Process Basics
Processes
COP-3402

Problem: we want to run many programs, but we only have one CPU.

What can we do?

Virtualize the CPU: give programs the illustion of exclusive CPU access

• Process control block
  • Process ID (unique ID for all running programs)
  • Saves register values
  • Saves current working directory
  • Saves pointer to its memory
  • File descriptors
  • etc.

Copy existing process with fork()

Replace program code with new program with exec()

• Single initial process (init)
  • Many variations (sysv init rc system, systemd)
  • e.g., runs /usr/bin/login program among other things
• Running processes form a tree

View running in this bash session

ps

View all processes on the system

ps aux

View the process tree

ps axjf

Additional space-deliminted strings are arguments passed to the program for processing. They are handled however the program likes, although there are conventions to their format (man 3 getopt).

ls ./ ../

UNIX convention: the PATH environment variable

echo $PATH

The which program does the lookup for you

which ls

which which

hello
# program not found

./hello

which cd
# nothing returned

How do I run a program that I named cd?

./cd

Where does printf's output go?

int
__printf (const char *format, ...)
{
  va_list arg;
  int done;

  va_start (arg, format);
  done = vfprintf (stdout, format, arg);
  va_end (arg);

  return done;
}

Every process is given three open files when it runs:

• standard input (stdin)
• standard output (stdout)
• standard error (stderr)

man 3 stdio

• Why standard I/O?
• Why separate stdout and stderr?

When running in bash: the terminal itself

echo "hello, world!"

When running in bash: the terminal itself again

cat
# Typing is sent to the cat program's standard in

cat reads a file from stdin and writes it to stdout.

Use Ctrl-D (ascii EOT character) on an empty line to mark the end of file input

grep "hello"
# Typing is sent to the cat program's standard in

grep reads a file from stdin and writes out lines that contain a given string.

Don't forget to use Ctrl-D if inputting the stdin file from the command-line.

cat < hello.c

grep define < /usr/include/stdio.h

What does this do?

How can I view grepresults?

grep define < /root > grepresults
# The error message is printed to console

Redirecting stderr

grep define < /root > grepresults 2> greperror
# The error message is saved to greperror

grep define < /root > grepresults 2>&1

1. Make each program do one thing well. To do a new job, build afresh rather than complicate old programs by adding new "features".
2. Expect the output of every program to become the input to another, as yet unknown, program. Don't clutter output with extraneous information. Avoid stringently columnar or binary input formats. Don't insist on interactive input.
3. Design and build software, even operating systems, to be tried early, ideally within weeks. Don't hesitate to throw away the clumsy parts and rebuild them.
4. Use tools in preference to unskilled help to lighten a programming task, even if you have to detour to build the tools and expect to throw some of them out after you've finished using them.

Doug McIlroy

• find lists each file in a file tree
• grep searches for text

# list all files
find > findresults

# get only files with hello in its path
grep hello < findresults

find | grep hello

Separate bash commands with a pipe | symbol to pass stdout to stdin

cat /usr/include/stdio.h | grep head

• OS creates two "virtual" files
• Writing to first file outputs to second file
• Allows processes to pass data between them

find | xargs file

xargs takes each line from stdin and turns them into arguments for the given command, in this case the file command.

Print the first few lines of every header file

find /usr/include | grep "\.h$" | xargs head -n3

I want to get all configuration options defined by the Linux build system.

# search for all configuration options that you can choose when building the Linux kernel
find | grep Kconfig | xargs grep "^config"

# deduplicate and sort them as well
find | grep Kconfig | xargs grep -h "^config" | sort | uniq

# trim off the "config " keyword
find | grep Kconfig | xargs grep -h "^config" | sort | uniq \
     | cut -f2 -d' '

# count the results
find | grep Kconfig | xargs grep -h "^config" | sort | uniq \
     | cut -f2 -d' ' | wc -l

Use |& instead of |

grep define /root |& grep -i Permission

Ctrl-C kills a running program.

Ctrl-Z suspends a running program.

find /
# type ctrl-z

[1]+  Stopped                 find /

fg resumes a suspended program to the foreground.

fg
# find continues running
# type ctrl-z to suspend again

• Foreground means process is running over the shell
• Background means process running separately from the shell

• Will block the user from running additional shell commands
• Can receive signals, e.g., Ctrl-z

• No bash signals will work (no Ctrl-C or Ctrl-Z)
• Output still to terminal (if not redirected)

find /
# type ctrl-z
bg
# ctrl-c will not terminate it
fg
# now ctrl-c will work

Suffix the command with & to put it in background immediately.

cat &
# to bring into foreground, use fg
fg
# suspend again with Ctrl-Z
# bring to back again with bg
bg

Warning: the stdout/stderr will still be the terminal if not redirected.

find / > /dev/null 2>&1 &
cat &
grep hello &
jobs
fg 2 # bring up the second job, cat &

• Ctrl-C basically asks the process to terminate (SIGTERM)
• SIGTERM can be ignored by the program
• SIGKILL cannot be

find / > /dev/null 2>&1 &
ps
kill -9 

find / > /dev/null 2>&1 &
ps
kill -9 $!

A wrapper for managing terminal multiplexers

Setup the multiplexer for bash/emacs' Ctrl-A keybinding.

byobu-ctrl-a
# Type 2 and hit enter

In eustis, run

byobu

You can tell you are in byobu (tmux), because there is a status bar at the bottom of the screen.

Press F2 to create a new terminal "window".

Note the new "tab" with number 1 near the bottom-left of the terminal.

F6 detaches from the byobu session

Rerun byobu to reattach

echo "hello, world!" # to show that we indeed are reattaching
# press ~F6~ to detach
# you will return to the original eustis bash session.
exit # you can even exit and reconnect
ssh eustis..
byobu
# select (1) or your last byobu session

• F3 or Alt-<left> to go to the previous window
• F4 or Alt-<right> to go to the next window

byobu-ctrl-a
# Type 2 and hit enter

• Abstracts away CPU resources
• Manages running programs
• Creation: duplicate then replace

• stdin, stdout, stderr
• Make I/O decisions independent of program

Chain multiple programs together, e.g.,

find / | grep bin | wc -l

Suspend and resume processes into the background or foreground to work with multiple programs.

emacs hello.c
# Ctrl-Z to suspend
gcc -o hello hello.c
./hello
fg # to resume