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_trans.h" 23 #include "xfs_buf_item.h" 24 #include "xfs_sb.h" 25 #include "xfs_ag.h" 26 #include "xfs_mount.h" 27 #include "xfs_trans_priv.h" 28 #include "xfs_extfree_item.h" 29 30 31 kmem_zone_t *xfs_efi_zone; 32 kmem_zone_t *xfs_efd_zone; 33 34 static inline struct xfs_efi_log_item *EFI_ITEM(struct xfs_log_item *lip) 35 { 36 return container_of(lip, struct xfs_efi_log_item, efi_item); 37 } 38 39 void 40 xfs_efi_item_free( 41 struct xfs_efi_log_item *efip) 42 { 43 if (efip->efi_format.efi_nextents > XFS_EFI_MAX_FAST_EXTENTS) 44 kmem_free(efip); 45 else 46 kmem_zone_free(xfs_efi_zone, efip); 47 } 48 49 /* 50 * Freeing the efi requires that we remove it from the AIL if it has already 51 * been placed there. However, the EFI may not yet have been placed in the AIL 52 * when called by xfs_efi_release() from EFD processing due to the ordering of 53 * committed vs unpin operations in bulk insert operations. Hence the 54 * test_and_clear_bit(XFS_EFI_COMMITTED) to ensure only the last caller frees 55 * the EFI. 56 */ 57 STATIC void 58 __xfs_efi_release( 59 struct xfs_efi_log_item *efip) 60 { 61 struct xfs_ail *ailp = efip->efi_item.li_ailp; 62 63 if (!test_and_clear_bit(XFS_EFI_COMMITTED, &efip->efi_flags)) { 64 spin_lock(&ailp->xa_lock); 65 /* xfs_trans_ail_delete() drops the AIL lock. */ 66 xfs_trans_ail_delete(ailp, &efip->efi_item, 67 SHUTDOWN_LOG_IO_ERROR); 68 xfs_efi_item_free(efip); 69 } 70 } 71 72 /* 73 * This returns the number of iovecs needed to log the given efi item. 74 * We only need 1 iovec for an efi item. It just logs the efi_log_format 75 * structure. 76 */ 77 STATIC uint 78 xfs_efi_item_size( 79 struct xfs_log_item *lip) 80 { 81 return 1; 82 } 83 84 /* 85 * This is called to fill in the vector of log iovecs for the 86 * given efi log item. We use only 1 iovec, and we point that 87 * at the efi_log_format structure embedded in the efi item. 88 * It is at this point that we assert that all of the extent 89 * slots in the efi item have been filled. 90 */ 91 STATIC void 92 xfs_efi_item_format( 93 struct xfs_log_item *lip, 94 struct xfs_log_iovec *log_vector) 95 { 96 struct xfs_efi_log_item *efip = EFI_ITEM(lip); 97 uint size; 98 99 ASSERT(atomic_read(&efip->efi_next_extent) == 100 efip->efi_format.efi_nextents); 101 102 efip->efi_format.efi_type = XFS_LI_EFI; 103 104 size = sizeof(xfs_efi_log_format_t); 105 size += (efip->efi_format.efi_nextents - 1) * sizeof(xfs_extent_t); 106 efip->efi_format.efi_size = 1; 107 108 log_vector->i_addr = &efip->efi_format; 109 log_vector->i_len = size; 110 log_vector->i_type = XLOG_REG_TYPE_EFI_FORMAT; 111 ASSERT(size >= sizeof(xfs_efi_log_format_t)); 112 } 113 114 115 /* 116 * Pinning has no meaning for an efi item, so just return. 117 */ 118 STATIC void 119 xfs_efi_item_pin( 120 struct xfs_log_item *lip) 121 { 122 } 123 124 /* 125 * While EFIs cannot really be pinned, the unpin operation is the last place at 126 * which the EFI is manipulated during a transaction. If we are being asked to 127 * remove the EFI it's because the transaction has been cancelled and by 128 * definition that means the EFI cannot be in the AIL so remove it from the 129 * transaction and free it. Otherwise coordinate with xfs_efi_release() (via 130 * XFS_EFI_COMMITTED) to determine who gets to free the EFI. 131 */ 132 STATIC void 133 xfs_efi_item_unpin( 134 struct xfs_log_item *lip, 135 int remove) 136 { 137 struct xfs_efi_log_item *efip = EFI_ITEM(lip); 138 139 if (remove) { 140 ASSERT(!(lip->li_flags & XFS_LI_IN_AIL)); 141 if (lip->li_desc) 142 xfs_trans_del_item(lip); 143 xfs_efi_item_free(efip); 144 return; 145 } 146 __xfs_efi_release(efip); 147 } 148 149 /* 150 * Efi items have no locking or pushing. However, since EFIs are pulled from 151 * the AIL when their corresponding EFDs are committed to disk, their situation 152 * is very similar to being pinned. Return XFS_ITEM_PINNED so that the caller 153 * will eventually flush the log. This should help in getting the EFI out of 154 * the AIL. 155 */ 156 STATIC uint 157 xfs_efi_item_push( 158 struct xfs_log_item *lip, 159 struct list_head *buffer_list) 160 { 161 return XFS_ITEM_PINNED; 162 } 163 164 STATIC void 165 xfs_efi_item_unlock( 166 struct xfs_log_item *lip) 167 { 168 if (lip->li_flags & XFS_LI_ABORTED) 169 xfs_efi_item_free(EFI_ITEM(lip)); 170 } 171 172 /* 173 * The EFI is logged only once and cannot be moved in the log, so simply return 174 * the lsn at which it's been logged. For bulk transaction committed 175 * processing, the EFI may be processed but not yet unpinned prior to the EFD 176 * being processed. Set the XFS_EFI_COMMITTED flag so this case can be detected 177 * when processing the EFD. 178 */ 179 STATIC xfs_lsn_t 180 xfs_efi_item_committed( 181 struct xfs_log_item *lip, 182 xfs_lsn_t lsn) 183 { 184 struct xfs_efi_log_item *efip = EFI_ITEM(lip); 185 186 set_bit(XFS_EFI_COMMITTED, &efip->efi_flags); 187 return lsn; 188 } 189 190 /* 191 * The EFI dependency tracking op doesn't do squat. It can't because 192 * it doesn't know where the free extent is coming from. The dependency 193 * tracking has to be handled by the "enclosing" metadata object. For 194 * example, for inodes, the inode is locked throughout the extent freeing 195 * so the dependency should be recorded there. 196 */ 197 STATIC void 198 xfs_efi_item_committing( 199 struct xfs_log_item *lip, 200 xfs_lsn_t lsn) 201 { 202 } 203 204 /* 205 * This is the ops vector shared by all efi log items. 206 */ 207 static const struct xfs_item_ops xfs_efi_item_ops = { 208 .iop_size = xfs_efi_item_size, 209 .iop_format = xfs_efi_item_format, 210 .iop_pin = xfs_efi_item_pin, 211 .iop_unpin = xfs_efi_item_unpin, 212 .iop_unlock = xfs_efi_item_unlock, 213 .iop_committed = xfs_efi_item_committed, 214 .iop_push = xfs_efi_item_push, 215 .iop_committing = xfs_efi_item_committing 216 }; 217 218 219 /* 220 * Allocate and initialize an efi item with the given number of extents. 221 */ 222 struct xfs_efi_log_item * 223 xfs_efi_init( 224 struct xfs_mount *mp, 225 uint nextents) 226 227 { 228 struct xfs_efi_log_item *efip; 229 uint size; 230 231 ASSERT(nextents > 0); 232 if (nextents > XFS_EFI_MAX_FAST_EXTENTS) { 233 size = (uint)(sizeof(xfs_efi_log_item_t) + 234 ((nextents - 1) * sizeof(xfs_extent_t))); 235 efip = kmem_zalloc(size, KM_SLEEP); 236 } else { 237 efip = kmem_zone_zalloc(xfs_efi_zone, KM_SLEEP); 238 } 239 240 xfs_log_item_init(mp, &efip->efi_item, XFS_LI_EFI, &xfs_efi_item_ops); 241 efip->efi_format.efi_nextents = nextents; 242 efip->efi_format.efi_id = (__psint_t)(void*)efip; 243 atomic_set(&efip->efi_next_extent, 0); 244 245 return efip; 246 } 247 248 /* 249 * Copy an EFI format buffer from the given buf, and into the destination 250 * EFI format structure. 251 * The given buffer can be in 32 bit or 64 bit form (which has different padding), 252 * one of which will be the native format for this kernel. 253 * It will handle the conversion of formats if necessary. 254 */ 255 int 256 xfs_efi_copy_format(xfs_log_iovec_t *buf, xfs_efi_log_format_t *dst_efi_fmt) 257 { 258 xfs_efi_log_format_t *src_efi_fmt = buf->i_addr; 259 uint i; 260 uint len = sizeof(xfs_efi_log_format_t) + 261 (src_efi_fmt->efi_nextents - 1) * sizeof(xfs_extent_t); 262 uint len32 = sizeof(xfs_efi_log_format_32_t) + 263 (src_efi_fmt->efi_nextents - 1) * sizeof(xfs_extent_32_t); 264 uint len64 = sizeof(xfs_efi_log_format_64_t) + 265 (src_efi_fmt->efi_nextents - 1) * sizeof(xfs_extent_64_t); 266 267 if (buf->i_len == len) { 268 memcpy((char *)dst_efi_fmt, (char*)src_efi_fmt, len); 269 return 0; 270 } else if (buf->i_len == len32) { 271 xfs_efi_log_format_32_t *src_efi_fmt_32 = buf->i_addr; 272 273 dst_efi_fmt->efi_type = src_efi_fmt_32->efi_type; 274 dst_efi_fmt->efi_size = src_efi_fmt_32->efi_size; 275 dst_efi_fmt->efi_nextents = src_efi_fmt_32->efi_nextents; 276 dst_efi_fmt->efi_id = src_efi_fmt_32->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_32->efi_extents[i].ext_start; 280 dst_efi_fmt->efi_extents[i].ext_len = 281 src_efi_fmt_32->efi_extents[i].ext_len; 282 } 283 return 0; 284 } else if (buf->i_len == len64) { 285 xfs_efi_log_format_64_t *src_efi_fmt_64 = buf->i_addr; 286 287 dst_efi_fmt->efi_type = src_efi_fmt_64->efi_type; 288 dst_efi_fmt->efi_size = src_efi_fmt_64->efi_size; 289 dst_efi_fmt->efi_nextents = src_efi_fmt_64->efi_nextents; 290 dst_efi_fmt->efi_id = src_efi_fmt_64->efi_id; 291 for (i = 0; i < dst_efi_fmt->efi_nextents; i++) { 292 dst_efi_fmt->efi_extents[i].ext_start = 293 src_efi_fmt_64->efi_extents[i].ext_start; 294 dst_efi_fmt->efi_extents[i].ext_len = 295 src_efi_fmt_64->efi_extents[i].ext_len; 296 } 297 return 0; 298 } 299 return EFSCORRUPTED; 300 } 301 302 /* 303 * This is called by the efd item code below to release references to the given 304 * efi item. Each efd calls this with the number of extents that it has 305 * logged, and when the sum of these reaches the total number of extents logged 306 * by this efi item we can free the efi item. 307 */ 308 void 309 xfs_efi_release(xfs_efi_log_item_t *efip, 310 uint nextents) 311 { 312 ASSERT(atomic_read(&efip->efi_next_extent) >= nextents); 313 if (atomic_sub_and_test(nextents, &efip->efi_next_extent)) 314 __xfs_efi_release(efip); 315 } 316 317 static inline struct xfs_efd_log_item *EFD_ITEM(struct xfs_log_item *lip) 318 { 319 return container_of(lip, struct xfs_efd_log_item, efd_item); 320 } 321 322 STATIC void 323 xfs_efd_item_free(struct xfs_efd_log_item *efdp) 324 { 325 if (efdp->efd_format.efd_nextents > XFS_EFD_MAX_FAST_EXTENTS) 326 kmem_free(efdp); 327 else 328 kmem_zone_free(xfs_efd_zone, efdp); 329 } 330 331 /* 332 * This returns the number of iovecs needed to log the given efd item. 333 * We only need 1 iovec for an efd item. It just logs the efd_log_format 334 * structure. 335 */ 336 STATIC uint 337 xfs_efd_item_size( 338 struct xfs_log_item *lip) 339 { 340 return 1; 341 } 342 343 /* 344 * This is called to fill in the vector of log iovecs for the 345 * given efd log item. We use only 1 iovec, and we point that 346 * at the efd_log_format structure embedded in the efd item. 347 * It is at this point that we assert that all of the extent 348 * slots in the efd item have been filled. 349 */ 350 STATIC void 351 xfs_efd_item_format( 352 struct xfs_log_item *lip, 353 struct xfs_log_iovec *log_vector) 354 { 355 struct xfs_efd_log_item *efdp = EFD_ITEM(lip); 356 uint size; 357 358 ASSERT(efdp->efd_next_extent == efdp->efd_format.efd_nextents); 359 360 efdp->efd_format.efd_type = XFS_LI_EFD; 361 362 size = sizeof(xfs_efd_log_format_t); 363 size += (efdp->efd_format.efd_nextents - 1) * sizeof(xfs_extent_t); 364 efdp->efd_format.efd_size = 1; 365 366 log_vector->i_addr = &efdp->efd_format; 367 log_vector->i_len = size; 368 log_vector->i_type = XLOG_REG_TYPE_EFD_FORMAT; 369 ASSERT(size >= sizeof(xfs_efd_log_format_t)); 370 } 371 372 /* 373 * Pinning has no meaning for an efd item, so just return. 374 */ 375 STATIC void 376 xfs_efd_item_pin( 377 struct xfs_log_item *lip) 378 { 379 } 380 381 /* 382 * Since pinning has no meaning for an efd item, unpinning does 383 * not either. 384 */ 385 STATIC void 386 xfs_efd_item_unpin( 387 struct xfs_log_item *lip, 388 int remove) 389 { 390 } 391 392 /* 393 * There isn't much you can do to push on an efd item. It is simply stuck 394 * waiting for the log to be flushed to disk. 395 */ 396 STATIC uint 397 xfs_efd_item_push( 398 struct xfs_log_item *lip, 399 struct list_head *buffer_list) 400 { 401 return XFS_ITEM_PINNED; 402 } 403 404 STATIC void 405 xfs_efd_item_unlock( 406 struct xfs_log_item *lip) 407 { 408 if (lip->li_flags & XFS_LI_ABORTED) 409 xfs_efd_item_free(EFD_ITEM(lip)); 410 } 411 412 /* 413 * When the efd item is committed to disk, all we need to do 414 * is delete our reference to our partner efi item and then 415 * free ourselves. Since we're freeing ourselves we must 416 * return -1 to keep the transaction code from further referencing 417 * this item. 418 */ 419 STATIC xfs_lsn_t 420 xfs_efd_item_committed( 421 struct xfs_log_item *lip, 422 xfs_lsn_t lsn) 423 { 424 struct xfs_efd_log_item *efdp = EFD_ITEM(lip); 425 426 /* 427 * If we got a log I/O error, it's always the case that the LR with the 428 * EFI got unpinned and freed before the EFD got aborted. 429 */ 430 if (!(lip->li_flags & XFS_LI_ABORTED)) 431 xfs_efi_release(efdp->efd_efip, efdp->efd_format.efd_nextents); 432 433 xfs_efd_item_free(efdp); 434 return (xfs_lsn_t)-1; 435 } 436 437 /* 438 * The EFD dependency tracking op doesn't do squat. It can't because 439 * it doesn't know where the free extent is coming from. The dependency 440 * tracking has to be handled by the "enclosing" metadata object. For 441 * example, for inodes, the inode is locked throughout the extent freeing 442 * so the dependency should be recorded there. 443 */ 444 STATIC void 445 xfs_efd_item_committing( 446 struct xfs_log_item *lip, 447 xfs_lsn_t lsn) 448 { 449 } 450 451 /* 452 * This is the ops vector shared by all efd log items. 453 */ 454 static const struct xfs_item_ops xfs_efd_item_ops = { 455 .iop_size = xfs_efd_item_size, 456 .iop_format = xfs_efd_item_format, 457 .iop_pin = xfs_efd_item_pin, 458 .iop_unpin = xfs_efd_item_unpin, 459 .iop_unlock = xfs_efd_item_unlock, 460 .iop_committed = xfs_efd_item_committed, 461 .iop_push = xfs_efd_item_push, 462 .iop_committing = xfs_efd_item_committing 463 }; 464 465 /* 466 * Allocate and initialize an efd item with the given number of extents. 467 */ 468 struct xfs_efd_log_item * 469 xfs_efd_init( 470 struct xfs_mount *mp, 471 struct xfs_efi_log_item *efip, 472 uint nextents) 473 474 { 475 struct xfs_efd_log_item *efdp; 476 uint size; 477 478 ASSERT(nextents > 0); 479 if (nextents > XFS_EFD_MAX_FAST_EXTENTS) { 480 size = (uint)(sizeof(xfs_efd_log_item_t) + 481 ((nextents - 1) * sizeof(xfs_extent_t))); 482 efdp = kmem_zalloc(size, KM_SLEEP); 483 } else { 484 efdp = kmem_zone_zalloc(xfs_efd_zone, KM_SLEEP); 485 } 486 487 xfs_log_item_init(mp, &efdp->efd_item, XFS_LI_EFD, &xfs_efd_item_ops); 488 efdp->efd_efip = efip; 489 efdp->efd_format.efd_nextents = nextents; 490 efdp->efd_format.efd_efi_id = efip->efi_format.efi_id; 491 492 return efdp; 493 } 494