Processes, timeouts and forks

Dr Qahhar Muhammad Qadir May 16, 2022 1 / 21

Processes, timeouts, and forks
How computers do several things at once

Some basic skills with processes

The fork system call and how to use it
How to create, initialise, and manage a timeout

Dr Qahhar Muhammad Qadir May 16, 2022 2 / 21

Processes, timeouts, and forks
Daemon process

A daemon is a background process

Not attached to any terminals
Uses syslogd for log and error messages
syslogd log files
Daemons
/var/run/log /dev/console
port 514 /var/log/cisco.log
/dev/klog

Kernal

Function of Daemon syslogd

Most daemons are created when the system is booted and stay alive
as long as the system running
Daemons provide various system services such as printing (daemon
lpd), ftp (daemon ftpd), telnet (daemon telnetd) and rlogin
(daemon rlogind) services
Dr Qahhar Muhammad Qadir May 16, 2022 3 / 21
Processes, timeouts, and forks
Superserver daemon inetd

daemon inetd runs on every Internet connected UNIX computer

Acts as a concurrent server
Creates various Internet servers upon request rather than provides
services
inetd daemon reduces the number of system daemons and simplifies
deamon process.

Dr Qahhar Muhammad Qadir May 16, 2022 4 / 21

Processes, timeouts, and forks
Converting a process to a daemon

To become a daemon, the process needs to become a background

process and, more importantly, it has to be de-associated with the
terminal of original process
Also, ensure that it will not be able to acquire any control terminal in
the future
function daemon init() does the job

Dr Qahhar Muhammad Qadir May 16, 2022 5 / 21

Processes, timeouts, and forks
Converting a process to a daemon; steps

Calls fork() to continue as the background child process (not a

group leader)
calls setid() to become the leader of a new process session and
de-associate any terminal
sets the hander to ignore SIGHUB, and
call fork() again to make sure the child daemon will not acquire any
controlling terminal

Dr Qahhar Muhammad Qadir May 16, 2022 6 / 21

Processes, timeouts, and forks
Processes

ps command
safeen@safeen-Lenovo$ ps aux | grep tftp
safeen 24153 0.0 0.0 2032 280 pts/27 S 21:05 0:00 ./tftp_ser 2222
safeen 24159 0.0 0.0 4680 820 pts/27 S+ 21:06 0:00 grep --color=auto tftp

killall; kill processes by name

safeen@safeen-Lenovo$ killall tftp_ser
[1]+ Terminated ./tftp_ser 2222

and kill; send a signal to a process

safeen@safeen-Lenovo$ kill -9 24153
[1]+ Terminated ./tftp_ser 2222

ctrl-Z, &, and jobs

ctrl-Z stops a program, after which bg causes it to continue, the
background. It can be put into action, in the foreground, by fg. The
cmd jobs shows the names of jobs in the bkgnd.
Dr Qahhar Muhammad Qadir May 16, 2022 7 / 21
Processes, timeouts, and forks
killall

When testing and writing a server, it is frequently necessary to kill one or

many copies of the server. For this, killall is ideal.
killall finds the processes with a specific name (of the program),
and kills all of them.

Dr Qahhar Muhammad Qadir May 16, 2022 8 / 21

Processes, timeouts, and forks
timers

Timeouts are an inherently multithread concept. We can either use a

separate process, or the operating system itself, or another thread in our
own process. We will use an OS call.
unsigned int alarm(unsigned int seconds);
causes a SIGALRM signal to be delivered however many seconds later
also cancels all previous signals
cancelled by calling alarm(0);
other ways to create timers include setitimer and timer create.

Dr Qahhar Muhammad Qadir May 16, 2022 9 / 21

Processes, timeouts, and forks
timers

void sig_alrm(int signo)

{
fprintf(stderr,"Alarm handler invoked.\n");
siglongjmp(jmpbuf, 1);
}
............
sigsetjmp(jmpbuf,1); // we will return here if the timer goes off
// so everything after here will be repeated
............
struct sigaction sa;
sa.sa_handler = sig_alrm;
sigaction(SIGALRM, &sa, NULL); /* estabish signal handler */
writeCounter = sendto(socket1, bufptr, sendCounter, 0,
(struct sockaddr *)&udpClient, sizeof(udpClient));
alarm(1); /* allow 1 second for the ACK to arrive */
............
alarm(0); /* at the end, cancel the timer */

Dr Qahhar Muhammad Qadir May 16, 2022 10 / 21

sigaction() instead of signal()
Change the action taken by a process on receipt of a specific signal
int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact);

#include <signal.h>

void handler(int signum)

{
if (signum == SIGINT)
{
printf("Ctrl + C pressed");
}
}
.
struct sigaction sa;
sa.sa_handler = handler;

struct sigaction {
void (*sa_handler)(int);
void (*sa_sigaction)(int, siginfo_t *, void *);
sigset_t sa_mask;
int sa_flags;
void (*sa_restorer)(void);
};

sigaction() returns 0 on success; on error, -1 is returned

Dr Qahhar Muhammad Qadir May 16, 2022 11 / 21
Processes, timeouts, and forks
sigsetjmp and siglongjmp

sigsetjmp and setjmp store the address of the next instruction in a

