CS 208 s22 — System I/O

• A Linux file is a sequence of m bytes:
  • B₀ , B₁ , …. , B_k , …. , B_m-1
• Cool fact: All I/O devices are represented as files:
• /dev/sda2 (/usr disk partition)
• /dev/tty2 (terminal)
• Even the kernel is represented as a file:
• /boot/vmlinuz-5.4.0-89-generic (kernel image)
• /proc (kernel data structures)
• Elegant mapping of files to devices allows kernel to export simple interface called Unix I/O:
  • these are system calls
  • Opening and closing files
    • open() and close()
  • Reading and writing a file
    • read() and write()
  • Changing the current file position (seek)
    • indicates next offset into file to read or write

    • lseek()

      

The C standard library (libc.so) contains a collection of higher-level standard I/O functions. Examples of standard I/O functions:

• Opening and closing files (fopen and fclose)
• Reading and writing bytes (fread and fwrite)
• Reading and writing text lines (fgets and fputs)
• Formatted reading and writing (fscanf and fprintf)

RIO is a set of wrappers that provide efficient and robust I/O in apps, such as network programs that are subject to short counts.

• RIO provides two different kinds of functions
  • Unbuffered input and output of binary data

    • rio_readn and rio_writen

      #include "csapp.h"
      
      ssize_t rio_readn(int fd, void *usrbuf, size_t n);
      ssize_t rio_writen(int fd, void *usrbuf, size_t n);
      
      //     Return: num. bytes transferred if OK,  0 on EOF (rio_readn only), -1 on error
      

  • Buffered input of text lines and binary data

    • rio_readlineb and rio_readnb

      #include "csapp.h"
      
      void rio_readinitb(rio_t *rp, int fd);
      
      ssize_t rio_readlineb(rio_t *rp, void *usrbuf, size_t maxlen);
      ssize_t rio_readnb(rio_t *rp, void *usrbuf, size_t n);
      
      //       Return: num. bytes read if OK, 0 on EOF, -1 on error
      

• Download from http://csapp.cs.cmu.edu/3e/code.html
  • src/csapp.c and include/csapp.h
• Same interface as Unix read and write
• Especially useful for transferring data on network sockets

/*
 * rio_readn - Robustly read n bytes (unbuffered)
 */
ssize_t rio_readn(int fd, void *usrbuf, size_t n) {
    size_t nleft = n;
    ssize_t nread;
    char *bufp = usrbuf;

    while (nleft > 0) {
        if ((nread = read(fd, bufp, nleft)) < 0) {
            if (errno == EINTR) /* Interrupted by sig handler return */
                nread = 0;       /* and call read() again */
            else
                return -1;       /* errno set by read() */
        }
        else if (nread == 0)
            break;              /* EOF */
        nleft -= nread;
        bufp += nread;
    }
    return (n - nleft);         /* Return >= 0 */
}

Buffered RIO input functions efficiently read text lines and binary data from a file partially cached in an internal memory buffer.

• rio_readlineb reads a text line of up to maxlen bytes from file fd and stores the line in usrbuf
  • Especially useful for reading text lines from network sockets
• Stopping conditions
  • maxlen bytes read
  • EOF encountered
  • Newline (‘\n’) encountered

typedef struct {
    int rio_fd;                /* descriptor for this internal buf */
    int rio_cnt;               /* unread bytes in internal buf */
    char *rio_bufptr;          /* next unread byte in internal buf */
    char rio_buf[RIO_BUFSIZE]; /* internal buffer */
} rio_t;

The rio_t struct:

The Unix file underneath:

• Unix I/O
  • Pros
    • Unix I/O is the most general and lowest overhead form of I/O
    • All other I/O packages are implemented using Unix I/O functions
    • Unix I/O functions are async-signal-safe and can be used safely in signal handlers
  • Cons
    • Dealing with short counts is tricky and error prone
    • Efficient reading of text lines requires some form of buffering, also tricky and error prone
    • Both of these issues are addressed by the standard I/O and RIO packages
• Standard I/O
  • Pros:
    • Buffering increases efficiency by decreasing the number of read and write system calls
    • Short counts are handled automatically
  • Cons:
    • Standard I/O functions are not async-signal-safe, and not appropriate for signal handlers
    • Standard I/O is not appropriate for input and output on network sockets
    • There are poorly documented restrictions on streams that interact badly with restrictions on sockets (CS:APP3e, Sec 10.11)
• General rule: use the highest-level I/O functions you can
  • Many C programmers are able to do all of their work using the standard I/O functions
  • But, be sure to understand the functions you use!
• When to use standard I/O
  • When working with disk or terminal files
• When to use raw Unix I/O
  • Inside signal handlers, because Unix I/O is async-signal-safe
  • In rare cases when you need absolute highest performance
• When to use RIO
  • When you are reading and writing network sockets
  • Avoid using standard I/O on sockets