Accessing Files Programmer's Guide (32650-90885)

Chapter 12 157
Sharing a File
Sharing the File Using FLOCK and FUNLOCK
Sharing the File Using FLOCK and FUNLOCK
Sharing a file among two or more processes may be hazardous. When a file is being shared
among two or more processes and is being written to by one or more of them, care must be
taken to ensure that the processes are properly interlocked. For example, if process A is
trying to read a particular record of the file, and at that time process B should execute and
try to write that record, the results are not predictable. process A may see the old record or
the new record, and not know whether it has read good data. If buffering is being done,
please bear in mind that an output request (FWRITE) does not cause physical I/O to occur
until a block is filled, which typically contains several records. A process trying to read
such a file could, for example, read past the last record of the file which has been written
on the disk because the end-of-file pointer is not kept in the file, but is kept in core where it
can be updated quickly as writes occur. The necessary interlocking is provided by the
intrinsics FLOCK and FUNLOCK, which use a resource identification number (RIN) as a flag
to interlock multiple accessors.
In the simple case of a file shared between a writer process and a reader process, where the
writer is merely adding records to the file, the writer calls FLOCK prior to writing each
record and FUNLOCK after writing. The reader calls FLOCK prior to reading each record, and
FUNLOCK after reading. If the writing process should execute while the reader is in the
middle of a read, the writer will be impeded on its FLOCK call until the reader signals that
it is done by calling FUNLOCK. Similarly, if the reader should execute while the writer is
performing a write, the reader will be impeded on its FLOCK call until the writer calls
FUNLOCK. FUNLOCK ensures that all buffers are posted on the disk so that the reading
processes can see all of the data.
More complicated cases arise when a file has two or more writing processes, or when the
writer may write more than one record at a time. If, for example, it should be necessary to
write pairs of records, with read prohibited until both records of the pair are written, the
writing process can call FLOCK before writing the first record of the pair, and FUNLOCK after
writing the second.
The shared file management scheme that MPE/iX provides you through the use of the
FLOCK and FUNLOCK intrinsics guarantees you exclusive access to a file being shared by a
set of processes that may be located in different jobs or sessions. MPE/iX also provides you
with RINs you can use to manage anything you may consider a resource to your program,
be it portions of a file, a device, or a segment of code in your program. Managing shared
resources with RINs is described in Resource Management Programmer's Guide.
For more information about the FLOCK and FUNLOCK intrinsics, consult the MPE/iX
Intrinsics Reference Manual.