reader priority using semaphores - c

Question

I am hitting a wall with a project I am working on and I was wondering if anyone can provide me with some help. I'll try to simplify my code so you aren't staring at 100+ lines of jibberish. I am pretty sure the only the first code block is relevant, the others are my system calls in sys.c for reference.
I am supposed to create a program to simulate a reader priority implementation of process synchronization using my own semaphores. When I run it I reach a deadlock whenever a reader gets to the critical section. I don't know what I did wrong.
An example output is:
Writer 0 wrote- 6
writer 1 wrote- 4
Writer 2 wrote- 2
Reader 0 read- 2
and then it freezes.
From what I can tell the Critcal Section semaphore is never getting released.
I believe the problem is with my program, and not with my semaphore and wait and signal opertaions, but I included them below for reference.
Thanks in advance.
My attempt so far is as follows:
I left out my initialization and memory mapping, this is the basic structure
Notes:
RWwait and RWsignal are wrapper methods which successfully make systems calls to my semaphore operations.
csMutex is to control access to the critical section.
nrMutex is to control the queue of readers to the critical section
Both mutex values are originally 1.
*number is a pointer to number which both readers and writers have access to
int i;
//create writers
for(i=0; i < writers; i++){
if (fork()==0){
while(1){
RWwait(csMutex); //wait for the critical section and lock
*number = rand() % 10;
printf("Writer %d wrote- %d\n", i, *number);
RWsignal(csMutex);//unlock critical section
}
}
}
int nr = 0; //number of readers
//create readers
for(i=0; i < readers; i++){
if (fork()==0){
while(1){
RWwait(nrMutex);
nr++;
if (nr == 1)
RWwait(csMutex);
RWsignal(nrMutex);
printf("Reader %d read- %d\n", i, *number);
RWwait(nrMutex);
nr--;
if (nr == 0)
RWsignal(csMutex);
RWsignal(nrMutex);
}
}
}
THESE ARE MY SYSTEM CALLS AND STRUCTURES IN sys.c
AGAIN, JUST FOR REFERENCE
struct ProcQ {
struct task_struct *ts;
struct ProcQ *next;
};
and
struct RW_Sem {
int value;
char *type;
//Front and back nodes for the queue
struct ProcQ *front;
struct ProcQ *back;
};
Wait Operation:
asmlinkage long sys_RW_wait(struct RW_Sem *sem){
spin_lock(&sem_lock); //locks the program
sem->value -= 1; //decrement value
if (sem->value < 0){ //insert into queue
struct ProcQ *node; //create a new node for the queue
node = (struct ProcQ*)kmalloc(sizeof(struct ProcQ), GFP_KERNEL);
node->ts = current; //assign this process to task_struct
node->next = NULL; //assign the next node to null
if(sem->front == NULL){ //if the process queue is empty
sem->front = node;
sem->back = node;
}
else{ //if the queue is NOT empty
sem->back->next = node;
sem->back = node;
}
set_current_state(TASK_INTERRUPTIBLE); //sleep my child
spin_unlock(&sem_lock); //unlock
schedule();
}
else{ //queue bypass
spin_unlock(&sem_lock);
}
return 0;
}
Signal Operation:
asmlinkage long sys_RW_signal(struct RW_Sem *sem){
spin_lock(&sem_lock); //locks the program
sem->value += 1; //increment value
if(sem->value <= 0){ //wake up process, otherwise bypass
struct ProcQ *dqProc; //temporary node pointer for signaled process
struct task_struct *wake; //temp for task struct to wake
dqProc = sem->front;
if (dqProc != NULL) {
wake = dqProc->ts;
if(sem->front==sem->back){ //if only item in queue
sem->front = NULL;
sem->back = NULL;
}
else{
sem->front = dqProc->next;
}
wake_up_process(wake); //wake up!
kfree(dqProc); //free that space
}
}
spin_unlock(&sem_lock); //unlock
return 0; //success!
}

Answer 1

I would say in your reader:
nr++;
if (nr == 1)
RWwait(csMutex);
Is a race condition.
Similarly I would not do:
if (nr == 0)
RWsignal(csMutex);