Scroll to navigation

STAT(2) Manuel du programmeur Linux STAT(2)

NOM

stat, fstat, lstat, fstatat - Obtenir l'état d'un fichier (file status)

SYNOPSIS

#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
int stat(const char *chemin, struct stat *statbuf);
int fstat(int fd, struct stat *statbuf);
int lstat(const char *chemin, struct stat *statbuf);
#include <fcntl.h>           /* Définition des constantes AT_* */
#include <sys/stat.h>
int fstatat(int dirfd, const char *chemin, struct stat *statbuf,
            int attributs);

Exigences de macros de test de fonctionnalités pour la glibc (consulter feature_test_macros(7)) :

lstat() :

/* Pour la glibc antérieure et égale à 2.19 */ _BSD_SOURCE
|| /* Depuis la glibc 2.20 */ _DEFAULT_SOURCE
|| _XOPEN_SOURCE >= 500
|| /* Depuis la glibc 2.10 : */ _POSIX_C_SOURCE >= 200112L

fstatat() :

_POSIX_C_SOURCE >= 200809L
_ATFILE_SOURCE

DESCRIPTION

Ces fonctions renvoient des renseignements sur le fichier indiqué, dans le tampon pointé par statbuf. Vous n'avez besoin d'aucun droit d'accès au fichier pour obtenir les informations, mais vous devez — dans le cas de stat(), fstatat() et lstat() — avoir le droit d'exécuter (search) sur tous les répertoires mentionnés dans le chemin menant au fichier.

stat() et fstatat() récupèrent des renseignements sur le fichier pointé par chemin. Les différences de fstatat() sont décrites ci-dessous :

lstat() est identique à stat(), sauf que dans le cas où chemin est un lien symbolique, auquel cas il renvoie des renseignements sur le lien lui-même plutôt que celui du fichier visé.

fstat() est identique à stat(), sauf que le fichier dont les renseignements sont à récupérer est référencé par le descripteur de fichier fd.

La structure stat

Les trois fonctions renvoient une structure stat contenant les champs suivants :


struct stat {

dev_t st_dev; /* ID du périphérique contenant le fichier */
ino_t st_ino; /* Numéro d’inœud */
mode_t st_mode; /* Type de fichier et mode */
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; /* ID du périphérique (si fichier spécial) */
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 */
/* 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. */
struct timespec st_atim; /* Heure dernier accès */
struct timespec st_mtim; /* Heure dernière modification */
struct timespec st_ctim; /* Heure dernier changement état */ #define st_atime st_atim.tv_sec /* Rétrocompatibilité */ #define st_mtime st_mtim.tv_sec #define st_ctime st_ctim.tv_sec };

Remarque : l’ordre des champs de la structure stat varie un peu en fonction des architectures. De plus, la définition ci-dessus ne montre pas les octets de remplissage qui peuvent être présents entre certains champs sur plusieurs architectures. Consultez le code source de la glibc et du noyau pour plus de précisions.

Note : pour des raisons de performance et de simplicité, différents champs dans la structure stat peuvent contenir des informations d'état à différents moments durant l'exécution de l'appel système. Par exemple, si st_mode ou st_uid sont modifiés par un autre processus en appelant chmod(2) ou chown(2), stat() peut renvoyer l'ancien st_mode en même temps que le nouveau st_uid ou l'ancien st_uid en même temps que le nouveau st_mode.

Les champs dans la structure stat ont la signification suivante :

Ce champ décrit le périphérique sur lequel ce fichier réside. Les macros major(3) et minor(3) peuvent être utiles pour décomposer l'identifiant de périphérique de ce champ.
Ce champs contient le nombre d'inœuds du fichier.
Ce champ contient le type et le mode du fichier. Consultez inode(7) pour plus d'informations.
Ce champ contient le nombre de liens physiques du fichier.
Ce champ contient l'identifiant de l'utilisateur propriétaire du fichier.
Ce champ contient l'identifiant du groupe propriétaire du fichier.
Ce champ décrit le périphérique que ce fichier (inœud) représente.
Ce champ 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 du nom de chemin qu'il vise, sans l’octet NULL final.
Ce champ indique la taille de bloc « préférée » pour des E/S efficaces du système de fichiers.
Le champ indique le nombre de blocs de 512 octets alloués au fichier. Cette valeur peut être inférieure à st_size/512 si le fichier a des trous.
C'est l'heure du dernier accès aux données du fichier.
C'est l'heure de la dernière modification des données du fichier.
C'est l'horodatage de la dernière modification de l'état du fichier (heure de la dernière modification de l'inœud).

