Inter process Communication in Linux Kernel (IPC)

When two processes trying to access a resource is called race condition.

Main challenge is to avoid the race condition, the following method is usually adopted to avoid the race condition

use of shared memory can prevent race condition
Use of threads. Threads use the same address space when switching it to other threads(so same page directories and tables), whereas processes uses different address which leads to exchange of page directories and page tables. This is made with the help of POSIX Threads.

Forms of IPC

Linux implements all forms of IPC

Synchronization in the Kernel

When multiple processors are used, how each processor is synchronized in the kernel is what described in this section.

Processor can acquire a spinlock whenever it wanted to access a resource.

typedef struct

{

volatile unsigned int lock; //default value is 1

}spinlock_t;

whenever a lock is wanted, it is set to 0 and during unlock it is set to 1
the bus access to the other processors are blocked during the processing of this command (spinlock)
if spinlock cannot be set, the processor waits in a loop until a lock variable is released again.
single processor do not need spinlock

Other than spinlock, there is one more lock called the Read write lock

typedef struct

{

volatile unsigned int lock;

}rwlock_t;

Semaphore

struct semaphore

{

atomic_t count;

int sleepers;

wait_queue_head_t *wait;

};

The word count is declared with the type atomic_t indicates that the atomic means it does not leads to any race condition
up() is a function which increments the count variable and wakes up all the sleeping processes when the count value is less than or equal to 0
down() is the function which decrements the count variable, also increments the sleepers variable.
the sum of sleepers and count is the correct value of the semaphore

Engineering Clinic