UNIX commands

Unix commands

Misc commands	File management	comparison and searching	Text processing
Shell and other programming	communications	Storage commands	System status

Misc commands

man,banner,cal, calendar,clear,nohup, tty .

Man ual command.
man man This is help command, and will explains you about online manual pages you can also use man in conjunction with any command to learn more about that command for example.

• man ls will explain about the ls command and how you can use it.
• man -k pattern command will search for the pattern in given command.

---

Banner command.
banner prints characters in a sort of ascii art poster, for example to print wait in big letters. I will type
banner wait at unix command line or in my script. This is how it will look.

    #    #    ##       #     #####  #    #   #  #      #       #  #    #  #    #     #       #  # ## #  ######     #       #  ##  ##  #    #     #       #  #    #  #    #     #       #  

---

Cal command
cal command will print the calander on current month by default. If you want to print calander of august of 1965. That's eightht month of 1965.
cal 8 1965 will print following results.

    August 1965  S  M Tu  W Th  F  S  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31  

---

Clear command

clear command clears the screen and puts cursor at beginning of first line.

---

Calendar command
calendar command reads your calendar file and displays only lines with current day.
For example in your calendar file if you have this

12/20   Test new software. 1/15    Test newly developed 3270 product. 1/20    Install memory on HP 9000 machine.

On dec 20th the first line will be displayed. you can use this command with your crontab file or in your login files.

---

Nohup command.
nohup command if added in front of any command will continue running the command or process even if you shut down your terminal or close your session to machine. For exmaple, if I want to run a job that takes lot of time and must be run from terminal and is called update_entries_tonight .
nohup update_entries_tonight will run the job even if terminal is shut down in middle of this job.

---

Tty command
Tty command will display your terminal. Syntax is
tty options

Options
• -l will print the synchronous line number.
• -s will return only the codes: 0 (a terminal), 1 (not a terminal), 2 (invalid options) (good for scripts)

---

back to top of misc commands
back to top of page

---

File Management commands.

cat,cd, cp, file,head,tail, ln,ls,mkdir ,more,mv, pwd, rcp,rm, rmdir, wc.

---

Pwd command.
pwd command will print your home directory on screen, pwd means print working directory.

 /u0/ssb/sandeep

is output for the command when I use pwd in /u0/ssb/sandeep directory.

---

Ls command
ls command is most widely used command and it displays the contents of directory.

options
• ls will list all the files in your home directory, this command has many options.
• ls -l will list all the file names, permissions, group, etc in long format.
• ls -a will list all the files including hidden files that start with . .
• ls -lt will list all files names based on the time of creation, newer files bring first.
• ls -Fxwill list files and directory names will be followed by slash.
• ls -Rwill lists all the files and files in the all the directories, recursively.
• ls -R | more will list all the files and files in all the directories, one page at a time.

---

Mkdir command.
mkdir sandeep will create new directory, i.e. here sandeep directory is created.

---

Cd command.
cd sandeep will change directory from current directory to sandeep directory.
Use pwd to check your current directory and ls to see if sandeep directory is there or not.
You can then use cd sandeep to change the directory to this new directory.

---

Cat command
cat cal.txt cat command displays the contents of a file here cal.txt on screen (or standard out).

---

Head command.
head filename by default will display the first 10 lines of a file.
If you want first 50 lines you can use head -50 filename or for 37 lines head -37 filename and so forth.

---

Tail command.
tail filename by default will display the last 10 lines of a file.
If you want last 50 lines then you can use tail -50 filename.

---

More command. more command will display a page at a time and then wait for input which is spacebar. For example if you have a file which is 500 lines and you want to read it all. So you can use

more filename

---

Wc command
wc command counts the characters, words or lines in a file depending upon the option.

Options
• wc -l filename will print total number of lines in a file.
• wc -w filename will print total number of words in a file.
• wc -c filename will print total number of characters in a file.

---

File command.
File command displays about the contents of a given file, whether it is a text (Ascii) or binary file. To use it type
file filename. For example I have cal.txt which has ascii characters about calander of current month and I have resume1.doc file which is a binariy file in microsoft word. I will get
file resume.doc

resume1.doc:    data   

file cal.txt

cal.txt:        ascii text

---

Cp command.
cp command copies a file. If I want to copy a file named oldfile in a current directory to a file named newfile in a current directory.
cp oldfile newfile
If I want to copy oldfile to other directory for example /tmp then
cp oldfile /tmp/newfile. Useful options available with cp are -p and -r . -p options preserves the modification time and permissions, -r recursively copy a directory and its files, duplicating the tree structure.

---

Rcp command.
rcp command will copy files between two unix systems and works just like cp command (-p and -i options too).
For example you are on a unix system that is called Cheetah and want to copy a file which is in current directory to a system that is called lion in /usr/john/ directory then you can use rcp command
rcp filename lion:/usr/john
You will also need permissions between the two machines. For more infor type man rcp at command line.

---

Mv command.
mv command is used to move a file from one directory to another directory or to rename a file.

Some examples:
• mv oldfile newfile will rename oldfile to newfile.
• mv -i oldfile newfile for confirmation prompt.
• mv -f oldfile newfile will force the rename even if target file exists.
• mv * /usr/bajwa/ will move all the files in current directory to /usr/bajwa directory.

---

Ln command.
Instead of copying you can also make links to existing files using ln command.
If you want to create a link to a file called coolfile in /usr/local/bin directory then you can enter this command.
ln mycoolfile /usr/local/bin/coolfile

Some examples:
• ln -s fileone filetwo will create a symbolic link and can exist across machines.
• ln -n option will not overwrite existing files.
• ln -f will force the link to occur.

---

Rm command.
To delete files use rm command.

Options:
• rm oldfile will delete file named oldfile.
• rm -f option will remove write-protected files without prompting.
• rm -r option will delete the entire directory as well as all the subdirectories, very dangerous command.

---

Rmdir command.
rmdir command will remove directory or directories if a directory is empty.

Options:
• rm -r directory_name will remove all files even if directory is not empty.
• rmdir sandeep is how you use it to remove sandeep directory.
• rmdir -p will remove directories and any parent directories that are empty.
• rmdir -s will suppress standard error messages caused by -p.

---

back to top of File management commands
back to top of page

---

Comparison and Searching

diff,dircmp, cmp, grep, find.

---

Diff command.
diff command will compare the two files and print out the differences between.
Here I have two ascii text files. fileone and file two.
Contents of fileone are

This is first file  this is second line this is third line this is different    as;lkdjf  this is not different

filetwo contains

This is first file this is second line this is third line this is different    xxxxxxxas;lkdjf this is not different

diff fileone filetwo will give following output

 4c4 < this is different    as;lkdjf --- > this is different    xxxxxxxas;lkdjf

---

Cmp command.
cmp command compares the two files. For exmaple I have two different files fileone and filetwo.
cmp fileone filetwo will give me

fileone filetwo differ: char 80, line 4 

if I run cmp command on similar files nothing is returned.
-s command can be used to return exit codes. i.e. return 0 if files are identical, 1 if files are different, 2 if files are inaccessible.
This following command prints a message 'no changes' if files are same
cmp -s fileone file1 && echo 'no changes' .

no changes

---

Dircmp Command.
dircmp command compares two directories. If i have two directories in my home directory named
dirone and dirtwo and each has 5-10 files in it. Then
dircmp dirone dirtwo will return this

 Dec  9 16:06 1997  dirone only and dirtwo only Page 1     ./cal.txt                                   ./fourth.txt ./dohazaar.txt                              ./rmt.txt ./four.txt                                  ./te.txt ./junk.txt                                  ./third.txt ./test.txt 

