UNIX File Systems

• int access(char *FileName, int Mode) - Determine accessibility of FileName. Modes are defined in unistd.h
  • F_OK - test whether the directories leading to the file can be searched and the file exists.
  • R_OK - test for read permission
  • W_OK - test for write permission
  • X_OK - test for execute or search permission
  • The latter three can be bitwise ORed to get a combination
• int stat(char *FileName,struct stat *StatusBuffer);
  • The stat call retrieves information about the named file into the StatusBuffer
  • The struct stat is declared in sys/stat.h:

    struct stat {
        dev_t  st_dev;   /* ID of device containing */
                         /* a directory entry for this file*/
        ino_t  st_ino;   /* File inode number */
        ushort st_mode;  /* File mode */
        short  st_nlink; /* Number of links */
        ushort st_uid;   /* User ID of the file's owner */
        ushort st_gid;   /* Group ID of the file's group */
        dev_t  st_rdev;  /* ID of device - only for */
                         /* character or block special */
        off_t  st_size;  /* File size in bytes */
        time_t st_atime; /* Time of last access */
        time_t st_mtime; /* Time of last data modification */
        time_t st_ctime; /* Time of last file status change*/
                         /* Time measured in seconds since */
                         /* 00:00:00 GMT, Jan. 1, 1970 */
    };

• int fstat(int Descriptor,struct stat *StatusBuffer);
  • fstat performs the same function as stat on an open file whos file descriptor is known.
• GetFileStatus.c

• char *getcwd(char *buf, size_t size) - Get the full pathname of the current working directory.
  • Returns a pointer to the current directory pathname.
  • If buf is not NULL, the pathname will be stored in the space pointed to by buf. If buf is NULL, getcwd() will obtain size bytes of space using malloc.
• int chdir(char *path) - Changes directory to specified path string, for the program.
  • MyCD.c - Program that changes its working directory
• int mkdir(const char *Path, mode_t Mode);
  • mkdir creates the directory Path with permissions Mode
  • Returns 0 on success and -1 on error
• Reading directories
  • DIR * opendir(const char *Directory);
    • opendir opens the Directory and returns a pointer to a directory stream.
    • Returns NULL on error
  • struct dirent * readdir(DIR *DirectoryStream);
    • readdir returns a pointer to the next directory entry
    • struct dirent is defined in sys/dirent.h:

      struct dirent {
          int  d_fileno;    /* file number of entry */
          int  d_reclen;    /* length of this record */
          int  d_type;      /* file type */
          int  d_namlen;    /* length of string in d_name */
          char d_name[255 + 1];    /* name must be no longer than this */
      };

    • Returns NULL on eof or error
  • int closedir(DIR *DirectoryStream);
    • closedir closes the directory stream
    • Returns 0 on success and -1 on error
  • Directory.c

• int utimes(char *Filename,struct timeval *Times);
  • utimes sets the access and modification times of a file
  • struct timeval is defined in sys/time.h

    struct timeval {
        long    tv_sec;         /* seconds since Jan. 1, 1970 */
        long    tv_usec;        /* and microseconds */
        };

  • If Times is NULL then the current time is used.
  • Returns -1 on error
• int chmod(char *Path,int Mode);
  • chmod changes the permission, sticky and set-ID bits of Path
  • A Mode is created from or'd permission bit masks defined in sys/stat.h:

    #define S_IRWXU 0000700    /* RWX mask for owner */
    #define S_IRUSR 0000400    /* R for owner */
    #define S_IWUSR 0000200    /* W for owner */
    #define S_IXUSR 0000100    /* X for owner */
    
    #define S_IRWXG 0000070    /* RWX mask for group */
    #define S_IRGRP 0000040    /* R for group */
    #define S_IWGRP 0000020    /* W for group */
    #define S_IXGRP 0000010    /* X for group */
    
    #define S_IRWXO 0000007    /* RWX mask for other */
    #define S_IROTH 0000004    /* R for other */
    #define S_IWOTH 0000002    /* W for other */
    #define S_IXOTH 0000001    /* X for other */
    
    #define S_ISUID 0004000    /* set user id on execution */
    #define S_ISGID 0002000    /* set group id on execution */
    #define S_ISVTX 0001000    /* sticky bit */

  • The caller's effective UID must match the file's owner UID, or the caller must be the superuser.
  • Only the superuser can turn on the sticky bit.
  • Returns -1 on error
• int chown(char *Path,int Owner,int Group);
  • chown changes the owner UID and GID of a file
  • The owner of a file may change the group to a group of which he or she is a member, but the change owner capability is restricted to the super-user.
  • Returns -1 on error
• SetFileStatus.c

• Recall the way files are linked in UNIX.
• int link(char *OldName,char *NewName);
  • link creates a hard link between the existing file OldName and the NewName
  • Only the super user can link to a directory, to prevent circular chains.
  • Returns -1 on error, 0 otherwise.
• int unlink(char *Pathname);
  • unlink removes a directory entry.
  • The associated inode has its count field decremented, and the file is deleted if the count reaches 0 (delayed when the file is open to anyone).
  • Returns -1 on error, 0 otherwise.
• MoveFile.c
• If a file is still open to a process when its count reaches 0 it is not deleted until it is closed. This can be used to ensure files are deleted even if the process crashes. e.g.

  Descriptor = open("temp_file",MODE);
  unlink("temp_file");
     . . . . .
  /*----processing that may crash */
     . . . . .
  close(Descriptor);

