UNIX

The kernel

The kernel of UNIX is the hub of the operating system: it allocates time and memory to programs and handles the filestore and communications in response to system calls.

As an illustration of the way that the shell and the kernel work together, suppose a user types

$ rm myfile

(which has the effect of removing the file myfile). The shell searches the filestore for the file containing the program rm, and then requests the kernel, through system calls, to execute the program rm on myfile. When the process rm myfile has finished running, the shell then returns the UNIX prompt $ to the user, indicating that it is waiting for further commands.

The shell

The shell acts as an interface between the user and the kernel. When a user logs in, the login program checks the username and password, and then starts another program called the shell. The shell is a command line interpreter (CLI). It interprets the commands the user types in and arranges for them to be carried out. The commands are themselves programs: when they terminate, the shell gives the user another prompt.

The adept user can customize his/her own shell, and users can use different shells on the same machine. Users will typically have the TCSH shell or Bash shell by default (Bash is typically the default on modern Linux distributions).

These shells have certain features to help the user inputting commands:

• Filename Completion - By typing part of the name of a command, filename or directory and pressing the [Tab] key, the tcsh and bash shells will complete the rest of the name automatically. If the shell finds more than one name beginning with those letters you have typed, it will beep, prompting you to type a few more letters before pressing the [Tab] key again.

• History - The shell keeps a list of the commands you have typed in. If you need to repeat a command, use the cursor keys to scroll up and down the list or type history for a list of previous commands.

ls (list)

When you first login, your current working directory is your home directory. Your home directory has the same name as your user-name, e.g. rkalescky, and it is where your personal files and subdirectories are saved.

To find out what is in your home directory, type

$ ls

The ls command lists the contents of your current working directory.

There may be no files visible in your home directory, in which case, the UNIX prompt will be returned. Alternatively, there may already be some files inserted by the System Administrator when your account was created.

ls does not, in fact, cause all the files in your home directory to be listed, but only those ones whose name does not begin with a dot (.) Files beginning with a dot (.) are “hidden” files and usually contain important program configuration information. They are hidden because you should not change them unless you are very familiar with UNIX.

To list all files in your home directory including those whose names begin with a dot, type

$ ls -a

As you can see, ls -a lists files that are normally hidden.

ls is an example of a command which can take options: -a is an example of an option. The options change the behaviour of the command. There are online manual pages that tell you which options a particular command can take, and how each option modifies the behaviour of the command. (See later in this tutorial).

mkdir (make directory)

We will now make a subdirectory in your home directory to hold the files you will be creating and using in the course of this tutorial. To make a subdirectory called unixstuff in your current working directory type

$ mkdir unixstuff

To see the directory you have just created, type

$ ls

Or to see what is inside of the directory unixstuff, type

$ ls unixstuff

cd (change directory)

The command cd directory means change the current working directory to directory. The current working directory may be thought of as the directory you are in, i.e. your current position in the file-system tree.

To change to the directory you have just made, type

$ cd unixstuff

Type ls to see the contents (which should be empty).

Exercise

Make another directory inside the unixstuff directory called backups.

. <. (the current directory)>

In UNIX, . means the current directory, so typing

$ cd .

means stay where you are (in the unixstuff directory).

This may not seem very useful at first, but using . as the name of the current directory will save a lot of typing, as we shall see later in the tutorial.

.. (the parent directory)

The other “special” directory in UNIX, .., refers to the parent of the current directory, so typing

$ cd ..

will take you one directory up the hierarchy (back to your home directory). Try it now.

pwd (print working directory)

Pathnames enable you to work out where you are in relation to the whole file-system. For example, to find out the absolute pathname of your home-directory, type cd to get back to your home-directory and then type

$ pwd

which should give you something like this,

/users/rkalescky

Suppose you were on the computer from our example UNIX directory structure figure (reproduced again below). There, typing pwd in the ee51vn sub-directory would produce

/home/its/ug1/ee51vn

which means that ee51vn is in the sub-directory ug1, which in turn is located in the its sub-directory, which is in the home sub-directory, which is in the top-level root directory called /.

Exercise

Use the commands cd, ls and pwd to explore the file-system.

(Remember, if you get lost, type cd by itself to return home).

Understanding pathnames

Go back to your home-directory and then type

$ ls unixstuff

to list the contents of your unixstuff directory. Now type

