|
/home/cpanrun/depot/main/contrib-patched/perl/CPAN/src/File-FcntlLock/blib/lib/File/FcntlLock.pm |
File::FcntlLock - File locking with fcntl(2)
use File::FcntlLock;
my $fs = new Fcntl::FcntlLock; $fs->l_type( F_RDLCK ); $fs->l_whence( SEEK_CUR ); $fs->l_start( 100 ); $fs->l_len( 123 );
my $fh;
open $fh, "<file_name" or die "Can't open file: $!\n";
$fs->lock( $fh, F_SETLK ) )
or print "Locking failed: " . $fs->error . "\n";
$fs->l_type( F_UNLCK );
$fs->lock( $fh, F_SETLK )
or print "Unlocking failed: " . $fs->error . "\n";
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 members of the flock structure, e.g.
$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()F_RDLCK, F_WRLCK or F_UNLCK (for read lock,
write lock or unlock).
l_whence()l_whence member of the flock structure,
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()l_whence member.
See also the man page for lseek(2).
l_len()l_start)
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()lock() with F_GETLK that
indicated that another process is holding the lock.
When not initialized the flock structure member l_type 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, i.e.
$fs->lock( $fh, F_SETLK );
There are three values that can be used as the second argument:
F_GETLKF_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,
with the l_pid member set to the PID of the process holding the
lock.
F_SETLKF_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 proces 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_SETLKWF_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()lock(). If the
last call did not result in an error the method returns undef.
error()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()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.
F_GETLK F_SETLK F_SETLKW F_RDLCK F_WRLCK F_UNLCK SEEK_SET SEEK_CUR SEEK_END
Thanks to Mark-Jason Dominus (MJD) and Benjamin Goldberg (GOLDBB) for helpful discussions, code examples and encouragement.
Jens Thoms Toerring <jt@toerring.de>
perl(1), fcntl(2), lseek(2).
|
/home/cpanrun/depot/main/contrib-patched/perl/CPAN/src/File-FcntlLock/blib/lib/File/FcntlLock.pm |