Provided by: manpages-fr-dev_4.27.0-1_all bug

NOM

       quotactl - Manipuler les quotas de disque

BIBLIOTHÈQUE

       Bibliothèque C standard (libc, -lc)

SYNOPSIS

       #include <sys/quota.h>
       #include <xfs/xqm.h> /* Définition des constantes Q_X* et XFS_QUOTA_*
                               (ou <linux/dqblk_xfs.h>; voir NOTES) */

       int quotactl(int op, const char *_Nullable special, int id,
                    caddr_t addr);

DESCRIPTION

       Le système de quotas permet de définir une limite sur la quantité d'espace disque utilisée sur un système
       de  fichiers,  qui  peut  être mise par utilisateur, par groupe ou par projet. Pour chaque utilisateur ou
       groupe, une limite souple et une limite impérative peuvent être définies sur chaque système de  fichiers.
       La  limite  impérative  ne  peut  pas  être  dépassée.  La  limite  souple  peut  être dépassée, mais des
       avertissements s'ensuivront. De plus, l'utilisateur ne peut pas dépasser une limite  souple  pendant  une
       certaine  période  de  grâce  d’affilée (une semaine par défaut). Une fois cette durée écoulée, la limite
       souple devient une limite impérative.

       L'appel quotactl() manipule ces quotas. L'argument op indique une opération à appliquer  à  l'identifiant
       d'utilisateur  ou  de  groupe  spécifié  dans  id.  Pour  initialiser  l'argument  op,  utilisez la macro
       QCMD(subop, type). La valeur type vaut soit USRQUOTA (pour les quotas d'utilisateur), soit GRPQUOTA (pour
       les quotas de groupe), soit PRJQUOTA (pour les projets depuis Linux 4.1). La valeur de subop est  décrite
       plus bas.

       L'argument special est un pointeur vers une chaîne de caractères (terminée par l’octet NULL) contenant le
       chemin du périphérique (monté) spécial en mode bloc pour le système de fichiers à manipuler.

       L'argument  addr  est l'adresse d'une structure de données optionnelle, spécifique à l'opération, qui est
       copiée sur ou depuis le système. L'interprétation d'addr est donnée avec chaque opération ci-dessous.

       La valeur de subop vaut une des opérations suivantes :

       Q_QUOTAON
              Activer les quotas pour un système de fichiers. L'argument id est le  numéro  d'identification  du
              format de quotas à utiliser. Il existe actuellement trois formats possibles de quotas :

              QFMT_VFS_OLD Le format original de quotas.

              QFMT_VFS_V0  Le   format   standard  VFS  v0  de  quotas,  qui  peut  manipuler  des  identifiants
                           d'utilisateur et de groupe sur 32 bits, et des limites de quotas jusqu'à 2^42  octets
                           et 2^32 inœuds.

              QFMT_VFS_V1  Un  format  de  quotas qui peut manipuler des identifiants d'utilisateur et de groupe
                           sur 32 bits, et des limites de quotas jusqu'à 2^63 octets et 2^63 inœuds.

              L'argument addr pointe sur le chemin d'un fichier contenant les quotas du système de fichiers.  Le
              fichier de quotas doit exister ; il est habituellement créé par la commande quotacheck(8).

              Des  informations de quotas peuvent également être stockées dans des inœuds cachés du système pour
              ext4, XFS et d'autres systèmes de fichiers s'ils sont configurés pour cela.  Dans  ce  cas,  aucun
              fichier  de  quota  n'est  visible  et  il  n'est  pas  nécessaire  d'utiliser  quotacheck(8). Les
              informations de quotas sont toujours maintenues  en  cohérence  par  le  système  de  fichiers  et
              l'opération  Q_QUOTAON  ne sert qu'à lancer l'application des quotas. La présence d'inœuds système
              cachés avec des informations de quotas est indiquée par l'attribut DQF_SYS_FILE du champ dqi_flags
              renvoyé par l'opération Q_GETINFO.

              Cette opération exige le privilège (CAP_SYS_ADMIN).

       Q_QUOTAOFF
              Désactiver les quotas pour un système de fichiers. Les arguments addr et id  sont  ignorés.  Cette
              opération nécessite le privilège CAP_SYS_ADMIN.

       Q_GETQUOTA
              Obtenir  les  limites  de quota et l’utilisation actuelle d’espace disque pour l'utilisateur ou le
              groupe id. L'argument addr est un pointeur sur une  structure  dqblk  définie  dans  <sys/quota.h>
              comme ceci :

                  /* uint64_t est un entier non signé 64 bits
                     uint32_t est un entier non signé 32 bits */

                  struct dqblk {      /* Définition depuis Linux 2.4.22 */
                      uint64_t dqb_bhardlimit;  /* Limite absolue de blocs de quota alloués sur
                                                   le disque */
                      uint64_t dqb_bsoftlimit;  /* Limite préférée de quota de blocs sur le
                                                   disque */
                      uint64_t dqb_curspace;    /* Espace actuellement occupé
                                                   (en octets) */
                      uint64_t dqb_ihardlimit;  /* Nombre maximal d'inœuds alloués */
                      uint64_t dqb_isoftlimit;  /* Limite préférée d'inœuds */
                      uint64_t dqb_curinodes;   /* Nombre actuel d'inœuds
                                                   alloués */
                      uint64_t dqb_btime;       /* Limite de temps de dépassement
                                                   d'utilisation du disque */
                      uint64_t dqb_itime;       /* Limite de temps de dépassement
                                                   des fichiers */
                      uint32_t dqb_valid;       /* Masque de bit des constantes QIF_* */
                  };

                  /* Attributs de dqb_valid qui indiquent quels champs
                     de la structure dqblk sont valables. */

                  #define QIF_BLIMITS   1
                  #define QIF_SPACE     2
                  #define QIF_ILIMITS   4
                  #define QIF_INODES    8
                  #define QIF_BTIME     16
                  #define QIF_ITIME     32
                  #define QIF_LIMITS    (QIF_BLIMITS | QIF_ILIMITS)
                  #define QIF_USAGE     (QIF_SPACE | QIF_INODES)
                  #define QIF_TIMES     (QIF_BTIME | QIF_ITIME)
                  #define QIF_ALL       (QIF_LIMITS | QIF_USAGE | QIF_TIMES)

              Le  champ  dqb_valid  est  un  masque de bit qui permet d'indiquer quelles entrées de la structure
              dqblk sont valables. Actuellement, le noyau remplit toutes les entrées de la  structure  dqblk  et
              les  marque  comme  valables  dans le champ dqb_valid. Les utilisateurs non privilégiés ne peuvent
              connaître que leurs propres quotas ; un utilisateur avec le privilège CAP_SYS_ADMIN peut connaître
              les quotas de tous les utilisateurs.

       Q_GETNEXTQUOTA (depuis Linux 4.6)
              Cette opération est la même que Q_GETQUOTA, mais  elle  renvoie  les  informations  de  quotas  du
              prochain identifiant supérieur ou égal à id où un quota est positionné.

              L'argument  addr  est  un  pointeur vers une structure nextdqblk dont les champs sont identiques à
              dqblk, excepté un  champ  dqb_id  supplémentaire  pour  renvoyer  l'identifiant  pour  lequel  les
              informations de quota seront renvoyées :

                  struct nextdqblk {
                      uint64_t dqb_bhardlimit;
                      uint64_t dqb_bsoftlimit;
                      uint64_t dqb_curspace;
                      uint64_t dqb_ihardlimit;
                      uint64_t dqb_isoftlimit;
                      uint64_t dqb_curinodes;
                      uint64_t dqb_btime;
                      uint64_t dqb_itime;
                      uint32_t dqb_valid;
                      uint32_t dqb_id;
                  };

       Q_SETQUOTA
              Définir  les  informations  de  quotas  pour  l'utilisateur  ou  le  groupe  id,  en utilisant les
              informations fournies par la structure dqblk dont l'adresse  est  contenue  dans  addr.  Le  champ
              dqb_valid  de  la  structure  dqblk  indique  quelles entrées de la structure ont été définies par
              l'appelant.  Cette  opération  remplace  les  opérations  Q_SETQLIM  et  Q_SETUSE  de  l'interface
              antérieure de quotas. Cette opération nécessite le privilège CAP_SYS_ADMIN.

       Q_GETINFO (depuis Linux 2.4.22)
              Obtenir  les  informations  (comme le délai de grâce) du fichier de quotas. L'argument addr est un
              pointeur sur une structure dqinfo. Cette structure est définie dans <sys/quota.h>  de  la  manière
              suivante :

                  /* uint64_t is an unsigned 64-bit integer;
                     uint32_t is an unsigned 32-bit integer */

                  struct dqinfo {         /* Defined since Linux 2.4.22 */
                      uint64_t dqi_bgrace;  /* Time before block soft limit
                                               becomes hard limit */
                      uint64_t dqi_igrace;  /* Time before inode soft limit
                                               becomes hard limit */
                      uint32_t dqi_flags;   /* Flags for quotafile
                                               (DQF_*) */
                      uint32_t dqi_valid;
                  };

                  /* Bits for dqi_flags */

                  /* Format de quota  QFMT_VFS_OLD */

                  #define DQF_ROOT_SQUASH (1 << 0) /* « Root squash » activé */
                                             /* Avant Linux v4.0, cela était défini
                                             /* en privé comme V1_DQF_RSQUASH */

                  /* Format de quota QFMT_VFS_V0 / QFMT_VFS_V1 */

                  #define DQF_SYS_FILE    (1 << 16)   /* Quota stocké dans
                                                         un système de fichiers */

                  /* Attributs de dqi_valid qui indiquent quels champs
                     de la structure dqinfo sont valables. */

                  #define IIF_BGRACE  1
                  #define IIF_IGRACE  2
                  #define IIF_FLAGS   4
                  #define IIF_ALL     (IIF_BGRACE | IIF_IGRACE | IIF_FLAGS)

              Le  champ  dqi_valid de la structure dqinfo indique les entrées de la structure qui sont valables.
              Le noyau remplit actuellement toutes les entrées de la structure dqinfo et les marque comme  étant
              valables dans le champ dqi_valid. L'argument id est ignoré.

       Q_SETINFO (depuis Linux 2.4.22)
              Définir  les  informations au sujet du fichier de quotas. L'argument addr devrait être un pointeur
              vers une structure dqinfo. Le champ dqi_valid de la structure dqinfo indique quelles entrées de la
              structure ont été définies par l'appelant. Cette opération remplace les opérations  Q_SETGRACE  et
              Q_SETFLAGS  de  l'interface  antérieure  de  quotas.  L'argument  id  est  ignoré. Cette opération
              nécessite le privilège CAP_SYS_ADMIN.

       Q_GETFMT (depuis Linux 2.4.22)
              Obtenir le format de quotas utilisé sur le système de fichiers spécifié. L'argument  addr  est  un
              pointeur sur un tampon de 4 octets qui contient le numéro du format.

       Q_SYNC Mettre  à  jour  la  copie  sur  disque de l'utilisation des quotas sur un système de fichiers. Si
              special vaut NULL, alors tous les systèmes de fichiers avec des quotas activés sont  synchronisés.
              Les arguments addr et id sont ignorés.

       Q_GETSTATS (pris en charge jusqu'à Linux 2.4.21)
              Récupérer  des  statistiques  et  d'autres  informations génériques sur le sous-système de quotas.
              L'argument addr doit être un pointeur sur une structure dqstats dans laquelle les  données  seront
              stockées.  Cette  structure  est  définie  dans  <sys/quota.h>.  Les  arguments special et id sont
              ignorés.

              Cette  opération  est  obsolète  et  a  été  supprimée  dans  Linux  2.4.22.  Les  fichiers   dans
              /proc/sys/fs/quota/ contiennent désormais les informations.

       Pour  des  systèmes  de  fichiers  XFS qui utilisent le gestionnaire de quotas XFS (XFS Quota Manager, ou
       XQM), les opérations ci-dessus doivent être remplacées par les commandes suivantes :

       Q_XQUOTAON
              Activer  les  quotas  sur  un  système  de  fichiers  XFS.  XFS  permet  d'activer  et  désactiver
              l'application  des  limites avec la gestion des quotas. Par conséquent, XFS attend qu'addr soit un
              pointeur sur un unsigned int qui contient  une  combinaison  bit  à  bit  des  attributs  suivants
              (définis dans <xfs/xqm.h>) :

                  XFS_QUOTA_UDQ_ACCT  /* Décompte du quota de l'utilisateur */
                  XFS_QUOTA_UDQ_ENFD  /* Application des limites du quota de l'utilisateur */
                  XFS_QUOTA_GDQ_ACCT  /* Décompte du quota du groupe */
                  XFS_QUOTA_GDQ_ENFD  /* Activation des limites de quota du groupe */
                  XFS_QUOTA_PDQ_ACCT  /* Décompte du quota du projet */
                  XFS_QUOTA_PDQ_ENFD  /* Activation des limites de quota du projet */

              Cette opération exige un privilège (CAP_SYS_ADMIN). L'argument id est ignoré.

       Q_XQUOTAOFF
              Désactiver les quotas pour un système de fichiers XFS. Comme pour Q_QUOTAON, le système de fichier
              XFS  attend  un  pointeur  vers  un  unsigned  int  qui  spécifie  si le décompte des quotas et/ou
              l'application des limites  doit  être  désactivé  (en  utilisant  les  mêmes  attributs  que  pour
              l'opération  Q_XQUOTAON).  Cette opération nécessite le privilège CAP_SYS_ADMIN. L'argument id est
              ignoré.

       Q_XGETQUOTA
              Obtenir les limites de quotas et l’utilisation actuelle d’espace  disque  pour  l'utilisateur  id.
              L'argument  addr  est  un  pointeur sur une structure fs_disk_quota définie dans <xfs/xqm.h> comme
              ceci :

                  /* Toutes les unités de bloc sont en BB (Basic Blocks) de
                     512 octets. */

                  #define FS_DQUOT_VERSION  1  /* fs_disk_quota.d_version */

                  #define XFS_USER_QUOTA    (1<<0)  /* Type de quota utilisateur */
                  #define XFS_PROJ_QUOTA    (1<<1)  /* Type de quota projet */
                  #define XFS_GROUP_QUOTA   (1<<2)  /* Type de quota groupe */

                  struct fs_disk_quota {
                      int8_t   d_version;   /* Version de cette structure */
                      int8_t   d_flags;     /* XFS_{USER,PROJ,GROUP}_QUOTA */
                      uint16_t d_fieldmask; /* Spécificateur de champ */
                      uint32_t d_id;        /* ID utilisateur, projet ou groupe */
                      uint64_t d_blk_hardlimit; /* Limite absolue sur les
                                                   blocs de disque */
                      uint64_t d_blk_softlimit; /* Limite préférée sur
                                                   les blocs de disque */
                      uint64_t d_ino_hardlimit; /* nombre maximal d'inœuds
                                                   alloués */
                      uint64_t d_ino_softlimit; /* Limite préférée d'inœuds */
                      uint64_t d_bcount;    /* Nombre de blocs de disque appartenant
                                               à l'utilisateur */
                      uint64_t d_icount;    /* Nombre d’inœuds de l'utilisateur */
                      int32_t  d_itimer;    /* Zéro si dans les limites d'inœuds */
                                            /* Sinon, on refuse le service */
                      int32_t  d_btimer;    /* Identique à ci-dessus ; pour
                                               les blocs de disque */
                      uint16_t d_iwarns;    /* Nombre d’avertissements intervenus par
                                               rapport au nombre d’inœuds */
                      uint16_t d_bwarns;    /* Nombre d’avertissements intervenus par
                                               rapport aux blocs de disque */
                      int32_t  d_padding2;  /* Remplissage — utilisation future */
                      uint64_t d_rtb_hardlimit; /* Limite absolue des blocs de disque
                                                   en temps réel (RT) */
                      uint64_t d_rtb_softlimit; /* Limite préférée de blocs de disque
                                                   en RT */
                      uint64_t d_rtbcount;  /* Nombre de blocs en temps réel possédés */
                      int32_t  d_rtbtimer;  /* Identique à ci-dessus ; pour les blocs de
                                               disque en RT */
                      uint16_t d_rtbwarns;  /* Nombre d’avertissements envoyés par rapport
                                               aux blocs de disque en RT */
                      int16_t  d_padding3;  /* Remplissage – utilisation future */
                      char     d_padding4[8];   /* Encore plus de remplissage */
                  };

              Les utilisateurs non privilégiés ne peuvent connaître que leurs propres quotas  ;  un  utilisateur
              avec les droits CAP_SYS_ADMIN peut connaître les quotas de tous les utilisateurs.

       Q_XGETNEXTQUOTA (depuis Linux 4.6)
              Cette  opération  est  la  même que Q_XGETQUOTA mais elle renvoie (dans la structure fs_disk_quota
              vers laquelle pointe addr) les informations de quotas du prochain identifiant supérieur ou égal  à
              id  ayant  des  quotas.  Remarquez  que  comme  fs_disk_quota  a déjà un champ q_id, aucun type de
              structure séparée n'est nécessaire (contrairement aux opérations Q_GETQUOTA et Q_GETNEXTQUOTA).

       Q_XSETQLIM
              Définir les informations de quotas pour l'utilisateur id. L'argument  addr  contient  un  pointeur
              vers une structure fs_disk_quota. Cette opération nécessite les privilèges CAP_SYS_ADMIN.

       Q_XGETQSTAT
              Renvoyer  les  informations  de  quotas  spécifiques  au système de fichiers XFS dans la structure
              fs_quota_stat vers laquelle pointe addr. Cela est utile pour savoir combien d'espace  est  utilisé
              pour  stocker  les  informations sur les quotas, ainsi que pour connaître l'état activé ou non des
              quotas d'un système de fichiers local XFS spécifique. La structure fs_quota_stat se définit  comme
              suit :

                  #define FS_QSTAT_VERSION 1  /* fs_quota_stat.qs_version */

                  struct fs_qfilestat {
                      uint64_t qfs_ino;       /* Nombre d'inœuds */
                      uint64_t qfs_nblks;     /* Nombre de BB
                                                 de 512 octets */
                      uint32_t qfs_nextents;  /* Nombre d'extensions */
                  };

                  struct fs_quota_stat {
                      int8_t   qs_version; /* Numéro de version pour des
                                              futurs changements */
                      uint16_t qs_flags; /* XFS_QUOTA_{U,P,G}DQ_{ACCT,ENFD} */
                      int8_t   qs_pad;   /* Inusité */
                      struct fs_qfilestat qs_uquota;  /* Informations de quota utilisateur */
                      struct fs_qfilestat qs_gquota;  /* Informations de quota groupe */
                      uint32_t qs_incoredqs;   /* Nombre de dquots dans le fichier core */
                      int32_t  qs_btimelimit;  /* Limite du délai pour les blocs */
                      int32_t  qs_itimelimit;  /* Limite du délai pour les inœuds */
                      int32_t  qs_rtbtimelimit;/* Limite de délai pour les blocs en
                                                  RT */
                      uint16_t qs_bwarnlimit;  /* Limite du nombre d’avertissements */
                      uint16_t qs_iwarnlimit;  /* Limite du nombre d’avertissements */
                  };

              L'argument id est ignoré.

       Q_XGETQSTATV
              Renvoyer  les  informations  de  quotas  spécifiques  au système de fichiers XFS dans la structure
              fs_quota_statv vers laquelle pointe l'argument addr. Cette  version  de  l'opération  utilise  une
              structure  gérant correctement les versions, et ayant une bonne mise en page (avec tous les champs
              naturellement alignés) et le remplissage pour éviter de gérer les fichiers spéciaux  de  compat  ;
              elle  donne  aussi  la possibilité d'avoir des statistiques sur le fichier de quotas du projet. La
              structure fs_quota_statv elle-même est définie comme suit :

                  #define FS_QSTATV_VERSION1 1 /* fs_quota_statv.qs_version */

                  struct fs_qfilestatv {
                  struct fs_qfilestatv {
                      uint64_t qfs_ino;       /* Nombre d'inœuds */
                      uint64_t qfs_nblks;     /* Nombre de BB de
                                                 512 octets */
                      uint32_t qfs_nextents;  /* Nombre d'extensions */
                      uint32_t qfs_pad;       /* Remplissage aligné sur 8 octets */
                  };

                  struct fs_quota_statv {
                      int8_t   qs_version;    /* Numéro de version pour de futurs
                                                 changements */
                      uint8_t  qs_pad1;       /* Remplissage aligné sur 16 bits */
                      uint16_t qs_flags;      /* Drapeaux XFS_QUOTA_.* */
                      uint32_t qs_incoredqs;  /* Nombre de dquots dans le core */
                      struct fs_qfilestatv qs_uquota;  /* Informations de quota
                                                          utilisateur */
                      struct fs_qfilestatv qs_gquota;  /* Informations de quota de
                                                          groupe */
                      struct fs_qfilestatv qs_pquota;  /* Informations de quota de
                                                          projet */
                      int32_t  qs_btimelimit;   /* Limite de délai pour les blocs */
                      int32_t  qs_itimelimit;   /* Limite de délai pour les inœuds */
                      int32_t  qs_rtbtimelimit; /* Limite du délai pour les blocs en RT */
                      uint16_t qs_bwarnlimit;   /* Limite du nombre d’avertissements */
                      uint16_t qs_iwarnlimit;   /* Limite du nombre d’avertissements */
                      uint64_t qs_pad2[8];      /* Pour une future démonstration */
                  };

              Le champ qs_version de la structure doit être rempli avec la version  de  la  structure  prise  en
              charge  par  l'appelant  (pour  l'instant,  seul  FS_QSTAT_VERSION1  est pris en charge). Le noyau
              remplira la structure en fonction de la version fournie. L'argument id est ignoré.

       Q_XQUOTARM (bogué jusqu'à Linux 3.16)
              Libérer l'espace disque concerné par le quota de disque. L'argument addr  doit  être  un  pointeur
              vers  une  valeur  unsigned int contenant les attributs (les mêmes que dans le champ d_flags de la
              structure fs_disk_quota) identifiant les types de quota à supprimer  (remarquez  que  le  type  de
              quota  fourni  dans  l'argument op est ignoré, mais il doit être valable pour passer les contrôles
              préalables du gestionnaire d’appel système quotactl).

              Les quotas doivent déjà avoir été désactivés. L'argument id est ignoré.

       Q_XQUOTASYNC (depuis Linux 2.6.15 ; inutilisable depuis Linux 3.4)
              Cette opération était un équivalent à Q_SYNC des quotas  XFS,  mais  elle  n'est  plus  utilisable
              depuis  Linux  3.4  car sync(1) écrit maintenant les informations de quotas sur le disque (en plus
              d'autres métadonnées du système de fichiers). Les arguments special, id et addr sont ignorés.

VALEUR RENVOYÉE

       L'appel renvoie 0 s'il réussit, ou -1 s'il échoue auquel cas errno contient le code d'erreur.

ERREURS

       EACCES op vaut Q_QUOTAON et le fichier de quotas pointé par addr existe, mais n'est pas un fichier normal
              ou alors n'est pas dans le système de fichiers pointé par special.

       EBUSY  op vaut Q_QUOTAON, mais un autre Q_QUOTAON a déjà été réalisé.

       EFAULT addr ou special n'est pas valable.

       EINVAL op ou type n'est pas valable.

       EINVAL op vaut Q_QUOTAON mais le fichier de quotas indiqué est corrompu.

       EINVAL (depuis Linux 5.5)
              op vaut Q_XQUOTARM mais addr ne pointe pas vers des types de quota valables.

       ENOENT Le fichier spécifié par special ou addr n'existe pas.

       ENOSYS Le noyau a été compilé sans l'option CONFIG_QUOTA.

       ENOTBLK
              special n'est pas un périphérique bloc.

       EPERM  L'appelant ne possède pas le privilège nécessaire (CAP_SYS_ADMIN) pour l'opération demandée.

       ERANGE op vaut Q_SETQUOTA, mais les limites spécifiées sont en dehors de l'intervalle  autorisé  pour  le
              format de quotas.

       ESRCH  Aucun  quota  de disque n'est imposé pour l'utilisateur spécifié. Les quotas n'ont pas été activés
              sur ce système de fichiers.

       ESRCH  op vaut Q_QUOTAON, mais le format de quotas spécifié n'a pas été trouvé.

       ESRCH  op vaut Q_GETNEXTQUOTA ou Q_XGETNEXTQUOTA mais aucun identifiant supérieur ou égal  à  id  n'a  de
              quota valable.

NOTES

       Vous  pouvez  utiliser <linux/dqblk_xfs.h> au lieu de <xfs/xqm.h>, en prenant en compte le fait qu'il y a
       plusieurs décalages de nommage :

       -  Les attributs d'activation des quotas (au  format  XFS_QUOTA_[UGP]DQ_{ACCT,ENFD})  sont  définis  sans
          « X » devant, comme FS_QUOTA_[UGP]DQ_{ACCT,ENFD}.

       -  La  même chose s'applique aux attributs de type de quotas XFS_{USER,GROUP,PROJ}_QUOTA qui sont définis
          en tant que FS_{USER,GROUP,PROJ}_QUOTA.

       -  Le fichier  d'en-tête  dqblk_xfs.h  définit  ses  propres  constantes  XQM_USRQUOTA,  XQM_GRPQUOTA  et
          XQM_PRJQUOTA  pour  les  types  de  quota  disponibles, mais leurs valeurs sont les mêmes que pour les
          constantes définies sans le préfixe XQM_.

VOIR AUSSI

       quota(1), getrlimit(2), quotacheck(8), quotaon(8)

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-Philippe MENGUAL <jpmengual@debian.org>

       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.

Pages du manuel de Linux 6.9.1                     2 mai 2024                                        quotactl(2)