/** * cluster_a_lba: transforma un cluster (direccion logica de FAT) a un * sector LBA (direccion logica de sector) * @param cluster cluster a transformar * @return el sectoren formato LBA */ int cluster_a_lba ( int cluster ) { int sector_dir_raiz; int tamanio_dir_raiz; int inicio; 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 */ tamanio_dir_raiz = ( sector_booteo->BPB_cant_entradas_root * sizeof ( entrada_directorio ) ) / 512; inicio = tamanio_dir_raiz + sector_dir_raiz; return ( (cluster - 2) * sector_booteo->BPB_sectores_por_cluster ) + inicio; }
/** * 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_abrir_dir ( dir* directorio ) { int sector_dir_raiz; int tamanio_dir_raiz; int cant_entradas = 512 / sizeof(entrada_directorio); //dir* directorio = direc + recuperar_base (); if ( sector_booteo == NULL ) { if ( cargar_BPB (sector_booteo) == ERROR ) { imprimir_cadena ("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; directorio->sector_a_leer = sector_dir_raiz; directorio->indice = -1; directorio->tamanio_dir_raiz = tamanio_dir_raiz; directorio->cant_entradas = cant_entradas; imprimir_cadena ("\ncantidad de sectores a leer: "); imprimir_entero (directorio->sector_a_leer); imprimir_cadena ("\nindice: "); imprimir_entero (directorio->indice); imprimir_cadena ("\ntamanio dir raiz: "); imprimir_entero (directorio->tamanio_dir_raiz); imprimir_cadena ("\ncantidad de entradas: "); imprimir_entero (directorio->cant_entradas); return OK; }