fs/xfs/xfs_trans_extfree.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright (c) 2000,2005 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_bit.h"
  13 #include "xfs_mount.h"
  14 #include "xfs_defer.h"
  15 #include "xfs_trans.h"
  16 #include "xfs_trans_priv.h"
  17 #include "xfs_extfree_item.h"
  18 #include "xfs_alloc.h"
  19 #include "xfs_bmap.h"
  20 #include "xfs_trace.h"
  21
  22 /*
  23  * This routine is called to allocate an "extent free done"
  24  * log item that will hold nextents worth of extents.  The
  25  * caller must use all nextents extents, because we are not
  26  * flexible about this at all.
  27  */
  28 struct xfs_efd_log_item *
  29 xfs_trans_get_efd(struct xfs_trans              *tp,
  30                   struct xfs_efi_log_item       *efip,
  31                   uint                          nextents)
  32 {
  33         struct xfs_efd_log_item                 *efdp;
  34
  35         ASSERT(tp != NULL);
  36         ASSERT(nextents > 0);
  37
  38         efdp = xfs_efd_init(tp->t_mountp, efip, nextents);
  39         ASSERT(efdp != NULL);
  40
  41         /*
  42          * Get a log_item_desc to point at the new item.
  43          */
  44         xfs_trans_add_item(tp, &efdp->efd_item);
  45         return efdp;
  46 }
  47
  48 /*
  49  * Free an extent and log it to the EFD. Note that the transaction is marked
  50  * dirty regardless of whether the extent free succeeds or fails to support the
  51  * EFI/EFD lifecycle rules.
  52  */
  53 int
  54 xfs_trans_free_extent(
  55         struct xfs_trans        *tp,
  56         struct xfs_efd_log_item *efdp,
  57         xfs_fsblock_t           start_block,
  58         xfs_extlen_t            ext_len,
  59         struct xfs_owner_info   *oinfo,
  60         bool                    skip_discard)
  61 {
  62         struct xfs_mount        *mp = tp->t_mountp;
  63         uint                    next_extent;
  64         xfs_agnumber_t          agno = XFS_FSB_TO_AGNO(mp, start_block);
  65         xfs_agblock_t           agbno = XFS_FSB_TO_AGBNO(mp, start_block);
  66         struct xfs_extent       *extp;
  67         int                     error;
  68
  69         trace_xfs_bmap_free_deferred(tp->t_mountp, agno, 0, agbno, ext_len);
  70
  71         error = __xfs_free_extent(tp, start_block, ext_len,
  72                                   oinfo, XFS_AG_RESV_NONE, skip_discard);
  73         /*
  74          * Mark the transaction dirty, even on error. This ensures the
  75          * transaction is aborted, which:
  76          *
  77          * 1.) releases the EFI and frees the EFD
  78          * 2.) shuts down the filesystem
  79          */
  80         tp->t_flags |= XFS_TRANS_DIRTY;
  81         set_bit(XFS_LI_DIRTY, &efdp->efd_item.li_flags);
  82
  83         next_extent = efdp->efd_next_extent;
  84         ASSERT(next_extent < efdp->efd_format.efd_nextents);
  85         extp = &(efdp->efd_format.efd_extents[next_extent]);
  86         extp->ext_start = start_block;
  87         extp->ext_len = ext_len;
  88         efdp->efd_next_extent++;
  89
  90         return error;
  91 }
  92
  93 /* Sort bmap items by AG. */
  94 static int
  95 xfs_extent_free_diff_items(
  96         void                            *priv,
  97         struct list_head                *a,
  98         struct list_head                *b)
  99 {
 100         struct xfs_mount                *mp = priv;
 101         struct xfs_extent_free_item     *ra;
 102         struct xfs_extent_free_item     *rb;
 103
 104         ra = container_of(a, struct xfs_extent_free_item, xefi_list);
 105         rb = container_of(b, struct xfs_extent_free_item, xefi_list);
 106         return  XFS_FSB_TO_AGNO(mp, ra->xefi_startblock) -
 107                 XFS_FSB_TO_AGNO(mp, rb->xefi_startblock);
 108 }
 109
 110 /* Get an EFI. */
 111 STATIC void *
 112 xfs_extent_free_create_intent(
 113         struct xfs_trans                *tp,
 114         unsigned int                    count)
 115 {
 116         struct xfs_efi_log_item         *efip;
 117
 118         ASSERT(tp != NULL);
 119         ASSERT(count > 0);
 120
 121         efip = xfs_efi_init(tp->t_mountp, count);
 122         ASSERT(efip != NULL);
 123
 124         /*
 125          * Get a log_item_desc to point at the new item.
 126          */
 127         xfs_trans_add_item(tp, &efip->efi_item);
 128         return efip;
 129 }
 130
 131 /* Log a free extent to the intent item. */
 132 STATIC void
 133 xfs_extent_free_log_item(
 134         struct xfs_trans                *tp,
 135         void                            *intent,
 136         struct list_head                *item)
 137 {
 138         struct xfs_efi_log_item         *efip = intent;
 139         struct xfs_extent_free_item     *free;
 140         uint                            next_extent;
 141         struct xfs_extent               *extp;
 142
 143         free = container_of(item, struct xfs_extent_free_item, xefi_list);
 144
 145         tp->t_flags |= XFS_TRANS_DIRTY;
 146         set_bit(XFS_LI_DIRTY, &efip->efi_item.li_flags);
 147
 148         /*
 149          * atomic_inc_return gives us the value after the increment;
 150          * we want to use it as an array index so we need to subtract 1 from
 151          * it.
 152          */
 153         next_extent = atomic_inc_return(&efip->efi_next_extent) - 1;
 154         ASSERT(next_extent < efip->efi_format.efi_nextents);
 155         extp = &efip->efi_format.efi_extents[next_extent];
 156         extp->ext_start = free->xefi_startblock;
 157         extp->ext_len = free->xefi_blockcount;
 158 }
 159
 160 /* Get an EFD so we can process all the free extents. */
 161 STATIC void *
 162 xfs_extent_free_create_done(
 163         struct xfs_trans                *tp,
 164         void                            *intent,
 165         unsigned int                    count)
 166 {
 167         return xfs_trans_get_efd(tp, intent, count);
 168 }
 169
 170 /* Process a free extent. */
 171 STATIC int
 172 xfs_extent_free_finish_item(
 173         struct xfs_trans                *tp,
 174         struct list_head                *item,
 175         void                            *done_item,
 176         void                            **state)
 177 {
 178         struct xfs_extent_free_item     *free;
 179         int                             error;
 180
 181         free = container_of(item, struct xfs_extent_free_item, xefi_list);
 182         error = xfs_trans_free_extent(tp, done_item,
 183                         free->xefi_startblock,
 184                         free->xefi_blockcount,
 185                         &free->xefi_oinfo, free->xefi_skip_discard);
 186         kmem_free(free);
 187         return error;
 188 }
 189
 190 /* Abort all pending EFIs. */
 191 STATIC void
 192 xfs_extent_free_abort_intent(
 193         void                            *intent)
 194 {
 195         xfs_efi_release(intent);
 196 }
 197
 198 /* Cancel a free extent. */
 199 STATIC void
 200 xfs_extent_free_cancel_item(
 201         struct list_head                *item)
 202 {
 203         struct xfs_extent_free_item     *free;
 204
 205         free = container_of(item, struct xfs_extent_free_item, xefi_list);
 206         kmem_free(free);
 207 }
 208
 209 static const struct xfs_defer_op_type xfs_extent_free_defer_type = {
 210         .type           = XFS_DEFER_OPS_TYPE_FREE,
 211         .max_items      = XFS_EFI_MAX_FAST_EXTENTS,
 212         .diff_items     = xfs_extent_free_diff_items,
 213         .create_intent  = xfs_extent_free_create_intent,
 214         .abort_intent   = xfs_extent_free_abort_intent,
 215         .log_item       = xfs_extent_free_log_item,
 216         .create_done    = xfs_extent_free_create_done,
 217         .finish_item    = xfs_extent_free_finish_item,
 218         .cancel_item    = xfs_extent_free_cancel_item,
 219 };
 220
 221 /*
 222  * AGFL blocks are accounted differently in the reserve pools and are not
 223  * inserted into the busy extent list.
 224  */
 225 STATIC int
 226 xfs_agfl_free_finish_item(
 227         struct xfs_trans                *tp,
 228         struct list_head                *item,
 229         void                            *done_item,
 230         void                            **state)
 231 {
 232         struct xfs_mount                *mp = tp->t_mountp;
 233         struct xfs_efd_log_item         *efdp = done_item;
 234         struct xfs_extent_free_item     *free;
 235         struct xfs_extent               *extp;
 236         struct xfs_buf                  *agbp;
 237         int                             error;
 238         xfs_agnumber_t                  agno;
 239         xfs_agblock_t                   agbno;
 240         uint                            next_extent;
 241
 242         free = container_of(item, struct xfs_extent_free_item, xefi_list);
 243         ASSERT(free->xefi_blockcount == 1);
 244         agno = XFS_FSB_TO_AGNO(mp, free->xefi_startblock);
 245         agbno = XFS_FSB_TO_AGBNO(mp, free->xefi_startblock);
 246
 247         trace_xfs_agfl_free_deferred(mp, agno, 0, agbno, free->xefi_blockcount);
 248
 249         error = xfs_alloc_read_agf(mp, tp, agno, 0, &agbp);
 250         if (!error)
 251                 error = xfs_free_agfl_block(tp, agno, agbno, agbp,
 252                                             &free->xefi_oinfo);
 253
 254         /*
 255          * Mark the transaction dirty, even on error. This ensures the
 256          * transaction is aborted, which:
 257          *
 258          * 1.) releases the EFI and frees the EFD
 259          * 2.) shuts down the filesystem
 260          */
 261         tp->t_flags |= XFS_TRANS_DIRTY;
 262         set_bit(XFS_LI_DIRTY, &efdp->efd_item.li_flags);
 263
 264         next_extent = efdp->efd_next_extent;
 265         ASSERT(next_extent < efdp->efd_format.efd_nextents);
 266         extp = &(efdp->efd_format.efd_extents[next_extent]);
 267         extp->ext_start = free->xefi_startblock;
 268         extp->ext_len = free->xefi_blockcount;
 269         efdp->efd_next_extent++;
 270
 271         kmem_free(free);
 272         return error;
 273 }
 274
 275
 276 /* sub-type with special handling for AGFL deferred frees */
 277 static const struct xfs_defer_op_type xfs_agfl_free_defer_type = {
 278         .type           = XFS_DEFER_OPS_TYPE_AGFL_FREE,
 279         .max_items      = XFS_EFI_MAX_FAST_EXTENTS,
 280         .diff_items     = xfs_extent_free_diff_items,
 281         .create_intent  = xfs_extent_free_create_intent,
 282         .abort_intent   = xfs_extent_free_abort_intent,
 283         .log_item       = xfs_extent_free_log_item,
 284         .create_done    = xfs_extent_free_create_done,
 285         .finish_item    = xfs_agfl_free_finish_item,
 286         .cancel_item    = xfs_extent_free_cancel_item,
 287 };
 288
 289 /* Register the deferred op type. */
 290 void
 291 xfs_extent_free_init_defer_op(void)
 292 {
 293         xfs_defer_init_op_type(&xfs_extent_free_defer_type);
 294         xfs_defer_init_op_type(&xfs_agfl_free_defer_type);
 295 }