Introduction to Unix

The following characters have special meaning to Unix shells:

& ; | * ? ' " ` [ ] ( ) $ < > ^ # / \ % !

In addition, the Return or Enter key, the space tab and the tab keys have special meaning to shells. It is best to not use any of these characters in filenames until you understand how the shell interprets them!

Quoting

Quoting removes the special meanings of characters.

You can quote a single character by preceding it with a backslash, \.

For example:

echo \|

results in | being typed at the terminal. If you hadn't quoted the |, but typed:

echo |

the shell would have thought you were trying to send the output from the echo command to a pipe, represented by | (there is more inf ormation on using pipes below), and your sequence of commands would have been incomplete.

Use single quotes, ' ... ', to remove the special meaning of al l characters except ' itself. You cannot include another single quote within a pair of single quotes.

Use double quotes, " ... ", to remove the special meaning of al l characters except $, \, `, and ".

Unix Commands

(This last example would attempt to list the files l and t in addition to the files starting with chap. The only option used in the a bove example is -r ).

File Redirection

You can use file redirection to specify where commands get input from or where they should send output to. Commands get their input from standard input, which by default is usually the terminal. Commands send their output to standard output, which by default is also usually the terminal. Suppose that you wanted to save the output from the ls command in a file (rather than have it displayed at the terminal, which is the default). You can use the > symbol to redirect the o utput from ls :

ls -lt > filename

Then you can look at the file (using an editor like vi, or via the more or cat commands).

Now suppose that you wanted to append one file to another. You can use >> to accomplish this. In the following example, we use the cat command to display the contents of file1. By default, this would be displayed at the terminal. Instead, we use >> to take the output from the cat command ( which is just the contents of file1) and append it to file2 :

cat file1 >> file2

You can also redirect standard input, using the < symbol. S uppose you have a program that needs to read in some data to standard input (in Fortran, standard input is unit 5). You could type:

program_name < input_data

Pipes

takes the output from the ls command and "pipes it into" the < STRONG>more command, which pauses after each screenful of information.

The "here document"

Another way to redirect I/O (input/output) is to use the "here document". Here documents are often used in scripts (a script is a sequence of commands contained in a file), when you want to say "use the following text (arguments, commands, or whatever) from HERE to HERE as input to my command". The general form of the here document is:

   command <<HERE
      command_input_line1
      command_input_line2
      ....
   HERE 

where HERE is a unique string (i.e. a string that won't be confused with any of the commands in the script) that marks the beginning and end of the input you want to provide to the command. For example, if you use FTP (File Transfer Protocol) within a script, use the here document to tell FTP which commands it should execute. For example:

   ftp -i my_workstation <<END
      get my_program
      get my_data
      quit
   END 

Unix Processes

A process is a command that is being executed by the Unix operating system. Each process is associated with a unique process id. To see the processes you own, type ps . The output from the ps command looks like this:

   PID TTY   TIME COMMAND
 17605 p024  0:01 csh
 10887 p024  0:00 ps

where PID is the process id, TTY identifies the terminal associated with the process, and TIME shows the number of CPU seconds the process has accumulated.

The first command in the above display, csh, shows the shell, i n this case the C shell.

When you type a command, the shell usually forks, or spawns, a child process to execute the command. Some commands are built into the shell. The shell does not have to fork a separate process to run a built-in command.

You can type <Ctrl>c (hold the Control key, then press t he c key) to stop the execution of your current process.

You can use the kill -9 command to kill a process you own. T ype:

kill -9 pid

where pid is the process id of the process you want to kill.

Getting Online Help With the man Command

The Unix man ("man" is derived from "manual") command provides online information about Unix commands, including syntax, function, and options. The NCCS has added site-specific information to the Unix man facility where appropriate. To use man , type:

man command_name

To find out what man pages (and software) are available in a general topic area, type:

man -k topic_name

or:

apropos topic_name

For more information on how to use the man command, type:

man man

Sometimes it is convenient to save the output from a man comman d to a file, so that you can browse through it with your favorite editor. You can remove the underscores and other "funny characters" by piping the output from man to the col -b command and saving the resulting file, as follows:

man command_name | col -b > filename

Note that there are usually no man pages for commands built into the shell. Information for built-in commands is contained within the man page for the shell. For example, type:

man csh

to see the C shell's built-in commands.

The Unix file system

Unix uses a hierarchical system, called a tree structure (it's actually an inverted tree), to store files. The top level of the Unix file system is the root directory called /. Below / are various directories, sub-directories, sub-sub directories, and so forth. A t the end of the "directory branches" are "ordinary files". A part of the Cray's Unix file tree is shown below.

                             /
                             |
     +------+------+------+--+---+-------+-------+--------+
     |      |      |      |      |       |       |        |
    u1     u2     u3     u4     bin     lib     silo     tmp  ...
            |                    |
       +----+---+            +---+---+
       |        |            |       |
     abxyz    acwxy  ...     cp     ls ...
                |
          +-----+-----+
          |           |
       project1   project2  ...
          |
      +---+-----+
      |         |
    test.f  test.data  ...

/u1, /u2, /u3 and /u4 are the user file systems on the Cray. /u2/abxyz and /u2/acwxy are the home directories for users abxyz and acwx y respectively. When you log into the Cray, you are automatically placed in your home directory. The above diagram shows user acwxy having several project directories. In each project directory are files associated with that project.

/bin contains many of the Unix user commands, such as c p (copy file) and ls (list files), shown in the diagra m. The complete pathnames (also called absolute pathnames) of these two commands are /bin/cp and /bin/ls respectively. Absolute pathnames start with th e root directory, /, and include the names of all the directori es you have to traverse downwards from / to get to the final fi le. Note that in a pathname, a / is inserted between the diffe rent directory names. An example would be:

/u2/acwxy/project1/test.f.

Normally, you don't have to type the complete pathnames for these commands, because Unix uses your PATH environment variable (an environment variable is a variable that defines characteristics of your shell environment) to search for the commands you type. The Cray automatically includes /bin, /usr/bin, /usr/ucb, and /usr/local/bin in your path. Introduction to Unix Shell s provides more information on how to include other pathnames in your path.

The term current directory refers to your current location in the directory tree. Unix calls your current directory . (dot). T he parent directory is the directory one level up from the current directory. Unix calls the parent directory .. (two dots). Yo u can use . and .. as command arguments. For example, you can use the change directory (cd) command to go up one directory level by typing:

cd ..

You can refer to files located below your current directory by their relative pathnames (that is, the name relative to the current directory). For example, if user acwxy is in her home directory, /u3/acwxy, she can refer to the file test.f as project1/test.f. If she is in her project1 directory, she can simply call this file test.f.

Note that in Unix, the word file can refer either to a directory or to an ordinary file (directories are just files to the Unix operating system!), although people often loosely use the word file to mean ordinary file.

Unix Filenames

Although almost any ASCII character can be used in a filename, it's best to restrict yourself to upper and lower case letters (keep in mind that Unix is case sensitive), digits, . and _. This is because many special characters have special meanings to Unix, and the ir use in filenames might be confusing. In particular, you should avoid using < STRONG>* and ? in filenames.

Some Unix files begin with a dot (.); they are often called hid den or dot files, and are usually startup files for various shells and utilities . This means that when the shell or utility starts running, it reads the information in the dot file for startup (or configuration) instructions. For example, the Korn and POSIX shells read your .profile for s tartup instructions. The C and Tenex C shells read your .login and .cshrc file. These files are not displayed when you use t he ls ("list files") command unless you give ls the -a option. To see your dot files, type:

ls -a

By convention, suffixes are used to indicate specific file types to certain Unix utilities. Some common suffixes are:

Unix File Permissions

All files (both ordinary files and directories) have file permissions associated with them. The three types of file permissions are:

• r (read permission): For directories, read permission means that you can list files within that directory.

• w ( write permission): For directories, write permission means that you can create and delete files within that directory. For files, write permission means that you can modify the file.

• x (execute/search permission): For directories, execute permission means that you can use that directory in a pathname, and can cd to that directory. You cannot list files within a directory that has execute permission but not read permission.

Permissions are set for three groups of users: "user" (the userid that created the file), "group", and "other". "group" refers to users who belong to the Unix group with which the file is associated. To see which groups you belong to, type:

groups

"other" means all other users (but does not include the owner or users with group privileges!). To see the file permissions of the files within your current directory, type:

ls -l

You will see output like:

-rw-------   1 abxyz    g123        3743 Dec  7 13:59 memo
-rw-r-----   1 abxyz    g123        7471 Mar 23 17:16 program.f
drwxr-xr-x   1 abxyz    g123        4096 Aug 19  1993 software
...

The first field of 10 columns shows the file permissions:

• column 1: indicates whether the file is a directory (d), an ordinary file (-), or something else (which we won't explain here)
• columns 2-4: permissions for "user" or "owner" (here, the user is abxyz )
• columns 5-7: permissions for "group" (here, the group is g123)
• columns 8-10: permissions for "other"