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 environ-
     ment  described on the lfcompile64(5) manual page. The func-
     tion 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.

  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
     definition  is  equivalent to the 64-bit file offset defini-

     struct aiocb                  struct aiocb64
        off_t aio_offset;             off64_t aio_offset;

     struct dirent                 struct dirent64
        ino_t d_ino;                  ino64_t d_ino;
        off_t d_off;                  off64_t d_off;

     struct flock                  struct flock64
        off_t l_start;                off64_t l_start;
        off_t l_len;                  off64_t l_len;
     F_SETLK                       F_SETLK64
     F_SETLKW                      F_SETLKW64
     F_GETLK                       F_GETLK64
     F_FREESP                      F_FREESP64

     fpos_t                        fpos64_t

     rlim_t                        rlim64_t
     struct rlimit                 struct rlimit64
        rlim_t rlim_cur;              rlim64_t rlim_cur;
        rlim_t rlim_max;              rlim64_t rlim_max;
     RLIM_INFINITY                 RLIM64_INFINITY
     RLIM_SAVED_MAX                RLIM64_SAVED_MAX
     RLIM_SAVED_CUR                RLIM64_SAVED_CUR

     struct stat                   struct 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;

     struct statvfs                struct statvfs64
        fsblkcnt_t f_blocks;          fsblkcnt64_t f_blocks;
        fsblkcnt_t f_bfree;           fsblkcnt64_t f_bfree;
        fsblkcnt_t f_bavial;          fsblkcnt64_t f_bavial;
        fsfilcnt_t  f_files;          fsfilcnt64_t  f_files;
        fsfilcnt_t  f_ffree;          fsfilcnt64_t  f_ffree;
        fsfilcnt_t  f_favail;         fsfilcnt64_t  f_favail;

     off_t;                        off64_t;
     ino_t;                        ino64_t;
     blkcnt_t;                     blkcnt64_t;
     fsblkcnt_t;                   fsblkcnt64_t;
     fsfilcnt_t;                   fsfilcnt64_t;



  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

     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_write(struct aiocb *);    int aio_write64(struct aiocb64 *);
     int lio_listio(...,               int lio_listio64(...,
        const struct aiocb *, ...);       const struct aiocb64 *, ...);

     struct dirent *readdir();     struct    dirent64    *read-
     struct dirent *readdir_r();   struct              dirent64

     int attropen();               int attropen64();
     int creat();                  int creat64();
     int open();                   int open64();
     int openat();                 int openat64();

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

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

     int fgetpos();                int fgetpos64();
     FILE *fopen();                FILE *fopen64();
     FILE *freopen();              FILE *freopen64();
     int fseeko(...,               int fseeko64(...,
       off_t, ...);                  off64_t, ...);
   int fsetpos(...,              int fsetpos64(...,
     const fpos_t *);              const fpos64_t *);

  off_t ftello();               off64_t ftello64();
  FILE *tmpfile();              FILE *tmpfile64();

     int mkstemp();                int mkstemp64();

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

     int alphasort(                int alphasort64(
        struct direct **,             struct direct64 **,
        struct direct **);            struct direct64 **);
     struct direct *readdir()      struct   direct64    *read-
    int scandir(...,              int scandir64(...,
      struct direct *(*[]);,        struct direct64 *(*[]);,
     ...);                         ...);

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

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

     int getrlimit(...,            int getrlimit64(...,
       struct rlimit *);             struct rlimit64 *);
    int setrlimit(...,            int setrlimit64(...,
      const struct rlimit *);       const struct rlimit64 *);

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

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

     int lockf(..., off_t);        int lockf64(...,
    off_t lseek(..., off_t,       off64_t lseek64(...,
      ...);                         off64_t, ...);
  int ftruncate(..., off_t);    int ftruncate64(...,
 ssize_t pread(..., off_t);    ssize_t pread64(...,

ssize_t pwrite(..., off_t); ssize_t pwrite64(...,


int truncate(..., off_t); int truncate64(...,



     lfcompile(5), lfcompile64(5)

Man(1) output converted with man2html