fs/xfs/xfs_iunlink_item.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright (c) 2020-2022, Red Hat, 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_trans.h"
  15 #include "xfs_trans_priv.h"
  16 #include "xfs_ag.h"
  17 #include "xfs_iunlink_item.h"
  18 #include "xfs_trace.h"
  19 #include "xfs_error.h"
  20
  21 struct kmem_cache       *xfs_iunlink_cache;
  22
  23 static inline struct xfs_iunlink_item *IUL_ITEM(struct xfs_log_item *lip)
  24 {
  25         return container_of(lip, struct xfs_iunlink_item, item);
  26 }
  27
  28 static void
  29 xfs_iunlink_item_release(
  30         struct xfs_log_item     *lip)
  31 {
  32         struct xfs_iunlink_item *iup = IUL_ITEM(lip);
  33
  34         xfs_perag_put(iup->pag);
  35         kmem_cache_free(xfs_iunlink_cache, IUL_ITEM(lip));
  36 }
  37
  38
  39 static uint64_t
  40 xfs_iunlink_item_sort(
  41         struct xfs_log_item     *lip)
  42 {
  43         return IUL_ITEM(lip)->ip->i_ino;
  44 }
  45
  46 /*
  47  * Look up the inode cluster buffer and log the on-disk unlinked inode change
  48  * we need to make.
  49  */
  50 static int
  51 xfs_iunlink_log_dinode(
  52         struct xfs_trans        *tp,
  53         struct xfs_iunlink_item *iup)
  54 {
  55         struct xfs_mount        *mp = tp->t_mountp;
  56         struct xfs_inode        *ip = iup->ip;
  57         struct xfs_dinode       *dip;
  58         struct xfs_buf          *ibp;
  59         int                     offset;
  60         int                     error;
  61
  62         error = xfs_imap_to_bp(mp, tp, &ip->i_imap, &ibp);
  63         if (error)
  64                 return error;
  65         /*
  66          * Don't log the unlinked field on stale buffers as this may be the
  67          * transaction that frees the inode cluster and relogging the buffer
  68          * here will incorrectly remove the stale state.
  69          */
  70         if (ibp->b_flags & XBF_STALE)
  71                 goto out;
  72
  73         dip = xfs_buf_offset(ibp, ip->i_imap.im_boffset);
  74
  75         /* Make sure the old pointer isn't garbage. */
  76         if (be32_to_cpu(dip->di_next_unlinked) != iup->old_agino) {
  77                 xfs_inode_verifier_error(ip, -EFSCORRUPTED, __func__, dip,
  78                                 sizeof(*dip), __this_address);
  79                 error = -EFSCORRUPTED;
  80                 goto out;
  81         }
  82
  83         trace_xfs_iunlink_update_dinode(mp, iup->pag->pag_agno,
  84                         XFS_INO_TO_AGINO(mp, ip->i_ino),
  85                         be32_to_cpu(dip->di_next_unlinked), iup->next_agino);
  86
  87         dip->di_next_unlinked = cpu_to_be32(iup->next_agino);
  88         offset = ip->i_imap.im_boffset +
  89                         offsetof(struct xfs_dinode, di_next_unlinked);
  90
  91         xfs_dinode_calc_crc(mp, dip);
  92         xfs_trans_inode_buf(tp, ibp);
  93         xfs_trans_log_buf(tp, ibp, offset, offset + sizeof(xfs_agino_t) - 1);
  94         return 0;
  95 out:
  96         xfs_trans_brelse(tp, ibp);
  97         return error;
  98 }
  99
 100 /*
 101  * On precommit, we grab the inode cluster buffer for the inode number we were
 102  * passed, then update the next unlinked field for that inode in the buffer and
 103  * log the buffer. This ensures that the inode cluster buffer was logged in the
 104  * correct order w.r.t. other inode cluster buffers. We can then remove the
 105  * iunlink item from the transaction and release it as it is has now served it's
 106  * purpose.
 107  */
 108 static int
 109 xfs_iunlink_item_precommit(
 110         struct xfs_trans        *tp,
 111         struct xfs_log_item     *lip)
 112 {
 113         struct xfs_iunlink_item *iup = IUL_ITEM(lip);
 114         int                     error;
 115
 116         error = xfs_iunlink_log_dinode(tp, iup);
 117         list_del(&lip->li_trans);
 118         xfs_iunlink_item_release(lip);
 119         return error;
 120 }
 121
 122 static const struct xfs_item_ops xfs_iunlink_item_ops = {
 123         .iop_release    = xfs_iunlink_item_release,
 124         .iop_sort       = xfs_iunlink_item_sort,
 125         .iop_precommit  = xfs_iunlink_item_precommit,
 126 };
 127
 128
 129 /*
 130  * Initialize the inode log item for a newly allocated (in-core) inode.
 131  *
 132  * Inode extents can only reside within an AG. Hence specify the starting
 133  * block for the inode chunk by offset within an AG as well as the
 134  * length of the allocated extent.
 135  *
 136  * This joins the item to the transaction and marks it dirty so
 137  * that we don't need a separate call to do this, nor does the
 138  * caller need to know anything about the iunlink item.
 139  */
 140 int
 141 xfs_iunlink_log_inode(
 142         struct xfs_trans        *tp,
 143         struct xfs_inode        *ip,
 144         struct xfs_perag        *pag,
 145         xfs_agino_t             next_agino)
 146 {
 147         struct xfs_mount        *mp = tp->t_mountp;
 148         struct xfs_iunlink_item *iup;
 149
 150         ASSERT(xfs_verify_agino_or_null(pag, next_agino));
 151         ASSERT(xfs_verify_agino_or_null(pag, ip->i_next_unlinked));
 152
 153         /*
 154          * Since we're updating a linked list, we should never find that the
 155          * current pointer is the same as the new value, unless we're
 156          * terminating the list.
 157          */
 158         if (ip->i_next_unlinked == next_agino) {
 159                 if (next_agino != NULLAGINO)
 160                         return -EFSCORRUPTED;
 161                 return 0;
 162         }
 163
 164         iup = kmem_cache_zalloc(xfs_iunlink_cache, GFP_KERNEL | __GFP_NOFAIL);
 165         xfs_log_item_init(mp, &iup->item, XFS_LI_IUNLINK,
 166                           &xfs_iunlink_item_ops);
 167
 168         iup->ip = ip;
 169         iup->next_agino = next_agino;
 170         iup->old_agino = ip->i_next_unlinked;
 171
 172         atomic_inc(&pag->pag_ref);
 173         iup->pag = pag;
 174
 175         xfs_trans_add_item(tp, &iup->item);
 176         tp->t_flags |= XFS_TRANS_DIRTY;
 177         set_bit(XFS_LI_DIRTY, &iup->item.li_flags);
 178         return 0;
 179 }
 180