The Virtual Filesystem

1. Universidade Federal do Rio de Janeiro (UFRJ)Instituto Alberto Luiz Coimbra de Pós-Graduação em engenharia (COPPE)Programa de Engenharia de Sistemas e Computação(PESC)Sistemas Operacionais (COS773) The Virtual Filesystem Rodrigo Souza Granja

2. Sistemas de arquivos(FS) • “Parte do SO responsável pelo tratamento de arquivos” Andrew S. Tannenbaum, Sistemas Operacionais Modernos, Página 101 • Permite aos processos acessar os arquivos de forma transparente • Abstrai complexidade de acesso ao hardware • Contém 2 partes: • Coleção de arquivos • Estrutura de diretórios The Virtual Filesystem

3. Arquivo Físico • Conjunto de informações correlatas salvas no armazenamento secundário • Vários tipos: numéricos, alfabéticos, alfanuméricos ou binários • Menor unidade de armazenamento lógico • Vários atributos, de acordo com o SO • Mais comuns: Nome, Tipo, Posição, Tamanho, Proteção, Hora, data e id user The Virtual Filesystem

4. FS no Unix/Linux • Arquivo é qualquer entidade capaz de tratar E/S com fluxo de dados • Arquivos, rede, dispositivos de I/O • 4 abstrações principais no Unix • Arquivos (Files) • Entradas de diretórios (Directory entrys - Dentrys) • Nós-i (Inodes) • Ponto de Montagem (Mount Point) The Virtual Filesystem

5. Entradas de Diretórios • São todos componentes em um path • Incluindo arquivos ou mount points • Eg: • /bin/ls • Tanto bin quanto ls são dentrys The Virtual Filesystem

6. Nós-i • Abreviatura de Nós-índices • Contém toda informação necessária para manipular um arquivo ou diretório • Cada nó-i representa um arquivo • Inclusive devices e pipes • Guarda informações de contabilização (dono do arquivo, bits de proteção) - Metadata • Guarda a localização dos blocos de dados que armazenam as informações de arquivos The Virtual Filesystem

7. Ponto de Montagem • Mapeia um sistema de arquivos para um diretório • Mecanismo usado para se criar um namespace comum ≠ Windows • Unix: Namespace Global • Linux 2.4.2: Namespace por processo (plan9) • Ex: • mount /dev/fd0 /mnt/floppy The Virtual Filesystem

8. VFS - Motivação • Existem muitos tipos distintos de Sistemas de Arquivos • Necessidade de interoperabilidade • Interface padrão para acesso a arquivos • Programar orientado para um FS específico seria inviável • Kernel precisa ser flexível para adição de novos sistemas de arquivos The Virtual Filesystem

9. VFS - Descrição • Similar a camada “vnode/vfs” de sistemas Unix • Criado para facilitar a implantação de novos sistemas de arquivos • Linux só suportava o Minix FileSystem • Desenvolvido inicialmente por Chris Provenzano, reescrito por Linus Torvalds • Após sua implementação foi o criado o Extended File System , adicionado ao kernel 0.96c em abril de 1992 • Orientação a objetos The Virtual Filesystem

10. VFS - Implementação • Kernel implementa camada de abstração ao redor das interfaces de FS de baixo-nível • Esta camada define interfaces conceituais básicas que existem em qualquer FS • Commom File Model – Baseado no modelo Unix • Conseqüência: Nenhuma parte do Kernel precisa entender peculiaridades do FS The Virtual Filesystem

11. Visão Global Processo do usuário Write() System call interface VFS Sys_write() Minix FS Dos FS Ext2 FS Linux Kernel Buffer Cache Device Driver Pedido de I/O Controlador de disco Hardware The Virtual Filesystem

12. VFS – Objetos e EDs • C não suporta orientação a objetos • Representados como estruturados de dados • Quatro tipos primários de objetos: • Superbloco (superblock) • Nó-i (Inode) • Dentry (Directory Entry) • Arquivo (file) The Virtual Filesystem

13. Outros Objetos • Estrutura File_system_type • Descreve um FS e suas características • Estrutura vsfmount • Descreve um ponto de montagem • Localização e flags • 3 estruturas presentes em processos • File_struct • Fs_struct • namespace The Virtual Filesystem

