Process Concepts

1. 1) What happens when ./a.out is called from shell ?
It is fact that a process is always invoked by process itself(via fork() )
Initially we are in shell prompt.As we invoke ./a.out then what happens is :
shell internally forks implicitly.And child process is now responsible to
execute ./a.out
Parent process that is nothing but shell is waiting to collect return status
of child process.
So,What happens is the executable(./a.out) is copied (via exec ) in process
address space of child process.
./a.out
shell -> fork()
if( pid == 0)
{
// child process execute ./a.out
}
else
{
Wait(0);
// Parent is waiting for child to complete the process and collecting the
return status.
}
2) What Acutually happens in write system call ?
Here we have three working space :
=> User-Space
=> Kernel-Space
=> Disk-Space
so Assume scenario: char str[15] = "Hello";
fd = open("filename",o_WRONLY,S_IRWX);
write(fd,str,sizeof(str),1); // jst check syntax
So, Exact scene is like that :
================================================================================
================
User Space char str[15]
="HEllo";
|
====================================================================|
============================
# All system calls are invoked in kernel space only |
V-------------------
| |
| Temperory Buffer | |
|
| |-------------------|
|

2. |
Kernel Space Write call here
|
=====================================================================|
============================
|
finally written in file with fd descriptor:
V
Disk Space ( All permanent
storage like files
are
here only )
================================================================================
==================
So, str is first copied into temperory buffer in kernel space after that write
system call invoked then it copies that buffer
into file which is in Disk Space. ( Temperory Buffer is required because cpu
processing speed is quite faster that disk operation like writing and reading ..
so in order to synchronise disk opeartion speed the data is temperorily copied
in buffer.
################################################################################
###############################################3
Note:
Kernel keeps or recognize each and every entity whether process,thread,files,etc
by numeric number.
So,At kernal level we have only numeric information. So,There must be some
mapping data structures:
Exactly true: Data Structures at Kernel Level are :=>
===> File Descriptor Table or Proces Control Block(PCB)
Having information about file decriptor and corresponding file pointers
====> V-table
===> Inode-Table
Having complete information about file with it's inode number.
====> Directory Inode Table( Directory table)
Having information about file and it's inode number
e===>(1)
################################################################################
################################################
================================================================================
================================================
Note===>(2)
Process should not enter into address space of each other, otherwise it can
corrupt each -other segment. It can be deliberately allowed in case of shared
memory scenario.

3. The child process copies the exact copy of parent adresss space which was there
before fork(). After that both works in there independent address space. Copy of
address space include complete copies ( all stack,data segment,heap etc, file
descriptors,..)
================================================================================
================================================