Exemplo n.º 1
0
void mostrarIA(struct superbloque SB) {
    char atime[80], mtime[80],cttime[80],*tipo,perm[3];
    struct inodo in;
    int ninodo;
    struct tm *ts;
    printf("\n\n \t*****Array de Inodos*****\n");
    printf("#Tamaño Inodo: %d\n",TAM_INODO);
    for(ninodo=0; ninodo<SB.totInodos; ninodo++) {
        in = leer_inodo(ninodo);
        if(in.tipo!='l') {
            ts = localtime(&in.atime);
            strftime(atime, sizeof(atime), "%a %Y-%m-%d %H:%M:%S", ts);
            ts = localtime(&in.mtime);
            strftime(mtime, sizeof(mtime), "%a %Y-%m-%d %H:%M:%S", ts);
            ts = localtime(&in.ctime);
            strftime(cttime, sizeof(cttime), "%a %Y-%m-%d %H:%M:%S", ts);
            perm[0]= ((unsigned char)in.permisos&(unsigned char)1)==0 ?'-':'X';
            perm[1]=((unsigned char)in.permisos&(unsigned char)2)==0?'-':'W';
            perm[2]=((unsigned char)in.permisos&(unsigned char)4)==0?'-':'R';
            tipo=in.tipo=='d'? "Directorio" : "Fichero";
            printf("#ID: %d TIPO: %s PERMISOS: %c%c%c NLINKS: %d TAMAÑO: %d BLOQUES OCUPADOS: %d \n",ninodo,tipo,perm[0], perm[1], perm[2], in.nlinks,in.tamEnBytesLog,in.numBloquesOcupados);
            printf(" ATIME: %s MTIME: %s CTIME: %s\n\n",atime,mtime,cttime);
        }
    }
}
Exemplo n.º 2
0
int liberar_inodo(unsigned int ninodo) {
    struct superbloque sb;
    struct inodo inodoAux;
    unsigned int blogico = 0;

    if (bread(posSB, &sb) == -1) {
        printf("Error: ficheros_basico.c > liberar_inodo > al intentar leer el superbloque \n");
        return -1;
    }
    inodoAux = leer_inodo(ninodo);
    liberar_bloques_inodo(ninodo, blogico);

    inodoAux.tipo = 'l';
    inodoAux.ctime = time(NULL);
    // Enlazamos el primer inodo libre 
    inodoAux.punterosDirectos[0] = sb.posPrimerInodoLibre;
    sb.posPrimerInodoLibre = ninodo;
    sb.cantInodosLibres++;

    if (escribir_inodo(inodoAux, ninodo) == -1) {
        printf("Error: ficheros_basico.c > liberar_inodo > al intentar liberar inodo \n");
        return -1;
    }
    
    if (bwrite(posSB, &sb) == -1) {
        printf("Error: ficheros_basico.c > reservar_inodo > al intentar actualizar el superbloque \n");
        return -1;
    }
    return ninodo;
}
Exemplo n.º 3
0
/*Trunca (corta) un fichero/directorio (ninodo) pasado por argumento a los bytes (nbytes) pasados por argumento, liberando los bloques que no hagan falta
 * si nbytes = 0 lo liberamos TODO
 */
