Branch data     Line data    Source code

       1                 :            : /*
       2                 :            :  * Copyright (c) 1982, 1986 Regents of the University of California.
       3                 :            :  * All rights reserved.
       4                 :            :  *
       5                 :            :  * This code is derived from software contributed to Berkeley by
       6                 :            :  * Robert Elz at The University of Melbourne.
       7                 :            :  *
       8                 :            :  * Redistribution and use in source and binary forms, with or without
       9                 :            :  * modification, are permitted provided that the following conditions
      10                 :            :  * are met:
      11                 :            :  * 1. Redistributions of source code must retain the above copyright
      12                 :            :  *    notice, this list of conditions and the following disclaimer.
      13                 :            :  * 2. Redistributions in binary form must reproduce the above copyright
      14                 :            :  *    notice, this list of conditions and the following disclaimer in the
      15                 :            :  *    documentation and/or other materials provided with the distribution.
      16                 :            :  * 3. Neither the name of the University nor the names of its contributors
      17                 :            :  *    may be used to endorse or promote products derived from this software
      18                 :            :  *    without specific prior written permission.
      19                 :            :  *
      20                 :            :  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
      21                 :            :  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
      22                 :            :  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
      23                 :            :  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
      24                 :            :  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
      25                 :            :  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
      26                 :            :  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
      27                 :            :  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
      28                 :            :  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
      29                 :            :  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
      30                 :            :  * SUCH DAMAGE.
      31                 :            :  */
      32                 :            : #ifndef _LINUX_QUOTA_
      33                 :            : #define _LINUX_QUOTA_
      34                 :            : 
      35                 :            : #include <linux/list.h>
      36                 :            : #include <linux/mutex.h>
      37                 :            : #include <linux/rwsem.h>
      38                 :            : #include <linux/spinlock.h>
      39                 :            : #include <linux/wait.h>
      40                 :            : #include <linux/percpu_counter.h>
      41                 :            : 
      42                 :            : #include <linux/dqblk_xfs.h>
      43                 :            : #include <linux/dqblk_v1.h>
      44                 :            : #include <linux/dqblk_v2.h>
      45                 :            : 
      46                 :            : #include <linux/atomic.h>
      47                 :            : #include <linux/uidgid.h>
      48                 :            : #include <linux/projid.h>
      49                 :            : #include <uapi/linux/quota.h>
      50                 :            : 
      51                 :            : #undef USRQUOTA
      52                 :            : #undef GRPQUOTA
      53                 :            : #undef PRJQUOTA
      54                 :            : enum quota_type {
      55                 :            :         USRQUOTA = 0,           /* element used for user quotas */
      56                 :            :         GRPQUOTA = 1,           /* element used for group quotas */
      57                 :            :         PRJQUOTA = 2,           /* element used for project quotas */
      58                 :            : };
      59                 :            : 
      60                 :            : /* Masks for quota types when used as a bitmask */
      61                 :            : #define QTYPE_MASK_USR (1 << USRQUOTA)
      62                 :            : #define QTYPE_MASK_GRP (1 << GRPQUOTA)
      63                 :            : #define QTYPE_MASK_PRJ (1 << PRJQUOTA)
      64                 :            : 
      65                 :            : typedef __kernel_uid32_t qid_t; /* Type in which we store ids in memory */
      66                 :            : typedef long long qsize_t;      /* Type in which we store sizes */
      67                 :            : 
      68                 :            : struct kqid {                   /* Type in which we store the quota identifier */
      69                 :            :         union {
      70                 :            :                 kuid_t uid;
      71                 :            :                 kgid_t gid;
      72                 :            :                 kprojid_t projid;
      73                 :            :         };
      74                 :            :         enum quota_type type;  /* USRQUOTA (uid) or GRPQUOTA (gid) or PRJQUOTA (projid) */
      75                 :            : };
      76                 :            : 
      77                 :            : extern bool qid_eq(struct kqid left, struct kqid right);
      78                 :            : extern bool qid_lt(struct kqid left, struct kqid right);
      79                 :            : extern qid_t from_kqid(struct user_namespace *to, struct kqid qid);
      80                 :            : extern qid_t from_kqid_munged(struct user_namespace *to, struct kqid qid);
      81                 :            : extern bool qid_valid(struct kqid qid);
      82                 :            : 
      83                 :            : /**
      84                 :            :  *      make_kqid - Map a user-namespace, type, qid tuple into a kqid.
      85                 :            :  *      @from: User namespace that the qid is in
      86                 :            :  *      @type: The type of quota
      87                 :            :  *      @qid: Quota identifier
      88                 :            :  *
      89                 :            :  *      Maps a user-namespace, type qid tuple into a kernel internal
      90                 :            :  *      kqid, and returns that kqid.
      91                 :            :  *
      92                 :            :  *      When there is no mapping defined for the user-namespace, type,
      93                 :            :  *      qid tuple an invalid kqid is returned.  Callers are expected to
      94                 :            :  *      test for and handle handle invalid kqids being returned.
      95                 :            :  *      Invalid kqids may be tested for using qid_valid().
      96                 :            :  */
      97                 :          0 : static inline struct kqid make_kqid(struct user_namespace *from,
      98                 :            :                                     enum quota_type type, qid_t qid)
      99                 :            : {
     100                 :            :         struct kqid kqid;
     101                 :            : 
     102                 :            :         kqid.type = type;
     103                 :          0 :         switch (type) {
     104                 :            :         case USRQUOTA:
     105                 :          0 :                 kqid.uid = make_kuid(from, qid);
     106                 :          0 :                 break;
     107                 :            :         case GRPQUOTA:
     108                 :          0 :                 kqid.gid = make_kgid(from, qid);
     109                 :          0 :                 break;
     110                 :            :         case PRJQUOTA:
     111                 :          0 :                 kqid.projid = make_kprojid(from, qid);
     112                 :          0 :                 break;
     113                 :            :         default:
     114                 :          0 :                 BUG();
     115                 :            :         }
     116                 :          0 :         return kqid;
     117                 :            : }
     118                 :            : 
     119                 :            : /**
     120                 :            :  *      make_kqid_invalid - Explicitly make an invalid kqid
     121                 :            :  *      @type: The type of quota identifier
     122                 :            :  *
     123                 :            :  *      Returns an invalid kqid with the specified type.
     124                 :            :  */
     125                 :            : static inline struct kqid make_kqid_invalid(enum quota_type type)
     126                 :            : {
     127                 :            :         struct kqid kqid;
     128                 :            : 
     129                 :            :         kqid.type = type;
     130                 :          0 :         switch (type) {
     131                 :            :         case USRQUOTA:
     132                 :            :                 kqid.uid = INVALID_UID;
     133                 :            :                 break;
     134                 :            :         case GRPQUOTA:
     135                 :            :                 kqid.gid = INVALID_GID;
     136                 :            :                 break;
     137                 :            :         case PRJQUOTA:
     138                 :            :                 kqid.projid = INVALID_PROJID;
     139                 :            :                 break;
     140                 :            :         default:
     141                 :          0 :                 BUG();
     142                 :            :         }
     143                 :            :         return kqid;
     144                 :            : }
     145                 :            : 
     146                 :            : /**
     147                 :            :  *      make_kqid_uid - Make a kqid from a kuid
     148                 :            :  *      @uid: The kuid to make the quota identifier from
     149                 :            :  */
     150                 :            : static inline struct kqid make_kqid_uid(kuid_t uid)
     151                 :            : {
     152                 :            :         struct kqid kqid;
     153                 :            :         kqid.type = USRQUOTA;
     154                 :            :         kqid.uid = uid;
     155                 :          0 :         return kqid;
     156                 :            : }
     157                 :            : 
     158                 :            : /**
     159                 :            :  *      make_kqid_gid - Make a kqid from a kgid
     160                 :            :  *      @gid: The kgid to make the quota identifier from
     161                 :            :  */
     162                 :            : static inline struct kqid make_kqid_gid(kgid_t gid)
     163                 :            : {
     164                 :            :         struct kqid kqid;
     165                 :            :         kqid.type = GRPQUOTA;
     166                 :            :         kqid.gid = gid;
     167                 :          0 :         return kqid;
     168                 :            : }
     169                 :            : 
     170                 :            : /**
     171                 :            :  *      make_kqid_projid - Make a kqid from a projid
     172                 :            :  *      @projid: The kprojid to make the quota identifier from
     173                 :            :  */
     174                 :            : static inline struct kqid make_kqid_projid(kprojid_t projid)
     175                 :            : {
     176                 :            :         struct kqid kqid;
     177                 :            :         kqid.type = PRJQUOTA;
     178                 :            :         kqid.projid = projid;
     179                 :          0 :         return kqid;
     180                 :            : }
     181                 :            : 
     182                 :            : /**
     183                 :            :  *      qid_has_mapping - Report if a qid maps into a user namespace.
     184                 :            :  *      @ns:  The user namespace to see if a value maps into.
     185                 :            :  *      @qid: The kernel internal quota identifier to test.
     186                 :            :  */
     187                 :            : static inline bool qid_has_mapping(struct user_namespace *ns, struct kqid qid)
     188                 :            : {
     189                 :          0 :         return from_kqid(ns, qid) != (qid_t) -1;
     190                 :            : }
     191                 :            : 
     192                 :            : 
     193                 :            : extern spinlock_t dq_data_lock;
     194                 :            : 
     195                 :            : /* Maximal numbers of writes for quota operation (insert/delete/update)
     196                 :            :  * (over VFS all formats) */
     197                 :            : #define DQUOT_INIT_ALLOC max(V1_INIT_ALLOC, V2_INIT_ALLOC)
     198                 :            : #define DQUOT_INIT_REWRITE max(V1_INIT_REWRITE, V2_INIT_REWRITE)
     199                 :            : #define DQUOT_DEL_ALLOC max(V1_DEL_ALLOC, V2_DEL_ALLOC)
     200                 :            : #define DQUOT_DEL_REWRITE max(V1_DEL_REWRITE, V2_DEL_REWRITE)
     201                 :            : 
     202                 :            : /*
     203                 :            :  * Data for one user/group kept in memory
     204                 :            :  */
     205                 :            : struct mem_dqblk {
     206                 :            :         qsize_t dqb_bhardlimit; /* absolute limit on disk blks alloc */
     207                 :            :         qsize_t dqb_bsoftlimit; /* preferred limit on disk blks */
     208                 :            :         qsize_t dqb_curspace;   /* current used space */
     209                 :            :         qsize_t dqb_rsvspace;   /* current reserved space for delalloc*/
     210                 :            :         qsize_t dqb_ihardlimit; /* absolute limit on allocated inodes */
     211                 :            :         qsize_t dqb_isoftlimit; /* preferred inode limit */
     212                 :            :         qsize_t dqb_curinodes;  /* current # allocated inodes */
     213                 :            :         time64_t dqb_btime;     /* time limit for excessive disk use */
     214                 :            :         time64_t dqb_itime;     /* time limit for excessive inode use */
     215                 :            : };
     216                 :            : 
     217                 :            : /*
     218                 :            :  * Data for one quotafile kept in memory
     219                 :            :  */
     220                 :            : struct quota_format_type;
     221                 :            : 
     222                 :            : struct mem_dqinfo {
     223                 :            :         struct quota_format_type *dqi_format;
     224                 :            :         int dqi_fmt_id;         /* Id of the dqi_format - used when turning
     225                 :            :                                  * quotas on after remount RW */
     226                 :            :         struct list_head dqi_dirty_list;        /* List of dirty dquots [dq_list_lock] */
     227                 :            :         unsigned long dqi_flags;        /* DFQ_ flags [dq_data_lock] */
     228                 :            :         unsigned int dqi_bgrace;        /* Space grace time [dq_data_lock] */
     229                 :            :         unsigned int dqi_igrace;        /* Inode grace time [dq_data_lock] */
     230                 :            :         qsize_t dqi_max_spc_limit;      /* Maximum space limit [static] */
     231                 :            :         qsize_t dqi_max_ino_limit;      /* Maximum inode limit [static] */
     232                 :            :         void *dqi_priv;
     233                 :            : };
     234                 :            : 
     235                 :            : struct super_block;
     236                 :            : 
     237                 :            : /* Mask for flags passed to userspace */
     238                 :            : #define DQF_GETINFO_MASK (DQF_ROOT_SQUASH | DQF_SYS_FILE)
     239                 :            : /* Mask for flags modifiable from userspace */
     240                 :            : #define DQF_SETINFO_MASK DQF_ROOT_SQUASH
     241                 :            : 
     242                 :            : enum {
     243                 :            :         DQF_INFO_DIRTY_B = DQF_PRIVATE,
     244                 :            : };
     245                 :            : #define DQF_INFO_DIRTY (1 << DQF_INFO_DIRTY_B)    /* Is info dirty? */
     246                 :            : 
     247                 :            : extern void mark_info_dirty(struct super_block *sb, int type);
     248                 :            : static inline int info_dirty(struct mem_dqinfo *info)
     249                 :            : {
     250                 :            :         return test_bit(DQF_INFO_DIRTY_B, &info->dqi_flags);
     251                 :            : }
     252                 :            : 
     253                 :            : enum {
     254                 :            :         DQST_LOOKUPS,
     255                 :            :         DQST_DROPS,
     256                 :            :         DQST_READS,
     257                 :            :         DQST_WRITES,
     258                 :            :         DQST_CACHE_HITS,
     259                 :            :         DQST_ALLOC_DQUOTS,
     260                 :            :         DQST_FREE_DQUOTS,
     261                 :            :         DQST_SYNCS,
     262                 :            :         _DQST_DQSTAT_LAST
     263                 :            : };
     264                 :            : 
     265                 :            : struct dqstats {
     266                 :            :         unsigned long stat[_DQST_DQSTAT_LAST];
     267                 :            :         struct percpu_counter counter[_DQST_DQSTAT_LAST];
     268                 :            : };
     269                 :            : 
     270                 :            : extern struct dqstats dqstats;
     271                 :            : 
     272                 :            : static inline void dqstats_inc(unsigned int type)
     273                 :            : {
     274                 :            :         percpu_counter_inc(&dqstats.counter[type]);
     275                 :            : }
     276                 :            : 
     277                 :            : static inline void dqstats_dec(unsigned int type)
     278                 :            : {
     279                 :            :         percpu_counter_dec(&dqstats.counter[type]);
     280                 :            : }
     281                 :            : 
     282                 :            : #define DQ_MOD_B        0       /* dquot modified since read */
     283                 :            : #define DQ_BLKS_B       1       /* uid/gid has been warned about blk limit */
     284                 :            : #define DQ_INODES_B     2       /* uid/gid has been warned about inode limit */
     285                 :            : #define DQ_FAKE_B       3       /* no limits only usage */
     286                 :            : #define DQ_READ_B       4       /* dquot was read into memory */
     287                 :            : #define DQ_ACTIVE_B     5       /* dquot is active (dquot_release not called) */
     288                 :            : #define DQ_LASTSET_B    6       /* Following 6 bits (see QIF_) are reserved\
     289                 :            :                                  * for the mask of entries set via SETQUOTA\
     290                 :            :                                  * quotactl. They are set under dq_data_lock\
     291                 :            :                                  * and the quota format handling dquot can\
     292                 :            :                                  * clear them when it sees fit. */
     293                 :            : 
     294                 :            : struct dquot {
     295                 :            :         struct hlist_node dq_hash;      /* Hash list in memory [dq_list_lock] */
     296                 :            :         struct list_head dq_inuse;      /* List of all quotas [dq_list_lock] */
     297                 :            :         struct list_head dq_free;       /* Free list element [dq_list_lock] */
     298                 :            :         struct list_head dq_dirty;      /* List of dirty dquots [dq_list_lock] */
     299                 :            :         struct mutex dq_lock;           /* dquot IO lock */
     300                 :            :         spinlock_t dq_dqb_lock;         /* Lock protecting dq_dqb changes */
     301                 :            :         atomic_t dq_count;              /* Use count */
     302                 :            :         struct super_block *dq_sb;      /* superblock this applies to */
     303                 :            :         struct kqid dq_id;              /* ID this applies to (uid, gid, projid) */
     304                 :            :         loff_t dq_off;                  /* Offset of dquot on disk [dq_lock, stable once set] */
     305                 :            :         unsigned long dq_flags;         /* See DQ_* */
     306                 :            :         struct mem_dqblk dq_dqb;        /* Diskquota usage [dq_dqb_lock] */
     307                 :            : };
     308                 :            : 
     309                 :            : /* Operations which must be implemented by each quota format */
     310                 :            : struct quota_format_ops {
     311                 :            :         int (*check_quota_file)(struct super_block *sb, int type);      /* Detect whether file is in our format */
     312                 :            :         int (*read_file_info)(struct super_block *sb, int type);        /* Read main info about file - called on quotaon() */
     313                 :            :         int (*write_file_info)(struct super_block *sb, int type);       /* Write main info about file */
     314                 :            :         int (*free_file_info)(struct super_block *sb, int type);        /* Called on quotaoff() */
     315                 :            :         int (*read_dqblk)(struct dquot *dquot);         /* Read structure for one user */
     316                 :            :         int (*commit_dqblk)(struct dquot *dquot);       /* Write structure for one user */
     317                 :            :         int (*release_dqblk)(struct dquot *dquot);      /* Called when last reference to dquot is being dropped */
     318                 :            :         int (*get_next_id)(struct super_block *sb, struct kqid *qid);   /* Get next ID with existing structure in the quota file */
     319                 :            : };
     320                 :            : 
     321                 :            : /* Operations working with dquots */
     322                 :            : struct dquot_operations {
     323                 :            :         int (*write_dquot) (struct dquot *);            /* Ordinary dquot write */
     324                 :            :         struct dquot *(*alloc_dquot)(struct super_block *, int);        /* Allocate memory for new dquot */
     325                 :            :         void (*destroy_dquot)(struct dquot *);          /* Free memory for dquot */
     326                 :            :         int (*acquire_dquot) (struct dquot *);          /* Quota is going to be created on disk */
     327                 :            :         int (*release_dquot) (struct dquot *);          /* Quota is going to be deleted from disk */
     328                 :            :         int (*mark_dirty) (struct dquot *);             /* Dquot is marked dirty */
     329                 :            :         int (*write_info) (struct super_block *, int);  /* Write of quota "superblock" */
     330                 :            :         /* get reserved quota for delayed alloc, value returned is managed by
     331                 :            :          * quota code only */
     332                 :            :         qsize_t *(*get_reserved_space) (struct inode *);
     333                 :            :         int (*get_projid) (struct inode *, kprojid_t *);/* Get project ID */
     334                 :            :         /* Get number of inodes that were charged for a given inode */
     335                 :            :         int (*get_inode_usage) (struct inode *, qsize_t *);
     336                 :            :         /* Get next ID with active quota structure */
     337                 :            :         int (*get_next_id) (struct super_block *sb, struct kqid *qid);
     338                 :            : };
     339                 :            : 
     340                 :            : struct path;
     341                 :            : 
     342                 :            : /* Structure for communicating via ->get_dqblk() & ->set_dqblk() */
     343                 :            : struct qc_dqblk {
     344                 :            :         int d_fieldmask;        /* mask of fields to change in ->set_dqblk() */
     345                 :            :         u64 d_spc_hardlimit;    /* absolute limit on used space */
     346                 :            :         u64 d_spc_softlimit;    /* preferred limit on used space */
     347                 :            :         u64 d_ino_hardlimit;    /* maximum # allocated inodes */
     348                 :            :         u64 d_ino_softlimit;    /* preferred inode limit */
     349                 :            :         u64 d_space;            /* Space owned by the user */
     350                 :            :         u64 d_ino_count;        /* # inodes owned by the user */
     351                 :            :         s64 d_ino_timer;        /* zero if within inode limits */
     352                 :            :                                 /* if not, we refuse service */
     353                 :            :         s64 d_spc_timer;        /* similar to above; for space */
     354                 :            :         int d_ino_warns;        /* # warnings issued wrt num inodes */
     355                 :            :         int d_spc_warns;        /* # warnings issued wrt used space */
     356                 :            :         u64 d_rt_spc_hardlimit; /* absolute limit on realtime space */
     357                 :            :         u64 d_rt_spc_softlimit; /* preferred limit on RT space */
     358                 :            :         u64 d_rt_space;         /* realtime space owned */
     359                 :            :         s64 d_rt_spc_timer;     /* similar to above; for RT space */
     360                 :            :         int d_rt_spc_warns;     /* # warnings issued wrt RT space */
     361                 :            : };
     362                 :            : 
     363                 :            : /*
     364                 :            :  * Field specifiers for ->set_dqblk() in struct qc_dqblk and also for
     365                 :            :  * ->set_info() in struct qc_info
     366                 :            :  */
     367                 :            : #define QC_INO_SOFT     (1<<0)
     368                 :            : #define QC_INO_HARD     (1<<1)
     369                 :            : #define QC_SPC_SOFT     (1<<2)
     370                 :            : #define QC_SPC_HARD     (1<<3)
     371                 :            : #define QC_RT_SPC_SOFT  (1<<4)
     372                 :            : #define QC_RT_SPC_HARD  (1<<5)
     373                 :            : #define QC_LIMIT_MASK (QC_INO_SOFT | QC_INO_HARD | QC_SPC_SOFT | QC_SPC_HARD | \
     374                 :            :                        QC_RT_SPC_SOFT | QC_RT_SPC_HARD)
     375                 :            : #define QC_SPC_TIMER    (1<<6)
     376                 :            : #define QC_INO_TIMER    (1<<7)
     377                 :            : #define QC_RT_SPC_TIMER (1<<8)
     378                 :            : #define QC_TIMER_MASK (QC_SPC_TIMER | QC_INO_TIMER | QC_RT_SPC_TIMER)
     379                 :            : #define QC_SPC_WARNS    (1<<9)
     380                 :            : #define QC_INO_WARNS    (1<<10)
     381                 :            : #define QC_RT_SPC_WARNS (1<<11)
     382                 :            : #define QC_WARNS_MASK (QC_SPC_WARNS | QC_INO_WARNS | QC_RT_SPC_WARNS)
     383                 :            : #define QC_SPACE        (1<<12)
     384                 :            : #define QC_INO_COUNT    (1<<13)
     385                 :            : #define QC_RT_SPACE     (1<<14)
     386                 :            : #define QC_ACCT_MASK (QC_SPACE | QC_INO_COUNT | QC_RT_SPACE)
     387                 :            : #define QC_FLAGS        (1<<15)
     388                 :            : 
     389                 :            : #define QCI_SYSFILE             (1 << 0)  /* Quota file is hidden from userspace */
     390                 :            : #define QCI_ROOT_SQUASH         (1 << 1)  /* Root squash turned on */
     391                 :            : #define QCI_ACCT_ENABLED        (1 << 2)  /* Quota accounting enabled */
     392                 :            : #define QCI_LIMITS_ENFORCED     (1 << 3)  /* Quota limits enforced */
     393                 :            : 
     394                 :            : /* Structures for communicating via ->get_state */
     395                 :            : struct qc_type_state {
     396                 :            :         unsigned int flags;             /* Flags QCI_* */
     397                 :            :         unsigned int spc_timelimit;     /* Time after which space softlimit is
     398                 :            :                                          * enforced */
     399                 :            :         unsigned int ino_timelimit;     /* Ditto for inode softlimit */
     400                 :            :         unsigned int rt_spc_timelimit;  /* Ditto for real-time space */
     401                 :            :         unsigned int spc_warnlimit;     /* Limit for number of space warnings */
     402                 :            :         unsigned int ino_warnlimit;     /* Ditto for inodes */
     403                 :            :         unsigned int rt_spc_warnlimit;  /* Ditto for real-time space */
     404                 :            :         unsigned long long ino;         /* Inode number of quota file */
     405                 :            :         blkcnt_t blocks;                /* Number of 512-byte blocks in the file */
     406                 :            :         blkcnt_t nextents;              /* Number of extents in the file */
     407                 :            : };
     408                 :            : 
     409                 :            : struct qc_state {
     410                 :            :         unsigned int s_incoredqs;       /* Number of dquots in core */
     411                 :            :         struct qc_type_state s_state[MAXQUOTAS];  /* Per quota type information */
     412                 :            : };
     413                 :            : 
     414                 :            : /* Structure for communicating via ->set_info */
     415                 :            : struct qc_info {
     416                 :            :         int i_fieldmask;        /* mask of fields to change in ->set_info() */
     417                 :            :         unsigned int i_flags;           /* Flags QCI_* */
     418                 :            :         unsigned int i_spc_timelimit;   /* Time after which space softlimit is
     419                 :            :                                          * enforced */
     420                 :            :         unsigned int i_ino_timelimit;   /* Ditto for inode softlimit */
     421                 :            :         unsigned int i_rt_spc_timelimit;/* Ditto for real-time space */
     422                 :            :         unsigned int i_spc_warnlimit;   /* Limit for number of space warnings */
     423                 :            :         unsigned int i_ino_warnlimit;   /* Limit for number of inode warnings */
     424                 :            :         unsigned int i_rt_spc_warnlimit;        /* Ditto for real-time space */
     425                 :            : };
     426                 :            : 
     427                 :            : /* Operations handling requests from userspace */
     428                 :            : struct quotactl_ops {
     429                 :            :         int (*quota_on)(struct super_block *, int, int, const struct path *);
     430                 :            :         int (*quota_off)(struct super_block *, int);
     431                 :            :         int (*quota_enable)(struct super_block *, unsigned int);
     432                 :            :         int (*quota_disable)(struct super_block *, unsigned int);
     433                 :            :         int (*quota_sync)(struct super_block *, int);
     434                 :            :         int (*set_info)(struct super_block *, int, struct qc_info *);
     435                 :            :         int (*get_dqblk)(struct super_block *, struct kqid, struct qc_dqblk *);
     436                 :            :         int (*get_nextdqblk)(struct super_block *, struct kqid *,
     437                 :            :                              struct qc_dqblk *);
     438                 :            :         int (*set_dqblk)(struct super_block *, struct kqid, struct qc_dqblk *);
     439                 :            :         int (*get_state)(struct super_block *, struct qc_state *);
     440                 :            :         int (*rm_xquota)(struct super_block *, unsigned int);
     441                 :            : };
     442                 :            : 
     443                 :            : struct quota_format_type {
     444                 :            :         int qf_fmt_id;  /* Quota format id */
     445                 :            :         const struct quota_format_ops *qf_ops;  /* Operations of format */
     446                 :            :         struct module *qf_owner;                /* Module implementing quota format */
     447                 :            :         struct quota_format_type *qf_next;
     448                 :            : };
     449                 :            : 
     450                 :            : /**
     451                 :            :  * Quota state flags - they actually come in two flavors - for users and groups.
     452                 :            :  *
     453                 :            :  * Actual typed flags layout:
     454                 :            :  *                              USRQUOTA        GRPQUOTA
     455                 :            :  *  DQUOT_USAGE_ENABLED         0x0001          0x0002
     456                 :            :  *  DQUOT_LIMITS_ENABLED        0x0004          0x0008
     457                 :            :  *  DQUOT_SUSPENDED             0x0010          0x0020
     458                 :            :  *
     459                 :            :  * Following bits are used for non-typed flags:
     460                 :            :  *  DQUOT_QUOTA_SYS_FILE        0x0040
     461                 :            :  *  DQUOT_NEGATIVE_USAGE        0x0080
     462                 :            :  */
     463                 :            : enum {
     464                 :            :         _DQUOT_USAGE_ENABLED = 0,               /* Track disk usage for users */
     465                 :            :         _DQUOT_LIMITS_ENABLED,                  /* Enforce quota limits for users */
     466                 :            :         _DQUOT_SUSPENDED,                       /* User diskquotas are off, but
     467                 :            :                                                  * we have necessary info in
     468                 :            :                                                  * memory to turn them on */
     469                 :            :         _DQUOT_STATE_FLAGS
     470                 :            : };
     471                 :            : #define DQUOT_USAGE_ENABLED     (1 << _DQUOT_USAGE_ENABLED * MAXQUOTAS)
     472                 :            : #define DQUOT_LIMITS_ENABLED    (1 << _DQUOT_LIMITS_ENABLED * MAXQUOTAS)
     473                 :            : #define DQUOT_SUSPENDED         (1 << _DQUOT_SUSPENDED * MAXQUOTAS)
     474                 :            : #define DQUOT_STATE_FLAGS       (DQUOT_USAGE_ENABLED | DQUOT_LIMITS_ENABLED | \
     475                 :            :                                  DQUOT_SUSPENDED)
     476                 :            : /* Other quota flags */
     477                 :            : #define DQUOT_STATE_LAST        (_DQUOT_STATE_FLAGS * MAXQUOTAS)
     478                 :            : #define DQUOT_QUOTA_SYS_FILE    (1 << DQUOT_STATE_LAST)
     479                 :            :                                                 /* Quota file is a special
     480                 :            :                                                  * system file and user cannot
     481                 :            :                                                  * touch it. Filesystem is
     482                 :            :                                                  * responsible for setting
     483                 :            :                                                  * S_NOQUOTA, S_NOATIME flags
     484                 :            :                                                  */
     485                 :            : #define DQUOT_NEGATIVE_USAGE    (1 << (DQUOT_STATE_LAST + 1))
     486                 :            :                                                /* Allow negative quota usage */
     487                 :            : /* Do not track dirty dquots in a list */
     488                 :            : #define DQUOT_NOLIST_DIRTY      (1 << (DQUOT_STATE_LAST + 2))
     489                 :            : 
     490                 :            : static inline unsigned int dquot_state_flag(unsigned int flags, int type)
     491                 :            : {
     492                 :          3 :         return flags << type;
     493                 :            : }
     494                 :            : 
     495                 :            : static inline unsigned int dquot_generic_flag(unsigned int flags, int type)
     496                 :            : {
     497                 :          0 :         return (flags >> type) & DQUOT_STATE_FLAGS;
     498                 :            : }
     499                 :            : 
     500                 :            : /* Bitmap of quota types where flag is set in flags */
     501                 :            : static __always_inline unsigned dquot_state_types(unsigned flags, unsigned flag)
     502                 :            : {
     503                 :            :         BUILD_BUG_ON_NOT_POWER_OF_2(flag);
     504                 :          3 :         return (flags / flag) & ((1 << MAXQUOTAS) - 1);
     505                 :            : }
     506                 :            : 
     507                 :            : #ifdef CONFIG_QUOTA_NETLINK_INTERFACE
     508                 :            : extern void quota_send_warning(struct kqid qid, dev_t dev,
     509                 :            :                                const char warntype);
     510                 :            : #else
     511                 :            : static inline void quota_send_warning(struct kqid qid, dev_t dev,
     512                 :            :                                       const char warntype)
     513                 :            : {
     514                 :            :         return;
     515                 :            : }
     516                 :            : #endif /* CONFIG_QUOTA_NETLINK_INTERFACE */
     517                 :            : 
     518                 :            : struct quota_info {
     519                 :            :         unsigned int flags;                     /* Flags for diskquotas on this device */
     520                 :            :         struct rw_semaphore dqio_sem;           /* Lock quota file while I/O in progress */
     521                 :            :         struct inode *files[MAXQUOTAS];         /* inodes of quotafiles */
     522                 :            :         struct mem_dqinfo info[MAXQUOTAS];      /* Information for each quota type */
     523                 :            :         const struct quota_format_ops *ops[MAXQUOTAS];  /* Operations for each type */
     524                 :            : };
     525                 :            : 
     526                 :            : int register_quota_format(struct quota_format_type *fmt);
     527                 :            : void unregister_quota_format(struct quota_format_type *fmt);
     528                 :            : 
     529                 :            : struct quota_module_name {
     530                 :            :         int qm_fmt_id;
     531                 :            :         char *qm_mod_name;
     532                 :            : };
     533                 :            : 
     534                 :            : #define INIT_QUOTA_MODULE_NAMES {\
     535                 :            :         {QFMT_VFS_OLD, "quota_v1"},\
     536                 :            :         {QFMT_VFS_V0, "quota_v2"},\
     537                 :            :         {QFMT_VFS_V1, "quota_v2"},\
     538                 :            :         {0, NULL}}
     539                 :            : 
     540                 :            : #endif /* _QUOTA_ */