E/S y sistema de ficheros María de los Santos Pérez Hernández mperez@fi.upm.es

Índice Conceptos básicos de E/S Concepto de sistema de ficheros Directorios Volúmenes y particiones Protección Ficheros, directorios y servicios en POSIX Cache de bloques Fiabilidad del sistema de ficheros Introducción a los sistemas de ficheros distribuidos (NFS) mperez@fi.upm.es

Referencias bibliográficas “Sistemas Operativos: una visión aplicada” Jesús Carretero et al. McGraw Hill, 2001 “Sistemas Operativos” Willian Stalling Willian Stalling Prentice Hall, 1997 “Operating System Concepts” A. Silberschatz, P. Galvin Addison-Wesley, 1998 mperez@fi.upm.es

Conceptos básicos de E/S Funciones del SO: Controlar el funcionamiento de los dispositivos de E/S Ofrecer un interfaz entre los dispositivos y el resto del sistema Hardware de E/S: Dispositivos de E/S: De bloques (discos) De caracteres (teclado, ratón) Controladores de dispositivos E/S programada Interrupciones DMA mperez@fi.upm.es

Hardware de E/S mperez@fi.upm.es

Conceptos básicos de E/S Software de E/S Objetivos: independencia de los dispositivos Estructuración del SW de E/S: mperez@fi.upm.es

Sistema de ficheros El acceso a los dispositivos es: Incómodo Detalles físicos de los dispositivos Dependiente de las direcciones físicas No seguro Si el usuario accede a nivel físico no tiene restricciones El sistema de ficheros es la capa de software entre dispositivos y usuarios. Objetivos: Suministrar una visión lógica de los dispositivos Ofrecer primitivas de acceso cómodas e independientes de los detalles físicos Mecanismos de protección mperez@fi.upm.es

Sistema de ficheros (II) El SF establece una correspondencia entre los ficheros y los dispositivos lógicos. mperez@fi.upm.es

Sistema de ficheros (III) Visión lógica: Ficheros Directorios Volúmenes y particiones Visión física: Bloques o bytes ubicados en dispositivos mperez@fi.upm.es

Ficheros: visión lógica Conjunto de información relacionada que ha sido definida por su creador Estructura de un fichero: Secuencia o tira de bytes (UNIX, POSIX) Registros (de tamaño fijo o variable) mperez@fi.upm.es

Ficheros: visión lógica (II) Estructura de un fichero (continuación): Ficheros de estructura compleja Ficheros indexados Ficheros directos o de dispersión Ejemplo de fichero indexado Los ficheros estructurados en registros y los ficheros con estructuras complejas se pueden construir como una capa sobre la visión de tira de bytes. mperez@fi.upm.es

Ficheros: visión lógica (III) Tipos de ficheros: Ficheros normales Ficheros especiales: De bloques De caracteres Atributos de un fichero: Nombre Tipo Dueño y grupo Información de protección Tamaño real Hora y fecha de creación Hora y fecha del último acceso Hora y fecha de la última modificación Número de enlaces mperez@fi.upm.es

Ficheros: visión lógica (IV) Tipos de acceso: Acceso secuencial Acceso directo Acceso indexado Operaciones sobre ficheros: Crear ficheros Abrir y cerrar ficheros Renombrar Borrar ficheros Leer y escribir ficheros Truncar un fichero Asignar espacio a un fichero Situar el puntero en una determinada posición dentro del fichero Obtener atributos Modificar atributos mperez@fi.upm.es

Ficheros: semántica de coutilización Para trabajar con un fichero hay que definir una sesión con las llamadas open y close. Semántica de coutilización: especifica el efecto de varios procesos accediendo de forma simultánea al mismo fichero. Tipos de semánticas: Semántica UNIX (POSIX) Las escrituras son inmediatamente visibles para todos los procesos con el fichero abierto. Los procesos pueden compartir ficheros. Si existe relación de parentesco pueden compartir el puntero. mperez@fi.upm.es

