EmbLogic » Parampreet Singh

Difference between Kmalloc() and Vmalloc()

Parampreet Singh — Sat, 24 Oct 2015 10:52:51 +0000

In order to allocate memory from kernel various types of API(application programming interfaces) are used.Two such API’s are Kmalloc() and Vmalloc().

SYNTAX:

void * kmalloc(size_t size , int flags);

void * vmalloc(unsigned long size);

Kmalloc() is use to allocate memory requested from the kernel.The memory allocated is returned by the API and it is physically as well virtually contiguous.Generally we need this physically contiguous memory when we have to implement some driver which will be used to interface some hardware or device.In kmalloc we can define the size,how much memory is needed and also we can give flags as GFP_ATOMIC and GFP_KERNEL.GFP_ATOMIC means get free pages from kernel in atomic fashion means the allocation will never sleep in between and the priority is also highest.This is generally used in interrupt handlers,and in those situation where sleep is not permitted as in the case with spinlocks.Another flag is GFP_KERNEL means get free pages from kernel,here sleep is allowed and it is normal allocation.The major disadvantage of kmalloc is that in certain cases when not enough physical memory is present,the API will return error usually NULL is returned and wastage of memory is there.There are other flags also GFP_WAIT,GFP_MASK depending on various features and requirements.The defintion of kmalloc is usually found in header file.

Vmalloc() is used to allocate memory from the kernel.The memory allocated is virtually contiguous but not physically contiguous.This API works in the similar manner as the user level malloc() works.It means vmalloc ensures memory is allocated from vitual address space.In vmalloc there is no option to define flag.We can give the amount of size we required in the argument.The user will not be able to distinguish the difference in memory allocated by vmalloc and kmalloc since it will be virtually contiguous but in real manner at the backend that memory will be in chunks /blocks.Every page table of the block will be having details of the another page table linked to it.If not enough memory is available then NULL will be returned.we can find vmalloc in header file.The major advantage of vmalloc is that if enough physical contiguous memory is not available then it will allocate memory virtually in chunks and will link that memory so it appears to be virtually contiguous.

POSIX THREADS: BRIEF INTRODUCTION

Parampreet Singh — Tue, 12 May 2015 12:14:04 +0000

Threads,Like processes are a mechanism to allow a program to do more than one thing at a time.As with processes,threads appear to run concurrently;the linux kernel schedules them asynchronously,interrupting each thread from time to time to give others a chance to execute.We can control the threads using various mechanism which we will discuss later.

Conceptually,a thread exists within a process.When we invoke a program,Linux creates a new process and in that process creates a single thread,which runs the program sequentially.That thread can create additional threads ; all these threads run the same program in the same process,but each thread may be executing a different part of the program at any given time.We can say sequence of execution is a thread.

When a program creates another thread,the creating and the created thread share the same memory space,file descriptors except a local stack is created for individual threads. If one thread changes the value of a variable ,for instance,the other thread subsequently will see the modified value.If one thread closes file descriptor the other threads may not be able to write or read to that file descriptor.If any thread inside a process calls one of the exec functions,all the other threads are ended(the new program may,of course create new threads).

The pthread_create() function creates a new thread.You can refer to man pages about pthread_create().We have to include header file .A call to pthread_create() returns immediately and the original thread continues executing the instructions following the call.Meanwhile , the new thread begins executing the thread function.Linux schedules both threads asynchronously.

Under normal circumstances, a thread exits in one othe two ways.One way is by returning from the thread function.The return value from the thread function is taken to the return value of the thread.Alternatively,a thread can exit explicitly by calling pthread_exit().This function may be called form within the thread function.The argument to pthread_exit() is the thread’s return value.

We can retrieve the thread exit status using pthread_join().The pthread_join() function shall suspend execution of the calling thread until the target thread terminates, unless the target thread has already terminated. On return from a successful pthread_join(), the value passed to pthread_exit() by the terminating thread shall be made available in the location referenced to pthread_join().When a pthread_join() returns successfully, the target thread has been terminated.

There are signals to control the threads.The pthread_kill() function requests that the signal to be delivered to the specified thread. The signal to be sent is specified by signal number and is either zero or one of the signals from the list of defined signals in the header file. If signal number is zero, error checking is performed, but no signal is sent to the target thread.

It returns 0 on success and a non zero value if pthread_kill() is unsuccessful.That non zero value is to check the error condition.One thing has to be made sure that the signal registration should be done in both the threads i.e the thread which is giving the signal and the target thread which will be killed.

