Here's what my program is supposed to do:
create 4 child processes:
process 0 is reading 1 byte at a time from STDIN, then writing it into FIFO
process 1 is reading this 1 byte from fifo and write its value as HEX into shared memory
process 2 is reading HEX value from shared memory and writing it into pipe
finally process 3 is reading from pipe and writing into STDOUT (in my case: terminal)
I can't change communication channels. FIFO, then shared memory, then pipes are the only option.
My problem: Program stops at random moments when some file is directed into stdin (for example:./program < /dev/urandom). Sometimes after writing 5 HEX values, sometimes after 100. Weird thing is that when it is working and in another terminal I write "pstree -c" there is 1 main process with 4 children processes (which is what I want), but when I write "pstree -c" after it stopped writing (but still runs) there are only 3 child processes. For some reason 1 is gone even though they all have while(1) in them..
I think I might have problem with synchronization here, but I am unable to spot it (I've tried for many hours).
Here's the code:
#include <unistd.h>
#include <fcntl.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/shm.h>
#include <sys/sem.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/stat.h>
#include <string.h>
#include <signal.h>
#define BUFSIZE 1
#define R 0
#define W 1
// processes ID
pid_t p0, p1, p2, p3;
// FIFO variables
int fifo_fd;
unsigned char bufor[BUFSIZE] = {};
unsigned char bufor1[BUFSIZE] = {};
// Shared memory variables
key_t key;
int shmid;
char * tab;
// zmienne do pipes
int file_des[2];
char bufor_pipe[BUFSIZE*30] = {};
void proces0()
{
ssize_t n;
while(1)
{
fifo_fd = open("/tmp/fifo",O_WRONLY);
if(fifo_fd == -1)
{
perror("blad przy otwieraniu kolejki FIFO w p0\n");
exit(1);
}
n = read(STDIN_FILENO, bufor, BUFSIZE);
if(n<0)
{
perror("read error w p0\n");
exit(1);
}
if(n > 0)
{
if(write(fifo_fd, bufor, n) != n)
{
perror("blad zapisu do kolejki fifo w p0\n");
exit(1);
}
memset(bufor, 0, n); // czyszczenie bufora
}
close(fifo_fd);
}
}
void proces1()
{
ssize_t m, x;
char wartosc_hex[30] = {};
while(1)
{
if(tab[0] == 0)
{
fifo_fd = open("/tmp/fifo", O_RDONLY); // otwiera plik typu fifo do odczytu
if(fifo_fd == -1)
{
perror("blad przy otwieraniu kolejki FIFO w p1\n");
exit(1);
}
m = read(fifo_fd, bufor1, BUFSIZE);
x = m;
if(x < 0)
{
perror("read error p1\n");
exit(1);
}
if(x > 0)
{
// Konwersja na HEX
if(bufor1[0] < 16)
{
if(bufor1[0] == 10) // gdy enter
{
sprintf(wartosc_hex, "0x0%X\n", bufor1[0]);
}
else
{
sprintf(wartosc_hex, "0x0%X ", bufor1[0]);
}
}
else
{
sprintf(wartosc_hex, "0x%X ", bufor1[0]);
}
// poczekaj az pamiec bedzie pusta (gotowa do zapisu)
strcpy(&tab[0], wartosc_hex);
memset(bufor1, 0, sizeof(bufor1)); // czyszczenie bufora
memset(wartosc_hex, 0, sizeof(wartosc_hex)); // przygotowanie tablicy na zapis wartosci hex
x = 0;
}
close(fifo_fd);
}
}
}
void proces2()
{
close(file_des[0]); // zablokuj kanal do odczytu
while(1)
{
if(tab[0] != 0)
{
if(write(file_des[1], tab, strlen(tab)) != strlen(tab))
{
perror("blad write w p2");
exit(1);
}
// wyczysc pamiec dzielona by przyjac kolejny bajt
memset(tab, 0, sizeof(tab));
}
}
}
void proces3()
{
ssize_t n;
close(file_des[1]); // zablokuj kanal do zapisu
while(1)
{
if(tab[0] == 0)
{
if((n = read(file_des[0], bufor_pipe, sizeof(bufor_pipe))) > 0)
{
if(write(STDOUT_FILENO, bufor_pipe, n) != n)
{
perror("write error w proces3()");
exit(1);
}
memset(bufor_pipe, 0, sizeof(bufor_pipe));
}
}
}
}
int main(void)
{
key = 5678;
int status;
// Tworzenie plikow przechowujacych ID procesow
int des_pid[2] = {};
char bufor_proces[50] = {};
mknod("pid0", S_IFREG | 0777, 0);
mknod("pid1", S_IFREG | 0777, 0);
mknod("pid2", S_IFREG | 0777, 0);
mknod("pid3", S_IFREG | 0777, 0);
// Tworzenie semaforow
key_t klucz;
klucz = ftok(".", 'a'); // na podstawie pliku i pojedynczego znaku id wyznacza klucz semafora
if(klucz == -1)
{
perror("blad wyznaczania klucza semafora");
exit(1);
}
semafor = semget(klucz, 1, IPC_CREAT | 0777); // tworzy na podstawie klucza semafor. 1 - ilosc semaforow
if(semafor == -1)
{
perror("blad przy tworzeniu semafora");
exit(1);
}
if(semctl(semafor, 0, SETVAL, 0) == -1) // ustawia poczatkowa wartosc semafora (klucz, numer w zbiorze od 0, polecenie, argument 0/1/2)
{
perror("blad przy ustawianiu wartosci poczatkowej semafora");
exit(1);
}
// Tworzenie lacza nazwanego FIFO
if(access("/tmp/fifo", F_OK) == -1) // sprawdza czy plik istnieje, jesli nie - tworzy go
{
if(mkfifo("/tmp/fifo", 0777) != 0)
{
perror("blad tworzenia FIFO w main");
exit(1);
}
}
// Tworzenie pamieci dzielonej
// Lista pamieci wspoldzielonych, komenda "ipcs"
// usuwanie pamieci wspoldzielonej, komenta "ipcrm -m ID_PAMIECI"
shmid = shmget(key, (BUFSIZE*30), 0666 | IPC_CREAT);
if(shmid == -1)
{
perror("shmget");
exit(1);
}
tab = (char *) shmat(shmid, NULL, 0);
if(tab == (char *)(-1))
{
perror("shmat");
exit(1);
}
memset(tab, 0, (BUFSIZE*30));
// Tworzenie lacza nienazwanego pipe
if(pipe(file_des) == -1)
{
perror("pipe");
exit(1);
}
// Tworzenie procesow potomnych
if(!(p0 = fork()))
{
des_pid[W] = open("pid0", O_WRONLY | O_TRUNC | O_CREAT); // 1 - zapis, 0 - odczyt
sprintf(bufor_proces, "Proces0 ma ID: %d\n", getpid());
if(write(des_pid[W], bufor_proces, sizeof(bufor_proces)) != sizeof(bufor_proces))
{
perror("blad przy zapisie pid do pliku w p0");
exit(1);
}
close(des_pid[W]);
proces0();
}
else if(p0 == -1)
{
perror("blad przy p0 fork w main");
exit(1);
}
else
{
if(!(p1 = fork()))
{
des_pid[W] = open("pid1", O_WRONLY | O_TRUNC | O_CREAT); // 1 - zapis, 0 - odczyt
sprintf(bufor_proces, "Proces1 ma ID: %d\n", getpid());
if(write(des_pid[W], bufor_proces, sizeof(bufor_proces)) != sizeof(bufor_proces))
{
perror("blad przy zapisie pid do pliku w p1");
exit(1);
}
close(des_pid[W]);
proces1();
}
else if(p1 == -1)
{
perror("blad przy p1 fork w main");
exit(1);
}
else
{
if(!(p2 = fork()))
{
des_pid[W] = open("pid2", O_WRONLY | O_TRUNC | O_CREAT); // 1 - zapis, 0 - odczyt
sprintf(bufor_proces, "Proces2 ma ID: %d\n", getpid());
if(write(des_pid[W], bufor_proces, sizeof(bufor_proces)) != sizeof(bufor_proces))
{
perror("blad przy zapisie pid do pliku w p2");
exit(1);
}
close(des_pid[W]);
proces2();
}
else if(p2 == -1)
{
perror("blad przy p2 fork w main");
exit(1);
}
else
{
if(!(p3 = fork()))
{
des_pid[W] = open("pid3", O_WRONLY | O_TRUNC | O_CREAT); // 1 - zapis, 0 - odczyt
sprintf(bufor_proces, "Proces3 ma ID: %d\n", getpid());
if(write(des_pid[W], bufor_proces, sizeof(bufor_proces)) != sizeof(bufor_proces))
{
perror("blad przy zapisie pid do pliku w p3");
exit(1);
}
close(des_pid[W]);
proces3();
}
else if(p3 == -1)
{
perror("blad przy p3 fork w main");
exit(1);
}
else
{
// proces macierzysty
waitpid(p0, &status, 0);
waitpid(p1, &status, 0);
waitpid(p2, &status, 0);
waitpid(p3, &status, 0);
//wait(NULL);
unlink("/tmp/fifo");
shmdt(tab); // odlaczenie pamieci dzielonej
shmctl(shmid, IPC_RMID, NULL); // usuwanie pamieci wspoldzielonej
printf("\nKONIEC PROGRAMU\n");
}
}
}
}
exit(0);
}
