DIO_FCNTL(3) 1 DIO_FCNTL(3)dio_fcntl - Performs a c library fcntl on fdSYNOPSIS
mixed dio_fcntl (resource $fd, int $cmd, [mixed $args])
DESCRIPTION
The dio_fcntl(3) function performs the operation specified by $cmd on the file descriptor $fd. Some commands require additional arguments
$args to be supplied.
PARAMETERS
o $fd
- The file descriptor returned by dio_open(3).
o $cmd
- Can be one of the following operations:
o F_SETLK - Lock is set or cleared. If the lock is held by someone else dio_fcntl(3) returns -1.
o F_SETLKW - like F_SETLK, but in case the lock is held by someone else, dio_fcntl(3) waits until the lock is released.
o F_GETLK - dio_fcntl(3) returns an associative array (as described above) if someone else prevents lock. If there is no
obstruction key "type" will set to F_UNLCK.
o F_DUPFD - finds the lowest numbered available file descriptor greater than or equal to $args and returns them.
o F_SETFL - Sets the file descriptors flags to the value specified by $args, which can be O_APPEND, O_NONBLOCK or O_ASYNC. To
use O_ASYNC you will need to use the PCNTL extension.
o $args
-$args is an associative array, when $cmd is F_SETLK or F_SETLLW, with the following keys:
o start - offset where lock begins
o length - size of locked area. zero means to end of file
o whence - Where l_start is relative to: can be SEEK_SET, SEEK_END and SEEK_CUR
o type - type of lock: can be F_RDLCK (read lock), F_WRLCK (write lock) or F_UNLCK (unlock)
RETURN VALUES
Returns the result of the C call.
EXAMPLES
Example #1
Setting and clearing a lock
<?php
$fd = dio_open('/dev/ttyS0', O_RDWR);
if (dio_fcntl($fd, F_SETLK, Array("type"=>F_WRLCK)) == -1) {
// the file descriptor appears locked
echo "The lock can not be cleared. It is held by someone else.";
} else {
echo "Lock successfully set/cleared";
}
dio_close($fd);
?>
NOTES
Note
This function is not implemented on Windows platforms.
PHP Documentation Group DIO_FCNTL(3)
Check Out this Related Man Page
File::FcntlLock(3pm) User Contributed Perl Documentation File::FcntlLock(3pm)NAME
File::FcntlLock - File locking with fcntl(2)SYNOPSIS
use File::FcntlLock;
my $fs = new File::FcntlLock;
$fs->l_type( F_RDLCK );
$fs->l_whence( SEEK_CUR );
$fs->l_start( 100 );
$fs->l_len( 123 );
open my $fh, '<', 'file_name' or die "Can't open file: $!
";
$fs->lock( $fh, F_SETLK )
or print "Locking failed: " . $fs->error . "
";
$fs->l_type( F_UNLCK );
$fs->lock( $fh, F_SETLK )
or print "Unlocking failed: " . $fs->error . "
";
DESCRIPTION
File locking in Perl is usually done using the flock() function. Unfortunately, this only allows locks on whole files and is often
implemented in terms of flock(2), which has some shortcomings.
Using this module file locking via fcntl(2) can be done (obviously, this restricts the use of the module to systems that have a fcntl(2)
system call). Before a file (or parts of a file) can be locked, an object simulating a flock structure must be created and its properties
set. Afterwards, by calling the "lock()" method a lock can be set or it can be determined if and which process currently holds the lock.
To create a new object representing a flock structure call "new()":
$fs = new File::FcntlLock;
You also can pass the "new()" method a set of key-value pairs to initialize the objects properties, e.g. use
$fs = new File::FcntlLock l_type => F_WRLCK,
l_whence => SEEK_SET,
l_start => 0,
l_len => 100;
if you plan to obtain a write lock for the first 100 bytes of a file.
Once you have created the object simulating the flock structure the following methods allow to query and in most cases also to modify the
properties of the object.
"l_type()"
If called without an argument returns the current setting of the lock type, otherwise the lock type is set to the argument, which must
be either "F_RDLCK", "F_WRLCK" or "F_UNLCK" (for read lock, write lock or unlock).
"l_whence()"
Queries or sets the "l_whence" property of the flock object, determining if the "l_start" value is relative to the start of the file,
to the current position in the file or to the end of the file. The corresponding values are "SEEK_SET", "SEEK_CUR" and "SEEK_END". See
also the man page for lseek(2).
"l_start()"
Queries or sets the start position (offset) of the lock in the file according to the mode selected by the "l_whence" member. See also
the man page for lseek(2).
"l_len()"
Queries or sets the length of the region (in bytes) in the file to be locked. A value of 0 is interpreted as to mean a lock (starting
at "l_start") up to the very end of the file.
According to SUSv3 negative values for "l_start" are allowed (resulting in a lock ranging from "l_start + l_len" to "l_start - 1")
Unfortunately, not all systems allow negative arguments and will return an error when you try to obtain the lock, so please read the
fcntl(2) man page of your system carefully for details.
"l_pid()"
This method allows retrieving the PID of a process currently holding the lock after a call of "lock()" with "F_SETLK" indicated that
another process is holding the lock. A call to "lock()" with "F_GETLK" will fill in this value so "l_pid()" can be called.
When not initialized the flock objects "l_type" property is set to "F_RDLCK" by default, "l_whence" to "SEEK_SET", and both "l_start" and
"l_len" to 0, i.e. the settings for a read lock on the whole file.
After having set up the object representing a flock structure you can determine the current holder of a lock or try to obtain a lock by
invoking the "lock()" method with two arguments, a file handle (or a file descriptor, the module figures out automatically what it got) and
a flag indicating the action to be taken, e.g.
$fs->lock( $fh, F_SETLK );
There are three values that can be used as the second argument:
"F_GETLK"
For "F_GETLK" the "lock()" method determines if and who currently is holding the lock. If no other process is holding the lock the
"l_type" field is set to "F_UNLCK". Otherwise the flock structure object is set to the values that prevent us from obtaining a lock.
There may be multiple such blocking processes, including some that are themselves blocked waiting to obtain a lock. "F_GETLK" will only
make details of one of these visible, and one has no control over which process this is.
"F_SETLK"
For "F_SETLK" the "lock()" method tries to obtain the lock (when "l_type" is set to either "F_WRLCK" or "F_RDLCK") or releases the lock
(if "l_type" is set to "F_UNLCK"). If a lock is held by some other process the method call returns "undef" and errno is set to
"EACCESS" or "EAGAIN" (please see the the man page for fcntl(2) for the details).
"F_SETLKW"
is similar to "F_SETLK" but instead of returning an error if the lock can't be obtained immediately it blocks until the lock is
obtained. If a signal is received while waiting for the lock the method returns "undef" and errno is set to "EINTR".
On success the method returns the string "0 but true". If the method fails (as indicated by an "undef" return value) you can either
immediately evaluate the error number (usingf $!, $ERRNO or $OS_ERROR) or check for it at some later time via the methods discussed below.
There are three methods for obtaining information about the reason the the last call of "lock()" for the object failed:
"lock_errno()"
Returns the error number from the latest call of "lock()". If the last call did not result in an error the method returns "undef".
"error()"
Returns a short description of the error that happened during the latest call of "lock()" with the object. Please take the messages
with a grain of salt, they represent what SUSv3 (IEEE 1003.1-2001) and the Linux, TRUE64, OpenBSD3 and Solaris8 man pages tell what the
error numbers mean, there could be differences (and additional error numbers) on other systems. If there was no error the method
returns "undef".
"system_error()"
While the previous method, "error()", tries to return a string with some relevance to the locking operation (i.e. "File or segment
already locked by other process(es)" instead of "Permission denied") this method returns the "normal" system error message associated
with errno. The method returns "undef" if there was no error.
EXPORT
F_GETLK F_SETLK F_SETLKW F_RDLCK F_WRLCK F_UNLCK SEEK_SET SEEK_CUR SEEK_END
CREDITS
Thanks to Mark Jason Dominus (MJD) and Benjamin Goldberg (GOLDBB) for helpful discussions, code examples and encouragement. Glenn Herteg
pointed out several problems and also helped improve the documentation. Julian Moreno Patino also helped correcting the documentation and
pointed out problems arising on GNU Hurd (which seems to have only very rudimentary support for locking with fcntl()).
AUTHOR
Jens Thoms Toerring <jt@toerring.de>
SEE ALSO perl(1), fcntl(2), lseek(2).
perl v5.14.2 2011-10-29 File::FcntlLock(3pm)