// SPDX-License-Identifier: GPL-2.0 /* * Implementation of the diskquota system for the LINUX operating system. QUOTA * is implemented using the BSD system call interface as the means of * communication with the user level. This file contains the generic routines * called by the different filesystems on allocation of an inode or block. * These routines take care of the administration needed to have a consistent * diskquota tracking system. The ideas of both user and group quotas are based * on the Melbourne quota system as used on BSD derived systems. The internal * implementation is based on one of the several variants of the LINUX * inode-subsystem with added complexity of the diskquota system. * * Author: Marco van Wieringen <[email protected]> * * Fixes: Dmitry Gorodchanin <[email protected]>, 11 Feb 96 * * Revised list management to avoid races * -- Bill Hawes, <[email protected]>, 9/98 * * Fixed races in dquot_transfer(), dqget() and dquot_alloc_...(). * As the consequence the locking was moved from dquot_decr_...(), * dquot_incr_...() to calling functions. * invalidate_dquots() now writes modified dquots. * Serialized quota_off() and quota_on() for mount point. * Fixed a few bugs in grow_dquots(). * Fixed deadlock in write_dquot() - we no longer account quotas on * quota files * remove_dquot_ref() moved to inode.c - it now traverses through inodes * add_dquot_ref() restarts after blocking * Added check for bogus uid and fixed check for group in quotactl. * Jan Kara, <[email protected]>, sponsored by SuSE CR, 10-11/99 * * Used struct list_head instead of own list struct * Invalidation of referenced dquots is no longer possible * Improved free_dquots list management * Quota and i_blocks are now updated in one place to avoid races * Warnings are now delayed so we won't block in critical section * Write updated not to require dquot lock * Jan Kara, <[email protected]>, 9/2000 * * Added dynamic quota structure allocation * Jan Kara <[email protected]> 12/2000 * * Rewritten quota interface. Implemented new quota format and * formats registering. * Jan Kara, <[email protected]>, 2001,2002 * * New SMP locking. * Jan Kara, <[email protected]>, 10/2002 * * Added journalled quota support, fix lock inversion problems * Jan Kara, <[email protected]>, 2003,2004 * * (C) Copyright 1994 - 1997 Marco van Wieringen */ #include <linux/errno.h> #include <linux/kernel.h> #include <linux/fs.h> #include <linux/mount.h> #include <linux/mm.h> #include <linux/time.h> #include <linux/types.h> #include <linux/string.h> #include <linux/fcntl.h> #include <linux/stat.h> #include <linux/tty.h> #include <linux/file.h> #include <linux/slab.h> #include <linux/sysctl.h> #include <linux/init.h> #include <linux/module.h> #include <linux/proc_fs.h> #include <linux/security.h> #include <linux/sched.h> #include <linux/cred.h> #include <linux/kmod.h> #include <linux/namei.h> #include <linux/capability.h> #include <linux/quotaops.h> #include <linux/blkdev.h> #include <linux/sched/mm.h> #include "../internal.h" /* ugh */ #include <linux/uaccess.h> /* * There are five quota SMP locks: * * dq_list_lock protects all lists with quotas and quota formats. * * dquot->dq_dqb_lock protects data from dq_dqb * * inode->i_lock protects inode->i_blocks, i_bytes and also guards * consistency of dquot->dq_dqb with inode->i_blocks, i_bytes so that * dquot_transfer() can stabilize amount it transfers * * dq_data_lock protects mem_dqinfo structures and modifications of dquot * pointers in the inode * * dq_state_lock protects modifications of quota state (on quotaon and * quotaoff) and readers who care about latest values take it as well. * * The spinlock ordering is hence: * dq_data_lock > dq_list_lock > i_lock > dquot->dq_dqb_lock, * dq_list_lock > dq_state_lock * * Note that some things (eg. sb pointer, type, id) doesn't change during * the life of the dquot structure and so needn't to be protected by a lock * * Operation accessing dquots via inode pointers are protected by dquot_srcu. * Operation of reading pointer needs srcu_read_lock(&dquot_srcu), and * synchronize_srcu(&dquot_srcu) is called after clearing pointers from * inode and before dropping dquot references to avoid use of dquots after * they are freed. dq_data_lock is used to serialize the pointer setting and * clearing operations. * Special care needs to be taken about S_NOQUOTA inode flag (marking that * inode is a quota file). Functions adding pointers from inode to dquots have * to check this flag under dq_data_lock and then (if S_NOQUOTA is not set) they * have to do all pointer modifications before dropping dq_data_lock. This makes * sure they cannot race with quotaon which first sets S_NOQUOTA flag and * then drops all pointers to dquots from an inode. * * Each dquot has its dq_lock mutex. Dquot is locked when it is being read to * memory (or space for it is being allocated) on the first dqget(), when it is * being written out, and when it is being released on the last dqput(). The * allocation and release operations are serialized by the dq_lock and by * checking the use count in dquot_release(). * * Lock ordering (including related VFS locks) is the following: * s_umount > i_mutex > journal_lock > dquot->dq_lock > dqio_sem */ static __cacheline_aligned_in_smp DEFINE_SPINLOCK(dq_list_lock); static __cacheline_aligned_in_smp DEFINE_SPINLOCK(dq_state_lock); __cacheline_aligned_in_smp DEFINE_SPINLOCK(…); EXPORT_SYMBOL(…); DEFINE_STATIC_SRCU(…); static DECLARE_WAIT_QUEUE_HEAD(dquot_ref_wq); void __quota_error(struct super_block *sb, const char *func, const char *fmt, ...) { … } EXPORT_SYMBOL(…); #if defined(CONFIG_QUOTA_DEBUG) || defined(CONFIG_PRINT_QUOTA_WARNING) static char *quotatypes[] = INITQFNAMES; #endif static struct quota_format_type *quota_formats; /* List of registered formats */ static struct quota_module_name module_names[] = …; /* SLAB cache for dquot structures */ static struct kmem_cache *dquot_cachep; int register_quota_format(struct quota_format_type *fmt) { … } EXPORT_SYMBOL(…); void unregister_quota_format(struct quota_format_type *fmt) { … } EXPORT_SYMBOL(…); static struct quota_format_type *find_quota_format(int id) { … } static void put_quota_format(struct quota_format_type *fmt) { … } /* * Dquot List Management: * The quota code uses five lists for dquot management: the inuse_list, * releasing_dquots, free_dquots, dqi_dirty_list, and dquot_hash[] array. * A single dquot structure may be on some of those lists, depending on * its current state. * * All dquots are placed to the end of inuse_list when first created, and this * list is used for invalidate operation, which must look at every dquot. * * When the last reference of a dquot is dropped, the dquot is added to * releasing_dquots. We'll then queue work item which will call * synchronize_srcu() and after that perform the final cleanup of all the * dquots on the list. Each cleaned up dquot is moved to free_dquots list. * Both releasing_dquots and free_dquots use the dq_free list_head in the dquot * struct. * * Unused and cleaned up dquots are in the free_dquots list and this list is * searched whenever we need an available dquot. Dquots are removed from the * list as soon as they are used again and dqstats.free_dquots gives the number * of dquots on the list. When dquot is invalidated it's completely released * from memory. * * Dirty dquots are added to the dqi_dirty_list of quota_info when mark * dirtied, and this list is searched when writing dirty dquots back to * quota file. Note that some filesystems do dirty dquot tracking on their * own (e.g. in a journal) and thus don't use dqi_dirty_list. * * Dquots with a specific identity (device, type and id) are placed on * one of the dquot_hash[] hash chains. The provides an efficient search * mechanism to locate a specific dquot. */ static LIST_HEAD(inuse_list); static LIST_HEAD(free_dquots); static LIST_HEAD(releasing_dquots); static unsigned int dq_hash_bits, dq_hash_mask; static struct hlist_head *dquot_hash; struct dqstats dqstats; EXPORT_SYMBOL(…); static qsize_t inode_get_rsv_space(struct inode *inode); static qsize_t __inode_get_rsv_space(struct inode *inode); static int __dquot_initialize(struct inode *inode, int type); static void quota_release_workfn(struct work_struct *work); static DECLARE_DELAYED_WORK(quota_release_work, quota_release_workfn); static inline unsigned int hashfn(const struct super_block *sb, struct kqid qid) { … } /* * Following list functions expect dq_list_lock to be held */ static inline void insert_dquot_hash(struct dquot *dquot) { … } static inline void remove_dquot_hash(struct dquot *dquot) { … } static struct dquot *find_dquot(unsigned int hashent, struct super_block *sb, struct kqid qid) { … } /* Add a dquot to the tail of the free list */ static inline void put_dquot_last(struct dquot *dquot) { … } static inline void put_releasing_dquots(struct dquot *dquot) { … } static inline void remove_free_dquot(struct dquot *dquot) { … } static inline void put_inuse(struct dquot *dquot) { … } static inline void remove_inuse(struct dquot *dquot) { … } /* * End of list functions needing dq_list_lock */ static void wait_on_dquot(struct dquot *dquot) { … } static inline int dquot_active(struct dquot *dquot) { … } static inline int dquot_dirty(struct dquot *dquot) { … } static inline int mark_dquot_dirty(struct dquot *dquot) { … } /* Mark dquot dirty in atomic manner, and return it's old dirty flag state */ int dquot_mark_dquot_dirty(struct dquot *dquot) { … } EXPORT_SYMBOL(…); /* Dirtify all the dquots - this can block when journalling */ static inline int mark_all_dquot_dirty(struct dquot __rcu * const *dquots) { … } static inline void dqput_all(struct dquot **dquot) { … } static inline int clear_dquot_dirty(struct dquot *dquot) { … } void mark_info_dirty(struct super_block *sb, int type) { … } EXPORT_SYMBOL(…); /* * Read dquot from disk and alloc space for it */ int dquot_acquire(struct dquot *dquot) { … } EXPORT_SYMBOL(…); /* * Write dquot to disk */ int dquot_commit(struct dquot *dquot) { … } EXPORT_SYMBOL(…); /* * Release dquot */ int dquot_release(struct dquot *dquot) { … } EXPORT_SYMBOL(…); void dquot_destroy(struct dquot *dquot) { … } EXPORT_SYMBOL(…); static inline void do_destroy_dquot(struct dquot *dquot) { … } /* Invalidate all dquots on the list. Note that this function is called after * quota is disabled and pointers from inodes removed so there cannot be new * quota users. There can still be some users of quotas due to inodes being * just deleted or pruned by prune_icache() (those are not attached to any * list) or parallel quotactl call. We have to wait for such users. */ static void invalidate_dquots(struct super_block *sb, int type) { … } /* Call callback for every active dquot on given filesystem */ int dquot_scan_active(struct super_block *sb, int (*fn)(struct dquot *dquot, unsigned long priv), unsigned long priv) { … } EXPORT_SYMBOL(…); static inline int dquot_write_dquot(struct dquot *dquot) { … } /* Write all dquot structures to quota files */ int dquot_writeback_dquots(struct super_block *sb, int type) { … } EXPORT_SYMBOL(…); /* Write all dquot structures to disk and make them visible from userspace */ int dquot_quota_sync(struct super_block *sb, int type) { … } EXPORT_SYMBOL(…); static unsigned long dqcache_shrink_scan(struct shrinker *shrink, struct shrink_control *sc) { … } static unsigned long dqcache_shrink_count(struct shrinker *shrink, struct shrink_control *sc) { … } /* * Safely release dquot and put reference to dquot. */ static void quota_release_workfn(struct work_struct *work) { … } /* * Put reference to dquot */ void dqput(struct dquot *dquot) { … } EXPORT_SYMBOL(…); struct dquot *dquot_alloc(struct super_block *sb, int type) { … } EXPORT_SYMBOL(…); static struct dquot *get_empty_dquot(struct super_block *sb, int type) { … } /* * Get reference to dquot * * Locking is slightly tricky here. We are guarded from parallel quotaoff() * destroying our dquot by: * a) checking for quota flags under dq_list_lock and * b) getting a reference to dquot before we release dq_list_lock */ struct dquot *dqget(struct super_block *sb, struct kqid qid) { … } EXPORT_SYMBOL(…); static inline struct dquot __rcu **i_dquot(struct inode *inode) { … } static int dqinit_needed(struct inode *inode, int type) { … } /* This routine is guarded by s_umount semaphore */ static int add_dquot_ref(struct super_block *sb, int type) { … } static void remove_dquot_ref(struct super_block *sb, int type) { … } /* Gather all references from inodes and drop them */ static void drop_dquot_ref(struct super_block *sb, int type) { … } static inline void dquot_free_reserved_space(struct dquot *dquot, qsize_t number) { … } static void dquot_decr_inodes(struct dquot *dquot, qsize_t number) { … } static void dquot_decr_space(struct dquot *dquot, qsize_t number) { … } struct dquot_warn { … }; static int warning_issued(struct dquot *dquot, const int warntype) { … } #ifdef CONFIG_PRINT_QUOTA_WARNING static int flag_print_warnings = 1; static int need_print_warning(struct dquot_warn *warn) { if (!flag_print_warnings) return 0; switch (warn->w_dq_id.type) { case USRQUOTA: return uid_eq(current_fsuid(), warn->w_dq_id.uid); case GRPQUOTA: return in_group_p(warn->w_dq_id.gid); case PRJQUOTA: return 1; } return 0; } /* Print warning to user which exceeded quota */ static void print_warning(struct dquot_warn *warn) { char *msg = NULL; struct tty_struct *tty; int warntype = warn->w_type; if (warntype == QUOTA_NL_IHARDBELOW || warntype == QUOTA_NL_ISOFTBELOW || warntype == QUOTA_NL_BHARDBELOW || warntype == QUOTA_NL_BSOFTBELOW || !need_print_warning(warn)) return; tty = get_current_tty(); if (!tty) return; tty_write_message(tty, warn->w_sb->s_id); if (warntype == QUOTA_NL_ISOFTWARN || warntype == QUOTA_NL_BSOFTWARN) tty_write_message(tty, ": warning, "); else tty_write_message(tty, ": write failed, "); tty_write_message(tty, quotatypes[warn->w_dq_id.type]); switch (warntype) { case QUOTA_NL_IHARDWARN: msg = " file limit reached.\r\n"; break; case QUOTA_NL_ISOFTLONGWARN: msg = " file quota exceeded too long.\r\n"; break; case QUOTA_NL_ISOFTWARN: msg = " file quota exceeded.\r\n"; break; case QUOTA_NL_BHARDWARN: msg = " block limit reached.\r\n"; break; case QUOTA_NL_BSOFTLONGWARN: msg = " block quota exceeded too long.\r\n"; break; case QUOTA_NL_BSOFTWARN: msg = " block quota exceeded.\r\n"; break; } tty_write_message(tty, msg); tty_kref_put(tty); } #endif static void prepare_warning(struct dquot_warn *warn, struct dquot *dquot, int warntype) { … } /* * Write warnings to the console and send warning messages over netlink. * * Note that this function can call into tty and networking code. */ static void flush_warnings(struct dquot_warn *warn) { … } static int ignore_hardlimit(struct dquot *dquot) { … } static int dquot_add_inodes(struct dquot *dquot, qsize_t inodes, struct dquot_warn *warn) { … } static int dquot_add_space(struct dquot *dquot, qsize_t space, qsize_t rsv_space, unsigned int flags, struct dquot_warn *warn) { … } static int info_idq_free(struct dquot *dquot, qsize_t inodes) { … } static int info_bdq_free(struct dquot *dquot, qsize_t space) { … } static int inode_quota_active(const struct inode *inode) { … } /* * Initialize quota pointers in inode * * It is better to call this function outside of any transaction as it * might need a lot of space in journal for dquot structure allocation. */ static int __dquot_initialize(struct inode *inode, int type) { … } int dquot_initialize(struct inode *inode) { … } EXPORT_SYMBOL(…); bool dquot_initialize_needed(struct inode *inode) { … } EXPORT_SYMBOL(…); /* * Release all quotas referenced by inode. * * This function only be called on inode free or converting * a file to quota file, no other users for the i_dquot in * both cases, so we needn't call synchronize_srcu() after * clearing i_dquot. */ static void __dquot_drop(struct inode *inode) { … } void dquot_drop(struct inode *inode) { … } EXPORT_SYMBOL(…); /* * inode_reserved_space is managed internally by quota, and protected by * i_lock similar to i_blocks+i_bytes. */ static qsize_t *inode_reserved_space(struct inode * inode) { … } static qsize_t __inode_get_rsv_space(struct inode *inode) { … } static qsize_t inode_get_rsv_space(struct inode *inode) { … } /* * This functions updates i_blocks+i_bytes fields and quota information * (together with appropriate checks). * * NOTE: We absolutely rely on the fact that caller dirties the inode * (usually helpers in quotaops.h care about this) and holds a handle for * the current transaction so that dquot write and inode write go into the * same transaction. */ /* * This operation can block, but only after everything is updated */ int __dquot_alloc_space(struct inode *inode, qsize_t number, int flags) { … } EXPORT_SYMBOL(…); /* * This operation can block, but only after everything is updated */ int dquot_alloc_inode(struct inode *inode) { … } EXPORT_SYMBOL(…); /* * Convert in-memory reserved quotas to real consumed quotas */ void dquot_claim_space_nodirty(struct inode *inode, qsize_t number) { … } EXPORT_SYMBOL(…); /* * Convert allocated space back to in-memory reserved quotas */ void dquot_reclaim_space_nodirty(struct inode *inode, qsize_t number) { … } EXPORT_SYMBOL(…); /* * This operation can block, but only after everything is updated */ void __dquot_free_space(struct inode *inode, qsize_t number, int flags) { … } EXPORT_SYMBOL(…); /* * This operation can block, but only after everything is updated */ void dquot_free_inode(struct inode *inode) { … } EXPORT_SYMBOL(…); /* * Transfer the number of inode and blocks from one diskquota to an other. * On success, dquot references in transfer_to are consumed and references * to original dquots that need to be released are placed there. On failure, * references are kept untouched. * * This operation can block, but only after everything is updated * A transaction must be started when entering this function. * * We are holding reference on transfer_from & transfer_to, no need to * protect them by srcu_read_lock(). */ int __dquot_transfer(struct inode *inode, struct dquot **transfer_to) { … } EXPORT_SYMBOL(…); /* Wrapper for transferring ownership of an inode for uid/gid only * Called from FSXXX_setattr() */ int dquot_transfer(struct mnt_idmap *idmap, struct inode *inode, struct iattr *iattr) { … } EXPORT_SYMBOL(…); /* * Write info of quota file to disk */ int dquot_commit_info(struct super_block *sb, int type) { … } EXPORT_SYMBOL(…); int dquot_get_next_id(struct super_block *sb, struct kqid *qid) { … } EXPORT_SYMBOL(…); /* * Definitions of diskquota operations. */ const struct dquot_operations dquot_operations = …; EXPORT_SYMBOL(…); /* * Generic helper for ->open on filesystems supporting disk quotas. */ int dquot_file_open(struct inode *inode, struct file *file) { … } EXPORT_SYMBOL(…); static void vfs_cleanup_quota_inode(struct super_block *sb, int type) { … } /* * Turn quota off on a device. type == -1 ==> quotaoff for all types (umount) */ int dquot_disable(struct super_block *sb, int type, unsigned int flags) { … } EXPORT_SYMBOL(…); int dquot_quota_off(struct super_block *sb, int type) { … } EXPORT_SYMBOL(…); /* * Turn quotas on on a device */ static int vfs_setup_quota_inode(struct inode *inode, int type) { … } int dquot_load_quota_sb(struct super_block *sb, int type, int format_id, unsigned int flags) { … } EXPORT_SYMBOL(…); /* * More powerful function for turning on quotas on given quota inode allowing * setting of individual quota flags */ int dquot_load_quota_inode(struct inode *inode, int type, int format_id, unsigned int flags) { … } EXPORT_SYMBOL(…); /* Reenable quotas on remount RW */ int dquot_resume(struct super_block *sb, int type) { … } EXPORT_SYMBOL(…); int dquot_quota_on(struct super_block *sb, int type, int format_id, const struct path *path) { … } EXPORT_SYMBOL(…); /* * This function is used when filesystem needs to initialize quotas * during mount time. */ int dquot_quota_on_mount(struct super_block *sb, char *qf_name, int format_id, int type) { … } EXPORT_SYMBOL(…); static int dquot_quota_enable(struct super_block *sb, unsigned int flags) { … } static int dquot_quota_disable(struct super_block *sb, unsigned int flags) { … } /* Generic routine for getting common part of quota structure */ static void do_get_dqblk(struct dquot *dquot, struct qc_dqblk *di) { … } int dquot_get_dqblk(struct super_block *sb, struct kqid qid, struct qc_dqblk *di) { … } EXPORT_SYMBOL(…); int dquot_get_next_dqblk(struct super_block *sb, struct kqid *qid, struct qc_dqblk *di) { … } EXPORT_SYMBOL(…); #define VFS_QC_MASK … /* Generic routine for setting common part of quota structure */ static int do_set_dqblk(struct dquot *dquot, struct qc_dqblk *di) { … } int dquot_set_dqblk(struct super_block *sb, struct kqid qid, struct qc_dqblk *di) { … } EXPORT_SYMBOL(…); /* Generic routine for getting common part of quota file information */ int dquot_get_state(struct super_block *sb, struct qc_state *state) { … } EXPORT_SYMBOL(…); /* Generic routine for setting common part of quota file information */ int dquot_set_dqinfo(struct super_block *sb, int type, struct qc_info *ii) { … } EXPORT_SYMBOL(…); const struct quotactl_ops dquot_quotactl_sysfile_ops = …; EXPORT_SYMBOL(…); static int do_proc_dqstats(const struct ctl_table *table, int write, void *buffer, size_t *lenp, loff_t *ppos) { … } static struct ctl_table fs_dqstats_table[] = …; static int __init dquot_init(void) { … } fs_initcall(dquot_init);
Codebase Browser
linux