~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/quota/dquot.c

Version: ~ [ linux-5.8 ] ~ [ linux-5.7.12 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.55 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.136 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.191 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.232 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.232 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp