Semaphore linux c example

SYSTEM V Semaphores in C using semget, semctl, semop system V system calls in Linux

In the previous chapter we learned about shared memory. And there is a problem of race condition when there are multiple process are trying to access and change the shared memory.

Now, we have 2 different API to use semaphores. System V semaphore are the older version and POSIX semaphore API which are newer version.

In this chapter we shall learn about System V semaphore.

So to solve this problem we should use semaphores to avoid the race condition.

We shall learn about semaphores by taking series of simple steps and then taking a full example.

1. How to get a System V semaphore?

To get a semaphore you need to use “semget()” system call.

The function prototype is:

#include #include #include int semget(key_t key, int nsems, int semflg);

key : It is a unique identifier, if any process wants to connect to the queue, it should have to use the same key.

As key is a “long” data type, you can use any integer to set the key.

Or you can also use “ftok()” known as “file to key”. The function accepts 2 arguments, first is file path and the next is a id. “ftok()” will use these 2 arguments and then will create a unique key. The other program trying to access this queue should use the same parameters.

Function prototype for ftok is:

key_t ftok(const char *path, int id);

nsems : It is the number of semaphores in the present semaphore set.

Below is the way to create a semaphore:

#include #include key_t key; int semid; key = ftok("/home/aj/myFile", 'E'); semid = semget(key, 10, 0666 | IPC_CREAT);

Once a semaphore is created, they’re all uninitialized; to make them free, you need to use semop() or semctl(). We shall see in further in this chapter.

2. How to control a System V semaphore?

To control a semaphore use “semctl()” system call.

“semctl()” will allow to initialize a positive value the semaphores, to make the resources available.

It allows you set for individual semaphore or complete semaphore set.

Function prototype is:

int semctl(int semid, int semnum, int cmd, . /*arg*/);

GETPID : Return the PID of the process that performed the last operation on the semaphore or array.
GETNCNT : Return the number of processes waiting for the value of a semaphore to increase.

GETZCNT : Return the number of processes waiting for the value of a particular semaphore to reach zero.

3. How to perform operations a System V semaphore?

To perform operations on a semaphore, you need to use semop() system call.

Syntax for semop():

int semop(int semid, struct sembuf *sops, unsigned int nsops);

semid: It is the ID you get, when you call semget().

sops: It ss a pointer to the “struct sembuf” which is filled with semaphore commands.

If sem_op is negative, then its value is subtracted from the semaphore.
If sem_op is positive, then it’s value is added to the semaphore.
if sem_op is zero (0), then the calling process will sleep() until the semaphore’s value is 0

4. How to destroy a System V semaphore?

A semaphore can be destroyed by calling semctl() with the cmd IPC_RMID.

2. SemDemo.c : It will use the semaphore that you have created. Run this in multiple windows.

SemInit.c [Run this first]

#include #include #include #include #include #include //for more tutorials on C, C++, STL, DS visit www.ProDeveloperTutorial.com int main(void) < key_t key; int semid; union semun arg; if ((key = ftok("semdemo.c", 'J')) == -1) < perror("ftok"); exit(1); >/* create a semaphore set with 1 semaphore: */ if ((semid = semget(key, 1, 0666 | IPC_CREAT)) == -1) < perror("semget"); exit(1); >/* initialize semaphore #0 to 1: */ arg.val = 1; if (semctl(semid, 0, SETVAL, arg) == -1) < perror("semctl"); exit(1); >return 0; >

SemDemo.c

#include #include #include #include #include #include //for more tutorials on C, C++, STL, DS visit www.ProDeveloperTutorial.com int main(void) < key_t key; int semid; struct sembuf sb = ; /* set to allocate resource */ if ((key = ftok("semdemo.c", 'J')) == -1) < perror("ftok"); exit(1); >/* grab the semaphore set created by seminit.c: */ if ((semid = semget(key, 1, 0)) == -1) < perror("semget"); exit(1); >printf("Press return to lock: "); getchar(); printf("Trying to lock. \n"); if (semop(semid, &sb, 1) == -1) < perror("semop"); exit(1); >printf("Locked.\n"); printf("Press return to unlock: "); getchar(); sb.sem_op = 1; /* free resource */ if (semop(semid, &sb, 1) == -1) < perror("semop"); exit(1); >printf("Unlocked\n"); return 0; >

SemRemove.c

#include #include #include #include #include #include //for more tutorials on C, C++, STL, DS visit www.ProDeveloperTutorial.com int main(void) < key_t key; int semid; union semun arg; if ((key = ftok("semdemo.c", 'J')) == -1) < perror("ftok"); exit(1); >/* grab the semaphore set created by seminit.c: */ if ((semid = semget(key, 1, 0)) == -1) < perror("semget"); exit(1); >/* remove it: */ if (semctl(semid, 0, IPC_RMID, arg) == -1) < perror("semctl"); exit(1); >return 0; >

