Some more notes on programming

• fork
  • #include <unistd.h>
  • No parameters.
  • returns a pid_t, which is really an int.
    • If the return value is -1 a failure occured.
    • If the return value is 0, this the new process.
    • If the return value is positive, this is the parent and the return value is the child's id.
  • Both processes have have the same values of the variables.
  • Both are at the same point in execution.
  • File descriptors are the same. (Including message queue descriptors)

  • pid = fork();
    if (pid == -1) {
        perror("Fork failed");
        exit(-1);
    }
    if (pid){
        // parent process goes here. 
    } else {
       // child process goes here.
    }
    	

• waidpid()
  • #include <sys/types.h>
  • #include <sys/wait.h>
  • three parameters:
    • pid_t: pid to wait for.
      • If this is -1, it waits for any child process.
      • If this is positive, it waits for a given process.
      • If it is less than -1, it waits for a process in the group of |pid| group.
      • If it is 0, it waits for a process in the group of this process.
    • Status points to a place to store information about the exiting process.
      • If it is NULL, nothing is stored.
      • If it is a pointer, you can get information about the exit status. (See waitpid)
    • Options let you set if this is blocking or not.
  • Return value
    • -1 means failure.
    • 0 means no child was available.

    pid = fork();
    if (pid == -1) {
        perror("Fork failed");
        exit(-1);
    }
    if (pid){
        waitpid(pid,&status,0);
        printf("the child exited, it's pid was %d\n",pid);
        // parent process goes here. 
    } else {
        printf("I am the child \n");
        sleep(3);
        printf("I am the child and I am out of here \n");
       // child process goes here.
    }
    	

  • There are other ways of handling this.
• Some code
• Exec family
  • Exec replaces the current program with a new one.
  • There are multiple versions of this call, depending on what you want to do.
  • execve takes
    • name of file to execute
    • an char * array that represents the arguments to the program
    • a char * array that represents the environment pointer for the program.
  • The new program has the same pid.
  • Should not return, but if it does, there is an error.
  • File descriptors are not closed on exec.
  • But memory is overwritten.
  • execl is a family of front ends for execve.