File::FcntlLock man page on ElementaryOS

Man page or keyword search:  
man Server   4994 pages
apropos Keyword Search (all sections)
Output format
ElementaryOS logo
[printable version]

File::FcntlLock(3pm)  User Contributed Perl Documentation File::FcntlLock(3pm)

       File::FcntlLock - File locking with fcntl(2)

	 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: $!\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 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.

	   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).

	   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).

	   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).

	   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.

	   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:

	   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.

	   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).

	   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:

	   Returns the error number from the latest call of "lock()". If the
	   last call did not result in an error the method returns "undef".

	   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".

	   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


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

       Jens Thoms Toerring <>

       perl(1), fcntl(2), lseek(2).

perl v5.18.1			  2011-10-29		  File::FcntlLock(3pm)

List of man pages available for ElementaryOS

Copyright (c) for man pages and the logo by the respective OS vendor.

For those who want to learn more, the polarhome community provides shell access and support.

[legal] [privacy] [GNU] [policy] [cookies] [netiquette] [sponsors] [FAQ]
Polarhome, production since 1999.
Member of Polarhome portal.
Based on Fawad Halim's script.
Vote for polarhome
Free Shell Accounts :: the biggest list on the net