Источник

c semaphore example

In computer science, a semaphore is a variable or abstract data type used to control access to a common resource by multiple processes and avoid critical section problems in a concurrent system such as a multitasking operating system.

What is semaphore with example?

Semaphore is simply a variable that is non-negative and shared between threads. A semaphore is a signaling mechanism, and a thread that is waiting on a semaphore can be signaled by another thread. It uses two atomic operations, 1)wait, and 2) signal for the process synchronization. . Example of Semaphore.

How does Semaphore work in C?

1 Semaphore implementation. When a thread waits on the semaphore, it has to lock the mutex before it decrements value. If the value of the semaphore becomes negative, the thread blocks until a “wakeup” is available. While it is blocked, the mutex is unlocked, so another thread can signal.

What is Sem_init in C?

The sem_init() function is used to initialise the unnamed semaphore referred to by sem. The value of the initialised semaphore is value. Following a successful call to sem_init(), the semaphore may be used in subsequent calls to sem_wait(), sem_trywait(), sem_post(), and sem_destroy().

Why Semaphore is used in OS?

Semaphores are integer variables that are used to solve the critical section problem by using two atomic operations, wait and signal that are used for process synchronization. The wait operation decrements the value of its argument S, if it is positive. If S is negative or zero, then no operation is performed.

Is Semaphore still used today?

Semaphore flags are still in use today, but have evolved into square flags on short poles. . When the system is used at sea, the flags are red and yellow, and, when on land, the flags are white and blue.

Who uses Semaphore?

The semaphore flag signalling system, designed by the Chappe brothers in France in the late 18th century was used to carry despatches between French army units, including those commanded by Napoleon, and was soon adopted by other European states.
.
Question 3.

Right Arm	Right Arm	Right Arm
Left Arm	Left Arm	Left Arm

What is a mutex C?

A Mutex is a lock that we set before using a shared resource and release after using it. When the lock is set, no other thread can access the locked region of code.

What is deadlock how it occurs?

In an operating system, a deadlock occurs when a process or thread enters a waiting state because a requested system resource is held by another waiting process, which in turn is waiting for another resource held by another waiting process.

What is difference between semaphore and mutex?

Semaphore supports wait and signal operations modification, whereas Mutex is only modified by the process that may request or release a resource. Semaphore value is modified using wait () and signal () operations, on the other hand, Mutex operations are locked or unlocked.

What are semaphore signals?

The Semaphore flag signaling system is an alphabet signalling system based on the waving of a pair of hand-held flags in a particular pattern. The flags are usually square, red and yellow, divided diagonaly with the red portion in the upper hoist.

Semaphore

What are Posix semaphores?How do you use semaphores in Posix?How does Semaphore work in C?What is semaphore in C?How do you destroy semaphores?How are.

Kali

Kali 2.0 – 11th August, 2015 – Major release, “safi», now a rolling distribution, major UI changes.Which version of Kali Linux is best?Do hackers use .

Storage

How to add NFS Data and Export Storage Domain to oVirt/RHEVCreating group/user account. First login to NFS server and create a system group called kvm.

Latest news, practical advice, detailed reviews and guides. We have everything about the Linux operating system

Источник

Adding Semaphore to a program — C in Linux

I am relatively new to programming, especially in the C Language. I got an assignment to write a simple program in C and executing it in Linux. I’ve written the code already as below:

#include #include #include #include #include #define BUFSZ 4096 int shmid; int shmkey = 12222; int main() < /* ----- Creating Shared memory ----- */ shmid=shmget(IPC_PRIVATE,BUFSZ,0666); if(shmid<0) < perror("shmget"); exit(EXIT_FAILURE); >printf(" Segment Created: %d \n", shmid); /* ----- Attaching Memory to Shared memory ----- */ char *shmbuf; if((shmbuf=shmat(shmid,0,0)) <0) < perror("shmat"); exit(EXIT_FAILURE); >printf("Segmet Attached at %p \n", shmbuf); //system("ipcs -m"); /* ----- Creating Process Using Fork ----- */ int p,i; //i is counter for (i=1; i else if (p==0) //Child Process < printf("Counter: %d\t Process ID: %d\n" ,i,getpid()); //Prints Counter Value and Process ID. >else //Parent Process < wait(NULL); //Waits Child Process to Complete exit(0); >> /* ----- Deattaching Memory -----*/ if((shmdt(shmbuf)) <0) < perror("shmat"); exit(EXIT_FAILURE); >printf("Segmet Deattached at %p \n", shmbuf); //system("ipcs -m"); /* ----- Exiting Program ----- */ exit(0); puts("\n End\n"); > 

