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

개요

섹션
맨 페이지 이름
검색(S)

lf64(7)

Standards, Environments, Macros, Character Sets, and miscellany
                                                                       lf64(7)



NAME
       lf64 - transitional interfaces for 64-bit file offsets

DESCRIPTION
       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.

   <aio.h>
       tab(); lw(2.75i) lw(2.75i)


       struct aiocbstruct aiocb64
         off_t aio_offset;  off64_t aio_offset;


   <sys/dirent.h>
       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;


   <sys/fcntl.h>
       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
       F_GETLKF_GETLK64 F_FREESPF_FREESP64 F_ALLOCSPF_ALLOCSP64 O_LARGEFILE


   <sys/stdio.h>
       tab(); lw(2.75i) lw(2.75i)


       fpos_tfpos64_t


   <sys/resource.h>
       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
       RLIM_SAVED_MAXRLIM64_SAVED_MAX RLIM_SAVED_CURRLIM64_SAVED_CUR


   <sys/stat.h>
       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;


   <sys/statvfs.h>
       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;


   <sys/types.h>
       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;


   <unistd.h>
       tab(); lw(2.75i) lw(2.75i)


       _LFS64_LARGEFILE _LFS64_STDIO


   <sys/unistd.h>
       tab(); lw(2.75i) lw(2.75i)


       _CS_LFS64_CFLAGS _CS_LFS64_LDFLAGS _CS_LFS64_LIBS _CS_LFS64_LINTFLAGS


   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.

   <aio.h>
       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
       aio_fsync64(...,
        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 *, ...);


   <dirent.h>
       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 **))


   <fcntl.h>
       tab(); lw(2.75i) lw(2.75i)


       int   attropen();int   attropen64();  int  creat();int  creat64();  int
       open();int  open64();  int  openat();int  openat64();  int   posix_fad‐
       vise()int   posix_fadvise64()   int  posix_fallocate()int  posix_fallo‐
       cate64()


   <ftw.h>
       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 *, ...);



   <libgen.h>
       tab(); lw(2.75i) lw(2.75i)


       char *copylist(..., off_t);char *copylist64(..., off64_t);


   <stdio.h>
       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 fsetpos(...,int fsetpos64(...,
        const  fpos_t  *);   const   fpos64_t   *);   off_t   ftello();off64_t
       ftello64()(); FILE *tmpfile();FILE *tmpfile64();


   <stdlib.h>
       tab(); lw(2.75i) lw(2.75i)


       int mkstemp();int mkstemp64();


   <sys/async.h>
       tab(); lw(2.75i) lw(2.75i)


       int  aioread(...,  off_t,  ...);int  aioread64(...,  off64_t, ...); int
       aiowrite(..., off_t, ...);int aiowrite64(..., off64_t, ...);


   <sys/dirent.h>
       tab(); lw(2.75i) lw(2.75i)


       int getdents(..., dirent);int getdents64(..., dirent64);



   <sys/mman.h>
       tab(); lw(2.75i) lw(2.75i)


       void mmap(..., off_t);void mmap64(..., off64_t);


   <sys/resource.h>
       tab(); lw(2.75i) lw(2.75i)


       int getrlimit(...,int getrlimit64(...,
        struct rlimit *); struct  rlimit64  *);  int  setrlimit(...,int  setr‐
       limit64(...,
        const struct rlimit *); const struct rlimit64 *);


   <sys/sendfile.h>
       tab(); lw(2.75i) lw(2.75i)


       ssize_t sendfile(..., ssize_t sendfile64(...,
         off_t *, ...);  off64_t *, ...); ssize_t sendfilev(..., const ssize_t
       sendfilev64(..., const
        struct sendfilevec *, ...); struct sendfilevec64 *, ...);



   <sys/stat.h>
       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 *);


   <sys/statvfs.h>
       tab(); lw(2.75i) lw(2.75i)


       int statvfs(...,int statvfs64(...,
        struct   statvfs  *);  struct  statvfs64  *);  int  fstatvfs(...,  int
       fstatvfs64(...,
        struct statvfs *); struct statvfs64 *);


   <unistd.h>
       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);


SEE ALSO
       lfcompile(7), lfcompile64(7)



Oracle Solaris 11.4               9 Jul 2018                           lf64(7)
맨 페이지 내용의 저작권은 맨 페이지 작성자에게 있습니다.
RSS ATOM XHTML 5 CSS3