writeFile function

lib/threadpool/fileQueue.c

@@ -21,6 +21,7 @@ fileT* createFileT(char *f, int O_LOCK, int client, int open){
     f->owner = client;
     f->open = (open == 0)? 0 : 1;
     f->size = 0;
+    f->valid = 0;
 
     if ((f->filepath = malloc(sizeof(char)*NAMELEN)) == NULL) {
 	perror("Malloc filepath");
@@ -44,13 +45,14 @@ int writeFileT(fileT *f, void *data, size_t size) {
 	return -1;
     }
 
-    if ((f->data = realloc(f->data, f->size + size)) == NULL) {
+    if ((f->data = realloc(f->data, f->valid + size)) == NULL) {
 	perror("Realloc content");
 	return -1;
     }
 
-    memcpy((char*) f->data + f->size, data, size);
-    f->size = f->size + size;
+    memcpy((char*) f->data + f->valid, data, size);
+    f->valid = f->valid + size;
+    f->size = (f->valid>f->size)?f->valid:f->size;
 }
 
 // destroy fileT
@@ -158,6 +160,8 @@ fileT* dequeue(queueT *q) {
 
     LOCK_RETURN(&q->m, NULL); // begin me
 
+    // TODO: altri oltre fifo
+
     if (q->head == NULL || q->len == 0) { // coda vuota
 	errno = ENOENT;
 	goto _end_dequeue;
@@ -185,6 +189,91 @@ _end_dequeue:
     return NULL;
 }
 
+
+// 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;
+	return NULL;
+    }
+    if(s<=0) {
+	return NULL;
+    }
+
+    LOCK_RETURN(&q->m, NULL); // begin me
+
+    /* TODO: altri oltre a fifo */
+
+    if (q->head == NULL || q->len == 0) { // coda vuota
+	errno = ENOENT;
+	goto _end_dequeueN;
+    }
+
+    if(q->maxSize > s) {
+	errno = EINVAL;
+	goto _end_dequeueN;
+    }
+
+    // scorro la queue per trovare l'elemento
+    nodeT *tmp = q->head;
+    while (tmp) {
+	if (strcmp(filepath, (tmp->data)->filepath) == 0) { // trovato
+	    break;
+	}
+	tmp = tmp->next;
+    }
+
+    if(!tmp) { // non trovato
+	errno = ENOENT;
+	goto _end_dequeueN;
+    }
+
+    if ((tmp->data)->open == 0 || ((tmp->data)->O_LOCK && (tmp->data)->owner != owner)) {
+	// if file non è aperto o la lock non è del owner
+	errno = EPERM;
+	goto _end_dequeueN;
+    }
+
+    fileT **returnList = NULL; // lista dei file rimossi
+    nodeT *tmp = NULL;
+
+    returnList = calloc(1, sizeof(fileT*));
+    returnList[0] = NULL;
+
+    int purged = 0;
+    while(q->size + s > q->maxSize) {
+	purged++;
+	returnList = realloc(purged, sizeof(fileT*));
+	if(!returnList) {
+	    perror("realloc");
+	    goto _end_dequeueN;
+	}
+	tmp = q->head;
+	q->head = (q->head)->next;
+
+	returnList[purged-1] = tmp->data;
+	--q->len;
+	q->size -= tmp->data->size;
+
+	if (q->head == NULL) { // coda diventa vuota
+	    q->tail = NULL;
+	    break; // we eliminated everything so we must have enought space
+	}
+    }
+    returnList = realloc(purged+1, sizeof(fileT*));
+    returnList[purged] = NULL; // null terminated
+
+    tmp->data->size += size;
+    q->size += size;
+
+    UNLOCK_RETURN(&q->m, NULL); // end me
+    return data;
+
+_end_dequeueN:
+    UNLOCK_RETURN(&q->m, NULL);
+    return NULL;
+}
+
 void voidDequeue(queueT *q) {
     if(!q) {
 	errno = EINVAL;
@@ -217,8 +306,8 @@ void voidDequeue(queueT *q) {
     return;
 
 _end_void_dequeue:
-    UNLOCK_RETURN(&q->m, NULL);
-    return NULL;
+    UNLOCK(&q->m);
+    return;
 }
 
 // print queue
@@ -239,6 +328,7 @@ int printQueue(FILE *stream, queueT *q) {
     fprintf(stream, "[Nome File] -> Dimensione in MB");
     while (temp!=NULL) {
 	float res = ((float)(tmp->data)->size)/1000000; // in MB
+	// float res = ((float)(tmp->data)->valid)/1000000; // in MB
 	fprintf(stream, "[%s]\t-> %f MB\n", (tmp->data)->filepath, res);
 	temp = temp->next;
     }
@@ -483,13 +573,14 @@ int writeFileInQueue(queueT *q, char *filepath, void *data, size_t size, int own
     }
 
     // scrivo
-    if (((tmp->data)->data = realloc((tmp->data)->data, (tmp->data)->size + size)) == NULL) {
+    if (((tmp->data)->data = realloc((tmp->data)->data, size)) == NULL) {
 	perror("Realloc content");
 	goto _end_write_file_queue;
     }
     memcpy((tmp->data)->data, data, size);
 
     q->size = (q->size) - ((tmp->data)->size) + size;
+    (tmp->data)->valid = size;
     (tmp->data)->size = size;
 
     UNLOCK_RETURN(&q->m, -1); // end me
@@ -542,15 +633,17 @@ int appendFileInQueue(queueT *q, char *filepath, void *data, size_t size, int ow
     }
 
     // scrivo
-    if (((tmp->data)->data = realloc((tmp->data)->data, (tmp->data)->size + size)) == NULL) {
+    if (((tmp->data)->data = realloc((tmp->data)->data, (tmp->data)->valid + size)) == NULL) {
 	perror("Realloc content");
 	goto _end_append_file_queue;
     }
 
-    memcpy(((tmp->data)->data) + (tmp->data)->size, data, size);
+    memcpy(((tmp->data)->data) + (tmp->data)->valid, data, size);
     // memmove sarebbe un'alternativa
-    (tmp->data)->size += size;
-    q->size += size;
+    (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
     return 0;