An Introduction to UNIX and Programming Under UNIX

Please Note:

Motivation

In my opinion, no one studying computer engineering or taking a course in computer operating systems, networking, or VLSI should get out without learning about, and working with, UNIX.

Computer engineers should be exposed to as many computing environments as possible so that they can not only understand how the computers they are learning to design may be used, but also so that they can work in these other environments once they graduate.

Many, if not most, of you will be designing computers, hardware, software, and VLSI circuits using software running on UNIX-based systems. For those of you interested in networking, the backbone of the Internet is composed primarily of computers running some variant of UNIX, and many of the routers and intermediate systems connected to the Internet are UNIX-based.

Most of the software packages that are familiar with were originally developed on UNIX systems: ProEngineer and PSPICE are just two that started as UNIX programs.

No matter what anyone else tells you, you will be better off knowing about UNIX and having had some experience with a UNIX-based system before you leave school.

Linux is an open-source version of UNIX which you can download for free; or, if you don't have the time, you can buy a prepackaged distribution of it from your favorite retailer.

There is a definite lack of a solid introduction to UNIX in our current curriculum. To ensure that you are exposed to a UNIX-like operating system, you will be using tools whose origins are in the UNIX world, in the environment they were originally designed for.

To make it easier for you to get your feet wet, I have put together this self-introduction.

Goals

UNIX Accounts

You will be given an account which you will be able to access from the machines in W109. Usually, this account will have the same login name as your official PSU email address. Depending on exactly how the account is set up, you will be able to log into a UNIX machine and run programs.

Part I: Getting Started

Booting Into Linux

At a certain point in the boot-up process, it will give a choice of operating systems to run. Choose Linux, then wait for the login prompt to appear...

Logging-in from the Console

Red Hat Linux release 7.1 (Seawolf)
Kernel 2.4.2-2 on an i686
 
pavil login: _

Password: _

Setting up Your Account

[eetpc20:~/463]$ passwd
Changing password for rfisher
(current) UNIX password:	<- Type in the UNIX password that I gave you.

passwd: Authentication failure

New UNIX password:		<- Type in a new password using a mix
				   of numbers and upper and lower case
				   letters.

BAD PASSWORD: ...

Retype new UNIX password:	<- Retype your new password.  This
				   helps to ensure that you do not
				   mistype the new password and lock
				   yourself out of the account.

passwd: all authentication tokens updated successfully

Sorry, passwords do not match

You can now start using your UNIX account.

Once your shell starts (I will make it "bash" by default), it will display a "command prompt". You can then type in commands that it will attempt to execute for you. These commands fall into three categories:

1. Shell commands - Commands that the shell itself performs.
2. System programs - Names of executable files that are provided as part of the Linux operating system. The shell itself is actually a system program.
3. Applications programs - Names of executable files that are not part of the operating system, although they may be commonly supplied with it. The debate about Microsoft's Internet Explorer centered around whether it was a system program or an application.

I will introduce you to several commands and programs in this short tutorial. Here are a couple of short, and admittedly incomplete, lists of the ones you may find most useful:

• Typical shell commands
• Linux system programs.
• Application programs which may be of immediate interest.

Part II: The File System

Some directory in this tree will be your "home" directory, and you will store your files in it and the subdirectories below it. You will "own" these files and directories, and can add, remove, or modify these files and directories.

To get a listing of the files in the "current directory" execute the command "ls". You should see the following:

Desktop

drwxr-xr-x    5 Yourlogin      users        4096 Sep 11 09:43 Desktop

Let's work from left to right. The first letter of the permissions indicate what type of object the item is. Files will have a dash, -, and directories will have a letter 'd'. There are other types of things, but we won't worry about them yet.

Immediately following the type indicator, there are three sets of three characters. These are, respectively, the owner, group, and world "permission sets". The owner's permissions are "rwx" which means that the owner has "read", "write", and "execute" permissions for this directory. This means that the owner, "Yourlogin", can get a listing of the items in the subdirectory "Desktop" (that is, they can read it), change the information stored about the those items such as renaming a file in that directory (that is, they can write to the table which stores the information about the items in the directory), and change the current directory to "Desktop" (i.e. they can execute that directory).

