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