1 :mod:`fcntl` --- The ``fcntl`` and ``ioctl`` system calls 2 ========================================================= 3 4 .. module:: fcntl 5 :platform: Unix 6 :synopsis: The fcntl() and ioctl() system calls. 7 .. sectionauthor:: Jaap Vermeulen 8 9 10 .. index:: 11 pair: UNIX; file control 12 pair: UNIX; I/O control 13 14 This module performs file control and I/O control on file descriptors. It is an 15 interface to the :c:func:`fcntl` and :c:func:`ioctl` Unix routines. For a 16 complete description of these calls, see :manpage:`fcntl(2)` and 17 :manpage:`ioctl(2)` Unix manual pages. 18 19 All functions in this module take a file descriptor *fd* as their first 20 argument. This can be an integer file descriptor, such as returned by 21 ``sys.stdin.fileno()``, or a file object, such as ``sys.stdin`` itself, which 22 provides a :meth:`~io.IOBase.fileno` which returns a genuine file descriptor. 23 24 The module defines the following functions: 25 26 27 .. function:: fcntl(fd, op[, arg]) 28 29 Perform the operation *op* on file descriptor *fd* (file objects providing 30 a :meth:`~io.IOBase.fileno` method are accepted as well). The values used 31 for for *op* are operating system dependent, and are available as constants 32 in the :mod:`fcntl` module, using the same names as used in the relevant C 33 header files. The argument *arg* is optional, and defaults to the integer 34 value ``0``. When present, it can either be an integer value, or a string. 35 With the argument missing or an integer value, the return value of this function 36 is the integer return value of the C :c:func:`fcntl` call. When the argument is 37 a string it represents a binary structure, e.g. created by :func:`struct.pack`. 38 The binary data is copied to a buffer whose address is passed to the C 39 :c:func:`fcntl` call. The return value after a successful call is the contents 40 of the buffer, converted to a string object. The length of the returned string 41 will be the same as the length of the *arg* argument. This is limited to 1024 42 bytes. If the information returned in the buffer by the operating system is 43 larger than 1024 bytes, this is most likely to result in a segmentation 44 violation or a more subtle data corruption. 45 46 If the :c:func:`fcntl` fails, an :exc:`IOError` is raised. 47 48 49 .. function:: ioctl(fd, op[, arg[, mutate_flag]]) 50 51 This function is identical to the :func:`~fcntl.fcntl` function, except that the 52 operations are typically defined in the library module :mod:`termios` and the 53 argument handling is even more complicated. 54 55 The op parameter is limited to values that can fit in 32-bits. 56 Additional constants of interest for use as the *op* argument can be 57 found in the :mod:`termios` module, under the same names as used in 58 the relevant C header files. 59 60 The parameter *arg* can be one of an integer, absent (treated identically to the 61 integer ``0``), an object supporting the read-only buffer interface (most likely 62 a plain Python string) or an object supporting the read-write buffer interface. 63 64 In all but the last case, behaviour is as for the :func:`~fcntl.fcntl` 65 function. 66 67 If a mutable buffer is passed, then the behaviour is determined by the value of 68 the *mutate_flag* parameter. 69 70 If it is false, the buffer's mutability is ignored and behaviour is as for a 71 read-only buffer, except that the 1024 byte limit mentioned above is avoided -- 72 so long as the buffer you pass is as least as long as what the operating system 73 wants to put there, things should work. 74 75 If *mutate_flag* is true, then the buffer is (in effect) passed to the 76 underlying :func:`ioctl` system call, the latter's return code is passed back to 77 the calling Python, and the buffer's new contents reflect the action of the 78 :func:`ioctl`. This is a slight simplification, because if the supplied buffer 79 is less than 1024 bytes long it is first copied into a static buffer 1024 bytes 80 long which is then passed to :func:`ioctl` and copied back into the supplied 81 buffer. 82 83 If *mutate_flag* is not supplied, then from Python 2.5 it defaults to true, 84 which is a change from versions 2.3 and 2.4. Supply the argument explicitly if 85 version portability is a priority. 86 87 If the :c:func:`ioctl` fails, an :exc:`IOError` exception is raised. 88 89 An example:: 90 91 >>> import array, fcntl, struct, termios, os 92 >>> os.getpgrp() 93 13341 94 >>> struct.unpack('h', fcntl.ioctl(0, termios.TIOCGPGRP, " "))[0] 95 13341 96 >>> buf = array.array('h', [0]) 97 >>> fcntl.ioctl(0, termios.TIOCGPGRP, buf, 1) 98 0 99 >>> buf 100 array('h', [13341]) 101 102 103 .. function:: flock(fd, op) 104 105 Perform the lock operation *op* on file descriptor *fd* (file objects providing 106 a :meth:`~io.IOBase.fileno` method are accepted as well). See the Unix manual 107 :manpage:`flock(2)` for details. (On some systems, this function is emulated 108 using :c:func:`fcntl`.) 109 110 If the :c:func:`flock` fails, an :exc:`IOError` exception is raised. 111 112 113 .. function:: lockf(fd, operation, [length, [start, [whence]]]) 114 115 This is essentially a wrapper around the :func:`~fcntl.fcntl` locking calls. 116 *fd* is the file descriptor of the file to lock or unlock, and *operation* 117 is one of the following values: 118 119 * :const:`LOCK_UN` -- unlock 120 * :const:`LOCK_SH` -- acquire a shared lock 121 * :const:`LOCK_EX` -- acquire an exclusive lock 122 123 When *operation* is :const:`LOCK_SH` or :const:`LOCK_EX`, it can also be 124 bitwise ORed with :const:`LOCK_NB` to avoid blocking on lock acquisition. 125 If :const:`LOCK_NB` is used and the lock cannot be acquired, an 126 :exc:`IOError` will be raised and the exception will have an *errno* 127 attribute set to :const:`EACCES` or :const:`EAGAIN` (depending on the 128 operating system; for portability, check for both values). On at least some 129 systems, :const:`LOCK_EX` can only be used if the file descriptor refers to a 130 file opened for writing. 131 132 *length* is the number of bytes to lock, *start* is the byte offset at 133 which the lock starts, relative to *whence*, and *whence* is as with 134 :func:`io.IOBase.seek`, specifically: 135 136 * :const:`0` -- relative to the start of the file (:data:`os.SEEK_SET`) 137 * :const:`1` -- relative to the current buffer position (:data:`os.SEEK_CUR`) 138 * :const:`2` -- relative to the end of the file (:data:`os.SEEK_END`) 139 140 The default for *start* is 0, which means to start at the beginning of the file. 141 The default for *length* is 0 which means to lock to the end of the file. The 142 default for *whence* is also 0. 143 144 Examples (all on a SVR4 compliant system):: 145 146 import struct, fcntl, os 147 148 f = open(...) 149 rv = fcntl.fcntl(f, fcntl.F_SETFL, os.O_NDELAY) 150 151 lockdata = struct.pack('hhllhh', fcntl.F_WRLCK, 0, 0, 0, 0, 0) 152 rv = fcntl.fcntl(f, fcntl.F_SETLKW, lockdata) 153 154 Note that in the first example the return value variable *rv* will hold an 155 integer value; in the second example it will hold a string value. The structure 156 lay-out for the *lockdata* variable is system dependent --- therefore using the 157 :func:`flock` call may be better. 158 159 160 .. seealso:: 161 162 Module :mod:`os` 163 If the locking flags :data:`~os.O_SHLOCK` and :data:`~os.O_EXLOCK` are 164 present in the :mod:`os` module (on BSD only), the :func:`os.open` 165 function provides an alternative to the :func:`lockf` and :func:`flock` 166 functions. 167 168