Ficheros: semántica de coutilización (II) Semántica de sesión Las escrituras que hace un proceso no son inmediatamente visibles para los demás procesos con el fichero abierto. Cuando se cierra el fichero los cambios se hacen visibles para las futuras sesiones. Un fichero puede asociarse temporalmente a varias imágenes. Semántica de ficheros inmutables Una vez creado el fichero sólo puede ser compartido para lectura y no cambia nunca mperez@fi.upm.es

Ficheros: visión física Conjunto de bloques ubicados en un dispositivo mperez@fi.upm.es

Ficheros: visión física (II) Bloque Unidad de transferencia 2n sectores Parámetro fijo por sistema de ficheros Agrupación Unidad de asignación 2p bloques Aumenta la secuencialidad del fichero Descripción de la estructura física: Bloques utilizados mperez@fi.upm.es

Descripción física en UNIX (nodo-i) Tamaño máximo del fichero: 10Sb+(Sb/4)Sb +(Sb/4)2Sb +(Sb/4)3Sb Sb el tamaño del bloque y direcciones de bloques de 4 bytes. mperez@fi.upm.es

Descripción física en MS-DOS (FAT) FAT de 12 bits 4K agrupaciones FAT de 16 bits 64K agrupaciones mperez@fi.upm.es

Directorios: visión lógica Un directorio es una tabla de entradas que asocia nombres simbólicos a ficheros. Esquema jerárquico. Cuando se abre un fichero el SO busca el nombre en la estructura de directorios. Operaciones sobre un directorio: Crear (insertar) y borrar (eliminar) directorios. Abrir y cerrar directorios. Renombrar directorios. Leer entradas de un directorio. Montar (combinar) La organización jerárquica de un directorio Simplifica el nombrado de ficheros (nombres únicos) Proporciona una gestión de la distribución => agrupar ficheros de forma lógica (mismo usuario, misma aplicación) mperez@fi.upm.es

Directorios: visión física Directorios en MS-DOS Directorios en UNIX mperez@fi.upm.es

Volúmenes y particiones Volumen: conjunto coherente de metainformación y datos. Ejemplos de volúmenes: mperez@fi.upm.es

Volúmenes y particiones (II) Descripción de volúmenes: El sector de arranque en MS-DOS El superbloque en UNIX Relación volumen-dispositivo: Típico: 1 dispositivo N volúmenes (particiones) Grandes ficheros: N dispositivos 1 volumen Típicamente cada dispositivo se divide en una o más particiones (en cada partición un volumen) La tabla de particiones indica el principio, el tamaño y el tipo de cada partición. mperez@fi.upm.es

Montado de volúmenes o particiones Oculta el nombre del dispositivo físico o partición En MS-DOS c:\tmp\datos.txt mperez@fi.upm.es

Enlaces Permite que dos o más nombres hagan referencia al mismo fichero. Dos tipos: Enlace físico El fichero sólo se elimina cuando se borran todos los enlaces Sólo se permiten enlazar ficheros (no directorios) del mismo volumen. Enlace simbólico El fichero se elimina cuando se borra el enlace físico. Si permanece el enlace simbólico provoca errores al tratar de accederlo. Se puede hacer con ficheros y directorios. Se puede hacer entre ficheros de diferentes volúmenes mperez@fi.upm.es

Enlace físico mperez@fi.upm.es

Enlace simbólico mperez@fi.upm.es

Protección Proteger del acceso inadecuado Distintos tipos de protección: Lectura Escritura Ejecución Eliminación Autenticación (¿quién?) Claves (paswords) Identificación física Tarjetas inteligentes Reconocimiento de voz Derechos de acceso (¿qué?) Objeto => qué usuarios y qué derechos Usuario => qué objetos y qué derechos mperez@fi.upm.es

