blob: f19282ec8549c13d21cd5a8469ffd9b507c3a8c4 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Nathan Scott7b718762005-11-02 14:58:39 +11002 * Copyright (c) 2000-2001,2005 Silicon Graphics, Inc.
3 * All Rights Reserved.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004 *
Nathan Scott7b718762005-11-02 14:58:39 +11005 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License as
Linus Torvalds1da177e2005-04-16 15:20:36 -07007 * published by the Free Software Foundation.
8 *
Nathan Scott7b718762005-11-02 14:58:39 +11009 * 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.
Linus Torvalds1da177e2005-04-16 15:20:36 -070013 *
Nathan Scott7b718762005-11-02 14:58:39 +110014 * 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
Linus Torvalds1da177e2005-04-16 15:20:36 -070017 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070018#include "xfs.h"
Nathan Scotta844f452005-11-02 14:38:42 +110019#include "xfs_fs.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070020#include "xfs_types.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070021#include "xfs_log.h"
Nathan Scotta844f452005-11-02 14:38:42 +110022#include "xfs_inum.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070023#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
33kmem_zone_t *xfs_efi_zone;
34kmem_zone_t *xfs_efd_zone;
35
36STATIC void xfs_efi_item_unlock(xfs_efi_log_item_t *);
37STATIC void xfs_efi_item_abort(xfs_efi_log_item_t *);
38STATIC void xfs_efd_item_abort(xfs_efd_log_item_t *);
39
40
Christoph Hellwig7d795ca2005-06-21 15:41:19 +100041void
42xfs_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}
Linus Torvalds1da177e2005-04-16 15:20:36 -070053
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*/
60STATIC uint
61xfs_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 */
73STATIC void
74xfs_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;
Tim Shimmin7e9c6392005-09-02 16:42:05 +100089 XLOG_VEC_SET_TYPE(log_vector, XLOG_REG_TYPE_EFI_FORMAT);
Linus Torvalds1da177e2005-04-16 15:20:36 -070090 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*/
98STATIC void
99xfs_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*/
112STATIC void
113xfs_efi_item_unpin(xfs_efi_log_item_t *efip, int stale)
114{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115 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);
Christoph Hellwig7d795ca2005-06-21 15:41:19 +1000125 xfs_efi_item_free(efip);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700126 } else {
127 efip->efi_flags |= XFS_EFI_COMMITTED;
128 AIL_UNLOCK(mp, s);
129 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130}
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 */
139STATIC void
140xfs_efi_item_unpin_remove(xfs_efi_log_item_t *efip, xfs_trans_t *tp)
141{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142 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);
Christoph Hellwig7d795ca2005-06-21 15:41:19 +1000159 xfs_efi_item_free(efip);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160 } else {
161 efip->efi_flags |= XFS_EFI_COMMITTED;
162 AIL_UNLOCK(mp, s);
163 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164}
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*/
174STATIC uint
175xfs_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*/
184STATIC void
185xfs_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*/
199STATIC xfs_lsn_t
200xfs_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 */
211STATIC void
212xfs_efi_item_abort(xfs_efi_log_item_t *efip)
213{
Christoph Hellwig7d795ca2005-06-21 15:41:19 +1000214 xfs_efi_item_free(efip);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215}
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*/
223STATIC void
224xfs_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*/
237STATIC void
238xfs_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 */
Christoph Hellwigba0f32d2005-06-21 15:36:52 +1000246STATIC struct xfs_item_ops xfs_efi_item_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247 .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 */
269xfs_efi_log_item_t *
270xfs_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 * This is called by the efd item code below to release references to
298 * the given efi item. Each efd calls this with the number of
299 * extents that it has logged, and when the sum of these reaches
300 * the total number of extents logged by this efi item we can free
301 * the efi item.
302 *
303 * Freeing the efi item requires that we remove it from the AIL.
304 * We'll use the AIL lock to protect our counters as well as
305 * the removal from the AIL.
306 */
307void
308xfs_efi_release(xfs_efi_log_item_t *efip,
309 uint nextents)
310{
311 xfs_mount_t *mp;
312 int extents_left;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313 SPLDECL(s);
314
315 mp = efip->efi_item.li_mountp;
316 ASSERT(efip->efi_next_extent > 0);
317 ASSERT(efip->efi_flags & XFS_EFI_COMMITTED);
318
319 AIL_LOCK(mp, s);
320 ASSERT(efip->efi_next_extent >= nextents);
321 efip->efi_next_extent -= nextents;
322 extents_left = efip->efi_next_extent;
323 if (extents_left == 0) {
324 /*
325 * xfs_trans_delete_ail() drops the AIL lock.
326 */
327 xfs_trans_delete_ail(mp, (xfs_log_item_t *)efip, s);
Christoph Hellwig7d795ca2005-06-21 15:41:19 +1000328 xfs_efi_item_free(efip);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329 } else {
330 AIL_UNLOCK(mp, s);
331 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700332}
333
334/*
335 * This is called when the transaction that should be committing the
336 * EFD corresponding to the given EFI is aborted. The committed and
337 * canceled flags are used to coordinate the freeing of the EFI and
338 * the references by the transaction that committed it.
339 */
340STATIC void
341xfs_efi_cancel(
342 xfs_efi_log_item_t *efip)
343{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344 xfs_mount_t *mp;
345 SPLDECL(s);
346
347 mp = efip->efi_item.li_mountp;
348 AIL_LOCK(mp, s);
349 if (efip->efi_flags & XFS_EFI_COMMITTED) {
350 /*
351 * xfs_trans_delete_ail() drops the AIL lock.
352 */
353 xfs_trans_delete_ail(mp, (xfs_log_item_t *)efip, s);
Christoph Hellwig7d795ca2005-06-21 15:41:19 +1000354 xfs_efi_item_free(efip);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355 } else {
356 efip->efi_flags |= XFS_EFI_CANCELED;
357 AIL_UNLOCK(mp, s);
358 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359}
360
Christoph Hellwig7d795ca2005-06-21 15:41:19 +1000361STATIC void
362xfs_efd_item_free(xfs_efd_log_item_t *efdp)
363{
364 int nexts = efdp->efd_format.efd_nextents;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365
Christoph Hellwig7d795ca2005-06-21 15:41:19 +1000366 if (nexts > XFS_EFD_MAX_FAST_EXTENTS) {
367 kmem_free(efdp, sizeof(xfs_efd_log_item_t) +
368 (nexts - 1) * sizeof(xfs_extent_t));
369 } else {
370 kmem_zone_free(xfs_efd_zone, efdp);
371 }
372}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700373
374/*
375 * This returns the number of iovecs needed to log the given efd item.
376 * We only need 1 iovec for an efd item. It just logs the efd_log_format
377 * structure.
378 */
379/*ARGSUSED*/
380STATIC uint
381xfs_efd_item_size(xfs_efd_log_item_t *efdp)
382{
383 return 1;
384}
385
386/*
387 * This is called to fill in the vector of log iovecs for the
388 * given efd log item. We use only 1 iovec, and we point that
389 * at the efd_log_format structure embedded in the efd item.
390 * It is at this point that we assert that all of the extent
391 * slots in the efd item have been filled.
392 */
393STATIC void
394xfs_efd_item_format(xfs_efd_log_item_t *efdp,
395 xfs_log_iovec_t *log_vector)
396{
397 uint size;
398
399 ASSERT(efdp->efd_next_extent == efdp->efd_format.efd_nextents);
400
401 efdp->efd_format.efd_type = XFS_LI_EFD;
402
403 size = sizeof(xfs_efd_log_format_t);
404 size += (efdp->efd_format.efd_nextents - 1) * sizeof(xfs_extent_t);
405 efdp->efd_format.efd_size = 1;
406
407 log_vector->i_addr = (xfs_caddr_t)&(efdp->efd_format);
408 log_vector->i_len = size;
Tim Shimmin7e9c6392005-09-02 16:42:05 +1000409 XLOG_VEC_SET_TYPE(log_vector, XLOG_REG_TYPE_EFD_FORMAT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410 ASSERT(size >= sizeof(xfs_efd_log_format_t));
411}
412
413
414/*
415 * Pinning has no meaning for an efd item, so just return.
416 */
417/*ARGSUSED*/
418STATIC void
419xfs_efd_item_pin(xfs_efd_log_item_t *efdp)
420{
421 return;
422}
423
424
425/*
426 * Since pinning has no meaning for an efd item, unpinning does
427 * not either.
428 */
429/*ARGSUSED*/
430STATIC void
431xfs_efd_item_unpin(xfs_efd_log_item_t *efdp, int stale)
432{
433 return;
434}
435
436/*ARGSUSED*/
437STATIC void
438xfs_efd_item_unpin_remove(xfs_efd_log_item_t *efdp, xfs_trans_t *tp)
439{
440 return;
441}
442
443/*
444 * Efd items have no locking, so just return success.
445 */
446/*ARGSUSED*/
447STATIC uint
448xfs_efd_item_trylock(xfs_efd_log_item_t *efdp)
449{
450 return XFS_ITEM_LOCKED;
451}
452
453/*
454 * Efd items have no locking or pushing, so return failure
455 * so that the caller doesn't bother with us.
456 */
457/*ARGSUSED*/
458STATIC void
459xfs_efd_item_unlock(xfs_efd_log_item_t *efdp)
460{
461 if (efdp->efd_item.li_flags & XFS_LI_ABORTED)
462 xfs_efd_item_abort(efdp);
463 return;
464}
465
466/*
467 * When the efd item is committed to disk, all we need to do
468 * is delete our reference to our partner efi item and then
469 * free ourselves. Since we're freeing ourselves we must
470 * return -1 to keep the transaction code from further referencing
471 * this item.
472 */
473/*ARGSUSED*/
474STATIC xfs_lsn_t
475xfs_efd_item_committed(xfs_efd_log_item_t *efdp, xfs_lsn_t lsn)
476{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700477 /*
478 * If we got a log I/O error, it's always the case that the LR with the
479 * EFI got unpinned and freed before the EFD got aborted.
480 */
481 if ((efdp->efd_item.li_flags & XFS_LI_ABORTED) == 0)
482 xfs_efi_release(efdp->efd_efip, efdp->efd_format.efd_nextents);
483
Christoph Hellwig7d795ca2005-06-21 15:41:19 +1000484 xfs_efd_item_free(efdp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700485 return (xfs_lsn_t)-1;
486}
487
488/*
489 * The transaction of which this EFD is a part has been aborted.
490 * Inform its companion EFI of this fact and then clean up after
491 * ourselves. No need to clean up the slot for the item in the
492 * transaction. That was done by the unpin code which is called
493 * prior to this routine in the abort/fs-shutdown path.
494 */
495STATIC void
496xfs_efd_item_abort(xfs_efd_log_item_t *efdp)
497{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700498 /*
499 * If we got a log I/O error, it's always the case that the LR with the
500 * EFI got unpinned and freed before the EFD got aborted. So don't
501 * reference the EFI at all in that case.
502 */
503 if ((efdp->efd_item.li_flags & XFS_LI_ABORTED) == 0)
504 xfs_efi_cancel(efdp->efd_efip);
505
Christoph Hellwig7d795ca2005-06-21 15:41:19 +1000506 xfs_efd_item_free(efdp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507}
508
509/*
510 * There isn't much you can do to push on an efd item. It is simply
511 * stuck waiting for the log to be flushed to disk.
512 */
513/*ARGSUSED*/
514STATIC void
515xfs_efd_item_push(xfs_efd_log_item_t *efdp)
516{
517 return;
518}
519
520/*
521 * The EFD dependency tracking op doesn't do squat. It can't because
522 * it doesn't know where the free extent is coming from. The dependency
523 * tracking has to be handled by the "enclosing" metadata object. For
524 * example, for inodes, the inode is locked throughout the extent freeing
525 * so the dependency should be recorded there.
526 */
527/*ARGSUSED*/
528STATIC void
529xfs_efd_item_committing(xfs_efd_log_item_t *efip, xfs_lsn_t lsn)
530{
531 return;
532}
533
534/*
535 * This is the ops vector shared by all efd log items.
536 */
Christoph Hellwigba0f32d2005-06-21 15:36:52 +1000537STATIC struct xfs_item_ops xfs_efd_item_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538 .iop_size = (uint(*)(xfs_log_item_t*))xfs_efd_item_size,
539 .iop_format = (void(*)(xfs_log_item_t*, xfs_log_iovec_t*))
540 xfs_efd_item_format,
541 .iop_pin = (void(*)(xfs_log_item_t*))xfs_efd_item_pin,
542 .iop_unpin = (void(*)(xfs_log_item_t*, int))xfs_efd_item_unpin,
543 .iop_unpin_remove = (void(*)(xfs_log_item_t*, xfs_trans_t*))
544 xfs_efd_item_unpin_remove,
545 .iop_trylock = (uint(*)(xfs_log_item_t*))xfs_efd_item_trylock,
546 .iop_unlock = (void(*)(xfs_log_item_t*))xfs_efd_item_unlock,
547 .iop_committed = (xfs_lsn_t(*)(xfs_log_item_t*, xfs_lsn_t))
548 xfs_efd_item_committed,
549 .iop_push = (void(*)(xfs_log_item_t*))xfs_efd_item_push,
550 .iop_abort = (void(*)(xfs_log_item_t*))xfs_efd_item_abort,
551 .iop_pushbuf = NULL,
552 .iop_committing = (void(*)(xfs_log_item_t*, xfs_lsn_t))
553 xfs_efd_item_committing
554};
555
556
557/*
558 * Allocate and initialize an efd item with the given number of extents.
559 */
560xfs_efd_log_item_t *
561xfs_efd_init(xfs_mount_t *mp,
562 xfs_efi_log_item_t *efip,
563 uint nextents)
564
565{
566 xfs_efd_log_item_t *efdp;
567 uint size;
568
569 ASSERT(nextents > 0);
570 if (nextents > XFS_EFD_MAX_FAST_EXTENTS) {
571 size = (uint)(sizeof(xfs_efd_log_item_t) +
572 ((nextents - 1) * sizeof(xfs_extent_t)));
573 efdp = (xfs_efd_log_item_t*)kmem_zalloc(size, KM_SLEEP);
574 } else {
575 efdp = (xfs_efd_log_item_t*)kmem_zone_zalloc(xfs_efd_zone,
576 KM_SLEEP);
577 }
578
579 efdp->efd_item.li_type = XFS_LI_EFD;
580 efdp->efd_item.li_ops = &xfs_efd_item_ops;
581 efdp->efd_item.li_mountp = mp;
582 efdp->efd_efip = efip;
583 efdp->efd_format.efd_nextents = nextents;
584 efdp->efd_format.efd_efi_id = efip->efi_format.efi_id;
585
586 return (efdp);
587}