P.S: Refer to man pages related to the arguments and the return values of the functions listed above.

Initializing a driver using alloc_chrdev_region()

Parampreet Singh — Sat, 25 Apr 2015 10:18:50 +0000

RCS file: header.h,v
Working file: header.h
head: 1.10
branch:
locks: strict
access list:
symbolic names:
keyword substitution: kv
total revisions: 10; selected revisions: 10
description:
this is header file

here various header files are included such as module param.h init.h cdev.h slab.h and many others
—————————
revision 1.10
date: 2015/04/24 12:36:40; author: psingh; state: Exp; lines: +1

Here module author,module licence and module description is defined

—————————

RCS file: declaration.h,v
Working file: declaration.h
head: 1.6
branch:
locks: strict
access list:
symbolic names:
keyword substitution: kv
total revisions: 6; selected revisions: 6
description:
—————————-
revision 1.6
date: 2015/04/25 00:38:02; author: psingh; state: Exp; lines: +6 -6
This is declaration.h…
here declaration of struct qset is defined
here declaration of struct Dev is also defined
and a structure variable of type Dev is also defined which contains the element *qset and predefined structure cdev as mentioned in cdev.h…

============================================================================

RCS file: fopr.h,v
Working file: fopr.h
head: 1.1
branch:
locks: strict
access list:
symbolic names:
keyword substitution: kv
total revisions: 1; selected revisions: 1
description:
—————————-
revision 1.1
date: 2015/04/25 00:38:05; author: psingh; state: Exp;
Initial revision
Here file operation structure is taken and declared as extern…
=============================================================================

RCS file: init.c,v
Working file: init.c
head: 1.2
branch:
locks: strict
access list:
symbolic names:
keyword substitution: kv
total revisions: 2; selected revisions: 2

date: 2015/04/24 10:54:2; author: psingh; state: Exp; lines: +1 -1
Here initalization of module is done using alloc_chrdev_region
after that memory will be allocated by kernel using kmalloc()
—————————
revision 1.6
date: 2015/04/24 10:53:1; author: psingh; state: Exp; lines: +4 -5
cdev structure is initialized and its memory is made NULL by using memset
after that cdev owner and file operation is declared and the addition of device table is done using cdev_add()

————————
=============================================================================

RCS file: clean.c,v
Working file: clean.c
head: 1.2
branch:p
locks: strict
access list:
symbolic names:
keyword substitution: kv
total revisions: 2; selected revisions: 2
description:
this is cleanup function

revision 1.2
date: 2015/04/24 10:36:12; author: psingh; state: Exp; lines: +3 -1
first cdev_del will remove the device table from the driver module
after that kfree will free the memory allocated to the structure pointer as defined to the strcut Dev..
then unregisteration of the module will be carried by using unregister_chrdev_region

—————————-
revision 1.1
date: 2015/04/24 10:12:13; author: psingh; state: Exp;
Initial revision
=============================================================================

Interprocess communication using message queues at the requesting side and shared memory at the processing side with three clients successfully implemented.

Parampreet Singh — Tue, 07 Apr 2015 16:42:15 +0000

RCS file: header.h,v
Working file: header.h
head:
branch:
locks: strict
access list:
symbolic names:
keyword substitution: kv
total revisions: 0
description:
>> header file: contains header files which are required in the program mostly named stdio.h,sys/shm.h,sys/ipc.h,sys/types.h,sys/msg.h
=============================================================================

RCS file: server.c,v
Working file: server.c
head:
branch:
locks: strict
access list:
symbolic names:
keyword substitution: kv
total revisions: 0
description:
this is main server..
here request is recieved using message queues
request is written to the shared memory
result is fetched back from the shared memory
and then result is sent back to the requesting clients using message queues.
=============================================================================

RCS file: c1.c,v
Working file: c1.c
head:
branch:
locks: strict
access list:
symbolic names:
keyword substitution: kv
total revisions: 0
description:
this is requesting client contains request for the add operation
the request is sent to the server using message queues
and the result is recieved back from the server using message queues
=============================================================================

RCS file: c2.c,v
Working file: c2.c
head:
branch:
locks: strict
access list:
symbolic names:
keyword substitution: kv
total revisions: 0
description:
this is requesting client contains request for the multiply operation
the request is sent to the server using message queues
and the result is recieved back from the server using message queues
=============================================================================