---

Grep Command
grep command is the most useful search command. You can use it to find processes running on system, to find a pattern in a file, etc. It can be used to search one or more files to match an expression.
It can also be used in conjunction with other commands as in this following example, output of ps command is passed to grep command, here it means search all processes in system and find the pattern sleep.
ps -ef | grep sleep will display all the sleep processes running in the system as follows.

     ops 12964 25853  0 16:12:24 ttyAE/AAES  0:00 sleep 60      dxi 12974 15640  0 16:12:25 ttyAH/AAHP  0:00 sleep 60      ops 12941 25688  0 16:12:21 ttyAE/AAEt  0:00 sleep 60      ops 12847 25812  0 16:11:59 ttyAH/AAH6  0:00 sleep 60      ops 12894 25834  0 16:12:12 ttyAE/AAEX  0:00 sleep 60      dxi 13067 27253  2 16:12:48 ttyAE/ABEY  0:00 sleep 1      ops 13046 25761  0 16:12:44 ttyAE/AAE0  0:00 sleep 60      dxi 12956 13078  0 16:12:23 ttyAG/AAG+  0:00 sleep 60      ops 12965 25737  0 16:12:24 ttyAE/AAEp  0:00 sleep 60      ops 12989 25778  0 16:12:28 ttyAH/AAHv  0:00 sleep 60      ssb 13069 26758  2 16:12:49 ttyAH/AAHs  0:00 grep sleep      pjk 27049  3353  0 15:20:23 ?           0:00 sleep 3600

Options:
• -b option will precede each line with its block number.
• -c option will only print the count of matched lines.
• -i ignores uppercase and lowercase distinctions.
• -l lists filenames but not matched lines.

other associated commands with grep are egrep and fgrep. egrep typically runs faster. for more information type man egrep or man fgrep in your system.

---

Find command.
Find command is a extremely useful command. you can search for any file anywhere using this command provided that file and directory you are searching has read write attributes set to you ,your, group or all. Find descends directory tree beginning at each pathname and finds the files that meet the specified conditions. Here are some examples.

Some Examples:
find $HOME -print will lists all files in your home directory.
find /work -name chapter1 -print will list all files named chapter1 in /work directory.
find / -type d -name 'man*' -print will list all manpage directories.
find / -size 0 -ok rm {} \; will remove all empty files on system.

conditions of find

• -atime +n |-n| n will find files that were last accessed more than n or less than -n days or n days.
• -ctime +n or -n will find that were changed +n -n or n days ago.
• -depth descend the directory structure, working on actual files first and then directories. You can use it with cpio command.
• -exec commad {} \; run the Unix command on each file matched by find. Very useful condition.
• -print print or list to standard output (screen).
• -name pattern find the pattern.
• -perm nnnfind files whole permission flags match octal number nnn.
• -size n find files that contain n blocks.
• -type c Find file whole type is c. C could be b or block, c Character special file, d directory, p fifo or named pipe, l symbolic link, or f plain file.

back to top of misc commands
back to top of page

---

Text processing

cut,paste, sort, uniq,awk,sed,vi.

---

Cut command.
cut command selects a list of columns or fields from one or more files.
Option -c is for columns and -f for fields. It is entered as
cut options [files]
for example if a file named testfile contains

this is firstline this is secondline this is thirdline

Examples:
cut -c1,4 testfile will print this to standard output (screen)

ts ts ts

It is printing columns 1 and 4 of this file which contains t and s (part of this).

Options:
• -c list cut the column positions identified in list.
• -f list will cut the fields identified in list.
• -s could be used with -f to suppress lines without delimiters.

---

Paste Command.
paste command merge the lines of one or more files into vertical columns separated by a tab.
for example if a file named testfile contains

this is firstline

and a file named testfile2 contains

this is testfile2

then running this command
paste testfile testfile2 > outputfile
will put this into outputfile

this is firstline       this is testfile2 

it contains contents of both files in columns.
who | paste - - will list users in two columns.

Options:
• -d'char' separate columns with char instead of a tab.
• -s merge subsequent lines from one file.

---

Sort command.
sort command sort the lines of a file or files, in alphabetical order. for example if you have a file named testfile with these contents

zzz aaa 1234 yuer wer qww wwe

Then running
sort testfile
will give us output of

1234 aaa qww wer wwe yuer zzz

Options:
• -b ignores leading spaces and tabs.
• -c checks whether files are already sorted.
• -d ignores punctuation.
• -i ignores non-printing characters.
• -n sorts in arithmetic order.
• -ofile put output in a file.
• +m[-m] skips n fields before sorting, and sort upto field position m.
• -r reverse the order of sort.
• -u identical lines in input file apear only one time in output.

---

Uniq command.
uniq command removes duplicate adjacent lines from sorted file while sending one copy of each second file.
Examples

sort names | uniq -d will show which lines appear more than once in names file.

Options:
• -c print each line once, counting instances of each.
• -d print duplicate lines once, but no unique lines.
• -u print only unique lines.

---

Awk and Nawk command.
awk is more like a scripting language builtin on all unix systems. Although mostly used for text processing, etc.
Here are some examples which are connected with other commands.
Examples:
df -t | awk 'BEGIN {tot=0} $2 == "total" {tot=tot+$1} END {print (tot*512)/1000000}' Will give total space in your system in megabytes.
Here the output of command df -t is being passed into awk which is counting the field 1 after pattern "total" appears. Same way if you change $1 to $4 it will accumulate and display the addition of field 4
which is used space.
for more information about awk and nawk command in your system enter man awk or man nawk.

---

Sed command.
sed command launches a stream line editor which you can use at command line.
you can enter your sed commands in a file and then using -f option edit your text file. It works as
sed [options] files

options:
• -e 'instruction' Apply the editing instruction to the files.
• -f script Apply the set of instructions from the editing script.
• -n suppress default output.

for more information about sed, enter man sed at command line in your system.

---

Vi editor.
vi command launches a vi sual editor. To edit a file type
vi filename
vi editor is a default editor of all Unix systems. It has several modes. In order to write characters you will need to hit i to be in insert mode and then start typing. Make sure that your terminal has correct settings, vt100 emulation works good if you are logged in using pc.
Once you are done typing then to be in command mode where you can write/search/ you need to hit :w filename to write
and in case you are done writing and want to exit
:w! will write and exit.

options:
• i for insert mode.
  • I inserts text at the curson
  • A appends text at the end of the line.
  • a appends text after cursor.
  • O open a new line of text above the curson.
  • o open a new line of text below the curson.
• : for command mode.
  • to invoke command mode from insert mode.
  • :!sh to run unix commands.
  • x to delete a single character.
  • dd to delete an entire line
  • ndd to delete n number of lines.
  • d$ to delete from cursor to end of line.
  • yy to copy a line to buffer.
  • P to paste text from buffer.
  • nyy copy n number of lines to buffer.
  • :%s/stringA/stringb /g to replace stringA with stringB in whole file.
  • G to go to last line in file.
  • 1G to go to the first line in file.
  • w to move forward to next word.
  • b to move backwards to next word.
  • $ to move to the end of line.
  • J join a line with the one below it.
• /string to search string in file.
• n to search for next occurence of string.

---

back to top of Text processing commands
back to top of page

---

Shell and programming
Shell programming,bourne shell, ksh, csh, echo,line,sleep, test,cc compiler.

---

