Unix processes

UNIX PROCESSES
1
Sunil Kumar R.M Assistant Professor
RLJIT

2
RLJIT

MAIN FUNCTION
 PROTOTYPE:
int main(int argc, char *argv[ ]);
Argc – is the number of command line
arguments
argv [ ] – is an array of pointers to the
arguments
3
RLJIT

 A C program is started by a kernel
 A special start up routine is called before
the main function is called
 This start up routine takes values from the
kernel and sets things up so that the main
function is called
4
RLJIT

Process termination
 Normal termination
* return from main
* calling exit
* calling _exit
 Abnormal termination
* calling abort
* terminated by a signal
5
RLJIT

exit and _exit functions
 _exit returns to kernel immediately
 exit performs certain cleanup processing
and then returns to kernel
 PROTOTYPE
#include <stdlib.h>
void _exit (int status)
void exit (int status)
6
RLJIT

 The exit status is undefined if
1. Either of these function is called without
an exit status
2. Main does a return without a return value
3. Main “falls of the end”
7
RLJIT

At exit function
 With ANSI C a process can register up to
32 functions that are called by exit ---called
exit handlers
 Exit handlers are registered by calling the
atexit function
#include <stdlib.h>
Int atexit (void (*clearfun) void));
8
RLJIT

 Atexit function calls these functions in
reverse order of their registration
 Each function is called as many times as
it was registered
9
RLJIT

#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");
printf("main is donen");
return(0);
}
10
RLJIT

static void
my_exit1(void)
{
printf("first exit handlern");
}
static void
my_exit2(void)
{
printf("second exit handlern");
}
11
RLJIT

Command-line arguments
 /* program to echo command line
arguments*/
int main (int argc, char* argv[ ])
{
for(int i=0;i<argc ;i++)
{
printf(“argv[%d]:%s n”,i,argv[i]);
}
}
12
RLJIT

Environment list
 Environment list – is an array of character
pointers ,where each pointer contains the
address of a null terminated C string
 The address of array of pointers is
contained in global variable environ
 extern char **environ;
 each string is of the form name=value
13
RLJIT

NULL
HOME=/home/abc
PATH=:/bin:/usr/bin0
Environment
pointer
Environment
list
14
RLJIT

Memory layout of a C program
 Text segment – sharable copy
 Initialized data segment – variables
specifically initialized in the program
 Uninitialized data segment – “bss”
segment
data is initialized to arithematic 0 or null
 Stack – return address and information
about caller’s environment
 Heap – dynamic memory allocation takes
place on the heap
15
RLJIT

Stack
heap
Uninitialised data
initialised data
Text
Command line arguments
And environment variables
Intialized to 0 by exec
Read from
prog File
by exec
High address
Low address
16
RLJIT

The size(1) command reports
the sizes (in bytes) of the text,
data, and bss segments#include <stdio.h>
int main(void)
{
return 0;
}
.
17
RLJIT

Shared libraries
 Shared libraries remove the common
library routines from the executable file ,
instead maintaining a single copy of the
library routine some where in memory
that all processes reference
 Advantage: reduces size of executable
file,
easy to replace with a newer version
 Disadvantage: some- runtime overhead
18
RLJIT

 Linking: Here is where all of the object files and
any libraries are linked together to make your
final program. Note that for static libraries, the
actual library is placed in your final program,
while for shared libraries, only a reference to the
library is placed inside.
19
RLJIT

20
RLJIT

Memory allocation
 malloc : allocates specified number of
bytes of memory
 calloc : allocates specified number of
objects of specified size
 realloc : changes size of previous
allocated area
21
RLJIT

#include <stdlib.h>
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 the
size of previously allocated area .If it
decreases the size no problem occurs
But if the size increases then………….
22
RLJIT

1. Either there is enough space then the
memory is reallocated and the same
pointer is returned
2. If there is no space then it allocates new
area copies the contents of old area to
new area frees the old area and returns
pointer to the new area
23
RLJIT

Alloca function
 It is same as malloc but instead of
allocating memory from heap, the memory
allocated from the stack frame of the
current function
24
RLJIT

Environment variables
 Environment strings are of the form
name=value
 ANSI C defined functions
#include <stdlib.h>
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);
25
RLJIT

 Getenv : fetches a specific value from the
environment
 Putenv : takes a string of the form
name=value , if it already exists then
old value is removed
 Setenv : sets name to value. If name
already exists then a) if rewrite is non zero,
then old definition is removed
b) if rewrite is zero old definition is
retained
 Unsetenv : removes any definition of name
26
RLJIT

 Removing an environment variable is
simple just find the pointer and move all
subsequent pointers down one
 But while modifying
* if size of new value<=size of old value
just copy new string over the old string
* if new value >oldvalue use malloc obtain
room for new string, replace the old
pointer in environment list for name
with pointer to this malloced area
27
RLJIT

 While adding a new name call malloc
