1*884d179dSJan Kara /* 2*884d179dSJan Kara * Implementation of the diskquota system for the LINUX operating system. QUOTA 3*884d179dSJan Kara * is implemented using the BSD system call interface as the means of 4*884d179dSJan Kara * communication with the user level. This file contains the generic routines 5*884d179dSJan Kara * called by the different filesystems on allocation of an inode or block. 6*884d179dSJan Kara * These routines take care of the administration needed to have a consistent 7*884d179dSJan Kara * diskquota tracking system. The ideas of both user and group quotas are based 8*884d179dSJan Kara * on the Melbourne quota system as used on BSD derived systems. The internal 9*884d179dSJan Kara * implementation is based on one of the several variants of the LINUX 10*884d179dSJan Kara * inode-subsystem with added complexity of the diskquota system. 11*884d179dSJan Kara * 12*884d179dSJan Kara * Author: Marco van Wieringen <mvw@planets.elm.net> 13*884d179dSJan Kara * 14*884d179dSJan Kara * Fixes: Dmitry Gorodchanin <pgmdsg@ibi.com>, 11 Feb 96 15*884d179dSJan Kara * 16*884d179dSJan Kara * Revised list management to avoid races 17*884d179dSJan Kara * -- Bill Hawes, <whawes@star.net>, 9/98 18*884d179dSJan Kara * 19*884d179dSJan Kara * Fixed races in dquot_transfer(), dqget() and dquot_alloc_...(). 20*884d179dSJan Kara * As the consequence the locking was moved from dquot_decr_...(), 21*884d179dSJan Kara * dquot_incr_...() to calling functions. 22*884d179dSJan Kara * invalidate_dquots() now writes modified dquots. 23*884d179dSJan Kara * Serialized quota_off() and quota_on() for mount point. 24*884d179dSJan Kara * Fixed a few bugs in grow_dquots(). 25*884d179dSJan Kara * Fixed deadlock in write_dquot() - we no longer account quotas on 26*884d179dSJan Kara * quota files 27*884d179dSJan Kara * remove_dquot_ref() moved to inode.c - it now traverses through inodes 28*884d179dSJan Kara * add_dquot_ref() restarts after blocking 29*884d179dSJan Kara * Added check for bogus uid and fixed check for group in quotactl. 30*884d179dSJan Kara * Jan Kara, <jack@suse.cz>, sponsored by SuSE CR, 10-11/99 31*884d179dSJan Kara * 32*884d179dSJan Kara * Used struct list_head instead of own list struct 33*884d179dSJan Kara * Invalidation of referenced dquots is no longer possible 34*884d179dSJan Kara * Improved free_dquots list management 35*884d179dSJan Kara * Quota and i_blocks are now updated in one place to avoid races 36*884d179dSJan Kara * Warnings are now delayed so we won't block in critical section 37*884d179dSJan Kara * Write updated not to require dquot lock 38*884d179dSJan Kara * Jan Kara, <jack@suse.cz>, 9/2000 39*884d179dSJan Kara * 40*884d179dSJan Kara * Added dynamic quota structure allocation 41*884d179dSJan Kara * Jan Kara <jack@suse.cz> 12/2000 42*884d179dSJan Kara * 43*884d179dSJan Kara * Rewritten quota interface. Implemented new quota format and 44*884d179dSJan Kara * formats registering. 45*884d179dSJan Kara * Jan Kara, <jack@suse.cz>, 2001,2002 46*884d179dSJan Kara * 47*884d179dSJan Kara * New SMP locking. 48*884d179dSJan Kara * Jan Kara, <jack@suse.cz>, 10/2002 49*884d179dSJan Kara * 50*884d179dSJan Kara * Added journalled quota support, fix lock inversion problems 51*884d179dSJan Kara * Jan Kara, <jack@suse.cz>, 2003,2004 52*884d179dSJan Kara * 53*884d179dSJan Kara * (C) Copyright 1994 - 1997 Marco van Wieringen 54*884d179dSJan Kara */ 55*884d179dSJan Kara 56*884d179dSJan Kara #include <linux/errno.h> 57*884d179dSJan Kara #include <linux/kernel.h> 58*884d179dSJan Kara #include <linux/fs.h> 59*884d179dSJan Kara #include <linux/mount.h> 60*884d179dSJan Kara #include <linux/mm.h> 61*884d179dSJan Kara #include <linux/time.h> 62*884d179dSJan Kara #include <linux/types.h> 63*884d179dSJan Kara #include <linux/string.h> 64*884d179dSJan Kara #include <linux/fcntl.h> 65*884d179dSJan Kara #include <linux/stat.h> 66*884d179dSJan Kara #include <linux/tty.h> 67*884d179dSJan Kara #include <linux/file.h> 68*884d179dSJan Kara #include <linux/slab.h> 69*884d179dSJan Kara #include <linux/sysctl.h> 70*884d179dSJan Kara #include <linux/init.h> 71*884d179dSJan Kara #include <linux/module.h> 72*884d179dSJan Kara #include <linux/proc_fs.h> 73*884d179dSJan Kara #include <linux/security.h> 74*884d179dSJan Kara #include <linux/kmod.h> 75*884d179dSJan Kara #include <linux/namei.h> 76*884d179dSJan Kara #include <linux/buffer_head.h> 77*884d179dSJan Kara #include <linux/capability.h> 78*884d179dSJan Kara #include <linux/quotaops.h> 79*884d179dSJan Kara #include <linux/writeback.h> /* for inode_lock, oddly enough.. */ 80*884d179dSJan Kara #ifdef CONFIG_QUOTA_NETLINK_INTERFACE 81*884d179dSJan Kara #include <net/netlink.h> 82*884d179dSJan Kara #include <net/genetlink.h> 83*884d179dSJan Kara #endif 84*884d179dSJan Kara 85*884d179dSJan Kara #include <asm/uaccess.h> 86*884d179dSJan Kara 87*884d179dSJan Kara #define __DQUOT_PARANOIA 88*884d179dSJan Kara 89*884d179dSJan Kara /* 90*884d179dSJan Kara * There are three quota SMP locks. dq_list_lock protects all lists with quotas 91*884d179dSJan Kara * and quota formats, dqstats structure containing statistics about the lists 92*884d179dSJan Kara * dq_data_lock protects data from dq_dqb and also mem_dqinfo structures and 93*884d179dSJan Kara * also guards consistency of dquot->dq_dqb with inode->i_blocks, i_bytes. 94*884d179dSJan Kara * i_blocks and i_bytes updates itself are guarded by i_lock acquired directly 95*884d179dSJan Kara * in inode_add_bytes() and inode_sub_bytes(). dq_state_lock protects 96*884d179dSJan Kara * modifications of quota state (on quotaon and quotaoff) and readers who care 97*884d179dSJan Kara * about latest values take it as well. 98*884d179dSJan Kara * 99*884d179dSJan Kara * The spinlock ordering is hence: dq_data_lock > dq_list_lock > i_lock, 100*884d179dSJan Kara * dq_list_lock > dq_state_lock 101*884d179dSJan Kara * 102*884d179dSJan Kara * Note that some things (eg. sb pointer, type, id) doesn't change during 103*884d179dSJan Kara * the life of the dquot structure and so needn't to be protected by a lock 104*884d179dSJan Kara * 105*884d179dSJan Kara * Any operation working on dquots via inode pointers must hold dqptr_sem. If 106*884d179dSJan Kara * operation is just reading pointers from inode (or not using them at all) the 107*884d179dSJan Kara * read lock is enough. If pointers are altered function must hold write lock 108*884d179dSJan Kara * (these locking rules also apply for S_NOQUOTA flag in the inode - note that 109*884d179dSJan Kara * for altering the flag i_mutex is also needed). 110*884d179dSJan Kara * 111*884d179dSJan Kara * Each dquot has its dq_lock mutex. Locked dquots might not be referenced 112*884d179dSJan Kara * from inodes (dquot_alloc_space() and such don't check the dq_lock). 113*884d179dSJan Kara * Currently dquot is locked only when it is being read to memory (or space for 114*884d179dSJan Kara * it is being allocated) on the first dqget() and when it is being released on 115*884d179dSJan Kara * the last dqput(). The allocation and release oparations are serialized by 116*884d179dSJan Kara * the dq_lock and by checking the use count in dquot_release(). Write 117*884d179dSJan Kara * operations on dquots don't hold dq_lock as they copy data under dq_data_lock 118*884d179dSJan Kara * spinlock to internal buffers before writing. 119*884d179dSJan Kara * 120*884d179dSJan Kara * Lock ordering (including related VFS locks) is the following: 121*884d179dSJan Kara * i_mutex > dqonoff_sem > journal_lock > dqptr_sem > dquot->dq_lock > 122*884d179dSJan Kara * dqio_mutex 123*884d179dSJan Kara * The lock ordering of dqptr_sem imposed by quota code is only dqonoff_sem > 124*884d179dSJan Kara * dqptr_sem. But filesystem has to count with the fact that functions such as 125*884d179dSJan Kara * dquot_alloc_space() acquire dqptr_sem and they usually have to be called 126*884d179dSJan Kara * from inside a transaction to keep filesystem consistency after a crash. Also 127*884d179dSJan Kara * filesystems usually want to do some IO on dquot from ->mark_dirty which is 128*884d179dSJan Kara * called with dqptr_sem held. 129*884d179dSJan Kara * i_mutex on quota files is special (it's below dqio_mutex) 130*884d179dSJan Kara */ 131*884d179dSJan Kara 132*884d179dSJan Kara static DEFINE_SPINLOCK(dq_list_lock); 133*884d179dSJan Kara static DEFINE_SPINLOCK(dq_state_lock); 134*884d179dSJan Kara DEFINE_SPINLOCK(dq_data_lock); 135*884d179dSJan Kara EXPORT_SYMBOL(dq_data_lock); 136*884d179dSJan Kara 137*884d179dSJan Kara static char *quotatypes[] = INITQFNAMES; 138*884d179dSJan Kara static struct quota_format_type *quota_formats; /* List of registered formats */ 139*884d179dSJan Kara static struct quota_module_name module_names[] = INIT_QUOTA_MODULE_NAMES; 140*884d179dSJan Kara 141*884d179dSJan Kara /* SLAB cache for dquot structures */ 142*884d179dSJan Kara static struct kmem_cache *dquot_cachep; 143*884d179dSJan Kara 144*884d179dSJan Kara int register_quota_format(struct quota_format_type *fmt) 145*884d179dSJan Kara { 146*884d179dSJan Kara spin_lock(&dq_list_lock); 147*884d179dSJan Kara fmt->qf_next = quota_formats; 148*884d179dSJan Kara quota_formats = fmt; 149*884d179dSJan Kara spin_unlock(&dq_list_lock); 150*884d179dSJan Kara return 0; 151*884d179dSJan Kara } 152*884d179dSJan Kara EXPORT_SYMBOL(register_quota_format); 153*884d179dSJan Kara 154*884d179dSJan Kara void unregister_quota_format(struct quota_format_type *fmt) 155*884d179dSJan Kara { 156*884d179dSJan Kara struct quota_format_type **actqf; 157*884d179dSJan Kara 158*884d179dSJan Kara spin_lock(&dq_list_lock); 159*884d179dSJan Kara for (actqf = "a_formats; *actqf && *actqf != fmt; actqf = &(*actqf)->qf_next); 160*884d179dSJan Kara if (*actqf) 161*884d179dSJan Kara *actqf = (*actqf)->qf_next; 162*884d179dSJan Kara spin_unlock(&dq_list_lock); 163*884d179dSJan Kara } 164*884d179dSJan Kara EXPORT_SYMBOL(unregister_quota_format); 165*884d179dSJan Kara 166*884d179dSJan Kara static struct quota_format_type *find_quota_format(int id) 167*884d179dSJan Kara { 168*884d179dSJan Kara struct quota_format_type *actqf; 169*884d179dSJan Kara 170*884d179dSJan Kara spin_lock(&dq_list_lock); 171*884d179dSJan Kara for (actqf = quota_formats; actqf && actqf->qf_fmt_id != id; actqf = actqf->qf_next); 172*884d179dSJan Kara if (!actqf || !try_module_get(actqf->qf_owner)) { 173*884d179dSJan Kara int qm; 174*884d179dSJan Kara 175*884d179dSJan Kara spin_unlock(&dq_list_lock); 176*884d179dSJan Kara 177*884d179dSJan Kara for (qm = 0; module_names[qm].qm_fmt_id && module_names[qm].qm_fmt_id != id; qm++); 178*884d179dSJan Kara if (!module_names[qm].qm_fmt_id || request_module(module_names[qm].qm_mod_name)) 179*884d179dSJan Kara return NULL; 180*884d179dSJan Kara 181*884d179dSJan Kara spin_lock(&dq_list_lock); 182*884d179dSJan Kara for (actqf = quota_formats; actqf && actqf->qf_fmt_id != id; actqf = actqf->qf_next); 183*884d179dSJan Kara if (actqf && !try_module_get(actqf->qf_owner)) 184*884d179dSJan Kara actqf = NULL; 185*884d179dSJan Kara } 186*884d179dSJan Kara spin_unlock(&dq_list_lock); 187*884d179dSJan Kara return actqf; 188*884d179dSJan Kara } 189*884d179dSJan Kara 190*884d179dSJan Kara static void put_quota_format(struct quota_format_type *fmt) 191*884d179dSJan Kara { 192*884d179dSJan Kara module_put(fmt->qf_owner); 193*884d179dSJan Kara } 194*884d179dSJan Kara 195*884d179dSJan Kara /* 196*884d179dSJan Kara * Dquot List Management: 197*884d179dSJan Kara * The quota code uses three lists for dquot management: the inuse_list, 198*884d179dSJan Kara * free_dquots, and dquot_hash[] array. A single dquot structure may be 199*884d179dSJan Kara * on all three lists, depending on its current state. 200*884d179dSJan Kara * 201*884d179dSJan Kara * All dquots are placed to the end of inuse_list when first created, and this 202*884d179dSJan Kara * list is used for invalidate operation, which must look at every dquot. 203*884d179dSJan Kara * 204*884d179dSJan Kara * Unused dquots (dq_count == 0) are added to the free_dquots list when freed, 205*884d179dSJan Kara * and this list is searched whenever we need an available dquot. Dquots are 206*884d179dSJan Kara * removed from the list as soon as they are used again, and 207*884d179dSJan Kara * dqstats.free_dquots gives the number of dquots on the list. When 208*884d179dSJan Kara * dquot is invalidated it's completely released from memory. 209*884d179dSJan Kara * 210*884d179dSJan Kara * Dquots with a specific identity (device, type and id) are placed on 211*884d179dSJan Kara * one of the dquot_hash[] hash chains. The provides an efficient search 212*884d179dSJan Kara * mechanism to locate a specific dquot. 213*884d179dSJan Kara */ 214*884d179dSJan Kara 215*884d179dSJan Kara static LIST_HEAD(inuse_list); 216*884d179dSJan Kara static LIST_HEAD(free_dquots); 217*884d179dSJan Kara static unsigned int dq_hash_bits, dq_hash_mask; 218*884d179dSJan Kara static struct hlist_head *dquot_hash; 219*884d179dSJan Kara 220*884d179dSJan Kara struct dqstats dqstats; 221*884d179dSJan Kara EXPORT_SYMBOL(dqstats); 222*884d179dSJan Kara 223*884d179dSJan Kara static inline unsigned int 224*884d179dSJan Kara hashfn(const struct super_block *sb, unsigned int id, int type) 225*884d179dSJan Kara { 226*884d179dSJan Kara unsigned long tmp; 227*884d179dSJan Kara 228*884d179dSJan Kara tmp = (((unsigned long)sb>>L1_CACHE_SHIFT) ^ id) * (MAXQUOTAS - type); 229*884d179dSJan Kara return (tmp + (tmp >> dq_hash_bits)) & dq_hash_mask; 230*884d179dSJan Kara } 231*884d179dSJan Kara 232*884d179dSJan Kara /* 233*884d179dSJan Kara * Following list functions expect dq_list_lock to be held 234*884d179dSJan Kara */ 235*884d179dSJan Kara static inline void insert_dquot_hash(struct dquot *dquot) 236*884d179dSJan Kara { 237*884d179dSJan Kara struct hlist_head *head = dquot_hash + hashfn(dquot->dq_sb, dquot->dq_id, dquot->dq_type); 238*884d179dSJan Kara hlist_add_head(&dquot->dq_hash, head); 239*884d179dSJan Kara } 240*884d179dSJan Kara 241*884d179dSJan Kara static inline void remove_dquot_hash(struct dquot *dquot) 242*884d179dSJan Kara { 243*884d179dSJan Kara hlist_del_init(&dquot->dq_hash); 244*884d179dSJan Kara } 245*884d179dSJan Kara 246*884d179dSJan Kara static inline struct dquot *find_dquot(unsigned int hashent, struct super_block *sb, unsigned int id, int type) 247*884d179dSJan Kara { 248*884d179dSJan Kara struct hlist_node *node; 249*884d179dSJan Kara struct dquot *dquot; 250*884d179dSJan Kara 251*884d179dSJan Kara hlist_for_each (node, dquot_hash+hashent) { 252*884d179dSJan Kara dquot = hlist_entry(node, struct dquot, dq_hash); 253*884d179dSJan Kara if (dquot->dq_sb == sb && dquot->dq_id == id && dquot->dq_type == type) 254*884d179dSJan Kara return dquot; 255*884d179dSJan Kara } 256*884d179dSJan Kara return NODQUOT; 257*884d179dSJan Kara } 258*884d179dSJan Kara 259*884d179dSJan Kara /* Add a dquot to the tail of the free list */ 260*884d179dSJan Kara static inline void put_dquot_last(struct dquot *dquot) 261*884d179dSJan Kara { 262*884d179dSJan Kara list_add_tail(&dquot->dq_free, &free_dquots); 263*884d179dSJan Kara dqstats.free_dquots++; 264*884d179dSJan Kara } 265*884d179dSJan Kara 266*884d179dSJan Kara static inline void remove_free_dquot(struct dquot *dquot) 267*884d179dSJan Kara { 268*884d179dSJan Kara if (list_empty(&dquot->dq_free)) 269*884d179dSJan Kara return; 270*884d179dSJan Kara list_del_init(&dquot->dq_free); 271*884d179dSJan Kara dqstats.free_dquots--; 272*884d179dSJan Kara } 273*884d179dSJan Kara 274*884d179dSJan Kara static inline void put_inuse(struct dquot *dquot) 275*884d179dSJan Kara { 276*884d179dSJan Kara /* We add to the back of inuse list so we don't have to restart 277*884d179dSJan Kara * when traversing this list and we block */ 278*884d179dSJan Kara list_add_tail(&dquot->dq_inuse, &inuse_list); 279*884d179dSJan Kara dqstats.allocated_dquots++; 280*884d179dSJan Kara } 281*884d179dSJan Kara 282*884d179dSJan Kara static inline void remove_inuse(struct dquot *dquot) 283*884d179dSJan Kara { 284*884d179dSJan Kara dqstats.allocated_dquots--; 285*884d179dSJan Kara list_del(&dquot->dq_inuse); 286*884d179dSJan Kara } 287*884d179dSJan Kara /* 288*884d179dSJan Kara * End of list functions needing dq_list_lock 289*884d179dSJan Kara */ 290*884d179dSJan Kara 291*884d179dSJan Kara static void wait_on_dquot(struct dquot *dquot) 292*884d179dSJan Kara { 293*884d179dSJan Kara mutex_lock(&dquot->dq_lock); 294*884d179dSJan Kara mutex_unlock(&dquot->dq_lock); 295*884d179dSJan Kara } 296*884d179dSJan Kara 297*884d179dSJan Kara static inline int dquot_dirty(struct dquot *dquot) 298*884d179dSJan Kara { 299*884d179dSJan Kara return test_bit(DQ_MOD_B, &dquot->dq_flags); 300*884d179dSJan Kara } 301*884d179dSJan Kara 302*884d179dSJan Kara static inline int mark_dquot_dirty(struct dquot *dquot) 303*884d179dSJan Kara { 304*884d179dSJan Kara return dquot->dq_sb->dq_op->mark_dirty(dquot); 305*884d179dSJan Kara } 306*884d179dSJan Kara 307*884d179dSJan Kara int dquot_mark_dquot_dirty(struct dquot *dquot) 308*884d179dSJan Kara { 309*884d179dSJan Kara spin_lock(&dq_list_lock); 310*884d179dSJan Kara if (!test_and_set_bit(DQ_MOD_B, &dquot->dq_flags)) 311*884d179dSJan Kara list_add(&dquot->dq_dirty, &sb_dqopt(dquot->dq_sb)-> 312*884d179dSJan Kara info[dquot->dq_type].dqi_dirty_list); 313*884d179dSJan Kara spin_unlock(&dq_list_lock); 314*884d179dSJan Kara return 0; 315*884d179dSJan Kara } 316*884d179dSJan Kara EXPORT_SYMBOL(dquot_mark_dquot_dirty); 317*884d179dSJan Kara 318*884d179dSJan Kara /* This function needs dq_list_lock */ 319*884d179dSJan Kara static inline int clear_dquot_dirty(struct dquot *dquot) 320*884d179dSJan Kara { 321*884d179dSJan Kara if (!test_and_clear_bit(DQ_MOD_B, &dquot->dq_flags)) 322*884d179dSJan Kara return 0; 323*884d179dSJan Kara list_del_init(&dquot->dq_dirty); 324*884d179dSJan Kara return 1; 325*884d179dSJan Kara } 326*884d179dSJan Kara 327*884d179dSJan Kara void mark_info_dirty(struct super_block *sb, int type) 328*884d179dSJan Kara { 329*884d179dSJan Kara set_bit(DQF_INFO_DIRTY_B, &sb_dqopt(sb)->info[type].dqi_flags); 330*884d179dSJan Kara } 331*884d179dSJan Kara EXPORT_SYMBOL(mark_info_dirty); 332*884d179dSJan Kara 333*884d179dSJan Kara /* 334*884d179dSJan Kara * Read dquot from disk and alloc space for it 335*884d179dSJan Kara */ 336*884d179dSJan Kara 337*884d179dSJan Kara int dquot_acquire(struct dquot *dquot) 338*884d179dSJan Kara { 339*884d179dSJan Kara int ret = 0, ret2 = 0; 340*884d179dSJan Kara struct quota_info *dqopt = sb_dqopt(dquot->dq_sb); 341*884d179dSJan Kara 342*884d179dSJan Kara mutex_lock(&dquot->dq_lock); 343*884d179dSJan Kara mutex_lock(&dqopt->dqio_mutex); 344*884d179dSJan Kara if (!test_bit(DQ_READ_B, &dquot->dq_flags)) 345*884d179dSJan Kara ret = dqopt->ops[dquot->dq_type]->read_dqblk(dquot); 346*884d179dSJan Kara if (ret < 0) 347*884d179dSJan Kara goto out_iolock; 348*884d179dSJan Kara set_bit(DQ_READ_B, &dquot->dq_flags); 349*884d179dSJan Kara /* Instantiate dquot if needed */ 350*884d179dSJan Kara if (!test_bit(DQ_ACTIVE_B, &dquot->dq_flags) && !dquot->dq_off) { 351*884d179dSJan Kara ret = dqopt->ops[dquot->dq_type]->commit_dqblk(dquot); 352*884d179dSJan Kara /* Write the info if needed */ 353*884d179dSJan Kara if (info_dirty(&dqopt->info[dquot->dq_type])) 354*884d179dSJan Kara ret2 = dqopt->ops[dquot->dq_type]->write_file_info(dquot->dq_sb, dquot->dq_type); 355*884d179dSJan Kara if (ret < 0) 356*884d179dSJan Kara goto out_iolock; 357*884d179dSJan Kara if (ret2 < 0) { 358*884d179dSJan Kara ret = ret2; 359*884d179dSJan Kara goto out_iolock; 360*884d179dSJan Kara } 361*884d179dSJan Kara } 362*884d179dSJan Kara set_bit(DQ_ACTIVE_B, &dquot->dq_flags); 363*884d179dSJan Kara out_iolock: 364*884d179dSJan Kara mutex_unlock(&dqopt->dqio_mutex); 365*884d179dSJan Kara mutex_unlock(&dquot->dq_lock); 366*884d179dSJan Kara return ret; 367*884d179dSJan Kara } 368*884d179dSJan Kara EXPORT_SYMBOL(dquot_acquire); 369*884d179dSJan Kara 370*884d179dSJan Kara /* 371*884d179dSJan Kara * Write dquot to disk 372*884d179dSJan Kara */ 373*884d179dSJan Kara int dquot_commit(struct dquot *dquot) 374*884d179dSJan Kara { 375*884d179dSJan Kara int ret = 0, ret2 = 0; 376*884d179dSJan Kara struct quota_info *dqopt = sb_dqopt(dquot->dq_sb); 377*884d179dSJan Kara 378*884d179dSJan Kara mutex_lock(&dqopt->dqio_mutex); 379*884d179dSJan Kara spin_lock(&dq_list_lock); 380*884d179dSJan Kara if (!clear_dquot_dirty(dquot)) { 381*884d179dSJan Kara spin_unlock(&dq_list_lock); 382*884d179dSJan Kara goto out_sem; 383*884d179dSJan Kara } 384*884d179dSJan Kara spin_unlock(&dq_list_lock); 385*884d179dSJan Kara /* Inactive dquot can be only if there was error during read/init 386*884d179dSJan Kara * => we have better not writing it */ 387*884d179dSJan Kara if (test_bit(DQ_ACTIVE_B, &dquot->dq_flags)) { 388*884d179dSJan Kara ret = dqopt->ops[dquot->dq_type]->commit_dqblk(dquot); 389*884d179dSJan Kara if (info_dirty(&dqopt->info[dquot->dq_type])) 390*884d179dSJan Kara ret2 = dqopt->ops[dquot->dq_type]->write_file_info(dquot->dq_sb, dquot->dq_type); 391*884d179dSJan Kara if (ret >= 0) 392*884d179dSJan Kara ret = ret2; 393*884d179dSJan Kara } 394*884d179dSJan Kara out_sem: 395*884d179dSJan Kara mutex_unlock(&dqopt->dqio_mutex); 396*884d179dSJan Kara return ret; 397*884d179dSJan Kara } 398*884d179dSJan Kara EXPORT_SYMBOL(dquot_commit); 399*884d179dSJan Kara 400*884d179dSJan Kara /* 401*884d179dSJan Kara * Release dquot 402*884d179dSJan Kara */ 403*884d179dSJan Kara int dquot_release(struct dquot *dquot) 404*884d179dSJan Kara { 405*884d179dSJan Kara int ret = 0, ret2 = 0; 406*884d179dSJan Kara struct quota_info *dqopt = sb_dqopt(dquot->dq_sb); 407*884d179dSJan Kara 408*884d179dSJan Kara mutex_lock(&dquot->dq_lock); 409*884d179dSJan Kara /* Check whether we are not racing with some other dqget() */ 410*884d179dSJan Kara if (atomic_read(&dquot->dq_count) > 1) 411*884d179dSJan Kara goto out_dqlock; 412*884d179dSJan Kara mutex_lock(&dqopt->dqio_mutex); 413*884d179dSJan Kara if (dqopt->ops[dquot->dq_type]->release_dqblk) { 414*884d179dSJan Kara ret = dqopt->ops[dquot->dq_type]->release_dqblk(dquot); 415*884d179dSJan Kara /* Write the info */ 416*884d179dSJan Kara if (info_dirty(&dqopt->info[dquot->dq_type])) 417*884d179dSJan Kara ret2 = dqopt->ops[dquot->dq_type]->write_file_info(dquot->dq_sb, dquot->dq_type); 418*884d179dSJan Kara if (ret >= 0) 419*884d179dSJan Kara ret = ret2; 420*884d179dSJan Kara } 421*884d179dSJan Kara clear_bit(DQ_ACTIVE_B, &dquot->dq_flags); 422*884d179dSJan Kara mutex_unlock(&dqopt->dqio_mutex); 423*884d179dSJan Kara out_dqlock: 424*884d179dSJan Kara mutex_unlock(&dquot->dq_lock); 425*884d179dSJan Kara return ret; 426*884d179dSJan Kara } 427*884d179dSJan Kara EXPORT_SYMBOL(dquot_release); 428*884d179dSJan Kara 429*884d179dSJan Kara void dquot_destroy(struct dquot *dquot) 430*884d179dSJan Kara { 431*884d179dSJan Kara kmem_cache_free(dquot_cachep, dquot); 432*884d179dSJan Kara } 433*884d179dSJan Kara EXPORT_SYMBOL(dquot_destroy); 434*884d179dSJan Kara 435*884d179dSJan Kara static inline void do_destroy_dquot(struct dquot *dquot) 436*884d179dSJan Kara { 437*884d179dSJan Kara dquot->dq_sb->dq_op->destroy_dquot(dquot); 438*884d179dSJan Kara } 439*884d179dSJan Kara 440*884d179dSJan Kara /* Invalidate all dquots on the list. Note that this function is called after 441*884d179dSJan Kara * quota is disabled and pointers from inodes removed so there cannot be new 442*884d179dSJan Kara * quota users. There can still be some users of quotas due to inodes being 443*884d179dSJan Kara * just deleted or pruned by prune_icache() (those are not attached to any 444*884d179dSJan Kara * list) or parallel quotactl call. We have to wait for such users. 445*884d179dSJan Kara */ 446*884d179dSJan Kara static void invalidate_dquots(struct super_block *sb, int type) 447*884d179dSJan Kara { 448*884d179dSJan Kara struct dquot *dquot, *tmp; 449*884d179dSJan Kara 450*884d179dSJan Kara restart: 451*884d179dSJan Kara spin_lock(&dq_list_lock); 452*884d179dSJan Kara list_for_each_entry_safe(dquot, tmp, &inuse_list, dq_inuse) { 453*884d179dSJan Kara if (dquot->dq_sb != sb) 454*884d179dSJan Kara continue; 455*884d179dSJan Kara if (dquot->dq_type != type) 456*884d179dSJan Kara continue; 457*884d179dSJan Kara /* Wait for dquot users */ 458*884d179dSJan Kara if (atomic_read(&dquot->dq_count)) { 459*884d179dSJan Kara DEFINE_WAIT(wait); 460*884d179dSJan Kara 461*884d179dSJan Kara atomic_inc(&dquot->dq_count); 462*884d179dSJan Kara prepare_to_wait(&dquot->dq_wait_unused, &wait, 463*884d179dSJan Kara TASK_UNINTERRUPTIBLE); 464*884d179dSJan Kara spin_unlock(&dq_list_lock); 465*884d179dSJan Kara /* Once dqput() wakes us up, we know it's time to free 466*884d179dSJan Kara * the dquot. 467*884d179dSJan Kara * IMPORTANT: we rely on the fact that there is always 468*884d179dSJan Kara * at most one process waiting for dquot to free. 469*884d179dSJan Kara * Otherwise dq_count would be > 1 and we would never 470*884d179dSJan Kara * wake up. 471*884d179dSJan Kara */ 472*884d179dSJan Kara if (atomic_read(&dquot->dq_count) > 1) 473*884d179dSJan Kara schedule(); 474*884d179dSJan Kara finish_wait(&dquot->dq_wait_unused, &wait); 475*884d179dSJan Kara dqput(dquot); 476*884d179dSJan Kara /* At this moment dquot() need not exist (it could be 477*884d179dSJan Kara * reclaimed by prune_dqcache(). Hence we must 478*884d179dSJan Kara * restart. */ 479*884d179dSJan Kara goto restart; 480*884d179dSJan Kara } 481*884d179dSJan Kara /* 482*884d179dSJan Kara * Quota now has no users and it has been written on last 483*884d179dSJan Kara * dqput() 484*884d179dSJan Kara */ 485*884d179dSJan Kara remove_dquot_hash(dquot); 486*884d179dSJan Kara remove_free_dquot(dquot); 487*884d179dSJan Kara remove_inuse(dquot); 488*884d179dSJan Kara do_destroy_dquot(dquot); 489*884d179dSJan Kara } 490*884d179dSJan Kara spin_unlock(&dq_list_lock); 491*884d179dSJan Kara } 492*884d179dSJan Kara 493*884d179dSJan Kara /* Call callback for every active dquot on given filesystem */ 494*884d179dSJan Kara int dquot_scan_active(struct super_block *sb, 495*884d179dSJan Kara int (*fn)(struct dquot *dquot, unsigned long priv), 496*884d179dSJan Kara unsigned long priv) 497*884d179dSJan Kara { 498*884d179dSJan Kara struct dquot *dquot, *old_dquot = NULL; 499*884d179dSJan Kara int ret = 0; 500*884d179dSJan Kara 501*884d179dSJan Kara mutex_lock(&sb_dqopt(sb)->dqonoff_mutex); 502*884d179dSJan Kara spin_lock(&dq_list_lock); 503*884d179dSJan Kara list_for_each_entry(dquot, &inuse_list, dq_inuse) { 504*884d179dSJan Kara if (!test_bit(DQ_ACTIVE_B, &dquot->dq_flags)) 505*884d179dSJan Kara continue; 506*884d179dSJan Kara if (dquot->dq_sb != sb) 507*884d179dSJan Kara continue; 508*884d179dSJan Kara /* Now we have active dquot so we can just increase use count */ 509*884d179dSJan Kara atomic_inc(&dquot->dq_count); 510*884d179dSJan Kara dqstats.lookups++; 511*884d179dSJan Kara spin_unlock(&dq_list_lock); 512*884d179dSJan Kara dqput(old_dquot); 513*884d179dSJan Kara old_dquot = dquot; 514*884d179dSJan Kara ret = fn(dquot, priv); 515*884d179dSJan Kara if (ret < 0) 516*884d179dSJan Kara goto out; 517*884d179dSJan Kara spin_lock(&dq_list_lock); 518*884d179dSJan Kara /* We are safe to continue now because our dquot could not 519*884d179dSJan Kara * be moved out of the inuse list while we hold the reference */ 520*884d179dSJan Kara } 521*884d179dSJan Kara spin_unlock(&dq_list_lock); 522*884d179dSJan Kara out: 523*884d179dSJan Kara dqput(old_dquot); 524*884d179dSJan Kara mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex); 525*884d179dSJan Kara return ret; 526*884d179dSJan Kara } 527*884d179dSJan Kara EXPORT_SYMBOL(dquot_scan_active); 528*884d179dSJan Kara 529*884d179dSJan Kara int vfs_quota_sync(struct super_block *sb, int type) 530*884d179dSJan Kara { 531*884d179dSJan Kara struct list_head *dirty; 532*884d179dSJan Kara struct dquot *dquot; 533*884d179dSJan Kara struct quota_info *dqopt = sb_dqopt(sb); 534*884d179dSJan Kara int cnt; 535*884d179dSJan Kara 536*884d179dSJan Kara mutex_lock(&dqopt->dqonoff_mutex); 537*884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 538*884d179dSJan Kara if (type != -1 && cnt != type) 539*884d179dSJan Kara continue; 540*884d179dSJan Kara if (!sb_has_quota_active(sb, cnt)) 541*884d179dSJan Kara continue; 542*884d179dSJan Kara spin_lock(&dq_list_lock); 543*884d179dSJan Kara dirty = &dqopt->info[cnt].dqi_dirty_list; 544*884d179dSJan Kara while (!list_empty(dirty)) { 545*884d179dSJan Kara dquot = list_first_entry(dirty, struct dquot, dq_dirty); 546*884d179dSJan Kara /* Dirty and inactive can be only bad dquot... */ 547*884d179dSJan Kara if (!test_bit(DQ_ACTIVE_B, &dquot->dq_flags)) { 548*884d179dSJan Kara clear_dquot_dirty(dquot); 549*884d179dSJan Kara continue; 550*884d179dSJan Kara } 551*884d179dSJan Kara /* Now we have active dquot from which someone is 552*884d179dSJan Kara * holding reference so we can safely just increase 553*884d179dSJan Kara * use count */ 554*884d179dSJan Kara atomic_inc(&dquot->dq_count); 555*884d179dSJan Kara dqstats.lookups++; 556*884d179dSJan Kara spin_unlock(&dq_list_lock); 557*884d179dSJan Kara sb->dq_op->write_dquot(dquot); 558*884d179dSJan Kara dqput(dquot); 559*884d179dSJan Kara spin_lock(&dq_list_lock); 560*884d179dSJan Kara } 561*884d179dSJan Kara spin_unlock(&dq_list_lock); 562*884d179dSJan Kara } 563*884d179dSJan Kara 564*884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) 565*884d179dSJan Kara if ((cnt == type || type == -1) && sb_has_quota_active(sb, cnt) 566*884d179dSJan Kara && info_dirty(&dqopt->info[cnt])) 567*884d179dSJan Kara sb->dq_op->write_info(sb, cnt); 568*884d179dSJan Kara spin_lock(&dq_list_lock); 569*884d179dSJan Kara dqstats.syncs++; 570*884d179dSJan Kara spin_unlock(&dq_list_lock); 571*884d179dSJan Kara mutex_unlock(&dqopt->dqonoff_mutex); 572*884d179dSJan Kara 573*884d179dSJan Kara return 0; 574*884d179dSJan Kara } 575*884d179dSJan Kara EXPORT_SYMBOL(vfs_quota_sync); 576*884d179dSJan Kara 577*884d179dSJan Kara /* Free unused dquots from cache */ 578*884d179dSJan Kara static void prune_dqcache(int count) 579*884d179dSJan Kara { 580*884d179dSJan Kara struct list_head *head; 581*884d179dSJan Kara struct dquot *dquot; 582*884d179dSJan Kara 583*884d179dSJan Kara head = free_dquots.prev; 584*884d179dSJan Kara while (head != &free_dquots && count) { 585*884d179dSJan Kara dquot = list_entry(head, struct dquot, dq_free); 586*884d179dSJan Kara remove_dquot_hash(dquot); 587*884d179dSJan Kara remove_free_dquot(dquot); 588*884d179dSJan Kara remove_inuse(dquot); 589*884d179dSJan Kara do_destroy_dquot(dquot); 590*884d179dSJan Kara count--; 591*884d179dSJan Kara head = free_dquots.prev; 592*884d179dSJan Kara } 593*884d179dSJan Kara } 594*884d179dSJan Kara 595*884d179dSJan Kara /* 596*884d179dSJan Kara * This is called from kswapd when we think we need some 597*884d179dSJan Kara * more memory 598*884d179dSJan Kara */ 599*884d179dSJan Kara 600*884d179dSJan Kara static int shrink_dqcache_memory(int nr, gfp_t gfp_mask) 601*884d179dSJan Kara { 602*884d179dSJan Kara if (nr) { 603*884d179dSJan Kara spin_lock(&dq_list_lock); 604*884d179dSJan Kara prune_dqcache(nr); 605*884d179dSJan Kara spin_unlock(&dq_list_lock); 606*884d179dSJan Kara } 607*884d179dSJan Kara return (dqstats.free_dquots / 100) * sysctl_vfs_cache_pressure; 608*884d179dSJan Kara } 609*884d179dSJan Kara 610*884d179dSJan Kara static struct shrinker dqcache_shrinker = { 611*884d179dSJan Kara .shrink = shrink_dqcache_memory, 612*884d179dSJan Kara .seeks = DEFAULT_SEEKS, 613*884d179dSJan Kara }; 614*884d179dSJan Kara 615*884d179dSJan Kara /* 616*884d179dSJan Kara * Put reference to dquot 617*884d179dSJan Kara * NOTE: If you change this function please check whether dqput_blocks() works right... 618*884d179dSJan Kara */ 619*884d179dSJan Kara void dqput(struct dquot *dquot) 620*884d179dSJan Kara { 621*884d179dSJan Kara int ret; 622*884d179dSJan Kara 623*884d179dSJan Kara if (!dquot) 624*884d179dSJan Kara return; 625*884d179dSJan Kara #ifdef __DQUOT_PARANOIA 626*884d179dSJan Kara if (!atomic_read(&dquot->dq_count)) { 627*884d179dSJan Kara printk("VFS: dqput: trying to free free dquot\n"); 628*884d179dSJan Kara printk("VFS: device %s, dquot of %s %d\n", 629*884d179dSJan Kara dquot->dq_sb->s_id, 630*884d179dSJan Kara quotatypes[dquot->dq_type], 631*884d179dSJan Kara dquot->dq_id); 632*884d179dSJan Kara BUG(); 633*884d179dSJan Kara } 634*884d179dSJan Kara #endif 635*884d179dSJan Kara 636*884d179dSJan Kara spin_lock(&dq_list_lock); 637*884d179dSJan Kara dqstats.drops++; 638*884d179dSJan Kara spin_unlock(&dq_list_lock); 639*884d179dSJan Kara we_slept: 640*884d179dSJan Kara spin_lock(&dq_list_lock); 641*884d179dSJan Kara if (atomic_read(&dquot->dq_count) > 1) { 642*884d179dSJan Kara /* We have more than one user... nothing to do */ 643*884d179dSJan Kara atomic_dec(&dquot->dq_count); 644*884d179dSJan Kara /* Releasing dquot during quotaoff phase? */ 645*884d179dSJan Kara if (!sb_has_quota_active(dquot->dq_sb, dquot->dq_type) && 646*884d179dSJan Kara atomic_read(&dquot->dq_count) == 1) 647*884d179dSJan Kara wake_up(&dquot->dq_wait_unused); 648*884d179dSJan Kara spin_unlock(&dq_list_lock); 649*884d179dSJan Kara return; 650*884d179dSJan Kara } 651*884d179dSJan Kara /* Need to release dquot? */ 652*884d179dSJan Kara if (test_bit(DQ_ACTIVE_B, &dquot->dq_flags) && dquot_dirty(dquot)) { 653*884d179dSJan Kara spin_unlock(&dq_list_lock); 654*884d179dSJan Kara /* Commit dquot before releasing */ 655*884d179dSJan Kara ret = dquot->dq_sb->dq_op->write_dquot(dquot); 656*884d179dSJan Kara if (ret < 0) { 657*884d179dSJan Kara printk(KERN_ERR "VFS: cannot write quota structure on " 658*884d179dSJan Kara "device %s (error %d). Quota may get out of " 659*884d179dSJan Kara "sync!\n", dquot->dq_sb->s_id, ret); 660*884d179dSJan Kara /* 661*884d179dSJan Kara * We clear dirty bit anyway, so that we avoid 662*884d179dSJan Kara * infinite loop here 663*884d179dSJan Kara */ 664*884d179dSJan Kara spin_lock(&dq_list_lock); 665*884d179dSJan Kara clear_dquot_dirty(dquot); 666*884d179dSJan Kara spin_unlock(&dq_list_lock); 667*884d179dSJan Kara } 668*884d179dSJan Kara goto we_slept; 669*884d179dSJan Kara } 670*884d179dSJan Kara /* Clear flag in case dquot was inactive (something bad happened) */ 671*884d179dSJan Kara clear_dquot_dirty(dquot); 672*884d179dSJan Kara if (test_bit(DQ_ACTIVE_B, &dquot->dq_flags)) { 673*884d179dSJan Kara spin_unlock(&dq_list_lock); 674*884d179dSJan Kara dquot->dq_sb->dq_op->release_dquot(dquot); 675*884d179dSJan Kara goto we_slept; 676*884d179dSJan Kara } 677*884d179dSJan Kara atomic_dec(&dquot->dq_count); 678*884d179dSJan Kara #ifdef __DQUOT_PARANOIA 679*884d179dSJan Kara /* sanity check */ 680*884d179dSJan Kara BUG_ON(!list_empty(&dquot->dq_free)); 681*884d179dSJan Kara #endif 682*884d179dSJan Kara put_dquot_last(dquot); 683*884d179dSJan Kara spin_unlock(&dq_list_lock); 684*884d179dSJan Kara } 685*884d179dSJan Kara EXPORT_SYMBOL(dqput); 686*884d179dSJan Kara 687*884d179dSJan Kara struct dquot *dquot_alloc(struct super_block *sb, int type) 688*884d179dSJan Kara { 689*884d179dSJan Kara return kmem_cache_zalloc(dquot_cachep, GFP_NOFS); 690*884d179dSJan Kara } 691*884d179dSJan Kara EXPORT_SYMBOL(dquot_alloc); 692*884d179dSJan Kara 693*884d179dSJan Kara static struct dquot *get_empty_dquot(struct super_block *sb, int type) 694*884d179dSJan Kara { 695*884d179dSJan Kara struct dquot *dquot; 696*884d179dSJan Kara 697*884d179dSJan Kara dquot = sb->dq_op->alloc_dquot(sb, type); 698*884d179dSJan Kara if(!dquot) 699*884d179dSJan Kara return NODQUOT; 700*884d179dSJan Kara 701*884d179dSJan Kara mutex_init(&dquot->dq_lock); 702*884d179dSJan Kara INIT_LIST_HEAD(&dquot->dq_free); 703*884d179dSJan Kara INIT_LIST_HEAD(&dquot->dq_inuse); 704*884d179dSJan Kara INIT_HLIST_NODE(&dquot->dq_hash); 705*884d179dSJan Kara INIT_LIST_HEAD(&dquot->dq_dirty); 706*884d179dSJan Kara init_waitqueue_head(&dquot->dq_wait_unused); 707*884d179dSJan Kara dquot->dq_sb = sb; 708*884d179dSJan Kara dquot->dq_type = type; 709*884d179dSJan Kara atomic_set(&dquot->dq_count, 1); 710*884d179dSJan Kara 711*884d179dSJan Kara return dquot; 712*884d179dSJan Kara } 713*884d179dSJan Kara 714*884d179dSJan Kara /* 715*884d179dSJan Kara * Get reference to dquot 716*884d179dSJan Kara * 717*884d179dSJan Kara * Locking is slightly tricky here. We are guarded from parallel quotaoff() 718*884d179dSJan Kara * destroying our dquot by: 719*884d179dSJan Kara * a) checking for quota flags under dq_list_lock and 720*884d179dSJan Kara * b) getting a reference to dquot before we release dq_list_lock 721*884d179dSJan Kara */ 722*884d179dSJan Kara struct dquot *dqget(struct super_block *sb, unsigned int id, int type) 723*884d179dSJan Kara { 724*884d179dSJan Kara unsigned int hashent = hashfn(sb, id, type); 725*884d179dSJan Kara struct dquot *dquot = NODQUOT, *empty = NODQUOT; 726*884d179dSJan Kara 727*884d179dSJan Kara if (!sb_has_quota_active(sb, type)) 728*884d179dSJan Kara return NODQUOT; 729*884d179dSJan Kara we_slept: 730*884d179dSJan Kara spin_lock(&dq_list_lock); 731*884d179dSJan Kara spin_lock(&dq_state_lock); 732*884d179dSJan Kara if (!sb_has_quota_active(sb, type)) { 733*884d179dSJan Kara spin_unlock(&dq_state_lock); 734*884d179dSJan Kara spin_unlock(&dq_list_lock); 735*884d179dSJan Kara goto out; 736*884d179dSJan Kara } 737*884d179dSJan Kara spin_unlock(&dq_state_lock); 738*884d179dSJan Kara 739*884d179dSJan Kara if ((dquot = find_dquot(hashent, sb, id, type)) == NODQUOT) { 740*884d179dSJan Kara if (empty == NODQUOT) { 741*884d179dSJan Kara spin_unlock(&dq_list_lock); 742*884d179dSJan Kara if ((empty = get_empty_dquot(sb, type)) == NODQUOT) 743*884d179dSJan Kara schedule(); /* Try to wait for a moment... */ 744*884d179dSJan Kara goto we_slept; 745*884d179dSJan Kara } 746*884d179dSJan Kara dquot = empty; 747*884d179dSJan Kara empty = NODQUOT; 748*884d179dSJan Kara dquot->dq_id = id; 749*884d179dSJan Kara /* all dquots go on the inuse_list */ 750*884d179dSJan Kara put_inuse(dquot); 751*884d179dSJan Kara /* hash it first so it can be found */ 752*884d179dSJan Kara insert_dquot_hash(dquot); 753*884d179dSJan Kara dqstats.lookups++; 754*884d179dSJan Kara spin_unlock(&dq_list_lock); 755*884d179dSJan Kara } else { 756*884d179dSJan Kara if (!atomic_read(&dquot->dq_count)) 757*884d179dSJan Kara remove_free_dquot(dquot); 758*884d179dSJan Kara atomic_inc(&dquot->dq_count); 759*884d179dSJan Kara dqstats.cache_hits++; 760*884d179dSJan Kara dqstats.lookups++; 761*884d179dSJan Kara spin_unlock(&dq_list_lock); 762*884d179dSJan Kara } 763*884d179dSJan Kara /* Wait for dq_lock - after this we know that either dquot_release() is already 764*884d179dSJan Kara * finished or it will be canceled due to dq_count > 1 test */ 765*884d179dSJan Kara wait_on_dquot(dquot); 766*884d179dSJan Kara /* Read the dquot and instantiate it (everything done only if needed) */ 767*884d179dSJan Kara if (!test_bit(DQ_ACTIVE_B, &dquot->dq_flags) && sb->dq_op->acquire_dquot(dquot) < 0) { 768*884d179dSJan Kara dqput(dquot); 769*884d179dSJan Kara dquot = NODQUOT; 770*884d179dSJan Kara goto out; 771*884d179dSJan Kara } 772*884d179dSJan Kara #ifdef __DQUOT_PARANOIA 773*884d179dSJan Kara BUG_ON(!dquot->dq_sb); /* Has somebody invalidated entry under us? */ 774*884d179dSJan Kara #endif 775*884d179dSJan Kara out: 776*884d179dSJan Kara if (empty) 777*884d179dSJan Kara do_destroy_dquot(empty); 778*884d179dSJan Kara 779*884d179dSJan Kara return dquot; 780*884d179dSJan Kara } 781*884d179dSJan Kara EXPORT_SYMBOL(dqget); 782*884d179dSJan Kara 783*884d179dSJan Kara static int dqinit_needed(struct inode *inode, int type) 784*884d179dSJan Kara { 785*884d179dSJan Kara int cnt; 786*884d179dSJan Kara 787*884d179dSJan Kara if (IS_NOQUOTA(inode)) 788*884d179dSJan Kara return 0; 789*884d179dSJan Kara if (type != -1) 790*884d179dSJan Kara return inode->i_dquot[type] == NODQUOT; 791*884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) 792*884d179dSJan Kara if (inode->i_dquot[cnt] == NODQUOT) 793*884d179dSJan Kara return 1; 794*884d179dSJan Kara return 0; 795*884d179dSJan Kara } 796*884d179dSJan Kara 797*884d179dSJan Kara /* This routine is guarded by dqonoff_mutex mutex */ 798*884d179dSJan Kara static void add_dquot_ref(struct super_block *sb, int type) 799*884d179dSJan Kara { 800*884d179dSJan Kara struct inode *inode, *old_inode = NULL; 801*884d179dSJan Kara 802*884d179dSJan Kara spin_lock(&inode_lock); 803*884d179dSJan Kara list_for_each_entry(inode, &sb->s_inodes, i_sb_list) { 804*884d179dSJan Kara if (!atomic_read(&inode->i_writecount)) 805*884d179dSJan Kara continue; 806*884d179dSJan Kara if (!dqinit_needed(inode, type)) 807*884d179dSJan Kara continue; 808*884d179dSJan Kara if (inode->i_state & (I_FREEING|I_WILL_FREE)) 809*884d179dSJan Kara continue; 810*884d179dSJan Kara 811*884d179dSJan Kara __iget(inode); 812*884d179dSJan Kara spin_unlock(&inode_lock); 813*884d179dSJan Kara 814*884d179dSJan Kara iput(old_inode); 815*884d179dSJan Kara sb->dq_op->initialize(inode, type); 816*884d179dSJan Kara /* We hold a reference to 'inode' so it couldn't have been 817*884d179dSJan Kara * removed from s_inodes list while we dropped the inode_lock. 818*884d179dSJan Kara * We cannot iput the inode now as we can be holding the last 819*884d179dSJan Kara * reference and we cannot iput it under inode_lock. So we 820*884d179dSJan Kara * keep the reference and iput it later. */ 821*884d179dSJan Kara old_inode = inode; 822*884d179dSJan Kara spin_lock(&inode_lock); 823*884d179dSJan Kara } 824*884d179dSJan Kara spin_unlock(&inode_lock); 825*884d179dSJan Kara iput(old_inode); 826*884d179dSJan Kara } 827*884d179dSJan Kara 828*884d179dSJan Kara /* Return 0 if dqput() won't block (note that 1 doesn't necessarily mean blocking) */ 829*884d179dSJan Kara static inline int dqput_blocks(struct dquot *dquot) 830*884d179dSJan Kara { 831*884d179dSJan Kara if (atomic_read(&dquot->dq_count) <= 1) 832*884d179dSJan Kara return 1; 833*884d179dSJan Kara return 0; 834*884d179dSJan Kara } 835*884d179dSJan Kara 836*884d179dSJan Kara /* Remove references to dquots from inode - add dquot to list for freeing if needed */ 837*884d179dSJan Kara /* We can't race with anybody because we hold dqptr_sem for writing... */ 838*884d179dSJan Kara static int remove_inode_dquot_ref(struct inode *inode, int type, 839*884d179dSJan Kara struct list_head *tofree_head) 840*884d179dSJan Kara { 841*884d179dSJan Kara struct dquot *dquot = inode->i_dquot[type]; 842*884d179dSJan Kara 843*884d179dSJan Kara inode->i_dquot[type] = NODQUOT; 844*884d179dSJan Kara if (dquot != NODQUOT) { 845*884d179dSJan Kara if (dqput_blocks(dquot)) { 846*884d179dSJan Kara #ifdef __DQUOT_PARANOIA 847*884d179dSJan Kara if (atomic_read(&dquot->dq_count) != 1) 848*884d179dSJan Kara printk(KERN_WARNING "VFS: Adding dquot with dq_count %d to dispose list.\n", atomic_read(&dquot->dq_count)); 849*884d179dSJan Kara #endif 850*884d179dSJan Kara spin_lock(&dq_list_lock); 851*884d179dSJan Kara list_add(&dquot->dq_free, tofree_head); /* As dquot must have currently users it can't be on the free list... */ 852*884d179dSJan Kara spin_unlock(&dq_list_lock); 853*884d179dSJan Kara return 1; 854*884d179dSJan Kara } 855*884d179dSJan Kara else 856*884d179dSJan Kara dqput(dquot); /* We have guaranteed we won't block */ 857*884d179dSJan Kara } 858*884d179dSJan Kara return 0; 859*884d179dSJan Kara } 860*884d179dSJan Kara 861*884d179dSJan Kara /* Free list of dquots - called from inode.c */ 862*884d179dSJan Kara /* dquots are removed from inodes, no new references can be got so we are the only ones holding reference */ 863*884d179dSJan Kara static void put_dquot_list(struct list_head *tofree_head) 864*884d179dSJan Kara { 865*884d179dSJan Kara struct list_head *act_head; 866*884d179dSJan Kara struct dquot *dquot; 867*884d179dSJan Kara 868*884d179dSJan Kara act_head = tofree_head->next; 869*884d179dSJan Kara /* So now we have dquots on the list... Just free them */ 870*884d179dSJan Kara while (act_head != tofree_head) { 871*884d179dSJan Kara dquot = list_entry(act_head, struct dquot, dq_free); 872*884d179dSJan Kara act_head = act_head->next; 873*884d179dSJan Kara list_del_init(&dquot->dq_free); /* Remove dquot from the list so we won't have problems... */ 874*884d179dSJan Kara dqput(dquot); 875*884d179dSJan Kara } 876*884d179dSJan Kara } 877*884d179dSJan Kara 878*884d179dSJan Kara static void remove_dquot_ref(struct super_block *sb, int type, 879*884d179dSJan Kara struct list_head *tofree_head) 880*884d179dSJan Kara { 881*884d179dSJan Kara struct inode *inode; 882*884d179dSJan Kara 883*884d179dSJan Kara spin_lock(&inode_lock); 884*884d179dSJan Kara list_for_each_entry(inode, &sb->s_inodes, i_sb_list) { 885*884d179dSJan Kara if (!IS_NOQUOTA(inode)) 886*884d179dSJan Kara remove_inode_dquot_ref(inode, type, tofree_head); 887*884d179dSJan Kara } 888*884d179dSJan Kara spin_unlock(&inode_lock); 889*884d179dSJan Kara } 890*884d179dSJan Kara 891*884d179dSJan Kara /* Gather all references from inodes and drop them */ 892*884d179dSJan Kara static void drop_dquot_ref(struct super_block *sb, int type) 893*884d179dSJan Kara { 894*884d179dSJan Kara LIST_HEAD(tofree_head); 895*884d179dSJan Kara 896*884d179dSJan Kara if (sb->dq_op) { 897*884d179dSJan Kara down_write(&sb_dqopt(sb)->dqptr_sem); 898*884d179dSJan Kara remove_dquot_ref(sb, type, &tofree_head); 899*884d179dSJan Kara up_write(&sb_dqopt(sb)->dqptr_sem); 900*884d179dSJan Kara put_dquot_list(&tofree_head); 901*884d179dSJan Kara } 902*884d179dSJan Kara } 903*884d179dSJan Kara 904*884d179dSJan Kara static inline void dquot_incr_inodes(struct dquot *dquot, qsize_t number) 905*884d179dSJan Kara { 906*884d179dSJan Kara dquot->dq_dqb.dqb_curinodes += number; 907*884d179dSJan Kara } 908*884d179dSJan Kara 909*884d179dSJan Kara static inline void dquot_incr_space(struct dquot *dquot, qsize_t number) 910*884d179dSJan Kara { 911*884d179dSJan Kara dquot->dq_dqb.dqb_curspace += number; 912*884d179dSJan Kara } 913*884d179dSJan Kara 914*884d179dSJan Kara static inline void dquot_resv_space(struct dquot *dquot, qsize_t number) 915*884d179dSJan Kara { 916*884d179dSJan Kara dquot->dq_dqb.dqb_rsvspace += number; 917*884d179dSJan Kara } 918*884d179dSJan Kara 919*884d179dSJan Kara /* 920*884d179dSJan Kara * Claim reserved quota space 921*884d179dSJan Kara */ 922*884d179dSJan Kara static void dquot_claim_reserved_space(struct dquot *dquot, 923*884d179dSJan Kara qsize_t number) 924*884d179dSJan Kara { 925*884d179dSJan Kara WARN_ON(dquot->dq_dqb.dqb_rsvspace < number); 926*884d179dSJan Kara dquot->dq_dqb.dqb_curspace += number; 927*884d179dSJan Kara dquot->dq_dqb.dqb_rsvspace -= number; 928*884d179dSJan Kara } 929*884d179dSJan Kara 930*884d179dSJan Kara static inline 931*884d179dSJan Kara void dquot_free_reserved_space(struct dquot *dquot, qsize_t number) 932*884d179dSJan Kara { 933*884d179dSJan Kara dquot->dq_dqb.dqb_rsvspace -= number; 934*884d179dSJan Kara } 935*884d179dSJan Kara 936*884d179dSJan Kara static inline void dquot_decr_inodes(struct dquot *dquot, qsize_t number) 937*884d179dSJan Kara { 938*884d179dSJan Kara if (sb_dqopt(dquot->dq_sb)->flags & DQUOT_NEGATIVE_USAGE || 939*884d179dSJan Kara dquot->dq_dqb.dqb_curinodes >= number) 940*884d179dSJan Kara dquot->dq_dqb.dqb_curinodes -= number; 941*884d179dSJan Kara else 942*884d179dSJan Kara dquot->dq_dqb.dqb_curinodes = 0; 943*884d179dSJan Kara if (dquot->dq_dqb.dqb_curinodes <= dquot->dq_dqb.dqb_isoftlimit) 944*884d179dSJan Kara dquot->dq_dqb.dqb_itime = (time_t) 0; 945*884d179dSJan Kara clear_bit(DQ_INODES_B, &dquot->dq_flags); 946*884d179dSJan Kara } 947*884d179dSJan Kara 948*884d179dSJan Kara static inline void dquot_decr_space(struct dquot *dquot, qsize_t number) 949*884d179dSJan Kara { 950*884d179dSJan Kara if (sb_dqopt(dquot->dq_sb)->flags & DQUOT_NEGATIVE_USAGE || 951*884d179dSJan Kara dquot->dq_dqb.dqb_curspace >= number) 952*884d179dSJan Kara dquot->dq_dqb.dqb_curspace -= number; 953*884d179dSJan Kara else 954*884d179dSJan Kara dquot->dq_dqb.dqb_curspace = 0; 955*884d179dSJan Kara if (dquot->dq_dqb.dqb_curspace <= dquot->dq_dqb.dqb_bsoftlimit) 956*884d179dSJan Kara dquot->dq_dqb.dqb_btime = (time_t) 0; 957*884d179dSJan Kara clear_bit(DQ_BLKS_B, &dquot->dq_flags); 958*884d179dSJan Kara } 959*884d179dSJan Kara 960*884d179dSJan Kara static int warning_issued(struct dquot *dquot, const int warntype) 961*884d179dSJan Kara { 962*884d179dSJan Kara int flag = (warntype == QUOTA_NL_BHARDWARN || 963*884d179dSJan Kara warntype == QUOTA_NL_BSOFTLONGWARN) ? DQ_BLKS_B : 964*884d179dSJan Kara ((warntype == QUOTA_NL_IHARDWARN || 965*884d179dSJan Kara warntype == QUOTA_NL_ISOFTLONGWARN) ? DQ_INODES_B : 0); 966*884d179dSJan Kara 967*884d179dSJan Kara if (!flag) 968*884d179dSJan Kara return 0; 969*884d179dSJan Kara return test_and_set_bit(flag, &dquot->dq_flags); 970*884d179dSJan Kara } 971*884d179dSJan Kara 972*884d179dSJan Kara #ifdef CONFIG_PRINT_QUOTA_WARNING 973*884d179dSJan Kara static int flag_print_warnings = 1; 974*884d179dSJan Kara 975*884d179dSJan Kara static inline int need_print_warning(struct dquot *dquot) 976*884d179dSJan Kara { 977*884d179dSJan Kara if (!flag_print_warnings) 978*884d179dSJan Kara return 0; 979*884d179dSJan Kara 980*884d179dSJan Kara switch (dquot->dq_type) { 981*884d179dSJan Kara case USRQUOTA: 982*884d179dSJan Kara return current_fsuid() == dquot->dq_id; 983*884d179dSJan Kara case GRPQUOTA: 984*884d179dSJan Kara return in_group_p(dquot->dq_id); 985*884d179dSJan Kara } 986*884d179dSJan Kara return 0; 987*884d179dSJan Kara } 988*884d179dSJan Kara 989*884d179dSJan Kara /* Print warning to user which exceeded quota */ 990*884d179dSJan Kara static void print_warning(struct dquot *dquot, const int warntype) 991*884d179dSJan Kara { 992*884d179dSJan Kara char *msg = NULL; 993*884d179dSJan Kara struct tty_struct *tty; 994*884d179dSJan Kara 995*884d179dSJan Kara if (warntype == QUOTA_NL_IHARDBELOW || 996*884d179dSJan Kara warntype == QUOTA_NL_ISOFTBELOW || 997*884d179dSJan Kara warntype == QUOTA_NL_BHARDBELOW || 998*884d179dSJan Kara warntype == QUOTA_NL_BSOFTBELOW || !need_print_warning(dquot)) 999*884d179dSJan Kara return; 1000*884d179dSJan Kara 1001*884d179dSJan Kara tty = get_current_tty(); 1002*884d179dSJan Kara if (!tty) 1003*884d179dSJan Kara return; 1004*884d179dSJan Kara tty_write_message(tty, dquot->dq_sb->s_id); 1005*884d179dSJan Kara if (warntype == QUOTA_NL_ISOFTWARN || warntype == QUOTA_NL_BSOFTWARN) 1006*884d179dSJan Kara tty_write_message(tty, ": warning, "); 1007*884d179dSJan Kara else 1008*884d179dSJan Kara tty_write_message(tty, ": write failed, "); 1009*884d179dSJan Kara tty_write_message(tty, quotatypes[dquot->dq_type]); 1010*884d179dSJan Kara switch (warntype) { 1011*884d179dSJan Kara case QUOTA_NL_IHARDWARN: 1012*884d179dSJan Kara msg = " file limit reached.\r\n"; 1013*884d179dSJan Kara break; 1014*884d179dSJan Kara case QUOTA_NL_ISOFTLONGWARN: 1015*884d179dSJan Kara msg = " file quota exceeded too long.\r\n"; 1016*884d179dSJan Kara break; 1017*884d179dSJan Kara case QUOTA_NL_ISOFTWARN: 1018*884d179dSJan Kara msg = " file quota exceeded.\r\n"; 1019*884d179dSJan Kara break; 1020*884d179dSJan Kara case QUOTA_NL_BHARDWARN: 1021*884d179dSJan Kara msg = " block limit reached.\r\n"; 1022*884d179dSJan Kara break; 1023*884d179dSJan Kara case QUOTA_NL_BSOFTLONGWARN: 1024*884d179dSJan Kara msg = " block quota exceeded too long.\r\n"; 1025*884d179dSJan Kara break; 1026*884d179dSJan Kara case QUOTA_NL_BSOFTWARN: 1027*884d179dSJan Kara msg = " block quota exceeded.\r\n"; 1028*884d179dSJan Kara break; 1029*884d179dSJan Kara } 1030*884d179dSJan Kara tty_write_message(tty, msg); 1031*884d179dSJan Kara tty_kref_put(tty); 1032*884d179dSJan Kara } 1033*884d179dSJan Kara #endif 1034*884d179dSJan Kara 1035*884d179dSJan Kara #ifdef CONFIG_QUOTA_NETLINK_INTERFACE 1036*884d179dSJan Kara 1037*884d179dSJan Kara /* Netlink family structure for quota */ 1038*884d179dSJan Kara static struct genl_family quota_genl_family = { 1039*884d179dSJan Kara .id = GENL_ID_GENERATE, 1040*884d179dSJan Kara .hdrsize = 0, 1041*884d179dSJan Kara .name = "VFS_DQUOT", 1042*884d179dSJan Kara .version = 1, 1043*884d179dSJan Kara .maxattr = QUOTA_NL_A_MAX, 1044*884d179dSJan Kara }; 1045*884d179dSJan Kara 1046*884d179dSJan Kara /* Send warning to userspace about user which exceeded quota */ 1047*884d179dSJan Kara static void send_warning(const struct dquot *dquot, const char warntype) 1048*884d179dSJan Kara { 1049*884d179dSJan Kara static atomic_t seq; 1050*884d179dSJan Kara struct sk_buff *skb; 1051*884d179dSJan Kara void *msg_head; 1052*884d179dSJan Kara int ret; 1053*884d179dSJan Kara int msg_size = 4 * nla_total_size(sizeof(u32)) + 1054*884d179dSJan Kara 2 * nla_total_size(sizeof(u64)); 1055*884d179dSJan Kara 1056*884d179dSJan Kara /* We have to allocate using GFP_NOFS as we are called from a 1057*884d179dSJan Kara * filesystem performing write and thus further recursion into 1058*884d179dSJan Kara * the fs to free some data could cause deadlocks. */ 1059*884d179dSJan Kara skb = genlmsg_new(msg_size, GFP_NOFS); 1060*884d179dSJan Kara if (!skb) { 1061*884d179dSJan Kara printk(KERN_ERR 1062*884d179dSJan Kara "VFS: Not enough memory to send quota warning.\n"); 1063*884d179dSJan Kara return; 1064*884d179dSJan Kara } 1065*884d179dSJan Kara msg_head = genlmsg_put(skb, 0, atomic_add_return(1, &seq), 1066*884d179dSJan Kara "a_genl_family, 0, QUOTA_NL_C_WARNING); 1067*884d179dSJan Kara if (!msg_head) { 1068*884d179dSJan Kara printk(KERN_ERR 1069*884d179dSJan Kara "VFS: Cannot store netlink header in quota warning.\n"); 1070*884d179dSJan Kara goto err_out; 1071*884d179dSJan Kara } 1072*884d179dSJan Kara ret = nla_put_u32(skb, QUOTA_NL_A_QTYPE, dquot->dq_type); 1073*884d179dSJan Kara if (ret) 1074*884d179dSJan Kara goto attr_err_out; 1075*884d179dSJan Kara ret = nla_put_u64(skb, QUOTA_NL_A_EXCESS_ID, dquot->dq_id); 1076*884d179dSJan Kara if (ret) 1077*884d179dSJan Kara goto attr_err_out; 1078*884d179dSJan Kara ret = nla_put_u32(skb, QUOTA_NL_A_WARNING, warntype); 1079*884d179dSJan Kara if (ret) 1080*884d179dSJan Kara goto attr_err_out; 1081*884d179dSJan Kara ret = nla_put_u32(skb, QUOTA_NL_A_DEV_MAJOR, 1082*884d179dSJan Kara MAJOR(dquot->dq_sb->s_dev)); 1083*884d179dSJan Kara if (ret) 1084*884d179dSJan Kara goto attr_err_out; 1085*884d179dSJan Kara ret = nla_put_u32(skb, QUOTA_NL_A_DEV_MINOR, 1086*884d179dSJan Kara MINOR(dquot->dq_sb->s_dev)); 1087*884d179dSJan Kara if (ret) 1088*884d179dSJan Kara goto attr_err_out; 1089*884d179dSJan Kara ret = nla_put_u64(skb, QUOTA_NL_A_CAUSED_ID, current_uid()); 1090*884d179dSJan Kara if (ret) 1091*884d179dSJan Kara goto attr_err_out; 1092*884d179dSJan Kara genlmsg_end(skb, msg_head); 1093*884d179dSJan Kara 1094*884d179dSJan Kara ret = genlmsg_multicast(skb, 0, quota_genl_family.id, GFP_NOFS); 1095*884d179dSJan Kara if (ret < 0 && ret != -ESRCH) 1096*884d179dSJan Kara printk(KERN_ERR 1097*884d179dSJan Kara "VFS: Failed to send notification message: %d\n", ret); 1098*884d179dSJan Kara return; 1099*884d179dSJan Kara attr_err_out: 1100*884d179dSJan Kara printk(KERN_ERR "VFS: Not enough space to compose quota message!\n"); 1101*884d179dSJan Kara err_out: 1102*884d179dSJan Kara kfree_skb(skb); 1103*884d179dSJan Kara } 1104*884d179dSJan Kara #endif 1105*884d179dSJan Kara /* 1106*884d179dSJan Kara * Write warnings to the console and send warning messages over netlink. 1107*884d179dSJan Kara * 1108*884d179dSJan Kara * Note that this function can sleep. 1109*884d179dSJan Kara */ 1110*884d179dSJan Kara static inline void flush_warnings(struct dquot * const *dquots, char *warntype) 1111*884d179dSJan Kara { 1112*884d179dSJan Kara int i; 1113*884d179dSJan Kara 1114*884d179dSJan Kara for (i = 0; i < MAXQUOTAS; i++) 1115*884d179dSJan Kara if (dquots[i] != NODQUOT && warntype[i] != QUOTA_NL_NOWARN && 1116*884d179dSJan Kara !warning_issued(dquots[i], warntype[i])) { 1117*884d179dSJan Kara #ifdef CONFIG_PRINT_QUOTA_WARNING 1118*884d179dSJan Kara print_warning(dquots[i], warntype[i]); 1119*884d179dSJan Kara #endif 1120*884d179dSJan Kara #ifdef CONFIG_QUOTA_NETLINK_INTERFACE 1121*884d179dSJan Kara send_warning(dquots[i], warntype[i]); 1122*884d179dSJan Kara #endif 1123*884d179dSJan Kara } 1124*884d179dSJan Kara } 1125*884d179dSJan Kara 1126*884d179dSJan Kara static inline char ignore_hardlimit(struct dquot *dquot) 1127*884d179dSJan Kara { 1128*884d179dSJan Kara struct mem_dqinfo *info = &sb_dqopt(dquot->dq_sb)->info[dquot->dq_type]; 1129*884d179dSJan Kara 1130*884d179dSJan Kara return capable(CAP_SYS_RESOURCE) && 1131*884d179dSJan Kara (info->dqi_format->qf_fmt_id != QFMT_VFS_OLD || !(info->dqi_flags & V1_DQF_RSQUASH)); 1132*884d179dSJan Kara } 1133*884d179dSJan Kara 1134*884d179dSJan Kara /* needs dq_data_lock */ 1135*884d179dSJan Kara static int check_idq(struct dquot *dquot, qsize_t inodes, char *warntype) 1136*884d179dSJan Kara { 1137*884d179dSJan Kara *warntype = QUOTA_NL_NOWARN; 1138*884d179dSJan Kara if (!sb_has_quota_limits_enabled(dquot->dq_sb, dquot->dq_type) || 1139*884d179dSJan Kara test_bit(DQ_FAKE_B, &dquot->dq_flags)) 1140*884d179dSJan Kara return QUOTA_OK; 1141*884d179dSJan Kara 1142*884d179dSJan Kara if (dquot->dq_dqb.dqb_ihardlimit && 1143*884d179dSJan Kara (dquot->dq_dqb.dqb_curinodes + inodes) > dquot->dq_dqb.dqb_ihardlimit && 1144*884d179dSJan Kara !ignore_hardlimit(dquot)) { 1145*884d179dSJan Kara *warntype = QUOTA_NL_IHARDWARN; 1146*884d179dSJan Kara return NO_QUOTA; 1147*884d179dSJan Kara } 1148*884d179dSJan Kara 1149*884d179dSJan Kara if (dquot->dq_dqb.dqb_isoftlimit && 1150*884d179dSJan Kara (dquot->dq_dqb.dqb_curinodes + inodes) > dquot->dq_dqb.dqb_isoftlimit && 1151*884d179dSJan Kara dquot->dq_dqb.dqb_itime && get_seconds() >= dquot->dq_dqb.dqb_itime && 1152*884d179dSJan Kara !ignore_hardlimit(dquot)) { 1153*884d179dSJan Kara *warntype = QUOTA_NL_ISOFTLONGWARN; 1154*884d179dSJan Kara return NO_QUOTA; 1155*884d179dSJan Kara } 1156*884d179dSJan Kara 1157*884d179dSJan Kara if (dquot->dq_dqb.dqb_isoftlimit && 1158*884d179dSJan Kara (dquot->dq_dqb.dqb_curinodes + inodes) > dquot->dq_dqb.dqb_isoftlimit && 1159*884d179dSJan Kara dquot->dq_dqb.dqb_itime == 0) { 1160*884d179dSJan Kara *warntype = QUOTA_NL_ISOFTWARN; 1161*884d179dSJan Kara dquot->dq_dqb.dqb_itime = get_seconds() + sb_dqopt(dquot->dq_sb)->info[dquot->dq_type].dqi_igrace; 1162*884d179dSJan Kara } 1163*884d179dSJan Kara 1164*884d179dSJan Kara return QUOTA_OK; 1165*884d179dSJan Kara } 1166*884d179dSJan Kara 1167*884d179dSJan Kara /* needs dq_data_lock */ 1168*884d179dSJan Kara static int check_bdq(struct dquot *dquot, qsize_t space, int prealloc, char *warntype) 1169*884d179dSJan Kara { 1170*884d179dSJan Kara qsize_t tspace; 1171*884d179dSJan Kara 1172*884d179dSJan Kara *warntype = QUOTA_NL_NOWARN; 1173*884d179dSJan Kara if (!sb_has_quota_limits_enabled(dquot->dq_sb, dquot->dq_type) || 1174*884d179dSJan Kara test_bit(DQ_FAKE_B, &dquot->dq_flags)) 1175*884d179dSJan Kara return QUOTA_OK; 1176*884d179dSJan Kara 1177*884d179dSJan Kara tspace = dquot->dq_dqb.dqb_curspace + dquot->dq_dqb.dqb_rsvspace 1178*884d179dSJan Kara + space; 1179*884d179dSJan Kara 1180*884d179dSJan Kara if (dquot->dq_dqb.dqb_bhardlimit && 1181*884d179dSJan Kara tspace > dquot->dq_dqb.dqb_bhardlimit && 1182*884d179dSJan Kara !ignore_hardlimit(dquot)) { 1183*884d179dSJan Kara if (!prealloc) 1184*884d179dSJan Kara *warntype = QUOTA_NL_BHARDWARN; 1185*884d179dSJan Kara return NO_QUOTA; 1186*884d179dSJan Kara } 1187*884d179dSJan Kara 1188*884d179dSJan Kara if (dquot->dq_dqb.dqb_bsoftlimit && 1189*884d179dSJan Kara tspace > dquot->dq_dqb.dqb_bsoftlimit && 1190*884d179dSJan Kara dquot->dq_dqb.dqb_btime && get_seconds() >= dquot->dq_dqb.dqb_btime && 1191*884d179dSJan Kara !ignore_hardlimit(dquot)) { 1192*884d179dSJan Kara if (!prealloc) 1193*884d179dSJan Kara *warntype = QUOTA_NL_BSOFTLONGWARN; 1194*884d179dSJan Kara return NO_QUOTA; 1195*884d179dSJan Kara } 1196*884d179dSJan Kara 1197*884d179dSJan Kara if (dquot->dq_dqb.dqb_bsoftlimit && 1198*884d179dSJan Kara tspace > dquot->dq_dqb.dqb_bsoftlimit && 1199*884d179dSJan Kara dquot->dq_dqb.dqb_btime == 0) { 1200*884d179dSJan Kara if (!prealloc) { 1201*884d179dSJan Kara *warntype = QUOTA_NL_BSOFTWARN; 1202*884d179dSJan Kara dquot->dq_dqb.dqb_btime = get_seconds() + sb_dqopt(dquot->dq_sb)->info[dquot->dq_type].dqi_bgrace; 1203*884d179dSJan Kara } 1204*884d179dSJan Kara else 1205*884d179dSJan Kara /* 1206*884d179dSJan Kara * We don't allow preallocation to exceed softlimit so exceeding will 1207*884d179dSJan Kara * be always printed 1208*884d179dSJan Kara */ 1209*884d179dSJan Kara return NO_QUOTA; 1210*884d179dSJan Kara } 1211*884d179dSJan Kara 1212*884d179dSJan Kara return QUOTA_OK; 1213*884d179dSJan Kara } 1214*884d179dSJan Kara 1215*884d179dSJan Kara static int info_idq_free(struct dquot *dquot, qsize_t inodes) 1216*884d179dSJan Kara { 1217*884d179dSJan Kara if (test_bit(DQ_FAKE_B, &dquot->dq_flags) || 1218*884d179dSJan Kara dquot->dq_dqb.dqb_curinodes <= dquot->dq_dqb.dqb_isoftlimit || 1219*884d179dSJan Kara !sb_has_quota_limits_enabled(dquot->dq_sb, dquot->dq_type)) 1220*884d179dSJan Kara return QUOTA_NL_NOWARN; 1221*884d179dSJan Kara 1222*884d179dSJan Kara if (dquot->dq_dqb.dqb_curinodes - inodes <= dquot->dq_dqb.dqb_isoftlimit) 1223*884d179dSJan Kara return QUOTA_NL_ISOFTBELOW; 1224*884d179dSJan Kara if (dquot->dq_dqb.dqb_curinodes >= dquot->dq_dqb.dqb_ihardlimit && 1225*884d179dSJan Kara dquot->dq_dqb.dqb_curinodes - inodes < dquot->dq_dqb.dqb_ihardlimit) 1226*884d179dSJan Kara return QUOTA_NL_IHARDBELOW; 1227*884d179dSJan Kara return QUOTA_NL_NOWARN; 1228*884d179dSJan Kara } 1229*884d179dSJan Kara 1230*884d179dSJan Kara static int info_bdq_free(struct dquot *dquot, qsize_t space) 1231*884d179dSJan Kara { 1232*884d179dSJan Kara if (test_bit(DQ_FAKE_B, &dquot->dq_flags) || 1233*884d179dSJan Kara dquot->dq_dqb.dqb_curspace <= dquot->dq_dqb.dqb_bsoftlimit) 1234*884d179dSJan Kara return QUOTA_NL_NOWARN; 1235*884d179dSJan Kara 1236*884d179dSJan Kara if (dquot->dq_dqb.dqb_curspace - space <= dquot->dq_dqb.dqb_bsoftlimit) 1237*884d179dSJan Kara return QUOTA_NL_BSOFTBELOW; 1238*884d179dSJan Kara if (dquot->dq_dqb.dqb_curspace >= dquot->dq_dqb.dqb_bhardlimit && 1239*884d179dSJan Kara dquot->dq_dqb.dqb_curspace - space < dquot->dq_dqb.dqb_bhardlimit) 1240*884d179dSJan Kara return QUOTA_NL_BHARDBELOW; 1241*884d179dSJan Kara return QUOTA_NL_NOWARN; 1242*884d179dSJan Kara } 1243*884d179dSJan Kara /* 1244*884d179dSJan Kara * Initialize quota pointers in inode 1245*884d179dSJan Kara * We do things in a bit complicated way but by that we avoid calling 1246*884d179dSJan Kara * dqget() and thus filesystem callbacks under dqptr_sem. 1247*884d179dSJan Kara */ 1248*884d179dSJan Kara int dquot_initialize(struct inode *inode, int type) 1249*884d179dSJan Kara { 1250*884d179dSJan Kara unsigned int id = 0; 1251*884d179dSJan Kara int cnt, ret = 0; 1252*884d179dSJan Kara struct dquot *got[MAXQUOTAS] = { NODQUOT, NODQUOT }; 1253*884d179dSJan Kara struct super_block *sb = inode->i_sb; 1254*884d179dSJan Kara 1255*884d179dSJan Kara /* First test before acquiring mutex - solves deadlocks when we 1256*884d179dSJan Kara * re-enter the quota code and are already holding the mutex */ 1257*884d179dSJan Kara if (IS_NOQUOTA(inode)) 1258*884d179dSJan Kara return 0; 1259*884d179dSJan Kara 1260*884d179dSJan Kara /* First get references to structures we might need. */ 1261*884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1262*884d179dSJan Kara if (type != -1 && cnt != type) 1263*884d179dSJan Kara continue; 1264*884d179dSJan Kara switch (cnt) { 1265*884d179dSJan Kara case USRQUOTA: 1266*884d179dSJan Kara id = inode->i_uid; 1267*884d179dSJan Kara break; 1268*884d179dSJan Kara case GRPQUOTA: 1269*884d179dSJan Kara id = inode->i_gid; 1270*884d179dSJan Kara break; 1271*884d179dSJan Kara } 1272*884d179dSJan Kara got[cnt] = dqget(sb, id, cnt); 1273*884d179dSJan Kara } 1274*884d179dSJan Kara 1275*884d179dSJan Kara down_write(&sb_dqopt(sb)->dqptr_sem); 1276*884d179dSJan Kara /* Having dqptr_sem we know NOQUOTA flags can't be altered... */ 1277*884d179dSJan Kara if (IS_NOQUOTA(inode)) 1278*884d179dSJan Kara goto out_err; 1279*884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1280*884d179dSJan Kara if (type != -1 && cnt != type) 1281*884d179dSJan Kara continue; 1282*884d179dSJan Kara /* Avoid races with quotaoff() */ 1283*884d179dSJan Kara if (!sb_has_quota_active(sb, cnt)) 1284*884d179dSJan Kara continue; 1285*884d179dSJan Kara if (inode->i_dquot[cnt] == NODQUOT) { 1286*884d179dSJan Kara inode->i_dquot[cnt] = got[cnt]; 1287*884d179dSJan Kara got[cnt] = NODQUOT; 1288*884d179dSJan Kara } 1289*884d179dSJan Kara } 1290*884d179dSJan Kara out_err: 1291*884d179dSJan Kara up_write(&sb_dqopt(sb)->dqptr_sem); 1292*884d179dSJan Kara /* Drop unused references */ 1293*884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) 1294*884d179dSJan Kara dqput(got[cnt]); 1295*884d179dSJan Kara return ret; 1296*884d179dSJan Kara } 1297*884d179dSJan Kara EXPORT_SYMBOL(dquot_initialize); 1298*884d179dSJan Kara 1299*884d179dSJan Kara /* 1300*884d179dSJan Kara * Release all quotas referenced by inode 1301*884d179dSJan Kara */ 1302*884d179dSJan Kara int dquot_drop(struct inode *inode) 1303*884d179dSJan Kara { 1304*884d179dSJan Kara int cnt; 1305*884d179dSJan Kara struct dquot *put[MAXQUOTAS]; 1306*884d179dSJan Kara 1307*884d179dSJan Kara down_write(&sb_dqopt(inode->i_sb)->dqptr_sem); 1308*884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1309*884d179dSJan Kara put[cnt] = inode->i_dquot[cnt]; 1310*884d179dSJan Kara inode->i_dquot[cnt] = NODQUOT; 1311*884d179dSJan Kara } 1312*884d179dSJan Kara up_write(&sb_dqopt(inode->i_sb)->dqptr_sem); 1313*884d179dSJan Kara 1314*884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) 1315*884d179dSJan Kara dqput(put[cnt]); 1316*884d179dSJan Kara return 0; 1317*884d179dSJan Kara } 1318*884d179dSJan Kara EXPORT_SYMBOL(dquot_drop); 1319*884d179dSJan Kara 1320*884d179dSJan Kara /* Wrapper to remove references to quota structures from inode */ 1321*884d179dSJan Kara void vfs_dq_drop(struct inode *inode) 1322*884d179dSJan Kara { 1323*884d179dSJan Kara /* Here we can get arbitrary inode from clear_inode() so we have 1324*884d179dSJan Kara * to be careful. OTOH we don't need locking as quota operations 1325*884d179dSJan Kara * are allowed to change only at mount time */ 1326*884d179dSJan Kara if (!IS_NOQUOTA(inode) && inode->i_sb && inode->i_sb->dq_op 1327*884d179dSJan Kara && inode->i_sb->dq_op->drop) { 1328*884d179dSJan Kara int cnt; 1329*884d179dSJan Kara /* Test before calling to rule out calls from proc and such 1330*884d179dSJan Kara * where we are not allowed to block. Note that this is 1331*884d179dSJan Kara * actually reliable test even without the lock - the caller 1332*884d179dSJan Kara * must assure that nobody can come after the DQUOT_DROP and 1333*884d179dSJan Kara * add quota pointers back anyway */ 1334*884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) 1335*884d179dSJan Kara if (inode->i_dquot[cnt] != NODQUOT) 1336*884d179dSJan Kara break; 1337*884d179dSJan Kara if (cnt < MAXQUOTAS) 1338*884d179dSJan Kara inode->i_sb->dq_op->drop(inode); 1339*884d179dSJan Kara } 1340*884d179dSJan Kara } 1341*884d179dSJan Kara EXPORT_SYMBOL(vfs_dq_drop); 1342*884d179dSJan Kara 1343*884d179dSJan Kara /* 1344*884d179dSJan Kara * Following four functions update i_blocks+i_bytes fields and 1345*884d179dSJan Kara * quota information (together with appropriate checks) 1346*884d179dSJan Kara * NOTE: We absolutely rely on the fact that caller dirties 1347*884d179dSJan Kara * the inode (usually macros in quotaops.h care about this) and 1348*884d179dSJan Kara * holds a handle for the current transaction so that dquot write and 1349*884d179dSJan Kara * inode write go into the same transaction. 1350*884d179dSJan Kara */ 1351*884d179dSJan Kara 1352*884d179dSJan Kara /* 1353*884d179dSJan Kara * This operation can block, but only after everything is updated 1354*884d179dSJan Kara */ 1355*884d179dSJan Kara int __dquot_alloc_space(struct inode *inode, qsize_t number, 1356*884d179dSJan Kara int warn, int reserve) 1357*884d179dSJan Kara { 1358*884d179dSJan Kara int cnt, ret = QUOTA_OK; 1359*884d179dSJan Kara char warntype[MAXQUOTAS]; 1360*884d179dSJan Kara 1361*884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) 1362*884d179dSJan Kara warntype[cnt] = QUOTA_NL_NOWARN; 1363*884d179dSJan Kara 1364*884d179dSJan Kara spin_lock(&dq_data_lock); 1365*884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1366*884d179dSJan Kara if (inode->i_dquot[cnt] == NODQUOT) 1367*884d179dSJan Kara continue; 1368*884d179dSJan Kara if (check_bdq(inode->i_dquot[cnt], number, warn, warntype+cnt) 1369*884d179dSJan Kara == NO_QUOTA) { 1370*884d179dSJan Kara ret = NO_QUOTA; 1371*884d179dSJan Kara goto out_unlock; 1372*884d179dSJan Kara } 1373*884d179dSJan Kara } 1374*884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1375*884d179dSJan Kara if (inode->i_dquot[cnt] == NODQUOT) 1376*884d179dSJan Kara continue; 1377*884d179dSJan Kara if (reserve) 1378*884d179dSJan Kara dquot_resv_space(inode->i_dquot[cnt], number); 1379*884d179dSJan Kara else 1380*884d179dSJan Kara dquot_incr_space(inode->i_dquot[cnt], number); 1381*884d179dSJan Kara } 1382*884d179dSJan Kara if (!reserve) 1383*884d179dSJan Kara inode_add_bytes(inode, number); 1384*884d179dSJan Kara out_unlock: 1385*884d179dSJan Kara spin_unlock(&dq_data_lock); 1386*884d179dSJan Kara flush_warnings(inode->i_dquot, warntype); 1387*884d179dSJan Kara return ret; 1388*884d179dSJan Kara } 1389*884d179dSJan Kara 1390*884d179dSJan Kara int dquot_alloc_space(struct inode *inode, qsize_t number, int warn) 1391*884d179dSJan Kara { 1392*884d179dSJan Kara int cnt, ret = QUOTA_OK; 1393*884d179dSJan Kara 1394*884d179dSJan Kara /* 1395*884d179dSJan Kara * First test before acquiring mutex - solves deadlocks when we 1396*884d179dSJan Kara * re-enter the quota code and are already holding the mutex 1397*884d179dSJan Kara */ 1398*884d179dSJan Kara if (IS_NOQUOTA(inode)) { 1399*884d179dSJan Kara inode_add_bytes(inode, number); 1400*884d179dSJan Kara goto out; 1401*884d179dSJan Kara } 1402*884d179dSJan Kara 1403*884d179dSJan Kara down_read(&sb_dqopt(inode->i_sb)->dqptr_sem); 1404*884d179dSJan Kara if (IS_NOQUOTA(inode)) { 1405*884d179dSJan Kara inode_add_bytes(inode, number); 1406*884d179dSJan Kara goto out_unlock; 1407*884d179dSJan Kara } 1408*884d179dSJan Kara 1409*884d179dSJan Kara ret = __dquot_alloc_space(inode, number, warn, 0); 1410*884d179dSJan Kara if (ret == NO_QUOTA) 1411*884d179dSJan Kara goto out_unlock; 1412*884d179dSJan Kara 1413*884d179dSJan Kara /* Dirtify all the dquots - this can block when journalling */ 1414*884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) 1415*884d179dSJan Kara if (inode->i_dquot[cnt]) 1416*884d179dSJan Kara mark_dquot_dirty(inode->i_dquot[cnt]); 1417*884d179dSJan Kara out_unlock: 1418*884d179dSJan Kara up_read(&sb_dqopt(inode->i_sb)->dqptr_sem); 1419*884d179dSJan Kara out: 1420*884d179dSJan Kara return ret; 1421*884d179dSJan Kara } 1422*884d179dSJan Kara EXPORT_SYMBOL(dquot_alloc_space); 1423*884d179dSJan Kara 1424*884d179dSJan Kara int dquot_reserve_space(struct inode *inode, qsize_t number, int warn) 1425*884d179dSJan Kara { 1426*884d179dSJan Kara int ret = QUOTA_OK; 1427*884d179dSJan Kara 1428*884d179dSJan Kara if (IS_NOQUOTA(inode)) 1429*884d179dSJan Kara goto out; 1430*884d179dSJan Kara 1431*884d179dSJan Kara down_read(&sb_dqopt(inode->i_sb)->dqptr_sem); 1432*884d179dSJan Kara if (IS_NOQUOTA(inode)) 1433*884d179dSJan Kara goto out_unlock; 1434*884d179dSJan Kara 1435*884d179dSJan Kara ret = __dquot_alloc_space(inode, number, warn, 1); 1436*884d179dSJan Kara out_unlock: 1437*884d179dSJan Kara up_read(&sb_dqopt(inode->i_sb)->dqptr_sem); 1438*884d179dSJan Kara out: 1439*884d179dSJan Kara return ret; 1440*884d179dSJan Kara } 1441*884d179dSJan Kara EXPORT_SYMBOL(dquot_reserve_space); 1442*884d179dSJan Kara 1443*884d179dSJan Kara /* 1444*884d179dSJan Kara * This operation can block, but only after everything is updated 1445*884d179dSJan Kara */ 1446*884d179dSJan Kara int dquot_alloc_inode(const struct inode *inode, qsize_t number) 1447*884d179dSJan Kara { 1448*884d179dSJan Kara int cnt, ret = NO_QUOTA; 1449*884d179dSJan Kara char warntype[MAXQUOTAS]; 1450*884d179dSJan Kara 1451*884d179dSJan Kara /* First test before acquiring mutex - solves deadlocks when we 1452*884d179dSJan Kara * re-enter the quota code and are already holding the mutex */ 1453*884d179dSJan Kara if (IS_NOQUOTA(inode)) 1454*884d179dSJan Kara return QUOTA_OK; 1455*884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) 1456*884d179dSJan Kara warntype[cnt] = QUOTA_NL_NOWARN; 1457*884d179dSJan Kara down_read(&sb_dqopt(inode->i_sb)->dqptr_sem); 1458*884d179dSJan Kara if (IS_NOQUOTA(inode)) { 1459*884d179dSJan Kara up_read(&sb_dqopt(inode->i_sb)->dqptr_sem); 1460*884d179dSJan Kara return QUOTA_OK; 1461*884d179dSJan Kara } 1462*884d179dSJan Kara spin_lock(&dq_data_lock); 1463*884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1464*884d179dSJan Kara if (inode->i_dquot[cnt] == NODQUOT) 1465*884d179dSJan Kara continue; 1466*884d179dSJan Kara if (check_idq(inode->i_dquot[cnt], number, warntype+cnt) == NO_QUOTA) 1467*884d179dSJan Kara goto warn_put_all; 1468*884d179dSJan Kara } 1469*884d179dSJan Kara 1470*884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1471*884d179dSJan Kara if (inode->i_dquot[cnt] == NODQUOT) 1472*884d179dSJan Kara continue; 1473*884d179dSJan Kara dquot_incr_inodes(inode->i_dquot[cnt], number); 1474*884d179dSJan Kara } 1475*884d179dSJan Kara ret = QUOTA_OK; 1476*884d179dSJan Kara warn_put_all: 1477*884d179dSJan Kara spin_unlock(&dq_data_lock); 1478*884d179dSJan Kara if (ret == QUOTA_OK) 1479*884d179dSJan Kara /* Dirtify all the dquots - this can block when journalling */ 1480*884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) 1481*884d179dSJan Kara if (inode->i_dquot[cnt]) 1482*884d179dSJan Kara mark_dquot_dirty(inode->i_dquot[cnt]); 1483*884d179dSJan Kara flush_warnings(inode->i_dquot, warntype); 1484*884d179dSJan Kara up_read(&sb_dqopt(inode->i_sb)->dqptr_sem); 1485*884d179dSJan Kara return ret; 1486*884d179dSJan Kara } 1487*884d179dSJan Kara EXPORT_SYMBOL(dquot_alloc_inode); 1488*884d179dSJan Kara 1489*884d179dSJan Kara int dquot_claim_space(struct inode *inode, qsize_t number) 1490*884d179dSJan Kara { 1491*884d179dSJan Kara int cnt; 1492*884d179dSJan Kara int ret = QUOTA_OK; 1493*884d179dSJan Kara 1494*884d179dSJan Kara if (IS_NOQUOTA(inode)) { 1495*884d179dSJan Kara inode_add_bytes(inode, number); 1496*884d179dSJan Kara goto out; 1497*884d179dSJan Kara } 1498*884d179dSJan Kara 1499*884d179dSJan Kara down_read(&sb_dqopt(inode->i_sb)->dqptr_sem); 1500*884d179dSJan Kara if (IS_NOQUOTA(inode)) { 1501*884d179dSJan Kara up_read(&sb_dqopt(inode->i_sb)->dqptr_sem); 1502*884d179dSJan Kara inode_add_bytes(inode, number); 1503*884d179dSJan Kara goto out; 1504*884d179dSJan Kara } 1505*884d179dSJan Kara 1506*884d179dSJan Kara spin_lock(&dq_data_lock); 1507*884d179dSJan Kara /* Claim reserved quotas to allocated quotas */ 1508*884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1509*884d179dSJan Kara if (inode->i_dquot[cnt] != NODQUOT) 1510*884d179dSJan Kara dquot_claim_reserved_space(inode->i_dquot[cnt], 1511*884d179dSJan Kara number); 1512*884d179dSJan Kara } 1513*884d179dSJan Kara /* Update inode bytes */ 1514*884d179dSJan Kara inode_add_bytes(inode, number); 1515*884d179dSJan Kara spin_unlock(&dq_data_lock); 1516*884d179dSJan Kara /* Dirtify all the dquots - this can block when journalling */ 1517*884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) 1518*884d179dSJan Kara if (inode->i_dquot[cnt]) 1519*884d179dSJan Kara mark_dquot_dirty(inode->i_dquot[cnt]); 1520*884d179dSJan Kara up_read(&sb_dqopt(inode->i_sb)->dqptr_sem); 1521*884d179dSJan Kara out: 1522*884d179dSJan Kara return ret; 1523*884d179dSJan Kara } 1524*884d179dSJan Kara EXPORT_SYMBOL(dquot_claim_space); 1525*884d179dSJan Kara 1526*884d179dSJan Kara /* 1527*884d179dSJan Kara * Release reserved quota space 1528*884d179dSJan Kara */ 1529*884d179dSJan Kara void dquot_release_reserved_space(struct inode *inode, qsize_t number) 1530*884d179dSJan Kara { 1531*884d179dSJan Kara int cnt; 1532*884d179dSJan Kara 1533*884d179dSJan Kara if (IS_NOQUOTA(inode)) 1534*884d179dSJan Kara goto out; 1535*884d179dSJan Kara 1536*884d179dSJan Kara down_read(&sb_dqopt(inode->i_sb)->dqptr_sem); 1537*884d179dSJan Kara if (IS_NOQUOTA(inode)) 1538*884d179dSJan Kara goto out_unlock; 1539*884d179dSJan Kara 1540*884d179dSJan Kara spin_lock(&dq_data_lock); 1541*884d179dSJan Kara /* Release reserved dquots */ 1542*884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1543*884d179dSJan Kara if (inode->i_dquot[cnt] != NODQUOT) 1544*884d179dSJan Kara dquot_free_reserved_space(inode->i_dquot[cnt], number); 1545*884d179dSJan Kara } 1546*884d179dSJan Kara spin_unlock(&dq_data_lock); 1547*884d179dSJan Kara 1548*884d179dSJan Kara out_unlock: 1549*884d179dSJan Kara up_read(&sb_dqopt(inode->i_sb)->dqptr_sem); 1550*884d179dSJan Kara out: 1551*884d179dSJan Kara return; 1552*884d179dSJan Kara } 1553*884d179dSJan Kara EXPORT_SYMBOL(dquot_release_reserved_space); 1554*884d179dSJan Kara 1555*884d179dSJan Kara /* 1556*884d179dSJan Kara * This operation can block, but only after everything is updated 1557*884d179dSJan Kara */ 1558*884d179dSJan Kara int dquot_free_space(struct inode *inode, qsize_t number) 1559*884d179dSJan Kara { 1560*884d179dSJan Kara unsigned int cnt; 1561*884d179dSJan Kara char warntype[MAXQUOTAS]; 1562*884d179dSJan Kara 1563*884d179dSJan Kara /* First test before acquiring mutex - solves deadlocks when we 1564*884d179dSJan Kara * re-enter the quota code and are already holding the mutex */ 1565*884d179dSJan Kara if (IS_NOQUOTA(inode)) { 1566*884d179dSJan Kara out_sub: 1567*884d179dSJan Kara inode_sub_bytes(inode, number); 1568*884d179dSJan Kara return QUOTA_OK; 1569*884d179dSJan Kara } 1570*884d179dSJan Kara 1571*884d179dSJan Kara down_read(&sb_dqopt(inode->i_sb)->dqptr_sem); 1572*884d179dSJan Kara /* Now recheck reliably when holding dqptr_sem */ 1573*884d179dSJan Kara if (IS_NOQUOTA(inode)) { 1574*884d179dSJan Kara up_read(&sb_dqopt(inode->i_sb)->dqptr_sem); 1575*884d179dSJan Kara goto out_sub; 1576*884d179dSJan Kara } 1577*884d179dSJan Kara spin_lock(&dq_data_lock); 1578*884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1579*884d179dSJan Kara if (inode->i_dquot[cnt] == NODQUOT) 1580*884d179dSJan Kara continue; 1581*884d179dSJan Kara warntype[cnt] = info_bdq_free(inode->i_dquot[cnt], number); 1582*884d179dSJan Kara dquot_decr_space(inode->i_dquot[cnt], number); 1583*884d179dSJan Kara } 1584*884d179dSJan Kara inode_sub_bytes(inode, number); 1585*884d179dSJan Kara spin_unlock(&dq_data_lock); 1586*884d179dSJan Kara /* Dirtify all the dquots - this can block when journalling */ 1587*884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) 1588*884d179dSJan Kara if (inode->i_dquot[cnt]) 1589*884d179dSJan Kara mark_dquot_dirty(inode->i_dquot[cnt]); 1590*884d179dSJan Kara flush_warnings(inode->i_dquot, warntype); 1591*884d179dSJan Kara up_read(&sb_dqopt(inode->i_sb)->dqptr_sem); 1592*884d179dSJan Kara return QUOTA_OK; 1593*884d179dSJan Kara } 1594*884d179dSJan Kara EXPORT_SYMBOL(dquot_free_space); 1595*884d179dSJan Kara 1596*884d179dSJan Kara /* 1597*884d179dSJan Kara * This operation can block, but only after everything is updated 1598*884d179dSJan Kara */ 1599*884d179dSJan Kara int dquot_free_inode(const struct inode *inode, qsize_t number) 1600*884d179dSJan Kara { 1601*884d179dSJan Kara unsigned int cnt; 1602*884d179dSJan Kara char warntype[MAXQUOTAS]; 1603*884d179dSJan Kara 1604*884d179dSJan Kara /* First test before acquiring mutex - solves deadlocks when we 1605*884d179dSJan Kara * re-enter the quota code and are already holding the mutex */ 1606*884d179dSJan Kara if (IS_NOQUOTA(inode)) 1607*884d179dSJan Kara return QUOTA_OK; 1608*884d179dSJan Kara 1609*884d179dSJan Kara down_read(&sb_dqopt(inode->i_sb)->dqptr_sem); 1610*884d179dSJan Kara /* Now recheck reliably when holding dqptr_sem */ 1611*884d179dSJan Kara if (IS_NOQUOTA(inode)) { 1612*884d179dSJan Kara up_read(&sb_dqopt(inode->i_sb)->dqptr_sem); 1613*884d179dSJan Kara return QUOTA_OK; 1614*884d179dSJan Kara } 1615*884d179dSJan Kara spin_lock(&dq_data_lock); 1616*884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1617*884d179dSJan Kara if (inode->i_dquot[cnt] == NODQUOT) 1618*884d179dSJan Kara continue; 1619*884d179dSJan Kara warntype[cnt] = info_idq_free(inode->i_dquot[cnt], number); 1620*884d179dSJan Kara dquot_decr_inodes(inode->i_dquot[cnt], number); 1621*884d179dSJan Kara } 1622*884d179dSJan Kara spin_unlock(&dq_data_lock); 1623*884d179dSJan Kara /* Dirtify all the dquots - this can block when journalling */ 1624*884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) 1625*884d179dSJan Kara if (inode->i_dquot[cnt]) 1626*884d179dSJan Kara mark_dquot_dirty(inode->i_dquot[cnt]); 1627*884d179dSJan Kara flush_warnings(inode->i_dquot, warntype); 1628*884d179dSJan Kara up_read(&sb_dqopt(inode->i_sb)->dqptr_sem); 1629*884d179dSJan Kara return QUOTA_OK; 1630*884d179dSJan Kara } 1631*884d179dSJan Kara EXPORT_SYMBOL(dquot_free_inode); 1632*884d179dSJan Kara 1633*884d179dSJan Kara /* 1634*884d179dSJan Kara * call back function, get reserved quota space from underlying fs 1635*884d179dSJan Kara */ 1636*884d179dSJan Kara qsize_t dquot_get_reserved_space(struct inode *inode) 1637*884d179dSJan Kara { 1638*884d179dSJan Kara qsize_t reserved_space = 0; 1639*884d179dSJan Kara 1640*884d179dSJan Kara if (sb_any_quota_active(inode->i_sb) && 1641*884d179dSJan Kara inode->i_sb->dq_op->get_reserved_space) 1642*884d179dSJan Kara reserved_space = inode->i_sb->dq_op->get_reserved_space(inode); 1643*884d179dSJan Kara return reserved_space; 1644*884d179dSJan Kara } 1645*884d179dSJan Kara 1646*884d179dSJan Kara /* 1647*884d179dSJan Kara * Transfer the number of inode and blocks from one diskquota to an other. 1648*884d179dSJan Kara * 1649*884d179dSJan Kara * This operation can block, but only after everything is updated 1650*884d179dSJan Kara * A transaction must be started when entering this function. 1651*884d179dSJan Kara */ 1652*884d179dSJan Kara int dquot_transfer(struct inode *inode, struct iattr *iattr) 1653*884d179dSJan Kara { 1654*884d179dSJan Kara qsize_t space, cur_space; 1655*884d179dSJan Kara qsize_t rsv_space = 0; 1656*884d179dSJan Kara struct dquot *transfer_from[MAXQUOTAS]; 1657*884d179dSJan Kara struct dquot *transfer_to[MAXQUOTAS]; 1658*884d179dSJan Kara int cnt, ret = QUOTA_OK; 1659*884d179dSJan Kara int chuid = iattr->ia_valid & ATTR_UID && inode->i_uid != iattr->ia_uid, 1660*884d179dSJan Kara chgid = iattr->ia_valid & ATTR_GID && inode->i_gid != iattr->ia_gid; 1661*884d179dSJan Kara char warntype_to[MAXQUOTAS]; 1662*884d179dSJan Kara char warntype_from_inodes[MAXQUOTAS], warntype_from_space[MAXQUOTAS]; 1663*884d179dSJan Kara 1664*884d179dSJan Kara /* First test before acquiring mutex - solves deadlocks when we 1665*884d179dSJan Kara * re-enter the quota code and are already holding the mutex */ 1666*884d179dSJan Kara if (IS_NOQUOTA(inode)) 1667*884d179dSJan Kara return QUOTA_OK; 1668*884d179dSJan Kara /* Initialize the arrays */ 1669*884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1670*884d179dSJan Kara transfer_from[cnt] = NODQUOT; 1671*884d179dSJan Kara transfer_to[cnt] = NODQUOT; 1672*884d179dSJan Kara warntype_to[cnt] = QUOTA_NL_NOWARN; 1673*884d179dSJan Kara switch (cnt) { 1674*884d179dSJan Kara case USRQUOTA: 1675*884d179dSJan Kara if (!chuid) 1676*884d179dSJan Kara continue; 1677*884d179dSJan Kara transfer_to[cnt] = dqget(inode->i_sb, iattr->ia_uid, cnt); 1678*884d179dSJan Kara break; 1679*884d179dSJan Kara case GRPQUOTA: 1680*884d179dSJan Kara if (!chgid) 1681*884d179dSJan Kara continue; 1682*884d179dSJan Kara transfer_to[cnt] = dqget(inode->i_sb, iattr->ia_gid, cnt); 1683*884d179dSJan Kara break; 1684*884d179dSJan Kara } 1685*884d179dSJan Kara } 1686*884d179dSJan Kara 1687*884d179dSJan Kara down_write(&sb_dqopt(inode->i_sb)->dqptr_sem); 1688*884d179dSJan Kara /* Now recheck reliably when holding dqptr_sem */ 1689*884d179dSJan Kara if (IS_NOQUOTA(inode)) { /* File without quota accounting? */ 1690*884d179dSJan Kara up_write(&sb_dqopt(inode->i_sb)->dqptr_sem); 1691*884d179dSJan Kara goto put_all; 1692*884d179dSJan Kara } 1693*884d179dSJan Kara spin_lock(&dq_data_lock); 1694*884d179dSJan Kara cur_space = inode_get_bytes(inode); 1695*884d179dSJan Kara rsv_space = dquot_get_reserved_space(inode); 1696*884d179dSJan Kara space = cur_space + rsv_space; 1697*884d179dSJan Kara /* Build the transfer_from list and check the limits */ 1698*884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1699*884d179dSJan Kara if (transfer_to[cnt] == NODQUOT) 1700*884d179dSJan Kara continue; 1701*884d179dSJan Kara transfer_from[cnt] = inode->i_dquot[cnt]; 1702*884d179dSJan Kara if (check_idq(transfer_to[cnt], 1, warntype_to + cnt) == 1703*884d179dSJan Kara NO_QUOTA || check_bdq(transfer_to[cnt], space, 0, 1704*884d179dSJan Kara warntype_to + cnt) == NO_QUOTA) 1705*884d179dSJan Kara goto over_quota; 1706*884d179dSJan Kara } 1707*884d179dSJan Kara 1708*884d179dSJan Kara /* 1709*884d179dSJan Kara * Finally perform the needed transfer from transfer_from to transfer_to 1710*884d179dSJan Kara */ 1711*884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1712*884d179dSJan Kara /* 1713*884d179dSJan Kara * Skip changes for same uid or gid or for turned off quota-type. 1714*884d179dSJan Kara */ 1715*884d179dSJan Kara if (transfer_to[cnt] == NODQUOT) 1716*884d179dSJan Kara continue; 1717*884d179dSJan Kara 1718*884d179dSJan Kara /* Due to IO error we might not have transfer_from[] structure */ 1719*884d179dSJan Kara if (transfer_from[cnt]) { 1720*884d179dSJan Kara warntype_from_inodes[cnt] = 1721*884d179dSJan Kara info_idq_free(transfer_from[cnt], 1); 1722*884d179dSJan Kara warntype_from_space[cnt] = 1723*884d179dSJan Kara info_bdq_free(transfer_from[cnt], space); 1724*884d179dSJan Kara dquot_decr_inodes(transfer_from[cnt], 1); 1725*884d179dSJan Kara dquot_decr_space(transfer_from[cnt], cur_space); 1726*884d179dSJan Kara dquot_free_reserved_space(transfer_from[cnt], 1727*884d179dSJan Kara rsv_space); 1728*884d179dSJan Kara } 1729*884d179dSJan Kara 1730*884d179dSJan Kara dquot_incr_inodes(transfer_to[cnt], 1); 1731*884d179dSJan Kara dquot_incr_space(transfer_to[cnt], cur_space); 1732*884d179dSJan Kara dquot_resv_space(transfer_to[cnt], rsv_space); 1733*884d179dSJan Kara 1734*884d179dSJan Kara inode->i_dquot[cnt] = transfer_to[cnt]; 1735*884d179dSJan Kara } 1736*884d179dSJan Kara spin_unlock(&dq_data_lock); 1737*884d179dSJan Kara up_write(&sb_dqopt(inode->i_sb)->dqptr_sem); 1738*884d179dSJan Kara 1739*884d179dSJan Kara /* Dirtify all the dquots - this can block when journalling */ 1740*884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1741*884d179dSJan Kara if (transfer_from[cnt]) 1742*884d179dSJan Kara mark_dquot_dirty(transfer_from[cnt]); 1743*884d179dSJan Kara if (transfer_to[cnt]) { 1744*884d179dSJan Kara mark_dquot_dirty(transfer_to[cnt]); 1745*884d179dSJan Kara /* The reference we got is transferred to the inode */ 1746*884d179dSJan Kara transfer_to[cnt] = NODQUOT; 1747*884d179dSJan Kara } 1748*884d179dSJan Kara } 1749*884d179dSJan Kara warn_put_all: 1750*884d179dSJan Kara flush_warnings(transfer_to, warntype_to); 1751*884d179dSJan Kara flush_warnings(transfer_from, warntype_from_inodes); 1752*884d179dSJan Kara flush_warnings(transfer_from, warntype_from_space); 1753*884d179dSJan Kara put_all: 1754*884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1755*884d179dSJan Kara dqput(transfer_from[cnt]); 1756*884d179dSJan Kara dqput(transfer_to[cnt]); 1757*884d179dSJan Kara } 1758*884d179dSJan Kara return ret; 1759*884d179dSJan Kara over_quota: 1760*884d179dSJan Kara spin_unlock(&dq_data_lock); 1761*884d179dSJan Kara up_write(&sb_dqopt(inode->i_sb)->dqptr_sem); 1762*884d179dSJan Kara /* Clear dquot pointers we don't want to dqput() */ 1763*884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) 1764*884d179dSJan Kara transfer_from[cnt] = NODQUOT; 1765*884d179dSJan Kara ret = NO_QUOTA; 1766*884d179dSJan Kara goto warn_put_all; 1767*884d179dSJan Kara } 1768*884d179dSJan Kara EXPORT_SYMBOL(dquot_transfer); 1769*884d179dSJan Kara 1770*884d179dSJan Kara /* Wrapper for transferring ownership of an inode */ 1771*884d179dSJan Kara int vfs_dq_transfer(struct inode *inode, struct iattr *iattr) 1772*884d179dSJan Kara { 1773*884d179dSJan Kara if (sb_any_quota_active(inode->i_sb) && !IS_NOQUOTA(inode)) { 1774*884d179dSJan Kara vfs_dq_init(inode); 1775*884d179dSJan Kara if (inode->i_sb->dq_op->transfer(inode, iattr) == NO_QUOTA) 1776*884d179dSJan Kara return 1; 1777*884d179dSJan Kara } 1778*884d179dSJan Kara return 0; 1779*884d179dSJan Kara } 1780*884d179dSJan Kara EXPORT_SYMBOL(vfs_dq_transfer); 1781*884d179dSJan Kara 1782*884d179dSJan Kara /* 1783*884d179dSJan Kara * Write info of quota file to disk 1784*884d179dSJan Kara */ 1785*884d179dSJan Kara int dquot_commit_info(struct super_block *sb, int type) 1786*884d179dSJan Kara { 1787*884d179dSJan Kara int ret; 1788*884d179dSJan Kara struct quota_info *dqopt = sb_dqopt(sb); 1789*884d179dSJan Kara 1790*884d179dSJan Kara mutex_lock(&dqopt->dqio_mutex); 1791*884d179dSJan Kara ret = dqopt->ops[type]->write_file_info(sb, type); 1792*884d179dSJan Kara mutex_unlock(&dqopt->dqio_mutex); 1793*884d179dSJan Kara return ret; 1794*884d179dSJan Kara } 1795*884d179dSJan Kara EXPORT_SYMBOL(dquot_commit_info); 1796*884d179dSJan Kara 1797*884d179dSJan Kara /* 1798*884d179dSJan Kara * Definitions of diskquota operations. 1799*884d179dSJan Kara */ 1800*884d179dSJan Kara struct dquot_operations dquot_operations = { 1801*884d179dSJan Kara .initialize = dquot_initialize, 1802*884d179dSJan Kara .drop = dquot_drop, 1803*884d179dSJan Kara .alloc_space = dquot_alloc_space, 1804*884d179dSJan Kara .alloc_inode = dquot_alloc_inode, 1805*884d179dSJan Kara .free_space = dquot_free_space, 1806*884d179dSJan Kara .free_inode = dquot_free_inode, 1807*884d179dSJan Kara .transfer = dquot_transfer, 1808*884d179dSJan Kara .write_dquot = dquot_commit, 1809*884d179dSJan Kara .acquire_dquot = dquot_acquire, 1810*884d179dSJan Kara .release_dquot = dquot_release, 1811*884d179dSJan Kara .mark_dirty = dquot_mark_dquot_dirty, 1812*884d179dSJan Kara .write_info = dquot_commit_info, 1813*884d179dSJan Kara .alloc_dquot = dquot_alloc, 1814*884d179dSJan Kara .destroy_dquot = dquot_destroy, 1815*884d179dSJan Kara }; 1816*884d179dSJan Kara 1817*884d179dSJan Kara /* 1818*884d179dSJan Kara * Turn quota off on a device. type == -1 ==> quotaoff for all types (umount) 1819*884d179dSJan Kara */ 1820*884d179dSJan Kara int vfs_quota_disable(struct super_block *sb, int type, unsigned int flags) 1821*884d179dSJan Kara { 1822*884d179dSJan Kara int cnt, ret = 0; 1823*884d179dSJan Kara struct quota_info *dqopt = sb_dqopt(sb); 1824*884d179dSJan Kara struct inode *toputinode[MAXQUOTAS]; 1825*884d179dSJan Kara 1826*884d179dSJan Kara /* Cannot turn off usage accounting without turning off limits, or 1827*884d179dSJan Kara * suspend quotas and simultaneously turn quotas off. */ 1828*884d179dSJan Kara if ((flags & DQUOT_USAGE_ENABLED && !(flags & DQUOT_LIMITS_ENABLED)) 1829*884d179dSJan Kara || (flags & DQUOT_SUSPENDED && flags & (DQUOT_LIMITS_ENABLED | 1830*884d179dSJan Kara DQUOT_USAGE_ENABLED))) 1831*884d179dSJan Kara return -EINVAL; 1832*884d179dSJan Kara 1833*884d179dSJan Kara /* We need to serialize quota_off() for device */ 1834*884d179dSJan Kara mutex_lock(&dqopt->dqonoff_mutex); 1835*884d179dSJan Kara 1836*884d179dSJan Kara /* 1837*884d179dSJan Kara * Skip everything if there's nothing to do. We have to do this because 1838*884d179dSJan Kara * sometimes we are called when fill_super() failed and calling 1839*884d179dSJan Kara * sync_fs() in such cases does no good. 1840*884d179dSJan Kara */ 1841*884d179dSJan Kara if (!sb_any_quota_loaded(sb)) { 1842*884d179dSJan Kara mutex_unlock(&dqopt->dqonoff_mutex); 1843*884d179dSJan Kara return 0; 1844*884d179dSJan Kara } 1845*884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1846*884d179dSJan Kara toputinode[cnt] = NULL; 1847*884d179dSJan Kara if (type != -1 && cnt != type) 1848*884d179dSJan Kara continue; 1849*884d179dSJan Kara if (!sb_has_quota_loaded(sb, cnt)) 1850*884d179dSJan Kara continue; 1851*884d179dSJan Kara 1852*884d179dSJan Kara if (flags & DQUOT_SUSPENDED) { 1853*884d179dSJan Kara spin_lock(&dq_state_lock); 1854*884d179dSJan Kara dqopt->flags |= 1855*884d179dSJan Kara dquot_state_flag(DQUOT_SUSPENDED, cnt); 1856*884d179dSJan Kara spin_unlock(&dq_state_lock); 1857*884d179dSJan Kara } else { 1858*884d179dSJan Kara spin_lock(&dq_state_lock); 1859*884d179dSJan Kara dqopt->flags &= ~dquot_state_flag(flags, cnt); 1860*884d179dSJan Kara /* Turning off suspended quotas? */ 1861*884d179dSJan Kara if (!sb_has_quota_loaded(sb, cnt) && 1862*884d179dSJan Kara sb_has_quota_suspended(sb, cnt)) { 1863*884d179dSJan Kara dqopt->flags &= ~dquot_state_flag( 1864*884d179dSJan Kara DQUOT_SUSPENDED, cnt); 1865*884d179dSJan Kara spin_unlock(&dq_state_lock); 1866*884d179dSJan Kara iput(dqopt->files[cnt]); 1867*884d179dSJan Kara dqopt->files[cnt] = NULL; 1868*884d179dSJan Kara continue; 1869*884d179dSJan Kara } 1870*884d179dSJan Kara spin_unlock(&dq_state_lock); 1871*884d179dSJan Kara } 1872*884d179dSJan Kara 1873*884d179dSJan Kara /* We still have to keep quota loaded? */ 1874*884d179dSJan Kara if (sb_has_quota_loaded(sb, cnt) && !(flags & DQUOT_SUSPENDED)) 1875*884d179dSJan Kara continue; 1876*884d179dSJan Kara 1877*884d179dSJan Kara /* Note: these are blocking operations */ 1878*884d179dSJan Kara drop_dquot_ref(sb, cnt); 1879*884d179dSJan Kara invalidate_dquots(sb, cnt); 1880*884d179dSJan Kara /* 1881*884d179dSJan Kara * Now all dquots should be invalidated, all writes done so we should be only 1882*884d179dSJan Kara * users of the info. No locks needed. 1883*884d179dSJan Kara */ 1884*884d179dSJan Kara if (info_dirty(&dqopt->info[cnt])) 1885*884d179dSJan Kara sb->dq_op->write_info(sb, cnt); 1886*884d179dSJan Kara if (dqopt->ops[cnt]->free_file_info) 1887*884d179dSJan Kara dqopt->ops[cnt]->free_file_info(sb, cnt); 1888*884d179dSJan Kara put_quota_format(dqopt->info[cnt].dqi_format); 1889*884d179dSJan Kara 1890*884d179dSJan Kara toputinode[cnt] = dqopt->files[cnt]; 1891*884d179dSJan Kara if (!sb_has_quota_loaded(sb, cnt)) 1892*884d179dSJan Kara dqopt->files[cnt] = NULL; 1893*884d179dSJan Kara dqopt->info[cnt].dqi_flags = 0; 1894*884d179dSJan Kara dqopt->info[cnt].dqi_igrace = 0; 1895*884d179dSJan Kara dqopt->info[cnt].dqi_bgrace = 0; 1896*884d179dSJan Kara dqopt->ops[cnt] = NULL; 1897*884d179dSJan Kara } 1898*884d179dSJan Kara mutex_unlock(&dqopt->dqonoff_mutex); 1899*884d179dSJan Kara 1900*884d179dSJan Kara /* Skip syncing and setting flags if quota files are hidden */ 1901*884d179dSJan Kara if (dqopt->flags & DQUOT_QUOTA_SYS_FILE) 1902*884d179dSJan Kara goto put_inodes; 1903*884d179dSJan Kara 1904*884d179dSJan Kara /* Sync the superblock so that buffers with quota data are written to 1905*884d179dSJan Kara * disk (and so userspace sees correct data afterwards). */ 1906*884d179dSJan Kara if (sb->s_op->sync_fs) 1907*884d179dSJan Kara sb->s_op->sync_fs(sb, 1); 1908*884d179dSJan Kara sync_blockdev(sb->s_bdev); 1909*884d179dSJan Kara /* Now the quota files are just ordinary files and we can set the 1910*884d179dSJan Kara * inode flags back. Moreover we discard the pagecache so that 1911*884d179dSJan Kara * userspace sees the writes we did bypassing the pagecache. We 1912*884d179dSJan Kara * must also discard the blockdev buffers so that we see the 1913*884d179dSJan Kara * changes done by userspace on the next quotaon() */ 1914*884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) 1915*884d179dSJan Kara if (toputinode[cnt]) { 1916*884d179dSJan Kara mutex_lock(&dqopt->dqonoff_mutex); 1917*884d179dSJan Kara /* If quota was reenabled in the meantime, we have 1918*884d179dSJan Kara * nothing to do */ 1919*884d179dSJan Kara if (!sb_has_quota_loaded(sb, cnt)) { 1920*884d179dSJan Kara mutex_lock_nested(&toputinode[cnt]->i_mutex, I_MUTEX_QUOTA); 1921*884d179dSJan Kara toputinode[cnt]->i_flags &= ~(S_IMMUTABLE | 1922*884d179dSJan Kara S_NOATIME | S_NOQUOTA); 1923*884d179dSJan Kara truncate_inode_pages(&toputinode[cnt]->i_data, 0); 1924*884d179dSJan Kara mutex_unlock(&toputinode[cnt]->i_mutex); 1925*884d179dSJan Kara mark_inode_dirty(toputinode[cnt]); 1926*884d179dSJan Kara } 1927*884d179dSJan Kara mutex_unlock(&dqopt->dqonoff_mutex); 1928*884d179dSJan Kara } 1929*884d179dSJan Kara if (sb->s_bdev) 1930*884d179dSJan Kara invalidate_bdev(sb->s_bdev); 1931*884d179dSJan Kara put_inodes: 1932*884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) 1933*884d179dSJan Kara if (toputinode[cnt]) { 1934*884d179dSJan Kara /* On remount RO, we keep the inode pointer so that we 1935*884d179dSJan Kara * can reenable quota on the subsequent remount RW. We 1936*884d179dSJan Kara * have to check 'flags' variable and not use sb_has_ 1937*884d179dSJan Kara * function because another quotaon / quotaoff could 1938*884d179dSJan Kara * change global state before we got here. We refuse 1939*884d179dSJan Kara * to suspend quotas when there is pending delete on 1940*884d179dSJan Kara * the quota file... */ 1941*884d179dSJan Kara if (!(flags & DQUOT_SUSPENDED)) 1942*884d179dSJan Kara iput(toputinode[cnt]); 1943*884d179dSJan Kara else if (!toputinode[cnt]->i_nlink) 1944*884d179dSJan Kara ret = -EBUSY; 1945*884d179dSJan Kara } 1946*884d179dSJan Kara return ret; 1947*884d179dSJan Kara } 1948*884d179dSJan Kara EXPORT_SYMBOL(vfs_quota_disable); 1949*884d179dSJan Kara 1950*884d179dSJan Kara int vfs_quota_off(struct super_block *sb, int type, int remount) 1951*884d179dSJan Kara { 1952*884d179dSJan Kara return vfs_quota_disable(sb, type, remount ? DQUOT_SUSPENDED : 1953*884d179dSJan Kara (DQUOT_USAGE_ENABLED | DQUOT_LIMITS_ENABLED)); 1954*884d179dSJan Kara } 1955*884d179dSJan Kara EXPORT_SYMBOL(vfs_quota_off); 1956*884d179dSJan Kara /* 1957*884d179dSJan Kara * Turn quotas on on a device 1958*884d179dSJan Kara */ 1959*884d179dSJan Kara 1960*884d179dSJan Kara /* 1961*884d179dSJan Kara * Helper function to turn quotas on when we already have the inode of 1962*884d179dSJan Kara * quota file and no quota information is loaded. 1963*884d179dSJan Kara */ 1964*884d179dSJan Kara static int vfs_load_quota_inode(struct inode *inode, int type, int format_id, 1965*884d179dSJan Kara unsigned int flags) 1966*884d179dSJan Kara { 1967*884d179dSJan Kara struct quota_format_type *fmt = find_quota_format(format_id); 1968*884d179dSJan Kara struct super_block *sb = inode->i_sb; 1969*884d179dSJan Kara struct quota_info *dqopt = sb_dqopt(sb); 1970*884d179dSJan Kara int error; 1971*884d179dSJan Kara int oldflags = -1; 1972*884d179dSJan Kara 1973*884d179dSJan Kara if (!fmt) 1974*884d179dSJan Kara return -ESRCH; 1975*884d179dSJan Kara if (!S_ISREG(inode->i_mode)) { 1976*884d179dSJan Kara error = -EACCES; 1977*884d179dSJan Kara goto out_fmt; 1978*884d179dSJan Kara } 1979*884d179dSJan Kara if (IS_RDONLY(inode)) { 1980*884d179dSJan Kara error = -EROFS; 1981*884d179dSJan Kara goto out_fmt; 1982*884d179dSJan Kara } 1983*884d179dSJan Kara if (!sb->s_op->quota_write || !sb->s_op->quota_read) { 1984*884d179dSJan Kara error = -EINVAL; 1985*884d179dSJan Kara goto out_fmt; 1986*884d179dSJan Kara } 1987*884d179dSJan Kara /* Usage always has to be set... */ 1988*884d179dSJan Kara if (!(flags & DQUOT_USAGE_ENABLED)) { 1989*884d179dSJan Kara error = -EINVAL; 1990*884d179dSJan Kara goto out_fmt; 1991*884d179dSJan Kara } 1992*884d179dSJan Kara 1993*884d179dSJan Kara if (!(dqopt->flags & DQUOT_QUOTA_SYS_FILE)) { 1994*884d179dSJan Kara /* As we bypass the pagecache we must now flush the inode so 1995*884d179dSJan Kara * that we see all the changes from userspace... */ 1996*884d179dSJan Kara write_inode_now(inode, 1); 1997*884d179dSJan Kara /* And now flush the block cache so that kernel sees the 1998*884d179dSJan Kara * changes */ 1999*884d179dSJan Kara invalidate_bdev(sb->s_bdev); 2000*884d179dSJan Kara } 2001*884d179dSJan Kara mutex_lock(&inode->i_mutex); 2002*884d179dSJan Kara mutex_lock(&dqopt->dqonoff_mutex); 2003*884d179dSJan Kara if (sb_has_quota_loaded(sb, type)) { 2004*884d179dSJan Kara error = -EBUSY; 2005*884d179dSJan Kara goto out_lock; 2006*884d179dSJan Kara } 2007*884d179dSJan Kara 2008*884d179dSJan Kara if (!(dqopt->flags & DQUOT_QUOTA_SYS_FILE)) { 2009*884d179dSJan Kara /* We don't want quota and atime on quota files (deadlocks 2010*884d179dSJan Kara * possible) Also nobody should write to the file - we use 2011*884d179dSJan Kara * special IO operations which ignore the immutable bit. */ 2012*884d179dSJan Kara down_write(&dqopt->dqptr_sem); 2013*884d179dSJan Kara oldflags = inode->i_flags & (S_NOATIME | S_IMMUTABLE | S_NOQUOTA); 2014*884d179dSJan Kara inode->i_flags |= S_NOQUOTA | S_NOATIME | S_IMMUTABLE; 2015*884d179dSJan Kara up_write(&dqopt->dqptr_sem); 2016*884d179dSJan Kara sb->dq_op->drop(inode); 2017*884d179dSJan Kara } 2018*884d179dSJan Kara 2019*884d179dSJan Kara error = -EIO; 2020*884d179dSJan Kara dqopt->files[type] = igrab(inode); 2021*884d179dSJan Kara if (!dqopt->files[type]) 2022*884d179dSJan Kara goto out_lock; 2023*884d179dSJan Kara error = -EINVAL; 2024*884d179dSJan Kara if (!fmt->qf_ops->check_quota_file(sb, type)) 2025*884d179dSJan Kara goto out_file_init; 2026*884d179dSJan Kara 2027*884d179dSJan Kara dqopt->ops[type] = fmt->qf_ops; 2028*884d179dSJan Kara dqopt->info[type].dqi_format = fmt; 2029*884d179dSJan Kara dqopt->info[type].dqi_fmt_id = format_id; 2030*884d179dSJan Kara INIT_LIST_HEAD(&dqopt->info[type].dqi_dirty_list); 2031*884d179dSJan Kara mutex_lock(&dqopt->dqio_mutex); 2032*884d179dSJan Kara if ((error = dqopt->ops[type]->read_file_info(sb, type)) < 0) { 2033*884d179dSJan Kara mutex_unlock(&dqopt->dqio_mutex); 2034*884d179dSJan Kara goto out_file_init; 2035*884d179dSJan Kara } 2036*884d179dSJan Kara mutex_unlock(&dqopt->dqio_mutex); 2037*884d179dSJan Kara mutex_unlock(&inode->i_mutex); 2038*884d179dSJan Kara spin_lock(&dq_state_lock); 2039*884d179dSJan Kara dqopt->flags |= dquot_state_flag(flags, type); 2040*884d179dSJan Kara spin_unlock(&dq_state_lock); 2041*884d179dSJan Kara 2042*884d179dSJan Kara add_dquot_ref(sb, type); 2043*884d179dSJan Kara mutex_unlock(&dqopt->dqonoff_mutex); 2044*884d179dSJan Kara 2045*884d179dSJan Kara return 0; 2046*884d179dSJan Kara 2047*884d179dSJan Kara out_file_init: 2048*884d179dSJan Kara dqopt->files[type] = NULL; 2049*884d179dSJan Kara iput(inode); 2050*884d179dSJan Kara out_lock: 2051*884d179dSJan Kara mutex_unlock(&dqopt->dqonoff_mutex); 2052*884d179dSJan Kara if (oldflags != -1) { 2053*884d179dSJan Kara down_write(&dqopt->dqptr_sem); 2054*884d179dSJan Kara /* Set the flags back (in the case of accidental quotaon() 2055*884d179dSJan Kara * on a wrong file we don't want to mess up the flags) */ 2056*884d179dSJan Kara inode->i_flags &= ~(S_NOATIME | S_NOQUOTA | S_IMMUTABLE); 2057*884d179dSJan Kara inode->i_flags |= oldflags; 2058*884d179dSJan Kara up_write(&dqopt->dqptr_sem); 2059*884d179dSJan Kara } 2060*884d179dSJan Kara mutex_unlock(&inode->i_mutex); 2061*884d179dSJan Kara out_fmt: 2062*884d179dSJan Kara put_quota_format(fmt); 2063*884d179dSJan Kara 2064*884d179dSJan Kara return error; 2065*884d179dSJan Kara } 2066*884d179dSJan Kara 2067*884d179dSJan Kara /* Reenable quotas on remount RW */ 2068*884d179dSJan Kara static int vfs_quota_on_remount(struct super_block *sb, int type) 2069*884d179dSJan Kara { 2070*884d179dSJan Kara struct quota_info *dqopt = sb_dqopt(sb); 2071*884d179dSJan Kara struct inode *inode; 2072*884d179dSJan Kara int ret; 2073*884d179dSJan Kara unsigned int flags; 2074*884d179dSJan Kara 2075*884d179dSJan Kara mutex_lock(&dqopt->dqonoff_mutex); 2076*884d179dSJan Kara if (!sb_has_quota_suspended(sb, type)) { 2077*884d179dSJan Kara mutex_unlock(&dqopt->dqonoff_mutex); 2078*884d179dSJan Kara return 0; 2079*884d179dSJan Kara } 2080*884d179dSJan Kara inode = dqopt->files[type]; 2081*884d179dSJan Kara dqopt->files[type] = NULL; 2082*884d179dSJan Kara spin_lock(&dq_state_lock); 2083*884d179dSJan Kara flags = dqopt->flags & dquot_state_flag(DQUOT_USAGE_ENABLED | 2084*884d179dSJan Kara DQUOT_LIMITS_ENABLED, type); 2085*884d179dSJan Kara dqopt->flags &= ~dquot_state_flag(DQUOT_STATE_FLAGS, type); 2086*884d179dSJan Kara spin_unlock(&dq_state_lock); 2087*884d179dSJan Kara mutex_unlock(&dqopt->dqonoff_mutex); 2088*884d179dSJan Kara 2089*884d179dSJan Kara flags = dquot_generic_flag(flags, type); 2090*884d179dSJan Kara ret = vfs_load_quota_inode(inode, type, dqopt->info[type].dqi_fmt_id, 2091*884d179dSJan Kara flags); 2092*884d179dSJan Kara iput(inode); 2093*884d179dSJan Kara 2094*884d179dSJan Kara return ret; 2095*884d179dSJan Kara } 2096*884d179dSJan Kara 2097*884d179dSJan Kara int vfs_quota_on_path(struct super_block *sb, int type, int format_id, 2098*884d179dSJan Kara struct path *path) 2099*884d179dSJan Kara { 2100*884d179dSJan Kara int error = security_quota_on(path->dentry); 2101*884d179dSJan Kara if (error) 2102*884d179dSJan Kara return error; 2103*884d179dSJan Kara /* Quota file not on the same filesystem? */ 2104*884d179dSJan Kara if (path->mnt->mnt_sb != sb) 2105*884d179dSJan Kara error = -EXDEV; 2106*884d179dSJan Kara else 2107*884d179dSJan Kara error = vfs_load_quota_inode(path->dentry->d_inode, type, 2108*884d179dSJan Kara format_id, DQUOT_USAGE_ENABLED | 2109*884d179dSJan Kara DQUOT_LIMITS_ENABLED); 2110*884d179dSJan Kara return error; 2111*884d179dSJan Kara } 2112*884d179dSJan Kara EXPORT_SYMBOL(vfs_quota_on_path); 2113*884d179dSJan Kara 2114*884d179dSJan Kara int vfs_quota_on(struct super_block *sb, int type, int format_id, char *name, 2115*884d179dSJan Kara int remount) 2116*884d179dSJan Kara { 2117*884d179dSJan Kara struct path path; 2118*884d179dSJan Kara int error; 2119*884d179dSJan Kara 2120*884d179dSJan Kara if (remount) 2121*884d179dSJan Kara return vfs_quota_on_remount(sb, type); 2122*884d179dSJan Kara 2123*884d179dSJan Kara error = kern_path(name, LOOKUP_FOLLOW, &path); 2124*884d179dSJan Kara if (!error) { 2125*884d179dSJan Kara error = vfs_quota_on_path(sb, type, format_id, &path); 2126*884d179dSJan Kara path_put(&path); 2127*884d179dSJan Kara } 2128*884d179dSJan Kara return error; 2129*884d179dSJan Kara } 2130*884d179dSJan Kara EXPORT_SYMBOL(vfs_quota_on); 2131*884d179dSJan Kara 2132*884d179dSJan Kara /* 2133*884d179dSJan Kara * More powerful function for turning on quotas allowing setting 2134*884d179dSJan Kara * of individual quota flags 2135*884d179dSJan Kara */ 2136*884d179dSJan Kara int vfs_quota_enable(struct inode *inode, int type, int format_id, 2137*884d179dSJan Kara unsigned int flags) 2138*884d179dSJan Kara { 2139*884d179dSJan Kara int ret = 0; 2140*884d179dSJan Kara struct super_block *sb = inode->i_sb; 2141*884d179dSJan Kara struct quota_info *dqopt = sb_dqopt(sb); 2142*884d179dSJan Kara 2143*884d179dSJan Kara /* Just unsuspend quotas? */ 2144*884d179dSJan Kara if (flags & DQUOT_SUSPENDED) 2145*884d179dSJan Kara return vfs_quota_on_remount(sb, type); 2146*884d179dSJan Kara if (!flags) 2147*884d179dSJan Kara return 0; 2148*884d179dSJan Kara /* Just updating flags needed? */ 2149*884d179dSJan Kara if (sb_has_quota_loaded(sb, type)) { 2150*884d179dSJan Kara mutex_lock(&dqopt->dqonoff_mutex); 2151*884d179dSJan Kara /* Now do a reliable test... */ 2152*884d179dSJan Kara if (!sb_has_quota_loaded(sb, type)) { 2153*884d179dSJan Kara mutex_unlock(&dqopt->dqonoff_mutex); 2154*884d179dSJan Kara goto load_quota; 2155*884d179dSJan Kara } 2156*884d179dSJan Kara if (flags & DQUOT_USAGE_ENABLED && 2157*884d179dSJan Kara sb_has_quota_usage_enabled(sb, type)) { 2158*884d179dSJan Kara ret = -EBUSY; 2159*884d179dSJan Kara goto out_lock; 2160*884d179dSJan Kara } 2161*884d179dSJan Kara if (flags & DQUOT_LIMITS_ENABLED && 2162*884d179dSJan Kara sb_has_quota_limits_enabled(sb, type)) { 2163*884d179dSJan Kara ret = -EBUSY; 2164*884d179dSJan Kara goto out_lock; 2165*884d179dSJan Kara } 2166*884d179dSJan Kara spin_lock(&dq_state_lock); 2167*884d179dSJan Kara sb_dqopt(sb)->flags |= dquot_state_flag(flags, type); 2168*884d179dSJan Kara spin_unlock(&dq_state_lock); 2169*884d179dSJan Kara out_lock: 2170*884d179dSJan Kara mutex_unlock(&dqopt->dqonoff_mutex); 2171*884d179dSJan Kara return ret; 2172*884d179dSJan Kara } 2173*884d179dSJan Kara 2174*884d179dSJan Kara load_quota: 2175*884d179dSJan Kara return vfs_load_quota_inode(inode, type, format_id, flags); 2176*884d179dSJan Kara } 2177*884d179dSJan Kara EXPORT_SYMBOL(vfs_quota_enable); 2178*884d179dSJan Kara 2179*884d179dSJan Kara /* 2180*884d179dSJan Kara * This function is used when filesystem needs to initialize quotas 2181*884d179dSJan Kara * during mount time. 2182*884d179dSJan Kara */ 2183*884d179dSJan Kara int vfs_quota_on_mount(struct super_block *sb, char *qf_name, 2184*884d179dSJan Kara int format_id, int type) 2185*884d179dSJan Kara { 2186*884d179dSJan Kara struct dentry *dentry; 2187*884d179dSJan Kara int error; 2188*884d179dSJan Kara 2189*884d179dSJan Kara dentry = lookup_one_len(qf_name, sb->s_root, strlen(qf_name)); 2190*884d179dSJan Kara if (IS_ERR(dentry)) 2191*884d179dSJan Kara return PTR_ERR(dentry); 2192*884d179dSJan Kara 2193*884d179dSJan Kara if (!dentry->d_inode) { 2194*884d179dSJan Kara error = -ENOENT; 2195*884d179dSJan Kara goto out; 2196*884d179dSJan Kara } 2197*884d179dSJan Kara 2198*884d179dSJan Kara error = security_quota_on(dentry); 2199*884d179dSJan Kara if (!error) 2200*884d179dSJan Kara error = vfs_load_quota_inode(dentry->d_inode, type, format_id, 2201*884d179dSJan Kara DQUOT_USAGE_ENABLED | DQUOT_LIMITS_ENABLED); 2202*884d179dSJan Kara 2203*884d179dSJan Kara out: 2204*884d179dSJan Kara dput(dentry); 2205*884d179dSJan Kara return error; 2206*884d179dSJan Kara } 2207*884d179dSJan Kara EXPORT_SYMBOL(vfs_quota_on_mount); 2208*884d179dSJan Kara 2209*884d179dSJan Kara /* Wrapper to turn on quotas when remounting rw */ 2210*884d179dSJan Kara int vfs_dq_quota_on_remount(struct super_block *sb) 2211*884d179dSJan Kara { 2212*884d179dSJan Kara int cnt; 2213*884d179dSJan Kara int ret = 0, err; 2214*884d179dSJan Kara 2215*884d179dSJan Kara if (!sb->s_qcop || !sb->s_qcop->quota_on) 2216*884d179dSJan Kara return -ENOSYS; 2217*884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 2218*884d179dSJan Kara err = sb->s_qcop->quota_on(sb, cnt, 0, NULL, 1); 2219*884d179dSJan Kara if (err < 0 && !ret) 2220*884d179dSJan Kara ret = err; 2221*884d179dSJan Kara } 2222*884d179dSJan Kara return ret; 2223*884d179dSJan Kara } 2224*884d179dSJan Kara EXPORT_SYMBOL(vfs_dq_quota_on_remount); 2225*884d179dSJan Kara 2226*884d179dSJan Kara static inline qsize_t qbtos(qsize_t blocks) 2227*884d179dSJan Kara { 2228*884d179dSJan Kara return blocks << QIF_DQBLKSIZE_BITS; 2229*884d179dSJan Kara } 2230*884d179dSJan Kara 2231*884d179dSJan Kara static inline qsize_t stoqb(qsize_t space) 2232*884d179dSJan Kara { 2233*884d179dSJan Kara return (space + QIF_DQBLKSIZE - 1) >> QIF_DQBLKSIZE_BITS; 2234*884d179dSJan Kara } 2235*884d179dSJan Kara 2236*884d179dSJan Kara /* Generic routine for getting common part of quota structure */ 2237*884d179dSJan Kara static void do_get_dqblk(struct dquot *dquot, struct if_dqblk *di) 2238*884d179dSJan Kara { 2239*884d179dSJan Kara struct mem_dqblk *dm = &dquot->dq_dqb; 2240*884d179dSJan Kara 2241*884d179dSJan Kara spin_lock(&dq_data_lock); 2242*884d179dSJan Kara di->dqb_bhardlimit = stoqb(dm->dqb_bhardlimit); 2243*884d179dSJan Kara di->dqb_bsoftlimit = stoqb(dm->dqb_bsoftlimit); 2244*884d179dSJan Kara di->dqb_curspace = dm->dqb_curspace + dm->dqb_rsvspace; 2245*884d179dSJan Kara di->dqb_ihardlimit = dm->dqb_ihardlimit; 2246*884d179dSJan Kara di->dqb_isoftlimit = dm->dqb_isoftlimit; 2247*884d179dSJan Kara di->dqb_curinodes = dm->dqb_curinodes; 2248*884d179dSJan Kara di->dqb_btime = dm->dqb_btime; 2249*884d179dSJan Kara di->dqb_itime = dm->dqb_itime; 2250*884d179dSJan Kara di->dqb_valid = QIF_ALL; 2251*884d179dSJan Kara spin_unlock(&dq_data_lock); 2252*884d179dSJan Kara } 2253*884d179dSJan Kara 2254*884d179dSJan Kara int vfs_get_dqblk(struct super_block *sb, int type, qid_t id, struct if_dqblk *di) 2255*884d179dSJan Kara { 2256*884d179dSJan Kara struct dquot *dquot; 2257*884d179dSJan Kara 2258*884d179dSJan Kara dquot = dqget(sb, id, type); 2259*884d179dSJan Kara if (dquot == NODQUOT) 2260*884d179dSJan Kara return -ESRCH; 2261*884d179dSJan Kara do_get_dqblk(dquot, di); 2262*884d179dSJan Kara dqput(dquot); 2263*884d179dSJan Kara 2264*884d179dSJan Kara return 0; 2265*884d179dSJan Kara } 2266*884d179dSJan Kara EXPORT_SYMBOL(vfs_get_dqblk); 2267*884d179dSJan Kara 2268*884d179dSJan Kara /* Generic routine for setting common part of quota structure */ 2269*884d179dSJan Kara static int do_set_dqblk(struct dquot *dquot, struct if_dqblk *di) 2270*884d179dSJan Kara { 2271*884d179dSJan Kara struct mem_dqblk *dm = &dquot->dq_dqb; 2272*884d179dSJan Kara int check_blim = 0, check_ilim = 0; 2273*884d179dSJan Kara struct mem_dqinfo *dqi = &sb_dqopt(dquot->dq_sb)->info[dquot->dq_type]; 2274*884d179dSJan Kara 2275*884d179dSJan Kara if ((di->dqb_valid & QIF_BLIMITS && 2276*884d179dSJan Kara (di->dqb_bhardlimit > dqi->dqi_maxblimit || 2277*884d179dSJan Kara di->dqb_bsoftlimit > dqi->dqi_maxblimit)) || 2278*884d179dSJan Kara (di->dqb_valid & QIF_ILIMITS && 2279*884d179dSJan Kara (di->dqb_ihardlimit > dqi->dqi_maxilimit || 2280*884d179dSJan Kara di->dqb_isoftlimit > dqi->dqi_maxilimit))) 2281*884d179dSJan Kara return -ERANGE; 2282*884d179dSJan Kara 2283*884d179dSJan Kara spin_lock(&dq_data_lock); 2284*884d179dSJan Kara if (di->dqb_valid & QIF_SPACE) { 2285*884d179dSJan Kara dm->dqb_curspace = di->dqb_curspace - dm->dqb_rsvspace; 2286*884d179dSJan Kara check_blim = 1; 2287*884d179dSJan Kara __set_bit(DQ_LASTSET_B + QIF_SPACE_B, &dquot->dq_flags); 2288*884d179dSJan Kara } 2289*884d179dSJan Kara if (di->dqb_valid & QIF_BLIMITS) { 2290*884d179dSJan Kara dm->dqb_bsoftlimit = qbtos(di->dqb_bsoftlimit); 2291*884d179dSJan Kara dm->dqb_bhardlimit = qbtos(di->dqb_bhardlimit); 2292*884d179dSJan Kara check_blim = 1; 2293*884d179dSJan Kara __set_bit(DQ_LASTSET_B + QIF_BLIMITS_B, &dquot->dq_flags); 2294*884d179dSJan Kara } 2295*884d179dSJan Kara if (di->dqb_valid & QIF_INODES) { 2296*884d179dSJan Kara dm->dqb_curinodes = di->dqb_curinodes; 2297*884d179dSJan Kara check_ilim = 1; 2298*884d179dSJan Kara __set_bit(DQ_LASTSET_B + QIF_INODES_B, &dquot->dq_flags); 2299*884d179dSJan Kara } 2300*884d179dSJan Kara if (di->dqb_valid & QIF_ILIMITS) { 2301*884d179dSJan Kara dm->dqb_isoftlimit = di->dqb_isoftlimit; 2302*884d179dSJan Kara dm->dqb_ihardlimit = di->dqb_ihardlimit; 2303*884d179dSJan Kara check_ilim = 1; 2304*884d179dSJan Kara __set_bit(DQ_LASTSET_B + QIF_ILIMITS_B, &dquot->dq_flags); 2305*884d179dSJan Kara } 2306*884d179dSJan Kara if (di->dqb_valid & QIF_BTIME) { 2307*884d179dSJan Kara dm->dqb_btime = di->dqb_btime; 2308*884d179dSJan Kara check_blim = 1; 2309*884d179dSJan Kara __set_bit(DQ_LASTSET_B + QIF_BTIME_B, &dquot->dq_flags); 2310*884d179dSJan Kara } 2311*884d179dSJan Kara if (di->dqb_valid & QIF_ITIME) { 2312*884d179dSJan Kara dm->dqb_itime = di->dqb_itime; 2313*884d179dSJan Kara check_ilim = 1; 2314*884d179dSJan Kara __set_bit(DQ_LASTSET_B + QIF_ITIME_B, &dquot->dq_flags); 2315*884d179dSJan Kara } 2316*884d179dSJan Kara 2317*884d179dSJan Kara if (check_blim) { 2318*884d179dSJan Kara if (!dm->dqb_bsoftlimit || dm->dqb_curspace < dm->dqb_bsoftlimit) { 2319*884d179dSJan Kara dm->dqb_btime = 0; 2320*884d179dSJan Kara clear_bit(DQ_BLKS_B, &dquot->dq_flags); 2321*884d179dSJan Kara } 2322*884d179dSJan Kara else if (!(di->dqb_valid & QIF_BTIME)) /* Set grace only if user hasn't provided his own... */ 2323*884d179dSJan Kara dm->dqb_btime = get_seconds() + dqi->dqi_bgrace; 2324*884d179dSJan Kara } 2325*884d179dSJan Kara if (check_ilim) { 2326*884d179dSJan Kara if (!dm->dqb_isoftlimit || dm->dqb_curinodes < dm->dqb_isoftlimit) { 2327*884d179dSJan Kara dm->dqb_itime = 0; 2328*884d179dSJan Kara clear_bit(DQ_INODES_B, &dquot->dq_flags); 2329*884d179dSJan Kara } 2330*884d179dSJan Kara else if (!(di->dqb_valid & QIF_ITIME)) /* Set grace only if user hasn't provided his own... */ 2331*884d179dSJan Kara dm->dqb_itime = get_seconds() + dqi->dqi_igrace; 2332*884d179dSJan Kara } 2333*884d179dSJan Kara if (dm->dqb_bhardlimit || dm->dqb_bsoftlimit || dm->dqb_ihardlimit || dm->dqb_isoftlimit) 2334*884d179dSJan Kara clear_bit(DQ_FAKE_B, &dquot->dq_flags); 2335*884d179dSJan Kara else 2336*884d179dSJan Kara set_bit(DQ_FAKE_B, &dquot->dq_flags); 2337*884d179dSJan Kara spin_unlock(&dq_data_lock); 2338*884d179dSJan Kara mark_dquot_dirty(dquot); 2339*884d179dSJan Kara 2340*884d179dSJan Kara return 0; 2341*884d179dSJan Kara } 2342*884d179dSJan Kara 2343*884d179dSJan Kara int vfs_set_dqblk(struct super_block *sb, int type, qid_t id, struct if_dqblk *di) 2344*884d179dSJan Kara { 2345*884d179dSJan Kara struct dquot *dquot; 2346*884d179dSJan Kara int rc; 2347*884d179dSJan Kara 2348*884d179dSJan Kara dquot = dqget(sb, id, type); 2349*884d179dSJan Kara if (!dquot) { 2350*884d179dSJan Kara rc = -ESRCH; 2351*884d179dSJan Kara goto out; 2352*884d179dSJan Kara } 2353*884d179dSJan Kara rc = do_set_dqblk(dquot, di); 2354*884d179dSJan Kara dqput(dquot); 2355*884d179dSJan Kara out: 2356*884d179dSJan Kara return rc; 2357*884d179dSJan Kara } 2358*884d179dSJan Kara EXPORT_SYMBOL(vfs_set_dqblk); 2359*884d179dSJan Kara 2360*884d179dSJan Kara /* Generic routine for getting common part of quota file information */ 2361*884d179dSJan Kara int vfs_get_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii) 2362*884d179dSJan Kara { 2363*884d179dSJan Kara struct mem_dqinfo *mi; 2364*884d179dSJan Kara 2365*884d179dSJan Kara mutex_lock(&sb_dqopt(sb)->dqonoff_mutex); 2366*884d179dSJan Kara if (!sb_has_quota_active(sb, type)) { 2367*884d179dSJan Kara mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex); 2368*884d179dSJan Kara return -ESRCH; 2369*884d179dSJan Kara } 2370*884d179dSJan Kara mi = sb_dqopt(sb)->info + type; 2371*884d179dSJan Kara spin_lock(&dq_data_lock); 2372*884d179dSJan Kara ii->dqi_bgrace = mi->dqi_bgrace; 2373*884d179dSJan Kara ii->dqi_igrace = mi->dqi_igrace; 2374*884d179dSJan Kara ii->dqi_flags = mi->dqi_flags & DQF_MASK; 2375*884d179dSJan Kara ii->dqi_valid = IIF_ALL; 2376*884d179dSJan Kara spin_unlock(&dq_data_lock); 2377*884d179dSJan Kara mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex); 2378*884d179dSJan Kara return 0; 2379*884d179dSJan Kara } 2380*884d179dSJan Kara EXPORT_SYMBOL(vfs_get_dqinfo); 2381*884d179dSJan Kara 2382*884d179dSJan Kara /* Generic routine for setting common part of quota file information */ 2383*884d179dSJan Kara int vfs_set_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii) 2384*884d179dSJan Kara { 2385*884d179dSJan Kara struct mem_dqinfo *mi; 2386*884d179dSJan Kara int err = 0; 2387*884d179dSJan Kara 2388*884d179dSJan Kara mutex_lock(&sb_dqopt(sb)->dqonoff_mutex); 2389*884d179dSJan Kara if (!sb_has_quota_active(sb, type)) { 2390*884d179dSJan Kara err = -ESRCH; 2391*884d179dSJan Kara goto out; 2392*884d179dSJan Kara } 2393*884d179dSJan Kara mi = sb_dqopt(sb)->info + type; 2394*884d179dSJan Kara spin_lock(&dq_data_lock); 2395*884d179dSJan Kara if (ii->dqi_valid & IIF_BGRACE) 2396*884d179dSJan Kara mi->dqi_bgrace = ii->dqi_bgrace; 2397*884d179dSJan Kara if (ii->dqi_valid & IIF_IGRACE) 2398*884d179dSJan Kara mi->dqi_igrace = ii->dqi_igrace; 2399*884d179dSJan Kara if (ii->dqi_valid & IIF_FLAGS) 2400*884d179dSJan Kara mi->dqi_flags = (mi->dqi_flags & ~DQF_MASK) | (ii->dqi_flags & DQF_MASK); 2401*884d179dSJan Kara spin_unlock(&dq_data_lock); 2402*884d179dSJan Kara mark_info_dirty(sb, type); 2403*884d179dSJan Kara /* Force write to disk */ 2404*884d179dSJan Kara sb->dq_op->write_info(sb, type); 2405*884d179dSJan Kara out: 2406*884d179dSJan Kara mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex); 2407*884d179dSJan Kara return err; 2408*884d179dSJan Kara } 2409*884d179dSJan Kara EXPORT_SYMBOL(vfs_set_dqinfo); 2410*884d179dSJan Kara 2411*884d179dSJan Kara struct quotactl_ops vfs_quotactl_ops = { 2412*884d179dSJan Kara .quota_on = vfs_quota_on, 2413*884d179dSJan Kara .quota_off = vfs_quota_off, 2414*884d179dSJan Kara .quota_sync = vfs_quota_sync, 2415*884d179dSJan Kara .get_info = vfs_get_dqinfo, 2416*884d179dSJan Kara .set_info = vfs_set_dqinfo, 2417*884d179dSJan Kara .get_dqblk = vfs_get_dqblk, 2418*884d179dSJan Kara .set_dqblk = vfs_set_dqblk 2419*884d179dSJan Kara }; 2420*884d179dSJan Kara 2421*884d179dSJan Kara static ctl_table fs_dqstats_table[] = { 2422*884d179dSJan Kara { 2423*884d179dSJan Kara .ctl_name = FS_DQ_LOOKUPS, 2424*884d179dSJan Kara .procname = "lookups", 2425*884d179dSJan Kara .data = &dqstats.lookups, 2426*884d179dSJan Kara .maxlen = sizeof(int), 2427*884d179dSJan Kara .mode = 0444, 2428*884d179dSJan Kara .proc_handler = &proc_dointvec, 2429*884d179dSJan Kara }, 2430*884d179dSJan Kara { 2431*884d179dSJan Kara .ctl_name = FS_DQ_DROPS, 2432*884d179dSJan Kara .procname = "drops", 2433*884d179dSJan Kara .data = &dqstats.drops, 2434*884d179dSJan Kara .maxlen = sizeof(int), 2435*884d179dSJan Kara .mode = 0444, 2436*884d179dSJan Kara .proc_handler = &proc_dointvec, 2437*884d179dSJan Kara }, 2438*884d179dSJan Kara { 2439*884d179dSJan Kara .ctl_name = FS_DQ_READS, 2440*884d179dSJan Kara .procname = "reads", 2441*884d179dSJan Kara .data = &dqstats.reads, 2442*884d179dSJan Kara .maxlen = sizeof(int), 2443*884d179dSJan Kara .mode = 0444, 2444*884d179dSJan Kara .proc_handler = &proc_dointvec, 2445*884d179dSJan Kara }, 2446*884d179dSJan Kara { 2447*884d179dSJan Kara .ctl_name = FS_DQ_WRITES, 2448*884d179dSJan Kara .procname = "writes", 2449*884d179dSJan Kara .data = &dqstats.writes, 2450*884d179dSJan Kara .maxlen = sizeof(int), 2451*884d179dSJan Kara .mode = 0444, 2452*884d179dSJan Kara .proc_handler = &proc_dointvec, 2453*884d179dSJan Kara }, 2454*884d179dSJan Kara { 2455*884d179dSJan Kara .ctl_name = FS_DQ_CACHE_HITS, 2456*884d179dSJan Kara .procname = "cache_hits", 2457*884d179dSJan Kara .data = &dqstats.cache_hits, 2458*884d179dSJan Kara .maxlen = sizeof(int), 2459*884d179dSJan Kara .mode = 0444, 2460*884d179dSJan Kara .proc_handler = &proc_dointvec, 2461*884d179dSJan Kara }, 2462*884d179dSJan Kara { 2463*884d179dSJan Kara .ctl_name = FS_DQ_ALLOCATED, 2464*884d179dSJan Kara .procname = "allocated_dquots", 2465*884d179dSJan Kara .data = &dqstats.allocated_dquots, 2466*884d179dSJan Kara .maxlen = sizeof(int), 2467*884d179dSJan Kara .mode = 0444, 2468*884d179dSJan Kara .proc_handler = &proc_dointvec, 2469*884d179dSJan Kara }, 2470*884d179dSJan Kara { 2471*884d179dSJan Kara .ctl_name = FS_DQ_FREE, 2472*884d179dSJan Kara .procname = "free_dquots", 2473*884d179dSJan Kara .data = &dqstats.free_dquots, 2474*884d179dSJan Kara .maxlen = sizeof(int), 2475*884d179dSJan Kara .mode = 0444, 2476*884d179dSJan Kara .proc_handler = &proc_dointvec, 2477*884d179dSJan Kara }, 2478*884d179dSJan Kara { 2479*884d179dSJan Kara .ctl_name = FS_DQ_SYNCS, 2480*884d179dSJan Kara .procname = "syncs", 2481*884d179dSJan Kara .data = &dqstats.syncs, 2482*884d179dSJan Kara .maxlen = sizeof(int), 2483*884d179dSJan Kara .mode = 0444, 2484*884d179dSJan Kara .proc_handler = &proc_dointvec, 2485*884d179dSJan Kara }, 2486*884d179dSJan Kara #ifdef CONFIG_PRINT_QUOTA_WARNING 2487*884d179dSJan Kara { 2488*884d179dSJan Kara .ctl_name = FS_DQ_WARNINGS, 2489*884d179dSJan Kara .procname = "warnings", 2490*884d179dSJan Kara .data = &flag_print_warnings, 2491*884d179dSJan Kara .maxlen = sizeof(int), 2492*884d179dSJan Kara .mode = 0644, 2493*884d179dSJan Kara .proc_handler = &proc_dointvec, 2494*884d179dSJan Kara }, 2495*884d179dSJan Kara #endif 2496*884d179dSJan Kara { .ctl_name = 0 }, 2497*884d179dSJan Kara }; 2498*884d179dSJan Kara 2499*884d179dSJan Kara static ctl_table fs_table[] = { 2500*884d179dSJan Kara { 2501*884d179dSJan Kara .ctl_name = FS_DQSTATS, 2502*884d179dSJan Kara .procname = "quota", 2503*884d179dSJan Kara .mode = 0555, 2504*884d179dSJan Kara .child = fs_dqstats_table, 2505*884d179dSJan Kara }, 2506*884d179dSJan Kara { .ctl_name = 0 }, 2507*884d179dSJan Kara }; 2508*884d179dSJan Kara 2509*884d179dSJan Kara static ctl_table sys_table[] = { 2510*884d179dSJan Kara { 2511*884d179dSJan Kara .ctl_name = CTL_FS, 2512*884d179dSJan Kara .procname = "fs", 2513*884d179dSJan Kara .mode = 0555, 2514*884d179dSJan Kara .child = fs_table, 2515*884d179dSJan Kara }, 2516*884d179dSJan Kara { .ctl_name = 0 }, 2517*884d179dSJan Kara }; 2518*884d179dSJan Kara 2519*884d179dSJan Kara static int __init dquot_init(void) 2520*884d179dSJan Kara { 2521*884d179dSJan Kara int i; 2522*884d179dSJan Kara unsigned long nr_hash, order; 2523*884d179dSJan Kara 2524*884d179dSJan Kara printk(KERN_NOTICE "VFS: Disk quotas %s\n", __DQUOT_VERSION__); 2525*884d179dSJan Kara 2526*884d179dSJan Kara register_sysctl_table(sys_table); 2527*884d179dSJan Kara 2528*884d179dSJan Kara dquot_cachep = kmem_cache_create("dquot", 2529*884d179dSJan Kara sizeof(struct dquot), sizeof(unsigned long) * 4, 2530*884d179dSJan Kara (SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT| 2531*884d179dSJan Kara SLAB_MEM_SPREAD|SLAB_PANIC), 2532*884d179dSJan Kara NULL); 2533*884d179dSJan Kara 2534*884d179dSJan Kara order = 0; 2535*884d179dSJan Kara dquot_hash = (struct hlist_head *)__get_free_pages(GFP_ATOMIC, order); 2536*884d179dSJan Kara if (!dquot_hash) 2537*884d179dSJan Kara panic("Cannot create dquot hash table"); 2538*884d179dSJan Kara 2539*884d179dSJan Kara /* Find power-of-two hlist_heads which can fit into allocation */ 2540*884d179dSJan Kara nr_hash = (1UL << order) * PAGE_SIZE / sizeof(struct hlist_head); 2541*884d179dSJan Kara dq_hash_bits = 0; 2542*884d179dSJan Kara do { 2543*884d179dSJan Kara dq_hash_bits++; 2544*884d179dSJan Kara } while (nr_hash >> dq_hash_bits); 2545*884d179dSJan Kara dq_hash_bits--; 2546*884d179dSJan Kara 2547*884d179dSJan Kara nr_hash = 1UL << dq_hash_bits; 2548*884d179dSJan Kara dq_hash_mask = nr_hash - 1; 2549*884d179dSJan Kara for (i = 0; i < nr_hash; i++) 2550*884d179dSJan Kara INIT_HLIST_HEAD(dquot_hash + i); 2551*884d179dSJan Kara 2552*884d179dSJan Kara printk("Dquot-cache hash table entries: %ld (order %ld, %ld bytes)\n", 2553*884d179dSJan Kara nr_hash, order, (PAGE_SIZE << order)); 2554*884d179dSJan Kara 2555*884d179dSJan Kara register_shrinker(&dqcache_shrinker); 2556*884d179dSJan Kara 2557*884d179dSJan Kara #ifdef CONFIG_QUOTA_NETLINK_INTERFACE 2558*884d179dSJan Kara if (genl_register_family("a_genl_family) != 0) 2559*884d179dSJan Kara printk(KERN_ERR "VFS: Failed to create quota netlink interface.\n"); 2560*884d179dSJan Kara #endif 2561*884d179dSJan Kara 2562*884d179dSJan Kara return 0; 2563*884d179dSJan Kara } 2564*884d179dSJan Kara module_init(dquot_init); 2565