Shell programming concepts and commands.
Shell programming is integral part of Unix operating systems. Shell is command line userinterface to Unix operating system, User have an option of picking an interface on Unix such as ksh, csh, or default sh., these are called shells(interface). Shell programming is used to automate many tasks. Shell programming is not a programming language in the truest sense of word since it is not compiled but rather an interpreted language. Unix was written in C language and thus c language is integral part of unix and available on all versions. Shells, like ksh and csh are popular shells on unix although there are 5 or 6 different shells available but I will only be discussing ksh and csh as well as sh. Common features among all shells are job control, for example if I am running a processes which is searching the whole system for .Z files and output is directed to a file named compressedfiles.

example:
• find / -name *.Z -print > compressedfiles
  then after entering this command hitting
• 
  key will suspend this job, then entering
• bg
  at command line will put this job in background, entering
• fg
  will put this job in foreground. Entering
• jobs
  at command line will show me all my concurrent jobs that are running.
  Other common features
  • > will redirect output from standard out (screen) to file or printer or whatever you like.
  • >> filename will append at the end of a file called filename.
  • < will redirect input to a process or commnand.
  • | pipe output, or redirect output, good for joining commands, i.e. find command with cpio, etc.
  • & at the end of command will run command in background.
  • ; will separate commands on same line.
  • * will match any characters in a file or directories. junk* will match all files with first 4 letters
  • ? will match single characters in a file.
  • [] will match any characters enclosed.
  • () execute in subshell.
  • ` ` to run a command inside another command and use its output.
  • " " partial quote for variables.
  • ' ' full quote for variables.
  • # begin comment (if #/bin/ksh or csh or sh is entered at first line of script it runs script in that shell)
  • bg background execution.
  • break break from loop statements.
  • continue Resume a program loop.
  • Kill pid number will terminate running jobs
  • stop will stop background job.
  • suspend will suspend foreground job.
  • wait will wait for a background job to finish.

---

Bourne Shell (sh shell).
sh or Bourne shell is default shell of Unix operating systems and is the most simplest shell in Unix systems.

Examples:
• cd; ls execute one after another.
• (date;who;pwd)> logifile will redirect all the output from three commands to a filenamed logfile.
• sort file | lp will first sort a file and then print it.
• alias [options] [name[='command']] will let you create your own commands. i.e.
  • alias ll="ls -la" will execute `ls -la` command whenever ll is entered.
• let expressions is syntax of let statement.
  • let i=i+1 will work as a counter with i incrementing each time this statement is encountered.
• for x[in list] do commands done is syntax for for do loop.
• function name {commands;} is the syntax of a function which can be called from anywhere in program.
• if condition1 then commands1 elif condition2 then commands2 ... ... ... else commands3 fi

---

Ksh shell (Korn).
Ksh or Korn shell is widely used shell.

---

Csh or C shell
csh is second most used shell.

---

Echo command
echo command in shell programming.

---

Line command.
line command in shell programming.

---

Sleep command.
sleep command in shell programming.

---

Test Command.
test command in shell programming.

---

CC compiler (c programming language compiler).
Since Unix is itself written in C programming language, most Unix operating systems come with c compiler called cc.

---

back to top of Shell programming.
back to top of page

---

Communications
cu,ftp,login, rlogin,talk,telnet, vacation and write .

---

Cu command.
cu command is used for communications over a modem or direct line with another Unix system.
Syntax is
cu options destination

Options
• -bn process lines using n-bit characters (7 or 8).
• -cname Search UUCP's device file and select local area network that matches name.
• -d Prints diagnostics.
• -e sends even parity data to remote system
• -lline communicate on this device (line=/dev/tty001, etc)
• -n prompts for a telephone number.
• -sn set transmission rate to n(e.g 1200,2400,9600, BPS)

Destination
• telno is the telephone number of the modem to connect to.
• system is call the system known to uucp.
• aadr is an address specific to LAN.

---

Ftp command (protocol).
ftp command is used to execute ftp protocol using which files are transferred over two systems.
Syntax is
ftp options hostname

options
• -d enable debugging.
• -g disable filename globbing.
• -i turn off interactive prompts.
• -v verbose on. show all responses from remote server.

ftp hostname by default will connect you to the system, you must have a login id to be able to transfer the files. Two types of files can be transferred, ASCII or Binary. bin at ftp> prompt will set the transfer to binary. Practice FTP by ftping to nic.funet.fi loggin in as anomymous with password being your e-mail address.

---

Login command.
login command invokes a login session to a Unix system, which then authenticates the login to a system. System prompts you to enter userid and password.

---

Rlogin command.
rlogin command is used to log on to remote Unix systems, user must have permissions on both systems as well as same userid, or an id defined in .rhosts file. Syntax is
rlogin options host

options
• -8 will allow 8 bit data to pass, instead of 7-bit data.
• -e c will let you use escape character c.
• -l user will let you to login as user to remote host, instead of same as local host.

---

Talk command.
talk command is used to invoke talk program available on all unix system which lets two users exchange information back and forth in real time. Syntax is
talk userid@hostname

---

Telnet command.
Telnet command invokes a telnet protocol which lets you log on to different unix, vms or any machine connected over TCP/IP protocol, IPx protocol or otherwise. Syntax is
telnet hostname

---

Vacation command.
vacation command is used when you are out of office. It returns a mail message to sender announcing that you are on vacation. to disable this feature, type mail -F " " .
syntax is
vacation options

Options
• -d will append the date to the logfile.
• -F user will forward mail to user when unable to send mail to mailfile.
• -l logfile will record in the logfile the names of senders who received automatic reply.
• -m mailfile will save received messages in mailfile.

---

Write command will initiate an interactive conversation with user. Syntax is
write user tty

---

back to top of communications commands
back to top of page

---

Storage commands compress uncompress, cpio,dump,pack, tar, mt.

---

Compress command.
Compress command compresses a file and returns the original file with .z extension, to uncompress this filename.Z file use uncompress filename command. syntax for compress command is
compress options files

Options
• -bn limit the number of bits in coding to n.
• -c write to standard output (do not change files).
• -f compress conditionally, do not prompt before overwriting files.
• -v Print the resulting percentage of reduction for files.

---

Uncompress command.
Uncompress file uncompresses a file and return it to its original form.
syntax is
uncompress filename.Z this uncompresses the compressed file to its original name.

Options
• -c write to standard output without changing files

---

Cpio command.
cpio command is useful to backup the file systems. It copy file archives in from or out to tape or disk, or to another location on the local machine. Its syntax is
cpio flags [options]

It has three flags, -i, -o, -p
• cpio -i [options] [patterns]
  • cpio -i copy in files who names match selected patterns.
  • If no pattern is used all files are copied in.
  • It is used to write to a tape.
  cpio -o
  • Copy out a list of files whose name are given on standard output.
  cpio -p
  • copy files to another directory on the same system.
  Options
  • -a reset access times of input files.
  • -A append files to an archive (must use with -o).
  • -b swap bytes and half-words. Words are 4 bytes.
  • -B block input or output using 5120 bytes per record.
  • -c Read or write header information as Ascii character.
  • -d create directories as needed.
  • -l link files instead of copying.
  • -o file direct output to a file.
  • -r rename files interactively.
  • -R ID reassign file ownership and group information to the user's login ID.
  • -V print a dot for each file read or written.
  • -s swap bytes.
  • -S swap half bytes.
  • -v print a list of filenames.
  Examples
  • find . -name "*.old" -print | cpio -ocvB > /dev/rst8 will backup all *.old files to a tape in /dev/rst8
  • cpio -icdv "save"" < /dev/rst8 will restore all files whose name contain "save"
  • find . -depth -print | cpio -padm /mydir will move a directory tree.

---

