fs/xfs/xfs_dquot_item.c

   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_format.h"
  21 #include "xfs_log_format.h"
  22 #include "xfs_trans_resv.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_trans.h"
  36 #include "xfs_buf_item.h"
  37 #include "xfs_trans_priv.h"
  38 #include "xfs_qm.h"
  39 #include "xfs_log.h"
  40
  41 static inline struct xfs_dq_logitem *DQUOT_ITEM(struct xfs_log_item *lip)
  42 {
  43         return container_of(lip, struct xfs_dq_logitem, qli_item);
  44 }
  45
  46 /*
  47  * returns the number of iovecs needed to log the given dquot item.
  48  */
  49 STATIC void
  50 xfs_qm_dquot_logitem_size(
  51         struct xfs_log_item     *lip,
  52         int                     *nvecs,
  53         int                     *nbytes)
  54 {
  55         *nvecs += 2;
  56         *nbytes += sizeof(struct xfs_dq_logformat) +
  57                    sizeof(struct xfs_disk_dquot);
  58 }
  59
  60 /*
  61  * fills in the vector of log iovecs for the given dquot log item.
  62  */
  63 STATIC void
  64 xfs_qm_dquot_logitem_format(
  65         struct xfs_log_item     *lip,
  66         struct xfs_log_iovec    *logvec)
  67 {
  68         struct xfs_dq_logitem   *qlip = DQUOT_ITEM(lip);
  69
  70         logvec->i_addr = &qlip->qli_format;
  71         logvec->i_len  = sizeof(xfs_dq_logformat_t);
  72         logvec->i_type = XLOG_REG_TYPE_QFORMAT;
  73         logvec++;
  74         logvec->i_addr = &qlip->qli_dquot->q_core;
  75         logvec->i_len  = sizeof(xfs_disk_dquot_t);
  76         logvec->i_type = XLOG_REG_TYPE_DQUOT;
  77
  78         qlip->qli_format.qlf_size = 2;
  79
  80 }
  81
  82 /*
  83  * Increment the pin count of the given dquot.
  84  */
  85 STATIC void
  86 xfs_qm_dquot_logitem_pin(
  87         struct xfs_log_item     *lip)
  88 {
  89         struct xfs_dquot        *dqp = DQUOT_ITEM(lip)->qli_dquot;
  90
  91         ASSERT(XFS_DQ_IS_LOCKED(dqp));
  92         atomic_inc(&dqp->q_pincount);
  93 }
  94
  95 /*
  96  * Decrement the pin count of the given dquot, and wake up
  97  * anyone in xfs_dqwait_unpin() if the count goes to 0.  The
  98  * dquot must have been previously pinned with a call to
  99  * xfs_qm_dquot_logitem_pin().
 100  */
 101 STATIC void
 102 xfs_qm_dquot_logitem_unpin(
 103         struct xfs_log_item     *lip,
 104         int                     remove)
 105 {
 106         struct xfs_dquot        *dqp = DQUOT_ITEM(lip)->qli_dquot;
 107
 108         ASSERT(atomic_read(&dqp->q_pincount) > 0);
 109         if (atomic_dec_and_test(&dqp->q_pincount))
 110                 wake_up(&dqp->q_pinwait);
 111 }
 112
 113 STATIC xfs_lsn_t
 114 xfs_qm_dquot_logitem_committed(
 115         struct xfs_log_item     *lip,
 116         xfs_lsn_t               lsn)
 117 {
 118         /*
 119          * We always re-log the entire dquot when it becomes dirty,
 120          * so, the latest copy _is_ the only one that matters.
 121          */
 122         return lsn;
 123 }
 124
 125 /*
 126  * This is called to wait for the given dquot to be unpinned.
 127  * Most of these pin/unpin routines are plagiarized from inode code.
 128  */
 129 void
 130 xfs_qm_dqunpin_wait(
 131         struct xfs_dquot        *dqp)
 132 {
 133         ASSERT(XFS_DQ_IS_LOCKED(dqp));
 134         if (atomic_read(&dqp->q_pincount) == 0)
 135                 return;
 136
 137         /*
 138          * Give the log a push so we don't wait here too long.
 139          */
 140         xfs_log_force(dqp->q_mount, 0);
 141         wait_event(dqp->q_pinwait, (atomic_read(&dqp->q_pincount) == 0));
 142 }
 143
 144 STATIC uint
 145 xfs_qm_dquot_logitem_push(
 146         struct xfs_log_item     *lip,
 147         struct list_head        *buffer_list) __releases(&lip->li_ailp->xa_lock)
 148                                               __acquires(&lip->li_ailp->xa_lock)
 149 {
 150         struct xfs_dquot        *dqp = DQUOT_ITEM(lip)->qli_dquot;
 151         struct xfs_buf          *bp = NULL;
 152         uint                    rval = XFS_ITEM_SUCCESS;
 153         int                     error;
 154
 155         if (atomic_read(&dqp->q_pincount) > 0)
 156                 return XFS_ITEM_PINNED;
 157
 158         if (!xfs_dqlock_nowait(dqp))
 159                 return XFS_ITEM_LOCKED;
 160
 161         /*
 162          * Re-check the pincount now that we stabilized the value by
 163          * taking the quota lock.
 164          */
 165         if (atomic_read(&dqp->q_pincount) > 0) {
 166                 rval = XFS_ITEM_PINNED;
 167                 goto out_unlock;
 168         }
 169
 170         /*
 171          * Someone else is already flushing the dquot.  Nothing we can do
 172          * here but wait for the flush to finish and remove the item from
 173          * the AIL.
 174          */
 175         if (!xfs_dqflock_nowait(dqp)) {
 176                 rval = XFS_ITEM_FLUSHING;
 177                 goto out_unlock;
 178         }
 179
 180         spin_unlock(&lip->li_ailp->xa_lock);
 181
 182         error = xfs_qm_dqflush(dqp, &bp);
 183         if (error) {
 184                 xfs_warn(dqp->q_mount, "%s: push error %d on dqp %p",
 185                         __func__, error, dqp);
 186         } else {
 187                 if (!xfs_buf_delwri_queue(bp, buffer_list))
 188                         rval = XFS_ITEM_FLUSHING;
 189                 xfs_buf_relse(bp);
 190         }
 191
 192         spin_lock(&lip->li_ailp->xa_lock);
 193 out_unlock:
 194         xfs_dqunlock(dqp);
 195         return rval;
 196 }
 197
 198 /*
 199  * Unlock the dquot associated with the log item.
 200  * Clear the fields of the dquot and dquot log item that
 201  * are specific to the current transaction.  If the
 202  * hold flags is set, do not unlock the dquot.
 203  */
 204 STATIC void
 205 xfs_qm_dquot_logitem_unlock(
 206         struct xfs_log_item     *lip)
 207 {
 208         struct xfs_dquot        *dqp = DQUOT_ITEM(lip)->qli_dquot;
 209
 210         ASSERT(XFS_DQ_IS_LOCKED(dqp));
 211
 212         /*
 213          * Clear the transaction pointer in the dquot
 214          */
 215         dqp->q_transp = NULL;
 216
 217         /*
 218          * dquots are never 'held' from getting unlocked at the end of
 219          * a transaction.  Their locking and unlocking is hidden inside the
 220          * transaction layer, within trans_commit. Hence, no LI_HOLD flag
 221          * for the logitem.
 222          */
 223         xfs_dqunlock(dqp);
 224 }
 225
 226 /*
 227  * this needs to stamp an lsn into the dquot, I think.
 228  * rpc's that look at user dquot's would then have to
 229  * push on the dependency recorded in the dquot
 230  */
 231 STATIC void
 232 xfs_qm_dquot_logitem_committing(
 233         struct xfs_log_item     *lip,
 234         xfs_lsn_t               lsn)
 235 {
 236 }
 237
 238 /*
 239  * This is the ops vector for dquots
 240  */
 241 static const struct xfs_item_ops xfs_dquot_item_ops = {
 242         .iop_size       = xfs_qm_dquot_logitem_size,
 243         .iop_format     = xfs_qm_dquot_logitem_format,
 244         .iop_pin        = xfs_qm_dquot_logitem_pin,
 245         .iop_unpin      = xfs_qm_dquot_logitem_unpin,
 246         .iop_unlock     = xfs_qm_dquot_logitem_unlock,
 247         .iop_committed  = xfs_qm_dquot_logitem_committed,
 248         .iop_push       = xfs_qm_dquot_logitem_push,
 249         .iop_committing = xfs_qm_dquot_logitem_committing
 250 };
 251
 252 /*
 253  * Initialize the dquot log item for a newly allocated dquot.
 254  * The dquot isn't locked at this point, but it isn't on any of the lists
 255  * either, so we don't care.
 256  */
 257 void
 258 xfs_qm_dquot_logitem_init(
 259         struct xfs_dquot        *dqp)
 260 {
 261         struct xfs_dq_logitem   *lp = &dqp->q_logitem;
 262
 263         xfs_log_item_init(dqp->q_mount, &lp->qli_item, XFS_LI_DQUOT,
 264                                         &xfs_dquot_item_ops);
 265         lp->qli_dquot = dqp;
 266         lp->qli_format.qlf_type = XFS_LI_DQUOT;
 267         lp->qli_format.qlf_id = be32_to_cpu(dqp->q_core.d_id);
 268         lp->qli_format.qlf_blkno = dqp->q_blkno;
 269         lp->qli_format.qlf_len = 1;
 270         /*
 271          * This is just the offset of this dquot within its buffer
 272          * (which is currently 1 FSB and probably won't change).
 273          * Hence 32 bits for this offset should be just fine.
 274          * Alternatively, we can store (bufoffset / sizeof(xfs_dqblk_t))
 275          * here, and recompute it at recovery time.
 276          */
 277         lp->qli_format.qlf_boffset = (__uint32_t)dqp->q_bufoffset;
 278 }
 279
 280 /*------------------  QUOTAOFF LOG ITEMS  -------------------*/
 281
 282 static inline struct xfs_qoff_logitem *QOFF_ITEM(struct xfs_log_item *lip)
 283 {
 284         return container_of(lip, struct xfs_qoff_logitem, qql_item);
 285 }
 286
 287
 288 /*
 289  * This returns the number of iovecs needed to log the given quotaoff item.
 290  * We only need 1 iovec for an quotaoff item.  It just logs the
 291  * quotaoff_log_format structure.
 292  */
 293 STATIC void
 294 xfs_qm_qoff_logitem_size(
 295         struct xfs_log_item     *lip,
 296         int                     *nvecs,
 297         int                     *nbytes)
 298 {
 299         *nvecs += 1;
 300         *nbytes += sizeof(struct xfs_qoff_logitem);
 301 }
 302
 303 /*
 304  * This is called to fill in the vector of log iovecs for the
 305  * given quotaoff log item. We use only 1 iovec, and we point that
 306  * at the quotaoff_log_format structure embedded in the quotaoff item.
 307  * It is at this point that we assert that all of the extent
 308  * slots in the quotaoff item have been filled.
 309  */
 310 STATIC void
 311 xfs_qm_qoff_logitem_format(
 312         struct xfs_log_item     *lip,
 313         struct xfs_log_iovec    *log_vector)
 314 {
 315         struct xfs_qoff_logitem *qflip = QOFF_ITEM(lip);
 316
 317         ASSERT(qflip->qql_format.qf_type == XFS_LI_QUOTAOFF);
 318
 319         log_vector->i_addr = &qflip->qql_format;
 320         log_vector->i_len = sizeof(xfs_qoff_logitem_t);
 321         log_vector->i_type = XLOG_REG_TYPE_QUOTAOFF;
 322         qflip->qql_format.qf_size = 1;
 323 }
 324
 325 /*
 326  * Pinning has no meaning for an quotaoff item, so just return.
 327  */
 328 STATIC void
 329 xfs_qm_qoff_logitem_pin(
 330         struct xfs_log_item     *lip)
 331 {
 332 }
 333
 334 /*
 335  * Since pinning has no meaning for an quotaoff item, unpinning does
 336  * not either.
 337  */
 338 STATIC void
 339 xfs_qm_qoff_logitem_unpin(
 340         struct xfs_log_item     *lip,
 341         int                     remove)
 342 {
 343 }
 344
 345 /*
 346  * There isn't much you can do to push a quotaoff item.  It is simply
 347  * stuck waiting for the log to be flushed to disk.
 348  */
 349 STATIC uint
 350 xfs_qm_qoff_logitem_push(
 351         struct xfs_log_item     *lip,
 352         struct list_head        *buffer_list)
 353 {
 354         return XFS_ITEM_LOCKED;
 355 }
 356
 357 /*
 358  * Quotaoff items have no locking or pushing, so return failure
 359  * so that the caller doesn't bother with us.
 360  */
 361 STATIC void
 362 xfs_qm_qoff_logitem_unlock(
 363         struct xfs_log_item     *lip)
 364 {
 365 }
 366
 367 /*
 368  * The quotaoff-start-item is logged only once and cannot be moved in the log,
 369  * so simply return the lsn at which it's been logged.
 370  */
 371 STATIC xfs_lsn_t
 372 xfs_qm_qoff_logitem_committed(
 373         struct xfs_log_item     *lip,
 374         xfs_lsn_t               lsn)
 375 {
 376         return lsn;
 377 }
 378
 379 STATIC xfs_lsn_t
 380 xfs_qm_qoffend_logitem_committed(
 381         struct xfs_log_item     *lip,
 382         xfs_lsn_t               lsn)
 383 {
 384         struct xfs_qoff_logitem *qfe = QOFF_ITEM(lip);
 385         struct xfs_qoff_logitem *qfs = qfe->qql_start_lip;
 386         struct xfs_ail          *ailp = qfs->qql_item.li_ailp;
 387
 388         /*
 389          * Delete the qoff-start logitem from the AIL.
 390          * xfs_trans_ail_delete() drops the AIL lock.
 391          */
 392         spin_lock(&ailp->xa_lock);
 393         xfs_trans_ail_delete(ailp, &qfs->qql_item, SHUTDOWN_LOG_IO_ERROR);
 394
 395         kmem_free(qfs);
 396         kmem_free(qfe);
 397         return (xfs_lsn_t)-1;
 398 }
 399
 400 /*
 401  * XXX rcc - don't know quite what to do with this.  I think we can
 402  * just ignore it.  The only time that isn't the case is if we allow
 403  * the client to somehow see that quotas have been turned off in which
 404  * we can't allow that to get back until the quotaoff hits the disk.
 405  * So how would that happen?  Also, do we need different routines for
 406  * quotaoff start and quotaoff end?  I suspect the answer is yes but
 407  * to be sure, I need to look at the recovery code and see how quota off
 408  * recovery is handled (do we roll forward or back or do something else).
 409  * If we roll forwards or backwards, then we need two separate routines,
 410  * one that does nothing and one that stamps in the lsn that matters
 411  * (truly makes the quotaoff irrevocable).  If we do something else,
 412  * then maybe we don't need two.
 413  */
 414 STATIC void
 415 xfs_qm_qoff_logitem_committing(
 416         struct xfs_log_item     *lip,
 417         xfs_lsn_t               commit_lsn)
 418 {
 419 }
 420
 421 static const struct xfs_item_ops xfs_qm_qoffend_logitem_ops = {
 422         .iop_size       = xfs_qm_qoff_logitem_size,
 423         .iop_format     = xfs_qm_qoff_logitem_format,
 424         .iop_pin        = xfs_qm_qoff_logitem_pin,
 425         .iop_unpin      = xfs_qm_qoff_logitem_unpin,
 426         .iop_unlock     = xfs_qm_qoff_logitem_unlock,
 427         .iop_committed  = xfs_qm_qoffend_logitem_committed,
 428         .iop_push       = xfs_qm_qoff_logitem_push,
 429         .iop_committing = xfs_qm_qoff_logitem_committing
 430 };
 431
 432 /*
 433  * This is the ops vector shared by all quotaoff-start log items.
 434  */
 435 static const struct xfs_item_ops xfs_qm_qoff_logitem_ops = {
 436         .iop_size       = xfs_qm_qoff_logitem_size,
 437         .iop_format     = xfs_qm_qoff_logitem_format,
 438         .iop_pin        = xfs_qm_qoff_logitem_pin,
 439         .iop_unpin      = xfs_qm_qoff_logitem_unpin,
 440         .iop_unlock     = xfs_qm_qoff_logitem_unlock,
 441         .iop_committed  = xfs_qm_qoff_logitem_committed,
 442         .iop_push       = xfs_qm_qoff_logitem_push,
 443         .iop_committing = xfs_qm_qoff_logitem_committing
 444 };
 445
 446 /*
 447  * Allocate and initialize an quotaoff item of the correct quota type(s).
 448  */
 449 struct xfs_qoff_logitem *
 450 xfs_qm_qoff_logitem_init(
 451         struct xfs_mount        *mp,
 452         struct xfs_qoff_logitem *start,
 453         uint                    flags)
 454 {
 455         struct xfs_qoff_logitem *qf;
 456
 457         qf = kmem_zalloc(sizeof(struct xfs_qoff_logitem), KM_SLEEP);
 458
 459         xfs_log_item_init(mp, &qf->qql_item, XFS_LI_QUOTAOFF, start ?
 460                         &xfs_qm_qoffend_logitem_ops : &xfs_qm_qoff_logitem_ops);
 461         qf->qql_item.li_mountp = mp;
 462         qf->qql_format.qf_type = XFS_LI_QUOTAOFF;
 463         qf->qql_format.qf_flags = flags;
 464         qf->qql_start_lip = start;
 465         return qf;
 466 }