fs/xfs/libxfs/xfs_defer.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright (C) 2016 Oracle.  All Rights Reserved.
   4  * Author: Darrick J. Wong <darrick.wong@oracle.com>
   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_defer.h"
  14 #include "xfs_trans.h"
  15 #include "xfs_buf_item.h"
  16 #include "xfs_inode.h"
  17 #include "xfs_inode_item.h"
  18 #include "xfs_trace.h"
  19
  20 /*
  21  * Deferred Operations in XFS
  22  *
  23  * Due to the way locking rules work in XFS, certain transactions (block
  24  * mapping and unmapping, typically) have permanent reservations so that
  25  * we can roll the transaction to adhere to AG locking order rules and
  26  * to unlock buffers between metadata updates.  Prior to rmap/reflink,
  27  * the mapping code had a mechanism to perform these deferrals for
  28  * extents that were going to be freed; this code makes that facility
  29  * more generic.
  30  *
  31  * When adding the reverse mapping and reflink features, it became
  32  * necessary to perform complex remapping multi-transactions to comply
  33  * with AG locking order rules, and to be able to spread a single
  34  * refcount update operation (an operation on an n-block extent can
  35  * update as many as n records!) among multiple transactions.  XFS can
  36  * roll a transaction to facilitate this, but using this facility
  37  * requires us to log "intent" items in case log recovery needs to
  38  * redo the operation, and to log "done" items to indicate that redo
  39  * is not necessary.
  40  *
  41  * Deferred work is tracked in xfs_defer_pending items.  Each pending
  42  * item tracks one type of deferred work.  Incoming work items (which
  43  * have not yet had an intent logged) are attached to a pending item
  44  * on the dop_intake list, where they wait for the caller to finish
  45  * the deferred operations.
  46  *
  47  * Finishing a set of deferred operations is an involved process.  To
  48  * start, we define "rolling a deferred-op transaction" as follows:
  49  *
  50  * > For each xfs_defer_pending item on the dop_intake list,
  51  *   - Sort the work items in AG order.  XFS locking
  52  *     order rules require us to lock buffers in AG order.
  53  *   - Create a log intent item for that type.
  54  *   - Attach it to the pending item.
  55  *   - Move the pending item from the dop_intake list to the
  56  *     dop_pending list.
  57  * > Roll the transaction.
  58  *
  59  * NOTE: To avoid exceeding the transaction reservation, we limit the
  60  * number of items that we attach to a given xfs_defer_pending.
  61  *
  62  * The actual finishing process looks like this:
  63  *
  64  * > For each xfs_defer_pending in the dop_pending list,
  65  *   - Roll the deferred-op transaction as above.
  66  *   - Create a log done item for that type, and attach it to the
  67  *     log intent item.
  68  *   - For each work item attached to the log intent item,
  69  *     * Perform the described action.
  70  *     * Attach the work item to the log done item.
  71  *     * If the result of doing the work was -EAGAIN, ->finish work
  72  *       wants a new transaction.  See the "Requesting a Fresh
  73  *       Transaction while Finishing Deferred Work" section below for
  74  *       details.
  75  *
  76  * The key here is that we must log an intent item for all pending
  77  * work items every time we roll the transaction, and that we must log
  78  * a done item as soon as the work is completed.  With this mechanism
  79  * we can perform complex remapping operations, chaining intent items
  80  * as needed.
  81  *
  82  * Requesting a Fresh Transaction while Finishing Deferred Work
  83  *
  84  * If ->finish_item decides that it needs a fresh transaction to
  85  * finish the work, it must ask its caller (xfs_defer_finish) for a
  86  * continuation.  The most likely cause of this circumstance are the
  87  * refcount adjust functions deciding that they've logged enough items
  88  * to be at risk of exceeding the transaction reservation.
  89  *
  90  * To get a fresh transaction, we want to log the existing log done
  91  * item to prevent the log intent item from replaying, immediately log
  92  * a new log intent item with the unfinished work items, roll the
  93  * transaction, and re-call ->finish_item wherever it left off.  The
  94  * log done item and the new log intent item must be in the same
  95  * transaction or atomicity cannot be guaranteed; defer_finish ensures
  96  * that this happens.
  97  *
  98  * This requires some coordination between ->finish_item and
  99  * defer_finish.  Upon deciding to request a new transaction,
 100  * ->finish_item should update the current work item to reflect the
 101  * unfinished work.  Next, it should reset the log done item's list
 102  * count to the number of items finished, and return -EAGAIN.
 103  * defer_finish sees the -EAGAIN, logs the new log intent item
 104  * with the remaining work items, and leaves the xfs_defer_pending
 105  * item at the head of the dop_work queue.  Then it rolls the
 106  * transaction and picks up processing where it left off.  It is
 107  * required that ->finish_item must be careful to leave enough
 108  * transaction reservation to fit the new log intent item.
 109  *
 110  * This is an example of remapping the extent (E, E+B) into file X at
 111  * offset A and dealing with the extent (C, C+B) already being mapped
 112  * there:
 113  * +-------------------------------------------------+
 114  * | Unmap file X startblock C offset A length B     | t0
 115  * | Intent to reduce refcount for extent (C, B)     |
 116  * | Intent to remove rmap (X, C, A, B)              |
 117  * | Intent to free extent (D, 1) (bmbt block)       |
 118  * | Intent to map (X, A, B) at startblock E         |
 119  * +-------------------------------------------------+
 120  * | Map file X startblock E offset A length B       | t1
 121  * | Done mapping (X, E, A, B)                       |
 122  * | Intent to increase refcount for extent (E, B)   |
 123  * | Intent to add rmap (X, E, A, B)                 |
 124  * +-------------------------------------------------+
 125  * | Reduce refcount for extent (C, B)               | t2
 126  * | Done reducing refcount for extent (C, 9)        |
 127  * | Intent to reduce refcount for extent (C+9, B-9) |
 128  * | (ran out of space after 9 refcount updates)     |
 129  * +-------------------------------------------------+
 130  * | Reduce refcount for extent (C+9, B+9)           | t3
 131  * | Done reducing refcount for extent (C+9, B-9)    |
 132  * | Increase refcount for extent (E, B)             |
 133  * | Done increasing refcount for extent (E, B)      |
 134  * | Intent to free extent (C, B)                    |
 135  * | Intent to free extent (F, 1) (refcountbt block) |
 136  * | Intent to remove rmap (F, 1, REFC)              |
 137  * +-------------------------------------------------+
 138  * | Remove rmap (X, C, A, B)                        | t4
 139  * | Done removing rmap (X, C, A, B)                 |
 140  * | Add rmap (X, E, A, B)                           |
 141  * | Done adding rmap (X, E, A, B)                   |
 142  * | Remove rmap (F, 1, REFC)                        |
 143  * | Done removing rmap (F, 1, REFC)                 |
 144  * +-------------------------------------------------+
 145  * | Free extent (C, B)                              | t5
 146  * | Done freeing extent (C, B)                      |
 147  * | Free extent (D, 1)                              |
 148  * | Done freeing extent (D, 1)                      |
 149  * | Free extent (F, 1)                              |
 150  * | Done freeing extent (F, 1)                      |
 151  * +-------------------------------------------------+
 152  *
 153  * If we should crash before t2 commits, log recovery replays
 154  * the following intent items:
 155  *
 156  * - Intent to reduce refcount for extent (C, B)
 157  * - Intent to remove rmap (X, C, A, B)
 158  * - Intent to free extent (D, 1) (bmbt block)
 159  * - Intent to increase refcount for extent (E, B)
 160  * - Intent to add rmap (X, E, A, B)
 161  *
 162  * In the process of recovering, it should also generate and take care
 163  * of these intent items:
 164  *
 165  * - Intent to free extent (C, B)
 166  * - Intent to free extent (F, 1) (refcountbt block)
 167  * - Intent to remove rmap (F, 1, REFC)
 168  *
 169  * Note that the continuation requested between t2 and t3 is likely to
 170  * reoccur.
 171  */
 172
 173 static const struct xfs_defer_op_type *defer_op_types[] = {
 174         [XFS_DEFER_OPS_TYPE_BMAP]       = &xfs_bmap_update_defer_type,
 175         [XFS_DEFER_OPS_TYPE_REFCOUNT]   = &xfs_refcount_update_defer_type,
 176         [XFS_DEFER_OPS_TYPE_RMAP]       = &xfs_rmap_update_defer_type,
 177         [XFS_DEFER_OPS_TYPE_FREE]       = &xfs_extent_free_defer_type,
 178         [XFS_DEFER_OPS_TYPE_AGFL_FREE]  = &xfs_agfl_free_defer_type,
 179 };
 180
 181 static void
 182 xfs_defer_create_intent(
 183         struct xfs_trans                *tp,
 184         struct xfs_defer_pending        *dfp,
 185         bool                            sort)
 186 {
 187         const struct xfs_defer_op_type  *ops = defer_op_types[dfp->dfp_type];
 188
 189         dfp->dfp_intent = ops->create_intent(tp, &dfp->dfp_work,
 190                         dfp->dfp_count, sort);
 191 }
 192
 193 /*
 194  * For each pending item in the intake list, log its intent item and the
 195  * associated extents, then add the entire intake list to the end of
 196  * the pending list.
 197  */
 198 STATIC void
 199 xfs_defer_create_intents(
 200         struct xfs_trans                *tp)
 201 {
 202         struct xfs_defer_pending        *dfp;
 203
 204         list_for_each_entry(dfp, &tp->t_dfops, dfp_list) {
 205                 trace_xfs_defer_create_intent(tp->t_mountp, dfp);
 206                 xfs_defer_create_intent(tp, dfp, true);
 207         }
 208 }
 209
 210 /* Abort all the intents that were committed. */
 211 STATIC void
 212 xfs_defer_trans_abort(
 213         struct xfs_trans                *tp,
 214         struct list_head                *dop_pending)
 215 {
 216         struct xfs_defer_pending        *dfp;
 217         const struct xfs_defer_op_type  *ops;
 218
 219         trace_xfs_defer_trans_abort(tp, _RET_IP_);
 220
 221         /* Abort intent items that don't have a done item. */
 222         list_for_each_entry(dfp, dop_pending, dfp_list) {
 223                 ops = defer_op_types[dfp->dfp_type];
 224                 trace_xfs_defer_pending_abort(tp->t_mountp, dfp);
 225                 if (dfp->dfp_intent && !dfp->dfp_done) {
 226                         ops->abort_intent(dfp->dfp_intent);
 227                         dfp->dfp_intent = NULL;
 228                 }
 229         }
 230 }
 231
 232 /* Roll a transaction so we can do some deferred op processing. */
 233 STATIC int
 234 xfs_defer_trans_roll(
 235         struct xfs_trans                **tpp)
 236 {
 237         struct xfs_trans                *tp = *tpp;
 238         struct xfs_buf_log_item         *bli;
 239         struct xfs_inode_log_item       *ili;
 240         struct xfs_log_item             *lip;
 241         struct xfs_buf                  *bplist[XFS_DEFER_OPS_NR_BUFS];
 242         struct xfs_inode                *iplist[XFS_DEFER_OPS_NR_INODES];
 243         unsigned int                    ordered = 0; /* bitmap */
 244         int                             bpcount = 0, ipcount = 0;
 245         int                             i;
 246         int                             error;
 247
 248         BUILD_BUG_ON(NBBY * sizeof(ordered) < XFS_DEFER_OPS_NR_BUFS);
 249
 250         list_for_each_entry(lip, &tp->t_items, li_trans) {
 251                 switch (lip->li_type) {
 252                 case XFS_LI_BUF:
 253                         bli = container_of(lip, struct xfs_buf_log_item,
 254                                            bli_item);
 255                         if (bli->bli_flags & XFS_BLI_HOLD) {
 256                                 if (bpcount >= XFS_DEFER_OPS_NR_BUFS) {
 257                                         ASSERT(0);
 258                                         return -EFSCORRUPTED;
 259                                 }
 260                                 if (bli->bli_flags & XFS_BLI_ORDERED)
 261                                         ordered |= (1U << bpcount);
 262                                 else
 263                                         xfs_trans_dirty_buf(tp, bli->bli_buf);
 264                                 bplist[bpcount++] = bli->bli_buf;
 265                         }
 266                         break;
 267                 case XFS_LI_INODE:
 268                         ili = container_of(lip, struct xfs_inode_log_item,
 269                                            ili_item);
 270                         if (ili->ili_lock_flags == 0) {
 271                                 if (ipcount >= XFS_DEFER_OPS_NR_INODES) {
 272                                         ASSERT(0);
 273                                         return -EFSCORRUPTED;
 274                                 }
 275                                 xfs_trans_log_inode(tp, ili->ili_inode,
 276                                                     XFS_ILOG_CORE);
 277                                 iplist[ipcount++] = ili->ili_inode;
 278                         }
 279                         break;
 280                 default:
 281                         break;
 282                 }
 283         }
 284
 285         trace_xfs_defer_trans_roll(tp, _RET_IP_);
 286
 287         /*
 288          * Roll the transaction.  Rolling always given a new transaction (even
 289          * if committing the old one fails!) to hand back to the caller, so we
 290          * join the held resources to the new transaction so that we always
 291          * return with the held resources joined to @tpp, no matter what
 292          * happened.
 293          */
 294         error = xfs_trans_roll(tpp);
 295         tp = *tpp;
 296
 297         /* Rejoin the joined inodes. */
 298         for (i = 0; i < ipcount; i++)
 299                 xfs_trans_ijoin(tp, iplist[i], 0);
 300
 301         /* Rejoin the buffers and dirty them so the log moves forward. */
 302         for (i = 0; i < bpcount; i++) {
 303                 xfs_trans_bjoin(tp, bplist[i]);
 304                 if (ordered & (1U << i))
 305                         xfs_trans_ordered_buf(tp, bplist[i]);
 306                 xfs_trans_bhold(tp, bplist[i]);
 307         }
 308
 309         if (error)
 310                 trace_xfs_defer_trans_roll_error(tp, error);
 311         return error;
 312 }
 313
 314 /*
 315  * Reset an already used dfops after finish.
 316  */
 317 static void
 318 xfs_defer_reset(
 319         struct xfs_trans        *tp)
 320 {
 321         ASSERT(list_empty(&tp->t_dfops));
 322
 323         /*
 324          * Low mode state transfers across transaction rolls to mirror dfops
 325          * lifetime. Clear it now that dfops is reset.
 326          */
 327         tp->t_flags &= ~XFS_TRANS_LOWMODE;
 328 }
 329
 330 /*
 331  * Free up any items left in the list.
 332  */
 333 static void
 334 xfs_defer_cancel_list(
 335         struct xfs_mount                *mp,
 336         struct list_head                *dop_list)
 337 {
 338         struct xfs_defer_pending        *dfp;
 339         struct xfs_defer_pending        *pli;
 340         struct list_head                *pwi;
 341         struct list_head                *n;
 342         const struct xfs_defer_op_type  *ops;
 343
 344         /*
 345          * Free the pending items.  Caller should already have arranged
 346          * for the intent items to be released.
 347          */
 348         list_for_each_entry_safe(dfp, pli, dop_list, dfp_list) {
 349                 ops = defer_op_types[dfp->dfp_type];
 350                 trace_xfs_defer_cancel_list(mp, dfp);
 351                 list_del(&dfp->dfp_list);
 352                 list_for_each_safe(pwi, n, &dfp->dfp_work) {
 353                         list_del(pwi);
 354                         dfp->dfp_count--;
 355                         ops->cancel_item(pwi);
 356                 }
 357                 ASSERT(dfp->dfp_count == 0);
 358                 kmem_free(dfp);
 359         }
 360 }
 361
 362 /*
 363  * Log an intent-done item for the first pending intent, and finish the work
 364  * items.
 365  */
 366 static int
 367 xfs_defer_finish_one(
 368         struct xfs_trans                *tp,
 369         struct xfs_defer_pending        *dfp)
 370 {
 371         const struct xfs_defer_op_type  *ops = defer_op_types[dfp->dfp_type];
 372         struct xfs_btree_cur            *state = NULL;
 373         struct list_head                *li, *n;
 374         int                             error;
 375
 376         trace_xfs_defer_pending_finish(tp->t_mountp, dfp);
 377
 378         dfp->dfp_done = ops->create_done(tp, dfp->dfp_intent, dfp->dfp_count);
 379         list_for_each_safe(li, n, &dfp->dfp_work) {
 380                 list_del(li);
 381                 dfp->dfp_count--;
 382                 error = ops->finish_item(tp, dfp->dfp_done, li, &state);
 383                 if (error == -EAGAIN) {
 384                         /*
 385                          * Caller wants a fresh transaction; put the work item
 386                          * back on the list and log a new log intent item to
 387                          * replace the old one.  See "Requesting a Fresh
 388                          * Transaction while Finishing Deferred Work" above.
 389                          */
 390                         list_add(li, &dfp->dfp_work);
 391                         dfp->dfp_count++;
 392                         dfp->dfp_done = NULL;
 393                         xfs_defer_create_intent(tp, dfp, false);
 394                 }
 395
 396                 if (error)
 397                         goto out;
 398         }
 399
 400         /* Done with the dfp, free it. */
 401         list_del(&dfp->dfp_list);
 402         kmem_free(dfp);
 403 out:
 404         if (ops->finish_cleanup)
 405                 ops->finish_cleanup(tp, state, error);
 406         return error;
 407 }
 408
 409 /*
 410  * Finish all the pending work.  This involves logging intent items for
 411  * any work items that wandered in since the last transaction roll (if
 412  * one has even happened), rolling the transaction, and finishing the
 413  * work items in the first item on the logged-and-pending list.
 414  *
 415  * If an inode is provided, relog it to the new transaction.
 416  */
 417 int
 418 xfs_defer_finish_noroll(
 419         struct xfs_trans                **tp)
 420 {
 421         struct xfs_defer_pending        *dfp;
 422         int                             error = 0;
 423         LIST_HEAD(dop_pending);
 424
 425         ASSERT((*tp)->t_flags & XFS_TRANS_PERM_LOG_RES);
 426
 427         trace_xfs_defer_finish(*tp, _RET_IP_);
 428
 429         /* Until we run out of pending work to finish... */
 430         while (!list_empty(&dop_pending) || !list_empty(&(*tp)->t_dfops)) {
 431                 xfs_defer_create_intents(*tp);
 432                 list_splice_tail_init(&(*tp)->t_dfops, &dop_pending);
 433
 434                 error = xfs_defer_trans_roll(tp);
 435                 if (error)
 436                         goto out_shutdown;
 437
 438                 dfp = list_first_entry(&dop_pending, struct xfs_defer_pending,
 439                                        dfp_list);
 440                 error = xfs_defer_finish_one(*tp, dfp);
 441                 if (error && error != -EAGAIN)
 442                         goto out_shutdown;
 443         }
 444
 445         trace_xfs_defer_finish_done(*tp, _RET_IP_);
 446         return 0;
 447
 448 out_shutdown:
 449         xfs_defer_trans_abort(*tp, &dop_pending);
 450         xfs_force_shutdown((*tp)->t_mountp, SHUTDOWN_CORRUPT_INCORE);
 451         trace_xfs_defer_finish_error(*tp, error);
 452         xfs_defer_cancel_list((*tp)->t_mountp, &dop_pending);
 453         xfs_defer_cancel(*tp);
 454         return error;
 455 }
 456
 457 int
 458 xfs_defer_finish(
 459         struct xfs_trans        **tp)
 460 {
 461         int                     error;
 462
 463         /*
 464          * Finish and roll the transaction once more to avoid returning to the
 465          * caller with a dirty transaction.
 466          */
 467         error = xfs_defer_finish_noroll(tp);
 468         if (error)
 469                 return error;
 470         if ((*tp)->t_flags & XFS_TRANS_DIRTY) {
 471                 error = xfs_defer_trans_roll(tp);
 472                 if (error) {
 473                         xfs_force_shutdown((*tp)->t_mountp,
 474                                            SHUTDOWN_CORRUPT_INCORE);
 475                         return error;
 476                 }
 477         }
 478         xfs_defer_reset(*tp);
 479         return 0;
 480 }
 481
 482 void
 483 xfs_defer_cancel(
 484         struct xfs_trans        *tp)
 485 {
 486         struct xfs_mount        *mp = tp->t_mountp;
 487
 488         trace_xfs_defer_cancel(tp, _RET_IP_);
 489         xfs_defer_cancel_list(mp, &tp->t_dfops);
 490 }
 491
 492 /* Add an item for later deferred processing. */
 493 void
 494 xfs_defer_add(
 495         struct xfs_trans                *tp,
 496         enum xfs_defer_ops_type         type,
 497         struct list_head                *li)
 498 {
 499         struct xfs_defer_pending        *dfp = NULL;
 500         const struct xfs_defer_op_type  *ops;
 501
 502         ASSERT(tp->t_flags & XFS_TRANS_PERM_LOG_RES);
 503         BUILD_BUG_ON(ARRAY_SIZE(defer_op_types) != XFS_DEFER_OPS_TYPE_MAX);
 504
 505         /*
 506          * Add the item to a pending item at the end of the intake list.
 507          * If the last pending item has the same type, reuse it.  Else,
 508          * create a new pending item at the end of the intake list.
 509          */
 510         if (!list_empty(&tp->t_dfops)) {
 511                 dfp = list_last_entry(&tp->t_dfops,
 512                                 struct xfs_defer_pending, dfp_list);
 513                 ops = defer_op_types[dfp->dfp_type];
 514                 if (dfp->dfp_type != type ||
 515                     (ops->max_items && dfp->dfp_count >= ops->max_items))
 516                         dfp = NULL;
 517         }
 518         if (!dfp) {
 519                 dfp = kmem_alloc(sizeof(struct xfs_defer_pending),
 520                                 KM_NOFS);
 521                 dfp->dfp_type = type;
 522                 dfp->dfp_intent = NULL;
 523                 dfp->dfp_done = NULL;
 524                 dfp->dfp_count = 0;
 525                 INIT_LIST_HEAD(&dfp->dfp_work);
 526                 list_add_tail(&dfp->dfp_list, &tp->t_dfops);
 527         }
 528
 529         list_add_tail(li, &dfp->dfp_work);
 530         dfp->dfp_count++;
 531 }
 532
 533 /*
 534  * Move deferred ops from one transaction to another and reset the source to
 535  * initial state. This is primarily used to carry state forward across
 536  * transaction rolls with pending dfops.
 537  */
 538 void
 539 xfs_defer_move(
 540         struct xfs_trans        *dtp,
 541         struct xfs_trans        *stp)
 542 {
 543         list_splice_init(&stp->t_dfops, &dtp->t_dfops);
 544
 545         /*
 546          * Low free space mode was historically controlled by a dfops field.
 547          * This meant that low mode state potentially carried across multiple
 548          * transaction rolls. Transfer low mode on a dfops move to preserve
 549          * that behavior.
 550          */
 551         dtp->t_flags |= (stp->t_flags & XFS_TRANS_LOWMODE);
 552
 553         xfs_defer_reset(stp);
 554 }