The code below gives preference to only it's first child to modify a shared variable. How to remove this bug? - process

Question

I want to capture the changes done by all the child processes to a shared variable with the parent process.
Here is the problem.
A parent process creates a structure like this:
struct data
{
int pid;
int n;
char c;
};
It creates k processes and the structure is shared with all it's child. Variable c is initialised to 'n' and it works as a flag.
Parent regularly "wakes up" (from "sleep") after a random amount of time (not more than 2 seconds) checks the value of c and if c is 'y' then prints the value of n (along with the corresponding pid) and makes c to be 'n' again.
On the other hand, every child Pi, 1≤ i ≤ k, regularly "wakes up" (from "sleep") after a random amount of time (not more than 2 seconds) checks the value of c and if c is 'n' then assigns some random value to n, along with its process id to pid, prints that value along with its own process id, and makes c to be 'y'.
If the program execution is terminated by the user (by pressing Ctrl-C), parent with all its children should terminate and the allocated memory should be realeased.
Here is the code:
typedef void (*sighandler_t)(int);
int shmid;
struct data
{
int pid;
int n;
char c;
};
void releaseSHM(int signum)
{
int status;
status = shmctl(shmid, IPC_RMID, NULL);
if (status == 0)
fprintf(stderr, "Remove shared memory with id = %d.\n", shmid);
else if (status == -1)
fprintf(stderr,"Cannot remove shared memory of id = %d.\n", shmid);
else
fprintf(stderr, "shmctl() returned wrong value while removing shared memory with id = %d.\n", shmid);
status = kill(0, SIGKILL);
exit(signum);
}
int main(int argc, char *argv[])
{
int num,k=5,i, p1;
struct data *s;
sighandler_t shandler;
shandler = signal(SIGINT, releaseSHM);
shmid = shmget(IPC_PRIVATE, sizeof(struct data), IPC_CREAT | 0777);
if(shmid==-1)
{
perror("shmget() failed");
exit(1);
}
s=(struct data *)shmat(shmid, NULL, 0);
s->c='n';
for(i=0;i<k;i++)
{
p1=fork();
if(p1==0)
{
while(1)
{
//shandler = signal(SIGINT, releaseSHM);
num=(rand()%3);
sleep(num);
if(s->c=='n')
{
s->n=rand();
s->pid=getpid();
printf("Child with pid %d set value of n as %d \n",s->pid,s->n);
s->c='y';
}
sleep(num);
}
}
else
{
while(1)
{
num=(rand()%3);
sleep(num);
if(s->c=='y')
printf("Parent reads value of n as %d set by child with process id %d \n",s->n, s->pid);
s->c='n';
}
}
}
return 0;
}
It gives output as:
Child with pid 13883 set value of n as 846930886
Parent reads value of n as 846930886 set by child with process id 13883
Child with pid 13883 set value of n as 1957747793
Parent reads value of n as 1957747793 set by child with process id 13883
Child with pid 13883 set value of n as 719885386
Parent reads value of n as 719885386 set by child with process id 13883
Child with pid 13883 set value of n as 596516649
Parent reads value of n as 596516649 set by child with process id 13883
Child with pid 13883 set value of n as 1350490027
Parent reads value of n as 1350490027 set by child with process id 13883
^CRemove shared memory with id = 15368197.
Killed
Clearly it captures the changes done by only one child process and don't give chance to other child processes. How to remove this bug?
If any other information required, drop a comment below.

Answer 1

You intend to have a parent and k children contending for shared memory, but instead you spawn only one child regardless of the value of k.
You write this:
....
for (int i = 0; i < k; i++) {
pid_t child = fork();
if (child == 0) do_child_infinite_loop();
else do_parent_infinite_loop(); // <- BUG: the for loop never resumes
}
You mean to do this:
....
for (int i = 0; i < k; i++) {
pid_t child = fork();
if (child == 0) do_child_infinite_loop();
}
do_parent_infinite_loop();
Once you fix this, you can move on to other debugging: the k children will stepping on each other's updates, and they also share the same pseudo-random number sequence.