1884d179dSJan Kara /* 2884d179dSJan Kara * Implementation of the diskquota system for the LINUX operating system. QUOTA 3884d179dSJan Kara * is implemented using the BSD system call interface as the means of 4884d179dSJan Kara * communication with the user level. This file contains the generic routines 5884d179dSJan Kara * called by the different filesystems on allocation of an inode or block. 6884d179dSJan Kara * These routines take care of the administration needed to have a consistent 7884d179dSJan Kara * diskquota tracking system. The ideas of both user and group quotas are based 8884d179dSJan Kara * on the Melbourne quota system as used on BSD derived systems. The internal 9884d179dSJan Kara * implementation is based on one of the several variants of the LINUX 10884d179dSJan Kara * inode-subsystem with added complexity of the diskquota system. 11884d179dSJan Kara * 12884d179dSJan Kara * Author: Marco van Wieringen <mvw@planets.elm.net> 13884d179dSJan Kara * 14884d179dSJan Kara * Fixes: Dmitry Gorodchanin <pgmdsg@ibi.com>, 11 Feb 96 15884d179dSJan Kara * 16884d179dSJan Kara * Revised list management to avoid races 17884d179dSJan Kara * -- Bill Hawes, <whawes@star.net>, 9/98 18884d179dSJan Kara * 19884d179dSJan Kara * Fixed races in dquot_transfer(), dqget() and dquot_alloc_...(). 20884d179dSJan Kara * As the consequence the locking was moved from dquot_decr_...(), 21884d179dSJan Kara * dquot_incr_...() to calling functions. 22884d179dSJan Kara * invalidate_dquots() now writes modified dquots. 23884d179dSJan Kara * Serialized quota_off() and quota_on() for mount point. 24884d179dSJan Kara * Fixed a few bugs in grow_dquots(). 25884d179dSJan Kara * Fixed deadlock in write_dquot() - we no longer account quotas on 26884d179dSJan Kara * quota files 27884d179dSJan Kara * remove_dquot_ref() moved to inode.c - it now traverses through inodes 28884d179dSJan Kara * add_dquot_ref() restarts after blocking 29884d179dSJan Kara * Added check for bogus uid and fixed check for group in quotactl. 30884d179dSJan Kara * Jan Kara, <jack@suse.cz>, sponsored by SuSE CR, 10-11/99 31884d179dSJan Kara * 32884d179dSJan Kara * Used struct list_head instead of own list struct 33884d179dSJan Kara * Invalidation of referenced dquots is no longer possible 34884d179dSJan Kara * Improved free_dquots list management 35884d179dSJan Kara * Quota and i_blocks are now updated in one place to avoid races 36884d179dSJan Kara * Warnings are now delayed so we won't block in critical section 37884d179dSJan Kara * Write updated not to require dquot lock 38884d179dSJan Kara * Jan Kara, <jack@suse.cz>, 9/2000 39884d179dSJan Kara * 40884d179dSJan Kara * Added dynamic quota structure allocation 41884d179dSJan Kara * Jan Kara <jack@suse.cz> 12/2000 42884d179dSJan Kara * 43884d179dSJan Kara * Rewritten quota interface. Implemented new quota format and 44884d179dSJan Kara * formats registering. 45884d179dSJan Kara * Jan Kara, <jack@suse.cz>, 2001,2002 46884d179dSJan Kara * 47884d179dSJan Kara * New SMP locking. 48884d179dSJan Kara * Jan Kara, <jack@suse.cz>, 10/2002 49884d179dSJan Kara * 50884d179dSJan Kara * Added journalled quota support, fix lock inversion problems 51884d179dSJan Kara * Jan Kara, <jack@suse.cz>, 2003,2004 52884d179dSJan Kara * 53884d179dSJan Kara * (C) Copyright 1994 - 1997 Marco van Wieringen 54884d179dSJan Kara */ 55884d179dSJan Kara 56884d179dSJan Kara #include <linux/errno.h> 57884d179dSJan Kara #include <linux/kernel.h> 58884d179dSJan Kara #include <linux/fs.h> 59884d179dSJan Kara #include <linux/mount.h> 60884d179dSJan Kara #include <linux/mm.h> 61884d179dSJan Kara #include <linux/time.h> 62884d179dSJan Kara #include <linux/types.h> 63884d179dSJan Kara #include <linux/string.h> 64884d179dSJan Kara #include <linux/fcntl.h> 65884d179dSJan Kara #include <linux/stat.h> 66884d179dSJan Kara #include <linux/tty.h> 67884d179dSJan Kara #include <linux/file.h> 68884d179dSJan Kara #include <linux/slab.h> 69884d179dSJan Kara #include <linux/sysctl.h> 70884d179dSJan Kara #include <linux/init.h> 71884d179dSJan Kara #include <linux/module.h> 72884d179dSJan Kara #include <linux/proc_fs.h> 73884d179dSJan Kara #include <linux/security.h> 7440401530SAl Viro #include <linux/sched.h> 755b825c3aSIngo Molnar #include <linux/cred.h> 76884d179dSJan Kara #include <linux/kmod.h> 77884d179dSJan Kara #include <linux/namei.h> 78884d179dSJan Kara #include <linux/capability.h> 79884d179dSJan Kara #include <linux/quotaops.h> 8055fa6091SDave Chinner #include "../internal.h" /* ugh */ 81884d179dSJan Kara 82f3da9310SJeff Liu #include <linux/uaccess.h> 83884d179dSJan Kara 84884d179dSJan Kara /* 85*7b9ca4c6SJan Kara * There are five quota SMP locks: 86*7b9ca4c6SJan Kara * * dq_list_lock protects all lists with quotas and quota formats. 87*7b9ca4c6SJan Kara * * dquot->dq_dqb_lock protects data from dq_dqb 88*7b9ca4c6SJan Kara * * inode->i_lock protects inode->i_blocks, i_bytes and also guards 89*7b9ca4c6SJan Kara * consistency of dquot->dq_dqb with inode->i_blocks, i_bytes so that 90*7b9ca4c6SJan Kara * dquot_transfer() can stabilize amount it transfers 91*7b9ca4c6SJan Kara * * dq_data_lock protects mem_dqinfo structures and modifications of dquot 92*7b9ca4c6SJan Kara * pointers in the inode 93*7b9ca4c6SJan Kara * * dq_state_lock protects modifications of quota state (on quotaon and 94*7b9ca4c6SJan Kara * quotaoff) and readers who care about latest values take it as well. 95884d179dSJan Kara * 96*7b9ca4c6SJan Kara * The spinlock ordering is hence: 97*7b9ca4c6SJan Kara * dq_data_lock > dq_list_lock > i_lock > dquot->dq_dqb_lock, 98884d179dSJan Kara * dq_list_lock > dq_state_lock 99884d179dSJan Kara * 100884d179dSJan Kara * Note that some things (eg. sb pointer, type, id) doesn't change during 101884d179dSJan Kara * the life of the dquot structure and so needn't to be protected by a lock 102884d179dSJan Kara * 103b9ba6f94SNiu Yawei * Operation accessing dquots via inode pointers are protected by dquot_srcu. 104b9ba6f94SNiu Yawei * Operation of reading pointer needs srcu_read_lock(&dquot_srcu), and 105b9ba6f94SNiu Yawei * synchronize_srcu(&dquot_srcu) is called after clearing pointers from 106b9ba6f94SNiu Yawei * inode and before dropping dquot references to avoid use of dquots after 107b9ba6f94SNiu Yawei * they are freed. dq_data_lock is used to serialize the pointer setting and 108b9ba6f94SNiu Yawei * clearing operations. 10926245c94SJan Kara * Special care needs to be taken about S_NOQUOTA inode flag (marking that 11026245c94SJan Kara * inode is a quota file). Functions adding pointers from inode to dquots have 111b9ba6f94SNiu Yawei * to check this flag under dq_data_lock and then (if S_NOQUOTA is not set) they 112b9ba6f94SNiu Yawei * have to do all pointer modifications before dropping dq_data_lock. This makes 11326245c94SJan Kara * sure they cannot race with quotaon which first sets S_NOQUOTA flag and 11426245c94SJan Kara * then drops all pointers to dquots from an inode. 115884d179dSJan Kara * 1165e8cb9b6SJan Kara * Each dquot has its dq_lock mutex. Dquot is locked when it is being read to 1175e8cb9b6SJan Kara * memory (or space for it is being allocated) on the first dqget(), when it is 1185e8cb9b6SJan Kara * being written out, and when it is being released on the last dqput(). The 1195e8cb9b6SJan Kara * allocation and release operations are serialized by the dq_lock and by 1205e8cb9b6SJan Kara * checking the use count in dquot_release(). 121884d179dSJan Kara * 122884d179dSJan Kara * Lock ordering (including related VFS locks) is the following: 123bc8230eeSJan Kara * s_umount > i_mutex > journal_lock > dquot->dq_lock > dqio_sem 124884d179dSJan Kara */ 125884d179dSJan Kara 126c516610cSJan Kara static __cacheline_aligned_in_smp DEFINE_SPINLOCK(dq_list_lock); 127c516610cSJan Kara static __cacheline_aligned_in_smp DEFINE_SPINLOCK(dq_state_lock); 128c516610cSJan Kara __cacheline_aligned_in_smp DEFINE_SPINLOCK(dq_data_lock); 129884d179dSJan Kara EXPORT_SYMBOL(dq_data_lock); 130b9ba6f94SNiu Yawei DEFINE_STATIC_SRCU(dquot_srcu); 131884d179dSJan Kara 132503330f3SJan Kara static DECLARE_WAIT_QUEUE_HEAD(dquot_ref_wq); 133503330f3SJan Kara 134fb5ffb0eSJiaying Zhang void __quota_error(struct super_block *sb, const char *func, 135fb5ffb0eSJiaying Zhang const char *fmt, ...) 136fb5ffb0eSJiaying Zhang { 137fb5ffb0eSJiaying Zhang if (printk_ratelimit()) { 138055adcbdSJoe Perches va_list args; 139055adcbdSJoe Perches struct va_format vaf; 140055adcbdSJoe Perches 141fb5ffb0eSJiaying Zhang va_start(args, fmt); 142055adcbdSJoe Perches 143055adcbdSJoe Perches vaf.fmt = fmt; 144055adcbdSJoe Perches vaf.va = &args; 145055adcbdSJoe Perches 146055adcbdSJoe Perches printk(KERN_ERR "Quota error (device %s): %s: %pV\n", 147055adcbdSJoe Perches sb->s_id, func, &vaf); 148055adcbdSJoe Perches 149fb5ffb0eSJiaying Zhang va_end(args); 150fb5ffb0eSJiaying Zhang } 151fb5ffb0eSJiaying Zhang } 152fb5ffb0eSJiaying Zhang EXPORT_SYMBOL(__quota_error); 153fb5ffb0eSJiaying Zhang 154da8d1ba2SSergey Senozhatsky #if defined(CONFIG_QUOTA_DEBUG) || defined(CONFIG_PRINT_QUOTA_WARNING) 155884d179dSJan Kara static char *quotatypes[] = INITQFNAMES; 156da8d1ba2SSergey Senozhatsky #endif 157884d179dSJan Kara static struct quota_format_type *quota_formats; /* List of registered formats */ 158884d179dSJan Kara static struct quota_module_name module_names[] = INIT_QUOTA_MODULE_NAMES; 159884d179dSJan Kara 160884d179dSJan Kara /* SLAB cache for dquot structures */ 161884d179dSJan Kara static struct kmem_cache *dquot_cachep; 162884d179dSJan Kara 163884d179dSJan Kara int register_quota_format(struct quota_format_type *fmt) 164884d179dSJan Kara { 165884d179dSJan Kara spin_lock(&dq_list_lock); 166884d179dSJan Kara fmt->qf_next = quota_formats; 167884d179dSJan Kara quota_formats = fmt; 168884d179dSJan Kara spin_unlock(&dq_list_lock); 169884d179dSJan Kara return 0; 170884d179dSJan Kara } 171884d179dSJan Kara EXPORT_SYMBOL(register_quota_format); 172884d179dSJan Kara 173884d179dSJan Kara void unregister_quota_format(struct quota_format_type *fmt) 174884d179dSJan Kara { 175884d179dSJan Kara struct quota_format_type **actqf; 176884d179dSJan Kara 177884d179dSJan Kara spin_lock(&dq_list_lock); 178268157baSJan Kara for (actqf = "a_formats; *actqf && *actqf != fmt; 179268157baSJan Kara actqf = &(*actqf)->qf_next) 180268157baSJan Kara ; 181884d179dSJan Kara if (*actqf) 182884d179dSJan Kara *actqf = (*actqf)->qf_next; 183884d179dSJan Kara spin_unlock(&dq_list_lock); 184884d179dSJan Kara } 185884d179dSJan Kara EXPORT_SYMBOL(unregister_quota_format); 186884d179dSJan Kara 187884d179dSJan Kara static struct quota_format_type *find_quota_format(int id) 188884d179dSJan Kara { 189884d179dSJan Kara struct quota_format_type *actqf; 190884d179dSJan Kara 191884d179dSJan Kara spin_lock(&dq_list_lock); 192268157baSJan Kara for (actqf = quota_formats; actqf && actqf->qf_fmt_id != id; 193268157baSJan Kara actqf = actqf->qf_next) 194268157baSJan Kara ; 195884d179dSJan Kara if (!actqf || !try_module_get(actqf->qf_owner)) { 196884d179dSJan Kara int qm; 197884d179dSJan Kara 198884d179dSJan Kara spin_unlock(&dq_list_lock); 199884d179dSJan Kara 200268157baSJan Kara for (qm = 0; module_names[qm].qm_fmt_id && 201268157baSJan Kara module_names[qm].qm_fmt_id != id; qm++) 202268157baSJan Kara ; 203268157baSJan Kara if (!module_names[qm].qm_fmt_id || 204268157baSJan Kara request_module(module_names[qm].qm_mod_name)) 205884d179dSJan Kara return NULL; 206884d179dSJan Kara 207884d179dSJan Kara spin_lock(&dq_list_lock); 208268157baSJan Kara for (actqf = quota_formats; actqf && actqf->qf_fmt_id != id; 209268157baSJan Kara actqf = actqf->qf_next) 210268157baSJan Kara ; 211884d179dSJan Kara if (actqf && !try_module_get(actqf->qf_owner)) 212884d179dSJan Kara actqf = NULL; 213884d179dSJan Kara } 214884d179dSJan Kara spin_unlock(&dq_list_lock); 215884d179dSJan Kara return actqf; 216884d179dSJan Kara } 217884d179dSJan Kara 218884d179dSJan Kara static void put_quota_format(struct quota_format_type *fmt) 219884d179dSJan Kara { 220884d179dSJan Kara module_put(fmt->qf_owner); 221884d179dSJan Kara } 222884d179dSJan Kara 223884d179dSJan Kara /* 224884d179dSJan Kara * Dquot List Management: 225884d179dSJan Kara * The quota code uses three lists for dquot management: the inuse_list, 226884d179dSJan Kara * free_dquots, and dquot_hash[] array. A single dquot structure may be 227884d179dSJan Kara * on all three lists, depending on its current state. 228884d179dSJan Kara * 229884d179dSJan Kara * All dquots are placed to the end of inuse_list when first created, and this 230884d179dSJan Kara * list is used for invalidate operation, which must look at every dquot. 231884d179dSJan Kara * 232884d179dSJan Kara * Unused dquots (dq_count == 0) are added to the free_dquots list when freed, 233884d179dSJan Kara * and this list is searched whenever we need an available dquot. Dquots are 234884d179dSJan Kara * removed from the list as soon as they are used again, and 235884d179dSJan Kara * dqstats.free_dquots gives the number of dquots on the list. When 236884d179dSJan Kara * dquot is invalidated it's completely released from memory. 237884d179dSJan Kara * 238884d179dSJan Kara * Dquots with a specific identity (device, type and id) are placed on 239884d179dSJan Kara * one of the dquot_hash[] hash chains. The provides an efficient search 240884d179dSJan Kara * mechanism to locate a specific dquot. 241884d179dSJan Kara */ 242884d179dSJan Kara 243884d179dSJan Kara static LIST_HEAD(inuse_list); 244884d179dSJan Kara static LIST_HEAD(free_dquots); 245884d179dSJan Kara static unsigned int dq_hash_bits, dq_hash_mask; 246884d179dSJan Kara static struct hlist_head *dquot_hash; 247884d179dSJan Kara 248884d179dSJan Kara struct dqstats dqstats; 249884d179dSJan Kara EXPORT_SYMBOL(dqstats); 250884d179dSJan Kara 2510a5a9c72SJan Kara static qsize_t inode_get_rsv_space(struct inode *inode); 252*7b9ca4c6SJan Kara static qsize_t __inode_get_rsv_space(struct inode *inode); 2536184fc0bSJan Kara static int __dquot_initialize(struct inode *inode, int type); 2540a5a9c72SJan Kara 255884d179dSJan Kara static inline unsigned int 2561a06d420SEric W. Biederman hashfn(const struct super_block *sb, struct kqid qid) 257884d179dSJan Kara { 2581a06d420SEric W. Biederman unsigned int id = from_kqid(&init_user_ns, qid); 2591a06d420SEric W. Biederman int type = qid.type; 260884d179dSJan Kara unsigned long tmp; 261884d179dSJan Kara 262884d179dSJan Kara tmp = (((unsigned long)sb>>L1_CACHE_SHIFT) ^ id) * (MAXQUOTAS - type); 263884d179dSJan Kara return (tmp + (tmp >> dq_hash_bits)) & dq_hash_mask; 264884d179dSJan Kara } 265884d179dSJan Kara 266884d179dSJan Kara /* 267884d179dSJan Kara * Following list functions expect dq_list_lock to be held 268884d179dSJan Kara */ 269884d179dSJan Kara static inline void insert_dquot_hash(struct dquot *dquot) 270884d179dSJan Kara { 271268157baSJan Kara struct hlist_head *head; 2721a06d420SEric W. Biederman head = dquot_hash + hashfn(dquot->dq_sb, dquot->dq_id); 273884d179dSJan Kara hlist_add_head(&dquot->dq_hash, head); 274884d179dSJan Kara } 275884d179dSJan Kara 276884d179dSJan Kara static inline void remove_dquot_hash(struct dquot *dquot) 277884d179dSJan Kara { 278884d179dSJan Kara hlist_del_init(&dquot->dq_hash); 279884d179dSJan Kara } 280884d179dSJan Kara 2817a2435d8SJan Kara static struct dquot *find_dquot(unsigned int hashent, struct super_block *sb, 2821a06d420SEric W. Biederman struct kqid qid) 283884d179dSJan Kara { 284884d179dSJan Kara struct hlist_node *node; 285884d179dSJan Kara struct dquot *dquot; 286884d179dSJan Kara 287884d179dSJan Kara hlist_for_each (node, dquot_hash+hashent) { 288884d179dSJan Kara dquot = hlist_entry(node, struct dquot, dq_hash); 2894c376dcaSEric W. Biederman if (dquot->dq_sb == sb && qid_eq(dquot->dq_id, qid)) 290884d179dSJan Kara return dquot; 291884d179dSJan Kara } 292dd6f3c6dSJan Kara return NULL; 293884d179dSJan Kara } 294884d179dSJan Kara 295884d179dSJan Kara /* Add a dquot to the tail of the free list */ 296884d179dSJan Kara static inline void put_dquot_last(struct dquot *dquot) 297884d179dSJan Kara { 298884d179dSJan Kara list_add_tail(&dquot->dq_free, &free_dquots); 299dde95888SDmitry Monakhov dqstats_inc(DQST_FREE_DQUOTS); 300884d179dSJan Kara } 301884d179dSJan Kara 302884d179dSJan Kara static inline void remove_free_dquot(struct dquot *dquot) 303884d179dSJan Kara { 304884d179dSJan Kara if (list_empty(&dquot->dq_free)) 305884d179dSJan Kara return; 306884d179dSJan Kara list_del_init(&dquot->dq_free); 307dde95888SDmitry Monakhov dqstats_dec(DQST_FREE_DQUOTS); 308884d179dSJan Kara } 309884d179dSJan Kara 310884d179dSJan Kara static inline void put_inuse(struct dquot *dquot) 311884d179dSJan Kara { 312884d179dSJan Kara /* We add to the back of inuse list so we don't have to restart 313884d179dSJan Kara * when traversing this list and we block */ 314884d179dSJan Kara list_add_tail(&dquot->dq_inuse, &inuse_list); 315dde95888SDmitry Monakhov dqstats_inc(DQST_ALLOC_DQUOTS); 316884d179dSJan Kara } 317884d179dSJan Kara 318884d179dSJan Kara static inline void remove_inuse(struct dquot *dquot) 319884d179dSJan Kara { 320dde95888SDmitry Monakhov dqstats_dec(DQST_ALLOC_DQUOTS); 321884d179dSJan Kara list_del(&dquot->dq_inuse); 322884d179dSJan Kara } 323884d179dSJan Kara /* 324884d179dSJan Kara * End of list functions needing dq_list_lock 325884d179dSJan Kara */ 326884d179dSJan Kara 327884d179dSJan Kara static void wait_on_dquot(struct dquot *dquot) 328884d179dSJan Kara { 329884d179dSJan Kara mutex_lock(&dquot->dq_lock); 330884d179dSJan Kara mutex_unlock(&dquot->dq_lock); 331884d179dSJan Kara } 332884d179dSJan Kara 333884d179dSJan Kara static inline int dquot_dirty(struct dquot *dquot) 334884d179dSJan Kara { 335884d179dSJan Kara return test_bit(DQ_MOD_B, &dquot->dq_flags); 336884d179dSJan Kara } 337884d179dSJan Kara 338884d179dSJan Kara static inline int mark_dquot_dirty(struct dquot *dquot) 339884d179dSJan Kara { 340884d179dSJan Kara return dquot->dq_sb->dq_op->mark_dirty(dquot); 341884d179dSJan Kara } 342884d179dSJan Kara 343eabf290dSDmitry Monakhov /* Mark dquot dirty in atomic manner, and return it's old dirty flag state */ 344884d179dSJan Kara int dquot_mark_dquot_dirty(struct dquot *dquot) 345884d179dSJan Kara { 346eabf290dSDmitry Monakhov int ret = 1; 347eabf290dSDmitry Monakhov 3484580b30eSJan Kara if (!test_bit(DQ_ACTIVE_B, &dquot->dq_flags)) 3494580b30eSJan Kara return 0; 3504580b30eSJan Kara 351834057bfSJan Kara if (sb_dqopt(dquot->dq_sb)->flags & DQUOT_NOLIST_DIRTY) 352834057bfSJan Kara return test_and_set_bit(DQ_MOD_B, &dquot->dq_flags); 353834057bfSJan Kara 354eabf290dSDmitry Monakhov /* If quota is dirty already, we don't have to acquire dq_list_lock */ 355eabf290dSDmitry Monakhov if (test_bit(DQ_MOD_B, &dquot->dq_flags)) 356eabf290dSDmitry Monakhov return 1; 357eabf290dSDmitry Monakhov 358884d179dSJan Kara spin_lock(&dq_list_lock); 359eabf290dSDmitry Monakhov if (!test_and_set_bit(DQ_MOD_B, &dquot->dq_flags)) { 360884d179dSJan Kara list_add(&dquot->dq_dirty, &sb_dqopt(dquot->dq_sb)-> 3614c376dcaSEric W. Biederman info[dquot->dq_id.type].dqi_dirty_list); 362eabf290dSDmitry Monakhov ret = 0; 363eabf290dSDmitry Monakhov } 364884d179dSJan Kara spin_unlock(&dq_list_lock); 365eabf290dSDmitry Monakhov return ret; 366884d179dSJan Kara } 367884d179dSJan Kara EXPORT_SYMBOL(dquot_mark_dquot_dirty); 368884d179dSJan Kara 369dc52dd3aSDmitry Monakhov /* Dirtify all the dquots - this can block when journalling */ 370dc52dd3aSDmitry Monakhov static inline int mark_all_dquot_dirty(struct dquot * const *dquot) 371dc52dd3aSDmitry Monakhov { 372dc52dd3aSDmitry Monakhov int ret, err, cnt; 373dc52dd3aSDmitry Monakhov 374dc52dd3aSDmitry Monakhov ret = err = 0; 375dc52dd3aSDmitry Monakhov for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 376dc52dd3aSDmitry Monakhov if (dquot[cnt]) 377dc52dd3aSDmitry Monakhov /* Even in case of error we have to continue */ 378dc52dd3aSDmitry Monakhov ret = mark_dquot_dirty(dquot[cnt]); 379dc52dd3aSDmitry Monakhov if (!err) 380dc52dd3aSDmitry Monakhov err = ret; 381dc52dd3aSDmitry Monakhov } 382dc52dd3aSDmitry Monakhov return err; 383dc52dd3aSDmitry Monakhov } 384dc52dd3aSDmitry Monakhov 385dc52dd3aSDmitry Monakhov static inline void dqput_all(struct dquot **dquot) 386dc52dd3aSDmitry Monakhov { 387dc52dd3aSDmitry Monakhov unsigned int cnt; 388dc52dd3aSDmitry Monakhov 389dc52dd3aSDmitry Monakhov for (cnt = 0; cnt < MAXQUOTAS; cnt++) 390dc52dd3aSDmitry Monakhov dqput(dquot[cnt]); 391dc52dd3aSDmitry Monakhov } 392dc52dd3aSDmitry Monakhov 393884d179dSJan Kara static inline int clear_dquot_dirty(struct dquot *dquot) 394884d179dSJan Kara { 395834057bfSJan Kara if (sb_dqopt(dquot->dq_sb)->flags & DQUOT_NOLIST_DIRTY) 396834057bfSJan Kara return test_and_clear_bit(DQ_MOD_B, &dquot->dq_flags); 397834057bfSJan Kara 3981e0b7cb0SJan Kara spin_lock(&dq_list_lock); 3991e0b7cb0SJan Kara if (!test_and_clear_bit(DQ_MOD_B, &dquot->dq_flags)) { 4001e0b7cb0SJan Kara spin_unlock(&dq_list_lock); 401884d179dSJan Kara return 0; 4021e0b7cb0SJan Kara } 403884d179dSJan Kara list_del_init(&dquot->dq_dirty); 4041e0b7cb0SJan Kara spin_unlock(&dq_list_lock); 405884d179dSJan Kara return 1; 406884d179dSJan Kara } 407884d179dSJan Kara 408884d179dSJan Kara void mark_info_dirty(struct super_block *sb, int type) 409884d179dSJan Kara { 41015512377SJan Kara spin_lock(&dq_data_lock); 41115512377SJan Kara sb_dqopt(sb)->info[type].dqi_flags |= DQF_INFO_DIRTY; 41215512377SJan Kara spin_unlock(&dq_data_lock); 413884d179dSJan Kara } 414884d179dSJan Kara EXPORT_SYMBOL(mark_info_dirty); 415884d179dSJan Kara 416884d179dSJan Kara /* 417884d179dSJan Kara * Read dquot from disk and alloc space for it 418884d179dSJan Kara */ 419884d179dSJan Kara 420884d179dSJan Kara int dquot_acquire(struct dquot *dquot) 421884d179dSJan Kara { 422884d179dSJan Kara int ret = 0, ret2 = 0; 423884d179dSJan Kara struct quota_info *dqopt = sb_dqopt(dquot->dq_sb); 424884d179dSJan Kara 425884d179dSJan Kara mutex_lock(&dquot->dq_lock); 426e342e38dSJan Kara if (!test_bit(DQ_READ_B, &dquot->dq_flags)) 4274c376dcaSEric W. Biederman ret = dqopt->ops[dquot->dq_id.type]->read_dqblk(dquot); 428884d179dSJan Kara if (ret < 0) 429884d179dSJan Kara goto out_iolock; 430044c9b67SJan Kara /* Make sure flags update is visible after dquot has been filled */ 431044c9b67SJan Kara smp_mb__before_atomic(); 432884d179dSJan Kara set_bit(DQ_READ_B, &dquot->dq_flags); 433884d179dSJan Kara /* Instantiate dquot if needed */ 434884d179dSJan Kara if (!test_bit(DQ_ACTIVE_B, &dquot->dq_flags) && !dquot->dq_off) { 4354c376dcaSEric W. Biederman ret = dqopt->ops[dquot->dq_id.type]->commit_dqblk(dquot); 436884d179dSJan Kara /* Write the info if needed */ 4374c376dcaSEric W. Biederman if (info_dirty(&dqopt->info[dquot->dq_id.type])) { 4384c376dcaSEric W. Biederman ret2 = dqopt->ops[dquot->dq_id.type]->write_file_info( 4394c376dcaSEric W. Biederman dquot->dq_sb, dquot->dq_id.type); 4408fc32c2bSJan Kara } 441884d179dSJan Kara if (ret < 0) 442884d179dSJan Kara goto out_iolock; 443884d179dSJan Kara if (ret2 < 0) { 444884d179dSJan Kara ret = ret2; 445884d179dSJan Kara goto out_iolock; 446884d179dSJan Kara } 447884d179dSJan Kara } 448044c9b67SJan Kara /* 449044c9b67SJan Kara * Make sure flags update is visible after on-disk struct has been 450044c9b67SJan Kara * allocated. Paired with smp_rmb() in dqget(). 451044c9b67SJan Kara */ 452044c9b67SJan Kara smp_mb__before_atomic(); 453884d179dSJan Kara set_bit(DQ_ACTIVE_B, &dquot->dq_flags); 454884d179dSJan Kara out_iolock: 455884d179dSJan Kara mutex_unlock(&dquot->dq_lock); 456884d179dSJan Kara return ret; 457884d179dSJan Kara } 458884d179dSJan Kara EXPORT_SYMBOL(dquot_acquire); 459884d179dSJan Kara 460884d179dSJan Kara /* 461884d179dSJan Kara * Write dquot to disk 462884d179dSJan Kara */ 463884d179dSJan Kara int dquot_commit(struct dquot *dquot) 464884d179dSJan Kara { 465b03f2456SJan Kara int ret = 0; 466884d179dSJan Kara struct quota_info *dqopt = sb_dqopt(dquot->dq_sb); 467884d179dSJan Kara 4685e8cb9b6SJan Kara mutex_lock(&dquot->dq_lock); 4691e0b7cb0SJan Kara if (!clear_dquot_dirty(dquot)) 4705e8cb9b6SJan Kara goto out_lock; 471884d179dSJan Kara /* Inactive dquot can be only if there was error during read/init 472884d179dSJan Kara * => we have better not writing it */ 4738fc32c2bSJan Kara if (test_bit(DQ_ACTIVE_B, &dquot->dq_flags)) 4744c376dcaSEric W. Biederman ret = dqopt->ops[dquot->dq_id.type]->commit_dqblk(dquot); 4758fc32c2bSJan Kara else 4765e8cb9b6SJan Kara ret = -EIO; 4775e8cb9b6SJan Kara out_lock: 4785e8cb9b6SJan Kara mutex_unlock(&dquot->dq_lock); 479884d179dSJan Kara return ret; 480884d179dSJan Kara } 481884d179dSJan Kara EXPORT_SYMBOL(dquot_commit); 482884d179dSJan Kara 483884d179dSJan Kara /* 484884d179dSJan Kara * Release dquot 485884d179dSJan Kara */ 486884d179dSJan Kara int dquot_release(struct dquot *dquot) 487884d179dSJan Kara { 488884d179dSJan Kara int ret = 0, ret2 = 0; 489884d179dSJan Kara struct quota_info *dqopt = sb_dqopt(dquot->dq_sb); 490884d179dSJan Kara 491884d179dSJan Kara mutex_lock(&dquot->dq_lock); 492884d179dSJan Kara /* Check whether we are not racing with some other dqget() */ 493884d179dSJan Kara if (atomic_read(&dquot->dq_count) > 1) 494884d179dSJan Kara goto out_dqlock; 4954c376dcaSEric W. Biederman if (dqopt->ops[dquot->dq_id.type]->release_dqblk) { 4964c376dcaSEric W. Biederman ret = dqopt->ops[dquot->dq_id.type]->release_dqblk(dquot); 497884d179dSJan Kara /* Write the info */ 4984c376dcaSEric W. Biederman if (info_dirty(&dqopt->info[dquot->dq_id.type])) { 4994c376dcaSEric W. Biederman ret2 = dqopt->ops[dquot->dq_id.type]->write_file_info( 5004c376dcaSEric W. Biederman dquot->dq_sb, dquot->dq_id.type); 501268157baSJan Kara } 502884d179dSJan Kara if (ret >= 0) 503884d179dSJan Kara ret = ret2; 504884d179dSJan Kara } 505884d179dSJan Kara clear_bit(DQ_ACTIVE_B, &dquot->dq_flags); 506884d179dSJan Kara out_dqlock: 507884d179dSJan Kara mutex_unlock(&dquot->dq_lock); 508884d179dSJan Kara return ret; 509884d179dSJan Kara } 510884d179dSJan Kara EXPORT_SYMBOL(dquot_release); 511884d179dSJan Kara 512884d179dSJan Kara void dquot_destroy(struct dquot *dquot) 513884d179dSJan Kara { 514884d179dSJan Kara kmem_cache_free(dquot_cachep, dquot); 515884d179dSJan Kara } 516884d179dSJan Kara EXPORT_SYMBOL(dquot_destroy); 517884d179dSJan Kara 518884d179dSJan Kara static inline void do_destroy_dquot(struct dquot *dquot) 519884d179dSJan Kara { 520884d179dSJan Kara dquot->dq_sb->dq_op->destroy_dquot(dquot); 521884d179dSJan Kara } 522884d179dSJan Kara 523884d179dSJan Kara /* Invalidate all dquots on the list. Note that this function is called after 524884d179dSJan Kara * quota is disabled and pointers from inodes removed so there cannot be new 525884d179dSJan Kara * quota users. There can still be some users of quotas due to inodes being 526884d179dSJan Kara * just deleted or pruned by prune_icache() (those are not attached to any 527884d179dSJan Kara * list) or parallel quotactl call. We have to wait for such users. 528884d179dSJan Kara */ 529884d179dSJan Kara static void invalidate_dquots(struct super_block *sb, int type) 530884d179dSJan Kara { 531884d179dSJan Kara struct dquot *dquot, *tmp; 532884d179dSJan Kara 533884d179dSJan Kara restart: 534884d179dSJan Kara spin_lock(&dq_list_lock); 535884d179dSJan Kara list_for_each_entry_safe(dquot, tmp, &inuse_list, dq_inuse) { 536884d179dSJan Kara if (dquot->dq_sb != sb) 537884d179dSJan Kara continue; 5384c376dcaSEric W. Biederman if (dquot->dq_id.type != type) 539884d179dSJan Kara continue; 540884d179dSJan Kara /* Wait for dquot users */ 541884d179dSJan Kara if (atomic_read(&dquot->dq_count)) { 5429f985cb6SJan Kara dqgrab(dquot); 543884d179dSJan Kara spin_unlock(&dq_list_lock); 544503330f3SJan Kara /* 545503330f3SJan Kara * Once dqput() wakes us up, we know it's time to free 546884d179dSJan Kara * the dquot. 547884d179dSJan Kara * IMPORTANT: we rely on the fact that there is always 548884d179dSJan Kara * at most one process waiting for dquot to free. 549884d179dSJan Kara * Otherwise dq_count would be > 1 and we would never 550884d179dSJan Kara * wake up. 551884d179dSJan Kara */ 552503330f3SJan Kara wait_event(dquot_ref_wq, 553503330f3SJan Kara atomic_read(&dquot->dq_count) == 1); 554884d179dSJan Kara dqput(dquot); 555884d179dSJan Kara /* At this moment dquot() need not exist (it could be 556884d179dSJan Kara * reclaimed by prune_dqcache(). Hence we must 557884d179dSJan Kara * restart. */ 558884d179dSJan Kara goto restart; 559884d179dSJan Kara } 560884d179dSJan Kara /* 561884d179dSJan Kara * Quota now has no users and it has been written on last 562884d179dSJan Kara * dqput() 563884d179dSJan Kara */ 564884d179dSJan Kara remove_dquot_hash(dquot); 565884d179dSJan Kara remove_free_dquot(dquot); 566884d179dSJan Kara remove_inuse(dquot); 567884d179dSJan Kara do_destroy_dquot(dquot); 568884d179dSJan Kara } 569884d179dSJan Kara spin_unlock(&dq_list_lock); 570884d179dSJan Kara } 571884d179dSJan Kara 572884d179dSJan Kara /* Call callback for every active dquot on given filesystem */ 573884d179dSJan Kara int dquot_scan_active(struct super_block *sb, 574884d179dSJan Kara int (*fn)(struct dquot *dquot, unsigned long priv), 575884d179dSJan Kara unsigned long priv) 576884d179dSJan Kara { 577884d179dSJan Kara struct dquot *dquot, *old_dquot = NULL; 578884d179dSJan Kara int ret = 0; 579884d179dSJan Kara 580ee1ac541SJan Kara WARN_ON_ONCE(!rwsem_is_locked(&sb->s_umount)); 581ee1ac541SJan Kara 582884d179dSJan Kara spin_lock(&dq_list_lock); 583884d179dSJan Kara list_for_each_entry(dquot, &inuse_list, dq_inuse) { 584884d179dSJan Kara if (!test_bit(DQ_ACTIVE_B, &dquot->dq_flags)) 585884d179dSJan Kara continue; 586884d179dSJan Kara if (dquot->dq_sb != sb) 587884d179dSJan Kara continue; 588884d179dSJan Kara /* Now we have active dquot so we can just increase use count */ 589884d179dSJan Kara atomic_inc(&dquot->dq_count); 590884d179dSJan Kara spin_unlock(&dq_list_lock); 591dde95888SDmitry Monakhov dqstats_inc(DQST_LOOKUPS); 592884d179dSJan Kara dqput(old_dquot); 593884d179dSJan Kara old_dquot = dquot; 5941362f4eaSJan Kara /* 5951362f4eaSJan Kara * ->release_dquot() can be racing with us. Our reference 5961362f4eaSJan Kara * protects us from new calls to it so just wait for any 5971362f4eaSJan Kara * outstanding call and recheck the DQ_ACTIVE_B after that. 5981362f4eaSJan Kara */ 5991362f4eaSJan Kara wait_on_dquot(dquot); 6001362f4eaSJan Kara if (test_bit(DQ_ACTIVE_B, &dquot->dq_flags)) { 601884d179dSJan Kara ret = fn(dquot, priv); 602884d179dSJan Kara if (ret < 0) 603884d179dSJan Kara goto out; 6041362f4eaSJan Kara } 605884d179dSJan Kara spin_lock(&dq_list_lock); 606884d179dSJan Kara /* We are safe to continue now because our dquot could not 607884d179dSJan Kara * be moved out of the inuse list while we hold the reference */ 608884d179dSJan Kara } 609884d179dSJan Kara spin_unlock(&dq_list_lock); 610884d179dSJan Kara out: 611884d179dSJan Kara dqput(old_dquot); 612884d179dSJan Kara return ret; 613884d179dSJan Kara } 614884d179dSJan Kara EXPORT_SYMBOL(dquot_scan_active); 615884d179dSJan Kara 616ceed1723SJan Kara /* Write all dquot structures to quota files */ 617ceed1723SJan Kara int dquot_writeback_dquots(struct super_block *sb, int type) 618884d179dSJan Kara { 619884d179dSJan Kara struct list_head *dirty; 620884d179dSJan Kara struct dquot *dquot; 621884d179dSJan Kara struct quota_info *dqopt = sb_dqopt(sb); 622884d179dSJan Kara int cnt; 623ceed1723SJan Kara int err, ret = 0; 624884d179dSJan Kara 6259d1ccbe7SJan Kara WARN_ON_ONCE(!rwsem_is_locked(&sb->s_umount)); 6269d1ccbe7SJan Kara 627884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 628884d179dSJan Kara if (type != -1 && cnt != type) 629884d179dSJan Kara continue; 630884d179dSJan Kara if (!sb_has_quota_active(sb, cnt)) 631884d179dSJan Kara continue; 632884d179dSJan Kara spin_lock(&dq_list_lock); 633884d179dSJan Kara dirty = &dqopt->info[cnt].dqi_dirty_list; 634884d179dSJan Kara while (!list_empty(dirty)) { 635268157baSJan Kara dquot = list_first_entry(dirty, struct dquot, 636268157baSJan Kara dq_dirty); 6374580b30eSJan Kara 6384580b30eSJan Kara WARN_ON(!test_bit(DQ_ACTIVE_B, &dquot->dq_flags)); 6394580b30eSJan Kara 640884d179dSJan Kara /* Now we have active dquot from which someone is 641884d179dSJan Kara * holding reference so we can safely just increase 642884d179dSJan Kara * use count */ 6439f985cb6SJan Kara dqgrab(dquot); 644884d179dSJan Kara spin_unlock(&dq_list_lock); 645dde95888SDmitry Monakhov dqstats_inc(DQST_LOOKUPS); 646ceed1723SJan Kara err = sb->dq_op->write_dquot(dquot); 647ceed1723SJan Kara if (!ret && err) 648474d2605SJan Kara ret = err; 649884d179dSJan Kara dqput(dquot); 650884d179dSJan Kara spin_lock(&dq_list_lock); 651884d179dSJan Kara } 652884d179dSJan Kara spin_unlock(&dq_list_lock); 653884d179dSJan Kara } 654884d179dSJan Kara 655884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) 656884d179dSJan Kara if ((cnt == type || type == -1) && sb_has_quota_active(sb, cnt) 657884d179dSJan Kara && info_dirty(&dqopt->info[cnt])) 658884d179dSJan Kara sb->dq_op->write_info(sb, cnt); 659dde95888SDmitry Monakhov dqstats_inc(DQST_SYNCS); 660884d179dSJan Kara 661ceed1723SJan Kara return ret; 662ceed1723SJan Kara } 663ceed1723SJan Kara EXPORT_SYMBOL(dquot_writeback_dquots); 664ceed1723SJan Kara 665ceed1723SJan Kara /* Write all dquot structures to disk and make them visible from userspace */ 666ceed1723SJan Kara int dquot_quota_sync(struct super_block *sb, int type) 667ceed1723SJan Kara { 668ceed1723SJan Kara struct quota_info *dqopt = sb_dqopt(sb); 669ceed1723SJan Kara int cnt; 670ceed1723SJan Kara int ret; 671ceed1723SJan Kara 672ceed1723SJan Kara ret = dquot_writeback_dquots(sb, type); 673ceed1723SJan Kara if (ret) 674ceed1723SJan Kara return ret; 675ceed1723SJan Kara if (dqopt->flags & DQUOT_QUOTA_SYS_FILE) 6765fb324adSChristoph Hellwig return 0; 6775fb324adSChristoph Hellwig 6785fb324adSChristoph Hellwig /* This is not very clever (and fast) but currently I don't know about 6795fb324adSChristoph Hellwig * any other simple way of getting quota data to disk and we must get 6805fb324adSChristoph Hellwig * them there for userspace to be visible... */ 6815fb324adSChristoph Hellwig if (sb->s_op->sync_fs) 6825fb324adSChristoph Hellwig sb->s_op->sync_fs(sb, 1); 6835fb324adSChristoph Hellwig sync_blockdev(sb->s_bdev); 6845fb324adSChristoph Hellwig 6855fb324adSChristoph Hellwig /* 6865fb324adSChristoph Hellwig * Now when everything is written we can discard the pagecache so 6875fb324adSChristoph Hellwig * that userspace sees the changes. 6885fb324adSChristoph Hellwig */ 6895fb324adSChristoph Hellwig for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 6905fb324adSChristoph Hellwig if (type != -1 && cnt != type) 6915fb324adSChristoph Hellwig continue; 6925fb324adSChristoph Hellwig if (!sb_has_quota_active(sb, cnt)) 6935fb324adSChristoph Hellwig continue; 6945955102cSAl Viro inode_lock(dqopt->files[cnt]); 695f9ef1784SJan Kara truncate_inode_pages(&dqopt->files[cnt]->i_data, 0); 6965955102cSAl Viro inode_unlock(dqopt->files[cnt]); 6975fb324adSChristoph Hellwig } 6985fb324adSChristoph Hellwig 699884d179dSJan Kara return 0; 700884d179dSJan Kara } 701287a8095SChristoph Hellwig EXPORT_SYMBOL(dquot_quota_sync); 702884d179dSJan Kara 7031ab6c499SDave Chinner static unsigned long 7041ab6c499SDave Chinner dqcache_shrink_scan(struct shrinker *shrink, struct shrink_control *sc) 705884d179dSJan Kara { 706884d179dSJan Kara struct list_head *head; 707884d179dSJan Kara struct dquot *dquot; 7081ab6c499SDave Chinner unsigned long freed = 0; 709884d179dSJan Kara 710d68aab6bSNiu Yawei spin_lock(&dq_list_lock); 711884d179dSJan Kara head = free_dquots.prev; 7121ab6c499SDave Chinner while (head != &free_dquots && sc->nr_to_scan) { 713884d179dSJan Kara dquot = list_entry(head, struct dquot, dq_free); 714884d179dSJan Kara remove_dquot_hash(dquot); 715884d179dSJan Kara remove_free_dquot(dquot); 716884d179dSJan Kara remove_inuse(dquot); 717884d179dSJan Kara do_destroy_dquot(dquot); 7181ab6c499SDave Chinner sc->nr_to_scan--; 7191ab6c499SDave Chinner freed++; 720884d179dSJan Kara head = free_dquots.prev; 721884d179dSJan Kara } 722d68aab6bSNiu Yawei spin_unlock(&dq_list_lock); 7231ab6c499SDave Chinner return freed; 724884d179dSJan Kara } 725884d179dSJan Kara 7261ab6c499SDave Chinner static unsigned long 7271ab6c499SDave Chinner dqcache_shrink_count(struct shrinker *shrink, struct shrink_control *sc) 728884d179dSJan Kara { 72955f841ceSGlauber Costa return vfs_pressure_ratio( 73055f841ceSGlauber Costa percpu_counter_read_positive(&dqstats.counter[DQST_FREE_DQUOTS])); 731884d179dSJan Kara } 732884d179dSJan Kara 733884d179dSJan Kara static struct shrinker dqcache_shrinker = { 7341ab6c499SDave Chinner .count_objects = dqcache_shrink_count, 7351ab6c499SDave Chinner .scan_objects = dqcache_shrink_scan, 736884d179dSJan Kara .seeks = DEFAULT_SEEKS, 737884d179dSJan Kara }; 738884d179dSJan Kara 739884d179dSJan Kara /* 740884d179dSJan Kara * Put reference to dquot 741884d179dSJan Kara */ 742884d179dSJan Kara void dqput(struct dquot *dquot) 743884d179dSJan Kara { 744884d179dSJan Kara int ret; 745884d179dSJan Kara 746884d179dSJan Kara if (!dquot) 747884d179dSJan Kara return; 74862af9b52SJan Kara #ifdef CONFIG_QUOTA_DEBUG 749884d179dSJan Kara if (!atomic_read(&dquot->dq_count)) { 750fb5ffb0eSJiaying Zhang quota_error(dquot->dq_sb, "trying to free free dquot of %s %d", 7514c376dcaSEric W. Biederman quotatypes[dquot->dq_id.type], 7524c376dcaSEric W. Biederman from_kqid(&init_user_ns, dquot->dq_id)); 753884d179dSJan Kara BUG(); 754884d179dSJan Kara } 755884d179dSJan Kara #endif 756dde95888SDmitry Monakhov dqstats_inc(DQST_DROPS); 757884d179dSJan Kara we_slept: 758884d179dSJan Kara spin_lock(&dq_list_lock); 759884d179dSJan Kara if (atomic_read(&dquot->dq_count) > 1) { 760884d179dSJan Kara /* We have more than one user... nothing to do */ 761884d179dSJan Kara atomic_dec(&dquot->dq_count); 762884d179dSJan Kara /* Releasing dquot during quotaoff phase? */ 7634c376dcaSEric W. Biederman if (!sb_has_quota_active(dquot->dq_sb, dquot->dq_id.type) && 764884d179dSJan Kara atomic_read(&dquot->dq_count) == 1) 765503330f3SJan Kara wake_up(&dquot_ref_wq); 766884d179dSJan Kara spin_unlock(&dq_list_lock); 767884d179dSJan Kara return; 768884d179dSJan Kara } 769884d179dSJan Kara /* Need to release dquot? */ 7704580b30eSJan Kara if (dquot_dirty(dquot)) { 771884d179dSJan Kara spin_unlock(&dq_list_lock); 772884d179dSJan Kara /* Commit dquot before releasing */ 773884d179dSJan Kara ret = dquot->dq_sb->dq_op->write_dquot(dquot); 774884d179dSJan Kara if (ret < 0) { 775fb5ffb0eSJiaying Zhang quota_error(dquot->dq_sb, "Can't write quota structure" 776fb5ffb0eSJiaying Zhang " (error %d). Quota may get out of sync!", 777fb5ffb0eSJiaying Zhang ret); 778884d179dSJan Kara /* 779884d179dSJan Kara * We clear dirty bit anyway, so that we avoid 780884d179dSJan Kara * infinite loop here 781884d179dSJan Kara */ 782884d179dSJan Kara clear_dquot_dirty(dquot); 783884d179dSJan Kara } 784884d179dSJan Kara goto we_slept; 785884d179dSJan Kara } 786884d179dSJan Kara if (test_bit(DQ_ACTIVE_B, &dquot->dq_flags)) { 787884d179dSJan Kara spin_unlock(&dq_list_lock); 788884d179dSJan Kara dquot->dq_sb->dq_op->release_dquot(dquot); 789884d179dSJan Kara goto we_slept; 790884d179dSJan Kara } 791884d179dSJan Kara atomic_dec(&dquot->dq_count); 79262af9b52SJan Kara #ifdef CONFIG_QUOTA_DEBUG 793884d179dSJan Kara /* sanity check */ 794884d179dSJan Kara BUG_ON(!list_empty(&dquot->dq_free)); 795884d179dSJan Kara #endif 796884d179dSJan Kara put_dquot_last(dquot); 797884d179dSJan Kara spin_unlock(&dq_list_lock); 798884d179dSJan Kara } 799884d179dSJan Kara EXPORT_SYMBOL(dqput); 800884d179dSJan Kara 801884d179dSJan Kara struct dquot *dquot_alloc(struct super_block *sb, int type) 802884d179dSJan Kara { 803884d179dSJan Kara return kmem_cache_zalloc(dquot_cachep, GFP_NOFS); 804884d179dSJan Kara } 805884d179dSJan Kara EXPORT_SYMBOL(dquot_alloc); 806884d179dSJan Kara 807884d179dSJan Kara static struct dquot *get_empty_dquot(struct super_block *sb, int type) 808884d179dSJan Kara { 809884d179dSJan Kara struct dquot *dquot; 810884d179dSJan Kara 811884d179dSJan Kara dquot = sb->dq_op->alloc_dquot(sb, type); 812884d179dSJan Kara if(!dquot) 813dd6f3c6dSJan Kara return NULL; 814884d179dSJan Kara 815884d179dSJan Kara mutex_init(&dquot->dq_lock); 816884d179dSJan Kara INIT_LIST_HEAD(&dquot->dq_free); 817884d179dSJan Kara INIT_LIST_HEAD(&dquot->dq_inuse); 818884d179dSJan Kara INIT_HLIST_NODE(&dquot->dq_hash); 819884d179dSJan Kara INIT_LIST_HEAD(&dquot->dq_dirty); 820884d179dSJan Kara dquot->dq_sb = sb; 8211a06d420SEric W. Biederman dquot->dq_id = make_kqid_invalid(type); 822884d179dSJan Kara atomic_set(&dquot->dq_count, 1); 823*7b9ca4c6SJan Kara spin_lock_init(&dquot->dq_dqb_lock); 824884d179dSJan Kara 825884d179dSJan Kara return dquot; 826884d179dSJan Kara } 827884d179dSJan Kara 828884d179dSJan Kara /* 829884d179dSJan Kara * Get reference to dquot 830884d179dSJan Kara * 831884d179dSJan Kara * Locking is slightly tricky here. We are guarded from parallel quotaoff() 832884d179dSJan Kara * destroying our dquot by: 833884d179dSJan Kara * a) checking for quota flags under dq_list_lock and 834884d179dSJan Kara * b) getting a reference to dquot before we release dq_list_lock 835884d179dSJan Kara */ 836aca645a6SEric W. Biederman struct dquot *dqget(struct super_block *sb, struct kqid qid) 837884d179dSJan Kara { 8381a06d420SEric W. Biederman unsigned int hashent = hashfn(sb, qid); 8396184fc0bSJan Kara struct dquot *dquot, *empty = NULL; 840884d179dSJan Kara 841d49d3762SEric W. Biederman if (!qid_has_mapping(sb->s_user_ns, qid)) 842d49d3762SEric W. Biederman return ERR_PTR(-EINVAL); 843d49d3762SEric W. Biederman 8441a06d420SEric W. Biederman if (!sb_has_quota_active(sb, qid.type)) 8456184fc0bSJan Kara return ERR_PTR(-ESRCH); 846884d179dSJan Kara we_slept: 847884d179dSJan Kara spin_lock(&dq_list_lock); 848884d179dSJan Kara spin_lock(&dq_state_lock); 8491a06d420SEric W. Biederman if (!sb_has_quota_active(sb, qid.type)) { 850884d179dSJan Kara spin_unlock(&dq_state_lock); 851884d179dSJan Kara spin_unlock(&dq_list_lock); 8526184fc0bSJan Kara dquot = ERR_PTR(-ESRCH); 853884d179dSJan Kara goto out; 854884d179dSJan Kara } 855884d179dSJan Kara spin_unlock(&dq_state_lock); 856884d179dSJan Kara 8571a06d420SEric W. Biederman dquot = find_dquot(hashent, sb, qid); 858dd6f3c6dSJan Kara if (!dquot) { 859dd6f3c6dSJan Kara if (!empty) { 860884d179dSJan Kara spin_unlock(&dq_list_lock); 8611a06d420SEric W. Biederman empty = get_empty_dquot(sb, qid.type); 862dd6f3c6dSJan Kara if (!empty) 863884d179dSJan Kara schedule(); /* Try to wait for a moment... */ 864884d179dSJan Kara goto we_slept; 865884d179dSJan Kara } 866884d179dSJan Kara dquot = empty; 867dd6f3c6dSJan Kara empty = NULL; 8684c376dcaSEric W. Biederman dquot->dq_id = qid; 869884d179dSJan Kara /* all dquots go on the inuse_list */ 870884d179dSJan Kara put_inuse(dquot); 871884d179dSJan Kara /* hash it first so it can be found */ 872884d179dSJan Kara insert_dquot_hash(dquot); 873884d179dSJan Kara spin_unlock(&dq_list_lock); 874dde95888SDmitry Monakhov dqstats_inc(DQST_LOOKUPS); 875884d179dSJan Kara } else { 876884d179dSJan Kara if (!atomic_read(&dquot->dq_count)) 877884d179dSJan Kara remove_free_dquot(dquot); 878884d179dSJan Kara atomic_inc(&dquot->dq_count); 879884d179dSJan Kara spin_unlock(&dq_list_lock); 880dde95888SDmitry Monakhov dqstats_inc(DQST_CACHE_HITS); 881dde95888SDmitry Monakhov dqstats_inc(DQST_LOOKUPS); 882884d179dSJan Kara } 883268157baSJan Kara /* Wait for dq_lock - after this we know that either dquot_release() is 884268157baSJan Kara * already finished or it will be canceled due to dq_count > 1 test */ 885884d179dSJan Kara wait_on_dquot(dquot); 886268157baSJan Kara /* Read the dquot / allocate space in quota file */ 8876184fc0bSJan Kara if (!test_bit(DQ_ACTIVE_B, &dquot->dq_flags)) { 8886184fc0bSJan Kara int err; 8896184fc0bSJan Kara 8906184fc0bSJan Kara err = sb->dq_op->acquire_dquot(dquot); 8916184fc0bSJan Kara if (err < 0) { 892884d179dSJan Kara dqput(dquot); 8936184fc0bSJan Kara dquot = ERR_PTR(err); 894884d179dSJan Kara goto out; 895884d179dSJan Kara } 8966184fc0bSJan Kara } 897044c9b67SJan Kara /* 898044c9b67SJan Kara * Make sure following reads see filled structure - paired with 899044c9b67SJan Kara * smp_mb__before_atomic() in dquot_acquire(). 900044c9b67SJan Kara */ 901044c9b67SJan Kara smp_rmb(); 90262af9b52SJan Kara #ifdef CONFIG_QUOTA_DEBUG 903884d179dSJan Kara BUG_ON(!dquot->dq_sb); /* Has somebody invalidated entry under us? */ 904884d179dSJan Kara #endif 905884d179dSJan Kara out: 906884d179dSJan Kara if (empty) 907884d179dSJan Kara do_destroy_dquot(empty); 908884d179dSJan Kara 909884d179dSJan Kara return dquot; 910884d179dSJan Kara } 911884d179dSJan Kara EXPORT_SYMBOL(dqget); 912884d179dSJan Kara 9132d0fa467SJan Kara static inline struct dquot **i_dquot(struct inode *inode) 9142d0fa467SJan Kara { 9152d0fa467SJan Kara return inode->i_sb->s_op->get_dquots(inode); 9162d0fa467SJan Kara } 9172d0fa467SJan Kara 918884d179dSJan Kara static int dqinit_needed(struct inode *inode, int type) 919884d179dSJan Kara { 9205bcd3b6fSKonstantin Khlebnikov struct dquot * const *dquots; 921884d179dSJan Kara int cnt; 922884d179dSJan Kara 923884d179dSJan Kara if (IS_NOQUOTA(inode)) 924884d179dSJan Kara return 0; 9255bcd3b6fSKonstantin Khlebnikov 9265bcd3b6fSKonstantin Khlebnikov dquots = i_dquot(inode); 927884d179dSJan Kara if (type != -1) 9285bcd3b6fSKonstantin Khlebnikov return !dquots[type]; 929884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) 9305bcd3b6fSKonstantin Khlebnikov if (!dquots[cnt]) 931884d179dSJan Kara return 1; 932884d179dSJan Kara return 0; 933884d179dSJan Kara } 934884d179dSJan Kara 935c3b00446SJan Kara /* This routine is guarded by s_umount semaphore */ 936884d179dSJan Kara static void add_dquot_ref(struct super_block *sb, int type) 937884d179dSJan Kara { 938884d179dSJan Kara struct inode *inode, *old_inode = NULL; 93962af9b52SJan Kara #ifdef CONFIG_QUOTA_DEBUG 9400a5a9c72SJan Kara int reserved = 0; 9414c5e6c0eSJan Kara #endif 942884d179dSJan Kara 94374278da9SDave Chinner spin_lock(&sb->s_inode_list_lock); 944884d179dSJan Kara list_for_each_entry(inode, &sb->s_inodes, i_sb_list) { 945250df6edSDave Chinner spin_lock(&inode->i_lock); 946250df6edSDave Chinner if ((inode->i_state & (I_FREEING|I_WILL_FREE|I_NEW)) || 947250df6edSDave Chinner !atomic_read(&inode->i_writecount) || 948250df6edSDave Chinner !dqinit_needed(inode, type)) { 949250df6edSDave Chinner spin_unlock(&inode->i_lock); 9503ae5080fSLinus Torvalds continue; 951250df6edSDave Chinner } 952884d179dSJan Kara __iget(inode); 953250df6edSDave Chinner spin_unlock(&inode->i_lock); 95474278da9SDave Chinner spin_unlock(&sb->s_inode_list_lock); 955884d179dSJan Kara 956d7e97117SJan Kara #ifdef CONFIG_QUOTA_DEBUG 957d7e97117SJan Kara if (unlikely(inode_get_rsv_space(inode) > 0)) 958d7e97117SJan Kara reserved = 1; 959d7e97117SJan Kara #endif 960884d179dSJan Kara iput(old_inode); 961871a2931SChristoph Hellwig __dquot_initialize(inode, type); 96255fa6091SDave Chinner 96355fa6091SDave Chinner /* 96455fa6091SDave Chinner * We hold a reference to 'inode' so it couldn't have been 96555fa6091SDave Chinner * removed from s_inodes list while we dropped the 96674278da9SDave Chinner * s_inode_list_lock. We cannot iput the inode now as we can be 96755fa6091SDave Chinner * holding the last reference and we cannot iput it under 96874278da9SDave Chinner * s_inode_list_lock. So we keep the reference and iput it 96955fa6091SDave Chinner * later. 97055fa6091SDave Chinner */ 971884d179dSJan Kara old_inode = inode; 97274278da9SDave Chinner spin_lock(&sb->s_inode_list_lock); 973884d179dSJan Kara } 97474278da9SDave Chinner spin_unlock(&sb->s_inode_list_lock); 975884d179dSJan Kara iput(old_inode); 9760a5a9c72SJan Kara 97762af9b52SJan Kara #ifdef CONFIG_QUOTA_DEBUG 9780a5a9c72SJan Kara if (reserved) { 979fb5ffb0eSJiaying Zhang quota_error(sb, "Writes happened before quota was turned on " 980fb5ffb0eSJiaying Zhang "thus quota information is probably inconsistent. " 981fb5ffb0eSJiaying Zhang "Please run quotacheck(8)"); 9820a5a9c72SJan Kara } 9834c5e6c0eSJan Kara #endif 984884d179dSJan Kara } 985884d179dSJan Kara 986268157baSJan Kara /* 987268157baSJan Kara * Remove references to dquots from inode and add dquot to list for freeing 98825985edcSLucas De Marchi * if we have the last reference to dquot 989268157baSJan Kara */ 9909eb6463fSNiu Yawei static void remove_inode_dquot_ref(struct inode *inode, int type, 991884d179dSJan Kara struct list_head *tofree_head) 992884d179dSJan Kara { 9935bcd3b6fSKonstantin Khlebnikov struct dquot **dquots = i_dquot(inode); 9945bcd3b6fSKonstantin Khlebnikov struct dquot *dquot = dquots[type]; 995884d179dSJan Kara 9969eb6463fSNiu Yawei if (!dquot) 9979eb6463fSNiu Yawei return; 9989eb6463fSNiu Yawei 9995bcd3b6fSKonstantin Khlebnikov dquots[type] = NULL; 10009eb6463fSNiu Yawei if (list_empty(&dquot->dq_free)) { 10019eb6463fSNiu Yawei /* 10029eb6463fSNiu Yawei * The inode still has reference to dquot so it can't be in the 10039eb6463fSNiu Yawei * free list 10049eb6463fSNiu Yawei */ 1005884d179dSJan Kara spin_lock(&dq_list_lock); 1006268157baSJan Kara list_add(&dquot->dq_free, tofree_head); 1007884d179dSJan Kara spin_unlock(&dq_list_lock); 10089eb6463fSNiu Yawei } else { 10099eb6463fSNiu Yawei /* 10109eb6463fSNiu Yawei * Dquot is already in a list to put so we won't drop the last 10119eb6463fSNiu Yawei * reference here. 10129eb6463fSNiu Yawei */ 10139eb6463fSNiu Yawei dqput(dquot); 1014884d179dSJan Kara } 1015884d179dSJan Kara } 1016884d179dSJan Kara 1017268157baSJan Kara /* 1018268157baSJan Kara * Free list of dquots 1019268157baSJan Kara * Dquots are removed from inodes and no new references can be got so we are 1020268157baSJan Kara * the only ones holding reference 1021268157baSJan Kara */ 1022884d179dSJan Kara static void put_dquot_list(struct list_head *tofree_head) 1023884d179dSJan Kara { 1024884d179dSJan Kara struct list_head *act_head; 1025884d179dSJan Kara struct dquot *dquot; 1026884d179dSJan Kara 1027884d179dSJan Kara act_head = tofree_head->next; 1028884d179dSJan Kara while (act_head != tofree_head) { 1029884d179dSJan Kara dquot = list_entry(act_head, struct dquot, dq_free); 1030884d179dSJan Kara act_head = act_head->next; 1031268157baSJan Kara /* Remove dquot from the list so we won't have problems... */ 1032268157baSJan Kara list_del_init(&dquot->dq_free); 1033884d179dSJan Kara dqput(dquot); 1034884d179dSJan Kara } 1035884d179dSJan Kara } 1036884d179dSJan Kara 1037884d179dSJan Kara static void remove_dquot_ref(struct super_block *sb, int type, 1038884d179dSJan Kara struct list_head *tofree_head) 1039884d179dSJan Kara { 1040884d179dSJan Kara struct inode *inode; 10417af9cce8SDmitry Monakhov int reserved = 0; 1042884d179dSJan Kara 104374278da9SDave Chinner spin_lock(&sb->s_inode_list_lock); 1044884d179dSJan Kara list_for_each_entry(inode, &sb->s_inodes, i_sb_list) { 10453ae5080fSLinus Torvalds /* 10463ae5080fSLinus Torvalds * We have to scan also I_NEW inodes because they can already 10473ae5080fSLinus Torvalds * have quota pointer initialized. Luckily, we need to touch 10483ae5080fSLinus Torvalds * only quota pointers and these have separate locking 1049b9ba6f94SNiu Yawei * (dq_data_lock). 10503ae5080fSLinus Torvalds */ 1051b9ba6f94SNiu Yawei spin_lock(&dq_data_lock); 10527af9cce8SDmitry Monakhov if (!IS_NOQUOTA(inode)) { 10537af9cce8SDmitry Monakhov if (unlikely(inode_get_rsv_space(inode) > 0)) 10547af9cce8SDmitry Monakhov reserved = 1; 1055884d179dSJan Kara remove_inode_dquot_ref(inode, type, tofree_head); 1056884d179dSJan Kara } 1057b9ba6f94SNiu Yawei spin_unlock(&dq_data_lock); 10587af9cce8SDmitry Monakhov } 105974278da9SDave Chinner spin_unlock(&sb->s_inode_list_lock); 10607af9cce8SDmitry Monakhov #ifdef CONFIG_QUOTA_DEBUG 10617af9cce8SDmitry Monakhov if (reserved) { 10627af9cce8SDmitry Monakhov printk(KERN_WARNING "VFS (%s): Writes happened after quota" 10637af9cce8SDmitry Monakhov " was disabled thus quota information is probably " 10647af9cce8SDmitry Monakhov "inconsistent. Please run quotacheck(8).\n", sb->s_id); 10657af9cce8SDmitry Monakhov } 10667af9cce8SDmitry Monakhov #endif 1067884d179dSJan Kara } 1068884d179dSJan Kara 1069884d179dSJan Kara /* Gather all references from inodes and drop them */ 1070884d179dSJan Kara static void drop_dquot_ref(struct super_block *sb, int type) 1071884d179dSJan Kara { 1072884d179dSJan Kara LIST_HEAD(tofree_head); 1073884d179dSJan Kara 1074884d179dSJan Kara if (sb->dq_op) { 1075884d179dSJan Kara remove_dquot_ref(sb, type, &tofree_head); 1076b9ba6f94SNiu Yawei synchronize_srcu(&dquot_srcu); 1077884d179dSJan Kara put_dquot_list(&tofree_head); 1078884d179dSJan Kara } 1079884d179dSJan Kara } 1080884d179dSJan Kara 1081884d179dSJan Kara static inline 1082884d179dSJan Kara void dquot_free_reserved_space(struct dquot *dquot, qsize_t number) 1083884d179dSJan Kara { 10840a5a9c72SJan Kara if (dquot->dq_dqb.dqb_rsvspace >= number) 1085884d179dSJan Kara dquot->dq_dqb.dqb_rsvspace -= number; 10860a5a9c72SJan Kara else { 10870a5a9c72SJan Kara WARN_ON_ONCE(1); 10880a5a9c72SJan Kara dquot->dq_dqb.dqb_rsvspace = 0; 10890a5a9c72SJan Kara } 1090884d179dSJan Kara } 1091884d179dSJan Kara 10927a2435d8SJan Kara static void dquot_decr_inodes(struct dquot *dquot, qsize_t number) 1093884d179dSJan Kara { 1094884d179dSJan Kara if (sb_dqopt(dquot->dq_sb)->flags & DQUOT_NEGATIVE_USAGE || 1095884d179dSJan Kara dquot->dq_dqb.dqb_curinodes >= number) 1096884d179dSJan Kara dquot->dq_dqb.dqb_curinodes -= number; 1097884d179dSJan Kara else 1098884d179dSJan Kara dquot->dq_dqb.dqb_curinodes = 0; 1099884d179dSJan Kara if (dquot->dq_dqb.dqb_curinodes <= dquot->dq_dqb.dqb_isoftlimit) 1100e008bb61SArnd Bergmann dquot->dq_dqb.dqb_itime = (time64_t) 0; 1101884d179dSJan Kara clear_bit(DQ_INODES_B, &dquot->dq_flags); 1102884d179dSJan Kara } 1103884d179dSJan Kara 11047a2435d8SJan Kara static void dquot_decr_space(struct dquot *dquot, qsize_t number) 1105884d179dSJan Kara { 1106884d179dSJan Kara if (sb_dqopt(dquot->dq_sb)->flags & DQUOT_NEGATIVE_USAGE || 1107884d179dSJan Kara dquot->dq_dqb.dqb_curspace >= number) 1108884d179dSJan Kara dquot->dq_dqb.dqb_curspace -= number; 1109884d179dSJan Kara else 1110884d179dSJan Kara dquot->dq_dqb.dqb_curspace = 0; 1111884d179dSJan Kara if (dquot->dq_dqb.dqb_curspace <= dquot->dq_dqb.dqb_bsoftlimit) 1112e008bb61SArnd Bergmann dquot->dq_dqb.dqb_btime = (time64_t) 0; 1113884d179dSJan Kara clear_bit(DQ_BLKS_B, &dquot->dq_flags); 1114884d179dSJan Kara } 1115884d179dSJan Kara 1116bf097aafSJan Kara struct dquot_warn { 1117bf097aafSJan Kara struct super_block *w_sb; 11187b9c7321SEric W. Biederman struct kqid w_dq_id; 1119bf097aafSJan Kara short w_type; 1120bf097aafSJan Kara }; 1121bf097aafSJan Kara 1122884d179dSJan Kara static int warning_issued(struct dquot *dquot, const int warntype) 1123884d179dSJan Kara { 1124884d179dSJan Kara int flag = (warntype == QUOTA_NL_BHARDWARN || 1125884d179dSJan Kara warntype == QUOTA_NL_BSOFTLONGWARN) ? DQ_BLKS_B : 1126884d179dSJan Kara ((warntype == QUOTA_NL_IHARDWARN || 1127884d179dSJan Kara warntype == QUOTA_NL_ISOFTLONGWARN) ? DQ_INODES_B : 0); 1128884d179dSJan Kara 1129884d179dSJan Kara if (!flag) 1130884d179dSJan Kara return 0; 1131884d179dSJan Kara return test_and_set_bit(flag, &dquot->dq_flags); 1132884d179dSJan Kara } 1133884d179dSJan Kara 1134884d179dSJan Kara #ifdef CONFIG_PRINT_QUOTA_WARNING 1135884d179dSJan Kara static int flag_print_warnings = 1; 1136884d179dSJan Kara 1137bf097aafSJan Kara static int need_print_warning(struct dquot_warn *warn) 1138884d179dSJan Kara { 1139884d179dSJan Kara if (!flag_print_warnings) 1140884d179dSJan Kara return 0; 1141884d179dSJan Kara 11427b9c7321SEric W. Biederman switch (warn->w_dq_id.type) { 1143884d179dSJan Kara case USRQUOTA: 11441a06d420SEric W. Biederman return uid_eq(current_fsuid(), warn->w_dq_id.uid); 1145884d179dSJan Kara case GRPQUOTA: 11467b9c7321SEric W. Biederman return in_group_p(warn->w_dq_id.gid); 1147847aac64SLi Xi case PRJQUOTA: 1148847aac64SLi Xi return 1; 1149884d179dSJan Kara } 1150884d179dSJan Kara return 0; 1151884d179dSJan Kara } 1152884d179dSJan Kara 1153884d179dSJan Kara /* Print warning to user which exceeded quota */ 1154bf097aafSJan Kara static void print_warning(struct dquot_warn *warn) 1155884d179dSJan Kara { 1156884d179dSJan Kara char *msg = NULL; 1157884d179dSJan Kara struct tty_struct *tty; 1158bf097aafSJan Kara int warntype = warn->w_type; 1159884d179dSJan Kara 1160884d179dSJan Kara if (warntype == QUOTA_NL_IHARDBELOW || 1161884d179dSJan Kara warntype == QUOTA_NL_ISOFTBELOW || 1162884d179dSJan Kara warntype == QUOTA_NL_BHARDBELOW || 1163bf097aafSJan Kara warntype == QUOTA_NL_BSOFTBELOW || !need_print_warning(warn)) 1164884d179dSJan Kara return; 1165884d179dSJan Kara 1166884d179dSJan Kara tty = get_current_tty(); 1167884d179dSJan Kara if (!tty) 1168884d179dSJan Kara return; 1169bf097aafSJan Kara tty_write_message(tty, warn->w_sb->s_id); 1170884d179dSJan Kara if (warntype == QUOTA_NL_ISOFTWARN || warntype == QUOTA_NL_BSOFTWARN) 1171884d179dSJan Kara tty_write_message(tty, ": warning, "); 1172884d179dSJan Kara else 1173884d179dSJan Kara tty_write_message(tty, ": write failed, "); 11747b9c7321SEric W. Biederman tty_write_message(tty, quotatypes[warn->w_dq_id.type]); 1175884d179dSJan Kara switch (warntype) { 1176884d179dSJan Kara case QUOTA_NL_IHARDWARN: 1177884d179dSJan Kara msg = " file limit reached.\r\n"; 1178884d179dSJan Kara break; 1179884d179dSJan Kara case QUOTA_NL_ISOFTLONGWARN: 1180884d179dSJan Kara msg = " file quota exceeded too long.\r\n"; 1181884d179dSJan Kara break; 1182884d179dSJan Kara case QUOTA_NL_ISOFTWARN: 1183884d179dSJan Kara msg = " file quota exceeded.\r\n"; 1184884d179dSJan Kara break; 1185884d179dSJan Kara case QUOTA_NL_BHARDWARN: 1186884d179dSJan Kara msg = " block limit reached.\r\n"; 1187884d179dSJan Kara break; 1188884d179dSJan Kara case QUOTA_NL_BSOFTLONGWARN: 1189884d179dSJan Kara msg = " block quota exceeded too long.\r\n"; 1190884d179dSJan Kara break; 1191884d179dSJan Kara case QUOTA_NL_BSOFTWARN: 1192884d179dSJan Kara msg = " block quota exceeded.\r\n"; 1193884d179dSJan Kara break; 1194884d179dSJan Kara } 1195884d179dSJan Kara tty_write_message(tty, msg); 1196884d179dSJan Kara tty_kref_put(tty); 1197884d179dSJan Kara } 1198884d179dSJan Kara #endif 1199884d179dSJan Kara 1200bf097aafSJan Kara static void prepare_warning(struct dquot_warn *warn, struct dquot *dquot, 1201bf097aafSJan Kara int warntype) 1202bf097aafSJan Kara { 1203bf097aafSJan Kara if (warning_issued(dquot, warntype)) 1204bf097aafSJan Kara return; 1205bf097aafSJan Kara warn->w_type = warntype; 1206bf097aafSJan Kara warn->w_sb = dquot->dq_sb; 1207bf097aafSJan Kara warn->w_dq_id = dquot->dq_id; 1208bf097aafSJan Kara } 1209bf097aafSJan Kara 1210884d179dSJan Kara /* 1211884d179dSJan Kara * Write warnings to the console and send warning messages over netlink. 1212884d179dSJan Kara * 1213bf097aafSJan Kara * Note that this function can call into tty and networking code. 1214884d179dSJan Kara */ 1215bf097aafSJan Kara static void flush_warnings(struct dquot_warn *warn) 1216884d179dSJan Kara { 1217884d179dSJan Kara int i; 1218884d179dSJan Kara 121986e931a3SSteven Whitehouse for (i = 0; i < MAXQUOTAS; i++) { 1220bf097aafSJan Kara if (warn[i].w_type == QUOTA_NL_NOWARN) 1221bf097aafSJan Kara continue; 1222884d179dSJan Kara #ifdef CONFIG_PRINT_QUOTA_WARNING 1223bf097aafSJan Kara print_warning(&warn[i]); 1224884d179dSJan Kara #endif 12257b9c7321SEric W. Biederman quota_send_warning(warn[i].w_dq_id, 1226bf097aafSJan Kara warn[i].w_sb->s_dev, warn[i].w_type); 1227884d179dSJan Kara } 1228884d179dSJan Kara } 1229884d179dSJan Kara 12307a2435d8SJan Kara static int ignore_hardlimit(struct dquot *dquot) 1231884d179dSJan Kara { 12324c376dcaSEric W. Biederman struct mem_dqinfo *info = &sb_dqopt(dquot->dq_sb)->info[dquot->dq_id.type]; 1233884d179dSJan Kara 1234884d179dSJan Kara return capable(CAP_SYS_RESOURCE) && 1235268157baSJan Kara (info->dqi_format->qf_fmt_id != QFMT_VFS_OLD || 12369c45101eSJan Kara !(info->dqi_flags & DQF_ROOT_SQUASH)); 1237884d179dSJan Kara } 1238884d179dSJan Kara 1239*7b9ca4c6SJan Kara static int dquot_add_inodes(struct dquot *dquot, qsize_t inodes, 1240bf097aafSJan Kara struct dquot_warn *warn) 1241884d179dSJan Kara { 1242*7b9ca4c6SJan Kara qsize_t newinodes; 1243*7b9ca4c6SJan Kara int ret = 0; 1244268157baSJan Kara 1245*7b9ca4c6SJan Kara spin_lock(&dquot->dq_dqb_lock); 1246*7b9ca4c6SJan Kara newinodes = dquot->dq_dqb.dqb_curinodes + inodes; 12474c376dcaSEric W. Biederman if (!sb_has_quota_limits_enabled(dquot->dq_sb, dquot->dq_id.type) || 1248884d179dSJan Kara test_bit(DQ_FAKE_B, &dquot->dq_flags)) 1249*7b9ca4c6SJan Kara goto add; 1250884d179dSJan Kara 1251884d179dSJan Kara if (dquot->dq_dqb.dqb_ihardlimit && 1252268157baSJan Kara newinodes > dquot->dq_dqb.dqb_ihardlimit && 1253884d179dSJan Kara !ignore_hardlimit(dquot)) { 1254bf097aafSJan Kara prepare_warning(warn, dquot, QUOTA_NL_IHARDWARN); 1255*7b9ca4c6SJan Kara ret = -EDQUOT; 1256*7b9ca4c6SJan Kara goto out; 1257884d179dSJan Kara } 1258884d179dSJan Kara 1259884d179dSJan Kara if (dquot->dq_dqb.dqb_isoftlimit && 1260268157baSJan Kara newinodes > dquot->dq_dqb.dqb_isoftlimit && 1261268157baSJan Kara dquot->dq_dqb.dqb_itime && 1262e008bb61SArnd Bergmann ktime_get_real_seconds() >= dquot->dq_dqb.dqb_itime && 1263884d179dSJan Kara !ignore_hardlimit(dquot)) { 1264bf097aafSJan Kara prepare_warning(warn, dquot, QUOTA_NL_ISOFTLONGWARN); 1265*7b9ca4c6SJan Kara ret = -EDQUOT; 1266*7b9ca4c6SJan Kara goto out; 1267884d179dSJan Kara } 1268884d179dSJan Kara 1269884d179dSJan Kara if (dquot->dq_dqb.dqb_isoftlimit && 1270268157baSJan Kara newinodes > dquot->dq_dqb.dqb_isoftlimit && 1271884d179dSJan Kara dquot->dq_dqb.dqb_itime == 0) { 1272bf097aafSJan Kara prepare_warning(warn, dquot, QUOTA_NL_ISOFTWARN); 1273e008bb61SArnd Bergmann dquot->dq_dqb.dqb_itime = ktime_get_real_seconds() + 12744c376dcaSEric W. Biederman sb_dqopt(dquot->dq_sb)->info[dquot->dq_id.type].dqi_igrace; 1275884d179dSJan Kara } 1276*7b9ca4c6SJan Kara add: 1277*7b9ca4c6SJan Kara dquot->dq_dqb.dqb_curinodes = newinodes; 1278884d179dSJan Kara 1279*7b9ca4c6SJan Kara out: 1280*7b9ca4c6SJan Kara spin_unlock(&dquot->dq_dqb_lock); 1281*7b9ca4c6SJan Kara return ret; 1282884d179dSJan Kara } 1283884d179dSJan Kara 1284*7b9ca4c6SJan Kara static int dquot_add_space(struct dquot *dquot, qsize_t space, 1285*7b9ca4c6SJan Kara qsize_t rsv_space, unsigned int flags, 1286bf097aafSJan Kara struct dquot_warn *warn) 1287884d179dSJan Kara { 1288884d179dSJan Kara qsize_t tspace; 1289268157baSJan Kara struct super_block *sb = dquot->dq_sb; 1290*7b9ca4c6SJan Kara int ret = 0; 1291884d179dSJan Kara 1292*7b9ca4c6SJan Kara spin_lock(&dquot->dq_dqb_lock); 12934c376dcaSEric W. Biederman if (!sb_has_quota_limits_enabled(sb, dquot->dq_id.type) || 1294884d179dSJan Kara test_bit(DQ_FAKE_B, &dquot->dq_flags)) 1295*7b9ca4c6SJan Kara goto add; 1296884d179dSJan Kara 1297884d179dSJan Kara tspace = dquot->dq_dqb.dqb_curspace + dquot->dq_dqb.dqb_rsvspace 1298*7b9ca4c6SJan Kara + space + rsv_space; 1299*7b9ca4c6SJan Kara 1300*7b9ca4c6SJan Kara if (flags & DQUOT_SPACE_NOFAIL) 1301*7b9ca4c6SJan Kara goto add; 1302884d179dSJan Kara 1303884d179dSJan Kara if (dquot->dq_dqb.dqb_bhardlimit && 1304884d179dSJan Kara tspace > dquot->dq_dqb.dqb_bhardlimit && 1305884d179dSJan Kara !ignore_hardlimit(dquot)) { 1306*7b9ca4c6SJan Kara if (flags & DQUOT_SPACE_WARN) 1307bf097aafSJan Kara prepare_warning(warn, dquot, QUOTA_NL_BHARDWARN); 1308*7b9ca4c6SJan Kara ret = -EDQUOT; 1309*7b9ca4c6SJan Kara goto out; 1310884d179dSJan Kara } 1311884d179dSJan Kara 1312884d179dSJan Kara if (dquot->dq_dqb.dqb_bsoftlimit && 1313884d179dSJan Kara tspace > dquot->dq_dqb.dqb_bsoftlimit && 1314268157baSJan Kara dquot->dq_dqb.dqb_btime && 1315e008bb61SArnd Bergmann ktime_get_real_seconds() >= dquot->dq_dqb.dqb_btime && 1316884d179dSJan Kara !ignore_hardlimit(dquot)) { 1317*7b9ca4c6SJan Kara if (flags & DQUOT_SPACE_WARN) 1318bf097aafSJan Kara prepare_warning(warn, dquot, QUOTA_NL_BSOFTLONGWARN); 1319*7b9ca4c6SJan Kara ret = -EDQUOT; 1320*7b9ca4c6SJan Kara goto out; 1321884d179dSJan Kara } 1322884d179dSJan Kara 1323884d179dSJan Kara if (dquot->dq_dqb.dqb_bsoftlimit && 1324884d179dSJan Kara tspace > dquot->dq_dqb.dqb_bsoftlimit && 1325884d179dSJan Kara dquot->dq_dqb.dqb_btime == 0) { 1326*7b9ca4c6SJan Kara if (flags & DQUOT_SPACE_WARN) { 1327bf097aafSJan Kara prepare_warning(warn, dquot, QUOTA_NL_BSOFTWARN); 1328e008bb61SArnd Bergmann dquot->dq_dqb.dqb_btime = ktime_get_real_seconds() + 13294c376dcaSEric W. Biederman sb_dqopt(sb)->info[dquot->dq_id.type].dqi_bgrace; 1330*7b9ca4c6SJan Kara } else { 1331884d179dSJan Kara /* 1332884d179dSJan Kara * We don't allow preallocation to exceed softlimit so exceeding will 1333884d179dSJan Kara * be always printed 1334884d179dSJan Kara */ 1335*7b9ca4c6SJan Kara ret = -EDQUOT; 1336*7b9ca4c6SJan Kara goto out; 1337884d179dSJan Kara } 1338*7b9ca4c6SJan Kara } 1339*7b9ca4c6SJan Kara add: 1340*7b9ca4c6SJan Kara dquot->dq_dqb.dqb_rsvspace += rsv_space; 1341*7b9ca4c6SJan Kara dquot->dq_dqb.dqb_curspace += space; 1342*7b9ca4c6SJan Kara out: 1343*7b9ca4c6SJan Kara spin_unlock(&dquot->dq_dqb_lock); 1344*7b9ca4c6SJan Kara return ret; 1345884d179dSJan Kara } 1346884d179dSJan Kara 1347884d179dSJan Kara static int info_idq_free(struct dquot *dquot, qsize_t inodes) 1348884d179dSJan Kara { 1349268157baSJan Kara qsize_t newinodes; 1350268157baSJan Kara 1351884d179dSJan Kara if (test_bit(DQ_FAKE_B, &dquot->dq_flags) || 1352884d179dSJan Kara dquot->dq_dqb.dqb_curinodes <= dquot->dq_dqb.dqb_isoftlimit || 13534c376dcaSEric W. Biederman !sb_has_quota_limits_enabled(dquot->dq_sb, dquot->dq_id.type)) 1354884d179dSJan Kara return QUOTA_NL_NOWARN; 1355884d179dSJan Kara 1356268157baSJan Kara newinodes = dquot->dq_dqb.dqb_curinodes - inodes; 1357268157baSJan Kara if (newinodes <= dquot->dq_dqb.dqb_isoftlimit) 1358884d179dSJan Kara return QUOTA_NL_ISOFTBELOW; 1359884d179dSJan Kara if (dquot->dq_dqb.dqb_curinodes >= dquot->dq_dqb.dqb_ihardlimit && 1360268157baSJan Kara newinodes < dquot->dq_dqb.dqb_ihardlimit) 1361884d179dSJan Kara return QUOTA_NL_IHARDBELOW; 1362884d179dSJan Kara return QUOTA_NL_NOWARN; 1363884d179dSJan Kara } 1364884d179dSJan Kara 1365884d179dSJan Kara static int info_bdq_free(struct dquot *dquot, qsize_t space) 1366884d179dSJan Kara { 1367884d179dSJan Kara if (test_bit(DQ_FAKE_B, &dquot->dq_flags) || 1368884d179dSJan Kara dquot->dq_dqb.dqb_curspace <= dquot->dq_dqb.dqb_bsoftlimit) 1369884d179dSJan Kara return QUOTA_NL_NOWARN; 1370884d179dSJan Kara 1371884d179dSJan Kara if (dquot->dq_dqb.dqb_curspace - space <= dquot->dq_dqb.dqb_bsoftlimit) 1372884d179dSJan Kara return QUOTA_NL_BSOFTBELOW; 1373884d179dSJan Kara if (dquot->dq_dqb.dqb_curspace >= dquot->dq_dqb.dqb_bhardlimit && 1374884d179dSJan Kara dquot->dq_dqb.dqb_curspace - space < dquot->dq_dqb.dqb_bhardlimit) 1375884d179dSJan Kara return QUOTA_NL_BHARDBELOW; 1376884d179dSJan Kara return QUOTA_NL_NOWARN; 1377884d179dSJan Kara } 13780a5a9c72SJan Kara 1379189eef59SChristoph Hellwig static int dquot_active(const struct inode *inode) 1380189eef59SChristoph Hellwig { 1381189eef59SChristoph Hellwig struct super_block *sb = inode->i_sb; 1382189eef59SChristoph Hellwig 1383189eef59SChristoph Hellwig if (IS_NOQUOTA(inode)) 1384189eef59SChristoph Hellwig return 0; 1385189eef59SChristoph Hellwig return sb_any_quota_loaded(sb) & ~sb_any_quota_suspended(sb); 1386189eef59SChristoph Hellwig } 1387189eef59SChristoph Hellwig 1388884d179dSJan Kara /* 1389884d179dSJan Kara * Initialize quota pointers in inode 1390871a2931SChristoph Hellwig * 1391871a2931SChristoph Hellwig * It is better to call this function outside of any transaction as it 1392871a2931SChristoph Hellwig * might need a lot of space in journal for dquot structure allocation. 1393884d179dSJan Kara */ 13946184fc0bSJan Kara static int __dquot_initialize(struct inode *inode, int type) 1395884d179dSJan Kara { 13961ea06becSNiu Yawei int cnt, init_needed = 0; 1397ab73ef46SNikolay Borisov struct dquot **dquots, *got[MAXQUOTAS] = {}; 1398884d179dSJan Kara struct super_block *sb = inode->i_sb; 13990a5a9c72SJan Kara qsize_t rsv; 14006184fc0bSJan Kara int ret = 0; 1401884d179dSJan Kara 1402189eef59SChristoph Hellwig if (!dquot_active(inode)) 14036184fc0bSJan Kara return 0; 1404884d179dSJan Kara 14055bcd3b6fSKonstantin Khlebnikov dquots = i_dquot(inode); 14065bcd3b6fSKonstantin Khlebnikov 1407884d179dSJan Kara /* First get references to structures we might need. */ 1408884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1409aca645a6SEric W. Biederman struct kqid qid; 1410847aac64SLi Xi kprojid_t projid; 1411847aac64SLi Xi int rc; 14126184fc0bSJan Kara struct dquot *dquot; 1413847aac64SLi Xi 1414884d179dSJan Kara if (type != -1 && cnt != type) 1415884d179dSJan Kara continue; 14161ea06becSNiu Yawei /* 14171ea06becSNiu Yawei * The i_dquot should have been initialized in most cases, 14181ea06becSNiu Yawei * we check it without locking here to avoid unnecessary 14191ea06becSNiu Yawei * dqget()/dqput() calls. 14201ea06becSNiu Yawei */ 14215bcd3b6fSKonstantin Khlebnikov if (dquots[cnt]) 14221ea06becSNiu Yawei continue; 1423847aac64SLi Xi 1424847aac64SLi Xi if (!sb_has_quota_active(sb, cnt)) 1425847aac64SLi Xi continue; 1426847aac64SLi Xi 14271ea06becSNiu Yawei init_needed = 1; 14281ea06becSNiu Yawei 1429884d179dSJan Kara switch (cnt) { 1430884d179dSJan Kara case USRQUOTA: 1431aca645a6SEric W. Biederman qid = make_kqid_uid(inode->i_uid); 1432884d179dSJan Kara break; 1433884d179dSJan Kara case GRPQUOTA: 1434aca645a6SEric W. Biederman qid = make_kqid_gid(inode->i_gid); 1435884d179dSJan Kara break; 1436847aac64SLi Xi case PRJQUOTA: 1437847aac64SLi Xi rc = inode->i_sb->dq_op->get_projid(inode, &projid); 1438847aac64SLi Xi if (rc) 1439847aac64SLi Xi continue; 1440847aac64SLi Xi qid = make_kqid_projid(projid); 1441847aac64SLi Xi break; 1442884d179dSJan Kara } 14436184fc0bSJan Kara dquot = dqget(sb, qid); 14446184fc0bSJan Kara if (IS_ERR(dquot)) { 14456184fc0bSJan Kara /* We raced with somebody turning quotas off... */ 14466184fc0bSJan Kara if (PTR_ERR(dquot) != -ESRCH) { 14476184fc0bSJan Kara ret = PTR_ERR(dquot); 14486184fc0bSJan Kara goto out_put; 14496184fc0bSJan Kara } 14506184fc0bSJan Kara dquot = NULL; 14516184fc0bSJan Kara } 14526184fc0bSJan Kara got[cnt] = dquot; 1453884d179dSJan Kara } 1454884d179dSJan Kara 14551ea06becSNiu Yawei /* All required i_dquot has been initialized */ 14561ea06becSNiu Yawei if (!init_needed) 14576184fc0bSJan Kara return 0; 14581ea06becSNiu Yawei 1459b9ba6f94SNiu Yawei spin_lock(&dq_data_lock); 1460884d179dSJan Kara if (IS_NOQUOTA(inode)) 14616184fc0bSJan Kara goto out_lock; 1462884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1463884d179dSJan Kara if (type != -1 && cnt != type) 1464884d179dSJan Kara continue; 1465884d179dSJan Kara /* Avoid races with quotaoff() */ 1466884d179dSJan Kara if (!sb_has_quota_active(sb, cnt)) 1467884d179dSJan Kara continue; 14684408ea41SJan Kara /* We could race with quotaon or dqget() could have failed */ 14694408ea41SJan Kara if (!got[cnt]) 14704408ea41SJan Kara continue; 14715bcd3b6fSKonstantin Khlebnikov if (!dquots[cnt]) { 14725bcd3b6fSKonstantin Khlebnikov dquots[cnt] = got[cnt]; 1473dd6f3c6dSJan Kara got[cnt] = NULL; 14740a5a9c72SJan Kara /* 14750a5a9c72SJan Kara * Make quota reservation system happy if someone 14760a5a9c72SJan Kara * did a write before quota was turned on 14770a5a9c72SJan Kara */ 14780a5a9c72SJan Kara rsv = inode_get_rsv_space(inode); 1479*7b9ca4c6SJan Kara if (unlikely(rsv)) { 1480*7b9ca4c6SJan Kara spin_lock(&inode->i_lock); 1481*7b9ca4c6SJan Kara /* Get reservation again under proper lock */ 1482*7b9ca4c6SJan Kara rsv = __inode_get_rsv_space(inode); 1483*7b9ca4c6SJan Kara spin_lock(&dquots[cnt]->dq_dqb_lock); 1484*7b9ca4c6SJan Kara dquots[cnt]->dq_dqb.dqb_rsvspace += rsv; 1485*7b9ca4c6SJan Kara spin_unlock(&dquots[cnt]->dq_dqb_lock); 1486*7b9ca4c6SJan Kara spin_unlock(&inode->i_lock); 1487*7b9ca4c6SJan Kara } 1488884d179dSJan Kara } 1489884d179dSJan Kara } 14906184fc0bSJan Kara out_lock: 1491b9ba6f94SNiu Yawei spin_unlock(&dq_data_lock); 14926184fc0bSJan Kara out_put: 1493884d179dSJan Kara /* Drop unused references */ 1494dc52dd3aSDmitry Monakhov dqput_all(got); 14956184fc0bSJan Kara 14966184fc0bSJan Kara return ret; 1497871a2931SChristoph Hellwig } 1498871a2931SChristoph Hellwig 14996184fc0bSJan Kara int dquot_initialize(struct inode *inode) 1500871a2931SChristoph Hellwig { 15016184fc0bSJan Kara return __dquot_initialize(inode, -1); 1502884d179dSJan Kara } 1503884d179dSJan Kara EXPORT_SYMBOL(dquot_initialize); 1504884d179dSJan Kara 1505b8cb5a54STahsin Erdogan bool dquot_initialize_needed(struct inode *inode) 1506b8cb5a54STahsin Erdogan { 1507b8cb5a54STahsin Erdogan struct dquot **dquots; 1508b8cb5a54STahsin Erdogan int i; 1509b8cb5a54STahsin Erdogan 1510b8cb5a54STahsin Erdogan if (!dquot_active(inode)) 1511b8cb5a54STahsin Erdogan return false; 1512b8cb5a54STahsin Erdogan 1513b8cb5a54STahsin Erdogan dquots = i_dquot(inode); 1514b8cb5a54STahsin Erdogan for (i = 0; i < MAXQUOTAS; i++) 1515b8cb5a54STahsin Erdogan if (!dquots[i] && sb_has_quota_active(inode->i_sb, i)) 1516b8cb5a54STahsin Erdogan return true; 1517b8cb5a54STahsin Erdogan return false; 1518b8cb5a54STahsin Erdogan } 1519b8cb5a54STahsin Erdogan EXPORT_SYMBOL(dquot_initialize_needed); 1520b8cb5a54STahsin Erdogan 1521884d179dSJan Kara /* 1522b9ba6f94SNiu Yawei * Release all quotas referenced by inode. 1523b9ba6f94SNiu Yawei * 1524b9ba6f94SNiu Yawei * This function only be called on inode free or converting 1525b9ba6f94SNiu Yawei * a file to quota file, no other users for the i_dquot in 1526b9ba6f94SNiu Yawei * both cases, so we needn't call synchronize_srcu() after 1527b9ba6f94SNiu Yawei * clearing i_dquot. 1528884d179dSJan Kara */ 15299f754758SChristoph Hellwig static void __dquot_drop(struct inode *inode) 1530884d179dSJan Kara { 1531884d179dSJan Kara int cnt; 15325bcd3b6fSKonstantin Khlebnikov struct dquot **dquots = i_dquot(inode); 1533884d179dSJan Kara struct dquot *put[MAXQUOTAS]; 1534884d179dSJan Kara 1535b9ba6f94SNiu Yawei spin_lock(&dq_data_lock); 1536884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 15375bcd3b6fSKonstantin Khlebnikov put[cnt] = dquots[cnt]; 15385bcd3b6fSKonstantin Khlebnikov dquots[cnt] = NULL; 1539884d179dSJan Kara } 1540b9ba6f94SNiu Yawei spin_unlock(&dq_data_lock); 1541dc52dd3aSDmitry Monakhov dqput_all(put); 1542884d179dSJan Kara } 1543884d179dSJan Kara 15449f754758SChristoph Hellwig void dquot_drop(struct inode *inode) 1545884d179dSJan Kara { 15465bcd3b6fSKonstantin Khlebnikov struct dquot * const *dquots; 1547884d179dSJan Kara int cnt; 15489f754758SChristoph Hellwig 15499f754758SChristoph Hellwig if (IS_NOQUOTA(inode)) 15509f754758SChristoph Hellwig return; 15519f754758SChristoph Hellwig 15529f754758SChristoph Hellwig /* 15539f754758SChristoph Hellwig * Test before calling to rule out calls from proc and such 1554884d179dSJan Kara * where we are not allowed to block. Note that this is 1555884d179dSJan Kara * actually reliable test even without the lock - the caller 1556884d179dSJan Kara * must assure that nobody can come after the DQUOT_DROP and 15579f754758SChristoph Hellwig * add quota pointers back anyway. 15589f754758SChristoph Hellwig */ 15595bcd3b6fSKonstantin Khlebnikov dquots = i_dquot(inode); 15609f754758SChristoph Hellwig for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 15615bcd3b6fSKonstantin Khlebnikov if (dquots[cnt]) 1562884d179dSJan Kara break; 15639f754758SChristoph Hellwig } 15649f754758SChristoph Hellwig 1565884d179dSJan Kara if (cnt < MAXQUOTAS) 15669f754758SChristoph Hellwig __dquot_drop(inode); 1567884d179dSJan Kara } 15689f754758SChristoph Hellwig EXPORT_SYMBOL(dquot_drop); 1569884d179dSJan Kara 1570884d179dSJan Kara /* 1571fd8fbfc1SDmitry Monakhov * inode_reserved_space is managed internally by quota, and protected by 1572fd8fbfc1SDmitry Monakhov * i_lock similar to i_blocks+i_bytes. 1573fd8fbfc1SDmitry Monakhov */ 1574fd8fbfc1SDmitry Monakhov static qsize_t *inode_reserved_space(struct inode * inode) 1575fd8fbfc1SDmitry Monakhov { 1576fd8fbfc1SDmitry Monakhov /* Filesystem must explicitly define it's own method in order to use 1577fd8fbfc1SDmitry Monakhov * quota reservation interface */ 1578fd8fbfc1SDmitry Monakhov BUG_ON(!inode->i_sb->dq_op->get_reserved_space); 1579fd8fbfc1SDmitry Monakhov return inode->i_sb->dq_op->get_reserved_space(inode); 1580fd8fbfc1SDmitry Monakhov } 1581fd8fbfc1SDmitry Monakhov 1582*7b9ca4c6SJan Kara static qsize_t __inode_get_rsv_space(struct inode *inode) 1583*7b9ca4c6SJan Kara { 1584*7b9ca4c6SJan Kara if (!inode->i_sb->dq_op->get_reserved_space) 1585*7b9ca4c6SJan Kara return 0; 1586*7b9ca4c6SJan Kara return *inode_reserved_space(inode); 1587*7b9ca4c6SJan Kara } 1588*7b9ca4c6SJan Kara 1589fd8fbfc1SDmitry Monakhov static qsize_t inode_get_rsv_space(struct inode *inode) 1590fd8fbfc1SDmitry Monakhov { 1591fd8fbfc1SDmitry Monakhov qsize_t ret; 159205b5d898SJan Kara 159305b5d898SJan Kara if (!inode->i_sb->dq_op->get_reserved_space) 159405b5d898SJan Kara return 0; 1595fd8fbfc1SDmitry Monakhov spin_lock(&inode->i_lock); 1596*7b9ca4c6SJan Kara ret = __inode_get_rsv_space(inode); 1597fd8fbfc1SDmitry Monakhov spin_unlock(&inode->i_lock); 1598fd8fbfc1SDmitry Monakhov return ret; 1599fd8fbfc1SDmitry Monakhov } 1600fd8fbfc1SDmitry Monakhov 1601fd8fbfc1SDmitry Monakhov /* 16025dd4056dSChristoph Hellwig * This functions updates i_blocks+i_bytes fields and quota information 16035dd4056dSChristoph Hellwig * (together with appropriate checks). 16045dd4056dSChristoph Hellwig * 16055dd4056dSChristoph Hellwig * NOTE: We absolutely rely on the fact that caller dirties the inode 16065dd4056dSChristoph Hellwig * (usually helpers in quotaops.h care about this) and holds a handle for 16075dd4056dSChristoph Hellwig * the current transaction so that dquot write and inode write go into the 16085dd4056dSChristoph Hellwig * same transaction. 1609884d179dSJan Kara */ 1610884d179dSJan Kara 1611884d179dSJan Kara /* 1612884d179dSJan Kara * This operation can block, but only after everything is updated 1613884d179dSJan Kara */ 161456246f9aSEric Sandeen int __dquot_alloc_space(struct inode *inode, qsize_t number, int flags) 1615884d179dSJan Kara { 1616b9ba6f94SNiu Yawei int cnt, ret = 0, index; 1617bf097aafSJan Kara struct dquot_warn warn[MAXQUOTAS]; 161856246f9aSEric Sandeen int reserve = flags & DQUOT_SPACE_RESERVE; 16195bcd3b6fSKonstantin Khlebnikov struct dquot **dquots; 1620884d179dSJan Kara 1621189eef59SChristoph Hellwig if (!dquot_active(inode)) { 1622a478e522SJan Kara if (reserve) { 1623a478e522SJan Kara spin_lock(&inode->i_lock); 1624a478e522SJan Kara *inode_reserved_space(inode) += number; 1625a478e522SJan Kara spin_unlock(&inode->i_lock); 1626a478e522SJan Kara } else { 1627a478e522SJan Kara inode_add_bytes(inode, number); 1628a478e522SJan Kara } 1629fd8fbfc1SDmitry Monakhov goto out; 1630fd8fbfc1SDmitry Monakhov } 1631fd8fbfc1SDmitry Monakhov 1632884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) 1633bf097aafSJan Kara warn[cnt].w_type = QUOTA_NL_NOWARN; 1634884d179dSJan Kara 16355bcd3b6fSKonstantin Khlebnikov dquots = i_dquot(inode); 1636b9ba6f94SNiu Yawei index = srcu_read_lock(&dquot_srcu); 1637*7b9ca4c6SJan Kara spin_lock(&inode->i_lock); 1638884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1639bf097aafSJan Kara if (!dquots[cnt]) 1640884d179dSJan Kara continue; 1641*7b9ca4c6SJan Kara if (flags & DQUOT_SPACE_RESERVE) { 1642*7b9ca4c6SJan Kara ret = dquot_add_space(dquots[cnt], 0, number, flags, 1643*7b9ca4c6SJan Kara &warn[cnt]); 1644*7b9ca4c6SJan Kara } else { 1645*7b9ca4c6SJan Kara ret = dquot_add_space(dquots[cnt], number, 0, flags, 1646*7b9ca4c6SJan Kara &warn[cnt]); 1647*7b9ca4c6SJan Kara } 1648*7b9ca4c6SJan Kara if (ret) { 1649*7b9ca4c6SJan Kara /* Back out changes we already did */ 1650*7b9ca4c6SJan Kara for (cnt--; cnt >= 0; cnt--) { 1651*7b9ca4c6SJan Kara if (!dquots[cnt]) 1652*7b9ca4c6SJan Kara continue; 1653*7b9ca4c6SJan Kara spin_lock(&dquots[cnt]->dq_dqb_lock); 1654*7b9ca4c6SJan Kara if (flags & DQUOT_SPACE_RESERVE) { 1655*7b9ca4c6SJan Kara dquots[cnt]->dq_dqb.dqb_rsvspace -= 1656*7b9ca4c6SJan Kara number; 1657*7b9ca4c6SJan Kara } else { 1658*7b9ca4c6SJan Kara dquots[cnt]->dq_dqb.dqb_curspace -= 1659*7b9ca4c6SJan Kara number; 1660*7b9ca4c6SJan Kara } 1661*7b9ca4c6SJan Kara spin_unlock(&dquots[cnt]->dq_dqb_lock); 1662*7b9ca4c6SJan Kara } 1663*7b9ca4c6SJan Kara spin_unlock(&inode->i_lock); 1664fd8fbfc1SDmitry Monakhov goto out_flush_warn; 1665884d179dSJan Kara } 1666884d179dSJan Kara } 1667884d179dSJan Kara if (reserve) 1668a478e522SJan Kara *inode_reserved_space(inode) += number; 1669*7b9ca4c6SJan Kara else 1670*7b9ca4c6SJan Kara __inode_add_bytes(inode, number); 1671a478e522SJan Kara spin_unlock(&inode->i_lock); 1672fd8fbfc1SDmitry Monakhov 1673fd8fbfc1SDmitry Monakhov if (reserve) 1674fd8fbfc1SDmitry Monakhov goto out_flush_warn; 1675bf097aafSJan Kara mark_all_dquot_dirty(dquots); 1676fd8fbfc1SDmitry Monakhov out_flush_warn: 1677b9ba6f94SNiu Yawei srcu_read_unlock(&dquot_srcu, index); 1678bf097aafSJan Kara flush_warnings(warn); 1679fd8fbfc1SDmitry Monakhov out: 1680884d179dSJan Kara return ret; 1681884d179dSJan Kara } 16825dd4056dSChristoph Hellwig EXPORT_SYMBOL(__dquot_alloc_space); 1683884d179dSJan Kara 1684884d179dSJan Kara /* 1685884d179dSJan Kara * This operation can block, but only after everything is updated 1686884d179dSJan Kara */ 16876bab3596SJan Kara int dquot_alloc_inode(struct inode *inode) 1688884d179dSJan Kara { 1689b9ba6f94SNiu Yawei int cnt, ret = 0, index; 1690bf097aafSJan Kara struct dquot_warn warn[MAXQUOTAS]; 16915bcd3b6fSKonstantin Khlebnikov struct dquot * const *dquots; 1692884d179dSJan Kara 1693189eef59SChristoph Hellwig if (!dquot_active(inode)) 169463936ddaSChristoph Hellwig return 0; 1695884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) 1696bf097aafSJan Kara warn[cnt].w_type = QUOTA_NL_NOWARN; 1697b9ba6f94SNiu Yawei 16985bcd3b6fSKonstantin Khlebnikov dquots = i_dquot(inode); 1699b9ba6f94SNiu Yawei index = srcu_read_lock(&dquot_srcu); 1700*7b9ca4c6SJan Kara spin_lock(&inode->i_lock); 1701884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1702bf097aafSJan Kara if (!dquots[cnt]) 1703884d179dSJan Kara continue; 1704*7b9ca4c6SJan Kara ret = dquot_add_inodes(dquots[cnt], 1, &warn[cnt]); 1705*7b9ca4c6SJan Kara if (ret) { 1706*7b9ca4c6SJan Kara for (cnt--; cnt >= 0; cnt--) { 1707*7b9ca4c6SJan Kara if (!dquots[cnt]) 1708*7b9ca4c6SJan Kara continue; 1709*7b9ca4c6SJan Kara /* Back out changes we already did */ 1710*7b9ca4c6SJan Kara spin_lock(&dquots[cnt]->dq_dqb_lock); 1711*7b9ca4c6SJan Kara dquots[cnt]->dq_dqb.dqb_curinodes--; 1712*7b9ca4c6SJan Kara spin_unlock(&dquots[cnt]->dq_dqb_lock); 1713*7b9ca4c6SJan Kara } 1714884d179dSJan Kara goto warn_put_all; 1715884d179dSJan Kara } 1716884d179dSJan Kara } 1717efd8f0e6SChristoph Hellwig 1718884d179dSJan Kara warn_put_all: 1719*7b9ca4c6SJan Kara spin_unlock(&inode->i_lock); 172063936ddaSChristoph Hellwig if (ret == 0) 1721bf097aafSJan Kara mark_all_dquot_dirty(dquots); 1722b9ba6f94SNiu Yawei srcu_read_unlock(&dquot_srcu, index); 1723bf097aafSJan Kara flush_warnings(warn); 1724884d179dSJan Kara return ret; 1725884d179dSJan Kara } 1726884d179dSJan Kara EXPORT_SYMBOL(dquot_alloc_inode); 1727884d179dSJan Kara 17285dd4056dSChristoph Hellwig /* 17295dd4056dSChristoph Hellwig * Convert in-memory reserved quotas to real consumed quotas 17305dd4056dSChristoph Hellwig */ 17315dd4056dSChristoph Hellwig int dquot_claim_space_nodirty(struct inode *inode, qsize_t number) 1732884d179dSJan Kara { 17335bcd3b6fSKonstantin Khlebnikov struct dquot **dquots; 1734b9ba6f94SNiu Yawei int cnt, index; 1735884d179dSJan Kara 1736189eef59SChristoph Hellwig if (!dquot_active(inode)) { 17370ed60de3SJan Kara spin_lock(&inode->i_lock); 17380ed60de3SJan Kara *inode_reserved_space(inode) -= number; 17390ed60de3SJan Kara __inode_add_bytes(inode, number); 17400ed60de3SJan Kara spin_unlock(&inode->i_lock); 17415dd4056dSChristoph Hellwig return 0; 1742884d179dSJan Kara } 1743884d179dSJan Kara 17445bcd3b6fSKonstantin Khlebnikov dquots = i_dquot(inode); 1745b9ba6f94SNiu Yawei index = srcu_read_lock(&dquot_srcu); 1746*7b9ca4c6SJan Kara spin_lock(&inode->i_lock); 1747884d179dSJan Kara /* Claim reserved quotas to allocated quotas */ 1748884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 17493ab167d2SJan Kara if (dquots[cnt]) { 17503ab167d2SJan Kara struct dquot *dquot = dquots[cnt]; 17513ab167d2SJan Kara 1752*7b9ca4c6SJan Kara spin_lock(&dquot->dq_dqb_lock); 17533ab167d2SJan Kara if (WARN_ON_ONCE(dquot->dq_dqb.dqb_rsvspace < number)) 17543ab167d2SJan Kara number = dquot->dq_dqb.dqb_rsvspace; 17553ab167d2SJan Kara dquot->dq_dqb.dqb_curspace += number; 17563ab167d2SJan Kara dquot->dq_dqb.dqb_rsvspace -= number; 1757*7b9ca4c6SJan Kara spin_unlock(&dquot->dq_dqb_lock); 17583ab167d2SJan Kara } 1759884d179dSJan Kara } 1760884d179dSJan Kara /* Update inode bytes */ 17610ed60de3SJan Kara *inode_reserved_space(inode) -= number; 17620ed60de3SJan Kara __inode_add_bytes(inode, number); 17630ed60de3SJan Kara spin_unlock(&inode->i_lock); 17645bcd3b6fSKonstantin Khlebnikov mark_all_dquot_dirty(dquots); 1765b9ba6f94SNiu Yawei srcu_read_unlock(&dquot_srcu, index); 17665dd4056dSChristoph Hellwig return 0; 1767884d179dSJan Kara } 17685dd4056dSChristoph Hellwig EXPORT_SYMBOL(dquot_claim_space_nodirty); 1769884d179dSJan Kara 1770884d179dSJan Kara /* 17711c8924ebSJan Kara * Convert allocated space back to in-memory reserved quotas 17721c8924ebSJan Kara */ 17731c8924ebSJan Kara void dquot_reclaim_space_nodirty(struct inode *inode, qsize_t number) 17741c8924ebSJan Kara { 17755bcd3b6fSKonstantin Khlebnikov struct dquot **dquots; 1776b9ba6f94SNiu Yawei int cnt, index; 17771c8924ebSJan Kara 17781c8924ebSJan Kara if (!dquot_active(inode)) { 17790ed60de3SJan Kara spin_lock(&inode->i_lock); 17800ed60de3SJan Kara *inode_reserved_space(inode) += number; 17810ed60de3SJan Kara __inode_sub_bytes(inode, number); 17820ed60de3SJan Kara spin_unlock(&inode->i_lock); 17831c8924ebSJan Kara return; 17841c8924ebSJan Kara } 17851c8924ebSJan Kara 17865bcd3b6fSKonstantin Khlebnikov dquots = i_dquot(inode); 1787b9ba6f94SNiu Yawei index = srcu_read_lock(&dquot_srcu); 1788*7b9ca4c6SJan Kara spin_lock(&inode->i_lock); 17891c8924ebSJan Kara /* Claim reserved quotas to allocated quotas */ 17901c8924ebSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 17913ab167d2SJan Kara if (dquots[cnt]) { 17923ab167d2SJan Kara struct dquot *dquot = dquots[cnt]; 17933ab167d2SJan Kara 1794*7b9ca4c6SJan Kara spin_lock(&dquot->dq_dqb_lock); 17953ab167d2SJan Kara if (WARN_ON_ONCE(dquot->dq_dqb.dqb_curspace < number)) 17963ab167d2SJan Kara number = dquot->dq_dqb.dqb_curspace; 17973ab167d2SJan Kara dquot->dq_dqb.dqb_rsvspace += number; 17983ab167d2SJan Kara dquot->dq_dqb.dqb_curspace -= number; 1799*7b9ca4c6SJan Kara spin_unlock(&dquot->dq_dqb_lock); 18003ab167d2SJan Kara } 18011c8924ebSJan Kara } 18021c8924ebSJan Kara /* Update inode bytes */ 18030ed60de3SJan Kara *inode_reserved_space(inode) += number; 18040ed60de3SJan Kara __inode_sub_bytes(inode, number); 18050ed60de3SJan Kara spin_unlock(&inode->i_lock); 18065bcd3b6fSKonstantin Khlebnikov mark_all_dquot_dirty(dquots); 1807b9ba6f94SNiu Yawei srcu_read_unlock(&dquot_srcu, index); 18081c8924ebSJan Kara return; 18091c8924ebSJan Kara } 18101c8924ebSJan Kara EXPORT_SYMBOL(dquot_reclaim_space_nodirty); 18111c8924ebSJan Kara 18121c8924ebSJan Kara /* 1813884d179dSJan Kara * This operation can block, but only after everything is updated 1814884d179dSJan Kara */ 181556246f9aSEric Sandeen void __dquot_free_space(struct inode *inode, qsize_t number, int flags) 1816884d179dSJan Kara { 1817884d179dSJan Kara unsigned int cnt; 1818bf097aafSJan Kara struct dquot_warn warn[MAXQUOTAS]; 18195bcd3b6fSKonstantin Khlebnikov struct dquot **dquots; 1820b9ba6f94SNiu Yawei int reserve = flags & DQUOT_SPACE_RESERVE, index; 1821884d179dSJan Kara 1822189eef59SChristoph Hellwig if (!dquot_active(inode)) { 1823a478e522SJan Kara if (reserve) { 1824a478e522SJan Kara spin_lock(&inode->i_lock); 1825a478e522SJan Kara *inode_reserved_space(inode) -= number; 1826a478e522SJan Kara spin_unlock(&inode->i_lock); 1827a478e522SJan Kara } else { 1828a478e522SJan Kara inode_sub_bytes(inode, number); 1829a478e522SJan Kara } 18305dd4056dSChristoph Hellwig return; 1831884d179dSJan Kara } 1832884d179dSJan Kara 18335bcd3b6fSKonstantin Khlebnikov dquots = i_dquot(inode); 1834b9ba6f94SNiu Yawei index = srcu_read_lock(&dquot_srcu); 1835*7b9ca4c6SJan Kara spin_lock(&inode->i_lock); 1836884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1837bf097aafSJan Kara int wtype; 1838bf097aafSJan Kara 1839bf097aafSJan Kara warn[cnt].w_type = QUOTA_NL_NOWARN; 1840bf097aafSJan Kara if (!dquots[cnt]) 1841884d179dSJan Kara continue; 1842*7b9ca4c6SJan Kara spin_lock(&dquots[cnt]->dq_dqb_lock); 1843bf097aafSJan Kara wtype = info_bdq_free(dquots[cnt], number); 1844bf097aafSJan Kara if (wtype != QUOTA_NL_NOWARN) 1845bf097aafSJan Kara prepare_warning(&warn[cnt], dquots[cnt], wtype); 1846fd8fbfc1SDmitry Monakhov if (reserve) 1847bf097aafSJan Kara dquot_free_reserved_space(dquots[cnt], number); 1848fd8fbfc1SDmitry Monakhov else 1849bf097aafSJan Kara dquot_decr_space(dquots[cnt], number); 1850*7b9ca4c6SJan Kara spin_unlock(&dquots[cnt]->dq_dqb_lock); 1851884d179dSJan Kara } 1852*7b9ca4c6SJan Kara if (reserve) 1853a478e522SJan Kara *inode_reserved_space(inode) -= number; 1854*7b9ca4c6SJan Kara else 1855*7b9ca4c6SJan Kara __inode_sub_bytes(inode, number); 1856a478e522SJan Kara spin_unlock(&inode->i_lock); 1857fd8fbfc1SDmitry Monakhov 1858fd8fbfc1SDmitry Monakhov if (reserve) 1859fd8fbfc1SDmitry Monakhov goto out_unlock; 1860bf097aafSJan Kara mark_all_dquot_dirty(dquots); 1861fd8fbfc1SDmitry Monakhov out_unlock: 1862b9ba6f94SNiu Yawei srcu_read_unlock(&dquot_srcu, index); 1863bf097aafSJan Kara flush_warnings(warn); 1864884d179dSJan Kara } 18655dd4056dSChristoph Hellwig EXPORT_SYMBOL(__dquot_free_space); 1866fd8fbfc1SDmitry Monakhov 1867fd8fbfc1SDmitry Monakhov /* 1868884d179dSJan Kara * This operation can block, but only after everything is updated 1869884d179dSJan Kara */ 18706bab3596SJan Kara void dquot_free_inode(struct inode *inode) 1871884d179dSJan Kara { 1872884d179dSJan Kara unsigned int cnt; 1873bf097aafSJan Kara struct dquot_warn warn[MAXQUOTAS]; 18745bcd3b6fSKonstantin Khlebnikov struct dquot * const *dquots; 1875b9ba6f94SNiu Yawei int index; 1876884d179dSJan Kara 1877189eef59SChristoph Hellwig if (!dquot_active(inode)) 187863936ddaSChristoph Hellwig return; 1879884d179dSJan Kara 18805bcd3b6fSKonstantin Khlebnikov dquots = i_dquot(inode); 1881b9ba6f94SNiu Yawei index = srcu_read_lock(&dquot_srcu); 1882*7b9ca4c6SJan 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; 1889*7b9ca4c6SJan Kara spin_lock(&dquots[cnt]->dq_dqb_lock); 1890bf097aafSJan Kara wtype = info_idq_free(dquots[cnt], 1); 1891bf097aafSJan Kara if (wtype != QUOTA_NL_NOWARN) 1892bf097aafSJan Kara prepare_warning(&warn[cnt], dquots[cnt], wtype); 1893bf097aafSJan Kara dquot_decr_inodes(dquots[cnt], 1); 1894*7b9ca4c6SJan Kara spin_unlock(&dquots[cnt]->dq_dqb_lock); 1895884d179dSJan Kara } 1896*7b9ca4c6SJan Kara spin_unlock(&inode->i_lock); 1897bf097aafSJan Kara mark_all_dquot_dirty(dquots); 1898b9ba6f94SNiu Yawei srcu_read_unlock(&dquot_srcu, index); 1899bf097aafSJan Kara flush_warnings(warn); 1900884d179dSJan Kara } 1901884d179dSJan Kara EXPORT_SYMBOL(dquot_free_inode); 1902884d179dSJan Kara 1903884d179dSJan Kara /* 1904884d179dSJan Kara * Transfer the number of inode and blocks from one diskquota to an other. 1905bc8e5f07SJan Kara * On success, dquot references in transfer_to are consumed and references 1906bc8e5f07SJan Kara * to original dquots that need to be released are placed there. On failure, 1907bc8e5f07SJan Kara * references are kept untouched. 1908884d179dSJan Kara * 1909884d179dSJan Kara * This operation can block, but only after everything is updated 1910884d179dSJan Kara * A transaction must be started when entering this function. 1911bc8e5f07SJan Kara * 1912b9ba6f94SNiu Yawei * We are holding reference on transfer_from & transfer_to, no need to 1913b9ba6f94SNiu Yawei * protect them by srcu_read_lock(). 1914884d179dSJan Kara */ 1915bc8e5f07SJan Kara int __dquot_transfer(struct inode *inode, struct dquot **transfer_to) 1916884d179dSJan Kara { 1917*7b9ca4c6SJan Kara qsize_t cur_space; 1918884d179dSJan Kara qsize_t rsv_space = 0; 19197a9ca53aSTahsin Erdogan qsize_t inode_usage = 1; 1920bc8e5f07SJan Kara struct dquot *transfer_from[MAXQUOTAS] = {}; 1921efd8f0e6SChristoph Hellwig int cnt, ret = 0; 19229e32784bSDmitry char is_valid[MAXQUOTAS] = {}; 1923bf097aafSJan Kara struct dquot_warn warn_to[MAXQUOTAS]; 1924bf097aafSJan Kara struct dquot_warn warn_from_inodes[MAXQUOTAS]; 1925bf097aafSJan Kara struct dquot_warn warn_from_space[MAXQUOTAS]; 1926884d179dSJan Kara 1927884d179dSJan Kara if (IS_NOQUOTA(inode)) 1928efd8f0e6SChristoph Hellwig return 0; 19297a9ca53aSTahsin Erdogan 19307a9ca53aSTahsin Erdogan if (inode->i_sb->dq_op->get_inode_usage) { 19317a9ca53aSTahsin Erdogan ret = inode->i_sb->dq_op->get_inode_usage(inode, &inode_usage); 19327a9ca53aSTahsin Erdogan if (ret) 19337a9ca53aSTahsin Erdogan return ret; 19347a9ca53aSTahsin Erdogan } 19357a9ca53aSTahsin Erdogan 1936884d179dSJan Kara /* Initialize the arrays */ 1937bf097aafSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1938bf097aafSJan Kara warn_to[cnt].w_type = QUOTA_NL_NOWARN; 1939bf097aafSJan Kara warn_from_inodes[cnt].w_type = QUOTA_NL_NOWARN; 1940bf097aafSJan Kara warn_from_space[cnt].w_type = QUOTA_NL_NOWARN; 1941bf097aafSJan Kara } 1942b9ba6f94SNiu Yawei 1943b9ba6f94SNiu Yawei spin_lock(&dq_data_lock); 1944*7b9ca4c6SJan Kara spin_lock(&inode->i_lock); 1945884d179dSJan Kara if (IS_NOQUOTA(inode)) { /* File without quota accounting? */ 1946*7b9ca4c6SJan Kara spin_unlock(&inode->i_lock); 1947b9ba6f94SNiu Yawei spin_unlock(&dq_data_lock); 1948bc8e5f07SJan Kara return 0; 1949884d179dSJan Kara } 1950*7b9ca4c6SJan Kara cur_space = __inode_get_bytes(inode); 1951*7b9ca4c6SJan Kara rsv_space = __inode_get_rsv_space(inode); 1952*7b9ca4c6SJan Kara /* 1953*7b9ca4c6SJan Kara * Build the transfer_from list, check limits, and update usage in 1954*7b9ca4c6SJan Kara * the target structures. 1955*7b9ca4c6SJan Kara */ 1956884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 19579e32784bSDmitry /* 19589e32784bSDmitry * Skip changes for same uid or gid or for turned off quota-type. 19599e32784bSDmitry */ 1960dd6f3c6dSJan Kara if (!transfer_to[cnt]) 1961884d179dSJan Kara continue; 19629e32784bSDmitry /* Avoid races with quotaoff() */ 19639e32784bSDmitry if (!sb_has_quota_active(inode->i_sb, cnt)) 19649e32784bSDmitry continue; 19659e32784bSDmitry is_valid[cnt] = 1; 19662d0fa467SJan Kara transfer_from[cnt] = i_dquot(inode)[cnt]; 1967*7b9ca4c6SJan Kara ret = dquot_add_inodes(transfer_to[cnt], inode_usage, 1968*7b9ca4c6SJan Kara &warn_to[cnt]); 1969efd8f0e6SChristoph Hellwig if (ret) 1970efd8f0e6SChristoph Hellwig goto over_quota; 1971*7b9ca4c6SJan Kara ret = dquot_add_space(transfer_to[cnt], cur_space, rsv_space, 0, 1972*7b9ca4c6SJan Kara &warn_to[cnt]); 1973*7b9ca4c6SJan Kara if (ret) { 1974*7b9ca4c6SJan Kara dquot_decr_inodes(transfer_to[cnt], inode_usage); 1975884d179dSJan Kara goto over_quota; 1976884d179dSJan Kara } 1977*7b9ca4c6SJan Kara } 1978884d179dSJan Kara 1979*7b9ca4c6SJan Kara /* Decrease usage for source structures and update quota pointers */ 1980884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 19819e32784bSDmitry if (!is_valid[cnt]) 1982884d179dSJan Kara continue; 1983884d179dSJan Kara /* Due to IO error we might not have transfer_from[] structure */ 1984884d179dSJan Kara if (transfer_from[cnt]) { 1985bf097aafSJan Kara int wtype; 1986*7b9ca4c6SJan Kara 1987*7b9ca4c6SJan Kara spin_lock(&transfer_from[cnt]->dq_dqb_lock); 19887a9ca53aSTahsin Erdogan wtype = info_idq_free(transfer_from[cnt], inode_usage); 1989bf097aafSJan Kara if (wtype != QUOTA_NL_NOWARN) 1990bf097aafSJan Kara prepare_warning(&warn_from_inodes[cnt], 1991bf097aafSJan Kara transfer_from[cnt], wtype); 1992*7b9ca4c6SJan Kara wtype = info_bdq_free(transfer_from[cnt], 1993*7b9ca4c6SJan Kara cur_space + rsv_space); 1994bf097aafSJan Kara if (wtype != QUOTA_NL_NOWARN) 1995bf097aafSJan Kara prepare_warning(&warn_from_space[cnt], 1996bf097aafSJan Kara transfer_from[cnt], wtype); 19977a9ca53aSTahsin Erdogan dquot_decr_inodes(transfer_from[cnt], inode_usage); 1998884d179dSJan Kara dquot_decr_space(transfer_from[cnt], cur_space); 1999884d179dSJan Kara dquot_free_reserved_space(transfer_from[cnt], 2000884d179dSJan Kara rsv_space); 2001*7b9ca4c6SJan Kara spin_unlock(&transfer_from[cnt]->dq_dqb_lock); 2002884d179dSJan Kara } 20032d0fa467SJan Kara i_dquot(inode)[cnt] = transfer_to[cnt]; 2004884d179dSJan Kara } 2005*7b9ca4c6SJan Kara spin_unlock(&inode->i_lock); 2006884d179dSJan Kara spin_unlock(&dq_data_lock); 2007884d179dSJan Kara 2008dc52dd3aSDmitry Monakhov mark_all_dquot_dirty(transfer_from); 2009dc52dd3aSDmitry Monakhov mark_all_dquot_dirty(transfer_to); 2010bf097aafSJan Kara flush_warnings(warn_to); 2011bf097aafSJan Kara flush_warnings(warn_from_inodes); 2012bf097aafSJan Kara flush_warnings(warn_from_space); 2013bc8e5f07SJan Kara /* Pass back references to put */ 2014dc52dd3aSDmitry Monakhov for (cnt = 0; cnt < MAXQUOTAS; cnt++) 20159e32784bSDmitry if (is_valid[cnt]) 2016bc8e5f07SJan Kara transfer_to[cnt] = transfer_from[cnt]; 201786f3cbecSJan Kara return 0; 2018884d179dSJan Kara over_quota: 2019*7b9ca4c6SJan Kara /* Back out changes we already did */ 2020*7b9ca4c6SJan Kara for (cnt--; cnt >= 0; cnt--) { 2021*7b9ca4c6SJan Kara if (!is_valid[cnt]) 2022*7b9ca4c6SJan Kara continue; 2023*7b9ca4c6SJan Kara spin_lock(&transfer_to[cnt]->dq_dqb_lock); 2024*7b9ca4c6SJan Kara dquot_decr_inodes(transfer_to[cnt], inode_usage); 2025*7b9ca4c6SJan Kara dquot_decr_space(transfer_to[cnt], cur_space); 2026*7b9ca4c6SJan Kara dquot_free_reserved_space(transfer_to[cnt], rsv_space); 2027*7b9ca4c6SJan Kara spin_unlock(&transfer_to[cnt]->dq_dqb_lock); 2028*7b9ca4c6SJan Kara } 2029*7b9ca4c6SJan Kara spin_unlock(&inode->i_lock); 2030884d179dSJan Kara spin_unlock(&dq_data_lock); 2031bf097aafSJan Kara flush_warnings(warn_to); 203286f3cbecSJan Kara return ret; 2033884d179dSJan Kara } 2034bc8e5f07SJan Kara EXPORT_SYMBOL(__dquot_transfer); 2035884d179dSJan Kara 20368ddd69d6SDmitry Monakhov /* Wrapper for transferring ownership of an inode for uid/gid only 20378ddd69d6SDmitry Monakhov * Called from FSXXX_setattr() 20388ddd69d6SDmitry Monakhov */ 2039b43fa828SChristoph Hellwig int dquot_transfer(struct inode *inode, struct iattr *iattr) 2040884d179dSJan Kara { 2041bc8e5f07SJan Kara struct dquot *transfer_to[MAXQUOTAS] = {}; 20426184fc0bSJan Kara struct dquot *dquot; 2043bc8e5f07SJan Kara struct super_block *sb = inode->i_sb; 2044bc8e5f07SJan Kara int ret; 20458ddd69d6SDmitry Monakhov 2046189eef59SChristoph Hellwig if (!dquot_active(inode)) 2047884d179dSJan Kara return 0; 2048bc8e5f07SJan Kara 20496184fc0bSJan Kara if (iattr->ia_valid & ATTR_UID && !uid_eq(iattr->ia_uid, inode->i_uid)){ 20506184fc0bSJan Kara dquot = dqget(sb, make_kqid_uid(iattr->ia_uid)); 20516184fc0bSJan Kara if (IS_ERR(dquot)) { 20526184fc0bSJan Kara if (PTR_ERR(dquot) != -ESRCH) { 20536184fc0bSJan Kara ret = PTR_ERR(dquot); 20546184fc0bSJan Kara goto out_put; 20556184fc0bSJan Kara } 20566184fc0bSJan Kara dquot = NULL; 20576184fc0bSJan Kara } 20586184fc0bSJan Kara transfer_to[USRQUOTA] = dquot; 20596184fc0bSJan Kara } 20606184fc0bSJan Kara if (iattr->ia_valid & ATTR_GID && !gid_eq(iattr->ia_gid, inode->i_gid)){ 20616184fc0bSJan Kara dquot = dqget(sb, make_kqid_gid(iattr->ia_gid)); 20626184fc0bSJan Kara if (IS_ERR(dquot)) { 20636184fc0bSJan Kara if (PTR_ERR(dquot) != -ESRCH) { 20646184fc0bSJan Kara ret = PTR_ERR(dquot); 20656184fc0bSJan Kara goto out_put; 20666184fc0bSJan Kara } 20676184fc0bSJan Kara dquot = NULL; 20686184fc0bSJan Kara } 20696184fc0bSJan Kara transfer_to[GRPQUOTA] = dquot; 20706184fc0bSJan Kara } 2071bc8e5f07SJan Kara ret = __dquot_transfer(inode, transfer_to); 20726184fc0bSJan Kara out_put: 2073bc8e5f07SJan Kara dqput_all(transfer_to); 2074bc8e5f07SJan Kara return ret; 2075884d179dSJan Kara } 2076b43fa828SChristoph Hellwig EXPORT_SYMBOL(dquot_transfer); 2077884d179dSJan Kara 2078884d179dSJan Kara /* 2079884d179dSJan Kara * Write info of quota file to disk 2080884d179dSJan Kara */ 2081884d179dSJan Kara int dquot_commit_info(struct super_block *sb, int type) 2082884d179dSJan Kara { 2083884d179dSJan Kara struct quota_info *dqopt = sb_dqopt(sb); 2084884d179dSJan Kara 20859a8ae30eSJan Kara return dqopt->ops[type]->write_file_info(sb, type); 2086884d179dSJan Kara } 2087884d179dSJan Kara EXPORT_SYMBOL(dquot_commit_info); 2088884d179dSJan Kara 2089be6257b2SJan Kara int dquot_get_next_id(struct super_block *sb, struct kqid *qid) 2090be6257b2SJan Kara { 2091be6257b2SJan Kara struct quota_info *dqopt = sb_dqopt(sb); 2092be6257b2SJan Kara 20939d1ccbe7SJan Kara if (!sb_has_quota_active(sb, qid->type)) 20949d1ccbe7SJan Kara return -ESRCH; 20959d1ccbe7SJan Kara if (!dqopt->ops[qid->type]->get_next_id) 20969d1ccbe7SJan Kara return -ENOSYS; 2097f14618c6SJan Kara return dqopt->ops[qid->type]->get_next_id(sb, qid); 2098be6257b2SJan Kara } 2099be6257b2SJan Kara EXPORT_SYMBOL(dquot_get_next_id); 2100be6257b2SJan Kara 2101884d179dSJan Kara /* 2102884d179dSJan Kara * Definitions of diskquota operations. 2103884d179dSJan Kara */ 210461e225dcSAlexey Dobriyan const struct dquot_operations dquot_operations = { 2105884d179dSJan Kara .write_dquot = dquot_commit, 2106884d179dSJan Kara .acquire_dquot = dquot_acquire, 2107884d179dSJan Kara .release_dquot = dquot_release, 2108884d179dSJan Kara .mark_dirty = dquot_mark_dquot_dirty, 2109884d179dSJan Kara .write_info = dquot_commit_info, 2110884d179dSJan Kara .alloc_dquot = dquot_alloc, 2111884d179dSJan Kara .destroy_dquot = dquot_destroy, 2112be6257b2SJan Kara .get_next_id = dquot_get_next_id, 2113884d179dSJan Kara }; 2114123e9cafSChristoph Hellwig EXPORT_SYMBOL(dquot_operations); 2115884d179dSJan Kara 2116884d179dSJan Kara /* 2117907f4554SChristoph Hellwig * Generic helper for ->open on filesystems supporting disk quotas. 2118907f4554SChristoph Hellwig */ 2119907f4554SChristoph Hellwig int dquot_file_open(struct inode *inode, struct file *file) 2120907f4554SChristoph Hellwig { 2121907f4554SChristoph Hellwig int error; 2122907f4554SChristoph Hellwig 2123907f4554SChristoph Hellwig error = generic_file_open(inode, file); 2124907f4554SChristoph Hellwig if (!error && (file->f_mode & FMODE_WRITE)) 2125871a2931SChristoph Hellwig dquot_initialize(inode); 2126907f4554SChristoph Hellwig return error; 2127907f4554SChristoph Hellwig } 2128907f4554SChristoph Hellwig EXPORT_SYMBOL(dquot_file_open); 2129907f4554SChristoph Hellwig 2130907f4554SChristoph Hellwig /* 2131884d179dSJan Kara * Turn quota off on a device. type == -1 ==> quotaoff for all types (umount) 2132884d179dSJan Kara */ 21330f0dd62fSChristoph Hellwig int dquot_disable(struct super_block *sb, int type, unsigned int flags) 2134884d179dSJan Kara { 2135884d179dSJan Kara int cnt, ret = 0; 2136884d179dSJan Kara struct quota_info *dqopt = sb_dqopt(sb); 2137884d179dSJan Kara struct inode *toputinode[MAXQUOTAS]; 2138884d179dSJan Kara 21397d6cd73dSJan Kara /* s_umount should be held in exclusive mode */ 21407d6cd73dSJan Kara if (WARN_ON_ONCE(down_read_trylock(&sb->s_umount))) 21417d6cd73dSJan Kara up_read(&sb->s_umount); 21427d6cd73dSJan Kara 2143884d179dSJan Kara /* Cannot turn off usage accounting without turning off limits, or 2144884d179dSJan Kara * suspend quotas and simultaneously turn quotas off. */ 2145884d179dSJan Kara if ((flags & DQUOT_USAGE_ENABLED && !(flags & DQUOT_LIMITS_ENABLED)) 2146884d179dSJan Kara || (flags & DQUOT_SUSPENDED && flags & (DQUOT_LIMITS_ENABLED | 2147884d179dSJan Kara DQUOT_USAGE_ENABLED))) 2148884d179dSJan Kara return -EINVAL; 2149884d179dSJan Kara 2150884d179dSJan Kara /* 2151884d179dSJan Kara * Skip everything if there's nothing to do. We have to do this because 2152884d179dSJan Kara * sometimes we are called when fill_super() failed and calling 2153884d179dSJan Kara * sync_fs() in such cases does no good. 2154884d179dSJan Kara */ 2155c3b00446SJan Kara if (!sb_any_quota_loaded(sb)) 2156884d179dSJan Kara return 0; 2157c3b00446SJan Kara 2158884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 2159884d179dSJan Kara toputinode[cnt] = NULL; 2160884d179dSJan Kara if (type != -1 && cnt != type) 2161884d179dSJan Kara continue; 2162884d179dSJan Kara if (!sb_has_quota_loaded(sb, cnt)) 2163884d179dSJan Kara continue; 2164884d179dSJan Kara 2165884d179dSJan Kara if (flags & DQUOT_SUSPENDED) { 2166884d179dSJan Kara spin_lock(&dq_state_lock); 2167884d179dSJan Kara dqopt->flags |= 2168884d179dSJan Kara dquot_state_flag(DQUOT_SUSPENDED, cnt); 2169884d179dSJan Kara spin_unlock(&dq_state_lock); 2170884d179dSJan Kara } else { 2171884d179dSJan Kara spin_lock(&dq_state_lock); 2172884d179dSJan Kara dqopt->flags &= ~dquot_state_flag(flags, cnt); 2173884d179dSJan Kara /* Turning off suspended quotas? */ 2174884d179dSJan Kara if (!sb_has_quota_loaded(sb, cnt) && 2175884d179dSJan Kara sb_has_quota_suspended(sb, cnt)) { 2176884d179dSJan Kara dqopt->flags &= ~dquot_state_flag( 2177884d179dSJan Kara DQUOT_SUSPENDED, cnt); 2178884d179dSJan Kara spin_unlock(&dq_state_lock); 2179884d179dSJan Kara iput(dqopt->files[cnt]); 2180884d179dSJan Kara dqopt->files[cnt] = NULL; 2181884d179dSJan Kara continue; 2182884d179dSJan Kara } 2183884d179dSJan Kara spin_unlock(&dq_state_lock); 2184884d179dSJan Kara } 2185884d179dSJan Kara 2186884d179dSJan Kara /* We still have to keep quota loaded? */ 2187884d179dSJan Kara if (sb_has_quota_loaded(sb, cnt) && !(flags & DQUOT_SUSPENDED)) 2188884d179dSJan Kara continue; 2189884d179dSJan Kara 2190884d179dSJan Kara /* Note: these are blocking operations */ 2191884d179dSJan Kara drop_dquot_ref(sb, cnt); 2192884d179dSJan Kara invalidate_dquots(sb, cnt); 2193884d179dSJan Kara /* 2194268157baSJan Kara * Now all dquots should be invalidated, all writes done so we 2195268157baSJan Kara * should be only users of the info. No locks needed. 2196884d179dSJan Kara */ 2197884d179dSJan Kara if (info_dirty(&dqopt->info[cnt])) 2198884d179dSJan Kara sb->dq_op->write_info(sb, cnt); 2199884d179dSJan Kara if (dqopt->ops[cnt]->free_file_info) 2200884d179dSJan Kara dqopt->ops[cnt]->free_file_info(sb, cnt); 2201884d179dSJan Kara put_quota_format(dqopt->info[cnt].dqi_format); 2202884d179dSJan Kara 2203884d179dSJan Kara toputinode[cnt] = dqopt->files[cnt]; 2204884d179dSJan Kara if (!sb_has_quota_loaded(sb, cnt)) 2205884d179dSJan Kara dqopt->files[cnt] = NULL; 2206884d179dSJan Kara dqopt->info[cnt].dqi_flags = 0; 2207884d179dSJan Kara dqopt->info[cnt].dqi_igrace = 0; 2208884d179dSJan Kara dqopt->info[cnt].dqi_bgrace = 0; 2209884d179dSJan Kara dqopt->ops[cnt] = NULL; 2210884d179dSJan Kara } 2211884d179dSJan Kara 2212884d179dSJan Kara /* Skip syncing and setting flags if quota files are hidden */ 2213884d179dSJan Kara if (dqopt->flags & DQUOT_QUOTA_SYS_FILE) 2214884d179dSJan Kara goto put_inodes; 2215884d179dSJan Kara 2216884d179dSJan Kara /* Sync the superblock so that buffers with quota data are written to 2217884d179dSJan Kara * disk (and so userspace sees correct data afterwards). */ 2218884d179dSJan Kara if (sb->s_op->sync_fs) 2219884d179dSJan Kara sb->s_op->sync_fs(sb, 1); 2220884d179dSJan Kara sync_blockdev(sb->s_bdev); 2221884d179dSJan Kara /* Now the quota files are just ordinary files and we can set the 2222884d179dSJan Kara * inode flags back. Moreover we discard the pagecache so that 2223884d179dSJan Kara * userspace sees the writes we did bypassing the pagecache. We 2224884d179dSJan Kara * must also discard the blockdev buffers so that we see the 2225884d179dSJan Kara * changes done by userspace on the next quotaon() */ 2226884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) 22272700e606SJan Kara /* This can happen when suspending quotas on remount-ro... */ 22282700e606SJan Kara if (toputinode[cnt] && !sb_has_quota_loaded(sb, cnt)) { 22295955102cSAl Viro inode_lock(toputinode[cnt]); 2230aad6cde9SJan Kara toputinode[cnt]->i_flags &= ~S_NOQUOTA; 2231c3b00446SJan Kara truncate_inode_pages(&toputinode[cnt]->i_data, 0); 22325955102cSAl Viro inode_unlock(toputinode[cnt]); 223343d2932dSJan Kara mark_inode_dirty_sync(toputinode[cnt]); 2234884d179dSJan Kara } 2235884d179dSJan Kara if (sb->s_bdev) 2236884d179dSJan Kara invalidate_bdev(sb->s_bdev); 2237884d179dSJan Kara put_inodes: 2238884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) 2239884d179dSJan Kara if (toputinode[cnt]) { 2240884d179dSJan Kara /* On remount RO, we keep the inode pointer so that we 2241884d179dSJan Kara * can reenable quota on the subsequent remount RW. We 2242884d179dSJan Kara * have to check 'flags' variable and not use sb_has_ 2243884d179dSJan Kara * function because another quotaon / quotaoff could 2244884d179dSJan Kara * change global state before we got here. We refuse 2245884d179dSJan Kara * to suspend quotas when there is pending delete on 2246884d179dSJan Kara * the quota file... */ 2247884d179dSJan Kara if (!(flags & DQUOT_SUSPENDED)) 2248884d179dSJan Kara iput(toputinode[cnt]); 2249884d179dSJan Kara else if (!toputinode[cnt]->i_nlink) 2250884d179dSJan Kara ret = -EBUSY; 2251884d179dSJan Kara } 2252884d179dSJan Kara return ret; 2253884d179dSJan Kara } 22540f0dd62fSChristoph Hellwig EXPORT_SYMBOL(dquot_disable); 2255884d179dSJan Kara 2256287a8095SChristoph Hellwig int dquot_quota_off(struct super_block *sb, int type) 2257884d179dSJan Kara { 22580f0dd62fSChristoph Hellwig return dquot_disable(sb, type, 22590f0dd62fSChristoph Hellwig DQUOT_USAGE_ENABLED | DQUOT_LIMITS_ENABLED); 2260884d179dSJan Kara } 2261287a8095SChristoph Hellwig EXPORT_SYMBOL(dquot_quota_off); 22620f0dd62fSChristoph Hellwig 2263884d179dSJan Kara /* 2264884d179dSJan Kara * Turn quotas on on a device 2265884d179dSJan Kara */ 2266884d179dSJan Kara 2267884d179dSJan Kara /* 2268884d179dSJan Kara * Helper function to turn quotas on when we already have the inode of 2269884d179dSJan Kara * quota file and no quota information is loaded. 2270884d179dSJan Kara */ 2271884d179dSJan Kara static int vfs_load_quota_inode(struct inode *inode, int type, int format_id, 2272884d179dSJan Kara unsigned int flags) 2273884d179dSJan Kara { 2274884d179dSJan Kara struct quota_format_type *fmt = find_quota_format(format_id); 2275884d179dSJan Kara struct super_block *sb = inode->i_sb; 2276884d179dSJan Kara struct quota_info *dqopt = sb_dqopt(sb); 2277884d179dSJan Kara int error; 2278884d179dSJan Kara 2279884d179dSJan Kara if (!fmt) 2280884d179dSJan Kara return -ESRCH; 2281884d179dSJan Kara if (!S_ISREG(inode->i_mode)) { 2282884d179dSJan Kara error = -EACCES; 2283884d179dSJan Kara goto out_fmt; 2284884d179dSJan Kara } 2285884d179dSJan Kara if (IS_RDONLY(inode)) { 2286884d179dSJan Kara error = -EROFS; 2287884d179dSJan Kara goto out_fmt; 2288884d179dSJan Kara } 2289847aac64SLi Xi if (!sb->s_op->quota_write || !sb->s_op->quota_read || 2290847aac64SLi Xi (type == PRJQUOTA && sb->dq_op->get_projid == NULL)) { 2291884d179dSJan Kara error = -EINVAL; 2292884d179dSJan Kara goto out_fmt; 2293884d179dSJan Kara } 22945c004828SEric W. Biederman /* Filesystems outside of init_user_ns not yet supported */ 22955c004828SEric W. Biederman if (sb->s_user_ns != &init_user_ns) { 22965c004828SEric W. Biederman error = -EINVAL; 22975c004828SEric W. Biederman goto out_fmt; 22985c004828SEric W. Biederman } 2299884d179dSJan Kara /* Usage always has to be set... */ 2300884d179dSJan Kara if (!(flags & DQUOT_USAGE_ENABLED)) { 2301884d179dSJan Kara error = -EINVAL; 2302884d179dSJan Kara goto out_fmt; 2303884d179dSJan Kara } 2304c3b00446SJan Kara if (sb_has_quota_loaded(sb, type)) { 2305c3b00446SJan Kara error = -EBUSY; 2306c3b00446SJan Kara goto out_fmt; 2307c3b00446SJan Kara } 2308884d179dSJan Kara 2309884d179dSJan Kara if (!(dqopt->flags & DQUOT_QUOTA_SYS_FILE)) { 2310ab94c39bSJan Kara /* As we bypass the pagecache we must now flush all the 2311ab94c39bSJan Kara * dirty data and invalidate caches so that kernel sees 2312ab94c39bSJan Kara * changes from userspace. It is not enough to just flush 2313ab94c39bSJan Kara * the quota file since if blocksize < pagesize, invalidation 2314ab94c39bSJan Kara * of the cache could fail because of other unrelated dirty 2315ab94c39bSJan Kara * data */ 2316ab94c39bSJan Kara sync_filesystem(sb); 2317884d179dSJan Kara invalidate_bdev(sb->s_bdev); 2318884d179dSJan Kara } 2319884d179dSJan Kara 2320884d179dSJan Kara if (!(dqopt->flags & DQUOT_QUOTA_SYS_FILE)) { 2321884d179dSJan Kara /* We don't want quota and atime on quota files (deadlocks 2322884d179dSJan Kara * possible) Also nobody should write to the file - we use 2323884d179dSJan Kara * special IO operations which ignore the immutable bit. */ 23245955102cSAl Viro inode_lock(inode); 2325aad6cde9SJan Kara inode->i_flags |= S_NOQUOTA; 23265955102cSAl Viro inode_unlock(inode); 232726245c94SJan Kara /* 232826245c94SJan Kara * When S_NOQUOTA is set, remove dquot references as no more 232926245c94SJan Kara * references can be added 233026245c94SJan Kara */ 23319f754758SChristoph Hellwig __dquot_drop(inode); 2332884d179dSJan Kara } 2333884d179dSJan Kara 2334884d179dSJan Kara error = -EIO; 2335884d179dSJan Kara dqopt->files[type] = igrab(inode); 2336884d179dSJan Kara if (!dqopt->files[type]) 2337c3b00446SJan Kara goto out_file_flags; 2338884d179dSJan Kara error = -EINVAL; 2339884d179dSJan Kara if (!fmt->qf_ops->check_quota_file(sb, type)) 2340884d179dSJan Kara goto out_file_init; 2341884d179dSJan Kara 2342884d179dSJan Kara dqopt->ops[type] = fmt->qf_ops; 2343884d179dSJan Kara dqopt->info[type].dqi_format = fmt; 2344884d179dSJan Kara dqopt->info[type].dqi_fmt_id = format_id; 2345884d179dSJan Kara INIT_LIST_HEAD(&dqopt->info[type].dqi_dirty_list); 2346268157baSJan Kara error = dqopt->ops[type]->read_file_info(sb, type); 234742fdb858SJan Kara if (error < 0) 2348884d179dSJan Kara goto out_file_init; 234915512377SJan Kara if (dqopt->flags & DQUOT_QUOTA_SYS_FILE) { 235015512377SJan Kara spin_lock(&dq_data_lock); 235146fe44ceSJan Kara dqopt->info[type].dqi_flags |= DQF_SYS_FILE; 235215512377SJan Kara spin_unlock(&dq_data_lock); 235315512377SJan Kara } 2354884d179dSJan Kara spin_lock(&dq_state_lock); 2355884d179dSJan Kara dqopt->flags |= dquot_state_flag(flags, type); 2356884d179dSJan Kara spin_unlock(&dq_state_lock); 2357884d179dSJan Kara 2358884d179dSJan Kara add_dquot_ref(sb, type); 2359884d179dSJan Kara 2360884d179dSJan Kara return 0; 2361884d179dSJan Kara 2362884d179dSJan Kara out_file_init: 2363884d179dSJan Kara dqopt->files[type] = NULL; 2364884d179dSJan Kara iput(inode); 2365c3b00446SJan Kara out_file_flags: 23665955102cSAl Viro inode_lock(inode); 2367aad6cde9SJan Kara inode->i_flags &= ~S_NOQUOTA; 23685955102cSAl Viro inode_unlock(inode); 2369884d179dSJan Kara out_fmt: 2370884d179dSJan Kara put_quota_format(fmt); 2371884d179dSJan Kara 2372884d179dSJan Kara return error; 2373884d179dSJan Kara } 2374884d179dSJan Kara 2375884d179dSJan Kara /* Reenable quotas on remount RW */ 23760f0dd62fSChristoph Hellwig int dquot_resume(struct super_block *sb, int type) 2377884d179dSJan Kara { 2378884d179dSJan Kara struct quota_info *dqopt = sb_dqopt(sb); 2379884d179dSJan Kara struct inode *inode; 23800f0dd62fSChristoph Hellwig int ret = 0, cnt; 2381884d179dSJan Kara unsigned int flags; 2382884d179dSJan Kara 23837d6cd73dSJan Kara /* s_umount should be held in exclusive mode */ 23847d6cd73dSJan Kara if (WARN_ON_ONCE(down_read_trylock(&sb->s_umount))) 23857d6cd73dSJan Kara up_read(&sb->s_umount); 23867d6cd73dSJan Kara 23870f0dd62fSChristoph Hellwig for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 23880f0dd62fSChristoph Hellwig if (type != -1 && cnt != type) 23890f0dd62fSChristoph Hellwig continue; 2390c3b00446SJan Kara if (!sb_has_quota_suspended(sb, cnt)) 23910f0dd62fSChristoph Hellwig continue; 2392c3b00446SJan Kara 23930f0dd62fSChristoph Hellwig inode = dqopt->files[cnt]; 23940f0dd62fSChristoph Hellwig dqopt->files[cnt] = NULL; 2395884d179dSJan Kara spin_lock(&dq_state_lock); 2396884d179dSJan Kara flags = dqopt->flags & dquot_state_flag(DQUOT_USAGE_ENABLED | 23970f0dd62fSChristoph Hellwig DQUOT_LIMITS_ENABLED, 23980f0dd62fSChristoph Hellwig cnt); 23990f0dd62fSChristoph Hellwig dqopt->flags &= ~dquot_state_flag(DQUOT_STATE_FLAGS, cnt); 2400884d179dSJan Kara spin_unlock(&dq_state_lock); 2401884d179dSJan Kara 24020f0dd62fSChristoph Hellwig flags = dquot_generic_flag(flags, cnt); 24030f0dd62fSChristoph Hellwig ret = vfs_load_quota_inode(inode, cnt, 24040f0dd62fSChristoph Hellwig dqopt->info[cnt].dqi_fmt_id, flags); 2405884d179dSJan Kara iput(inode); 24060f0dd62fSChristoph Hellwig } 2407884d179dSJan Kara 2408884d179dSJan Kara return ret; 2409884d179dSJan Kara } 24100f0dd62fSChristoph Hellwig EXPORT_SYMBOL(dquot_resume); 2411884d179dSJan Kara 2412f00c9e44SJan Kara int dquot_quota_on(struct super_block *sb, int type, int format_id, 24138c54ca9cSAl Viro const struct path *path) 2414884d179dSJan Kara { 2415884d179dSJan Kara int error = security_quota_on(path->dentry); 2416884d179dSJan Kara if (error) 2417884d179dSJan Kara return error; 2418884d179dSJan Kara /* Quota file not on the same filesystem? */ 2419d8c9584eSAl Viro if (path->dentry->d_sb != sb) 2420884d179dSJan Kara error = -EXDEV; 2421884d179dSJan Kara else 2422dea655c2SDavid Howells error = vfs_load_quota_inode(d_inode(path->dentry), type, 2423884d179dSJan Kara format_id, DQUOT_USAGE_ENABLED | 2424884d179dSJan Kara DQUOT_LIMITS_ENABLED); 2425884d179dSJan Kara return error; 2426884d179dSJan Kara } 2427287a8095SChristoph Hellwig EXPORT_SYMBOL(dquot_quota_on); 2428884d179dSJan Kara 2429884d179dSJan Kara /* 2430884d179dSJan Kara * More powerful function for turning on quotas allowing setting 2431884d179dSJan Kara * of individual quota flags 2432884d179dSJan Kara */ 2433287a8095SChristoph Hellwig int dquot_enable(struct inode *inode, int type, int format_id, 2434884d179dSJan Kara unsigned int flags) 2435884d179dSJan Kara { 2436884d179dSJan Kara struct super_block *sb = inode->i_sb; 2437884d179dSJan Kara 2438884d179dSJan Kara /* Just unsuspend quotas? */ 24390f0dd62fSChristoph Hellwig BUG_ON(flags & DQUOT_SUSPENDED); 24407d6cd73dSJan Kara /* s_umount should be held in exclusive mode */ 24417d6cd73dSJan Kara if (WARN_ON_ONCE(down_read_trylock(&sb->s_umount))) 24427d6cd73dSJan Kara up_read(&sb->s_umount); 24430f0dd62fSChristoph Hellwig 2444884d179dSJan Kara if (!flags) 2445884d179dSJan Kara return 0; 2446884d179dSJan Kara /* Just updating flags needed? */ 2447884d179dSJan Kara if (sb_has_quota_loaded(sb, type)) { 2448884d179dSJan Kara if (flags & DQUOT_USAGE_ENABLED && 2449c3b00446SJan Kara sb_has_quota_usage_enabled(sb, type)) 2450c3b00446SJan Kara return -EBUSY; 2451884d179dSJan Kara if (flags & DQUOT_LIMITS_ENABLED && 2452c3b00446SJan Kara sb_has_quota_limits_enabled(sb, type)) 2453c3b00446SJan Kara return -EBUSY; 2454884d179dSJan Kara spin_lock(&dq_state_lock); 2455884d179dSJan Kara sb_dqopt(sb)->flags |= dquot_state_flag(flags, type); 2456884d179dSJan Kara spin_unlock(&dq_state_lock); 2457c3b00446SJan Kara return 0; 2458884d179dSJan Kara } 2459884d179dSJan Kara 2460884d179dSJan Kara return vfs_load_quota_inode(inode, type, format_id, flags); 2461884d179dSJan Kara } 2462287a8095SChristoph Hellwig EXPORT_SYMBOL(dquot_enable); 2463884d179dSJan Kara 2464884d179dSJan Kara /* 2465884d179dSJan Kara * This function is used when filesystem needs to initialize quotas 2466884d179dSJan Kara * during mount time. 2467884d179dSJan Kara */ 2468287a8095SChristoph Hellwig int dquot_quota_on_mount(struct super_block *sb, char *qf_name, 2469884d179dSJan Kara int format_id, int type) 2470884d179dSJan Kara { 2471884d179dSJan Kara struct dentry *dentry; 2472884d179dSJan Kara int error; 2473884d179dSJan Kara 2474e12a4e8aSAl Viro dentry = lookup_one_len_unlocked(qf_name, sb->s_root, strlen(qf_name)); 2475884d179dSJan Kara if (IS_ERR(dentry)) 2476884d179dSJan Kara return PTR_ERR(dentry); 2477884d179dSJan Kara 2478dea655c2SDavid Howells if (d_really_is_negative(dentry)) { 2479884d179dSJan Kara error = -ENOENT; 2480884d179dSJan Kara goto out; 2481884d179dSJan Kara } 2482884d179dSJan Kara 2483884d179dSJan Kara error = security_quota_on(dentry); 2484884d179dSJan Kara if (!error) 2485dea655c2SDavid Howells error = vfs_load_quota_inode(d_inode(dentry), type, format_id, 2486884d179dSJan Kara DQUOT_USAGE_ENABLED | DQUOT_LIMITS_ENABLED); 2487884d179dSJan Kara 2488884d179dSJan Kara out: 2489884d179dSJan Kara dput(dentry); 2490884d179dSJan Kara return error; 2491884d179dSJan Kara } 2492287a8095SChristoph Hellwig EXPORT_SYMBOL(dquot_quota_on_mount); 2493884d179dSJan Kara 24943e2af67eSJan Kara static int dquot_quota_enable(struct super_block *sb, unsigned int flags) 24953e2af67eSJan Kara { 24963e2af67eSJan Kara int ret; 24973e2af67eSJan Kara int type; 24983e2af67eSJan Kara struct quota_info *dqopt = sb_dqopt(sb); 24993e2af67eSJan Kara 25003e2af67eSJan Kara if (!(dqopt->flags & DQUOT_QUOTA_SYS_FILE)) 25013e2af67eSJan Kara return -ENOSYS; 25023e2af67eSJan Kara /* Accounting cannot be turned on while fs is mounted */ 25033e2af67eSJan Kara flags &= ~(FS_QUOTA_UDQ_ACCT | FS_QUOTA_GDQ_ACCT | FS_QUOTA_PDQ_ACCT); 25043e2af67eSJan Kara if (!flags) 25053e2af67eSJan Kara return -EINVAL; 25063e2af67eSJan Kara for (type = 0; type < MAXQUOTAS; type++) { 25073e2af67eSJan Kara if (!(flags & qtype_enforce_flag(type))) 25083e2af67eSJan Kara continue; 25093e2af67eSJan Kara /* Can't enforce without accounting */ 25103e2af67eSJan Kara if (!sb_has_quota_usage_enabled(sb, type)) 25113e2af67eSJan Kara return -EINVAL; 25123e2af67eSJan Kara ret = dquot_enable(dqopt->files[type], type, 25133e2af67eSJan Kara dqopt->info[type].dqi_fmt_id, 25143e2af67eSJan Kara DQUOT_LIMITS_ENABLED); 25153e2af67eSJan Kara if (ret < 0) 25163e2af67eSJan Kara goto out_err; 25173e2af67eSJan Kara } 25183e2af67eSJan Kara return 0; 25193e2af67eSJan Kara out_err: 25203e2af67eSJan Kara /* Backout enforcement enablement we already did */ 25213e2af67eSJan Kara for (type--; type >= 0; type--) { 25223e2af67eSJan Kara if (flags & qtype_enforce_flag(type)) 25233e2af67eSJan Kara dquot_disable(sb, type, DQUOT_LIMITS_ENABLED); 25243e2af67eSJan Kara } 25253e2af67eSJan Kara /* Error code translation for better compatibility with XFS */ 25263e2af67eSJan Kara if (ret == -EBUSY) 25273e2af67eSJan Kara ret = -EEXIST; 25283e2af67eSJan Kara return ret; 25293e2af67eSJan Kara } 25303e2af67eSJan Kara 25313e2af67eSJan Kara static int dquot_quota_disable(struct super_block *sb, unsigned int flags) 25323e2af67eSJan Kara { 25333e2af67eSJan Kara int ret; 25343e2af67eSJan Kara int type; 25353e2af67eSJan Kara struct quota_info *dqopt = sb_dqopt(sb); 25363e2af67eSJan Kara 25373e2af67eSJan Kara if (!(dqopt->flags & DQUOT_QUOTA_SYS_FILE)) 25383e2af67eSJan Kara return -ENOSYS; 25393e2af67eSJan Kara /* 25403e2af67eSJan Kara * We don't support turning off accounting via quotactl. In principle 25413e2af67eSJan Kara * quota infrastructure can do this but filesystems don't expect 25423e2af67eSJan Kara * userspace to be able to do it. 25433e2af67eSJan Kara */ 25443e2af67eSJan Kara if (flags & 25453e2af67eSJan Kara (FS_QUOTA_UDQ_ACCT | FS_QUOTA_GDQ_ACCT | FS_QUOTA_PDQ_ACCT)) 25463e2af67eSJan Kara return -EOPNOTSUPP; 25473e2af67eSJan Kara 25483e2af67eSJan Kara /* Filter out limits not enabled */ 25493e2af67eSJan Kara for (type = 0; type < MAXQUOTAS; type++) 25503e2af67eSJan Kara if (!sb_has_quota_limits_enabled(sb, type)) 25513e2af67eSJan Kara flags &= ~qtype_enforce_flag(type); 25523e2af67eSJan Kara /* Nothing left? */ 25533e2af67eSJan Kara if (!flags) 25543e2af67eSJan Kara return -EEXIST; 25553e2af67eSJan Kara for (type = 0; type < MAXQUOTAS; type++) { 25563e2af67eSJan Kara if (flags & qtype_enforce_flag(type)) { 25573e2af67eSJan Kara ret = dquot_disable(sb, type, DQUOT_LIMITS_ENABLED); 25583e2af67eSJan Kara if (ret < 0) 25593e2af67eSJan Kara goto out_err; 25603e2af67eSJan Kara } 25613e2af67eSJan Kara } 25623e2af67eSJan Kara return 0; 25633e2af67eSJan Kara out_err: 25643e2af67eSJan Kara /* Backout enforcement disabling we already did */ 25653e2af67eSJan Kara for (type--; type >= 0; type--) { 25663e2af67eSJan Kara if (flags & qtype_enforce_flag(type)) 25673e2af67eSJan Kara dquot_enable(dqopt->files[type], type, 25683e2af67eSJan Kara dqopt->info[type].dqi_fmt_id, 25693e2af67eSJan Kara DQUOT_LIMITS_ENABLED); 25703e2af67eSJan Kara } 25713e2af67eSJan Kara return ret; 25723e2af67eSJan Kara } 25733e2af67eSJan Kara 2574884d179dSJan Kara /* Generic routine for getting common part of quota structure */ 257514bf61ffSJan Kara static void do_get_dqblk(struct dquot *dquot, struct qc_dqblk *di) 2576884d179dSJan Kara { 2577884d179dSJan Kara struct mem_dqblk *dm = &dquot->dq_dqb; 2578884d179dSJan Kara 2579b9b2dd36SChristoph Hellwig memset(di, 0, sizeof(*di)); 2580*7b9ca4c6SJan Kara spin_lock(&dquot->dq_dqb_lock); 258114bf61ffSJan Kara di->d_spc_hardlimit = dm->dqb_bhardlimit; 258214bf61ffSJan Kara di->d_spc_softlimit = dm->dqb_bsoftlimit; 2583b9b2dd36SChristoph Hellwig di->d_ino_hardlimit = dm->dqb_ihardlimit; 2584b9b2dd36SChristoph Hellwig di->d_ino_softlimit = dm->dqb_isoftlimit; 258514bf61ffSJan Kara di->d_space = dm->dqb_curspace + dm->dqb_rsvspace; 258614bf61ffSJan Kara di->d_ino_count = dm->dqb_curinodes; 258714bf61ffSJan Kara di->d_spc_timer = dm->dqb_btime; 258814bf61ffSJan Kara di->d_ino_timer = dm->dqb_itime; 2589*7b9ca4c6SJan Kara spin_unlock(&dquot->dq_dqb_lock); 2590884d179dSJan Kara } 2591884d179dSJan Kara 259274a8a103SEric W. Biederman int dquot_get_dqblk(struct super_block *sb, struct kqid qid, 259314bf61ffSJan Kara struct qc_dqblk *di) 2594884d179dSJan Kara { 2595884d179dSJan Kara struct dquot *dquot; 2596884d179dSJan Kara 2597aca645a6SEric W. Biederman dquot = dqget(sb, qid); 25986184fc0bSJan Kara if (IS_ERR(dquot)) 25996184fc0bSJan Kara return PTR_ERR(dquot); 2600884d179dSJan Kara do_get_dqblk(dquot, di); 2601884d179dSJan Kara dqput(dquot); 2602884d179dSJan Kara 2603884d179dSJan Kara return 0; 2604884d179dSJan Kara } 2605287a8095SChristoph Hellwig EXPORT_SYMBOL(dquot_get_dqblk); 2606884d179dSJan Kara 2607be6257b2SJan Kara int dquot_get_next_dqblk(struct super_block *sb, struct kqid *qid, 2608be6257b2SJan Kara struct qc_dqblk *di) 2609be6257b2SJan Kara { 2610be6257b2SJan Kara struct dquot *dquot; 2611be6257b2SJan Kara int err; 2612be6257b2SJan Kara 2613be6257b2SJan Kara if (!sb->dq_op->get_next_id) 2614be6257b2SJan Kara return -ENOSYS; 2615be6257b2SJan Kara err = sb->dq_op->get_next_id(sb, qid); 2616be6257b2SJan Kara if (err < 0) 2617be6257b2SJan Kara return err; 2618be6257b2SJan Kara dquot = dqget(sb, *qid); 2619be6257b2SJan Kara if (IS_ERR(dquot)) 2620be6257b2SJan Kara return PTR_ERR(dquot); 2621be6257b2SJan Kara do_get_dqblk(dquot, di); 2622be6257b2SJan Kara dqput(dquot); 2623be6257b2SJan Kara 2624be6257b2SJan Kara return 0; 2625be6257b2SJan Kara } 2626be6257b2SJan Kara EXPORT_SYMBOL(dquot_get_next_dqblk); 2627be6257b2SJan Kara 262814bf61ffSJan Kara #define VFS_QC_MASK \ 262914bf61ffSJan Kara (QC_SPACE | QC_SPC_SOFT | QC_SPC_HARD | \ 263014bf61ffSJan Kara QC_INO_COUNT | QC_INO_SOFT | QC_INO_HARD | \ 263114bf61ffSJan Kara QC_SPC_TIMER | QC_INO_TIMER) 2632c472b432SChristoph Hellwig 2633884d179dSJan Kara /* Generic routine for setting common part of quota structure */ 263414bf61ffSJan Kara static int do_set_dqblk(struct dquot *dquot, struct qc_dqblk *di) 2635884d179dSJan Kara { 2636884d179dSJan Kara struct mem_dqblk *dm = &dquot->dq_dqb; 2637884d179dSJan Kara int check_blim = 0, check_ilim = 0; 26384c376dcaSEric W. Biederman struct mem_dqinfo *dqi = &sb_dqopt(dquot->dq_sb)->info[dquot->dq_id.type]; 2639884d179dSJan Kara 264014bf61ffSJan Kara if (di->d_fieldmask & ~VFS_QC_MASK) 2641c472b432SChristoph Hellwig return -EINVAL; 2642c472b432SChristoph Hellwig 264314bf61ffSJan Kara if (((di->d_fieldmask & QC_SPC_SOFT) && 2644b10a0819SJan Kara di->d_spc_softlimit > dqi->dqi_max_spc_limit) || 264514bf61ffSJan Kara ((di->d_fieldmask & QC_SPC_HARD) && 2646b10a0819SJan Kara di->d_spc_hardlimit > dqi->dqi_max_spc_limit) || 264714bf61ffSJan Kara ((di->d_fieldmask & QC_INO_SOFT) && 2648b10a0819SJan Kara (di->d_ino_softlimit > dqi->dqi_max_ino_limit)) || 264914bf61ffSJan Kara ((di->d_fieldmask & QC_INO_HARD) && 2650b10a0819SJan Kara (di->d_ino_hardlimit > dqi->dqi_max_ino_limit))) 2651884d179dSJan Kara return -ERANGE; 2652884d179dSJan Kara 2653*7b9ca4c6SJan Kara spin_lock(&dquot->dq_dqb_lock); 265414bf61ffSJan Kara if (di->d_fieldmask & QC_SPACE) { 265514bf61ffSJan Kara dm->dqb_curspace = di->d_space - dm->dqb_rsvspace; 2656884d179dSJan Kara check_blim = 1; 265708261673SAndrew Perepechko set_bit(DQ_LASTSET_B + QIF_SPACE_B, &dquot->dq_flags); 2658884d179dSJan Kara } 2659c472b432SChristoph Hellwig 266014bf61ffSJan Kara if (di->d_fieldmask & QC_SPC_SOFT) 266114bf61ffSJan Kara dm->dqb_bsoftlimit = di->d_spc_softlimit; 266214bf61ffSJan Kara if (di->d_fieldmask & QC_SPC_HARD) 266314bf61ffSJan Kara dm->dqb_bhardlimit = di->d_spc_hardlimit; 266414bf61ffSJan Kara if (di->d_fieldmask & (QC_SPC_SOFT | QC_SPC_HARD)) { 2665884d179dSJan Kara check_blim = 1; 266608261673SAndrew Perepechko set_bit(DQ_LASTSET_B + QIF_BLIMITS_B, &dquot->dq_flags); 2667884d179dSJan Kara } 2668c472b432SChristoph Hellwig 266914bf61ffSJan Kara if (di->d_fieldmask & QC_INO_COUNT) { 267014bf61ffSJan Kara dm->dqb_curinodes = di->d_ino_count; 2671884d179dSJan Kara check_ilim = 1; 267208261673SAndrew Perepechko set_bit(DQ_LASTSET_B + QIF_INODES_B, &dquot->dq_flags); 2673884d179dSJan Kara } 2674c472b432SChristoph Hellwig 267514bf61ffSJan Kara if (di->d_fieldmask & QC_INO_SOFT) 2676c472b432SChristoph Hellwig dm->dqb_isoftlimit = di->d_ino_softlimit; 267714bf61ffSJan Kara if (di->d_fieldmask & QC_INO_HARD) 2678c472b432SChristoph Hellwig dm->dqb_ihardlimit = di->d_ino_hardlimit; 267914bf61ffSJan Kara if (di->d_fieldmask & (QC_INO_SOFT | QC_INO_HARD)) { 2680884d179dSJan Kara check_ilim = 1; 268108261673SAndrew Perepechko set_bit(DQ_LASTSET_B + QIF_ILIMITS_B, &dquot->dq_flags); 2682884d179dSJan Kara } 2683c472b432SChristoph Hellwig 268414bf61ffSJan Kara if (di->d_fieldmask & QC_SPC_TIMER) { 268514bf61ffSJan Kara dm->dqb_btime = di->d_spc_timer; 2686884d179dSJan Kara check_blim = 1; 268708261673SAndrew Perepechko set_bit(DQ_LASTSET_B + QIF_BTIME_B, &dquot->dq_flags); 2688884d179dSJan Kara } 2689c472b432SChristoph Hellwig 269014bf61ffSJan Kara if (di->d_fieldmask & QC_INO_TIMER) { 269114bf61ffSJan Kara dm->dqb_itime = di->d_ino_timer; 2692884d179dSJan Kara check_ilim = 1; 269308261673SAndrew Perepechko set_bit(DQ_LASTSET_B + QIF_ITIME_B, &dquot->dq_flags); 2694884d179dSJan Kara } 2695884d179dSJan Kara 2696884d179dSJan Kara if (check_blim) { 2697268157baSJan Kara if (!dm->dqb_bsoftlimit || 2698268157baSJan Kara dm->dqb_curspace < dm->dqb_bsoftlimit) { 2699884d179dSJan Kara dm->dqb_btime = 0; 2700884d179dSJan Kara clear_bit(DQ_BLKS_B, &dquot->dq_flags); 270114bf61ffSJan Kara } else if (!(di->d_fieldmask & QC_SPC_TIMER)) 2702268157baSJan Kara /* Set grace only if user hasn't provided his own... */ 2703e008bb61SArnd Bergmann dm->dqb_btime = ktime_get_real_seconds() + dqi->dqi_bgrace; 2704884d179dSJan Kara } 2705884d179dSJan Kara if (check_ilim) { 2706268157baSJan Kara if (!dm->dqb_isoftlimit || 2707268157baSJan Kara dm->dqb_curinodes < dm->dqb_isoftlimit) { 2708884d179dSJan Kara dm->dqb_itime = 0; 2709884d179dSJan Kara clear_bit(DQ_INODES_B, &dquot->dq_flags); 271014bf61ffSJan Kara } else if (!(di->d_fieldmask & QC_INO_TIMER)) 2711268157baSJan Kara /* Set grace only if user hasn't provided his own... */ 2712e008bb61SArnd Bergmann dm->dqb_itime = ktime_get_real_seconds() + dqi->dqi_igrace; 2713884d179dSJan Kara } 2714268157baSJan Kara if (dm->dqb_bhardlimit || dm->dqb_bsoftlimit || dm->dqb_ihardlimit || 2715268157baSJan Kara dm->dqb_isoftlimit) 2716884d179dSJan Kara clear_bit(DQ_FAKE_B, &dquot->dq_flags); 2717884d179dSJan Kara else 2718884d179dSJan Kara set_bit(DQ_FAKE_B, &dquot->dq_flags); 2719*7b9ca4c6SJan Kara spin_unlock(&dquot->dq_dqb_lock); 2720884d179dSJan Kara mark_dquot_dirty(dquot); 2721884d179dSJan Kara 2722884d179dSJan Kara return 0; 2723884d179dSJan Kara } 2724884d179dSJan Kara 272574a8a103SEric W. Biederman int dquot_set_dqblk(struct super_block *sb, struct kqid qid, 272614bf61ffSJan Kara struct qc_dqblk *di) 2727884d179dSJan Kara { 2728884d179dSJan Kara struct dquot *dquot; 2729884d179dSJan Kara int rc; 2730884d179dSJan Kara 2731aca645a6SEric W. Biederman dquot = dqget(sb, qid); 27326184fc0bSJan Kara if (IS_ERR(dquot)) { 27336184fc0bSJan Kara rc = PTR_ERR(dquot); 2734884d179dSJan Kara goto out; 2735884d179dSJan Kara } 2736884d179dSJan Kara rc = do_set_dqblk(dquot, di); 2737884d179dSJan Kara dqput(dquot); 2738884d179dSJan Kara out: 2739884d179dSJan Kara return rc; 2740884d179dSJan Kara } 2741287a8095SChristoph Hellwig EXPORT_SYMBOL(dquot_set_dqblk); 2742884d179dSJan Kara 2743884d179dSJan Kara /* Generic routine for getting common part of quota file information */ 27440a240339SJan Kara int dquot_get_state(struct super_block *sb, struct qc_state *state) 2745884d179dSJan Kara { 2746884d179dSJan Kara struct mem_dqinfo *mi; 27470a240339SJan Kara struct qc_type_state *tstate; 27480a240339SJan Kara struct quota_info *dqopt = sb_dqopt(sb); 27490a240339SJan Kara int type; 2750884d179dSJan Kara 27510a240339SJan Kara memset(state, 0, sizeof(*state)); 27520a240339SJan Kara for (type = 0; type < MAXQUOTAS; type++) { 27530a240339SJan Kara if (!sb_has_quota_active(sb, type)) 27540a240339SJan Kara continue; 27550a240339SJan Kara tstate = state->s_state + type; 2756884d179dSJan Kara mi = sb_dqopt(sb)->info + type; 27570a240339SJan Kara tstate->flags = QCI_ACCT_ENABLED; 2758884d179dSJan Kara spin_lock(&dq_data_lock); 27590a240339SJan Kara if (mi->dqi_flags & DQF_SYS_FILE) 27600a240339SJan Kara tstate->flags |= QCI_SYSFILE; 27610a240339SJan Kara if (mi->dqi_flags & DQF_ROOT_SQUASH) 27620a240339SJan Kara tstate->flags |= QCI_ROOT_SQUASH; 27630a240339SJan Kara if (sb_has_quota_limits_enabled(sb, type)) 27640a240339SJan Kara tstate->flags |= QCI_LIMITS_ENFORCED; 27650a240339SJan Kara tstate->spc_timelimit = mi->dqi_bgrace; 27660a240339SJan Kara tstate->ino_timelimit = mi->dqi_igrace; 27670a240339SJan Kara tstate->ino = dqopt->files[type]->i_ino; 27680a240339SJan Kara tstate->blocks = dqopt->files[type]->i_blocks; 27690a240339SJan Kara tstate->nextents = 1; /* We don't know... */ 2770884d179dSJan Kara spin_unlock(&dq_data_lock); 27710a240339SJan Kara } 2772884d179dSJan Kara return 0; 2773884d179dSJan Kara } 27740a240339SJan Kara EXPORT_SYMBOL(dquot_get_state); 2775884d179dSJan Kara 2776884d179dSJan Kara /* Generic routine for setting common part of quota file information */ 27775eacb2acSJan Kara int dquot_set_dqinfo(struct super_block *sb, int type, struct qc_info *ii) 2778884d179dSJan Kara { 2779884d179dSJan Kara struct mem_dqinfo *mi; 2780884d179dSJan Kara int err = 0; 2781884d179dSJan Kara 27825eacb2acSJan Kara if ((ii->i_fieldmask & QC_WARNS_MASK) || 27835eacb2acSJan Kara (ii->i_fieldmask & QC_RT_SPC_TIMER)) 27845eacb2acSJan Kara return -EINVAL; 27859d1ccbe7SJan Kara if (!sb_has_quota_active(sb, type)) 27869d1ccbe7SJan Kara return -ESRCH; 2787884d179dSJan Kara mi = sb_dqopt(sb)->info + type; 27885eacb2acSJan Kara if (ii->i_fieldmask & QC_FLAGS) { 27895eacb2acSJan Kara if ((ii->i_flags & QCI_ROOT_SQUASH && 27909d1ccbe7SJan Kara mi->dqi_format->qf_fmt_id != QFMT_VFS_OLD)) 27919d1ccbe7SJan Kara return -EINVAL; 2792ca6cb091SJan Kara } 2793884d179dSJan Kara spin_lock(&dq_data_lock); 27945eacb2acSJan Kara if (ii->i_fieldmask & QC_SPC_TIMER) 27955eacb2acSJan Kara mi->dqi_bgrace = ii->i_spc_timelimit; 27965eacb2acSJan Kara if (ii->i_fieldmask & QC_INO_TIMER) 27975eacb2acSJan Kara mi->dqi_igrace = ii->i_ino_timelimit; 27985eacb2acSJan Kara if (ii->i_fieldmask & QC_FLAGS) { 27995eacb2acSJan Kara if (ii->i_flags & QCI_ROOT_SQUASH) 28005eacb2acSJan Kara mi->dqi_flags |= DQF_ROOT_SQUASH; 28015eacb2acSJan Kara else 28025eacb2acSJan Kara mi->dqi_flags &= ~DQF_ROOT_SQUASH; 28035eacb2acSJan Kara } 2804884d179dSJan Kara spin_unlock(&dq_data_lock); 2805884d179dSJan Kara mark_info_dirty(sb, type); 2806884d179dSJan Kara /* Force write to disk */ 2807884d179dSJan Kara sb->dq_op->write_info(sb, type); 2808884d179dSJan Kara return err; 2809884d179dSJan Kara } 2810287a8095SChristoph Hellwig EXPORT_SYMBOL(dquot_set_dqinfo); 2811884d179dSJan Kara 28123e2af67eSJan Kara const struct quotactl_ops dquot_quotactl_sysfile_ops = { 28133e2af67eSJan Kara .quota_enable = dquot_quota_enable, 28143e2af67eSJan Kara .quota_disable = dquot_quota_disable, 28153e2af67eSJan Kara .quota_sync = dquot_quota_sync, 28160a240339SJan Kara .get_state = dquot_get_state, 28173e2af67eSJan Kara .set_info = dquot_set_dqinfo, 28183e2af67eSJan Kara .get_dqblk = dquot_get_dqblk, 2819be6257b2SJan Kara .get_nextdqblk = dquot_get_next_dqblk, 28203e2af67eSJan Kara .set_dqblk = dquot_set_dqblk 28213e2af67eSJan Kara }; 28223e2af67eSJan Kara EXPORT_SYMBOL(dquot_quotactl_sysfile_ops); 28233e2af67eSJan Kara 2824dde95888SDmitry Monakhov static int do_proc_dqstats(struct ctl_table *table, int write, 2825dde95888SDmitry Monakhov void __user *buffer, size_t *lenp, loff_t *ppos) 2826dde95888SDmitry Monakhov { 2827dde95888SDmitry Monakhov unsigned int type = (int *)table->data - dqstats.stat; 2828f32764bdSDmitry Monakhov 2829f32764bdSDmitry Monakhov /* Update global table */ 2830f32764bdSDmitry Monakhov dqstats.stat[type] = 2831f32764bdSDmitry Monakhov percpu_counter_sum_positive(&dqstats.counter[type]); 2832dde95888SDmitry Monakhov return proc_dointvec(table, write, buffer, lenp, ppos); 2833dde95888SDmitry Monakhov } 2834dde95888SDmitry Monakhov 2835e628753bSJoe Perches static struct ctl_table fs_dqstats_table[] = { 2836884d179dSJan Kara { 2837884d179dSJan Kara .procname = "lookups", 2838dde95888SDmitry Monakhov .data = &dqstats.stat[DQST_LOOKUPS], 2839884d179dSJan Kara .maxlen = sizeof(int), 2840884d179dSJan Kara .mode = 0444, 2841dde95888SDmitry Monakhov .proc_handler = do_proc_dqstats, 2842884d179dSJan Kara }, 2843884d179dSJan Kara { 2844884d179dSJan Kara .procname = "drops", 2845dde95888SDmitry Monakhov .data = &dqstats.stat[DQST_DROPS], 2846884d179dSJan Kara .maxlen = sizeof(int), 2847884d179dSJan Kara .mode = 0444, 2848dde95888SDmitry Monakhov .proc_handler = do_proc_dqstats, 2849884d179dSJan Kara }, 2850884d179dSJan Kara { 2851884d179dSJan Kara .procname = "reads", 2852dde95888SDmitry Monakhov .data = &dqstats.stat[DQST_READS], 2853884d179dSJan Kara .maxlen = sizeof(int), 2854884d179dSJan Kara .mode = 0444, 2855dde95888SDmitry Monakhov .proc_handler = do_proc_dqstats, 2856884d179dSJan Kara }, 2857884d179dSJan Kara { 2858884d179dSJan Kara .procname = "writes", 2859dde95888SDmitry Monakhov .data = &dqstats.stat[DQST_WRITES], 2860884d179dSJan Kara .maxlen = sizeof(int), 2861884d179dSJan Kara .mode = 0444, 2862dde95888SDmitry Monakhov .proc_handler = do_proc_dqstats, 2863884d179dSJan Kara }, 2864884d179dSJan Kara { 2865884d179dSJan Kara .procname = "cache_hits", 2866dde95888SDmitry Monakhov .data = &dqstats.stat[DQST_CACHE_HITS], 2867884d179dSJan Kara .maxlen = sizeof(int), 2868884d179dSJan Kara .mode = 0444, 2869dde95888SDmitry Monakhov .proc_handler = do_proc_dqstats, 2870884d179dSJan Kara }, 2871884d179dSJan Kara { 2872884d179dSJan Kara .procname = "allocated_dquots", 2873dde95888SDmitry Monakhov .data = &dqstats.stat[DQST_ALLOC_DQUOTS], 2874884d179dSJan Kara .maxlen = sizeof(int), 2875884d179dSJan Kara .mode = 0444, 2876dde95888SDmitry Monakhov .proc_handler = do_proc_dqstats, 2877884d179dSJan Kara }, 2878884d179dSJan Kara { 2879884d179dSJan Kara .procname = "free_dquots", 2880dde95888SDmitry Monakhov .data = &dqstats.stat[DQST_FREE_DQUOTS], 2881884d179dSJan Kara .maxlen = sizeof(int), 2882884d179dSJan Kara .mode = 0444, 2883dde95888SDmitry Monakhov .proc_handler = do_proc_dqstats, 2884884d179dSJan Kara }, 2885884d179dSJan Kara { 2886884d179dSJan Kara .procname = "syncs", 2887dde95888SDmitry Monakhov .data = &dqstats.stat[DQST_SYNCS], 2888884d179dSJan Kara .maxlen = sizeof(int), 2889884d179dSJan Kara .mode = 0444, 2890dde95888SDmitry Monakhov .proc_handler = do_proc_dqstats, 2891884d179dSJan Kara }, 2892884d179dSJan Kara #ifdef CONFIG_PRINT_QUOTA_WARNING 2893884d179dSJan Kara { 2894884d179dSJan Kara .procname = "warnings", 2895884d179dSJan Kara .data = &flag_print_warnings, 2896884d179dSJan Kara .maxlen = sizeof(int), 2897884d179dSJan Kara .mode = 0644, 28986d456111SEric W. Biederman .proc_handler = proc_dointvec, 2899884d179dSJan Kara }, 2900884d179dSJan Kara #endif 2901ab09203eSEric W. Biederman { }, 2902884d179dSJan Kara }; 2903884d179dSJan Kara 2904e628753bSJoe Perches static struct ctl_table fs_table[] = { 2905884d179dSJan Kara { 2906884d179dSJan Kara .procname = "quota", 2907884d179dSJan Kara .mode = 0555, 2908884d179dSJan Kara .child = fs_dqstats_table, 2909884d179dSJan Kara }, 2910ab09203eSEric W. Biederman { }, 2911884d179dSJan Kara }; 2912884d179dSJan Kara 2913e628753bSJoe Perches static struct ctl_table sys_table[] = { 2914884d179dSJan Kara { 2915884d179dSJan Kara .procname = "fs", 2916884d179dSJan Kara .mode = 0555, 2917884d179dSJan Kara .child = fs_table, 2918884d179dSJan Kara }, 2919ab09203eSEric W. Biederman { }, 2920884d179dSJan Kara }; 2921884d179dSJan Kara 2922884d179dSJan Kara static int __init dquot_init(void) 2923884d179dSJan Kara { 2924f32764bdSDmitry Monakhov int i, ret; 2925884d179dSJan Kara unsigned long nr_hash, order; 2926884d179dSJan Kara 2927884d179dSJan Kara printk(KERN_NOTICE "VFS: Disk quotas %s\n", __DQUOT_VERSION__); 2928884d179dSJan Kara 2929884d179dSJan Kara register_sysctl_table(sys_table); 2930884d179dSJan Kara 2931884d179dSJan Kara dquot_cachep = kmem_cache_create("dquot", 2932884d179dSJan Kara sizeof(struct dquot), sizeof(unsigned long) * 4, 2933884d179dSJan Kara (SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT| 2934884d179dSJan Kara SLAB_MEM_SPREAD|SLAB_PANIC), 2935884d179dSJan Kara NULL); 2936884d179dSJan Kara 2937884d179dSJan Kara order = 0; 2938884d179dSJan Kara dquot_hash = (struct hlist_head *)__get_free_pages(GFP_ATOMIC, order); 2939884d179dSJan Kara if (!dquot_hash) 2940884d179dSJan Kara panic("Cannot create dquot hash table"); 2941884d179dSJan Kara 2942f32764bdSDmitry Monakhov for (i = 0; i < _DQST_DQSTAT_LAST; i++) { 2943908c7f19STejun Heo ret = percpu_counter_init(&dqstats.counter[i], 0, GFP_KERNEL); 2944f32764bdSDmitry Monakhov if (ret) 2945f32764bdSDmitry Monakhov panic("Cannot create dquot stat counters"); 2946f32764bdSDmitry Monakhov } 2947dde95888SDmitry Monakhov 2948884d179dSJan Kara /* Find power-of-two hlist_heads which can fit into allocation */ 2949884d179dSJan Kara nr_hash = (1UL << order) * PAGE_SIZE / sizeof(struct hlist_head); 2950884d179dSJan Kara dq_hash_bits = 0; 2951884d179dSJan Kara do { 2952884d179dSJan Kara dq_hash_bits++; 2953884d179dSJan Kara } while (nr_hash >> dq_hash_bits); 2954884d179dSJan Kara dq_hash_bits--; 2955884d179dSJan Kara 2956884d179dSJan Kara nr_hash = 1UL << dq_hash_bits; 2957884d179dSJan Kara dq_hash_mask = nr_hash - 1; 2958884d179dSJan Kara for (i = 0; i < nr_hash; i++) 2959884d179dSJan Kara INIT_HLIST_HEAD(dquot_hash + i); 2960884d179dSJan Kara 296119858e7bSAnton Blanchard pr_info("VFS: Dquot-cache hash table entries: %ld (order %ld," 296219858e7bSAnton Blanchard " %ld bytes)\n", nr_hash, order, (PAGE_SIZE << order)); 2963884d179dSJan Kara 2964884d179dSJan Kara register_shrinker(&dqcache_shrinker); 2965884d179dSJan Kara 2966884d179dSJan Kara return 0; 2967884d179dSJan Kara } 2968331221faSPaul Gortmaker fs_initcall(dquot_init); 2969