xref: /openbmc/linux/fs/xfs/xfs_bmap_item.c (revision abe9af53)
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_log_priv.h"
26 #include "xfs_log_recover.h"
27 #include "xfs_quota.h"
28 
29 kmem_zone_t	*xfs_bui_zone;
30 kmem_zone_t	*xfs_bud_zone;
31 
32 static const struct xfs_item_ops xfs_bui_item_ops;
33 
34 static inline struct xfs_bui_log_item *BUI_ITEM(struct xfs_log_item *lip)
35 {
36 	return container_of(lip, struct xfs_bui_log_item, bui_item);
37 }
38 
39 STATIC void
40 xfs_bui_item_free(
41 	struct xfs_bui_log_item	*buip)
42 {
43 	kmem_cache_free(xfs_bui_zone, buip);
44 }
45 
46 /*
47  * Freeing the BUI requires that we remove it from the AIL if it has already
48  * been placed there. However, the BUI may not yet have been placed in the AIL
49  * when called by xfs_bui_release() from BUD processing due to the ordering of
50  * committed vs unpin operations in bulk insert operations. Hence the reference
51  * count to ensure only the last caller frees the BUI.
52  */
53 STATIC void
54 xfs_bui_release(
55 	struct xfs_bui_log_item	*buip)
56 {
57 	ASSERT(atomic_read(&buip->bui_refcount) > 0);
58 	if (atomic_dec_and_test(&buip->bui_refcount)) {
59 		xfs_trans_ail_delete(&buip->bui_item, SHUTDOWN_LOG_IO_ERROR);
60 		xfs_bui_item_free(buip);
61 	}
62 }
63 
64 
65 STATIC void
66 xfs_bui_item_size(
67 	struct xfs_log_item	*lip,
68 	int			*nvecs,
69 	int			*nbytes)
70 {
71 	struct xfs_bui_log_item	*buip = BUI_ITEM(lip);
72 
73 	*nvecs += 1;
74 	*nbytes += xfs_bui_log_format_sizeof(buip->bui_format.bui_nextents);
75 }
76 
77 /*
78  * This is called to fill in the vector of log iovecs for the
79  * given bui log item. We use only 1 iovec, and we point that
80  * at the bui_log_format structure embedded in the bui item.
81  * It is at this point that we assert that all of the extent
82  * slots in the bui item have been filled.
83  */
84 STATIC void
85 xfs_bui_item_format(
86 	struct xfs_log_item	*lip,
87 	struct xfs_log_vec	*lv)
88 {
89 	struct xfs_bui_log_item	*buip = BUI_ITEM(lip);
90 	struct xfs_log_iovec	*vecp = NULL;
91 
92 	ASSERT(atomic_read(&buip->bui_next_extent) ==
93 			buip->bui_format.bui_nextents);
94 
95 	buip->bui_format.bui_type = XFS_LI_BUI;
96 	buip->bui_format.bui_size = 1;
97 
98 	xlog_copy_iovec(lv, &vecp, XLOG_REG_TYPE_BUI_FORMAT, &buip->bui_format,
99 			xfs_bui_log_format_sizeof(buip->bui_format.bui_nextents));
100 }
101 
102 /*
103  * The unpin operation is the last place an BUI is manipulated in the log. It is
104  * either inserted in the AIL or aborted in the event of a log I/O error. In
105  * either case, the BUI transaction has been successfully committed to make it
106  * this far. Therefore, we expect whoever committed the BUI to either construct
107  * and commit the BUD or drop the BUD's reference in the event of error. Simply
108  * drop the log's BUI reference now that the log is done with it.
109  */
110 STATIC void
111 xfs_bui_item_unpin(
112 	struct xfs_log_item	*lip,
113 	int			remove)
114 {
115 	struct xfs_bui_log_item	*buip = BUI_ITEM(lip);
116 
117 	xfs_bui_release(buip);
118 }
119 
120 /*
121  * The BUI has been either committed or aborted if the transaction has been
122  * cancelled. If the transaction was cancelled, an BUD isn't going to be
123  * constructed and thus we free the BUI here directly.
124  */
125 STATIC void
126 xfs_bui_item_release(
127 	struct xfs_log_item	*lip)
128 {
129 	xfs_bui_release(BUI_ITEM(lip));
130 }
131 
132 /*
133  * Allocate and initialize an bui item with the given number of extents.
134  */
135 STATIC struct xfs_bui_log_item *
136 xfs_bui_init(
137 	struct xfs_mount		*mp)
138 
139 {
140 	struct xfs_bui_log_item		*buip;
141 
142 	buip = kmem_cache_zalloc(xfs_bui_zone, GFP_KERNEL | __GFP_NOFAIL);
143 
144 	xfs_log_item_init(mp, &buip->bui_item, XFS_LI_BUI, &xfs_bui_item_ops);
145 	buip->bui_format.bui_nextents = XFS_BUI_MAX_FAST_EXTENTS;
146 	buip->bui_format.bui_id = (uintptr_t)(void *)buip;
147 	atomic_set(&buip->bui_next_extent, 0);
148 	atomic_set(&buip->bui_refcount, 2);
149 
150 	return buip;
151 }
152 
153 static inline struct xfs_bud_log_item *BUD_ITEM(struct xfs_log_item *lip)
154 {
155 	return container_of(lip, struct xfs_bud_log_item, bud_item);
156 }
157 
158 STATIC void
159 xfs_bud_item_size(
160 	struct xfs_log_item	*lip,
161 	int			*nvecs,
162 	int			*nbytes)
163 {
164 	*nvecs += 1;
165 	*nbytes += sizeof(struct xfs_bud_log_format);
166 }
167 
168 /*
169  * This is called to fill in the vector of log iovecs for the
170  * given bud log item. We use only 1 iovec, and we point that
171  * at the bud_log_format structure embedded in the bud item.
172  * It is at this point that we assert that all of the extent
173  * slots in the bud item have been filled.
174  */
175 STATIC void
176 xfs_bud_item_format(
177 	struct xfs_log_item	*lip,
178 	struct xfs_log_vec	*lv)
179 {
180 	struct xfs_bud_log_item	*budp = BUD_ITEM(lip);
181 	struct xfs_log_iovec	*vecp = NULL;
182 
183 	budp->bud_format.bud_type = XFS_LI_BUD;
184 	budp->bud_format.bud_size = 1;
185 
186 	xlog_copy_iovec(lv, &vecp, XLOG_REG_TYPE_BUD_FORMAT, &budp->bud_format,
187 			sizeof(struct xfs_bud_log_format));
188 }
189 
190 /*
191  * The BUD is either committed or aborted if the transaction is cancelled. If
192  * the transaction is cancelled, drop our reference to the BUI and free the
193  * BUD.
194  */
195 STATIC void
196 xfs_bud_item_release(
197 	struct xfs_log_item	*lip)
198 {
199 	struct xfs_bud_log_item	*budp = BUD_ITEM(lip);
200 
201 	xfs_bui_release(budp->bud_buip);
202 	kmem_cache_free(xfs_bud_zone, budp);
203 }
204 
205 static const struct xfs_item_ops xfs_bud_item_ops = {
206 	.flags		= XFS_ITEM_RELEASE_WHEN_COMMITTED,
207 	.iop_size	= xfs_bud_item_size,
208 	.iop_format	= xfs_bud_item_format,
209 	.iop_release	= xfs_bud_item_release,
210 };
211 
212 static struct xfs_bud_log_item *
213 xfs_trans_get_bud(
214 	struct xfs_trans		*tp,
215 	struct xfs_bui_log_item		*buip)
216 {
217 	struct xfs_bud_log_item		*budp;
218 
219 	budp = kmem_cache_zalloc(xfs_bud_zone, GFP_KERNEL | __GFP_NOFAIL);
220 	xfs_log_item_init(tp->t_mountp, &budp->bud_item, XFS_LI_BUD,
221 			  &xfs_bud_item_ops);
222 	budp->bud_buip = buip;
223 	budp->bud_format.bud_bui_id = buip->bui_format.bui_id;
224 
225 	xfs_trans_add_item(tp, &budp->bud_item);
226 	return budp;
227 }
228 
229 /*
230  * Finish an bmap update and log it to the BUD. Note that the
231  * transaction is marked dirty regardless of whether the bmap update
232  * succeeds or fails to support the BUI/BUD lifecycle rules.
233  */
234 static int
235 xfs_trans_log_finish_bmap_update(
236 	struct xfs_trans		*tp,
237 	struct xfs_bud_log_item		*budp,
238 	enum xfs_bmap_intent_type	type,
239 	struct xfs_inode		*ip,
240 	int				whichfork,
241 	xfs_fileoff_t			startoff,
242 	xfs_fsblock_t			startblock,
243 	xfs_filblks_t			*blockcount,
244 	xfs_exntst_t			state)
245 {
246 	int				error;
247 
248 	error = xfs_bmap_finish_one(tp, ip, type, whichfork, startoff,
249 			startblock, blockcount, state);
250 
251 	/*
252 	 * Mark the transaction dirty, even on error. This ensures the
253 	 * transaction is aborted, which:
254 	 *
255 	 * 1.) releases the BUI and frees the BUD
256 	 * 2.) shuts down the filesystem
257 	 */
258 	tp->t_flags |= XFS_TRANS_DIRTY;
259 	set_bit(XFS_LI_DIRTY, &budp->bud_item.li_flags);
260 
261 	return error;
262 }
263 
264 /* Sort bmap intents by inode. */
265 static int
266 xfs_bmap_update_diff_items(
267 	void				*priv,
268 	struct list_head		*a,
269 	struct list_head		*b)
270 {
271 	struct xfs_bmap_intent		*ba;
272 	struct xfs_bmap_intent		*bb;
273 
274 	ba = container_of(a, struct xfs_bmap_intent, bi_list);
275 	bb = container_of(b, struct xfs_bmap_intent, bi_list);
276 	return ba->bi_owner->i_ino - bb->bi_owner->i_ino;
277 }
278 
279 /* Set the map extent flags for this mapping. */
280 static void
281 xfs_trans_set_bmap_flags(
282 	struct xfs_map_extent		*bmap,
283 	enum xfs_bmap_intent_type	type,
284 	int				whichfork,
285 	xfs_exntst_t			state)
286 {
287 	bmap->me_flags = 0;
288 	switch (type) {
289 	case XFS_BMAP_MAP:
290 	case XFS_BMAP_UNMAP:
291 		bmap->me_flags = type;
292 		break;
293 	default:
294 		ASSERT(0);
295 	}
296 	if (state == XFS_EXT_UNWRITTEN)
297 		bmap->me_flags |= XFS_BMAP_EXTENT_UNWRITTEN;
298 	if (whichfork == XFS_ATTR_FORK)
299 		bmap->me_flags |= XFS_BMAP_EXTENT_ATTR_FORK;
300 }
301 
302 /* Log bmap updates in the intent item. */
303 STATIC void
304 xfs_bmap_update_log_item(
305 	struct xfs_trans		*tp,
306 	struct xfs_bui_log_item		*buip,
307 	struct xfs_bmap_intent		*bmap)
308 {
309 	uint				next_extent;
310 	struct xfs_map_extent		*map;
311 
312 	tp->t_flags |= XFS_TRANS_DIRTY;
313 	set_bit(XFS_LI_DIRTY, &buip->bui_item.li_flags);
314 
315 	/*
316 	 * atomic_inc_return gives us the value after the increment;
317 	 * we want to use it as an array index so we need to subtract 1 from
318 	 * it.
319 	 */
320 	next_extent = atomic_inc_return(&buip->bui_next_extent) - 1;
321 	ASSERT(next_extent < buip->bui_format.bui_nextents);
322 	map = &buip->bui_format.bui_extents[next_extent];
323 	map->me_owner = bmap->bi_owner->i_ino;
324 	map->me_startblock = bmap->bi_bmap.br_startblock;
325 	map->me_startoff = bmap->bi_bmap.br_startoff;
326 	map->me_len = bmap->bi_bmap.br_blockcount;
327 	xfs_trans_set_bmap_flags(map, bmap->bi_type, bmap->bi_whichfork,
328 			bmap->bi_bmap.br_state);
329 }
330 
331 static struct xfs_log_item *
332 xfs_bmap_update_create_intent(
333 	struct xfs_trans		*tp,
334 	struct list_head		*items,
335 	unsigned int			count,
336 	bool				sort)
337 {
338 	struct xfs_mount		*mp = tp->t_mountp;
339 	struct xfs_bui_log_item		*buip = xfs_bui_init(mp);
340 	struct xfs_bmap_intent		*bmap;
341 
342 	ASSERT(count == XFS_BUI_MAX_FAST_EXTENTS);
343 
344 	xfs_trans_add_item(tp, &buip->bui_item);
345 	if (sort)
346 		list_sort(mp, items, xfs_bmap_update_diff_items);
347 	list_for_each_entry(bmap, items, bi_list)
348 		xfs_bmap_update_log_item(tp, buip, bmap);
349 	return &buip->bui_item;
350 }
351 
352 /* Get an BUD so we can process all the deferred rmap updates. */
353 static struct xfs_log_item *
354 xfs_bmap_update_create_done(
355 	struct xfs_trans		*tp,
356 	struct xfs_log_item		*intent,
357 	unsigned int			count)
358 {
359 	return &xfs_trans_get_bud(tp, BUI_ITEM(intent))->bud_item;
360 }
361 
362 /* Process a deferred rmap update. */
363 STATIC int
364 xfs_bmap_update_finish_item(
365 	struct xfs_trans		*tp,
366 	struct xfs_log_item		*done,
367 	struct list_head		*item,
368 	struct xfs_btree_cur		**state)
369 {
370 	struct xfs_bmap_intent		*bmap;
371 	xfs_filblks_t			count;
372 	int				error;
373 
374 	bmap = container_of(item, struct xfs_bmap_intent, bi_list);
375 	count = bmap->bi_bmap.br_blockcount;
376 	error = xfs_trans_log_finish_bmap_update(tp, BUD_ITEM(done),
377 			bmap->bi_type,
378 			bmap->bi_owner, bmap->bi_whichfork,
379 			bmap->bi_bmap.br_startoff,
380 			bmap->bi_bmap.br_startblock,
381 			&count,
382 			bmap->bi_bmap.br_state);
383 	if (!error && count > 0) {
384 		ASSERT(bmap->bi_type == XFS_BMAP_UNMAP);
385 		bmap->bi_bmap.br_blockcount = count;
386 		return -EAGAIN;
387 	}
388 	kmem_free(bmap);
389 	return error;
390 }
391 
392 /* Abort all pending BUIs. */
393 STATIC void
394 xfs_bmap_update_abort_intent(
395 	struct xfs_log_item		*intent)
396 {
397 	xfs_bui_release(BUI_ITEM(intent));
398 }
399 
400 /* Cancel a deferred rmap update. */
401 STATIC void
402 xfs_bmap_update_cancel_item(
403 	struct list_head		*item)
404 {
405 	struct xfs_bmap_intent		*bmap;
406 
407 	bmap = container_of(item, struct xfs_bmap_intent, bi_list);
408 	kmem_free(bmap);
409 }
410 
411 const struct xfs_defer_op_type xfs_bmap_update_defer_type = {
412 	.max_items	= XFS_BUI_MAX_FAST_EXTENTS,
413 	.create_intent	= xfs_bmap_update_create_intent,
414 	.abort_intent	= xfs_bmap_update_abort_intent,
415 	.create_done	= xfs_bmap_update_create_done,
416 	.finish_item	= xfs_bmap_update_finish_item,
417 	.cancel_item	= xfs_bmap_update_cancel_item,
418 };
419 
420 /*
421  * Process a bmap update intent item that was recovered from the log.
422  * We need to update some inode's bmbt.
423  */
424 STATIC int
425 xfs_bui_item_recover(
426 	struct xfs_log_item		*lip,
427 	struct list_head		*capture_list)
428 {
429 	struct xfs_bmbt_irec		irec;
430 	struct xfs_bui_log_item		*buip = BUI_ITEM(lip);
431 	struct xfs_trans		*tp;
432 	struct xfs_inode		*ip = NULL;
433 	struct xfs_mount		*mp = lip->li_mountp;
434 	struct xfs_map_extent		*bmap;
435 	struct xfs_bud_log_item		*budp;
436 	xfs_fsblock_t			startblock_fsb;
437 	xfs_fsblock_t			inode_fsb;
438 	xfs_filblks_t			count;
439 	xfs_exntst_t			state;
440 	unsigned int			bui_type;
441 	int				whichfork;
442 	int				error = 0;
443 
444 	/* Only one mapping operation per BUI... */
445 	if (buip->bui_format.bui_nextents != XFS_BUI_MAX_FAST_EXTENTS)
446 		return -EFSCORRUPTED;
447 
448 	/*
449 	 * First check the validity of the extent described by the
450 	 * BUI.  If anything is bad, then toss the BUI.
451 	 */
452 	bmap = &buip->bui_format.bui_extents[0];
453 	startblock_fsb = XFS_BB_TO_FSB(mp,
454 			   XFS_FSB_TO_DADDR(mp, bmap->me_startblock));
455 	inode_fsb = XFS_BB_TO_FSB(mp, XFS_FSB_TO_DADDR(mp,
456 			XFS_INO_TO_FSB(mp, bmap->me_owner)));
457 	state = (bmap->me_flags & XFS_BMAP_EXTENT_UNWRITTEN) ?
458 			XFS_EXT_UNWRITTEN : XFS_EXT_NORM;
459 	whichfork = (bmap->me_flags & XFS_BMAP_EXTENT_ATTR_FORK) ?
460 			XFS_ATTR_FORK : XFS_DATA_FORK;
461 	bui_type = bmap->me_flags & XFS_BMAP_EXTENT_TYPE_MASK;
462 	switch (bui_type) {
463 	case XFS_BMAP_MAP:
464 	case XFS_BMAP_UNMAP:
465 		break;
466 	default:
467 		return -EFSCORRUPTED;
468 	}
469 	if (startblock_fsb == 0 ||
470 	    bmap->me_len == 0 ||
471 	    inode_fsb == 0 ||
472 	    startblock_fsb >= mp->m_sb.sb_dblocks ||
473 	    bmap->me_len >= mp->m_sb.sb_agblocks ||
474 	    inode_fsb >= mp->m_sb.sb_dblocks ||
475 	    (bmap->me_flags & ~XFS_BMAP_EXTENT_FLAGS))
476 		return -EFSCORRUPTED;
477 
478 	/* Grab the inode. */
479 	error = xfs_iget(mp, NULL, bmap->me_owner, 0, 0, &ip);
480 	if (error)
481 		return error;
482 
483 	error = xfs_qm_dqattach(ip);
484 	if (error)
485 		goto err_rele;
486 
487 	if (VFS_I(ip)->i_nlink == 0)
488 		xfs_iflags_set(ip, XFS_IRECOVERY);
489 
490 	/* Allocate transaction and do the work. */
491 	error = xfs_trans_alloc(mp, &M_RES(mp)->tr_itruncate,
492 			XFS_EXTENTADD_SPACE_RES(mp, XFS_DATA_FORK), 0, 0, &tp);
493 	if (error)
494 		goto err_rele;
495 
496 	budp = xfs_trans_get_bud(tp, buip);
497 	xfs_ilock(ip, XFS_ILOCK_EXCL);
498 	xfs_trans_ijoin(tp, ip, 0);
499 
500 	count = bmap->me_len;
501 	error = xfs_trans_log_finish_bmap_update(tp, budp, bui_type, ip,
502 			whichfork, bmap->me_startoff, bmap->me_startblock,
503 			&count, state);
504 	if (error)
505 		goto err_cancel;
506 
507 	if (count > 0) {
508 		ASSERT(bui_type == XFS_BMAP_UNMAP);
509 		irec.br_startblock = bmap->me_startblock;
510 		irec.br_blockcount = count;
511 		irec.br_startoff = bmap->me_startoff;
512 		irec.br_state = state;
513 		xfs_bmap_unmap_extent(tp, ip, &irec);
514 	}
515 
516 	/*
517 	 * Commit transaction, which frees the transaction and saves the inode
518 	 * for later replay activities.
519 	 */
520 	error = xfs_defer_ops_capture_and_commit(tp, ip, capture_list);
521 	if (error)
522 		goto err_unlock;
523 
524 	xfs_iunlock(ip, XFS_ILOCK_EXCL);
525 	xfs_irele(ip);
526 	return 0;
527 
528 err_cancel:
529 	xfs_trans_cancel(tp);
530 err_unlock:
531 	xfs_iunlock(ip, XFS_ILOCK_EXCL);
532 err_rele:
533 	xfs_irele(ip);
534 	return error;
535 }
536 
537 STATIC bool
538 xfs_bui_item_match(
539 	struct xfs_log_item	*lip,
540 	uint64_t		intent_id)
541 {
542 	return BUI_ITEM(lip)->bui_format.bui_id == intent_id;
543 }
544 
545 /* Relog an intent item to push the log tail forward. */
546 static struct xfs_log_item *
547 xfs_bui_item_relog(
548 	struct xfs_log_item		*intent,
549 	struct xfs_trans		*tp)
550 {
551 	struct xfs_bud_log_item		*budp;
552 	struct xfs_bui_log_item		*buip;
553 	struct xfs_map_extent		*extp;
554 	unsigned int			count;
555 
556 	count = BUI_ITEM(intent)->bui_format.bui_nextents;
557 	extp = BUI_ITEM(intent)->bui_format.bui_extents;
558 
559 	tp->t_flags |= XFS_TRANS_DIRTY;
560 	budp = xfs_trans_get_bud(tp, BUI_ITEM(intent));
561 	set_bit(XFS_LI_DIRTY, &budp->bud_item.li_flags);
562 
563 	buip = xfs_bui_init(tp->t_mountp);
564 	memcpy(buip->bui_format.bui_extents, extp, count * sizeof(*extp));
565 	atomic_set(&buip->bui_next_extent, count);
566 	xfs_trans_add_item(tp, &buip->bui_item);
567 	set_bit(XFS_LI_DIRTY, &buip->bui_item.li_flags);
568 	return &buip->bui_item;
569 }
570 
571 static const struct xfs_item_ops xfs_bui_item_ops = {
572 	.iop_size	= xfs_bui_item_size,
573 	.iop_format	= xfs_bui_item_format,
574 	.iop_unpin	= xfs_bui_item_unpin,
575 	.iop_release	= xfs_bui_item_release,
576 	.iop_recover	= xfs_bui_item_recover,
577 	.iop_match	= xfs_bui_item_match,
578 	.iop_relog	= xfs_bui_item_relog,
579 };
580 
581 /*
582  * Copy an BUI format buffer from the given buf, and into the destination
583  * BUI format structure.  The BUI/BUD items were designed not to need any
584  * special alignment handling.
585  */
586 static int
587 xfs_bui_copy_format(
588 	struct xfs_log_iovec		*buf,
589 	struct xfs_bui_log_format	*dst_bui_fmt)
590 {
591 	struct xfs_bui_log_format	*src_bui_fmt;
592 	uint				len;
593 
594 	src_bui_fmt = buf->i_addr;
595 	len = xfs_bui_log_format_sizeof(src_bui_fmt->bui_nextents);
596 
597 	if (buf->i_len == len) {
598 		memcpy(dst_bui_fmt, src_bui_fmt, len);
599 		return 0;
600 	}
601 	XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_LOW, NULL);
602 	return -EFSCORRUPTED;
603 }
604 
605 /*
606  * This routine is called to create an in-core extent bmap update
607  * item from the bui format structure which was logged on disk.
608  * It allocates an in-core bui, copies the extents from the format
609  * structure into it, and adds the bui to the AIL with the given
610  * LSN.
611  */
612 STATIC int
613 xlog_recover_bui_commit_pass2(
614 	struct xlog			*log,
615 	struct list_head		*buffer_list,
616 	struct xlog_recover_item	*item,
617 	xfs_lsn_t			lsn)
618 {
619 	int				error;
620 	struct xfs_mount		*mp = log->l_mp;
621 	struct xfs_bui_log_item		*buip;
622 	struct xfs_bui_log_format	*bui_formatp;
623 
624 	bui_formatp = item->ri_buf[0].i_addr;
625 
626 	if (bui_formatp->bui_nextents != XFS_BUI_MAX_FAST_EXTENTS) {
627 		XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_LOW, log->l_mp);
628 		return -EFSCORRUPTED;
629 	}
630 	buip = xfs_bui_init(mp);
631 	error = xfs_bui_copy_format(&item->ri_buf[0], &buip->bui_format);
632 	if (error) {
633 		xfs_bui_item_free(buip);
634 		return error;
635 	}
636 	atomic_set(&buip->bui_next_extent, bui_formatp->bui_nextents);
637 	/*
638 	 * Insert the intent into the AIL directly and drop one reference so
639 	 * that finishing or canceling the work will drop the other.
640 	 */
641 	xfs_trans_ail_insert(log->l_ailp, &buip->bui_item, lsn);
642 	xfs_bui_release(buip);
643 	return 0;
644 }
645 
646 const struct xlog_recover_item_ops xlog_bui_item_ops = {
647 	.item_type		= XFS_LI_BUI,
648 	.commit_pass2		= xlog_recover_bui_commit_pass2,
649 };
650 
651 /*
652  * This routine is called when an BUD format structure is found in a committed
653  * transaction in the log. Its purpose is to cancel the corresponding BUI if it
654  * was still in the log. To do this it searches the AIL for the BUI with an id
655  * equal to that in the BUD format structure. If we find it we drop the BUD
656  * reference, which removes the BUI from the AIL and frees it.
657  */
658 STATIC int
659 xlog_recover_bud_commit_pass2(
660 	struct xlog			*log,
661 	struct list_head		*buffer_list,
662 	struct xlog_recover_item	*item,
663 	xfs_lsn_t			lsn)
664 {
665 	struct xfs_bud_log_format	*bud_formatp;
666 
667 	bud_formatp = item->ri_buf[0].i_addr;
668 	if (item->ri_buf[0].i_len != sizeof(struct xfs_bud_log_format)) {
669 		XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_LOW, log->l_mp);
670 		return -EFSCORRUPTED;
671 	}
672 
673 	xlog_recover_release_intent(log, XFS_LI_BUI, bud_formatp->bud_bui_id);
674 	return 0;
675 }
676 
677 const struct xlog_recover_item_ops xlog_bud_item_ops = {
678 	.item_type		= XFS_LI_BUD,
679 	.commit_pass2		= xlog_recover_bud_commit_pass2,
680 };
681