Pour plus d'informations sur les champs ci-dessus, consultez inode(7).

fstatat()

L'appel système fstatat() est une interface plus générale pour accéder à des informations de fichier qui peut encore fournir exactement le comportement de chaque appel à stat(), lstat() et fstat().

Si le chemin donnée dans chemin est un chemin relatif, il est interprété par rapport au répertoire référencé par le descripteur de fichier dirfd, (plutôt que par rapport au répertoire courant du processus appelant, comme avec stat() et lstat() pour un chemin relatif).

Si chemin est relatif, et si dirfd est la valeur spéciale AT_FDCWD, chemin est interprété comme étant relatif au répertoire courant du processus appelant, comme stat() et lstat().

Si pathname est absolu, alors dirfd est ignoré.

L'argument attributs est soit 0, soit un OU binaire « | » avec les options suivantes :

Si chemin est une chaîne vide, opérer sur le fichier référencé par dirfd (qui peut avoir été obtenu en utilisant open(2) avec l’attribut O_PATH). Dans ce cas, dirfd peut référencer tout type de fichier, pas uniquement un répertoire et le comportement de fstatat() est similaire à celui de fstat(). Si dirfd est AT_FDCWD, l’appel opère sur le répertoire de travail actuel. Cet attribut est spécifique à Linux, _GNU_SOURCE doit être définie pour obtenir sa définition.
Ne pas monter automatiquement le composant terminal (« nom de base ») de chemin 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 monterait). Depuis Linux 4.14, ne pas créer également d'instance d'un nom qui n'existe pas dans un répertoire créé à la demande comme utilisé pour des mappages indirects d'auto-monteur. Cet attribut n'a aucun effet si le point de montage est déjà attaché.
stat() et lstat() agissent comme si AT_NO_AUTOMOUNT était défini.
L'attribut AT_NO_AUTOMOUNT peut être utilisé dans les outils qui balayent les répertoires pour éviter un montage automatique massif dans un répertoire avec des points de montage automatiques.
Cet attribut est spécifique à Linux ; définir _GNU_SOURCE pour obtenir sa définition.
Si chemin est un lien symbolique, ne pas le déréférencer, mais renvoyer des informations sur le lien lui‐même, comme le fait lstat(2). (Par défaut, fstatat() déréférence les liens symboliques, comme stat(2).)

Consultez openat(2) pour une explication de la nécessité de fstatat().

VALEUR RENVOYÉE

En cas de succès, zéro est renvoyé. En cas d'erreur, -1 est renvoyé et errno reçoit une valeur adéquate.

ERREURS

