8/13/2019 unix7_2
1/14
File and record locking
8/13/2019 unix7_2
2/14
File locking versus record lockingFile locking :locks an entire file
Record locking: allows a process to lock a specified portion of file. Locks the region form starting
byte offset in the file and number of bytes from that position.
The term record locking is derived from other operating systems that enforce the record structure odisk files.
Range blocking: As unix kernel doesn't support the concept of records. It is the range of the file th
is locked.
Lockf function is used to lock the region. Lockf function has the following sequence.
#include
int lockf( int fd, int function, long size);
where function has one of the following values
F_ULOCK unlock a previously locked region.F_LOCK lock a region ( blocking ) .
F_TLOCK test and lock a region (non blocking ) .
F_TEST test a region to see if it is locked
8/13/2019 unix7_2
3/14
The lockf function uses the current file offset , which the process can set using the lseek
system call.
The record starts at the current offset and extends forward for a positive size, or extends
backward for a negative size.
If the size is Zero the record extends from the current offset to the end of the file.
Blocking: if a lock is set and the region is already locked by another process, the calling
process is put to sleep until the region is available. (F_LOCK)
Non blocking: if a process is started and it wants to assure that only a single copy of therunning . When the daemon starts, it executes a non blocking lock on a specified file. If the
lock succeeds, then the daemon is the only copy running, but if it fails the daemon can exi
since it knows that a copy is already running. (F_TLOCK)
if( lockf(fd, F_TEST, size)==0)
{rc= lockf( fd, F_LOCK, size);
..
}
8/13/2019 unix7_2
4/14
fcntl Record locking
#include< sys/types.h>
#include
#include
int fcntl( int filedes, int cmd, .../* struct flock *flockptr */);
returnsdepends on cmd, if ok(F_GETLK, F_SETLK,F_SETLKW)
-1 on error.
Structure of flock
struct flock
{short l_type; /* F_RDLCK, F_WRLCK, or F_UNLCK */
off_t l_start; /* offset in bytes, relative to l_whence */
short l_whence; /* SEEK_SET, SEEK_CUR, or SEEK_END */
off_t l_len; /* length in bytes; 0 means lock to EOF */
pid_t l_pid; /* returned with F_GETLK */
};
The structure defines
the type of lock desired:
F_RDLCK( a shared lock )
F_WRLCK ( an exclusive lock
F_UNLCK ( unlocking a regio
8/13/2019 unix7_2
5/14
The starting offset of the region being locked or unlocked ( l_start and l_whence)
The size of the region (l_len)
F_GETLK:determines if the lock described by flockptr id blocked by some other lock.
If a lock exists that would prevent ours from being created the information on existing lock
overwrites the information pointed by the flockptr.
If no lock exists that would prevent ours from being created., the structure pointed by flock
pointer is left unchanged except the l_type member which is set to F_UNLCK.
F_SETLK:Set the lock described by flockptr. If we are trying to obtain a read lock l_type o
F_RDLCK) or a write lock ( l_type of F_WRLCK) and the compatibility rule prevents the
system from giving us the lock fcntl returns immediately with errno set to either EACCES o
EAGAIN.
F_SETLKW:This command is a blocking version of F_SETLK. (The W in the command na
means wait.) If the requested read lock or write lock cannot be granted because another
process currently has some part of the requested region locked, the calling process is put
sleep. The process wakes up either when the lock becomes available or when interrupted
si nal.
8/13/2019 unix7_2
6/14
No locks Ok ok
One or more readlocks
Ok denied
One write lock Denied denied
Region currently
had
Request for
Read write
8/13/2019 unix7_2
7/14
ADVISORY LOCKING & MANDATORY LOCKING
Advisory locking means the operating system maintains the a correct knowledge of which
have been locked. But it doesn't prevents some process from writing to a file that is lockeanother process.
A process can ignore the lock and can write to a file that is locked . If the process has
adequate permissions.
The flock function is used to lock and unlock a file.
#includeint flock(int fd, int operation);
Operations
LOCK_SH shared lock
LOCK_EX exclusive lock
LOCK_UN unlock
LOCK_NB dont block when locking
Mandatory locking:
Operating system checks every read and write request to verify that the operation doesnt
interfere with a lock held by a process.
8/13/2019 unix7_2
8/14
STREAMS The STREAMS mechanism is provided by System V as a general way to
interfacecommunication drivers into the kernel.
We need to discuss STREAMS to understand the terminal interface in SysteV, the use of the poll function for I/O multiplexing , and the implementation
STREAMS-based pipes and named pipes
Be careful not to confuse this usage of the word stream with our previous usaof it in the standard I/O library
History
1. Developed by dennis ritchie
2. STREAMS-based terminal I/O system SVR4
8/13/2019 unix7_2
9/14
A stream provides a full-duplex path between a user process and a devicedriver. There is no need for a stream to talk to a hardware device; a streamcan also be used with a pseudo-device driver.
Figure : A simple Stream
8/13/2019 unix7_2
10/14
Figure : A stream with a processing module
8/13/2019 unix7_2
11/14
Any number of processing modules can be pushed onto a stream.
We use the term push, because each new module goes beneath the
stream head, pushing any previously pushed modules down. (This issimilar to a last- in, first-out stack.
We access a stream with the functions from open, close, read, write,and ioctl
All STREAMS devices are character special files.
The pathname that we open for a stream normally lives beneath the/dev directory
Before STREAMS, terminals were handled with the existing c-list
mechanism
8/13/2019 unix7_2
12/14
Malloc, calloc, realloc functions
ISO C specifies three functions for memory allocation:
1. malloc, which allocates a specified number of bytes of memory. The initial
value of the memory is indeterminate.
2. calloc, which allocates space for a specified number of objects of a specified
size. The space is initialized to all 0 bits.
3. realloc, which increases or decreases the size of a previously allocated area.
When the size increases, it may involve moving the previously allocated area
somewhere else, to provide the additional room at the end. Also, when the
size increases, the initial value of the space between the old contents and the end
of the new area is indeterminate.
8/13/2019 unix7_2
13/14
#include
void *malloc(size_t size);
void *calloc(size_t nobj , size_t size);
void *realloc(void * ptr, size_t newsize);
All three return: non-null pointer if OK, NULL on error
void free(void *ptr);
The function free causes the space pointed to byptr to be deallocated. This freed space is
usually put into a pool of available memory and can be allocated in a later call to one of th
three alloc functions.
sbrk can expand or contract the memory of a process, most versions ofmalloc and f
never decrease their memory size. The space that we free is available for a later allocation
but the freed space is not usually returned to the kernel; that space is kept in the
malloc pool.
8/13/2019 unix7_2
14/14
MEMORY ALLOCATION OF A C-PROGRAM
text
Initialized data
uninitialized
data
stack
heap
High address
Low address
Command line arguments andenvironment variables
Initialized to zero by exec
Read from program file by exec