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