mirror of https://github.com/red-prig/fpPS4.git
204 lines
6.4 KiB
Plaintext
204 lines
6.4 KiB
Plaintext
unit vfcntl;
|
|
|
|
{$mode ObjFPC}{$H+}
|
|
{$CALLING SysV_ABI_CDecl}
|
|
|
|
interface
|
|
|
|
const
|
|
{
|
|
* File status flags: these are used by open(2), fcntl(2).
|
|
* They are also used (indirectly) in the kernel file structure f_flags,
|
|
* which is a superset of the open/fcntl flags. Open flags and f_flags
|
|
* are inter-convertible using OFLAGS(fflags) and FFLAGS(oflags).
|
|
* Open/fcntl flags begin with O_; kernel-internal flags begin with F.
|
|
}
|
|
{ open-only flags }
|
|
O_RDONLY =$0000; { open for reading only }
|
|
O_WRONLY =$0001; { open for writing only }
|
|
O_RDWR =$0002; { open for reading and writing }
|
|
O_ACCMODE=$0003; { mask for above modes }
|
|
|
|
{
|
|
* Kernel encoding of open mode; separate read and write bits that are
|
|
* independently testable: 1 greater than the above.
|
|
*
|
|
* XXX
|
|
* FREAD and FWRITE are excluded from the #ifdef _KERNEL so that TIOCFLUSH,
|
|
* which was documented to use FREAD/FWRITE, continues to work.
|
|
}
|
|
FREAD =$0001;
|
|
FWRITE =$0002;
|
|
|
|
O_NONBLOCK=$0004; { no delay }
|
|
O_APPEND =$0008; { set append mode }
|
|
|
|
O_SHLOCK=$0010; { open with shared file lock }
|
|
O_EXLOCK=$0020; { open with exclusive file lock }
|
|
O_ASYNC =$0040; { signal pgrp when data ready }
|
|
O_FSYNC =$0080; { synchronous writes }
|
|
|
|
O_SYNC =$0080; { POSIX synonym for O_FSYNC }
|
|
O_NOFOLLOW=$0100; { don't follow symlinks }
|
|
O_CREAT =$0200; { create if nonexistent }
|
|
O_TRUNC =$0400; { truncate to zero length }
|
|
O_EXCL =$0800; { error if already exists }
|
|
O_DSYNC =$1000; { synchronous data writes(omit inode writes) }
|
|
FHASLOCK =$4000; { descriptor holds advisory lock }
|
|
|
|
{ Defined by POSIX 1003.1; BSD default, but must be distinct from O_RDONLY. }
|
|
O_NOCTTY=$8000; { don't assign controlling terminal }
|
|
|
|
{ Attempt to bypass buffer cache }
|
|
O_DIRECT=$00010000;
|
|
|
|
{ Defined by POSIX Extended API Set Part 2 }
|
|
O_DIRECTORY=$00020000; { Fail if not directory }
|
|
O_EXEC =$00040000; { Open for execute only }
|
|
|
|
FEXEC=O_EXEC;
|
|
|
|
O_TTY_INIT=$00080000; { Restore default termios attributes }
|
|
O_CLOEXEC =$00100000;
|
|
|
|
{
|
|
* The O_* flags used to have only F* names, which were used in the kernel
|
|
* and by fcntl. We retain the F* names for the kernel f_flag field
|
|
* and for backward compatibility for fcntl. These flags are deprecated.
|
|
}
|
|
FAPPEND =O_APPEND; { kernel/compat }
|
|
FASYNC =O_ASYNC; { kernel/compat }
|
|
FFSYNC =O_FSYNC; { kernel }
|
|
FDSYNC =O_DSYNC; { kernel }
|
|
FNONBLOCK=O_NONBLOCK; { kernel }
|
|
FNDELAY =O_NONBLOCK; { compat }
|
|
O_NDELAY =O_NONBLOCK; { compat }
|
|
|
|
FRDAHEAD =O_CREAT;
|
|
|
|
{ bits to save after open }
|
|
FMASK=(FREAD or FWRITE or FAPPEND or FASYNC or FFSYNC or FDSYNC or FNONBLOCK or O_DIRECT or FEXEC);
|
|
{ bits settable by fcntl(F_SETFL, ...) }
|
|
FCNTLFLAGS=(FAPPEND or FASYNC or FFSYNC or FDSYNC or FNONBLOCK or FRDAHEAD or O_DIRECT);
|
|
|
|
{ Defined by POSIX Extended API Set Part 2 }
|
|
{
|
|
* Magic value that specify the use of the current working directory
|
|
* to determine the target of relative file paths in the openat() and
|
|
* similar syscalls.
|
|
}
|
|
AT_FDCWD=-100;
|
|
|
|
{
|
|
* Miscellaneous flags for the *at() syscalls.
|
|
}
|
|
AT_EACCESS =$100; { Check access using effective user and group ID }
|
|
AT_SYMLINK_NOFOLLOW=$200; { Do not follow symbolic links }
|
|
AT_SYMLINK_FOLLOW =$400; { Follow symbolic link }
|
|
AT_REMOVEDIR =$800; { Remove directory instead of file }
|
|
|
|
{
|
|
* Constants used for fcntl(2)
|
|
}
|
|
{ command values }
|
|
F_DUPFD = 0; { duplicate file descriptor }
|
|
F_GETFD = 1; { get file descriptor flags }
|
|
F_SETFD = 2; { set file descriptor flags }
|
|
|
|
F_GETFL = 3; { get file status flags }
|
|
F_SETFL = 4; { set file status flags }
|
|
|
|
F_GETOWN = 5; { get SIGIO/SIGURG proc/pgrp }
|
|
F_SETOWN = 6; { set SIGIO/SIGURG proc/pgrp }
|
|
|
|
F_OGETLK = 7; { get record locking information }
|
|
F_OSETLK = 8; { set record locking information }
|
|
F_OSETLKW= 9; { F_SETLK; wait if blocked }
|
|
F_DUP2FD =10; { duplicate file descriptor to arg }
|
|
|
|
F_GETLK =11; { get record locking information }
|
|
F_SETLK =12; { set record locking information }
|
|
F_SETLKW =13; { F_SETLK; wait if blocked }
|
|
|
|
F_SETLK_REMOTE =14; { debugging support for remote locks }
|
|
F_READAHEAD =15; { read ahead }
|
|
F_RDAHEAD =16; { Darwin compatible read ahead }
|
|
F_DUPFD_CLOEXEC =17; { Like F_DUPFD, but FD_CLOEXEC is set }
|
|
F_DUP2FD_CLOEXEC=18; { Like F_DUP2FD, but FD_CLOEXEC is set }
|
|
|
|
{ file descriptor flags (F_GETFD, F_SETFD) }
|
|
FD_CLOEXEC=1; { close-on-exec flag }
|
|
|
|
{ record locking flags (F_GETLK, F_SETLK, F_SETLKW) }
|
|
F_RDLCK =1; { shared or read lock }
|
|
F_UNLCK =2; { unlock }
|
|
F_WRLCK =3; { exclusive or write lock }
|
|
F_UNLCKSYS=4; { purge locks for a given system ID }
|
|
F_CANCEL =5; { cancel an async lock request }
|
|
|
|
F_WAIT =$010; { Wait until lock is granted }
|
|
F_FLOCK =$020; { Use flock(2) semantics for lock }
|
|
F_POSIX =$040; { Use POSIX semantics for lock }
|
|
F_REMOTE=$080; { Lock owner is remote NFS client }
|
|
F_NOINTR=$100; { Ignore signals when waiting }
|
|
|
|
// lock operations for flock(2)
|
|
LOCK_SH =$01; // shared file lock
|
|
LOCK_EX =$02; // exclusive file lock
|
|
LOCK_NB =$04; // don't block when locking
|
|
LOCK_UN =$08; // unlock file
|
|
|
|
//Advice to posix_fadvise
|
|
POSIX_FADV_NORMAL =0; // no special treatment
|
|
POSIX_FADV_RANDOM =1; // expect random page references
|
|
POSIX_FADV_SEQUENTIAL=2; // expect sequential page references
|
|
POSIX_FADV_WILLNEED =3; // will need these pages
|
|
POSIX_FADV_DONTNEED =4; // dont need these pages
|
|
POSIX_FADV_NOREUSE =5; // access data only once
|
|
|
|
{
|
|
* Advisory file segment locking data type -
|
|
* information passed to system by user
|
|
}
|
|
type
|
|
p_flock=^t_flock;
|
|
t_flock=packed record
|
|
l_start :Int64 ; // starting offset
|
|
l_len :Int64 ; // len = 0 means until end of file
|
|
l_pid :DWORD ; // lock owner
|
|
l_type :WORD ; // lock type: read/write, etc.
|
|
l_whence:WORD ; // type of l_start
|
|
l_sysid :Integer; // remote system id or zero for local
|
|
end;
|
|
|
|
{
|
|
* Old advisory file segment locking data type,
|
|
* before adding l_sysid.
|
|
}
|
|
__oflock=packed record
|
|
l_start :Int64; // starting offset
|
|
l_len :Int64; // len = 0 means until end of file
|
|
l_pid :DWORD; // lock owner
|
|
l_type :WORD ; // lock type: read/write, etc.
|
|
l_whence:WORD ; // type of l_start
|
|
end;
|
|
|
|
{ convert from open() flags to/from fflags; convert O_RD/WR to FREAD/FWRITE }
|
|
function FFLAGS(oflags:Integer):Integer; inline;
|
|
function OFLAGS(fflags:Integer):Integer; inline;
|
|
|
|
implementation
|
|
|
|
function FFLAGS(oflags:Integer):Integer; inline;
|
|
begin
|
|
Result:=oflags+1;
|
|
end;
|
|
|
|
function OFLAGS(fflags:Integer):Integer; inline;
|
|
begin
|
|
Result:=fflags-1;
|
|
end;
|
|
|
|
end.
|
|
|