unix processes 1complete4&5

7/28/2019 Unix Processes 1complete4&5

1/165

UNIX PROCESSES


2/165

MAIN FUNCTION

PROTOTYPE:int main(int argc, char *argv[ ]);

Argc is the number of command line

argumentsargv [ ] is an array of pointers to the

arguments


3/165

A C program is started by a kernel

A special start up routine is called beforethe main function is called

This start up routine takes values from thekernel and sets things up so that the mainfunction is called


4/165

Process terminationNormal termination

* return from main* calling exit

* calling _exitAbnormal termination

* calling abort

* terminated by a signal


5/165

exit and _exit functions_exit returns to kernel immediatelyexit performs certain cleanup processingand then returns to kernelPROTOTYPE

#include void _exit (int status)

void exit (int status)


6/165

The exit status is undefined if

1.Either of these function is called withoutan exit status2.Main does a return without a return value3.Main falls of the end


7/165

At exit function

With ANSI C a process can register up to 32functions that are called by exit ---called exithandlers

Exit handlers are registered by calling theatexit function

#include Int atexit (void (*fun) void));


8/165

Atexit function calls these functions inreverse order of their registration

Each function is called as many times as itwas registered


9/165

#include "ourhdr.h"static void my_exit1(void), my_exit2(void);int main(void){

if (atexit(my_exit2) != 0)err_sys("can't register my_exit2");

if (atexit(my_exit1) != 0)

err_sys("can't register my_exit1");if (atexit(my_exit1) != 0)err_sys("can't register my_exit1");

printf("main is done\n");

return(0);}


10/165

static voidmy_exit1(void)

{printf("first exit handler\n");

}

static voidmy_exit2(void){

printf("second exit handler\n");

}


11/165

Command-line arguments

/* program to echo command linearguments*/int main (int argc, char* argv[ ]){

for(int i=0;i


12/165

Environment list

Environment list is an array ofcharacterpointers ,where each pointer contains theaddress of a null terminated C string

The address of array of pointers iscontained in global variable environextern char **environ;

each string is of the form name=value


13/165

NULL

HOME=/home/abc

PATH=:/bin:/usr/bin\0

Environmentpointer

Environmentlist


14/165

Memory layout of a C program

Text segment sharable copyInitialized data segment variablesspecifically initialized in the program

Uninitialized data segmentbss

segmentdata is initialized to arithematic 0 or nullStack return address and informationabout callers environment

Heapdynamic memory allocation takesplace on the heap


15/165

Stack

heap

Uninitialised data

initialised data

Text

Command line argumentsAnd environment variables

Intialized to 0 by exec

Read fromprog Fileby exec

High address

Low address


16/165

Shared libraries

Shared libraries remove the commonlibrary routines from the executable file ,instead maintaining a single copy of the

library routine some where in memory thatall processes referenceAdvantage: reduces size of executable file

easy to replace with a newer versionDisadvantage: some- runtime overhead


17/165

Memory allocation

malloc : allocates specified number ofbytes of memory

calloc : allocates specified number of

objects of specified sizerealloc : changes size of previous

allocated area


18/165

#include

void *malloc (size_t size);void *calloc (size_t nobj, size_t size);void *realloc (void *ptr, size_t newsize);

realloc may increase or decrease thesize of previously allocated area .If it

decreases the size no problem occursBut if the size increases then.


19/165

1.Either there is enough space then thememory is reallocated and the same pointeris returned2.If there is no space then it allocates newarea copies the contents of old area to new

area frees the old area and returns pointerto the new area


20/165

Alloca function

It is same as malloc but instead ofallocating memory from heap, the memoryallocated from the stack frame of the

current function


21/165

Environment variablesEnvironment strings are of the formname=valueANSI C defined functions

#include char *getenv (const char *name);int putenv (const char *str);int setenv (const char *name, const char

*value ,int rewrite);void unsetenv (const char *name);


22/165

Getenv : fetches a specific value from theenvironment

Putenv : takes a string of the formname=value , if it already exists thenold value is removed

Setenv : sets name to value. If name already

exists then a) if rewrite is non zero, then olddefinition is removed

b) if rewrite is zero old definition isretained

Unsetenv : removes any definition of name


23/165

Removing an environment variable issimple just find the pointer and move all

subsequent pointers down oneBut while modifying

* if size of new valueoldvalue use malloc obtainroom for new string, copy the newstring to this area and replace the old

pointer in environment list for namewith pointer to this malloced area


24/165

While adding a new name call mallocallocate room forname=value string andcopy the string to this areaIf its the first time a new name is added ,

use malloc to obtain area for new list ofpointers. Copy the old list of pointers to themalloced area and add the new pointer toits endIf its not the first time a new name was

added ,then just reallocate area for new