Dump command is useful to backup the file systems.
dump command copies all the files in filesystem that have been changed after a certain date. It is good for incremental backups. This information about date is derived from /var/adm/dumpdates and /etc/fstab .
syntax for HP-UX dump is
/usr/sbin/dump [option [argument ...] filesystem]

Options
• 0-9 This number is dump level. 0 option causes entire filesystem to be dumped.
• b blocking factor taken into argument.
• d density of tape default value is 1600.
• f place the dump on next argument file instead of tape.
• This example causes the entire file system (/mnt) to be dumped on /dev/rmt/c0t0d0BEST and specifies that the density of the tape is 6250 BPI.
  • /usr/sbin/dump 0df 6250 /dev/rmt/c0t0d0BEST /mnt
• for more info type man dump at command line.

---

Pack command.
pack command compacts each file and combine them together into a filename.z file. The original file is replaced. Pcat and unpack will restore packed files to their original form.
Syntax is
Pack options files

Options
• - Print number of times each byte is used, relative frequency and byte code.
• -f Force the pack even when disk space isn't saved.

• To display Packed files in a file use pcat command
  pcat filename.z
• To unpack a packed file use unpack command as unpack filename.z .

---

Tar command.
tar command creates an archive of files into a single file.
Tar copies and restore files to a tape or any storage media. Synopsis of tar is
tar [options] [file]

Examples:
tar cvf /dev/rmt/0 /bin /usr/bin creates an archive of /bin and /usr/bin, and store on the tape in /dev/rmt0.
tar tvf /dev/rmt0 will list the tape's content in a /dev/rmt0 drive.
tar cvf - 'find . -print' > backup.tar will creates an archive of current directory and store it in file backup.tar.

Functions:
• c creates a new tape.
• r append files to a tape.
• t print the names of files if they are stored on the tape.
• x extract files from tape.

Options:
• b n use blocking factor of n.
• l print error messages about links not found.
• L follow symbolic links.
• v print function letter (x for extraction or a for archive) and name of files.

---

Mt command

Mt command is used for tape and other device functions like rewinding, ejecting, etc. It give commands to tape device rather than tape itself. Mt command is BSD command and is seldom found in system V unix versions.
syntax is
mt [-t tapename] command [count]

mt for HP-UX accept following commands
• eof write count EOF marks.
• fsf Forward space count files.
• fsr Forward space count records.
• bsf Backward space count files.
• bsr Backward space count records.
• rew Rewind tape.
• offl Rewind tape and go offline.
• eod Seek to end of data (DDS and QIC drives only).
• smk Write count setmarks (DDS drives only).
• fss Forward space count setmarks (DDS drives only).
• bss Backward space count setmarks (DDS drives only).
• Examples
  • mt -t /dev/rmt/0mnb rew will rewind the tape in this device.
  • mt -t /dev/rmt/0mnb offl will eject the tape in this device.

---

back to top of storage commands
back to top of page

---

System Status

at, chmod,chgrp, chown,crontab,date, df,du, env, finger, ps,ruptime, shutdwon,stty, who.

---

At command.
at command along with crontab command is used to schedule jobs.
at options time [ddate] [+increment] is syntax of at command.
for example if I have a script named usersloggedin which contains.

 #!/bin/ksh who | wc -l echo "are total number of people logged in at this time."

and I want to run this script at 8:00 AM. So I will first type at 8:00 %lt;enter>
usersloggedin %lt;enter>
I will get following output at 8:00 AM

      30 are total number of people logged in at this time.

Options:
• -f file will execute commands in a file.
• -m will send mail to user after job is completed.
• -l will report all jobs that are scheduled and their jobnumbers.
• -r jobnumber will remove specified jobs that were previously scheduled.

---

Chmod command.
chmod command is used to change permissions on a file.
for example if I have a text file with calender in it called cal.txt.
initially when this file will be created the permissions for this file depends upon umask set in your profile files. As you can see this file has 666 or -rw-rw-rw attributes.

ls -la cal.txt

-rw-rw-rw-    1 ssb      dxidev       135 Dec  3 16:14 cal.txt

In this line above I have -rw-rw-rw- meaning respectively that owner can read and write file, member of the owner's group can read and write this file and anyone else connected to this system can read and write this file., next ssb is owner of this file dxidev is the group of this file, there are 135 bytes in this file, this file was created on December 3 at time16:14 and at the end there is name of this file. Learn to read these permissions in binary, like this for example Decimal 644 which is 110 100 100 in binary meand rw-r--r-- or user can read,write this file, group can read only, everyone else can read only. Similarly, if permissions are 755 or 111 101 101 that means rwxr-xr-x or user can read, write and execute, group can read and execute, everyone else can read and execute. All directories have d in front of permissions. So if you don't want anyone to see your files or to do anything with it use chmod command and make permissions so that only you can read and write to that file, i.e.
chmod 600 filename.

---

Chgrp command.
chgrp command is used to change the group of a file or directory.
You must own the file or be a superuser.
chgrp [options] newgroup files is syntax of chgrp.
Newgroup is either a group Id or a group name located in /etc/group .

Options:
• -h will change the group on symbolic links.
• -R recursively descend through directory changing group of all files and subdirectories.

---

Chown command.
chown command to change ownership of a file or directory to one or more users.
Syntax is
chown options newowner files

Options
• -h will change the owner on symbolic links.
• -R will recursively descend through the directory, including subdirectories and symbolic links.

---

Crontab command.
crontab command is used to schedule jobs. You must have permission to run this command by unix Administrator. Jobs are scheduled in five numbers, as follows.

 Minutes   0-59     Hour      0-23     Day of month 1-31     month   1-12     Day of week  0-6 (0 is sunday) 

so for example you want to schedule a job which runs from script named backup_jobs in /usr/local/bin directory on sunday (day 0) at 11.25 (22:25) on 15th of month. The entry in crontab file will be. * represents all values.

 25 22  15 * 0 /usr/local/bin/backup_jobs 

The * here tells system to run this each month.
Syntax is
crontab file So a create a file with the scheduled jobs as above and then type
crontab filename .This will scheduled the jobs.

---

Date command.
Date displays todays date, to use it type date at prompt.

Sun Dec  7 14:23:08 EST 1997 

is similar to what you should see on screen.

---

Df command.
df command displays information about mounted filesystems. It reports the number of free disk blocks. Typically a Disk block is 512 bytes (or 1/2 Kilobyte).
syntax is
df options name

Options
• -b will print only the number of free blocks.
• -e will print only the number of free files.
• -f will report free blocks but not free inodes.
• -F type will report on an umounted file system specified by type.
• -k will print allocation in kilobytes.
• -l will report only on local file systems.
• -n will print only the file system name type, with no arguments it lists type of all filesystems

---

Du command.
du command displays disk usage.

---

Env command.
env command displays all the variables.

---

Finger command.
finger command.

---

PS command
ps command is probably the most useful command for systems administrators. It reports information on active processes.
ps options

options.
• -a Lists all processes in system except processes not attached to terminals.
• -e Lists all processes in system.
• -f Lists a full listing.
• -j print process group ID and session ID.

---

Ruptime command.
ruptime command tells the status of local networked machines.
ruptime options

options.
• -a include user even if they've been idle for more than one hour.
• -l sort by load average.
• -r reverse the sort order.
• -t sort by uptime.
• -i sort by number of users.

---

Shutdown command.
Shutdown command can only be executed by root. To gracefully bring down a system, shutdown command is used.

options.
• -gn use a grace-period of n seconds (default is 60).
• -ik tell the init command to place system in a state k.
  • s single-user state (default)
  • 0 shutdown for power-off.
  • 1 like s, but mount multi-user file systems.
  • 5 stop system, go to firmware mode.
  • 6 stop system then reboot.
