Process Creation

• This is chapter 24, because
  • I need multiple processes to prove some file claims to myself.
  • And I need an easier topic for a few days.
  • And I like processes.
  • I want to.
• Chapter 6 (I think) stuff
  • Each process on linux has a process id.
    • this is a (recyclable) integer.
    • This is a *nix feature, windows is different.
  • Process id 1 is reserved for the initializer.
    • This is no longer necessarily the case.
    • We will check this out later.
    • In the past, it was the creator of all other processes (think Adam, not Israel nee Jacob.)
  • Running processes
    • ps -ef will show the processes on the system
      • I frequently use ps -ef | grep the thing I am interested in
      • ps -ef | grep bash
      • -H shows the hierarchy
      • ps -efH
    • Top will also show processes (if it is installed)
  • Maximum process id
    • In chapter 6 he states the maximum process id is $2^{15}$ or 32,767
    • But clearly that is not the case on Mirkwood.
    • If you look at /proc/sys/kernel/pid_max you find it is 4,194,304
    • This is apparently the max for 64 bit systems, PID_MAX_LIMIT since linux 2.5.34
  • Two system calls:
    • Need unistd.h
    • pid_t getpid(void);
    • Returns the process id
    • pid_t getppid(void);
    • Returns the parent process id.
    • see mypid.cpp.
  • In bash
    • \$\$ contains the current pid.
    • ${PPID} contains the parent process id.
    • See pid.bashfile
  • In python
    • This is part of os, which contains os specific calls.
    • Reference.
    • os.getpid()
    • os.getppid()
    • See pid.pythonfile
• Four commands
  • fork - start a new process
  • exit - terminate this process
  • exec - run another program
  • wait - wait for a child to exit.
• We have skipped the chapters on signals.
  • A signal is a message from the kernel to a process.
  • It is a way to communicate status changes and control the process (somewhat).
  • We are interested in two or three signals
    • SIGCHLD - a child process has died.
    • SIGKILL - The process must terminate immediately
    • SIGABRT - The process should abort/terminate.
    • SIGHUP - The terminal connected to the process has disconnected.
  • A SIGCHLD is sent to the parent process when a child process dies
    • This is a mechanism to know that this has happened.
    • This is what wait waits for.
    • This is useful in the shell for example

      while (1)
          get command 
          fork
          if child process
              exec command
          else
              wait 

  • The other three, along with many others will terminate a process.
    • When we get to signals, we will find that there are some we can "catch" or "handle".
    • But others we can not.
  • We can send a signal to a process with the system command kill
    • kill -signal pid
    • kill -9 pid
    • kill -SIGKILL pid
  • Note: kill -l (that is a l as in list) will show signals and their numbers.
    • The numbers are not progressive.
    • A 2 is completely different from a 1, not the next level.
    • I generally try 1 then 9, which are uniform (I think)
    • Others are not (I know)
  • There are other programs that can send signals.
  • There are system calls that can generate
• The typical use of the system calls in this section
• 
• Just to finish
  • Reference
  • Or any OS book.
  • A process can have a number of states
    • Starting
    • Running or Runable.
    • Sleeping - blocked - waiting
    • Exiting
    • Zombie
    • Stopped
• Try test1.cpp to see the change of parent.
• Try zombie.cpp.