1b2441318SGreg Kroah-Hartman // SPDX-License-Identifier: GPL-2.0 2884d179dSJan Kara /* 3884d179dSJan Kara * Implementation of the diskquota system for the LINUX operating system. QUOTA 4884d179dSJan Kara * is implemented using the BSD system call interface as the means of 5884d179dSJan Kara * communication with the user level. This file contains the generic routines 6884d179dSJan Kara * called by the different filesystems on allocation of an inode or block. 7884d179dSJan Kara * These routines take care of the administration needed to have a consistent 8884d179dSJan Kara * diskquota tracking system. The ideas of both user and group quotas are based 9884d179dSJan Kara * on the Melbourne quota system as used on BSD derived systems. The internal 10884d179dSJan Kara * implementation is based on one of the several variants of the LINUX 11884d179dSJan Kara * inode-subsystem with added complexity of the diskquota system. 12884d179dSJan Kara * 13884d179dSJan Kara * Author: Marco van Wieringen <mvw@planets.elm.net> 14884d179dSJan Kara * 15884d179dSJan Kara * Fixes: Dmitry Gorodchanin <pgmdsg@ibi.com>, 11 Feb 96 16884d179dSJan Kara * 17884d179dSJan Kara * Revised list management to avoid races 18884d179dSJan Kara * -- Bill Hawes, <whawes@star.net>, 9/98 19884d179dSJan Kara * 20884d179dSJan Kara * Fixed races in dquot_transfer(), dqget() and dquot_alloc_...(). 21884d179dSJan Kara * As the consequence the locking was moved from dquot_decr_...(), 22884d179dSJan Kara * dquot_incr_...() to calling functions. 23884d179dSJan Kara * invalidate_dquots() now writes modified dquots. 24884d179dSJan Kara * Serialized quota_off() and quota_on() for mount point. 25884d179dSJan Kara * Fixed a few bugs in grow_dquots(). 26884d179dSJan Kara * Fixed deadlock in write_dquot() - we no longer account quotas on 27884d179dSJan Kara * quota files 28884d179dSJan Kara * remove_dquot_ref() moved to inode.c - it now traverses through inodes 29884d179dSJan Kara * add_dquot_ref() restarts after blocking 30884d179dSJan Kara * Added check for bogus uid and fixed check for group in quotactl. 31884d179dSJan Kara * Jan Kara, <jack@suse.cz>, sponsored by SuSE CR, 10-11/99 32884d179dSJan Kara * 33884d179dSJan Kara * Used struct list_head instead of own list struct 34884d179dSJan Kara * Invalidation of referenced dquots is no longer possible 35884d179dSJan Kara * Improved free_dquots list management 36884d179dSJan Kara * Quota and i_blocks are now updated in one place to avoid races 37884d179dSJan Kara * Warnings are now delayed so we won't block in critical section 38884d179dSJan Kara * Write updated not to require dquot lock 39884d179dSJan Kara * Jan Kara, <jack@suse.cz>, 9/2000 40884d179dSJan Kara * 41884d179dSJan Kara * Added dynamic quota structure allocation 42884d179dSJan Kara * Jan Kara <jack@suse.cz> 12/2000 43884d179dSJan Kara * 44884d179dSJan Kara * Rewritten quota interface. Implemented new quota format and 45884d179dSJan Kara * formats registering. 46884d179dSJan Kara * Jan Kara, <jack@suse.cz>, 2001,2002 47884d179dSJan Kara * 48884d179dSJan Kara * New SMP locking. 49884d179dSJan Kara * Jan Kara, <jack@suse.cz>, 10/2002 50884d179dSJan Kara * 51884d179dSJan Kara * Added journalled quota support, fix lock inversion problems 52884d179dSJan Kara * Jan Kara, <jack@suse.cz>, 2003,2004 53884d179dSJan Kara * 54884d179dSJan Kara * (C) Copyright 1994 - 1997 Marco van Wieringen 55884d179dSJan Kara */ 56884d179dSJan Kara 57884d179dSJan Kara #include <linux/errno.h> 58884d179dSJan Kara #include <linux/kernel.h> 59884d179dSJan Kara #include <linux/fs.h> 60884d179dSJan Kara #include <linux/mount.h> 61884d179dSJan Kara #include <linux/mm.h> 62884d179dSJan Kara #include <linux/time.h> 63884d179dSJan Kara #include <linux/types.h> 64884d179dSJan Kara #include <linux/string.h> 65884d179dSJan Kara #include <linux/fcntl.h> 66884d179dSJan Kara #include <linux/stat.h> 67884d179dSJan Kara #include <linux/tty.h> 68884d179dSJan Kara #include <linux/file.h> 69884d179dSJan Kara #include <linux/slab.h> 70884d179dSJan Kara #include <linux/sysctl.h> 71884d179dSJan Kara #include <linux/init.h> 72884d179dSJan Kara #include <linux/module.h> 73884d179dSJan Kara #include <linux/proc_fs.h> 74884d179dSJan Kara #include <linux/security.h> 7540401530SAl Viro #include <linux/sched.h> 765b825c3aSIngo Molnar #include <linux/cred.h> 77884d179dSJan Kara #include <linux/kmod.h> 78884d179dSJan Kara #include <linux/namei.h> 79884d179dSJan Kara #include <linux/capability.h> 80884d179dSJan Kara #include <linux/quotaops.h> 813f1266f1SChristoph Hellwig #include <linux/blkdev.h> 82537e11cdSMatthew Wilcox (Oracle) #include <linux/sched/mm.h> 8355fa6091SDave Chinner #include "../internal.h" /* ugh */ 84884d179dSJan Kara 85f3da9310SJeff Liu #include <linux/uaccess.h> 86884d179dSJan Kara 87884d179dSJan Kara /* 887b9ca4c6SJan Kara * There are five quota SMP locks: 897b9ca4c6SJan Kara * * dq_list_lock protects all lists with quotas and quota formats. 907b9ca4c6SJan Kara * * dquot->dq_dqb_lock protects data from dq_dqb 917b9ca4c6SJan Kara * * inode->i_lock protects inode->i_blocks, i_bytes and also guards 927b9ca4c6SJan Kara * consistency of dquot->dq_dqb with inode->i_blocks, i_bytes so that 937b9ca4c6SJan Kara * dquot_transfer() can stabilize amount it transfers 947b9ca4c6SJan Kara * * dq_data_lock protects mem_dqinfo structures and modifications of dquot 957b9ca4c6SJan Kara * pointers in the inode 967b9ca4c6SJan Kara * * dq_state_lock protects modifications of quota state (on quotaon and 977b9ca4c6SJan Kara * quotaoff) and readers who care about latest values take it as well. 98884d179dSJan Kara * 997b9ca4c6SJan Kara * The spinlock ordering is hence: 1007b9ca4c6SJan Kara * dq_data_lock > dq_list_lock > i_lock > dquot->dq_dqb_lock, 101884d179dSJan Kara * dq_list_lock > dq_state_lock 102884d179dSJan Kara * 103884d179dSJan Kara * Note that some things (eg. sb pointer, type, id) doesn't change during 104884d179dSJan Kara * the life of the dquot structure and so needn't to be protected by a lock 105884d179dSJan Kara * 106b9ba6f94SNiu Yawei * Operation accessing dquots via inode pointers are protected by dquot_srcu. 107b9ba6f94SNiu Yawei * Operation of reading pointer needs srcu_read_lock(&dquot_srcu), and 108b9ba6f94SNiu Yawei * synchronize_srcu(&dquot_srcu) is called after clearing pointers from 109b9ba6f94SNiu Yawei * inode and before dropping dquot references to avoid use of dquots after 110b9ba6f94SNiu Yawei * they are freed. dq_data_lock is used to serialize the pointer setting and 111b9ba6f94SNiu Yawei * clearing operations. 11226245c94SJan Kara * Special care needs to be taken about S_NOQUOTA inode flag (marking that 11326245c94SJan Kara * inode is a quota file). Functions adding pointers from inode to dquots have 114b9ba6f94SNiu Yawei * to check this flag under dq_data_lock and then (if S_NOQUOTA is not set) they 115b9ba6f94SNiu Yawei * have to do all pointer modifications before dropping dq_data_lock. This makes 11626245c94SJan Kara * sure they cannot race with quotaon which first sets S_NOQUOTA flag and 11726245c94SJan Kara * then drops all pointers to dquots from an inode. 118884d179dSJan Kara * 1195e8cb9b6SJan Kara * Each dquot has its dq_lock mutex. Dquot is locked when it is being read to 1205e8cb9b6SJan Kara * memory (or space for it is being allocated) on the first dqget(), when it is 1215e8cb9b6SJan Kara * being written out, and when it is being released on the last dqput(). The 1225e8cb9b6SJan Kara * allocation and release operations are serialized by the dq_lock and by 1235e8cb9b6SJan Kara * checking the use count in dquot_release(). 124884d179dSJan Kara * 125884d179dSJan Kara * Lock ordering (including related VFS locks) is the following: 126bc8230eeSJan Kara * s_umount > i_mutex > journal_lock > dquot->dq_lock > dqio_sem 127884d179dSJan Kara */ 128884d179dSJan Kara 129c516610cSJan Kara static __cacheline_aligned_in_smp DEFINE_SPINLOCK(dq_list_lock); 130c516610cSJan Kara static __cacheline_aligned_in_smp DEFINE_SPINLOCK(dq_state_lock); 131c516610cSJan Kara __cacheline_aligned_in_smp DEFINE_SPINLOCK(dq_data_lock); 132884d179dSJan Kara EXPORT_SYMBOL(dq_data_lock); 133b9ba6f94SNiu Yawei DEFINE_STATIC_SRCU(dquot_srcu); 134884d179dSJan Kara 135503330f3SJan Kara static DECLARE_WAIT_QUEUE_HEAD(dquot_ref_wq); 136503330f3SJan Kara 137fb5ffb0eSJiaying Zhang void __quota_error(struct super_block *sb, const char *func, 138fb5ffb0eSJiaying Zhang const char *fmt, ...) 139fb5ffb0eSJiaying Zhang { 140fb5ffb0eSJiaying Zhang if (printk_ratelimit()) { 141055adcbdSJoe Perches va_list args; 142055adcbdSJoe Perches struct va_format vaf; 143055adcbdSJoe Perches 144fb5ffb0eSJiaying Zhang va_start(args, fmt); 145055adcbdSJoe Perches 146055adcbdSJoe Perches vaf.fmt = fmt; 147055adcbdSJoe Perches vaf.va = &args; 148055adcbdSJoe Perches 149055adcbdSJoe Perches printk(KERN_ERR "Quota error (device %s): %s: %pV\n", 150055adcbdSJoe Perches sb->s_id, func, &vaf); 151055adcbdSJoe Perches 152fb5ffb0eSJiaying Zhang va_end(args); 153fb5ffb0eSJiaying Zhang } 154fb5ffb0eSJiaying Zhang } 155fb5ffb0eSJiaying Zhang EXPORT_SYMBOL(__quota_error); 156fb5ffb0eSJiaying Zhang 157da8d1ba2SSergey Senozhatsky #if defined(CONFIG_QUOTA_DEBUG) || defined(CONFIG_PRINT_QUOTA_WARNING) 158884d179dSJan Kara static char *quotatypes[] = INITQFNAMES; 159da8d1ba2SSergey Senozhatsky #endif 160884d179dSJan Kara static struct quota_format_type *quota_formats; /* List of registered formats */ 161884d179dSJan Kara static struct quota_module_name module_names[] = INIT_QUOTA_MODULE_NAMES; 162884d179dSJan Kara 163884d179dSJan Kara /* SLAB cache for dquot structures */ 164884d179dSJan Kara static struct kmem_cache *dquot_cachep; 165884d179dSJan Kara 166884d179dSJan Kara int register_quota_format(struct quota_format_type *fmt) 167884d179dSJan Kara { 168884d179dSJan Kara spin_lock(&dq_list_lock); 169884d179dSJan Kara fmt->qf_next = quota_formats; 170884d179dSJan Kara quota_formats = fmt; 171884d179dSJan Kara spin_unlock(&dq_list_lock); 172884d179dSJan Kara return 0; 173884d179dSJan Kara } 174884d179dSJan Kara EXPORT_SYMBOL(register_quota_format); 175884d179dSJan Kara 176884d179dSJan Kara void unregister_quota_format(struct quota_format_type *fmt) 177884d179dSJan Kara { 178884d179dSJan Kara struct quota_format_type **actqf; 179884d179dSJan Kara 180884d179dSJan Kara spin_lock(&dq_list_lock); 181268157baSJan Kara for (actqf = "a_formats; *actqf && *actqf != fmt; 182268157baSJan Kara actqf = &(*actqf)->qf_next) 183268157baSJan Kara ; 184884d179dSJan Kara if (*actqf) 185884d179dSJan Kara *actqf = (*actqf)->qf_next; 186884d179dSJan Kara spin_unlock(&dq_list_lock); 187884d179dSJan Kara } 188884d179dSJan Kara EXPORT_SYMBOL(unregister_quota_format); 189884d179dSJan Kara 190884d179dSJan Kara static struct quota_format_type *find_quota_format(int id) 191884d179dSJan Kara { 192884d179dSJan Kara struct quota_format_type *actqf; 193884d179dSJan Kara 194884d179dSJan Kara spin_lock(&dq_list_lock); 195268157baSJan Kara for (actqf = quota_formats; actqf && actqf->qf_fmt_id != id; 196268157baSJan Kara actqf = actqf->qf_next) 197268157baSJan Kara ; 198884d179dSJan Kara if (!actqf || !try_module_get(actqf->qf_owner)) { 199884d179dSJan Kara int qm; 200884d179dSJan Kara 201884d179dSJan Kara spin_unlock(&dq_list_lock); 202884d179dSJan Kara 203268157baSJan Kara for (qm = 0; module_names[qm].qm_fmt_id && 204268157baSJan Kara module_names[qm].qm_fmt_id != id; qm++) 205268157baSJan Kara ; 206268157baSJan Kara if (!module_names[qm].qm_fmt_id || 207268157baSJan Kara request_module(module_names[qm].qm_mod_name)) 208884d179dSJan Kara return NULL; 209884d179dSJan Kara 210884d179dSJan Kara spin_lock(&dq_list_lock); 211268157baSJan Kara for (actqf = quota_formats; actqf && actqf->qf_fmt_id != id; 212268157baSJan Kara actqf = actqf->qf_next) 213268157baSJan Kara ; 214884d179dSJan Kara if (actqf && !try_module_get(actqf->qf_owner)) 215884d179dSJan Kara actqf = NULL; 216884d179dSJan Kara } 217884d179dSJan Kara spin_unlock(&dq_list_lock); 218884d179dSJan Kara return actqf; 219884d179dSJan Kara } 220884d179dSJan Kara 221884d179dSJan Kara static void put_quota_format(struct quota_format_type *fmt) 222884d179dSJan Kara { 223884d179dSJan Kara module_put(fmt->qf_owner); 224884d179dSJan Kara } 225884d179dSJan Kara 226884d179dSJan Kara /* 227884d179dSJan Kara * Dquot List Management: 228dabc8b20SBaokun Li * The quota code uses five lists for dquot management: the inuse_list, 229dabc8b20SBaokun Li * releasing_dquots, free_dquots, dqi_dirty_list, and dquot_hash[] array. 230dabc8b20SBaokun Li * A single dquot structure may be on some of those lists, depending on 231dabc8b20SBaokun Li * its current state. 232884d179dSJan Kara * 233884d179dSJan Kara * All dquots are placed to the end of inuse_list when first created, and this 234884d179dSJan Kara * list is used for invalidate operation, which must look at every dquot. 235884d179dSJan Kara * 236869b6ea1SJan Kara * When the last reference of a dquot is dropped, the dquot is added to 237869b6ea1SJan Kara * releasing_dquots. We'll then queue work item which will call 238dabc8b20SBaokun Li * synchronize_srcu() and after that perform the final cleanup of all the 239869b6ea1SJan Kara * dquots on the list. Each cleaned up dquot is moved to free_dquots list. 240869b6ea1SJan Kara * Both releasing_dquots and free_dquots use the dq_free list_head in the dquot 241869b6ea1SJan Kara * struct. 242dabc8b20SBaokun Li * 243869b6ea1SJan Kara * Unused and cleaned up dquots are in the free_dquots list and this list is 244869b6ea1SJan Kara * searched whenever we need an available dquot. Dquots are removed from the 245869b6ea1SJan Kara * list as soon as they are used again and dqstats.free_dquots gives the number 246869b6ea1SJan Kara * of dquots on the list. When dquot is invalidated it's completely released 247869b6ea1SJan Kara * from memory. 248884d179dSJan Kara * 249f44840adSChengguang Xu * Dirty dquots are added to the dqi_dirty_list of quota_info when mark 250f44840adSChengguang Xu * dirtied, and this list is searched when writing dirty dquots back to 251f44840adSChengguang Xu * quota file. Note that some filesystems do dirty dquot tracking on their 252f44840adSChengguang Xu * own (e.g. in a journal) and thus don't use dqi_dirty_list. 253f44840adSChengguang Xu * 254884d179dSJan Kara * Dquots with a specific identity (device, type and id) are placed on 255884d179dSJan Kara * one of the dquot_hash[] hash chains. The provides an efficient search 256884d179dSJan Kara * mechanism to locate a specific dquot. 257884d179dSJan Kara */ 258884d179dSJan Kara 259884d179dSJan Kara static LIST_HEAD(inuse_list); 260884d179dSJan Kara static LIST_HEAD(free_dquots); 261dabc8b20SBaokun Li static LIST_HEAD(releasing_dquots); 262884d179dSJan Kara static unsigned int dq_hash_bits, dq_hash_mask; 263884d179dSJan Kara static struct hlist_head *dquot_hash; 264884d179dSJan Kara 265884d179dSJan Kara struct dqstats dqstats; 266884d179dSJan Kara EXPORT_SYMBOL(dqstats); 267884d179dSJan Kara 2680a5a9c72SJan Kara static qsize_t inode_get_rsv_space(struct inode *inode); 2697b9ca4c6SJan Kara static qsize_t __inode_get_rsv_space(struct inode *inode); 2706184fc0bSJan Kara static int __dquot_initialize(struct inode *inode, int type); 2710a5a9c72SJan Kara 272dabc8b20SBaokun Li static void quota_release_workfn(struct work_struct *work); 273dabc8b20SBaokun Li static DECLARE_DELAYED_WORK(quota_release_work, quota_release_workfn); 274dabc8b20SBaokun Li 275884d179dSJan Kara static inline unsigned int 2761a06d420SEric W. Biederman hashfn(const struct super_block *sb, struct kqid qid) 277884d179dSJan Kara { 2781a06d420SEric W. Biederman unsigned int id = from_kqid(&init_user_ns, qid); 2791a06d420SEric W. Biederman int type = qid.type; 280884d179dSJan Kara unsigned long tmp; 281884d179dSJan Kara 282884d179dSJan Kara tmp = (((unsigned long)sb>>L1_CACHE_SHIFT) ^ id) * (MAXQUOTAS - type); 283884d179dSJan Kara return (tmp + (tmp >> dq_hash_bits)) & dq_hash_mask; 284884d179dSJan Kara } 285884d179dSJan Kara 286884d179dSJan Kara /* 287884d179dSJan Kara * Following list functions expect dq_list_lock to be held 288884d179dSJan Kara */ 289884d179dSJan Kara static inline void insert_dquot_hash(struct dquot *dquot) 290884d179dSJan Kara { 291268157baSJan Kara struct hlist_head *head; 2921a06d420SEric W. Biederman head = dquot_hash + hashfn(dquot->dq_sb, dquot->dq_id); 293884d179dSJan Kara hlist_add_head(&dquot->dq_hash, head); 294884d179dSJan Kara } 295884d179dSJan Kara 296884d179dSJan Kara static inline void remove_dquot_hash(struct dquot *dquot) 297884d179dSJan Kara { 298884d179dSJan Kara hlist_del_init(&dquot->dq_hash); 299884d179dSJan Kara } 300884d179dSJan Kara 3017a2435d8SJan Kara static struct dquot *find_dquot(unsigned int hashent, struct super_block *sb, 3021a06d420SEric W. Biederman struct kqid qid) 303884d179dSJan Kara { 304884d179dSJan Kara struct dquot *dquot; 305884d179dSJan Kara 3068c721cb0SChristophe JAILLET hlist_for_each_entry(dquot, dquot_hash+hashent, dq_hash) 3074c376dcaSEric W. Biederman if (dquot->dq_sb == sb && qid_eq(dquot->dq_id, qid)) 308884d179dSJan Kara return dquot; 3098c721cb0SChristophe JAILLET 310dd6f3c6dSJan Kara return NULL; 311884d179dSJan Kara } 312884d179dSJan Kara 313884d179dSJan Kara /* Add a dquot to the tail of the free list */ 314884d179dSJan Kara static inline void put_dquot_last(struct dquot *dquot) 315884d179dSJan Kara { 316884d179dSJan Kara list_add_tail(&dquot->dq_free, &free_dquots); 317dde95888SDmitry Monakhov dqstats_inc(DQST_FREE_DQUOTS); 318884d179dSJan Kara } 319884d179dSJan Kara 320dabc8b20SBaokun Li static inline void put_releasing_dquots(struct dquot *dquot) 321dabc8b20SBaokun Li { 322dabc8b20SBaokun Li list_add_tail(&dquot->dq_free, &releasing_dquots); 323869b6ea1SJan Kara set_bit(DQ_RELEASING_B, &dquot->dq_flags); 324dabc8b20SBaokun Li } 325dabc8b20SBaokun Li 326884d179dSJan Kara static inline void remove_free_dquot(struct dquot *dquot) 327884d179dSJan Kara { 328884d179dSJan Kara if (list_empty(&dquot->dq_free)) 329884d179dSJan Kara return; 330884d179dSJan Kara list_del_init(&dquot->dq_free); 331869b6ea1SJan Kara if (!test_bit(DQ_RELEASING_B, &dquot->dq_flags)) 332dde95888SDmitry Monakhov dqstats_dec(DQST_FREE_DQUOTS); 333869b6ea1SJan Kara else 334869b6ea1SJan Kara clear_bit(DQ_RELEASING_B, &dquot->dq_flags); 335884d179dSJan Kara } 336884d179dSJan Kara 337884d179dSJan Kara static inline void put_inuse(struct dquot *dquot) 338884d179dSJan Kara { 339884d179dSJan Kara /* We add to the back of inuse list so we don't have to restart 340884d179dSJan Kara * when traversing this list and we block */ 341884d179dSJan Kara list_add_tail(&dquot->dq_inuse, &inuse_list); 342dde95888SDmitry Monakhov dqstats_inc(DQST_ALLOC_DQUOTS); 343884d179dSJan Kara } 344884d179dSJan Kara 345884d179dSJan Kara static inline void remove_inuse(struct dquot *dquot) 346884d179dSJan Kara { 347dde95888SDmitry Monakhov dqstats_dec(DQST_ALLOC_DQUOTS); 348884d179dSJan Kara list_del(&dquot->dq_inuse); 349884d179dSJan Kara } 350884d179dSJan Kara /* 351884d179dSJan Kara * End of list functions needing dq_list_lock 352884d179dSJan Kara */ 353884d179dSJan Kara 354884d179dSJan Kara static void wait_on_dquot(struct dquot *dquot) 355884d179dSJan Kara { 356884d179dSJan Kara mutex_lock(&dquot->dq_lock); 357884d179dSJan Kara mutex_unlock(&dquot->dq_lock); 358884d179dSJan Kara } 359884d179dSJan Kara 36033bcfafcSBaokun Li static inline int dquot_active(struct dquot *dquot) 36133bcfafcSBaokun Li { 36233bcfafcSBaokun Li return test_bit(DQ_ACTIVE_B, &dquot->dq_flags); 36333bcfafcSBaokun Li } 36433bcfafcSBaokun Li 365884d179dSJan Kara static inline int dquot_dirty(struct dquot *dquot) 366884d179dSJan Kara { 367884d179dSJan Kara return test_bit(DQ_MOD_B, &dquot->dq_flags); 368884d179dSJan Kara } 369884d179dSJan Kara 370884d179dSJan Kara static inline int mark_dquot_dirty(struct dquot *dquot) 371884d179dSJan Kara { 372884d179dSJan Kara return dquot->dq_sb->dq_op->mark_dirty(dquot); 373884d179dSJan Kara } 374884d179dSJan Kara 375eabf290dSDmitry Monakhov /* Mark dquot dirty in atomic manner, and return it's old dirty flag state */ 376884d179dSJan Kara int dquot_mark_dquot_dirty(struct dquot *dquot) 377884d179dSJan Kara { 378eabf290dSDmitry Monakhov int ret = 1; 379eabf290dSDmitry Monakhov 38033bcfafcSBaokun Li if (!dquot_active(dquot)) 3814580b30eSJan Kara return 0; 3824580b30eSJan Kara 383834057bfSJan Kara if (sb_dqopt(dquot->dq_sb)->flags & DQUOT_NOLIST_DIRTY) 384834057bfSJan Kara return test_and_set_bit(DQ_MOD_B, &dquot->dq_flags); 385834057bfSJan Kara 386eabf290dSDmitry Monakhov /* If quota is dirty already, we don't have to acquire dq_list_lock */ 38733bcfafcSBaokun Li if (dquot_dirty(dquot)) 388eabf290dSDmitry Monakhov return 1; 389eabf290dSDmitry Monakhov 390884d179dSJan Kara spin_lock(&dq_list_lock); 391eabf290dSDmitry Monakhov if (!test_and_set_bit(DQ_MOD_B, &dquot->dq_flags)) { 392884d179dSJan Kara list_add(&dquot->dq_dirty, &sb_dqopt(dquot->dq_sb)-> 3934c376dcaSEric W. Biederman info[dquot->dq_id.type].dqi_dirty_list); 394eabf290dSDmitry Monakhov ret = 0; 395eabf290dSDmitry Monakhov } 396884d179dSJan Kara spin_unlock(&dq_list_lock); 397eabf290dSDmitry Monakhov return ret; 398884d179dSJan Kara } 399884d179dSJan Kara EXPORT_SYMBOL(dquot_mark_dquot_dirty); 400884d179dSJan Kara 401dc52dd3aSDmitry Monakhov /* Dirtify all the dquots - this can block when journalling */ 402*40a673b4SWang Jianjian static inline int mark_all_dquot_dirty(struct dquot * const *dquots) 403dc52dd3aSDmitry Monakhov { 404dc52dd3aSDmitry Monakhov int ret, err, cnt; 405*40a673b4SWang Jianjian struct dquot *dquot; 406dc52dd3aSDmitry Monakhov 407dc52dd3aSDmitry Monakhov ret = err = 0; 408dc52dd3aSDmitry Monakhov for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 409*40a673b4SWang Jianjian dquot = srcu_dereference(dquots[cnt], &dquot_srcu); 410*40a673b4SWang Jianjian if (dquot) 411dc52dd3aSDmitry Monakhov /* Even in case of error we have to continue */ 412*40a673b4SWang Jianjian ret = mark_dquot_dirty(dquot); 413dc52dd3aSDmitry Monakhov if (!err) 414dc52dd3aSDmitry Monakhov err = ret; 415dc52dd3aSDmitry Monakhov } 416dc52dd3aSDmitry Monakhov return err; 417dc52dd3aSDmitry Monakhov } 418dc52dd3aSDmitry Monakhov 419dc52dd3aSDmitry Monakhov static inline void dqput_all(struct dquot **dquot) 420dc52dd3aSDmitry Monakhov { 421dc52dd3aSDmitry Monakhov unsigned int cnt; 422dc52dd3aSDmitry Monakhov 423dc52dd3aSDmitry Monakhov for (cnt = 0; cnt < MAXQUOTAS; cnt++) 424dc52dd3aSDmitry Monakhov dqput(dquot[cnt]); 425dc52dd3aSDmitry Monakhov } 426dc52dd3aSDmitry Monakhov 427884d179dSJan Kara static inline int clear_dquot_dirty(struct dquot *dquot) 428884d179dSJan Kara { 429834057bfSJan Kara if (sb_dqopt(dquot->dq_sb)->flags & DQUOT_NOLIST_DIRTY) 430834057bfSJan Kara return test_and_clear_bit(DQ_MOD_B, &dquot->dq_flags); 431834057bfSJan Kara 4321e0b7cb0SJan Kara spin_lock(&dq_list_lock); 4331e0b7cb0SJan Kara if (!test_and_clear_bit(DQ_MOD_B, &dquot->dq_flags)) { 4341e0b7cb0SJan Kara spin_unlock(&dq_list_lock); 435884d179dSJan Kara return 0; 4361e0b7cb0SJan Kara } 437884d179dSJan Kara list_del_init(&dquot->dq_dirty); 4381e0b7cb0SJan Kara spin_unlock(&dq_list_lock); 439884d179dSJan Kara return 1; 440884d179dSJan Kara } 441884d179dSJan Kara 442884d179dSJan Kara void mark_info_dirty(struct super_block *sb, int type) 443884d179dSJan Kara { 44415512377SJan Kara spin_lock(&dq_data_lock); 44515512377SJan Kara sb_dqopt(sb)->info[type].dqi_flags |= DQF_INFO_DIRTY; 44615512377SJan Kara spin_unlock(&dq_data_lock); 447884d179dSJan Kara } 448884d179dSJan Kara EXPORT_SYMBOL(mark_info_dirty); 449884d179dSJan Kara 450884d179dSJan Kara /* 451884d179dSJan Kara * Read dquot from disk and alloc space for it 452884d179dSJan Kara */ 453884d179dSJan Kara 454884d179dSJan Kara int dquot_acquire(struct dquot *dquot) 455884d179dSJan Kara { 456884d179dSJan Kara int ret = 0, ret2 = 0; 457537e11cdSMatthew Wilcox (Oracle) unsigned int memalloc; 458884d179dSJan Kara struct quota_info *dqopt = sb_dqopt(dquot->dq_sb); 459884d179dSJan Kara 460884d179dSJan Kara mutex_lock(&dquot->dq_lock); 461537e11cdSMatthew Wilcox (Oracle) memalloc = memalloc_nofs_save(); 4623ef177ecSChengguang Xu if (!test_bit(DQ_READ_B, &dquot->dq_flags)) { 4634c376dcaSEric W. Biederman ret = dqopt->ops[dquot->dq_id.type]->read_dqblk(dquot); 464884d179dSJan Kara if (ret < 0) 465884d179dSJan Kara goto out_iolock; 4663ef177ecSChengguang Xu } 467044c9b67SJan Kara /* Make sure flags update is visible after dquot has been filled */ 468044c9b67SJan Kara smp_mb__before_atomic(); 469884d179dSJan Kara set_bit(DQ_READ_B, &dquot->dq_flags); 470884d179dSJan Kara /* Instantiate dquot if needed */ 47133bcfafcSBaokun Li if (!dquot_active(dquot) && !dquot->dq_off) { 4724c376dcaSEric W. Biederman ret = dqopt->ops[dquot->dq_id.type]->commit_dqblk(dquot); 473884d179dSJan Kara /* Write the info if needed */ 4744c376dcaSEric W. Biederman if (info_dirty(&dqopt->info[dquot->dq_id.type])) { 4754c376dcaSEric W. Biederman ret2 = dqopt->ops[dquot->dq_id.type]->write_file_info( 4764c376dcaSEric W. Biederman dquot->dq_sb, dquot->dq_id.type); 477268157baSJan Kara } 478884d179dSJan Kara if (ret < 0) 479884d179dSJan Kara goto out_iolock; 480884d179dSJan Kara if (ret2 < 0) { 481884d179dSJan Kara ret = ret2; 482884d179dSJan Kara goto out_iolock; 483884d179dSJan Kara } 484884d179dSJan Kara } 485044c9b67SJan Kara /* 486044c9b67SJan Kara * Make sure flags update is visible after on-disk struct has been 487044c9b67SJan Kara * allocated. Paired with smp_rmb() in dqget(). 488044c9b67SJan Kara */ 489044c9b67SJan Kara smp_mb__before_atomic(); 490884d179dSJan Kara set_bit(DQ_ACTIVE_B, &dquot->dq_flags); 491884d179dSJan Kara out_iolock: 492537e11cdSMatthew Wilcox (Oracle) memalloc_nofs_restore(memalloc); 493884d179dSJan Kara mutex_unlock(&dquot->dq_lock); 494884d179dSJan Kara return ret; 495884d179dSJan Kara } 496884d179dSJan Kara EXPORT_SYMBOL(dquot_acquire); 497884d179dSJan Kara 498884d179dSJan Kara /* 499884d179dSJan Kara * Write dquot to disk 500884d179dSJan Kara */ 501884d179dSJan Kara int dquot_commit(struct dquot *dquot) 502884d179dSJan Kara { 503b03f2456SJan Kara int ret = 0; 504537e11cdSMatthew Wilcox (Oracle) unsigned int memalloc; 505884d179dSJan Kara struct quota_info *dqopt = sb_dqopt(dquot->dq_sb); 506884d179dSJan Kara 5075e8cb9b6SJan Kara mutex_lock(&dquot->dq_lock); 508537e11cdSMatthew Wilcox (Oracle) memalloc = memalloc_nofs_save(); 5091e0b7cb0SJan Kara if (!clear_dquot_dirty(dquot)) 5105e8cb9b6SJan Kara goto out_lock; 511884d179dSJan Kara /* Inactive dquot can be only if there was error during read/init 512884d179dSJan Kara * => we have better not writing it */ 51333bcfafcSBaokun Li if (dquot_active(dquot)) 5144c376dcaSEric W. Biederman ret = dqopt->ops[dquot->dq_id.type]->commit_dqblk(dquot); 515b03f2456SJan Kara else 516b03f2456SJan Kara ret = -EIO; 5175e8cb9b6SJan Kara out_lock: 518537e11cdSMatthew Wilcox (Oracle) memalloc_nofs_restore(memalloc); 5195e8cb9b6SJan Kara mutex_unlock(&dquot->dq_lock); 520884d179dSJan Kara return ret; 521884d179dSJan Kara } 522884d179dSJan Kara EXPORT_SYMBOL(dquot_commit); 523884d179dSJan Kara 524884d179dSJan Kara /* 525884d179dSJan Kara * Release dquot 526884d179dSJan Kara */ 527884d179dSJan Kara int dquot_release(struct dquot *dquot) 528884d179dSJan Kara { 529884d179dSJan Kara int ret = 0, ret2 = 0; 530537e11cdSMatthew Wilcox (Oracle) unsigned int memalloc; 531884d179dSJan Kara struct quota_info *dqopt = sb_dqopt(dquot->dq_sb); 532884d179dSJan Kara 533884d179dSJan Kara mutex_lock(&dquot->dq_lock); 534537e11cdSMatthew Wilcox (Oracle) memalloc = memalloc_nofs_save(); 535884d179dSJan Kara /* Check whether we are not racing with some other dqget() */ 536df4bb5d1SDmitry Monakhov if (dquot_is_busy(dquot)) 537884d179dSJan Kara goto out_dqlock; 5384c376dcaSEric W. Biederman if (dqopt->ops[dquot->dq_id.type]->release_dqblk) { 5394c376dcaSEric W. Biederman ret = dqopt->ops[dquot->dq_id.type]->release_dqblk(dquot); 540884d179dSJan Kara /* Write the info */ 5414c376dcaSEric W. Biederman if (info_dirty(&dqopt->info[dquot->dq_id.type])) { 5424c376dcaSEric W. Biederman ret2 = dqopt->ops[dquot->dq_id.type]->write_file_info( 5434c376dcaSEric W. Biederman dquot->dq_sb, dquot->dq_id.type); 544268157baSJan Kara } 545884d179dSJan Kara if (ret >= 0) 546884d179dSJan Kara ret = ret2; 547884d179dSJan Kara } 548884d179dSJan Kara clear_bit(DQ_ACTIVE_B, &dquot->dq_flags); 549884d179dSJan Kara out_dqlock: 550537e11cdSMatthew Wilcox (Oracle) memalloc_nofs_restore(memalloc); 551884d179dSJan Kara mutex_unlock(&dquot->dq_lock); 552884d179dSJan Kara return ret; 553884d179dSJan Kara } 554884d179dSJan Kara EXPORT_SYMBOL(dquot_release); 555884d179dSJan Kara 556884d179dSJan Kara void dquot_destroy(struct dquot *dquot) 557884d179dSJan Kara { 558884d179dSJan Kara kmem_cache_free(dquot_cachep, dquot); 559884d179dSJan Kara } 560884d179dSJan Kara EXPORT_SYMBOL(dquot_destroy); 561884d179dSJan Kara 562884d179dSJan Kara static inline void do_destroy_dquot(struct dquot *dquot) 563884d179dSJan Kara { 564884d179dSJan Kara dquot->dq_sb->dq_op->destroy_dquot(dquot); 565884d179dSJan Kara } 566884d179dSJan Kara 567884d179dSJan Kara /* Invalidate all dquots on the list. Note that this function is called after 568884d179dSJan Kara * quota is disabled and pointers from inodes removed so there cannot be new 569884d179dSJan Kara * quota users. There can still be some users of quotas due to inodes being 570884d179dSJan Kara * just deleted or pruned by prune_icache() (those are not attached to any 571884d179dSJan Kara * list) or parallel quotactl call. We have to wait for such users. 572884d179dSJan Kara */ 573884d179dSJan Kara static void invalidate_dquots(struct super_block *sb, int type) 574884d179dSJan Kara { 575884d179dSJan Kara struct dquot *dquot, *tmp; 576884d179dSJan Kara 577884d179dSJan Kara restart: 578dabc8b20SBaokun Li flush_delayed_work("a_release_work); 579dabc8b20SBaokun Li 580884d179dSJan Kara spin_lock(&dq_list_lock); 581884d179dSJan Kara list_for_each_entry_safe(dquot, tmp, &inuse_list, dq_inuse) { 582884d179dSJan Kara if (dquot->dq_sb != sb) 583884d179dSJan Kara continue; 5844c376dcaSEric W. Biederman if (dquot->dq_id.type != type) 585884d179dSJan Kara continue; 586884d179dSJan Kara /* Wait for dquot users */ 587884d179dSJan Kara if (atomic_read(&dquot->dq_count)) { 588d6a95db3SYe Bin atomic_inc(&dquot->dq_count); 589884d179dSJan Kara spin_unlock(&dq_list_lock); 590503330f3SJan Kara /* 591503330f3SJan Kara * Once dqput() wakes us up, we know it's time to free 592884d179dSJan Kara * the dquot. 593884d179dSJan Kara * IMPORTANT: we rely on the fact that there is always 594884d179dSJan Kara * at most one process waiting for dquot to free. 595884d179dSJan Kara * Otherwise dq_count would be > 1 and we would never 596884d179dSJan Kara * wake up. 597884d179dSJan Kara */ 598503330f3SJan Kara wait_event(dquot_ref_wq, 599503330f3SJan Kara atomic_read(&dquot->dq_count) == 1); 600884d179dSJan Kara dqput(dquot); 601884d179dSJan Kara /* At this moment dquot() need not exist (it could be 602884d179dSJan Kara * reclaimed by prune_dqcache(). Hence we must 603884d179dSJan Kara * restart. */ 604884d179dSJan Kara goto restart; 605884d179dSJan Kara } 606884d179dSJan Kara /* 607869b6ea1SJan Kara * The last user already dropped its reference but dquot didn't 608869b6ea1SJan Kara * get fully cleaned up yet. Restart the scan which flushes the 609869b6ea1SJan Kara * work cleaning up released dquots. 610869b6ea1SJan Kara */ 611869b6ea1SJan Kara if (test_bit(DQ_RELEASING_B, &dquot->dq_flags)) { 612869b6ea1SJan Kara spin_unlock(&dq_list_lock); 613869b6ea1SJan Kara goto restart; 614869b6ea1SJan Kara } 615869b6ea1SJan Kara /* 616884d179dSJan Kara * Quota now has no users and it has been written on last 617884d179dSJan Kara * dqput() 618884d179dSJan Kara */ 619884d179dSJan Kara remove_dquot_hash(dquot); 620884d179dSJan Kara remove_free_dquot(dquot); 621884d179dSJan Kara remove_inuse(dquot); 622884d179dSJan Kara do_destroy_dquot(dquot); 623884d179dSJan Kara } 624884d179dSJan Kara spin_unlock(&dq_list_lock); 625884d179dSJan Kara } 626884d179dSJan Kara 627884d179dSJan Kara /* Call callback for every active dquot on given filesystem */ 628884d179dSJan Kara int dquot_scan_active(struct super_block *sb, 629884d179dSJan Kara int (*fn)(struct dquot *dquot, unsigned long priv), 630884d179dSJan Kara unsigned long priv) 631884d179dSJan Kara { 632884d179dSJan Kara struct dquot *dquot, *old_dquot = NULL; 633884d179dSJan Kara int ret = 0; 634884d179dSJan Kara 635ee1ac541SJan Kara WARN_ON_ONCE(!rwsem_is_locked(&sb->s_umount)); 636ee1ac541SJan Kara 637884d179dSJan Kara spin_lock(&dq_list_lock); 638884d179dSJan Kara list_for_each_entry(dquot, &inuse_list, dq_inuse) { 63933bcfafcSBaokun Li if (!dquot_active(dquot)) 640884d179dSJan Kara continue; 641884d179dSJan Kara if (dquot->dq_sb != sb) 642884d179dSJan Kara continue; 643884d179dSJan Kara /* Now we have active dquot so we can just increase use count */ 644884d179dSJan Kara atomic_inc(&dquot->dq_count); 645884d179dSJan Kara spin_unlock(&dq_list_lock); 646884d179dSJan Kara dqput(old_dquot); 647884d179dSJan Kara old_dquot = dquot; 6481362f4eaSJan Kara /* 6491362f4eaSJan Kara * ->release_dquot() can be racing with us. Our reference 6501362f4eaSJan Kara * protects us from new calls to it so just wait for any 6511362f4eaSJan Kara * outstanding call and recheck the DQ_ACTIVE_B after that. 6521362f4eaSJan Kara */ 6531362f4eaSJan Kara wait_on_dquot(dquot); 65433bcfafcSBaokun Li if (dquot_active(dquot)) { 655884d179dSJan Kara ret = fn(dquot, priv); 656884d179dSJan Kara if (ret < 0) 657884d179dSJan Kara goto out; 6581362f4eaSJan Kara } 659884d179dSJan Kara spin_lock(&dq_list_lock); 660884d179dSJan Kara /* We are safe to continue now because our dquot could not 661884d179dSJan Kara * be moved out of the inuse list while we hold the reference */ 662884d179dSJan Kara } 663884d179dSJan Kara spin_unlock(&dq_list_lock); 664884d179dSJan Kara out: 665884d179dSJan Kara dqput(old_dquot); 666884d179dSJan Kara return ret; 667884d179dSJan Kara } 668884d179dSJan Kara EXPORT_SYMBOL(dquot_scan_active); 669884d179dSJan Kara 67002412847SBaokun Li static inline int dquot_write_dquot(struct dquot *dquot) 67102412847SBaokun Li { 67202412847SBaokun Li int ret = dquot->dq_sb->dq_op->write_dquot(dquot); 67302412847SBaokun Li if (ret < 0) { 67402412847SBaokun Li quota_error(dquot->dq_sb, "Can't write quota structure " 67502412847SBaokun Li "(error %d). Quota may get out of sync!", ret); 67602412847SBaokun Li /* Clear dirty bit anyway to avoid infinite loop. */ 67702412847SBaokun Li clear_dquot_dirty(dquot); 67802412847SBaokun Li } 67902412847SBaokun Li return ret; 68002412847SBaokun Li } 68102412847SBaokun Li 682ceed1723SJan Kara /* Write all dquot structures to quota files */ 683ceed1723SJan Kara int dquot_writeback_dquots(struct super_block *sb, int type) 684884d179dSJan Kara { 6856ff33d99SDmitry Monakhov struct list_head dirty; 686884d179dSJan Kara struct dquot *dquot; 687884d179dSJan Kara struct quota_info *dqopt = sb_dqopt(sb); 688884d179dSJan Kara int cnt; 689ceed1723SJan Kara int err, ret = 0; 690884d179dSJan Kara 6919d1ccbe7SJan Kara WARN_ON_ONCE(!rwsem_is_locked(&sb->s_umount)); 6929d1ccbe7SJan Kara 693884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 694884d179dSJan Kara if (type != -1 && cnt != type) 695884d179dSJan Kara continue; 696884d179dSJan Kara if (!sb_has_quota_active(sb, cnt)) 697884d179dSJan Kara continue; 698884d179dSJan Kara spin_lock(&dq_list_lock); 6996ff33d99SDmitry Monakhov /* Move list away to avoid livelock. */ 7006ff33d99SDmitry Monakhov list_replace_init(&dqopt->info[cnt].dqi_dirty_list, &dirty); 7016ff33d99SDmitry Monakhov while (!list_empty(&dirty)) { 7026ff33d99SDmitry Monakhov dquot = list_first_entry(&dirty, struct dquot, 703268157baSJan Kara dq_dirty); 7044580b30eSJan Kara 70533bcfafcSBaokun Li WARN_ON(!dquot_active(dquot)); 706869b6ea1SJan Kara /* If the dquot is releasing we should not touch it */ 707869b6ea1SJan Kara if (test_bit(DQ_RELEASING_B, &dquot->dq_flags)) { 708869b6ea1SJan Kara spin_unlock(&dq_list_lock); 709869b6ea1SJan Kara flush_delayed_work("a_release_work); 710869b6ea1SJan Kara spin_lock(&dq_list_lock); 711869b6ea1SJan Kara continue; 712869b6ea1SJan Kara } 7134580b30eSJan Kara 714884d179dSJan Kara /* Now we have active dquot from which someone is 715884d179dSJan Kara * holding reference so we can safely just increase 716884d179dSJan Kara * use count */ 7179f985cb6SJan Kara dqgrab(dquot); 718884d179dSJan Kara spin_unlock(&dq_list_lock); 71902412847SBaokun Li err = dquot_write_dquot(dquot); 72002412847SBaokun Li if (err && !ret) 721474d2605SJan Kara ret = err; 722884d179dSJan Kara dqput(dquot); 723884d179dSJan Kara spin_lock(&dq_list_lock); 724884d179dSJan Kara } 725884d179dSJan Kara spin_unlock(&dq_list_lock); 726884d179dSJan Kara } 727884d179dSJan Kara 728884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) 729884d179dSJan Kara if ((cnt == type || type == -1) && sb_has_quota_active(sb, cnt) 730884d179dSJan Kara && info_dirty(&dqopt->info[cnt])) 731884d179dSJan Kara sb->dq_op->write_info(sb, cnt); 732dde95888SDmitry Monakhov dqstats_inc(DQST_SYNCS); 733884d179dSJan Kara 734ceed1723SJan Kara return ret; 735ceed1723SJan Kara } 736ceed1723SJan Kara EXPORT_SYMBOL(dquot_writeback_dquots); 737ceed1723SJan Kara 738ceed1723SJan Kara /* Write all dquot structures to disk and make them visible from userspace */ 739ceed1723SJan Kara int dquot_quota_sync(struct super_block *sb, int type) 740ceed1723SJan Kara { 741ceed1723SJan Kara struct quota_info *dqopt = sb_dqopt(sb); 742ceed1723SJan Kara int cnt; 743ceed1723SJan Kara int ret; 744ceed1723SJan Kara 745ceed1723SJan Kara ret = dquot_writeback_dquots(sb, type); 746ceed1723SJan Kara if (ret) 747ceed1723SJan Kara return ret; 748ceed1723SJan Kara if (dqopt->flags & DQUOT_QUOTA_SYS_FILE) 7495fb324adSChristoph Hellwig return 0; 7505fb324adSChristoph Hellwig 7515fb324adSChristoph Hellwig /* This is not very clever (and fast) but currently I don't know about 7525fb324adSChristoph Hellwig * any other simple way of getting quota data to disk and we must get 7535fb324adSChristoph Hellwig * them there for userspace to be visible... */ 754dd5532a4SDarrick J. Wong if (sb->s_op->sync_fs) { 755dd5532a4SDarrick J. Wong ret = sb->s_op->sync_fs(sb, 1); 756dd5532a4SDarrick J. Wong if (ret) 757dd5532a4SDarrick J. Wong return ret; 758dd5532a4SDarrick J. Wong } 759dd5532a4SDarrick J. Wong ret = sync_blockdev(sb->s_bdev); 760dd5532a4SDarrick J. Wong if (ret) 761dd5532a4SDarrick J. Wong return ret; 7625fb324adSChristoph Hellwig 7635fb324adSChristoph Hellwig /* 7645fb324adSChristoph Hellwig * Now when everything is written we can discard the pagecache so 7655fb324adSChristoph Hellwig * that userspace sees the changes. 7665fb324adSChristoph Hellwig */ 7675fb324adSChristoph Hellwig for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 7685fb324adSChristoph Hellwig if (type != -1 && cnt != type) 7695fb324adSChristoph Hellwig continue; 7705fb324adSChristoph Hellwig if (!sb_has_quota_active(sb, cnt)) 7715fb324adSChristoph Hellwig continue; 7725955102cSAl Viro inode_lock(dqopt->files[cnt]); 773f9ef1784SJan Kara truncate_inode_pages(&dqopt->files[cnt]->i_data, 0); 7745955102cSAl Viro inode_unlock(dqopt->files[cnt]); 7755fb324adSChristoph Hellwig } 7765fb324adSChristoph Hellwig 777884d179dSJan Kara return 0; 778884d179dSJan Kara } 779287a8095SChristoph Hellwig EXPORT_SYMBOL(dquot_quota_sync); 780884d179dSJan Kara 7811ab6c499SDave Chinner static unsigned long 7821ab6c499SDave Chinner dqcache_shrink_scan(struct shrinker *shrink, struct shrink_control *sc) 783884d179dSJan Kara { 784884d179dSJan Kara struct dquot *dquot; 7851ab6c499SDave Chinner unsigned long freed = 0; 786884d179dSJan Kara 787d68aab6bSNiu Yawei spin_lock(&dq_list_lock); 7881822193bSJan Kara while (!list_empty(&free_dquots) && sc->nr_to_scan) { 7891822193bSJan Kara dquot = list_first_entry(&free_dquots, struct dquot, dq_free); 790884d179dSJan Kara remove_dquot_hash(dquot); 791884d179dSJan Kara remove_free_dquot(dquot); 792884d179dSJan Kara remove_inuse(dquot); 793884d179dSJan Kara do_destroy_dquot(dquot); 7941ab6c499SDave Chinner sc->nr_to_scan--; 7951ab6c499SDave Chinner freed++; 796884d179dSJan Kara } 797d68aab6bSNiu Yawei spin_unlock(&dq_list_lock); 7981ab6c499SDave Chinner return freed; 799884d179dSJan Kara } 800884d179dSJan Kara 8011ab6c499SDave Chinner static unsigned long 8021ab6c499SDave Chinner dqcache_shrink_count(struct shrinker *shrink, struct shrink_control *sc) 803884d179dSJan Kara { 80455f841ceSGlauber Costa return vfs_pressure_ratio( 80555f841ceSGlauber Costa percpu_counter_read_positive(&dqstats.counter[DQST_FREE_DQUOTS])); 806884d179dSJan Kara } 807884d179dSJan Kara 808884d179dSJan Kara static struct shrinker dqcache_shrinker = { 8091ab6c499SDave Chinner .count_objects = dqcache_shrink_count, 8101ab6c499SDave Chinner .scan_objects = dqcache_shrink_scan, 811884d179dSJan Kara .seeks = DEFAULT_SEEKS, 812884d179dSJan Kara }; 813884d179dSJan Kara 814884d179dSJan Kara /* 815dabc8b20SBaokun Li * Safely release dquot and put reference to dquot. 816dabc8b20SBaokun Li */ 817dabc8b20SBaokun Li static void quota_release_workfn(struct work_struct *work) 818dabc8b20SBaokun Li { 819dabc8b20SBaokun Li struct dquot *dquot; 820dabc8b20SBaokun Li struct list_head rls_head; 821dabc8b20SBaokun Li 822dabc8b20SBaokun Li spin_lock(&dq_list_lock); 823dabc8b20SBaokun Li /* Exchange the list head to avoid livelock. */ 824dabc8b20SBaokun Li list_replace_init(&releasing_dquots, &rls_head); 825dabc8b20SBaokun Li spin_unlock(&dq_list_lock); 826869b6ea1SJan Kara synchronize_srcu(&dquot_srcu); 827dabc8b20SBaokun Li 828dabc8b20SBaokun Li restart: 829dabc8b20SBaokun Li spin_lock(&dq_list_lock); 830dabc8b20SBaokun Li while (!list_empty(&rls_head)) { 831dabc8b20SBaokun Li dquot = list_first_entry(&rls_head, struct dquot, dq_free); 832869b6ea1SJan Kara WARN_ON_ONCE(atomic_read(&dquot->dq_count)); 833869b6ea1SJan Kara /* 834869b6ea1SJan Kara * Note that DQ_RELEASING_B protects us from racing with 835869b6ea1SJan Kara * invalidate_dquots() calls so we are safe to work with the 836869b6ea1SJan Kara * dquot even after we drop dq_list_lock. 837869b6ea1SJan Kara */ 838dabc8b20SBaokun Li if (dquot_dirty(dquot)) { 839dabc8b20SBaokun Li spin_unlock(&dq_list_lock); 840dabc8b20SBaokun Li /* Commit dquot before releasing */ 841dabc8b20SBaokun Li dquot_write_dquot(dquot); 842dabc8b20SBaokun Li goto restart; 843dabc8b20SBaokun Li } 844dabc8b20SBaokun Li if (dquot_active(dquot)) { 845dabc8b20SBaokun Li spin_unlock(&dq_list_lock); 846dabc8b20SBaokun Li dquot->dq_sb->dq_op->release_dquot(dquot); 847dabc8b20SBaokun Li goto restart; 848dabc8b20SBaokun Li } 849dabc8b20SBaokun Li /* Dquot is inactive and clean, now move it to free list */ 850dabc8b20SBaokun Li remove_free_dquot(dquot); 851dabc8b20SBaokun Li put_dquot_last(dquot); 852dabc8b20SBaokun Li } 853dabc8b20SBaokun Li spin_unlock(&dq_list_lock); 854dabc8b20SBaokun Li } 855dabc8b20SBaokun Li 856dabc8b20SBaokun Li /* 857884d179dSJan Kara * Put reference to dquot 858884d179dSJan Kara */ 859884d179dSJan Kara void dqput(struct dquot *dquot) 860884d179dSJan Kara { 861884d179dSJan Kara if (!dquot) 862884d179dSJan Kara return; 86362af9b52SJan Kara #ifdef CONFIG_QUOTA_DEBUG 864884d179dSJan Kara if (!atomic_read(&dquot->dq_count)) { 865fb5ffb0eSJiaying Zhang quota_error(dquot->dq_sb, "trying to free free dquot of %s %d", 8664c376dcaSEric W. Biederman quotatypes[dquot->dq_id.type], 8674c376dcaSEric W. Biederman from_kqid(&init_user_ns, dquot->dq_id)); 868884d179dSJan Kara BUG(); 869884d179dSJan Kara } 870884d179dSJan Kara #endif 871dde95888SDmitry Monakhov dqstats_inc(DQST_DROPS); 872dabc8b20SBaokun Li 873884d179dSJan Kara spin_lock(&dq_list_lock); 874884d179dSJan Kara if (atomic_read(&dquot->dq_count) > 1) { 875884d179dSJan Kara /* We have more than one user... nothing to do */ 876884d179dSJan Kara atomic_dec(&dquot->dq_count); 877884d179dSJan Kara /* Releasing dquot during quotaoff phase? */ 8784c376dcaSEric W. Biederman if (!sb_has_quota_active(dquot->dq_sb, dquot->dq_id.type) && 879884d179dSJan Kara atomic_read(&dquot->dq_count) == 1) 880503330f3SJan Kara wake_up(&dquot_ref_wq); 881884d179dSJan Kara spin_unlock(&dq_list_lock); 882884d179dSJan Kara return; 883884d179dSJan Kara } 884dabc8b20SBaokun Li 885884d179dSJan Kara /* Need to release dquot? */ 88662af9b52SJan Kara #ifdef CONFIG_QUOTA_DEBUG 887884d179dSJan Kara /* sanity check */ 888884d179dSJan Kara BUG_ON(!list_empty(&dquot->dq_free)); 889884d179dSJan Kara #endif 890dabc8b20SBaokun Li put_releasing_dquots(dquot); 891869b6ea1SJan Kara atomic_dec(&dquot->dq_count); 892884d179dSJan Kara spin_unlock(&dq_list_lock); 893dabc8b20SBaokun Li queue_delayed_work(system_unbound_wq, "a_release_work, 1); 894884d179dSJan Kara } 895884d179dSJan Kara EXPORT_SYMBOL(dqput); 896884d179dSJan Kara 897884d179dSJan Kara struct dquot *dquot_alloc(struct super_block *sb, int type) 898884d179dSJan Kara { 899884d179dSJan Kara return kmem_cache_zalloc(dquot_cachep, GFP_NOFS); 900884d179dSJan Kara } 901884d179dSJan Kara EXPORT_SYMBOL(dquot_alloc); 902884d179dSJan Kara 903884d179dSJan Kara static struct dquot *get_empty_dquot(struct super_block *sb, int type) 904884d179dSJan Kara { 905884d179dSJan Kara struct dquot *dquot; 906884d179dSJan Kara 907884d179dSJan Kara dquot = sb->dq_op->alloc_dquot(sb, type); 908884d179dSJan Kara if(!dquot) 909dd6f3c6dSJan Kara return NULL; 910884d179dSJan Kara 911884d179dSJan Kara mutex_init(&dquot->dq_lock); 912884d179dSJan Kara INIT_LIST_HEAD(&dquot->dq_free); 913884d179dSJan Kara INIT_LIST_HEAD(&dquot->dq_inuse); 914884d179dSJan Kara INIT_HLIST_NODE(&dquot->dq_hash); 915884d179dSJan Kara INIT_LIST_HEAD(&dquot->dq_dirty); 916884d179dSJan Kara dquot->dq_sb = sb; 9171a06d420SEric W. Biederman dquot->dq_id = make_kqid_invalid(type); 918884d179dSJan Kara atomic_set(&dquot->dq_count, 1); 9197b9ca4c6SJan Kara spin_lock_init(&dquot->dq_dqb_lock); 920884d179dSJan Kara 921884d179dSJan Kara return dquot; 922884d179dSJan Kara } 923884d179dSJan Kara 924884d179dSJan Kara /* 925884d179dSJan Kara * Get reference to dquot 926884d179dSJan Kara * 927884d179dSJan Kara * Locking is slightly tricky here. We are guarded from parallel quotaoff() 928884d179dSJan Kara * destroying our dquot by: 929884d179dSJan Kara * a) checking for quota flags under dq_list_lock and 930884d179dSJan Kara * b) getting a reference to dquot before we release dq_list_lock 931884d179dSJan Kara */ 932aca645a6SEric W. Biederman struct dquot *dqget(struct super_block *sb, struct kqid qid) 933884d179dSJan Kara { 9341a06d420SEric W. Biederman unsigned int hashent = hashfn(sb, qid); 9356184fc0bSJan Kara struct dquot *dquot, *empty = NULL; 936884d179dSJan Kara 937d49d3762SEric W. Biederman if (!qid_has_mapping(sb->s_user_ns, qid)) 938d49d3762SEric W. Biederman return ERR_PTR(-EINVAL); 939d49d3762SEric W. Biederman 9401a06d420SEric W. Biederman if (!sb_has_quota_active(sb, qid.type)) 9416184fc0bSJan Kara return ERR_PTR(-ESRCH); 942884d179dSJan Kara we_slept: 943884d179dSJan Kara spin_lock(&dq_list_lock); 944884d179dSJan Kara spin_lock(&dq_state_lock); 9451a06d420SEric W. Biederman if (!sb_has_quota_active(sb, qid.type)) { 946884d179dSJan Kara spin_unlock(&dq_state_lock); 947884d179dSJan Kara spin_unlock(&dq_list_lock); 9486184fc0bSJan Kara dquot = ERR_PTR(-ESRCH); 949884d179dSJan Kara goto out; 950884d179dSJan Kara } 951884d179dSJan Kara spin_unlock(&dq_state_lock); 952884d179dSJan Kara 9531a06d420SEric W. Biederman dquot = find_dquot(hashent, sb, qid); 954dd6f3c6dSJan Kara if (!dquot) { 955dd6f3c6dSJan Kara if (!empty) { 956884d179dSJan Kara spin_unlock(&dq_list_lock); 9571a06d420SEric W. Biederman empty = get_empty_dquot(sb, qid.type); 958dd6f3c6dSJan Kara if (!empty) 959884d179dSJan Kara schedule(); /* Try to wait for a moment... */ 960884d179dSJan Kara goto we_slept; 961884d179dSJan Kara } 962884d179dSJan Kara dquot = empty; 963dd6f3c6dSJan Kara empty = NULL; 9644c376dcaSEric W. Biederman dquot->dq_id = qid; 965884d179dSJan Kara /* all dquots go on the inuse_list */ 966884d179dSJan Kara put_inuse(dquot); 967884d179dSJan Kara /* hash it first so it can be found */ 968884d179dSJan Kara insert_dquot_hash(dquot); 969884d179dSJan Kara spin_unlock(&dq_list_lock); 970dde95888SDmitry Monakhov dqstats_inc(DQST_LOOKUPS); 971884d179dSJan Kara } else { 972884d179dSJan Kara if (!atomic_read(&dquot->dq_count)) 973884d179dSJan Kara remove_free_dquot(dquot); 974884d179dSJan Kara atomic_inc(&dquot->dq_count); 975884d179dSJan Kara spin_unlock(&dq_list_lock); 976dde95888SDmitry Monakhov dqstats_inc(DQST_CACHE_HITS); 977dde95888SDmitry Monakhov dqstats_inc(DQST_LOOKUPS); 978884d179dSJan Kara } 979268157baSJan Kara /* Wait for dq_lock - after this we know that either dquot_release() is 980869b6ea1SJan Kara * already finished or it will be canceled due to dq_count > 0 test */ 981884d179dSJan Kara wait_on_dquot(dquot); 982268157baSJan Kara /* Read the dquot / allocate space in quota file */ 98333bcfafcSBaokun Li if (!dquot_active(dquot)) { 9846184fc0bSJan Kara int err; 9856184fc0bSJan Kara 9866184fc0bSJan Kara err = sb->dq_op->acquire_dquot(dquot); 9876184fc0bSJan Kara if (err < 0) { 988884d179dSJan Kara dqput(dquot); 9896184fc0bSJan Kara dquot = ERR_PTR(err); 990884d179dSJan Kara goto out; 991884d179dSJan Kara } 9926184fc0bSJan Kara } 993044c9b67SJan Kara /* 994044c9b67SJan Kara * Make sure following reads see filled structure - paired with 995044c9b67SJan Kara * smp_mb__before_atomic() in dquot_acquire(). 996044c9b67SJan Kara */ 997044c9b67SJan Kara smp_rmb(); 99862af9b52SJan Kara #ifdef CONFIG_QUOTA_DEBUG 999884d179dSJan Kara BUG_ON(!dquot->dq_sb); /* Has somebody invalidated entry under us? */ 1000884d179dSJan Kara #endif 1001884d179dSJan Kara out: 1002884d179dSJan Kara if (empty) 1003884d179dSJan Kara do_destroy_dquot(empty); 1004884d179dSJan Kara 1005884d179dSJan Kara return dquot; 1006884d179dSJan Kara } 1007884d179dSJan Kara EXPORT_SYMBOL(dqget); 1008884d179dSJan Kara 10092d0fa467SJan Kara static inline struct dquot **i_dquot(struct inode *inode) 10102d0fa467SJan Kara { 10112d0fa467SJan Kara return inode->i_sb->s_op->get_dquots(inode); 10122d0fa467SJan Kara } 10132d0fa467SJan Kara 1014884d179dSJan Kara static int dqinit_needed(struct inode *inode, int type) 1015884d179dSJan Kara { 10165bcd3b6fSKonstantin Khlebnikov struct dquot * const *dquots; 1017884d179dSJan Kara int cnt; 1018884d179dSJan Kara 1019884d179dSJan Kara if (IS_NOQUOTA(inode)) 1020884d179dSJan Kara return 0; 10215bcd3b6fSKonstantin Khlebnikov 10225bcd3b6fSKonstantin Khlebnikov dquots = i_dquot(inode); 1023884d179dSJan Kara if (type != -1) 10245bcd3b6fSKonstantin Khlebnikov return !dquots[type]; 1025884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) 10265bcd3b6fSKonstantin Khlebnikov if (!dquots[cnt]) 1027884d179dSJan Kara return 1; 1028884d179dSJan Kara return 0; 1029884d179dSJan Kara } 1030884d179dSJan Kara 1031c3b00446SJan Kara /* This routine is guarded by s_umount semaphore */ 10321a6152d3SChao Yu static int add_dquot_ref(struct super_block *sb, int type) 1033884d179dSJan Kara { 1034884d179dSJan Kara struct inode *inode, *old_inode = NULL; 103562af9b52SJan Kara #ifdef CONFIG_QUOTA_DEBUG 10360a5a9c72SJan Kara int reserved = 0; 10374c5e6c0eSJan Kara #endif 10381a6152d3SChao Yu int err = 0; 1039884d179dSJan Kara 104074278da9SDave Chinner spin_lock(&sb->s_inode_list_lock); 1041884d179dSJan Kara list_for_each_entry(inode, &sb->s_inodes, i_sb_list) { 1042250df6edSDave Chinner spin_lock(&inode->i_lock); 1043250df6edSDave Chinner if ((inode->i_state & (I_FREEING|I_WILL_FREE|I_NEW)) || 1044250df6edSDave Chinner !atomic_read(&inode->i_writecount) || 1045250df6edSDave Chinner !dqinit_needed(inode, type)) { 1046250df6edSDave Chinner spin_unlock(&inode->i_lock); 10473ae5080fSLinus Torvalds continue; 1048250df6edSDave Chinner } 1049884d179dSJan Kara __iget(inode); 1050250df6edSDave Chinner spin_unlock(&inode->i_lock); 105174278da9SDave Chinner spin_unlock(&sb->s_inode_list_lock); 1052884d179dSJan Kara 1053d7e97117SJan Kara #ifdef CONFIG_QUOTA_DEBUG 1054d7e97117SJan Kara if (unlikely(inode_get_rsv_space(inode) > 0)) 1055d7e97117SJan Kara reserved = 1; 1056d7e97117SJan Kara #endif 1057884d179dSJan Kara iput(old_inode); 10581a6152d3SChao Yu err = __dquot_initialize(inode, type); 10591a6152d3SChao Yu if (err) { 10601a6152d3SChao Yu iput(inode); 10611a6152d3SChao Yu goto out; 10621a6152d3SChao Yu } 106355fa6091SDave Chinner 106455fa6091SDave Chinner /* 106555fa6091SDave Chinner * We hold a reference to 'inode' so it couldn't have been 106655fa6091SDave Chinner * removed from s_inodes list while we dropped the 106774278da9SDave Chinner * s_inode_list_lock. We cannot iput the inode now as we can be 106855fa6091SDave Chinner * holding the last reference and we cannot iput it under 106974278da9SDave Chinner * s_inode_list_lock. So we keep the reference and iput it 107055fa6091SDave Chinner * later. 107155fa6091SDave Chinner */ 1072884d179dSJan Kara old_inode = inode; 107304646aebSEric Sandeen cond_resched(); 107474278da9SDave Chinner spin_lock(&sb->s_inode_list_lock); 1075884d179dSJan Kara } 107674278da9SDave Chinner spin_unlock(&sb->s_inode_list_lock); 1077884d179dSJan Kara iput(old_inode); 10781a6152d3SChao Yu out: 107962af9b52SJan Kara #ifdef CONFIG_QUOTA_DEBUG 10800a5a9c72SJan Kara if (reserved) { 1081fb5ffb0eSJiaying Zhang quota_error(sb, "Writes happened before quota was turned on " 1082fb5ffb0eSJiaying Zhang "thus quota information is probably inconsistent. " 1083fb5ffb0eSJiaying Zhang "Please run quotacheck(8)"); 10840a5a9c72SJan Kara } 10854c5e6c0eSJan Kara #endif 10861a6152d3SChao Yu return err; 1087884d179dSJan Kara } 1088884d179dSJan Kara 10897bce48f0SBaokun Li static void remove_dquot_ref(struct super_block *sb, int type) 1090884d179dSJan Kara { 1091884d179dSJan Kara struct inode *inode; 109278bc3334SJiang Biao #ifdef CONFIG_QUOTA_DEBUG 10937af9cce8SDmitry Monakhov int reserved = 0; 109478bc3334SJiang Biao #endif 1095884d179dSJan Kara 109674278da9SDave Chinner spin_lock(&sb->s_inode_list_lock); 1097884d179dSJan Kara list_for_each_entry(inode, &sb->s_inodes, i_sb_list) { 10983ae5080fSLinus Torvalds /* 10993ae5080fSLinus Torvalds * We have to scan also I_NEW inodes because they can already 11003ae5080fSLinus Torvalds * have quota pointer initialized. Luckily, we need to touch 11013ae5080fSLinus Torvalds * only quota pointers and these have separate locking 1102b9ba6f94SNiu Yawei * (dq_data_lock). 11033ae5080fSLinus Torvalds */ 1104b9ba6f94SNiu Yawei spin_lock(&dq_data_lock); 11057af9cce8SDmitry Monakhov if (!IS_NOQUOTA(inode)) { 11067bce48f0SBaokun Li struct dquot **dquots = i_dquot(inode); 11077bce48f0SBaokun Li struct dquot *dquot = dquots[type]; 11087bce48f0SBaokun Li 110978bc3334SJiang Biao #ifdef CONFIG_QUOTA_DEBUG 11107af9cce8SDmitry Monakhov if (unlikely(inode_get_rsv_space(inode) > 0)) 11117af9cce8SDmitry Monakhov reserved = 1; 111278bc3334SJiang Biao #endif 11137bce48f0SBaokun Li dquots[type] = NULL; 11147bce48f0SBaokun Li if (dquot) 11157bce48f0SBaokun Li dqput(dquot); 1116884d179dSJan Kara } 1117b9ba6f94SNiu Yawei spin_unlock(&dq_data_lock); 11187af9cce8SDmitry Monakhov } 111974278da9SDave Chinner spin_unlock(&sb->s_inode_list_lock); 11207af9cce8SDmitry Monakhov #ifdef CONFIG_QUOTA_DEBUG 11217af9cce8SDmitry Monakhov if (reserved) { 11227af9cce8SDmitry Monakhov printk(KERN_WARNING "VFS (%s): Writes happened after quota" 11237af9cce8SDmitry Monakhov " was disabled thus quota information is probably " 11247af9cce8SDmitry Monakhov "inconsistent. Please run quotacheck(8).\n", sb->s_id); 11257af9cce8SDmitry Monakhov } 11267af9cce8SDmitry Monakhov #endif 1127884d179dSJan Kara } 1128884d179dSJan Kara 1129884d179dSJan Kara /* Gather all references from inodes and drop them */ 1130884d179dSJan Kara static void drop_dquot_ref(struct super_block *sb, int type) 1131884d179dSJan Kara { 11327bce48f0SBaokun Li if (sb->dq_op) 11337bce48f0SBaokun Li remove_dquot_ref(sb, type); 1134884d179dSJan Kara } 1135884d179dSJan Kara 1136884d179dSJan Kara static inline 1137884d179dSJan Kara void dquot_free_reserved_space(struct dquot *dquot, qsize_t number) 1138884d179dSJan Kara { 11390a5a9c72SJan Kara if (dquot->dq_dqb.dqb_rsvspace >= number) 1140884d179dSJan Kara dquot->dq_dqb.dqb_rsvspace -= number; 11410a5a9c72SJan Kara else { 11420a5a9c72SJan Kara WARN_ON_ONCE(1); 11430a5a9c72SJan Kara dquot->dq_dqb.dqb_rsvspace = 0; 11440a5a9c72SJan Kara } 114541e327b5Szhangyi (F) if (dquot->dq_dqb.dqb_curspace + dquot->dq_dqb.dqb_rsvspace <= 114641e327b5Szhangyi (F) dquot->dq_dqb.dqb_bsoftlimit) 114741e327b5Szhangyi (F) dquot->dq_dqb.dqb_btime = (time64_t) 0; 114841e327b5Szhangyi (F) clear_bit(DQ_BLKS_B, &dquot->dq_flags); 1149884d179dSJan Kara } 1150884d179dSJan Kara 11517a2435d8SJan Kara static void dquot_decr_inodes(struct dquot *dquot, qsize_t number) 1152884d179dSJan Kara { 1153884d179dSJan Kara if (sb_dqopt(dquot->dq_sb)->flags & DQUOT_NEGATIVE_USAGE || 1154884d179dSJan Kara dquot->dq_dqb.dqb_curinodes >= number) 1155884d179dSJan Kara dquot->dq_dqb.dqb_curinodes -= number; 1156884d179dSJan Kara else 1157884d179dSJan Kara dquot->dq_dqb.dqb_curinodes = 0; 1158884d179dSJan Kara if (dquot->dq_dqb.dqb_curinodes <= dquot->dq_dqb.dqb_isoftlimit) 1159e008bb61SArnd Bergmann dquot->dq_dqb.dqb_itime = (time64_t) 0; 1160884d179dSJan Kara clear_bit(DQ_INODES_B, &dquot->dq_flags); 1161884d179dSJan Kara } 1162884d179dSJan Kara 11637a2435d8SJan Kara static void dquot_decr_space(struct dquot *dquot, qsize_t number) 1164884d179dSJan Kara { 1165884d179dSJan Kara if (sb_dqopt(dquot->dq_sb)->flags & DQUOT_NEGATIVE_USAGE || 1166884d179dSJan Kara dquot->dq_dqb.dqb_curspace >= number) 1167884d179dSJan Kara dquot->dq_dqb.dqb_curspace -= number; 1168884d179dSJan Kara else 1169884d179dSJan Kara dquot->dq_dqb.dqb_curspace = 0; 117041e327b5Szhangyi (F) if (dquot->dq_dqb.dqb_curspace + dquot->dq_dqb.dqb_rsvspace <= 117141e327b5Szhangyi (F) dquot->dq_dqb.dqb_bsoftlimit) 1172e008bb61SArnd Bergmann dquot->dq_dqb.dqb_btime = (time64_t) 0; 1173884d179dSJan Kara clear_bit(DQ_BLKS_B, &dquot->dq_flags); 1174884d179dSJan Kara } 1175884d179dSJan Kara 1176bf097aafSJan Kara struct dquot_warn { 1177bf097aafSJan Kara struct super_block *w_sb; 11787b9c7321SEric W. Biederman struct kqid w_dq_id; 1179bf097aafSJan Kara short w_type; 1180bf097aafSJan Kara }; 1181bf097aafSJan Kara 1182884d179dSJan Kara static int warning_issued(struct dquot *dquot, const int warntype) 1183884d179dSJan Kara { 1184884d179dSJan Kara int flag = (warntype == QUOTA_NL_BHARDWARN || 1185884d179dSJan Kara warntype == QUOTA_NL_BSOFTLONGWARN) ? DQ_BLKS_B : 1186884d179dSJan Kara ((warntype == QUOTA_NL_IHARDWARN || 1187884d179dSJan Kara warntype == QUOTA_NL_ISOFTLONGWARN) ? DQ_INODES_B : 0); 1188884d179dSJan Kara 1189884d179dSJan Kara if (!flag) 1190884d179dSJan Kara return 0; 1191884d179dSJan Kara return test_and_set_bit(flag, &dquot->dq_flags); 1192884d179dSJan Kara } 1193884d179dSJan Kara 1194884d179dSJan Kara #ifdef CONFIG_PRINT_QUOTA_WARNING 1195884d179dSJan Kara static int flag_print_warnings = 1; 1196884d179dSJan Kara 1197bf097aafSJan Kara static int need_print_warning(struct dquot_warn *warn) 1198884d179dSJan Kara { 1199884d179dSJan Kara if (!flag_print_warnings) 1200884d179dSJan Kara return 0; 1201884d179dSJan Kara 12027b9c7321SEric W. Biederman switch (warn->w_dq_id.type) { 1203884d179dSJan Kara case USRQUOTA: 12041a06d420SEric W. Biederman return uid_eq(current_fsuid(), warn->w_dq_id.uid); 1205884d179dSJan Kara case GRPQUOTA: 12067b9c7321SEric W. Biederman return in_group_p(warn->w_dq_id.gid); 1207847aac64SLi Xi case PRJQUOTA: 1208847aac64SLi Xi return 1; 1209884d179dSJan Kara } 1210884d179dSJan Kara return 0; 1211884d179dSJan Kara } 1212884d179dSJan Kara 1213884d179dSJan Kara /* Print warning to user which exceeded quota */ 1214bf097aafSJan Kara static void print_warning(struct dquot_warn *warn) 1215884d179dSJan Kara { 1216884d179dSJan Kara char *msg = NULL; 1217884d179dSJan Kara struct tty_struct *tty; 1218bf097aafSJan Kara int warntype = warn->w_type; 1219884d179dSJan Kara 1220884d179dSJan Kara if (warntype == QUOTA_NL_IHARDBELOW || 1221884d179dSJan Kara warntype == QUOTA_NL_ISOFTBELOW || 1222884d179dSJan Kara warntype == QUOTA_NL_BHARDBELOW || 1223bf097aafSJan Kara warntype == QUOTA_NL_BSOFTBELOW || !need_print_warning(warn)) 1224884d179dSJan Kara return; 1225884d179dSJan Kara 1226884d179dSJan Kara tty = get_current_tty(); 1227884d179dSJan Kara if (!tty) 1228884d179dSJan Kara return; 1229bf097aafSJan Kara tty_write_message(tty, warn->w_sb->s_id); 1230884d179dSJan Kara if (warntype == QUOTA_NL_ISOFTWARN || warntype == QUOTA_NL_BSOFTWARN) 1231884d179dSJan Kara tty_write_message(tty, ": warning, "); 1232884d179dSJan Kara else 1233884d179dSJan Kara tty_write_message(tty, ": write failed, "); 12347b9c7321SEric W. Biederman tty_write_message(tty, quotatypes[warn->w_dq_id.type]); 1235884d179dSJan Kara switch (warntype) { 1236884d179dSJan Kara case QUOTA_NL_IHARDWARN: 1237884d179dSJan Kara msg = " file limit reached.\r\n"; 1238884d179dSJan Kara break; 1239884d179dSJan Kara case QUOTA_NL_ISOFTLONGWARN: 1240884d179dSJan Kara msg = " file quota exceeded too long.\r\n"; 1241884d179dSJan Kara break; 1242884d179dSJan Kara case QUOTA_NL_ISOFTWARN: 1243884d179dSJan Kara msg = " file quota exceeded.\r\n"; 1244884d179dSJan Kara break; 1245884d179dSJan Kara case QUOTA_NL_BHARDWARN: 1246884d179dSJan Kara msg = " block limit reached.\r\n"; 1247884d179dSJan Kara break; 1248884d179dSJan Kara case QUOTA_NL_BSOFTLONGWARN: 1249884d179dSJan Kara msg = " block quota exceeded too long.\r\n"; 1250884d179dSJan Kara break; 1251884d179dSJan Kara case QUOTA_NL_BSOFTWARN: 1252884d179dSJan Kara msg = " block quota exceeded.\r\n"; 1253884d179dSJan Kara break; 1254884d179dSJan Kara } 1255884d179dSJan Kara tty_write_message(tty, msg); 1256884d179dSJan Kara tty_kref_put(tty); 1257884d179dSJan Kara } 1258884d179dSJan Kara #endif 1259884d179dSJan Kara 1260bf097aafSJan Kara static void prepare_warning(struct dquot_warn *warn, struct dquot *dquot, 1261bf097aafSJan Kara int warntype) 1262bf097aafSJan Kara { 1263bf097aafSJan Kara if (warning_issued(dquot, warntype)) 1264bf097aafSJan Kara return; 1265bf097aafSJan Kara warn->w_type = warntype; 1266bf097aafSJan Kara warn->w_sb = dquot->dq_sb; 1267bf097aafSJan Kara warn->w_dq_id = dquot->dq_id; 1268bf097aafSJan Kara } 1269bf097aafSJan Kara 1270884d179dSJan Kara /* 1271884d179dSJan Kara * Write warnings to the console and send warning messages over netlink. 1272884d179dSJan Kara * 1273bf097aafSJan Kara * Note that this function can call into tty and networking code. 1274884d179dSJan Kara */ 1275bf097aafSJan Kara static void flush_warnings(struct dquot_warn *warn) 1276884d179dSJan Kara { 1277884d179dSJan Kara int i; 1278884d179dSJan Kara 127986e931a3SSteven Whitehouse for (i = 0; i < MAXQUOTAS; i++) { 1280bf097aafSJan Kara if (warn[i].w_type == QUOTA_NL_NOWARN) 1281bf097aafSJan Kara continue; 1282884d179dSJan Kara #ifdef CONFIG_PRINT_QUOTA_WARNING 1283bf097aafSJan Kara print_warning(&warn[i]); 1284884d179dSJan Kara #endif 12857b9c7321SEric W. Biederman quota_send_warning(warn[i].w_dq_id, 1286bf097aafSJan Kara warn[i].w_sb->s_dev, warn[i].w_type); 1287884d179dSJan Kara } 1288884d179dSJan Kara } 1289884d179dSJan Kara 12907a2435d8SJan Kara static int ignore_hardlimit(struct dquot *dquot) 1291884d179dSJan Kara { 12924c376dcaSEric W. Biederman struct mem_dqinfo *info = &sb_dqopt(dquot->dq_sb)->info[dquot->dq_id.type]; 1293884d179dSJan Kara 1294884d179dSJan Kara return capable(CAP_SYS_RESOURCE) && 1295268157baSJan Kara (info->dqi_format->qf_fmt_id != QFMT_VFS_OLD || 12969c45101eSJan Kara !(info->dqi_flags & DQF_ROOT_SQUASH)); 1297884d179dSJan Kara } 1298884d179dSJan Kara 12997b9ca4c6SJan Kara static int dquot_add_inodes(struct dquot *dquot, qsize_t inodes, 1300bf097aafSJan Kara struct dquot_warn *warn) 1301884d179dSJan Kara { 13027b9ca4c6SJan Kara qsize_t newinodes; 13037b9ca4c6SJan Kara int ret = 0; 1304268157baSJan Kara 13057b9ca4c6SJan Kara spin_lock(&dquot->dq_dqb_lock); 13067b9ca4c6SJan Kara newinodes = dquot->dq_dqb.dqb_curinodes + inodes; 13074c376dcaSEric W. Biederman if (!sb_has_quota_limits_enabled(dquot->dq_sb, dquot->dq_id.type) || 1308884d179dSJan Kara test_bit(DQ_FAKE_B, &dquot->dq_flags)) 13097b9ca4c6SJan Kara goto add; 1310884d179dSJan Kara 1311884d179dSJan Kara if (dquot->dq_dqb.dqb_ihardlimit && 1312268157baSJan Kara newinodes > dquot->dq_dqb.dqb_ihardlimit && 1313884d179dSJan Kara !ignore_hardlimit(dquot)) { 1314bf097aafSJan Kara prepare_warning(warn, dquot, QUOTA_NL_IHARDWARN); 13157b9ca4c6SJan Kara ret = -EDQUOT; 13167b9ca4c6SJan Kara goto out; 1317884d179dSJan Kara } 1318884d179dSJan Kara 1319884d179dSJan Kara if (dquot->dq_dqb.dqb_isoftlimit && 1320268157baSJan Kara newinodes > dquot->dq_dqb.dqb_isoftlimit && 1321268157baSJan Kara dquot->dq_dqb.dqb_itime && 1322e008bb61SArnd Bergmann ktime_get_real_seconds() >= dquot->dq_dqb.dqb_itime && 1323884d179dSJan Kara !ignore_hardlimit(dquot)) { 1324bf097aafSJan Kara prepare_warning(warn, dquot, QUOTA_NL_ISOFTLONGWARN); 13257b9ca4c6SJan Kara ret = -EDQUOT; 13267b9ca4c6SJan Kara goto out; 1327884d179dSJan Kara } 1328884d179dSJan Kara 1329884d179dSJan Kara if (dquot->dq_dqb.dqb_isoftlimit && 1330268157baSJan Kara newinodes > dquot->dq_dqb.dqb_isoftlimit && 1331884d179dSJan Kara dquot->dq_dqb.dqb_itime == 0) { 1332bf097aafSJan Kara prepare_warning(warn, dquot, QUOTA_NL_ISOFTWARN); 1333e008bb61SArnd Bergmann dquot->dq_dqb.dqb_itime = ktime_get_real_seconds() + 13344c376dcaSEric W. Biederman sb_dqopt(dquot->dq_sb)->info[dquot->dq_id.type].dqi_igrace; 1335884d179dSJan Kara } 13367b9ca4c6SJan Kara add: 13377b9ca4c6SJan Kara dquot->dq_dqb.dqb_curinodes = newinodes; 1338884d179dSJan Kara 13397b9ca4c6SJan Kara out: 13407b9ca4c6SJan Kara spin_unlock(&dquot->dq_dqb_lock); 13417b9ca4c6SJan Kara return ret; 1342884d179dSJan Kara } 1343884d179dSJan Kara 13447b9ca4c6SJan Kara static int dquot_add_space(struct dquot *dquot, qsize_t space, 13457b9ca4c6SJan Kara qsize_t rsv_space, unsigned int flags, 1346bf097aafSJan Kara struct dquot_warn *warn) 1347884d179dSJan Kara { 1348884d179dSJan Kara qsize_t tspace; 1349268157baSJan Kara struct super_block *sb = dquot->dq_sb; 13507b9ca4c6SJan Kara int ret = 0; 1351884d179dSJan Kara 13527b9ca4c6SJan Kara spin_lock(&dquot->dq_dqb_lock); 13534c376dcaSEric W. Biederman if (!sb_has_quota_limits_enabled(sb, dquot->dq_id.type) || 1354884d179dSJan Kara test_bit(DQ_FAKE_B, &dquot->dq_flags)) 1355ac3d7939SJan Kara goto finish; 1356884d179dSJan Kara 1357884d179dSJan Kara tspace = dquot->dq_dqb.dqb_curspace + dquot->dq_dqb.dqb_rsvspace 13587b9ca4c6SJan Kara + space + rsv_space; 13597b9ca4c6SJan Kara 1360884d179dSJan Kara if (dquot->dq_dqb.dqb_bhardlimit && 1361884d179dSJan Kara tspace > dquot->dq_dqb.dqb_bhardlimit && 1362884d179dSJan Kara !ignore_hardlimit(dquot)) { 13637b9ca4c6SJan Kara if (flags & DQUOT_SPACE_WARN) 1364bf097aafSJan Kara prepare_warning(warn, dquot, QUOTA_NL_BHARDWARN); 13657b9ca4c6SJan Kara ret = -EDQUOT; 1366ac3d7939SJan Kara goto finish; 1367884d179dSJan Kara } 1368884d179dSJan Kara 1369884d179dSJan Kara if (dquot->dq_dqb.dqb_bsoftlimit && 1370884d179dSJan Kara tspace > dquot->dq_dqb.dqb_bsoftlimit && 1371268157baSJan Kara dquot->dq_dqb.dqb_btime && 1372e008bb61SArnd Bergmann ktime_get_real_seconds() >= dquot->dq_dqb.dqb_btime && 1373884d179dSJan Kara !ignore_hardlimit(dquot)) { 13747b9ca4c6SJan Kara if (flags & DQUOT_SPACE_WARN) 1375bf097aafSJan Kara prepare_warning(warn, dquot, QUOTA_NL_BSOFTLONGWARN); 13767b9ca4c6SJan Kara ret = -EDQUOT; 1377ac3d7939SJan Kara goto finish; 1378884d179dSJan Kara } 1379884d179dSJan Kara 1380884d179dSJan Kara if (dquot->dq_dqb.dqb_bsoftlimit && 1381884d179dSJan Kara tspace > dquot->dq_dqb.dqb_bsoftlimit && 1382884d179dSJan Kara dquot->dq_dqb.dqb_btime == 0) { 13837b9ca4c6SJan Kara if (flags & DQUOT_SPACE_WARN) { 1384bf097aafSJan Kara prepare_warning(warn, dquot, QUOTA_NL_BSOFTWARN); 1385e008bb61SArnd Bergmann dquot->dq_dqb.dqb_btime = ktime_get_real_seconds() + 13864c376dcaSEric W. Biederman sb_dqopt(sb)->info[dquot->dq_id.type].dqi_bgrace; 13877b9ca4c6SJan Kara } else { 1388884d179dSJan Kara /* 1389884d179dSJan Kara * We don't allow preallocation to exceed softlimit so exceeding will 1390884d179dSJan Kara * be always printed 1391884d179dSJan Kara */ 13927b9ca4c6SJan Kara ret = -EDQUOT; 1393ac3d7939SJan Kara goto finish; 1394884d179dSJan Kara } 13957b9ca4c6SJan Kara } 1396ac3d7939SJan Kara finish: 1397ac3d7939SJan Kara /* 1398ac3d7939SJan Kara * We have to be careful and go through warning generation & grace time 1399ac3d7939SJan Kara * setting even if DQUOT_SPACE_NOFAIL is set. That's why we check it 1400ac3d7939SJan Kara * only here... 1401ac3d7939SJan Kara */ 1402ac3d7939SJan Kara if (flags & DQUOT_SPACE_NOFAIL) 1403ac3d7939SJan Kara ret = 0; 1404ac3d7939SJan Kara if (!ret) { 14057b9ca4c6SJan Kara dquot->dq_dqb.dqb_rsvspace += rsv_space; 14067b9ca4c6SJan Kara dquot->dq_dqb.dqb_curspace += space; 1407ac3d7939SJan Kara } 14087b9ca4c6SJan Kara spin_unlock(&dquot->dq_dqb_lock); 14097b9ca4c6SJan Kara return ret; 1410884d179dSJan Kara } 1411884d179dSJan Kara 1412884d179dSJan Kara static int info_idq_free(struct dquot *dquot, qsize_t inodes) 1413884d179dSJan Kara { 1414268157baSJan Kara qsize_t newinodes; 1415268157baSJan Kara 1416884d179dSJan Kara if (test_bit(DQ_FAKE_B, &dquot->dq_flags) || 1417884d179dSJan Kara dquot->dq_dqb.dqb_curinodes <= dquot->dq_dqb.dqb_isoftlimit || 14184c376dcaSEric W. Biederman !sb_has_quota_limits_enabled(dquot->dq_sb, dquot->dq_id.type)) 1419884d179dSJan Kara return QUOTA_NL_NOWARN; 1420884d179dSJan Kara 1421268157baSJan Kara newinodes = dquot->dq_dqb.dqb_curinodes - inodes; 1422268157baSJan Kara if (newinodes <= dquot->dq_dqb.dqb_isoftlimit) 1423884d179dSJan Kara return QUOTA_NL_ISOFTBELOW; 1424884d179dSJan Kara if (dquot->dq_dqb.dqb_curinodes >= dquot->dq_dqb.dqb_ihardlimit && 1425268157baSJan Kara newinodes < dquot->dq_dqb.dqb_ihardlimit) 1426884d179dSJan Kara return QUOTA_NL_IHARDBELOW; 1427884d179dSJan Kara return QUOTA_NL_NOWARN; 1428884d179dSJan Kara } 1429884d179dSJan Kara 1430884d179dSJan Kara static int info_bdq_free(struct dquot *dquot, qsize_t space) 1431884d179dSJan Kara { 143241e327b5Szhangyi (F) qsize_t tspace; 143341e327b5Szhangyi (F) 143441e327b5Szhangyi (F) tspace = dquot->dq_dqb.dqb_curspace + dquot->dq_dqb.dqb_rsvspace; 143541e327b5Szhangyi (F) 1436884d179dSJan Kara if (test_bit(DQ_FAKE_B, &dquot->dq_flags) || 143741e327b5Szhangyi (F) tspace <= dquot->dq_dqb.dqb_bsoftlimit) 1438884d179dSJan Kara return QUOTA_NL_NOWARN; 1439884d179dSJan Kara 144041e327b5Szhangyi (F) if (tspace - space <= dquot->dq_dqb.dqb_bsoftlimit) 1441884d179dSJan Kara return QUOTA_NL_BSOFTBELOW; 144241e327b5Szhangyi (F) if (tspace >= dquot->dq_dqb.dqb_bhardlimit && 144341e327b5Szhangyi (F) tspace - space < dquot->dq_dqb.dqb_bhardlimit) 1444884d179dSJan Kara return QUOTA_NL_BHARDBELOW; 1445884d179dSJan Kara return QUOTA_NL_NOWARN; 1446884d179dSJan Kara } 14470a5a9c72SJan Kara 14484b9bdfa1SBaokun Li static int inode_quota_active(const struct inode *inode) 1449189eef59SChristoph Hellwig { 1450189eef59SChristoph Hellwig struct super_block *sb = inode->i_sb; 1451189eef59SChristoph Hellwig 1452189eef59SChristoph Hellwig if (IS_NOQUOTA(inode)) 1453189eef59SChristoph Hellwig return 0; 1454189eef59SChristoph Hellwig return sb_any_quota_loaded(sb) & ~sb_any_quota_suspended(sb); 1455189eef59SChristoph Hellwig } 1456189eef59SChristoph Hellwig 1457884d179dSJan Kara /* 1458884d179dSJan Kara * Initialize quota pointers in inode 1459871a2931SChristoph Hellwig * 1460871a2931SChristoph Hellwig * It is better to call this function outside of any transaction as it 1461871a2931SChristoph Hellwig * might need a lot of space in journal for dquot structure allocation. 1462884d179dSJan Kara */ 14636184fc0bSJan Kara static int __dquot_initialize(struct inode *inode, int type) 1464884d179dSJan Kara { 14651ea06becSNiu Yawei int cnt, init_needed = 0; 1466ab73ef46SNikolay Borisov struct dquot **dquots, *got[MAXQUOTAS] = {}; 1467884d179dSJan Kara struct super_block *sb = inode->i_sb; 14680a5a9c72SJan Kara qsize_t rsv; 14696184fc0bSJan Kara int ret = 0; 1470884d179dSJan Kara 14714b9bdfa1SBaokun Li if (!inode_quota_active(inode)) 14726184fc0bSJan Kara return 0; 1473884d179dSJan Kara 14745bcd3b6fSKonstantin Khlebnikov dquots = i_dquot(inode); 14755bcd3b6fSKonstantin Khlebnikov 1476884d179dSJan Kara /* First get references to structures we might need. */ 1477884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1478aca645a6SEric W. Biederman struct kqid qid; 1479847aac64SLi Xi kprojid_t projid; 1480847aac64SLi Xi int rc; 14816184fc0bSJan Kara struct dquot *dquot; 1482847aac64SLi Xi 1483884d179dSJan Kara if (type != -1 && cnt != type) 1484884d179dSJan Kara continue; 14851ea06becSNiu Yawei /* 14861ea06becSNiu Yawei * The i_dquot should have been initialized in most cases, 14871ea06becSNiu Yawei * we check it without locking here to avoid unnecessary 14881ea06becSNiu Yawei * dqget()/dqput() calls. 14891ea06becSNiu Yawei */ 14905bcd3b6fSKonstantin Khlebnikov if (dquots[cnt]) 14911ea06becSNiu Yawei continue; 1492847aac64SLi Xi 1493847aac64SLi Xi if (!sb_has_quota_active(sb, cnt)) 1494847aac64SLi Xi continue; 1495847aac64SLi Xi 14961ea06becSNiu Yawei init_needed = 1; 14971ea06becSNiu Yawei 1498884d179dSJan Kara switch (cnt) { 1499884d179dSJan Kara case USRQUOTA: 1500aca645a6SEric W. Biederman qid = make_kqid_uid(inode->i_uid); 1501884d179dSJan Kara break; 1502884d179dSJan Kara case GRPQUOTA: 1503aca645a6SEric W. Biederman qid = make_kqid_gid(inode->i_gid); 1504884d179dSJan Kara break; 1505847aac64SLi Xi case PRJQUOTA: 1506847aac64SLi Xi rc = inode->i_sb->dq_op->get_projid(inode, &projid); 1507847aac64SLi Xi if (rc) 1508847aac64SLi Xi continue; 1509847aac64SLi Xi qid = make_kqid_projid(projid); 1510847aac64SLi Xi break; 1511884d179dSJan Kara } 15126184fc0bSJan Kara dquot = dqget(sb, qid); 15136184fc0bSJan Kara if (IS_ERR(dquot)) { 15146184fc0bSJan Kara /* We raced with somebody turning quotas off... */ 15156184fc0bSJan Kara if (PTR_ERR(dquot) != -ESRCH) { 15166184fc0bSJan Kara ret = PTR_ERR(dquot); 15176184fc0bSJan Kara goto out_put; 15186184fc0bSJan Kara } 15196184fc0bSJan Kara dquot = NULL; 15206184fc0bSJan Kara } 15216184fc0bSJan Kara got[cnt] = dquot; 1522884d179dSJan Kara } 1523884d179dSJan Kara 15241ea06becSNiu Yawei /* All required i_dquot has been initialized */ 15251ea06becSNiu Yawei if (!init_needed) 15266184fc0bSJan Kara return 0; 15271ea06becSNiu Yawei 1528b9ba6f94SNiu Yawei spin_lock(&dq_data_lock); 1529884d179dSJan Kara if (IS_NOQUOTA(inode)) 15306184fc0bSJan Kara goto out_lock; 1531884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1532884d179dSJan Kara if (type != -1 && cnt != type) 1533884d179dSJan Kara continue; 1534884d179dSJan Kara /* Avoid races with quotaoff() */ 1535884d179dSJan Kara if (!sb_has_quota_active(sb, cnt)) 1536884d179dSJan Kara continue; 15374408ea41SJan Kara /* We could race with quotaon or dqget() could have failed */ 15384408ea41SJan Kara if (!got[cnt]) 15394408ea41SJan Kara continue; 15405bcd3b6fSKonstantin Khlebnikov if (!dquots[cnt]) { 15415bcd3b6fSKonstantin Khlebnikov dquots[cnt] = got[cnt]; 1542dd6f3c6dSJan Kara got[cnt] = NULL; 15430a5a9c72SJan Kara /* 15440a5a9c72SJan Kara * Make quota reservation system happy if someone 15450a5a9c72SJan Kara * did a write before quota was turned on 15460a5a9c72SJan Kara */ 15470a5a9c72SJan Kara rsv = inode_get_rsv_space(inode); 15487b9ca4c6SJan Kara if (unlikely(rsv)) { 15497b9ca4c6SJan Kara spin_lock(&inode->i_lock); 15507b9ca4c6SJan Kara /* Get reservation again under proper lock */ 15517b9ca4c6SJan Kara rsv = __inode_get_rsv_space(inode); 15527b9ca4c6SJan Kara spin_lock(&dquots[cnt]->dq_dqb_lock); 15537b9ca4c6SJan Kara dquots[cnt]->dq_dqb.dqb_rsvspace += rsv; 15547b9ca4c6SJan Kara spin_unlock(&dquots[cnt]->dq_dqb_lock); 15557b9ca4c6SJan Kara spin_unlock(&inode->i_lock); 15567b9ca4c6SJan Kara } 1557884d179dSJan Kara } 1558884d179dSJan Kara } 15596184fc0bSJan Kara out_lock: 1560b9ba6f94SNiu Yawei spin_unlock(&dq_data_lock); 15616184fc0bSJan Kara out_put: 1562884d179dSJan Kara /* Drop unused references */ 1563dc52dd3aSDmitry Monakhov dqput_all(got); 15646184fc0bSJan Kara 15656184fc0bSJan Kara return ret; 1566871a2931SChristoph Hellwig } 1567871a2931SChristoph Hellwig 15686184fc0bSJan Kara int dquot_initialize(struct inode *inode) 1569871a2931SChristoph Hellwig { 15706184fc0bSJan Kara return __dquot_initialize(inode, -1); 1571884d179dSJan Kara } 1572884d179dSJan Kara EXPORT_SYMBOL(dquot_initialize); 1573884d179dSJan Kara 1574b8cb5a54STahsin Erdogan bool dquot_initialize_needed(struct inode *inode) 1575b8cb5a54STahsin Erdogan { 1576b8cb5a54STahsin Erdogan struct dquot **dquots; 1577b8cb5a54STahsin Erdogan int i; 1578b8cb5a54STahsin Erdogan 15794b9bdfa1SBaokun Li if (!inode_quota_active(inode)) 1580b8cb5a54STahsin Erdogan return false; 1581b8cb5a54STahsin Erdogan 1582b8cb5a54STahsin Erdogan dquots = i_dquot(inode); 1583b8cb5a54STahsin Erdogan for (i = 0; i < MAXQUOTAS; i++) 1584b8cb5a54STahsin Erdogan if (!dquots[i] && sb_has_quota_active(inode->i_sb, i)) 1585b8cb5a54STahsin Erdogan return true; 1586b8cb5a54STahsin Erdogan return false; 1587b8cb5a54STahsin Erdogan } 1588b8cb5a54STahsin Erdogan EXPORT_SYMBOL(dquot_initialize_needed); 1589b8cb5a54STahsin Erdogan 1590884d179dSJan Kara /* 1591b9ba6f94SNiu Yawei * Release all quotas referenced by inode. 1592b9ba6f94SNiu Yawei * 1593b9ba6f94SNiu Yawei * This function only be called on inode free or converting 1594b9ba6f94SNiu Yawei * a file to quota file, no other users for the i_dquot in 1595b9ba6f94SNiu Yawei * both cases, so we needn't call synchronize_srcu() after 1596b9ba6f94SNiu Yawei * clearing i_dquot. 1597884d179dSJan Kara */ 15989f754758SChristoph Hellwig static void __dquot_drop(struct inode *inode) 1599884d179dSJan Kara { 1600884d179dSJan Kara int cnt; 16015bcd3b6fSKonstantin Khlebnikov struct dquot **dquots = i_dquot(inode); 1602884d179dSJan Kara struct dquot *put[MAXQUOTAS]; 1603884d179dSJan Kara 1604b9ba6f94SNiu Yawei spin_lock(&dq_data_lock); 1605884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 16065bcd3b6fSKonstantin Khlebnikov put[cnt] = dquots[cnt]; 16075bcd3b6fSKonstantin Khlebnikov dquots[cnt] = NULL; 1608884d179dSJan Kara } 1609b9ba6f94SNiu Yawei spin_unlock(&dq_data_lock); 1610dc52dd3aSDmitry Monakhov dqput_all(put); 1611884d179dSJan Kara } 1612884d179dSJan Kara 16139f754758SChristoph Hellwig void dquot_drop(struct inode *inode) 1614884d179dSJan Kara { 16155bcd3b6fSKonstantin Khlebnikov struct dquot * const *dquots; 1616884d179dSJan Kara int cnt; 16179f754758SChristoph Hellwig 16189f754758SChristoph Hellwig if (IS_NOQUOTA(inode)) 16199f754758SChristoph Hellwig return; 16209f754758SChristoph Hellwig 16219f754758SChristoph Hellwig /* 16229f754758SChristoph Hellwig * Test before calling to rule out calls from proc and such 1623884d179dSJan Kara * where we are not allowed to block. Note that this is 1624884d179dSJan Kara * actually reliable test even without the lock - the caller 1625884d179dSJan Kara * must assure that nobody can come after the DQUOT_DROP and 16269f754758SChristoph Hellwig * add quota pointers back anyway. 16279f754758SChristoph Hellwig */ 16285bcd3b6fSKonstantin Khlebnikov dquots = i_dquot(inode); 16299f754758SChristoph Hellwig for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 16305bcd3b6fSKonstantin Khlebnikov if (dquots[cnt]) 1631884d179dSJan Kara break; 16329f754758SChristoph Hellwig } 16339f754758SChristoph Hellwig 1634884d179dSJan Kara if (cnt < MAXQUOTAS) 16359f754758SChristoph Hellwig __dquot_drop(inode); 1636884d179dSJan Kara } 16379f754758SChristoph Hellwig EXPORT_SYMBOL(dquot_drop); 1638884d179dSJan Kara 1639884d179dSJan Kara /* 1640fd8fbfc1SDmitry Monakhov * inode_reserved_space is managed internally by quota, and protected by 1641fd8fbfc1SDmitry Monakhov * i_lock similar to i_blocks+i_bytes. 1642fd8fbfc1SDmitry Monakhov */ 1643fd8fbfc1SDmitry Monakhov static qsize_t *inode_reserved_space(struct inode * inode) 1644fd8fbfc1SDmitry Monakhov { 1645fd8fbfc1SDmitry Monakhov /* Filesystem must explicitly define it's own method in order to use 1646fd8fbfc1SDmitry Monakhov * quota reservation interface */ 1647fd8fbfc1SDmitry Monakhov BUG_ON(!inode->i_sb->dq_op->get_reserved_space); 1648fd8fbfc1SDmitry Monakhov return inode->i_sb->dq_op->get_reserved_space(inode); 1649fd8fbfc1SDmitry Monakhov } 1650fd8fbfc1SDmitry Monakhov 16517b9ca4c6SJan Kara static qsize_t __inode_get_rsv_space(struct inode *inode) 1652fd8fbfc1SDmitry Monakhov { 16537b9ca4c6SJan Kara if (!inode->i_sb->dq_op->get_reserved_space) 16547b9ca4c6SJan Kara return 0; 16557b9ca4c6SJan Kara return *inode_reserved_space(inode); 1656fd8fbfc1SDmitry Monakhov } 1657fd8fbfc1SDmitry Monakhov 1658fd8fbfc1SDmitry Monakhov static qsize_t inode_get_rsv_space(struct inode *inode) 1659fd8fbfc1SDmitry Monakhov { 1660fd8fbfc1SDmitry Monakhov qsize_t ret; 166105b5d898SJan Kara 166205b5d898SJan Kara if (!inode->i_sb->dq_op->get_reserved_space) 166305b5d898SJan Kara return 0; 1664fd8fbfc1SDmitry Monakhov spin_lock(&inode->i_lock); 16657b9ca4c6SJan Kara ret = __inode_get_rsv_space(inode); 1666fd8fbfc1SDmitry Monakhov spin_unlock(&inode->i_lock); 1667fd8fbfc1SDmitry Monakhov return ret; 1668fd8fbfc1SDmitry Monakhov } 1669fd8fbfc1SDmitry Monakhov 1670fd8fbfc1SDmitry Monakhov /* 16715dd4056dSChristoph Hellwig * This functions updates i_blocks+i_bytes fields and quota information 16725dd4056dSChristoph Hellwig * (together with appropriate checks). 16735dd4056dSChristoph Hellwig * 16745dd4056dSChristoph Hellwig * NOTE: We absolutely rely on the fact that caller dirties the inode 16755dd4056dSChristoph Hellwig * (usually helpers in quotaops.h care about this) and holds a handle for 16765dd4056dSChristoph Hellwig * the current transaction so that dquot write and inode write go into the 16775dd4056dSChristoph Hellwig * same transaction. 1678884d179dSJan Kara */ 1679884d179dSJan Kara 1680884d179dSJan Kara /* 1681884d179dSJan Kara * This operation can block, but only after everything is updated 1682884d179dSJan Kara */ 168356246f9aSEric Sandeen int __dquot_alloc_space(struct inode *inode, qsize_t number, int flags) 1684884d179dSJan Kara { 1685b9ba6f94SNiu Yawei int cnt, ret = 0, index; 1686bf097aafSJan Kara struct dquot_warn warn[MAXQUOTAS]; 168756246f9aSEric Sandeen int reserve = flags & DQUOT_SPACE_RESERVE; 16885bcd3b6fSKonstantin Khlebnikov struct dquot **dquots; 1689*40a673b4SWang Jianjian struct dquot *dquot; 1690884d179dSJan Kara 16914b9bdfa1SBaokun Li if (!inode_quota_active(inode)) { 1692a478e522SJan Kara if (reserve) { 1693a478e522SJan Kara spin_lock(&inode->i_lock); 1694a478e522SJan Kara *inode_reserved_space(inode) += number; 1695a478e522SJan Kara spin_unlock(&inode->i_lock); 1696a478e522SJan Kara } else { 1697a478e522SJan Kara inode_add_bytes(inode, number); 1698a478e522SJan Kara } 1699fd8fbfc1SDmitry Monakhov goto out; 1700fd8fbfc1SDmitry Monakhov } 1701fd8fbfc1SDmitry Monakhov 1702884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) 1703bf097aafSJan Kara warn[cnt].w_type = QUOTA_NL_NOWARN; 1704884d179dSJan Kara 17055bcd3b6fSKonstantin Khlebnikov dquots = i_dquot(inode); 1706b9ba6f94SNiu Yawei index = srcu_read_lock(&dquot_srcu); 17077b9ca4c6SJan Kara spin_lock(&inode->i_lock); 1708884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1709*40a673b4SWang Jianjian dquot = srcu_dereference(dquots[cnt], &dquot_srcu); 1710*40a673b4SWang Jianjian if (!dquot) 1711884d179dSJan Kara continue; 1712df15a2a5SChengguang Xu if (reserve) { 1713*40a673b4SWang Jianjian ret = dquot_add_space(dquot, 0, number, flags, &warn[cnt]); 17147b9ca4c6SJan Kara } else { 1715*40a673b4SWang Jianjian ret = dquot_add_space(dquot, number, 0, flags, &warn[cnt]); 17167b9ca4c6SJan Kara } 17177b9ca4c6SJan Kara if (ret) { 17187b9ca4c6SJan Kara /* Back out changes we already did */ 17197b9ca4c6SJan Kara for (cnt--; cnt >= 0; cnt--) { 1720*40a673b4SWang Jianjian dquot = srcu_dereference(dquots[cnt], &dquot_srcu); 1721*40a673b4SWang Jianjian if (!dquot) 17227b9ca4c6SJan Kara continue; 1723*40a673b4SWang Jianjian spin_lock(&dquot->dq_dqb_lock); 1724632a9f3aSChengguang Xu if (reserve) 1725*40a673b4SWang Jianjian dquot_free_reserved_space(dquot, number); 1726632a9f3aSChengguang Xu else 1727*40a673b4SWang Jianjian dquot_decr_space(dquot, number); 1728*40a673b4SWang Jianjian spin_unlock(&dquot->dq_dqb_lock); 17297b9ca4c6SJan Kara } 17307b9ca4c6SJan Kara spin_unlock(&inode->i_lock); 1731fd8fbfc1SDmitry Monakhov goto out_flush_warn; 1732884d179dSJan Kara } 1733884d179dSJan Kara } 1734884d179dSJan Kara if (reserve) 1735a478e522SJan Kara *inode_reserved_space(inode) += number; 1736884d179dSJan Kara else 17377b9ca4c6SJan Kara __inode_add_bytes(inode, number); 1738a478e522SJan Kara spin_unlock(&inode->i_lock); 1739fd8fbfc1SDmitry Monakhov 1740fd8fbfc1SDmitry Monakhov if (reserve) 1741fd8fbfc1SDmitry Monakhov goto out_flush_warn; 1742bf097aafSJan Kara mark_all_dquot_dirty(dquots); 1743fd8fbfc1SDmitry Monakhov out_flush_warn: 1744b9ba6f94SNiu Yawei srcu_read_unlock(&dquot_srcu, index); 1745bf097aafSJan Kara flush_warnings(warn); 1746fd8fbfc1SDmitry Monakhov out: 1747884d179dSJan Kara return ret; 1748884d179dSJan Kara } 17495dd4056dSChristoph Hellwig EXPORT_SYMBOL(__dquot_alloc_space); 1750884d179dSJan Kara 1751884d179dSJan Kara /* 1752884d179dSJan Kara * This operation can block, but only after everything is updated 1753884d179dSJan Kara */ 17546bab3596SJan Kara int dquot_alloc_inode(struct inode *inode) 1755884d179dSJan Kara { 1756b9ba6f94SNiu Yawei int cnt, ret = 0, index; 1757bf097aafSJan Kara struct dquot_warn warn[MAXQUOTAS]; 17585bcd3b6fSKonstantin Khlebnikov struct dquot * const *dquots; 1759*40a673b4SWang Jianjian struct dquot *dquot; 1760884d179dSJan Kara 17614b9bdfa1SBaokun Li if (!inode_quota_active(inode)) 176263936ddaSChristoph Hellwig return 0; 1763884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) 1764bf097aafSJan Kara warn[cnt].w_type = QUOTA_NL_NOWARN; 1765b9ba6f94SNiu Yawei 17665bcd3b6fSKonstantin Khlebnikov dquots = i_dquot(inode); 1767b9ba6f94SNiu Yawei index = srcu_read_lock(&dquot_srcu); 17687b9ca4c6SJan Kara spin_lock(&inode->i_lock); 1769884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1770*40a673b4SWang Jianjian dquot = srcu_dereference(dquots[cnt], &dquot_srcu); 1771*40a673b4SWang Jianjian if (!dquot) 1772884d179dSJan Kara continue; 1773*40a673b4SWang Jianjian ret = dquot_add_inodes(dquot, 1, &warn[cnt]); 17747b9ca4c6SJan Kara if (ret) { 17757b9ca4c6SJan Kara for (cnt--; cnt >= 0; cnt--) { 1776*40a673b4SWang Jianjian dquot = srcu_dereference(dquots[cnt], &dquot_srcu); 1777*40a673b4SWang Jianjian if (!dquot) 17787b9ca4c6SJan Kara continue; 17797b9ca4c6SJan Kara /* Back out changes we already did */ 1780*40a673b4SWang Jianjian spin_lock(&dquot->dq_dqb_lock); 1781*40a673b4SWang Jianjian dquot_decr_inodes(dquot, 1); 1782*40a673b4SWang Jianjian spin_unlock(&dquot->dq_dqb_lock); 17837b9ca4c6SJan Kara } 1784884d179dSJan Kara goto warn_put_all; 1785884d179dSJan Kara } 1786884d179dSJan Kara } 1787efd8f0e6SChristoph Hellwig 1788884d179dSJan Kara warn_put_all: 17897b9ca4c6SJan Kara spin_unlock(&inode->i_lock); 179063936ddaSChristoph Hellwig if (ret == 0) 1791bf097aafSJan Kara mark_all_dquot_dirty(dquots); 1792b9ba6f94SNiu Yawei srcu_read_unlock(&dquot_srcu, index); 1793bf097aafSJan Kara flush_warnings(warn); 1794884d179dSJan Kara return ret; 1795884d179dSJan Kara } 1796884d179dSJan Kara EXPORT_SYMBOL(dquot_alloc_inode); 1797884d179dSJan Kara 17985dd4056dSChristoph Hellwig /* 17995dd4056dSChristoph Hellwig * Convert in-memory reserved quotas to real consumed quotas 18005dd4056dSChristoph Hellwig */ 18015dd4056dSChristoph Hellwig int dquot_claim_space_nodirty(struct inode *inode, qsize_t number) 1802884d179dSJan Kara { 18035bcd3b6fSKonstantin Khlebnikov struct dquot **dquots; 1804*40a673b4SWang Jianjian struct dquot *dquot; 1805b9ba6f94SNiu Yawei int cnt, index; 1806884d179dSJan Kara 18074b9bdfa1SBaokun Li if (!inode_quota_active(inode)) { 18080ed60de3SJan Kara spin_lock(&inode->i_lock); 18090ed60de3SJan Kara *inode_reserved_space(inode) -= number; 18100ed60de3SJan Kara __inode_add_bytes(inode, number); 18110ed60de3SJan Kara spin_unlock(&inode->i_lock); 18125dd4056dSChristoph Hellwig return 0; 1813884d179dSJan Kara } 1814884d179dSJan Kara 18155bcd3b6fSKonstantin Khlebnikov dquots = i_dquot(inode); 1816b9ba6f94SNiu Yawei index = srcu_read_lock(&dquot_srcu); 18177b9ca4c6SJan Kara spin_lock(&inode->i_lock); 1818884d179dSJan Kara /* Claim reserved quotas to allocated quotas */ 1819884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1820*40a673b4SWang Jianjian dquot = srcu_dereference(dquots[cnt], &dquot_srcu); 1821*40a673b4SWang Jianjian if (dquot) { 18227b9ca4c6SJan Kara spin_lock(&dquot->dq_dqb_lock); 18233ab167d2SJan Kara if (WARN_ON_ONCE(dquot->dq_dqb.dqb_rsvspace < number)) 18243ab167d2SJan Kara number = dquot->dq_dqb.dqb_rsvspace; 18253ab167d2SJan Kara dquot->dq_dqb.dqb_curspace += number; 18263ab167d2SJan Kara dquot->dq_dqb.dqb_rsvspace -= number; 18277b9ca4c6SJan Kara spin_unlock(&dquot->dq_dqb_lock); 18283ab167d2SJan Kara } 1829884d179dSJan Kara } 1830884d179dSJan Kara /* Update inode bytes */ 18310ed60de3SJan Kara *inode_reserved_space(inode) -= number; 18320ed60de3SJan Kara __inode_add_bytes(inode, number); 18330ed60de3SJan Kara spin_unlock(&inode->i_lock); 18345bcd3b6fSKonstantin Khlebnikov mark_all_dquot_dirty(dquots); 1835b9ba6f94SNiu Yawei srcu_read_unlock(&dquot_srcu, index); 18365dd4056dSChristoph Hellwig return 0; 1837884d179dSJan Kara } 18385dd4056dSChristoph Hellwig EXPORT_SYMBOL(dquot_claim_space_nodirty); 1839884d179dSJan Kara 1840884d179dSJan Kara /* 18411c8924ebSJan Kara * Convert allocated space back to in-memory reserved quotas 18421c8924ebSJan Kara */ 18431c8924ebSJan Kara void dquot_reclaim_space_nodirty(struct inode *inode, qsize_t number) 18441c8924ebSJan Kara { 18455bcd3b6fSKonstantin Khlebnikov struct dquot **dquots; 1846*40a673b4SWang Jianjian struct dquot *dquot; 1847b9ba6f94SNiu Yawei int cnt, index; 18481c8924ebSJan Kara 18494b9bdfa1SBaokun Li if (!inode_quota_active(inode)) { 18500ed60de3SJan Kara spin_lock(&inode->i_lock); 18510ed60de3SJan Kara *inode_reserved_space(inode) += number; 18520ed60de3SJan Kara __inode_sub_bytes(inode, number); 18530ed60de3SJan Kara spin_unlock(&inode->i_lock); 18541c8924ebSJan Kara return; 18551c8924ebSJan Kara } 18561c8924ebSJan Kara 18575bcd3b6fSKonstantin Khlebnikov dquots = i_dquot(inode); 1858b9ba6f94SNiu Yawei index = srcu_read_lock(&dquot_srcu); 18597b9ca4c6SJan Kara spin_lock(&inode->i_lock); 18601c8924ebSJan Kara /* Claim reserved quotas to allocated quotas */ 18611c8924ebSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1862*40a673b4SWang Jianjian dquot = srcu_dereference(dquots[cnt], &dquot_srcu); 1863*40a673b4SWang Jianjian if (dquot) { 18647b9ca4c6SJan Kara spin_lock(&dquot->dq_dqb_lock); 18653ab167d2SJan Kara if (WARN_ON_ONCE(dquot->dq_dqb.dqb_curspace < number)) 18663ab167d2SJan Kara number = dquot->dq_dqb.dqb_curspace; 18673ab167d2SJan Kara dquot->dq_dqb.dqb_rsvspace += number; 18683ab167d2SJan Kara dquot->dq_dqb.dqb_curspace -= number; 18697b9ca4c6SJan Kara spin_unlock(&dquot->dq_dqb_lock); 18703ab167d2SJan Kara } 18711c8924ebSJan Kara } 18721c8924ebSJan Kara /* Update inode bytes */ 18730ed60de3SJan Kara *inode_reserved_space(inode) += number; 18740ed60de3SJan Kara __inode_sub_bytes(inode, number); 18750ed60de3SJan Kara spin_unlock(&inode->i_lock); 18765bcd3b6fSKonstantin Khlebnikov mark_all_dquot_dirty(dquots); 1877b9ba6f94SNiu Yawei srcu_read_unlock(&dquot_srcu, index); 18781c8924ebSJan Kara return; 18791c8924ebSJan Kara } 18801c8924ebSJan Kara EXPORT_SYMBOL(dquot_reclaim_space_nodirty); 18811c8924ebSJan Kara 18821c8924ebSJan Kara /* 1883884d179dSJan Kara * This operation can block, but only after everything is updated 1884884d179dSJan Kara */ 188556246f9aSEric Sandeen void __dquot_free_space(struct inode *inode, qsize_t number, int flags) 1886884d179dSJan Kara { 1887884d179dSJan Kara unsigned int cnt; 1888bf097aafSJan Kara struct dquot_warn warn[MAXQUOTAS]; 18895bcd3b6fSKonstantin Khlebnikov struct dquot **dquots; 1890*40a673b4SWang Jianjian struct dquot *dquot; 1891b9ba6f94SNiu Yawei int reserve = flags & DQUOT_SPACE_RESERVE, index; 1892884d179dSJan Kara 18934b9bdfa1SBaokun Li if (!inode_quota_active(inode)) { 1894a478e522SJan Kara if (reserve) { 1895a478e522SJan Kara spin_lock(&inode->i_lock); 1896a478e522SJan Kara *inode_reserved_space(inode) -= number; 1897a478e522SJan Kara spin_unlock(&inode->i_lock); 1898a478e522SJan Kara } else { 1899a478e522SJan Kara inode_sub_bytes(inode, number); 1900a478e522SJan Kara } 19015dd4056dSChristoph Hellwig return; 1902884d179dSJan Kara } 1903884d179dSJan Kara 19045bcd3b6fSKonstantin Khlebnikov dquots = i_dquot(inode); 1905b9ba6f94SNiu Yawei index = srcu_read_lock(&dquot_srcu); 19067b9ca4c6SJan Kara spin_lock(&inode->i_lock); 1907884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1908bf097aafSJan Kara int wtype; 1909bf097aafSJan Kara 1910bf097aafSJan Kara warn[cnt].w_type = QUOTA_NL_NOWARN; 1911*40a673b4SWang Jianjian dquot = srcu_dereference(dquots[cnt], &dquot_srcu); 1912*40a673b4SWang Jianjian if (!dquot) 1913884d179dSJan Kara continue; 1914*40a673b4SWang Jianjian spin_lock(&dquot->dq_dqb_lock); 1915*40a673b4SWang Jianjian wtype = info_bdq_free(dquot, number); 1916bf097aafSJan Kara if (wtype != QUOTA_NL_NOWARN) 1917*40a673b4SWang Jianjian prepare_warning(&warn[cnt], dquot, wtype); 1918fd8fbfc1SDmitry Monakhov if (reserve) 1919*40a673b4SWang Jianjian dquot_free_reserved_space(dquot, number); 1920fd8fbfc1SDmitry Monakhov else 1921*40a673b4SWang Jianjian dquot_decr_space(dquot, number); 1922*40a673b4SWang Jianjian spin_unlock(&dquot->dq_dqb_lock); 1923884d179dSJan Kara } 19247b9ca4c6SJan Kara if (reserve) 1925a478e522SJan Kara *inode_reserved_space(inode) -= number; 19267b9ca4c6SJan Kara else 19277b9ca4c6SJan Kara __inode_sub_bytes(inode, number); 1928a478e522SJan Kara spin_unlock(&inode->i_lock); 1929fd8fbfc1SDmitry Monakhov 1930fd8fbfc1SDmitry Monakhov if (reserve) 1931fd8fbfc1SDmitry Monakhov goto out_unlock; 1932bf097aafSJan Kara mark_all_dquot_dirty(dquots); 1933fd8fbfc1SDmitry Monakhov out_unlock: 1934b9ba6f94SNiu Yawei srcu_read_unlock(&dquot_srcu, index); 1935bf097aafSJan Kara flush_warnings(warn); 1936884d179dSJan Kara } 19375dd4056dSChristoph Hellwig EXPORT_SYMBOL(__dquot_free_space); 1938fd8fbfc1SDmitry Monakhov 1939fd8fbfc1SDmitry Monakhov /* 1940884d179dSJan Kara * This operation can block, but only after everything is updated 1941884d179dSJan Kara */ 19426bab3596SJan Kara void dquot_free_inode(struct inode *inode) 1943884d179dSJan Kara { 1944884d179dSJan Kara unsigned int cnt; 1945bf097aafSJan Kara struct dquot_warn warn[MAXQUOTAS]; 19465bcd3b6fSKonstantin Khlebnikov struct dquot * const *dquots; 1947*40a673b4SWang Jianjian struct dquot *dquot; 1948b9ba6f94SNiu Yawei int index; 1949884d179dSJan Kara 19504b9bdfa1SBaokun Li if (!inode_quota_active(inode)) 195163936ddaSChristoph Hellwig return; 1952884d179dSJan Kara 19535bcd3b6fSKonstantin Khlebnikov dquots = i_dquot(inode); 1954b9ba6f94SNiu Yawei index = srcu_read_lock(&dquot_srcu); 19557b9ca4c6SJan Kara spin_lock(&inode->i_lock); 1956884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1957bf097aafSJan Kara int wtype; 1958bf097aafSJan Kara warn[cnt].w_type = QUOTA_NL_NOWARN; 1959*40a673b4SWang Jianjian dquot = srcu_dereference(dquots[cnt], &dquot_srcu); 1960*40a673b4SWang Jianjian if (!dquot) 1961884d179dSJan Kara continue; 1962*40a673b4SWang Jianjian spin_lock(&dquot->dq_dqb_lock); 1963*40a673b4SWang Jianjian wtype = info_idq_free(dquot, 1); 1964bf097aafSJan Kara if (wtype != QUOTA_NL_NOWARN) 1965*40a673b4SWang Jianjian prepare_warning(&warn[cnt], dquot, wtype); 1966*40a673b4SWang Jianjian dquot_decr_inodes(dquot, 1); 1967*40a673b4SWang Jianjian spin_unlock(&dquot->dq_dqb_lock); 1968884d179dSJan Kara } 19697b9ca4c6SJan Kara spin_unlock(&inode->i_lock); 1970bf097aafSJan Kara mark_all_dquot_dirty(dquots); 1971b9ba6f94SNiu Yawei srcu_read_unlock(&dquot_srcu, index); 1972bf097aafSJan Kara flush_warnings(warn); 1973884d179dSJan Kara } 1974884d179dSJan Kara EXPORT_SYMBOL(dquot_free_inode); 1975884d179dSJan Kara 1976884d179dSJan Kara /* 1977884d179dSJan Kara * Transfer the number of inode and blocks from one diskquota to an other. 1978bc8e5f07SJan Kara * On success, dquot references in transfer_to are consumed and references 1979bc8e5f07SJan Kara * to original dquots that need to be released are placed there. On failure, 1980bc8e5f07SJan Kara * references are kept untouched. 1981884d179dSJan Kara * 1982884d179dSJan Kara * This operation can block, but only after everything is updated 1983884d179dSJan Kara * A transaction must be started when entering this function. 1984bc8e5f07SJan Kara * 1985b9ba6f94SNiu Yawei * We are holding reference on transfer_from & transfer_to, no need to 1986b9ba6f94SNiu Yawei * protect them by srcu_read_lock(). 1987884d179dSJan Kara */ 1988bc8e5f07SJan Kara int __dquot_transfer(struct inode *inode, struct dquot **transfer_to) 1989884d179dSJan Kara { 19907b9ca4c6SJan Kara qsize_t cur_space; 1991884d179dSJan Kara qsize_t rsv_space = 0; 19927a9ca53aSTahsin Erdogan qsize_t inode_usage = 1; 1993bc8e5f07SJan Kara struct dquot *transfer_from[MAXQUOTAS] = {}; 1994*40a673b4SWang Jianjian int cnt, index, ret = 0; 19959e32784bSDmitry char is_valid[MAXQUOTAS] = {}; 1996bf097aafSJan Kara struct dquot_warn warn_to[MAXQUOTAS]; 1997bf097aafSJan Kara struct dquot_warn warn_from_inodes[MAXQUOTAS]; 1998bf097aafSJan Kara struct dquot_warn warn_from_space[MAXQUOTAS]; 1999884d179dSJan Kara 2000884d179dSJan Kara if (IS_NOQUOTA(inode)) 2001efd8f0e6SChristoph Hellwig return 0; 20027a9ca53aSTahsin Erdogan 20037a9ca53aSTahsin Erdogan if (inode->i_sb->dq_op->get_inode_usage) { 20047a9ca53aSTahsin Erdogan ret = inode->i_sb->dq_op->get_inode_usage(inode, &inode_usage); 20057a9ca53aSTahsin Erdogan if (ret) 20067a9ca53aSTahsin Erdogan return ret; 20077a9ca53aSTahsin Erdogan } 20087a9ca53aSTahsin Erdogan 2009884d179dSJan Kara /* Initialize the arrays */ 2010bf097aafSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 2011bf097aafSJan Kara warn_to[cnt].w_type = QUOTA_NL_NOWARN; 2012bf097aafSJan Kara warn_from_inodes[cnt].w_type = QUOTA_NL_NOWARN; 2013bf097aafSJan Kara warn_from_space[cnt].w_type = QUOTA_NL_NOWARN; 2014bf097aafSJan Kara } 2015b9ba6f94SNiu Yawei 2016b9ba6f94SNiu Yawei spin_lock(&dq_data_lock); 20177b9ca4c6SJan Kara spin_lock(&inode->i_lock); 2018884d179dSJan Kara if (IS_NOQUOTA(inode)) { /* File without quota accounting? */ 20197b9ca4c6SJan Kara spin_unlock(&inode->i_lock); 2020b9ba6f94SNiu Yawei spin_unlock(&dq_data_lock); 2021bc8e5f07SJan Kara return 0; 2022884d179dSJan Kara } 20237b9ca4c6SJan Kara cur_space = __inode_get_bytes(inode); 20247b9ca4c6SJan Kara rsv_space = __inode_get_rsv_space(inode); 20257b9ca4c6SJan Kara /* 20267b9ca4c6SJan Kara * Build the transfer_from list, check limits, and update usage in 20277b9ca4c6SJan Kara * the target structures. 20287b9ca4c6SJan Kara */ 2029884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 20309e32784bSDmitry /* 20319e32784bSDmitry * Skip changes for same uid or gid or for turned off quota-type. 20329e32784bSDmitry */ 2033dd6f3c6dSJan Kara if (!transfer_to[cnt]) 2034884d179dSJan Kara continue; 20359e32784bSDmitry /* Avoid races with quotaoff() */ 20369e32784bSDmitry if (!sb_has_quota_active(inode->i_sb, cnt)) 20379e32784bSDmitry continue; 20389e32784bSDmitry is_valid[cnt] = 1; 20392d0fa467SJan Kara transfer_from[cnt] = i_dquot(inode)[cnt]; 20407b9ca4c6SJan Kara ret = dquot_add_inodes(transfer_to[cnt], inode_usage, 20417b9ca4c6SJan Kara &warn_to[cnt]); 2042efd8f0e6SChristoph Hellwig if (ret) 2043efd8f0e6SChristoph Hellwig goto over_quota; 2044c6d9c35dSyangerkun ret = dquot_add_space(transfer_to[cnt], cur_space, rsv_space, 2045c6d9c35dSyangerkun DQUOT_SPACE_WARN, &warn_to[cnt]); 20467b9ca4c6SJan Kara if (ret) { 20470a51fb71SKonstantin Khlebnikov spin_lock(&transfer_to[cnt]->dq_dqb_lock); 20487b9ca4c6SJan Kara dquot_decr_inodes(transfer_to[cnt], inode_usage); 20490a51fb71SKonstantin Khlebnikov spin_unlock(&transfer_to[cnt]->dq_dqb_lock); 2050884d179dSJan Kara goto over_quota; 2051884d179dSJan Kara } 20527b9ca4c6SJan Kara } 2053884d179dSJan Kara 20547b9ca4c6SJan Kara /* Decrease usage for source structures and update quota pointers */ 2055884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 20569e32784bSDmitry if (!is_valid[cnt]) 2057884d179dSJan Kara continue; 2058884d179dSJan Kara /* Due to IO error we might not have transfer_from[] structure */ 2059884d179dSJan Kara if (transfer_from[cnt]) { 2060bf097aafSJan Kara int wtype; 20617b9ca4c6SJan Kara 20627b9ca4c6SJan Kara spin_lock(&transfer_from[cnt]->dq_dqb_lock); 20637a9ca53aSTahsin Erdogan wtype = info_idq_free(transfer_from[cnt], inode_usage); 2064bf097aafSJan Kara if (wtype != QUOTA_NL_NOWARN) 2065bf097aafSJan Kara prepare_warning(&warn_from_inodes[cnt], 2066bf097aafSJan Kara transfer_from[cnt], wtype); 20677b9ca4c6SJan Kara wtype = info_bdq_free(transfer_from[cnt], 20687b9ca4c6SJan Kara cur_space + rsv_space); 2069bf097aafSJan Kara if (wtype != QUOTA_NL_NOWARN) 2070bf097aafSJan Kara prepare_warning(&warn_from_space[cnt], 2071bf097aafSJan Kara transfer_from[cnt], wtype); 20727a9ca53aSTahsin Erdogan dquot_decr_inodes(transfer_from[cnt], inode_usage); 2073884d179dSJan Kara dquot_decr_space(transfer_from[cnt], cur_space); 2074884d179dSJan Kara dquot_free_reserved_space(transfer_from[cnt], 2075884d179dSJan Kara rsv_space); 20767b9ca4c6SJan Kara spin_unlock(&transfer_from[cnt]->dq_dqb_lock); 2077884d179dSJan Kara } 20782d0fa467SJan Kara i_dquot(inode)[cnt] = transfer_to[cnt]; 2079884d179dSJan Kara } 20807b9ca4c6SJan Kara spin_unlock(&inode->i_lock); 2081884d179dSJan Kara spin_unlock(&dq_data_lock); 2082884d179dSJan Kara 2083*40a673b4SWang Jianjian /* 2084*40a673b4SWang Jianjian * These arrays are local and we hold dquot references so we don't need 2085*40a673b4SWang Jianjian * the srcu protection but still take dquot_srcu to avoid warning in 2086*40a673b4SWang Jianjian * mark_all_dquot_dirty(). 2087*40a673b4SWang Jianjian */ 2088*40a673b4SWang Jianjian index = srcu_read_lock(&dquot_srcu); 2089dc52dd3aSDmitry Monakhov mark_all_dquot_dirty(transfer_from); 2090dc52dd3aSDmitry Monakhov mark_all_dquot_dirty(transfer_to); 2091*40a673b4SWang Jianjian srcu_read_unlock(&dquot_srcu, index); 2092*40a673b4SWang Jianjian 2093bf097aafSJan Kara flush_warnings(warn_to); 2094bf097aafSJan Kara flush_warnings(warn_from_inodes); 2095bf097aafSJan Kara flush_warnings(warn_from_space); 2096bc8e5f07SJan Kara /* Pass back references to put */ 2097dc52dd3aSDmitry Monakhov for (cnt = 0; cnt < MAXQUOTAS; cnt++) 20989e32784bSDmitry if (is_valid[cnt]) 2099bc8e5f07SJan Kara transfer_to[cnt] = transfer_from[cnt]; 210086f3cbecSJan Kara return 0; 2101884d179dSJan Kara over_quota: 21027b9ca4c6SJan Kara /* Back out changes we already did */ 21037b9ca4c6SJan Kara for (cnt--; cnt >= 0; cnt--) { 21047b9ca4c6SJan Kara if (!is_valid[cnt]) 21057b9ca4c6SJan Kara continue; 21067b9ca4c6SJan Kara spin_lock(&transfer_to[cnt]->dq_dqb_lock); 21077b9ca4c6SJan Kara dquot_decr_inodes(transfer_to[cnt], inode_usage); 21087b9ca4c6SJan Kara dquot_decr_space(transfer_to[cnt], cur_space); 21097b9ca4c6SJan Kara dquot_free_reserved_space(transfer_to[cnt], rsv_space); 21107b9ca4c6SJan Kara spin_unlock(&transfer_to[cnt]->dq_dqb_lock); 21117b9ca4c6SJan Kara } 21127b9ca4c6SJan Kara spin_unlock(&inode->i_lock); 2113884d179dSJan Kara spin_unlock(&dq_data_lock); 2114bf097aafSJan Kara flush_warnings(warn_to); 211586f3cbecSJan Kara return ret; 2116884d179dSJan Kara } 2117bc8e5f07SJan Kara EXPORT_SYMBOL(__dquot_transfer); 2118884d179dSJan Kara 21198ddd69d6SDmitry Monakhov /* Wrapper for transferring ownership of an inode for uid/gid only 21208ddd69d6SDmitry Monakhov * Called from FSXXX_setattr() 21218ddd69d6SDmitry Monakhov */ 2122f861646aSChristian Brauner int dquot_transfer(struct mnt_idmap *idmap, struct inode *inode, 212371e7b535SChristian Brauner struct iattr *iattr) 2124884d179dSJan Kara { 2125bc8e5f07SJan Kara struct dquot *transfer_to[MAXQUOTAS] = {}; 21266184fc0bSJan Kara struct dquot *dquot; 2127bc8e5f07SJan Kara struct super_block *sb = inode->i_sb; 2128bc8e5f07SJan Kara int ret; 21298ddd69d6SDmitry Monakhov 21304b9bdfa1SBaokun Li if (!inode_quota_active(inode)) 2131884d179dSJan Kara return 0; 2132bc8e5f07SJan Kara 21330dbe12f2SChristian Brauner if (i_uid_needs_update(idmap, iattr, inode)) { 21344d7ca409SChristian Brauner kuid_t kuid = from_vfsuid(idmap, i_user_ns(inode), 2135b27c82e1SChristian Brauner iattr->ia_vfsuid); 2136b27c82e1SChristian Brauner 2137b27c82e1SChristian Brauner dquot = dqget(sb, make_kqid_uid(kuid)); 21386184fc0bSJan Kara if (IS_ERR(dquot)) { 21396184fc0bSJan Kara if (PTR_ERR(dquot) != -ESRCH) { 21406184fc0bSJan Kara ret = PTR_ERR(dquot); 21416184fc0bSJan Kara goto out_put; 21426184fc0bSJan Kara } 21436184fc0bSJan Kara dquot = NULL; 21446184fc0bSJan Kara } 21456184fc0bSJan Kara transfer_to[USRQUOTA] = dquot; 21466184fc0bSJan Kara } 21470dbe12f2SChristian Brauner if (i_gid_needs_update(idmap, iattr, inode)) { 21484d7ca409SChristian Brauner kgid_t kgid = from_vfsgid(idmap, i_user_ns(inode), 2149b27c82e1SChristian Brauner iattr->ia_vfsgid); 2150b27c82e1SChristian Brauner 2151b27c82e1SChristian Brauner dquot = dqget(sb, make_kqid_gid(kgid)); 21526184fc0bSJan Kara if (IS_ERR(dquot)) { 21536184fc0bSJan Kara if (PTR_ERR(dquot) != -ESRCH) { 21546184fc0bSJan Kara ret = PTR_ERR(dquot); 21556184fc0bSJan Kara goto out_put; 21566184fc0bSJan Kara } 21576184fc0bSJan Kara dquot = NULL; 21586184fc0bSJan Kara } 21596184fc0bSJan Kara transfer_to[GRPQUOTA] = dquot; 21606184fc0bSJan Kara } 2161bc8e5f07SJan Kara ret = __dquot_transfer(inode, transfer_to); 21626184fc0bSJan Kara out_put: 2163bc8e5f07SJan Kara dqput_all(transfer_to); 2164bc8e5f07SJan Kara return ret; 2165884d179dSJan Kara } 2166b43fa828SChristoph Hellwig EXPORT_SYMBOL(dquot_transfer); 2167884d179dSJan Kara 2168884d179dSJan Kara /* 2169884d179dSJan Kara * Write info of quota file to disk 2170884d179dSJan Kara */ 2171884d179dSJan Kara int dquot_commit_info(struct super_block *sb, int type) 2172884d179dSJan Kara { 2173884d179dSJan Kara struct quota_info *dqopt = sb_dqopt(sb); 2174884d179dSJan Kara 21759a8ae30eSJan Kara return dqopt->ops[type]->write_file_info(sb, type); 2176884d179dSJan Kara } 2177884d179dSJan Kara EXPORT_SYMBOL(dquot_commit_info); 2178884d179dSJan Kara 2179be6257b2SJan Kara int dquot_get_next_id(struct super_block *sb, struct kqid *qid) 2180be6257b2SJan Kara { 2181be6257b2SJan Kara struct quota_info *dqopt = sb_dqopt(sb); 2182be6257b2SJan Kara 21839d1ccbe7SJan Kara if (!sb_has_quota_active(sb, qid->type)) 21849d1ccbe7SJan Kara return -ESRCH; 21859d1ccbe7SJan Kara if (!dqopt->ops[qid->type]->get_next_id) 21869d1ccbe7SJan Kara return -ENOSYS; 2187f14618c6SJan Kara return dqopt->ops[qid->type]->get_next_id(sb, qid); 2188be6257b2SJan Kara } 2189be6257b2SJan Kara EXPORT_SYMBOL(dquot_get_next_id); 2190be6257b2SJan Kara 2191884d179dSJan Kara /* 2192884d179dSJan Kara * Definitions of diskquota operations. 2193884d179dSJan Kara */ 219461e225dcSAlexey Dobriyan const struct dquot_operations dquot_operations = { 2195884d179dSJan Kara .write_dquot = dquot_commit, 2196884d179dSJan Kara .acquire_dquot = dquot_acquire, 2197884d179dSJan Kara .release_dquot = dquot_release, 2198884d179dSJan Kara .mark_dirty = dquot_mark_dquot_dirty, 2199884d179dSJan Kara .write_info = dquot_commit_info, 2200884d179dSJan Kara .alloc_dquot = dquot_alloc, 2201884d179dSJan Kara .destroy_dquot = dquot_destroy, 2202be6257b2SJan Kara .get_next_id = dquot_get_next_id, 2203884d179dSJan Kara }; 2204123e9cafSChristoph Hellwig EXPORT_SYMBOL(dquot_operations); 2205884d179dSJan Kara 2206884d179dSJan Kara /* 2207907f4554SChristoph Hellwig * Generic helper for ->open on filesystems supporting disk quotas. 2208907f4554SChristoph Hellwig */ 2209907f4554SChristoph Hellwig int dquot_file_open(struct inode *inode, struct file *file) 2210907f4554SChristoph Hellwig { 2211907f4554SChristoph Hellwig int error; 2212907f4554SChristoph Hellwig 2213907f4554SChristoph Hellwig error = generic_file_open(inode, file); 2214907f4554SChristoph Hellwig if (!error && (file->f_mode & FMODE_WRITE)) 221588d8ff97SChao Yu error = dquot_initialize(inode); 2216907f4554SChristoph Hellwig return error; 2217907f4554SChristoph Hellwig } 2218907f4554SChristoph Hellwig EXPORT_SYMBOL(dquot_file_open); 2219907f4554SChristoph Hellwig 22202ec1f301SJan Kara static void vfs_cleanup_quota_inode(struct super_block *sb, int type) 22212ec1f301SJan Kara { 22222ec1f301SJan Kara struct quota_info *dqopt = sb_dqopt(sb); 22232ec1f301SJan Kara struct inode *inode = dqopt->files[type]; 22242ec1f301SJan Kara 22252ec1f301SJan Kara if (!inode) 22262ec1f301SJan Kara return; 22272ec1f301SJan Kara if (!(dqopt->flags & DQUOT_QUOTA_SYS_FILE)) { 22282ec1f301SJan Kara inode_lock(inode); 22292ec1f301SJan Kara inode->i_flags &= ~S_NOQUOTA; 22302ec1f301SJan Kara inode_unlock(inode); 22312ec1f301SJan Kara } 22322ec1f301SJan Kara dqopt->files[type] = NULL; 22332ec1f301SJan Kara iput(inode); 22342ec1f301SJan Kara } 22352ec1f301SJan Kara 2236907f4554SChristoph Hellwig /* 2237884d179dSJan Kara * Turn quota off on a device. type == -1 ==> quotaoff for all types (umount) 2238884d179dSJan Kara */ 22390f0dd62fSChristoph Hellwig int dquot_disable(struct super_block *sb, int type, unsigned int flags) 2240884d179dSJan Kara { 22412ec1f301SJan Kara int cnt; 2242884d179dSJan Kara struct quota_info *dqopt = sb_dqopt(sb); 2243884d179dSJan Kara 22447d6cd73dSJan Kara /* s_umount should be held in exclusive mode */ 22457d6cd73dSJan Kara if (WARN_ON_ONCE(down_read_trylock(&sb->s_umount))) 22467d6cd73dSJan Kara up_read(&sb->s_umount); 22477d6cd73dSJan Kara 2248884d179dSJan Kara /* Cannot turn off usage accounting without turning off limits, or 2249884d179dSJan Kara * suspend quotas and simultaneously turn quotas off. */ 2250884d179dSJan Kara if ((flags & DQUOT_USAGE_ENABLED && !(flags & DQUOT_LIMITS_ENABLED)) 2251884d179dSJan Kara || (flags & DQUOT_SUSPENDED && flags & (DQUOT_LIMITS_ENABLED | 2252884d179dSJan Kara DQUOT_USAGE_ENABLED))) 2253884d179dSJan Kara return -EINVAL; 2254884d179dSJan Kara 2255884d179dSJan Kara /* 2256884d179dSJan Kara * Skip everything if there's nothing to do. We have to do this because 2257884d179dSJan Kara * sometimes we are called when fill_super() failed and calling 2258884d179dSJan Kara * sync_fs() in such cases does no good. 2259884d179dSJan Kara */ 2260c3b00446SJan Kara if (!sb_any_quota_loaded(sb)) 2261884d179dSJan Kara return 0; 2262c3b00446SJan Kara 2263884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 2264884d179dSJan Kara if (type != -1 && cnt != type) 2265884d179dSJan Kara continue; 2266884d179dSJan Kara if (!sb_has_quota_loaded(sb, cnt)) 2267884d179dSJan Kara continue; 2268884d179dSJan Kara 2269884d179dSJan Kara if (flags & DQUOT_SUSPENDED) { 2270884d179dSJan Kara spin_lock(&dq_state_lock); 2271884d179dSJan Kara dqopt->flags |= 2272884d179dSJan Kara dquot_state_flag(DQUOT_SUSPENDED, cnt); 2273884d179dSJan Kara spin_unlock(&dq_state_lock); 2274884d179dSJan Kara } else { 2275884d179dSJan Kara spin_lock(&dq_state_lock); 2276884d179dSJan Kara dqopt->flags &= ~dquot_state_flag(flags, cnt); 2277884d179dSJan Kara /* Turning off suspended quotas? */ 2278884d179dSJan Kara if (!sb_has_quota_loaded(sb, cnt) && 2279884d179dSJan Kara sb_has_quota_suspended(sb, cnt)) { 2280884d179dSJan Kara dqopt->flags &= ~dquot_state_flag( 2281884d179dSJan Kara DQUOT_SUSPENDED, cnt); 2282884d179dSJan Kara spin_unlock(&dq_state_lock); 22832ec1f301SJan Kara vfs_cleanup_quota_inode(sb, cnt); 2284884d179dSJan Kara continue; 2285884d179dSJan Kara } 2286884d179dSJan Kara spin_unlock(&dq_state_lock); 2287884d179dSJan Kara } 2288884d179dSJan Kara 2289884d179dSJan Kara /* We still have to keep quota loaded? */ 2290884d179dSJan Kara if (sb_has_quota_loaded(sb, cnt) && !(flags & DQUOT_SUSPENDED)) 2291884d179dSJan Kara continue; 2292884d179dSJan Kara 2293884d179dSJan Kara /* Note: these are blocking operations */ 2294884d179dSJan Kara drop_dquot_ref(sb, cnt); 2295884d179dSJan Kara invalidate_dquots(sb, cnt); 2296884d179dSJan Kara /* 2297268157baSJan Kara * Now all dquots should be invalidated, all writes done so we 2298268157baSJan Kara * should be only users of the info. No locks needed. 2299884d179dSJan Kara */ 2300884d179dSJan Kara if (info_dirty(&dqopt->info[cnt])) 2301884d179dSJan Kara sb->dq_op->write_info(sb, cnt); 2302884d179dSJan Kara if (dqopt->ops[cnt]->free_file_info) 2303884d179dSJan Kara dqopt->ops[cnt]->free_file_info(sb, cnt); 2304884d179dSJan Kara put_quota_format(dqopt->info[cnt].dqi_format); 2305884d179dSJan Kara dqopt->info[cnt].dqi_flags = 0; 2306884d179dSJan Kara dqopt->info[cnt].dqi_igrace = 0; 2307884d179dSJan Kara dqopt->info[cnt].dqi_bgrace = 0; 2308884d179dSJan Kara dqopt->ops[cnt] = NULL; 2309884d179dSJan Kara } 2310884d179dSJan Kara 2311884d179dSJan Kara /* Skip syncing and setting flags if quota files are hidden */ 2312884d179dSJan Kara if (dqopt->flags & DQUOT_QUOTA_SYS_FILE) 2313884d179dSJan Kara goto put_inodes; 2314884d179dSJan Kara 2315884d179dSJan Kara /* Sync the superblock so that buffers with quota data are written to 2316884d179dSJan Kara * disk (and so userspace sees correct data afterwards). */ 2317884d179dSJan Kara if (sb->s_op->sync_fs) 2318884d179dSJan Kara sb->s_op->sync_fs(sb, 1); 2319884d179dSJan Kara sync_blockdev(sb->s_bdev); 2320884d179dSJan Kara /* Now the quota files are just ordinary files and we can set the 2321884d179dSJan Kara * inode flags back. Moreover we discard the pagecache so that 2322884d179dSJan Kara * userspace sees the writes we did bypassing the pagecache. We 2323884d179dSJan Kara * must also discard the blockdev buffers so that we see the 2324884d179dSJan Kara * changes done by userspace on the next quotaon() */ 2325884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) 23262ec1f301SJan Kara if (!sb_has_quota_loaded(sb, cnt) && dqopt->files[cnt]) { 23272ec1f301SJan Kara inode_lock(dqopt->files[cnt]); 23282ec1f301SJan Kara truncate_inode_pages(&dqopt->files[cnt]->i_data, 0); 23292ec1f301SJan Kara inode_unlock(dqopt->files[cnt]); 2330884d179dSJan Kara } 2331884d179dSJan Kara if (sb->s_bdev) 2332884d179dSJan Kara invalidate_bdev(sb->s_bdev); 2333884d179dSJan Kara put_inodes: 23342ec1f301SJan Kara /* We are done when suspending quotas */ 23352ec1f301SJan Kara if (flags & DQUOT_SUSPENDED) 23362ec1f301SJan Kara return 0; 23372ec1f301SJan Kara 2338884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) 23392ec1f301SJan Kara if (!sb_has_quota_loaded(sb, cnt)) 23402ec1f301SJan Kara vfs_cleanup_quota_inode(sb, cnt); 23412ec1f301SJan Kara return 0; 2342884d179dSJan Kara } 23430f0dd62fSChristoph Hellwig EXPORT_SYMBOL(dquot_disable); 2344884d179dSJan Kara 2345287a8095SChristoph Hellwig int dquot_quota_off(struct super_block *sb, int type) 2346884d179dSJan Kara { 23470f0dd62fSChristoph Hellwig return dquot_disable(sb, type, 23480f0dd62fSChristoph Hellwig DQUOT_USAGE_ENABLED | DQUOT_LIMITS_ENABLED); 2349884d179dSJan Kara } 2350287a8095SChristoph Hellwig EXPORT_SYMBOL(dquot_quota_off); 23510f0dd62fSChristoph Hellwig 2352884d179dSJan Kara /* 2353884d179dSJan Kara * Turn quotas on on a device 2354884d179dSJan Kara */ 2355884d179dSJan Kara 2356c7d3d283SJan Kara static int vfs_setup_quota_inode(struct inode *inode, int type) 2357c7d3d283SJan Kara { 2358c7d3d283SJan Kara struct super_block *sb = inode->i_sb; 2359c7d3d283SJan Kara struct quota_info *dqopt = sb_dqopt(sb); 2360c7d3d283SJan Kara 2361d3238774SBaokun Li if (is_bad_inode(inode)) 2362d3238774SBaokun Li return -EUCLEAN; 2363c7d3d283SJan Kara if (!S_ISREG(inode->i_mode)) 2364c7d3d283SJan Kara return -EACCES; 2365c7d3d283SJan Kara if (IS_RDONLY(inode)) 2366c7d3d283SJan Kara return -EROFS; 2367c7d3d283SJan Kara if (sb_has_quota_loaded(sb, type)) 2368c7d3d283SJan Kara return -EBUSY; 2369c7d3d283SJan Kara 23700b98335aSEric Biggers /* 23710b98335aSEric Biggers * Quota files should never be encrypted. They should be thought of as 23720b98335aSEric Biggers * filesystem metadata, not user data. New-style internal quota files 23730b98335aSEric Biggers * cannot be encrypted by users anyway, but old-style external quota 23740b98335aSEric Biggers * files could potentially be incorrectly created in an encrypted 23750b98335aSEric Biggers * directory, hence this explicit check. Some reasons why encrypted 23760b98335aSEric Biggers * quota files don't work include: (1) some filesystems that support 23770b98335aSEric Biggers * encryption don't handle it in their quota_read and quota_write, and 23780b98335aSEric Biggers * (2) cleaning up encrypted quota files at unmount would need special 23790b98335aSEric Biggers * consideration, as quota files are cleaned up later than user files. 23800b98335aSEric Biggers */ 23810b98335aSEric Biggers if (IS_ENCRYPTED(inode)) 23820b98335aSEric Biggers return -EINVAL; 23830b98335aSEric Biggers 2384c7d3d283SJan Kara dqopt->files[type] = igrab(inode); 2385c7d3d283SJan Kara if (!dqopt->files[type]) 2386c7d3d283SJan Kara return -EIO; 2387c7d3d283SJan Kara if (!(dqopt->flags & DQUOT_QUOTA_SYS_FILE)) { 2388c7d3d283SJan Kara /* We don't want quota and atime on quota files (deadlocks 2389c7d3d283SJan Kara * possible) Also nobody should write to the file - we use 2390c7d3d283SJan Kara * special IO operations which ignore the immutable bit. */ 2391c7d3d283SJan Kara inode_lock(inode); 2392c7d3d283SJan Kara inode->i_flags |= S_NOQUOTA; 2393c7d3d283SJan Kara inode_unlock(inode); 2394884d179dSJan Kara /* 2395c7d3d283SJan Kara * When S_NOQUOTA is set, remove dquot references as no more 2396c7d3d283SJan Kara * references can be added 2397884d179dSJan Kara */ 2398c7d3d283SJan Kara __dquot_drop(inode); 2399c7d3d283SJan Kara } 2400c7d3d283SJan Kara return 0; 2401c7d3d283SJan Kara } 2402c7d3d283SJan Kara 2403c7d3d283SJan Kara int dquot_load_quota_sb(struct super_block *sb, int type, int format_id, 2404884d179dSJan Kara unsigned int flags) 2405884d179dSJan Kara { 2406884d179dSJan Kara struct quota_format_type *fmt = find_quota_format(format_id); 2407884d179dSJan Kara struct quota_info *dqopt = sb_dqopt(sb); 2408884d179dSJan Kara int error; 2409884d179dSJan Kara 24107a64774aSChristoph Hellwig lockdep_assert_held_write(&sb->s_umount); 24117a64774aSChristoph Hellwig 2412dc19432aSJan Kara /* Just unsuspend quotas? */ 2413dc19432aSJan Kara BUG_ON(flags & DQUOT_SUSPENDED); 2414dc19432aSJan Kara 2415884d179dSJan Kara if (!fmt) 2416884d179dSJan Kara return -ESRCH; 241786be6b8bSJan Kara if (!sb->dq_op || !sb->s_qcop || 2418847aac64SLi Xi (type == PRJQUOTA && sb->dq_op->get_projid == NULL)) { 2419884d179dSJan Kara error = -EINVAL; 2420884d179dSJan Kara goto out_fmt; 2421884d179dSJan Kara } 24225c004828SEric W. Biederman /* Filesystems outside of init_user_ns not yet supported */ 24235c004828SEric W. Biederman if (sb->s_user_ns != &init_user_ns) { 24245c004828SEric W. Biederman error = -EINVAL; 24255c004828SEric W. Biederman goto out_fmt; 24265c004828SEric W. Biederman } 2427884d179dSJan Kara /* Usage always has to be set... */ 2428884d179dSJan Kara if (!(flags & DQUOT_USAGE_ENABLED)) { 2429884d179dSJan Kara error = -EINVAL; 2430884d179dSJan Kara goto out_fmt; 2431884d179dSJan Kara } 2432c3b00446SJan Kara if (sb_has_quota_loaded(sb, type)) { 2433c3b00446SJan Kara error = -EBUSY; 2434c3b00446SJan Kara goto out_fmt; 2435c3b00446SJan Kara } 2436884d179dSJan Kara 2437884d179dSJan Kara if (!(dqopt->flags & DQUOT_QUOTA_SYS_FILE)) { 2438ab94c39bSJan Kara /* As we bypass the pagecache we must now flush all the 2439ab94c39bSJan Kara * dirty data and invalidate caches so that kernel sees 2440ab94c39bSJan Kara * changes from userspace. It is not enough to just flush 2441ab94c39bSJan Kara * the quota file since if blocksize < pagesize, invalidation 2442ab94c39bSJan Kara * of the cache could fail because of other unrelated dirty 2443ab94c39bSJan Kara * data */ 2444ab94c39bSJan Kara sync_filesystem(sb); 2445884d179dSJan Kara invalidate_bdev(sb->s_bdev); 2446884d179dSJan Kara } 2447884d179dSJan Kara 2448884d179dSJan Kara error = -EINVAL; 2449884d179dSJan Kara if (!fmt->qf_ops->check_quota_file(sb, type)) 2450c7d3d283SJan Kara goto out_fmt; 2451884d179dSJan Kara 2452884d179dSJan Kara dqopt->ops[type] = fmt->qf_ops; 2453884d179dSJan Kara dqopt->info[type].dqi_format = fmt; 2454884d179dSJan Kara dqopt->info[type].dqi_fmt_id = format_id; 2455884d179dSJan Kara INIT_LIST_HEAD(&dqopt->info[type].dqi_dirty_list); 2456268157baSJan Kara error = dqopt->ops[type]->read_file_info(sb, type); 245742fdb858SJan Kara if (error < 0) 2458c7d3d283SJan Kara goto out_fmt; 245915512377SJan Kara if (dqopt->flags & DQUOT_QUOTA_SYS_FILE) { 246015512377SJan Kara spin_lock(&dq_data_lock); 246146fe44ceSJan Kara dqopt->info[type].dqi_flags |= DQF_SYS_FILE; 246215512377SJan Kara spin_unlock(&dq_data_lock); 246315512377SJan Kara } 2464884d179dSJan Kara spin_lock(&dq_state_lock); 2465884d179dSJan Kara dqopt->flags |= dquot_state_flag(flags, type); 2466884d179dSJan Kara spin_unlock(&dq_state_lock); 2467884d179dSJan Kara 24681a6152d3SChao Yu error = add_dquot_ref(sb, type); 24691a6152d3SChao Yu if (error) 24706a4e3363SJan Kara dquot_disable(sb, type, 24716a4e3363SJan Kara DQUOT_USAGE_ENABLED | DQUOT_LIMITS_ENABLED); 2472884d179dSJan Kara 24731a6152d3SChao Yu return error; 2474884d179dSJan Kara out_fmt: 2475884d179dSJan Kara put_quota_format(fmt); 2476884d179dSJan Kara 2477884d179dSJan Kara return error; 2478884d179dSJan Kara } 2479c7d3d283SJan Kara EXPORT_SYMBOL(dquot_load_quota_sb); 2480c7d3d283SJan Kara 2481c7d3d283SJan Kara /* 2482dc19432aSJan Kara * More powerful function for turning on quotas on given quota inode allowing 2483dc19432aSJan Kara * setting of individual quota flags 2484c7d3d283SJan Kara */ 2485dc19432aSJan Kara int dquot_load_quota_inode(struct inode *inode, int type, int format_id, 2486c7d3d283SJan Kara unsigned int flags) 2487c7d3d283SJan Kara { 2488c7d3d283SJan Kara int err; 2489c7d3d283SJan Kara 2490c7d3d283SJan Kara err = vfs_setup_quota_inode(inode, type); 2491c7d3d283SJan Kara if (err < 0) 2492c7d3d283SJan Kara return err; 2493c7d3d283SJan Kara err = dquot_load_quota_sb(inode->i_sb, type, format_id, flags); 2494c7d3d283SJan Kara if (err < 0) 2495c7d3d283SJan Kara vfs_cleanup_quota_inode(inode->i_sb, type); 2496c7d3d283SJan Kara return err; 2497c7d3d283SJan Kara } 2498dc19432aSJan Kara EXPORT_SYMBOL(dquot_load_quota_inode); 2499884d179dSJan Kara 2500884d179dSJan Kara /* Reenable quotas on remount RW */ 25010f0dd62fSChristoph Hellwig int dquot_resume(struct super_block *sb, int type) 2502884d179dSJan Kara { 2503884d179dSJan Kara struct quota_info *dqopt = sb_dqopt(sb); 25040f0dd62fSChristoph Hellwig int ret = 0, cnt; 2505884d179dSJan Kara unsigned int flags; 2506884d179dSJan Kara 25077d6cd73dSJan Kara /* s_umount should be held in exclusive mode */ 25087d6cd73dSJan Kara if (WARN_ON_ONCE(down_read_trylock(&sb->s_umount))) 25097d6cd73dSJan Kara up_read(&sb->s_umount); 25107d6cd73dSJan Kara 25110f0dd62fSChristoph Hellwig for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 25120f0dd62fSChristoph Hellwig if (type != -1 && cnt != type) 25130f0dd62fSChristoph Hellwig continue; 2514c3b00446SJan Kara if (!sb_has_quota_suspended(sb, cnt)) 25150f0dd62fSChristoph Hellwig continue; 2516c3b00446SJan Kara 2517884d179dSJan Kara spin_lock(&dq_state_lock); 2518884d179dSJan Kara flags = dqopt->flags & dquot_state_flag(DQUOT_USAGE_ENABLED | 25190f0dd62fSChristoph Hellwig DQUOT_LIMITS_ENABLED, 25200f0dd62fSChristoph Hellwig cnt); 25210f0dd62fSChristoph Hellwig dqopt->flags &= ~dquot_state_flag(DQUOT_STATE_FLAGS, cnt); 2522884d179dSJan Kara spin_unlock(&dq_state_lock); 2523884d179dSJan Kara 25240f0dd62fSChristoph Hellwig flags = dquot_generic_flag(flags, cnt); 2525ae45f07dSJan Kara ret = dquot_load_quota_sb(sb, cnt, dqopt->info[cnt].dqi_fmt_id, 2526ae45f07dSJan Kara flags); 2527ae45f07dSJan Kara if (ret < 0) 2528e51d68e7SAnant Thazhemadam vfs_cleanup_quota_inode(sb, cnt); 25290f0dd62fSChristoph Hellwig } 2530884d179dSJan Kara 2531884d179dSJan Kara return ret; 2532884d179dSJan Kara } 25330f0dd62fSChristoph Hellwig EXPORT_SYMBOL(dquot_resume); 2534884d179dSJan Kara 2535f00c9e44SJan Kara int dquot_quota_on(struct super_block *sb, int type, int format_id, 25368c54ca9cSAl Viro const struct path *path) 2537884d179dSJan Kara { 2538884d179dSJan Kara int error = security_quota_on(path->dentry); 2539884d179dSJan Kara if (error) 2540884d179dSJan Kara return error; 2541884d179dSJan Kara /* Quota file not on the same filesystem? */ 2542d8c9584eSAl Viro if (path->dentry->d_sb != sb) 2543884d179dSJan Kara error = -EXDEV; 2544884d179dSJan Kara else 2545dc19432aSJan Kara error = dquot_load_quota_inode(d_inode(path->dentry), type, 2546884d179dSJan Kara format_id, DQUOT_USAGE_ENABLED | 2547884d179dSJan Kara DQUOT_LIMITS_ENABLED); 2548884d179dSJan Kara return error; 2549884d179dSJan Kara } 2550287a8095SChristoph Hellwig EXPORT_SYMBOL(dquot_quota_on); 2551884d179dSJan Kara 2552884d179dSJan Kara /* 2553884d179dSJan Kara * This function is used when filesystem needs to initialize quotas 2554884d179dSJan Kara * during mount time. 2555884d179dSJan Kara */ 2556287a8095SChristoph Hellwig int dquot_quota_on_mount(struct super_block *sb, char *qf_name, 2557884d179dSJan Kara int format_id, int type) 2558884d179dSJan Kara { 2559884d179dSJan Kara struct dentry *dentry; 2560884d179dSJan Kara int error; 2561884d179dSJan Kara 25626c2d4798SAl Viro dentry = lookup_positive_unlocked(qf_name, sb->s_root, strlen(qf_name)); 2563884d179dSJan Kara if (IS_ERR(dentry)) 2564884d179dSJan Kara return PTR_ERR(dentry); 2565884d179dSJan Kara 2566884d179dSJan Kara error = security_quota_on(dentry); 2567884d179dSJan Kara if (!error) 2568dc19432aSJan Kara error = dquot_load_quota_inode(d_inode(dentry), type, format_id, 2569884d179dSJan Kara DQUOT_USAGE_ENABLED | DQUOT_LIMITS_ENABLED); 2570884d179dSJan Kara 2571884d179dSJan Kara dput(dentry); 2572884d179dSJan Kara return error; 2573884d179dSJan Kara } 2574287a8095SChristoph Hellwig EXPORT_SYMBOL(dquot_quota_on_mount); 2575884d179dSJan Kara 25763e2af67eSJan Kara static int dquot_quota_enable(struct super_block *sb, unsigned int flags) 25773e2af67eSJan Kara { 25783e2af67eSJan Kara int ret; 25793e2af67eSJan Kara int type; 25803e2af67eSJan Kara struct quota_info *dqopt = sb_dqopt(sb); 25813e2af67eSJan Kara 25823e2af67eSJan Kara if (!(dqopt->flags & DQUOT_QUOTA_SYS_FILE)) 25833e2af67eSJan Kara return -ENOSYS; 25843e2af67eSJan Kara /* Accounting cannot be turned on while fs is mounted */ 25853e2af67eSJan Kara flags &= ~(FS_QUOTA_UDQ_ACCT | FS_QUOTA_GDQ_ACCT | FS_QUOTA_PDQ_ACCT); 25863e2af67eSJan Kara if (!flags) 25873e2af67eSJan Kara return -EINVAL; 25883e2af67eSJan Kara for (type = 0; type < MAXQUOTAS; type++) { 25893e2af67eSJan Kara if (!(flags & qtype_enforce_flag(type))) 25903e2af67eSJan Kara continue; 25913e2af67eSJan Kara /* Can't enforce without accounting */ 2592069a9166SJan Kara if (!sb_has_quota_usage_enabled(sb, type)) { 2593069a9166SJan Kara ret = -EINVAL; 25943e2af67eSJan Kara goto out_err; 25953e2af67eSJan Kara } 2596069a9166SJan Kara if (sb_has_quota_limits_enabled(sb, type)) { 2597069a9166SJan Kara ret = -EBUSY; 2598069a9166SJan Kara goto out_err; 2599069a9166SJan Kara } 2600069a9166SJan Kara spin_lock(&dq_state_lock); 2601069a9166SJan Kara dqopt->flags |= dquot_state_flag(DQUOT_LIMITS_ENABLED, type); 2602069a9166SJan Kara spin_unlock(&dq_state_lock); 2603069a9166SJan Kara } 26043e2af67eSJan Kara return 0; 26053e2af67eSJan Kara out_err: 26063e2af67eSJan Kara /* Backout enforcement enablement we already did */ 26073e2af67eSJan Kara for (type--; type >= 0; type--) { 26083e2af67eSJan Kara if (flags & qtype_enforce_flag(type)) 26093e2af67eSJan Kara dquot_disable(sb, type, DQUOT_LIMITS_ENABLED); 26103e2af67eSJan Kara } 26113e2af67eSJan Kara /* Error code translation for better compatibility with XFS */ 26123e2af67eSJan Kara if (ret == -EBUSY) 26133e2af67eSJan Kara ret = -EEXIST; 26143e2af67eSJan Kara return ret; 26153e2af67eSJan Kara } 26163e2af67eSJan Kara 26173e2af67eSJan Kara static int dquot_quota_disable(struct super_block *sb, unsigned int flags) 26183e2af67eSJan Kara { 26193e2af67eSJan Kara int ret; 26203e2af67eSJan Kara int type; 26213e2af67eSJan Kara struct quota_info *dqopt = sb_dqopt(sb); 26223e2af67eSJan Kara 26233e2af67eSJan Kara if (!(dqopt->flags & DQUOT_QUOTA_SYS_FILE)) 26243e2af67eSJan Kara return -ENOSYS; 26253e2af67eSJan Kara /* 26263e2af67eSJan Kara * We don't support turning off accounting via quotactl. In principle 26273e2af67eSJan Kara * quota infrastructure can do this but filesystems don't expect 26283e2af67eSJan Kara * userspace to be able to do it. 26293e2af67eSJan Kara */ 26303e2af67eSJan Kara if (flags & 26313e2af67eSJan Kara (FS_QUOTA_UDQ_ACCT | FS_QUOTA_GDQ_ACCT | FS_QUOTA_PDQ_ACCT)) 26323e2af67eSJan Kara return -EOPNOTSUPP; 26333e2af67eSJan Kara 26343e2af67eSJan Kara /* Filter out limits not enabled */ 26353e2af67eSJan Kara for (type = 0; type < MAXQUOTAS; type++) 26363e2af67eSJan Kara if (!sb_has_quota_limits_enabled(sb, type)) 26373e2af67eSJan Kara flags &= ~qtype_enforce_flag(type); 26383e2af67eSJan Kara /* Nothing left? */ 26393e2af67eSJan Kara if (!flags) 26403e2af67eSJan Kara return -EEXIST; 26413e2af67eSJan Kara for (type = 0; type < MAXQUOTAS; type++) { 26423e2af67eSJan Kara if (flags & qtype_enforce_flag(type)) { 26433e2af67eSJan Kara ret = dquot_disable(sb, type, DQUOT_LIMITS_ENABLED); 26443e2af67eSJan Kara if (ret < 0) 26453e2af67eSJan Kara goto out_err; 26463e2af67eSJan Kara } 26473e2af67eSJan Kara } 26483e2af67eSJan Kara return 0; 26493e2af67eSJan Kara out_err: 26503e2af67eSJan Kara /* Backout enforcement disabling we already did */ 26513e2af67eSJan Kara for (type--; type >= 0; type--) { 2652069a9166SJan Kara if (flags & qtype_enforce_flag(type)) { 2653069a9166SJan Kara spin_lock(&dq_state_lock); 2654069a9166SJan Kara dqopt->flags |= 2655069a9166SJan Kara dquot_state_flag(DQUOT_LIMITS_ENABLED, type); 2656069a9166SJan Kara spin_unlock(&dq_state_lock); 2657069a9166SJan Kara } 26583e2af67eSJan Kara } 26593e2af67eSJan Kara return ret; 26603e2af67eSJan Kara } 26613e2af67eSJan Kara 2662884d179dSJan Kara /* Generic routine for getting common part of quota structure */ 266314bf61ffSJan Kara static void do_get_dqblk(struct dquot *dquot, struct qc_dqblk *di) 2664884d179dSJan Kara { 2665884d179dSJan Kara struct mem_dqblk *dm = &dquot->dq_dqb; 2666884d179dSJan Kara 2667b9b2dd36SChristoph Hellwig memset(di, 0, sizeof(*di)); 26687b9ca4c6SJan Kara spin_lock(&dquot->dq_dqb_lock); 266914bf61ffSJan Kara di->d_spc_hardlimit = dm->dqb_bhardlimit; 267014bf61ffSJan Kara di->d_spc_softlimit = dm->dqb_bsoftlimit; 2671b9b2dd36SChristoph Hellwig di->d_ino_hardlimit = dm->dqb_ihardlimit; 2672b9b2dd36SChristoph Hellwig di->d_ino_softlimit = dm->dqb_isoftlimit; 267314bf61ffSJan Kara di->d_space = dm->dqb_curspace + dm->dqb_rsvspace; 267414bf61ffSJan Kara di->d_ino_count = dm->dqb_curinodes; 267514bf61ffSJan Kara di->d_spc_timer = dm->dqb_btime; 267614bf61ffSJan Kara di->d_ino_timer = dm->dqb_itime; 26777b9ca4c6SJan Kara spin_unlock(&dquot->dq_dqb_lock); 2678884d179dSJan Kara } 2679884d179dSJan Kara 268074a8a103SEric W. Biederman int dquot_get_dqblk(struct super_block *sb, struct kqid qid, 268114bf61ffSJan Kara struct qc_dqblk *di) 2682884d179dSJan Kara { 2683884d179dSJan Kara struct dquot *dquot; 2684884d179dSJan Kara 2685aca645a6SEric W. Biederman dquot = dqget(sb, qid); 26866184fc0bSJan Kara if (IS_ERR(dquot)) 26876184fc0bSJan Kara return PTR_ERR(dquot); 2688884d179dSJan Kara do_get_dqblk(dquot, di); 2689884d179dSJan Kara dqput(dquot); 2690884d179dSJan Kara 2691884d179dSJan Kara return 0; 2692884d179dSJan Kara } 2693287a8095SChristoph Hellwig EXPORT_SYMBOL(dquot_get_dqblk); 2694884d179dSJan Kara 2695be6257b2SJan Kara int dquot_get_next_dqblk(struct super_block *sb, struct kqid *qid, 2696be6257b2SJan Kara struct qc_dqblk *di) 2697be6257b2SJan Kara { 2698be6257b2SJan Kara struct dquot *dquot; 2699be6257b2SJan Kara int err; 2700be6257b2SJan Kara 2701be6257b2SJan Kara if (!sb->dq_op->get_next_id) 2702be6257b2SJan Kara return -ENOSYS; 2703be6257b2SJan Kara err = sb->dq_op->get_next_id(sb, qid); 2704be6257b2SJan Kara if (err < 0) 2705be6257b2SJan Kara return err; 2706be6257b2SJan Kara dquot = dqget(sb, *qid); 2707be6257b2SJan Kara if (IS_ERR(dquot)) 2708be6257b2SJan Kara return PTR_ERR(dquot); 2709be6257b2SJan Kara do_get_dqblk(dquot, di); 2710be6257b2SJan Kara dqput(dquot); 2711be6257b2SJan Kara 2712be6257b2SJan Kara return 0; 2713be6257b2SJan Kara } 2714be6257b2SJan Kara EXPORT_SYMBOL(dquot_get_next_dqblk); 2715be6257b2SJan Kara 271614bf61ffSJan Kara #define VFS_QC_MASK \ 271714bf61ffSJan Kara (QC_SPACE | QC_SPC_SOFT | QC_SPC_HARD | \ 271814bf61ffSJan Kara QC_INO_COUNT | QC_INO_SOFT | QC_INO_HARD | \ 271914bf61ffSJan Kara QC_SPC_TIMER | QC_INO_TIMER) 2720c472b432SChristoph Hellwig 2721884d179dSJan Kara /* Generic routine for setting common part of quota structure */ 272214bf61ffSJan Kara static int do_set_dqblk(struct dquot *dquot, struct qc_dqblk *di) 2723884d179dSJan Kara { 2724884d179dSJan Kara struct mem_dqblk *dm = &dquot->dq_dqb; 2725884d179dSJan Kara int check_blim = 0, check_ilim = 0; 27264c376dcaSEric W. Biederman struct mem_dqinfo *dqi = &sb_dqopt(dquot->dq_sb)->info[dquot->dq_id.type]; 2727884d179dSJan Kara 272814bf61ffSJan Kara if (di->d_fieldmask & ~VFS_QC_MASK) 2729c472b432SChristoph Hellwig return -EINVAL; 2730c472b432SChristoph Hellwig 273114bf61ffSJan Kara if (((di->d_fieldmask & QC_SPC_SOFT) && 2732b10a0819SJan Kara di->d_spc_softlimit > dqi->dqi_max_spc_limit) || 273314bf61ffSJan Kara ((di->d_fieldmask & QC_SPC_HARD) && 2734b10a0819SJan Kara di->d_spc_hardlimit > dqi->dqi_max_spc_limit) || 273514bf61ffSJan Kara ((di->d_fieldmask & QC_INO_SOFT) && 2736b10a0819SJan Kara (di->d_ino_softlimit > dqi->dqi_max_ino_limit)) || 273714bf61ffSJan Kara ((di->d_fieldmask & QC_INO_HARD) && 2738b10a0819SJan Kara (di->d_ino_hardlimit > dqi->dqi_max_ino_limit))) 2739884d179dSJan Kara return -ERANGE; 2740884d179dSJan Kara 27417b9ca4c6SJan Kara spin_lock(&dquot->dq_dqb_lock); 274214bf61ffSJan Kara if (di->d_fieldmask & QC_SPACE) { 274314bf61ffSJan Kara dm->dqb_curspace = di->d_space - dm->dqb_rsvspace; 2744884d179dSJan Kara check_blim = 1; 274508261673SAndrew Perepechko set_bit(DQ_LASTSET_B + QIF_SPACE_B, &dquot->dq_flags); 2746884d179dSJan Kara } 2747c472b432SChristoph Hellwig 274814bf61ffSJan Kara if (di->d_fieldmask & QC_SPC_SOFT) 274914bf61ffSJan Kara dm->dqb_bsoftlimit = di->d_spc_softlimit; 275014bf61ffSJan Kara if (di->d_fieldmask & QC_SPC_HARD) 275114bf61ffSJan Kara dm->dqb_bhardlimit = di->d_spc_hardlimit; 275214bf61ffSJan Kara if (di->d_fieldmask & (QC_SPC_SOFT | QC_SPC_HARD)) { 2753884d179dSJan Kara check_blim = 1; 275408261673SAndrew Perepechko set_bit(DQ_LASTSET_B + QIF_BLIMITS_B, &dquot->dq_flags); 2755884d179dSJan Kara } 2756c472b432SChristoph Hellwig 275714bf61ffSJan Kara if (di->d_fieldmask & QC_INO_COUNT) { 275814bf61ffSJan Kara dm->dqb_curinodes = di->d_ino_count; 2759884d179dSJan Kara check_ilim = 1; 276008261673SAndrew Perepechko set_bit(DQ_LASTSET_B + QIF_INODES_B, &dquot->dq_flags); 2761884d179dSJan Kara } 2762c472b432SChristoph Hellwig 276314bf61ffSJan Kara if (di->d_fieldmask & QC_INO_SOFT) 2764c472b432SChristoph Hellwig dm->dqb_isoftlimit = di->d_ino_softlimit; 276514bf61ffSJan Kara if (di->d_fieldmask & QC_INO_HARD) 2766c472b432SChristoph Hellwig dm->dqb_ihardlimit = di->d_ino_hardlimit; 276714bf61ffSJan Kara if (di->d_fieldmask & (QC_INO_SOFT | QC_INO_HARD)) { 2768884d179dSJan Kara check_ilim = 1; 276908261673SAndrew Perepechko set_bit(DQ_LASTSET_B + QIF_ILIMITS_B, &dquot->dq_flags); 2770884d179dSJan Kara } 2771c472b432SChristoph Hellwig 277214bf61ffSJan Kara if (di->d_fieldmask & QC_SPC_TIMER) { 277314bf61ffSJan Kara dm->dqb_btime = di->d_spc_timer; 2774884d179dSJan Kara check_blim = 1; 277508261673SAndrew Perepechko set_bit(DQ_LASTSET_B + QIF_BTIME_B, &dquot->dq_flags); 2776884d179dSJan Kara } 2777c472b432SChristoph Hellwig 277814bf61ffSJan Kara if (di->d_fieldmask & QC_INO_TIMER) { 277914bf61ffSJan Kara dm->dqb_itime = di->d_ino_timer; 2780884d179dSJan Kara check_ilim = 1; 278108261673SAndrew Perepechko set_bit(DQ_LASTSET_B + QIF_ITIME_B, &dquot->dq_flags); 2782884d179dSJan Kara } 2783884d179dSJan Kara 2784884d179dSJan Kara if (check_blim) { 2785268157baSJan Kara if (!dm->dqb_bsoftlimit || 27864b8e1106SChengguang Xu dm->dqb_curspace + dm->dqb_rsvspace <= dm->dqb_bsoftlimit) { 2787884d179dSJan Kara dm->dqb_btime = 0; 2788884d179dSJan Kara clear_bit(DQ_BLKS_B, &dquot->dq_flags); 278914bf61ffSJan Kara } else if (!(di->d_fieldmask & QC_SPC_TIMER)) 2790268157baSJan Kara /* Set grace only if user hasn't provided his own... */ 2791e008bb61SArnd Bergmann dm->dqb_btime = ktime_get_real_seconds() + dqi->dqi_bgrace; 2792884d179dSJan Kara } 2793884d179dSJan Kara if (check_ilim) { 2794268157baSJan Kara if (!dm->dqb_isoftlimit || 27954b8e1106SChengguang Xu dm->dqb_curinodes <= dm->dqb_isoftlimit) { 2796884d179dSJan Kara dm->dqb_itime = 0; 2797884d179dSJan Kara clear_bit(DQ_INODES_B, &dquot->dq_flags); 279814bf61ffSJan Kara } else if (!(di->d_fieldmask & QC_INO_TIMER)) 2799268157baSJan Kara /* Set grace only if user hasn't provided his own... */ 2800e008bb61SArnd Bergmann dm->dqb_itime = ktime_get_real_seconds() + dqi->dqi_igrace; 2801884d179dSJan Kara } 2802268157baSJan Kara if (dm->dqb_bhardlimit || dm->dqb_bsoftlimit || dm->dqb_ihardlimit || 2803268157baSJan Kara dm->dqb_isoftlimit) 2804884d179dSJan Kara clear_bit(DQ_FAKE_B, &dquot->dq_flags); 2805884d179dSJan Kara else 2806884d179dSJan Kara set_bit(DQ_FAKE_B, &dquot->dq_flags); 28077b9ca4c6SJan Kara spin_unlock(&dquot->dq_dqb_lock); 2808884d179dSJan Kara mark_dquot_dirty(dquot); 2809884d179dSJan Kara 2810884d179dSJan Kara return 0; 2811884d179dSJan Kara } 2812884d179dSJan Kara 281374a8a103SEric W. Biederman int dquot_set_dqblk(struct super_block *sb, struct kqid qid, 281414bf61ffSJan Kara struct qc_dqblk *di) 2815884d179dSJan Kara { 2816884d179dSJan Kara struct dquot *dquot; 2817884d179dSJan Kara int rc; 2818884d179dSJan Kara 2819aca645a6SEric W. Biederman dquot = dqget(sb, qid); 28206184fc0bSJan Kara if (IS_ERR(dquot)) { 28216184fc0bSJan Kara rc = PTR_ERR(dquot); 2822884d179dSJan Kara goto out; 2823884d179dSJan Kara } 2824884d179dSJan Kara rc = do_set_dqblk(dquot, di); 2825884d179dSJan Kara dqput(dquot); 2826884d179dSJan Kara out: 2827884d179dSJan Kara return rc; 2828884d179dSJan Kara } 2829287a8095SChristoph Hellwig EXPORT_SYMBOL(dquot_set_dqblk); 2830884d179dSJan Kara 2831884d179dSJan Kara /* Generic routine for getting common part of quota file information */ 28320a240339SJan Kara int dquot_get_state(struct super_block *sb, struct qc_state *state) 2833884d179dSJan Kara { 2834884d179dSJan Kara struct mem_dqinfo *mi; 28350a240339SJan Kara struct qc_type_state *tstate; 28360a240339SJan Kara struct quota_info *dqopt = sb_dqopt(sb); 28370a240339SJan Kara int type; 2838884d179dSJan Kara 28390a240339SJan Kara memset(state, 0, sizeof(*state)); 28400a240339SJan Kara for (type = 0; type < MAXQUOTAS; type++) { 28410a240339SJan Kara if (!sb_has_quota_active(sb, type)) 28420a240339SJan Kara continue; 28430a240339SJan Kara tstate = state->s_state + type; 2844884d179dSJan Kara mi = sb_dqopt(sb)->info + type; 28450a240339SJan Kara tstate->flags = QCI_ACCT_ENABLED; 2846884d179dSJan Kara spin_lock(&dq_data_lock); 28470a240339SJan Kara if (mi->dqi_flags & DQF_SYS_FILE) 28480a240339SJan Kara tstate->flags |= QCI_SYSFILE; 28490a240339SJan Kara if (mi->dqi_flags & DQF_ROOT_SQUASH) 28500a240339SJan Kara tstate->flags |= QCI_ROOT_SQUASH; 28510a240339SJan Kara if (sb_has_quota_limits_enabled(sb, type)) 28520a240339SJan Kara tstate->flags |= QCI_LIMITS_ENFORCED; 28530a240339SJan Kara tstate->spc_timelimit = mi->dqi_bgrace; 28540a240339SJan Kara tstate->ino_timelimit = mi->dqi_igrace; 2855a0828b6cSJan Kara if (dqopt->files[type]) { 28560a240339SJan Kara tstate->ino = dqopt->files[type]->i_ino; 28570a240339SJan Kara tstate->blocks = dqopt->files[type]->i_blocks; 2858a0828b6cSJan Kara } 28590a240339SJan Kara tstate->nextents = 1; /* We don't know... */ 2860884d179dSJan Kara spin_unlock(&dq_data_lock); 28610a240339SJan Kara } 2862884d179dSJan Kara return 0; 2863884d179dSJan Kara } 28640a240339SJan Kara EXPORT_SYMBOL(dquot_get_state); 2865884d179dSJan Kara 2866884d179dSJan Kara /* Generic routine for setting common part of quota file information */ 28675eacb2acSJan Kara int dquot_set_dqinfo(struct super_block *sb, int type, struct qc_info *ii) 2868884d179dSJan Kara { 2869884d179dSJan Kara struct mem_dqinfo *mi; 2870884d179dSJan Kara 28715eacb2acSJan Kara if ((ii->i_fieldmask & QC_WARNS_MASK) || 28725eacb2acSJan Kara (ii->i_fieldmask & QC_RT_SPC_TIMER)) 28735eacb2acSJan Kara return -EINVAL; 28749d1ccbe7SJan Kara if (!sb_has_quota_active(sb, type)) 28759d1ccbe7SJan Kara return -ESRCH; 2876884d179dSJan Kara mi = sb_dqopt(sb)->info + type; 28775eacb2acSJan Kara if (ii->i_fieldmask & QC_FLAGS) { 28785eacb2acSJan Kara if ((ii->i_flags & QCI_ROOT_SQUASH && 28799d1ccbe7SJan Kara mi->dqi_format->qf_fmt_id != QFMT_VFS_OLD)) 28809d1ccbe7SJan Kara return -EINVAL; 2881ca6cb091SJan Kara } 2882884d179dSJan Kara spin_lock(&dq_data_lock); 28835eacb2acSJan Kara if (ii->i_fieldmask & QC_SPC_TIMER) 28845eacb2acSJan Kara mi->dqi_bgrace = ii->i_spc_timelimit; 28855eacb2acSJan Kara if (ii->i_fieldmask & QC_INO_TIMER) 28865eacb2acSJan Kara mi->dqi_igrace = ii->i_ino_timelimit; 28875eacb2acSJan Kara if (ii->i_fieldmask & QC_FLAGS) { 28885eacb2acSJan Kara if (ii->i_flags & QCI_ROOT_SQUASH) 28895eacb2acSJan Kara mi->dqi_flags |= DQF_ROOT_SQUASH; 28905eacb2acSJan Kara else 28915eacb2acSJan Kara mi->dqi_flags &= ~DQF_ROOT_SQUASH; 28925eacb2acSJan Kara } 2893884d179dSJan Kara spin_unlock(&dq_data_lock); 2894884d179dSJan Kara mark_info_dirty(sb, type); 2895884d179dSJan Kara /* Force write to disk */ 2896c87d175dSYangtao Li return sb->dq_op->write_info(sb, type); 2897884d179dSJan Kara } 2898287a8095SChristoph Hellwig EXPORT_SYMBOL(dquot_set_dqinfo); 2899884d179dSJan Kara 29003e2af67eSJan Kara const struct quotactl_ops dquot_quotactl_sysfile_ops = { 29013e2af67eSJan Kara .quota_enable = dquot_quota_enable, 29023e2af67eSJan Kara .quota_disable = dquot_quota_disable, 29033e2af67eSJan Kara .quota_sync = dquot_quota_sync, 29040a240339SJan Kara .get_state = dquot_get_state, 29053e2af67eSJan Kara .set_info = dquot_set_dqinfo, 29063e2af67eSJan Kara .get_dqblk = dquot_get_dqblk, 2907be6257b2SJan Kara .get_nextdqblk = dquot_get_next_dqblk, 29083e2af67eSJan Kara .set_dqblk = dquot_set_dqblk 29093e2af67eSJan Kara }; 29103e2af67eSJan Kara EXPORT_SYMBOL(dquot_quotactl_sysfile_ops); 29113e2af67eSJan Kara 2912dde95888SDmitry Monakhov static int do_proc_dqstats(struct ctl_table *table, int write, 291332927393SChristoph Hellwig void *buffer, size_t *lenp, loff_t *ppos) 2914dde95888SDmitry Monakhov { 29156fcbcec9SKonstantin Khlebnikov unsigned int type = (unsigned long *)table->data - dqstats.stat; 29166fcbcec9SKonstantin Khlebnikov s64 value = percpu_counter_sum(&dqstats.counter[type]); 29176fcbcec9SKonstantin Khlebnikov 29186fcbcec9SKonstantin Khlebnikov /* Filter negative values for non-monotonic counters */ 29196fcbcec9SKonstantin Khlebnikov if (value < 0 && (type == DQST_ALLOC_DQUOTS || 29206fcbcec9SKonstantin Khlebnikov type == DQST_FREE_DQUOTS)) 29216fcbcec9SKonstantin Khlebnikov value = 0; 2922f32764bdSDmitry Monakhov 2923f32764bdSDmitry Monakhov /* Update global table */ 29246fcbcec9SKonstantin Khlebnikov dqstats.stat[type] = value; 29256fcbcec9SKonstantin Khlebnikov return proc_doulongvec_minmax(table, write, buffer, lenp, ppos); 2926dde95888SDmitry Monakhov } 2927dde95888SDmitry Monakhov 2928e628753bSJoe Perches static struct ctl_table fs_dqstats_table[] = { 2929884d179dSJan Kara { 2930884d179dSJan Kara .procname = "lookups", 2931dde95888SDmitry Monakhov .data = &dqstats.stat[DQST_LOOKUPS], 29326fcbcec9SKonstantin Khlebnikov .maxlen = sizeof(unsigned long), 2933884d179dSJan Kara .mode = 0444, 2934dde95888SDmitry Monakhov .proc_handler = do_proc_dqstats, 2935884d179dSJan Kara }, 2936884d179dSJan Kara { 2937884d179dSJan Kara .procname = "drops", 2938dde95888SDmitry Monakhov .data = &dqstats.stat[DQST_DROPS], 29396fcbcec9SKonstantin Khlebnikov .maxlen = sizeof(unsigned long), 2940884d179dSJan Kara .mode = 0444, 2941dde95888SDmitry Monakhov .proc_handler = do_proc_dqstats, 2942884d179dSJan Kara }, 2943884d179dSJan Kara { 2944884d179dSJan Kara .procname = "reads", 2945dde95888SDmitry Monakhov .data = &dqstats.stat[DQST_READS], 29466fcbcec9SKonstantin Khlebnikov .maxlen = sizeof(unsigned long), 2947884d179dSJan Kara .mode = 0444, 2948dde95888SDmitry Monakhov .proc_handler = do_proc_dqstats, 2949884d179dSJan Kara }, 2950884d179dSJan Kara { 2951884d179dSJan Kara .procname = "writes", 2952dde95888SDmitry Monakhov .data = &dqstats.stat[DQST_WRITES], 29536fcbcec9SKonstantin Khlebnikov .maxlen = sizeof(unsigned long), 2954884d179dSJan Kara .mode = 0444, 2955dde95888SDmitry Monakhov .proc_handler = do_proc_dqstats, 2956884d179dSJan Kara }, 2957884d179dSJan Kara { 2958884d179dSJan Kara .procname = "cache_hits", 2959dde95888SDmitry Monakhov .data = &dqstats.stat[DQST_CACHE_HITS], 29606fcbcec9SKonstantin Khlebnikov .maxlen = sizeof(unsigned long), 2961884d179dSJan Kara .mode = 0444, 2962dde95888SDmitry Monakhov .proc_handler = do_proc_dqstats, 2963884d179dSJan Kara }, 2964884d179dSJan Kara { 2965884d179dSJan Kara .procname = "allocated_dquots", 2966dde95888SDmitry Monakhov .data = &dqstats.stat[DQST_ALLOC_DQUOTS], 29676fcbcec9SKonstantin Khlebnikov .maxlen = sizeof(unsigned long), 2968884d179dSJan Kara .mode = 0444, 2969dde95888SDmitry Monakhov .proc_handler = do_proc_dqstats, 2970884d179dSJan Kara }, 2971884d179dSJan Kara { 2972884d179dSJan Kara .procname = "free_dquots", 2973dde95888SDmitry Monakhov .data = &dqstats.stat[DQST_FREE_DQUOTS], 29746fcbcec9SKonstantin Khlebnikov .maxlen = sizeof(unsigned long), 2975884d179dSJan Kara .mode = 0444, 2976dde95888SDmitry Monakhov .proc_handler = do_proc_dqstats, 2977884d179dSJan Kara }, 2978884d179dSJan Kara { 2979884d179dSJan Kara .procname = "syncs", 2980dde95888SDmitry Monakhov .data = &dqstats.stat[DQST_SYNCS], 29816fcbcec9SKonstantin Khlebnikov .maxlen = sizeof(unsigned long), 2982884d179dSJan Kara .mode = 0444, 2983dde95888SDmitry Monakhov .proc_handler = do_proc_dqstats, 2984884d179dSJan Kara }, 2985884d179dSJan Kara #ifdef CONFIG_PRINT_QUOTA_WARNING 2986884d179dSJan Kara { 2987884d179dSJan Kara .procname = "warnings", 2988884d179dSJan Kara .data = &flag_print_warnings, 2989884d179dSJan Kara .maxlen = sizeof(int), 2990884d179dSJan Kara .mode = 0644, 29916d456111SEric W. Biederman .proc_handler = proc_dointvec, 2992884d179dSJan Kara }, 2993884d179dSJan Kara #endif 2994ab09203eSEric W. Biederman { }, 2995884d179dSJan Kara }; 2996884d179dSJan Kara 2997884d179dSJan Kara static int __init dquot_init(void) 2998884d179dSJan Kara { 2999f32764bdSDmitry Monakhov int i, ret; 3000884d179dSJan Kara unsigned long nr_hash, order; 3001884d179dSJan Kara 3002884d179dSJan Kara printk(KERN_NOTICE "VFS: Disk quotas %s\n", __DQUOT_VERSION__); 3003884d179dSJan Kara 30049e1fb91bSJan Kara register_sysctl_init("fs/quota", fs_dqstats_table); 3005884d179dSJan Kara 3006884d179dSJan Kara dquot_cachep = kmem_cache_create("dquot", 3007884d179dSJan Kara sizeof(struct dquot), sizeof(unsigned long) * 4, 3008884d179dSJan Kara (SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT| 3009884d179dSJan Kara SLAB_MEM_SPREAD|SLAB_PANIC), 3010884d179dSJan Kara NULL); 3011884d179dSJan Kara 3012884d179dSJan Kara order = 0; 30131aa3b3e0SJia-Ju Bai dquot_hash = (struct hlist_head *)__get_free_pages(GFP_KERNEL, order); 3014884d179dSJan Kara if (!dquot_hash) 3015884d179dSJan Kara panic("Cannot create dquot hash table"); 3016884d179dSJan Kara 3017f32764bdSDmitry Monakhov for (i = 0; i < _DQST_DQSTAT_LAST; i++) { 3018908c7f19STejun Heo ret = percpu_counter_init(&dqstats.counter[i], 0, GFP_KERNEL); 3019f32764bdSDmitry Monakhov if (ret) 3020f32764bdSDmitry Monakhov panic("Cannot create dquot stat counters"); 3021f32764bdSDmitry Monakhov } 3022dde95888SDmitry Monakhov 3023884d179dSJan Kara /* Find power-of-two hlist_heads which can fit into allocation */ 3024884d179dSJan Kara nr_hash = (1UL << order) * PAGE_SIZE / sizeof(struct hlist_head); 302524fc755fSChengguang Xu dq_hash_bits = ilog2(nr_hash); 3026884d179dSJan Kara 3027884d179dSJan Kara nr_hash = 1UL << dq_hash_bits; 3028884d179dSJan Kara dq_hash_mask = nr_hash - 1; 3029884d179dSJan Kara for (i = 0; i < nr_hash; i++) 3030884d179dSJan Kara INIT_HLIST_HEAD(dquot_hash + i); 3031884d179dSJan Kara 303219858e7bSAnton Blanchard pr_info("VFS: Dquot-cache hash table entries: %ld (order %ld," 303319858e7bSAnton Blanchard " %ld bytes)\n", nr_hash, order, (PAGE_SIZE << order)); 3034884d179dSJan Kara 3035e33c267aSRoman Gushchin if (register_shrinker(&dqcache_shrinker, "dquota-cache")) 303688bc0edeSTetsuo Handa panic("Cannot register dquot shrinker"); 3037884d179dSJan Kara 3038884d179dSJan Kara return 0; 3039884d179dSJan Kara } 3040331221faSPaul Gortmaker fs_initcall(dquot_init); 3041