• -y suppress the default prompt for confirmation.

---

Stty command
stty command sets terminal input output options for the current terminal. without options stty reports terminal settings.
stty options modes < device

options
• -a report all options.
• -g report current settings.

Modes
• 0 hang up phone.
• n set terminal baud.
• erase keyname, will change your keyname to be backspace key.

---

Who command
who command displays information about the current status of system.
who options file
Who as default prints login names of users currently logged in.

Options
• -a use all options.
• -b Report information about last reboot.
• -d report expired processes.
• -H print headings.
• -p report previously spawned processes.
• -u report terminal usage.

UNIX Origin and History 1969-95

A notorious ‘second-system effect‘ often afflicts the successors of small experimental prototypes. The urge to add everything that was left out the first time around all too frequently leads to huge and overcomplicated design. Less well known, because less common, is the ‘third-system effect’; sometimes, after the second system has collapsed of its own weight, there is a chance to go back to simplicity and get it really right.

The original Unix was a third system. Its grandfather was the small and simple Compatible Time-Sharing System (CTSS), either the first or second timesharing system ever deployed (depending on some definitional questions we are going to determinedly ignore). Its father was the pioneering Multics project, an attempt to create a feature-packed ‘information utility’ that would gracefully support interactive timesharing of mainframe computers by large communities of users. Multics, alas, did collapse of its own weight. But Unix was born from that collapse.

Genesis: 1969–1971

Unix was born in 1969 out of the mind of a computer scientist at Bell Laboratories, Ken Thompson. Thompson had been a researcher on the Multics project, an experience which spoiled him for the primitive batch computing that was the rule almost everywhere else. But the concept of timesharing was still a novel one in the late 1960s; the first speculations on it had been uttered barely ten years earlier by computer scientist John McCarthy (also the inventor of the Lisp language), the first actual deployment had been in 1962, seven years earlier, and timesharing operating systems were still experimental and temperamental beasts.

Computer hardware was at that time more primitive than even people who were there to see it can now easily recall. The most powerful machines of the day had less computing power and internal memory than a typical cellphone of today.^[13] Video display terminals were in their infancy and would not be widely deployed for another six years. The standard interactive device on the earliest timesharing systems was the ASR-33 teletype — a slow, noisy device that printed upper-case-only on big rolls of yellow paper. The ASR-33 was the natural parent of the Unix tradition of terse commands and sparse responses.

When Bell Labs withdrew from the Multics research consortium, Ken Thompson was left with some Multics-inspired ideas about how to build a file system. He was also left without a machine on which to play a game he had written called Space Travel, a science-fiction simulation that involved navigating a rocket through the solar system. Unix began its life on a scavenged PDP-7 minicomputer^[14] like the one shown in Figure 2.1, as a platform for the Space Travel game and a testbed for Thompson's ideas about operating system design.

Figure 2.1. The PDP-7.

The full origin story is told in [Ritchie79] from the point of view of Thompson's first collaborator, Dennis Ritchie, the man who would become known as the co-inventor of Unix and the inventor of the C language. Dennis Ritchie, Doug McIlroy, and a few colleagues had become used to interactive computing under Multics and did not want to lose that capability. Thompson's PDP-7 operating system offered them a lifeline.

