The Virtual File System (VFS)

Andrey Matheus Coppieters Prof. Vitor Santos Sistemas Operacionais I

Arquivos - Introduo
?

Necessidade de armazenamento de informaes que precisam estar disponveis aps eventual restart do sistema. Meio fsico comum utilizado: disco rgido. Para ler/gravar no disco necessrio saber informaes sobre: a superfcie, a trilha e o setor. O device driver faz a converso do que o S.O. enxerga, virtual e unidimensional (array de blocos), para o endereamento real de 3 campos. A linearizao do disco realizada atravs da numerao dos setores, de forma optimizada, tal que blocos prximos no array virtual correspondam setores prximos entre si fisicamente.

No Linux, cada dispositivo, inclusive os discos rgidos, corresponde um arquivo especial no sistema. No caso dos discos, h um regra fixa para nomenclatura. /dev/hda

hda1 1 partio do HD Master da 1 IDE hdc2 2 partio do HD Master da 2 IDE sda1 1 partio do 1 disco SCSI sdb3 3 partio do 2 disco SCSI
?

H uma rvore nica para todos os discos --> / (dispositivo raiz = root device) Para que um disco possa ser usado necessrio mont-lo na rvore pr-montada pelo S.O. Esta rvore automaticamente montada no boot do sistema.

Montar um dispositivo significa torn-lo acessvel a partir de um determinado ponto na rvore. Geralmente, estes pontos de montagem so criados no diretrio /mnt Ao montar um dispositivo em um diretrio, o contudo daquele torna-se inacessvel. A vantagem desta organizao em uma rvore nica, sem meno parties fsicas ou discos, que o S.O. desconhece a localizao fsica dos arquivos, ou seja, em qual disco esto gravados. Uma caracterstica interessante a Montagem Remota, que consiste em montar na rvore de uma mquina parties lgicas de outras mquinas, de uma rede, que parecero indiferentes aos usurios em relao s parties locais.

? ?

Arquivo conceito lgico: uma seqncia de bytes. As chamadas de sistema bsicas que lidam com arquivos so: ler, escrever, criar, excluir, renomear e abrir. Nos S.O.s que usam o nome do arquivo como seu identificador, no h a necessidade da existncia das chamadas Abrir e Fechar. No caso do Linux, onde o identificador do arquivo um nmero, estas chamadas so teis, fazendo a associao com nome e as devidas validaes: se o arquivo existe, se o usurio tem acesso, etc. A vantagem de se fazer a validao em uma chamada parte (Abrir) que em caso de mltiplos acessos fazemos uma nica validao, no havendo a necessidade desta verificao a cada leitura/escrita.

No Linux, a chamada Fechar no faz o salvamento do contudo em disco e, sim, simplesmente libera o espao em RAM no qual o S.O. estava utilizando para fazer a associao entre o nmero do arquivo e o seu nome (metadata). H duas formas de acesso um arquivo: Seqencial - modo mais usual. Aleatrio (Randmico) acesso aos arquivos de dados atravs do uso de arquivos de ndices, que guardam uma associao entre cada ndice e um registro de dados no arquivo de dados a ser acessado.

Sistema de Arquivos
?

o mdulo do sistema que implementa a poltica de alocao dos arquivos no disco. - Alocao contnua arquivos devem ser alocados continuamente. A estrutura de dados para localizao dos arquivos bastante simples neste caso. Problemas: mover arquivos de um lugar para outro devido aos seu crescimento. Fragmentao do disco decorrente desta movimentao.

Alocao Linkada(encadeada) ao final de cada bloco do disco h a informao de controle gravada que indica o prximo bloco do disco que faz parte daquele arquivo. Problema: ineficiente para o acesso randmico. Exemplos: FAT (File Allocation Table) h uma tabela que associa os arquivos aos seus blocos iniciais. Enquanto que a tabela FAT, carregada em memria, usada pelo S.O. para consultar o encadeamento dos blocos do arquivo desejado. No mais necessrio acessar aos blocos anteriores ao bloco-alvo no disco. Seu uso vantajoso desde que seja uma estrutura pequena, armazenada por completo na RAM.