Ficheros, directorios y servicios en POSIX (UNIX) Nombres de fichero y directorio: Nombre completo (empieza por /) /usr/include/stdio.h Nombre relativo al directorio actual (no empieza por /) stdio.h asumiendo que /usr/include es el directorio actual. La entradas . y .. pueden utilizarse para formar rutas de acceso ../include/stdio.h ./../include/stdio.h /usr/./include/../include/stdio.h Estos tres ficheros hacen referencia a stdio.h si /usr/include es el directorio actual mperez@fi.upm.es

Ficheros, directorios y servicios en POSIX (UNIX) (II) Tipos de fichero: Normales Directorios Especiales Descriptores de fichero: Entero no negativo que identifica un fichero abierto Se asignan en orden 0, 1, 2, ... Los procesos en su inicio: 0 entrada estándar 1 salida estándar 2 salida de error Se heredan en el fork() Los ficheros abiertos siguen abiertos después del exec() Cuando se hace un fork() se comparte el puntero mperez@fi.upm.es

Protección Identificación de usuarios y grupos UID: identificador de usuario GID: identificador de grupo Los procesos se ejecutan con UID real UID efectivo GID real GID efectivo mperez@fi.upm.es

Protección (II) Protección sobre un fichero UID del propietario y GID del grupo 9 bits de protección rwx para el propietario grupo y otros. En ficheros r => leer w => escribir x => permiso de ejecución En directorios r => listar contenidos w => crear o eliminar entradas x => permiso de acceso mperez@fi.upm.es

Protección (III) Bits SETUID y GETUID Reglas de protección: Si un proceso ejecuta un fichero con el SETUID activo UID efectivo = UID del propietario del fichero Si un proceso ejecuta un fichero con el GETUID activo GID efectivo = GID del propietario del fichero Reglas de protección: Si UID efectivo = 0 se concede el acceso Si UID efectivo = UID del propietario se utiliza el primer grupo de bits; si no Si GID efectivo = GID del propietario se utiliza el segundo grupos de bits; si no Se utiliza el último grupo de bits. mperez@fi.upm.es

Operaciones sobre ficheros mperez@fi.upm.es

open. Abre un fichero Servicio: Devuelve: Argumentos: Ejemplos: #include <sys/types.h> #include <sys/stat.h> #include <fcntl.h> int open(char *name, int flag, ...); Argumentos: name: Puntero al nombre del fichero flags: Opciones de apertura: O_RDONLY: Sólo lectura O_WRONLY: Sólo escritura O_RDWR: Lectura y escritura O_APPEND: El puntero de acceso se desplaza al final del fichero abierto O_CREAT: Si no existe no tiene efecto. Si no existe lo crea O_TRUNC: Trunca si se abre para escritura Devuelve: Un descriptor de fichero o -1 si hay error. Ejemplos: fd = open ("/home/juan/datos.txt"); ("/home/juan/datos.txt", O_WRONLY | O_CREAT | O_TRUNC, 0750); mperez@fi.upm.es

creat. Crea un fichero Servicio: Argumentos: Devuelve: Descripción: #include <sys/types.h> #include <sys/stat.h> #include <fcntl.h> int creat(char *name, mode_t mode); Argumentos: name: Nombre de fichero mode: Bits de permiso para el fichero Devuelve: Devuelve un descriptor de fichero ó -1 si error. Descripción: El fichero se abre para escritura. Si no existe crea un fichero vacío. UID_dueño = UID_efectivo GID_dueño = GID_efectivo Si existe lo trunca sin cambiar los bits de permiso. Ejemplos: fd = creat("datos.txt", 0751); fd = open("datos.txt", O_WRONLY | O_CREAT | O_TRUNC, 0751); mperez@fi.upm.es

read. Lectura de un fichero Servicio: #include <sys/types.h> ssize_t read(int fd, void *buf, size_t n_bytes); Argumentos: fd: descriptor de fichero buf: zona donde almacenar los datos n_bytes: número de bytes a leer Devuelve: Número de bytes realmente leídos ó -1 si error Descripción: Transfiere n_bytes. Puede leer menos datos de los solicitados si se rebasa el fin de fichero o se interrumpe por una señal. Después de la lectura se incrementa el puntero del fichero con el número de bytes realmente transferidos. mperez@fi.upm.es