14. Objeto Superbloco • Implementado por cada FS • Contém informações que o descrevem • Em geral corresponde ao superbloco ou bloco de controle do FS • Se o FS não possui SB, um é gerado “on the fly” e depois é armazenado na memória • Representado pela estrutura super_block The Virtual Filesystem

15. Estrutura super_block • Disponível em <linux/fs.h> • Versão Resumida: struct super_block { struct list_head s_list; /* list of all superblocks */ dev_t s_dev; /* identifier */ unsigned long s_blocksize; /* block size in bytes */ unsigned long long s_maxbytes; /* max file size */ struct file_system_type s_type; /* filesystem type */ struct super_operations s_op; /* superblock methods */ struct dquot_operations *dq_op; /* quota methods */ struct quotactl_ops *s_qcop; /* quota control methods */ unsigned long s_flags; /* mount flags */ struct dentry *s_root; /* directory mount point */ struct list_head s_dirty; /* list of dirty inodes */ struct list_head s_io; /* list of writebacks */ struct hlist_head s_anon; /* anonymous dentries */ struct list_head s_files; /* list of assigned files */ struct block_device *s_bdev; /* associated block device */ struct list_head s_instances; /* instances of this fs */ char s_id[32]; /* text name */ void *s_fs_info; /* filesystem-specific info */ }; The Virtual Filesystem

16. Criação do superbloco • Código em fs/super.c • Criação e alocação • static struct super_block *alloc_super(void) • Retorna ponteiro para o SB ou null se falhar • Ao montar um FS • FS invoca esta função • Lê o super bloco do disco • Preenche o objeto superbloco The Virtual Filesystem

17. Operações no SB • Implementado como ponteiros para funções que operam no Objeto SB • Realizam operações de baixo-nível no FS e seus inodes • O ponteiro é seguido pelo FS ao realizar uma op • Sb->s_op->write_super(sb); • SB é um ponteiro para o superbloco do FS The Virtual Filesystem

18. Operações no SB • Representado pela struct super_operations (<linux/fs.h>) struct super_operations { struct inode *(*alloc_inode) (struct super_block *sb); void (*destroy_inode) (struct inode *); void (*read_inode) (struct inode *); void (*dirty_inode) (struct inode *); /* Inode Sujo, usado por Journaling FS, eg, EXT3 */ void (*write_inode) (struct inode *, int); void (*put_inode) (struct inode *); /* Libera o inode */ void (*drop_inode) (struct inode *); /* Chamada quando última ref. para o inode é liberada */ void (*delete_inode) (struct inode *); void (*clear_inode) (struct inode *); void (*put_super) (struct super_block *); /* Chamada quando se realiza um umount */ void (*write_super) (struct super_block *);/* Atualiza o superbloco presente no disco */ int (*sync_fs) (struct super_block *, int); void (*write_super_lockfs) (struct super_block *); void (*unlockfs) (struct super_block *); int (*statfs) (struct super_block *, struct statfs *); int (*remount_fs) (struct super_block *, int *, char *); void (*umount_begin) (struct super_block *); int (*show_options) (struct seq_file *, struct vfsmount *); ssize_t (*quota_read)(struct super_block *, int, char *, size_t, loff_t); ssize_t (*quota_write)(struct super_block *, int, const char *, size_t, loff_t); }; • struct inode *(*alloc_inode) (struct super_block *sb); • void (*destroy_inode) (struct inode *); • void (*read_inode) (struct inode *); • void (*dirty_inode) (struct inode *); /* Inode Sujo, usado por Journaling FS, eg, EXT3 */ • void (*write_inode) (struct inode *, int); • void (*put_inode) (struct inode *); /* Libera o inode */ • void (*drop_inode) (struct inode *); /* Chamada quando última ref. para o inode é liberada */ • void (*delete_inode) (struct inode *); • void (*clear_inode) (struct inode *); • void (*put_super) (struct super_block *); /* Chamada quando se realiza um umount */ • void (*write_super) (struct super_block *);/* Atualiza o superbloco presente no disco */ • int (*sync_fs) (struct super_block *, int wait); /* Atualiza metada com o disco */ • void (*write_super_lockfs) (struct super_block *); /* Não permite mudanças no FS */ • void (*unlockfs) (struct super_block *); • int (*statfs) (struct super_block *, struct statfs *); • int (*remount_fs) (struct super_block *, int *, char *); • void (*umount_begin) (struct super_block *); • int (*show_options) (struct seq_file *, struct vfsmount *); • ssize_t (*quota_read)(struct super_block *, int, char *, size_t, loff_t); The Virtual Filesystem

