Process Creation

• There are two ways of creating a new process:
  • Build one from scratch:
    • Load code and data into memory.
    • Create (empty) a dynamic memory workspace (heap).
    • Create and initialize the PCB (make look like context-switch).
    • Make process known to dispatcher.
  • Clone an existing one (e.g., Unix fork() syscall):
    • Stop current process and save its state.
    • Make a copy of code, data, dynamic memory workspace and PCB.
    • Make process known to dispatcher.
• Who creates the processes and how they are supported? Every operating system has a mechanism to create processes.
• in UNIX, the fork() system call is used to create processes. fork() creates an identical copy of the calling process. After the fork(), the parent continues running concurrently with its child competing equally for the CPU. exec system call used after a fork to replace the process' memory space with a new program.

  cmd = readcmd();
  pid = fork();
  if (pid == 0) {
  // Child process -- Setup environment here
  // e.g., standard i/o, signals exec(cmd);
  // exec doesn t return
  } else {
  // Parent process -- Wait for child to finish
  wait(pid);
  }
  

• in MS-DOS, the LOAD_AND_EXEC system call creates a child process. This call suspends the parent until the child has finished execution, so the parent and child do not run concurrently
• Parent process create children processes, which, in turn create other processes forming a tree of processes
• Resource sharing
  • Parent and children share all resources.
  • Children share subset of parent's resources.
  • Parent and child share no resources.
• Execution, once a parent creates a child process, a number of execution possibilities exist:
  • Parent and children execute concurrently.
  • the parent may immediately enter a wait state for the child to finish - on UNIX, see the man pages for {wait, waitpid, wait4, wait3}.
  • the parent could immediately terminate.
• If the parent happens to terminate before the child has returned its value, then the child will become a zombie process and may be listed as such in the process status list!
• Address space, once a parent creates a child process, a number of memory possibilities exist:
  • the child can have a duplicate of the parent's address space - as each process continues to execute, their data spaces will presumably diverge.
  • the child can have a completely new program loaded into its address space.
• If either process needs to run a different program, it can perform a call to int execlp(const char *file, const char *arg, ...) where arguments specify the executable file and optional run-time arguments which the caller may wish to provide. See the man pages on fork and also {execl, execlp, execle, exect, execv, execvp}.
• How does each process know whether it is the parent or child after a fork? On BSD UNIX, fork() returns a value of 0 to the child process and returns the process ID of the child process to the parent process.