1884d179dSJan Kara /* 2884d179dSJan Kara * Implementation of the diskquota system for the LINUX operating system. QUOTA 3884d179dSJan Kara * is implemented using the BSD system call interface as the means of 4884d179dSJan Kara * communication with the user level. This file contains the generic routines 5884d179dSJan Kara * called by the different filesystems on allocation of an inode or block. 6884d179dSJan Kara * These routines take care of the administration needed to have a consistent 7884d179dSJan Kara * diskquota tracking system. The ideas of both user and group quotas are based 8884d179dSJan Kara * on the Melbourne quota system as used on BSD derived systems. The internal 9884d179dSJan Kara * implementation is based on one of the several variants of the LINUX 10884d179dSJan Kara * inode-subsystem with added complexity of the diskquota system. 11884d179dSJan Kara * 12884d179dSJan Kara * Author: Marco van Wieringen <mvw@planets.elm.net> 13884d179dSJan Kara * 14884d179dSJan Kara * Fixes: Dmitry Gorodchanin <pgmdsg@ibi.com>, 11 Feb 96 15884d179dSJan Kara * 16884d179dSJan Kara * Revised list management to avoid races 17884d179dSJan Kara * -- Bill Hawes, <whawes@star.net>, 9/98 18884d179dSJan Kara * 19884d179dSJan Kara * Fixed races in dquot_transfer(), dqget() and dquot_alloc_...(). 20884d179dSJan Kara * As the consequence the locking was moved from dquot_decr_...(), 21884d179dSJan Kara * dquot_incr_...() to calling functions. 22884d179dSJan Kara * invalidate_dquots() now writes modified dquots. 23884d179dSJan Kara * Serialized quota_off() and quota_on() for mount point. 24884d179dSJan Kara * Fixed a few bugs in grow_dquots(). 25884d179dSJan Kara * Fixed deadlock in write_dquot() - we no longer account quotas on 26884d179dSJan Kara * quota files 27884d179dSJan Kara * remove_dquot_ref() moved to inode.c - it now traverses through inodes 28884d179dSJan Kara * add_dquot_ref() restarts after blocking 29884d179dSJan Kara * Added check for bogus uid and fixed check for group in quotactl. 30884d179dSJan Kara * Jan Kara, <jack@suse.cz>, sponsored by SuSE CR, 10-11/99 31884d179dSJan Kara * 32884d179dSJan Kara * Used struct list_head instead of own list struct 33884d179dSJan Kara * Invalidation of referenced dquots is no longer possible 34884d179dSJan Kara * Improved free_dquots list management 35884d179dSJan Kara * Quota and i_blocks are now updated in one place to avoid races 36884d179dSJan Kara * Warnings are now delayed so we won't block in critical section 37884d179dSJan Kara * Write updated not to require dquot lock 38884d179dSJan Kara * Jan Kara, <jack@suse.cz>, 9/2000 39884d179dSJan Kara * 40884d179dSJan Kara * Added dynamic quota structure allocation 41884d179dSJan Kara * Jan Kara <jack@suse.cz> 12/2000 42884d179dSJan Kara * 43884d179dSJan Kara * Rewritten quota interface. Implemented new quota format and 44884d179dSJan Kara * formats registering. 45884d179dSJan Kara * Jan Kara, <jack@suse.cz>, 2001,2002 46884d179dSJan Kara * 47884d179dSJan Kara * New SMP locking. 48884d179dSJan Kara * Jan Kara, <jack@suse.cz>, 10/2002 49884d179dSJan Kara * 50884d179dSJan Kara * Added journalled quota support, fix lock inversion problems 51884d179dSJan Kara * Jan Kara, <jack@suse.cz>, 2003,2004 52884d179dSJan Kara * 53884d179dSJan Kara * (C) Copyright 1994 - 1997 Marco van Wieringen 54884d179dSJan Kara */ 55884d179dSJan Kara 56884d179dSJan Kara #include <linux/errno.h> 57884d179dSJan Kara #include <linux/kernel.h> 58884d179dSJan Kara #include <linux/fs.h> 59884d179dSJan Kara #include <linux/mount.h> 60884d179dSJan Kara #include <linux/mm.h> 61884d179dSJan Kara #include <linux/time.h> 62884d179dSJan Kara #include <linux/types.h> 63884d179dSJan Kara #include <linux/string.h> 64884d179dSJan Kara #include <linux/fcntl.h> 65884d179dSJan Kara #include <linux/stat.h> 66884d179dSJan Kara #include <linux/tty.h> 67884d179dSJan Kara #include <linux/file.h> 68884d179dSJan Kara #include <linux/slab.h> 69884d179dSJan Kara #include <linux/sysctl.h> 70884d179dSJan Kara #include <linux/init.h> 71884d179dSJan Kara #include <linux/module.h> 72884d179dSJan Kara #include <linux/proc_fs.h> 73884d179dSJan Kara #include <linux/security.h> 74884d179dSJan Kara #include <linux/kmod.h> 75884d179dSJan Kara #include <linux/namei.h> 76884d179dSJan Kara #include <linux/buffer_head.h> 77884d179dSJan Kara #include <linux/capability.h> 78884d179dSJan Kara #include <linux/quotaops.h> 79884d179dSJan Kara #include <linux/writeback.h> /* for inode_lock, oddly enough.. */ 80884d179dSJan Kara #ifdef CONFIG_QUOTA_NETLINK_INTERFACE 81884d179dSJan Kara #include <net/netlink.h> 82884d179dSJan Kara #include <net/genetlink.h> 83884d179dSJan Kara #endif 84884d179dSJan Kara 85884d179dSJan Kara #include <asm/uaccess.h> 86884d179dSJan Kara 87884d179dSJan Kara #define __DQUOT_PARANOIA 88884d179dSJan Kara 89884d179dSJan Kara /* 90884d179dSJan Kara * There are three quota SMP locks. dq_list_lock protects all lists with quotas 91884d179dSJan Kara * and quota formats, dqstats structure containing statistics about the lists 92884d179dSJan Kara * dq_data_lock protects data from dq_dqb and also mem_dqinfo structures and 93884d179dSJan Kara * also guards consistency of dquot->dq_dqb with inode->i_blocks, i_bytes. 94884d179dSJan Kara * i_blocks and i_bytes updates itself are guarded by i_lock acquired directly 95884d179dSJan Kara * in inode_add_bytes() and inode_sub_bytes(). dq_state_lock protects 96884d179dSJan Kara * modifications of quota state (on quotaon and quotaoff) and readers who care 97884d179dSJan Kara * about latest values take it as well. 98884d179dSJan Kara * 99884d179dSJan Kara * The spinlock ordering is hence: dq_data_lock > dq_list_lock > i_lock, 100884d179dSJan Kara * dq_list_lock > dq_state_lock 101884d179dSJan Kara * 102884d179dSJan Kara * Note that some things (eg. sb pointer, type, id) doesn't change during 103884d179dSJan Kara * the life of the dquot structure and so needn't to be protected by a lock 104884d179dSJan Kara * 105884d179dSJan Kara * Any operation working on dquots via inode pointers must hold dqptr_sem. If 106884d179dSJan Kara * operation is just reading pointers from inode (or not using them at all) the 107884d179dSJan Kara * read lock is enough. If pointers are altered function must hold write lock 108884d179dSJan Kara * (these locking rules also apply for S_NOQUOTA flag in the inode - note that 109884d179dSJan Kara * for altering the flag i_mutex is also needed). 110884d179dSJan Kara * 111884d179dSJan Kara * Each dquot has its dq_lock mutex. Locked dquots might not be referenced 112884d179dSJan Kara * from inodes (dquot_alloc_space() and such don't check the dq_lock). 113884d179dSJan Kara * Currently dquot is locked only when it is being read to memory (or space for 114884d179dSJan Kara * it is being allocated) on the first dqget() and when it is being released on 115884d179dSJan Kara * the last dqput(). The allocation and release oparations are serialized by 116884d179dSJan Kara * the dq_lock and by checking the use count in dquot_release(). Write 117884d179dSJan Kara * operations on dquots don't hold dq_lock as they copy data under dq_data_lock 118884d179dSJan Kara * spinlock to internal buffers before writing. 119884d179dSJan Kara * 120884d179dSJan Kara * Lock ordering (including related VFS locks) is the following: 121884d179dSJan Kara * i_mutex > dqonoff_sem > journal_lock > dqptr_sem > dquot->dq_lock > 122884d179dSJan Kara * dqio_mutex 123884d179dSJan Kara * The lock ordering of dqptr_sem imposed by quota code is only dqonoff_sem > 124884d179dSJan Kara * dqptr_sem. But filesystem has to count with the fact that functions such as 125884d179dSJan Kara * dquot_alloc_space() acquire dqptr_sem and they usually have to be called 126884d179dSJan Kara * from inside a transaction to keep filesystem consistency after a crash. Also 127884d179dSJan Kara * filesystems usually want to do some IO on dquot from ->mark_dirty which is 128884d179dSJan Kara * called with dqptr_sem held. 129884d179dSJan Kara * i_mutex on quota files is special (it's below dqio_mutex) 130884d179dSJan Kara */ 131884d179dSJan Kara 132c516610cSJan Kara static __cacheline_aligned_in_smp DEFINE_SPINLOCK(dq_list_lock); 133c516610cSJan Kara static __cacheline_aligned_in_smp DEFINE_SPINLOCK(dq_state_lock); 134c516610cSJan Kara __cacheline_aligned_in_smp DEFINE_SPINLOCK(dq_data_lock); 135884d179dSJan Kara EXPORT_SYMBOL(dq_data_lock); 136884d179dSJan Kara 137884d179dSJan Kara static char *quotatypes[] = INITQFNAMES; 138884d179dSJan Kara static struct quota_format_type *quota_formats; /* List of registered formats */ 139884d179dSJan Kara static struct quota_module_name module_names[] = INIT_QUOTA_MODULE_NAMES; 140884d179dSJan Kara 141884d179dSJan Kara /* SLAB cache for dquot structures */ 142884d179dSJan Kara static struct kmem_cache *dquot_cachep; 143884d179dSJan Kara 144884d179dSJan Kara int register_quota_format(struct quota_format_type *fmt) 145884d179dSJan Kara { 146884d179dSJan Kara spin_lock(&dq_list_lock); 147884d179dSJan Kara fmt->qf_next = quota_formats; 148884d179dSJan Kara quota_formats = fmt; 149884d179dSJan Kara spin_unlock(&dq_list_lock); 150884d179dSJan Kara return 0; 151884d179dSJan Kara } 152884d179dSJan Kara EXPORT_SYMBOL(register_quota_format); 153884d179dSJan Kara 154884d179dSJan Kara void unregister_quota_format(struct quota_format_type *fmt) 155884d179dSJan Kara { 156884d179dSJan Kara struct quota_format_type **actqf; 157884d179dSJan Kara 158884d179dSJan Kara spin_lock(&dq_list_lock); 159884d179dSJan Kara for (actqf = "a_formats; *actqf && *actqf != fmt; actqf = &(*actqf)->qf_next); 160884d179dSJan Kara if (*actqf) 161884d179dSJan Kara *actqf = (*actqf)->qf_next; 162884d179dSJan Kara spin_unlock(&dq_list_lock); 163884d179dSJan Kara } 164884d179dSJan Kara EXPORT_SYMBOL(unregister_quota_format); 165884d179dSJan Kara 166884d179dSJan Kara static struct quota_format_type *find_quota_format(int id) 167884d179dSJan Kara { 168884d179dSJan Kara struct quota_format_type *actqf; 169884d179dSJan Kara 170884d179dSJan Kara spin_lock(&dq_list_lock); 171884d179dSJan Kara for (actqf = quota_formats; actqf && actqf->qf_fmt_id != id; actqf = actqf->qf_next); 172884d179dSJan Kara if (!actqf || !try_module_get(actqf->qf_owner)) { 173884d179dSJan Kara int qm; 174884d179dSJan Kara 175884d179dSJan Kara spin_unlock(&dq_list_lock); 176884d179dSJan Kara 177884d179dSJan Kara for (qm = 0; module_names[qm].qm_fmt_id && module_names[qm].qm_fmt_id != id; qm++); 178884d179dSJan Kara if (!module_names[qm].qm_fmt_id || request_module(module_names[qm].qm_mod_name)) 179884d179dSJan Kara return NULL; 180884d179dSJan Kara 181884d179dSJan Kara spin_lock(&dq_list_lock); 182884d179dSJan Kara for (actqf = quota_formats; actqf && actqf->qf_fmt_id != id; actqf = actqf->qf_next); 183884d179dSJan Kara if (actqf && !try_module_get(actqf->qf_owner)) 184884d179dSJan Kara actqf = NULL; 185884d179dSJan Kara } 186884d179dSJan Kara spin_unlock(&dq_list_lock); 187884d179dSJan Kara return actqf; 188884d179dSJan Kara } 189884d179dSJan Kara 190884d179dSJan Kara static void put_quota_format(struct quota_format_type *fmt) 191884d179dSJan Kara { 192884d179dSJan Kara module_put(fmt->qf_owner); 193884d179dSJan Kara } 194884d179dSJan Kara 195884d179dSJan Kara /* 196884d179dSJan Kara * Dquot List Management: 197884d179dSJan Kara * The quota code uses three lists for dquot management: the inuse_list, 198884d179dSJan Kara * free_dquots, and dquot_hash[] array. A single dquot structure may be 199884d179dSJan Kara * on all three lists, depending on its current state. 200884d179dSJan Kara * 201884d179dSJan Kara * All dquots are placed to the end of inuse_list when first created, and this 202884d179dSJan Kara * list is used for invalidate operation, which must look at every dquot. 203884d179dSJan Kara * 204884d179dSJan Kara * Unused dquots (dq_count == 0) are added to the free_dquots list when freed, 205884d179dSJan Kara * and this list is searched whenever we need an available dquot. Dquots are 206884d179dSJan Kara * removed from the list as soon as they are used again, and 207884d179dSJan Kara * dqstats.free_dquots gives the number of dquots on the list. When 208884d179dSJan Kara * dquot is invalidated it's completely released from memory. 209884d179dSJan Kara * 210884d179dSJan Kara * Dquots with a specific identity (device, type and id) are placed on 211884d179dSJan Kara * one of the dquot_hash[] hash chains. The provides an efficient search 212884d179dSJan Kara * mechanism to locate a specific dquot. 213884d179dSJan Kara */ 214884d179dSJan Kara 215884d179dSJan Kara static LIST_HEAD(inuse_list); 216884d179dSJan Kara static LIST_HEAD(free_dquots); 217884d179dSJan Kara static unsigned int dq_hash_bits, dq_hash_mask; 218884d179dSJan Kara static struct hlist_head *dquot_hash; 219884d179dSJan Kara 220884d179dSJan Kara struct dqstats dqstats; 221884d179dSJan Kara EXPORT_SYMBOL(dqstats); 222884d179dSJan Kara 223884d179dSJan Kara static inline unsigned int 224884d179dSJan Kara hashfn(const struct super_block *sb, unsigned int id, int type) 225884d179dSJan Kara { 226884d179dSJan Kara unsigned long tmp; 227884d179dSJan Kara 228884d179dSJan Kara tmp = (((unsigned long)sb>>L1_CACHE_SHIFT) ^ id) * (MAXQUOTAS - type); 229884d179dSJan Kara return (tmp + (tmp >> dq_hash_bits)) & dq_hash_mask; 230884d179dSJan Kara } 231884d179dSJan Kara 232884d179dSJan Kara /* 233884d179dSJan Kara * Following list functions expect dq_list_lock to be held 234884d179dSJan Kara */ 235884d179dSJan Kara static inline void insert_dquot_hash(struct dquot *dquot) 236884d179dSJan Kara { 237884d179dSJan Kara struct hlist_head *head = dquot_hash + hashfn(dquot->dq_sb, dquot->dq_id, dquot->dq_type); 238884d179dSJan Kara hlist_add_head(&dquot->dq_hash, head); 239884d179dSJan Kara } 240884d179dSJan Kara 241884d179dSJan Kara static inline void remove_dquot_hash(struct dquot *dquot) 242884d179dSJan Kara { 243884d179dSJan Kara hlist_del_init(&dquot->dq_hash); 244884d179dSJan Kara } 245884d179dSJan Kara 246*7a2435d8SJan Kara static struct dquot *find_dquot(unsigned int hashent, struct super_block *sb, 247*7a2435d8SJan Kara unsigned int id, int type) 248884d179dSJan Kara { 249884d179dSJan Kara struct hlist_node *node; 250884d179dSJan Kara struct dquot *dquot; 251884d179dSJan Kara 252884d179dSJan Kara hlist_for_each (node, dquot_hash+hashent) { 253884d179dSJan Kara dquot = hlist_entry(node, struct dquot, dq_hash); 254884d179dSJan Kara if (dquot->dq_sb == sb && dquot->dq_id == id && dquot->dq_type == type) 255884d179dSJan Kara return dquot; 256884d179dSJan Kara } 257dd6f3c6dSJan Kara return NULL; 258884d179dSJan Kara } 259884d179dSJan Kara 260884d179dSJan Kara /* Add a dquot to the tail of the free list */ 261884d179dSJan Kara static inline void put_dquot_last(struct dquot *dquot) 262884d179dSJan Kara { 263884d179dSJan Kara list_add_tail(&dquot->dq_free, &free_dquots); 264884d179dSJan Kara dqstats.free_dquots++; 265884d179dSJan Kara } 266884d179dSJan Kara 267884d179dSJan Kara static inline void remove_free_dquot(struct dquot *dquot) 268884d179dSJan Kara { 269884d179dSJan Kara if (list_empty(&dquot->dq_free)) 270884d179dSJan Kara return; 271884d179dSJan Kara list_del_init(&dquot->dq_free); 272884d179dSJan Kara dqstats.free_dquots--; 273884d179dSJan Kara } 274884d179dSJan Kara 275884d179dSJan Kara static inline void put_inuse(struct dquot *dquot) 276884d179dSJan Kara { 277884d179dSJan Kara /* We add to the back of inuse list so we don't have to restart 278884d179dSJan Kara * when traversing this list and we block */ 279884d179dSJan Kara list_add_tail(&dquot->dq_inuse, &inuse_list); 280884d179dSJan Kara dqstats.allocated_dquots++; 281884d179dSJan Kara } 282884d179dSJan Kara 283884d179dSJan Kara static inline void remove_inuse(struct dquot *dquot) 284884d179dSJan Kara { 285884d179dSJan Kara dqstats.allocated_dquots--; 286884d179dSJan Kara list_del(&dquot->dq_inuse); 287884d179dSJan Kara } 288884d179dSJan Kara /* 289884d179dSJan Kara * End of list functions needing dq_list_lock 290884d179dSJan Kara */ 291884d179dSJan Kara 292884d179dSJan Kara static void wait_on_dquot(struct dquot *dquot) 293884d179dSJan Kara { 294884d179dSJan Kara mutex_lock(&dquot->dq_lock); 295884d179dSJan Kara mutex_unlock(&dquot->dq_lock); 296884d179dSJan Kara } 297884d179dSJan Kara 298884d179dSJan Kara static inline int dquot_dirty(struct dquot *dquot) 299884d179dSJan Kara { 300884d179dSJan Kara return test_bit(DQ_MOD_B, &dquot->dq_flags); 301884d179dSJan Kara } 302884d179dSJan Kara 303884d179dSJan Kara static inline int mark_dquot_dirty(struct dquot *dquot) 304884d179dSJan Kara { 305884d179dSJan Kara return dquot->dq_sb->dq_op->mark_dirty(dquot); 306884d179dSJan Kara } 307884d179dSJan Kara 308884d179dSJan Kara int dquot_mark_dquot_dirty(struct dquot *dquot) 309884d179dSJan Kara { 310884d179dSJan Kara spin_lock(&dq_list_lock); 311884d179dSJan Kara if (!test_and_set_bit(DQ_MOD_B, &dquot->dq_flags)) 312884d179dSJan Kara list_add(&dquot->dq_dirty, &sb_dqopt(dquot->dq_sb)-> 313884d179dSJan Kara info[dquot->dq_type].dqi_dirty_list); 314884d179dSJan Kara spin_unlock(&dq_list_lock); 315884d179dSJan Kara return 0; 316884d179dSJan Kara } 317884d179dSJan Kara EXPORT_SYMBOL(dquot_mark_dquot_dirty); 318884d179dSJan Kara 319884d179dSJan Kara /* This function needs dq_list_lock */ 320884d179dSJan Kara static inline int clear_dquot_dirty(struct dquot *dquot) 321884d179dSJan Kara { 322884d179dSJan Kara if (!test_and_clear_bit(DQ_MOD_B, &dquot->dq_flags)) 323884d179dSJan Kara return 0; 324884d179dSJan Kara list_del_init(&dquot->dq_dirty); 325884d179dSJan Kara return 1; 326884d179dSJan Kara } 327884d179dSJan Kara 328884d179dSJan Kara void mark_info_dirty(struct super_block *sb, int type) 329884d179dSJan Kara { 330884d179dSJan Kara set_bit(DQF_INFO_DIRTY_B, &sb_dqopt(sb)->info[type].dqi_flags); 331884d179dSJan Kara } 332884d179dSJan Kara EXPORT_SYMBOL(mark_info_dirty); 333884d179dSJan Kara 334884d179dSJan Kara /* 335884d179dSJan Kara * Read dquot from disk and alloc space for it 336884d179dSJan Kara */ 337884d179dSJan Kara 338884d179dSJan Kara int dquot_acquire(struct dquot *dquot) 339884d179dSJan Kara { 340884d179dSJan Kara int ret = 0, ret2 = 0; 341884d179dSJan Kara struct quota_info *dqopt = sb_dqopt(dquot->dq_sb); 342884d179dSJan Kara 343884d179dSJan Kara mutex_lock(&dquot->dq_lock); 344884d179dSJan Kara mutex_lock(&dqopt->dqio_mutex); 345884d179dSJan Kara if (!test_bit(DQ_READ_B, &dquot->dq_flags)) 346884d179dSJan Kara ret = dqopt->ops[dquot->dq_type]->read_dqblk(dquot); 347884d179dSJan Kara if (ret < 0) 348884d179dSJan Kara goto out_iolock; 349884d179dSJan Kara set_bit(DQ_READ_B, &dquot->dq_flags); 350884d179dSJan Kara /* Instantiate dquot if needed */ 351884d179dSJan Kara if (!test_bit(DQ_ACTIVE_B, &dquot->dq_flags) && !dquot->dq_off) { 352884d179dSJan Kara ret = dqopt->ops[dquot->dq_type]->commit_dqblk(dquot); 353884d179dSJan Kara /* Write the info if needed */ 354884d179dSJan Kara if (info_dirty(&dqopt->info[dquot->dq_type])) 355884d179dSJan Kara ret2 = dqopt->ops[dquot->dq_type]->write_file_info(dquot->dq_sb, dquot->dq_type); 356884d179dSJan Kara if (ret < 0) 357884d179dSJan Kara goto out_iolock; 358884d179dSJan Kara if (ret2 < 0) { 359884d179dSJan Kara ret = ret2; 360884d179dSJan Kara goto out_iolock; 361884d179dSJan Kara } 362884d179dSJan Kara } 363884d179dSJan Kara set_bit(DQ_ACTIVE_B, &dquot->dq_flags); 364884d179dSJan Kara out_iolock: 365884d179dSJan Kara mutex_unlock(&dqopt->dqio_mutex); 366884d179dSJan Kara mutex_unlock(&dquot->dq_lock); 367884d179dSJan Kara return ret; 368884d179dSJan Kara } 369884d179dSJan Kara EXPORT_SYMBOL(dquot_acquire); 370884d179dSJan Kara 371884d179dSJan Kara /* 372884d179dSJan Kara * Write dquot to disk 373884d179dSJan Kara */ 374884d179dSJan Kara int dquot_commit(struct dquot *dquot) 375884d179dSJan Kara { 376884d179dSJan Kara int ret = 0, ret2 = 0; 377884d179dSJan Kara struct quota_info *dqopt = sb_dqopt(dquot->dq_sb); 378884d179dSJan Kara 379884d179dSJan Kara mutex_lock(&dqopt->dqio_mutex); 380884d179dSJan Kara spin_lock(&dq_list_lock); 381884d179dSJan Kara if (!clear_dquot_dirty(dquot)) { 382884d179dSJan Kara spin_unlock(&dq_list_lock); 383884d179dSJan Kara goto out_sem; 384884d179dSJan Kara } 385884d179dSJan Kara spin_unlock(&dq_list_lock); 386884d179dSJan Kara /* Inactive dquot can be only if there was error during read/init 387884d179dSJan Kara * => we have better not writing it */ 388884d179dSJan Kara if (test_bit(DQ_ACTIVE_B, &dquot->dq_flags)) { 389884d179dSJan Kara ret = dqopt->ops[dquot->dq_type]->commit_dqblk(dquot); 390884d179dSJan Kara if (info_dirty(&dqopt->info[dquot->dq_type])) 391884d179dSJan Kara ret2 = dqopt->ops[dquot->dq_type]->write_file_info(dquot->dq_sb, dquot->dq_type); 392884d179dSJan Kara if (ret >= 0) 393884d179dSJan Kara ret = ret2; 394884d179dSJan Kara } 395884d179dSJan Kara out_sem: 396884d179dSJan Kara mutex_unlock(&dqopt->dqio_mutex); 397884d179dSJan Kara return ret; 398884d179dSJan Kara } 399884d179dSJan Kara EXPORT_SYMBOL(dquot_commit); 400884d179dSJan Kara 401884d179dSJan Kara /* 402884d179dSJan Kara * Release dquot 403884d179dSJan Kara */ 404884d179dSJan Kara int dquot_release(struct dquot *dquot) 405884d179dSJan Kara { 406884d179dSJan Kara int ret = 0, ret2 = 0; 407884d179dSJan Kara struct quota_info *dqopt = sb_dqopt(dquot->dq_sb); 408884d179dSJan Kara 409884d179dSJan Kara mutex_lock(&dquot->dq_lock); 410884d179dSJan Kara /* Check whether we are not racing with some other dqget() */ 411884d179dSJan Kara if (atomic_read(&dquot->dq_count) > 1) 412884d179dSJan Kara goto out_dqlock; 413884d179dSJan Kara mutex_lock(&dqopt->dqio_mutex); 414884d179dSJan Kara if (dqopt->ops[dquot->dq_type]->release_dqblk) { 415884d179dSJan Kara ret = dqopt->ops[dquot->dq_type]->release_dqblk(dquot); 416884d179dSJan Kara /* Write the info */ 417884d179dSJan Kara if (info_dirty(&dqopt->info[dquot->dq_type])) 418884d179dSJan Kara ret2 = dqopt->ops[dquot->dq_type]->write_file_info(dquot->dq_sb, dquot->dq_type); 419884d179dSJan Kara if (ret >= 0) 420884d179dSJan Kara ret = ret2; 421884d179dSJan Kara } 422884d179dSJan Kara clear_bit(DQ_ACTIVE_B, &dquot->dq_flags); 423884d179dSJan Kara mutex_unlock(&dqopt->dqio_mutex); 424884d179dSJan Kara out_dqlock: 425884d179dSJan Kara mutex_unlock(&dquot->dq_lock); 426884d179dSJan Kara return ret; 427884d179dSJan Kara } 428884d179dSJan Kara EXPORT_SYMBOL(dquot_release); 429884d179dSJan Kara 430884d179dSJan Kara void dquot_destroy(struct dquot *dquot) 431884d179dSJan Kara { 432884d179dSJan Kara kmem_cache_free(dquot_cachep, dquot); 433884d179dSJan Kara } 434884d179dSJan Kara EXPORT_SYMBOL(dquot_destroy); 435884d179dSJan Kara 436884d179dSJan Kara static inline void do_destroy_dquot(struct dquot *dquot) 437884d179dSJan Kara { 438884d179dSJan Kara dquot->dq_sb->dq_op->destroy_dquot(dquot); 439884d179dSJan Kara } 440884d179dSJan Kara 441884d179dSJan Kara /* Invalidate all dquots on the list. Note that this function is called after 442884d179dSJan Kara * quota is disabled and pointers from inodes removed so there cannot be new 443884d179dSJan Kara * quota users. There can still be some users of quotas due to inodes being 444884d179dSJan Kara * just deleted or pruned by prune_icache() (those are not attached to any 445884d179dSJan Kara * list) or parallel quotactl call. We have to wait for such users. 446884d179dSJan Kara */ 447884d179dSJan Kara static void invalidate_dquots(struct super_block *sb, int type) 448884d179dSJan Kara { 449884d179dSJan Kara struct dquot *dquot, *tmp; 450884d179dSJan Kara 451884d179dSJan Kara restart: 452884d179dSJan Kara spin_lock(&dq_list_lock); 453884d179dSJan Kara list_for_each_entry_safe(dquot, tmp, &inuse_list, dq_inuse) { 454884d179dSJan Kara if (dquot->dq_sb != sb) 455884d179dSJan Kara continue; 456884d179dSJan Kara if (dquot->dq_type != type) 457884d179dSJan Kara continue; 458884d179dSJan Kara /* Wait for dquot users */ 459884d179dSJan Kara if (atomic_read(&dquot->dq_count)) { 460884d179dSJan Kara DEFINE_WAIT(wait); 461884d179dSJan Kara 462884d179dSJan Kara atomic_inc(&dquot->dq_count); 463884d179dSJan Kara prepare_to_wait(&dquot->dq_wait_unused, &wait, 464884d179dSJan Kara TASK_UNINTERRUPTIBLE); 465884d179dSJan Kara spin_unlock(&dq_list_lock); 466884d179dSJan Kara /* Once dqput() wakes us up, we know it's time to free 467884d179dSJan Kara * the dquot. 468884d179dSJan Kara * IMPORTANT: we rely on the fact that there is always 469884d179dSJan Kara * at most one process waiting for dquot to free. 470884d179dSJan Kara * Otherwise dq_count would be > 1 and we would never 471884d179dSJan Kara * wake up. 472884d179dSJan Kara */ 473884d179dSJan Kara if (atomic_read(&dquot->dq_count) > 1) 474884d179dSJan Kara schedule(); 475884d179dSJan Kara finish_wait(&dquot->dq_wait_unused, &wait); 476884d179dSJan Kara dqput(dquot); 477884d179dSJan Kara /* At this moment dquot() need not exist (it could be 478884d179dSJan Kara * reclaimed by prune_dqcache(). Hence we must 479884d179dSJan Kara * restart. */ 480884d179dSJan Kara goto restart; 481884d179dSJan Kara } 482884d179dSJan Kara /* 483884d179dSJan Kara * Quota now has no users and it has been written on last 484884d179dSJan Kara * dqput() 485884d179dSJan Kara */ 486884d179dSJan Kara remove_dquot_hash(dquot); 487884d179dSJan Kara remove_free_dquot(dquot); 488884d179dSJan Kara remove_inuse(dquot); 489884d179dSJan Kara do_destroy_dquot(dquot); 490884d179dSJan Kara } 491884d179dSJan Kara spin_unlock(&dq_list_lock); 492884d179dSJan Kara } 493884d179dSJan Kara 494884d179dSJan Kara /* Call callback for every active dquot on given filesystem */ 495884d179dSJan Kara int dquot_scan_active(struct super_block *sb, 496884d179dSJan Kara int (*fn)(struct dquot *dquot, unsigned long priv), 497884d179dSJan Kara unsigned long priv) 498884d179dSJan Kara { 499884d179dSJan Kara struct dquot *dquot, *old_dquot = NULL; 500884d179dSJan Kara int ret = 0; 501884d179dSJan Kara 502884d179dSJan Kara mutex_lock(&sb_dqopt(sb)->dqonoff_mutex); 503884d179dSJan Kara spin_lock(&dq_list_lock); 504884d179dSJan Kara list_for_each_entry(dquot, &inuse_list, dq_inuse) { 505884d179dSJan Kara if (!test_bit(DQ_ACTIVE_B, &dquot->dq_flags)) 506884d179dSJan Kara continue; 507884d179dSJan Kara if (dquot->dq_sb != sb) 508884d179dSJan Kara continue; 509884d179dSJan Kara /* Now we have active dquot so we can just increase use count */ 510884d179dSJan Kara atomic_inc(&dquot->dq_count); 511884d179dSJan Kara dqstats.lookups++; 512884d179dSJan Kara spin_unlock(&dq_list_lock); 513884d179dSJan Kara dqput(old_dquot); 514884d179dSJan Kara old_dquot = dquot; 515884d179dSJan Kara ret = fn(dquot, priv); 516884d179dSJan Kara if (ret < 0) 517884d179dSJan Kara goto out; 518884d179dSJan Kara spin_lock(&dq_list_lock); 519884d179dSJan Kara /* We are safe to continue now because our dquot could not 520884d179dSJan Kara * be moved out of the inuse list while we hold the reference */ 521884d179dSJan Kara } 522884d179dSJan Kara spin_unlock(&dq_list_lock); 523884d179dSJan Kara out: 524884d179dSJan Kara dqput(old_dquot); 525884d179dSJan Kara mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex); 526884d179dSJan Kara return ret; 527884d179dSJan Kara } 528884d179dSJan Kara EXPORT_SYMBOL(dquot_scan_active); 529884d179dSJan Kara 530884d179dSJan Kara int vfs_quota_sync(struct super_block *sb, int type) 531884d179dSJan Kara { 532884d179dSJan Kara struct list_head *dirty; 533884d179dSJan Kara struct dquot *dquot; 534884d179dSJan Kara struct quota_info *dqopt = sb_dqopt(sb); 535884d179dSJan Kara int cnt; 536884d179dSJan Kara 537884d179dSJan Kara mutex_lock(&dqopt->dqonoff_mutex); 538884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 539884d179dSJan Kara if (type != -1 && cnt != type) 540884d179dSJan Kara continue; 541884d179dSJan Kara if (!sb_has_quota_active(sb, cnt)) 542884d179dSJan Kara continue; 543884d179dSJan Kara spin_lock(&dq_list_lock); 544884d179dSJan Kara dirty = &dqopt->info[cnt].dqi_dirty_list; 545884d179dSJan Kara while (!list_empty(dirty)) { 546884d179dSJan Kara dquot = list_first_entry(dirty, struct dquot, dq_dirty); 547884d179dSJan Kara /* Dirty and inactive can be only bad dquot... */ 548884d179dSJan Kara if (!test_bit(DQ_ACTIVE_B, &dquot->dq_flags)) { 549884d179dSJan Kara clear_dquot_dirty(dquot); 550884d179dSJan Kara continue; 551884d179dSJan Kara } 552884d179dSJan Kara /* Now we have active dquot from which someone is 553884d179dSJan Kara * holding reference so we can safely just increase 554884d179dSJan Kara * use count */ 555884d179dSJan Kara atomic_inc(&dquot->dq_count); 556884d179dSJan Kara dqstats.lookups++; 557884d179dSJan Kara spin_unlock(&dq_list_lock); 558884d179dSJan Kara sb->dq_op->write_dquot(dquot); 559884d179dSJan Kara dqput(dquot); 560884d179dSJan Kara spin_lock(&dq_list_lock); 561884d179dSJan Kara } 562884d179dSJan Kara spin_unlock(&dq_list_lock); 563884d179dSJan Kara } 564884d179dSJan Kara 565884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) 566884d179dSJan Kara if ((cnt == type || type == -1) && sb_has_quota_active(sb, cnt) 567884d179dSJan Kara && info_dirty(&dqopt->info[cnt])) 568884d179dSJan Kara sb->dq_op->write_info(sb, cnt); 569884d179dSJan Kara spin_lock(&dq_list_lock); 570884d179dSJan Kara dqstats.syncs++; 571884d179dSJan Kara spin_unlock(&dq_list_lock); 572884d179dSJan Kara mutex_unlock(&dqopt->dqonoff_mutex); 573884d179dSJan Kara 574884d179dSJan Kara return 0; 575884d179dSJan Kara } 576884d179dSJan Kara EXPORT_SYMBOL(vfs_quota_sync); 577884d179dSJan Kara 578884d179dSJan Kara /* Free unused dquots from cache */ 579884d179dSJan Kara static void prune_dqcache(int count) 580884d179dSJan Kara { 581884d179dSJan Kara struct list_head *head; 582884d179dSJan Kara struct dquot *dquot; 583884d179dSJan Kara 584884d179dSJan Kara head = free_dquots.prev; 585884d179dSJan Kara while (head != &free_dquots && count) { 586884d179dSJan Kara dquot = list_entry(head, struct dquot, dq_free); 587884d179dSJan Kara remove_dquot_hash(dquot); 588884d179dSJan Kara remove_free_dquot(dquot); 589884d179dSJan Kara remove_inuse(dquot); 590884d179dSJan Kara do_destroy_dquot(dquot); 591884d179dSJan Kara count--; 592884d179dSJan Kara head = free_dquots.prev; 593884d179dSJan Kara } 594884d179dSJan Kara } 595884d179dSJan Kara 596884d179dSJan Kara /* 597884d179dSJan Kara * This is called from kswapd when we think we need some 598884d179dSJan Kara * more memory 599884d179dSJan Kara */ 600884d179dSJan Kara 601884d179dSJan Kara static int shrink_dqcache_memory(int nr, gfp_t gfp_mask) 602884d179dSJan Kara { 603884d179dSJan Kara if (nr) { 604884d179dSJan Kara spin_lock(&dq_list_lock); 605884d179dSJan Kara prune_dqcache(nr); 606884d179dSJan Kara spin_unlock(&dq_list_lock); 607884d179dSJan Kara } 608884d179dSJan Kara return (dqstats.free_dquots / 100) * sysctl_vfs_cache_pressure; 609884d179dSJan Kara } 610884d179dSJan Kara 611884d179dSJan Kara static struct shrinker dqcache_shrinker = { 612884d179dSJan Kara .shrink = shrink_dqcache_memory, 613884d179dSJan Kara .seeks = DEFAULT_SEEKS, 614884d179dSJan Kara }; 615884d179dSJan Kara 616884d179dSJan Kara /* 617884d179dSJan Kara * Put reference to dquot 618884d179dSJan Kara * NOTE: If you change this function please check whether dqput_blocks() works right... 619884d179dSJan Kara */ 620884d179dSJan Kara void dqput(struct dquot *dquot) 621884d179dSJan Kara { 622884d179dSJan Kara int ret; 623884d179dSJan Kara 624884d179dSJan Kara if (!dquot) 625884d179dSJan Kara return; 626884d179dSJan Kara #ifdef __DQUOT_PARANOIA 627884d179dSJan Kara if (!atomic_read(&dquot->dq_count)) { 628884d179dSJan Kara printk("VFS: dqput: trying to free free dquot\n"); 629884d179dSJan Kara printk("VFS: device %s, dquot of %s %d\n", 630884d179dSJan Kara dquot->dq_sb->s_id, 631884d179dSJan Kara quotatypes[dquot->dq_type], 632884d179dSJan Kara dquot->dq_id); 633884d179dSJan Kara BUG(); 634884d179dSJan Kara } 635884d179dSJan Kara #endif 636884d179dSJan Kara 637884d179dSJan Kara spin_lock(&dq_list_lock); 638884d179dSJan Kara dqstats.drops++; 639884d179dSJan Kara spin_unlock(&dq_list_lock); 640884d179dSJan Kara we_slept: 641884d179dSJan Kara spin_lock(&dq_list_lock); 642884d179dSJan Kara if (atomic_read(&dquot->dq_count) > 1) { 643884d179dSJan Kara /* We have more than one user... nothing to do */ 644884d179dSJan Kara atomic_dec(&dquot->dq_count); 645884d179dSJan Kara /* Releasing dquot during quotaoff phase? */ 646884d179dSJan Kara if (!sb_has_quota_active(dquot->dq_sb, dquot->dq_type) && 647884d179dSJan Kara atomic_read(&dquot->dq_count) == 1) 648884d179dSJan Kara wake_up(&dquot->dq_wait_unused); 649884d179dSJan Kara spin_unlock(&dq_list_lock); 650884d179dSJan Kara return; 651884d179dSJan Kara } 652884d179dSJan Kara /* Need to release dquot? */ 653884d179dSJan Kara if (test_bit(DQ_ACTIVE_B, &dquot->dq_flags) && dquot_dirty(dquot)) { 654884d179dSJan Kara spin_unlock(&dq_list_lock); 655884d179dSJan Kara /* Commit dquot before releasing */ 656884d179dSJan Kara ret = dquot->dq_sb->dq_op->write_dquot(dquot); 657884d179dSJan Kara if (ret < 0) { 658884d179dSJan Kara printk(KERN_ERR "VFS: cannot write quota structure on " 659884d179dSJan Kara "device %s (error %d). Quota may get out of " 660884d179dSJan Kara "sync!\n", dquot->dq_sb->s_id, ret); 661884d179dSJan Kara /* 662884d179dSJan Kara * We clear dirty bit anyway, so that we avoid 663884d179dSJan Kara * infinite loop here 664884d179dSJan Kara */ 665884d179dSJan Kara spin_lock(&dq_list_lock); 666884d179dSJan Kara clear_dquot_dirty(dquot); 667884d179dSJan Kara spin_unlock(&dq_list_lock); 668884d179dSJan Kara } 669884d179dSJan Kara goto we_slept; 670884d179dSJan Kara } 671884d179dSJan Kara /* Clear flag in case dquot was inactive (something bad happened) */ 672884d179dSJan Kara clear_dquot_dirty(dquot); 673884d179dSJan Kara if (test_bit(DQ_ACTIVE_B, &dquot->dq_flags)) { 674884d179dSJan Kara spin_unlock(&dq_list_lock); 675884d179dSJan Kara dquot->dq_sb->dq_op->release_dquot(dquot); 676884d179dSJan Kara goto we_slept; 677884d179dSJan Kara } 678884d179dSJan Kara atomic_dec(&dquot->dq_count); 679884d179dSJan Kara #ifdef __DQUOT_PARANOIA 680884d179dSJan Kara /* sanity check */ 681884d179dSJan Kara BUG_ON(!list_empty(&dquot->dq_free)); 682884d179dSJan Kara #endif 683884d179dSJan Kara put_dquot_last(dquot); 684884d179dSJan Kara spin_unlock(&dq_list_lock); 685884d179dSJan Kara } 686884d179dSJan Kara EXPORT_SYMBOL(dqput); 687884d179dSJan Kara 688884d179dSJan Kara struct dquot *dquot_alloc(struct super_block *sb, int type) 689884d179dSJan Kara { 690884d179dSJan Kara return kmem_cache_zalloc(dquot_cachep, GFP_NOFS); 691884d179dSJan Kara } 692884d179dSJan Kara EXPORT_SYMBOL(dquot_alloc); 693884d179dSJan Kara 694884d179dSJan Kara static struct dquot *get_empty_dquot(struct super_block *sb, int type) 695884d179dSJan Kara { 696884d179dSJan Kara struct dquot *dquot; 697884d179dSJan Kara 698884d179dSJan Kara dquot = sb->dq_op->alloc_dquot(sb, type); 699884d179dSJan Kara if(!dquot) 700dd6f3c6dSJan Kara return NULL; 701884d179dSJan Kara 702884d179dSJan Kara mutex_init(&dquot->dq_lock); 703884d179dSJan Kara INIT_LIST_HEAD(&dquot->dq_free); 704884d179dSJan Kara INIT_LIST_HEAD(&dquot->dq_inuse); 705884d179dSJan Kara INIT_HLIST_NODE(&dquot->dq_hash); 706884d179dSJan Kara INIT_LIST_HEAD(&dquot->dq_dirty); 707884d179dSJan Kara init_waitqueue_head(&dquot->dq_wait_unused); 708884d179dSJan Kara dquot->dq_sb = sb; 709884d179dSJan Kara dquot->dq_type = type; 710884d179dSJan Kara atomic_set(&dquot->dq_count, 1); 711884d179dSJan Kara 712884d179dSJan Kara return dquot; 713884d179dSJan Kara } 714884d179dSJan Kara 715884d179dSJan Kara /* 716884d179dSJan Kara * Get reference to dquot 717884d179dSJan Kara * 718884d179dSJan Kara * Locking is slightly tricky here. We are guarded from parallel quotaoff() 719884d179dSJan Kara * destroying our dquot by: 720884d179dSJan Kara * a) checking for quota flags under dq_list_lock and 721884d179dSJan Kara * b) getting a reference to dquot before we release dq_list_lock 722884d179dSJan Kara */ 723884d179dSJan Kara struct dquot *dqget(struct super_block *sb, unsigned int id, int type) 724884d179dSJan Kara { 725884d179dSJan Kara unsigned int hashent = hashfn(sb, id, type); 726dd6f3c6dSJan Kara struct dquot *dquot = NULL, *empty = NULL; 727884d179dSJan Kara 728884d179dSJan Kara if (!sb_has_quota_active(sb, type)) 729dd6f3c6dSJan Kara return NULL; 730884d179dSJan Kara we_slept: 731884d179dSJan Kara spin_lock(&dq_list_lock); 732884d179dSJan Kara spin_lock(&dq_state_lock); 733884d179dSJan Kara if (!sb_has_quota_active(sb, type)) { 734884d179dSJan Kara spin_unlock(&dq_state_lock); 735884d179dSJan Kara spin_unlock(&dq_list_lock); 736884d179dSJan Kara goto out; 737884d179dSJan Kara } 738884d179dSJan Kara spin_unlock(&dq_state_lock); 739884d179dSJan Kara 740dd6f3c6dSJan Kara dquot = find_dquot(hashent, sb, id, type); 741dd6f3c6dSJan Kara if (!dquot) { 742dd6f3c6dSJan Kara if (!empty) { 743884d179dSJan Kara spin_unlock(&dq_list_lock); 744dd6f3c6dSJan Kara empty = get_empty_dquot(sb, type); 745dd6f3c6dSJan Kara if (!empty) 746884d179dSJan Kara schedule(); /* Try to wait for a moment... */ 747884d179dSJan Kara goto we_slept; 748884d179dSJan Kara } 749884d179dSJan Kara dquot = empty; 750dd6f3c6dSJan Kara empty = NULL; 751884d179dSJan Kara dquot->dq_id = id; 752884d179dSJan Kara /* all dquots go on the inuse_list */ 753884d179dSJan Kara put_inuse(dquot); 754884d179dSJan Kara /* hash it first so it can be found */ 755884d179dSJan Kara insert_dquot_hash(dquot); 756884d179dSJan Kara dqstats.lookups++; 757884d179dSJan Kara spin_unlock(&dq_list_lock); 758884d179dSJan Kara } else { 759884d179dSJan Kara if (!atomic_read(&dquot->dq_count)) 760884d179dSJan Kara remove_free_dquot(dquot); 761884d179dSJan Kara atomic_inc(&dquot->dq_count); 762884d179dSJan Kara dqstats.cache_hits++; 763884d179dSJan Kara dqstats.lookups++; 764884d179dSJan Kara spin_unlock(&dq_list_lock); 765884d179dSJan Kara } 766884d179dSJan Kara /* Wait for dq_lock - after this we know that either dquot_release() is already 767884d179dSJan Kara * finished or it will be canceled due to dq_count > 1 test */ 768884d179dSJan Kara wait_on_dquot(dquot); 769884d179dSJan Kara /* Read the dquot and instantiate it (everything done only if needed) */ 770884d179dSJan Kara if (!test_bit(DQ_ACTIVE_B, &dquot->dq_flags) && sb->dq_op->acquire_dquot(dquot) < 0) { 771884d179dSJan Kara dqput(dquot); 772dd6f3c6dSJan Kara dquot = NULL; 773884d179dSJan Kara goto out; 774884d179dSJan Kara } 775884d179dSJan Kara #ifdef __DQUOT_PARANOIA 776884d179dSJan Kara BUG_ON(!dquot->dq_sb); /* Has somebody invalidated entry under us? */ 777884d179dSJan Kara #endif 778884d179dSJan Kara out: 779884d179dSJan Kara if (empty) 780884d179dSJan Kara do_destroy_dquot(empty); 781884d179dSJan Kara 782884d179dSJan Kara return dquot; 783884d179dSJan Kara } 784884d179dSJan Kara EXPORT_SYMBOL(dqget); 785884d179dSJan Kara 786884d179dSJan Kara static int dqinit_needed(struct inode *inode, int type) 787884d179dSJan Kara { 788884d179dSJan Kara int cnt; 789884d179dSJan Kara 790884d179dSJan Kara if (IS_NOQUOTA(inode)) 791884d179dSJan Kara return 0; 792884d179dSJan Kara if (type != -1) 793dd6f3c6dSJan Kara return !inode->i_dquot[type]; 794884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) 795dd6f3c6dSJan Kara if (!inode->i_dquot[cnt]) 796884d179dSJan Kara return 1; 797884d179dSJan Kara return 0; 798884d179dSJan Kara } 799884d179dSJan Kara 800884d179dSJan Kara /* This routine is guarded by dqonoff_mutex mutex */ 801884d179dSJan Kara static void add_dquot_ref(struct super_block *sb, int type) 802884d179dSJan Kara { 803884d179dSJan Kara struct inode *inode, *old_inode = NULL; 804884d179dSJan Kara 805884d179dSJan Kara spin_lock(&inode_lock); 806884d179dSJan Kara list_for_each_entry(inode, &sb->s_inodes, i_sb_list) { 807884d179dSJan Kara if (!atomic_read(&inode->i_writecount)) 808884d179dSJan Kara continue; 809884d179dSJan Kara if (!dqinit_needed(inode, type)) 810884d179dSJan Kara continue; 811884d179dSJan Kara if (inode->i_state & (I_FREEING|I_WILL_FREE)) 812884d179dSJan Kara continue; 813884d179dSJan Kara 814884d179dSJan Kara __iget(inode); 815884d179dSJan Kara spin_unlock(&inode_lock); 816884d179dSJan Kara 817884d179dSJan Kara iput(old_inode); 818884d179dSJan Kara sb->dq_op->initialize(inode, type); 819884d179dSJan Kara /* We hold a reference to 'inode' so it couldn't have been 820884d179dSJan Kara * removed from s_inodes list while we dropped the inode_lock. 821884d179dSJan Kara * We cannot iput the inode now as we can be holding the last 822884d179dSJan Kara * reference and we cannot iput it under inode_lock. So we 823884d179dSJan Kara * keep the reference and iput it later. */ 824884d179dSJan Kara old_inode = inode; 825884d179dSJan Kara spin_lock(&inode_lock); 826884d179dSJan Kara } 827884d179dSJan Kara spin_unlock(&inode_lock); 828884d179dSJan Kara iput(old_inode); 829884d179dSJan Kara } 830884d179dSJan Kara 831884d179dSJan Kara /* Return 0 if dqput() won't block (note that 1 doesn't necessarily mean blocking) */ 832884d179dSJan Kara static inline int dqput_blocks(struct dquot *dquot) 833884d179dSJan Kara { 834884d179dSJan Kara if (atomic_read(&dquot->dq_count) <= 1) 835884d179dSJan Kara return 1; 836884d179dSJan Kara return 0; 837884d179dSJan Kara } 838884d179dSJan Kara 839884d179dSJan Kara /* Remove references to dquots from inode - add dquot to list for freeing if needed */ 840884d179dSJan Kara /* We can't race with anybody because we hold dqptr_sem for writing... */ 841884d179dSJan Kara static int remove_inode_dquot_ref(struct inode *inode, int type, 842884d179dSJan Kara struct list_head *tofree_head) 843884d179dSJan Kara { 844884d179dSJan Kara struct dquot *dquot = inode->i_dquot[type]; 845884d179dSJan Kara 846dd6f3c6dSJan Kara inode->i_dquot[type] = NULL; 847dd6f3c6dSJan Kara if (dquot) { 848884d179dSJan Kara if (dqput_blocks(dquot)) { 849884d179dSJan Kara #ifdef __DQUOT_PARANOIA 850884d179dSJan Kara if (atomic_read(&dquot->dq_count) != 1) 851884d179dSJan Kara printk(KERN_WARNING "VFS: Adding dquot with dq_count %d to dispose list.\n", atomic_read(&dquot->dq_count)); 852884d179dSJan Kara #endif 853884d179dSJan Kara spin_lock(&dq_list_lock); 854884d179dSJan Kara list_add(&dquot->dq_free, tofree_head); /* As dquot must have currently users it can't be on the free list... */ 855884d179dSJan Kara spin_unlock(&dq_list_lock); 856884d179dSJan Kara return 1; 857884d179dSJan Kara } 858884d179dSJan Kara else 859884d179dSJan Kara dqput(dquot); /* We have guaranteed we won't block */ 860884d179dSJan Kara } 861884d179dSJan Kara return 0; 862884d179dSJan Kara } 863884d179dSJan Kara 864884d179dSJan Kara /* Free list of dquots - called from inode.c */ 865884d179dSJan Kara /* dquots are removed from inodes, no new references can be got so we are the only ones holding reference */ 866884d179dSJan Kara static void put_dquot_list(struct list_head *tofree_head) 867884d179dSJan Kara { 868884d179dSJan Kara struct list_head *act_head; 869884d179dSJan Kara struct dquot *dquot; 870884d179dSJan Kara 871884d179dSJan Kara act_head = tofree_head->next; 872884d179dSJan Kara /* So now we have dquots on the list... Just free them */ 873884d179dSJan Kara while (act_head != tofree_head) { 874884d179dSJan Kara dquot = list_entry(act_head, struct dquot, dq_free); 875884d179dSJan Kara act_head = act_head->next; 876884d179dSJan Kara list_del_init(&dquot->dq_free); /* Remove dquot from the list so we won't have problems... */ 877884d179dSJan Kara dqput(dquot); 878884d179dSJan Kara } 879884d179dSJan Kara } 880884d179dSJan Kara 881884d179dSJan Kara static void remove_dquot_ref(struct super_block *sb, int type, 882884d179dSJan Kara struct list_head *tofree_head) 883884d179dSJan Kara { 884884d179dSJan Kara struct inode *inode; 885884d179dSJan Kara 886884d179dSJan Kara spin_lock(&inode_lock); 887884d179dSJan Kara list_for_each_entry(inode, &sb->s_inodes, i_sb_list) { 888884d179dSJan Kara if (!IS_NOQUOTA(inode)) 889884d179dSJan Kara remove_inode_dquot_ref(inode, type, tofree_head); 890884d179dSJan Kara } 891884d179dSJan Kara spin_unlock(&inode_lock); 892884d179dSJan Kara } 893884d179dSJan Kara 894884d179dSJan Kara /* Gather all references from inodes and drop them */ 895884d179dSJan Kara static void drop_dquot_ref(struct super_block *sb, int type) 896884d179dSJan Kara { 897884d179dSJan Kara LIST_HEAD(tofree_head); 898884d179dSJan Kara 899884d179dSJan Kara if (sb->dq_op) { 900884d179dSJan Kara down_write(&sb_dqopt(sb)->dqptr_sem); 901884d179dSJan Kara remove_dquot_ref(sb, type, &tofree_head); 902884d179dSJan Kara up_write(&sb_dqopt(sb)->dqptr_sem); 903884d179dSJan Kara put_dquot_list(&tofree_head); 904884d179dSJan Kara } 905884d179dSJan Kara } 906884d179dSJan Kara 907884d179dSJan Kara static inline void dquot_incr_inodes(struct dquot *dquot, qsize_t number) 908884d179dSJan Kara { 909884d179dSJan Kara dquot->dq_dqb.dqb_curinodes += number; 910884d179dSJan Kara } 911884d179dSJan Kara 912884d179dSJan Kara static inline void dquot_incr_space(struct dquot *dquot, qsize_t number) 913884d179dSJan Kara { 914884d179dSJan Kara dquot->dq_dqb.dqb_curspace += number; 915884d179dSJan Kara } 916884d179dSJan Kara 917884d179dSJan Kara static inline void dquot_resv_space(struct dquot *dquot, qsize_t number) 918884d179dSJan Kara { 919884d179dSJan Kara dquot->dq_dqb.dqb_rsvspace += number; 920884d179dSJan Kara } 921884d179dSJan Kara 922884d179dSJan Kara /* 923884d179dSJan Kara * Claim reserved quota space 924884d179dSJan Kara */ 925884d179dSJan Kara static void dquot_claim_reserved_space(struct dquot *dquot, 926884d179dSJan Kara qsize_t number) 927884d179dSJan Kara { 928884d179dSJan Kara WARN_ON(dquot->dq_dqb.dqb_rsvspace < number); 929884d179dSJan Kara dquot->dq_dqb.dqb_curspace += number; 930884d179dSJan Kara dquot->dq_dqb.dqb_rsvspace -= number; 931884d179dSJan Kara } 932884d179dSJan Kara 933884d179dSJan Kara static inline 934884d179dSJan Kara void dquot_free_reserved_space(struct dquot *dquot, qsize_t number) 935884d179dSJan Kara { 936884d179dSJan Kara dquot->dq_dqb.dqb_rsvspace -= number; 937884d179dSJan Kara } 938884d179dSJan Kara 939*7a2435d8SJan Kara static void dquot_decr_inodes(struct dquot *dquot, qsize_t number) 940884d179dSJan Kara { 941884d179dSJan Kara if (sb_dqopt(dquot->dq_sb)->flags & DQUOT_NEGATIVE_USAGE || 942884d179dSJan Kara dquot->dq_dqb.dqb_curinodes >= number) 943884d179dSJan Kara dquot->dq_dqb.dqb_curinodes -= number; 944884d179dSJan Kara else 945884d179dSJan Kara dquot->dq_dqb.dqb_curinodes = 0; 946884d179dSJan Kara if (dquot->dq_dqb.dqb_curinodes <= dquot->dq_dqb.dqb_isoftlimit) 947884d179dSJan Kara dquot->dq_dqb.dqb_itime = (time_t) 0; 948884d179dSJan Kara clear_bit(DQ_INODES_B, &dquot->dq_flags); 949884d179dSJan Kara } 950884d179dSJan Kara 951*7a2435d8SJan Kara static void dquot_decr_space(struct dquot *dquot, qsize_t number) 952884d179dSJan Kara { 953884d179dSJan Kara if (sb_dqopt(dquot->dq_sb)->flags & DQUOT_NEGATIVE_USAGE || 954884d179dSJan Kara dquot->dq_dqb.dqb_curspace >= number) 955884d179dSJan Kara dquot->dq_dqb.dqb_curspace -= number; 956884d179dSJan Kara else 957884d179dSJan Kara dquot->dq_dqb.dqb_curspace = 0; 958884d179dSJan Kara if (dquot->dq_dqb.dqb_curspace <= dquot->dq_dqb.dqb_bsoftlimit) 959884d179dSJan Kara dquot->dq_dqb.dqb_btime = (time_t) 0; 960884d179dSJan Kara clear_bit(DQ_BLKS_B, &dquot->dq_flags); 961884d179dSJan Kara } 962884d179dSJan Kara 963884d179dSJan Kara static int warning_issued(struct dquot *dquot, const int warntype) 964884d179dSJan Kara { 965884d179dSJan Kara int flag = (warntype == QUOTA_NL_BHARDWARN || 966884d179dSJan Kara warntype == QUOTA_NL_BSOFTLONGWARN) ? DQ_BLKS_B : 967884d179dSJan Kara ((warntype == QUOTA_NL_IHARDWARN || 968884d179dSJan Kara warntype == QUOTA_NL_ISOFTLONGWARN) ? DQ_INODES_B : 0); 969884d179dSJan Kara 970884d179dSJan Kara if (!flag) 971884d179dSJan Kara return 0; 972884d179dSJan Kara return test_and_set_bit(flag, &dquot->dq_flags); 973884d179dSJan Kara } 974884d179dSJan Kara 975884d179dSJan Kara #ifdef CONFIG_PRINT_QUOTA_WARNING 976884d179dSJan Kara static int flag_print_warnings = 1; 977884d179dSJan Kara 978*7a2435d8SJan Kara static int need_print_warning(struct dquot *dquot) 979884d179dSJan Kara { 980884d179dSJan Kara if (!flag_print_warnings) 981884d179dSJan Kara return 0; 982884d179dSJan Kara 983884d179dSJan Kara switch (dquot->dq_type) { 984884d179dSJan Kara case USRQUOTA: 985884d179dSJan Kara return current_fsuid() == dquot->dq_id; 986884d179dSJan Kara case GRPQUOTA: 987884d179dSJan Kara return in_group_p(dquot->dq_id); 988884d179dSJan Kara } 989884d179dSJan Kara return 0; 990884d179dSJan Kara } 991884d179dSJan Kara 992884d179dSJan Kara /* Print warning to user which exceeded quota */ 993884d179dSJan Kara static void print_warning(struct dquot *dquot, const int warntype) 994884d179dSJan Kara { 995884d179dSJan Kara char *msg = NULL; 996884d179dSJan Kara struct tty_struct *tty; 997884d179dSJan Kara 998884d179dSJan Kara if (warntype == QUOTA_NL_IHARDBELOW || 999884d179dSJan Kara warntype == QUOTA_NL_ISOFTBELOW || 1000884d179dSJan Kara warntype == QUOTA_NL_BHARDBELOW || 1001884d179dSJan Kara warntype == QUOTA_NL_BSOFTBELOW || !need_print_warning(dquot)) 1002884d179dSJan Kara return; 1003884d179dSJan Kara 1004884d179dSJan Kara tty = get_current_tty(); 1005884d179dSJan Kara if (!tty) 1006884d179dSJan Kara return; 1007884d179dSJan Kara tty_write_message(tty, dquot->dq_sb->s_id); 1008884d179dSJan Kara if (warntype == QUOTA_NL_ISOFTWARN || warntype == QUOTA_NL_BSOFTWARN) 1009884d179dSJan Kara tty_write_message(tty, ": warning, "); 1010884d179dSJan Kara else 1011884d179dSJan Kara tty_write_message(tty, ": write failed, "); 1012884d179dSJan Kara tty_write_message(tty, quotatypes[dquot->dq_type]); 1013884d179dSJan Kara switch (warntype) { 1014884d179dSJan Kara case QUOTA_NL_IHARDWARN: 1015884d179dSJan Kara msg = " file limit reached.\r\n"; 1016884d179dSJan Kara break; 1017884d179dSJan Kara case QUOTA_NL_ISOFTLONGWARN: 1018884d179dSJan Kara msg = " file quota exceeded too long.\r\n"; 1019884d179dSJan Kara break; 1020884d179dSJan Kara case QUOTA_NL_ISOFTWARN: 1021884d179dSJan Kara msg = " file quota exceeded.\r\n"; 1022884d179dSJan Kara break; 1023884d179dSJan Kara case QUOTA_NL_BHARDWARN: 1024884d179dSJan Kara msg = " block limit reached.\r\n"; 1025884d179dSJan Kara break; 1026884d179dSJan Kara case QUOTA_NL_BSOFTLONGWARN: 1027884d179dSJan Kara msg = " block quota exceeded too long.\r\n"; 1028884d179dSJan Kara break; 1029884d179dSJan Kara case QUOTA_NL_BSOFTWARN: 1030884d179dSJan Kara msg = " block quota exceeded.\r\n"; 1031884d179dSJan Kara break; 1032884d179dSJan Kara } 1033884d179dSJan Kara tty_write_message(tty, msg); 1034884d179dSJan Kara tty_kref_put(tty); 1035884d179dSJan Kara } 1036884d179dSJan Kara #endif 1037884d179dSJan Kara 1038884d179dSJan Kara #ifdef CONFIG_QUOTA_NETLINK_INTERFACE 1039884d179dSJan Kara 1040884d179dSJan Kara /* Netlink family structure for quota */ 1041884d179dSJan Kara static struct genl_family quota_genl_family = { 1042884d179dSJan Kara .id = GENL_ID_GENERATE, 1043884d179dSJan Kara .hdrsize = 0, 1044884d179dSJan Kara .name = "VFS_DQUOT", 1045884d179dSJan Kara .version = 1, 1046884d179dSJan Kara .maxattr = QUOTA_NL_A_MAX, 1047884d179dSJan Kara }; 1048884d179dSJan Kara 1049884d179dSJan Kara /* Send warning to userspace about user which exceeded quota */ 1050884d179dSJan Kara static void send_warning(const struct dquot *dquot, const char warntype) 1051884d179dSJan Kara { 1052884d179dSJan Kara static atomic_t seq; 1053884d179dSJan Kara struct sk_buff *skb; 1054884d179dSJan Kara void *msg_head; 1055884d179dSJan Kara int ret; 1056884d179dSJan Kara int msg_size = 4 * nla_total_size(sizeof(u32)) + 1057884d179dSJan Kara 2 * nla_total_size(sizeof(u64)); 1058884d179dSJan Kara 1059884d179dSJan Kara /* We have to allocate using GFP_NOFS as we are called from a 1060884d179dSJan Kara * filesystem performing write and thus further recursion into 1061884d179dSJan Kara * the fs to free some data could cause deadlocks. */ 1062884d179dSJan Kara skb = genlmsg_new(msg_size, GFP_NOFS); 1063884d179dSJan Kara if (!skb) { 1064884d179dSJan Kara printk(KERN_ERR 1065884d179dSJan Kara "VFS: Not enough memory to send quota warning.\n"); 1066884d179dSJan Kara return; 1067884d179dSJan Kara } 1068884d179dSJan Kara msg_head = genlmsg_put(skb, 0, atomic_add_return(1, &seq), 1069884d179dSJan Kara "a_genl_family, 0, QUOTA_NL_C_WARNING); 1070884d179dSJan Kara if (!msg_head) { 1071884d179dSJan Kara printk(KERN_ERR 1072884d179dSJan Kara "VFS: Cannot store netlink header in quota warning.\n"); 1073884d179dSJan Kara goto err_out; 1074884d179dSJan Kara } 1075884d179dSJan Kara ret = nla_put_u32(skb, QUOTA_NL_A_QTYPE, dquot->dq_type); 1076884d179dSJan Kara if (ret) 1077884d179dSJan Kara goto attr_err_out; 1078884d179dSJan Kara ret = nla_put_u64(skb, QUOTA_NL_A_EXCESS_ID, dquot->dq_id); 1079884d179dSJan Kara if (ret) 1080884d179dSJan Kara goto attr_err_out; 1081884d179dSJan Kara ret = nla_put_u32(skb, QUOTA_NL_A_WARNING, warntype); 1082884d179dSJan Kara if (ret) 1083884d179dSJan Kara goto attr_err_out; 1084884d179dSJan Kara ret = nla_put_u32(skb, QUOTA_NL_A_DEV_MAJOR, 1085884d179dSJan Kara MAJOR(dquot->dq_sb->s_dev)); 1086884d179dSJan Kara if (ret) 1087884d179dSJan Kara goto attr_err_out; 1088884d179dSJan Kara ret = nla_put_u32(skb, QUOTA_NL_A_DEV_MINOR, 1089884d179dSJan Kara MINOR(dquot->dq_sb->s_dev)); 1090884d179dSJan Kara if (ret) 1091884d179dSJan Kara goto attr_err_out; 1092884d179dSJan Kara ret = nla_put_u64(skb, QUOTA_NL_A_CAUSED_ID, current_uid()); 1093884d179dSJan Kara if (ret) 1094884d179dSJan Kara goto attr_err_out; 1095884d179dSJan Kara genlmsg_end(skb, msg_head); 1096884d179dSJan Kara 1097884d179dSJan Kara ret = genlmsg_multicast(skb, 0, quota_genl_family.id, GFP_NOFS); 1098884d179dSJan Kara if (ret < 0 && ret != -ESRCH) 1099884d179dSJan Kara printk(KERN_ERR 1100884d179dSJan Kara "VFS: Failed to send notification message: %d\n", ret); 1101884d179dSJan Kara return; 1102884d179dSJan Kara attr_err_out: 1103884d179dSJan Kara printk(KERN_ERR "VFS: Not enough space to compose quota message!\n"); 1104884d179dSJan Kara err_out: 1105884d179dSJan Kara kfree_skb(skb); 1106884d179dSJan Kara } 1107884d179dSJan Kara #endif 1108884d179dSJan Kara /* 1109884d179dSJan Kara * Write warnings to the console and send warning messages over netlink. 1110884d179dSJan Kara * 1111884d179dSJan Kara * Note that this function can sleep. 1112884d179dSJan Kara */ 1113*7a2435d8SJan Kara static void flush_warnings(struct dquot *const *dquots, char *warntype) 1114884d179dSJan Kara { 1115884d179dSJan Kara int i; 1116884d179dSJan Kara 1117884d179dSJan Kara for (i = 0; i < MAXQUOTAS; i++) 1118dd6f3c6dSJan Kara if (dquots[i] && warntype[i] != QUOTA_NL_NOWARN && 1119884d179dSJan Kara !warning_issued(dquots[i], warntype[i])) { 1120884d179dSJan Kara #ifdef CONFIG_PRINT_QUOTA_WARNING 1121884d179dSJan Kara print_warning(dquots[i], warntype[i]); 1122884d179dSJan Kara #endif 1123884d179dSJan Kara #ifdef CONFIG_QUOTA_NETLINK_INTERFACE 1124884d179dSJan Kara send_warning(dquots[i], warntype[i]); 1125884d179dSJan Kara #endif 1126884d179dSJan Kara } 1127884d179dSJan Kara } 1128884d179dSJan Kara 1129*7a2435d8SJan Kara static int ignore_hardlimit(struct dquot *dquot) 1130884d179dSJan Kara { 1131884d179dSJan Kara struct mem_dqinfo *info = &sb_dqopt(dquot->dq_sb)->info[dquot->dq_type]; 1132884d179dSJan Kara 1133884d179dSJan Kara return capable(CAP_SYS_RESOURCE) && 1134884d179dSJan Kara (info->dqi_format->qf_fmt_id != QFMT_VFS_OLD || !(info->dqi_flags & V1_DQF_RSQUASH)); 1135884d179dSJan Kara } 1136884d179dSJan Kara 1137884d179dSJan Kara /* needs dq_data_lock */ 1138884d179dSJan Kara static int check_idq(struct dquot *dquot, qsize_t inodes, char *warntype) 1139884d179dSJan Kara { 1140884d179dSJan Kara *warntype = QUOTA_NL_NOWARN; 1141884d179dSJan Kara if (!sb_has_quota_limits_enabled(dquot->dq_sb, dquot->dq_type) || 1142884d179dSJan Kara test_bit(DQ_FAKE_B, &dquot->dq_flags)) 1143884d179dSJan Kara return QUOTA_OK; 1144884d179dSJan Kara 1145884d179dSJan Kara if (dquot->dq_dqb.dqb_ihardlimit && 1146884d179dSJan Kara (dquot->dq_dqb.dqb_curinodes + inodes) > dquot->dq_dqb.dqb_ihardlimit && 1147884d179dSJan Kara !ignore_hardlimit(dquot)) { 1148884d179dSJan Kara *warntype = QUOTA_NL_IHARDWARN; 1149884d179dSJan Kara return NO_QUOTA; 1150884d179dSJan Kara } 1151884d179dSJan Kara 1152884d179dSJan Kara if (dquot->dq_dqb.dqb_isoftlimit && 1153884d179dSJan Kara (dquot->dq_dqb.dqb_curinodes + inodes) > dquot->dq_dqb.dqb_isoftlimit && 1154884d179dSJan Kara dquot->dq_dqb.dqb_itime && get_seconds() >= dquot->dq_dqb.dqb_itime && 1155884d179dSJan Kara !ignore_hardlimit(dquot)) { 1156884d179dSJan Kara *warntype = QUOTA_NL_ISOFTLONGWARN; 1157884d179dSJan Kara return NO_QUOTA; 1158884d179dSJan Kara } 1159884d179dSJan Kara 1160884d179dSJan Kara if (dquot->dq_dqb.dqb_isoftlimit && 1161884d179dSJan Kara (dquot->dq_dqb.dqb_curinodes + inodes) > dquot->dq_dqb.dqb_isoftlimit && 1162884d179dSJan Kara dquot->dq_dqb.dqb_itime == 0) { 1163884d179dSJan Kara *warntype = QUOTA_NL_ISOFTWARN; 1164884d179dSJan Kara dquot->dq_dqb.dqb_itime = get_seconds() + sb_dqopt(dquot->dq_sb)->info[dquot->dq_type].dqi_igrace; 1165884d179dSJan Kara } 1166884d179dSJan Kara 1167884d179dSJan Kara return QUOTA_OK; 1168884d179dSJan Kara } 1169884d179dSJan Kara 1170884d179dSJan Kara /* needs dq_data_lock */ 1171884d179dSJan Kara static int check_bdq(struct dquot *dquot, qsize_t space, int prealloc, char *warntype) 1172884d179dSJan Kara { 1173884d179dSJan Kara qsize_t tspace; 1174884d179dSJan Kara 1175884d179dSJan Kara *warntype = QUOTA_NL_NOWARN; 1176884d179dSJan Kara if (!sb_has_quota_limits_enabled(dquot->dq_sb, dquot->dq_type) || 1177884d179dSJan Kara test_bit(DQ_FAKE_B, &dquot->dq_flags)) 1178884d179dSJan Kara return QUOTA_OK; 1179884d179dSJan Kara 1180884d179dSJan Kara tspace = dquot->dq_dqb.dqb_curspace + dquot->dq_dqb.dqb_rsvspace 1181884d179dSJan Kara + space; 1182884d179dSJan Kara 1183884d179dSJan Kara if (dquot->dq_dqb.dqb_bhardlimit && 1184884d179dSJan Kara tspace > dquot->dq_dqb.dqb_bhardlimit && 1185884d179dSJan Kara !ignore_hardlimit(dquot)) { 1186884d179dSJan Kara if (!prealloc) 1187884d179dSJan Kara *warntype = QUOTA_NL_BHARDWARN; 1188884d179dSJan Kara return NO_QUOTA; 1189884d179dSJan Kara } 1190884d179dSJan Kara 1191884d179dSJan Kara if (dquot->dq_dqb.dqb_bsoftlimit && 1192884d179dSJan Kara tspace > dquot->dq_dqb.dqb_bsoftlimit && 1193884d179dSJan Kara dquot->dq_dqb.dqb_btime && get_seconds() >= dquot->dq_dqb.dqb_btime && 1194884d179dSJan Kara !ignore_hardlimit(dquot)) { 1195884d179dSJan Kara if (!prealloc) 1196884d179dSJan Kara *warntype = QUOTA_NL_BSOFTLONGWARN; 1197884d179dSJan Kara return NO_QUOTA; 1198884d179dSJan Kara } 1199884d179dSJan Kara 1200884d179dSJan Kara if (dquot->dq_dqb.dqb_bsoftlimit && 1201884d179dSJan Kara tspace > dquot->dq_dqb.dqb_bsoftlimit && 1202884d179dSJan Kara dquot->dq_dqb.dqb_btime == 0) { 1203884d179dSJan Kara if (!prealloc) { 1204884d179dSJan Kara *warntype = QUOTA_NL_BSOFTWARN; 1205884d179dSJan Kara dquot->dq_dqb.dqb_btime = get_seconds() + sb_dqopt(dquot->dq_sb)->info[dquot->dq_type].dqi_bgrace; 1206884d179dSJan Kara } 1207884d179dSJan Kara else 1208884d179dSJan Kara /* 1209884d179dSJan Kara * We don't allow preallocation to exceed softlimit so exceeding will 1210884d179dSJan Kara * be always printed 1211884d179dSJan Kara */ 1212884d179dSJan Kara return NO_QUOTA; 1213884d179dSJan Kara } 1214884d179dSJan Kara 1215884d179dSJan Kara return QUOTA_OK; 1216884d179dSJan Kara } 1217884d179dSJan Kara 1218884d179dSJan Kara static int info_idq_free(struct dquot *dquot, qsize_t inodes) 1219884d179dSJan Kara { 1220884d179dSJan Kara if (test_bit(DQ_FAKE_B, &dquot->dq_flags) || 1221884d179dSJan Kara dquot->dq_dqb.dqb_curinodes <= dquot->dq_dqb.dqb_isoftlimit || 1222884d179dSJan Kara !sb_has_quota_limits_enabled(dquot->dq_sb, dquot->dq_type)) 1223884d179dSJan Kara return QUOTA_NL_NOWARN; 1224884d179dSJan Kara 1225884d179dSJan Kara if (dquot->dq_dqb.dqb_curinodes - inodes <= dquot->dq_dqb.dqb_isoftlimit) 1226884d179dSJan Kara return QUOTA_NL_ISOFTBELOW; 1227884d179dSJan Kara if (dquot->dq_dqb.dqb_curinodes >= dquot->dq_dqb.dqb_ihardlimit && 1228884d179dSJan Kara dquot->dq_dqb.dqb_curinodes - inodes < dquot->dq_dqb.dqb_ihardlimit) 1229884d179dSJan Kara return QUOTA_NL_IHARDBELOW; 1230884d179dSJan Kara return QUOTA_NL_NOWARN; 1231884d179dSJan Kara } 1232884d179dSJan Kara 1233884d179dSJan Kara static int info_bdq_free(struct dquot *dquot, qsize_t space) 1234884d179dSJan Kara { 1235884d179dSJan Kara if (test_bit(DQ_FAKE_B, &dquot->dq_flags) || 1236884d179dSJan Kara dquot->dq_dqb.dqb_curspace <= dquot->dq_dqb.dqb_bsoftlimit) 1237884d179dSJan Kara return QUOTA_NL_NOWARN; 1238884d179dSJan Kara 1239884d179dSJan Kara if (dquot->dq_dqb.dqb_curspace - space <= dquot->dq_dqb.dqb_bsoftlimit) 1240884d179dSJan Kara return QUOTA_NL_BSOFTBELOW; 1241884d179dSJan Kara if (dquot->dq_dqb.dqb_curspace >= dquot->dq_dqb.dqb_bhardlimit && 1242884d179dSJan Kara dquot->dq_dqb.dqb_curspace - space < dquot->dq_dqb.dqb_bhardlimit) 1243884d179dSJan Kara return QUOTA_NL_BHARDBELOW; 1244884d179dSJan Kara return QUOTA_NL_NOWARN; 1245884d179dSJan Kara } 1246884d179dSJan Kara /* 1247884d179dSJan Kara * Initialize quota pointers in inode 1248884d179dSJan Kara * We do things in a bit complicated way but by that we avoid calling 1249884d179dSJan Kara * dqget() and thus filesystem callbacks under dqptr_sem. 1250884d179dSJan Kara */ 1251884d179dSJan Kara int dquot_initialize(struct inode *inode, int type) 1252884d179dSJan Kara { 1253884d179dSJan Kara unsigned int id = 0; 1254884d179dSJan Kara int cnt, ret = 0; 1255dd6f3c6dSJan Kara struct dquot *got[MAXQUOTAS] = { NULL, NULL }; 1256884d179dSJan Kara struct super_block *sb = inode->i_sb; 1257884d179dSJan Kara 1258884d179dSJan Kara /* First test before acquiring mutex - solves deadlocks when we 1259884d179dSJan Kara * re-enter the quota code and are already holding the mutex */ 1260884d179dSJan Kara if (IS_NOQUOTA(inode)) 1261884d179dSJan Kara return 0; 1262884d179dSJan Kara 1263884d179dSJan Kara /* First get references to structures we might need. */ 1264884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1265884d179dSJan Kara if (type != -1 && cnt != type) 1266884d179dSJan Kara continue; 1267884d179dSJan Kara switch (cnt) { 1268884d179dSJan Kara case USRQUOTA: 1269884d179dSJan Kara id = inode->i_uid; 1270884d179dSJan Kara break; 1271884d179dSJan Kara case GRPQUOTA: 1272884d179dSJan Kara id = inode->i_gid; 1273884d179dSJan Kara break; 1274884d179dSJan Kara } 1275884d179dSJan Kara got[cnt] = dqget(sb, id, cnt); 1276884d179dSJan Kara } 1277884d179dSJan Kara 1278884d179dSJan Kara down_write(&sb_dqopt(sb)->dqptr_sem); 1279884d179dSJan Kara /* Having dqptr_sem we know NOQUOTA flags can't be altered... */ 1280884d179dSJan Kara if (IS_NOQUOTA(inode)) 1281884d179dSJan Kara goto out_err; 1282884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1283884d179dSJan Kara if (type != -1 && cnt != type) 1284884d179dSJan Kara continue; 1285884d179dSJan Kara /* Avoid races with quotaoff() */ 1286884d179dSJan Kara if (!sb_has_quota_active(sb, cnt)) 1287884d179dSJan Kara continue; 1288dd6f3c6dSJan Kara if (!inode->i_dquot[cnt]) { 1289884d179dSJan Kara inode->i_dquot[cnt] = got[cnt]; 1290dd6f3c6dSJan Kara got[cnt] = NULL; 1291884d179dSJan Kara } 1292884d179dSJan Kara } 1293884d179dSJan Kara out_err: 1294884d179dSJan Kara up_write(&sb_dqopt(sb)->dqptr_sem); 1295884d179dSJan Kara /* Drop unused references */ 1296884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) 1297884d179dSJan Kara dqput(got[cnt]); 1298884d179dSJan Kara return ret; 1299884d179dSJan Kara } 1300884d179dSJan Kara EXPORT_SYMBOL(dquot_initialize); 1301884d179dSJan Kara 1302884d179dSJan Kara /* 1303884d179dSJan Kara * Release all quotas referenced by inode 1304884d179dSJan Kara */ 1305884d179dSJan Kara int dquot_drop(struct inode *inode) 1306884d179dSJan Kara { 1307884d179dSJan Kara int cnt; 1308884d179dSJan Kara struct dquot *put[MAXQUOTAS]; 1309884d179dSJan Kara 1310884d179dSJan Kara down_write(&sb_dqopt(inode->i_sb)->dqptr_sem); 1311884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1312884d179dSJan Kara put[cnt] = inode->i_dquot[cnt]; 1313dd6f3c6dSJan Kara inode->i_dquot[cnt] = NULL; 1314884d179dSJan Kara } 1315884d179dSJan Kara up_write(&sb_dqopt(inode->i_sb)->dqptr_sem); 1316884d179dSJan Kara 1317884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) 1318884d179dSJan Kara dqput(put[cnt]); 1319884d179dSJan Kara return 0; 1320884d179dSJan Kara } 1321884d179dSJan Kara EXPORT_SYMBOL(dquot_drop); 1322884d179dSJan Kara 1323884d179dSJan Kara /* Wrapper to remove references to quota structures from inode */ 1324884d179dSJan Kara void vfs_dq_drop(struct inode *inode) 1325884d179dSJan Kara { 1326884d179dSJan Kara /* Here we can get arbitrary inode from clear_inode() so we have 1327884d179dSJan Kara * to be careful. OTOH we don't need locking as quota operations 1328884d179dSJan Kara * are allowed to change only at mount time */ 1329884d179dSJan Kara if (!IS_NOQUOTA(inode) && inode->i_sb && inode->i_sb->dq_op 1330884d179dSJan Kara && inode->i_sb->dq_op->drop) { 1331884d179dSJan Kara int cnt; 1332884d179dSJan Kara /* Test before calling to rule out calls from proc and such 1333884d179dSJan Kara * where we are not allowed to block. Note that this is 1334884d179dSJan Kara * actually reliable test even without the lock - the caller 1335884d179dSJan Kara * must assure that nobody can come after the DQUOT_DROP and 1336884d179dSJan Kara * add quota pointers back anyway */ 1337884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) 1338dd6f3c6dSJan Kara if (inode->i_dquot[cnt]) 1339884d179dSJan Kara break; 1340884d179dSJan Kara if (cnt < MAXQUOTAS) 1341884d179dSJan Kara inode->i_sb->dq_op->drop(inode); 1342884d179dSJan Kara } 1343884d179dSJan Kara } 1344884d179dSJan Kara EXPORT_SYMBOL(vfs_dq_drop); 1345884d179dSJan Kara 1346884d179dSJan Kara /* 1347884d179dSJan Kara * Following four functions update i_blocks+i_bytes fields and 1348884d179dSJan Kara * quota information (together with appropriate checks) 1349884d179dSJan Kara * NOTE: We absolutely rely on the fact that caller dirties 1350884d179dSJan Kara * the inode (usually macros in quotaops.h care about this) and 1351884d179dSJan Kara * holds a handle for the current transaction so that dquot write and 1352884d179dSJan Kara * inode write go into the same transaction. 1353884d179dSJan Kara */ 1354884d179dSJan Kara 1355884d179dSJan Kara /* 1356884d179dSJan Kara * This operation can block, but only after everything is updated 1357884d179dSJan Kara */ 1358884d179dSJan Kara int __dquot_alloc_space(struct inode *inode, qsize_t number, 1359884d179dSJan Kara int warn, int reserve) 1360884d179dSJan Kara { 1361884d179dSJan Kara int cnt, ret = QUOTA_OK; 1362884d179dSJan Kara char warntype[MAXQUOTAS]; 1363884d179dSJan Kara 1364884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) 1365884d179dSJan Kara warntype[cnt] = QUOTA_NL_NOWARN; 1366884d179dSJan Kara 1367884d179dSJan Kara spin_lock(&dq_data_lock); 1368884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1369dd6f3c6dSJan Kara if (!inode->i_dquot[cnt]) 1370884d179dSJan Kara continue; 1371884d179dSJan Kara if (check_bdq(inode->i_dquot[cnt], number, warn, warntype+cnt) 1372884d179dSJan Kara == NO_QUOTA) { 1373884d179dSJan Kara ret = NO_QUOTA; 1374884d179dSJan Kara goto out_unlock; 1375884d179dSJan Kara } 1376884d179dSJan Kara } 1377884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1378dd6f3c6dSJan Kara if (!inode->i_dquot[cnt]) 1379884d179dSJan Kara continue; 1380884d179dSJan Kara if (reserve) 1381884d179dSJan Kara dquot_resv_space(inode->i_dquot[cnt], number); 1382884d179dSJan Kara else 1383884d179dSJan Kara dquot_incr_space(inode->i_dquot[cnt], number); 1384884d179dSJan Kara } 1385884d179dSJan Kara if (!reserve) 1386884d179dSJan Kara inode_add_bytes(inode, number); 1387884d179dSJan Kara out_unlock: 1388884d179dSJan Kara spin_unlock(&dq_data_lock); 1389884d179dSJan Kara flush_warnings(inode->i_dquot, warntype); 1390884d179dSJan Kara return ret; 1391884d179dSJan Kara } 1392884d179dSJan Kara 1393884d179dSJan Kara int dquot_alloc_space(struct inode *inode, qsize_t number, int warn) 1394884d179dSJan Kara { 1395884d179dSJan Kara int cnt, ret = QUOTA_OK; 1396884d179dSJan Kara 1397884d179dSJan Kara /* 1398884d179dSJan Kara * First test before acquiring mutex - solves deadlocks when we 1399884d179dSJan Kara * re-enter the quota code and are already holding the mutex 1400884d179dSJan Kara */ 1401884d179dSJan Kara if (IS_NOQUOTA(inode)) { 1402884d179dSJan Kara inode_add_bytes(inode, number); 1403884d179dSJan Kara goto out; 1404884d179dSJan Kara } 1405884d179dSJan Kara 1406884d179dSJan Kara down_read(&sb_dqopt(inode->i_sb)->dqptr_sem); 1407884d179dSJan Kara if (IS_NOQUOTA(inode)) { 1408884d179dSJan Kara inode_add_bytes(inode, number); 1409884d179dSJan Kara goto out_unlock; 1410884d179dSJan Kara } 1411884d179dSJan Kara 1412884d179dSJan Kara ret = __dquot_alloc_space(inode, number, warn, 0); 1413884d179dSJan Kara if (ret == NO_QUOTA) 1414884d179dSJan Kara goto out_unlock; 1415884d179dSJan Kara 1416884d179dSJan Kara /* Dirtify all the dquots - this can block when journalling */ 1417884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) 1418884d179dSJan Kara if (inode->i_dquot[cnt]) 1419884d179dSJan Kara mark_dquot_dirty(inode->i_dquot[cnt]); 1420884d179dSJan Kara out_unlock: 1421884d179dSJan Kara up_read(&sb_dqopt(inode->i_sb)->dqptr_sem); 1422884d179dSJan Kara out: 1423884d179dSJan Kara return ret; 1424884d179dSJan Kara } 1425884d179dSJan Kara EXPORT_SYMBOL(dquot_alloc_space); 1426884d179dSJan Kara 1427884d179dSJan Kara int dquot_reserve_space(struct inode *inode, qsize_t number, int warn) 1428884d179dSJan Kara { 1429884d179dSJan Kara int ret = QUOTA_OK; 1430884d179dSJan Kara 1431884d179dSJan Kara if (IS_NOQUOTA(inode)) 1432884d179dSJan Kara goto out; 1433884d179dSJan Kara 1434884d179dSJan Kara down_read(&sb_dqopt(inode->i_sb)->dqptr_sem); 1435884d179dSJan Kara if (IS_NOQUOTA(inode)) 1436884d179dSJan Kara goto out_unlock; 1437884d179dSJan Kara 1438884d179dSJan Kara ret = __dquot_alloc_space(inode, number, warn, 1); 1439884d179dSJan Kara out_unlock: 1440884d179dSJan Kara up_read(&sb_dqopt(inode->i_sb)->dqptr_sem); 1441884d179dSJan Kara out: 1442884d179dSJan Kara return ret; 1443884d179dSJan Kara } 1444884d179dSJan Kara EXPORT_SYMBOL(dquot_reserve_space); 1445884d179dSJan Kara 1446884d179dSJan Kara /* 1447884d179dSJan Kara * This operation can block, but only after everything is updated 1448884d179dSJan Kara */ 1449884d179dSJan Kara int dquot_alloc_inode(const struct inode *inode, qsize_t number) 1450884d179dSJan Kara { 1451884d179dSJan Kara int cnt, ret = NO_QUOTA; 1452884d179dSJan Kara char warntype[MAXQUOTAS]; 1453884d179dSJan Kara 1454884d179dSJan Kara /* First test before acquiring mutex - solves deadlocks when we 1455884d179dSJan Kara * re-enter the quota code and are already holding the mutex */ 1456884d179dSJan Kara if (IS_NOQUOTA(inode)) 1457884d179dSJan Kara return QUOTA_OK; 1458884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) 1459884d179dSJan Kara warntype[cnt] = QUOTA_NL_NOWARN; 1460884d179dSJan Kara down_read(&sb_dqopt(inode->i_sb)->dqptr_sem); 1461884d179dSJan Kara if (IS_NOQUOTA(inode)) { 1462884d179dSJan Kara up_read(&sb_dqopt(inode->i_sb)->dqptr_sem); 1463884d179dSJan Kara return QUOTA_OK; 1464884d179dSJan Kara } 1465884d179dSJan Kara spin_lock(&dq_data_lock); 1466884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1467dd6f3c6dSJan Kara if (!inode->i_dquot[cnt]) 1468884d179dSJan Kara continue; 1469884d179dSJan Kara if (check_idq(inode->i_dquot[cnt], number, warntype+cnt) == NO_QUOTA) 1470884d179dSJan Kara goto warn_put_all; 1471884d179dSJan Kara } 1472884d179dSJan Kara 1473884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1474dd6f3c6dSJan Kara if (!inode->i_dquot[cnt]) 1475884d179dSJan Kara continue; 1476884d179dSJan Kara dquot_incr_inodes(inode->i_dquot[cnt], number); 1477884d179dSJan Kara } 1478884d179dSJan Kara ret = QUOTA_OK; 1479884d179dSJan Kara warn_put_all: 1480884d179dSJan Kara spin_unlock(&dq_data_lock); 1481884d179dSJan Kara if (ret == QUOTA_OK) 1482884d179dSJan Kara /* Dirtify all the dquots - this can block when journalling */ 1483884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) 1484884d179dSJan Kara if (inode->i_dquot[cnt]) 1485884d179dSJan Kara mark_dquot_dirty(inode->i_dquot[cnt]); 1486884d179dSJan Kara flush_warnings(inode->i_dquot, warntype); 1487884d179dSJan Kara up_read(&sb_dqopt(inode->i_sb)->dqptr_sem); 1488884d179dSJan Kara return ret; 1489884d179dSJan Kara } 1490884d179dSJan Kara EXPORT_SYMBOL(dquot_alloc_inode); 1491884d179dSJan Kara 1492884d179dSJan Kara int dquot_claim_space(struct inode *inode, qsize_t number) 1493884d179dSJan Kara { 1494884d179dSJan Kara int cnt; 1495884d179dSJan Kara int ret = QUOTA_OK; 1496884d179dSJan Kara 1497884d179dSJan Kara if (IS_NOQUOTA(inode)) { 1498884d179dSJan Kara inode_add_bytes(inode, number); 1499884d179dSJan Kara goto out; 1500884d179dSJan Kara } 1501884d179dSJan Kara 1502884d179dSJan Kara down_read(&sb_dqopt(inode->i_sb)->dqptr_sem); 1503884d179dSJan Kara if (IS_NOQUOTA(inode)) { 1504884d179dSJan Kara up_read(&sb_dqopt(inode->i_sb)->dqptr_sem); 1505884d179dSJan Kara inode_add_bytes(inode, number); 1506884d179dSJan Kara goto out; 1507884d179dSJan Kara } 1508884d179dSJan Kara 1509884d179dSJan Kara spin_lock(&dq_data_lock); 1510884d179dSJan Kara /* Claim reserved quotas to allocated quotas */ 1511884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1512dd6f3c6dSJan Kara if (inode->i_dquot[cnt]) 1513884d179dSJan Kara dquot_claim_reserved_space(inode->i_dquot[cnt], 1514884d179dSJan Kara number); 1515884d179dSJan Kara } 1516884d179dSJan Kara /* Update inode bytes */ 1517884d179dSJan Kara inode_add_bytes(inode, number); 1518884d179dSJan Kara spin_unlock(&dq_data_lock); 1519884d179dSJan Kara /* Dirtify all the dquots - this can block when journalling */ 1520884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) 1521884d179dSJan Kara if (inode->i_dquot[cnt]) 1522884d179dSJan Kara mark_dquot_dirty(inode->i_dquot[cnt]); 1523884d179dSJan Kara up_read(&sb_dqopt(inode->i_sb)->dqptr_sem); 1524884d179dSJan Kara out: 1525884d179dSJan Kara return ret; 1526884d179dSJan Kara } 1527884d179dSJan Kara EXPORT_SYMBOL(dquot_claim_space); 1528884d179dSJan Kara 1529884d179dSJan Kara /* 1530884d179dSJan Kara * Release reserved quota space 1531884d179dSJan Kara */ 1532884d179dSJan Kara void dquot_release_reserved_space(struct inode *inode, qsize_t number) 1533884d179dSJan Kara { 1534884d179dSJan Kara int cnt; 1535884d179dSJan Kara 1536884d179dSJan Kara if (IS_NOQUOTA(inode)) 1537884d179dSJan Kara goto out; 1538884d179dSJan Kara 1539884d179dSJan Kara down_read(&sb_dqopt(inode->i_sb)->dqptr_sem); 1540884d179dSJan Kara if (IS_NOQUOTA(inode)) 1541884d179dSJan Kara goto out_unlock; 1542884d179dSJan Kara 1543884d179dSJan Kara spin_lock(&dq_data_lock); 1544884d179dSJan Kara /* Release reserved dquots */ 1545884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1546dd6f3c6dSJan Kara if (inode->i_dquot[cnt]) 1547884d179dSJan Kara dquot_free_reserved_space(inode->i_dquot[cnt], number); 1548884d179dSJan Kara } 1549884d179dSJan Kara spin_unlock(&dq_data_lock); 1550884d179dSJan Kara 1551884d179dSJan Kara out_unlock: 1552884d179dSJan Kara up_read(&sb_dqopt(inode->i_sb)->dqptr_sem); 1553884d179dSJan Kara out: 1554884d179dSJan Kara return; 1555884d179dSJan Kara } 1556884d179dSJan Kara EXPORT_SYMBOL(dquot_release_reserved_space); 1557884d179dSJan Kara 1558884d179dSJan Kara /* 1559884d179dSJan Kara * This operation can block, but only after everything is updated 1560884d179dSJan Kara */ 1561884d179dSJan Kara int dquot_free_space(struct inode *inode, qsize_t number) 1562884d179dSJan Kara { 1563884d179dSJan Kara unsigned int cnt; 1564884d179dSJan Kara char warntype[MAXQUOTAS]; 1565884d179dSJan Kara 1566884d179dSJan Kara /* First test before acquiring mutex - solves deadlocks when we 1567884d179dSJan Kara * re-enter the quota code and are already holding the mutex */ 1568884d179dSJan Kara if (IS_NOQUOTA(inode)) { 1569884d179dSJan Kara out_sub: 1570884d179dSJan Kara inode_sub_bytes(inode, number); 1571884d179dSJan Kara return QUOTA_OK; 1572884d179dSJan Kara } 1573884d179dSJan Kara 1574884d179dSJan Kara down_read(&sb_dqopt(inode->i_sb)->dqptr_sem); 1575884d179dSJan Kara /* Now recheck reliably when holding dqptr_sem */ 1576884d179dSJan Kara if (IS_NOQUOTA(inode)) { 1577884d179dSJan Kara up_read(&sb_dqopt(inode->i_sb)->dqptr_sem); 1578884d179dSJan Kara goto out_sub; 1579884d179dSJan Kara } 1580884d179dSJan Kara spin_lock(&dq_data_lock); 1581884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1582dd6f3c6dSJan Kara if (!inode->i_dquot[cnt]) 1583884d179dSJan Kara continue; 1584884d179dSJan Kara warntype[cnt] = info_bdq_free(inode->i_dquot[cnt], number); 1585884d179dSJan Kara dquot_decr_space(inode->i_dquot[cnt], number); 1586884d179dSJan Kara } 1587884d179dSJan Kara inode_sub_bytes(inode, number); 1588884d179dSJan Kara spin_unlock(&dq_data_lock); 1589884d179dSJan Kara /* Dirtify all the dquots - this can block when journalling */ 1590884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) 1591884d179dSJan Kara if (inode->i_dquot[cnt]) 1592884d179dSJan Kara mark_dquot_dirty(inode->i_dquot[cnt]); 1593884d179dSJan Kara flush_warnings(inode->i_dquot, warntype); 1594884d179dSJan Kara up_read(&sb_dqopt(inode->i_sb)->dqptr_sem); 1595884d179dSJan Kara return QUOTA_OK; 1596884d179dSJan Kara } 1597884d179dSJan Kara EXPORT_SYMBOL(dquot_free_space); 1598884d179dSJan Kara 1599884d179dSJan Kara /* 1600884d179dSJan Kara * This operation can block, but only after everything is updated 1601884d179dSJan Kara */ 1602884d179dSJan Kara int dquot_free_inode(const struct inode *inode, qsize_t number) 1603884d179dSJan Kara { 1604884d179dSJan Kara unsigned int cnt; 1605884d179dSJan Kara char warntype[MAXQUOTAS]; 1606884d179dSJan Kara 1607884d179dSJan Kara /* First test before acquiring mutex - solves deadlocks when we 1608884d179dSJan Kara * re-enter the quota code and are already holding the mutex */ 1609884d179dSJan Kara if (IS_NOQUOTA(inode)) 1610884d179dSJan Kara return QUOTA_OK; 1611884d179dSJan Kara 1612884d179dSJan Kara down_read(&sb_dqopt(inode->i_sb)->dqptr_sem); 1613884d179dSJan Kara /* Now recheck reliably when holding dqptr_sem */ 1614884d179dSJan Kara if (IS_NOQUOTA(inode)) { 1615884d179dSJan Kara up_read(&sb_dqopt(inode->i_sb)->dqptr_sem); 1616884d179dSJan Kara return QUOTA_OK; 1617884d179dSJan Kara } 1618884d179dSJan Kara spin_lock(&dq_data_lock); 1619884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1620dd6f3c6dSJan Kara if (!inode->i_dquot[cnt]) 1621884d179dSJan Kara continue; 1622884d179dSJan Kara warntype[cnt] = info_idq_free(inode->i_dquot[cnt], number); 1623884d179dSJan Kara dquot_decr_inodes(inode->i_dquot[cnt], number); 1624884d179dSJan Kara } 1625884d179dSJan Kara spin_unlock(&dq_data_lock); 1626884d179dSJan Kara /* Dirtify all the dquots - this can block when journalling */ 1627884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) 1628884d179dSJan Kara if (inode->i_dquot[cnt]) 1629884d179dSJan Kara mark_dquot_dirty(inode->i_dquot[cnt]); 1630884d179dSJan Kara flush_warnings(inode->i_dquot, warntype); 1631884d179dSJan Kara up_read(&sb_dqopt(inode->i_sb)->dqptr_sem); 1632884d179dSJan Kara return QUOTA_OK; 1633884d179dSJan Kara } 1634884d179dSJan Kara EXPORT_SYMBOL(dquot_free_inode); 1635884d179dSJan Kara 1636884d179dSJan Kara /* 1637884d179dSJan Kara * call back function, get reserved quota space from underlying fs 1638884d179dSJan Kara */ 1639884d179dSJan Kara qsize_t dquot_get_reserved_space(struct inode *inode) 1640884d179dSJan Kara { 1641884d179dSJan Kara qsize_t reserved_space = 0; 1642884d179dSJan Kara 1643884d179dSJan Kara if (sb_any_quota_active(inode->i_sb) && 1644884d179dSJan Kara inode->i_sb->dq_op->get_reserved_space) 1645884d179dSJan Kara reserved_space = inode->i_sb->dq_op->get_reserved_space(inode); 1646884d179dSJan Kara return reserved_space; 1647884d179dSJan Kara } 1648884d179dSJan Kara 1649884d179dSJan Kara /* 1650884d179dSJan Kara * Transfer the number of inode and blocks from one diskquota to an other. 1651884d179dSJan Kara * 1652884d179dSJan Kara * This operation can block, but only after everything is updated 1653884d179dSJan Kara * A transaction must be started when entering this function. 1654884d179dSJan Kara */ 1655884d179dSJan Kara int dquot_transfer(struct inode *inode, struct iattr *iattr) 1656884d179dSJan Kara { 1657884d179dSJan Kara qsize_t space, cur_space; 1658884d179dSJan Kara qsize_t rsv_space = 0; 1659884d179dSJan Kara struct dquot *transfer_from[MAXQUOTAS]; 1660884d179dSJan Kara struct dquot *transfer_to[MAXQUOTAS]; 1661884d179dSJan Kara int cnt, ret = QUOTA_OK; 1662884d179dSJan Kara int chuid = iattr->ia_valid & ATTR_UID && inode->i_uid != iattr->ia_uid, 1663884d179dSJan Kara chgid = iattr->ia_valid & ATTR_GID && inode->i_gid != iattr->ia_gid; 1664884d179dSJan Kara char warntype_to[MAXQUOTAS]; 1665884d179dSJan Kara char warntype_from_inodes[MAXQUOTAS], warntype_from_space[MAXQUOTAS]; 1666884d179dSJan Kara 1667884d179dSJan Kara /* First test before acquiring mutex - solves deadlocks when we 1668884d179dSJan Kara * re-enter the quota code and are already holding the mutex */ 1669884d179dSJan Kara if (IS_NOQUOTA(inode)) 1670884d179dSJan Kara return QUOTA_OK; 1671884d179dSJan Kara /* Initialize the arrays */ 1672884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1673dd6f3c6dSJan Kara transfer_from[cnt] = NULL; 1674dd6f3c6dSJan Kara transfer_to[cnt] = NULL; 1675884d179dSJan Kara warntype_to[cnt] = QUOTA_NL_NOWARN; 1676884d179dSJan Kara switch (cnt) { 1677884d179dSJan Kara case USRQUOTA: 1678884d179dSJan Kara if (!chuid) 1679884d179dSJan Kara continue; 1680884d179dSJan Kara transfer_to[cnt] = dqget(inode->i_sb, iattr->ia_uid, cnt); 1681884d179dSJan Kara break; 1682884d179dSJan Kara case GRPQUOTA: 1683884d179dSJan Kara if (!chgid) 1684884d179dSJan Kara continue; 1685884d179dSJan Kara transfer_to[cnt] = dqget(inode->i_sb, iattr->ia_gid, cnt); 1686884d179dSJan Kara break; 1687884d179dSJan Kara } 1688884d179dSJan Kara } 1689884d179dSJan Kara 1690884d179dSJan Kara down_write(&sb_dqopt(inode->i_sb)->dqptr_sem); 1691884d179dSJan Kara /* Now recheck reliably when holding dqptr_sem */ 1692884d179dSJan Kara if (IS_NOQUOTA(inode)) { /* File without quota accounting? */ 1693884d179dSJan Kara up_write(&sb_dqopt(inode->i_sb)->dqptr_sem); 1694884d179dSJan Kara goto put_all; 1695884d179dSJan Kara } 1696884d179dSJan Kara spin_lock(&dq_data_lock); 1697884d179dSJan Kara cur_space = inode_get_bytes(inode); 1698884d179dSJan Kara rsv_space = dquot_get_reserved_space(inode); 1699884d179dSJan Kara space = cur_space + rsv_space; 1700884d179dSJan Kara /* Build the transfer_from list and check the limits */ 1701884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1702dd6f3c6dSJan Kara if (!transfer_to[cnt]) 1703884d179dSJan Kara continue; 1704884d179dSJan Kara transfer_from[cnt] = inode->i_dquot[cnt]; 1705884d179dSJan Kara if (check_idq(transfer_to[cnt], 1, warntype_to + cnt) == 1706884d179dSJan Kara NO_QUOTA || check_bdq(transfer_to[cnt], space, 0, 1707884d179dSJan Kara warntype_to + cnt) == NO_QUOTA) 1708884d179dSJan Kara goto over_quota; 1709884d179dSJan Kara } 1710884d179dSJan Kara 1711884d179dSJan Kara /* 1712884d179dSJan Kara * Finally perform the needed transfer from transfer_from to transfer_to 1713884d179dSJan Kara */ 1714884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1715884d179dSJan Kara /* 1716884d179dSJan Kara * Skip changes for same uid or gid or for turned off quota-type. 1717884d179dSJan Kara */ 1718dd6f3c6dSJan Kara if (!transfer_to[cnt]) 1719884d179dSJan Kara continue; 1720884d179dSJan Kara 1721884d179dSJan Kara /* Due to IO error we might not have transfer_from[] structure */ 1722884d179dSJan Kara if (transfer_from[cnt]) { 1723884d179dSJan Kara warntype_from_inodes[cnt] = 1724884d179dSJan Kara info_idq_free(transfer_from[cnt], 1); 1725884d179dSJan Kara warntype_from_space[cnt] = 1726884d179dSJan Kara info_bdq_free(transfer_from[cnt], space); 1727884d179dSJan Kara dquot_decr_inodes(transfer_from[cnt], 1); 1728884d179dSJan Kara dquot_decr_space(transfer_from[cnt], cur_space); 1729884d179dSJan Kara dquot_free_reserved_space(transfer_from[cnt], 1730884d179dSJan Kara rsv_space); 1731884d179dSJan Kara } 1732884d179dSJan Kara 1733884d179dSJan Kara dquot_incr_inodes(transfer_to[cnt], 1); 1734884d179dSJan Kara dquot_incr_space(transfer_to[cnt], cur_space); 1735884d179dSJan Kara dquot_resv_space(transfer_to[cnt], rsv_space); 1736884d179dSJan Kara 1737884d179dSJan Kara inode->i_dquot[cnt] = transfer_to[cnt]; 1738884d179dSJan Kara } 1739884d179dSJan Kara spin_unlock(&dq_data_lock); 1740884d179dSJan Kara up_write(&sb_dqopt(inode->i_sb)->dqptr_sem); 1741884d179dSJan Kara 1742884d179dSJan Kara /* Dirtify all the dquots - this can block when journalling */ 1743884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1744884d179dSJan Kara if (transfer_from[cnt]) 1745884d179dSJan Kara mark_dquot_dirty(transfer_from[cnt]); 1746884d179dSJan Kara if (transfer_to[cnt]) { 1747884d179dSJan Kara mark_dquot_dirty(transfer_to[cnt]); 1748884d179dSJan Kara /* The reference we got is transferred to the inode */ 1749dd6f3c6dSJan Kara transfer_to[cnt] = NULL; 1750884d179dSJan Kara } 1751884d179dSJan Kara } 1752884d179dSJan Kara warn_put_all: 1753884d179dSJan Kara flush_warnings(transfer_to, warntype_to); 1754884d179dSJan Kara flush_warnings(transfer_from, warntype_from_inodes); 1755884d179dSJan Kara flush_warnings(transfer_from, warntype_from_space); 1756884d179dSJan Kara put_all: 1757884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1758884d179dSJan Kara dqput(transfer_from[cnt]); 1759884d179dSJan Kara dqput(transfer_to[cnt]); 1760884d179dSJan Kara } 1761884d179dSJan Kara return ret; 1762884d179dSJan Kara over_quota: 1763884d179dSJan Kara spin_unlock(&dq_data_lock); 1764884d179dSJan Kara up_write(&sb_dqopt(inode->i_sb)->dqptr_sem); 1765884d179dSJan Kara /* Clear dquot pointers we don't want to dqput() */ 1766884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) 1767dd6f3c6dSJan Kara transfer_from[cnt] = NULL; 1768884d179dSJan Kara ret = NO_QUOTA; 1769884d179dSJan Kara goto warn_put_all; 1770884d179dSJan Kara } 1771884d179dSJan Kara EXPORT_SYMBOL(dquot_transfer); 1772884d179dSJan Kara 1773884d179dSJan Kara /* Wrapper for transferring ownership of an inode */ 1774884d179dSJan Kara int vfs_dq_transfer(struct inode *inode, struct iattr *iattr) 1775884d179dSJan Kara { 1776884d179dSJan Kara if (sb_any_quota_active(inode->i_sb) && !IS_NOQUOTA(inode)) { 1777884d179dSJan Kara vfs_dq_init(inode); 1778884d179dSJan Kara if (inode->i_sb->dq_op->transfer(inode, iattr) == NO_QUOTA) 1779884d179dSJan Kara return 1; 1780884d179dSJan Kara } 1781884d179dSJan Kara return 0; 1782884d179dSJan Kara } 1783884d179dSJan Kara EXPORT_SYMBOL(vfs_dq_transfer); 1784884d179dSJan Kara 1785884d179dSJan Kara /* 1786884d179dSJan Kara * Write info of quota file to disk 1787884d179dSJan Kara */ 1788884d179dSJan Kara int dquot_commit_info(struct super_block *sb, int type) 1789884d179dSJan Kara { 1790884d179dSJan Kara int ret; 1791884d179dSJan Kara struct quota_info *dqopt = sb_dqopt(sb); 1792884d179dSJan Kara 1793884d179dSJan Kara mutex_lock(&dqopt->dqio_mutex); 1794884d179dSJan Kara ret = dqopt->ops[type]->write_file_info(sb, type); 1795884d179dSJan Kara mutex_unlock(&dqopt->dqio_mutex); 1796884d179dSJan Kara return ret; 1797884d179dSJan Kara } 1798884d179dSJan Kara EXPORT_SYMBOL(dquot_commit_info); 1799884d179dSJan Kara 1800884d179dSJan Kara /* 1801884d179dSJan Kara * Definitions of diskquota operations. 1802884d179dSJan Kara */ 1803884d179dSJan Kara struct dquot_operations dquot_operations = { 1804884d179dSJan Kara .initialize = dquot_initialize, 1805884d179dSJan Kara .drop = dquot_drop, 1806884d179dSJan Kara .alloc_space = dquot_alloc_space, 1807884d179dSJan Kara .alloc_inode = dquot_alloc_inode, 1808884d179dSJan Kara .free_space = dquot_free_space, 1809884d179dSJan Kara .free_inode = dquot_free_inode, 1810884d179dSJan Kara .transfer = dquot_transfer, 1811884d179dSJan Kara .write_dquot = dquot_commit, 1812884d179dSJan Kara .acquire_dquot = dquot_acquire, 1813884d179dSJan Kara .release_dquot = dquot_release, 1814884d179dSJan Kara .mark_dirty = dquot_mark_dquot_dirty, 1815884d179dSJan Kara .write_info = dquot_commit_info, 1816884d179dSJan Kara .alloc_dquot = dquot_alloc, 1817884d179dSJan Kara .destroy_dquot = dquot_destroy, 1818884d179dSJan Kara }; 1819884d179dSJan Kara 1820884d179dSJan Kara /* 1821884d179dSJan Kara * Turn quota off on a device. type == -1 ==> quotaoff for all types (umount) 1822884d179dSJan Kara */ 1823884d179dSJan Kara int vfs_quota_disable(struct super_block *sb, int type, unsigned int flags) 1824884d179dSJan Kara { 1825884d179dSJan Kara int cnt, ret = 0; 1826884d179dSJan Kara struct quota_info *dqopt = sb_dqopt(sb); 1827884d179dSJan Kara struct inode *toputinode[MAXQUOTAS]; 1828884d179dSJan Kara 1829884d179dSJan Kara /* Cannot turn off usage accounting without turning off limits, or 1830884d179dSJan Kara * suspend quotas and simultaneously turn quotas off. */ 1831884d179dSJan Kara if ((flags & DQUOT_USAGE_ENABLED && !(flags & DQUOT_LIMITS_ENABLED)) 1832884d179dSJan Kara || (flags & DQUOT_SUSPENDED && flags & (DQUOT_LIMITS_ENABLED | 1833884d179dSJan Kara DQUOT_USAGE_ENABLED))) 1834884d179dSJan Kara return -EINVAL; 1835884d179dSJan Kara 1836884d179dSJan Kara /* We need to serialize quota_off() for device */ 1837884d179dSJan Kara mutex_lock(&dqopt->dqonoff_mutex); 1838884d179dSJan Kara 1839884d179dSJan Kara /* 1840884d179dSJan Kara * Skip everything if there's nothing to do. We have to do this because 1841884d179dSJan Kara * sometimes we are called when fill_super() failed and calling 1842884d179dSJan Kara * sync_fs() in such cases does no good. 1843884d179dSJan Kara */ 1844884d179dSJan Kara if (!sb_any_quota_loaded(sb)) { 1845884d179dSJan Kara mutex_unlock(&dqopt->dqonoff_mutex); 1846884d179dSJan Kara return 0; 1847884d179dSJan Kara } 1848884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1849884d179dSJan Kara toputinode[cnt] = NULL; 1850884d179dSJan Kara if (type != -1 && cnt != type) 1851884d179dSJan Kara continue; 1852884d179dSJan Kara if (!sb_has_quota_loaded(sb, cnt)) 1853884d179dSJan Kara continue; 1854884d179dSJan Kara 1855884d179dSJan Kara if (flags & DQUOT_SUSPENDED) { 1856884d179dSJan Kara spin_lock(&dq_state_lock); 1857884d179dSJan Kara dqopt->flags |= 1858884d179dSJan Kara dquot_state_flag(DQUOT_SUSPENDED, cnt); 1859884d179dSJan Kara spin_unlock(&dq_state_lock); 1860884d179dSJan Kara } else { 1861884d179dSJan Kara spin_lock(&dq_state_lock); 1862884d179dSJan Kara dqopt->flags &= ~dquot_state_flag(flags, cnt); 1863884d179dSJan Kara /* Turning off suspended quotas? */ 1864884d179dSJan Kara if (!sb_has_quota_loaded(sb, cnt) && 1865884d179dSJan Kara sb_has_quota_suspended(sb, cnt)) { 1866884d179dSJan Kara dqopt->flags &= ~dquot_state_flag( 1867884d179dSJan Kara DQUOT_SUSPENDED, cnt); 1868884d179dSJan Kara spin_unlock(&dq_state_lock); 1869884d179dSJan Kara iput(dqopt->files[cnt]); 1870884d179dSJan Kara dqopt->files[cnt] = NULL; 1871884d179dSJan Kara continue; 1872884d179dSJan Kara } 1873884d179dSJan Kara spin_unlock(&dq_state_lock); 1874884d179dSJan Kara } 1875884d179dSJan Kara 1876884d179dSJan Kara /* We still have to keep quota loaded? */ 1877884d179dSJan Kara if (sb_has_quota_loaded(sb, cnt) && !(flags & DQUOT_SUSPENDED)) 1878884d179dSJan Kara continue; 1879884d179dSJan Kara 1880884d179dSJan Kara /* Note: these are blocking operations */ 1881884d179dSJan Kara drop_dquot_ref(sb, cnt); 1882884d179dSJan Kara invalidate_dquots(sb, cnt); 1883884d179dSJan Kara /* 1884884d179dSJan Kara * Now all dquots should be invalidated, all writes done so we should be only 1885884d179dSJan Kara * users of the info. No locks needed. 1886884d179dSJan Kara */ 1887884d179dSJan Kara if (info_dirty(&dqopt->info[cnt])) 1888884d179dSJan Kara sb->dq_op->write_info(sb, cnt); 1889884d179dSJan Kara if (dqopt->ops[cnt]->free_file_info) 1890884d179dSJan Kara dqopt->ops[cnt]->free_file_info(sb, cnt); 1891884d179dSJan Kara put_quota_format(dqopt->info[cnt].dqi_format); 1892884d179dSJan Kara 1893884d179dSJan Kara toputinode[cnt] = dqopt->files[cnt]; 1894884d179dSJan Kara if (!sb_has_quota_loaded(sb, cnt)) 1895884d179dSJan Kara dqopt->files[cnt] = NULL; 1896884d179dSJan Kara dqopt->info[cnt].dqi_flags = 0; 1897884d179dSJan Kara dqopt->info[cnt].dqi_igrace = 0; 1898884d179dSJan Kara dqopt->info[cnt].dqi_bgrace = 0; 1899884d179dSJan Kara dqopt->ops[cnt] = NULL; 1900884d179dSJan Kara } 1901884d179dSJan Kara mutex_unlock(&dqopt->dqonoff_mutex); 1902884d179dSJan Kara 1903884d179dSJan Kara /* Skip syncing and setting flags if quota files are hidden */ 1904884d179dSJan Kara if (dqopt->flags & DQUOT_QUOTA_SYS_FILE) 1905884d179dSJan Kara goto put_inodes; 1906884d179dSJan Kara 1907884d179dSJan Kara /* Sync the superblock so that buffers with quota data are written to 1908884d179dSJan Kara * disk (and so userspace sees correct data afterwards). */ 1909884d179dSJan Kara if (sb->s_op->sync_fs) 1910884d179dSJan Kara sb->s_op->sync_fs(sb, 1); 1911884d179dSJan Kara sync_blockdev(sb->s_bdev); 1912884d179dSJan Kara /* Now the quota files are just ordinary files and we can set the 1913884d179dSJan Kara * inode flags back. Moreover we discard the pagecache so that 1914884d179dSJan Kara * userspace sees the writes we did bypassing the pagecache. We 1915884d179dSJan Kara * must also discard the blockdev buffers so that we see the 1916884d179dSJan Kara * changes done by userspace on the next quotaon() */ 1917884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) 1918884d179dSJan Kara if (toputinode[cnt]) { 1919884d179dSJan Kara mutex_lock(&dqopt->dqonoff_mutex); 1920884d179dSJan Kara /* If quota was reenabled in the meantime, we have 1921884d179dSJan Kara * nothing to do */ 1922884d179dSJan Kara if (!sb_has_quota_loaded(sb, cnt)) { 1923884d179dSJan Kara mutex_lock_nested(&toputinode[cnt]->i_mutex, I_MUTEX_QUOTA); 1924884d179dSJan Kara toputinode[cnt]->i_flags &= ~(S_IMMUTABLE | 1925884d179dSJan Kara S_NOATIME | S_NOQUOTA); 1926884d179dSJan Kara truncate_inode_pages(&toputinode[cnt]->i_data, 0); 1927884d179dSJan Kara mutex_unlock(&toputinode[cnt]->i_mutex); 1928884d179dSJan Kara mark_inode_dirty(toputinode[cnt]); 1929884d179dSJan Kara } 1930884d179dSJan Kara mutex_unlock(&dqopt->dqonoff_mutex); 1931884d179dSJan Kara } 1932884d179dSJan Kara if (sb->s_bdev) 1933884d179dSJan Kara invalidate_bdev(sb->s_bdev); 1934884d179dSJan Kara put_inodes: 1935884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) 1936884d179dSJan Kara if (toputinode[cnt]) { 1937884d179dSJan Kara /* On remount RO, we keep the inode pointer so that we 1938884d179dSJan Kara * can reenable quota on the subsequent remount RW. We 1939884d179dSJan Kara * have to check 'flags' variable and not use sb_has_ 1940884d179dSJan Kara * function because another quotaon / quotaoff could 1941884d179dSJan Kara * change global state before we got here. We refuse 1942884d179dSJan Kara * to suspend quotas when there is pending delete on 1943884d179dSJan Kara * the quota file... */ 1944884d179dSJan Kara if (!(flags & DQUOT_SUSPENDED)) 1945884d179dSJan Kara iput(toputinode[cnt]); 1946884d179dSJan Kara else if (!toputinode[cnt]->i_nlink) 1947884d179dSJan Kara ret = -EBUSY; 1948884d179dSJan Kara } 1949884d179dSJan Kara return ret; 1950884d179dSJan Kara } 1951884d179dSJan Kara EXPORT_SYMBOL(vfs_quota_disable); 1952884d179dSJan Kara 1953884d179dSJan Kara int vfs_quota_off(struct super_block *sb, int type, int remount) 1954884d179dSJan Kara { 1955884d179dSJan Kara return vfs_quota_disable(sb, type, remount ? DQUOT_SUSPENDED : 1956884d179dSJan Kara (DQUOT_USAGE_ENABLED | DQUOT_LIMITS_ENABLED)); 1957884d179dSJan Kara } 1958884d179dSJan Kara EXPORT_SYMBOL(vfs_quota_off); 1959884d179dSJan Kara /* 1960884d179dSJan Kara * Turn quotas on on a device 1961884d179dSJan Kara */ 1962884d179dSJan Kara 1963884d179dSJan Kara /* 1964884d179dSJan Kara * Helper function to turn quotas on when we already have the inode of 1965884d179dSJan Kara * quota file and no quota information is loaded. 1966884d179dSJan Kara */ 1967884d179dSJan Kara static int vfs_load_quota_inode(struct inode *inode, int type, int format_id, 1968884d179dSJan Kara unsigned int flags) 1969884d179dSJan Kara { 1970884d179dSJan Kara struct quota_format_type *fmt = find_quota_format(format_id); 1971884d179dSJan Kara struct super_block *sb = inode->i_sb; 1972884d179dSJan Kara struct quota_info *dqopt = sb_dqopt(sb); 1973884d179dSJan Kara int error; 1974884d179dSJan Kara int oldflags = -1; 1975884d179dSJan Kara 1976884d179dSJan Kara if (!fmt) 1977884d179dSJan Kara return -ESRCH; 1978884d179dSJan Kara if (!S_ISREG(inode->i_mode)) { 1979884d179dSJan Kara error = -EACCES; 1980884d179dSJan Kara goto out_fmt; 1981884d179dSJan Kara } 1982884d179dSJan Kara if (IS_RDONLY(inode)) { 1983884d179dSJan Kara error = -EROFS; 1984884d179dSJan Kara goto out_fmt; 1985884d179dSJan Kara } 1986884d179dSJan Kara if (!sb->s_op->quota_write || !sb->s_op->quota_read) { 1987884d179dSJan Kara error = -EINVAL; 1988884d179dSJan Kara goto out_fmt; 1989884d179dSJan Kara } 1990884d179dSJan Kara /* Usage always has to be set... */ 1991884d179dSJan Kara if (!(flags & DQUOT_USAGE_ENABLED)) { 1992884d179dSJan Kara error = -EINVAL; 1993884d179dSJan Kara goto out_fmt; 1994884d179dSJan Kara } 1995884d179dSJan Kara 1996884d179dSJan Kara if (!(dqopt->flags & DQUOT_QUOTA_SYS_FILE)) { 1997884d179dSJan Kara /* As we bypass the pagecache we must now flush the inode so 1998884d179dSJan Kara * that we see all the changes from userspace... */ 1999884d179dSJan Kara write_inode_now(inode, 1); 2000884d179dSJan Kara /* And now flush the block cache so that kernel sees the 2001884d179dSJan Kara * changes */ 2002884d179dSJan Kara invalidate_bdev(sb->s_bdev); 2003884d179dSJan Kara } 2004884d179dSJan Kara mutex_lock(&inode->i_mutex); 2005884d179dSJan Kara mutex_lock(&dqopt->dqonoff_mutex); 2006884d179dSJan Kara if (sb_has_quota_loaded(sb, type)) { 2007884d179dSJan Kara error = -EBUSY; 2008884d179dSJan Kara goto out_lock; 2009884d179dSJan Kara } 2010884d179dSJan Kara 2011884d179dSJan Kara if (!(dqopt->flags & DQUOT_QUOTA_SYS_FILE)) { 2012884d179dSJan Kara /* We don't want quota and atime on quota files (deadlocks 2013884d179dSJan Kara * possible) Also nobody should write to the file - we use 2014884d179dSJan Kara * special IO operations which ignore the immutable bit. */ 2015884d179dSJan Kara down_write(&dqopt->dqptr_sem); 2016884d179dSJan Kara oldflags = inode->i_flags & (S_NOATIME | S_IMMUTABLE | S_NOQUOTA); 2017884d179dSJan Kara inode->i_flags |= S_NOQUOTA | S_NOATIME | S_IMMUTABLE; 2018884d179dSJan Kara up_write(&dqopt->dqptr_sem); 2019884d179dSJan Kara sb->dq_op->drop(inode); 2020884d179dSJan Kara } 2021884d179dSJan Kara 2022884d179dSJan Kara error = -EIO; 2023884d179dSJan Kara dqopt->files[type] = igrab(inode); 2024884d179dSJan Kara if (!dqopt->files[type]) 2025884d179dSJan Kara goto out_lock; 2026884d179dSJan Kara error = -EINVAL; 2027884d179dSJan Kara if (!fmt->qf_ops->check_quota_file(sb, type)) 2028884d179dSJan Kara goto out_file_init; 2029884d179dSJan Kara 2030884d179dSJan Kara dqopt->ops[type] = fmt->qf_ops; 2031884d179dSJan Kara dqopt->info[type].dqi_format = fmt; 2032884d179dSJan Kara dqopt->info[type].dqi_fmt_id = format_id; 2033884d179dSJan Kara INIT_LIST_HEAD(&dqopt->info[type].dqi_dirty_list); 2034884d179dSJan Kara mutex_lock(&dqopt->dqio_mutex); 2035884d179dSJan Kara if ((error = dqopt->ops[type]->read_file_info(sb, type)) < 0) { 2036884d179dSJan Kara mutex_unlock(&dqopt->dqio_mutex); 2037884d179dSJan Kara goto out_file_init; 2038884d179dSJan Kara } 2039884d179dSJan Kara mutex_unlock(&dqopt->dqio_mutex); 2040884d179dSJan Kara mutex_unlock(&inode->i_mutex); 2041884d179dSJan Kara spin_lock(&dq_state_lock); 2042884d179dSJan Kara dqopt->flags |= dquot_state_flag(flags, type); 2043884d179dSJan Kara spin_unlock(&dq_state_lock); 2044884d179dSJan Kara 2045884d179dSJan Kara add_dquot_ref(sb, type); 2046884d179dSJan Kara mutex_unlock(&dqopt->dqonoff_mutex); 2047884d179dSJan Kara 2048884d179dSJan Kara return 0; 2049884d179dSJan Kara 2050884d179dSJan Kara out_file_init: 2051884d179dSJan Kara dqopt->files[type] = NULL; 2052884d179dSJan Kara iput(inode); 2053884d179dSJan Kara out_lock: 2054884d179dSJan Kara mutex_unlock(&dqopt->dqonoff_mutex); 2055884d179dSJan Kara if (oldflags != -1) { 2056884d179dSJan Kara down_write(&dqopt->dqptr_sem); 2057884d179dSJan Kara /* Set the flags back (in the case of accidental quotaon() 2058884d179dSJan Kara * on a wrong file we don't want to mess up the flags) */ 2059884d179dSJan Kara inode->i_flags &= ~(S_NOATIME | S_NOQUOTA | S_IMMUTABLE); 2060884d179dSJan Kara inode->i_flags |= oldflags; 2061884d179dSJan Kara up_write(&dqopt->dqptr_sem); 2062884d179dSJan Kara } 2063884d179dSJan Kara mutex_unlock(&inode->i_mutex); 2064884d179dSJan Kara out_fmt: 2065884d179dSJan Kara put_quota_format(fmt); 2066884d179dSJan Kara 2067884d179dSJan Kara return error; 2068884d179dSJan Kara } 2069884d179dSJan Kara 2070884d179dSJan Kara /* Reenable quotas on remount RW */ 2071884d179dSJan Kara static int vfs_quota_on_remount(struct super_block *sb, int type) 2072884d179dSJan Kara { 2073884d179dSJan Kara struct quota_info *dqopt = sb_dqopt(sb); 2074884d179dSJan Kara struct inode *inode; 2075884d179dSJan Kara int ret; 2076884d179dSJan Kara unsigned int flags; 2077884d179dSJan Kara 2078884d179dSJan Kara mutex_lock(&dqopt->dqonoff_mutex); 2079884d179dSJan Kara if (!sb_has_quota_suspended(sb, type)) { 2080884d179dSJan Kara mutex_unlock(&dqopt->dqonoff_mutex); 2081884d179dSJan Kara return 0; 2082884d179dSJan Kara } 2083884d179dSJan Kara inode = dqopt->files[type]; 2084884d179dSJan Kara dqopt->files[type] = NULL; 2085884d179dSJan Kara spin_lock(&dq_state_lock); 2086884d179dSJan Kara flags = dqopt->flags & dquot_state_flag(DQUOT_USAGE_ENABLED | 2087884d179dSJan Kara DQUOT_LIMITS_ENABLED, type); 2088884d179dSJan Kara dqopt->flags &= ~dquot_state_flag(DQUOT_STATE_FLAGS, type); 2089884d179dSJan Kara spin_unlock(&dq_state_lock); 2090884d179dSJan Kara mutex_unlock(&dqopt->dqonoff_mutex); 2091884d179dSJan Kara 2092884d179dSJan Kara flags = dquot_generic_flag(flags, type); 2093884d179dSJan Kara ret = vfs_load_quota_inode(inode, type, dqopt->info[type].dqi_fmt_id, 2094884d179dSJan Kara flags); 2095884d179dSJan Kara iput(inode); 2096884d179dSJan Kara 2097884d179dSJan Kara return ret; 2098884d179dSJan Kara } 2099884d179dSJan Kara 2100884d179dSJan Kara int vfs_quota_on_path(struct super_block *sb, int type, int format_id, 2101884d179dSJan Kara struct path *path) 2102884d179dSJan Kara { 2103884d179dSJan Kara int error = security_quota_on(path->dentry); 2104884d179dSJan Kara if (error) 2105884d179dSJan Kara return error; 2106884d179dSJan Kara /* Quota file not on the same filesystem? */ 2107884d179dSJan Kara if (path->mnt->mnt_sb != sb) 2108884d179dSJan Kara error = -EXDEV; 2109884d179dSJan Kara else 2110884d179dSJan Kara error = vfs_load_quota_inode(path->dentry->d_inode, type, 2111884d179dSJan Kara format_id, DQUOT_USAGE_ENABLED | 2112884d179dSJan Kara DQUOT_LIMITS_ENABLED); 2113884d179dSJan Kara return error; 2114884d179dSJan Kara } 2115884d179dSJan Kara EXPORT_SYMBOL(vfs_quota_on_path); 2116884d179dSJan Kara 2117884d179dSJan Kara int vfs_quota_on(struct super_block *sb, int type, int format_id, char *name, 2118884d179dSJan Kara int remount) 2119884d179dSJan Kara { 2120884d179dSJan Kara struct path path; 2121884d179dSJan Kara int error; 2122884d179dSJan Kara 2123884d179dSJan Kara if (remount) 2124884d179dSJan Kara return vfs_quota_on_remount(sb, type); 2125884d179dSJan Kara 2126884d179dSJan Kara error = kern_path(name, LOOKUP_FOLLOW, &path); 2127884d179dSJan Kara if (!error) { 2128884d179dSJan Kara error = vfs_quota_on_path(sb, type, format_id, &path); 2129884d179dSJan Kara path_put(&path); 2130884d179dSJan Kara } 2131884d179dSJan Kara return error; 2132884d179dSJan Kara } 2133884d179dSJan Kara EXPORT_SYMBOL(vfs_quota_on); 2134884d179dSJan Kara 2135884d179dSJan Kara /* 2136884d179dSJan Kara * More powerful function for turning on quotas allowing setting 2137884d179dSJan Kara * of individual quota flags 2138884d179dSJan Kara */ 2139884d179dSJan Kara int vfs_quota_enable(struct inode *inode, int type, int format_id, 2140884d179dSJan Kara unsigned int flags) 2141884d179dSJan Kara { 2142884d179dSJan Kara int ret = 0; 2143884d179dSJan Kara struct super_block *sb = inode->i_sb; 2144884d179dSJan Kara struct quota_info *dqopt = sb_dqopt(sb); 2145884d179dSJan Kara 2146884d179dSJan Kara /* Just unsuspend quotas? */ 2147884d179dSJan Kara if (flags & DQUOT_SUSPENDED) 2148884d179dSJan Kara return vfs_quota_on_remount(sb, type); 2149884d179dSJan Kara if (!flags) 2150884d179dSJan Kara return 0; 2151884d179dSJan Kara /* Just updating flags needed? */ 2152884d179dSJan Kara if (sb_has_quota_loaded(sb, type)) { 2153884d179dSJan Kara mutex_lock(&dqopt->dqonoff_mutex); 2154884d179dSJan Kara /* Now do a reliable test... */ 2155884d179dSJan Kara if (!sb_has_quota_loaded(sb, type)) { 2156884d179dSJan Kara mutex_unlock(&dqopt->dqonoff_mutex); 2157884d179dSJan Kara goto load_quota; 2158884d179dSJan Kara } 2159884d179dSJan Kara if (flags & DQUOT_USAGE_ENABLED && 2160884d179dSJan Kara sb_has_quota_usage_enabled(sb, type)) { 2161884d179dSJan Kara ret = -EBUSY; 2162884d179dSJan Kara goto out_lock; 2163884d179dSJan Kara } 2164884d179dSJan Kara if (flags & DQUOT_LIMITS_ENABLED && 2165884d179dSJan Kara sb_has_quota_limits_enabled(sb, type)) { 2166884d179dSJan Kara ret = -EBUSY; 2167884d179dSJan Kara goto out_lock; 2168884d179dSJan Kara } 2169884d179dSJan Kara spin_lock(&dq_state_lock); 2170884d179dSJan Kara sb_dqopt(sb)->flags |= dquot_state_flag(flags, type); 2171884d179dSJan Kara spin_unlock(&dq_state_lock); 2172884d179dSJan Kara out_lock: 2173884d179dSJan Kara mutex_unlock(&dqopt->dqonoff_mutex); 2174884d179dSJan Kara return ret; 2175884d179dSJan Kara } 2176884d179dSJan Kara 2177884d179dSJan Kara load_quota: 2178884d179dSJan Kara return vfs_load_quota_inode(inode, type, format_id, flags); 2179884d179dSJan Kara } 2180884d179dSJan Kara EXPORT_SYMBOL(vfs_quota_enable); 2181884d179dSJan Kara 2182884d179dSJan Kara /* 2183884d179dSJan Kara * This function is used when filesystem needs to initialize quotas 2184884d179dSJan Kara * during mount time. 2185884d179dSJan Kara */ 2186884d179dSJan Kara int vfs_quota_on_mount(struct super_block *sb, char *qf_name, 2187884d179dSJan Kara int format_id, int type) 2188884d179dSJan Kara { 2189884d179dSJan Kara struct dentry *dentry; 2190884d179dSJan Kara int error; 2191884d179dSJan Kara 2192884d179dSJan Kara dentry = lookup_one_len(qf_name, sb->s_root, strlen(qf_name)); 2193884d179dSJan Kara if (IS_ERR(dentry)) 2194884d179dSJan Kara return PTR_ERR(dentry); 2195884d179dSJan Kara 2196884d179dSJan Kara if (!dentry->d_inode) { 2197884d179dSJan Kara error = -ENOENT; 2198884d179dSJan Kara goto out; 2199884d179dSJan Kara } 2200884d179dSJan Kara 2201884d179dSJan Kara error = security_quota_on(dentry); 2202884d179dSJan Kara if (!error) 2203884d179dSJan Kara error = vfs_load_quota_inode(dentry->d_inode, type, format_id, 2204884d179dSJan Kara DQUOT_USAGE_ENABLED | DQUOT_LIMITS_ENABLED); 2205884d179dSJan Kara 2206884d179dSJan Kara out: 2207884d179dSJan Kara dput(dentry); 2208884d179dSJan Kara return error; 2209884d179dSJan Kara } 2210884d179dSJan Kara EXPORT_SYMBOL(vfs_quota_on_mount); 2211884d179dSJan Kara 2212884d179dSJan Kara /* Wrapper to turn on quotas when remounting rw */ 2213884d179dSJan Kara int vfs_dq_quota_on_remount(struct super_block *sb) 2214884d179dSJan Kara { 2215884d179dSJan Kara int cnt; 2216884d179dSJan Kara int ret = 0, err; 2217884d179dSJan Kara 2218884d179dSJan Kara if (!sb->s_qcop || !sb->s_qcop->quota_on) 2219884d179dSJan Kara return -ENOSYS; 2220884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 2221884d179dSJan Kara err = sb->s_qcop->quota_on(sb, cnt, 0, NULL, 1); 2222884d179dSJan Kara if (err < 0 && !ret) 2223884d179dSJan Kara ret = err; 2224884d179dSJan Kara } 2225884d179dSJan Kara return ret; 2226884d179dSJan Kara } 2227884d179dSJan Kara EXPORT_SYMBOL(vfs_dq_quota_on_remount); 2228884d179dSJan Kara 2229884d179dSJan Kara static inline qsize_t qbtos(qsize_t blocks) 2230884d179dSJan Kara { 2231884d179dSJan Kara return blocks << QIF_DQBLKSIZE_BITS; 2232884d179dSJan Kara } 2233884d179dSJan Kara 2234884d179dSJan Kara static inline qsize_t stoqb(qsize_t space) 2235884d179dSJan Kara { 2236884d179dSJan Kara return (space + QIF_DQBLKSIZE - 1) >> QIF_DQBLKSIZE_BITS; 2237884d179dSJan Kara } 2238884d179dSJan Kara 2239884d179dSJan Kara /* Generic routine for getting common part of quota structure */ 2240884d179dSJan Kara static void do_get_dqblk(struct dquot *dquot, struct if_dqblk *di) 2241884d179dSJan Kara { 2242884d179dSJan Kara struct mem_dqblk *dm = &dquot->dq_dqb; 2243884d179dSJan Kara 2244884d179dSJan Kara spin_lock(&dq_data_lock); 2245884d179dSJan Kara di->dqb_bhardlimit = stoqb(dm->dqb_bhardlimit); 2246884d179dSJan Kara di->dqb_bsoftlimit = stoqb(dm->dqb_bsoftlimit); 2247884d179dSJan Kara di->dqb_curspace = dm->dqb_curspace + dm->dqb_rsvspace; 2248884d179dSJan Kara di->dqb_ihardlimit = dm->dqb_ihardlimit; 2249884d179dSJan Kara di->dqb_isoftlimit = dm->dqb_isoftlimit; 2250884d179dSJan Kara di->dqb_curinodes = dm->dqb_curinodes; 2251884d179dSJan Kara di->dqb_btime = dm->dqb_btime; 2252884d179dSJan Kara di->dqb_itime = dm->dqb_itime; 2253884d179dSJan Kara di->dqb_valid = QIF_ALL; 2254884d179dSJan Kara spin_unlock(&dq_data_lock); 2255884d179dSJan Kara } 2256884d179dSJan Kara 2257884d179dSJan Kara int vfs_get_dqblk(struct super_block *sb, int type, qid_t id, struct if_dqblk *di) 2258884d179dSJan Kara { 2259884d179dSJan Kara struct dquot *dquot; 2260884d179dSJan Kara 2261884d179dSJan Kara dquot = dqget(sb, id, type); 2262dd6f3c6dSJan Kara if (!dquot) 2263884d179dSJan Kara return -ESRCH; 2264884d179dSJan Kara do_get_dqblk(dquot, di); 2265884d179dSJan Kara dqput(dquot); 2266884d179dSJan Kara 2267884d179dSJan Kara return 0; 2268884d179dSJan Kara } 2269884d179dSJan Kara EXPORT_SYMBOL(vfs_get_dqblk); 2270884d179dSJan Kara 2271884d179dSJan Kara /* Generic routine for setting common part of quota structure */ 2272884d179dSJan Kara static int do_set_dqblk(struct dquot *dquot, struct if_dqblk *di) 2273884d179dSJan Kara { 2274884d179dSJan Kara struct mem_dqblk *dm = &dquot->dq_dqb; 2275884d179dSJan Kara int check_blim = 0, check_ilim = 0; 2276884d179dSJan Kara struct mem_dqinfo *dqi = &sb_dqopt(dquot->dq_sb)->info[dquot->dq_type]; 2277884d179dSJan Kara 2278884d179dSJan Kara if ((di->dqb_valid & QIF_BLIMITS && 2279884d179dSJan Kara (di->dqb_bhardlimit > dqi->dqi_maxblimit || 2280884d179dSJan Kara di->dqb_bsoftlimit > dqi->dqi_maxblimit)) || 2281884d179dSJan Kara (di->dqb_valid & QIF_ILIMITS && 2282884d179dSJan Kara (di->dqb_ihardlimit > dqi->dqi_maxilimit || 2283884d179dSJan Kara di->dqb_isoftlimit > dqi->dqi_maxilimit))) 2284884d179dSJan Kara return -ERANGE; 2285884d179dSJan Kara 2286884d179dSJan Kara spin_lock(&dq_data_lock); 2287884d179dSJan Kara if (di->dqb_valid & QIF_SPACE) { 2288884d179dSJan Kara dm->dqb_curspace = di->dqb_curspace - dm->dqb_rsvspace; 2289884d179dSJan Kara check_blim = 1; 2290884d179dSJan Kara __set_bit(DQ_LASTSET_B + QIF_SPACE_B, &dquot->dq_flags); 2291884d179dSJan Kara } 2292884d179dSJan Kara if (di->dqb_valid & QIF_BLIMITS) { 2293884d179dSJan Kara dm->dqb_bsoftlimit = qbtos(di->dqb_bsoftlimit); 2294884d179dSJan Kara dm->dqb_bhardlimit = qbtos(di->dqb_bhardlimit); 2295884d179dSJan Kara check_blim = 1; 2296884d179dSJan Kara __set_bit(DQ_LASTSET_B + QIF_BLIMITS_B, &dquot->dq_flags); 2297884d179dSJan Kara } 2298884d179dSJan Kara if (di->dqb_valid & QIF_INODES) { 2299884d179dSJan Kara dm->dqb_curinodes = di->dqb_curinodes; 2300884d179dSJan Kara check_ilim = 1; 2301884d179dSJan Kara __set_bit(DQ_LASTSET_B + QIF_INODES_B, &dquot->dq_flags); 2302884d179dSJan Kara } 2303884d179dSJan Kara if (di->dqb_valid & QIF_ILIMITS) { 2304884d179dSJan Kara dm->dqb_isoftlimit = di->dqb_isoftlimit; 2305884d179dSJan Kara dm->dqb_ihardlimit = di->dqb_ihardlimit; 2306884d179dSJan Kara check_ilim = 1; 2307884d179dSJan Kara __set_bit(DQ_LASTSET_B + QIF_ILIMITS_B, &dquot->dq_flags); 2308884d179dSJan Kara } 2309884d179dSJan Kara if (di->dqb_valid & QIF_BTIME) { 2310884d179dSJan Kara dm->dqb_btime = di->dqb_btime; 2311884d179dSJan Kara check_blim = 1; 2312884d179dSJan Kara __set_bit(DQ_LASTSET_B + QIF_BTIME_B, &dquot->dq_flags); 2313884d179dSJan Kara } 2314884d179dSJan Kara if (di->dqb_valid & QIF_ITIME) { 2315884d179dSJan Kara dm->dqb_itime = di->dqb_itime; 2316884d179dSJan Kara check_ilim = 1; 2317884d179dSJan Kara __set_bit(DQ_LASTSET_B + QIF_ITIME_B, &dquot->dq_flags); 2318884d179dSJan Kara } 2319884d179dSJan Kara 2320884d179dSJan Kara if (check_blim) { 2321884d179dSJan Kara if (!dm->dqb_bsoftlimit || dm->dqb_curspace < dm->dqb_bsoftlimit) { 2322884d179dSJan Kara dm->dqb_btime = 0; 2323884d179dSJan Kara clear_bit(DQ_BLKS_B, &dquot->dq_flags); 2324884d179dSJan Kara } 2325884d179dSJan Kara else if (!(di->dqb_valid & QIF_BTIME)) /* Set grace only if user hasn't provided his own... */ 2326884d179dSJan Kara dm->dqb_btime = get_seconds() + dqi->dqi_bgrace; 2327884d179dSJan Kara } 2328884d179dSJan Kara if (check_ilim) { 2329884d179dSJan Kara if (!dm->dqb_isoftlimit || dm->dqb_curinodes < dm->dqb_isoftlimit) { 2330884d179dSJan Kara dm->dqb_itime = 0; 2331884d179dSJan Kara clear_bit(DQ_INODES_B, &dquot->dq_flags); 2332884d179dSJan Kara } 2333884d179dSJan Kara else if (!(di->dqb_valid & QIF_ITIME)) /* Set grace only if user hasn't provided his own... */ 2334884d179dSJan Kara dm->dqb_itime = get_seconds() + dqi->dqi_igrace; 2335884d179dSJan Kara } 2336884d179dSJan Kara if (dm->dqb_bhardlimit || dm->dqb_bsoftlimit || dm->dqb_ihardlimit || dm->dqb_isoftlimit) 2337884d179dSJan Kara clear_bit(DQ_FAKE_B, &dquot->dq_flags); 2338884d179dSJan Kara else 2339884d179dSJan Kara set_bit(DQ_FAKE_B, &dquot->dq_flags); 2340884d179dSJan Kara spin_unlock(&dq_data_lock); 2341884d179dSJan Kara mark_dquot_dirty(dquot); 2342884d179dSJan Kara 2343884d179dSJan Kara return 0; 2344884d179dSJan Kara } 2345884d179dSJan Kara 2346884d179dSJan Kara int vfs_set_dqblk(struct super_block *sb, int type, qid_t id, struct if_dqblk *di) 2347884d179dSJan Kara { 2348884d179dSJan Kara struct dquot *dquot; 2349884d179dSJan Kara int rc; 2350884d179dSJan Kara 2351884d179dSJan Kara dquot = dqget(sb, id, type); 2352884d179dSJan Kara if (!dquot) { 2353884d179dSJan Kara rc = -ESRCH; 2354884d179dSJan Kara goto out; 2355884d179dSJan Kara } 2356884d179dSJan Kara rc = do_set_dqblk(dquot, di); 2357884d179dSJan Kara dqput(dquot); 2358884d179dSJan Kara out: 2359884d179dSJan Kara return rc; 2360884d179dSJan Kara } 2361884d179dSJan Kara EXPORT_SYMBOL(vfs_set_dqblk); 2362884d179dSJan Kara 2363884d179dSJan Kara /* Generic routine for getting common part of quota file information */ 2364884d179dSJan Kara int vfs_get_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii) 2365884d179dSJan Kara { 2366884d179dSJan Kara struct mem_dqinfo *mi; 2367884d179dSJan Kara 2368884d179dSJan Kara mutex_lock(&sb_dqopt(sb)->dqonoff_mutex); 2369884d179dSJan Kara if (!sb_has_quota_active(sb, type)) { 2370884d179dSJan Kara mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex); 2371884d179dSJan Kara return -ESRCH; 2372884d179dSJan Kara } 2373884d179dSJan Kara mi = sb_dqopt(sb)->info + type; 2374884d179dSJan Kara spin_lock(&dq_data_lock); 2375884d179dSJan Kara ii->dqi_bgrace = mi->dqi_bgrace; 2376884d179dSJan Kara ii->dqi_igrace = mi->dqi_igrace; 2377884d179dSJan Kara ii->dqi_flags = mi->dqi_flags & DQF_MASK; 2378884d179dSJan Kara ii->dqi_valid = IIF_ALL; 2379884d179dSJan Kara spin_unlock(&dq_data_lock); 2380884d179dSJan Kara mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex); 2381884d179dSJan Kara return 0; 2382884d179dSJan Kara } 2383884d179dSJan Kara EXPORT_SYMBOL(vfs_get_dqinfo); 2384884d179dSJan Kara 2385884d179dSJan Kara /* Generic routine for setting common part of quota file information */ 2386884d179dSJan Kara int vfs_set_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii) 2387884d179dSJan Kara { 2388884d179dSJan Kara struct mem_dqinfo *mi; 2389884d179dSJan Kara int err = 0; 2390884d179dSJan Kara 2391884d179dSJan Kara mutex_lock(&sb_dqopt(sb)->dqonoff_mutex); 2392884d179dSJan Kara if (!sb_has_quota_active(sb, type)) { 2393884d179dSJan Kara err = -ESRCH; 2394884d179dSJan Kara goto out; 2395884d179dSJan Kara } 2396884d179dSJan Kara mi = sb_dqopt(sb)->info + type; 2397884d179dSJan Kara spin_lock(&dq_data_lock); 2398884d179dSJan Kara if (ii->dqi_valid & IIF_BGRACE) 2399884d179dSJan Kara mi->dqi_bgrace = ii->dqi_bgrace; 2400884d179dSJan Kara if (ii->dqi_valid & IIF_IGRACE) 2401884d179dSJan Kara mi->dqi_igrace = ii->dqi_igrace; 2402884d179dSJan Kara if (ii->dqi_valid & IIF_FLAGS) 2403884d179dSJan Kara mi->dqi_flags = (mi->dqi_flags & ~DQF_MASK) | (ii->dqi_flags & DQF_MASK); 2404884d179dSJan Kara spin_unlock(&dq_data_lock); 2405884d179dSJan Kara mark_info_dirty(sb, type); 2406884d179dSJan Kara /* Force write to disk */ 2407884d179dSJan Kara sb->dq_op->write_info(sb, type); 2408884d179dSJan Kara out: 2409884d179dSJan Kara mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex); 2410884d179dSJan Kara return err; 2411884d179dSJan Kara } 2412884d179dSJan Kara EXPORT_SYMBOL(vfs_set_dqinfo); 2413884d179dSJan Kara 2414884d179dSJan Kara struct quotactl_ops vfs_quotactl_ops = { 2415884d179dSJan Kara .quota_on = vfs_quota_on, 2416884d179dSJan Kara .quota_off = vfs_quota_off, 2417884d179dSJan Kara .quota_sync = vfs_quota_sync, 2418884d179dSJan Kara .get_info = vfs_get_dqinfo, 2419884d179dSJan Kara .set_info = vfs_set_dqinfo, 2420884d179dSJan Kara .get_dqblk = vfs_get_dqblk, 2421884d179dSJan Kara .set_dqblk = vfs_set_dqblk 2422884d179dSJan Kara }; 2423884d179dSJan Kara 2424884d179dSJan Kara static ctl_table fs_dqstats_table[] = { 2425884d179dSJan Kara { 2426884d179dSJan Kara .ctl_name = FS_DQ_LOOKUPS, 2427884d179dSJan Kara .procname = "lookups", 2428884d179dSJan Kara .data = &dqstats.lookups, 2429884d179dSJan Kara .maxlen = sizeof(int), 2430884d179dSJan Kara .mode = 0444, 2431884d179dSJan Kara .proc_handler = &proc_dointvec, 2432884d179dSJan Kara }, 2433884d179dSJan Kara { 2434884d179dSJan Kara .ctl_name = FS_DQ_DROPS, 2435884d179dSJan Kara .procname = "drops", 2436884d179dSJan Kara .data = &dqstats.drops, 2437884d179dSJan Kara .maxlen = sizeof(int), 2438884d179dSJan Kara .mode = 0444, 2439884d179dSJan Kara .proc_handler = &proc_dointvec, 2440884d179dSJan Kara }, 2441884d179dSJan Kara { 2442884d179dSJan Kara .ctl_name = FS_DQ_READS, 2443884d179dSJan Kara .procname = "reads", 2444884d179dSJan Kara .data = &dqstats.reads, 2445884d179dSJan Kara .maxlen = sizeof(int), 2446884d179dSJan Kara .mode = 0444, 2447884d179dSJan Kara .proc_handler = &proc_dointvec, 2448884d179dSJan Kara }, 2449884d179dSJan Kara { 2450884d179dSJan Kara .ctl_name = FS_DQ_WRITES, 2451884d179dSJan Kara .procname = "writes", 2452884d179dSJan Kara .data = &dqstats.writes, 2453884d179dSJan Kara .maxlen = sizeof(int), 2454884d179dSJan Kara .mode = 0444, 2455884d179dSJan Kara .proc_handler = &proc_dointvec, 2456884d179dSJan Kara }, 2457884d179dSJan Kara { 2458884d179dSJan Kara .ctl_name = FS_DQ_CACHE_HITS, 2459884d179dSJan Kara .procname = "cache_hits", 2460884d179dSJan Kara .data = &dqstats.cache_hits, 2461884d179dSJan Kara .maxlen = sizeof(int), 2462884d179dSJan Kara .mode = 0444, 2463884d179dSJan Kara .proc_handler = &proc_dointvec, 2464884d179dSJan Kara }, 2465884d179dSJan Kara { 2466884d179dSJan Kara .ctl_name = FS_DQ_ALLOCATED, 2467884d179dSJan Kara .procname = "allocated_dquots", 2468884d179dSJan Kara .data = &dqstats.allocated_dquots, 2469884d179dSJan Kara .maxlen = sizeof(int), 2470884d179dSJan Kara .mode = 0444, 2471884d179dSJan Kara .proc_handler = &proc_dointvec, 2472884d179dSJan Kara }, 2473884d179dSJan Kara { 2474884d179dSJan Kara .ctl_name = FS_DQ_FREE, 2475884d179dSJan Kara .procname = "free_dquots", 2476884d179dSJan Kara .data = &dqstats.free_dquots, 2477884d179dSJan Kara .maxlen = sizeof(int), 2478884d179dSJan Kara .mode = 0444, 2479884d179dSJan Kara .proc_handler = &proc_dointvec, 2480884d179dSJan Kara }, 2481884d179dSJan Kara { 2482884d179dSJan Kara .ctl_name = FS_DQ_SYNCS, 2483884d179dSJan Kara .procname = "syncs", 2484884d179dSJan Kara .data = &dqstats.syncs, 2485884d179dSJan Kara .maxlen = sizeof(int), 2486884d179dSJan Kara .mode = 0444, 2487884d179dSJan Kara .proc_handler = &proc_dointvec, 2488884d179dSJan Kara }, 2489884d179dSJan Kara #ifdef CONFIG_PRINT_QUOTA_WARNING 2490884d179dSJan Kara { 2491884d179dSJan Kara .ctl_name = FS_DQ_WARNINGS, 2492884d179dSJan Kara .procname = "warnings", 2493884d179dSJan Kara .data = &flag_print_warnings, 2494884d179dSJan Kara .maxlen = sizeof(int), 2495884d179dSJan Kara .mode = 0644, 2496884d179dSJan Kara .proc_handler = &proc_dointvec, 2497884d179dSJan Kara }, 2498884d179dSJan Kara #endif 2499884d179dSJan Kara { .ctl_name = 0 }, 2500884d179dSJan Kara }; 2501884d179dSJan Kara 2502884d179dSJan Kara static ctl_table fs_table[] = { 2503884d179dSJan Kara { 2504884d179dSJan Kara .ctl_name = FS_DQSTATS, 2505884d179dSJan Kara .procname = "quota", 2506884d179dSJan Kara .mode = 0555, 2507884d179dSJan Kara .child = fs_dqstats_table, 2508884d179dSJan Kara }, 2509884d179dSJan Kara { .ctl_name = 0 }, 2510884d179dSJan Kara }; 2511884d179dSJan Kara 2512884d179dSJan Kara static ctl_table sys_table[] = { 2513884d179dSJan Kara { 2514884d179dSJan Kara .ctl_name = CTL_FS, 2515884d179dSJan Kara .procname = "fs", 2516884d179dSJan Kara .mode = 0555, 2517884d179dSJan Kara .child = fs_table, 2518884d179dSJan Kara }, 2519884d179dSJan Kara { .ctl_name = 0 }, 2520884d179dSJan Kara }; 2521884d179dSJan Kara 2522884d179dSJan Kara static int __init dquot_init(void) 2523884d179dSJan Kara { 2524884d179dSJan Kara int i; 2525884d179dSJan Kara unsigned long nr_hash, order; 2526884d179dSJan Kara 2527884d179dSJan Kara printk(KERN_NOTICE "VFS: Disk quotas %s\n", __DQUOT_VERSION__); 2528884d179dSJan Kara 2529884d179dSJan Kara register_sysctl_table(sys_table); 2530884d179dSJan Kara 2531884d179dSJan Kara dquot_cachep = kmem_cache_create("dquot", 2532884d179dSJan Kara sizeof(struct dquot), sizeof(unsigned long) * 4, 2533884d179dSJan Kara (SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT| 2534884d179dSJan Kara SLAB_MEM_SPREAD|SLAB_PANIC), 2535884d179dSJan Kara NULL); 2536884d179dSJan Kara 2537884d179dSJan Kara order = 0; 2538884d179dSJan Kara dquot_hash = (struct hlist_head *)__get_free_pages(GFP_ATOMIC, order); 2539884d179dSJan Kara if (!dquot_hash) 2540884d179dSJan Kara panic("Cannot create dquot hash table"); 2541884d179dSJan Kara 2542884d179dSJan Kara /* Find power-of-two hlist_heads which can fit into allocation */ 2543884d179dSJan Kara nr_hash = (1UL << order) * PAGE_SIZE / sizeof(struct hlist_head); 2544884d179dSJan Kara dq_hash_bits = 0; 2545884d179dSJan Kara do { 2546884d179dSJan Kara dq_hash_bits++; 2547884d179dSJan Kara } while (nr_hash >> dq_hash_bits); 2548884d179dSJan Kara dq_hash_bits--; 2549884d179dSJan Kara 2550884d179dSJan Kara nr_hash = 1UL << dq_hash_bits; 2551884d179dSJan Kara dq_hash_mask = nr_hash - 1; 2552884d179dSJan Kara for (i = 0; i < nr_hash; i++) 2553884d179dSJan Kara INIT_HLIST_HEAD(dquot_hash + i); 2554884d179dSJan Kara 2555884d179dSJan Kara printk("Dquot-cache hash table entries: %ld (order %ld, %ld bytes)\n", 2556884d179dSJan Kara nr_hash, order, (PAGE_SIZE << order)); 2557884d179dSJan Kara 2558884d179dSJan Kara register_shrinker(&dqcache_shrinker); 2559884d179dSJan Kara 2560884d179dSJan Kara #ifdef CONFIG_QUOTA_NETLINK_INTERFACE 2561884d179dSJan Kara if (genl_register_family("a_genl_family) != 0) 2562884d179dSJan Kara printk(KERN_ERR "VFS: Failed to create quota netlink interface.\n"); 2563884d179dSJan Kara #endif 2564884d179dSJan Kara 2565884d179dSJan Kara return 0; 2566884d179dSJan Kara } 2567884d179dSJan Kara module_init(dquot_init); 2568