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