La permission de parcours est refusée pour un des répertoires contenu dans le chemin chemin. (Consultez aussi path_resolution(7).)
Le descripteur de fichier fd est non valable.
Un pointeur se trouve en dehors de l'espace d'adressage.
Trop de liens symboliques rencontrés dans le chemin d'accès.
nom_chemin est trop long.
Un composant du chemin d'accès chemin n'existe pas ou est un lien symbolique pointant nulle part.
chemin est une chaîne vide et AT_EMPTY_PATH n'a pas été spécifié dans attributs.
Pas assez de mémoire (c'est-à-dire, mémoire du noyau).
Un élément du préfixe de chemin n'est pas un répertoire.
chemin ou fd font référence à un fichier dont la taille, l'inœud ou le nombre de blocs ne peut pas être représenté respectivement avec le type off_t, ino_t ou blkcnt_t. Cela peut arriver par exemple quand une application compilée sans l'option -D_FILE_OFFSET_BITS=64 sur une plate-forme 32 bits appelle stat() pour un fichier dont la taille est supérieure à (1<<31)-1 octets.

Les erreurs supplémentaires suivantes peuvent également se produire pour fstatat() :

dirfd n'est pas un descripteur de fichier valable.
flags contient un attribut non valable.
pathname est relatif et dirfd est un descripteur de fichier faisant référence à un fichier qui n'est pas un dossier.

VERSIONS

fstatat() a été ajouté au noyau Linux dans sa version 2.6.16 ; la glibc le gère depuis la version 2.4.

CONFORMITÉ

stat(), fstat(), lstat() : SVr4, 4.3BSD, POSIX.1-2001, POSIX.1.2008.

fstatat() : POSIX.1-2008.

D'après POSIX.1-2001, lstat() sur un lien symbolique ne doit renvoyer des informations valables que dans le champ st_size et le type de fichier du champ st_mode de la structure stat. POSIX.1-2008 renforce la spécification, obligeant lstat() à renvoyer des informations valables dans tous les champs à part les bits de mode dans st_mode.

L'utilisation des champs st_blocks et 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).

NOTES

Champs temporels

Les anciens noyaux et les anciennes normes ne permettaient pas d’utiliser des champs temporels en nanosecondes. À la place, trois champs temporels — st_atime, st_mtime et st_ctime — étaient utilisés pour time_t qui enregistraient des horodatages avec une précision à la seconde.

Depuis le noyau 2.5.48, la structure stat permet une résolution d'une nanoseconde pour les trois champs temporels. Les composants en nanosecondes de chaque horodatage sont disponibles en utilisant des noms de la forme st_atim.tv_nsec si des macros de test de fonctionnalités appropriées sont définis. Les horodatages en nanosecondes ont été normalisés dans POSIX.1-2008 et, à partir de la version 2.12, la glibc expose les noms de composants en nanosecondes si _POSIX_C_SOURCE est définie avec une valeur supérieure ou égale à 200809L ou si _XOPEN_SOURCE est définie avec une valeur supérieure ou égale à 700. Jusqu'à la version 2.19 comprise de la glibc, les définitions des composants en nanosecondes sont aussi fixée si _BSD_SOURCE ou _SVID_SOURCE est définie. Si aucune de ces macros susmentionnées n'est définie, alors les valeurs en nanosecondes sont exposées avec des noms de la forme st_atimensec.

différences entre bibliothèque C et noyau

Avec le temps, l'augmentation de la taille de la structure stat a conduit à trois versions successives de stat() : sys_stat() (slot __NR_oldstat), sys_newstat() (slot __NR_stat) et sys_stat64() __NR_stat64) sur les plateformes 32 bits telles que i386. Les deux premières versions étaient déjà présentes dans Linux 1.0 (quoiqu'avec des noms différents), la dernière a été ajoutée dans Linux 2.4. La même remarque s'applique à fstat() et lstat().

Les versions internes du noyau de la structure stat traitées par les différentes versions étaient respectivement :

__old_kernel_stat
La structure d'origine avec des champs plutôt étroits et pas de remplissage.
Un champ plus grand st_ino et le remplissage ont été ajoutés dans différentes parties de la structure pour autoriser un agrandissement futur.
Un champ st_ino encore plus grand, des champs st_uid et st_gid plus grands pour s'adapter à l'extension à 32 bits des UID et GID dans Linux 2.4 et d'autres champs agrandis ainsi que plus de remplissage dans la structure. (Divers octets de remplissage étaient finalement consommés dans Linux 2.6 avec l'introduction d'ID de périphérique 32 bits et des composants en nanosecondes dans les champs d'horodatage.)

La fonction d'enveloppe stat() de la glibc dissimule ces détails aux applications invoquant la version la plus récente de l'appel système fourni par le noyau, et recompresse l'information renvoyée si nécessaire pour les binaires anciens.

Dans les systèmes modernes 64 bits, la vie est plus simple : il n'y a qu'un seul appel système stat() et le noyau s'occupe de la structure stat qui contient des champs d'une taille suffisante.

