1
2
3
4
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
28kmem_zone_t *xfs_bui_zone;
29kmem_zone_t *xfs_bud_zone;
30
31static const struct xfs_item_ops xfs_bui_item_ops;
32
33static inline struct xfs_bui_log_item *BUI_ITEM(struct xfs_log_item *lip)
34{
35 return container_of(lip, struct xfs_bui_log_item, bui_item);
36}
37
38STATIC void
39xfs_bui_item_free(
40 struct xfs_bui_log_item *buip)
41{
42 kmem_cache_free(xfs_bui_zone, buip);
43}
44
45
46
47
48
49
50
51
52STATIC void
53xfs_bui_release(
54 struct xfs_bui_log_item *buip)
55{
56 ASSERT(atomic_read(&buip->bui_refcount) > 0);
57 if (atomic_dec_and_test(&buip->bui_refcount)) {
58 xfs_trans_ail_delete(&buip->bui_item, SHUTDOWN_LOG_IO_ERROR);
59 xfs_bui_item_free(buip);
60 }
61}
62
63
64STATIC void
65xfs_bui_item_size(
66 struct xfs_log_item *lip,
67 int *nvecs,
68 int *nbytes)
69{
70 struct xfs_bui_log_item *buip = BUI_ITEM(lip);
71
72 *nvecs += 1;
73 *nbytes += xfs_bui_log_format_sizeof(buip->bui_format.bui_nextents);
74}
75
76
77
78
79
80
81
82
83STATIC void
84xfs_bui_item_format(
85 struct xfs_log_item *lip,
86 struct xfs_log_vec *lv)
87{
88 struct xfs_bui_log_item *buip = BUI_ITEM(lip);
89 struct xfs_log_iovec *vecp = NULL;
90
91 ASSERT(atomic_read(&buip->bui_next_extent) ==
92 buip->bui_format.bui_nextents);
93
94 buip->bui_format.bui_type = XFS_LI_BUI;
95 buip->bui_format.bui_size = 1;
96
97 xlog_copy_iovec(lv, &vecp, XLOG_REG_TYPE_BUI_FORMAT, &buip->bui_format,
98 xfs_bui_log_format_sizeof(buip->bui_format.bui_nextents));
99}
100
101
102
103
104
105
106
107
108
109STATIC void
110xfs_bui_item_unpin(
111 struct xfs_log_item *lip,
112 int remove)
113{
114 struct xfs_bui_log_item *buip = BUI_ITEM(lip);
115
116 xfs_bui_release(buip);
117}
118
119
120
121
122
123
124STATIC void
125xfs_bui_item_release(
126 struct xfs_log_item *lip)
127{
128 xfs_bui_release(BUI_ITEM(lip));
129}
130
131
132
133
134STATIC struct xfs_bui_log_item *
135xfs_bui_init(
136 struct xfs_mount *mp)
137
138{
139 struct xfs_bui_log_item *buip;
140
141 buip = kmem_cache_zalloc(xfs_bui_zone, GFP_KERNEL | __GFP_NOFAIL);
142
143 xfs_log_item_init(mp, &buip->bui_item, XFS_LI_BUI, &xfs_bui_item_ops);
144 buip->bui_format.bui_nextents = XFS_BUI_MAX_FAST_EXTENTS;
145 buip->bui_format.bui_id = (uintptr_t)(void *)buip;
146 atomic_set(&buip->bui_next_extent, 0);
147 atomic_set(&buip->bui_refcount, 2);
148
149 return buip;
150}
151
152static inline struct xfs_bud_log_item *BUD_ITEM(struct xfs_log_item *lip)
153{
154 return container_of(lip, struct xfs_bud_log_item, bud_item);
155}
156
157STATIC void
158xfs_bud_item_size(
159 struct xfs_log_item *lip,
160 int *nvecs,
161 int *nbytes)
162{
163 *nvecs += 1;
164 *nbytes += sizeof(struct xfs_bud_log_format);
165}
166
167
168
169
170
171
172
173
174STATIC void
175xfs_bud_item_format(
176 struct xfs_log_item *lip,
177 struct xfs_log_vec *lv)
178{
179 struct xfs_bud_log_item *budp = BUD_ITEM(lip);
180 struct xfs_log_iovec *vecp = NULL;
181
182 budp->bud_format.bud_type = XFS_LI_BUD;
183 budp->bud_format.bud_size = 1;
184
185 xlog_copy_iovec(lv, &vecp, XLOG_REG_TYPE_BUD_FORMAT, &budp->bud_format,
186 sizeof(struct xfs_bud_log_format));
187}
188
189
190
191
192
193
194STATIC void
195xfs_bud_item_release(
196 struct xfs_log_item *lip)
197{
198 struct xfs_bud_log_item *budp = BUD_ITEM(lip);
199
200 xfs_bui_release(budp->bud_buip);
201 kmem_cache_free(xfs_bud_zone, budp);
202}
203
204static const struct xfs_item_ops xfs_bud_item_ops = {
205 .flags = XFS_ITEM_RELEASE_WHEN_COMMITTED,
206 .iop_size = xfs_bud_item_size,
207 .iop_format = xfs_bud_item_format,
208 .iop_release = xfs_bud_item_release,
209};
210
211static struct xfs_bud_log_item *
212xfs_trans_get_bud(
213 struct xfs_trans *tp,
214 struct xfs_bui_log_item *buip)
215{
216 struct xfs_bud_log_item *budp;
217
218 budp = kmem_cache_zalloc(xfs_bud_zone, GFP_KERNEL | __GFP_NOFAIL);
219 xfs_log_item_init(tp->t_mountp, &budp->bud_item, XFS_LI_BUD,
220 &xfs_bud_item_ops);
221 budp->bud_buip = buip;
222 budp->bud_format.bud_bui_id = buip->bui_format.bui_id;
223
224 xfs_trans_add_item(tp, &budp->bud_item);
225 return budp;
226}
227
228
229
230
231
232
233static int
234xfs_trans_log_finish_bmap_update(
235 struct xfs_trans *tp,
236 struct xfs_bud_log_item *budp,
237 enum xfs_bmap_intent_type type,
238 struct xfs_inode *ip,
239 int whichfork,
240 xfs_fileoff_t startoff,
241 xfs_fsblock_t startblock,
242 xfs_filblks_t *blockcount,
243 xfs_exntst_t state)
244{
245 int error;
246
247 error = xfs_bmap_finish_one(tp, ip, type, whichfork, startoff,
248 startblock, blockcount, state);
249
250
251
252
253
254
255
256
257 tp->t_flags |= XFS_TRANS_DIRTY;
258 set_bit(XFS_LI_DIRTY, &budp->bud_item.li_flags);
259
260 return error;
261}
262
263
264static int
265xfs_bmap_update_diff_items(
266 void *priv,
267 const struct list_head *a,
268 const struct list_head *b)
269{
270 struct xfs_bmap_intent *ba;
271 struct xfs_bmap_intent *bb;
272
273 ba = container_of(a, struct xfs_bmap_intent, bi_list);
274 bb = container_of(b, struct xfs_bmap_intent, bi_list);
275 return ba->bi_owner->i_ino - bb->bi_owner->i_ino;
276}
277
278
279static void
280xfs_trans_set_bmap_flags(
281 struct xfs_map_extent *bmap,
282 enum xfs_bmap_intent_type type,
283 int whichfork,
284 xfs_exntst_t state)
285{
286 bmap->me_flags = 0;
287 switch (type) {
288 case XFS_BMAP_MAP:
289 case XFS_BMAP_UNMAP:
290 bmap->me_flags = type;
291 break;
292 default:
293 ASSERT(0);
294 }
295 if (state == XFS_EXT_UNWRITTEN)
296 bmap->me_flags |= XFS_BMAP_EXTENT_UNWRITTEN;
297 if (whichfork == XFS_ATTR_FORK)
298 bmap->me_flags |= XFS_BMAP_EXTENT_ATTR_FORK;
299}
300
301
302STATIC void
303xfs_bmap_update_log_item(
304 struct xfs_trans *tp,
305 struct xfs_bui_log_item *buip,
306 struct xfs_bmap_intent *bmap)
307{
308 uint next_extent;
309 struct xfs_map_extent *map;
310
311 tp->t_flags |= XFS_TRANS_DIRTY;
312 set_bit(XFS_LI_DIRTY, &buip->bui_item.li_flags);
313
314
315
316
317
318
319 next_extent = atomic_inc_return(&buip->bui_next_extent) - 1;
320 ASSERT(next_extent < buip->bui_format.bui_nextents);
321 map = &buip->bui_format.bui_extents[next_extent];
322 map->me_owner = bmap->bi_owner->i_ino;
323 map->me_startblock = bmap->bi_bmap.br_startblock;
324 map->me_startoff = bmap->bi_bmap.br_startoff;
325 map->me_len = bmap->bi_bmap.br_blockcount;
326 xfs_trans_set_bmap_flags(map, bmap->bi_type, bmap->bi_whichfork,
327 bmap->bi_bmap.br_state);
328}
329
330static struct xfs_log_item *
331xfs_bmap_update_create_intent(
332 struct xfs_trans *tp,
333 struct list_head *items,
334 unsigned int count,
335 bool sort)
336{
337 struct xfs_mount *mp = tp->t_mountp;
338 struct xfs_bui_log_item *buip = xfs_bui_init(mp);
339 struct xfs_bmap_intent *bmap;
340
341 ASSERT(count == XFS_BUI_MAX_FAST_EXTENTS);
342
343 xfs_trans_add_item(tp, &buip->bui_item);
344 if (sort)
345 list_sort(mp, items, xfs_bmap_update_diff_items);
346 list_for_each_entry(bmap, items, bi_list)
347 xfs_bmap_update_log_item(tp, buip, bmap);
348 return &buip->bui_item;
349}
350
351
352static struct xfs_log_item *
353xfs_bmap_update_create_done(
354 struct xfs_trans *tp,
355 struct xfs_log_item *intent,
356 unsigned int count)
357{
358 return &xfs_trans_get_bud(tp, BUI_ITEM(intent))->bud_item;
359}
360
361
362STATIC int
363xfs_bmap_update_finish_item(
364 struct xfs_trans *tp,
365 struct xfs_log_item *done,
366 struct list_head *item,
367 struct xfs_btree_cur **state)
368{
369 struct xfs_bmap_intent *bmap;
370 xfs_filblks_t count;
371 int error;
372
373 bmap = container_of(item, struct xfs_bmap_intent, bi_list);
374 count = bmap->bi_bmap.br_blockcount;
375 error = xfs_trans_log_finish_bmap_update(tp, BUD_ITEM(done),
376 bmap->bi_type,
377 bmap->bi_owner, bmap->bi_whichfork,
378 bmap->bi_bmap.br_startoff,
379 bmap->bi_bmap.br_startblock,
380 &count,
381 bmap->bi_bmap.br_state);
382 if (!error && count > 0) {
383 ASSERT(bmap->bi_type == XFS_BMAP_UNMAP);
384 bmap->bi_bmap.br_blockcount = count;
385 return -EAGAIN;
386 }
387 kmem_free(bmap);
388 return error;
389}
390
391
392STATIC void
393xfs_bmap_update_abort_intent(
394 struct xfs_log_item *intent)
395{
396 xfs_bui_release(BUI_ITEM(intent));
397}
398
399
400STATIC void
401xfs_bmap_update_cancel_item(
402 struct list_head *item)
403{
404 struct xfs_bmap_intent *bmap;
405
406 bmap = container_of(item, struct xfs_bmap_intent, bi_list);
407 kmem_free(bmap);
408}
409
410const struct xfs_defer_op_type xfs_bmap_update_defer_type = {
411 .max_items = XFS_BUI_MAX_FAST_EXTENTS,
412 .create_intent = xfs_bmap_update_create_intent,
413 .abort_intent = xfs_bmap_update_abort_intent,
414 .create_done = xfs_bmap_update_create_done,
415 .finish_item = xfs_bmap_update_finish_item,
416 .cancel_item = xfs_bmap_update_cancel_item,
417};
418
419
420static inline bool
421xfs_bui_validate(
422 struct xfs_mount *mp,
423 struct xfs_bui_log_item *buip)
424{
425 struct xfs_map_extent *bmap;
426
427
428 if (buip->bui_format.bui_nextents != XFS_BUI_MAX_FAST_EXTENTS)
429 return false;
430
431 bmap = &buip->bui_format.bui_extents[0];
432
433 if (bmap->me_flags & ~XFS_BMAP_EXTENT_FLAGS)
434 return false;
435
436 switch (bmap->me_flags & XFS_BMAP_EXTENT_TYPE_MASK) {
437 case XFS_BMAP_MAP:
438 case XFS_BMAP_UNMAP:
439 break;
440 default:
441 return false;
442 }
443
444 if (!xfs_verify_ino(mp, bmap->me_owner))
445 return false;
446
447 if (!xfs_verify_fileext(mp, bmap->me_startoff, bmap->me_len))
448 return false;
449
450 return xfs_verify_fsbext(mp, bmap->me_startblock, bmap->me_len);
451}
452
453
454
455
456
457STATIC int
458xfs_bui_item_recover(
459 struct xfs_log_item *lip,
460 struct list_head *capture_list)
461{
462 struct xfs_bmbt_irec irec;
463 struct xfs_bui_log_item *buip = BUI_ITEM(lip);
464 struct xfs_trans *tp;
465 struct xfs_inode *ip = NULL;
466 struct xfs_mount *mp = lip->li_mountp;
467 struct xfs_map_extent *bmap;
468 struct xfs_bud_log_item *budp;
469 xfs_filblks_t count;
470 xfs_exntst_t state;
471 unsigned int bui_type;
472 int whichfork;
473 int iext_delta;
474 int error = 0;
475
476 if (!xfs_bui_validate(mp, buip)) {
477 XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp,
478 &buip->bui_format, sizeof(buip->bui_format));
479 return -EFSCORRUPTED;
480 }
481
482 bmap = &buip->bui_format.bui_extents[0];
483 state = (bmap->me_flags & XFS_BMAP_EXTENT_UNWRITTEN) ?
484 XFS_EXT_UNWRITTEN : XFS_EXT_NORM;
485 whichfork = (bmap->me_flags & XFS_BMAP_EXTENT_ATTR_FORK) ?
486 XFS_ATTR_FORK : XFS_DATA_FORK;
487 bui_type = bmap->me_flags & XFS_BMAP_EXTENT_TYPE_MASK;
488
489 error = xlog_recover_iget(mp, bmap->me_owner, &ip);
490 if (error)
491 return error;
492
493
494 error = xfs_trans_alloc(mp, &M_RES(mp)->tr_itruncate,
495 XFS_EXTENTADD_SPACE_RES(mp, XFS_DATA_FORK), 0, 0, &tp);
496 if (error)
497 goto err_rele;
498
499 budp = xfs_trans_get_bud(tp, buip);
500 xfs_ilock(ip, XFS_ILOCK_EXCL);
501 xfs_trans_ijoin(tp, ip, 0);
502
503 if (bui_type == XFS_BMAP_MAP)
504 iext_delta = XFS_IEXT_ADD_NOSPLIT_CNT;
505 else
506 iext_delta = XFS_IEXT_PUNCH_HOLE_CNT;
507
508 error = xfs_iext_count_may_overflow(ip, whichfork, iext_delta);
509 if (error)
510 goto err_cancel;
511
512 count = bmap->me_len;
513 error = xfs_trans_log_finish_bmap_update(tp, budp, bui_type, ip,
514 whichfork, bmap->me_startoff, bmap->me_startblock,
515 &count, state);
516 if (error == -EFSCORRUPTED)
517 XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, bmap,
518 sizeof(*bmap));
519 if (error)
520 goto err_cancel;
521
522 if (count > 0) {
523 ASSERT(bui_type == XFS_BMAP_UNMAP);
524 irec.br_startblock = bmap->me_startblock;
525 irec.br_blockcount = count;
526 irec.br_startoff = bmap->me_startoff;
527 irec.br_state = state;
528 xfs_bmap_unmap_extent(tp, ip, &irec);
529 }
530
531
532
533
534
535 error = xfs_defer_ops_capture_and_commit(tp, ip, capture_list);
536 if (error)
537 goto err_unlock;
538
539 xfs_iunlock(ip, XFS_ILOCK_EXCL);
540 xfs_irele(ip);
541 return 0;
542
543err_cancel:
544 xfs_trans_cancel(tp);
545err_unlock:
546 xfs_iunlock(ip, XFS_ILOCK_EXCL);
547err_rele:
548 xfs_irele(ip);
549 return error;
550}
551
552STATIC bool
553xfs_bui_item_match(
554 struct xfs_log_item *lip,
555 uint64_t intent_id)
556{
557 return BUI_ITEM(lip)->bui_format.bui_id == intent_id;
558}
559
560
561static struct xfs_log_item *
562xfs_bui_item_relog(
563 struct xfs_log_item *intent,
564 struct xfs_trans *tp)
565{
566 struct xfs_bud_log_item *budp;
567 struct xfs_bui_log_item *buip;
568 struct xfs_map_extent *extp;
569 unsigned int count;
570
571 count = BUI_ITEM(intent)->bui_format.bui_nextents;
572 extp = BUI_ITEM(intent)->bui_format.bui_extents;
573
574 tp->t_flags |= XFS_TRANS_DIRTY;
575 budp = xfs_trans_get_bud(tp, BUI_ITEM(intent));
576 set_bit(XFS_LI_DIRTY, &budp->bud_item.li_flags);
577
578 buip = xfs_bui_init(tp->t_mountp);
579 memcpy(buip->bui_format.bui_extents, extp, count * sizeof(*extp));
580 atomic_set(&buip->bui_next_extent, count);
581 xfs_trans_add_item(tp, &buip->bui_item);
582 set_bit(XFS_LI_DIRTY, &buip->bui_item.li_flags);
583 return &buip->bui_item;
584}
585
586static const struct xfs_item_ops xfs_bui_item_ops = {
587 .iop_size = xfs_bui_item_size,
588 .iop_format = xfs_bui_item_format,
589 .iop_unpin = xfs_bui_item_unpin,
590 .iop_release = xfs_bui_item_release,
591 .iop_recover = xfs_bui_item_recover,
592 .iop_match = xfs_bui_item_match,
593 .iop_relog = xfs_bui_item_relog,
594};
595
596
597
598
599
600
601static int
602xfs_bui_copy_format(
603 struct xfs_log_iovec *buf,
604 struct xfs_bui_log_format *dst_bui_fmt)
605{
606 struct xfs_bui_log_format *src_bui_fmt;
607 uint len;
608
609 src_bui_fmt = buf->i_addr;
610 len = xfs_bui_log_format_sizeof(src_bui_fmt->bui_nextents);
611
612 if (buf->i_len == len) {
613 memcpy(dst_bui_fmt, src_bui_fmt, len);
614 return 0;
615 }
616 XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_LOW, NULL);
617 return -EFSCORRUPTED;
618}
619
620
621
622
623
624
625
626
627STATIC int
628xlog_recover_bui_commit_pass2(
629 struct xlog *log,
630 struct list_head *buffer_list,
631 struct xlog_recover_item *item,
632 xfs_lsn_t lsn)
633{
634 int error;
635 struct xfs_mount *mp = log->l_mp;
636 struct xfs_bui_log_item *buip;
637 struct xfs_bui_log_format *bui_formatp;
638
639 bui_formatp = item->ri_buf[0].i_addr;
640
641 if (bui_formatp->bui_nextents != XFS_BUI_MAX_FAST_EXTENTS) {
642 XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_LOW, log->l_mp);
643 return -EFSCORRUPTED;
644 }
645 buip = xfs_bui_init(mp);
646 error = xfs_bui_copy_format(&item->ri_buf[0], &buip->bui_format);
647 if (error) {
648 xfs_bui_item_free(buip);
649 return error;
650 }
651 atomic_set(&buip->bui_next_extent, bui_formatp->bui_nextents);
652
653
654
655
656 xfs_trans_ail_insert(log->l_ailp, &buip->bui_item, lsn);
657 xfs_bui_release(buip);
658 return 0;
659}
660
661const struct xlog_recover_item_ops xlog_bui_item_ops = {
662 .item_type = XFS_LI_BUI,
663 .commit_pass2 = xlog_recover_bui_commit_pass2,
664};
665
666
667
668
669
670
671
672
673STATIC int
674xlog_recover_bud_commit_pass2(
675 struct xlog *log,
676 struct list_head *buffer_list,
677 struct xlog_recover_item *item,
678 xfs_lsn_t lsn)
679{
680 struct xfs_bud_log_format *bud_formatp;
681
682 bud_formatp = item->ri_buf[0].i_addr;
683 if (item->ri_buf[0].i_len != sizeof(struct xfs_bud_log_format)) {
684 XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_LOW, log->l_mp);
685 return -EFSCORRUPTED;
686 }
687
688 xlog_recover_release_intent(log, XFS_LI_BUI, bud_formatp->bud_bui_id);
689 return 0;
690}
691
692const struct xlog_recover_item_ops xlog_bud_item_ops = {
693 .item_type = XFS_LI_BUD,
694 .commit_pass2 = xlog_recover_bud_commit_pass2,
695};
696