fs/xfs/xfs_extfree_item.c

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