perkamon - en to fr translation catalogue (728 entries)

note: type: TH
en: 2014-01-15
fr: 15 janvier 2014

note: type: TH
en: Linux Programmer's Manual
fr: Manuel du programmeur Linux

note: type: SH
en: NAME
fr: NOM

note: type: Plain text
en: filesystems - Linux filesystem types: minix, ext, ext2, ext3, ext4, Reiserfs, XFS, JFS, xia, msdos, umsdos, vfat, ntfs, proc, nfs, iso9660, hpfs, sysv, smb, ncpfs
fr: filesystems - Types des systèmes de fichiers sous Linux : minix, ext, ext2, ext3, ext4, Reiserfs, XFS, JFS, xia, msdos, umsdos, vfat, ntfs, proc, nfs, iso9660, hpfs, sysv, smb, ncpfs

note: type: Plain text
en: When, as is customary, the B<proc> filesystem is mounted on I</proc>, you can find in the file I</proc/filesystems> which filesystems your kernel currently supports; see B<proc>(5)  for more details.  If you need a currently unsupported filesystem, insert the corresponding module or recompile the kernel.
fr: Lorsque, ce qui est habituel, le système de fichiers B<proc> est monté sur I</proc>, I</proc/filesystems> contient la liste des systèmes de fichiers gérés par le noyau actuel ; consultez B<proc>(5) pour plus de précisions. Si vous avez besoin d'utiliser un système de fichiers non géré, vous pouvez insérer le module correspondant dans le noyau ou le recompiler avec l'option correspondante.

note: type: Plain text
en: In order to use a filesystem, you have to I<mount> it; see B<mount>(8).
fr: Pour pouvoir utiliser un système de fichiers, vous devez le I<monter> ; consultez B<mount>(8).

note: type: Plain text
en: Below a short description of a few of the available filesystems.
fr: Voici une description des divers types de systèmes de fichiers :

note: type: Plain text
en: is the filesystem used in the Minix operating system, the first to run under Linux.  It has a number of shortcomings, including a 64MB partition size limit, short filenames, and a single timestamp.  It remains useful for floppies and RAM disks.
fr: est le système de fichiers utilisé par le système d'exploitation Minix, le premier à avoir fonctionné sous Linux. Il a de nombreuses limitations (un maximum de 64 Mo par partition, des noms de fichiers courts, un seul horodatage, etc.). Néanmoins, il reste très appréciable pour les disquettes et les disques en mémoire vive.

note: type: Plain text
en: is an elaborate extension of the B<minix> filesystem.  It has been completely superseded by the second version of the extended filesystem (B<ext2>)  and has been removed from the kernel (in 2.1.21).
fr: est une extension élaborée du système de fichiers B<minix>. Il a été complètement remplacé par sa seconde version (B<ext2>) et supprimé du noyau (depuis la version 2.1.21).

note: type: Plain text
en: is the high performance disk filesystem used by Linux for fixed disks as well as removable media.  The second extended filesystem was designed as an extension of the extended filesystem (B<ext>).  B<ext2> offers the best performance (in terms of speed and CPU usage) of the filesystems supported under Linux.
fr: est un système de fichiers de hautes performances, utilisé par Linux pour les disques fixes tout autant que pour les supports amovibles. Le second système de fichiers étendu a été conçu comme une extension du système (B<ext>). B<ext2> offre les meilleures performances (en termes de vitesse et de consommation CPU) de tous les systèmes de fichiers gérés par Linux.

note: type: Plain text
en: is a journaling version of the ext2 filesystem.  It is easy to switch back and forth between ext2 and ext3.
fr: est une version d'ext2 gérant la journalisation. On peut basculer facilement d'ext2 à ext3, et inversement.

note: type: Plain text
en: is a set of upgrades to ext3 including substantial performance and reliability enhancements, plus large increases in volume, file, and directory size limits.
fr: est un ensemble de mises à jour d'ext3 qui apporte des améliorations notables en terme de performance et de stabilité, ainsi qu'une augmentation importante des limites des volumes, fichiers et tailles de répertoire.

note: type: Plain text
en: is a journaling filesystem, designed by Hans Reiser, that was integrated into Linux in kernel 2.4.1.
fr: est un système de fichiers journalisé, conçu par Hans Reiser, qui a été intégré dans Linux avec la version 2.4.1 du noyau

note: type: Plain text
en: is a journaling filesystem, developed by SGI, that was integrated into Linux in kernel 2.4.20.
fr: est un système de fichiers journalisé, développé par CGI, qui a été intégré dans Linux avec la version 2.4.20 du noyau

note: type: Plain text
en: is a journaling filesystem, developed by IBM, that was integrated into Linux in kernel 2.4.24.
fr: est un système de fichiers journalisé, développé par IBM, qui a été intégré dans Linux avec la version 2.4.24 du noyau

note: type: Plain text
en: was designed and implemented to be a stable, safe filesystem by extending the Minix filesystem code.  It provides the basic most requested features without undue complexity.  The B<xia> filesystem is no longer actively developed or maintained.  It was removed from the kernel in 2.1.21.
fr: a été conçu et implémenté, à partir du code du système de fichiers Minix, pour être un système de fichiers sûr et stable. Il procure les fonctionnalités de base sans complications excessives. Le système de fichiers B<xia> n'est plus développé ni maintenu. Il a été retiré du noyau depuis la version 2.1.21.

note: type: Plain text
en: is the filesystem used by DOS, Windows, and some OS/2 computers.  B<msdos> filenames can be no longer than 8 characters, followed by an optional period and 3 character extension.
fr: est le système de fichiers utilisé sous DOS, Windows, et certains ordinateurs sous OS/2. Les noms de fichiers sous B<msdos> sont limités à 8 caractères suivis éventuellement d'un point et jusqu'à 3 caractères d'extension.

note: type: Plain text
en: is an extended DOS filesystem used by Linux.  It adds capability for long filenames, UID/GID, POSIX permissions, and special files (devices, named pipes, etc.)  under the DOS filesystem, without sacrificing compatibility with DOS.
fr: est un système de fichiers DOS étendu utilisé par Linux. Il ajoute la possibilité d'utiliser des noms de fichier longs, les UID/GID, les autorisations POSIX, les fichiers spéciaux (périphériques, tubes nommés, etc.), au système de fichiers DOS, sans sacrifier la compatibilité avec celui-ci.

note: type: Plain text
en: is an extended DOS filesystem used by Microsoft Windows95 and Windows NT.  VFAT adds the capability to use long filenames under the MSDOS filesystem.
fr: est un système de fichiers DOS étendu utilisé par Microsoft Windows95 et Windows NT. VFAT ajoute la possibilité d'utiliser des noms de fichiers longs au système de fichiers MSDOS.

note: type: Plain text
en: replaces Microsoft Window's FAT filesystems (VFAT, FAT32).  It has reliability, performance, and space-utilization enhancements plus features like ACLs, journaling, encryption, and so on.
fr: remplace le système de fichiers FAT (VFAT, FAT32) de Microsoft Window. Il apporte des améliorations en terme de fiabilité et de performance, et une meilleure utilisation de l'espace disque, ainsi que des fonctionnalités comme les ACL, la journalisation, le chiffrage, etc.

note: type: Plain text
en: is a pseudo filesystem which is used as an interface to kernel data structures rather than reading and interpreting I</dev/kmem>.  In particular, its files do not take disk space.  See B<proc>(5).
fr: est un pseudosystème de fichiers qui est utilisé comme interface avec les structures de données du noyau plutôt que de lire et interpréter I</dev/kmem>. En particulier, ses fichiers n'occupent aucun espace disque. Consultez B<proc>(5).

note: type: Plain text
en: is a CD-ROM filesystem type conforming to the ISO 9660 standard.
fr: est un système de fichiers pour CD-ROM, conforme à la norme ISO 9660.

note: type: Plain text
en: Linux supports High Sierra, the precursor to the ISO 9660 standard for CD-ROM filesystems.  It is automatically recognized within the B<iso9660> filesystem support under Linux.
fr: Linux gère le format « High Sierra », précurseur de la norme ISO 9660 pour les CD-ROM. Ce format est automatiquement reconnu par le gestionnaire du système de fichiers B<iso9660> de Linux.

note: type: Plain text
en: Linux also supports the System Use Sharing Protocol records specified by the Rock Ridge Interchange Protocol.  They are used to further describe the files in the B<iso9660> filesystem to a UNIX host, and provide information such as long filenames, UID/GID, POSIX permissions, and devices.  It is automatically recognized within the B<iso9660> filesystem support under Linux.
fr: Linux gère également le format « System Use Sharing Protocol » indiqué par le « Rock Ridge Interchange Protocol ». Ils sont utilisés pour décrire plus en profondeur les fichiers contenus dans un système de fichiers B<iso9660> à destination d'un hôte UNIX, et pour fournir des informations telles que les noms de fichiers longs, les UID/GID, les autorisations POSIX, et les fichiers de périphériques. Ce format est automatiquement reconnu par le gestionnaire du système de fichiers B<iso9660> de Linux.

note: type: Plain text
en: is the High Performance Filesystem, used in OS/2.  This filesystem is read-only under Linux due to the lack of available documentation.
fr: est le système de fichiers « High Performance Filesystem » utilisé par OS/2. Ce système de fichiers est en lecture seule sous Linux en raison du manque de documentation disponible.

note: type: Plain text
en: is an implementation of the SystemV/Coherent filesystem for Linux.  It implements all of Xenix FS, SystemV/386 FS, and Coherent FS.
fr: est une implémentation du système de fichiers SystemV/Coherent pour Linux. Il implémente tous les protocoles Xenix FS, SystemV/386 FS, et Coherent FS.

note: type: Plain text
en: is the network filesystem used to access disks located on remote computers.
fr: est le système de fichiers par le réseau utilisé pour accéder à des disques situés sur des ordinateurs distants.

note: type: Plain text
en: is a network filesystem that supports the SMB protocol, used by Windows for Workgroups, Windows NT, and Lan Manager.
fr: est un système de fichiers par le réseau gérant le protocole SMB, utilisé par Windows pour Workgroups, Windows NT, et Lan Manager.

note: type: Plain text
en: To use B<smb> fs, you need a special mount program, which can be found in the ksmbfs package, found at E<.UR ftp://sunsite.unc.edu\:/pub\:/Linux\:/system\:/Filesystems\:/smbfs> E<.UE .>
fr: Pour utiliser le système B<smb>, il vous faut un programme spécial de montage, disponible dans le paquet ksmbfs que vous trouverez à E<.UR ftp://sunsite.unc.edu\:/pub\:/Linux\:/system\:/Filesystems\:/smbfs> E<.UE .>

note: type: Plain text
en: is a network filesystem that supports the NCP protocol, used by Novell NetWare.
fr: est un système de fichiers par le réseau gérant le protocole NCP, utilisé par Novell NetWare.

note: type: Plain text
en: To use B<ncpfs>, you need special programs, which can be found at E<.UR ftp://linux01.gwdg.de\:/pub\:/ncpfs> E<.UE .>
fr: Pour utiliser le système B<ncpfs>, il vous faut un programme spécial disponible à E<.UR ftp://linux01.gwdg.de\:/pub\:/ncpfs> E<.UE .>

note: type: SH
en: SEE ALSO
fr: VOIR AUSSI

note: type: Plain text
en: This page is part of release 3.65 of the Linux I<man-pages> project.  A description of the project, and information about reporting bugs, can be found at \%http://www.kernel.org/doc/man-pages/.
fr: Cette page fait partie de la publication 3.65 du projet I<man-pages> Linux. Une description du projet et des instructions pour signaler des anomalies peuvent être trouvées à l'adresse \%http://www.kernel.org/doc/man-pages/.

note: type: TH
en: 2014-03-18
fr: 18 mars 2014

note: type: Plain text
en: fts, fts_open, fts_read, fts_children, fts_set, fts_close - traverse a file hierarchy
fr: fts, fts_open, fts_read, fts_children, fts_set, fts_close - Parcourir une hiérarchie de fichiers

note: type: Plain text
en: The fts functions are provided for traversing file hierarchies.  A simple overview is that the B<fts_open>()  function returns a "handle" on a file hierarchy, which is then supplied to the other fts functions.  The function B<fts_read>()  returns a pointer to a structure describing one of the files in the file hierarchy.  The function B<fts_children>()  returns a pointer to a linked list of structures, each of which describes one of the files contained in a directory in the hierarchy.  In general, directories are visited two distinguishable times; in preorder (before any of their descendants are visited) and in postorder (after all of their descendants have been visited).  Files are visited once.  It is possible to walk the hierarchy "logically" (visiting the files that symbolic links point to)  or physically (visiting the symbolic links themselves), order the walk of the hierarchy or prune and/or revisit portions of the hierarchy.
fr: Les fonctions de la famille fts servent à traverser des hiérarchies de fichiers. Rapidement, disons que la fonction B<fts_open>() renvoie une sorte de descripteur de la hiérarchie de fichiers, que l'on fournit ensuite aux autres fonctions de la famille fts. La fonction B<fts_read>() renvoie un pointeur sur une structure décrivant l'un des fichiers de l'arborescence. La fonction B<fts_children>() renvoie un pointeur sur une liste chaînée de structures, chacune décrivant l'un des fichiers contenu dans le répertoire de la hiérarchie. En général, les répertoires sont visités à deux reprises, distinctes. Un passage en ordre «\ preorder\ » avant d'avoir parcouru leurs descendants, et un passage en ordre «\ postorder\ » après avoir visité tous les sous-répertoires. Les fichiers ne sont examinés qu'une seule fois. Il est possible de parcourir la hiérarchie «\ logiquement\ » (en visitant les fichiers pointés par les liens symboliques) ou «\ physiquement\ » (en visitant les liens symboliques eux-mêmes). On peut ordonner le parcours de la hiérarchie, ignorer ou visiter plusieurs fois certaines parties.