pointer since the list is already on theheap


25/165

Set jump and long jump

To transfer control from one function toanother we make use ofsetjmp and longjmpfunctions

#include int setjmp (jmp_buf env);

void longjmp (jmp_buf env, int val);


26/165

env is of type jmp_buf,this data type isform of array that is capable of holding all

information required to restore the statusof the stack to the state when we calllongjmp

Val allows us to have more than onelongjmp for one setjmp


27/165

#include #include "ourhdr.h"

static void f1(int, int, int);static void f2(void);

static jmp_buf jmpbuffer;int main(void)

{ int count;register int val;volatile int sum;


28/165

count = 2; val = 3; sum = 4;if (setjmp(jmpbuffer) != 0) {

printf("after longjmp: count = %d,val = %d, sum = %d\n", count, val, sum);

exit(0);}count = 97; val = 98; sum = 99;/* changed after setjmp, before

longjmp */

f1(count, val, sum);/* never returns */

}


29/165

static voidf1(int i, int j, int k){

printf("in f1(): count = %d, val = %d,sum = %d\n", i, j, k);

f2();

}static void f2(void){

longjmp(jmpbuffer, 1);

}


30/165

The state of automatic,register and volatilevariables after longjmp

If compiled with optimization


31/165

getrlimit and setrlimit#include #include

int getrlimit (int resource ,structrlimit *rlptr);

int setrlimit (int resource ,const struct

rlimit *rlptr);


32/165

Struct rlimit{rlim_t rlim_cur; /*soft limit*/rlim_t rlim_max; /*hard limit */}

1.Soft link can be changed by any process to

a value


33/165

RLIMIT_CORE max size in bytes of a corefile

RLIMIT_CPU max amount of CPU time insecondsRLIMIT_DATA max size in bytes of datasegmentRLIMIT_FSIZE max size in bytes of a filethat can be createdRLIMIT_MEMLOCK locked in-memory

address space


34/165

RLIMIT_NOFILE max number of openfiles per process

RLIMIT_NPROCmax number of childprocess per real user IDRLIMIT_OFILE same as RLIMIT_NOFILERLIMIT_RSSmax resident set size inbytesRLIMIT_STACK max size in bytes of thestack

RLIMIT_VMEM max size in bytes of themapped address space


35/165

#include #include #include #include "ourhdr.h"#define doit(name) pr_limits(#name, name)static voidpr_limits(char *, int);int main(void)

{ doit(RLIMIT_CORE);doit(RLIMIT_CPU);doit(RLIMIT_DATA);

doit(RLIMIT_FSIZE);


36/165

#ifdef RLIMIT_MEMLOCKdoit (RLIMIT_MEMLOCK);

#endif#ifdef RLIMIT_NOFILE /* SVR4 name */

doit (RLIMIT_NOFILE);#endif

#ifdef RLIMIT_OFILE /* 44BSD name */doit (RLIMIT_OFILE);

#endif


37/165

#ifdef RLIMIT_NPROCdoit (RLIMIT_NPROC);

#endif#ifdef RLIMIT_RSS

doit(RLIMIT_RSS);#endif

doit(RLIMIT_STACK);#ifdef RLIMIT_VMEMdoit(RLIMIT_VMEM);

#endif

exit(0);}


38/165

static voidpr_limits(char *name, int resource)

{ struct rlimit limit;if (getrlimit(resource, &limit) < 0)

err_sys("getrlimit error for %s",

name);printf("%-14s ", name);if (limit.rlim_cur == RLIM_INFINITY)

printf("(infinite) ");


39/165

elseprintf("%10ld ", limit.rlim_cur);

if (limit.rlim_max == RLIM_INFINITY)printf("(infinite)\n");

elseprintf("%10ld\n", limit.rlim_max);

}


40/165

Kernel support for processes

File descriptor tableCurrent directoryroot

text

data

stack

Per process u-area

Per process region table

Kernel region tableProcess table


41/165

A process consists ofA text segment program text of a processin machine executable instruction codeformatA data segment static and globalvariables in machine executable format

A stack segment function arguments,automatic variables and return addresses ofall active functions of a process at any timeU-area is an extension of Process table

entry and contains process-specific data


42/165

Fd table

stack

data

text

stack

data

File tableparent

child

Process tableKernel region table

Fd table


43/165

Besides open files the other propertiesinherited by child are

Real user ID, group ID, effective user ID,effective group IDSupplementary group IDProcess group IDSession IDControlling terminalset-user-ID and set-group-ID

Current working directory


44/165

Root directorySignal handlingSignal mask and dispositionsUmaskNice valueThe difference between the parent & child

The process IDParent process IDFile locksAlarms clock timePending signals


45/165

Process identifiers