int mi_truncar_f(unsigned int ninodo, unsigned int nbytes) {
    struct inodo inode;

    inode = leer_inodo(ninodo);
    if ((inode.permisos & 2) != 2) { //Si no tenemos permisos de lectura devolvemos un error
        return -1;
    }

    if (nbytes == 0) {//liberamos todo el inodo		
        liberar_inodo(ninodo);
    } else {
        //liberamos a partir del bloque correspondiente del nbyte

        if (liberar_bloques_inodo(ninodo, nbytes) < 0) {
            printf("ERROR: ficheros_basic.c -> (metodo) -> descripcion error.\n");
            return -1;
        }

    }

    //actualizamos el inodo
    inode.mtime = time(NULL);
    inode.ctime = time(NULL);
    inode.tamEnBytesLog = nbytes;

    escribir_inodo(inode, ninodo); //guardamos el inodo

    mi_signalSem();
    return 0;
}
Exemplo n.º 4
0
int mi_chmod_f(unsigned int ninodo, unsigned char modo) {
    struct inodo inode;
    inode = leer_inodo(ninodo);
    inode.permisos = modo;
    inode.ctime = time(NULL);
    escribir_inodo(inode, ninodo);

    return 1;
}
Exemplo n.º 5
0
int mi_chmod_f(unsigned int ninodo, unsigned char modo) {
    // Creamos una estructura inodo.
	struct inodo Inodo;
    // Leemos el inodo indicado.
	Inodo = leer_inodo(ninodo);
    // Cambiamos los permisos del inodo.
	Inodo.permisos = modo;
    // Modificamos la variable ctime.
	Inodo.ctime = time(NULL);
    // Actualizamos el inodo.
	escribir_inodo(Inodo, ninodo);
}
Exemplo n.º 6
0
int mi_stat_f(unsigned int ninodo, struct STAT *p_stat) {
    struct inodo inode;
    inode = leer_inodo(ninodo);

    p_stat -> tipo = inode.tipo; //Tipo (libre, directorio o fichero)
    p_stat -> permisos = inode.permisos; //Permisos (lectura y/o escritura y/o ejecución)
    p_stat -> atime = inode.atime; //Fecha y hora del último acceso a datos: atime
    p_stat -> mtime = inode.mtime; //Fecha y hora de la última modificación de datos: mtime
    p_stat -> ctime = inode.ctime; //Fecha y hora de la última modificación del inodo: ctime
    p_stat -> nlinks = inode.nlinks; //Cantidad de enlaces de entradas en directorio
    p_stat -> tamEnBytesLog = inode.tamEnBytesLog; //Tamaño en bytes lógicos
    p_stat -> numBloquesOcupados = inode.numBloquesOcupados; //Cantidad de bloques ocupados en la zona de datos

    return 0;
}
Exemplo n.º 7
0
int mi_stat_f(unsigned int ninodo, struct STAT *p_stat) {
    // Creamos una estructura inodo.
	struct inodo Inodo;
	struct STAT stat;
    // Leemos el inodo indicado por parámetro.
	Inodo = leer_inodo(ninodo);
    // Asignamos información a la estructura STAT.
	stat.tipo = Inodo.tipo;
	stat.tamEnBytesLog = Inodo.tamEnBytesLog;
	stat.permisos = Inodo.permisos;
	stat.numBloquesOcupados = Inodo.numBloquesOcupados;
	stat.nlinks = Inodo.nlinks;
	stat.mtime = Inodo.mtime;
	stat.ctime = Inodo.ctime;
	stat.atime = Inodo.atime;

	*p_stat = stat;

}
Exemplo n.º 8
0
int main(int argc, char **argv){

	
	if(argc<3){
		printf("\nescribir: Error debe escribir: $ ./escribir <nombre_fichero> <offset> <inodo(opcinal)>\n");
		printf("*Si no indica el inodo el sistema se encargará de reservar un inodo nuevo.\n");
		return -1;
	}
	struct INODO inodo;
	int ninodo;
	char ruta[128];
	long nbytes;
	long offset = atoi(argv[2]);
	printf("\nescribir: Escribe la ruta del fichero: ");
	scanf("%s",ruta);
	FILE *fichero = fopen(ruta,"r");
	fseek(fichero, 0, SEEK_END); // Colocar el cursor al final del fichero
	nbytes = ftell(fichero); // Tamaño en bytes
	printf("\nescribir: El tamaño del fichero es: %ld\n",nbytes);
	char entrada[nbytes];
	fseek(fichero,0,0);
	fscanf(fichero,"%s",entrada);
	fclose(fichero);
	
	//Montamos el dispositivo.
	printf("\nescribir: Montando el dispositivo...\n");	
	bmount(argv[1]);//nombre_fichero
	printf("\nescribir: El dispositivo se ha montado con éxito.\n");
	
	//Si el inodo se pasa como argumento
	if(argc == 4){
		ninodo = atoi(argv[3]);
	}else{
		//Reservamos el inodo.
		ninodo = reservar_inodo('f',6);
	}

	inodo = leer_inodo(ninodo);
	
	//IMPRIMIR INODO 
	printf("\nNº INODO %i:\n",ninodo);
	printf("Tipo: %c\n",inodo.tipo);
	printf("Permisos: %i\n",inodo.permisos);
	printf("Nº enlaces: %i\n",inodo.nlinks);
	printf("Bytes lógicos: %i\n",inodo.tamEnBytesLog);
	printf("Bloques ocupados: %i\n",inodo.numBloquesOcupados);
	//ESCRITURA 
	if(mi_write_f(ninodo,entrada,offset,nbytes)!=nbytes){
		printf("\nescribir: ERROR, no se ha escrito en el fichero correctamente.\n");
		return -1;
	}
	//LECTURA 
	printf("\nescribir:Se ha leído lo siguiente con el offset %ld:\n",offset);
	if(mi_read_f(ninodo,entrada,offset,nbytes)!=nbytes){
		printf("\nescribir: ERROR, no se ha leído en el fichero correctamente.\n");
		return -1;
	}
	write(1,entrada,nbytes);
	printf("\n\nInodo Actualizado:\n");
	inodo = leer_inodo(ninodo);
	//IMPRIMIR INODO
	printf("\nNº INODO %i:\n",ninodo);
	printf("Tipo: %c\n",inodo.tipo);
	printf("Permisos: %i\n",inodo.permisos);
	printf("Nº enlaces: %i\n",inodo.nlinks);
	printf("Bytes lógicos: %i\n",inodo.tamEnBytesLog);
	printf("Bloques ocupados: %i\n",inodo.numBloquesOcupados);
	
	//Desmontamos el dispositivo.
	printf("\nescribir: Desmontando el dispositivo...\n\n");
	bumount();
	printf("\nescribir: Dispositivo desmontado con éxito.\n");
	
	return 0;
}
Exemplo n.º 9
0
int traducir_bloque_inodo(unsigned int ninodo, unsigned int blogico, unsigned int *bfisico, char reservar) {

    int nPunterosDirectos = 12;
    int nPuntInd0 = BLOCKSIZE / 4;
    int nPuntInd1 = nPuntInd0 * nPuntInd0;
    int nPuntInd2 = nPuntInd0 * nPuntInd0 * nPuntInd0;
    int numPunt = BLOCKSIZE / 4;

    struct inodo inodoAux = leer_inodo(inodo);

    if (blogico < nPunterosDirectos) { //Si el puntero es directo
        if (reservar == '0') {
            if (inodoAux.punterosDirectos[blogico] == 0) { //si el bloque físico no existe
                return -1;
            } else {
                *bfisico = inodoAux.punterosDirectos[blogico]; //hallamos el bloque físico
            }
        }
        if (reservar == '1') {
            if (inodoAux.punterosDirectos[blogico] == 0) { //si el bloque físico no existe
                inodoAux.punterosDirectos[blogico] = reservar_bloque(); //reservamos el bloque 
                //asignamos el bloque reservado al bloque físico
                *bfisico = inodoAux.punterosDirectos[blogico];
                inodoAux.numBloquesOcupados++;
                escribir_inodo(inod, inodo);
            }
            *bfisico = inodoAux.punterosDirectos[blogico];
        }

    } else if (blogico < nPunterosDirectos + nPuntInd0) { //puntero indirecto de nivel 0
        if (reservar == '0') {
            if (inodoAux.punterosIndirectos[0] == 0) {
                return -1;
            } else {
                int array[nPuntInd0];
                bread(inodoAux.punterosIndirectos[0], array);
                if (array[blogico - nPunterosDirectos] == 0) { //si el puntero leido no apunta a un bloque de datos
                    return -1;
                } else { //si existe el bloque físico de datos
                    *bfisico = array[blogico - nPunterosDirectos];
                }
            }
        }

        if (reservar == '1') {
            if (inodoAux.punterosIndirectos[0] == 0) { //si el puntero indirecto de nivel 0 no apunta a nada
                int bufferPunt0[nPuntInd0];
                memset(bufferPunt0, 0, BLOCKSIZE);
                inodoAux.punterosIndirectos[0] = reservar_bloque(); // reservamos el bloque de punteros indirectos
                bufferPunt0[blogico - nPunterosDirectos] = reservar_bloque(); //reservamos el bloque de datos
                inodoAux.numBloquesOcupados++;
                bwrite(inodoAux.punterosIndirectos[0], bufferPunt0); //escribimos el bloque reservado
                *bfisico = bufferPunt0[blogico - nPunterosDirectos];
                escribir_inodo(inod, inodo);

            } else {
                int array[nPuntInd0];
                bread(inodoAux.punterosIndirectos[0], array);
                //miramos si existe el bloque físico de datos
                // si no existe reservaremos el bloque
                if (array[blogico - nPunterosDirectos] == 0) {
                    array[blogico - nPunterosDirectos] = reservar_bloque();
                    bwrite(inodoAux.punterosIndirectos[0], array); //escribimos el bloque para guardar los cambios
                    inodoAux.numBloquesOcupados++;
                    escribir_inodo(inod, inodo);
                }
                *bfisico = array[blogico - nPunterosDirectos];
            }
        }

        // puntero indirecto nivel 1
    } else if (blogico < nPunterosDirectos + nPuntInd0 + nPuntInd1) {
        int puntNiv0 = (blogico - (nPunterosDirectos + nPuntInd0)) % nPuntInd0; //puntero nivel 0
        int puntNiv1 = (blogico - (nPunterosDirectos + nPuntInd0)) / nPuntInd0; //puntero nivel 1

        if (reservar == '0') {
            if (inodoAux.punterosIndirectos[1] == 0) {
                return -1;
            } else {
                int array[numPunt];
                bread(inodoAux.punterosIndirectos[1], array);
                if (array[puntNiv1] == 0) {

                    return -1;
                } else {
                    bread(array[puntNiv1], array);
                    if (array[puntNiv0] == 0) {
                        return -1;
                    } else {
                        *bfisico = array[puntNiv0];
                    }
                }
            }
        }
        if (reservar == '1') {
            int buffer[numPunt];
            int bufferPunt1[numPunt];
            int bufferPunt0[numPunt];

            if (inodoAux.punterosIndirectos[1] == 0) {
                inodoAux.punterosIndirectos[1] = reservar_bloque();
                memset(bufferPunt1, 0, BLOCKSIZE);
                bwrite(inodoAux.punterosIndirectos[1], bufferPunt1);
            }
            bread(inodoAux.punterosIndirectos[1], bufferPunt1);
            if (bufferPunt1[puntNiv1] == 0) {
                bufferPunt1[puntNiv1] = reservar_bloque();
                memset(bufferPunt0, 0, BLOCKSIZE);
                bwrite(inodoAux.punterosIndirectos[1], bufferPunt1);
                bwrite(bufferPunt1[puntNiv1], bufferPunt0);
            }
            bread(bufferPunt1[puntNiv1], buffer);
            if (buffer[puntNiv0] == 0) {
                buffer[puntNiv0] = reservar_bloque();
                inodoAux.numBloquesOcupados++;
                bwrite(bufferPunt1[puntNiv1], buffer);
            }
            escribir_inodo(inod, inodo);
            *bfisico = buffer[puntNiv0];
        }
        //puntero indirecto nivel 2
    } else if (blogico < nPunterosDirectos + nPuntInd0 + nPuntInd1 + nPuntInd2) {
        int puntNiv2 = (blogico - (nPunterosDirectos + nPuntInd0 + nPuntInd1)) / nPuntInd1;
        int puntNiv1 = ((blogico - (nPunterosDirectos + nPuntInd0 + nPuntInd1)) % nPuntInd1) / nPuntInd0;
        int puntNiv0 = ((blogico - (nPunterosDirectos + nPuntInd0 + nPuntInd1)) % nPuntInd1) % nPuntInd0;

        if (reservar == '0') {
            if (inodoAux.punterosIndirectos[2] == 0) {
                return -1;
            } else {
                int array[numPunt];
                bread(inodoAux.punterosIndirectos[2], array);
                if (array[puntNiv2] == 0) {
                    return -1;
                } else {
                    bread(array[puntNiv2], array);
                    if (array[puntNiv1] == 0) {
                        return -1;
                    } else {
                        bread(array[puntNiv1], array);
                        if (array[puntNiv0] == 0) {
                            return -1;
                        } else {
                            *bfisico = array[puntNiv0];
                        }
                    }
                }
            }
        }
        if (reservar == '1') {
            int buffer[numPunt];
            int bufferPunt1[numPunt];
            int bufferPunt2[numPunt];
            if (inodoAux.punterosIndirectos[2] == 0) {
                inodoAux.punterosIndirectos[2] = reservar_bloque();
                memset(bufferPunt2, 0, BLOCKSIZE);
                bwrite(inodoAux.punterosIndirectos[2], bufferPunt2);

            }
            bread(inodoAux.punterosIndirectos[2], bufferPunt2);
            if (bufferPunt2[puntNiv2] == 0) {
                bufferPunt2[puntNiv2] = reservar_bloque();
                memset(bufferPunt1, 0, BLOCKSIZE);
                bwrite(inodoAux.punterosIndirectos[2], bufferPunt2);
                bwrite(bufferPunt2[puntNiv2], bufferPunt1);
            }

            bread(bufferPunt2[puntNiv2], bufferPunt1);
            if (bufferPunt1[puntNiv1] == 0) {
                bufferPunt1[puntNiv1] = reservar_bloque();
                int bufPunt0[numPunt];
                memset(bufPunt0, 0, BLOCKSIZE);
                bwrite(bufferPunt2[puntNiv2], bufferPunt1);
                bwrite(bufferPunt1[puntNiv1], bufPunt0);
            }
            bread(bufferPunt1[puntNiv1], buffer);
            if (buffer[puntNiv0] == 0) {
                buffer[puntNiv0] = reservar_bloque();
                inodoAux.numBloquesOcupados++;
                escribir_inodo(inod, inodo);
                bwrite(bufferPunt1[puntNiv1], buffer);

            }
            *bfisico = buffer[puntNiv0];
        }
    }
    return 0;
}
Exemplo n.º 10
0
int liberar_bloques_inodo(unsigned int ninodo, unsigned int blogico) {
    int numPdirectos = 12;
    int numPunt = BLOCKSIZE / 4;
    int nPunteros0 = numPunt;
    int nPunteros1 = numPunt * numPunt;
    int nPunteros2 = numPunt * numPunt * numPunt;

    struct inodo inodoAux = leer_inodo(ninodo); //leemos el inodo que nos indican por parámetro
    int ultimoBloqueOcupado = inodoAux.tamEnBytesLog / BLOCKSIZE; //nos interesa saber donde acaba
    int bufferAuxPunt[BLOCKSIZE / 4];
    memset(bufferAuxPunt, 0, BLOCKSIZE);

    int array2[numPunt];
    int array1[numPunt];
    int array[numPunt];
    int pCeros[numPunt];
    memset(pCeros, 0, BLOCKSIZE);
    int bloque;
    for (bloque = blogico; bloque <= ultimoBloqueOcupado; bloque++) {

        //Punteros Directos
        if (bloque < numPdirectos) {
            if (inodoAux.punterosDirectos[bloque] != 0) {
                liberar_bloque(bloque); //liberamos el bloque al cual apunta el inodo
                inodoAux.punterosDirectos[bloque] = 0; //quitamos el puntero que apunta al bloque que hemos liberado
            }

            //Punteros indirctos niv 0  
        } else if (bloque < numPdirectos + nPunteros0) {
            if (inodoAux.punterosIndirectos[0] != 0) {
                bread(inodoAux.punterosIndirectos[0], array); //leemos el bloque de punteros de nivel 0
                if (array[bloque - numPdirectos] != 0) { //si existe bloque de datos    
                    liberar_bloque(array[bloque - numPdirectos]); //liberamos el bloque al cual apunta el inodo
                    array[bloque - numPdirectos] = 0; //quitamos el puntero que apunta al bloque que hemos liberado

                    //miramos si quedan punteros que no esten libres en el bloque de los de nivel 0
                    //si ninguno apunta a nada liberamos el bloque de punteros indirectos
                    //y hacemos que el inodo de punteros indirectos de nivel 0 no apunte a nada
                    if (memcmp(array, pCeros, BLOCKSIZE) == 0) {
                        liberar_bloque(inodoAux.punterosIndirectos[0]);
                        inodoAux.punterosIndirectos[0] = 0;
                    } else {
                        bwrite(inodoAux.punterosIndirectos[0], array);
                    }
                }
            }
            //INDIRECTOS1
        } else if (bloque < numPdirectos + nPunteros0 + nPunteros1) {
            int puntNiv0 = (bloque - (numPdirectos + nPunteros0)) % nPunteros0;
            int puntNiv1 = (bloque - (numPdirectos + nPunteros0)) / nPunteros0;

            if (inodoAux.punterosIndirectos[1] != 0) {
                bread(inodoAux.punterosIndirectos[1], array1);
                if (array1[puntNiv1] != 0) {
                    bread(array1[puntNiv1], array);
                    if (array[puntNiv0] != 0) {
                        liberar_bloque(array[puntNiv0]);
                        array[puntNiv0] = 0;
                        if (memcmp(array, pCeros, BLOCKSIZE) == 0) {
                            liberar_bloque(array1[puntNiv1]);
                            array1[puntNiv1] = 0;
                            if (memcmp(array1, pCeros, BLOCKSIZE) == 0) {
                                liberar_bloque(inodoAux.punterosIndirectos[1]);
                                inodoAux.punterosIndirectos[1] = 0;
                            } else {
                                bwrite(inodoAux.punterosIndirectos[1], array1);
                            }
                        } else {
                            bwrite(array1[puntNiv1], array);
                        }
                    }
                }
            }
            //INDIRECTOS2
        } else if (bloque < numPdirectos + nPunteros0 + nPunteros1 + nPunteros2) {
            int puntNiv0 = ((bloque - (numPdirectos + nPunteros0 + nPunteros1)) % nPunteros1) % nPunteros0;
            int puntNiv1 = ((bloque - (numPdirectos + nPunteros0 + nPunteros1)) % nPunteros1) / nPunteros0;
            int puntNiv2 = (bloque - (numPdirectos + nPunteros0 + nPunteros1)) / nPunteros1;

            if (inodoAux.punterosIndirectos[2] != 0) {
                bread(inodoAux.punterosIndirectos[2], array2);
                if (array2[puntNiv2] != 0) {
                    bread(array2[puntNiv2], array1);
                    if (array1[puntNiv1] != 0) {
                        bread(array[puntNiv1], array);
                        if (array[puntNiv0] != 0) {
                            liberar_bloque(array[puntNiv0]);
                            array[puntNiv0] = 0;
                            if (memcmp(array, pCeros, BLOCKSIZE) == 0) {
                                liberar_bloque(array1[puntNiv1]);
                                array1[puntNiv1] = 0;
                                if (memcmp(array1, pCeros, BLOCKSIZE) == 0) {
                                    liberar_bloque(array2[puntNiv2]);
                                    array1[puntNiv2] = 0;
                                    if (memcmp(array2, pCeros, BLOCKSIZE) == 0) {
                                        liberar_bloque(inodoAux.punterosIndirectos[2]);
                                        inodoAux.punterosIndirectos[2] = 0;
                                    } else {
                                        bwrite(inodoAux.punterosIndirectos[1], array2);
                                    }
                                } else {
                                    bwrite(array2[puntNiv2], array1);
                                }
                            } else {
                                bwrite(array1[puntNiv1], array);
                            }
                        }
                    }
                }
            }
        }

    }
    escribir_inodo(inodoAux, ninodo);
}
Exemplo n.º 11
0
int main (int argc,char **argv) {

	if (argc == 2) {

		signal(SIGCHLD,reaper);
	
		mount(argv[1]);
		
		struct inodo in;
		if (leer_inodo(&in, 0) < 0) {
			printf("ERROR (simulacion.c -> mi_stat(/)): Error al leer el estado\n");
		}
		
		struct superbloque SB;
		if (bread(0, (char *)&SB) < 0) {
			printf("ERROR (simulacion.c -> error al leer el superbloque)\n");
		}
		
		if (in.t_bytes > 0) {
			vaciar();
			initSB(SB.n_bloques, argv[1]);
			initMB(SB.n_bloques);
			initAI(SB.n_bloques);
		}
			
			
		int i;
		for (i = 0; i < N_PROCESOS; i++) {
		
			int hilo = fork();
			if (hilo == 0) {
			
				if (proceso(i) < 0) {
					printf("ERROR (simulacion.c): Error al crear el proceso %d.\n", i);
					return (-1);
				}
				exit(0);
			}
			else if (hilo < 0) {
				i--;
				printf("Llamamos al reaper, hilo = %d\n", hilo);
				reaper();
			}
			
			sleep(1);		
		}
	
		while (acabados < N_PROCESOS) {
			pause();
		}
			
		unmount(argv[1]);
	
	}
	else {
		printf("ERROR (simulacion.c): Error, parámetros != de 2 (%d).\n", argc);
		return (-1);
	}
	
	return (0);
}
Exemplo n.º 12
0
/*Escribe el contenido de un buffer (buf_original dado por parámetro) en un fichero o directorio (inodo pasado por argumento)
 * offset: posicion inicial de escritura con respeccto al inodo (bytes)
 * nbytes: nº de bytes a escribir
 * devuelve la cantidad de bytes escritos (si es que ha escrito bytes)
 */
