/** Escriu al final del fitxer especificat al primer paramentre
* la cadena del segon paramentre.
* mi_apend <path> <string> */
int main(int argc, char **argv) {
char path[MAX_PATH_LEN];
emofs_inode_stat info;
if (argc != 3) {
puts("Nombre de parametres incorrecte.\n");
puts("Us: mi_append <fitxer> <cadena>\n");
return -1;
}
bmount();
strcpy(path, argv[1]);
if (!emofs_file_exists(path)) {
emofs_create(path);
}
if (emofs_is_file(path) == 0) {
puts("append: no es poden fer appends a directoris");
bumount();
return -2;
}
emofs_stat(path, &info);
emofs_write(path, argv[2], info.size, strlen(argv[2]));
bumount();
return 0;
}
int main(int argc, char **argv){
int tam2,tam3,tam4;
if(argc!=5){
printf("Número de argumentos incorrecto \n");
return -1;
}
tam2 = strlen(argv[2]);
tam3 = strlen(argv[3]);
tam4 = atoi(argv[4]);
if(argv[2][tam2-1]=='/'){
printf("No es un fichero \n");
return -2;
}
bmount(argv[1]); //Monta disco
if(mi_write(argv[2], argv[3], tam4, tam3)<0){
printf("Error al escribir en el fichero \n");
}else{
printf("Fichero escrito correctamente \n");
}
bumount(); //Desmonta disco
return 0;
}
int main(int argc, char **argv){
if(argc != 4){
printf("mi_chmod, 6: Error en els arguments.\n");
printf("L'ús del programa és:\n \t.");
printf("/mi_chmod [nom_del_dispositiu] [permisos] [cami]\n");
exit(0);
}
if(bmount(argv[1]) == -1){
printf("mi_chmod, 13: Error en obrir el dispositiu: %s.\n", argv[1]);
return -1;
}
/* Hem de comprovar que els permisos són correctes. */
int per = atoi(argv[2]);
if(per > 7 || per < 0){
printf("mi_chmod, 20: Error en els permisos.\n");
return -1;
}
if(mi_chmod(argv[3], atoi(argv[2])) < 0){
printf("mi_chmod, 25: Error en mi_chmod.\n");
bumount();
return -1;
}
bumount();
return 0;
}
int main(int argc, char **argv){
if(argc != 3){
printf("Faltan argumentos\n");
return -1;
}
bmount(argv[1]);
empty(0);
empty(1);
if(argv[2][strlen(argv[2])-1] == '/'){
if(directorio_vacio(argv[2]) < 1){
printf("Directorio no vacío\n");
return -1;
}
}
if(mi_unlink(argv[2]) < 0){
printf("Error al desenlazar los ficheros/directorios\n");
return -1;
}
bumount();
printf("Fichero/directorio desenlazado correctamente\n");
return 0;
}
int main(int argc, char **argv) {
/*argc = nº de parámetros
argv[0]="simulacion"; nombre del main
argv[1]=disco(sistema de ficheros) se ha de llamar disco.imagen
*/
if (argc != 2) {
printf("ERROR: simulacion => main: Faltan argumentos!!! El número permitido de argumentos son 2. \n");
return (EXIT_FAILURE);
} else {
if (bmount(argv[1]) == -1) {
printf("ERROR: simulacion => main: Error al abrir (bmount) el sistema de ficheros.\n");
return (EXIT_FAILURE);
}
//creamos el directorio de simulación
struct tm *tm;
time_t tiempo = time(NULL);
tm = localtime(&tiempo);
memset(dir_sim, 0, strlen(dir_sim));
sprintf(dir_sim, "/simul_%d%02d%02d%02d%02d%02d/",
tm -> tm_year + 1900,
tm -> tm_mon + 1,
tm -> tm_mday,
tm -> tm_hour,
tm -> tm_min,
tm -> tm_sec);
printf("Creación del directorio de simulacion %s\n", dir_sim);
//mi_creat (ruta, permisos);
if (mi_creat(dir_sim, 7) < 0) {
printf("ERROR: simulacion => main: Error al crear el directorio %s\n", dir_sim);
} else {
//Llamamos al enterrador
signal(SIGCHLD, enterrador);
//Creamos los 100 procesos de escritura
int i;
for (i = 0; i < num_procesos; i++) {
if (fork() == 0) { //quiere decir que hemos podido crear un proceso hijo
escrituras();
exit(0);
}
usleep(200);
}
printf("Se han creado %d procesos\n", i);
//Mientras no hayan acabado todos los procesos, pause();
while (acabados < num_procesos) { //Mientras queden procesos
pause();
}
//verificamos escrituras
verificacion();
if (bumount(argv[1]) == -1) {
printf("ERROR: simulacion => main: Error al cerrar (bumount) el sistema de ficheros.\n");
return (EXIT_FAILURE);
}
}
}
return 0;
}
int main(int argc, char **argv) {
bmount(argv[1]);
char text [2048]= "Empieza con un prólogo en el que se burla de la erudición pedantesca y con unos poemas cómicos, a manera de preliminares, compuestos en alabanza de la obra por el propio autor, quien lo justifica diciendo que no encontró a nadie que quisiera alabar una obra tan extravagante como esta, como sabemos por una carta de Lope de Vega. En efecto, se trata, como dice el cura, de una escritura desatada libre de normativas que mezcla lo lírico, épico, trágico, cómico y donde se entremeten en el desarrollo historias de varios géneros, como por ejemplo: Grisóstomo y la pastora Marcela, la novela de El curioso impertinente, la historia del cautivo, el discurso sobre las armas y las letras, el de la Edad de Oro, la primera salida de don Quijote solo y la segunda con su inseparable escudero Sancho Panza (la segunda parte narra la tercera y postrera salida La novela comienza describiéndonos a un tal Alonso Quijano, hidalgo pobre, que enloquece leyendo libros de caballerías y se cree un caballero medieval. Decide armarse como tal en una venta, que él ve como castillo. Le suceden toda suerte de cómicas aventuras en las que el personaje principal, impulsado en el fondo por la bondad y el idealismo, busca «desfacer agravios» y ayudar a los desfavorecidos y desventurados. Profesa un amor platónico a una tal Dulcinea del Toboso; que es, en realidad, una moza labradora «de muy buen parecer»: Aldonza Lorenzo. El cura y el barbero del lugar someten la biblioteca de don Quijote a un expurgo, y queman parte de los libros que le han hecho tanto mal.Don Quijote lucha contra unos gigantes, que no son otra cosa que molinos de viento";
/*
int ninodo = reservar_inodo('f', '6');
printf("\t- Reserva primer inodo: %d\n", ninodo);
mi_write_f(ninodo, "Esto es la prueba numero 1\0", 5120, 27);
*/
int ninodo = reservar_inodo('f', '6');
printf("\t- Reserva inodo: %d\n", ninodo);
mi_write_f(ninodo, text, 409604096, strlen(text));
//ninodo = reservar_inodo('f', '6');
// printf("\t- Reserva segundo inodo: %d\n", ninodo);
// mi_write_f(ninodo, "Esto es la segunda prueba\0", 256000, 26);
// ninodo = reservar_inodo('f', '6');
// printf("\t- Reserva tercer inodo: %d\n", ninodo);
// mi_write_f(ninodo, "Esto es la prueba numero 3\0", 30721024, 27);
// ninodo = reservar_inodo('f', '6');
// printf("\t- Reserva cuarto inodo: %d\n", ninodo);
// mi_write_f(ninodo, "Esto es la cuarta prueba\0", 71680000, 25);
bumount();
return ninodo;
}
int main() {
int i;
/* mi_mount */
emofs_sem_init(&mutex);
bmount();
init_fs();
signal(SIGCHLD, reaper);
for(i = 0; i < PROCESS_NUMBER; i++) {
if (fork() == 0) {
sim_work();
exit(0);
} else {
usleep(NEXT_CHILDREN_WAIT);
}
}
while (ENDED_CHILDREN < PROCESS_NUMBER) {
pause();
}
show_work();
puts("Simulació acabada");
/* mi_umount */
bumount();
emofs_sem_get(&mutex);
emofs_sem_del(mutex);
return 0;
}
int main(int argc, char **argv){
if(argc!=4){
printf("Número de argumentos incorrecto \n");
return -1;
}
int tam;
bmount(argv[1]); //Monta disco
unsigned int modo = atoi(argv[3]);
tam = strlen(argv[2]);
if(argv[2][tam-1]!='/'){
if(mi_creat(argv[2], modo)<0){
printf("Error en la creación de archivo \n");
}else{
printf("Archivo creado \n");
}
}else{
printf("Debe introducir un fichero válido \n");
}
bumount(); //Desmonta disco
return 0;
}
int main(int argc, char **argv) {
struct superbloque SB;
struct tm *ts;
struct inodo in;
unsigned char buf[BLOCKSIZE];
int nbloque,i,j,descriptor;
if(argc<2) {
printf("Syntax error, not enough arguments, file mi_chmod.c\n"
"Correct Order:\n"
"Argument 1: File system name\n");
return -1;
}
descriptor = bmount(argv[1]);
if(descriptor<0) {
exit(1);
}
if(bread(posSB,&SB)<0) return -1;
printf("-----Información del fichero %s-----\n", argv[1]);
mostrarSB(SB);
mostrarBM(SB);
mostrarIA(SB);
if(bumount(descriptor)<0) {
exit(1);
}
}
int main(int argc, char **argv)
{
unsigned int blocks;
unsigned char buf[BLOCK_SIZE];
if (argc != 3) {
printf("\nusage: mkfs [imge_file] [blocks]\n");
exit(EXIT_FAILURE);
}
blocks = atol(argv[2]);
bmount(argv[1]);
// test code
memset(buf, 1, BLOCK_SIZE);
bwrite(0,buf);
bwrite(1,buf);
memset(buf, 'a', BLOCK_SIZE);
bwrite(2,buf);
// end test code
bumount();
return EXIT_SUCCESS;
}
int main(int argc, char** argv) {
if (argc != 4) {
printf("\n\033[31mERROR -> Los argumentos son incorrectos.");
printf("\n\033[31m -> Faltan/sobran argumentos.\n\n");
printf("\033[m"); // Color default.
return -1;
}
int x = atoi(argv[2]);
if ((x < 0) || (x > 7)) {
printf("\n\033[31mERROR -> Los argumentos son incorrectos.");
printf("\n\033[31m -> Modo incorrecto. (Debe ser de 0 a 7)\n");
printf("\033[m"); // Color default.
return -1;
}
bmount(argv[1]);
if (mi_chmod(argv[3], argv[2][0])) {
bumount();
return -1;
}
printf("\n\033[32mLos permisos del fichero/directorio (%s) se han modificado safisfactoriamente.\n\n", argv[3]);
printf("\033[m"); // Color default.
bumount();
return (EXIT_SUCCESS);
}
int main(int argc, char **argv) {
/*argc = nº de parámetros
argv[0]="mi_mkdir"; nombre del main
argv[1]=disco(sistema de ficheros)
argv[2]=permisos
argv[3] = ruta
*/
if (argc != 4) {
printf("ERROR: mi_mkdir => main: Faltan argumentos!!! El número permitido de argumentos son 4. \n");
return (EXIT_FAILURE);
} else {
if (bmount(argv[1]) == -1) {
printf("ERROR: mi_mkdir => main: Error al abrir (bmount) el sistema de ficheros.\n");
return (EXIT_FAILURE);
}
int resultado = mi_creat(argv[3], atoi(argv[2]));
if (resultado < 0) {
printf("ERROR: mi_mkdir => main: Error al crear el directorio/fichero.\n");
return resultado;
}
if (bumount() == -1) {
printf("ERROR: mi_mkdir => main =>Error al desmontar(bumount) el sistema de ficheros.\n");
return (EXIT_FAILURE);
}
}
return (EXIT_SUCCESS);
}
int main(int argc, char **argv){
unsigned int a, descriptor, b;
descriptor = bmount(argv[1]);
b = atoi(argv[2]);
a = liberar_inodo(b);
printf("El inodo liberado es: %d\n", a);
if(bumount(descriptor)<0) exit(1);
}
int main(int argc, char **argv){
if(argc!=3){
printf("\nmi_mkfs: Error debe escribir: $ ./mi_mkfs <nombre_fichero> <cantidad_bloques>\n");
return -1;
}
//cantidad_bloques
unsigned int numBloques = atoi(argv[2]);
//cantidad_inodos
unsigned int ninodos = numBloques/4;
if(numBloques==0){
printf("\nmi_mkfs: El nº de bloques debe ser mayor a 0.\n");
return -1;
}
//ETAPA 1:
unsigned char buf[BLOCKSIZE];
//Rellenamos de 0's el buffer.
memset(buf,0,BLOCKSIZE);
//Montamos el dispositivo.
printf("\nmi_mkfs: Montando el dispositivo...\n");
bmount(argv[1]);//nombre_fichero
printf("\nmi_mkfs: El dispositivo se ha montado con éxito.\n");
printf("\nmi_mkfs: Realizando escritura...\n");
//ETAPA 1:
//Escribimos todos los bloques en el dispositivo.
for(int i=0; i<numBloques; i++){
bwrite(i,buf);
}
if(initSB(numBloques,ninodos)<0)return -1;
if(initMB()<0)return -1;
if(initAI(ninodos)<0)return -1;
//Se escribe el directorio raíz = inodo raíz.
reservar_inodo('d',7);
//Desmontamos el dispositivo.
printf("\nmi_mkfs: Desmontando el dispositivo...\n");
bumount();
printf("\nmi_mkfs: Dispositivo desmontado con éxito.\n");
return 0;
}
int main(int argc, char **argv){
if(argc!=3){
printf("Número de argumentos incorrecto \n");
return -1;
}
unsigned int n_bloques = atoi(argv[2]); //Número de bloques del FS
unsigned char buf[blocksize];
memset(buf,0,blocksize);
bmount(argv[1]); //Monta Disco
int i;
for (i=0; i<n_bloques-1; i++){ //Llena bloques con 0s
bwrite(i,buf);
}
memset(buf,1,blocksize);
bwrite(n_bloques,buf);
int block = n_bloques/4;//Para el cáculo de inodos
if(initSB(n_bloques, block)==-1){ //Inicializa SB
printf("Error al escribir superbloque");
}else{
printf("Superbloque escrito \n");
}
if(initMB(n_bloques)==-1){ //Inicializa MB
printf("Error al escribir mapa de bits");
}else{
printf("Mapa de bits escrito \n");
}
int n = tamAI(block);
if (initAI(n)==-1){ //Inicializa AI
printf("Error al escribir el array de inodes");
}else{
printf("Array de inodes escrito \n");
}
int inodoraiz = reservar_inodo('d',7);
printf("Sistema de ficheros creado correctamente \n");
bumount(); //Desmonta disco
return 0;
}
int mount(const char *nombre) {
if (bmount(nombre) < 0) {
printf("ERROR (directorios.c ->): METER EL ERROR\n");
return (-1);
}
else {
mutex = nuevo_semaforo(ftok("/home/", 's'), 1);
inicializar_semaforo(mutex, 1);
return (1);
}
}
int main(int argc, char **argv) {
if (argc != 3) {
printf("\n\033[31mERROR -> Los argumentos son incorrectos.");
printf("\n\033[31m -> Faltan/sobran argumentos.\n\n");
printf("\033[m"); // Color default.
return -1;
}
bmount(argv[1]);
// Comprobamos que es un fichero.
struct STAT stat;
if (mi_stat(argv[2], &stat)<0){
return -1;
}
if (stat.tipo != 'f') {
printf("\n\033[31mERROR -> No se pudo abrir el fichero.");
printf("\n\033[31m -> El archivo indicado no es un fichero.\n");
printf("\033[m"); // Color default.
bumount();
return -1;
}
char buffer[BLOCKSIZE];
memset(buffer, 0, BLOCKSIZE);
int i = 0;
int leidos = 0;
leidos = mi_read(argv[2], buffer, i, BLOCKSIZE);
//printf("Leidos %d",leidos);
printf("\n\033[32m- Este es el contenido del fichero (%s): \n", argv[2]);
printf("\033[m"); // Color default.
printf("\n");
while (leidos > 0) {
write(1, buffer, leidos);
memset(buffer, 0, BLOCKSIZE);
i++;
leidos = mi_read(argv[2], buffer, i*BLOCKSIZE, BLOCKSIZE);
}
printf("\n\n");
bumount();
return 0;
}
int main(int argc, char **argv) {
if (argc != 3) {
printf("Error: Número de argumentos incorrecto.\n");
return -1;
}
bmount(argv[1]);
if (mi_unlink(argv[2]) == -1) {
printf("Error: No se puede borrar el fichero/directorio.\n");
} else {
printf("Borrado correctamente.\n");
}
bumount();
return 0;
}
int main(int argc, char **argv){
if(argc!=4){
printf("Número de argumentos incorrecto \n");
return -1;
}
bmount(argv[1]); //Monta disco
if(mi_link(argv[2], argv[3])<0){
printf("Error al enlazar el fichero o directorio \n");
}else{
printf("Enlace realizado correctamente \n");
}
bumount(); //Desnonta disco
return 0;
}
int main(int argc, char **argv) {
char path[MAX_PATH_LEN];
int error = 0;
if (argc != 2) {
puts("Nombre de parametres incorrecte.");
puts("Us: mi_rm <cami>");
return -1;
}
bmount();
strcpy(path, argv[1]);
if (!emofs_file_exists(path)) {
printf("El fitxer/directori %s no existeix\n", path);
return -2;
}
recursive_rm(argv[1]);
bumount();
return error;
}
int main(int argc, char **argv) {
if (argc != 3) {
printf("mi_cat: numero de argumentos incorrecto\n");
return -1;
}
if(argv[2][strlen(argv[2])-1] == '/'){
printf("mi_cat: %s corresponde al path de un directorio\n",argv[2]);
return -1;
}
bmount(argv[1]);
unsigned int i = 0;//variable incremental auxiliar para calcular el offset
char buffer [TAM_BUF];//buffer de lectura para no cargar la memoria principal con lecturas pesadas
int lecturaB; //lecturaB(ytes): variable para controlar el resultado de las lecturas e imprimirlas sin llamadas innecesarias a mi_read
char *archivo = argv[2];
while ((lecturaB = mi_read(archivo, buffer, i*TAM_BUF, TAM_BUF))>0) {
fwrite(buffer,sizeof(char),lecturaB,stdout); //volcado del buffer en la salida estandar
i++;
}
bumount();
return 0;
}
int main(int argc, char **argv){
if(argc!=4){
printf("Número de argumentos incorrecto \n");
return -1;
}
bmount(argv[1]); //Monta Disco
unsigned int modo = atoi(argv[2]);
if(mi_chmod(argv[3], modo)<0){
printf("Error en el cambio de permisos \n");
}else{
printf("Permisos cambiados \n");
}
bumount(); //Desmonta disco
return 0;
}
int main(int argc, char *argv[])
{
char *buff;
int offset;
int nbytes;
if (argc != 6) {
printf("[mi_write.c] ERROR: Arguments incorrectes. Ex: mi_write <nomFS> <cami> <buff> <offset> <nbytes>\n");
exit(-1);
}
sem_init();
// montam es FS
if (bmount(argv[1]) == -1) {
sem_del();
return -1;
}
// codi
offset = atoi(argv[4]);
nbytes = atoi(argv[5]);
buff = argv[3];
if (mi_write(argv[2], buff, offset, nbytes) == -1) {
printf("[mi_write.c] ERROR: No s'ha pogut escriure!\n");
} else {
printf("[mi_write.c] INFO: S'ha escrit correctament.\n");
}
// desmontam es FS
if (bumount() == -1) {
sem_del();
return -1;
}
sem_del();
return 0;
}
int main(int argc, char **argv){
unsigned int tam2,n;
unsigned char buf[blocksize];
FILE *salida;
struct STAT p_stat;
memset(buf,'\0',blocksize);
if(argc!=3){ //Comprueba el número de argumentos
printf("Número de argumentos incorrecto \n");
return -1;
}
tam2 = strlen(argv[2]);
if(argv[2][tam2-1]=='/'){ //Comprueba si es un fichero
printf("No es un fichero \n");
return -2;
}
bmount(argv[1]); //Monta el disco
mi_stat(argv[2], &p_stat); //Extrae el tamaño en bytes para recorrer los bloques
for(n=0;(n*blocksize)<p_stat.tamEnBytesLog;n++){ //Recorre los bloques y los escribe en stdout(salida estándar)
if(mi_read(argv[2], buf, (n*blocksize), blocksize)<0){
printf("Error al leer del fichero \n");
return -1;
}else{
salida=fopen("/dev/stdout", "w");
fwrite (buf,1,blocksize,salida);
fclose(salida);
}
}
printf("\n");
bumount(); //Desmonta disco
return 0;
}
int main(int argc, char **argv){
int descriptor,ninodo,offset,bytesLeidos,totalBytes;
struct STAT status;
unsigned char input[1500];
char string[128];
descriptor = bmount(argv[1]);
ninodo = atoi(argv[2]);
if(descriptor<0) exit(1);
mi_stat_f(ninodo,&status);
showStats(status, ninodo);
mi_chmod_f(ninodo,4);
mi_stat_f(ninodo,&status);
showStats(status, ninodo);
mi_chmod_f(ninodo,2);
mi_stat_f(ninodo,&status);
showStats(status, ninodo);
mi_chmod_f(ninodo,6);
mi_stat_f(ninodo,&status);
showStats(status, ninodo);
if(bumount(descriptor)<0) exit(1);
return 0;
}
int main(int argc, char **argv) {
/*argc = nº de parámetros
argv[0]="mi_rm"; nombre del main
argv[1]=disco(sistema de ficheros)
argv[2]= /ruta
*/
if (argc != 3) {
printf("ERROR: mi_rm => main: Faltan argumentos!!! El número permitido de argumentos son 3. \n");
return (EXIT_FAILURE);
} else {
if (bmount(argv[1]) == -1) {
printf("ERROR: mi_rm => main: Error al abrir (bmount) el sistema de ficheros.\n");
return (EXIT_FAILURE);
}
char camino[strlen(argv[2])];
strcpy(camino, argv[2]);
struct STAT stat_inodo;
if (mi_stat(argv[2], &stat_inodo) < 0) {
printf("ERROR: mi_rm => main: Error al leer el inodo.\n");
return (EXIT_FAILURE);
}
if (strcmp(camino, "/") == 0) {
printf("No se puede borrar el directorio raíz\n");
} else if ((stat_inodo.tipo == 'd') && (stat_inodo.tamEnBytesLog != 0)) {
printf("No se puede borrar porque el directorio no está vacío.\n");
} else {
mi_unlink(camino);
}
if (bumount() == -1) {
printf("ERROR: mi_ln => main =>Error al desmontar(bumount) el sistema de ficheros.\n");
return (EXIT_FAILURE);
}
}
return (EXIT_SUCCESS);
}
int main (int argc,char **argv) {
time_t temps;
struct tm t;
temps = time(NULL);
localtime_r(&temps, &t);
int i = 0;
char dir_actual[MAXLONG];
acabados = 0;
bmount(DISK_NAME);
signal(SIGCHLD,reaper);
// printf("Llistam contingut abans de començar: \n");
// mi_ls2();
// printf("Esperant 2 segons abans de començar... \n");
// sleep(2);
// cleanup();
sprintf(dir_actual, "simul_%d%d%d", t.tm_hour, t.tm_min, t.tm_sec);
for (i = 0;i<PROCESOS; i++) {
// if(fork() == 0) {
proceso(dir_actual, i);
// exit(0);
// }
sleep(1);
}
// while (acabados<PROCESOS)
// pause();
printf("Llistam contingut després d'haver acabat: \n");
mi_ls2();
bumount(DISK_NAME);
}
/*
* Mostra el contingut d'un fitxer. Aquest cat és especial i permet mostrar el
* contingut d'un directori.
* mi_cat <nom>
* @return: 0 èxit, -1 nombre de paràmetres incorrecte
*/
int main(int argc, char **argv) {
char path[MAX_PATH_LEN];
int n_entries;
int error = 0;
emofs_inode_stat info;
char *buffer;
int offset = 0;
int bytes_left = 0;
int to_read = 0; /* bytes llegits */
int read_bytes = 0;
if (argc != 2) {
puts("Nombre de paràmetres incorrecte.");
puts("Ús: mi_cat <nom>");
return -1;
}
strcpy(path, argv[1]);
bmount();
if(!emofs_file_exists(path)) {
bumount();
return -2;
}
emofs_stat(path, &info);
for (bytes_left = info.size; bytes_left > 0; bytes_left -= C_BUF) {
to_read = (bytes_left < C_BUF) ? (bytes_left % C_BUF) : C_BUF;
read_bytes = emofs_read(path, (void *) &buffer, offset, to_read);
fwrite(buffer, read_bytes, 1, stdout);
/* A la ultima iteracio no es cert pero ens estalvam un acces
* a memoria a cada iteració. */
offset += C_BUF;
}
puts("");
bumount();
return error;
}
int main(int argc, char **argv) {
bmount(argv[1]);
int ninodo = atoi(argv[2]);
unsigned char buffer[BLOCKSIZE];
memset(buffer, 0, BLOCKSIZE);
int i = 0;
int leido = 0;
printf("Leyendo archivo\n");
while ((leido = mi_read_f(ninodo, buffer, i * BLOCKSIZE, BLOCKSIZE)) > 0) {
printf("%s", buffer);
memset(buffer,0,BLOCKSIZE);
i++;
}
printf("\n");
if (leido == -1) {
printf("No existe el fichero");
}
bumount();
}
int main(int argc, char **argv){
int i;
unsigned int fichero;
unsigned int cantidad_bloques;
unsigned int cantInt;
unsigned char buffer[BLOCKSIZE];
unsigned int numInodos;
fichero=bmount(argv[1]);
cantidad_bloques=atoi(argv[2]);
cantInt=atoi(argv[3]); //divisor para la cantidad de inodos de nuestro sistema
if (fichero==-1){
printf("Error en el montaje del dispositivo en mi_mkfs.c\n");
}
else
{
memset (buffer,0,BLOCKSIZE);
for (i=0; i<cantidad_bloques; i++){
bwrite(i,buffer);
}
printf("i: %i\n",i);
}
numInodos = cantidad_bloques/cantInt;
tamMB(cantidad_bloques);
tamAI(numInodos);
initSB(cantidad_bloques,numInodos);
initMB(cantidad_bloques);
initAI(numInodos);
bumount();
return 0;
}