View difference between Paste ID: Kmp5dUPL and vxWnqttB

 #include <stdlib.h>
 #include <stdio.h>
 #include <pthread.h>
 #include <errno.h>
 #include <string.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
 #include <unistd.h>
 #include <time.h>
 
 int thread_quantity;
 int buffer_size;
 char *requested_file_name;
 char *requested_word;
 
 int file_des = 0;
 int created_threads = 0;
 int alive_threads;
 
 pthread_mutex_t reading_mutex = PTHREAD_MUTEX_INITIALIZER;
 pthread_t *thread_id = NULL;
 off_t file_size;
 pthread_key_t buffer;
 
 void usage() {
 exit(1);
 }
 void err_exit(char *);
 void* thread_function(void *);
 void clean_thread(void *);
 void clean_tsd_buffer(void *); //thread specific data
 //############################################################
 int main(int argc, char *argv[]) {
 	int i;
 	if (argc != 5) {
 		usage();
 	} else {
 		thread_quantity = (int) strtol(argv[1], NULL, 10);
 		alive_threads = thread_quantity;
 		thread_id = malloc(sizeof(pthread_t) * thread_quantity);
 		requested_file_name = argv[2];
 		buffer_size = (int) strtol(argv[3], NULL, 10);
 		if (errno) {
 			usage();
 		}
 		requested_word = argv[4];
 	}
 	if ((file_des = open(requested_file_name, O_RDONLY)) == -1) {
 		err_exit("Error: open(requested_file_name)");
 	}
 	if ((file_size = lseek(file_des, 0, SEEK_END)) == (off_t) -1) {
 		err_exit("Error: lseek(file_des, 0, SEEK_END)");
 	}
 	if (lseek(file_des, 0, SEEK_SET) == (off_t) -1) {
 		err_exit("Error: lseek(file_des, 0, SEEK_END)");
 	}
 	if (pthread_mutex_init(&reading_mutex, NULL) != 0) {
 		err_exit("Error: pthread_mutex_init(reading_mutex)");
 	}
 	if (pthread_key_create(&buffer, clean_tsd_buffer)) {
 		err_exit("Error: pthread_key_create()");
 	}
 	//=========================================================
 	for (i = 0; i < thread_quantity; i++) {
 		if (pthread_create(&thread_id[i], NULL, thread_function, NULL)) {
 			err_exit("Error: pthread_create()");
 		} else {
 			created_threads++;
 		}
 	}
 	while (alive_threads) {
 		usleep(1000);
 	}
 	for (i = 0; i < thread_quantity; i++) {
 		if (pthread_join(thread_id[i], NULL)) {
 			err_exit("Error: pthread_join()");
 		}
 	}
 	//=========================================================
 	err_exit(NULL);
 	return EXIT_SUCCESS;
 }
 //############################################################
 void clean_tsd_buffer(void *arg) {
 	if (arg != NULL) {
 		free(arg);
 	}
 }
 void clean_thread(void *arg) {
 	alive_threads--;
 }
 //-----------------------------------------------------------
 void *thread_function(void *data) {
 	pthread_cleanup_push(clean_thread, NULL);
 				if (pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL)) {
 					err_exit("Error: pthread_setcanceltype()");
 				}
 				if (pthread_setspecific(buffer, malloc(sizeof(char) * buffer_size))) {
 					err_exit("Error: pthread_setspecific()");
 				}
 				int i, bytes_readed;
 				off_t jump, current_offset;
 				void *cbuffer = pthread_getspecific(buffer);
 				for (i = 0; i < thread_quantity; i++) {
 					if (pthread_equal(pthread_self(), thread_id[i])) {
 						jump = (off_t) i * buffer_size;
 						break;
 					}
 				}
 				//==========================================================
 				while (1) {
 					if (pthread_mutex_lock(&reading_mutex) != 0) {
 						err_exit("Error: pthread_mutex_lock(reading_mutex)");
 					}
 					if ((current_offset = lseek(file_des, jump, SEEK_SET)) == (off_t) -1) {
 						err_exit("Error: lseek(reading_mutex)");
 					}
 					if (current_offset > file_size) {
 						if (pthread_mutex_unlock(&reading_mutex) != 0) {
 							err_exit("Error: pthread_mutex_unlock(reading_mutex)");
 						}
 						if (pthread_cancel(pthread_self())) {
 							err_exit("Error: pthread_cancel()");
 						}
 					} else {
 						bytes_readed = read(file_des, cbuffer, buffer_size);
 					}
 					if (pthread_mutex_unlock(&reading_mutex) != 0) {
 						err_exit("Error: pthread_mutex_unlock(reading_mutex)");
 					}
 					usleep(50);
 					if (bytes_readed > 0) {
                         //no, don't need that code
 					} else if (!bytes_readed) {
 						if (pthread_cancel(pthread_self())) {
 							err_exit("Error: pthread_cancel()");
 						}
 					} else { // Error
 						err_exit("Error: czytanie z pliku w wątku");
 					}
 					jump += thread_quantity * buffer_size;
 				}
 				//==========================================================
 				pthread_cleanup_pop(1);
 	if (pthread_cancel(pthread_self())) {
 		err_exit("Error: pthread_cancel()");
 	}
 	return data;
 }
 //-----------------------------------------------------------
 void err_exit(char *msg) {
 	if (msg != NULL) {
 		perror(msg);
 		sleep(10);
 	}
 	if (file_des != 0) {
 		if (close(file_des) == -1) {
 			perror("Error: close(file_des)");
 		}
 	}
 	if (thread_id != NULL) {
 		free(thread_id);
 	}
 	exit(1);
 }
 
 
 
 
 
 
 /////////////////////////////////////####################### test.txt #################
 The pthread_cleanup_push() function pushes routine onto the top of  the
        stack  of clean-up handlers.  When routine is later invoked, it will be
        given arg as its clean argument.
        The pthread_cleanup_pop() function removes the routine at  the  top  of
        the  stack  of clean-up handlers, and optionally executes it if execute
        is nonzero.
 
        A cancellation clean-up handler is popped from the stack  and  executed
        in the following circumstances:
 
        1. When  a thread is canceled, all of the stacked clean-up handlers are
           popped and executed in the reverse of the order in which  they  were
           pushed onto the stack.
 
        2. When  a  thread  terminates by calling pthread_exit(3), all clean-up
           handlers are executed as described in the preceding point.   (Clean-
           up  handlers are not called if the thread terminates by performing a
           return from the thread start function.) clean
 
        3. When a thread calls pthread_cleanup_pop()  with  a  nonzero  execute
           argument, the top-mst clean-up handler is popped and executed.
 
        POSIX.1  permits pthread_cleanup_push() and pthread_cleanup_pop() to be
        implemented as macros that expand  to  text  containing  '{'  and  '}',
        respectively.   For  this  reason, the caller must ensure that call