te
Copyright (c) 2008, Sun Microsystems, Inc. All Rights Reserved.
The contents of this file are subject to the terms of the Common Development and Distribution License (the "License"). You may not use this file except in compliance with the License.
You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE or http://www.opensolaris.org/os/licensing. See the License for the specific language governing permissions and limitations under the License.
When distributing Covered Code, include this CDDL HEADER in each file and include the License file at usr/src/OPENSOLARIS.LICENSE. If applicable, add the following below this CDDL HEADER, with the fields enclosed by brackets "[]" replaced with your own identifying information: Portions Copyright [yyyy] [name of copyright owner]
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(5) 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.

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\(emhand 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;

F_SETLK F_SETLK64

F_SETLKW F_SETLKW64

F_GETLK F_GETLK64

F_FREESP F_FREESP64

F_ALLOCSP F_ALLOCSP64

O_LARGEFILE

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;

_LFS64_LARGEFILE

_LFS64_STDIO

_CS_LFS64_CFLAGS

_CS_LFS64_LDFLAGS

_CS_LFS64_LIBS

_CS_LFS64_LINTFLAGS

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);

lfcompile(5), lfcompile64(5)