1884d179dSJan Kara /* 2884d179dSJan Kara * Implementation of the diskquota system for the LINUX operating system. QUOTA 3884d179dSJan Kara * is implemented using the BSD system call interface as the means of 4884d179dSJan Kara * communication with the user level. This file contains the generic routines 5884d179dSJan Kara * called by the different filesystems on allocation of an inode or block. 6884d179dSJan Kara * These routines take care of the administration needed to have a consistent 7884d179dSJan Kara * diskquota tracking system. The ideas of both user and group quotas are based 8884d179dSJan Kara * on the Melbourne quota system as used on BSD derived systems. The internal 9884d179dSJan Kara * implementation is based on one of the several variants of the LINUX 10884d179dSJan Kara * inode-subsystem with added complexity of the diskquota system. 11884d179dSJan Kara * 12884d179dSJan Kara * Author: Marco van Wieringen <mvw@planets.elm.net> 13884d179dSJan Kara * 14884d179dSJan Kara * Fixes: Dmitry Gorodchanin <pgmdsg@ibi.com>, 11 Feb 96 15884d179dSJan Kara * 16884d179dSJan Kara * Revised list management to avoid races 17884d179dSJan Kara * -- Bill Hawes, <whawes@star.net>, 9/98 18884d179dSJan Kara * 19884d179dSJan Kara * Fixed races in dquot_transfer(), dqget() and dquot_alloc_...(). 20884d179dSJan Kara * As the consequence the locking was moved from dquot_decr_...(), 21884d179dSJan Kara * dquot_incr_...() to calling functions. 22884d179dSJan Kara * invalidate_dquots() now writes modified dquots. 23884d179dSJan Kara * Serialized quota_off() and quota_on() for mount point. 24884d179dSJan Kara * Fixed a few bugs in grow_dquots(). 25884d179dSJan Kara * Fixed deadlock in write_dquot() - we no longer account quotas on 26884d179dSJan Kara * quota files 27884d179dSJan Kara * remove_dquot_ref() moved to inode.c - it now traverses through inodes 28884d179dSJan Kara * add_dquot_ref() restarts after blocking 29884d179dSJan Kara * Added check for bogus uid and fixed check for group in quotactl. 30884d179dSJan Kara * Jan Kara, <jack@suse.cz>, sponsored by SuSE CR, 10-11/99 31884d179dSJan Kara * 32884d179dSJan Kara * Used struct list_head instead of own list struct 33884d179dSJan Kara * Invalidation of referenced dquots is no longer possible 34884d179dSJan Kara * Improved free_dquots list management 35884d179dSJan Kara * Quota and i_blocks are now updated in one place to avoid races 36884d179dSJan Kara * Warnings are now delayed so we won't block in critical section 37884d179dSJan Kara * Write updated not to require dquot lock 38884d179dSJan Kara * Jan Kara, <jack@suse.cz>, 9/2000 39884d179dSJan Kara * 40884d179dSJan Kara * Added dynamic quota structure allocation 41884d179dSJan Kara * Jan Kara <jack@suse.cz> 12/2000 42884d179dSJan Kara * 43884d179dSJan Kara * Rewritten quota interface. Implemented new quota format and 44884d179dSJan Kara * formats registering. 45884d179dSJan Kara * Jan Kara, <jack@suse.cz>, 2001,2002 46884d179dSJan Kara * 47884d179dSJan Kara * New SMP locking. 48884d179dSJan Kara * Jan Kara, <jack@suse.cz>, 10/2002 49884d179dSJan Kara * 50884d179dSJan Kara * Added journalled quota support, fix lock inversion problems 51884d179dSJan Kara * Jan Kara, <jack@suse.cz>, 2003,2004 52884d179dSJan Kara * 53884d179dSJan Kara * (C) Copyright 1994 - 1997 Marco van Wieringen 54884d179dSJan Kara */ 55884d179dSJan Kara 56884d179dSJan Kara #include <linux/errno.h> 57884d179dSJan Kara #include <linux/kernel.h> 58884d179dSJan Kara #include <linux/fs.h> 59884d179dSJan Kara #include <linux/mount.h> 60884d179dSJan Kara #include <linux/mm.h> 61884d179dSJan Kara #include <linux/time.h> 62884d179dSJan Kara #include <linux/types.h> 63884d179dSJan Kara #include <linux/string.h> 64884d179dSJan Kara #include <linux/fcntl.h> 65884d179dSJan Kara #include <linux/stat.h> 66884d179dSJan Kara #include <linux/tty.h> 67884d179dSJan Kara #include <linux/file.h> 68884d179dSJan Kara #include <linux/slab.h> 69884d179dSJan Kara #include <linux/sysctl.h> 70884d179dSJan Kara #include <linux/init.h> 71884d179dSJan Kara #include <linux/module.h> 72884d179dSJan Kara #include <linux/proc_fs.h> 73884d179dSJan Kara #include <linux/security.h> 7440401530SAl Viro #include <linux/sched.h> 75884d179dSJan Kara #include <linux/kmod.h> 76884d179dSJan Kara #include <linux/namei.h> 77884d179dSJan Kara #include <linux/capability.h> 78884d179dSJan Kara #include <linux/quotaops.h> 7955fa6091SDave Chinner #include "../internal.h" /* ugh */ 80884d179dSJan Kara 81f3da9310SJeff Liu #include <linux/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 * 99b9ba6f94SNiu Yawei * Operation accessing dquots via inode pointers are protected by dquot_srcu. 100b9ba6f94SNiu Yawei * Operation of reading pointer needs srcu_read_lock(&dquot_srcu), and 101b9ba6f94SNiu Yawei * synchronize_srcu(&dquot_srcu) is called after clearing pointers from 102b9ba6f94SNiu Yawei * inode and before dropping dquot references to avoid use of dquots after 103b9ba6f94SNiu Yawei * they are freed. dq_data_lock is used to serialize the pointer setting and 104b9ba6f94SNiu Yawei * clearing operations. 10526245c94SJan Kara * Special care needs to be taken about S_NOQUOTA inode flag (marking that 10626245c94SJan Kara * inode is a quota file). Functions adding pointers from inode to dquots have 107b9ba6f94SNiu Yawei * to check this flag under dq_data_lock and then (if S_NOQUOTA is not set) they 108b9ba6f94SNiu Yawei * have to do all pointer modifications before dropping dq_data_lock. This makes 10926245c94SJan Kara * sure they cannot race with quotaon which first sets S_NOQUOTA flag and 11026245c94SJan Kara * then drops all pointers to dquots from an inode. 111884d179dSJan Kara * 112884d179dSJan Kara * Each dquot has its dq_lock mutex. Locked dquots might not be referenced 113884d179dSJan Kara * from inodes (dquot_alloc_space() and such don't check the dq_lock). 114884d179dSJan Kara * Currently dquot is locked only when it is being read to memory (or space for 115884d179dSJan Kara * it is being allocated) on the first dqget() and when it is being released on 116884d179dSJan Kara * the last dqput(). The allocation and release oparations are serialized by 117884d179dSJan Kara * the dq_lock and by checking the use count in dquot_release(). Write 118884d179dSJan Kara * operations on dquots don't hold dq_lock as they copy data under dq_data_lock 119884d179dSJan Kara * spinlock to internal buffers before writing. 120884d179dSJan Kara * 121884d179dSJan Kara * Lock ordering (including related VFS locks) is the following: 122b9ba6f94SNiu Yawei * dqonoff_mutex > i_mutex > journal_lock > dquot->dq_lock > dqio_mutex 123a80b12c3SJan Kara * dqonoff_mutex > i_mutex comes from dquot_quota_sync, dquot_enable, etc. 124884d179dSJan Kara */ 125884d179dSJan Kara 126c516610cSJan Kara static __cacheline_aligned_in_smp DEFINE_SPINLOCK(dq_list_lock); 127c516610cSJan Kara static __cacheline_aligned_in_smp DEFINE_SPINLOCK(dq_state_lock); 128c516610cSJan Kara __cacheline_aligned_in_smp DEFINE_SPINLOCK(dq_data_lock); 129884d179dSJan Kara EXPORT_SYMBOL(dq_data_lock); 130b9ba6f94SNiu Yawei DEFINE_STATIC_SRCU(dquot_srcu); 131884d179dSJan Kara 132fb5ffb0eSJiaying Zhang void __quota_error(struct super_block *sb, const char *func, 133fb5ffb0eSJiaying Zhang const char *fmt, ...) 134fb5ffb0eSJiaying Zhang { 135fb5ffb0eSJiaying Zhang if (printk_ratelimit()) { 136055adcbdSJoe Perches va_list args; 137055adcbdSJoe Perches struct va_format vaf; 138055adcbdSJoe Perches 139fb5ffb0eSJiaying Zhang va_start(args, fmt); 140055adcbdSJoe Perches 141055adcbdSJoe Perches vaf.fmt = fmt; 142055adcbdSJoe Perches vaf.va = &args; 143055adcbdSJoe Perches 144055adcbdSJoe Perches printk(KERN_ERR "Quota error (device %s): %s: %pV\n", 145055adcbdSJoe Perches sb->s_id, func, &vaf); 146055adcbdSJoe Perches 147fb5ffb0eSJiaying Zhang va_end(args); 148fb5ffb0eSJiaying Zhang } 149fb5ffb0eSJiaying Zhang } 150fb5ffb0eSJiaying Zhang EXPORT_SYMBOL(__quota_error); 151fb5ffb0eSJiaying Zhang 152da8d1ba2SSergey Senozhatsky #if defined(CONFIG_QUOTA_DEBUG) || defined(CONFIG_PRINT_QUOTA_WARNING) 153884d179dSJan Kara static char *quotatypes[] = INITQFNAMES; 154da8d1ba2SSergey Senozhatsky #endif 155884d179dSJan Kara static struct quota_format_type *quota_formats; /* List of registered formats */ 156884d179dSJan Kara static struct quota_module_name module_names[] = INIT_QUOTA_MODULE_NAMES; 157884d179dSJan Kara 158884d179dSJan Kara /* SLAB cache for dquot structures */ 159884d179dSJan Kara static struct kmem_cache *dquot_cachep; 160884d179dSJan Kara 161884d179dSJan Kara int register_quota_format(struct quota_format_type *fmt) 162884d179dSJan Kara { 163884d179dSJan Kara spin_lock(&dq_list_lock); 164884d179dSJan Kara fmt->qf_next = quota_formats; 165884d179dSJan Kara quota_formats = fmt; 166884d179dSJan Kara spin_unlock(&dq_list_lock); 167884d179dSJan Kara return 0; 168884d179dSJan Kara } 169884d179dSJan Kara EXPORT_SYMBOL(register_quota_format); 170884d179dSJan Kara 171884d179dSJan Kara void unregister_quota_format(struct quota_format_type *fmt) 172884d179dSJan Kara { 173884d179dSJan Kara struct quota_format_type **actqf; 174884d179dSJan Kara 175884d179dSJan Kara spin_lock(&dq_list_lock); 176268157baSJan Kara for (actqf = "a_formats; *actqf && *actqf != fmt; 177268157baSJan Kara actqf = &(*actqf)->qf_next) 178268157baSJan Kara ; 179884d179dSJan Kara if (*actqf) 180884d179dSJan Kara *actqf = (*actqf)->qf_next; 181884d179dSJan Kara spin_unlock(&dq_list_lock); 182884d179dSJan Kara } 183884d179dSJan Kara EXPORT_SYMBOL(unregister_quota_format); 184884d179dSJan Kara 185884d179dSJan Kara static struct quota_format_type *find_quota_format(int id) 186884d179dSJan Kara { 187884d179dSJan Kara struct quota_format_type *actqf; 188884d179dSJan Kara 189884d179dSJan Kara spin_lock(&dq_list_lock); 190268157baSJan Kara for (actqf = quota_formats; actqf && actqf->qf_fmt_id != id; 191268157baSJan Kara actqf = actqf->qf_next) 192268157baSJan Kara ; 193884d179dSJan Kara if (!actqf || !try_module_get(actqf->qf_owner)) { 194884d179dSJan Kara int qm; 195884d179dSJan Kara 196884d179dSJan Kara spin_unlock(&dq_list_lock); 197884d179dSJan Kara 198268157baSJan Kara for (qm = 0; module_names[qm].qm_fmt_id && 199268157baSJan Kara module_names[qm].qm_fmt_id != id; qm++) 200268157baSJan Kara ; 201268157baSJan Kara if (!module_names[qm].qm_fmt_id || 202268157baSJan Kara request_module(module_names[qm].qm_mod_name)) 203884d179dSJan Kara return NULL; 204884d179dSJan Kara 205884d179dSJan Kara spin_lock(&dq_list_lock); 206268157baSJan Kara for (actqf = quota_formats; actqf && actqf->qf_fmt_id != id; 207268157baSJan Kara actqf = actqf->qf_next) 208268157baSJan Kara ; 209884d179dSJan Kara if (actqf && !try_module_get(actqf->qf_owner)) 210884d179dSJan Kara actqf = NULL; 211884d179dSJan Kara } 212884d179dSJan Kara spin_unlock(&dq_list_lock); 213884d179dSJan Kara return actqf; 214884d179dSJan Kara } 215884d179dSJan Kara 216884d179dSJan Kara static void put_quota_format(struct quota_format_type *fmt) 217884d179dSJan Kara { 218884d179dSJan Kara module_put(fmt->qf_owner); 219884d179dSJan Kara } 220884d179dSJan Kara 221884d179dSJan Kara /* 222884d179dSJan Kara * Dquot List Management: 223884d179dSJan Kara * The quota code uses three lists for dquot management: the inuse_list, 224884d179dSJan Kara * free_dquots, and dquot_hash[] array. A single dquot structure may be 225884d179dSJan Kara * on all three lists, depending on its current state. 226884d179dSJan Kara * 227884d179dSJan Kara * All dquots are placed to the end of inuse_list when first created, and this 228884d179dSJan Kara * list is used for invalidate operation, which must look at every dquot. 229884d179dSJan Kara * 230884d179dSJan Kara * Unused dquots (dq_count == 0) are added to the free_dquots list when freed, 231884d179dSJan Kara * and this list is searched whenever we need an available dquot. Dquots are 232884d179dSJan Kara * removed from the list as soon as they are used again, and 233884d179dSJan Kara * dqstats.free_dquots gives the number of dquots on the list. When 234884d179dSJan Kara * dquot is invalidated it's completely released from memory. 235884d179dSJan Kara * 236884d179dSJan Kara * Dquots with a specific identity (device, type and id) are placed on 237884d179dSJan Kara * one of the dquot_hash[] hash chains. The provides an efficient search 238884d179dSJan Kara * mechanism to locate a specific dquot. 239884d179dSJan Kara */ 240884d179dSJan Kara 241884d179dSJan Kara static LIST_HEAD(inuse_list); 242884d179dSJan Kara static LIST_HEAD(free_dquots); 243884d179dSJan Kara static unsigned int dq_hash_bits, dq_hash_mask; 244884d179dSJan Kara static struct hlist_head *dquot_hash; 245884d179dSJan Kara 246884d179dSJan Kara struct dqstats dqstats; 247884d179dSJan Kara EXPORT_SYMBOL(dqstats); 248884d179dSJan Kara 2490a5a9c72SJan Kara static qsize_t inode_get_rsv_space(struct inode *inode); 250871a2931SChristoph Hellwig static void __dquot_initialize(struct inode *inode, int type); 2510a5a9c72SJan Kara 252884d179dSJan Kara static inline unsigned int 2531a06d420SEric W. Biederman hashfn(const struct super_block *sb, struct kqid qid) 254884d179dSJan Kara { 2551a06d420SEric W. Biederman unsigned int id = from_kqid(&init_user_ns, qid); 2561a06d420SEric W. Biederman int type = qid.type; 257884d179dSJan Kara unsigned long tmp; 258884d179dSJan Kara 259884d179dSJan Kara tmp = (((unsigned long)sb>>L1_CACHE_SHIFT) ^ id) * (MAXQUOTAS - type); 260884d179dSJan Kara return (tmp + (tmp >> dq_hash_bits)) & dq_hash_mask; 261884d179dSJan Kara } 262884d179dSJan Kara 263884d179dSJan Kara /* 264884d179dSJan Kara * Following list functions expect dq_list_lock to be held 265884d179dSJan Kara */ 266884d179dSJan Kara static inline void insert_dquot_hash(struct dquot *dquot) 267884d179dSJan Kara { 268268157baSJan Kara struct hlist_head *head; 2691a06d420SEric W. Biederman head = dquot_hash + hashfn(dquot->dq_sb, dquot->dq_id); 270884d179dSJan Kara hlist_add_head(&dquot->dq_hash, head); 271884d179dSJan Kara } 272884d179dSJan Kara 273884d179dSJan Kara static inline void remove_dquot_hash(struct dquot *dquot) 274884d179dSJan Kara { 275884d179dSJan Kara hlist_del_init(&dquot->dq_hash); 276884d179dSJan Kara } 277884d179dSJan Kara 2787a2435d8SJan Kara static struct dquot *find_dquot(unsigned int hashent, struct super_block *sb, 2791a06d420SEric W. Biederman struct kqid qid) 280884d179dSJan Kara { 281884d179dSJan Kara struct hlist_node *node; 282884d179dSJan Kara struct dquot *dquot; 283884d179dSJan Kara 284884d179dSJan Kara hlist_for_each (node, dquot_hash+hashent) { 285884d179dSJan Kara dquot = hlist_entry(node, struct dquot, dq_hash); 2864c376dcaSEric W. Biederman if (dquot->dq_sb == sb && qid_eq(dquot->dq_id, qid)) 287884d179dSJan Kara return dquot; 288884d179dSJan Kara } 289dd6f3c6dSJan Kara return NULL; 290884d179dSJan Kara } 291884d179dSJan Kara 292884d179dSJan Kara /* Add a dquot to the tail of the free list */ 293884d179dSJan Kara static inline void put_dquot_last(struct dquot *dquot) 294884d179dSJan Kara { 295884d179dSJan Kara list_add_tail(&dquot->dq_free, &free_dquots); 296dde95888SDmitry Monakhov dqstats_inc(DQST_FREE_DQUOTS); 297884d179dSJan Kara } 298884d179dSJan Kara 299884d179dSJan Kara static inline void remove_free_dquot(struct dquot *dquot) 300884d179dSJan Kara { 301884d179dSJan Kara if (list_empty(&dquot->dq_free)) 302884d179dSJan Kara return; 303884d179dSJan Kara list_del_init(&dquot->dq_free); 304dde95888SDmitry Monakhov dqstats_dec(DQST_FREE_DQUOTS); 305884d179dSJan Kara } 306884d179dSJan Kara 307884d179dSJan Kara static inline void put_inuse(struct dquot *dquot) 308884d179dSJan Kara { 309884d179dSJan Kara /* We add to the back of inuse list so we don't have to restart 310884d179dSJan Kara * when traversing this list and we block */ 311884d179dSJan Kara list_add_tail(&dquot->dq_inuse, &inuse_list); 312dde95888SDmitry Monakhov dqstats_inc(DQST_ALLOC_DQUOTS); 313884d179dSJan Kara } 314884d179dSJan Kara 315884d179dSJan Kara static inline void remove_inuse(struct dquot *dquot) 316884d179dSJan Kara { 317dde95888SDmitry Monakhov dqstats_dec(DQST_ALLOC_DQUOTS); 318884d179dSJan Kara list_del(&dquot->dq_inuse); 319884d179dSJan Kara } 320884d179dSJan Kara /* 321884d179dSJan Kara * End of list functions needing dq_list_lock 322884d179dSJan Kara */ 323884d179dSJan Kara 324884d179dSJan Kara static void wait_on_dquot(struct dquot *dquot) 325884d179dSJan Kara { 326884d179dSJan Kara mutex_lock(&dquot->dq_lock); 327884d179dSJan Kara mutex_unlock(&dquot->dq_lock); 328884d179dSJan Kara } 329884d179dSJan Kara 330884d179dSJan Kara static inline int dquot_dirty(struct dquot *dquot) 331884d179dSJan Kara { 332884d179dSJan Kara return test_bit(DQ_MOD_B, &dquot->dq_flags); 333884d179dSJan Kara } 334884d179dSJan Kara 335884d179dSJan Kara static inline int mark_dquot_dirty(struct dquot *dquot) 336884d179dSJan Kara { 337884d179dSJan Kara return dquot->dq_sb->dq_op->mark_dirty(dquot); 338884d179dSJan Kara } 339884d179dSJan Kara 340eabf290dSDmitry Monakhov /* Mark dquot dirty in atomic manner, and return it's old dirty flag state */ 341884d179dSJan Kara int dquot_mark_dquot_dirty(struct dquot *dquot) 342884d179dSJan Kara { 343eabf290dSDmitry Monakhov int ret = 1; 344eabf290dSDmitry Monakhov 345eabf290dSDmitry Monakhov /* If quota is dirty already, we don't have to acquire dq_list_lock */ 346eabf290dSDmitry Monakhov if (test_bit(DQ_MOD_B, &dquot->dq_flags)) 347eabf290dSDmitry Monakhov return 1; 348eabf290dSDmitry Monakhov 349884d179dSJan Kara spin_lock(&dq_list_lock); 350eabf290dSDmitry Monakhov if (!test_and_set_bit(DQ_MOD_B, &dquot->dq_flags)) { 351884d179dSJan Kara list_add(&dquot->dq_dirty, &sb_dqopt(dquot->dq_sb)-> 3524c376dcaSEric W. Biederman info[dquot->dq_id.type].dqi_dirty_list); 353eabf290dSDmitry Monakhov ret = 0; 354eabf290dSDmitry Monakhov } 355884d179dSJan Kara spin_unlock(&dq_list_lock); 356eabf290dSDmitry Monakhov return ret; 357884d179dSJan Kara } 358884d179dSJan Kara EXPORT_SYMBOL(dquot_mark_dquot_dirty); 359884d179dSJan Kara 360dc52dd3aSDmitry Monakhov /* Dirtify all the dquots - this can block when journalling */ 361dc52dd3aSDmitry Monakhov static inline int mark_all_dquot_dirty(struct dquot * const *dquot) 362dc52dd3aSDmitry Monakhov { 363dc52dd3aSDmitry Monakhov int ret, err, cnt; 364dc52dd3aSDmitry Monakhov 365dc52dd3aSDmitry Monakhov ret = err = 0; 366dc52dd3aSDmitry Monakhov for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 367dc52dd3aSDmitry Monakhov if (dquot[cnt]) 368dc52dd3aSDmitry Monakhov /* Even in case of error we have to continue */ 369dc52dd3aSDmitry Monakhov ret = mark_dquot_dirty(dquot[cnt]); 370dc52dd3aSDmitry Monakhov if (!err) 371dc52dd3aSDmitry Monakhov err = ret; 372dc52dd3aSDmitry Monakhov } 373dc52dd3aSDmitry Monakhov return err; 374dc52dd3aSDmitry Monakhov } 375dc52dd3aSDmitry Monakhov 376dc52dd3aSDmitry Monakhov static inline void dqput_all(struct dquot **dquot) 377dc52dd3aSDmitry Monakhov { 378dc52dd3aSDmitry Monakhov unsigned int cnt; 379dc52dd3aSDmitry Monakhov 380dc52dd3aSDmitry Monakhov for (cnt = 0; cnt < MAXQUOTAS; cnt++) 381dc52dd3aSDmitry Monakhov dqput(dquot[cnt]); 382dc52dd3aSDmitry Monakhov } 383dc52dd3aSDmitry Monakhov 384884d179dSJan Kara /* This function needs dq_list_lock */ 385884d179dSJan Kara static inline int clear_dquot_dirty(struct dquot *dquot) 386884d179dSJan Kara { 387884d179dSJan Kara if (!test_and_clear_bit(DQ_MOD_B, &dquot->dq_flags)) 388884d179dSJan Kara return 0; 389884d179dSJan Kara list_del_init(&dquot->dq_dirty); 390884d179dSJan Kara return 1; 391884d179dSJan Kara } 392884d179dSJan Kara 393884d179dSJan Kara void mark_info_dirty(struct super_block *sb, int type) 394884d179dSJan Kara { 395884d179dSJan Kara set_bit(DQF_INFO_DIRTY_B, &sb_dqopt(sb)->info[type].dqi_flags); 396884d179dSJan Kara } 397884d179dSJan Kara EXPORT_SYMBOL(mark_info_dirty); 398884d179dSJan Kara 399884d179dSJan Kara /* 400884d179dSJan Kara * Read dquot from disk and alloc space for it 401884d179dSJan Kara */ 402884d179dSJan Kara 403884d179dSJan Kara int dquot_acquire(struct dquot *dquot) 404884d179dSJan Kara { 405884d179dSJan Kara int ret = 0, ret2 = 0; 406884d179dSJan Kara struct quota_info *dqopt = sb_dqopt(dquot->dq_sb); 407884d179dSJan Kara 408884d179dSJan Kara mutex_lock(&dquot->dq_lock); 409884d179dSJan Kara mutex_lock(&dqopt->dqio_mutex); 410884d179dSJan Kara if (!test_bit(DQ_READ_B, &dquot->dq_flags)) 4114c376dcaSEric W. Biederman ret = dqopt->ops[dquot->dq_id.type]->read_dqblk(dquot); 412884d179dSJan Kara if (ret < 0) 413884d179dSJan Kara goto out_iolock; 414884d179dSJan Kara set_bit(DQ_READ_B, &dquot->dq_flags); 415884d179dSJan Kara /* Instantiate dquot if needed */ 416884d179dSJan Kara if (!test_bit(DQ_ACTIVE_B, &dquot->dq_flags) && !dquot->dq_off) { 4174c376dcaSEric W. Biederman ret = dqopt->ops[dquot->dq_id.type]->commit_dqblk(dquot); 418884d179dSJan Kara /* Write the info if needed */ 4194c376dcaSEric W. Biederman if (info_dirty(&dqopt->info[dquot->dq_id.type])) { 4204c376dcaSEric W. Biederman ret2 = dqopt->ops[dquot->dq_id.type]->write_file_info( 4214c376dcaSEric W. Biederman dquot->dq_sb, dquot->dq_id.type); 422268157baSJan Kara } 423884d179dSJan Kara if (ret < 0) 424884d179dSJan Kara goto out_iolock; 425884d179dSJan Kara if (ret2 < 0) { 426884d179dSJan Kara ret = ret2; 427884d179dSJan Kara goto out_iolock; 428884d179dSJan Kara } 429884d179dSJan Kara } 430884d179dSJan Kara set_bit(DQ_ACTIVE_B, &dquot->dq_flags); 431884d179dSJan Kara out_iolock: 432884d179dSJan Kara mutex_unlock(&dqopt->dqio_mutex); 433884d179dSJan Kara mutex_unlock(&dquot->dq_lock); 434884d179dSJan Kara return ret; 435884d179dSJan Kara } 436884d179dSJan Kara EXPORT_SYMBOL(dquot_acquire); 437884d179dSJan Kara 438884d179dSJan Kara /* 439884d179dSJan Kara * Write dquot to disk 440884d179dSJan Kara */ 441884d179dSJan Kara int dquot_commit(struct dquot *dquot) 442884d179dSJan Kara { 443b03f2456SJan Kara int ret = 0; 444884d179dSJan Kara struct quota_info *dqopt = sb_dqopt(dquot->dq_sb); 445884d179dSJan Kara 446884d179dSJan Kara mutex_lock(&dqopt->dqio_mutex); 447884d179dSJan Kara spin_lock(&dq_list_lock); 448884d179dSJan Kara if (!clear_dquot_dirty(dquot)) { 449884d179dSJan Kara spin_unlock(&dq_list_lock); 450884d179dSJan Kara goto out_sem; 451884d179dSJan Kara } 452884d179dSJan Kara spin_unlock(&dq_list_lock); 453884d179dSJan Kara /* Inactive dquot can be only if there was error during read/init 454884d179dSJan Kara * => we have better not writing it */ 455b03f2456SJan Kara if (test_bit(DQ_ACTIVE_B, &dquot->dq_flags)) 4564c376dcaSEric W. Biederman ret = dqopt->ops[dquot->dq_id.type]->commit_dqblk(dquot); 457b03f2456SJan Kara else 458b03f2456SJan Kara ret = -EIO; 459884d179dSJan Kara out_sem: 460884d179dSJan Kara mutex_unlock(&dqopt->dqio_mutex); 461884d179dSJan Kara return ret; 462884d179dSJan Kara } 463884d179dSJan Kara EXPORT_SYMBOL(dquot_commit); 464884d179dSJan Kara 465884d179dSJan Kara /* 466884d179dSJan Kara * Release dquot 467884d179dSJan Kara */ 468884d179dSJan Kara int dquot_release(struct dquot *dquot) 469884d179dSJan Kara { 470884d179dSJan Kara int ret = 0, ret2 = 0; 471884d179dSJan Kara struct quota_info *dqopt = sb_dqopt(dquot->dq_sb); 472884d179dSJan Kara 473884d179dSJan Kara mutex_lock(&dquot->dq_lock); 474884d179dSJan Kara /* Check whether we are not racing with some other dqget() */ 475884d179dSJan Kara if (atomic_read(&dquot->dq_count) > 1) 476884d179dSJan Kara goto out_dqlock; 477884d179dSJan Kara mutex_lock(&dqopt->dqio_mutex); 4784c376dcaSEric W. Biederman if (dqopt->ops[dquot->dq_id.type]->release_dqblk) { 4794c376dcaSEric W. Biederman ret = dqopt->ops[dquot->dq_id.type]->release_dqblk(dquot); 480884d179dSJan Kara /* Write the info */ 4814c376dcaSEric W. Biederman if (info_dirty(&dqopt->info[dquot->dq_id.type])) { 4824c376dcaSEric W. Biederman ret2 = dqopt->ops[dquot->dq_id.type]->write_file_info( 4834c376dcaSEric W. Biederman dquot->dq_sb, dquot->dq_id.type); 484268157baSJan Kara } 485884d179dSJan Kara if (ret >= 0) 486884d179dSJan Kara ret = ret2; 487884d179dSJan Kara } 488884d179dSJan Kara clear_bit(DQ_ACTIVE_B, &dquot->dq_flags); 489884d179dSJan Kara mutex_unlock(&dqopt->dqio_mutex); 490884d179dSJan Kara out_dqlock: 491884d179dSJan Kara mutex_unlock(&dquot->dq_lock); 492884d179dSJan Kara return ret; 493884d179dSJan Kara } 494884d179dSJan Kara EXPORT_SYMBOL(dquot_release); 495884d179dSJan Kara 496884d179dSJan Kara void dquot_destroy(struct dquot *dquot) 497884d179dSJan Kara { 498884d179dSJan Kara kmem_cache_free(dquot_cachep, dquot); 499884d179dSJan Kara } 500884d179dSJan Kara EXPORT_SYMBOL(dquot_destroy); 501884d179dSJan Kara 502884d179dSJan Kara static inline void do_destroy_dquot(struct dquot *dquot) 503884d179dSJan Kara { 504884d179dSJan Kara dquot->dq_sb->dq_op->destroy_dquot(dquot); 505884d179dSJan Kara } 506884d179dSJan Kara 507884d179dSJan Kara /* Invalidate all dquots on the list. Note that this function is called after 508884d179dSJan Kara * quota is disabled and pointers from inodes removed so there cannot be new 509884d179dSJan Kara * quota users. There can still be some users of quotas due to inodes being 510884d179dSJan Kara * just deleted or pruned by prune_icache() (those are not attached to any 511884d179dSJan Kara * list) or parallel quotactl call. We have to wait for such users. 512884d179dSJan Kara */ 513884d179dSJan Kara static void invalidate_dquots(struct super_block *sb, int type) 514884d179dSJan Kara { 515884d179dSJan Kara struct dquot *dquot, *tmp; 516884d179dSJan Kara 517884d179dSJan Kara restart: 518884d179dSJan Kara spin_lock(&dq_list_lock); 519884d179dSJan Kara list_for_each_entry_safe(dquot, tmp, &inuse_list, dq_inuse) { 520884d179dSJan Kara if (dquot->dq_sb != sb) 521884d179dSJan Kara continue; 5224c376dcaSEric W. Biederman if (dquot->dq_id.type != type) 523884d179dSJan Kara continue; 524884d179dSJan Kara /* Wait for dquot users */ 525884d179dSJan Kara if (atomic_read(&dquot->dq_count)) { 526884d179dSJan Kara DEFINE_WAIT(wait); 527884d179dSJan Kara 5289f985cb6SJan Kara dqgrab(dquot); 529884d179dSJan Kara prepare_to_wait(&dquot->dq_wait_unused, &wait, 530884d179dSJan Kara TASK_UNINTERRUPTIBLE); 531884d179dSJan Kara spin_unlock(&dq_list_lock); 532884d179dSJan Kara /* Once dqput() wakes us up, we know it's time to free 533884d179dSJan Kara * the dquot. 534884d179dSJan Kara * IMPORTANT: we rely on the fact that there is always 535884d179dSJan Kara * at most one process waiting for dquot to free. 536884d179dSJan Kara * Otherwise dq_count would be > 1 and we would never 537884d179dSJan Kara * wake up. 538884d179dSJan Kara */ 539884d179dSJan Kara if (atomic_read(&dquot->dq_count) > 1) 540884d179dSJan Kara schedule(); 541884d179dSJan Kara finish_wait(&dquot->dq_wait_unused, &wait); 542884d179dSJan Kara dqput(dquot); 543884d179dSJan Kara /* At this moment dquot() need not exist (it could be 544884d179dSJan Kara * reclaimed by prune_dqcache(). Hence we must 545884d179dSJan Kara * restart. */ 546884d179dSJan Kara goto restart; 547884d179dSJan Kara } 548884d179dSJan Kara /* 549884d179dSJan Kara * Quota now has no users and it has been written on last 550884d179dSJan Kara * dqput() 551884d179dSJan Kara */ 552884d179dSJan Kara remove_dquot_hash(dquot); 553884d179dSJan Kara remove_free_dquot(dquot); 554884d179dSJan Kara remove_inuse(dquot); 555884d179dSJan Kara do_destroy_dquot(dquot); 556884d179dSJan Kara } 557884d179dSJan Kara spin_unlock(&dq_list_lock); 558884d179dSJan Kara } 559884d179dSJan Kara 560884d179dSJan Kara /* Call callback for every active dquot on given filesystem */ 561884d179dSJan Kara int dquot_scan_active(struct super_block *sb, 562884d179dSJan Kara int (*fn)(struct dquot *dquot, unsigned long priv), 563884d179dSJan Kara unsigned long priv) 564884d179dSJan Kara { 565884d179dSJan Kara struct dquot *dquot, *old_dquot = NULL; 566884d179dSJan Kara int ret = 0; 567884d179dSJan Kara 568884d179dSJan Kara mutex_lock(&sb_dqopt(sb)->dqonoff_mutex); 569884d179dSJan Kara spin_lock(&dq_list_lock); 570884d179dSJan Kara list_for_each_entry(dquot, &inuse_list, dq_inuse) { 571884d179dSJan Kara if (!test_bit(DQ_ACTIVE_B, &dquot->dq_flags)) 572884d179dSJan Kara continue; 573884d179dSJan Kara if (dquot->dq_sb != sb) 574884d179dSJan Kara continue; 575884d179dSJan Kara /* Now we have active dquot so we can just increase use count */ 576884d179dSJan Kara atomic_inc(&dquot->dq_count); 577884d179dSJan Kara spin_unlock(&dq_list_lock); 578dde95888SDmitry Monakhov dqstats_inc(DQST_LOOKUPS); 579884d179dSJan Kara dqput(old_dquot); 580884d179dSJan Kara old_dquot = dquot; 5811362f4eaSJan Kara /* 5821362f4eaSJan Kara * ->release_dquot() can be racing with us. Our reference 5831362f4eaSJan Kara * protects us from new calls to it so just wait for any 5841362f4eaSJan Kara * outstanding call and recheck the DQ_ACTIVE_B after that. 5851362f4eaSJan Kara */ 5861362f4eaSJan Kara wait_on_dquot(dquot); 5871362f4eaSJan Kara if (test_bit(DQ_ACTIVE_B, &dquot->dq_flags)) { 588884d179dSJan Kara ret = fn(dquot, priv); 589884d179dSJan Kara if (ret < 0) 590884d179dSJan Kara goto out; 5911362f4eaSJan Kara } 592884d179dSJan Kara spin_lock(&dq_list_lock); 593884d179dSJan Kara /* We are safe to continue now because our dquot could not 594884d179dSJan Kara * be moved out of the inuse list while we hold the reference */ 595884d179dSJan Kara } 596884d179dSJan Kara spin_unlock(&dq_list_lock); 597884d179dSJan Kara out: 598884d179dSJan Kara dqput(old_dquot); 599884d179dSJan Kara mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex); 600884d179dSJan Kara return ret; 601884d179dSJan Kara } 602884d179dSJan Kara EXPORT_SYMBOL(dquot_scan_active); 603884d179dSJan Kara 604ceed1723SJan Kara /* Write all dquot structures to quota files */ 605ceed1723SJan Kara int dquot_writeback_dquots(struct super_block *sb, int type) 606884d179dSJan Kara { 607884d179dSJan Kara struct list_head *dirty; 608884d179dSJan Kara struct dquot *dquot; 609884d179dSJan Kara struct quota_info *dqopt = sb_dqopt(sb); 610884d179dSJan Kara int cnt; 611ceed1723SJan Kara int err, ret = 0; 612884d179dSJan Kara 613884d179dSJan Kara mutex_lock(&dqopt->dqonoff_mutex); 614884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 615884d179dSJan Kara if (type != -1 && cnt != type) 616884d179dSJan Kara continue; 617884d179dSJan Kara if (!sb_has_quota_active(sb, cnt)) 618884d179dSJan Kara continue; 619884d179dSJan Kara spin_lock(&dq_list_lock); 620884d179dSJan Kara dirty = &dqopt->info[cnt].dqi_dirty_list; 621884d179dSJan Kara while (!list_empty(dirty)) { 622268157baSJan Kara dquot = list_first_entry(dirty, struct dquot, 623268157baSJan Kara dq_dirty); 624884d179dSJan Kara /* Dirty and inactive can be only bad dquot... */ 625884d179dSJan Kara if (!test_bit(DQ_ACTIVE_B, &dquot->dq_flags)) { 626884d179dSJan Kara clear_dquot_dirty(dquot); 627884d179dSJan Kara continue; 628884d179dSJan Kara } 629884d179dSJan Kara /* Now we have active dquot from which someone is 630884d179dSJan Kara * holding reference so we can safely just increase 631884d179dSJan Kara * use count */ 6329f985cb6SJan Kara dqgrab(dquot); 633884d179dSJan Kara spin_unlock(&dq_list_lock); 634dde95888SDmitry Monakhov dqstats_inc(DQST_LOOKUPS); 635ceed1723SJan Kara err = sb->dq_op->write_dquot(dquot); 636ceed1723SJan Kara if (!ret && err) 637474d2605SJan Kara ret = err; 638884d179dSJan Kara dqput(dquot); 639884d179dSJan Kara spin_lock(&dq_list_lock); 640884d179dSJan Kara } 641884d179dSJan Kara spin_unlock(&dq_list_lock); 642884d179dSJan Kara } 643884d179dSJan Kara 644884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) 645884d179dSJan Kara if ((cnt == type || type == -1) && sb_has_quota_active(sb, cnt) 646884d179dSJan Kara && info_dirty(&dqopt->info[cnt])) 647884d179dSJan Kara sb->dq_op->write_info(sb, cnt); 648dde95888SDmitry Monakhov dqstats_inc(DQST_SYNCS); 649884d179dSJan Kara mutex_unlock(&dqopt->dqonoff_mutex); 650884d179dSJan Kara 651ceed1723SJan Kara return ret; 652ceed1723SJan Kara } 653ceed1723SJan Kara EXPORT_SYMBOL(dquot_writeback_dquots); 654ceed1723SJan Kara 655ceed1723SJan Kara /* Write all dquot structures to disk and make them visible from userspace */ 656ceed1723SJan Kara int dquot_quota_sync(struct super_block *sb, int type) 657ceed1723SJan Kara { 658ceed1723SJan Kara struct quota_info *dqopt = sb_dqopt(sb); 659ceed1723SJan Kara int cnt; 660ceed1723SJan Kara int ret; 661ceed1723SJan Kara 662ceed1723SJan Kara ret = dquot_writeback_dquots(sb, type); 663ceed1723SJan Kara if (ret) 664ceed1723SJan Kara return ret; 665ceed1723SJan Kara if (dqopt->flags & DQUOT_QUOTA_SYS_FILE) 6665fb324adSChristoph Hellwig return 0; 6675fb324adSChristoph Hellwig 6685fb324adSChristoph Hellwig /* This is not very clever (and fast) but currently I don't know about 6695fb324adSChristoph Hellwig * any other simple way of getting quota data to disk and we must get 6705fb324adSChristoph Hellwig * them there for userspace to be visible... */ 6715fb324adSChristoph Hellwig if (sb->s_op->sync_fs) 6725fb324adSChristoph Hellwig sb->s_op->sync_fs(sb, 1); 6735fb324adSChristoph Hellwig sync_blockdev(sb->s_bdev); 6745fb324adSChristoph Hellwig 6755fb324adSChristoph Hellwig /* 6765fb324adSChristoph Hellwig * Now when everything is written we can discard the pagecache so 6775fb324adSChristoph Hellwig * that userspace sees the changes. 6785fb324adSChristoph Hellwig */ 679f9ef1784SJan Kara mutex_lock(&dqopt->dqonoff_mutex); 6805fb324adSChristoph Hellwig for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 6815fb324adSChristoph Hellwig if (type != -1 && cnt != type) 6825fb324adSChristoph Hellwig continue; 6835fb324adSChristoph Hellwig if (!sb_has_quota_active(sb, cnt)) 6845fb324adSChristoph Hellwig continue; 685a80b12c3SJan Kara mutex_lock(&dqopt->files[cnt]->i_mutex); 686f9ef1784SJan Kara truncate_inode_pages(&dqopt->files[cnt]->i_data, 0); 687f9ef1784SJan Kara mutex_unlock(&dqopt->files[cnt]->i_mutex); 6885fb324adSChristoph Hellwig } 689f9ef1784SJan Kara mutex_unlock(&dqopt->dqonoff_mutex); 6905fb324adSChristoph Hellwig 691884d179dSJan Kara return 0; 692884d179dSJan Kara } 693287a8095SChristoph Hellwig EXPORT_SYMBOL(dquot_quota_sync); 694884d179dSJan Kara 6951ab6c499SDave Chinner static unsigned long 6961ab6c499SDave Chinner dqcache_shrink_scan(struct shrinker *shrink, struct shrink_control *sc) 697884d179dSJan Kara { 698884d179dSJan Kara struct list_head *head; 699884d179dSJan Kara struct dquot *dquot; 7001ab6c499SDave Chinner unsigned long freed = 0; 701884d179dSJan Kara 702d68aab6bSNiu Yawei spin_lock(&dq_list_lock); 703884d179dSJan Kara head = free_dquots.prev; 7041ab6c499SDave Chinner while (head != &free_dquots && sc->nr_to_scan) { 705884d179dSJan Kara dquot = list_entry(head, struct dquot, dq_free); 706884d179dSJan Kara remove_dquot_hash(dquot); 707884d179dSJan Kara remove_free_dquot(dquot); 708884d179dSJan Kara remove_inuse(dquot); 709884d179dSJan Kara do_destroy_dquot(dquot); 7101ab6c499SDave Chinner sc->nr_to_scan--; 7111ab6c499SDave Chinner freed++; 712884d179dSJan Kara head = free_dquots.prev; 713884d179dSJan Kara } 714d68aab6bSNiu Yawei spin_unlock(&dq_list_lock); 7151ab6c499SDave Chinner return freed; 716884d179dSJan Kara } 717884d179dSJan Kara 7181ab6c499SDave Chinner static unsigned long 7191ab6c499SDave Chinner dqcache_shrink_count(struct shrinker *shrink, struct shrink_control *sc) 720884d179dSJan Kara { 72155f841ceSGlauber Costa return vfs_pressure_ratio( 72255f841ceSGlauber Costa percpu_counter_read_positive(&dqstats.counter[DQST_FREE_DQUOTS])); 723884d179dSJan Kara } 724884d179dSJan Kara 725884d179dSJan Kara static struct shrinker dqcache_shrinker = { 7261ab6c499SDave Chinner .count_objects = dqcache_shrink_count, 7271ab6c499SDave Chinner .scan_objects = dqcache_shrink_scan, 728884d179dSJan Kara .seeks = DEFAULT_SEEKS, 729884d179dSJan Kara }; 730884d179dSJan Kara 731884d179dSJan Kara /* 732884d179dSJan Kara * Put reference to dquot 733884d179dSJan Kara */ 734884d179dSJan Kara void dqput(struct dquot *dquot) 735884d179dSJan Kara { 736884d179dSJan Kara int ret; 737884d179dSJan Kara 738884d179dSJan Kara if (!dquot) 739884d179dSJan Kara return; 74062af9b52SJan Kara #ifdef CONFIG_QUOTA_DEBUG 741884d179dSJan Kara if (!atomic_read(&dquot->dq_count)) { 742fb5ffb0eSJiaying Zhang quota_error(dquot->dq_sb, "trying to free free dquot of %s %d", 7434c376dcaSEric W. Biederman quotatypes[dquot->dq_id.type], 7444c376dcaSEric W. Biederman from_kqid(&init_user_ns, dquot->dq_id)); 745884d179dSJan Kara BUG(); 746884d179dSJan Kara } 747884d179dSJan Kara #endif 748dde95888SDmitry Monakhov dqstats_inc(DQST_DROPS); 749884d179dSJan Kara we_slept: 750884d179dSJan Kara spin_lock(&dq_list_lock); 751884d179dSJan Kara if (atomic_read(&dquot->dq_count) > 1) { 752884d179dSJan Kara /* We have more than one user... nothing to do */ 753884d179dSJan Kara atomic_dec(&dquot->dq_count); 754884d179dSJan Kara /* Releasing dquot during quotaoff phase? */ 7554c376dcaSEric W. Biederman if (!sb_has_quota_active(dquot->dq_sb, dquot->dq_id.type) && 756884d179dSJan Kara atomic_read(&dquot->dq_count) == 1) 757884d179dSJan Kara wake_up(&dquot->dq_wait_unused); 758884d179dSJan Kara spin_unlock(&dq_list_lock); 759884d179dSJan Kara return; 760884d179dSJan Kara } 761884d179dSJan Kara /* Need to release dquot? */ 762884d179dSJan Kara if (test_bit(DQ_ACTIVE_B, &dquot->dq_flags) && dquot_dirty(dquot)) { 763884d179dSJan Kara spin_unlock(&dq_list_lock); 764884d179dSJan Kara /* Commit dquot before releasing */ 765884d179dSJan Kara ret = dquot->dq_sb->dq_op->write_dquot(dquot); 766884d179dSJan Kara if (ret < 0) { 767fb5ffb0eSJiaying Zhang quota_error(dquot->dq_sb, "Can't write quota structure" 768fb5ffb0eSJiaying Zhang " (error %d). Quota may get out of sync!", 769fb5ffb0eSJiaying Zhang ret); 770884d179dSJan Kara /* 771884d179dSJan Kara * We clear dirty bit anyway, so that we avoid 772884d179dSJan Kara * infinite loop here 773884d179dSJan Kara */ 774884d179dSJan Kara spin_lock(&dq_list_lock); 775884d179dSJan Kara clear_dquot_dirty(dquot); 776884d179dSJan Kara spin_unlock(&dq_list_lock); 777884d179dSJan Kara } 778884d179dSJan Kara goto we_slept; 779884d179dSJan Kara } 780884d179dSJan Kara /* Clear flag in case dquot was inactive (something bad happened) */ 781884d179dSJan Kara clear_dquot_dirty(dquot); 782884d179dSJan Kara if (test_bit(DQ_ACTIVE_B, &dquot->dq_flags)) { 783884d179dSJan Kara spin_unlock(&dq_list_lock); 784884d179dSJan Kara dquot->dq_sb->dq_op->release_dquot(dquot); 785884d179dSJan Kara goto we_slept; 786884d179dSJan Kara } 787884d179dSJan Kara atomic_dec(&dquot->dq_count); 78862af9b52SJan Kara #ifdef CONFIG_QUOTA_DEBUG 789884d179dSJan Kara /* sanity check */ 790884d179dSJan Kara BUG_ON(!list_empty(&dquot->dq_free)); 791884d179dSJan Kara #endif 792884d179dSJan Kara put_dquot_last(dquot); 793884d179dSJan Kara spin_unlock(&dq_list_lock); 794884d179dSJan Kara } 795884d179dSJan Kara EXPORT_SYMBOL(dqput); 796884d179dSJan Kara 797884d179dSJan Kara struct dquot *dquot_alloc(struct super_block *sb, int type) 798884d179dSJan Kara { 799884d179dSJan Kara return kmem_cache_zalloc(dquot_cachep, GFP_NOFS); 800884d179dSJan Kara } 801884d179dSJan Kara EXPORT_SYMBOL(dquot_alloc); 802884d179dSJan Kara 803884d179dSJan Kara static struct dquot *get_empty_dquot(struct super_block *sb, int type) 804884d179dSJan Kara { 805884d179dSJan Kara struct dquot *dquot; 806884d179dSJan Kara 807884d179dSJan Kara dquot = sb->dq_op->alloc_dquot(sb, type); 808884d179dSJan Kara if(!dquot) 809dd6f3c6dSJan Kara return NULL; 810884d179dSJan Kara 811884d179dSJan Kara mutex_init(&dquot->dq_lock); 812884d179dSJan Kara INIT_LIST_HEAD(&dquot->dq_free); 813884d179dSJan Kara INIT_LIST_HEAD(&dquot->dq_inuse); 814884d179dSJan Kara INIT_HLIST_NODE(&dquot->dq_hash); 815884d179dSJan Kara INIT_LIST_HEAD(&dquot->dq_dirty); 816884d179dSJan Kara init_waitqueue_head(&dquot->dq_wait_unused); 817884d179dSJan Kara dquot->dq_sb = sb; 8181a06d420SEric W. Biederman dquot->dq_id = make_kqid_invalid(type); 819884d179dSJan Kara atomic_set(&dquot->dq_count, 1); 820884d179dSJan Kara 821884d179dSJan Kara return dquot; 822884d179dSJan Kara } 823884d179dSJan Kara 824884d179dSJan Kara /* 825884d179dSJan Kara * Get reference to dquot 826884d179dSJan Kara * 827884d179dSJan Kara * Locking is slightly tricky here. We are guarded from parallel quotaoff() 828884d179dSJan Kara * destroying our dquot by: 829884d179dSJan Kara * a) checking for quota flags under dq_list_lock and 830884d179dSJan Kara * b) getting a reference to dquot before we release dq_list_lock 831884d179dSJan Kara */ 832aca645a6SEric W. Biederman struct dquot *dqget(struct super_block *sb, struct kqid qid) 833884d179dSJan Kara { 8341a06d420SEric W. Biederman unsigned int hashent = hashfn(sb, qid); 835dd6f3c6dSJan Kara struct dquot *dquot = NULL, *empty = NULL; 836884d179dSJan Kara 8371a06d420SEric W. Biederman if (!sb_has_quota_active(sb, qid.type)) 838dd6f3c6dSJan Kara return NULL; 839884d179dSJan Kara we_slept: 840884d179dSJan Kara spin_lock(&dq_list_lock); 841884d179dSJan Kara spin_lock(&dq_state_lock); 8421a06d420SEric W. Biederman if (!sb_has_quota_active(sb, qid.type)) { 843884d179dSJan Kara spin_unlock(&dq_state_lock); 844884d179dSJan Kara spin_unlock(&dq_list_lock); 845884d179dSJan Kara goto out; 846884d179dSJan Kara } 847884d179dSJan Kara spin_unlock(&dq_state_lock); 848884d179dSJan Kara 8491a06d420SEric W. Biederman dquot = find_dquot(hashent, sb, qid); 850dd6f3c6dSJan Kara if (!dquot) { 851dd6f3c6dSJan Kara if (!empty) { 852884d179dSJan Kara spin_unlock(&dq_list_lock); 8531a06d420SEric W. Biederman empty = get_empty_dquot(sb, qid.type); 854dd6f3c6dSJan Kara if (!empty) 855884d179dSJan Kara schedule(); /* Try to wait for a moment... */ 856884d179dSJan Kara goto we_slept; 857884d179dSJan Kara } 858884d179dSJan Kara dquot = empty; 859dd6f3c6dSJan Kara empty = NULL; 8604c376dcaSEric W. Biederman dquot->dq_id = qid; 861884d179dSJan Kara /* all dquots go on the inuse_list */ 862884d179dSJan Kara put_inuse(dquot); 863884d179dSJan Kara /* hash it first so it can be found */ 864884d179dSJan Kara insert_dquot_hash(dquot); 865884d179dSJan Kara spin_unlock(&dq_list_lock); 866dde95888SDmitry Monakhov dqstats_inc(DQST_LOOKUPS); 867884d179dSJan Kara } else { 868884d179dSJan Kara if (!atomic_read(&dquot->dq_count)) 869884d179dSJan Kara remove_free_dquot(dquot); 870884d179dSJan Kara atomic_inc(&dquot->dq_count); 871884d179dSJan Kara spin_unlock(&dq_list_lock); 872dde95888SDmitry Monakhov dqstats_inc(DQST_CACHE_HITS); 873dde95888SDmitry Monakhov dqstats_inc(DQST_LOOKUPS); 874884d179dSJan Kara } 875268157baSJan Kara /* Wait for dq_lock - after this we know that either dquot_release() is 876268157baSJan Kara * already finished or it will be canceled due to dq_count > 1 test */ 877884d179dSJan Kara wait_on_dquot(dquot); 878268157baSJan Kara /* Read the dquot / allocate space in quota file */ 879268157baSJan Kara if (!test_bit(DQ_ACTIVE_B, &dquot->dq_flags) && 880268157baSJan Kara sb->dq_op->acquire_dquot(dquot) < 0) { 881884d179dSJan Kara dqput(dquot); 882dd6f3c6dSJan Kara dquot = NULL; 883884d179dSJan Kara goto out; 884884d179dSJan Kara } 88562af9b52SJan Kara #ifdef CONFIG_QUOTA_DEBUG 886884d179dSJan Kara BUG_ON(!dquot->dq_sb); /* Has somebody invalidated entry under us? */ 887884d179dSJan Kara #endif 888884d179dSJan Kara out: 889884d179dSJan Kara if (empty) 890884d179dSJan Kara do_destroy_dquot(empty); 891884d179dSJan Kara 892884d179dSJan Kara return dquot; 893884d179dSJan Kara } 894884d179dSJan Kara EXPORT_SYMBOL(dqget); 895884d179dSJan Kara 896*2d0fa467SJan Kara static inline struct dquot **i_dquot(struct inode *inode) 897*2d0fa467SJan Kara { 898*2d0fa467SJan Kara /* Temporary workaround until all filesystems are converted. */ 899*2d0fa467SJan Kara if (!inode->i_sb->s_op->get_dquots) 900*2d0fa467SJan Kara return inode->i_dquot; 901*2d0fa467SJan Kara return inode->i_sb->s_op->get_dquots(inode); 902*2d0fa467SJan Kara } 903*2d0fa467SJan Kara 904884d179dSJan Kara static int dqinit_needed(struct inode *inode, int type) 905884d179dSJan Kara { 906884d179dSJan Kara int cnt; 907884d179dSJan Kara 908884d179dSJan Kara if (IS_NOQUOTA(inode)) 909884d179dSJan Kara return 0; 910884d179dSJan Kara if (type != -1) 911*2d0fa467SJan Kara return !i_dquot(inode)[type]; 912884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) 913*2d0fa467SJan Kara if (!i_dquot(inode)[cnt]) 914884d179dSJan Kara return 1; 915884d179dSJan Kara return 0; 916884d179dSJan Kara } 917884d179dSJan Kara 918884d179dSJan Kara /* This routine is guarded by dqonoff_mutex mutex */ 919884d179dSJan Kara static void add_dquot_ref(struct super_block *sb, int type) 920884d179dSJan Kara { 921884d179dSJan Kara struct inode *inode, *old_inode = NULL; 92262af9b52SJan Kara #ifdef CONFIG_QUOTA_DEBUG 9230a5a9c72SJan Kara int reserved = 0; 9244c5e6c0eSJan Kara #endif 925884d179dSJan Kara 92655fa6091SDave Chinner spin_lock(&inode_sb_list_lock); 927884d179dSJan Kara list_for_each_entry(inode, &sb->s_inodes, i_sb_list) { 928250df6edSDave Chinner spin_lock(&inode->i_lock); 929250df6edSDave Chinner if ((inode->i_state & (I_FREEING|I_WILL_FREE|I_NEW)) || 930250df6edSDave Chinner !atomic_read(&inode->i_writecount) || 931250df6edSDave Chinner !dqinit_needed(inode, type)) { 932250df6edSDave Chinner spin_unlock(&inode->i_lock); 9333ae5080fSLinus Torvalds continue; 934250df6edSDave Chinner } 935884d179dSJan Kara __iget(inode); 936250df6edSDave Chinner spin_unlock(&inode->i_lock); 93755fa6091SDave Chinner spin_unlock(&inode_sb_list_lock); 938884d179dSJan Kara 939d7e97117SJan Kara #ifdef CONFIG_QUOTA_DEBUG 940d7e97117SJan Kara if (unlikely(inode_get_rsv_space(inode) > 0)) 941d7e97117SJan Kara reserved = 1; 942d7e97117SJan Kara #endif 943884d179dSJan Kara iput(old_inode); 944871a2931SChristoph Hellwig __dquot_initialize(inode, type); 94555fa6091SDave Chinner 94655fa6091SDave Chinner /* 94755fa6091SDave Chinner * We hold a reference to 'inode' so it couldn't have been 94855fa6091SDave Chinner * removed from s_inodes list while we dropped the 94955fa6091SDave Chinner * inode_sb_list_lock We cannot iput the inode now as we can be 95055fa6091SDave Chinner * holding the last reference and we cannot iput it under 95155fa6091SDave Chinner * inode_sb_list_lock. So we keep the reference and iput it 95255fa6091SDave Chinner * later. 95355fa6091SDave Chinner */ 954884d179dSJan Kara old_inode = inode; 95555fa6091SDave Chinner spin_lock(&inode_sb_list_lock); 956884d179dSJan Kara } 95755fa6091SDave Chinner spin_unlock(&inode_sb_list_lock); 958884d179dSJan Kara iput(old_inode); 9590a5a9c72SJan Kara 96062af9b52SJan Kara #ifdef CONFIG_QUOTA_DEBUG 9610a5a9c72SJan Kara if (reserved) { 962fb5ffb0eSJiaying Zhang quota_error(sb, "Writes happened before quota was turned on " 963fb5ffb0eSJiaying Zhang "thus quota information is probably inconsistent. " 964fb5ffb0eSJiaying Zhang "Please run quotacheck(8)"); 9650a5a9c72SJan Kara } 9664c5e6c0eSJan Kara #endif 967884d179dSJan Kara } 968884d179dSJan Kara 969268157baSJan Kara /* 970268157baSJan Kara * Remove references to dquots from inode and add dquot to list for freeing 97125985edcSLucas De Marchi * if we have the last reference to dquot 972268157baSJan Kara */ 9739eb6463fSNiu Yawei static void remove_inode_dquot_ref(struct inode *inode, int type, 974884d179dSJan Kara struct list_head *tofree_head) 975884d179dSJan Kara { 976*2d0fa467SJan Kara struct dquot *dquot = i_dquot(inode)[type]; 977884d179dSJan Kara 978*2d0fa467SJan Kara i_dquot(inode)[type] = NULL; 9799eb6463fSNiu Yawei if (!dquot) 9809eb6463fSNiu Yawei return; 9819eb6463fSNiu Yawei 9829eb6463fSNiu Yawei if (list_empty(&dquot->dq_free)) { 9839eb6463fSNiu Yawei /* 9849eb6463fSNiu Yawei * The inode still has reference to dquot so it can't be in the 9859eb6463fSNiu Yawei * free list 9869eb6463fSNiu Yawei */ 987884d179dSJan Kara spin_lock(&dq_list_lock); 988268157baSJan Kara list_add(&dquot->dq_free, tofree_head); 989884d179dSJan Kara spin_unlock(&dq_list_lock); 9909eb6463fSNiu Yawei } else { 9919eb6463fSNiu Yawei /* 9929eb6463fSNiu Yawei * Dquot is already in a list to put so we won't drop the last 9939eb6463fSNiu Yawei * reference here. 9949eb6463fSNiu Yawei */ 9959eb6463fSNiu Yawei dqput(dquot); 996884d179dSJan Kara } 997884d179dSJan Kara } 998884d179dSJan Kara 999268157baSJan Kara /* 1000268157baSJan Kara * Free list of dquots 1001268157baSJan Kara * Dquots are removed from inodes and no new references can be got so we are 1002268157baSJan Kara * the only ones holding reference 1003268157baSJan Kara */ 1004884d179dSJan Kara static void put_dquot_list(struct list_head *tofree_head) 1005884d179dSJan Kara { 1006884d179dSJan Kara struct list_head *act_head; 1007884d179dSJan Kara struct dquot *dquot; 1008884d179dSJan Kara 1009884d179dSJan Kara act_head = tofree_head->next; 1010884d179dSJan Kara while (act_head != tofree_head) { 1011884d179dSJan Kara dquot = list_entry(act_head, struct dquot, dq_free); 1012884d179dSJan Kara act_head = act_head->next; 1013268157baSJan Kara /* Remove dquot from the list so we won't have problems... */ 1014268157baSJan Kara list_del_init(&dquot->dq_free); 1015884d179dSJan Kara dqput(dquot); 1016884d179dSJan Kara } 1017884d179dSJan Kara } 1018884d179dSJan Kara 1019884d179dSJan Kara static void remove_dquot_ref(struct super_block *sb, int type, 1020884d179dSJan Kara struct list_head *tofree_head) 1021884d179dSJan Kara { 1022884d179dSJan Kara struct inode *inode; 10237af9cce8SDmitry Monakhov int reserved = 0; 1024884d179dSJan Kara 102555fa6091SDave Chinner spin_lock(&inode_sb_list_lock); 1026884d179dSJan Kara list_for_each_entry(inode, &sb->s_inodes, i_sb_list) { 10273ae5080fSLinus Torvalds /* 10283ae5080fSLinus Torvalds * We have to scan also I_NEW inodes because they can already 10293ae5080fSLinus Torvalds * have quota pointer initialized. Luckily, we need to touch 10303ae5080fSLinus Torvalds * only quota pointers and these have separate locking 1031b9ba6f94SNiu Yawei * (dq_data_lock). 10323ae5080fSLinus Torvalds */ 1033b9ba6f94SNiu Yawei spin_lock(&dq_data_lock); 10347af9cce8SDmitry Monakhov if (!IS_NOQUOTA(inode)) { 10357af9cce8SDmitry Monakhov if (unlikely(inode_get_rsv_space(inode) > 0)) 10367af9cce8SDmitry Monakhov reserved = 1; 1037884d179dSJan Kara remove_inode_dquot_ref(inode, type, tofree_head); 1038884d179dSJan Kara } 1039b9ba6f94SNiu Yawei spin_unlock(&dq_data_lock); 10407af9cce8SDmitry Monakhov } 104155fa6091SDave Chinner spin_unlock(&inode_sb_list_lock); 10427af9cce8SDmitry Monakhov #ifdef CONFIG_QUOTA_DEBUG 10437af9cce8SDmitry Monakhov if (reserved) { 10447af9cce8SDmitry Monakhov printk(KERN_WARNING "VFS (%s): Writes happened after quota" 10457af9cce8SDmitry Monakhov " was disabled thus quota information is probably " 10467af9cce8SDmitry Monakhov "inconsistent. Please run quotacheck(8).\n", sb->s_id); 10477af9cce8SDmitry Monakhov } 10487af9cce8SDmitry Monakhov #endif 1049884d179dSJan Kara } 1050884d179dSJan Kara 1051884d179dSJan Kara /* Gather all references from inodes and drop them */ 1052884d179dSJan Kara static void drop_dquot_ref(struct super_block *sb, int type) 1053884d179dSJan Kara { 1054884d179dSJan Kara LIST_HEAD(tofree_head); 1055884d179dSJan Kara 1056884d179dSJan Kara if (sb->dq_op) { 1057884d179dSJan Kara remove_dquot_ref(sb, type, &tofree_head); 1058b9ba6f94SNiu Yawei synchronize_srcu(&dquot_srcu); 1059884d179dSJan Kara put_dquot_list(&tofree_head); 1060884d179dSJan Kara } 1061884d179dSJan Kara } 1062884d179dSJan Kara 1063884d179dSJan Kara static inline void dquot_incr_inodes(struct dquot *dquot, qsize_t number) 1064884d179dSJan Kara { 1065884d179dSJan Kara dquot->dq_dqb.dqb_curinodes += number; 1066884d179dSJan Kara } 1067884d179dSJan Kara 1068884d179dSJan Kara static inline void dquot_incr_space(struct dquot *dquot, qsize_t number) 1069884d179dSJan Kara { 1070884d179dSJan Kara dquot->dq_dqb.dqb_curspace += number; 1071884d179dSJan Kara } 1072884d179dSJan Kara 1073884d179dSJan Kara static inline void dquot_resv_space(struct dquot *dquot, qsize_t number) 1074884d179dSJan Kara { 1075884d179dSJan Kara dquot->dq_dqb.dqb_rsvspace += number; 1076884d179dSJan Kara } 1077884d179dSJan Kara 1078884d179dSJan Kara /* 1079884d179dSJan Kara * Claim reserved quota space 1080884d179dSJan Kara */ 10810a5a9c72SJan Kara static void dquot_claim_reserved_space(struct dquot *dquot, qsize_t number) 1082884d179dSJan Kara { 10830a5a9c72SJan Kara if (dquot->dq_dqb.dqb_rsvspace < number) { 10840a5a9c72SJan Kara WARN_ON_ONCE(1); 10850a5a9c72SJan Kara number = dquot->dq_dqb.dqb_rsvspace; 10860a5a9c72SJan Kara } 1087884d179dSJan Kara dquot->dq_dqb.dqb_curspace += number; 1088884d179dSJan Kara dquot->dq_dqb.dqb_rsvspace -= number; 1089884d179dSJan Kara } 1090884d179dSJan Kara 10911c8924ebSJan Kara static void dquot_reclaim_reserved_space(struct dquot *dquot, qsize_t number) 10921c8924ebSJan Kara { 10931c8924ebSJan Kara if (WARN_ON_ONCE(dquot->dq_dqb.dqb_curspace < number)) 10941c8924ebSJan Kara number = dquot->dq_dqb.dqb_curspace; 10951c8924ebSJan Kara dquot->dq_dqb.dqb_rsvspace += number; 10961c8924ebSJan Kara dquot->dq_dqb.dqb_curspace -= number; 10971c8924ebSJan Kara } 10981c8924ebSJan Kara 1099884d179dSJan Kara static inline 1100884d179dSJan Kara void dquot_free_reserved_space(struct dquot *dquot, qsize_t number) 1101884d179dSJan Kara { 11020a5a9c72SJan Kara if (dquot->dq_dqb.dqb_rsvspace >= number) 1103884d179dSJan Kara dquot->dq_dqb.dqb_rsvspace -= number; 11040a5a9c72SJan Kara else { 11050a5a9c72SJan Kara WARN_ON_ONCE(1); 11060a5a9c72SJan Kara dquot->dq_dqb.dqb_rsvspace = 0; 11070a5a9c72SJan Kara } 1108884d179dSJan Kara } 1109884d179dSJan Kara 11107a2435d8SJan Kara static void dquot_decr_inodes(struct dquot *dquot, qsize_t number) 1111884d179dSJan Kara { 1112884d179dSJan Kara if (sb_dqopt(dquot->dq_sb)->flags & DQUOT_NEGATIVE_USAGE || 1113884d179dSJan Kara dquot->dq_dqb.dqb_curinodes >= number) 1114884d179dSJan Kara dquot->dq_dqb.dqb_curinodes -= number; 1115884d179dSJan Kara else 1116884d179dSJan Kara dquot->dq_dqb.dqb_curinodes = 0; 1117884d179dSJan Kara if (dquot->dq_dqb.dqb_curinodes <= dquot->dq_dqb.dqb_isoftlimit) 1118884d179dSJan Kara dquot->dq_dqb.dqb_itime = (time_t) 0; 1119884d179dSJan Kara clear_bit(DQ_INODES_B, &dquot->dq_flags); 1120884d179dSJan Kara } 1121884d179dSJan Kara 11227a2435d8SJan Kara static void dquot_decr_space(struct dquot *dquot, qsize_t number) 1123884d179dSJan Kara { 1124884d179dSJan Kara if (sb_dqopt(dquot->dq_sb)->flags & DQUOT_NEGATIVE_USAGE || 1125884d179dSJan Kara dquot->dq_dqb.dqb_curspace >= number) 1126884d179dSJan Kara dquot->dq_dqb.dqb_curspace -= number; 1127884d179dSJan Kara else 1128884d179dSJan Kara dquot->dq_dqb.dqb_curspace = 0; 1129884d179dSJan Kara if (dquot->dq_dqb.dqb_curspace <= dquot->dq_dqb.dqb_bsoftlimit) 1130884d179dSJan Kara dquot->dq_dqb.dqb_btime = (time_t) 0; 1131884d179dSJan Kara clear_bit(DQ_BLKS_B, &dquot->dq_flags); 1132884d179dSJan Kara } 1133884d179dSJan Kara 1134bf097aafSJan Kara struct dquot_warn { 1135bf097aafSJan Kara struct super_block *w_sb; 11367b9c7321SEric W. Biederman struct kqid w_dq_id; 1137bf097aafSJan Kara short w_type; 1138bf097aafSJan Kara }; 1139bf097aafSJan Kara 1140884d179dSJan Kara static int warning_issued(struct dquot *dquot, const int warntype) 1141884d179dSJan Kara { 1142884d179dSJan Kara int flag = (warntype == QUOTA_NL_BHARDWARN || 1143884d179dSJan Kara warntype == QUOTA_NL_BSOFTLONGWARN) ? DQ_BLKS_B : 1144884d179dSJan Kara ((warntype == QUOTA_NL_IHARDWARN || 1145884d179dSJan Kara warntype == QUOTA_NL_ISOFTLONGWARN) ? DQ_INODES_B : 0); 1146884d179dSJan Kara 1147884d179dSJan Kara if (!flag) 1148884d179dSJan Kara return 0; 1149884d179dSJan Kara return test_and_set_bit(flag, &dquot->dq_flags); 1150884d179dSJan Kara } 1151884d179dSJan Kara 1152884d179dSJan Kara #ifdef CONFIG_PRINT_QUOTA_WARNING 1153884d179dSJan Kara static int flag_print_warnings = 1; 1154884d179dSJan Kara 1155bf097aafSJan Kara static int need_print_warning(struct dquot_warn *warn) 1156884d179dSJan Kara { 1157884d179dSJan Kara if (!flag_print_warnings) 1158884d179dSJan Kara return 0; 1159884d179dSJan Kara 11607b9c7321SEric W. Biederman switch (warn->w_dq_id.type) { 1161884d179dSJan Kara case USRQUOTA: 11621a06d420SEric W. Biederman return uid_eq(current_fsuid(), warn->w_dq_id.uid); 1163884d179dSJan Kara case GRPQUOTA: 11647b9c7321SEric W. Biederman return in_group_p(warn->w_dq_id.gid); 11656c29c50fSJan Kara case PRJQUOTA: /* Never taken... Just make gcc happy */ 11666c29c50fSJan Kara return 0; 1167884d179dSJan Kara } 1168884d179dSJan Kara return 0; 1169884d179dSJan Kara } 1170884d179dSJan Kara 1171884d179dSJan Kara /* Print warning to user which exceeded quota */ 1172bf097aafSJan Kara static void print_warning(struct dquot_warn *warn) 1173884d179dSJan Kara { 1174884d179dSJan Kara char *msg = NULL; 1175884d179dSJan Kara struct tty_struct *tty; 1176bf097aafSJan Kara int warntype = warn->w_type; 1177884d179dSJan Kara 1178884d179dSJan Kara if (warntype == QUOTA_NL_IHARDBELOW || 1179884d179dSJan Kara warntype == QUOTA_NL_ISOFTBELOW || 1180884d179dSJan Kara warntype == QUOTA_NL_BHARDBELOW || 1181bf097aafSJan Kara warntype == QUOTA_NL_BSOFTBELOW || !need_print_warning(warn)) 1182884d179dSJan Kara return; 1183884d179dSJan Kara 1184884d179dSJan Kara tty = get_current_tty(); 1185884d179dSJan Kara if (!tty) 1186884d179dSJan Kara return; 1187bf097aafSJan Kara tty_write_message(tty, warn->w_sb->s_id); 1188884d179dSJan Kara if (warntype == QUOTA_NL_ISOFTWARN || warntype == QUOTA_NL_BSOFTWARN) 1189884d179dSJan Kara tty_write_message(tty, ": warning, "); 1190884d179dSJan Kara else 1191884d179dSJan Kara tty_write_message(tty, ": write failed, "); 11927b9c7321SEric W. Biederman tty_write_message(tty, quotatypes[warn->w_dq_id.type]); 1193884d179dSJan Kara switch (warntype) { 1194884d179dSJan Kara case QUOTA_NL_IHARDWARN: 1195884d179dSJan Kara msg = " file limit reached.\r\n"; 1196884d179dSJan Kara break; 1197884d179dSJan Kara case QUOTA_NL_ISOFTLONGWARN: 1198884d179dSJan Kara msg = " file quota exceeded too long.\r\n"; 1199884d179dSJan Kara break; 1200884d179dSJan Kara case QUOTA_NL_ISOFTWARN: 1201884d179dSJan Kara msg = " file quota exceeded.\r\n"; 1202884d179dSJan Kara break; 1203884d179dSJan Kara case QUOTA_NL_BHARDWARN: 1204884d179dSJan Kara msg = " block limit reached.\r\n"; 1205884d179dSJan Kara break; 1206884d179dSJan Kara case QUOTA_NL_BSOFTLONGWARN: 1207884d179dSJan Kara msg = " block quota exceeded too long.\r\n"; 1208884d179dSJan Kara break; 1209884d179dSJan Kara case QUOTA_NL_BSOFTWARN: 1210884d179dSJan Kara msg = " block quota exceeded.\r\n"; 1211884d179dSJan Kara break; 1212884d179dSJan Kara } 1213884d179dSJan Kara tty_write_message(tty, msg); 1214884d179dSJan Kara tty_kref_put(tty); 1215884d179dSJan Kara } 1216884d179dSJan Kara #endif 1217884d179dSJan Kara 1218bf097aafSJan Kara static void prepare_warning(struct dquot_warn *warn, struct dquot *dquot, 1219bf097aafSJan Kara int warntype) 1220bf097aafSJan Kara { 1221bf097aafSJan Kara if (warning_issued(dquot, warntype)) 1222bf097aafSJan Kara return; 1223bf097aafSJan Kara warn->w_type = warntype; 1224bf097aafSJan Kara warn->w_sb = dquot->dq_sb; 1225bf097aafSJan Kara warn->w_dq_id = dquot->dq_id; 1226bf097aafSJan Kara } 1227bf097aafSJan Kara 1228884d179dSJan Kara /* 1229884d179dSJan Kara * Write warnings to the console and send warning messages over netlink. 1230884d179dSJan Kara * 1231bf097aafSJan Kara * Note that this function can call into tty and networking code. 1232884d179dSJan Kara */ 1233bf097aafSJan Kara static void flush_warnings(struct dquot_warn *warn) 1234884d179dSJan Kara { 1235884d179dSJan Kara int i; 1236884d179dSJan Kara 123786e931a3SSteven Whitehouse for (i = 0; i < MAXQUOTAS; i++) { 1238bf097aafSJan Kara if (warn[i].w_type == QUOTA_NL_NOWARN) 1239bf097aafSJan Kara continue; 1240884d179dSJan Kara #ifdef CONFIG_PRINT_QUOTA_WARNING 1241bf097aafSJan Kara print_warning(&warn[i]); 1242884d179dSJan Kara #endif 12437b9c7321SEric W. Biederman quota_send_warning(warn[i].w_dq_id, 1244bf097aafSJan Kara warn[i].w_sb->s_dev, warn[i].w_type); 1245884d179dSJan Kara } 1246884d179dSJan Kara } 1247884d179dSJan Kara 12487a2435d8SJan Kara static int ignore_hardlimit(struct dquot *dquot) 1249884d179dSJan Kara { 12504c376dcaSEric W. Biederman struct mem_dqinfo *info = &sb_dqopt(dquot->dq_sb)->info[dquot->dq_id.type]; 1251884d179dSJan Kara 1252884d179dSJan Kara return capable(CAP_SYS_RESOURCE) && 1253268157baSJan Kara (info->dqi_format->qf_fmt_id != QFMT_VFS_OLD || 1254268157baSJan Kara !(info->dqi_flags & V1_DQF_RSQUASH)); 1255884d179dSJan Kara } 1256884d179dSJan Kara 1257884d179dSJan Kara /* needs dq_data_lock */ 1258bf097aafSJan Kara static int check_idq(struct dquot *dquot, qsize_t inodes, 1259bf097aafSJan Kara struct dquot_warn *warn) 1260884d179dSJan Kara { 1261268157baSJan Kara qsize_t newinodes = dquot->dq_dqb.dqb_curinodes + inodes; 1262268157baSJan Kara 12634c376dcaSEric W. Biederman if (!sb_has_quota_limits_enabled(dquot->dq_sb, dquot->dq_id.type) || 1264884d179dSJan Kara test_bit(DQ_FAKE_B, &dquot->dq_flags)) 1265efd8f0e6SChristoph Hellwig return 0; 1266884d179dSJan Kara 1267884d179dSJan Kara if (dquot->dq_dqb.dqb_ihardlimit && 1268268157baSJan Kara newinodes > dquot->dq_dqb.dqb_ihardlimit && 1269884d179dSJan Kara !ignore_hardlimit(dquot)) { 1270bf097aafSJan Kara prepare_warning(warn, dquot, QUOTA_NL_IHARDWARN); 1271efd8f0e6SChristoph Hellwig return -EDQUOT; 1272884d179dSJan Kara } 1273884d179dSJan Kara 1274884d179dSJan Kara if (dquot->dq_dqb.dqb_isoftlimit && 1275268157baSJan Kara newinodes > dquot->dq_dqb.dqb_isoftlimit && 1276268157baSJan Kara dquot->dq_dqb.dqb_itime && 1277268157baSJan Kara get_seconds() >= dquot->dq_dqb.dqb_itime && 1278884d179dSJan Kara !ignore_hardlimit(dquot)) { 1279bf097aafSJan Kara prepare_warning(warn, dquot, QUOTA_NL_ISOFTLONGWARN); 1280efd8f0e6SChristoph Hellwig return -EDQUOT; 1281884d179dSJan Kara } 1282884d179dSJan Kara 1283884d179dSJan Kara if (dquot->dq_dqb.dqb_isoftlimit && 1284268157baSJan Kara newinodes > dquot->dq_dqb.dqb_isoftlimit && 1285884d179dSJan Kara dquot->dq_dqb.dqb_itime == 0) { 1286bf097aafSJan Kara prepare_warning(warn, dquot, QUOTA_NL_ISOFTWARN); 1287268157baSJan Kara dquot->dq_dqb.dqb_itime = get_seconds() + 12884c376dcaSEric W. Biederman sb_dqopt(dquot->dq_sb)->info[dquot->dq_id.type].dqi_igrace; 1289884d179dSJan Kara } 1290884d179dSJan Kara 1291efd8f0e6SChristoph Hellwig return 0; 1292884d179dSJan Kara } 1293884d179dSJan Kara 1294884d179dSJan Kara /* needs dq_data_lock */ 1295bf097aafSJan Kara static int check_bdq(struct dquot *dquot, qsize_t space, int prealloc, 1296bf097aafSJan Kara struct dquot_warn *warn) 1297884d179dSJan Kara { 1298884d179dSJan Kara qsize_t tspace; 1299268157baSJan Kara struct super_block *sb = dquot->dq_sb; 1300884d179dSJan Kara 13014c376dcaSEric W. Biederman if (!sb_has_quota_limits_enabled(sb, dquot->dq_id.type) || 1302884d179dSJan Kara test_bit(DQ_FAKE_B, &dquot->dq_flags)) 1303efd8f0e6SChristoph Hellwig return 0; 1304884d179dSJan Kara 1305884d179dSJan Kara tspace = dquot->dq_dqb.dqb_curspace + dquot->dq_dqb.dqb_rsvspace 1306884d179dSJan Kara + space; 1307884d179dSJan Kara 1308884d179dSJan Kara if (dquot->dq_dqb.dqb_bhardlimit && 1309884d179dSJan Kara tspace > dquot->dq_dqb.dqb_bhardlimit && 1310884d179dSJan Kara !ignore_hardlimit(dquot)) { 1311884d179dSJan Kara if (!prealloc) 1312bf097aafSJan Kara prepare_warning(warn, dquot, QUOTA_NL_BHARDWARN); 1313efd8f0e6SChristoph Hellwig return -EDQUOT; 1314884d179dSJan Kara } 1315884d179dSJan Kara 1316884d179dSJan Kara if (dquot->dq_dqb.dqb_bsoftlimit && 1317884d179dSJan Kara tspace > dquot->dq_dqb.dqb_bsoftlimit && 1318268157baSJan Kara dquot->dq_dqb.dqb_btime && 1319268157baSJan Kara get_seconds() >= dquot->dq_dqb.dqb_btime && 1320884d179dSJan Kara !ignore_hardlimit(dquot)) { 1321884d179dSJan Kara if (!prealloc) 1322bf097aafSJan Kara prepare_warning(warn, dquot, QUOTA_NL_BSOFTLONGWARN); 1323efd8f0e6SChristoph Hellwig return -EDQUOT; 1324884d179dSJan Kara } 1325884d179dSJan Kara 1326884d179dSJan Kara if (dquot->dq_dqb.dqb_bsoftlimit && 1327884d179dSJan Kara tspace > dquot->dq_dqb.dqb_bsoftlimit && 1328884d179dSJan Kara dquot->dq_dqb.dqb_btime == 0) { 1329884d179dSJan Kara if (!prealloc) { 1330bf097aafSJan Kara prepare_warning(warn, dquot, QUOTA_NL_BSOFTWARN); 1331268157baSJan Kara dquot->dq_dqb.dqb_btime = get_seconds() + 13324c376dcaSEric W. Biederman sb_dqopt(sb)->info[dquot->dq_id.type].dqi_bgrace; 1333884d179dSJan Kara } 1334884d179dSJan Kara else 1335884d179dSJan Kara /* 1336884d179dSJan Kara * We don't allow preallocation to exceed softlimit so exceeding will 1337884d179dSJan Kara * be always printed 1338884d179dSJan Kara */ 1339efd8f0e6SChristoph Hellwig return -EDQUOT; 1340884d179dSJan Kara } 1341884d179dSJan Kara 1342efd8f0e6SChristoph Hellwig return 0; 1343884d179dSJan Kara } 1344884d179dSJan Kara 1345884d179dSJan Kara static int info_idq_free(struct dquot *dquot, qsize_t inodes) 1346884d179dSJan Kara { 1347268157baSJan Kara qsize_t newinodes; 1348268157baSJan Kara 1349884d179dSJan Kara if (test_bit(DQ_FAKE_B, &dquot->dq_flags) || 1350884d179dSJan Kara dquot->dq_dqb.dqb_curinodes <= dquot->dq_dqb.dqb_isoftlimit || 13514c376dcaSEric W. Biederman !sb_has_quota_limits_enabled(dquot->dq_sb, dquot->dq_id.type)) 1352884d179dSJan Kara return QUOTA_NL_NOWARN; 1353884d179dSJan Kara 1354268157baSJan Kara newinodes = dquot->dq_dqb.dqb_curinodes - inodes; 1355268157baSJan Kara if (newinodes <= dquot->dq_dqb.dqb_isoftlimit) 1356884d179dSJan Kara return QUOTA_NL_ISOFTBELOW; 1357884d179dSJan Kara if (dquot->dq_dqb.dqb_curinodes >= dquot->dq_dqb.dqb_ihardlimit && 1358268157baSJan Kara newinodes < dquot->dq_dqb.dqb_ihardlimit) 1359884d179dSJan Kara return QUOTA_NL_IHARDBELOW; 1360884d179dSJan Kara return QUOTA_NL_NOWARN; 1361884d179dSJan Kara } 1362884d179dSJan Kara 1363884d179dSJan Kara static int info_bdq_free(struct dquot *dquot, qsize_t space) 1364884d179dSJan Kara { 1365884d179dSJan Kara if (test_bit(DQ_FAKE_B, &dquot->dq_flags) || 1366884d179dSJan Kara dquot->dq_dqb.dqb_curspace <= dquot->dq_dqb.dqb_bsoftlimit) 1367884d179dSJan Kara return QUOTA_NL_NOWARN; 1368884d179dSJan Kara 1369884d179dSJan Kara if (dquot->dq_dqb.dqb_curspace - space <= dquot->dq_dqb.dqb_bsoftlimit) 1370884d179dSJan Kara return QUOTA_NL_BSOFTBELOW; 1371884d179dSJan Kara if (dquot->dq_dqb.dqb_curspace >= dquot->dq_dqb.dqb_bhardlimit && 1372884d179dSJan Kara dquot->dq_dqb.dqb_curspace - space < dquot->dq_dqb.dqb_bhardlimit) 1373884d179dSJan Kara return QUOTA_NL_BHARDBELOW; 1374884d179dSJan Kara return QUOTA_NL_NOWARN; 1375884d179dSJan Kara } 13760a5a9c72SJan Kara 1377189eef59SChristoph Hellwig static int dquot_active(const struct inode *inode) 1378189eef59SChristoph Hellwig { 1379189eef59SChristoph Hellwig struct super_block *sb = inode->i_sb; 1380189eef59SChristoph Hellwig 1381189eef59SChristoph Hellwig if (IS_NOQUOTA(inode)) 1382189eef59SChristoph Hellwig return 0; 1383189eef59SChristoph Hellwig return sb_any_quota_loaded(sb) & ~sb_any_quota_suspended(sb); 1384189eef59SChristoph Hellwig } 1385189eef59SChristoph Hellwig 1386884d179dSJan Kara /* 1387884d179dSJan Kara * Initialize quota pointers in inode 1388871a2931SChristoph Hellwig * 1389871a2931SChristoph Hellwig * It is better to call this function outside of any transaction as it 1390871a2931SChristoph Hellwig * might need a lot of space in journal for dquot structure allocation. 1391884d179dSJan Kara */ 1392871a2931SChristoph Hellwig static void __dquot_initialize(struct inode *inode, int type) 1393884d179dSJan Kara { 13941ea06becSNiu Yawei int cnt, init_needed = 0; 1395ad1e6e8dSDmitry Monakhov struct dquot *got[MAXQUOTAS]; 1396884d179dSJan Kara struct super_block *sb = inode->i_sb; 13970a5a9c72SJan Kara qsize_t rsv; 1398884d179dSJan Kara 1399189eef59SChristoph Hellwig if (!dquot_active(inode)) 1400871a2931SChristoph Hellwig return; 1401884d179dSJan Kara 1402884d179dSJan Kara /* First get references to structures we might need. */ 1403884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1404aca645a6SEric W. Biederman struct kqid qid; 1405ad1e6e8dSDmitry Monakhov got[cnt] = NULL; 1406884d179dSJan Kara if (type != -1 && cnt != type) 1407884d179dSJan Kara continue; 14081ea06becSNiu Yawei /* 14091ea06becSNiu Yawei * The i_dquot should have been initialized in most cases, 14101ea06becSNiu Yawei * we check it without locking here to avoid unnecessary 14111ea06becSNiu Yawei * dqget()/dqput() calls. 14121ea06becSNiu Yawei */ 1413*2d0fa467SJan Kara if (i_dquot(inode)[cnt]) 14141ea06becSNiu Yawei continue; 14151ea06becSNiu Yawei init_needed = 1; 14161ea06becSNiu Yawei 1417884d179dSJan Kara switch (cnt) { 1418884d179dSJan Kara case USRQUOTA: 1419aca645a6SEric W. Biederman qid = make_kqid_uid(inode->i_uid); 1420884d179dSJan Kara break; 1421884d179dSJan Kara case GRPQUOTA: 1422aca645a6SEric W. Biederman qid = make_kqid_gid(inode->i_gid); 1423884d179dSJan Kara break; 1424884d179dSJan Kara } 1425aca645a6SEric W. Biederman got[cnt] = dqget(sb, qid); 1426884d179dSJan Kara } 1427884d179dSJan Kara 14281ea06becSNiu Yawei /* All required i_dquot has been initialized */ 14291ea06becSNiu Yawei if (!init_needed) 14301ea06becSNiu Yawei return; 14311ea06becSNiu Yawei 1432b9ba6f94SNiu Yawei spin_lock(&dq_data_lock); 1433884d179dSJan Kara if (IS_NOQUOTA(inode)) 1434884d179dSJan Kara goto out_err; 1435884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1436884d179dSJan Kara if (type != -1 && cnt != type) 1437884d179dSJan Kara continue; 1438884d179dSJan Kara /* Avoid races with quotaoff() */ 1439884d179dSJan Kara if (!sb_has_quota_active(sb, cnt)) 1440884d179dSJan Kara continue; 14414408ea41SJan Kara /* We could race with quotaon or dqget() could have failed */ 14424408ea41SJan Kara if (!got[cnt]) 14434408ea41SJan Kara continue; 1444*2d0fa467SJan Kara if (!i_dquot(inode)[cnt]) { 1445*2d0fa467SJan Kara i_dquot(inode)[cnt] = got[cnt]; 1446dd6f3c6dSJan Kara got[cnt] = NULL; 14470a5a9c72SJan Kara /* 14480a5a9c72SJan Kara * Make quota reservation system happy if someone 14490a5a9c72SJan Kara * did a write before quota was turned on 14500a5a9c72SJan Kara */ 14510a5a9c72SJan Kara rsv = inode_get_rsv_space(inode); 1452b9ba6f94SNiu Yawei if (unlikely(rsv)) 1453*2d0fa467SJan Kara dquot_resv_space(i_dquot(inode)[cnt], rsv); 1454884d179dSJan Kara } 1455884d179dSJan Kara } 1456884d179dSJan Kara out_err: 1457b9ba6f94SNiu Yawei spin_unlock(&dq_data_lock); 1458884d179dSJan Kara /* Drop unused references */ 1459dc52dd3aSDmitry Monakhov dqput_all(got); 1460871a2931SChristoph Hellwig } 1461871a2931SChristoph Hellwig 1462871a2931SChristoph Hellwig void dquot_initialize(struct inode *inode) 1463871a2931SChristoph Hellwig { 1464871a2931SChristoph Hellwig __dquot_initialize(inode, -1); 1465884d179dSJan Kara } 1466884d179dSJan Kara EXPORT_SYMBOL(dquot_initialize); 1467884d179dSJan Kara 1468884d179dSJan Kara /* 1469b9ba6f94SNiu Yawei * Release all quotas referenced by inode. 1470b9ba6f94SNiu Yawei * 1471b9ba6f94SNiu Yawei * This function only be called on inode free or converting 1472b9ba6f94SNiu Yawei * a file to quota file, no other users for the i_dquot in 1473b9ba6f94SNiu Yawei * both cases, so we needn't call synchronize_srcu() after 1474b9ba6f94SNiu Yawei * clearing i_dquot. 1475884d179dSJan Kara */ 14769f754758SChristoph Hellwig static void __dquot_drop(struct inode *inode) 1477884d179dSJan Kara { 1478884d179dSJan Kara int cnt; 1479884d179dSJan Kara struct dquot *put[MAXQUOTAS]; 1480884d179dSJan Kara 1481b9ba6f94SNiu Yawei spin_lock(&dq_data_lock); 1482884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1483*2d0fa467SJan Kara put[cnt] = i_dquot(inode)[cnt]; 1484*2d0fa467SJan Kara i_dquot(inode)[cnt] = NULL; 1485884d179dSJan Kara } 1486b9ba6f94SNiu Yawei spin_unlock(&dq_data_lock); 1487dc52dd3aSDmitry Monakhov dqput_all(put); 1488884d179dSJan Kara } 1489884d179dSJan Kara 14909f754758SChristoph Hellwig void dquot_drop(struct inode *inode) 1491884d179dSJan Kara { 1492884d179dSJan Kara int cnt; 14939f754758SChristoph Hellwig 14949f754758SChristoph Hellwig if (IS_NOQUOTA(inode)) 14959f754758SChristoph Hellwig return; 14969f754758SChristoph Hellwig 14979f754758SChristoph Hellwig /* 14989f754758SChristoph Hellwig * Test before calling to rule out calls from proc and such 1499884d179dSJan Kara * where we are not allowed to block. Note that this is 1500884d179dSJan Kara * actually reliable test even without the lock - the caller 1501884d179dSJan Kara * must assure that nobody can come after the DQUOT_DROP and 15029f754758SChristoph Hellwig * add quota pointers back anyway. 15039f754758SChristoph Hellwig */ 15049f754758SChristoph Hellwig for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1505*2d0fa467SJan Kara if (i_dquot(inode)[cnt]) 1506884d179dSJan Kara break; 15079f754758SChristoph Hellwig } 15089f754758SChristoph Hellwig 1509884d179dSJan Kara if (cnt < MAXQUOTAS) 15109f754758SChristoph Hellwig __dquot_drop(inode); 1511884d179dSJan Kara } 15129f754758SChristoph Hellwig EXPORT_SYMBOL(dquot_drop); 1513884d179dSJan Kara 1514884d179dSJan Kara /* 1515fd8fbfc1SDmitry Monakhov * inode_reserved_space is managed internally by quota, and protected by 1516fd8fbfc1SDmitry Monakhov * i_lock similar to i_blocks+i_bytes. 1517fd8fbfc1SDmitry Monakhov */ 1518fd8fbfc1SDmitry Monakhov static qsize_t *inode_reserved_space(struct inode * inode) 1519fd8fbfc1SDmitry Monakhov { 1520fd8fbfc1SDmitry Monakhov /* Filesystem must explicitly define it's own method in order to use 1521fd8fbfc1SDmitry Monakhov * quota reservation interface */ 1522fd8fbfc1SDmitry Monakhov BUG_ON(!inode->i_sb->dq_op->get_reserved_space); 1523fd8fbfc1SDmitry Monakhov return inode->i_sb->dq_op->get_reserved_space(inode); 1524fd8fbfc1SDmitry Monakhov } 1525fd8fbfc1SDmitry Monakhov 1526c469070aSDmitry Monakhov void inode_add_rsv_space(struct inode *inode, qsize_t number) 1527fd8fbfc1SDmitry Monakhov { 1528fd8fbfc1SDmitry Monakhov spin_lock(&inode->i_lock); 1529fd8fbfc1SDmitry Monakhov *inode_reserved_space(inode) += number; 1530fd8fbfc1SDmitry Monakhov spin_unlock(&inode->i_lock); 1531fd8fbfc1SDmitry Monakhov } 1532c469070aSDmitry Monakhov EXPORT_SYMBOL(inode_add_rsv_space); 1533fd8fbfc1SDmitry Monakhov 1534c469070aSDmitry Monakhov void inode_claim_rsv_space(struct inode *inode, qsize_t number) 1535fd8fbfc1SDmitry Monakhov { 1536fd8fbfc1SDmitry Monakhov spin_lock(&inode->i_lock); 1537fd8fbfc1SDmitry Monakhov *inode_reserved_space(inode) -= number; 1538fd8fbfc1SDmitry Monakhov __inode_add_bytes(inode, number); 1539fd8fbfc1SDmitry Monakhov spin_unlock(&inode->i_lock); 1540fd8fbfc1SDmitry Monakhov } 1541c469070aSDmitry Monakhov EXPORT_SYMBOL(inode_claim_rsv_space); 1542fd8fbfc1SDmitry Monakhov 15431c8924ebSJan Kara void inode_reclaim_rsv_space(struct inode *inode, qsize_t number) 15441c8924ebSJan Kara { 15451c8924ebSJan Kara spin_lock(&inode->i_lock); 15461c8924ebSJan Kara *inode_reserved_space(inode) += number; 15471c8924ebSJan Kara __inode_sub_bytes(inode, number); 15481c8924ebSJan Kara spin_unlock(&inode->i_lock); 15491c8924ebSJan Kara } 15501c8924ebSJan Kara EXPORT_SYMBOL(inode_reclaim_rsv_space); 15511c8924ebSJan Kara 1552c469070aSDmitry Monakhov void inode_sub_rsv_space(struct inode *inode, qsize_t number) 1553fd8fbfc1SDmitry Monakhov { 1554fd8fbfc1SDmitry Monakhov spin_lock(&inode->i_lock); 1555fd8fbfc1SDmitry Monakhov *inode_reserved_space(inode) -= number; 1556fd8fbfc1SDmitry Monakhov spin_unlock(&inode->i_lock); 1557fd8fbfc1SDmitry Monakhov } 1558c469070aSDmitry Monakhov EXPORT_SYMBOL(inode_sub_rsv_space); 1559fd8fbfc1SDmitry Monakhov 1560fd8fbfc1SDmitry Monakhov static qsize_t inode_get_rsv_space(struct inode *inode) 1561fd8fbfc1SDmitry Monakhov { 1562fd8fbfc1SDmitry Monakhov qsize_t ret; 156305b5d898SJan Kara 156405b5d898SJan Kara if (!inode->i_sb->dq_op->get_reserved_space) 156505b5d898SJan Kara return 0; 1566fd8fbfc1SDmitry Monakhov spin_lock(&inode->i_lock); 1567fd8fbfc1SDmitry Monakhov ret = *inode_reserved_space(inode); 1568fd8fbfc1SDmitry Monakhov spin_unlock(&inode->i_lock); 1569fd8fbfc1SDmitry Monakhov return ret; 1570fd8fbfc1SDmitry Monakhov } 1571fd8fbfc1SDmitry Monakhov 1572fd8fbfc1SDmitry Monakhov static void inode_incr_space(struct inode *inode, qsize_t number, 1573fd8fbfc1SDmitry Monakhov int reserve) 1574fd8fbfc1SDmitry Monakhov { 1575fd8fbfc1SDmitry Monakhov if (reserve) 1576fd8fbfc1SDmitry Monakhov inode_add_rsv_space(inode, number); 1577fd8fbfc1SDmitry Monakhov else 1578fd8fbfc1SDmitry Monakhov inode_add_bytes(inode, number); 1579fd8fbfc1SDmitry Monakhov } 1580fd8fbfc1SDmitry Monakhov 1581fd8fbfc1SDmitry Monakhov static void inode_decr_space(struct inode *inode, qsize_t number, int reserve) 1582fd8fbfc1SDmitry Monakhov { 1583fd8fbfc1SDmitry Monakhov if (reserve) 1584fd8fbfc1SDmitry Monakhov inode_sub_rsv_space(inode, number); 1585fd8fbfc1SDmitry Monakhov else 1586fd8fbfc1SDmitry Monakhov inode_sub_bytes(inode, number); 1587fd8fbfc1SDmitry Monakhov } 1588fd8fbfc1SDmitry Monakhov 1589fd8fbfc1SDmitry Monakhov /* 15905dd4056dSChristoph Hellwig * This functions updates i_blocks+i_bytes fields and quota information 15915dd4056dSChristoph Hellwig * (together with appropriate checks). 15925dd4056dSChristoph Hellwig * 15935dd4056dSChristoph Hellwig * NOTE: We absolutely rely on the fact that caller dirties the inode 15945dd4056dSChristoph Hellwig * (usually helpers in quotaops.h care about this) and holds a handle for 15955dd4056dSChristoph Hellwig * the current transaction so that dquot write and inode write go into the 15965dd4056dSChristoph Hellwig * same transaction. 1597884d179dSJan Kara */ 1598884d179dSJan Kara 1599884d179dSJan Kara /* 1600884d179dSJan Kara * This operation can block, but only after everything is updated 1601884d179dSJan Kara */ 160256246f9aSEric Sandeen int __dquot_alloc_space(struct inode *inode, qsize_t number, int flags) 1603884d179dSJan Kara { 1604b9ba6f94SNiu Yawei int cnt, ret = 0, index; 1605bf097aafSJan Kara struct dquot_warn warn[MAXQUOTAS]; 1606*2d0fa467SJan Kara struct dquot **dquots = i_dquot(inode); 160756246f9aSEric Sandeen int reserve = flags & DQUOT_SPACE_RESERVE; 1608884d179dSJan Kara 1609189eef59SChristoph Hellwig if (!dquot_active(inode)) { 1610fd8fbfc1SDmitry Monakhov inode_incr_space(inode, number, reserve); 1611fd8fbfc1SDmitry Monakhov goto out; 1612fd8fbfc1SDmitry Monakhov } 1613fd8fbfc1SDmitry Monakhov 1614884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) 1615bf097aafSJan Kara warn[cnt].w_type = QUOTA_NL_NOWARN; 1616884d179dSJan Kara 1617b9ba6f94SNiu Yawei index = srcu_read_lock(&dquot_srcu); 1618884d179dSJan Kara spin_lock(&dq_data_lock); 1619884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1620bf097aafSJan Kara if (!dquots[cnt]) 1621884d179dSJan Kara continue; 1622bf097aafSJan Kara ret = check_bdq(dquots[cnt], number, 1623bf097aafSJan Kara !(flags & DQUOT_SPACE_WARN), &warn[cnt]); 1624bf097aafSJan Kara if (ret && !(flags & DQUOT_SPACE_NOFAIL)) { 1625fd8fbfc1SDmitry Monakhov spin_unlock(&dq_data_lock); 1626fd8fbfc1SDmitry Monakhov goto out_flush_warn; 1627884d179dSJan Kara } 1628884d179dSJan Kara } 1629884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1630bf097aafSJan Kara if (!dquots[cnt]) 1631884d179dSJan Kara continue; 1632884d179dSJan Kara if (reserve) 1633bf097aafSJan Kara dquot_resv_space(dquots[cnt], number); 1634884d179dSJan Kara else 1635bf097aafSJan Kara dquot_incr_space(dquots[cnt], number); 1636884d179dSJan Kara } 1637fd8fbfc1SDmitry Monakhov inode_incr_space(inode, number, reserve); 1638884d179dSJan Kara spin_unlock(&dq_data_lock); 1639fd8fbfc1SDmitry Monakhov 1640fd8fbfc1SDmitry Monakhov if (reserve) 1641fd8fbfc1SDmitry Monakhov goto out_flush_warn; 1642bf097aafSJan Kara mark_all_dquot_dirty(dquots); 1643fd8fbfc1SDmitry Monakhov out_flush_warn: 1644b9ba6f94SNiu Yawei srcu_read_unlock(&dquot_srcu, index); 1645bf097aafSJan Kara flush_warnings(warn); 1646fd8fbfc1SDmitry Monakhov out: 1647884d179dSJan Kara return ret; 1648884d179dSJan Kara } 16495dd4056dSChristoph Hellwig EXPORT_SYMBOL(__dquot_alloc_space); 1650884d179dSJan Kara 1651884d179dSJan Kara /* 1652884d179dSJan Kara * This operation can block, but only after everything is updated 1653884d179dSJan Kara */ 16546bab3596SJan Kara int dquot_alloc_inode(struct inode *inode) 1655884d179dSJan Kara { 1656b9ba6f94SNiu Yawei int cnt, ret = 0, index; 1657bf097aafSJan Kara struct dquot_warn warn[MAXQUOTAS]; 1658*2d0fa467SJan Kara struct dquot * const *dquots = i_dquot(inode); 1659884d179dSJan Kara 1660189eef59SChristoph Hellwig if (!dquot_active(inode)) 166163936ddaSChristoph Hellwig return 0; 1662884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) 1663bf097aafSJan Kara warn[cnt].w_type = QUOTA_NL_NOWARN; 1664b9ba6f94SNiu Yawei 1665b9ba6f94SNiu Yawei index = srcu_read_lock(&dquot_srcu); 1666884d179dSJan Kara spin_lock(&dq_data_lock); 1667884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1668bf097aafSJan Kara if (!dquots[cnt]) 1669884d179dSJan Kara continue; 1670bf097aafSJan Kara ret = check_idq(dquots[cnt], 1, &warn[cnt]); 1671efd8f0e6SChristoph Hellwig if (ret) 1672884d179dSJan Kara goto warn_put_all; 1673884d179dSJan Kara } 1674884d179dSJan Kara 1675884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1676bf097aafSJan Kara if (!dquots[cnt]) 1677884d179dSJan Kara continue; 1678bf097aafSJan Kara dquot_incr_inodes(dquots[cnt], 1); 1679884d179dSJan Kara } 1680efd8f0e6SChristoph Hellwig 1681884d179dSJan Kara warn_put_all: 1682884d179dSJan Kara spin_unlock(&dq_data_lock); 168363936ddaSChristoph Hellwig if (ret == 0) 1684bf097aafSJan Kara mark_all_dquot_dirty(dquots); 1685b9ba6f94SNiu Yawei srcu_read_unlock(&dquot_srcu, index); 1686bf097aafSJan Kara flush_warnings(warn); 1687884d179dSJan Kara return ret; 1688884d179dSJan Kara } 1689884d179dSJan Kara EXPORT_SYMBOL(dquot_alloc_inode); 1690884d179dSJan Kara 16915dd4056dSChristoph Hellwig /* 16925dd4056dSChristoph Hellwig * Convert in-memory reserved quotas to real consumed quotas 16935dd4056dSChristoph Hellwig */ 16945dd4056dSChristoph Hellwig int dquot_claim_space_nodirty(struct inode *inode, qsize_t number) 1695884d179dSJan Kara { 1696b9ba6f94SNiu Yawei int cnt, index; 1697884d179dSJan Kara 1698189eef59SChristoph Hellwig if (!dquot_active(inode)) { 1699fd8fbfc1SDmitry Monakhov inode_claim_rsv_space(inode, number); 17005dd4056dSChristoph Hellwig return 0; 1701884d179dSJan Kara } 1702884d179dSJan Kara 1703b9ba6f94SNiu Yawei index = srcu_read_lock(&dquot_srcu); 1704884d179dSJan Kara spin_lock(&dq_data_lock); 1705884d179dSJan Kara /* Claim reserved quotas to allocated quotas */ 1706884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1707*2d0fa467SJan Kara if (i_dquot(inode)[cnt]) 1708*2d0fa467SJan Kara dquot_claim_reserved_space(i_dquot(inode)[cnt], 1709884d179dSJan Kara number); 1710884d179dSJan Kara } 1711884d179dSJan Kara /* Update inode bytes */ 1712fd8fbfc1SDmitry Monakhov inode_claim_rsv_space(inode, number); 1713884d179dSJan Kara spin_unlock(&dq_data_lock); 1714*2d0fa467SJan Kara mark_all_dquot_dirty(i_dquot(inode)); 1715b9ba6f94SNiu Yawei srcu_read_unlock(&dquot_srcu, index); 17165dd4056dSChristoph Hellwig return 0; 1717884d179dSJan Kara } 17185dd4056dSChristoph Hellwig EXPORT_SYMBOL(dquot_claim_space_nodirty); 1719884d179dSJan Kara 1720884d179dSJan Kara /* 17211c8924ebSJan Kara * Convert allocated space back to in-memory reserved quotas 17221c8924ebSJan Kara */ 17231c8924ebSJan Kara void dquot_reclaim_space_nodirty(struct inode *inode, qsize_t number) 17241c8924ebSJan Kara { 1725b9ba6f94SNiu Yawei int cnt, index; 17261c8924ebSJan Kara 17271c8924ebSJan Kara if (!dquot_active(inode)) { 17281c8924ebSJan Kara inode_reclaim_rsv_space(inode, number); 17291c8924ebSJan Kara return; 17301c8924ebSJan Kara } 17311c8924ebSJan Kara 1732b9ba6f94SNiu Yawei index = srcu_read_lock(&dquot_srcu); 17331c8924ebSJan Kara spin_lock(&dq_data_lock); 17341c8924ebSJan Kara /* Claim reserved quotas to allocated quotas */ 17351c8924ebSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1736*2d0fa467SJan Kara if (i_dquot(inode)[cnt]) 1737*2d0fa467SJan Kara dquot_reclaim_reserved_space(i_dquot(inode)[cnt], 17381c8924ebSJan Kara number); 17391c8924ebSJan Kara } 17401c8924ebSJan Kara /* Update inode bytes */ 17411c8924ebSJan Kara inode_reclaim_rsv_space(inode, number); 17421c8924ebSJan Kara spin_unlock(&dq_data_lock); 1743*2d0fa467SJan Kara mark_all_dquot_dirty(i_dquot(inode)); 1744b9ba6f94SNiu Yawei srcu_read_unlock(&dquot_srcu, index); 17451c8924ebSJan Kara return; 17461c8924ebSJan Kara } 17471c8924ebSJan Kara EXPORT_SYMBOL(dquot_reclaim_space_nodirty); 17481c8924ebSJan Kara 17491c8924ebSJan Kara /* 1750884d179dSJan Kara * This operation can block, but only after everything is updated 1751884d179dSJan Kara */ 175256246f9aSEric Sandeen void __dquot_free_space(struct inode *inode, qsize_t number, int flags) 1753884d179dSJan Kara { 1754884d179dSJan Kara unsigned int cnt; 1755bf097aafSJan Kara struct dquot_warn warn[MAXQUOTAS]; 1756*2d0fa467SJan Kara struct dquot **dquots = i_dquot(inode); 1757b9ba6f94SNiu Yawei int reserve = flags & DQUOT_SPACE_RESERVE, index; 1758884d179dSJan Kara 1759189eef59SChristoph Hellwig if (!dquot_active(inode)) { 1760fd8fbfc1SDmitry Monakhov inode_decr_space(inode, number, reserve); 17615dd4056dSChristoph Hellwig return; 1762884d179dSJan Kara } 1763884d179dSJan Kara 1764b9ba6f94SNiu Yawei index = srcu_read_lock(&dquot_srcu); 1765884d179dSJan Kara spin_lock(&dq_data_lock); 1766884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1767bf097aafSJan Kara int wtype; 1768bf097aafSJan Kara 1769bf097aafSJan Kara warn[cnt].w_type = QUOTA_NL_NOWARN; 1770bf097aafSJan Kara if (!dquots[cnt]) 1771884d179dSJan Kara continue; 1772bf097aafSJan Kara wtype = info_bdq_free(dquots[cnt], number); 1773bf097aafSJan Kara if (wtype != QUOTA_NL_NOWARN) 1774bf097aafSJan Kara prepare_warning(&warn[cnt], dquots[cnt], wtype); 1775fd8fbfc1SDmitry Monakhov if (reserve) 1776bf097aafSJan Kara dquot_free_reserved_space(dquots[cnt], number); 1777fd8fbfc1SDmitry Monakhov else 1778bf097aafSJan Kara dquot_decr_space(dquots[cnt], number); 1779884d179dSJan Kara } 1780fd8fbfc1SDmitry Monakhov inode_decr_space(inode, number, reserve); 1781884d179dSJan Kara spin_unlock(&dq_data_lock); 1782fd8fbfc1SDmitry Monakhov 1783fd8fbfc1SDmitry Monakhov if (reserve) 1784fd8fbfc1SDmitry Monakhov goto out_unlock; 1785bf097aafSJan Kara mark_all_dquot_dirty(dquots); 1786fd8fbfc1SDmitry Monakhov out_unlock: 1787b9ba6f94SNiu Yawei srcu_read_unlock(&dquot_srcu, index); 1788bf097aafSJan Kara flush_warnings(warn); 1789884d179dSJan Kara } 17905dd4056dSChristoph Hellwig EXPORT_SYMBOL(__dquot_free_space); 1791fd8fbfc1SDmitry Monakhov 1792fd8fbfc1SDmitry Monakhov /* 1793884d179dSJan Kara * This operation can block, but only after everything is updated 1794884d179dSJan Kara */ 17956bab3596SJan Kara void dquot_free_inode(struct inode *inode) 1796884d179dSJan Kara { 1797884d179dSJan Kara unsigned int cnt; 1798bf097aafSJan Kara struct dquot_warn warn[MAXQUOTAS]; 1799*2d0fa467SJan Kara struct dquot * const *dquots = i_dquot(inode); 1800b9ba6f94SNiu Yawei int index; 1801884d179dSJan Kara 1802189eef59SChristoph Hellwig if (!dquot_active(inode)) 180363936ddaSChristoph Hellwig return; 1804884d179dSJan Kara 1805b9ba6f94SNiu Yawei index = srcu_read_lock(&dquot_srcu); 1806884d179dSJan Kara spin_lock(&dq_data_lock); 1807884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1808bf097aafSJan Kara int wtype; 1809bf097aafSJan Kara 1810bf097aafSJan Kara warn[cnt].w_type = QUOTA_NL_NOWARN; 1811bf097aafSJan Kara if (!dquots[cnt]) 1812884d179dSJan Kara continue; 1813bf097aafSJan Kara wtype = info_idq_free(dquots[cnt], 1); 1814bf097aafSJan Kara if (wtype != QUOTA_NL_NOWARN) 1815bf097aafSJan Kara prepare_warning(&warn[cnt], dquots[cnt], wtype); 1816bf097aafSJan Kara dquot_decr_inodes(dquots[cnt], 1); 1817884d179dSJan Kara } 1818884d179dSJan Kara spin_unlock(&dq_data_lock); 1819bf097aafSJan Kara mark_all_dquot_dirty(dquots); 1820b9ba6f94SNiu Yawei srcu_read_unlock(&dquot_srcu, index); 1821bf097aafSJan Kara flush_warnings(warn); 1822884d179dSJan Kara } 1823884d179dSJan Kara EXPORT_SYMBOL(dquot_free_inode); 1824884d179dSJan Kara 1825884d179dSJan Kara /* 1826884d179dSJan Kara * Transfer the number of inode and blocks from one diskquota to an other. 1827bc8e5f07SJan Kara * On success, dquot references in transfer_to are consumed and references 1828bc8e5f07SJan Kara * to original dquots that need to be released are placed there. On failure, 1829bc8e5f07SJan Kara * references are kept untouched. 1830884d179dSJan Kara * 1831884d179dSJan Kara * This operation can block, but only after everything is updated 1832884d179dSJan Kara * A transaction must be started when entering this function. 1833bc8e5f07SJan Kara * 1834b9ba6f94SNiu Yawei * We are holding reference on transfer_from & transfer_to, no need to 1835b9ba6f94SNiu Yawei * protect them by srcu_read_lock(). 1836884d179dSJan Kara */ 1837bc8e5f07SJan Kara int __dquot_transfer(struct inode *inode, struct dquot **transfer_to) 1838884d179dSJan Kara { 1839884d179dSJan Kara qsize_t space, cur_space; 1840884d179dSJan Kara qsize_t rsv_space = 0; 1841bc8e5f07SJan Kara struct dquot *transfer_from[MAXQUOTAS] = {}; 1842efd8f0e6SChristoph Hellwig int cnt, ret = 0; 18439e32784bSDmitry char is_valid[MAXQUOTAS] = {}; 1844bf097aafSJan Kara struct dquot_warn warn_to[MAXQUOTAS]; 1845bf097aafSJan Kara struct dquot_warn warn_from_inodes[MAXQUOTAS]; 1846bf097aafSJan Kara struct dquot_warn warn_from_space[MAXQUOTAS]; 1847884d179dSJan Kara 1848884d179dSJan Kara if (IS_NOQUOTA(inode)) 1849efd8f0e6SChristoph Hellwig return 0; 1850884d179dSJan Kara /* Initialize the arrays */ 1851bf097aafSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1852bf097aafSJan Kara warn_to[cnt].w_type = QUOTA_NL_NOWARN; 1853bf097aafSJan Kara warn_from_inodes[cnt].w_type = QUOTA_NL_NOWARN; 1854bf097aafSJan Kara warn_from_space[cnt].w_type = QUOTA_NL_NOWARN; 1855bf097aafSJan Kara } 1856b9ba6f94SNiu Yawei 1857b9ba6f94SNiu Yawei spin_lock(&dq_data_lock); 1858884d179dSJan Kara if (IS_NOQUOTA(inode)) { /* File without quota accounting? */ 1859b9ba6f94SNiu Yawei spin_unlock(&dq_data_lock); 1860bc8e5f07SJan Kara return 0; 1861884d179dSJan Kara } 1862884d179dSJan Kara cur_space = inode_get_bytes(inode); 1863fd8fbfc1SDmitry Monakhov rsv_space = inode_get_rsv_space(inode); 1864884d179dSJan Kara space = cur_space + rsv_space; 1865884d179dSJan Kara /* Build the transfer_from list and check the limits */ 1866884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 18679e32784bSDmitry /* 18689e32784bSDmitry * Skip changes for same uid or gid or for turned off quota-type. 18699e32784bSDmitry */ 1870dd6f3c6dSJan Kara if (!transfer_to[cnt]) 1871884d179dSJan Kara continue; 18729e32784bSDmitry /* Avoid races with quotaoff() */ 18739e32784bSDmitry if (!sb_has_quota_active(inode->i_sb, cnt)) 18749e32784bSDmitry continue; 18759e32784bSDmitry is_valid[cnt] = 1; 1876*2d0fa467SJan Kara transfer_from[cnt] = i_dquot(inode)[cnt]; 1877bf097aafSJan Kara ret = check_idq(transfer_to[cnt], 1, &warn_to[cnt]); 1878efd8f0e6SChristoph Hellwig if (ret) 1879efd8f0e6SChristoph Hellwig goto over_quota; 1880bf097aafSJan Kara ret = check_bdq(transfer_to[cnt], space, 0, &warn_to[cnt]); 1881efd8f0e6SChristoph Hellwig if (ret) 1882884d179dSJan Kara goto over_quota; 1883884d179dSJan Kara } 1884884d179dSJan Kara 1885884d179dSJan Kara /* 1886884d179dSJan Kara * Finally perform the needed transfer from transfer_from to transfer_to 1887884d179dSJan Kara */ 1888884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 18899e32784bSDmitry if (!is_valid[cnt]) 1890884d179dSJan Kara continue; 1891884d179dSJan Kara /* Due to IO error we might not have transfer_from[] structure */ 1892884d179dSJan Kara if (transfer_from[cnt]) { 1893bf097aafSJan Kara int wtype; 1894bf097aafSJan Kara wtype = info_idq_free(transfer_from[cnt], 1); 1895bf097aafSJan Kara if (wtype != QUOTA_NL_NOWARN) 1896bf097aafSJan Kara prepare_warning(&warn_from_inodes[cnt], 1897bf097aafSJan Kara transfer_from[cnt], wtype); 1898bf097aafSJan Kara wtype = info_bdq_free(transfer_from[cnt], space); 1899bf097aafSJan Kara if (wtype != QUOTA_NL_NOWARN) 1900bf097aafSJan Kara prepare_warning(&warn_from_space[cnt], 1901bf097aafSJan Kara transfer_from[cnt], wtype); 1902884d179dSJan Kara dquot_decr_inodes(transfer_from[cnt], 1); 1903884d179dSJan Kara dquot_decr_space(transfer_from[cnt], cur_space); 1904884d179dSJan Kara dquot_free_reserved_space(transfer_from[cnt], 1905884d179dSJan Kara rsv_space); 1906884d179dSJan Kara } 1907884d179dSJan Kara 1908884d179dSJan Kara dquot_incr_inodes(transfer_to[cnt], 1); 1909884d179dSJan Kara dquot_incr_space(transfer_to[cnt], cur_space); 1910884d179dSJan Kara dquot_resv_space(transfer_to[cnt], rsv_space); 1911884d179dSJan Kara 1912*2d0fa467SJan Kara i_dquot(inode)[cnt] = transfer_to[cnt]; 1913884d179dSJan Kara } 1914884d179dSJan Kara spin_unlock(&dq_data_lock); 1915884d179dSJan Kara 1916dc52dd3aSDmitry Monakhov mark_all_dquot_dirty(transfer_from); 1917dc52dd3aSDmitry Monakhov mark_all_dquot_dirty(transfer_to); 1918bf097aafSJan Kara flush_warnings(warn_to); 1919bf097aafSJan Kara flush_warnings(warn_from_inodes); 1920bf097aafSJan Kara flush_warnings(warn_from_space); 1921bc8e5f07SJan Kara /* Pass back references to put */ 1922dc52dd3aSDmitry Monakhov for (cnt = 0; cnt < MAXQUOTAS; cnt++) 19239e32784bSDmitry if (is_valid[cnt]) 1924bc8e5f07SJan Kara transfer_to[cnt] = transfer_from[cnt]; 192586f3cbecSJan Kara return 0; 1926884d179dSJan Kara over_quota: 1927884d179dSJan Kara spin_unlock(&dq_data_lock); 1928bf097aafSJan Kara flush_warnings(warn_to); 192986f3cbecSJan Kara return ret; 1930884d179dSJan Kara } 1931bc8e5f07SJan Kara EXPORT_SYMBOL(__dquot_transfer); 1932884d179dSJan Kara 19338ddd69d6SDmitry Monakhov /* Wrapper for transferring ownership of an inode for uid/gid only 19348ddd69d6SDmitry Monakhov * Called from FSXXX_setattr() 19358ddd69d6SDmitry Monakhov */ 1936b43fa828SChristoph Hellwig int dquot_transfer(struct inode *inode, struct iattr *iattr) 1937884d179dSJan Kara { 1938bc8e5f07SJan Kara struct dquot *transfer_to[MAXQUOTAS] = {}; 1939bc8e5f07SJan Kara struct super_block *sb = inode->i_sb; 1940bc8e5f07SJan Kara int ret; 19418ddd69d6SDmitry Monakhov 1942189eef59SChristoph Hellwig if (!dquot_active(inode)) 1943884d179dSJan Kara return 0; 1944bc8e5f07SJan Kara 19451a06d420SEric W. Biederman if (iattr->ia_valid & ATTR_UID && !uid_eq(iattr->ia_uid, inode->i_uid)) 1946aca645a6SEric W. Biederman transfer_to[USRQUOTA] = dqget(sb, make_kqid_uid(iattr->ia_uid)); 19471a06d420SEric W. Biederman if (iattr->ia_valid & ATTR_GID && !gid_eq(iattr->ia_gid, inode->i_gid)) 1948aca645a6SEric W. Biederman transfer_to[GRPQUOTA] = dqget(sb, make_kqid_gid(iattr->ia_gid)); 1949bc8e5f07SJan Kara 1950bc8e5f07SJan Kara ret = __dquot_transfer(inode, transfer_to); 1951bc8e5f07SJan Kara dqput_all(transfer_to); 1952bc8e5f07SJan Kara return ret; 1953884d179dSJan Kara } 1954b43fa828SChristoph Hellwig EXPORT_SYMBOL(dquot_transfer); 1955884d179dSJan Kara 1956884d179dSJan Kara /* 1957884d179dSJan Kara * Write info of quota file to disk 1958884d179dSJan Kara */ 1959884d179dSJan Kara int dquot_commit_info(struct super_block *sb, int type) 1960884d179dSJan Kara { 1961884d179dSJan Kara int ret; 1962884d179dSJan Kara struct quota_info *dqopt = sb_dqopt(sb); 1963884d179dSJan Kara 1964884d179dSJan Kara mutex_lock(&dqopt->dqio_mutex); 1965884d179dSJan Kara ret = dqopt->ops[type]->write_file_info(sb, type); 1966884d179dSJan Kara mutex_unlock(&dqopt->dqio_mutex); 1967884d179dSJan Kara return ret; 1968884d179dSJan Kara } 1969884d179dSJan Kara EXPORT_SYMBOL(dquot_commit_info); 1970884d179dSJan Kara 1971884d179dSJan Kara /* 1972884d179dSJan Kara * Definitions of diskquota operations. 1973884d179dSJan Kara */ 197461e225dcSAlexey Dobriyan const struct dquot_operations dquot_operations = { 1975884d179dSJan Kara .write_dquot = dquot_commit, 1976884d179dSJan Kara .acquire_dquot = dquot_acquire, 1977884d179dSJan Kara .release_dquot = dquot_release, 1978884d179dSJan Kara .mark_dirty = dquot_mark_dquot_dirty, 1979884d179dSJan Kara .write_info = dquot_commit_info, 1980884d179dSJan Kara .alloc_dquot = dquot_alloc, 1981884d179dSJan Kara .destroy_dquot = dquot_destroy, 1982884d179dSJan Kara }; 1983123e9cafSChristoph Hellwig EXPORT_SYMBOL(dquot_operations); 1984884d179dSJan Kara 1985884d179dSJan Kara /* 1986907f4554SChristoph Hellwig * Generic helper for ->open on filesystems supporting disk quotas. 1987907f4554SChristoph Hellwig */ 1988907f4554SChristoph Hellwig int dquot_file_open(struct inode *inode, struct file *file) 1989907f4554SChristoph Hellwig { 1990907f4554SChristoph Hellwig int error; 1991907f4554SChristoph Hellwig 1992907f4554SChristoph Hellwig error = generic_file_open(inode, file); 1993907f4554SChristoph Hellwig if (!error && (file->f_mode & FMODE_WRITE)) 1994871a2931SChristoph Hellwig dquot_initialize(inode); 1995907f4554SChristoph Hellwig return error; 1996907f4554SChristoph Hellwig } 1997907f4554SChristoph Hellwig EXPORT_SYMBOL(dquot_file_open); 1998907f4554SChristoph Hellwig 1999907f4554SChristoph Hellwig /* 2000884d179dSJan Kara * Turn quota off on a device. type == -1 ==> quotaoff for all types (umount) 2001884d179dSJan Kara */ 20020f0dd62fSChristoph Hellwig int dquot_disable(struct super_block *sb, int type, unsigned int flags) 2003884d179dSJan Kara { 2004884d179dSJan Kara int cnt, ret = 0; 2005884d179dSJan Kara struct quota_info *dqopt = sb_dqopt(sb); 2006884d179dSJan Kara struct inode *toputinode[MAXQUOTAS]; 2007884d179dSJan Kara 2008884d179dSJan Kara /* Cannot turn off usage accounting without turning off limits, or 2009884d179dSJan Kara * suspend quotas and simultaneously turn quotas off. */ 2010884d179dSJan Kara if ((flags & DQUOT_USAGE_ENABLED && !(flags & DQUOT_LIMITS_ENABLED)) 2011884d179dSJan Kara || (flags & DQUOT_SUSPENDED && flags & (DQUOT_LIMITS_ENABLED | 2012884d179dSJan Kara DQUOT_USAGE_ENABLED))) 2013884d179dSJan Kara return -EINVAL; 2014884d179dSJan Kara 2015884d179dSJan Kara /* We need to serialize quota_off() for device */ 2016884d179dSJan Kara mutex_lock(&dqopt->dqonoff_mutex); 2017884d179dSJan Kara 2018884d179dSJan Kara /* 2019884d179dSJan Kara * Skip everything if there's nothing to do. We have to do this because 2020884d179dSJan Kara * sometimes we are called when fill_super() failed and calling 2021884d179dSJan Kara * sync_fs() in such cases does no good. 2022884d179dSJan Kara */ 2023884d179dSJan Kara if (!sb_any_quota_loaded(sb)) { 2024884d179dSJan Kara mutex_unlock(&dqopt->dqonoff_mutex); 2025884d179dSJan Kara return 0; 2026884d179dSJan Kara } 2027884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 2028884d179dSJan Kara toputinode[cnt] = NULL; 2029884d179dSJan Kara if (type != -1 && cnt != type) 2030884d179dSJan Kara continue; 2031884d179dSJan Kara if (!sb_has_quota_loaded(sb, cnt)) 2032884d179dSJan Kara continue; 2033884d179dSJan Kara 2034884d179dSJan Kara if (flags & DQUOT_SUSPENDED) { 2035884d179dSJan Kara spin_lock(&dq_state_lock); 2036884d179dSJan Kara dqopt->flags |= 2037884d179dSJan Kara dquot_state_flag(DQUOT_SUSPENDED, cnt); 2038884d179dSJan Kara spin_unlock(&dq_state_lock); 2039884d179dSJan Kara } else { 2040884d179dSJan Kara spin_lock(&dq_state_lock); 2041884d179dSJan Kara dqopt->flags &= ~dquot_state_flag(flags, cnt); 2042884d179dSJan Kara /* Turning off suspended quotas? */ 2043884d179dSJan Kara if (!sb_has_quota_loaded(sb, cnt) && 2044884d179dSJan Kara sb_has_quota_suspended(sb, cnt)) { 2045884d179dSJan Kara dqopt->flags &= ~dquot_state_flag( 2046884d179dSJan Kara DQUOT_SUSPENDED, cnt); 2047884d179dSJan Kara spin_unlock(&dq_state_lock); 2048884d179dSJan Kara iput(dqopt->files[cnt]); 2049884d179dSJan Kara dqopt->files[cnt] = NULL; 2050884d179dSJan Kara continue; 2051884d179dSJan Kara } 2052884d179dSJan Kara spin_unlock(&dq_state_lock); 2053884d179dSJan Kara } 2054884d179dSJan Kara 2055884d179dSJan Kara /* We still have to keep quota loaded? */ 2056884d179dSJan Kara if (sb_has_quota_loaded(sb, cnt) && !(flags & DQUOT_SUSPENDED)) 2057884d179dSJan Kara continue; 2058884d179dSJan Kara 2059884d179dSJan Kara /* Note: these are blocking operations */ 2060884d179dSJan Kara drop_dquot_ref(sb, cnt); 2061884d179dSJan Kara invalidate_dquots(sb, cnt); 2062884d179dSJan Kara /* 2063268157baSJan Kara * Now all dquots should be invalidated, all writes done so we 2064268157baSJan Kara * should be only users of the info. No locks needed. 2065884d179dSJan Kara */ 2066884d179dSJan Kara if (info_dirty(&dqopt->info[cnt])) 2067884d179dSJan Kara sb->dq_op->write_info(sb, cnt); 2068884d179dSJan Kara if (dqopt->ops[cnt]->free_file_info) 2069884d179dSJan Kara dqopt->ops[cnt]->free_file_info(sb, cnt); 2070884d179dSJan Kara put_quota_format(dqopt->info[cnt].dqi_format); 2071884d179dSJan Kara 2072884d179dSJan Kara toputinode[cnt] = dqopt->files[cnt]; 2073884d179dSJan Kara if (!sb_has_quota_loaded(sb, cnt)) 2074884d179dSJan Kara dqopt->files[cnt] = NULL; 2075884d179dSJan Kara dqopt->info[cnt].dqi_flags = 0; 2076884d179dSJan Kara dqopt->info[cnt].dqi_igrace = 0; 2077884d179dSJan Kara dqopt->info[cnt].dqi_bgrace = 0; 2078884d179dSJan Kara dqopt->ops[cnt] = NULL; 2079884d179dSJan Kara } 2080884d179dSJan Kara mutex_unlock(&dqopt->dqonoff_mutex); 2081884d179dSJan Kara 2082884d179dSJan Kara /* Skip syncing and setting flags if quota files are hidden */ 2083884d179dSJan Kara if (dqopt->flags & DQUOT_QUOTA_SYS_FILE) 2084884d179dSJan Kara goto put_inodes; 2085884d179dSJan Kara 2086884d179dSJan Kara /* Sync the superblock so that buffers with quota data are written to 2087884d179dSJan Kara * disk (and so userspace sees correct data afterwards). */ 2088884d179dSJan Kara if (sb->s_op->sync_fs) 2089884d179dSJan Kara sb->s_op->sync_fs(sb, 1); 2090884d179dSJan Kara sync_blockdev(sb->s_bdev); 2091884d179dSJan Kara /* Now the quota files are just ordinary files and we can set the 2092884d179dSJan Kara * inode flags back. Moreover we discard the pagecache so that 2093884d179dSJan Kara * userspace sees the writes we did bypassing the pagecache. We 2094884d179dSJan Kara * must also discard the blockdev buffers so that we see the 2095884d179dSJan Kara * changes done by userspace on the next quotaon() */ 2096884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) 2097884d179dSJan Kara if (toputinode[cnt]) { 2098884d179dSJan Kara mutex_lock(&dqopt->dqonoff_mutex); 2099884d179dSJan Kara /* If quota was reenabled in the meantime, we have 2100884d179dSJan Kara * nothing to do */ 2101884d179dSJan Kara if (!sb_has_quota_loaded(sb, cnt)) { 2102a80b12c3SJan Kara mutex_lock(&toputinode[cnt]->i_mutex); 2103884d179dSJan Kara toputinode[cnt]->i_flags &= ~(S_IMMUTABLE | 2104884d179dSJan Kara S_NOATIME | S_NOQUOTA); 2105268157baSJan Kara truncate_inode_pages(&toputinode[cnt]->i_data, 2106268157baSJan Kara 0); 2107884d179dSJan Kara mutex_unlock(&toputinode[cnt]->i_mutex); 210843d2932dSJan Kara mark_inode_dirty_sync(toputinode[cnt]); 2109884d179dSJan Kara } 2110884d179dSJan Kara mutex_unlock(&dqopt->dqonoff_mutex); 2111884d179dSJan Kara } 2112884d179dSJan Kara if (sb->s_bdev) 2113884d179dSJan Kara invalidate_bdev(sb->s_bdev); 2114884d179dSJan Kara put_inodes: 2115884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) 2116884d179dSJan Kara if (toputinode[cnt]) { 2117884d179dSJan Kara /* On remount RO, we keep the inode pointer so that we 2118884d179dSJan Kara * can reenable quota on the subsequent remount RW. We 2119884d179dSJan Kara * have to check 'flags' variable and not use sb_has_ 2120884d179dSJan Kara * function because another quotaon / quotaoff could 2121884d179dSJan Kara * change global state before we got here. We refuse 2122884d179dSJan Kara * to suspend quotas when there is pending delete on 2123884d179dSJan Kara * the quota file... */ 2124884d179dSJan Kara if (!(flags & DQUOT_SUSPENDED)) 2125884d179dSJan Kara iput(toputinode[cnt]); 2126884d179dSJan Kara else if (!toputinode[cnt]->i_nlink) 2127884d179dSJan Kara ret = -EBUSY; 2128884d179dSJan Kara } 2129884d179dSJan Kara return ret; 2130884d179dSJan Kara } 21310f0dd62fSChristoph Hellwig EXPORT_SYMBOL(dquot_disable); 2132884d179dSJan Kara 2133287a8095SChristoph Hellwig int dquot_quota_off(struct super_block *sb, int type) 2134884d179dSJan Kara { 21350f0dd62fSChristoph Hellwig return dquot_disable(sb, type, 21360f0dd62fSChristoph Hellwig DQUOT_USAGE_ENABLED | DQUOT_LIMITS_ENABLED); 2137884d179dSJan Kara } 2138287a8095SChristoph Hellwig EXPORT_SYMBOL(dquot_quota_off); 21390f0dd62fSChristoph Hellwig 2140884d179dSJan Kara /* 2141884d179dSJan Kara * Turn quotas on on a device 2142884d179dSJan Kara */ 2143884d179dSJan Kara 2144884d179dSJan Kara /* 2145884d179dSJan Kara * Helper function to turn quotas on when we already have the inode of 2146884d179dSJan Kara * quota file and no quota information is loaded. 2147884d179dSJan Kara */ 2148884d179dSJan Kara static int vfs_load_quota_inode(struct inode *inode, int type, int format_id, 2149884d179dSJan Kara unsigned int flags) 2150884d179dSJan Kara { 2151884d179dSJan Kara struct quota_format_type *fmt = find_quota_format(format_id); 2152884d179dSJan Kara struct super_block *sb = inode->i_sb; 2153884d179dSJan Kara struct quota_info *dqopt = sb_dqopt(sb); 2154884d179dSJan Kara int error; 2155884d179dSJan Kara int oldflags = -1; 2156884d179dSJan Kara 2157884d179dSJan Kara if (!fmt) 2158884d179dSJan Kara return -ESRCH; 2159884d179dSJan Kara if (!S_ISREG(inode->i_mode)) { 2160884d179dSJan Kara error = -EACCES; 2161884d179dSJan Kara goto out_fmt; 2162884d179dSJan Kara } 2163884d179dSJan Kara if (IS_RDONLY(inode)) { 2164884d179dSJan Kara error = -EROFS; 2165884d179dSJan Kara goto out_fmt; 2166884d179dSJan Kara } 2167884d179dSJan Kara if (!sb->s_op->quota_write || !sb->s_op->quota_read) { 2168884d179dSJan Kara error = -EINVAL; 2169884d179dSJan Kara goto out_fmt; 2170884d179dSJan Kara } 2171884d179dSJan Kara /* Usage always has to be set... */ 2172884d179dSJan Kara if (!(flags & DQUOT_USAGE_ENABLED)) { 2173884d179dSJan Kara error = -EINVAL; 2174884d179dSJan Kara goto out_fmt; 2175884d179dSJan Kara } 2176884d179dSJan Kara 2177884d179dSJan Kara if (!(dqopt->flags & DQUOT_QUOTA_SYS_FILE)) { 2178ab94c39bSJan Kara /* As we bypass the pagecache we must now flush all the 2179ab94c39bSJan Kara * dirty data and invalidate caches so that kernel sees 2180ab94c39bSJan Kara * changes from userspace. It is not enough to just flush 2181ab94c39bSJan Kara * the quota file since if blocksize < pagesize, invalidation 2182ab94c39bSJan Kara * of the cache could fail because of other unrelated dirty 2183ab94c39bSJan Kara * data */ 2184ab94c39bSJan Kara sync_filesystem(sb); 2185884d179dSJan Kara invalidate_bdev(sb->s_bdev); 2186884d179dSJan Kara } 2187884d179dSJan Kara mutex_lock(&dqopt->dqonoff_mutex); 2188884d179dSJan Kara if (sb_has_quota_loaded(sb, type)) { 2189884d179dSJan Kara error = -EBUSY; 2190884d179dSJan Kara goto out_lock; 2191884d179dSJan Kara } 2192884d179dSJan Kara 2193884d179dSJan Kara if (!(dqopt->flags & DQUOT_QUOTA_SYS_FILE)) { 2194884d179dSJan Kara /* We don't want quota and atime on quota files (deadlocks 2195884d179dSJan Kara * possible) Also nobody should write to the file - we use 2196884d179dSJan Kara * special IO operations which ignore the immutable bit. */ 2197a80b12c3SJan Kara mutex_lock(&inode->i_mutex); 2198268157baSJan Kara oldflags = inode->i_flags & (S_NOATIME | S_IMMUTABLE | 2199268157baSJan Kara S_NOQUOTA); 2200884d179dSJan Kara inode->i_flags |= S_NOQUOTA | S_NOATIME | S_IMMUTABLE; 2201dee86565SJan Kara mutex_unlock(&inode->i_mutex); 220226245c94SJan Kara /* 220326245c94SJan Kara * When S_NOQUOTA is set, remove dquot references as no more 220426245c94SJan Kara * references can be added 220526245c94SJan Kara */ 22069f754758SChristoph Hellwig __dquot_drop(inode); 2207884d179dSJan Kara } 2208884d179dSJan Kara 2209884d179dSJan Kara error = -EIO; 2210884d179dSJan Kara dqopt->files[type] = igrab(inode); 2211884d179dSJan Kara if (!dqopt->files[type]) 2212884d179dSJan Kara goto out_lock; 2213884d179dSJan Kara error = -EINVAL; 2214884d179dSJan Kara if (!fmt->qf_ops->check_quota_file(sb, type)) 2215884d179dSJan Kara goto out_file_init; 2216884d179dSJan Kara 2217884d179dSJan Kara dqopt->ops[type] = fmt->qf_ops; 2218884d179dSJan Kara dqopt->info[type].dqi_format = fmt; 2219884d179dSJan Kara dqopt->info[type].dqi_fmt_id = format_id; 2220884d179dSJan Kara INIT_LIST_HEAD(&dqopt->info[type].dqi_dirty_list); 2221884d179dSJan Kara mutex_lock(&dqopt->dqio_mutex); 2222268157baSJan Kara error = dqopt->ops[type]->read_file_info(sb, type); 2223268157baSJan Kara if (error < 0) { 2224884d179dSJan Kara mutex_unlock(&dqopt->dqio_mutex); 2225884d179dSJan Kara goto out_file_init; 2226884d179dSJan Kara } 222746fe44ceSJan Kara if (dqopt->flags & DQUOT_QUOTA_SYS_FILE) 222846fe44ceSJan Kara dqopt->info[type].dqi_flags |= DQF_SYS_FILE; 2229884d179dSJan Kara mutex_unlock(&dqopt->dqio_mutex); 2230884d179dSJan Kara spin_lock(&dq_state_lock); 2231884d179dSJan Kara dqopt->flags |= dquot_state_flag(flags, type); 2232884d179dSJan Kara spin_unlock(&dq_state_lock); 2233884d179dSJan Kara 2234884d179dSJan Kara add_dquot_ref(sb, type); 2235884d179dSJan Kara mutex_unlock(&dqopt->dqonoff_mutex); 2236884d179dSJan Kara 2237884d179dSJan Kara return 0; 2238884d179dSJan Kara 2239884d179dSJan Kara out_file_init: 2240884d179dSJan Kara dqopt->files[type] = NULL; 2241884d179dSJan Kara iput(inode); 2242884d179dSJan Kara out_lock: 2243884d179dSJan Kara if (oldflags != -1) { 2244a80b12c3SJan Kara mutex_lock(&inode->i_mutex); 2245884d179dSJan Kara /* Set the flags back (in the case of accidental quotaon() 2246884d179dSJan Kara * on a wrong file we don't want to mess up the flags) */ 2247884d179dSJan Kara inode->i_flags &= ~(S_NOATIME | S_NOQUOTA | S_IMMUTABLE); 2248884d179dSJan Kara inode->i_flags |= oldflags; 2249dee86565SJan Kara mutex_unlock(&inode->i_mutex); 2250884d179dSJan Kara } 2251d01730d7SJiaying Zhang mutex_unlock(&dqopt->dqonoff_mutex); 2252884d179dSJan Kara out_fmt: 2253884d179dSJan Kara put_quota_format(fmt); 2254884d179dSJan Kara 2255884d179dSJan Kara return error; 2256884d179dSJan Kara } 2257884d179dSJan Kara 2258884d179dSJan Kara /* Reenable quotas on remount RW */ 22590f0dd62fSChristoph Hellwig int dquot_resume(struct super_block *sb, int type) 2260884d179dSJan Kara { 2261884d179dSJan Kara struct quota_info *dqopt = sb_dqopt(sb); 2262884d179dSJan Kara struct inode *inode; 22630f0dd62fSChristoph Hellwig int ret = 0, cnt; 2264884d179dSJan Kara unsigned int flags; 2265884d179dSJan Kara 22660f0dd62fSChristoph Hellwig for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 22670f0dd62fSChristoph Hellwig if (type != -1 && cnt != type) 22680f0dd62fSChristoph Hellwig continue; 22690f0dd62fSChristoph Hellwig 2270884d179dSJan Kara mutex_lock(&dqopt->dqonoff_mutex); 22710f0dd62fSChristoph Hellwig if (!sb_has_quota_suspended(sb, cnt)) { 2272884d179dSJan Kara mutex_unlock(&dqopt->dqonoff_mutex); 22730f0dd62fSChristoph Hellwig continue; 2274884d179dSJan Kara } 22750f0dd62fSChristoph Hellwig inode = dqopt->files[cnt]; 22760f0dd62fSChristoph Hellwig dqopt->files[cnt] = NULL; 2277884d179dSJan Kara spin_lock(&dq_state_lock); 2278884d179dSJan Kara flags = dqopt->flags & dquot_state_flag(DQUOT_USAGE_ENABLED | 22790f0dd62fSChristoph Hellwig DQUOT_LIMITS_ENABLED, 22800f0dd62fSChristoph Hellwig cnt); 22810f0dd62fSChristoph Hellwig dqopt->flags &= ~dquot_state_flag(DQUOT_STATE_FLAGS, cnt); 2282884d179dSJan Kara spin_unlock(&dq_state_lock); 2283884d179dSJan Kara mutex_unlock(&dqopt->dqonoff_mutex); 2284884d179dSJan Kara 22850f0dd62fSChristoph Hellwig flags = dquot_generic_flag(flags, cnt); 22860f0dd62fSChristoph Hellwig ret = vfs_load_quota_inode(inode, cnt, 22870f0dd62fSChristoph Hellwig dqopt->info[cnt].dqi_fmt_id, flags); 2288884d179dSJan Kara iput(inode); 22890f0dd62fSChristoph Hellwig } 2290884d179dSJan Kara 2291884d179dSJan Kara return ret; 2292884d179dSJan Kara } 22930f0dd62fSChristoph Hellwig EXPORT_SYMBOL(dquot_resume); 2294884d179dSJan Kara 2295f00c9e44SJan Kara int dquot_quota_on(struct super_block *sb, int type, int format_id, 2296884d179dSJan Kara struct path *path) 2297884d179dSJan Kara { 2298884d179dSJan Kara int error = security_quota_on(path->dentry); 2299884d179dSJan Kara if (error) 2300884d179dSJan Kara return error; 2301884d179dSJan Kara /* Quota file not on the same filesystem? */ 2302d8c9584eSAl Viro if (path->dentry->d_sb != sb) 2303884d179dSJan Kara error = -EXDEV; 2304884d179dSJan Kara else 2305884d179dSJan Kara error = vfs_load_quota_inode(path->dentry->d_inode, type, 2306884d179dSJan Kara format_id, DQUOT_USAGE_ENABLED | 2307884d179dSJan Kara DQUOT_LIMITS_ENABLED); 2308884d179dSJan Kara return error; 2309884d179dSJan Kara } 2310287a8095SChristoph Hellwig EXPORT_SYMBOL(dquot_quota_on); 2311884d179dSJan Kara 2312884d179dSJan Kara /* 2313884d179dSJan Kara * More powerful function for turning on quotas allowing setting 2314884d179dSJan Kara * of individual quota flags 2315884d179dSJan Kara */ 2316287a8095SChristoph Hellwig int dquot_enable(struct inode *inode, int type, int format_id, 2317884d179dSJan Kara unsigned int flags) 2318884d179dSJan Kara { 2319884d179dSJan Kara int ret = 0; 2320884d179dSJan Kara struct super_block *sb = inode->i_sb; 2321884d179dSJan Kara struct quota_info *dqopt = sb_dqopt(sb); 2322884d179dSJan Kara 2323884d179dSJan Kara /* Just unsuspend quotas? */ 23240f0dd62fSChristoph Hellwig BUG_ON(flags & DQUOT_SUSPENDED); 23250f0dd62fSChristoph Hellwig 2326884d179dSJan Kara if (!flags) 2327884d179dSJan Kara return 0; 2328884d179dSJan Kara /* Just updating flags needed? */ 2329884d179dSJan Kara if (sb_has_quota_loaded(sb, type)) { 2330884d179dSJan Kara mutex_lock(&dqopt->dqonoff_mutex); 2331884d179dSJan Kara /* Now do a reliable test... */ 2332884d179dSJan Kara if (!sb_has_quota_loaded(sb, type)) { 2333884d179dSJan Kara mutex_unlock(&dqopt->dqonoff_mutex); 2334884d179dSJan Kara goto load_quota; 2335884d179dSJan Kara } 2336884d179dSJan Kara if (flags & DQUOT_USAGE_ENABLED && 2337884d179dSJan Kara sb_has_quota_usage_enabled(sb, type)) { 2338884d179dSJan Kara ret = -EBUSY; 2339884d179dSJan Kara goto out_lock; 2340884d179dSJan Kara } 2341884d179dSJan Kara if (flags & DQUOT_LIMITS_ENABLED && 2342884d179dSJan Kara sb_has_quota_limits_enabled(sb, type)) { 2343884d179dSJan Kara ret = -EBUSY; 2344884d179dSJan Kara goto out_lock; 2345884d179dSJan Kara } 2346884d179dSJan Kara spin_lock(&dq_state_lock); 2347884d179dSJan Kara sb_dqopt(sb)->flags |= dquot_state_flag(flags, type); 2348884d179dSJan Kara spin_unlock(&dq_state_lock); 2349884d179dSJan Kara out_lock: 2350884d179dSJan Kara mutex_unlock(&dqopt->dqonoff_mutex); 2351884d179dSJan Kara return ret; 2352884d179dSJan Kara } 2353884d179dSJan Kara 2354884d179dSJan Kara load_quota: 2355884d179dSJan Kara return vfs_load_quota_inode(inode, type, format_id, flags); 2356884d179dSJan Kara } 2357287a8095SChristoph Hellwig EXPORT_SYMBOL(dquot_enable); 2358884d179dSJan Kara 2359884d179dSJan Kara /* 2360884d179dSJan Kara * This function is used when filesystem needs to initialize quotas 2361884d179dSJan Kara * during mount time. 2362884d179dSJan Kara */ 2363287a8095SChristoph Hellwig int dquot_quota_on_mount(struct super_block *sb, char *qf_name, 2364884d179dSJan Kara int format_id, int type) 2365884d179dSJan Kara { 2366884d179dSJan Kara struct dentry *dentry; 2367884d179dSJan Kara int error; 2368884d179dSJan Kara 2369c56818d7SJan Kara mutex_lock(&sb->s_root->d_inode->i_mutex); 2370884d179dSJan Kara dentry = lookup_one_len(qf_name, sb->s_root, strlen(qf_name)); 2371c56818d7SJan Kara mutex_unlock(&sb->s_root->d_inode->i_mutex); 2372884d179dSJan Kara if (IS_ERR(dentry)) 2373884d179dSJan Kara return PTR_ERR(dentry); 2374884d179dSJan Kara 2375884d179dSJan Kara if (!dentry->d_inode) { 2376884d179dSJan Kara error = -ENOENT; 2377884d179dSJan Kara goto out; 2378884d179dSJan Kara } 2379884d179dSJan Kara 2380884d179dSJan Kara error = security_quota_on(dentry); 2381884d179dSJan Kara if (!error) 2382884d179dSJan Kara error = vfs_load_quota_inode(dentry->d_inode, type, format_id, 2383884d179dSJan Kara DQUOT_USAGE_ENABLED | DQUOT_LIMITS_ENABLED); 2384884d179dSJan Kara 2385884d179dSJan Kara out: 2386884d179dSJan Kara dput(dentry); 2387884d179dSJan Kara return error; 2388884d179dSJan Kara } 2389287a8095SChristoph Hellwig EXPORT_SYMBOL(dquot_quota_on_mount); 2390884d179dSJan Kara 2391884d179dSJan Kara static inline qsize_t qbtos(qsize_t blocks) 2392884d179dSJan Kara { 2393884d179dSJan Kara return blocks << QIF_DQBLKSIZE_BITS; 2394884d179dSJan Kara } 2395884d179dSJan Kara 2396884d179dSJan Kara static inline qsize_t stoqb(qsize_t space) 2397884d179dSJan Kara { 2398884d179dSJan Kara return (space + QIF_DQBLKSIZE - 1) >> QIF_DQBLKSIZE_BITS; 2399884d179dSJan Kara } 2400884d179dSJan Kara 2401884d179dSJan Kara /* Generic routine for getting common part of quota structure */ 2402b9b2dd36SChristoph Hellwig static void do_get_dqblk(struct dquot *dquot, struct fs_disk_quota *di) 2403884d179dSJan Kara { 2404884d179dSJan Kara struct mem_dqblk *dm = &dquot->dq_dqb; 2405884d179dSJan Kara 2406b9b2dd36SChristoph Hellwig memset(di, 0, sizeof(*di)); 2407b9b2dd36SChristoph Hellwig di->d_version = FS_DQUOT_VERSION; 24084c376dcaSEric W. Biederman di->d_flags = dquot->dq_id.type == USRQUOTA ? 2409ade7ce31SChristoph Hellwig FS_USER_QUOTA : FS_GROUP_QUOTA; 24104c376dcaSEric W. Biederman di->d_id = from_kqid_munged(current_user_ns(), dquot->dq_id); 2411b9b2dd36SChristoph Hellwig 2412884d179dSJan Kara spin_lock(&dq_data_lock); 2413b9b2dd36SChristoph Hellwig di->d_blk_hardlimit = stoqb(dm->dqb_bhardlimit); 2414b9b2dd36SChristoph Hellwig di->d_blk_softlimit = stoqb(dm->dqb_bsoftlimit); 2415b9b2dd36SChristoph Hellwig di->d_ino_hardlimit = dm->dqb_ihardlimit; 2416b9b2dd36SChristoph Hellwig di->d_ino_softlimit = dm->dqb_isoftlimit; 2417b9b2dd36SChristoph Hellwig di->d_bcount = dm->dqb_curspace + dm->dqb_rsvspace; 2418b9b2dd36SChristoph Hellwig di->d_icount = dm->dqb_curinodes; 2419b9b2dd36SChristoph Hellwig di->d_btimer = dm->dqb_btime; 2420b9b2dd36SChristoph Hellwig di->d_itimer = dm->dqb_itime; 2421884d179dSJan Kara spin_unlock(&dq_data_lock); 2422884d179dSJan Kara } 2423884d179dSJan Kara 242474a8a103SEric W. Biederman int dquot_get_dqblk(struct super_block *sb, struct kqid qid, 2425b9b2dd36SChristoph Hellwig struct fs_disk_quota *di) 2426884d179dSJan Kara { 2427884d179dSJan Kara struct dquot *dquot; 2428884d179dSJan Kara 2429aca645a6SEric W. Biederman dquot = dqget(sb, qid); 2430dd6f3c6dSJan Kara if (!dquot) 2431884d179dSJan Kara return -ESRCH; 2432884d179dSJan Kara do_get_dqblk(dquot, di); 2433884d179dSJan Kara dqput(dquot); 2434884d179dSJan Kara 2435884d179dSJan Kara return 0; 2436884d179dSJan Kara } 2437287a8095SChristoph Hellwig EXPORT_SYMBOL(dquot_get_dqblk); 2438884d179dSJan Kara 2439c472b432SChristoph Hellwig #define VFS_FS_DQ_MASK \ 2440c472b432SChristoph Hellwig (FS_DQ_BCOUNT | FS_DQ_BSOFT | FS_DQ_BHARD | \ 2441c472b432SChristoph Hellwig FS_DQ_ICOUNT | FS_DQ_ISOFT | FS_DQ_IHARD | \ 2442c472b432SChristoph Hellwig FS_DQ_BTIMER | FS_DQ_ITIMER) 2443c472b432SChristoph Hellwig 2444884d179dSJan Kara /* Generic routine for setting common part of quota structure */ 2445c472b432SChristoph Hellwig static int do_set_dqblk(struct dquot *dquot, struct fs_disk_quota *di) 2446884d179dSJan Kara { 2447884d179dSJan Kara struct mem_dqblk *dm = &dquot->dq_dqb; 2448884d179dSJan Kara int check_blim = 0, check_ilim = 0; 24494c376dcaSEric W. Biederman struct mem_dqinfo *dqi = &sb_dqopt(dquot->dq_sb)->info[dquot->dq_id.type]; 2450884d179dSJan Kara 2451c472b432SChristoph Hellwig if (di->d_fieldmask & ~VFS_FS_DQ_MASK) 2452c472b432SChristoph Hellwig return -EINVAL; 2453c472b432SChristoph Hellwig 2454c472b432SChristoph Hellwig if (((di->d_fieldmask & FS_DQ_BSOFT) && 2455c472b432SChristoph Hellwig (di->d_blk_softlimit > dqi->dqi_maxblimit)) || 2456c472b432SChristoph Hellwig ((di->d_fieldmask & FS_DQ_BHARD) && 2457c472b432SChristoph Hellwig (di->d_blk_hardlimit > dqi->dqi_maxblimit)) || 2458c472b432SChristoph Hellwig ((di->d_fieldmask & FS_DQ_ISOFT) && 2459c472b432SChristoph Hellwig (di->d_ino_softlimit > dqi->dqi_maxilimit)) || 2460c472b432SChristoph Hellwig ((di->d_fieldmask & FS_DQ_IHARD) && 2461c472b432SChristoph Hellwig (di->d_ino_hardlimit > dqi->dqi_maxilimit))) 2462884d179dSJan Kara return -ERANGE; 2463884d179dSJan Kara 2464884d179dSJan Kara spin_lock(&dq_data_lock); 2465c472b432SChristoph Hellwig if (di->d_fieldmask & FS_DQ_BCOUNT) { 2466c472b432SChristoph Hellwig dm->dqb_curspace = di->d_bcount - dm->dqb_rsvspace; 2467884d179dSJan Kara check_blim = 1; 246808261673SAndrew Perepechko set_bit(DQ_LASTSET_B + QIF_SPACE_B, &dquot->dq_flags); 2469884d179dSJan Kara } 2470c472b432SChristoph Hellwig 2471c472b432SChristoph Hellwig if (di->d_fieldmask & FS_DQ_BSOFT) 2472c472b432SChristoph Hellwig dm->dqb_bsoftlimit = qbtos(di->d_blk_softlimit); 2473c472b432SChristoph Hellwig if (di->d_fieldmask & FS_DQ_BHARD) 2474c472b432SChristoph Hellwig dm->dqb_bhardlimit = qbtos(di->d_blk_hardlimit); 2475c472b432SChristoph Hellwig if (di->d_fieldmask & (FS_DQ_BSOFT | FS_DQ_BHARD)) { 2476884d179dSJan Kara check_blim = 1; 247708261673SAndrew Perepechko set_bit(DQ_LASTSET_B + QIF_BLIMITS_B, &dquot->dq_flags); 2478884d179dSJan Kara } 2479c472b432SChristoph Hellwig 2480c472b432SChristoph Hellwig if (di->d_fieldmask & FS_DQ_ICOUNT) { 2481c472b432SChristoph Hellwig dm->dqb_curinodes = di->d_icount; 2482884d179dSJan Kara check_ilim = 1; 248308261673SAndrew Perepechko set_bit(DQ_LASTSET_B + QIF_INODES_B, &dquot->dq_flags); 2484884d179dSJan Kara } 2485c472b432SChristoph Hellwig 2486c472b432SChristoph Hellwig if (di->d_fieldmask & FS_DQ_ISOFT) 2487c472b432SChristoph Hellwig dm->dqb_isoftlimit = di->d_ino_softlimit; 2488c472b432SChristoph Hellwig if (di->d_fieldmask & FS_DQ_IHARD) 2489c472b432SChristoph Hellwig dm->dqb_ihardlimit = di->d_ino_hardlimit; 2490c472b432SChristoph Hellwig if (di->d_fieldmask & (FS_DQ_ISOFT | FS_DQ_IHARD)) { 2491884d179dSJan Kara check_ilim = 1; 249208261673SAndrew Perepechko set_bit(DQ_LASTSET_B + QIF_ILIMITS_B, &dquot->dq_flags); 2493884d179dSJan Kara } 2494c472b432SChristoph Hellwig 2495c472b432SChristoph Hellwig if (di->d_fieldmask & FS_DQ_BTIMER) { 2496c472b432SChristoph Hellwig dm->dqb_btime = di->d_btimer; 2497884d179dSJan Kara check_blim = 1; 249808261673SAndrew Perepechko set_bit(DQ_LASTSET_B + QIF_BTIME_B, &dquot->dq_flags); 2499884d179dSJan Kara } 2500c472b432SChristoph Hellwig 2501c472b432SChristoph Hellwig if (di->d_fieldmask & FS_DQ_ITIMER) { 2502c472b432SChristoph Hellwig dm->dqb_itime = di->d_itimer; 2503884d179dSJan Kara check_ilim = 1; 250408261673SAndrew Perepechko set_bit(DQ_LASTSET_B + QIF_ITIME_B, &dquot->dq_flags); 2505884d179dSJan Kara } 2506884d179dSJan Kara 2507884d179dSJan Kara if (check_blim) { 2508268157baSJan Kara if (!dm->dqb_bsoftlimit || 2509268157baSJan Kara dm->dqb_curspace < dm->dqb_bsoftlimit) { 2510884d179dSJan Kara dm->dqb_btime = 0; 2511884d179dSJan Kara clear_bit(DQ_BLKS_B, &dquot->dq_flags); 2512c472b432SChristoph Hellwig } else if (!(di->d_fieldmask & FS_DQ_BTIMER)) 2513268157baSJan Kara /* Set grace only if user hasn't provided his own... */ 2514884d179dSJan Kara dm->dqb_btime = get_seconds() + dqi->dqi_bgrace; 2515884d179dSJan Kara } 2516884d179dSJan Kara if (check_ilim) { 2517268157baSJan Kara if (!dm->dqb_isoftlimit || 2518268157baSJan Kara dm->dqb_curinodes < dm->dqb_isoftlimit) { 2519884d179dSJan Kara dm->dqb_itime = 0; 2520884d179dSJan Kara clear_bit(DQ_INODES_B, &dquot->dq_flags); 2521c472b432SChristoph Hellwig } else if (!(di->d_fieldmask & FS_DQ_ITIMER)) 2522268157baSJan Kara /* Set grace only if user hasn't provided his own... */ 2523884d179dSJan Kara dm->dqb_itime = get_seconds() + dqi->dqi_igrace; 2524884d179dSJan Kara } 2525268157baSJan Kara if (dm->dqb_bhardlimit || dm->dqb_bsoftlimit || dm->dqb_ihardlimit || 2526268157baSJan Kara dm->dqb_isoftlimit) 2527884d179dSJan Kara clear_bit(DQ_FAKE_B, &dquot->dq_flags); 2528884d179dSJan Kara else 2529884d179dSJan Kara set_bit(DQ_FAKE_B, &dquot->dq_flags); 2530884d179dSJan Kara spin_unlock(&dq_data_lock); 2531884d179dSJan Kara mark_dquot_dirty(dquot); 2532884d179dSJan Kara 2533884d179dSJan Kara return 0; 2534884d179dSJan Kara } 2535884d179dSJan Kara 253674a8a103SEric W. Biederman int dquot_set_dqblk(struct super_block *sb, struct kqid qid, 2537c472b432SChristoph Hellwig struct fs_disk_quota *di) 2538884d179dSJan Kara { 2539884d179dSJan Kara struct dquot *dquot; 2540884d179dSJan Kara int rc; 2541884d179dSJan Kara 2542aca645a6SEric W. Biederman dquot = dqget(sb, qid); 2543884d179dSJan Kara if (!dquot) { 2544884d179dSJan Kara rc = -ESRCH; 2545884d179dSJan Kara goto out; 2546884d179dSJan Kara } 2547884d179dSJan Kara rc = do_set_dqblk(dquot, di); 2548884d179dSJan Kara dqput(dquot); 2549884d179dSJan Kara out: 2550884d179dSJan Kara return rc; 2551884d179dSJan Kara } 2552287a8095SChristoph Hellwig EXPORT_SYMBOL(dquot_set_dqblk); 2553884d179dSJan Kara 2554884d179dSJan Kara /* Generic routine for getting common part of quota file information */ 2555287a8095SChristoph Hellwig int dquot_get_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii) 2556884d179dSJan Kara { 2557884d179dSJan Kara struct mem_dqinfo *mi; 2558884d179dSJan Kara 2559884d179dSJan Kara mutex_lock(&sb_dqopt(sb)->dqonoff_mutex); 2560884d179dSJan Kara if (!sb_has_quota_active(sb, type)) { 2561884d179dSJan Kara mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex); 2562884d179dSJan Kara return -ESRCH; 2563884d179dSJan Kara } 2564884d179dSJan Kara mi = sb_dqopt(sb)->info + type; 2565884d179dSJan Kara spin_lock(&dq_data_lock); 2566884d179dSJan Kara ii->dqi_bgrace = mi->dqi_bgrace; 2567884d179dSJan Kara ii->dqi_igrace = mi->dqi_igrace; 256846fe44ceSJan Kara ii->dqi_flags = mi->dqi_flags & DQF_GETINFO_MASK; 2569884d179dSJan Kara ii->dqi_valid = IIF_ALL; 2570884d179dSJan Kara spin_unlock(&dq_data_lock); 2571884d179dSJan Kara mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex); 2572884d179dSJan Kara return 0; 2573884d179dSJan Kara } 2574287a8095SChristoph Hellwig EXPORT_SYMBOL(dquot_get_dqinfo); 2575884d179dSJan Kara 2576884d179dSJan Kara /* Generic routine for setting common part of quota file information */ 2577287a8095SChristoph Hellwig int dquot_set_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii) 2578884d179dSJan Kara { 2579884d179dSJan Kara struct mem_dqinfo *mi; 2580884d179dSJan Kara int err = 0; 2581884d179dSJan Kara 2582884d179dSJan Kara mutex_lock(&sb_dqopt(sb)->dqonoff_mutex); 2583884d179dSJan Kara if (!sb_has_quota_active(sb, type)) { 2584884d179dSJan Kara err = -ESRCH; 2585884d179dSJan Kara goto out; 2586884d179dSJan Kara } 2587884d179dSJan Kara mi = sb_dqopt(sb)->info + type; 2588884d179dSJan Kara spin_lock(&dq_data_lock); 2589884d179dSJan Kara if (ii->dqi_valid & IIF_BGRACE) 2590884d179dSJan Kara mi->dqi_bgrace = ii->dqi_bgrace; 2591884d179dSJan Kara if (ii->dqi_valid & IIF_IGRACE) 2592884d179dSJan Kara mi->dqi_igrace = ii->dqi_igrace; 2593884d179dSJan Kara if (ii->dqi_valid & IIF_FLAGS) 259446fe44ceSJan Kara mi->dqi_flags = (mi->dqi_flags & ~DQF_SETINFO_MASK) | 259546fe44ceSJan Kara (ii->dqi_flags & DQF_SETINFO_MASK); 2596884d179dSJan Kara spin_unlock(&dq_data_lock); 2597884d179dSJan Kara mark_info_dirty(sb, type); 2598884d179dSJan Kara /* Force write to disk */ 2599884d179dSJan Kara sb->dq_op->write_info(sb, type); 2600884d179dSJan Kara out: 2601884d179dSJan Kara mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex); 2602884d179dSJan Kara return err; 2603884d179dSJan Kara } 2604287a8095SChristoph Hellwig EXPORT_SYMBOL(dquot_set_dqinfo); 2605884d179dSJan Kara 2606287a8095SChristoph Hellwig const struct quotactl_ops dquot_quotactl_ops = { 2607287a8095SChristoph Hellwig .quota_on = dquot_quota_on, 2608287a8095SChristoph Hellwig .quota_off = dquot_quota_off, 2609287a8095SChristoph Hellwig .quota_sync = dquot_quota_sync, 2610287a8095SChristoph Hellwig .get_info = dquot_get_dqinfo, 2611287a8095SChristoph Hellwig .set_info = dquot_set_dqinfo, 2612287a8095SChristoph Hellwig .get_dqblk = dquot_get_dqblk, 2613287a8095SChristoph Hellwig .set_dqblk = dquot_set_dqblk 2614884d179dSJan Kara }; 2615287a8095SChristoph Hellwig EXPORT_SYMBOL(dquot_quotactl_ops); 2616dde95888SDmitry Monakhov 2617dde95888SDmitry Monakhov static int do_proc_dqstats(struct ctl_table *table, int write, 2618dde95888SDmitry Monakhov void __user *buffer, size_t *lenp, loff_t *ppos) 2619dde95888SDmitry Monakhov { 2620dde95888SDmitry Monakhov unsigned int type = (int *)table->data - dqstats.stat; 2621f32764bdSDmitry Monakhov 2622f32764bdSDmitry Monakhov /* Update global table */ 2623f32764bdSDmitry Monakhov dqstats.stat[type] = 2624f32764bdSDmitry Monakhov percpu_counter_sum_positive(&dqstats.counter[type]); 2625dde95888SDmitry Monakhov return proc_dointvec(table, write, buffer, lenp, ppos); 2626dde95888SDmitry Monakhov } 2627dde95888SDmitry Monakhov 2628e628753bSJoe Perches static struct ctl_table fs_dqstats_table[] = { 2629884d179dSJan Kara { 2630884d179dSJan Kara .procname = "lookups", 2631dde95888SDmitry Monakhov .data = &dqstats.stat[DQST_LOOKUPS], 2632884d179dSJan Kara .maxlen = sizeof(int), 2633884d179dSJan Kara .mode = 0444, 2634dde95888SDmitry Monakhov .proc_handler = do_proc_dqstats, 2635884d179dSJan Kara }, 2636884d179dSJan Kara { 2637884d179dSJan Kara .procname = "drops", 2638dde95888SDmitry Monakhov .data = &dqstats.stat[DQST_DROPS], 2639884d179dSJan Kara .maxlen = sizeof(int), 2640884d179dSJan Kara .mode = 0444, 2641dde95888SDmitry Monakhov .proc_handler = do_proc_dqstats, 2642884d179dSJan Kara }, 2643884d179dSJan Kara { 2644884d179dSJan Kara .procname = "reads", 2645dde95888SDmitry Monakhov .data = &dqstats.stat[DQST_READS], 2646884d179dSJan Kara .maxlen = sizeof(int), 2647884d179dSJan Kara .mode = 0444, 2648dde95888SDmitry Monakhov .proc_handler = do_proc_dqstats, 2649884d179dSJan Kara }, 2650884d179dSJan Kara { 2651884d179dSJan Kara .procname = "writes", 2652dde95888SDmitry Monakhov .data = &dqstats.stat[DQST_WRITES], 2653884d179dSJan Kara .maxlen = sizeof(int), 2654884d179dSJan Kara .mode = 0444, 2655dde95888SDmitry Monakhov .proc_handler = do_proc_dqstats, 2656884d179dSJan Kara }, 2657884d179dSJan Kara { 2658884d179dSJan Kara .procname = "cache_hits", 2659dde95888SDmitry Monakhov .data = &dqstats.stat[DQST_CACHE_HITS], 2660884d179dSJan Kara .maxlen = sizeof(int), 2661884d179dSJan Kara .mode = 0444, 2662dde95888SDmitry Monakhov .proc_handler = do_proc_dqstats, 2663884d179dSJan Kara }, 2664884d179dSJan Kara { 2665884d179dSJan Kara .procname = "allocated_dquots", 2666dde95888SDmitry Monakhov .data = &dqstats.stat[DQST_ALLOC_DQUOTS], 2667884d179dSJan Kara .maxlen = sizeof(int), 2668884d179dSJan Kara .mode = 0444, 2669dde95888SDmitry Monakhov .proc_handler = do_proc_dqstats, 2670884d179dSJan Kara }, 2671884d179dSJan Kara { 2672884d179dSJan Kara .procname = "free_dquots", 2673dde95888SDmitry Monakhov .data = &dqstats.stat[DQST_FREE_DQUOTS], 2674884d179dSJan Kara .maxlen = sizeof(int), 2675884d179dSJan Kara .mode = 0444, 2676dde95888SDmitry Monakhov .proc_handler = do_proc_dqstats, 2677884d179dSJan Kara }, 2678884d179dSJan Kara { 2679884d179dSJan Kara .procname = "syncs", 2680dde95888SDmitry Monakhov .data = &dqstats.stat[DQST_SYNCS], 2681884d179dSJan Kara .maxlen = sizeof(int), 2682884d179dSJan Kara .mode = 0444, 2683dde95888SDmitry Monakhov .proc_handler = do_proc_dqstats, 2684884d179dSJan Kara }, 2685884d179dSJan Kara #ifdef CONFIG_PRINT_QUOTA_WARNING 2686884d179dSJan Kara { 2687884d179dSJan Kara .procname = "warnings", 2688884d179dSJan Kara .data = &flag_print_warnings, 2689884d179dSJan Kara .maxlen = sizeof(int), 2690884d179dSJan Kara .mode = 0644, 26916d456111SEric W. Biederman .proc_handler = proc_dointvec, 2692884d179dSJan Kara }, 2693884d179dSJan Kara #endif 2694ab09203eSEric W. Biederman { }, 2695884d179dSJan Kara }; 2696884d179dSJan Kara 2697e628753bSJoe Perches static struct ctl_table fs_table[] = { 2698884d179dSJan Kara { 2699884d179dSJan Kara .procname = "quota", 2700884d179dSJan Kara .mode = 0555, 2701884d179dSJan Kara .child = fs_dqstats_table, 2702884d179dSJan Kara }, 2703ab09203eSEric W. Biederman { }, 2704884d179dSJan Kara }; 2705884d179dSJan Kara 2706e628753bSJoe Perches static struct ctl_table sys_table[] = { 2707884d179dSJan Kara { 2708884d179dSJan Kara .procname = "fs", 2709884d179dSJan Kara .mode = 0555, 2710884d179dSJan Kara .child = fs_table, 2711884d179dSJan Kara }, 2712ab09203eSEric W. Biederman { }, 2713884d179dSJan Kara }; 2714884d179dSJan Kara 2715884d179dSJan Kara static int __init dquot_init(void) 2716884d179dSJan Kara { 2717f32764bdSDmitry Monakhov int i, ret; 2718884d179dSJan Kara unsigned long nr_hash, order; 2719884d179dSJan Kara 2720884d179dSJan Kara printk(KERN_NOTICE "VFS: Disk quotas %s\n", __DQUOT_VERSION__); 2721884d179dSJan Kara 2722884d179dSJan Kara register_sysctl_table(sys_table); 2723884d179dSJan Kara 2724884d179dSJan Kara dquot_cachep = kmem_cache_create("dquot", 2725884d179dSJan Kara sizeof(struct dquot), sizeof(unsigned long) * 4, 2726884d179dSJan Kara (SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT| 2727884d179dSJan Kara SLAB_MEM_SPREAD|SLAB_PANIC), 2728884d179dSJan Kara NULL); 2729884d179dSJan Kara 2730884d179dSJan Kara order = 0; 2731884d179dSJan Kara dquot_hash = (struct hlist_head *)__get_free_pages(GFP_ATOMIC, order); 2732884d179dSJan Kara if (!dquot_hash) 2733884d179dSJan Kara panic("Cannot create dquot hash table"); 2734884d179dSJan Kara 2735f32764bdSDmitry Monakhov for (i = 0; i < _DQST_DQSTAT_LAST; i++) { 2736908c7f19STejun Heo ret = percpu_counter_init(&dqstats.counter[i], 0, GFP_KERNEL); 2737f32764bdSDmitry Monakhov if (ret) 2738f32764bdSDmitry Monakhov panic("Cannot create dquot stat counters"); 2739f32764bdSDmitry Monakhov } 2740dde95888SDmitry Monakhov 2741884d179dSJan Kara /* Find power-of-two hlist_heads which can fit into allocation */ 2742884d179dSJan Kara nr_hash = (1UL << order) * PAGE_SIZE / sizeof(struct hlist_head); 2743884d179dSJan Kara dq_hash_bits = 0; 2744884d179dSJan Kara do { 2745884d179dSJan Kara dq_hash_bits++; 2746884d179dSJan Kara } while (nr_hash >> dq_hash_bits); 2747884d179dSJan Kara dq_hash_bits--; 2748884d179dSJan Kara 2749884d179dSJan Kara nr_hash = 1UL << dq_hash_bits; 2750884d179dSJan Kara dq_hash_mask = nr_hash - 1; 2751884d179dSJan Kara for (i = 0; i < nr_hash; i++) 2752884d179dSJan Kara INIT_HLIST_HEAD(dquot_hash + i); 2753884d179dSJan Kara 275419858e7bSAnton Blanchard pr_info("VFS: Dquot-cache hash table entries: %ld (order %ld," 275519858e7bSAnton Blanchard " %ld bytes)\n", nr_hash, order, (PAGE_SIZE << order)); 2756884d179dSJan Kara 2757884d179dSJan Kara register_shrinker(&dqcache_shrinker); 2758884d179dSJan Kara 2759884d179dSJan Kara return 0; 2760884d179dSJan Kara } 2761884d179dSJan Kara module_init(dquot_init); 2762