lf64(7) 맨 페이지 - 윈디하나의 솔라나라


맨 페이지 이름


Standards, Environments, Macros, Character Sets, and miscellany

       lf64 - transitional interfaces for 64-bit file offsets

       The  data  types, interfaces, and macros described on this page provide
       explicit access to 64-bit file offsets. They are accessible through the
       transitional  compilation  environment  described on the lfcompile64(7)
       manual page. The function prototype and  semantics  of  a  transitional
       interface  are equivalent to those of the standard version of the call,
       except that relevant data types are 64-bit entities. However, there  is
       one exception concerning the behavior of getrlimit64 when called from a
       32-bit process. When getrlimit64 is called from a  32-bit  process,  it
       returns  a  real  limit  value  when the limit value is greater than or
       equal to 32-bit model maximum and less than 64-bit  model  maximum.  On
       the  other  hand,  the  standard  getrlimit(2) returns a limit value as
       RLIM_INFINITY for limit values that fall in this range.

   Data Types
       The following tables list the standard data  or  struct  types  in  the
       left-hand  column  and  their corresponding explicit 64-bit file offset
       types in the right-hand column, grouped by header. The  absence  of  an
       entry  in  the  left-hand  column  indicates  that there is no existing
       explicit 32-bit type that corresponds to the 64-bit type listed in  the
       right—hand column. Note that in a 64-bit application, the standard def‐
       inition is equivalent to the 64-bit file offset definition.

       tab(); lw(2.75i) lw(2.75i) struct aiocbstruct aiocb64
         off_t aio_offset;  off64_t aio_offset;

       tab(); lw(2.75i) lw(2.75i) struct direntstruct dirent64
         ino_t d_ino;  ino64_t d_ino;
         off_t d_off;  off64_t d_off;

       tab(); lw(2.75i) lw(2.75i) struct flockstruct flock64
         off_t l_start;  off64_t l_start;
         off_t  l_len;   off64_t  l_len;  F_SETLKF_SETLK64  F_SETLKWF_SETLKW64

       tab(); lw(2.75i) lw(2.75i) fpos_tfpos64_t

       tab(); lw(2.75i) lw(2.75i) rlim_trlim64_t struct rlimitstruct rlimit64
         rlim_t rlim_cur;  rlim64_t rlim_cur;
         rlim_t  rlim_max;   rlim64_t  rlim_max;  RLIM_INFINITYRLIM64_INFINITY

       tab(); lw(2.75i) lw(2.75i) struct statstruct stat64
         ino_t st_ino;  ino64_t st_ino;
         off_t st_size;  off64_t st_size;
         blkcnt_t st_blocks;  blkcnt64_t st_blocks;

       tab(); lw(2.75i) lw(2.75i) struct statvfsstruct statvfs64
         fsblkcnt_t f_blocks;  fsblkcnt64_t f_blocks;
         fsblkcnt_t f_bfree;  fsblkcnt64_t f_bfree;
         fsblkcnt_t f_bavail;  fsblkcnt64_t f_bavail;
         fsfilcnt_t f_files;  fsfilcnt64_t f_files;
         fsfilcnt_t f_ffree;  fsfilcnt64_t f_ffree;
         fsfilcnt_t f_favail;  fsfilcnt64_t f_favail;

       tab();    lw(2.75i)     lw(2.75i)     off_t;off64_t;     ino_t;ino64_t;
       blkcnt_t;blkcnt64_t; fsblkcnt_t;fsblkcnt64_t; fsfilcnt_t;fsfilcnt64_t;

       tab(); lw(2.75i) lw(2.75i) _LFS64_LARGEFILE _LFS64_STDIO

       tab();    lw(2.75i)    lw(2.75i)   _CS_LFS64_CFLAGS   _CS_LFS64_LDFLAGS

   System Interfaces
       The following tables display the standard  API  and  the  corresponding
       transitional  interfaces  for  64-bit  file offsets. The interfaces are
       grouped by header. The interface name and the affected data  types  are
       displayed in courier font.

       tab(); lw(2.75i) lw(2.75i) int aio_cancel(..., int aio_cancel64(...,
        struct aiocb *); struct aiocb64 *); int aio_error(int aio_error64(
        const struct aiocb *); const struct aiocb64 *); int aio_fsync(..., int
        struct aiocb *); struct aiocb64 *); int aio_read(struct aiocb *);  int
       aio_read64(struct  aiocb64  *);  int  aio_return(struct  aiocb  *); int
       aio_return64(struct aiocb64 *); int aio_suspend(int aio_suspend64(
        const struct  aiocb  *,  ...);  const  struct  aiocb64  *,  ...);  int
       aio_waitn(aiocb_t *[],int aio_waitn64(aiocb64_t *[],
        ...);  ...);  int  aio_write(struct  aiocb  *); int aio_write64(struct
       aiocb64 *); int lio_listio(..., int lio_listio64(...,
        const struct aiocb *, ...); const struct aiocb64 *, ...);

       tab(); lw(2.74i) lw(2.76i) int alphasort(int alphasort64(
        const struct dirent **,  const struct dirent64 **,
        const struct dirent **) const struct dirent64 **) struct dirent *read‐
       dir();struct  dirent64  *readdir64(); struct dirent *readdir_r();struct
       dirent64 *readdir64_r(); int scandir(..., int scandir64(...,
        struct dirent *(*[]),  struct dirent64 *(*[]),
        int (*)(const struct dirent *), int (*)(const struct dirent64 *),
        int (*)(const struct dirent **, int (*)(const struct dirent64 **,
        const struct dirent **)) const struct dirent64 **))

       tab();  lw(2.75i)  lw(2.75i)  int  attropen();int   attropen64();   int
       creat();int  creat64();  int open();int open64(); int openat();int ope‐
       nat64();  int  posix_fadvise()int  posix_fadvise64()  int  posix_fallo‐
       cate()int posix_fallocate64()

       tab(); lw(2.75i) lw(2.75i) int ftw(...,int ftw64(...,
        const struct stat *, ...); const struct stat64 *, ...);

       int nftw(..int nftw64(...,
        const struct stat *, ...); const struct stat64 *, ...);

       tab();  lw(2.75i)  lw(2.75i)  char  *copylist(...,  off_t);char  *copy‐
       list64(..., off64_t);

       tab();  lw(2.75i)  lw(2.75i)  int   fgetpos();int   fgetpos64();   FILE
       *fopen();FILE   *fopen64();   FILE  *freopen();FILE  *freopen64();  int
       fseeko(..., off_t, ...);int  fseeko64(...,  off64_t,  ...);  int  fset‐
       pos(...,int fsetpos64(...,
        const   fpos_t   *);   const   fpos64_t   *);  off_t  ftello();off64_t
       ftello64()(); FILE *tmpfile();FILE *tmpfile64();

       tab();  lw(2.75i)  lw(2.75i)   int   mkstemp();int   mkstemp64();   int
       mkstemps();int   mkstemps64();  int  mkostemp();int  mkostemp64();  int
       mkostemps();int mkostemps64();

       tab();   lw(2.75i)   lw(2.75i)   int   aioread(...,   off_t,   ...);int
       aioread64(...,   off64_t,   ...);  int  aiowrite(...,  off_t,  ...);int
       aiowrite64(..., off64_t, ...);

       tab();  lw(2.75i)  lw(2.75i)   int   getdents(...,   dirent);int   get‐
       dents64(..., dirent64);

       tab();  lw(2.75i)  lw(2.75i)  void  mmap(...,  off_t);void  mmap64(...,

       tab(); lw(2.75i) lw(2.75i) int getrlimit(...,int getrlimit64(...,
        struct rlimit *); struct  rlimit64  *);  int  setrlimit(...,int  setr‐
        const struct rlimit *); const struct rlimit64 *);

       tab();   lw(2.75i)   lw(2.75i)   ssize_t  sendfile(...,  ssize_t  send‐
         off_t *, ...);  off64_t *, ...); ssize_t sendfilev(..., const ssize_t
       sendfilev64(..., const
        struct sendfilevec *, ...); struct sendfilevec64 *, ...);

       tab();   lw(2.75i)   lw(2.75i)  int  fstat(...,  struct  stat  *);  int
       fstat64(..., struct stat64 *); int fstatat(..., int fstatat64(...,
        struct stat *, int); struct stat64 *, int); int lstat(..., struct stat
       *);  int  lstat64(...,  struct stat64 *); int stat(..., struct stat *);
       int stat64(..., struct stat64 *);

       tab(); lw(2.75i) lw(2.75i) int statvfs(...,int statvfs64(...,
        struct  statvfs  *);  struct  statvfs64  *);  int  fstatvfs(...,   int
        struct statvfs *); struct statvfs64 *);

       tab();  lw(2.75i)  lw(2.75i)  int  lockf(...,  off_t);int  lockf64(...,
       off64_t); off_t lseek(..., off_t,  ...);off64_t  lseek64(...,  off64_t,
       ...);  int  ftruncate(..., off_t);int ftruncate64..., off64_t); ssize_t
       pread(..., off_t);ssize_t  pread64...,  off64_t);  ssize_t  pwrite(...,
       off_t);ssize_t  pwrite64(...,  off64_t);  int  truncate(..., off_t);int
       truncate64(..., off64_t);

       lfcompile(7), lfcompile64(7)

Oracle Solaris 11.4               5 Aug 2019                           lf64(7)
맨 페이지 내용의 저작권은 맨 페이지 작성자에게 있습니다.