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;
}