Ritchie observes: “What we wanted to preserve was not just a good environment in which to do programming, but a system around which a fellowship could form. We knew from experience that the essence of communal computing, as supplied by remote-access, time-shared machines, is not just to type programs into a terminal instead of a keypunch, but to encourage close communication”. The theme of computers being viewed not merely as logic devices but as the nuclei of communities was in the air; 1969 was also the year the ARPANET (the direct ancestor of today's Internet) was invented. The theme of “fellowship” would resonate all through Unix's subsequent history.

Thompson and Ritchie's Space Travel implementation attracted notice. At first, the PDP-7's software had to be cross-compiled on a GE mainframe. The utility programs that Thompson and Ritchie wrote to support hosting game development on the PDP-7 itself became the core of Unix — though the name did not attach itself until 1970. The original spelling was “UNICS” (UNiplexed Information and Computing Service), which Ritchie later described as “a somewhat treacherous pun on Multics”, which stood for MULTiplexed Information and Computing Service.

Even at its earliest stages, PDP-7 Unix bore a strong resemblance to today's Unixes and provided a rather more pleasant programming environment than was available anywhere else in those days of card-fed batch mainframes. Unix was very close to being the first system under which a programmer could sit down directly at a machine and compose programs on the fly, exploring possibilities and testing while composing. All through its lifetime Unix has had a pattern of growing more capabilities by attracting highly skilled volunteer efforts from programmers impatient with the limitations of other operating systems. This pattern was set early, within Bell Labs itself.

The Unix tradition of lightweight development and informal methods also began at its beginning. Where Multics had been a large project with thousands of pages of technical specifications written before the hardware arrived, the first running Unix code was brainstormed by three people and implemented by Ken Thompson in two days — on an obsolete machine that had been designed to be a graphics terminal for a ‘real’ computer.

Unix's first real job, in 1971, was to support what would now be called word processing for the Bell Labs patent department; the first Unix application was the ancestor of the nroff(1) text formatter. This project justified the purchase of a PDP-11, a much more capable minicomputer. Management remained blissfully unaware that the word-processing system that Thompson and colleagues were building was incubating an operating system. Operating systems were not in the Bell Labs plan — AT&T had joined the Multics consortium precisely to avoid doing an operating system on its own. Nevertheless, the completed system was a rousing success. It established Unix as a permanent and valued part of the computing ecology at Bell Labs, and began another theme in Unix's history — a close association with document-formatting, typesetting, and communications tools. The 1972 manual claimed 10 installations.

Later, Doug McIlroy would write of this period [McIlroy91]: “Peer pressure and simple pride in workmanship caused gobs of code to be rewritten or discarded as better or more basic ideas emerged. Professional rivalry and protection of turf were practically unknown: so many good things were happening that nobody needed to be proprietary about innovations”. But it would take another quarter century for all the implications of that observation to come home.

Exodus: 1971–1980

The original Unix operating system was written in assembler, and the applications in a mix of assembler and an interpreted language called B, which had the virtue that it was small enough to run on the PDP-7. But B was not powerful enough for systems programming, so Dennis Ritchie added data types and structures to it. The resulting C language evolved from B beginning in 1971; in 1973 Thompson and Ritchie finally succeeded in rewriting Unix in their new language. This was quite an audacious move; at the time, system programming was done in assembler in order to extract maximum performance from the hardware, and the very concept of a portable operating system was barely a gleam in anyone's eye. As late as 1979, Ritchie could write: “It seems certain that much of the success of Unix follows from the readability, modifiability, and portability of its software that in turn follows from its expression in high-level languages”, in the knowledge that this was a point that still needed making.

Ken (seated) and Dennis (standing) at a PDP-11 in 1972.

A 1974 paper in Communications of the ACM [Ritchie-Thompson] gave Unix its first public exposure. In that paper, its authors described the unprecedentedly simple design of Unix, and reported over 600 Unix installations. All were on machines underpowered even by the standards of that day, but (as Ritchie and Thompson wrote) “constraint has encouraged not only economy, but also a certain elegance of design”.

After the CACM paper, research labs and universities all over the world clamored for the chance to try out Unix themselves. Under a 1958 consent decree in settlement of an antitrust case, AT&T (the parent organization of Bell Labs) had been forbidden from entering the computer business. Unix could not, therefore, be turned into a product; indeed, under the terms of the consent decree, Bell Labs was required to license its nontelephone technology to anyone who asked. Ken Thompson quietly began answering requests by shipping out tapes and disk packs — each, according to legend, with a note signed “love, ken”.

This was years before personal computers. Not only was the hardware needed to run Unix too expensive to be within an individual's reach, but nobody imagined that would change in the foreseeable future. So Unix machines were only available by the grace of big organizations with big budgets: corporations, universities, government agencies. But use of these minicomputers was less regulated than the even-bigger mainframes, and Unix development rapidly took on a countercultural air. It was the early 1970s; the pioneering Unix programmers were shaggy hippies and hippie-wannabes. They delighted in playing with an operating system that not only offered them fascinating challenges at the leading edge of computer science, but also subverted all the technical assumptions and business practices that went with Big Computing. Card punches, COBOL, business suits, and batch IBM mainframes were the despised old wave; Unix hackers reveled in the sense that they were simultaneously building the future and flipping a finger at the system.

The excitement of those days is captured in this quote from Douglas Comer: “Many universities contributed to UNIX. At the University of Toronto, the department acquired a 200-dot-per-inch printer/plotter and built software that used the printer to simulate a phototypesetter. At Yale University, students and computer scientists modified the UNIX shell. At Purdue University, the Electrical Engineering Department made major improvements in performance, producing a version of UNIX that supported a larger number of users. Purdue also developed one of the first UNIX computer networks. At the University of California at Berkeley, students developed a new shell and dozens of smaller utilities. By the late 1970s, when Bell Labs released Version 7 UNIX, it was clear that the system solved the computing problems of many departments, and that it incorporated many of the ideas that had arisen in universities. The end result was a strengthened system. A tide of ideas had started a new cycle, flowing from academia to an industrial laboratory, back to academia, and finally moving on to a growing number of commercial sites” [Comer].

The first Unix of which it can be said that essentially all of it would be recognizable to a modern Unix programmer was the Version 7 release in 1979.^[15] The first Unix user group had formed the previous year. By this time Unix was in use for operations support all through the Bell System [Hauben], and had spread to universities as far away as Australia, where John Lions's 1976 notes [Lions] on the Version 6 source code became the first serious documentation of the Unix kernel internals. Many senior Unix hackers still treasure a copy.

	The Lions book was a samizdat publishing sensation. Because of copyright infringement or some such it couldn't be published in the U.S., so copies of copies seeped everywhere. I still have my copy, which was at least 6th generation. Back then you couldn't be a kernel hacker without a Lions.
-- Ken Arnold

The beginnings of a Unix industry were coalescing as well. The first Unix company (the Santa Cruz Operation, SCO) began operations in 1978, and the first commercial C compiler (Whitesmiths) sold that same year. By 1980 an obscure software company in Seattle was also getting into the Unix game, shipping a port of the AT&T version for microcomputers called XENIX. But Microsoft's affection for Unix as a product was not to last very long (though Unix would continue to be used for most internal development work at the company until after 1990).

TCP/IP and the Unix Wars: 1980-1990

The Berkeley campus of the University of California emerged early as the single most important academic hot-spot in Unix development. Unix research had begun there in 1974, and was given a substantial impetus when Ken Thompson taught at the University during a 1975-76 sabbatical. The first BSD release had been in 1977 from a lab run by a then-unknown grad student named Bill Joy. By 1980 Berkeley was the hub of a sub-network of universities actively contributing to their variant of Unix. Ideas and code from Berkeley Unix (including the vi(1) editor) were feeding back from Berkeley to Bell Labs.

Then, in 1980, the Defense Advanced Research Projects Agency needed a team to implement its brand-new TCP/IP protocol stack on the VAX under Unix. The PDP-10s that powered the ARPANET at that time were aging, and indications that DEC might be forced to cancel the 10 in order to support the VAX were already in the air. DARPA considered contracting DEC to implement TCP/IP, but rejected that idea because they were concerned that DEC might not be responsive to requests for changes in their proprietary VAX/VMS operating system [Libes-Ressler]. Instead, DARPA chose Berkeley Unix as a platform — explicitly because its source code was available and unencumbered [Leonard].

Berkeley's Computer Science Research Group was in the right place at the right time with the strongest development tools; the result became arguably the most critical turning point in Unix's history since its invention.

Until the TCP/IP implementation was released with Berkeley 4.2 in 1983, Unix had had only the weakest networking support. Early experiments with Ethernet were unsatisfactory. An ugly but serviceable facility called UUCP (Unix to Unix Copy Program) had been developed at Bell Labs for distributing software over conventional telephone lines via modem.^[16] UUCP could forward Unix mail between widely separated machines, and (after Usenet was invented in 1981) supported Usenet, a distributed bulletin-board facility that allowed users to broadcast text messages to anywhere that had phone lines and Unix systems.

Still, the few Unix users aware of the bright lights of the ARPANET felt like they were stuck in a backwater. No FTP, no telnet, only the most restricted remote job execution, and painfully slow links. Before TCP/IP, the Internet and Unix cultures did not mix. Dennis Ritchie's vision of computers as a way to “encourage close communication” was one of collegial communities clustered around individual timesharing machines or in the same computing center; it didn't extend to the continent-wide distributed ‘network nation’ that ARPA users had started to form in the mid-1970s. Early ARPANETters, for their part, considered Unix a crude makeshift limping along on risibly weak hardware.

After TCP/IP, everything changed. The ARPANET and Unix cultures began to merge at the edges, a development that would eventually save both from destruction. But there would be hell to pay first as the result of two unrelated disasters; the rise of Microsoft and the AT&T divestiture.

In 1981, Microsoft made its historic deal with IBM over the new IBM PC. Bill Gates bought QDOS (Quick and Dirty Operating System), a clone of CP/M that its programmer Tim Paterson had thrown together in six weeks, from Paterson's employer Seattle Computer Products. Gates, concealing the IBM deal from Paterson and SCP, bought the rights for $50,000. He then talked IBM into allowing Microsoft to market MS-DOS separately from the PC hardware. Over the next decade, leveraging code he didn't write made Bill Gates a multibillionaire, and business tactics even sharper than the original deal gained Microsoft a monopoly lock on desktop computing. XENIX as a product was rapidly deep-sixed, and eventually sold to SCO.

It was not apparent at the time how successful (or how destructive) Microsoft was going to be. Since the IBM PC-1 didn't have the hardware capacity to run Unix, Unix people barely noticed it at all (though, ironically enough, DOS 2.0 eclipsed CP/M largely because Microsoft's co-founder Paul Allen merged in Unix features including subdirectories and pipes). There were things that seemed much more interesting going on — like the 1982 launching of Sun Microsystems.

Sun Microsystems founders Bill Joy, Andreas Bechtolsheim, and Vinod Khosla set out to build a dream Unix machine with built-in networking capability. They combined hardware designed at Stanford with the Unix developed at Berkeley to produce a smashing success, and founded the workstation industry. At the time, nobody much minded watching source-code access to one branch of the Unix tree gradually dry up as Sun began to behave less like a freewheeling startup and more like a conventional firm. Berkeley was still distributing BSD with source code. Officially, System III source licenses cost $40,000 each; but Bell Labs was turning a blind eye to the number of bootleg Bell Labs Unix tapes in circulation, the universities were still swapping code with Bell Labs, and it looked like Sun's commercialization of Unix might just be the best thing to happen to it yet.

1982 was also the year that C first showed signs of establishing itself outside the Unix world as the systems-programming language of choice. It would only take about five years for C to drive machine assemblers almost completely out of use. By the early 1990s C and C++ would dominate not only systems but application programming; by the late 1990s all other conventional compiled languages would be effectively obsolete.

