Systèmes de fichiers et appels systèmes associés

Systèmes de fichiers et appels systèmes associés Anthony Busson Paul Crozat Hugues Mounier Lynda Zitoune Plan Les fichiers sur le disque dur Le système arborescent Gestion par le noyau des fichiers ouverts Appels systèmes : ouverture, écriture/lecture, fermeture de fichiers Appels systèmes : liens, propriétés des fichiers Appels systèmes : manipulation des répertoires Appels systèmes : verrouillage des fichiers. 1

Organisation du disque dur secteur plateau piste Une piste est un cercle sur le disque dur. Le secteur est l unité de base, il est d au moins 512 octets (Le formatage de bas niveau définit les différents secteurs). La lecture d information se fait par block. On lit de manière systématique un block composé de un ou de plusieurs secteurs. Table du système de fichiers Une table est associée à chaque partition du disque dur Elle contient une liste décrivant chaque fichier Chaque élément de cette liste est un i-nœud (i-node) Un i-nœud décrit un fichier. C est une structure contenant les informations sur les fichiers, entre autres: Les attributs d un fichier: date de création Date de dernière modification Taille du fichier Droits sur le fichier Nombre de liens sur le fichier Les numéros de blocks où il se trouve physiquement sur le disque dur 2

Table du système de fichiers (2) Sur les premiers secteurs se trouve la table de partition (la table des i-noeuds). Table des i-noeuds i-nœud 5 -------------------- Date de créat Date de modif # de liens: 3 Taille : 1324 octets Blocks: 14; 15 i-nœud 6 -------------------- Date de créat Date de modif # de liens: 2 Taille : 1000 octets Blocks: 123; i-nœud -------------------- Secteur 14-15 (correspondant à l emplacement du fichier décrit par l i-node 5) Secteur 123 (correspondant à l emplacement du fichier décrit par l i-node 6) Structure détaillée d un i-nœud (système de fichiers ext2) La structure ext2_inode est définie dans le fichier <linux/ext2_fs.h>. Voici une liste non exhaustive des champs. Type u16 u16 u32 u32 u32 u32 u16 u16 u32 u32 [EXT2_N_BLOCKS]... Champ i_mode i_uid i_size i_atime i_mtime i_ctime i_gid i_links_count i_blocks i_block Description Mode du fichier (type et droits d accès) Utilisateur propriétaire Taille du fichier en octets Date de dernier accès Date de dernière modification du contenu Date de dernière modification de l i-nœud Groupe propriétaire Nombre de liens Nombre de blocs alloués au fichier Adresses des blocs alloués à l i-noeuds 3

Structure détaillée d un i-nœud: adresses des blocs (ext2) Le champ i_block est un tableau décrivant les blocs alloués au fichier. Bloc sur le disque dur Tableau i_block Tableau de EXT2_N_BLOCK éléments... Blocs directs Blocs indirects Blocs doublement indirects Vue utilisateur dus système de fichiers La vision utilisateur du système de fichiers est une arborescente de répertoire contenant des fichiers identifiables par des noms. Cette structure n a rien à voir avec la structure du système de fichier sur le disque (voir les transparents précédents). Les répertoires sont des fichiers spéciaux (non ordinaires) qui contiennent une liste de fichiers Le numéro du périphérique (plusieurs périphériques peuvent regroupés au sein d une même arborescence) Le numéro d inode sur le périphérique 4

Lecture d un fichier: exemple Ouverture du fichier /user/busson/cours.pdf Inode 2 Blocs: 212 Inode 17 Blocs: 15, 16 Inode 21 Blocs: 3 Inode 22 Blocs: 9 Lecture du bloc 212 correspondant au répertoire racine Nom Périphérique Inode ------------------- usr 000 8 home 000 234 bin 000 147 user 000 21 include 000 228 Lecture d un fichier: exemple Ouverture du fichier /user/busson/cours.pdf Inode 2 Blocs: 212 Inode 17 Blocs: 15, 16 Inode 21 Blocs: 3 Inode 22 Blocs: 9 Lecture du bloc 212 correspondant au répertoire racine Nom Périphérique Inode ------------------- Nom Périphérique Inode usr ------------------- 000 8 homedupont 000 000 234 167 bin dupond000 000 147 564 user busson000 000 21 22 include 000 228 Lecture du bloc 3 correspondant au répertoire /user 5

