This document is posted to help you gain knowledge. Please leave a comment to let me know what you think about it! Share it to your friends and learn new things together.
• Under UNIX, (almost) everything is a “file”:– Normal files– Directories– Hardware– Sockets– Pipes
• Things that are not files:– Users– Groups– Processes
OwnershipOwnership• Files have two owners
– Every file has exactly one user owner– Every file has exactly one group owner
• Everyone is a user– Users are in at least one group
• Processes have owners, too (known as an “id”)– Every process has exactly one user id– Every process has at least on group id
• Users and groups are really just numbers with names– Every username is mapped to a single numeric “uid”– Every groupname is mapped to a single numeric “gid”
Who am I?Who am I?
• Commands that tell you who you are:– whoami displays your username– id displays your username and groups
• Commands that tell you who others are:– finger [<name>] displays info for <name>– id [<username>] displays info for <username>
• Commands that change who you are:– su <username> “switch user” to <username> – login login as a different user
File PermissionsFile Permissions
• Every file has three access levels:– user (the user owner of the file)
– group (the group owner of the file)
– other (everyone else)
• At each level, there are three access types:– read (looking at the contents)
– write (altering the contents)
– execute (executing the contents)
Strange ThingsStrange Things
• There are three “strange” permissions:– setuid (run program as user owner)– setgid (run program as group owner)– text (stay in swap after executing)
• Directories act differently– “write” (creating/deleting files)– “execute” (cd-ing to that directory)– “setuid” (ignored)– “setgid” (created files have same group owner)– “text” (deletion restricted to user owned files)
• What can you do with it?– Start programs in the background– Run more than one program per terminal– Kill bad and/or crashing programs– Suspend programs mid-execution– List all jobs running in a shell– Move foreground jobs to the background– More …
Three States of a ProcessThree States of a Process• Foreground
– Attached to keyboard– Outputs to the screen– Shell waits until the process ends
• Background, running– Not attached to keyboard– Might output to the screen– Shell immediately gives you another prompt
• Background, suspended– Paused mid-execution– Can be resumed in background or foreground
– jobs lists background “jobs” and job #’s– ps lists processes and their process id (“pid”)– %<job#> expands to the process id of the job
• Stopping foreground jobs– Press ^Z (Ctrl-Z) in the terminal window
• Starting a process in the background– Append a & character to the command line– Examples: ls –lR > ls-lR.out &
xemacs my_program.cc &
• Resuming a stopped job– In the foreground: fg [<pid>]– In the background: bg [<pid>]
Killing ProcessesKilling Processes• The “kill” command:
kill [-<signal>] <pid>Send <signal> to process <pid>
• The “killall” command:killall [-<signal>] <command>Send <signal> to all processes that start with <command>
• Useful signals (kill –l for the complete list):TERM the default, “terminate”, kills things nicelyKILL will kill anything, but not nicelyHUP “hangup”, used to reload configurationsSTOP stops (suspends) a running process
What are environment variables?What are environment variables?
• The environment is an array of strings of the formNAME=VALUE
• Each process (program) has its own copy of the environment
• Processes started by the shell get a (“deep”) copy of the shell’s current environment
• Each process can examine and modify its own (and only its own) environment
• The “meaning” of environment variables is merely a matter of established conventions
Viewing your shell’s environmentViewing your shell’s environment
• To view a single environment variable’s value:echo $<name>
• For example:echo $HOME
will display/homes/iws/evgenyr
• To view all environment variables at once:– tcsh/csh/bash: printenv– sh/ksh: set
• You may want to save output and examine it at your leisure:– if the program generates a lot of output
– if the program takes a long time to run
• You may want to present the output to another person
• Having the program write to standard output may make the program simpler to write
Standard output vs Standard errorStandard output vs Standard error
• By convention, “normal” output of a program is sent to standard output (stdout [C++’s cout]), while debugging or error output is sent to standard error (stderr [C++’s cerr]).
How to redirect program’s output?How to redirect program’s output?• To redirect just the standard output:<program> > <FILE>
• To redirect just the standard error:sh/ksh/bash: <program> 2> <FILE>csh/tcsh: ( <program> > STDOUT ) >& STDERR
• To redirect both standard output and standard error:
• Piping is connecting programs together by using the output of one program as the input to the next.
• Syntax:<program1> | <program2> | … | <programN>
• A simple example (view a sorted file-listing a page at a time):ls | sort | less
• Note: piping deals with the input/output of programs (that is, stdin, stdout, stderr)
Why piping?Why piping?
• Because “the whole is bigger than the sum of its parts.
• By combining Unix utilities in a pipeline, you can build tools “on-the-fly” as you need them.
Piping examplesPiping examples
• How many .c files are in this directory?ls *.c | wc –l
• What files were modified most recently?ls –t | head
• What processes am I running?ps auxw | grep <mylogin>
• Make an alias for the above, for other Linux boxen too:alias myps=’ ps auxw | grep `id –un`’
TheThe catcat utilityutility
• Especially useful: cat– When used with pipes, “copies” stdin to stdout
•cat can be used to redirect out of a pipe!
• Example: make a file containing currently running processes ps aux | grep evgenyr | cat > my_processes
– When used with a file, “copies” the file into stdout•cat can be used to place a file’s contents into a pipe!
• Example: list all the items in a list in alphabetical ordercat my_grocery_list.txt | sort | uniq
Command substitutionCommand substitution(aka “what’s up with the backquotes?”)(aka “what’s up with the backquotes?”)
• Command substitution means that the shell substitutes a command’s output for the command itself.
• To get the shell to perform command substitution, enclose the command in backquotes (`)
Shell as a work-saver: scriptsShell as a work-saver: scripts• Instead of typing the same series of commands over and
over again, put them in a file and have the shell execute the (commands in the) file!
• The file must have execute permission• The first line of the file should be:#! <YOURSHELL> (e.g., /bin/bash)
• There must be no space (or any other character) between ‘#’ and ‘!’.
• Whether to put space after ‘!’ is a matter of style• Shell also has control flow, tests, etc. The shell tutorial
on the ACM web page goes into much more detail.
Intermezzo: quotingIntermezzo: quoting
• Problem: some characters are special to the shell (*, ?), but you would like to pass those characters to the programs the shell runs as-is.
• So you quote the character(s):– A single character: by prefixing it with a \ (backslash)
– A string of characters: by enclosing them in• Single quotes: no characters are special. None
• Double quotes: some characters (notably $ and `) are still special. You’ll need to prefix those with a backslash to pass to the program as-is.
Quoting examplesQuoting examples• List all the files in the current directory:ls *
• List the file or directory called ‘*’ (or complain if it’s not there):ls \*
• Print $HOME:echo ’$HOME’
• Print the path to your home directory:echo ”$HOME”
• Print `id –un`: echo ’`id –un`’
• Print your login:echo ”`id –un`”
Next stop: utilitiesNext stop: utilities
• (No, not electricity, water, and sewer)• diff and patch• grep• find and xargs
diffdiff and and patchpatch
• You have two versions of a file; how do you see what’s changed between the two versions?– diff shows the differences between two files; you’ll
want to use the –u or –c option to diff to produce output in human-friendly format:diff –u my_file my_file.orig | less
– patch applies differences to a filediff –u my_file my_file.orig > my_patchpatch my_file < mypatch
my_file is now the same as my_file.orig
grep grep – search for patterns– search for patterns
• grep searches for patterns in texts:grep <string> <FILE>
• grep uses regular expressions to describe the string(s) to search for
• In a regular expression, most characters are treated as-is, but a few are magic– Ordinary characters just represent themselves– Magic characters do special things
grepgrep’s magic characters’s magic characters
• A few different kinds of magic characters:– Some characters “anchor” (parts of) a regular
expressions to specific places in the string:^ - The beginning of a line$ - The end of a line
– A dot (.) matches “any one character whasoever” (except for newline)
– [ ] form a character class:•[aeiou] – any single vowel•[a-zA-z0-9] – Any single letter or digit•[^0-9] – Any single character that isn’t a digit
Here, ‘^’means “not”
Even more of Even more of grepgrep’s magic characters’s magic characters
• Quantifiers say how many times the preceeding “thing” should be repeated:– * means “zero or more times”– ? Means “zero or one time”
Frequently used Frequently used grepgrep options options
-i : do case-insensitive search
-n : print line numbers
-v : print lines that do not match
-l : only list the files from which output would have been printed
grep grep examplesexamples
• Print all non-blank lines:grep –v ’^$’ my_file.txt
• Print all the lines on which my_function is called (or declared):grep –n ’my_function *(’ my_code.c
• Show all the xterms I am running:ps auxw | grep ”`id –un` .*xterm”
findfind
• Traverse the tree(s) rooted at <PATHs> , and for each “thing” found, evaluate the <EXPRESSION> until the result of <EXPRESSION> is known.
• The evaluation of <EXPRESSION> “short-circuits”, just like expressions in C/C++.– false && some_expression can never be true
• Options apply to the entire find command, not the individual expression
find <PATHS> <OPTIONS> <EXPRESSION>
Components of a Components of a findfind expression expression
• An expression is zero or more primaries connected by operators
• Two kinds of primaries:– Tests: just return true or false– Actions: do something, in addition to returning true or false– Operators work just as they do in C/C++.
•! / -not•-a / -and•-o / -or•, (comma)
– Parentheses are used for grouping, just as in C/C++.
findfind examples examples• Print all the *.c* and *.h* files in and below the current directory
find . –name ’*.[ch]*’ –a –print
• Show line numbers myfunction calls in the above *.c* filesfind . –name ’*.c*’ | xargs grep –n ’myfunction.*(’
• Change permissions on files under your home directory so they’re inaccessible to everyone but you (except for files in the www directory)cd; find . –path ”./www*” –prune –o –exec chmod go-rwx {} \;
• How big are my *.c* files?expr `find –name ’*.c*’ –printf ”%k + ”` 0
• Read the find manual (info find) for more examples
xargsxargs: combine arguments: combine arguments
• Feeds standard input as arguments to <COMMAND>• Often used with find
(find … | xargs grep)• But it doesn’t have to be used with find:cat filelist | xargs cat {} > concatenated
xargs <OPTION> <COMMAND> <INITIAL_ARGS>
Finding more information – at CSEFinding more information – at CSE
• Use info and man• Peruse the “see also” section of the man pages
• Peruse info’s i (search index) command
• The uw-cs.lab-help group
• Look at your .login, .cshrc, etc. to see how support has set things up
Finding more info – on the webFinding more info – on the web• http://www.faqs.org (comp.unix questions FAQ)• http://www.google.com• http://www.deja.com• The support web page: