elvis/progettoso
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

style and comments for fileQueue.*

Browse Source
This commit is contained in:
elvis
2022-05-07 22:21:20 +02:00
parent f547da3d73
commit 0242635691
2 changed files with 226 additions and 228 deletions
Download Patch File Download Diff File Expand all files Collapse all files

274
lib/threadpool/fileQueue.c
View File

@ -3,12 +3,12 @@
#include <stdio.h>
#include <string.h>
#include <fileQueue.h>
#include <util.h>
#include "fileQueue.h"
#include "util.h"
#define MAXNAMELEN 512
// creazione di un fileT
/* create a fileT file */
fileT* createFileT(char *f, int O_LOCK, int client, int open) {
if(!f){
errno = EINVAL;
@ -18,7 +18,7 @@ fileT* createFileT(char *f, int O_LOCK, int client, int open){
fileT *file = malloc(sizeof(fileT));
if (file == NULL) {
perror("Malloc createFileT");
perror("createFileT: malloc");
return NULL;
}
@ -28,23 +28,24 @@ fileT* createFileT(char *f, int O_LOCK, int client, int open){
file->size = 0;
file->valid = 0;
if ((file->filepath = calloc(strnlen(f, MAXNAMELEN)+1, sizeof(char))) == NULL) {
perror("Malloc filepath");
file->filepath = calloc(strnlen(f, MAXNAMELEN)+1, sizeof(char));
if (file->filepath == NULL) {
perror("createFileT: malloc");
destroyFile(file);
return NULL;
}
strncpy(file->filepath, f, strnlen(f, MAXNAMELEN));
// in seguito semplicemente facciamo realloc
/* after a realloc is enough */
if ((file->data = calloc(1, sizeof(char))) == NULL) {
perror("Calloc content");
perror("createFileT: calloc");
return NULL;
}
return file;
}
// append su fileT
/* append on fileT */
int writeFileT(fileT *f, void *data, size_t size) {
if(!f || !data || size < 0){
errno = EINVAL;
@ -56,7 +57,7 @@ int writeFileT(fileT *f, void *data, size_t size) {
}
if ((f->data = realloc(f->data, f->valid + size)) == NULL) {
perror("Realloc content");
perror("writeFileT: realloc");
return -1;
}
@ -66,7 +67,7 @@ int writeFileT(fileT *f, void *data, size_t size) {
return 0;
}
// destroy fileT
/* destroy fileT */
void destroyFile(fileT *f) {
if(!f)
return;
@ -77,9 +78,9 @@ void destroyFile(fileT *f) {
free(f);
}
// --------------
// -----------------------------------------------------------------------------
// creazione queue
/* create queue */
queueT* createQueue(size_t maxLen, size_t maxSize) {
if(maxLen<0 || maxSize<0){
errno = EINVAL;
@ -88,13 +89,13 @@ queueT* createQueue(size_t maxLen, size_t maxSize) {
queueT *q = malloc(sizeof(queueT));
if(q==NULL){
perror("Malloc createQueue");
perror("createQueue: malloc");
return NULL;
}
// creazione lock
/* create lock */
if (pthread_mutex_init(&q->m, NULL) != 0) {
perror("pthread_mutex_init createQueue");
perror("createQueue: pthread_mutex_init");
destroyQueue(q);
return NULL;
}
@ -109,16 +110,16 @@ queueT* createQueue(size_t maxLen, size_t maxSize) {
return q;
}
// insert
/* insert into the queue */
int enqueue(queueT *q, fileT* data) {
if(!q || !data){
errno = EINVAL;
return -1;
}
LOCK_RETURN(&q->m, -1); // begin me
LOCK_RETURN(&q->m, -1); /* begin me */
if (q->len == q->maxLen) { // too many files
if (q->len == q->maxLen) { /* too many files */
errno = ENFILE;
goto _end_enqueue;
}
@ -128,10 +129,10 @@ int enqueue(queueT *q, fileT* data) {
goto _end_enqueue;
}
// inserisco l'elemento
/* insert the element */
nodeT *newNode = malloc(sizeof(nodeT));
if (newNode == NULL) {
perror("malloc newNode");
perror("enqueue: malloc");
goto _end_enqueue;
}
@ -153,7 +154,7 @@ int enqueue(queueT *q, fileT* data) {
++q->len;
q->size += data->size;
UNLOCK_RETURN(&q->m, -1); // end me
UNLOCK_RETURN(&q->m, -1); /* end me */
return 0;
_end_enqueue:
@ -161,18 +162,16 @@ _end_enqueue:
return -1;
}
// remove
/* dequeue one element */
fileT* dequeue(queueT *q) {
if(!q) {
errno = EINVAL;
return NULL;
}
LOCK_RETURN(&q->m, NULL); // begin me
LOCK_RETURN(&q->m, NULL); /* begin me */
// TODO: altri oltre fifo
if (q->head == NULL || q->len == 0) { // coda vuota
if (q->head == NULL || q->len == 0) { /* empty queue */
errno = ENOENT;
goto _end_dequeue;
}
@ -183,15 +182,15 @@ fileT* dequeue(queueT *q) {
tmp = q->head;
q->head = (q->head)->next;
if (q->head == NULL) { // coda diventa vuota
if (q->head == NULL) { /* queue becomes empty */
q->tail = NULL;
}
--q->len;
q->size -= data->size;
free(tmp); // free del nodo
free(tmp); /* free of the node */
UNLOCK_RETURN(&q->m, NULL); // end me
UNLOCK_RETURN(&q->m, NULL); /* end me */
return data;
_end_dequeue:
@ -200,7 +199,7 @@ _end_dequeue:
}
// dequeue until we have s free space and expand the file by s
/* dequeue until we have s free space and expand the file by s */
fileT ** dequeueN(queueT *q, char *filepath, size_t s) {
if(!q) {
errno = EINVAL;
@ -210,11 +209,9 @@ fileT ** dequeueN(queueT *q, char *filepath, size_t s) {
return NULL;
}
LOCK_RETURN(&q->m, NULL); // begin me
LOCK_RETURN(&q->m, NULL); /* begin me */
/* TODO: altri oltre a fifo */
if (q->head == NULL || q->len == 0) { // coda vuota
if (q->head == NULL || q->len == 0) { /* empty queue */
errno = ENOENT;
goto _end_dequeueN;
}
@ -224,21 +221,21 @@ fileT ** dequeueN(queueT *q, char *filepath, size_t s) {
goto _end_dequeueN;
}
// scorro la queue per trovare l'elemento
/* try to find the file */
nodeT *tmp = q->head;
while (tmp) {
if (strcmp(filepath, (tmp->data)->filepath) == 0) { // trovato
if (strcmp(filepath, (tmp->data)->filepath) == 0) { /* found */
break;
}
tmp = tmp->next;
}
if(!tmp) { // non trovato
if(!tmp) { /* not found */
errno = ENOENT;
goto _end_dequeueN;
}
fileT **returnList = NULL; // lista dei file rimossi
fileT **returnList = NULL; /* list of removed files */
tmp = NULL;
returnList = calloc(1, sizeof(fileT*));
@ -249,7 +246,7 @@ fileT ** dequeueN(queueT *q, char *filepath, size_t s) {
purged++;
returnList = realloc(returnList, purged * sizeof(fileT*));
if(!returnList) {
perror("realloc");
perror("dequeueN: realloc");
goto _end_dequeueN;
}
tmp = q->head;
@ -259,18 +256,18 @@ fileT ** dequeueN(queueT *q, char *filepath, size_t s) {
--q->len;
q->size -= tmp->data->size;
if (q->head == NULL) { // coda diventa vuota
if (q->head == NULL) { /* queue becomes empty */
q->tail = NULL;
break; // we eliminated everything so we must have enought space
break; /* we eliminated everything so we must have enought space */
}
}
returnList = realloc(returnList, (purged+1) * sizeof(fileT*));
returnList[purged] = NULL; // null terminated
returnList[purged] = NULL; /* null terminated */
tmp->data->size += s;
q->size += s;
UNLOCK_RETURN(&q->m, NULL); // end me
UNLOCK_RETURN(&q->m, NULL); /* end me */
return returnList;
_end_dequeueN:
@ -284,9 +281,9 @@ void voidDequeue(queueT *q) {
return;
}
LOCK(&q->m); // begin me
LOCK(&q->m); /* begin me */
if (q->head == NULL || q->len == 0) { // coda vuota
if (q->head == NULL || q->len == 0) { /* empty queue */
errno = ENOENT;
goto _end_void_dequeue;
}
@ -296,17 +293,17 @@ void voidDequeue(queueT *q) {
q->head = (q->head)->next;
if (q->head == NULL) { // coda diventa vuota
if (q->head == NULL) { /* queue becomes empty */
q->tail = NULL;
}
--q->len;
q->size -= (tmp->data)->size;
destroyFile(tmp->data); // free fileT
free(tmp); // free nodo
destroyFile(tmp->data); /* free fileT */
free(tmp); /* free node */
UNLOCK(&q->m); // end me
UNLOCK(&q->m); /* end me */
return;
_end_void_dequeue:
@ -314,69 +311,70 @@ _end_void_dequeue:
return;
}
// print queue
/* print queue */
int printQueue(FILE *stream, queueT *q) {
if(!q || !stream) {
errno = EINVAL;
return -1;
}
LOCK_RETURN(&q->m, -1); // begin me
LOCK_RETURN(&q->m, -1); /* begin me */
nodeT *tmp = q->head;
fprintf(stream, "Lista file:\n");
fprintf(stream, "[Nome File] -> Dimensione in MB\n");
while (tmp!=NULL) {
float res = ((float)(tmp->data)->size)/1000000; // in MB
// float res = ((float)(tmp->data)->valid)/1000000; // in MB
float res = ((float)(tmp->data)->size)/1000000; /* in MB */
// float res = ((float)(tmp->data)->valid)/1000000; /* in MB */
fprintf(stream, "[%s] -> %f MB\n", (tmp->data)->filepath, res);
tmp = tmp->next;
}
UNLOCK_RETURN(&q->m, -1); // end me
UNLOCK_RETURN(&q->m, -1); /* end me */
return 0;
}
// acquisizione lock
/* acquire lock */
int lockFileInQueue(queueT *q, char *filepath, int owner) {
if(!q || !filepath) {
errno = EINVAL;
return -1;
}
LOCK_RETURN(&q->m, -1); // begin me
LOCK_RETURN(&q->m, -1); /* begin me */
if (q->len == 0) {
errno = ENOENT;
goto _end_lock_file_queue;
}
// scorro la queue per trovare l'elemento
/* find file */
nodeT *tmp = q->head;
while (tmp) {
if (strcmp(filepath, (tmp->data)->filepath) == 0) { // trovato
if (strcmp(filepath, (tmp->data)->filepath) == 0) { /* found */
break;
}
tmp = tmp->next;
}
if(!tmp) { // non trovato
if(!tmp) { /* not found */
errno = ENOENT;
goto _end_lock_file_queue;
}
if ((tmp->data)->O_LOCK && (tmp->data)->owner != owner) { // lock non del owner
/* lock already aquired by another client */
if ((tmp->data)->O_LOCK && (tmp->data)->owner != owner) {
errno = EPERM;
goto _end_lock_file_queue;
}
// acquisisco lock sul file
/* aquire lock on the file */
(tmp->data)->O_LOCK = 1;
(tmp->data)->owner = owner;
UNLOCK_RETURN(&q->m, -1); // end me
UNLOCK_RETURN(&q->m, -1); /* end me */
return 0;
_end_lock_file_queue:
@ -391,41 +389,42 @@ int unlockFileInQueue(queueT *q, char *filepath, int owner) {
return -1;
}
LOCK_RETURN(&q->m, -1); // begin me
LOCK_RETURN(&q->m, -1); /* begin me */
if (q->len == 0) {
errno = ENOENT;
goto _end_unlock_file_queue;
}
// scorro la queue per trovare l'elemento
/* find the file */
nodeT *tmp = q->head;
while (tmp) {
if (strcmp(filepath, (tmp->data)->filepath) == 0) { // trovato
if (strcmp(filepath, (tmp->data)->filepath) == 0) { /* found */
break;
}
tmp = tmp->next;
}
if(!tmp) { // non trovato
if(!tmp) { /* not found */
errno = ENOENT;
goto _end_unlock_file_queue;
}
if((tmp->data)->O_LOCK == 0) { // nessuno ha il lock
if((tmp->data)->O_LOCK == 0) { /* no one has the lock */
UNLOCK_RETURN(&q->m, -1);
return 0;
}
if((tmp->data)->O_LOCK == 1 && (tmp->data)->owner != owner) { // lock non del owner
/* another client holds the lock */
if((tmp->data)->O_LOCK == 1 && (tmp->data)->owner != owner) {
errno = EPERM;
goto _end_unlock_file_queue;
}
(tmp->data)->O_LOCK = 0;
UNLOCK_RETURN(&q->m, -1); // end me
UNLOCK_RETURN(&q->m, -1); /* end me */
return 0;
_end_unlock_file_queue:
@ -434,35 +433,35 @@ _end_unlock_file_queue:
}
// open file
/* open file */
int openFileInQueue(queueT *q, char *filepath, int O_LOCK, int owner) {
if(!q || !filepath) {
errno = EINVAL;
return -1;
}
LOCK_RETURN(&q->m, -1); // begin me
LOCK_RETURN(&q->m, -1); /* begin me */
if (q->len == 0) {
errno = ENOENT;
goto _end_open_file_queue;
}
// scorro la queue per trovare l'elemento
/* find the file */
nodeT *tmp = q->head;
while (tmp) {
if (strcmp(filepath, (tmp->data)->filepath) == 0) { // trovato
if (strcmp(filepath, (tmp->data)->filepath) == 0) { /* found */
break;
}
tmp = tmp->next;
}
if(!tmp) { // non trovato
if(!tmp) { /* not found */
errno = ENOENT;
goto _end_open_file_queue;
}
// lock non del owner
/* lock aquired by another client */
if((tmp->data)->O_LOCK == 1 && (tmp->data)->owner != owner) {
errno = EPERM;
goto _end_open_file_queue;
@ -475,7 +474,7 @@ int openFileInQueue(queueT *q, char *filepath, int O_LOCK, int owner) {
(tmp->data)->owner = owner;
}
UNLOCK_RETURN(&q->m, -1); // end me
UNLOCK_RETURN(&q->m, -1); /* end me */
return 0;
_end_open_file_queue:
@ -483,35 +482,36 @@ _end_open_file_queue:
return -1;
}
// close and relese lock
/* close and relese lock */
int closeFileInQueue(queueT *q, char *filepath, int owner) {
if(!q || !filepath) {
errno = EINVAL;
return -1;
}
LOCK_RETURN(&q->m, -1); // begin me
LOCK_RETURN(&q->m, -1); /* begin me */
if (q->len == 0) {
errno = ENOENT;
goto _end_close_file_queue;
}
// scorro la queue per trovare l'elemento
/* find file */
nodeT *tmp = q->head;
while (tmp) {
if (strcmp(filepath, (tmp->data)->filepath) == 0) { // trovato
if (strcmp(filepath, (tmp->data)->filepath) == 0) { /* found */
break;
}
tmp = tmp->next;
}
if(!tmp) { // non trovato
if(!tmp) { /* not found */
errno = ENOENT;
goto _end_close_file_queue;
}
if((tmp->data)->O_LOCK == 1 && (tmp->data)->owner != owner) { // lock non del owner
/* lock aquired by another client */
if((tmp->data)->O_LOCK == 1 && (tmp->data)->owner != owner) {
errno = EPERM;
goto _end_close_file_queue;
}
@ -520,7 +520,7 @@ int closeFileInQueue(queueT *q, char *filepath, int owner) {
(tmp->data)->O_LOCK = 0;
(tmp->data)->owner = owner;
UNLOCK_RETURN(&q->m, -1); // end me
UNLOCK_RETURN(&q->m, -1); /* end me */
return 0;
_end_close_file_queue:
@ -538,41 +538,41 @@ int writeFileInQueue(queueT *q, char *filepath, void *data, size_t size, int own
if(size == 0)
return 0;
LOCK_RETURN(&q->m, -1); // begin me
LOCK_RETURN(&q->m, -1); /* begin me */
if (q->len == 0) { // coda vuota
if (q->len == 0) { /* empty queue */
errno = ENOENT;
goto _end_write_file_queue;
}
if (q->size + size > q->maxSize) { // non c'e' abbastanza spazio
if (q->size + size > q->maxSize) { /* not enough space */
errno = EFBIG;
goto _end_write_file_queue;
}
// scorro la queue per trovare l'elemento
/* find the file */
nodeT *tmp = q->head;
while (tmp) {
if (strcmp(filepath, (tmp->data)->filepath) == 0) { // trovato
if (strcmp(filepath, (tmp->data)->filepath) == 0) { /* found */
break;
}
tmp = tmp->next;
}
if(!tmp) { // non trovato
if(!tmp) { /* not found */
errno = ENOENT;
goto _end_write_file_queue;
}
if ((tmp->data)->open == 0 || ((tmp->data)->O_LOCK && (tmp->data)->owner != owner)) {
// if file non è aperto o la lock non è del owner
/* file is closed or the client does not hold the lock */
errno = EPERM;
goto _end_write_file_queue;
}
// scrivo
/* write */
if (((tmp->data)->data = realloc((tmp->data)->data, size)) == NULL) {
perror("Realloc content");
perror("writeFileInQueue: realloc");
goto _end_write_file_queue;
}
memcpy((tmp->data)->data, data, size);
@ -581,7 +581,7 @@ int writeFileInQueue(queueT *q, char *filepath, void *data, size_t size, int own
(tmp->data)->valid = size;
(tmp->data)->size = size;
UNLOCK_RETURN(&q->m, -1); // end me
UNLOCK_RETURN(&q->m, -1); /* end me */
return 0;
_end_write_file_queue:
@ -598,52 +598,52 @@ int appendFileInQueue(queueT *q, char *filepath, void *data, size_t size, int ow
if (size == 0)
return 0;
LOCK_RETURN(&q->m, -1); // begin me
LOCK_RETURN(&q->m, -1); /* begin me */
if (q->len == 0) { // coda vuota
if (q->len == 0) { /* empty queue */
errno = ENOENT;
goto _end_append_file_queue;
}
if (q->size + size > q->maxSize) { // non c'e' abbastanza spazio
if (q->size + size > q->maxSize) { /* not enough space */
errno = EFBIG;
goto _end_append_file_queue;
}
// scorro la queue per trovare l'elemento
/* find the file */
nodeT *tmp = q->head;
while (tmp) {
if (strcmp(filepath, (tmp->data)->filepath) == 0) { // trovato
if (strcmp(filepath, (tmp->data)->filepath) == 0) { /* found */
break;
}
tmp = tmp->next;
}
if(!tmp) { // non trovato
if(!tmp) { /* not found */
errno = ENOENT;
goto _end_append_file_queue;
}
if ((tmp->data)->open == 0 || ((tmp->data)->O_LOCK && (tmp->data)->owner != owner)) {
// if file non è aperto o la lock non è del owner
/* file is closed or the client does not hold the lock */
errno = EPERM;
goto _end_append_file_queue;
}
// scrivo
/* write */
if (((tmp->data)->data = realloc((tmp->data)->data, (tmp->data)->valid + size)) == NULL) {
perror("Realloc content");
perror("appendFileInQueue: realloc");
goto _end_append_file_queue;
}
memcpy(((char *)(tmp->data)->data) + (tmp->data)->valid, data, size);
// memmove sarebbe un'alternativa
/* memmove could be an alternative */
(tmp->data)->valid += size;
q->size -= (tmp->data)->size;
(tmp->data)->size = ((tmp->data)->size > (tmp->data)->valid) ? (tmp->data)->size : (tmp->data)->valid;
q->size += (tmp->data)->size;
UNLOCK_RETURN(&q->m, -1); // end me
UNLOCK_RETURN(&q->m, -1); /* end me */
return 0;
_end_append_file_queue:
@ -658,18 +658,18 @@ int removeFileFromQueue(queueT *q, char *filepath, int owner) {
return -1;
}
LOCK_RETURN(&q->m, -1); // begin me
LOCK_RETURN(&q->m, -1); /* begin me */
if (q->len == 0) { // coda vuota
if (q->len == 0) { /* empty queue */
errno = ENOENT;
goto _end_remove_file_queue;
}
// scorro la queue per trovare l'elemento
/* find the file */
nodeT *tmp = q->head;
nodeT *pre = q->head;
while (tmp) {
if (strcmp(filepath, (tmp->data)->filepath) == 0) { // trovato
if (strcmp(filepath, (tmp->data)->filepath) == 0) { /* found */
break;
}
if(pre!=tmp)
@ -677,24 +677,24 @@ int removeFileFromQueue(queueT *q, char *filepath, int owner) {
tmp = tmp->next;
}
if (!tmp) { // non trovato
if (!tmp) { /* not found */
errno = ENOENT;
goto _end_remove_file_queue;
}
if (((tmp->data)->O_LOCK) && ((tmp->data)->owner != owner)) {
// if lock non è del owner
/* lock not by the client */
errno = EPERM;
goto _end_remove_file_queue;
}
if (tmp == pre) { // file è il primo
if (tmp == pre) { /* file is the first */
q->head = tmp->next;
if (tmp->next == NULL) {
q->tail = tmp;
}
} else { // file non è il primo
} else {
pre->next = tmp->next;
if (pre->next == NULL) {
@ -704,10 +704,10 @@ int removeFileFromQueue(queueT *q, char *filepath, int owner) {
--q->len;
q->size -= (tmp->data)->size;
destroyFile(tmp->data); // free file
free(tmp); // free node
destroyFile(tmp->data); /* free file */
free(tmp); /* free node */
UNLOCK_RETURN(&q->m, -1); // end me
UNLOCK_RETURN(&q->m, -1); /* end me */
return 0;
_end_remove_file_queue:
@ -716,16 +716,16 @@ _end_remove_file_queue:
}
// ----------------
// -----------------------------------------------------------------------------
// cerco e ritorno una copia
/* search for file and return a copy */
fileT* find(queueT *q, char *filepath) {
if(!q || !filepath) {
errno = EINVAL;
return NULL;
}
LOCK_RETURN(&q->m, NULL); // begin me
LOCK_RETURN(&q->m, NULL); /* begin me */
if (q->len == 0)
goto _end_find_in_queue;
@ -734,7 +734,7 @@ fileT* find(queueT *q, char *filepath) {
nodeT *tmp = q->head;
while (tmp) {
if (strcmp(filepath, (tmp->data)->filepath) == 0) { // trovato
if (strcmp(filepath, (tmp->data)->filepath) == 0) { /* trovato */
break;
}
tmp = tmp->next;
@ -743,23 +743,21 @@ fileT* find(queueT *q, char *filepath) {
if(!tmp)
goto _end_find_in_queue;
// creo una nuova istanza
/* create a new instance */
res = createFileT((tmp->data)->filepath, (tmp->data)->O_LOCK, (tmp->data)->owner, (tmp->data)->open);
if (!res) {
perror("createFileT res");
perror("find: createFileT");
goto _end_find_in_queue;
}
if (writeFileT(res, (tmp->data)->data, (tmp->data)->size) == -1) {
perror("writeFileT res");
perror("find: writeFileT");
destroyFile(res);
goto _end_find_in_queue;
}
UNLOCK_RETURN(&q->m, NULL); // end me
UNLOCK_RETURN(&q->m, NULL); /* end me */
return res;
_end_find_in_queue:
@ -767,14 +765,14 @@ _end_find_in_queue:
return NULL;
}
// cerco
/* search for file and return result of search */
int searchFile(queueT *q, char *filepath) {
if(!q || !filepath) {
errno = EINVAL;
return 0;
}
LOCK_RETURN(&q->m, 0); // begin me
LOCK_RETURN(&q->m, 0); /* begin me */
if (q->len == 0)
goto _end_search_file_in_queue;
@ -782,7 +780,7 @@ int searchFile(queueT *q, char *filepath) {
nodeT *tmp = q->head;
while (tmp) {
if (strcmp(filepath, (tmp->data)->filepath) == 0) { // trovato
if (strcmp(filepath, (tmp->data)->filepath) == 0) { /* found */
break;
}
tmp = tmp->next;
@ -791,7 +789,7 @@ int searchFile(queueT *q, char *filepath) {
if(!tmp)
goto _end_search_file_in_queue;
UNLOCK_RETURN(&q->m, 0); // end me
UNLOCK_RETURN(&q->m, 0); /* end me */
return 1;
_end_search_file_in_queue:
@ -799,7 +797,7 @@ _end_search_file_in_queue:
return 0;
}
// numero di elementi della queue
/* number of elements in queue */
size_t getLen(queueT *q) {
if(!q) {
errno = EINVAL;
@ -807,15 +805,15 @@ size_t getLen(queueT *q) {
}
size_t len = -1;
LOCK_RETURN(&q->m, -1); // begin me
LOCK_RETURN(&q->m, -1); /* begin me */
len = q->len;
UNLOCK_RETURN(&q->m, -1); // end me
UNLOCK_RETURN(&q->m, -1); /* end me */
return len;
}
// dimensione in byte
/* size in bytes of queue */
size_t getSize(queueT *q) {
if(!q) {
errno = EINVAL;
@ -823,11 +821,11 @@ size_t getSize(queueT *q) {
}
size_t size = -1;
LOCK_RETURN(&q->m, -1); // begin me
LOCK_RETURN(&q->m, -1); /* begin me */
size = q->size;
UNLOCK_RETURN(&q->m, -1); // end me
UNLOCK_RETURN(&q->m, -1); /* end me */
return size;
}
@ -835,12 +833,12 @@ void destroyQueue(queueT *q) {
if(!q)
return;
// no need for lock over queue
/* no need for lock over queue */
while (q->len > 0) {
errno = 0;
voidDequeue(q);
if (errno) {
perror("voiDequeue");
perror("destroyQueue: voidDequeue");
}
}

178
lib/threadpool/fileQueue.h
View File

@ -5,62 +5,62 @@
#include <stdio.h>
#include <pthread.h>
#include <conn.h>
#include "conn.h"
// struttura dati per gestire i file in memoria principale
/* struttura dati per gestire i file in memoria principale */
typedef struct {
char *filepath; // path assoluto del file
int O_LOCK; // 1 se il file e' in modalita' locked
int owner; // client che possiede la lock sul file
int open; // 1 se il file e' aperto
void *data; // contenuto del file
size_t size; // dimensione del file in bytes
size_t valid; // posizione fino a cui i dati sono validi
char *filepath; /* path assoluto del file */
int O_LOCK; /* 1 se il file e' in modalita' locked */
int owner; /* client che possiede la lock sul file */
int open; /* 1 se il file e' aperto */
void *data; /* contenuto del file */
size_t size; /* dimensione del file in bytes */
size_t valid; /* posizione fino a cui i dati sono validi */
} fileT;
// nodo di una linked list
/* nodo di una linked list */
typedef struct node {
fileT *data;
struct node *next;
} nodeT;
// coda FIFO
/* coda FIFO */
typedef struct {
nodeT *head; // puntatore al primo elemento
nodeT *tail; // puntatore all'ultimo elemento
size_t maxLen; // numero massimo di elementi
size_t len; // numero attuale di elementi
size_t maxSize; // dimensione massima
size_t size; // dimensione attuale
pthread_mutex_t m; // lock sulla coda
nodeT *head; /* puntatore al primo elemento */
nodeT *tail; /* puntatore all'ultimo elemento */
size_t maxLen; /* numero massimo di elementi */
size_t len; /* numero attuale di elementi */
size_t maxSize; /* dimensione massima */
size_t size; /* dimensione attuale */
pthread_mutex_t m; /* lock sulla coda */
} queueT;
/**
* Creazione di un fileT.
* \param f: string che identifica il fileT tramite il suo path assoluto
* \param O_LOCK: 1 locked, 0 unlocked
* \param client: client associato
* \param open: apertura del file dopo la creazione
* @param f: string che identifica il fileT tramite il suo path assoluto
* @param O_LOCK: 1 locked, 0 unlocked
* @param client: client associato
* @param open: apertura del file dopo la creazione
*
* \retval puntatore al fileT, NULL se errore (errno)
* @return puntatore al fileT, NULL se errore (errno)
*/
fileT* createFileT(char *f, int O_LOCK, int client, int open);
/**
* Append su un fileT.
* \param f: fileT sul quale scrivere
* \param data: puntatore al buffer da scrivere
* \param size: dimensione in bytes del buffer
* @param f: fileT sul quale scrivere
* @param data: puntatore al buffer da scrivere
* @param size: dimensione in bytes del buffer
*
* \retval 0 se successo, -1 se errore (errno)
* @return 0 se successo, -1 se errore (errno)
*/
int writeFileT(fileT *f, void *data, size_t size);
/**
* Rimozione di un fileT.
* \param f
* @param f
*/
void destroyFile(fileT *f);
@ -69,37 +69,37 @@ void destroyFile(fileT *f);
/**
* Alloca ed inizializza una coda di fileT. Deve essere chiamata da un solo
* thread.
* \param maxLen: lunghezza massima della coda
* \param maxSize: dimensione massima della coda in bytes
* @param maxLen: lunghezza massima della coda
* @param maxSize: dimensione massima della coda in bytes
*
* \retval puntatore alla coda allocata, NULL se errore
* @return puntatore alla coda allocata, NULL se errore
*/
queueT* createQueue(size_t maxLen, size_t maxSize);
/**
* Inserisce un fileT nella coda.
* \param q: puntatore alla coda
* \param data: puntatore al fileT da inserire
* @param q: puntatore alla coda
* @param data: puntatore al fileT da inserire
*
* \retval 0 se successo, -1 se errore (errno)
* @return 0 se successo, -1 se errore (errno)
*/
int enqueue(queueT *q, fileT* data);
/**
* Estrae un fileT dalla coda.
* \param q: puntatore alla coda
* @param q: puntatore alla coda
*
* \retval puntatore al file estratto, NULL se errore
* @return puntatore al file estratto, NULL se errore
*/
fileT* dequeue(queueT *q);
/**
* Estrae fileT dalla coda fino ad ottenere abbastanza spazio in q.
* \param q: puntatore alla coda
* \param filepath: file a cui bisogna aggiungere s di spazio
* \param s: dimensione da aggiungere al file
* @param q: puntatore alla coda
* @param filepath: file a cui bisogna aggiungere s di spazio
* @param s: dimensione da aggiungere al file
*
* \retval puntatore alla lista di file estratti (NULL terminated), NULL se errore
* @return puntatore alla lista di file estratti (NULL terminated), NULL se errore
*/
fileT ** dequeueN(queueT *q, char *filepath, size_t s);
@ -107,17 +107,17 @@ fileT ** dequeueN(queueT *q, char *filepath, size_t s);
* Estrae un fileT dalla coda come la dequeue, ma invece di restituire il
* file estratto lo distrugge immediatamente, liberandone la memoria.
*
* \param q: puntatore alla coda
* @param q: puntatore alla coda
*/
void voidDequeue(queueT *q);
/**
* Stampa l'intero contenuto della coda.
* \param stream: file su cui stampare
* \param q: puntatore alla coda da stampare
* @param stream: file su cui stampare
* @param q: puntatore alla coda da stampare
*
* \retval 0 se successo, -1 se errore (errno)
* @retval 0 se successo, -1 se errore (errno)
*/
int printQueue(FILE *stream, queueT *q);
@ -126,81 +126,81 @@ int printQueue(FILE *stream, queueT *q);
/**
* Cerca di ottenere il lock su un fileT, fallisce se un altro client ha gia'
* richiesto la lock
* \param q: puntatore alla coda che contiene il fileT
* \param filepath: path assoluto (identificatore) del fileT
* \param owner: client che ha richiesto l'operazione
* @param q: puntatore alla coda che contiene il fileT
* @param filepath: path assoluto (identificatore) del fileT
* @param owner: client che ha richiesto l'operazione
*
* \retval 0 se successo, -1 se errore (errno)
* @return 0 se successo, -1 se errore (errno)
*/
int lockFileInQueue(queueT *q, char *filepath, int owner);
/**
* Rilascia il lock di un file, fallisce se non si e' il possessore del lock
* \param q: puntatore alla coda che contiene il fileT
* \param filepath -> path assoluto (identificatore) del fileT
* \param owner -> client che ha richiesto l'operazione
* @param q: puntatore alla coda che contiene il fileT
* @param filepath -> path assoluto (identificatore) del fileT
* @param owner -> client che ha richiesto l'operazione
*
* \retval 0 se successo, -1 se errore (errno)
* @return 0 se successo, -1 se errore (errno)
*/
int unlockFileInQueue(queueT *q, char *filepath, int owner);
/**
* Apre un fileT contenuto nella coda. Fallisce se il lock appartiene a un
* client diverso.
* \param q: puntatore alla coda che contiene il fileT da aprire
* \param filepath: path assoluto (identificatore) del fileT da aprire
* \param O_LOCK: 1 locked, 0 unlocked
* \param owner: client che ha richiesto l'apertura
* @param q: puntatore alla coda che contiene il fileT da aprire
* @param filepath: path assoluto (identificatore) del fileT da aprire
* @param O_LOCK: 1 locked, 0 unlocked
* @param owner: client che ha richiesto l'apertura
*
* \retval 0 se successo, -1 se errore (errno)
* @return 0 se successo, -1 se errore (errno)
*/
int openFileInQueue(queueT *q, char *filepath, int O_LOCK, int owner);
/**
* Chiude un file contenuto nella coda. Ha successo se fileT non e' stato aperto.
* Fallisce se il file e' stato messo in modalita' locked da un client diverso.
* \param q: puntatore alla coda che contiene il fileT da chiudere
* \param filepath: path assoluto (identificatore) del fileT da chiudere
* \param owner: client che ha richiesto la chiusura
* @param q: puntatore alla coda che contiene il fileT da chiudere
* @param filepath: path assoluto (identificatore) del fileT da chiudere
* @param owner: client che ha richiesto la chiusura
*
* \retval 0 se successo, -1 se errore (errno)
* @return 0 se successo, -1 se errore (errno)
*/
int closeFileInQueue(queueT *q, char *filepath, int owner);
/**
* Scrive del contenuto su un fileT all'interno della coda. Fallisce se il file
* non e' stato aperto o se il lock appartiene a un client diverso.
* \param q: puntatore alla coda che contiene il fileT su cui scrivere
* \param filepath: path assoluto (identificatore) del fileT
* \param data: buffer che contiene i dati
* \param size: dimensione in bytes del buffer
* \param owner: client che ha richiesto l'operazione di scrittura
* @param q: puntatore alla coda che contiene il fileT su cui scrivere
* @param filepath: path assoluto (identificatore) del fileT
* @param data: buffer che contiene i dati
* @param size: dimensione in bytes del buffer
* @param owner: client che ha richiesto l'operazione di scrittura
*
* \retval 0 se successo, -1 se errore (errno)
* @return 0 se successo, -1 se errore (errno)
*/
int writeFileInQueue(queueT *q, char *filepath, void *data, size_t size, int owner);
/**
* Scrive del contenuto in append su un fileT all'interno della coda. Fallisce
* se il file non e' stato aperto o se il lock appartiene a un client diverso.
* \param q: puntatore alla coda che contiene il fileT su cui effettuare l'append
* \param filepath: path assoluto (identificatore) del fileT
* \param data: buffer che contiene i dati
* \param size: dimensione in bytes del buffer
* \param owner: client che ha richiesto l'operazione di append
* @param q: puntatore alla coda che contiene il fileT su cui effettuare l'append
* @param filepath: path assoluto (identificatore) del fileT
* @param data: buffer che contiene i dati
* @param size: dimensione in bytes del buffer
* @param owner: client che ha richiesto l'operazione di append
*
* \retval 0 se successo, -1 se errore (setta errno)
* @return 0 se successo, -1 se errore (setta errno)
*/
int appendFileInQueue(queueT *q, char *filepath, void *data, size_t size, int owner);
/**
* Rimuove un fileT dalla coda. Fallisce se non si è in possesso della lock o se
* la lock e' posseduta da un client diverso.
* \param q: puntatore alla coda che contiene il fileT da rimuovere
* \param filepath: path assoluto (identificatore) del fileT da rimuovere
* \param owner: client che ha richiesto la rimozione
* @param q: puntatore alla coda che contiene il fileT da rimuovere
* @param filepath: path assoluto (identificatore) del fileT da rimuovere
* @param owner: client che ha richiesto la rimozione
*
* \retval 0 se successo, -1 se errore (errno)
* @return 0 se successo, -1 se errore (errno)
*/
int removeFileFromQueue(queueT *q, char *filepath, int owner);
@ -208,42 +208,42 @@ int removeFileFromQueue(queueT *q, char *filepath, int owner);
/**
* Cerca un fileT nella coda e ritorna una copia.
* \param q: puntatore alla coda sulla quale cercare il fileT
* \param filepath: path assoluto del fileT da cercare
* @param q: puntatore alla coda sulla quale cercare il fileT
* @param filepath: path assoluto del fileT da cercare
*
* \retval puntatore a una copia del fileT se trovato, NULL se non trovato o errore (errno)
* @return puntatore a una copia del fileT se trovato, NULL se non trovato o errore (errno)
*/
fileT* find(queueT *q, char *filepath);
/**
* Cerca il fileT nella coda e ritorna il siultato dell'operazione
* \param q: puntatore alla coda sulla quale cercare il fileT
* \param filepath: path assoluto del fileT da cercare
* @param q: puntatore alla coda sulla quale cercare il fileT
* @param filepath: path assoluto del fileT da cercare
*
* \retval 0 se non trovato, 1 se trovato
* @return 0 se non trovato, 1 se trovato
*/
int searchFile(queueT *q, char *filepath);
/**
* Numero di elementi presenti nella coda.
* \param q: puntatore alla coda
* @param q: puntatore alla coda
*
* \retval numero di elementi presenti, -1 se errore (errno)
* @return numero di elementi presenti, -1 se errore (errno)
*/
size_t getLen(queueT *q);
/**
* Restituisce la dimensione attuale della coda in bytes.
* \param q: puntatore alla coda
* @param q: puntatore alla coda
*
* \retval dimensione della coda in bytes, -1 se errore (errno)
* @return dimensione della coda in bytes, -1 se errore (errno)
*/
size_t getSize(queueT *q);
/**
* Cancella una coda allocata con createQueue e ne libera la memoria.
* \param q: puntatore alla coda da distruggere
* @param q: puntatore alla coda da distruggere
*/
void destroyQueue(queueT *q);
#endif // _FILE_QUEUE
#endif /* _FILE_QUEUE */