fs/xfs/xfs_extfree_item.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright (c) 2000-2001,2005 Silicon Graphics, Inc.
   4  * All Rights Reserved.
   5  */
   6 #include "xfs.h"
   7 #include "xfs_fs.h"
   8 #include "xfs_format.h"
   9 #include "xfs_log_format.h"
  10 #include "xfs_trans_resv.h"
  11 #include "xfs_bit.h"
  12 #include "xfs_shared.h"
  13 #include "xfs_mount.h"
  14 #include "xfs_ag.h"
  15 #include "xfs_defer.h"
  16 #include "xfs_trans.h"
  17 #include "xfs_trans_priv.h"
  18 #include "xfs_extfree_item.h"
  19 #include "xfs_log.h"
  20 #include "xfs_btree.h"
  21 #include "xfs_rmap.h"
  22 #include "xfs_alloc.h"
  23 #include "xfs_bmap.h"
  24 #include "xfs_trace.h"
  25 #include "xfs_error.h"
  26 #include "xfs_log_priv.h"
  27 #include "xfs_log_recover.h"
  28 #include "xfs_rtalloc.h"
  29 #include "xfs_inode.h"
  30 #include "xfs_rtbitmap.h"
  31 #include "xfs_rtgroup.h"
  32
  33 struct kmem_cache       *xfs_efi_cache;
  34 struct kmem_cache       *xfs_efd_cache;
  35
  36 static const struct xfs_item_ops xfs_efi_item_ops;
  37
  38 static inline struct xfs_efi_log_item *EFI_ITEM(struct xfs_log_item *lip)
  39 {
  40         return container_of(lip, struct xfs_efi_log_item, efi_item);
  41 }
  42
  43 STATIC void
  44 xfs_efi_item_free(
  45         struct xfs_efi_log_item *efip)
  46 {
  47         kvfree(efip->efi_item.li_lv_shadow);
  48         if (efip->efi_format.efi_nextents > XFS_EFI_MAX_FAST_EXTENTS)
  49                 kfree(efip);
  50         else
  51                 kmem_cache_free(xfs_efi_cache, efip);
  52 }
  53
  54 /*
  55  * Freeing the efi requires that we remove it from the AIL if it has already
  56  * been placed there. However, the EFI may not yet have been placed in the AIL
  57  * when called by xfs_efi_release() from EFD processing due to the ordering of
  58  * committed vs unpin operations in bulk insert operations. Hence the reference
  59  * count to ensure only the last caller frees the EFI.
  60  */
  61 STATIC void
  62 xfs_efi_release(
  63         struct xfs_efi_log_item *efip)
  64 {
  65         ASSERT(atomic_read(&efip->efi_refcount) > 0);
  66         if (!atomic_dec_and_test(&efip->efi_refcount))
  67                 return;
  68
  69         xfs_trans_ail_delete(&efip->efi_item, 0);
  70         xfs_efi_item_free(efip);
  71 }
  72
  73 STATIC void
  74 xfs_efi_item_size(
  75         struct xfs_log_item     *lip,
  76         int                     *nvecs,
  77         int                     *nbytes)
  78 {
  79         struct xfs_efi_log_item *efip = EFI_ITEM(lip);
  80
  81         *nvecs += 1;
  82         *nbytes += xfs_efi_log_format_sizeof(efip->efi_format.efi_nextents);
  83 }
  84
  85 /*
  86  * This is called to fill in the vector of log iovecs for the
  87  * given efi log item. We use only 1 iovec, and we point that
  88  * at the efi_log_format structure embedded in the efi item.
  89  * It is at this point that we assert that all of the extent
  90  * slots in the efi item have been filled.
  91  */
  92 STATIC void
  93 xfs_efi_item_format(
  94         struct xfs_log_item     *lip,
  95         struct xfs_log_vec      *lv)
  96 {
  97         struct xfs_efi_log_item *efip = EFI_ITEM(lip);
  98         struct xfs_log_iovec    *vecp = NULL;
  99
 100         ASSERT(atomic_read(&efip->efi_next_extent) ==
 101                                 efip->efi_format.efi_nextents);
 102         ASSERT(lip->li_type == XFS_LI_EFI || lip->li_type == XFS_LI_EFI_RT);
 103
 104         efip->efi_format.efi_type = lip->li_type;
 105         efip->efi_format.efi_size = 1;
 106
 107         xlog_copy_iovec(lv, &vecp, XLOG_REG_TYPE_EFI_FORMAT, &efip->efi_format,
 108                         xfs_efi_log_format_sizeof(efip->efi_format.efi_nextents));
 109 }
 110
 111 /*
 112  * The unpin operation is the last place an EFI is manipulated in the log. It is
 113  * either inserted in the AIL or aborted in the event of a log I/O error. In
 114  * either case, the EFI transaction has been successfully committed to make it
 115  * this far. Therefore, we expect whoever committed the EFI to either construct
 116  * and commit the EFD or drop the EFD's reference in the event of error. Simply
 117  * drop the log's EFI reference now that the log is done with it.
 118  */
 119 STATIC void
 120 xfs_efi_item_unpin(
 121         struct xfs_log_item     *lip,
 122         int                     remove)
 123 {
 124         struct xfs_efi_log_item *efip = EFI_ITEM(lip);
 125         xfs_efi_release(efip);
 126 }
 127
 128 /*
 129  * The EFI has been either committed or aborted if the transaction has been
 130  * cancelled. If the transaction was cancelled, an EFD isn't going to be
 131  * constructed and thus we free the EFI here directly.
 132  */
 133 STATIC void
 134 xfs_efi_item_release(
 135         struct xfs_log_item     *lip)
 136 {
 137         xfs_efi_release(EFI_ITEM(lip));
 138 }
 139
 140 /*
 141  * Allocate and initialize an efi item with the given number of extents.
 142  */
 143 STATIC struct xfs_efi_log_item *
 144 xfs_efi_init(
 145         struct xfs_mount        *mp,
 146         unsigned short          item_type,
 147         uint                    nextents)
 148 {
 149         struct xfs_efi_log_item *efip;
 150
 151         ASSERT(item_type == XFS_LI_EFI || item_type == XFS_LI_EFI_RT);
 152         ASSERT(nextents > 0);
 153
 154         if (nextents > XFS_EFI_MAX_FAST_EXTENTS) {
 155                 efip = kzalloc(xfs_efi_log_item_sizeof(nextents),
 156                                 GFP_KERNEL | __GFP_NOFAIL);
 157         } else {
 158                 efip = kmem_cache_zalloc(xfs_efi_cache,
 159                                          GFP_KERNEL | __GFP_NOFAIL);
 160         }
 161
 162         xfs_log_item_init(mp, &efip->efi_item, item_type, &xfs_efi_item_ops);
 163         efip->efi_format.efi_nextents = nextents;
 164         efip->efi_format.efi_id = (uintptr_t)(void *)efip;
 165         atomic_set(&efip->efi_next_extent, 0);
 166         atomic_set(&efip->efi_refcount, 2);
 167
 168         return efip;
 169 }
 170
 171 /*
 172  * Copy an EFI format buffer from the given buf, and into the destination
 173  * EFI format structure.
 174  * The given buffer can be in 32 bit or 64 bit form (which has different padding),
 175  * one of which will be the native format for this kernel.
 176  * It will handle the conversion of formats if necessary.
 177  */
 178 STATIC int
 179 xfs_efi_copy_format(xfs_log_iovec_t *buf, xfs_efi_log_format_t *dst_efi_fmt)
 180 {
 181         xfs_efi_log_format_t *src_efi_fmt = buf->i_addr;
 182         uint i;
 183         uint len = xfs_efi_log_format_sizeof(src_efi_fmt->efi_nextents);
 184         uint len32 = xfs_efi_log_format32_sizeof(src_efi_fmt->efi_nextents);
 185         uint len64 = xfs_efi_log_format64_sizeof(src_efi_fmt->efi_nextents);
 186
 187         if (buf->i_len == len) {
 188                 memcpy(dst_efi_fmt, src_efi_fmt,
 189                        offsetof(struct xfs_efi_log_format, efi_extents));
 190                 for (i = 0; i < src_efi_fmt->efi_nextents; i++)
 191                         memcpy(&dst_efi_fmt->efi_extents[i],
 192                                &src_efi_fmt->efi_extents[i],
 193                                sizeof(struct xfs_extent));
 194                 return 0;
 195         } else if (buf->i_len == len32) {
 196                 xfs_efi_log_format_32_t *src_efi_fmt_32 = buf->i_addr;
 197
 198                 dst_efi_fmt->efi_type     = src_efi_fmt_32->efi_type;
 199                 dst_efi_fmt->efi_size     = src_efi_fmt_32->efi_size;
 200                 dst_efi_fmt->efi_nextents = src_efi_fmt_32->efi_nextents;
 201                 dst_efi_fmt->efi_id       = src_efi_fmt_32->efi_id;
 202                 for (i = 0; i < dst_efi_fmt->efi_nextents; i++) {
 203                         dst_efi_fmt->efi_extents[i].ext_start =
 204                                 src_efi_fmt_32->efi_extents[i].ext_start;
 205                         dst_efi_fmt->efi_extents[i].ext_len =
 206                                 src_efi_fmt_32->efi_extents[i].ext_len;
 207                 }
 208                 return 0;
 209         } else if (buf->i_len == len64) {
 210                 xfs_efi_log_format_64_t *src_efi_fmt_64 = buf->i_addr;
 211
 212                 dst_efi_fmt->efi_type     = src_efi_fmt_64->efi_type;
 213                 dst_efi_fmt->efi_size     = src_efi_fmt_64->efi_size;
 214                 dst_efi_fmt->efi_nextents = src_efi_fmt_64->efi_nextents;
 215                 dst_efi_fmt->efi_id       = src_efi_fmt_64->efi_id;
 216                 for (i = 0; i < dst_efi_fmt->efi_nextents; i++) {
 217                         dst_efi_fmt->efi_extents[i].ext_start =
 218                                 src_efi_fmt_64->efi_extents[i].ext_start;
 219                         dst_efi_fmt->efi_extents[i].ext_len =
 220                                 src_efi_fmt_64->efi_extents[i].ext_len;
 221                 }
 222                 return 0;
 223         }
 224         XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, NULL, buf->i_addr,
 225                         buf->i_len);
 226         return -EFSCORRUPTED;
 227 }
 228
 229 static inline struct xfs_efd_log_item *EFD_ITEM(struct xfs_log_item *lip)
 230 {
 231         return container_of(lip, struct xfs_efd_log_item, efd_item);
 232 }
 233
 234 STATIC void
 235 xfs_efd_item_free(struct xfs_efd_log_item *efdp)
 236 {
 237         kvfree(efdp->efd_item.li_lv_shadow);
 238         if (efdp->efd_format.efd_nextents > XFS_EFD_MAX_FAST_EXTENTS)
 239                 kfree(efdp);
 240         else
 241                 kmem_cache_free(xfs_efd_cache, efdp);
 242 }
 243
 244 STATIC void
 245 xfs_efd_item_size(
 246         struct xfs_log_item     *lip,
 247         int                     *nvecs,
 248         int                     *nbytes)
 249 {
 250         struct xfs_efd_log_item *efdp = EFD_ITEM(lip);
 251
 252         *nvecs += 1;
 253         *nbytes += xfs_efd_log_format_sizeof(efdp->efd_format.efd_nextents);
 254 }
 255
 256 /*
 257  * This is called to fill in the vector of log iovecs for the
 258  * given efd log item. We use only 1 iovec, and we point that
 259  * at the efd_log_format structure embedded in the efd item.
 260  * It is at this point that we assert that all of the extent
 261  * slots in the efd item have been filled.
 262  */
 263 STATIC void
 264 xfs_efd_item_format(
 265         struct xfs_log_item     *lip,
 266         struct xfs_log_vec      *lv)
 267 {
 268         struct xfs_efd_log_item *efdp = EFD_ITEM(lip);
 269         struct xfs_log_iovec    *vecp = NULL;
 270
 271         ASSERT(efdp->efd_next_extent == efdp->efd_format.efd_nextents);
 272         ASSERT(lip->li_type == XFS_LI_EFD || lip->li_type == XFS_LI_EFD_RT);
 273
 274         efdp->efd_format.efd_type = lip->li_type;
 275         efdp->efd_format.efd_size = 1;
 276
 277         xlog_copy_iovec(lv, &vecp, XLOG_REG_TYPE_EFD_FORMAT, &efdp->efd_format,
 278                         xfs_efd_log_format_sizeof(efdp->efd_format.efd_nextents));
 279 }
 280
 281 /*
 282  * The EFD is either committed or aborted if the transaction is cancelled. If
 283  * the transaction is cancelled, drop our reference to the EFI and free the EFD.
 284  */
 285 STATIC void
 286 xfs_efd_item_release(
 287         struct xfs_log_item     *lip)
 288 {
 289         struct xfs_efd_log_item *efdp = EFD_ITEM(lip);
 290
 291         xfs_efi_release(efdp->efd_efip);
 292         xfs_efd_item_free(efdp);
 293 }
 294
 295 static struct xfs_log_item *
 296 xfs_efd_item_intent(
 297         struct xfs_log_item     *lip)
 298 {
 299         return &EFD_ITEM(lip)->efd_efip->efi_item;
 300 }
 301
 302 static const struct xfs_item_ops xfs_efd_item_ops = {
 303         .flags          = XFS_ITEM_RELEASE_WHEN_COMMITTED |
 304                           XFS_ITEM_INTENT_DONE,
 305         .iop_size       = xfs_efd_item_size,
 306         .iop_format     = xfs_efd_item_format,
 307         .iop_release    = xfs_efd_item_release,
 308         .iop_intent     = xfs_efd_item_intent,
 309 };
 310
 311 static inline struct xfs_extent_free_item *xefi_entry(const struct list_head *e)
 312 {
 313         return list_entry(e, struct xfs_extent_free_item, xefi_list);
 314 }
 315
 316 static inline bool
 317 xfs_efi_item_isrt(const struct xfs_log_item *lip)
 318 {
 319         ASSERT(lip->li_type == XFS_LI_EFI || lip->li_type == XFS_LI_EFI_RT);
 320
 321         return lip->li_type == XFS_LI_EFI_RT;
 322 }
 323
 324 /*
 325  * Fill the EFD with all extents from the EFI when we need to roll the
 326  * transaction and continue with a new EFI.
 327  *
 328  * This simply copies all the extents in the EFI to the EFD rather than make
 329  * assumptions about which extents in the EFI have already been processed. We
 330  * currently keep the xefi list in the same order as the EFI extent list, but
 331  * that may not always be the case. Copying everything avoids leaving a landmine
 332  * were we fail to cancel all the extents in an EFI if the xefi list is
 333  * processed in a different order to the extents in the EFI.
 334  */
 335 static void
 336 xfs_efd_from_efi(
 337         struct xfs_efd_log_item *efdp)
 338 {
 339         struct xfs_efi_log_item *efip = efdp->efd_efip;
 340         uint                    i;
 341
 342         ASSERT(efip->efi_format.efi_nextents > 0);
 343         ASSERT(efdp->efd_next_extent < efip->efi_format.efi_nextents);
 344
 345         for (i = 0; i < efip->efi_format.efi_nextents; i++) {
 346                efdp->efd_format.efd_extents[i] =
 347                        efip->efi_format.efi_extents[i];
 348         }
 349         efdp->efd_next_extent = efip->efi_format.efi_nextents;
 350 }
 351
 352 static void
 353 xfs_efd_add_extent(
 354         struct xfs_efd_log_item         *efdp,
 355         struct xfs_extent_free_item     *xefi)
 356 {
 357         struct xfs_extent               *extp;
 358
 359         ASSERT(efdp->efd_next_extent < efdp->efd_format.efd_nextents);
 360
 361         extp = &efdp->efd_format.efd_extents[efdp->efd_next_extent];
 362         extp->ext_start = xefi->xefi_startblock;
 363         extp->ext_len = xefi->xefi_blockcount;
 364
 365         efdp->efd_next_extent++;
 366 }
 367
 368 /* Sort bmap items by AG. */
 369 static int
 370 xfs_extent_free_diff_items(
 371         void                            *priv,
 372         const struct list_head          *a,
 373         const struct list_head          *b)
 374 {
 375         struct xfs_extent_free_item     *ra = xefi_entry(a);
 376         struct xfs_extent_free_item     *rb = xefi_entry(b);
 377
 378         return ra->xefi_group->xg_gno - rb->xefi_group->xg_gno;
 379 }
 380
 381 /* Log a free extent to the intent item. */
 382 STATIC void
 383 xfs_extent_free_log_item(
 384         struct xfs_trans                *tp,
 385         struct xfs_efi_log_item         *efip,
 386         struct xfs_extent_free_item     *xefi)
 387 {
 388         uint                            next_extent;
 389         struct xfs_extent               *extp;
 390
 391         /*
 392          * atomic_inc_return gives us the value after the increment;
 393          * we want to use it as an array index so we need to subtract 1 from
 394          * it.
 395          */
 396         next_extent = atomic_inc_return(&efip->efi_next_extent) - 1;
 397         ASSERT(next_extent < efip->efi_format.efi_nextents);
 398         extp = &efip->efi_format.efi_extents[next_extent];
 399         extp->ext_start = xefi->xefi_startblock;
 400         extp->ext_len = xefi->xefi_blockcount;
 401 }
 402
 403 static struct xfs_log_item *
 404 __xfs_extent_free_create_intent(
 405         struct xfs_trans                *tp,
 406         struct list_head                *items,
 407         unsigned int                    count,
 408         bool                            sort,
 409         unsigned short                  item_type)
 410 {
 411         struct xfs_mount                *mp = tp->t_mountp;
 412         struct xfs_efi_log_item         *efip;
 413         struct xfs_extent_free_item     *xefi;
 414
 415         ASSERT(count > 0);
 416
 417         efip = xfs_efi_init(mp, item_type, count);
 418         if (sort)
 419                 list_sort(mp, items, xfs_extent_free_diff_items);
 420         list_for_each_entry(xefi, items, xefi_list)
 421                 xfs_extent_free_log_item(tp, efip, xefi);
 422         return &efip->efi_item;
 423 }
 424
 425 static struct xfs_log_item *
 426 xfs_extent_free_create_intent(
 427         struct xfs_trans                *tp,
 428         struct list_head                *items,
 429         unsigned int                    count,
 430         bool                            sort)
 431 {
 432         return __xfs_extent_free_create_intent(tp, items, count, sort,
 433                         XFS_LI_EFI);
 434 }
 435
 436 static inline unsigned short
 437 xfs_efd_type_from_efi(const struct xfs_efi_log_item *efip)
 438 {
 439         return xfs_efi_item_isrt(&efip->efi_item) ?  XFS_LI_EFD_RT : XFS_LI_EFD;
 440 }
 441
 442 /* Get an EFD so we can process all the free extents. */
 443 static struct xfs_log_item *
 444 xfs_extent_free_create_done(
 445         struct xfs_trans                *tp,
 446         struct xfs_log_item             *intent,
 447         unsigned int                    count)
 448 {
 449         struct xfs_efi_log_item         *efip = EFI_ITEM(intent);
 450         struct xfs_efd_log_item         *efdp;
 451
 452         ASSERT(count > 0);
 453
 454         if (count > XFS_EFD_MAX_FAST_EXTENTS) {
 455                 efdp = kzalloc(xfs_efd_log_item_sizeof(count),
 456                                 GFP_KERNEL | __GFP_NOFAIL);
 457         } else {
 458                 efdp = kmem_cache_zalloc(xfs_efd_cache,
 459                                         GFP_KERNEL | __GFP_NOFAIL);
 460         }
 461
 462         xfs_log_item_init(tp->t_mountp, &efdp->efd_item,
 463                         xfs_efd_type_from_efi(efip), &xfs_efd_item_ops);
 464         efdp->efd_efip = efip;
 465         efdp->efd_format.efd_nextents = count;
 466         efdp->efd_format.efd_efi_id = efip->efi_format.efi_id;
 467
 468         return &efdp->efd_item;
 469 }
 470
 471 static inline const struct xfs_defer_op_type *
 472 xefi_ops(
 473         struct xfs_extent_free_item     *xefi)
 474 {
 475         if (xfs_efi_is_realtime(xefi))
 476                 return &xfs_rtextent_free_defer_type;
 477         if (xefi->xefi_agresv == XFS_AG_RESV_AGFL)
 478                 return &xfs_agfl_free_defer_type;
 479         return &xfs_extent_free_defer_type;
 480 }
 481
 482 /* Add this deferred EFI to the transaction. */
 483 void
 484 xfs_extent_free_defer_add(
 485         struct xfs_trans                *tp,
 486         struct xfs_extent_free_item     *xefi,
 487         struct xfs_defer_pending        **dfpp)
 488 {
 489         struct xfs_mount                *mp = tp->t_mountp;
 490
 491         xefi->xefi_group = xfs_group_intent_get(mp, xefi->xefi_startblock,
 492                         xfs_efi_is_realtime(xefi) ? XG_TYPE_RTG : XG_TYPE_AG);
 493
 494         trace_xfs_extent_free_defer(mp, xefi);
 495         *dfpp = xfs_defer_add(tp, &xefi->xefi_list, xefi_ops(xefi));
 496 }
 497
 498 /* Cancel a free extent. */
 499 STATIC void
 500 xfs_extent_free_cancel_item(
 501         struct list_head                *item)
 502 {
 503         struct xfs_extent_free_item     *xefi = xefi_entry(item);
 504
 505         xfs_group_intent_put(xefi->xefi_group);
 506         kmem_cache_free(xfs_extfree_item_cache, xefi);
 507 }
 508
 509 /* Process a free extent. */
 510 STATIC int
 511 xfs_extent_free_finish_item(
 512         struct xfs_trans                *tp,
 513         struct xfs_log_item             *done,
 514         struct list_head                *item,
 515         struct xfs_btree_cur            **state)
 516 {
 517         struct xfs_owner_info           oinfo = { };
 518         struct xfs_extent_free_item     *xefi = xefi_entry(item);
 519         struct xfs_efd_log_item         *efdp = EFD_ITEM(done);
 520         struct xfs_mount                *mp = tp->t_mountp;
 521         xfs_agblock_t                   agbno;
 522         int                             error = 0;
 523
 524         agbno = XFS_FSB_TO_AGBNO(mp, xefi->xefi_startblock);
 525
 526         oinfo.oi_owner = xefi->xefi_owner;
 527         if (xefi->xefi_flags & XFS_EFI_ATTR_FORK)
 528                 oinfo.oi_flags |= XFS_OWNER_INFO_ATTR_FORK;
 529         if (xefi->xefi_flags & XFS_EFI_BMBT_BLOCK)
 530                 oinfo.oi_flags |= XFS_OWNER_INFO_BMBT_BLOCK;
 531
 532         trace_xfs_extent_free_deferred(mp, xefi);
 533
 534         /*
 535          * If we need a new transaction to make progress, the caller will log a
 536          * new EFI with the current contents. It will also log an EFD to cancel
 537          * the existing EFI, and so we need to copy all the unprocessed extents
 538          * in this EFI to the EFD so this works correctly.
 539          */
 540         if (!(xefi->xefi_flags & XFS_EFI_CANCELLED))
 541                 error = __xfs_free_extent(tp, to_perag(xefi->xefi_group), agbno,
 542                                 xefi->xefi_blockcount, &oinfo, xefi->xefi_agresv,
 543                                 xefi->xefi_flags & XFS_EFI_SKIP_DISCARD);
 544         if (error == -EAGAIN) {
 545                 xfs_efd_from_efi(efdp);
 546                 return error;
 547         }
 548
 549         xfs_efd_add_extent(efdp, xefi);
 550         xfs_extent_free_cancel_item(item);
 551         return error;
 552 }
 553
 554 /* Abort all pending EFIs. */
 555 STATIC void
 556 xfs_extent_free_abort_intent(
 557         struct xfs_log_item             *intent)
 558 {
 559         xfs_efi_release(EFI_ITEM(intent));
 560 }
 561
 562 /*
 563  * AGFL blocks are accounted differently in the reserve pools and are not
 564  * inserted into the busy extent list.
 565  */
 566 STATIC int
 567 xfs_agfl_free_finish_item(
 568         struct xfs_trans                *tp,
 569         struct xfs_log_item             *done,
 570         struct list_head                *item,
 571         struct xfs_btree_cur            **state)
 572 {
 573         struct xfs_owner_info           oinfo = { };
 574         struct xfs_mount                *mp = tp->t_mountp;
 575         struct xfs_efd_log_item         *efdp = EFD_ITEM(done);
 576         struct xfs_extent_free_item     *xefi = xefi_entry(item);
 577         struct xfs_buf                  *agbp;
 578         int                             error;
 579         xfs_agblock_t                   agbno;
 580
 581         ASSERT(xefi->xefi_blockcount == 1);
 582         agbno = XFS_FSB_TO_AGBNO(mp, xefi->xefi_startblock);
 583         oinfo.oi_owner = xefi->xefi_owner;
 584
 585         trace_xfs_agfl_free_deferred(mp, xefi);
 586
 587         error = xfs_alloc_read_agf(to_perag(xefi->xefi_group), tp, 0, &agbp);
 588         if (!error)
 589                 error = xfs_free_ag_extent(tp, agbp, agbno, 1, &oinfo,
 590                                 XFS_AG_RESV_AGFL);
 591
 592         xfs_efd_add_extent(efdp, xefi);
 593         xfs_extent_free_cancel_item(&xefi->xefi_list);
 594         return error;
 595 }
 596
 597 /* Is this recovered EFI ok? */
 598 static inline bool
 599 xfs_efi_validate_ext(
 600         struct xfs_mount                *mp,
 601         bool                            isrt,
 602         struct xfs_extent               *extp)
 603 {
 604         if (isrt)
 605                 return xfs_verify_rtbext(mp, extp->ext_start, extp->ext_len);
 606
 607         return xfs_verify_fsbext(mp, extp->ext_start, extp->ext_len);
 608 }
 609
 610 static inline void
 611 xfs_efi_recover_work(
 612         struct xfs_mount                *mp,
 613         struct xfs_defer_pending        *dfp,
 614         bool                            isrt,
 615         struct xfs_extent               *extp)
 616 {
 617         struct xfs_extent_free_item     *xefi;
 618
 619         xefi = kmem_cache_zalloc(xfs_extfree_item_cache,
 620                                GFP_KERNEL | __GFP_NOFAIL);
 621         xefi->xefi_startblock = extp->ext_start;
 622         xefi->xefi_blockcount = extp->ext_len;
 623         xefi->xefi_agresv = XFS_AG_RESV_NONE;
 624         xefi->xefi_owner = XFS_RMAP_OWN_UNKNOWN;
 625         xefi->xefi_group = xfs_group_intent_get(mp, extp->ext_start,
 626                         isrt ? XG_TYPE_RTG : XG_TYPE_AG);
 627         if (isrt)
 628                 xefi->xefi_flags |= XFS_EFI_REALTIME;
 629
 630         xfs_defer_add_item(dfp, &xefi->xefi_list);
 631 }
 632
 633 /*
 634  * Process an extent free intent item that was recovered from
 635  * the log.  We need to free the extents that it describes.
 636  */
 637 STATIC int
 638 xfs_extent_free_recover_work(
 639         struct xfs_defer_pending        *dfp,
 640         struct list_head                *capture_list)
 641 {
 642         struct xfs_trans_res            resv;
 643         struct xfs_log_item             *lip = dfp->dfp_intent;
 644         struct xfs_efi_log_item         *efip = EFI_ITEM(lip);
 645         struct xfs_mount                *mp = lip->li_log->l_mp;
 646         struct xfs_trans                *tp;
 647         int                             i;
 648         int                             error = 0;
 649         bool                            isrt = xfs_efi_item_isrt(lip);
 650
 651         /*
 652          * First check the validity of the extents described by the EFI.  If
 653          * any are bad, then assume that all are bad and just toss the EFI.
 654          * Mixing RT and non-RT extents in the same EFI item is not allowed.
 655          */
 656         for (i = 0; i < efip->efi_format.efi_nextents; i++) {
 657                 if (!xfs_efi_validate_ext(mp, isrt,
 658                                         &efip->efi_format.efi_extents[i])) {
 659                         XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp,
 660                                         &efip->efi_format,
 661                                         sizeof(efip->efi_format));
 662                         return -EFSCORRUPTED;
 663                 }
 664
 665                 xfs_efi_recover_work(mp, dfp, isrt,
 666                                 &efip->efi_format.efi_extents[i]);
 667         }
 668
 669         resv = xlog_recover_resv(&M_RES(mp)->tr_itruncate);
 670         error = xfs_trans_alloc(mp, &resv, 0, 0, 0, &tp);
 671         if (error)
 672                 return error;
 673
 674         error = xlog_recover_finish_intent(tp, dfp);
 675         if (error == -EFSCORRUPTED)
 676                 XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp,
 677                                 &efip->efi_format,
 678                                 sizeof(efip->efi_format));
 679         if (error)
 680                 goto abort_error;
 681
 682         return xfs_defer_ops_capture_and_commit(tp, capture_list);
 683
 684 abort_error:
 685         xfs_trans_cancel(tp);
 686         return error;
 687 }
 688
 689 /* Relog an intent item to push the log tail forward. */
 690 static struct xfs_log_item *
 691 xfs_extent_free_relog_intent(
 692         struct xfs_trans                *tp,
 693         struct xfs_log_item             *intent,
 694         struct xfs_log_item             *done_item)
 695 {
 696         struct xfs_efd_log_item         *efdp = EFD_ITEM(done_item);
 697         struct xfs_efi_log_item         *efip;
 698         struct xfs_extent               *extp;
 699         unsigned int                    count;
 700
 701         count = EFI_ITEM(intent)->efi_format.efi_nextents;
 702         extp = EFI_ITEM(intent)->efi_format.efi_extents;
 703
 704         ASSERT(intent->li_type == XFS_LI_EFI || intent->li_type == XFS_LI_EFI_RT);
 705
 706         efdp->efd_next_extent = count;
 707         memcpy(efdp->efd_format.efd_extents, extp, count * sizeof(*extp));
 708
 709         efip = xfs_efi_init(tp->t_mountp, intent->li_type, count);
 710         memcpy(efip->efi_format.efi_extents, extp, count * sizeof(*extp));
 711         atomic_set(&efip->efi_next_extent, count);
 712
 713         return &efip->efi_item;
 714 }
 715
 716 const struct xfs_defer_op_type xfs_extent_free_defer_type = {
 717         .name           = "extent_free",
 718         .max_items      = XFS_EFI_MAX_FAST_EXTENTS,
 719         .create_intent  = xfs_extent_free_create_intent,
 720         .abort_intent   = xfs_extent_free_abort_intent,
 721         .create_done    = xfs_extent_free_create_done,
 722         .finish_item    = xfs_extent_free_finish_item,
 723         .cancel_item    = xfs_extent_free_cancel_item,
 724         .recover_work   = xfs_extent_free_recover_work,
 725         .relog_intent   = xfs_extent_free_relog_intent,
 726 };
 727
 728 /* sub-type with special handling for AGFL deferred frees */
 729 const struct xfs_defer_op_type xfs_agfl_free_defer_type = {
 730         .name           = "agfl_free",
 731         .max_items      = XFS_EFI_MAX_FAST_EXTENTS,
 732         .create_intent  = xfs_extent_free_create_intent,
 733         .abort_intent   = xfs_extent_free_abort_intent,
 734         .create_done    = xfs_extent_free_create_done,
 735         .finish_item    = xfs_agfl_free_finish_item,
 736         .cancel_item    = xfs_extent_free_cancel_item,
 737         .recover_work   = xfs_extent_free_recover_work,
 738         .relog_intent   = xfs_extent_free_relog_intent,
 739 };
 740
 741 #ifdef CONFIG_XFS_RT
 742 /* Create a realtime extent freeing */
 743 static struct xfs_log_item *
 744 xfs_rtextent_free_create_intent(
 745         struct xfs_trans                *tp,
 746         struct list_head                *items,
 747         unsigned int                    count,
 748         bool                            sort)
 749 {
 750         return __xfs_extent_free_create_intent(tp, items, count, sort,
 751                         XFS_LI_EFI_RT);
 752 }
 753
 754 /* Process a free realtime extent. */
 755 STATIC int
 756 xfs_rtextent_free_finish_item(
 757         struct xfs_trans                *tp,
 758         struct xfs_log_item             *done,
 759         struct list_head                *item,
 760         struct xfs_btree_cur            **state)
 761 {
 762         struct xfs_mount                *mp = tp->t_mountp;
 763         struct xfs_extent_free_item     *xefi = xefi_entry(item);
 764         struct xfs_efd_log_item         *efdp = EFD_ITEM(done);
 765         struct xfs_rtgroup              **rtgp = (struct xfs_rtgroup **)state;
 766         int                             error = 0;
 767
 768         trace_xfs_extent_free_deferred(mp, xefi);
 769
 770         if (!(xefi->xefi_flags & XFS_EFI_CANCELLED)) {
 771                 if (*rtgp != to_rtg(xefi->xefi_group)) {
 772                         *rtgp = to_rtg(xefi->xefi_group);
 773                         xfs_rtgroup_lock(*rtgp, XFS_RTGLOCK_BITMAP);
 774                         xfs_rtgroup_trans_join(tp, *rtgp,
 775                                         XFS_RTGLOCK_BITMAP);
 776                 }
 777                 error = xfs_rtfree_blocks(tp, *rtgp,
 778                                 xefi->xefi_startblock, xefi->xefi_blockcount);
 779         }
 780         if (error == -EAGAIN) {
 781                 xfs_efd_from_efi(efdp);
 782                 return error;
 783         }
 784
 785         xfs_efd_add_extent(efdp, xefi);
 786         xfs_extent_free_cancel_item(item);
 787         return error;
 788 }
 789
 790 const struct xfs_defer_op_type xfs_rtextent_free_defer_type = {
 791         .name           = "rtextent_free",
 792         .max_items      = XFS_EFI_MAX_FAST_EXTENTS,
 793         .create_intent  = xfs_rtextent_free_create_intent,
 794         .abort_intent   = xfs_extent_free_abort_intent,
 795         .create_done    = xfs_extent_free_create_done,
 796         .finish_item    = xfs_rtextent_free_finish_item,
 797         .cancel_item    = xfs_extent_free_cancel_item,
 798         .recover_work   = xfs_extent_free_recover_work,
 799         .relog_intent   = xfs_extent_free_relog_intent,
 800 };
 801 #else
 802 const struct xfs_defer_op_type xfs_rtextent_free_defer_type = {
 803         .name           = "rtextent_free",
 804 };
 805 #endif /* CONFIG_XFS_RT */
 806
 807 STATIC bool
 808 xfs_efi_item_match(
 809         struct xfs_log_item     *lip,
 810         uint64_t                intent_id)
 811 {
 812         return EFI_ITEM(lip)->efi_format.efi_id == intent_id;
 813 }
 814
 815 static const struct xfs_item_ops xfs_efi_item_ops = {
 816         .flags          = XFS_ITEM_INTENT,
 817         .iop_size       = xfs_efi_item_size,
 818         .iop_format     = xfs_efi_item_format,
 819         .iop_unpin      = xfs_efi_item_unpin,
 820         .iop_release    = xfs_efi_item_release,
 821         .iop_match      = xfs_efi_item_match,
 822 };
 823
 824 /*
 825  * This routine is called to create an in-core extent free intent
 826  * item from the efi format structure which was logged on disk.
 827  * It allocates an in-core efi, copies the extents from the format
 828  * structure into it, and adds the efi to the AIL with the given
 829  * LSN.
 830  */
 831 STATIC int
 832 xlog_recover_efi_commit_pass2(
 833         struct xlog                     *log,
 834         struct list_head                *buffer_list,
 835         struct xlog_recover_item        *item,
 836         xfs_lsn_t                       lsn)
 837 {
 838         struct xfs_mount                *mp = log->l_mp;
 839         struct xfs_efi_log_item         *efip;
 840         struct xfs_efi_log_format       *efi_formatp;
 841         int                             error;
 842
 843         efi_formatp = item->ri_buf[0].i_addr;
 844
 845         if (item->ri_buf[0].i_len < xfs_efi_log_format_sizeof(0)) {
 846                 XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp,
 847                                 item->ri_buf[0].i_addr, item->ri_buf[0].i_len);
 848                 return -EFSCORRUPTED;
 849         }
 850
 851         efip = xfs_efi_init(mp, ITEM_TYPE(item), efi_formatp->efi_nextents);
 852         error = xfs_efi_copy_format(&item->ri_buf[0], &efip->efi_format);
 853         if (error) {
 854                 xfs_efi_item_free(efip);
 855                 return error;
 856         }
 857         atomic_set(&efip->efi_next_extent, efi_formatp->efi_nextents);
 858
 859         xlog_recover_intent_item(log, &efip->efi_item, lsn,
 860                         &xfs_extent_free_defer_type);
 861         return 0;
 862 }
 863
 864 const struct xlog_recover_item_ops xlog_efi_item_ops = {
 865         .item_type              = XFS_LI_EFI,
 866         .commit_pass2           = xlog_recover_efi_commit_pass2,
 867 };
 868
 869 #ifdef CONFIG_XFS_RT
 870 STATIC int
 871 xlog_recover_rtefi_commit_pass2(
 872         struct xlog                     *log,
 873         struct list_head                *buffer_list,
 874         struct xlog_recover_item        *item,
 875         xfs_lsn_t                       lsn)
 876 {
 877         struct xfs_mount                *mp = log->l_mp;
 878         struct xfs_efi_log_item         *efip;
 879         struct xfs_efi_log_format       *efi_formatp;
 880         int                             error;
 881
 882         efi_formatp = item->ri_buf[0].i_addr;
 883
 884         if (item->ri_buf[0].i_len < xfs_efi_log_format_sizeof(0)) {
 885                 XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp,
 886                                 item->ri_buf[0].i_addr, item->ri_buf[0].i_len);
 887                 return -EFSCORRUPTED;
 888         }
 889
 890         efip = xfs_efi_init(mp, ITEM_TYPE(item), efi_formatp->efi_nextents);
 891         error = xfs_efi_copy_format(&item->ri_buf[0], &efip->efi_format);
 892         if (error) {
 893                 xfs_efi_item_free(efip);
 894                 return error;
 895         }
 896         atomic_set(&efip->efi_next_extent, efi_formatp->efi_nextents);
 897
 898         xlog_recover_intent_item(log, &efip->efi_item, lsn,
 899                         &xfs_rtextent_free_defer_type);
 900         return 0;
 901 }
 902 #else
 903 STATIC int
 904 xlog_recover_rtefi_commit_pass2(
 905         struct xlog                     *log,
 906         struct list_head                *buffer_list,
 907         struct xlog_recover_item        *item,
 908         xfs_lsn_t                       lsn)
 909 {
 910         XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, log->l_mp,
 911                         item->ri_buf[0].i_addr, item->ri_buf[0].i_len);
 912         return -EFSCORRUPTED;
 913 }
 914 #endif
 915
 916 const struct xlog_recover_item_ops xlog_rtefi_item_ops = {
 917         .item_type              = XFS_LI_EFI_RT,
 918         .commit_pass2           = xlog_recover_rtefi_commit_pass2,
 919 };
 920
 921 /*
 922  * This routine is called when an EFD format structure is found in a committed
 923  * transaction in the log. Its purpose is to cancel the corresponding EFI if it
 924  * was still in the log. To do this it searches the AIL for the EFI with an id
 925  * equal to that in the EFD format structure. If we find it we drop the EFD
 926  * reference, which removes the EFI from the AIL and frees it.
 927  */
 928 STATIC int
 929 xlog_recover_efd_commit_pass2(
 930         struct xlog                     *log,
 931         struct list_head                *buffer_list,
 932         struct xlog_recover_item        *item,
 933         xfs_lsn_t                       lsn)
 934 {
 935         struct xfs_efd_log_format       *efd_formatp;
 936         int                             buflen = item->ri_buf[0].i_len;
 937
 938         efd_formatp = item->ri_buf[0].i_addr;
 939
 940         if (buflen < sizeof(struct xfs_efd_log_format)) {
 941                 XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, log->l_mp,
 942                                 efd_formatp, buflen);
 943                 return -EFSCORRUPTED;
 944         }
 945
 946         if (item->ri_buf[0].i_len != xfs_efd_log_format32_sizeof(
 947                                                 efd_formatp->efd_nextents) &&
 948             item->ri_buf[0].i_len != xfs_efd_log_format64_sizeof(
 949                                                 efd_formatp->efd_nextents)) {
 950                 XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, log->l_mp,
 951                                 efd_formatp, buflen);
 952                 return -EFSCORRUPTED;
 953         }
 954
 955         xlog_recover_release_intent(log, XFS_LI_EFI, efd_formatp->efd_efi_id);
 956         return 0;
 957 }
 958
 959 const struct xlog_recover_item_ops xlog_efd_item_ops = {
 960         .item_type              = XFS_LI_EFD,
 961         .commit_pass2           = xlog_recover_efd_commit_pass2,
 962 };
 963
 964 #ifdef CONFIG_XFS_RT
 965 STATIC int
 966 xlog_recover_rtefd_commit_pass2(
 967         struct xlog                     *log,
 968         struct list_head                *buffer_list,
 969         struct xlog_recover_item        *item,
 970         xfs_lsn_t                       lsn)
 971 {
 972         struct xfs_efd_log_format       *efd_formatp;
 973         int                             buflen = item->ri_buf[0].i_len;
 974
 975         efd_formatp = item->ri_buf[0].i_addr;
 976
 977         if (buflen < sizeof(struct xfs_efd_log_format)) {
 978                 XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, log->l_mp,
 979                                 efd_formatp, buflen);
 980                 return -EFSCORRUPTED;
 981         }
 982
 983         if (item->ri_buf[0].i_len != xfs_efd_log_format32_sizeof(
 984                                                 efd_formatp->efd_nextents) &&
 985             item->ri_buf[0].i_len != xfs_efd_log_format64_sizeof(
 986                                                 efd_formatp->efd_nextents)) {
 987                 XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, log->l_mp,
 988                                 efd_formatp, buflen);
 989                 return -EFSCORRUPTED;
 990         }
 991
 992         xlog_recover_release_intent(log, XFS_LI_EFI_RT,
 993                         efd_formatp->efd_efi_id);
 994         return 0;
 995 }
 996 #else
 997 # define xlog_recover_rtefd_commit_pass2        xlog_recover_rtefi_commit_pass2
 998 #endif
 999
1000 const struct xlog_recover_item_ops xlog_rtefd_item_ops = {
1001         .item_type              = XFS_LI_EFD_RT,
1002         .commit_pass2           = xlog_recover_rtefd_commit_pass2,
1003 };