/************************************************************************/
/* */
/* SFBASICO.C */
/* ========== */
/* */
/* Implementación de un sistema de ficheros muy simple, */
/* para realizar prácticas de diseño de sistemas operativos. */
/* */
/* Características: */
/* */
/* - Sólo un directorio raíz */
/* - Ficheros de tamaño fijo */
/* - Transferencias por bloques (no por bytes) */
/* - Si se borra un fichero, los bloques ocupados */
/* no quedan disponibles */
/* */
/* Versión 2.0b */
/* */
/* © José Miguel Santos, Carmelo Rubén García, Gabino Padrón, */
/* 1996-97-98 */
/* */
/************************************************************************/
/* Ficheros cabeceras de la aplicación */
#include "sfbasico.h" /* Interfaz pública de este módulo */
#include "sffisico.h" /* Funciones de acceso a disco */
#include "errores.h" /* Códigos de error */
#include "descr.h" /* Descriptor de sistema de ficheros y superbloque */
#include "bfb.h" /* Estructura Bloque de Fichero Básico (BFB) */
/* Ficheros cabeceras para las bibliotecas del C */
#include <assert.h>
#include <string.h>
#include <stdlib.h>
/* En esta implementación, todos los ficheros tienen longitud fija */
/* Habrá que reformarlo para permitir longitudes variables */
#define NUM_BLOQUES_FICHERO 4
/* Macro para conocer si hay un disco montado */
/* Se utiliza por todo el código */
#define MONTADO \
{ Error_SF=ERR_SINERROR; \
if (DESC.montado==0) \
{ Error_SF=ERR_INACTIVO; return -1; } \
}
/************************************************************************/
/* */
/* FUNCIONES PÚBLICAS DEL MÓDULO */
/* IMPLEMENTACIÓN */
/* */
/************************************************************************/
/* Reserva espacio para un fichero */
/* En esta implementación, reserva un número fijo de bloques */
static DWORD ReservaEspacio (void);
/* Función FormateaSFB (nombre_fichero,args[]) */
/* */
/* Da formato a un disco, cuya ruta UNIX es el parámetro */
/* "nombre_fichero". "args" es un vector de cadenas de */
/* caracteres que contienen los parámetros para el formato.*/
/* Después del último parámetro, debería venir una cadena */
/* nula. */
/* */
/* En esta implementación básica, se pasan dos parámetros: */
/* */
/* args[0] - Cantidad de BFBs */
/* args[1] - Tamaño de bloque de datos */
/* Funciones secundarias del formato */
/* para dar formato a los BFB y los bloques de datos */
static void FormatoBFBs(void);
static void FormatoBloquesDatos(void);
int FormateaSFB ( const char* nombre_fichero, const char* args[] )
{
DWORD nbloques_BFB;
/* No puede haber un disco montado mientras se formatea */
if (DESC.montado==1)
{ Error_SF=ERR_MONTADO; return -1; }
/* Lee los parámetros del formateo */
if ( args[0]==0 || args[1]==0 || args[2]!=0 )
{ Error_SF = ERR_PARAMETRO; return -1; }
DESC.num_BFB = atoi(args[0]);
DESC.tam_bloque_datos = atoi(args[1]);
if ( DESC.num_BFB<=0 || DESC.tam_bloque_datos<=0 )
{ Error_SF = ERR_PARAMETRO; return -1; }
/* Monta el disco físico y recoge los parámetros del disco */
Error_SF = ERR_SINERROR;
MontaDisco(nombre_fichero,0);
LeeDatosDisco (&DESC.tam_bloque_fisico, &DESC.num_bloques_fisicos);
if (HAY_ERROR) { return -1; }
/* Comprueba si hay espacio suficiente: */
/* - el BFB tiene que caber en un bloque físico */
/* - los BFBs no deben ocupar todo el disco */
/* - debería haber bloques de datos suficientes */
/* para crear todos los ficheros */
nbloques_BFB = (DESC.num_BFB*TAM_BFB)/(DESC.tam_bloque_fisico)+1;
if ( DESC.tam_bloque_fisico < TAM_BFB
|| nbloques_BFB >= DESC.num_bloques_fisicos
|| DESC.num_bloques_fisicos < DESC.tam_bloque_datos*DESC.num_BFB + 2
)
{
DesmontaDisco();
Error_SF = ERR_ESPACIO;
return -1;
}
/* Calcula tamaños y límites */
DESC.org_BFB = 1;
DESC.org_datos = nbloques_BFB+1;
DESC.nbloques_datos =
(DESC.num_bloques_fisicos-DESC.org_datos) / DESC.tam_bloque_datos;
assert(DESC.nbloques_datos>0);
DESC.primer_bloque_libre = 0;
DESC.ultimo_bloque_datos = DESC.nbloques_datos-1;
/* Si todo está correcto, */
/* escribe la nueva información en el superbloque del disco */
EscribeSuperbloque(&DESC);
DesmontaDisco();
/* Se monta el nuevo sistema, para inicializar bloques, etc. */
MontaSFB(nombre_fichero,0);
/* Da formato a los bloques de fichero básicos */
FormatoBFBs();
/* Da formato a los bloques de datos */
/* (en esta implementación, no se hace nada con ellos) */
FormatoBloquesDatos();
/* Desmonta el disco y retorna */
return DesmontaSFB();
} /* FormateaSFB() */
/* Implementación de las funciones secundarias */
static
void FormatoBFBs (void)
{
int indice;
for ( indice=0; indice<DESC.num_BFB; indice++ )
{
BFB bfb;
/* Da valores iniciales a los campos del BFB */
bfb.estado = BFB_LIBRE;
bfb.id = indice;
bfb.nombre[0] = 0;
bfb.bloque=0;
/* Guarda el BFB en disco */
BFB_guarda (&bfb,indice);
}
}
static
void FormatoBloquesDatos (void)
{
/* En esta implementación, no hace falta hacer nada */
}
/* Función MontaSFB (nombre_fichero,nbloques_cache) */
/* */
/* Monta un disco formateado, cuya ruta UNIX es el */
/* parámetro "nombre_fichero". "nbloques_cache" es */
/* la cantidad de bloques en la caché, para pasárselo */
/* como parámetro a MontaDisco(). */
/* Para usar un SFB, primero hay que invocar a esta */
/* función. */
int MontaSFB ( const char* nombre_fichero, int nbloques_cache )
{
/* Monta el disco en bajo nivel */
Error_SF = ERR_SINERROR;
MontaDisco(nombre_fichero,nbloques_cache);
if (HAY_ERROR) return -1;
/* Lee el superbloque y configura DESC */
LeeSuperbloque(&DESC);
if (HAY_ERROR) return -1;
DESC.montado=1;
/* Habilita los datos para los BFB */
BFB_empieza_sesion ();
return 0;
} /* MontaSFB() */
/* Función DesmontaSFB () */
/* */
/* Desmonta el disco actualmente montado. */
int DesmontaSFB (void)
{
Error_SF = ERR_SINERROR;
/* Guarda el superbloque, por si acaso */
EscribeSuperbloque(&DESC);
/* Inhabilita datos de los BFB */
BFB_termina_sesion();
DESC.montado=0;
return 0;
} /* DesmontaSFB() */
/* Función CreaFB (nombre_fichero,num_bloques) */
/* */
/* Crea un fichero, de nombre "nombre_fichero". */
/* El parámetro "num_bloques" se ignora en esta */
/* implementación, ya que se trabaja con ficheros */
/* de tamaño fijo. */
/* */
/* Hay que reformar el código para permitir ficheros */
/* de cualquier tamaño. */
IFB CreaFB ( const char* nombre_fichero, WORD num_bloques )
{
int indice;
int buscando_hueco;
IFB ifb_libre;
BFB bfb;
/* Verifica que el disco está montado */
MONTADO
/* Si el nombre es la cadena vacía, es un error */
if (nombre_fichero[0]==0)
{ Error_SF=ERR_PARAMETRO; return -1; }
/* Busca una entrada libre */
/* y se asegura de que ningún otro BFB tiene el mismo nombre */
buscando_hueco=1;
for ( indice=0; indice<DESC.num_BFB; indice++ )
{
BFB_recoge (&bfb,indice);
if (HAY_ERROR) return NINGUN_IFB;
switch ( bfb.estado )
{
/* Si está ocupado, se compara el nombre */
case BFB_OCUPADO:
if ( !strncmp ( bfb.nombre, nombre_fichero, LONG_NOMBRE ) )
{
/* Si el nombre ya existía, es un error */
Error_SF = ERR_EXISTE;
return NINGUN_IFB;
}
break;
/* Si está libre, guarda la dirección del bloque */
/* para reservarlo posteriormente */
case BFB_LIBRE:
if ( buscando_hueco )
{
buscando_hueco=0;
ifb_libre = indice;
}
break;
default:
Error_SF = ERR_CORRUPTO;
return NINGUN_IFB;
} /* switch */
} /* for */
/* Si no se ha encontrado un BFB libre */
if (buscando_hueco)
{
Error_SF = ERR_ESPACIO;
return NINGUN_IFB;
}
/* Si se ha encontrado un BFB libre */
/* Carga en memoria el BFB correspondiente */
BFB_recoge (&bfb,ifb_libre);
/* Construye la estructura del nuevo BFB */
bfb.estado = BFB_OCUPADO;
bfb.bloque = ReservaEspacio();
if (HAY_ERROR) return NINGUN_IFB;
strncpy(bfb.nombre,nombre_fichero,LONG_NOMBRE);
/* Guarda el BFB en disco */
BFB_guarda (&bfb,ifb_libre);
return ifb_libre;
} /* CreaFB() */
/* Función DestruyeFB (fichero) */
/* */
/* Destruye el fichero referenciado por "fichero". */
/* */
/* En esta implementación, no se desasignan los bloques */
/* asignados al fichero. Hay que reformar el código para */
/* permitirlo. */
int DestruyeFB (IFB fichero)
{
BFB bfb;
/* Verifica que el disco está montado */
MONTADO
/* Lee de disco el BFB */
BFB_recoge (&bfb,fichero);
if (HAY_ERROR) return -1;
/* Comprueba que es un ifb ocupado */
if (bfb.estado==BFB_LIBRE)
{
Error_SF = ERR_LIBRE;
return -1;
}
/* Modifica la estructura del BFB */
/* Habría que liberar el espacio que ocupaba */
/* BFB_cambia_longitud(bfb,0); */
bfb.estado = BFB_LIBRE;
/* Actualiza la estructura en el disco */
BFB_guarda (&bfb,fichero);
if (HAY_ERROR) return -1;
return 0;
} /* DestruyeFB() */
/* Función BuscaFB (nombre_fichero) */
/* */
/* Busca el fichero especificado dentro de los BFBs. */
/* Si lo encuentra, devuelve el IFB correspondiente. */
/* Si no lo encuentra, devuelve NINGUN_IFB. */
IFB BuscaFB ( const char* nombre_fichero )
{
int ifb;
/* Si el nombre es la cadena vacía, es un error */
if (nombre_fichero[0]==0)
{ Error_SF=ERR_PARAMETRO; return NINGUN_IFB; }
/* Verifica que hay un disco montado */
MONTADO
/* Busca en todos los BFBs */
for ( ifb=0; ifb < DESC.num_BFB; ifb++ )
{
BFB bfb;
BFB_recoge (&bfb,ifb);
if (HAY_ERROR) return NINGUN_IFB;
/* Si lo encuentra, deja de buscar y retorna */
if ( bfb.estado==BFB_OCUPADO )
if ( !strncmp ( bfb.nombre, nombre_fichero, LONG_NOMBRE ) )
return ifb;
}
/* Si termina de barrer y no encuentra nada */
return NINGUN_IFB;
} /* BuscaFB() */
/* Función EntradaDir (entrada,nombre) */
/* */
/* "entrada" es el número de orden dentro del direc- */
/* torio del fichero que se quiere encontrar. */
/* Si la entrada existe, devuelve el IFB correspondiente. */
/* Si no existe, devuelve NINGUN_IFB. */
/* En "nombre" aparece el nombre simbolico del fichero */
IFB EntradaDir ( int entrada, char* nombre )
{
BFB bfb;
int contador=0;
IFB ifb;
MONTADO
/* Busca en el directorio la entrada correspondiente */
for ( ifb=0; ifb<DESC.num_BFB; ifb++ )
{
BFB_recoge(&bfb,ifb);
if (bfb.estado==BFB_OCUPADO)
{
if (contador==entrada)
{
strncpy (nombre,bfb.nombre,LONG_NOMBRE);
return ifb;
}
else contador++;
}
}
/* Si el numero de entrada es muy grande,
se devuelve un ifb nulo */
nombre[0]=0;
Error_SF = ERR_RANGO;
return NINGUN_IFB;
} /* EntradaDir() */
/* Función LongitudFB (fichero) */
/* */
/* Devuelve la longitud del fichero referenciado por */
/* "fichero". */
/* */
/* En esta implementación, se devuelve una cantida fija. */
/* Si se reforma el código para permitir ficheros de */
/* tamaño variable, habrá que retocar esta función. */
WORD LongitudFB ( IFB fichero )
{
BFB bfb;
MONTADO
BFB_recoge (&bfb,fichero);
return HAY_ERROR ? (WORD)-1 : NUM_BLOQUES_FICHERO;
} /* LongitudFB() */
/* Función CambiaLongitudFB (fichero,num_bloques) */
/* */
/* Cambia la longitud del fichero referenciado por */
/* "fichero" a "num_bloques". Por tanto, puede hacer */
/* crecer o encoger el fichero. "num_bloques" puede */
/* valer cero. */
/* */
/* En esta implementación, no se hace nada, ya que se */
/* trabaja con ficheros de longitud fija. */
/* Si se reforma el código para permitir ficheros de */
/* tamaño variable, habrá que retocar esta función. */
int CambiaLongitudFB ( IFB fichero, WORD num_bloques )
{
BFB bfb;
MONTADO
BFB_recoge(&bfb,fichero);
/* ... cambia la longitud del fichero ... */
/* BFB_guarda(&bfb,fichero); */
return HAY_ERROR ? -1 : 0;
} /* CambiaLongitudFB() */
/* Función TamBloqueDatos () */
/* */
/* Devuelve el tamaño en bytes del bloque de datos */
/* empleado por el sistema de ficheros montado. */
WORD TamBloqueDatos (void)
{
MONTADO
return DESC.tam_bloque_datos*DESC.tam_bloque_fisico;
}
/* Función EspacioLibre() */
/* */
/* Devuelve el espacio libre en bytes */
DWORD EspacioLibre (void)
{
MONTADO
return
( DESC.ultimo_bloque_datos - DESC.primer_bloque_libre + 1 )
* TamBloqueDatos();
}
/* Función FicherosLibres() */
/* */
/* Devuelve el número de BFBs disponibles */
WORD FicherosLibres (void)
{
unsigned contador=0;
IFB ifb;
MONTADO
for ( ifb=0; ifb<DESC.num_BFB; ifb++ )
{
BFB bfb;
BFB_recoge (&bfb,ifb);
if ( bfb.estado==BFB_LIBRE ) contador++;
}
return contador;
}
/* Funciones: */
/* LeeBloqueFB (fichero,num_bloque,bufer) */
/* EscribeBloqueFB (fichero,num_bloque,bufer) */
/* */
/* Lee/escribe el bloque "num_bloque" del fichero */
/* referenciado por "fichero" en/desde la dirección */
/* de memoria apuntada por "bufer". */
/* */
/* Como son funciones muy similares, se hace uso de una */
/* función común de acceso a un bloque del FB, llamada */
/* AccedeBloqueFB() */
enum Oper { LECTURA=0, ESCRITURA=1 };
static
int AccedeBloqueFB ( IFB fichero, WORD num_bloque, void* bufer, enum Oper );
int LeeBloqueFB ( IFB fichero, WORD num_bloque, void* bufer )
{
return AccedeBloqueFB(fichero,num_bloque,bufer,LECTURA);
}
int EscribeBloqueFB ( IFB fichero, WORD num_bloque, const void* bufer )
{
return AccedeBloqueFB(fichero,num_bloque,(void*)bufer,ESCRITURA);
}
/* Función general para lecturas y escrituras */
static
int AccedeBloqueFB ( IFB fichero, WORD num_bloque, void* bufer, enum Oper tipo )
{
BFB bfb;
/* Verifica que el disco está montado */
MONTADO
/* Si el bloque se sale de los límites del fichero, retorna */
if ( num_bloque>=NUM_BLOQUES_FICHERO )
{
Error_SF = ERR_RANGO;
return -1;
}
/* Lee el BFB correspondiente */
BFB_recoge (&bfb,fichero);
if (bfb.estado==BFB_LIBRE)
{
Error_SF = ERR_LIBRE;
return -1;
}
/* Accede al bloque de datos */
{
DWORD bloque_datos = bfb.bloque + num_bloque;
DWORD bloque_fisico = DESC.org_datos
+ bloque_datos*DESC.tam_bloque_datos;
int nbloque;
if ( bloque_datos > DESC.nbloques_datos )
{ Error_SF = ERR_RANGO; return -1; }
/* Como un bloque de datos puede consistir en varios bloques físicos,
se entra en un bucle de transferencias */
for ( nbloque=0; nbloque<DESC.tam_bloque_datos; nbloque++ )
{
/* Calcula de qué bloque físico se trata */
DWORD bloque_transfer = bloque_fisico + nbloque;
/* Calcula la dirección de memoria para este bloque */
void* direccion_memoria = ((char*)bufer)
+ (DESC.tam_bloque_fisico*nbloque);
/* Realiza la transferencia */
if (tipo==LECTURA)
LeeBloqueFisico (bloque_transfer,direccion_memoria);
else
EscribeBloqueFisico (bloque_transfer,(const void*)direccion_memoria);
if (HAY_ERROR) return -1;
}
}
return 0;
} /* AccedeBloqueFB() */
/* Función ReservaEspacio() */
/* */
/* Reserva NUM_BLOQUES_FICHERO bloques del espacio libre. */
/* Simplemente avanza el apuntador a la zona de bloques */
/* libres. */
/* */
/* Esta función dejará de tener sentido cuando se gestione */
/* eficientemente el espacio libre y se trabaje con fi- */
/* cheros de tamaño variable. */
#define CHUNGO ((DWORD)-1)
static
DWORD ReservaEspacio (void)
{
DWORD bloque_inicial;
assert (DESC.primer_bloque_libre<=DESC.ultimo_bloque_datos);
assert (DESC.montado==1);
/* Verifica si queda espacio libre */
if ( DESC.primer_bloque_libre >=
DESC.ultimo_bloque_datos - NUM_BLOQUES_FICHERO )
{
Error_SF = ERR_ESPACIO;
return CHUNGO;
}
/* Mueve el apuntador a los bloques libres*/
bloque_inicial = DESC.primer_bloque_libre;
DESC.primer_bloque_libre += NUM_BLOQUES_FICHERO;
/* Por seguridad, se actualiza el superbloque */
EscribeSuperbloque (&DESC);
if (HAY_ERROR) return CHUNGO;
return bloque_inicial;
} /* ReservaEspacio() */