Green shading in the line number column means the source is part of the translation unit, red means it is conditionally excluded. Highlighted line numbers link to the translation unit page. Highlighted macros link to the macro page.
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: enum quota_type { 54: USRQUOTA = 0, /* element used for user quotas */ 55: GRPQUOTA = 1, /* element used for group quotas */ 56: PRJQUOTA = 2, /* element used for project quotas */ 57: }; 58: 59: typedef __kernel_uid32_t qid_t; /* Type in which we store ids in memory */ 60: typedef long long qsize_t; /* Type in which we store sizes */ 61: 62: struct kqid { /* Type in which we store the quota identifier */ 63: union { 64: kuid_t uid; 65: kgid_t gid; 66: kprojid_t projid; 67: }; 68: enum quota_type type; /* USRQUOTA (uid) or GRPQUOTA (gid) or PRJQUOTA (projid) */ 69: }; 70: 71: extern bool qid_eq(struct kqid left, struct kqid right); 72: extern bool qid_lt(struct kqid left, struct kqid right); 73: extern qid_t from_kqid(struct user_namespace *to, struct kqid qid); 74: extern qid_t from_kqid_munged(struct user_namespace *to, struct kqid qid); 75: extern bool qid_valid(struct kqid qid); 76: 77: /** 78: * make_kqid - Map a user-namespace, type, qid tuple into a kqid. 79: * @from: User namespace that the qid is in 80: * @type: The type of quota 81: * @qid: Quota identifier 82: * 83: * Maps a user-namespace, type qid tuple into a kernel internal 84: * kqid, and returns that kqid. 85: * 86: * When there is no mapping defined for the user-namespace, type, 87: * qid tuple an invalid kqid is returned. Callers are expected to 88: * test for and handle handle invalid kqids being returned. 89: * Invalid kqids may be tested for using qid_valid(). 90: */ 91: static inline struct kqid make_kqid(struct user_namespace *from, 92: enum quota_type type, qid_t qid) 93: { 94: struct kqid kqid; 95: 96: kqid.type = type; 97: switch (type) { 98: case USRQUOTA: 99: kqid.uid = make_kuid(from, qid); 100: break; 101: case GRPQUOTA: 102: kqid.gid = make_kgid(from, qid); 103: break; 104: case PRJQUOTA: 105: kqid.projid = make_kprojid(from, qid); 106: break; 107: default: 108: BUG(); 109: } 110: return kqid; 111: } 112: 113: /** 114: * make_kqid_invalid - Explicitly make an invalid kqid 115: * @type: The type of quota identifier 116: * 117: * Returns an invalid kqid with the specified type. 118: */ 119: static inline struct kqid make_kqid_invalid(enum quota_type type) 120: { 121: struct kqid kqid; 122: 123: kqid.type = type; 124: switch (type) { 125: case USRQUOTA: 126: kqid.uid = INVALID_UID; 127: break; 128: case GRPQUOTA: 129: kqid.gid = INVALID_GID; 130: break; 131: case PRJQUOTA: 132: kqid.projid = INVALID_PROJID; 133: break; 134: default: 135: BUG(); 136: } 137: return kqid; 138: } 139: 140: /** 141: * make_kqid_uid - Make a kqid from a kuid 142: * @uid: The kuid to make the quota identifier from 143: */ 144: static inline struct kqid make_kqid_uid(kuid_t uid) 145: { 146: struct kqid kqid; 147: kqid.type = USRQUOTA; 148: kqid.uid = uid; 149: return kqid; 150: } 151: 152: /** 153: * make_kqid_gid - Make a kqid from a kgid 154: * @gid: The kgid to make the quota identifier from 155: */ 156: static inline struct kqid make_kqid_gid(kgid_t gid) 157: { 158: struct kqid kqid; 159: kqid.type = GRPQUOTA; 160: kqid.gid = gid; 161: return kqid; 162: } 163: 164: /** 165: * make_kqid_projid - Make a kqid from a projid 166: * @projid: The kprojid to make the quota identifier from 167: */ 168: static inline struct kqid make_kqid_projid(kprojid_t projid) 169: { 170: struct kqid kqid; 171: kqid.type = PRJQUOTA; 172: kqid.projid = projid; 173: return kqid; 174: } 175: 176: 177: extern spinlock_t dq_data_lock; 178: 179: /* Maximal numbers of writes for quota operation (insert/delete/update) 180: * (over VFS all formats) */ 181: #define DQUOT_INIT_ALLOC max(V1_INIT_ALLOC, V2_INIT_ALLOC) 182: #define DQUOT_INIT_REWRITE max(V1_INIT_REWRITE, V2_INIT_REWRITE) 183: #define DQUOT_DEL_ALLOC max(V1_DEL_ALLOC, V2_DEL_ALLOC) 184: #define DQUOT_DEL_REWRITE max(V1_DEL_REWRITE, V2_DEL_REWRITE) 185: 186: /* 187: * Data for one user/group kept in memory 188: */ 189: struct mem_dqblk { 190: qsize_t dqb_bhardlimit; /* absolute limit on disk blks alloc */ 191: qsize_t dqb_bsoftlimit; /* preferred limit on disk blks */ 192: qsize_t dqb_curspace; /* current used space */ 193: qsize_t dqb_rsvspace; /* current reserved space for delalloc*/ 194: qsize_t dqb_ihardlimit; /* absolute limit on allocated inodes */ 195: qsize_t dqb_isoftlimit; /* preferred inode limit */ 196: qsize_t dqb_curinodes; /* current # allocated inodes */ 197: time_t dqb_btime; /* time limit for excessive disk use */ 198: time_t dqb_itime; /* time limit for excessive inode use */ 199: }; 200: 201: /* 202: * Data for one quotafile kept in memory 203: */ 204: struct quota_format_type; 205: 206: struct mem_dqinfo { 207: struct quota_format_type *dqi_format; 208: int dqi_fmt_id; /* Id of the dqi_format - used when turning 209: * quotas on after remount RW */ 210: struct list_head dqi_dirty_list; /* List of dirty dquots */ 211: unsigned long dqi_flags; 212: unsigned int dqi_bgrace; 213: unsigned int dqi_igrace; 214: qsize_t dqi_maxblimit; 215: qsize_t dqi_maxilimit; 216: void *dqi_priv; 217: }; 218: 219: struct super_block; 220: 221: #define DQF_MASK 0xffff /* Mask for format specific flags */ 222: #define DQF_GETINFO_MASK 0x1ffff /* Mask for flags passed to userspace */ 223: #define DQF_SETINFO_MASK 0xffff /* Mask for flags modifiable from userspace */ 224: #define DQF_SYS_FILE_B 16 225: #define DQF_SYS_FILE (1 << DQF_SYS_FILE_B) /* Quota file stored as system file */ 226: #define DQF_INFO_DIRTY_B 31 227: #define DQF_INFO_DIRTY (1 << DQF_INFO_DIRTY_B) /* Is info dirty? */ 228: 229: extern void mark_info_dirty(struct super_block *sb, int type); 230: static inline int info_dirty(struct mem_dqinfo *info) 231: { 232: return test_bit(DQF_INFO_DIRTY_B, &info->dqi_flags); 233: } 234: 235: enum { 236: DQST_LOOKUPS, 237: DQST_DROPS, 238: DQST_READS, 239: DQST_WRITES, 240: DQST_CACHE_HITS, 241: DQST_ALLOC_DQUOTS, 242: DQST_FREE_DQUOTS, 243: DQST_SYNCS, 244: _DQST_DQSTAT_LAST 245: }; 246: 247: struct dqstats { 248: int stat[_DQST_DQSTAT_LAST]; 249: struct percpu_counter counter[_DQST_DQSTAT_LAST]; 250: }; 251: 252: extern struct dqstats *dqstats_pcpu; 253: extern struct dqstats dqstats; 254: 255: static inline void dqstats_inc(unsigned int type) 256: { 257: percpu_counter_inc(&dqstats.counter[type]); 258: } 259: 260: static inline void dqstats_dec(unsigned int type) 261: { 262: percpu_counter_dec(&dqstats.counter[type]); 263: } 264: 265: #define DQ_MOD_B 0 /* dquot modified since read */ 266: #define DQ_BLKS_B 1 /* uid/gid has been warned about blk limit */ 267: #define DQ_INODES_B 2 /* uid/gid has been warned about inode limit */ 268: #define DQ_FAKE_B 3 /* no limits only usage */ 269: #define DQ_READ_B 4 /* dquot was read into memory */ 270: #define DQ_ACTIVE_B 5 /* dquot is active (dquot_release not called) */ 271: #define DQ_LASTSET_B 6 /* Following 6 bits (see QIF_) are reserved\ 272: * for the mask of entries set via SETQUOTA\ 273: * quotactl. They are set under dq_data_lock\ 274: * and the quota format handling dquot can\ 275: * clear them when it sees fit. */ 276: 277: struct dquot { 278: struct hlist_node dq_hash; /* Hash list in memory */ 279: struct list_head dq_inuse; /* List of all quotas */ 280: struct list_head dq_free; /* Free list element */ 281: struct list_head dq_dirty; /* List of dirty dquots */ 282: struct mutex dq_lock; /* dquot IO lock */ 283: atomic_t dq_count; /* Use count */ 284: wait_queue_head_t dq_wait_unused; /* Wait queue for dquot to become unused */ 285: struct super_block *dq_sb; /* superblock this applies to */ 286: struct kqid dq_id; /* ID this applies to (uid, gid, projid) */ 287: loff_t dq_off; /* Offset of dquot on disk */ 288: unsigned long dq_flags; /* See DQ_* */ 289: struct mem_dqblk dq_dqb; /* Diskquota usage */ 290: }; 291: 292: /* Operations which must be implemented by each quota format */ 293: struct quota_format_ops { 294: int (*check_quota_file)(struct super_block *sb, int type); /* Detect whether file is in our format */ 295: int (*read_file_info)(struct super_block *sb, int type); /* Read main info about file - called on quotaon() */ 296: int (*write_file_info)(struct super_block *sb, int type); /* Write main info about file */ 297: int (*free_file_info)(struct super_block *sb, int type); /* Called on quotaoff() */ 298: int (*read_dqblk)(struct dquot *dquot); /* Read structure for one user */ 299: int (*commit_dqblk)(struct dquot *dquot); /* Write structure for one user */ 300: int (*release_dqblk)(struct dquot *dquot); /* Called when last reference to dquot is being dropped */ 301: }; 302: 303: /* Operations working with dquots */ 304: struct dquot_operations { 305: int (*write_dquot) (struct dquot *); /* Ordinary dquot write */ 306: struct dquot *(*alloc_dquot)(struct super_block *, int); /* Allocate memory for new dquot */ 307: void (*destroy_dquot)(struct dquot *); /* Free memory for dquot */ 308: int (*acquire_dquot) (struct dquot *); /* Quota is going to be created on disk */ 309: int (*release_dquot) (struct dquot *); /* Quota is going to be deleted from disk */ 310: int (*mark_dirty) (struct dquot *); /* Dquot is marked dirty */ 311: int (*write_info) (struct super_block *, int); /* Write of quota "superblock" */ 312: /* get reserved quota for delayed alloc, value returned is managed by 313: * quota code only */ 314: qsize_t *(*get_reserved_space) (struct inode *); 315: }; 316: 317: struct path; 318: 319: /* Operations handling requests from userspace */ 320: struct quotactl_ops { 321: int (*quota_on)(struct super_block *, int, int, struct path *); 322: int (*quota_on_meta)(struct super_block *, int, int); 323: int (*quota_off)(struct super_block *, int); 324: int (*quota_sync)(struct super_block *, int); 325: int (*get_info)(struct super_block *, int, struct if_dqinfo *); 326: int (*set_info)(struct super_block *, int, struct if_dqinfo *); 327: int (*get_dqblk)(struct super_block *, struct kqid, struct fs_disk_quota *); 328: int (*set_dqblk)(struct super_block *, struct kqid, struct fs_disk_quota *); 329: int (*get_xstate)(struct super_block *, struct fs_quota_stat *); 330: int (*set_xstate)(struct super_block *, unsigned int, int); 331: int (*get_xstatev)(struct super_block *, struct fs_quota_statv *); 332: }; 333: 334: struct quota_format_type { 335: int qf_fmt_id; /* Quota format id */ 336: const struct quota_format_ops *qf_ops; /* Operations of format */ 337: struct module *qf_owner; /* Module implementing quota format */ 338: struct quota_format_type *qf_next; 339: }; 340: 341: /* Quota state flags - they actually come in two flavors - for users and groups */ 342: enum { 343: _DQUOT_USAGE_ENABLED = 0, /* Track disk usage for users */ 344: _DQUOT_LIMITS_ENABLED, /* Enforce quota limits for users */ 345: _DQUOT_SUSPENDED, /* User diskquotas are off, but 346: * we have necessary info in 347: * memory to turn them on */ 348: _DQUOT_STATE_FLAGS 349: }; 350: #define DQUOT_USAGE_ENABLED (1 << _DQUOT_USAGE_ENABLED) 351: #define DQUOT_LIMITS_ENABLED (1 << _DQUOT_LIMITS_ENABLED) 352: #define DQUOT_SUSPENDED (1 << _DQUOT_SUSPENDED) 353: #define DQUOT_STATE_FLAGS (DQUOT_USAGE_ENABLED | DQUOT_LIMITS_ENABLED | \ 354: DQUOT_SUSPENDED) 355: /* Other quota flags */ 356: #define DQUOT_STATE_LAST (_DQUOT_STATE_FLAGS * MAXQUOTAS) 357: #define DQUOT_QUOTA_SYS_FILE (1 << DQUOT_STATE_LAST) 358: /* Quota file is a special 359: * system file and user cannot 360: * touch it. Filesystem is 361: * responsible for setting 362: * S_NOQUOTA, S_NOATIME flags 363: */ 364: #define DQUOT_NEGATIVE_USAGE (1 << (DQUOT_STATE_LAST + 1)) 365: /* Allow negative quota usage */ 366: 367: static inline unsigned int dquot_state_flag(unsigned int flags, int type) 368: { 369: return flags << _DQUOT_STATE_FLAGS * type; 370: } 371: 372: static inline unsigned int dquot_generic_flag(unsigned int flags, int type) 373: { 374: return (flags >> _DQUOT_STATE_FLAGS * type) & DQUOT_STATE_FLAGS; 375: } 376: 377: #ifdef CONFIG_QUOTA_NETLINK_INTERFACE 378: extern void quota_send_warning(struct kqid qid, dev_t dev, 379: const char warntype); 380: #else 381: static inline void quota_send_warning(struct kqid qid, dev_t dev, 382: const char warntype) 383: { 384: return; 385: } 386: #endif /* CONFIG_QUOTA_NETLINK_INTERFACE */ 387: 388: struct quota_info { 389: unsigned int flags; /* Flags for diskquotas on this device */ 390: struct mutex dqio_mutex; /* lock device while I/O in progress */ 391: struct mutex dqonoff_mutex; /* Serialize quotaon & quotaoff */ 392: struct rw_semaphore dqptr_sem; /* serialize ops using quota_info struct, pointers from inode to dquots */ 393: struct inode *files[MAXQUOTAS]; /* inodes of quotafiles */ 394: struct mem_dqinfo info[MAXQUOTAS]; /* Information for each quota type */ 395: const struct quota_format_ops *ops[MAXQUOTAS]; /* Operations for each type */ 396: }; 397: 398: int register_quota_format(struct quota_format_type *fmt); 399: void unregister_quota_format(struct quota_format_type *fmt); 400: 401: struct quota_module_name { 402: int qm_fmt_id; 403: char *qm_mod_name; 404: }; 405: 406: #define INIT_QUOTA_MODULE_NAMES {\ {QFMT_VFS_OLD, "quota_v1"},\ {QFMT_VFS_V0, "quota_v2"},\ {QFMT_VFS_V1, "quota_v2"},\ {0, NULL}} 411: 412: #endif /* _QUOTA_ */ 413: