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 #include "xfs_icache.h" 20 #include "xfs_log.h" 21 #include "xfs_rmap.h" 22 #include "xfs_refcount.h" 23 #include "xfs_bmap.h" 24 #include "xfs_alloc.h" 25 #include "xfs_buf.h" 26 #include "xfs_da_format.h" 27 #include "xfs_da_btree.h" 28 #include "xfs_attr.h" 29 30 static struct kmem_cache *xfs_defer_pending_cache; 31 32 /* 33 * Deferred Operations in XFS 34 * 35 * Due to the way locking rules work in XFS, certain transactions (block 36 * mapping and unmapping, typically) have permanent reservations so that 37 * we can roll the transaction to adhere to AG locking order rules and 38 * to unlock buffers between metadata updates. Prior to rmap/reflink, 39 * the mapping code had a mechanism to perform these deferrals for 40 * extents that were going to be freed; this code makes that facility 41 * more generic. 42 * 43 * When adding the reverse mapping and reflink features, it became 44 * necessary to perform complex remapping multi-transactions to comply 45 * with AG locking order rules, and to be able to spread a single 46 * refcount update operation (an operation on an n-block extent can 47 * update as many as n records!) among multiple transactions. XFS can 48 * roll a transaction to facilitate this, but using this facility 49 * requires us to log "intent" items in case log recovery needs to 50 * redo the operation, and to log "done" items to indicate that redo 51 * is not necessary. 52 * 53 * Deferred work is tracked in xfs_defer_pending items. Each pending 54 * item tracks one type of deferred work. Incoming work items (which 55 * have not yet had an intent logged) are attached to a pending item 56 * on the dop_intake list, where they wait for the caller to finish 57 * the deferred operations. 58 * 59 * Finishing a set of deferred operations is an involved process. To 60 * start, we define "rolling a deferred-op transaction" as follows: 61 * 62 * > For each xfs_defer_pending item on the dop_intake list, 63 * - Sort the work items in AG order. XFS locking 64 * order rules require us to lock buffers in AG order. 65 * - Create a log intent item for that type. 66 * - Attach it to the pending item. 67 * - Move the pending item from the dop_intake list to the 68 * dop_pending list. 69 * > Roll the transaction. 70 * 71 * NOTE: To avoid exceeding the transaction reservation, we limit the 72 * number of items that we attach to a given xfs_defer_pending. 73 * 74 * The actual finishing process looks like this: 75 * 76 * > For each xfs_defer_pending in the dop_pending list, 77 * - Roll the deferred-op transaction as above. 78 * - Create a log done item for that type, and attach it to the 79 * log intent item. 80 * - For each work item attached to the log intent item, 81 * * Perform the described action. 82 * * Attach the work item to the log done item. 83 * * If the result of doing the work was -EAGAIN, ->finish work 84 * wants a new transaction. See the "Requesting a Fresh 85 * Transaction while Finishing Deferred Work" section below for 86 * details. 87 * 88 * The key here is that we must log an intent item for all pending 89 * work items every time we roll the transaction, and that we must log 90 * a done item as soon as the work is completed. With this mechanism 91 * we can perform complex remapping operations, chaining intent items 92 * as needed. 93 * 94 * Requesting a Fresh Transaction while Finishing Deferred Work 95 * 96 * If ->finish_item decides that it needs a fresh transaction to 97 * finish the work, it must ask its caller (xfs_defer_finish) for a 98 * continuation. The most likely cause of this circumstance are the 99 * refcount adjust functions deciding that they've logged enough items 100 * to be at risk of exceeding the transaction reservation. 101 * 102 * To get a fresh transaction, we want to log the existing log done 103 * item to prevent the log intent item from replaying, immediately log 104 * a new log intent item with the unfinished work items, roll the 105 * transaction, and re-call ->finish_item wherever it left off. The 106 * log done item and the new log intent item must be in the same 107 * transaction or atomicity cannot be guaranteed; defer_finish ensures 108 * that this happens. 109 * 110 * This requires some coordination between ->finish_item and 111 * defer_finish. Upon deciding to request a new transaction, 112 * ->finish_item should update the current work item to reflect the 113 * unfinished work. Next, it should reset the log done item's list 114 * count to the number of items finished, and return -EAGAIN. 115 * defer_finish sees the -EAGAIN, logs the new log intent item 116 * with the remaining work items, and leaves the xfs_defer_pending 117 * item at the head of the dop_work queue. Then it rolls the 118 * transaction and picks up processing where it left off. It is 119 * required that ->finish_item must be careful to leave enough 120 * transaction reservation to fit the new log intent item. 121 * 122 * This is an example of remapping the extent (E, E+B) into file X at 123 * offset A and dealing with the extent (C, C+B) already being mapped 124 * there: 125 * +-------------------------------------------------+ 126 * | Unmap file X startblock C offset A length B | t0 127 * | Intent to reduce refcount for extent (C, B) | 128 * | Intent to remove rmap (X, C, A, B) | 129 * | Intent to free extent (D, 1) (bmbt block) | 130 * | Intent to map (X, A, B) at startblock E | 131 * +-------------------------------------------------+ 132 * | Map file X startblock E offset A length B | t1 133 * | Done mapping (X, E, A, B) | 134 * | Intent to increase refcount for extent (E, B) | 135 * | Intent to add rmap (X, E, A, B) | 136 * +-------------------------------------------------+ 137 * | Reduce refcount for extent (C, B) | t2 138 * | Done reducing refcount for extent (C, 9) | 139 * | Intent to reduce refcount for extent (C+9, B-9) | 140 * | (ran out of space after 9 refcount updates) | 141 * +-------------------------------------------------+ 142 * | Reduce refcount for extent (C+9, B+9) | t3 143 * | Done reducing refcount for extent (C+9, B-9) | 144 * | Increase refcount for extent (E, B) | 145 * | Done increasing refcount for extent (E, B) | 146 * | Intent to free extent (C, B) | 147 * | Intent to free extent (F, 1) (refcountbt block) | 148 * | Intent to remove rmap (F, 1, REFC) | 149 * +-------------------------------------------------+ 150 * | Remove rmap (X, C, A, B) | t4 151 * | Done removing rmap (X, C, A, B) | 152 * | Add rmap (X, E, A, B) | 153 * | Done adding rmap (X, E, A, B) | 154 * | Remove rmap (F, 1, REFC) | 155 * | Done removing rmap (F, 1, REFC) | 156 * +-------------------------------------------------+ 157 * | Free extent (C, B) | t5 158 * | Done freeing extent (C, B) | 159 * | Free extent (D, 1) | 160 * | Done freeing extent (D, 1) | 161 * | Free extent (F, 1) | 162 * | Done freeing extent (F, 1) | 163 * +-------------------------------------------------+ 164 * 165 * If we should crash before t2 commits, log recovery replays 166 * the following intent items: 167 * 168 * - Intent to reduce refcount for extent (C, B) 169 * - Intent to remove rmap (X, C, A, B) 170 * - Intent to free extent (D, 1) (bmbt block) 171 * - Intent to increase refcount for extent (E, B) 172 * - Intent to add rmap (X, E, A, B) 173 * 174 * In the process of recovering, it should also generate and take care 175 * of these intent items: 176 * 177 * - Intent to free extent (C, B) 178 * - Intent to free extent (F, 1) (refcountbt block) 179 * - Intent to remove rmap (F, 1, REFC) 180 * 181 * Note that the continuation requested between t2 and t3 is likely to 182 * reoccur. 183 */ 184 185 static const struct xfs_defer_op_type *defer_op_types[] = { 186 [XFS_DEFER_OPS_TYPE_BMAP] = &xfs_bmap_update_defer_type, 187 [XFS_DEFER_OPS_TYPE_REFCOUNT] = &xfs_refcount_update_defer_type, 188 [XFS_DEFER_OPS_TYPE_RMAP] = &xfs_rmap_update_defer_type, 189 [XFS_DEFER_OPS_TYPE_FREE] = &xfs_extent_free_defer_type, 190 [XFS_DEFER_OPS_TYPE_AGFL_FREE] = &xfs_agfl_free_defer_type, 191 [XFS_DEFER_OPS_TYPE_ATTR] = &xfs_attr_defer_type, 192 }; 193 194 /* 195 * Ensure there's a log intent item associated with this deferred work item if 196 * the operation must be restarted on crash. Returns 1 if there's a log item; 197 * 0 if there isn't; or a negative errno. 198 */ 199 static int 200 xfs_defer_create_intent( 201 struct xfs_trans *tp, 202 struct xfs_defer_pending *dfp, 203 bool sort) 204 { 205 const struct xfs_defer_op_type *ops = defer_op_types[dfp->dfp_type]; 206 struct xfs_log_item *lip; 207 208 if (dfp->dfp_intent) 209 return 1; 210 211 lip = ops->create_intent(tp, &dfp->dfp_work, dfp->dfp_count, sort); 212 if (!lip) 213 return 0; 214 if (IS_ERR(lip)) 215 return PTR_ERR(lip); 216 217 dfp->dfp_intent = lip; 218 return 1; 219 } 220 221 /* 222 * For each pending item in the intake list, log its intent item and the 223 * associated extents, then add the entire intake list to the end of 224 * the pending list. 225 * 226 * Returns 1 if at least one log item was associated with the deferred work; 227 * 0 if there are no log items; or a negative errno. 228 */ 229 static int 230 xfs_defer_create_intents( 231 struct xfs_trans *tp) 232 { 233 struct xfs_defer_pending *dfp; 234 int ret = 0; 235 236 list_for_each_entry(dfp, &tp->t_dfops, dfp_list) { 237 int ret2; 238 239 trace_xfs_defer_create_intent(tp->t_mountp, dfp); 240 ret2 = xfs_defer_create_intent(tp, dfp, true); 241 if (ret2 < 0) 242 return ret2; 243 ret |= ret2; 244 } 245 return ret; 246 } 247 248 /* Abort all the intents that were committed. */ 249 STATIC void 250 xfs_defer_trans_abort( 251 struct xfs_trans *tp, 252 struct list_head *dop_pending) 253 { 254 struct xfs_defer_pending *dfp; 255 const struct xfs_defer_op_type *ops; 256 257 trace_xfs_defer_trans_abort(tp, _RET_IP_); 258 259 /* Abort intent items that don't have a done item. */ 260 list_for_each_entry(dfp, dop_pending, dfp_list) { 261 ops = defer_op_types[dfp->dfp_type]; 262 trace_xfs_defer_pending_abort(tp->t_mountp, dfp); 263 if (dfp->dfp_intent && !dfp->dfp_done) { 264 ops->abort_intent(dfp->dfp_intent); 265 dfp->dfp_intent = NULL; 266 } 267 } 268 } 269 270 /* 271 * Capture resources that the caller said not to release ("held") when the 272 * transaction commits. Caller is responsible for zero-initializing @dres. 273 */ 274 static int 275 xfs_defer_save_resources( 276 struct xfs_defer_resources *dres, 277 struct xfs_trans *tp) 278 { 279 struct xfs_buf_log_item *bli; 280 struct xfs_inode_log_item *ili; 281 struct xfs_log_item *lip; 282 283 BUILD_BUG_ON(NBBY * sizeof(dres->dr_ordered) < XFS_DEFER_OPS_NR_BUFS); 284 285 list_for_each_entry(lip, &tp->t_items, li_trans) { 286 switch (lip->li_type) { 287 case XFS_LI_BUF: 288 bli = container_of(lip, struct xfs_buf_log_item, 289 bli_item); 290 if (bli->bli_flags & XFS_BLI_HOLD) { 291 if (dres->dr_bufs >= XFS_DEFER_OPS_NR_BUFS) { 292 ASSERT(0); 293 return -EFSCORRUPTED; 294 } 295 if (bli->bli_flags & XFS_BLI_ORDERED) 296 dres->dr_ordered |= 297 (1U << dres->dr_bufs); 298 else 299 xfs_trans_dirty_buf(tp, bli->bli_buf); 300 dres->dr_bp[dres->dr_bufs++] = bli->bli_buf; 301 } 302 break; 303 case XFS_LI_INODE: 304 ili = container_of(lip, struct xfs_inode_log_item, 305 ili_item); 306 if (ili->ili_lock_flags == 0) { 307 if (dres->dr_inos >= XFS_DEFER_OPS_NR_INODES) { 308 ASSERT(0); 309 return -EFSCORRUPTED; 310 } 311 xfs_trans_log_inode(tp, ili->ili_inode, 312 XFS_ILOG_CORE); 313 dres->dr_ip[dres->dr_inos++] = ili->ili_inode; 314 } 315 break; 316 default: 317 break; 318 } 319 } 320 321 return 0; 322 } 323 324 /* Attach the held resources to the transaction. */ 325 static void 326 xfs_defer_restore_resources( 327 struct xfs_trans *tp, 328 struct xfs_defer_resources *dres) 329 { 330 unsigned short i; 331 332 /* Rejoin the joined inodes. */ 333 for (i = 0; i < dres->dr_inos; i++) 334 xfs_trans_ijoin(tp, dres->dr_ip[i], 0); 335 336 /* Rejoin the buffers and dirty them so the log moves forward. */ 337 for (i = 0; i < dres->dr_bufs; i++) { 338 xfs_trans_bjoin(tp, dres->dr_bp[i]); 339 if (dres->dr_ordered & (1U << i)) 340 xfs_trans_ordered_buf(tp, dres->dr_bp[i]); 341 xfs_trans_bhold(tp, dres->dr_bp[i]); 342 } 343 } 344 345 /* Roll a transaction so we can do some deferred op processing. */ 346 STATIC int 347 xfs_defer_trans_roll( 348 struct xfs_trans **tpp) 349 { 350 struct xfs_defer_resources dres = { }; 351 int error; 352 353 error = xfs_defer_save_resources(&dres, *tpp); 354 if (error) 355 return error; 356 357 trace_xfs_defer_trans_roll(*tpp, _RET_IP_); 358 359 /* 360 * Roll the transaction. Rolling always given a new transaction (even 361 * if committing the old one fails!) to hand back to the caller, so we 362 * join the held resources to the new transaction so that we always 363 * return with the held resources joined to @tpp, no matter what 364 * happened. 365 */ 366 error = xfs_trans_roll(tpp); 367 368 xfs_defer_restore_resources(*tpp, &dres); 369 370 if (error) 371 trace_xfs_defer_trans_roll_error(*tpp, error); 372 return error; 373 } 374 375 /* 376 * Free up any items left in the list. 377 */ 378 static void 379 xfs_defer_cancel_list( 380 struct xfs_mount *mp, 381 struct list_head *dop_list) 382 { 383 struct xfs_defer_pending *dfp; 384 struct xfs_defer_pending *pli; 385 struct list_head *pwi; 386 struct list_head *n; 387 const struct xfs_defer_op_type *ops; 388 389 /* 390 * Free the pending items. Caller should already have arranged 391 * for the intent items to be released. 392 */ 393 list_for_each_entry_safe(dfp, pli, dop_list, dfp_list) { 394 ops = defer_op_types[dfp->dfp_type]; 395 trace_xfs_defer_cancel_list(mp, dfp); 396 list_del(&dfp->dfp_list); 397 list_for_each_safe(pwi, n, &dfp->dfp_work) { 398 list_del(pwi); 399 dfp->dfp_count--; 400 trace_xfs_defer_cancel_item(mp, dfp, pwi); 401 ops->cancel_item(pwi); 402 } 403 ASSERT(dfp->dfp_count == 0); 404 kmem_cache_free(xfs_defer_pending_cache, dfp); 405 } 406 } 407 408 /* 409 * Prevent a log intent item from pinning the tail of the log by logging a 410 * done item to release the intent item; and then log a new intent item. 411 * The caller should provide a fresh transaction and roll it after we're done. 412 */ 413 static int 414 xfs_defer_relog( 415 struct xfs_trans **tpp, 416 struct list_head *dfops) 417 { 418 struct xlog *log = (*tpp)->t_mountp->m_log; 419 struct xfs_defer_pending *dfp; 420 xfs_lsn_t threshold_lsn = NULLCOMMITLSN; 421 422 423 ASSERT((*tpp)->t_flags & XFS_TRANS_PERM_LOG_RES); 424 425 list_for_each_entry(dfp, dfops, dfp_list) { 426 /* 427 * If the log intent item for this deferred op is not a part of 428 * the current log checkpoint, relog the intent item to keep 429 * the log tail moving forward. We're ok with this being racy 430 * because an incorrect decision means we'll be a little slower 431 * at pushing the tail. 432 */ 433 if (dfp->dfp_intent == NULL || 434 xfs_log_item_in_current_chkpt(dfp->dfp_intent)) 435 continue; 436 437 /* 438 * Figure out where we need the tail to be in order to maintain 439 * the minimum required free space in the log. Only sample 440 * the log threshold once per call. 441 */ 442 if (threshold_lsn == NULLCOMMITLSN) { 443 threshold_lsn = xlog_grant_push_threshold(log, 0); 444 if (threshold_lsn == NULLCOMMITLSN) 445 break; 446 } 447 if (XFS_LSN_CMP(dfp->dfp_intent->li_lsn, threshold_lsn) >= 0) 448 continue; 449 450 trace_xfs_defer_relog_intent((*tpp)->t_mountp, dfp); 451 XFS_STATS_INC((*tpp)->t_mountp, defer_relog); 452 dfp->dfp_intent = xfs_trans_item_relog(dfp->dfp_intent, *tpp); 453 } 454 455 if ((*tpp)->t_flags & XFS_TRANS_DIRTY) 456 return xfs_defer_trans_roll(tpp); 457 return 0; 458 } 459 460 /* 461 * Log an intent-done item for the first pending intent, and finish the work 462 * items. 463 */ 464 static int 465 xfs_defer_finish_one( 466 struct xfs_trans *tp, 467 struct xfs_defer_pending *dfp) 468 { 469 const struct xfs_defer_op_type *ops = defer_op_types[dfp->dfp_type]; 470 struct xfs_btree_cur *state = NULL; 471 struct list_head *li, *n; 472 int error; 473 474 trace_xfs_defer_pending_finish(tp->t_mountp, dfp); 475 476 dfp->dfp_done = ops->create_done(tp, dfp->dfp_intent, dfp->dfp_count); 477 list_for_each_safe(li, n, &dfp->dfp_work) { 478 list_del(li); 479 dfp->dfp_count--; 480 trace_xfs_defer_finish_item(tp->t_mountp, dfp, li); 481 error = ops->finish_item(tp, dfp->dfp_done, li, &state); 482 if (error == -EAGAIN) { 483 int ret; 484 485 /* 486 * Caller wants a fresh transaction; put the work item 487 * back on the list and log a new log intent item to 488 * replace the old one. See "Requesting a Fresh 489 * Transaction while Finishing Deferred Work" above. 490 */ 491 list_add(li, &dfp->dfp_work); 492 dfp->dfp_count++; 493 dfp->dfp_done = NULL; 494 dfp->dfp_intent = NULL; 495 ret = xfs_defer_create_intent(tp, dfp, false); 496 if (ret < 0) 497 error = ret; 498 } 499 500 if (error) 501 goto out; 502 } 503 504 /* Done with the dfp, free it. */ 505 list_del(&dfp->dfp_list); 506 kmem_cache_free(xfs_defer_pending_cache, dfp); 507 out: 508 if (ops->finish_cleanup) 509 ops->finish_cleanup(tp, state, error); 510 return error; 511 } 512 513 /* 514 * Finish all the pending work. This involves logging intent items for 515 * any work items that wandered in since the last transaction roll (if 516 * one has even happened), rolling the transaction, and finishing the 517 * work items in the first item on the logged-and-pending list. 518 * 519 * If an inode is provided, relog it to the new transaction. 520 */ 521 int 522 xfs_defer_finish_noroll( 523 struct xfs_trans **tp) 524 { 525 struct xfs_defer_pending *dfp = NULL; 526 int error = 0; 527 LIST_HEAD(dop_pending); 528 529 ASSERT((*tp)->t_flags & XFS_TRANS_PERM_LOG_RES); 530 531 trace_xfs_defer_finish(*tp, _RET_IP_); 532 533 /* Until we run out of pending work to finish... */ 534 while (!list_empty(&dop_pending) || !list_empty(&(*tp)->t_dfops)) { 535 /* 536 * Deferred items that are created in the process of finishing 537 * other deferred work items should be queued at the head of 538 * the pending list, which puts them ahead of the deferred work 539 * that was created by the caller. This keeps the number of 540 * pending work items to a minimum, which decreases the amount 541 * of time that any one intent item can stick around in memory, 542 * pinning the log tail. 543 */ 544 int has_intents = xfs_defer_create_intents(*tp); 545 546 list_splice_init(&(*tp)->t_dfops, &dop_pending); 547 548 if (has_intents < 0) { 549 error = has_intents; 550 goto out_shutdown; 551 } 552 if (has_intents || dfp) { 553 error = xfs_defer_trans_roll(tp); 554 if (error) 555 goto out_shutdown; 556 557 /* Relog intent items to keep the log moving. */ 558 error = xfs_defer_relog(tp, &dop_pending); 559 if (error) 560 goto out_shutdown; 561 } 562 563 dfp = list_first_entry(&dop_pending, struct xfs_defer_pending, 564 dfp_list); 565 error = xfs_defer_finish_one(*tp, dfp); 566 if (error && error != -EAGAIN) 567 goto out_shutdown; 568 } 569 570 trace_xfs_defer_finish_done(*tp, _RET_IP_); 571 return 0; 572 573 out_shutdown: 574 xfs_defer_trans_abort(*tp, &dop_pending); 575 xfs_force_shutdown((*tp)->t_mountp, SHUTDOWN_CORRUPT_INCORE); 576 trace_xfs_defer_finish_error(*tp, error); 577 xfs_defer_cancel_list((*tp)->t_mountp, &dop_pending); 578 xfs_defer_cancel(*tp); 579 return error; 580 } 581 582 int 583 xfs_defer_finish( 584 struct xfs_trans **tp) 585 { 586 int error; 587 588 /* 589 * Finish and roll the transaction once more to avoid returning to the 590 * caller with a dirty transaction. 591 */ 592 error = xfs_defer_finish_noroll(tp); 593 if (error) 594 return error; 595 if ((*tp)->t_flags & XFS_TRANS_DIRTY) { 596 error = xfs_defer_trans_roll(tp); 597 if (error) { 598 xfs_force_shutdown((*tp)->t_mountp, 599 SHUTDOWN_CORRUPT_INCORE); 600 return error; 601 } 602 } 603 604 /* Reset LOWMODE now that we've finished all the dfops. */ 605 ASSERT(list_empty(&(*tp)->t_dfops)); 606 (*tp)->t_flags &= ~XFS_TRANS_LOWMODE; 607 return 0; 608 } 609 610 void 611 xfs_defer_cancel( 612 struct xfs_trans *tp) 613 { 614 struct xfs_mount *mp = tp->t_mountp; 615 616 trace_xfs_defer_cancel(tp, _RET_IP_); 617 xfs_defer_cancel_list(mp, &tp->t_dfops); 618 } 619 620 /* Add an item for later deferred processing. */ 621 void 622 xfs_defer_add( 623 struct xfs_trans *tp, 624 enum xfs_defer_ops_type type, 625 struct list_head *li) 626 { 627 struct xfs_defer_pending *dfp = NULL; 628 const struct xfs_defer_op_type *ops = defer_op_types[type]; 629 630 ASSERT(tp->t_flags & XFS_TRANS_PERM_LOG_RES); 631 BUILD_BUG_ON(ARRAY_SIZE(defer_op_types) != XFS_DEFER_OPS_TYPE_MAX); 632 633 /* 634 * Add the item to a pending item at the end of the intake list. 635 * If the last pending item has the same type, reuse it. Else, 636 * create a new pending item at the end of the intake list. 637 */ 638 if (!list_empty(&tp->t_dfops)) { 639 dfp = list_last_entry(&tp->t_dfops, 640 struct xfs_defer_pending, dfp_list); 641 if (dfp->dfp_type != type || 642 (ops->max_items && dfp->dfp_count >= ops->max_items)) 643 dfp = NULL; 644 } 645 if (!dfp) { 646 dfp = kmem_cache_zalloc(xfs_defer_pending_cache, 647 GFP_NOFS | __GFP_NOFAIL); 648 dfp->dfp_type = type; 649 dfp->dfp_intent = NULL; 650 dfp->dfp_done = NULL; 651 dfp->dfp_count = 0; 652 INIT_LIST_HEAD(&dfp->dfp_work); 653 list_add_tail(&dfp->dfp_list, &tp->t_dfops); 654 } 655 656 list_add_tail(li, &dfp->dfp_work); 657 trace_xfs_defer_add_item(tp->t_mountp, dfp, li); 658 dfp->dfp_count++; 659 } 660 661 /* 662 * Move deferred ops from one transaction to another and reset the source to 663 * initial state. This is primarily used to carry state forward across 664 * transaction rolls with pending dfops. 665 */ 666 void 667 xfs_defer_move( 668 struct xfs_trans *dtp, 669 struct xfs_trans *stp) 670 { 671 list_splice_init(&stp->t_dfops, &dtp->t_dfops); 672 673 /* 674 * Low free space mode was historically controlled by a dfops field. 675 * This meant that low mode state potentially carried across multiple 676 * transaction rolls. Transfer low mode on a dfops move to preserve 677 * that behavior. 678 */ 679 dtp->t_flags |= (stp->t_flags & XFS_TRANS_LOWMODE); 680 stp->t_flags &= ~XFS_TRANS_LOWMODE; 681 } 682 683 /* 684 * Prepare a chain of fresh deferred ops work items to be completed later. Log 685 * recovery requires the ability to put off until later the actual finishing 686 * work so that it can process unfinished items recovered from the log in 687 * correct order. 688 * 689 * Create and log intent items for all the work that we're capturing so that we 690 * can be assured that the items will get replayed if the system goes down 691 * before log recovery gets a chance to finish the work it put off. The entire 692 * deferred ops state is transferred to the capture structure and the 693 * transaction is then ready for the caller to commit it. If there are no 694 * intent items to capture, this function returns NULL. 695 * 696 * If capture_ip is not NULL, the capture structure will obtain an extra 697 * reference to the inode. 698 */ 699 static struct xfs_defer_capture * 700 xfs_defer_ops_capture( 701 struct xfs_trans *tp) 702 { 703 struct xfs_defer_capture *dfc; 704 unsigned short i; 705 int error; 706 707 if (list_empty(&tp->t_dfops)) 708 return NULL; 709 710 error = xfs_defer_create_intents(tp); 711 if (error < 0) 712 return ERR_PTR(error); 713 714 /* Create an object to capture the defer ops. */ 715 dfc = kmem_zalloc(sizeof(*dfc), KM_NOFS); 716 INIT_LIST_HEAD(&dfc->dfc_list); 717 INIT_LIST_HEAD(&dfc->dfc_dfops); 718 719 /* Move the dfops chain and transaction state to the capture struct. */ 720 list_splice_init(&tp->t_dfops, &dfc->dfc_dfops); 721 dfc->dfc_tpflags = tp->t_flags & XFS_TRANS_LOWMODE; 722 tp->t_flags &= ~XFS_TRANS_LOWMODE; 723 724 /* Capture the remaining block reservations along with the dfops. */ 725 dfc->dfc_blkres = tp->t_blk_res - tp->t_blk_res_used; 726 dfc->dfc_rtxres = tp->t_rtx_res - tp->t_rtx_res_used; 727 728 /* Preserve the log reservation size. */ 729 dfc->dfc_logres = tp->t_log_res; 730 731 error = xfs_defer_save_resources(&dfc->dfc_held, tp); 732 if (error) { 733 /* 734 * Resource capture should never fail, but if it does, we 735 * still have to shut down the log and release things 736 * properly. 737 */ 738 xfs_force_shutdown(tp->t_mountp, SHUTDOWN_CORRUPT_INCORE); 739 } 740 741 /* 742 * Grab extra references to the inodes and buffers because callers are 743 * expected to release their held references after we commit the 744 * transaction. 745 */ 746 for (i = 0; i < dfc->dfc_held.dr_inos; i++) { 747 ASSERT(xfs_isilocked(dfc->dfc_held.dr_ip[i], XFS_ILOCK_EXCL)); 748 ihold(VFS_I(dfc->dfc_held.dr_ip[i])); 749 } 750 751 for (i = 0; i < dfc->dfc_held.dr_bufs; i++) 752 xfs_buf_hold(dfc->dfc_held.dr_bp[i]); 753 754 return dfc; 755 } 756 757 /* Release all resources that we used to capture deferred ops. */ 758 void 759 xfs_defer_ops_capture_free( 760 struct xfs_mount *mp, 761 struct xfs_defer_capture *dfc) 762 { 763 unsigned short i; 764 765 xfs_defer_cancel_list(mp, &dfc->dfc_dfops); 766 767 for (i = 0; i < dfc->dfc_held.dr_bufs; i++) 768 xfs_buf_relse(dfc->dfc_held.dr_bp[i]); 769 770 for (i = 0; i < dfc->dfc_held.dr_inos; i++) 771 xfs_irele(dfc->dfc_held.dr_ip[i]); 772 773 kmem_free(dfc); 774 } 775 776 /* 777 * Capture any deferred ops and commit the transaction. This is the last step 778 * needed to finish a log intent item that we recovered from the log. If any 779 * of the deferred ops operate on an inode, the caller must pass in that inode 780 * so that the reference can be transferred to the capture structure. The 781 * caller must hold ILOCK_EXCL on the inode, and must unlock it before calling 782 * xfs_defer_ops_continue. 783 */ 784 int 785 xfs_defer_ops_capture_and_commit( 786 struct xfs_trans *tp, 787 struct list_head *capture_list) 788 { 789 struct xfs_mount *mp = tp->t_mountp; 790 struct xfs_defer_capture *dfc; 791 int error; 792 793 /* If we don't capture anything, commit transaction and exit. */ 794 dfc = xfs_defer_ops_capture(tp); 795 if (IS_ERR(dfc)) { 796 xfs_trans_cancel(tp); 797 return PTR_ERR(dfc); 798 } 799 if (!dfc) 800 return xfs_trans_commit(tp); 801 802 /* Commit the transaction and add the capture structure to the list. */ 803 error = xfs_trans_commit(tp); 804 if (error) { 805 xfs_defer_ops_capture_free(mp, dfc); 806 return error; 807 } 808 809 list_add_tail(&dfc->dfc_list, capture_list); 810 return 0; 811 } 812 813 /* 814 * Attach a chain of captured deferred ops to a new transaction and free the 815 * capture structure. If an inode was captured, it will be passed back to the 816 * caller with ILOCK_EXCL held and joined to the transaction with lockflags==0. 817 * The caller now owns the inode reference. 818 */ 819 void 820 xfs_defer_ops_continue( 821 struct xfs_defer_capture *dfc, 822 struct xfs_trans *tp, 823 struct xfs_defer_resources *dres) 824 { 825 unsigned int i; 826 827 ASSERT(tp->t_flags & XFS_TRANS_PERM_LOG_RES); 828 ASSERT(!(tp->t_flags & XFS_TRANS_DIRTY)); 829 830 /* Lock the captured resources to the new transaction. */ 831 if (dfc->dfc_held.dr_inos == 2) 832 xfs_lock_two_inodes(dfc->dfc_held.dr_ip[0], XFS_ILOCK_EXCL, 833 dfc->dfc_held.dr_ip[1], XFS_ILOCK_EXCL); 834 else if (dfc->dfc_held.dr_inos == 1) 835 xfs_ilock(dfc->dfc_held.dr_ip[0], XFS_ILOCK_EXCL); 836 837 for (i = 0; i < dfc->dfc_held.dr_bufs; i++) 838 xfs_buf_lock(dfc->dfc_held.dr_bp[i]); 839 840 /* Join the captured resources to the new transaction. */ 841 xfs_defer_restore_resources(tp, &dfc->dfc_held); 842 memcpy(dres, &dfc->dfc_held, sizeof(struct xfs_defer_resources)); 843 dres->dr_bufs = 0; 844 845 /* Move captured dfops chain and state to the transaction. */ 846 list_splice_init(&dfc->dfc_dfops, &tp->t_dfops); 847 tp->t_flags |= dfc->dfc_tpflags; 848 849 kmem_free(dfc); 850 } 851 852 /* Release the resources captured and continued during recovery. */ 853 void 854 xfs_defer_resources_rele( 855 struct xfs_defer_resources *dres) 856 { 857 unsigned short i; 858 859 for (i = 0; i < dres->dr_inos; i++) { 860 xfs_iunlock(dres->dr_ip[i], XFS_ILOCK_EXCL); 861 xfs_irele(dres->dr_ip[i]); 862 dres->dr_ip[i] = NULL; 863 } 864 865 for (i = 0; i < dres->dr_bufs; i++) { 866 xfs_buf_relse(dres->dr_bp[i]); 867 dres->dr_bp[i] = NULL; 868 } 869 870 dres->dr_inos = 0; 871 dres->dr_bufs = 0; 872 dres->dr_ordered = 0; 873 } 874 875 static inline int __init 876 xfs_defer_init_cache(void) 877 { 878 xfs_defer_pending_cache = kmem_cache_create("xfs_defer_pending", 879 sizeof(struct xfs_defer_pending), 880 0, 0, NULL); 881 882 return xfs_defer_pending_cache != NULL ? 0 : -ENOMEM; 883 } 884 885 static inline void 886 xfs_defer_destroy_cache(void) 887 { 888 kmem_cache_destroy(xfs_defer_pending_cache); 889 xfs_defer_pending_cache = NULL; 890 } 891 892 /* Set up caches for deferred work items. */ 893 int __init 894 xfs_defer_init_item_caches(void) 895 { 896 int error; 897 898 error = xfs_defer_init_cache(); 899 if (error) 900 return error; 901 error = xfs_rmap_intent_init_cache(); 902 if (error) 903 goto err; 904 error = xfs_refcount_intent_init_cache(); 905 if (error) 906 goto err; 907 error = xfs_bmap_intent_init_cache(); 908 if (error) 909 goto err; 910 error = xfs_extfree_intent_init_cache(); 911 if (error) 912 goto err; 913 error = xfs_attr_intent_init_cache(); 914 if (error) 915 goto err; 916 return 0; 917 err: 918 xfs_defer_destroy_item_caches(); 919 return error; 920 } 921 922 /* Destroy all the deferred work item caches, if they've been allocated. */ 923 void 924 xfs_defer_destroy_item_caches(void) 925 { 926 xfs_attr_intent_destroy_cache(); 927 xfs_extfree_intent_destroy_cache(); 928 xfs_bmap_intent_destroy_cache(); 929 xfs_refcount_intent_destroy_cache(); 930 xfs_rmap_intent_destroy_cache(); 931 xfs_defer_destroy_cache(); 932 } 933