$ ls backups

You will get a message like this

/bin/ls: cannot access backups: No such file or directory

The reason is, backups is not in your current working directory. To use a command on a file (or directory) not in the current working directory (the directory you are currently in), you must either cd to the correct directory, or specify its full pathname. To list the contents of the backups directory that we made earlier, you must instead type

$ ls unixstuff/backups

~ (your home directory)

Home directories can also be referred to by the tilde character, ~. It can be used to specify paths starting at your home directory. So typing

$ ls ~/unixstuff

will list the contents of your unixstuff directory, no matter where you currently are in the file-system.

What do you imagine that

$ ls ~

would list? What do you think that

$ ls ~/..

would list?

cp (copy)

cp file1 file2 is the command which makes a copy of file1 in the current working directory and calls it file2.

What we are going to do now, is to take a file stored in an open access area of the file system, and use the cp command to copy it to your unixstuff directory.

First, go to your unixstuff directory.

$ cd ~/unixstuff

Then at the UNIX prompt, type,

$ cp /usr/include/sys/types.h types.h

The above command means copy the file types.h from the /usr/include/sys directory to the current directory, keeping the name the same.

You can accomplish the same thing by typing

$ cp /usr/include/sys/types.h .

Like the previous command, it directs the computer to copy the file types.h from the /usr/include/sys directory to the current directory, ., without changing the file name.

Exercise

Create a backup of your types.h file by copying it to a file called types.bak.

mv (move)

To move a file from one place to another, use the mv command. This has the effect of moving rather than copying the file, so you end up with only one file rather than two. The calling sequence is of the form mv file1 file2 which results in moving file1 to file2.

This can be helpful when moving a file from one directory to another. We are now going to move the file types.bak to your backup directory.

First, change directories to your unixstuff directory (can you remember how?). Then, inside the unixstuff directory, type

$ mv types.bak backups/.

Type ls and ls backups to see if it has worked.

The mv command can also be used to rename a file, by moving the file to the same directory, but giving it a different filename.

rm (remove), rmdir (remove directory)

To delete (remove) a file, use the rm command. As an example, we are going to create a copy of the types.h file then delete it.

Inside your unixstuff directory, type

$ cp types.h tempfile.txt
$ ls
$ rm tempfile.txt
$ ls

(after rm tempfile.txt you may need to answer “y” at the prompt and hit [Enter] before continuing).

These commands first copied the file types.h to a copy called tempfile.txt, then showed you the list of files in this directory (notice the new file), then deleted tempfile.txt, and finally showed you the updated list of files in this directory.

You can use the rmdir command to remove a directory (make sure it is empty first). Try to remove the backups directory:

$ rmdir backups

Notice that you cannot remove the directory, since UNIX will not let you remove a non-empty directory.

Exercise

Create a directory called tempstuff using mkdir, then remove it using the rmdir command.

clear (clear screen)

Before you start the next section, you may want to clear the terminal window of the previous commands so the output of the following commands can be clearly understood.

At the prompt, type

$ clear

This will clear all text and leave you with the $ prompt at the top of the window.

cat (concatenate)

The command cat can be used to display the contents of a file to the screen. Type:

$ cat types.h

As you can see, the file is longer than than the size of the window, so it scrolls past making it difficult to read the file from the beginning.

less (view file contents)

The command less writes the contents of a file onto the screen one page at a time. Type

$ less types.h

Press the [space-bar] if you want to see another page, and type [q] if you want to quit reading.

As you can see, less can be more useful for reading long files than cat.

head (view top of file)

The head command writes the first ten lines of a file to the screen.

First clear the screen then type

$ head types.h

Then type

$ head -3 types.h

What difference did the -3 do to the head command?

tail (view bottom of file)

The tail command writes the last ten lines of a file to the screen.

Clear the screen and type

$ tail types.h

17. Can you figure out how to view the last 15 lines of this file?

Simple searching using less

Using less, you can search though a text file for a keyword (pattern). For example, to search through types.h for the word long, type

$ less types.h

then, still in less, type a forward slash [/] followed by the word you want to search for,

/long

As you can see, less finds and highlights the keyword. Type [n] to search for the next occurrence of the word. Type [q] to quit the search.

grep <grep (file search)> (don’t ask why it is called grep)

grep is one of many standard UNIX utilities. It searches files for specified words or patterns. First clear the screen, then type