The next set of permissions apply to the group "users". Anyone in that group can read or execute the directory, but they cannot write to it. This means that other people can go into your "Desktop" directory and get a listing of the files there, but they can not write their own files into it or rename yours. If the group had write permissions to "Desktop", they could do these things.

One caveat though, they would have to have execute permission through the entire path from the root to your Desktop directory to go into it. You must always have execute permission to a directory to go into it or any directory below it.

Groups are intended to allow a set of users to be specified which can have less permissions to certain files or directories than the owner(s) of those items, but more than the general class of users. This allows a group of students in a class to look at certain files, or people working on the same project to do so without other users on the system interfering or copying their work.

The final set of permissions is for anyone logged onto the system who isn't the owner or in the group that owns the item.

After the permissions is the number of links. We won't worry about that right now. Following this is the owner's login name or user ID (UID) number, and the name or group ID (GID) of the group which owns the file. You've already seen what these mean.

After this is the size. For a file, this would be the size of the file in bytes, but for a directory, it is the size of the disk are set aside to store its information.

The creation date and time follow the size, and finally, the name of the item itself is listed.

ls has another switch -a which shows "hidden" files. Let's do an "ls -la" or an "ls -al" (either works):

total 44
drwx------    4 rfisher   users        4096 Sep 11 10:55 .
drwx--x--x   16 root     root         4096 Sep 11 09:45 ..
-rw-------    1 rfisher   users           5 Sep 11 10:55 .bash_history
-rw-r--r--    1 rfisher   users          24 Sep 11 09:43 .bash_logout
-rw-r--r--    1 rfisher   users         230 Sep 11 09:43 .bash_profile
-rw-r--r--    1 rfisher   users         124 Sep 11 09:43 .bashrc
-rwxr-xr-x    1 rfisher   users         434 Sep 11 09:43 .emacs
drwxr-xr-x    3 rfisher   users        4096 Sep 11 09:43 .kde
-rw-r--r--    1 rfisher   users         435 Sep 11 09:43 .kderc
-rw-r--r--    1 rfisher   users        3394 Sep 11 09:43 .screenrc
drwxr-xr-x    5 rfisher   users        4096 Sep 11 09:43 Desktop

There are two special files "." and "..". "Dot" is the name given to the current directory. "dot dot", or "double-dot" is the name given to the parent directory of the current directory.

You can move up the tree by changing to the parent directory. You do this by using the "cd" command:

cd ..

ls: .: Permission denied

Okay, let's look at where we are, then take a short trip before heading back home. The "pwd" command lists the path from the root, named "/" to the current working directory (pwd=path to working directory). If you run it you will see:

/home/students

cd /

1. cd /home/students/Yourlogin/Desktop
2. cd ~Yourlogin/Desktop
3. cd ~/Desktop
4. cd ~Yourlogin; cd Desktop
5. cd; cd Desktop

Okay, we've killed cd. What if you want to make your own directories? You can do this with the "mkdir" command. You can also remove these directories with the "rmdir" command. In either case, you can name the directory using an absolute or relative pathname. Let's create a subdirectory for your first project called "Project0" off your home directory:

cd
mkdir Project0
cd Project0

total 8
drwxrwxr-x    2 rfisher  users      4096 Sep 13 17:17 ./
drwx------   10 rfisher  users      4096 Sep 13 17:17 ../

Part III: Basic File Manipulation

cat > hello.c

void main(void)
{
	printf("Hello, World!\n");
}

cat hello.c

void main(void)
{
	printf("Hello, World!\n");
}

Now, we should have #included stdio in the above file, so we need to get it at the top of the file somehow. Let's use cat to do this. First, we need to make a new file with the #include line in it. Let's call it "tmp:":

cat > tmp
#include <stdio.h>

cat tmp hello.c > tmp2

