👤
Home Man
Search
Today's Posts
Register

Linux & Unix Commands - Search Man Pages
Man Page or Keyword Search:
Select Section of Man Page:
Select Man Page Repository:

OpenSolaris 2009.06 - man page for lf64 (opensolaris section 5)

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 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 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
       F_ALLOCSP		     F_ALLOCSP64
				     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   inter-
       faces  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_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>
       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 **))

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

   <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(..., 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>
       int mkstemp();		     int mkstemp64();

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

   <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/sendfile.h>
       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>
       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>
       int statvfs(..., 	     int statvfs64(...,
	  struct statvfs *);		struct statvfs64 *);
       int fstatvfs(...,	     int fstatvfs64(...,
	  struct statvfs *);	       struct statvfs64 *);

   <ucbinclude/stdio.h>
       FILE *fopen()		     FILE *fopen64()
       FILE *freopen()		     FILE *freopen64()

   <ucbinclude/sys/dir.h>
       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 *(*[]);,  ...);

   <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.11				   14 Jul 2008					  lf64(5)


All times are GMT -4. The time now is 11:00 PM.

Unix & Linux Forums Content Copyrightę1993-2018. All Rights Reserved.
×
UNIX.COM Login
Username:
Password:  
Show Password





Not a Forum Member?
Forgot Password?