19. Detalhes das operações • São chamadas pelo VFS no contexto do processo • Algumas são opcionais • Se associa o ponteiro para NULL • VFS pode chamar função genérica • Ou nada é feito, de acordo com operação The Virtual Filesystem

20. Objeto nó-i • Contém toda informação necessária para manipular arquivo ou diretório • Se FS é estilo Unix, é lido do disco • Se não possuir nó-i, FS precisa descobrir onde ele está no disco para construi-lo • Pode estar no próprio arquivo ou em um BD • Representado pelo estrutura inode The Virtual Filesystem

21. Estrutura inode struct inode { struct hlist_node i_hash; /* hash list */ struct list_head i_list; /* list of inodes */ struct list_head i_dentry; /* list of dentries */ unsigned long i_ino; /* inode number */ umode_t i_mode; /* access permissions */ unsigned int i_nlink; /* number of hard links */ uid_t i_uid; /* user id of owner */ gid_t i_gid; /* group id of owner */ kdev_t i_rdev; /* real device node */ loff_t i_size; /* file size in bytes */ struct timespec i_atime; /* last access time */ struct timespec i_mtime; /* last modify time */ unsigned long i_blksize; /* block size in bytes */ unsigned long i_blocks; /* file size in blocks */ unsigned short i_bytes; /* bytes consumed */ struct inode_operations *i_op; /* inode ops table */ struct file_operations *i_fop; /* default inode ops */ struct super_block *i_sb; /* associated superblock */ struct address_space *i_mapping; /* associated mapping */ struct address_space i_data; /* mapping for device */ unsigned long i_state; /* state flags */ unsigned int i_flags; /* filesystem flags */ }; The Virtual Filesystem

22. Operações nos nós-i • Pode ocorrer de um FS não dar suporte uma propriedade representada no nó-i • Eg, pode não haver um timestamp de acesso • FS é livre para implementar funcionalidade • Ex.: pode zerar ou igualar a outra variável i_atime = i_mtime • Também é necessário seguir ponteiros • i->i_op->truncate(i) • Onde i é um ponteiro para um inode The Virtual Filesystem

23. Operações nos nós-i • Representado pela struct inode_operations (<linux/fs.h>) struct inode_operations { int (*create) (struct inode *, struct dentry *,int); struct dentry * (*lookup) (struct inode *, struct dentry *); int (*link) (struct dentry *, struct inode *, struct dentry *); int (*unlink) (struct inode *, struct dentry *); int (*symlink) (struct inode *, struct dentry *, const char *); int (*mkdir) (struct inode *, struct dentry *, int); int (*rmdir) (struct inode *, struct dentry *); int (*mknod) (struct inode *, struct dentry *, int, dev_t); int (*rename) (struct inode *, struct dentry *, struct inode *, struct dentry *); int (*readlink) (struct dentry *, char *, int); int (*follow_link) (struct dentry *, struct nameidata *); int (*put_link) (struct dentry *, struct nameidata *); void (*truncate) (struct inode *); int (*permission) (struct inode *, int); int (*setattr) (struct dentry *, struct iattr *); int (*getattr) (struct vfsmount *, 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); ssize_t (*listxattr) (struct dentry *, char *, size_t); int (*removexattr) (struct dentry *, const char *); }; • int (*create) (struct inode *, struct dentry *,int); /*Cria um novo inode associado a objeto dentry */ • struct dentry * (*lookup) (struct inode *, struct dentry *); /* Busca um inode relativo a um dentry */ • int (*link) (struct dentry *, struct inode *, struct dentry *); /* Cria hard link */ • int (*unlink) (struct inode *, struct dentry *); /* Remove inode especificado por dentry */ • int (*symlink) (struct inode *, struct dentry *, const char *); /* Cria link simbolico */ • int (*mkdir) (struct inode *, struct dentry *, int mode); /* Usado para criar diretório */ • int (*rmdir) (struct inode *, struct dentry *); /* Usado para apagar diretório */ The Virtual Filesystem

