Toll Free Numbers
  • Last 5 Forum Topics
    Last post

The Web Only This Site



  • MARC

    Mailing list ARChives
    - Search by -


    Computing Dictionary

  • Text Link Ads
  • LINUX man pages
  • Linux Man Page Viewer

    The following form allows you to view linux man pages.





           #include <unistd.h>
           #include <fcntl.h>
           int fcntl(int fd, int cmd, ... /* arg */ );


           fcntl() performs one of the operations described below on the open file
           descriptor fd.  The operation is determined by cmd.
           fcntl() can take an optional third argument.  Whether or not this argu-
           ment  is  required is determined by cmd.  The required argument type is
           indicated in parentheses after  each  cmd  name  (in  most  cases,  the
           required type is int, and we identify the argument using the name arg),
           or void is specified if the argument is not required.
       Duplicating a file descriptor
           F_DUPFD (int)
                  Find the lowest numbered available file descriptor greater  than
                  or  equal to arg and make it be a copy of fd.  This is different
                  from dup2(2), which uses exactly the descriptor specified.
                  On success, the new descriptor is returned.
                  See dup(2) for further details.
           F_DUPFD_CLOEXEC (int; since Linux 2.6.24)
                  As for F_DUPFD, but additionally set the close-on-exec flag  for
                  the  duplicate  descriptor.  Specifying this flag permits a pro-
                  gram to avoid an additional fcntl() F_SETFD operation to set the
                  FD_CLOEXEC flag.  For an explanation of why this flag is useful,
                  see the description of O_CLOEXEC in open(2).
       File descriptor flags
           The following commands manipulate the  flags  associated  with  a  file
           descriptor.   Currently, only one such flag is defined: FD_CLOEXEC, the
           close-on-exec flag.  If the FD_CLOEXEC bit is 0,  the  file  descriptor
           will remain open across an execve(2), otherwise it will be closed.
           F_GETFD (void)
                  Read the file descriptor flags; arg is ignored.
           F_SETFD (int)
                  Set the file descriptor flags to the value specified by arg.
       File status flags
           Each  open  file  description has certain associated status flags, ini-
           tialized by open(2) and possibly modified by fcntl().  Duplicated  file
           descriptors  (made with dup(2), fcntl(F_DUPFD), fork(2), etc.) refer to
           the same open file description, and thus share  the  same  file  status
       Advisory locking
           F_SETLK,  F_SETLKW,  and F_GETLK are used to acquire, release, and test
           for the existence of record locks (also known as file-segment or  file-
           region  locks).   The third argument, lock, is a pointer to a structure
           that has at least the following fields (in unspecified order).
               struct flock {
                   short l_type;    /* Type of lock: F_RDLCK,
                                       F_WRLCK, F_UNLCK */
                   short l_whence;  /* How to interpret l_start:
                                       SEEK_SET, SEEK_CUR, SEEK_END */
                   off_t l_start;   /* Starting offset for lock */
                   off_t l_len;     /* Number of bytes to lock */
                   pid_t l_pid;     /* PID of process blocking our lock
                                       (F_GETLK only) */
           The l_whence, l_start, and l_len fields of this structure  specify  the
           range  of bytes we wish to lock.  Bytes past the end of the file may be
           locked, but not bytes before the start of the file.
           l_start is the starting offset for the lock, and is  interpreted  rela-
           tive  to  either:  the start of the file (if l_whence is SEEK_SET); the
           current file offset (if l_whence is SEEK_CUR); or the end of  the  file
           (if  l_whence  is  SEEK_END).  In the final two cases, l_start can be a
           negative number provided the offset does not lie before  the  start  of
           the file.
           l_len  specifies  the  number of bytes to be locked.  If l_len is posi-
           tive, then the range to be  locked  covers  bytes  l_start  up  to  and
           including  l_start+l_len-1.   Specifying  0  for  l_len has the special
           meaning: lock all bytes starting at the location specified by  l_whence
           and  l_start  through  to the end of file, no matter how large the file
           POSIX.1-2001 allows (but does not require) an implementation to support
           a negative l_len value; if l_len is negative, the interval described by
           lock covers bytes l_start+l_len up to and including l_start-1.  This is
           supported by Linux since kernel versions 2.4.21 and 2.5.49.
           The  l_type  field  can  be  used  to place a read (F_RDLCK) or a write
           (F_WRLCK) lock on a file.  Any number of processes may hold a read lock
           (shared  lock)  on a file region, but only one process may hold a write
           lock (exclusive lock).  An exclusive lock  excludes  all  other  locks,
           both  shared and exclusive.  A single process can hold only one type of
           lock on a file region; if a new lock is applied  to  an  already-locked
           region,  then  the  existing  lock  is  converted to the new lock type.
           (Such conversions may involve splitting, shrinking, or coalescing  with
           an  existing  lock if the byte range specified by the new lock does not
           precisely coincide with the range of the existing lock.)
           F_GETLK (struct flock *)
                  On input to this call, lock describes a lock we  would  like  to
                  place  on  the  file.  If the lock could be placed, fcntl() does
                  not actually place it, but returns F_UNLCK in the  l_type  field
                  of  lock and leaves the other fields of the structure unchanged.
                  If one or more incompatible locks would prevent this lock  being
                  placed, then fcntl() returns details about one of these locks in
                  the l_type, l_whence, l_start, and l_len fields of lock and sets
                  l_pid to be the PID of the process holding that lock.  Note that
                  the information returned by F_GETLK may already be out  of  date
                  by the time the caller inspects it.
           In  order  to place a read lock, fd must be open for reading.  In order
           to place a write lock, fd must be open  for  writing.   To  place  both
           types of lock, open a file read-write.
           As well as being removed by an explicit F_UNLCK, record locks are auto-
           matically released when the process terminates or if it closes any file
           descriptor  referring  to a file on which locks are held.  This is bad:
           it means that a process can lose the locks on a file  like  /etc/passwd
           or  /etc/mtab  when for some reason a library function decides to open,
           read and close it.
           Record locks are not inherited by a child created via fork(2), but  are
           preserved across an execve(2).
           Because  of the buffering performed by the stdio(3) library, the use of
           record locking with routines in that package  should  be  avoided;  use
           read(2) and write(2) instead.
       Mandatory locking
           (Non-POSIX.)   The  above record locks may be either advisory or manda-
           tory, and are advisory by default.
           Advisory locks are not enforced and are useful only between cooperating
           Mandatory  locks are enforced for all processes.  If a process tries to
           perform an incompatible access (e.g., read(2) or write(2))  on  a  file
           region that has an incompatible mandatory lock, then the result depends
           upon whether the O_NONBLOCK flag is enabled for its open file  descrip-
           tion.   If  the  O_NONBLOCK  flag  is  not enabled, then system call is
           blocked until the lock is removed or converted to a mode that  is  com-
           patible  with  the access.  If the O_NONBLOCK flag is enabled, then the
           system call fails with the error EAGAIN.
           To make use of mandatory locks, mandatory locking must be enabled  both
           on  the filesystem that contains the file to be locked, and on the file
           itself.  Mandatory locking is enabled on a  filesystem  using  the  "-o
           mand" option to mount(8), or the MS_MANDLOCK flag for mount(2).  Manda-
           tory locking is enabled on a file by disabling group execute permission
                  process  group IDs are returned as negative values (but see BUGS
                  below).  arg is ignored.
           F_SETOWN (int)
                  Set the process ID or process group ID that will  receive  SIGIO
                  and  SIGURG  signals  for events on file descriptor fd to the ID
                  given in arg.  A process ID is specified as a positive value;  a
                  process  group  ID  is specified as a negative value.  Most com-
                  monly, the calling process specifies itself as the  owner  (that
                  is, arg is specified as getpid(2)).
                  If you set the O_ASYNC status flag on a file descriptor by using
                  the F_SETFL command of fcntl(), a SIGIO signal is sent  whenever
                  input  or  output  becomes  possible  on  that  file descriptor.
                  F_SETSIG can be used to obtain delivery of a signal  other  than
                  SIGIO.   If  this  permission  check  fails,  then the signal is
                  silently discarded.
                  Sending a signal to  the  owner  process  (group)  specified  by
                  F_SETOWN  is  subject  to  the  same  permissions  checks as are
                  described for kill(2), where the sending process is the one that
                  employs F_SETOWN (but see BUGS below).
                  If  the  file  descriptor  fd  refers to a socket, F_SETOWN also
                  selects the recipient of SIGURG signals that are delivered  when
                  out-of-band data arrives on that socket.  (SIGURG is sent in any
                  situation where select(2) would report the socket as  having  an
                  "exceptional condition".)
                  The following was true in 2.6.x kernels up to and including ker-
                  nel 2.6.11:
                         If a nonzero value is  given  to  F_SETSIG  in  a  multi-
                         threaded  process  running  with a threading library that
                         supports thread groups  (e.g.,  NPTL),  then  a  positive
                         value  given to F_SETOWN has a different meaning: instead
                         of being a process ID identifying a whole process, it  is
                         a  thread  ID identifying a specific thread within a pro-
                         cess.  Consequently, it may be necessary to pass F_SETOWN
                         the  result of gettid(2) instead of getpid(2) to get sen-
                         sible results when F_SETSIG is used.  (In  current  Linux
                         threading  implementations,  a main thread's thread ID is
                         the same as its process ID.  This means  that  a  single-
                         threaded  program  can equally use gettid(2) or getpid(2)
                         in this scenario.)  Note, however, that the statements in
                         this  paragraph  do not apply to the SIGURG signal gener-
                         ated for out-of-band data on a  socket:  this  signal  is
                         always  sent  to  either  a  process  or a process group,
                         depending on the value given to F_SETOWN.
                  The above behavior was accidentally dropped in Linux 2.6.12, and
                  won't be restored.  From Linux 2.6.32 onward, use F_SETOWN_EX to
                  F_OWNER_PID, or F_OWNER_PGRP.   The  pid  field  is  a  positive
                  integer  representing  a thread ID, process ID, or process group
                  ID.  See F_SETOWN_EX for more details.
           F_SETOWN_EX (struct f_owner_ex *) (since Linux 2.6.32)
                  This operation performs a similar task to F_SETOWN.   It  allows
                  the  caller  to  direct  I/O  availability signals to a specific
                  thread, process, or process group.   The  caller  specifies  the
                  target  of  signals  via arg, which is a pointer to a f_owner_ex
                  structure.  The type field has  one  of  the  following  values,
                  which define how pid is interpreted:
                         Send  the signal to the thread whose thread ID (the value
                         returned by a call to clone(2) or gettid(2)) is specified
                         in pid.
                         Send  the  signal to the process whose ID is specified in
                         Send the signal to the process group whose ID  is  speci-
                         fied in pid.  (Note that, unlike with F_SETOWN, a process
                         group ID is specified as a positive value here.)
           F_GETSIG (void)
                  Return (as the function result) the signal sent  when  input  or
                  output  becomes  possible.  A value of zero means SIGIO is sent.
                  Any other value (including SIGIO) is the  signal  sent  instead,
                  and in this case additional info is available to the signal han-
                  dler if installed with SA_SIGINFO.  arg is ignored.
           F_SETSIG (int)
                  Set the signal sent when input or output becomes possible to the
                  value  given  in arg.  A value of zero means to send the default
                  SIGIO signal.  Any other value (including SIGIO) is  the  signal
                  to  send  instead, and in this case additional info is available
                  to the signal handler if installed with SA_SIGINFO.
                  By using F_SETSIG with a nonzero value, and  setting  SA_SIGINFO
                  for  the  signal  handler  (see sigaction(2)), extra information
                  about I/O events is passed to the handler in a siginfo_t  struc-
                  ture.   If  the  si_code field indicates the source is SI_SIGIO,
                  the si_fd field gives the file descriptor  associated  with  the
                  event.  Otherwise, there is no indication which file descriptors
                  are pending, and you should use the usual mechanisms (select(2),
                  poll(2),  read(2)  with  O_NONBLOCK set etc.) to determine which
                  file descriptors are available for I/O.
                  By selecting a real time signal (value  >=  SIGRTMIN),  multiple
                  I/O  events may be queued using the same signal numbers.  (Queu-
           use of the SIGURG signal on sockets.  (POSIX does not specify the SIGIO
           signal.)  F_GETOWN_EX, F_SETOWN_EX, F_GETSIG, and F_SETSIG  are  Linux-
           specific.  POSIX has asynchronous I/O and the aio_sigevent structure to
           achieve similar things; these are also available in Linux  as  part  of
           the GNU C Library (Glibc).
           F_SETLEASE and F_GETLEASE (Linux 2.4 onward) are used (respectively) to
           establish a new lease, and retrieve the current lease, on the open file
           description  referred  to by the file descriptor fd.  A file lease pro-
           vides a mechanism whereby the process holding  the  lease  (the  "lease
           holder")  is  notified  (via  delivery of a signal) when a process (the
           "lease breaker") tries to open(2) or truncate(2) the file  referred  to
           by that file descriptor.
           F_SETLEASE (int)
                  Set  or  remove a file lease according to which of the following
                  values is specified in the integer arg:
                         Take out a read lease.  This will cause the calling  pro-
                         cess  to  be notified when the file is opened for writing
                         or is truncated.  A read lease can be placed  only  on  a
                         file descriptor that is opened read-only.
                         Take out a write lease.  This will cause the caller to be
                         notified when the file is opened for reading  or  writing
                         or  is  truncated.  A write lease may be placed on a file
                         only if there are no other open file descriptors for  the
                         Remove our lease from the file.
           Leases  are  associated  with  an  open file description (see open(2)).
           This means that duplicate file descriptors (created  by,  for  example,
           fork(2) or dup(2)) refer to the same lease, and this lease may be modi-
           fied or released using any  of  these  descriptors.   Furthermore,  the
           lease  is  released  by  either an explicit F_UNLCK operation on any of
           these duplicate descriptors, or when all  such  descriptors  have  been
           Leases may be taken out only on regular files.  An unprivileged process
           may take out a lease only on a  file  whose  UID  (owner)  matches  the
           filesystem UID of the process.  A process with the CAP_LEASE capability
           may take out leases on arbitrary files.
           F_GETLEASE (void)
                  Indicates what  type  of  lease  is  associated  with  the  file
                  descriptor  fd by returning either F_RDLCK, F_WRLCK, or F_UNLCK,
                  indicating, respectively, a read lease , a write  lease,  or  no
           If  the  lease holder fails to downgrade or remove the lease within the
           number of seconds specified in /proc/sys/fs/lease-break-time  then  the
           kernel forcibly removes or downgrades the lease holder's lease.
           Once  a  lease  break has been initiated, F_GETLEASE returns the target
           lease type (either F_RDLCK or F_UNLCK, depending on what would be  com-
           patible  with  the  lease  breaker)  until the lease holder voluntarily
           downgrades or removes the lease or the kernel forcibly  does  so  after
           the lease break timer expires.
           Once  the lease has been voluntarily or forcibly removed or downgraded,
           and assuming the lease breaker has not unblocked its system  call,  the
           kernel permits the lease breaker's system call to proceed.
           If the lease breaker's blocked open(2) or truncate(2) is interrupted by
           a signal handler, then the system call fails with the error EINTR,  but
           the  other  steps still occur as described above.  If the lease breaker
           is killed by a signal while blocked in open(2) or truncate(2), then the
           other steps still occur as described above.  If the lease breaker spec-
           ifies the O_NONBLOCK flag when calling open(2), then the  call  immedi-
           ately fails with the error EWOULDBLOCK, but the other steps still occur
           as described above.
           The default signal used to notify the lease holder is SIGIO,  but  this
           can  be  changed  using the F_SETSIG command to fcntl().  If a F_SETSIG
           command is performed (even one specifying SIGIO), and the  signal  han-
           dler  is  established using SA_SIGINFO, then the handler will receive a
           siginfo_t structure as its second argument, and the si_fd field of this
           argument  will  hold  the  descriptor  of the leased file that has been
           accessed by another process.  (This  is  useful  if  the  caller  holds
           leases against multiple files).
       File and directory change notification (dnotify)
           F_NOTIFY (int)
                  (Linux  2.4  onward)  Provide  notification  when  the directory
                  referred to by fd or any  of  the  files  that  it  contains  is
                  changed.   The events to be notified are specified in arg, which
                  is a bit mask specified by ORing together zero or  more  of  the
                  following bits:
                  DN_ACCESS   A file was accessed (read, pread, readv)
                  DN_MODIFY   A  file  was  modified (write, pwrite, writev, trun-
                              cate, ftruncate).
                  DN_CREATE   A file was created (open, creat, mknod, mkdir, link,
                              symlink, rename).
                  DN_DELETE   A  file  was  unlinked  (unlink,  rename  to another
                              directory, rmdir).
                  DN_RENAME   A file was renamed within this directory (rename).
                  DN_ATTRIB   The attributes of a file were changed (chown, chmod,
                  Notification occurs via delivery of a signal.  The default  sig-
                  nal is SIGIO, but this can be changed using the F_SETSIG command
                  to fcntl().  In the latter case, the signal handler  receives  a
                  siginfo_t  structure  as its second argument (if the handler was
                  established using SA_SIGINFO) and the si_fd field of this struc-
                  ture  contains the file descriptor which generated the notifica-
                  tion  (useful  when  establishing   notification   on   multiple
                  Especially when using DN_MULTISHOT, a real time signal should be
                  used for notification, so that  multiple  notifications  can  be
                  NOTE:  New applications should use the inotify interface (avail-
                  able since kernel 2.6.13), which provides a much superior inter-
                  face for obtaining notifications of filesystem events.  See ino-
       Changing the capacity of a pipe
           F_SETPIPE_SZ (int; since Linux 2.6.35)
                  Change the capacity of the pipe referred to by fd to be at least
                  arg bytes.  An unprivileged process can adjust the pipe capacity
                  to any value between the system page size and the limit  defined
                  in  /proc/sys/fs/pipe-max-size  (see  proc(5)).  Attempts to set
                  the pipe capacity below the page size are silently rounded up to
                  the  page  size.  Attempts by an unprivileged process to set the
                  pipe capacity  above  the  limit  in  /proc/sys/fs/pipe-max-size
                  yield  the  error EPERM; a privileged process (CAP_SYS_RESOURCE)
                  can override the limit.  When  allocating  the  buffer  for  the
                  pipe,  the kernel may use a capacity larger than arg, if that is
                  convenient for the implementation.  The  F_GETPIPE_SZ  operation
                  returns the actual size used.  Attempting to set the pipe capac-
                  ity smaller than the amount of buffer space  currently  used  to
                  store data produces the error EBUSY.
           F_GETPIPE_SZ (void; since Linux 2.6.35)
                  Return  (as  the  function  result)  the  capacity  of  the pipe
                  referred to by fd.


           For a successful call, the return value depends on the operation:
           F_DUPFD  The new descriptor.
           F_GETFD  Value of file descriptor flags.
           F_GETFL  Value of file status flags.
                    Type of lease held on file descriptor.
           F_GETOWN Value of descriptor owner.
                  Operation is prohibited by locks held by other processes.
           EAGAIN The  operation  is  prohibited because the file has been memory-
                  mapped by another process.
           EBADF  fd is not an open file descriptor, or the command was F_SETLK or
                  F_SETLKW  and  the  file descriptor open mode doesn't match with
                  the type of lock requested.
                  It was detected that the specified F_SETLKW command would  cause
                  a deadlock.
           EFAULT lock is outside your accessible address space.
           EINTR  For  F_SETLKW, the command was interrupted by a signal; see sig-
                  nal(7).  For F_GETLK and F_SETLK, the command was interrupted by
                  a  signal  before the lock was checked or acquired.  Most likely
                  when locking a remote file (e.g., locking  over  NFS),  but  can
                  sometimes happen locally.
           EINVAL For  F_DUPFD,  arg  is  negative  or is greater than the maximum
                  allowable value.  For F_SETSIG, arg is not an  allowable  signal
           EMFILE For  F_DUPFD, the process already has the maximum number of file
                  descriptors open.
           ENOLCK Too many segment locks open, lock table is  full,  or  a  remote
                  locking protocol failed (e.g., locking over NFS).
           EPERM  Attempted  to  clear  the  O_APPEND  flag on a file that has the
                  append-only attribute set.


           SVr4, 4.3BSD, POSIX.1-2001.   Only  the  operations  F_DUPFD,  F_GETFD,
           F_SETFD, F_GETFL, F_SETFL, F_GETLK, F_SETLK, and F_SETLKW are specified
           in POSIX.1-2001.
           F_GETOWN and F_SETOWN are specified in  POSIX.1-2001.   (To  get  their
           definitions, define _BSD_SOURCE, or _XOPEN_SOURCE with the value 500 or
           greater, or define _POSIX_C_SOURCE with the value 200809L or  greater.)
           F_DUPFD_CLOEXEC is specified in POSIX.1-2008.  (To get this definition,
           define  _POSIX_C_SOURCE  with  the  value  200809L   or   greater,   or
           _XOPEN_SOURCE with the value 700 or greater.)
           SIG, F_NOTIFY, F_GETLEASE, and F_SETLEASE are Linux-specific.   (Define
           the _GNU_SOURCE macro to obtain these definitions.)


           Several systems have more fields in struct flock such as, for  example,
           l_sysid.   Clearly,  l_pid  alone is not going to be very useful if the
           process holding the lock may live on a different machine.


           It is not possible to use F_SETFL to change the state  of  the  O_DSYNC
           and  O_SYNC  flags.   Attempts  to  change the state of these flags are
           silently ignored.
           A limitation of the Linux system call conventions on some architectures
           (notably  i386)  means  that  if  a  (negative)  process group ID to be
           returned by F_GETOWN falls in the range -1 to -4095,  then  the  return
           value  is  wrongly interpreted by glibc as an error in the system call;
           that is, the return value of fcntl() will be -1, and errno will contain
           the (positive) process group ID.  The Linux-specific F_GETOWN_EX opera-
           tion avoids this problem.  Since glibc version 2.11,  glibc  makes  the
           kernel  F_GETOWN  problem  invisible  by  implementing  F_GETOWN  using
           In Linux 2.4 and earlier, there is bug that can occur when an  unprivi-
           leged  process  uses  F_SETOWN  to  specify  the owner of a socket file
           descriptor as a process (group) other than the caller.  In  this  case,
           fcntl() can return -1 with errno set to EPERM, even when the owner pro-
           cess (group) is one that the caller has permission to send signals  to.
           Despite  this  error return, the file descriptor owner is set, and sig-
           nals will be sent to the owner.
       Mandatory locking
           The implementation of mandatory locking in all known versions of  Linux
           is  subject  to  race conditions which render it unreliable: a write(2)
           call that overlaps with a lock may modify data after the mandatory lock
           is  acquired;  a  read(2)  call  that  overlaps  with a lock may detect
           changes to data that were made only after a write  lock  was  acquired.
           Similar  races exist between mandatory locks and mmap(2).  It is there-
           fore inadvisable to rely on mandatory locking.


           dup2(2), flock(2), open(2), socket(2), lockf(3), capabilities(7),  fea-
           locks.txt,  mandatory-locking.txt,  and dnotify.txt in the Linux kernel
           source directory Documentation/filesystems/ (on  older  kernels,  these
           files  are  directly under the Documentation/ directory, and mandatory-
           locking.txt is called mandatory.txt)

    Linux 2014-02-20 FCNTL(2)


  • Linux

    The Distributions


    The Software


    The News


  • Toll Free

Toll Free Numbers
Copyright © 1999 - 2016 by LinuxGuruz