linux/fs/xfs/xfs_dquot.c
<<
>>
Prefs
   1/*
   2 * Copyright (c) 2000-2003 Silicon Graphics, Inc.
   3 * All Rights Reserved.
   4 *
   5 * This program is free software; you can redistribute it and/or
   6 * modify it under the terms of the GNU General Public License as
   7 * published by the Free Software Foundation.
   8 *
   9 * This program is distributed in the hope that it would be useful,
  10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 * GNU General Public License for more details.
  13 *
  14 * You should have received a copy of the GNU General Public License
  15 * along with this program; if not, write the Free Software Foundation,
  16 * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  17 */
  18#include "xfs.h"
  19#include "xfs_fs.h"
  20#include "xfs_bit.h"
  21#include "xfs_log.h"
  22#include "xfs_trans.h"
  23#include "xfs_sb.h"
  24#include "xfs_ag.h"
  25#include "xfs_alloc.h"
  26#include "xfs_quota.h"
  27#include "xfs_mount.h"
  28#include "xfs_bmap_btree.h"
  29#include "xfs_inode.h"
  30#include "xfs_bmap.h"
  31#include "xfs_rtalloc.h"
  32#include "xfs_error.h"
  33#include "xfs_itable.h"
  34#include "xfs_attr.h"
  35#include "xfs_buf_item.h"
  36#include "xfs_trans_space.h"
  37#include "xfs_trans_priv.h"
  38#include "xfs_qm.h"
  39#include "xfs_cksum.h"
  40#include "xfs_trace.h"
  41
  42/*
  43 * Lock order:
  44 *
  45 * ip->i_lock
  46 *   qi->qi_tree_lock
  47 *     dquot->q_qlock (xfs_dqlock() and friends)
  48 *       dquot->q_flush (xfs_dqflock() and friends)
  49 *       qi->qi_lru_lock
  50 *
  51 * If two dquots need to be locked the order is user before group/project,
  52 * otherwise by the lowest id first, see xfs_dqlock2.
  53 */
  54
  55#ifdef DEBUG
  56xfs_buftarg_t *xfs_dqerror_target;
  57int xfs_do_dqerror;
  58int xfs_dqreq_num;
  59int xfs_dqerror_mod = 33;
  60#endif
  61
  62struct kmem_zone                *xfs_qm_dqtrxzone;
  63static struct kmem_zone         *xfs_qm_dqzone;
  64
  65static struct lock_class_key xfs_dquot_other_class;
  66
  67/*
  68 * This is called to free all the memory associated with a dquot
  69 */
  70void
  71xfs_qm_dqdestroy(
  72        xfs_dquot_t     *dqp)
  73{
  74        ASSERT(list_empty(&dqp->q_lru));
  75
  76        mutex_destroy(&dqp->q_qlock);
  77        kmem_zone_free(xfs_qm_dqzone, dqp);
  78
  79        XFS_STATS_DEC(xs_qm_dquot);
  80}
  81
  82/*
  83 * If default limits are in force, push them into the dquot now.
  84 * We overwrite the dquot limits only if they are zero and this
  85 * is not the root dquot.
  86 */
  87void
  88xfs_qm_adjust_dqlimits(
  89        struct xfs_mount        *mp,
  90        struct xfs_dquot        *dq)
  91{
  92        struct xfs_quotainfo    *q = mp->m_quotainfo;
  93        struct xfs_disk_dquot   *d = &dq->q_core;
  94        int                     prealloc = 0;
  95
  96        ASSERT(d->d_id);
  97
  98        if (q->qi_bsoftlimit && !d->d_blk_softlimit) {
  99                d->d_blk_softlimit = cpu_to_be64(q->qi_bsoftlimit);
 100                prealloc = 1;
 101        }
 102        if (q->qi_bhardlimit && !d->d_blk_hardlimit) {
 103                d->d_blk_hardlimit = cpu_to_be64(q->qi_bhardlimit);
 104                prealloc = 1;
 105        }
 106        if (q->qi_isoftlimit && !d->d_ino_softlimit)
 107                d->d_ino_softlimit = cpu_to_be64(q->qi_isoftlimit);
 108        if (q->qi_ihardlimit && !d->d_ino_hardlimit)
 109                d->d_ino_hardlimit = cpu_to_be64(q->qi_ihardlimit);
 110        if (q->qi_rtbsoftlimit && !d->d_rtb_softlimit)
 111                d->d_rtb_softlimit = cpu_to_be64(q->qi_rtbsoftlimit);
 112        if (q->qi_rtbhardlimit && !d->d_rtb_hardlimit)
 113                d->d_rtb_hardlimit = cpu_to_be64(q->qi_rtbhardlimit);
 114
 115        if (prealloc)
 116                xfs_dquot_set_prealloc_limits(dq);
 117}
 118
 119/*
 120 * Check the limits and timers of a dquot and start or reset timers
 121 * if necessary.
 122 * This gets called even when quota enforcement is OFF, which makes our
 123 * life a little less complicated. (We just don't reject any quota
 124 * reservations in that case, when enforcement is off).
 125 * We also return 0 as the values of the timers in Q_GETQUOTA calls, when
 126 * enforcement's off.
 127 * In contrast, warnings are a little different in that they don't
 128 * 'automatically' get started when limits get exceeded.  They do
 129 * get reset to zero, however, when we find the count to be under
 130 * the soft limit (they are only ever set non-zero via userspace).
 131 */
 132void
 133xfs_qm_adjust_dqtimers(
 134        xfs_mount_t             *mp,
 135        xfs_disk_dquot_t        *d)
 136{
 137        ASSERT(d->d_id);
 138
 139#ifdef DEBUG
 140        if (d->d_blk_hardlimit)
 141                ASSERT(be64_to_cpu(d->d_blk_softlimit) <=
 142                       be64_to_cpu(d->d_blk_hardlimit));
 143        if (d->d_ino_hardlimit)
 144                ASSERT(be64_to_cpu(d->d_ino_softlimit) <=
 145                       be64_to_cpu(d->d_ino_hardlimit));
 146        if (d->d_rtb_hardlimit)
 147                ASSERT(be64_to_cpu(d->d_rtb_softlimit) <=
 148                       be64_to_cpu(d->d_rtb_hardlimit));
 149#endif
 150
 151        if (!d->d_btimer) {
 152                if ((d->d_blk_softlimit &&
 153                     (be64_to_cpu(d->d_bcount) >
 154                      be64_to_cpu(d->d_blk_softlimit))) ||
 155                    (d->d_blk_hardlimit &&
 156                     (be64_to_cpu(d->d_bcount) >
 157                      be64_to_cpu(d->d_blk_hardlimit)))) {
 158                        d->d_btimer = cpu_to_be32(get_seconds() +
 159                                        mp->m_quotainfo->qi_btimelimit);
 160                } else {
 161                        d->d_bwarns = 0;
 162                }
 163        } else {
 164                if ((!d->d_blk_softlimit ||
 165                     (be64_to_cpu(d->d_bcount) <=
 166                      be64_to_cpu(d->d_blk_softlimit))) &&
 167                    (!d->d_blk_hardlimit ||
 168                    (be64_to_cpu(d->d_bcount) <=
 169                     be64_to_cpu(d->d_blk_hardlimit)))) {
 170                        d->d_btimer = 0;
 171                }
 172        }
 173
 174        if (!d->d_itimer) {
 175                if ((d->d_ino_softlimit &&
 176                     (be64_to_cpu(d->d_icount) >
 177                      be64_to_cpu(d->d_ino_softlimit))) ||
 178                    (d->d_ino_hardlimit &&
 179                     (be64_to_cpu(d->d_icount) >
 180                      be64_to_cpu(d->d_ino_hardlimit)))) {
 181                        d->d_itimer = cpu_to_be32(get_seconds() +
 182                                        mp->m_quotainfo->qi_itimelimit);
 183                } else {
 184                        d->d_iwarns = 0;
 185                }
 186        } else {
 187                if ((!d->d_ino_softlimit ||
 188                     (be64_to_cpu(d->d_icount) <=
 189                      be64_to_cpu(d->d_ino_softlimit)))  &&
 190                    (!d->d_ino_hardlimit ||
 191                     (be64_to_cpu(d->d_icount) <=
 192                      be64_to_cpu(d->d_ino_hardlimit)))) {
 193                        d->d_itimer = 0;
 194                }
 195        }
 196
 197        if (!d->d_rtbtimer) {
 198                if ((d->d_rtb_softlimit &&
 199                     (be64_to_cpu(d->d_rtbcount) >
 200                      be64_to_cpu(d->d_rtb_softlimit))) ||
 201                    (d->d_rtb_hardlimit &&
 202                     (be64_to_cpu(d->d_rtbcount) >
 203                      be64_to_cpu(d->d_rtb_hardlimit)))) {
 204                        d->d_rtbtimer = cpu_to_be32(get_seconds() +
 205                                        mp->m_quotainfo->qi_rtbtimelimit);
 206                } else {
 207                        d->d_rtbwarns = 0;
 208                }
 209        } else {
 210                if ((!d->d_rtb_softlimit ||
 211                     (be64_to_cpu(d->d_rtbcount) <=
 212                      be64_to_cpu(d->d_rtb_softlimit))) &&
 213                    (!d->d_rtb_hardlimit ||
 214                     (be64_to_cpu(d->d_rtbcount) <=
 215                      be64_to_cpu(d->d_rtb_hardlimit)))) {
 216                        d->d_rtbtimer = 0;
 217                }
 218        }
 219}
 220
 221/*
 222 * initialize a buffer full of dquots and log the whole thing
 223 */
 224STATIC void
 225xfs_qm_init_dquot_blk(
 226        xfs_trans_t     *tp,
 227        xfs_mount_t     *mp,
 228        xfs_dqid_t      id,
 229        uint            type,
 230        xfs_buf_t       *bp)
 231{
 232        struct xfs_quotainfo    *q = mp->m_quotainfo;
 233        xfs_dqblk_t     *d;
 234        int             curid, i;
 235
 236        ASSERT(tp);
 237        ASSERT(xfs_buf_islocked(bp));
 238
 239        d = bp->b_addr;
 240
 241        /*
 242         * ID of the first dquot in the block - id's are zero based.
 243         */
 244        curid = id - (id % q->qi_dqperchunk);
 245        ASSERT(curid >= 0);
 246        memset(d, 0, BBTOB(q->qi_dqchunklen));
 247        for (i = 0; i < q->qi_dqperchunk; i++, d++, curid++) {
 248                d->dd_diskdq.d_magic = cpu_to_be16(XFS_DQUOT_MAGIC);
 249                d->dd_diskdq.d_version = XFS_DQUOT_VERSION;
 250                d->dd_diskdq.d_id = cpu_to_be32(curid);
 251                d->dd_diskdq.d_flags = type;
 252                if (xfs_sb_version_hascrc(&mp->m_sb)) {
 253                        uuid_copy(&d->dd_uuid, &mp->m_sb.sb_uuid);
 254                        xfs_update_cksum((char *)d, sizeof(struct xfs_dqblk),
 255                                         XFS_DQUOT_CRC_OFF);
 256                }
 257        }
 258
 259        xfs_trans_dquot_buf(tp, bp,
 260                            (type & XFS_DQ_USER ? XFS_BLF_UDQUOT_BUF :
 261                            ((type & XFS_DQ_PROJ) ? XFS_BLF_PDQUOT_BUF :
 262                             XFS_BLF_GDQUOT_BUF)));
 263        xfs_trans_log_buf(tp, bp, 0, BBTOB(q->qi_dqchunklen) - 1);
 264}
 265
 266/*
 267 * Initialize the dynamic speculative preallocation thresholds. The lo/hi
 268 * watermarks correspond to the soft and hard limits by default. If a soft limit
 269 * is not specified, we use 95% of the hard limit.
 270 */
 271void
 272xfs_dquot_set_prealloc_limits(struct xfs_dquot *dqp)
 273{
 274        __uint64_t space;
 275
 276        dqp->q_prealloc_hi_wmark = be64_to_cpu(dqp->q_core.d_blk_hardlimit);
 277        dqp->q_prealloc_lo_wmark = be64_to_cpu(dqp->q_core.d_blk_softlimit);
 278        if (!dqp->q_prealloc_lo_wmark) {
 279                dqp->q_prealloc_lo_wmark = dqp->q_prealloc_hi_wmark;
 280                do_div(dqp->q_prealloc_lo_wmark, 100);
 281                dqp->q_prealloc_lo_wmark *= 95;
 282        }
 283
 284        space = dqp->q_prealloc_hi_wmark;
 285
 286        do_div(space, 100);
 287        dqp->q_low_space[XFS_QLOWSP_1_PCNT] = space;
 288        dqp->q_low_space[XFS_QLOWSP_3_PCNT] = space * 3;
 289        dqp->q_low_space[XFS_QLOWSP_5_PCNT] = space * 5;
 290}
 291
 292STATIC bool
 293xfs_dquot_buf_verify_crc(
 294        struct xfs_mount        *mp,
 295        struct xfs_buf          *bp)
 296{
 297        struct xfs_dqblk        *d = (struct xfs_dqblk *)bp->b_addr;
 298        int                     ndquots;
 299        int                     i;
 300
 301        if (!xfs_sb_version_hascrc(&mp->m_sb))
 302                return true;
 303
 304        /*
 305         * if we are in log recovery, the quota subsystem has not been
 306         * initialised so we have no quotainfo structure. In that case, we need
 307         * to manually calculate the number of dquots in the buffer.
 308         */
 309        if (mp->m_quotainfo)
 310                ndquots = mp->m_quotainfo->qi_dqperchunk;
 311        else
 312                ndquots = xfs_qm_calc_dquots_per_chunk(mp,
 313                                        XFS_BB_TO_FSB(mp, bp->b_length));
 314
 315        for (i = 0; i < ndquots; i++, d++) {
 316                if (!xfs_verify_cksum((char *)d, sizeof(struct xfs_dqblk),
 317                                 XFS_DQUOT_CRC_OFF))
 318                        return false;
 319                if (!uuid_equal(&d->dd_uuid, &mp->m_sb.sb_uuid))
 320                        return false;
 321        }
 322        return true;
 323}
 324
 325STATIC bool
 326xfs_dquot_buf_verify(
 327        struct xfs_mount        *mp,
 328        struct xfs_buf          *bp)
 329{
 330        struct xfs_dqblk        *d = (struct xfs_dqblk *)bp->b_addr;
 331        xfs_dqid_t              id = 0;
 332        int                     ndquots;
 333        int                     i;
 334
 335        /*
 336         * if we are in log recovery, the quota subsystem has not been
 337         * initialised so we have no quotainfo structure. In that case, we need
 338         * to manually calculate the number of dquots in the buffer.
 339         */
 340        if (mp->m_quotainfo)
 341                ndquots = mp->m_quotainfo->qi_dqperchunk;
 342        else
 343                ndquots = xfs_qm_calc_dquots_per_chunk(mp, bp->b_length);
 344
 345        /*
 346         * On the first read of the buffer, verify that each dquot is valid.
 347         * We don't know what the id of the dquot is supposed to be, just that
 348         * they should be increasing monotonically within the buffer. If the
 349         * first id is corrupt, then it will fail on the second dquot in the
 350         * buffer so corruptions could point to the wrong dquot in this case.
 351         */
 352        for (i = 0; i < ndquots; i++) {
 353                struct xfs_disk_dquot   *ddq;
 354                int                     error;
 355
 356                ddq = &d[i].dd_diskdq;
 357
 358                if (i == 0)
 359                        id = be32_to_cpu(ddq->d_id);
 360
 361                error = xfs_qm_dqcheck(mp, ddq, id + i, 0, XFS_QMOPT_DOWARN,
 362                                       "xfs_dquot_buf_verify");
 363                if (error)
 364                        return false;
 365        }
 366        return true;
 367}
 368
 369static void
 370xfs_dquot_buf_read_verify(
 371        struct xfs_buf  *bp)
 372{
 373        struct xfs_mount        *mp = bp->b_target->bt_mount;
 374
 375        if (!xfs_dquot_buf_verify_crc(mp, bp) || !xfs_dquot_buf_verify(mp, bp)) {
 376                XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, bp->b_addr);
 377                xfs_buf_ioerror(bp, EFSCORRUPTED);
 378        }
 379}
 380
 381/*
 382 * we don't calculate the CRC here as that is done when the dquot is flushed to
 383 * the buffer after the update is done. This ensures that the dquot in the
 384 * buffer always has an up-to-date CRC value.
 385 */
 386void
 387xfs_dquot_buf_write_verify(
 388        struct xfs_buf  *bp)
 389{
 390        struct xfs_mount        *mp = bp->b_target->bt_mount;
 391
 392        if (!xfs_dquot_buf_verify(mp, bp)) {
 393                XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, bp->b_addr);
 394                xfs_buf_ioerror(bp, EFSCORRUPTED);
 395                return;
 396        }
 397}
 398
 399const struct xfs_buf_ops xfs_dquot_buf_ops = {
 400        .verify_read = xfs_dquot_buf_read_verify,
 401        .verify_write = xfs_dquot_buf_write_verify,
 402};
 403
 404/*
 405 * Allocate a block and fill it with dquots.
 406 * This is called when the bmapi finds a hole.
 407 */
 408STATIC int
 409xfs_qm_dqalloc(
 410        xfs_trans_t     **tpp,
 411        xfs_mount_t     *mp,
 412        xfs_dquot_t     *dqp,
 413        xfs_inode_t     *quotip,
 414        xfs_fileoff_t   offset_fsb,
 415        xfs_buf_t       **O_bpp)
 416{
 417        xfs_fsblock_t   firstblock;
 418        xfs_bmap_free_t flist;
 419        xfs_bmbt_irec_t map;
 420        int             nmaps, error, committed;
 421        xfs_buf_t       *bp;
 422        xfs_trans_t     *tp = *tpp;
 423
 424        ASSERT(tp != NULL);
 425
 426        trace_xfs_dqalloc(dqp);
 427
 428        /*
 429         * Initialize the bmap freelist prior to calling bmapi code.
 430         */
 431        xfs_bmap_init(&flist, &firstblock);
 432        xfs_ilock(quotip, XFS_ILOCK_EXCL);
 433        /*
 434         * Return if this type of quotas is turned off while we didn't
 435         * have an inode lock
 436         */
 437        if (!xfs_this_quota_on(dqp->q_mount, dqp->dq_flags)) {
 438                xfs_iunlock(quotip, XFS_ILOCK_EXCL);
 439                return (ESRCH);
 440        }
 441
 442        xfs_trans_ijoin(tp, quotip, XFS_ILOCK_EXCL);
 443        nmaps = 1;
 444        error = xfs_bmapi_write(tp, quotip, offset_fsb,
 445                                XFS_DQUOT_CLUSTER_SIZE_FSB, XFS_BMAPI_METADATA,
 446                                &firstblock, XFS_QM_DQALLOC_SPACE_RES(mp),
 447                                &map, &nmaps, &flist);
 448        if (error)
 449                goto error0;
 450        ASSERT(map.br_blockcount == XFS_DQUOT_CLUSTER_SIZE_FSB);
 451        ASSERT(nmaps == 1);
 452        ASSERT((map.br_startblock != DELAYSTARTBLOCK) &&
 453               (map.br_startblock != HOLESTARTBLOCK));
 454
 455        /*
 456         * Keep track of the blkno to save a lookup later
 457         */
 458        dqp->q_blkno = XFS_FSB_TO_DADDR(mp, map.br_startblock);
 459
 460        /* now we can just get the buffer (there's nothing to read yet) */
 461        bp = xfs_trans_get_buf(tp, mp->m_ddev_targp,
 462                               dqp->q_blkno,
 463                               mp->m_quotainfo->qi_dqchunklen,
 464                               0);
 465
 466        error = xfs_buf_geterror(bp);
 467        if (error)
 468                goto error1;
 469        bp->b_ops = &xfs_dquot_buf_ops;
 470
 471        /*
 472         * Make a chunk of dquots out of this buffer and log
 473         * the entire thing.
 474         */
 475        xfs_qm_init_dquot_blk(tp, mp, be32_to_cpu(dqp->q_core.d_id),
 476                              dqp->dq_flags & XFS_DQ_ALLTYPES, bp);
 477
 478        /*
 479         * xfs_bmap_finish() may commit the current transaction and
 480         * start a second transaction if the freelist is not empty.
 481         *
 482         * Since we still want to modify this buffer, we need to
 483         * ensure that the buffer is not released on commit of
 484         * the first transaction and ensure the buffer is added to the
 485         * second transaction.
 486         *
 487         * If there is only one transaction then don't stop the buffer
 488         * from being released when it commits later on.
 489         */
 490
 491        xfs_trans_bhold(tp, bp);
 492
 493        if ((error = xfs_bmap_finish(tpp, &flist, &committed))) {
 494                goto error1;
 495        }
 496
 497        if (committed) {
 498                tp = *tpp;
 499                xfs_trans_bjoin(tp, bp);
 500        } else {
 501                xfs_trans_bhold_release(tp, bp);
 502        }
 503
 504        *O_bpp = bp;
 505        return 0;
 506
 507      error1:
 508        xfs_bmap_cancel(&flist);
 509      error0:
 510        xfs_iunlock(quotip, XFS_ILOCK_EXCL);
 511
 512        return (error);
 513}
 514STATIC int
 515xfs_qm_dqrepair(
 516        struct xfs_mount        *mp,
 517        struct xfs_trans        *tp,
 518        struct xfs_dquot        *dqp,
 519        xfs_dqid_t              firstid,
 520        struct xfs_buf          **bpp)
 521{
 522        int                     error;
 523        struct xfs_disk_dquot   *ddq;
 524        struct xfs_dqblk        *d;
 525        int                     i;
 526
 527        /*
 528         * Read the buffer without verification so we get the corrupted
 529         * buffer returned to us. make sure we verify it on write, though.
 530         */
 531        error = xfs_trans_read_buf(mp, tp, mp->m_ddev_targp, dqp->q_blkno,
 532                                   mp->m_quotainfo->qi_dqchunklen,
 533                                   0, bpp, NULL);
 534
 535        if (error) {
 536                ASSERT(*bpp == NULL);
 537                return XFS_ERROR(error);
 538        }
 539        (*bpp)->b_ops = &xfs_dquot_buf_ops;
 540
 541        ASSERT(xfs_buf_islocked(*bpp));
 542        d = (struct xfs_dqblk *)(*bpp)->b_addr;
 543
 544        /* Do the actual repair of dquots in this buffer */
 545        for (i = 0; i < mp->m_quotainfo->qi_dqperchunk; i++) {
 546                ddq = &d[i].dd_diskdq;
 547                error = xfs_qm_dqcheck(mp, ddq, firstid + i,
 548                                       dqp->dq_flags & XFS_DQ_ALLTYPES,
 549                                       XFS_QMOPT_DQREPAIR, "xfs_qm_dqrepair");
 550                if (error) {
 551                        /* repair failed, we're screwed */
 552                        xfs_trans_brelse(tp, *bpp);
 553                        return XFS_ERROR(EIO);
 554                }
 555        }
 556
 557        return 0;
 558}
 559
 560/*
 561 * Maps a dquot to the buffer containing its on-disk version.
 562 * This returns a ptr to the buffer containing the on-disk dquot
 563 * in the bpp param, and a ptr to the on-disk dquot within that buffer
 564 */
 565STATIC int
 566xfs_qm_dqtobp(
 567        xfs_trans_t             **tpp,
 568        xfs_dquot_t             *dqp,
 569        xfs_disk_dquot_t        **O_ddpp,
 570        xfs_buf_t               **O_bpp,
 571        uint                    flags)
 572{
 573        struct xfs_bmbt_irec    map;
 574        int                     nmaps = 1, error;
 575        struct xfs_buf          *bp;
 576        struct xfs_inode        *quotip = xfs_dq_to_quota_inode(dqp);
 577        struct xfs_mount        *mp = dqp->q_mount;
 578        xfs_dqid_t              id = be32_to_cpu(dqp->q_core.d_id);
 579        struct xfs_trans        *tp = (tpp ? *tpp : NULL);
 580
 581        dqp->q_fileoffset = (xfs_fileoff_t)id / mp->m_quotainfo->qi_dqperchunk;
 582
 583        xfs_ilock(quotip, XFS_ILOCK_SHARED);
 584        if (!xfs_this_quota_on(dqp->q_mount, dqp->dq_flags)) {
 585                /*
 586                 * Return if this type of quotas is turned off while we
 587                 * didn't have the quota inode lock.
 588                 */
 589                xfs_iunlock(quotip, XFS_ILOCK_SHARED);
 590                return ESRCH;
 591        }
 592
 593        /*
 594         * Find the block map; no allocations yet
 595         */
 596        error = xfs_bmapi_read(quotip, dqp->q_fileoffset,
 597                               XFS_DQUOT_CLUSTER_SIZE_FSB, &map, &nmaps, 0);
 598
 599        xfs_iunlock(quotip, XFS_ILOCK_SHARED);
 600        if (error)
 601                return error;
 602
 603        ASSERT(nmaps == 1);
 604        ASSERT(map.br_blockcount == 1);
 605
 606        /*
 607         * Offset of dquot in the (fixed sized) dquot chunk.
 608         */
 609        dqp->q_bufoffset = (id % mp->m_quotainfo->qi_dqperchunk) *
 610                sizeof(xfs_dqblk_t);
 611
 612        ASSERT(map.br_startblock != DELAYSTARTBLOCK);
 613        if (map.br_startblock == HOLESTARTBLOCK) {
 614                /*
 615                 * We don't allocate unless we're asked to
 616                 */
 617                if (!(flags & XFS_QMOPT_DQALLOC))
 618                        return ENOENT;
 619
 620                ASSERT(tp);
 621                error = xfs_qm_dqalloc(tpp, mp, dqp, quotip,
 622                                        dqp->q_fileoffset, &bp);
 623                if (error)
 624                        return error;
 625                tp = *tpp;
 626        } else {
 627                trace_xfs_dqtobp_read(dqp);
 628
 629                /*
 630                 * store the blkno etc so that we don't have to do the
 631                 * mapping all the time
 632                 */
 633                dqp->q_blkno = XFS_FSB_TO_DADDR(mp, map.br_startblock);
 634
 635                error = xfs_trans_read_buf(mp, tp, mp->m_ddev_targp,
 636                                           dqp->q_blkno,
 637                                           mp->m_quotainfo->qi_dqchunklen,
 638                                           0, &bp, &xfs_dquot_buf_ops);
 639
 640                if (error == EFSCORRUPTED && (flags & XFS_QMOPT_DQREPAIR)) {
 641                        xfs_dqid_t firstid = (xfs_dqid_t)map.br_startoff *
 642                                                mp->m_quotainfo->qi_dqperchunk;
 643                        ASSERT(bp == NULL);
 644                        error = xfs_qm_dqrepair(mp, tp, dqp, firstid, &bp);
 645                }
 646
 647                if (error) {
 648                        ASSERT(bp == NULL);
 649                        return XFS_ERROR(error);
 650                }
 651        }
 652
 653        ASSERT(xfs_buf_islocked(bp));
 654        *O_bpp = bp;
 655        *O_ddpp = bp->b_addr + dqp->q_bufoffset;
 656
 657        return (0);
 658}
 659
 660
 661/*
 662 * Read in the ondisk dquot using dqtobp() then copy it to an incore version,
 663 * and release the buffer immediately.
 664 *
 665 * If XFS_QMOPT_DQALLOC is set, allocate a dquot on disk if it needed.
 666 */
 667int
 668xfs_qm_dqread(
 669        struct xfs_mount        *mp,
 670        xfs_dqid_t              id,
 671        uint                    type,
 672        uint                    flags,
 673        struct xfs_dquot        **O_dqpp)
 674{
 675        struct xfs_dquot        *dqp;
 676        struct xfs_disk_dquot   *ddqp;
 677        struct xfs_buf          *bp;
 678        struct xfs_trans        *tp = NULL;
 679        int                     error;
 680        int                     cancelflags = 0;
 681
 682
 683        dqp = kmem_zone_zalloc(xfs_qm_dqzone, KM_SLEEP);
 684
 685        dqp->dq_flags = type;
 686        dqp->q_core.d_id = cpu_to_be32(id);
 687        dqp->q_mount = mp;
 688        INIT_LIST_HEAD(&dqp->q_lru);
 689        mutex_init(&dqp->q_qlock);
 690        init_waitqueue_head(&dqp->q_pinwait);
 691
 692        /*
 693         * Because we want to use a counting completion, complete
 694         * the flush completion once to allow a single access to
 695         * the flush completion without blocking.
 696         */
 697        init_completion(&dqp->q_flush);
 698        complete(&dqp->q_flush);
 699
 700        /*
 701         * Make sure group quotas have a different lock class than user
 702         * quotas.
 703         */
 704        if (!(type & XFS_DQ_USER))
 705                lockdep_set_class(&dqp->q_qlock, &xfs_dquot_other_class);
 706
 707        XFS_STATS_INC(xs_qm_dquot);
 708
 709        trace_xfs_dqread(dqp);
 710
 711        if (flags & XFS_QMOPT_DQALLOC) {
 712                tp = xfs_trans_alloc(mp, XFS_TRANS_QM_DQALLOC);
 713                error = xfs_trans_reserve(tp, XFS_QM_DQALLOC_SPACE_RES(mp),
 714                                          XFS_QM_DQALLOC_LOG_RES(mp), 0,
 715                                          XFS_TRANS_PERM_LOG_RES,
 716                                          XFS_WRITE_LOG_COUNT);
 717                if (error)
 718                        goto error1;
 719                cancelflags = XFS_TRANS_RELEASE_LOG_RES;
 720        }
 721
 722        /*
 723         * get a pointer to the on-disk dquot and the buffer containing it
 724         * dqp already knows its own type (GROUP/USER).
 725         */
 726        error = xfs_qm_dqtobp(&tp, dqp, &ddqp, &bp, flags);
 727        if (error) {
 728                /*
 729                 * This can happen if quotas got turned off (ESRCH),
 730                 * or if the dquot didn't exist on disk and we ask to
 731                 * allocate (ENOENT).
 732                 */
 733                trace_xfs_dqread_fail(dqp);
 734                cancelflags |= XFS_TRANS_ABORT;
 735                goto error1;
 736        }
 737
 738        /* copy everything from disk dquot to the incore dquot */
 739        memcpy(&dqp->q_core, ddqp, sizeof(xfs_disk_dquot_t));
 740        xfs_qm_dquot_logitem_init(dqp);
 741
 742        /*
 743         * Reservation counters are defined as reservation plus current usage
 744         * to avoid having to add every time.
 745         */
 746        dqp->q_res_bcount = be64_to_cpu(ddqp->d_bcount);
 747        dqp->q_res_icount = be64_to_cpu(ddqp->d_icount);
 748        dqp->q_res_rtbcount = be64_to_cpu(ddqp->d_rtbcount);
 749
 750        /* initialize the dquot speculative prealloc thresholds */
 751        xfs_dquot_set_prealloc_limits(dqp);
 752
 753        /* Mark the buf so that this will stay incore a little longer */
 754        xfs_buf_set_ref(bp, XFS_DQUOT_REF);
 755
 756        /*
 757         * We got the buffer with a xfs_trans_read_buf() (in dqtobp())
 758         * So we need to release with xfs_trans_brelse().
 759         * The strategy here is identical to that of inodes; we lock
 760         * the dquot in xfs_qm_dqget() before making it accessible to
 761         * others. This is because dquots, like inodes, need a good level of
 762         * concurrency, and we don't want to take locks on the entire buffers
 763         * for dquot accesses.
 764         * Note also that the dquot buffer may even be dirty at this point, if
 765         * this particular dquot was repaired. We still aren't afraid to
 766         * brelse it because we have the changes incore.
 767         */
 768        ASSERT(xfs_buf_islocked(bp));
 769        xfs_trans_brelse(tp, bp);
 770
 771        if (tp) {
 772                error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
 773                if (error)
 774                        goto error0;
 775        }
 776
 777        *O_dqpp = dqp;
 778        return error;
 779
 780error1:
 781        if (tp)
 782                xfs_trans_cancel(tp, cancelflags);
 783error0:
 784        xfs_qm_dqdestroy(dqp);
 785        *O_dqpp = NULL;
 786        return error;
 787}
 788
 789/*
 790 * Given the file system, inode OR id, and type (UDQUOT/GDQUOT), return a
 791 * a locked dquot, doing an allocation (if requested) as needed.
 792 * When both an inode and an id are given, the inode's id takes precedence.
 793 * That is, if the id changes while we don't hold the ilock inside this
 794 * function, the new dquot is returned, not necessarily the one requested
 795 * in the id argument.
 796 */
 797int
 798xfs_qm_dqget(
 799        xfs_mount_t     *mp,
 800        xfs_inode_t     *ip,      /* locked inode (optional) */
 801        xfs_dqid_t      id,       /* uid/projid/gid depending on type */
 802        uint            type,     /* XFS_DQ_USER/XFS_DQ_PROJ/XFS_DQ_GROUP */
 803        uint            flags,    /* DQALLOC, DQSUSER, DQREPAIR, DOWARN */
 804        xfs_dquot_t     **O_dqpp) /* OUT : locked incore dquot */
 805{
 806        struct xfs_quotainfo    *qi = mp->m_quotainfo;
 807        struct radix_tree_root *tree = xfs_dquot_tree(qi, type);
 808        struct xfs_dquot        *dqp;
 809        int                     error;
 810
 811        ASSERT(XFS_IS_QUOTA_RUNNING(mp));
 812        if ((! XFS_IS_UQUOTA_ON(mp) && type == XFS_DQ_USER) ||
 813            (! XFS_IS_PQUOTA_ON(mp) && type == XFS_DQ_PROJ) ||
 814            (! XFS_IS_GQUOTA_ON(mp) && type == XFS_DQ_GROUP)) {
 815                return (ESRCH);
 816        }
 817
 818#ifdef DEBUG
 819        if (xfs_do_dqerror) {
 820                if ((xfs_dqerror_target == mp->m_ddev_targp) &&
 821                    (xfs_dqreq_num++ % xfs_dqerror_mod) == 0) {
 822                        xfs_debug(mp, "Returning error in dqget");
 823                        return (EIO);
 824                }
 825        }
 826
 827        ASSERT(type == XFS_DQ_USER ||
 828               type == XFS_DQ_PROJ ||
 829               type == XFS_DQ_GROUP);
 830        if (ip) {
 831                ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
 832                ASSERT(xfs_inode_dquot(ip, type) == NULL);
 833        }
 834#endif
 835
 836restart:
 837        mutex_lock(&qi->qi_tree_lock);
 838        dqp = radix_tree_lookup(tree, id);
 839        if (dqp) {
 840                xfs_dqlock(dqp);
 841                if (dqp->dq_flags & XFS_DQ_FREEING) {
 842                        xfs_dqunlock(dqp);
 843                        mutex_unlock(&qi->qi_tree_lock);
 844                        trace_xfs_dqget_freeing(dqp);
 845                        delay(1);
 846                        goto restart;
 847                }
 848
 849                dqp->q_nrefs++;
 850                mutex_unlock(&qi->qi_tree_lock);
 851
 852                trace_xfs_dqget_hit(dqp);
 853                XFS_STATS_INC(xs_qm_dqcachehits);
 854                *O_dqpp = dqp;
 855                return 0;
 856        }
 857        mutex_unlock(&qi->qi_tree_lock);
 858        XFS_STATS_INC(xs_qm_dqcachemisses);
 859
 860        /*
 861         * Dquot cache miss. We don't want to keep the inode lock across
 862         * a (potential) disk read. Also we don't want to deal with the lock
 863         * ordering between quotainode and this inode. OTOH, dropping the inode
 864         * lock here means dealing with a chown that can happen before
 865         * we re-acquire the lock.
 866         */
 867        if (ip)
 868                xfs_iunlock(ip, XFS_ILOCK_EXCL);
 869
 870        error = xfs_qm_dqread(mp, id, type, flags, &dqp);
 871
 872        if (ip)
 873                xfs_ilock(ip, XFS_ILOCK_EXCL);
 874
 875        if (error)
 876                return error;
 877
 878        if (ip) {
 879                /*
 880                 * A dquot could be attached to this inode by now, since
 881                 * we had dropped the ilock.
 882                 */
 883                if (xfs_this_quota_on(mp, type)) {
 884                        struct xfs_dquot        *dqp1;
 885
 886                        dqp1 = xfs_inode_dquot(ip, type);
 887                        if (dqp1) {
 888                                xfs_qm_dqdestroy(dqp);
 889                                dqp = dqp1;
 890                                xfs_dqlock(dqp);
 891                                goto dqret;
 892                        }
 893                } else {
 894                        /* inode stays locked on return */
 895                        xfs_qm_dqdestroy(dqp);
 896                        return XFS_ERROR(ESRCH);
 897                }
 898        }
 899
 900        mutex_lock(&qi->qi_tree_lock);
 901        error = -radix_tree_insert(tree, id, dqp);
 902        if (unlikely(error)) {
 903                WARN_ON(error != EEXIST);
 904
 905                /*
 906                 * Duplicate found. Just throw away the new dquot and start
 907                 * over.
 908                 */
 909                mutex_unlock(&qi->qi_tree_lock);
 910                trace_xfs_dqget_dup(dqp);
 911                xfs_qm_dqdestroy(dqp);
 912                XFS_STATS_INC(xs_qm_dquot_dups);
 913                goto restart;
 914        }
 915
 916        /*
 917         * We return a locked dquot to the caller, with a reference taken
 918         */
 919        xfs_dqlock(dqp);
 920        dqp->q_nrefs = 1;
 921
 922        qi->qi_dquots++;
 923        mutex_unlock(&qi->qi_tree_lock);
 924
 925 dqret:
 926        ASSERT((ip == NULL) || xfs_isilocked(ip, XFS_ILOCK_EXCL));
 927        trace_xfs_dqget_miss(dqp);
 928        *O_dqpp = dqp;
 929        return (0);
 930}
 931
 932
 933STATIC void
 934xfs_qm_dqput_final(
 935        struct xfs_dquot        *dqp)
 936{
 937        struct xfs_quotainfo    *qi = dqp->q_mount->m_quotainfo;
 938        struct xfs_dquot        *gdqp;
 939        struct xfs_dquot        *pdqp;
 940
 941        trace_xfs_dqput_free(dqp);
 942
 943        mutex_lock(&qi->qi_lru_lock);
 944        if (list_empty(&dqp->q_lru)) {
 945                list_add_tail(&dqp->q_lru, &qi->qi_lru_list);
 946                qi->qi_lru_count++;
 947                XFS_STATS_INC(xs_qm_dquot_unused);
 948        }
 949        mutex_unlock(&qi->qi_lru_lock);
 950
 951        /*
 952         * If we just added a udquot to the freelist, then we want to release
 953         * the gdquot/pdquot reference that it (probably) has. Otherwise it'll
 954         * keep the gdquot/pdquot from getting reclaimed.
 955         */
 956        gdqp = dqp->q_gdquot;
 957        if (gdqp) {
 958                xfs_dqlock(gdqp);
 959                dqp->q_gdquot = NULL;
 960        }
 961
 962        pdqp = dqp->q_pdquot;
 963        if (pdqp) {
 964                xfs_dqlock(pdqp);
 965                dqp->q_pdquot = NULL;
 966        }
 967        xfs_dqunlock(dqp);
 968
 969        /*
 970         * If we had a group/project quota hint, release it now.
 971         */
 972        if (gdqp)
 973                xfs_qm_dqput(gdqp);
 974        if (pdqp)
 975                xfs_qm_dqput(pdqp);
 976}
 977
 978/*
 979 * Release a reference to the dquot (decrement ref-count) and unlock it.
 980 *
 981 * If there is a group quota attached to this dquot, carefully release that
 982 * too without tripping over deadlocks'n'stuff.
 983 */
 984void
 985xfs_qm_dqput(
 986        struct xfs_dquot        *dqp)
 987{
 988        ASSERT(dqp->q_nrefs > 0);
 989        ASSERT(XFS_DQ_IS_LOCKED(dqp));
 990
 991        trace_xfs_dqput(dqp);
 992
 993        if (--dqp->q_nrefs > 0)
 994                xfs_dqunlock(dqp);
 995        else
 996                xfs_qm_dqput_final(dqp);
 997}
 998
 999/*
1000 * Release a dquot. Flush it if dirty, then dqput() it.
1001 * dquot must not be locked.
1002 */
1003void
1004xfs_qm_dqrele(
1005        xfs_dquot_t     *dqp)
1006{
1007        if (!dqp)
1008                return;
1009
1010        trace_xfs_dqrele(dqp);
1011
1012        xfs_dqlock(dqp);
1013        /*
1014         * We don't care to flush it if the dquot is dirty here.
1015         * That will create stutters that we want to avoid.
1016         * Instead we do a delayed write when we try to reclaim
1017         * a dirty dquot. Also xfs_sync will take part of the burden...
1018         */
1019        xfs_qm_dqput(dqp);
1020}
1021
1022/*
1023 * This is the dquot flushing I/O completion routine.  It is called
1024 * from interrupt level when the buffer containing the dquot is
1025 * flushed to disk.  It is responsible for removing the dquot logitem
1026 * from the AIL if it has not been re-logged, and unlocking the dquot's
1027 * flush lock. This behavior is very similar to that of inodes..
1028 */
1029STATIC void
1030xfs_qm_dqflush_done(
1031        struct xfs_buf          *bp,
1032        struct xfs_log_item     *lip)
1033{
1034        xfs_dq_logitem_t        *qip = (struct xfs_dq_logitem *)lip;
1035        xfs_dquot_t             *dqp = qip->qli_dquot;
1036        struct xfs_ail          *ailp = lip->li_ailp;
1037
1038        /*
1039         * We only want to pull the item from the AIL if its
1040         * location in the log has not changed since we started the flush.
1041         * Thus, we only bother if the dquot's lsn has
1042         * not changed. First we check the lsn outside the lock
1043         * since it's cheaper, and then we recheck while
1044         * holding the lock before removing the dquot from the AIL.
1045         */
1046        if ((lip->li_flags & XFS_LI_IN_AIL) &&
1047            lip->li_lsn == qip->qli_flush_lsn) {
1048
1049                /* xfs_trans_ail_delete() drops the AIL lock. */
1050                spin_lock(&ailp->xa_lock);
1051                if (lip->li_lsn == qip->qli_flush_lsn)
1052                        xfs_trans_ail_delete(ailp, lip, SHUTDOWN_CORRUPT_INCORE);
1053                else
1054                        spin_unlock(&ailp->xa_lock);
1055        }
1056
1057        /*
1058         * Release the dq's flush lock since we're done with it.
1059         */
1060        xfs_dqfunlock(dqp);
1061}
1062
1063/*
1064 * Write a modified dquot to disk.
1065 * The dquot must be locked and the flush lock too taken by caller.
1066 * The flush lock will not be unlocked until the dquot reaches the disk,
1067 * but the dquot is free to be unlocked and modified by the caller
1068 * in the interim. Dquot is still locked on return. This behavior is
1069 * identical to that of inodes.
1070 */
1071int
1072xfs_qm_dqflush(
1073        struct xfs_dquot        *dqp,
1074        struct xfs_buf          **bpp)
1075{
1076        struct xfs_mount        *mp = dqp->q_mount;
1077        struct xfs_buf          *bp;
1078        struct xfs_disk_dquot   *ddqp;
1079        int                     error;
1080
1081        ASSERT(XFS_DQ_IS_LOCKED(dqp));
1082        ASSERT(!completion_done(&dqp->q_flush));
1083
1084        trace_xfs_dqflush(dqp);
1085
1086        *bpp = NULL;
1087
1088        xfs_qm_dqunpin_wait(dqp);
1089
1090        /*
1091         * This may have been unpinned because the filesystem is shutting
1092         * down forcibly. If that's the case we must not write this dquot
1093         * to disk, because the log record didn't make it to disk.
1094         *
1095         * We also have to remove the log item from the AIL in this case,
1096         * as we wait for an emptry AIL as part of the unmount process.
1097         */
1098        if (XFS_FORCED_SHUTDOWN(mp)) {
1099                struct xfs_log_item     *lip = &dqp->q_logitem.qli_item;
1100                dqp->dq_flags &= ~XFS_DQ_DIRTY;
1101
1102                spin_lock(&mp->m_ail->xa_lock);
1103                if (lip->li_flags & XFS_LI_IN_AIL)
1104                        xfs_trans_ail_delete(mp->m_ail, lip,
1105                                             SHUTDOWN_CORRUPT_INCORE);
1106                else
1107                        spin_unlock(&mp->m_ail->xa_lock);
1108                error = XFS_ERROR(EIO);
1109                goto out_unlock;
1110        }
1111
1112        /*
1113         * Get the buffer containing the on-disk dquot
1114         */
1115        error = xfs_trans_read_buf(mp, NULL, mp->m_ddev_targp, dqp->q_blkno,
1116                                   mp->m_quotainfo->qi_dqchunklen, 0, &bp, NULL);
1117        if (error)
1118                goto out_unlock;
1119
1120        /*
1121         * Calculate the location of the dquot inside the buffer.
1122         */
1123        ddqp = bp->b_addr + dqp->q_bufoffset;
1124
1125        /*
1126         * A simple sanity check in case we got a corrupted dquot..
1127         */
1128        error = xfs_qm_dqcheck(mp, &dqp->q_core, be32_to_cpu(ddqp->d_id), 0,
1129                           XFS_QMOPT_DOWARN, "dqflush (incore copy)");
1130        if (error) {
1131                xfs_buf_relse(bp);
1132                xfs_dqfunlock(dqp);
1133                xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
1134                return XFS_ERROR(EIO);
1135        }
1136
1137        /* This is the only portion of data that needs to persist */
1138        memcpy(ddqp, &dqp->q_core, sizeof(xfs_disk_dquot_t));
1139
1140        /*
1141         * Clear the dirty field and remember the flush lsn for later use.
1142         */
1143        dqp->dq_flags &= ~XFS_DQ_DIRTY;
1144
1145        xfs_trans_ail_copy_lsn(mp->m_ail, &dqp->q_logitem.qli_flush_lsn,
1146                                        &dqp->q_logitem.qli_item.li_lsn);
1147
1148        /*
1149         * copy the lsn into the on-disk dquot now while we have the in memory
1150         * dquot here. This can't be done later in the write verifier as we
1151         * can't get access to the log item at that point in time.
1152         *
1153         * We also calculate the CRC here so that the on-disk dquot in the
1154         * buffer always has a valid CRC. This ensures there is no possibility
1155         * of a dquot without an up-to-date CRC getting to disk.
1156         */
1157        if (xfs_sb_version_hascrc(&mp->m_sb)) {
1158                struct xfs_dqblk *dqb = (struct xfs_dqblk *)ddqp;
1159
1160                dqb->dd_lsn = cpu_to_be64(dqp->q_logitem.qli_item.li_lsn);
1161                xfs_update_cksum((char *)dqb, sizeof(struct xfs_dqblk),
1162                                 XFS_DQUOT_CRC_OFF);
1163        }
1164
1165        /*
1166         * Attach an iodone routine so that we can remove this dquot from the
1167         * AIL and release the flush lock once the dquot is synced to disk.
1168         */
1169        xfs_buf_attach_iodone(bp, xfs_qm_dqflush_done,
1170                                  &dqp->q_logitem.qli_item);
1171
1172        /*
1173         * If the buffer is pinned then push on the log so we won't
1174         * get stuck waiting in the write for too long.
1175         */
1176        if (xfs_buf_ispinned(bp)) {
1177                trace_xfs_dqflush_force(dqp);
1178                xfs_log_force(mp, 0);
1179        }
1180
1181        trace_xfs_dqflush_done(dqp);
1182        *bpp = bp;
1183        return 0;
1184
1185out_unlock:
1186        xfs_dqfunlock(dqp);
1187        return XFS_ERROR(EIO);
1188}
1189
1190/*
1191 * Lock two xfs_dquot structures.
1192 *
1193 * To avoid deadlocks we always lock the quota structure with
1194 * the lowerd id first.
1195 */
1196void
1197xfs_dqlock2(
1198        xfs_dquot_t     *d1,
1199        xfs_dquot_t     *d2)
1200{
1201        if (d1 && d2) {
1202                ASSERT(d1 != d2);
1203                if (be32_to_cpu(d1->q_core.d_id) >
1204                    be32_to_cpu(d2->q_core.d_id)) {
1205                        mutex_lock(&d2->q_qlock);
1206                        mutex_lock_nested(&d1->q_qlock, XFS_QLOCK_NESTED);
1207                } else {
1208                        mutex_lock(&d1->q_qlock);
1209                        mutex_lock_nested(&d2->q_qlock, XFS_QLOCK_NESTED);
1210                }
1211        } else if (d1) {
1212                mutex_lock(&d1->q_qlock);
1213        } else if (d2) {
1214                mutex_lock(&d2->q_qlock);
1215        }
1216}
1217
1218int __init
1219xfs_qm_init(void)
1220{
1221        xfs_qm_dqzone =
1222                kmem_zone_init(sizeof(struct xfs_dquot), "xfs_dquot");
1223        if (!xfs_qm_dqzone)
1224                goto out;
1225
1226        xfs_qm_dqtrxzone =
1227                kmem_zone_init(sizeof(struct xfs_dquot_acct), "xfs_dqtrx");
1228        if (!xfs_qm_dqtrxzone)
1229                goto out_free_dqzone;
1230
1231        return 0;
1232
1233out_free_dqzone:
1234        kmem_zone_destroy(xfs_qm_dqzone);
1235out:
1236        return -ENOMEM;
1237}
1238
1239void
1240xfs_qm_exit(void)
1241{
1242        kmem_zone_destroy(xfs_qm_dqtrxzone);
1243        kmem_zone_destroy(xfs_qm_dqzone);
1244}
1245
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.