The Unix File System

The Unix file system is a methodology for logically organizing and storing large quantities of data such that the system is easy to manage. A file can be informally defined as a collection of (typically related) data, which can be logically viewed as a stream of bytes (i.e. characters). A file is the smallest unit of storage in the Unix file system.

By contrast, a file system consists of files, relationships to other files, as well as the attributes of each file. File attributes are information relating to the file, but do not include the data contained within a file. File attributes for a generic operating system might include (but are not limited to):

• a file type (i.e. what kind of data is in the file)
• a file name (which may or may not include an extension)
• a physical file size
• a file owner
• file protection/privacy capability
• file time stamp (time and date created/modified)

From the beginners perspective, the Unix file system is essentially composed of files and directories. Directories are special files that may contain other files.

The Unix file system has a hierarchical (or tree-like) structure with its highest level directory called root (denoted by /, pronounced slash). Immediately below the root level directory are several subdirectories, most of which contain system files. Below this can exist system files, application files, and/or user data files. Similar to the concept of the process parent-child relationship, all files on a Unix system are related to one another. That is, files also have a parent-child existence. Thus, all files (except one) share a common parental link, the top-most file (i.e. /) being the exception.

Below is a diagram (slice) of a "typical" Unix file system. As you can see, the top-most directory is / (slash), with the directories directly beneath being system directories. Note that as Unix implementaions and vendors vary, so will this file system hierarchy. However, the organization of most file systems is similar.

File Types

How can this be, you ask? Since all data is essentially a stream of bytes, each device can be viewed logically as a file.

All files in the Unix file system can be loosely categorized into 3 types, specifically:

1. ordinary files
2. directory files
3. device files ¹

The first type of file listed above is an ordinary file, that is, a file with no "special-ness". Ordinary files are comprised of streams of data (bytes) stored on some physical device. Examples of ordinary files include simple text files, application data files, files containing high-level source code, executable text files, and binary image files. Note that unlike some other OS implementations, files do not have to be binary Images to be executable (more on this to come).

The second type of file listed above is a special file called a directory (please don't call it a folder?). Directory files act as a container for other files, of any category. Thus we can have a directory file contained within a directory file (this is commonly referred to as a subdirectory). Directory files don't contain data in the user sense of data, they merely contain references to the files contained within them.

It is perhaps noteworthy at this point to mention that any "file" that has files directly below (contained within) it in the hierarchy must be a directory, and any "file" that does not have files below it in the hierarchy can be an ordinary file, or a directory, albeit empty.

The third category of file mentioned above is a device file. This is another special file that is used to describe a physical device, such as a printer or a portable drive. This file contains no data whatsoever, it merely maps any data coming its way to the physical device it describes.

¹ Device file types typically include: character device files, block device files, Unix domain sockets, named pipes and symbolic links. However, not all of these file types may be present across various Unix implementations.

File System Navigation

By rule, Unix file names do not have to have ending extensions (such as .txt or .exe) as do some other operating systems. However, certain applications with which you interact may require extensions, such as Adobe's Acrobat Reader (.pdf) or a web browser (.html). And as always character case matters (don't tell me you have forgotten this already?). Thus the following are all valid Unix file names (note these may be any file type):

	My_Stuff		a file named My_Stuff
	my_stuff		a different file than above
	mortgage.c		a C language program...can you guess what it does?
	a.out			a C language binary executable
	.profile		ksh default startup file

While file names are certainly important, there is another important related concept, and that is the concept of a file specification¹ (or file spec for short). A file spec may simply consist of a file name, or it might also include more information about a file, such as where is resides in the overall file system. There are 2 techniques for describing file specifications, absolute and relative.

With absolute file specifications, the file specification always begins from the root directory, complete and unambiguous. Absolute file specs are sometimes referred to as fully qualified path names². Thus, absolute file specs always begin with /. For example, the following are all absolute file specs from the diagram above:

	/etc/passwd
	/bin
	/usr/bin
	/home/mthomas/bin
	/home/mthomas/class_stuff/foo

With relative file specifications, the file specification always is related to the users current position or location in the file system. Thus, the beginning (left-most part) of a relative file spec describes either:

• an ordinary file, which implies the file is contained within the current directory
  
• a directory, which implies a child of the current directory (i.e. one level down)
  
• a reference to the parent of the current directory (i.e. one level up)

What this means then is that a relative file specification that is valid from one file system position is probably not valid from another location. Beginning users often ask "How do I know where I am?" The command to use to find this is the pwd (print working directory) command, which will indicate the users current position (in absolute form) in the file system.

As mentioned abpve, part of a relative file specification can be a reference to a parent directory. The way one references a parent (of the current) directory is with the characters .. (pronounced dot-dot). These characters (with no separating spaces) describe the parent directory relative to the current directory, again, one directory level up in the file system. Note that more than one level up (a parents parent, for example) can be referenced with ../.., up two levels in this example.

The following are examples referencing the diagram above:

To identify where we are, we type and the system returns the following:

	$ pwd [Enter]
	/home/mthomas/class_stuff	