Lecture d un fichier: exemple Ouverture du fichier /user/busson/cours.pdf Inode 2 Blocs: 212 Inode 17 Blocs: 15, 16 Inode 21 Blocs: 3 Inode 22 Blocs: 9 Nom Périphérique Inode ------------------- Nom Périphérique Inode usr ------------------- Nom 000 Périphérique 8 Inode homedupont ------------------- 000 000 234 167 bin dupond fichier1 000 000 000 147 564 54 user busson fichier2 000 000 000 21 22 765 include cours.pdf 000 000 228 17 Lecture du bloc 9 correspondant au répertoire /user/busson Lecture d un fichier: exemple Ouverture du fichier /user/busson/cours.pdf Inode 2 Blocs: 212 Inode 17 Blocs: 15, 16 Inode 21 Blocs: 3 Inode 22 Blocs: 9 Nom Périphérique Inode ------------------- Nom Périphérique Inode usr ------------------- Nom 000 Périphérique 8 Inode homedupont ------------------- 000 000 234 167 bin dupond fichier1 000 000 000 147 564 54 user busson fichier2 000 000 000 21 22 765 include cours.pdf 000 000 228 17 Lecture des blocs 15 et 16 correspondant au fichier /user/busson/cours.pdf 6

Structure physique d un système de fichiers: Ext2 Disque dur avec une seule partition. Secteur de boot Ensemble de blocs 1 Ensemble de blocs 2 Ensemble de blocs n super bloc descripteurs Bitmap blocs Bitmap i-nodes i-nodes table Blocs de données propriétés du système de fichiers contiennent les numéros de blocs des bitmaps, des tables des i-noeuds indique l allocation des blocs pour cet ensemble indique l allocation des i- nodes pour cet ensemble Structure physique d un système de fichiers: Ext2 (2) Le super bloc contient les informations de contrôle du système de fichiers et est dupliquée dans chaque ensemble de blocs pour des raisons de fiabilité. Il contient entre autres: le nombre de blocs libre, leur taille le nombre d i-nœuds libre nombre de blocs par ensemble les dates de montage, d écriture, etc. la gestion de la vérification du système (intervalle entre deux vérifications, date de dernière vérification, etc.) La table des descripteurs contient les adresses des blocs contenant les informations cruciales (bitmap, table des i-nœuds, etc.) 7

Structure physique d un système de fichiers: Ext2 (3) Le bloc de bitmap pour les blocs est une carte binaire indiquant les blocs libres. Elle est mise à jour à chaque création/extension ou suppression d un fichier. Un 0 indique un bloc libre Un 1 indique un bloc plein 00110101001111111100000111010101111100011100110101 les deux premiers blocs sont libre. les deux blocs suivants sont occupés. Le bloc de bitmap pour les i-nœuds indique les i-nœuds libre Structure physique des systèmes de fichiers sur un disque dur Disque dur. MBR Partition 1 Partition 2 Partition 3 Master Boot Record Contient les caractéristiques physique du disque dur (taille de secteurs, etc). La table de partition principale décrivant le nombre de partition et leur emplacement. Un programme de lancement. Chaque partition contient un système de fichier indépendant. Il peut contenir un système d exploitation ou non. 8

