Loading...
1/*
2 * Copyright (C) 2016 Oracle. All Rights Reserved.
3 *
4 * Author: Darrick J. Wong <darrick.wong@oracle.com>
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version 2
9 * of the License, or (at your option) any later version.
10 *
11 * This program is distributed in the hope that it would be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write the Free Software Foundation,
18 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
19 */
20#include "xfs.h"
21#include "xfs_fs.h"
22#include "xfs_format.h"
23#include "xfs_log_format.h"
24#include "xfs_trans_resv.h"
25#include "xfs_bit.h"
26#include "xfs_mount.h"
27#include "xfs_defer.h"
28#include "xfs_inode.h"
29#include "xfs_trans.h"
30#include "xfs_trans_priv.h"
31#include "xfs_buf_item.h"
32#include "xfs_bmap_item.h"
33#include "xfs_log.h"
34#include "xfs_bmap.h"
35#include "xfs_icache.h"
36#include "xfs_trace.h"
37
38
39kmem_zone_t *xfs_bui_zone;
40kmem_zone_t *xfs_bud_zone;
41
42static inline struct xfs_bui_log_item *BUI_ITEM(struct xfs_log_item *lip)
43{
44 return container_of(lip, struct xfs_bui_log_item, bui_item);
45}
46
47void
48xfs_bui_item_free(
49 struct xfs_bui_log_item *buip)
50{
51 kmem_zone_free(xfs_bui_zone, buip);
52}
53
54STATIC void
55xfs_bui_item_size(
56 struct xfs_log_item *lip,
57 int *nvecs,
58 int *nbytes)
59{
60 struct xfs_bui_log_item *buip = BUI_ITEM(lip);
61
62 *nvecs += 1;
63 *nbytes += xfs_bui_log_format_sizeof(buip->bui_format.bui_nextents);
64}
65
66/*
67 * This is called to fill in the vector of log iovecs for the
68 * given bui log item. We use only 1 iovec, and we point that
69 * at the bui_log_format structure embedded in the bui item.
70 * It is at this point that we assert that all of the extent
71 * slots in the bui item have been filled.
72 */
73STATIC void
74xfs_bui_item_format(
75 struct xfs_log_item *lip,
76 struct xfs_log_vec *lv)
77{
78 struct xfs_bui_log_item *buip = BUI_ITEM(lip);
79 struct xfs_log_iovec *vecp = NULL;
80
81 ASSERT(atomic_read(&buip->bui_next_extent) ==
82 buip->bui_format.bui_nextents);
83
84 buip->bui_format.bui_type = XFS_LI_BUI;
85 buip->bui_format.bui_size = 1;
86
87 xlog_copy_iovec(lv, &vecp, XLOG_REG_TYPE_BUI_FORMAT, &buip->bui_format,
88 xfs_bui_log_format_sizeof(buip->bui_format.bui_nextents));
89}
90
91/*
92 * Pinning has no meaning for an bui item, so just return.
93 */
94STATIC void
95xfs_bui_item_pin(
96 struct xfs_log_item *lip)
97{
98}
99
100/*
101 * The unpin operation is the last place an BUI is manipulated in the log. It is
102 * either inserted in the AIL or aborted in the event of a log I/O error. In
103 * either case, the BUI transaction has been successfully committed to make it
104 * this far. Therefore, we expect whoever committed the BUI to either construct
105 * and commit the BUD or drop the BUD's reference in the event of error. Simply
106 * drop the log's BUI reference now that the log is done with it.
107 */
108STATIC void
109xfs_bui_item_unpin(
110 struct xfs_log_item *lip,
111 int remove)
112{
113 struct xfs_bui_log_item *buip = BUI_ITEM(lip);
114
115 xfs_bui_release(buip);
116}
117
118/*
119 * BUI items have no locking or pushing. However, since BUIs are pulled from
120 * the AIL when their corresponding BUDs are committed to disk, their situation
121 * is very similar to being pinned. Return XFS_ITEM_PINNED so that the caller
122 * will eventually flush the log. This should help in getting the BUI out of
123 * the AIL.
124 */
125STATIC uint
126xfs_bui_item_push(
127 struct xfs_log_item *lip,
128 struct list_head *buffer_list)
129{
130 return XFS_ITEM_PINNED;
131}
132
133/*
134 * The BUI has been either committed or aborted if the transaction has been
135 * cancelled. If the transaction was cancelled, an BUD isn't going to be
136 * constructed and thus we free the BUI here directly.
137 */
138STATIC void
139xfs_bui_item_unlock(
140 struct xfs_log_item *lip)
141{
142 if (lip->li_flags & XFS_LI_ABORTED)
143 xfs_bui_item_free(BUI_ITEM(lip));
144}
145
146/*
147 * The BUI is logged only once and cannot be moved in the log, so simply return
148 * the lsn at which it's been logged.
149 */
150STATIC xfs_lsn_t
151xfs_bui_item_committed(
152 struct xfs_log_item *lip,
153 xfs_lsn_t lsn)
154{
155 return lsn;
156}
157
158/*
159 * The BUI dependency tracking op doesn't do squat. It can't because
160 * it doesn't know where the free extent is coming from. The dependency
161 * tracking has to be handled by the "enclosing" metadata object. For
162 * example, for inodes, the inode is locked throughout the extent freeing
163 * so the dependency should be recorded there.
164 */
165STATIC void
166xfs_bui_item_committing(
167 struct xfs_log_item *lip,
168 xfs_lsn_t lsn)
169{
170}
171
172/*
173 * This is the ops vector shared by all bui log items.
174 */
175static const struct xfs_item_ops xfs_bui_item_ops = {
176 .iop_size = xfs_bui_item_size,
177 .iop_format = xfs_bui_item_format,
178 .iop_pin = xfs_bui_item_pin,
179 .iop_unpin = xfs_bui_item_unpin,
180 .iop_unlock = xfs_bui_item_unlock,
181 .iop_committed = xfs_bui_item_committed,
182 .iop_push = xfs_bui_item_push,
183 .iop_committing = xfs_bui_item_committing,
184};
185
186/*
187 * Allocate and initialize an bui item with the given number of extents.
188 */
189struct xfs_bui_log_item *
190xfs_bui_init(
191 struct xfs_mount *mp)
192
193{
194 struct xfs_bui_log_item *buip;
195
196 buip = kmem_zone_zalloc(xfs_bui_zone, KM_SLEEP);
197
198 xfs_log_item_init(mp, &buip->bui_item, XFS_LI_BUI, &xfs_bui_item_ops);
199 buip->bui_format.bui_nextents = XFS_BUI_MAX_FAST_EXTENTS;
200 buip->bui_format.bui_id = (uintptr_t)(void *)buip;
201 atomic_set(&buip->bui_next_extent, 0);
202 atomic_set(&buip->bui_refcount, 2);
203
204 return buip;
205}
206
207/*
208 * Freeing the BUI requires that we remove it from the AIL if it has already
209 * been placed there. However, the BUI may not yet have been placed in the AIL
210 * when called by xfs_bui_release() from BUD processing due to the ordering of
211 * committed vs unpin operations in bulk insert operations. Hence the reference
212 * count to ensure only the last caller frees the BUI.
213 */
214void
215xfs_bui_release(
216 struct xfs_bui_log_item *buip)
217{
218 if (atomic_dec_and_test(&buip->bui_refcount)) {
219 xfs_trans_ail_remove(&buip->bui_item, SHUTDOWN_LOG_IO_ERROR);
220 xfs_bui_item_free(buip);
221 }
222}
223
224static inline struct xfs_bud_log_item *BUD_ITEM(struct xfs_log_item *lip)
225{
226 return container_of(lip, struct xfs_bud_log_item, bud_item);
227}
228
229STATIC void
230xfs_bud_item_size(
231 struct xfs_log_item *lip,
232 int *nvecs,
233 int *nbytes)
234{
235 *nvecs += 1;
236 *nbytes += sizeof(struct xfs_bud_log_format);
237}
238
239/*
240 * This is called to fill in the vector of log iovecs for the
241 * given bud log item. We use only 1 iovec, and we point that
242 * at the bud_log_format structure embedded in the bud item.
243 * It is at this point that we assert that all of the extent
244 * slots in the bud item have been filled.
245 */
246STATIC void
247xfs_bud_item_format(
248 struct xfs_log_item *lip,
249 struct xfs_log_vec *lv)
250{
251 struct xfs_bud_log_item *budp = BUD_ITEM(lip);
252 struct xfs_log_iovec *vecp = NULL;
253
254 budp->bud_format.bud_type = XFS_LI_BUD;
255 budp->bud_format.bud_size = 1;
256
257 xlog_copy_iovec(lv, &vecp, XLOG_REG_TYPE_BUD_FORMAT, &budp->bud_format,
258 sizeof(struct xfs_bud_log_format));
259}
260
261/*
262 * Pinning has no meaning for an bud item, so just return.
263 */
264STATIC void
265xfs_bud_item_pin(
266 struct xfs_log_item *lip)
267{
268}
269
270/*
271 * Since pinning has no meaning for an bud item, unpinning does
272 * not either.
273 */
274STATIC void
275xfs_bud_item_unpin(
276 struct xfs_log_item *lip,
277 int remove)
278{
279}
280
281/*
282 * There isn't much you can do to push on an bud item. It is simply stuck
283 * waiting for the log to be flushed to disk.
284 */
285STATIC uint
286xfs_bud_item_push(
287 struct xfs_log_item *lip,
288 struct list_head *buffer_list)
289{
290 return XFS_ITEM_PINNED;
291}
292
293/*
294 * The BUD is either committed or aborted if the transaction is cancelled. If
295 * the transaction is cancelled, drop our reference to the BUI and free the
296 * BUD.
297 */
298STATIC void
299xfs_bud_item_unlock(
300 struct xfs_log_item *lip)
301{
302 struct xfs_bud_log_item *budp = BUD_ITEM(lip);
303
304 if (lip->li_flags & XFS_LI_ABORTED) {
305 xfs_bui_release(budp->bud_buip);
306 kmem_zone_free(xfs_bud_zone, budp);
307 }
308}
309
310/*
311 * When the bud item is committed to disk, all we need to do is delete our
312 * reference to our partner bui item and then free ourselves. Since we're
313 * freeing ourselves we must return -1 to keep the transaction code from
314 * further referencing this item.
315 */
316STATIC xfs_lsn_t
317xfs_bud_item_committed(
318 struct xfs_log_item *lip,
319 xfs_lsn_t lsn)
320{
321 struct xfs_bud_log_item *budp = BUD_ITEM(lip);
322
323 /*
324 * Drop the BUI reference regardless of whether the BUD has been
325 * aborted. Once the BUD transaction is constructed, it is the sole
326 * responsibility of the BUD to release the BUI (even if the BUI is
327 * aborted due to log I/O error).
328 */
329 xfs_bui_release(budp->bud_buip);
330 kmem_zone_free(xfs_bud_zone, budp);
331
332 return (xfs_lsn_t)-1;
333}
334
335/*
336 * The BUD dependency tracking op doesn't do squat. It can't because
337 * it doesn't know where the free extent is coming from. The dependency
338 * tracking has to be handled by the "enclosing" metadata object. For
339 * example, for inodes, the inode is locked throughout the extent freeing
340 * so the dependency should be recorded there.
341 */
342STATIC void
343xfs_bud_item_committing(
344 struct xfs_log_item *lip,
345 xfs_lsn_t lsn)
346{
347}
348
349/*
350 * This is the ops vector shared by all bud log items.
351 */
352static const struct xfs_item_ops xfs_bud_item_ops = {
353 .iop_size = xfs_bud_item_size,
354 .iop_format = xfs_bud_item_format,
355 .iop_pin = xfs_bud_item_pin,
356 .iop_unpin = xfs_bud_item_unpin,
357 .iop_unlock = xfs_bud_item_unlock,
358 .iop_committed = xfs_bud_item_committed,
359 .iop_push = xfs_bud_item_push,
360 .iop_committing = xfs_bud_item_committing,
361};
362
363/*
364 * Allocate and initialize an bud item with the given number of extents.
365 */
366struct xfs_bud_log_item *
367xfs_bud_init(
368 struct xfs_mount *mp,
369 struct xfs_bui_log_item *buip)
370
371{
372 struct xfs_bud_log_item *budp;
373
374 budp = kmem_zone_zalloc(xfs_bud_zone, KM_SLEEP);
375 xfs_log_item_init(mp, &budp->bud_item, XFS_LI_BUD, &xfs_bud_item_ops);
376 budp->bud_buip = buip;
377 budp->bud_format.bud_bui_id = buip->bui_format.bui_id;
378
379 return budp;
380}
381
382/*
383 * Process a bmap update intent item that was recovered from the log.
384 * We need to update some inode's bmbt.
385 */
386int
387xfs_bui_recover(
388 struct xfs_mount *mp,
389 struct xfs_bui_log_item *buip)
390{
391 int error = 0;
392 unsigned int bui_type;
393 struct xfs_map_extent *bmap;
394 xfs_fsblock_t startblock_fsb;
395 xfs_fsblock_t inode_fsb;
396 bool op_ok;
397 struct xfs_bud_log_item *budp;
398 enum xfs_bmap_intent_type type;
399 int whichfork;
400 xfs_exntst_t state;
401 struct xfs_trans *tp;
402 struct xfs_inode *ip = NULL;
403 struct xfs_defer_ops dfops;
404 xfs_fsblock_t firstfsb;
405
406 ASSERT(!test_bit(XFS_BUI_RECOVERED, &buip->bui_flags));
407
408 /* Only one mapping operation per BUI... */
409 if (buip->bui_format.bui_nextents != XFS_BUI_MAX_FAST_EXTENTS) {
410 set_bit(XFS_BUI_RECOVERED, &buip->bui_flags);
411 xfs_bui_release(buip);
412 return -EIO;
413 }
414
415 /*
416 * First check the validity of the extent described by the
417 * BUI. If anything is bad, then toss the BUI.
418 */
419 bmap = &buip->bui_format.bui_extents[0];
420 startblock_fsb = XFS_BB_TO_FSB(mp,
421 XFS_FSB_TO_DADDR(mp, bmap->me_startblock));
422 inode_fsb = XFS_BB_TO_FSB(mp, XFS_FSB_TO_DADDR(mp,
423 XFS_INO_TO_FSB(mp, bmap->me_owner)));
424 switch (bmap->me_flags & XFS_BMAP_EXTENT_TYPE_MASK) {
425 case XFS_BMAP_MAP:
426 case XFS_BMAP_UNMAP:
427 op_ok = true;
428 break;
429 default:
430 op_ok = false;
431 break;
432 }
433 if (!op_ok || startblock_fsb == 0 ||
434 bmap->me_len == 0 ||
435 inode_fsb == 0 ||
436 startblock_fsb >= mp->m_sb.sb_dblocks ||
437 bmap->me_len >= mp->m_sb.sb_agblocks ||
438 inode_fsb >= mp->m_sb.sb_dblocks ||
439 (bmap->me_flags & ~XFS_BMAP_EXTENT_FLAGS)) {
440 /*
441 * This will pull the BUI from the AIL and
442 * free the memory associated with it.
443 */
444 set_bit(XFS_BUI_RECOVERED, &buip->bui_flags);
445 xfs_bui_release(buip);
446 return -EIO;
447 }
448
449 error = xfs_trans_alloc(mp, &M_RES(mp)->tr_itruncate, 0, 0, 0, &tp);
450 if (error)
451 return error;
452 budp = xfs_trans_get_bud(tp, buip);
453
454 /* Grab the inode. */
455 error = xfs_iget(mp, tp, bmap->me_owner, 0, XFS_ILOCK_EXCL, &ip);
456 if (error)
457 goto err_inode;
458
459 if (VFS_I(ip)->i_nlink == 0)
460 xfs_iflags_set(ip, XFS_IRECOVERY);
461 xfs_defer_init(&dfops, &firstfsb);
462
463 /* Process deferred bmap item. */
464 state = (bmap->me_flags & XFS_BMAP_EXTENT_UNWRITTEN) ?
465 XFS_EXT_UNWRITTEN : XFS_EXT_NORM;
466 whichfork = (bmap->me_flags & XFS_BMAP_EXTENT_ATTR_FORK) ?
467 XFS_ATTR_FORK : XFS_DATA_FORK;
468 bui_type = bmap->me_flags & XFS_BMAP_EXTENT_TYPE_MASK;
469 switch (bui_type) {
470 case XFS_BMAP_MAP:
471 case XFS_BMAP_UNMAP:
472 type = bui_type;
473 break;
474 default:
475 error = -EFSCORRUPTED;
476 goto err_dfops;
477 }
478 xfs_trans_ijoin(tp, ip, 0);
479
480 error = xfs_trans_log_finish_bmap_update(tp, budp, &dfops, type,
481 ip, whichfork, bmap->me_startoff,
482 bmap->me_startblock, bmap->me_len,
483 state);
484 if (error)
485 goto err_dfops;
486
487 /* Finish transaction, free inodes. */
488 error = xfs_defer_finish(&tp, &dfops, NULL);
489 if (error)
490 goto err_dfops;
491
492 set_bit(XFS_BUI_RECOVERED, &buip->bui_flags);
493 error = xfs_trans_commit(tp);
494 xfs_iunlock(ip, XFS_ILOCK_EXCL);
495 IRELE(ip);
496
497 return error;
498
499err_dfops:
500 xfs_defer_cancel(&dfops);
501err_inode:
502 xfs_trans_cancel(tp);
503 if (ip) {
504 xfs_iunlock(ip, XFS_ILOCK_EXCL);
505 IRELE(ip);
506 }
507 return error;
508}
1/*
2 * Copyright (C) 2016 Oracle. All Rights Reserved.
3 *
4 * Author: Darrick J. Wong <darrick.wong@oracle.com>
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version 2
9 * of the License, or (at your option) any later version.
10 *
11 * This program is distributed in the hope that it would be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write the Free Software Foundation,
18 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
19 */
20#include "xfs.h"
21#include "xfs_fs.h"
22#include "xfs_format.h"
23#include "xfs_log_format.h"
24#include "xfs_trans_resv.h"
25#include "xfs_bit.h"
26#include "xfs_mount.h"
27#include "xfs_defer.h"
28#include "xfs_inode.h"
29#include "xfs_trans.h"
30#include "xfs_trans_priv.h"
31#include "xfs_buf_item.h"
32#include "xfs_bmap_item.h"
33#include "xfs_log.h"
34#include "xfs_bmap.h"
35#include "xfs_icache.h"
36#include "xfs_trace.h"
37#include "xfs_bmap_btree.h"
38#include "xfs_trans_space.h"
39
40
41kmem_zone_t *xfs_bui_zone;
42kmem_zone_t *xfs_bud_zone;
43
44static inline struct xfs_bui_log_item *BUI_ITEM(struct xfs_log_item *lip)
45{
46 return container_of(lip, struct xfs_bui_log_item, bui_item);
47}
48
49void
50xfs_bui_item_free(
51 struct xfs_bui_log_item *buip)
52{
53 kmem_zone_free(xfs_bui_zone, buip);
54}
55
56/*
57 * Freeing the BUI requires that we remove it from the AIL if it has already
58 * been placed there. However, the BUI may not yet have been placed in the AIL
59 * when called by xfs_bui_release() from BUD processing due to the ordering of
60 * committed vs unpin operations in bulk insert operations. Hence the reference
61 * count to ensure only the last caller frees the BUI.
62 */
63void
64xfs_bui_release(
65 struct xfs_bui_log_item *buip)
66{
67 ASSERT(atomic_read(&buip->bui_refcount) > 0);
68 if (atomic_dec_and_test(&buip->bui_refcount)) {
69 xfs_trans_ail_remove(&buip->bui_item, SHUTDOWN_LOG_IO_ERROR);
70 xfs_bui_item_free(buip);
71 }
72}
73
74
75STATIC void
76xfs_bui_item_size(
77 struct xfs_log_item *lip,
78 int *nvecs,
79 int *nbytes)
80{
81 struct xfs_bui_log_item *buip = BUI_ITEM(lip);
82
83 *nvecs += 1;
84 *nbytes += xfs_bui_log_format_sizeof(buip->bui_format.bui_nextents);
85}
86
87/*
88 * This is called to fill in the vector of log iovecs for the
89 * given bui log item. We use only 1 iovec, and we point that
90 * at the bui_log_format structure embedded in the bui item.
91 * It is at this point that we assert that all of the extent
92 * slots in the bui item have been filled.
93 */
94STATIC void
95xfs_bui_item_format(
96 struct xfs_log_item *lip,
97 struct xfs_log_vec *lv)
98{
99 struct xfs_bui_log_item *buip = BUI_ITEM(lip);
100 struct xfs_log_iovec *vecp = NULL;
101
102 ASSERT(atomic_read(&buip->bui_next_extent) ==
103 buip->bui_format.bui_nextents);
104
105 buip->bui_format.bui_type = XFS_LI_BUI;
106 buip->bui_format.bui_size = 1;
107
108 xlog_copy_iovec(lv, &vecp, XLOG_REG_TYPE_BUI_FORMAT, &buip->bui_format,
109 xfs_bui_log_format_sizeof(buip->bui_format.bui_nextents));
110}
111
112/*
113 * Pinning has no meaning for an bui item, so just return.
114 */
115STATIC void
116xfs_bui_item_pin(
117 struct xfs_log_item *lip)
118{
119}
120
121/*
122 * The unpin operation is the last place an BUI is manipulated in the log. It is
123 * either inserted in the AIL or aborted in the event of a log I/O error. In
124 * either case, the BUI transaction has been successfully committed to make it
125 * this far. Therefore, we expect whoever committed the BUI to either construct
126 * and commit the BUD or drop the BUD's reference in the event of error. Simply
127 * drop the log's BUI reference now that the log is done with it.
128 */
129STATIC void
130xfs_bui_item_unpin(
131 struct xfs_log_item *lip,
132 int remove)
133{
134 struct xfs_bui_log_item *buip = BUI_ITEM(lip);
135
136 xfs_bui_release(buip);
137}
138
139/*
140 * BUI items have no locking or pushing. However, since BUIs are pulled from
141 * the AIL when their corresponding BUDs are committed to disk, their situation
142 * is very similar to being pinned. Return XFS_ITEM_PINNED so that the caller
143 * will eventually flush the log. This should help in getting the BUI out of
144 * the AIL.
145 */
146STATIC uint
147xfs_bui_item_push(
148 struct xfs_log_item *lip,
149 struct list_head *buffer_list)
150{
151 return XFS_ITEM_PINNED;
152}
153
154/*
155 * The BUI has been either committed or aborted if the transaction has been
156 * cancelled. If the transaction was cancelled, an BUD isn't going to be
157 * constructed and thus we free the BUI here directly.
158 */
159STATIC void
160xfs_bui_item_unlock(
161 struct xfs_log_item *lip)
162{
163 if (lip->li_flags & XFS_LI_ABORTED)
164 xfs_bui_release(BUI_ITEM(lip));
165}
166
167/*
168 * The BUI is logged only once and cannot be moved in the log, so simply return
169 * the lsn at which it's been logged.
170 */
171STATIC xfs_lsn_t
172xfs_bui_item_committed(
173 struct xfs_log_item *lip,
174 xfs_lsn_t lsn)
175{
176 return lsn;
177}
178
179/*
180 * The BUI dependency tracking op doesn't do squat. It can't because
181 * it doesn't know where the free extent is coming from. The dependency
182 * tracking has to be handled by the "enclosing" metadata object. For
183 * example, for inodes, the inode is locked throughout the extent freeing
184 * so the dependency should be recorded there.
185 */
186STATIC void
187xfs_bui_item_committing(
188 struct xfs_log_item *lip,
189 xfs_lsn_t lsn)
190{
191}
192
193/*
194 * This is the ops vector shared by all bui log items.
195 */
196static const struct xfs_item_ops xfs_bui_item_ops = {
197 .iop_size = xfs_bui_item_size,
198 .iop_format = xfs_bui_item_format,
199 .iop_pin = xfs_bui_item_pin,
200 .iop_unpin = xfs_bui_item_unpin,
201 .iop_unlock = xfs_bui_item_unlock,
202 .iop_committed = xfs_bui_item_committed,
203 .iop_push = xfs_bui_item_push,
204 .iop_committing = xfs_bui_item_committing,
205};
206
207/*
208 * Allocate and initialize an bui item with the given number of extents.
209 */
210struct xfs_bui_log_item *
211xfs_bui_init(
212 struct xfs_mount *mp)
213
214{
215 struct xfs_bui_log_item *buip;
216
217 buip = kmem_zone_zalloc(xfs_bui_zone, KM_SLEEP);
218
219 xfs_log_item_init(mp, &buip->bui_item, XFS_LI_BUI, &xfs_bui_item_ops);
220 buip->bui_format.bui_nextents = XFS_BUI_MAX_FAST_EXTENTS;
221 buip->bui_format.bui_id = (uintptr_t)(void *)buip;
222 atomic_set(&buip->bui_next_extent, 0);
223 atomic_set(&buip->bui_refcount, 2);
224
225 return buip;
226}
227
228static inline struct xfs_bud_log_item *BUD_ITEM(struct xfs_log_item *lip)
229{
230 return container_of(lip, struct xfs_bud_log_item, bud_item);
231}
232
233STATIC void
234xfs_bud_item_size(
235 struct xfs_log_item *lip,
236 int *nvecs,
237 int *nbytes)
238{
239 *nvecs += 1;
240 *nbytes += sizeof(struct xfs_bud_log_format);
241}
242
243/*
244 * This is called to fill in the vector of log iovecs for the
245 * given bud log item. We use only 1 iovec, and we point that
246 * at the bud_log_format structure embedded in the bud item.
247 * It is at this point that we assert that all of the extent
248 * slots in the bud item have been filled.
249 */
250STATIC void
251xfs_bud_item_format(
252 struct xfs_log_item *lip,
253 struct xfs_log_vec *lv)
254{
255 struct xfs_bud_log_item *budp = BUD_ITEM(lip);
256 struct xfs_log_iovec *vecp = NULL;
257
258 budp->bud_format.bud_type = XFS_LI_BUD;
259 budp->bud_format.bud_size = 1;
260
261 xlog_copy_iovec(lv, &vecp, XLOG_REG_TYPE_BUD_FORMAT, &budp->bud_format,
262 sizeof(struct xfs_bud_log_format));
263}
264
265/*
266 * Pinning has no meaning for an bud item, so just return.
267 */
268STATIC void
269xfs_bud_item_pin(
270 struct xfs_log_item *lip)
271{
272}
273
274/*
275 * Since pinning has no meaning for an bud item, unpinning does
276 * not either.
277 */
278STATIC void
279xfs_bud_item_unpin(
280 struct xfs_log_item *lip,
281 int remove)
282{
283}
284
285/*
286 * There isn't much you can do to push on an bud item. It is simply stuck
287 * waiting for the log to be flushed to disk.
288 */
289STATIC uint
290xfs_bud_item_push(
291 struct xfs_log_item *lip,
292 struct list_head *buffer_list)
293{
294 return XFS_ITEM_PINNED;
295}
296
297/*
298 * The BUD is either committed or aborted if the transaction is cancelled. If
299 * the transaction is cancelled, drop our reference to the BUI and free the
300 * BUD.
301 */
302STATIC void
303xfs_bud_item_unlock(
304 struct xfs_log_item *lip)
305{
306 struct xfs_bud_log_item *budp = BUD_ITEM(lip);
307
308 if (lip->li_flags & XFS_LI_ABORTED) {
309 xfs_bui_release(budp->bud_buip);
310 kmem_zone_free(xfs_bud_zone, budp);
311 }
312}
313
314/*
315 * When the bud item is committed to disk, all we need to do is delete our
316 * reference to our partner bui item and then free ourselves. Since we're
317 * freeing ourselves we must return -1 to keep the transaction code from
318 * further referencing this item.
319 */
320STATIC xfs_lsn_t
321xfs_bud_item_committed(
322 struct xfs_log_item *lip,
323 xfs_lsn_t lsn)
324{
325 struct xfs_bud_log_item *budp = BUD_ITEM(lip);
326
327 /*
328 * Drop the BUI reference regardless of whether the BUD has been
329 * aborted. Once the BUD transaction is constructed, it is the sole
330 * responsibility of the BUD to release the BUI (even if the BUI is
331 * aborted due to log I/O error).
332 */
333 xfs_bui_release(budp->bud_buip);
334 kmem_zone_free(xfs_bud_zone, budp);
335
336 return (xfs_lsn_t)-1;
337}
338
339/*
340 * The BUD dependency tracking op doesn't do squat. It can't because
341 * it doesn't know where the free extent is coming from. The dependency
342 * tracking has to be handled by the "enclosing" metadata object. For
343 * example, for inodes, the inode is locked throughout the extent freeing
344 * so the dependency should be recorded there.
345 */
346STATIC void
347xfs_bud_item_committing(
348 struct xfs_log_item *lip,
349 xfs_lsn_t lsn)
350{
351}
352
353/*
354 * This is the ops vector shared by all bud log items.
355 */
356static const struct xfs_item_ops xfs_bud_item_ops = {
357 .iop_size = xfs_bud_item_size,
358 .iop_format = xfs_bud_item_format,
359 .iop_pin = xfs_bud_item_pin,
360 .iop_unpin = xfs_bud_item_unpin,
361 .iop_unlock = xfs_bud_item_unlock,
362 .iop_committed = xfs_bud_item_committed,
363 .iop_push = xfs_bud_item_push,
364 .iop_committing = xfs_bud_item_committing,
365};
366
367/*
368 * Allocate and initialize an bud item with the given number of extents.
369 */
370struct xfs_bud_log_item *
371xfs_bud_init(
372 struct xfs_mount *mp,
373 struct xfs_bui_log_item *buip)
374
375{
376 struct xfs_bud_log_item *budp;
377
378 budp = kmem_zone_zalloc(xfs_bud_zone, KM_SLEEP);
379 xfs_log_item_init(mp, &budp->bud_item, XFS_LI_BUD, &xfs_bud_item_ops);
380 budp->bud_buip = buip;
381 budp->bud_format.bud_bui_id = buip->bui_format.bui_id;
382
383 return budp;
384}
385
386/*
387 * Process a bmap update intent item that was recovered from the log.
388 * We need to update some inode's bmbt.
389 */
390int
391xfs_bui_recover(
392 struct xfs_mount *mp,
393 struct xfs_bui_log_item *buip,
394 struct xfs_defer_ops *dfops)
395{
396 int error = 0;
397 unsigned int bui_type;
398 struct xfs_map_extent *bmap;
399 xfs_fsblock_t startblock_fsb;
400 xfs_fsblock_t inode_fsb;
401 xfs_filblks_t count;
402 bool op_ok;
403 struct xfs_bud_log_item *budp;
404 enum xfs_bmap_intent_type type;
405 int whichfork;
406 xfs_exntst_t state;
407 struct xfs_trans *tp;
408 struct xfs_inode *ip = NULL;
409 struct xfs_bmbt_irec irec;
410
411 ASSERT(!test_bit(XFS_BUI_RECOVERED, &buip->bui_flags));
412
413 /* Only one mapping operation per BUI... */
414 if (buip->bui_format.bui_nextents != XFS_BUI_MAX_FAST_EXTENTS) {
415 set_bit(XFS_BUI_RECOVERED, &buip->bui_flags);
416 xfs_bui_release(buip);
417 return -EIO;
418 }
419
420 /*
421 * First check the validity of the extent described by the
422 * BUI. If anything is bad, then toss the BUI.
423 */
424 bmap = &buip->bui_format.bui_extents[0];
425 startblock_fsb = XFS_BB_TO_FSB(mp,
426 XFS_FSB_TO_DADDR(mp, bmap->me_startblock));
427 inode_fsb = XFS_BB_TO_FSB(mp, XFS_FSB_TO_DADDR(mp,
428 XFS_INO_TO_FSB(mp, bmap->me_owner)));
429 switch (bmap->me_flags & XFS_BMAP_EXTENT_TYPE_MASK) {
430 case XFS_BMAP_MAP:
431 case XFS_BMAP_UNMAP:
432 op_ok = true;
433 break;
434 default:
435 op_ok = false;
436 break;
437 }
438 if (!op_ok || startblock_fsb == 0 ||
439 bmap->me_len == 0 ||
440 inode_fsb == 0 ||
441 startblock_fsb >= mp->m_sb.sb_dblocks ||
442 bmap->me_len >= mp->m_sb.sb_agblocks ||
443 inode_fsb >= mp->m_sb.sb_dblocks ||
444 (bmap->me_flags & ~XFS_BMAP_EXTENT_FLAGS)) {
445 /*
446 * This will pull the BUI from the AIL and
447 * free the memory associated with it.
448 */
449 set_bit(XFS_BUI_RECOVERED, &buip->bui_flags);
450 xfs_bui_release(buip);
451 return -EIO;
452 }
453
454 error = xfs_trans_alloc(mp, &M_RES(mp)->tr_itruncate,
455 XFS_EXTENTADD_SPACE_RES(mp, XFS_DATA_FORK), 0, 0, &tp);
456 if (error)
457 return error;
458 budp = xfs_trans_get_bud(tp, buip);
459
460 /* Grab the inode. */
461 error = xfs_iget(mp, tp, bmap->me_owner, 0, XFS_ILOCK_EXCL, &ip);
462 if (error)
463 goto err_inode;
464
465 if (VFS_I(ip)->i_nlink == 0)
466 xfs_iflags_set(ip, XFS_IRECOVERY);
467
468 /* Process deferred bmap item. */
469 state = (bmap->me_flags & XFS_BMAP_EXTENT_UNWRITTEN) ?
470 XFS_EXT_UNWRITTEN : XFS_EXT_NORM;
471 whichfork = (bmap->me_flags & XFS_BMAP_EXTENT_ATTR_FORK) ?
472 XFS_ATTR_FORK : XFS_DATA_FORK;
473 bui_type = bmap->me_flags & XFS_BMAP_EXTENT_TYPE_MASK;
474 switch (bui_type) {
475 case XFS_BMAP_MAP:
476 case XFS_BMAP_UNMAP:
477 type = bui_type;
478 break;
479 default:
480 error = -EFSCORRUPTED;
481 goto err_inode;
482 }
483 xfs_trans_ijoin(tp, ip, 0);
484
485 count = bmap->me_len;
486 error = xfs_trans_log_finish_bmap_update(tp, budp, dfops, type,
487 ip, whichfork, bmap->me_startoff,
488 bmap->me_startblock, &count, state);
489 if (error)
490 goto err_inode;
491
492 if (count > 0) {
493 ASSERT(type == XFS_BMAP_UNMAP);
494 irec.br_startblock = bmap->me_startblock;
495 irec.br_blockcount = count;
496 irec.br_startoff = bmap->me_startoff;
497 irec.br_state = state;
498 error = xfs_bmap_unmap_extent(tp->t_mountp, dfops, ip, &irec);
499 if (error)
500 goto err_inode;
501 }
502
503 set_bit(XFS_BUI_RECOVERED, &buip->bui_flags);
504 error = xfs_trans_commit(tp);
505 xfs_iunlock(ip, XFS_ILOCK_EXCL);
506 IRELE(ip);
507
508 return error;
509
510err_inode:
511 xfs_trans_cancel(tp);
512 if (ip) {
513 xfs_iunlock(ip, XFS_ILOCK_EXCL);
514 IRELE(ip);
515 }
516 return error;
517}