Every process has a unique process ID, anon negative integer

Special processes : process ID 0scheduler process also known as swapper

process ID 1 init processinit process never dies,its a normal user

process run with super user privilegeprocess ID 2 pagedaemon


46/165

#include

#include pid_t getpid (void);pid_t getppid (void);

uid_t getuid (void);uid_t geteuid (void);gid_t getgid (void);gid_t getegid (void);


47/165

Fork functionThe only way a new process is createdby UNIX kernel is when an existingprocess calls the fork function

#include #include

pid_t fork (void);


48/165

The new process created by fork is calledchild process

The function is called once but returnstwiceThe return value in the child is 0The return value in parent is the process ID

of the new childThe child is a copy of parentChild gets a copy of parents text, data ,heap and stack

Instead of completely copying we can useCOW copy on write technique


49/165

#include #include "ourhdr.h"int glob = 6;/* external variable in initialized data */char buf[ ] = "a write to stdout\n";int main(void){

int var;/* automatic variable on the stack */

pid_t pid;


50/165

var = 88;if (write(STDOUT_FILENO, buf,

sizeof(buf)-1) != sizeof(buf)-1)

err_sys("write error");

printf("before fork\n");if ( (pid = fork()) < 0)

err_sys("fork error");else if (pid == 0){ /* child */

glob++; /* modify variables */var++;

}


51/165

elsesleep(2);

/* parent */

printf("pid = %d, glob = %d, var =%d\n", getpid(), glob, var);

exit(0);}


52/165

file sharingFork creates a duplicate copy of the file

descriptors opened by parentThere are two ways of handling descriptorsafter fork1.The parent waits for the child to complete2.After fork the parent closes all descriptorsthat it doesnt need and the does the same

thing


53/165

Besides open files the other propertiesinherited by child are

Real user ID, group ID, effective user ID,effective group IDSupplementary group IDProcess group IDSession IDControlling terminalset-user-ID and set-group-ID

Current working directory


54/165

Root directoryFile mode creation maskSignal mask and dispositionsThe close-on-exec flag for any open filedescriptors

EnvironmentAttached shared memory segmentsResource limits

Th diff b h d hild


55/165

The difference between the parent and childThe return value of fork

The process IDParent process IDThe values of tms_utime , tms_stime ,tms_cutime , tms_ustime is 0 for child

file locks set by parent are not inherited bychildPending alrams are cleared for the childThe set of pending signals for the child isset to empty set


56/165

The functions of fork

1.A process can duplicate itself so thatparent and child can each execute differentsections of code

1.A process can execute a different program


57/165

vfork

It is same as forkIt is intended to create a new process whenthe purpose of new process is to exec anew programThe child runs in the same address spaceas parent until it calls either exec or exitvfork guarantees that the child runs first ,

until the child calls exec or exit


58/165

int glob = 6;/* external variable in initialized data */