$ grep long types.h

As you can see, grep has printed out each line of the file types.h that contains the word long.

Or has it ????

Try typing

$ grep LONG types.h

Note that the grep command is case sensitive; it distinguishes between LONG and long.

To ignore upper/lower case distinctions, use the -i option, i.e. type

$ grep -i long types.h

To search for a phrase or pattern, you must enclose it in single quotes (the apostrophe symbol). For example to search for long int you would type

$ grep -i 'long int' types.h

Some of the other options of grep are:

-v display those lines that do NOT match

-n precede each matching line with the line number

-c print only the total count of matched lines

Try some of them and see how the results differ. Don’t forget, you can combine options to do more than just one thing at a time. For example, the number of lines without the words long or LONG is

$ grep -ivc long types.h

wc (word count)

A handy little utility is the wc command, short for word count. To do a word count on types.h, type

$ wc -w types.h

To find out how many lines the file has, type

$ wc -l types.h

Exercise

Using the above method, create another file called list2 containing the following fruit: orange, plum, mango, grapefruit. Read the contents of the new file, list2.

Appending to a file <>> (appending output)>

The double greater-than symbol >> appends standard output to a file. So to add more items to the existing file list1, type

$ cat >> list1

Then type in the names of more fruit

peach
grape
orange
^D

To read the contents of the file, type

$ cat list1

You should now have two files: list1 contains six fruit, while list2 contains four.

We will now use the cat command to join (concatenate) list1 and list2 into a new file called biglist. Type

$ cat list1 list2 > biglist

What this is doing is reading the contents of both files list1 and list2 in turn, then outputing the text to the file biglist

To read the contents of this new file, type

$ cat biglist

Exercise

Using two pipes, display all lines of list1 and list2 containing the letter “p”, and sort the result.

The * <* (wildcard)> wildcard

The character * is called a wildcard, and will match against none or more character(s) in a file (or directory) name. For example, in your unixstuff directory, type

$ ls list*

This will list all files in the current directory starting with the characters “list”

Try typing

$ ls *list

This will list all files in the current directory ending with “list”

The ? <? (wildcard)> wildcard

The character ? will match exactly one character, So ?ouse will match files like house and mouse, but not grouse.

Try typing

$ ls ?list

On-line Manuals

There are built-in manuals which give information about most commands. The manual pages <man (manual)> tell you which options a particular command can take, and how each option modifies the behaviour of the command. Type “man command” to read the manual page for a particular command.

For example, to find out more about the wc (word count) command, type

$ man wc

Alternatively

$ whatis wc

gives a one-line description <whatis (brief manual)> of the command, but omits any information about options etc.

Apropos <apropos (command search)>

When you are not sure of the exact name of a command, “apropos keyword” will give you the commands with keyword in their manual page header. For example, try typing

$ apropos copy

Access rights on files

• r (or -), indicates read permission (or otherwise), that is, the presence or absence of permission to read and copy the file

• w (or -), indicates write permission (or otherwise), that is, the permission (or otherwise) to change a file

• x (or -), indicates execution permission (or otherwise), that is, the permission to execute/run a file, where appropriate

Access rights on directories

• r allows users to list files in the directory

• w means that users may delete files from the directory or move files into it

• x means the right to access files in the directory. This implies that you may read files in the directory provided you have read permission on the individual files.

So, in order to read a file, you must have execute permission on the directory containing that file, and hence on any directory containing that directory as a subdirectory, and so on, up the tree.

Some examples

chmod (change permissions)

Only the owner of a file can use chmod to change the permissions of a file. The options of chmod are as follows

For example, to remove read write and execute permissions on the file biglist for the group and others, type

$ chmod go-rwx biglist

This will leave the other permissions unaffected.

To give read and write permissions on the file biglist to all,

$ chmod a+rw biglist

Alternatively, you may use a three-digit number to specify the access permissions. The numerical values for the permissions are

Add up the desired permissions for the user to form the first digit, add up the desired permissions for the group to form the second digit, and add up the desired permissions for others to form the third digit.

For example, to grant read and write permissions to the user (4+2=6), read permissions (4) to the group, and no permissions to others (0), for the file biglist, use the command

$ chmod 640 biglist

Exercise

Try changing access permissions on the file types.h and on the directory backups.

Use ls -l to check that the permissions have changed.