Sistemas de ficheros virtual Introduccin David Borrego Vias

Sistemas de ficheros virtual Introducción David Borrego Viñas Borja Navarro Paradinas 1

Introducción n Función del sistema de ficheros Mantener los ficheros en estructura de árbol n Los nodos hojas son los ficheros y el resto de nodos son los directorios n La información de los nodos se guarda en las estructuras inode n La estructura del sistema de ficheros en la estructura de superbloque n 2

Introducción 3

Introducción n En 1993 Remy Card diseña el sistema de ficheros “ext”: n n VFS tiene: n n n Mediante una capa de software “VFS” trabaja con sistemas de ficheros reales: ISO 9660, vfat un conjunto de estructuras en memoria principal un conjunto de funciones para manejarlas Para cada uno de los sistemas de ficheros reales n n una serie de estructuras en disco su conjunto particular de funciones para manejarlas. 4

Introducción n Para poder trabajar con sistemas de ficheros reales deben montarse (insertarse en el árbol en /mnt) El sistema de ficheros trata los dispositivos como secuencias de bloques, el manejador del dispositivo será el encargado de traducir las peticiones de bloques en cabeza, cilindro, pista, etc… El VFS oculta las características de los sistemas reales n Mantiene unas estructuras en memoria RAM y unos procedimientos para trabajar con estos 5

Estructura file_system_type n Al arrancar el PC se inicializa cada sistema de ficheros y se registra mediante la función “register_file_system” en una lista de estructuras de tipo “file_system_type”, apuntadas por la variable “file_system” n Podemos ver los sistemas de ficheros registrados en el sistema leyendo el fichero /proc/filesystems. 6

Estructrura file_system_type struct file_system_type { /* nombre del sistema de ficheros real ( ext 2, minix, msdos) */ const char *name; /* flags para indicar si el sistema de ficheros precisa un dispositivo * de bloques para soportarlo */ int fs_flags; /* función particular de cada sistema de fichero real que lee * su superbloque en disco y escribe en el superbloque del VFS */ struct super_block *(*read_super) (struct super_block *, void *, int); struct module *owner; /* para kernel mount, si es un sistema de ficheros FS_SINGLE */ struct vfsmount *kern_mnt; struct file_system_type * next; }; 7

Montaje sistema de ficheros real n Si ejecutamos la siguiente instrucción: mount –t sist_fich dispositivo puntomontaje n El VFS busca en la lista “file_system_type” si el sist_fich está soportado. n Busca el inode del puntomontaje. n Se llama al procedimiento “read_super” particular al sistema de ficheros para leer el superbloque almacenado en dispositivo y demás información para crear el superbloque del VFS en el vector “super_blocks” (super bloques montados) 8

Montaje sistema de ficheros real n Cada sistema de ficheros montado se describe por la estructura vfsmount que forman una lista apuntada por la variable vfsmntlist, en include/linux/mount. h 9

Montaje sistema de ficheros real struct vfsmount { struct list_head mnt_hash; struct vfsmount *mnt_parent; /* entrada al directorio cache que indica el inodo del punto de montaje o directorio de montaje*/ struct dentry *mnt_mountpoint; /* entrada al directorio cache que indica el inodo del directorio raiz del sistema de archivos */ struct dentry *mnt_root; /* root del arbol montado */ /* otros vsmonunts del mismo sistema de ficheros */ struct list_head mnt_instances; struct super_block *mnt_sb; /* puntero al superblock */ struct list_head mnt_mounts; /* lista de hijos, anclados aquí */ struct list_head mnt_child; /* y recorriendo a traves de su mnt_child */ atomic_t mnt_count; int mnt_flags; /* condiciones de montaje */ /* nombre del dispositivo de bloques que contiene el sistema de ficheros montado(/dev/cdrom) char *mnt_devname; /* lista de estructuras vfsmount (next) */ struct list_head mnt_list; uid_t mnt_owner; }; 10

Montaje sistema de ficheros real n n n Para desmontar un sistema de ficheros “umount” no se debe estar usando ninguno de sus ficheros. Si el campo dirty del superbloque está activado, se debe actualizar el superbloque de disco y liberar la estructura super_block de memoria y la estructura vfsmount. Existen varias funciones que trabajan con esta estructura vfsmount n n n lookup_vfsmnt – busca un sistemas de archivos en la lista. add_vfsmnt – añade un sistema de ficheros montado en la lista remove_vfsmnt – quita de la lista un sistema de ficheros que se desmonta 11

