libxfs/xfs_dquot_buf.c

   1 /*
   2  * Copyright (c) 2000-2006 Silicon Graphics, Inc.
   3  * Copyright (c) 2013 Red Hat, Inc.
   4  * All Rights Reserved.
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License as
   8  * published by the Free Software Foundation.
   9  *
  10  * This program is distributed in the hope that it would be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write the Free Software Foundation,
  17  * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  18  */
  19 #include "libxfs_priv.h"
  20 #include "xfs_fs.h"
  21 #include "xfs_shared.h"
  22 #include "xfs_format.h"
  23 #include "xfs_log_format.h"
  24 #include "xfs_trans_resv.h"
  25 #include "xfs_mount.h"
  26 #include "xfs_inode.h"
  27 #include "xfs_trans.h"
  28 #include "xfs_cksum.h"
  29 #include "xfs_trace.h"
  30 #include "xfs_quota_defs.h"
  31
  32 int
  33 xfs_calc_dquots_per_chunk(
  34         unsigned int            nbblks) /* basic block units */
  35 {
  36         ASSERT(nbblks > 0);
  37         return BBTOB(nbblks) / sizeof(xfs_dqblk_t);
  38 }
  39
  40 /*
  41  * Do some primitive error checking on ondisk dquot data structures.
  42  */
  43 xfs_failaddr_t
  44 xfs_dquot_verify(
  45         struct xfs_mount *mp,
  46         xfs_disk_dquot_t *ddq,
  47         xfs_dqid_t       id,
  48         uint             type)    /* used only during quotacheck */
  49 {
  50         /*
  51          * We can encounter an uninitialized dquot buffer for 2 reasons:
  52          * 1. If we crash while deleting the quotainode(s), and those blks got
  53          *    used for user data. This is because we take the path of regular
  54          *    file deletion; however, the size field of quotainodes is never
  55          *    updated, so all the tricks that we play in itruncate_finish
  56          *    don't quite matter.
  57          *
  58          * 2. We don't play the quota buffers when there's a quotaoff logitem.
  59          *    But the allocation will be replayed so we'll end up with an
  60          *    uninitialized quota block.
  61          *
  62          * This is all fine; things are still consistent, and we haven't lost
  63          * any quota information. Just don't complain about bad dquot blks.
  64          */
  65         if (ddq->d_magic != cpu_to_be16(XFS_DQUOT_MAGIC))
  66                 return __this_address;
  67         if (ddq->d_version != XFS_DQUOT_VERSION)
  68                 return __this_address;
  69
  70         if (type && ddq->d_flags != type)
  71                 return __this_address;
  72         if (ddq->d_flags != XFS_DQ_USER &&
  73             ddq->d_flags != XFS_DQ_PROJ &&
  74             ddq->d_flags != XFS_DQ_GROUP)
  75                 return __this_address;
  76
  77         if (id != -1 && id != be32_to_cpu(ddq->d_id))
  78                 return __this_address;
  79
  80         if (!ddq->d_id)
  81                 return NULL;
  82
  83         if (ddq->d_blk_softlimit &&
  84             be64_to_cpu(ddq->d_bcount) > be64_to_cpu(ddq->d_blk_softlimit) &&
  85             !ddq->d_btimer)
  86                 return __this_address;
  87
  88         if (ddq->d_ino_softlimit &&
  89             be64_to_cpu(ddq->d_icount) > be64_to_cpu(ddq->d_ino_softlimit) &&
  90             !ddq->d_itimer)
  91                 return __this_address;
  92
  93         if (ddq->d_rtb_softlimit &&
  94             be64_to_cpu(ddq->d_rtbcount) > be64_to_cpu(ddq->d_rtb_softlimit) &&
  95             !ddq->d_rtbtimer)
  96                 return __this_address;
  97
  98         return NULL;
  99 }
 100
 101 /*
 102  * Do some primitive error checking on ondisk dquot data structures.
 103  */
 104 int
 105 xfs_dqblk_repair(
 106         struct xfs_mount        *mp,
 107         struct xfs_dqblk        *dqb,
 108         xfs_dqid_t              id,
 109         uint                    type)
 110 {
 111         /*
 112          * Typically, a repair is only requested by quotacheck.
 113          */
 114         ASSERT(id != -1);
 115         memset(dqb, 0, sizeof(xfs_dqblk_t));
 116
 117         dqb->dd_diskdq.d_magic = cpu_to_be16(XFS_DQUOT_MAGIC);
 118         dqb->dd_diskdq.d_version = XFS_DQUOT_VERSION;
 119         dqb->dd_diskdq.d_flags = type;
 120         dqb->dd_diskdq.d_id = cpu_to_be32(id);
 121
 122         if (xfs_sb_version_hascrc(&mp->m_sb)) {
 123                 uuid_copy(&dqb->dd_uuid, &mp->m_sb.sb_meta_uuid);
 124                 xfs_update_cksum((char *)dqb, sizeof(struct xfs_dqblk),
 125                                  XFS_DQUOT_CRC_OFF);
 126         }
 127
 128         return 0;
 129 }
 130
 131 STATIC bool
 132 xfs_dquot_buf_verify_crc(
 133         struct xfs_mount        *mp,
 134         struct xfs_buf          *bp)
 135 {
 136         struct xfs_dqblk        *d = (struct xfs_dqblk *)bp->b_addr;
 137         int                     ndquots;
 138         int                     i;
 139
 140         if (!xfs_sb_version_hascrc(&mp->m_sb))
 141                 return true;
 142
 143         /*
 144          * if we are in log recovery, the quota subsystem has not been
 145          * initialised so we have no quotainfo structure. In that case, we need
 146          * to manually calculate the number of dquots in the buffer.
 147          */
 148         if (mp->m_quotainfo)
 149                 ndquots = mp->m_quotainfo->qi_dqperchunk;
 150         else
 151                 ndquots = xfs_calc_dquots_per_chunk(bp->b_length);
 152
 153         for (i = 0; i < ndquots; i++, d++) {
 154                 if (!xfs_verify_cksum((char *)d, sizeof(struct xfs_dqblk),
 155                                  XFS_DQUOT_CRC_OFF))
 156                         return false;
 157                 if (!uuid_equal(&d->dd_uuid, &mp->m_sb.sb_meta_uuid))
 158                         return false;
 159         }
 160         return true;
 161 }
 162
 163 STATIC xfs_failaddr_t
 164 xfs_dquot_buf_verify(
 165         struct xfs_mount        *mp,
 166         struct xfs_buf          *bp)
 167 {
 168         struct xfs_dqblk        *d = (struct xfs_dqblk *)bp->b_addr;
 169         xfs_failaddr_t          fa;
 170         xfs_dqid_t              id = 0;
 171         int                     ndquots;
 172         int                     i;
 173
 174         /*
 175          * if we are in log recovery, the quota subsystem has not been
 176          * initialised so we have no quotainfo structure. In that case, we need
 177          * to manually calculate the number of dquots in the buffer.
 178          */
 179         if (mp->m_quotainfo)
 180                 ndquots = mp->m_quotainfo->qi_dqperchunk;
 181         else
 182                 ndquots = xfs_calc_dquots_per_chunk(bp->b_length);
 183
 184         /*
 185          * On the first read of the buffer, verify that each dquot is valid.
 186          * We don't know what the id of the dquot is supposed to be, just that
 187          * they should be increasing monotonically within the buffer. If the
 188          * first id is corrupt, then it will fail on the second dquot in the
 189          * buffer so corruptions could point to the wrong dquot in this case.
 190          */
 191         for (i = 0; i < ndquots; i++) {
 192                 struct xfs_disk_dquot   *ddq;
 193
 194                 ddq = &d[i].dd_diskdq;
 195
 196                 if (i == 0)
 197                         id = be32_to_cpu(ddq->d_id);
 198
 199                 fa = xfs_dquot_verify(mp, ddq, id + i, 0);
 200                 if (fa)
 201                         return fa;
 202         }
 203
 204         return NULL;
 205 }
 206
 207 static xfs_failaddr_t
 208 xfs_dquot_buf_verify_struct(
 209         struct xfs_buf          *bp)
 210 {
 211         struct xfs_mount        *mp = bp->b_target->bt_mount;
 212
 213         return xfs_dquot_buf_verify(mp, bp);
 214 }
 215
 216 static void
 217 xfs_dquot_buf_read_verify(
 218         struct xfs_buf          *bp)
 219 {
 220         struct xfs_mount        *mp = bp->b_target->bt_mount;
 221         xfs_failaddr_t          fa;
 222
 223         if (!xfs_dquot_buf_verify_crc(mp, bp))
 224                 xfs_verifier_error(bp, -EFSBADCRC, __this_address);
 225         else {
 226                 fa = xfs_dquot_buf_verify(mp, bp);
 227                 if (fa)
 228                         xfs_verifier_error(bp, -EFSCORRUPTED, __this_address);
 229         }
 230 }
 231
 232 /*
 233  * readahead errors are silent and simply leave the buffer as !done so a real
 234  * read will then be run with the xfs_dquot_buf_ops verifier. See
 235  * xfs_inode_buf_verify() for why we use EIO and ~XBF_DONE here rather than
 236  * reporting the failure.
 237  */
 238 static void
 239 xfs_dquot_buf_readahead_verify(
 240         struct xfs_buf  *bp)
 241 {
 242         struct xfs_mount        *mp = bp->b_target->bt_mount;
 243
 244         if (!xfs_dquot_buf_verify_crc(mp, bp) ||
 245             xfs_dquot_buf_verify(mp, bp) != NULL) {
 246                 xfs_buf_ioerror(bp, -EIO);
 247                 bp->b_flags &= ~XBF_DONE;
 248         }
 249 }
 250
 251 /*
 252  * we don't calculate the CRC here as that is done when the dquot is flushed to
 253  * the buffer after the update is done. This ensures that the dquot in the
 254  * buffer always has an up-to-date CRC value.
 255  */
 256 static void
 257 xfs_dquot_buf_write_verify(
 258         struct xfs_buf          *bp)
 259 {
 260         struct xfs_mount        *mp = bp->b_target->bt_mount;
 261         xfs_failaddr_t          fa;
 262
 263         fa = xfs_dquot_buf_verify(mp, bp);
 264         if (fa)
 265                 xfs_verifier_error(bp, -EFSCORRUPTED, __this_address);
 266 }
 267
 268 const struct xfs_buf_ops xfs_dquot_buf_ops = {
 269         .name = "xfs_dquot",
 270         .verify_read = xfs_dquot_buf_read_verify,
 271         .verify_write = xfs_dquot_buf_write_verify,
 272         .verify_struct = xfs_dquot_buf_verify_struct,
 273 };
 274
 275 const struct xfs_buf_ops xfs_dquot_buf_ra_ops = {
 276         .name = "xfs_dquot_ra",
 277         .verify_read = xfs_dquot_buf_readahead_verify,
 278         .verify_write = xfs_dquot_buf_write_verify,
 279 };