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