[LA] Linux avanzato 2008

/*
maggio 2008 prova 1

Il processo padre apre due file in lettura/scrittura (i nomi dei file sono passati sulla riga di comando) e crea due processi clone passando come parametro ad ognuno di essi uno dei file descriptor dei file aperti in precedenza nonchè il byte da scrivere ripetutamente nel file. 

Ognuno dei due clone esegue un ciclo senza fine aspettando un segnale SIGUSR1 dal processo padre. 

Quando riceve tale segnale, il clone scrive 10 byte nel file di sua competenza (il tipo di byte che il clone deve scrivere ed il file descriptor sono passati come parametri della clone() dal processo padre) e si mette in attesa del prossimo segnale. 

Dopo avere creato i due cloni, il processo padre esegue un ciclo per 10 volte consecutive in cui: 

1)calcola con probabilità 1/2 il pid del clone al quale inviare un segnale SIGUSR1 

2)invia al clone avente il pid calcolato in precedenza il segnale SIGUSR1 

3)aspetta 200 msec 

I nomi dei file da creare e i due caratteri che i cloni dovranno scrivere sono passati sulla riga di comando. 

Esempio di riga di comando: prova ./file1 ./file2 a b 
*/

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
#include <sched.h>
#include <time.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <string.h>
#include <sys/wait.h>

#define NPROC 2
#define STACK_SIZE 4096

struct argomenti
{
	int fd;
	char *byte;
};

void handler(int sign)
{
	printf("handler attivato da %d\n", getpid());
	
	return;
}

int cloneFunc(void *args)
{
	signal(SIGUSR1, handler);
	
	int fd = ((struct argomenti *) args)->fd;
	char *byte = ((struct argomenti *) args)->byte;
	
	printf("Creato processo %d, con fd %d e byte %s\n", getpid(), fd, byte);
	
	for ( ; ; )
	{
		pause();
		
		int j;
		for (j = 0; j < 10; j++)
		{
			if (write(fd, byte, 1) < 0)
			{
				printf("Errore in stampa\n");
			}
		}
	
		printf("%d ha eseguito una stampa\n", getpid());
	}
	
	exit(1);
	
	return 1;
}

int main(int argc, char *argv[])
{	
	if (argc != 5)
	{
		printf("Errore nel numero di parametri\nUso: scriviByte2File filename1 filename2 byte1 byte2\n");
		exit(-1);
	}
	
	int i;
	
	struct argomenti *args[2];
	int childStack[2][STACK_SIZE];
	int pid[2];
	int fds[2];
	
	for (i = 0; i < NPROC; i++)
	{	
		if ((fds[i] = creat(argv[i + 1], 0777)) < 0)
		{
			printf("Impossibile creare %s, forse già esiste\n", argv[i + 1]);
			exit(-1);
		}
		
		args[i] = calloc(1, sizeof(struct argomenti));
		
		args[i]->fd = fds[i];
		args[i]->byte = (char *) argv[i + 3];
		
		//childStack[i] = calloc(1, STACK_SIZE);				
		
		if ((pid[i] = clone(cloneFunc, &childStack[i][STACK_SIZE-1], CLONE_FILES, (void *) args[i])) < 0)
		{
			printf("Errore in clone()\n");
			exit(-1);
		}
		
	}
	
	for (i = 0; i < 10; i++)
	{
		srand(time(NULL));
		int prob = rand() % 2;
		
		kill(pid[prob], SIGUSR1);
		printf("Inviato SIGUSR1 a %d\n", pid[prob]);
		
		usleep(200000);
	}	
	
	for (i = 0; i < NPROC; i++)
	{
		if (kill(pid[i], SIGKILL) < 0)
			printf("Errore in kill %d\n", pid[i]);
			
		if (close(fds[i]) < 0)
			printf("Errore in close %d\n", fds[i]);
	}
	
	exit(1);
}

#define __do_strncpy_from_user(dst,src,count,res)			   \
do {									   \
	long __d0, __d1, __d2;						   \
	might_sleep();							   \
	__asm__ __volatile__(						   \
		"	testq %1,%1\n"					   \
		"	jz 2f\n"					   \
		"0:	lodsb\n"					   \
		"	stosb\n"					   \
		"	testb %%al,%%al\n"				   \
		"	jz 1f\n"					   \
		"	decq %1\n"					   \
		"	jnz 0b\n"					   \
		"1:	subq %1,%0\n"					   \
		"2:\n"							   \
		".section .fixup,\"ax\"\n"				   \
		"3:	movq %5,%0\n"					   \
		"	jmp 2b\n"					   \
		".previous\n"						   \
		".section __ex_table,\"a\"\n"				   \
		"	.align 8\n"					   \
		"	.quad 0b,3b\n"					   \
		".previous"						   \
		: "=r"(res), "=c"(count), "=&a" (__d0), "=&S" (__d1),	   \
		  "=&D" (__d2)						   \
		: "i"(-EFAULT), "0"(count), "1"(count), "3"(src), "4"(dst) \
		: "memory");						   \
} while (0)