L'appel système sous-jacent employé par la fonction d'enveloppe fstatat() de la glibc s'appelle en fait fstatat64() ou, sur certaines architectures, newfstatat().

EXEMPLES

Le programme suivant appelle lstat() et affiche certains champs sélectionnés dans la structure stat renvoyée.

#include <sys/types.h>
#include <sys/stat.h>
#include <stdint.h>
#include <time.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/sysmacros.h>
int
main(int argc, char *argv[])
{

struct stat sb;
if (argc != 2) {
fprintf(stderr, "Usage: %s <pathname>\n", argv[0]);
exit(EXIT_FAILURE);
}
if (lstat(argv[1], &sb) == -1) {
perror("lstat");
exit(EXIT_FAILURE);
}
printf("ID du périphérique contenant : [%jx,%jx]\n",
(uintmax_t) major(sb.st_dev),
(uintmax_t) minor(sb.st_dev));
printf("Type de fichier : ");
switch (sb.st_mode & S_IFMT) {
case S_IFBLK: printf("périphérique bloc\n"); break;
case S_IFCHR: printf("périphérique caractère\n"); break;
case S_IFDIR: printf("répertoire\n"); break;
case S_IFIFO: printf("FIFO/tube\n"); break;
case S_IFLNK: printf("lien symbolique\n"); break;
case S_IFREG: printf("fichier ordinaire\n"); break;
case S_IFSOCK: printf("socket\n"); break;
default: printf("inconnu ?\n"); break;
}
printf("Numéro d'inœud : %ju\n", (uintmax_t) sb.st_ino);
printf("Mode: %jo (octal)\n",
(uintmax_t) sb.st_mode);
printf("Nombre de liens : %ju\n", (uintmax_t) sb.st_nlink);
printf("Propriétaire : UID=%ju GID=%ju\n",
(uintmax_t) sb.st_uid, (uintmax_t) sb.st_gid);
printf("Taille de bloc d'E/S : %jd octets\n",
(intmax_t) sb.st_blksize);
printf("Taille du fichier : %jd octets\n",
(intmax_t) sb.st_size);
printf("Blocs alloués : %jd\n",
(intmax_t) sb.st_blocks);
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));
exit(EXIT_SUCCESS); }

VOIR AUSSI

ls(1), stat(1), access(2), chmod(2), chown(2), readlink(2), statx(2), utime(2), capabilities(7), inode(7), symlink(7)

COLOPHON

Cette page fait partie de la publication 5.10 du projet man-pages Linux. Une description du projet et des instructions pour signaler des anomalies et la dernière version de cette page peuvent être trouvées à l'adresse https://www.kernel.org/doc/man-pages/.

TRADUCTION

La traduction française de cette page de manuel a été créée par Christophe Blaess <https://www.blaess.fr/christophe/>, Stéphan Rafin <stephan.rafin@laposte.net>, Thierry Vignaud <tvignaud@mandriva.com>, François Micaux, Alain Portal <aportal@univ-montp2.fr>, Jean-Philippe Guérard <fevrier@tigreraye.org>, Jean-Luc Coulon (f5ibh) <jean-luc.coulon@wanadoo.fr>, Julien Cristau <jcristau@debian.org>, Thomas Huriaux <thomas.huriaux@gmail.com>, Nicolas François <nicolas.francois@centraliens.net>, Florentin Duneau <fduneau@gmail.com>, Simon Paillard <simon.paillard@resel.enst-bretagne.fr>, Denis Barbier <barbier@debian.org>, David Prévot <david@tilapin.org> et Jean-Pierre Giraud <jean-pierregiraud@neuf.fr>

Cette traduction est une documentation libre ; veuillez vous reporter à la GNU General Public License version 3 concernant les conditions de copie et de distribution. Il n'y a aucune RESPONSABILITÉ LÉGALE.

Si vous découvrez un bogue dans la traduction de cette page de manuel, veuillez envoyer un message à debian-l10n-french@lists.debian.org.

13 août 2020 Linux