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