int mi_write_f(unsigned int ninodo, const void *buf_original, unsigned int offset, unsigned int nbytes) {
    struct superbloque sbloq;
    struct inodo inode;
    inode = leer_inodo(ninodo);
    unsigned int bfisico; //Para el uso de la función traducir_bloque_inodo
    unsigned int bytes_escritos;
    unsigned char buf_bloque[BLOCKSIZE];
    memset(buf_bloque, 0, BLOCKSIZE);

    if ((inode.permisos & 2) != 2) { //Si no tenemos permisos de escritura devolvemos un error
        printf("ERROR: ficheros.c => mi_write => No se tienen permisos de escritura\n");
        return -1;
    } else { //en caso contrario, escribimos el buffer en la posición indicada	

        //primer bloque lógico a escribir
        int primerBlogico = offset / BLOCKSIZE;
        //último bloque lógico a escribir
        int ultimoBlogico = (offset + nbytes - 1) / BLOCKSIZE;

        //desplazamientos
        int desp1 = offset % BLOCKSIZE; //despl. en el primer bloque
        int desp2 = (offset + nbytes - 1) % BLOCKSIZE; //despl. en el último bloque

        //caso 1
        if (primerBlogico == ultimoBlogico) {

            /*	Hacemos un bread de este bloque (con ayuda de la función traducir_bloque_inodo) 
             * y almacenamos el resultado en un buffer llamado buf_bloque.
             */

            if (traducir_bloque_inodo(ninodo, primerBlogico, &bfisico, 1) == -1) {
                printf("ERROR: ficheros.c -> mi_write_f => Error al traducir el bloque lógico %d\n", primerBlogico);
                return -1;
            }

            if (bread(bfisico, buf_bloque) == -1) {//leemos el bloque en el que vamos a escribir
                printf("ERROR:	ficheros.c -> mi_write_f => Error al leer el bloque físico %d\n", bfisico);
                if (bread(posSB, (char *) &sbloq) == -1) printf("\tficheros.c -> mi_write_f => Error al leer el superbloque \n");
                else if (sbloq.totBloques < bfisico) printf("\tficheros.c -> mi_write_f => bfisico fuera de rango\n");
                return -1;
            }

            //Escribimos el contenido de 'buf_original' en la posición correspondiente del buffer
            memcpy(buf_bloque + desp1, buf_original, nbytes);

            /*Hacemos un bwrite del buf_bloque (con los nuevos datos, preservando los que contenía), 
             * en el bloque que nos devuelva la función y guardamos la cantidad de bytes escritos
             */
            if (bwrite(bfisico, buf_bloque) == -1) {
                printf("ERROR: ficheros.c -> mi_write_f => (Caso 1) Error al escribir el bloque %d \n", bfisico);
            }

            bytes_escritos = nbytes; //devolvemos la cantidad de bytes escritos

        } else { //caso 2: primerByteLogico != ultimoByteLogico

            /////tratamiento del primer bloque lógico
            /*	Hacemos un bread de este bloque (con ayuda de la función traducir_bloque_inodo) 
             * y almacenamos el resultado en un buffer llamado buf_bloque.
             */

            if (traducir_bloque_inodo(ninodo, primerBlogico, &bfisico, 1) == -1) {
                printf("ERROR: ficheros.c -> mi_write_f => Error al traducir el bloque lógico %d\n", primerBlogico);
                return -1;
            }

            if (bread(bfisico, buf_bloque) == -1) {
                printf("ERROR: ficheros.c -> mi_write_f => (Tratamiento PBL) Error al leer el bloque %d\n", bfisico);
                return -1;
            }

            memcpy(buf_bloque + desp1, buf_original, BLOCKSIZE - desp1);

            /*Hacemos un bwrite del buf_bloque (con los nuevos datos, preservando los que contenía), 
             * en el bloque que nos devuelva la función
             */

            bytes_escritos = BLOCKSIZE - desp1; //primeros bytes escritos

            if (bwrite(bfisico, buf_bloque) == -1) {
                printf("ERROR: ficheros.c -> mi_write_f => (Tratamiento PBL) Error al escribir el bloque %d \n", bfisico);
            }

            //tratamiento de los bloques intermedios     
            int i;
            for (i = primerBlogico + 1; i < ultimoBlogico; i++) {
                if (traducir_bloque_inodo(ninodo, i, &bfisico, 1) == -1) {
                    printf("ERROR: ficheros.c -> mi_write_f => Error al traducir el bloque lógico %d\n", i);
                    return -1;
                }
                //buf_bloque = buf_original + (BLOCKSIZE - desp1) + (i - primerBlogico - 1) * BLOCKSIZE;		  
                int var = bwrite(bfisico, buf_original + (BLOCKSIZE - desp1) + (i - primerBlogico - 1) * BLOCKSIZE); //bytes escritos en el bloque intermedio actual
                if (var != BLOCKSIZE) {//comprobamos si se ha escrito el bloque al completo
                    printf("ERROR: ficheros.c -> mi_write_f => (Tratamiento bloques intermedios) No se ha escrito el bloque %d al completo\n", bfisico);
                }
                bytes_escritos = bytes_escritos + var; //sumamos los bytes escritos en este bloque intermedio
            }

            //tratamiento del último bloque
            if (traducir_bloque_inodo(ninodo, ultimoBlogico, &bfisico, 1) == -1) {
                printf("ERROR: ficheros.c -> mi_write_f => Error al traducir el bloque lógico %d\n", ultimoBlogico);
                return -1;
            }

            if (bread(bfisico, buf_bloque) == -1) {
                printf("ERROR: ficheros.c -> mi_write_f => (Tratamiento UBL) Error al leer el bloque %d \n", bfisico);
                return -1;
            }

            memcpy(buf_bloque, buf_original + (nbytes - desp2 - 1), desp2 + 1);

            if (bwrite(bfisico, buf_bloque) == -1) {
                printf("ERROR: ficheros.c -> mi_write_f => (Tratamiento UBL) Error al escribir el bloque %d \n", bfisico);
            }

            bytes_escritos = bytes_escritos + desp2 + 1;
        }

        //Finalmente y en todo caso:

        //Leemos el inodo
        inode = leer_inodo(ninodo);

        //Actualizar el tamaño en bytes lógicos si hemos escrito más allá del final del fichero
        if (inode.tamEnBytesLog < offset + bytes_escritos) {//En el caso de que tengamos que aumentar el tamaño del fichero
            inode.tamEnBytesLog = offset + bytes_escritos; //actualizamos el tamaño de bytes lógicos de la metainformación
        }

        //actualizar mtime y el ctime
        inode.ctime = time(NULL);
        inode.mtime = time(NULL);

        //Escribir el inodo
        if (escribir_inodo(inode, ninodo) == -1) {
            printf("ERROR: ficheros.c -> mi_write_f => Error al escribir inodo %d \n", ninodo);
            return -1;
        }
    }
    return bytes_escritos; //si todo va bien bytes_escritos=nbytes
}
Exemplo n.º 13
0
int mi_read_f(unsigned int ninodo, void *buf_original, unsigned int offset, unsigned int nbytes) {
    struct inodo inode;
    inode = leer_inodo(ninodo);
    unsigned int bfisico; //Para el uso de la función traducir_bloque_inodo
    unsigned int bytes_leidos = 0;
    unsigned int desp_buffer = 0; //bytes_leidos sin contar los bloques vacíos

    unsigned char buf_bloque[BLOCKSIZE];
    memset(buf_bloque, 0, BLOCKSIZE);


    if ((inode.permisos & 4) != 4) { //Si no tenemos permisos de lectura devolvemos un error
        printf("ERROR: ficheros.c => mi_read_f => No se tienen permisos de lectura\n");
        return -1;
    } else { //en caso contrario, leemos el buffer en la posición indicada

        if (offset + nbytes >= inode.tamEnBytesLog) {
            nbytes = inode.tamEnBytesLog - offset; // leemos sólo los bytes que podemos desde el offset hasta el final de fichero
        }

        if (offset > inode.tamEnBytesLog) {
            nbytes = 0;
            return nbytes; //no leemos nada
        }

        int primerBlogico = offset / BLOCKSIZE; //primer byte lógico a leer	
        int ultimoBlogico = (offset + nbytes - 1) / BLOCKSIZE; //último byte lógico a leer

        //desplazamientos
        int desp1 = offset % BLOCKSIZE; //despl. en el primer bloque
        int desp2 = (offset + nbytes - 1) % BLOCKSIZE; //despl. en el último bloque

        //caso 1
        if (primerBlogico == ultimoBlogico) {

            int resultado_traducir = traducir_bloque_inodo(ninodo, primerBlogico, &bfisico, 0);

            if (resultado_traducir == -1) {
                printf("ERROR: ficheros.c -> mi_read_f => Error al traducir el bloque lógico %d\n", primerBlogico);
                return -1;
            }

            if (resultado_traducir == -2) {//bloque lógico vacío
                bytes_leidos = nbytes; //lo indicamos como leído pero no pasamos nada al buffer de salida
            } else {//sino leemos y pasamos el contenido al buffer
                if (bread(bfisico, buf_bloque) == -1) {
                    printf("ERROR: ficheros.c -> mi_read_f => Error al leer el bloque %d\n", bfisico);
                    return -1;
                }
                memcpy(buf_original, buf_bloque + desp1, nbytes); //copiamos el contenido en el buffer de salida	
                bytes_leidos = nbytes;
            }

        } else { //caso 2 primerBloqueLogico != ultimoBloqueLogico

            //tratamiento del primer bloque lógico

            int resultado_traducir = traducir_bloque_inodo(ninodo, primerBlogico, &bfisico, 0);
            if (resultado_traducir == -1) {
                printf("ERROR: ficheros.c -> mi_read_f => Error al traducir el bloque lógico %d\n", primerBlogico);
                return -1;
            }

            if (resultado_traducir == -2) {//bloque lógico vacío    
                bytes_leidos = BLOCKSIZE - desp1; //lo indicamos como leído pero no pasamos nada al buffer de salida ni desplazamos el puntero
            } else {//leemos el primer bloque		
                if (bread(bfisico, buf_bloque) == -1) {
                    printf("ERROR: ficheros.c -> mi_read_f => (Tratamiento PBL) Error al leer el bloque %d\n", bfisico);
                    return -1;
                }
                memcpy(buf_original, buf_bloque + desp1, BLOCKSIZE - desp1); //guardamos los bytes leídos en el buffer de salida
                bytes_leidos = BLOCKSIZE - desp1; //guardamos la cantidad de bytes leidos
                desp_buffer = bytes_leidos; //posición del puntero de buf_original
            }

            //tratamiento de los bloques intermedios
            int i;
            for (i = primerBlogico + 1; i < ultimoBlogico; i++) {
                int resultado_traducir = traducir_bloque_inodo(ninodo, primerBlogico, &bfisico, 0);
                if (resultado_traducir == -1) {
                    printf("ERROR: ficheros.c -> mi_read_f => Error al traducir el bloque lógico intermedio %d\n", i);
                    return -1;
                }

                if (resultado_traducir == -2) {//bloque lógico vacío
                    bytes_leidos = bytes_leidos + BLOCKSIZE; //lo indicamos como leído pero no pasamos nada al buffer de salida ni desplazamos el puntero
                } else {//leemos el bloque		
                    if (bread(bfisico, buf_bloque) == -1) {
                        printf("ERROR: ficheros.c -> mi_read_f => (Tratamiento bloques intermedios) Error al leer el bloque %d\n", bfisico);
                        return -1;
                    }
                    memcpy(buf_original + desp_buffer, buf_bloque, BLOCKSIZE); //guardamos los bytes leídos en el buffer de salida
                    bytes_leidos = bytes_leidos + BLOCKSIZE; //guardamos la cantidad de bytes leidos
                    desp_buffer = desp_buffer + BLOCKSIZE; //actualizamos la posición del puntero de buf_original
                }
            }

            //tratamiento del último bloque

            resultado_traducir = traducir_bloque_inodo(ninodo, ultimoBlogico, &bfisico, 0);
            if (resultado_traducir == -1) {
                printf("ERROR: ficheros.c -> mi_read_f => Error al traducir el bloque lógico %d\n", ultimoBlogico);
                return -1;
            }

            if (resultado_traducir == -2) {//bloque lógico vacío
                bytes_leidos = desp2 + 1; //lo indicamos como leído pero no pasamos nada al buffer de salida ni desplazamos el puntero
            } else {//leemos el primer bloque		
                if (bread(bfisico, buf_bloque) == -1) {
                    printf("ERROR: ficheros.c -> mi_read_f => (Tratamiento PBL) Error al leer el bloque %d\n", bfisico);
                    return -1;
                }
                memcpy(buf_original, buf_bloque, desp2 + 1); //guardamos los bytes leídos en el buffer de salida
                bytes_leidos = bytes_leidos + desp2 + 1; //guardamos la cantidad de bytes leidos
            }

        }
        //Finalmente y en todo caso:

        //Leemos el inodo
        inode = leer_inodo(ninodo);

        //actualizar sellos de tiempo
        inode.ctime = time(NULL);
        inode.mtime = time(NULL);
        inode.atime = time(NULL);

        //Escribir el inodo
        if (escribir_inodo(inode, ninodo) == -1) {
            printf("ERROR: ficheros.c -> mi_read_f => Error al escribir inodo %d \n", ninodo);
            return -1;
        }
    }
    return bytes_leidos;
}
Exemplo n.º 14
0
int mi_read_f(unsigned int ninodo, void *buf, unsigned int offset, unsigned int nbytes){
	
	struct inodo Inodo = leer_inodo(ninodo);
	if(!(Inodo.permisos & 4)){
		printf("Error: no tiene los permisos necesarios\n");
		return -1;
	}
	if(offset + nbytes > Inodo.tamEnBytesLog){ //si se quiere leer mas de lo que ocupa el fichero
		nbytes = Inodo.tamEnBytesLog - offset;
	}
	if(offset >= Inodo.tamEnBytesLog){ //Se quiere leer mas alla del final de fichero
		nbytes = 0;
		return nbytes;
	}
	int bFisico = 0;
	unsigned int primerLogico = offset/BLOCKSIZE;
	unsigned int ultimoLogico = (offset+nbytes-1)/BLOCKSIZE;
	unsigned char buffer[BLOCKSIZE];
	memset(buffer, 0, sizeof(buffer));
	int bytesleidos = 0;
	if(primerLogico == ultimoLogico){ //se lee un unico bloque
		bFisico = traducir_bloque_inodo(ninodo, primerLogico, 0);
		if(bread(bFisico, &buffer) < 0){
			return -1;
		} 
		int desp1 = offset % BLOCKSIZE;
		memcpy(buf, buffer+desp1, nbytes);
		bytesleidos += nbytes;

	}else{ // Hay que leer varios bloques
		// Primer bloque
		bFisico = traducir_bloque_inodo(ninodo, primerLogico, 0);
		if(bread(bFisico, &buffer) < 0){
			return -1;
		} 
		int desp1 = offset % BLOCKSIZE;
		memcpy(buf, buffer + desp1, BLOCKSIZE - desp1);
		bytesleidos += BLOCKSIZE - desp1;
		memset(buffer, 0, sizeof(buffer));
		// Bloques intermedios
		int i;
		for(i = primerLogico + 1; i < ultimoLogico; i++){
			bFisico = traducir_bloque_inodo(ninodo, i, 0);
			if(bread(bFisico, &buffer) < 0){
			return -1;
		} 
			memcpy(buf + bytesleidos, buffer, BLOCKSIZE);
			bytesleidos += BLOCKSIZE;
			memset(buffer, 0, sizeof(buffer));
		}
		// Ultimo bloque
		int desp2 = (offset + nbytes - 1) % BLOCKSIZE;
		bFisico = traducir_bloque_inodo(ninodo, ultimoLogico, 0);
		if(bread(bFisico, &buffer) < 0){
			return -1;
		} 
		memcpy(buf + bytesleidos, buffer, desp2 + 1);
		bytesleidos += desp2 + 1;
	}
	

	Inodo = leer_inodo(ninodo);
	Inodo.atime = time(NULL);
	if(escribir_inodo(Inodo, ninodo) < 0){
			return -1;
		} 
	return bytesleidos;
}
Exemplo n.º 15
0
int mi_write_f(unsigned int ninodo, const void *buf_original, unsigned int offset, unsigned int nbytes){
	struct inodo Inodo = leer_inodo(ninodo);
	int bytesEscritos = 0;
	unsigned int primerLogico = offset/BLOCKSIZE;
	unsigned int ultimoLogico = (offset+nbytes-1)/BLOCKSIZE;
	if ((Inodo.permisos & 2) != 2) {
		printf("No tienes permisos de escritura.\n");
		return -1;
	}
	if(primerLogico == ultimoLogico){
		// Un unico bloque modificado
		unsigned char bufBloque[BLOCKSIZE];
		memset(bufBloque, 0, sizeof(bufBloque));
		int desp1 = offset%BLOCKSIZE;
		int bFisico = traducir_bloque_inodo(ninodo, primerLogico, 1); //reserva del bloque fisico
		if(bread(bFisico, bufBloque) < 0){
			return -1;
		} 
		memcpy(bufBloque+desp1, buf_original, nbytes);
		int incremento;
		if((incremento = bwrite(bFisico, &bufBloque)) < 0){
			return -1;
		} 
		bytesEscritos += incremento;
	}else{
		// Primer bloque
		int desp = 0;
		unsigned char bufBloque[BLOCKSIZE];
		memset(bufBloque, 0, sizeof(bufBloque));
		int desp1 = offset%BLOCKSIZE;
		int bFisico = traducir_bloque_inodo(ninodo, primerLogico, 1); //reserva del bloque fisico
		if(bFisico < 0) return bytesEscritos;
		if(bread(bFisico, bufBloque) < 0) return -1;
		memcpy(bufBloque+desp1, buf_original, BLOCKSIZE-desp1);
		int incremento;
		if((incremento = bwrite(bFisico, &bufBloque)) < 0){
			return -1;
		} 
		desp += desp1;
		bytesEscritos += incremento;
		// Bloques intermedios
		int i;
		for(i = primerLogico + 1; i < ultimoLogico; i++){
			bFisico = traducir_bloque_inodo(ninodo, i, 1);
			if(bFisico < 0) return bytesEscritos;
			memcpy(bufBloque, buf_original + (BLOCKSIZE - desp1) + (i - primerLogico - 1) * BLOCKSIZE, BLOCKSIZE);
			int incremento;
			if((incremento = bwrite(bFisico, &bufBloque)) < 0){
			return -1;
		} 
			bytesEscritos += incremento;
		}
		// Último bloque
		int desp2 = (offset+nbytes-1)%BLOCKSIZE;
		bFisico = traducir_bloque_inodo(ninodo, ultimoLogico, 1);
		if(bFisico < 0) return bytesEscritos;
		if(bread(bFisico, &bufBloque) < 0){
			return -1;
		} 
		memcpy(bufBloque, buf_original + (nbytes - desp2 - 1), desp2 + 1);
		if((incremento = bwrite(bFisico, &bufBloque)) < 0){
			return -1;
		} 
		bytesEscritos += incremento;
	}
	// Actualizar informacion del inodo
	Inodo = leer_inodo(ninodo);
	if(offset+nbytes > Inodo.tamEnBytesLog){
		Inodo.tamEnBytesLog = offset + nbytes;
	}
	Inodo.mtime = time(NULL);
	Inodo.ctime = time(NULL);
	if(escribir_inodo(Inodo, ninodo) < 0){
			return -1;
		} 
	return bytesEscritos;
}
Exemplo n.º 16
0
int mi_truncar_f(unsigned int ninodo, unsigned int nbytes) {
    // Creamos una estructura inodo.
	struct inodo Inodo;
    // Leemos el inodo indicado por parámetro.
	Inodo = leer_inodo(ninodo);

	if (nbytes > Inodo.tamEnBytesLog) {
		printf("ERROR -> No se ha podido truncar el fichero por sobrepasar su tamaño.\n");
		return -1;
	}

    // Si el número de bytes es 0, vaciamos el fichero.
	if (nbytes == 0) {
		liberar_inodo(ninodo);

		Inodo.tamEnBytesLog = nbytes;

		if (escribir_inodo(Inodo, ninodo) == -1) {
			return -1;
		}
    }// Si no...
    else if (nbytes > 0) {
        // Calculamos el último bloque a truncar.
    	int ultimoblogico = Inodo.tamEnBytesLog / BLOCKSIZE;

        // Si el tamaño en bytes lógicos del inodo es múltiplo del tamaño de bloque
        // decrementamos la variable ultimoblogico.
    	if ((Inodo.tamEnBytesLog % BLOCKSIZE) == 0) {
    		ultimoblogico--;
    	}

        // Calculamos el último bloque que conservamos.
    	int bloq_queda = nbytes / BLOCKSIZE;
        // Si el número de bytes es múltiplo de tamaño de bloque, decrementamos 
        // la variable bloq_queda.
    	if (nbytes % BLOCKSIZE == 0) {
    		bloq_queda--;
    	}

    	unsigned int bfisico;
    	int i = 0;
    	char reservar = '0';
        // Iteramos para todos los bloques que queremos liberar.
    	for (i = bloq_queda + 1; i <= ultimoblogico; i++) {
            // Obtenemos el bloque físico.
    		bfisico = traducir_bloque_inodo(ninodo, i, reservar);

            // Si no es el bloque raíz (SUPERBLOQUE)...
    		if (bfisico > 0) {
    			if (liberar_bloque(bfisico) == -1) {

    				printf("ERROR -> No se ha liberado el bloque.\n");
    				return -1;
    			}
                // Decrementamos los bloques ocupados.
    			Inodo.numBloquesOcupados--;
    		}

            // Si estamos en el último bloque y no ocupa el bloque entero...
    		if ((i == ultimoblogico) && (Inodo.tamEnBytesLog % BLOCKSIZE != 0)) {
                // Truncamos el trozo del bloque.
    			Inodo.tamEnBytesLog = Inodo.tamEnBytesLog - (Inodo.tamEnBytesLog % BLOCKSIZE);
    		} else {
                // Truncamos todo el bloque.
    			Inodo.tamEnBytesLog = Inodo.tamEnBytesLog - BLOCKSIZE;
    		}
    	}

    	Inodo.tamEnBytesLog = nbytes;

    	if (escribir_inodo(Inodo, ninodo) == -1) {
    		return -1;
    	}
    }
    return 0;
}