linux/fs/xfs/xfs_dquot_item_recover.c
<<
>>
Prefs
   1// SPDX-License-Identifier: GPL-2.0
   2/*
   3 * Copyright (c) 2000-2006 Silicon Graphics, Inc.
   4 * All Rights Reserved.
   5 */
   6#include "xfs.h"
   7#include "xfs_fs.h"
   8#include "xfs_shared.h"
   9#include "xfs_format.h"
  10#include "xfs_log_format.h"
  11#include "xfs_trans_resv.h"
  12#include "xfs_mount.h"
  13#include "xfs_inode.h"
  14#include "xfs_quota.h"
  15#include "xfs_trans.h"
  16#include "xfs_buf_item.h"
  17#include "xfs_trans_priv.h"
  18#include "xfs_qm.h"
  19#include "xfs_log.h"
  20#include "xfs_log_priv.h"
  21#include "xfs_log_recover.h"
  22
  23STATIC void
  24xlog_recover_dquot_ra_pass2(
  25        struct xlog                     *log,
  26        struct xlog_recover_item        *item)
  27{
  28        struct xfs_mount        *mp = log->l_mp;
  29        struct xfs_disk_dquot   *recddq;
  30        struct xfs_dq_logformat *dq_f;
  31        uint                    type;
  32
  33        if (mp->m_qflags == 0)
  34                return;
  35
  36        recddq = item->ri_buf[1].i_addr;
  37        if (recddq == NULL)
  38                return;
  39        if (item->ri_buf[1].i_len < sizeof(struct xfs_disk_dquot))
  40                return;
  41
  42        type = recddq->d_type & XFS_DQTYPE_REC_MASK;
  43        ASSERT(type);
  44        if (log->l_quotaoffs_flag & type)
  45                return;
  46
  47        dq_f = item->ri_buf[0].i_addr;
  48        ASSERT(dq_f);
  49        ASSERT(dq_f->qlf_len == 1);
  50
  51        xlog_buf_readahead(log, dq_f->qlf_blkno,
  52                        XFS_FSB_TO_BB(mp, dq_f->qlf_len),
  53                        &xfs_dquot_buf_ra_ops);
  54}
  55
  56/*
  57 * Recover a dquot record
  58 */
  59STATIC int
  60xlog_recover_dquot_commit_pass2(
  61        struct xlog                     *log,
  62        struct list_head                *buffer_list,
  63        struct xlog_recover_item        *item,
  64        xfs_lsn_t                       current_lsn)
  65{
  66        struct xfs_mount                *mp = log->l_mp;
  67        struct xfs_buf                  *bp;
  68        struct xfs_disk_dquot           *ddq, *recddq;
  69        struct xfs_dq_logformat         *dq_f;
  70        xfs_failaddr_t                  fa;
  71        int                             error;
  72        uint                            type;
  73
  74        /*
  75         * Filesystems are required to send in quota flags at mount time.
  76         */
  77        if (mp->m_qflags == 0)
  78                return 0;
  79
  80        recddq = item->ri_buf[1].i_addr;
  81        if (recddq == NULL) {
  82                xfs_alert(log->l_mp, "NULL dquot in %s.", __func__);
  83                return -EFSCORRUPTED;
  84        }
  85        if (item->ri_buf[1].i_len < sizeof(struct xfs_disk_dquot)) {
  86                xfs_alert(log->l_mp, "dquot too small (%d) in %s.",
  87                        item->ri_buf[1].i_len, __func__);
  88                return -EFSCORRUPTED;
  89        }
  90
  91        /*
  92         * This type of quotas was turned off, so ignore this record.
  93         */
  94        type = recddq->d_type & XFS_DQTYPE_REC_MASK;
  95        ASSERT(type);
  96        if (log->l_quotaoffs_flag & type)
  97                return 0;
  98
  99        /*
 100         * At this point we know that quota was _not_ turned off.
 101         * Since the mount flags are not indicating to us otherwise, this
 102         * must mean that quota is on, and the dquot needs to be replayed.
 103         * Remember that we may not have fully recovered the superblock yet,
 104         * so we can't do the usual trick of looking at the SB quota bits.
 105         *
 106         * The other possibility, of course, is that the quota subsystem was
 107         * removed since the last mount - ENOSYS.
 108         */
 109        dq_f = item->ri_buf[0].i_addr;
 110        ASSERT(dq_f);
 111        fa = xfs_dquot_verify(mp, recddq, dq_f->qlf_id);
 112        if (fa) {
 113                xfs_alert(mp, "corrupt dquot ID 0x%x in log at %pS",
 114                                dq_f->qlf_id, fa);
 115                return -EFSCORRUPTED;
 116        }
 117        ASSERT(dq_f->qlf_len == 1);
 118
 119        /*
 120         * At this point we are assuming that the dquots have been allocated
 121         * and hence the buffer has valid dquots stamped in it. It should,
 122         * therefore, pass verifier validation. If the dquot is bad, then the
 123         * we'll return an error here, so we don't need to specifically check
 124         * the dquot in the buffer after the verifier has run.
 125         */
 126        error = xfs_trans_read_buf(mp, NULL, mp->m_ddev_targp, dq_f->qlf_blkno,
 127                                   XFS_FSB_TO_BB(mp, dq_f->qlf_len), 0, &bp,
 128                                   &xfs_dquot_buf_ops);
 129        if (error)
 130                return error;
 131
 132        ASSERT(bp);
 133        ddq = xfs_buf_offset(bp, dq_f->qlf_boffset);
 134
 135        /*
 136         * If the dquot has an LSN in it, recover the dquot only if it's less
 137         * than the lsn of the transaction we are replaying.
 138         */
 139        if (xfs_sb_version_hascrc(&mp->m_sb)) {
 140                struct xfs_dqblk *dqb = (struct xfs_dqblk *)ddq;
 141                xfs_lsn_t       lsn = be64_to_cpu(dqb->dd_lsn);
 142
 143                if (lsn && lsn != -1 && XFS_LSN_CMP(lsn, current_lsn) >= 0) {
 144                        goto out_release;
 145                }
 146        }
 147
 148        memcpy(ddq, recddq, item->ri_buf[1].i_len);
 149        if (xfs_sb_version_hascrc(&mp->m_sb)) {
 150                xfs_update_cksum((char *)ddq, sizeof(struct xfs_dqblk),
 151                                 XFS_DQUOT_CRC_OFF);
 152        }
 153
 154        ASSERT(dq_f->qlf_size == 2);
 155        ASSERT(bp->b_mount == mp);
 156        bp->b_flags |= _XBF_LOGRECOVERY;
 157        xfs_buf_delwri_queue(bp, buffer_list);
 158
 159out_release:
 160        xfs_buf_relse(bp);
 161        return 0;
 162}
 163
 164const struct xlog_recover_item_ops xlog_dquot_item_ops = {
 165        .item_type              = XFS_LI_DQUOT,
 166        .ra_pass2               = xlog_recover_dquot_ra_pass2,
 167        .commit_pass2           = xlog_recover_dquot_commit_pass2,
 168};
 169
 170/*
 171 * Recover QUOTAOFF records. We simply make a note of it in the xlog
 172 * structure, so that we know not to do any dquot item or dquot buffer recovery,
 173 * of that type.
 174 */
 175STATIC int
 176xlog_recover_quotaoff_commit_pass1(
 177        struct xlog                     *log,
 178        struct xlog_recover_item        *item)
 179{
 180        struct xfs_qoff_logformat       *qoff_f = item->ri_buf[0].i_addr;
 181        ASSERT(qoff_f);
 182
 183        /*
 184         * The logitem format's flag tells us if this was user quotaoff,
 185         * group/project quotaoff or both.
 186         */
 187        if (qoff_f->qf_flags & XFS_UQUOTA_ACCT)
 188                log->l_quotaoffs_flag |= XFS_DQTYPE_USER;
 189        if (qoff_f->qf_flags & XFS_PQUOTA_ACCT)
 190                log->l_quotaoffs_flag |= XFS_DQTYPE_PROJ;
 191        if (qoff_f->qf_flags & XFS_GQUOTA_ACCT)
 192                log->l_quotaoffs_flag |= XFS_DQTYPE_GROUP;
 193
 194        return 0;
 195}
 196
 197const struct xlog_recover_item_ops xlog_quotaoff_item_ops = {
 198        .item_type              = XFS_LI_QUOTAOFF,
 199        .commit_pass1           = xlog_recover_quotaoff_commit_pass1,
 200        /* nothing to commit in pass2 */
 201};
 202