24. Objeto Dentry • VFS trata diretórios como arquivos • Necessário a realização de operações específicas • Ex: path name lookup • Não existe estrutura correspondente em disco • São criados “on the fly” a partir de string com o path • Por não estar no disco, não existe flag que especifique se está “sujo” The Virtual Filesystem

25. Estrutura Dentry struct dentry { atomic_t d_count; /* usage count */ unsigned long d_vfs_flags; /* dentry cache flags */ spinlock_t d_lock; /* per-dentry lock */ struct inode *d_inode; /* associated inode */ struct list_head d_lru; /* unused list */ struct list_head d_child; /* list of dentries within */ struct list_head d_subdirs; /* subdirectories */ struct list_head d_alias; /* list of alias inodes */ unsigned long d_time; /* revalidate time */ struct dentry_operations *d_op; /* dentry operations table */ struct super_block *d_sb; /* superblock of file */ unsigned int d_flags; /* dentry flags */ int d_mounted; /* is this a mount point? */ void *d_fsdata; /* filesystem-specific data */ struct rcu_head d_rcu; /* RCU locking */ struct dcookie_struct *d_cookie; /* cookie */ struct dentry *d_parent; /* dentry object of parent */ struct qstr d_name; /* dentry name */ struct hlist_node d_hash; /* list of hash table entries */ struct hlist_head *d_bucket; /* hash bucket */ unsigned char d_iname[DNAME_INLINE_LEN_MIN]; /* short name */ }; The Virtual Filesystem

26. Estados de Dentry • Três estados: Used, unused e negative • Used • Aponta para um inode válido e está em uso • Não pode ser descartado • Unused • Aponta para um inode válido e não está em uso • Armazenado para otimizar buscas futuras • Negative • Aponta para um inode inválido – apagado ou erro no path • Pode ser mantido para otimizar possíveis erros futuros The Virtual Filesystem

27. Dentry cache • Usada para otimizar busca já realizadas • Composta de 3 partes • Lista de dentries marcados como used linkados aos respectivos inodes pelo campo i_dentry do inode • Lista duplamente encadeada de dentries marcados como negative e unused • Tabela Hash e uma função hash usadas para resolver um path para um dentry com rapidez • Representada pelo dentry_hastable • Interesante: No código há um comentário dizendo que ela precisa ser otimizada /* * This is the single most critical data structure when it comes * to the dcache: the hashtable for lookups. Somebody should try * to make this good - I've just made it work. * This hash-function tries to avoid losing too many bits of hash * information, yet avoid using a prime hash-size or similar. */ The Virtual Filesystem

28. Dcache - Exemplo • Acesso ao arquivo • /home/rodrigo/projeto/src/exemplo.c • Sem dcache, toda a árvore precisa ser percorrida ao manipular o arquivo • Ao abrir, salvar, compilar, etc • Com dcache, o trabalho só precisa ser feito uma vez enquanto a entrada permanecer na cache The Virtual Filesystem

29. Dentry Operations • Definida em <linux/dcache.h> struct dentry_operations { int (*d_revalidate) (struct dentry *, int); int (*d_hash) (struct dentry *, struct qstr *); /* Usada para popular a tabela hash */ int (*d_compare) (struct dentry *, struct qstr *, struct qstr *); /* Compara 2 arquivos, FAT precisa de impl. Especifica) */ int (*d_delete) (struct dentry *); void (*d_release) (struct dentry *); /* Libera um dentry */ void (*d_iput) (struct dentry *, struct inode *); }; The Virtual Filesystem

30. Objeto arquivo • Representa um arquivo aberto por um processo • É o objeto que realmente é manipulado pelo processo, este não acessa inodes ou dentries • O objeto é criado ao se realizar a chamada open() e destruído com a chamada close() • Podem haver vários objetos para um único arquivo • O objeto aponta para o dentry, que aponta para o inode que realmente representa o arquivo The Virtual Filesystem

