How can I generate three child processes respecting a particular order? - c

Question

I'm assigned to make a program that creates three child processes as follows: A, B and C.
Process A reads data from a file and sends 4KB-long fragments to a message queue.
Process B reads these fragments from the queue, converts them and writes the
new data on the queue.
Finally, process C reads the converted string from the message queue and writes it on another file.
I used the fork() function to create them, and I'm having trouble generating the three child processes in a sequential order. When I run the program, usually processes B or C are created before A, and they can't read properly from the message queue because process A hasn't been generated yet.
How could I solve this problem?
This is the code I've been working on:
(Note: Two parameters must be added before running the program: ./program.exe source.txt destination.txt)
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/msg.h>
#include <unistd.h>
#define TAM 4096
#define FILEKEY "/bin/cat"
#define KEY 4242
#define N_PROCESSES 3
typedef struct msgbuf{
long type;
char text[TAM];
}message;
int main (int argc, char *argv[]){
key_t key;
pid_t pid;
int msqid;
message env, enda, endb;
message rcv;
message conv;
message msg;
int buf_length;
FILE *f1=NULL;
FILE *f2=NULL;
char string[TAM], *receive;
int rc;
int i;
int status;
int p;
if(argc < 2){
printf("Incorrect command line arguments");
exit(-1);
}
p = getpid();
/*Opens files*/
f1 = fopen(argv[1], "r");
if(f1 == NULL){
exit(-1);
}
f2 = fopen(argv[2], "w");
if(f2 == NULL){
fclose(f1);
exit(-1);
}
/*Obtains key for message queue*/
key = ftok(FILEKEY, KEY);
if(key == -1){
fclose(f1);
fclose(f2);
exit(-1);
}
/*Creates message queue*/
msqid = msgget(key, IPC_CREAT | 0600);
if(msqid == -1){
fclose(f1);
fclose(f2);
exit(-1);
}
/*Message types*/
env.type = 1; /*Message from process A to process B*/
enda.type = 2; /*Process A has finished reading data from f1*/
conv.type = 3; /*Message from process B to process C*/
endb.type = 4; /*Process B has finished converting the string*/
/*Message size (4KB)*/
buf_length = sizeof(message)-sizeof(long);
/*Creates processes A, B and C*/
for ( i = 0; i < N_PROCESSES; i++){
pid = fork();
if(pid == -1){ /*Error*/
msgctl(msqid, IPC_RMID, (struct msqid_ds *)NULL);
fclose(f1);
fclose(f2);
exit(-1);
}else if (pid == 0 && i == 0){/*Process A*/
/*Reads from f1 while end of file is not reached*/
while (fgets(string, TAM, f1) !=NULL){
/*Copies string to env.text*/
strcpy(env.text, cadena);
/*Sends text fragments (4KB) to message queue*/
if(msgsnd(msqid, &env, buf_length, IPC_NOWAIT)<0){
msgctl(msqid, IPC_RMID, (struct msqid_ds *)NULL);
fclose(f1);
fclose(f2);
exit(-1);
}
}
/*Process A sends this message when there's no more data to read*/
if(msgsnd(msqid, &enda, buf_length, IPC_NOWAIT)<0){
msgctl(msqid, IPC_RMID, (struct msqid_ds *)NULL);
fclose(f1);
fclose(f2);
exit(-1);
}
exit(EXIT_SUCCESS);
}else if(pid == 0 && i == 1){/*Process B*/
/*Reads text fragments (4KB) from message queue*/
while (msgrcv(msqid, &rcv, buf_length, 1, IPC_NOWAIT)>0) {
/*Converts string*/
strcpy(receive, rcv.text);
for(i = 0; i < TAM; i++){
receive[i] = toupper(receive[i]);
}
strcpy(conv.text, receive);
/*Sends fragments of converted string to message queue*/
if(msgsnd(msqid, &conv, buf_length, IPC_NOWAIT)<0){
msgctl(msqid, IPC_RMID, (struct msqid_ds *)NULL);
fclose(f1);
fclose(f2);
exit(-1);
}
}
/*The loop finishes when there's an error or when there are no more type 1 messages to read*/
/*Reads type 2 message from process A*/
rc = msgrcv(msqid, &rcv, buf_length, 2, 0);
if( rc == -1){
msgctl(msqid, IPC_RMID, (struct msqid_ds *)NULL);
fclose(f1);
fclose(f2);
exit(-1);
}
/*Process B sends this message indicating that it has finished sending string fragments*/
if(msgsnd(msqid, &endb, buf_length, IPC_NOWAIT)<0){
msgctl(msqid, IPC_RMID, (struct msqid_ds *)NULL);
fclose(f1);
fclose(f2);
exit(-1);
}
exit(EXIT_SUCCESS);
}else if(pid == 0 && i == 2){/*Process C*/
/*Reads converted string fragments from message queue*/
while (msgrcv(msqid, &msg, buf_length, 3, IPC_NOWAIT)>0) {
/*Writes fragments on another file*/
if(fputs(msg.text, f2)<0){
exit(-1);
}
}
/*The loop finishes when there are no more fragments to write on f2*/
/*Then process C reads the last message sent from B*/
rc = msgrcv(msqid, &rcv, buf_length, 4, 0);
if( rc == -1){
msgctl(msqid, IPC_RMID, (struct msqid_ds *)NULL);
fclose(f1);
fclose(f2);
exit(-1);
}
exit (EXIT_SUCCESS);
}
}
/*Parent process waits for processes A, B and C*/
for (i=0; i<N_PROCESSES; i++) {
pid=wait(&status);
printf("Process %d with PPID = %d terminated\n", pid, p);
}
msgctl(msqid, IPC_RMID, (struct msqid_ds *)NULL);
fclose(f1);
fclose(f2);
return (EXIT_SUCCESS);
}

Answer 1

The processes are created in the order you specified, but the scheduler can schedule them in any order it likes, so you find code from process B executing before process A has finished, etc.
What I'd do to set up the situation you want is have 2 queues, one from A to B, the other from B to C. I'd create them all in the parent, to keep things simple.
Then I'd have the reading children do blocking reads (msgrcv() without IPC_NOWAIT), or I'd loop until I got a failure other than no data received.
The sending processes (A and B) would both put "and that's all" indicators into the queue when done, so the receivers would know they had everything.