RCS file: c3.c,v
Working file: c3.c
head:
branch:
locks: strict
access list:
symbolic names:
keyword substitution: kv
total revisions: 0
description:
this is requesting client contains request for the subtraction operation
the request sent to the server using message queues
and the result is recieved back from the server using message queues
=============================================================================

RCS file: p1.c,v
Working file: p1.c
head:
branch:
locks: strict
access list:
symbolic names:
keyword substitution: kv
total revisions: 0
description:
this is processing client..here adding operation is performed..
request is retrieved using shared memory
and result is written back to the shared memory
=============================================================================

RCS file: p2.c,v
Working file: p2.c
head:
branch:
locks: strict
access list:
symbolic names:
keyword substitution: kv
total revisions: 0
description:
second processing client..here subtraction operation is performed
request is retrieved using shared memory
and result is written back to the shared memory
,
=============================================================================

RCS file: p3.c,v
Working file: p3.c
head:
branch:
locks: strict
access list:
symbolic names:
keyword substitution: kv
total revisions: 0
description:
this is third processing client ..here multiplication operation is performed
request is retrieved using shared memory
and result is written back to the shared memory
=============================================================================

Inter process communication using message queues with three requesting clients and three processing clients implemented successfully

Parampreet Singh — Sun, 05 Apr 2015 01:45:46 +0000

RCS file: header.h,v
Working file: header.h
head: 1.1
branch:
locks: strict
psingh: 1.1
access list:
symbolic names:
keyword substitution: kv
total revisions: 1; selected revisions: 1
description:
define header files thar are required for the implementation of message queues at the requesting side and pipes at the processing side
gave prototype for the request strcture
gave prototype for the block of data that has to be sent to server via message queues
gave prototype for the result structure that has to be captured by requesting client from server side via meaasge queues
gave prototype for the functions used for invoking the processing clients.
—————————-
revision 1.1 locked by: psingh;
date: 2015/04/05 01:44:07; author: psingh; state: Exp;
Initial revision
=============================================================================

RCS file: c1.c,v
Working file: c1.c
head: 1.1
branch:
locks: strict
psingh: 1.1
access list:
symbolic names:
keyword substitution: kv
total revisions: 1; selected revisions: 1
description:
here request for addition is present that has to be sent to server via message queues
and result is captured via another message queue
—————————-
revision 1.1 locked by: psingh;
date: 2015/04/05 01:44:07; author: psingh; state: Exp;
Initial revision
=============================================================================

RCS file: c2.c,v
Working file: c2.c
head: 1.1
branch:
locks: strict
psingh: 1.1
access list:
symbolic names:
keyword substitution: kv
total revisions: 1; selected revisions: 1
description:
here request for subtraction is present that has to be sent to server via message queues
and result is captured via another message queues
—————————-
revision 1.1 locked by: psingh;
date: 2015/04/05 01:44:07; author: psingh; state: Exp;
Initial revision
=============================================================================

RCS file: c3.c,v
Working file: c3.c
head: 1.1
branch:
locks: strict
psingh: 1.1
access list:
symbolic names:
keyword substitution: kv
total revisions: 1; selected revisions: 1
description:
here request for multiplication is present that has to be sent to server via message queues
and result is captured via another message queue
—————————-
revision 1.1 locked by: psingh;
date: 2015/04/05 01:44:07; author: psingh; state: Exp;
Initial revision
=============================================================================

RCS file: p1.c,v
Working file: p1.c
head: 1.1
branch:
locks: strict
psingh: 1.1
access list:
symbolic names:
keyword substitution: kv
total revisions: 1; selected revisions: 1
description:
here addition operation is performed on the request sent by the server via pipe and then the result is transferred back to the server via pipe using signals.
—————————-
revision 1.1 locked by: psingh;
date: 2015/04/05 01:44:07; author: psingh; state: Exp;
Initial revision
=============================================================================

RCS file: p2.c,v
Working file: p2.c
head: 1.1
branch:
locks: strict
psingh: 1.1
access list:
symbolic names:
keyword substitution: kv
total revisions: 1; selected revisions: 1
description:
here subtraction operation is performed on the request sent by the server via pipe and then the result is transferred back to the server via pipe using signals
—————————-
revision 1.1 locked by: psingh;
date: 2015/04/05 01:44:07; author: psingh; state: Exp;
Initial revision
=============================================================================

