Introduction

In Unix, Everything is a File…

• Files (and directories) are one of Unix’s most fundamental abstractions
• They, of course, represent data stored on disks
• But there are files in a typical Unix fs tree that do not correspond to anything stored on disk
• Consequence: file operations are one of the most fundamental on a Unix-like system, such as Linux
• We will see how to implement a basic file system toward the end of the course, today we concentrate on how to use the API provided by the system

Files & Directories

• Modern file systems have two abstractions:
  1. File - think of them simply as a collection of bytes that can be read and written and can be addressed using a name
     • Has a name associated with it, and some other information
  2. Directory - a collection of files and other directories
• In its simplest form, this gives rise to a tree-shaped organisation:

                   foo/
                    |
          +-----+---+---+--------+
          |     |       |        |
         bar/  baz/  info.txt hello.c        
          |     |
      img.png   |
                |
       +--------+-------+-------+-------+
       |        |       |       |       |
    meme.gif run.sh items.csv main.s letter.docx

• Files and directories have a few properties:
  1. User owner
  2. Group owner
  3. Access permissions for user/group/others (read/write/execute)
  4. Access/modification/creation dates
  5. Size
  6. etc…

File System API

• When we talk about API, we mean system calls (just like with fork, wait, and exec)
• The OS provides several system calls to interact with a file system
• This week we will work mainly with operations for opening and closing files, as well as for reading from and writing to them

File Descriptors

• The POSIX File API works with file descriptors

• These are integers that represent open files

• Each process has its own file descriptor table

  In xv6:

  struct proc {
    // ...
    struct file *ofile[NOFILE];  // Open files
    // ...
  };

  In Linux:

  struct task_struct {
    // ...
      /* Open file information: */
    struct files_struct       *files;
    // ...
  }

• The file descriptor that the API uses is usually the literal index into the above array

Default Descriptors

• Each process gets 3 default descriptors upon its start up

Opening and Closing Files

• To open a file, we issue the open system call

  #include <sys/types.h>
  #include <sys/stat.h>
  #include <fcntl.h>
  
  int open(const char *pathname, int flags);
  int open(const char *pathname, int flags, mode_t mode);

• We need to give it a filename (with path) and flags

• Flags give specifics about how a file should be open

• Access mode flags (one of them is required):

  O_RDONLY

  Open file for reading only.

  O_WRONLY

  Open file for writing only

  O_RDWR

  Open file for both reading and writing

• Other flags:

  O_APPEND

  Open file in append mode - writing will add to the end of the file

  O_CREAT

  Create a file if it doesn’t exist. If this option is used, the third argument must be present and specify a file access mode (rwr)

  O_TRUNC

  Truncate the file to 0 and write from the beginning

• Multiple flags are “orred” using |, e.g.,

  open("foo.txt", O_RDWR | O_CREAT | O_TRUNC, 0644)

• If we are CREAT-ing a file, we also need to supply permissions for the new file - e.g., the 0644 above corresponds to rw-r--r--

• (For an explanation of file permissions in Linux, see https://www.linuxfoundation.org/blog/blog/classic-sysadmin-understanding-linux-file-permissions)

• When successful, open will return a file descriptor  ≥ 0

• On error, it will return -1 and the errno variable is set to the error code

• Full usage info: man 2 open

• To close an open file, call close with the file descriptor as argument

Reading from Files

• The read syscall allows reading from a file

• It takes a file descriptor, a buffer to be written to and the maximum number of bytes to be read

  #include <unistd.h>
  
  ssize_t read(int fd, void *buf, size_t count);

• On success, it will return the number of bytes actually read

• On error, it will return -1 and the errno variable is set to the error code

Writing to a File

• The write syscall is for writing

• Args: file descriptor, a buffer containing the contents to be written, and the number of bytes to write

  #include <unistd.h>
  
  ssize_t write(int fd, const void *buf, size_t count);

• Success: the number of bytes written

• On error, it will return -1 and the errno variable is set to the error code

(Use strace to trace cat foo)

Other operations

• lseek
  • move withing a file
• fsync
  • flush a buffer to a file - force data to be written
• rename
  • rename a file
• stat
  • get information (metadata) about a file
• link
  • associate another name with file data
• unlink
  • remove (a reference to) a file / delete a file

Fun With Redirection

• examples