Managing Files and Directories

Chris Brown
 In This Module

File System Structure Working with Directories

Links, inodes, directories Creating, deleting, listing

Advanced Techniques Demonstration:

Monitoring file events Directory listing
 File System Structure
inode
Directory 1 File permissions
2 Owner and group
Time stamps
3

foo 5 4

5
bar 3 inode table Here is the data

Link
 Examining File Attributes

Pathname of the Pointer to a

file to be opened stat structure
struct stat {

stat(name, buf) };
fstat(fd, buf)
Open file
descriptor
Returns 0 on success,
-1 on failure
 The stat Structure
struct stat {
dev_t st_dev; /* ID of device containing file */
ino_t st_ino; /* inode number */
mode_t st_mode; /* protection */
nlink_t st_nlink; /* number of hard links */
uid_t st_uid; /* user ID of owner */
gid_t st_gid; /* group ID of owner */
dev_t st_rdev; /* device ID (if special file) */
off_t st_size; /* total size, in bytes */
blksize_t st_blksize; /* blocksize for filesystem I/O */
blkcnt_t st_blocks; /* number of 512B blocks allocated */
time_t st_atime; /* time of last access */
time_t st_mtime; /* time of last modification */
time_t st_ctime; /* time of last status change */
};
 Time Stamps

st_atime Time of last access

st_mtime Time of last modification

st_ctime Time of last status change (inode)

The creation time of a file is not recorded

 File Type and Permissions
st_mode
s g t r w x r w x r w x
File Type
Owner
0010000 FIFO (pipe) permissions Group
0020000 character device
0040000 directory
permissions Other
0060000 block device permissions
0100000 regular file
"Sticky bit"
0120000 symbolic link Set GID
0140000 socket
Set UID
 Useful Macros
st_mode
s g t r w x r w x r w x
File Type

S_ISUID
S_ISGID
S_ISVTX
S_IRUSR
S_IWUSR
S_IXUSR
S_IRGRP
S_IWGRP
S_IXGRP
S_IROTH
S_IWOTH
S_IXOTH
S_ISREG
S_ISDIR
S_ISCHR if (statbuf.st_mode & S_IWOTH)
S_ISBLK printf("file is world writeable");
S_ISFIFO
S_ISLNK if (S_ISREG(statbuf.st_mode))
S_ISSOCK printf("regular file");
 Creating Files

Includes O_CREAT

open(name, flags, mode)

Pathname Access mode of the file

creat(name, mode)
 Creating and Removing Links

link(oldname, newname)
Gives the file an additional name

unlink(name)
If this is the last remaining link
the file is deleted
Deletion is postponed if a
process has the file open
 Creating and Removing Links
Directory 1
open("foo", O_CREAT, 0644);
2
3
link("foo", "bar");
foo 3 4

5 unlink("foo");
bar 3 Inode
table
 Creating and Removing Links
Directory 1
open("foo", O_CREAT, 0644);
2
3
link("foo", "bar");
4

5 unlink("foo");
bar 3 Inode
table
 Symbolic Links

A symbolic link is a file that contains

the name of another file
Similar to a shortcut on Windows
Symbolic links can do things that
hard links cannot
- Link to directories
- Link across file system boundaries
 Creating Symbolic Links

symlink(oldname, newname)

unlink(name)
Removes the symlink, not the target file
 Hard Links vs. Symbolic Links

Hard Link Symbolic Link

inode Another
Name Name
number name
 To Follow or Not to Follow
Some system calls follow symbolic links:

open(), read(), write()

Symlink Target file

Some don't
unlink()
Interacting with Directories

The current directory

Creating and deleting directories
Reading directories
The Current Directory

Every process has a "current directory"

Relative path names are interpreted relative to this
Suggest
PATH_MAX bytes

getcwd(buf, size)

Result here
The Current Directory

A process can change its current directory

chdir(pathname)
Creating and Deleting Directories

mkdir(name, mode)
This will only create one directory
mkdir("a/b/c", 0755) will fail unless a, b exist

rmdir(name)
Fails unless the directory is empty
 Reading Directories

d = opendir(dirname)
struct dirent
loop
d_ino /* inode number */
d_type /* file type */
d_name /* file name */
info = readdir(d)

closedir(d)
 Directory Traversal Example
/* Add up sizes of all files in the current directory */

#include <stdio.h>
#include <sys/stat.h>
#include <dirent.h>

void main()
{
DIR *d;
struct dirent *info; /* A directory entry */
struct stat sb; /* The stat buffer */
long total = 0; /* Total of file sizes */
 Directory Traversal Example

d = opendir(".");

while ((info = readdir(d)) != NULL) {

stat(info->d_name, &sb);
total += sb.st_size;
}

closedir(d);

printf("total size = %ld\n", total);

}
 Doing It in Python
Most of the calls we've seen here are available in the os module:
Function Description
os.stat(path) Returns a stat_result instance,
similar to a stat structure
os.link(src, dst) Create a new hard link
os.symlink(src, dst) Create a symbolic link
os.chdir(path) Change directory
os.getcwd() Get current working directory

No direct equivalents to opendir/readdir, use listdir instead

 Python Directory Traversal
#! /usr/bin/python3
# Add up sizes of all files in the current directory

import os
total = 0

for file in os.listdir(".") :

statinfo = os.stat(file)
total = total + statinfo.st_size

print ("total is", total)

Monitoring File System Events

The inotify API

Creating an inotify instance
Adding to the watch list
Reading events
 File System Events
I've been
I've been accessed!
moved!

I've been
I've been modified!
created!

I've been
I've been deleted!
closed!

Individual files or whole directories can be watched

 Three Steps
Create inotify instance
(file descriptor)

Add watch item

````

Read and process events

````
Creating an inotify Instance

fd = inotify_init()

Returns a file descriptor on which

we can later read() the events.
 Adding a watch Item
File descriptor of Name of file or directory
inotify instance to be watched.

wd = inotify_add_watch(fd, path, mask)

Bit mask specifying

Returns a watch descriptor (small the events to be
integer) identifying this watch monitored
 Watches and Events in Detail
Each event is specified by a single-bit constant
-- bitwise OR them together
Bit value Meaning
IN_ACCESS File was accessed
IN_ATTRIB File attributes changed (ownership, permissions etc.)
IN_CREAT File created inside watched directory
IN_DELETE File deleted inside watched directory
IN_DELETE_SELF Watched file deleted
IN_MODIFY File was modified
IN_MOVE_SELF File was moved
 Watch Items
Events of interest
inotify for this path
instance
1 path mask
watch
2 path mask items
3 path mask

Watch
Path name of file or
descriptors
directory to be watched
 Reading Events
wd
File descriptor mask
struct
from inotify_init() cookie inotify_event
len
name
n = read(fd, buf, size)
n padding len

The read will block until Next

a watched event occurs event
record
More than one event may be
returned in a single read
Demonstration

Read a list of files (not directories)

from a configuration file

Watch them for modification

or deletion

Report changes to a log file

Module Summary

File system structure

inodes and the stat structure
Links and symbolic links
Directories
Current directory
Creation, deletion
Traversal
Monitoring file system events
inotify
Coming up in the Next Module

Accessing the command line

The Environment

Time