buffer;
siglongjmp longjmp jumps to the location in a buffer;
these are used together to cause a process to jump to a previously
stored location.
this may seem an odd thing to do; it is certainly not a conventional
programming practice. But, for timeouts, it is exactly what we need.

Dr Qahhar Muhammad Qadir May 16, 2022 12 / 21

Processes, timeouts, and forks
fork

The fork system call creates a copy of the current process and
resumes processing of both the original and the new process at
exactly the same location
In both processes the next instruction executed is the one
immediately after return from the fork.
we can use fork in a server to create child processes which deal with
each request;
the parent process can continue handling new requests – it continues
forever;
each child exits when the request is fulfilled;
we need to make sure children all terminate properly.

Dr Qahhar Muhammad Qadir May 16, 2022 13 / 21

Processes, timeouts, and forks
fork

Called once but return twice

Returns once in the calling process (parent) with a return value that
is the process ID of the newly created process (child)
Returns also in the child with a return value of 0
Returns value tells the process whether it is the parent or the child
if ((pid = fork()) == 0)
print "hello from the child"
else
print "hello from the parent"

Dr Qahhar Muhammad Qadir May 16, 2022 14 / 21

Processes, timeouts, and forks
Use of fork

All descriptors open in the parent before the call to fork are shared
with the child after fork returns.
Example:
Parent calls accept and then calls fork
Socket shared between the parent and child
Child reads and writes the socket
Parent Closes the socket
A process makes a copy of itself
A process wants to execute another program

Dr Qahhar Muhammad Qadir May 16, 2022 15 / 21

Processes, timeouts, and forks
Concurrent servers to handle multiple client

pid_t pid;
int listenfd, connfd;
listenfd = Socket( ... );
/* fill in sockaddr_in{} with server’s well-known port */
Bind(listenfd, ... );
Listen(listenfd, LISTENQ);
for ( ; ; ) {
connfd = Accept (listenfd, ... ); /* probably blocks */
if( (pid = fork()) == 0)
{
close(listenfd); /* child closes listening socket */
doit(connfd); /* process the request */
close(connfd); /* done with this client */
exit(0); /* child terminates */
}
close(connfd); /* parent closes connected socket */
}

Dr Qahhar Muhammad Qadir May 16, 2022 16 / 21

Processes, timeouts, and forks
Concurrent servers to handle multiple client
client server
connection listenfd
connect() request

Status of client/server before call to accept returns

client server
listenfd
connect() connection
connfd

Status of client/server after return from accept

client server (parent)

connection listenfd
connect()
connfd
fork
server (child)
listenfd

connfd

Status of client/server after fork returns

client server (parent)
listenfd
connect()

connection server (child)

connfd

Status Qadir
Dr Qahhar Muhammad of client/server after parent and child close appropriate sockets May 16, 2022 17 / 21
Processes, timeouts, and forks
Zombies and terminating children

Zombies are child processes that occur when the parent process exits
without calling wait or waitpid on the child process
The kernel keeps the exit information for these child processes until
the parent process call these functions
When children created by fork, the kernel expects the parent to
exectute waitpid for each child process
A way to handle zombies is to send the SIGCHLD signal to the parent
and calling waitpid when the child terminates.

Dr Qahhar Muhammad Qadir May 16, 2022 18 / 21

Processes, timeouts, and forks
How to handle zombies

void sigchld_handler(int signo)

{
while(waitpid(-1,NULL,WNOHANG)>0);
}
..........
struct sigaction sa;
sa.sa_handler = sigchld_handler;
sigaction(SIGCHLD, &sa, NULL);
while(1) {
..........
}

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

waitpid suspends execution of the calling process until a child

specified by pid argument has changed state
on success, returns the process ID of the child; if WNOHANG was
specified and one or more child(ren) specified by pid exist, but have
not yet changed state, then 0 is returned. On error, -1 is returned.

Dr Qahhar Muhammad Qadir May 16, 2022 19 / 21

Processes, timeouts, and forks
fork

The overall structure of the server is like so:

struct sigaction sa;
sa.sa_handler = sigchld_handler;
sigaction(SIGCHLD, &sa, NULL);
while(1) {
addrlen = sizeof(client_address);
rcvcount = recvfrom(socket1,&buf,MAXBUF,0,(struct sockaddr*)&
.........
if (fork()==0) {
close(socket1);
server_address.sin_family = AF_INET;
server_address.sin_addr.s_addr = INADDR_ANY;
udpnet_open_ser(&socket2, "0", &server_address, NULL, buf
...... only the child in here -- it handles a request
close (socket2);
exit(0);
} else {
}
} //Muhammad
Dr Qahhar end ofQadir
infinite loop May 16, 2022 20 / 21
Processes, timeouts, and forks
ports and calls to bind

When using UDP, the socket is fully identified by the port. Since the
server is communicating with several clients at once, each one must use a
different port. (This is not necessary in TCP, because the several sockets
can use the same port on the server.)
The main process must use the “well-known port”;
Each child process in the server gets a new port from the OS;
The client must switch to using the new port at the server;
it finds out what this new port is from the address stored in the first
reply.

Dr Qahhar Muhammad Qadir May 16, 2022 21 / 21