Traitement des fichiers ouverts par le noyau Gestion des fichiers ouverts par le noyau A chaque processus (programme en cours d exécution) le noyau associe une liste de fichiers ouverts Cette première liste est référencée par les descripteurs de fichiers (des entiers) Chaque élément de cette liste pointe vers une table générale (commune à tous les processus) listant tous les fichiers ouverts Chaque élément de cette dernière table pointe vers une entrée de d une table d i-nœuds chargé en mémoire. 9

Gestion des fichiers ouverts par le noyau current Pointeur pointant sur le descriptif du processus en cours d exécution. Liste des fichiers ouverts par l ensemble des processus Liste des i-nœuds chargés en mémoire Pointeur vers la liste des fichiers ouverts par ce processus task_struct files_struct Chaque entrée contient essentiellement un pointeur sur une entrée de la table globale. files i-nodes Détail de la structure files_struct La structure files_struct (définit dans le fichier <linux/fs.h>) est la suivante (exhaustive): Type int fd_set struct file * [NR_OPEN] Champ count close_on_exec fd Description Nombre de descripteurs de fichiers associés indique si le fichier doit être fermé lors d un recouvrement (voir cours sur les processsu et l appel execl() ) pointeurs sur les descripteurs de fichiers ouverts 10

Détail de la structure files La structure files (définit dans le fichier <linux/fs.h>) est la suivante (non exhaustive): Type loff_t unsigned long Champ f_pos f_flags Description position courante en octets depuis le début du fichier (c est la position en lecture/ecriture dans le fichier). mode du fichier (mode d ouverture spécifié par l appel open) struct file * struct file * strcut inode * struct file_operations * unsigned long f_next f_prev f_inode f_op f_version pointeur de chaînage sur la structure suivante pointeur de chaînage sur la structure précédente pointeur sur l i-nœud correspondant au fichier opérations liées au fichier ouvert numéro de version incrémenté à chaque utilisation du descripteur Structure détaillée d un i-nœud (inœud des fichiers ouverts) La structure inode est définie dans le fichier <linux/fs.h>. Voici une liste non exhaustive des champs. Type kdev_t unsigned long umode_t n_link_t uid_t gid_t kdev_t off_t time_t time_t time_t unsigned long unisgned long Champ i_dev i_ino i_mode i_nlink i_uid i_gid i_rdev i_size i_atime i_mtime i_ctime i_blksize i_blocks Description Identificateur du périphérique (il y a une seule table d inode pour l ensemble des périphériques). Numéro d i-nœud Mode du fichier (type et droits d accès) Nombre de liens Utilisateur propriétaire Groupe propriétaire Identificateur du périphérique dans le cas d un fichier spécial Taille du fichier en octets Date de dernier accès Date de dernière modification du contenu Date de dernière modification de l i-nœud Taille des blocs en octet Nombre de blocs alloués au fichier 11

Structure détaillée d un i-nœud (inœud des fichiers ouverts) Type struct inode * struct inode * struct inode * struct inode * Struct inode * Champ i_next i_prev i_hash_next i_hash_prev i_mount Description Pointeur sur le prochain i-node Pointeur sur l i-node précèdent Pointeur sur le prochain i-node dans la liste de hachage Pointeur sur l i-node précédent dans la liste de hachage Pointeur sur l inoeud racine d un système de fichier dans le cas d un point de montage (l i-nœud du répertoire de montage) Les appels systèmes open() close() read() write() lseek() 12

Préambule Les appels systèmes renvoient un code de retour. Celui permet de vérifier le bon déroulement de l appel. La fonction perror(), permet d afficher un message quelconque et d afficher le code d erreur renvoyé par l appel système. #include<perror.h> void perror(const char* s); La fonction perror() affiche un message sur la sortie standard, décrivant la dernière erreur rencontrée durant un appel système ou une fonction de bibliothèque. La chaîne de caractère s est affichée en premier puis le message. Opérations sur un fichier Pour effectuer une opération de lecture ou d écriture sur un fichier, il faut: L ouvrir avec l appel système open() Lire avec l appel read() Ou écrire avec l appel write() On peut également se déplacer dans le fichier avec l appel lseek() Fermer le fichier avec l appel close(). 13