RCS file: p3.c,v
Working file: p3.c
head: 1.1
branch:
locks: strict
psingh: 1.1
access list:
symbolic names:
keyword substitution: kv
total revisions: 1; selected revisions: 1
description:
here multiplication operation is performed on the request sent bye the server via pipe and then the result is transferred back to the to the server via pipe using signals
—————————-
revision 1.1 locked by: psingh;
date: 2015/04/05 01:44:07; author: psingh; state: Exp;
Initial revision
=============================================================================

Inter process communication using fifo at the requesting side and pipes at the processing side using semaphores and signals.

Parampreet Singh — Sat, 04 Apr 2015 04:52:45 +0000

RCS file: header.h,v
Working file: header.h
head: 1.1
branch:
locks: strict
psingh: 1.1
access list:
symbolic names:
keyword substitution: kv
total revisions: 1; selected revisions: 1
description:
gave header files which are required for the fifo and semaphore implementation.
gave prototypes for the request structure
gave prototype for the semaphore union
gave prototypes for the invoke_process functions
—————————-
revision 1.1 locked by: psingh;
date: 2015/04/03 18:51:58; author: psingh; state: Exp;
Initial revision
=============================================================================

RCS file: c1.c,v
Working file: c1.c
head: 1.1
branch:
locks: strict
psingh: 1.1
access list:
symbolic names:
keyword substitution: kv
total revisions: 1; selected revisions: 1
description:
thi is first requesting client
here request for addition is sent to the server side
including semaphores and signals
request has been sent through the fifo to the server
—————————-
revision 1.1 locked by: psingh;
date: 2015/04/03 18:51:58; author: psingh; state: Exp;
Initial revision
=============================================================================

RCS file: c2.c,v
Working file: c2.c
head: 1.1
branch:
locks: strict
psingh: 1.1
access list:
symbolic names:
keyword substitution: kv
total revisions: 1; selected revisions: 1
description:
this is second requesting client
here request for subtraction sent to server side
using semaphores and signals
request sent through fifo
result read through another fifo
—————————-
revision 1.1 locked by: psingh;
date: 2015/04/03 18:51:58; author: psingh; state: Exp;
Initial revision
=============================================================================

RCS file: c3.c,v
Working file: c3.c
head: 1.1
branch:
locks: strict
psingh: 1.1
access list:
symbolic names:
keyword substitution: kv
total revisions: 1; selected revisions: 1
description:
this is third requesting client
here request for multiplication sent thorugh fifo to the server side
using semaphores and signals
result read through another fifo from the server’s end
—————————-
revision 1.1 locked by: psingh;
date: 2015/04/03 18:51:58; author: psingh; state: Exp;
Initial revision
=============================================================================

RCS file: p1.c,v
Working file: p1.c
head: 1.1
branch:
locks: strict
psingh: 1.1
access list:
symbolic names:
keyword substitution: kv
total revisions: 1; selected revisions: 1
description:
this is the processing client
here addition operation is performed on the request sent by the requesting client
result is send through the pipe to the servers end using signals
—————————-
revision 1.1 locked by: psingh;
date: 2015/04/03 18:51:58; author: psingh; state: Exp;
Initial revision
=============================================================================

RCS file: p2.c,v
Working file: p2.c
head: 1.1
branch:
locks: strict
psingh: 1.1
access list:
symbolic names:
keyword substitution: kv
total revisions: 1; selected revisions: 1
description:
this is the second processing client
here subtraction operation is performed on the request sent by the requesting client
result is sent back to the server’s end using pipes and signals
—————————-
revision 1.1 locked by: psingh;
date: 2015/04/03 18:51:58; author: psingh; state: Exp;
Initial revision
=============================================================================

RCS file: p3.c,v
Working file: p3.c
head: 1.1
branch:
locks: strict
psingh: 1.1
access list:
symbolic names:
keyword substitution: kv
total revisions: 1; selected revisions: 1
description:
this is third processing client
here operation of multiplication is performed on the request sent by the requsting client
result is sent back to the server using pipes and signals
—————————-
revision 1.1 locked by: psingh;
date: 2015/04/03 18:51:58; author: psingh; state: Exp;
Initial revision
=============================================================================

Project 03: Client Server implementation using PIPES

Parampreet Singh — Thu, 05 Mar 2015 00:21:20 +0000