When DEC canceled development on the PDP-10's successor machine (Jupiter) in 1983, VAXes running Unix began to take over as the dominant Internet machines, a position they would hold until being displaced by Sun workstations. By 1985, about 25% of all VAXes would be running Unix despite DEC's stiff opposition. But the longest-term effect of the Jupiter cancellation was a less obvious one; the death of the MIT AI Lab's PDP-10-centered hacker culture motivated a programmer named Richard Stallman to begin writing GNU, a complete free clone of Unix.

By 1983 there were no fewer than six Unix-workalike operating systems for the IBM-PC: uNETix, Venix, Coherent, QNX, Idris, and the port hosted on the Sritek PC daughtercard. There was still no port of Unix in either the System V or BSD versions; both groups considered the 8086 microprocessor woefully underpowered and wouldn't go near it. None of the Unix-workalikes were significant as commercial successes, but they indicated a significant demand for Unix on cheap hardware that the major vendors were not supplying. No individual could afford to meet it, either, not with the $40,000 price-tag on a source-code license.

Sun was already a success (with imitators!) when, in 1983, the U.S. Department of Justice won its second antitrust case against AT&T and broke up the Bell System. This relieved AT&T from the 1958 consent decree that had prevented them from turning Unix into a product. AT&T promptly rushed to commercialize Unix System V—a move that nearly killed Unix.

	So true. But their marketing did spread Unix internationally.
-- Ken Thompson

Most Unix boosters thought that the divestiture was great news. We thought we saw in the post-divestiture AT&T, Sun Microsystems, and Sun's smaller imitators the nucleus of a healthy Unix industry — one that, using inexpensive 68000-based workstations, would challenge and eventually break the oppressive monopoly that then loomed over the computer industry — IBM's.

What none of us realized at the time was that the productization of Unix would destroy the free exchanges of source code that had nurtured so much of the system's early vitality. Knowing no other model than secrecy for collecting profits from software and no other model than centralized control for developing a commercial product, AT&T clamped down hard on source-code distribution. Bootleg Unix tapes became far less interesting in the knowledge that the threat of lawsuit might come with them. Contributions from universities began to dry up.

To make matters worse, the big new players in the Unix market promptly committed major strategic blunders. One was to seek advantage by product differentiation — a tactic which resulted in the interfaces of different Unixes diverging. This threw away cross-platform compatibility and fragmented the Unix market.

The other, subtler error was to behave as if personal computers and Microsoft were irrelevant to Unix's prospects. Sun Microsystems failed to see that commoditized PCs would inevitably become an attack on its workstation market from below. AT&T, fixated on minicomputers and mainframes, tried several different strategies to become a major player in computers, and badly botched all of them. A dozen small companies formed to support Unix on PCs; all were underfunded, focused on selling to developers and engineers, and never aimed at the business and home market that Microsoft was targeting.

In fact, for years after divestiture the Unix community was preoccupied with the first phase of the Unix wars — an internal dispute, the rivalry between System V Unix and BSD Unix. The dispute had several levels, some technical (sockets vs. streams, BSD tty vs. System V termio) and some cultural. The divide was roughly between longhairs and shorthairs; programmers and technical people tended to line up with Berkeley and BSD, more business-oriented types with AT&T and System V. The longhairs, repeating a theme from Unix's early days ten years before, liked to see themselves as rebels against a corporate empire; one of the small companies put out a poster showing an X-wing-like space fighter marked “BSD” speeding away from a huge AT&T ‘death star’ logo left broken and in flames. Thus we fiddled while Rome burned.

But something else happened in the year of the AT&T divestiture that would have more long-term importance for Unix. A programmer/linguist named Larry Wall quietly invented the patch(1) utility. The patch program, a simple tool that applies changebars generated by diff(1) to a base file, meant that Unix developers could cooperate by passing around patch sets — incremental changes to code — rather than entire code files. This was important not only because patches are less bulky than full files, but because patches would often apply cleanly even if much of the base file had changed since the patch-sender fetched his copy. With this tool, streams of development on a common source-code base could diverge, run in parallel, and re-converge. The patch program did more than any other single tool to enable collaborative development over the Internet — a method that would revitalize Unix after 1990.

In 1985 Intel shipped the first 386 chip, capable of addressing 4 gigabytes of memory with a flat address space. The clumsy segment addressing of the 8086 and 286 became immediately obsolete. This was big news, because it meant that for the first time, a microprocessor in the dominant Intel family had the capability to run Unix without painful compromises. The handwriting was on the wall for Sun and the other workstation makers. They failed to see it.

1985 was also the year that Richard Stallman issued the GNU manifesto [Stallman] and launched the Free Software Foundation. Very few people took him or his GNU project seriously, a judgment that turned out to be seriously mistaken. In an unrelated development of the same year, the originators of the X window system released it as source code without royalties, restrictions, or license code. As a direct result of this decision, it became a safe neutral area for collaboration between Unix vendors, and defeated proprietary contenders to become Unix's graphics engine.

Serious standardization efforts aimed at reconciling the System V and Berkeley APIs also began in 1983 with the /usr/group standard. This was followed in 1985 by the POSIX standards, an effort backed by the IEEE. These described the intersection set of the BSD and SVR3 (System V Release 3) calls, with the superior Berkeley signal handling and job control but with SVR3 terminal control. All later Unix standards would incorporate POSIX at their core, and later Unixes would adhere to it closely. The only major addition to the modern Unix kernel API to come afterwards was BSD sockets.

In 1986 Larry Wall, previously the inventor of patch(1), began work on Perl, which would become the first and most widely used of the open-source scripting languages. In early 1987 the first version of the GNU C compiler appeared, and by the end of 1987 the core of the GNU toolset was falling into place: editor, compiler, debugger, and other basic development tools. Meanwhile, the X windowing system was beginning to show up on relatively inexpensive workstations. Together, these would provide the armature for the open-source Unix developments of the 1990s.

1986 was also the year that PC technology broke free of IBM's grip. IBM, still trying to preserve a price-vs.-power curve across its product line that would favor its high-margin mainframe business, rejected the 386 for most of its new line of PS/2 computers in favor of the weaker 286. The PS/2 series, designed around a proprietary bus architecture to lock out clonemakers, became a colossally expensive failure.^[17] Compaq, the most aggressive of the clonemakers, trumped IBM's move by releasing the first 386 machine. Even with a clock speed of a mere 16 MHz, the 386 made a tolerable Unix machine. It was the first PC of which that could be said.

It was beginning to be possible to imagine that Stallman's GNU project might mate with 386 machines to produce Unix workstations almost an order of magnitude less costly than anyone was offering. Curiously, no one seems to have actually got this far in their thinking. Most Unix programmers, coming from the minicomputer and workstation worlds, continued to disdain cheap 80x86 machines in favor of more elegant 68000-based designs. And, though a lot of programmers contributed to the GNU project, among Unix people it tended to be considered a quixotic gesture that was unlikely to have near-term practical consequences.

The Unix community had never lost its rebel streak. But in retrospect, we were nearly as blind to the future bearing down on us as IBM or AT&T. Not even Richard Stallman, who had declared a moral crusade against proprietary software a few years before, really understood how badly the productization of Unix had damaged the community around it; his concerns were with more abstract and long-term issues. The rest of us kept hoping that some clever variation on the corporate formula would solve the problems of fragmentation, wretched marketing, and strategic drift, and redeem Unix's pre-divestiture promise. But worse was still to come.