Superbloque Al montar los sistemas de ficheros reales se representan en la tabla “super_blocks” struct super_block { /* lista doblemente enlazada de todos los superbloques activos */ struct list_head s_list; /* para sistemas de ficheros que requieren un bloque (dispositivo físico) para ser * montado en él. Se trata de un identificador de dicho dispositivo (ejem. 0 x 301 para el * disco IDE /dev/hda 1) */ kdev_t s_dev; /* tamaño del bloque en bytes, (1024 bytes) */ unsigned long s_blocksize; /* tamaño del bloque en bytes expresado en potencia de 2 */ unsigned char s_blocksize_bits; /* indica si el superbloque ha sido modificado y debe escribirse en disco */ unsigned char s_dirt; /* tamaño maximo del fichero */ unsigned long s_maxbytes; /* puntero a la estructura file_system_type que indica el tipo de sistema de fichero */ struct file_system_type *s_type; /* puntero a la estructura que contiene las funciones especificas de * este sistema de fichero real usadas para leer inodos y superbloque */ struct super_operations *s_op; /* puntero a las funciones relacionadas con la cuota de disco */ struct dquot_operations *dq_op; 12

Superbloque /* opciones para el montaje */ unsigned long s_flags; /* número que identifica a este sistema de ficheros y que servirá para que * Linux pueda reconocer dicho file system en cualquier partición */ unsigned long s_magic; /* puntero a la entrada de directorio donde esta el inodo raiz del sistema * de ficheros montado */ struct dentry *s_root; /* semáforo para bloquear el descriptor */ struct rw_semaphore s_umount; /* indica cuando un superbloque está actualmente bloqueado por lock_super()/unlock_super() */ struct semaphore s_lock; /* lista de todos los inodos del superbloque han sido modificados */ struct list_head s_dirty; /* lista con los inodos que tienen que escribirse en disco */ struct list_head s_locked_inodes; /* lista de todos los ficheros abiertos en este superbloque */ struct list_head s_files; /* puntero a la estructura que contiene las características del dispositivo * que contiene el sistema de ficheros */ struct block_device *s_bdev; /* lista de estructuras vfsmount(s) de sistemas de archivos * montados pertenecientes a este superbloque */ struct list_head s_mounts; /* opciones de cuota de disco */ struct quota_info s_dquot; 13

Estructura inode n Todo fichero o directorio accedido es representado en el VFS con un struct inode. n n n Cada inode se llena mediante funciones especificas del sistema real. Para un acceso más rápido se estructuran en listas en el inode caché. Todos los inode se combinan en una lista global, además mediante una tabla de hash se acceden a lista con igual valor de hash. Cuando se necesita un inodo y no está en caché, se busca en disco y se almacena en la caché, usando un count, para extraer un inodo de la caché. El valor de hash se obtiene con el número de dispositivo y el de inode 14

Estructura inode Cuando se extrae un inodo modificado (dirty=1) se debe escribir en disco. n Las funciones sobre un inode son especificas de cada sistema de fichero “inode_operations” n 15

Estructura inode struct inode { struct list_head i_hash; /* lista de hash */ struct list_head i_list; /* lista global de inodos*/ struct list_head i_dentry; /* lista de inodos en la cache directorio */ /* lista de inodos que han sido modificado y precisan escribirse * en disco */ struct list_head i_dirty_buffers; unsigned long i_ino; /* número del inode, i_ino; inode, es único */ /* número de veces que se ha abierto este inodo, si esta a cero * este inodo se puede quitar de memoria */ atomic_t i_count; /* número de usos del inodo */ /* identificador del dispositivo que contiene el sistema de ficheros */ kdev_t i_dev; umode_t i_mode; /* tipo y derechos de acceso a este inodo */ nlink_t i_nlink; /* número de enlaces a este inodo*/ uid_t i_uid; /* identificador del propietario*/ gid_t i_gid; /* identificador de grupo del propietario */ kdev_t i_rdev; ; /* identificador de archivo especial */ i_rdev loff_t i_size; /* tamaño del fichero en bytes */ time_t i_atime; /* fecha del último acceso */ time_t i_mtime; /* fecha de la última modificación */ time_t i_ctime; /* fecha de creación del inode*/ 16

Estructura inode /* tamaño del bloque para este fichero en bytes (1024) */ unsigned long i_blksize; /* número de bloques asignado a este fichero */ unsigned long i_blocks; /* numero de versión, se incrementa con cada nuevo uso */ unsigned long i_version; unsigned short i_bytes; /*semaforo para los accesos concurrentes al inodo */ /* struct semaphore i_sem; struct rw_semaphore i_truncate_sem; struct semaphore i_zombie; /* puntero a funciones que operan con el inodo especificas del * sistema de ficheros real (define las operaciones que se pueden realizar con cada inodo )*/ struct inode_operations *i_op; /* puntero a funciones que operan con la estructura file */ struct file_operations *i_fop; /* former ->i_op ->default_file_ops */ i_fop; ->i_op-> /* puntero a la estructura super_block de este sistema de ficheros */ struct super_block *i_sb; /* variable utilizada para sincronizar los accesos concurrentes a este inode */ wait_queue_head_t i_wait; /* puntero a las estructuras de bloqueo de este inodo en memoria*/ struct file_lock *i_flock; 17

Estructura inode /* puntero a las áreas y páginas de memoria de este inode */ struct address_space *i_mapping; struct address_space i_data; /* cuotas del disco asociadas con este inodo */ struct dquot *i_dquot[MAXQUOTAS]; /* puntero a la estructura pipe si el inodo representa un pipe */ struct pipe_inode_info *i_pipe; /* puntero a la estructura block_device si el inodo representa * un dispositivo de modo bloque */ struct block_device *i_bdev; /* puntero a la estructura char_device si el inodo representa * un dispositivo de modo carácter */ struct char_device *i_cdev; /* mascara para notificación de eventos a directorios */ unsigned long i_dnotify_mask; struct dnotify_struct *i_dnotify; /* para notificaciones a directorios */ unsigned long i_state; /* opciones de montaje del sistema de ficheros que contiene el inodo */ unsigned int i_flags; /* campo que indica si el inode representa a un socket */ unsigned char i_sock; 18

Estructura inode /* número de aperturas para escritura de este nodo */ atomic_t i_writecount; unsigned int i_attr_flags; __u 32 i_generation; /* información especifica de cada sistema de ficheros */ union { struct minix_inode_info minix_i; struct ext 2_inode_info ext 2_i; struct ext 3_inode_info ext 3_i; struct hpfs_inode_info hpfs_i; struct ntfs_inode_info ntfs_i; struct msdos_inode_info msdos_i; …. struct jffs 2_inode_info jffs 2_i; /* campo para guardar la dirección de datos privados */ void *generic_ip; } u; }; 19

Estructura inode (operaciones) struct inode_operations { /* crea una entrada en el directorio cache */ int (*create) (struct inode *, struct dentry *, int); /* busca en el directorio un inode */ struct dentry *(*lookup) (struct inode *, struct dentry *); /* crea un enlace a un inodo */ int (*link) (struct dentry *, struct inode *, struct dentry *); /* borra un enlace a un inodo */ int (*unlink) (struct inode *, struct dentry *); /* crea un enlace simbólico al inodo */ int (*symlink) (struct inode *, struct dentry *, const char *); /* crea un directorio */ int (*mkdir) (struct inode *, struct dentry *, int); /* borra un directorio */ int (*rmdir) (struct inode *, struct dentry *); /* crea un archivo especial */ int (*mknod) (struct inode *, struct dentry *, int); /* cambia el nombre de un fichero o directorio */ int (*rename) (struct inode *, struct dentry *, struct inode *, struct dentry *); 20

Estructura inode(operaciones) /* lee el contenido de un enlace simbólico */ int (*readlink) (struct dentry *, char *, int); /* resuelve un enlace simbólico */ int (*follow_link) (struct dentry *, struct nameidata *); /* modifica el tamaño de un fichero */ void (*truncate) (struct inode *); /* comprueba los permisos para acceder al fichero */ int (*permission) (struct inode *, int); /* detecta las nuevas caracteríaticas del dispositivo removible */ int(*revalidate) (struct dentry *); int (*setattr) (struct dentry *, struct iattr *); int (*getattr) (struct dentry *, struct iattr *); }; 21

Estructura address_space n Estructura que contiene las VMA y las páginas de este inodo. struct address_space { struct list_head clean_pages; /* lista de páginas clean */ struct list_head dirty_pages; /* lista de páginas modificadas*/ struct list_head locked_pages; /* lista de páginas bloqueadas*/ unsigned long nrpages; /* número total de páginas*/ spinlock_t page_lock; /* bloqueo de páginas en memoria */ /* punteros a funciones que operan con el espacio de direcciones */ struct address_space_operations *a_ops; struct inode *host; /* inode del dispositvo de bloques */ /* lista de direcciones de memoria privadas*/ struct vm_area_struct *i_mmap; /* lista de direcciones de memoria compartidas*/ struct vm_area_struct *i_mmap_shared; spinlock_t i_shared_lock; /* bloqueo para protección */ int gfp_mask; /* como asignar las páginas */ }; 22

Tabla de montajes 23

Caché de directorios n Para mayor eficiencia en la búsqueda de un directorio o fichero se usan dos tablas de cache, con las entradas de directorio más usadas y sus inodos. Se estructuran como una tabla de hash con varias listas, donde cada entrada apunta a una lista con el mismo valor de hash. n La función de hash usa el identificador de dispositivo y el nombre del directorio. (fs/dcache. c) n 24

Buffer caché n Para minimizar accesos a disco se implementa un conjunto de buffer que actúan como interfaz entre usuario y dispositivo. Las lecturas y escrituras se realizan sobre el buffer y el sistema escribe o lee del buffer en el bloque de disco. n Compartido por todos los sistemas de ficheros reales montados, puesto que es independiente de las características físicas de cada sistema n 25

Buffer caché n n Contiene uno o varios bloques referenciados por el número de bloque y de dispositivo. Existen varias listas según el estado de los bloques: n Dirty, Shared, clean. 26

Estructura file Es creada por el VFS al abrir un fichero, y se encadenan en una lista de estructuras file apuntadas por “first_file”. n Definida en “include/linux/fs. h”. n 27

Estructura file struct file { struct list_head f_list; /* lista de estructuras file */ struct dentry *f_dentry; /* puntero al inodo de ese fichero */ /* puntero a la estructura de ficheros montados */ struct vfsmount *f_vfsmnt; /* conjunto de operaciones relacionadas con un fichero abierto */ struct file_operations *f_op; /* puntero a file_operations */ atomic_t f_count; /* flag relacionado con el modo de apertura del fichero */ unsigned int f_flags; /* modo de apertura del fichero en la llamada open, conjunción * de FMODE_READ y FMODE_WRITE */ mode_t f_mode; /* posición actual desde el principio del fichero en bytes */ loff_t f_pos; 28

Estructura file /* número de bloques a leer en lectura anticipada */ unsigned long f_reada, /* número máximo de bloques a leer en lectura anticipada */ f_ramax, /* posición dentro del fichero, después de la última pagina leída * de forma anticipada */ f_raend, /* número de bytes leidos en la última lectura anticipada */ f_ralen, /* tamaño de la ventana para lectura anticipada */ f_rawin; /* estructura con información del proceso propietario */ struct fown_struct f_owner; /* identificador del propietario y de su grupo */ unsigned int f_uid, f_gid; int f_error; unsigned long f_version; /* necesario para algunos manejadores como el tty */ void *private_data; }; 29

Operaciones sobre ficheros n Esta estructura tiene punteros a funciones que trabajan con la estructura file y son propias y se implementan en el sistema de ficheros real. struct file_operations { struct module *owner; /* modifica la posición actual del fichero */ loff_t (*llseek) (struct file *, loff_t, int); /* lectura en el fichero */ ssize_t (*read) (struct file *, char *, size_t, loff_t *); /* escritura en el fichero */ ssize_t (*write) (struct file *, const char *, size_t, loff_t *) /* lee entradas desde el directorio */ int (*readdir) (struct file *, void *, filldir_t); unsigned int (*poll) (struct file *, struct poll_table_struct *); /* realiza operaciones de control sobre un dispositivo */ int (*ioctl) (struct inode *, struct file *, unsigned int, unsigned long); /* coloca el contenido de un fichero en la memoria del proceso */ int (*mmap) (struct file *, struct 30

Operaciones sobre ficheros /* abre un fichero */ int (*open) (struct inode *, struct file *); int (*flush) (struct file *); /* se llama al efectuar el último cierre de un archivo */ int (*release) (struct inode *, struct file *); /* escribe los bloques modificados del fichero en disco */ int (*fsync) (struct file *, struct dentry *, int datasync); /* activa o desactiva las entradas o salidas asincronas sobre el fichero */ int (*fasync) (int, struct file *, int); int (*lock) (struct file *, int, struct file_lock *); /* lectura adelantada de varios bloques */ ssize_t *readv) (struct file *, const struct iovec *, unsigned long, loff_t *); /* escritura de varios bloques */ ssize_t (*writev) (struct file *, const struct iovec *, unsigned long, loff_t *); ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *, int); unsigned long (*get_unmapped_area) (struct file *, unsigned long, unsigned long); }; 31

Llamada al sistema Proceso n Interfaz de llamada al sistema Sistema virtual de ficheros (caché de nombres) ext 2 fs minix proc Cuando un proceso hace una llamada al sistema es atendida por el VFS y es redirigida al sistema de ficheros particular de que se trate. Buffer cache Gestor de dispositivos (drivers) Máquina 32