UNIX File Systems

Last modified Tuesday, 18-Nov-2025 13:50:29 UTC.

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 whose file descriptor is known.

GetFileStatus.c

UNIX directories
- 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

Setting file status

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

Linking and unlinking
- 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
- 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).
- FIFORead.c - Program that creates and reads from a named pipe
  FIFOWrite.c - Program that writes to a named pipe
Flushing buffers
- I/O is buffered, but the sync call can be used to schedule the output of buffers.
- void sync(void);
- sync does not actually write out the buffers, merely requests the hardware to do so, and it will as soon as possible.
CSC322 STOPS HERE
File System Structure
- A file system consists of randomly accessible data blocks. The size of a block is given in sys/param.h as BSIZE, and is typically 512 or 1024 bytes.
- The area of disc set aside for a file system is split into 4 regions:
  - Block 0 is set aside for a bootstrap program if required
  - Block 1 contains the superblock which describes the file system as a whole, including free blocks and inodes lists.
  - Block 2 starts the inode area (fixed size)
  - Remaining blocks are allocated to files
Inodes
- Each file is identified by an index node (inode).
- Inodes are numbered from 1
  - Inode 1 is reserved for the bad blocks list. In modern UNIX systems this is used only when the disk is mounted. Bad block management internally at the firmware level - when a drive detects a bad block, it silently remaps it to a reserved, good block pool without involving the file system.
  - Inode 2 for the root directory of the file system.
- Inodes contain detailed information about the file
  - Type of file and access permissions.
  - Number of links to this inode (see below)
  - User and group IDs of the file owner.
  - Size of file in bytes for files, device number for devices.
  - Addresses of the files data blocks.
  - Times of creation, last access, and last modification
- A UNIX directory entry contains a file name and inode number
  - It is possible for more than one entry to have the same inode number
  - A file cannot be deleted until the number of links to the inode is 0
Opening, reading, writing and closing files
Selecting ready files
- 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
- Pipe.c - Program to transfer data through a pipe
- TwoPipes.c - Program that reads from two pipes using select
Redirecting from within a program
- 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.

Exercises

Write the program touch, which takes a file name as its argument and changes the modification and access times of the file to the current time.
Write a directory listing program that takes one or more of the following flags :
- -u uid : Only list files owned by uid
- -g uid : Only list files in the group gid
- -m days : Only list files which have been modified in the last days days.
- -a days : Only list files which have been accessed in the last days days.
- -s size : Only list files that are larger than size bytes.
- -r : List subdirectories recursively.
Write a program that will list all files in a current directory and all files in subsequent subdirectories.
Write a program that shows the user all his/her C source programs and then prompts interactively as to whether others should be granted read permission; if affirmative such permission should be granted.
Write a program that gives the user the opportunity to remove any or all of the files in a current working directory. The name of the file should appear followed by a prompt as to whether it should be removed.

Exam Style Questions

The read system call is declared as:
```
int read(int Descriptor,char *Buffer,int NumberOfBytes); 
```
and the write system call is declared as:
```
int write(int Descriptor,char *Buffer,int NumberOfBytes); 
```
Complete the internals of the following function, which must copy data from the ReadDescriptor to the WriteDescriptor until end-of-file on the ReadDescriptor, and then close both descriptors. Both descriptors are already open when passed into the function.
```
void CopyData(int ReadDescriptor,int WriteDescriptor) {

} 
```
How is it possible to increase the size of a file, without explicitly appending data to the end?
Describe two direct ways to find out how many names (links from directory entries) a file has? (No search the whole file system!)
Which system calls allow you to find out and set the last modification time of a file?
Explain the structure and contents of the st_mode field of a struct stat.
The link system call is declared as:
```
int link(char *OldName,char *NewName); 
```
and the unlink system call is declared as:
```
int unlink(char *Pathname);  
```
Write a function that takes two filenames as string parameters, and renames the first named file to the second name.
Explain how the select system call is used to allow a program to read data from multiple sources.
What are the differences between named and unnamed pipes?
What is the effect of the dup (not dup2) system call?

UNIX File Systems

CSC322 STOPS HERE

Exercises

Exam Style Questions