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