[C] Lock su singoli byte

[Njk00]

Salve,
il codice è lungo, ma sinceramente non capisco dov'è l'errore: sembra come se i processi siano eseguiti uno alla volta. Ciò che deve fare il programma è scritto nel commento iniziale.

/*
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 uguali a "k" con il byte "A".
Il secondo clone fa la stessa cosa ma inizia dall'ultimo byte del file e procede per numeri di byte decrescenti e sostituisce le k con B.
Non appena uno dei due cloni incontra un byte gia verificato dall'altro clone, termina.
*/
	#include <stdio.h>
	#include <stdlib.h>
	#include <sched.h>
	#include <sys/types.h>
        #include <sys/stat.h>
        #include <fcntl.h>
	#include <signal.h>
	#include <errno.h>
	#include <unistd.h>
	
	#define STACK_SIZE 1024*64

	int create_lock(int fd, struct flock* lock, int start);
	int clone_fn(void*);

	int main(int argc, char** argv)
	{
		char* stack = malloc(STACK_SIZE);
		int* param = malloc(sizeof(int) * 2);
		int* pid = malloc(sizeof(int) * 2);
		int fd = open("/home/nicola/Desktop/test_read.txt", O_RDWR, S_IRUSR|S_IWUSR);

		param[0] = 1;
		param[1] = fd;
		pid[0] = clone(&clone_fn, stack + STACK_SIZE, CLONE_VM|CLONE_SIGHAND, (void*) param);

		param[0] = -1;
		param[1] = fd;
		pid[1] = clone(&clone_fn, stack + STACK_SIZE, CLONE_VM|CLONE_SIGHAND, (void*) param);

		sleep(10);

		printf("(GOD) Killing clone with pid %d...\n", pid[0]);
		int res = kill(pid[0], SIGTERM);
		if(res == 0)
			printf("(GOD) Clone with pid %d SUCCESSFULL killed\n", pid[0]);
		else
		{
			printf("(GOD) Clone with pid %d NOT killed\n", pid[0]);
			perror("kill");
		}

		printf("(GOD) Killing clone with pid %d...\n", pid[1]);
		res = kill(pid[1], SIGTERM);
		if(res == 0)
			printf("(GOD) Clone with pid %d SUCCESSFULL killed\n", pid[1]);
		else
		{
			printf("(GOD) Clone with pid %d NOT killed\n", pid[1]);
			perror("kill");
		}

		close(fd);	
		return 0;
	}
	
	int unlock(int fd, struct flock* lock, int start)
	{
		int cmd = F_SETLK;
		lock->l_type = F_UNLCK;
		lock->l_whence = SEEK_SET;
		lock->l_start = start;
		lock->l_len = 1;

		int res = fcntl(fd, cmd, lock);
		
		if(res == -1) 
		{        
			perror("fcntl");
			return -1;
		} 
		if(res == 0) 
		{ 
			int pid = getpid();          		
			printf("(CLONE %d) UNLOCK successfull\n", pid);
			return 0;
		}
	}

	int create_lock(int fd, struct flock* lock, int start)
	{
		int cmd = F_SETLK;
		lock->l_type = F_WRLCK;
		lock->l_whence = SEEK_SET;
		lock->l_start = start;
		lock->l_len = 1;

		int res = fcntl(fd, cmd, lock);
		
		if(res == -1) 
		{        
			perror("fcntl");
			return -1;
		} 
		if(res == 0) 
		{ 
			int pid = getpid();          		
			printf("(CLONE %d) LOCK ACQUIRED!!!\n", pid);
			return 0;
		}
	}

	int clone_fn(void* arg)
	{
		int res;
		int pid = getpid();

		int* param = malloc(sizeof(int) * 2);
		param = (int*) arg;
		int id = param[0];
		int fd = param[1];

		char* buffer = malloc(sizeof(char));
		struct flock* lock = malloc(sizeof(struct flock));
		int index;
		int size = lseek(fd, 0, SEEK_END);

		if(id == 1)
		{	
			index = 0;
		
			while(index <= size - 2)
			{		
				res = create_lock(fd, lock, index);		

				if(res == -1)
				{
					printf("(CLONE %d) Byte busy, closing...\n", pid);
					return 0;
				}
				
				else
				{
					lseek(fd, index, SEEK_SET);
					read(fd, buffer, 1);

					if(*buffer == 'k')
					{
						int pos = lseek(fd, index, SEEK_SET);
						*buffer = 'A';					
						write(fd, buffer, 1);
						printf("(CHILD %d) writting A in pos %d\n", pid, pos);
					}
					
					res = unlock(fd, lock, index);
					if(res == -1)
					{
						printf("(CLONE %d) ERRON in UNLOCK function. Quitting...\n", pid);
						return 0;
					}
					
					index++; 
				}
			}
		}					
		else
		{
			printf("-----------------------------CLONE 2 ACTIVE--------------------------\n");
			index = size - 2;
		
			while(index >= 0)
			{				
				res = create_lock(fd, lock, index);		

				if(res != 0)
				{
					printf("(CLONE %d) Byte busy, closing...\n", pid);
					return 0;
				}
				
				else
				{
					lseek(fd, index, SEEK_SET);
					read(fd, buffer, 1);

					if(*buffer == 'k')
					{
						int pos = lseek(fd, index, SEEK_SET);
						*buffer = 'B';					
						write(fd, buffer, 1);
						printf("(CHILD %d) writting B in pos %d\n", pid, pos);
					}
					
					res = unlock(fd, lock, index);
					if(res == -1)
					{
						printf("(CLONE %d) ERRON in UNLOCK function. Quitting...\n", pid);
						return 0;
					}

					index--; 
				}
			}
		}

		return 0;
	}

Grazie a tutti per l'infinita pazienza.