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> 74884d179dSJan Kara #include <linux/kmod.h> 75884d179dSJan Kara #include <linux/namei.h> 76884d179dSJan Kara #include <linux/buffer_head.h> 77884d179dSJan Kara #include <linux/capability.h> 78884d179dSJan Kara #include <linux/quotaops.h> 79884d179dSJan Kara #include <linux/writeback.h> /* for inode_lock, oddly enough.. */ 80884d179dSJan Kara 81884d179dSJan Kara #include <asm/uaccess.h> 82884d179dSJan Kara 83884d179dSJan Kara /* 84884d179dSJan Kara * There are three quota SMP locks. dq_list_lock protects all lists with quotas 85dde95888SDmitry Monakhov * and quota formats. 86884d179dSJan Kara * dq_data_lock protects data from dq_dqb and also mem_dqinfo structures and 87884d179dSJan Kara * also guards consistency of dquot->dq_dqb with inode->i_blocks, i_bytes. 88884d179dSJan Kara * i_blocks and i_bytes updates itself are guarded by i_lock acquired directly 89884d179dSJan Kara * in inode_add_bytes() and inode_sub_bytes(). dq_state_lock protects 90884d179dSJan Kara * modifications of quota state (on quotaon and quotaoff) and readers who care 91884d179dSJan Kara * about latest values take it as well. 92884d179dSJan Kara * 93884d179dSJan Kara * The spinlock ordering is hence: dq_data_lock > dq_list_lock > i_lock, 94884d179dSJan Kara * dq_list_lock > dq_state_lock 95884d179dSJan Kara * 96884d179dSJan Kara * Note that some things (eg. sb pointer, type, id) doesn't change during 97884d179dSJan Kara * the life of the dquot structure and so needn't to be protected by a lock 98884d179dSJan Kara * 99884d179dSJan Kara * Any operation working on dquots via inode pointers must hold dqptr_sem. If 100884d179dSJan Kara * operation is just reading pointers from inode (or not using them at all) the 10126245c94SJan Kara * read lock is enough. If pointers are altered function must hold write lock. 10226245c94SJan Kara * Special care needs to be taken about S_NOQUOTA inode flag (marking that 10326245c94SJan Kara * inode is a quota file). Functions adding pointers from inode to dquots have 10426245c94SJan Kara * to check this flag under dqptr_sem and then (if S_NOQUOTA is not set) they 10526245c94SJan Kara * have to do all pointer modifications before dropping dqptr_sem. This makes 10626245c94SJan Kara * sure they cannot race with quotaon which first sets S_NOQUOTA flag and 10726245c94SJan Kara * then drops all pointers to dquots from an inode. 108884d179dSJan Kara * 109884d179dSJan Kara * Each dquot has its dq_lock mutex. Locked dquots might not be referenced 110884d179dSJan Kara * from inodes (dquot_alloc_space() and such don't check the dq_lock). 111884d179dSJan Kara * Currently dquot is locked only when it is being read to memory (or space for 112884d179dSJan Kara * it is being allocated) on the first dqget() and when it is being released on 113884d179dSJan Kara * the last dqput(). The allocation and release oparations are serialized by 114884d179dSJan Kara * the dq_lock and by checking the use count in dquot_release(). Write 115884d179dSJan Kara * operations on dquots don't hold dq_lock as they copy data under dq_data_lock 116884d179dSJan Kara * spinlock to internal buffers before writing. 117884d179dSJan Kara * 118884d179dSJan Kara * Lock ordering (including related VFS locks) is the following: 119884d179dSJan Kara * i_mutex > dqonoff_sem > journal_lock > dqptr_sem > dquot->dq_lock > 120884d179dSJan Kara * dqio_mutex 121884d179dSJan Kara * The lock ordering of dqptr_sem imposed by quota code is only dqonoff_sem > 122884d179dSJan Kara * dqptr_sem. But filesystem has to count with the fact that functions such as 123884d179dSJan Kara * dquot_alloc_space() acquire dqptr_sem and they usually have to be called 124884d179dSJan Kara * from inside a transaction to keep filesystem consistency after a crash. Also 125884d179dSJan Kara * filesystems usually want to do some IO on dquot from ->mark_dirty which is 126884d179dSJan Kara * called with dqptr_sem held. 127884d179dSJan Kara * i_mutex on quota files is special (it's below dqio_mutex) 128884d179dSJan Kara */ 129884d179dSJan Kara 130c516610cSJan Kara static __cacheline_aligned_in_smp DEFINE_SPINLOCK(dq_list_lock); 131c516610cSJan Kara static __cacheline_aligned_in_smp DEFINE_SPINLOCK(dq_state_lock); 132c516610cSJan Kara __cacheline_aligned_in_smp DEFINE_SPINLOCK(dq_data_lock); 133884d179dSJan Kara EXPORT_SYMBOL(dq_data_lock); 134884d179dSJan Kara 135fb5ffb0eSJiaying Zhang void __quota_error(struct super_block *sb, const char *func, 136fb5ffb0eSJiaying Zhang const char *fmt, ...) 137fb5ffb0eSJiaying Zhang { 138fb5ffb0eSJiaying Zhang va_list args; 139fb5ffb0eSJiaying Zhang 140fb5ffb0eSJiaying Zhang if (printk_ratelimit()) { 141fb5ffb0eSJiaying Zhang va_start(args, fmt); 142fb5ffb0eSJiaying Zhang printk(KERN_ERR "Quota error (device %s): %s: ", 143fb5ffb0eSJiaying Zhang sb->s_id, func); 144fb5ffb0eSJiaying Zhang vprintk(fmt, args); 145fb5ffb0eSJiaying Zhang printk("\n"); 146fb5ffb0eSJiaying Zhang va_end(args); 147fb5ffb0eSJiaying Zhang } 148fb5ffb0eSJiaying Zhang } 149fb5ffb0eSJiaying Zhang EXPORT_SYMBOL(__quota_error); 150fb5ffb0eSJiaying Zhang 151da8d1ba2SSergey Senozhatsky #if defined(CONFIG_QUOTA_DEBUG) || defined(CONFIG_PRINT_QUOTA_WARNING) 152884d179dSJan Kara static char *quotatypes[] = INITQFNAMES; 153da8d1ba2SSergey Senozhatsky #endif 154884d179dSJan Kara static struct quota_format_type *quota_formats; /* List of registered formats */ 155884d179dSJan Kara static struct quota_module_name module_names[] = INIT_QUOTA_MODULE_NAMES; 156884d179dSJan Kara 157884d179dSJan Kara /* SLAB cache for dquot structures */ 158884d179dSJan Kara static struct kmem_cache *dquot_cachep; 159884d179dSJan Kara 160884d179dSJan Kara int register_quota_format(struct quota_format_type *fmt) 161884d179dSJan Kara { 162884d179dSJan Kara spin_lock(&dq_list_lock); 163884d179dSJan Kara fmt->qf_next = quota_formats; 164884d179dSJan Kara quota_formats = fmt; 165884d179dSJan Kara spin_unlock(&dq_list_lock); 166884d179dSJan Kara return 0; 167884d179dSJan Kara } 168884d179dSJan Kara EXPORT_SYMBOL(register_quota_format); 169884d179dSJan Kara 170884d179dSJan Kara void unregister_quota_format(struct quota_format_type *fmt) 171884d179dSJan Kara { 172884d179dSJan Kara struct quota_format_type **actqf; 173884d179dSJan Kara 174884d179dSJan Kara spin_lock(&dq_list_lock); 175268157baSJan Kara for (actqf = "a_formats; *actqf && *actqf != fmt; 176268157baSJan Kara actqf = &(*actqf)->qf_next) 177268157baSJan Kara ; 178884d179dSJan Kara if (*actqf) 179884d179dSJan Kara *actqf = (*actqf)->qf_next; 180884d179dSJan Kara spin_unlock(&dq_list_lock); 181884d179dSJan Kara } 182884d179dSJan Kara EXPORT_SYMBOL(unregister_quota_format); 183884d179dSJan Kara 184884d179dSJan Kara static struct quota_format_type *find_quota_format(int id) 185884d179dSJan Kara { 186884d179dSJan Kara struct quota_format_type *actqf; 187884d179dSJan Kara 188884d179dSJan Kara spin_lock(&dq_list_lock); 189268157baSJan Kara for (actqf = quota_formats; actqf && actqf->qf_fmt_id != id; 190268157baSJan Kara actqf = actqf->qf_next) 191268157baSJan Kara ; 192884d179dSJan Kara if (!actqf || !try_module_get(actqf->qf_owner)) { 193884d179dSJan Kara int qm; 194884d179dSJan Kara 195884d179dSJan Kara spin_unlock(&dq_list_lock); 196884d179dSJan Kara 197268157baSJan Kara for (qm = 0; module_names[qm].qm_fmt_id && 198268157baSJan Kara module_names[qm].qm_fmt_id != id; qm++) 199268157baSJan Kara ; 200268157baSJan Kara if (!module_names[qm].qm_fmt_id || 201268157baSJan Kara request_module(module_names[qm].qm_mod_name)) 202884d179dSJan Kara return NULL; 203884d179dSJan Kara 204884d179dSJan Kara spin_lock(&dq_list_lock); 205268157baSJan Kara for (actqf = quota_formats; actqf && actqf->qf_fmt_id != id; 206268157baSJan Kara actqf = actqf->qf_next) 207268157baSJan Kara ; 208884d179dSJan Kara if (actqf && !try_module_get(actqf->qf_owner)) 209884d179dSJan Kara actqf = NULL; 210884d179dSJan Kara } 211884d179dSJan Kara spin_unlock(&dq_list_lock); 212884d179dSJan Kara return actqf; 213884d179dSJan Kara } 214884d179dSJan Kara 215884d179dSJan Kara static void put_quota_format(struct quota_format_type *fmt) 216884d179dSJan Kara { 217884d179dSJan Kara module_put(fmt->qf_owner); 218884d179dSJan Kara } 219884d179dSJan Kara 220884d179dSJan Kara /* 221884d179dSJan Kara * Dquot List Management: 222884d179dSJan Kara * The quota code uses three lists for dquot management: the inuse_list, 223884d179dSJan Kara * free_dquots, and dquot_hash[] array. A single dquot structure may be 224884d179dSJan Kara * on all three lists, depending on its current state. 225884d179dSJan Kara * 226884d179dSJan Kara * All dquots are placed to the end of inuse_list when first created, and this 227884d179dSJan Kara * list is used for invalidate operation, which must look at every dquot. 228884d179dSJan Kara * 229884d179dSJan Kara * Unused dquots (dq_count == 0) are added to the free_dquots list when freed, 230884d179dSJan Kara * and this list is searched whenever we need an available dquot. Dquots are 231884d179dSJan Kara * removed from the list as soon as they are used again, and 232884d179dSJan Kara * dqstats.free_dquots gives the number of dquots on the list. When 233884d179dSJan Kara * dquot is invalidated it's completely released from memory. 234884d179dSJan Kara * 235884d179dSJan Kara * Dquots with a specific identity (device, type and id) are placed on 236884d179dSJan Kara * one of the dquot_hash[] hash chains. The provides an efficient search 237884d179dSJan Kara * mechanism to locate a specific dquot. 238884d179dSJan Kara */ 239884d179dSJan Kara 240884d179dSJan Kara static LIST_HEAD(inuse_list); 241884d179dSJan Kara static LIST_HEAD(free_dquots); 242884d179dSJan Kara static unsigned int dq_hash_bits, dq_hash_mask; 243884d179dSJan Kara static struct hlist_head *dquot_hash; 244884d179dSJan Kara 245884d179dSJan Kara struct dqstats dqstats; 246884d179dSJan Kara EXPORT_SYMBOL(dqstats); 247884d179dSJan Kara 2480a5a9c72SJan Kara static qsize_t inode_get_rsv_space(struct inode *inode); 249871a2931SChristoph Hellwig static void __dquot_initialize(struct inode *inode, int type); 2500a5a9c72SJan Kara 251884d179dSJan Kara static inline unsigned int 252884d179dSJan Kara hashfn(const struct super_block *sb, unsigned int id, int type) 253884d179dSJan Kara { 254884d179dSJan Kara unsigned long tmp; 255884d179dSJan Kara 256884d179dSJan Kara tmp = (((unsigned long)sb>>L1_CACHE_SHIFT) ^ id) * (MAXQUOTAS - type); 257884d179dSJan Kara return (tmp + (tmp >> dq_hash_bits)) & dq_hash_mask; 258884d179dSJan Kara } 259884d179dSJan Kara 260884d179dSJan Kara /* 261884d179dSJan Kara * Following list functions expect dq_list_lock to be held 262884d179dSJan Kara */ 263884d179dSJan Kara static inline void insert_dquot_hash(struct dquot *dquot) 264884d179dSJan Kara { 265268157baSJan Kara struct hlist_head *head; 266268157baSJan Kara head = dquot_hash + hashfn(dquot->dq_sb, dquot->dq_id, dquot->dq_type); 267884d179dSJan Kara hlist_add_head(&dquot->dq_hash, head); 268884d179dSJan Kara } 269884d179dSJan Kara 270884d179dSJan Kara static inline void remove_dquot_hash(struct dquot *dquot) 271884d179dSJan Kara { 272884d179dSJan Kara hlist_del_init(&dquot->dq_hash); 273884d179dSJan Kara } 274884d179dSJan Kara 2757a2435d8SJan Kara static struct dquot *find_dquot(unsigned int hashent, struct super_block *sb, 2767a2435d8SJan Kara unsigned int id, int type) 277884d179dSJan Kara { 278884d179dSJan Kara struct hlist_node *node; 279884d179dSJan Kara struct dquot *dquot; 280884d179dSJan Kara 281884d179dSJan Kara hlist_for_each (node, dquot_hash+hashent) { 282884d179dSJan Kara dquot = hlist_entry(node, struct dquot, dq_hash); 283268157baSJan Kara if (dquot->dq_sb == sb && dquot->dq_id == id && 284268157baSJan Kara dquot->dq_type == type) 285884d179dSJan Kara return dquot; 286884d179dSJan Kara } 287dd6f3c6dSJan Kara return NULL; 288884d179dSJan Kara } 289884d179dSJan Kara 290884d179dSJan Kara /* Add a dquot to the tail of the free list */ 291884d179dSJan Kara static inline void put_dquot_last(struct dquot *dquot) 292884d179dSJan Kara { 293884d179dSJan Kara list_add_tail(&dquot->dq_free, &free_dquots); 294dde95888SDmitry Monakhov dqstats_inc(DQST_FREE_DQUOTS); 295884d179dSJan Kara } 296884d179dSJan Kara 297884d179dSJan Kara static inline void remove_free_dquot(struct dquot *dquot) 298884d179dSJan Kara { 299884d179dSJan Kara if (list_empty(&dquot->dq_free)) 300884d179dSJan Kara return; 301884d179dSJan Kara list_del_init(&dquot->dq_free); 302dde95888SDmitry Monakhov dqstats_dec(DQST_FREE_DQUOTS); 303884d179dSJan Kara } 304884d179dSJan Kara 305884d179dSJan Kara static inline void put_inuse(struct dquot *dquot) 306884d179dSJan Kara { 307884d179dSJan Kara /* We add to the back of inuse list so we don't have to restart 308884d179dSJan Kara * when traversing this list and we block */ 309884d179dSJan Kara list_add_tail(&dquot->dq_inuse, &inuse_list); 310dde95888SDmitry Monakhov dqstats_inc(DQST_ALLOC_DQUOTS); 311884d179dSJan Kara } 312884d179dSJan Kara 313884d179dSJan Kara static inline void remove_inuse(struct dquot *dquot) 314884d179dSJan Kara { 315dde95888SDmitry Monakhov dqstats_dec(DQST_ALLOC_DQUOTS); 316884d179dSJan Kara list_del(&dquot->dq_inuse); 317884d179dSJan Kara } 318884d179dSJan Kara /* 319884d179dSJan Kara * End of list functions needing dq_list_lock 320884d179dSJan Kara */ 321884d179dSJan Kara 322884d179dSJan Kara static void wait_on_dquot(struct dquot *dquot) 323884d179dSJan Kara { 324884d179dSJan Kara mutex_lock(&dquot->dq_lock); 325884d179dSJan Kara mutex_unlock(&dquot->dq_lock); 326884d179dSJan Kara } 327884d179dSJan Kara 328884d179dSJan Kara static inline int dquot_dirty(struct dquot *dquot) 329884d179dSJan Kara { 330884d179dSJan Kara return test_bit(DQ_MOD_B, &dquot->dq_flags); 331884d179dSJan Kara } 332884d179dSJan Kara 333884d179dSJan Kara static inline int mark_dquot_dirty(struct dquot *dquot) 334884d179dSJan Kara { 335884d179dSJan Kara return dquot->dq_sb->dq_op->mark_dirty(dquot); 336884d179dSJan Kara } 337884d179dSJan Kara 338eabf290dSDmitry Monakhov /* Mark dquot dirty in atomic manner, and return it's old dirty flag state */ 339884d179dSJan Kara int dquot_mark_dquot_dirty(struct dquot *dquot) 340884d179dSJan Kara { 341eabf290dSDmitry Monakhov int ret = 1; 342eabf290dSDmitry Monakhov 343eabf290dSDmitry Monakhov /* If quota is dirty already, we don't have to acquire dq_list_lock */ 344eabf290dSDmitry Monakhov if (test_bit(DQ_MOD_B, &dquot->dq_flags)) 345eabf290dSDmitry Monakhov return 1; 346eabf290dSDmitry Monakhov 347884d179dSJan Kara spin_lock(&dq_list_lock); 348eabf290dSDmitry Monakhov if (!test_and_set_bit(DQ_MOD_B, &dquot->dq_flags)) { 349884d179dSJan Kara list_add(&dquot->dq_dirty, &sb_dqopt(dquot->dq_sb)-> 350884d179dSJan Kara info[dquot->dq_type].dqi_dirty_list); 351eabf290dSDmitry Monakhov ret = 0; 352eabf290dSDmitry Monakhov } 353884d179dSJan Kara spin_unlock(&dq_list_lock); 354eabf290dSDmitry Monakhov return ret; 355884d179dSJan Kara } 356884d179dSJan Kara EXPORT_SYMBOL(dquot_mark_dquot_dirty); 357884d179dSJan Kara 358dc52dd3aSDmitry Monakhov /* Dirtify all the dquots - this can block when journalling */ 359dc52dd3aSDmitry Monakhov static inline int mark_all_dquot_dirty(struct dquot * const *dquot) 360dc52dd3aSDmitry Monakhov { 361dc52dd3aSDmitry Monakhov int ret, err, cnt; 362dc52dd3aSDmitry Monakhov 363dc52dd3aSDmitry Monakhov ret = err = 0; 364dc52dd3aSDmitry Monakhov for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 365dc52dd3aSDmitry Monakhov if (dquot[cnt]) 366dc52dd3aSDmitry Monakhov /* Even in case of error we have to continue */ 367dc52dd3aSDmitry Monakhov ret = mark_dquot_dirty(dquot[cnt]); 368dc52dd3aSDmitry Monakhov if (!err) 369dc52dd3aSDmitry Monakhov err = ret; 370dc52dd3aSDmitry Monakhov } 371dc52dd3aSDmitry Monakhov return err; 372dc52dd3aSDmitry Monakhov } 373dc52dd3aSDmitry Monakhov 374dc52dd3aSDmitry Monakhov static inline void dqput_all(struct dquot **dquot) 375dc52dd3aSDmitry Monakhov { 376dc52dd3aSDmitry Monakhov unsigned int cnt; 377dc52dd3aSDmitry Monakhov 378dc52dd3aSDmitry Monakhov for (cnt = 0; cnt < MAXQUOTAS; cnt++) 379dc52dd3aSDmitry Monakhov dqput(dquot[cnt]); 380dc52dd3aSDmitry Monakhov } 381dc52dd3aSDmitry Monakhov 382884d179dSJan Kara /* This function needs dq_list_lock */ 383884d179dSJan Kara static inline int clear_dquot_dirty(struct dquot *dquot) 384884d179dSJan Kara { 385884d179dSJan Kara if (!test_and_clear_bit(DQ_MOD_B, &dquot->dq_flags)) 386884d179dSJan Kara return 0; 387884d179dSJan Kara list_del_init(&dquot->dq_dirty); 388884d179dSJan Kara return 1; 389884d179dSJan Kara } 390884d179dSJan Kara 391884d179dSJan Kara void mark_info_dirty(struct super_block *sb, int type) 392884d179dSJan Kara { 393884d179dSJan Kara set_bit(DQF_INFO_DIRTY_B, &sb_dqopt(sb)->info[type].dqi_flags); 394884d179dSJan Kara } 395884d179dSJan Kara EXPORT_SYMBOL(mark_info_dirty); 396884d179dSJan Kara 397884d179dSJan Kara /* 398884d179dSJan Kara * Read dquot from disk and alloc space for it 399884d179dSJan Kara */ 400884d179dSJan Kara 401884d179dSJan Kara int dquot_acquire(struct dquot *dquot) 402884d179dSJan Kara { 403884d179dSJan Kara int ret = 0, ret2 = 0; 404884d179dSJan Kara struct quota_info *dqopt = sb_dqopt(dquot->dq_sb); 405884d179dSJan Kara 406884d179dSJan Kara mutex_lock(&dquot->dq_lock); 407884d179dSJan Kara mutex_lock(&dqopt->dqio_mutex); 408884d179dSJan Kara if (!test_bit(DQ_READ_B, &dquot->dq_flags)) 409884d179dSJan Kara ret = dqopt->ops[dquot->dq_type]->read_dqblk(dquot); 410884d179dSJan Kara if (ret < 0) 411884d179dSJan Kara goto out_iolock; 412884d179dSJan Kara set_bit(DQ_READ_B, &dquot->dq_flags); 413884d179dSJan Kara /* Instantiate dquot if needed */ 414884d179dSJan Kara if (!test_bit(DQ_ACTIVE_B, &dquot->dq_flags) && !dquot->dq_off) { 415884d179dSJan Kara ret = dqopt->ops[dquot->dq_type]->commit_dqblk(dquot); 416884d179dSJan Kara /* Write the info if needed */ 417268157baSJan Kara if (info_dirty(&dqopt->info[dquot->dq_type])) { 418268157baSJan Kara ret2 = dqopt->ops[dquot->dq_type]->write_file_info( 419268157baSJan Kara dquot->dq_sb, dquot->dq_type); 420268157baSJan Kara } 421884d179dSJan Kara if (ret < 0) 422884d179dSJan Kara goto out_iolock; 423884d179dSJan Kara if (ret2 < 0) { 424884d179dSJan Kara ret = ret2; 425884d179dSJan Kara goto out_iolock; 426884d179dSJan Kara } 427884d179dSJan Kara } 428884d179dSJan Kara set_bit(DQ_ACTIVE_B, &dquot->dq_flags); 429884d179dSJan Kara out_iolock: 430884d179dSJan Kara mutex_unlock(&dqopt->dqio_mutex); 431884d179dSJan Kara mutex_unlock(&dquot->dq_lock); 432884d179dSJan Kara return ret; 433884d179dSJan Kara } 434884d179dSJan Kara EXPORT_SYMBOL(dquot_acquire); 435884d179dSJan Kara 436884d179dSJan Kara /* 437884d179dSJan Kara * Write dquot to disk 438884d179dSJan Kara */ 439884d179dSJan Kara int dquot_commit(struct dquot *dquot) 440884d179dSJan Kara { 441884d179dSJan Kara int ret = 0, ret2 = 0; 442884d179dSJan Kara struct quota_info *dqopt = sb_dqopt(dquot->dq_sb); 443884d179dSJan Kara 444884d179dSJan Kara mutex_lock(&dqopt->dqio_mutex); 445884d179dSJan Kara spin_lock(&dq_list_lock); 446884d179dSJan Kara if (!clear_dquot_dirty(dquot)) { 447884d179dSJan Kara spin_unlock(&dq_list_lock); 448884d179dSJan Kara goto out_sem; 449884d179dSJan Kara } 450884d179dSJan Kara spin_unlock(&dq_list_lock); 451884d179dSJan Kara /* Inactive dquot can be only if there was error during read/init 452884d179dSJan Kara * => we have better not writing it */ 453884d179dSJan Kara if (test_bit(DQ_ACTIVE_B, &dquot->dq_flags)) { 454884d179dSJan Kara ret = dqopt->ops[dquot->dq_type]->commit_dqblk(dquot); 455268157baSJan Kara if (info_dirty(&dqopt->info[dquot->dq_type])) { 456268157baSJan Kara ret2 = dqopt->ops[dquot->dq_type]->write_file_info( 457268157baSJan Kara dquot->dq_sb, dquot->dq_type); 458268157baSJan Kara } 459884d179dSJan Kara if (ret >= 0) 460884d179dSJan Kara ret = ret2; 461884d179dSJan Kara } 462884d179dSJan Kara out_sem: 463884d179dSJan Kara mutex_unlock(&dqopt->dqio_mutex); 464884d179dSJan Kara return ret; 465884d179dSJan Kara } 466884d179dSJan Kara EXPORT_SYMBOL(dquot_commit); 467884d179dSJan Kara 468884d179dSJan Kara /* 469884d179dSJan Kara * Release dquot 470884d179dSJan Kara */ 471884d179dSJan Kara int dquot_release(struct dquot *dquot) 472884d179dSJan Kara { 473884d179dSJan Kara int ret = 0, ret2 = 0; 474884d179dSJan Kara struct quota_info *dqopt = sb_dqopt(dquot->dq_sb); 475884d179dSJan Kara 476884d179dSJan Kara mutex_lock(&dquot->dq_lock); 477884d179dSJan Kara /* Check whether we are not racing with some other dqget() */ 478884d179dSJan Kara if (atomic_read(&dquot->dq_count) > 1) 479884d179dSJan Kara goto out_dqlock; 480884d179dSJan Kara mutex_lock(&dqopt->dqio_mutex); 481884d179dSJan Kara if (dqopt->ops[dquot->dq_type]->release_dqblk) { 482884d179dSJan Kara ret = dqopt->ops[dquot->dq_type]->release_dqblk(dquot); 483884d179dSJan Kara /* Write the info */ 484268157baSJan Kara if (info_dirty(&dqopt->info[dquot->dq_type])) { 485268157baSJan Kara ret2 = dqopt->ops[dquot->dq_type]->write_file_info( 486268157baSJan Kara dquot->dq_sb, dquot->dq_type); 487268157baSJan Kara } 488884d179dSJan Kara if (ret >= 0) 489884d179dSJan Kara ret = ret2; 490884d179dSJan Kara } 491884d179dSJan Kara clear_bit(DQ_ACTIVE_B, &dquot->dq_flags); 492884d179dSJan Kara mutex_unlock(&dqopt->dqio_mutex); 493884d179dSJan Kara out_dqlock: 494884d179dSJan Kara mutex_unlock(&dquot->dq_lock); 495884d179dSJan Kara return ret; 496884d179dSJan Kara } 497884d179dSJan Kara EXPORT_SYMBOL(dquot_release); 498884d179dSJan Kara 499884d179dSJan Kara void dquot_destroy(struct dquot *dquot) 500884d179dSJan Kara { 501884d179dSJan Kara kmem_cache_free(dquot_cachep, dquot); 502884d179dSJan Kara } 503884d179dSJan Kara EXPORT_SYMBOL(dquot_destroy); 504884d179dSJan Kara 505884d179dSJan Kara static inline void do_destroy_dquot(struct dquot *dquot) 506884d179dSJan Kara { 507884d179dSJan Kara dquot->dq_sb->dq_op->destroy_dquot(dquot); 508884d179dSJan Kara } 509884d179dSJan Kara 510884d179dSJan Kara /* Invalidate all dquots on the list. Note that this function is called after 511884d179dSJan Kara * quota is disabled and pointers from inodes removed so there cannot be new 512884d179dSJan Kara * quota users. There can still be some users of quotas due to inodes being 513884d179dSJan Kara * just deleted or pruned by prune_icache() (those are not attached to any 514884d179dSJan Kara * list) or parallel quotactl call. We have to wait for such users. 515884d179dSJan Kara */ 516884d179dSJan Kara static void invalidate_dquots(struct super_block *sb, int type) 517884d179dSJan Kara { 518884d179dSJan Kara struct dquot *dquot, *tmp; 519884d179dSJan Kara 520884d179dSJan Kara restart: 521884d179dSJan Kara spin_lock(&dq_list_lock); 522884d179dSJan Kara list_for_each_entry_safe(dquot, tmp, &inuse_list, dq_inuse) { 523884d179dSJan Kara if (dquot->dq_sb != sb) 524884d179dSJan Kara continue; 525884d179dSJan Kara if (dquot->dq_type != type) 526884d179dSJan Kara continue; 527884d179dSJan Kara /* Wait for dquot users */ 528884d179dSJan Kara if (atomic_read(&dquot->dq_count)) { 529884d179dSJan Kara DEFINE_WAIT(wait); 530884d179dSJan Kara 531884d179dSJan Kara atomic_inc(&dquot->dq_count); 532884d179dSJan Kara prepare_to_wait(&dquot->dq_wait_unused, &wait, 533884d179dSJan Kara TASK_UNINTERRUPTIBLE); 534884d179dSJan Kara spin_unlock(&dq_list_lock); 535884d179dSJan Kara /* Once dqput() wakes us up, we know it's time to free 536884d179dSJan Kara * the dquot. 537884d179dSJan Kara * IMPORTANT: we rely on the fact that there is always 538884d179dSJan Kara * at most one process waiting for dquot to free. 539884d179dSJan Kara * Otherwise dq_count would be > 1 and we would never 540884d179dSJan Kara * wake up. 541884d179dSJan Kara */ 542884d179dSJan Kara if (atomic_read(&dquot->dq_count) > 1) 543884d179dSJan Kara schedule(); 544884d179dSJan Kara finish_wait(&dquot->dq_wait_unused, &wait); 545884d179dSJan Kara dqput(dquot); 546884d179dSJan Kara /* At this moment dquot() need not exist (it could be 547884d179dSJan Kara * reclaimed by prune_dqcache(). Hence we must 548884d179dSJan Kara * restart. */ 549884d179dSJan Kara goto restart; 550884d179dSJan Kara } 551884d179dSJan Kara /* 552884d179dSJan Kara * Quota now has no users and it has been written on last 553884d179dSJan Kara * dqput() 554884d179dSJan Kara */ 555884d179dSJan Kara remove_dquot_hash(dquot); 556884d179dSJan Kara remove_free_dquot(dquot); 557884d179dSJan Kara remove_inuse(dquot); 558884d179dSJan Kara do_destroy_dquot(dquot); 559884d179dSJan Kara } 560884d179dSJan Kara spin_unlock(&dq_list_lock); 561884d179dSJan Kara } 562884d179dSJan Kara 563884d179dSJan Kara /* Call callback for every active dquot on given filesystem */ 564884d179dSJan Kara int dquot_scan_active(struct super_block *sb, 565884d179dSJan Kara int (*fn)(struct dquot *dquot, unsigned long priv), 566884d179dSJan Kara unsigned long priv) 567884d179dSJan Kara { 568884d179dSJan Kara struct dquot *dquot, *old_dquot = NULL; 569884d179dSJan Kara int ret = 0; 570884d179dSJan Kara 571884d179dSJan Kara mutex_lock(&sb_dqopt(sb)->dqonoff_mutex); 572884d179dSJan Kara spin_lock(&dq_list_lock); 573884d179dSJan Kara list_for_each_entry(dquot, &inuse_list, dq_inuse) { 574884d179dSJan Kara if (!test_bit(DQ_ACTIVE_B, &dquot->dq_flags)) 575884d179dSJan Kara continue; 576884d179dSJan Kara if (dquot->dq_sb != sb) 577884d179dSJan Kara continue; 578884d179dSJan Kara /* Now we have active dquot so we can just increase use count */ 579884d179dSJan Kara atomic_inc(&dquot->dq_count); 580884d179dSJan Kara spin_unlock(&dq_list_lock); 581dde95888SDmitry Monakhov dqstats_inc(DQST_LOOKUPS); 582884d179dSJan Kara dqput(old_dquot); 583884d179dSJan Kara old_dquot = dquot; 584884d179dSJan Kara ret = fn(dquot, priv); 585884d179dSJan Kara if (ret < 0) 586884d179dSJan Kara goto out; 587884d179dSJan Kara spin_lock(&dq_list_lock); 588884d179dSJan Kara /* We are safe to continue now because our dquot could not 589884d179dSJan Kara * be moved out of the inuse list while we hold the reference */ 590884d179dSJan Kara } 591884d179dSJan Kara spin_unlock(&dq_list_lock); 592884d179dSJan Kara out: 593884d179dSJan Kara dqput(old_dquot); 594884d179dSJan Kara mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex); 595884d179dSJan Kara return ret; 596884d179dSJan Kara } 597884d179dSJan Kara EXPORT_SYMBOL(dquot_scan_active); 598884d179dSJan Kara 599287a8095SChristoph Hellwig int dquot_quota_sync(struct super_block *sb, int type, int wait) 600884d179dSJan Kara { 601884d179dSJan Kara struct list_head *dirty; 602884d179dSJan Kara struct dquot *dquot; 603884d179dSJan Kara struct quota_info *dqopt = sb_dqopt(sb); 604884d179dSJan Kara int cnt; 605884d179dSJan Kara 606884d179dSJan Kara mutex_lock(&dqopt->dqonoff_mutex); 607884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 608884d179dSJan Kara if (type != -1 && cnt != type) 609884d179dSJan Kara continue; 610884d179dSJan Kara if (!sb_has_quota_active(sb, cnt)) 611884d179dSJan Kara continue; 612884d179dSJan Kara spin_lock(&dq_list_lock); 613884d179dSJan Kara dirty = &dqopt->info[cnt].dqi_dirty_list; 614884d179dSJan Kara while (!list_empty(dirty)) { 615268157baSJan Kara dquot = list_first_entry(dirty, struct dquot, 616268157baSJan Kara dq_dirty); 617884d179dSJan Kara /* Dirty and inactive can be only bad dquot... */ 618884d179dSJan Kara if (!test_bit(DQ_ACTIVE_B, &dquot->dq_flags)) { 619884d179dSJan Kara clear_dquot_dirty(dquot); 620884d179dSJan Kara continue; 621884d179dSJan Kara } 622884d179dSJan Kara /* Now we have active dquot from which someone is 623884d179dSJan Kara * holding reference so we can safely just increase 624884d179dSJan Kara * use count */ 625884d179dSJan Kara atomic_inc(&dquot->dq_count); 626884d179dSJan Kara spin_unlock(&dq_list_lock); 627dde95888SDmitry Monakhov dqstats_inc(DQST_LOOKUPS); 628884d179dSJan Kara sb->dq_op->write_dquot(dquot); 629884d179dSJan Kara dqput(dquot); 630884d179dSJan Kara spin_lock(&dq_list_lock); 631884d179dSJan Kara } 632884d179dSJan Kara spin_unlock(&dq_list_lock); 633884d179dSJan Kara } 634884d179dSJan Kara 635884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) 636884d179dSJan Kara if ((cnt == type || type == -1) && sb_has_quota_active(sb, cnt) 637884d179dSJan Kara && info_dirty(&dqopt->info[cnt])) 638884d179dSJan Kara sb->dq_op->write_info(sb, cnt); 639dde95888SDmitry Monakhov dqstats_inc(DQST_SYNCS); 640884d179dSJan Kara mutex_unlock(&dqopt->dqonoff_mutex); 641884d179dSJan Kara 6425fb324adSChristoph Hellwig if (!wait || (sb_dqopt(sb)->flags & DQUOT_QUOTA_SYS_FILE)) 6435fb324adSChristoph Hellwig return 0; 6445fb324adSChristoph Hellwig 6455fb324adSChristoph Hellwig /* This is not very clever (and fast) but currently I don't know about 6465fb324adSChristoph Hellwig * any other simple way of getting quota data to disk and we must get 6475fb324adSChristoph Hellwig * them there for userspace to be visible... */ 6485fb324adSChristoph Hellwig if (sb->s_op->sync_fs) 6495fb324adSChristoph Hellwig sb->s_op->sync_fs(sb, 1); 6505fb324adSChristoph Hellwig sync_blockdev(sb->s_bdev); 6515fb324adSChristoph Hellwig 6525fb324adSChristoph Hellwig /* 6535fb324adSChristoph Hellwig * Now when everything is written we can discard the pagecache so 6545fb324adSChristoph Hellwig * that userspace sees the changes. 6555fb324adSChristoph Hellwig */ 6565fb324adSChristoph Hellwig mutex_lock(&sb_dqopt(sb)->dqonoff_mutex); 6575fb324adSChristoph Hellwig for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 6585fb324adSChristoph Hellwig if (type != -1 && cnt != type) 6595fb324adSChristoph Hellwig continue; 6605fb324adSChristoph Hellwig if (!sb_has_quota_active(sb, cnt)) 6615fb324adSChristoph Hellwig continue; 6625fb324adSChristoph Hellwig mutex_lock_nested(&sb_dqopt(sb)->files[cnt]->i_mutex, 6635fb324adSChristoph Hellwig I_MUTEX_QUOTA); 6645fb324adSChristoph Hellwig truncate_inode_pages(&sb_dqopt(sb)->files[cnt]->i_data, 0); 6655fb324adSChristoph Hellwig mutex_unlock(&sb_dqopt(sb)->files[cnt]->i_mutex); 6665fb324adSChristoph Hellwig } 6675fb324adSChristoph Hellwig mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex); 6685fb324adSChristoph Hellwig 669884d179dSJan Kara return 0; 670884d179dSJan Kara } 671287a8095SChristoph Hellwig EXPORT_SYMBOL(dquot_quota_sync); 672884d179dSJan Kara 673884d179dSJan Kara /* Free unused dquots from cache */ 674884d179dSJan Kara static void prune_dqcache(int count) 675884d179dSJan Kara { 676884d179dSJan Kara struct list_head *head; 677884d179dSJan Kara struct dquot *dquot; 678884d179dSJan Kara 679884d179dSJan Kara head = free_dquots.prev; 680884d179dSJan Kara while (head != &free_dquots && count) { 681884d179dSJan Kara dquot = list_entry(head, struct dquot, dq_free); 682884d179dSJan Kara remove_dquot_hash(dquot); 683884d179dSJan Kara remove_free_dquot(dquot); 684884d179dSJan Kara remove_inuse(dquot); 685884d179dSJan Kara do_destroy_dquot(dquot); 686884d179dSJan Kara count--; 687884d179dSJan Kara head = free_dquots.prev; 688884d179dSJan Kara } 689884d179dSJan Kara } 690884d179dSJan Kara 691884d179dSJan Kara /* 692884d179dSJan Kara * This is called from kswapd when we think we need some 693884d179dSJan Kara * more memory 694884d179dSJan Kara */ 6957f8275d0SDave Chinner static int shrink_dqcache_memory(struct shrinker *shrink, int nr, gfp_t gfp_mask) 696884d179dSJan Kara { 697884d179dSJan Kara if (nr) { 698884d179dSJan Kara spin_lock(&dq_list_lock); 699884d179dSJan Kara prune_dqcache(nr); 700884d179dSJan Kara spin_unlock(&dq_list_lock); 701884d179dSJan Kara } 702f32764bdSDmitry Monakhov return ((unsigned) 703f32764bdSDmitry Monakhov percpu_counter_read_positive(&dqstats.counter[DQST_FREE_DQUOTS]) 704f32764bdSDmitry Monakhov /100) * sysctl_vfs_cache_pressure; 705884d179dSJan Kara } 706884d179dSJan Kara 707884d179dSJan Kara static struct shrinker dqcache_shrinker = { 708884d179dSJan Kara .shrink = shrink_dqcache_memory, 709884d179dSJan Kara .seeks = DEFAULT_SEEKS, 710884d179dSJan Kara }; 711884d179dSJan Kara 712884d179dSJan Kara /* 713884d179dSJan Kara * Put reference to dquot 714884d179dSJan Kara * NOTE: If you change this function please check whether dqput_blocks() works right... 715884d179dSJan Kara */ 716884d179dSJan Kara void dqput(struct dquot *dquot) 717884d179dSJan Kara { 718884d179dSJan Kara int ret; 719884d179dSJan Kara 720884d179dSJan Kara if (!dquot) 721884d179dSJan Kara return; 72262af9b52SJan Kara #ifdef CONFIG_QUOTA_DEBUG 723884d179dSJan Kara if (!atomic_read(&dquot->dq_count)) { 724fb5ffb0eSJiaying Zhang quota_error(dquot->dq_sb, "trying to free free dquot of %s %d", 725fb5ffb0eSJiaying Zhang quotatypes[dquot->dq_type], dquot->dq_id); 726884d179dSJan Kara BUG(); 727884d179dSJan Kara } 728884d179dSJan Kara #endif 729dde95888SDmitry Monakhov dqstats_inc(DQST_DROPS); 730884d179dSJan Kara we_slept: 731884d179dSJan Kara spin_lock(&dq_list_lock); 732884d179dSJan Kara if (atomic_read(&dquot->dq_count) > 1) { 733884d179dSJan Kara /* We have more than one user... nothing to do */ 734884d179dSJan Kara atomic_dec(&dquot->dq_count); 735884d179dSJan Kara /* Releasing dquot during quotaoff phase? */ 736884d179dSJan Kara if (!sb_has_quota_active(dquot->dq_sb, dquot->dq_type) && 737884d179dSJan Kara atomic_read(&dquot->dq_count) == 1) 738884d179dSJan Kara wake_up(&dquot->dq_wait_unused); 739884d179dSJan Kara spin_unlock(&dq_list_lock); 740884d179dSJan Kara return; 741884d179dSJan Kara } 742884d179dSJan Kara /* Need to release dquot? */ 743884d179dSJan Kara if (test_bit(DQ_ACTIVE_B, &dquot->dq_flags) && dquot_dirty(dquot)) { 744884d179dSJan Kara spin_unlock(&dq_list_lock); 745884d179dSJan Kara /* Commit dquot before releasing */ 746884d179dSJan Kara ret = dquot->dq_sb->dq_op->write_dquot(dquot); 747884d179dSJan Kara if (ret < 0) { 748fb5ffb0eSJiaying Zhang quota_error(dquot->dq_sb, "Can't write quota structure" 749fb5ffb0eSJiaying Zhang " (error %d). Quota may get out of sync!", 750fb5ffb0eSJiaying Zhang ret); 751884d179dSJan Kara /* 752884d179dSJan Kara * We clear dirty bit anyway, so that we avoid 753884d179dSJan Kara * infinite loop here 754884d179dSJan Kara */ 755884d179dSJan Kara spin_lock(&dq_list_lock); 756884d179dSJan Kara clear_dquot_dirty(dquot); 757884d179dSJan Kara spin_unlock(&dq_list_lock); 758884d179dSJan Kara } 759884d179dSJan Kara goto we_slept; 760884d179dSJan Kara } 761884d179dSJan Kara /* Clear flag in case dquot was inactive (something bad happened) */ 762884d179dSJan Kara clear_dquot_dirty(dquot); 763884d179dSJan Kara if (test_bit(DQ_ACTIVE_B, &dquot->dq_flags)) { 764884d179dSJan Kara spin_unlock(&dq_list_lock); 765884d179dSJan Kara dquot->dq_sb->dq_op->release_dquot(dquot); 766884d179dSJan Kara goto we_slept; 767884d179dSJan Kara } 768884d179dSJan Kara atomic_dec(&dquot->dq_count); 76962af9b52SJan Kara #ifdef CONFIG_QUOTA_DEBUG 770884d179dSJan Kara /* sanity check */ 771884d179dSJan Kara BUG_ON(!list_empty(&dquot->dq_free)); 772884d179dSJan Kara #endif 773884d179dSJan Kara put_dquot_last(dquot); 774884d179dSJan Kara spin_unlock(&dq_list_lock); 775884d179dSJan Kara } 776884d179dSJan Kara EXPORT_SYMBOL(dqput); 777884d179dSJan Kara 778884d179dSJan Kara struct dquot *dquot_alloc(struct super_block *sb, int type) 779884d179dSJan Kara { 780884d179dSJan Kara return kmem_cache_zalloc(dquot_cachep, GFP_NOFS); 781884d179dSJan Kara } 782884d179dSJan Kara EXPORT_SYMBOL(dquot_alloc); 783884d179dSJan Kara 784884d179dSJan Kara static struct dquot *get_empty_dquot(struct super_block *sb, int type) 785884d179dSJan Kara { 786884d179dSJan Kara struct dquot *dquot; 787884d179dSJan Kara 788884d179dSJan Kara dquot = sb->dq_op->alloc_dquot(sb, type); 789884d179dSJan Kara if(!dquot) 790dd6f3c6dSJan Kara return NULL; 791884d179dSJan Kara 792884d179dSJan Kara mutex_init(&dquot->dq_lock); 793884d179dSJan Kara INIT_LIST_HEAD(&dquot->dq_free); 794884d179dSJan Kara INIT_LIST_HEAD(&dquot->dq_inuse); 795884d179dSJan Kara INIT_HLIST_NODE(&dquot->dq_hash); 796884d179dSJan Kara INIT_LIST_HEAD(&dquot->dq_dirty); 797884d179dSJan Kara init_waitqueue_head(&dquot->dq_wait_unused); 798884d179dSJan Kara dquot->dq_sb = sb; 799884d179dSJan Kara dquot->dq_type = type; 800884d179dSJan Kara atomic_set(&dquot->dq_count, 1); 801884d179dSJan Kara 802884d179dSJan Kara return dquot; 803884d179dSJan Kara } 804884d179dSJan Kara 805884d179dSJan Kara /* 806884d179dSJan Kara * Get reference to dquot 807884d179dSJan Kara * 808884d179dSJan Kara * Locking is slightly tricky here. We are guarded from parallel quotaoff() 809884d179dSJan Kara * destroying our dquot by: 810884d179dSJan Kara * a) checking for quota flags under dq_list_lock and 811884d179dSJan Kara * b) getting a reference to dquot before we release dq_list_lock 812884d179dSJan Kara */ 813884d179dSJan Kara struct dquot *dqget(struct super_block *sb, unsigned int id, int type) 814884d179dSJan Kara { 815884d179dSJan Kara unsigned int hashent = hashfn(sb, id, type); 816dd6f3c6dSJan Kara struct dquot *dquot = NULL, *empty = NULL; 817884d179dSJan Kara 818884d179dSJan Kara if (!sb_has_quota_active(sb, type)) 819dd6f3c6dSJan Kara return NULL; 820884d179dSJan Kara we_slept: 821884d179dSJan Kara spin_lock(&dq_list_lock); 822884d179dSJan Kara spin_lock(&dq_state_lock); 823884d179dSJan Kara if (!sb_has_quota_active(sb, type)) { 824884d179dSJan Kara spin_unlock(&dq_state_lock); 825884d179dSJan Kara spin_unlock(&dq_list_lock); 826884d179dSJan Kara goto out; 827884d179dSJan Kara } 828884d179dSJan Kara spin_unlock(&dq_state_lock); 829884d179dSJan Kara 830dd6f3c6dSJan Kara dquot = find_dquot(hashent, sb, id, type); 831dd6f3c6dSJan Kara if (!dquot) { 832dd6f3c6dSJan Kara if (!empty) { 833884d179dSJan Kara spin_unlock(&dq_list_lock); 834dd6f3c6dSJan Kara empty = get_empty_dquot(sb, type); 835dd6f3c6dSJan Kara if (!empty) 836884d179dSJan Kara schedule(); /* Try to wait for a moment... */ 837884d179dSJan Kara goto we_slept; 838884d179dSJan Kara } 839884d179dSJan Kara dquot = empty; 840dd6f3c6dSJan Kara empty = NULL; 841884d179dSJan Kara dquot->dq_id = id; 842884d179dSJan Kara /* all dquots go on the inuse_list */ 843884d179dSJan Kara put_inuse(dquot); 844884d179dSJan Kara /* hash it first so it can be found */ 845884d179dSJan Kara insert_dquot_hash(dquot); 846884d179dSJan Kara spin_unlock(&dq_list_lock); 847dde95888SDmitry Monakhov dqstats_inc(DQST_LOOKUPS); 848884d179dSJan Kara } else { 849884d179dSJan Kara if (!atomic_read(&dquot->dq_count)) 850884d179dSJan Kara remove_free_dquot(dquot); 851884d179dSJan Kara atomic_inc(&dquot->dq_count); 852884d179dSJan Kara spin_unlock(&dq_list_lock); 853dde95888SDmitry Monakhov dqstats_inc(DQST_CACHE_HITS); 854dde95888SDmitry Monakhov dqstats_inc(DQST_LOOKUPS); 855884d179dSJan Kara } 856268157baSJan Kara /* Wait for dq_lock - after this we know that either dquot_release() is 857268157baSJan Kara * already finished or it will be canceled due to dq_count > 1 test */ 858884d179dSJan Kara wait_on_dquot(dquot); 859268157baSJan Kara /* Read the dquot / allocate space in quota file */ 860268157baSJan Kara if (!test_bit(DQ_ACTIVE_B, &dquot->dq_flags) && 861268157baSJan Kara sb->dq_op->acquire_dquot(dquot) < 0) { 862884d179dSJan Kara dqput(dquot); 863dd6f3c6dSJan Kara dquot = NULL; 864884d179dSJan Kara goto out; 865884d179dSJan Kara } 86662af9b52SJan Kara #ifdef CONFIG_QUOTA_DEBUG 867884d179dSJan Kara BUG_ON(!dquot->dq_sb); /* Has somebody invalidated entry under us? */ 868884d179dSJan Kara #endif 869884d179dSJan Kara out: 870884d179dSJan Kara if (empty) 871884d179dSJan Kara do_destroy_dquot(empty); 872884d179dSJan Kara 873884d179dSJan Kara return dquot; 874884d179dSJan Kara } 875884d179dSJan Kara EXPORT_SYMBOL(dqget); 876884d179dSJan Kara 877884d179dSJan Kara static int dqinit_needed(struct inode *inode, int type) 878884d179dSJan Kara { 879884d179dSJan Kara int cnt; 880884d179dSJan Kara 881884d179dSJan Kara if (IS_NOQUOTA(inode)) 882884d179dSJan Kara return 0; 883884d179dSJan Kara if (type != -1) 884dd6f3c6dSJan Kara return !inode->i_dquot[type]; 885884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) 886dd6f3c6dSJan Kara if (!inode->i_dquot[cnt]) 887884d179dSJan Kara return 1; 888884d179dSJan Kara return 0; 889884d179dSJan Kara } 890884d179dSJan Kara 891884d179dSJan Kara /* This routine is guarded by dqonoff_mutex mutex */ 892884d179dSJan Kara static void add_dquot_ref(struct super_block *sb, int type) 893884d179dSJan Kara { 894884d179dSJan Kara struct inode *inode, *old_inode = NULL; 89562af9b52SJan Kara #ifdef CONFIG_QUOTA_DEBUG 8960a5a9c72SJan Kara int reserved = 0; 8974c5e6c0eSJan Kara #endif 898884d179dSJan Kara 899884d179dSJan Kara spin_lock(&inode_lock); 900884d179dSJan Kara list_for_each_entry(inode, &sb->s_inodes, i_sb_list) { 901a4ffdde6SAl Viro if (inode->i_state & (I_FREEING|I_WILL_FREE|I_NEW)) 9023ae5080fSLinus Torvalds continue; 90362af9b52SJan Kara #ifdef CONFIG_QUOTA_DEBUG 9040a5a9c72SJan Kara if (unlikely(inode_get_rsv_space(inode) > 0)) 9050a5a9c72SJan Kara reserved = 1; 9064c5e6c0eSJan Kara #endif 907884d179dSJan Kara if (!atomic_read(&inode->i_writecount)) 908884d179dSJan Kara continue; 909884d179dSJan Kara if (!dqinit_needed(inode, type)) 910884d179dSJan Kara continue; 911884d179dSJan Kara 912884d179dSJan Kara __iget(inode); 913884d179dSJan Kara spin_unlock(&inode_lock); 914884d179dSJan Kara 915884d179dSJan Kara iput(old_inode); 916871a2931SChristoph Hellwig __dquot_initialize(inode, type); 917884d179dSJan Kara /* We hold a reference to 'inode' so it couldn't have been 918884d179dSJan Kara * removed from s_inodes list while we dropped the inode_lock. 919884d179dSJan Kara * We cannot iput the inode now as we can be holding the last 920884d179dSJan Kara * reference and we cannot iput it under inode_lock. So we 921884d179dSJan Kara * keep the reference and iput it later. */ 922884d179dSJan Kara old_inode = inode; 923884d179dSJan Kara spin_lock(&inode_lock); 924884d179dSJan Kara } 925884d179dSJan Kara spin_unlock(&inode_lock); 926884d179dSJan Kara iput(old_inode); 9270a5a9c72SJan Kara 92862af9b52SJan Kara #ifdef CONFIG_QUOTA_DEBUG 9290a5a9c72SJan Kara if (reserved) { 930fb5ffb0eSJiaying Zhang quota_error(sb, "Writes happened before quota was turned on " 931fb5ffb0eSJiaying Zhang "thus quota information is probably inconsistent. " 932fb5ffb0eSJiaying Zhang "Please run quotacheck(8)"); 9330a5a9c72SJan Kara } 9344c5e6c0eSJan Kara #endif 935884d179dSJan Kara } 936884d179dSJan Kara 937268157baSJan Kara /* 938268157baSJan Kara * Return 0 if dqput() won't block. 939268157baSJan Kara * (note that 1 doesn't necessarily mean blocking) 940268157baSJan Kara */ 941884d179dSJan Kara static inline int dqput_blocks(struct dquot *dquot) 942884d179dSJan Kara { 943884d179dSJan Kara if (atomic_read(&dquot->dq_count) <= 1) 944884d179dSJan Kara return 1; 945884d179dSJan Kara return 0; 946884d179dSJan Kara } 947884d179dSJan Kara 948268157baSJan Kara /* 949268157baSJan Kara * Remove references to dquots from inode and add dquot to list for freeing 950268157baSJan Kara * if we have the last referece to dquot 951268157baSJan Kara * We can't race with anybody because we hold dqptr_sem for writing... 952268157baSJan Kara */ 953884d179dSJan Kara static int remove_inode_dquot_ref(struct inode *inode, int type, 954884d179dSJan Kara struct list_head *tofree_head) 955884d179dSJan Kara { 956884d179dSJan Kara struct dquot *dquot = inode->i_dquot[type]; 957884d179dSJan Kara 958dd6f3c6dSJan Kara inode->i_dquot[type] = NULL; 959dd6f3c6dSJan Kara if (dquot) { 960884d179dSJan Kara if (dqput_blocks(dquot)) { 96162af9b52SJan Kara #ifdef CONFIG_QUOTA_DEBUG 962884d179dSJan Kara if (atomic_read(&dquot->dq_count) != 1) 963fb5ffb0eSJiaying Zhang quota_error(inode->i_sb, "Adding dquot with " 964fb5ffb0eSJiaying Zhang "dq_count %d to dispose list", 965fb5ffb0eSJiaying Zhang atomic_read(&dquot->dq_count)); 966884d179dSJan Kara #endif 967884d179dSJan Kara spin_lock(&dq_list_lock); 968268157baSJan Kara /* As dquot must have currently users it can't be on 969268157baSJan Kara * the free list... */ 970268157baSJan Kara list_add(&dquot->dq_free, tofree_head); 971884d179dSJan Kara spin_unlock(&dq_list_lock); 972884d179dSJan Kara return 1; 973884d179dSJan Kara } 974884d179dSJan Kara else 975884d179dSJan Kara dqput(dquot); /* We have guaranteed we won't block */ 976884d179dSJan Kara } 977884d179dSJan Kara return 0; 978884d179dSJan Kara } 979884d179dSJan Kara 980268157baSJan Kara /* 981268157baSJan Kara * Free list of dquots 982268157baSJan Kara * Dquots are removed from inodes and no new references can be got so we are 983268157baSJan Kara * the only ones holding reference 984268157baSJan Kara */ 985884d179dSJan Kara static void put_dquot_list(struct list_head *tofree_head) 986884d179dSJan Kara { 987884d179dSJan Kara struct list_head *act_head; 988884d179dSJan Kara struct dquot *dquot; 989884d179dSJan Kara 990884d179dSJan Kara act_head = tofree_head->next; 991884d179dSJan Kara while (act_head != tofree_head) { 992884d179dSJan Kara dquot = list_entry(act_head, struct dquot, dq_free); 993884d179dSJan Kara act_head = act_head->next; 994268157baSJan Kara /* Remove dquot from the list so we won't have problems... */ 995268157baSJan Kara list_del_init(&dquot->dq_free); 996884d179dSJan Kara dqput(dquot); 997884d179dSJan Kara } 998884d179dSJan Kara } 999884d179dSJan Kara 1000884d179dSJan Kara static void remove_dquot_ref(struct super_block *sb, int type, 1001884d179dSJan Kara struct list_head *tofree_head) 1002884d179dSJan Kara { 1003884d179dSJan Kara struct inode *inode; 10047af9cce8SDmitry Monakhov int reserved = 0; 1005884d179dSJan Kara 1006884d179dSJan Kara spin_lock(&inode_lock); 1007884d179dSJan Kara list_for_each_entry(inode, &sb->s_inodes, i_sb_list) { 10083ae5080fSLinus Torvalds /* 10093ae5080fSLinus Torvalds * We have to scan also I_NEW inodes because they can already 10103ae5080fSLinus Torvalds * have quota pointer initialized. Luckily, we need to touch 10113ae5080fSLinus Torvalds * only quota pointers and these have separate locking 10123ae5080fSLinus Torvalds * (dqptr_sem). 10133ae5080fSLinus Torvalds */ 10147af9cce8SDmitry Monakhov if (!IS_NOQUOTA(inode)) { 10157af9cce8SDmitry Monakhov if (unlikely(inode_get_rsv_space(inode) > 0)) 10167af9cce8SDmitry Monakhov reserved = 1; 1017884d179dSJan Kara remove_inode_dquot_ref(inode, type, tofree_head); 1018884d179dSJan Kara } 10197af9cce8SDmitry Monakhov } 1020884d179dSJan Kara spin_unlock(&inode_lock); 10217af9cce8SDmitry Monakhov #ifdef CONFIG_QUOTA_DEBUG 10227af9cce8SDmitry Monakhov if (reserved) { 10237af9cce8SDmitry Monakhov printk(KERN_WARNING "VFS (%s): Writes happened after quota" 10247af9cce8SDmitry Monakhov " was disabled thus quota information is probably " 10257af9cce8SDmitry Monakhov "inconsistent. Please run quotacheck(8).\n", sb->s_id); 10267af9cce8SDmitry Monakhov } 10277af9cce8SDmitry Monakhov #endif 1028884d179dSJan Kara } 1029884d179dSJan Kara 1030884d179dSJan Kara /* Gather all references from inodes and drop them */ 1031884d179dSJan Kara static void drop_dquot_ref(struct super_block *sb, int type) 1032884d179dSJan Kara { 1033884d179dSJan Kara LIST_HEAD(tofree_head); 1034884d179dSJan Kara 1035884d179dSJan Kara if (sb->dq_op) { 1036884d179dSJan Kara down_write(&sb_dqopt(sb)->dqptr_sem); 1037884d179dSJan Kara remove_dquot_ref(sb, type, &tofree_head); 1038884d179dSJan Kara up_write(&sb_dqopt(sb)->dqptr_sem); 1039884d179dSJan Kara put_dquot_list(&tofree_head); 1040884d179dSJan Kara } 1041884d179dSJan Kara } 1042884d179dSJan Kara 1043884d179dSJan Kara static inline void dquot_incr_inodes(struct dquot *dquot, qsize_t number) 1044884d179dSJan Kara { 1045884d179dSJan Kara dquot->dq_dqb.dqb_curinodes += number; 1046884d179dSJan Kara } 1047884d179dSJan Kara 1048884d179dSJan Kara static inline void dquot_incr_space(struct dquot *dquot, qsize_t number) 1049884d179dSJan Kara { 1050884d179dSJan Kara dquot->dq_dqb.dqb_curspace += number; 1051884d179dSJan Kara } 1052884d179dSJan Kara 1053884d179dSJan Kara static inline void dquot_resv_space(struct dquot *dquot, qsize_t number) 1054884d179dSJan Kara { 1055884d179dSJan Kara dquot->dq_dqb.dqb_rsvspace += number; 1056884d179dSJan Kara } 1057884d179dSJan Kara 1058884d179dSJan Kara /* 1059884d179dSJan Kara * Claim reserved quota space 1060884d179dSJan Kara */ 10610a5a9c72SJan Kara static void dquot_claim_reserved_space(struct dquot *dquot, qsize_t number) 1062884d179dSJan Kara { 10630a5a9c72SJan Kara if (dquot->dq_dqb.dqb_rsvspace < number) { 10640a5a9c72SJan Kara WARN_ON_ONCE(1); 10650a5a9c72SJan Kara number = dquot->dq_dqb.dqb_rsvspace; 10660a5a9c72SJan Kara } 1067884d179dSJan Kara dquot->dq_dqb.dqb_curspace += number; 1068884d179dSJan Kara dquot->dq_dqb.dqb_rsvspace -= number; 1069884d179dSJan Kara } 1070884d179dSJan Kara 1071884d179dSJan Kara static inline 1072884d179dSJan Kara void dquot_free_reserved_space(struct dquot *dquot, qsize_t number) 1073884d179dSJan Kara { 10740a5a9c72SJan Kara if (dquot->dq_dqb.dqb_rsvspace >= number) 1075884d179dSJan Kara dquot->dq_dqb.dqb_rsvspace -= number; 10760a5a9c72SJan Kara else { 10770a5a9c72SJan Kara WARN_ON_ONCE(1); 10780a5a9c72SJan Kara dquot->dq_dqb.dqb_rsvspace = 0; 10790a5a9c72SJan Kara } 1080884d179dSJan Kara } 1081884d179dSJan Kara 10827a2435d8SJan Kara static void dquot_decr_inodes(struct dquot *dquot, qsize_t number) 1083884d179dSJan Kara { 1084884d179dSJan Kara if (sb_dqopt(dquot->dq_sb)->flags & DQUOT_NEGATIVE_USAGE || 1085884d179dSJan Kara dquot->dq_dqb.dqb_curinodes >= number) 1086884d179dSJan Kara dquot->dq_dqb.dqb_curinodes -= number; 1087884d179dSJan Kara else 1088884d179dSJan Kara dquot->dq_dqb.dqb_curinodes = 0; 1089884d179dSJan Kara if (dquot->dq_dqb.dqb_curinodes <= dquot->dq_dqb.dqb_isoftlimit) 1090884d179dSJan Kara dquot->dq_dqb.dqb_itime = (time_t) 0; 1091884d179dSJan Kara clear_bit(DQ_INODES_B, &dquot->dq_flags); 1092884d179dSJan Kara } 1093884d179dSJan Kara 10947a2435d8SJan Kara static void dquot_decr_space(struct dquot *dquot, qsize_t number) 1095884d179dSJan Kara { 1096884d179dSJan Kara if (sb_dqopt(dquot->dq_sb)->flags & DQUOT_NEGATIVE_USAGE || 1097884d179dSJan Kara dquot->dq_dqb.dqb_curspace >= number) 1098884d179dSJan Kara dquot->dq_dqb.dqb_curspace -= number; 1099884d179dSJan Kara else 1100884d179dSJan Kara dquot->dq_dqb.dqb_curspace = 0; 1101884d179dSJan Kara if (dquot->dq_dqb.dqb_curspace <= dquot->dq_dqb.dqb_bsoftlimit) 1102884d179dSJan Kara dquot->dq_dqb.dqb_btime = (time_t) 0; 1103884d179dSJan Kara clear_bit(DQ_BLKS_B, &dquot->dq_flags); 1104884d179dSJan Kara } 1105884d179dSJan Kara 1106884d179dSJan Kara static int warning_issued(struct dquot *dquot, const int warntype) 1107884d179dSJan Kara { 1108884d179dSJan Kara int flag = (warntype == QUOTA_NL_BHARDWARN || 1109884d179dSJan Kara warntype == QUOTA_NL_BSOFTLONGWARN) ? DQ_BLKS_B : 1110884d179dSJan Kara ((warntype == QUOTA_NL_IHARDWARN || 1111884d179dSJan Kara warntype == QUOTA_NL_ISOFTLONGWARN) ? DQ_INODES_B : 0); 1112884d179dSJan Kara 1113884d179dSJan Kara if (!flag) 1114884d179dSJan Kara return 0; 1115884d179dSJan Kara return test_and_set_bit(flag, &dquot->dq_flags); 1116884d179dSJan Kara } 1117884d179dSJan Kara 1118884d179dSJan Kara #ifdef CONFIG_PRINT_QUOTA_WARNING 1119884d179dSJan Kara static int flag_print_warnings = 1; 1120884d179dSJan Kara 11217a2435d8SJan Kara static int need_print_warning(struct dquot *dquot) 1122884d179dSJan Kara { 1123884d179dSJan Kara if (!flag_print_warnings) 1124884d179dSJan Kara return 0; 1125884d179dSJan Kara 1126884d179dSJan Kara switch (dquot->dq_type) { 1127884d179dSJan Kara case USRQUOTA: 1128884d179dSJan Kara return current_fsuid() == dquot->dq_id; 1129884d179dSJan Kara case GRPQUOTA: 1130884d179dSJan Kara return in_group_p(dquot->dq_id); 1131884d179dSJan Kara } 1132884d179dSJan Kara return 0; 1133884d179dSJan Kara } 1134884d179dSJan Kara 1135884d179dSJan Kara /* Print warning to user which exceeded quota */ 1136884d179dSJan Kara static void print_warning(struct dquot *dquot, const int warntype) 1137884d179dSJan Kara { 1138884d179dSJan Kara char *msg = NULL; 1139884d179dSJan Kara struct tty_struct *tty; 1140884d179dSJan Kara 1141884d179dSJan Kara if (warntype == QUOTA_NL_IHARDBELOW || 1142884d179dSJan Kara warntype == QUOTA_NL_ISOFTBELOW || 1143884d179dSJan Kara warntype == QUOTA_NL_BHARDBELOW || 1144884d179dSJan Kara warntype == QUOTA_NL_BSOFTBELOW || !need_print_warning(dquot)) 1145884d179dSJan Kara return; 1146884d179dSJan Kara 1147884d179dSJan Kara tty = get_current_tty(); 1148884d179dSJan Kara if (!tty) 1149884d179dSJan Kara return; 1150884d179dSJan Kara tty_write_message(tty, dquot->dq_sb->s_id); 1151884d179dSJan Kara if (warntype == QUOTA_NL_ISOFTWARN || warntype == QUOTA_NL_BSOFTWARN) 1152884d179dSJan Kara tty_write_message(tty, ": warning, "); 1153884d179dSJan Kara else 1154884d179dSJan Kara tty_write_message(tty, ": write failed, "); 1155884d179dSJan Kara tty_write_message(tty, quotatypes[dquot->dq_type]); 1156884d179dSJan Kara switch (warntype) { 1157884d179dSJan Kara case QUOTA_NL_IHARDWARN: 1158884d179dSJan Kara msg = " file limit reached.\r\n"; 1159884d179dSJan Kara break; 1160884d179dSJan Kara case QUOTA_NL_ISOFTLONGWARN: 1161884d179dSJan Kara msg = " file quota exceeded too long.\r\n"; 1162884d179dSJan Kara break; 1163884d179dSJan Kara case QUOTA_NL_ISOFTWARN: 1164884d179dSJan Kara msg = " file quota exceeded.\r\n"; 1165884d179dSJan Kara break; 1166884d179dSJan Kara case QUOTA_NL_BHARDWARN: 1167884d179dSJan Kara msg = " block limit reached.\r\n"; 1168884d179dSJan Kara break; 1169884d179dSJan Kara case QUOTA_NL_BSOFTLONGWARN: 1170884d179dSJan Kara msg = " block quota exceeded too long.\r\n"; 1171884d179dSJan Kara break; 1172884d179dSJan Kara case QUOTA_NL_BSOFTWARN: 1173884d179dSJan Kara msg = " block quota exceeded.\r\n"; 1174884d179dSJan Kara break; 1175884d179dSJan Kara } 1176884d179dSJan Kara tty_write_message(tty, msg); 1177884d179dSJan Kara tty_kref_put(tty); 1178884d179dSJan Kara } 1179884d179dSJan Kara #endif 1180884d179dSJan Kara 1181884d179dSJan Kara /* 1182884d179dSJan Kara * Write warnings to the console and send warning messages over netlink. 1183884d179dSJan Kara * 1184884d179dSJan Kara * Note that this function can sleep. 1185884d179dSJan Kara */ 11867a2435d8SJan Kara static void flush_warnings(struct dquot *const *dquots, char *warntype) 1187884d179dSJan Kara { 118886e931a3SSteven Whitehouse struct dquot *dq; 1189884d179dSJan Kara int i; 1190884d179dSJan Kara 119186e931a3SSteven Whitehouse for (i = 0; i < MAXQUOTAS; i++) { 119286e931a3SSteven Whitehouse dq = dquots[i]; 119386e931a3SSteven Whitehouse if (dq && warntype[i] != QUOTA_NL_NOWARN && 119486e931a3SSteven Whitehouse !warning_issued(dq, warntype[i])) { 1195884d179dSJan Kara #ifdef CONFIG_PRINT_QUOTA_WARNING 119686e931a3SSteven Whitehouse print_warning(dq, warntype[i]); 1197884d179dSJan Kara #endif 119886e931a3SSteven Whitehouse quota_send_warning(dq->dq_type, dq->dq_id, 119986e931a3SSteven Whitehouse dq->dq_sb->s_dev, warntype[i]); 120086e931a3SSteven Whitehouse } 1201884d179dSJan Kara } 1202884d179dSJan Kara } 1203884d179dSJan Kara 12047a2435d8SJan Kara static int ignore_hardlimit(struct dquot *dquot) 1205884d179dSJan Kara { 1206884d179dSJan Kara struct mem_dqinfo *info = &sb_dqopt(dquot->dq_sb)->info[dquot->dq_type]; 1207884d179dSJan Kara 1208884d179dSJan Kara return capable(CAP_SYS_RESOURCE) && 1209268157baSJan Kara (info->dqi_format->qf_fmt_id != QFMT_VFS_OLD || 1210268157baSJan Kara !(info->dqi_flags & V1_DQF_RSQUASH)); 1211884d179dSJan Kara } 1212884d179dSJan Kara 1213884d179dSJan Kara /* needs dq_data_lock */ 1214884d179dSJan Kara static int check_idq(struct dquot *dquot, qsize_t inodes, char *warntype) 1215884d179dSJan Kara { 1216268157baSJan Kara qsize_t newinodes = dquot->dq_dqb.dqb_curinodes + inodes; 1217268157baSJan Kara 1218884d179dSJan Kara *warntype = QUOTA_NL_NOWARN; 1219884d179dSJan Kara if (!sb_has_quota_limits_enabled(dquot->dq_sb, dquot->dq_type) || 1220884d179dSJan Kara test_bit(DQ_FAKE_B, &dquot->dq_flags)) 1221efd8f0e6SChristoph Hellwig return 0; 1222884d179dSJan Kara 1223884d179dSJan Kara if (dquot->dq_dqb.dqb_ihardlimit && 1224268157baSJan Kara newinodes > dquot->dq_dqb.dqb_ihardlimit && 1225884d179dSJan Kara !ignore_hardlimit(dquot)) { 1226884d179dSJan Kara *warntype = QUOTA_NL_IHARDWARN; 1227efd8f0e6SChristoph Hellwig return -EDQUOT; 1228884d179dSJan Kara } 1229884d179dSJan Kara 1230884d179dSJan Kara if (dquot->dq_dqb.dqb_isoftlimit && 1231268157baSJan Kara newinodes > dquot->dq_dqb.dqb_isoftlimit && 1232268157baSJan Kara dquot->dq_dqb.dqb_itime && 1233268157baSJan Kara get_seconds() >= dquot->dq_dqb.dqb_itime && 1234884d179dSJan Kara !ignore_hardlimit(dquot)) { 1235884d179dSJan Kara *warntype = QUOTA_NL_ISOFTLONGWARN; 1236efd8f0e6SChristoph Hellwig return -EDQUOT; 1237884d179dSJan Kara } 1238884d179dSJan Kara 1239884d179dSJan Kara if (dquot->dq_dqb.dqb_isoftlimit && 1240268157baSJan Kara newinodes > dquot->dq_dqb.dqb_isoftlimit && 1241884d179dSJan Kara dquot->dq_dqb.dqb_itime == 0) { 1242884d179dSJan Kara *warntype = QUOTA_NL_ISOFTWARN; 1243268157baSJan Kara dquot->dq_dqb.dqb_itime = get_seconds() + 1244268157baSJan Kara sb_dqopt(dquot->dq_sb)->info[dquot->dq_type].dqi_igrace; 1245884d179dSJan Kara } 1246884d179dSJan Kara 1247efd8f0e6SChristoph Hellwig return 0; 1248884d179dSJan Kara } 1249884d179dSJan Kara 1250884d179dSJan Kara /* needs dq_data_lock */ 1251884d179dSJan Kara static int check_bdq(struct dquot *dquot, qsize_t space, int prealloc, char *warntype) 1252884d179dSJan Kara { 1253884d179dSJan Kara qsize_t tspace; 1254268157baSJan Kara struct super_block *sb = dquot->dq_sb; 1255884d179dSJan Kara 1256884d179dSJan Kara *warntype = QUOTA_NL_NOWARN; 1257268157baSJan Kara if (!sb_has_quota_limits_enabled(sb, dquot->dq_type) || 1258884d179dSJan Kara test_bit(DQ_FAKE_B, &dquot->dq_flags)) 1259efd8f0e6SChristoph Hellwig return 0; 1260884d179dSJan Kara 1261884d179dSJan Kara tspace = dquot->dq_dqb.dqb_curspace + dquot->dq_dqb.dqb_rsvspace 1262884d179dSJan Kara + space; 1263884d179dSJan Kara 1264884d179dSJan Kara if (dquot->dq_dqb.dqb_bhardlimit && 1265884d179dSJan Kara tspace > dquot->dq_dqb.dqb_bhardlimit && 1266884d179dSJan Kara !ignore_hardlimit(dquot)) { 1267884d179dSJan Kara if (!prealloc) 1268884d179dSJan Kara *warntype = QUOTA_NL_BHARDWARN; 1269efd8f0e6SChristoph Hellwig return -EDQUOT; 1270884d179dSJan Kara } 1271884d179dSJan Kara 1272884d179dSJan Kara if (dquot->dq_dqb.dqb_bsoftlimit && 1273884d179dSJan Kara tspace > dquot->dq_dqb.dqb_bsoftlimit && 1274268157baSJan Kara dquot->dq_dqb.dqb_btime && 1275268157baSJan Kara get_seconds() >= dquot->dq_dqb.dqb_btime && 1276884d179dSJan Kara !ignore_hardlimit(dquot)) { 1277884d179dSJan Kara if (!prealloc) 1278884d179dSJan Kara *warntype = QUOTA_NL_BSOFTLONGWARN; 1279efd8f0e6SChristoph Hellwig return -EDQUOT; 1280884d179dSJan Kara } 1281884d179dSJan Kara 1282884d179dSJan Kara if (dquot->dq_dqb.dqb_bsoftlimit && 1283884d179dSJan Kara tspace > dquot->dq_dqb.dqb_bsoftlimit && 1284884d179dSJan Kara dquot->dq_dqb.dqb_btime == 0) { 1285884d179dSJan Kara if (!prealloc) { 1286884d179dSJan Kara *warntype = QUOTA_NL_BSOFTWARN; 1287268157baSJan Kara dquot->dq_dqb.dqb_btime = get_seconds() + 1288268157baSJan Kara sb_dqopt(sb)->info[dquot->dq_type].dqi_bgrace; 1289884d179dSJan Kara } 1290884d179dSJan Kara else 1291884d179dSJan Kara /* 1292884d179dSJan Kara * We don't allow preallocation to exceed softlimit so exceeding will 1293884d179dSJan Kara * be always printed 1294884d179dSJan Kara */ 1295efd8f0e6SChristoph Hellwig return -EDQUOT; 1296884d179dSJan Kara } 1297884d179dSJan Kara 1298efd8f0e6SChristoph Hellwig return 0; 1299884d179dSJan Kara } 1300884d179dSJan Kara 1301884d179dSJan Kara static int info_idq_free(struct dquot *dquot, qsize_t inodes) 1302884d179dSJan Kara { 1303268157baSJan Kara qsize_t newinodes; 1304268157baSJan Kara 1305884d179dSJan Kara if (test_bit(DQ_FAKE_B, &dquot->dq_flags) || 1306884d179dSJan Kara dquot->dq_dqb.dqb_curinodes <= dquot->dq_dqb.dqb_isoftlimit || 1307884d179dSJan Kara !sb_has_quota_limits_enabled(dquot->dq_sb, dquot->dq_type)) 1308884d179dSJan Kara return QUOTA_NL_NOWARN; 1309884d179dSJan Kara 1310268157baSJan Kara newinodes = dquot->dq_dqb.dqb_curinodes - inodes; 1311268157baSJan Kara if (newinodes <= dquot->dq_dqb.dqb_isoftlimit) 1312884d179dSJan Kara return QUOTA_NL_ISOFTBELOW; 1313884d179dSJan Kara if (dquot->dq_dqb.dqb_curinodes >= dquot->dq_dqb.dqb_ihardlimit && 1314268157baSJan Kara newinodes < dquot->dq_dqb.dqb_ihardlimit) 1315884d179dSJan Kara return QUOTA_NL_IHARDBELOW; 1316884d179dSJan Kara return QUOTA_NL_NOWARN; 1317884d179dSJan Kara } 1318884d179dSJan Kara 1319884d179dSJan Kara static int info_bdq_free(struct dquot *dquot, qsize_t space) 1320884d179dSJan Kara { 1321884d179dSJan Kara if (test_bit(DQ_FAKE_B, &dquot->dq_flags) || 1322884d179dSJan Kara dquot->dq_dqb.dqb_curspace <= dquot->dq_dqb.dqb_bsoftlimit) 1323884d179dSJan Kara return QUOTA_NL_NOWARN; 1324884d179dSJan Kara 1325884d179dSJan Kara if (dquot->dq_dqb.dqb_curspace - space <= dquot->dq_dqb.dqb_bsoftlimit) 1326884d179dSJan Kara return QUOTA_NL_BSOFTBELOW; 1327884d179dSJan Kara if (dquot->dq_dqb.dqb_curspace >= dquot->dq_dqb.dqb_bhardlimit && 1328884d179dSJan Kara dquot->dq_dqb.dqb_curspace - space < dquot->dq_dqb.dqb_bhardlimit) 1329884d179dSJan Kara return QUOTA_NL_BHARDBELOW; 1330884d179dSJan Kara return QUOTA_NL_NOWARN; 1331884d179dSJan Kara } 13320a5a9c72SJan Kara 1333189eef59SChristoph Hellwig static int dquot_active(const struct inode *inode) 1334189eef59SChristoph Hellwig { 1335189eef59SChristoph Hellwig struct super_block *sb = inode->i_sb; 1336189eef59SChristoph Hellwig 1337189eef59SChristoph Hellwig if (IS_NOQUOTA(inode)) 1338189eef59SChristoph Hellwig return 0; 1339189eef59SChristoph Hellwig return sb_any_quota_loaded(sb) & ~sb_any_quota_suspended(sb); 1340189eef59SChristoph Hellwig } 1341189eef59SChristoph Hellwig 1342884d179dSJan Kara /* 1343884d179dSJan Kara * Initialize quota pointers in inode 1344871a2931SChristoph Hellwig * 1345884d179dSJan Kara * We do things in a bit complicated way but by that we avoid calling 1346884d179dSJan Kara * dqget() and thus filesystem callbacks under dqptr_sem. 1347871a2931SChristoph Hellwig * 1348871a2931SChristoph Hellwig * It is better to call this function outside of any transaction as it 1349871a2931SChristoph Hellwig * might need a lot of space in journal for dquot structure allocation. 1350884d179dSJan Kara */ 1351871a2931SChristoph Hellwig static void __dquot_initialize(struct inode *inode, int type) 1352884d179dSJan Kara { 1353884d179dSJan Kara unsigned int id = 0; 1354871a2931SChristoph Hellwig int cnt; 1355ad1e6e8dSDmitry Monakhov struct dquot *got[MAXQUOTAS]; 1356884d179dSJan Kara struct super_block *sb = inode->i_sb; 13570a5a9c72SJan Kara qsize_t rsv; 1358884d179dSJan Kara 1359884d179dSJan Kara /* First test before acquiring mutex - solves deadlocks when we 1360884d179dSJan Kara * re-enter the quota code and are already holding the mutex */ 1361189eef59SChristoph Hellwig if (!dquot_active(inode)) 1362871a2931SChristoph Hellwig return; 1363884d179dSJan Kara 1364884d179dSJan Kara /* First get references to structures we might need. */ 1365884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1366ad1e6e8dSDmitry Monakhov got[cnt] = NULL; 1367884d179dSJan Kara if (type != -1 && cnt != type) 1368884d179dSJan Kara continue; 1369884d179dSJan Kara switch (cnt) { 1370884d179dSJan Kara case USRQUOTA: 1371884d179dSJan Kara id = inode->i_uid; 1372884d179dSJan Kara break; 1373884d179dSJan Kara case GRPQUOTA: 1374884d179dSJan Kara id = inode->i_gid; 1375884d179dSJan Kara break; 1376884d179dSJan Kara } 1377884d179dSJan Kara got[cnt] = dqget(sb, id, cnt); 1378884d179dSJan Kara } 1379884d179dSJan Kara 1380884d179dSJan Kara down_write(&sb_dqopt(sb)->dqptr_sem); 1381884d179dSJan Kara if (IS_NOQUOTA(inode)) 1382884d179dSJan Kara goto out_err; 1383884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1384884d179dSJan Kara if (type != -1 && cnt != type) 1385884d179dSJan Kara continue; 1386884d179dSJan Kara /* Avoid races with quotaoff() */ 1387884d179dSJan Kara if (!sb_has_quota_active(sb, cnt)) 1388884d179dSJan Kara continue; 1389dd6f3c6dSJan Kara if (!inode->i_dquot[cnt]) { 1390884d179dSJan Kara inode->i_dquot[cnt] = got[cnt]; 1391dd6f3c6dSJan Kara got[cnt] = NULL; 13920a5a9c72SJan Kara /* 13930a5a9c72SJan Kara * Make quota reservation system happy if someone 13940a5a9c72SJan Kara * did a write before quota was turned on 13950a5a9c72SJan Kara */ 13960a5a9c72SJan Kara rsv = inode_get_rsv_space(inode); 13970a5a9c72SJan Kara if (unlikely(rsv)) 13980a5a9c72SJan Kara dquot_resv_space(inode->i_dquot[cnt], rsv); 1399884d179dSJan Kara } 1400884d179dSJan Kara } 1401884d179dSJan Kara out_err: 1402884d179dSJan Kara up_write(&sb_dqopt(sb)->dqptr_sem); 1403884d179dSJan Kara /* Drop unused references */ 1404dc52dd3aSDmitry Monakhov dqput_all(got); 1405871a2931SChristoph Hellwig } 1406871a2931SChristoph Hellwig 1407871a2931SChristoph Hellwig void dquot_initialize(struct inode *inode) 1408871a2931SChristoph Hellwig { 1409871a2931SChristoph Hellwig __dquot_initialize(inode, -1); 1410884d179dSJan Kara } 1411884d179dSJan Kara EXPORT_SYMBOL(dquot_initialize); 1412884d179dSJan Kara 1413884d179dSJan Kara /* 1414884d179dSJan Kara * Release all quotas referenced by inode 1415884d179dSJan Kara */ 14169f754758SChristoph Hellwig static void __dquot_drop(struct inode *inode) 1417884d179dSJan Kara { 1418884d179dSJan Kara int cnt; 1419884d179dSJan Kara struct dquot *put[MAXQUOTAS]; 1420884d179dSJan Kara 1421884d179dSJan Kara down_write(&sb_dqopt(inode->i_sb)->dqptr_sem); 1422884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1423884d179dSJan Kara put[cnt] = inode->i_dquot[cnt]; 1424dd6f3c6dSJan Kara inode->i_dquot[cnt] = NULL; 1425884d179dSJan Kara } 1426884d179dSJan Kara up_write(&sb_dqopt(inode->i_sb)->dqptr_sem); 1427dc52dd3aSDmitry Monakhov dqput_all(put); 1428884d179dSJan Kara } 1429884d179dSJan Kara 14309f754758SChristoph Hellwig void dquot_drop(struct inode *inode) 1431884d179dSJan Kara { 1432884d179dSJan Kara int cnt; 14339f754758SChristoph Hellwig 14349f754758SChristoph Hellwig if (IS_NOQUOTA(inode)) 14359f754758SChristoph Hellwig return; 14369f754758SChristoph Hellwig 14379f754758SChristoph Hellwig /* 14389f754758SChristoph Hellwig * Test before calling to rule out calls from proc and such 1439884d179dSJan Kara * where we are not allowed to block. Note that this is 1440884d179dSJan Kara * actually reliable test even without the lock - the caller 1441884d179dSJan Kara * must assure that nobody can come after the DQUOT_DROP and 14429f754758SChristoph Hellwig * add quota pointers back anyway. 14439f754758SChristoph Hellwig */ 14449f754758SChristoph Hellwig for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1445dd6f3c6dSJan Kara if (inode->i_dquot[cnt]) 1446884d179dSJan Kara break; 14479f754758SChristoph Hellwig } 14489f754758SChristoph Hellwig 1449884d179dSJan Kara if (cnt < MAXQUOTAS) 14509f754758SChristoph Hellwig __dquot_drop(inode); 1451884d179dSJan Kara } 14529f754758SChristoph Hellwig EXPORT_SYMBOL(dquot_drop); 1453884d179dSJan Kara 1454884d179dSJan Kara /* 1455fd8fbfc1SDmitry Monakhov * inode_reserved_space is managed internally by quota, and protected by 1456fd8fbfc1SDmitry Monakhov * i_lock similar to i_blocks+i_bytes. 1457fd8fbfc1SDmitry Monakhov */ 1458fd8fbfc1SDmitry Monakhov static qsize_t *inode_reserved_space(struct inode * inode) 1459fd8fbfc1SDmitry Monakhov { 1460fd8fbfc1SDmitry Monakhov /* Filesystem must explicitly define it's own method in order to use 1461fd8fbfc1SDmitry Monakhov * quota reservation interface */ 1462fd8fbfc1SDmitry Monakhov BUG_ON(!inode->i_sb->dq_op->get_reserved_space); 1463fd8fbfc1SDmitry Monakhov return inode->i_sb->dq_op->get_reserved_space(inode); 1464fd8fbfc1SDmitry Monakhov } 1465fd8fbfc1SDmitry Monakhov 1466c469070aSDmitry Monakhov void inode_add_rsv_space(struct inode *inode, qsize_t number) 1467fd8fbfc1SDmitry Monakhov { 1468fd8fbfc1SDmitry Monakhov spin_lock(&inode->i_lock); 1469fd8fbfc1SDmitry Monakhov *inode_reserved_space(inode) += number; 1470fd8fbfc1SDmitry Monakhov spin_unlock(&inode->i_lock); 1471fd8fbfc1SDmitry Monakhov } 1472c469070aSDmitry Monakhov EXPORT_SYMBOL(inode_add_rsv_space); 1473fd8fbfc1SDmitry Monakhov 1474c469070aSDmitry Monakhov void inode_claim_rsv_space(struct inode *inode, qsize_t number) 1475fd8fbfc1SDmitry Monakhov { 1476fd8fbfc1SDmitry Monakhov spin_lock(&inode->i_lock); 1477fd8fbfc1SDmitry Monakhov *inode_reserved_space(inode) -= number; 1478fd8fbfc1SDmitry Monakhov __inode_add_bytes(inode, number); 1479fd8fbfc1SDmitry Monakhov spin_unlock(&inode->i_lock); 1480fd8fbfc1SDmitry Monakhov } 1481c469070aSDmitry Monakhov EXPORT_SYMBOL(inode_claim_rsv_space); 1482fd8fbfc1SDmitry Monakhov 1483c469070aSDmitry Monakhov void inode_sub_rsv_space(struct inode *inode, qsize_t number) 1484fd8fbfc1SDmitry Monakhov { 1485fd8fbfc1SDmitry Monakhov spin_lock(&inode->i_lock); 1486fd8fbfc1SDmitry Monakhov *inode_reserved_space(inode) -= number; 1487fd8fbfc1SDmitry Monakhov spin_unlock(&inode->i_lock); 1488fd8fbfc1SDmitry Monakhov } 1489c469070aSDmitry Monakhov EXPORT_SYMBOL(inode_sub_rsv_space); 1490fd8fbfc1SDmitry Monakhov 1491fd8fbfc1SDmitry Monakhov static qsize_t inode_get_rsv_space(struct inode *inode) 1492fd8fbfc1SDmitry Monakhov { 1493fd8fbfc1SDmitry Monakhov qsize_t ret; 149405b5d898SJan Kara 149505b5d898SJan Kara if (!inode->i_sb->dq_op->get_reserved_space) 149605b5d898SJan Kara return 0; 1497fd8fbfc1SDmitry Monakhov spin_lock(&inode->i_lock); 1498fd8fbfc1SDmitry Monakhov ret = *inode_reserved_space(inode); 1499fd8fbfc1SDmitry Monakhov spin_unlock(&inode->i_lock); 1500fd8fbfc1SDmitry Monakhov return ret; 1501fd8fbfc1SDmitry Monakhov } 1502fd8fbfc1SDmitry Monakhov 1503fd8fbfc1SDmitry Monakhov static void inode_incr_space(struct inode *inode, qsize_t number, 1504fd8fbfc1SDmitry Monakhov int reserve) 1505fd8fbfc1SDmitry Monakhov { 1506fd8fbfc1SDmitry Monakhov if (reserve) 1507fd8fbfc1SDmitry Monakhov inode_add_rsv_space(inode, number); 1508fd8fbfc1SDmitry Monakhov else 1509fd8fbfc1SDmitry Monakhov inode_add_bytes(inode, number); 1510fd8fbfc1SDmitry Monakhov } 1511fd8fbfc1SDmitry Monakhov 1512fd8fbfc1SDmitry Monakhov static void inode_decr_space(struct inode *inode, qsize_t number, int reserve) 1513fd8fbfc1SDmitry Monakhov { 1514fd8fbfc1SDmitry Monakhov if (reserve) 1515fd8fbfc1SDmitry Monakhov inode_sub_rsv_space(inode, number); 1516fd8fbfc1SDmitry Monakhov else 1517fd8fbfc1SDmitry Monakhov inode_sub_bytes(inode, number); 1518fd8fbfc1SDmitry Monakhov } 1519fd8fbfc1SDmitry Monakhov 1520fd8fbfc1SDmitry Monakhov /* 15215dd4056dSChristoph Hellwig * This functions updates i_blocks+i_bytes fields and quota information 15225dd4056dSChristoph Hellwig * (together with appropriate checks). 15235dd4056dSChristoph Hellwig * 15245dd4056dSChristoph Hellwig * NOTE: We absolutely rely on the fact that caller dirties the inode 15255dd4056dSChristoph Hellwig * (usually helpers in quotaops.h care about this) and holds a handle for 15265dd4056dSChristoph Hellwig * the current transaction so that dquot write and inode write go into the 15275dd4056dSChristoph Hellwig * same transaction. 1528884d179dSJan Kara */ 1529884d179dSJan Kara 1530884d179dSJan Kara /* 1531884d179dSJan Kara * This operation can block, but only after everything is updated 1532884d179dSJan Kara */ 153356246f9aSEric Sandeen int __dquot_alloc_space(struct inode *inode, qsize_t number, int flags) 1534884d179dSJan Kara { 15355dd4056dSChristoph Hellwig int cnt, ret = 0; 1536884d179dSJan Kara char warntype[MAXQUOTAS]; 153756246f9aSEric Sandeen int warn = flags & DQUOT_SPACE_WARN; 153856246f9aSEric Sandeen int reserve = flags & DQUOT_SPACE_RESERVE; 15390e05842bSEric Sandeen int nofail = flags & DQUOT_SPACE_NOFAIL; 1540884d179dSJan Kara 1541fd8fbfc1SDmitry Monakhov /* 1542fd8fbfc1SDmitry Monakhov * First test before acquiring mutex - solves deadlocks when we 1543fd8fbfc1SDmitry Monakhov * re-enter the quota code and are already holding the mutex 1544fd8fbfc1SDmitry Monakhov */ 1545189eef59SChristoph Hellwig if (!dquot_active(inode)) { 1546fd8fbfc1SDmitry Monakhov inode_incr_space(inode, number, reserve); 1547fd8fbfc1SDmitry Monakhov goto out; 1548fd8fbfc1SDmitry Monakhov } 1549fd8fbfc1SDmitry Monakhov 1550fd8fbfc1SDmitry Monakhov down_read(&sb_dqopt(inode->i_sb)->dqptr_sem); 1551884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) 1552884d179dSJan Kara warntype[cnt] = QUOTA_NL_NOWARN; 1553884d179dSJan Kara 1554884d179dSJan Kara spin_lock(&dq_data_lock); 1555884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1556dd6f3c6dSJan Kara if (!inode->i_dquot[cnt]) 1557884d179dSJan Kara continue; 1558efd8f0e6SChristoph Hellwig ret = check_bdq(inode->i_dquot[cnt], number, !warn, 1559efd8f0e6SChristoph Hellwig warntype+cnt); 15600e05842bSEric Sandeen if (ret && !nofail) { 1561fd8fbfc1SDmitry Monakhov spin_unlock(&dq_data_lock); 1562fd8fbfc1SDmitry Monakhov goto out_flush_warn; 1563884d179dSJan Kara } 1564884d179dSJan Kara } 1565884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1566dd6f3c6dSJan Kara if (!inode->i_dquot[cnt]) 1567884d179dSJan Kara continue; 1568884d179dSJan Kara if (reserve) 1569884d179dSJan Kara dquot_resv_space(inode->i_dquot[cnt], number); 1570884d179dSJan Kara else 1571884d179dSJan Kara dquot_incr_space(inode->i_dquot[cnt], number); 1572884d179dSJan Kara } 1573fd8fbfc1SDmitry Monakhov inode_incr_space(inode, number, reserve); 1574884d179dSJan Kara spin_unlock(&dq_data_lock); 1575fd8fbfc1SDmitry Monakhov 1576fd8fbfc1SDmitry Monakhov if (reserve) 1577fd8fbfc1SDmitry Monakhov goto out_flush_warn; 1578dc52dd3aSDmitry Monakhov mark_all_dquot_dirty(inode->i_dquot); 1579fd8fbfc1SDmitry Monakhov out_flush_warn: 1580884d179dSJan Kara flush_warnings(inode->i_dquot, warntype); 1581fd8fbfc1SDmitry Monakhov up_read(&sb_dqopt(inode->i_sb)->dqptr_sem); 1582fd8fbfc1SDmitry Monakhov out: 1583884d179dSJan Kara return ret; 1584884d179dSJan Kara } 15855dd4056dSChristoph Hellwig EXPORT_SYMBOL(__dquot_alloc_space); 1586884d179dSJan Kara 1587884d179dSJan Kara /* 1588884d179dSJan Kara * This operation can block, but only after everything is updated 1589884d179dSJan Kara */ 159063936ddaSChristoph Hellwig int dquot_alloc_inode(const struct inode *inode) 1591884d179dSJan Kara { 1592efd8f0e6SChristoph Hellwig int cnt, ret = 0; 1593884d179dSJan Kara char warntype[MAXQUOTAS]; 1594884d179dSJan Kara 1595884d179dSJan Kara /* First test before acquiring mutex - solves deadlocks when we 1596884d179dSJan Kara * re-enter the quota code and are already holding the mutex */ 1597189eef59SChristoph Hellwig if (!dquot_active(inode)) 159863936ddaSChristoph Hellwig return 0; 1599884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) 1600884d179dSJan Kara warntype[cnt] = QUOTA_NL_NOWARN; 1601884d179dSJan Kara down_read(&sb_dqopt(inode->i_sb)->dqptr_sem); 1602884d179dSJan Kara spin_lock(&dq_data_lock); 1603884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1604dd6f3c6dSJan Kara if (!inode->i_dquot[cnt]) 1605884d179dSJan Kara continue; 1606efd8f0e6SChristoph Hellwig ret = check_idq(inode->i_dquot[cnt], 1, warntype + cnt); 1607efd8f0e6SChristoph Hellwig if (ret) 1608884d179dSJan Kara goto warn_put_all; 1609884d179dSJan Kara } 1610884d179dSJan Kara 1611884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1612dd6f3c6dSJan Kara if (!inode->i_dquot[cnt]) 1613884d179dSJan Kara continue; 161463936ddaSChristoph Hellwig dquot_incr_inodes(inode->i_dquot[cnt], 1); 1615884d179dSJan Kara } 1616efd8f0e6SChristoph Hellwig 1617884d179dSJan Kara warn_put_all: 1618884d179dSJan Kara spin_unlock(&dq_data_lock); 161963936ddaSChristoph Hellwig if (ret == 0) 1620dc52dd3aSDmitry Monakhov mark_all_dquot_dirty(inode->i_dquot); 1621884d179dSJan Kara flush_warnings(inode->i_dquot, warntype); 1622884d179dSJan Kara up_read(&sb_dqopt(inode->i_sb)->dqptr_sem); 1623884d179dSJan Kara return ret; 1624884d179dSJan Kara } 1625884d179dSJan Kara EXPORT_SYMBOL(dquot_alloc_inode); 1626884d179dSJan Kara 16275dd4056dSChristoph Hellwig /* 16285dd4056dSChristoph Hellwig * Convert in-memory reserved quotas to real consumed quotas 16295dd4056dSChristoph Hellwig */ 16305dd4056dSChristoph Hellwig int dquot_claim_space_nodirty(struct inode *inode, qsize_t number) 1631884d179dSJan Kara { 1632884d179dSJan Kara int cnt; 1633884d179dSJan Kara 1634189eef59SChristoph Hellwig if (!dquot_active(inode)) { 1635fd8fbfc1SDmitry Monakhov inode_claim_rsv_space(inode, number); 16365dd4056dSChristoph Hellwig return 0; 1637884d179dSJan Kara } 1638884d179dSJan Kara 1639884d179dSJan Kara down_read(&sb_dqopt(inode->i_sb)->dqptr_sem); 1640884d179dSJan Kara spin_lock(&dq_data_lock); 1641884d179dSJan Kara /* Claim reserved quotas to allocated quotas */ 1642884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1643dd6f3c6dSJan Kara if (inode->i_dquot[cnt]) 1644884d179dSJan Kara dquot_claim_reserved_space(inode->i_dquot[cnt], 1645884d179dSJan Kara number); 1646884d179dSJan Kara } 1647884d179dSJan Kara /* Update inode bytes */ 1648fd8fbfc1SDmitry Monakhov inode_claim_rsv_space(inode, number); 1649884d179dSJan Kara spin_unlock(&dq_data_lock); 1650dc52dd3aSDmitry Monakhov mark_all_dquot_dirty(inode->i_dquot); 1651884d179dSJan Kara up_read(&sb_dqopt(inode->i_sb)->dqptr_sem); 16525dd4056dSChristoph Hellwig return 0; 1653884d179dSJan Kara } 16545dd4056dSChristoph Hellwig EXPORT_SYMBOL(dquot_claim_space_nodirty); 1655884d179dSJan Kara 1656884d179dSJan Kara /* 1657884d179dSJan Kara * This operation can block, but only after everything is updated 1658884d179dSJan Kara */ 165956246f9aSEric Sandeen void __dquot_free_space(struct inode *inode, qsize_t number, int flags) 1660884d179dSJan Kara { 1661884d179dSJan Kara unsigned int cnt; 1662884d179dSJan Kara char warntype[MAXQUOTAS]; 166356246f9aSEric Sandeen int reserve = flags & DQUOT_SPACE_RESERVE; 1664884d179dSJan Kara 1665884d179dSJan Kara /* First test before acquiring mutex - solves deadlocks when we 1666884d179dSJan Kara * re-enter the quota code and are already holding the mutex */ 1667189eef59SChristoph Hellwig if (!dquot_active(inode)) { 1668fd8fbfc1SDmitry Monakhov inode_decr_space(inode, number, reserve); 16695dd4056dSChristoph Hellwig return; 1670884d179dSJan Kara } 1671884d179dSJan Kara 1672884d179dSJan Kara down_read(&sb_dqopt(inode->i_sb)->dqptr_sem); 1673884d179dSJan Kara spin_lock(&dq_data_lock); 1674884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1675dd6f3c6dSJan Kara if (!inode->i_dquot[cnt]) 1676884d179dSJan Kara continue; 1677884d179dSJan Kara warntype[cnt] = info_bdq_free(inode->i_dquot[cnt], number); 1678fd8fbfc1SDmitry Monakhov if (reserve) 1679fd8fbfc1SDmitry Monakhov dquot_free_reserved_space(inode->i_dquot[cnt], number); 1680fd8fbfc1SDmitry Monakhov else 1681884d179dSJan Kara dquot_decr_space(inode->i_dquot[cnt], number); 1682884d179dSJan Kara } 1683fd8fbfc1SDmitry Monakhov inode_decr_space(inode, number, reserve); 1684884d179dSJan Kara spin_unlock(&dq_data_lock); 1685fd8fbfc1SDmitry Monakhov 1686fd8fbfc1SDmitry Monakhov if (reserve) 1687fd8fbfc1SDmitry Monakhov goto out_unlock; 1688dc52dd3aSDmitry Monakhov mark_all_dquot_dirty(inode->i_dquot); 1689fd8fbfc1SDmitry Monakhov out_unlock: 1690884d179dSJan Kara flush_warnings(inode->i_dquot, warntype); 1691884d179dSJan Kara up_read(&sb_dqopt(inode->i_sb)->dqptr_sem); 1692884d179dSJan Kara } 16935dd4056dSChristoph Hellwig EXPORT_SYMBOL(__dquot_free_space); 1694fd8fbfc1SDmitry Monakhov 1695fd8fbfc1SDmitry Monakhov /* 1696884d179dSJan Kara * This operation can block, but only after everything is updated 1697884d179dSJan Kara */ 169863936ddaSChristoph Hellwig void dquot_free_inode(const struct inode *inode) 1699884d179dSJan Kara { 1700884d179dSJan Kara unsigned int cnt; 1701884d179dSJan Kara char warntype[MAXQUOTAS]; 1702884d179dSJan Kara 1703884d179dSJan Kara /* First test before acquiring mutex - solves deadlocks when we 1704884d179dSJan Kara * re-enter the quota code and are already holding the mutex */ 1705189eef59SChristoph Hellwig if (!dquot_active(inode)) 170663936ddaSChristoph Hellwig return; 1707884d179dSJan Kara 1708884d179dSJan Kara down_read(&sb_dqopt(inode->i_sb)->dqptr_sem); 1709884d179dSJan Kara spin_lock(&dq_data_lock); 1710884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1711dd6f3c6dSJan Kara if (!inode->i_dquot[cnt]) 1712884d179dSJan Kara continue; 171363936ddaSChristoph Hellwig warntype[cnt] = info_idq_free(inode->i_dquot[cnt], 1); 171463936ddaSChristoph Hellwig dquot_decr_inodes(inode->i_dquot[cnt], 1); 1715884d179dSJan Kara } 1716884d179dSJan Kara spin_unlock(&dq_data_lock); 1717dc52dd3aSDmitry Monakhov mark_all_dquot_dirty(inode->i_dquot); 1718884d179dSJan Kara flush_warnings(inode->i_dquot, warntype); 1719884d179dSJan Kara up_read(&sb_dqopt(inode->i_sb)->dqptr_sem); 1720884d179dSJan Kara } 1721884d179dSJan Kara EXPORT_SYMBOL(dquot_free_inode); 1722884d179dSJan Kara 1723884d179dSJan Kara /* 1724884d179dSJan Kara * Transfer the number of inode and blocks from one diskquota to an other. 1725bc8e5f07SJan Kara * On success, dquot references in transfer_to are consumed and references 1726bc8e5f07SJan Kara * to original dquots that need to be released are placed there. On failure, 1727bc8e5f07SJan Kara * references are kept untouched. 1728884d179dSJan Kara * 1729884d179dSJan Kara * This operation can block, but only after everything is updated 1730884d179dSJan Kara * A transaction must be started when entering this function. 1731bc8e5f07SJan Kara * 1732884d179dSJan Kara */ 1733bc8e5f07SJan Kara int __dquot_transfer(struct inode *inode, struct dquot **transfer_to) 1734884d179dSJan Kara { 1735884d179dSJan Kara qsize_t space, cur_space; 1736884d179dSJan Kara qsize_t rsv_space = 0; 1737bc8e5f07SJan Kara struct dquot *transfer_from[MAXQUOTAS] = {}; 1738efd8f0e6SChristoph Hellwig int cnt, ret = 0; 1739*9e32784bSDmitry char is_valid[MAXQUOTAS] = {}; 1740884d179dSJan Kara char warntype_to[MAXQUOTAS]; 1741884d179dSJan Kara char warntype_from_inodes[MAXQUOTAS], warntype_from_space[MAXQUOTAS]; 1742884d179dSJan Kara 1743884d179dSJan Kara /* First test before acquiring mutex - solves deadlocks when we 1744884d179dSJan Kara * re-enter the quota code and are already holding the mutex */ 1745884d179dSJan Kara if (IS_NOQUOTA(inode)) 1746efd8f0e6SChristoph Hellwig return 0; 1747884d179dSJan Kara /* Initialize the arrays */ 1748bc8e5f07SJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) 1749884d179dSJan Kara warntype_to[cnt] = QUOTA_NL_NOWARN; 1750884d179dSJan Kara down_write(&sb_dqopt(inode->i_sb)->dqptr_sem); 1751884d179dSJan Kara if (IS_NOQUOTA(inode)) { /* File without quota accounting? */ 1752884d179dSJan Kara up_write(&sb_dqopt(inode->i_sb)->dqptr_sem); 1753bc8e5f07SJan Kara return 0; 1754884d179dSJan Kara } 1755884d179dSJan Kara spin_lock(&dq_data_lock); 1756884d179dSJan Kara cur_space = inode_get_bytes(inode); 1757fd8fbfc1SDmitry Monakhov rsv_space = inode_get_rsv_space(inode); 1758884d179dSJan Kara space = cur_space + rsv_space; 1759884d179dSJan Kara /* Build the transfer_from list and check the limits */ 1760884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1761*9e32784bSDmitry /* 1762*9e32784bSDmitry * Skip changes for same uid or gid or for turned off quota-type. 1763*9e32784bSDmitry */ 1764dd6f3c6dSJan Kara if (!transfer_to[cnt]) 1765884d179dSJan Kara continue; 1766*9e32784bSDmitry /* Avoid races with quotaoff() */ 1767*9e32784bSDmitry if (!sb_has_quota_active(inode->i_sb, cnt)) 1768*9e32784bSDmitry continue; 1769*9e32784bSDmitry is_valid[cnt] = 1; 1770884d179dSJan Kara transfer_from[cnt] = inode->i_dquot[cnt]; 1771efd8f0e6SChristoph Hellwig ret = check_idq(transfer_to[cnt], 1, warntype_to + cnt); 1772efd8f0e6SChristoph Hellwig if (ret) 1773efd8f0e6SChristoph Hellwig goto over_quota; 1774efd8f0e6SChristoph Hellwig ret = check_bdq(transfer_to[cnt], space, 0, warntype_to + cnt); 1775efd8f0e6SChristoph Hellwig if (ret) 1776884d179dSJan Kara goto over_quota; 1777884d179dSJan Kara } 1778884d179dSJan Kara 1779884d179dSJan Kara /* 1780884d179dSJan Kara * Finally perform the needed transfer from transfer_from to transfer_to 1781884d179dSJan Kara */ 1782884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1783*9e32784bSDmitry if (!is_valid[cnt]) 1784884d179dSJan Kara continue; 1785884d179dSJan Kara /* Due to IO error we might not have transfer_from[] structure */ 1786884d179dSJan Kara if (transfer_from[cnt]) { 1787884d179dSJan Kara warntype_from_inodes[cnt] = 1788884d179dSJan Kara info_idq_free(transfer_from[cnt], 1); 1789884d179dSJan Kara warntype_from_space[cnt] = 1790884d179dSJan Kara info_bdq_free(transfer_from[cnt], space); 1791884d179dSJan Kara dquot_decr_inodes(transfer_from[cnt], 1); 1792884d179dSJan Kara dquot_decr_space(transfer_from[cnt], cur_space); 1793884d179dSJan Kara dquot_free_reserved_space(transfer_from[cnt], 1794884d179dSJan Kara rsv_space); 1795884d179dSJan Kara } 1796884d179dSJan Kara 1797884d179dSJan Kara dquot_incr_inodes(transfer_to[cnt], 1); 1798884d179dSJan Kara dquot_incr_space(transfer_to[cnt], cur_space); 1799884d179dSJan Kara dquot_resv_space(transfer_to[cnt], rsv_space); 1800884d179dSJan Kara 1801884d179dSJan Kara inode->i_dquot[cnt] = transfer_to[cnt]; 1802884d179dSJan Kara } 1803884d179dSJan Kara spin_unlock(&dq_data_lock); 1804884d179dSJan Kara up_write(&sb_dqopt(inode->i_sb)->dqptr_sem); 1805884d179dSJan Kara 1806dc52dd3aSDmitry Monakhov mark_all_dquot_dirty(transfer_from); 1807dc52dd3aSDmitry Monakhov mark_all_dquot_dirty(transfer_to); 1808bc8e5f07SJan Kara /* Pass back references to put */ 1809dc52dd3aSDmitry Monakhov for (cnt = 0; cnt < MAXQUOTAS; cnt++) 1810*9e32784bSDmitry if (is_valid[cnt]) 1811bc8e5f07SJan Kara transfer_to[cnt] = transfer_from[cnt]; 1812*9e32784bSDmitry 1813bc8e5f07SJan Kara warn: 1814884d179dSJan Kara flush_warnings(transfer_to, warntype_to); 1815884d179dSJan Kara flush_warnings(transfer_from, warntype_from_inodes); 1816884d179dSJan Kara flush_warnings(transfer_from, warntype_from_space); 1817884d179dSJan Kara return ret; 1818884d179dSJan Kara over_quota: 1819884d179dSJan Kara spin_unlock(&dq_data_lock); 1820884d179dSJan Kara up_write(&sb_dqopt(inode->i_sb)->dqptr_sem); 1821bc8e5f07SJan Kara goto warn; 1822884d179dSJan Kara } 1823bc8e5f07SJan Kara EXPORT_SYMBOL(__dquot_transfer); 1824884d179dSJan Kara 18258ddd69d6SDmitry Monakhov /* Wrapper for transferring ownership of an inode for uid/gid only 18268ddd69d6SDmitry Monakhov * Called from FSXXX_setattr() 18278ddd69d6SDmitry Monakhov */ 1828b43fa828SChristoph Hellwig int dquot_transfer(struct inode *inode, struct iattr *iattr) 1829884d179dSJan Kara { 1830bc8e5f07SJan Kara struct dquot *transfer_to[MAXQUOTAS] = {}; 1831bc8e5f07SJan Kara struct super_block *sb = inode->i_sb; 1832bc8e5f07SJan Kara int ret; 18338ddd69d6SDmitry Monakhov 1834189eef59SChristoph Hellwig if (!dquot_active(inode)) 1835884d179dSJan Kara return 0; 1836bc8e5f07SJan Kara 1837bc8e5f07SJan Kara if (iattr->ia_valid & ATTR_UID && iattr->ia_uid != inode->i_uid) 1838bc8e5f07SJan Kara transfer_to[USRQUOTA] = dqget(sb, iattr->ia_uid, USRQUOTA); 1839bc8e5f07SJan Kara if (iattr->ia_valid & ATTR_GID && iattr->ia_gid != inode->i_gid) 18404dea4969SJan Kara transfer_to[GRPQUOTA] = dqget(sb, iattr->ia_gid, GRPQUOTA); 1841bc8e5f07SJan Kara 1842bc8e5f07SJan Kara ret = __dquot_transfer(inode, transfer_to); 1843bc8e5f07SJan Kara dqput_all(transfer_to); 1844bc8e5f07SJan Kara return ret; 1845884d179dSJan Kara } 1846b43fa828SChristoph Hellwig EXPORT_SYMBOL(dquot_transfer); 1847884d179dSJan Kara 1848884d179dSJan Kara /* 1849884d179dSJan Kara * Write info of quota file to disk 1850884d179dSJan Kara */ 1851884d179dSJan Kara int dquot_commit_info(struct super_block *sb, int type) 1852884d179dSJan Kara { 1853884d179dSJan Kara int ret; 1854884d179dSJan Kara struct quota_info *dqopt = sb_dqopt(sb); 1855884d179dSJan Kara 1856884d179dSJan Kara mutex_lock(&dqopt->dqio_mutex); 1857884d179dSJan Kara ret = dqopt->ops[type]->write_file_info(sb, type); 1858884d179dSJan Kara mutex_unlock(&dqopt->dqio_mutex); 1859884d179dSJan Kara return ret; 1860884d179dSJan Kara } 1861884d179dSJan Kara EXPORT_SYMBOL(dquot_commit_info); 1862884d179dSJan Kara 1863884d179dSJan Kara /* 1864884d179dSJan Kara * Definitions of diskquota operations. 1865884d179dSJan Kara */ 186661e225dcSAlexey Dobriyan const struct dquot_operations dquot_operations = { 1867884d179dSJan Kara .write_dquot = dquot_commit, 1868884d179dSJan Kara .acquire_dquot = dquot_acquire, 1869884d179dSJan Kara .release_dquot = dquot_release, 1870884d179dSJan Kara .mark_dirty = dquot_mark_dquot_dirty, 1871884d179dSJan Kara .write_info = dquot_commit_info, 1872884d179dSJan Kara .alloc_dquot = dquot_alloc, 1873884d179dSJan Kara .destroy_dquot = dquot_destroy, 1874884d179dSJan Kara }; 1875123e9cafSChristoph Hellwig EXPORT_SYMBOL(dquot_operations); 1876884d179dSJan Kara 1877884d179dSJan Kara /* 1878907f4554SChristoph Hellwig * Generic helper for ->open on filesystems supporting disk quotas. 1879907f4554SChristoph Hellwig */ 1880907f4554SChristoph Hellwig int dquot_file_open(struct inode *inode, struct file *file) 1881907f4554SChristoph Hellwig { 1882907f4554SChristoph Hellwig int error; 1883907f4554SChristoph Hellwig 1884907f4554SChristoph Hellwig error = generic_file_open(inode, file); 1885907f4554SChristoph Hellwig if (!error && (file->f_mode & FMODE_WRITE)) 1886871a2931SChristoph Hellwig dquot_initialize(inode); 1887907f4554SChristoph Hellwig return error; 1888907f4554SChristoph Hellwig } 1889907f4554SChristoph Hellwig EXPORT_SYMBOL(dquot_file_open); 1890907f4554SChristoph Hellwig 1891907f4554SChristoph Hellwig /* 1892884d179dSJan Kara * Turn quota off on a device. type == -1 ==> quotaoff for all types (umount) 1893884d179dSJan Kara */ 18940f0dd62fSChristoph Hellwig int dquot_disable(struct super_block *sb, int type, unsigned int flags) 1895884d179dSJan Kara { 1896884d179dSJan Kara int cnt, ret = 0; 1897884d179dSJan Kara struct quota_info *dqopt = sb_dqopt(sb); 1898884d179dSJan Kara struct inode *toputinode[MAXQUOTAS]; 1899884d179dSJan Kara 1900884d179dSJan Kara /* Cannot turn off usage accounting without turning off limits, or 1901884d179dSJan Kara * suspend quotas and simultaneously turn quotas off. */ 1902884d179dSJan Kara if ((flags & DQUOT_USAGE_ENABLED && !(flags & DQUOT_LIMITS_ENABLED)) 1903884d179dSJan Kara || (flags & DQUOT_SUSPENDED && flags & (DQUOT_LIMITS_ENABLED | 1904884d179dSJan Kara DQUOT_USAGE_ENABLED))) 1905884d179dSJan Kara return -EINVAL; 1906884d179dSJan Kara 1907884d179dSJan Kara /* We need to serialize quota_off() for device */ 1908884d179dSJan Kara mutex_lock(&dqopt->dqonoff_mutex); 1909884d179dSJan Kara 1910884d179dSJan Kara /* 1911884d179dSJan Kara * Skip everything if there's nothing to do. We have to do this because 1912884d179dSJan Kara * sometimes we are called when fill_super() failed and calling 1913884d179dSJan Kara * sync_fs() in such cases does no good. 1914884d179dSJan Kara */ 1915884d179dSJan Kara if (!sb_any_quota_loaded(sb)) { 1916884d179dSJan Kara mutex_unlock(&dqopt->dqonoff_mutex); 1917884d179dSJan Kara return 0; 1918884d179dSJan Kara } 1919884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1920884d179dSJan Kara toputinode[cnt] = NULL; 1921884d179dSJan Kara if (type != -1 && cnt != type) 1922884d179dSJan Kara continue; 1923884d179dSJan Kara if (!sb_has_quota_loaded(sb, cnt)) 1924884d179dSJan Kara continue; 1925884d179dSJan Kara 1926884d179dSJan Kara if (flags & DQUOT_SUSPENDED) { 1927884d179dSJan Kara spin_lock(&dq_state_lock); 1928884d179dSJan Kara dqopt->flags |= 1929884d179dSJan Kara dquot_state_flag(DQUOT_SUSPENDED, cnt); 1930884d179dSJan Kara spin_unlock(&dq_state_lock); 1931884d179dSJan Kara } else { 1932884d179dSJan Kara spin_lock(&dq_state_lock); 1933884d179dSJan Kara dqopt->flags &= ~dquot_state_flag(flags, cnt); 1934884d179dSJan Kara /* Turning off suspended quotas? */ 1935884d179dSJan Kara if (!sb_has_quota_loaded(sb, cnt) && 1936884d179dSJan Kara sb_has_quota_suspended(sb, cnt)) { 1937884d179dSJan Kara dqopt->flags &= ~dquot_state_flag( 1938884d179dSJan Kara DQUOT_SUSPENDED, cnt); 1939884d179dSJan Kara spin_unlock(&dq_state_lock); 1940884d179dSJan Kara iput(dqopt->files[cnt]); 1941884d179dSJan Kara dqopt->files[cnt] = NULL; 1942884d179dSJan Kara continue; 1943884d179dSJan Kara } 1944884d179dSJan Kara spin_unlock(&dq_state_lock); 1945884d179dSJan Kara } 1946884d179dSJan Kara 1947884d179dSJan Kara /* We still have to keep quota loaded? */ 1948884d179dSJan Kara if (sb_has_quota_loaded(sb, cnt) && !(flags & DQUOT_SUSPENDED)) 1949884d179dSJan Kara continue; 1950884d179dSJan Kara 1951884d179dSJan Kara /* Note: these are blocking operations */ 1952884d179dSJan Kara drop_dquot_ref(sb, cnt); 1953884d179dSJan Kara invalidate_dquots(sb, cnt); 1954884d179dSJan Kara /* 1955268157baSJan Kara * Now all dquots should be invalidated, all writes done so we 1956268157baSJan Kara * should be only users of the info. No locks needed. 1957884d179dSJan Kara */ 1958884d179dSJan Kara if (info_dirty(&dqopt->info[cnt])) 1959884d179dSJan Kara sb->dq_op->write_info(sb, cnt); 1960884d179dSJan Kara if (dqopt->ops[cnt]->free_file_info) 1961884d179dSJan Kara dqopt->ops[cnt]->free_file_info(sb, cnt); 1962884d179dSJan Kara put_quota_format(dqopt->info[cnt].dqi_format); 1963884d179dSJan Kara 1964884d179dSJan Kara toputinode[cnt] = dqopt->files[cnt]; 1965884d179dSJan Kara if (!sb_has_quota_loaded(sb, cnt)) 1966884d179dSJan Kara dqopt->files[cnt] = NULL; 1967884d179dSJan Kara dqopt->info[cnt].dqi_flags = 0; 1968884d179dSJan Kara dqopt->info[cnt].dqi_igrace = 0; 1969884d179dSJan Kara dqopt->info[cnt].dqi_bgrace = 0; 1970884d179dSJan Kara dqopt->ops[cnt] = NULL; 1971884d179dSJan Kara } 1972884d179dSJan Kara mutex_unlock(&dqopt->dqonoff_mutex); 1973884d179dSJan Kara 1974884d179dSJan Kara /* Skip syncing and setting flags if quota files are hidden */ 1975884d179dSJan Kara if (dqopt->flags & DQUOT_QUOTA_SYS_FILE) 1976884d179dSJan Kara goto put_inodes; 1977884d179dSJan Kara 1978884d179dSJan Kara /* Sync the superblock so that buffers with quota data are written to 1979884d179dSJan Kara * disk (and so userspace sees correct data afterwards). */ 1980884d179dSJan Kara if (sb->s_op->sync_fs) 1981884d179dSJan Kara sb->s_op->sync_fs(sb, 1); 1982884d179dSJan Kara sync_blockdev(sb->s_bdev); 1983884d179dSJan Kara /* Now the quota files are just ordinary files and we can set the 1984884d179dSJan Kara * inode flags back. Moreover we discard the pagecache so that 1985884d179dSJan Kara * userspace sees the writes we did bypassing the pagecache. We 1986884d179dSJan Kara * must also discard the blockdev buffers so that we see the 1987884d179dSJan Kara * changes done by userspace on the next quotaon() */ 1988884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) 1989884d179dSJan Kara if (toputinode[cnt]) { 1990884d179dSJan Kara mutex_lock(&dqopt->dqonoff_mutex); 1991884d179dSJan Kara /* If quota was reenabled in the meantime, we have 1992884d179dSJan Kara * nothing to do */ 1993884d179dSJan Kara if (!sb_has_quota_loaded(sb, cnt)) { 1994268157baSJan Kara mutex_lock_nested(&toputinode[cnt]->i_mutex, 1995268157baSJan Kara I_MUTEX_QUOTA); 1996884d179dSJan Kara toputinode[cnt]->i_flags &= ~(S_IMMUTABLE | 1997884d179dSJan Kara S_NOATIME | S_NOQUOTA); 1998268157baSJan Kara truncate_inode_pages(&toputinode[cnt]->i_data, 1999268157baSJan Kara 0); 2000884d179dSJan Kara mutex_unlock(&toputinode[cnt]->i_mutex); 200143d2932dSJan Kara mark_inode_dirty_sync(toputinode[cnt]); 2002884d179dSJan Kara } 2003884d179dSJan Kara mutex_unlock(&dqopt->dqonoff_mutex); 2004884d179dSJan Kara } 2005884d179dSJan Kara if (sb->s_bdev) 2006884d179dSJan Kara invalidate_bdev(sb->s_bdev); 2007884d179dSJan Kara put_inodes: 2008884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) 2009884d179dSJan Kara if (toputinode[cnt]) { 2010884d179dSJan Kara /* On remount RO, we keep the inode pointer so that we 2011884d179dSJan Kara * can reenable quota on the subsequent remount RW. We 2012884d179dSJan Kara * have to check 'flags' variable and not use sb_has_ 2013884d179dSJan Kara * function because another quotaon / quotaoff could 2014884d179dSJan Kara * change global state before we got here. We refuse 2015884d179dSJan Kara * to suspend quotas when there is pending delete on 2016884d179dSJan Kara * the quota file... */ 2017884d179dSJan Kara if (!(flags & DQUOT_SUSPENDED)) 2018884d179dSJan Kara iput(toputinode[cnt]); 2019884d179dSJan Kara else if (!toputinode[cnt]->i_nlink) 2020884d179dSJan Kara ret = -EBUSY; 2021884d179dSJan Kara } 2022884d179dSJan Kara return ret; 2023884d179dSJan Kara } 20240f0dd62fSChristoph Hellwig EXPORT_SYMBOL(dquot_disable); 2025884d179dSJan Kara 2026287a8095SChristoph Hellwig int dquot_quota_off(struct super_block *sb, int type) 2027884d179dSJan Kara { 20280f0dd62fSChristoph Hellwig return dquot_disable(sb, type, 20290f0dd62fSChristoph Hellwig DQUOT_USAGE_ENABLED | DQUOT_LIMITS_ENABLED); 2030884d179dSJan Kara } 2031287a8095SChristoph Hellwig EXPORT_SYMBOL(dquot_quota_off); 20320f0dd62fSChristoph Hellwig 2033884d179dSJan Kara /* 2034884d179dSJan Kara * Turn quotas on on a device 2035884d179dSJan Kara */ 2036884d179dSJan Kara 2037884d179dSJan Kara /* 2038884d179dSJan Kara * Helper function to turn quotas on when we already have the inode of 2039884d179dSJan Kara * quota file and no quota information is loaded. 2040884d179dSJan Kara */ 2041884d179dSJan Kara static int vfs_load_quota_inode(struct inode *inode, int type, int format_id, 2042884d179dSJan Kara unsigned int flags) 2043884d179dSJan Kara { 2044884d179dSJan Kara struct quota_format_type *fmt = find_quota_format(format_id); 2045884d179dSJan Kara struct super_block *sb = inode->i_sb; 2046884d179dSJan Kara struct quota_info *dqopt = sb_dqopt(sb); 2047884d179dSJan Kara int error; 2048884d179dSJan Kara int oldflags = -1; 2049884d179dSJan Kara 2050884d179dSJan Kara if (!fmt) 2051884d179dSJan Kara return -ESRCH; 2052884d179dSJan Kara if (!S_ISREG(inode->i_mode)) { 2053884d179dSJan Kara error = -EACCES; 2054884d179dSJan Kara goto out_fmt; 2055884d179dSJan Kara } 2056884d179dSJan Kara if (IS_RDONLY(inode)) { 2057884d179dSJan Kara error = -EROFS; 2058884d179dSJan Kara goto out_fmt; 2059884d179dSJan Kara } 2060884d179dSJan Kara if (!sb->s_op->quota_write || !sb->s_op->quota_read) { 2061884d179dSJan Kara error = -EINVAL; 2062884d179dSJan Kara goto out_fmt; 2063884d179dSJan Kara } 2064884d179dSJan Kara /* Usage always has to be set... */ 2065884d179dSJan Kara if (!(flags & DQUOT_USAGE_ENABLED)) { 2066884d179dSJan Kara error = -EINVAL; 2067884d179dSJan Kara goto out_fmt; 2068884d179dSJan Kara } 2069884d179dSJan Kara 2070884d179dSJan Kara if (!(dqopt->flags & DQUOT_QUOTA_SYS_FILE)) { 2071ab94c39bSJan Kara /* As we bypass the pagecache we must now flush all the 2072ab94c39bSJan Kara * dirty data and invalidate caches so that kernel sees 2073ab94c39bSJan Kara * changes from userspace. It is not enough to just flush 2074ab94c39bSJan Kara * the quota file since if blocksize < pagesize, invalidation 2075ab94c39bSJan Kara * of the cache could fail because of other unrelated dirty 2076ab94c39bSJan Kara * data */ 2077ab94c39bSJan Kara sync_filesystem(sb); 2078884d179dSJan Kara invalidate_bdev(sb->s_bdev); 2079884d179dSJan Kara } 2080884d179dSJan Kara mutex_lock(&dqopt->dqonoff_mutex); 2081884d179dSJan Kara if (sb_has_quota_loaded(sb, type)) { 2082884d179dSJan Kara error = -EBUSY; 2083884d179dSJan Kara goto out_lock; 2084884d179dSJan Kara } 2085884d179dSJan Kara 2086884d179dSJan Kara if (!(dqopt->flags & DQUOT_QUOTA_SYS_FILE)) { 2087884d179dSJan Kara /* We don't want quota and atime on quota files (deadlocks 2088884d179dSJan Kara * possible) Also nobody should write to the file - we use 2089884d179dSJan Kara * special IO operations which ignore the immutable bit. */ 2090dee86565SJan Kara mutex_lock_nested(&inode->i_mutex, I_MUTEX_QUOTA); 2091268157baSJan Kara oldflags = inode->i_flags & (S_NOATIME | S_IMMUTABLE | 2092268157baSJan Kara S_NOQUOTA); 2093884d179dSJan Kara inode->i_flags |= S_NOQUOTA | S_NOATIME | S_IMMUTABLE; 2094dee86565SJan Kara mutex_unlock(&inode->i_mutex); 209526245c94SJan Kara /* 209626245c94SJan Kara * When S_NOQUOTA is set, remove dquot references as no more 209726245c94SJan Kara * references can be added 209826245c94SJan Kara */ 20999f754758SChristoph Hellwig __dquot_drop(inode); 2100884d179dSJan Kara } 2101884d179dSJan Kara 2102884d179dSJan Kara error = -EIO; 2103884d179dSJan Kara dqopt->files[type] = igrab(inode); 2104884d179dSJan Kara if (!dqopt->files[type]) 2105884d179dSJan Kara goto out_lock; 2106884d179dSJan Kara error = -EINVAL; 2107884d179dSJan Kara if (!fmt->qf_ops->check_quota_file(sb, type)) 2108884d179dSJan Kara goto out_file_init; 2109884d179dSJan Kara 2110884d179dSJan Kara dqopt->ops[type] = fmt->qf_ops; 2111884d179dSJan Kara dqopt->info[type].dqi_format = fmt; 2112884d179dSJan Kara dqopt->info[type].dqi_fmt_id = format_id; 2113884d179dSJan Kara INIT_LIST_HEAD(&dqopt->info[type].dqi_dirty_list); 2114884d179dSJan Kara mutex_lock(&dqopt->dqio_mutex); 2115268157baSJan Kara error = dqopt->ops[type]->read_file_info(sb, type); 2116268157baSJan Kara if (error < 0) { 2117884d179dSJan Kara mutex_unlock(&dqopt->dqio_mutex); 2118884d179dSJan Kara goto out_file_init; 2119884d179dSJan Kara } 2120884d179dSJan Kara mutex_unlock(&dqopt->dqio_mutex); 2121884d179dSJan Kara spin_lock(&dq_state_lock); 2122884d179dSJan Kara dqopt->flags |= dquot_state_flag(flags, type); 2123884d179dSJan Kara spin_unlock(&dq_state_lock); 2124884d179dSJan Kara 2125884d179dSJan Kara add_dquot_ref(sb, type); 2126884d179dSJan Kara mutex_unlock(&dqopt->dqonoff_mutex); 2127884d179dSJan Kara 2128884d179dSJan Kara return 0; 2129884d179dSJan Kara 2130884d179dSJan Kara out_file_init: 2131884d179dSJan Kara dqopt->files[type] = NULL; 2132884d179dSJan Kara iput(inode); 2133884d179dSJan Kara out_lock: 2134884d179dSJan Kara if (oldflags != -1) { 2135dee86565SJan Kara mutex_lock_nested(&inode->i_mutex, I_MUTEX_QUOTA); 2136884d179dSJan Kara /* Set the flags back (in the case of accidental quotaon() 2137884d179dSJan Kara * on a wrong file we don't want to mess up the flags) */ 2138884d179dSJan Kara inode->i_flags &= ~(S_NOATIME | S_NOQUOTA | S_IMMUTABLE); 2139884d179dSJan Kara inode->i_flags |= oldflags; 2140dee86565SJan Kara mutex_unlock(&inode->i_mutex); 2141884d179dSJan Kara } 2142d01730d7SJiaying Zhang mutex_unlock(&dqopt->dqonoff_mutex); 2143884d179dSJan Kara out_fmt: 2144884d179dSJan Kara put_quota_format(fmt); 2145884d179dSJan Kara 2146884d179dSJan Kara return error; 2147884d179dSJan Kara } 2148884d179dSJan Kara 2149884d179dSJan Kara /* Reenable quotas on remount RW */ 21500f0dd62fSChristoph Hellwig int dquot_resume(struct super_block *sb, int type) 2151884d179dSJan Kara { 2152884d179dSJan Kara struct quota_info *dqopt = sb_dqopt(sb); 2153884d179dSJan Kara struct inode *inode; 21540f0dd62fSChristoph Hellwig int ret = 0, cnt; 2155884d179dSJan Kara unsigned int flags; 2156884d179dSJan Kara 21570f0dd62fSChristoph Hellwig for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 21580f0dd62fSChristoph Hellwig if (type != -1 && cnt != type) 21590f0dd62fSChristoph Hellwig continue; 21600f0dd62fSChristoph Hellwig 2161884d179dSJan Kara mutex_lock(&dqopt->dqonoff_mutex); 21620f0dd62fSChristoph Hellwig if (!sb_has_quota_suspended(sb, cnt)) { 2163884d179dSJan Kara mutex_unlock(&dqopt->dqonoff_mutex); 21640f0dd62fSChristoph Hellwig continue; 2165884d179dSJan Kara } 21660f0dd62fSChristoph Hellwig inode = dqopt->files[cnt]; 21670f0dd62fSChristoph Hellwig dqopt->files[cnt] = NULL; 2168884d179dSJan Kara spin_lock(&dq_state_lock); 2169884d179dSJan Kara flags = dqopt->flags & dquot_state_flag(DQUOT_USAGE_ENABLED | 21700f0dd62fSChristoph Hellwig DQUOT_LIMITS_ENABLED, 21710f0dd62fSChristoph Hellwig cnt); 21720f0dd62fSChristoph Hellwig dqopt->flags &= ~dquot_state_flag(DQUOT_STATE_FLAGS, cnt); 2173884d179dSJan Kara spin_unlock(&dq_state_lock); 2174884d179dSJan Kara mutex_unlock(&dqopt->dqonoff_mutex); 2175884d179dSJan Kara 21760f0dd62fSChristoph Hellwig flags = dquot_generic_flag(flags, cnt); 21770f0dd62fSChristoph Hellwig ret = vfs_load_quota_inode(inode, cnt, 21780f0dd62fSChristoph Hellwig dqopt->info[cnt].dqi_fmt_id, flags); 2179884d179dSJan Kara iput(inode); 21800f0dd62fSChristoph Hellwig } 2181884d179dSJan Kara 2182884d179dSJan Kara return ret; 2183884d179dSJan Kara } 21840f0dd62fSChristoph Hellwig EXPORT_SYMBOL(dquot_resume); 2185884d179dSJan Kara 2186287a8095SChristoph Hellwig int dquot_quota_on_path(struct super_block *sb, int type, int format_id, 2187884d179dSJan Kara struct path *path) 2188884d179dSJan Kara { 2189884d179dSJan Kara int error = security_quota_on(path->dentry); 2190884d179dSJan Kara if (error) 2191884d179dSJan Kara return error; 2192884d179dSJan Kara /* Quota file not on the same filesystem? */ 2193884d179dSJan Kara if (path->mnt->mnt_sb != sb) 2194884d179dSJan Kara error = -EXDEV; 2195884d179dSJan Kara else 2196884d179dSJan Kara error = vfs_load_quota_inode(path->dentry->d_inode, type, 2197884d179dSJan Kara format_id, DQUOT_USAGE_ENABLED | 2198884d179dSJan Kara DQUOT_LIMITS_ENABLED); 2199884d179dSJan Kara return error; 2200884d179dSJan Kara } 2201287a8095SChristoph Hellwig EXPORT_SYMBOL(dquot_quota_on_path); 2202884d179dSJan Kara 2203287a8095SChristoph Hellwig int dquot_quota_on(struct super_block *sb, int type, int format_id, char *name) 2204884d179dSJan Kara { 2205884d179dSJan Kara struct path path; 2206884d179dSJan Kara int error; 2207884d179dSJan Kara 2208884d179dSJan Kara error = kern_path(name, LOOKUP_FOLLOW, &path); 2209884d179dSJan Kara if (!error) { 2210287a8095SChristoph Hellwig error = dquot_quota_on_path(sb, type, format_id, &path); 2211884d179dSJan Kara path_put(&path); 2212884d179dSJan Kara } 2213884d179dSJan Kara return error; 2214884d179dSJan Kara } 2215287a8095SChristoph Hellwig EXPORT_SYMBOL(dquot_quota_on); 2216884d179dSJan Kara 2217884d179dSJan Kara /* 2218884d179dSJan Kara * More powerful function for turning on quotas allowing setting 2219884d179dSJan Kara * of individual quota flags 2220884d179dSJan Kara */ 2221287a8095SChristoph Hellwig int dquot_enable(struct inode *inode, int type, int format_id, 2222884d179dSJan Kara unsigned int flags) 2223884d179dSJan Kara { 2224884d179dSJan Kara int ret = 0; 2225884d179dSJan Kara struct super_block *sb = inode->i_sb; 2226884d179dSJan Kara struct quota_info *dqopt = sb_dqopt(sb); 2227884d179dSJan Kara 2228884d179dSJan Kara /* Just unsuspend quotas? */ 22290f0dd62fSChristoph Hellwig BUG_ON(flags & DQUOT_SUSPENDED); 22300f0dd62fSChristoph Hellwig 2231884d179dSJan Kara if (!flags) 2232884d179dSJan Kara return 0; 2233884d179dSJan Kara /* Just updating flags needed? */ 2234884d179dSJan Kara if (sb_has_quota_loaded(sb, type)) { 2235884d179dSJan Kara mutex_lock(&dqopt->dqonoff_mutex); 2236884d179dSJan Kara /* Now do a reliable test... */ 2237884d179dSJan Kara if (!sb_has_quota_loaded(sb, type)) { 2238884d179dSJan Kara mutex_unlock(&dqopt->dqonoff_mutex); 2239884d179dSJan Kara goto load_quota; 2240884d179dSJan Kara } 2241884d179dSJan Kara if (flags & DQUOT_USAGE_ENABLED && 2242884d179dSJan Kara sb_has_quota_usage_enabled(sb, type)) { 2243884d179dSJan Kara ret = -EBUSY; 2244884d179dSJan Kara goto out_lock; 2245884d179dSJan Kara } 2246884d179dSJan Kara if (flags & DQUOT_LIMITS_ENABLED && 2247884d179dSJan Kara sb_has_quota_limits_enabled(sb, type)) { 2248884d179dSJan Kara ret = -EBUSY; 2249884d179dSJan Kara goto out_lock; 2250884d179dSJan Kara } 2251884d179dSJan Kara spin_lock(&dq_state_lock); 2252884d179dSJan Kara sb_dqopt(sb)->flags |= dquot_state_flag(flags, type); 2253884d179dSJan Kara spin_unlock(&dq_state_lock); 2254884d179dSJan Kara out_lock: 2255884d179dSJan Kara mutex_unlock(&dqopt->dqonoff_mutex); 2256884d179dSJan Kara return ret; 2257884d179dSJan Kara } 2258884d179dSJan Kara 2259884d179dSJan Kara load_quota: 2260884d179dSJan Kara return vfs_load_quota_inode(inode, type, format_id, flags); 2261884d179dSJan Kara } 2262287a8095SChristoph Hellwig EXPORT_SYMBOL(dquot_enable); 2263884d179dSJan Kara 2264884d179dSJan Kara /* 2265884d179dSJan Kara * This function is used when filesystem needs to initialize quotas 2266884d179dSJan Kara * during mount time. 2267884d179dSJan Kara */ 2268287a8095SChristoph Hellwig int dquot_quota_on_mount(struct super_block *sb, char *qf_name, 2269884d179dSJan Kara int format_id, int type) 2270884d179dSJan Kara { 2271884d179dSJan Kara struct dentry *dentry; 2272884d179dSJan Kara int error; 2273884d179dSJan Kara 2274c56818d7SJan Kara mutex_lock(&sb->s_root->d_inode->i_mutex); 2275884d179dSJan Kara dentry = lookup_one_len(qf_name, sb->s_root, strlen(qf_name)); 2276c56818d7SJan Kara mutex_unlock(&sb->s_root->d_inode->i_mutex); 2277884d179dSJan Kara if (IS_ERR(dentry)) 2278884d179dSJan Kara return PTR_ERR(dentry); 2279884d179dSJan Kara 2280884d179dSJan Kara if (!dentry->d_inode) { 2281884d179dSJan Kara error = -ENOENT; 2282884d179dSJan Kara goto out; 2283884d179dSJan Kara } 2284884d179dSJan Kara 2285884d179dSJan Kara error = security_quota_on(dentry); 2286884d179dSJan Kara if (!error) 2287884d179dSJan Kara error = vfs_load_quota_inode(dentry->d_inode, type, format_id, 2288884d179dSJan Kara DQUOT_USAGE_ENABLED | DQUOT_LIMITS_ENABLED); 2289884d179dSJan Kara 2290884d179dSJan Kara out: 2291884d179dSJan Kara dput(dentry); 2292884d179dSJan Kara return error; 2293884d179dSJan Kara } 2294287a8095SChristoph Hellwig EXPORT_SYMBOL(dquot_quota_on_mount); 2295884d179dSJan Kara 2296884d179dSJan Kara static inline qsize_t qbtos(qsize_t blocks) 2297884d179dSJan Kara { 2298884d179dSJan Kara return blocks << QIF_DQBLKSIZE_BITS; 2299884d179dSJan Kara } 2300884d179dSJan Kara 2301884d179dSJan Kara static inline qsize_t stoqb(qsize_t space) 2302884d179dSJan Kara { 2303884d179dSJan Kara return (space + QIF_DQBLKSIZE - 1) >> QIF_DQBLKSIZE_BITS; 2304884d179dSJan Kara } 2305884d179dSJan Kara 2306884d179dSJan Kara /* Generic routine for getting common part of quota structure */ 2307b9b2dd36SChristoph Hellwig static void do_get_dqblk(struct dquot *dquot, struct fs_disk_quota *di) 2308884d179dSJan Kara { 2309884d179dSJan Kara struct mem_dqblk *dm = &dquot->dq_dqb; 2310884d179dSJan Kara 2311b9b2dd36SChristoph Hellwig memset(di, 0, sizeof(*di)); 2312b9b2dd36SChristoph Hellwig di->d_version = FS_DQUOT_VERSION; 2313b9b2dd36SChristoph Hellwig di->d_flags = dquot->dq_type == USRQUOTA ? 2314ade7ce31SChristoph Hellwig FS_USER_QUOTA : FS_GROUP_QUOTA; 2315b9b2dd36SChristoph Hellwig di->d_id = dquot->dq_id; 2316b9b2dd36SChristoph Hellwig 2317884d179dSJan Kara spin_lock(&dq_data_lock); 2318b9b2dd36SChristoph Hellwig di->d_blk_hardlimit = stoqb(dm->dqb_bhardlimit); 2319b9b2dd36SChristoph Hellwig di->d_blk_softlimit = stoqb(dm->dqb_bsoftlimit); 2320b9b2dd36SChristoph Hellwig di->d_ino_hardlimit = dm->dqb_ihardlimit; 2321b9b2dd36SChristoph Hellwig di->d_ino_softlimit = dm->dqb_isoftlimit; 2322b9b2dd36SChristoph Hellwig di->d_bcount = dm->dqb_curspace + dm->dqb_rsvspace; 2323b9b2dd36SChristoph Hellwig di->d_icount = dm->dqb_curinodes; 2324b9b2dd36SChristoph Hellwig di->d_btimer = dm->dqb_btime; 2325b9b2dd36SChristoph Hellwig di->d_itimer = dm->dqb_itime; 2326884d179dSJan Kara spin_unlock(&dq_data_lock); 2327884d179dSJan Kara } 2328884d179dSJan Kara 2329287a8095SChristoph Hellwig int dquot_get_dqblk(struct super_block *sb, int type, qid_t id, 2330b9b2dd36SChristoph Hellwig struct fs_disk_quota *di) 2331884d179dSJan Kara { 2332884d179dSJan Kara struct dquot *dquot; 2333884d179dSJan Kara 2334884d179dSJan Kara dquot = dqget(sb, id, type); 2335dd6f3c6dSJan Kara if (!dquot) 2336884d179dSJan Kara return -ESRCH; 2337884d179dSJan Kara do_get_dqblk(dquot, di); 2338884d179dSJan Kara dqput(dquot); 2339884d179dSJan Kara 2340884d179dSJan Kara return 0; 2341884d179dSJan Kara } 2342287a8095SChristoph Hellwig EXPORT_SYMBOL(dquot_get_dqblk); 2343884d179dSJan Kara 2344c472b432SChristoph Hellwig #define VFS_FS_DQ_MASK \ 2345c472b432SChristoph Hellwig (FS_DQ_BCOUNT | FS_DQ_BSOFT | FS_DQ_BHARD | \ 2346c472b432SChristoph Hellwig FS_DQ_ICOUNT | FS_DQ_ISOFT | FS_DQ_IHARD | \ 2347c472b432SChristoph Hellwig FS_DQ_BTIMER | FS_DQ_ITIMER) 2348c472b432SChristoph Hellwig 2349884d179dSJan Kara /* Generic routine for setting common part of quota structure */ 2350c472b432SChristoph Hellwig static int do_set_dqblk(struct dquot *dquot, struct fs_disk_quota *di) 2351884d179dSJan Kara { 2352884d179dSJan Kara struct mem_dqblk *dm = &dquot->dq_dqb; 2353884d179dSJan Kara int check_blim = 0, check_ilim = 0; 2354884d179dSJan Kara struct mem_dqinfo *dqi = &sb_dqopt(dquot->dq_sb)->info[dquot->dq_type]; 2355884d179dSJan Kara 2356c472b432SChristoph Hellwig if (di->d_fieldmask & ~VFS_FS_DQ_MASK) 2357c472b432SChristoph Hellwig return -EINVAL; 2358c472b432SChristoph Hellwig 2359c472b432SChristoph Hellwig if (((di->d_fieldmask & FS_DQ_BSOFT) && 2360c472b432SChristoph Hellwig (di->d_blk_softlimit > dqi->dqi_maxblimit)) || 2361c472b432SChristoph Hellwig ((di->d_fieldmask & FS_DQ_BHARD) && 2362c472b432SChristoph Hellwig (di->d_blk_hardlimit > dqi->dqi_maxblimit)) || 2363c472b432SChristoph Hellwig ((di->d_fieldmask & FS_DQ_ISOFT) && 2364c472b432SChristoph Hellwig (di->d_ino_softlimit > dqi->dqi_maxilimit)) || 2365c472b432SChristoph Hellwig ((di->d_fieldmask & FS_DQ_IHARD) && 2366c472b432SChristoph Hellwig (di->d_ino_hardlimit > dqi->dqi_maxilimit))) 2367884d179dSJan Kara return -ERANGE; 2368884d179dSJan Kara 2369884d179dSJan Kara spin_lock(&dq_data_lock); 2370c472b432SChristoph Hellwig if (di->d_fieldmask & FS_DQ_BCOUNT) { 2371c472b432SChristoph Hellwig dm->dqb_curspace = di->d_bcount - dm->dqb_rsvspace; 2372884d179dSJan Kara check_blim = 1; 237308261673SAndrew Perepechko set_bit(DQ_LASTSET_B + QIF_SPACE_B, &dquot->dq_flags); 2374884d179dSJan Kara } 2375c472b432SChristoph Hellwig 2376c472b432SChristoph Hellwig if (di->d_fieldmask & FS_DQ_BSOFT) 2377c472b432SChristoph Hellwig dm->dqb_bsoftlimit = qbtos(di->d_blk_softlimit); 2378c472b432SChristoph Hellwig if (di->d_fieldmask & FS_DQ_BHARD) 2379c472b432SChristoph Hellwig dm->dqb_bhardlimit = qbtos(di->d_blk_hardlimit); 2380c472b432SChristoph Hellwig if (di->d_fieldmask & (FS_DQ_BSOFT | FS_DQ_BHARD)) { 2381884d179dSJan Kara check_blim = 1; 238208261673SAndrew Perepechko set_bit(DQ_LASTSET_B + QIF_BLIMITS_B, &dquot->dq_flags); 2383884d179dSJan Kara } 2384c472b432SChristoph Hellwig 2385c472b432SChristoph Hellwig if (di->d_fieldmask & FS_DQ_ICOUNT) { 2386c472b432SChristoph Hellwig dm->dqb_curinodes = di->d_icount; 2387884d179dSJan Kara check_ilim = 1; 238808261673SAndrew Perepechko set_bit(DQ_LASTSET_B + QIF_INODES_B, &dquot->dq_flags); 2389884d179dSJan Kara } 2390c472b432SChristoph Hellwig 2391c472b432SChristoph Hellwig if (di->d_fieldmask & FS_DQ_ISOFT) 2392c472b432SChristoph Hellwig dm->dqb_isoftlimit = di->d_ino_softlimit; 2393c472b432SChristoph Hellwig if (di->d_fieldmask & FS_DQ_IHARD) 2394c472b432SChristoph Hellwig dm->dqb_ihardlimit = di->d_ino_hardlimit; 2395c472b432SChristoph Hellwig if (di->d_fieldmask & (FS_DQ_ISOFT | FS_DQ_IHARD)) { 2396884d179dSJan Kara check_ilim = 1; 239708261673SAndrew Perepechko set_bit(DQ_LASTSET_B + QIF_ILIMITS_B, &dquot->dq_flags); 2398884d179dSJan Kara } 2399c472b432SChristoph Hellwig 2400c472b432SChristoph Hellwig if (di->d_fieldmask & FS_DQ_BTIMER) { 2401c472b432SChristoph Hellwig dm->dqb_btime = di->d_btimer; 2402884d179dSJan Kara check_blim = 1; 240308261673SAndrew Perepechko set_bit(DQ_LASTSET_B + QIF_BTIME_B, &dquot->dq_flags); 2404884d179dSJan Kara } 2405c472b432SChristoph Hellwig 2406c472b432SChristoph Hellwig if (di->d_fieldmask & FS_DQ_ITIMER) { 2407c472b432SChristoph Hellwig dm->dqb_itime = di->d_itimer; 2408884d179dSJan Kara check_ilim = 1; 240908261673SAndrew Perepechko set_bit(DQ_LASTSET_B + QIF_ITIME_B, &dquot->dq_flags); 2410884d179dSJan Kara } 2411884d179dSJan Kara 2412884d179dSJan Kara if (check_blim) { 2413268157baSJan Kara if (!dm->dqb_bsoftlimit || 2414268157baSJan Kara dm->dqb_curspace < dm->dqb_bsoftlimit) { 2415884d179dSJan Kara dm->dqb_btime = 0; 2416884d179dSJan Kara clear_bit(DQ_BLKS_B, &dquot->dq_flags); 2417c472b432SChristoph Hellwig } else if (!(di->d_fieldmask & FS_DQ_BTIMER)) 2418268157baSJan Kara /* Set grace only if user hasn't provided his own... */ 2419884d179dSJan Kara dm->dqb_btime = get_seconds() + dqi->dqi_bgrace; 2420884d179dSJan Kara } 2421884d179dSJan Kara if (check_ilim) { 2422268157baSJan Kara if (!dm->dqb_isoftlimit || 2423268157baSJan Kara dm->dqb_curinodes < dm->dqb_isoftlimit) { 2424884d179dSJan Kara dm->dqb_itime = 0; 2425884d179dSJan Kara clear_bit(DQ_INODES_B, &dquot->dq_flags); 2426c472b432SChristoph Hellwig } else if (!(di->d_fieldmask & FS_DQ_ITIMER)) 2427268157baSJan Kara /* Set grace only if user hasn't provided his own... */ 2428884d179dSJan Kara dm->dqb_itime = get_seconds() + dqi->dqi_igrace; 2429884d179dSJan Kara } 2430268157baSJan Kara if (dm->dqb_bhardlimit || dm->dqb_bsoftlimit || dm->dqb_ihardlimit || 2431268157baSJan Kara dm->dqb_isoftlimit) 2432884d179dSJan Kara clear_bit(DQ_FAKE_B, &dquot->dq_flags); 2433884d179dSJan Kara else 2434884d179dSJan Kara set_bit(DQ_FAKE_B, &dquot->dq_flags); 2435884d179dSJan Kara spin_unlock(&dq_data_lock); 2436884d179dSJan Kara mark_dquot_dirty(dquot); 2437884d179dSJan Kara 2438884d179dSJan Kara return 0; 2439884d179dSJan Kara } 2440884d179dSJan Kara 2441287a8095SChristoph Hellwig int dquot_set_dqblk(struct super_block *sb, int type, qid_t id, 2442c472b432SChristoph Hellwig struct fs_disk_quota *di) 2443884d179dSJan Kara { 2444884d179dSJan Kara struct dquot *dquot; 2445884d179dSJan Kara int rc; 2446884d179dSJan Kara 2447884d179dSJan Kara dquot = dqget(sb, id, type); 2448884d179dSJan Kara if (!dquot) { 2449884d179dSJan Kara rc = -ESRCH; 2450884d179dSJan Kara goto out; 2451884d179dSJan Kara } 2452884d179dSJan Kara rc = do_set_dqblk(dquot, di); 2453884d179dSJan Kara dqput(dquot); 2454884d179dSJan Kara out: 2455884d179dSJan Kara return rc; 2456884d179dSJan Kara } 2457287a8095SChristoph Hellwig EXPORT_SYMBOL(dquot_set_dqblk); 2458884d179dSJan Kara 2459884d179dSJan Kara /* Generic routine for getting common part of quota file information */ 2460287a8095SChristoph Hellwig int dquot_get_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii) 2461884d179dSJan Kara { 2462884d179dSJan Kara struct mem_dqinfo *mi; 2463884d179dSJan Kara 2464884d179dSJan Kara mutex_lock(&sb_dqopt(sb)->dqonoff_mutex); 2465884d179dSJan Kara if (!sb_has_quota_active(sb, type)) { 2466884d179dSJan Kara mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex); 2467884d179dSJan Kara return -ESRCH; 2468884d179dSJan Kara } 2469884d179dSJan Kara mi = sb_dqopt(sb)->info + type; 2470884d179dSJan Kara spin_lock(&dq_data_lock); 2471884d179dSJan Kara ii->dqi_bgrace = mi->dqi_bgrace; 2472884d179dSJan Kara ii->dqi_igrace = mi->dqi_igrace; 2473884d179dSJan Kara ii->dqi_flags = mi->dqi_flags & DQF_MASK; 2474884d179dSJan Kara ii->dqi_valid = IIF_ALL; 2475884d179dSJan Kara spin_unlock(&dq_data_lock); 2476884d179dSJan Kara mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex); 2477884d179dSJan Kara return 0; 2478884d179dSJan Kara } 2479287a8095SChristoph Hellwig EXPORT_SYMBOL(dquot_get_dqinfo); 2480884d179dSJan Kara 2481884d179dSJan Kara /* Generic routine for setting common part of quota file information */ 2482287a8095SChristoph Hellwig int dquot_set_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii) 2483884d179dSJan Kara { 2484884d179dSJan Kara struct mem_dqinfo *mi; 2485884d179dSJan Kara int err = 0; 2486884d179dSJan Kara 2487884d179dSJan Kara mutex_lock(&sb_dqopt(sb)->dqonoff_mutex); 2488884d179dSJan Kara if (!sb_has_quota_active(sb, type)) { 2489884d179dSJan Kara err = -ESRCH; 2490884d179dSJan Kara goto out; 2491884d179dSJan Kara } 2492884d179dSJan Kara mi = sb_dqopt(sb)->info + type; 2493884d179dSJan Kara spin_lock(&dq_data_lock); 2494884d179dSJan Kara if (ii->dqi_valid & IIF_BGRACE) 2495884d179dSJan Kara mi->dqi_bgrace = ii->dqi_bgrace; 2496884d179dSJan Kara if (ii->dqi_valid & IIF_IGRACE) 2497884d179dSJan Kara mi->dqi_igrace = ii->dqi_igrace; 2498884d179dSJan Kara if (ii->dqi_valid & IIF_FLAGS) 2499268157baSJan Kara mi->dqi_flags = (mi->dqi_flags & ~DQF_MASK) | 2500268157baSJan Kara (ii->dqi_flags & DQF_MASK); 2501884d179dSJan Kara spin_unlock(&dq_data_lock); 2502884d179dSJan Kara mark_info_dirty(sb, type); 2503884d179dSJan Kara /* Force write to disk */ 2504884d179dSJan Kara sb->dq_op->write_info(sb, type); 2505884d179dSJan Kara out: 2506884d179dSJan Kara mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex); 2507884d179dSJan Kara return err; 2508884d179dSJan Kara } 2509287a8095SChristoph Hellwig EXPORT_SYMBOL(dquot_set_dqinfo); 2510884d179dSJan Kara 2511287a8095SChristoph Hellwig const struct quotactl_ops dquot_quotactl_ops = { 2512287a8095SChristoph Hellwig .quota_on = dquot_quota_on, 2513287a8095SChristoph Hellwig .quota_off = dquot_quota_off, 2514287a8095SChristoph Hellwig .quota_sync = dquot_quota_sync, 2515287a8095SChristoph Hellwig .get_info = dquot_get_dqinfo, 2516287a8095SChristoph Hellwig .set_info = dquot_set_dqinfo, 2517287a8095SChristoph Hellwig .get_dqblk = dquot_get_dqblk, 2518287a8095SChristoph Hellwig .set_dqblk = dquot_set_dqblk 2519884d179dSJan Kara }; 2520287a8095SChristoph Hellwig EXPORT_SYMBOL(dquot_quotactl_ops); 2521dde95888SDmitry Monakhov 2522dde95888SDmitry Monakhov static int do_proc_dqstats(struct ctl_table *table, int write, 2523dde95888SDmitry Monakhov void __user *buffer, size_t *lenp, loff_t *ppos) 2524dde95888SDmitry Monakhov { 2525dde95888SDmitry Monakhov unsigned int type = (int *)table->data - dqstats.stat; 2526f32764bdSDmitry Monakhov 2527f32764bdSDmitry Monakhov /* Update global table */ 2528f32764bdSDmitry Monakhov dqstats.stat[type] = 2529f32764bdSDmitry Monakhov percpu_counter_sum_positive(&dqstats.counter[type]); 2530dde95888SDmitry Monakhov return proc_dointvec(table, write, buffer, lenp, ppos); 2531dde95888SDmitry Monakhov } 2532dde95888SDmitry Monakhov 2533884d179dSJan Kara static ctl_table fs_dqstats_table[] = { 2534884d179dSJan Kara { 2535884d179dSJan Kara .procname = "lookups", 2536dde95888SDmitry Monakhov .data = &dqstats.stat[DQST_LOOKUPS], 2537884d179dSJan Kara .maxlen = sizeof(int), 2538884d179dSJan Kara .mode = 0444, 2539dde95888SDmitry Monakhov .proc_handler = do_proc_dqstats, 2540884d179dSJan Kara }, 2541884d179dSJan Kara { 2542884d179dSJan Kara .procname = "drops", 2543dde95888SDmitry Monakhov .data = &dqstats.stat[DQST_DROPS], 2544884d179dSJan Kara .maxlen = sizeof(int), 2545884d179dSJan Kara .mode = 0444, 2546dde95888SDmitry Monakhov .proc_handler = do_proc_dqstats, 2547884d179dSJan Kara }, 2548884d179dSJan Kara { 2549884d179dSJan Kara .procname = "reads", 2550dde95888SDmitry Monakhov .data = &dqstats.stat[DQST_READS], 2551884d179dSJan Kara .maxlen = sizeof(int), 2552884d179dSJan Kara .mode = 0444, 2553dde95888SDmitry Monakhov .proc_handler = do_proc_dqstats, 2554884d179dSJan Kara }, 2555884d179dSJan Kara { 2556884d179dSJan Kara .procname = "writes", 2557dde95888SDmitry Monakhov .data = &dqstats.stat[DQST_WRITES], 2558884d179dSJan Kara .maxlen = sizeof(int), 2559884d179dSJan Kara .mode = 0444, 2560dde95888SDmitry Monakhov .proc_handler = do_proc_dqstats, 2561884d179dSJan Kara }, 2562884d179dSJan Kara { 2563884d179dSJan Kara .procname = "cache_hits", 2564dde95888SDmitry Monakhov .data = &dqstats.stat[DQST_CACHE_HITS], 2565884d179dSJan Kara .maxlen = sizeof(int), 2566884d179dSJan Kara .mode = 0444, 2567dde95888SDmitry Monakhov .proc_handler = do_proc_dqstats, 2568884d179dSJan Kara }, 2569884d179dSJan Kara { 2570884d179dSJan Kara .procname = "allocated_dquots", 2571dde95888SDmitry Monakhov .data = &dqstats.stat[DQST_ALLOC_DQUOTS], 2572884d179dSJan Kara .maxlen = sizeof(int), 2573884d179dSJan Kara .mode = 0444, 2574dde95888SDmitry Monakhov .proc_handler = do_proc_dqstats, 2575884d179dSJan Kara }, 2576884d179dSJan Kara { 2577884d179dSJan Kara .procname = "free_dquots", 2578dde95888SDmitry Monakhov .data = &dqstats.stat[DQST_FREE_DQUOTS], 2579884d179dSJan Kara .maxlen = sizeof(int), 2580884d179dSJan Kara .mode = 0444, 2581dde95888SDmitry Monakhov .proc_handler = do_proc_dqstats, 2582884d179dSJan Kara }, 2583884d179dSJan Kara { 2584884d179dSJan Kara .procname = "syncs", 2585dde95888SDmitry Monakhov .data = &dqstats.stat[DQST_SYNCS], 2586884d179dSJan Kara .maxlen = sizeof(int), 2587884d179dSJan Kara .mode = 0444, 2588dde95888SDmitry Monakhov .proc_handler = do_proc_dqstats, 2589884d179dSJan Kara }, 2590884d179dSJan Kara #ifdef CONFIG_PRINT_QUOTA_WARNING 2591884d179dSJan Kara { 2592884d179dSJan Kara .procname = "warnings", 2593884d179dSJan Kara .data = &flag_print_warnings, 2594884d179dSJan Kara .maxlen = sizeof(int), 2595884d179dSJan Kara .mode = 0644, 25966d456111SEric W. Biederman .proc_handler = proc_dointvec, 2597884d179dSJan Kara }, 2598884d179dSJan Kara #endif 2599ab09203eSEric W. Biederman { }, 2600884d179dSJan Kara }; 2601884d179dSJan Kara 2602884d179dSJan Kara static ctl_table fs_table[] = { 2603884d179dSJan Kara { 2604884d179dSJan Kara .procname = "quota", 2605884d179dSJan Kara .mode = 0555, 2606884d179dSJan Kara .child = fs_dqstats_table, 2607884d179dSJan Kara }, 2608ab09203eSEric W. Biederman { }, 2609884d179dSJan Kara }; 2610884d179dSJan Kara 2611884d179dSJan Kara static ctl_table sys_table[] = { 2612884d179dSJan Kara { 2613884d179dSJan Kara .procname = "fs", 2614884d179dSJan Kara .mode = 0555, 2615884d179dSJan Kara .child = fs_table, 2616884d179dSJan Kara }, 2617ab09203eSEric W. Biederman { }, 2618884d179dSJan Kara }; 2619884d179dSJan Kara 2620884d179dSJan Kara static int __init dquot_init(void) 2621884d179dSJan Kara { 2622f32764bdSDmitry Monakhov int i, ret; 2623884d179dSJan Kara unsigned long nr_hash, order; 2624884d179dSJan Kara 2625884d179dSJan Kara printk(KERN_NOTICE "VFS: Disk quotas %s\n", __DQUOT_VERSION__); 2626884d179dSJan Kara 2627884d179dSJan Kara register_sysctl_table(sys_table); 2628884d179dSJan Kara 2629884d179dSJan Kara dquot_cachep = kmem_cache_create("dquot", 2630884d179dSJan Kara sizeof(struct dquot), sizeof(unsigned long) * 4, 2631884d179dSJan Kara (SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT| 2632884d179dSJan Kara SLAB_MEM_SPREAD|SLAB_PANIC), 2633884d179dSJan Kara NULL); 2634884d179dSJan Kara 2635884d179dSJan Kara order = 0; 2636884d179dSJan Kara dquot_hash = (struct hlist_head *)__get_free_pages(GFP_ATOMIC, order); 2637884d179dSJan Kara if (!dquot_hash) 2638884d179dSJan Kara panic("Cannot create dquot hash table"); 2639884d179dSJan Kara 2640f32764bdSDmitry Monakhov for (i = 0; i < _DQST_DQSTAT_LAST; i++) { 2641f32764bdSDmitry Monakhov ret = percpu_counter_init(&dqstats.counter[i], 0); 2642f32764bdSDmitry Monakhov if (ret) 2643f32764bdSDmitry Monakhov panic("Cannot create dquot stat counters"); 2644f32764bdSDmitry Monakhov } 2645dde95888SDmitry Monakhov 2646884d179dSJan Kara /* Find power-of-two hlist_heads which can fit into allocation */ 2647884d179dSJan Kara nr_hash = (1UL << order) * PAGE_SIZE / sizeof(struct hlist_head); 2648884d179dSJan Kara dq_hash_bits = 0; 2649884d179dSJan Kara do { 2650884d179dSJan Kara dq_hash_bits++; 2651884d179dSJan Kara } while (nr_hash >> dq_hash_bits); 2652884d179dSJan Kara dq_hash_bits--; 2653884d179dSJan Kara 2654884d179dSJan Kara nr_hash = 1UL << dq_hash_bits; 2655884d179dSJan Kara dq_hash_mask = nr_hash - 1; 2656884d179dSJan Kara for (i = 0; i < nr_hash; i++) 2657884d179dSJan Kara INIT_HLIST_HEAD(dquot_hash + i); 2658884d179dSJan Kara 2659884d179dSJan Kara printk("Dquot-cache hash table entries: %ld (order %ld, %ld bytes)\n", 2660884d179dSJan Kara nr_hash, order, (PAGE_SIZE << order)); 2661884d179dSJan Kara 2662884d179dSJan Kara register_shrinker(&dqcache_shrinker); 2663884d179dSJan Kara 2664884d179dSJan Kara return 0; 2665884d179dSJan Kara } 2666884d179dSJan Kara module_init(dquot_init); 2667