int main(void){int var;

/* automatic variable on the stack */

pid_t pid;var = 88;printf("before vfork\n");

if ( (pid = vfork()) < 0)

err_sys("vfork error");


59/165

else if (pid == 0) { /* child */glob++;

/* modify parent's variables */var++;_exit(0); /* child terminates

*/

}/* parent */printf("pid = %d, glob = %d, var =

%d\n", getpid(), glob, var);

exit(0);}

i f i


60/165

exit functionsNormal termination1.Return from main2.Calling exit includes calling exit handlers3.Calling _exit it is called by exit function

Abnormal termination1.Calling abortSIGABRT2.When process receives certain signals

E it t t i d t tif t h


61/165

Exit status is used to notify parent how achild terminated

When a parent terminates before thechild, the child is inherited by init process

If the child terminates before the parentthen the information about the is obtained

by parent when it executes wait or waitpidThe information consists of the process

ID, the termination status and amount ofCPU time taken by process


62/165

A process that has terminated , but

whose parents has not yet waited forit, is called a zombieWhen a process inherited by init

terminates it doesnt become a zombieInit executes one of the wait functions to

fetch the termination status

W it d it id f ti


63/165

Wait and waitpid functions

When a child id terminated the parent isnotified by the kernel by sending a

SIGCHLD signal

The termination of a child is anasynchronous eventThe parent can ignore or can provide afunction that is called when the signal

occurs

Th th t ll it it id


64/165

The process that calls wait or waitpid can1.Block

2.Return immediately with termination statusof the child3.Return immediately with an error

#include #include pid_t wait (int *statloc);

pid_t waitpid (pid_t pid,int *statloc ,int options );


65/165

Statloc is a pointer to integerIfstatloc is not a null pointer,the

termination status of the terminatedprocess is stored in the location pointed toby the argument

The integer status returned by the twofunctions give information about exit status,signal numberand about generation of corefile

M hi h id i f ti b t


66/165

Macros which provide information abouthow a process terminated

WIFEXITED TRUE if child terminatednormally

WEXITSTATUS is used tofetch the lower 8 bits ofargument child passed to

exit or _exit

TRUE if child


67/165

WIFSIGNALEDTRUE if childterminated abnormallyWTERMSIG is used tofetch the signal numberthat caused terminationWCOREDUMP is true is

core file was generated

WIFSTOPPED TRUE for a child that iscurrently stopped

WSTOPSIG -- is used tofetch the signal numberthat caused child to stop

it id


68/165

The interpretation of pid in waitpiddepends on its value1.Pid == -1 waits for any child2.Pid > 0 waits for child whose process

ID equals pid3.Pid == 0 waits for child whose processgroup ID equals that of calling process

4.Pid < -1 waits for child whose processgroup ID equals to absolute value of pid

waitpid

W it id h l it f ti l


69/165

Waitpid helps us wait for a particularprocess

It is nonblocking version of waitIt supportsjob control

WNOHANG Waitpid will not block ifthe child specified is notavailable

WUNTRACED supports job control

#incl de


70/165

#include #include #include "ourhdr.h"

Int main(void){

pid_t pid;int status;

if ( (pid = fork()) < 0)err_sys("fork error");else if (pid == 0) /* child */

exit(7);


71/165

if (wait(&status) != pid)/* wait for child */

err_sys("wait error");pr_exit(status);

/* and print its status */if ( (pid = fork()) < 0)

err_sys("fork error");else if (pid == 0) /* child */

abort();

/* generates SIGABRT */

if (wait(&status) != pid)


72/165

if (wait(&status) != pid)/* wait for child */

err_sys("wait error");pr_exit(status);

/* and print its status */if ( (pid = fork()) < 0)

err_sys("fork error");else if (pid == 0) /* child */

status /= 0;/* divide by 0 generates SIGFPE */


73/165

if (wait(&status) != pid)

/* wait for child */err_sys("wait error");

pr_exit(status);/* and print its status */

exit(0);}

wait3 and wait4 functions


74/165

wait3 and wait4 functionsThese functions are same as waitpid butprovide additional information about theresourcesused by the terminated process


75/165

#include

#include #include #include

pid_t wait3 (int *statloc ,int options, structrusage *rusage );

pid_t wait4 (pid_t pid ,int *statloc ,intoptions, struct rusage *rusage );

Race condition


76/165

Race condition

Race condition occurs when multipleprocess are trying to do something withshared data and final out come depends on

the order in which the processes run

Program with race condition


77/165

Program with race condition

#include #include "ourhdr.h"static void charatatime(char *);int main(void){

pid_t pid;if ( (pid = fork()) < 0)

err_sys("fork error");

l if ( id 0)


78/165

else if (pid == 0){

charatatime("output fromchild\n");

}else

{charatatime("output from

parent\n");

}exit(0);}


79/165

/*altered program*/


80/165

/ altered program /#include

#include "ourhdr.h"static void charatatime(char *);Int main(void){

pid_t pid;TELL_WAIT();

if ( (pid = fork()) < 0)


else if (pid == 0)


81/165

else if (pid == 0){

WAIT_PARENT(); /* parent goesfirst */charatatime("output from

child\n");

}else {

charatatime("output from

parent\n");TELL_CHILD(pid);}exit(0);

}


82/165

exec functions


83/165

exec functions

Exec replaces the calling process by anew programThe new program has sameprocess ID as

the calling processNo new program is created , exec justreplaces the current process by a newprogram


84/165

#include

int exec1 ( const char *pathname,const char *arg0 , /*(char *) 0*/);

int execv (const char *pathname, char *

const argv[ ]);int execle (const char *pathname, constchar *arg0 , /*(char *) 0,

char *const envp[ ] */);


85/165

int execve ( const char *pathname,char *const argv[ ] ,char *const envp [ ]);

int execlp (const char *filename, const

char *arg0 , /*(char *) 0*/);int execvp (const char *filename ,char

*const argv[ ] );

Relation between exec functions


86/165

Relation between exec functions

execle

execv execve

execlexeclp

execvp

Build argv Build argv Build argv

Try each

PATH prefix

use

environ

#include


87/165

y yp#include #include "ourhdr.h"

char *env_init[ ] ={ "USER=unknown", "PATH=/tmp", NULL };int main(void){

pid_t pid;if ( (pid = fork()) < 0)

err_sys("fork error");else if (pid == 0) {/* specify pathname, specify environment */

if ( execle ("/home/stevens/bin/echoall",


88/165

"echoall", "myarg1", "MY ARG2",(char *) 0, env_init) < 0)

err_sys("execle error");}if (waitpid(pid, NULL, 0) < 0)

err_sys("wait error");if ( (pid = fork()) < 0)


else if (pid == 0) {


89/165

else if (pid 0) {/* specify filename, inherit environment */

if (execlp("echoall","echoall", "only 1 arg",(char *) 0) < 0)

err_sys("execlp error");

}exit(0);

}

Changing user IDs and group IDs


90/165

Changing user IDs and group IDs

Prototype

#include #include int setuid (uid_t uid);int setgid (gid_t gid);

Rules


91/165

1.If the process has superuser privilege, thesetuid function setsreal user ID, effective

user ID , saved set-user-ID to uid2.If the process doesnot have superuserprivilege, but uid equals eitherreal user IDorsavedset-user-ID, setuid sets only

effective user ID to uid3.If neither of the two conditions is true,errno is set to EPERM and an error isreturned


92/165

ID exec

Set-user-IDbit off

exec

Set-user-Id biton

Real user IDEffective userIDSaved setuser ID

unchangedunchanged

copied fromeffective

user ID

unchangedSet from user IDof program filecopied fromeffective user ID


93/165

ID Superuser

Unprivilegeduser

Real user ID

Effective user IDSaved set-user ID

Set to uid

Set to uidSet to uid

unchanged

Set to uidunchanged

setreuid and setregid


94/165

setreuid and setregid

#include

#include int setreuid (uid_t ruid, uid_t euid);int setregid (gid_t rgid,gid_t egid);

seteuid and setegid


95/165

seteuid and setegid

#include #include

int seteuid (uid_t euid);int setegid (gid_t egid);


96/165

Real user ID

EffectiveUser ID

SavedSet-user-ID

Interpreter files


97/165

Interpreter files

Files which begin with a line of the form#! pathname [ optional argument ]

most common example :

#! /bin/bashThe actual file execed by kernel is the onespecified in the pathname

/*example of interpreter file*/


98/165

/ example of interpreter file /

#!/bin/awk -f

BEGIN{

for (i = 0; i < ARGC; i++)printf "ARGV[%d] = %s\n", i,

ARGV[i]exit

}


99/165

Uses of interpreter files

1.They hide the fact that certain programsare scripts in some other language2.They provide an efficiency gain3.

They help us write shell scripts usingshells other than /bin/sh

system function


100/165

y

It helps us execute a command stringwithin a programSystem is implemented by calling fork,

exec and waidpid

#include

int system (const char *cmdstring);

Return values of system function


101/165

Return values of system function

-1 if either fork fails or waitpid returns an

error other than EINTR127 -- If exec fails [as if shell has executedexit ]

termination status of shell -- if all threefunctions succeed

#include


102/165

y yp#include #include #include

int system(const char *cmdstring)/* version without signal handling */

{pid_t pid;int status;

if (cmdstring == NULL)ret rn(1)


103/165

return(1);/* always a command processor with Unix */

if ( (pid = fork()) < 0){status = -1;

/* probably out of processes */

} else if (pid == 0){ /* child */execl("/bin/sh", "sh", "-c", cmdstring,

(char *) 0);

_exit(127); /* execl error*/}

else { /* parent */


104/165

while (waitpid(pid, &status, 0) < 0)if (errno != EINTR) {

status = -1;/* error other than EINTR from waitpid() */

break;

}}return(status);

}

/* calling system function*/#include


105/165

#include #include #include "ourhdr.h"int main(void){

int status;

if ( (status = system("date")) < 0)err_sys("system() error");pr_exit(status);

if ( (status = system("nosuchcommand")) < 0)


106/165

if ( (status system( nosuchcommand )) < 0)err_sys("system() error");

pr_exit(status);

if ( (status = system("who; exit 44")) < 0)err_sys("system() error");

pr_exit(status);

exit(0);}

Process accounting


107/165

g

Process accounting : when enabled kernelwrites an accounting record each time aprocess terminates

Accounting records : 32 bytes of binarydata

Struct acct{char ac flag;


108/165

char ac_flag;char ac_stat;uid_t ac_uid;gid_t ac_gid;dev_t ac_ttty;time_t ac_btime;comp_t ac_utime;

comp_t ac_stime;comp_t ac_etime;comp_t ac_mem;comp_t ac_io;comp_t ac_rw;

char ac_comm;}

/*prog: to generate accounting data */#include


109/165

#include #include

#include "ourhdr.h"#define ACCTFILE "/var/adm/pacct"static unsigned long

compt2ulong(comp_t);

int main(void){

struct acct acdata;FILE *fp;

if ( (fp = fopen(ACCTFILE, "r")) == NULL)err sys("can't open %s"


110/165

err_sys( can t open %s ,ACCTFILE);

while(fread(&acdata, sizeof(acdata), 1, fp) == 1)

{ printf("%-*.*s e = %6ld, chars = %7ld, ""stat = %3u: %c %c %c

%c\n",

sizeof(acdata.ac_comm),

sizeof(acdata.ac_comm),acdata.ac_comm,

compt2ulong(acdata.ac_etime),compt2ulong(acdata.ac_io),(unsigned char)

acdata.ac_stat,

#ifdef ACORE/* SVR4 d 't d fi ACORE */


111/165

/* SVR4 doesn't define ACORE */acdata.ac_flag & ACORE ? 'D' : ' ',

#else

' ',#endif

#ifdef AXSIG/* SVR4 doesn't define AXSIG */acdata.ac_flag & AXSIG ? 'X' : ' ',

#else

' ',#endif

acdata.ac flag & AFORK ? 'F' : ' ',


112/165

_ g ,

acdata.ac_flag & ASU ? 'S' : ' ');

}if (ferror(fp))err_sys("read error");

exit(0);

}

static unsigned longcompt2ulong(comp t comptime)


113/165

compt2ulong(comp_t comptime)/* convert comp_t to unsigned long */

{ unsigned long val;int exp;val = comptime & 017777;

/* 13-bit fraction */exp = (comptime >> 13) & 7;

/* 3-bit exponent (0-7) */while (exp-- > 0)

val *= 8;

return(val);}

User identification


114/165

To obtain the login name

#include

char *getlogin (void);

Process times


115/165

Struct tms {clock_t tms_utime;

clock_t tms_stime;clock_t tms_cutime;clock_t tms_cstime;

}

#include clock_t times (struct tms *buf);

#include #include "ourhdr h"


116/165

#include ourhdr.h static void

pr_times (clock_t, struct tms *, struct tms *);static void do_cmd(char *);int main (int argc, char *argv[ ])

{ int i;for (i = 1; i < argc; i++)do_cmd(argv[i]);

/* once for each command-line arg */

exit(0);}

static voiddo cmd (char *cmd)


117/165

do_cmd (char *cmd)/* execute and time the "cmd" */

{struct tms tmsstart, tmsend;clock_t start, end;int status;

fprintf(stderr, "\ncommand: %s\n",cmd);

if ( (start = times(&tmsstart)) == -1)/* starting values */

err_sys("times error");

if ( (status = system(cmd)) < 0)


118/165

/* execute command */

err_sys("system() error");if ( (end = times(&tmsend)) == -1)

/* ending values */

err_sys("times error");pr_times(end-start, &tmsstart,

&tmsend);

pr_exit(status);}

static void


119/165

pr_times (clock_t real, struct tms *tmsstart,

struct tms *tmsend){ static long clktck = 0;if (clktck == 0)

/* fetch clock ticks per second first time */

if ( (clktck = sysconf(_SC_CLK_TCK)) tms_utime - tmsstart>

tms_utime) / (double) clktck);fprintf(stderr, " sys: %7.2f\n",(tmsend->tms_stime - tmsstart-

>tms_stime) / (double) clktck);


121/165

Terminal logins


122/165

4.3+BSD terminal login

Getty

init

init

Process ID 1

Forks once per terminal

Each child execsgetty

fork

exec


123/165

init

init

getty

login

fork

Reads /etc/ttysForks once per terminal

creats empty environment

opens terminal devicereads user name

exec

exec

process ID 1


124/165

user ata terminal

terminal devicedriver

login shell

init

through login and getty

fd 0,1,2

RS 232 connection

network login


125/165

inetd

init

inetd

telnetd

fork/exec of/bin/shwhich executes shell script /etc/rc

when connection request arivesfrom telnet user

fork

exec

proces ID 1


126/165

pseudo-terminaldevice driver

user at aterminal

login shell

init

through inetd, telenetdand login

fd 0, 1, 2

network connection through

telnetd server and telnetd client

process ID 1

Process groups


127/165

A process group is a collection of one ormore processes.Each process group has a unique processgroup ID.

Process group IDs are similar to processIDs---they are positive integers and they canbe stored in a pid_tdata type.The function getpgrp returns the processgroup ID of the calling process.


128/165

Each process group can have a processleader. The leader is identified by havingits process group ID equal its process ID.

#include

#include pid_t getpgrp (void);

It is possible for a process group leader tot t i


129/165

create a process group, create processes in

the group, and then terminate.The process group still exists, as long asthere is at least one process in the group,regardless whether the group leader

terminates or notprocess group lifetime the period oftime that begins when the group is createdand ends when the last process in thegroup leaves the group

A process joins an existing process group,or creates a new process group by calling


130/165

or creates a new process group by callingsetpgid.

This sets the process group ID to pgid of

the process pid. If the two arguments areequal, the process specified by pidbecomes a process group leader.

#include #include int setpgid (pid_t p id, pid_t pgid);

A process can set the process group ID ofl it lf f it hild If id i 0


131/165

only itselforone of its children. Ifp idis 0,

the process ID of the caller is used. Also ifpgidis 0, the process ID specified by p idisused as the process group ID.In most job-control shells this function is

called after a fork to have the parent set theprocess group ID of the child, and to havethe child set its own process groupID.

SESSIONSA S i i ll ti f


132/165

A Session is a collection ofone or moregroups.The processes in a process group areusually grouped together into a processgroup by a shell pipeline.

A process establishes a new session bycalling the setsidfunction.

#include #include pid_t setsid (void)


133/165

Login shell proc1 proc2 proc3 proc4

proc5

Process group

process group

Process group

session

Arrangement of processes intoprocess groups and sessions

If the calling process is not a processgroup leader this function creates a new


134/165

group leader, this function creates a newsession. Three things happen:1.The process becomes the session leaderof this new session.2.The process becomes the process group

leader of a new process group. The newprocess group ID is the process ID of thecalling process.3.The process has no controlling terminal.

If the process had a controlling terminalbefore calling setsid, that association isbroken.

Controlling terminal


135/165

characteristics of sessions and process

groupsA session can have a single controllingterminal.The session leader that establishes the

connection to the controlling terminal iscalled the controlling process.The process groups within a session canbe divided into a single foreground process

group and one or morebackground processgroups.

If a session has a controlling terminal,then it has a single foreground process


136/165

then it has a single foreground processgroup, and all other process groups in thesession are background process groups.Whenever we type ourterminals interruptkey or quit key this causes either the

interrupt signal or the quit signal to be sentto all processes in the foreground processgroup.If a modem disconnect is detected by the

terminal interface, the hang-up signal issent to the controlling process

L i h ll 1 2 3 4

session


137/165

Login shell proc1 proc2 proc3 proc4

proc5

background process group

Session leader =Controlling process

background process group

foreground process group

Controllingterminal

modem disconnect(hangup signal)

Terminal input andTerminal-generated signals

Process groups and sessions showing controlling terminal

tcgetpgrp and tcsetpgrp Functions


138/165

We need to tell the kernel which processgroup is the foreground process group, sothat the terminal device driver knows whereto send the terminal input and the terminal-

generated signals#include #include

pid_t tcgetpgrp(int f i ledes);int tcsetpgrp(int f i ledes, pid_t pgrp id);

The functiontcgetpgrpreturns the processID f h f d


139/165

group ID of the foreground process group

associated with the terminal open onfiledes.If the process has a controlling terminal,the process can call tcsetpgrp to set the

foreground process group ID to pgrpid..

Job Control


140/165

Why do we need job control?

To allow us to start multiple jobs from asingle terminal and control which jobs canaccess the terminal and which jobs are tobe run in the background.It requires 3 forms of support:A shell that supports job control.The terminal driver in the kernel must

support job control.Support for certain job-control signals

A job is just a collection of processes, often apipeline of processes.


141/165

When we start a background job, the

shell assigns it a job identifier and prints oneor more process IDs.$ make all > Make.out &

[1] 1475

$ pr *.c | lpr &[2] 1490$ just press RETURN[2] + Done pr *.c | lpr &[1] + Done make all > Make.out

&

The reason why we have to press RETURNis to ha e the shell print its prompt The


142/165

is to have the shell print its prompt. The

shell doesnt print the changed status ofbackground jobs at any random time --only right before it prints its prompt, to letus enter a new command line.Entering the suspend key (Ctrl + Z) causesthe terminal driver to send the SIGTSTPsignal to all processes in the foreground

process group.

The terminal driver really looks for 3special characters which generate signals


143/165

special characters, which generate signalsto the foreground process group:

The interrupt character generates SIGINTThe quit character generates SIGQUIT

The suspend character generates SIGTSTP

PROGRAM:$cat temp.foo & start in background, but Itll

read from standard input


144/165

read from standard input[1] 1681

$ we press RETURN[1] + Stopped (tty input) cat > temp.foo &$ fg %1 bring job number 1 to

foregroundcat > temp.foo the shell tells us which job is

now in the foregroundhello, world enter one line^D type our end-of-file$ cat temp.foo check that the one line put

into the filehello, world


145/165

Shell Execution Of Programs


146/165

Bourne shell doesnt support job controlpsxj gives the following output

PPID PID PGID SID TPGID COMMAND1 163 163 163 163 -sh

163 168 163 163 163 ps

Both the shell and the ps command are inth i d f d


147/165

the same session and foreground process

group(163). The parent of the ps commandis the shell.A process doesnt have a terminal process

control group.A process belongs to a process group, andthe process group belongs to a session.The session may or may not have a

controlling terminal.

The foreground process group ID is anattribute of the terminal, not the process.


148/165

, p If ps finds that the session does not have

a controlling terminal, it prints -1.If we execute the command in the

background,

Psxj &The only value that changes is the process

ID.

psxj | cat1

PPID PID PGID SID TPGID COMMAND


149/165

PPID PID PGID SID TPGID COMMAND

1 163 163 163 163 -sh163 200 163 163 163 cat1200 201 163 163 163 ps

The last process in the pipeline is the child ofthe shell, and the first process in the pipelineis a child of the last process.


150/165

Orphaned process groups


151/165

We know that a process whose parentterminates is called an orphan and isinherited by the init process.

Sometimes the entire process groups canbe orphaned.


152/165

Login shell(PID 442)

Parent( PID 512)

Child(PID 513)

Process group 512

Processgroup 442

Fork/execsession

fork

This is a job-control shell. The shell placesthe foreground process in its own process


153/165

g p pgroup( 512 in the example) and the shell

stays in its own process group(442). Thechild inherits the process group of itsparent(512). After the fork,

The parent sleeps for 5 seconds. This is the(imperfect) way of letting the child executebefore the parent terminatesThe child establishes a signal handler for

the hang-up signal (SIGHUP). This is so wecan see if SIGHUP is sent to the child.

The child itself the stop signal(SIGTSTP)ith th kill f ti


154/165

with the kill function.

When the parent terminates, the child isorphaned, so the childs parent process ID

becomes 1, the init process ID.

At this point the child is now a member ofan orphaned process group.

Since the process group is orphaned whenthe parent terminates, it is required that


155/165

p qevery process in the newly orphaned

process group that is stopped be sent thehang-up signal (SIGHUP) followed by thecontinue signal.

This causes the child to be continued, afterprocessing the hang-up signal. The defaultaction for the hang-up signal is to terminatethe process, which is why we have to

provide a signal handler to catch the signal

Creating an orphaned process

group


156/165

group

#include #include #include #include

#include "ourhdr.h"static void sig_hup(int);static void pr_ids(char *);

int main(void){

h


157/165

char c;

pid_t pid;pr_ids("parent");if ( (pid = fork()) < 0)


else if (pid > 0){ /* parent */

sleep(5);exit(0);

}

else { /* child */pr_ids("child");signal(SIGHUP sig hup);


158/165

signal(SIGHUP, sig_hup);

/* establish signal handler */kill (getpid(), SIGTSTP);pr_ids("child");

/* this prints only if we're continued */

if (read(0, &c, 1) != 1)printf ("read error from controlterminal,errno = %d\n", errno);

exit(0);

}}

static void sig_hup (int signo){

printf("SIGHUP received pid = %d\n"


159/165

printf( SIGHUP received, pid %d\n ,getpid());

return;}

static void pr_ids (char *name)

{ printf("%s: pid = %d, ppid = %d, pgrp =d\n", name, getpid(), getppid(), getpgrp());

fflush(stdout);

}

/* OUTPUT$ a.out


160/165

$Parent: pid = 512, ppid=442, pgrp = 512Child: parent = 513, ppid = 512, pgrp = 512$ SIGHUP received, pid = 513Child: pid = 513 , ppid = 1, pgrp = 512

Read error from control terminal, errno = 5*/

The parent process ID of the child hasbecome 1.


161/165

After calling pr_ids in the child, theprogram tries to read from standard input.When the background process group triesto read from its controlling terminal,

SIGTTIN is generated from the backgroundprocess group.The child becomes the backgroundprocess group when the parent terminates,since the parent was executed as aforeground job by the shell

The parent process ID of the child hasbecome 1.


162/165

After calling pr_ids in the child, theprogram tries to read from standard input.When the background process group triesto read from its controlling terminal,

SIGTTIN is generated from the backgroundprocess group.The child becomes the backgroundprocess group when the parent terminates,since the parent was executed as aforeground job by the shell

Questions

f f C


163/165

Explain briefly the memory layout of a C

program (10)What is fork and vfork ? Explain with anexample for each (8)What is a zombie process ? Write a

program in C/C++ to avoid zombie processby forking twice (6)What is job control ? Summarize the jobcontrol features with the help of a figure

(10)


164/165

What is a controlling terminal ? Explain itscharacteristics and relation to session andprocess groups (10)


165/165

process groups (10)

With an example explain the use of setjmpand longjmp functions (10)What is race condition ? Write a programto demonstrate the race condition (10)

With a neat block diagram, explain how a Cprogram is started and the various ways itcan terminate. Give the prototypes for exitand _exit functions and explain their

difference (10)

unix processes 1complete4&5

Documents