1 /* 2 * Copyright (c) 2000-2001,2005 Silicon Graphics, Inc. 3 * All Rights Reserved. 4 * 5 * This program is free software; you can redistribute it and/or 6 * modify it under the terms of the GNU General Public License as 7 * published by the Free Software Foundation. 8 * 9 * This program is distributed in the hope that it would be useful, 10 * but WITHOUT ANY WARRANTY; without even the implied warranty of 11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 * GNU General Public License for more details. 13 * 14 * You should have received a copy of the GNU General Public License 15 * along with this program; if not, write the Free Software Foundation, 16 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA 17 */ 18 #include "xfs.h" 19 #include "xfs_fs.h" 20 #include "xfs_types.h" 21 #include "xfs_log.h" 22 #include "xfs_inum.h" 23 #include "xfs_trans.h" 24 #include "xfs_buf_item.h" 25 #include "xfs_sb.h" 26 #include "xfs_ag.h" 27 #include "xfs_dmapi.h" 28 #include "xfs_mount.h" 29 #include "xfs_trans_priv.h" 30 #include "xfs_extfree_item.h" 31 32 33 kmem_zone_t *xfs_efi_zone; 34 kmem_zone_t *xfs_efd_zone; 35 36 STATIC void xfs_efi_item_unlock(xfs_efi_log_item_t *); 37 38 void 39 xfs_efi_item_free(xfs_efi_log_item_t *efip) 40 { 41 int nexts = efip->efi_format.efi_nextents; 42 43 if (nexts > XFS_EFI_MAX_FAST_EXTENTS) { 44 kmem_free(efip); 45 } else { 46 kmem_zone_free(xfs_efi_zone, efip); 47 } 48 } 49 50 /* 51 * This returns the number of iovecs needed to log the given efi item. 52 * We only need 1 iovec for an efi item. It just logs the efi_log_format 53 * structure. 54 */ 55 /*ARGSUSED*/ 56 STATIC uint 57 xfs_efi_item_size(xfs_efi_log_item_t *efip) 58 { 59 return 1; 60 } 61 62 /* 63 * This is called to fill in the vector of log iovecs for the 64 * given efi log item. We use only 1 iovec, and we point that 65 * at the efi_log_format structure embedded in the efi item. 66 * It is at this point that we assert that all of the extent 67 * slots in the efi item have been filled. 68 */ 69 STATIC void 70 xfs_efi_item_format(xfs_efi_log_item_t *efip, 71 xfs_log_iovec_t *log_vector) 72 { 73 uint size; 74 75 ASSERT(efip->efi_next_extent == efip->efi_format.efi_nextents); 76 77 efip->efi_format.efi_type = XFS_LI_EFI; 78 79 size = sizeof(xfs_efi_log_format_t); 80 size += (efip->efi_format.efi_nextents - 1) * sizeof(xfs_extent_t); 81 efip->efi_format.efi_size = 1; 82 83 log_vector->i_addr = (xfs_caddr_t)&(efip->efi_format); 84 log_vector->i_len = size; 85 log_vector->i_type = XLOG_REG_TYPE_EFI_FORMAT; 86 ASSERT(size >= sizeof(xfs_efi_log_format_t)); 87 } 88 89 90 /* 91 * Pinning has no meaning for an efi item, so just return. 92 */ 93 /*ARGSUSED*/ 94 STATIC void 95 xfs_efi_item_pin(xfs_efi_log_item_t *efip) 96 { 97 return; 98 } 99 100 101 /* 102 * While EFIs cannot really be pinned, the unpin operation is the 103 * last place at which the EFI is manipulated during a transaction. 104 * Here we coordinate with xfs_efi_cancel() to determine who gets to 105 * free the EFI. 106 */ 107 /*ARGSUSED*/ 108 STATIC void 109 xfs_efi_item_unpin(xfs_efi_log_item_t *efip) 110 { 111 struct xfs_ail *ailp = efip->efi_item.li_ailp; 112 113 spin_lock(&ailp->xa_lock); 114 if (efip->efi_flags & XFS_EFI_CANCELED) { 115 /* xfs_trans_ail_delete() drops the AIL lock. */ 116 xfs_trans_ail_delete(ailp, (xfs_log_item_t *)efip); 117 xfs_efi_item_free(efip); 118 } else { 119 efip->efi_flags |= XFS_EFI_COMMITTED; 120 spin_unlock(&ailp->xa_lock); 121 } 122 } 123 124 /* 125 * like unpin only we have to also clear the xaction descriptor 126 * pointing the log item if we free the item. This routine duplicates 127 * unpin because efi_flags is protected by the AIL lock. Freeing 128 * the descriptor and then calling unpin would force us to drop the AIL 129 * lock which would open up a race condition. 130 */ 131 STATIC void 132 xfs_efi_item_unpin_remove(xfs_efi_log_item_t *efip, xfs_trans_t *tp) 133 { 134 struct xfs_ail *ailp = efip->efi_item.li_ailp; 135 xfs_log_item_desc_t *lidp; 136 137 spin_lock(&ailp->xa_lock); 138 if (efip->efi_flags & XFS_EFI_CANCELED) { 139 /* 140 * free the xaction descriptor pointing to this item 141 */ 142 lidp = xfs_trans_find_item(tp, (xfs_log_item_t *) efip); 143 xfs_trans_free_item(tp, lidp); 144 145 /* xfs_trans_ail_delete() drops the AIL lock. */ 146 xfs_trans_ail_delete(ailp, (xfs_log_item_t *)efip); 147 xfs_efi_item_free(efip); 148 } else { 149 efip->efi_flags |= XFS_EFI_COMMITTED; 150 spin_unlock(&ailp->xa_lock); 151 } 152 } 153 154 /* 155 * Efi items have no locking or pushing. However, since EFIs are 156 * pulled from the AIL when their corresponding EFDs are committed 157 * to disk, their situation is very similar to being pinned. Return 158 * XFS_ITEM_PINNED so that the caller will eventually flush the log. 159 * This should help in getting the EFI out of the AIL. 160 */ 161 /*ARGSUSED*/ 162 STATIC uint 163 xfs_efi_item_trylock(xfs_efi_log_item_t *efip) 164 { 165 return XFS_ITEM_PINNED; 166 } 167 168 /* 169 * Efi items have no locking, so just return. 170 */ 171 /*ARGSUSED*/ 172 STATIC void 173 xfs_efi_item_unlock(xfs_efi_log_item_t *efip) 174 { 175 if (efip->efi_item.li_flags & XFS_LI_ABORTED) 176 xfs_efi_item_free(efip); 177 return; 178 } 179 180 /* 181 * The EFI is logged only once and cannot be moved in the log, so 182 * simply return the lsn at which it's been logged. The canceled 183 * flag is not paid any attention here. Checking for that is delayed 184 * until the EFI is unpinned. 185 */ 186 /*ARGSUSED*/ 187 STATIC xfs_lsn_t 188 xfs_efi_item_committed(xfs_efi_log_item_t *efip, xfs_lsn_t lsn) 189 { 190 return lsn; 191 } 192 193 /* 194 * There isn't much you can do to push on an efi item. It is simply 195 * stuck waiting for all of its corresponding efd items to be 196 * committed to disk. 197 */ 198 /*ARGSUSED*/ 199 STATIC void 200 xfs_efi_item_push(xfs_efi_log_item_t *efip) 201 { 202 return; 203 } 204 205 /* 206 * The EFI dependency tracking op doesn't do squat. It can't because 207 * it doesn't know where the free extent is coming from. The dependency 208 * tracking has to be handled by the "enclosing" metadata object. For 209 * example, for inodes, the inode is locked throughout the extent freeing 210 * so the dependency should be recorded there. 211 */ 212 /*ARGSUSED*/ 213 STATIC void 214 xfs_efi_item_committing(xfs_efi_log_item_t *efip, xfs_lsn_t lsn) 215 { 216 return; 217 } 218 219 /* 220 * This is the ops vector shared by all efi log items. 221 */ 222 static struct xfs_item_ops xfs_efi_item_ops = { 223 .iop_size = (uint(*)(xfs_log_item_t*))xfs_efi_item_size, 224 .iop_format = (void(*)(xfs_log_item_t*, xfs_log_iovec_t*)) 225 xfs_efi_item_format, 226 .iop_pin = (void(*)(xfs_log_item_t*))xfs_efi_item_pin, 227 .iop_unpin = (void(*)(xfs_log_item_t*))xfs_efi_item_unpin, 228 .iop_unpin_remove = (void(*)(xfs_log_item_t*, xfs_trans_t *)) 229 xfs_efi_item_unpin_remove, 230 .iop_trylock = (uint(*)(xfs_log_item_t*))xfs_efi_item_trylock, 231 .iop_unlock = (void(*)(xfs_log_item_t*))xfs_efi_item_unlock, 232 .iop_committed = (xfs_lsn_t(*)(xfs_log_item_t*, xfs_lsn_t)) 233 xfs_efi_item_committed, 234 .iop_push = (void(*)(xfs_log_item_t*))xfs_efi_item_push, 235 .iop_pushbuf = NULL, 236 .iop_committing = (void(*)(xfs_log_item_t*, xfs_lsn_t)) 237 xfs_efi_item_committing 238 }; 239 240 241 /* 242 * Allocate and initialize an efi item with the given number of extents. 243 */ 244 xfs_efi_log_item_t * 245 xfs_efi_init(xfs_mount_t *mp, 246 uint nextents) 247 248 { 249 xfs_efi_log_item_t *efip; 250 uint size; 251 252 ASSERT(nextents > 0); 253 if (nextents > XFS_EFI_MAX_FAST_EXTENTS) { 254 size = (uint)(sizeof(xfs_efi_log_item_t) + 255 ((nextents - 1) * sizeof(xfs_extent_t))); 256 efip = (xfs_efi_log_item_t*)kmem_zalloc(size, KM_SLEEP); 257 } else { 258 efip = (xfs_efi_log_item_t*)kmem_zone_zalloc(xfs_efi_zone, 259 KM_SLEEP); 260 } 261 262 xfs_log_item_init(mp, &efip->efi_item, XFS_LI_EFI, &xfs_efi_item_ops); 263 efip->efi_format.efi_nextents = nextents; 264 efip->efi_format.efi_id = (__psint_t)(void*)efip; 265 266 return (efip); 267 } 268 269 /* 270 * Copy an EFI format buffer from the given buf, and into the destination 271 * EFI format structure. 272 * The given buffer can be in 32 bit or 64 bit form (which has different padding), 273 * one of which will be the native format for this kernel. 274 * It will handle the conversion of formats if necessary. 275 */ 276 int 277 xfs_efi_copy_format(xfs_log_iovec_t *buf, xfs_efi_log_format_t *dst_efi_fmt) 278 { 279 xfs_efi_log_format_t *src_efi_fmt = (xfs_efi_log_format_t *)buf->i_addr; 280 uint i; 281 uint len = sizeof(xfs_efi_log_format_t) + 282 (src_efi_fmt->efi_nextents - 1) * sizeof(xfs_extent_t); 283 uint len32 = sizeof(xfs_efi_log_format_32_t) + 284 (src_efi_fmt->efi_nextents - 1) * sizeof(xfs_extent_32_t); 285 uint len64 = sizeof(xfs_efi_log_format_64_t) + 286 (src_efi_fmt->efi_nextents - 1) * sizeof(xfs_extent_64_t); 287 288 if (buf->i_len == len) { 289 memcpy((char *)dst_efi_fmt, (char*)src_efi_fmt, len); 290 return 0; 291 } else if (buf->i_len == len32) { 292 xfs_efi_log_format_32_t *src_efi_fmt_32 = 293 (xfs_efi_log_format_32_t *)buf->i_addr; 294 295 dst_efi_fmt->efi_type = src_efi_fmt_32->efi_type; 296 dst_efi_fmt->efi_size = src_efi_fmt_32->efi_size; 297 dst_efi_fmt->efi_nextents = src_efi_fmt_32->efi_nextents; 298 dst_efi_fmt->efi_id = src_efi_fmt_32->efi_id; 299 for (i = 0; i < dst_efi_fmt->efi_nextents; i++) { 300 dst_efi_fmt->efi_extents[i].ext_start = 301 src_efi_fmt_32->efi_extents[i].ext_start; 302 dst_efi_fmt->efi_extents[i].ext_len = 303 src_efi_fmt_32->efi_extents[i].ext_len; 304 } 305 return 0; 306 } else if (buf->i_len == len64) { 307 xfs_efi_log_format_64_t *src_efi_fmt_64 = 308 (xfs_efi_log_format_64_t *)buf->i_addr; 309 310 dst_efi_fmt->efi_type = src_efi_fmt_64->efi_type; 311 dst_efi_fmt->efi_size = src_efi_fmt_64->efi_size; 312 dst_efi_fmt->efi_nextents = src_efi_fmt_64->efi_nextents; 313 dst_efi_fmt->efi_id = src_efi_fmt_64->efi_id; 314 for (i = 0; i < dst_efi_fmt->efi_nextents; i++) { 315 dst_efi_fmt->efi_extents[i].ext_start = 316 src_efi_fmt_64->efi_extents[i].ext_start; 317 dst_efi_fmt->efi_extents[i].ext_len = 318 src_efi_fmt_64->efi_extents[i].ext_len; 319 } 320 return 0; 321 } 322 return EFSCORRUPTED; 323 } 324 325 /* 326 * This is called by the efd item code below to release references to 327 * the given efi item. Each efd calls this with the number of 328 * extents that it has logged, and when the sum of these reaches 329 * the total number of extents logged by this efi item we can free 330 * the efi item. 331 * 332 * Freeing the efi item requires that we remove it from the AIL. 333 * We'll use the AIL lock to protect our counters as well as 334 * the removal from the AIL. 335 */ 336 void 337 xfs_efi_release(xfs_efi_log_item_t *efip, 338 uint nextents) 339 { 340 struct xfs_ail *ailp = efip->efi_item.li_ailp; 341 int extents_left; 342 343 ASSERT(efip->efi_next_extent > 0); 344 ASSERT(efip->efi_flags & XFS_EFI_COMMITTED); 345 346 spin_lock(&ailp->xa_lock); 347 ASSERT(efip->efi_next_extent >= nextents); 348 efip->efi_next_extent -= nextents; 349 extents_left = efip->efi_next_extent; 350 if (extents_left == 0) { 351 /* xfs_trans_ail_delete() drops the AIL lock. */ 352 xfs_trans_ail_delete(ailp, (xfs_log_item_t *)efip); 353 xfs_efi_item_free(efip); 354 } else { 355 spin_unlock(&ailp->xa_lock); 356 } 357 } 358 359 STATIC void 360 xfs_efd_item_free(xfs_efd_log_item_t *efdp) 361 { 362 int nexts = efdp->efd_format.efd_nextents; 363 364 if (nexts > XFS_EFD_MAX_FAST_EXTENTS) { 365 kmem_free(efdp); 366 } else { 367 kmem_zone_free(xfs_efd_zone, efdp); 368 } 369 } 370 371 /* 372 * This returns the number of iovecs needed to log the given efd item. 373 * We only need 1 iovec for an efd item. It just logs the efd_log_format 374 * structure. 375 */ 376 /*ARGSUSED*/ 377 STATIC uint 378 xfs_efd_item_size(xfs_efd_log_item_t *efdp) 379 { 380 return 1; 381 } 382 383 /* 384 * This is called to fill in the vector of log iovecs for the 385 * given efd log item. We use only 1 iovec, and we point that 386 * at the efd_log_format structure embedded in the efd item. 387 * It is at this point that we assert that all of the extent 388 * slots in the efd item have been filled. 389 */ 390 STATIC void 391 xfs_efd_item_format(xfs_efd_log_item_t *efdp, 392 xfs_log_iovec_t *log_vector) 393 { 394 uint size; 395 396 ASSERT(efdp->efd_next_extent == efdp->efd_format.efd_nextents); 397 398 efdp->efd_format.efd_type = XFS_LI_EFD; 399 400 size = sizeof(xfs_efd_log_format_t); 401 size += (efdp->efd_format.efd_nextents - 1) * sizeof(xfs_extent_t); 402 efdp->efd_format.efd_size = 1; 403 404 log_vector->i_addr = (xfs_caddr_t)&(efdp->efd_format); 405 log_vector->i_len = size; 406 log_vector->i_type = XLOG_REG_TYPE_EFD_FORMAT; 407 ASSERT(size >= sizeof(xfs_efd_log_format_t)); 408 } 409 410 411 /* 412 * Pinning has no meaning for an efd item, so just return. 413 */ 414 /*ARGSUSED*/ 415 STATIC void 416 xfs_efd_item_pin(xfs_efd_log_item_t *efdp) 417 { 418 return; 419 } 420 421 422 /* 423 * Since pinning has no meaning for an efd item, unpinning does 424 * not either. 425 */ 426 /*ARGSUSED*/ 427 STATIC void 428 xfs_efd_item_unpin(xfs_efd_log_item_t *efdp) 429 { 430 return; 431 } 432 433 /*ARGSUSED*/ 434 STATIC void 435 xfs_efd_item_unpin_remove(xfs_efd_log_item_t *efdp, xfs_trans_t *tp) 436 { 437 return; 438 } 439 440 /* 441 * Efd items have no locking, so just return success. 442 */ 443 /*ARGSUSED*/ 444 STATIC uint 445 xfs_efd_item_trylock(xfs_efd_log_item_t *efdp) 446 { 447 return XFS_ITEM_LOCKED; 448 } 449 450 /* 451 * Efd items have no locking or pushing, so return failure 452 * so that the caller doesn't bother with us. 453 */ 454 /*ARGSUSED*/ 455 STATIC void 456 xfs_efd_item_unlock(xfs_efd_log_item_t *efdp) 457 { 458 if (efdp->efd_item.li_flags & XFS_LI_ABORTED) 459 xfs_efd_item_free(efdp); 460 return; 461 } 462 463 /* 464 * When the efd item is committed to disk, all we need to do 465 * is delete our reference to our partner efi item and then 466 * free ourselves. Since we're freeing ourselves we must 467 * return -1 to keep the transaction code from further referencing 468 * this item. 469 */ 470 /*ARGSUSED*/ 471 STATIC xfs_lsn_t 472 xfs_efd_item_committed(xfs_efd_log_item_t *efdp, xfs_lsn_t lsn) 473 { 474 /* 475 * If we got a log I/O error, it's always the case that the LR with the 476 * EFI got unpinned and freed before the EFD got aborted. 477 */ 478 if ((efdp->efd_item.li_flags & XFS_LI_ABORTED) == 0) 479 xfs_efi_release(efdp->efd_efip, efdp->efd_format.efd_nextents); 480 481 xfs_efd_item_free(efdp); 482 return (xfs_lsn_t)-1; 483 } 484 485 /* 486 * There isn't much you can do to push on an efd item. It is simply 487 * stuck waiting for the log to be flushed to disk. 488 */ 489 /*ARGSUSED*/ 490 STATIC void 491 xfs_efd_item_push(xfs_efd_log_item_t *efdp) 492 { 493 return; 494 } 495 496 /* 497 * The EFD dependency tracking op doesn't do squat. It can't because 498 * it doesn't know where the free extent is coming from. The dependency 499 * tracking has to be handled by the "enclosing" metadata object. For 500 * example, for inodes, the inode is locked throughout the extent freeing 501 * so the dependency should be recorded there. 502 */ 503 /*ARGSUSED*/ 504 STATIC void 505 xfs_efd_item_committing(xfs_efd_log_item_t *efip, xfs_lsn_t lsn) 506 { 507 return; 508 } 509 510 /* 511 * This is the ops vector shared by all efd log items. 512 */ 513 static struct xfs_item_ops xfs_efd_item_ops = { 514 .iop_size = (uint(*)(xfs_log_item_t*))xfs_efd_item_size, 515 .iop_format = (void(*)(xfs_log_item_t*, xfs_log_iovec_t*)) 516 xfs_efd_item_format, 517 .iop_pin = (void(*)(xfs_log_item_t*))xfs_efd_item_pin, 518 .iop_unpin = (void(*)(xfs_log_item_t*))xfs_efd_item_unpin, 519 .iop_unpin_remove = (void(*)(xfs_log_item_t*, xfs_trans_t*)) 520 xfs_efd_item_unpin_remove, 521 .iop_trylock = (uint(*)(xfs_log_item_t*))xfs_efd_item_trylock, 522 .iop_unlock = (void(*)(xfs_log_item_t*))xfs_efd_item_unlock, 523 .iop_committed = (xfs_lsn_t(*)(xfs_log_item_t*, xfs_lsn_t)) 524 xfs_efd_item_committed, 525 .iop_push = (void(*)(xfs_log_item_t*))xfs_efd_item_push, 526 .iop_pushbuf = NULL, 527 .iop_committing = (void(*)(xfs_log_item_t*, xfs_lsn_t)) 528 xfs_efd_item_committing 529 }; 530 531 532 /* 533 * Allocate and initialize an efd item with the given number of extents. 534 */ 535 xfs_efd_log_item_t * 536 xfs_efd_init(xfs_mount_t *mp, 537 xfs_efi_log_item_t *efip, 538 uint nextents) 539 540 { 541 xfs_efd_log_item_t *efdp; 542 uint size; 543 544 ASSERT(nextents > 0); 545 if (nextents > XFS_EFD_MAX_FAST_EXTENTS) { 546 size = (uint)(sizeof(xfs_efd_log_item_t) + 547 ((nextents - 1) * sizeof(xfs_extent_t))); 548 efdp = (xfs_efd_log_item_t*)kmem_zalloc(size, KM_SLEEP); 549 } else { 550 efdp = (xfs_efd_log_item_t*)kmem_zone_zalloc(xfs_efd_zone, 551 KM_SLEEP); 552 } 553 554 xfs_log_item_init(mp, &efdp->efd_item, XFS_LI_EFD, &xfs_efd_item_ops); 555 efdp->efd_efip = efip; 556 efdp->efd_format.efd_nextents = nextents; 557 efdp->efd_format.efd_efi_id = efip->efi_format.efi_id; 558 559 return (efdp); 560 } 561