Here i have used 3 requesting clients and 3 processing clients.
RCS file: header1.h,v
Working file: header1.h
head:
branch:
locks: strict
access list:
symbolic names:
keyword substitution: kv
total revisions: 0
description:
this is the header file.it contains library which are required by programs
contains prototype for functions and structures
=============================================================================
RCS file: server.c,v
Working file: server.c
head: 1.1
branch:
locks: strict
root: 1.1
access list:
symbolic names:
keyword substitution: kv
total revisions: 1; selected revisions: 1
description:
this is the server program..here i have created six pipes.
3 each for requesting clients and 3 for processing clients
requesting client will send request to the server and server then transfer the info to the processing clients
processing clients will process that info and send back to the server
server will then transfer the info back to the requesting clients
i have implemented the server program using functions
—————————-
revision 1.1 locked by: root;
date: 2015/03/05 00:08:19; author: root; state: Exp;
Initial revision
=============================================================================

RCS file: request_client.c,v
Working file: request_client.c
head: 1.1
branch:
locks: strict
root: 1.1
access list:
symbolic names:
keyword substitution: kv
total revisions: 1; selected revisions: 1
description:
this is the first requesting client.
Sending request for the addtion.
—————————-
revision 1.1 locked by: root;
date: 2015/03/05 00:08:11; author: root; state: Exp;
Initial revision
=============================================================================

RCS file: request_client_mul.c,v
Working file: request_client_mul.c
head: 1.1
branch:
locks: strict
root: 1.1
access list:
symbolic names:
keyword substitution: kv
total revisions: 1; selected revisions: 1
description:
this is second requesting client
sending request for the multiplication.
—————————-
revision 1.1 locked by: root;
date: 2015/03/05 00:08:19; author: root; state: Exp;
Initial revision
=============================================================================

RCS file: request_client_sub.c,v
Working file: request_client_sub.c
head: 1.1
branch:
locks: strict
root: 1.1
access list:
symbolic names:
keyword substitution: kv
total revisions: 1; selected revisions: 1
description:
this is the third requesting client
sending request for the subtraction
—————————-
revision 1.1 locked by: root;
date: 2015/03/05 00:08:19; author: root; state: Exp;
Initial revision
=============================================================================

RCS file: adder.c,v
Working file: adder.c
head: 1.1
branch:
locks: strict
root: 1.1
access list:
symbolic names:
keyword substitution: kv
total revisions: 1; selected revisions: 1
description:
this is first processing client
here arithmetic operation”ADDITION” is performed
—————————-
revision 1.1 locked by: root;
date: 2015/03/05 00:08:19; author: root; state: Exp;
Initial revision
=============================================================================

RCS file: mul.c,v
Working file: mul.c
head: 1.1
branch:
locks: strict
root: 1.1
access list:
symbolic names:
keyword substitution: kv
total revisions: 1; selected revisions: 1
description:
this is the second processing client
here arithmetic operation “MULTIPLICATION” is performed.
—————————-
revision 1.1 locked by: root;
date: 2015/03/05 00:08:19; author: root; state: Exp;
Initial revision
=============================================================================

RCS file: sub.c,v
Working file: sub.c
head: 1.1
branch:
locks: strict
root: 1.1
access list:
symbolic names:
keyword substitution: kv
total revisions: 1; selected revisions: 1
description:
this is the third processing client.
Here arithmetic operation “SUBTRACTION” is performed.
—————————-
revision 1.1 locked by: root;
date: 2015/03/05 00:08:19; author: root; state: Exp;
Initial revision
=============================================================================

Inter Process Communication Using Pipes:

Parampreet Singh — Sat, 28 Feb 2015 10:10:48 +0000

RCS file: header.h,v
Working file: header.h
head: 1.1
branch:
locks: strict
root: 1.1
access list:
symbolic names:
keyword substitution: kv
total revisions: 1; selected revisions: 1
description:
this includes header files
different libraries used in our program
structure is also defined here,to be used in the main as well as execl initiated program.
—————————-
revision 1.1 locked by: root;
date: 2015/02/27 17:08:22; author: root; state: Exp;
Initial revision
=============================================================================

RCS file: main.c,v
Working file: main.c
head: 1.2
branch:
locks: strict
root: 1.2
access list:
symbolic names:
keyword substitution: kv
total revisions: 2; selected revisions: 2
description:
pipes are used to create a inter process communication
two file descriptors are created.one for read and other for write.
—————————-
revision 1.2 locked by: root;
date: 2015/02/27 17:28:11; author: root; state: Exp; lines: +3 -3
this is the main program we have initiated a execl program call
we have taken data from the user end and write it into another process.
—————————-
revision 1.1
date: 2015/02/27 17:08:22; author: root; state: Exp;
Initial revision
=============================================================================