open() #include<sys/types.h> #include<sys/stat.h> #include<fcntl.h> int open(const char *pathname, int flags); int open(const char *pathname, int flags, mode_t mode); Le paramètre pathname spécifie le nom du fichier à ouvrir. Il peut être exprimé sous forme relative ou absolue. Le paramètre flags indique le mode d ouverture du fichier (lecture/écriture). Voir transparent suivant. Le paramètre mode spécifie les droits du fichier lors d une création. Valeur renvoyée: retourne un descripteur de fichier (un entier >2, sauf exception) ou la valeur -1 en cas d erreur. open(): mode d ouverture Un fichier peut être ouvert suivant les modes définit dans le tableau cidessous. Plusieurs options peuvent être combinées avec des OU logique. Par exemple une ouverture de fichier en écriture avec création et renvoi d une erreur si le fichier existe déjà correspondra au mode O_WRONLY O_CREAT O_EXCL option O_RDONLY O_WRONLY O_RDWR O_CREAT O_EXCL O_TRUNC O_APPEND O_SYNC signification lecture seule écriture seule lecture et écriture Création du fichier s il n existe pas provoque une erreur si O_CREAT est utilisé et que le fichier existe déjà suppression du contenu du fichier si celui-ci existe lors de sa création ouverture en mode ajout, toute écriture est effectuée en fin de fichier ouverture du fichier en mode synchrone: toute mise à jour est écrite immédiatement sur le disque 14

open : mode du fichier lors de sa création Lors d une création de fichier l argument mode définit les droits sur le fichier créé. Le fonctionnement est le même que pour les flags d ouverture. option S_ISUID S_ISGID S_ISVTX S_IRUSR S_IWUSR S_IXUSR S_IRWXU S_IRGRP S_IWGRP S_IXGRP S_IRWXG S_IROTH S_IWOTH S_IXOTH S_IRWXO signification Bit setuid Bit setgid Bit sticky Droit de lecture pour le propriétaire Droit d écriture pour le propriétaire Droit d exécution pour le propriétaire Droits de lecture, écriture, exécution pour le propriétaire Droit de lecture pour le groupe Droit d écriture pour le groupe Droit d exécution pour le groupe Droits de lecture, écriture, exécution pour le groupe Droit de lecture pour le reste des utilisateurs Droit d écriture pour le reste des utilisateurs Droit d exécution pour le reste des utilisateurs Droits de lecture, écriture, exécution pour le reste des utilisateurs read() ssize_t read(int fd, void* buf, size_t count); Le paramètre fd spécifie le descripteur du fichier sur lequel on souhaite lire. Il s agit du descripteur de fichier qui a été renvoyé par l appel de open(). Le paramètre buf est un pointeur indiquant où doivent être rangé les données lues. Le paramètre count est la taille en octet du buffer qui a été réservée pour la lecture et pointé par buf. C est le nombre maximale d octets qui peut être lu. Valeur renvoyée: retourne le nombre d octets qui a été lu ou bien 0 si on se trouve en fin de fichier ou -1 en cas d erreur. 15

write() ssize_t write(int fd, const char* buf, size_t count); Le paramètre fd spécifie le descripteur du fichier sur lequel on souhaite écrire. Il s agit du descripteur de fichier qui a été renvoyé par l appel de open(). Le paramètre buf est un pointeur indiquant où sont rangées les données à écrire dans le fichier. Le paramètre count est le nombre d octets à écrire dans le ficher. Valeur renvoyée: retourne le nombre d octets qui a été écrits dans le fichier ou -1 en cas d erreur. close() ssize_t close(int fd); Le paramètre fd spécifie le descripteur du fichier correspondant au fichier que l on souhaite fermer. Il s agit du descripteur de fichier qui a été renvoyé par l appel de open(). Valeur renvoyée: retourne le nombre 0 en cas de succès ou -1 en cas d erreur. 16

