fs/xfs/libxfs/xfs_defer.c

   1 /*
   2  * Copyright (C) 2016 Oracle.  All Rights Reserved.
   3  *
   4  * Author: Darrick J. Wong <darrick.wong@oracle.com>
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License
   8  * as published by the Free Software Foundation; either version 2
   9  * of the License, or (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it would be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write the Free Software Foundation,
  18  * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA.
  19  */
  20 #include "xfs.h"
  21 #include "xfs_fs.h"
  22 #include "xfs_shared.h"
  23 #include "xfs_format.h"
  24 #include "xfs_log_format.h"
  25 #include "xfs_trans_resv.h"
  26 #include "xfs_bit.h"
  27 #include "xfs_sb.h"
  28 #include "xfs_mount.h"
  29 #include "xfs_defer.h"
  30 #include "xfs_trans.h"
  31 #include "xfs_trace.h"
  32
  33 /*
  34  * Deferred Operations in XFS
  35  *
  36  * Due to the way locking rules work in XFS, certain transactions (block
  37  * mapping and unmapping, typically) have permanent reservations so that
  38  * we can roll the transaction to adhere to AG locking order rules and
  39  * to unlock buffers between metadata updates.  Prior to rmap/reflink,
  40  * the mapping code had a mechanism to perform these deferrals for
  41  * extents that were going to be freed; this code makes that facility
  42  * more generic.
  43  *
  44  * When adding the reverse mapping and reflink features, it became
  45  * necessary to perform complex remapping multi-transactions to comply
  46  * with AG locking order rules, and to be able to spread a single
  47  * refcount update operation (an operation on an n-block extent can
  48  * update as many as n records!) among multiple transactions.  XFS can
  49  * roll a transaction to facilitate this, but using this facility
  50  * requires us to log "intent" items in case log recovery needs to
  51  * redo the operation, and to log "done" items to indicate that redo
  52  * is not necessary.
  53  *
  54  * Deferred work is tracked in xfs_defer_pending items.  Each pending
  55  * item tracks one type of deferred work.  Incoming work items (which
  56  * have not yet had an intent logged) are attached to a pending item
  57  * on the dop_intake list, where they wait for the caller to finish
  58  * the deferred operations.
  59  *
  60  * Finishing a set of deferred operations is an involved process.  To
  61  * start, we define "rolling a deferred-op transaction" as follows:
  62  *
  63  * > For each xfs_defer_pending item on the dop_intake list,
  64  *   - Sort the work items in AG order.  XFS locking
  65  *     order rules require us to lock buffers in AG order.
  66  *   - Create a log intent item for that type.
  67  *   - Attach it to the pending item.
  68  *   - Move the pending item from the dop_intake list to the
  69  *     dop_pending list.
  70  * > Roll the transaction.
  71  *
  72  * NOTE: To avoid exceeding the transaction reservation, we limit the
  73  * number of items that we attach to a given xfs_defer_pending.
  74  *
  75  * The actual finishing process looks like this:
  76  *
  77  * > For each xfs_defer_pending in the dop_pending list,
  78  *   - Roll the deferred-op transaction as above.
  79  *   - Create a log done item for that type, and attach it to the
  80  *     log intent item.
  81  *   - For each work item attached to the log intent item,
  82  *     * Perform the described action.
  83  *     * Attach the work item to the log done item.
  84  *     * If the result of doing the work was -EAGAIN, ->finish work
  85  *       wants a new transaction.  See the "Requesting a Fresh
  86  *       Transaction while Finishing Deferred Work" section below for
  87  *       details.
  88  *
  89  * The key here is that we must log an intent item for all pending
  90  * work items every time we roll the transaction, and that we must log
  91  * a done item as soon as the work is completed.  With this mechanism
  92  * we can perform complex remapping operations, chaining intent items
  93  * as needed.
  94  *
  95  * Requesting a Fresh Transaction while Finishing Deferred Work
  96  *
  97  * If ->finish_item decides that it needs a fresh transaction to
  98  * finish the work, it must ask its caller (xfs_defer_finish) for a
  99  * continuation.  The most likely cause of this circumstance are the
 100  * refcount adjust functions deciding that they've logged enough items
 101  * to be at risk of exceeding the transaction reservation.
 102  *
 103  * To get a fresh transaction, we want to log the existing log done
 104  * item to prevent the log intent item from replaying, immediately log
 105  * a new log intent item with the unfinished work items, roll the
 106  * transaction, and re-call ->finish_item wherever it left off.  The
 107  * log done item and the new log intent item must be in the same
 108  * transaction or atomicity cannot be guaranteed; defer_finish ensures
 109  * that this happens.
 110  *
 111  * This requires some coordination between ->finish_item and
 112  * defer_finish.  Upon deciding to request a new transaction,
 113  * ->finish_item should update the current work item to reflect the
 114  * unfinished work.  Next, it should reset the log done item's list
 115  * count to the number of items finished, and return -EAGAIN.
 116  * defer_finish sees the -EAGAIN, logs the new log intent item
 117  * with the remaining work items, and leaves the xfs_defer_pending
 118  * item at the head of the dop_work queue.  Then it rolls the
 119  * transaction and picks up processing where it left off.  It is
 120  * required that ->finish_item must be careful to leave enough
 121  * transaction reservation to fit the new log intent item.
 122  *
 123  * This is an example of remapping the extent (E, E+B) into file X at
 124  * offset A and dealing with the extent (C, C+B) already being mapped
 125  * there:
 126  * +-------------------------------------------------+
 127  * | Unmap file X startblock C offset A length B     | t0
 128  * | Intent to reduce refcount for extent (C, B)     |
 129  * | Intent to remove rmap (X, C, A, B)              |
 130  * | Intent to free extent (D, 1) (bmbt block)       |
 131  * | Intent to map (X, A, B) at startblock E         |
 132  * +-------------------------------------------------+
 133  * | Map file X startblock E offset A length B       | t1
 134  * | Done mapping (X, E, A, B)                       |
 135  * | Intent to increase refcount for extent (E, B)   |
 136  * | Intent to add rmap (X, E, A, B)                 |
 137  * +-------------------------------------------------+
 138  * | Reduce refcount for extent (C, B)               | t2
 139  * | Done reducing refcount for extent (C, 9)        |
 140  * | Intent to reduce refcount for extent (C+9, B-9) |
 141  * | (ran out of space after 9 refcount updates)     |
 142  * +-------------------------------------------------+
 143  * | Reduce refcount for extent (C+9, B+9)           | t3
 144  * | Done reducing refcount for extent (C+9, B-9)    |
 145  * | Increase refcount for extent (E, B)             |
 146  * | Done increasing refcount for extent (E, B)      |
 147  * | Intent to free extent (C, B)                    |
 148  * | Intent to free extent (F, 1) (refcountbt block) |
 149  * | Intent to remove rmap (F, 1, REFC)              |
 150  * +-------------------------------------------------+
 151  * | Remove rmap (X, C, A, B)                        | t4
 152  * | Done removing rmap (X, C, A, B)                 |
 153  * | Add rmap (X, E, A, B)                           |
 154  * | Done adding rmap (X, E, A, B)                   |
 155  * | Remove rmap (F, 1, REFC)                        |
 156  * | Done removing rmap (F, 1, REFC)                 |
 157  * +-------------------------------------------------+
 158  * | Free extent (C, B)                              | t5
 159  * | Done freeing extent (C, B)                      |
 160  * | Free extent (D, 1)                              |
 161  * | Done freeing extent (D, 1)                      |
 162  * | Free extent (F, 1)                              |
 163  * | Done freeing extent (F, 1)                      |
 164  * +-------------------------------------------------+
 165  *
 166  * If we should crash before t2 commits, log recovery replays
 167  * the following intent items:
 168  *
 169  * - Intent to reduce refcount for extent (C, B)
 170  * - Intent to remove rmap (X, C, A, B)
 171  * - Intent to free extent (D, 1) (bmbt block)
 172  * - Intent to increase refcount for extent (E, B)
 173  * - Intent to add rmap (X, E, A, B)
 174  *
 175  * In the process of recovering, it should also generate and take care
 176  * of these intent items:
 177  *
 178  * - Intent to free extent (C, B)
 179  * - Intent to free extent (F, 1) (refcountbt block)
 180  * - Intent to remove rmap (F, 1, REFC)
 181  *
 182  * Note that the continuation requested between t2 and t3 is likely to
 183  * reoccur.
 184  */
 185
 186 static const struct xfs_defer_op_type *defer_op_types[XFS_DEFER_OPS_TYPE_MAX];
 187
 188 /*
 189  * For each pending item in the intake list, log its intent item and the
 190  * associated extents, then add the entire intake list to the end of
 191  * the pending list.
 192  */
 193 STATIC void
 194 xfs_defer_intake_work(
 195         struct xfs_trans                *tp,
 196         struct xfs_defer_ops            *dop)
 197 {
 198         struct list_head                *li;
 199         struct xfs_defer_pending        *dfp;
 200
 201         list_for_each_entry(dfp, &dop->dop_intake, dfp_list) {
 202                 trace_xfs_defer_intake_work(tp->t_mountp, dfp);
 203                 dfp->dfp_intent = dfp->dfp_type->create_intent(tp,
 204                                 dfp->dfp_count);
 205                 list_sort(tp->t_mountp, &dfp->dfp_work,
 206                                 dfp->dfp_type->diff_items);
 207                 list_for_each(li, &dfp->dfp_work)
 208                         dfp->dfp_type->log_item(tp, dfp->dfp_intent, li);
 209         }
 210
 211         list_splice_tail_init(&dop->dop_intake, &dop->dop_pending);
 212 }
 213
 214 /* Abort all the intents that were committed. */
 215 STATIC void
 216 xfs_defer_trans_abort(
 217         struct xfs_trans                *tp,
 218         struct xfs_defer_ops            *dop,
 219         int                             error)
 220 {
 221         struct xfs_defer_pending        *dfp;
 222
 223         trace_xfs_defer_trans_abort(tp->t_mountp, dop);
 224         /*
 225          * If the transaction was committed, drop the intent reference
 226          * since we're bailing out of here. The other reference is
 227          * dropped when the intent hits the AIL.  If the transaction
 228          * was not committed, the intent is freed by the intent item
 229          * unlock handler on abort.
 230          */
 231         if (!dop->dop_committed)
 232                 return;
 233
 234         /* Abort intent items. */
 235         list_for_each_entry(dfp, &dop->dop_pending, dfp_list) {
 236                 trace_xfs_defer_pending_abort(tp->t_mountp, dfp);
 237                 if (!dfp->dfp_done)
 238                         dfp->dfp_type->abort_intent(dfp->dfp_intent);
 239         }
 240
 241         /* Shut down FS. */
 242         xfs_force_shutdown(tp->t_mountp, (error == -EFSCORRUPTED) ?
 243                         SHUTDOWN_CORRUPT_INCORE : SHUTDOWN_META_IO_ERROR);
 244 }
 245
 246 /* Roll a transaction so we can do some deferred op processing. */
 247 STATIC int
 248 xfs_defer_trans_roll(
 249         struct xfs_trans                **tp,
 250         struct xfs_defer_ops            *dop,
 251         struct xfs_inode                *ip)
 252 {
 253         int                             i;
 254         int                             error;
 255
 256         /* Log all the joined inodes except the one we passed in. */
 257         for (i = 0; i < XFS_DEFER_OPS_NR_INODES && dop->dop_inodes[i]; i++) {
 258                 if (dop->dop_inodes[i] == ip)
 259                         continue;
 260                 xfs_trans_log_inode(*tp, dop->dop_inodes[i], XFS_ILOG_CORE);
 261         }
 262
 263         trace_xfs_defer_trans_roll((*tp)->t_mountp, dop);
 264
 265         /* Roll the transaction. */
 266         error = xfs_trans_roll(tp, ip);
 267         if (error) {
 268                 trace_xfs_defer_trans_roll_error((*tp)->t_mountp, dop, error);
 269                 xfs_defer_trans_abort(*tp, dop, error);
 270                 return error;
 271         }
 272         dop->dop_committed = true;
 273
 274         /* Rejoin the joined inodes except the one we passed in. */
 275         for (i = 0; i < XFS_DEFER_OPS_NR_INODES && dop->dop_inodes[i]; i++) {
 276                 if (dop->dop_inodes[i] == ip)
 277                         continue;
 278                 xfs_trans_ijoin(*tp, dop->dop_inodes[i], 0);
 279         }
 280
 281         return error;
 282 }
 283
 284 /* Do we have any work items to finish? */
 285 bool
 286 xfs_defer_has_unfinished_work(
 287         struct xfs_defer_ops            *dop)
 288 {
 289         return !list_empty(&dop->dop_pending) || !list_empty(&dop->dop_intake);
 290 }
 291
 292 /*
 293  * Add this inode to the deferred op.  Each joined inode is relogged
 294  * each time we roll the transaction, in addition to any inode passed
 295  * to xfs_defer_finish().
 296  */
 297 int
 298 xfs_defer_join(
 299         struct xfs_defer_ops            *dop,
 300         struct xfs_inode                *ip)
 301 {
 302         int                             i;
 303
 304         for (i = 0; i < XFS_DEFER_OPS_NR_INODES; i++) {
 305                 if (dop->dop_inodes[i] == ip)
 306                         return 0;
 307                 else if (dop->dop_inodes[i] == NULL) {
 308                         dop->dop_inodes[i] = ip;
 309                         return 0;
 310                 }
 311         }
 312
 313         return -EFSCORRUPTED;
 314 }
 315
 316 /*
 317  * Finish all the pending work.  This involves logging intent items for
 318  * any work items that wandered in since the last transaction roll (if
 319  * one has even happened), rolling the transaction, and finishing the
 320  * work items in the first item on the logged-and-pending list.
 321  *
 322  * If an inode is provided, relog it to the new transaction.
 323  */
 324 int
 325 xfs_defer_finish(
 326         struct xfs_trans                **tp,
 327         struct xfs_defer_ops            *dop,
 328         struct xfs_inode                *ip)
 329 {
 330         struct xfs_defer_pending        *dfp;
 331         struct list_head                *li;
 332         struct list_head                *n;
 333         void                            *state;
 334         int                             error = 0;
 335         void                            (*cleanup_fn)(struct xfs_trans *, void *, int);
 336
 337         ASSERT((*tp)->t_flags & XFS_TRANS_PERM_LOG_RES);
 338
 339         trace_xfs_defer_finish((*tp)->t_mountp, dop);
 340
 341         /* Until we run out of pending work to finish... */
 342         while (xfs_defer_has_unfinished_work(dop)) {
 343                 /* Log intents for work items sitting in the intake. */
 344                 xfs_defer_intake_work(*tp, dop);
 345
 346                 /* Roll the transaction. */
 347                 error = xfs_defer_trans_roll(tp, dop, ip);
 348                 if (error)
 349                         goto out;
 350
 351                 /* Log an intent-done item for the first pending item. */
 352                 dfp = list_first_entry(&dop->dop_pending,
 353                                 struct xfs_defer_pending, dfp_list);
 354                 trace_xfs_defer_pending_finish((*tp)->t_mountp, dfp);
 355                 dfp->dfp_done = dfp->dfp_type->create_done(*tp, dfp->dfp_intent,
 356                                 dfp->dfp_count);
 357                 cleanup_fn = dfp->dfp_type->finish_cleanup;
 358
 359                 /* Finish the work items. */
 360                 state = NULL;
 361                 list_for_each_safe(li, n, &dfp->dfp_work) {
 362                         list_del(li);
 363                         dfp->dfp_count--;
 364                         error = dfp->dfp_type->finish_item(*tp, dop, li,
 365                                         dfp->dfp_done, &state);
 366                         if (error == -EAGAIN) {
 367                                 /*
 368                                  * Caller wants a fresh transaction;
 369                                  * put the work item back on the list
 370                                  * and jump out.
 371                                  */
 372                                 list_add(li, &dfp->dfp_work);
 373                                 dfp->dfp_count++;
 374                                 break;
 375                         } else if (error) {
 376                                 /*
 377                                  * Clean up after ourselves and jump out.
 378                                  * xfs_defer_cancel will take care of freeing
 379                                  * all these lists and stuff.
 380                                  */
 381                                 if (cleanup_fn)
 382                                         cleanup_fn(*tp, state, error);
 383                                 xfs_defer_trans_abort(*tp, dop, error);
 384                                 goto out;
 385                         }
 386                 }
 387                 if (error == -EAGAIN) {
 388                         /*
 389                          * Caller wants a fresh transaction, so log a
 390                          * new log intent item to replace the old one
 391                          * and roll the transaction.  See "Requesting
 392                          * a Fresh Transaction while Finishing
 393                          * Deferred Work" above.
 394                          */
 395                         dfp->dfp_intent = dfp->dfp_type->create_intent(*tp,
 396                                         dfp->dfp_count);
 397                         dfp->dfp_done = NULL;
 398                         list_for_each(li, &dfp->dfp_work)
 399                                 dfp->dfp_type->log_item(*tp, dfp->dfp_intent,
 400                                                 li);
 401                 } else {
 402                         /* Done with the dfp, free it. */
 403                         list_del(&dfp->dfp_list);
 404                         kmem_free(dfp);
 405                 }
 406
 407                 if (cleanup_fn)
 408                         cleanup_fn(*tp, state, error);
 409         }
 410
 411 out:
 412         if (error)
 413                 trace_xfs_defer_finish_error((*tp)->t_mountp, dop, error);
 414         else
 415                 trace_xfs_defer_finish_done((*tp)->t_mountp, dop);
 416         return error;
 417 }
 418
 419 /*
 420  * Free up any items left in the list.
 421  */
 422 void
 423 xfs_defer_cancel(
 424         struct xfs_defer_ops            *dop)
 425 {
 426         struct xfs_defer_pending        *dfp;
 427         struct xfs_defer_pending        *pli;
 428         struct list_head                *pwi;
 429         struct list_head                *n;
 430
 431         trace_xfs_defer_cancel(NULL, dop);
 432
 433         /*
 434          * Free the pending items.  Caller should already have arranged
 435          * for the intent items to be released.
 436          */
 437         list_for_each_entry_safe(dfp, pli, &dop->dop_intake, dfp_list) {
 438                 trace_xfs_defer_intake_cancel(NULL, dfp);
 439                 list_del(&dfp->dfp_list);
 440                 list_for_each_safe(pwi, n, &dfp->dfp_work) {
 441                         list_del(pwi);
 442                         dfp->dfp_count--;
 443                         dfp->dfp_type->cancel_item(pwi);
 444                 }
 445                 ASSERT(dfp->dfp_count == 0);
 446                 kmem_free(dfp);
 447         }
 448         list_for_each_entry_safe(dfp, pli, &dop->dop_pending, dfp_list) {
 449                 trace_xfs_defer_pending_cancel(NULL, dfp);
 450                 list_del(&dfp->dfp_list);
 451                 list_for_each_safe(pwi, n, &dfp->dfp_work) {
 452                         list_del(pwi);
 453                         dfp->dfp_count--;
 454                         dfp->dfp_type->cancel_item(pwi);
 455                 }
 456                 ASSERT(dfp->dfp_count == 0);
 457                 kmem_free(dfp);
 458         }
 459 }
 460
 461 /* Add an item for later deferred processing. */
 462 void
 463 xfs_defer_add(
 464         struct xfs_defer_ops            *dop,
 465         enum xfs_defer_ops_type         type,
 466         struct list_head                *li)
 467 {
 468         struct xfs_defer_pending        *dfp = NULL;
 469
 470         /*
 471          * Add the item to a pending item at the end of the intake list.
 472          * If the last pending item has the same type, reuse it.  Else,
 473          * create a new pending item at the end of the intake list.
 474          */
 475         if (!list_empty(&dop->dop_intake)) {
 476                 dfp = list_last_entry(&dop->dop_intake,
 477                                 struct xfs_defer_pending, dfp_list);
 478                 if (dfp->dfp_type->type != type ||
 479                     (dfp->dfp_type->max_items &&
 480                      dfp->dfp_count >= dfp->dfp_type->max_items))
 481                         dfp = NULL;
 482         }
 483         if (!dfp) {
 484                 dfp = kmem_alloc(sizeof(struct xfs_defer_pending),
 485                                 KM_SLEEP | KM_NOFS);
 486                 dfp->dfp_type = defer_op_types[type];
 487                 dfp->dfp_intent = NULL;
 488                 dfp->dfp_done = NULL;
 489                 dfp->dfp_count = 0;
 490                 INIT_LIST_HEAD(&dfp->dfp_work);
 491                 list_add_tail(&dfp->dfp_list, &dop->dop_intake);
 492         }
 493
 494         list_add_tail(li, &dfp->dfp_work);
 495         dfp->dfp_count++;
 496 }
 497
 498 /* Initialize a deferred operation list. */
 499 void
 500 xfs_defer_init_op_type(
 501         const struct xfs_defer_op_type  *type)
 502 {
 503         defer_op_types[type->type] = type;
 504 }
 505
 506 /* Initialize a deferred operation. */
 507 void
 508 xfs_defer_init(
 509         struct xfs_defer_ops            *dop,
 510         xfs_fsblock_t                   *fbp)
 511 {
 512         dop->dop_committed = false;
 513         dop->dop_low = false;
 514         memset(&dop->dop_inodes, 0, sizeof(dop->dop_inodes));
 515         *fbp = NULLFSBLOCK;
 516         INIT_LIST_HEAD(&dop->dop_intake);
 517         INIT_LIST_HEAD(&dop->dop_pending);
 518         trace_xfs_defer_init(NULL, dop);
 519 }