write. Escritura de un fichero Servicio: #include <sys/types.h> ssize_t write(int fd, void *buf, size_t n_bytes); Argumentos: fd: descriptor de fichero buf: zona de datos a escribir n_bytes: número de bytes a escribir Devuelve: Número de bytes realmente escritos -1 si error Descripción: Transfiere n_bytes. Puede escribir menos datos de los solicitados si se rebasa el tamaño máximo de un fichero o se interrumpe por una señal. Después de la escritura se incrementa el puntero del fichero con el número de bytes realmente transferidos. Si se rebasa el fin de fichero el fichero aumenta de tamaño. mperez@fi.upm.es

close. Cierra un descriptor de fichero Servicio: int close(int fd); Argumentos: fd: descriptor de fichero Devuelve: Cero o -1 si error. Descripción: El proceso pierde la asociación a un fichero. mperez@fi.upm.es

lseek. Modifica el valor del puntero de posición Servicio: #include <sys/types.h> #include <unistd.h> off_t lseek(int fd, off_t offset, int whence); Argumentos: fd: Descriptor de fichero offset: desplazamiento whence: base del desplazamiento Devuelve: La nueva posición del puntero ó -1 si error. Descripción: Coloca el puntero de acceso asociado a fd La nueva posición se calcula: SEEK_SET: posición = offset SEEK_CUR: posición = posición actual + offset SEEK_END: posición = tamaño del fichero + offset mperez@fi.upm.es

dup. Duplica un descriptor de fichero Servicio: int dup(int fd); Argumentos: fd: descriptor de fichero Devuelve: Un descriptor de fichero que comparte todas las propiedades del fd ó -1 si error. Descripción: Crea un nuevo descriptor de fichero que tiene en común con el anterior: Accede al mismo fichero Comparte el mismo puntero de posición El modo de acceso es idéntico. El nuevo descriptor tendrá el menor valor numérico posible. mperez@fi.upm.es

ftruncate. Asigna espacio a un fichero Servicio: #include <unistd.h> int ftruncate(int fd, off_t length); Argumentos: fd descriptor de fichero length nuevo tamaño del fichero Devuelve: Devuelve 0 ó -1 si error. Descripción: El nuevo tamaño del fichero es length. Si length es 0 se trunca el fichero. mperez@fi.upm.es

Operaciones sobre directorios mperez@fi.upm.es

opendir. Abre un directorio Servicio: #include <sys/types.h> #include <dirent.h> DIR *opendir(char *dirname); Argumentos: dirname puntero al nombre del directorio Devuelve: Un puntero para utilizarse en readdir() o closedir(). NULL si hubo error. Descripción: Abre un directorio como una secuencia de entradas. Se coloca en el primer elemento. mperez@fi.upm.es

readdir. Lectura de entradas de directorio Servicio: #include <sys/types.h> #include <dirent.h> struct dirent *readdir(DIR *dirp); Argumentos: dirp puntero retornado por opendir(). Devuelve: Un puntero a un objeto del tipo struct dirent que representa una entrada de directorio o NULL si hubo error. Descripción: Devuelve la siguiente entrada del directorio asociado a dirp. Avanza el puntero a la siguiente entrada. La estructura es dependiente de la implementación. Debería asumirse que tan solo se obtiene un miembro: char *d_name. mperez@fi.upm.es

closedir. Cierra un directorio Servicio: #include <sys/types.h> #include <dirent.h> int closedir(DIR *dirp); Argumentos: dirp puntero devuelto por opendir(). Devuelve: Cero ó -1 si error. Descripción: Cierra la asociación entre dirp y la secuencia de entradas de directorio. mperez@fi.upm.es