Positionnement dans un fichier L écriture ou la lecture dans un fichier sont séquentiels. aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ouverture du fichier en lecture, le pointeur est positionné sur le premier octet. après lecture de 13 octets, le pointeur est positionné sur le 14 ème octets. à chaque nouvelle lecture le pointeur est déplacé du nombre d octets lu. lseek() off_t lseek(int fd, off_t offset, int whence); Le paramètre fd spécifie le descripteur du fichier. Il s agit du descripteur de fichier qui a été renvoyé par l appel de open(). Le paramètre offset définit le déplacement en octet que l on souhaite effectuer. Le paramètre whence définit la base du déplacement (à partir de quel endroit on se déplace). Valeur renvoyée: retourne la nouvelle position courante en octets par rapport au début du fichier ou -1 en cas d erreur. 17

lseek(): déplacement Le paramètre whence peut prendre les valeurs suivantes option SEEK_SET SEEK_CUR SEEK_END signification positionnement par rapport au début de fichier positionnement par rapport à la position courante du pointeur positionnement par rapport à la fin du fichier Remarque: Dans le cas où la position de référence définit par whence est SEEK_END, la valeur du paramètre offset doit être négative. Tampon Un tampon est zone mémoire dans laquelle les opérations de lectures et d écritures sont effectués. Le contenu de ces tampon sont mise, correspondance avec un média physique. Ils permettent de diminuer le nombre d accès physique au média. Ils accélèrent les lectures/écritures 18

Tampon (2) Lors de la lecture, une partie du fichier est placé dans le tampon. L écriture (mise à jour) du fichier sur le disque dur se fait lorsque les données écrites arrive en fin de tampon de manière régulière par le noyau la fonction fsync est appelé aaaaaaaaaaaaaaaa Disque lecture aaaaaaaaaabbbbbb écriture Disque Appels systèmes supplémentaires link() unlink() symlink() readlink() rename() chmod() fchmod() chown() fchown() stat() fstat() lstat 19

link() int link(const char* oldpath, const char* newpath); Cette fonction permet de créer un nouveau lien sur un fichier. Il s agit d un lien par inode. Le nouveau lien doit donc se trouver impérativement sur le même système de fichier que le lien de référence. Les fichiers ne doivent pas être des répertoires. Le paramètre oldpath spécifie l emplacement du fichier de référence. Le paramètre newpath définit le nom et emplacement du nouveau lien. Valeur renvoyée: retourne la valeur 0 en cas de succès ou -1 en cas d erreur. unlink() int unlink(const char* pathname); Cette fonction permet de supprimer lien sur un fichier. Il s agit d un lien par inode. Le fichier est définitivement supprimer s il s agit du dernier lien. Le paramètre pathname spécifie l emplacement du fichier. Valeur renvoyée: retourne la valeur 0 en cas de succès ou -1 en cas d erreur. 20

symlink() int symlink(const char* oldpath, const char* newpath); Cette fonction permet de créer un lien symbolique sur un fichier. Le paramètre oldpath spécifie l emplacement du fichier de référence. Le paramètre newpath définit le nom (et emplacement) du lien symbolique. Valeur renvoyée: retourne la valeur 0 en cas de succès ou -1 en cas d erreur. readlink() int readlink(const char* pathname, char* buf, size_t bufsiz); Cette fonction permet de lire le nom du fichier sur lequel pointe un lien symbolique. Le paramètre pathname spécifie l emplacement du lien symbolique. Le paramètre buf définit l emplacement du tampon mémoire dans lequel le nom du fichier pointé sera placé. Le paramètre bufsiz est la taille du tampon mémoire Valeur renvoyée: retourne le nombre d octets placés dans le tampon mémoire (le nombre d octets constituant le nom du fichier pointé) ou -1 en cas d erreur. 21

