Go to main content

man pages section 7: Standards, Environments, Macros, Character Sets, and Miscellany

Exit Print View

Updated: Wednesday, January 24, 2018



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

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;
struct rlimit
struct rlimit64
rlim_t rlim_cur;
rlim64_t rlim_cur;
rlim_t rlim_max;
rlim64_t rlim_max;
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_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;

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.

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 *, ...);
int alphasort(
int alphasort64(
const struct dirent **,
const struct dirent64 **,
const struct dirent **)
const struct dirent64 **)
struct dirent *readdir();
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 **))
int attropen();
int attropen64();
int creat();
int creat64();
int open();
int open64();
int openat();
int openat64();
int posix_fadvise()
int posix_fadvise64()
int posix_fallocate()
int posix_fallocate64()
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(..., off64_t);
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();
int mkstemp();
int mkstemp64();
int aioread(..., off_t, ...);
int aioread64(..., off64_t, ...);
int aiowrite(..., off_t, ...);
int aiowrite64(..., off64_t, ...);
int getdents(..., dirent);
int getdents64(..., dirent64);
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 *);
ssize_t sendfile(...,
ssize_t sendfile64(...,
off_t *, ...);
off64_t *, ...);
ssize_t sendfilev(..., const
ssize_t sendfilev64(..., const
struct sendfilevec *, ...);
struct sendfilevec64 *, ...);
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 *);
int statvfs(...,
int statvfs64(...,
struct statvfs *);
struct statvfs64 *);
int fstatvfs(...,
int fstatvfs64(...,
struct statvfs *);
struct statvfs64 *);
FILE *fopen()
FILE *fopen64()
FILE *freopen()
FILE *freopen64()
int alphasort(
int alphasort64(
struct direct **,
struct direct64 **,
struct direct **);
struct direct64 **);
struct direct *readdir();
struct direct64 *readdir64();
int scandir(...,
int scandir64(...,
struct direct *(*[]);, ...);
struct direct64 *(*[]);, ...);
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)