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