Com o aumento da capacidade dos discos, a tabela FAT aumenta de tamanho (h uma entrada na tabela para cada bloco fsico), sendo parte de sua estrutura salva em disco, o que tornou seu uso mais ineficiente, voltando a enfrentar os problemas do acesso randmico com a alocao encadeada. A estrutura deve estar toda em RAM para que o percorrimento encadeado seja eficiente.
?

Alocao por extenso (NTFS) usada pelo Windows NT. O S.O. aloca uma extenso para o arquivo conforme a sua necessidade. H uma estrutura de controle por arquivo que contm as informaes de bloco inicial, quantidade de blocos na extenso e o nmero do bloco do arquivo na extenso. H preocupao com a fragmentao do arquivo no disco, o que ir gerar o crescimento da estrutura de controle.

Alocao por Indexao (usada pelo Linux)

- H uma estrutura de controle para cada arquivo (INODE), a qual carregada em memria medida que feita chamada Abrir. - O INODE uma estrutura de tamanho fixo, que contm as informaes dos 10 primeiros blocos do arquivo. Soluo eficiente encontrada para trabalharse com alocao indexada. - Para arquivos pequenos, fcil a a localizao dos blocos fsicos. Para arquivos maiores (>10 blocos), so utilizados os artifcios do Bloco de Indireo (contm o endereo de um bloco que contm as demais entradas do restante do arquivo) e do Bloco de Dupla Indireo (aponta para os 256 blocos de indireo).

O Linux identifica o INDOE de um arquivo atravs da estrutura denominada Diretrio (um outro arquivo) que contm os nomes dos arquivos e as associaes com seus respectivos INODES. No Windows no h INODES, logo a estrutura de diretrio contm o nome dos arquivos e todas as suas informaes de bloco inicial e dados de controle. O Superbloco uma estrutura de controle nica que contm metadados sobre o sistema de arquivos, tais como a lista de blocos livres. O Linux tem uma estrutura simples e eficiente para tratamento de arquivos, visto que a maioria ocupa menos que 10 blocos no disco. Alm disso, tambm bastante eficiente no acesso arquivos maiores, com o uso do mecanismo de indireo.

Sistemas de arquivos do Linux

? ? ? ?

minix-FS ext ext2 ext3

? padro oficial atual ? = ext2 + journaling (snap shots do

sistema de arquivos para recuperao em caso de falhas blocos abertos)

reiserFS JFS XFS

? tamanho do bloco manipulvel

Enderea arquivos > 2GB

? ?

? padro IBM ? padro da SGI. Tamanho de bloco

manipulvel. Enderea arquivos > 2GB

Interface Comum para Sistemas de Arquivos - VFS

?O

VFS (Virtual File System) o mecanismo que permite que chamadas de sistemas genricas, tais como open( ) e read( ),possam ser executadas independentemente do sistema de arquivos usado ou do meio fsico.

?O

VFS (tambm conhecido como Virtual File Switch) um sub-sistema do Kernel que implementa as interfaces para que os programas de usurios acessem ao sistema de arquivos. os sistemas de arquivos existentes baseiam-se no VFS para coexistir e interagir entre si.

? Todos

Camada de Abstrao para o Sistema de Arquivos

?

uma implementao do Kernel sobre sua interface para sistema de arquivos baixo nvel. que o Linux suporte diferentes sistemas de arquivos, apesar das suas diferenas.

? Permite

Prov um modelo comum capaz de representar todas as caractersticas genricas de um sistema de arquivos. Define um conjunto bsico de conceitos de interfaces e estruturas de dados que todos os sistemas de arquivos suportam: arquivos, diretrios, operaes como criao e remoo. O cdigo real do sistema de arquivos oculta os detalhes da implementao. Para a camada VFS e para o resto do Kernel, todos os sistemas de arquivos parecem iguais.