• int symlink(const char *Target, const char *LinkPath);
  • int symlink creates a symbolic link from the LinkPath to the Target.
  • Returns -1 on error, 0 otherwise.

• Named pipes are permanent fixtures in the file system, and provide pipe communication between processes.
• At the command prompt

  prompt> mknod MyPipeName p 

  or (FreeBSD)

  prompt> mkfifo MyPipeName 

  or write a program using the same named system calls.
• FIFOs can be used just like files.
• A named pipe cannot be written to or read from until it is open for both writing and reading. An open for writing (reading) blocks until there is a simultaneous open for reading (writing).
• FIFOWrite.c - Program that writes to a named pipe
  FIFORead.c - Program that reads from a named pipe

CSC322 STOPS HERE

• int open(char *Pathname,int OpenFlag[,int AccessPerms]);
  • open returns a file descriptor, -1 on error
  • The OpenFlag indicates whether the file is to opened for reading, writing or updating. It is created by taking the inclusive-OR of a number of possible values defined in file /usr/include/fcntl.h
    • O_RDONLY - open for reading
      O_WRONLY - open for writing
      O_RDWR - open for reading and writing
      Exactly one of these must be used in combination with any of the others.
    • O_NDELAY - if the file is being opened as a pipe then opening for reading will return immediately and opening for writing will return an error if no process has the file open for reading. If the file is being opened as a communications line then the file will open without waiting for a carrier.
    • O_APPEND - sets the file pointer to the end of the file when opening for writing.
    • O_SYNC - sets synchronous write option
    • O_CREAT - if the file already exists the O_CREAT has no effect, but if it does not exist it is created with the access permissions being passed in the optional 3rd parameter.
    • O_TRUNC - if the file already exists then its length is set back to 0.
    • O_EXCL - if O_CREAT and O_EXCL are both set then the open call will fail if the file already exists. This prevents copies of a file being overwritten.
  • The access permissions are included if the file is being created
• int write(int Descriptor,char *Buffer,int NumberOfBytes);
  • write writes NumberOfBytes bytes to the Descriptor from the Buffer
  • Returns the number of bytes written, or -1 on error.
• int read(int Descriptor,char *Buffer,int NumberOfBytes);
  • read reads NumberOfBytes bytes from the Descriptor into the Buffer
  • Returns the number of bytes read, 0 on eof, or -1 on error.
• lseek(int Descriptor,long Offset,int Origin);
  • lseek moves the file pointer of the Descriptor to Offset bytes from Origin.
  • Origin can be 0, 1 or 2 indicating that the offset is relative to the beginning, current position or end of the file respectively.
  • Returns the resulting offset location as measured in bytes from the beginning of the file, or -1 on error.
  • The fseek call handling is implemented
• close(int Descriptor);
  • close breaks the link between the Descriptor and the file.
  • Returns -1 on error
• FileOps.c - Program to copy via a buffer
• LowLevelWrite.c - Program to read floats at the byte level
• LowLevelRead.c - Program to read floats at the byte level

• In cases where multiple files are being read/written, and the devices are slower than the process, it is necessary to find which devices are ready, and use that one.
• int select(int nfds,fd_set *readfds,fd_set *writefds, fd_set *exceptfds,struct timeval *timeout); - Examines the I/O descriptor sets whose addresses are passed in readfds, writefds, and exceptfds to see if some of their descriptors are ready for reading, are ready for writing, or have an exceptional condition pending, respectively.
  • The first nfds descriptors are checked in each set.
  • On return, select() replaces the given descriptor sets with subsets consisting of those descriptors that are ready for the requested operation.
  • Select() returns the total number of ready descriptors in all the sets, or -1 if an error occurs.
  • Macros are provided for manipulating such descriptor sets:
    • FD_ZERO(&fdset) initializes a descriptor set fdset to the null set.
    • FD_SET(fd,&fdset) includes a particular descriptor fd in fdset.
    • FD_CLR(fd,&fdset) removes fd from fdset.
    • FD_ISSET(fd,&fdset) is non-zero if fd is a member of fdset, zero otherwise.
  • If timeout is a non-null pointer, it specifies the maximum interval to wait for the selection to complete. If timeout is NULL, the select blocks indefinitely.
  • Any of readfds, writefds, and exceptfds may be NULL if no descriptors are of interest.
• SelectReadFiles.c - Program that reads from multiple files using select

• Unnamed pipes can be used to implement communication between processes.
• The processes have to be related through a fork due to the data structure.
• The system call
  int pipe(int Descriptors[2]);
  creates a bidirectional pipe
• By tradition, if a pipe is used for unidirectional communication then the pipe is written to in Descriptors[1] and read from Descriptors[0]
• Pipe.c - Program to transfer data through a pipe
• TwoPipes.c - Program that reads from two pipes using select

• int dup(int oldd); - Duplicates an existing object descriptor and returns its value. The first free descriptor is used for the copy.
• Dup.c - Program that dups standard output
• int dup2(int oldd, int newd); - Like dup, but specifies the new descriptor. If it's already in use then it is closed first.
• PipeStdin.c - Program that redirects stdin
• Need an example to show command line piping.