rm tmp2
cat tmp > tmp2
cat hello.c >> tmp2

We can look at what we have now by catting tmp2. We should see:

#include <stdio.h>
void main(void)
{
	printf("Hello, World!\n");
}

mv tmp2 hello.c
rm tmp

If you are in cenbd431 (VLSI Design), then skip ahead to Part V.

Otherwise, let's compile this puppy and see what we get!

Part IV: Compiling Using GCC

Let's use gcc to compile our hello.c now:

gcc -Wall -o hello hello.c

When we run gcc, it finds something to warn us about:

hello.c:3: warning: return type of `main' is not `int'

Part V: The vi Text Editor

To open an existing file using vi, you just enter "vi" followed by the file name:

vi hello.c

#include <stdio.h>
void main(void)
{
        printf("Hello, World!\n");
}
~
~
~
~
~
~
~
~
~
~
~
~
~
~
~
~
"hello.c" 5L, 67C

Right now, we are in "command mode". We can move the cursor around or give vi commands. Let's move to the word "void" using the cursor movement keys. h, j, k, and l move the cursor left, down, up, and right, respectively. The arrow keys on your keyboard may or may not move the cursor. The cursor starts at the upper left corner, so we want to move down one line to get to the beginning of "void". Do that now.

Now we want to change that word from "void" to "int". Do this by using the "change word" command, cw:

cw int<ESC>

Now, let's change the word "World" to "Randy". We can go directly to the word "World" by using the search command (/):

/World<Enter>

n

N

Okay, enough playing around, let's change this word. This time we'll use the replace-characters command (R):

RRandy<Esc>

Let's save this version and compile it. We do that using the write command (:w) [colon-w]. This tells vi to save the file with its current name, hello.c.

We could also save it with a different name, say randy.c, by using the :w command with a filename:

:w randy.c

Now, let's see the files in the current directory without leaving vi. We do this by invoking a shell from vi using the shell command (:!) followed by the command we want to execute (in this case ls):

:!ls<Enter>

Let's hit <Enter> then quit vi. We quit using the quit command (:q):

<Enter>
:q<Enter>

Okay, I said we would compile this, so let's do it:

gcc -Wall -o hello hello.c

