PROCESS CONTROL
Topics covered
Introduction
Process identifiers
Fork function
vfork function
Exit function
wait and waitpid function
Wait3 and wait4 functions
Race conditions
Exec conditions
Changing user ID’s and Group ID’s
Interpreter files
System function
User identification
Process times
Process acounting
Introduction
Process control – concerned – creation of new processes , program execution and process termination
Process Identifiers
1. Process ID (pid)
- unique process ID
- Function to retrieve – getpid
prototype
#include<unistd.h>
pid_t getpid(void);
Returns : process ID of calling process
2. Parent Process ID ( ppid) pid retrieved – getppid prototype pid_t getppid(void); Returns : parent process ID of the calling process
3. Real user ID (ruid) is user created – parent process prototype uid_t getuid(void); Returns : real user ID of the calling process
4. Effective user ID (euid) - same as real user id , except file executed – create process – set – uid
turned on prototype : uid_t geteuid(void) Returns : effective user ID of calling process 5. Real group ID (gid) : - id - user – parent process prototype : gid_t getgid(void); Returns : real group ID of calling proces
6. Effective Group ID (egid) :
same as real group id , except file executed – create process – set – gid flag
turned on
function ptototype :
gid_t getegid(void);
Returns : effective ID of the calling process
Fork function
- process created – existing process – calls fork function
#include <unistd.h>
pid_t fork(void);
Returns : 0 in child , process ID of child in parent , -1 on error
- new process created – fork – child process
Program to demonstrate fork function
#include <sys/types.h>
#include <unistd.h>
int main( )
{
fork( );
printf(“\n hello USP”);
}
Properties of parent inherited by child
• Real user ID , real group ID , effective user ID , effective group ID
• Supplementary group ID’s
• Process group ID
• Session ID
• Controlling terminal
• Set -user-id and set-group-id
• Current working directory
• Root directory
• File mode creation mask
• Signal masks and dispositions
• Close – on – exec flag for any open file descriptors
• Environment
• Attached shared memory segments
• Memory mappings
• Resource limits
Differences between parent and child are
• Return value from fork
• Process IDs are different
• The 2 processes have different parent process IDs : parent process ID of the
child is the parent ; the parent process ID of the parent doesn’t change
• The child’s tms_utime , tms_stime , tms_cutime , and tms_cstime values
are set to 0
• File locks set by the parent are not inherited by the child
• The set of pending signals for the child is set to the empty set
2 reasons for calling fork system call are :
• Process – duplicates itself so that parent and child can each execute
different sections of code at the same time
• Common for network servers
• Process – wants to execute different program
• Common for shells
vfork function
- same calling sequence and same return values as that of fork
- intended – create – new process
Prototype of vfork is
#include<unistd.h>
#include<sys/types.h>
pid_t vfork(void);
Returns : 0 in child , process ID of child in parent , -1 on error
Example of vfork#include<unistd.h>#include<sys/types.h>int glob = 6;int main(void){ int var; pid_t pid; var = 88; printf(“before vfork\n”); if((pid=vfork( ))<0){
err_sys(“vfork error”);}else if (pid= = 0){glob++;var++;_exit(0);}
Exit functions
Process can be terminated in 5 ways
• Executing return from main function
• Calling exit function
• Calling the _exit or _Exit
• Executing a return from the start routine of the last thread in the process
• Calling the pthread_exit function from the last thread in the process
3 forms of abnormal termination
• Calling abort
• When the process receives certain signals
• The last thread responds to a cancellation request
Wait and waitpid functions
Parent process – use – wait – waitpid – wait – child process – terminate and
retrieve the child exit status
prototype
#include<sys/wait.h>
pid_t wait(int *statloc);
#include<sys/wait.h>
pid_t wait(int *statloc);
pid_t waitpid(pid_t pid , int *statloc , int options);
both return : process ID if ok and -1 on error
Differences between wait and waitpid
Wait – block – caller , waitpid – option – prevents – blocking
Waitpid – doesn’t wait – child – terminates
Wait – child terminated
Parent can check the exit status code with the following macro’s defined in <sys/wait.h>
• WIFEXITED
• WEXITSTATUS
• WIFSIGNALLED
• WTERMSIG
• WIFSTOPPED
• WSTOPSIG
Wait3 and wait4 functions - provide additional arguments – allows – kernel – return – summary –
resources – used – terminated process prototype #include < sys/types.h> #include <sys/wait.h> #include <sys/time.h> #include<sys/resource.h> pid_t wait3(int *statloc , int options , struct rusage *rusage); pid_t wait4(pid_t pid , int *statloc , int options , struct rusage *rusage); both return : process ID if ok , -1 on error
Race conditions• Occurs – multiple processes – trying – something – shared data – final
outcome – depends – order – processes runs• To avoid race condition and avoid poling – signaling required – multiple
processes• Program that contains a race condition : #include<stdlib.h> #include<sys/types.h> static void charatatime(char *); int main (void) { pid_t pid;
if((pid=fork( ))<0){ printf(“fork error”);}else if(pid = = 0){ charatatime(“output from child\n”);}else{ charatatime(“output from parent\n”); }
exit(0);}
static void charatatime(char *str){ char *ptr; int c; stdbuf(stdout , NULL); for (ptr = str; (c = *ptr++) ! = 0) putc(c, stdout);}• To avoid race condition TELL and WAIT functions can be used in above
program
Exec functions• Causes – calling process – change – context – execute – different program• 6 versions of exec system calls• Same function – differ – argument lists• Process ID does not change – new process – not createdPrototype of these functions#include <unistd.h>int execl(const char *pathname , const char *arg0 , …/* (char *) 0 */ );int execv(const char *pathname , char *const argv [ ]);int execle(const char *pathname , const char *arg0,…/*(char *)0, char *constenvp */ );
int execve(const char *pathname , char *const argv[ ] ,char *const envp[ ]);
int execlp(const char *filename, const char *ag0,…/* (char *)0 */ );
int execvp(const char *filename , char *const argv [ ] );
Return : -1 on error , no return on success
- 1st difference – 1st 4 – pathname – argument , last 2 – filename argument
- Filename - / - pathname
- Executable file – searched – directories specified – PATH environment
variable
Additional properties inherited from calling process
• Process ID and parent process ID
• Real user ID and real group ID
• Supplementary group ID’s
• Process group ID
• Session ID
• Controlling terminal
• Time left until alarm clock
• Current working directory
• Root directory
• File mode creation mask
• File locks
• Process signal mask
• Pending signals
• Resource limits
Changing user ID’s and group ID’s
1.Setuid and setgid functions
Real group ID and effective group ID - set – setgid
Prototype :
#include<unistd.h>
int setuid(uid_t uid);
int setgid(gid_t gid);
Return : 0 if ok , 1 on error
Rules to change these ID’s
• Process – superuser privileges – setuid function – sets – real user ID ,
effective user ID , saved user ID – uid
• Process – no – superuser privileges – uid – equals – either – real user ID –
saved set-user-ID
• Errno – EPERM – 1 RETURNED
• Superuser process – change – real user ID• Effective user ID – set – exec functions – set user ID set – program file• Saved set user ID – copied – effecctive user ID – exec
Setreuid and setregid functions
• Swapping – real user ID , effective user ID – setreuid function
#include <unistd.h>
int setreuid(uid_t ruid , uid_t euid);
int setregid(gid_t rgid , gid_t egid);
Return : 0 if ok , -1 on error
Seteuid and setegid functions
- Similar – setuid and setgid , effective user ID and effcetive group ID
changed
#include <unistd.h>
int seteuid(uid_t uid);
int setegid(gid_t gid);
Return : 0 if ok , 1 on error
Interpreter files
- Text files – begin – line of form
# ! pathname [ optional – argument]
- Space – exclamation – pathname- optional
- Most common
# !/bin/sh
Program
#include < sys/types.h>
#include <sys/wait.h>
int main (void)
{
pid_t pid;
if ((pid = fork( )) < 0 ){ printf(“fork error”);}else if( pid = = 0){ /* child*/if (execl(“/home/vtu/testinterp” , “testinterp” , “myarg1 “ ,”MY ARG2” , (char * )
0) < 0 )printf(“execl error”);}if(waitpid(pid , NULL , 0) < 0 ) /*parent*/printf(“waitpid error”);exit(0);}
System function
- Used – execute – command string – program
- Can be called as
system(“date > file “);
Prototype :
#include <stdlib.h>
int system(const char *cmdstring);
- System function – implemented – calling fork , exec and waitpid
- Calls – fork – create – child process
- Inturn – calls – execlp – execute – bourne shell with –c option
3 types of return values
• either – fork – fails – waitpid – returns – error – system returns 1 – errno –
set – indicate – error
• Exec – fails – return value – shell – executed – exit
• All 3 succeed – return value – termination status
User identification
System – keeps – track – name – logged in
getlogin – way – fetch – login name
Prototype :
#include <unistd.h>
char *getlogin(void);
Return : pointer to string giving login name if ok , NULL on error
Process times
3 values of a process maintained
• Wall clock time
• System CPU time
• User CPU time
Prototype :
#include <sys/times.h>
clock_t times(struct tms *buf);
Returns : elapsed wall clock time in clock ticks if ok , -1 on error
struct tms
{
clock_t tms_utime;
clock_t tms_stime;
clock_t tms_cutime;
clock_t tms_cstime;
};
Process accounting
- When enabled – kernel – writes – acounting record – process terminates
- Accounting records – small – amount – binary data – command name , amount
of CPU time used , user ID , group ID
- Superuser – executes – accton – pathname argument – enable accounting
- Structure – accounting records – defined - <sys/acct.h>
struct acct
{
char ac_flag;char ac_stat;uid_t ac_uid;gid_t ac_gid;dev_t ac_tty;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;};
ac_flag description
AFORK process is the result of fork , but never called exec
ASU process used superuser privileges
ACOMPAT process used compatibility mode
ACORE process dumped core
AXSIG process was killed by a signal
AEXPND expanded accounting entry