M.I.T. DEPARTMENT OF EECS
|6.033 - Computer System Engineering||UNIX Hands-On Assignment|
This hands-on assignment is due at the beginning of class on Feb 25. Please submit your assignment using the online submissions page. Before attempting this hands-on, you should read The Unix Time-Sharing System, which is also assigned for this recitation.
If necessary, you may want to briefly re-read sections 5.2 and 6.2-6.4 of the paper to refresh yourself on the concepts of pipes and I/O redirection.
Note: Since the GNU Linux system commands function slightly differently to their UNIX counterparts, please ensure that your answers work on a Solaris Athena machine such as sun.dialup.mit.edu. (Note: athena.dialup.mit.edu is Linux.)
We'll start off with an extremely simple example that most of you are probably familiar with already:
Here, we are first changing into the /bin directory, which contains many of the executable commands for the system. The command
athena% cd /bin
athena% ls -1 | more
ls -1gives us a listing of all the files in the current directory with one file per line. (Note that
-1is the numeral "one", not the letter "L".) We then pipe the output from
lsto the command
more, which displays the results one page at a time. (Press the space bar to show the next page.) You can refer to the manual pages for
moreto see more details and options for each command. Manual pages let you read information about various commands on UNIX systems; to use them, run
athena% man command
command is the command you are interested
in. If you are unfamiliar with manual pages, you may want to try
for information on the man command itself. Keep in mind that the manual pages for basic commands vary from system to system (much as the commands themselves do).
athena% man man
Now, try this:
This runs the same
athena% cd /bin
athena% ls -1 | grep p | more
ls -1command, but only lists the executable files which happen to contain the letter "p" somewhere in their names.
The point here is to observe that you can chain together multiple commands using the pipe character ( | ), and the output from each command will be passed to the input of the next, in left-to-right order. This allows you to treat any command that uses standard input and output as a primitive from which you can build more complex and useful commands.
Now, we'd like you to figure out on your own how to solve some problems by chaining different commands together.
If you aren't already familiar with these commands, you may want to briefly skim through their man pages to familiarize yourself with what they do. You will probably need to use some of the options for the different commands in order to solve these problems.
Here are the commands you may find useful:
cat fmt grep head ls ps sort tail top wc yes (*)
(*) On some Athena machines, the
yes command isn't
available. However, if you are doing this assignment on Athena you
can use the command
gyes, which is functionally
gyes is located in the "gnu" locker, so
before you can use it you need to add the locker. You can do so with
the following command:
athena% add gnu
(If you are curious about Athena's locker system, you can run
man lockers for more information. The command
whichlocker can be used to determine which locker
contains a given command. The
whichlocker command itself
resides in the "outland" locker. For more info on other lockers, look at
this SIPB article)
Once you have added the gnu locker, you can use
yes. Some Athena machines seem to lack the
manual pages for both
(hereafter referred to just as
yes). In case the man
pages are missing on the machine you are using, here is a brief
description of what
yes is very
simple; it just outputs a string repeatedly until killed. It takes
either one or zero arguments; if you give it a string as an argument
it will output that string until it is killed (you can kill a process by
pressing control-c). If you give it no
arguments, it will output the string "y" until it is killed, which
explains why it is named
For each of the outputs listed below, find one sequence of commands connected by pipes that produces the output. For each problem, turn in the command sequence that you used to generate the requested output. (Do NOT turn in the output itself.)
acroreadshould be listed before a process running
zwgc). The output should consist only of the processes you are running, and nothing else (i.e. if you are running 6 processes, the output should only have 6 lines).
/usr/dict/words(*) which do not contain any of the letters a, e, i, o, or u.
[* Note: On some Unix/Linux systems, the dictionary has the filename /usr/share/dict/words]
5x6matrix of entries of alternating
0's. It should look like this:
1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0
/etcdirectory whose name contains the string ".conf", sorted by increasing file size.
Now we'd like to explore something slightly different, having to do with file redirection as discussed in section 6.2-6.4 of the paper. The authors explain that the following two commands are functionally equivalent (except that you have to remove the temp file afterwards in the second case):
athena% ls | head -1
athena% ls > temp; head -1 < temp
The UNIX paper authors explain in section 6.3 that a user can type two commands together in parenthesis separated by a semicolon, and redirect the output to a file. The file will then contain the concatenation of the two commands. The example from the paper is roughly:
athena% (date ; ls) > temp1 &
Note that this example uses the & operator to run the process asynchronously. That is, the shell will accept and run another command without waiting for the first to finish. The authors also mention that one can use the & operator multiple times on one line. For example, we can do almost the same thing:
athena% (date & ls) > temp2 &
See if you can figure out for yourself what exactly the difference is between using ";" and "&" in the examples above.
Let's explore this for ourselves. First, we will write a very simple variation on the "yes" program that you encountered earlier on in this assignment. To do so, we will use the "command file" functionality described in section 6.4 of the paper. Most people call these command files "shell scripts", since they are essentially simple scripts that are executed by the shell.
First, start up a copy of emacs editing a new file called "myyes".
athena% emacs myyes
Now, enter the following lines into your file:
#!/bin/sh echo y sleep 1 echo n
Save the file and exit emacs. If you don't already know what the
sleep commands do, look them up in
the man pages. Lastly, make the file executable by running the
athena% chmod a+rx myyes
Now let's try running the following two commands:
athena% (./myyes ; ./myyes) > temp3
athena% (./myyes & ./myyes) > temp4
Note: If you're using a fast multicore machine for this handson, please ensure that you run the latter command on sun.dialup.mit.edu instead. Some fast multicore machines may occasionally give unexpected answers, where some output is lost - originally unexpected even to the 6.033 staff. If this occurs for you on your home machine, you may want to think briefly about why this occurs.
|Go to 6.033 Home Page|