1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright (c) 2000-2001,2005 Silicon Graphics, Inc. 4 * All Rights Reserved. 5 */ 6 #include "xfs.h" 7 #include "xfs_fs.h" 8 #include "xfs_format.h" 9 #include "xfs_log_format.h" 10 #include "xfs_trans_resv.h" 11 #include "xfs_bit.h" 12 #include "xfs_mount.h" 13 #include "xfs_trans.h" 14 #include "xfs_trans_priv.h" 15 #include "xfs_buf_item.h" 16 #include "xfs_extfree_item.h" 17 #include "xfs_log.h" 18 #include "xfs_btree.h" 19 #include "xfs_rmap.h" 20 21 22 kmem_zone_t *xfs_efi_zone; 23 kmem_zone_t *xfs_efd_zone; 24 25 static inline struct xfs_efi_log_item *EFI_ITEM(struct xfs_log_item *lip) 26 { 27 return container_of(lip, struct xfs_efi_log_item, efi_item); 28 } 29 30 void 31 xfs_efi_item_free( 32 struct xfs_efi_log_item *efip) 33 { 34 kmem_free(efip->efi_item.li_lv_shadow); 35 if (efip->efi_format.efi_nextents > XFS_EFI_MAX_FAST_EXTENTS) 36 kmem_free(efip); 37 else 38 kmem_zone_free(xfs_efi_zone, efip); 39 } 40 41 /* 42 * Freeing the efi requires that we remove it from the AIL if it has already 43 * been placed there. However, the EFI may not yet have been placed in the AIL 44 * when called by xfs_efi_release() from EFD processing due to the ordering of 45 * committed vs unpin operations in bulk insert operations. Hence the reference 46 * count to ensure only the last caller frees the EFI. 47 */ 48 void 49 xfs_efi_release( 50 struct xfs_efi_log_item *efip) 51 { 52 ASSERT(atomic_read(&efip->efi_refcount) > 0); 53 if (atomic_dec_and_test(&efip->efi_refcount)) { 54 xfs_trans_ail_remove(&efip->efi_item, SHUTDOWN_LOG_IO_ERROR); 55 xfs_efi_item_free(efip); 56 } 57 } 58 59 /* 60 * This returns the number of iovecs needed to log the given efi item. 61 * We only need 1 iovec for an efi item. It just logs the efi_log_format 62 * structure. 63 */ 64 static inline int 65 xfs_efi_item_sizeof( 66 struct xfs_efi_log_item *efip) 67 { 68 return sizeof(struct xfs_efi_log_format) + 69 (efip->efi_format.efi_nextents - 1) * sizeof(xfs_extent_t); 70 } 71 72 STATIC void 73 xfs_efi_item_size( 74 struct xfs_log_item *lip, 75 int *nvecs, 76 int *nbytes) 77 { 78 *nvecs += 1; 79 *nbytes += xfs_efi_item_sizeof(EFI_ITEM(lip)); 80 } 81 82 /* 83 * This is called to fill in the vector of log iovecs for the 84 * given efi log item. We use only 1 iovec, and we point that 85 * at the efi_log_format structure embedded in the efi item. 86 * It is at this point that we assert that all of the extent 87 * slots in the efi item have been filled. 88 */ 89 STATIC void 90 xfs_efi_item_format( 91 struct xfs_log_item *lip, 92 struct xfs_log_vec *lv) 93 { 94 struct xfs_efi_log_item *efip = EFI_ITEM(lip); 95 struct xfs_log_iovec *vecp = NULL; 96 97 ASSERT(atomic_read(&efip->efi_next_extent) == 98 efip->efi_format.efi_nextents); 99 100 efip->efi_format.efi_type = XFS_LI_EFI; 101 efip->efi_format.efi_size = 1; 102 103 xlog_copy_iovec(lv, &vecp, XLOG_REG_TYPE_EFI_FORMAT, 104 &efip->efi_format, 105 xfs_efi_item_sizeof(efip)); 106 } 107 108 109 /* 110 * Pinning has no meaning for an efi item, so just return. 111 */ 112 STATIC void 113 xfs_efi_item_pin( 114 struct xfs_log_item *lip) 115 { 116 } 117 118 /* 119 * The unpin operation is the last place an EFI is manipulated in the log. It is 120 * either inserted in the AIL or aborted in the event of a log I/O error. In 121 * either case, the EFI transaction has been successfully committed to make it 122 * this far. Therefore, we expect whoever committed the EFI to either construct 123 * and commit the EFD or drop the EFD's reference in the event of error. Simply 124 * drop the log's EFI reference now that the log is done with it. 125 */ 126 STATIC void 127 xfs_efi_item_unpin( 128 struct xfs_log_item *lip, 129 int remove) 130 { 131 struct xfs_efi_log_item *efip = EFI_ITEM(lip); 132 xfs_efi_release(efip); 133 } 134 135 /* 136 * Efi items have no locking or pushing. However, since EFIs are pulled from 137 * the AIL when their corresponding EFDs are committed to disk, their situation 138 * is very similar to being pinned. Return XFS_ITEM_PINNED so that the caller 139 * will eventually flush the log. This should help in getting the EFI out of 140 * the AIL. 141 */ 142 STATIC uint 143 xfs_efi_item_push( 144 struct xfs_log_item *lip, 145 struct list_head *buffer_list) 146 { 147 return XFS_ITEM_PINNED; 148 } 149 150 /* 151 * The EFI has been either committed or aborted if the transaction has been 152 * cancelled. If the transaction was cancelled, an EFD isn't going to be 153 * constructed and thus we free the EFI here directly. 154 */ 155 STATIC void 156 xfs_efi_item_unlock( 157 struct xfs_log_item *lip) 158 { 159 if (test_bit(XFS_LI_ABORTED, &lip->li_flags)) 160 xfs_efi_release(EFI_ITEM(lip)); 161 } 162 163 /* 164 * The EFI is logged only once and cannot be moved in the log, so simply return 165 * the lsn at which it's been logged. 166 */ 167 STATIC xfs_lsn_t 168 xfs_efi_item_committed( 169 struct xfs_log_item *lip, 170 xfs_lsn_t lsn) 171 { 172 return lsn; 173 } 174 175 /* 176 * The EFI dependency tracking op doesn't do squat. It can't because 177 * it doesn't know where the free extent is coming from. The dependency 178 * tracking has to be handled by the "enclosing" metadata object. For 179 * example, for inodes, the inode is locked throughout the extent freeing 180 * so the dependency should be recorded there. 181 */ 182 STATIC void 183 xfs_efi_item_committing( 184 struct xfs_log_item *lip, 185 xfs_lsn_t lsn) 186 { 187 } 188 189 /* 190 * This is the ops vector shared by all efi log items. 191 */ 192 static const struct xfs_item_ops xfs_efi_item_ops = { 193 .iop_size = xfs_efi_item_size, 194 .iop_format = xfs_efi_item_format, 195 .iop_pin = xfs_efi_item_pin, 196 .iop_unpin = xfs_efi_item_unpin, 197 .iop_unlock = xfs_efi_item_unlock, 198 .iop_committed = xfs_efi_item_committed, 199 .iop_push = xfs_efi_item_push, 200 .iop_committing = xfs_efi_item_committing 201 }; 202 203 204 /* 205 * Allocate and initialize an efi item with the given number of extents. 206 */ 207 struct xfs_efi_log_item * 208 xfs_efi_init( 209 struct xfs_mount *mp, 210 uint nextents) 211 212 { 213 struct xfs_efi_log_item *efip; 214 uint size; 215 216 ASSERT(nextents > 0); 217 if (nextents > XFS_EFI_MAX_FAST_EXTENTS) { 218 size = (uint)(sizeof(xfs_efi_log_item_t) + 219 ((nextents - 1) * sizeof(xfs_extent_t))); 220 efip = kmem_zalloc(size, KM_SLEEP); 221 } else { 222 efip = kmem_zone_zalloc(xfs_efi_zone, KM_SLEEP); 223 } 224 225 xfs_log_item_init(mp, &efip->efi_item, XFS_LI_EFI, &xfs_efi_item_ops); 226 efip->efi_format.efi_nextents = nextents; 227 efip->efi_format.efi_id = (uintptr_t)(void *)efip; 228 atomic_set(&efip->efi_next_extent, 0); 229 atomic_set(&efip->efi_refcount, 2); 230 231 return efip; 232 } 233 234 /* 235 * Copy an EFI format buffer from the given buf, and into the destination 236 * EFI format structure. 237 * The given buffer can be in 32 bit or 64 bit form (which has different padding), 238 * one of which will be the native format for this kernel. 239 * It will handle the conversion of formats if necessary. 240 */ 241 int 242 xfs_efi_copy_format(xfs_log_iovec_t *buf, xfs_efi_log_format_t *dst_efi_fmt) 243 { 244 xfs_efi_log_format_t *src_efi_fmt = buf->i_addr; 245 uint i; 246 uint len = sizeof(xfs_efi_log_format_t) + 247 (src_efi_fmt->efi_nextents - 1) * sizeof(xfs_extent_t); 248 uint len32 = sizeof(xfs_efi_log_format_32_t) + 249 (src_efi_fmt->efi_nextents - 1) * sizeof(xfs_extent_32_t); 250 uint len64 = sizeof(xfs_efi_log_format_64_t) + 251 (src_efi_fmt->efi_nextents - 1) * sizeof(xfs_extent_64_t); 252 253 if (buf->i_len == len) { 254 memcpy((char *)dst_efi_fmt, (char*)src_efi_fmt, len); 255 return 0; 256 } else if (buf->i_len == len32) { 257 xfs_efi_log_format_32_t *src_efi_fmt_32 = buf->i_addr; 258 259 dst_efi_fmt->efi_type = src_efi_fmt_32->efi_type; 260 dst_efi_fmt->efi_size = src_efi_fmt_32->efi_size; 261 dst_efi_fmt->efi_nextents = src_efi_fmt_32->efi_nextents; 262 dst_efi_fmt->efi_id = src_efi_fmt_32->efi_id; 263 for (i = 0; i < dst_efi_fmt->efi_nextents; i++) { 264 dst_efi_fmt->efi_extents[i].ext_start = 265 src_efi_fmt_32->efi_extents[i].ext_start; 266 dst_efi_fmt->efi_extents[i].ext_len = 267 src_efi_fmt_32->efi_extents[i].ext_len; 268 } 269 return 0; 270 } else if (buf->i_len == len64) { 271 xfs_efi_log_format_64_t *src_efi_fmt_64 = buf->i_addr; 272 273 dst_efi_fmt->efi_type = src_efi_fmt_64->efi_type; 274 dst_efi_fmt->efi_size = src_efi_fmt_64->efi_size; 275 dst_efi_fmt->efi_nextents = src_efi_fmt_64->efi_nextents; 276 dst_efi_fmt->efi_id = src_efi_fmt_64->efi_id; 277 for (i = 0; i < dst_efi_fmt->efi_nextents; i++) { 278 dst_efi_fmt->efi_extents[i].ext_start = 279 src_efi_fmt_64->efi_extents[i].ext_start; 280 dst_efi_fmt->efi_extents[i].ext_len = 281 src_efi_fmt_64->efi_extents[i].ext_len; 282 } 283 return 0; 284 } 285 return -EFSCORRUPTED; 286 } 287 288 static inline struct xfs_efd_log_item *EFD_ITEM(struct xfs_log_item *lip) 289 { 290 return container_of(lip, struct xfs_efd_log_item, efd_item); 291 } 292 293 STATIC void 294 xfs_efd_item_free(struct xfs_efd_log_item *efdp) 295 { 296 kmem_free(efdp->efd_item.li_lv_shadow); 297 if (efdp->efd_format.efd_nextents > XFS_EFD_MAX_FAST_EXTENTS) 298 kmem_free(efdp); 299 else 300 kmem_zone_free(xfs_efd_zone, efdp); 301 } 302 303 /* 304 * This returns the number of iovecs needed to log the given efd item. 305 * We only need 1 iovec for an efd item. It just logs the efd_log_format 306 * structure. 307 */ 308 static inline int 309 xfs_efd_item_sizeof( 310 struct xfs_efd_log_item *efdp) 311 { 312 return sizeof(xfs_efd_log_format_t) + 313 (efdp->efd_format.efd_nextents - 1) * sizeof(xfs_extent_t); 314 } 315 316 STATIC void 317 xfs_efd_item_size( 318 struct xfs_log_item *lip, 319 int *nvecs, 320 int *nbytes) 321 { 322 *nvecs += 1; 323 *nbytes += xfs_efd_item_sizeof(EFD_ITEM(lip)); 324 } 325 326 /* 327 * This is called to fill in the vector of log iovecs for the 328 * given efd log item. We use only 1 iovec, and we point that 329 * at the efd_log_format structure embedded in the efd item. 330 * It is at this point that we assert that all of the extent 331 * slots in the efd item have been filled. 332 */ 333 STATIC void 334 xfs_efd_item_format( 335 struct xfs_log_item *lip, 336 struct xfs_log_vec *lv) 337 { 338 struct xfs_efd_log_item *efdp = EFD_ITEM(lip); 339 struct xfs_log_iovec *vecp = NULL; 340 341 ASSERT(efdp->efd_next_extent == efdp->efd_format.efd_nextents); 342 343 efdp->efd_format.efd_type = XFS_LI_EFD; 344 efdp->efd_format.efd_size = 1; 345 346 xlog_copy_iovec(lv, &vecp, XLOG_REG_TYPE_EFD_FORMAT, 347 &efdp->efd_format, 348 xfs_efd_item_sizeof(efdp)); 349 } 350 351 /* 352 * Pinning has no meaning for an efd item, so just return. 353 */ 354 STATIC void 355 xfs_efd_item_pin( 356 struct xfs_log_item *lip) 357 { 358 } 359 360 /* 361 * Since pinning has no meaning for an efd item, unpinning does 362 * not either. 363 */ 364 STATIC void 365 xfs_efd_item_unpin( 366 struct xfs_log_item *lip, 367 int remove) 368 { 369 } 370 371 /* 372 * There isn't much you can do to push on an efd item. It is simply stuck 373 * waiting for the log to be flushed to disk. 374 */ 375 STATIC uint 376 xfs_efd_item_push( 377 struct xfs_log_item *lip, 378 struct list_head *buffer_list) 379 { 380 return XFS_ITEM_PINNED; 381 } 382 383 /* 384 * The EFD is either committed or aborted if the transaction is cancelled. If 385 * the transaction is cancelled, drop our reference to the EFI and free the EFD. 386 */ 387 STATIC void 388 xfs_efd_item_unlock( 389 struct xfs_log_item *lip) 390 { 391 struct xfs_efd_log_item *efdp = EFD_ITEM(lip); 392 393 if (test_bit(XFS_LI_ABORTED, &lip->li_flags)) { 394 xfs_efi_release(efdp->efd_efip); 395 xfs_efd_item_free(efdp); 396 } 397 } 398 399 /* 400 * When the efd item is committed to disk, all we need to do is delete our 401 * reference to our partner efi item and then free ourselves. Since we're 402 * freeing ourselves we must return -1 to keep the transaction code from further 403 * referencing this item. 404 */ 405 STATIC xfs_lsn_t 406 xfs_efd_item_committed( 407 struct xfs_log_item *lip, 408 xfs_lsn_t lsn) 409 { 410 struct xfs_efd_log_item *efdp = EFD_ITEM(lip); 411 412 /* 413 * Drop the EFI reference regardless of whether the EFD has been 414 * aborted. Once the EFD transaction is constructed, it is the sole 415 * responsibility of the EFD to release the EFI (even if the EFI is 416 * aborted due to log I/O error). 417 */ 418 xfs_efi_release(efdp->efd_efip); 419 xfs_efd_item_free(efdp); 420 421 return (xfs_lsn_t)-1; 422 } 423 424 /* 425 * The EFD dependency tracking op doesn't do squat. It can't because 426 * it doesn't know where the free extent is coming from. The dependency 427 * tracking has to be handled by the "enclosing" metadata object. For 428 * example, for inodes, the inode is locked throughout the extent freeing 429 * so the dependency should be recorded there. 430 */ 431 STATIC void 432 xfs_efd_item_committing( 433 struct xfs_log_item *lip, 434 xfs_lsn_t lsn) 435 { 436 } 437 438 /* 439 * This is the ops vector shared by all efd log items. 440 */ 441 static const struct xfs_item_ops xfs_efd_item_ops = { 442 .iop_size = xfs_efd_item_size, 443 .iop_format = xfs_efd_item_format, 444 .iop_pin = xfs_efd_item_pin, 445 .iop_unpin = xfs_efd_item_unpin, 446 .iop_unlock = xfs_efd_item_unlock, 447 .iop_committed = xfs_efd_item_committed, 448 .iop_push = xfs_efd_item_push, 449 .iop_committing = xfs_efd_item_committing 450 }; 451 452 /* 453 * Allocate and initialize an efd item with the given number of extents. 454 */ 455 struct xfs_efd_log_item * 456 xfs_efd_init( 457 struct xfs_mount *mp, 458 struct xfs_efi_log_item *efip, 459 uint nextents) 460 461 { 462 struct xfs_efd_log_item *efdp; 463 uint size; 464 465 ASSERT(nextents > 0); 466 if (nextents > XFS_EFD_MAX_FAST_EXTENTS) { 467 size = (uint)(sizeof(xfs_efd_log_item_t) + 468 ((nextents - 1) * sizeof(xfs_extent_t))); 469 efdp = kmem_zalloc(size, KM_SLEEP); 470 } else { 471 efdp = kmem_zone_zalloc(xfs_efd_zone, KM_SLEEP); 472 } 473 474 xfs_log_item_init(mp, &efdp->efd_item, XFS_LI_EFD, &xfs_efd_item_ops); 475 efdp->efd_efip = efip; 476 efdp->efd_format.efd_nextents = nextents; 477 efdp->efd_format.efd_efi_id = efip->efi_format.efi_id; 478 479 return efdp; 480 } 481 482 /* 483 * Process an extent free intent item that was recovered from 484 * the log. We need to free the extents that it describes. 485 */ 486 int 487 xfs_efi_recover( 488 struct xfs_mount *mp, 489 struct xfs_efi_log_item *efip) 490 { 491 struct xfs_efd_log_item *efdp; 492 struct xfs_trans *tp; 493 int i; 494 int error = 0; 495 xfs_extent_t *extp; 496 xfs_fsblock_t startblock_fsb; 497 498 ASSERT(!test_bit(XFS_EFI_RECOVERED, &efip->efi_flags)); 499 500 /* 501 * First check the validity of the extents described by the 502 * EFI. If any are bad, then assume that all are bad and 503 * just toss the EFI. 504 */ 505 for (i = 0; i < efip->efi_format.efi_nextents; i++) { 506 extp = &efip->efi_format.efi_extents[i]; 507 startblock_fsb = XFS_BB_TO_FSB(mp, 508 XFS_FSB_TO_DADDR(mp, extp->ext_start)); 509 if (startblock_fsb == 0 || 510 extp->ext_len == 0 || 511 startblock_fsb >= mp->m_sb.sb_dblocks || 512 extp->ext_len >= mp->m_sb.sb_agblocks) { 513 /* 514 * This will pull the EFI from the AIL and 515 * free the memory associated with it. 516 */ 517 set_bit(XFS_EFI_RECOVERED, &efip->efi_flags); 518 xfs_efi_release(efip); 519 return -EIO; 520 } 521 } 522 523 error = xfs_trans_alloc(mp, &M_RES(mp)->tr_itruncate, 0, 0, 0, &tp); 524 if (error) 525 return error; 526 efdp = xfs_trans_get_efd(tp, efip, efip->efi_format.efi_nextents); 527 528 for (i = 0; i < efip->efi_format.efi_nextents; i++) { 529 extp = &efip->efi_format.efi_extents[i]; 530 error = xfs_trans_free_extent(tp, efdp, extp->ext_start, 531 extp->ext_len, 532 &XFS_RMAP_OINFO_ANY_OWNER, false); 533 if (error) 534 goto abort_error; 535 536 } 537 538 set_bit(XFS_EFI_RECOVERED, &efip->efi_flags); 539 error = xfs_trans_commit(tp); 540 return error; 541 542 abort_error: 543 xfs_trans_cancel(tp); 544 return error; 545 } 546