LINUX AVANZATO 2007

prova di programmazione del 26/04/07
Il processo padre apre il file e crea 2 processi clone che verificano in parallelo un file.
Il primo clone inizia dal primo byte, procede per numeri di byte crescenti e sostituisce tutti gli eventuali byte ugualia 0xff con il byte 0x00.
Il secondo clone fa la stessa cosa ma inizia dall'ultimo byte del file e procede per numeri di byte decrescenti.
Non appena uno dei due cloni incontra un byte gia verificato dall'altro clone, termina.

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

#define NUM_CLONI 2
#define STACK_SIZE 2048

#define CHIAVE 0xff
#define SOSTITUTO 0x00

#define MAX_CONTESA_SLEEP_SEC 1

struct arg_t
{
	int file_descriptor;
	int index;
};

typedef struct arg_t arg_t;

int next[NUM_CLONI] = {0, 0};
int last[NUM_CLONI] = {0, 0};

int contesa()
{
	struct timespec *time;

	time = (struct timespec *) malloc(sizeof(struct timespec));

	time->tv_nsec = rand() % (MAX_CONTESA_SLEEP_SEC * 1000000000);

	return nanosleep(time, NULL);
}

void lock()
{
	int fd;

	while(1)
	{
		fd = creat("/tmp/esercizio_cloni_lock", 0500);

		if(fd < 0)
		{
			close(fd);
			return;
		}
	}
}

void unlock()
{
	unlink("/tmp/esercizio_cloni_lock");
}

int run(void *data)
{
	arg_t *args;
	args = (arg_t *) data;
	char ch;
	
	while(1)
	{
		if(contesa() == 0)
		{
			lock();

			if(args->index == 0)
			{
				if(next[0] == last[1])
				{
					fprintf(stderr, "[%d] : ho incontrato un byte gia' verificato dall'altro clone\n", getpid());
					break;
				}

				lseek(args->file_descriptor, next[0], SEEK_SET);

				if(read(args->file_descriptor, &ch, 1) > 0)
				{
					if(ch == (char) CHIAVE)
					{
						fprintf(stderr, "[%d] : ho letto %c\n", getpid(), (char) CHIAVE);
						lseek(args->file_descriptor, -1, SEEK_CUR);
						ch = SOSTITUTO;
						write(args->file_descriptor, &ch, 1);
						fprintf(stderr, "[%d] : ho scritto %c\n", getpid(), (char) SOSTITUTO);
					}
					else
					{
						fprintf(stderr, "[%d] : ho letto %c\n", getpid(), ch);
					}
					next[0]++;
					last[0]++;
				}
			}
			else if(args->index == 1)
			{
				if(next[1] == last[0])
				{
					fprintf(stderr, "[%d] : ho incontrato un byte gia' verificato dall'altro clone\n", getpid());
					break;
				}

				lseek(args->file_descriptor, next[1], SEEK_SET);

				if(read(args->file_descriptor, &ch, 1) > 0)
				{
					if(ch == (char) CHIAVE)
					{
						fprintf(stderr, "[%d] : ho letto %c\n", getpid(), (char) CHIAVE);
						lseek(args->file_descriptor, -1, SEEK_CUR);
						ch = SOSTITUTO;
						write(args->file_descriptor, &ch, 1);
						fprintf(stderr, "[%d] : ho scritto %c\n", getpid(), (char) SOSTITUTO);
					}
					else
					{
						fprintf(stderr, "[%d] : ho letto %c\n", getpid(), ch);
					}

					next[1]--;
					last[1]--;
				}
			}

			unlock();
		}
	}

	exit(EXIT_SUCCESS);
}

