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 * Log an intent-done item for the first pending intent, and finish the work 356 * items. 357 */ 358 static int 359 xfs_defer_finish_one( 360 struct xfs_trans *tp, 361 struct xfs_defer_pending *dfp) 362 { 363 const struct xfs_defer_op_type *ops = defer_op_types[dfp->dfp_type]; 364 void *state = NULL; 365 struct list_head *li, *n; 366 int error; 367 368 trace_xfs_defer_pending_finish(tp->t_mountp, dfp); 369 370 dfp->dfp_done = ops->create_done(tp, dfp->dfp_intent, dfp->dfp_count); 371 list_for_each_safe(li, n, &dfp->dfp_work) { 372 list_del(li); 373 dfp->dfp_count--; 374 error = ops->finish_item(tp, li, dfp->dfp_done, &state); 375 if (error == -EAGAIN) { 376 /* 377 * Caller wants a fresh transaction; put the work item 378 * back on the list and log a new log intent item to 379 * replace the old one. See "Requesting a Fresh 380 * Transaction while Finishing Deferred Work" above. 381 */ 382 list_add(li, &dfp->dfp_work); 383 dfp->dfp_count++; 384 dfp->dfp_done = NULL; 385 xfs_defer_create_intent(tp, dfp, false); 386 } 387 388 if (error) 389 goto out; 390 } 391 392 /* Done with the dfp, free it. */ 393 list_del(&dfp->dfp_list); 394 kmem_free(dfp); 395 out: 396 if (ops->finish_cleanup) 397 ops->finish_cleanup(tp, state, error); 398 return error; 399 } 400 401 /* 402 * Finish all the pending work. This involves logging intent items for 403 * any work items that wandered in since the last transaction roll (if 404 * one has even happened), rolling the transaction, and finishing the 405 * work items in the first item on the logged-and-pending list. 406 * 407 * If an inode is provided, relog it to the new transaction. 408 */ 409 int 410 xfs_defer_finish_noroll( 411 struct xfs_trans **tp) 412 { 413 struct xfs_defer_pending *dfp; 414 int error = 0; 415 LIST_HEAD(dop_pending); 416 417 ASSERT((*tp)->t_flags & XFS_TRANS_PERM_LOG_RES); 418 419 trace_xfs_defer_finish(*tp, _RET_IP_); 420 421 /* Until we run out of pending work to finish... */ 422 while (!list_empty(&dop_pending) || !list_empty(&(*tp)->t_dfops)) { 423 xfs_defer_create_intents(*tp); 424 list_splice_tail_init(&(*tp)->t_dfops, &dop_pending); 425 426 error = xfs_defer_trans_roll(tp); 427 if (error) 428 goto out_shutdown; 429 430 dfp = list_first_entry(&dop_pending, struct xfs_defer_pending, 431 dfp_list); 432 error = xfs_defer_finish_one(*tp, dfp); 433 if (error && error != -EAGAIN) 434 goto out_shutdown; 435 } 436 437 trace_xfs_defer_finish_done(*tp, _RET_IP_); 438 return 0; 439 440 out_shutdown: 441 xfs_defer_trans_abort(*tp, &dop_pending); 442 xfs_force_shutdown((*tp)->t_mountp, SHUTDOWN_CORRUPT_INCORE); 443 trace_xfs_defer_finish_error(*tp, error); 444 xfs_defer_cancel_list((*tp)->t_mountp, &dop_pending); 445 xfs_defer_cancel(*tp); 446 return error; 447 } 448 449 int 450 xfs_defer_finish( 451 struct xfs_trans **tp) 452 { 453 int error; 454 455 /* 456 * Finish and roll the transaction once more to avoid returning to the 457 * caller with a dirty transaction. 458 */ 459 error = xfs_defer_finish_noroll(tp); 460 if (error) 461 return error; 462 if ((*tp)->t_flags & XFS_TRANS_DIRTY) { 463 error = xfs_defer_trans_roll(tp); 464 if (error) { 465 xfs_force_shutdown((*tp)->t_mountp, 466 SHUTDOWN_CORRUPT_INCORE); 467 return error; 468 } 469 } 470 xfs_defer_reset(*tp); 471 return 0; 472 } 473 474 void 475 xfs_defer_cancel( 476 struct xfs_trans *tp) 477 { 478 struct xfs_mount *mp = tp->t_mountp; 479 480 trace_xfs_defer_cancel(tp, _RET_IP_); 481 xfs_defer_cancel_list(mp, &tp->t_dfops); 482 } 483 484 /* Add an item for later deferred processing. */ 485 void 486 xfs_defer_add( 487 struct xfs_trans *tp, 488 enum xfs_defer_ops_type type, 489 struct list_head *li) 490 { 491 struct xfs_defer_pending *dfp = NULL; 492 const struct xfs_defer_op_type *ops; 493 494 ASSERT(tp->t_flags & XFS_TRANS_PERM_LOG_RES); 495 BUILD_BUG_ON(ARRAY_SIZE(defer_op_types) != XFS_DEFER_OPS_TYPE_MAX); 496 497 /* 498 * Add the item to a pending item at the end of the intake list. 499 * If the last pending item has the same type, reuse it. Else, 500 * create a new pending item at the end of the intake list. 501 */ 502 if (!list_empty(&tp->t_dfops)) { 503 dfp = list_last_entry(&tp->t_dfops, 504 struct xfs_defer_pending, dfp_list); 505 ops = defer_op_types[dfp->dfp_type]; 506 if (dfp->dfp_type != type || 507 (ops->max_items && dfp->dfp_count >= ops->max_items)) 508 dfp = NULL; 509 } 510 if (!dfp) { 511 dfp = kmem_alloc(sizeof(struct xfs_defer_pending), 512 KM_NOFS); 513 dfp->dfp_type = type; 514 dfp->dfp_intent = NULL; 515 dfp->dfp_done = NULL; 516 dfp->dfp_count = 0; 517 INIT_LIST_HEAD(&dfp->dfp_work); 518 list_add_tail(&dfp->dfp_list, &tp->t_dfops); 519 } 520 521 list_add_tail(li, &dfp->dfp_work); 522 dfp->dfp_count++; 523 } 524 525 /* 526 * Move deferred ops from one transaction to another and reset the source to 527 * initial state. This is primarily used to carry state forward across 528 * transaction rolls with pending dfops. 529 */ 530 void 531 xfs_defer_move( 532 struct xfs_trans *dtp, 533 struct xfs_trans *stp) 534 { 535 list_splice_init(&stp->t_dfops, &dtp->t_dfops); 536 537 /* 538 * Low free space mode was historically controlled by a dfops field. 539 * This meant that low mode state potentially carried across multiple 540 * transaction rolls. Transfer low mode on a dfops move to preserve 541 * that behavior. 542 */ 543 dtp->t_flags |= (stp->t_flags & XFS_TRANS_LOWMODE); 544 545 xfs_defer_reset(stp); 546 } 547