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