Thus the parent of this directory is:

	/home/mthomas		# in absolute form
	..			# in relative form

Looking at another example:

	$ pwd [Enter]
	/home/mthomas	

Thus the parent of this directory is:

	/home			# in absolute form
	..			# in relative form


And one (note there could be many) child of the /home/mthomas directory is:

	/home/mthomas/bin	# in absolute form
	bin			# in relative form

	$ cd [Enter]

	$ cd file_spec [Enter]

As before, we type and the system returns the following:

	$ pwd [Enter]
	/home/mthomas/class_stuff

If we wish to change directories to the /home/mthomas/bin directory, we can type

	$ cd /home/mthomas/bin [Enter]		# absolute, will work from anywhere

or

	$ cd .. [Enter]		# relative, move up one directory, i.e. to the parent
	$ cd bin [Enter]	# relative, move down to the bin directory

or

	$ cd ../bin [Enter]	# relative, both steps in one file spec

Novice users sometimes ask which file specification method should they use, or which one is better. The simple and open ended answer is "it depends." That is it depends upon where one currently is in the file system hierarchy, and what one is trying to do. This also depends upon how long the file specification is, or how easy it is to type, including any special characters, or how familiar one is with the current location in the file system hierarchy, etc.

Take some time to navigate the file system of your Unix implementation and see how it compares to the diagram above.

¹ Some might choose to call this a path name or path specifier, but I prefer to call this a file specification since all the individual components are files.

² Fully qualified path names, also referred to as FQPN, are frequently used by system administrators who are used to working with DNS. More information can be found by searching on fully qualified path names in your favorite search engine.

³ A user can also move to their "home" directory using the command cd ~ (tilde), where the ~ character represents a users "home" directory. If used in this simple way, cd and cd ~ are equivalent. However, much more sophisticated behaviorcan be achieved using the ~ character as described here.

Additional File Attributes

From the above output, we can observe 7 attribute fields listed for each file. From right to left, the attribute fields are:

• file name: the name associated with the file (recall, this can be any type of file)

• modification date: the date the file was last modified, i.e. a "time-stamp". If the file has not been modified within the last year (or six months for Linux), the year of last modification is displayed.

• size: the size of the file in bytes (i.e. characters).²

• group: associated group for the file

• owner: the owner of the file

• number of links: the number of other links associated with this file

• permission modes: the permissions assigned to the file for the owner, the group and all others.

² This is the number of characters in the file, not necessarily the size on disk, since files are written to disk in 1024 byte blocks. Note also if the file is a directory, this is the size of the structure needed to manage the directory hierarchy.

Understanding and Modifying File Permissions

The first (leftmost) character indicates the "type" of the file. Another way to describe this is whether the file has any special attributes associated with it. If it is an ordinary file (i.e. no special attributes), it will have a dash in this first position. If it is a directory file, it will have the letter d in this position. Or, if it is a link to another file it will have the letter l (ell) in this first position. You can see examples of an ordinary file and a directory in the ls -l output above. Other special attributes exist but do not merit discussion here.

The next 9 characters are arranged in 3 groups of 3 characters each; that is 3 characters to describe the permissions for the owner of the file, 3 characters to describe the permissions for the group and 3 characters for all other users permissions. The 3 characters indicate whether the particular user has read (denoted by r), write (denoted by w), or execute (denoted by x) permissions on that particular file. Thus in the diagram above, the owner of the file has all available permissions (indicated by rwx), a user belonging to this group has read and execute (indicated by r-x) permissions, and everyone else also has read and execute permissions. Observe if a user does not have a particular permission, a dash will appear instead of the corresponding letter.

Changing the permission of an existing file is accomplished using the chmod command, that is to change file protection modes. Changing the permission for a file (or files) can only be done by the owner of the file (or the root user). The usage of this command (using octal mode ¹) is

	chmod ijk file(s)

	chmod 755 file_spec(s)

To illustrate with another example, if the owner of a file wanted to set read and execute for the user permissions, read only for group permissions and disable all permissions for all others, the command to set this would be

	chmod 540 file_spec(s)

	-r-xr-----		#assuming an ordinary file

The permissions of read, write and execute take on a slightly different meaning with respect to directory files. Thus if a file is a directory:

• read permission determines if a user can view the files contained in a directory, i.e. list the files in it

• write permission determines if a user can create new files or delete files in the directory. This allows a user with write permission to a directory to have the ability to delete files in the directory even if they don't have write permissions for the file (see Note: on rm below). Watch out for this gotcha!

• execute permission determines if the user can move (i.e. cd) into the directory

Where chmod sets permissions on existing files, setting default file permissions set upon file creation is done using the umask command. This is somewhat similar to chmod, but the permissions are set on newly created files only. While similar to chmod, rather than setting which permissions are set, umask sets which permissions are "removed" or unset.

General syntax is as follows:

	umask [-S] [mode] 

	$ umask [Enter]
	022

	$ umask -S [Enter]
	u=rwx,g=rx,o=rx

