Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help
lf64(5)		      Standards, Environments, and Macros	       lf64(5)

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(5)
       manual page. The	function prototype and semantics of a transitional in-
       terface	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 ex-
       plicit 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.

   <aio.h>
       struct aiocb		     struct aiocb64
	  off_t	aio_offset;		off64_t	aio_offset;

   <sys/dirent.h>
       struct dirent		     struct dirent64
	  ino_t	d_ino;			ino64_t	d_ino;
	  off_t	d_off;			off64_t	d_off;

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

   <sys/stdio.h>
       fpos_t			     fpos64_t

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

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

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

   <sys/types.h>
       off_t;			     off64_t;
       ino_t;			     ino64_t;
       blkcnt_t;		     blkcnt64_t;
       fsblkcnt_t;		     fsblkcnt64_t;
       fsfilcnt_t;		     fsfilcnt64_t;

   <unistd.h>
				     _LFS64_LARGEFILE
				     _LFS64_STDIO

   <sys/unistd.h>
				     _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>
       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 *, ...);

   <dirent.h>
       struct dirent *readdir();     struct    dirent64	   *read-
				     dir64();
       struct dirent *readdir_r();   struct    dirent64	   *read-
				     dir64_r();

   <fcntl.h>
       int attropen();		     int attropen64();
       int creat();		     int creat64();
       int open();		     int open64();
       int openat();		     int openat64();

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

   <libgen.h>
       char *copylist(..., off_t);   char *copylist64(...,
					off64_t);

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

   <stdlib.h>
       int mkstemp();		     int mkstemp64();

   <sys/async.h>
       int aioread(...,	off_t,	     int aioread64(...,	off64_t,
	  ...);				...);
       int aiowrite(..., off_t,	     int aiowrite64(...,
	  ...);				off64_t, ...);

   <ucbinclude/sys/dir.h>
       int alphasort(		     int alphasort64(
	  struct direct	**,		struct direct64	**,
	  struct direct	**);		struct direct64	**);
       struct direct *readdir()	     struct    direct64	  *read-
				     dir64();
       int scandir(...,		     int scandir64(...,
	  struct direct	*(*[]);,	struct direct64	*(*[]);,
	  ...);				...);

   <sys/dirent.h>
       int getdents(..., dirent);    int getdents64(...,
					dirent64);

   <sys/mman.h>
       void mmap(..., off_t);	     void mmap64(..., off64_t);

   <sys/resource.h>
       int getrlimit(...,	     int getrlimit64(...,
	  struct rlimit	*);		struct rlimit64	*);
       int setrlimit(...,	     int setrlimit64(...,
	  const	struct rlimit *);	const struct rlimit64 *);

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

   <sys/statvfs.h>
       int statvfs(...,		     int statvfs64(...,
	  struct statvfs *);		struct statvfs64 *);
       int fstatvfs(...,	     int fstatvfs64(...,
	  struct statvfs *);		struct statvfs64 *);

   <unistd.h>
       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(5), lfcompile64(5)

SunOS 5.9			  1 Aug	2001			       lf64(5)

NAME | DESCRIPTION | SEE ALSO

Want to link to this manual page? Use this URL:
<https://www.freebsd.org/cgi/man.cgi?query=lf64&sektion=5&manpath=SunOS+5.9>

home | help