rename() int rename(const char* oldpath, const char* newpath); Cette fonction permet de modifier le nom d un fichier. Le nouveau nom peut se trouver dans un répertoire différent. Le paramètre oldpath spécifie le nom du fichier de référence. Le paramètre newpath définit le nouveau nom du fichier. Valeur renvoyée: retourne la valeur 0 en cas de succès ou -1 en cas d erreur. chmod() fchmod() #include<sys/types.h> #include<sys/stat.h> int chmod(const char* pathname, mode_t mode); int fchmod(int fd, mode_t mode); Cette fonction permet de modifier les droits d accès sur un fichier. Le paramètre pathname (appel chmod) spécifie l emplacement du fichier dont on veut modifier les droits d accès. Le paramètre fd (appel fchmod) spécifie le descripteur de fichier pour lequel on veut modifier les droits d accès. Le paramètre mode définit les droits sur le fichier. Valeur renvoyée: retourne la valeur 0 en cas de succès ou -1 en cas d erreur. Remarque: seuls les propriétaire du fichier et le super utilisateur peuvent modifier les droits sur un fichier. 22

Constantes possibles pour la variable mode_t Le fonctionnement et les valeurs des constantes sont les mêmes que pour l appel open(): option S_ISUID S_ISGID S_ISVTX S_IRUSR S_IWUSR S_IXUSR S_IRWXU S_IRGRP S_IWGRP S_IXGRP S_IRWXG S_IROTH S_IWOTH S_IXOTH S_IRWXO signification Bit setuid Bit setgid Bit sticky Droit de lecture pour le propriétaire Droit d écriture pour le propriétaire Droit d exécution pour le propriétaire Droits de lecture, écriture, exécution pour le propriétaire Droit de lecture pour le groupe Droit d écriture pour le groupe Droit d exécution pour le groupe Droits de lecture, écriture, exécution pour le groupe Droit de lecture pour le reste des utilisateurs Droit d écriture pour le reste des utilisateurs Droit d exécution pour le reste des utilisateurs Droits de lecture, écriture, exécution pour le reste des utilisateurs chown() fchown() #include<sys/types.h> int chown(const char* pathname, uid_t owner, gid_t group); int fchown(int fd, uid_t owner, gid_t group); Cette fonction permet de modifier le propriétaire ou le groupe d un fichier. Le paramètre pathname (appel chown) spécifie l emplacement du fichier dont on veut modifier le propriétaire/groupe. Le paramètre fd (appel fchown) spécifie le descripteur de fichier pour lequel on veut modifier le propriétaire/groupe. Le paramètre owner définit le nouveau propriétaire. Le paramètre group définit le nouveau groupe. Valeur renvoyée: retourne la valeur 0 en cas de succès ou -1 en cas d erreur. Remarque: seul le super utilisateur peut modifier le propriétaire d un fichier. 23

stat() fstat() #include <sys/types.h> #include <sys/stat.h> #include <unistd.h> int stat(const char *pathname, struct stat *buf); int fstat(int fd, struct stat *buf); int lstat(const char *pathname, struct stat *buf); Cette fonction permet de récupérer les propriétés d un fichier. Le paramètre pathname (appels stat et lstat) spécifie l emplacement du fichier dont on veut connaître les propriétés. Le paramètre fd (appel fstat) spécifie le descripteur de fichier pour lequel on veut connaître les propriétés. Cela suppose un appel préalable à open(). Le paramètre buf est un pointeur sur une structure stat dans laquelle sera placé les propriétés du fichier spécifié. Valeur renvoyée: retourne la valeur 0 en cas de succès ou -1 en cas d erreur. Remarque: la seule différence entre stat() et lstat() est que si le fichier est un lien symbolique alors lstat() renvoi les propriétés du lien lui-même alors que stat() renvoi les propriétés du fichier pointé par le lien symbolique. Les champs de la structure stat struct stat { dev_t st_dev; /* numéro de périphérique */ ino_t st_ino; /* numéro d i-noeud */ mode_t st_mode; /* droits */ nlink_t st_nlink; /* nombre de liens */ uid_t st_uid; /* propriétaire */ gid_t st_gid; /* groupe */ dev_t st_rdev; /* périphérique (si fichier spéciale) */ off_t st_size; /* taille en octets */ blksize_t st_blksize; /* blocksize for filesystem I/O */ blkcnt_t st_blocks; /* number of blocks allocated */ time_t st_atime; /* time of last access */ time_t st_mtime; /* time of last modification */ time_t st_ctime; /* time of last status change */ }; 24