31. Estrutura File • Definido em <linux/fs.h> struct file { struct list_head f_list; /* list of file objects */ struct dentry *f_dentry; /* associated dentry object */ struct vfsmount *f_vfsmnt; /* associated mounted fs */ struct file_operations *f_op; /* file operations table */ atomic_t f_count; /* file object's usage count */ unsigned int f_flags; /* flags specified on open */ mode_t f_mode; /* file access mode */ loff_t f_pos; /* file offset (file pointer) */ struct fown_struct f_owner; /* owner data for signals */ unsigned int f_uid; /* user's UID */ unsigned int f_gid; /* user's GID */ int f_error; /* error code */ struct file_ra_state f_ra; /* read-ahead state */ unsigned long f_version; /* version number */ void *f_security; /* security module */ void *private_data; /* tty driver hook */ struct list_head f_ep_links; /* list of eventpoll links */ spinlock_t f_ep_lock; /* eventpoll lock */ struct address_space *f_mapping; /* page cache mapping */ }; The Virtual Filesystem

32. Operações em File • Operações representam as chamadas usadas em C para manipular arquivos • Cada FS pode implementar funções particulares ou usar função padrão, se existir • Não obrigatoriedade de implementação, pode ser setado para NULL The Virtual Filesystem

33. Operações de File struct file_operations { struct module *owner; loff_t (*llseek) (struct file *, loff_t, int); ssize_t (*read) (struct file *, char *, size_t, loff_t *); ssize_t (*aio_read) (struct kiocb *, char *, size_t, loff_t); ssize_t (*write) (struct file *, const char *, size_t, loff_t *); ssize_t (*aio_write) (struct kiocb *, const char *, size_t, 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); int (*mmap) (struct file *, struct vm_area_struct *); int (*open) (struct inode *, struct file *); int (*flush) (struct file *); int (*release) (struct inode *, struct file *); int (*fsync) (struct file *, struct dentry *, int); int (*aio_fsync) (struct kiocb *, int); int (*fasync) (int, struct file *, int); int (*lock) (struct file *, int, struct file_lock *); ssize_t (*readv) (struct file *, const struct iovec *, unsigned long, loff_t *); ssize_t (*writev) (struct file *, const struct iovec *, unsigned long, loff_t *); ssize_t (*sendfile) (struct file *, loff_t *, size_t, read_actor_t, void *); ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *, int); unsigned long (*get_unmapped_area) (struct file *, unsigned long, unsigned long, unsigned long, unsigned long); int (*check_flags) (int flags); int (*dir_notify) (struct file *filp, unsigned long arg); int (*flock) (struct file *filp, int cmd, struct file_lock *fl); }; The Virtual Filesystem

34. Outras Estruturas de Dados • Estrutura de dados associadas com FS • Usado para descrever um determinado FS • Ex.:Ext2, Ext3, XFS • Kernel suporta muitos tipos de FS, é necessário uma estrtura para descrever as peculiaridades de cada um • Só há uma estrutura para cada tipo de FS, independente de quantas instâncias estão montadas The Virtual Filesystem

35. Estrutura file_system_type struct file_system_type { const char *name; int fs_flags; struct super_block *(*get_sb) (struct file_system_type *, int, char *, void *); void (*kill_sb) (struct super_block *); struct module *owner; struct file_system_type * next; struct list_head fs_supers; }; The Virtual Filesystem

36. Estrutura vfsmount • Criada ao se montar um diretório • Definida em <linux/mount.h> • Algumas flags associadas • MNT_NOSUID • Não permite as flags setuid e setgid em binários desse FS • MNT_NODEV • Não permite acesso a arquivos de dispositivos nesse FS • MNT_NOEXEC • Proibi a execução de binários nesse FS • Flags úteis para dispositivos removíveis não confiáveis The Virtual Filesystem

37. Vfsmount struct vfsmount { struct list_head mnt_hash; struct vfsmount *mnt_parent; /* fs we are mounted on */ struct dentry *mnt_mountpoint; /* dentry of mountpoint */ 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 */ atomic_t mnt_count; int mnt_flags; int mnt_expiry_mark; /* true if marked for expiry */ char *mnt_devname; /* Name of device e.g. /dev/dsk/hda1 */ struct list_head mnt_list; struct list_head mnt_fslink; /* link in fs-specific expiry list */ struct namespace *mnt_namespace; /* containing namespace */ }; The Virtual Filesystem

