Documenti di Didattica
Documenti di Professioni
Documenti di Cultura
ficheros virtual
Introducción
3
Introducción
En 1993 Remy Card diseña el sistema de
ficheros “ext”:
Mediante una capa de software “VFS” trabaja con
sistemas de ficheros reales: ISO9660,vfat
VFS tiene:
un conjunto de estructuras en memoria principal
un conjunto de funciones para manejarlas
Para cada uno de los sistemas de ficheros
reales
una serie de estructuras en disco
su conjunto particular de funciones para
manejarlas.
4
Introducció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
Mantiene unas estructuras en memoria RAM y
unos procedimientos para trabajar con estos
5
Estructura
file_system_type
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”
6
Estructrura
file_system_type
struct file_system_type {
/* nombre del sistema de ficheros real ( ext2, 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
Si ejecutamos la siguiente instrucción:
mount –t sist_fich dispositivo puntomontaje
El VFS busca en la lista “file_system_type”
si el sist_fich está soportado.
Busca el inode del puntomontaje.
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
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
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
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. 0x301 para el
14
Estructura inode
Cuando se extrae un inodo modificado
(dirty=1) se debe escribir en disco.
Las funciones sobre un inode son especificas
de cada sistema de fichero “inode_operations”
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;
i_ino; /* número del 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;
i_count; /* número de usos del inodo */
/* identificador del dispositivo que contiene el sistema de ficheros */
kdev_t i_dev;
i_dev;
umode_t i_mode;
i_mode; /* tipo y derechos de acceso a este inodo */
nlink_t i_nlink;
i_nlink; /* número de enlaces a este inodo*/
uid_t i_uid;
i_uid; /* identificador del propietario*/
gid_t i_gid;
i_gid; /* identificador de grupo del propietario */
kdev_t i_rdev;
i_rdev; /* identificador de archivo especial */
loff_t i_size;
i_size; /* tamaño del fichero en bytes */
time_t i_atime;
i_atime; /* fecha del último acceso */
time_t i_mtime;
i_mtime; /* fecha de la última modificación */
time_t i_ctime;
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;
i_blksize;
/* número de bloques asignado a este fichero */
unsigned long i_blocks;
i_blocks;
/* numero de versión, se incrementa con cada nuevo uso */
unsigned long i_version;
i_version;
unsigned short i_bytes;
/*semaforo para los accesos concurrentes al inodo */
struct semaphore i_sem;
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;
*i_op;
/* puntero a funciones que operan con la estructura file */
struct file_operations *i_fop; /* former ->i_op->default_file_ops */
/* puntero a la estructura super_block de este sistema de ficheros */
struct super_block *i_sb;
*i_sb;
/* variable utilizada para sincronizar los accesos concurrentes a este inode */
wait_queue_head_t i_wait;
i_wait;
/* puntero a las estructuras de bloqueo de este inodo en memoria*/
struct file_lock *i_flock;
*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;
__u32 i_generation;
/* información especifica de cada sistema de ficheros */
union {
struct minix_inode_info minix_i;
struct ext2_inode_info ext2_i;
struct ext3_inode_info ext3_i;
struct hpfs_inode_info hpfs_i;
struct ntfs_inode_info ntfs_i;
struct msdos_inode_info msdos_i;
….
struct jffs2_inode_info jffs2_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,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
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
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.
La función de hash usa el identificador de
dispositivo y el nombre del directorio.
(fs/dcache.c)
24
Buffer caché
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.
Compartido por todos los sistemas de ficheros
reales montados, puesto que es independiente
de las características físicas de cada sistema
25
Buffer caché
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:
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”.
Definida en “include/linux/fs.h”.
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
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 *);
31
Llamada al sistema
Proceso Cuando un proceso
Interfaz de llamada al sistema hace una llamada
Sistema virtual de ficheros
al sistema es
(caché de nombres) atendida por el
VFS y es redirigida
ext2fs minix proc
al sistema de
ficheros particular
Buffer cache
de que se trate.
Gestor de dispositivos
(drivers)
Máquina
32