Unit 4

UNIX SYSTEMS PROGRAMMING
Subject code: 06CS62
By
Kala.C.L
Lecturer, Dept of ISE
SJBIT, Bengaluru
UNIT-4
UNIX PROCESSES
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
 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
Process termination
 Normal termination
* return from main
* calling exit
* calling _exit
 Abnormal termination
* calling abort
* terminated by a signal
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)
 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”
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 (*fun) void));
 Atexit function calls these functions in
reverse order of their registration
 Each function is called as many times as

it was registered
#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 done\n");
return(0);
}
static void
my_exit1(void)
{
printf("first exit handler\n");
}
static void
my_exit2(void)
{
printf("second exit handler\n");
}
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]);
}
}
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
Environment
Environment list
pointer
HOME=/home/abc
PATH=:/bin:/usr/bin\0
NULL
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
High address
Command line arguments

Stack And environment variables
heap
Uninitialised data Intialized to 0 by exec
initialised data Read from

prog File
Text by exec
Low address
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
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
#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………….
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
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
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);
 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
 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 new value
just copy new string over the old string
* if new value >oldvalue use malloc obtain
room for new string, copy the new
string to this area and replace the old
pointer in environment list for name
with pointer to this malloced area
 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
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);
 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
#include <setjmp.h>
#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;
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 */
}
static void
f1(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);
}
 The state of automatic,register and
volatile variables after longjmp
 If compiled with optimization
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);
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
 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
 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
#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);
#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
#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);
}
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) ");
else
printf("%10ld ", limit.rlim_cur);
if (limit.rlim_max == RLIM_INFINITY)
printf("(infinite)\n");
else
printf("%10ld\n", limit.rlim_max);
}
Kernel support for processes
Kernel region table
Process table
Per process region table

text
File descriptor table data

Current directory
root stack
Per process u-area
 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
Kernel region table
Process table
stack
data
parent File table
text
Fd table
child
Fd table
stack
data
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

 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

Unit 4

Uploaded by

Copyright:

Available Formats

Unit 4

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Unit 4

Uploaded by

Copyright:

Available Formats

UNIX SYSTEMS PROGRAMMING

Subject code: 06CS62

Argc – is the number of command line

 A special start up routine is called before

 This start up routine takes values from the

 _exit returns to kernel immediately

1. Either of these function is called without

 With ANSI C a process can register up to

 Each function is called as many times as

 Environment list – is an array of character

Command line arguments

initialised data Read from

 malloc : allocates specified number of

realloc may increase or decrease the

 It is same as malloc but instead of

 To transfer control from one function to

 Val allows us to have more than one

static void f1(int, int, int);

static jmp_buf jmpbuffer;

Per process region table

File descriptor table data

 set-user-ID and set-group-ID

 Current working directory

You might also like