Octal digit in umask command	Permissions disabled during file creation
0	none, all original permissions will remain
1	execute permission is disabled
2	write permission is disabled
3	write and execute permission are disabled
4	read permission is disabled
5	read and execute permissions are disabled
6	read and write permission are disabled
7	all permissions are disabled

Recall that chmod value of 4 for an owner, group or other grants read access. As mentioned, umask is somewhat the opposite of chmod. A umask mode of 4 disables read access for that owner, group or other. The most common setting for umask mode value is 022, set as follows:

	$ umask 022[Enter]

	$ umask 077[Enter]

Note there is no file specification present in the umask command since this command sets the default mode for all newly created files (and directories).

² One can use the table to see what umask values set what, but one can also use binary logic to calculate this. This works as each default octal digit is ANDed with the NOTed value of each umask octal digit. For example, if the default digit is 7 (111₂), and your umask digit is 2 (010₂), then the binary values of 111 AND NOT 010 = 111 AND 101 = 101 = 5 (r-x), i.e. write permission disabled (see table above). Similarly, if the starting default digit is 6 (110₂), and your umask digit is 2 (010₂) then the binary values of 110 AND NOT 010 = 110 AND 101 = 100 = 4 (r--), again write permission disabled. The latter example is documented in the man pages as 666 & ~022 = 644; i.e., rw-r--r--.

Additional File System Manipulation

Creating new ordinary files is typically done using application programs. These application programs can be as sophisticated as a large computer-aided design programs (CAD) or as simple as a text editing program. It is dependent upon the application program as to the mechanism for opening and saving files to the Unix file system.

Creating directory files is done with the command mkdir as follows:

	mkdir file_spec

Once files are created and saved, users typically find the need to make copies of various files. Files are copied in Unix using the cp command as follows:

	cp source_file_spec(s) destination_file_spec(s)

• syntactically incorrect file specifications
  
• the source or destination argument is missing
  
• the source does not exist, or is not readable (see permissions above)
  
• the destination is not writable
  

Since the cp command mandates 2 distinct arguments, now is a good time to introduce notation to make things a little simpler. This notation uses a single character named "dot", represented by the . (period) character (not to be confused with "dot-dot" (..) above). The dot character has several uses based upon context (more uses of dot here). In this context, dot will denote your current working directory, in other words, where you are. Thus if you wish to copy a file and have the destination be your current working directory and maintain the same file name, you can simply do:

	cp source_file_spec(s) .

Moving files is very similar to copying files, the difference being with copy, the source files remain intact while with move, the source files no longer exist in their original location. The command to move files is mv and the syntax is analogous to copy:

	mv source_file_spec(s) destination_file_spec(s)

Some examples using the cp command based upon the diagram above given the working directory as follows:

	$ pwd [Enter]
	/home/stu1	

	$ cp /home/mthomas/class_stuff/foo /home/stu1/foo		# pure absolute form
	$ cp ../mthomas/class_stuff/foo foo		   		# relative form, same file name
	$ cp ../mthomas/class_stuff/foo new_foo				# relative, new file name
	$ cp ../mthomas/class_stuff/foo /home/stu1			# no file specified, original name assumed
	$ cp ../mthomas/class_stuff/foo .				# destination is current working directory
	$ cp ../mthomas/class_stuff/foo ~				# destination is "home" directory

	rm file_spec(s)

In similar fashion, users can remove directories from the file system using the rmdir command as follows:

	rmdir file_spec(s)

File System Miscellany

In working with the Unix file system, understanding a few miscellaneous concepts can be helpful. The first of these is the capability to specify multiple files. This is accomplished using something called a metacharacter; that is a character that may have special meaning other than the "literal" meaning of the character. The first of these to discuss is called the wildcard character, represented by the * (asterisk) character.

Using the * character alone represents (matches) all files in the specified location. For example, the command:

	$ cp /home/mthomas/class_stuff/* .

	$ chmod 755 *

	$ ls net*
	$ chmod 755 net*

One should be careful using the wildcard character though, as this can have dangerous results. Can you tell what the following command does?

	$ rm *

Another topic which can aid in working within the file system is using the copy (cp) command when working with directories. If one wishes to copy all files within a directory to another location, one could simply use the command:

	$ cp * destination_file_spec

However, if any of the files to be copied are directories themselves, the cp program will report an error, looking something like:

	cp: omitting directory `foo'

	$ cp -r * destination_file_spec

Command Summary

• cat - display entire file(s) in the terminal window (also see more command below)

• cd - change the current directory (see bash-builtins note)

• cp - copy file(s)

• chmod - change file(s) protection modes

• lpr - send file(s) to the line printer

• mkdir - create (make) a new directory

• more - nicely view the contents of file(s)

• mv - move (and/or rename) file(s)

• pwd - print ablsoute pathname of current working directory

• rm - remove file(s)

• rmdir - remove an empty directory

• umask - set file mode creation mask

©2019, Mark A. Thomas. All Rights Reserved.