void eliminarPrograma(int pid) { int i; for(i=0; i<config->cantidad_paginas; i++) { //si encuentra un registro con el mismo processID, hace la baja logica y libera el espacio en el bitmap if(tabla[i].pid==pid) { tabla[i].pid=-1; tabla[i].page=-1; bitarray_clean_bit(bitMap,i); } } }
void moverFrame(int frame_origen, int frame_destino) { pagina pag; //setea el frame donde se va mover en 1 bitarray_set_bit(bitMap,frame_destino); //trae la pagina del frame origen y la escribe en el frame destino pag = leerPaginaFromFrame(frame_origen); escribirPaginaEnFrame(frame_destino,pag); free(pag); tabla[frame_destino].page = tabla[frame_origen].page; tabla[frame_destino].pid = tabla[frame_origen].pid; tabla[frame_origen].page = -1; tabla[frame_origen].pid = -1; bitarray_clean_bit(bitMap,frame_origen); }
static int grasa_truncate(const char *path, off_t offset) { pthread_mutex_lock(&mutex); int pos_archivo = obtener_bloque_archivo(path); pthread_mutex_unlock(&mutex); //Achicar archivo if(nodos[pos_archivo].file_size > offset) // Si el offset es mas chico que el tamaño del archivo, va a achicarlo //tengo que liberar bloques de datos { int cant_bloques = (offset / BLOCK_SIZE); int i = (cant_bloques / 1024); //Subindice Array[1000] int j = (cant_bloques % 1024); //Subindice Array[1024] int off_bloque = (offset % BLOCK_SIZE); if(offset == 0) // (cant_bloques == 0) && (off_bloque == 0) //Borrar archivo completo { while((nodos[pos_archivo].blk_indirect[i] != 0) && (i < 1000)) { pthread_mutex_lock(&mutex); ptrGBloque *blk_direct = (ptrGBloque *) (data_disco + nodos[pos_archivo].blk_indirect[i] * BLOCK_SIZE);//blk_direct = Array[1024] pthread_mutex_unlock(&mutex); while((blk_direct[j] != 0) && (j < 1024)) { pthread_mutex_lock(&mutex); bitarray_clean_bit(bitmap, blk_direct[j]); char *bloque_dato = (char *) data_disco + blk_direct[j] * BLOCK_SIZE; bzero(bloque_dato, BLOCK_SIZE); blk_direct[j] = 0; pthread_mutex_unlock(&mutex); ++j; } pthread_mutex_lock(&mutex); bitarray_clean_bit(bitmap, nodos[pos_archivo].blk_indirect[i]);//Borra Array[1024] nodos[pos_archivo].blk_indirect[i] = 0; pthread_mutex_unlock(&mutex); ++i; } pthread_mutex_lock(&mutex); nodos[pos_archivo].file_size = 0; pthread_mutex_unlock(&mutex); return 0; } if((cant_bloques == 0) && (off_bloque > 0)) //Menos de un bloque , el offset me para en la mitad del primer bloque entonces tengo que liberar todos los bloques que le siguen a ese, //me muevo al bloque siguiente y empiezo a liberar { while((nodos[pos_archivo].blk_indirect[i] != 0) && (i < 1000)) { pthread_mutex_lock(&mutex); ptrGBloque *blk_direct = (ptrGBloque *) (data_disco + nodos[pos_archivo].blk_indirect[i] * BLOCK_SIZE); pthread_mutex_unlock(&mutex); ++j; while((blk_direct[j] != 0) && (j < 1024)) { pthread_mutex_lock(&mutex); bitarray_clean_bit(bitmap, blk_direct[j]); char *bloque_dato = (char *) data_disco + blk_direct[j] * BLOCK_SIZE; bzero(bloque_dato, BLOCK_SIZE); blk_direct[j] = 0; pthread_mutex_unlock(&mutex); ++j; } if(i > 0) { pthread_mutex_lock(&mutex); bitarray_clean_bit(bitmap, nodos[pos_archivo].blk_indirect[i]); nodos[pos_archivo].blk_indirect[i] = 0; pthread_mutex_unlock(&mutex); } ++i; } return 0; } if(cant_bloques > 0) //1 Bloque entero y un poco mas || N Bloques enteros y un poco mas { if(off_bloque > 0) //Valido si estoy en la mitad del bloque, si es asi, paso al siguiente { ++j; if(j == 1024) { ++i; if(i == 1000) { return -1; } j = 0; } } while((nodos[pos_archivo].blk_indirect[i] != 0) && (i < 1000)) { pthread_mutex_lock(&mutex); ptrGBloque *blk_direct = (ptrGBloque *) (data_disco + nodos[pos_archivo].blk_indirect[i] * BLOCK_SIZE); pthread_mutex_unlock(&mutex); while((blk_direct[j] != 0) && (j < 1024)) { pthread_mutex_lock(&mutex); bitarray_clean_bit(bitmap, blk_direct[j]); char *bloque_dato = (char *) data_disco + blk_direct[j] * BLOCK_SIZE; bzero(bloque_dato, BLOCK_SIZE); blk_direct[j] = 0; pthread_mutex_unlock(&mutex); ++j; } if(blk_direct[0] == 0) //Si tengo un bloque de datos en la posicion 0, no borro el array[1024] { pthread_mutex_lock(&mutex); bitarray_clean_bit(bitmap, nodos[pos_archivo].blk_indirect[i]); nodos[pos_archivo].blk_indirect[i] = 0; pthread_mutex_unlock(&mutex); } ++i; } return 0; } } //Hasta aca chequeado //Agrandar archivo if(nodos[pos_archivo].file_size < offset) { pthread_mutex_lock(&mutex); int cant_bloques = (nodos[pos_archivo].file_size / BLOCK_SIZE); int i = (cant_bloques / 1024); //Subindice Array[1000] int j = (cant_bloques % 1024); //Subindice Array[1024] int off_bloque = (nodos[pos_archivo].file_size % BLOCK_SIZE); pthread_mutex_unlock(&mutex); if (nodos[pos_archivo].file_size == 0) //el archivo es nuevo { int bytes_por_reservar = offset; int bytes_reservados = 0; pthread_mutex_lock(&mutex); reservar_bloque_directo(pos_archivo, i); //Array[1024] ptrGBloque *blk_direct = (ptrGBloque *) (data_disco + nodos[pos_archivo].blk_indirect[i] * BLOCK_SIZE); pthread_mutex_unlock(&mutex); while(bytes_por_reservar > bytes_reservados) { pthread_mutex_lock(&mutex); reservar_bloque_datos(blk_direct, j); pthread_mutex_unlock(&mutex); bytes_reservados += BLOCK_SIZE; bytes_por_reservar -= bytes_reservados; ++j; if(j == 1024) { ++i; if(i < 1000) { pthread_mutex_lock(&mutex); reservar_bloque_directo(pos_archivo, i); blk_direct = (ptrGBloque *) (data_disco + nodos[pos_archivo].blk_indirect[i] * BLOCK_SIZE); pthread_mutex_unlock(&mutex); j = 0; } else { return -1; } } } return 0; } else //filesize > 0 El archivo ya tiene datos grabados { int bytes_por_reservar = offset - nodos[pos_archivo].file_size; int bytes_reservados = 0; while(bytes_por_reservar > bytes_reservados) { if(nodos[pos_archivo].blk_indirect[i] == 0) { pthread_mutex_lock(&mutex); reservar_bloque_directo(pos_archivo, i); pthread_mutex_unlock(&mutex); j = 0; } pthread_mutex_lock(&mutex); ptrGBloque *blk_direct = (ptrGBloque *) (data_disco + nodos[pos_archivo].blk_indirect[i] * BLOCK_SIZE); pthread_mutex_unlock(&mutex); if(blk_direct[j] == 0) { pthread_mutex_lock(&mutex); reservar_bloque_datos(blk_direct, j); pthread_mutex_unlock(&mutex); bytes_reservados += BLOCK_SIZE; bytes_por_reservar -= bytes_reservados; } ++j; if(j == 1024) { ++i; if(i < 1000) { pthread_mutex_lock(&mutex); reservar_bloque_directo(pos_archivo, i); blk_direct = (ptrGBloque *) (data_disco + nodos[pos_archivo].blk_indirect[i] * BLOCK_SIZE); pthread_mutex_unlock(&mutex); j = 0; } else { return -1; } } else { bytes_reservados += (offset - bytes_por_reservar); bytes_por_reservar -= bytes_reservados; } } } return 0; } return 0; }