I now have to apply the concept of semaphore to this program, using semget(), semop(), and semctl(). Can I please get help on how to use the three functions in my program?

1 Answer 1

The advantage of semaphores over other synchronization mechanisms is that they can be used to synchronize two related or unrelated processes trying to access the same resource. Related Process

The processes are said to be related if the new process is created from within an existing process, which ends up in duplicating the resources of the creating process. Such processes are called related processes. The following example shows how the related processes are synchronized.

#include #include #include #include #include #include #include #include #include int main(int argc, char **argv) < int fd, i,count=0,nloop=10,zero=0,*ptr; sem_t mutex; //open a file and map it into memory fd = open("log.txt",O_RDWR|O_CREAT,S_IRWXU); write(fd,&zero,sizeof(int)); ptr = mmap(NULL,sizeof(int),PROT_READ |PROT_WRITE,MAP_SHARED,fd,0); close(fd); /* create, initialize semaphore */ if( sem_init(&mutex,1,1) < 0) < perror("semaphore initilization"); exit(0); >if (fork() == 0) < /* child process*/ for (i = 0; i < nloop; i++) < sem_wait(&mutex); printf("child: %d\n", (*ptr)++); sem_post(&mutex); >exit(0); > /* back to parent process */ for (i = 0; i < nloop; i++) < sem_wait(&mutex); printf("parent: %d\n", (*ptr)++); sem_post(&mutex); >exit(0); > 

In this example, the related process access a common piece of memory, which is synchronized. Unrelated Process

Processes are said to be unrelated if the two processes are unknown to each other and no relationship exists between them. For example, instances of two different programs are unrelated process. If such programs try to access a shared resource, a semaphore could be used to synchronize their access. The following source code demonstrates this:

#include #include #include #include #include #include #include #include #define SHMSZ 27 char SEM_NAME[]= "vik"; int main() < char ch; int shmid; key_t key; char *shm,*s; sem_t *mutex; //name the shared memory segment key = 1000; //create & initialize semaphore mutex = sem_open(SEM_NAME,O_CREAT,0644,1); if(mutex == SEM_FAILED) < perror("unable to create semaphore"); sem_unlink(SEM_NAME); exit(-1); >//create the shared memory segment with this key shmid = shmget(key,SHMSZ,IPC_CREAT|0666); if(shmid <0) < perror("failure in shmget"); exit(-1); >//attach this segment to virtual memory shm = shmat(shmid,NULL,0); //start writing into memory s = shm; for(ch='A';ch <='Z';ch++) < sem_wait(mutex); *s++ = ch; sem_post(mutex); >//the below loop could be replaced by binary semaphore while(*shm != '*') < sleep(1); >sem_close(mutex); sem_unlink(SEM_NAME); shmctl(shmid, IPC_RMID, 0); _exit(0); > 

#include #include #include #include #include #include #include #include #define SHMSZ 27 char SEM_NAME[]= "vik"; int main() < char ch; int shmid; key_t key; char *shm,*s; sem_t *mutex; //name the shared memory segment key = 1000; //create & initialize existing semaphore mutex = sem_open(SEM_NAME,0,0644,0); if(mutex == SEM_FAILED) < perror("reader:unable to execute semaphore"); sem_close(mutex); exit(-1); >//create the shared memory segment with this key shmid = shmget(key,SHMSZ,0666); if(shmid <0) < perror("reader:failure in shmget"); exit(-1); >//attach this segment to virtual memory shm = shmat(shmid,NULL,0); //start reading s = shm; for(s=shm;*s!=NULL;s++) < sem_wait(mutex); putchar(*s); sem_post(mutex); >//once done signal exiting of reader:This can be replaced by another semaphore *shm = '*'; sem_close(mutex); shmctl(shmid, IPC_RMID, 0); exit(0); > 

The above executables (client and server) demonstrate how semaphore could be used between completely different processes.

In addition to the applications shown above, semaphores can be used cooperatively to access a resource. Please note that a semaphore is not a Mutex. A Mutex allows serial access to a resource, whereas semaphores, in addition to allowing serial access, could also be used to access resources in parallel. For example, consider resource R being accessed by n number of users. When using a Mutex, we would need a Mutex «m» to lock and unlock the resource, thus allowing only one user at a time to use the resource R. In contrast, semaphores can allow n number of users to synchronously access the resource R.

Источник