7.1. Introduction

Unix-like operating systems use a hierarchical filesystem to store files and directories. Directories can contain files and other directories, the top directory (/) is named the root directory (not to be confused with the /root directory). Most filesystems also support file links (which provide alternative names for a file) and soft links. Other filesystems can be "connected" to an arbitrary directory. This process is named "mounting", and the directory in which the filesystem is mounted is named the "mount point".

This chapter covers the basic navigation of the filesystem, commands which are used to remove and create directories, filesystem permissions, links and mounting.

7.2. The basics

pwd

pwd(1) is a simple utility which shows the directory you are currently working in. The pwd does not require any parameters. This is an example output of pwd:

$ pwd
/home/danieldk

ls

ls is similar to the dir command in DOS and Windows. ls can be used to display files and directories located in specific directories. Running the ls command without any parameters shows the contents of the current directory:

$ ls
COPYING  CVS  Makefile  README  html  images  pdf  src  tex

Naturally it is also possible to show the contents of other directories. You can do this by specifying the path as a parameter tot the ls command:

$ ls /
bin   cdrom   dev  floppy  initrd  lost+found  opt   root  sys  usr  windows
boot  cdrom1  etc  home    lib     mnt         proc  sbin  tmp  var

A disadvantage of the default output is that it provides little information about files and directories. For example, it is not possible to see whether some entry is a file or directory, what size a file is, or who the owner of the file is. The ls has the "-l" parameter to show more information:

$ ls -l
total 52
-rw-r--r--    1 daniel   daniel      20398 Jul 16 14:28 COPYING
drwxr-xr-x    2 daniel   daniel       4096 Jul 16 14:28 CVS
-rw-r--r--    1 daniel   daniel        768 Jul 16 14:28 Makefile
-rw-r--r--    1 daniel   daniel        408 Jul 16 14:28 README
drwxr-xr-x    3 daniel   daniel       4096 Jul 16 14:28 html
drwxr-xr-x    3 daniel   daniel       4096 Jul 16 14:28 images
drwxr-xr-x    3 daniel   daniel       4096 Jul 16 14:28 pdf
drwxr-xr-x    3 daniel   daniel       4096 Jul 20 00:11 src
drwxr-xr-x    3 daniel   daniel       4096 Jul 16 14:28 tex

cd

Another important command is the cd command. It can be used to change the current working directory:

$ cd /home/danieldk/

With the pwd command you can see it worked:

$ pwd
/home/danieldk

mkdir

As you might have guessed, the mkdir(1) command can be used to create directories. For example:

$ pwd
/home/danieldk
$ mkdir test
$ cd test
$ pwd
/home/danieldk/test

It might happen that you want to create a directory in a parent directory which does not exist yet. For example, if you want to create the test2/hello/ directory, but the test2 directory does not yet exist. In this case you can make both directories with only one mkdir command:

$ mkdir -p test2/hello

cp

Files can be copied with the cp(1) command, the basic syntax is cp source destination. For example, suppose that we have a file named memo which we would like to copy to the writings directory. You can do this with the following command:

$ cp memo writings/

It is also possible to copy a file in the same directory. For example, if we would like to make a new memo based on memo, named memo2, we could execute the following command:

$ cp memo memo2

It is also possible to copy directories recursively, this can be done by adding the -r. The following command copies the memos directory, and all subdirectories, and (sub)files to the writings directory:

$ cp -r memos writings/

mv

The mv(1) command is comparable to cp, but it is used to move files. Suppose that we have the same situation as in the first cp example, but you would rather like to move memo to the writings directory. The following command would do that:

$ mv memo writings/

It is also possible to move directories. But, mv always works recursively. For example, the following command will move the memos directory to the writings directory:

$ mv memos writings/

rm

The rm(1) command is used to remove files and directories. Let's look at a simple example:

$ rm hello.c

This commands removes the file hello.c. Sometimes the rm asks for a confirmation. You can ignore this with the '-f' parameter:

$ rm -f *

This command removes all files in the current directory without asking for confirmation. It is also possible to delete directories or even whole directory trees. rm provides the '-r' parameter to do this. Suppose we want to delete the ogle directory and all subdirectories and files in that directory, this can be done in the following way:

$ rm -r -f ogle/

Many commands allow you to combine parameters. The following example is equivalent to the last one:

$ rm -rf ogle/

7.3. Permissions

