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_mount.h"
  13 #include "xfs_trans.h"
  14 #include "xfs_trans_priv.h"
  15 #include "xfs_buf_item.h"
  16 #include "xfs_extfree_item.h"
  17 #include "xfs_log.h"
  18 #include "xfs_btree.h"
  19 #include "xfs_rmap.h"
  20
  21
  22 kmem_zone_t     *xfs_efi_zone;
  23 kmem_zone_t     *xfs_efd_zone;
  24
  25 static inline struct xfs_efi_log_item *EFI_ITEM(struct xfs_log_item *lip)
  26 {
  27         return container_of(lip, struct xfs_efi_log_item, efi_item);
  28 }
  29
  30 void
  31 xfs_efi_item_free(
  32         struct xfs_efi_log_item *efip)
  33 {
  34         kmem_free(efip->efi_item.li_lv_shadow);
  35         if (efip->efi_format.efi_nextents > XFS_EFI_MAX_FAST_EXTENTS)
  36                 kmem_free(efip);
  37         else
  38                 kmem_zone_free(xfs_efi_zone, efip);
  39 }
  40
  41 /*
  42  * Freeing the efi requires that we remove it from the AIL if it has already
  43  * been placed there. However, the EFI may not yet have been placed in the AIL
  44  * when called by xfs_efi_release() from EFD processing due to the ordering of
  45  * committed vs unpin operations in bulk insert operations. Hence the reference
  46  * count to ensure only the last caller frees the EFI.
  47  */
  48 void
  49 xfs_efi_release(
  50         struct xfs_efi_log_item *efip)
  51 {
  52         ASSERT(atomic_read(&efip->efi_refcount) > 0);
  53         if (atomic_dec_and_test(&efip->efi_refcount)) {
  54                 xfs_trans_ail_remove(&efip->efi_item, SHUTDOWN_LOG_IO_ERROR);
  55                 xfs_efi_item_free(efip);
  56         }
  57 }
  58
  59 /*
  60  * This returns the number of iovecs needed to log the given efi item.
  61  * We only need 1 iovec for an efi item.  It just logs the efi_log_format
  62  * structure.
  63  */
  64 static inline int
  65 xfs_efi_item_sizeof(
  66         struct xfs_efi_log_item *efip)
  67 {
  68         return sizeof(struct xfs_efi_log_format) +
  69                (efip->efi_format.efi_nextents - 1) * sizeof(xfs_extent_t);
  70 }
  71
  72 STATIC void
  73 xfs_efi_item_size(
  74         struct xfs_log_item     *lip,
  75         int                     *nvecs,
  76         int                     *nbytes)
  77 {
  78         *nvecs += 1;
  79         *nbytes += xfs_efi_item_sizeof(EFI_ITEM(lip));
  80 }
  81
  82 /*
  83  * This is called to fill in the vector of log iovecs for the
  84  * given efi log item. We use only 1 iovec, and we point that
  85  * at the efi_log_format structure embedded in the efi item.
  86  * It is at this point that we assert that all of the extent
  87  * slots in the efi item have been filled.
  88  */
  89 STATIC void
  90 xfs_efi_item_format(
  91         struct xfs_log_item     *lip,
  92         struct xfs_log_vec      *lv)
  93 {
  94         struct xfs_efi_log_item *efip = EFI_ITEM(lip);
  95         struct xfs_log_iovec    *vecp = NULL;
  96
  97         ASSERT(atomic_read(&efip->efi_next_extent) ==
  98                                 efip->efi_format.efi_nextents);
  99
 100         efip->efi_format.efi_type = XFS_LI_EFI;
 101         efip->efi_format.efi_size = 1;
 102
 103         xlog_copy_iovec(lv, &vecp, XLOG_REG_TYPE_EFI_FORMAT,
 104                         &efip->efi_format,
 105                         xfs_efi_item_sizeof(efip));
 106 }
 107
 108
 109 /*
 110  * Pinning has no meaning for an efi item, so just return.
 111  */
 112 STATIC void
 113 xfs_efi_item_pin(
 114         struct xfs_log_item     *lip)
 115 {
 116 }
 117
 118 /*
 119  * The unpin operation is the last place an EFI is manipulated in the log. It is
 120  * either inserted in the AIL or aborted in the event of a log I/O error. In
 121  * either case, the EFI transaction has been successfully committed to make it
 122  * this far. Therefore, we expect whoever committed the EFI to either construct
 123  * and commit the EFD or drop the EFD's reference in the event of error. Simply
 124  * drop the log's EFI reference now that the log is done with it.
 125  */
 126 STATIC void
 127 xfs_efi_item_unpin(
 128         struct xfs_log_item     *lip,
 129         int                     remove)
 130 {
 131         struct xfs_efi_log_item *efip = EFI_ITEM(lip);
 132         xfs_efi_release(efip);
 133 }
 134
 135 /*
 136  * Efi items have no locking or pushing.  However, since EFIs are pulled from
 137  * the AIL when their corresponding EFDs are committed to disk, their situation
 138  * is very similar to being pinned.  Return XFS_ITEM_PINNED so that the caller
 139  * will eventually flush the log.  This should help in getting the EFI out of
 140  * the AIL.
 141  */
 142 STATIC uint
 143 xfs_efi_item_push(
 144         struct xfs_log_item     *lip,
 145         struct list_head        *buffer_list)
 146 {
 147         return XFS_ITEM_PINNED;
 148 }
 149
 150 /*
 151  * The EFI has been either committed or aborted if the transaction has been
 152  * cancelled. If the transaction was cancelled, an EFD isn't going to be
 153  * constructed and thus we free the EFI here directly.
 154  */
 155 STATIC void
 156 xfs_efi_item_unlock(
 157         struct xfs_log_item     *lip)
 158 {
 159         if (test_bit(XFS_LI_ABORTED, &lip->li_flags))
 160                 xfs_efi_release(EFI_ITEM(lip));
 161 }
 162
 163 /*
 164  * The EFI is logged only once and cannot be moved in the log, so simply return
 165  * the lsn at which it's been logged.
 166  */
 167 STATIC xfs_lsn_t
 168 xfs_efi_item_committed(
 169         struct xfs_log_item     *lip,
 170         xfs_lsn_t               lsn)
 171 {
 172         return lsn;
 173 }
 174
 175 /*
 176  * The EFI dependency tracking op doesn't do squat.  It can't because
 177  * it doesn't know where the free extent is coming from.  The dependency
 178  * tracking has to be handled by the "enclosing" metadata object.  For
 179  * example, for inodes, the inode is locked throughout the extent freeing
 180  * so the dependency should be recorded there.
 181  */
 182 STATIC void
 183 xfs_efi_item_committing(
 184         struct xfs_log_item     *lip,
 185         xfs_lsn_t               lsn)
 186 {
 187 }
 188
 189 /*
 190  * This is the ops vector shared by all efi log items.
 191  */
 192 static const struct xfs_item_ops xfs_efi_item_ops = {
 193         .iop_size       = xfs_efi_item_size,
 194         .iop_format     = xfs_efi_item_format,
 195         .iop_pin        = xfs_efi_item_pin,
 196         .iop_unpin      = xfs_efi_item_unpin,
 197         .iop_unlock     = xfs_efi_item_unlock,
 198         .iop_committed  = xfs_efi_item_committed,
 199         .iop_push       = xfs_efi_item_push,
 200         .iop_committing = xfs_efi_item_committing
 201 };
 202
 203
 204 /*
 205  * Allocate and initialize an efi item with the given number of extents.
 206  */
 207 struct xfs_efi_log_item *
 208 xfs_efi_init(
 209         struct xfs_mount        *mp,
 210         uint                    nextents)
 211
 212 {
 213         struct xfs_efi_log_item *efip;
 214         uint                    size;
 215
 216         ASSERT(nextents > 0);
 217         if (nextents > XFS_EFI_MAX_FAST_EXTENTS) {
 218                 size = (uint)(sizeof(xfs_efi_log_item_t) +
 219                         ((nextents - 1) * sizeof(xfs_extent_t)));
 220                 efip = kmem_zalloc(size, KM_SLEEP);
 221         } else {
 222                 efip = kmem_zone_zalloc(xfs_efi_zone, KM_SLEEP);
 223         }
 224
 225         xfs_log_item_init(mp, &efip->efi_item, XFS_LI_EFI, &xfs_efi_item_ops);
 226         efip->efi_format.efi_nextents = nextents;
 227         efip->efi_format.efi_id = (uintptr_t)(void *)efip;
 228         atomic_set(&efip->efi_next_extent, 0);
 229         atomic_set(&efip->efi_refcount, 2);
 230
 231         return efip;
 232 }
 233
 234 /*
 235  * Copy an EFI format buffer from the given buf, and into the destination
 236  * EFI format structure.
 237  * The given buffer can be in 32 bit or 64 bit form (which has different padding),
 238  * one of which will be the native format for this kernel.
 239  * It will handle the conversion of formats if necessary.
 240  */
 241 int
 242 xfs_efi_copy_format(xfs_log_iovec_t *buf, xfs_efi_log_format_t *dst_efi_fmt)
 243 {
 244         xfs_efi_log_format_t *src_efi_fmt = buf->i_addr;
 245         uint i;
 246         uint len = sizeof(xfs_efi_log_format_t) +
 247                 (src_efi_fmt->efi_nextents - 1) * sizeof(xfs_extent_t);
 248         uint len32 = sizeof(xfs_efi_log_format_32_t) +
 249                 (src_efi_fmt->efi_nextents - 1) * sizeof(xfs_extent_32_t);
 250         uint len64 = sizeof(xfs_efi_log_format_64_t) +
 251                 (src_efi_fmt->efi_nextents - 1) * sizeof(xfs_extent_64_t);
 252
 253         if (buf->i_len == len) {
 254                 memcpy((char *)dst_efi_fmt, (char*)src_efi_fmt, len);
 255                 return 0;
 256         } else if (buf->i_len == len32) {
 257                 xfs_efi_log_format_32_t *src_efi_fmt_32 = buf->i_addr;
 258
 259                 dst_efi_fmt->efi_type     = src_efi_fmt_32->efi_type;
 260                 dst_efi_fmt->efi_size     = src_efi_fmt_32->efi_size;
 261                 dst_efi_fmt->efi_nextents = src_efi_fmt_32->efi_nextents;
 262                 dst_efi_fmt->efi_id       = src_efi_fmt_32->efi_id;
 263                 for (i = 0; i < dst_efi_fmt->efi_nextents; i++) {
 264                         dst_efi_fmt->efi_extents[i].ext_start =
 265                                 src_efi_fmt_32->efi_extents[i].ext_start;
 266                         dst_efi_fmt->efi_extents[i].ext_len =
 267                                 src_efi_fmt_32->efi_extents[i].ext_len;
 268                 }
 269                 return 0;
 270         } else if (buf->i_len == len64) {
 271                 xfs_efi_log_format_64_t *src_efi_fmt_64 = buf->i_addr;
 272
 273                 dst_efi_fmt->efi_type     = src_efi_fmt_64->efi_type;
 274                 dst_efi_fmt->efi_size     = src_efi_fmt_64->efi_size;
 275                 dst_efi_fmt->efi_nextents = src_efi_fmt_64->efi_nextents;
 276                 dst_efi_fmt->efi_id       = src_efi_fmt_64->efi_id;
 277                 for (i = 0; i < dst_efi_fmt->efi_nextents; i++) {
 278                         dst_efi_fmt->efi_extents[i].ext_start =
 279                                 src_efi_fmt_64->efi_extents[i].ext_start;
 280                         dst_efi_fmt->efi_extents[i].ext_len =
 281                                 src_efi_fmt_64->efi_extents[i].ext_len;
 282                 }
 283                 return 0;
 284         }
 285         return -EFSCORRUPTED;
 286 }
 287
 288 static inline struct xfs_efd_log_item *EFD_ITEM(struct xfs_log_item *lip)
 289 {
 290         return container_of(lip, struct xfs_efd_log_item, efd_item);
 291 }
 292
 293 STATIC void
 294 xfs_efd_item_free(struct xfs_efd_log_item *efdp)
 295 {
 296         kmem_free(efdp->efd_item.li_lv_shadow);
 297         if (efdp->efd_format.efd_nextents > XFS_EFD_MAX_FAST_EXTENTS)
 298                 kmem_free(efdp);
 299         else
 300                 kmem_zone_free(xfs_efd_zone, efdp);
 301 }
 302
 303 /*
 304  * This returns the number of iovecs needed to log the given efd item.
 305  * We only need 1 iovec for an efd item.  It just logs the efd_log_format
 306  * structure.
 307  */
 308 static inline int
 309 xfs_efd_item_sizeof(
 310         struct xfs_efd_log_item *efdp)
 311 {
 312         return sizeof(xfs_efd_log_format_t) +
 313                (efdp->efd_format.efd_nextents - 1) * sizeof(xfs_extent_t);
 314 }
 315
 316 STATIC void
 317 xfs_efd_item_size(
 318         struct xfs_log_item     *lip,
 319         int                     *nvecs,
 320         int                     *nbytes)
 321 {
 322         *nvecs += 1;
 323         *nbytes += xfs_efd_item_sizeof(EFD_ITEM(lip));
 324 }
 325
 326 /*
 327  * This is called to fill in the vector of log iovecs for the
 328  * given efd log item. We use only 1 iovec, and we point that
 329  * at the efd_log_format structure embedded in the efd item.
 330  * It is at this point that we assert that all of the extent
 331  * slots in the efd item have been filled.
 332  */
 333 STATIC void
 334 xfs_efd_item_format(
 335         struct xfs_log_item     *lip,
 336         struct xfs_log_vec      *lv)
 337 {
 338         struct xfs_efd_log_item *efdp = EFD_ITEM(lip);
 339         struct xfs_log_iovec    *vecp = NULL;
 340
 341         ASSERT(efdp->efd_next_extent == efdp->efd_format.efd_nextents);
 342
 343         efdp->efd_format.efd_type = XFS_LI_EFD;
 344         efdp->efd_format.efd_size = 1;
 345
 346         xlog_copy_iovec(lv, &vecp, XLOG_REG_TYPE_EFD_FORMAT,
 347                         &efdp->efd_format,
 348                         xfs_efd_item_sizeof(efdp));
 349 }
 350
 351 /*
 352  * Pinning has no meaning for an efd item, so just return.
 353  */
 354 STATIC void
 355 xfs_efd_item_pin(
 356         struct xfs_log_item     *lip)
 357 {
 358 }
 359
 360 /*
 361  * Since pinning has no meaning for an efd item, unpinning does
 362  * not either.
 363  */
 364 STATIC void
 365 xfs_efd_item_unpin(
 366         struct xfs_log_item     *lip,
 367         int                     remove)
 368 {
 369 }
 370
 371 /*
 372  * There isn't much you can do to push on an efd item.  It is simply stuck
 373  * waiting for the log to be flushed to disk.
 374  */
 375 STATIC uint
 376 xfs_efd_item_push(
 377         struct xfs_log_item     *lip,
 378         struct list_head        *buffer_list)
 379 {
 380         return XFS_ITEM_PINNED;
 381 }
 382
 383 /*
 384  * The EFD is either committed or aborted if the transaction is cancelled. If
 385  * the transaction is cancelled, drop our reference to the EFI and free the EFD.
 386  */
 387 STATIC void
 388 xfs_efd_item_unlock(
 389         struct xfs_log_item     *lip)
 390 {
 391         struct xfs_efd_log_item *efdp = EFD_ITEM(lip);
 392
 393         if (test_bit(XFS_LI_ABORTED, &lip->li_flags)) {
 394                 xfs_efi_release(efdp->efd_efip);
 395                 xfs_efd_item_free(efdp);
 396         }
 397 }
 398
 399 /*
 400  * When the efd item is committed to disk, all we need to do is delete our
 401  * reference to our partner efi item and then free ourselves. Since we're
 402  * freeing ourselves we must return -1 to keep the transaction code from further
 403  * referencing this item.
 404  */
 405 STATIC xfs_lsn_t
 406 xfs_efd_item_committed(
 407         struct xfs_log_item     *lip,
 408         xfs_lsn_t               lsn)
 409 {
 410         struct xfs_efd_log_item *efdp = EFD_ITEM(lip);
 411
 412         /*
 413          * Drop the EFI reference regardless of whether the EFD has been
 414          * aborted. Once the EFD transaction is constructed, it is the sole
 415          * responsibility of the EFD to release the EFI (even if the EFI is
 416          * aborted due to log I/O error).
 417          */
 418         xfs_efi_release(efdp->efd_efip);
 419         xfs_efd_item_free(efdp);
 420
 421         return (xfs_lsn_t)-1;
 422 }
 423
 424 /*
 425  * The EFD dependency tracking op doesn't do squat.  It can't because
 426  * it doesn't know where the free extent is coming from.  The dependency
 427  * tracking has to be handled by the "enclosing" metadata object.  For
 428  * example, for inodes, the inode is locked throughout the extent freeing
 429  * so the dependency should be recorded there.
 430  */
 431 STATIC void
 432 xfs_efd_item_committing(
 433         struct xfs_log_item     *lip,
 434         xfs_lsn_t               lsn)
 435 {
 436 }
 437
 438 /*
 439  * This is the ops vector shared by all efd log items.
 440  */
 441 static const struct xfs_item_ops xfs_efd_item_ops = {
 442         .iop_size       = xfs_efd_item_size,
 443         .iop_format     = xfs_efd_item_format,
 444         .iop_pin        = xfs_efd_item_pin,
 445         .iop_unpin      = xfs_efd_item_unpin,
 446         .iop_unlock     = xfs_efd_item_unlock,
 447         .iop_committed  = xfs_efd_item_committed,
 448         .iop_push       = xfs_efd_item_push,
 449         .iop_committing = xfs_efd_item_committing
 450 };
 451
 452 /*
 453  * Allocate and initialize an efd item with the given number of extents.
 454  */
 455 struct xfs_efd_log_item *
 456 xfs_efd_init(
 457         struct xfs_mount        *mp,
 458         struct xfs_efi_log_item *efip,
 459         uint                    nextents)
 460
 461 {
 462         struct xfs_efd_log_item *efdp;
 463         uint                    size;
 464
 465         ASSERT(nextents > 0);
 466         if (nextents > XFS_EFD_MAX_FAST_EXTENTS) {
 467                 size = (uint)(sizeof(xfs_efd_log_item_t) +
 468                         ((nextents - 1) * sizeof(xfs_extent_t)));
 469                 efdp = kmem_zalloc(size, KM_SLEEP);
 470         } else {
 471                 efdp = kmem_zone_zalloc(xfs_efd_zone, KM_SLEEP);
 472         }
 473
 474         xfs_log_item_init(mp, &efdp->efd_item, XFS_LI_EFD, &xfs_efd_item_ops);
 475         efdp->efd_efip = efip;
 476         efdp->efd_format.efd_nextents = nextents;
 477         efdp->efd_format.efd_efi_id = efip->efi_format.efi_id;
 478
 479         return efdp;
 480 }
 481
 482 /*
 483  * Process an extent free intent item that was recovered from
 484  * the log.  We need to free the extents that it describes.
 485  */
 486 int
 487 xfs_efi_recover(
 488         struct xfs_mount        *mp,
 489         struct xfs_efi_log_item *efip)
 490 {
 491         struct xfs_efd_log_item *efdp;
 492         struct xfs_trans        *tp;
 493         int                     i;
 494         int                     error = 0;
 495         xfs_extent_t            *extp;
 496         xfs_fsblock_t           startblock_fsb;
 497
 498         ASSERT(!test_bit(XFS_EFI_RECOVERED, &efip->efi_flags));
 499
 500         /*
 501          * First check the validity of the extents described by the
 502          * EFI.  If any are bad, then assume that all are bad and
 503          * just toss the EFI.
 504          */
 505         for (i = 0; i < efip->efi_format.efi_nextents; i++) {
 506                 extp = &efip->efi_format.efi_extents[i];
 507                 startblock_fsb = XFS_BB_TO_FSB(mp,
 508                                    XFS_FSB_TO_DADDR(mp, extp->ext_start));
 509                 if (startblock_fsb == 0 ||
 510                     extp->ext_len == 0 ||
 511                     startblock_fsb >= mp->m_sb.sb_dblocks ||
 512                     extp->ext_len >= mp->m_sb.sb_agblocks) {
 513                         /*
 514                          * This will pull the EFI from the AIL and
 515                          * free the memory associated with it.
 516                          */
 517                         set_bit(XFS_EFI_RECOVERED, &efip->efi_flags);
 518                         xfs_efi_release(efip);
 519                         return -EIO;
 520                 }
 521         }
 522
 523         error = xfs_trans_alloc(mp, &M_RES(mp)->tr_itruncate, 0, 0, 0, &tp);
 524         if (error)
 525                 return error;
 526         efdp = xfs_trans_get_efd(tp, efip, efip->efi_format.efi_nextents);
 527
 528         for (i = 0; i < efip->efi_format.efi_nextents; i++) {
 529                 extp = &efip->efi_format.efi_extents[i];
 530                 error = xfs_trans_free_extent(tp, efdp, extp->ext_start,
 531                                               extp->ext_len,
 532                                               &XFS_RMAP_OINFO_ANY_OWNER, false);
 533                 if (error)
 534                         goto abort_error;
 535
 536         }
 537
 538         set_bit(XFS_EFI_RECOVERED, &efip->efi_flags);
 539         error = xfs_trans_commit(tp);
 540         return error;
 541
 542 abort_error:
 543         xfs_trans_cancel(tp);
 544         return error;
 545 }