rewindir. Sitúa el puntero de directorio Servicio: #include <sys/types.h> #include <dirent.h> void rewindir(DIR *dirp); Argumentos: dirp puntero devuelto por opendir() Descripción: Sitúa el puntero de posición dentro del directorio en la primera entrada. mperez@fi.upm.es

mkdir. Crea un directorio Servicio: #include <sys/types.h> #include <dirent.h> int mkdir(char *name, mode_t mode); Argumentos: name nombre del directorio mode bits de protección Devuelve: Cero ó -1 si error Descripción: Crea un directorio de nombre name. UID_dueño = UID_efectivo GID_dueño = GID_efectivo mperez@fi.upm.es

rmdir. Borra un directorio Servicio: #include <sys/types.h> int rmdir(char *name); Argumentos: name nombre del directorio Devuelve: Cero ó -1 si error Descripción: Borra el directorio si está vacío. Si el directorio no está vacío no se borra. mperez@fi.upm.es

link. Crea una entrada de directorio Servicio: #include <unistd.h> int link(char *existing, char *new); Argumentos: existing nombre del fichero existente. new nombre de la nueva entrada que será un enlace al fichero existente. Devuelve: Cero ó -1 si error. Descripción: Crea un nuevo enlace para un fichero existente. El sistema no registra cuál es el enlace original. existing no debe ser el nombre de un directorio salvo que se tenga privilegio suficiente y la implementación soporte el enlace de directorios. mperez@fi.upm.es

unlink. Elimina una entrada de directorio Servicio: #include <sys/types> int unlink(char *name); Argumentos: name nombre de fichero Devuelve: Cero ó -1 si error Descripción: Elimina la entrada de directorio y decrementa el número de enlaces del fichero correspondiente. Cuando el número de enlaces es igual a cero y ningún proceso lo mantiene abierto, se libera el espacio ocupado por el fichero y el fichero deja de ser accesible. mperez@fi.upm.es

chdir. Cambia el directorio actual Servicio: int chdir(char *name); Argumentos: name nombre de un directorio Devuelve: Cero ó -1 si error Descripción: Modifica el directorio actual, aquel a partir del cual se forman los nombre relativos. mperez@fi.upm.es

rename. Cambia el nombre de un fichero Servicio: #include <unistd.h> int rename(char *old, char *new); Argumentos: old nombre de un fichero existente new nuevo nombre del fichero Devuelve: Cero ó -1 si error Descripción: Cambia el nombre del fichero old. El nuevo nombre es new. mperez@fi.upm.es

getcwd. Obtiene el nombre del directorio actual Servicio: char *getcwd(char *buf, size_t size); Argumentos: buf puntero al espacio donde almacenar el nombre del directorio actual size longitud en bytes de dicho espacio Devuelve: Puntero a buf o NULL si error. Descripción: Obtiene el nombre del directorio actual mperez@fi.upm.es

Protección mperez@fi.upm.es

access. Accesibilidad sobre un fichero Servicio: #include <unistd.h> int access(char *name, int amode); Argumentos: name nombre del fichero amode modo de acceso que se quiere comprobar. amode es el OR inclusivo de R_OK, W_OK, X_OK o F_OK. Devuelve: 0 si el proceso tiene acceso al fichero (para lectura, escritura o ejecución) ó -1 en caso contrario mperez@fi.upm.es

access. Accesibilidad sobre un fichero (II) Descripción: Utiliza el UID real y el GID real (en lugar de los efectivos) para comprobar los derechos de acceso sobre un fichero. Ejemplos: access("fichero", F_OK) devuelve 0 si el fichero existe ó -1 si no existe. access("fichero", R_OK|W_OK) devuelve 0 si el proceso que ejecuta la llamada tiene permisos de acceso de lectura y escritura sobre el fichero (utilizando el UID real y el GID real). mperez@fi.upm.es