A short introduction

Every file in GNU/Linux has permissions. As you might have noticed, file permissions can be shown with the ls -l command:

$ ls -l logo.jpg
-rw-r--r--    1 danieldk users        9253 Dec 23 19:12 logo.jpg

The permissions are shown in the first column. Permissions that can be set are read(r), write(w) and execute(x). These permissions can we set for three classes: owner(u), group(g) and others(o). The permissions are visible in the second to ninth character in the first column. These nine characters are divided in three groups. The first three characters represent the permissions for the owner, the next three characters represent the permissions for the group, finally the last three characters represent the permissions for other users. Thus, the example file shown above can be written to by the owner and can be read by all three classes of users (owner, group and others).

Each GNU/Linux system has many distinct users (a list of users can be found in /etc/passwd), and a user can be a member of certain groups. This kind of user management provides makes it possible to manage detailed permissions for each file. In the example shown above danieldk is the owner of the file and group permissions apply to the group users. In this example groups rights do not differ from the rights of other users.

chown

The chown(1) command is used to set the file owner and to which group group permissions should apply to. Suppose we want to make danieldk the owner of the file logo2.jpg, this can be done with the chown:

$ chown danieldk logo2.jpg

Using the ls we can see that the owner is now danieldk:

$ ls -l logo2.jpg 
-rw-r--r--    1 root     root        9253 Dec 29 11:35 logo2.jpg
$ chown danieldk logo2.jpg
$ ls -l logo2.jpg 
-rw-r--r--    1 danieldk root        9253 Dec 29 11:35 logo2.jpg

But group permissions still apply for the root group. This group can be changed by adding a dot after the owner, followed by the name of the group (in this example the group is nedslackers):

$ chown danieldk.nedslackers logo2.jpg
$ ls -l logo2.jpg
-rw-r--r--    1 danieldk nedslackers        9253 Dec 29 11:35 logo2.jpg

It is also possible to change ownership recursively, this can be done with the recursive (-R) parameter:

$ chown -R danieldk.users oggs/

chmod

File permissions can be manipulated using the chmod(1) command. The most basic syntax of chmod is chmod [u,g,o][+/-][r,w,x] filename. The first parameter consists of the following elements: 1. which classes this manipulation permission applies to, 2. if the permissions should be added (+) or removed (-), and 3. which permissions should be manipulated. Suppose we want to make the file memo writable for the owner of the file and the groups for which the group permissions apply. This can be done with the following command:

$ chmod ug+w memo

As you can see below the memo is now writable for the file owner and group:

$ ls -l notes 
-r--r--r--    1 daniel   users          12 Mar  9 16:28 memo 
bash-2.05b$ chmod ug+w memo
bash-2.05b$ ls -l notes 
-rw-rw-r--    1 daniel   users          12 Mar  9 16:28 momo 

Just like the chown command it is also possible to do recursive (-R) operations. In the following example the secret/, including subdirectories and files in this directory, is made unreadable for the group set for this directory and other users:

$ chmod -R go-r secret/

7.4. Extended attributes

# apt-get install attr

$ getfattr note.txt 
# file: note.txt
user.Author

$ getfattr -d note.txt 
# file: note.txt
user.Author="Daniel"

$ setfattr -n user.Author note2.txt

$ setfattr -n user.Author -v Mike note2.txt

$ setfattr -n user.MD5 -v `md5sum note2.txt` note2.txt
$ getfattr -d note2.txt
# file: note2.txt
user.Author="Mike"
user.MD5="78be7a3148027ae7a897aad95e7d9c58"

7.5. Mounting filesystems

# mount /dev/cdrom /cdrom

# mount -t vfat /dev/sda1 /flash

# umount /cdrom
# umount /dev/sda1

/dev/hda10       swap             swap        defaults         0   0
/dev/hda5        /                xfs         defaults         1   1
/dev/hda6        /var             xfs         defaults         1   2
/dev/hda7        /tmp             xfs         defaults         1   2
/dev/hda8        /home            xfs         defaults         1   2
/dev/hda9        /usr             xfs         defaults         1   2
/dev/cdrom       /mnt/cdrom       iso9660     noauto,owner,ro  0   0
/dev/fd0         /mnt/floppy      auto        noauto,owner     0   0
devpts           /dev/pts         devpts      gid=5,mode=620   0   0
proc             /proc            proc        defaults         0   0