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