Os sistemas de arquivos so implementados de forma a prover as abstraes, tanto de interface quanto de estrutura de dados, que a camada VFS espera.

Exemplo write (f, &buf, len);

O VFS foi construdo para trabalhar com sistemas de arquivos do Linux, que implementam naturalmente os conceitos j na organizao das informaes no disco: informaes de um arquivos so armazenados em um bloco especfico em separado (INODE), diretrios so tratados como arquivos, informaes de controle so centralizadas no Superbloco. Sistemas de arquivos como FAT e NTFS devem prover uma abstrao destes conceitos, tal que sejam suportados pelo Linux.

Objetos do VFS e suas Estruturas de Dados

?

O VFS orientado objetos. Como o kernel programado em C, as estruturas de dados so simuladas nesta linguagem, contendo dados e ponteiros para funes do sistema de arquivos que operam sobre os dados. Os 4 objetos primrios do VFS:
?

Objeto Superbloco ? corresponde ao superbloco do sistema de arquivos, gravado em um setor especial do disco. Objeto Inode ? representa um arquivo especfico Objeto Dentry ? representa uma entrada de diretrio (parte do path) Objeto File ? representa a associao de um arquivo aberto um processo.

? ?

Em cada um destes 4 objetos primrios, h um objeto especfico para operaes (operations object), o qual descreve quais mtodos o Kernel invoca sobre aqueles objetos. Os objetos de operao so implementados como uma estrutura de ponteiros para funes do Kernel que operam sobre o objeto pai, e esto identificados abaixo:
? ? ? ?

super_operations contm os mtodos que o Kernel invoca sobre um sistema de arquivos. inode_operations contm os mtodos que o Kernel invoca sobre um arquivo. dentry_operations - contm os mtodos que o Kernel invoca sobre um diretrio. file - contm os mtodos que o Kernel invoca sobre um arquivo aberto.

Alm dos 4 objetos primrios, o VFS ainda contm mais 5 objetos importantes a serem citados:
? file_system_type

representa cada sistema de arquivos existente, descrevendo suas funes. contm informaes sobre o ponto de montagem, como a sua localizao. file_struct, fs_struct e namespace, que descrevem o sistema de arquivos e os arquivos associados um processo.

? vfsmount

? Objetos

O Objeto Superbloco
?

Usado para armazenar informaes sobre um sistema de arquivos especfico. representado pela estrutura super_block, definida em <linux/fs.h>, e que instanciada pela funo alloc_super( ). Quando um sistema de arquivos montado, este invoca uma funo que l o Superbloco a partir do disco e carrega as informaes no objeto Superbloco, em memria.

struct super_block { struct list_head dev_t unsigned long unsigned long long struct file_system_type struct super_operations struct dquot_operations struct quotactl_ops unsigned long struct dentry struct list_head struct list_head struct hlist_head struct list_head struct block_device struct list_head char void };

s_list; /* list of all superblocks */ s_dev; /* identifier */ s_blocksize; /* block size in bytes */ s_maxbytes; /* max file size */ s_type; /* filesystem type */ s_op; /* superblock methods */ *dq_op; /* quota methods */ *s_qcop; /* quota control methods */ s_flags; /* mount flags */ *s_root; /* directory mount point */ s_dirty; /* list of dirty inodes */ s_io; /* list of writebacks */ s_anon; /* anonymous dentries */ s_files; /* list of assigned files */ *s_bdev; /* associated block device */ s_instances; /* instances of this fs */ s_id[32]; /* text name */ *s_fs_info; /* filesystem-specific info */

