Process Group Notes

This contains links to information used in the lectures. Note that the code segments have less than and greater than replaced by < and > so that they display correctly.

Controlling Terminal

The first terminal device open in a process becomes the controlling terminal for that process.
The controlling terminal is inherited by children during a fork().
The device /dev/tty is, for each process, that process's controlling terminal

Process Groups

On System V systems, the set of processes that share a controlling terminal is defined as the process group. This also applies to Berkeley systems, when using the Bourne shell and the old tty driver.
On Berkeley systems, it is possible to place processes into any arbitrary process group using setpgrp
On HP-UX pid_t setsid(void) and pid_t setpgrp(void) create a new session, if the calling process is not a process group leader. The calling process becomes the session leader of this new session, becomes the process group leader of a new process group, and has no controlling terminal. The process group ID of the calling process is set equal to the process ID of the calling process.
Upon successful completion, setsid() returns the value of the new process group ID of the calling process. Otherwise, a value of -1 is returned, and errno is set to indicate the error.
The csh uses this. Each csh job constitutes a session or process group. When csh starts a job, it sets the process's process group ID to the process ID. In the case of a pipe, all the processes are in the same process group as the last process in the pipeline (which is the first forked).
Each terminal is associated with a process group known as a distinguished process group. Processes in a distinguished process group are considered foreground processes. Proceses not in a distinguished process group are considered background jobs and cannot read from the terminal and they do not receive keyboard interrupts.

Example program

#include <stdio.h>
#include <unistd.h>
#include <errno.h>


void brag(void)
{
        pid_t  mypid,myppid,mypgid,myppgid;
      
	mypid = getpid();
	mypgid = getpgrp();
	myppid = getppid();
	myppgid = getpgrp2(myppid);

	printf ("My process id is %d\n",mypid);
	printf ("My process group is %d\n",mypgid);
	printf ("my parent is %d\n",myppid);
	printf ("and the process group is %d \n",myppgid);
	if (myppid == mypgid) {
	   printf("  My parent is my process leader, now\n");
	} else {
	   printf("  My parent is not my process leader, bummer!\n");
	}
}

main (int argc, char * argv[]) {

       pid_t  pid;
       pid_t  mypid,mypgid;

       brag();

      
       if (!setsid()) {
          perror("");
       }
       mypid = getpid();
       mypgid = getpgrp();
       if (mypid == mypgid)
       {
       printf ("I set my group id equal to my process id %d\n",mypid);
       printf ("WOW that means I'm a process leader now \n");
       }

       if (!(pid = fork())) {
	  int i=0;

          brag();
/*	This is an  infinite loop so the program hangs about long enough
        for to do a ps -ef and see the process chain */
	  while (1) {
	      i++;
	  }
       }
       printf (" A child called %d was spawned \n",pid);
       wait();
}

Running from the C shell

Status of processes before running play using ps -ef
```
 farrell  2157     1  0 03:43:02 ?        0:02 xterm -ls -T Condor -n Condor -T Condor
 farrell  2158  2157  0 03:43:02 ttyp1    0:00 -csh
```
Note that the xterm (pid 2157) is the parent of the csh (pid 2158) and that init (pid 1) is the parent of the xterm.

The result of running play from the csh. The # lines are comments inserted after the run.

#at this stage brag is run as a function from play 
#The parent is the csh (pid 2158)
#The csh sets the process group of play to play's process id (2570)
#since it is a separate "shell job"
#Hence it is different from that of the parent (2158)
My process id is 2570      
My process group is 2570
my parent is 2158
and the process group is 2158 
  My parent is not my process leader, bummer!
#
I set my group id equal to my process id 2570
#Actually this has no effect since it already is
WOW that means I'm a process leader now 
#Now fork a child (pid 2571) and have the child run brag as a function
My process id is 2571
My process group is 2570
my parent is 2570
and the process group is 2570 
#Note that the csh has set the process group of the spawned process
#to that of the parent
  My parent is my process leader, now
#The parent prints the pid of the spawned process
#Note this was returned by fork()
 A child called 2571 was spawned

At this stage the status of processes using ps -ef is:

 farrell  2157     1  0 03:43:02 ?        0:02 xterm -ls -T Condor -n Condor -T Condor
 farrell  2158  2157  1 03:43:02 ttyp1    0:00 -csh
 farrell  2570  2158  0 05:30:00 ttyp1    0:00 play
 farrell  2571  2570 10 05:30:00 ttyp1   11:06 play

Now I create a Bourne subshell using sh. The status of processes before running play is now:

 farrell  2157     1  1 03:43:02 ?        0:04 xterm -ls -T Condor -n Condor -T Condor
 farrell  2158  2157  0 03:43:02 ttyp1    0:00 -csh
 farrell  2634  2158  0 05:52:39 ttyp1    0:00 sh

Question : Will ^C or ^\ at the keyboard kill play?
Running from the Bourne shell

The result of running play from the sh. The # lines are comments inserted after the run.

My process id is 2650
My process group is 2634
my parent is 2634
and the process group is 2634 
  My parent is my process leader, now
#Notice that the sh which is the parent is the  process leader
#since the Bourne shell does not change the process group
I set my group id equal to my process id 2650
#This changed the process leader
WOW that means I'm a process leader now 
My process id is 2651
My process group is 2650
my parent is 2650
and the process group is 2650 
  My parent is my process leader, now
#The parent prints the child's pid
 A child called 2651 was spawned