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