gcc -Wall -o hello hello.c
hello.c: In function `main':
hello.c:5: warning: control reaches end of non-void function

vi hello.c

G

O<Tab>return<Esc>

A;

a 0

Let's use the go command to go to line 2 just for kicks. Just type:

2G

Now, let's change the void argument to main() to be "int argc, char *argv[]);". We can do this without causing any new errors or warnings. To do this we'll use the delete-character command (x) a couple of times, then the change-to-end-of-line command (c$):

/main
lllllxxc$int argc, char *argv[])<Esc>

We can remove a line entirely by doing a delete-line command (dd). First, let's add a junk line to the file...

2j
A<Enter><Tab>junk this line<Esc>

dd

kkkp

#include <stdio.h>
int main(int argc, char *argv[]);
        junk this line
{
        printf("Hello, Randy!\n");
        return 0;
}

j4ddP

#include <stdio.h>
int main(int argc, char *argv[]);
{
        printf("Hello, Randy!\n");
        return 0;
}
        junk this line

/junk<Enter>yyk%P

Now let's delete these lines and quit screwing around.

ddGdd

uuddGdd

:wq<Enter>

If you are in cenbd431 (VLSI Design), you can skip ahead to Appendix B.

Let's compile it one more time to see if it's still correct:

gcc -Wall -o hello hello.c

Part VI: make and makefiles

make is actually a pretty stupid program, what it does is to look at the source files that a target file depends on to see if they are newer (have been changed) since the last time the target file was built. If so, it will follow a list of commands that you supply to update the target file.

I have a reasonably good tutorial on make already, so I'll just give a URL for it here, and let you read it later. For now though, we'll go ahead and build a makefile for our hello project...

First let's call our makefile "Makefile" and write it with cat:

cat > Makefile

hello: hello.c

After the target line, we can have a set of "command" lines. Each of these must begin with a tab. These lines are a list of commands to execute, just as you would from the command prompt, to build the target from the dependencies. The command we have been using will suffice, so we will add the following line under the target line:

	gcc -Wall -o hello hello.c

	gcc -Wall -E -o hello.i hello.c
	gcc -Wall -S -o hello.s hello.i
	gcc -Wall -o hello hello.s

hello: hello.s
	gcc -Wall -o hello hello.s

hello.s: hello.i
	gcc -Wall -S -o hello.s hello.i

hello.i: hello.c
	gcc -Wall -E -o hello.i hello.c

Okay, now we have a "rule" for building hello from hello.c. Let's add a couple more to make it easier to manage the project. First, let's add a "clean" target. For this course, clean should remove any files that are not needed to build or execute the program. That means it should remove any .i, .o, and .s files that it might create, but not the source file "hello.c" or the executable file "hello":

clean:
	rm -f *.i *.o *.s

Now let's add one more target to clean up our source tree to be distributed. We'll call the target "distclean":

distclean: clean
	rm -f hello

If your lost here, it's because I didn't explain things too thoroughly above. Each target represents a file. If the file doesn't exist, or if the target file is older than any of its dependencies, the commands to build it will be run. Notice that none of the commands actually makes a file named "distclean", and also that none of them makes a file named "clean". Thus, whenever the rules for these targets are reached, the commands to build them will always be executed. This is really why we didn't need any dependencies in the rule for "clean".

Now make chains the dependencies to update each file that the target depends on before executing the commands to build that target. So, because distclean dependend on clean, the first thing that happens when make reaches the rule for distclean is that it updates the dependency clean by going to the rule to build it. There are no dependencies for clean, and never a file named "clean", so it tries to build it by executing the command "rm -f *.i *.o *.s". Then it returns to the rule for distclean.

If there were more dependencies for distclean, it would update each of them in turn, but because there aren't, it now checks to see if distclean is newer than its dependencies. Now, we know that distclean doesn't exist, so it will now try to build it by executing the command "rm -f hello".

Okay, we've played around enough here. You can read up on make in the tutuorial I mentioned above. Right now, your Makefile should look about like this:

hello: hello.c
	gcc -Wall -o hello hello.c

clean:
	rm -f *.i *.o *.s

distclean: clean
	rm -f hello

Part VII: Documenting Your Project

In this file you must list your name and the class number. You must also describe the choices you made in implementing your solution to the project (for example "I chose to use a linked list instead of an array because..."), and the problems you encountered in doing so (for example "This was a bad idea because...").

Your documentation should reflect the way your program really works (or doesn't), not the way it was supposed to work according to the project assignment. I already know what it says, and can always print up a copy if I forget.

Part VIII: Submitting Your Project

To submit your project sources, you must first clean them up for distribution. If you implemented your makefile correctly, you should be able to just do:

make distclean

Next, we want to convert the source tree into a single compressed file. To do this we will first move up one directory (to your home directory). You can do this by executing:

cd

tar cvzf Project0.tgz Project0

Now you have a single compressed archive of your project sources. However, this is a binary file, so we need to convert it to a text file so it can be mailed without getting trashed. We do this using "uuencode":

uuencode Project0.tgz Project0.tgz > Project0.uue

You will turn your project source archive in by mailing it to course account on ece.bd.psu.edu (for example, cenbd463@ece.bd.psu.edu for the Operating Systems course).

The subject line must include your login name and the project number. For example, if a student with the login "joe999" were in the Operating Systems course (cenbd463), he would use the command:

mail -s "joe999 project0" cenbd463@ece.bd.psu.edu < Project0.uue

Remember, you may submit new revisions of this project as often as you like up until the deadline. I will grade the last version submitted.

Appendix A: A Quick Word About Grading

It is important for you to realize that the scripts are not forgiving at all. If your programs do not output exactly the format I specify, the scripts will flag them as errors.

Appendix B: Other Resources

Here is a short list of Linux resources.

Appendix C: Xwindows