O item mais importante do superbloco a estrutura s_op, que a sua tabela de operaes. Todo item nesta estrutura um ponteiro para funes que operam sobre o objeto Superbloco. Para realizar uma operao sobre o seu Superbloco, o sistema de arquivos segue os ponteiros daquele at o mtodo desejado. sb -> s_op -> write_super (sb) ; sb um ponteiro para o Superbloco do sistema de arquivos.

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 *); Todas estas funes void (*write_inode) (struct inode *, int); so invocadas pelo void (*put_inode) (struct inode *); VFS, no contexto do void (*drop_inode) (struct inode *); processo! void (*delete_inode) (struct inode *); void (*put_super) (struct super_block *); void (*write_super) (struct super_block *); 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 (*clear_inode) (struct inode *); void (*umount_begin) (struct super_block *); int (*show_options) (struct seq_file *, struct vfsmount *); };

O objeto Inode
?

Representa toda a informao necessria ao Kernel para manipulao de um arquivo ou diretrio. Um inode representa cada arquivo no sistema de arquivos. Porm o objeto s instanciado em memria no momento que o arquivo aberto (acessado) A informao obtida pela leitura do inode que est gravado em disco. Se um sistema de arquivos no trabalhar com inodes, deve obter esta informao do local onde estiver armazenada. Geralmente, nestes casos, a informao gravado no prprio arquivo. O objeto inode representado pela struct inode, definida em <linux/fs.h>

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 */ };

O item mais importante o inode_operations, que descreve as funes implementadas pelo sistema de arquivos que podem ser invocadas pelo VFS para operar sobre um inode. Operaes sobre inode so invocadas da forma abaixo, onde i referencia um inode especfico: i -> i_op -> truncate (i) No exemplo acima, esta funo chamada pelo VFS para modificar o tamanho de um arquivo na proporo desejada.

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 *); };

O Objeto Dentry
? ?

O VFS trata diretrios como arquivos. Exemplo: /bin/vi bin e vi so arquivos, ambos representados pelo objeto inode. Para facilitar a realizao de operaes especficas sobre diretrios, o VFS usa o conceito de entrada de diretrio (dentry). O dentry um componente especfico do path. No exemplo, /, bin e vi so objetos dentry. O VFS instancia estes objetos on the fly, quando h anecessidade de realizar operaes sobre diretrios. Os objetos dentry podem portanto ser diretrios, arquivos ou at pontos de montagem.

Ao contrrio das demais estruturas vistas anteriormente, o objeto dentry no corresponde a qualquer estrutura de dados armazenada em disco. O VFS cria este objeto on the fly, a partir da string de representao do path. H uma flag, Dentry State, que indica o status de um objeto dentry:
?

usado corresponde a um inode vlido e indica que h um ou mais usurios para aquele objeto no usado o VFS no est usando o objeto no momento, apesar do inode correspondente ser vlido. negativo o objeto est associado a um inode invlido porque o inode foi apagado ou porque o path sequer jamais exisitiu.

Dentry Cache (dcache) aps o VFS resolver todo o nome que compem o path e atingir o seu final, o Kernel armazena os objetos dentry daquele path na Dentry Cache, a qual consiste de 3 partes:
? Lista

de objetos dentry com o status usado para um nico inode, visto que este pode ter mltiplos links; lista duplamente encadeada de objetos dentry menos recentemente usados com status nousado ou negativo; tabela hash para resolver rapidamente a associo entre um dado caminho e o objeto dentry;

? Uma

? Uma

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 */ };

A estrutura dentry_operations especifica os mtodos que o VFS invoca sobre as entradas de diretrio em um sistema de arquivos, sendo definida em <linux/dcache.h>

struct dentry_operations { int (*d_revalidate) (struct dentry *, int); int (*d_hash) (struct dentry *, struct qstr *); int (*d_compare) (struct dentry *, struct qstr *, struct qstr *); int (*d_delete) (struct dentry *); void (*d_release) (struct dentry *); void (*d_iput) (struct dentry *, struct inode *); };

O Objeto File
? ?