umask. Asigna la máscara de creación Servicio: #include <sys/types.h> #include <sys/stat.h> mode_t umask(mode_t cmask); Argumentos: cmask bits de permiso a desasignar en la creación de ficheros. Devuelve: Devuelve la máscara previa Descripción: Asigna la máscara de creación de ficheros del proceso que la invoca. Los bits activos en la máscara son desactivados en la palabra de protección del fichero. Si máscara =022 , y se crea un fichero con bits 0777 , los bits reales del fichero serán 0755 . mperez@fi.upm.es

chmod. Cambia los bits de permiso Servicio: #include <sys/types.h> #include <sys/stat.h> int chmod(char *name, mode_t mode); Argumentos: name nombre del fichero mode Nuevos bits de protección Devuelve: Cero ó -1 si error. Descripción: Modifica los bits de permiso y los bits SETUID y SETGID del fichero. Sólo el propietario del fichero puede cambiar estos bits mperez@fi.upm.es

chown. Cambia la propiedad de un fichero Servicio: #include <sys/types.h> #include <unistd.h> int chown(char name, uid_t owner, gid_t group); Argumentos: name nombre del fichero owner nuevo propietario del fichero group nuevo identificador de grupo del fichero Devuelve: Cero ó -1 si error Descripción: Modifica el identificador de usuario y de grupo del fichero Los bits SETUID y SETGID son borrados mperez@fi.upm.es

Atributos mperez@fi.upm.es

stat, fstat Información sobre un fichero Servicio: #include <sys/types.h> #include <sys/stat.h> int stat(char *name, struct stat *buf); int fstat(int fd, struct stat *buf); Argumentos: name nombre del fichero fd descriptor de fichero buf puntero a un objeto de tipo struct stat donde se almacenará la información del fichero. Devuelve: Cero ó -1 si error mperez@fi.upm.es

stat, fstat Información sobre un fichero Descripción: Obtiene información sobre un fichero y la almacena en una estructura de tipo struct stat: struct stat { mode_t st_mode; /* modo del fichero */ ino_t st_ino; /* número del fichero */ dev_t st_dev; /* dispositivo */ nlink_t st_nlink; /* número de enlaces */ uid_t st_uid; /* UID del propietario */ gid_t st_gid; /* GID del propietario */ off_t st_size; /* número de bytes */ time_t st_atime; /* último acceso */ time_t st_mtime; /* última modificacion */ time_t st_ctime; /* último modificacion de datos */ }; mperez@fi.upm.es

stat, fstat Información sobre un fichero Comprobación del tipo de fichero aplicado a st_mode: S_ISDIR(s.st_mode) Cierto si directorio S_ISCHR(s.st_mode) Cierto si especial de caracteres S_ISBLK(s.st_mode) Cierto si especial de bloques S_ISREG(s.st_mode) Cierto si fichero normal S_ISFIFO(s.st_mode) Cierto si pipe o FIFO mperez@fi.upm.es

utime. Fechas último acceso y modifación Servicio: #include <sys/stat.h> #include <utime.h> int utime(char *name, struct utimbuf *times); Argumentos: name nombre del fichero times estructura con las fechas de último acceso y modificación. time_t actime fecha de acceso time_t mctime fecha de modificación Devuelve: Devuelve 0 ó -1 si error Descripción: Cambia las fechas de último acceso y última modificación según los valores de la estructura struct utimbuf mperez@fi.upm.es

Ejemplo. Copia un fichero en otro #include <sys/types.h> #include <sys/stat.h> #include <fcntl.h> #include <stdio.h> #define BUFSIZE 512 main(int argc, char **argv) { int fd_ent, fd_sal; char buffer[BUFSIZE]; int n_read; /* abre el fichero de entrada */ fd_ent = open(argv[1], O_RDONLY); if (fd_ent < 0) { perror("open"); exit(1); } mperez@fi.upm.es

