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