IPC_NOWAIT semop() Buffer SysV Processes - c

Question

I'm really in trouble with this piece of code.
I have a buffer and a method Produce() which should be Non Blocking,this means that when many processes try to Produce() all of them should return/or fail except one process.
I read that in man semop(),when we use IPC_NOWAIT process should fails if the semaphor is already in use. But What Does it mean fails? It returns something? It does an Exit() ?
I really don't know what happens.
In my code, sometimes I found 2 messages in the buffer and sometimes 1.
Since I'm using IPC_NOWAIT I should have at the end just 1 single message in the buffer because other processes should fail because the have been started together!
Here is the Produce() code:
msg_t* put_non_bloccante(buffer_t* buffer, msg_t* msg){
...
struct sembuf sb;
sb.sem_flg=IPC_NOWAIT;
int x=0;
sb.sem_num=VUOTE; sb.sem_op=-1;
if ((x=semop(buffer->semid, &sb,1))<0) {
printf("\n DENTROOOO DOWN%d VUOTE \n",x);/* down(VUOTE) */
perror("semop() producer down(VUOTE)");
exit(-9);
}
sb.sem_num=USO_D; sb.sem_op=-1;
if ((x=semop(buffer->semid, &sb,1))<0) { /* down(USO_D) */
printf("\n DENTROOOO DO%dWN USO D \n",x);
perror("semop() producer down(USO_D)");
exit(-10);
}
if((buffer->msg_presenti)< (buffer->size)){
/*HERE DROP THE MESSAGE IN THE BUFFER IF IS NOT FULL*/
}
sb.sem_num=USO_D; sb.sem_op= 1;
if (semop(buffer->semid, &sb,1)<0) { /* up(USO_D) */
printf("\n DENTROOOO UP USO D \n");
perror("semop() producer up(USO_D)");
exit(-11);
}
sb.sem_num=PIENE; sb.sem_op= 1;
if (semop(buffer->semid, &sb,1)<0) {
printf("\n DENTROOOO UP PIENE \n");/* up(PIENE) */
perror("semop() producer up(PIENE)");
exit(-12);
}
int delay;
delay = (int)(random() % 5 ) / 2 + 1;
sleep(delay);
}
shmdt(buffer);
shmdt(sa);
shmdt(array_msg); */
return msg;
}
Here my simple CUNIT test:
void test_bufferVuoto_3P_NonBlocking_Concurrently(void)
{
pid_t pid=-1;
msg_t* msg = msg_init_string("ciao");
pid_t cons_pid[3];
buffer_t* b=buffer_init(3);
int k;
for(k=0;k<3 && pid!=0;k++) {
pid = cons_pid[k]=fork();
}
switch(pid){
case -1:
printf("error fork()");
exit(-5);
break;
case 0:
buffer_attach(b->bufferid);
msg_attach(msg->msg_id);
put_non_bloccante(b,msg);
msg_deattach(msg);
buffer_deattach(b);
sleep(17);
exit(-5);
}
sleep(12);
int j=0;
for(j=0; j<3; j++) {
kill(cons_pid[j],SIGKILL); // ... and Kill processes
wait(NULL);
}
CU_ASSERT_EQUAL(b->msg_presenti,1);
CU_ASSERT(0==strcmp("ciao", (b->array_msg[0])->content) );
msg_destroy_string(msg);
buffer_destroy(b);
return;
}
I also read a BUG In the Man of SemOP() and IPC_NOWAIT I don'know if is related to this:
*This is however undesirable since it could force
process termination to block for arbitrarily long periods. Another
possibility is that such semaphore adjustments could be ignored alto‐
gether (somewhat analogously to failing when IPC_NOWAIT is specified
for a semaphore operation). Linux adopts a third approach: decreasing
the semaphore value as far as possible (i.e., to zero) and allowing
process termination to proceed immediately.
In kernels 2.6.x, x <= 10, there is a bug that in some circumstances
prevents a process that is waiting for a semaphore value to become zero
from being woken up when the value does actually become zero. This bug
is fixed in kernel 2.6.11.*

Answer 1

As far as I can see the semaphores are doing what you ask but your concept of what should be happening is a little skewed.
If you use IPC_NOWAIT and the process can't acquire the semaphore then it will immediately return with -1 and errno == EAGAIN. Normally you would use this time to do something else and try again later. You are immediately exiting the process, possibly while holding one or more of the semaphores.
Worse yet it looks like you have at least 3 semaphores going. You decrement VUOTE and USO_D, do something, and then increment USO_D and PIENE leaving VUOTE locked. Is that a typo, a mistake, or my misunderstanding?
Overall your expectations of what should happen are wrong. It is entirely possible for your code to end up with 1,2 or 3 messages. (And possibly 0 if bailing out while holding a semaphore.) In other words, depending on how they are scheduled by the OS all 3 of your processes can acquire the semaphore and succeed or maybe just one or two. It is indeterminate.
If it is really your intention that one and only one process can succeed then just initialize a semaphore to 1 and never increment it. The first process to acquire it will get to proceed and the rest will fail because it will never again allow anything else through.
Edit
if ((x = semop(buffer->semid, &sb, 1)) < 0)
{
printf("\n DENTROOOO DOWN%d VUOTE \n", x); /* down(VUOTE) */
perror("semop() producer down(VUOTE)");
exit( -9);
}
Here the semop call returns immediately setting x to -1 and errno to EAGAIN if it can't get the lock. You are coding it to just exit the process. You can code the condition to do something else.
if ((x = semop(buffer->semid, &sb, 1)) < 0)
{
if (errno == EAGAIN)
return NULL; //OR WHATEVER you think appropriate
else
{ //some other failure that's not EAGAIN
printf("\n DENTROOOO DOWN%d VUOTE \n", x); /* down(VUOTE) */
perror("semop() producer down(VUOTE)");
exit( -9);
}
}
//ELSE you got the lock
The processes don't know about each other except (indirectly) through the use of the semaphores. Each of them is going to execute this code. Some will succeed and some won't.
The reason this doesn't work with IPC_NOWAIT is because it is entirely possible each process won't have to wait for the lock. Depending on how they are scheduled one might get the lock and execute, then the next and the next. Or some will and some won't. It is impossible to predict.