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 struct list_head *li; 189 190 if (sort) 191 list_sort(tp->t_mountp, &dfp->dfp_work, ops->diff_items); 192 193 dfp->dfp_intent = ops->create_intent(tp, dfp->dfp_count); 194 list_for_each(li, &dfp->dfp_work) 195 ops->log_item(tp, dfp->dfp_intent, li); 196 } 197 198 /* 199 * For each pending item in the intake list, log its intent item and the 200 * associated extents, then add the entire intake list to the end of 201 * the pending list. 202 */ 203 STATIC void 204 xfs_defer_create_intents( 205 struct xfs_trans *tp) 206 { 207 struct xfs_defer_pending *dfp; 208 209 list_for_each_entry(dfp, &tp->t_dfops, dfp_list) { 210 trace_xfs_defer_create_intent(tp->t_mountp, dfp); 211 xfs_defer_create_intent(tp, dfp, true); 212 } 213 } 214 215 /* Abort all the intents that were committed. */ 216 STATIC void 217 xfs_defer_trans_abort( 218 struct xfs_trans *tp, 219 struct list_head *dop_pending) 220 { 221 struct xfs_defer_pending *dfp; 222 const struct xfs_defer_op_type *ops; 223 224 trace_xfs_defer_trans_abort(tp, _RET_IP_); 225 226 /* Abort intent items that don't have a done item. */ 227 list_for_each_entry(dfp, dop_pending, dfp_list) { 228 ops = defer_op_types[dfp->dfp_type]; 229 trace_xfs_defer_pending_abort(tp->t_mountp, dfp); 230 if (dfp->dfp_intent && !dfp->dfp_done) { 231 ops->abort_intent(dfp->dfp_intent); 232 dfp->dfp_intent = NULL; 233 } 234 } 235 } 236 237 /* Roll a transaction so we can do some deferred op processing. */ 238 STATIC int 239 xfs_defer_trans_roll( 240 struct xfs_trans **tpp) 241 { 242 struct xfs_trans *tp = *tpp; 243 struct xfs_buf_log_item *bli; 244 struct xfs_inode_log_item *ili; 245 struct xfs_log_item *lip; 246 struct xfs_buf *bplist[XFS_DEFER_OPS_NR_BUFS]; 247 struct xfs_inode *iplist[XFS_DEFER_OPS_NR_INODES]; 248 int bpcount = 0, ipcount = 0; 249 int i; 250 int error; 251 252 list_for_each_entry(lip, &tp->t_items, li_trans) { 253 switch (lip->li_type) { 254 case XFS_LI_BUF: 255 bli = container_of(lip, struct xfs_buf_log_item, 256 bli_item); 257 if (bli->bli_flags & XFS_BLI_HOLD) { 258 if (bpcount >= XFS_DEFER_OPS_NR_BUFS) { 259 ASSERT(0); 260 return -EFSCORRUPTED; 261 } 262 xfs_trans_dirty_buf(tp, bli->bli_buf); 263 bplist[bpcount++] = bli->bli_buf; 264 } 265 break; 266 case XFS_LI_INODE: 267 ili = container_of(lip, struct xfs_inode_log_item, 268 ili_item); 269 if (ili->ili_lock_flags == 0) { 270 if (ipcount >= XFS_DEFER_OPS_NR_INODES) { 271 ASSERT(0); 272 return -EFSCORRUPTED; 273 } 274 xfs_trans_log_inode(tp, ili->ili_inode, 275 XFS_ILOG_CORE); 276 iplist[ipcount++] = ili->ili_inode; 277 } 278 break; 279 default: 280 break; 281 } 282 } 283 284 trace_xfs_defer_trans_roll(tp, _RET_IP_); 285 286 /* 287 * Roll the transaction. Rolling always given a new transaction (even 288 * if committing the old one fails!) to hand back to the caller, so we 289 * join the held resources to the new transaction so that we always 290 * return with the held resources joined to @tpp, no matter what 291 * happened. 292 */ 293 error = xfs_trans_roll(tpp); 294 tp = *tpp; 295 296 /* Rejoin the joined inodes. */ 297 for (i = 0; i < ipcount; i++) 298 xfs_trans_ijoin(tp, iplist[i], 0); 299 300 /* Rejoin the buffers and dirty them so the log moves forward. */ 301 for (i = 0; i < bpcount; i++) { 302 xfs_trans_bjoin(tp, bplist[i]); 303 xfs_trans_bhold(tp, bplist[i]); 304 } 305 306 if (error) 307 trace_xfs_defer_trans_roll_error(tp, error); 308 return error; 309 } 310 311 /* 312 * Reset an already used dfops after finish. 313 */ 314 static void 315 xfs_defer_reset( 316 struct xfs_trans *tp) 317 { 318 ASSERT(list_empty(&tp->t_dfops)); 319 320 /* 321 * Low mode state transfers across transaction rolls to mirror dfops 322 * lifetime. Clear it now that dfops is reset. 323 */ 324 tp->t_flags &= ~XFS_TRANS_LOWMODE; 325 } 326 327 /* 328 * Free up any items left in the list. 329 */ 330 static void 331 xfs_defer_cancel_list( 332 struct xfs_mount *mp, 333 struct list_head *dop_list) 334 { 335 struct xfs_defer_pending *dfp; 336 struct xfs_defer_pending *pli; 337 struct list_head *pwi; 338 struct list_head *n; 339 const struct xfs_defer_op_type *ops; 340 341 /* 342 * Free the pending items. Caller should already have arranged 343 * for the intent items to be released. 344 */ 345 list_for_each_entry_safe(dfp, pli, dop_list, dfp_list) { 346 ops = defer_op_types[dfp->dfp_type]; 347 trace_xfs_defer_cancel_list(mp, dfp); 348 list_del(&dfp->dfp_list); 349 list_for_each_safe(pwi, n, &dfp->dfp_work) { 350 list_del(pwi); 351 dfp->dfp_count--; 352 ops->cancel_item(pwi); 353 } 354 ASSERT(dfp->dfp_count == 0); 355 kmem_free(dfp); 356 } 357 } 358 359 /* 360 * Finish all the pending work. This involves logging intent items for 361 * any work items that wandered in since the last transaction roll (if 362 * one has even happened), rolling the transaction, and finishing the 363 * work items in the first item on the logged-and-pending list. 364 * 365 * If an inode is provided, relog it to the new transaction. 366 */ 367 int 368 xfs_defer_finish_noroll( 369 struct xfs_trans **tp) 370 { 371 struct xfs_defer_pending *dfp; 372 struct list_head *li; 373 struct list_head *n; 374 void *state; 375 int error = 0; 376 const struct xfs_defer_op_type *ops; 377 LIST_HEAD(dop_pending); 378 379 ASSERT((*tp)->t_flags & XFS_TRANS_PERM_LOG_RES); 380 381 trace_xfs_defer_finish(*tp, _RET_IP_); 382 383 /* Until we run out of pending work to finish... */ 384 while (!list_empty(&dop_pending) || !list_empty(&(*tp)->t_dfops)) { 385 /* log intents and pull in intake items */ 386 xfs_defer_create_intents(*tp); 387 list_splice_tail_init(&(*tp)->t_dfops, &dop_pending); 388 389 /* 390 * Roll the transaction. 391 */ 392 error = xfs_defer_trans_roll(tp); 393 if (error) 394 goto out; 395 396 /* Log an intent-done item for the first pending item. */ 397 dfp = list_first_entry(&dop_pending, struct xfs_defer_pending, 398 dfp_list); 399 ops = defer_op_types[dfp->dfp_type]; 400 trace_xfs_defer_pending_finish((*tp)->t_mountp, dfp); 401 dfp->dfp_done = ops->create_done(*tp, dfp->dfp_intent, 402 dfp->dfp_count); 403 404 /* Finish the work items. */ 405 state = NULL; 406 list_for_each_safe(li, n, &dfp->dfp_work) { 407 list_del(li); 408 dfp->dfp_count--; 409 error = ops->finish_item(*tp, li, dfp->dfp_done, 410 &state); 411 if (error == -EAGAIN) { 412 /* 413 * Caller wants a fresh transaction; 414 * put the work item back on the list 415 * and jump out. 416 */ 417 list_add(li, &dfp->dfp_work); 418 dfp->dfp_count++; 419 break; 420 } else if (error) { 421 /* 422 * Clean up after ourselves and jump out. 423 * xfs_defer_cancel will take care of freeing 424 * all these lists and stuff. 425 */ 426 if (ops->finish_cleanup) 427 ops->finish_cleanup(*tp, state, error); 428 goto out; 429 } 430 } 431 if (error == -EAGAIN) { 432 /* 433 * Caller wants a fresh transaction, so log a new log 434 * intent item to replace the old one and roll the 435 * transaction. See "Requesting a Fresh Transaction 436 * while Finishing Deferred Work" above. 437 */ 438 dfp->dfp_done = NULL; 439 xfs_defer_create_intent(*tp, dfp, false); 440 } else { 441 /* Done with the dfp, free it. */ 442 list_del(&dfp->dfp_list); 443 kmem_free(dfp); 444 } 445 446 if (ops->finish_cleanup) 447 ops->finish_cleanup(*tp, state, error); 448 } 449 450 out: 451 if (error) { 452 xfs_defer_trans_abort(*tp, &dop_pending); 453 xfs_force_shutdown((*tp)->t_mountp, SHUTDOWN_CORRUPT_INCORE); 454 trace_xfs_defer_finish_error(*tp, error); 455 xfs_defer_cancel_list((*tp)->t_mountp, &dop_pending); 456 xfs_defer_cancel(*tp); 457 return error; 458 } 459 460 trace_xfs_defer_finish_done(*tp, _RET_IP_); 461 return 0; 462 } 463 464 int 465 xfs_defer_finish( 466 struct xfs_trans **tp) 467 { 468 int error; 469 470 /* 471 * Finish and roll the transaction once more to avoid returning to the 472 * caller with a dirty transaction. 473 */ 474 error = xfs_defer_finish_noroll(tp); 475 if (error) 476 return error; 477 if ((*tp)->t_flags & XFS_TRANS_DIRTY) { 478 error = xfs_defer_trans_roll(tp); 479 if (error) { 480 xfs_force_shutdown((*tp)->t_mountp, 481 SHUTDOWN_CORRUPT_INCORE); 482 return error; 483 } 484 } 485 xfs_defer_reset(*tp); 486 return 0; 487 } 488 489 void 490 xfs_defer_cancel( 491 struct xfs_trans *tp) 492 { 493 struct xfs_mount *mp = tp->t_mountp; 494 495 trace_xfs_defer_cancel(tp, _RET_IP_); 496 xfs_defer_cancel_list(mp, &tp->t_dfops); 497 } 498 499 /* Add an item for later deferred processing. */ 500 void 501 xfs_defer_add( 502 struct xfs_trans *tp, 503 enum xfs_defer_ops_type type, 504 struct list_head *li) 505 { 506 struct xfs_defer_pending *dfp = NULL; 507 const struct xfs_defer_op_type *ops; 508 509 ASSERT(tp->t_flags & XFS_TRANS_PERM_LOG_RES); 510 BUILD_BUG_ON(ARRAY_SIZE(defer_op_types) != XFS_DEFER_OPS_TYPE_MAX); 511 512 /* 513 * Add the item to a pending item at the end of the intake list. 514 * If the last pending item has the same type, reuse it. Else, 515 * create a new pending item at the end of the intake list. 516 */ 517 if (!list_empty(&tp->t_dfops)) { 518 dfp = list_last_entry(&tp->t_dfops, 519 struct xfs_defer_pending, dfp_list); 520 ops = defer_op_types[dfp->dfp_type]; 521 if (dfp->dfp_type != type || 522 (ops->max_items && dfp->dfp_count >= ops->max_items)) 523 dfp = NULL; 524 } 525 if (!dfp) { 526 dfp = kmem_alloc(sizeof(struct xfs_defer_pending), 527 KM_NOFS); 528 dfp->dfp_type = type; 529 dfp->dfp_intent = NULL; 530 dfp->dfp_done = NULL; 531 dfp->dfp_count = 0; 532 INIT_LIST_HEAD(&dfp->dfp_work); 533 list_add_tail(&dfp->dfp_list, &tp->t_dfops); 534 } 535 536 list_add_tail(li, &dfp->dfp_work); 537 dfp->dfp_count++; 538 } 539 540 /* 541 * Move deferred ops from one transaction to another and reset the source to 542 * initial state. This is primarily used to carry state forward across 543 * transaction rolls with pending dfops. 544 */ 545 void 546 xfs_defer_move( 547 struct xfs_trans *dtp, 548 struct xfs_trans *stp) 549 { 550 list_splice_init(&stp->t_dfops, &dtp->t_dfops); 551 552 /* 553 * Low free space mode was historically controlled by a dfops field. 554 * This meant that low mode state potentially carried across multiple 555 * transaction rolls. Transfer low mode on a dfops move to preserve 556 * that behavior. 557 */ 558 dtp->t_flags |= (stp->t_flags & XFS_TRANS_LOWMODE); 559 560 xfs_defer_reset(stp); 561 } 562