1988 was the year Ken Olsen (CEO of DEC) famously described Unix as “snake oil”. DEC had been shipping its own variant of Unix on PDP-11s since 1982, but really wanted the business to go to its proprietary VMS operating system. DEC and the minicomputer industry were in deep trouble, swamped by waves of powerful low-cost machines coming out of Sun Microsystems and the rest of the workstation vendors. Most of those workstations ran Unix.

But the Unix industry's own problems were growing more severe. In 1988 AT&T took a 20% stake in Sun Microsystems. These two companies, the leaders in the Unix market, were beginning to wake up to the threat posed by PCs, IBM, and Microsoft, and to realize that the preceding five years of bloodletting had gained them little. The AT&T/Sun alliance and the development of technical standards around POSIX eventually healed the breach between the System V and BSD Unix lines. But the second phase of the Unix wars began when the second-tier vendors (IBM, DEC, Hewlett-Packard, and others) formed the Open Software Foundation and lined up against the AT&T/Sun axis (represented by Unix International). More rounds of Unix fighting Unix ensued.

Meanwhile, Microsoft was making billions in the home and small-business markets that the warring Unix factions had never found the will to address. The 1990 release of Windows 3.0 — the first successful graphical operating system from Redmond — cemented Microsoft's dominance, and created the conditions that would allow them to flatten and monopolize the market for desktop applications in the 1990s.

The years from 1989 to 1993 were the darkest in Unix's history. It appeared then that all the Unix community's dreams had failed. Internecine warfare had reduced the proprietary Unix industry to a squabbling shambles that never summoned either the determination or the capability to challenge Microsoft. The elegant Motorola chips favored by most Unix programmers had lost out to Intel's ugly but inexpensive processors. The GNU project failed to produce the free Unix kernel it had been promising since 1985, and after years of excuses its credibility was beginning to wear thin. PC technology was being relentlessly corporatized. The pioneering Unix hackers of the 1970s were hitting middle age and slowing down. Hardware was getting cheaper, but Unix was still too expensive. We were belatedly becoming aware that the old monopoly of IBM had yielded to a newer monopoly of Microsoft, and Microsoft's mal-engineered software was rising around us like a tide of sewage.

Blows against the Empire: 1991-1995

The first glimmer of light in the darkness was the 1990 effort by William Jolitz to port BSD onto a 386 box, publicized by a series of magazine articles beginning in 1991. The 386BSD port was possible because, partly influenced by Stallman, Berkeley hacker Keith Bostic had begun an effort to clean AT&T proprietary code out of the BSD sources in 1988. But the 386BSD project took a severe blow when, near the end of 1991, Jolitz walked away from it and destroyed his own work. There are conflicting explanations, but a common thread in all is that Jolitz wanted his code to be released as unencumbered source and was upset when the corporate sponsors of the project opted for a more proprietary licensing model.

In August 1991 Linus Torvalds, then an unknown university student from Finland, announced the Linux project. Torvalds is on record that one of his main motivations was the high cost of Sun's Unix at his university. Torvalds has also said that he would have joined the BSD effort had he known of it, rather than founding his own. But 386BSD was not shipped until early 1992, some months after the first Linux release.

The importance of both these projects became clear only in retrospect. At the time, they attracted little notice even within the Internet hacker culture — let alone in the wider Unix community, which was still fixated on more capable machines than PCs, and on trying to reconcile the special properties of Unix with the conventional proprietary model of a software business.

It would take another two years and the great Internet explosion of 1993–1994 before the true importance of Linux and the open-source BSD distributions became evident to the rest of the Unix world. Unfortunately for the BSDers, an AT&T lawsuit against BSDI (the startup company that had backed the Jolitz port) consumed much of that time and motivated some key Berkeley developers to switch to Linux.

	Code copying and theft of trade secrets was alleged. The actual infringing code was not identified for nearly two years. The lawsuit could have dragged on for much longer but for the fact that Novell bought USL from AT&T and sought a settlement. In the end, three files were removed from the 18,000 that made up the distribution, and a number of minor changes were made to other files. In addition, the University agreed to add USL copyrights to about 70 files, with the stipulation that those files continued to be freely redistributed.
-- Marshall Kirk McKusick

The settlement set an important precedent by freeing an entire working Unix from proprietary control, but its effects on BSD itself were dire. Matters were not helped when, in 1992–1994, the Computer Science Research Group at Berkeley shut down; afterwards, factional warfare within the BSD community split it into three competing development efforts. As a result, the BSD lineage lagged behind Linux at a crucial time and lost to it the lead position in the Unix community.

The Linux and BSD development efforts were native to the Internet in a way previous Unixes had not been. They relied on distributed development and Larry Wall's patch(1) tool, and recruited developers via email and through Usenet newsgroups. Accordingly, they got a tremendous boost when Internet Service Provider businesses began to proliferate in 1993, enabled by changes in telecomm technology and the privatization of the Internet backbone that are outside the scope of this history. The demand for cheap Internet was created by something else: the 1991 invention of the World Wide Web. The Web was the “killer app” of the Internet, the graphical user interface technology that made it irresistible to a huge population of nontechnical end users.

The mass-marketing of the Internet both increased the pool of potential developers and lowered the transaction costs of distributed development. The results were reflected in efforts like XFree86, which used the Internet-centric model to build a more effective development organization than that of the official X Consortium. The first XFree86 in 1992 gave Linux and the BSDs the graphical-user-interface engine they had been missing. Over the next decade XFree86 would lead in X development, and an increasing portion of the X Consortium's activity would come to consist of funneling innovations originated in the XFree86 community back to the Consortium's industrial sponsors.

By late 1993, Linux had both Internet capability and X. The entire GNU toolkit had been hosted on it from the beginning, providing high-quality development tools. Beyond GNU tools, Linux acted as a basin of attraction, collecting and concentrating twenty years of open-source software that had previously been scattered across a dozen different proprietary Unix platforms. Though the Linux kernel was still officially in beta (at 0.99 level), it was remarkably crash-free. The breadth and quality of the software in Linux distributions was already that of a production-ready operating system.

A few of the more flexible-minded among old-school Unix developers began to notice that the long-awaited dream of a cheap Unix system for everybody had snuck up on them from an unexpected direction. It didn't come from AT&T or Sun or any of the traditional vendors. Nor did it rise out of an organized effort in academia. It was a bricolage that bubbled up out of the Internet by what seemed like spontaneous generation, appropriating and recombining elements of the Unix tradition in surprising ways.

Elsewhere, corporate maneuvering continued. AT&T divested its interest in Sun in 1992; then sold its Unix Systems Laboratories to Novell in 1993; Novell handed off the Unix trademark to the X/Open standards group in 1994; AT&T and Novell joined OSF in 1994, finally ending the Unix wars. In 1995 SCO bought UnixWare (and the rights to the original Unix sources) from Novell. In 1996, X/Open and OSF merged, creating one big Unix standards group.

But the conventional Unix vendors and the wreckage of their wars came to seem steadily less and less relevant. The action and energy in the Unix community were shifting to Linux and BSD and the open-source developers. By the time IBM, Intel, and SCO announced the Monterey project in 1998 — a last-gasp attempt to merge One Big System out of all the proprietary Unixes left standing — developers and the trade press reacted with amusement, and the project was abruptly canceled in 2001 after three years of going nowhere.

The industry transition could not be said to have completed until 2000, when SCO sold UnixWare and the original Unix source-code base to Caldera — a Linux distributor. But after 1995, the story of Unix became the story of the open-source movement. There's another side to that story; to tell it, we'll need to return to 1961 and the origins of the Internet hacker culture.