Attributs du champ st_mode Les attributs suivants correspondent au champ st_mode. S_IFMT 00170000 (non POSIX) masque de l'ensemble des bits du type de fichier S_IFSOCK 0140000 (non POSIX) socket S_IFLNK 0120000 (non POSIX) lien symbolique S_IFREG 0100000 (non POSIX) fichier régulier S_IFBLK 0060000 (non POSIX) périphérique blocs S_IFDIR 0040000 (non POSIX) répertoire S_IFCHR 0020000 (non POSIX) périphérique caractères S_IFIFO 0010000 (non POSIX) fifo S_ISUID 0004000 bit Set-UID S_ISGID 0002000 bit Set-Gid S_ISVTX 0001000 (non POSIX) bit "sticky" S_IRWXU 00700 droits de lecture/écriture/exécution du propriétaire S_IRUSR 00400 le propriétaire a le droit de lecture (comme S_IREAD qui n'est pas POSIX) S_IWUSR 00200 le propriétaire a le droit d'écriture (comme S_IWRITE qui n'est pas POSIX) S_IXUSR 00100 le propriétaire a le droit d'exécution (comme S_IEXEC qui n'est pas POSIX) S_IRWXG 00070 droits de lecture/écriture/exécution du groupe S_IRGRP 00040 le groupe a le droit de lecture S_IWGRP 00020 le groupe a le droit d'écriture S_IXGRP 00010 le groupe a le droit d'exécution S_IRWXO 00007 droits de lecture/écriture/exécution des autres S_IROTH 00004 les autres ont le droit de lecture S_IWOTH 00002 les autres ont le droit d'écriture S_IXOTH 00001 les autres ont le droit d'exécution Macro S_ISLNK(m) est-ce un lien symbolique? S_ISREG(m) un fichier régulier? S_ISDIR(m) un répertoire? S_ISCHR(m) un péripherique en mode caractère? S_ISBLK(m) un périphérique en mode blocs? S_ISFIFO(m) une FIFO? S_ISSOCK(m) une socket? m est le champ st_mode. 25

Appels systèmes liés à la gestion des répertoires mkdir() rmdir() chdir() getcwd() chroot() opendir() readdir() closedir() mkdir() #include<sys/types.h> #include<fcntl.h> int mkdir(const char* pathname, mode_t mode); Cette fonction permet de un répertoire. Le paramètre pathname spécifie le nom et emplacement du nouveau répertoire. Le paramètre mode définit les droits sur le répertoire. Valeur renvoyée: retourne la valeur 0 en cas de succès ou -1 en cas d erreur. 26

mkdir() int rmdir(const char* pathname); Cette fonction supprimer un répertoire. Le paramètre pathname spécifie le nom et emplacement du répertoire à supprimer. Valeur renvoyée: retourne la valeur 0 en cas de succès ou -1 en cas d erreur. chdir() int chdir(const char* pathname); A chaque processus est associé un répertoire courant. Les noms relatifs des fichiers et répertoire sont basés sur ce répertoire courant. Cette fonction permet de changer de répertoire courant. Le paramètre pathname spécifie le nom et emplacement du nouveau répertoire courant. Valeur renvoyée: retourne la valeur 0 en cas de succès ou -1 en cas d erreur. 27