38. ED associadas a processos • Cada processo possui ED associadas • Arquivos abertos, FS root, diretório corrente, mount points, etc • Três estruturas ligam essas EDs com o VFS • Files_structs • Fs_struct • namespace The Virtual Filesystem

39. Estrutura Files_structs • Definida em <linux/file.h> • Apontada pela entrada files do descritor de processo • Todas informações sobre arquivos abertos e descritores de arquivos estão aqui The Virtual Filesystem

40. Files_structs struct files_struct { atomic_t count; spinlock_t file_lock; int max_fds; /* Número máximo de objetos File */ int max_fdset;/* Número máximo de descritores de arquivo */ int next_fd; struct file ** fd; /* Lista de todos os objetos File */ fd_set *close_on_exec; fd_set *open_fds; fd_set close_on_exec_init; fd_set open_fds_init; struct file * fd_array[NR_OPEN_DEFAULT]; }; The Virtual Filesystem

41. Files_structs - Detalhes • Fd_array aponta para a lista de arquivos abertos • NR_OPEN_DEFAULT é igual a 32 por default • Se um arquivo precisar de mais de 32 arquivos, uma nova lista é criada e o ponteiro é ajustado • Se criar mais de 32 arquivos for comum, NR_OPEN_DEFAULT pode ser alterado The Virtual Filesystem

42. Estrutura fs_struct • Contém informações do FS relacionada a um proceso • Apontada pelo campo FS no descritor de processo • Definida em <linux/fs_struct.h> The Virtual Filesystem

43. fs_struct struct fs_struct { atomic_t count; rwlock_t lock; int umask; struct dentry * root; /* Dentry do diretório root */ struct dentry * pwd; /* Dentry do diretório atual */ struct dentry * altroot; /* Dentry do root alternativo*/ struct vfsmount * rootmnt; /* Objeto mount do dir root */ struct vfsmount * pwdmnt; /* Objeto mount do dir atual */ struct vfsmount * altrootmnt; /* Objeto mount do dir root altern.*/ }; The Virtual Filesystem

44. Estrutura namespace • Adicionada no kernel 2.4 • Apontada pelo campo namespace no descritor de processos • Permite visão única dos FSs montados no sistema para cada processo • Definida em <linux/namespace.h> • Implementada como lista duplamente encadeada de FSs montados The Virtual Filesystem

45. namespace struct namespace { atomic_t count; struct vfsmount * root; /* Lista de FS montados */ struct list_head list; struct rw_semaphore sem; }; The Virtual Filesystem

46. Detalhes • Em geral as estruturas files_struct e fs_struct são únicas • Se o processo é criado com a flag CLONE_FILES ou CLONE_FS elas são compartilhadas • Contador count é usado para que as estruturas não sejam apagadas nestes casos • Namespace em geral é única • Default: todos os processos tem mesmo namespace • Flag CLONE_NEWNS usada durante clone() cria um namespace único The Virtual Filesystem

47. Conclusão • VFS garante flexibilidade e que grande número de FSs coexistam • Mais de 50 FSs suportados pelo kernel oficial • Torna fácil a criação de novos FSs e a utilização desses com os já existentes The Virtual Filesystem

48. Bibliografia Adicional • Silberschatz. A, Galvin P.B, Greg G. Sistemas Operacionais Conceitos e Aplicações. Editora Campus 2000 • Wikipedia(A), Virtual File System. Disponível [Online] http://en.wikipedia.org/wiki/Virtual_file_system • Ts'o T, e outros. Design and Implementation of the Second Extended Filesystem, Disponível [Online] http://web.mit.edu/tytso/www/linux/ext2intro.html • Tannenbaum, Andrew S. Sistemas Operacionais Modernos. Prentice Hall do Brasil, 1992. • Wikipedia(B), Mount Point. Disponível[Online] http://en.wikipedia.org/wiki/Mount_point • Browne, C. The Linux Kernel. Disponível [Online] http://cbbrowne.com/info/fs.html • Gleditsch, A, Gjermshus, P. Linux Cross-Referencing. Disponível [Online] http://lxr.linux.no/ The Virtual Filesystem