RCS file: new.c,v
Working file: new.c
head: 1.1
branch:
locks: strict
root: 1.1
access list:
symbolic names:
keyword substitution: kv
total revisions: 1; selected revisions: 1
description:
here arithmetic operations are performed
we have used switch statements
—————————-
revision 1.1 locked by: root;
date: 2015/02/27 17:12:18; author: root; state: Exp;
Initial revision
=============================================================================

RCS file: new.c,v
Working file: new.c
head:
branch:
locks: strict
access list:
symbolic names:
keyword substitution: kv
total revisions: 0
description:
=============================================================================

RCS file: header.h,v
Working file: header.h
head: 1.1
branch:
locks: strict
root: 1.1
access list:
symbolic names:
keyword substitution: kv
total revisions: 1; selected revisions: 1
description:
this includes header files
different libraries used in our program
—————————-
revision 1.1 locked by: root;
date: 2015/02/27 17:08:22; author: root; state: Exp;
Initial revision
=============================================================================

RCS file: main.c,v
Working file: main.c
head: 1.2
branch:
locks: strict
root: 1.2
access list:
symbolic names:
keyword substitution: kv
total revisions: 2; selected revisions: 2
description:
this is the main program we have initaiated a execl program call
we have taken data from the user end and write it into another process.
—————————-
revision 1.2 locked by: root;
date: 2015/02/27 17:28:11; author: root; state: Exp; lines: +3 -3
*** empty log message ***
—————————-
revision 1.1
date: 2015/02/27 17:08:22; author: root; state: Exp;
Initial revision
=============================================================================

RCS file: new.c,v
Working file: new.c
head: 1.9
branch:
locks: strict
root: 1.9
access list:
symbolic names:
keyword substitution: kv
total revisions: 9; selected revisions: 9
description:
here result is calculated.
—————————-
revision 1.3 locked by: root;
date: 2015/02/27 18:16:21; author: root; state: Exp; lines: +1 -1
result is transferred to the main program.
—————————-
revision 1.2
date: 2015/02/27 18:14:02; author: root; state: Exp; lines: +1 -1
error resolved
—————————-
revision 1.1
date: 2015/02/27 17:57:28; author: root; state: Exp;
Initial revision
=============================================================================

Inter Process Communication using files:

Parampreet Singh — Sat, 28 Feb 2015 04:45:30 +0000

RCS file: header.h,v
Working file: header.h
head: 1.1
branch:
locks: strict
root: 1.1
access list:
symbolic names:
keyword substitution: kv
total revisions: 1; selected revisions: 1
description:
this is header file
this file includes the standard libraries required in the program.
—————————-
revision 1.1 locked by: root;
date: 2015/02/27 04:43:41; author: root; state: Exp;
Initial revision
=============================================================================

RCS file: replace1.c,v
Working file: replace1.c
head: 1.4
branch:
locks: strict
root: 1.4
access list:
symbolic names:
keyword substitution: kv
total revisions: 4; selected revisions: 4
description:
this is main file
in this program we have initiated a call using execl function
—————————-
revision 1.4 locked by: root;
date: 2015/02/27 15:27:16; author: root; state: Exp; lines: +1 -1
first converting the integer to the character type
since execl takes char* as a argument.
—————————-
revision 1.3
date: 2015/02/27 15:25:30; author: root; state: Exp; lines: +2 -3
sending data to the new program initiated by execl
—————————-
revision 1.2
date: 2015/02/27 05:27:27; author: root; state: Exp; lines: +5 -5
reading back the values send by execl initiated program
output is displayed.
—————————-
revision 1.1
date: 2015/02/27 04:43:41; author: root; state: Exp;
Initial revision
=============================================================================

RCS file: new1.c,v
Working file: new1.c
head: 1.3
branch:
locks: strict
root: 1.3
access list:
symbolic names:
keyword substitution: kv
total revisions: 3; selected revisions: 3
description:
this is called by execl
—————————-
revision 1.3 locked by: root;
date: 2015/02/27 05:27:31; author: root; state: Exp; lines: +1 -1
here we have used command line arguments to collect the char* values
then these values converted to integer type using atoi()
—————————-
revision 1.2
date: 2015/02/27 04:58:29; author: root; state: Exp; lines: +1 -1
reading the values transmitted by the main program
and writting the results back to the main program.
—————————-
revision 1.1
date: 2015/02/27 04:43:41; author: root; state: Exp;
Initial revision
=============================================================================