Transcript Unix programming INDEX UNIT-V I PPT SLIDES Srl. No. No. Module as per Session planner Lecture No. PPT Slide 1.

Unix programming
1
INDEX
UNIT-V I PPT SLIDES
Srl. No.
No.
Module as per Session planner
Lecture No.
PPT Slide
1. Process, process structure
L1
3-5
2. Starting new process, waiting for a process
L2
6-8
3. Zombie process, process control
L3
9-10
4. Process identifiers, fork, vfork, exit, wait, exe
L4
11-19
5. Signal functions, unreliable signals
L5
20-24
6. Interrupted system calls, kill, raise functions
L6
25-29
7. Alarm, pause, abort, system ,sleep functions
L7
51 -54
8. Revision
2
Process ,Process structure:
• Every process has a unique process ID, a
non-negative integer. Unique, process IDs are
reused. As processes terminate, their IDs
become candidates for reuse.
• Process ID 0 is usually the scheduler process
and is often known as the swapper.
• Process ID 1 is usually the init process and is
invoked by the kernel at the end of the
bootstrap procedure. The init process never
dies.
• process ID 2 is the page daemon.
3
L1.1
• In addition to the process ID, there are other
identifiers for every process. The following
functions return these identifiers.
#include <unistd.h>
pid_t getpid (void);
Returns: process ID of calling process.
pid_t getppid (void);
Returns: parent process ID of calling process.
uid_t getuid (void);
Returns: real user ID of calling process.
L1.2
4
uid_t geteuid (void);
Returns: effective user ID of calling process
gid_t getgid (void);
Returns: real group ID of calling process.
gid_t getegid (void);
Returns: effective group ID of calling process.
• None of these functions has an error return.
L1.3
5
fork Function:
• An existing process can create a new one by
calling the fork function.
#include <unistd.h>
pid_t fork(void);
Returns: 0 in child, process ID of child in parent,
-1 on error.
The new process created by fork is called the
child process. This function is called once but
returns twice. The only difference in the
returns is that the return value in the child is 0,
whereas the return value
in the parent is the 6
L2.1
process ID of the new child.
Eg:
int glob = 6;
char buf[] = "a write to stdout\n";
int main(void)
{
int var; pid_t pid; 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)
{
L2.2
err_sys("fork error");
7
else if (pid == 0)
{
glob++; var++;
}
else
{
sleep(2);
}
printf("pid = %d, glob = %d, var = %d\n", getpid(),
glob, var);
exit(0);
}
L2.3
8
$ ./a.out
a write to stdout
before fork
pid = 430, glob = 7, var = 89
pid = 429, glob = 6, var = 88
uses for fork:
1.When a process wants to duplicate itself so
that the parent and child can each execute
different sections of code at the same time.
2.When a process wants to execute a different
program. This is common for shells.
L2.4
9
vfork :
• The function vfork has the same calling
sequence and same return values as fork.
• The vfork function creates the new process,
just like fork, without copying the address
space of the parent into the child, as the child
won't reference that address space.
• vfork guarantees that the child runs first, until
the child calls exec or exit. When the child
calls either of these functions, the parent
resumes.
L2.5
10
exit :
A process can terminate normally in five ways:
1.Executing a return from the main function.
2.Calling the exit function.
3.Calling the _exit or _Exit function.
4.Executing a return from the start routine of the
last thread in the process.
5.Calling the pthread_exit function from the last
thread in the process.
Once the process terminates, the kernel closes
all the open descriptors for the process,
L4.1
11
releases the memory that it was using.
Exit Functions
Three functions terminate a program normally:
_exit and _Exit, which return to the kernel
immediately, and exit, which performs certain
cleanup processing and then returns to the
kernel.
#include <stdlib.h>
void exit( int status);
void _Exit( int status);
#include <unistd.h>
void _exit( int status);
L4.2
12
wait and waitpid Functions:
#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, or -1 on error.
• The wait function can block the caller until a
child process terminates, whereas waitpid has
an option that prevents it from blocking.
• The waitpid function doesn't wait for the child
that terminates first; it has a number of
options that control which process it waits for.
L4.3
13
For both functions, the argument statloc is a
pointer to an integer. If this argument is not a
null pointer, the termination status of the
terminated process is stored in the location
pointed to by the argument.
The interpretation of the pid argument for
waitpid depends on its value:
pid == 1 Waits for any child process.
pid > 0 Waits for the child whose process ID
equals pid.
pid == 0 Waits for any child whose process
group ID equals that L4.4
of the calling process. 14
pid < 1 Waits for any child whose process
group ID equals the absolute value of pid.
The options constants for waitpid:
WCONTINUED
WNOHANG
WUNTRACED
The waitpid function returns the process ID of
the child that terminated and stores the child's
termination status in the memory location
pointed to by statloc.
L4.5
15
exec Functions:
• Exec replaces the current process its text,
data, heap, and stack segments with a brand
new program from disk.
• with the exec functions, we can initiate new
programs.
There are six different exec functions.
L4.6
16
#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 *const envp[] */ );
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 17
L4.7
All six return: 1 on error, no return on success.
• The first difference in these functions is that
the first four take a pathname argument,
whereas the last two take a filename
argument. When a filename argument is
specified
If filename contains a slash, it is taken as a
pathname.
Otherwise, the executable file is searched for
in the directories specified by the PATH
environment variable.
L4.8
18
• The functions execl, execlp, and execle
require each of the command-line arguments
to the new program to be specified as
separate arguments. We mark the end of the
arguments with a null pointer.
• For the other three functions (execv, execvp,
and execve), we have to build an array of
pointers to the arguments, and the address of
this array is the argument to these three
functions.
L4.8
19
Signals:
• Signals are software interrupts. Signals
provide a way of handling asynchronous
events.
• Every signal has a name. These names all
begin with the three characters SIG. These
names are all defined by positive integer
constants (the signal number) in the header
<signal.h>.
• No signal has a signal number of 0.
L5.1
20
Signal Function:
• The simplest interface to the signal features
of the UNIX System is the signal function.
include <signal.h>
void (*signal(int signo, void (*func)(int)))(int);
Returns: previous disposition of signal if OK,
SIG_ERR on error.
• The signo argument is just the name of the
signal. The value of func is (a) the constant
SIG_IGN, (b) the constant SIG_DFL, or (c)
the address of a function to be called when
21
the signal occurs.
Simple program to catch SIGUSR1 &
SIGUSR2
static void sig_usr (int);
int main(void)
{
if (signal(SIGUSR1, sig_usr) == SIG_ERR)
err_sys("can't catch SIGUSR1");
if (signal(SIGUSR2, sig_usr) == SIG_ERR)
err_sys("can't catch SIGUSR2");
for ( ; ; )
pause();
L5.2
}
22
static void sig_usr (int signo)
{
if (signo == SIGUSR1)
printf("received SIGUSR1\n");
else if (signo == SIGUSR2)
printf("received SIGUSR2\n");
else err_dump("received signal %d\n", signo);
}
L5.3
23
Unreliable Signals:
Unreliable signals mean that signals could get
lost: a signal could occur and the process
would never know about it. Also, a process
had little control over a signal: a process
could catch the signal or ignore it.
L5.4
24
Interrupted System Calls:
• It is a system call within the kernel that is
interrupted when a signal is caught.
• To support this feature, the system calls are
divided into two categories: the "slow"
system calls and all the others.
• The slow system calls are those that can
block forever.
L6.1
25
• Reads that can block the caller forever if data
isn't present with certain file types.
• Writes that can block the caller forever if the
data can't be accepted immediately by these
same file types.
• Opens that block until some condition occurs
on certain file types.
• The pause function and the wait function.
• Certain ioctl operations.
• Some of the interprocess communication
functions .
L6.2
26
kill and raise Functions:
• The kill function sends a signal to a process
or a group of processes.
• The raise function allows a process to send a
signal to itself.
#include <signal.h>
int kill( pid_t pid, int signo);
int raise(int signo);
Both return: 0 if OK,-1 on error.
L6.3
27
There are four different conditions for the pid
argument to kill.
pid > 0 The signal is sent to the process
whose process ID is pid.
pid == 0 The signal is sent to all processes
whose process group ID equals the process
group ID of the sender and for which the
sender has permission to send the signal.
pid < 0 The signal is sent to all processes
whose process group ID equals the absolute
value of pid and for which the sender has
permission to send the
signal.
L6.4
28
pid == 1 The signal is sent to all processes on
the system for which the sender has
permission to send the signal.
• The super user can send a signal to any
process.
L6.5
29
alarm function:
• The alarm function allows us to set a timer
that will expire at a specified time in the
future.
• When the timer expires, the SIGALRM signal
is generated.
#include <unistd.h>
unsigned int alarm(unsigned int seconds);
Returns: 0 or number of seconds until
previously set alarm.
The seconds value is no.of clock seconds in the
future when the signal should be generated.30
L7.1
• If, when we call alarm, a previously registered
alarm clock for the process has not yet
expired, the number of seconds left for that
alarm clock is returned as the value of this
function.
• If a previously registered alarm clock for the
process has not yet expired and if the
seconds value is 0, the previous alarm clock
is canceled. The number of seconds left for
that previous alarm clock is still returned as
the value of the function.
L7.2
31
pause function:
• The pause function suspends the calling
process until a signal is caught.
#include <unistd.h>
int pause(void);
Returns: 1 with errno set to EINTR
• The only time pause returns is if a signal
handler is executed and that handler returns.
L7.3
32
abort Function:
• The abort function causes abnormal program
termination.
#include <stdlib.h>
void abort(void);
This function never returns.
• This function sends the SIGABRT signal to
the caller.
L7.4
33
system Function:
• It is convenient to execute a command string
from within a program.
#include <stdlib.h>
int system(const char *cmdstring);
• If cmdstring is a null pointer, system returns
nonzero only if a command processor is
available. This feature determines whether
the system function is supported on a given
operating system. Under the UNIX System,
system is always available.
L7.5
34
The system is implemented by calling fork,
exec, and waitpid, there are three types of
return values.
• If either the fork fails or waitpid returns an
error ,system returns 1 with errno set to
indicate the error.
• If the exec fails, implying that the shell can't
be executed, the return value is as if the shell
had executed exit(127).
• Otherwise, all three functions fork, exec, and
waitpid succeed, and the return value from
system is the termination
status
of
the
shell,
in
L7.6
35
the format specified for waitpid.
sleep Function:
#include <unistd.h>
unsigned int sleep(unsigned int seconds);
Returns: 0 or number of unslept seconds.
This function causes the calling process to be
suspended until either
• The amount of wall clock time specified by
seconds has elapsed. The return value is 0.
• A signal is caught by the process and the
signal handler returns. Return value is the
number of unslept seconds.
L7.7
36