L5/6: Files and Directories Flashcards
Six Main Topics
in the
Systems Programming Class
Program Development
Files and Directories
Tool Building
Processes
Networking
OS Implementation
Shell Command Equivalents:
mv
From stdio.h library:
rename( old_filepath, new_filepath);
Equivalent to:
%mv old new
Shell Command Equivalents:
ln
From unistd.h library:
link( old_filepath, new_filepath);
Equivalent to:
%ln old new
Shell Command Equivalents:
rm
From unistd.h library:
unlink( “old_file” );
Equivalent to:
%rm old_file
Shell Command Equivalents:
rm -r
From stdio.h library:
remove( “old_file” );
Equivalent to:
%rm -r old_file
Shell Command Equivalents:
cp
No direct method.
Use read/write File I/O operations
to copy old file to new.
Equivalent to:
%cp old new
Shell Command Equivalents:
cd
From unistd.h library:
chdir( “path” );
Equivalent to:
%cd path
Shell Command Equivalents:
mkdir
From unistd.h library:
mkdir( “newpath”, 0777);
Note: Not sure what the 0777 flag does
Equivalent to:
%mkdir newpath
Shell Command Equivalents:
rmdir
From unistd.h library:
rmdir( “path”);
Equivalent to:
%rmdir path
unistd.h
Methods that are equivalent to
common shell commands (5)
- link()
- equivalent to “ln”
- unlink()
- equivalent to “rm”
- chdir()
- equivalent to “chdir”
- mkdir()
- equivalent to “mkdir”
- rmdir()
- equivalent to “rmdir”
Physical Disk Organization:
Partition Sections
- boot and superblocks
- ilist
- contains inodes
- datablocks
Physical Disk Organization:
inode structure
An inode consists of
- a status block
- addresses to multiple data blocks
Physical Disk Organization:
Key Points
- Disk is arranged into blocks
- some for data
- some for management
- Each inode corresponds to one file and the data blocks associated with that file
- Physical layout is not consecutive, file blocks can be all over the place
How many data blocks can an inode point to?
13
How do inodes handle larger file sizes?
- The inode only has 13 pointers, so an indirect approach is used
- File blocks can each contain many pointers
- Pointers are classified into levels L0, L1, L2, …
- This allows a hierarchy of blocks to be created to handle arbitrary file sizes
- Level L0 is a pointer that points directly to an actual datablock
- L1 points to a block of L0 pointers, L2 to a block of L1 pointers, and so on.
Directory Access Rules (3)
- Search Rule
- to open a file, the user or program must have execute permission on each directory in the full pathname
- Write Rule
- to create or delete a file, must have write access to directory
- Read Rule
- to read file names, must have read access on the directory
inodes:
Design Consequences
for
Move Operations
- Move speed is independent of the file size
- data blocks do not have to be moved around
- only the pointers change(unless moving partitions/drives)
- Moves are easy to implement as atomic operations
Structure of a
Directory
- The directory is a specific type of file
- Contains a table of inodes paired with filenames
- inodes are identified with inode numbers
- The table contains a reference to the directory itself (.)
- and to it’s parent directory( .. )
Directory Structure:
How do Link(ln) operations work?
- Works similarly to move operation, but old reference is kept
- The inode number is copied from the first directory’s table and added to the second specified directory’s table with a new filename
- Both directories now have a reference to the same inode, but may have different names for the same file.
- File data is not duplicated
- Example:
ln dir_1/myFile dir_2/myFile2
Directory Structure:
How Move (mv)
operations work
- Physical data is not moved around on the disk, and will keep the same inode
- The inode number is copied from the table in the source directory
- Then added to the table in the destination directory with a new filename
- The old reference is then deleted from the table in the source directory
- Example:
mv dir_1/derp.txt dir_2/samederp.txt
Physical Disk Organization:
Common Data Block Size
Pointer Size
Block Size: 512 bytes
Pointer Size: 4 bytes
Disk Structure:
How data is accessed by a programmer
- A programmer can get to data only through an inode.
- Data is “seen” as a simple, expandable array of bytes
- Physical and “housekeeping” details are invisible to the programmer
Which Operations( Access Modes)
are files protected for?
Each file is protected for:
- read
- write
- execute
3 Identities for File Access
Access (bits)permissions are defined for:
- user
- group
- other
How do Unix/Linux systems
distinguish
Users and Groups?
Each User has a unique identifier
- uid
- The etc/passwd file matches the user name and uid
Each User belongs to one or more groups
Each Group is identified by a unique identifier
- gid
- The etc/groups file matches group names and gid
Where are uid’s and user names stored?
etc/passwd
This matches user names to uid
Where are group id’s (gid) and names stored?
etc/groups
matches group names and gid
What is the “stat” structure?
A structure that can be obtained at runtime,
it contains statistics and information about a specific file.
Often used to check the access mode bits on a file before attempting to use it.
Important fields of the “stat” structure (9)
Given a stat structure “s”
Not comprehensive.
- st_ino - inode
- st_nlink - link count
- st_uid - user id of the file
- st_gid - group id of the file
- st_mode - mode bits
- st_atime - last access time
- st_ctime - creation time
- st_mtime - last modification time
- st_size - size of the file
Difference between
real uid
and
effective uid
Real uid
- the uid of the actual user who is logged in
Effective uid
- uid temporarily used for the lifetime of a process
Most of the time, the effective uid and real uid are the same,
but Administrative programs are able to operate with a different uid than the invoker.
How to get the
Status of a file
(in code)
Need to use the “stat” struct
- located in the “sys/stat.h” library
Use one of the functions:
- stat( “pathname”, stat s)
- fstat()
- lstat()
To return a stat structure, placed in s
Then check s->st_mode to determine the file type and if the program has the correct permissions to access
File Status:
Helpful operations defined in
sys/stat.h
(2)
S_ISREG(m)
- Check if the file is a regular file
- pass the stat struct as the parameter “m”
- if( S_ISREG( s->st_mode) ) …
S_ISDIR(m)
- Check if the file is a directory
- if ( S_ISDIR( s->st_mode) ) …
stat structure:
How to check permissions
the sys/stat.h header file defines some useful values to use as bitmasks to check against s->st_mode:
- User permissions:
- S_IRUSR, S_IWUSR, S_IXUSR
- Group permissions:
- S_IRGRP, S_IWGRP, S_IXGRP
- Other permissions:
- S_IROTH, S_IWOTH, S_IXOTH
These can be “anded” against s->st_mode:
- if (s->st_mode && S_IRUSR) …
inodes and Datablocks
are reclaimed only
when ________
Two conditions are met:
- The Link Count becomes 0
- The number of “opens” becomes 0
How to change the
Effective uid
of a program?
- Must use the “set-uid” bit on executables
- The Super User must turn on the set-uid bit for trusted programs
- The effective uid becomes that of the executable’s owner for the duration of the process
Turning on the set-uid bit:
Use chmod, as super user. It is the 4th of the permission bits:
-rws –x –x
Symbolic Links:
Overview
- A special file type that simply contains the name of another file
- Different from regular links, called “hard links”
- All file operations attempted on a symbolic link will follow the link and affect the destination file
- Created using command:
- ln -s
- Also called sym links
How to list inodes on the shell
ls -i
Design Consequences of Inodes
- Directories reference files only through inode numbers
- moving files between directories is very fast
- and, the operation is atomic (as are link and remove)
- Two directories can include the same inode number
- a file can be shared, appearing in several places with same or different name
- also, no special cases for “shortcuts” etc.
- Space is freed only when inode link & open counts are both 0
- removing a file may not create free space
- files can’t disappear while a process is working on them
- also, no special cases for “sharing violation” etc.
- An inode number is unique only within a file system
- files can’t span partitions or disks, or be moved to new disks
- and, files can’t be bigger than a single physical disk
- Files don’t have “type” (beyond regular vs. directory)
- no optimizations for databases, no self-identifying objects, no new types
- but, easy to code general programs such as “cp”, “mv”
- Plus, as we will see, file security information is in the inode
- data is protected even when files are shared (details later)