allocate room for name=value string and
copy the string to this area
 If it’s the first time a new name is added ,
use malloc to obtain area for new list of
pointers. Copy the old list of pointers to
the malloced area and add the new
pointer to its end
 If its not the first time a new name was
added ,then just reallocate area for new
pointer since the list is already on the
heap
28
RLJIT

Set jump and long jump
 To transfer control from one function to
another we make use of setjmp and
longjmp functions
#include <stdio.h>
int setjmp (jmp_buf env);
void longjmp (jmp_buf env, int val);
29
RLJIT

 env is of type jmp_buf ,this data type is
form of array that is capable of holding all
information required to restore the status
of the stack to the state when we call
longjmp
 Val allows us to have more than one
longjmp for one setjmp
30
RLJIT

#include <stdio.h>
#include <stdlib.h>
#include <setjmp.h>
int main()
{ int val;
jmp_buf env_buffer; /* save calling environment
for longjmp */
val = setjmp( env_buffer );
if( val != 0 )
{ printf("Returned from a longjmp() with value =
%sn", val); exit(0); }
31
RLJIT

 printf("Jump function calln");
jmpfunction( env_buffer );
return(0); }
void jmpfunction(jmp_buf env_buf)
{ longjmp(env_buf, “RLJITCSE"); }
Output:
Jump function call
Returned from a longjmp()
with value = RLJITCSE 32
RLJIT

getrlimit and setrlimit
#include <sys/time.h>
#include <sys/resource.h>
int getrlimit (int resource ,struct
rlimit *rlptr);
int setrlimit (int resource ,const struct
rlimit *rlptr);
33
RLJIT

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 <= to its hard limit
2. Any process can lower its hard limit to a
value greater than or equal to its soft
limit
3. Only super user can raise hard limit
34
RLJIT

 RLIMIT_CORE – max size in bytes of a
core file
 RLIMIT_CPU – max amount of CPU time in
seconds
 RLIMIT_DATA – max size in bytes of data
segment
 RLIMIT_FSIZE – max size in bytes of a file
that can be created
 RLIMIT_MEMLOCK – locked in-memory
address space
35
RLJIT

 RLIMIT_NOFILE – max number of open
files per process
 RLIMIT_NPROC – max number of child
process per real user ID
 RLIMIT_OFILE – same as RLIMIT_NOFILE
 RLIMIT_RSS – max resident set size in
bytes
 RLIMIT_STACK – max size in bytes of the
stack
 RLIMIT_VMEM – max size in bytes of the
mapped address space
36
RLJIT

#include <sys/types.h>
#include <sys/time.h>
#include <sys/resource.h>
#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);
37
RLJIT

#ifdef RLIMIT_MEMLOCK
doit (RLIMIT_MEMLOCK);
#endif
#ifdef RLIMIT_NOFILE /* SVR4 name */
doit (RLIMIT_NOFILE);
#endif
#ifdef RLIMIT_OFILE /* 44BSD name */
doit (RLIMIT_OFILE);
#endif
38
RLJIT

#ifdef RLIMIT_NPROC
doit (RLIMIT_NPROC);
#endif
#ifdef RLIMIT_RSS
doit(RLIMIT_RSS);
#endif
doit(RLIMIT_STACK);
#ifdef RLIMIT_VMEM
doit(RLIMIT_VMEM);
#endif
exit(0);
}
39
RLJIT

static void
pr_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) ");
40
RLJIT

else
printf("%10ld ", limit.rlim_cur);
if (limit.rlim_max == RLIM_INFINITY)
printf("(infinite)n");
else
printf("%10ldn", limit.rlim_max);
}
41
RLJIT

Kernel support for processes

File descriptor table
Current directory
root
text
data
stack
Per process u-area
Per process region table
Kernel region table
Process table
42
RLJIT

 A process consists of
 A text segment – program text of a
process in machine executable
instruction code format
 A data segment – static and global
variables in machine executable format
 A stack segment – function arguments,
automatic variables and return addresses
of all active functions of a process at any
time
 U-area is an extension of Process table
entry and contains process-specific data
43
RLJIT


Fd table
stack
data
text
stack
data
File tableparent
child
Process table
Kernel region table
Fd table
44
RLJIT

Besides open files the other properties
inherited by child are
 Real user ID, group ID, effective user ID,
effective group ID
 Supplementary group ID
 Process group ID
 Session ID
 Controlling terminal
 set-user-ID and set-group-ID
 Current working directory
45
RLJIT

 Root directory
 Signal handling
 Signal mask and dispositions
 Umask
 Nice value
 The difference between the parent & child
 The process ID
 Parent process ID
 File locks
 Alarms clock time
 Pending signals
46
RLJIT

Unix processes

More Related Content

What's hot (20)

Viewers also liked (15)

Similar to Unix processes (20)

Recently uploaded (20)

Unix processes