/** * cargar_fat: Carga la tabla FAT en memoria (en una variable global) * * @return el estado de la operacion */ int cargar_fat() { int indice; int tamanio_fat; dword sector_fat; if ( sector_booteo == NULL ) { if ( cargar_BPB (sector_booteo) == ERROR ) { imprimir ("Error cargando el sector de booteo\n"); return ERROR; } } // obtengo el tamanio de la fat en bytes tamanio_fat = sector_booteo->BPB_tamanio_FAT * 512; // le aloco memoria fat = (byte*) sys_alocar ( tamanio_fat ); // inicializo la FAT con ceros setear_memoria ( fat, 0, tamanio_fat ); // obtengo el primer sector (LOGICO) donde comienza la tabla FAT // (el primer sector es el del BPB, luego del cual vienen los sectores // reservados, y a continuacion la tabla FAT). sector_fat = sector_booteo->BPB_cant_sectores_reservados + 1; // leo los N sectores que conforman la tabla FAT imprimir ( "Cargando FAT" ); for ( indice = 0; indice < sector_booteo->BPB_tamanio_FAT; indice++ ) { imprimir ( "." ); /* * sector_fat es un sector logico, el cual antes de leerlo hay que * trasnformarlo a CHS. * fat es el buffer donde leemos, pero hay que ir incrementandolo por * cada lectura(la primera vez (fat), la segunda (fat+512), y asi... */ if ( leer_sector_logico (sector_fat, fat + indice * 512) == LECTURA_ERRONEA ) { imprimir ( "Error al leer la tabla fat!\n" ); return ERROR; } // leo el siguiente sector logico sector_fat++; } imprimir ( "\n" ); #ifdef DEBUG // el MediaID es 0xF0 para disquettes! imprimir ( "FAT Cargada, MediaID: 0x%xb\n", *fat ); #endif return OK; }
/** * buscar_entrada: busca una entrada dentro del root directory * @param nombre nombre de la entrada a buscar * @param arch puntero a la variable donde se almacenaran los datos * de la entrada encontrada * * @return el estado de la operacion */ int buscar_entrada ( char* nombre, entrada_directorio* arch ) { int indice, j; int sector_dir_raiz; int tamanio_dir_raiz; int cant_entradas = 512 / sizeof(entrada_directorio); entrada_directorio ed[cant_entradas]; if ( sector_booteo == NULL ) { if ( cargar_BPB (sector_booteo) == ERROR ) { imprimir ("Error cargando el sector de booteo\n"); return ERROR; } } /* * calculo el primer sector del directorio raiz: * 1 (BPB) + cant_sectores_reservados + tam_FAT * cant_tablas_FAT */ sector_dir_raiz = sector_booteo->BPB_cant_sectores_reservados + 1 + sector_booteo->BPB_tamanio_FAT * sector_booteo->BPB_cant_FAT; /* * calculo la cantidad de sectores que ocupa el directorio raiz * Nota: se redondea para arriba! */ tamanio_dir_raiz = ( sector_booteo->BPB_cant_entradas_root * sizeof ( entrada_directorio ) + 512 ) / 512; // leo los N sectores del directorio raiz for ( indice = 0; indice < tamanio_dir_raiz; indice++ ) { if ( leer_sector_logico ( sector_dir_raiz++, ed ) == LECTURA_ERRONEA ) { imprimir ( "Error leyendo directorio raiz!\n" ); return ERROR; } for ( j = 0; j < cant_entradas; j++ ) { if ( ed[j].nombre[0] == ULTIMA_ENTRADA ) { return ERROR; } else if ( ed[j].atributos != ATR_NOMBRE_LARGO && ed[j].atributos != ATR_ID_UNIDAD && ed[j].nombre[0] != BORRADO ) { if ( comparar_nombres ( nombre, ed[j].nombre ) == OK ) { *arch = ed[j]; return OK; } } } } return ERROR; }
int sys_leer_entrada_dir ( char* entrada, dir* directorio ) { int i; static entrada_directorio* ed = NULL; //dir* directorio = direc + recuperar_base (); //char* entrada = ent + recuperar_base (); if ( directorio == NULL ) { return ERROR; } if ( ed == NULL ) { ed = (entrada_directorio*) sys_alocar ( directorio->cant_entradas ); } if ( directorio->indice == -1 ) { if ( leer_sector_logico (directorio->sector_a_leer++, ed) == LECTURA_ERRONEA ) { imprimir ( "Error leyendo directorio raiz!\n" ); return ERROR; } directorio->indice = 0; } if ( ed[directorio->indice].nombre[0] == ULTIMA_ENTRADA ) { return NULL; } for ( i = 0; i < 11; i++ ) { entrada[i] = ed[directorio->indice].nombre[i]; } entrada[i] = '\0'; if (directorio->indice+1 == directorio->cant_entradas) { directorio->indice = -1; } else { directorio->indice += 1; } return OK; }
/** * leer_archivo: lee desde un file descriptor, que representa un archivo, * analoga a la funcion read de UNIX * @param fd descriptor de archivo * @param buffer posicion de memoria donde se leera * @param cant cantidad de bytes a leer * @return estado de la lectura */ int leer_archivo ( int fd, void* buffer, unsigned int cant ) { unsigned int cluster_a_leer; unsigned int tam_lectura; char* buffer_temporal; int sector_logico; int bytes_leidos = 0; int indice_copia = 0; int idx; descriptor_archivo descr = tarea_actual->archivos [ fd ]; #ifdef DEBUG imprimir ( "Se va a leer: <" ); for ( idx = 0; idx < 11; idx++ ) { imprimir ( "%c", descr.ed.nombre[idx] ); } imprimir ( ">\n" ); #endif buffer_temporal = (char*) sys_alocar ( 512 ); indice_copia = descr.posicion_actual % 512; while ( cant > 0 ) { // si todavia tengo que leer el sector actual (aun no avanzo). if ( descr.posicion_actual == 0 || (descr.posicion_actual % 512) != 0 ) { cluster_a_leer = descr.cluster_actual; if ( cant < ( 512 - (descr.posicion_actual % 512) ) ) { tam_lectura = cant; } else { tam_lectura = 512 - ( descr.posicion_actual % 512 ); } } else { cluster_a_leer = proximo ( descr.cluster_actual ); descr.cluster_actual = cluster_a_leer; if ( cluster_a_leer == 0x0 || (cluster_a_leer & 0x0FF0) == 0x0FF0 ) { imprimir ( "ultimo cluster: 0x%x\n", cluster_a_leer ); //return bytes_leidos; break; } tam_lectura = cant > 512 ? 512 : cant; } if ( tam_lectura + bytes_leidos > descr.ed.tamanio ) { tam_lectura = descr.ed.tamanio - bytes_leidos; tam_lectura = tam_lectura > 512 ? 512 : tam_lectura; cant = 0; imprimir ("se quiere leer mas de lo que se puede!\n" ); } sector_logico = cluster_a_lba ( cluster_a_leer ); leer_sector_logico ( sector_logico, buffer_temporal ); for ( idx = indice_copia; idx < (indice_copia+tam_lectura); idx++ ) { ((char*)buffer) [ idx - indice_copia + bytes_leidos ] = buffer_temporal [ idx ]; } cant -= tam_lectura; descr.posicion_actual += tam_lectura; bytes_leidos += tam_lectura; indice_copia += tam_lectura; indice_copia = indice_copia == 512 ? 0 : indice_copia; } tarea_actual->archivos [ fd ] = descr; return bytes_leidos; }