int main(int argc, char *argv[])
{
	int fd, i, rc, status;
	pid_t pid[NUM_CLONI];
	char *nomefile;
	arg_t *args;
	char clone_stack[NUM_CLONI][STACK_SIZE];

	if(argc != 2)
	{
		fprintf(stderr, "Uso : %s <nomefile>\n", argv[0]);
		exit(EXIT_FAILURE);
	}

	nomefile = strdup(argv[1]);

	if(nomefile == NULL)
	{
		perror("strdup error");
		exit(EXIT_FAILURE);
	}

	srand(time(0));

	fd = open(nomefile, O_RDWR);

	if(fd < 0)
	{
		perror("open error");
		exit(EXIT_FAILURE);
	}

	next[0] = lseek(fd, 0, SEEK_SET);
	next[1] = lseek(fd, -1, SEEK_END);

	if(next[1] < 0)
	{
		fprintf(stderr, "Il file %s e' vuoto\n", nomefile);
		exit(EXIT_FAILURE);
	}

	last[0] = next[0] - 1;
	last[1] = next[1] + 1;

	lseek(fd, 0, SEEK_SET);

	if(fd < 0)
	{
		perror("open error");
		exit(EXIT_FAILURE);
	}

	for(i = 0; i < NUM_CLONI; i++)
	{
		args = (arg_t *) malloc(sizeof(arg_t));
		args->file_descriptor = fd;
		args->index = i;

		pid[i] = clone(run, &clone_stack[i][STACK_SIZE-1], CLONE_VM | CLONE_FILES, (void *) args);
	
		if(pid[i] < 0)
		{
			perror("clone error");
			exit(EXIT_FAILURE);
		}

		fprintf(stderr, "[%d] : clone con PID %d creato correttamente.\n", getpid(), pid[i]);
	}

	for(i = 0; i < NUM_CLONI; i++)
	{
		rc = waitpid(pid[i], &status, __WCLONE);
		fprintf(stderr, "[%d] : clone con PID %d terminato con stato %d.\n", getpid(), rc, status);
	}

	close(fd);

	return 0;
}

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


int fd;
int pid_top, pid_bot;		//pid dei cloni
int off_top, off_bot, off_tot;	//offset dei cloni

void clone_func_top();
void clone_func_bot();


void handler_top();
void handler_bot();
void handler_error();


int main(int argn, char** argv){
	
	if(argn != 2){
		printf(" - Sintassi: inserire il nome del file da analizzare\n");
		return -1;
	}
	
	char *path;
	path = (char*)malloc(sizeof(char) * strlen(argv[1]));
	strcpy(path, argv[1]);
		
	printf(" - Il file da analizzare è: %s\n", path);
	
	// dichiara gestori dei segnali
	signal(SIGUSR1, handler_top);
	signal(SIGUSR2, handler_bot);
	
	fd = open(path, O_RDWR);
	
	int stack_clone_top[1024];
	int stack_clone_bot[1024];
	
	off_top = 0;
	off_bot = lseek(fd, 0, SEEK_END) - 1;
	off_tot = off_bot;
	
	pid_top = clone((void*)clone_func_top, &stack_clone_top[1023], CLONE_VM, NULL);
	pid_bot = clone((void*)clone_func_bot, &stack_clone_bot[1023], CLONE_VM, NULL);
	
	sleep(1);
	kill(pid_top, SIGUSR1);
	
// 	sleep(5);
	// aspetta che venga premuto invio da tastiera
	getchar();
	close(fd);
	
	printf("Il padre uccide i cloni\n");
	// uccide i cloni
	kill(pid_top, SIGKILL);
	kill(pid_bot, SIGKILL);
	
	return 0;
}


void handler_top(){
	if(off_top >= off_tot){
		printf("Il clone top ha terminato la lettura del file dall'alto\n");
		return;
	}
	char tmp, new;
	lseek(fd, off_top, SEEK_SET);
	if(read(fd, &tmp, sizeof(tmp)) < 0){
		perror("errore lettura di top");
		handler_error();
	}
	printf("Legge top %i b:%i\n", off_top, tmp);
	off_top++;
	if(tmp == (char)0xfe){
		printf("Il clone top modifica il carattere\n");
		new = 0x00;
		lseek(fd, -1, SEEK_CUR);
		if(write(fd, &new, sizeof(new)) < 0){
			perror("errore scrittura di top");
			handler_error();
		}
	}
}


void handler_bot(){
	if(off_bot < 0){
		printf("Il clone bot ha terminato la lettura del file dal basso\n");
		return;
	}
	
	char tmp, new;
	lseek(fd, off_bot, SEEK_SET);
	if(read(fd, &tmp, sizeof(tmp)) < 0){
		perror("errore lettura di bot");
		handler_error();
	}
	printf("Legge bot %i b:%i\n", off_bot, tmp);
	off_bot--;
	if(tmp == 's'/*(char)0xff*/){
		printf("Il clone bot modifica il carattere\n");
		new = 0x11;
		lseek(fd, -1, SEEK_CUR);
		if(write(fd, &new, sizeof(new)) < 0){
			perror("errore scrittura di bot");
			handler_error();
		}
	}
	
}

void handler_error(){
	printf("A causa di errore i cloni sono uccisi\n");
	kill(pid_top, SIGKILL);
	kill(pid_bot, SIGKILL);
}


void clone_func_bot(){
	while(1){
		pause();
		sleep(1);
		kill(pid_top, SIGUSR1);
	}	
}

void clone_func_top(){
	while(1){
		pause();
		sleep(1);
		kill(pid_bot, SIGUSR2);
	}	
}