3IS - Système d`exploitation linux - Système de fichiers - Etis

Transcription

3IS - Système d'exploitation linux
Système de fichiers
2010 – David Picard
Contributions de : Arnaud Revel, Mickaël Maillard
[email protected]
ÉCOLE NATIONALE SUPÉRIEURE DE L'ÉLECTRONIQUE ET DE SES APPLICATIONS
Notion de fichiers
●
Fichiers ordinaires
–
●
Répertories
–
●
Conteneurs d'autres fichiers
Liens
–
–
●
Suite d'octets quelconque
Liens matériels
Liens symboliques (l)
Fichiers spéciaux : périphériques /dev
–
–
En mode caractère (c)
En mode block (b)
●
Pipes et pipes nommés
●
sockets
Cycle de vie
CREATE
OPEN
WRITE
READ
SEEK
CLOSE
UNLINK
Appels systèmes basic
●
Ouverture : open()
●
Fermeture : close()
●
Lecture : read()
●
Écriture : write()
●
Recherche : lseek()
●
Suppression : unlink()
●
Infos : stat(), fstat(), lstat()
Structure File en 0.01
struct file {
unsigned short f_mode; /* Mode d'ouverture */
unsigned short f_flags; /* Drapeaux fichier */
unsigned short f_count; /* Nb de références */
struct m_inode * f_inode; /* Inode associée */
off_t f_pos; /* Déplacement */
};
task_struct
●
stack
data
task_struct
fd1
iptr
●
ref=1
position
text
Une liste des
descripteurs de
fichiers ouvert par le
processus est
sauvegardée dans la
task_struct
Une liste globale des
fichiers ouverts est
sauvegardée par le
noyau
Effet du fork()
●
stack
stack
data task_struct
fd1
text
data task_struct
fd1
text
iptr
ref=2
position
●
La task_struct étant
duppliquée, les
descripteurs de
fichiers aussi
Le nombre de
référence dans la liste
des fichiers ouverts
est augmenté
Ouverture de deux fichiers
●
stack
data
task_struct
text
fd1
fd2
iptr
ref=1
position
iptr
ref=1
position
●
Un nouveau
descripteur est ajouté
à la task_struct
Un nouvelle entrée
est créée dans la liste
des fichiers ouverts
(positions différentes)
Commande dup()
●
stack
data
task_struct
text
fd1
fd2
iptr
ref=2
position
●
Permet de duppliquer
une entrée de la liste
des descripteurs de
fichiers
Le nombre de
références dans la
liste des fichiers
ouvert est incrémenté
Système de fichiers (Filesystem)
●
●
Un système de fichier est une structure de données
permettant de stocker et d'organiser des fichiers et leurs
données sur des supports de mémoire de masse
La grande force de linux est de pouvoir cohabiter avec
beaucoup d'autres SE, notamment en étant capable
d'utiliser de nombreux systèmes de fichiers
–
●
ext2/3/4, MINIX, NTFS, FAT16/32, JFS, Reiser3/4, UDF, HFS, XFS, brtfs,
…
Sur les système UNIX, les fs sont une arborescence de
répertoires contenant des fichiers
Disque dur
●
●
●
Un disque dur est un ensemble de
plateaux rigides magnétiques en
rotation
À l'origine, le support magnétique
est dans un état indéterminé
Il faut le formatter
–
–
Le formatage de bas niveau de blocs de
512 ou 1024 octets rend la surface du
disque conforme à ce qu'attend le
contrôleur hardware
Le formatage haut niveau crée certaines
unités fonctionnelles signifiantes pour les
système d'exploitation
Spécificité des FS
●
●
●
●
Un système de fichiers correspond à l'organisation des
blocs disponibles sur le disque
Les opérations élémentaires d'accès aux fichiers (open(),
read(), write(), etc) sont donc dépendantes du FS
Pour que les programmes n'aient pas à se soucier du type
de système de fichier, Linux met en place une couche
d'abstraction appelée le VFS (Virtual Filesystem Switch)
Le VFS se charge d'utiliser la bonne procédure d'accès en
fonction du système de fichier utilisé
VFS
cp
inf = open(“/mnt/usbdisk/fichier.txt”, O_RDONLY, 0);
outf = open(“/home/toto/fichier.txt”, O_WRONLY|O_CREAT|O_TRUNK, 0600);
VFS
do{
i = read(inf, buf, 4096);
write(outf, buf, i);
} while(i);
close(outf);
close(inf);
ext3
FAT16
Système de fichiers supportés par le
VFS
●
FS sur disque
–
–
–
–
●
FS en réseau
–
●
Dédiés à Linux (ext2/3/4, brtfs, Tux3, …)
Unix (sysv, UFS, MINIX, …)
Propriétaires (VFAT, NTFS, HFS, AFFS, …)
Journalisés (JFS, XFS, …)
Permettent d'accéder facilement à un FS situé sur un autre
ordinateur (NFS, CIFS, NCP, AFS, …)
FS spéciaux
–
FS virtuels permettant de simuler l'accès à certaines
ressources comme des accès à des fichiers (/proc, /dev, ...)
Implantation spécifique
●
●
●
Ajout du champ f_op dans la structure file
f_op contient des pointeurs vers les routines
spécifiques au système de fichier sur lequel se
trouve le fichier ouvert
Les routines de services d'accès au fichier
(read() par exemple) font appel aux routines
pointées par la structure f_op
file>f_op>read(...);
Modèle objet du VFS
●
Développé en C pur pour des question de performances
●
L'objet superblock
–
●
L'objet inode
–
●
Contient des informations spécifique à un fichier (block de contrôle de
fichier sur le disque), identifié par un numéro d'inode unique
L'objet file
–
●
Stocke des informations sur le système de fichier (block de contrôle du fs
sur le disque)
Contient des informations sur l'état d'un fichier ouvert et son utilisation par
un processus (n'existe qu'en mémoire)
L'objet dentry
–
Information entre une entrée de répertoire (nom de fichier) et le fichier
correspondant (enregistré sur le disque de manière spécifique au fs)
Exemple
disque
Processus 1
Objet
superblock
Objet
inode
Objet
dentry
Objet
dentry
Objet file 1
Objet file 2
struct super_block
struct super_block {
struct list_head s_list; // liste de superblock
dev_t s_dev; // identifiant de périphérique
...
unsigned char s_blocksize_bits; // taille block en bits
unsigned long s_blocksize; //taille block en octets
loff_t s_maxbytes; //taille max des fichiers
struct file_system_type *s_type; //type de fs
const struct super_operations *s_op; // pointeurs fonctions sb
...
struct dentry *s_root; // dentry de la racine
...
int s_count; //compteur de références
...
struct list_head s_inodes; //list des inodes
...
struct list_head s_files; //liste de fichiers
...
struct block_device *s_bdev; //pilote du périphérique
...
struct list_head s_instances; // list des sb du type de fs
...
char s_id[32]; // nom du périphérique
void *s_fs_info; // info sur le fs
}
struct super_block
●
●
●
s_fs_info contient des informations sur le
système de fichier, spécifique au type de fichier
Généralement des informations contenu sur le
disque, et recopiées en mémoire pour des
raisons d'efficacité
s_op contient des pointeurs vers les routines
d'opérations sur les superblocks, donc
spécifique au type de fs
–
Ex : sb>s_op>read_inode(inode);
struct inode
struct inode {
...
struct list_head i_sb_list; // list des inodes du sb
struct list_head i_dentry; //list des dentry qui font référence à l'inode
unsigned long i_ino; // numéro d'inode
atomic_t i_count; // compteur d'utilisation
unsigned int i_nlink; //nombre de liens physique
uid_t i_uid; //id du propriétaire
gid_t i_gid; //id du groupe
dev_t i_rdev; //id du périphérique unsigned int i_blkbits; // taille du block en bits
loff_t i_size; //taille en octet
struct timespec i_atime; //date d'accès
struct timespec i_mtime; //date de modification
struct timespec i_ctime; //date de création
blkcnt_t i_blocks; //nombre de blocks contenant le fichier
unsigned short i_bytes; //bombre d'octet utilisés dans le dernier block
umode_t i_mode; //type de fichier et droits d'accès
const struct inode_operations *i_op; // routines sur les inodes
struct super_block *i_sb; //pointeur vers le superblock
…
}
struct file
struct file {
struct list_head struct dentry f_list; //list de fichier du processus
*f_dentry; //répertoire contenant le fichier
...
struct file_operations *f_op; //pointeurs de fonction
atomic_t f_count; //conteur d'ouverture
unsigned int f_flags; // drapeaux comme lecture seule, append, etc
mode_t f_mode; // mode : read ou write
int f_error; //erreur
loff_t f_pos; //position dans le fichier
struct fown_struct
f_owner; // propriétaire du fichier
unsigned int f_uid, f_gid; //id du propriétaire, du groupe
...
size_t f_maxcount;
...
};
struct file_operations
struct file_operations {
// Pointer to the owning module
struct module *owner;
// Change read/write position
loff_t (*llseek) (struct file *, loff_t, int);
// Read data, returns number of read bytes
ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
// Write
ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
// Device specific (non read or write) commands
int (*ioctl) (struct inode *, struct file *, unsigned int, unsigned long);
// The first operation on the driver, it can be left NULL but then the driver
// won't be notified
int (*open) (struct inode *, struct file *);
// Most of the times called before closing the files. Demands that pending
// operations be finished.
int (*flush) (struct file *);
// Implementation of file locking
int (*lock) (struct file *, int, struct file_lock *);
...
};
struct dentry
struct dentry {
atomic_t d_count;
unsigned int d_flags; /* protected by d_lock */
spinlock_t d_lock; /* per dentry lock */
int d_mounted;
struct inode *d_inode; /* Where the name belongs to NULL is
* negative */
struct hlist_node d_hash; /* lookup hash list */
struct dentry *d_parent; /* parent directory */
struct qstr d_name;
struct list_head d_subdirs; /* our children */
struct list_head d_alias; /* inode alias list */
unsigned long d_time; /* used by d_revalidate */
const struct dentry_operations *d_op; // opérations sur les dentry
struct super_block *d_sb; /* The root of the dentry tree */
void *d_fsdata; /* fsspecific data */
unsigned char d_iname[DNAME_INLINE_LEN_MIN]; /* small names */
};
struct dentry
●
●
Objet uniquement en mémoire (pas de
stockage sur disque)
Un objet créé pour chaque répertoire lu
–
●
●
Ex : /tmp/test créé 3 dentry : un pour “/”, un pour “tmp”
dans “/” et un pour “test” dans “tmp”
Associe le répertoire à son inode
Gérés dans un cache de manière à faire le
moins de lecture disque possible (i.e. créer le
moins de dentry possible)
Système ext2
●
●
●
Inspiré du système de fichier MINIX
Définition d'une taille de blocs optimale (1024 à 4096
octets)
Regroupe les blocs en groupes
–
●
Les blocs et les inodes d'un même groupe sont proches sur le
support physique, ce qui réduit le temps d'accès
Allocation par anticipation
–
ext2 réserve plusieurs blocs à création d'un fichier, afin d'anticiper
l'augmentation de la taille du fichier
●
Support des fichier inaltérables
●
Compatibilité avec les sémantiques SysVR4 et BSD
Structures sur le disque
Bloc
d'amorce
superbloc
1 bloc
Groupe 0
Descripteurs
de groupe
n blocs
Groupe n
Carte des
blocs de
données
Carte
des
inodes
Table
des
inodes
Bloc
De données
1 bloc
1 bloc
n bloc
n blocs
Groupe
●
Chaque groupe contient un ensemble de blocs
qui sont soit :
–
–
–
–
–
–
Une copie du superbloc (seul le superbloc du groupe 0
est utilisé, les autres servent de sauvegarde)
Une copie d'un bloc de descripteur des groupes (idem
que pour le superbloc)
Une carte d'allocation (bitmap) des blocs
Une carte d'allocation (bitmap) des inodes
Un tableau d'inodes
Un ensemble de données d'un fichier
Table d'inodes
●
●
La table des inodes est un ensemble de blocs
contenant les inodes du groupe
Chaque inode fait 128 octets
–
–
●
●
Un bloc de 1024 octets contient 8 inodes
Un bloc de 4096 octets en contient 32
Le nombre d'inodes est indiqué dans le champs
s_inode_per_group du superbloc
Le nombre de blocs utilisés dépend de la taille
des blocs et du nombre d'inodes par groupe
inode
●
L'inode du système de fichier ext2 est très proche
de celle du VFS
–
–
–
–
–
●
Contient la taille en octet et la taille en blocs
Indicateur de propriétaire, de groupe
Temps de d'accès, de modification
Compteur de lien physique
Date de suppression
Contient une liste de numéros de blocs de
données
–
__le32[EXT2_N_BLOCKS] i_block;
–
EXT2_N_BLOCKS généralement à 15
bloc
de
données
bloc
de
données
bloc
de
données
Direct 1
Direct 2
Direct 3
bloc
de
données
bloc
de
données
bloc
d'indirection
Direct 12
bloc
d'indirection
Double ind
Triple ind
bloc
de
données
bloc
d'indirection
Simple ind
bloc
d'indirection
inode
bloc
d'indirection
bloc
d'indirection
bloc
de
données
bloc
d'indirection
bloc
de
données
bloc
d'indirection
bloc
de
données
i_block
●
15 numéros de blocs (position physique sur le disque)
–
–
–
–
●
Les blocs d'indirection contient une liste de numéros de
bloc
–
●
12 premiers éléments sont les 12 premiers blocs de données du fichier
(bloc 0 à bloc 11)
13ième élément est un bloc de simple indirection (bloc 12 à 11+b/4)
14ième élément un est bloc de double indirection (bloc 12+b/4 à
11+b/4+b²/16)
15ième élément est un bloc de triple indirection (bloc 12+b/4+b²/16 à
11+b/4+b²/16+b³/64)
(taille du bloc / 4) blocs peuvent ainsi être référencés
Le nombre maximum de blocs d'un fichier est donc : 12+
(b/4)+(b/4)²+(b/4)³
–
–
Avec b = 4096, on obtient environ 4To
48ko en adressage direct, 4Mo en simple indirection, et 4Go en double
indirection
Système ext3
●
Système de journalisation
●
Possibilité d'agrandissement des partitions
●
Indexation des répertoires contenant beaucoup
de fichiers par H-Tree
–
●
accès plus rapide aux fichiers d'un répertoire
Compatibilité avec ext2
–
Possibilité de monter une partition ext3 comme une
partition ext2, mais en perdant les options nouvelles
Journalisation
●
Principe :
–
–
●
Si tout ce passe bien
–
●
On recopie le journal dans les blocs de données, on obtient
le nouveau fichier
Si crash pendant l'écriture dans le journal
–
●
On invalide les entrées du journal, on a le nouveau fichier
Si crash pendant l'écriture sur les blocs de donnees
–
●
On écrit d'abord dans le journal
Puis sur les blocs de données
On ignore le contenu du journal, et garde l'ancien fichier
Plus robuste, mais plus lent
Type de journalisation
●
Journalisé
–
–
●
Ordonné
–
–
●
On écrit les données et les méta-données dans le journal
Le plus sûr, mais le plus lent
On n'écrit que les méta-données dans le journal (nombre de
blocs utilisés, etc)
Moins sûr (possible perte de données, mais pas de corruption du
fs), comportement par défaut d'ext3
Différé
–
–
On n'écrit que les modification des méta-données dans le journal
Le plus véloce, mais le moins robuste
Système ext4
●
1 Eo (1 million de To) de taille max
●
Fichiers jusqu'à 16To
●
Gestion par extents
–
–
●
Journal checksumming
–
●
Ensembles de blocs continus
Facilite la gestion des gros fichiers (jusqu'à 128Mo par extend)
Vérification de la consistence du journal
Allocation multiblocs
–
Lors de l'augmentation de la taille d'un fichier, plusieurs blocs
peuvent être alloués d'un coup
Système ext4
●
Nombre de fichiers dans un répertoire sans limite
●
Allocation retardée
–
N'allouer les blocs qu'au dernier moment de l'écriture sur le
disque
●
fsck rapide (ne check pas les inodes inutilisées)
●
Préallocation persistente
●
Utilisation des barrières pour garantir l'intégrité
–
Les disques ont la facheuse tendance à réorganiser les
ordres d'écritures → forcer l'exécution de certains write
Extents (1)
Tiré de The new ext4 filesystem: current status and future plans, A. Mathur 2007
Extents (2)
/*
* ext4_inode has i_block array (60 bytes total).
* The first 12 bytes store ext4_extent_header;
* the remainder stores an array of ext4_extent.
*/
/*
* Each block (leaves and indexes), even inode-stored has header.
*/
struct ext4_extent_header {
__le16
eh_magic;
/* probably will support different formats */
__le16
eh_entries; /* number of valid entries */
__le16
eh_max;
/* capacity of store in entries */
__le16
eh_depth;
/* has tree real underlying blocks? */
__le32
eh_generation;
/* generation of the tree */
};
Extents (3)
/*
* This is the extent on-disk structure.
* It's used at the bottom of the tree.
*/
struct ext4_extent {
__le32
ee_block;
/* first logical block extent covers */
__le16
ee_len;
/* number of blocks covered by extent */
__le16
ee_start_hi; /* high 16 bits of physical block */
__le32
ee_start_lo; /* low 32 bits of physical block */
};
/*
* This is index on-disk structure.
* It's used at all the levels except the bottom.
*/
struct ext4_extent_idx {
__le32
ei_block;
/* index covers logical blocks from 'block' */
__le32
ei_leaf_lo; /* pointer to the physical block of the next *
* level. leaf or next index could be there */
__le16
ei_leaf_hi; /* high 16 bits of physical block */
__u16
ei_unused;
};
Brtfs
●
Changement de taille dynamique
●
Défragmentation dynamique
●
Ajout/suppression de périphérique bloc
●
Balancement dynamique
●
Subvolumes (sous-arborescence montable)
●
Snapshots
●
RAID-like mirroring et striping
●
...

3IS - Système d`exploitation linux - Système de fichiers - Etis

Transcription

Documents pareils

1 Préliminaires

Allocation dynamique de mémoire Allocation dynamique de mémoire

Chapitre trois : les structures

1 Modules 2 Signatures

1 Tableaux statiques/dynamiques 2 Chaˆınes de caract`eres 3

Blocs mono unison research smart 845

Programmation 1 – TD 4

Fiche d`activité Nom de l`activité : La plus haute tour! Groupe d`âge

Décision - Office de la protection du consommateur

Description technique de l`installation Pondeuse EL12.