Vi t l Fil t S it h Virtual Filesystem Switch

Vi t l Fil
Virtual
Filesystem
t
SSwitch
it h
Ancor Santiago
g Romero Gutiérrez
Daniel Suárez García
1
1
VFS - Introducción
Sistema ficheros: Es una estructura de tipo árbol, en la que los
nodos son los directorios y las hojas son los ficheros. Esto permite
al sistema operativo mantener los ficheros con un cierto orden.
En el caso de linux, el sistema de ficheros estándar es el ext, que
actualmente se encuentra en su versión 3.
L sistemas
Los
it
soportados
t d por linux
li
se pueden
d dividir
di idi en 3 categorías:
t
í
y
Basados en disco: discos duros, disquetes, CD-ROM, etc. (Estos
sistemas son: ext2, ext3, ReiserFS, XFS, JJFS, ISO9660, etc.))
y
Sistemas remotos (de red): NFS, Coda, Samba, etc.
y
Sistemas especiales: procfs, ramfs y devfs.
2
2
VFS - Introducción
ext3
/
bin
ls
etc
cat
mnt
CD
dev
usr
sbin
dos
bin
etc
src
lib
gcc
cdrom
windows
3
3
VFS - Objetivo
y
Objetivo: Transparencia del sistema de ficheros mediante
el uso de una capa de software por encima de los sistemas
de ficheros reales.
y
Para cada
P
d lectura,
l
escritura
i
u otra operación
ió que realice
li ell
usuario, el VFS apunta a la operación correspondiente para
cada sistema de ficheros que sustituirá a la función
inicialmente referenciada.
4
4
VFS - Funcionamiento
La filosofía de funcionamiento es:
X
X
X
X
X
Se produce una llamada al sistema que implica un acceso a un
sistema de ficheros.
El VFS determina a qué sistema de ficheros vamos a acceder.
acceder
Se comprueba si existe ya una entrada en el caché y si dicha
entrada es válida.
En el caso de que se requiera
requiera, se accede a la función del sistema de
ficheros específico a través de las estructuras del VFS.
La función puede, o bien completar la llamada, o bien requerir una
operación de E/S sobre un dispositivo,
dispositivo que en su caso puede
provocar el paso a modo "sleep" del proceso que invocó la
operación sobre el sistema de ficheros , hasta que la operación se
complete.
5
5
VFS - Funcionamiento
VFS
directorio
cache
superb
inode cache
superb
cdrom
superb
wind
ext2
buffer cache
manejador
disco
6
6
VFS – Ejemplo Funcionamiento
7
7
VFS - Estructuras
y
VFS tiene un conjunto de estructuras en memoria principal,
principal
definidas en el archivo include/linux/fs.h:
◦ lista de sistemas soportados
◦ lista de sistemas montados
◦ superbloque
◦ inode
◦ buffer cache
◦ cache de directorios
◦ File
y
Una serie de funciones para poder manejarlas.
8
8
VFS - Estructuras
y
Por su parte, cada sistema de ficheros tiene sus propias
estructuras de datos en disco.
y
Y unas funciones propias para cada sistema para el manejo
de dichas estructuras.
9
9
VFS - Interacción entre procesos y
entidades VFS
10
10
VFS - Sistemas soportados
¿Qué pasa cuando arrancamos el sistema?
Cuando el sistema arranca cada sistema de ficheros se inicializa y se
registra en el VFS llamando a la función register_file_system en una
lista de estructuras file_system_type, apuntadas por la variable
file_systems.
file_systems
*read_super
name ext2
next
*read_super
name vfat
next
*read_super
name 9660
next
11
11
VFS – file_system_type
file system type
struct file_system
y
_type
yp
{
const char *name;
int fs_flags;
int (*get_sb)
* t b (struct file_system_type *,
* int,
const char *, void *);
};
void (*kill_sb)
(*kill sb) (struct super
super_block
block *);
struct module *owner;
struct file_system_type * next;
struct list_head
list head fs_supers;
fs supers;
struct lock_class_key s_lock_key;
struct lock_class_key s_umount_key;
struct lock_class_key i_lock_key;
struct lock_class_key i_mutex_key;
struct lock_class_key i_mutex_dir_key;
struct lock_class_key i_alloc_sem_key
12
12
VFS – file_system_type
(campos)
name: nombre, aparece en el fichero /proc/filesystems y es usado como clave para encontrar un
sistema de ficheros por su nombre
fs_flags: Banderas,
FS_REQUIRES_DEV para sistemas de ficheros que sólo pueden ser
montados como dispositivos de bloque.
FS_SINGLE para sistemas de ficheros que pueden tener sólo un superbloque.
FS_NOMOUNT para los sistemas de ficheros que no pueden ser montados
el espacio de usuario.
desde
*get_sb: Copia el superbloque del sistema de ficheros real en el VFS. Se invoca cuando montamos
un sistema de ficheros.
*kill_sb: deshace las inicializaciones y las asignaciones realizadas por get_sb(). Se invoca al
desmontar el sistema de ficheros.
Next: puntero al siguiente nodo de la lista.
fs_supers: puntero al primer nodo de una lista que contiene todos los superbloques del mismo tipo.
13
13
VFS - Sistemas montados
¿Qué pasa cuando se monta un sistema de ficheros real?
Al invocar una orden del tipo:
mount –t sistemaficheros –o ro dispositivofisico puntomontaje
Ej: mount –t iso9660 –o ro /dev/cdrom /mnt/CD
VFS buscará el nombre del sistema de ficheros en la lista apuntada
por file_sytems y llamará a la función get_sb que cargará el
superbloque correspondiente.
correspondiente
14
14
VFS – Sistemas montados
¿Qué pasa cuando se monta un sistema de ficheros real?
file_system_type
file
system type ofrece poca información acerca del sistema
de ficheros montado.
Por ello, cada sistema de ficheros montado se describe por una
estructura vfsmount. Todas forman una lista apuntada por
current->namespace->list en /include/linux/mount.h.
current->namespace->list,
/include/linux/mount h
current->
namespace
->list
*mnt_mountp
oint
*mnt_root
*mnt_sp
*mnt_mountp
oint
*mnt_root
*mnt_sp
*mnt_mountp
oint
*mnt_root
*mnt_sp
15
15
VFS - vfsmount
struct vfsmount {
struct list_head mnt_hash;
struct vfsmount *mnt_parent;
/* fs we are mounted on */
struct dentryy *mnt_mountpoint;
/* dentryy of mountpoint
p
*/
struct dentry *mnt_root;
/* root of the mounted tree */
struct super_block *mnt_sb; /* pointer to superblock */
struct list_head
_
mnt_mounts;
_
/* list of children, anchored here */
struct list_head mnt_child;
/* and going through their mnt_child */
int mnt_flags;
/* 4 bytes hole on 64bits arches */
const char *mnt_devname;; /* Name of device e.g.
g /dev/dsk/hda1 */
struct list_head mnt_list;
struct list_head mnt_expire; /* link in fs-specific expiry list */
struct list_head mnt_share;; /* circular list of shared mounts */
struct list_head mnt_slave_list;
/* list of slave mounts */
struct list_head mnt_slave;
/* slave list entry */
16
16
VFS - vfsmount
struct vfsmount *mnt_master;
*mnt master;
/* slave is on master->mnt_slave_list
master >mnt slave list */
struct mnt_namespace *mnt_ns; /* containing namespace */
int mnt_id;
/* mount identifier */
int mnt_g
group
p_id;;
/* p
peer group
g p identifier */
/*
* We put mnt_count & mnt_expiry_mark at the end of struct vfsmount
* to let these frequently modified fields in a separate cache line
* (so that reads of mnt_flags wont ping-pong on SMP machines)
*/
atomic_t mnt_count;
int mnt_expiry_mark;
mnt expiry mark;
/* true if marked for expiry */
int mnt_pinned;
int mnt_ghosts;
/
/*
* This value is not stable unless all of the mnt_writers[] spinlocks
* are held, and all mnt_writer[]s on this mount have 0 as their ->count
*/
atomic_t __mnt_writers;
};
17
17
VFS – Desmontando un FS
¿Y que pasa cuando desmontamos?
umount /mnt/CD
/
/CD
◦
El sistema comprueba que el directorio pasado es un punto de
montaje, que el usuario tenga privilegios para desmontarlo y
que ninguno de sus archivos este en uso.
◦
Comprueba que en el superbloque el campo s_dirt del
superbloque y si este esta activado guarda los cambios en el
disco.
◦
Libera la estructura vfsmount y la la estructura super_block si
nadie mas la esta usando.
18
18
VFS – Algunas funciones
y
alloc_vfsmnt(name)
Ubica e inicializa un sistema de ficheros montado
y
free_vfsmnt(mnt)
(
)
Libera una descriptor de fs apuntado por mnt
y
lookup_mnt(mnt, dentry)
Realiza la función de hash correspondiente y devuelve la dirección
de el struct vfsmount correspondiente.
correspondiente
19
19
VFS - Superbloque
y
Mantiene metadatos sobre los sistemas de ficheros montados.
Está representado por un bloque de control de sistema
almacenado
l
d en disco.
d
y
Cuando los sistemas de ficheros reales se montan en el sistema
son representados en el sistema en la tabla super_blocks
(linux/fs/super.c) de NR_SUPER elementos de estructura
super_block. Esta tabla se encuentra en memoria principal.
20
20
VFS – super_block
super block
struct super
p _block {
struct list_head
s_list;
/* Keep this first */
dev_t
s_dev;
/* search index; _not_ kdev_t */
unsigned long
s blocksize;
s_blocksize;
unsigned char
s_blocksize_bits;
unsigned char
s_dirt;
unsigned long long
s_maxbytes;
b t
/* Max file
f size */
struct file_system_type *s_type;
p _ p
*s_op;
_ p
const struct super_operations
struct dquot_operations *dq_op;
struct quotactl_ops
*s_qcop;
const struct export_operations
export operations *s
s_export_op;
export op;
unsigned long
s_flags;
unsigned long
s_magic;
21
21
VFS – super_block
super block
struct dentry
*s_root;
struct rw_semaphore
s_umount;
struct mutex
s_lock;
int
s_count;
int
s_need_sync_fs;
atomic_t
s_active;
#ifdef CONFIG_SECURITY
CONFIG SECURITY
void
*s_security;
#endif
struct xattr_handler
**
**s_xattr;
tt
struct list_head
s_inodes;
/* all inodes */
_
s_dirty;
_ y
/* dirtyy inodes */
struct list_head
struct list_head
s_io;
/* parked for writeback */
struct list_head
s_more_io;
/* parked for more writeback
*/
22
22
VFS – super_block
super block
struct hlist_head
s_anon;/* anonymous
y
dentries for ((nfs))
exporting */
struct list_head
s_files; /* s_dentry_lru and
s_nr_dentry_unused are protected by dcache_lock */
struct list_head
s_dentry_lru; /* unused dentry lru */
int
s_nr_dentry_unused; /* # of dentry on lru */
struct block_device
block device
*s
s_bdev;
bdev;
struct mtd_info
*s_mtd;
struct list_head
s_instances;
struct
t t quota_info
t i f
s dquot
s_dquot;
/* Diskquota
Di k
t specific
ifi options
ti
*/
int
s_frozen;
wait_queue_head_t
s_wait_unfrozen;
char
s_id[32];
/* Informational name */
void
*s_fs_info; /* Filesystem private info */
fmode t
fmode_t
s mode;
s_mode;
23
23
VFS - Superbloque
s_list: una lista doblemente enlazada de todos los superbloques activos.
s_dev: para sistemas de archivos que requieren un bloque para ser
montado en él.
s_blocksize, s_blocksize_bits: tamaño del bloque y log2(tamaño del
bloque).
s_lock: indica cuando un superbloque está actualmente bloqueado por
lock_super()/unlock_super().
s_dirt: establece cuando superbloque está modificado, y limpiado cuando es
vuelto a ser escrito a disco.
s_type:
t
puntero a struct file_system_type
f
del sistema de archivos
correspondiente.
s_op: puntero a la
l estructura super_operations, la
l cuall contiene métodos
é d
específicos del sistema de archivos para leer/escribir inodos, etc.
24
24
d
i
d
d di
VFS - Superbloque
s_flags: banderas de superbloque.
s_magic: número mágico del sistema de archivos. Usado por el sistema de
archivos de minix para diferenciar entre múltiples tipos de él mismo.
s_root: dentry de la raiz del sistema de archivos.
s_wait: cola de espera de los procesos esperando para que el superbloque
sea desbloqueado.
s_dirty: una lista de todos los inodos sucios.
s_files: una lista de todos los archivos abiertos en este superbloque.
p
q
s_bdev: para FS_REQUIRES_DEV, esto apunta a la estructura block_device
p
en el que
q el sistema de archivos está montado.
describiendo el dispositivo
s_mounts: una lista de todas las estructuras vfsmount, una por cada instancia
25
25
montada de este superbloque.
VFS – Operaciones de superbloque
Las operaciones
p
de superbloque
p
q están descritas en la estructura
super_operations declarada en include/linux/fs.h:
struct super_operations {
struct inode *(*alloc_inode)(struct super_block *sb);
void (*destroy
vo
( dest oy_inode)(struct
ode)(st uct inode
o e *);
);
void (*dirty_inode) (struct inode *);
int (*write_inode) (struct inode *, int);
void (*drop_inode)
(*drop inode) (struct inode *);
void (*delete_inode) (struct inode *);
void (*put_super) (struct super_block *);
void (*write_super) (struct super_block *);
int (*sync_fs)(struct super_block *sb, int wait);
p _block *);
);
int ((*freeze_fs)) ((struct super
int (*unfreeze_fs) (struct super_block *);
26
26
VFS – Operaciones de superbloque
int (*statfs) (struct dentry *, struct kstatfs *);
int (*remount_fs) (struct super_block *, int *, char *);
void
id (*clear_inode)
(*clear inode) ((struct
t t iinode
d *)
*);
void (*umount_begin) (struct super_block *);
int (*show_options)(struct seq_file *, struct vfsmount *);
int (*show_stats)(struct seq_file *, struct vfsmount *);
#ifdef CONFIG_QUOTA
ssize t ((*quota
ssize_t
quota_read)(struct
read)(struct super_block
super block *,, int, char *,, size_t,
size t, loff_t);
loff t);
ssize_t (*quota_write)(struct super_block *, int, const char *, size_t,
loff_t);
#endif
int (*bdev_try_to_free_page)(struct super_block*, struct page*,
gfp_t);
};
27
27
VFS – Operaciones de superbloqe
read_inode: lee un inodo desde el sistema de archivos.
write_inode: escribe un inodo de vuelta al disco.
put_inode: llamado cuando la cuenta de referencia es decrementada.
delete_inode:
d
l t i d llamado
ll
d cuando
d inode->i_count
i d i
y iinode->i_nlink
d i li k llllegana
a 0.
put_super:
t
llamado en las últimas etapas de la llamada al sistema
umount para notificar al sistema de archivos que cualquier información
mantenida por el sistema de archivos sobre esa instancia tiene que ser
liberada.
liberada
write_super: llamado cuando el superbloque necesita ser vuelto a
escribir en el disco
disco.
statfs: implementa las llamadas al sistema fstatfs / statfs.
28
28
VFS – Operaciones de Superbloque
clear_inode: llamado desde el nivel VFS clear_inode(). Los sistemas
que
incluyen datos privados a la estructura del inodo (a través del campo
generic_ip) deben liberarse aquí.
umount_begin: llamado durante el desmontaje forzado para
notificarlo al sistema de archivos de antemano, por lo tanto puede ser
lo mejor para asegurarse que nada mantiene al sistema de archivos
ocupado.
29
29
VFS - Inodos
y
Todo fichero y directorio del sistema de ficheros está representado
por un inodo
i d del
d l VFS.
VFS
y
La información que contiene un inodo se construye obteniendo
i f
información
ió d
dell sistema
i
d
de fificheros
h
reall mediante
di
ffunciones
i
específicas de cada uno de ellos.
y
Todo
T
d ffichero
h
od
directorio que estáá siendo
d accedido,
d d se representa
en el VFS por medio de un struct “inode” en la memoria principal
del núcleo. Permanecen ahí mientras sean útiles para el sistema.
30
30
VFS – Inode cache
y
Inode cache:
◦ A medida que navegamos por el sistema de ficheros, sus inodes VFS son
leídos o escritos continuamente. VFS mantiene una cache de inodes para
acelerar este proceso.
Esta cache se construye con unas tablas de hash cuyas entradas son
punteros a listas doblemente encadenadas de inodes VFS con el
mismo valor hash.
y
Si un inode se necesita y no está en la cache, se busca en el disco el
inodo y se almacena en ésta.
y
Las funciones de lectura y escritura de inodos en disco son
específicas de cada fs -> “inode_operations”.
31
31
VFS – Inode cache
listas de inodes
tabla
hash
first_
inode
32
32
VFS – struct inode
struct inode {
struct hlist_node
_
i_hash;
_
struct list_head
i_list;
struct list_head
i_sb_list;
struct list_head
i_dentry;
unsigned long
i_ino;
atomic_t
i_count;
unsigned int
i_nlink;
uid_t
id
i id
i_uid;
gid_t
i_gid;
dev_t
i_rdev;
u64
i version;
i_version;
loff_t
i_size;
#ifdef __NEED_I_SIZE_ORDERED
seqcount t
seqcount_t
i size seqcount;
i_size_seqcount;
#endif
struct timespec
i_atime;
struct timespec
p
i_mtime;;
struct timespec
i_ctime;
33
33
VFS – struct inode (II)
unsigned int
i_blkbits;
blkcnt t
blkcnt_t
i blocks;
i_blocks;
unsigned short
i_bytes;
umode_t
i_mode;
spinlock t
spinlock_t
i lock;
i_lock;
struct mutex
i_mutex;
struct rw_semaphore i_alloc_sem;
const struct inode
inode_operations
operations
*i op;
*i_op;
const struct file_operations *i_fop;
struct super_block
*i_sb;
str ct file_lock
struct
file l ck
*i flock;
*i_flock;
struct address_space
*i_mapping;
struct address_space
i_data;
#ifd f CONFIG_QUOTA
#ifdef
CONFIG QUOTA
struct dquot
*i_dquot[MAXQUOTAS];
#endif
struct list_head
li h d
i d i
i_devices;
34
34
VFS – struct inode (III)
union {
struct pipe
pipe_inode_info
inode info *i_pipe;
*i pipe;
struct block_device
*i_bdev;
struct cdev
*i_cdev;
};
int
i_cindex;
__u32
u32
i generation;
i_generation;
#ifdef CONFIG_DNOTIFY
unsigned long
i_dnotify_mask;
struct dnotify_struct *i_dnotify;
#endif
#ifdef CONFIG_INOTIFY
CONFIG INOTIFY
struct list_head
inotify_watches;
struct mutex
inotify_mutex;
#endif
35
35
VFS – struct inode (IV)
unsigned
i d llong
i t t
i_state;
unsigned long
dirtied_when;
unsigned int
i_flags;
atomic_t
i_writecount;
#ifdef CONFIG_SECURITY
void
*ii_security;
security;
#endif
void
*i_private;
};
36
36
VFS – Inode - Campos
i_hash: lista de inodos con el mismo valor de hash.
i_list: lista global de inodos.
i_ino: número de inode (único).
i_count: número de usos del inode.
i_mode: flags.
i_nlink: número de enlaces a este inode.
i uid: identificador de usuario propietario.
i_uid:
propietario
i_gid: identificador de grupo propietario.
i_size: tamaño del fichero asociado.
i_time: fecha del último acceso.
i_mtime: fecha de última modificación.
i_ctime: fecha de creación.
i_blkbits: tamaño del bloque en bits
i_blksize: tamaño del bloque
i blocks: número de bloques que ocupa el inode.
i_blocks:
inode
37
37
VFS – Inode – Campos (II)
i_lock: cerrojo para asegurar exclusión mutua.
i_op: puntero a estructura de operaciones de inode.
i fop: puntero a estructura de operaciones de ficher.
i_fop:
ficher
i_sb: puntero al superbloque.
i_mapping: puntero a las áreas y páginas de memoria de este inode.
i data
i_data
i_dquot[MAXQUOTAS]: cuotas de disco.
i_pipe: puntero a estructura pipe si el inode representa un pipe.
i_cdev: puntero a block_device si el inode representa un dispositivo de
modo bloque.
dirtied when: fecha de la primera modificación.
dirtied_when:
i_writecount: número de accesos de escritura.
38
38
VFS – Inode - address_space
address space
Contiene las VMA y las ppáginas
g
del inode
struct address_space {
struct inode
*host
struct radix_tree_root page_tree;
spinlock
sp
oc _tt
ttree
ee_lock;
oc ;
unsigned int
i_mmap_writable;
struct prio_tree_root i_mmap;
struct list_head
list head
i mmap nonlinear;
i_mmap_nonlinear;
spinlock_t
i_mmap_lock;
unsigned int
truncate_count;
unsigned long
nrpages;
pgoff_t
writeback_index;
p _operations
p
*a_ops;
p ;
const struct address_space
39
39
VFS – Inode - address_space
address space
unsigned long
struct backing_dev_info
spinlock t
spinlock_t
struct address_space
flags;
*backing_dev_info;
private lock;
private_lock;
*assoc_mapping;
} __attribute__((aligned(sizeof(long))));
ib
(( li d( i f(l ))))
40
40
VFS – Operaciones de Inode(I)
Cada sistema de ficheros tiene sus propios métodos para
manejar inodes.
inodes
y Las operaciones que utiliza VFS para manejarlos, no son mas que
punteros a la función del manejador del filesystem
correspondiente.
di t
y
struct inode_operations
inode operations {
int (*create) (struct inode *,struct dentry *,int, struct nameidata *);
struct dentry * (*lookup) (struct inode *,struct dentry *, struct
nameidata *);
*
int (*link) (struct dentry *,struct inode *,struct dentry *);
)
int ((*unlink)) ((struct inode *,struct dentryy *);
int (*symlink) (struct inode *,struct dentry *,const char *);
int (*mkdir) (struct inode *,struct dentry *,int);
int ((*rmdir)
rmdir) (struct inode *,struct
struct dentry *);
);
int (*mknod) (struct inode *,struct dentry *,int,dev_t);
41
41
VFS – Operaciones de inode(II)
int (*rename) (struct inode *, struct dentry *, struct inode *, struct dentry
*);
int (*readlink) (struct dentry *, char __user *,int);
void * (*follow_link) (struct dentry *, struct nameidata *);
p _link)) ((struct dentryy *,, struct nameidata *,, void *);
);
void ((*put
void (*truncate) (struct inode *);
int (*permission) (struct inode *, int);
int (*setattr) (struct dentry **, struct iattr *);
int (*getattr) (struct vfsmount *mnt, struct dentry *, struct kstat *);
int (*setxattr) (struct dentry *, const char *,const void *,size_t,int);
ssize_t (*getxattr) (struct dentry *, const char *, void *, size_t);
42
42
VFS – Operaciones de inode(III)
ssize_t (*listxattr) (struct dentry *, char *, size_t);
int (*removexattr) (struct dentry *, const char *);
void ((*truncate
truncate_range)(struct
range)(struct inode *, loff_t,
loff t loff
loff_t);
t);
long (*fallocate)(struct inode *inode, int mode, loff_t offset, loff_t len);
int (*fiemap)(struct inode *, struct fiemap_extent_info *, u64 start,
u64
64 len);
l )
};
43
43
VFS - Caché de directorios
y
Para agilizar las búsquedas VFS mantiene dos tablas caché de
directorio, con las entradas de directorio más utilizadas y sus
inodos.
inodos
- Cada caché se estructura como una tabla hash con varias listas.
- Cada entrada de la tabla apunta a una lista que tiene el mismo valor
hash.
- La función hash utiliza el número de dispositivo del sistema de
ficheros, y el nombre del directorio.
44
44
VFS - Caché de directorios
Fondo (MRU)
Frente (LRU
Tabla HASH
45
45
VFS – Buffer Cache
y
Para minimizar los accesos a disco, VFS implementa un conjunto de
principal.
p
buffers,, con estructura “buffer_head” en memoria p
y
Mantiene copias de bloques de disco individuales. Las entradas del
caché están identificadas por el dispositivo y número de bloque
y
El buffer es compartido por todos los sistemas de ficheros reales
montados en el sistema.
y
Es independiente de las particularidades físicas de los discos.
discos
y
Los buffers se mantienen en una de varias listas enlazadas: sin usar
(unused), libres (free), no modificadas (clean), modificadas (dirty),
bloqueadas (locked), etc.
y
Periódicamente, el proceso “update” llama a la primitiva “sync()”
para forzar la reescritura de todos los buffers modificados con esto
el sistema experimenta una notable reducción de las E/S a disco.
46
46
VFS - Estructura File
y
Cuando
C
d un proceso d
de usuario
i abre
b un fifichero,
h
VFS crea un objeto
bj
file compuesto de una estructura file. Esta estructura no tiene
imagen en disco, por tanto, no se incluye dirty bit.
y
Todas ellas se encadenan en una lista apuntada por first_file
first file
first_file
*ff_dentry
dentry
*f_op
f_pos
*ff_dentry
dentry
*f_op
f_pos
*ff_dentry
dentry
*f_op
f_pos
47
47
VFS - Estructura File
struct file {
union {
struct list_head
fu_list;
struct
t t rcu_head
h d
f
fu_rcuhead;
h d
} f_u;
struct ppath
f_path;
_p
#define f_dentry
f_path.dentry
#define f_vfsmnt
f_path.mnt
const struct file_operations
*f
*f_op;
atomic_long_t
f_count;
unsigned int
f flags;
f_flags;
fmode_t
f_mode;
loff_t
f_pos;
struct fown_struct
f_owner;
const struct cred
*f_cred;
48
48
VFS - Estructura File
struct file_ra_state
f_ra;
u64
64
f
f_version;
i
#ifdef CONFIG_SECURITY
void
y
*f_security;
#endif
void
*private_data;
#ifdef CONFIG_EPOLL
struct list_head
f_ep_links;
spinlock t
spinlock_t
f ep lock;
f_ep_lock;
#endif
struct address_space
*f_mapping;
#ifdef CONFIG_DEBUG_WRITECOUNT
unsigned long
f_mnt_write_state;
#endif
};
49
49
VFS – file_operations
file operations
struct file_operations
file operations {
struct module *owner;
loff_t (*llseek) (struct file *, loff_t, int);
ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
ssize_t (*aio_read) (struct kiocb *, const struct iovec *, unsigned long,
loff_t);
ssize_tt ((*aio
ssize
aio_write)
write) (struct kiocb *, const struct iovec *, unsigned long,
long
loff_t);
int (*readdir) (struct file *, void *, filldir_t);
unsigned int (*poll) (struct file *, struct poll_table_struct *);
int (*ioctl) (struct inode *, struct file *, unsigned int, unsigned long);
50
50
VFS – file_operations
file operations
long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
long (*compat_ioctl) (struct file *, unsigned int, unsigned long);
int (*mmap) (struct file *, struct vm_area_struct *);
int (*open)
(*
) ((struct inode
d **, struct ffile
l *);
*)
int (*flush) (struct file *, fl_owner_t id);
int ((*release)
release) (struct inode *, struct file *);
);
int (*fsync) (struct file *, struct dentry *, int datasync);
int ((*aio_fsync)
y ) ((struct kiocb *,, int datasync);
y );
int (*fasync) (int, struct file *, int);
int (*lock) (struct file *, int, struct file_lock *);
ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *,
int);
unsigned long (*get_unmapped_area)(struct
(*get unmapped area)(struct file *,
* unsigned long
long,
unsigned long, unsigned long, unsigned long);
51
51
VFS – file_operations
file operations
int (*check_flags)(int);
int (*flock) (struct file *, int, struct file_lock *);
ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, loff_t *,
size t unsigned int);
size_t,
ssize_t (*splice_read)(struct file *, loff_t *, struct pipe_inode_info *,
size_t, unsigned int);
int (*setlease)(struct file *, long, struct file_lock **);
};
52
52
VFS--Estructura Dentry
VFS
Co s e a os cada
Consideramos
ca a directorio
ecto o como
co o un
u fichero
c e o que contiene
co t e e una
u a
lista de ficheros y otros directorios.
y Cuando leemos una entrada de directorio, el kernel crea un
objeto dentry para cada componente de su inode.
inode
y Dentry no tiene imagen en disco
y
Ejemplo: Cuando buscamos en la ruta /tmp/test, el kernel crea un
objeto dentry para el directorio / , un segundo objeto para la
entrada tmp del directorio raíz y un tercer objeto dentry para la
entrada test del directorio /tmp/
y Definido en dcache.h
y
53
53