Assim como o objeto dentry, o objeto file no corresponde realmente a um dado salvo em disco. usado para representar um arquivo que foi aberto por um processo, fazendo parte da representao daquele arquivo carregada em memria. Representa a viso de um processo sobre o arquivo aberto. Como um arquivo pode ser manipulado por vrios processos, ao mesmo tempo, natural haver vrios objetos file associados a um nico arquivo. O objeto file possui um ponteiro (f_dentry) para um objeto dentry, o qual por sua vez possui um ponteiro para um objeto inode, que representa na realidade o arquivo que fra aberto. Obviamente, os objetos dentry e inode so nicos para um arquivo. representado pela struct file, definida em <linux/fs.h>

struct file { struct list_head struct dentry struct vfsmount struct file_operations atomic_t unsigned int mode_t loff_t struct fown_struct unsigned int unsigned int int struct file_ra_state unsigned long void void struct list_head spinlock_t struct address_space };

f_list; /* list of file objects */ *f_dentry; /* associated dentry object */ *f_vfsmnt; /* associated mounted fs */ *f_op; /* file operations table */ f_count; /* file object's usage count */ f_flags; /* flags specified on open */ f_mode; /* file access mode */ f_pos; /* file offset (file pointer) */ f_owner; /* owner data for signals */ f_uid; /* user's UID */ f_gid; /* user's GID */ f_error; /* error code */ f_ra; /* read-ahead state */ f_version; /* version number */ *f_security; /* security module */ *private_data; /* tty driver hook */ f_ep_links; /* list of eventpoll links */ f_ep_lock; /* eventpoll lock */ *f_mapping; /* page cache mapping */

? As

operaes associadas struct file so as familiares chamadas de sistemas que formam a base das chamadas padro do Linux. sistemas de arquivos no so obrigados a implementar todos estes mtodos, bastando configur-los para NULL quando estes no forem interessantes.

? Os

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); };

Estruturas de dados associadas aos File Systems

?

Alm dos objetos primrios apresentados, o Kernel usa mais algumas estruturas para a manipulao de dados relacionados aos sistemas de arquivos.
?

File_system_type objeto usado para descrever uma variante especfica de um sistema de arquivos (ext3 ou XFS). H apenas uma estrutura destas para cada sistema de arquivos, independentemente de quantas instncias daquele esto montadas no sistema. Vfsmount objeto criado no momento em que o sistema de arquivos montado. usado para representar uma instncia montada, especfica, de um sistema de arquivos. Esta estrutura est definida em <linux/mount.h>

Estruturas de dados associadas a um Processo

?

Cada processo no sistema possui sua prpria lista de arquivos acessados, o sistema de arquivos raiz, o diretrio corrente de trabalho, etc. H 3 estruturas que interligam a camada VFS aos processos:
?

Files_struct estrutura apontada na entrada files no descritor do processo. Contm uma varivel (array fd) que aponta para a lista de arquivos abertos por aquele processo. Este array tem 32 entradas, mas outro array pode ser alocado pelo Kernel, em tempo de execuo, caso o processo necessite acessar mais arquivos. Fs_struct - estrutura apontada no campo fs no descritor do processo, que contm informaes do sistema de arquivos relacionadas ao processo, tais como o diretrio corrente de trabalho e o diretrio raiz do processo. Namespace - estrutura apontada no campo namespace no descritor do processo, que possibilita que cada processo tenha uma viso nica do sistema de arquivos montado. cada processo dada uma cpia do namespace (filesystem hierarchy).

Concluso
?

O Linux suporta uma grande variedade de sistemas de arquivos (cerca de 50 no Kernel oficial); A camada VFS prov a estes sistemas de arquivos um framework para a sua implementao e uma interface para que trabalhem com chamadas de sistema padro do Linux; A camada VFS permite a implementao transparente de novos sistemas de arquivos para o Linux, alm de permitir que estes interoperem atravs das chamadas de sistema padro.

OBRIGADO !!!
andrey@ufrj.br acoppie@centroin.com.br