Qnx Fcntl
Emigdio Binet
All functions in this module take a file descriptor fd as their firstargument. This can be an integer file descriptor, such as returned bysys.stdin.fileno(), or an io.IOBase object, such as sys.stdinitself, which provides a fileno() that returns a genuine filedescriptor.
Changed in version 3.9: On macOS, the fcntl module exposes the F_GETPATH constant, which obtainsthe path of a file from a file descriptor.On Linux(>=3.15), the fcntl module exposes the F_OFD_GETLK, F_OFD_SETLKand F_OFD_SETLKW constants, which are used when working with open filedescription locks.
Perform the operation cmd on file descriptor fd (file objects providinga fileno() method are accepted as well). The values usedfor cmd are operating system dependent, and are available as constantsin the fcntl module, using the same names as used in the relevant Cheader files. The argument arg can either be an integer value, or abytes object. With an integer value, the return value of thisfunction is the integer return value of the C fcntl() call. Whenthe argument is bytes it represents a binary structure, e.g. created bystruct.pack(). The binary data is copied to a buffer whose address ispassed to the C fcntl() call. The return value after a successfulcall is the contents of the buffer, converted to a bytes object.The length of the returned object will be the same as the length of thearg argument. This is limited to 1024 bytes. If the information returnedin the buffer by the operating system is larger than 1024 bytes, this ismost likely to result in a segmentation violation or a more subtle datacorruption.
The request parameter is limited to values that can fit in 32-bits.Additional constants of interest for use as the request argument can befound in the termios module, under the same names as used inthe relevant C header files.
This is essentially a wrapper around the fcntl() locking calls.fd is the file descriptor (file objects providing a fileno()method are accepted as well) of the file to lock or unlock, and cmdis one of the following values:
If LOCK_NB is used and the lock cannot be acquired, anOSError will be raised and the exception will have an errnoattribute set to EACCES or EAGAIN (depending on theoperating system; for portability, check for both values). On at least somesystems, LOCK_EX can only be used if the file descriptor refers to afile opened for writing.
I received a Python project (which happens to be a Django project, if that matters,) that uses the fcntl module from the standard library, which seems to be available only on Linux. When I try to run it on my Windows machine, it stops with an ImportError, because this module does not exist here.
There's also the possibility that some code using fcntl has no windows equivalent, which would require you to change the module api and maybe the structure/paradigm of the program using the module you're porting.
The fcntl module is just used for locking the pinning file, so assuming you don't try multiple access, this can be an acceptable workaround. Place this module in your sys.path, and it should just work as the official fcntl module.
Of course, then you need to place the fcntl.py module in your site-packages directory for the Python interpreter that you want to use. For example, %LOCALAPPDATA%\Programs\Python\Python310\lib\site-packages\fcntl\. This is where my site-packages live. Check Tutorialspoint to find where yours is located.
When a shared lock is set on a segment of a file, other processes shall be able to set shared locks on that segment or a portionof it. A shared lock prevents any other process from setting an exclusive lock on any portion of the protected area. A request fora shared lock shall fail if the file descriptor was not opened with read access.
An exclusive lock shall prevent any other process from setting a shared lock or an exclusive lock on any portion of theprotected area. A request for an exclusive lock shall fail if the file descriptor was not opened with write access.
If the command is F_SETLKW and the process must wait for another process to release a lock, then the range of bytes to be lockedshall be determined before the fcntl() function blocks. If the file size or file descriptor seek offset change whilefcntl() is blocked, this shall not affect the range of bytes locked.
There shall be at most one type of lock set for each byte in the file. Before a successful return from an F_SETLK or an F_SETLKWrequest when the calling process has previously existing locks on bytes in the region specified by the request, the previous locktype for each byte in the specified region shall be replaced by the new lock type. As specified above under the descriptions ofshared locks and exclusive locks, an F_SETLK or an F_SETLKW request (respectively) shall fail or block when another process hasexisting locks on bytes in the specified region and the type of any of those locks conflicts with the type specified in therequest.
All locks associated with a file for a given process shall be removed when a file descriptor for that file is closed by thatprocess or the process holding that file descriptor terminates. Locks are not inherited by a child process.
A potential for deadlock occurs if a process controlling a locked region is put to sleep by attempting to lock another process'locked region. If the system detects that sleeping until a locked region is unlocked would cause a deadlock, fcntl() shallfail with an [EDEADLK] error.
An unlock (F_UNLCK) request in which l_len is non-zero and the offset of the last byte of the requested segment is themaximum value for an object of type off_t, when the process has an existing lock in which l_len is 0 and whichincludes the last byte of the requested segment, shall be treated as a request to unlock from the start of the requested segmentwith an l_len equal to 0. Otherwise, an unlock (F_UNLCK) request shall attempt to unlock only the requested segment.
[SHM] When the file descriptor fildes refers to a shared memory object, the behavior of fcntl() shall be the same as for aregular file except the effect of the following values for the argument cmd shall be unspecified: F_SETFL, F_GETLK, F_SETLK,and F_SETLKW.
The following example demonstrates how to place a lock on bytes 100 to 109 of a file and then later remove it. F_SETLK is usedto perform a non-blocking lock request so that the process does not have to wait if an incompatible lock is held by anotherprocess; instead the process can take some other action.
The ellipsis in the SYNOPSIS is the syntax specified by the ISO C standard for a variable number of arguments. It is usedbecause System V uses pointers for the implementation of file locking functions.
The arg values to F_GETFD, F_SETFD, F_GETFL, and F_SETFL all represent flag values to allow for future growth.Applications using these functions should do a read-modify-write operation on them, rather than assuming that only the valuesdefined by this volume of IEEE Std 1003.1-2001 are valid. It is a common error to forget this, particularly in the caseof F_SETFD.
This volume of IEEE Std 1003.1-2001 permits concurrent read and write access to file data using the fcntl()function; this is a change from the 1984 /usr/group standard and early proposals. Without concurrency controls, this feature maynot be fully utilized without occasional loss of data.
Data losses occur in several ways. One case occurs when several processes try to update the same record, without sequencingcontrols; several updates may occur in parallel and the last writer "wins". Another case is a bit-tree or other internallist-based database that is undergoing reorganization. Without exclusive use to the tree segment by the updating process, otherreading processes chance getting lost in the database when the index blocks are split, condensed, inserted, or deleted. Whilefcntl() is useful for many applications, it is not intended to be overly general and does not handle the bit-tree examplewell.
The use of the open file description to identify what to lock requires extra calls and presents problems if several processesare sharing an open file description, but there are too many implementations of the existing mechanism for this volume ofIEEE Std 1003.1-2001 to use different specifications.
Another consequence of this model is that closing any file descriptor for a given file (whether or not it is the same open filedescription that created the lock) causes the locks on that file to be relinquished for that process. Equivalently, any close forany file/process pair relinquishes the locks owned on that file for that process. But note that while an open file description maybe shared through fork(), locks are not inherited through fork(). Yet locks may be inherited through one of the exec functions.
The identification of a machine in a network environment is outside the scope of this volume of IEEE Std 1003.1-2001.Thus, an l_sysid member, such as found in System V, is not included in the locking structure.
For advisory file record locking to be effective, all processes that have access to a file must cooperate and use the advisorymechanism before doing I/O on the file. Enforcement-mode record locking is important when it cannot be assumed that all processesare cooperating. For example, if one user uses an editor to update a file at the same time that a second user executes anotherprocess that updates the same file and if only one of the two processes is using advisory locking, the processes are notcooperating. Enforcement-mode record locking would protect against accidental collisions.
Secondly, advisory record locking requires a process using locking to bracket each I/O operation with lock (or test) and unlockoperations. With enforcement-mode file and record locking, a process can lock the file once and unlock when all I/O operations havebeen completed. Enforcement-mode record locking provides a base that can be enhanced; for example, with sharable locks. That is,the mechanism could be enhanced to allow a process to lock a file so other processes could read it, but none of them could writeit.
c80f0f1006