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