More File I/O

• You should read chapter 5, especially the first part.
• Atomicity and Race Conditions
  • Remember, a process can be interrupted at any time.
  • If there is no interaction between processes this is not a problem.
  • But if processes interact, then there is a great potential for problems.
  • A race condition occurs when two processes operating on a shared resource produce results which depends in an unexpected way on the relative order in which the processes gain access to the CPU.
    • This is a major area of study in operating systems.
    • Race conditions are difficult to spot as they occur at random.
  • He presents a possible race condition
    • Assume that you want to create a log file shared across multiple processes.
    • Assume that the first program that creates this file has the responsibility for writing some header information.

    • 
       if (-1 == open(logfile, O_WRONLY) ) {
           if (-1 == open(logfile, O_WRONLY | O_CREAT)
               error
           else
               write header information
               write log entry
       else
           write log entry
      
      	     

    • If two processes reach this code simultaneously
      • Assume process 1 is interrupted right after line 1.
      • Process 2 will then open, create the file and write the header information.
      • Assume that process two is interrupted right after line 5
      • Then process 1 will reopen the file and write the header information and the first log information
    • In this case, both programs will have written header information.
  • He states that this is why the O_EXCL flag was created
    • O_EXCL must be used in conjunction with O_CREAT
    • If the file exists, the open call will fail.
    • Interestingly, the man page says that behavior of O_EXCL without O_CREAT is undefined.
    • This turns checking for file existence and creation into an atomic operation.
      Both will occur in the same instruction stream and will not be subject to interruption.
      • There is still a race condition here, but more on that later.
    • He points out that O_APPEND covers the problem when writing to the end of a file.
• Two system calls he uses in his example
  • getpid()

    • #include <sys/types.h>
      #include <unistd.h>
      pid_t getpid(void);
      pid_t getppid(void);
      	     

    • Returns the process, or parent process id.
    • Under errors: These functions are always successful.
  • sleep()

    • #include <unistd.h>
      unsigned int sleep(unsigned int seconds)
      	     

    • Causes a process to sleep.
    • Return value: seconds left to sleep if it was awaken (due to a signal) before the time expired.
    • This sets a signal and places the process in a waiting state.
    • The process is not active and not consuming system resources during the sleep process.
    • This is not the same as a for loop.
    • And should work across optimization, different hardware , ...
    • We will see other ways to do this in the future.
  • And while we are at it,

    • #include <unistd.h>
      int usleep(useconds_t usec);
      	

    • Sleep for a set period of microseconds.
    • Same as sleep for action
    • return -1 if it was interrupted by a signal, 0 otherwise.
    • This one is deprecated, but easy to use so ...
    • We will see other ways to do this in the future.
• fcntl

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

  • Manipulate a file descriptor.
  • This is a changing command, the man pages states :

    "Certain of the operations below are supported only since a particular Linux kernel version. The preferred method of checking whether the host kernel supports a particular operation is to invoke fcntl() with the desired cmd value and then test whether the call failed with EIN- VAL, indicating that the kernel does not recognize this value."

  • This function can perform many tasks:
    • F_DUPFD: find the lowest available file descriptor greater than or equal fd and make a copy of fd. (We will see another way to do this )
    • F_GETFL: Get the file access mode, returned from fcntl
    • F_SETFL: Set the status flag indicated by arg
      • Mode: O_RDONLY, O_WRONLY, O_RDWR and creation flags O_CREAT, O_EXCL, O_NOCTTY, O_TRUNC are ignored.
      • O_APPEND, O_ASYNC, O_DIRECT, O_NOATIME, and O_NONBLOCK can be changed.
    • F_SETLK, F_SETLKW, and F_GETLK are used for advisory file locking.
      • A later topic.
    • There are commands related to what processes are "watching" a file.
    • And more.
  • He gives us a quick bit of code to see how we opened the file (for read,write, read/write)