• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3  * Copyright (C) 2016 Oracle.  All Rights Reserved.
4  * Author: Darrick J. Wong <darrick.wong@oracle.com>
5  */
6 #include "xfs.h"
7 #include "xfs_fs.h"
8 #include "xfs_format.h"
9 #include "xfs_log_format.h"
10 #include "xfs_trans_resv.h"
11 #include "xfs_bit.h"
12 #include "xfs_shared.h"
13 #include "xfs_mount.h"
14 #include "xfs_defer.h"
15 #include "xfs_inode.h"
16 #include "xfs_trans.h"
17 #include "xfs_trans_priv.h"
18 #include "xfs_bmap_item.h"
19 #include "xfs_log.h"
20 #include "xfs_bmap.h"
21 #include "xfs_icache.h"
22 #include "xfs_bmap_btree.h"
23 #include "xfs_trans_space.h"
24 #include "xfs_error.h"
25 #include "xfs_quota.h"
26 
27 kmem_zone_t	*xfs_bui_zone;
28 kmem_zone_t	*xfs_bud_zone;
29 
BUI_ITEM(struct xfs_log_item * lip)30 static inline struct xfs_bui_log_item *BUI_ITEM(struct xfs_log_item *lip)
31 {
32 	return container_of(lip, struct xfs_bui_log_item, bui_item);
33 }
34 
35 void
xfs_bui_item_free(struct xfs_bui_log_item * buip)36 xfs_bui_item_free(
37 	struct xfs_bui_log_item	*buip)
38 {
39 	kmem_zone_free(xfs_bui_zone, buip);
40 }
41 
42 /*
43  * Freeing the BUI requires that we remove it from the AIL if it has already
44  * been placed there. However, the BUI may not yet have been placed in the AIL
45  * when called by xfs_bui_release() from BUD processing due to the ordering of
46  * committed vs unpin operations in bulk insert operations. Hence the reference
47  * count to ensure only the last caller frees the BUI.
48  */
49 void
xfs_bui_release(struct xfs_bui_log_item * buip)50 xfs_bui_release(
51 	struct xfs_bui_log_item	*buip)
52 {
53 	ASSERT(atomic_read(&buip->bui_refcount) > 0);
54 	if (atomic_dec_and_test(&buip->bui_refcount)) {
55 		xfs_trans_ail_remove(&buip->bui_item, SHUTDOWN_LOG_IO_ERROR);
56 		xfs_bui_item_free(buip);
57 	}
58 }
59 
60 
61 STATIC void
xfs_bui_item_size(struct xfs_log_item * lip,int * nvecs,int * nbytes)62 xfs_bui_item_size(
63 	struct xfs_log_item	*lip,
64 	int			*nvecs,
65 	int			*nbytes)
66 {
67 	struct xfs_bui_log_item	*buip = BUI_ITEM(lip);
68 
69 	*nvecs += 1;
70 	*nbytes += xfs_bui_log_format_sizeof(buip->bui_format.bui_nextents);
71 }
72 
73 /*
74  * This is called to fill in the vector of log iovecs for the
75  * given bui log item. We use only 1 iovec, and we point that
76  * at the bui_log_format structure embedded in the bui item.
77  * It is at this point that we assert that all of the extent
78  * slots in the bui item have been filled.
79  */
80 STATIC void
xfs_bui_item_format(struct xfs_log_item * lip,struct xfs_log_vec * lv)81 xfs_bui_item_format(
82 	struct xfs_log_item	*lip,
83 	struct xfs_log_vec	*lv)
84 {
85 	struct xfs_bui_log_item	*buip = BUI_ITEM(lip);
86 	struct xfs_log_iovec	*vecp = NULL;
87 
88 	ASSERT(atomic_read(&buip->bui_next_extent) ==
89 			buip->bui_format.bui_nextents);
90 
91 	buip->bui_format.bui_type = XFS_LI_BUI;
92 	buip->bui_format.bui_size = 1;
93 
94 	xlog_copy_iovec(lv, &vecp, XLOG_REG_TYPE_BUI_FORMAT, &buip->bui_format,
95 			xfs_bui_log_format_sizeof(buip->bui_format.bui_nextents));
96 }
97 
98 /*
99  * The unpin operation is the last place an BUI is manipulated in the log. It is
100  * either inserted in the AIL or aborted in the event of a log I/O error. In
101  * either case, the BUI transaction has been successfully committed to make it
102  * this far. Therefore, we expect whoever committed the BUI to either construct
103  * and commit the BUD or drop the BUD's reference in the event of error. Simply
104  * drop the log's BUI reference now that the log is done with it.
105  */
106 STATIC void
xfs_bui_item_unpin(struct xfs_log_item * lip,int remove)107 xfs_bui_item_unpin(
108 	struct xfs_log_item	*lip,
109 	int			remove)
110 {
111 	struct xfs_bui_log_item	*buip = BUI_ITEM(lip);
112 
113 	xfs_bui_release(buip);
114 }
115 
116 /*
117  * The BUI has been either committed or aborted if the transaction has been
118  * cancelled. If the transaction was cancelled, an BUD isn't going to be
119  * constructed and thus we free the BUI here directly.
120  */
121 STATIC void
xfs_bui_item_release(struct xfs_log_item * lip)122 xfs_bui_item_release(
123 	struct xfs_log_item	*lip)
124 {
125 	xfs_bui_release(BUI_ITEM(lip));
126 }
127 
BUD_ITEM(struct xfs_log_item * lip)128 static inline struct xfs_bud_log_item *BUD_ITEM(struct xfs_log_item *lip)
129 {
130 	return container_of(lip, struct xfs_bud_log_item, bud_item);
131 }
132 
133 STATIC void
xfs_bud_item_size(struct xfs_log_item * lip,int * nvecs,int * nbytes)134 xfs_bud_item_size(
135 	struct xfs_log_item	*lip,
136 	int			*nvecs,
137 	int			*nbytes)
138 {
139 	*nvecs += 1;
140 	*nbytes += sizeof(struct xfs_bud_log_format);
141 }
142 
143 /*
144  * This is called to fill in the vector of log iovecs for the
145  * given bud log item. We use only 1 iovec, and we point that
146  * at the bud_log_format structure embedded in the bud item.
147  * It is at this point that we assert that all of the extent
148  * slots in the bud item have been filled.
149  */
150 STATIC void
xfs_bud_item_format(struct xfs_log_item * lip,struct xfs_log_vec * lv)151 xfs_bud_item_format(
152 	struct xfs_log_item	*lip,
153 	struct xfs_log_vec	*lv)
154 {
155 	struct xfs_bud_log_item	*budp = BUD_ITEM(lip);
156 	struct xfs_log_iovec	*vecp = NULL;
157 
158 	budp->bud_format.bud_type = XFS_LI_BUD;
159 	budp->bud_format.bud_size = 1;
160 
161 	xlog_copy_iovec(lv, &vecp, XLOG_REG_TYPE_BUD_FORMAT, &budp->bud_format,
162 			sizeof(struct xfs_bud_log_format));
163 }
164 
165 /*
166  * The BUD is either committed or aborted if the transaction is cancelled. If
167  * the transaction is cancelled, drop our reference to the BUI and free the
168  * BUD.
169  */
170 STATIC void
xfs_bud_item_release(struct xfs_log_item * lip)171 xfs_bud_item_release(
172 	struct xfs_log_item	*lip)
173 {
174 	struct xfs_bud_log_item	*budp = BUD_ITEM(lip);
175 
176 	xfs_bui_release(budp->bud_buip);
177 	kmem_zone_free(xfs_bud_zone, budp);
178 }
179 
180 static const struct xfs_item_ops xfs_bud_item_ops = {
181 	.flags		= XFS_ITEM_RELEASE_WHEN_COMMITTED,
182 	.iop_size	= xfs_bud_item_size,
183 	.iop_format	= xfs_bud_item_format,
184 	.iop_release	= xfs_bud_item_release,
185 };
186 
187 static struct xfs_bud_log_item *
xfs_trans_get_bud(struct xfs_trans * tp,struct xfs_bui_log_item * buip)188 xfs_trans_get_bud(
189 	struct xfs_trans		*tp,
190 	struct xfs_bui_log_item		*buip)
191 {
192 	struct xfs_bud_log_item		*budp;
193 
194 	budp = kmem_zone_zalloc(xfs_bud_zone, 0);
195 	xfs_log_item_init(tp->t_mountp, &budp->bud_item, XFS_LI_BUD,
196 			  &xfs_bud_item_ops);
197 	budp->bud_buip = buip;
198 	budp->bud_format.bud_bui_id = buip->bui_format.bui_id;
199 
200 	xfs_trans_add_item(tp, &budp->bud_item);
201 	return budp;
202 }
203 
204 /*
205  * Finish an bmap update and log it to the BUD. Note that the
206  * transaction is marked dirty regardless of whether the bmap update
207  * succeeds or fails to support the BUI/BUD lifecycle rules.
208  */
209 static int
xfs_trans_log_finish_bmap_update(struct xfs_trans * tp,struct xfs_bud_log_item * budp,enum xfs_bmap_intent_type type,struct xfs_inode * ip,int whichfork,xfs_fileoff_t startoff,xfs_fsblock_t startblock,xfs_filblks_t * blockcount,xfs_exntst_t state)210 xfs_trans_log_finish_bmap_update(
211 	struct xfs_trans		*tp,
212 	struct xfs_bud_log_item		*budp,
213 	enum xfs_bmap_intent_type	type,
214 	struct xfs_inode		*ip,
215 	int				whichfork,
216 	xfs_fileoff_t			startoff,
217 	xfs_fsblock_t			startblock,
218 	xfs_filblks_t			*blockcount,
219 	xfs_exntst_t			state)
220 {
221 	int				error;
222 
223 	error = xfs_bmap_finish_one(tp, ip, type, whichfork, startoff,
224 			startblock, blockcount, state);
225 
226 	/*
227 	 * Mark the transaction dirty, even on error. This ensures the
228 	 * transaction is aborted, which:
229 	 *
230 	 * 1.) releases the BUI and frees the BUD
231 	 * 2.) shuts down the filesystem
232 	 */
233 	tp->t_flags |= XFS_TRANS_DIRTY;
234 	set_bit(XFS_LI_DIRTY, &budp->bud_item.li_flags);
235 
236 	return error;
237 }
238 
239 /* Sort bmap intents by inode. */
240 static int
xfs_bmap_update_diff_items(void * priv,struct list_head * a,struct list_head * b)241 xfs_bmap_update_diff_items(
242 	void				*priv,
243 	struct list_head		*a,
244 	struct list_head		*b)
245 {
246 	struct xfs_bmap_intent		*ba;
247 	struct xfs_bmap_intent		*bb;
248 
249 	ba = container_of(a, struct xfs_bmap_intent, bi_list);
250 	bb = container_of(b, struct xfs_bmap_intent, bi_list);
251 	return ba->bi_owner->i_ino - bb->bi_owner->i_ino;
252 }
253 
254 /* Set the map extent flags for this mapping. */
255 static void
xfs_trans_set_bmap_flags(struct xfs_map_extent * bmap,enum xfs_bmap_intent_type type,int whichfork,xfs_exntst_t state)256 xfs_trans_set_bmap_flags(
257 	struct xfs_map_extent		*bmap,
258 	enum xfs_bmap_intent_type	type,
259 	int				whichfork,
260 	xfs_exntst_t			state)
261 {
262 	bmap->me_flags = 0;
263 	switch (type) {
264 	case XFS_BMAP_MAP:
265 	case XFS_BMAP_UNMAP:
266 		bmap->me_flags = type;
267 		break;
268 	default:
269 		ASSERT(0);
270 	}
271 	if (state == XFS_EXT_UNWRITTEN)
272 		bmap->me_flags |= XFS_BMAP_EXTENT_UNWRITTEN;
273 	if (whichfork == XFS_ATTR_FORK)
274 		bmap->me_flags |= XFS_BMAP_EXTENT_ATTR_FORK;
275 }
276 
277 /* Log bmap updates in the intent item. */
278 STATIC void
xfs_bmap_update_log_item(struct xfs_trans * tp,struct xfs_bui_log_item * buip,struct xfs_bmap_intent * bmap)279 xfs_bmap_update_log_item(
280 	struct xfs_trans		*tp,
281 	struct xfs_bui_log_item		*buip,
282 	struct xfs_bmap_intent		*bmap)
283 {
284 	uint				next_extent;
285 	struct xfs_map_extent		*map;
286 
287 	tp->t_flags |= XFS_TRANS_DIRTY;
288 	set_bit(XFS_LI_DIRTY, &buip->bui_item.li_flags);
289 
290 	/*
291 	 * atomic_inc_return gives us the value after the increment;
292 	 * we want to use it as an array index so we need to subtract 1 from
293 	 * it.
294 	 */
295 	next_extent = atomic_inc_return(&buip->bui_next_extent) - 1;
296 	ASSERT(next_extent < buip->bui_format.bui_nextents);
297 	map = &buip->bui_format.bui_extents[next_extent];
298 	map->me_owner = bmap->bi_owner->i_ino;
299 	map->me_startblock = bmap->bi_bmap.br_startblock;
300 	map->me_startoff = bmap->bi_bmap.br_startoff;
301 	map->me_len = bmap->bi_bmap.br_blockcount;
302 	xfs_trans_set_bmap_flags(map, bmap->bi_type, bmap->bi_whichfork,
303 			bmap->bi_bmap.br_state);
304 }
305 
306 static struct xfs_log_item *
xfs_bmap_update_create_intent(struct xfs_trans * tp,struct list_head * items,unsigned int count,bool sort)307 xfs_bmap_update_create_intent(
308 	struct xfs_trans		*tp,
309 	struct list_head		*items,
310 	unsigned int			count,
311 	bool				sort)
312 {
313 	struct xfs_mount		*mp = tp->t_mountp;
314 	struct xfs_bui_log_item		*buip = xfs_bui_init(mp);
315 	struct xfs_bmap_intent		*bmap;
316 
317 	ASSERT(count == XFS_BUI_MAX_FAST_EXTENTS);
318 
319 	xfs_trans_add_item(tp, &buip->bui_item);
320 	if (sort)
321 		list_sort(mp, items, xfs_bmap_update_diff_items);
322 	list_for_each_entry(bmap, items, bi_list)
323 		xfs_bmap_update_log_item(tp, buip, bmap);
324 	return &buip->bui_item;
325 }
326 
327 /* Get an BUD so we can process all the deferred rmap updates. */
328 STATIC void *
xfs_bmap_update_create_done(struct xfs_trans * tp,struct xfs_log_item * intent,unsigned int count)329 xfs_bmap_update_create_done(
330 	struct xfs_trans		*tp,
331 	struct xfs_log_item		*intent,
332 	unsigned int			count)
333 {
334 	return xfs_trans_get_bud(tp, BUI_ITEM(intent));
335 }
336 
337 /* Process a deferred rmap update. */
338 STATIC int
xfs_bmap_update_finish_item(struct xfs_trans * tp,struct list_head * item,void * done_item,void ** state)339 xfs_bmap_update_finish_item(
340 	struct xfs_trans		*tp,
341 	struct list_head		*item,
342 	void				*done_item,
343 	void				**state)
344 {
345 	struct xfs_bmap_intent		*bmap;
346 	xfs_filblks_t			count;
347 	int				error;
348 
349 	bmap = container_of(item, struct xfs_bmap_intent, bi_list);
350 	count = bmap->bi_bmap.br_blockcount;
351 	error = xfs_trans_log_finish_bmap_update(tp, done_item,
352 			bmap->bi_type,
353 			bmap->bi_owner, bmap->bi_whichfork,
354 			bmap->bi_bmap.br_startoff,
355 			bmap->bi_bmap.br_startblock,
356 			&count,
357 			bmap->bi_bmap.br_state);
358 	if (!error && count > 0) {
359 		ASSERT(bmap->bi_type == XFS_BMAP_UNMAP);
360 		bmap->bi_bmap.br_blockcount = count;
361 		return -EAGAIN;
362 	}
363 	kmem_free(bmap);
364 	return error;
365 }
366 
367 /* Abort all pending BUIs. */
368 STATIC void
xfs_bmap_update_abort_intent(struct xfs_log_item * intent)369 xfs_bmap_update_abort_intent(
370 	struct xfs_log_item		*intent)
371 {
372 	xfs_bui_release(BUI_ITEM(intent));
373 }
374 
375 /* Cancel a deferred rmap update. */
376 STATIC void
xfs_bmap_update_cancel_item(struct list_head * item)377 xfs_bmap_update_cancel_item(
378 	struct list_head		*item)
379 {
380 	struct xfs_bmap_intent		*bmap;
381 
382 	bmap = container_of(item, struct xfs_bmap_intent, bi_list);
383 	kmem_free(bmap);
384 }
385 
386 const struct xfs_defer_op_type xfs_bmap_update_defer_type = {
387 	.max_items	= XFS_BUI_MAX_FAST_EXTENTS,
388 	.create_intent	= xfs_bmap_update_create_intent,
389 	.abort_intent	= xfs_bmap_update_abort_intent,
390 	.create_done	= xfs_bmap_update_create_done,
391 	.finish_item	= xfs_bmap_update_finish_item,
392 	.cancel_item	= xfs_bmap_update_cancel_item,
393 };
394 
395 /*
396  * Process a bmap update intent item that was recovered from the log.
397  * We need to update some inode's bmbt.
398  */
399 int
xfs_bui_recover(struct xfs_bui_log_item * buip,struct list_head * capture_list)400 xfs_bui_recover(
401 	struct xfs_bui_log_item		*buip,
402 	struct list_head		*capture_list)
403 {
404 	int				error = 0;
405 	unsigned int			bui_type;
406 	struct xfs_map_extent		*bmap;
407 	xfs_fsblock_t			startblock_fsb;
408 	xfs_fsblock_t			inode_fsb;
409 	xfs_filblks_t			count;
410 	struct xfs_bud_log_item		*budp;
411 	int				whichfork;
412 	xfs_exntst_t			state;
413 	struct xfs_trans		*tp;
414 	struct xfs_inode		*ip = NULL;
415 	struct xfs_bmbt_irec		irec;
416 	struct xfs_mount		*mp = buip->bui_item.li_mountp;
417 
418 	ASSERT(!test_bit(XFS_BUI_RECOVERED, &buip->bui_flags));
419 
420 	/* Only one mapping operation per BUI... */
421 	if (buip->bui_format.bui_nextents != XFS_BUI_MAX_FAST_EXTENTS) {
422 		set_bit(XFS_BUI_RECOVERED, &buip->bui_flags);
423 		xfs_bui_release(buip);
424 		return -EFSCORRUPTED;
425 	}
426 
427 	/*
428 	 * First check the validity of the extent described by the
429 	 * BUI.  If anything is bad, then toss the BUI.
430 	 */
431 	bmap = &buip->bui_format.bui_extents[0];
432 	startblock_fsb = XFS_BB_TO_FSB(mp,
433 			   XFS_FSB_TO_DADDR(mp, bmap->me_startblock));
434 	inode_fsb = XFS_BB_TO_FSB(mp, XFS_FSB_TO_DADDR(mp,
435 			XFS_INO_TO_FSB(mp, bmap->me_owner)));
436 	state = (bmap->me_flags & XFS_BMAP_EXTENT_UNWRITTEN) ?
437 			XFS_EXT_UNWRITTEN : XFS_EXT_NORM;
438 	whichfork = (bmap->me_flags & XFS_BMAP_EXTENT_ATTR_FORK) ?
439 			XFS_ATTR_FORK : XFS_DATA_FORK;
440 	bui_type = bmap->me_flags & XFS_BMAP_EXTENT_TYPE_MASK;
441 	switch (bui_type) {
442 	case XFS_BMAP_MAP:
443 	case XFS_BMAP_UNMAP:
444 		break;
445 	default:
446 		return -EFSCORRUPTED;
447 	}
448 	if (startblock_fsb == 0 ||
449 	    bmap->me_len == 0 ||
450 	    inode_fsb == 0 ||
451 	    startblock_fsb >= mp->m_sb.sb_dblocks ||
452 	    bmap->me_len >= mp->m_sb.sb_agblocks ||
453 	    inode_fsb >= mp->m_sb.sb_dblocks ||
454 	    (bmap->me_flags & ~XFS_BMAP_EXTENT_FLAGS)) {
455 		/*
456 		 * This will pull the BUI from the AIL and
457 		 * free the memory associated with it.
458 		 */
459 		set_bit(XFS_BUI_RECOVERED, &buip->bui_flags);
460 		xfs_bui_release(buip);
461 		return -EFSCORRUPTED;
462 	}
463 
464 	/* Grab the inode. */
465 	error = xfs_iget(mp, NULL, bmap->me_owner, 0, 0, &ip);
466 	if (error)
467 		return error;
468 
469 	error = xfs_qm_dqattach(ip);
470 	if (error)
471 		goto err_rele;
472 
473 	if (VFS_I(ip)->i_nlink == 0)
474 		xfs_iflags_set(ip, XFS_IRECOVERY);
475 
476 	/* Allocate transaction and do the work. */
477 	error = xfs_trans_alloc(mp, &M_RES(mp)->tr_itruncate,
478 			XFS_EXTENTADD_SPACE_RES(mp, XFS_DATA_FORK), 0, 0, &tp);
479 	if (error)
480 		goto err_rele;
481 
482 	budp = xfs_trans_get_bud(tp, buip);
483 	xfs_ilock(ip, XFS_ILOCK_EXCL);
484 	xfs_trans_ijoin(tp, ip, 0);
485 
486 	count = bmap->me_len;
487 	error = xfs_trans_log_finish_bmap_update(tp, budp, bui_type, ip,
488 			whichfork, bmap->me_startoff, bmap->me_startblock,
489 			&count, state);
490 	if (error)
491 		goto err_cancel;
492 
493 	if (count > 0) {
494 		ASSERT(bui_type == XFS_BMAP_UNMAP);
495 		irec.br_startblock = bmap->me_startblock;
496 		irec.br_blockcount = count;
497 		irec.br_startoff = bmap->me_startoff;
498 		irec.br_state = state;
499 		xfs_bmap_unmap_extent(tp, ip, &irec);
500 	}
501 
502 	set_bit(XFS_BUI_RECOVERED, &buip->bui_flags);
503 	/*
504 	 * Commit transaction, which frees the transaction and saves the inode
505 	 * for later replay activities.
506 	 */
507 	error = xfs_defer_ops_capture_and_commit(tp, ip, capture_list);
508 	if (error)
509 		goto err_unlock;
510 
511 	xfs_iunlock(ip, XFS_ILOCK_EXCL);
512 	xfs_irele(ip);
513 	return 0;
514 
515 err_cancel:
516 	xfs_trans_cancel(tp);
517 err_unlock:
518 	xfs_iunlock(ip, XFS_ILOCK_EXCL);
519 err_rele:
520 	xfs_irele(ip);
521 	return error;
522 }
523 
524 /* Relog an intent item to push the log tail forward. */
525 static struct xfs_log_item *
xfs_bui_item_relog(struct xfs_log_item * intent,struct xfs_trans * tp)526 xfs_bui_item_relog(
527 	struct xfs_log_item		*intent,
528 	struct xfs_trans		*tp)
529 {
530 	struct xfs_bud_log_item		*budp;
531 	struct xfs_bui_log_item		*buip;
532 	struct xfs_map_extent		*extp;
533 	unsigned int			count;
534 
535 	count = BUI_ITEM(intent)->bui_format.bui_nextents;
536 	extp = BUI_ITEM(intent)->bui_format.bui_extents;
537 
538 	tp->t_flags |= XFS_TRANS_DIRTY;
539 	budp = xfs_trans_get_bud(tp, BUI_ITEM(intent));
540 	set_bit(XFS_LI_DIRTY, &budp->bud_item.li_flags);
541 
542 	buip = xfs_bui_init(tp->t_mountp);
543 	memcpy(buip->bui_format.bui_extents, extp, count * sizeof(*extp));
544 	atomic_set(&buip->bui_next_extent, count);
545 	xfs_trans_add_item(tp, &buip->bui_item);
546 	set_bit(XFS_LI_DIRTY, &buip->bui_item.li_flags);
547 	return &buip->bui_item;
548 }
549 
550 static const struct xfs_item_ops xfs_bui_item_ops = {
551 	.iop_size	= xfs_bui_item_size,
552 	.iop_format	= xfs_bui_item_format,
553 	.iop_unpin	= xfs_bui_item_unpin,
554 	.iop_release	= xfs_bui_item_release,
555 	.iop_relog	= xfs_bui_item_relog,
556 };
557 
558 /*
559  * Allocate and initialize an bui item with the given number of extents.
560  */
561 struct xfs_bui_log_item *
xfs_bui_init(struct xfs_mount * mp)562 xfs_bui_init(
563 	struct xfs_mount		*mp)
564 
565 {
566 	struct xfs_bui_log_item		*buip;
567 
568 	buip = kmem_zone_zalloc(xfs_bui_zone, 0);
569 
570 	xfs_log_item_init(mp, &buip->bui_item, XFS_LI_BUI, &xfs_bui_item_ops);
571 	buip->bui_format.bui_nextents = XFS_BUI_MAX_FAST_EXTENTS;
572 	buip->bui_format.bui_id = (uintptr_t)(void *)buip;
573 	atomic_set(&buip->bui_next_extent, 0);
574 	atomic_set(&buip->bui_refcount, 2);
575 
576 	return buip;
577 }
578