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