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: 228f44840adSChengguang Xu * The quota code uses four lists for dquot management: the inuse_list, 229f44840adSChengguang Xu * free_dquots, dqi_dirty_list, and dquot_hash[] array. A single dquot 230f44840adSChengguang Xu * structure may be on some of those lists, depending on its current state. 231884d179dSJan Kara * 232884d179dSJan Kara * All dquots are placed to the end of inuse_list when first created, and this 233884d179dSJan Kara * list is used for invalidate operation, which must look at every dquot. 234884d179dSJan Kara * 235884d179dSJan Kara * Unused dquots (dq_count == 0) are added to the free_dquots list when freed, 236884d179dSJan Kara * and this list is searched whenever we need an available dquot. Dquots are 237884d179dSJan Kara * removed from the list as soon as they are used again, and 238884d179dSJan Kara * dqstats.free_dquots gives the number of dquots on the list. When 239884d179dSJan Kara * dquot is invalidated it's completely released from memory. 240884d179dSJan Kara * 241f44840adSChengguang Xu * Dirty dquots are added to the dqi_dirty_list of quota_info when mark 242f44840adSChengguang Xu * dirtied, and this list is searched when writing dirty dquots back to 243f44840adSChengguang Xu * quota file. Note that some filesystems do dirty dquot tracking on their 244f44840adSChengguang Xu * own (e.g. in a journal) and thus don't use dqi_dirty_list. 245f44840adSChengguang Xu * 246884d179dSJan Kara * Dquots with a specific identity (device, type and id) are placed on 247884d179dSJan Kara * one of the dquot_hash[] hash chains. The provides an efficient search 248884d179dSJan Kara * mechanism to locate a specific dquot. 249884d179dSJan Kara */ 250884d179dSJan Kara 251884d179dSJan Kara static LIST_HEAD(inuse_list); 252884d179dSJan Kara static LIST_HEAD(free_dquots); 253884d179dSJan Kara static unsigned int dq_hash_bits, dq_hash_mask; 254884d179dSJan Kara static struct hlist_head *dquot_hash; 255884d179dSJan Kara 256884d179dSJan Kara struct dqstats dqstats; 257884d179dSJan Kara EXPORT_SYMBOL(dqstats); 258884d179dSJan Kara 2590a5a9c72SJan Kara static qsize_t inode_get_rsv_space(struct inode *inode); 2607b9ca4c6SJan Kara static qsize_t __inode_get_rsv_space(struct inode *inode); 2616184fc0bSJan Kara static int __dquot_initialize(struct inode *inode, int type); 2620a5a9c72SJan Kara 263884d179dSJan Kara static inline unsigned int 2641a06d420SEric W. Biederman hashfn(const struct super_block *sb, struct kqid qid) 265884d179dSJan Kara { 2661a06d420SEric W. Biederman unsigned int id = from_kqid(&init_user_ns, qid); 2671a06d420SEric W. Biederman int type = qid.type; 268884d179dSJan Kara unsigned long tmp; 269884d179dSJan Kara 270884d179dSJan Kara tmp = (((unsigned long)sb>>L1_CACHE_SHIFT) ^ id) * (MAXQUOTAS - type); 271884d179dSJan Kara return (tmp + (tmp >> dq_hash_bits)) & dq_hash_mask; 272884d179dSJan Kara } 273884d179dSJan Kara 274884d179dSJan Kara /* 275884d179dSJan Kara * Following list functions expect dq_list_lock to be held 276884d179dSJan Kara */ 277884d179dSJan Kara static inline void insert_dquot_hash(struct dquot *dquot) 278884d179dSJan Kara { 279268157baSJan Kara struct hlist_head *head; 2801a06d420SEric W. Biederman head = dquot_hash + hashfn(dquot->dq_sb, dquot->dq_id); 281884d179dSJan Kara hlist_add_head(&dquot->dq_hash, head); 282884d179dSJan Kara } 283884d179dSJan Kara 284884d179dSJan Kara static inline void remove_dquot_hash(struct dquot *dquot) 285884d179dSJan Kara { 286884d179dSJan Kara hlist_del_init(&dquot->dq_hash); 287884d179dSJan Kara } 288884d179dSJan Kara 2897a2435d8SJan Kara static struct dquot *find_dquot(unsigned int hashent, struct super_block *sb, 2901a06d420SEric W. Biederman struct kqid qid) 291884d179dSJan Kara { 292884d179dSJan Kara struct dquot *dquot; 293884d179dSJan Kara 2948c721cb0SChristophe JAILLET hlist_for_each_entry(dquot, dquot_hash+hashent, dq_hash) 2954c376dcaSEric W. Biederman if (dquot->dq_sb == sb && qid_eq(dquot->dq_id, qid)) 296884d179dSJan Kara return dquot; 2978c721cb0SChristophe JAILLET 298dd6f3c6dSJan Kara return NULL; 299884d179dSJan Kara } 300884d179dSJan Kara 301884d179dSJan Kara /* Add a dquot to the tail of the free list */ 302884d179dSJan Kara static inline void put_dquot_last(struct dquot *dquot) 303884d179dSJan Kara { 304884d179dSJan Kara list_add_tail(&dquot->dq_free, &free_dquots); 305dde95888SDmitry Monakhov dqstats_inc(DQST_FREE_DQUOTS); 306884d179dSJan Kara } 307884d179dSJan Kara 308884d179dSJan Kara static inline void remove_free_dquot(struct dquot *dquot) 309884d179dSJan Kara { 310884d179dSJan Kara if (list_empty(&dquot->dq_free)) 311884d179dSJan Kara return; 312884d179dSJan Kara list_del_init(&dquot->dq_free); 313dde95888SDmitry Monakhov dqstats_dec(DQST_FREE_DQUOTS); 314884d179dSJan Kara } 315884d179dSJan Kara 316884d179dSJan Kara static inline void put_inuse(struct dquot *dquot) 317884d179dSJan Kara { 318884d179dSJan Kara /* We add to the back of inuse list so we don't have to restart 319884d179dSJan Kara * when traversing this list and we block */ 320884d179dSJan Kara list_add_tail(&dquot->dq_inuse, &inuse_list); 321dde95888SDmitry Monakhov dqstats_inc(DQST_ALLOC_DQUOTS); 322884d179dSJan Kara } 323884d179dSJan Kara 324884d179dSJan Kara static inline void remove_inuse(struct dquot *dquot) 325884d179dSJan Kara { 326dde95888SDmitry Monakhov dqstats_dec(DQST_ALLOC_DQUOTS); 327884d179dSJan Kara list_del(&dquot->dq_inuse); 328884d179dSJan Kara } 329884d179dSJan Kara /* 330884d179dSJan Kara * End of list functions needing dq_list_lock 331884d179dSJan Kara */ 332884d179dSJan Kara 333884d179dSJan Kara static void wait_on_dquot(struct dquot *dquot) 334884d179dSJan Kara { 335884d179dSJan Kara mutex_lock(&dquot->dq_lock); 336884d179dSJan Kara mutex_unlock(&dquot->dq_lock); 337884d179dSJan Kara } 338884d179dSJan Kara 339884d179dSJan Kara static inline int dquot_dirty(struct dquot *dquot) 340884d179dSJan Kara { 341884d179dSJan Kara return test_bit(DQ_MOD_B, &dquot->dq_flags); 342884d179dSJan Kara } 343884d179dSJan Kara 344884d179dSJan Kara static inline int mark_dquot_dirty(struct dquot *dquot) 345884d179dSJan Kara { 346884d179dSJan Kara return dquot->dq_sb->dq_op->mark_dirty(dquot); 347884d179dSJan Kara } 348884d179dSJan Kara 349eabf290dSDmitry Monakhov /* Mark dquot dirty in atomic manner, and return it's old dirty flag state */ 350884d179dSJan Kara int dquot_mark_dquot_dirty(struct dquot *dquot) 351884d179dSJan Kara { 352eabf290dSDmitry Monakhov int ret = 1; 353eabf290dSDmitry Monakhov 3544580b30eSJan Kara if (!test_bit(DQ_ACTIVE_B, &dquot->dq_flags)) 3554580b30eSJan Kara return 0; 3564580b30eSJan Kara 357834057bfSJan Kara if (sb_dqopt(dquot->dq_sb)->flags & DQUOT_NOLIST_DIRTY) 358834057bfSJan Kara return test_and_set_bit(DQ_MOD_B, &dquot->dq_flags); 359834057bfSJan Kara 360eabf290dSDmitry Monakhov /* If quota is dirty already, we don't have to acquire dq_list_lock */ 361eabf290dSDmitry Monakhov if (test_bit(DQ_MOD_B, &dquot->dq_flags)) 362eabf290dSDmitry Monakhov return 1; 363eabf290dSDmitry Monakhov 364884d179dSJan Kara spin_lock(&dq_list_lock); 365eabf290dSDmitry Monakhov if (!test_and_set_bit(DQ_MOD_B, &dquot->dq_flags)) { 366884d179dSJan Kara list_add(&dquot->dq_dirty, &sb_dqopt(dquot->dq_sb)-> 3674c376dcaSEric W. Biederman info[dquot->dq_id.type].dqi_dirty_list); 368eabf290dSDmitry Monakhov ret = 0; 369eabf290dSDmitry Monakhov } 370884d179dSJan Kara spin_unlock(&dq_list_lock); 371eabf290dSDmitry Monakhov return ret; 372884d179dSJan Kara } 373884d179dSJan Kara EXPORT_SYMBOL(dquot_mark_dquot_dirty); 374884d179dSJan Kara 375dc52dd3aSDmitry Monakhov /* Dirtify all the dquots - this can block when journalling */ 376dc52dd3aSDmitry Monakhov static inline int mark_all_dquot_dirty(struct dquot * const *dquot) 377dc52dd3aSDmitry Monakhov { 378dc52dd3aSDmitry Monakhov int ret, err, cnt; 379dc52dd3aSDmitry Monakhov 380dc52dd3aSDmitry Monakhov ret = err = 0; 381dc52dd3aSDmitry Monakhov for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 382dc52dd3aSDmitry Monakhov if (dquot[cnt]) 383dc52dd3aSDmitry Monakhov /* Even in case of error we have to continue */ 384dc52dd3aSDmitry Monakhov ret = mark_dquot_dirty(dquot[cnt]); 385dc52dd3aSDmitry Monakhov if (!err) 386dc52dd3aSDmitry Monakhov err = ret; 387dc52dd3aSDmitry Monakhov } 388dc52dd3aSDmitry Monakhov return err; 389dc52dd3aSDmitry Monakhov } 390dc52dd3aSDmitry Monakhov 391dc52dd3aSDmitry Monakhov static inline void dqput_all(struct dquot **dquot) 392dc52dd3aSDmitry Monakhov { 393dc52dd3aSDmitry Monakhov unsigned int cnt; 394dc52dd3aSDmitry Monakhov 395dc52dd3aSDmitry Monakhov for (cnt = 0; cnt < MAXQUOTAS; cnt++) 396dc52dd3aSDmitry Monakhov dqput(dquot[cnt]); 397dc52dd3aSDmitry Monakhov } 398dc52dd3aSDmitry Monakhov 399884d179dSJan Kara static inline int clear_dquot_dirty(struct dquot *dquot) 400884d179dSJan Kara { 401834057bfSJan Kara if (sb_dqopt(dquot->dq_sb)->flags & DQUOT_NOLIST_DIRTY) 402834057bfSJan Kara return test_and_clear_bit(DQ_MOD_B, &dquot->dq_flags); 403834057bfSJan Kara 4041e0b7cb0SJan Kara spin_lock(&dq_list_lock); 4051e0b7cb0SJan Kara if (!test_and_clear_bit(DQ_MOD_B, &dquot->dq_flags)) { 4061e0b7cb0SJan Kara spin_unlock(&dq_list_lock); 407884d179dSJan Kara return 0; 4081e0b7cb0SJan Kara } 409884d179dSJan Kara list_del_init(&dquot->dq_dirty); 4101e0b7cb0SJan Kara spin_unlock(&dq_list_lock); 411884d179dSJan Kara return 1; 412884d179dSJan Kara } 413884d179dSJan Kara 414884d179dSJan Kara void mark_info_dirty(struct super_block *sb, int type) 415884d179dSJan Kara { 41615512377SJan Kara spin_lock(&dq_data_lock); 41715512377SJan Kara sb_dqopt(sb)->info[type].dqi_flags |= DQF_INFO_DIRTY; 41815512377SJan Kara spin_unlock(&dq_data_lock); 419884d179dSJan Kara } 420884d179dSJan Kara EXPORT_SYMBOL(mark_info_dirty); 421884d179dSJan Kara 422884d179dSJan Kara /* 423884d179dSJan Kara * Read dquot from disk and alloc space for it 424884d179dSJan Kara */ 425884d179dSJan Kara 426884d179dSJan Kara int dquot_acquire(struct dquot *dquot) 427884d179dSJan Kara { 428884d179dSJan Kara int ret = 0, ret2 = 0; 429537e11cdSMatthew Wilcox (Oracle) unsigned int memalloc; 430884d179dSJan Kara struct quota_info *dqopt = sb_dqopt(dquot->dq_sb); 431884d179dSJan Kara 432884d179dSJan Kara mutex_lock(&dquot->dq_lock); 433537e11cdSMatthew Wilcox (Oracle) memalloc = memalloc_nofs_save(); 4343ef177ecSChengguang Xu if (!test_bit(DQ_READ_B, &dquot->dq_flags)) { 4354c376dcaSEric W. Biederman ret = dqopt->ops[dquot->dq_id.type]->read_dqblk(dquot); 436884d179dSJan Kara if (ret < 0) 437884d179dSJan Kara goto out_iolock; 4383ef177ecSChengguang Xu } 439044c9b67SJan Kara /* Make sure flags update is visible after dquot has been filled */ 440044c9b67SJan Kara smp_mb__before_atomic(); 441884d179dSJan Kara set_bit(DQ_READ_B, &dquot->dq_flags); 442884d179dSJan Kara /* Instantiate dquot if needed */ 443884d179dSJan Kara if (!test_bit(DQ_ACTIVE_B, &dquot->dq_flags) && !dquot->dq_off) { 4444c376dcaSEric W. Biederman ret = dqopt->ops[dquot->dq_id.type]->commit_dqblk(dquot); 445884d179dSJan Kara /* Write the info if needed */ 4464c376dcaSEric W. Biederman if (info_dirty(&dqopt->info[dquot->dq_id.type])) { 4474c376dcaSEric W. Biederman ret2 = dqopt->ops[dquot->dq_id.type]->write_file_info( 4484c376dcaSEric W. Biederman dquot->dq_sb, dquot->dq_id.type); 449268157baSJan Kara } 450884d179dSJan Kara if (ret < 0) 451884d179dSJan Kara goto out_iolock; 452884d179dSJan Kara if (ret2 < 0) { 453884d179dSJan Kara ret = ret2; 454884d179dSJan Kara goto out_iolock; 455884d179dSJan Kara } 456884d179dSJan Kara } 457044c9b67SJan Kara /* 458044c9b67SJan Kara * Make sure flags update is visible after on-disk struct has been 459044c9b67SJan Kara * allocated. Paired with smp_rmb() in dqget(). 460044c9b67SJan Kara */ 461044c9b67SJan Kara smp_mb__before_atomic(); 462884d179dSJan Kara set_bit(DQ_ACTIVE_B, &dquot->dq_flags); 463884d179dSJan Kara out_iolock: 464537e11cdSMatthew Wilcox (Oracle) memalloc_nofs_restore(memalloc); 465884d179dSJan Kara mutex_unlock(&dquot->dq_lock); 466884d179dSJan Kara return ret; 467884d179dSJan Kara } 468884d179dSJan Kara EXPORT_SYMBOL(dquot_acquire); 469884d179dSJan Kara 470884d179dSJan Kara /* 471884d179dSJan Kara * Write dquot to disk 472884d179dSJan Kara */ 473884d179dSJan Kara int dquot_commit(struct dquot *dquot) 474884d179dSJan Kara { 475b03f2456SJan Kara int ret = 0; 476537e11cdSMatthew Wilcox (Oracle) unsigned int memalloc; 477884d179dSJan Kara struct quota_info *dqopt = sb_dqopt(dquot->dq_sb); 478884d179dSJan Kara 4795e8cb9b6SJan Kara mutex_lock(&dquot->dq_lock); 480537e11cdSMatthew Wilcox (Oracle) memalloc = memalloc_nofs_save(); 4811e0b7cb0SJan Kara if (!clear_dquot_dirty(dquot)) 4825e8cb9b6SJan Kara goto out_lock; 483884d179dSJan Kara /* Inactive dquot can be only if there was error during read/init 484884d179dSJan Kara * => we have better not writing it */ 485b03f2456SJan Kara if (test_bit(DQ_ACTIVE_B, &dquot->dq_flags)) 4864c376dcaSEric W. Biederman ret = dqopt->ops[dquot->dq_id.type]->commit_dqblk(dquot); 487b03f2456SJan Kara else 488b03f2456SJan Kara ret = -EIO; 4895e8cb9b6SJan Kara out_lock: 490537e11cdSMatthew Wilcox (Oracle) memalloc_nofs_restore(memalloc); 4915e8cb9b6SJan Kara mutex_unlock(&dquot->dq_lock); 492884d179dSJan Kara return ret; 493884d179dSJan Kara } 494884d179dSJan Kara EXPORT_SYMBOL(dquot_commit); 495884d179dSJan Kara 496884d179dSJan Kara /* 497884d179dSJan Kara * Release dquot 498884d179dSJan Kara */ 499884d179dSJan Kara int dquot_release(struct dquot *dquot) 500884d179dSJan Kara { 501884d179dSJan Kara int ret = 0, ret2 = 0; 502537e11cdSMatthew Wilcox (Oracle) unsigned int memalloc; 503884d179dSJan Kara struct quota_info *dqopt = sb_dqopt(dquot->dq_sb); 504884d179dSJan Kara 505884d179dSJan Kara mutex_lock(&dquot->dq_lock); 506537e11cdSMatthew Wilcox (Oracle) memalloc = memalloc_nofs_save(); 507884d179dSJan Kara /* Check whether we are not racing with some other dqget() */ 508df4bb5d1SDmitry Monakhov if (dquot_is_busy(dquot)) 509884d179dSJan Kara goto out_dqlock; 5104c376dcaSEric W. Biederman if (dqopt->ops[dquot->dq_id.type]->release_dqblk) { 5114c376dcaSEric W. Biederman ret = dqopt->ops[dquot->dq_id.type]->release_dqblk(dquot); 512884d179dSJan Kara /* Write the info */ 5134c376dcaSEric W. Biederman if (info_dirty(&dqopt->info[dquot->dq_id.type])) { 5144c376dcaSEric W. Biederman ret2 = dqopt->ops[dquot->dq_id.type]->write_file_info( 5154c376dcaSEric W. Biederman dquot->dq_sb, dquot->dq_id.type); 516268157baSJan Kara } 517884d179dSJan Kara if (ret >= 0) 518884d179dSJan Kara ret = ret2; 519884d179dSJan Kara } 520884d179dSJan Kara clear_bit(DQ_ACTIVE_B, &dquot->dq_flags); 521884d179dSJan Kara out_dqlock: 522537e11cdSMatthew Wilcox (Oracle) memalloc_nofs_restore(memalloc); 523884d179dSJan Kara mutex_unlock(&dquot->dq_lock); 524884d179dSJan Kara return ret; 525884d179dSJan Kara } 526884d179dSJan Kara EXPORT_SYMBOL(dquot_release); 527884d179dSJan Kara 528884d179dSJan Kara void dquot_destroy(struct dquot *dquot) 529884d179dSJan Kara { 530884d179dSJan Kara kmem_cache_free(dquot_cachep, dquot); 531884d179dSJan Kara } 532884d179dSJan Kara EXPORT_SYMBOL(dquot_destroy); 533884d179dSJan Kara 534884d179dSJan Kara static inline void do_destroy_dquot(struct dquot *dquot) 535884d179dSJan Kara { 536884d179dSJan Kara dquot->dq_sb->dq_op->destroy_dquot(dquot); 537884d179dSJan Kara } 538884d179dSJan Kara 539884d179dSJan Kara /* Invalidate all dquots on the list. Note that this function is called after 540884d179dSJan Kara * quota is disabled and pointers from inodes removed so there cannot be new 541884d179dSJan Kara * quota users. There can still be some users of quotas due to inodes being 542884d179dSJan Kara * just deleted or pruned by prune_icache() (those are not attached to any 543884d179dSJan Kara * list) or parallel quotactl call. We have to wait for such users. 544884d179dSJan Kara */ 545884d179dSJan Kara static void invalidate_dquots(struct super_block *sb, int type) 546884d179dSJan Kara { 547884d179dSJan Kara struct dquot *dquot, *tmp; 548884d179dSJan Kara 549884d179dSJan Kara restart: 550884d179dSJan Kara spin_lock(&dq_list_lock); 551884d179dSJan Kara list_for_each_entry_safe(dquot, tmp, &inuse_list, dq_inuse) { 552884d179dSJan Kara if (dquot->dq_sb != sb) 553884d179dSJan Kara continue; 5544c376dcaSEric W. Biederman if (dquot->dq_id.type != type) 555884d179dSJan Kara continue; 556884d179dSJan Kara /* Wait for dquot users */ 557884d179dSJan Kara if (atomic_read(&dquot->dq_count)) { 5589f985cb6SJan Kara dqgrab(dquot); 559884d179dSJan Kara spin_unlock(&dq_list_lock); 560503330f3SJan Kara /* 561503330f3SJan Kara * Once dqput() wakes us up, we know it's time to free 562884d179dSJan Kara * the dquot. 563884d179dSJan Kara * IMPORTANT: we rely on the fact that there is always 564884d179dSJan Kara * at most one process waiting for dquot to free. 565884d179dSJan Kara * Otherwise dq_count would be > 1 and we would never 566884d179dSJan Kara * wake up. 567884d179dSJan Kara */ 568503330f3SJan Kara wait_event(dquot_ref_wq, 569503330f3SJan Kara atomic_read(&dquot->dq_count) == 1); 570884d179dSJan Kara dqput(dquot); 571884d179dSJan Kara /* At this moment dquot() need not exist (it could be 572884d179dSJan Kara * reclaimed by prune_dqcache(). Hence we must 573884d179dSJan Kara * restart. */ 574884d179dSJan Kara goto restart; 575884d179dSJan Kara } 576884d179dSJan Kara /* 577884d179dSJan Kara * Quota now has no users and it has been written on last 578884d179dSJan Kara * dqput() 579884d179dSJan Kara */ 580884d179dSJan Kara remove_dquot_hash(dquot); 581884d179dSJan Kara remove_free_dquot(dquot); 582884d179dSJan Kara remove_inuse(dquot); 583884d179dSJan Kara do_destroy_dquot(dquot); 584884d179dSJan Kara } 585884d179dSJan Kara spin_unlock(&dq_list_lock); 586884d179dSJan Kara } 587884d179dSJan Kara 588884d179dSJan Kara /* Call callback for every active dquot on given filesystem */ 589884d179dSJan Kara int dquot_scan_active(struct super_block *sb, 590884d179dSJan Kara int (*fn)(struct dquot *dquot, unsigned long priv), 591884d179dSJan Kara unsigned long priv) 592884d179dSJan Kara { 593884d179dSJan Kara struct dquot *dquot, *old_dquot = NULL; 594884d179dSJan Kara int ret = 0; 595884d179dSJan Kara 596ee1ac541SJan Kara WARN_ON_ONCE(!rwsem_is_locked(&sb->s_umount)); 597ee1ac541SJan Kara 598884d179dSJan Kara spin_lock(&dq_list_lock); 599884d179dSJan Kara list_for_each_entry(dquot, &inuse_list, dq_inuse) { 600884d179dSJan Kara if (!test_bit(DQ_ACTIVE_B, &dquot->dq_flags)) 601884d179dSJan Kara continue; 602884d179dSJan Kara if (dquot->dq_sb != sb) 603884d179dSJan Kara continue; 604884d179dSJan Kara /* Now we have active dquot so we can just increase use count */ 605884d179dSJan Kara atomic_inc(&dquot->dq_count); 606884d179dSJan Kara spin_unlock(&dq_list_lock); 607884d179dSJan Kara dqput(old_dquot); 608884d179dSJan Kara old_dquot = dquot; 6091362f4eaSJan Kara /* 6101362f4eaSJan Kara * ->release_dquot() can be racing with us. Our reference 6111362f4eaSJan Kara * protects us from new calls to it so just wait for any 6121362f4eaSJan Kara * outstanding call and recheck the DQ_ACTIVE_B after that. 6131362f4eaSJan Kara */ 6141362f4eaSJan Kara wait_on_dquot(dquot); 6151362f4eaSJan Kara if (test_bit(DQ_ACTIVE_B, &dquot->dq_flags)) { 616884d179dSJan Kara ret = fn(dquot, priv); 617884d179dSJan Kara if (ret < 0) 618884d179dSJan Kara goto out; 6191362f4eaSJan Kara } 620884d179dSJan Kara spin_lock(&dq_list_lock); 621884d179dSJan Kara /* We are safe to continue now because our dquot could not 622884d179dSJan Kara * be moved out of the inuse list while we hold the reference */ 623884d179dSJan Kara } 624884d179dSJan Kara spin_unlock(&dq_list_lock); 625884d179dSJan Kara out: 626884d179dSJan Kara dqput(old_dquot); 627884d179dSJan Kara return ret; 628884d179dSJan Kara } 629884d179dSJan Kara EXPORT_SYMBOL(dquot_scan_active); 630884d179dSJan Kara 631ceed1723SJan Kara /* Write all dquot structures to quota files */ 632ceed1723SJan Kara int dquot_writeback_dquots(struct super_block *sb, int type) 633884d179dSJan Kara { 6346ff33d99SDmitry Monakhov struct list_head dirty; 635884d179dSJan Kara struct dquot *dquot; 636884d179dSJan Kara struct quota_info *dqopt = sb_dqopt(sb); 637884d179dSJan Kara int cnt; 638ceed1723SJan Kara int err, ret = 0; 639884d179dSJan Kara 6409d1ccbe7SJan Kara WARN_ON_ONCE(!rwsem_is_locked(&sb->s_umount)); 6419d1ccbe7SJan Kara 642884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 643884d179dSJan Kara if (type != -1 && cnt != type) 644884d179dSJan Kara continue; 645884d179dSJan Kara if (!sb_has_quota_active(sb, cnt)) 646884d179dSJan Kara continue; 647884d179dSJan Kara spin_lock(&dq_list_lock); 6486ff33d99SDmitry Monakhov /* Move list away to avoid livelock. */ 6496ff33d99SDmitry Monakhov list_replace_init(&dqopt->info[cnt].dqi_dirty_list, &dirty); 6506ff33d99SDmitry Monakhov while (!list_empty(&dirty)) { 6516ff33d99SDmitry Monakhov dquot = list_first_entry(&dirty, struct dquot, 652268157baSJan Kara dq_dirty); 6534580b30eSJan Kara 6544580b30eSJan Kara WARN_ON(!test_bit(DQ_ACTIVE_B, &dquot->dq_flags)); 6554580b30eSJan Kara 656884d179dSJan Kara /* Now we have active dquot from which someone is 657884d179dSJan Kara * holding reference so we can safely just increase 658884d179dSJan Kara * use count */ 6599f985cb6SJan Kara dqgrab(dquot); 660884d179dSJan Kara spin_unlock(&dq_list_lock); 661ceed1723SJan Kara err = sb->dq_op->write_dquot(dquot); 662dd5f6279Szhangyi (F) if (err) { 663dd5f6279Szhangyi (F) /* 664dd5f6279Szhangyi (F) * Clear dirty bit anyway to avoid infinite 665dd5f6279Szhangyi (F) * loop here. 666dd5f6279Szhangyi (F) */ 667dd5f6279Szhangyi (F) clear_dquot_dirty(dquot); 668dd5f6279Szhangyi (F) if (!ret) 669474d2605SJan Kara ret = err; 670dd5f6279Szhangyi (F) } 671884d179dSJan Kara dqput(dquot); 672884d179dSJan Kara spin_lock(&dq_list_lock); 673884d179dSJan Kara } 674884d179dSJan Kara spin_unlock(&dq_list_lock); 675884d179dSJan Kara } 676884d179dSJan Kara 677884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) 678884d179dSJan Kara if ((cnt == type || type == -1) && sb_has_quota_active(sb, cnt) 679884d179dSJan Kara && info_dirty(&dqopt->info[cnt])) 680884d179dSJan Kara sb->dq_op->write_info(sb, cnt); 681dde95888SDmitry Monakhov dqstats_inc(DQST_SYNCS); 682884d179dSJan Kara 683ceed1723SJan Kara return ret; 684ceed1723SJan Kara } 685ceed1723SJan Kara EXPORT_SYMBOL(dquot_writeback_dquots); 686ceed1723SJan Kara 687ceed1723SJan Kara /* Write all dquot structures to disk and make them visible from userspace */ 688ceed1723SJan Kara int dquot_quota_sync(struct super_block *sb, int type) 689ceed1723SJan Kara { 690ceed1723SJan Kara struct quota_info *dqopt = sb_dqopt(sb); 691ceed1723SJan Kara int cnt; 692ceed1723SJan Kara int ret; 693ceed1723SJan Kara 694ceed1723SJan Kara ret = dquot_writeback_dquots(sb, type); 695ceed1723SJan Kara if (ret) 696ceed1723SJan Kara return ret; 697ceed1723SJan Kara if (dqopt->flags & DQUOT_QUOTA_SYS_FILE) 6985fb324adSChristoph Hellwig return 0; 6995fb324adSChristoph Hellwig 7005fb324adSChristoph Hellwig /* This is not very clever (and fast) but currently I don't know about 7015fb324adSChristoph Hellwig * any other simple way of getting quota data to disk and we must get 7025fb324adSChristoph Hellwig * them there for userspace to be visible... */ 703dd5532a4SDarrick J. Wong if (sb->s_op->sync_fs) { 704dd5532a4SDarrick J. Wong ret = sb->s_op->sync_fs(sb, 1); 705dd5532a4SDarrick J. Wong if (ret) 706dd5532a4SDarrick J. Wong return ret; 707dd5532a4SDarrick J. Wong } 708dd5532a4SDarrick J. Wong ret = sync_blockdev(sb->s_bdev); 709dd5532a4SDarrick J. Wong if (ret) 710dd5532a4SDarrick J. Wong return ret; 7115fb324adSChristoph Hellwig 7125fb324adSChristoph Hellwig /* 7135fb324adSChristoph Hellwig * Now when everything is written we can discard the pagecache so 7145fb324adSChristoph Hellwig * that userspace sees the changes. 7155fb324adSChristoph Hellwig */ 7165fb324adSChristoph Hellwig for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 7175fb324adSChristoph Hellwig if (type != -1 && cnt != type) 7185fb324adSChristoph Hellwig continue; 7195fb324adSChristoph Hellwig if (!sb_has_quota_active(sb, cnt)) 7205fb324adSChristoph Hellwig continue; 7215955102cSAl Viro inode_lock(dqopt->files[cnt]); 722f9ef1784SJan Kara truncate_inode_pages(&dqopt->files[cnt]->i_data, 0); 7235955102cSAl Viro inode_unlock(dqopt->files[cnt]); 7245fb324adSChristoph Hellwig } 7255fb324adSChristoph Hellwig 726884d179dSJan Kara return 0; 727884d179dSJan Kara } 728287a8095SChristoph Hellwig EXPORT_SYMBOL(dquot_quota_sync); 729884d179dSJan Kara 7301ab6c499SDave Chinner static unsigned long 7311ab6c499SDave Chinner dqcache_shrink_scan(struct shrinker *shrink, struct shrink_control *sc) 732884d179dSJan Kara { 733884d179dSJan Kara struct dquot *dquot; 7341ab6c499SDave Chinner unsigned long freed = 0; 735884d179dSJan Kara 736d68aab6bSNiu Yawei spin_lock(&dq_list_lock); 7371822193bSJan Kara while (!list_empty(&free_dquots) && sc->nr_to_scan) { 7381822193bSJan Kara dquot = list_first_entry(&free_dquots, struct dquot, dq_free); 739884d179dSJan Kara remove_dquot_hash(dquot); 740884d179dSJan Kara remove_free_dquot(dquot); 741884d179dSJan Kara remove_inuse(dquot); 742884d179dSJan Kara do_destroy_dquot(dquot); 7431ab6c499SDave Chinner sc->nr_to_scan--; 7441ab6c499SDave Chinner freed++; 745884d179dSJan Kara } 746d68aab6bSNiu Yawei spin_unlock(&dq_list_lock); 7471ab6c499SDave Chinner return freed; 748884d179dSJan Kara } 749884d179dSJan Kara 7501ab6c499SDave Chinner static unsigned long 7511ab6c499SDave Chinner dqcache_shrink_count(struct shrinker *shrink, struct shrink_control *sc) 752884d179dSJan Kara { 75355f841ceSGlauber Costa return vfs_pressure_ratio( 75455f841ceSGlauber Costa percpu_counter_read_positive(&dqstats.counter[DQST_FREE_DQUOTS])); 755884d179dSJan Kara } 756884d179dSJan Kara 757884d179dSJan Kara static struct shrinker dqcache_shrinker = { 7581ab6c499SDave Chinner .count_objects = dqcache_shrink_count, 7591ab6c499SDave Chinner .scan_objects = dqcache_shrink_scan, 760884d179dSJan Kara .seeks = DEFAULT_SEEKS, 761884d179dSJan Kara }; 762884d179dSJan Kara 763884d179dSJan Kara /* 764884d179dSJan Kara * Put reference to dquot 765884d179dSJan Kara */ 766884d179dSJan Kara void dqput(struct dquot *dquot) 767884d179dSJan Kara { 768884d179dSJan Kara int ret; 769884d179dSJan Kara 770884d179dSJan Kara if (!dquot) 771884d179dSJan Kara return; 77262af9b52SJan Kara #ifdef CONFIG_QUOTA_DEBUG 773884d179dSJan Kara if (!atomic_read(&dquot->dq_count)) { 774fb5ffb0eSJiaying Zhang quota_error(dquot->dq_sb, "trying to free free dquot of %s %d", 7754c376dcaSEric W. Biederman quotatypes[dquot->dq_id.type], 7764c376dcaSEric W. Biederman from_kqid(&init_user_ns, dquot->dq_id)); 777884d179dSJan Kara BUG(); 778884d179dSJan Kara } 779884d179dSJan Kara #endif 780dde95888SDmitry Monakhov dqstats_inc(DQST_DROPS); 781884d179dSJan Kara we_slept: 782884d179dSJan Kara spin_lock(&dq_list_lock); 783884d179dSJan Kara if (atomic_read(&dquot->dq_count) > 1) { 784884d179dSJan Kara /* We have more than one user... nothing to do */ 785884d179dSJan Kara atomic_dec(&dquot->dq_count); 786884d179dSJan Kara /* Releasing dquot during quotaoff phase? */ 7874c376dcaSEric W. Biederman if (!sb_has_quota_active(dquot->dq_sb, dquot->dq_id.type) && 788884d179dSJan Kara atomic_read(&dquot->dq_count) == 1) 789503330f3SJan Kara wake_up(&dquot_ref_wq); 790884d179dSJan Kara spin_unlock(&dq_list_lock); 791884d179dSJan Kara return; 792884d179dSJan Kara } 793884d179dSJan Kara /* Need to release dquot? */ 7944580b30eSJan Kara if (dquot_dirty(dquot)) { 795884d179dSJan Kara spin_unlock(&dq_list_lock); 796884d179dSJan Kara /* Commit dquot before releasing */ 797884d179dSJan Kara ret = dquot->dq_sb->dq_op->write_dquot(dquot); 798884d179dSJan Kara if (ret < 0) { 799fb5ffb0eSJiaying Zhang quota_error(dquot->dq_sb, "Can't write quota structure" 800fb5ffb0eSJiaying Zhang " (error %d). Quota may get out of sync!", 801fb5ffb0eSJiaying Zhang ret); 802884d179dSJan Kara /* 803884d179dSJan Kara * We clear dirty bit anyway, so that we avoid 804884d179dSJan Kara * infinite loop here 805884d179dSJan Kara */ 806884d179dSJan Kara clear_dquot_dirty(dquot); 807884d179dSJan Kara } 808884d179dSJan Kara goto we_slept; 809884d179dSJan Kara } 810884d179dSJan Kara if (test_bit(DQ_ACTIVE_B, &dquot->dq_flags)) { 811884d179dSJan Kara spin_unlock(&dq_list_lock); 812884d179dSJan Kara dquot->dq_sb->dq_op->release_dquot(dquot); 813884d179dSJan Kara goto we_slept; 814884d179dSJan Kara } 815884d179dSJan Kara atomic_dec(&dquot->dq_count); 81662af9b52SJan Kara #ifdef CONFIG_QUOTA_DEBUG 817884d179dSJan Kara /* sanity check */ 818884d179dSJan Kara BUG_ON(!list_empty(&dquot->dq_free)); 819884d179dSJan Kara #endif 820884d179dSJan Kara put_dquot_last(dquot); 821884d179dSJan Kara spin_unlock(&dq_list_lock); 822884d179dSJan Kara } 823884d179dSJan Kara EXPORT_SYMBOL(dqput); 824884d179dSJan Kara 825884d179dSJan Kara struct dquot *dquot_alloc(struct super_block *sb, int type) 826884d179dSJan Kara { 827884d179dSJan Kara return kmem_cache_zalloc(dquot_cachep, GFP_NOFS); 828884d179dSJan Kara } 829884d179dSJan Kara EXPORT_SYMBOL(dquot_alloc); 830884d179dSJan Kara 831884d179dSJan Kara static struct dquot *get_empty_dquot(struct super_block *sb, int type) 832884d179dSJan Kara { 833884d179dSJan Kara struct dquot *dquot; 834884d179dSJan Kara 835884d179dSJan Kara dquot = sb->dq_op->alloc_dquot(sb, type); 836884d179dSJan Kara if(!dquot) 837dd6f3c6dSJan Kara return NULL; 838884d179dSJan Kara 839884d179dSJan Kara mutex_init(&dquot->dq_lock); 840884d179dSJan Kara INIT_LIST_HEAD(&dquot->dq_free); 841884d179dSJan Kara INIT_LIST_HEAD(&dquot->dq_inuse); 842884d179dSJan Kara INIT_HLIST_NODE(&dquot->dq_hash); 843884d179dSJan Kara INIT_LIST_HEAD(&dquot->dq_dirty); 844884d179dSJan Kara dquot->dq_sb = sb; 8451a06d420SEric W. Biederman dquot->dq_id = make_kqid_invalid(type); 846884d179dSJan Kara atomic_set(&dquot->dq_count, 1); 8477b9ca4c6SJan Kara spin_lock_init(&dquot->dq_dqb_lock); 848884d179dSJan Kara 849884d179dSJan Kara return dquot; 850884d179dSJan Kara } 851884d179dSJan Kara 852884d179dSJan Kara /* 853884d179dSJan Kara * Get reference to dquot 854884d179dSJan Kara * 855884d179dSJan Kara * Locking is slightly tricky here. We are guarded from parallel quotaoff() 856884d179dSJan Kara * destroying our dquot by: 857884d179dSJan Kara * a) checking for quota flags under dq_list_lock and 858884d179dSJan Kara * b) getting a reference to dquot before we release dq_list_lock 859884d179dSJan Kara */ 860aca645a6SEric W. Biederman struct dquot *dqget(struct super_block *sb, struct kqid qid) 861884d179dSJan Kara { 8621a06d420SEric W. Biederman unsigned int hashent = hashfn(sb, qid); 8636184fc0bSJan Kara struct dquot *dquot, *empty = NULL; 864884d179dSJan Kara 865d49d3762SEric W. Biederman if (!qid_has_mapping(sb->s_user_ns, qid)) 866d49d3762SEric W. Biederman return ERR_PTR(-EINVAL); 867d49d3762SEric W. Biederman 8681a06d420SEric W. Biederman if (!sb_has_quota_active(sb, qid.type)) 8696184fc0bSJan Kara return ERR_PTR(-ESRCH); 870884d179dSJan Kara we_slept: 871884d179dSJan Kara spin_lock(&dq_list_lock); 872884d179dSJan Kara spin_lock(&dq_state_lock); 8731a06d420SEric W. Biederman if (!sb_has_quota_active(sb, qid.type)) { 874884d179dSJan Kara spin_unlock(&dq_state_lock); 875884d179dSJan Kara spin_unlock(&dq_list_lock); 8766184fc0bSJan Kara dquot = ERR_PTR(-ESRCH); 877884d179dSJan Kara goto out; 878884d179dSJan Kara } 879884d179dSJan Kara spin_unlock(&dq_state_lock); 880884d179dSJan Kara 8811a06d420SEric W. Biederman dquot = find_dquot(hashent, sb, qid); 882dd6f3c6dSJan Kara if (!dquot) { 883dd6f3c6dSJan Kara if (!empty) { 884884d179dSJan Kara spin_unlock(&dq_list_lock); 8851a06d420SEric W. Biederman empty = get_empty_dquot(sb, qid.type); 886dd6f3c6dSJan Kara if (!empty) 887884d179dSJan Kara schedule(); /* Try to wait for a moment... */ 888884d179dSJan Kara goto we_slept; 889884d179dSJan Kara } 890884d179dSJan Kara dquot = empty; 891dd6f3c6dSJan Kara empty = NULL; 8924c376dcaSEric W. Biederman dquot->dq_id = qid; 893884d179dSJan Kara /* all dquots go on the inuse_list */ 894884d179dSJan Kara put_inuse(dquot); 895884d179dSJan Kara /* hash it first so it can be found */ 896884d179dSJan Kara insert_dquot_hash(dquot); 897884d179dSJan Kara spin_unlock(&dq_list_lock); 898dde95888SDmitry Monakhov dqstats_inc(DQST_LOOKUPS); 899884d179dSJan Kara } else { 900884d179dSJan Kara if (!atomic_read(&dquot->dq_count)) 901884d179dSJan Kara remove_free_dquot(dquot); 902884d179dSJan Kara atomic_inc(&dquot->dq_count); 903884d179dSJan Kara spin_unlock(&dq_list_lock); 904dde95888SDmitry Monakhov dqstats_inc(DQST_CACHE_HITS); 905dde95888SDmitry Monakhov dqstats_inc(DQST_LOOKUPS); 906884d179dSJan Kara } 907268157baSJan Kara /* Wait for dq_lock - after this we know that either dquot_release() is 908268157baSJan Kara * already finished or it will be canceled due to dq_count > 1 test */ 909884d179dSJan Kara wait_on_dquot(dquot); 910268157baSJan Kara /* Read the dquot / allocate space in quota file */ 9116184fc0bSJan Kara if (!test_bit(DQ_ACTIVE_B, &dquot->dq_flags)) { 9126184fc0bSJan Kara int err; 9136184fc0bSJan Kara 9146184fc0bSJan Kara err = sb->dq_op->acquire_dquot(dquot); 9156184fc0bSJan Kara if (err < 0) { 916884d179dSJan Kara dqput(dquot); 9176184fc0bSJan Kara dquot = ERR_PTR(err); 918884d179dSJan Kara goto out; 919884d179dSJan Kara } 9206184fc0bSJan Kara } 921044c9b67SJan Kara /* 922044c9b67SJan Kara * Make sure following reads see filled structure - paired with 923044c9b67SJan Kara * smp_mb__before_atomic() in dquot_acquire(). 924044c9b67SJan Kara */ 925044c9b67SJan Kara smp_rmb(); 92662af9b52SJan Kara #ifdef CONFIG_QUOTA_DEBUG 927884d179dSJan Kara BUG_ON(!dquot->dq_sb); /* Has somebody invalidated entry under us? */ 928884d179dSJan Kara #endif 929884d179dSJan Kara out: 930884d179dSJan Kara if (empty) 931884d179dSJan Kara do_destroy_dquot(empty); 932884d179dSJan Kara 933884d179dSJan Kara return dquot; 934884d179dSJan Kara } 935884d179dSJan Kara EXPORT_SYMBOL(dqget); 936884d179dSJan Kara 9372d0fa467SJan Kara static inline struct dquot **i_dquot(struct inode *inode) 9382d0fa467SJan Kara { 9392d0fa467SJan Kara return inode->i_sb->s_op->get_dquots(inode); 9402d0fa467SJan Kara } 9412d0fa467SJan Kara 942884d179dSJan Kara static int dqinit_needed(struct inode *inode, int type) 943884d179dSJan Kara { 9445bcd3b6fSKonstantin Khlebnikov struct dquot * const *dquots; 945884d179dSJan Kara int cnt; 946884d179dSJan Kara 947884d179dSJan Kara if (IS_NOQUOTA(inode)) 948884d179dSJan Kara return 0; 9495bcd3b6fSKonstantin Khlebnikov 9505bcd3b6fSKonstantin Khlebnikov dquots = i_dquot(inode); 951884d179dSJan Kara if (type != -1) 9525bcd3b6fSKonstantin Khlebnikov return !dquots[type]; 953884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) 9545bcd3b6fSKonstantin Khlebnikov if (!dquots[cnt]) 955884d179dSJan Kara return 1; 956884d179dSJan Kara return 0; 957884d179dSJan Kara } 958884d179dSJan Kara 959c3b00446SJan Kara /* This routine is guarded by s_umount semaphore */ 9601a6152d3SChao Yu static int add_dquot_ref(struct super_block *sb, int type) 961884d179dSJan Kara { 962884d179dSJan Kara struct inode *inode, *old_inode = NULL; 96362af9b52SJan Kara #ifdef CONFIG_QUOTA_DEBUG 9640a5a9c72SJan Kara int reserved = 0; 9654c5e6c0eSJan Kara #endif 9661a6152d3SChao Yu int err = 0; 967884d179dSJan Kara 96874278da9SDave Chinner spin_lock(&sb->s_inode_list_lock); 969884d179dSJan Kara list_for_each_entry(inode, &sb->s_inodes, i_sb_list) { 970250df6edSDave Chinner spin_lock(&inode->i_lock); 971250df6edSDave Chinner if ((inode->i_state & (I_FREEING|I_WILL_FREE|I_NEW)) || 972250df6edSDave Chinner !atomic_read(&inode->i_writecount) || 973250df6edSDave Chinner !dqinit_needed(inode, type)) { 974250df6edSDave Chinner spin_unlock(&inode->i_lock); 9753ae5080fSLinus Torvalds continue; 976250df6edSDave Chinner } 977884d179dSJan Kara __iget(inode); 978250df6edSDave Chinner spin_unlock(&inode->i_lock); 97974278da9SDave Chinner spin_unlock(&sb->s_inode_list_lock); 980884d179dSJan Kara 981d7e97117SJan Kara #ifdef CONFIG_QUOTA_DEBUG 982d7e97117SJan Kara if (unlikely(inode_get_rsv_space(inode) > 0)) 983d7e97117SJan Kara reserved = 1; 984d7e97117SJan Kara #endif 985884d179dSJan Kara iput(old_inode); 9861a6152d3SChao Yu err = __dquot_initialize(inode, type); 9871a6152d3SChao Yu if (err) { 9881a6152d3SChao Yu iput(inode); 9891a6152d3SChao Yu goto out; 9901a6152d3SChao Yu } 99155fa6091SDave Chinner 99255fa6091SDave Chinner /* 99355fa6091SDave Chinner * We hold a reference to 'inode' so it couldn't have been 99455fa6091SDave Chinner * removed from s_inodes list while we dropped the 99574278da9SDave Chinner * s_inode_list_lock. We cannot iput the inode now as we can be 99655fa6091SDave Chinner * holding the last reference and we cannot iput it under 99774278da9SDave Chinner * s_inode_list_lock. So we keep the reference and iput it 99855fa6091SDave Chinner * later. 99955fa6091SDave Chinner */ 1000884d179dSJan Kara old_inode = inode; 100104646aebSEric Sandeen cond_resched(); 100274278da9SDave Chinner spin_lock(&sb->s_inode_list_lock); 1003884d179dSJan Kara } 100474278da9SDave Chinner spin_unlock(&sb->s_inode_list_lock); 1005884d179dSJan Kara iput(old_inode); 10061a6152d3SChao Yu out: 100762af9b52SJan Kara #ifdef CONFIG_QUOTA_DEBUG 10080a5a9c72SJan Kara if (reserved) { 1009fb5ffb0eSJiaying Zhang quota_error(sb, "Writes happened before quota was turned on " 1010fb5ffb0eSJiaying Zhang "thus quota information is probably inconsistent. " 1011fb5ffb0eSJiaying Zhang "Please run quotacheck(8)"); 10120a5a9c72SJan Kara } 10134c5e6c0eSJan Kara #endif 10141a6152d3SChao Yu return err; 1015884d179dSJan Kara } 1016884d179dSJan Kara 1017268157baSJan Kara /* 1018268157baSJan Kara * Remove references to dquots from inode and add dquot to list for freeing 101925985edcSLucas De Marchi * if we have the last reference to dquot 1020268157baSJan Kara */ 10219eb6463fSNiu Yawei static void remove_inode_dquot_ref(struct inode *inode, int type, 1022884d179dSJan Kara struct list_head *tofree_head) 1023884d179dSJan Kara { 10245bcd3b6fSKonstantin Khlebnikov struct dquot **dquots = i_dquot(inode); 10255bcd3b6fSKonstantin Khlebnikov struct dquot *dquot = dquots[type]; 1026884d179dSJan Kara 10279eb6463fSNiu Yawei if (!dquot) 10289eb6463fSNiu Yawei return; 10299eb6463fSNiu Yawei 10305bcd3b6fSKonstantin Khlebnikov dquots[type] = NULL; 10319eb6463fSNiu Yawei if (list_empty(&dquot->dq_free)) { 10329eb6463fSNiu Yawei /* 10339eb6463fSNiu Yawei * The inode still has reference to dquot so it can't be in the 10349eb6463fSNiu Yawei * free list 10359eb6463fSNiu Yawei */ 1036884d179dSJan Kara spin_lock(&dq_list_lock); 1037268157baSJan Kara list_add(&dquot->dq_free, tofree_head); 1038884d179dSJan Kara spin_unlock(&dq_list_lock); 10399eb6463fSNiu Yawei } else { 10409eb6463fSNiu Yawei /* 10419eb6463fSNiu Yawei * Dquot is already in a list to put so we won't drop the last 10429eb6463fSNiu Yawei * reference here. 10439eb6463fSNiu Yawei */ 10449eb6463fSNiu Yawei dqput(dquot); 1045884d179dSJan Kara } 1046884d179dSJan Kara } 1047884d179dSJan Kara 1048268157baSJan Kara /* 1049268157baSJan Kara * Free list of dquots 1050268157baSJan Kara * Dquots are removed from inodes and no new references can be got so we are 1051268157baSJan Kara * the only ones holding reference 1052268157baSJan Kara */ 1053884d179dSJan Kara static void put_dquot_list(struct list_head *tofree_head) 1054884d179dSJan Kara { 1055884d179dSJan Kara struct list_head *act_head; 1056884d179dSJan Kara struct dquot *dquot; 1057884d179dSJan Kara 1058884d179dSJan Kara act_head = tofree_head->next; 1059884d179dSJan Kara while (act_head != tofree_head) { 1060884d179dSJan Kara dquot = list_entry(act_head, struct dquot, dq_free); 1061884d179dSJan Kara act_head = act_head->next; 1062268157baSJan Kara /* Remove dquot from the list so we won't have problems... */ 1063268157baSJan Kara list_del_init(&dquot->dq_free); 1064884d179dSJan Kara dqput(dquot); 1065884d179dSJan Kara } 1066884d179dSJan Kara } 1067884d179dSJan Kara 1068884d179dSJan Kara static void remove_dquot_ref(struct super_block *sb, int type, 1069884d179dSJan Kara struct list_head *tofree_head) 1070884d179dSJan Kara { 1071884d179dSJan Kara struct inode *inode; 107278bc3334SJiang Biao #ifdef CONFIG_QUOTA_DEBUG 10737af9cce8SDmitry Monakhov int reserved = 0; 107478bc3334SJiang Biao #endif 1075884d179dSJan Kara 107674278da9SDave Chinner spin_lock(&sb->s_inode_list_lock); 1077884d179dSJan Kara list_for_each_entry(inode, &sb->s_inodes, i_sb_list) { 10783ae5080fSLinus Torvalds /* 10793ae5080fSLinus Torvalds * We have to scan also I_NEW inodes because they can already 10803ae5080fSLinus Torvalds * have quota pointer initialized. Luckily, we need to touch 10813ae5080fSLinus Torvalds * only quota pointers and these have separate locking 1082b9ba6f94SNiu Yawei * (dq_data_lock). 10833ae5080fSLinus Torvalds */ 1084b9ba6f94SNiu Yawei spin_lock(&dq_data_lock); 10857af9cce8SDmitry Monakhov if (!IS_NOQUOTA(inode)) { 108678bc3334SJiang Biao #ifdef CONFIG_QUOTA_DEBUG 10877af9cce8SDmitry Monakhov if (unlikely(inode_get_rsv_space(inode) > 0)) 10887af9cce8SDmitry Monakhov reserved = 1; 108978bc3334SJiang Biao #endif 1090884d179dSJan Kara remove_inode_dquot_ref(inode, type, tofree_head); 1091884d179dSJan Kara } 1092b9ba6f94SNiu Yawei spin_unlock(&dq_data_lock); 10937af9cce8SDmitry Monakhov } 109474278da9SDave Chinner spin_unlock(&sb->s_inode_list_lock); 10957af9cce8SDmitry Monakhov #ifdef CONFIG_QUOTA_DEBUG 10967af9cce8SDmitry Monakhov if (reserved) { 10977af9cce8SDmitry Monakhov printk(KERN_WARNING "VFS (%s): Writes happened after quota" 10987af9cce8SDmitry Monakhov " was disabled thus quota information is probably " 10997af9cce8SDmitry Monakhov "inconsistent. Please run quotacheck(8).\n", sb->s_id); 11007af9cce8SDmitry Monakhov } 11017af9cce8SDmitry Monakhov #endif 1102884d179dSJan Kara } 1103884d179dSJan Kara 1104884d179dSJan Kara /* Gather all references from inodes and drop them */ 1105884d179dSJan Kara static void drop_dquot_ref(struct super_block *sb, int type) 1106884d179dSJan Kara { 1107884d179dSJan Kara LIST_HEAD(tofree_head); 1108884d179dSJan Kara 1109884d179dSJan Kara if (sb->dq_op) { 1110884d179dSJan Kara remove_dquot_ref(sb, type, &tofree_head); 1111b9ba6f94SNiu Yawei synchronize_srcu(&dquot_srcu); 1112884d179dSJan Kara put_dquot_list(&tofree_head); 1113884d179dSJan Kara } 1114884d179dSJan Kara } 1115884d179dSJan Kara 1116884d179dSJan Kara static inline 1117884d179dSJan Kara void dquot_free_reserved_space(struct dquot *dquot, qsize_t number) 1118884d179dSJan Kara { 11190a5a9c72SJan Kara if (dquot->dq_dqb.dqb_rsvspace >= number) 1120884d179dSJan Kara dquot->dq_dqb.dqb_rsvspace -= number; 11210a5a9c72SJan Kara else { 11220a5a9c72SJan Kara WARN_ON_ONCE(1); 11230a5a9c72SJan Kara dquot->dq_dqb.dqb_rsvspace = 0; 11240a5a9c72SJan Kara } 112541e327b5Szhangyi (F) if (dquot->dq_dqb.dqb_curspace + dquot->dq_dqb.dqb_rsvspace <= 112641e327b5Szhangyi (F) dquot->dq_dqb.dqb_bsoftlimit) 112741e327b5Szhangyi (F) dquot->dq_dqb.dqb_btime = (time64_t) 0; 112841e327b5Szhangyi (F) clear_bit(DQ_BLKS_B, &dquot->dq_flags); 1129884d179dSJan Kara } 1130884d179dSJan Kara 11317a2435d8SJan Kara static void dquot_decr_inodes(struct dquot *dquot, qsize_t number) 1132884d179dSJan Kara { 1133884d179dSJan Kara if (sb_dqopt(dquot->dq_sb)->flags & DQUOT_NEGATIVE_USAGE || 1134884d179dSJan Kara dquot->dq_dqb.dqb_curinodes >= number) 1135884d179dSJan Kara dquot->dq_dqb.dqb_curinodes -= number; 1136884d179dSJan Kara else 1137884d179dSJan Kara dquot->dq_dqb.dqb_curinodes = 0; 1138884d179dSJan Kara if (dquot->dq_dqb.dqb_curinodes <= dquot->dq_dqb.dqb_isoftlimit) 1139e008bb61SArnd Bergmann dquot->dq_dqb.dqb_itime = (time64_t) 0; 1140884d179dSJan Kara clear_bit(DQ_INODES_B, &dquot->dq_flags); 1141884d179dSJan Kara } 1142884d179dSJan Kara 11437a2435d8SJan Kara static void dquot_decr_space(struct dquot *dquot, qsize_t number) 1144884d179dSJan Kara { 1145884d179dSJan Kara if (sb_dqopt(dquot->dq_sb)->flags & DQUOT_NEGATIVE_USAGE || 1146884d179dSJan Kara dquot->dq_dqb.dqb_curspace >= number) 1147884d179dSJan Kara dquot->dq_dqb.dqb_curspace -= number; 1148884d179dSJan Kara else 1149884d179dSJan Kara dquot->dq_dqb.dqb_curspace = 0; 115041e327b5Szhangyi (F) if (dquot->dq_dqb.dqb_curspace + dquot->dq_dqb.dqb_rsvspace <= 115141e327b5Szhangyi (F) dquot->dq_dqb.dqb_bsoftlimit) 1152e008bb61SArnd Bergmann dquot->dq_dqb.dqb_btime = (time64_t) 0; 1153884d179dSJan Kara clear_bit(DQ_BLKS_B, &dquot->dq_flags); 1154884d179dSJan Kara } 1155884d179dSJan Kara 1156bf097aafSJan Kara struct dquot_warn { 1157bf097aafSJan Kara struct super_block *w_sb; 11587b9c7321SEric W. Biederman struct kqid w_dq_id; 1159bf097aafSJan Kara short w_type; 1160bf097aafSJan Kara }; 1161bf097aafSJan Kara 1162884d179dSJan Kara static int warning_issued(struct dquot *dquot, const int warntype) 1163884d179dSJan Kara { 1164884d179dSJan Kara int flag = (warntype == QUOTA_NL_BHARDWARN || 1165884d179dSJan Kara warntype == QUOTA_NL_BSOFTLONGWARN) ? DQ_BLKS_B : 1166884d179dSJan Kara ((warntype == QUOTA_NL_IHARDWARN || 1167884d179dSJan Kara warntype == QUOTA_NL_ISOFTLONGWARN) ? DQ_INODES_B : 0); 1168884d179dSJan Kara 1169884d179dSJan Kara if (!flag) 1170884d179dSJan Kara return 0; 1171884d179dSJan Kara return test_and_set_bit(flag, &dquot->dq_flags); 1172884d179dSJan Kara } 1173884d179dSJan Kara 1174884d179dSJan Kara #ifdef CONFIG_PRINT_QUOTA_WARNING 1175884d179dSJan Kara static int flag_print_warnings = 1; 1176884d179dSJan Kara 1177bf097aafSJan Kara static int need_print_warning(struct dquot_warn *warn) 1178884d179dSJan Kara { 1179884d179dSJan Kara if (!flag_print_warnings) 1180884d179dSJan Kara return 0; 1181884d179dSJan Kara 11827b9c7321SEric W. Biederman switch (warn->w_dq_id.type) { 1183884d179dSJan Kara case USRQUOTA: 11841a06d420SEric W. Biederman return uid_eq(current_fsuid(), warn->w_dq_id.uid); 1185884d179dSJan Kara case GRPQUOTA: 11867b9c7321SEric W. Biederman return in_group_p(warn->w_dq_id.gid); 1187847aac64SLi Xi case PRJQUOTA: 1188847aac64SLi Xi return 1; 1189884d179dSJan Kara } 1190884d179dSJan Kara return 0; 1191884d179dSJan Kara } 1192884d179dSJan Kara 1193884d179dSJan Kara /* Print warning to user which exceeded quota */ 1194bf097aafSJan Kara static void print_warning(struct dquot_warn *warn) 1195884d179dSJan Kara { 1196884d179dSJan Kara char *msg = NULL; 1197884d179dSJan Kara struct tty_struct *tty; 1198bf097aafSJan Kara int warntype = warn->w_type; 1199884d179dSJan Kara 1200884d179dSJan Kara if (warntype == QUOTA_NL_IHARDBELOW || 1201884d179dSJan Kara warntype == QUOTA_NL_ISOFTBELOW || 1202884d179dSJan Kara warntype == QUOTA_NL_BHARDBELOW || 1203bf097aafSJan Kara warntype == QUOTA_NL_BSOFTBELOW || !need_print_warning(warn)) 1204884d179dSJan Kara return; 1205884d179dSJan Kara 1206884d179dSJan Kara tty = get_current_tty(); 1207884d179dSJan Kara if (!tty) 1208884d179dSJan Kara return; 1209bf097aafSJan Kara tty_write_message(tty, warn->w_sb->s_id); 1210884d179dSJan Kara if (warntype == QUOTA_NL_ISOFTWARN || warntype == QUOTA_NL_BSOFTWARN) 1211884d179dSJan Kara tty_write_message(tty, ": warning, "); 1212884d179dSJan Kara else 1213884d179dSJan Kara tty_write_message(tty, ": write failed, "); 12147b9c7321SEric W. Biederman tty_write_message(tty, quotatypes[warn->w_dq_id.type]); 1215884d179dSJan Kara switch (warntype) { 1216884d179dSJan Kara case QUOTA_NL_IHARDWARN: 1217884d179dSJan Kara msg = " file limit reached.\r\n"; 1218884d179dSJan Kara break; 1219884d179dSJan Kara case QUOTA_NL_ISOFTLONGWARN: 1220884d179dSJan Kara msg = " file quota exceeded too long.\r\n"; 1221884d179dSJan Kara break; 1222884d179dSJan Kara case QUOTA_NL_ISOFTWARN: 1223884d179dSJan Kara msg = " file quota exceeded.\r\n"; 1224884d179dSJan Kara break; 1225884d179dSJan Kara case QUOTA_NL_BHARDWARN: 1226884d179dSJan Kara msg = " block limit reached.\r\n"; 1227884d179dSJan Kara break; 1228884d179dSJan Kara case QUOTA_NL_BSOFTLONGWARN: 1229884d179dSJan Kara msg = " block quota exceeded too long.\r\n"; 1230884d179dSJan Kara break; 1231884d179dSJan Kara case QUOTA_NL_BSOFTWARN: 1232884d179dSJan Kara msg = " block quota exceeded.\r\n"; 1233884d179dSJan Kara break; 1234884d179dSJan Kara } 1235884d179dSJan Kara tty_write_message(tty, msg); 1236884d179dSJan Kara tty_kref_put(tty); 1237884d179dSJan Kara } 1238884d179dSJan Kara #endif 1239884d179dSJan Kara 1240bf097aafSJan Kara static void prepare_warning(struct dquot_warn *warn, struct dquot *dquot, 1241bf097aafSJan Kara int warntype) 1242bf097aafSJan Kara { 1243bf097aafSJan Kara if (warning_issued(dquot, warntype)) 1244bf097aafSJan Kara return; 1245bf097aafSJan Kara warn->w_type = warntype; 1246bf097aafSJan Kara warn->w_sb = dquot->dq_sb; 1247bf097aafSJan Kara warn->w_dq_id = dquot->dq_id; 1248bf097aafSJan Kara } 1249bf097aafSJan Kara 1250884d179dSJan Kara /* 1251884d179dSJan Kara * Write warnings to the console and send warning messages over netlink. 1252884d179dSJan Kara * 1253bf097aafSJan Kara * Note that this function can call into tty and networking code. 1254884d179dSJan Kara */ 1255bf097aafSJan Kara static void flush_warnings(struct dquot_warn *warn) 1256884d179dSJan Kara { 1257884d179dSJan Kara int i; 1258884d179dSJan Kara 125986e931a3SSteven Whitehouse for (i = 0; i < MAXQUOTAS; i++) { 1260bf097aafSJan Kara if (warn[i].w_type == QUOTA_NL_NOWARN) 1261bf097aafSJan Kara continue; 1262884d179dSJan Kara #ifdef CONFIG_PRINT_QUOTA_WARNING 1263bf097aafSJan Kara print_warning(&warn[i]); 1264884d179dSJan Kara #endif 12657b9c7321SEric W. Biederman quota_send_warning(warn[i].w_dq_id, 1266bf097aafSJan Kara warn[i].w_sb->s_dev, warn[i].w_type); 1267884d179dSJan Kara } 1268884d179dSJan Kara } 1269884d179dSJan Kara 12707a2435d8SJan Kara static int ignore_hardlimit(struct dquot *dquot) 1271884d179dSJan Kara { 12724c376dcaSEric W. Biederman struct mem_dqinfo *info = &sb_dqopt(dquot->dq_sb)->info[dquot->dq_id.type]; 1273884d179dSJan Kara 1274884d179dSJan Kara return capable(CAP_SYS_RESOURCE) && 1275268157baSJan Kara (info->dqi_format->qf_fmt_id != QFMT_VFS_OLD || 12769c45101eSJan Kara !(info->dqi_flags & DQF_ROOT_SQUASH)); 1277884d179dSJan Kara } 1278884d179dSJan Kara 12797b9ca4c6SJan Kara static int dquot_add_inodes(struct dquot *dquot, qsize_t inodes, 1280bf097aafSJan Kara struct dquot_warn *warn) 1281884d179dSJan Kara { 12827b9ca4c6SJan Kara qsize_t newinodes; 12837b9ca4c6SJan Kara int ret = 0; 1284268157baSJan Kara 12857b9ca4c6SJan Kara spin_lock(&dquot->dq_dqb_lock); 12867b9ca4c6SJan Kara newinodes = dquot->dq_dqb.dqb_curinodes + inodes; 12874c376dcaSEric W. Biederman if (!sb_has_quota_limits_enabled(dquot->dq_sb, dquot->dq_id.type) || 1288884d179dSJan Kara test_bit(DQ_FAKE_B, &dquot->dq_flags)) 12897b9ca4c6SJan Kara goto add; 1290884d179dSJan Kara 1291884d179dSJan Kara if (dquot->dq_dqb.dqb_ihardlimit && 1292268157baSJan Kara newinodes > dquot->dq_dqb.dqb_ihardlimit && 1293884d179dSJan Kara !ignore_hardlimit(dquot)) { 1294bf097aafSJan Kara prepare_warning(warn, dquot, QUOTA_NL_IHARDWARN); 12957b9ca4c6SJan Kara ret = -EDQUOT; 12967b9ca4c6SJan Kara goto out; 1297884d179dSJan Kara } 1298884d179dSJan Kara 1299884d179dSJan Kara if (dquot->dq_dqb.dqb_isoftlimit && 1300268157baSJan Kara newinodes > dquot->dq_dqb.dqb_isoftlimit && 1301268157baSJan Kara dquot->dq_dqb.dqb_itime && 1302e008bb61SArnd Bergmann ktime_get_real_seconds() >= dquot->dq_dqb.dqb_itime && 1303884d179dSJan Kara !ignore_hardlimit(dquot)) { 1304bf097aafSJan Kara prepare_warning(warn, dquot, QUOTA_NL_ISOFTLONGWARN); 13057b9ca4c6SJan Kara ret = -EDQUOT; 13067b9ca4c6SJan Kara goto out; 1307884d179dSJan Kara } 1308884d179dSJan Kara 1309884d179dSJan Kara if (dquot->dq_dqb.dqb_isoftlimit && 1310268157baSJan Kara newinodes > dquot->dq_dqb.dqb_isoftlimit && 1311884d179dSJan Kara dquot->dq_dqb.dqb_itime == 0) { 1312bf097aafSJan Kara prepare_warning(warn, dquot, QUOTA_NL_ISOFTWARN); 1313e008bb61SArnd Bergmann dquot->dq_dqb.dqb_itime = ktime_get_real_seconds() + 13144c376dcaSEric W. Biederman sb_dqopt(dquot->dq_sb)->info[dquot->dq_id.type].dqi_igrace; 1315884d179dSJan Kara } 13167b9ca4c6SJan Kara add: 13177b9ca4c6SJan Kara dquot->dq_dqb.dqb_curinodes = newinodes; 1318884d179dSJan Kara 13197b9ca4c6SJan Kara out: 13207b9ca4c6SJan Kara spin_unlock(&dquot->dq_dqb_lock); 13217b9ca4c6SJan Kara return ret; 1322884d179dSJan Kara } 1323884d179dSJan Kara 13247b9ca4c6SJan Kara static int dquot_add_space(struct dquot *dquot, qsize_t space, 13257b9ca4c6SJan Kara qsize_t rsv_space, unsigned int flags, 1326bf097aafSJan Kara struct dquot_warn *warn) 1327884d179dSJan Kara { 1328884d179dSJan Kara qsize_t tspace; 1329268157baSJan Kara struct super_block *sb = dquot->dq_sb; 13307b9ca4c6SJan Kara int ret = 0; 1331884d179dSJan Kara 13327b9ca4c6SJan Kara spin_lock(&dquot->dq_dqb_lock); 13334c376dcaSEric W. Biederman if (!sb_has_quota_limits_enabled(sb, dquot->dq_id.type) || 1334884d179dSJan Kara test_bit(DQ_FAKE_B, &dquot->dq_flags)) 1335ac3d7939SJan Kara goto finish; 1336884d179dSJan Kara 1337884d179dSJan Kara tspace = dquot->dq_dqb.dqb_curspace + dquot->dq_dqb.dqb_rsvspace 13387b9ca4c6SJan Kara + space + rsv_space; 13397b9ca4c6SJan Kara 1340884d179dSJan Kara if (dquot->dq_dqb.dqb_bhardlimit && 1341884d179dSJan Kara tspace > dquot->dq_dqb.dqb_bhardlimit && 1342884d179dSJan Kara !ignore_hardlimit(dquot)) { 13437b9ca4c6SJan Kara if (flags & DQUOT_SPACE_WARN) 1344bf097aafSJan Kara prepare_warning(warn, dquot, QUOTA_NL_BHARDWARN); 13457b9ca4c6SJan Kara ret = -EDQUOT; 1346ac3d7939SJan Kara goto finish; 1347884d179dSJan Kara } 1348884d179dSJan Kara 1349884d179dSJan Kara if (dquot->dq_dqb.dqb_bsoftlimit && 1350884d179dSJan Kara tspace > dquot->dq_dqb.dqb_bsoftlimit && 1351268157baSJan Kara dquot->dq_dqb.dqb_btime && 1352e008bb61SArnd Bergmann ktime_get_real_seconds() >= dquot->dq_dqb.dqb_btime && 1353884d179dSJan Kara !ignore_hardlimit(dquot)) { 13547b9ca4c6SJan Kara if (flags & DQUOT_SPACE_WARN) 1355bf097aafSJan Kara prepare_warning(warn, dquot, QUOTA_NL_BSOFTLONGWARN); 13567b9ca4c6SJan Kara ret = -EDQUOT; 1357ac3d7939SJan Kara goto finish; 1358884d179dSJan Kara } 1359884d179dSJan Kara 1360884d179dSJan Kara if (dquot->dq_dqb.dqb_bsoftlimit && 1361884d179dSJan Kara tspace > dquot->dq_dqb.dqb_bsoftlimit && 1362884d179dSJan Kara dquot->dq_dqb.dqb_btime == 0) { 13637b9ca4c6SJan Kara if (flags & DQUOT_SPACE_WARN) { 1364bf097aafSJan Kara prepare_warning(warn, dquot, QUOTA_NL_BSOFTWARN); 1365e008bb61SArnd Bergmann dquot->dq_dqb.dqb_btime = ktime_get_real_seconds() + 13664c376dcaSEric W. Biederman sb_dqopt(sb)->info[dquot->dq_id.type].dqi_bgrace; 13677b9ca4c6SJan Kara } else { 1368884d179dSJan Kara /* 1369884d179dSJan Kara * We don't allow preallocation to exceed softlimit so exceeding will 1370884d179dSJan Kara * be always printed 1371884d179dSJan Kara */ 13727b9ca4c6SJan Kara ret = -EDQUOT; 1373ac3d7939SJan Kara goto finish; 1374884d179dSJan Kara } 13757b9ca4c6SJan Kara } 1376ac3d7939SJan Kara finish: 1377ac3d7939SJan Kara /* 1378ac3d7939SJan Kara * We have to be careful and go through warning generation & grace time 1379ac3d7939SJan Kara * setting even if DQUOT_SPACE_NOFAIL is set. That's why we check it 1380ac3d7939SJan Kara * only here... 1381ac3d7939SJan Kara */ 1382ac3d7939SJan Kara if (flags & DQUOT_SPACE_NOFAIL) 1383ac3d7939SJan Kara ret = 0; 1384ac3d7939SJan Kara if (!ret) { 13857b9ca4c6SJan Kara dquot->dq_dqb.dqb_rsvspace += rsv_space; 13867b9ca4c6SJan Kara dquot->dq_dqb.dqb_curspace += space; 1387ac3d7939SJan Kara } 13887b9ca4c6SJan Kara spin_unlock(&dquot->dq_dqb_lock); 13897b9ca4c6SJan Kara return ret; 1390884d179dSJan Kara } 1391884d179dSJan Kara 1392884d179dSJan Kara static int info_idq_free(struct dquot *dquot, qsize_t inodes) 1393884d179dSJan Kara { 1394268157baSJan Kara qsize_t newinodes; 1395268157baSJan Kara 1396884d179dSJan Kara if (test_bit(DQ_FAKE_B, &dquot->dq_flags) || 1397884d179dSJan Kara dquot->dq_dqb.dqb_curinodes <= dquot->dq_dqb.dqb_isoftlimit || 13984c376dcaSEric W. Biederman !sb_has_quota_limits_enabled(dquot->dq_sb, dquot->dq_id.type)) 1399884d179dSJan Kara return QUOTA_NL_NOWARN; 1400884d179dSJan Kara 1401268157baSJan Kara newinodes = dquot->dq_dqb.dqb_curinodes - inodes; 1402268157baSJan Kara if (newinodes <= dquot->dq_dqb.dqb_isoftlimit) 1403884d179dSJan Kara return QUOTA_NL_ISOFTBELOW; 1404884d179dSJan Kara if (dquot->dq_dqb.dqb_curinodes >= dquot->dq_dqb.dqb_ihardlimit && 1405268157baSJan Kara newinodes < dquot->dq_dqb.dqb_ihardlimit) 1406884d179dSJan Kara return QUOTA_NL_IHARDBELOW; 1407884d179dSJan Kara return QUOTA_NL_NOWARN; 1408884d179dSJan Kara } 1409884d179dSJan Kara 1410884d179dSJan Kara static int info_bdq_free(struct dquot *dquot, qsize_t space) 1411884d179dSJan Kara { 141241e327b5Szhangyi (F) qsize_t tspace; 141341e327b5Szhangyi (F) 141441e327b5Szhangyi (F) tspace = dquot->dq_dqb.dqb_curspace + dquot->dq_dqb.dqb_rsvspace; 141541e327b5Szhangyi (F) 1416884d179dSJan Kara if (test_bit(DQ_FAKE_B, &dquot->dq_flags) || 141741e327b5Szhangyi (F) tspace <= dquot->dq_dqb.dqb_bsoftlimit) 1418884d179dSJan Kara return QUOTA_NL_NOWARN; 1419884d179dSJan Kara 142041e327b5Szhangyi (F) if (tspace - space <= dquot->dq_dqb.dqb_bsoftlimit) 1421884d179dSJan Kara return QUOTA_NL_BSOFTBELOW; 142241e327b5Szhangyi (F) if (tspace >= dquot->dq_dqb.dqb_bhardlimit && 142341e327b5Szhangyi (F) tspace - space < dquot->dq_dqb.dqb_bhardlimit) 1424884d179dSJan Kara return QUOTA_NL_BHARDBELOW; 1425884d179dSJan Kara return QUOTA_NL_NOWARN; 1426884d179dSJan Kara } 14270a5a9c72SJan Kara 1428189eef59SChristoph Hellwig static int dquot_active(const struct inode *inode) 1429189eef59SChristoph Hellwig { 1430189eef59SChristoph Hellwig struct super_block *sb = inode->i_sb; 1431189eef59SChristoph Hellwig 1432189eef59SChristoph Hellwig if (IS_NOQUOTA(inode)) 1433189eef59SChristoph Hellwig return 0; 1434189eef59SChristoph Hellwig return sb_any_quota_loaded(sb) & ~sb_any_quota_suspended(sb); 1435189eef59SChristoph Hellwig } 1436189eef59SChristoph Hellwig 1437884d179dSJan Kara /* 1438884d179dSJan Kara * Initialize quota pointers in inode 1439871a2931SChristoph Hellwig * 1440871a2931SChristoph Hellwig * It is better to call this function outside of any transaction as it 1441871a2931SChristoph Hellwig * might need a lot of space in journal for dquot structure allocation. 1442884d179dSJan Kara */ 14436184fc0bSJan Kara static int __dquot_initialize(struct inode *inode, int type) 1444884d179dSJan Kara { 14451ea06becSNiu Yawei int cnt, init_needed = 0; 1446ab73ef46SNikolay Borisov struct dquot **dquots, *got[MAXQUOTAS] = {}; 1447884d179dSJan Kara struct super_block *sb = inode->i_sb; 14480a5a9c72SJan Kara qsize_t rsv; 14496184fc0bSJan Kara int ret = 0; 1450884d179dSJan Kara 1451189eef59SChristoph Hellwig if (!dquot_active(inode)) 14526184fc0bSJan Kara return 0; 1453884d179dSJan Kara 14545bcd3b6fSKonstantin Khlebnikov dquots = i_dquot(inode); 14555bcd3b6fSKonstantin Khlebnikov 1456884d179dSJan Kara /* First get references to structures we might need. */ 1457884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1458aca645a6SEric W. Biederman struct kqid qid; 1459847aac64SLi Xi kprojid_t projid; 1460847aac64SLi Xi int rc; 14616184fc0bSJan Kara struct dquot *dquot; 1462847aac64SLi Xi 1463884d179dSJan Kara if (type != -1 && cnt != type) 1464884d179dSJan Kara continue; 14651ea06becSNiu Yawei /* 14661ea06becSNiu Yawei * The i_dquot should have been initialized in most cases, 14671ea06becSNiu Yawei * we check it without locking here to avoid unnecessary 14681ea06becSNiu Yawei * dqget()/dqput() calls. 14691ea06becSNiu Yawei */ 14705bcd3b6fSKonstantin Khlebnikov if (dquots[cnt]) 14711ea06becSNiu Yawei continue; 1472847aac64SLi Xi 1473847aac64SLi Xi if (!sb_has_quota_active(sb, cnt)) 1474847aac64SLi Xi continue; 1475847aac64SLi Xi 14761ea06becSNiu Yawei init_needed = 1; 14771ea06becSNiu Yawei 1478884d179dSJan Kara switch (cnt) { 1479884d179dSJan Kara case USRQUOTA: 1480aca645a6SEric W. Biederman qid = make_kqid_uid(inode->i_uid); 1481884d179dSJan Kara break; 1482884d179dSJan Kara case GRPQUOTA: 1483aca645a6SEric W. Biederman qid = make_kqid_gid(inode->i_gid); 1484884d179dSJan Kara break; 1485847aac64SLi Xi case PRJQUOTA: 1486847aac64SLi Xi rc = inode->i_sb->dq_op->get_projid(inode, &projid); 1487847aac64SLi Xi if (rc) 1488847aac64SLi Xi continue; 1489847aac64SLi Xi qid = make_kqid_projid(projid); 1490847aac64SLi Xi break; 1491884d179dSJan Kara } 14926184fc0bSJan Kara dquot = dqget(sb, qid); 14936184fc0bSJan Kara if (IS_ERR(dquot)) { 14946184fc0bSJan Kara /* We raced with somebody turning quotas off... */ 14956184fc0bSJan Kara if (PTR_ERR(dquot) != -ESRCH) { 14966184fc0bSJan Kara ret = PTR_ERR(dquot); 14976184fc0bSJan Kara goto out_put; 14986184fc0bSJan Kara } 14996184fc0bSJan Kara dquot = NULL; 15006184fc0bSJan Kara } 15016184fc0bSJan Kara got[cnt] = dquot; 1502884d179dSJan Kara } 1503884d179dSJan Kara 15041ea06becSNiu Yawei /* All required i_dquot has been initialized */ 15051ea06becSNiu Yawei if (!init_needed) 15066184fc0bSJan Kara return 0; 15071ea06becSNiu Yawei 1508b9ba6f94SNiu Yawei spin_lock(&dq_data_lock); 1509884d179dSJan Kara if (IS_NOQUOTA(inode)) 15106184fc0bSJan Kara goto out_lock; 1511884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1512884d179dSJan Kara if (type != -1 && cnt != type) 1513884d179dSJan Kara continue; 1514884d179dSJan Kara /* Avoid races with quotaoff() */ 1515884d179dSJan Kara if (!sb_has_quota_active(sb, cnt)) 1516884d179dSJan Kara continue; 15174408ea41SJan Kara /* We could race with quotaon or dqget() could have failed */ 15184408ea41SJan Kara if (!got[cnt]) 15194408ea41SJan Kara continue; 15205bcd3b6fSKonstantin Khlebnikov if (!dquots[cnt]) { 15215bcd3b6fSKonstantin Khlebnikov dquots[cnt] = got[cnt]; 1522dd6f3c6dSJan Kara got[cnt] = NULL; 15230a5a9c72SJan Kara /* 15240a5a9c72SJan Kara * Make quota reservation system happy if someone 15250a5a9c72SJan Kara * did a write before quota was turned on 15260a5a9c72SJan Kara */ 15270a5a9c72SJan Kara rsv = inode_get_rsv_space(inode); 15287b9ca4c6SJan Kara if (unlikely(rsv)) { 15297b9ca4c6SJan Kara spin_lock(&inode->i_lock); 15307b9ca4c6SJan Kara /* Get reservation again under proper lock */ 15317b9ca4c6SJan Kara rsv = __inode_get_rsv_space(inode); 15327b9ca4c6SJan Kara spin_lock(&dquots[cnt]->dq_dqb_lock); 15337b9ca4c6SJan Kara dquots[cnt]->dq_dqb.dqb_rsvspace += rsv; 15347b9ca4c6SJan Kara spin_unlock(&dquots[cnt]->dq_dqb_lock); 15357b9ca4c6SJan Kara spin_unlock(&inode->i_lock); 15367b9ca4c6SJan Kara } 1537884d179dSJan Kara } 1538884d179dSJan Kara } 15396184fc0bSJan Kara out_lock: 1540b9ba6f94SNiu Yawei spin_unlock(&dq_data_lock); 15416184fc0bSJan Kara out_put: 1542884d179dSJan Kara /* Drop unused references */ 1543dc52dd3aSDmitry Monakhov dqput_all(got); 15446184fc0bSJan Kara 15456184fc0bSJan Kara return ret; 1546871a2931SChristoph Hellwig } 1547871a2931SChristoph Hellwig 15486184fc0bSJan Kara int dquot_initialize(struct inode *inode) 1549871a2931SChristoph Hellwig { 15506184fc0bSJan Kara return __dquot_initialize(inode, -1); 1551884d179dSJan Kara } 1552884d179dSJan Kara EXPORT_SYMBOL(dquot_initialize); 1553884d179dSJan Kara 1554b8cb5a54STahsin Erdogan bool dquot_initialize_needed(struct inode *inode) 1555b8cb5a54STahsin Erdogan { 1556b8cb5a54STahsin Erdogan struct dquot **dquots; 1557b8cb5a54STahsin Erdogan int i; 1558b8cb5a54STahsin Erdogan 1559b8cb5a54STahsin Erdogan if (!dquot_active(inode)) 1560b8cb5a54STahsin Erdogan return false; 1561b8cb5a54STahsin Erdogan 1562b8cb5a54STahsin Erdogan dquots = i_dquot(inode); 1563b8cb5a54STahsin Erdogan for (i = 0; i < MAXQUOTAS; i++) 1564b8cb5a54STahsin Erdogan if (!dquots[i] && sb_has_quota_active(inode->i_sb, i)) 1565b8cb5a54STahsin Erdogan return true; 1566b8cb5a54STahsin Erdogan return false; 1567b8cb5a54STahsin Erdogan } 1568b8cb5a54STahsin Erdogan EXPORT_SYMBOL(dquot_initialize_needed); 1569b8cb5a54STahsin Erdogan 1570884d179dSJan Kara /* 1571b9ba6f94SNiu Yawei * Release all quotas referenced by inode. 1572b9ba6f94SNiu Yawei * 1573b9ba6f94SNiu Yawei * This function only be called on inode free or converting 1574b9ba6f94SNiu Yawei * a file to quota file, no other users for the i_dquot in 1575b9ba6f94SNiu Yawei * both cases, so we needn't call synchronize_srcu() after 1576b9ba6f94SNiu Yawei * clearing i_dquot. 1577884d179dSJan Kara */ 15789f754758SChristoph Hellwig static void __dquot_drop(struct inode *inode) 1579884d179dSJan Kara { 1580884d179dSJan Kara int cnt; 15815bcd3b6fSKonstantin Khlebnikov struct dquot **dquots = i_dquot(inode); 1582884d179dSJan Kara struct dquot *put[MAXQUOTAS]; 1583884d179dSJan Kara 1584b9ba6f94SNiu Yawei spin_lock(&dq_data_lock); 1585884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 15865bcd3b6fSKonstantin Khlebnikov put[cnt] = dquots[cnt]; 15875bcd3b6fSKonstantin Khlebnikov dquots[cnt] = NULL; 1588884d179dSJan Kara } 1589b9ba6f94SNiu Yawei spin_unlock(&dq_data_lock); 1590dc52dd3aSDmitry Monakhov dqput_all(put); 1591884d179dSJan Kara } 1592884d179dSJan Kara 15939f754758SChristoph Hellwig void dquot_drop(struct inode *inode) 1594884d179dSJan Kara { 15955bcd3b6fSKonstantin Khlebnikov struct dquot * const *dquots; 1596884d179dSJan Kara int cnt; 15979f754758SChristoph Hellwig 15989f754758SChristoph Hellwig if (IS_NOQUOTA(inode)) 15999f754758SChristoph Hellwig return; 16009f754758SChristoph Hellwig 16019f754758SChristoph Hellwig /* 16029f754758SChristoph Hellwig * Test before calling to rule out calls from proc and such 1603884d179dSJan Kara * where we are not allowed to block. Note that this is 1604884d179dSJan Kara * actually reliable test even without the lock - the caller 1605884d179dSJan Kara * must assure that nobody can come after the DQUOT_DROP and 16069f754758SChristoph Hellwig * add quota pointers back anyway. 16079f754758SChristoph Hellwig */ 16085bcd3b6fSKonstantin Khlebnikov dquots = i_dquot(inode); 16099f754758SChristoph Hellwig for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 16105bcd3b6fSKonstantin Khlebnikov if (dquots[cnt]) 1611884d179dSJan Kara break; 16129f754758SChristoph Hellwig } 16139f754758SChristoph Hellwig 1614884d179dSJan Kara if (cnt < MAXQUOTAS) 16159f754758SChristoph Hellwig __dquot_drop(inode); 1616884d179dSJan Kara } 16179f754758SChristoph Hellwig EXPORT_SYMBOL(dquot_drop); 1618884d179dSJan Kara 1619884d179dSJan Kara /* 1620fd8fbfc1SDmitry Monakhov * inode_reserved_space is managed internally by quota, and protected by 1621fd8fbfc1SDmitry Monakhov * i_lock similar to i_blocks+i_bytes. 1622fd8fbfc1SDmitry Monakhov */ 1623fd8fbfc1SDmitry Monakhov static qsize_t *inode_reserved_space(struct inode * inode) 1624fd8fbfc1SDmitry Monakhov { 1625fd8fbfc1SDmitry Monakhov /* Filesystem must explicitly define it's own method in order to use 1626fd8fbfc1SDmitry Monakhov * quota reservation interface */ 1627fd8fbfc1SDmitry Monakhov BUG_ON(!inode->i_sb->dq_op->get_reserved_space); 1628fd8fbfc1SDmitry Monakhov return inode->i_sb->dq_op->get_reserved_space(inode); 1629fd8fbfc1SDmitry Monakhov } 1630fd8fbfc1SDmitry Monakhov 16317b9ca4c6SJan Kara static qsize_t __inode_get_rsv_space(struct inode *inode) 1632fd8fbfc1SDmitry Monakhov { 16337b9ca4c6SJan Kara if (!inode->i_sb->dq_op->get_reserved_space) 16347b9ca4c6SJan Kara return 0; 16357b9ca4c6SJan Kara return *inode_reserved_space(inode); 1636fd8fbfc1SDmitry Monakhov } 1637fd8fbfc1SDmitry Monakhov 1638fd8fbfc1SDmitry Monakhov static qsize_t inode_get_rsv_space(struct inode *inode) 1639fd8fbfc1SDmitry Monakhov { 1640fd8fbfc1SDmitry Monakhov qsize_t ret; 164105b5d898SJan Kara 164205b5d898SJan Kara if (!inode->i_sb->dq_op->get_reserved_space) 164305b5d898SJan Kara return 0; 1644fd8fbfc1SDmitry Monakhov spin_lock(&inode->i_lock); 16457b9ca4c6SJan Kara ret = __inode_get_rsv_space(inode); 1646fd8fbfc1SDmitry Monakhov spin_unlock(&inode->i_lock); 1647fd8fbfc1SDmitry Monakhov return ret; 1648fd8fbfc1SDmitry Monakhov } 1649fd8fbfc1SDmitry Monakhov 1650fd8fbfc1SDmitry Monakhov /* 16515dd4056dSChristoph Hellwig * This functions updates i_blocks+i_bytes fields and quota information 16525dd4056dSChristoph Hellwig * (together with appropriate checks). 16535dd4056dSChristoph Hellwig * 16545dd4056dSChristoph Hellwig * NOTE: We absolutely rely on the fact that caller dirties the inode 16555dd4056dSChristoph Hellwig * (usually helpers in quotaops.h care about this) and holds a handle for 16565dd4056dSChristoph Hellwig * the current transaction so that dquot write and inode write go into the 16575dd4056dSChristoph Hellwig * same transaction. 1658884d179dSJan Kara */ 1659884d179dSJan Kara 1660884d179dSJan Kara /* 1661884d179dSJan Kara * This operation can block, but only after everything is updated 1662884d179dSJan Kara */ 166356246f9aSEric Sandeen int __dquot_alloc_space(struct inode *inode, qsize_t number, int flags) 1664884d179dSJan Kara { 1665b9ba6f94SNiu Yawei int cnt, ret = 0, index; 1666bf097aafSJan Kara struct dquot_warn warn[MAXQUOTAS]; 166756246f9aSEric Sandeen int reserve = flags & DQUOT_SPACE_RESERVE; 16685bcd3b6fSKonstantin Khlebnikov struct dquot **dquots; 1669884d179dSJan Kara 1670189eef59SChristoph Hellwig if (!dquot_active(inode)) { 1671a478e522SJan Kara if (reserve) { 1672a478e522SJan Kara spin_lock(&inode->i_lock); 1673a478e522SJan Kara *inode_reserved_space(inode) += number; 1674a478e522SJan Kara spin_unlock(&inode->i_lock); 1675a478e522SJan Kara } else { 1676a478e522SJan Kara inode_add_bytes(inode, number); 1677a478e522SJan Kara } 1678fd8fbfc1SDmitry Monakhov goto out; 1679fd8fbfc1SDmitry Monakhov } 1680fd8fbfc1SDmitry Monakhov 1681884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) 1682bf097aafSJan Kara warn[cnt].w_type = QUOTA_NL_NOWARN; 1683884d179dSJan Kara 16845bcd3b6fSKonstantin Khlebnikov dquots = i_dquot(inode); 1685b9ba6f94SNiu Yawei index = srcu_read_lock(&dquot_srcu); 16867b9ca4c6SJan Kara spin_lock(&inode->i_lock); 1687884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1688bf097aafSJan Kara if (!dquots[cnt]) 1689884d179dSJan Kara continue; 1690df15a2a5SChengguang Xu if (reserve) { 16917b9ca4c6SJan Kara ret = dquot_add_space(dquots[cnt], 0, number, flags, 16927b9ca4c6SJan Kara &warn[cnt]); 16937b9ca4c6SJan Kara } else { 16947b9ca4c6SJan Kara ret = dquot_add_space(dquots[cnt], number, 0, flags, 16957b9ca4c6SJan Kara &warn[cnt]); 16967b9ca4c6SJan Kara } 16977b9ca4c6SJan Kara if (ret) { 16987b9ca4c6SJan Kara /* Back out changes we already did */ 16997b9ca4c6SJan Kara for (cnt--; cnt >= 0; cnt--) { 17007b9ca4c6SJan Kara if (!dquots[cnt]) 17017b9ca4c6SJan Kara continue; 17027b9ca4c6SJan Kara spin_lock(&dquots[cnt]->dq_dqb_lock); 1703632a9f3aSChengguang Xu if (reserve) 1704632a9f3aSChengguang Xu dquot_free_reserved_space(dquots[cnt], 1705632a9f3aSChengguang Xu number); 1706632a9f3aSChengguang Xu else 1707632a9f3aSChengguang Xu dquot_decr_space(dquots[cnt], number); 17087b9ca4c6SJan Kara spin_unlock(&dquots[cnt]->dq_dqb_lock); 17097b9ca4c6SJan Kara } 17107b9ca4c6SJan Kara spin_unlock(&inode->i_lock); 1711fd8fbfc1SDmitry Monakhov goto out_flush_warn; 1712884d179dSJan Kara } 1713884d179dSJan Kara } 1714884d179dSJan Kara if (reserve) 1715a478e522SJan Kara *inode_reserved_space(inode) += number; 1716884d179dSJan Kara else 17177b9ca4c6SJan Kara __inode_add_bytes(inode, number); 1718a478e522SJan Kara spin_unlock(&inode->i_lock); 1719fd8fbfc1SDmitry Monakhov 1720fd8fbfc1SDmitry Monakhov if (reserve) 1721fd8fbfc1SDmitry Monakhov goto out_flush_warn; 1722bf097aafSJan Kara mark_all_dquot_dirty(dquots); 1723fd8fbfc1SDmitry Monakhov out_flush_warn: 1724b9ba6f94SNiu Yawei srcu_read_unlock(&dquot_srcu, index); 1725bf097aafSJan Kara flush_warnings(warn); 1726fd8fbfc1SDmitry Monakhov out: 1727884d179dSJan Kara return ret; 1728884d179dSJan Kara } 17295dd4056dSChristoph Hellwig EXPORT_SYMBOL(__dquot_alloc_space); 1730884d179dSJan Kara 1731884d179dSJan Kara /* 1732884d179dSJan Kara * This operation can block, but only after everything is updated 1733884d179dSJan Kara */ 17346bab3596SJan Kara int dquot_alloc_inode(struct inode *inode) 1735884d179dSJan Kara { 1736b9ba6f94SNiu Yawei int cnt, ret = 0, index; 1737bf097aafSJan Kara struct dquot_warn warn[MAXQUOTAS]; 17385bcd3b6fSKonstantin Khlebnikov struct dquot * const *dquots; 1739884d179dSJan Kara 1740189eef59SChristoph Hellwig if (!dquot_active(inode)) 174163936ddaSChristoph Hellwig return 0; 1742884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) 1743bf097aafSJan Kara warn[cnt].w_type = QUOTA_NL_NOWARN; 1744b9ba6f94SNiu Yawei 17455bcd3b6fSKonstantin Khlebnikov dquots = i_dquot(inode); 1746b9ba6f94SNiu Yawei index = srcu_read_lock(&dquot_srcu); 17477b9ca4c6SJan Kara spin_lock(&inode->i_lock); 1748884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1749bf097aafSJan Kara if (!dquots[cnt]) 1750884d179dSJan Kara continue; 17517b9ca4c6SJan Kara ret = dquot_add_inodes(dquots[cnt], 1, &warn[cnt]); 17527b9ca4c6SJan Kara if (ret) { 17537b9ca4c6SJan Kara for (cnt--; cnt >= 0; cnt--) { 17547b9ca4c6SJan Kara if (!dquots[cnt]) 17557b9ca4c6SJan Kara continue; 17567b9ca4c6SJan Kara /* Back out changes we already did */ 17577b9ca4c6SJan Kara spin_lock(&dquots[cnt]->dq_dqb_lock); 1758632a9f3aSChengguang Xu dquot_decr_inodes(dquots[cnt], 1); 17597b9ca4c6SJan Kara spin_unlock(&dquots[cnt]->dq_dqb_lock); 17607b9ca4c6SJan Kara } 1761884d179dSJan Kara goto warn_put_all; 1762884d179dSJan Kara } 1763884d179dSJan Kara } 1764efd8f0e6SChristoph Hellwig 1765884d179dSJan Kara warn_put_all: 17667b9ca4c6SJan Kara spin_unlock(&inode->i_lock); 176763936ddaSChristoph Hellwig if (ret == 0) 1768bf097aafSJan Kara mark_all_dquot_dirty(dquots); 1769b9ba6f94SNiu Yawei srcu_read_unlock(&dquot_srcu, index); 1770bf097aafSJan Kara flush_warnings(warn); 1771884d179dSJan Kara return ret; 1772884d179dSJan Kara } 1773884d179dSJan Kara EXPORT_SYMBOL(dquot_alloc_inode); 1774884d179dSJan Kara 17755dd4056dSChristoph Hellwig /* 17765dd4056dSChristoph Hellwig * Convert in-memory reserved quotas to real consumed quotas 17775dd4056dSChristoph Hellwig */ 17785dd4056dSChristoph Hellwig int dquot_claim_space_nodirty(struct inode *inode, qsize_t number) 1779884d179dSJan Kara { 17805bcd3b6fSKonstantin Khlebnikov struct dquot **dquots; 1781b9ba6f94SNiu Yawei int cnt, index; 1782884d179dSJan Kara 1783189eef59SChristoph Hellwig if (!dquot_active(inode)) { 17840ed60de3SJan Kara spin_lock(&inode->i_lock); 17850ed60de3SJan Kara *inode_reserved_space(inode) -= number; 17860ed60de3SJan Kara __inode_add_bytes(inode, number); 17870ed60de3SJan Kara spin_unlock(&inode->i_lock); 17885dd4056dSChristoph Hellwig return 0; 1789884d179dSJan Kara } 1790884d179dSJan Kara 17915bcd3b6fSKonstantin Khlebnikov dquots = i_dquot(inode); 1792b9ba6f94SNiu Yawei index = srcu_read_lock(&dquot_srcu); 17937b9ca4c6SJan Kara spin_lock(&inode->i_lock); 1794884d179dSJan Kara /* Claim reserved quotas to allocated quotas */ 1795884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 17963ab167d2SJan Kara if (dquots[cnt]) { 17973ab167d2SJan Kara struct dquot *dquot = dquots[cnt]; 17983ab167d2SJan Kara 17997b9ca4c6SJan Kara spin_lock(&dquot->dq_dqb_lock); 18003ab167d2SJan Kara if (WARN_ON_ONCE(dquot->dq_dqb.dqb_rsvspace < number)) 18013ab167d2SJan Kara number = dquot->dq_dqb.dqb_rsvspace; 18023ab167d2SJan Kara dquot->dq_dqb.dqb_curspace += number; 18033ab167d2SJan Kara dquot->dq_dqb.dqb_rsvspace -= number; 18047b9ca4c6SJan Kara spin_unlock(&dquot->dq_dqb_lock); 18053ab167d2SJan Kara } 1806884d179dSJan Kara } 1807884d179dSJan Kara /* Update inode bytes */ 18080ed60de3SJan Kara *inode_reserved_space(inode) -= number; 18090ed60de3SJan Kara __inode_add_bytes(inode, number); 18100ed60de3SJan Kara spin_unlock(&inode->i_lock); 18115bcd3b6fSKonstantin Khlebnikov mark_all_dquot_dirty(dquots); 1812b9ba6f94SNiu Yawei srcu_read_unlock(&dquot_srcu, index); 18135dd4056dSChristoph Hellwig return 0; 1814884d179dSJan Kara } 18155dd4056dSChristoph Hellwig EXPORT_SYMBOL(dquot_claim_space_nodirty); 1816884d179dSJan Kara 1817884d179dSJan Kara /* 18181c8924ebSJan Kara * Convert allocated space back to in-memory reserved quotas 18191c8924ebSJan Kara */ 18201c8924ebSJan Kara void dquot_reclaim_space_nodirty(struct inode *inode, qsize_t number) 18211c8924ebSJan Kara { 18225bcd3b6fSKonstantin Khlebnikov struct dquot **dquots; 1823b9ba6f94SNiu Yawei int cnt, index; 18241c8924ebSJan Kara 18251c8924ebSJan Kara if (!dquot_active(inode)) { 18260ed60de3SJan Kara spin_lock(&inode->i_lock); 18270ed60de3SJan Kara *inode_reserved_space(inode) += number; 18280ed60de3SJan Kara __inode_sub_bytes(inode, number); 18290ed60de3SJan Kara spin_unlock(&inode->i_lock); 18301c8924ebSJan Kara return; 18311c8924ebSJan Kara } 18321c8924ebSJan Kara 18335bcd3b6fSKonstantin Khlebnikov dquots = i_dquot(inode); 1834b9ba6f94SNiu Yawei index = srcu_read_lock(&dquot_srcu); 18357b9ca4c6SJan Kara spin_lock(&inode->i_lock); 18361c8924ebSJan Kara /* Claim reserved quotas to allocated quotas */ 18371c8924ebSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 18383ab167d2SJan Kara if (dquots[cnt]) { 18393ab167d2SJan Kara struct dquot *dquot = dquots[cnt]; 18403ab167d2SJan Kara 18417b9ca4c6SJan Kara spin_lock(&dquot->dq_dqb_lock); 18423ab167d2SJan Kara if (WARN_ON_ONCE(dquot->dq_dqb.dqb_curspace < number)) 18433ab167d2SJan Kara number = dquot->dq_dqb.dqb_curspace; 18443ab167d2SJan Kara dquot->dq_dqb.dqb_rsvspace += number; 18453ab167d2SJan Kara dquot->dq_dqb.dqb_curspace -= number; 18467b9ca4c6SJan Kara spin_unlock(&dquot->dq_dqb_lock); 18473ab167d2SJan Kara } 18481c8924ebSJan Kara } 18491c8924ebSJan Kara /* Update inode bytes */ 18500ed60de3SJan Kara *inode_reserved_space(inode) += number; 18510ed60de3SJan Kara __inode_sub_bytes(inode, number); 18520ed60de3SJan Kara spin_unlock(&inode->i_lock); 18535bcd3b6fSKonstantin Khlebnikov mark_all_dquot_dirty(dquots); 1854b9ba6f94SNiu Yawei srcu_read_unlock(&dquot_srcu, index); 18551c8924ebSJan Kara return; 18561c8924ebSJan Kara } 18571c8924ebSJan Kara EXPORT_SYMBOL(dquot_reclaim_space_nodirty); 18581c8924ebSJan Kara 18591c8924ebSJan Kara /* 1860884d179dSJan Kara * This operation can block, but only after everything is updated 1861884d179dSJan Kara */ 186256246f9aSEric Sandeen void __dquot_free_space(struct inode *inode, qsize_t number, int flags) 1863884d179dSJan Kara { 1864884d179dSJan Kara unsigned int cnt; 1865bf097aafSJan Kara struct dquot_warn warn[MAXQUOTAS]; 18665bcd3b6fSKonstantin Khlebnikov struct dquot **dquots; 1867b9ba6f94SNiu Yawei int reserve = flags & DQUOT_SPACE_RESERVE, index; 1868884d179dSJan Kara 1869189eef59SChristoph Hellwig if (!dquot_active(inode)) { 1870a478e522SJan Kara if (reserve) { 1871a478e522SJan Kara spin_lock(&inode->i_lock); 1872a478e522SJan Kara *inode_reserved_space(inode) -= number; 1873a478e522SJan Kara spin_unlock(&inode->i_lock); 1874a478e522SJan Kara } else { 1875a478e522SJan Kara inode_sub_bytes(inode, number); 1876a478e522SJan Kara } 18775dd4056dSChristoph Hellwig return; 1878884d179dSJan Kara } 1879884d179dSJan Kara 18805bcd3b6fSKonstantin Khlebnikov dquots = i_dquot(inode); 1881b9ba6f94SNiu Yawei index = srcu_read_lock(&dquot_srcu); 18827b9ca4c6SJan Kara spin_lock(&inode->i_lock); 1883884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1884bf097aafSJan Kara int wtype; 1885bf097aafSJan Kara 1886bf097aafSJan Kara warn[cnt].w_type = QUOTA_NL_NOWARN; 1887bf097aafSJan Kara if (!dquots[cnt]) 1888884d179dSJan Kara continue; 18897b9ca4c6SJan Kara spin_lock(&dquots[cnt]->dq_dqb_lock); 1890bf097aafSJan Kara wtype = info_bdq_free(dquots[cnt], number); 1891bf097aafSJan Kara if (wtype != QUOTA_NL_NOWARN) 1892bf097aafSJan Kara prepare_warning(&warn[cnt], dquots[cnt], wtype); 1893fd8fbfc1SDmitry Monakhov if (reserve) 1894bf097aafSJan Kara dquot_free_reserved_space(dquots[cnt], number); 1895fd8fbfc1SDmitry Monakhov else 1896bf097aafSJan Kara dquot_decr_space(dquots[cnt], number); 18977b9ca4c6SJan Kara spin_unlock(&dquots[cnt]->dq_dqb_lock); 1898884d179dSJan Kara } 18997b9ca4c6SJan Kara if (reserve) 1900a478e522SJan Kara *inode_reserved_space(inode) -= number; 19017b9ca4c6SJan Kara else 19027b9ca4c6SJan Kara __inode_sub_bytes(inode, number); 1903a478e522SJan Kara spin_unlock(&inode->i_lock); 1904fd8fbfc1SDmitry Monakhov 1905fd8fbfc1SDmitry Monakhov if (reserve) 1906fd8fbfc1SDmitry Monakhov goto out_unlock; 1907bf097aafSJan Kara mark_all_dquot_dirty(dquots); 1908fd8fbfc1SDmitry Monakhov out_unlock: 1909b9ba6f94SNiu Yawei srcu_read_unlock(&dquot_srcu, index); 1910bf097aafSJan Kara flush_warnings(warn); 1911884d179dSJan Kara } 19125dd4056dSChristoph Hellwig EXPORT_SYMBOL(__dquot_free_space); 1913fd8fbfc1SDmitry Monakhov 1914fd8fbfc1SDmitry Monakhov /* 1915884d179dSJan Kara * This operation can block, but only after everything is updated 1916884d179dSJan Kara */ 19176bab3596SJan Kara void dquot_free_inode(struct inode *inode) 1918884d179dSJan Kara { 1919884d179dSJan Kara unsigned int cnt; 1920bf097aafSJan Kara struct dquot_warn warn[MAXQUOTAS]; 19215bcd3b6fSKonstantin Khlebnikov struct dquot * const *dquots; 1922b9ba6f94SNiu Yawei int index; 1923884d179dSJan Kara 1924189eef59SChristoph Hellwig if (!dquot_active(inode)) 192563936ddaSChristoph Hellwig return; 1926884d179dSJan Kara 19275bcd3b6fSKonstantin Khlebnikov dquots = i_dquot(inode); 1928b9ba6f94SNiu Yawei index = srcu_read_lock(&dquot_srcu); 19297b9ca4c6SJan Kara spin_lock(&inode->i_lock); 1930884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1931bf097aafSJan Kara int wtype; 1932bf097aafSJan Kara 1933bf097aafSJan Kara warn[cnt].w_type = QUOTA_NL_NOWARN; 1934bf097aafSJan Kara if (!dquots[cnt]) 1935884d179dSJan Kara continue; 19367b9ca4c6SJan Kara spin_lock(&dquots[cnt]->dq_dqb_lock); 1937bf097aafSJan Kara wtype = info_idq_free(dquots[cnt], 1); 1938bf097aafSJan Kara if (wtype != QUOTA_NL_NOWARN) 1939bf097aafSJan Kara prepare_warning(&warn[cnt], dquots[cnt], wtype); 1940bf097aafSJan Kara dquot_decr_inodes(dquots[cnt], 1); 19417b9ca4c6SJan Kara spin_unlock(&dquots[cnt]->dq_dqb_lock); 1942884d179dSJan Kara } 19437b9ca4c6SJan Kara spin_unlock(&inode->i_lock); 1944bf097aafSJan Kara mark_all_dquot_dirty(dquots); 1945b9ba6f94SNiu Yawei srcu_read_unlock(&dquot_srcu, index); 1946bf097aafSJan Kara flush_warnings(warn); 1947884d179dSJan Kara } 1948884d179dSJan Kara EXPORT_SYMBOL(dquot_free_inode); 1949884d179dSJan Kara 1950884d179dSJan Kara /* 1951884d179dSJan Kara * Transfer the number of inode and blocks from one diskquota to an other. 1952bc8e5f07SJan Kara * On success, dquot references in transfer_to are consumed and references 1953bc8e5f07SJan Kara * to original dquots that need to be released are placed there. On failure, 1954bc8e5f07SJan Kara * references are kept untouched. 1955884d179dSJan Kara * 1956884d179dSJan Kara * This operation can block, but only after everything is updated 1957884d179dSJan Kara * A transaction must be started when entering this function. 1958bc8e5f07SJan Kara * 1959b9ba6f94SNiu Yawei * We are holding reference on transfer_from & transfer_to, no need to 1960b9ba6f94SNiu Yawei * protect them by srcu_read_lock(). 1961884d179dSJan Kara */ 1962bc8e5f07SJan Kara int __dquot_transfer(struct inode *inode, struct dquot **transfer_to) 1963884d179dSJan Kara { 19647b9ca4c6SJan Kara qsize_t cur_space; 1965884d179dSJan Kara qsize_t rsv_space = 0; 19667a9ca53aSTahsin Erdogan qsize_t inode_usage = 1; 1967bc8e5f07SJan Kara struct dquot *transfer_from[MAXQUOTAS] = {}; 1968efd8f0e6SChristoph Hellwig int cnt, ret = 0; 19699e32784bSDmitry char is_valid[MAXQUOTAS] = {}; 1970bf097aafSJan Kara struct dquot_warn warn_to[MAXQUOTAS]; 1971bf097aafSJan Kara struct dquot_warn warn_from_inodes[MAXQUOTAS]; 1972bf097aafSJan Kara struct dquot_warn warn_from_space[MAXQUOTAS]; 1973884d179dSJan Kara 1974884d179dSJan Kara if (IS_NOQUOTA(inode)) 1975efd8f0e6SChristoph Hellwig return 0; 19767a9ca53aSTahsin Erdogan 19777a9ca53aSTahsin Erdogan if (inode->i_sb->dq_op->get_inode_usage) { 19787a9ca53aSTahsin Erdogan ret = inode->i_sb->dq_op->get_inode_usage(inode, &inode_usage); 19797a9ca53aSTahsin Erdogan if (ret) 19807a9ca53aSTahsin Erdogan return ret; 19817a9ca53aSTahsin Erdogan } 19827a9ca53aSTahsin Erdogan 1983884d179dSJan Kara /* Initialize the arrays */ 1984bf097aafSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1985bf097aafSJan Kara warn_to[cnt].w_type = QUOTA_NL_NOWARN; 1986bf097aafSJan Kara warn_from_inodes[cnt].w_type = QUOTA_NL_NOWARN; 1987bf097aafSJan Kara warn_from_space[cnt].w_type = QUOTA_NL_NOWARN; 1988bf097aafSJan Kara } 1989b9ba6f94SNiu Yawei 1990b9ba6f94SNiu Yawei spin_lock(&dq_data_lock); 19917b9ca4c6SJan Kara spin_lock(&inode->i_lock); 1992884d179dSJan Kara if (IS_NOQUOTA(inode)) { /* File without quota accounting? */ 19937b9ca4c6SJan Kara spin_unlock(&inode->i_lock); 1994b9ba6f94SNiu Yawei spin_unlock(&dq_data_lock); 1995bc8e5f07SJan Kara return 0; 1996884d179dSJan Kara } 19977b9ca4c6SJan Kara cur_space = __inode_get_bytes(inode); 19987b9ca4c6SJan Kara rsv_space = __inode_get_rsv_space(inode); 19997b9ca4c6SJan Kara /* 20007b9ca4c6SJan Kara * Build the transfer_from list, check limits, and update usage in 20017b9ca4c6SJan Kara * the target structures. 20027b9ca4c6SJan Kara */ 2003884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 20049e32784bSDmitry /* 20059e32784bSDmitry * Skip changes for same uid or gid or for turned off quota-type. 20069e32784bSDmitry */ 2007dd6f3c6dSJan Kara if (!transfer_to[cnt]) 2008884d179dSJan Kara continue; 20099e32784bSDmitry /* Avoid races with quotaoff() */ 20109e32784bSDmitry if (!sb_has_quota_active(inode->i_sb, cnt)) 20119e32784bSDmitry continue; 20129e32784bSDmitry is_valid[cnt] = 1; 20132d0fa467SJan Kara transfer_from[cnt] = i_dquot(inode)[cnt]; 20147b9ca4c6SJan Kara ret = dquot_add_inodes(transfer_to[cnt], inode_usage, 20157b9ca4c6SJan Kara &warn_to[cnt]); 2016efd8f0e6SChristoph Hellwig if (ret) 2017efd8f0e6SChristoph Hellwig goto over_quota; 2018c6d9c35dSyangerkun ret = dquot_add_space(transfer_to[cnt], cur_space, rsv_space, 2019c6d9c35dSyangerkun DQUOT_SPACE_WARN, &warn_to[cnt]); 20207b9ca4c6SJan Kara if (ret) { 20210a51fb71SKonstantin Khlebnikov spin_lock(&transfer_to[cnt]->dq_dqb_lock); 20227b9ca4c6SJan Kara dquot_decr_inodes(transfer_to[cnt], inode_usage); 20230a51fb71SKonstantin Khlebnikov spin_unlock(&transfer_to[cnt]->dq_dqb_lock); 2024884d179dSJan Kara goto over_quota; 2025884d179dSJan Kara } 20267b9ca4c6SJan Kara } 2027884d179dSJan Kara 20287b9ca4c6SJan Kara /* Decrease usage for source structures and update quota pointers */ 2029884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 20309e32784bSDmitry if (!is_valid[cnt]) 2031884d179dSJan Kara continue; 2032884d179dSJan Kara /* Due to IO error we might not have transfer_from[] structure */ 2033884d179dSJan Kara if (transfer_from[cnt]) { 2034bf097aafSJan Kara int wtype; 20357b9ca4c6SJan Kara 20367b9ca4c6SJan Kara spin_lock(&transfer_from[cnt]->dq_dqb_lock); 20377a9ca53aSTahsin Erdogan wtype = info_idq_free(transfer_from[cnt], inode_usage); 2038bf097aafSJan Kara if (wtype != QUOTA_NL_NOWARN) 2039bf097aafSJan Kara prepare_warning(&warn_from_inodes[cnt], 2040bf097aafSJan Kara transfer_from[cnt], wtype); 20417b9ca4c6SJan Kara wtype = info_bdq_free(transfer_from[cnt], 20427b9ca4c6SJan Kara cur_space + rsv_space); 2043bf097aafSJan Kara if (wtype != QUOTA_NL_NOWARN) 2044bf097aafSJan Kara prepare_warning(&warn_from_space[cnt], 2045bf097aafSJan Kara transfer_from[cnt], wtype); 20467a9ca53aSTahsin Erdogan dquot_decr_inodes(transfer_from[cnt], inode_usage); 2047884d179dSJan Kara dquot_decr_space(transfer_from[cnt], cur_space); 2048884d179dSJan Kara dquot_free_reserved_space(transfer_from[cnt], 2049884d179dSJan Kara rsv_space); 20507b9ca4c6SJan Kara spin_unlock(&transfer_from[cnt]->dq_dqb_lock); 2051884d179dSJan Kara } 20522d0fa467SJan Kara i_dquot(inode)[cnt] = transfer_to[cnt]; 2053884d179dSJan Kara } 20547b9ca4c6SJan Kara spin_unlock(&inode->i_lock); 2055884d179dSJan Kara spin_unlock(&dq_data_lock); 2056884d179dSJan Kara 2057dc52dd3aSDmitry Monakhov mark_all_dquot_dirty(transfer_from); 2058dc52dd3aSDmitry Monakhov mark_all_dquot_dirty(transfer_to); 2059bf097aafSJan Kara flush_warnings(warn_to); 2060bf097aafSJan Kara flush_warnings(warn_from_inodes); 2061bf097aafSJan Kara flush_warnings(warn_from_space); 2062bc8e5f07SJan Kara /* Pass back references to put */ 2063dc52dd3aSDmitry Monakhov for (cnt = 0; cnt < MAXQUOTAS; cnt++) 20649e32784bSDmitry if (is_valid[cnt]) 2065bc8e5f07SJan Kara transfer_to[cnt] = transfer_from[cnt]; 206686f3cbecSJan Kara return 0; 2067884d179dSJan Kara over_quota: 20687b9ca4c6SJan Kara /* Back out changes we already did */ 20697b9ca4c6SJan Kara for (cnt--; cnt >= 0; cnt--) { 20707b9ca4c6SJan Kara if (!is_valid[cnt]) 20717b9ca4c6SJan Kara continue; 20727b9ca4c6SJan Kara spin_lock(&transfer_to[cnt]->dq_dqb_lock); 20737b9ca4c6SJan Kara dquot_decr_inodes(transfer_to[cnt], inode_usage); 20747b9ca4c6SJan Kara dquot_decr_space(transfer_to[cnt], cur_space); 20757b9ca4c6SJan Kara dquot_free_reserved_space(transfer_to[cnt], rsv_space); 20767b9ca4c6SJan Kara spin_unlock(&transfer_to[cnt]->dq_dqb_lock); 20777b9ca4c6SJan Kara } 20787b9ca4c6SJan Kara spin_unlock(&inode->i_lock); 2079884d179dSJan Kara spin_unlock(&dq_data_lock); 2080bf097aafSJan Kara flush_warnings(warn_to); 208186f3cbecSJan Kara return ret; 2082884d179dSJan Kara } 2083bc8e5f07SJan Kara EXPORT_SYMBOL(__dquot_transfer); 2084884d179dSJan Kara 20858ddd69d6SDmitry Monakhov /* Wrapper for transferring ownership of an inode for uid/gid only 20868ddd69d6SDmitry Monakhov * Called from FSXXX_setattr() 20878ddd69d6SDmitry Monakhov */ 2088f861646aSChristian Brauner int dquot_transfer(struct mnt_idmap *idmap, struct inode *inode, 208971e7b535SChristian Brauner struct iattr *iattr) 2090884d179dSJan Kara { 2091f861646aSChristian Brauner struct user_namespace *mnt_userns = mnt_idmap_owner(idmap); 2092bc8e5f07SJan Kara struct dquot *transfer_to[MAXQUOTAS] = {}; 20936184fc0bSJan Kara struct dquot *dquot; 2094bc8e5f07SJan Kara struct super_block *sb = inode->i_sb; 2095bc8e5f07SJan Kara int ret; 20968ddd69d6SDmitry Monakhov 2097189eef59SChristoph Hellwig if (!dquot_active(inode)) 2098884d179dSJan Kara return 0; 2099bc8e5f07SJan Kara 2100*0dbe12f2SChristian Brauner if (i_uid_needs_update(idmap, iattr, inode)) { 2101b27c82e1SChristian Brauner kuid_t kuid = from_vfsuid(mnt_userns, i_user_ns(inode), 2102b27c82e1SChristian Brauner iattr->ia_vfsuid); 2103b27c82e1SChristian Brauner 2104b27c82e1SChristian Brauner dquot = dqget(sb, make_kqid_uid(kuid)); 21056184fc0bSJan Kara if (IS_ERR(dquot)) { 21066184fc0bSJan Kara if (PTR_ERR(dquot) != -ESRCH) { 21076184fc0bSJan Kara ret = PTR_ERR(dquot); 21086184fc0bSJan Kara goto out_put; 21096184fc0bSJan Kara } 21106184fc0bSJan Kara dquot = NULL; 21116184fc0bSJan Kara } 21126184fc0bSJan Kara transfer_to[USRQUOTA] = dquot; 21136184fc0bSJan Kara } 2114*0dbe12f2SChristian Brauner if (i_gid_needs_update(idmap, iattr, inode)) { 2115b27c82e1SChristian Brauner kgid_t kgid = from_vfsgid(mnt_userns, i_user_ns(inode), 2116b27c82e1SChristian Brauner iattr->ia_vfsgid); 2117b27c82e1SChristian Brauner 2118b27c82e1SChristian Brauner dquot = dqget(sb, make_kqid_gid(kgid)); 21196184fc0bSJan Kara if (IS_ERR(dquot)) { 21206184fc0bSJan Kara if (PTR_ERR(dquot) != -ESRCH) { 21216184fc0bSJan Kara ret = PTR_ERR(dquot); 21226184fc0bSJan Kara goto out_put; 21236184fc0bSJan Kara } 21246184fc0bSJan Kara dquot = NULL; 21256184fc0bSJan Kara } 21266184fc0bSJan Kara transfer_to[GRPQUOTA] = dquot; 21276184fc0bSJan Kara } 2128bc8e5f07SJan Kara ret = __dquot_transfer(inode, transfer_to); 21296184fc0bSJan Kara out_put: 2130bc8e5f07SJan Kara dqput_all(transfer_to); 2131bc8e5f07SJan Kara return ret; 2132884d179dSJan Kara } 2133b43fa828SChristoph Hellwig EXPORT_SYMBOL(dquot_transfer); 2134884d179dSJan Kara 2135884d179dSJan Kara /* 2136884d179dSJan Kara * Write info of quota file to disk 2137884d179dSJan Kara */ 2138884d179dSJan Kara int dquot_commit_info(struct super_block *sb, int type) 2139884d179dSJan Kara { 2140884d179dSJan Kara struct quota_info *dqopt = sb_dqopt(sb); 2141884d179dSJan Kara 21429a8ae30eSJan Kara return dqopt->ops[type]->write_file_info(sb, type); 2143884d179dSJan Kara } 2144884d179dSJan Kara EXPORT_SYMBOL(dquot_commit_info); 2145884d179dSJan Kara 2146be6257b2SJan Kara int dquot_get_next_id(struct super_block *sb, struct kqid *qid) 2147be6257b2SJan Kara { 2148be6257b2SJan Kara struct quota_info *dqopt = sb_dqopt(sb); 2149be6257b2SJan Kara 21509d1ccbe7SJan Kara if (!sb_has_quota_active(sb, qid->type)) 21519d1ccbe7SJan Kara return -ESRCH; 21529d1ccbe7SJan Kara if (!dqopt->ops[qid->type]->get_next_id) 21539d1ccbe7SJan Kara return -ENOSYS; 2154f14618c6SJan Kara return dqopt->ops[qid->type]->get_next_id(sb, qid); 2155be6257b2SJan Kara } 2156be6257b2SJan Kara EXPORT_SYMBOL(dquot_get_next_id); 2157be6257b2SJan Kara 2158884d179dSJan Kara /* 2159884d179dSJan Kara * Definitions of diskquota operations. 2160884d179dSJan Kara */ 216161e225dcSAlexey Dobriyan const struct dquot_operations dquot_operations = { 2162884d179dSJan Kara .write_dquot = dquot_commit, 2163884d179dSJan Kara .acquire_dquot = dquot_acquire, 2164884d179dSJan Kara .release_dquot = dquot_release, 2165884d179dSJan Kara .mark_dirty = dquot_mark_dquot_dirty, 2166884d179dSJan Kara .write_info = dquot_commit_info, 2167884d179dSJan Kara .alloc_dquot = dquot_alloc, 2168884d179dSJan Kara .destroy_dquot = dquot_destroy, 2169be6257b2SJan Kara .get_next_id = dquot_get_next_id, 2170884d179dSJan Kara }; 2171123e9cafSChristoph Hellwig EXPORT_SYMBOL(dquot_operations); 2172884d179dSJan Kara 2173884d179dSJan Kara /* 2174907f4554SChristoph Hellwig * Generic helper for ->open on filesystems supporting disk quotas. 2175907f4554SChristoph Hellwig */ 2176907f4554SChristoph Hellwig int dquot_file_open(struct inode *inode, struct file *file) 2177907f4554SChristoph Hellwig { 2178907f4554SChristoph Hellwig int error; 2179907f4554SChristoph Hellwig 2180907f4554SChristoph Hellwig error = generic_file_open(inode, file); 2181907f4554SChristoph Hellwig if (!error && (file->f_mode & FMODE_WRITE)) 218288d8ff97SChao Yu error = dquot_initialize(inode); 2183907f4554SChristoph Hellwig return error; 2184907f4554SChristoph Hellwig } 2185907f4554SChristoph Hellwig EXPORT_SYMBOL(dquot_file_open); 2186907f4554SChristoph Hellwig 21872ec1f301SJan Kara static void vfs_cleanup_quota_inode(struct super_block *sb, int type) 21882ec1f301SJan Kara { 21892ec1f301SJan Kara struct quota_info *dqopt = sb_dqopt(sb); 21902ec1f301SJan Kara struct inode *inode = dqopt->files[type]; 21912ec1f301SJan Kara 21922ec1f301SJan Kara if (!inode) 21932ec1f301SJan Kara return; 21942ec1f301SJan Kara if (!(dqopt->flags & DQUOT_QUOTA_SYS_FILE)) { 21952ec1f301SJan Kara inode_lock(inode); 21962ec1f301SJan Kara inode->i_flags &= ~S_NOQUOTA; 21972ec1f301SJan Kara inode_unlock(inode); 21982ec1f301SJan Kara } 21992ec1f301SJan Kara dqopt->files[type] = NULL; 22002ec1f301SJan Kara iput(inode); 22012ec1f301SJan Kara } 22022ec1f301SJan Kara 2203907f4554SChristoph Hellwig /* 2204884d179dSJan Kara * Turn quota off on a device. type == -1 ==> quotaoff for all types (umount) 2205884d179dSJan Kara */ 22060f0dd62fSChristoph Hellwig int dquot_disable(struct super_block *sb, int type, unsigned int flags) 2207884d179dSJan Kara { 22082ec1f301SJan Kara int cnt; 2209884d179dSJan Kara struct quota_info *dqopt = sb_dqopt(sb); 2210884d179dSJan Kara 22117d6cd73dSJan Kara /* s_umount should be held in exclusive mode */ 22127d6cd73dSJan Kara if (WARN_ON_ONCE(down_read_trylock(&sb->s_umount))) 22137d6cd73dSJan Kara up_read(&sb->s_umount); 22147d6cd73dSJan Kara 2215884d179dSJan Kara /* Cannot turn off usage accounting without turning off limits, or 2216884d179dSJan Kara * suspend quotas and simultaneously turn quotas off. */ 2217884d179dSJan Kara if ((flags & DQUOT_USAGE_ENABLED && !(flags & DQUOT_LIMITS_ENABLED)) 2218884d179dSJan Kara || (flags & DQUOT_SUSPENDED && flags & (DQUOT_LIMITS_ENABLED | 2219884d179dSJan Kara DQUOT_USAGE_ENABLED))) 2220884d179dSJan Kara return -EINVAL; 2221884d179dSJan Kara 2222884d179dSJan Kara /* 2223884d179dSJan Kara * Skip everything if there's nothing to do. We have to do this because 2224884d179dSJan Kara * sometimes we are called when fill_super() failed and calling 2225884d179dSJan Kara * sync_fs() in such cases does no good. 2226884d179dSJan Kara */ 2227c3b00446SJan Kara if (!sb_any_quota_loaded(sb)) 2228884d179dSJan Kara return 0; 2229c3b00446SJan Kara 2230884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 2231884d179dSJan Kara if (type != -1 && cnt != type) 2232884d179dSJan Kara continue; 2233884d179dSJan Kara if (!sb_has_quota_loaded(sb, cnt)) 2234884d179dSJan Kara continue; 2235884d179dSJan Kara 2236884d179dSJan Kara if (flags & DQUOT_SUSPENDED) { 2237884d179dSJan Kara spin_lock(&dq_state_lock); 2238884d179dSJan Kara dqopt->flags |= 2239884d179dSJan Kara dquot_state_flag(DQUOT_SUSPENDED, cnt); 2240884d179dSJan Kara spin_unlock(&dq_state_lock); 2241884d179dSJan Kara } else { 2242884d179dSJan Kara spin_lock(&dq_state_lock); 2243884d179dSJan Kara dqopt->flags &= ~dquot_state_flag(flags, cnt); 2244884d179dSJan Kara /* Turning off suspended quotas? */ 2245884d179dSJan Kara if (!sb_has_quota_loaded(sb, cnt) && 2246884d179dSJan Kara sb_has_quota_suspended(sb, cnt)) { 2247884d179dSJan Kara dqopt->flags &= ~dquot_state_flag( 2248884d179dSJan Kara DQUOT_SUSPENDED, cnt); 2249884d179dSJan Kara spin_unlock(&dq_state_lock); 22502ec1f301SJan Kara vfs_cleanup_quota_inode(sb, cnt); 2251884d179dSJan Kara continue; 2252884d179dSJan Kara } 2253884d179dSJan Kara spin_unlock(&dq_state_lock); 2254884d179dSJan Kara } 2255884d179dSJan Kara 2256884d179dSJan Kara /* We still have to keep quota loaded? */ 2257884d179dSJan Kara if (sb_has_quota_loaded(sb, cnt) && !(flags & DQUOT_SUSPENDED)) 2258884d179dSJan Kara continue; 2259884d179dSJan Kara 2260884d179dSJan Kara /* Note: these are blocking operations */ 2261884d179dSJan Kara drop_dquot_ref(sb, cnt); 2262884d179dSJan Kara invalidate_dquots(sb, cnt); 2263884d179dSJan Kara /* 2264268157baSJan Kara * Now all dquots should be invalidated, all writes done so we 2265268157baSJan Kara * should be only users of the info. No locks needed. 2266884d179dSJan Kara */ 2267884d179dSJan Kara if (info_dirty(&dqopt->info[cnt])) 2268884d179dSJan Kara sb->dq_op->write_info(sb, cnt); 2269884d179dSJan Kara if (dqopt->ops[cnt]->free_file_info) 2270884d179dSJan Kara dqopt->ops[cnt]->free_file_info(sb, cnt); 2271884d179dSJan Kara put_quota_format(dqopt->info[cnt].dqi_format); 2272884d179dSJan Kara dqopt->info[cnt].dqi_flags = 0; 2273884d179dSJan Kara dqopt->info[cnt].dqi_igrace = 0; 2274884d179dSJan Kara dqopt->info[cnt].dqi_bgrace = 0; 2275884d179dSJan Kara dqopt->ops[cnt] = NULL; 2276884d179dSJan Kara } 2277884d179dSJan Kara 2278884d179dSJan Kara /* Skip syncing and setting flags if quota files are hidden */ 2279884d179dSJan Kara if (dqopt->flags & DQUOT_QUOTA_SYS_FILE) 2280884d179dSJan Kara goto put_inodes; 2281884d179dSJan Kara 2282884d179dSJan Kara /* Sync the superblock so that buffers with quota data are written to 2283884d179dSJan Kara * disk (and so userspace sees correct data afterwards). */ 2284884d179dSJan Kara if (sb->s_op->sync_fs) 2285884d179dSJan Kara sb->s_op->sync_fs(sb, 1); 2286884d179dSJan Kara sync_blockdev(sb->s_bdev); 2287884d179dSJan Kara /* Now the quota files are just ordinary files and we can set the 2288884d179dSJan Kara * inode flags back. Moreover we discard the pagecache so that 2289884d179dSJan Kara * userspace sees the writes we did bypassing the pagecache. We 2290884d179dSJan Kara * must also discard the blockdev buffers so that we see the 2291884d179dSJan Kara * changes done by userspace on the next quotaon() */ 2292884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) 22932ec1f301SJan Kara if (!sb_has_quota_loaded(sb, cnt) && dqopt->files[cnt]) { 22942ec1f301SJan Kara inode_lock(dqopt->files[cnt]); 22952ec1f301SJan Kara truncate_inode_pages(&dqopt->files[cnt]->i_data, 0); 22962ec1f301SJan Kara inode_unlock(dqopt->files[cnt]); 2297884d179dSJan Kara } 2298884d179dSJan Kara if (sb->s_bdev) 2299884d179dSJan Kara invalidate_bdev(sb->s_bdev); 2300884d179dSJan Kara put_inodes: 23012ec1f301SJan Kara /* We are done when suspending quotas */ 23022ec1f301SJan Kara if (flags & DQUOT_SUSPENDED) 23032ec1f301SJan Kara return 0; 23042ec1f301SJan Kara 2305884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) 23062ec1f301SJan Kara if (!sb_has_quota_loaded(sb, cnt)) 23072ec1f301SJan Kara vfs_cleanup_quota_inode(sb, cnt); 23082ec1f301SJan Kara return 0; 2309884d179dSJan Kara } 23100f0dd62fSChristoph Hellwig EXPORT_SYMBOL(dquot_disable); 2311884d179dSJan Kara 2312287a8095SChristoph Hellwig int dquot_quota_off(struct super_block *sb, int type) 2313884d179dSJan Kara { 23140f0dd62fSChristoph Hellwig return dquot_disable(sb, type, 23150f0dd62fSChristoph Hellwig DQUOT_USAGE_ENABLED | DQUOT_LIMITS_ENABLED); 2316884d179dSJan Kara } 2317287a8095SChristoph Hellwig EXPORT_SYMBOL(dquot_quota_off); 23180f0dd62fSChristoph Hellwig 2319884d179dSJan Kara /* 2320884d179dSJan Kara * Turn quotas on on a device 2321884d179dSJan Kara */ 2322884d179dSJan Kara 2323c7d3d283SJan Kara static int vfs_setup_quota_inode(struct inode *inode, int type) 2324c7d3d283SJan Kara { 2325c7d3d283SJan Kara struct super_block *sb = inode->i_sb; 2326c7d3d283SJan Kara struct quota_info *dqopt = sb_dqopt(sb); 2327c7d3d283SJan Kara 2328d3238774SBaokun Li if (is_bad_inode(inode)) 2329d3238774SBaokun Li return -EUCLEAN; 2330c7d3d283SJan Kara if (!S_ISREG(inode->i_mode)) 2331c7d3d283SJan Kara return -EACCES; 2332c7d3d283SJan Kara if (IS_RDONLY(inode)) 2333c7d3d283SJan Kara return -EROFS; 2334c7d3d283SJan Kara if (sb_has_quota_loaded(sb, type)) 2335c7d3d283SJan Kara return -EBUSY; 2336c7d3d283SJan Kara 2337c7d3d283SJan Kara dqopt->files[type] = igrab(inode); 2338c7d3d283SJan Kara if (!dqopt->files[type]) 2339c7d3d283SJan Kara return -EIO; 2340c7d3d283SJan Kara if (!(dqopt->flags & DQUOT_QUOTA_SYS_FILE)) { 2341c7d3d283SJan Kara /* We don't want quota and atime on quota files (deadlocks 2342c7d3d283SJan Kara * possible) Also nobody should write to the file - we use 2343c7d3d283SJan Kara * special IO operations which ignore the immutable bit. */ 2344c7d3d283SJan Kara inode_lock(inode); 2345c7d3d283SJan Kara inode->i_flags |= S_NOQUOTA; 2346c7d3d283SJan Kara inode_unlock(inode); 2347884d179dSJan Kara /* 2348c7d3d283SJan Kara * When S_NOQUOTA is set, remove dquot references as no more 2349c7d3d283SJan Kara * references can be added 2350884d179dSJan Kara */ 2351c7d3d283SJan Kara __dquot_drop(inode); 2352c7d3d283SJan Kara } 2353c7d3d283SJan Kara return 0; 2354c7d3d283SJan Kara } 2355c7d3d283SJan Kara 2356c7d3d283SJan Kara int dquot_load_quota_sb(struct super_block *sb, int type, int format_id, 2357884d179dSJan Kara unsigned int flags) 2358884d179dSJan Kara { 2359884d179dSJan Kara struct quota_format_type *fmt = find_quota_format(format_id); 2360884d179dSJan Kara struct quota_info *dqopt = sb_dqopt(sb); 2361884d179dSJan Kara int error; 2362884d179dSJan Kara 2363dc19432aSJan Kara /* Just unsuspend quotas? */ 2364dc19432aSJan Kara BUG_ON(flags & DQUOT_SUSPENDED); 2365dc19432aSJan Kara /* s_umount should be held in exclusive mode */ 2366dc19432aSJan Kara if (WARN_ON_ONCE(down_read_trylock(&sb->s_umount))) 2367dc19432aSJan Kara up_read(&sb->s_umount); 2368dc19432aSJan Kara 2369884d179dSJan Kara if (!fmt) 2370884d179dSJan Kara return -ESRCH; 2371847aac64SLi Xi if (!sb->s_op->quota_write || !sb->s_op->quota_read || 2372847aac64SLi Xi (type == PRJQUOTA && sb->dq_op->get_projid == NULL)) { 2373884d179dSJan Kara error = -EINVAL; 2374884d179dSJan Kara goto out_fmt; 2375884d179dSJan Kara } 23765c004828SEric W. Biederman /* Filesystems outside of init_user_ns not yet supported */ 23775c004828SEric W. Biederman if (sb->s_user_ns != &init_user_ns) { 23785c004828SEric W. Biederman error = -EINVAL; 23795c004828SEric W. Biederman goto out_fmt; 23805c004828SEric W. Biederman } 2381884d179dSJan Kara /* Usage always has to be set... */ 2382884d179dSJan Kara if (!(flags & DQUOT_USAGE_ENABLED)) { 2383884d179dSJan Kara error = -EINVAL; 2384884d179dSJan Kara goto out_fmt; 2385884d179dSJan Kara } 2386c3b00446SJan Kara if (sb_has_quota_loaded(sb, type)) { 2387c3b00446SJan Kara error = -EBUSY; 2388c3b00446SJan Kara goto out_fmt; 2389c3b00446SJan Kara } 2390884d179dSJan Kara 2391884d179dSJan Kara if (!(dqopt->flags & DQUOT_QUOTA_SYS_FILE)) { 2392ab94c39bSJan Kara /* As we bypass the pagecache we must now flush all the 2393ab94c39bSJan Kara * dirty data and invalidate caches so that kernel sees 2394ab94c39bSJan Kara * changes from userspace. It is not enough to just flush 2395ab94c39bSJan Kara * the quota file since if blocksize < pagesize, invalidation 2396ab94c39bSJan Kara * of the cache could fail because of other unrelated dirty 2397ab94c39bSJan Kara * data */ 2398ab94c39bSJan Kara sync_filesystem(sb); 2399884d179dSJan Kara invalidate_bdev(sb->s_bdev); 2400884d179dSJan Kara } 2401884d179dSJan Kara 2402884d179dSJan Kara error = -EINVAL; 2403884d179dSJan Kara if (!fmt->qf_ops->check_quota_file(sb, type)) 2404c7d3d283SJan Kara goto out_fmt; 2405884d179dSJan Kara 2406884d179dSJan Kara dqopt->ops[type] = fmt->qf_ops; 2407884d179dSJan Kara dqopt->info[type].dqi_format = fmt; 2408884d179dSJan Kara dqopt->info[type].dqi_fmt_id = format_id; 2409884d179dSJan Kara INIT_LIST_HEAD(&dqopt->info[type].dqi_dirty_list); 2410268157baSJan Kara error = dqopt->ops[type]->read_file_info(sb, type); 241142fdb858SJan Kara if (error < 0) 2412c7d3d283SJan Kara goto out_fmt; 241315512377SJan Kara if (dqopt->flags & DQUOT_QUOTA_SYS_FILE) { 241415512377SJan Kara spin_lock(&dq_data_lock); 241546fe44ceSJan Kara dqopt->info[type].dqi_flags |= DQF_SYS_FILE; 241615512377SJan Kara spin_unlock(&dq_data_lock); 241715512377SJan Kara } 2418884d179dSJan Kara spin_lock(&dq_state_lock); 2419884d179dSJan Kara dqopt->flags |= dquot_state_flag(flags, type); 2420884d179dSJan Kara spin_unlock(&dq_state_lock); 2421884d179dSJan Kara 24221a6152d3SChao Yu error = add_dquot_ref(sb, type); 24231a6152d3SChao Yu if (error) 24241a6152d3SChao Yu dquot_disable(sb, type, flags); 2425884d179dSJan Kara 24261a6152d3SChao Yu return error; 2427884d179dSJan Kara out_fmt: 2428884d179dSJan Kara put_quota_format(fmt); 2429884d179dSJan Kara 2430884d179dSJan Kara return error; 2431884d179dSJan Kara } 2432c7d3d283SJan Kara EXPORT_SYMBOL(dquot_load_quota_sb); 2433c7d3d283SJan Kara 2434c7d3d283SJan Kara /* 2435dc19432aSJan Kara * More powerful function for turning on quotas on given quota inode allowing 2436dc19432aSJan Kara * setting of individual quota flags 2437c7d3d283SJan Kara */ 2438dc19432aSJan Kara int dquot_load_quota_inode(struct inode *inode, int type, int format_id, 2439c7d3d283SJan Kara unsigned int flags) 2440c7d3d283SJan Kara { 2441c7d3d283SJan Kara int err; 2442c7d3d283SJan Kara 2443c7d3d283SJan Kara err = vfs_setup_quota_inode(inode, type); 2444c7d3d283SJan Kara if (err < 0) 2445c7d3d283SJan Kara return err; 2446c7d3d283SJan Kara err = dquot_load_quota_sb(inode->i_sb, type, format_id, flags); 2447c7d3d283SJan Kara if (err < 0) 2448c7d3d283SJan Kara vfs_cleanup_quota_inode(inode->i_sb, type); 2449c7d3d283SJan Kara return err; 2450c7d3d283SJan Kara } 2451dc19432aSJan Kara EXPORT_SYMBOL(dquot_load_quota_inode); 2452884d179dSJan Kara 2453884d179dSJan Kara /* Reenable quotas on remount RW */ 24540f0dd62fSChristoph Hellwig int dquot_resume(struct super_block *sb, int type) 2455884d179dSJan Kara { 2456884d179dSJan Kara struct quota_info *dqopt = sb_dqopt(sb); 24570f0dd62fSChristoph Hellwig int ret = 0, cnt; 2458884d179dSJan Kara unsigned int flags; 2459884d179dSJan Kara 24607d6cd73dSJan Kara /* s_umount should be held in exclusive mode */ 24617d6cd73dSJan Kara if (WARN_ON_ONCE(down_read_trylock(&sb->s_umount))) 24627d6cd73dSJan Kara up_read(&sb->s_umount); 24637d6cd73dSJan Kara 24640f0dd62fSChristoph Hellwig for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 24650f0dd62fSChristoph Hellwig if (type != -1 && cnt != type) 24660f0dd62fSChristoph Hellwig continue; 2467c3b00446SJan Kara if (!sb_has_quota_suspended(sb, cnt)) 24680f0dd62fSChristoph Hellwig continue; 2469c3b00446SJan Kara 2470884d179dSJan Kara spin_lock(&dq_state_lock); 2471884d179dSJan Kara flags = dqopt->flags & dquot_state_flag(DQUOT_USAGE_ENABLED | 24720f0dd62fSChristoph Hellwig DQUOT_LIMITS_ENABLED, 24730f0dd62fSChristoph Hellwig cnt); 24740f0dd62fSChristoph Hellwig dqopt->flags &= ~dquot_state_flag(DQUOT_STATE_FLAGS, cnt); 2475884d179dSJan Kara spin_unlock(&dq_state_lock); 2476884d179dSJan Kara 24770f0dd62fSChristoph Hellwig flags = dquot_generic_flag(flags, cnt); 2478ae45f07dSJan Kara ret = dquot_load_quota_sb(sb, cnt, dqopt->info[cnt].dqi_fmt_id, 2479ae45f07dSJan Kara flags); 2480ae45f07dSJan Kara if (ret < 0) 2481e51d68e7SAnant Thazhemadam vfs_cleanup_quota_inode(sb, cnt); 24820f0dd62fSChristoph Hellwig } 2483884d179dSJan Kara 2484884d179dSJan Kara return ret; 2485884d179dSJan Kara } 24860f0dd62fSChristoph Hellwig EXPORT_SYMBOL(dquot_resume); 2487884d179dSJan Kara 2488f00c9e44SJan Kara int dquot_quota_on(struct super_block *sb, int type, int format_id, 24898c54ca9cSAl Viro const struct path *path) 2490884d179dSJan Kara { 2491884d179dSJan Kara int error = security_quota_on(path->dentry); 2492884d179dSJan Kara if (error) 2493884d179dSJan Kara return error; 2494884d179dSJan Kara /* Quota file not on the same filesystem? */ 2495d8c9584eSAl Viro if (path->dentry->d_sb != sb) 2496884d179dSJan Kara error = -EXDEV; 2497884d179dSJan Kara else 2498dc19432aSJan Kara error = dquot_load_quota_inode(d_inode(path->dentry), type, 2499884d179dSJan Kara format_id, DQUOT_USAGE_ENABLED | 2500884d179dSJan Kara DQUOT_LIMITS_ENABLED); 2501884d179dSJan Kara return error; 2502884d179dSJan Kara } 2503287a8095SChristoph Hellwig EXPORT_SYMBOL(dquot_quota_on); 2504884d179dSJan Kara 2505884d179dSJan Kara /* 2506884d179dSJan Kara * This function is used when filesystem needs to initialize quotas 2507884d179dSJan Kara * during mount time. 2508884d179dSJan Kara */ 2509287a8095SChristoph Hellwig int dquot_quota_on_mount(struct super_block *sb, char *qf_name, 2510884d179dSJan Kara int format_id, int type) 2511884d179dSJan Kara { 2512884d179dSJan Kara struct dentry *dentry; 2513884d179dSJan Kara int error; 2514884d179dSJan Kara 25156c2d4798SAl Viro dentry = lookup_positive_unlocked(qf_name, sb->s_root, strlen(qf_name)); 2516884d179dSJan Kara if (IS_ERR(dentry)) 2517884d179dSJan Kara return PTR_ERR(dentry); 2518884d179dSJan Kara 2519884d179dSJan Kara error = security_quota_on(dentry); 2520884d179dSJan Kara if (!error) 2521dc19432aSJan Kara error = dquot_load_quota_inode(d_inode(dentry), type, format_id, 2522884d179dSJan Kara DQUOT_USAGE_ENABLED | DQUOT_LIMITS_ENABLED); 2523884d179dSJan Kara 2524884d179dSJan Kara dput(dentry); 2525884d179dSJan Kara return error; 2526884d179dSJan Kara } 2527287a8095SChristoph Hellwig EXPORT_SYMBOL(dquot_quota_on_mount); 2528884d179dSJan Kara 25293e2af67eSJan Kara static int dquot_quota_enable(struct super_block *sb, unsigned int flags) 25303e2af67eSJan Kara { 25313e2af67eSJan Kara int ret; 25323e2af67eSJan Kara int type; 25333e2af67eSJan Kara struct quota_info *dqopt = sb_dqopt(sb); 25343e2af67eSJan Kara 25353e2af67eSJan Kara if (!(dqopt->flags & DQUOT_QUOTA_SYS_FILE)) 25363e2af67eSJan Kara return -ENOSYS; 25373e2af67eSJan Kara /* Accounting cannot be turned on while fs is mounted */ 25383e2af67eSJan Kara flags &= ~(FS_QUOTA_UDQ_ACCT | FS_QUOTA_GDQ_ACCT | FS_QUOTA_PDQ_ACCT); 25393e2af67eSJan Kara if (!flags) 25403e2af67eSJan Kara return -EINVAL; 25413e2af67eSJan Kara for (type = 0; type < MAXQUOTAS; type++) { 25423e2af67eSJan Kara if (!(flags & qtype_enforce_flag(type))) 25433e2af67eSJan Kara continue; 25443e2af67eSJan Kara /* Can't enforce without accounting */ 2545069a9166SJan Kara if (!sb_has_quota_usage_enabled(sb, type)) { 2546069a9166SJan Kara ret = -EINVAL; 25473e2af67eSJan Kara goto out_err; 25483e2af67eSJan Kara } 2549069a9166SJan Kara if (sb_has_quota_limits_enabled(sb, type)) { 2550069a9166SJan Kara ret = -EBUSY; 2551069a9166SJan Kara goto out_err; 2552069a9166SJan Kara } 2553069a9166SJan Kara spin_lock(&dq_state_lock); 2554069a9166SJan Kara dqopt->flags |= dquot_state_flag(DQUOT_LIMITS_ENABLED, type); 2555069a9166SJan Kara spin_unlock(&dq_state_lock); 2556069a9166SJan Kara } 25573e2af67eSJan Kara return 0; 25583e2af67eSJan Kara out_err: 25593e2af67eSJan Kara /* Backout enforcement enablement we already did */ 25603e2af67eSJan Kara for (type--; type >= 0; type--) { 25613e2af67eSJan Kara if (flags & qtype_enforce_flag(type)) 25623e2af67eSJan Kara dquot_disable(sb, type, DQUOT_LIMITS_ENABLED); 25633e2af67eSJan Kara } 25643e2af67eSJan Kara /* Error code translation for better compatibility with XFS */ 25653e2af67eSJan Kara if (ret == -EBUSY) 25663e2af67eSJan Kara ret = -EEXIST; 25673e2af67eSJan Kara return ret; 25683e2af67eSJan Kara } 25693e2af67eSJan Kara 25703e2af67eSJan Kara static int dquot_quota_disable(struct super_block *sb, unsigned int flags) 25713e2af67eSJan Kara { 25723e2af67eSJan Kara int ret; 25733e2af67eSJan Kara int type; 25743e2af67eSJan Kara struct quota_info *dqopt = sb_dqopt(sb); 25753e2af67eSJan Kara 25763e2af67eSJan Kara if (!(dqopt->flags & DQUOT_QUOTA_SYS_FILE)) 25773e2af67eSJan Kara return -ENOSYS; 25783e2af67eSJan Kara /* 25793e2af67eSJan Kara * We don't support turning off accounting via quotactl. In principle 25803e2af67eSJan Kara * quota infrastructure can do this but filesystems don't expect 25813e2af67eSJan Kara * userspace to be able to do it. 25823e2af67eSJan Kara */ 25833e2af67eSJan Kara if (flags & 25843e2af67eSJan Kara (FS_QUOTA_UDQ_ACCT | FS_QUOTA_GDQ_ACCT | FS_QUOTA_PDQ_ACCT)) 25853e2af67eSJan Kara return -EOPNOTSUPP; 25863e2af67eSJan Kara 25873e2af67eSJan Kara /* Filter out limits not enabled */ 25883e2af67eSJan Kara for (type = 0; type < MAXQUOTAS; type++) 25893e2af67eSJan Kara if (!sb_has_quota_limits_enabled(sb, type)) 25903e2af67eSJan Kara flags &= ~qtype_enforce_flag(type); 25913e2af67eSJan Kara /* Nothing left? */ 25923e2af67eSJan Kara if (!flags) 25933e2af67eSJan Kara return -EEXIST; 25943e2af67eSJan Kara for (type = 0; type < MAXQUOTAS; type++) { 25953e2af67eSJan Kara if (flags & qtype_enforce_flag(type)) { 25963e2af67eSJan Kara ret = dquot_disable(sb, type, DQUOT_LIMITS_ENABLED); 25973e2af67eSJan Kara if (ret < 0) 25983e2af67eSJan Kara goto out_err; 25993e2af67eSJan Kara } 26003e2af67eSJan Kara } 26013e2af67eSJan Kara return 0; 26023e2af67eSJan Kara out_err: 26033e2af67eSJan Kara /* Backout enforcement disabling we already did */ 26043e2af67eSJan Kara for (type--; type >= 0; type--) { 2605069a9166SJan Kara if (flags & qtype_enforce_flag(type)) { 2606069a9166SJan Kara spin_lock(&dq_state_lock); 2607069a9166SJan Kara dqopt->flags |= 2608069a9166SJan Kara dquot_state_flag(DQUOT_LIMITS_ENABLED, type); 2609069a9166SJan Kara spin_unlock(&dq_state_lock); 2610069a9166SJan Kara } 26113e2af67eSJan Kara } 26123e2af67eSJan Kara return ret; 26133e2af67eSJan Kara } 26143e2af67eSJan Kara 2615884d179dSJan Kara /* Generic routine for getting common part of quota structure */ 261614bf61ffSJan Kara static void do_get_dqblk(struct dquot *dquot, struct qc_dqblk *di) 2617884d179dSJan Kara { 2618884d179dSJan Kara struct mem_dqblk *dm = &dquot->dq_dqb; 2619884d179dSJan Kara 2620b9b2dd36SChristoph Hellwig memset(di, 0, sizeof(*di)); 26217b9ca4c6SJan Kara spin_lock(&dquot->dq_dqb_lock); 262214bf61ffSJan Kara di->d_spc_hardlimit = dm->dqb_bhardlimit; 262314bf61ffSJan Kara di->d_spc_softlimit = dm->dqb_bsoftlimit; 2624b9b2dd36SChristoph Hellwig di->d_ino_hardlimit = dm->dqb_ihardlimit; 2625b9b2dd36SChristoph Hellwig di->d_ino_softlimit = dm->dqb_isoftlimit; 262614bf61ffSJan Kara di->d_space = dm->dqb_curspace + dm->dqb_rsvspace; 262714bf61ffSJan Kara di->d_ino_count = dm->dqb_curinodes; 262814bf61ffSJan Kara di->d_spc_timer = dm->dqb_btime; 262914bf61ffSJan Kara di->d_ino_timer = dm->dqb_itime; 26307b9ca4c6SJan Kara spin_unlock(&dquot->dq_dqb_lock); 2631884d179dSJan Kara } 2632884d179dSJan Kara 263374a8a103SEric W. Biederman int dquot_get_dqblk(struct super_block *sb, struct kqid qid, 263414bf61ffSJan Kara struct qc_dqblk *di) 2635884d179dSJan Kara { 2636884d179dSJan Kara struct dquot *dquot; 2637884d179dSJan Kara 2638aca645a6SEric W. Biederman dquot = dqget(sb, qid); 26396184fc0bSJan Kara if (IS_ERR(dquot)) 26406184fc0bSJan Kara return PTR_ERR(dquot); 2641884d179dSJan Kara do_get_dqblk(dquot, di); 2642884d179dSJan Kara dqput(dquot); 2643884d179dSJan Kara 2644884d179dSJan Kara return 0; 2645884d179dSJan Kara } 2646287a8095SChristoph Hellwig EXPORT_SYMBOL(dquot_get_dqblk); 2647884d179dSJan Kara 2648be6257b2SJan Kara int dquot_get_next_dqblk(struct super_block *sb, struct kqid *qid, 2649be6257b2SJan Kara struct qc_dqblk *di) 2650be6257b2SJan Kara { 2651be6257b2SJan Kara struct dquot *dquot; 2652be6257b2SJan Kara int err; 2653be6257b2SJan Kara 2654be6257b2SJan Kara if (!sb->dq_op->get_next_id) 2655be6257b2SJan Kara return -ENOSYS; 2656be6257b2SJan Kara err = sb->dq_op->get_next_id(sb, qid); 2657be6257b2SJan Kara if (err < 0) 2658be6257b2SJan Kara return err; 2659be6257b2SJan Kara dquot = dqget(sb, *qid); 2660be6257b2SJan Kara if (IS_ERR(dquot)) 2661be6257b2SJan Kara return PTR_ERR(dquot); 2662be6257b2SJan Kara do_get_dqblk(dquot, di); 2663be6257b2SJan Kara dqput(dquot); 2664be6257b2SJan Kara 2665be6257b2SJan Kara return 0; 2666be6257b2SJan Kara } 2667be6257b2SJan Kara EXPORT_SYMBOL(dquot_get_next_dqblk); 2668be6257b2SJan Kara 266914bf61ffSJan Kara #define VFS_QC_MASK \ 267014bf61ffSJan Kara (QC_SPACE | QC_SPC_SOFT | QC_SPC_HARD | \ 267114bf61ffSJan Kara QC_INO_COUNT | QC_INO_SOFT | QC_INO_HARD | \ 267214bf61ffSJan Kara QC_SPC_TIMER | QC_INO_TIMER) 2673c472b432SChristoph Hellwig 2674884d179dSJan Kara /* Generic routine for setting common part of quota structure */ 267514bf61ffSJan Kara static int do_set_dqblk(struct dquot *dquot, struct qc_dqblk *di) 2676884d179dSJan Kara { 2677884d179dSJan Kara struct mem_dqblk *dm = &dquot->dq_dqb; 2678884d179dSJan Kara int check_blim = 0, check_ilim = 0; 26794c376dcaSEric W. Biederman struct mem_dqinfo *dqi = &sb_dqopt(dquot->dq_sb)->info[dquot->dq_id.type]; 2680884d179dSJan Kara 268114bf61ffSJan Kara if (di->d_fieldmask & ~VFS_QC_MASK) 2682c472b432SChristoph Hellwig return -EINVAL; 2683c472b432SChristoph Hellwig 268414bf61ffSJan Kara if (((di->d_fieldmask & QC_SPC_SOFT) && 2685b10a0819SJan Kara di->d_spc_softlimit > dqi->dqi_max_spc_limit) || 268614bf61ffSJan Kara ((di->d_fieldmask & QC_SPC_HARD) && 2687b10a0819SJan Kara di->d_spc_hardlimit > dqi->dqi_max_spc_limit) || 268814bf61ffSJan Kara ((di->d_fieldmask & QC_INO_SOFT) && 2689b10a0819SJan Kara (di->d_ino_softlimit > dqi->dqi_max_ino_limit)) || 269014bf61ffSJan Kara ((di->d_fieldmask & QC_INO_HARD) && 2691b10a0819SJan Kara (di->d_ino_hardlimit > dqi->dqi_max_ino_limit))) 2692884d179dSJan Kara return -ERANGE; 2693884d179dSJan Kara 26947b9ca4c6SJan Kara spin_lock(&dquot->dq_dqb_lock); 269514bf61ffSJan Kara if (di->d_fieldmask & QC_SPACE) { 269614bf61ffSJan Kara dm->dqb_curspace = di->d_space - dm->dqb_rsvspace; 2697884d179dSJan Kara check_blim = 1; 269808261673SAndrew Perepechko set_bit(DQ_LASTSET_B + QIF_SPACE_B, &dquot->dq_flags); 2699884d179dSJan Kara } 2700c472b432SChristoph Hellwig 270114bf61ffSJan Kara if (di->d_fieldmask & QC_SPC_SOFT) 270214bf61ffSJan Kara dm->dqb_bsoftlimit = di->d_spc_softlimit; 270314bf61ffSJan Kara if (di->d_fieldmask & QC_SPC_HARD) 270414bf61ffSJan Kara dm->dqb_bhardlimit = di->d_spc_hardlimit; 270514bf61ffSJan Kara if (di->d_fieldmask & (QC_SPC_SOFT | QC_SPC_HARD)) { 2706884d179dSJan Kara check_blim = 1; 270708261673SAndrew Perepechko set_bit(DQ_LASTSET_B + QIF_BLIMITS_B, &dquot->dq_flags); 2708884d179dSJan Kara } 2709c472b432SChristoph Hellwig 271014bf61ffSJan Kara if (di->d_fieldmask & QC_INO_COUNT) { 271114bf61ffSJan Kara dm->dqb_curinodes = di->d_ino_count; 2712884d179dSJan Kara check_ilim = 1; 271308261673SAndrew Perepechko set_bit(DQ_LASTSET_B + QIF_INODES_B, &dquot->dq_flags); 2714884d179dSJan Kara } 2715c472b432SChristoph Hellwig 271614bf61ffSJan Kara if (di->d_fieldmask & QC_INO_SOFT) 2717c472b432SChristoph Hellwig dm->dqb_isoftlimit = di->d_ino_softlimit; 271814bf61ffSJan Kara if (di->d_fieldmask & QC_INO_HARD) 2719c472b432SChristoph Hellwig dm->dqb_ihardlimit = di->d_ino_hardlimit; 272014bf61ffSJan Kara if (di->d_fieldmask & (QC_INO_SOFT | QC_INO_HARD)) { 2721884d179dSJan Kara check_ilim = 1; 272208261673SAndrew Perepechko set_bit(DQ_LASTSET_B + QIF_ILIMITS_B, &dquot->dq_flags); 2723884d179dSJan Kara } 2724c472b432SChristoph Hellwig 272514bf61ffSJan Kara if (di->d_fieldmask & QC_SPC_TIMER) { 272614bf61ffSJan Kara dm->dqb_btime = di->d_spc_timer; 2727884d179dSJan Kara check_blim = 1; 272808261673SAndrew Perepechko set_bit(DQ_LASTSET_B + QIF_BTIME_B, &dquot->dq_flags); 2729884d179dSJan Kara } 2730c472b432SChristoph Hellwig 273114bf61ffSJan Kara if (di->d_fieldmask & QC_INO_TIMER) { 273214bf61ffSJan Kara dm->dqb_itime = di->d_ino_timer; 2733884d179dSJan Kara check_ilim = 1; 273408261673SAndrew Perepechko set_bit(DQ_LASTSET_B + QIF_ITIME_B, &dquot->dq_flags); 2735884d179dSJan Kara } 2736884d179dSJan Kara 2737884d179dSJan Kara if (check_blim) { 2738268157baSJan Kara if (!dm->dqb_bsoftlimit || 27394b8e1106SChengguang Xu dm->dqb_curspace + dm->dqb_rsvspace <= dm->dqb_bsoftlimit) { 2740884d179dSJan Kara dm->dqb_btime = 0; 2741884d179dSJan Kara clear_bit(DQ_BLKS_B, &dquot->dq_flags); 274214bf61ffSJan Kara } else if (!(di->d_fieldmask & QC_SPC_TIMER)) 2743268157baSJan Kara /* Set grace only if user hasn't provided his own... */ 2744e008bb61SArnd Bergmann dm->dqb_btime = ktime_get_real_seconds() + dqi->dqi_bgrace; 2745884d179dSJan Kara } 2746884d179dSJan Kara if (check_ilim) { 2747268157baSJan Kara if (!dm->dqb_isoftlimit || 27484b8e1106SChengguang Xu dm->dqb_curinodes <= dm->dqb_isoftlimit) { 2749884d179dSJan Kara dm->dqb_itime = 0; 2750884d179dSJan Kara clear_bit(DQ_INODES_B, &dquot->dq_flags); 275114bf61ffSJan Kara } else if (!(di->d_fieldmask & QC_INO_TIMER)) 2752268157baSJan Kara /* Set grace only if user hasn't provided his own... */ 2753e008bb61SArnd Bergmann dm->dqb_itime = ktime_get_real_seconds() + dqi->dqi_igrace; 2754884d179dSJan Kara } 2755268157baSJan Kara if (dm->dqb_bhardlimit || dm->dqb_bsoftlimit || dm->dqb_ihardlimit || 2756268157baSJan Kara dm->dqb_isoftlimit) 2757884d179dSJan Kara clear_bit(DQ_FAKE_B, &dquot->dq_flags); 2758884d179dSJan Kara else 2759884d179dSJan Kara set_bit(DQ_FAKE_B, &dquot->dq_flags); 27607b9ca4c6SJan Kara spin_unlock(&dquot->dq_dqb_lock); 2761884d179dSJan Kara mark_dquot_dirty(dquot); 2762884d179dSJan Kara 2763884d179dSJan Kara return 0; 2764884d179dSJan Kara } 2765884d179dSJan Kara 276674a8a103SEric W. Biederman int dquot_set_dqblk(struct super_block *sb, struct kqid qid, 276714bf61ffSJan Kara struct qc_dqblk *di) 2768884d179dSJan Kara { 2769884d179dSJan Kara struct dquot *dquot; 2770884d179dSJan Kara int rc; 2771884d179dSJan Kara 2772aca645a6SEric W. Biederman dquot = dqget(sb, qid); 27736184fc0bSJan Kara if (IS_ERR(dquot)) { 27746184fc0bSJan Kara rc = PTR_ERR(dquot); 2775884d179dSJan Kara goto out; 2776884d179dSJan Kara } 2777884d179dSJan Kara rc = do_set_dqblk(dquot, di); 2778884d179dSJan Kara dqput(dquot); 2779884d179dSJan Kara out: 2780884d179dSJan Kara return rc; 2781884d179dSJan Kara } 2782287a8095SChristoph Hellwig EXPORT_SYMBOL(dquot_set_dqblk); 2783884d179dSJan Kara 2784884d179dSJan Kara /* Generic routine for getting common part of quota file information */ 27850a240339SJan Kara int dquot_get_state(struct super_block *sb, struct qc_state *state) 2786884d179dSJan Kara { 2787884d179dSJan Kara struct mem_dqinfo *mi; 27880a240339SJan Kara struct qc_type_state *tstate; 27890a240339SJan Kara struct quota_info *dqopt = sb_dqopt(sb); 27900a240339SJan Kara int type; 2791884d179dSJan Kara 27920a240339SJan Kara memset(state, 0, sizeof(*state)); 27930a240339SJan Kara for (type = 0; type < MAXQUOTAS; type++) { 27940a240339SJan Kara if (!sb_has_quota_active(sb, type)) 27950a240339SJan Kara continue; 27960a240339SJan Kara tstate = state->s_state + type; 2797884d179dSJan Kara mi = sb_dqopt(sb)->info + type; 27980a240339SJan Kara tstate->flags = QCI_ACCT_ENABLED; 2799884d179dSJan Kara spin_lock(&dq_data_lock); 28000a240339SJan Kara if (mi->dqi_flags & DQF_SYS_FILE) 28010a240339SJan Kara tstate->flags |= QCI_SYSFILE; 28020a240339SJan Kara if (mi->dqi_flags & DQF_ROOT_SQUASH) 28030a240339SJan Kara tstate->flags |= QCI_ROOT_SQUASH; 28040a240339SJan Kara if (sb_has_quota_limits_enabled(sb, type)) 28050a240339SJan Kara tstate->flags |= QCI_LIMITS_ENFORCED; 28060a240339SJan Kara tstate->spc_timelimit = mi->dqi_bgrace; 28070a240339SJan Kara tstate->ino_timelimit = mi->dqi_igrace; 2808a0828b6cSJan Kara if (dqopt->files[type]) { 28090a240339SJan Kara tstate->ino = dqopt->files[type]->i_ino; 28100a240339SJan Kara tstate->blocks = dqopt->files[type]->i_blocks; 2811a0828b6cSJan Kara } 28120a240339SJan Kara tstate->nextents = 1; /* We don't know... */ 2813884d179dSJan Kara spin_unlock(&dq_data_lock); 28140a240339SJan Kara } 2815884d179dSJan Kara return 0; 2816884d179dSJan Kara } 28170a240339SJan Kara EXPORT_SYMBOL(dquot_get_state); 2818884d179dSJan Kara 2819884d179dSJan Kara /* Generic routine for setting common part of quota file information */ 28205eacb2acSJan Kara int dquot_set_dqinfo(struct super_block *sb, int type, struct qc_info *ii) 2821884d179dSJan Kara { 2822884d179dSJan Kara struct mem_dqinfo *mi; 2823884d179dSJan Kara int err = 0; 2824884d179dSJan Kara 28255eacb2acSJan Kara if ((ii->i_fieldmask & QC_WARNS_MASK) || 28265eacb2acSJan Kara (ii->i_fieldmask & QC_RT_SPC_TIMER)) 28275eacb2acSJan Kara return -EINVAL; 28289d1ccbe7SJan Kara if (!sb_has_quota_active(sb, type)) 28299d1ccbe7SJan Kara return -ESRCH; 2830884d179dSJan Kara mi = sb_dqopt(sb)->info + type; 28315eacb2acSJan Kara if (ii->i_fieldmask & QC_FLAGS) { 28325eacb2acSJan Kara if ((ii->i_flags & QCI_ROOT_SQUASH && 28339d1ccbe7SJan Kara mi->dqi_format->qf_fmt_id != QFMT_VFS_OLD)) 28349d1ccbe7SJan Kara return -EINVAL; 2835ca6cb091SJan Kara } 2836884d179dSJan Kara spin_lock(&dq_data_lock); 28375eacb2acSJan Kara if (ii->i_fieldmask & QC_SPC_TIMER) 28385eacb2acSJan Kara mi->dqi_bgrace = ii->i_spc_timelimit; 28395eacb2acSJan Kara if (ii->i_fieldmask & QC_INO_TIMER) 28405eacb2acSJan Kara mi->dqi_igrace = ii->i_ino_timelimit; 28415eacb2acSJan Kara if (ii->i_fieldmask & QC_FLAGS) { 28425eacb2acSJan Kara if (ii->i_flags & QCI_ROOT_SQUASH) 28435eacb2acSJan Kara mi->dqi_flags |= DQF_ROOT_SQUASH; 28445eacb2acSJan Kara else 28455eacb2acSJan Kara mi->dqi_flags &= ~DQF_ROOT_SQUASH; 28465eacb2acSJan Kara } 2847884d179dSJan Kara spin_unlock(&dq_data_lock); 2848884d179dSJan Kara mark_info_dirty(sb, type); 2849884d179dSJan Kara /* Force write to disk */ 2850884d179dSJan Kara sb->dq_op->write_info(sb, type); 2851884d179dSJan Kara return err; 2852884d179dSJan Kara } 2853287a8095SChristoph Hellwig EXPORT_SYMBOL(dquot_set_dqinfo); 2854884d179dSJan Kara 28553e2af67eSJan Kara const struct quotactl_ops dquot_quotactl_sysfile_ops = { 28563e2af67eSJan Kara .quota_enable = dquot_quota_enable, 28573e2af67eSJan Kara .quota_disable = dquot_quota_disable, 28583e2af67eSJan Kara .quota_sync = dquot_quota_sync, 28590a240339SJan Kara .get_state = dquot_get_state, 28603e2af67eSJan Kara .set_info = dquot_set_dqinfo, 28613e2af67eSJan Kara .get_dqblk = dquot_get_dqblk, 2862be6257b2SJan Kara .get_nextdqblk = dquot_get_next_dqblk, 28633e2af67eSJan Kara .set_dqblk = dquot_set_dqblk 28643e2af67eSJan Kara }; 28653e2af67eSJan Kara EXPORT_SYMBOL(dquot_quotactl_sysfile_ops); 28663e2af67eSJan Kara 2867dde95888SDmitry Monakhov static int do_proc_dqstats(struct ctl_table *table, int write, 286832927393SChristoph Hellwig void *buffer, size_t *lenp, loff_t *ppos) 2869dde95888SDmitry Monakhov { 28706fcbcec9SKonstantin Khlebnikov unsigned int type = (unsigned long *)table->data - dqstats.stat; 28716fcbcec9SKonstantin Khlebnikov s64 value = percpu_counter_sum(&dqstats.counter[type]); 28726fcbcec9SKonstantin Khlebnikov 28736fcbcec9SKonstantin Khlebnikov /* Filter negative values for non-monotonic counters */ 28746fcbcec9SKonstantin Khlebnikov if (value < 0 && (type == DQST_ALLOC_DQUOTS || 28756fcbcec9SKonstantin Khlebnikov type == DQST_FREE_DQUOTS)) 28766fcbcec9SKonstantin Khlebnikov value = 0; 2877f32764bdSDmitry Monakhov 2878f32764bdSDmitry Monakhov /* Update global table */ 28796fcbcec9SKonstantin Khlebnikov dqstats.stat[type] = value; 28806fcbcec9SKonstantin Khlebnikov return proc_doulongvec_minmax(table, write, buffer, lenp, ppos); 2881dde95888SDmitry Monakhov } 2882dde95888SDmitry Monakhov 2883e628753bSJoe Perches static struct ctl_table fs_dqstats_table[] = { 2884884d179dSJan Kara { 2885884d179dSJan Kara .procname = "lookups", 2886dde95888SDmitry Monakhov .data = &dqstats.stat[DQST_LOOKUPS], 28876fcbcec9SKonstantin Khlebnikov .maxlen = sizeof(unsigned long), 2888884d179dSJan Kara .mode = 0444, 2889dde95888SDmitry Monakhov .proc_handler = do_proc_dqstats, 2890884d179dSJan Kara }, 2891884d179dSJan Kara { 2892884d179dSJan Kara .procname = "drops", 2893dde95888SDmitry Monakhov .data = &dqstats.stat[DQST_DROPS], 28946fcbcec9SKonstantin Khlebnikov .maxlen = sizeof(unsigned long), 2895884d179dSJan Kara .mode = 0444, 2896dde95888SDmitry Monakhov .proc_handler = do_proc_dqstats, 2897884d179dSJan Kara }, 2898884d179dSJan Kara { 2899884d179dSJan Kara .procname = "reads", 2900dde95888SDmitry Monakhov .data = &dqstats.stat[DQST_READS], 29016fcbcec9SKonstantin Khlebnikov .maxlen = sizeof(unsigned long), 2902884d179dSJan Kara .mode = 0444, 2903dde95888SDmitry Monakhov .proc_handler = do_proc_dqstats, 2904884d179dSJan Kara }, 2905884d179dSJan Kara { 2906884d179dSJan Kara .procname = "writes", 2907dde95888SDmitry Monakhov .data = &dqstats.stat[DQST_WRITES], 29086fcbcec9SKonstantin Khlebnikov .maxlen = sizeof(unsigned long), 2909884d179dSJan Kara .mode = 0444, 2910dde95888SDmitry Monakhov .proc_handler = do_proc_dqstats, 2911884d179dSJan Kara }, 2912884d179dSJan Kara { 2913884d179dSJan Kara .procname = "cache_hits", 2914dde95888SDmitry Monakhov .data = &dqstats.stat[DQST_CACHE_HITS], 29156fcbcec9SKonstantin Khlebnikov .maxlen = sizeof(unsigned long), 2916884d179dSJan Kara .mode = 0444, 2917dde95888SDmitry Monakhov .proc_handler = do_proc_dqstats, 2918884d179dSJan Kara }, 2919884d179dSJan Kara { 2920884d179dSJan Kara .procname = "allocated_dquots", 2921dde95888SDmitry Monakhov .data = &dqstats.stat[DQST_ALLOC_DQUOTS], 29226fcbcec9SKonstantin Khlebnikov .maxlen = sizeof(unsigned long), 2923884d179dSJan Kara .mode = 0444, 2924dde95888SDmitry Monakhov .proc_handler = do_proc_dqstats, 2925884d179dSJan Kara }, 2926884d179dSJan Kara { 2927884d179dSJan Kara .procname = "free_dquots", 2928dde95888SDmitry Monakhov .data = &dqstats.stat[DQST_FREE_DQUOTS], 29296fcbcec9SKonstantin Khlebnikov .maxlen = sizeof(unsigned long), 2930884d179dSJan Kara .mode = 0444, 2931dde95888SDmitry Monakhov .proc_handler = do_proc_dqstats, 2932884d179dSJan Kara }, 2933884d179dSJan Kara { 2934884d179dSJan Kara .procname = "syncs", 2935dde95888SDmitry Monakhov .data = &dqstats.stat[DQST_SYNCS], 29366fcbcec9SKonstantin Khlebnikov .maxlen = sizeof(unsigned long), 2937884d179dSJan Kara .mode = 0444, 2938dde95888SDmitry Monakhov .proc_handler = do_proc_dqstats, 2939884d179dSJan Kara }, 2940884d179dSJan Kara #ifdef CONFIG_PRINT_QUOTA_WARNING 2941884d179dSJan Kara { 2942884d179dSJan Kara .procname = "warnings", 2943884d179dSJan Kara .data = &flag_print_warnings, 2944884d179dSJan Kara .maxlen = sizeof(int), 2945884d179dSJan Kara .mode = 0644, 29466d456111SEric W. Biederman .proc_handler = proc_dointvec, 2947884d179dSJan Kara }, 2948884d179dSJan Kara #endif 2949ab09203eSEric W. Biederman { }, 2950884d179dSJan Kara }; 2951884d179dSJan Kara 2952e628753bSJoe Perches static struct ctl_table fs_table[] = { 2953884d179dSJan Kara { 2954884d179dSJan Kara .procname = "quota", 2955884d179dSJan Kara .mode = 0555, 2956884d179dSJan Kara .child = fs_dqstats_table, 2957884d179dSJan Kara }, 2958ab09203eSEric W. Biederman { }, 2959884d179dSJan Kara }; 2960884d179dSJan Kara 2961e628753bSJoe Perches static struct ctl_table sys_table[] = { 2962884d179dSJan Kara { 2963884d179dSJan Kara .procname = "fs", 2964884d179dSJan Kara .mode = 0555, 2965884d179dSJan Kara .child = fs_table, 2966884d179dSJan Kara }, 2967ab09203eSEric W. Biederman { }, 2968884d179dSJan Kara }; 2969884d179dSJan Kara 2970884d179dSJan Kara static int __init dquot_init(void) 2971884d179dSJan Kara { 2972f32764bdSDmitry Monakhov int i, ret; 2973884d179dSJan Kara unsigned long nr_hash, order; 2974884d179dSJan Kara 2975884d179dSJan Kara printk(KERN_NOTICE "VFS: Disk quotas %s\n", __DQUOT_VERSION__); 2976884d179dSJan Kara 2977884d179dSJan Kara register_sysctl_table(sys_table); 2978884d179dSJan Kara 2979884d179dSJan Kara dquot_cachep = kmem_cache_create("dquot", 2980884d179dSJan Kara sizeof(struct dquot), sizeof(unsigned long) * 4, 2981884d179dSJan Kara (SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT| 2982884d179dSJan Kara SLAB_MEM_SPREAD|SLAB_PANIC), 2983884d179dSJan Kara NULL); 2984884d179dSJan Kara 2985884d179dSJan Kara order = 0; 29861aa3b3e0SJia-Ju Bai dquot_hash = (struct hlist_head *)__get_free_pages(GFP_KERNEL, order); 2987884d179dSJan Kara if (!dquot_hash) 2988884d179dSJan Kara panic("Cannot create dquot hash table"); 2989884d179dSJan Kara 2990f32764bdSDmitry Monakhov for (i = 0; i < _DQST_DQSTAT_LAST; i++) { 2991908c7f19STejun Heo ret = percpu_counter_init(&dqstats.counter[i], 0, GFP_KERNEL); 2992f32764bdSDmitry Monakhov if (ret) 2993f32764bdSDmitry Monakhov panic("Cannot create dquot stat counters"); 2994f32764bdSDmitry Monakhov } 2995dde95888SDmitry Monakhov 2996884d179dSJan Kara /* Find power-of-two hlist_heads which can fit into allocation */ 2997884d179dSJan Kara nr_hash = (1UL << order) * PAGE_SIZE / sizeof(struct hlist_head); 299824fc755fSChengguang Xu dq_hash_bits = ilog2(nr_hash); 2999884d179dSJan Kara 3000884d179dSJan Kara nr_hash = 1UL << dq_hash_bits; 3001884d179dSJan Kara dq_hash_mask = nr_hash - 1; 3002884d179dSJan Kara for (i = 0; i < nr_hash; i++) 3003884d179dSJan Kara INIT_HLIST_HEAD(dquot_hash + i); 3004884d179dSJan Kara 300519858e7bSAnton Blanchard pr_info("VFS: Dquot-cache hash table entries: %ld (order %ld," 300619858e7bSAnton Blanchard " %ld bytes)\n", nr_hash, order, (PAGE_SIZE << order)); 3007884d179dSJan Kara 3008e33c267aSRoman Gushchin if (register_shrinker(&dqcache_shrinker, "dquota-cache")) 300988bc0edeSTetsuo Handa panic("Cannot register dquot shrinker"); 3010884d179dSJan Kara 3011884d179dSJan Kara return 0; 3012884d179dSJan Kara } 3013331221faSPaul Gortmaker fs_initcall(dquot_init); 3014