note: type: Plain text
en: Two structures are defined (and typedef'd) in the include file I<E<lt>fts.hE<gt>>.  The first is I<FTS>, the structure that represents the file hierarchy itself.  The second is I<FTSENT>, the structure that represents a file in the file hierarchy.  Normally, an I<FTSENT> structure is returned for every file in the file hierarchy.  In this manual page, "file" and "FTSENT structure" are generally interchangeable.  The I<FTSENT> structure contains at least the following fields, which are described in greater detail below:
fr: Deux structures sont définies (avec typedef) dans le fichier d'en-tête I<E<lt>fts.hE<gt>>. La première est I<FTS>, une structure représentant l'arborescence des fichiers elle-même, et la seconde est I<FTSENT>, une structure représentant un fichier dans la hiérarchie. Normalement, une structure I<FTSENT> est renvoyée pour chaque fichier rencontré dans la hiérarchie. Dans cette page de manuel, les termes «\ fichier\ » et « structure FTSENT » sont généralement interchangeables. La structure I<FTSENT> contient au moins les champs suivants, décrits en détail ci-dessous\ :

note: type: Plain text
en: typedef struct _ftsent {
        unsigned short fts_info;     /* flags for FTSENT structure */
        char          *fts_accpath;  /* access path */
        char          *fts_path;     /* root path */
        short          fts_pathlen;  /* strlen(fts_path) */
        char          *fts_name;     /* filename */
        short          fts_namelen;  /* strlen(fts_name) */
        short          fts_level;    /* depth (-1 to N) */
        int            fts_errno;    /* file errno */
        long           fts_number;   /* local numeric value */
        void          *fts_pointer;  /* local address value */
        struct ftsent *fts_parent;   /* parent directory */
        struct ftsent *fts_link;     /* next file structure */
        struct ftsent *fts_cycle;    /* cycle structure */
        struct stat   *fts_statp;    /* stat(2) information */
    } FTSENT;
fr: typedef struct _ftsent {
        unsigned short fts_info;     /* attribut de la structure FTSENT */
        char          *fts_accpath;  /* chemin d'accès */
        char          *fts_path;     /* chemin de la racine */
        short          fts_pathlen;  /* strlen(fts_path) */
        char          *fts_name;     /* non du fichier */
        short          fts_namelen;  /* strlen(fts_name) */
        short          fts_level;    /* profondeur (-1 à N) */
        int            fts_errno;    /* fichier errno */
        long           fts_number;   /* valeur numérique locale */
        void          *fts_pointer;  /* valeur de l'adresse locale */
        struct ftsent *fts_parent;   /* répertoire parent */
        struct ftsent *fts_link;     /* fichier de structure suivant */
        struct ftsent *fts_cycle;    /* cycle structure */
        struct stat   *fts_statp;    /* information sur stat(2) */
    } FTSENT;

note: .Bl -tag -width "fts_namelen" type: Plain text
en: These fields are defined as follows:
fr: Les membres ont les significations suivantes\ :

note: .Bl  -tag -width FTS_DEFAULT type: Plain text
en: One of the following flags describing the returned I<FTSENT> structure and the file it represents.  With the exception of directories without errors (B<FTS_D>), all of these entries are terminal, that is, they will not be revisited, nor will any of their descendants be visited.
fr: L'un des attributs suivants, décrivant la structure I<FTSENT> et le fichier qu'elle représente. Toutes ces entrées sont terminales (sauf les répertoires B<FTS_D> ne présentant pas d'erreur), ce qui signifie qu'elle ne seront visitées qu'une seule fois, et que leur éventuels descendants (cas des répertoires en erreur) ne seront pas visités.

note: type: Plain text
en: A directory being visited in preorder.
fr: Un répertoire visité en phase «\ preorder\ ».

note: type: Plain text
en: A directory that causes a cycle in the tree.  (The I<fts_cycle> field of the I<FTSENT> structure will be filled in as well.)
fr: Un répertoire introduisant une boucle dans l'arborescence. Le champ I<fts_cycle> de la structure I<FTSENT> sera également remplis.

note: type: Plain text
en: Any I<FTSENT> structure that represents a file type not explicitly described by one of the other I<fts_info> values.
fr: Toute structure I<FTSENT> représentant un type de fichier non décrit explicitement par l'une des autres valeurs de I<fts_info>.

note: type: Plain text
en: A directory which cannot be read.  This is an error return, and the I<fts_errno> field will be set to indicate what caused the error.
fr: Un répertoire ne pouvant être lu. C'est considéré comme une erreur, et le champ I<fts_errno> sera défini avec une valeur décrivant sa cause.

note: type: Plain text
en: A file named "." or ".." which was not specified as a filename to B<fts_open>()  (see B<FTS_SEEDOT>).
fr: Un fichier nommé « . » ou « .. » qui n'a pas été indiqué explicitement comme argument de B<fts_open>() (consultez B<FTS_SEEDOT>).

note: type: Plain text
en: A directory being visited in postorder.  The contents of the I<FTSENT> structure will be unchanged from when it was returned in preorder, that is, with the I<fts_info> field set to B<FTS_D>.
fr: Un répertoire visité en phase «\ postorder\ ». Le contenu de la structure I<FTSENT> ne sera pas différent de ce qu'il était après la phase «\ preorder\ ». C'est-à-dire quand le champ I<fts_info> valait B<FTS_D>.

note: type: Plain text
en: This is an error return, and the I<fts_errno> field will be set to indicate what caused the error.
fr: Il s'agit d'un retour d'erreur, le champ I<fts_errno> étant rempli pour indiquer la cause de l'erreur.

note: type: Plain text
en: A regular file.
fr: Un fichier normal.

note: type: Plain text
en: A file for which no B<stat>(2)  information was available.  The contents of the I<fts_statp> field are undefined.  This is an error return, and the I<fts_errno> field will be set to indicate what caused the error.
fr: Un fichier pour lequel aucune information provenant de B<stat>(2) n'est disponible. Le contenu du champ I<fts_statp> est indéfini. Il s'agit d'un cas d'erreur dont la cause est indiquée dans I<fts_errno>.

note: type: Plain text
en: A file for which no B<stat>(2)  information was requested.  The contents of the I<fts_statp> field are undefined.
fr: Un fichier pour lequel aucune information provenant de B<stat>(2) n'a été demandée. Le contenu du champ I<fts_statp> est indéfini.

note: type: Plain text
en: A symbolic link.
fr: Un lien symbolique.

note: .El type: Plain text
en: A symbolic link with a nonexistent target.  The contents of the I<fts_statp> field reference the file characteristic information for the symbolic link itself.
fr: Un lien symbolique pointant dans le vide. Le contenu du champ I<fts_statp> contient les caractéristiques du lien lui-même.

note: type: Plain text
en: A path for accessing the file from the current directory.
fr: Un chemin permettant d'accéder au fichier depuis le répertoire courant.

note: type: Plain text
en: The path for the file relative to the root of the traversal.  This path contains the path specified to B<fts_open>()  as a prefix.
fr: Le chemin d'accès au fichier à partir du point de départ du parcours. Il contient en préfixe le chemin fourni lors de l'invocation de B<fts_open>().

note: type: Plain text
en: The length of the string referenced by I<fts_path>.
fr: La longueur de la chaîne pointée par I<fts_path>.

note: type: Plain text
en: The name of the file.
fr: Le nom du fichier.

note: type: Plain text
en: The length of the string referenced by I<fts_name>.
fr: La longueur de la chaîne pointée par I<fts_name>.

note: type: Plain text
en: The depth of the traversal, numbered from -1 to N, where this file was found.  The I<FTSENT> structure representing the parent of the starting point (or root)  of the traversal is numbered -1, and the I<FTSENT> structure for the root itself is numbered 0.
fr: La profondeur où le fichier a été trouvé dans l'arborescence, numérotée de -1 à N. La structure I<FTSENT> représentant le parent du point de départ est numérotée -1. La structure I<FTSENT> représentant la racine de départ elle-même est numérotée 0.

note: type: Plain text
en: Upon return of a I<FTSENT> structure from the B<fts_children>()  or B<fts_read>()  functions, with its I<fts_info> field set to B<FTS_DNR>, B<FTS_ERR> or B<FTS_NS>, the I<fts_errno> field contains the value of the external variable I<errno> specifying the cause of the error.  Otherwise, the contents of the I<fts_errno> field are undefined.
fr: Dans une structure I<FTSENT> renvoyée par un appel B<fts_children>() ou B<fts_read>(), dont le champ I<fts_info> contient B<FTS_DNR>, B<FTS_ERR> ou B<FTS_NS>, le champ I<fts_errno> est défini avec la valeur de la variable externe I<errno> indiquant la cause de l'erreur. Dans les autres cas, le contenu du champ I<fts_errno> est indéfini.

note: type: Plain text
en: This field is provided for the use of the application program and is not modified by the fts functions.  It is initialized to 0.
fr: Ce champ est mis à la disposition des programmes applicatifs, et n'est modifié par aucune fonction de la famille fts. Il est toutefois initialisé à zéro.

note: type: Plain text
en: This field is provided for the use of the application program and is not modified by the fts functions.  It is initialized to NULL.
fr: Ce champ est mis à la disposition des programmes applicatifs, et n'est modifié par aucune fonction de la famille fts. Il est toutefois initialisé à NULL.

note: type: Plain text
en: A pointer to the I<FTSENT> structure referencing the file in the hierarchy immediately above the current file, that is, the directory of which this file is a member.  A parent structure for the initial entry point is provided as well, however, only the I<fts_level>, I<fts_number> and I<fts_pointer> fields are guaranteed to be initialized.
fr: Un pointeur sur la structure I<FTSENT> référençant le fichier dans la hiérarchie immédiatement au dessus du fichier en cours, c'est-à-dire le répertoire auquel il appartient. Une structure parente pour le point d'entrée initial est également fournie, mais seuls ses membres I<fts_level>, I<fts_number> et I<fts_pointer> sont garantis d'être initialisés.

note: type: Plain text
en: Upon return from the B<fts_children>()  function, the I<fts_link> field points to the next structure in the NULL-terminated linked list of directory members.  Otherwise, the contents of the I<fts_link> field are undefined.
fr: Au retour de la fonction B<fts_children>(), le champ I<fts_link> pointe sur la structure suivante dans la liste chaînée des membres du répertoires, liste terminée par un NULL. Dans les autres situations, le contenu du champ I<fts_link> est indéterminé.

note: type: Plain text
en: If a directory causes a cycle in the hierarchy (see B<FTS_DC>), either because of a hard link between two directories, or a symbolic link pointing to a directory, the I<fts_cycle> field of the structure will point to the I<FTSENT> structure in the hierarchy that references the same file as the current I<FTSENT> structure.  Otherwise, the contents of the I<fts_cycle> field are undefined.
fr: Si un répertoire introduit une boucle dans la hiérarchie (consultez B<FTS_DC>),soit à cause d'un lien physique entre deux répertoires, soit à cause d'un lien symbolique pointant vers un répertoire, le champ I<fts_cycle> pointera vers la structure I<FTSENT> de la hiérarchie qui référence le même fichier que celui représenté par la structure I<FTSENT>. Sinon, le contenu du champ I<fts_cycle> est indéfini.

note: .El type: Plain text
en: A pointer to B<stat>(2)  information for the file.
fr: Un pointeur vers les informations fournies par B<stat>(2).

note: type: Plain text
en: A single buffer is used for all of the paths of all of the files in the file hierarchy.  Therefore, the I<fts_path> and I<fts_accpath> fields are guaranteed to be null-terminated I<only> for the file most recently returned by B<fts_read>().  To use these fields to reference any files represented by other I<FTSENT> structures will require that the path buffer be modified using the information contained in that I<FTSENT> structure's I<fts_pathlen> field.  Any such modifications should be undone before further calls to B<fts_read>()  are attempted.  The I<fts_name> field is always null-terminated.
fr: Un tampon unique est utilisé pour tous les chemins d'accès de tous les fichiers de la hiérarchie. Ainsi, les champs I<fts_path> et I<fts_accpath> sont assurés d'être terminés par un caractère nul I<seulement> pour le fichier renvoyé le plus récemment par B<fts_read>(). Pour utiliser ces champs pour référencer un fichier représenté par une autre structure I<FTSENT>, il faut que le chemin du tampon soit modifié avec l'information contenu dans le champ I<fts_pathlen> de cette structure I<FTSENT>. Tout autre modification devra être défaite avant que d'autres appels à B<fts_read>() ne soient tentés. Le champ I<fts_name> est toujours terminé par un caractère nul.

note: type: Plain text
en: The B<fts_open>()  function takes a pointer to an array of character pointers naming one or more paths which make up a logical file hierarchy to be traversed.  The array must be terminated by a null pointer.
fr: La fonction B<fts_open>() reçoit un pointeur vers une table de chaînes de caractères représentant un ou plusieurs chemins décrivant la hiérarchie de fichiers à traverser. Cette table doit se terminer par un pointeur NULL.

note: .Bl -tag -width "FTS_PHYSICAL" type: Plain text
en: There are a number of options, at least one of which (either B<FTS_LOGICAL> or B<FTS_PHYSICAL>)  must be specified.  The options are selected by ORing the following values:
fr: Il existe un certain nombre d'options, dont au moins une est obligatoire (soit B<FTS_LOGICAL> ou soit B<FTS_PHYSICAL>). Les options sont sélectionnées par un I<ou logique> entre les valeurs suivantes\ :

note: type: Plain text
en: This option causes any symbolic link specified as a root path to be followed immediately whether or not B<FTS_LOGICAL> is also specified.
fr: Tout lien symbolique indiqué comme racine du parcours sera immédiatement suivi (déréférencé), que l'option B<FTS_LOGICAL> soit indiquée ou non.

note: type: Plain text
en: This option causes the fts routines to return I<FTSENT> structures for the targets of symbolic links instead of the symbolic links themselves.  If this option is set, the only symbolic links for which I<FTSENT> structures are returned to the application are those referencing nonexistent files.  Either B<FTS_LOGICAL> or B<FTS_PHYSICAL> I<must> be provided to the B<fts_open>()  function.
fr: Cette option indique aux fonctions fts de renvoyer des structures I<FTSENT>  concernant les cibles des liens symboliques plutôt que les liens eux-mêmes. Avec cette option, les seuls liens symboliques pour lesquels une structure I<FTSENT> est renvoyée sont ceux pointant dans le vide. Il I<faut> préciser soit B<FTS_LOGICAL>, soit B<FTS_PHYSICAL> à la fonction B<fts_open>().

note: type: Plain text
en: As a performance optimization, the fts functions change directories as they walk the file hierarchy.  This has the side-effect that an application cannot rely on being in any particular directory during the traversal.  The B<FTS_NOCHDIR> option turns off this optimization, and the fts functions will not change the current directory.  Note that applications should not themselves change their current directory and try to access files unless B<FTS_NOCHDIR> is specified and absolute pathnames were provided as arguments to B<fts_open>().
fr: Pour optimiser les performances, les fonctions fts changent de répertoire au cours de la traversée de la hiérarchie de fichiers. En contrepartie, l'application ne peut pas savoir à l'avance où elle se trouve durant la traversée. L'option B<FTS_NOCHDIR> supprime cette optimisation et les fonctions fts ne changeront pas de répertoire de travail. Remarquez que les applications ne doivent pas modifier elles-même le répertoire de travail et essayer d'accéder aux fichiers sans que l'option B<FTS_NOCHDIR> ne soit indiquée et que des chemins d'accès absolus soient transmis à B<fts_open>().

note: type: Plain text
en: By default, returned I<FTSENT> structures reference file characteristic information (the I<statp> field) for each file visited.  This option relaxes that requirement as a performance optimization, allowing the fts functions to set the I<fts_info> field to B<FTS_NSOK> and leave the contents of the I<statp> field undefined.
fr: Par défaut, les structures I<FTSENT> renvoyées contiennent les caractéristiques (voir le champ I<statp>) de chaque fichier visité. Cette option relâche cette contrainte pour optimiser les performances, en autorisant les fonctions fts à remplir le champ I<fts_info> avec B<FTS_NSOK> et laisser le contenu du membre I<statp> indéfini.

note: type: Plain text
en: This option causes the fts routines to return I<FTSENT> structures for symbolic links themselves instead of the target files they point to.  If this option is set, I<FTSENT> structures for all symbolic links in the hierarchy are returned to the application.  Either B<FTS_LOGICAL> or B<FTS_PHYSICAL> I<must> be provided to the B<fts_open>()  function.
fr: Avec cette option, les routines fts renvoient des structures I<FTSENT> pour les liens symboliques eux-mêmes et non pas les fichiers qu'ils pointent. Si cette option est définie, des structures I<FTSENT> pour tous les liens symboliques de la hiérarchie sont renvoyées à l'application. Soit B<FTS_LOGICAL> ou soit B<FTS_PHYSICAL> I<doit> être fourni à la fonction B<fts_open>().

note: type: Plain text
en: By default, unless they are specified as path arguments to B<fts_open>(), any files named "." or ".." encountered in the file hierarchy are ignored.  This option causes the fts routines to return I<FTSENT> structures for them.
fr: Par défaut, à moins d'être fournis explicitement en argument à B<fts_open>() ,tout fichier nommé « . » ou « .. » rencontré dans la hiérarchie est ignoré. Avec cette option, les routines fts renvoient des structures I<FTSENT> pour ces fichiers.

note: .El type: Plain text
en: This option prevents fts from descending into directories that have a different device number than the file from which the descent began.
fr: Cette option empêche fts de descendre dans les répertoires se trouvant sur un périphérique différent de celui dans lequel le parcours a commencé.

note: type: Plain text
en: The argument B<compar>()  specifies a user-defined function which may be used to order the traversal of the hierarchy.  It takes two pointers to pointers to I<FTSENT> structures as arguments and should return a negative value, zero, or a positive value to indicate if the file referenced by its first argument comes before, in any order with respect to, or after, the file referenced by its second argument.  The I<fts_accpath>, I<fts_path> and I<fts_pathlen> fields of the I<FTSENT> structures may I<never> be used in this comparison.  If the I<fts_info> field is set to B<FTS_NS> or B<FTS_NSOK>, the I<fts_statp> field may not either.  If the B<compar>()  argument is NULL, the directory traversal order is in the order listed in I<path_argv> for the root paths, and in the order listed in the directory for everything else.
fr: L'argument B<compar>() indique une fonction définie par l'utilisateur pour ordonner la traversée de la hiérarchie. Elle prend en argument deux pointeurs sur des pointeurs sur des structures I<FTSENT>, et doit renvoyer une valeur négative, nulle, ou positive pour indiquer que le fichier représenté par le premier argument doit venir avant, à n'importe quel moment, ou après le fichier référencé par le second argument. Les champs I<fts_accpath>, I<fts_path> et I<fts_pathlen> des structures I<FTSENT> ne doivent I<jamais> être utilisés dans cette comparaison. Si le champ I<fts_info> contient B<FTS_NS> ou B<FTS_NSOK>, le membre I<fts_statp> ne doit pas être utilisé non plus. Si l'argument B<compar>() est NULL, l'ordre de traversée des répertoires est celui de l'argument I<path_argv> pour les racines, et l'ordre interne des répertoires pour le reste.

note: type: Plain text
en: The B<fts_read>()  function returns a pointer to an I<FTSENT> structure describing a file in the hierarchy.  Directories (that are readable and do not cause cycles) are visited at least twice, once in preorder and once in postorder.  All other files are visited at least once.  (Hard links between directories that do not cause cycles or symbolic links to symbolic links may cause files to be visited more than once, or directories more than twice.)
fr: La fonction B<fts_read>() renvoie un pointeur sur une structure I<FTSENT> décrivant un fichier de la hiérarchie. Les répertoires lisibles et ne causant pas de boucles sont parcourus au moins deux fois, une fois en phase «\ preorder\ », et une en phase «\ postorder\ ». Les autres fichiers ne sont examinés qu'une seule fois. Les liens physiques entre répertoires qui ne causent pas de boucles, ou les liens symboliques vers des liens symboliques peuvent entraîner des fichiers visités plus d'une fois, ou des répertoires plus de deux fois.

note: type: Plain text
en: If all the members of the hierarchy have been returned, B<fts_read>()  returns NULL and sets the external variable I<errno> to 0.  If an error unrelated to a file in the hierarchy occurs, B<fts_read>()  returns NULL and sets I<errno> appropriately.  If an error related to a returned file occurs, a pointer to an I<FTSENT> structure is returned, and I<errno> may or may not have been set (see I<fts_info>).
fr: Si tous les membres de la hiérarchie ont été examinés, B<fts_read>() renvoie NULL et définit la variable externe I<errno> avec un 0. Si une erreur sans rapport avec un fichier particulier se produit, B<fts_read>() renvoie NULL et définit I<errno> en conséquence. Si une erreur concernant le fichier en cours se produit, un pointeur sur une structure I<FTSENT> est renvoyé, et I<errno> peut ou non être défini (consultez I<fts_info>).

note: type: Plain text
en: The I<FTSENT> structures returned by B<fts_read>()  may be overwritten after a call to B<fts_close>()  on the same file hierarchy stream, or, after a call to B<fts_read>()  on the same file hierarchy stream unless they represent a file of type directory, in which case they will not be overwritten until after a call to B<fts_read>()  after the I<FTSENT> structure has been returned by the function B<fts_read>()  in postorder.
fr: Les structures I<FTSENT> renvoyées par B<fts_read>() peuvent être écrasées après un appel à B<fts_close>() sur le même descripteur de hiérarchie ou après un appel à B<fts_read>() sur la même hiérarchie, sauf si elles représentent un répertoire, auquel cas elles ne seront pas écrasées avant l'appel B<fts_read>() renvoyant la structure I<FTSENT> du répertoire en phase «\ postorder\ ».

note: type: Plain text
en: The B<fts_children>()  function returns a pointer to an I<FTSENT> structure describing the first entry in a NULL-terminated linked list of the files in the directory represented by the I<FTSENT> structure most recently returned by B<fts_read>().  The list is linked through the I<fts_link> field of the I<FTSENT> structure, and is ordered by the user-specified comparison function, if any.  Repeated calls to B<fts_children>()  will re-create this linked list.
fr: La fonction B<fts_children>() renvoie un pointeur sur une structure I<FTSENT> décrivant la première entrée d'une liste chaînée terminée par un NULL et représentant les fichiers se trouvant dans le répertoire indiqué par la dernière structure I<FTSENT> renvoyée par un appel B<fts_read>(). La liste est chaînée par le biais du membre I<fts_link> de la structure I<FTSENT>, et est ordonnée suivant la routine de comparaison fournie par l'utilisateur, si elle existe. Des appels répétés à B<fts_children>() recréeront la liste chaînée.

note: type: Plain text
en: As a special case, if B<fts_read>()  has not yet been called for a hierarchy, B<fts_children>()  will return a pointer to the files in the logical directory specified to B<fts_open>(), that is, the arguments specified to B<fts_open>().  Otherwise, if the I<FTSENT> structure most recently returned by B<fts_read>()  is not a directory being visited in preorder, or the directory does not contain any files, B<fts_children>()  returns NULL and sets I<errno> to zero.  If an error occurs, B<fts_children>()  returns NULL and sets I<errno> appropriately.
fr: Un cas particulier se présente si B<fts_read>() n'a pas encore été appelée pour une hiérarchie. Alors, B<fts_children>() renverra un pointeur sur les fichiers du répertoire logique indiqué dans B<fts_open>(), c'est-à-dire les arguments fournis à B<fts_open>(). Sinon, si la structure I<FTSENT> la plus récemment renvoyée par B<fts_read>() n'est pas un répertoire visité en phase «\ preorder\ », ou si le répertoire ne contient aucun fichier, B<fts_children>() renvoie NULL et met la variable externe I<errno> à zéro. Si une erreur se produit, B<fts_children>() renvoie NULL et définit I<errno> en conséquence.

note: type: Plain text
en: The I<FTSENT> structures returned by B<fts_children>()  may be overwritten after a call to B<fts_children>(), B<fts_close>()  or B<fts_read>()  on the same file hierarchy stream.
fr: Les structures  I<FTSENT> renvoyées par B<fts_children>()  peuvent être écrasées après un appel à B<fts_children>(), B<fts_close>() ou B<fts_read>() sur la même hiérarchie de fichiers.

note: .Bl -tag -width FTS_NAMEONLY type: Plain text
en: I<Option> may be set to the following value:
fr: I<Option> peut contenir l'une des valeurs suivantes\ :

note: .El type: Plain text
en: Only the names of the files are needed.  The contents of all the fields in the returned linked list of structures are undefined with the exception of the I<fts_name> and I<fts_namelen> fields.
fr: Seuls les noms des fichiers sont nécessaires. Le contenu des membres des structures de la liste chaînée est indéfini sauf pour I<fts_name> et I<fts_namelen>.

note: .Bl -tag -width FTS_PHYSICAL type: Plain text
en: The function B<fts_set>()  allows the user application to determine further processing for the file I<f> of the stream I<ftsp>.  The B<fts_set>()  function returns 0 on success, and -1 if an error occurs.  I<Option> must be set to one of the following values:
fr: La fonction B<fts_set>() permet à l'application de paramétrer le traitement à venir du fichier I<f> sur la hiérarchie I<ftsp>. La fonction B<fts_set>() renvoie 0 si elle réussit, et -1 si une erreur se produit. I<Option> doit contenir l'une des valeurs suivantes\ :

note: type: Plain text
en: Revisit the file; any file type may be revisited.  The next call to B<fts_read>()  will return the referenced file.  The I<fts_stat> and I<fts_info> fields of the structure will be reinitialized at that time, but no other fields will have been changed.  This option is meaningful only for the most recently returned file from B<fts_read>().  Normal use is for postorder directory visits, where it causes the directory to be revisited (in both preorder and postorder) as well as all of its descendants.
fr: Revisiter à nouveau le fichier. N'importe quel type de fichier peut être revisité. L'appel suivant de B<fts_read>() renverra le fichier indiqué. Les membres I<fts_stat> et I<fts_info> de la structure seront réinitialisés à ce moment, mais aucun autre champ ne sera modifié. Cette option n'a de sens que pour le dernier fichier renvoyé par B<fts_read>(). L'utilisation habituelle de cette possibilité concerne les répertoires en phase «\ postorder\ », qui sont alors réexaminés (aussi bien en phase «\ preorder\ » que «\ postorder\ »), ainsi que leurs descendants.

note: type: Plain text
en: The referenced file must be a symbolic link.  If the referenced file is the one most recently returned by B<fts_read>(), the next call to B<fts_read>()  returns the file with the I<fts_info> and I<fts_statp> fields reinitialized to reflect the target of the symbolic link instead of the symbolic link itself.  If the file is one of those most recently returned by B<fts_children>(), the I<fts_info> and I<fts_statp> fields of the structure, when returned by B<fts_read>(), will reflect the target of the symbolic link instead of the symbolic link itself.  In either case, if the target of the symbolic link does not exist, the fields of the returned structure will be unchanged and the I<fts_info> field will be set to B<FTS_SLNONE>.
fr: Le fichier référencé doit être un lien symbolique. Si ce fichier est le dernier renvoyé par B<fts_read>(), alors l'appel suivant de B<fts_read>() renverra le fichier, avec les champs I<fts_info> et I<fts_statp> réinitialisés pour représenter la cible du lien symbolique plutôt que le lien lui-même. Si le fichier est le dernier renvoyé par B<fts_children>(), alors les membres I<fts_info> et I<fts_statp> de la structure, lorsqu'elle sera renvoyée par B<fts_read>(), représenteront la cible du lien symbolique plutôt que le lien lui-même. Dans tous les cas, si la cible du lien symbolique n'existe pas, les membres de la structure ne seront pas modifiés, et le champ I<fts_info> contiendra B<FTS_SLNONE>.

note: type: Plain text
en: If the target of the link is a directory, the preorder return, followed by the return of all of its descendants, followed by a postorder return, is done.
fr: Si la cible du lien est un répertoire, il y aura un retour «\ preorder\ », suivi d'un retour pour chaque descendant, suivi d'un retour «\ postorder\ ».

note: .El type: Plain text
en: No descendants of this file are visited.  The file may be one of those most recently returned by either B<fts_children>()  or B<fts_read>().
fr: Aucun descendant de ce fichier ne sera visité. Le fichier doit être le dernier renvoyé par B<fts_children>() ou B<fts_read>().

note: type: Plain text
en: The B<fts_close>()  function closes a file hierarchy stream I<ftsp> and restores the current directory to the directory from which B<fts_open>()  was called to open I<ftsp>.  The B<fts_close>()  function returns 0 on success, and -1 if an error occurs.
fr: La fonction B<fts_close>() ferme un descripteur I<ftsp> de hiérarchie de fichier, et restitue le répertoire de travail qui était en vigueur lors de l'appel B<fts_open>() qui avait permit d'ouvrir I<ftsp>. La fonction B<fts_close>() renvoie 0 si elle réussit, et -1 en cas d'erreur.

note: type: SH
en: ERRORS
fr: ERREURS

note: type: Plain text
en: The function B<fts_open>()  may fail and set I<errno> for any of the errors specified for B<open>(2)  and B<malloc>(3).
fr: La fonction B<fts_open>() peut échouer, et mettre dans I<errno> l'une des erreurs indiquées pour les fonctions B<open>(2) et B<malloc>(3).

note: type: Plain text
en: The function B<fts_close>()  may fail and set I<errno> for any of the errors specified for B<chdir>(2)  and B<close>(2).
fr: La fonction B<fts_close>() peut échouer, et mettre dans I<errno> l'une des erreurs indiquées pour les fonctions B<chdir>(2) et B<close>(2).

note: type: Plain text
en: The functions B<fts_read>()  and B<fts_children>()  may fail and set I<errno> for any of the errors specified for B<chdir>(2), B<malloc>(3), B<opendir>(3), B<readdir>(3)  and B<stat>(2).
fr: Les fonctions B<fts_read>() et B<fts_children>() peuvent échouer, et mettre dans I<errno> l'une des erreurs indiquées pour les fonctions B<chdir>(2), B<malloc>(3), B<opendir>(3), B<readdir>(3) et B<stat>(2).

note: type: Plain text
en: In addition, B<fts_children>(), B<fts_open>()  and B<fts_set>()  may fail and set I<errno> as follows:
fr: De plus B<fts_children>(), B<fts_open>() et B<fts_set>() peuvent échouer, et mettre dans I<errno> l'une des erreurs suivantes\ :

note: type: Plain text
en: The options were invalid.
fr: Les options ne sont pas valables.

note: type: Plain text
en: These functions are available in Linux since glibc2.
fr: Ces fonctions sont disponibles sous Linux depuis la glibc2.

note: type: SH
en: CONFORMING TO
fr: CONFORMITÉ

note: type: SH
en: BUGS
fr: BOGUES

note: https://sourceware.org/bugzilla/show_bug.cgi?id=15838 https://sourceware.org/bugzilla/show_bug.cgi?id=11460 The following statement is years old, and seems no closer to being true -- mtk The .I fts utility is expected to be included in a future POSIX.1 revision. type: Plain text
en: All of the APIs described in this man page are not safe when compiling a program using the LFS APIs (e.g., when compiling with I<-D_FILE_OFFSET_BITS=64>).
fr: Aucune des interfaces de programmation décrites dans cette page de manuel n’est sûre lors de la compilation d’un programme utilisant les interfaces de programmation LFS (par exemple lors de la compilation avec I<-D_FILE_OFFSET_BITS=64>).

note: type: TH
en: 2014-01-11
fr: 11 janvier 2014

note: type: Plain text
en: ftw, nftw - file tree walk
fr: ftw, nftw - Parcourir des arborescences de fichiers

note: type: Plain text
en: B<#define _XOPEN_SOURCE 500>   /* See feature_test_macros(7) */
    B<#include E<lt>ftw.hE<gt>>
fr: B<#define _XOPEN_SOURCE 500>   /* Consultez feature_test_macros(7) */
    B<#include E<lt>ftw.hE<gt>>

note: type: Plain text
en: B<ftw>()  walks through the directory tree that is located under the directory I<dirpath>, and calls I<fn>() once for each entry in the tree.  By default, directories are handled before the files and subdirectories they contain (preorder traversal).
fr: La fonction B<ftw>() parcourt une arborescence de fichiers située dans le répertoire I<dirpath> et appelle I<fn>() pour chaque entrée de l'arborescence. Par défaut, les répertoires sont traités avant les fichiers et sous-répertoires qu'ils contiennent.

note: type: Plain text
en: To avoid using up all of the calling process's file descriptors, I<nopenfd> specifies the maximum number of directories that B<ftw>()  will hold open simultaneously.  When the search depth exceeds this, B<ftw>()  will become slower because directories have to be closed and reopened.  B<ftw>()  uses at most one file descriptor for each level in the directory tree.
fr: Afin d'éviter d'utiliser tous les descripteurs de fichier disponibles pour le programme, I<nopenfd> indique le nombre maximal de répertoires que B<ftw>() peut ouvrir de manière simultanée. Lorsque la profondeur de recherche est supérieure à cette valeur, B<ftw>() ralentit car les répertoires doivent être fermés puis réouverts. B<ftw>() utilise au plus un descripteur de fichier pour chaque niveau dans l'arborescence des fichiers.

note: type: Plain text
en: For each entry found in the tree, B<ftw>()  calls I<fn>() with three arguments: I<fpath>, I<sb>, and I<typeflag>.  I<fpath> is the pathname of the entry, and is expressed either as a pathname relative to the calling process's current working directory at the time of the call to B<ftw>(), if I<dirpath> was expressed as a relative pathname, or as an absolute pathname, if I<dirpath> was expressed as an absolute pathname.  I<sb> is a pointer to the I<stat> structure returned by a call to B<stat>(2)  for I<fpath>.  I<typeflag> is an integer that has one of the following values:
fr: Pour chaque entrée trouvée dans l'arbre, B<ftw>() appelle I<fn>() avec trois arguments\ : I<fpath>, I<sb> et I<typeflag>. I<fpath> est le chemin de l'entrée , il est soit défini comme un chemin relatif au répertoire actuel de travail du processus appelant à l'instant de l'appel à B<ftw>() si I<dirpath> est un chemin relatif, ou soit comme un chemin absolu si I<dirpath> est un chemin absolu. I<sb> est un pointeur vers la structure I<stat> renvoyée par un appel à B<stat>(2) pour I<fpath>. I<typeflag> est un entier qui a une des valeurs suivantes\ :

note: type: Plain text
en: I<fpath> is a regular file.
fr: I<fpath> est un fichier régulier.

note: type: Plain text
en: I<fpath> is a directory.
fr: I<fpath> est un répertoire.

note: type: Plain text
en: I<fpath> is a directory which can't be read.
fr: I<fpath> est un répertoire non lisible.

note: type: Plain text
en: The B<stat>(2)  call failed on I<fpath>, which is not a symbolic link.  The probable cause for this is that the caller had read permission on the parent directory, so that the filename I<fpath> could be seen, but did not have execute permission, so that the file could not be reached for B<stat>(2).
fr: L'appel B<stat>(2) a échoué sur I<fpath>, qui n'est pas un lien symbolique. C’est probablement dû au fait que l’appelant avait les droits de lecture dans le répertoire parent, de tel sorte que I<fpath> était visible, mais pas les droits d’exécution, donc le fichier ne pouvait pas être atteint pour B<stat>(2).

note: type: Plain text
en: If I<fpath> is a symbolic link and B<stat>(2)  failed, POSIX.1-2001 states that it is undefined whether B<FTW_NS> or B<FTW_SL> (see below)  is passed in I<typeflag>.
fr: Si I<fpath> est un lien symbolique et que B<stat>(2) échoue, POSIX.1-2001 précise que c'est indéfini si B<FTW_NS> ou B<FTW_SL> sont passés à I<typeflag> (consultez ci-dessous).

note: type: Plain text
en: To stop the tree walk, I<fn>() returns a nonzero value; this value will become the return value of B<ftw>().  As long as I<fn>() returns 0, B<ftw>()  will continue either until it has traversed the entire tree, in which case it will return zero, or until it encounters an error (such as a B<malloc>(3)  failure), in which case it will return -1.
fr: Pour arrêter le parcours des arborescences de fichiers, la fonction I<fn>() renvoie une valeur non nulle, qui deviendra la valeur de retour de B<ftw>(). Tant que I<fn>() renvoie 0, B<ftw>() continuera jusqu'à la fin du parcours de l'arborescence, et dans ce cas renverra zéro, ou jusqu'à ce que une erreur se produise (comme pour B<malloc>(3)) et renverra -1.

note: type: Plain text
en: Because B<ftw>()  uses dynamic data structures, the only safe way to exit out of a tree walk is to return a nonzero value from I<fn>().  To allow a signal to terminate the walk without causing a memory leak, have the handler set a global flag that is checked by I<fn>().  I<Don't> use B<longjmp>(3)  unless the program is going to terminate.
fr: Comme B<ftw>() utilise des structures de données allouées dynamiquement, la seule manière propre de sortir d'un parcours d'arborescence est de renvoyer une valeur non nulle depuis I<fn>(). Pour permettre à un signal de terminer le parcours sans causer de fuite de mémoire, utilisez un «\ handler\ » qui définit un attribut vérifié par I<fn>(). I<N'utilisez pas> B<longjmp>(3) à moins que le programme ne soit prêt à se terminer.

note: type: Plain text
en: The function B<nftw>()  is the same as B<ftw>(), except that it has one additional argument, I<flags>, and calls I<fn>() with one more argument, I<ftwbuf>.
fr: La fonction B<nftw>() fait exactement la même chose que B<ftw>(), sauf qu'elle utilise un argument I<flags> et appelle I<fn>() avec un argument supplémentaire I<ftwbuf>.

note: type: Plain text
en: This I<flags> argument is formed by ORing zero or more of the following flags:
fr: L'argument I<flags> est un OU regroupant zéro ou certains des attributs suivants\ :

note: type: TP
en: B<FTW_ACTIONRETVAL> (since glibc 2.3.3)
fr: B<FTW_ACTIONRETVAL> (depuis la glibc\ 2.3.3)

note: type: Plain text
en: If this glibc-specific flag is set, then B<nftw>()  handles the return value from I<fn>()  differently.  I<fn>()  should return one of the following values:
fr: Si cet attribut, spécifique à la glibc, est positionné, alors B<nftw>() gère la valeur de retour de I<fn>() différemment. I<fn>() devrait renvoyer l'une des valeurs suivantes\ :

note: type: Plain text
en: Instructs B<nftw>()  to continue normally.
fr: B<nftw>() va continuer normalement.

note: If \fBFTW_DEPTH\fP is set, the entry's parent directory is processed next (with \fIflag\fP set to \fBFTW_DP\fP). type: Plain text
en: If I<fn>() returns this value, then siblings of the current entry will be skipped, and processing continues in the parent.
fr: Si I<fn>() renvoie cette valeur, alors les «\ siblings\ » des entrées courantes seront passées, et la procédure continuera avec le parent.

note: type: Plain text
en: If I<fn>() is called with an entry that is a directory (I<typeflag> is B<FTW_D>), this return value will prevent objects within that directory from being passed as arguments to I<fn>().  B<nftw>()  continues processing with the next sibling of the directory.
fr: Si I<fn>() est appelée avec une entrée qui est un répertoire (I<typeflag> vaut B<FTW_D>), cette valeur de retour prévient les objets dans ce répertoire d'être passés comme argument à I<fn>(). B<nftw>() continue avec le «\ sibling\ » suivant du répertoire.

note: type: Plain text
en: Causes B<nftw>()  to return immediately with the return value B<FTW_STOP>.
fr: B<nftw>() quitte immédiatement avec la valeur de retour B<FTW_STOP>.

note: type: Plain text
en: Other return values could be associated with new actions in the future; I<fn>() should not return values other than those listed above.
fr: Les autres valeurs de retour pourront être associées avec une nouvelle action dans le futur\ ; I<fn> ne devrait renvoyer que les valeurs citées ci-dessus.

note: type: Plain text
en: The feature test macro B<_GNU_SOURCE> must be defined (before including I<any> header files)  in order to obtain the definition of B<FTW_ACTIONRETVAL> from I<E<lt>ftw.hE<gt>>.
fr: La macro de test B<_GNU_SOURCE> doit être définie (avant I<toute> inclusion de fichiers d'en-tête) afin d'obtenir la définition de B<FTW_ACTIONRETVAL> depuis I<E<lt>ftw.hE<gt>>.

note: type: Plain text
en: If set, do a B<chdir>(2)  to each directory before handling its contents.  This is useful if the program needs to perform some action in the directory in which I<fpath> resides.
fr: Si défini, faire un B<chdir>(2) avec chaque répertoire avant de traiter son contenu. C'est utile si le programme doit exécuter des actions dans le répertoire où I<fpath> réside.

note: type: Plain text
en: If set, do a post-order traversal, that is, call I<fn>() for the directory itself I<after> handling the contents of the directory and its subdirectories.  (By default, each directory is handled I<before> its contents.)
fr: Si défini, faire une recherche «\ postorder\ »\ ; c'est-à-dire, appeler I<fn>() pour le répertoire lui-même I<après> avoir traité son contenu et celui de ses sous-répertoires (par défaut chaque répertoire est traité I<avant> son contenu).

note: type: Plain text
en: If set, stay within the same filesystem (i.e., do not cross mount points).
fr: Si défini, rester uniquement dans le même système de fichiers (p.\ ex.\ : ne pas parcourir un point de montage).

note: type: Plain text
en: If set, do not follow symbolic links.  (This is what you want.)  If not set, symbolic links are followed, but no file is reported twice.
fr: Si défini, ne pas suivre les liens symboliques (c'est ce que l'on veut). Si non défini, les liens symboliques sont suivis, mais aucun fichier n'est traité plus d'une fois.

note: type: Plain text
en: If B<FTW_PHYS> is not set, but B<FTW_DEPTH> is set, then the function I<fn>()  is never called for a directory that would be a descendant of itself.
fr: Si B<FTW_PHYS> n'est pas défini, mais si B<FTW_DEPTH> l'est, alors la fonction I<fn>() n'est jamais appelée pour un répertoire que l'on retrouve dans ses propres descendants.

note: type: Plain text
en: For each entry in the directory tree, B<nftw>()  calls I<fn>()  with four arguments.  I<fpath> and I<sb> are as for B<ftw>().  I<typeflag> may receive any of the same values as with B<ftw>(), or any of the following values:
fr: Pour chaque entrée de l'arbre du répertoire, B<nftw>() appelle I<fn>() avec quatre arguments\ : I<fpath> et I<sb> sont les mêmes que pour B<ftw>(). I<typeflag> peut prendre l'une des valeurs définies par B<ftw>() ou l'une des valeurs suivantes\ :

note: type: Plain text
en: I<fpath> is a directory, and B<FTW_DEPTH> was specified in I<flags>.  (If B<FTW_DEPTH> was not specified in I<flags>, then directories will always be visited with I<typeflag> set to B<FTW_D>.)  All of the files and subdirectories within I<fpath> have been processed.
fr: I<fpath> est un répertoire, et B<FTW_DEPTH> a été défini dans I<flags>. (Si B<FTW_DEPTH> n’était pas défini dans I<flags>, alors les répertoires seront toujours visités avec I<typeflag> défini à B<FTW_D>.) Tous les fichiers et les sous-répertoires dans I<fpath> ont été traités.

note: To obtain the definition of this constant from .IR <ftw.h> , either .B _BSD_SOURCE must be defined, or .BR _XOPEN_SOURCE must be defined with a value of 500 or more. type: Plain text
en: I<fpath> is a symbolic link, and B<FTW_PHYS> was set in I<flags>.
fr: I<fpath> est un lien symbolique, et B<FTW_PHYS> a été défini dans I<flags>.

note: type: Plain text
en: I<fpath> is a symbolic link pointing to a nonexistent file.  (This occurs only if B<FTW_PHYS> is not set.)
fr: I<fpath> est un lien symbolique pointant nulle part. Cela ne se produit que si B<FTW_PHYS> n'est pas défini.

note: type: Plain text
en: The fourth argument that B<nftw>()  supplies when calling I<fn>()  is a structure of type I<FTW>:
fr: Le quatrième argument qu'utilise B<nftw>() lorsqu'elle appelle I<fn> est une structure du type I<FTW>\ :

note: type: Plain text
en: I<base> is the offset of the filename (i.e., basename component)  in the pathname given in I<fpath>.  I<level> is the depth of I<fpath> in the directory tree, relative to the root of the tree (I<dirpath>, which has depth 0).
fr: I<base> est le décalage du nom de fichier («\ basename\ ») du chemin donné par I<fpath>. I<level> est la profondeur de I<fpath> dans l'arbre des répertoires, relative à la racine de l'arbre (I<dirpath> qui a une profondeur nulle).

note: type: SH
en: RETURN VALUE
fr: VALEUR RENVOYÉE

note: type: Plain text
en: These functions return 0 on success, and -1 if an error occurs.
fr: Ces fonctions renvoie 0 en cas de succès et -1 en cas d'erreur.

note: type: Plain text
en: If I<fn>() returns nonzero, then the tree walk is terminated and the value returned by I<fn>()  is returned as the result of B<ftw>()  or B<nftw>().
fr: Si I<fn>() renvoie une valeur non nulle, alors le parcours de l'arbre se termine et la valeur renvoyée par I<fn>() est renvoyée comme résultat de B<ftw>() ou B<nftw>().

note: type: Plain text
en: If B<nftw>()  is called with the B<FTW_ACTIONRETVAL> flag, then the only nonzero value that should be used by I<fn>()  to terminate the tree walk is B<FTW_STOP>, and that value is returned as the result of B<nftw>().
fr: Si B<nftw>() est appelé avec l’attribut B<FTW_ACTIONRETVAL>, alors la seule valeur non nulle qui pourra être utilisée par I<fn>() pour terminer le parcours de l'arbre est B<FTW_STOP>, et cette valeur est renvoyée comme le résultat de B<nftw>().

note: type: Plain text
en: POSIX.1-2001, SVr4, SUSv1.  POSIX.1-2008 marks B<ftw>()  as obsolete.
fr: POSIX.1-2001, SVr4, SUSv1. POSIX.1-2008 marque B<ftw>() comme étant obsolète.

note: type: Plain text
en: POSIX.1-2001 note that the results are unspecified if I<fn> does not preserve the current working directory.
fr: POSIX.1-2001 indique que les résultats sont imprévisibles si I<fn> ne préserve pas le répertoire de travail actuel.

note: type: Plain text
en: The function B<nftw>()  and the use of B<FTW_SL> with B<ftw>()  were introduced in SUSv1.
fr: La fonction B<nftw>() et l'utilisation de B<FTW_SL>() avec B<ftw>() ont été introduites dans SUSv1.

note: type: Plain text
en: On some systems B<ftw>()  will never use B<FTW_SL>, on other systems B<FTW_SL> occurs only for symbolic links that do not point to an existing file, and again on other systems B<ftw>()  will use B<FTW_SL> for each symbolic link.  For predictable control, use B<nftw>().
fr: Sur certains systèmes, B<ftw>() n'utilise jamais B<FTW_SL>, sur d'autres, B<FTW_SL> ne survient que pour les liens symboliques pointant nulle part, sur d'autres encore, B<ftw>() utilise B<FTW_SL> pour chaque lien symbolique. Pour un fonctionnement prévisible, employez B<nftw>().

note: type: Plain text
en: Under Linux, libc4 and libc5 and glibc 2.0.6 will use B<FTW_F> for all objects (files, symbolic links, FIFOs, etc.)  that can be stat'ed but are not a directory.
fr: Sous Linux, les libc4, libc5 et glibc\ 2.0.6 utilisent B<FTW_F> pour tous les objets (fichier, lien symbolique, fifo, etc.), sauf pour les répertoires, qui peuvent être utilisés par stat.

note: type: Plain text
en: The function B<nftw>()  is available since glibc 2.1.
fr: La fonction B<nftw>() est disponible depuis la glibc\ 2.1.

note: type: Plain text
en: B<FTW_ACTIONRETVAL> is glibc-specific.
fr: B<FTW_ACTIONRETVAL> est spécifique à la glibc.

note: type: SH
en: EXAMPLE
fr: EXEMPLE

note: type: Plain text
en: The following program traverses the directory tree under the path named in its first command-line argument, or under the current directory if no argument is supplied.  It displays various information about each file.  The second command-line argument can be used to specify characters that control the value assigned to the I<flags> argument when calling B<nftw>().
fr: Le programme suivant parcours l'arbre des répertoires du chemin donné en premier argument de la ligne de commande ou du répertoire courant s'il n'est pas indiqué. Il affiche divers informations à propos de chaque fichier. Le second argument de la ligne de commande peut être utilisé pour indiquer les caractères assignés à l'argument I<flags> lors des appels de B<nftw>().

note: type: SS
en: Program source
fr: Source du programme

note: type: TH
en: 2002-02-28
fr: 28 février 2002

note: type: Plain text
en: getfsent, getfsspec, getfsfile, setfsent, endfsent - handle fstab entries
fr: getfsent, getfsspec, getfsfile, setfsent, endfsent - Gérer la table des systèmes de fichiers

note: type: Plain text
en: These functions read from the file I</etc/fstab>.  The I<struct fstab> is defined by:
fr: Ces fonctions lisent depuis le fichier I</etc/fstab>. La structure I<fstab> est définie ainsi\ :

note: type: Plain text
en: struct fstab {
        char       *fs_spec;       /* block device name */
        char       *fs_file;       /* mount point */
        char       *fs_vfstype;    /* file-sysem type */
        char       *fs_mntops;     /* mount options */
        const char *fs_type;       /* rw/rq/ro/sw/xx option */
        int         fs_freq;       /* dump frequency, in days */
        int         fs_passno;     /* pass number on parallel dump */
    };
fr: struct fstab {
         char *fs_spec;          /* nom du périphérique bloc */
         char *fs_file;          /* point de montage */
         char *fs_vfstype;       /* type système de fichiers */
         char *fs_mntops;        /* options de montage */
         const char *fs_type;    /* option rw/rq/ro/sw/xx */
         int fs_freq;            /* période sauvegarde en jours */
         int fs_passno;          /* numéro de passage parallèle */
    };

note: type: Plain text
en: Here the field I<fs_type> contains (on a *BSD system)  one of the five strings "rw", "rq", "ro", "sw", "xx" (read-write, read-write with quota, read-only, swap, ignore).
fr: Ici, le champ I<fs_type> contient (sur un système type BSD)  l'une des cinq chaînes «\ rw\ », «\ rq\ », «\ ro\ », «\ sw\ », «\ xx\ » (read-write, read-write et quota, read-only, swap, ignore).

note: type: Plain text
en: The function B<setfsent>()  opens the file when required and positions it at the first line.
fr: La fonction B<setfsent>() ouvre le fichier au besoin et se positionne sur la première ligne.

note: type: Plain text
en: The function B<getfsent>()  parses the next line from the file.  (After opening it when required.)
fr: La fonction B<getfsent>() examine la ligne suivante du fichier (après ouverture si besoin).

note: type: Plain text
en: The function B<endfsent>()  closes the file when required.
fr: La fonction B<endfsent>() ferme le fichier si nécessaire.

note: type: Plain text
en: The function B<getfsspec>()  searches the file from the start and returns the first entry found for which the I<fs_spec> field matches the I<special_file> argument.
fr: La fonction B<getfsspec>() recherche dans le fichier la première entrée pour laquelle le champ I<fs_spec> correspond à l'argument I<special_file>.

note: type: Plain text
en: The function B<getfsfile>()  searches the file from the start and returns the first entry found for which the I<fs_file> field matches the I<mount_point> argument.
fr: La fonction B<getfsfile>() recherche dans le fichier la première entrée pour laquelle le champ I<fs_file> correspond à l'argument I<mount_point>.

note: .SH HISTORY The .BR getfsent () function appeared in 4.0BSD; the other four functions appeared in 4.3BSD. type: Plain text
en: Upon success, the functions B<getfsent>(), B<getfsfile>(), and B<getfsspec>()  return a pointer to a I<struct fstab>, while B<setfsent>()  returns 1.  Upon failure or end-of-file, these functions return NULL and 0, respectively.
fr: Si elles réussissent, les fonctions B<getfsent>(), B<getfsfile>() et B<getfsspec>() renvoient un pointeur sur une structure I<fstab>, et B<setfsent>() renvoie 1. En cas d'échec ou de fin de fichier, ces fonctions renvoient NULL et 0, respectivement.

note: type: Plain text
en: These functions are not in POSIX.1-2001.  Several operating systems have them, for example, *BSD, SunOS, Digital UNIX, AIX (which also has a B<getfstype>()).  HP-UX has functions of the same names, that however use a I<struct checklist> instead of a I<struct fstab>, and calls these functions obsolete, superseded by B<getmntent>(3).
fr: Ces fonctions ne sont pas dans POSIX.1-2001. Plusieurs systèmes d'exploitation les proposent\ : BSD*, SunOS, Digital UNIX, AIX (qui possède également une fonction B<getfstype>()). HP-UX a des fonctions avec les mêmes noms, mais utilise une structure I<checklist> plutôt que la structure I<fstab>, et ces fonctions sont obsolètes, remplacées par B<getmntent>(3).

note: type: Plain text
en: These functions are not thread-safe.
fr: Ces routines ne sont pas sûres dans un contexte multithread.

note: type: Plain text
en: Since Linux allows mounting a block special device in several places, and since several devices can have the same mount point, where the last device with a given mount point is the interesting one, while B<getfsfile>()  and B<getfsspec>()  only return the first occurrence, these two functions are not suitable for use under Linux.
fr: Comme Linux autorise le montage d'un périphérique bloc en plusieurs endroits, comme plusieurs périphériques peuvent avoir le même point de montage (le dernier est celui qui compte), et comme B<getfsfile>() et B<getfsspec>() ne renvoient que les premières occurrences, ces deux fonctions ne sont pas très utilisables sous Linux.

note: type: TH
en: 2009-09-15
fr: 15 septembre 2009

note: type: Plain text
en: getmntent, setmntent, addmntent, endmntent, hasmntopt, getmntent_r - get filesystem descriptor file entry
fr: getmntent, setmntent, addmntent, endmntent, hasmntopt - Obtenir des descriptions d'un système de fichiers

note: type: Plain text
en: Feature Test Macro Requirements for glibc (see B<feature_test_macros>(7)):
fr: Exigences de macros de test de fonctionnalités pour la glibc (consultez B<feature_test_macros>(7)) :

note: type: Plain text
en: B<getmntent_r>(): _BSD_SOURCE || _SVID_SOURCE
fr: B<getmntent_r>()\ : _BSD_SOURCE || _SVID_SOURCE

note: type: Plain text
en: These routines are used to access the filesystem description file I</etc/fstab> and the mounted filesystem description file I</etc/mtab>.
fr: Ces routines servent à accéder au fichier de description des systèmes de fichiers I</etc/fstab> et aux descriptions des systèmes de fichiers montés I</etc/mtab>.

note: type: Plain text
en: The B<setmntent>()  function opens the filesystem description file I<filename> and returns a file pointer which can be used by B<getmntent>().  The argument I<type> is the type of access required and can take the same values as the I<mode> argument of B<fopen>(3).
fr: La fonction B<setmntent>() ouvre le fichier de description des systèmes de fichiers I<filename> et renvoie un pointeur de fichier utilisable avec B<getmntent>(). L'argument I<type> est le type d'accès demandé, et peut prendre les même valeurs que l'argument I<mode> de B<fopen>(3).

note: type: Plain text
en: The B<getmntent>()  function reads the next line from the filesystem description file I<fp> and returns a pointer to a structure containing the broken out fields from a line in the file.  The pointer points to a static area of memory which is overwritten by subsequent calls to B<getmntent>().
fr: La fonction B<getmntent>() lit la ligne suivante du fichier de description des systèmes de fichiers I<fp> et renvoie un pointeur vers une structure détaillant les champs de cette ligne. Il s'agit d'un pointeur vers une zone de données statiques, qui peut être écrasée par des appels ultérieurs à B<getmntent>().

note: type: Plain text
en: The B<addmntent>()  function adds the I<mntent> structure I<mnt> to the end of the open file I<fp>.
fr: La fonction B<addmntent>() ajoute la structure I<mntent> I<mnt> à la fin du fichier ouvert I<fp>.

note: type: Plain text
en: The B<endmntent>()  function closes the filesystem description file I<fp>.
fr: La fonction B<endmntent>() ferme le fichier de description des systèmes de fichiers I<fp>.

note: type: Plain text
en: The B<hasmntopt>()  function scans the I<mnt_opts> field (see below)  of the I<mntent> structure I<mnt> for a substring that matches I<opt>.  See I<E<lt>mntent.hE<gt>> and B<mount>(8)  for valid mount options.
fr: La fonction B<hasmntopt>() parcourt le champ I<mnt_opts> (consultez plus bas) de la structure I<mntent> I<mnt>, à la recherche d'une chaîne correspondant à I<opt>. Consultez I<E<lt>mntent.hE<gt>> et B<mount>(8) pour les options de montage.

note: type: Plain text
en: The reentrant B<getmntent_r>()  function is similar to B<getmntent>(), but stores the I<struct mount> in the provided I<*mntbuf> and stores the strings pointed to by the entries in that struct in the provided array I<buf> of size I<buflen>.
fr: La fonction réentrante B<getmntent_r>() est similaire à B<getmntent>(), mais enregistre la structure I<mount> dans le I<*mntbuf> fourni et enregistre les chaînes pointées par les entrées de cette structure dans le tampon I<buf> fourni, de taille I<buflen>.

note: type: Plain text
en: The I<mntent> structure is defined in I<E<lt>mntent.hE<gt>> as follows:
fr: La structure I<mntent> est définie dans I<E<lt>mntent.hE<gt>> ainsi\ :

note: type: Plain text
en: struct mntent {
        char *mnt_fsname;   /* name of mounted filesystem */
        char *mnt_dir;      /* filesystem path prefix */
        char *mnt_type;     /* mount type (see mntent.h) */
        char *mnt_opts;     /* mount options (see mntent.h) */
        int   mnt_freq;     /* dump frequency in days */
        int   mnt_passno;   /* pass number on parallel fsck */
    };
fr: struct mntent {
        char *mnt_fsname;   /* Nom du système de fichiers monté */
        char *mnt_dir;      /* Chemin d'accès au système de fichiers */
        char *mnt_type;     /* Type de montage (voir mntent.h) */
        char *mnt_opts;     /* Options de montage (voir mntent.h) */
        int   mnt_freq;     /* Fréquence de sauvegarde (en jour) */
        int   mnt_passno;   /* Ordre de passage dans fsck */
    };

note: type: Plain text
en: Since fields in the mtab and fstab files are separated by whitespace, octal escapes are used to represent the four characters space (\e040), tab (\e011), newline (\e012) and backslash (\e134) in those files when they occur in one of the four strings in a I<mntent> structure.  The routines B<addmntent>()  and B<getmntent>()  will convert from string representation to escaped representation and back.
fr: Depuis que les champs dans les fichiers mtab et fstab sont séparés par des espaces, les échappements en valeur octale sont utilisés pour représentés les quatre caractères espace (\e040), tabulation (\e011), nouvelle ligne (\e012) et barre oblique inverse (\e134) dans ces fichiers lorsqu'ils apparaissent dans l'une des quatre chaînes d'une structure I<mntent>. Les routines B<addmntent>() et B<getmntent>() convertiront la représentation des chaînes en représentations échappées et vice-versa.

note: type: Plain text
en: The B<getmntent>()  and B<getmntent_r>()  functions return a pointer to the I<mntent> structure or NULL on failure.
fr: Les fonctions B<getmntent>() et B<getmntent_r>() renvoient un pointeur sur la structure I<mntent>, ou NULL en cas d'échec.

note: type: Plain text
en: The B<addmntent>()  function returns 0 on success and 1 on failure.
fr: La fonction B<addmntent>() renvoie 0 si elle réussit, et 1 si elle échoue.

note: type: Plain text
en: The B<endmntent>()  function always returns 1.
fr: La fonction B<endmntent>() renvoie toujours 1.

note: type: Plain text
en: The B<hasmntopt>()  function returns the address of the substring if a match is found and NULL otherwise.
fr: La fonction B<hasmntopt>() renvoie l'adresse de la sous-chaîne si une correspondance est trouvée, ou NULL sinon.

note: type: SH
en: FILES
fr: FICHIERS

note: type: Plain text
en: /etc/fstab          filesystem description file
    /etc/mtab           mounted filesystem description file
fr: /etc/fstab      Description des systèmes de fichiers
    /etc/mtab       Description des systèmes de fichiers montés

note: type: Plain text
en: The nonreentrant functions are from SunOS 4.1.3.  A routine B<getmntent_r>()  was introduced in HP-UX 10, but it returns an int.  The prototype shown above is glibc-only.
fr: Les fonctions non réentrantes viennent de SunOS\ 4.1.3. Une routine B<getmntent_r>() a été introduite dans HP-UX\ 10, mais elle renvoie un entier. Le prototype ci-dessus ne concerne que la glibc.

note: type: Plain text
en: System V also has a B<getmntent>()  function but the calling sequence differs, and the returned structure is different.  Under System V I</etc/mnttab> is used.  4.4BSD and Digital UNIX have a routine B<getmntinfo>(), a wrapper around the system call B<getfsstat>().
fr: System V a aussi une fonction B<getmntent>() mais l'appel est différent, ainsi que la structure renvoyée. Sous System V, le fichier I</etc/mnttab> est employé. BSD\ 4.4 et Digital UNIX ont une routine B<getmntinfo>(), qui sert à invoquer l'appel système B<getfsstat>().

note: type: TH
en: 2014-04-06
fr: 6 avril 2014

note: type: Plain text
en: getxattr, lgetxattr, fgetxattr - retrieve an extended attribute value
fr: getxattr, lgetxattr, fgetxattr - Lire la valeur d'un attribut étendu

note: type: Plain text
en: B<ssize_t getxattr(const char\ *>I<path>B<, const char\ *>I<name>B<,>
    B<                 void\ *>I<value>B<, size_t >I<size>B<);>
    B<ssize_t lgetxattr(const char\ *>I<path>B<, const char\ *>I<name>B<,>
    B<                 void\ *>I<value>B<, size_t >I<size>B<);>
    B<ssize_t fgetxattr(int >I<fd>B<, const char\ *>I<name>B<,>
    B<                 void\ *>I<value>B<, size_t >I<size>B<);>
fr: B<ssize_t getxattr (const char\ *>I<chemin>B<, const char\ *>I<nom>B<,>
    B<                  void\ *>I<valeur>B<, size_t >I<taille>B<);>
    B<ssize_t lgetxattr (const char\ *>I<chemin>B<, const char\ *>I<nom>B<,>
    B<                   void\ *>I<valeur>B<, size_t >I<taille>B<);>
    B<ssize_t fgetxattr (int >I<descripteur>B<, const char\ *>I<nom>B<,>
    B<                   void\ *>I<valeur>B<, size_t >I<taille>B<);>

note: type: Plain text
en: Extended attributes are I<name>:I<value> pairs associated with inodes (files, directories, symbolic links, etc.).  They are extensions to the normal attributes which are associated with all inodes in the system (i.e., the B<stat>(2)  data).  A complete overview of extended attributes concepts can be found in B<attr>(5).
fr: Les attributs étendus sont des paires I<nom>:I<valeur> associées aux inœuds (fichiers, répertoires, liens symboliques, etc.). Ce sont des extensions des attributs normaux qui sont associés avec tous les inœuds du système (les informations renvoyées par B<stat>(2). Une description complète des concepts d'attributs étendus est disponible dans B<attr>(5).

note: type: Plain text
en: B<getxattr>()  retrieves the I<value> of the extended attribute identified by I<name> and associated with the given I<path> in the filesystem.  The length of the attribute I<value> is returned.
fr: B<getxattr>()  récupère la I<valeur> de l'attribut étendu identifié par le I<nom> et associé au I<chemin> donné dans le système de fichiers. La longueur de la I<valeur> est renvoyée.

note: type: Plain text
en: B<lgetxattr>()  is identical to B<getxattr>(), except in the case of a symbolic link, where the link itself is interrogated, not the file that it refers to.
fr: B<lgetxattr>()  est identique à B<getxattr>(), sauf dans le cas d'un lien symbolique, où il interroge le lien lui-même et non le fichier qu'il vise.

note: type: Plain text
en: B<fgetxattr>()  is identical to B<getxattr>(), only the open file referred to by I<fd> (as returned by B<open>(2))  is interrogated in place of I<path>.
fr: B<fgetxattr>()  est identique à B<getxattr>(), seulement c'est le fichier ouvert indiqué par le I<descripteur> (fourni par B<open>(2))  qui est interrogé à la place du I<chemin>.

note: type: Plain text
en: An extended attribute I<name> is a simple null-terminated string.  The name includes a namespace prefix; there may be several, disjoint namespaces associated with an individual inode.  The value of an extended attribute is a chunk of arbitrary textual or binary data of specified length.
fr: Le I<nom> d'un attribut étendu est une simple chaîne terminée par un octet nul. Le nom inclut un préfixe d'espace de noms - il peut y avoir plusieurs espaces de noms disjoints associés avec un inœud donné. La valeur d'un attribut étendu est un bloc de données littérales ou binaires d'une longueur donnée.

note: type: Plain text
en: An empty buffer of I<size> zero can be passed into these calls to return the current size of the named extended attribute, which can be used to estimate the size of a buffer which is sufficiently large to hold the value associated with the extended attribute.
fr: Un tampon vide, de I<taille> nulle peut être transmis à ses appels, pour qu'ils renvoient la taille actuelle de l'attribut étendu indiqué, ce qui permet d'estimer la taille du tampon nécessaire pour contenir la valeur associée à l'attribut étendu.

note: type: Plain text
en: The interface is designed to allow guessing of initial buffer sizes, and to enlarge buffers when the return value indicates that the buffer provided was too small.
fr: L'interface est conçue pour permettre de supposer une taille de tampon initiale et de l'agrandir si la valeur renvoyée indique qu'il est trop petit.

note: type: Plain text
en: On success, a nonnegative number is returned indicating the size of the extended attribute value.  On failure, -1 is returned and I<errno> is set appropriately.
fr: S'ils réussissent, ces appels renvoient un nombre positif correspondant à la taille de la valeur de l'attribut étendu. En cas d'échec, ils renvoient -1 et remplissent I<errno> avec un code d'erreur.

note: type: Plain text
en: The named attribute does not exist, or the process has no access to this attribute.  (B<ENOATTR> is defined to be a synonym for B<ENODATA> in I<E<lt>attr/xattr.hE<gt>>.)
fr: L'attribut indiqué n'existe pas, ou le processus n'a pas accès à cet attribut (B<ENOATTR> est défini comme un synonyme de B<ENODATA> dans I<E<lt>attr/xattr.hE<gt>>).

note: type: Plain text
en: Extended attributes are not supported by the filesystem, or are disabled.
fr: Les attributs étendus ne sont pas pris en charge par le système de fichiers ou sont désactivés.

note: type: Plain text
en: The I<size> of the I<value> buffer is too small to hold the result.
fr: La I<taille> du tampon I<value> est trop petite pour contenir le résultat.

note: type: Plain text
en: In addition, the errors documented in B<stat>(2)  can also occur.
fr: De plus, les erreurs documentées dans B<stat>(2) peuvent aussi survenir.

note: type: Plain text
en: These system calls have been available on Linux since kernel 2.4; glibc support is provided since version 2.3.
fr: Ces appels système sont disponibles sous Linux depuis le noyau\ 2.4\ ; la glibc les prend en charge depuis la version\ 2.3.

note: .SH AUTHORS Andreas Gruenbacher, .RI < a.gruenbacher@computer.org > and the SGI XFS development team, .RI < linux-xfs@oss.sgi.com >. Please send any bug reports or comments to these addresses. type: Plain text
en: These system calls are Linux-specific.
fr: Ces appels système sont spécifiques à Linux.

note: type: TH
en: 2014-02-06
fr: 6 février 2014

note: type: Plain text
en: listxattr, llistxattr, flistxattr - list extended attribute names
fr: listxattr, llistxattr, flistxattr - Lister les noms des attributs étendus

note: type: Plain text
en: B<ssize_t listxattr(const char\ *>I<path>B<, char\ *>I<list>B<, size_t >I<size>B<);>
    B<ssize_t llistxattr(const char\ *>I<path>B<, char\ *>I<list>B<, size_t >I<size>B<);>
    B<ssize_t flistxattr(int >I<fd>B<, char\ *>I<list>B<, size_t >I<size>B<);>
fr: B<ssize_t listxattr (const char\ *>I<chemin>B<, char\ *>I<liste>B<, size_t >I<taille>B<);>
    B<ssize_t llistxattr (const char\ *>I<chemin>B<, char\ *>I<liste>B<, size_t >I<taille>B<);>
    B<ssize_t flistxattr (int >I<descripteur>B<, char\ *>I<liste>B<, size_t >I<taille>B<);>

note: type: Plain text
en: Extended attributes are name:value pairs associated with inodes (files, directories, symbolic links, etc.).  They are extensions to the normal attributes which are associated with all inodes in the system (i.e., the B<stat>(2)  data).  A complete overview of extended attributes concepts can be found in B<attr>(5).
fr: Les attributs étendus sont des paires I<nom>:I<valeur> associées aux inœuds (fichiers, répertoires, liens symboliques, etc). Ce sont des extensions des attributs normaux qui sont associés avec tous les inœuds du système (les informations renvoyées par B<stat>(2)). Une description complète des concepts d'attributs étendus est disponible dans B<attr>(5).

note: type: Plain text
en: B<listxattr>()  retrieves the list of extended attribute names associated with the given I<path> in the filesystem.  The retrieved list is placed in I<list>, a caller-allocated buffer whose size (in bytes) is specified in the argument I<size>.  The list is the set of (null-terminated) names, one after the other.  Names of extended attributes to which the calling process does not have access may be omitted from the list.  The length of the attribute name I<list> is returned.
fr: B<listxattr>()  récupère la liste des attributs étendus associés avec le I<chemin> indiqué du système de fichier. La liste récupérée est placée dans I<list>, un tampon alloué par l'appelant, dont la taille (en octets) est indiquée dans l'argument I<size>. La liste est l'ensemble des noms (terminés par NULL), l'un après l'autre. Les noms des attributs étendus auxquels le processus appelant n'a pas accès peuvent être omis dans la liste. La longueur de la I<liste> de noms d'attributs est renvoyée.

note: type: Plain text
en: B<llistxattr>()  is identical to B<listxattr>(), except in the case of a symbolic link, where the list of names of extended attributes associated with the link itself is retrieved, not the file that it refers to.
fr: B<llistxattr>()  est identique à B<listxattr>(), sauf dans le cas d'un lien symbolique, où il renvoie la liste des noms des attributs associés au lien lui-même et non au fichier auquel il se réfère.

note: type: Plain text
en: B<flistxattr>()  is identical to B<listxattr>(), only the open file referred to by I<fd> (as returned by B<open>(2))  is interrogated in place of I<path>.
fr: B<flistxattr>()  est identique à B<listxattr>(), sauf que le fichier ouvert associé au I<descripteur> (fourni par B<open>(2))  est interrogé à la place du I<chemin>.

note: type: Plain text
en: A single extended attribute I<name> is a simple null-terminated string.  The name includes a namespace prefix; there may be several, disjoint namespaces associated with an individual inode.
fr: Le I<nom> d'un attribut étendu est une simple chaîne terminée par un octet nul. Le nom inclut un préfixe d'espace de noms - il peut y avoir plusieurs espaces de noms disjoints associés avec un inœud donné.

note: type: Plain text
en: An empty buffer of I<size> zero can be passed into these calls to return the current size of the list of extended attribute names, which can be used to estimate the size of a buffer which is sufficiently large to hold the list of names.
fr: Un tampon vide, de I<taille> nulle, peut être transmis à ses appels, pour qu'ils renvoient la taille actuelle de la liste des noms d'attributs étendus, pour estimer la taille de tampon nécessaire pour contenir la liste des noms.

note: type: SS
en: Example
fr: Exemple

note: type: Plain text
en: The I<list> of names is returned as an unordered array of null-terminated character strings (attribute names are separated by null bytes (\(aq\e0\(aq)), like this:
fr: La I<liste> est noms est renvoyée sous forme de table de chaînes de caractères terminées par un octet nul, sans ordre particulier, les noms des attributs étant séparés par un caractère nul, ainsi\ :

note: type: Plain text
en: Filesystems like ext2, ext3 and XFS which implement POSIX ACLs using extended attributes, might return a I<list> like this:
fr: Les systèmes comme ext2, ext3, et XFS qui implémentent les ACLs POSIX en utilisant les attributs étendus peuvent renvoyer une I<liste> comme celle-ci\ :

note: type: Plain text
en: On success, a nonnegative number is returned indicating the size of the extended attribute name list.  On failure, -1 is returned and I<errno> is set appropriately.
fr: S'ils réussissent, ces appels renvoient un nombre non négatif correspondant à la taille de la liste de noms d'attributs. En cas d'échec, ils renvoient -1 et remplissent I<errno> avec un code d'erreur.

note: type: Plain text
en: The I<size> of the I<list> buffer is too small to hold the result.
fr: La I<taille> du tampon pour le tampon I<liste> est trop petite pour contenir le résultat.

note: type: TH
en: 2014-03-17
fr: 17 mars 2014

note: type: Plain text
en: mount - mount filesystem
fr: mount - Monter un système de fichiers

note: type: Plain text
en: B<mount>()  attaches the filesystem specified by I<source> (which is often a device name, but can also be a directory name or a dummy) to the directory specified by I<target>.
fr: B<mount>() attache le système de fichiers indiqué par I<source> (qui est généralement un nom de périphérique, mais peut aussi être un répertoire ou un objet fictif) au répertoire indiqué par I<target>.

note: type: Plain text
en: Appropriate privilege (Linux: the B<CAP_SYS_ADMIN> capability) is required to mount filesystems.
fr: Des privilèges appropriés (sous Linux\ : la capacité B<CAP_SYS_ADMIN>) sont nécessaires pour monter des systèmes de fichiers.

note: Multiple mounts on same mount point: since 2.3.99pre7. type: Plain text
en: Since Linux 2.4 a single filesystem can be visible at multiple mount points, and multiple mounts can be stacked on the same mount point.
fr: Depuis Linux 2.4 un même système de fichiers peut être visible en différents points, et plusieurs montages peuvent être empilés au même point.

note: type: Plain text
en: Values for the I<filesystemtype> argument supported by the kernel are listed in I</proc/filesystems> (e.g., "minix", "ext2", "ext3", "jfs", "xfs", "reiserfs", "msdos", "proc", "nfs", "iso9660").  Further types may become available when the appropriate modules are loaded.
fr: L'argument I<filesystemtype> prend une des valeurs listées dans I</proc/filesystems> (par exemple «\ ext2\ », «\ minix\ », «\ ext3\ », «\ jfs\ », «\ xfs\ », «\ reiserfs\ », «\ msdos\ », «\ proc\ », «\ nfs\ », «\ iso9660\ »). Des types supplémentaires peuvent être disponibles lorsque les modules appropriés sont chargés.

note: (as defined in \fI<linux/fs.h>\fP for libc4 and libc5 and in \fI<sys/mount.h>\fP for glibc2) FIXME 2.6.15 added flags for "shared subtree" functionality: MS_UNBINDABLE, MS_PRIVATE, MS_SHARED, MS_SLAVE MS_PRIVATE. All mounts are private by default. Previously shared mounts can be remarked PRIVATE. MS
en: The I<mountflags> argument may have the magic number 0xC0ED (B<MS_MGC_VAL>)  in the top 16 bits (this was required in kernel versions prior to 2.4, but is no longer required and ignored if specified), and various mount flags in the low order 16 bits:
fr: L'argument I<mountflags> peut avoir le nombre magique 0xC0ED (B<MS_MGC_VAL>) dans ses 16 bits de poids fort (c'était obligatoire dans les noyaux de version antérieure à 2.4, mais ne l'est plus), et certains attributs de montage dans ses 16 bits de poids faible :

note: type: TP
en: B<MS_BIND> (Linux 2.4 onward)
fr: B<MS_BIND> (depuis Linux 2.4)

note: since 2.4.0-test9 with the exception of the "hidden" MS_REC mountflags bit type: Plain text
en: Perform a bind mount, making a file or a directory subtree visible at another point within a filesystem.  Bind mounts may cross filesystem boundaries and span B<chroot>(2)  jails.  The I<filesystemtype> and I<data> arguments are ignored.  Up until Linux 2.6.26, I<mountflags> was also ignored (the bind mount has the same mount options as the underlying mount point).
fr: Effectuer un montage lié, rendant un fichier ou une arborescence visibles en un autre point du système de fichiers. Les montages liés peuvent traverser les frontières entre systèmes de fichiers et ouvrir une porte dans une prison B<chroot>(2). Les paramètres I<filesystemtype> et I<data> sont ignorés. Jusqu'à Linux 2.6.26, I<mountflags> était également ignoré (le montage lié a les même options de montage que le point de montage sous-jacent).

note: type: TP
en: B<MS_DIRSYNC> (since Linux 2.5.19)
fr: B<MS_DIRSYNC> (depuis Linux 2.5.19)

note: type: Plain text
en: Make directory changes on this filesystem synchronous.  (This property can be obtained for individual directories or subtrees using B<chattr>(1).)
fr: Rendre synchrones les modifications sur les répertoires du système de fichiers. (Cette propriété peut être obtenue pour les répertoires individuels ou les sous\(hyarborescences en utilisant B<chattr>(1).)

note: FIXME Say more about MS_MOVE type: Plain text
en: Permit mandatory locking on files in this filesystem.  (Mandatory locking must still be enabled on a per-file basis, as described in B<fcntl>(2).)
fr: Autoriser les verrouillages impératifs sur le système de fichiers. (Le verrouillage impératif devra toutefois être validé fichier par fichier, comme décrit dans B<fcntl>(2).)

note: type: Plain text
en: Move a subtree.  I<source> specifies an existing mount point and I<target> specifies the new location.  The move is atomic: at no point is the subtree unmounted.  The I<filesystemtype>, I<mountflags>, and I<data> arguments are ignored.
fr: Déplacer une sous\(hyarborescence. I<source> indique un point de montage existant et I<target> indique son nouvel emplacement. Le déplacement est atomique, à aucun moment la sous\(hyarborescence n'est démontée. Les arguments I<filesystemtype>, I<mountflags>, et I<data> sont ignorés.

note: type: Plain text
en: Do not update access times for (all types of) files on this filesystem.
fr: Ne pas mettre à jour les dates d'accès pour (tous) les fichiers du système de fichiers.

note: type: Plain text
en: Do not allow access to devices (special files) on this filesystem.
fr: Ne pas autoriser la présence de fichiers spéciaux de périphérique sur le système de fichiers.

note: type: Plain text
en: Do not update access times for directories on this filesystem.  This flag provides a subset of the functionality provided by B<MS_NOATIME>; that is, B<MS_NOATIME> implies B<MS_NODIRATIME>.
fr: Ne pas mettre à jour les dates d'accès pour les répertoires du système de fichiers. Cet attribut fournit un sous-ensemble de la fonctionnalité fournie par B<MS_NOATIME> ; c'est-à-dire, B<MS_NOATIME> implique B<MS_NODIRATIME>.

note: (Possibly useful for a filesystem that contains non-Linux executables. Often used as a security feature, e.g., to make sure that restricted users cannot execute files uploaded using ftp or so.) type: Plain text
en: Do not allow programs to be executed from this filesystem.
fr: Ne pas permettre l'exécution de programme depuis le système de fichiers.

note: (This is a security feature to prevent users executing set-user-ID and set-group-ID programs from removable disk devices.) type: Plain text
en: Do not honor set-user-ID and set-group-ID bits when executing programs from this filesystem.
fr: Ne pas tenir compte des bits Set-UID et Set-GID lors de l'exécution de programmes sur le système de fichiers.

note: FIXME Document MS_REC, available since 2.4.11. This flag has meaning in conjunction with MS_BIND and also with the shared subtree flags. type: Plain text
en: Mount filesystem read-only.
fr: Monter le système de fichiers en lecture seule.

note: type: TP
en: B<MS_RELATIME> (since Linux 2.6.20)
fr: B<MS_RELATIME> (depuis Linux 2.6.20)

note: Matthew Garrett notes in the patch that added this behavior that this lets utilities such as tmpreaper (which deletes files based on last access time) work correctly. type: Plain text
en: When a file on this filesystem is accessed, update the file's last access time (atime) only if the current value of atime is less than or equal to the file's last modification time (mtime)  or last status change time (ctime).  This option is useful for programs, such as B<mutt>(1), that need to know when a file has been read since it was last modified.  Since Linux 2.6.30, the kernel defaults to the behavior provided by this flag (unless B<MS_NOATIME> was specified), and the B<MS_STRICTATIME> flag is required to obtain traditional semantics.  In addition, since Linux 2.6.30, the file's last access time is always updated if it is more than 1 day old.
fr: Lorsqu'un fichier sur ce système de fichiers est utilisé, ne mettre à jour sa date d'accès (atime) que si la valeur actuelle de atime est inférieure ou égale à sa date de dernière modification (mtime) ou de changement d'état (ctime). Cette option est utile pour les programmes tels que B<mutt>(1) qui veulent savoir si un fichier a été lu depuis sa dernière modification. Depuis Linux\ 2.6.30, les noyaux suivent le comportement fourni par cet attribut (à moins que B<MS_NOATIME> soit indiqué), et l’attribut B<MS_STRICTATIME> est nécessaire pour avoir la sémantique originale. De plus, depuis Linux\ 2.6.30, le temps du dernier accès à un fichier est toujours mis à jour s'il est plus ancien qu'un jour.

note: type: Plain text
en: Remount an existing mount.  This allows you to change the I<mountflags> and I<data> of an existing mount without having to unmount and remount the filesystem.  I<target> should be the same value specified in the initial B<mount>()  call; I<source> and I<filesystemtype> are ignored.
fr: Réinitialiser un montage existant. Cela permet de modifier les attributs I<mountflags> et I<data> d'un montage existant sans avoir besoin de démonter et remonter le système de fichiers. I<target> doit avoir la même valeur que lors de l'appel B<mount>() initial\ ; I<source> et I<filesystemtype> sont ignorés.

note: type: Plain text
en: The following I<mountflags> can be changed: B<MS_RDONLY>, B<MS_SYNCHRONOUS>, B<MS_MANDLOCK>; before kernel 2.6.16, the following could also be changed: B<MS_NOATIME> and B<MS_NODIRATIME>; and, additionally, before kernel 2.4.10, the following could also be changed: B<MS_NOSUID>, B<MS_NODEV>, B<MS_NOEXEC>.
fr: Les attributs I<mountflags> suivants peuvent être modifiés\ : B<MS_RDONLY>, B<MS_SYNCHRONOUS>, B<MS_MANDLOCK>\ ; avant le noyau 2.6.16, B<MS_NOATIME> et B<MS_NODIRATIME> pouvaient également être modifiés. Enfin, avant le noyau 2.4.10, les attributs B<MS_NOSUID>, B<MS_NODEV> et B<MS_NOEXEC> pouvaient être modifiés.

note: type: TP
en: B<MS_SILENT> (since Linux 2.6.17)
fr: B<MS_SILENT> (depuis Linux 2.6.17)

note: type: Plain text
en: Suppress the display of certain (I<printk>())  warning messages in the kernel log.  This flag supersedes the misnamed and obsolete B<MS_VERBOSE> flag (available since Linux 2.4.12), which has the same meaning.
fr: Supprime l'affichage de certain messages d'avertissement (I<printk>()) dans le journal noyau. Cet attribut remplace l'attribut B<MS_VERBOSE> qui avait un mauvais nom et est obsolète (il était disponible depuis Linux 2.4.12), et qui a la même signification.

note: type: TP
en: B<MS_STRICTATIME> (since Linux 2.6.30)
fr: B<MS_STRICTATIME> (depuis Linux 2.6.30)

note: type: Plain text
en: Always update the last access time (atime) when files on this filesystem are accessed.  (This was the default behavior before Linux 2.6.30.)  Specifying this flag overrides the effect of setting the B<MS_NOATIME> and B<MS_RELATIME> flags.
fr: Toujours mettre à jour le temps du dernier d'accès (atime) lorsque des fichiers sur le système de fichiers sont lus (c'était le comportement par défaut avant Linux\ 2.6.30). Indiquer cet attribut annule l'effet des attributs B<MS_NOATIME> et B<MS_RELATIME>.

note: type: Plain text
en: Make writes on this filesystem synchronous (as though the B<O_SYNC> flag to B<open>(2)  was specified for all file opens to this filesystem).
fr: Rendre synchrones les écritures sur le système de fichiers (comme si l'option B<O_SYNC> de B<open>(2) était indiquée à chaque appel sur ce système de fichiers).

note: type: Plain text
en: From Linux 2.4 onward, the B<MS_NODEV>, B<MS_NOEXEC>, and B<MS_NOSUID> flags are settable on a per-mount-point basis.  From kernel 2.6.16 onward, B<MS_NOATIME> and B<MS_NODIRATIME> are also settable on a per-mount-point basis.  The B<MS_RELATIME> flag is also settable on a per-mount-point basis.
fr: Depuis Linux 2.4, les attributs B<MS_NODEV>, B<MS_NOEXEC>, et B<MS_NOSUID> sont configurables de manière variable sur chaque point de montage. À partir du noyau 2.6.16, B<MS_NOATIME> et B<MS_NODIRATIME> peuvent aussi être configurés pour chaque point de montage. L'attribut B<MS_RELATIME> peut aussi être configuré pour chaque point de montage.

note: type: Plain text
en: The I<data> argument is interpreted by the different filesystems.  Typically it is a string of comma-separated options understood by this filesystem.  See B<mount>(8)  for details of the options available for each filesystem type.
fr: L'argument I<data> est interprété différemment suivant le type de système de fichiers. Typiquement, c'est une chaîne d'options comprises par le système de fichiers, séparées par des virgules. Consultez B<mount>(8) pour des détails sur les options disponibles pour chaque type de système.

note: type: Plain text
en: On success, zero is returned.  On error, -1 is returned, and I<errno> is set appropriately.
fr: S'il réussit, cet appel système renvoie 0. S'il échoue, il renvoie -1 et remplit I<errno> en conséquence.

note: type: Plain text
en: The error values given below result from filesystem type independent errors.  Each filesystem type may have its own special errors and its own special behavior.  See the Linux kernel source code for details.
fr: Les erreurs détaillées ici sont indépendantes du type de système de fichiers. Chaque type de système peut avoir des codes d'erreurs spécifiques, et un comportement particulier. Consultez les sources du noyau Linux pour plus de détails.

note: mtk: Probably: write permission is required for MS_BIND, with the error EPERM if not present; CAP_DAC_OVERRIDE is required. type: Plain text
en: A component of a path was not searchable.  (See also B<path_resolution>(7).)  Or, mounting a read-only filesystem was attempted without giving the B<MS_RDONLY> flag.  Or, the block device I<source> is located on a filesystem mounted with the B<MS_NODEV> option.
fr: Un élément du chemin d'accès n'est pas consultable (voir aussi B<path_resolution>(7)), ou on tente de monter un système de fichiers en lecture seule sans préciser l'attribut B<MS_RDONLY>, ou bien le périphérique bloc I<source> est situé sur un système de fichiers monté avec l'attribut B<MS_NODEV>.

note: type: Plain text
en: I<source> is already mounted.  Or, it cannot be remounted read-only, because it still holds files open for writing.  Or, it cannot be mounted on I<target> because I<target> is still busy (it is the working directory of some thread, the mount point of another device, has open files, etc.).
fr: I<source> est déjà monté, ou ne peut pas être remonté en lecture seule car il y a des fichiers ouverts en écriture, ou ne peut pas être monté sur I<target> car I<target> est occupé (c'est le répertoire de travail d'un processus, le point de montage d'un autre périphérique, des fichiers y sont ouverts, etc.).

note: type: Plain text
en: One of the pointer arguments points outside the user address space.
fr: L'un des arguments pointe en\(hydehors de l'espace d'adressage accessible.

note: type: Plain text
en: I<source> had an invalid superblock.  Or, a remount (B<MS_REMOUNT>)  was attempted, but I<source> was not already mounted on I<target>.  Or, a move (B<MS_MOVE>)  was attempted, but I<source> was not a mount point, or was \(aq/\(aq.
fr: I<source> a un superbloc invalide, ou on tente un remontage (B<MS_REMOUNT>) alors que I<source> n'était pas encore monté sur I<target>. Ou un déplacement (B<MS_MOVE>) est demandé alors que I<source> n'est pas un point de montage ou est «\ /\ ».

note: type: Plain text
en: Too many links encountered during pathname resolution.  Or, a move was attempted, while I<target> is a descendant of I<source>.
fr: Trop de liens symboliques rencontrés dans un chemin, ou un déplacement a été tenté dans lequel I<target> est un descendant de I<source>.

note: type: Plain text
en: (In case no block device is required:)  Table of dummy devices is full.
fr: (Dans le cas où un périphérique bloc n'est pas nécessaire\ :) Table de montage factice pleine.

note: type: Plain text
en: A pathname was longer than B<MAXPATHLEN>.
fr: Un des arguments est plus long que B<MAXPATHLEN>.

note: type: Plain text
en: I<filesystemtype> not configured in the kernel.
fr: I<filesystemtype> n'est pas configuré dans le noyau.

note: type: Plain text
en: A pathname was empty or had a nonexistent component.
fr: Un des chemins est vide ou a un composant inexistant.

note: type: Plain text
en: The kernel could not allocate a free page to copy filenames or data into.
fr: Le noyau n'a pas pu allouer suffisamment de mémoire.

note: type: Plain text
en: I<source> is not a block device (and a device was required).
fr: I<Source> n'est pas un périphérique bloc (et un périphérique était nécessaire).

note: type: Plain text
en: I<target>, or a prefix of I<source>, is not a directory.
fr: I<target> ou un préfixe de I<source> n'est pas un répertoire.

note: type: Plain text
en: The major number of the block device I<source> is out of range.
fr: Le nombre majeur du périphérique bloc I<source> est invalide.

note: type: Plain text
en: The caller does not have the required privileges.
fr: L'appelant n'a pas les privilèges appropriés.

note: FIXME: Definitions of the so-far-undocumented MS_UNBINDABLE, MS_PRIVATE, MS_SHARED, and MS_SLAVE were (also) only added to glibc headers in 2.12. type: Plain text
en: The definitions of B<MS_DIRSYNC>, B<MS_MOVE>, B<MS_REC>, B<MS_RELATIME>, and B<MS_STRICTATIME> were added to glibc headers in version 2.12.
fr: Les définitions de B<MS_DIRSYNC>, B<MS_MOVE>, B<MS_REC>, B<MS_RELATIME> et B<MS_STRICTATIME> ont été ajoutées aux en\(hytêtes de la glibc depuis la version 2.12.

note: type: Plain text
en: This function is Linux-specific and should not be used in programs intended to be portable.
fr: Cette fonction est spécifique à Linux et ne doit pas être employée dans des programmes destinés à être portables.

note: type: Plain text
en: The original B<MS_SYNC> flag was renamed B<MS_SYNCHRONOUS> in 1.1.69 when a different B<MS_SYNC> was added to I<E<lt>mman.hE<gt>>.
fr: L'attribut original B<MS_SYNC> a été renommé B<MS_SYNCHRONOUS> dans Linux 1.1.69 car un B<MS_SYNC> différent a été ajouté dans I<E<lt>mman.hE<gt>>.

note: The change is in patch-2.4.0-prerelease. type: Plain text
en: Before Linux 2.4 an attempt to execute a set-user-ID or set-group-ID program on a filesystem mounted with B<MS_NOSUID> would fail with B<EPERM>.  Since Linux 2.4 the set-user-ID and set-group-ID bits are just silently ignored in this case.
fr: Avant Linux 2.4, une tentative d'exécution d'un programme Set-UID ou Set-GID sur un système de fichiers monté avec l'attribut B<MS_NOSUID> échouait avec l'erreur B<EPERM>. Depuis Linux 2.4 les bits Set-UID et Set-GID sont simplement ignorés silencieusement dans ce cas.

note: type: SS
en: Per-process namespaces
fr: Espaces de noms par processus

note: type: Plain text
en: Starting with kernel 2.4.19, Linux provides per-process mount namespaces.  A mount namespace is the set of filesystem mounts that are visible to a process.  Mount-point namespaces can be (and usually are)  shared between multiple processes, and changes to the namespace (i.e., mounts and unmounts) by one process are visible to all other processes sharing the same namespace.  (The pre-2.4.19 Linux situation can be considered as one in which a single namespace was shared by every process on the system.)
fr: À partir du noyau 2.4.19, Linux fournit des espaces de noms de montage par processus. Un espace de noms de montage est un ensemble de montage de systèmes de fichiers qui sont visibles d'un processus. Les espaces de noms de montage peuvent être (ils le sont généralement) partagés entre différents processus et les modifications à l'espace de noms (c'est-à-dire les montages et démontages) par un processus sont visibles pour tous les autres processus qui partagent le même espace de noms (la situation des versions antérieures à pre-2.4.19 de Linux peut être considérée comme l'utilisation d'un unique espace de noms partagé par tous les processus du système).

note: type: Plain text
en: A child process created by B<fork>(2)  shares its parent's mount namespace; the mount namespace is preserved across an B<execve>(2).
fr: Un processus fils créé avec B<fork>(2) partage l'espace de noms de montage de son père ; l'espace de noms de montage est préservée au travers d'un B<execve>(2).

note: type: Plain text
en: A process can obtain a private mount namespace if: it was created using the B<clone>(2)  B<CLONE_NEWNS> flag, in which case its new namespace is initialized to be a I<copy> of the namespace of the process that called B<clone>(2); or it calls B<unshare>(2)  with the B<CLONE_NEWNS> flag, which causes the caller's mount namespace to obtain a private copy of the namespace that it was previously sharing with other processes, so that future mounts and unmounts by the caller are invisible to other processes (except child processes that the caller subsequently creates) and vice versa.
fr: Un processus peut obtenir un espace de noms de montage privé si : il a été créé en utilisant l'attribut B<CLONE_NEWNS> de B<clone>(2), dans ce cas son nouvel espace de noms est initialisé comme une I<copie> de l'espace de noms du processus qui a appelé B<clone>(2) ; ou il appelle B<unshare>(2) avec l'attribut B<CLONE_NEWNS>, ce qui provoque l'obtention d'une copie privée de l'environnement de l'appelant, qui était auparavant partagé avec d'autres processus, de telle sorte que les montages ou démontages futurs de l'appelant ne seront pas visibles des autres processus (à l'exception des processus fils que le processus pourrait créer), et vice-versa.

note: type: Plain text
en: The Linux-specific I</proc/PID/mounts> file exposes the list of mount points in the mount namespace of the process with the specified ID; see B<proc>(5)  for details.
fr: Le fichier I</proc/PID/mounts>, spécifique à Linux, expose une liste de points de montage de l'espace de noms de montage du processus avec l'identifiant indiqué ; consultez B<proc>(5) pour des détails.

note: type: TH
en: 2009-12-05
fr: 5 décembre 2009

note: type: Plain text
en: path_resolution - how a pathname is resolved to a file
fr: path_resolution - Trouver le fichier auquel un chemin fait référence

note: type: Plain text
en: Some UNIX/Linux system calls have as parameter one or more filenames.  A filename (or pathname) is resolved as follows.
fr: Certains appels système UNIX/Linux ont pour paramètre un ou plusieurs noms de fichiers. Un nom de fichier (ou chemin) est résolu de la manière suivante.

note: type: SS
en: Step 1: start of the resolution process
fr: Étape 1\ : Démarrer le processus de résolution

note: type: Plain text
en: If the pathname starts with the \(aq/\(aq character, the starting lookup directory is the root directory of the calling process.  (A process inherits its root directory from its parent.  Usually this will be the root directory of the file hierarchy.  A process may get a different root directory by use of the B<chroot>(2)  system call.  A process may get an entirely private mount namespace in case it\(emor one of its ancestors\(emwas started by an invocation of the B<clone>(2)  system call that had the B<CLONE_NEWNS> flag set.)  This handles the \(aq/\(aq part of the pathname.
fr: Si le chemin débute avec le caractère «\ /\ », le répertoire de recherche de départ est le répertoire racine du processus appelant. (Un processus hérite son répertoire racine de son père. Habituellement, c'est le répertoire racine de la hiérarchie des fichiers. Un processus peut avoir un répertoire racine différent avec l'utilisation de l'appel système B<chroot>(2). Un processus peut récupérer un espace noms de montage privé entier dans le cas où lui \(em ou un de ses parents \(em a été démarré par une invocation de l'appel système B<clone>(2) avec l'attribut B<CLONE_NEWNS> positionné.) Cela gère la partie «\ /\ » du chemin.

note: type: Plain text
en: If the pathname does not start with the \(aq/\(aq character, the starting lookup directory of the resolution process is the current working directory of the process.  (This is also inherited from the parent.  It can be changed by use of the B<chdir>(2)  system call.)
fr: Si le chemin ne débute pas par le caractère «\ /\ », le répertoire de recherche de départ du processus de résolution est le répertoire courant du processus. (Lui aussi est hérité du père. Il peut être modifié avec l'appel système B<chdir>(2).)

note: type: Plain text
en: Pathnames starting with a \(aq/\(aq character are called absolute pathnames.  Pathnames not starting with a \(aq/\(aq are called relative pathnames.
fr: Les chemins débutant avec le caractère «\ /\ » sont appelés chemins absolus. Les chemins ne débutant pas avec le caractère «\ /\ » sont appelés chemins relatifs.

note: type: SS
en: Step 2: walk along the path
fr: Étape 2\ : Se promener le long du chemin

note: type: Plain text
en: Set the current lookup directory to the starting lookup directory.  Now, for each nonfinal component of the pathname, where a component is a substring delimited by \(aq/\(aq characters, this component is looked up in the current lookup directory.
fr: Le répertoire de recherche courant est le répertoire de recherche de départ. On appellera composant d'un chemin une sous-chaîne délimitée par des caractères «\ /\ ». Chaque composant du chemin qui n'est pas le composant final est recherché dans le répertoire de recherche courant.

note: type: Plain text
en: If the process does not have search permission on the current lookup directory, an B<EACCES> error is returned ("Permission denied").
fr: Si le processus n'a pas les permissions nécessaires pour effectuer la recherche dans le répertoire de recherche courant, une erreur B<EACCES> est renvoyée (« Permission denied » : « Permission non accordée »).

note: type: Plain text
en: If the component is not found, an B<ENOENT> error is returned ("No such file or directory").
fr: Si le composant n'est pas trouvé, une erreur B<ENOENT> est renvoyée (« No such file or directory » : « Aucun fichier ou répertoire de ce type »).

note: type: Plain text
en: If the component is found, but is neither a directory nor a symbolic link, an B<ENOTDIR> error is returned ("Not a directory").
fr: Si le composant est trouvé mais que ce n'est ni un répertoire, ni un lien symbolique, une erreur B<ENOTDIR> est renvoyée (« Not a directory » : « N'est pas un répertoire »).

note: type: Plain text
en: If the component is found and is a directory, we set the current lookup directory to that directory, and go to the next component.
fr: Si le composant est trouvé et que c'est un répertoire, le répertoire de recherche courant devient ce répertoire et on passe au composant suivant.

note: presently: max recursion depth during symlink resolution: 5 max total number of symbolic links followed: 40 _POSIX_SYMLOOP_MAX is 8 type: Plain text
en: If the component is found and is a symbolic link (symlink), we first resolve this symbolic link (with the current lookup directory as starting lookup directory).  Upon error, that error is returned.  If the result is not a directory, an B<ENOTDIR> error is returned.  If the resolution of the symlink is successful and returns a directory, we set the current lookup directory to that directory, and go to the next component.  Note that the resolution process here involves recursion.  In order to protect the kernel against stack overflow, and also to protect against denial of service, there are limits on the maximum recursion depth, and on the maximum number of symbolic links followed.  An B<ELOOP> error is returned when the maximum is exceeded ("Too many levels of symbolic links").
fr: Si le composant est trouvé et que c'est un lien symbolique, on résout d'abord ce lien (avec le répertoire de recherche courant comme répertoire de recherche de départ). Si une erreur survient, cette erreur est renvoyée. Si le résultat de la résolution n'est pas un répertoire, une erreur B<ENOTDIR> est renvoyée. Si la résolution du lien symbolique est couronnée de succès et renvoie un répertoire, le répertoire de recherche courant devient ce répertoire et on passe au composant suivant. Veuillez noter que le processus de résolution implique une récursivité. Afin de protéger le noyau d'un débordement de pile et également d'un déni de service, il y a des limites à la profondeur maximum de récursivité et aux nombres maximum de liens symboliques suivis. Une erreur B<ELOOP> est renvoyée lors ces maxima sont atteints (« Too many levels of symbolic links » : « Trop de niveaux de liens symboliques »).

note: type: SS
en: Step 3: find the final entry
fr: Étape 3\ : Trouver l'entrée finale

note: type: Plain text
en: The lookup of the final component of the pathname goes just like that of all other components, as described in the previous step, with two differences: (i) the final component need not be a directory (at least as far as the path resolution process is concerned\(emit may have to be a directory, or a nondirectory, because of the requirements of the specific system call), and (ii) it is not necessarily an error if the component is not found\(emmaybe we are just creating it.  The details on the treatment of the final entry are described in the manual pages of the specific system calls.
fr: La recherche du dernier composant du nom de chemin s'effectue de la même manière que les autres composants, comme décrit dans l'étape précédente, avec deux différences\ : (i) le composant final n'a pas besoin d'être un répertoire (du moins tant que le processus de résolution du chemin est concerné \(em il peut être ou ne pas être un répertoire, suivant les exigences de l'appel système concerné), et (ii) ce n'est peut-être pas une erreur si le composant n'est pas trouvé \(em peut-être vient on juste de le créer. Les détails du traitement du composant final sont décrits dans les pages de manuel des appels système concernés.

note: type: SS
en: . and ..
fr: . et ..

note: type: Plain text
en: By convention, every directory has the entries "." and "..", which refer to the directory itself and to its parent directory, respectively.
fr: Par convention, chaque répertoire possède les entrées I<.> et I<..>, qui se rapportent, respectivement, au répertoire lui-même et à son répertoire parent.

note: type: Plain text
en: The path resolution process will assume that these entries have their conventional meanings, regardless of whether they are actually present in the physical filesystem.
fr: Le processus de résolution de chemin considère que ces entrées ont leurs sens conventionnels, sans considération de leur existence ou non sur le système de fichiers.

note: type: Plain text
en: One cannot walk down past the root: "/.." is the same as "/".
fr: On ne peut plus sortir passée la racine\ : I</..> est identique à I</>.

note: type: SS
en: Mount points
fr: Points de montage

note: type: Plain text
en: After a "mount dev path" command, the pathname "path" refers to the root of the filesystem hierarchy on the device "dev", and no longer to whatever it referred to earlier.
fr: Après une commande B<mount> I<périphérique chemin>, le nom de chemin I<chemin> fait référence à la racine de la hiérarchie du système de fichiers sur le I<périphérique>, et plus du tout ce qu'il référençait précédemment.

note: type: Plain text
en: One can walk out of a mounted filesystem: "path/.." refers to the parent directory of "path", outside of the filesystem hierarchy on "dev".
fr: On peut sortir d'un système de fichiers monté\ : I<chemin/..> fait référence au répertoire parent de I<chemin>, en dehors de la hiérarchie du système de fichiers sur I<périphérique>.

note: type: SS
en: Trailing slashes
fr: Barres obliques de fin

note: type: Plain text
en: If a pathname ends in a \(aq/\(aq, that forces resolution of the preceding component as in Step 2: it has to exist and resolve to a directory.  Otherwise a trailing \(aq/\(aq is ignored.  (Or, equivalently, a pathname with a trailing \(aq/\(aq is equivalent to the pathname obtained by appending \(aq.\(aq to it.)
fr: Si un nom de chemin finit avec un «\ /\ », cela force la résolution du composant qui le précède comme décrit dans l'étape 2 \(em le composant doit exister et être résolu comme répertoire. Autrement, un «\ /\ » final est ignoré. (Ou bien, de manière équivalente, un nom de chemin avec un «\ /\ » final est équivalent au nom de chemin obtenu en ajoutant «\ .\ » à la fin.)

note: type: SS
en: Final symlink
fr: Lien symbolique final

note: type: Plain text
en: If the last component of a pathname is a symbolic link, then it depends on the system call whether the file referred to will be the symbolic link or the result of path resolution on its contents.  For example, the system call B<lstat>(2)  will operate on the symlink, while B<stat>(2)  operates on the file pointed to by the symlink.
fr: Si le dernier composant d'un nom de chemin est un lien symbolique, cela dépend de l'appel système si le fichier référencé sera le lien symbolique ou bien le résultat de la résolution de chemin sur son contenu. Par exemple, l'appel système B<lstat>(2) agit sur le lien symbolique alors que B<stat>(2) agit sur le fichier pointé par le lien.

note: type: SS
en: Length limit
fr: Limite de longueur

note: type: Plain text
en: There is a maximum length for pathnames.  If the pathname (or some intermediate pathname obtained while resolving symbolic links)  is too long, an B<ENAMETOOLONG> error is returned ("Filename too long").
fr: Il y a une longueur maximum pour les noms de chemins. Si le chemin (ou un chemin intermédiaire obtenu en résolvant un lien symbolique) est trop long, une erreur B<ENAMETOOLONG> est renvoyée (« Filename too long » : « Nom de fichier trop long »).

note: type: SS
en: Empty pathname
fr: Nom de chemin vide

note: type: Plain text
en: In the original UNIX, the empty pathname referred to the current directory.  Nowadays POSIX decrees that an empty pathname must not be resolved successfully.  Linux returns B<ENOENT> in this case.
fr: Dans l'UNIX d'origine, un nom de chemin vide faisait référence au répertoire courant. Aujourd'hui, POSIX décrète qu'un nom de fichier vide ne doit pas être résolu avec succès. Linux renvoie B<ENOENT> dans ce cas.

note: type: Plain text
en: The permission bits of a file consist of three groups of three bits, cf.\& B<chmod>(1)  and B<stat>(2).  The first group of three is used when the effective user ID of the calling process equals the owner ID of the file.  The second group of three is used when the group ID of the file either equals the effective group ID of the calling process, or is one of the supplementary group IDs of the calling process (as set by B<setgroups>(2)).  When neither holds, the third group is used.
fr: Les bits de permissions d'un fichier consistent en trois groupes de trois bits, cf.\& B<chmod>(1) et B<stat>(2). Le premier de ces groupes est utilisé lorsque l'UID effectif du processus appelant est égal à l'UID réel (le propriétaire) du fichier. Le deuxième de ces groupes est utilisé lorsque le GID du fichier est soit égal au GID effectif du processus appelant, soit est un des GID supplémentaires du processus appelant (comme configuré avec B<setgroups>(2)). Lorsqu'aucun ne correspond, le troisième groupe est utilisé.

note: type: Plain text
en: Of the three bits used, the first bit determines read permission, the second write permission, and the last execute permission in case of ordinary files, or search permission in case of directories.
fr: Des trois bits utilisés, le premier détermine la permission de lecture, le deuxième la permission d'écriture et le dernier la permission d'exécution dans le cas d'un fichier ordinaire ou la permission de recherche dans le cas d'un répertoire.

note: type: Plain text
en: Linux uses the fsuid instead of the effective user ID in permission checks.  Ordinarily the fsuid will equal the effective user ID, but the fsuid can be changed by the system call B<setfsuid>(2).
fr: Linux utilise le fsuid à la place de l'UID effectif lors de la vérification des permissions. D'ordinaire, le fsuid est égal à l'UID effectif, mais le fsuid peut être modifié avec l'appel système B<setfsuid>(2).

note: type: Plain text
en: (Here "fsuid" stands for something like "filesystem user ID".  The concept was required for the implementation of a user space NFS server at a time when processes could send a signal to a process with the same effective user ID.  It is obsolete now.  Nobody should use B<setfsuid>(2).)
fr: (Ici, «\ fsuid\ » signifie quelque chose comme «\ UID système de fichiers\ » (« filesystem user ID »). Le concept était requis pour l'implémentation d'un serveur NFS en espace utilisateur au moment où les processus pouvaient envoyer un signal à un processus qui avait le même UID effectif. Il est aujourd'hui obsolète. Personne ne devrait plus utiliser B<setfsuid>(2).)

note: FIXME say something about filesystem mounted read-only ? type: Plain text
en: Similarly, Linux uses the fsgid ("filesystem group ID")  instead of the effective group ID.  See B<setfsgid>(2).
fr: De la même manière, Linux utilise le fsgid à la place du GID effectif. Consultez B<setfsgid>(2).

note: type: SS
en: Bypassing permission checks: superuser and capabilities
fr: Contourner les vérifications de permissions\ : superutilisateur et capacités

note: (but for exec at least one x bit must be set) -- AEB but there is variation across systems on this point: for example, HP-UX and Tru64 are as described by AEB.  However, on some implementations (e.g., Solaris, FreeBSD), access(X_OK) by superuser will report success, regardless of the file's execute 
en: On a traditional UNIX system, the superuser (I<root>, user ID 0) is all-powerful, and bypasses all permissions restrictions when accessing files.
fr: Sur un système UNIX traditionnel, le superutilisateur (I<root>, d'identifiant 0) est tout-puissant, et shunte toutes les restrictions de permissions lorsqu'il accède à des fichiers.

note: type: Plain text
en: On Linux, superuser privileges are divided into capabilities (see B<capabilities>(7)).  Two capabilities are relevant for file permissions checks: B<CAP_DAC_OVERRIDE> and B<CAP_DAC_READ_SEARCH>.  (A process has these capabilities if its fsuid is 0.)
fr: Sous Linux, les privilèges du superutilisateur sont divisés en capacités (consultez B<capabilities>(7)). Deux de ces capacités sont liées aux vérifications d'accès aux fichiers\ : B<CAP_DAC_OVERRIDE> et B<CAP_DAC_READ_SEARCH>. (Un processus a ces capacités si son fsuid est 0.)

note: type: Plain text
en: The B<CAP_DAC_OVERRIDE> capability overrides all permission checking, but grants execute permission only when at least one of the file's three execute permission bits is set.
fr: La capacité B<CAP_DAC_OVERRIDE> écrase toutes les vérifications de permission mais n'assurera la permission d'exécution que si au moins un des trois bits d'exécution est à 1.

note: FIXME say something about immutable files FIXME say something about ACLs type: Plain text
en: The B<CAP_DAC_READ_SEARCH> capability grants read and search permission on directories, and read permission on ordinary files.
fr: La capacité B<CAP_DAC_READ_SEARCH> assurera la permission de lecture et de recherche sur les répertoires, et la permission de lecture sur les fichiers ordinaires.

note: type: Plain text
en: removexattr, lremovexattr, fremovexattr - remove an extended attribute
fr: removexattr, lremovexattr, fremovexattr - Suppression d'un attribut étendu

note: type: Plain text
en: B<int removexattr(const char\ *>I<path>B<, const char\ *>I<name>B<);>
    B<int lremovexattr(const char\ *>I<path>B<, const char\ *>I<name>B<);>
    B<int fremovexattr(int >I<fd>B<, const char\ *>I<name>B<);>
fr: B<int removexattr(const char\ *>I<chemin>B<, const char\ *>I<nom>B<);>
    B<int lremovexattr(const char\ *>I<chemin>B<, const char\ *>I<nom>B<);>
    B<int fremovexattr(int >I<descripteur>B<, const char\ *>I<nom>B<);>

note: type: Plain text
en: Extended attributes are I<name>:value pairs associated with inodes (files, directories, symbolic links, etc.).  They are extensions to the normal attributes which are associated with all inodes in the system (i.e., the B<stat>(2)  data).  A complete overview of extended attributes concepts can be found in B<attr>(5).
fr: Les attributs étendus sont des paires I<nom>:I<valeur> associées aux inœuds (fichiers, répertoires, liens symboliques, etc). Ce sont des extensions des attributs normaux qui sont associés avec tous les inœuds du système (les informations renvoyées par B<stat>(2)). Une description complète des concepts d'attributs étendus est disponible dans B<attr>(5).

note: type: Plain text
en: B<removexattr>()  removes the extended attribute identified by I<name> and associated with the given I<path> in the filesystem.
fr: B<removexattr>()  supprime l'attribut étendu identifié par le I<nom> et associé au I<chemin> du système de fichiers.

note: type: Plain text
en: B<lremovexattr>()  is identical to B<removexattr>(), except in the case of a symbolic link, where the extended attribute is removed from the link itself, not the file that it refers to.
fr: B<lremovexattr>()  est identique à B<removexattr>(), sauf dans le cas d'un lien symbolique, où il supprime l'attribut du lien lui-même et non du fichier qu'il vise.

note: type: Plain text
en: B<fremovexattr>()  is identical to B<removexattr>(), only the extended attribute is removed from the open file referred to by I<fd> (as returned by B<open>(2))  in place of I<path>.
fr: B<fremovexattr>()  est identique à B<removexattr>(), mais l'attribut est supprimé du fichier ouvert indiqué par le I<descripteur> (renvoyé par B<open>(2))  à la place du I<chemin>.

note: type: Plain text
en: An extended attribute name is a simple null-terminated string.  The I<name> includes a namespace prefix; there may be several, disjoint namespaces associated with an individual inode.
fr: Le I<nom> d'un attribut étendu est une simple chaîne terminée par un octet nul. Le nom inclut un préfixe d'espace de noms - il peut y avoir plusieurs espaces de noms disjoints associés avec un inœud donné.

note: type: Plain text
en: On success, zero is returned.  On failure, -1 is returned and I<errno> is set appropriately.
fr: S'ils réussissent, ces appels renvoient zéro. En cas d'échec, ils renvoient -1 et I<errno> contient le code d'erreur.

note: type: Plain text
en: The named attribute does not exist.  (B<ENOATTR> is defined to be a synonym for B<ENODATA> in I<E<lt>attr/xattr.hE<gt>>.)
fr: L'attribut indiqué n'existe pas (B<ENOATTR> est défini comme un synonyme de B<ENODATA> dans I<E<lt>attr/xattr.hE<gt>>).

note: type: Plain text
en: setxattr, lsetxattr, fsetxattr - set an extended attribute value
fr: setxattr, lsetxattr, fsetxattr - Définir les attributs étendus

note: type: Plain text
en: B<int setxattr(const char\ *>I<path>B<, const char\ *>I<name>B<,>
    B<              const void\ *>I<value>B<, size_t >I<size>B<, int >I<flags>B<);>
    B<int lsetxattr(const char\ *>I<path>B<, const char\ *>I<name>B<,>
    B<              const void\ *>I<value>B<, size_t >I<size>B<, int >I<flags>B<);>
    B<int fsetxattr(int >I<fd>B<, const char\ *>I<name>B<,>
    B<              const void\ *>I<value>B<, size_t >I<size>B<, int >I<flags>B<);>
fr: B<int setxattr (const char\ *>I<chemin>B<, const char\ *>I<nom>B<,>
    B<              const void\ *>I<valeur>B<, size_t >I<taille>B<, int >I<options>B<);>
    B<int lsetxattr (const char\ *>I<chemin>B<, const char\ *>I<nom>B<,>
    B<               const void\ *>I<valeur>B<, size_t >I<taille>B<, int >I<options>B<);>
    B<int fsetxattr (int >I<descripteur>B<, const char\ *>I<nom>B<,>
    B<               const void\ *>I<valeur>B<, size_t >I<taille>B<, int >I<options>B<);>

note: type: Plain text
en: B<setxattr>()  sets the I<value> of the extended attribute identified by I<name> and associated with the given I<path> in the filesystem.  The I<size> of the I<value> must be specified.
fr: B<setxattr>()  écrit la I<valeur> dans l'attribut étendu identifié par le I<nom> et associé avec le I<chemin> dans le système de fichiers La I<taille> de la I<valeur> doit être indiquée

note: type: Plain text
en: B<lsetxattr>()  is identical to B<setxattr>(), except in the case of a symbolic link, where the extended attribute is set on the link itself, not the file that it refers to.
fr: B<lsetxattr>()  est identique à B<setxattr>(), sauf dans le cas d'un lien symbolique, où il traite le lien lui-même et non le fichier qu'il vise.

note: type: Plain text
en: B<fsetxattr>()  is identical to B<setxattr>(), only the extended attribute is set on the open file referred to by I<fd> (as returned by B<open>(2))  in place of I<path>.
fr: B<fsetxattr>()  est identique à B<setxattr>(), seulement on écrit l'attribut du fichier ouvert indiqué par le I<descripteur> (renvoyé par B<open>(2))  plutôt que par un I<chemin>.

note: type: Plain text
en: An extended attribute name is a simple null-terminated string.  The I<name> includes a namespace prefix; there may be several, disjoint namespaces associated with an individual inode.  The I<value> of an extended attribute is a chunk of arbitrary textual or binary data of specified length.
fr: Le I<nom> d'un attribut étendu est une simple chaîne terminée par un octet nul. Le nom inclut un préfixe d'espace de noms - il peut y avoir plusieurs espaces de noms disjoints associés avec un inœud donné. La valeur d'un attribut étendu est un bloc de données littérales ou binaires d'une longueur donnée.

note: type: Plain text
en: The I<flags> argument can be used to refine the semantics of the operation.  B<XATTR_CREATE> specifies a pure create, which fails if the named attribute exists already.  B<XATTR_REPLACE> specifies a pure replace operation, which fails if the named attribute does not already exist.  By default (no flags), the extended attribute will be created if need be, or will simply replace the value if the attribute exists.
fr: Le paramètre I<option> permet d'affiner la sémantique de l'opétation. B<XATTR_CREATE> indique une création pure, avec un échec si l'attribut existe déjà. B<XATTR_REPLACE> indique un remplacement, échouant si l'attribut n'existe pas. Par défaut (pas d'option), l'attribut sera créé s'il le faut, ou remplacé s'il existe déjà.

note: type: Plain text
en: Disk quota limits meant that there is insufficient space remaining to store the extended attribute.
fr: Les limites de quota de disque indiquaient un espace insuffisant pour stocker l'attribut étendu.

note: type: Plain text
en: B<XATTR_CREATE> was specified, and the attribute exists already.
fr: B<XATTR_CREATE> a été indiqué et l'attribut existe déjà.

note: type: Plain text
en: B<XATTR_REPLACE> was specified, and the attribute does not exist.  (B<ENOATTR> is defined to be a synonym for B<ENODATA> in I<E<lt>attr/xattr.hE<gt>>.)
fr: B<XATTR_CREATE> a été indiqué et l'attribut n'existe pas (B<ENOATTR> est défini comme un synonyme de B<ENODATA> dans I<E<lt>attr/xattr.hE<gt>>).

note: type: Plain text
en: There is insufficient space remaining to store the extended attribute.
fr: Il n'y a pas suffisamment d'espace pour stocker l'attribut étendu.

note: type: Plain text
en: Extended attributes are not supported by the filesystem, or are disabled, I<errno> is set to B<ENOTSUP>.
fr: Les attributs étendus ne sont pas pris en charge par le système de fichiers ou sont désactivés, I<errno> contient B<ENOTSUP>.

note: type: TH
en: 2012-08-05
fr: 5 août 2012

note: type: Plain text
en: spu_create - create a new spu context
fr: spu_create - Créer un nouveau contexte spu

note: type: Plain text
en: I<Note>: There is no glibc wrapper for this system call; see NOTES.
fr: I<Remarque> : il n'existe pas de fonction glibc autour de cet appel système ; consultez B<NOTES>.

note: type: Plain text
en: The B<spu_create>()  system call is used on PowerPC machines that implement the Cell Broadband Engine Architecture in order to access Synergistic Processor Units (SPUs).  It creates a new logical context for an SPU in I<pathname> and returns a file descriptor associated with it.  I<pathname> must refer to a nonexistent directory in the mount point of the SPU filesystem (B<spufs>).  If B<spu_create>()  is successful, a directory is created at I<pathname> and it is populated with the files described in B<spufs>(7).
fr: L'appel système B<spu_create>() est utilisé sur les PowerPC disposant de l'architecture du processeur Cell dans le but d'accéder aux SPU (Synergistic Processor Units). Il crée un nouveau contexte logique pour un SPU dans I<pathname> et renvoie le descripteur de fichier qui lui est associé. I<pathname> doit pointer vers un répertoire qui n'existe pas sur le point de montage du système de fichiers SPU (B<spufs>). Si B<spu_create>() réussit, un répertoire est créé dans I<pathname> et est rempli par les fichiers décrits dans B<spufs>(7).

note: type: Plain text
en: When a context is created, the returned file descriptor can only be passed to B<spu_run>(2), used as the I<dirfd> argument to the B<*at> family of system calls (e.g., B<openat>(2)), or closed; other operations are not defined.  A logical SPU context is destroyed (along with all files created within the context's I<pathname> directory) once the last reference to the context has gone; this usually occurs when the file descriptor returned by B<spu_create>()  is closed.
fr: Lorsqu'un contexte est créé, le descripteur de fichier renvoyé ne peut qu'être passé à B<spu_run>(2), utilisé comme paramètre I<dirfd> pour les appels système de la famille B<*at> (par exemple, B<openat>(2)), ou fermé ; d'autres opérations ne sont pas définies. Un contexte logique SPU est détruit (avec tous les fichiers créés dans le répertoire I<pathname> du contexte) lorsque la dernière référence au contexte a disparu ; cela survient généralement lorsque le descripteur de fichier renvoyé par B<spu_create>() est fermé.

note: type: Plain text
en: The I<flags> argument can be zero or any bitwise OR-ed combination of the following constants:
fr: Le paramètre I<flags> vaut zéro ou une combinaison par un OU bit à bit des options suivantes\ :

note: type: Plain text
en: Rather than using signals for reporting DMA errors, use the I<event> argument to B<spu_run>(2).
fr: Plutôt que d'utiliser des signaux pour signaler des erreurs DMA, utiliser l'argument I<event> de B<spu_run>(2).

note: type: Plain text
en: Create an SPU gang instead of a context.  (A gang is a group of SPU contexts that are functionally related to each other and which share common scheduling parameters\(empriority and policy.  In the future, gang scheduling may be implemented causing the group to be switched in and out as a single unit.)
fr: Créer un gang SPU plutôt qu'un contexte. (Un gang est un groupe de contextes SPU qui sont en relation fonctionnelle entre eux et qui partagent des paramètres d'ordonnancement communs \(em priorité et politique. Dans le futur, l'ordonnancement de gangs pourra être implémenté faisant que le groupe soit commuté comme une unité simple.)

note: type: Plain text
en: A new directory will be created at the location specified by the I<pathname> argument.  This gang may be used to hold other SPU contexts, by providing a pathname that is within the gang directory to further calls to B<spu_create>().
fr: Un nouveau répertoire sera créé à l'endroit indiqué par l'argument I<pathname>. Le gang peut être utilisé pour tenir d'autres contextes en fournissant un nom de chemin qui soit à l'intérieur du répertoire du gang pour des appels ultérieurs à B<spu_create>().

note: type: Plain text
en: Create a context that is not affected by the SPU scheduler.  Once the context is run, it will not be scheduled out until it is destroyed by the creating process.
fr: Crée un contexte qui ne soit pas affecté par l'ordonnanceur SPU. Une fois que le contexte est lancé, il ne sera pas déplanifié jusqu'à ce qu'il soit détruit par le processus créateur.

note: type: Plain text
en: Because the context cannot be removed from the SPU, some functionality is disabled for B<SPU_CREATE_NOSCHED> contexts.  Only a subset of the files will be available in this context directory in B<spufs>.  Additionally, B<SPU_CREATE_NOSCHED> contexts cannot dump a core file when crashing.
fr: Parce que le contexte ne peut pas être supprimé de la SPU, certaines fonctionnalités sont désactivées des contextes B<SPU_CREATE_NOSCHED>. Seul un sous-ensemble de fichiers sera disponible dans le répertoire du contexte sur le système de fichiers B<spufs>. De plus, les contextes B<SPU_CREATE_NOSCHED> ne peuvent pas créer de fichier de vidage lors d'un plantage.

note: type: Plain text
en: Creating B<SPU_CREATE_NOSCHED> contexts requires the B<CAP_SYS_NICE> capability.
fr: La création de contextes B<SPU_CREATE_NOSCHED> nécessite la capacité B<CAP_SYS_NICE>.

note: type: Plain text
en: Create an isolated SPU context.  Isolated contexts are protected from some PPE (PowerPC Processing Element)  operations, such as access to the SPU local store and the NPC register.
fr: Crée un contexte SPU isolé. Les contextes isolés sont protégés de certaines opérations PPE (PowerPC Processing Element), comme l'accès au stockage local de la SPU ou au registre NPC.

note: type: Plain text
en: Creating B<SPU_CREATE_ISOLATE> contexts also requires the B<SPU_CREATE_NOSCHED> flag.
fr: La création de contextes B<SPU_CREATE_ISOLATE> nécessite également l'attribut B<SPU_CREATE_NOSCHED>.

note: type: Plain text
en: Create a context with affinity to another SPU context.  This affinity information is used within the SPU scheduling algorithm.  Using this flag requires that a file descriptor referring to the other SPU context be passed in the I<neighbor_fd> argument.
fr: Crée un contexte avec l'affinité d'un autre contexte SPU. Cette information d'affinité est utilisée dans l'algorithme d'ordonnancement du SPU. L'utilisation de cet attribut nécessite que le descripteur de fichier référençant l'autre contexte SPU soit passé dans l'argument I<neighbor_fd>.

note: type: Plain text
en: Create a context with affinity to system memory.  This affinity information is used within the SPU scheduling algorithm.
fr: Crée un contexte avec l'affinité de la mémoire système. Cette information d'affinité est utilisée dans l'algorithme d'ordonnancement du SPU.

note: type: Plain text
en: The I<mode> argument (minus any bits set in the process's B<umask>(2))  specifies the permissions used for creating the new directory in B<spufs>.  See B<stat>(2)  for a full list of the possible I<mode> values.
fr: Le paramètre I<mode> (sauf les bits positionnés dans l'B<umask>(2) du processus) indique les permissions utilisées pour créer le nouveau répertoire sur le système de fichiers B<spufs>. Consultez B<stat>(2) pour une liste complète des valeurs de I<mode>.

note: type: Plain text
en: On success, B<spu_create>()  returns a new file descriptor.  On error, -1 is returned, and I<errno> is set to one of the error codes listed below.
fr: S'il réussit, B<spu_create>() renvoie un nouveau descripteur de fichier. En cas d'erreur, il renvoie -1 et I<errno> contient l'un des codes d'erreur listés ci-dessous.

note: type: Plain text
en: The current user does not have write access to the B<spufs>(7)  mount point.
fr: L'utilisateur en cours n'a pas accès au point de montage du B<spufs>(7).

note: type: Plain text
en: An SPU context already exists at the given pathname.
fr: Un contexte SPU existe déjà dans le chemin fourni.

note: type: Plain text
en: I<pathname> is not a valid string pointer in the calling process's address space.
fr: I<pathname> n'est pas un pointeur de chaîne valable dans l'espace d'adresses du processus appelant.

note: type: Plain text
en: I<pathname> is not a directory in the B<spufs>(7)  mount point, or invalid flags have been provided.
fr: I<pathname> n'est pas un répertoire du point de montage du B<spufs>(7), ou des options non valables ont été fournies.

note: type: Plain text
en: Too many symbolic links were found while resolving I<pathname>.
fr: Trop de liens symboliques trouvés lors de la résolution de I<pathname>.

note: type: Plain text
en: The process has reached its maximum open files limit.
fr: Le processus a atteint sa limite du nombre de fichiers ouverts.

note: type: Plain text
en: I<pathname> is too long.
fr: I<pathname> est trop long.

note: type: Plain text
en: The system has reached the global open files limit.
fr: Le système a atteint la limite globale du nombre de fichiers ouverts.

note: type: Plain text
en: An isolated context was requested, but the hardware does not support SPU isolation.
fr: Un contexte isolé a été demandé mais le matériel ne prend pas en charge l'isolation SPU.

note: type: Plain text
en: Part of I<pathname> could not be resolved.
fr: Une partie de I<pathname> n'a pas pu être résolue.

note: type: Plain text
en: The kernel could not allocate all resources required.
fr: Le noyau n'a pas pu allouer toutes les ressources nécessaires.

note: type: Plain text
en: There are not enough SPU resources available to create a new context or the user-specific limit for the number of SPU contexts has been reached.
fr: Il n'y a pas suffisamment de ressources SPU disponibles pour créer un nouveau contexte ou la limite spécifique à l'utilisateur du nombre de contextes SPU a été atteinte.

note: type: Plain text
en: The functionality is not provided by the current system, because either the hardware does not provide SPUs or the spufs module is not loaded.
fr: La fonctionnalité n'est par fournie par le système actuel parce que le matériel ne fournit pas de SPU ou parce que le module spufs n'est pas chargé.

note: type: Plain text
en: A part of I<pathname> is not a directory.
fr: Un élément du chemin d'accès I<pathname> n'est pas un répertoire.

note: type: Plain text
en: The I<SPU_CREATE_NOSCHED> flag has been given, but the user does not have the B<CAP_SYS_NICE> capability.
fr: L'attribut B<SPU_CREATE_NOSCHED> a été fourni mais l'utilisateur n'a pas la capacité B<CAP_SYS_NICE>.

note: type: Plain text
en: I<pathname> must point to a location beneath the mount point of B<spufs>.  By convention, it gets mounted in I</spu>.
fr: I<pathname> doit pointer vers un emplacement du point de montage du B<spufs>, qui est monté par convention dans I</spu>.

note: type: Plain text
en: The B<spu_create>()  system call was added to Linux in kernel 2.6.16.
fr: L'appel système B<spu_create>() est apparu dans Linux 2.6.16.

note: type: Plain text
en: This call is Linux-specific and implemented only on the PowerPC architecture.  Programs using this system call are not portable.
fr: Cet appel système est spécifique à Linux et implémenté uniquement sur l'architecture PowerPC. Les programmes qui l'utilisent ne sont pas portables.

note: type: Plain text
en: Glibc does not provide a wrapper for this system call; call it using B<syscall>(2).  Note however, that B<spu_create>()  is meant to be used from libraries that implement a more abstract interface to SPUs, not to be used from regular applications.  See E<.UR http://www.bsc.es\:/projects\:/deepcomputing\:/linuxoncell/> E<.UE> for the recommended libraries.
fr: La glibc ne fournit pas de fonction pour cet appel système : utilisez B<syscall>(2) pour l'appeler. Notez cependant que B<spu_create>() est conçu pour être appelé depuis des bibliothèques qui implémentent une interface plus abstraite pour les SPU, pas pour être appelé directement par les applications normales. Consultez E<.UR http://www.bsc.es\:/projects\:/deepcomputing\:/linuxoncell/> E<.UE> pour les bibliothèques recommandées.

note: type: Plain text
en: See B<spu_run>(2)  for an example of the use of B<spu_create>()
fr: Consultez B<spu_run>(2) pour un exemple d'utilisation de B<spu_create>()

note: type: Plain text
en: spu_run - execute an SPU context
fr: spu_run - Exécuter un contexte SPU

note: type: Plain text
en: The B<spu_run>()  system call is used on PowerPC machines that implement the Cell Broadband Engine Architecture in order to access Synergistic Processor Units (SPUs).  The I<fd> argument is a file descriptor returned by B<spu_create>(2)  that refers to a specific SPU context.  When the context gets scheduled to a physical SPU, it starts execution at the instruction pointer passed in I<npc>.
fr: L'appel système B<spu_run>() est utilisé sur les PowerPC disposant de l'architecture du processeur Cell dans le but d'accéder aux SPUs (Synergistic Processor Units). L'argument I<fd> est un descripteur de fichiers renvoyé par B<spu_create>(2) qui se réfère à un contexte SPU spécifique. Lorsque le contexte est livré à un SPU physique, il démarre son exécution au pointeur d'instruction passé à I<npc>.

note: type: Plain text
en: Execution of SPU code happens synchronously, meaning that B<spu_run>()  blocks while the SPU is still running.  If there is a need to execute SPU code in parallel with other code on either the main CPU or other SPUs, a new thread of execution must be created first (e.g., using B<pthread_create>(3)).
fr: L'exécution du code SPU se fait de manière synchrone. C'est pourquoi B<spu_run>() est bloquant tant que le SPU fonctionne. S'il est nécessaire d'exécuter du code SPU en parallèle avec d'autres codes, que se soit sur le processeur principal ou sur d'autres SPU, un nouveau thread doit d'abord être créé (par exemple en utilisant B<pthread_create>(3)).

note: type: Plain text
en: When B<spu_run>()  returns, the current value of the SPU program counter is written to I<npc>, so successive calls to B<spu_run>()  can use the same I<npc> pointer.
fr: Lorsque B<spu_run>() revient, la valeur courante du pointeur d'instruction SPU est écrite à I<npc>, donc il est possible d'appeler B<spu_run>() de nouveau avec le même pointeur I<npc>.

note: type: Plain text
en: The I<event> argument provides a buffer for an extended status code.  If the SPU context was created with the B<SPU_CREATE_EVENTS_ENABLED> flag, then this buffer is populated by the Linux kernel before B<spu_run>()  returns.
fr: Le paramètre I<event> fournit un tampon pour un code d'état étendu. Si le contexte SPU a été créé avec l'attribut B<SPU_CREATE_EVENTS_ENABLED>, ce tampon sera rempli par le noyau Linux avant que B<spu_run>() revienne.

note: type: Plain text
en: The status code may be one (or more) of the following constants:
fr: Le code d'état peut être l'une (ou plus) des constantes suivantes :

note: type: Plain text
en: A DMA alignment error occurred.
fr: Une erreur d'alignement DMA s'est produite.

note: type: Plain text
en: An invalid MFC DMA command was attempted.
fr: Une commande MFC DMA invalide a été tentée.

note: type: Plain text
en: A DMA storage error occurred.
fr: Une erreur de stockage DMA s'est produite.

note: type: Plain text
en: An illegal instruction was executed.
fr: Une instruction illégale a été exécutée.

note: type: Plain text
en: NULL is a valid value for the I<event> argument.  In this case, the events will not be reported to the calling process.
fr: NULL est une valeur valable pour le paramètre I<event>. Dans ce cas, les événements ne seront pas remontés au processus appelant.

note: type: Plain text
en: On success, B<spu_run>()  returns the value of the I<spu_status> register.  On error, it returns -1 and sets I<errno> to one of the error codes listed below.
fr: En cas de succès, B<spu_run>() renvoie la valeur du registre I<spu_status>. En cas d'erreur, l'appel renvoie -1 et positionne I<errno> à l'un des codes d'erreur listés ci-dessous.

note: type: Plain text
en: The I<spu_status> register value is a bit mask of status codes and optionally a 14-bit code returned from the B<stop-and-signal> instruction on the SPU.  The bit masks for the status codes are:
fr: La valeur du registre I<spu_status> est un masque de bits de code d'erreurs et en option d'un code de retour de 14 bits provenant de l'instruction B<stop-and-signal> du SPU. Les bits des masques du code de retour sont :

note: type: Plain text
en: SPU was stopped by a B<stop-and-signal> instruction.
fr: Le SPU a été stoppé par une instruction B<stop-and-signal>.

note: type: Plain text
en: SPU was stopped by a B<halt> instruction.
fr: Le SPU a été arrêté par une instruction B<halt>.

note: type: Plain text
en: SPU is waiting for a channel.
fr: Le SPU est en attente d'un canal.

note: type: Plain text
en: SPU is in single-step mode.
fr: Le SPU est en mode single-step.

note: type: Plain text
en: SPU has tried to execute an invalid instruction.
fr: SPU a essayé d'exécuter une instruction non valable.

note: type: Plain text
en: SPU has tried to access an invalid channel.
fr: SPU a essayé d'accéder à un canal non valable.

note: type: Plain text
en: The bits masked with this value contain the code returned from a B<stop-and-signal> instruction.  These bits are valid only if the 0x02 bit is set.
fr: Les bits masqués avec cette valeur contiennent le code renvoyé par une instruction B<stop-and-signal>. Ces bits ne sont valables que si le bit 0x02 est positionné.

note: type: Plain text
en: If B<spu_run>()  has not returned an error, one or more bits among the lower eight ones are always set.
fr: Si B<spu_run>() ne renvoie pas d'erreur, au moins un des huit bits de poids faible est toujours positionné.

note: type: Plain text
en: I<fd> is not a valid file descriptor.
fr: I<fd> n'est pas un descripteur de fichier valable.

note: type: Plain text
en: I<npc> is not a valid pointer, or I<event> is non-NULL and an invalid pointer.
fr: I<npc> n'est pas un pointeur valable ou I<event> n'est ni NULL ni un pointeur valable.

note: type: Plain text
en: A signal occurred while B<spu_run>()  was in progress; see B<signal>(7).  The I<npc> value has been updated to the new program counter value if necessary.
fr: Un signal est apparu pendant la progression de B<spu_run>() ; consultez B<signal>(7). La valeur I<npc> a été mise à jour à la nouvelle valeur du compteur de programme si nécessaire.

note: type: Plain text
en: I<fd> is not a valid file descriptor returned from B<spu_create>(2).
fr: I<fd> n'est pas un descripteur de fichier valable renvoyé par B<spu_create>(2).

note: type: Plain text
en: There was not enough memory available to handle a page fault resulting from a Memory Flow Controller (MFC) direct memory access.
fr: Il n'y a pas suffisamment de mémoire disponible pour gérer une faute de page résultant d'un accès direct à la mémoire d'un MFC (« Memory Flow Controller »).

note: type: Plain text
en: The B<spu_run>()  system call was added to Linux in kernel 2.6.16.
fr: L'appel système B<spu_run>() est apparu dans Linux 2.6.16.

note: type: Plain text
en: This call is Linux-specific and implemented only by the PowerPC architecture.  Programs using this system call are not portable.
fr: Cet appel système est spécifique à Linux et implémenté uniquement sur l'architecture PowerPC. Les programmes qui l'utilisent ne sont pas portables.

note: type: Plain text
en: Glibc does not provide a wrapper for this system call; call it using B<syscall>(2).  Note however, that B<spu_run>()  is meant to be used from libraries that implement a more abstract interface to SPUs, not to be used from regular applications.  See E<.UR http://www.bsc.es\:/projects\:/deepcomputing\:/linuxoncell/> E<.UE> for the recommended libraries.
fr: La glibc ne fournit pas de fonction pour cet appel système : utilisez B<syscall>(2) pour l'appeler. Notez cependant que B<spu_run>() est conçu pour être appelé depuis des bibliothèques qui implémentent une interface plus abstraite pour les SPU, pas pour être appelé directement par les applications normales. Consultez E<.UR http://www.bsc.es\:/projects\:/deepcomputing\:/linuxoncell/> E<.UE> pour les bibliothèques recommandées.

note: type: Plain text
en: The following is an example of running a simple, one-instruction SPU program with the B<spu_run>()  system call.
fr: Vous trouverez ci-dessous un exemple pour lancer un programme simple, d'une instruction SPU, utilisant l'appel système B<spu_run>().

note: type: TH
en: 2007-12-20
fr: 20 décembre 2007

note: type: Plain text
en: spufs - SPU filesystem
fr: spufs - Système de fichiers SPU

note: type: Plain text
en: The SPU filesystem is used on PowerPC machines that implement the Cell Broadband Engine Architecture in order to access Synergistic Processor Units (SPUs).
fr: Le système de fichiers SPU est utilisé sur les machines PowerPC qui utilisent l'architecture Cell Broadband Engine Architecture pour accéder aux SPU (« Synergistic Processor Units »).

note: type: Plain text
en: The filesystem provides a name space similar to POSIX shared memory or message queues.  Users that have write permissions on the filesystem can use B<spu_create>(2)  to establish SPU contexts under the B<spufs> root directory.
fr: Le système de fichiers fournit un espace de noms similaire à la mémoire partagée ou aux queues de messages POSIX. Les utilisateurs qui ont la permission d'écrire sur le système de fichiers peuvent utiliser B<spu_create>(2) pour établir des contextes SPU dans le répertoire racine du B<spufs>.

note: type: Plain text
en: Every SPU context is represented by a directory containing a predefined set of files.  These files can be used for manipulating the state of the logical SPU.  Users can change permissions on the files, but can't add or remove files.
fr: Chaque contexte SPU est représenté par un répertoire contenant un jeu de fichiers prédéfinis. Ces fichiers peuvent être utilisés pour manipuler l'état du SPU logique. Les utilisateurs peuvent changer les permissions des fichiers, mais ne peuvent ni en ajouter ni en supprimer.

note: type: SS
en: Mount options
fr: Options de montage

note: type: Plain text
en: Set the user owning the mount point; the default is 0 (root).
fr: Définit l'utilisateur propriétaire du point de montage ; 0 par défaut (root).

note: type: Plain text
en: Set the group owning the mount point; the default is 0 (root).
fr: Définit le groupe propriétaire du point de montage ; 0 par défaut (root).

note: type: Plain text
en: Set the mode of the top-level directory in B<spufs>, as an octal mode string.  The default is 0775.
fr: Définir le mode du répertoire de plus haut niveau du B<spufs> sous la forme d'une chaîne de valeur octale. La valeur par défaut est 0775.

note: type: SS
en: Files
fr: Fichiers

note: type: Plain text
en: The files in B<spufs> mostly follow the standard behavior for regular system calls like B<read>(2)  or B<write>(2), but often support only a subset of the operations supported on regular filesystems.  This list details the supported operations and the deviations from the standard behavior described in the respective man pages.
fr: Les fichiers du B<spufs> se comportent majoritairement de façon standard pour les appels système comme B<read>(2) ou B<write>(2), mais ne gèrent souvent qu'une fraction des opérations permises par les systèmes de fichiers normaux. Cette liste détaille les opérations gérées et les dérogations par rapport aux comportements standards qui sont décrits dans les différentes pages de manuel.

note: type: Plain text
en: All files that support the B<read>(2)  operation also support B<readv>(2)  and all files that support the B<write>(2)  operation also support B<writev>(2).  All files support the B<access>(2)  and B<stat>(2)  family of operations, but for the latter call, the only fields of the returned I<stat> structure that contain reliable information are I<st_mode>, I<st_nlink>, I<st_uid>, and I<st_gid>.
fr: Tous les fichiers qui gèrent l'opération B<read>(2) gèrent également B<readv>(2) et tous les fichiers qui gèrent l'opération B<write>(2) gèrent aussi B<writev>(2). Tous les fichiers gèrent les familles d'opérations B<access>(2) B<stat>(2), mais pour cette dernière famille, les seuls champs de la structure I<stat> renvoyée qui contiennent des informations fiables sont I<st_mode>, I<st_nlink>, I<st_uid> et I<st_gid>.

note: type: Plain text
en: All files support the B<chmod>(2)/B<fchmod>(2)  and B<chown>(2)/B<fchown>(2)  operations, but will not be able to grant permissions that contradict the possible operations (e.g., read access on the I<wbox> file).
fr: Tous les fichiers gèrent les opérations B<chmod>(2)/B<fchmod>(2) et B<chown>(2)/B<fchown>(2), mais ne permettront pas des autorisations d'accès qui contredisent les opérations possibles pour un fichier (par exemple, l'accès en lecture pour un fichier I<wbox>).

note: type: Plain text
en: The current set of files is:
fr: Le jeux actuel de fichiers est :

note: type: Plain text
en: Contains a comma-delimited string representing the capabilities of this SPU context.  Possible capabilities are:
fr: Contient une chaîne représentant les capacités, séparées par des virgules, de ce contexte SPU. Les capacités possibles sont :

note: type: Plain text
en: This context may be scheduled.
fr: Ce contexte peut être ordonnancé.

note: type: Plain text
en: This context can be run in single-step mode, for debugging.
fr: Ce contexte peut être exécuté en mode pas-à-pas, pour débogage.

note: type: Plain text
en: New capabilities flags may be added in the future.
fr: De nouveaux attributs de capacités pourront être ajoutés dans le futur.

note: type: Plain text
en: the contents of the local storage memory of the SPU.  This can be accessed like a regular shared memory file and contains both code and data in the address space of the SPU.  The possible operations on an open I<mem> file are:
fr: Le contenu de la mémoire de stockage locale du SPU. On peut y accéder comme à un fichier de mémoire partagé standard et il contient à la fois le code et les données de l'espace d'adressage du SPU. Les opérations possibles sur un fichier I<mem> ouvert sont :

note: type: Plain text
en: These operate as usual, with the exception that B<lseek>(2), B<write>(2), and B<pwrite>(2)  are not supported beyond the end of the file.  The file size is the size of the local storage of the SPU, which is normally 256 kilobytes.
fr: Elles opèrent normalement, à l'exception de B<lseek>(2), B<write>(2) et B<pwrite>(2) qui ne sont pas gérées en dehors des limites du fichier. La taille du fichier est la taille de l'espace de stockage local du SPU, qui est normalement de 256 kilooctets.

note: type: Plain text
en: Mapping I<mem> into the process address space provides access to the SPU local storage within the process address space.  Only B<MAP_SHARED> mappings are allowed.
fr: La projection de I<mem> dans l'espace d'adressage du processus donne accès à l'espace de stockage local du SPU depuis l'espace d'adressage du processus. Seules les projections B<MAP_SHARED> sont autorisées.

note: type: Plain text
en: Contains the saved general-purpose registers of the SPU context.  This file contains the 128-bit values of each register, from register 0 to register 127, in order.  This allows the general-purpose registers to be inspected for debugging.
fr: Contient la sauvegarde des registres à vocation générale du contexte SPU. Ce fichier contient les valeurs 128 bits de chaque registre, du registre 0 au registre 127, dans l'ordre. Cela permet de consulter le contenu de ces registres à vocation générale à des fins de débogage.

note: type: Plain text
en: Reading to or writing from this file requires that the context is scheduled out, so use of this file is not recommended in normal program operation.
fr: La lecture ou l'écriture dans ce fichier nécessite que le contexte ne soit pas ordonnancé, aussi, l'utilisation de ce fichier n'est pas recommandé lors de l'exécution normale d'un programme.

note: type: Plain text
en: The I<regs> file is not present on contexts that have been created with the B<SPU_CREATE_NOSCHED> flag.
fr: Le fichier I<regs> n'existe pas pour les contextes créés avec l'attribut B<SPU_CREATE_NOSCHED>.

note: type: Plain text
en: The first SPU-to-CPU communication mailbox.  This file is read-only and can be read in units of 4 bytes.  The file can be used only in nonblocking mode - even B<poll>(2)  cannot be used to block on this file.  The only possible operation on an open I<mbox> file is:
fr: La première boîte aux lettres pour la communication entre SPU et CPU. Ce fichier est en lecture seule et peut être lu par unités de 4 octets. Le fichier peut uniquement être utilisé en mode non bloquant - même B<poll>(2) ne peut pas être utuilisé pour se bloquer sur ce fichier. La seule opération possible sur un fichier I<mbox> ouvert est :

note: type: Plain text
en: If I<count> is smaller than four, B<read>(2)  returns -1 and sets I<errno> to B<EINVAL>.  If there is no data available in the mailbox (i.e., the SPU has not sent a mailbox message), the return value is set to -1 and I<errno> is set to B<EAGAIN>.  When data has been read successfully, four bytes are placed in the data buffer and the value four is returned.
fr: Si I<count> est plus petit que quatre, B<read>(2) renvoie -1 et positionne I<errno> à B<EINVAL>. S'il n'y a pas de donnée disponible dans la boîte aux lettres (c'est-à-dire si le SPU n'a pas envoyé de message dans la boîte aux lettres), la valeur de retour est -1 et I<errno> est positionnée à B<EAGAIN>. Quand des données ont été lues avec succès, quatre octets sont placés dans le tampon de données et la valeur renvoyée est quatre.

note: type: Plain text
en: The second SPU-to-CPU communication mailbox.  This file is similar to the first mailbox file, but can be read in blocking I/O mode, thus calling B<read>(2)  on an open I<ibox> file will block until the SPU has written data to its interrupt mailbox channel (unless the file has been opened with B<O_NONBLOCK>, see below).  Also, B<poll>(2)  and similar system calls can be used to monitor for the presence of mailbox data.
fr: La deuxième boîte aux lettres pour la communication entre SPU et CPU. Ce fichier est similaire au premier fichier de boîte aux lettres, mais peut être lu en mode bloquant, ainsi appeler B<read>(2) sur un fichier I<ibox> ouvert bloquera tant que le SPU n'a pas écrit dans son canal boîte à lettres (à moins que le fichier n'ait été ouvert avec B<O_NONBLOCK>, voir ci-dessous). Également, B<poll>(2) et des appels système similaires peuvent être utilisés pour surveiller la présence de données dans la boîte à lettres.

note: type: Plain text
en: The possible operations on an open I<ibox> file are:
fr: Les opérations possibles sur un fichier I<ibox> ouvert sont :

note: type: Plain text
en: If I<count> is smaller than four, B<read>(2)  returns -1 and sets I<errno> to B<EINVAL>.  If there is no data available in the mailbox and the file descriptor has been opened with B<O_NONBLOCK>, the return value is set to -1 and I<errno> is set to B<EAGAIN>.
fr: Si I<count> est plus petit que quatre, B<read>(2) renvoie -1 et positionne I<errno> à B<EINVAL>. S'il n'y a pas de donnée disponible dans la boîte aux lettres et que le fichier a été ouvert avec B<O_NONBLOCK>, la valeur renvoyée est -1 et I<errno> est positionnée à B<EAGAIN>.

note: type: Plain text
en: If there is no data available in the mailbox and the file descriptor has been opened without B<O_NONBLOCK>, the call will block until the SPU writes to its interrupt mailbox channel.  When data has been read successfully, four bytes are placed in the data buffer and the value four is returned.
fr: S'il n'y a pas de donnée disponible dans la boîte aux lettres et que le fichier a été ouvert sans l'attribut B<O_NONBLOCK>, l'appel bloquera jusqu'à ce que le SPU écrive dans son canal d'interruption de la boîte aux lettres. Quand des données ont été lues avec succès, quatre octets sont placés dans le tampon de données et la valeur quatre est renvoyée.

note: type: Plain text
en: Poll on the I<ibox> file returns I<(POLLIN | POLLRDNORM)> whenever data is available for reading.
fr: L'appel de B<poll>(2) sur le fichier I<ibox> renvoie I<(POLLIN | POLLRDNORM)> quand des données sont disponibles en lecture.

note: type: Plain text
en: The CPU-to-SPU communication mailbox.  It is write-only and can be written in units of four bytes.  If the mailbox is full, B<write>(2)  will block, and B<poll>(2)  can be used to block until the mailbox is available for writing again.  The possible operations on an open I<wbox> file are:
fr: La boîte aux lettres pour la communication entre CPU et SPU. Elle est en écriture seulement et on peut y écrire des données de 32 bits. Si la boîte aux lettres est pleine, B<write>(2) bloque et B<poll>(2) peut être utilisé pour bloquer jusqu'à ce qu'il soit possible d'écrire dans la boîte aux lettres. Les opérations possibles sur un fichier I<wbox> ouvert sont :

note: type: Plain text
en: If I<count> is smaller than four, B<write>(2)  returns -1 and sets I<errno> to B<EINVAL>.  If there is no space available in the mailbox and the file descriptor has been opened with B<O_NONBLOCK>, the return value is set to -1 and I<errno> is set to B<EAGAIN>.
fr: Si I<count> est plus petit que quatre, B<write>(2) renvoie -1 et positionne I<errno> à B<EINVAL>. S'il n'y a pas d'espace disponible dans la boîte aux lettres et que le fichier a été ouvert avec B<O_NONBLOCK>, la valeur renvoyée est -1 et I<errno> est positionnée à B<EAGAIN>.

note: type: Plain text
en: If there is no space available in the mailbox and the file descriptor has been opened without B<O_NONBLOCK>, the call will block until the SPU reads from its PPE (PowerPC Processing Element)  mailbox channel.  When data has been written successfully, the system call returns four as its function result.
fr: S'il n'y a pas d'espace disponible dans la boîte aux lettres et que le fichier a été ouvert sans l'attribut B<O_NONBLOCK>, l'appel bloque jusqu'à ce que le SPU lise dans le canal de sa boîte aux lettres PPE (PowerPC Processing Element). Quand des données ont été écrites avec succès, l'appel système renvoie 4 comme résultat de la fonction.

note: type: Plain text
en: A poll on the I<wbox> file returns I<(POLLOUT | POLLWRNORM)> whenever space is available for writing.
fr: Un appel à B<poll>(2) sur le fichier I<wbox> renvoie I<(POLLOUT | POLLWRNORM)> quand de l'espace est disponible en écriture.

note: type: Plain text
en: These are read-only files that contain the length of the current queue of each mailbox\(emthat is, how many words can be read from I<mbox> or I<ibox> or how many words can be written to I<wbox> without blocking.  The files can be read only in four-byte units and return a big-endian binary integer number.  The only possible operation on an open I<*box_stat> file is:
fr: Ce sont des fichiers en lecture seule qui contiennent la taille des différentes queues des boîtes aux lettres, c'est-à-dire le nombre de mots qui peuvent être lus dans I<mbox> ou I<ibox> ou peuvent être écrits dans I<wbox> sans bloquer. Ces fichiers ne peuvent être lus que par blocs de quatre octets et renvoient un nombre entier avec un codage grand boutiste (« big endian ». La seule opération possible sur un fichier I<*box_stat> ouvert est :

note: type: Plain text
en: If I<count> is smaller than four, B<read>(2)  returns -1 and sets I<errno> to B<EINVAL>.  Otherwise, a four-byte value is placed in the data buffer.  This value is the number of elements that can be read from (for I<mbox_stat> and I<ibox_stat>)  or written to (for I<wbox_stat>)  the respective mailbox without blocking or returning an B<EAGAIN> error.
fr: Si I<count> est plus petit que quatre, B<read>(2) renvoie -1 et positionne I<errno> à B<EINVAL>. Sinon, une valeur de quatre octets est placée dans le tampon de données. Cette valeur est le nombre d'éléments qui peuvent être lus (pour I<mbox_stat> et I<ibox_stat>) ou écrits (pour I<wbox_stat>) dans les boîtes aux lettres respectives sans bloquer ou renvoyer une erreur B<EAGAIN>.

note: type: Plain text
en: Internal registers of the SPU.  These files contain an ASCII string representing the hex value of the specified register.  Reads and writes on these files (except for I<npc>, see below) require that the SPU context be scheduled out, so frequent access to these files is not recommended for normal program operation.
fr: Les registres internes du SPU. Ces fichiers contiennent une chaîne de caractère ASCII représentant la valeur hexadécimale du registre indiqué. Lire et écrire dans ces fichiers (hormis I<npc>, voir ci-dessous) nécessite que le contexte du SPU ne soit pas ordonnancé, aussi, les accès fréquents à ces fichiers ne sont pas recommandés lors de l'exécution normale d'un programme.

note: type: Plain text
en: The contents of these files are:
fr: Le contenu des fichiers est :

note: type: Plain text
en: Next Program Counter - valid only when the SPU is in a stopped state.
fr: Compteur programme suivant - Valide uniquement lorsque le SPU est dans un état arrêté.

note: type: Plain text
en: SPU Decrementer
fr: Décrémenteur SPU

note: type: Plain text
en: Decrementer Status
fr: État du décrémenteur

note: type: Plain text
en: MFC tag mask for SPU DMA
fr: Masque de attributs MFC pour le DMA SPU

note: type: Plain text
en: Event mask for SPU interrupts
fr: Masque d'événements pour les interruptions SPU

note: type: Plain text
en: Number of SPU events pending (read-only)
fr: Nombre d'événements SPU en attente (lecture seule)

note: type: Plain text
en: Interrupt Return address register
fr: Registre contenant l'adresse de retour d'interruption

note: type: Plain text
en: Local Store Limit Register
fr: Registre de limite de stokage local

note: type: Plain text
en: The possible operations on these files are:
fr: Les opérations possibles sur ces fichiers sont :

note: type: Plain text
en: Reads the current register value.  If the register value is larger than the buffer passed to the B<read>(2)  system call, subsequent reads will continue reading from the same buffer, until the end of the buffer is reached.
fr: Lit la valeur actuelle du registre. Si la valeur du registre est plus grande que le tampon passé à B<read>(2), les lectures suivantes continueront à lire à partir du même tampon jusqu'à ce que la fin du tampon soit atteinte.

note: type: Plain text
en: When a complete string has been read, all subsequent read operations will return zero bytes and a new file descriptor needs to be opened to read a new value.
fr: Lorsqu'une chaîne complète a été lue, toutes les opérations de lecture suivantes renverront zéro octet et il faudra ouvrir un nouveau descripteur de fichier pour lire une nouvelle valeur.

note: type: Plain text
en: A B<write>(2)  operation on the file sets the register to the value given in the string.  The string is parsed from the beginning until the first nonnumeric character or the end of the buffer.  Subsequent writes to the same file descriptor overwrite the previous setting.
fr: Un appel à B<write>(2) sur le fichier définit le registre à la valeur fournie dans la chaîne. La chaîne est analysée du début jusqu'au premier caractère non numérique ou jusqu'à la fin du tampon. Les écritures suivantes sur le même descripteur de fichier remplaceront les précédentes écritures.

note: type: Plain text
en: Except for the I<npc> file, these files are not present on contexts that have been created with the B<SPU_CREATE_NOSCHED> flag.
fr: Excepté pour le fichier I<npc>, ces fichiers n'existent pas dans les contextes créés avec l'attribut B<SPU_CREATE_NOSCHED>.

note: type: Plain text
en: This file provides access to the Floating Point Status and Control Register (fcpr) as a binary, four-byte file.  The operations on the I<fpcr> file are:
fr: Ce fichier donne accès au registre d'état et de contrôle pour la virgule flottante (Floating Point Status and Control Register, fcpr) comme un fichier binaire de quatre octets. Les opérations pour le fichier I<fpcr> sont :

note: type: Plain text
en: If I<count> is smaller than four, B<read>(2)  returns -1 and sets I<errno> to B<EINVAL>.  Otherwise, a four-byte value is placed in the data buffer; this is the current value of the I<fpcr> register.
fr: Si I<count> est plus petit que quatre, B<read>(2) renvoie -1 et positionne I<errno> à B<EINVAL>. Sinon, une valeur de quatre octets est placée dans le tampon de données ; c'est la valeur actuelle du registre I<fpcr>.

note: type: Plain text
en: If I<count> is smaller than four, B<write>(2)  returns -1 and sets I<errno> to B<EINVAL>.  Otherwise, a four-byte value is copied from the data buffer, updating the value of the I<fpcr> register.
fr: Si I<count> est plus petit que quatre, B<write>(2) renvoie -1 et positionne I<errno> à B<EINVAL>. Sinon, une valeur de quatre octets est copiée depuis le tampon de données, mettant à jour la valeur du registre I<fpcr>.

note: type: Plain text
en: The files provide access to the two signal notification channels of an SPU.  These are read-write files that operate on four-byte words.  Writing to one of these files triggers an interrupt on the SPU.  The value written to the signal files can be read from the SPU through a channel read or from host user space through the file.  After the value has been read by the SPU, it is reset to zero.  The possible operations on an open I<signal1> or I<signal2> file are:
fr: Le fichier donne accès aux deux canaux de notification de signal d'un SPU. Ce sont des fichiers en lecture et écriture qui utilisent des mots de quatre octets. Écrire dans un de ces fichiers déclenche une interruption sur le SPU. La valeur écrite dans le fichier de signalisation peut être lue depuis le SPU au travers d'un canal de lecture ou par l'espace utilisateur sur l'hôte grâce au fichier. Les opérations possibles sur un fichier I<signal1> ou I<signal2> ouvert sont :

note: type: Plain text
en: If I<count> is smaller than four, B<read>(2)  returns -1 and sets I<errno> to B<EINVAL>.  Otherwise, a four-byte value is placed in the data buffer; this is the current value of the specified signal notification register.
fr: Si I<count> est plus petit que quatre, B<read>(2) renvoie -1 et positionne I<errno> à B<EINVAL>. Sinon, une valeur de quatre octets est placée dans le tampon de données ; c'est la valeur actuelle du registre de notification du signal indiqué.

note: type: Plain text
en: If I<count> is smaller than four, B<write>(2)  returns -1 and sets I<errno> to B<EINVAL>.  Otherwise, a four-byte value is copied from the data buffer, updating the value of the specified signal notification register.  The signal notification register will either be replaced with the input data or will be updated to the bitwise OR operation of the old value and the input data, depending on the contents of the I<signal1_type> or I<signal2_type> files respectively.
fr: Si I<count> est plus petit que quatre, B<write>(2) renvoie -1 et positionne I<errno> à B<EINVAL>. Sinon, une valeur de quatre octets est copiée depuis le tampon de données et met à jour la valeur du registre de notification du signal indiqué. Le registre de notification du signal sera soit remplacé par les données fournies en entrée ou sera mis à jour par un OU bit à bit de l'ancienne valeur et des données fournies en entrée, en fonction du contenu des fichiers I<signal1_type> ou I<signal2_type> respectivement.

note: type: Plain text
en: These two files change the behavior of the I<signal1> and I<signal2> notification files.  They contain a numeric ASCII string which is read as either "1" or "0".  In mode 0 (overwrite), the hardware replaces the contents of the signal channel with the data that is written to it.  In mode 1 (logical OR), the hardware accumulates the bits that are subsequently written to it.  The possible operations on an open I<signal1_type> or I<signal2_type> file are:
fr: Ces deux fichiers changent le comportement des fichiers de notification I<signal1> et I<signal2>. Ils contiennent une chaîne ASCII numérique qui est lue comme "1" ou "0". Dans le mode 0 (remplacement), le matériel remplace le contenu du canal du signal avec la donnée qu'on y écrit. Dans le mode 1 (OU logique), le matériel accumule les bits qui y sont écrits au fur et à mesure. Les opérations possibles sur un fichier I<signal1_type> ou I<signal2_type> sont :

note: type: Plain text
en: When the count supplied to the B<read>(2)  call is shorter than the required length for the digit (plus a newline character), subsequent reads from the same file descriptor will complete the string.  When a complete string has been read, all subsequent read operations will return zero bytes and a new file descriptor needs to be opened to read the value again.
fr: Quand le paramètre I<count> fourni à l'appel B<read>(2) est plus petit que la longueur nécessaire pour la valeur du chiffre (plus un caractère de fin de ligne), les lectures suivantes sur le même descripteur de fichier compléteront la chaîne. Quand une chaîne complète a été lue, les lectures qui suivent ne renvoient aucun octet et un nouveau descripteur de fichier doit être ouvert pour lire une nouvelle valeur.

note: type: Plain text
en: Read-only files that contain the saved state of the SPU mailboxes and DMA queues.  This allows the SPU status to be inspected, mainly for debugging.  The I<mbox_info> and I<ibox_info> files each contain the four-byte mailbox message that has been written by the SPU.  If no message has been written to these mailboxes, then contents of these files is undefined.  The I<mbox_stat>, I<ibox_stat> and I<wbox_stat> files contain the available message count.
fr: Fichiers en lecture seule qui contiennent l'état sauvegardé des boîtes à lettres SPU et des files DMA. Cela permet de pouvoir consulter l'état du SPU, principalement à des fins de débogage. Les fichiers I<mbox_info> et I<ibox_info> contiennent chacun un message de 4 octets qui a été écrit par le SPU. Si aucun message n'a été écrit dans ces boîtes à lettres, le contenu de ces fichiers est indéterminé. Les fichiers I<mbox_stat>, I<ibox_stat> et I<wbox_stat> contient le nombre de messages disponibles.

note: type: Plain text
en: The I<wbox_info> file contains an array of four-byte mailbox messages, which have been sent to the SPU.  With current CBEA machines, the array is four items in length, so up to 4 * 4 = 16 bytes can be read from this file.  If any mailbox queue entry is empty, then the bytes read at the corresponding location are undefined.
fr: Le fichier I<wbox_info> contient un tableau de messages de 4 octets qui ont été envoyés à le SPU. Sur les machines CBEA actuelles, le tableau a une longueur de 4 éléments, ainsi, on peut lire jusqu'à 4 * 4 = 16 octets. Si une entrée de file de boîte à lettres est vide, les octets lus dans l'emplacement correspondant sont indéterminés.

note: type: Plain text
en: The I<dma_info> file contains the contents of the SPU MFC DMA queue, represented as the following structure:
fr: Le fichier I<dma_info> contient le contenu de la file DMA du MFC du SPU, représenté par la structure suivante :

note: type: Plain text
en: The last member of this data structure is the actual DMA queue, containing 16 entries.  The I<mfc_cq_sr> structure is defined as:
fr: Le dernier membre de cette structure de données est la file DMA réelle contenant 16 entrées. La structure I<mfc_cq_sr> est définie ainsi :

note: type: Plain text
en: The I<proxydma_info> file contains similar information, but describes the proxy DMA queue (i.e., DMAs initiated by entities outside the SPU) instead.  The file is in the following format:
fr: Le fichier I<proxydma_info> contient des informations similaires mais décrit la file DMA proxy (c'est-à-dire, les DMA initiés par des entités extérieures au SPU). Le fichier a le format suivant :

note: type: Plain text
en: Accessing these files requires that the SPU context is scheduled out - frequent use can be inefficient.  These files should not be used for normal program operation.
fr: L'accès à ces fichiers nécessite que le contexte SPU ne soit pas ordonnancé ; une utilisation fréquente serait inefficace. Ces fichiers ne doivent pas être utilisés dans l'exécution normale d'un programme.

note: type: Plain text
en: These files are not present on contexts that have been created with the B<SPU_CREATE_NOSCHED> flag.
fr: Ces fichiers n'existent pas dans les contextes créés avec l'attribut B<SPU_CREATE_NOSCHED>.

note: type: Plain text
en: This file provides access to the SPU Run Control and SPU status registers, as an ASCII string.  The following operations are supported:
fr: Ce fichier fournit un accès aux registres de contrôle d'exécution et d'état du SPU sous forme d'une chaîne ASCII. Les opérations suivantes sont prises en charge :

note: type: Plain text
en: Reads from the I<cntl> file will return an ASCII string with the hex value of the SPU Status register.
fr: La lecture du fichier I<cntl> renverra une chaîne ASCCI contenant la valeur hexadécimale du registre d'état du SPU.

note: type: Plain text
en: Writes to the I<cntl> file will set the context's SPU Run Control register.
fr: L'écriture dans le fichier I<cntl> définira le registre de contrôle d'exécution du contexte du SPU.

note: type: Plain text
en: Provides access to the Memory Flow Controller of the SPU.  Reading from the file returns the contents of the SPU's MFC Tag Status register, and writing to the file initiates a DMA from the MFC.  The following operations are supported:
fr: Fournit un accès au contrôleur de flux mémoire (MFC) du SPU. Une lecture de ce fichier renvoie le contenu du registre d'état de balise MFC du SPU et une écriture dans le fichier initie un DMA du MFC. Les opérations suivantes sont prises en charge :

note: type: Plain text
en: Writes to this file need to be in the format of a MFC DMA command, defined as follows:
fr: L'écriture dans ce fichier nécessite d'être dans le format d'une commande DMA du MFC défini ainsi :

note: type: Plain text
en: struct mfc_dma_command {
        int32_t  pad;    /* reserved */
        uint32_t lsa;    /* local storage address */
        uint64_t ea;     /* effective address */
        uint16_t size;   /* transfer size */
        uint16_t tag;    /* command tag */
        uint16_t class;  /* class ID */
        uint16_t cmd;    /* command opcode */
    };
fr: struct mfc_dma_command {
        int32_t  pad;    /* réservé */
        uint32_t lsa;    /* adresse de stockage local */
        uint64_t ea;     /* adresse effective */
        uint16_t size;   /* taille de transfert */
        uint16_t tag;    /* attribut de commande */
        uint16_t class;  /* identifiant de la classe */
        uint16_t cmd;    /* opcode de la commande */
    };

note: type: Plain text
en: Writes are required to be exactly I<sizeof(struct mfc_dma_command)> bytes in size.  The command will be sent to the SPU's MFC proxy queue, and the tag stored in the kernel (see below).
fr: Les écritures doivent avoir une taille d'exactement I<sizeof(struct mfc_dma_command)> octets. La commande sera envoyée à la file proxy MFC du SPU et l’attribut enregistré dans le noyau (voir ci-dessous).

note: type: Plain text
en: Reads the contents of the tag status register.  If the file is opened in blocking mode (i.e., without B<O_NONBLOCK>), then the read will block until a DMA tag (as performed by a previous write) is complete.  In nonblocking mode, the MFC tag status register will be returned without waiting.
fr: Lire le contenu du registre d'état de l’attribut. Si le fichier est ouvert en mode bloquant (c'est-à-dire, sans B<O_NONBLOCK>), la lecture bloquera jusqu'à ce qu'une balise DMA (comme effectué par une écriture précédente) soit achevée. En mode non bloquant, le registre d'état de l’attribut MFC sera renvoyé sans attente.

note: type: Plain text
en: Calling B<poll>(2)  on the I<mfc> file will block until a new DMA can be started (by checking for B<POLLOUT>)  or until a previously started DMA (by checking for B<POLLIN>)  has been completed.
fr: Appeler B<poll>(2) sur le fichier I<mfc> bloquera jusqu'à ce qu'un nouveau DMA puisse être démarré (en vérifiant B<POLLOUT>) ou jusqu'à ce qu'un DMA démarré précédemment (en vérifiant B<POLLIN>) se soit achevé.

note: type: Plain text
en: I</mss> Provides access to the MFC MultiSource Synchronization (MSS) facility.  By B<mmap>(2)-ing this file, processes can access the MSS area of the SPU.
fr: I</mss> Fournit un accès à la fonctionnalité de synchronisation multisource (MSS) MFC. En effectuant un B<mmap>(2) sur ce fichier, les processus peuvent accéder à la zone MSS du SPU.

note: type: Plain text
en: The following operations are supported:
fr: Les opérations suivantes sont gérées :

note: type: Plain text
en: Mapping B<mss> into the process address space gives access to the SPU MSS area within the process address space.  Only B<MAP_SHARED> mappings are allowed.
fr: La projection de B<mss> dans l'espace d'adressage du processus donne accès à la zone MSS du SPU depuis l'espace d'adressage du processus. Seules les projections B<MAP_SHARED> sont autorisées.

note: type: Plain text
en: Provides access to the whole problem-state mapping of the SPU.  Applications can use this area to interface to the SPU, rather than writing to individual register files in B<spufs>.
fr: Fournit un accès à l'ensemble de la projection d'état de problèmes du SPU. Les applications peuvent utiliser cette zone pour interfacer le SPU plutôt que d'écrire dans les fichiers individuels des registres sur le système de fichiers B<spufs>.

note: type: Plain text
en: Mapping B<psmap> gives a process a direct map of the SPU problem state area.  Only B<MAP_SHARED> mappings are supported.
fr: La projection de B<psmap> donne un accès direct à un processus vers la zone d'état des problèmes du SPU. Seules les projections B<MAP_SHARED> sont autorisées.

note: type: Plain text
en: Read-only file containing the physical SPU number that the SPU context is running on.  When the context is not running, this file contains the string "-1".
fr: Fichier en lecture seule contenant le nombre de SPU physiques sur lesquelles s'exécutent le contexte SPU. Lorsque le contexte n'est pas en cours d'exécution, ce fichier contient la chaîne « -1 ».

note: type: Plain text
en: The physical SPU number is given by an ASCII hex string.
fr: Le nombre de SPU physiques est fourni sous forme d'une chaîne ASCII hexadécimale.

note: type: Plain text
en: Allows applications to store (or retrieve) a single 64-bit ID into the context.  This ID is later used by profiling tools to uniquely identify the context.
fr: Permet aux applications de stocker (ou récupérer) un idendifiant 64 bits dans le contexte. Cet identifiant est utilisé plus tard par les outils de profilage pour identifier de manière unique le contexte.

note: type: Plain text
en: By writing an ASCII hex value into this file, applications can set the object ID of the SPU context.  Any previous value of the object ID is overwritten.
fr: En écrivant une valeur hexadécimale ASCII dans ce fichier, les applications peuvent définir l'identifiant d'objet du contexte SPU. Toute valeur précédente de l'identifiant d'objet est écrasée.

note: type: Plain text
en: Reading this file gives an ASCII hex string representing the object ID for this SPU context.
fr: La lecture de ce fichier fournit une chaîne hexadécimale ASCII représentant l'identifiant d'objet de ce contexte SPU.

note: type: TP
en: I</etc/fstab>  entry
fr: Entrée I</etc/fstab>

note: type: TH
en: 2014-03-19
fr: 19 mars 2014

note: type: Plain text
en: stat, fstat, lstat, fstatat - get file status
fr: stat, fstat, lstat, fstatat - Obtenir l'état d'un fichier (file status)

note: type: Plain text
en: B<#include E<lt>fcntl.hE<gt>           >/* Definition of AT_* constants */
    B<#include E<lt>sys/stat.hE<gt>>
fr: B<#include E<lt>fcntl.hE<gt> /* Définition des constantes AT_* */>
    B<#include E<lt>sys/stat.hE<gt>>

note: type: Plain text
en: B<lstat>():
fr: B<lstat>()\ :

note: type: Plain text
en: || /* Since glibc 2.10: */ _POSIX_C_SOURCE\ E<gt>=\ 200112L
fr: || /* Depuis la glibc 2.10 : */ _POSIX_C_SOURCE\ E<gt>=\ 200112L

note: type: Plain text
en: B<fstatat>():
fr: B<fstatat>()\ :

note: type: TP
en: Since glibc 2.10:
fr: Depuis la glibc 2.10 :

note: type: TP
en: Before glibc 2.10:
fr: Avant la glibc 2.10 :

note: type: Plain text
en: These functions return information about a file, in the buffer pointed to by I<stat>.  No permissions are required on the file itself, but\(emin the case of B<stat>(), B<fstatat>(), and B<lstat>()\(emexecute (search) permission is required on all of the directories in I<pathname> that lead to the file.
fr: Ces fonctions renvoient des renseignements sur le fichier indiqué, dans le tampon pointé par I<stat>. Vous n'avez besoin d'aucun droit d'accès au fichier pour obtenir les informations, mais vous devez \(em dans le cas de B<stat>(), B<fstatat>() et B<lstat>() \(em avoir le droit de parcours de tous les répertoires mentionnés dans le chemin menant au fichier.

note: type: Plain text
en: B<stat>()  and B<fstatat>()  retrieve information about the file pointed to by I<pathname>; the differences for B<fstatat>()  are described below.
fr: B<stat>() et B<fstatat>() récupèrent des renseignements sur le fichier pointé par I<pathname>. Les différences de B<fstatat>() sont décrites ci-dessous :

note: type: Plain text
en: B<lstat>()  is identical to B<stat>(), except that if I<pathname> is a symbolic link, then it returns information about the link itself, not the file that it refers to.
fr: B<lstat>() est identique à B<stat>(), sauf que dans le cas où I<pathname> est un lien symbolique, auquel cas il renvoie des renseignements sur le lien lui-même plutôt que celui du fichier visé.

note: type: Plain text
en: B<fstat>()  is identical to B<stat>(), except that the file about which information is to be retrieved is specified by the file descriptor I<fd>.
fr: B<fstat>() est identique à B<stat>(), sauf que le fichier dont les renseignements sont à récupérer est référencé par le descripteur de fichier I<fd>.

note: type: Plain text
en: All of these system calls return a I<stat> structure, which contains the following fields:
fr: Les trois fonctions renvoient une structure I<stat> contenant les champs suivants\ :

note: type: Plain text
en: struct stat {
        dev_t     st_dev;         /* ID of device containing file */
        ino_t     st_ino;         /* inode number */
        mode_t    st_mode;        /* protection */
        nlink_t   st_nlink;       /* number of hard links */
        uid_t     st_uid;         /* user ID of owner */
        gid_t     st_gid;         /* group ID of owner */
        dev_t     st_rdev;        /* device ID (if special file) */
        off_t     st_size;        /* total size, in bytes */
        blksize_t st_blksize;     /* blocksize for filesystem I/O */
        blkcnt_t  st_blocks;      /* number of 512B blocks allocated */
fr: struct stat {
        dev_t     st_dev;         /* Périphérique                     */
        ino_t     st_ino;         /* Numéro d’inœud                   */
        mode_t    st_mode;        /* Protection                       */
        nlink_t   st_nlink;       /* Nombre de liens physiques        */
        uid_t     st_uid;         /* UID du propriétaire              */
        gid_t     st_gid;         /* GID du propriétaire              */
        dev_t     st_rdev;        /* Type de périphérique             */
        off_t     st_size;        /* Taille totale en octets          */
        blksize_t st_blksize;     /* Taille de bloc pour E/S          */
        blkcnt_t  st_blocks;      /* Nombre de blocs de 512 o alloués */

note: type: Plain text
en:     /* Since Linux 2.6, the kernel supports nanosecond
           precision for the following timestamp fields.
           For the details before Linux 2.6, see NOTES. */
fr:     /* Depuis Linux 2.6, le noyau permet une précision à la
           nanoseconde pour les champs temporels suivants. Pour
           plus de précisions avant Linux 2.6, consultez les NOTES.   */

note: type: Plain text
en:     struct timespec st_atim;  /* time of last access */
        struct timespec st_mtim;  /* time of last modification */
        struct timespec st_ctim;  /* time of last status change */
fr:     struct timespec st_atim;  /* Heure dernier accès              */
        struct timespec st_mtim;  /* Heure dernière modification      */
        struct timespec st_ctim;  /* Heure dernier changement état    */

note: type: Plain text
en: #define st_atime st_atim.tv_sec      /* Backward compatibility */
    #define st_mtime st_mtim.tv_sec
    #define st_ctime st_ctim.tv_sec
    };
fr: #define st_atime st_atim.tv_sec      /* Rétrocompatibilité        */
    #define st_mtime st_mtim.tv_sec
    #define st_ctime st_ctim.tv_sec
    };

note: type: Plain text
en: I<Note:> the order of fields in the I<stat> structure varies somewhat across architectures.  In addition, the definition above does not show the padding bytes that may be present between some fields on various architectures.  Consult the the glibc and kernel source code if you need to know the details.
fr: I<Remarque> : l’ordre des champs de la structure I<stat> varie un peu en fonction des architectures. De plus, la définition ci-dessus ne montre pas les octets de remplissage qui pourraient être présents entre certains champs sur plusieurs architectures. Consultez les sources de la glibc et du noyau pour plus de précisions.

note: type: Plain text
en: The I<st_dev> field describes the device on which this file resides.  (The B<major>(3)  and B<minor>(3)  macros may be useful to decompose the device ID in this field.)
fr: Le champ I<st_dev> décrit le périphérique sur lequel ce fichier réside. Les macros B<major>(3) et B<minor>(3) peuvent être utiles pour décomposer l'identifiant de périphérique de ce champ.

note: type: Plain text
en: The I<st_rdev> field describes the device that this file (inode) represents.
fr: Le champ I<st_rdev> indique le périphérique que ce fichier (inœud) représente.

note: type: Plain text
en: The I<st_size> field gives the size of the file (if it is a regular file or a symbolic link) in bytes.  The size of a symbolic link is the length of the pathname it contains, without a terminating null byte.
fr: Le champ I<st_size> indique la taille du fichier (s'il s'agit d'un fichier ordinaire ou d'un lien symbolique) en octets. La taille d'un lien symbolique est la longueur de la chaîne représentant le chemin d'accès qu'il vise, sans le caractère NUL final.

note: type: Plain text
en: The I<st_blocks> field indicates the number of blocks allocated to the file, 512-byte units.  (This may be smaller than I<st_size>/512 when the file has holes.)
fr: Le champ I<st_blocks> indique le nombre de blocs de 512 octets alloués au fichier. Cette valeur peut être inférieure à I<st_size>/512 si le fichier a des trous.

note: type: Plain text
en: The I<st_blksize> field gives the "preferred" blocksize for efficient filesystem I/O.  (Writing to a file in smaller chunks may cause an inefficient read-modify-rewrite.)
fr: Le champ I<st_blksize> donne la taille de bloc «\ préférée\ » pour des entrées-sorties efficaces. Des écritures par blocs plus petits peuvent entraîner un cycle lecture/modification/réécriture inefficace.

note: type: Plain text
en: Not all of the Linux filesystems implement all of the time fields.  Some filesystem types allow mounting in such a way that file and/or directory accesses do not cause an update of the I<st_atime> field.  (See I<noatime>, I<nodiratime>, and I<relatime> in B<mount>(8), and related information in B<mount>(2).)  In addition, I<st_atime> is not updated if a file is opened with the B<O_NOATIME>; see B<open>(2).
fr: Tous les systèmes de fichiers de Linux n'implémentent pas tous les champs liés à la date. Certains systèmes de fichiers autorisent le montage de telle manière que les accès à des fichiers et/ou répertoires ne modifient pas le champ I<st_atime> (voir les options I<noatime>, I<nodiratime> et I<relatime> de B<mount>(8) ainsi que les informations correspondante dans B<mount>(2)). De plus, I<st_atime> n'est pas mis à jour si un fichier est ouvert avec l'option B<O_NOATIME> ; consultez B<open>(2).

note: type: Plain text
en: The field I<st_atime> is changed by file accesses, for example, by B<execve>(2), B<mknod>(2), B<pipe>(2), B<utime>(2)  and B<read>(2)  (of more than zero bytes).  Other routines, like B<mmap>(2), may or may not update I<st_atime>.
fr: Le champ I<st_atime> est modifié par les accès au fichier, par exemple avec B<execve>(2), B<mknod>(2), B<pipe>(2), B<utime>(2) et B<read>(2) (d'au moins un octet). D'autres routines, comme B<mmap>(2), peuvent ou non mettre à jour ce champ I<st_atime>.

note: type: Plain text
en: The field I<st_mtime> is changed by file modifications, for example, by B<mknod>(2), B<truncate>(2), B<utime>(2)  and B<write>(2)  (of more than zero bytes).  Moreover, I<st_mtime> of a directory is changed by the creation or deletion of files in that directory.  The I<st_mtime> field is I<not> changed for changes in owner, group, hard link count, or mode.
fr: Le champ I<st_mtime> est modifié par des changements sur le fichier lui-même, c'est-à-dire B<mknod>(2), B<truncate>(2), B<utime>(2) et B<write>(2) (d'au moins un octet). D'autre part, le champ I<st_mtime> d'un répertoire est modifié lors de la création ou la suppression de fichiers en son sein. Le champ I<st_mtime> n'est I<pas> mis à jour lors de modification de propriétaire, groupe, mode ou nombre de liens physiques.

note: type: Plain text
en: The field I<st_ctime> is changed by writing or by setting inode information (i.e., owner, group, link count, mode, etc.).
fr: Le champ I<st_ctime> est modifié lors d'une écriture ou une modification de données concernant l'inœud (propriétaire, groupe, mode, etc.).

note: type: Plain text
en: The following POSIX macros are defined to check the file type using the I<st_mode> field:
fr: Les macros POSIX suivantes sont fournies pour vérifier le type de fichier (dans le champ I<st_mode>)\ :

note: type: Plain text
en: is it a regular file?
fr: un fichier ordinaire\ ?

note: type: Plain text
en: directory?
fr: un répertoire\ ?

note: type: Plain text
en: character device?
fr: un périphérique caractère\ ?

note: type: Plain text
en: block device?
fr: un périphérique bloc\ ?

note: type: Plain text
en: FIFO (named pipe)?
fr: FIFO (tube nommé)\ ?

note: type: Plain text
en: symbolic link? (Not in POSIX.1-1996.)
fr: un lien symbolique\ ? (Pas dans POSIX.1-1996).

note: type: Plain text
en: socket? (Not in POSIX.1-1996.)
fr: une socket\ ? (Pas dans POSIX.1-1996).

note: type: Plain text
en: The following flags are defined for the I<st_mode> field:
fr: Les attributs suivants correspondent au champ I<st_mode>\ :

note: type: tbl table
en: S_IFMT	0170000	bit mask for the file type bit fields
fr: S_IFMT	0170000	masque du type de fichier

note: type: tbl table
en: S_IFLNK	0120000	symbolic link
fr: S_IFLNK	0120000	lien symbolique

note: type: tbl table
en: S_IFREG	0100000	regular file
fr: S_IFREG	0100000	fichier ordinaire

note: type: tbl table
en: S_IFBLK	0060000	block device
fr: S_IFBLK	0060000	périphérique bloc

note: type: tbl table
en: S_IFDIR	0040000	directory
fr: S_IFDIR	0040000	répertoire

note: type: tbl table
en: S_IFCHR	0020000	character device
fr: S_IFCHR	0020000	périphérique caractère

note: type: tbl table
en: S_IFIFO	0010000	FIFO
fr: S_IFIFO	0010000	fifo

note: type: tbl table
en: S_ISUID	0004000	set-user-ID bit
fr: S_ISUID	0004000	bit Set-UID

note: type: tbl table
en: S_ISGID	0002000	set-group-ID bit (see below)
fr: S_ISGID	0002000	bit Set-Gid (voir ci\(hydessous)

note: type: tbl table
en: S_ISVTX	0001000	sticky bit (see below)
fr: S_ISVTX	0001000	bit «\ sticky\ » (voir ci\(hydessous)

note: type: tbl table
en: S_IRWXU	00700	mask for file owner permissions
fr: S_IRWXU	00700	lecture/écriture/exécution du propriétaire

note: type: tbl table
en: S_IRUSR	00400	owner has read permission
fr: S_IRUSR	00400	le propriétaire a le droit de lecture

note: type: tbl table
en: S_IWUSR	00200	owner has write permission
fr: S_IWUSR	00200	le propriétaire a le droit d'écriture

note: type: tbl table
en: S_IXUSR	00100	owner has execute permission
fr: S_IXUSR	00100	le propriétaire a le droit d'exécution

note: type: tbl table
en: S_IRWXG	00070	mask for group permissions
fr: S_IRWXG	00070	lecture/écriture/exécution du groupe

note: type: tbl table
en: S_IRGRP	00040	group has read permission
fr: S_IRGRP	00040	le groupe a le droit de lecture

note: type: tbl table
en: S_IWGRP	00020	group has write permission
fr: S_IWGRP	00020	le groupe a le droit d'écriture

note: type: tbl table
en: S_IXGRP	00010	group has execute permission
fr: S_IXGRP	00010	le groupe a le droit d'exécution

note: type: tbl table
en: mask for permissions for others (not in group)
fr: lecture/écriture/exécution des autres

note: type: tbl table
en: S_IROTH	00004	others have read permission
fr: S_IROTH	00004	les autres ont le droit de lecture

note: type: tbl table
en: S_IWOTH	00002	others have write permission
fr: S_IWOTH	00002	les autres ont le droit d'écriture

note: type: tbl table
en: S_IXOTH	00001	others have execute permission
fr: S_IXOTH	00001	les autres ont le droit d'exécution

note: type: Plain text
en: The set-group-ID bit (B<S_ISGID>)  has several special uses.  For a directory it indicates that BSD semantics is to be used for that directory: files created there inherit their group ID from the directory, not from the effective group ID of the creating process, and directories created there will also get the B<S_ISGID> bit set.  For a file that does not have the group execution bit (B<S_IXGRP>)  set, the set-group-ID bit indicates mandatory file/record locking.
fr: Le bit Set-GID (B<S_ISGID>) a plusieurs utilisations particulières\ : pour un répertoire, il indique que la sémantique BSD doit être appliquée en son sein, c'est-à-dire que les fichiers qui y sont créés héritent leur GID du répertoire et non pas du GID effectif du processus créateur, et les sous-répertoires auront automatiquement le bit B<S_ISGID> actif. Pour les fichiers qui n'ont pas d'autorisation d'exécution pour le groupe (B<S_IXGRP> non actif), ce bit indique qu'un verrouillage strict est en vigueur sur ce fichier.

note: type: Plain text
en: The sticky bit (B<S_ISVTX>)  on a directory means that a file in that directory can be renamed or deleted only by the owner of the file, by the owner of the directory, and by a privileged process.
fr: Le bit «\ sticky\ » (B<S_ISVTX>) sur un répertoire indique que les fichiers qui s'y trouvent ne peuvent être renommés ou effacés que par leur propriétaire, par le propriétaire du répertoire ou par un processus privilégié.

note: type: Plain text
en: The B<fstatat>()  system call operates in exactly the same way as B<stat>(), except for the differences described here.
fr: L'appel système B<fstatat>() fonctionne exactement comme B<stat>(2), les seules différences étant celles décrites ici.

note: type: Plain text
en: If the pathname given in I<pathname> is relative, then it is interpreted relative to the directory referred to by the file descriptor I<dirfd> (rather than relative to the current working directory of the calling process, as is done by B<stat>()  for a relative pathname).
fr: Si I<pathname> est un chemin relatif, il est interprété par rapport au répertoire référencé par le descripteur de fichier I<dirfd>, plutôt que par rapport au répertoire courant, comme dans B<stat>().

note: type: Plain text
en: If I<pathname> is relative and I<dirfd> is the special value B<AT_FDCWD>, then I<pathname> is interpreted relative to the current working directory of the calling process (like B<stat>()).
fr: Si I<pathname> est relatif, et si I<dirfd> est la valeur spéciale B<AT_FDCWD>, I<pathname> est interprété comme étant relatif au répertoire courant du processus appelant, comme B<stat>().

note: type: Plain text
en: If I<pathname> is absolute, then I<dirfd> is ignored.
fr: Si I<pathname> est un chemin absolu, I<dirfd> est ignoré.

note: type: Plain text
en: I<flags> can either be 0, or include one or more of the following flags ORed:
fr: L'argument I<flags> est soit 0, soit un I<OU> binaire «\ |\ » avec les options suivantes\ :

note: type: TP
en: B<AT_EMPTY_PATH> (since Linux 2.6.39)
fr: B<AT_EMPTY_PATH> (depuis Linux 2.6.39)

note: commit 65cfc6722361570bfe255698d9cd4dccaf47570d Before glibc 2.16, defining _ATFILE_SOURCE sufficed type: Plain text
en: If I<pathname> is an empty string, operate on the file referred to by I<dirfd> (which may have been obtained using the B<open>(2)  B<O_PATH> flag).  If I<dirfd> is B<AT_FDCWD>, the call operates on the current working directory.  In this case, I<dirfd> can refer to any type of file, not just a directory.  This flag is Linux-specific; define B<_GNU_SOURCE> to obtain its definition.
fr: Si I<pathname> est une chaîne vide, opérer sur le fichier référencé par I<dirfd> (qui peut avoir été obtenu en utilisant B<open>(2) avec l’attribut B<O_PATH>). Si I<dirfd> est B<AT_FDCWD>, l’appel opère sur le répertoire de travail actuel. Dans ce cas, I<dirfd> peut référencer tout type de fichier, pas uniquement un répertoire. Cet attribut est spécifique à Linux, B<_GNU_SOURCE> doit être définie pour obtenir sa définition.

note: type: TP
en: B<AT_NO_AUTOMOUNT> (since Linux 2.6.38)
fr: B<AT_NO_AUTOMOUNT> (depuis Linux 2.6.38)

note: Before glibc 2.16, defining _ATFILE_SOURCE sufficed type: Plain text
en: Don't automount the terminal ("basename") component of I<pathname> if it is a directory that is an automount point.  This allows the caller to gather attributes of an automount point (rather than the location it would mount).  This flag can be used in tools that scan directories to prevent mass-automounting of a directory of automount points.  The B<AT_NO_AUTOMOUNT> flag has no effect if the mount point has already been mounted over.  This flag is Linux-specific; define B<_GNU_SOURCE> to obtain its definition.
fr: N'attache pas automatiquement le composant terminal (nom de base) de I<pathname> s'il s'agit d'un répertoire qui est un point de montage automatique. Cela permet à l'appelant de rassembler les attributs d'un point de montage automatique (plutôt que l'emplacement qu'il attacherait). Ce drapeau peut être utilisé dans des outils qui analysent les répertoires pour éviter un montage automatique en masse d'un répertoire contenant des points de montage automatique. Le drapeau B<AT_NO_AUTOMOUNT> n'a aucun effet si le point de montage est déjà attaché. Ce drapeau est spécifique à Linux, B<_GNU_SOURCE> doit être définie pour obtenir sa définition.

note: type: Plain text
en: If I<pathname> is a symbolic link, do not dereference it: instead return information about the link itself, like B<lstat>().  (By default, B<fstatat>()  dereferences symbolic links, like B<stat>().)
fr: Si I<pathname> est un lien symbolique, ne pas le déréférencer, mais renvoyer des informations sur le lien lui\(hymême, comme le fait B<lstat>(2). (Par défaut, B<fstatat>() suit les liens symboliques, comme B<stat>(2).)

note: type: Plain text
en: See B<openat>(2)  for an explanation of the need for B<fstatat>().
fr: Consultez B<openat>(2) pour une explication de la nécessité de B<fstatat>().

note: type: Plain text
en: Search permission is denied for one of the directories in the path prefix of I<pathname>.  (See also B<path_resolution>(7).)
fr: La permission de parcours est refusée pour un des répertoires contenu dans le chemin I<pathname>. (Consultez aussi B<path_resolution>(7).)

note: type: Plain text
en: I<fd> is bad.
fr: I<fd> est un mauvais descripteur.

note: type: Plain text
en: Bad address.
fr: Un pointeur se trouve en dehors de l'espace d'adressage.

note: type: Plain text
en: Too many symbolic links encountered while traversing the path.
fr: Trop de liens symboliques rencontrés dans le chemin d'accès.

note: type: Plain text
en: A component of I<pathname> does not exist, or I<pathname> is an empty string.
fr: Un composant du chemin I<pathname> n'existe pas, ou I<pathname> est une chaîne vide.

note: type: Plain text
en: Out of memory (i.e., kernel memory).
fr: Pas assez de mémoire (mémoire noyau).

note: type: Plain text
en: A component of the path prefix of I<pathname> is not a directory.
fr: Un élément du préfixe du chemin I<pathname> n'est pas un répertoire.

note: type: Plain text
en: I<pathname> or I<fd> refers to a file whose size, inode number, or number of blocks cannot be represented in, respectively, the types I<off_t>, I<ino_t>, or I<blkcnt_t>.  This error can occur when, for example, an application compiled on a 32-bit platform without I<-D_FILE_OFFSET_BITS=64> calls B<stat>()  on a file whose size exceeds I<(1E<lt>E<lt>31)-1> bytes.
fr: I<pathname> ou I<fd> se réfèrent à un fichier dont la taille, l'inœud ou le nombre de blocs ne peut pas être représenté respectivement avec le type I<off_t>, I<ino_t> ou I<blkcnt_t>. Cela peut arriver par exemple quand une application compilée sans l'option I<-D_FILE_OFFSET_BITS=64> sur une plate-forme 32 bits appelle B<stat>() pour un fichier dont la taille est supérieure à I<(1E<lt>E<lt>31)-1> octets.

note: type: Plain text
en: The following additional errors can occur for B<fstatat>():
fr: Les erreurs supplémentaires suivantes peuvent également se produire pour B<fstatat>()\ :

note: type: Plain text
en: I<dirfd> is not a valid file descriptor.
fr: I<dirfd> n'est pas un descripteur de fichier valable.

note: type: Plain text
en: Invalid flag specified in I<flags>.
fr: I<flags> contient un attribut invalide.

note: type: Plain text
en: I<pathname> is relative and I<dirfd> is a file descriptor referring to a file other than a directory.
fr: I<pathname> est relatif, et le descripteur de fichier I<dirfd> est associé à un fichier, pas à un répertoire.

note: type: Plain text
en: B<fstatat>()  was added to Linux in kernel 2.6.16; library support was added to glibc in version 2.4.
fr: B<fstatat>() a été ajouté au noyau Linux dans sa version 2.6.16 ; la glibc le gère depuis la version 2.4.

note: SVr4 documents additional .BR fstat () error conditions EINTR, ENOLINK, and EOVERFLOW.  SVr4 documents additional .BR stat () and .BR lstat () error conditions EINTR, EMULTIHOP, ENOLINK, and EOVERFLOW. type: Plain text
en: B<stat>(), B<fstat>(), B<lstat>(): SVr4, 4.3BSD, POSIX.1-2001, POSIX.1.2008.
fr: B<stat>(), B<fstat>(), B<lstat>() : SVr4, 4.3BSD, POSIX.1-2001, POSIX.1.2008.

note: type: Plain text
en: B<fstatat>(): POSIX.1-2008.
fr: B<fstatat>() : POSIX.1-2008.

note: type: Plain text
en: According to POSIX.1-2001, B<lstat>()  on a symbolic link need return valid information only in the I<st_size> field and the file-type component of the I<st_mode> field of the I<stat> structure.  POSIX.1-2008 tightens the specification, requiring B<lstat>()  to return valid information in all fields except the permission bits in I<st_mode>.
fr: D'après POSIX.1-2001, B<lstat>() sur un lien symbolique ne doit renvoyer des informations valables que dans le champ I<st_size> et pour le composant de type de fichier du champ I<st_mode> de la structure I<stat>. POSIX.1-2008 renforce la spécification, obligeant B<lstat>() à renvoyer des informations valables dans tous les champs à part les bits de droit de I<st_mode>.

note: type: Plain text
en: Use of the I<st_blocks> and I<st_blksize> fields may be less portable.  (They were introduced in BSD.  The interpretation differs between systems, and possibly on a single system when NFS mounts are involved.)  If you need to obtain the definition of the I<blkcnt_t> or I<blksize_t> types from I<E<lt>sys/stat.hE<gt>>, then define B<_XOPEN_SOURCE> with the value 500 or greater (before including I<any> header files).
fr: L'utilisation des champs I<st_blocks> et I<st_blksize> risque d'être moins portable (ils ont été introduits dans BSD. Leur interprétation change suivant les systèmes, voire sur un même système s'il y a des montages NFS). Si vous avez besoin de connaître la définition des types I<blkcnt_t> ou I<blksize_t> de I<E<lt>sys/stat.hE<gt>>, alors définissez B<_XOPEN_SOURCE> avec une valeur supérieure ou égale à 500 (avant d'inclure I<tout> en\(hytête).

note: type: Plain text
en: POSIX.1-1990 did not describe the B<S_IFMT>, B<S_IFSOCK>, B<S_IFLNK>, B<S_IFREG>, B<S_IFBLK>, B<S_IFDIR>, B<S_IFCHR>, B<S_IFIFO>, B<S_ISVTX> constants, but instead demanded the use of the macros B<S_ISDIR>(), and so on.  The B<S_IF*> constants are present in POSIX.1-2001 and later.
fr: POSIX.1-1990 ne décrivait pas les constantes B<S_IFMT>, B<S_IFSOCK>, B<S_IFLNK>, B<S_IFREG>, B<S_IFBLK>, B<S_IFDIR>, B<S_IFCHR>, B<S_IFIFO>, B<S_ISVTX>, mais réclamait d'utiliser les macros B<S_ISDIR>(), etc. Les constantes B<S_IF>I<*>() sont présentes dans POSIX.1-2011 et versions suivantes.

note: type: Plain text
en: The B<S_ISLNK>()  and B<S_ISSOCK>()  macros are not in POSIX.1-1996, but both are present in POSIX.1-2001; the former is from SVID 4, the latter from SUSv2.
fr: Les macros B<S_ISLNK>() et B<S_ISSOCK>() ne se trouvent pas dans POSIX.1-1996 mais sont présentes dans POSIX.1-2001. La première vient de SVID 4, la seconde de SUSv2.

note: type: Plain text
en: UNIX V7 (and later systems) had B<S_IREAD>, B<S_IWRITE>, B<S_IEXEC>, where POSIX prescribes the synonyms B<S_IRUSR>, B<S_IWUSR>, B<S_IXUSR>.
fr: UNIX V7 (et les systèmes suivants) propose B<S_IREAD>, B<S_IWRITE>, B<S_IEXEC>, là où POSIX préfère leurs synonymes B<S_IRUSR>, B<S_IWUSR>, B<S_IXUSR>.

note: type: SS
en: Other systems
fr: Autres systèmes

note: type: Plain text
en: Values that have been (or are) in use on various systems:
fr: Voici quelques valeurs qui ont été (ou sont) utilisées sur d'autres systèmes

note: type: tbl table
en: hex	name	ls	octal	description
fr: hex	nom	ls	octal	description

note: type: tbl table
en: f000	S_IFMT		170000	mask for file type
fr: f000	S_IFMT		170000	masque du type de fichier

note: type: tbl table
en: SCO out-of-service inode; BSD unknown type; SVID-v2 and XPG2
fr: inœud hors-service (SCO) ; type inconnu (BSD) ; SVID-v2 et XPG2 ont 0 et

note: type: tbl table
en: have both 0 and 0100000 for ordinary file
fr: 0100000 pour «\ fichier ordinaire\ »

note: type: tbl table
en: 1000	S_IFIFO	p|	010000	FIFO (named pipe)
fr: 1000	S_IFIFO	p|	010000	fifo (tube nommé)

note: type: tbl table
en: 2000	S_IFCHR	c	020000	character special (V7)
fr: 2000	S_IFCHR	c	020000	fichier spécial caractère (V7)

note: type: tbl table
en: 3000	S_IFMPC		030000	multiplexed character special (V7)
fr: 3000	S_IFMPC		030000	fichier spécial caractère multiplexé
    				(V7)

note: type: tbl table
en: 4000	S_IFDIR	d/	040000	directory (V7)
fr: 4000	S_IFDIR	d/	040000	répertoire (V7)

note: type: tbl table
en: XENIX named special file with two subtypes, distinguished by
fr: fichier spécial nommé XENIX avec deux sous-types distingués par

note: type: tbl table
en: I<st_rdev> values 1, 2
fr: I<st_rdev> valant 1 ou 2

note: type: tbl table
en: 0001	S_INSEM	s	000001	XENIX semaphore subtype of IFNAM
fr: 0001	S_INSEM	s	000001	sous-type sémaphore de IFNAM XENIX

note: type: tbl table
en: 0002	S_INSHD	m	000002	XENIX shared data subtype of IFNAM
fr: 0002	S_INSHD	m	000002	sous-type données partagées de IFNAM
    				XENIX

note: type: tbl table
en: 6000	S_IFBLK	b	060000	block special (V7)
fr: 6000	S_IFBLK	b	060000	fichier spécial bloc (V7)

note: type: tbl table
en: 7000	S_IFMPB		070000	multiplexed block special (V7)
fr: 7000	S_IFMPB		070000	fichier spécial bloc multiplexé (V7)

note: type: tbl table
en: 8000	S_IFREG	-	100000	regular (V7)
fr: 8000	S_IFREG	-	100000	fichier normal (V7)

note: type: tbl table
en: 9000	S_IFCMP		110000	VxFS compressed
fr: 9000	S_IFCMP		110000	compressé VxFS

note: type: tbl table
en: 9000	S_IFNWK	n	110000	network special (HP-UX)
fr: 9000	S_IFNWK	n	110000	fichier spécial réseau (HP-UX)

note: type: tbl table
en: a000	S_IFLNK	l@	120000	symbolic link (BSD)
fr: a000	S_IFLNK	l@	120000	lien symbolique (BSD)

note: type: tbl table
en: Solaris shadow inode for ACL (not seen by user space)
fr: inœud shadow Solaris pour l'ACL (invisible depuis l'espace utilisateur)

note: type: tbl table
en: c000	S_IFSOCK	s=	140000	socket (BSD; also "S_IFSOC" on VxFS)
fr: c000	S_IFSOCK	s=	140000	socket (BSD ; aussi "S_IFSOC" sur VxFS)

note: type: tbl table
en: e000	S_IFWHT	w%	160000	BSD whiteout (not used for inode)
fr: e000	S_IFWHT	w%	160000	correcteur BSD (inutilisé pour les
    				inœuds)

note: type: tbl table
en: sticky bit: save swapped text even after use (V7)
fr: «\ sticky bit\ » : garder en mémoire après exécution (V7)

note: type: tbl table
en: reserved (SVID-v2)
fr: réservé (SVID-v2)

note: type: tbl table
en: On nondirectories: don't cache this file (SunOS)
fr: non répertoires : ne pas placer ce fichier en cache (SunOS)

note: type: tbl table
en: On directories: restricted deletion flag (SVID-v4.2)
fr: répertoires : attribut de restrictions d'effacement (SVID-v4.2)

note: type: tbl table
en: set-group-ID on execution (V7)
fr: définir le GID à l'exécution (V7)

note: type: tbl table
en: for directories: use BSD semantics for propagation of GID
fr: pour les répertoires\ : sémantique BSD pour la propagation du GID

note: type: tbl table
en: System V file locking enforcement (shared with S_ISGID)
fr: verrouillage strict System V (partagé avec S_ISGID)

note: type: tbl table
en: 0800	S_ISUID		004000	set-user-ID on execution (V7)
fr: 0800	S_ISUID		004000	définir l'UID à l'exécution (V7)

note: type: tbl table
en: directory is a context dependent file (HP-UX)
fr: le répertoire est un fichier dépendant du contexte (HP-UX)

note: type: Plain text
en: A sticky command appeared in Version 32V AT&T UNIX.
fr: Une commande sticky est apparue dans la version 32V d'AT&T UNIX.

note: type: Plain text
en: On Linux, B<lstat>()  will generally not trigger automounter action, whereas B<stat>()  will (but see B<fstatat>(2)).
fr: Sous Linux, B<lstat>() ne provoque généralement pas d'action de l'« automonteur », tandis que B<stat>() le fera (mais consultez B<fstatat>(2)).

note: type: Plain text
en: For most files under the I</proc> directory, B<stat>()  does not return the file size in the I<st_size> field; instead the field is returned with the value 0.
fr: Pour la plupart des fichiers sous I</proc>, B<stat>() ne renvoie pas la taille du fichier dans le champ I<st_size>. La valeur 0 est placée dans ce champ.

note: type: SS
en: Timestamp fields
fr: Champs temporels

note: type: Plain text
en: Older kernels and older standards did not support nanosecond timestamp fields.  Instead, there were three timestamp fields\(emI<st_atime>, I<st_mtime>, and I<st_ctime>\(emtyped as I<time_t> that recorded timestamps with one-second precision.
fr: Les anciens noyaux et les anciennes normes ne permettaient pas d’utiliser des champs temporels en nanoseconde. À la place, trois champs temporels — I<st_atime>, I<st_mtime> et I<st_ctime> — étaient utilisés pour I<time_t> qui enregistraient des horodatages avec une précision à la seconde.

note: type: Plain text
en: Since kernel 2.5.48, the I<stat> structure supports nanosecond resolution for the three file timestamp fields.  The nanosecond components of each timestamp are available via names of the form I<st_atim.tv_nsec> if the B<_BSD_SOURCE> or B<_SVID_SOURCE> feature test macro is defined.  Nanosecond timestamps are nowadays standardized, starting with POSIX.1-2008, and, starting with version 2.12, glibc also exposes the nanosecond component names if B<_POSIX_C_SOURCE> is defined with the value 200809L or greater, or B<_XOPEN_SOURCE> is defined with the value 700 or greater.  If none of the aforementioned macros are defined, then the nanosecond values are exposed with names of the form I<st_atimensec>.
fr: Depuis le noyau 2.5.48, la structure I<stat> permet une résolution d'une nanoseconde pour les trois champs temporels. Les composants en nanoseconde de chaque horodatage sont disponibles en utilisant des noms de la forme I<st_atim.tv_nsec> si une des macros de test de fonctionnalités B<_BSD_SOURCE> ou B<_SVID_SOURCE> est définie. Les horodatages en nanoseconde sont maintenant définis, depuis POSIX.1-2008 et, à partir de la version 2.12, la glibc expose aussi ces noms de composant en nanoseconde si B<_POSIX_C_SOURCE> est définie avec une valeur supérieure ou égale à 200809L ou si B<_XOPEN_SOURCE> est définie avec une valeur supérieure ou égale à 700. Si aucune de ces macros ne sont définies, alors les valeurs en nanosecondes sont exposées avec des noms de la forme I<st_atimensec>.

note: commit ef7f38359ea8b3e9c7f2cae9a4d4935f55ca9e80 type: Plain text
en: Nanosecond timestamps are supported on XFS, JFS, Btrfs, and ext4 (since Linux 2.6.23).  Nanosecond timestamps are not supported in ext2, ext3, and Resierfs.  On filesystems that do not support subsecond timestamps, the nanosecond fields are returned with the value 0.
fr: Les horodatages en nanoseconde sont permis sur les systèmes de fichiers XFS, JFS, Btrfs et ext4 (depuis Linux 2.6.23). Les horodatages en nanoseconde ne sont pas permis sur les systèmes de fichiers ext2, ext3, and Resierfs. Sur les systèmes de fichiers qui ne permettent pas les résolutions inférieures à la seconde, ces champs en nanoseconde prennent la valeur 0.

note: type: SS
en: Underlying kernel interface
fr: Interface noyau sous-jacente

note: A note from Andries Brouwer, July 2007 > Is the story not rather more complicated for some calls like > stat(2)? Yes and no, mostly no. See /usr/include/sys/stat.h . The idea is here not so much that syscalls change, but that the definitions of struct stat and of the types dev_t and mode_t change. T
en: Over time, increases in the size of the I<stat> structure have led to three successive versions of B<stat>(): I<sys_stat>()  (slot I<__NR_oldstat>), I<sys_newstat>()  (slot I<__NR_stat>), and I<sys_stat64()> (new in kernel 2.4; slot I<__NR_stat64>).  The glibc B<stat>()  wrapper function hides these details from applications, invoking the most recent version of the system call provided by the kernel, and repacking the returned information if required for old binaries.  Similar remarks apply for B<fstat>()  and B<lstat>().
fr: Avec le temps, l'augmentation de la taille de la structure I<stat> a conduit à 3 versions successives de B<stat>() : I<sys_stat>() (entrée I<__NR_oldstat>), I<sys_newstat>() (entrée I<__NR_stat>) et I<sys_stat64>() (nouveauté du noyau 2.4 ; entrée I<__NR_stat64>). La fonction B<stat>() fournie par la glibc cache ces détails aux applications, en appelant la version la plus récente de l'appel système fournie par le noyau et en réorganisant si nécessaire les informations renvoyées pour les anciens binaires. La même remarque s'applique à B<fstat>() et B<lstat>().

note: type: Plain text
en: The underlying system call employed by the glibc B<fstatat>()  wrapper function is actually called B<fstatat64>().
fr: L'appel système sous-jacent à la fonction B<fstatat()> de la glibc s'appelle B<fstatat64>().

note: type: Plain text
en: The following program calls B<stat>()  and displays selected fields in the returned I<stat> structure.
fr: Le programme suivant appelle B<stat>() et affiche certains champs sélectionnés dans la structure I<stat> renvoyée.

note: type: Plain text
en:     printf("File type:                ");
fr:     printf("Type de fichier\ :                  ");

note: type: Plain text
en:     switch (sb.st_mode & S_IFMT) {
        case S_IFBLK:  printf("block device\en");            break;
        case S_IFCHR:  printf("character device\en");        break;
        case S_IFDIR:  printf("directory\en");               break;
        case S_IFIFO:  printf("FIFO/pipe\en");               break;
        case S_IFLNK:  printf("symlink\en");                 break;
        case S_IFREG:  printf("regular file\en");            break;
        case S_IFSOCK: printf("socket\en");                  break;
        default:       printf("unknown?\en");                break;
        }
fr:     switch (sb.st_mode & S_IFMT) {
        case S_IFBLK:  printf("périphérique bloc\en");       break;
        case S_IFCHR:  printf("périphérique caractère\en");  break;
        case S_IFDIR:  printf("répertoire\en");              break;
        case S_IFIFO:  printf("FIFO/tube\en");               break;
        case S_IFLNK:  printf("lien symbolique\en");         break;
        case S_IFREG:  printf("fichier ordinaire\en");       break;
        case S_IFSOCK: printf("socket\en");                  break;
        default:       printf("inconnu\ ?\en");               break;
        }

note: type: Plain text
en:     printf("I-node number:            %ld\en", (long) sb.st_ino);
fr:     printf("Numéro d'inœud\ :                   %ld\en", (long) sb.st_ino);

note: type: Plain text
en:     printf("Mode:                     %lo (octal)\en",
                (unsigned long) sb.st_mode);
fr:     printf("Mode\ :                             %lo (octal)\en",
                (unsigned long) sb.st_mode);

note: type: Plain text
en:     printf("Link count:               %ld\en", (long) sb.st_nlink);
        printf("Ownership:                UID=%ld   GID=%ld\en",
                (long) sb.st_uid, (long) sb.st_gid);
fr:     printf("Nombre de liens\ :                  %ld\en", (long) sb.st_nlink);
        printf("Propriétaires\ :                    UID=%ld   GID=%ld\en",
                (long) sb.st_uid, (long) sb.st_gid);

note: type: Plain text
en:     printf("Preferred I/O block size: %ld bytes\en",
                (long) sb.st_blksize);
        printf("File size:                %lld bytes\en",
                (long long) sb.st_size);
        printf("Blocks allocated:         %lld\en",
                (long long) sb.st_blocks);
fr:     printf("Taille de bloc d'E/S\ :             %ld octets\en", 
                (long) sb.st_blksize);
        printf("Taille du fichier\ :                %lld octets\en", 
                (long long) sb.st_size);
        printf("Blocs alloués\ :                    %lld\en", 
                (long long) sb.st_blocks);

note: type: Plain text
en:     printf("Last status change:       %s", ctime(&sb.st_ctime));
        printf("Last file access:         %s", ctime(&sb.st_atime));
        printf("Last file modification:   %s", ctime(&sb.st_mtime));
fr:     printf("Dernier changement d'état\ :        %s", ctime(&sb.st_ctime));
        printf("Dernier accès au fichier\ :         %s", ctime(&sb.st_atime));
        printf("Dernière modification du fichier\ : %s", ctime(&sb.st_mtime));

note: type: TH
en: 2010-11-21
fr: 21 novembre 2010

note: type: Plain text
en: statfs, fstatfs - get filesystem statistics
fr: statfs, fstatfs - Obtenir des statistiques sur le système de fichiers

note: type: Plain text
en: B<#include E<lt>sys/vfs.hE<gt> >/* or E<lt>sys/statfs.hE<gt> */
fr: B<#include E<lt>sys/vfs.hE<gt> >/* ou E<lt>sys/statfs.hE<gt> */

note: type: Plain text
en: The function B<statfs>()  returns information about a mounted filesystem.  I<path> is the pathname of any file within the mounted filesystem.  I<buf> is a pointer to a I<statfs> structure defined approximately as follows:
fr: La fonction B<statfs>() renvoie des informations à propos d'un système de fichiers monté. I<path> est le nom d'un fichier quelconque dans le système de fichiers. I<buf> est un pointeur sur une structure I<statfs> approximativement définie comme suit\ :

note: type: Plain text
en: #if __WORDSIZE == 32		/* System word size */
    # define __SWORD_TYPE           int
    #else /* __WORDSIZE == 64 */
    # define __SWORD_TYPE		long int
    #endif
fr: #if __WORDSIZE == 32		/* Taille de mots du système */
    # define __SWORD_TYPE		int
    #else /* __WORDSIZE == 64 */
    # define __SWORD_TYPE		long int
    #endif

note: type: Plain text
en: struct statfs {
        __SWORD_TYPE f_type;    /* type of filesystem (see below) */
        __SWORD_TYPE f_bsize;   /* optimal transfer block size */
        fsblkcnt_t   f_blocks;  /* total data blocks in filesystem */
        fsblkcnt_t   f_bfree;   /* free blocks in fs */
        fsblkcnt_t   f_bavail;  /* free blocks available to
                                   unprivileged user */
        fsfilcnt_t   f_files;   /* total file nodes in filesystem */
        fsfilcnt_t   f_ffree;   /* free file nodes in fs */
        fsid_t       f_fsid;    /* filesystem id */
        __SWORD_TYPE f_namelen; /* maximum length of filenames */
        __SWORD_TYPE f_frsize;  /* fragment size (since Linux 2.6) */
        __SWORD_TYPE f_spare[5];
    };
fr: struct statfs {
       __SWORD_TYPE  f_type;     /* type de système de fichiers          */
       __SWORD_TYPE  f_bsize;    /* Taille optimale de bloc              */
       fsblkcnt_t    f_blocks;   /* Nombre total de blocs                */
       fsblkcnt_t    f_bfree;    /* Blocs libres                         */
       fsblkcnt_t    f_bavail;   /* Blocs libres pour util. ordinaires   */
       fsfilcnt_t    f_files;    /* Nombres de nœuds                     */
       fsfilcnt_t    f_ffree;    /* Nombre de nœuds libres               */
       fsid_t        f_fsid;     /* ID du système de fichiers            */
       __SWORD_TYPE  f_namelen;  /* Longueur maxi des noms de fichier    */
       __SWORD_TYPE  f_frsize;   /* taille de fragment (depuis Linux 2.6)*/
       __SWORD_TYPE  f_spare[5];
    };

note: type: Plain text
en: Filesystem types:
fr: Types de systèmes de fichiers\ :

note: type: Plain text
en:    ADFS_SUPER_MAGIC      0xadf5
       AFFS_SUPER_MAGIC      0xADFF
       BEFS_SUPER_MAGIC      0x42465331
       BFS_MAGIC             0x1BADFACE
       CIFS_MAGIC_NUMBER     0xFF534D42
       CODA_SUPER_MAGIC      0x73757245
       COH_SUPER_MAGIC       0x012FF7B7
       CRAMFS_MAGIC          0x28cd3d45
       DEVFS_SUPER_MAGIC     0x1373
       EFS_SUPER_MAGIC       0x00414A53
       EXT_SUPER_MAGIC       0x137D
       EXT2_OLD_SUPER_MAGIC  0xEF51
       EXT2_SUPER_MAGIC      0xEF53
       EXT3_SUPER_MAGIC      0xEF53
       EXT4_SUPER_MAGIC      0xEF53
       HFS_SUPER_MAGIC       0x4244
       HPFS_SUPER_MAGIC      0xF995E849
       HUGETLBFS_MAGIC       0x958458f6
       ISOFS_SUPER_MAGIC     0x9660
       JFFS2_SUPER_MAGIC     0x72b6
       JFS_SUPER_MAGIC       0x3153464a
       MINIX_SUPER_MAGIC     0x137F /* orig. minix */
       MINIX_SUPER_MAGIC2    0x138F /* 30 char minix */
       MINIX2_SUPER_MAGIC    0x2468 /* minix V2 */
       MINIX2_SUPER_MAGIC2   0x2478 /* minix V2, 30 char names */
       MSDOS_SUPER_MAGIC     0x4d44
       NCP_SUPER_MAGIC       0x564c
       NFS_SUPER_MAGIC       0x6969
       NTFS_SB_MAGIC         0x5346544e
       OPENPROM_SUPER_MAGIC  0x9fa1
       PROC_SUPER_MAGIC      0x9fa0
       QNX4_SUPER_MAGIC      0x002f
       REISERFS_SUPER_MAGIC  0x52654973
       ROMFS_MAGIC           0x7275
       SMB_SUPER_MAGIC       0x517B
       SYSV2_SUPER_MAGIC     0x012FF7B6
       SYSV4_SUPER_MAGIC     0x012FF7B5
       TMPFS_MAGIC           0x01021994
       UDF_SUPER_MAGIC       0x15013346
       UFS_MAGIC             0x00011954
       USBDEVICE_SUPER_MAGIC 0x9fa2
       VXFS_SUPER_MAGIC      0xa501FCF5
       XENIX_SUPER_MAGIC     0x012FF7B4
       XFS_SUPER_MAGIC       0x58465342
       _XIAFS_SUPER_MAGIC    0x012FD16D
fr:    ADFS_SUPER_MAGIC       0xadf5
       AFFS_SUPER_MAGIC       0xADFF
       BEFS_SUPER_MAGIC       0x42465331
       BFS_MAGIC              0x1BADFACE
       CIFS_MAGIC_NUMBER      0xFF534D42
       CODA_SUPER_MAGIC       0x73757245
       COH_SUPER_MAGIC        0x012FF7B7
       CRAMFS_MAGIC           0x28cd3d45
       DEVFS_SUPER_MAGIC      0x1373
       EFS_SUPER_MAGIC        0x00414A53
       EXT_SUPER_MAGIC        0x137D
       EXT2_OLD_SUPER_MAGIC   0xEF51
       EXT2_SUPER_MAGIC       0xEF53
       EXT3_SUPER_MAGIC       0xEF53
       EXT4_SUPER_MAGIC       0xEF53
       HFS_SUPER_MAGIC        0x4244
       HPFS_SUPER_MAGIC       0xF995E849
       HUGETLBFS_MAGIC        0x958458f6
       ISOFS_SUPER_MAGIC      0x9660
       JFFS2_SUPER_MAGIC      0x72b6
       JFS_SUPER_MAGIC        0x3153464a
       MINIX_SUPER_MAGIC      0x137F  /* Minix original   */
       MINIX_SUPER_MAGIC2     0x138F  /* Minix 30 caract. */
       MINIX2_SUPER_MAGIC     0x2468  /* Minix V2         */
       MINIX2_SUPER_MAGIC2    0x2478  /* Minix V2 30 car. */
       MSDOS_SUPER_MAGIC      0x4d44
       NCP_SUPER_MAGIC        0x564c
       NFS_SUPER_MAGIC        0x6969
       NTFS_SB_MAGIC          0x5346544e
       OPENPROM_SUPER_MAGIC   0x9fa1
       PROC_SUPER_MAGIC       0x9fa0
       QNX4_SUPER_MAGIC       0x002f
       REISERFS_SUPER_MAGIC   0x52654973
       ROMFS_MAGIC            0x7275
       SMB_SUPER_MAGIC        0x517B
       SYSV2_SUPER_MAGIC      0x012FF7B6
       SYSV4_SUPER_MAGIC      0x012FF7B5
       TMPFS_MAGIC            0x01021994
       UDF_SUPER_MAGIC        0x15013346
       UFS_MAGIC              0x00011954
       USBDEVICE_SUPER_MAGIC  0x9fa2
       VXFS_SUPER_MAGIC       0xa501FCF5
       XENIX_SUPER_MAGIC      0x012FF7B4
       XFS_SUPER_MAGIC        0x58465342
       _XIAFS_SUPER_MAGIC     0x012FD16D

note: type: Plain text
en: Nobody knows what I<f_fsid> is supposed to contain (but see below).
fr: Personne ne sait ce que I<f_fsid> est supposé contenir (voir plus loin).

note: type: Plain text
en: Fields that are undefined for a particular filesystem are set to 0.  B<fstatfs>()  returns the same information about an open file referenced by descriptor I<fd>.
fr: Les champs indéfinis pour un système de fichiers donné sont mis à 0. B<fstatfs>() renvoie les mêmes informations concernant un fichier ouvert référencé par I<fd>.

note: type: Plain text
en: (B<statfs>())  Search permission is denied for a component of the path prefix of I<path>.  (See also B<path_resolution>(7).)
fr: (B<statfs>()) Un élément du chemin d'accès I<path> ne permet pas le parcours. (Consultez aussi B<path_resolution>(7).)

note: type: Plain text
en: (B<fstatfs>())  I<fd> is not a valid open file descriptor.
fr: (B<fstatfs>()) I<fd> n'est pas un descripteur de fichier ouvert valide.

note: type: Plain text
en: I<buf> or I<path> points to an invalid address.
fr: I<buf> ou I<path> pointent en dehors de l'espace d'adressage accessible.

note: type: Plain text
en: This call was interrupted by a signal.
fr: L'appel a été interrompu par un signal.

note: type: Plain text
en: An I/O error occurred while reading from the filesystem.
fr: Une erreur d'entrée-sortie est survenue lors de la lecture sur le système de fichiers.

note: type: Plain text
en: (B<statfs>())  Too many symbolic links were encountered in translating I<path>.
fr: (B<statfs>()) I<path> contient une référence circulaire (à travers un lien symbolique).

note: type: Plain text
en: (B<statfs>())  I<path> is too long.
fr: (B<statfs>()) I<path> est trop long.

note: type: Plain text
en: (B<statfs>())  The file referred to by I<path> does not exist.
fr: (B<statfs>()) Le fichier indiqué par I<path> n'existe pas.

note: type: Plain text
en: Insufficient kernel memory was available.
fr: Pas assez de mémoire pour le noyau.

note: type: Plain text
en: The filesystem does not support this call.
fr: Le système de fichiers ne supporte pas cet appel.

note: type: Plain text
en: (B<statfs>())  A component of the path prefix of I<path> is not a directory.
fr: (B<statfs>()) Un élément du chemin d'accès I<path> n'est pas un répertoire.

note: type: Plain text
en: Some values were too large to be represented in the returned struct.
fr: Certaines valeurs sont trop grandes pour être représentées dans la structure renvoyée.

note: type: Plain text
en: Linux-specific.  The Linux B<statfs>()  was inspired by the 4.4BSD one (but they do not use the same structure).
fr: Spécifique à Linux. La routine B<statfs>() de Linux a été inspirée par celle de BSD\ 4.4, mais n'emploie pas la même structure.

note: type: Plain text
en: The original Linux B<statfs>()  and B<fstatfs>()  system calls were not designed with extremely large file sizes in mind.  Subsequently, Linux 2.6 added new B<statfs64>()  and B<fstatfs64>()  system calls that employ a new structure, I<statfs64>.  The new structure contains the same fields as the original I<statfs> structure, but the sizes of various fields are increased, to accommodate large file sizes.  The glibc B<statfs>()  and B<fstatfs>()  wrapper functions transparently deal with the kernel differences.
fr: Les appels système B<statfs>() et B<fstatfs>() originaux de Linux n'ont pas été conçus pour gérer des fichiers de très grosse taille. En conséquence, Linux 2.6 a ajouté de nouveaux appels système B<statfs64>() et B<fstatfs64>() qui utilisent une nouvelle structure, I<statfs64>. La nouvelle structure contient les mêmes champs que la structure I<statfs> originale, mais les tailles des différents champs sont augmentées pour gérer de grandes tailles de fichiers. Les fonctions B<statfs>() et B<fstatfs>() de la glibc qui les encapsulent gèrent de manière transparente ces différences entre noyaux.

note: type: Plain text
en: Some systems only have I<E<lt>sys/vfs.hE<gt>>, other systems also have I<E<lt>sys/statfs.hE<gt>>, where the former includes the latter.  So it seems including the former is the best choice.
fr: Certains systèmes ont seulement I<E<lt>sys/vfs.hE<gt>>, d'autres ont aussi I<E<lt>sys/statfs.hE<gt>>, où le premier inclus le dernier. Aussi, il semble qu'inclure le premier soit le meilleur choix.

note: type: Plain text
en: LSB has deprecated the library calls B<statfs>()  and B<fstatfs>()  and tells us to use B<statvfs>(2)  and B<fstatvfs>(2)  instead.
fr: LSB déconseille les appels bibliothèque B<statfs>() et B<fstatfs>() et demande d'utiliser B<statvfs>(2) et B<fstatvfs>(2) à la place.

note: type: SS
en: The f_fsid field
fr: Le champ f_fsid

note: type: Plain text
en: Solaris, Irix and POSIX have a system call B<statvfs>(2)  that returns a I<struct statvfs> (defined in I<E<lt>sys/statvfs.hE<gt>>)  containing an I<unsigned long> I<f_fsid>.  Linux, SunOS, HP-UX, 4.4BSD have a system call B<statfs>()  that returns a I<struct statfs> (defined in I<E<lt>sys/vfs.hE<gt>>)  containing a I<fsid_t> I<f_fsid>, where I<fsid_t> is defined as I<struct { int val[2]; }>.  The same holds for FreeBSD, except that it uses the include file I<E<lt>sys/mount.hE<gt>>.
fr: Solaris, Irix et POSIX ont un appel système B<statvfs>(2) qui renvoie une I<struct statvfs> (définie dans I<E<lt>sys/statvfs.hE<gt>>) contenant un I<unsigned long> I<f_fsid>. Linux, SunOS, HP-UX, BSD\ 4.4 ont un appel système B<statfs>() qui renvoie une I<struct statfs> (définie dans I<E<lt>sys/vfs.hE<gt>>) contenant un I<fsid_t> I<f_fsid>, où I<fsid_t> est défini comme une I<struct { int val[2]; }>. La même chose vaut pour FreeBSD, sauf que le fichier d'en-tête est I<E<lt>sys/mount.hE<gt>>.

note: type: Plain text
en: The general idea is that I<f_fsid> contains some random stuff such that the pair (I<f_fsid>,I<ino>)  uniquely determines a file.  Some operating systems use (a variation on) the device number, or the device number combined with the filesystem type.  Several OSes restrict giving out the I<f_fsid> field to the superuser only (and zero it for unprivileged users), because this field is used in the filehandle of the filesystem when NFS-exported, and giving it out is a security concern.
fr: L'idée générale est que I<f_fsid> contient quelque chose qui permette que la paire (I<f_fsid>,I<ino>) identifie un fichier de manière unique. Certains systèmes utilisent (une variation sur) le numéro de périphérique combiné au type de système de fichiers. Plusieurs systèmes restreignent l'accès au champ I<f_fsid> pour le superutilisateur (et indiquent zéro pour les utilisateurs normaux), car ce champ est utilisé dans la manipulation du système de fichiers lors d'exportation par NFS, et sa valeur peut être considérée comme un élément de sécurité.

note: type: Plain text
en: Under some operating systems the I<fsid> can be used as second argument to the B<sysfs>(2)  system call.
fr: Sous certains systèmes, le I<fsid> peut être utilisé en second paramètre de l'appel système B<sysfs>().

note: type: TH
en: 2013-09-26
fr: 26 septembre 2013

note: type: Plain text
en: statvfs, fstatvfs - get filesystem statistics
fr: statvfs, fstatvfs - Obtenir les statistiques d'un système de fichiers

note: type: Plain text
en: The function B<statvfs>()  returns information about a mounted filesystem.  I<path> is the pathname of any file within the mounted filesystem.  I<buf> is a pointer to a I<statvfs> structure defined approximately as follows:
fr: La fonction B<statvfs>() renvoie des informations sur un système de fichiers monté. I<path> est un chemin vers n'importe quel fichier du système de fichiers monté. I<buf> est un pointeur vers une structure I<statvfs> approximativement définie comme ceci\ :

note: type: Plain text
en: struct statvfs {
        unsigned long  f_bsize;    /* filesystem block size */
        unsigned long  f_frsize;   /* fragment size */
        fsblkcnt_t     f_blocks;   /* size of fs in f_frsize units */
        fsblkcnt_t     f_bfree;    /* # free blocks */
        fsblkcnt_t     f_bavail;   /* # free blocks for unprivileged users */
        fsfilcnt_t     f_files;    /* # inodes */
        fsfilcnt_t     f_ffree;    /* # free inodes */
        fsfilcnt_t     f_favail;   /* # free inodes for unprivileged users */
        unsigned long  f_fsid;     /* filesystem ID */
        unsigned long  f_flag;     /* mount flags */
        unsigned long  f_namemax;  /* maximum filename length */
    };
fr: struct statvfs {
        unsigned long  f_bsize;    /* taille de bloc du fs */
        unsigned long  f_frsize;   /* taille d'un fragment */
        fsblkcnt_t     f_blocks;   /* taille du fs en unité f_frsize  */
        fsblkcnt_t     f_bfree;    /* # blocs libres */
        fsblkcnt_t     f_bavail;   /* # blocs libres pour util. ordinaires */
        fsfilcnt_t     f_files;    /* # inœuds */
        fsfilcnt_t     f_ffree;    /* # inœuds libres */
        fsfilcnt_t     f_favail;   /* # inœuds libres pour util. ordinaires */
        unsigned long  f_fsid;     /* identifiant du système de fichiers */
        unsigned long  f_flag;     /* attributs de montage */
        unsigned long  f_namemax;  /* longueur maximum de nom de fichier */
    };

note: type: Plain text
en: Here the types I<fsblkcnt_t> and I<fsfilcnt_t> are defined in I<E<lt>sys/types.hE<gt>>.  Both used to be I<unsigned long>.
fr: Les types I<fsblkcnt_t> et I<fsfilcnt_t> utilisés ici sont définis dans I<E<lt>sys/types.hE<gt>>. Auparavant les deux étaient des I<unsigned long>.

note: type: Plain text
en: The field I<f_flag> is a bit mask (of mount flags, see B<mount>(8)).  Bits defined by POSIX are
fr: Le champ I<f_flag> est un masque de bit (des attributs de montage, voir B<mount>(8)). Les bits définis par la spécification POSIX sont

note: type: Plain text
en: Read-only filesystem.
fr: Système de fichiers en lecture seule.

note: type: Plain text
en: Set-user-ID/set-group-ID bits are ignored by B<exec>(3).
fr: Les bits Set-UID/Set-GID sont ignorés par B<exec>(3).

note: type: Plain text
en: It is unspecified whether all members of the returned struct have meaningful values on all filesystems.
fr: Il n'est pas indiqué si tous les membres de la structure renvoyée ont un sens quel que soit le système de fichiers.

note: type: Plain text
en: B<fstatvfs>()  returns the same information about an open file referenced by descriptor I<fd>.
fr: B<fstatvfs>() renvoie la même information sur un fichier ouvert référencé par le descripteur I<fd>.

note: type: Plain text
en: (B<statvfs>())  Search permission is denied for a component of the path prefix of I<path>.  (See also B<path_resolution>(7).)
fr: (B<statvfs>()) Un élément du chemin d'accès I<path> ne permet pas le parcours. (Consultez aussi B<path_resolution>(7).)

note: type: Plain text
en: (B<fstatvfs>())  I<fd> is not a valid open file descriptor.
fr: (B<fstatvfs>()) I<fd> n'est pas un descripteur de fichier ouvert valide.

note: type: Plain text
en: I<Buf> or I<path> points to an invalid address.
fr: I<Buf> ou I<path> pointent en dehors de l'espace d'adressage accessible.

note: type: Plain text
en: (B<statvfs>())  Too many symbolic links were encountered in translating I<path>.
fr: (B<statvfs>()) I<path> contient une référence circulaire (à travers un lien symbolique).

note: type: Plain text
en: (B<statvfs>())  I<path> is too long.
fr: (B<statvfs>()) I<path> est trop long.

note: type: Plain text
en: (B<statvfs>())  The file referred to by I<path> does not exist.
fr: (B<statvfs>()) Le fichier indiqué par I<path> n'existe pas.

note: type: Plain text
en: (B<statvfs>())  A component of the path prefix of I<path> is not a directory.
fr: (B<statvfs>()) Un élément du chemin d'accès I<path> n'est pas un répertoire.

note: type: SH
en: ATTRIBUTES
fr: ATTRIBUTS

note: type: SS
en: Multithreading (see pthreads(7))
fr: Multithreading (voir pthreads(7))

note: type: Plain text
en: The B<statvfs>()  and B<fstatvfs>()  functions are thread-safe.
fr: Les fonctions B<statvfs>() et B<fstatvfs>() sont sûres dans un contexte multithread.

note: type: Plain text
en: The Linux kernel has system calls B<statfs>(2)  and B<fstatfs>(2)  to support this library call.
fr: Le noyau Linux a les appels système B<statfs>(2) et B<fstatfs>(2) pour supporter cette fonction de bibliothèque.

note: type: Plain text
en: The current glibc implementations of
fr: Les implémentations actuelles de

note: type: Plain text
en: respectively use the I<f_frsize>, I<f_frsize>, and I<f_bsize> fields of the return value of I<statvfs(path,buf)>.
fr: dans la glibc utilisent respectivement les champs I<f_frsize>, I<f_frsize>, et I<f_bsize> de la valeur de retour de I<statvfs(path,buf)>.

note: type: TH
en: 2010-06-27
fr: 27 juin 2010

note: type: Plain text
en: sysfs - get filesystem type information
fr: sysfs - Obtenir des informations sur les types de systèmes de fichiers

note: type: Plain text
en: B<sysfs>()  returns information about the filesystem types currently present in the kernel.  The specific form of the B<sysfs>()  call and the information returned depends on the I<option> in effect:
fr: B<sysfs>() renvoie les informations concernant les types de systèmes de fichiers connus par le noyau. La forme exacte de l'appel à B<sysfs>() et les informations renvoyées dépendent de l'argument I<option>\ :

note: type: Plain text
en: Translate the filesystem identifier string I<fsname> into a filesystem type index.
fr: Traduit l'identifiant textuel du système de fichiers I<fsname> en un index.

note: type: Plain text
en: Translate the filesystem type index I<fs_index> into a null-terminated filesystem identifier string.  This string will be written to the buffer pointed to by I<buf>.  Make sure that I<buf> has enough space to accept the string.
fr: Traduit l'index de type de système de fichiers I<fs_index> en une chaîne de caractères terminée par un caractère nul. La chaîne sera écrite dans le tampon pointé par I<buf>. Assurez vous que I<buf> contient suffisamment de place pour la chaîne entière.

note: type: Plain text
en: Return the total number of filesystem types currently present in the kernel.
fr: Renvoie le nombre total de types de systèmes de fichiers reconnus par le noyau.

note: type: Plain text
en: The numbering of the filesystem type indexes begins with zero.
fr: La numérotation des index de systèmes de fichiers commence à zéro.

note: type: Plain text
en: On success, B<sysfs>()  returns the filesystem index for option B<1>, zero for option B<2>, and the number of currently configured filesystems for option B<3>.  On error, -1 is returned, and I<errno> is set appropriately.
fr: S'il réussit B<sysfs>() renvoie l'index du système de fichiers pour l'option B<1>, zéro pour l'option B<2>, et le nombre de systèmes de fichiers connus pour l'option B<3>. En cas d'erreur, -1 est renvoyé et I<errno> contient le code d'erreur.

note: type: Plain text
en: Either I<fsname> or I<buf> is outside your accessible address space.
fr: I<fsname> ou I<buf> pointent en dehors de l'espace d'adressage accessible.

note: type: Plain text
en: I<fsname> is not a valid filesystem type identifier; I<fs_index> is out-of-bounds; I<option> is invalid.
fr: I<fsname> n'est pas un identifiant de système de fichiers. I<fs_index> est hors limite. I<option> est invalide

note: type: Plain text
en: This System-V derived system call is obsolete; don't use it.  On systems with I</proc>, the same information can be obtained via I</proc/filesystems>; use that interface instead.
fr: Cet appel système dérivé de System V est obsolète, ne l'utilisez pas. Sur des systèmes avec I</proc>, la même information peut être obtenue avec I</proc/filesystems> ; utilisez plutôt cette interface.

note: type: Plain text
en: There is no libc or glibc support.  There is no way to guess how large I<buf> should be.
fr: Il n'y a pas de support dans la libc ou la glibc. On ne peut pas savoir de quelle taille doit être I<buf>.

note: type: TH
en: 2014-02-26
fr: 26 février 2014

note: type: Plain text
en: umount, umount2 - unmount filesystem
fr: umount, umount2 - Démonter un système de fichier

note: Note: the kernel naming differs from the glibc naming umount2 is the glibc name for what the kernel now calls umount and umount is the glibc name for oldumount type: Plain text
en: B<umount>()  and B<umount2>()  remove the attachment of the (topmost) filesystem mounted on I<target>.
fr: B<umount>() et B<umount2>() suppriment l'attachement du système de fichiers (le plus récemment) monté sur le répertoire I<target>.

note: type: Plain text
en: Appropriate privilege (Linux: the B<CAP_SYS_ADMIN> capability) is required to unmount filesystems.
fr: Les privilèges appropriés 'sous Linux : la capacité B<CAP_SYS_ADMIN>) est requise pour démonter des systèmes de fichiers.

note: type: Plain text
en: Linux 2.1.116 added the B<umount2>()  system call, which, like B<umount>(), unmounts a target, but allows additional I<flags> controlling the behavior of the operation:
fr: Depuis Linux 2.1.116 l'appel système B<umount2>() fonctionne comme B<umount>(), mais dispose d'options supplémentaires (I<flags>) configurant le comportement de l'opération\ :

note: type: TP
en: B<MNT_FORCE> (since Linux 2.1.116)
fr: B<MNT_FORCE> (depuis Linux 2.1.116)

note: type: Plain text
en: Force unmount even if busy.  This can cause data loss.  (Only for NFS mounts.)
fr: Forcer le démontage, même si le système de fichiers est occupé. Cela peut causer des pertes de données (seulement pour les montages NFS).

note: type: TP
en: B<MNT_DETACH> (since Linux 2.4.11)
fr: B<MNT_DETACH> (depuis Linux 2.4.11)

note: type: Plain text
en: Perform a lazy unmount: make the mount point unavailable for new accesses, and actually perform the unmount when the mount point ceases to be busy.
fr: Faire un détachement paresseux\ : rendre le point de montage invalide pour les nouveaux accès, et réaliser le démontage complet lorsque le point ne sera plus occupé.

note: type: TP
en: B<MNT_EXPIRE> (since Linux 2.6.8)
fr: B<MNT_EXPIRE> (depuis Linux 2.6.8)

note: type: Plain text
en: Mark the mount point as expired.  If a mount point is not currently in use, then an initial call to B<umount2>()  with this flag fails with the error B<EAGAIN>, but marks the mount point as expired.  The mount point remains expired as long as it isn't accessed by any process.  A second B<umount2>()  call specifying B<MNT_EXPIRE> unmounts an expired mount point.  This flag cannot be specified with either B<MNT_FORCE> or B<MNT_DETACH>.
fr: Marquer le point de montage comme ayant expiré. Si un point de montage n'est pas utilisé, un premier appel à B<umount2>() avec ce paramètre échoue avec l'erreur B<EAGAIN>, mais marque le point de montage comme expiré. Il reste dans cet état tant qu'aucun processus n'y accède. Un second appel à B<umount2>() avec B<MNT_EXPIRE> détache le point de montage expiré. Ce paramètre ne peut être combiné avec B<MNT_FORCE> ou B<MNT_DETACH>.

note: type: TP
en: B<UMOUNT_NOFOLLOW> (since Linux 2.6.34)
fr: B<UMOUNT_NOFOLLOW> (depuis Linux 2.6.34)

note: Later added to 2.6.33-stable type: Plain text
en: Don't dereference I<target> if it is a symbolic link.  This flag allows security problems to be avoided in set-user-ID-I<root> programs that allow unprivileged users to unmount filesystems.
fr: Ne pas démonter I<target> s'il s'agit d'un lien symbolique. Ce paramètre permet d'éviter des problèmes de sécurité dans des programmes set-UID-I<root> qui permettent aux utilisateurs ordinaires de démonter des systèmes de fichiers.

note: type: Plain text
en: A call to B<umount2>()  specifying B<MNT_EXPIRE> successfully marked an unbusy filesystem as expired.
fr: Un appel à B<umount2>() avec l'attribut B<MNT_EXPIRE> a marqué correctement un système de fichiers non utilisé comme expiré.

note: type: Plain text
en: I<target> could not be unmounted because it is busy.
fr: I<target> ne peut pas être démonté car il est occupé.

note: type: Plain text
en: I<target> points outside the user address space.
fr: I<target> pointe en dehors de l'espace d'adressage de l'utilisateur.

note: type: Plain text
en: I<target> is not a mount point.
fr: I<target> n'est pas un point de montage.

note: type: Plain text
en: B<umount2>()  was called with B<MNT_EXPIRE> and either B<MNT_DETACH> or B<MNT_FORCE>.
fr: B<umount2>() a été appelé avec l'option B<MNT_EXPIRE>, en même temps que B<MNT_DETACH> ou B<MNT_FORCE>.

note: type: TP
en: B<EINVAL> (since Linux 2.6.34)
fr: B<EINVAL> (depuis Linux 2.6.34)

note: type: Plain text
en: B<umount2>()  was called with an invalid flag value in I<flags>.
fr: I<flags> contient un drapeau invalide.

note: http://sourceware.org/bugzilla/show_bug.cgi?id=10092 type: Plain text
en: B<MNT_DETACH> and B<MNT_EXPIRE> are available in glibc since version 2.11.
fr: B<MNT_DETACH> et B<MNT_EXPIRE>  sont disponibles depuis la glibc\ 2.11.

note: type: Plain text
en: These functions are Linux-specific and should not be used in programs intended to be portable.
fr: Ces fonctions sont spécifiques à Linux et ne doivent pas être employées dans des programmes destinés à être portables.

note: type: Plain text
en: The original B<umount>()  function was called as I<umount(device)> and would return B<ENOTBLK> when called with something other than a block device.  In Linux 0.98p4 a call I<umount(dir)> was added, in order to support anonymous devices.  In Linux 2.3.99-pre7 the call I<umount(device)> was removed, leaving only I<umount(dir)> (since now devices can be mounted in more than one place, so specifying the device does not suffice).
fr: La fonction B<umount> d'origine était invoquée avec I<umount(device)> et renvoyait B<ENOTBLK> si l'argument était autre chose qu'un périphérique bloc. Dans Linux 0.98p4 un appel I<umount(répertoire)> fut ajouté, afin de gérer des périphériques anonymes. Dans Linux 2.3.99-pre7 l'appel I<umount(device)> fut supprimé, en ne gardant que I<umount(répertoire)> (car maintenant les périphériques peuvent être montés en plusieurs endroits, et l'indication du périphérique ne suffit plus).

note: type: TH
en: 2003-08-04
fr: 4 août 2003

note: type: Plain text
en: ustat - get filesystem statistics
fr: ustat - Obtenir les statistiques sur le système de fichiers

note: type: Plain text
en: B<ustat>()  returns information about a mounted filesystem.  I<dev> is a device number identifying a device containing a mounted filesystem.  I<ubuf> is a pointer to a I<ustat> structure that contains the following members:
fr: B<ustat>() renvoie des informations sur un système de fichiers monté. I<dev> est le numéro de périphérique contenant le système de fichiers monté. I<ubuf> est un pointeur sur une structure I<ustat> contenant les champs suivants\ :

note: type: Plain text
en: daddr_t f_tfree;      /* Total free blocks */
    ino_t   f_tinode;     /* Number of free inodes */
    char    f_fname[6];   /* Filsys name */
    char    f_fpack[6];   /* Filsys pack name */
fr: daddr_t f_tfree;      /* Nombre total de blocs libres */
    ino_t   f_tinode;     /* Nombre d'inœuds libres */
    char    f_fname[6];   /* Nom du système de fichiers */
    char    f_fpack[6];   /* Filsys pack name */

note: type: Plain text
en: The last two fields, I<f_fname> and I<f_fpack>, are not implemented and will always be filled with null bytes (\(aq\e0\(aq).
fr: Les deux derniers champs, I<f_fname> et I<f_fpack>, ne sont pas implémentés actuellement et sont remplis avec des caractères nuls (\(aq\e0\(aq).

note: type: Plain text
en: On success, zero is returned and the I<ustat> structure pointed to by I<ubuf> will be filled in.  On error, -1 is returned, and I<errno> is set appropriately.
fr: B<ustat>() renvoie zéro s'il réussit, et la structure I<ustat> pointée par I<ubuf> sera remplie. S'il échoue, l'appel système renvoie -1 et I<errno> contient le code d'erreur.

note: type: Plain text
en: I<ubuf> points outside of your accessible address space.
fr: I<ubuf> pointe en dehors de l'espace d'adressage accessible.

note: type: Plain text
en: I<dev> does not refer to a device containing a mounted filesystem.
fr: I<dev> n'est pas un périphérique contenant un système de fichiers monté.

note: type: Plain text
en: The mounted filesystem referenced by I<dev> does not support this operation, or any version of Linux before 1.3.16.
fr: Le système de fichiers monté indiqué par I<dev> ne permet pas cette opération. (Cette erreur est aussi produite par tous les noyaux Linux antérieurs au 1.3.16)

note: type: Plain text
en: B<ustat>()  is deprecated and has been provided only for compatibility.  All new programs should use B<statfs>(2)  instead.
fr: B<ustat>() est fourni à titre de compatibilité, les nouveaux programmes devraient utiliser B<statfs>(2) à la place.

note: type: SS
en: HP-UX notes
fr: Notes sur HP-UX

note: Some software tries to use this in order to test whether the underlying filesystem is NFS. type: Plain text
en: The HP-UX version of the I<ustat> structure has an additional field, I<f_blksize>, that is unknown elsewhere.  HP-UX warns: For some filesystems, the number of free inodes does not change.  Such filesystems will return -1 in the field I<f_tinode>.  For some filesystems, inodes are dynamically allocated.  Such filesystems will return the current number of free inodes.
fr: La version HP-UX de la structure I<ustat> a un champ supplémentaire, I<f_blksize>, qui n'existe nulle part ailleurs. HP-UX avertit que pour certains systèmes de fichiers, le nombre d'inœuds libres ne change pas. Ces systèmes de fichiers renvoient -1 dans le champ I<f_tinode>. Pour certains systèmes de fichiers, les inœuds sont alloués dynamiquement. Ces systèmes de fichiers renverront le nombre actuel d'inœuds libres.