Ejemplo. Copia un fichero en otro (II) /* crea el fichero de salida */ fd_sal = creat(argv[2], 0644); if (fd_sal < 0) { close(fd_ent); perror("open"); exit(1); } /* bucle de lectura del fichero de entrada */ while ((n_read = read(fd_ent, buffer, BUFSIZE)) > 0) { /* escribir el buffer al fichero de salida */ if (write(fd_sal, buffer, n_read) < n_read) { perror("write2); close(fd_ent); close(fd_sal); mperez@fi.upm.es

Ejemplo. Copia un fichero en otro (III) if (n_read < 0) { perror("read"); close(fd_ent); close(fd_sal); exit(1); } close(fd_ent); close(fd_sal); exit(0); mperez@fi.upm.es

Ejemplo: redirecciones Programa que ejecuta ls > fichero void main(void) { pid_t pid; int status; int fd; fd = open("fichero", O_WRONLY|O_CREAT|O_TRUNC, 0644); if (fd < 0) { perror("open"); exit(1); } pid = fork(); switch(pid) { case -1: /* error */ perror("fork"); mperez@fi.upm.es

Ejemplo: redirecciones (II) case 0: /* proceso hijo ejecuta "ls" */ close(STDOUT_FILENO); /* cierra la salida estandar */ dup(fd); /* duplica el descriptor del fichero */ close(fd); execlp("ls","ls",NULL); perror("execlp"); exit(1); default: /* proceso padre */ close(fd); /* cierra el fichero */ while (pid != wait(&status)); } exit(0); mperez@fi.upm.es

Programa que lista un directorio #include <sys/types.h> #include <dirent.h> #include <stdio.h> #define MAX_BUF 256 void main(int argc, char **argv) { DIR *dirp; struct dirent *dp; char buf[MAX_BUF]; /* imrpime el directorio actual */ getcwd(buf, MAX_BUF); printf("Directorio actual: %s\n", buf); mperez@fi.upm.es

Programa que lista un directorio (II) /* abre el directorio pasado como argumento */ dirp = opendir(argv[1]); if (dirp == NULL) { fprintf(stderr,"No puedo abrir %s\n", argv[1]); } else { /* lee entrada a entrada */ while ( (dp = readdir(dirp)) != NULL) printf("%s\n", dp->d_name); closedir(dirp); } exit(0); mperez@fi.upm.es

Descomposición en operaciones de bloques Ficheros con estructura de bytes Escritura  leer mperez@fi.upm.es

Descomposición en operaciones de bloques (II) Ficheros de registros de tamaño fijo mperez@fi.upm.es

Cache de bloques Fundamento: Proximidad espacial Proximidad temporal Dos clases de flujos de E/S: Usan una sola vez cada bloque Usan repetidamente los bloques Acceso a disco mucho más lento que el acceso a memoria mperez@fi.upm.es

Cache de bloques (II) Estructura de datos en memoria con los bloques más frecuentemente utilizados Lecturas adelantadas Limpieza de la cache (sync) Principal problema: fiabilidad del sistema de ficheros. mperez@fi.upm.es

Fiabilidad del sistema de ficheros Fallos HW y SW pueden provocar fallos en un volumen Soluciones: Hardware: Controladores que tratan con sectores con fallos Discos con información redundante (RAID) Backups (copias de seguridad) En discos En cintas Backups incrementales mperez@fi.upm.es

Consistencia del sistema de ficheros Reparar fallos software en un volumen Ejemplo: herramienta fsck Dos tipos de consistencia: Consistencia sobre bloques: mperez@fi.upm.es

Consistencia del sistema de ficheros (II) Consistencia sobre ficheros: Contador de enlaces > contador real Contador de enlaces < contador real Número de nodo-i > Número total de nodos-i Ficheros con bits de protección 0007 Ficheros con privilegios en directorios de usuario mperez@fi.upm.es

Introducción a los sistemas de ficheros distribuidos (NFS) Objetivo: compartir y distribuir ficheros entre diferentes máquinas. En B mount -t nfs maqA:/bin /bin mount -t nfs maqA:/usr /usr mperez@fi.upm.es