getcwd() char* getcwd(char* buf, size_t size); Cette fonction permet de connaître le nom du répertoire courant. Le paramètre buf spécifie un pointeur dans lequel est placé le nom absolu du répertoire courant. Le paramètre size est la taille ne octet de la mémoire tampon pointé par buf. Valeur renvoyée: retourne le pointeur buf en cas de succès ou le pointeur NULL en cas d erreur. Remarque: cette fonction n est pas un appel système mais une fonction de la bibliothèque C. chroot() int chroot(const char* pathname); A chaque processus est associé un répertoire racine. Le répertoire racine associé à un processus peut être différent de la racine de l arborescence du système de fichiers. Les noms de fichiers absolus sont basés sur ce répertoire racine. Cette fonction permet de changer le répertoire racine du processus (qui appelle cette fonction). Le paramètre pathname spécifie le nom et emplacement du nouveau répertoire courant. Valeur renvoyée: retourne la valeur 0 en cas de succès ou -1 en cas d erreur. 28

opendir() #include<sys/types.h> #include<dirent.h> DIR* opendir(const char* pathname); Cette fonction permet d ouvrir un répertoire. Le paramètre pathname spécifie le nom et emplacement du répertoire que l on souhaite ouvrir. Valeur renvoyée: retourne un pointeur sur un répertoire ouvert en cas de succès ou NULL en cas d erreur. readdir() #include<sys/types.h> #include<dirent.h> struct dirent* readdir(dir* dir); Cette fonction permet de lire un répertoire. Il retourne une entrée de ce répertoire. Le paramètre dir spécifie le descripteur de répertoire ouvert. Une ouverture préalable du répertoire par l appel opendir() est nécessaire. Valeur renvoyée: retourne un pointeur non NULL sur une structure dirent en cas de succès ou NULL en cas d erreur. 29

Structure d une entrée du répertoire struct dirent { long d_ino; /* inode number */ off_t d_off; /* offset to this dirent */ unsigned short d_reclen; /* length of this d_name */ char d_name [NAME_MAX+1]; /* file name (null-terminated) */ }; Attention: Les deux champs d_off et d_reclen ne fonctionnent pas toujours. closedir() #include<sys/types.h> #include<dirent.h> int closedir(dir* dir); Cette fonction permet de fermer un répertoire. Le paramètre dir spécifie le descripteur de répertoire ouvert. Une ouverture préalable du répertoire par l appel opendir() est nécessaire. Valeur renvoyée: retourne 0 en cas de succès ou -1 en cas d erreur. 30

Appels systèmes liés à la synchronisation des lectures/écritures sur un fichier flock() lockf() #include<sys/file.h> int lockf(int fd, int operation, off_t len); Cette fonction permet de poser ou de retirer un verrou sur un fichier. Le paramètre fd spécifie le descripteur du fichier sur lequel on va mettre/enlever un verrou. Le paramètre operation décrit l opération à effectuer. Les opérations possibles sont: F_LOCK : Poser un verrou exclusif sur le fichier. Un seul processus peut posséder un verrou exclusif sur un fichier donné à un moment donné. Si le fichier est déjà verrouillé, l'appel bloque jusqu'à la suppression du verrou précédent. F_TLOCK : Comme F_LOCK mais l'appel n'est pas bloquant, il renvoie une erreur si le fichier est déjà verrouillé. F_ULOCK : Déverrouiller un fichier. F_TEST : Vérifie s'il y a un verrou : l'appel renvoie 0 si le fichier est libre, ou s'il est verrouillé par le processus appelant. Il renvoie -1 avec EACCES dans errno si un autre processus possède le verrou. Le paramètre len spécifie la portée du verrouillage. Cette portée s exprime par rapport à la position courante. Valeur renvoyée: retourne -1 en cas de succès ou 0 en cas d erreur. 31