35 #include <linux/slab.h>
49 #define SC_N_INODEVEC 16
51 #define SC_MAX_SEGDELTA 64
80 #define NILFS_CF_NODE 0x0001
81 #define NILFS_CF_IFILE_STARTED 0x0002
82 #define NILFS_CF_SUFREED 0x0004
83 #define NILFS_CF_HISTORY_MASK (NILFS_CF_IFILE_STARTED | NILFS_CF_SUFREED)
104 static void nilfs_segctor_start_timer(
struct nilfs_sc_info *);
105 static void nilfs_segctor_do_flush(
struct nilfs_sc_info *,
int);
106 static void nilfs_segctor_do_immediate_flush(
struct nilfs_sc_info *);
109 #define nilfs_cnt32_gt(a, b) \
110 (typecheck(__u32, a) && typecheck(__u32, b) && \
111 ((__s32)(b) - (__s32)(a) < 0))
112 #define nilfs_cnt32_ge(a, b) \
113 (typecheck(__u32, a) && typecheck(__u32, b) && \
114 ((__s32)(a) - (__s32)(b) >= 0))
115 #define nilfs_cnt32_lt(a, b) nilfs_cnt32_gt(b, a)
116 #define nilfs_cnt32_le(a, b) nilfs_cnt32_ge(b, a)
133 "NILFS warning: journal info from a different "
185 int ret = nilfs_prepare_segment_lock(ti);
192 sb_start_intwrite(sb);
239 nilfs_segctor_start_timer(sci);
241 nilfs_segctor_do_flush(sci, 0);
289 nilfs_segctor_do_immediate_flush(sci);
295 static void nilfs_transaction_lock(
struct super_block *sb,
316 nilfs_segctor_do_immediate_flush(sci);
325 static void nilfs_transaction_unlock(
struct super_block *sb)
336 nilfs_dispose_list(nilfs, &ti->
ti_garbage, 0);
339 static void *nilfs_segctor_map_segsum_entry(
struct nilfs_sc_info *sci,
344 unsigned blocksize = sci->
sc_super->s_blocksize;
362 static int nilfs_segctor_reset_segment_buffer(
struct nilfs_sc_info *sci)
365 struct buffer_head *sumbh;
370 if (nilfs_doing_gc())
377 sumbytes = segbuf->
sb_sum.sumbytes;
384 static int nilfs_segctor_feed_segment(
struct nilfs_sc_info *sci)
391 return nilfs_segctor_reset_segment_buffer(sci);
394 static int nilfs_segctor_add_super_root(
struct nilfs_sc_info *sci)
400 err = nilfs_segctor_feed_segment(sci);
414 static int nilfs_segctor_segsum_block_required(
418 unsigned blocksize = sci->
sc_super->s_blocksize;
421 return ssp->
offset + binfo_size +
426 static
void nilfs_segctor_begin_finfo(struct nilfs_sc_info *sci,
431 nilfs_segctor_map_segsum_entry(
434 if (NILFS_I(
inode)->i_root &&
440 static void nilfs_segctor_end_finfo(
struct nilfs_sc_info *sci,
460 finfo = nilfs_segctor_map_segsum_entry(sci, &sci->
sc_finfo_ptr,
474 static int nilfs_segctor_add_file_block(
struct nilfs_sc_info *sci,
475 struct buffer_head *bh,
480 int required, err = 0;
484 required = nilfs_segctor_segsum_block_required(
487 nilfs_segctor_end_finfo(sci, inode);
488 err = nilfs_segctor_feed_segment(sci);
499 nilfs_segctor_begin_finfo(sci, inode);
501 nilfs_segctor_map_segsum_entry(sci, &sci->
sc_binfo_ptr, binfo_size);
503 nilfs_segbuf_add_file_buffer(segbuf, bh);
512 static int nilfs_collect_file_data(
struct nilfs_sc_info *sci,
513 struct buffer_head *bh,
struct inode *inode)
521 err = nilfs_segctor_add_file_block(sci, bh, inode,
528 static int nilfs_collect_file_node(
struct nilfs_sc_info *sci,
529 struct buffer_head *bh,
535 static int nilfs_collect_file_bmap(
struct nilfs_sc_info *sci,
536 struct buffer_head *bh,
540 return nilfs_segctor_add_file_block(sci, bh, inode,
sizeof(
__le64));
543 static void nilfs_write_file_data_binfo(
struct nilfs_sc_info *sci,
547 struct nilfs_binfo_v *binfo_v = nilfs_segctor_map_segsum_entry(
548 sci, ssp,
sizeof(*binfo_v));
549 *binfo_v = binfo->
bi_v;
552 static void nilfs_write_file_node_binfo(
struct nilfs_sc_info *sci,
556 __le64 *vblocknr = nilfs_segctor_map_segsum_entry(
557 sci, ssp,
sizeof(*vblocknr));
558 *vblocknr = binfo->
bi_v.bi_vblocknr;
562 .collect_data = nilfs_collect_file_data,
563 .collect_node = nilfs_collect_file_node,
564 .collect_bmap = nilfs_collect_file_bmap,
565 .write_data_binfo = nilfs_write_file_data_binfo,
566 .write_node_binfo = nilfs_write_file_node_binfo,
570 struct buffer_head *bh,
struct inode *inode)
578 err = nilfs_segctor_add_file_block(sci, bh, inode,
sizeof(
__le64));
585 struct buffer_head *bh,
struct inode *inode)
588 return nilfs_segctor_add_file_block(sci, bh, inode,
592 static void nilfs_write_dat_data_binfo(
struct nilfs_sc_info *sci,
596 __le64 *blkoff = nilfs_segctor_map_segsum_entry(sci, ssp,
598 *blkoff = binfo->
bi_dat.bi_blkoff;
601 static void nilfs_write_dat_node_binfo(
struct nilfs_sc_info *sci,
606 nilfs_segctor_map_segsum_entry(sci, ssp,
sizeof(*binfo_dat));
607 *binfo_dat = binfo->
bi_dat;
611 .collect_data = nilfs_collect_dat_data,
612 .collect_node = nilfs_collect_file_node,
613 .collect_bmap = nilfs_collect_dat_bmap,
614 .write_data_binfo = nilfs_write_dat_data_binfo,
615 .write_node_binfo = nilfs_write_dat_node_binfo,
619 .collect_data = nilfs_collect_file_data,
620 .collect_node =
NULL,
621 .collect_bmap =
NULL,
622 .write_data_binfo = nilfs_write_file_data_binfo,
623 .write_node_binfo =
NULL,
626 static size_t nilfs_lookup_dirty_data_buffers(
struct inode *inode,
646 pagevec_init(&pvec, 0);
654 for (i = 0; i < pagevec_count(&pvec); i++) {
655 struct buffer_head *bh, *
head;
662 if (!page_has_buffers(page))
666 bh = head = page_buffers(page);
668 if (!buffer_dirty(bh))
674 pagevec_release(&pvec);
678 }
while (bh = bh->b_this_page, bh != head);
680 pagevec_release(&pvec);
685 static void nilfs_lookup_dirty_node_buffers(
struct inode *inode,
691 struct buffer_head *bh, *
head;
695 pagevec_init(&pvec, 0);
699 for (i = 0; i < pagevec_count(&pvec); i++) {
700 bh = head = page_buffers(pvec.pages[i]);
702 if (buffer_dirty(bh)) {
707 bh = bh->b_this_page;
708 }
while (bh != head);
710 pagevec_release(&pvec);
715 static void nilfs_dispose_list(
struct the_nilfs *nilfs,
722 while (!list_empty(head)) {
743 for (pii = ivec; nv > 0; pii++, nv--)
744 iput(&(*pii)->vfs_inode);
748 static int nilfs_test_metadata_dirty(
struct the_nilfs *nilfs,
777 if (nilfs_test_metadata_dirty(nilfs, sci->
sc_root))
781 if (list_empty(&nilfs->
ns_dirty_files) && nilfs_segctor_clean(sci))
788 static void nilfs_segctor_clear_metadata_dirty(
struct nilfs_sc_info *sci)
792 nilfs_mdt_clear_dirty(sci->
sc_root->ifile);
795 nilfs_mdt_clear_dirty(nilfs->
ns_dat);
798 static int nilfs_segctor_create_checkpoint(
struct nilfs_sc_info *sci)
801 struct buffer_head *bh_cp;
822 static int nilfs_segctor_fill_in_checkpoint(
struct nilfs_sc_info *sci)
825 struct buffer_head *bh_cp;
847 nilfs_checkpoint_clear_minor(raw_cp);
849 nilfs_checkpoint_set_minor(raw_cp);
860 static void nilfs_fill_in_file_bmap(
struct inode *ifile,
864 struct buffer_head *ibh;
870 raw_inode = nilfs_ifile_map_inode(ifile, ii->
vfs_inode.i_ino,
873 nilfs_ifile_unmap_inode(ifile, ii->
vfs_inode.i_ino, ibh);
877 static void nilfs_segctor_fill_in_file_bmap(
struct nilfs_sc_info *sci)
882 nilfs_fill_in_file_bmap(sci->
sc_root->ifile, ii);
887 static void nilfs_segctor_fill_in_super_root(
struct nilfs_sc_info *sci,
890 struct buffer_head *bh_sr;
914 static void nilfs_redirty_inodes(
struct list_head *head)
924 static void nilfs_drop_collected_inodes(
struct list_head *head)
937 static int nilfs_segctor_apply_buffers(
struct nilfs_sc_info *sci,
941 struct buffer_head *,
944 struct buffer_head *bh, *
n;
949 list_del_init(&bh->b_assoc_buffers);
950 err = collect(sci, bh, inode);
953 goto dispose_buffers;
959 while (!list_empty(listp)) {
962 list_del_init(&bh->b_assoc_buffers);
968 static size_t nilfs_segctor_buffer_rest(
struct nilfs_sc_info *sci)
975 static int nilfs_segctor_scan_file(
struct nilfs_sc_info *sci,
984 size_t n,
rest = nilfs_segctor_buffer_rest(sci);
986 n = nilfs_lookup_dirty_data_buffers(
987 inode, &data_buffers, rest + 1, 0,
LLONG_MAX);
989 err = nilfs_segctor_apply_buffers(
990 sci, inode, &data_buffers,
996 nilfs_lookup_dirty_node_buffers(inode, &node_buffers);
999 err = nilfs_segctor_apply_buffers(
1003 nilfs_segctor_apply_buffers(
1004 sci, inode, &node_buffers,
NULL);
1010 err = nilfs_segctor_apply_buffers(
1016 err = nilfs_segctor_apply_buffers(
1021 nilfs_segctor_end_finfo(sci, inode);
1028 static int nilfs_segctor_scan_file_dsync(
struct nilfs_sc_info *sci,
1029 struct inode *inode)
1032 size_t n, rest = nilfs_segctor_buffer_rest(sci);
1035 n = nilfs_lookup_dirty_data_buffers(inode, &data_buffers, rest + 1,
1039 err = nilfs_segctor_apply_buffers(sci, inode, &data_buffers,
1040 nilfs_collect_file_data);
1042 nilfs_segctor_end_finfo(sci, inode);
1079 if (nilfs_doing_gc()) {
1084 err = nilfs_segctor_scan_file(
1086 &nilfs_sc_file_ops);
1106 err = nilfs_segctor_scan_file(sci, &ii->
vfs_inode,
1107 &nilfs_sc_file_ops);
1127 err = nilfs_segctor_scan_file(sci, sci->
sc_root->ifile,
1128 &nilfs_sc_file_ops);
1133 err = nilfs_segctor_create_checkpoint(sci);
1138 err = nilfs_segctor_scan_file(sci, nilfs->
ns_cpfile,
1139 &nilfs_sc_file_ops);
1147 nilfs_sufile_cancel_freev(nilfs->
ns_sufile,
1154 err = nilfs_segctor_scan_file(sci, nilfs->
ns_sufile,
1155 &nilfs_sc_file_ops);
1161 err = nilfs_segctor_scan_file(sci, nilfs->
ns_dat,
1173 err = nilfs_segctor_add_super_root(sci);
1188 err = nilfs_segctor_scan_file_dsync(sci, &ii->
vfs_inode);
1209 static int nilfs_segctor_begin_construction(
struct nilfs_sc_info *sci,
1224 nilfs_shift_to_next_segment(nilfs);
1243 segbuf->
sb_sum.seg_seq++;
1269 static int nilfs_segctor_extend_segments(
struct nilfs_sc_info *sci,
1273 struct inode *sufile = nilfs->
ns_sufile;
1289 for (i = 0; i < nadd; i++) {
1318 ret = nilfs_sufile_free(sufile, segbuf->
sb_nextnum);
1321 nilfs_destroy_logs(&
list);
1325 static void nilfs_free_incomplete_logs(
struct list_head *
logs,
1329 struct inode *sufile = nilfs->
ns_sufile;
1334 ret = nilfs_sufile_free(sufile, segbuf->
sb_nextnum);
1345 set_nilfs_discontinued(nilfs);
1351 ret = nilfs_sufile_free(sufile, segbuf->
sb_nextnum);
1357 nilfs_sufile_set_error(sufile, segbuf->
sb_segnum);
1362 static void nilfs_segctor_update_segusage(
struct nilfs_sc_info *sci,
1363 struct inode *sufile)
1366 unsigned long live_blocks;
1370 live_blocks = segbuf->
sb_sum.nblocks +
1379 static void nilfs_cancel_segusage(
struct list_head *logs,
struct inode *sufile)
1397 static void nilfs_segctor_truncate_segments(
struct nilfs_sc_info *sci,
1399 struct inode *sufile)
1406 ret = nilfs_sufile_free(sufile, segbuf->
sb_nextnum);
1424 err = nilfs_segctor_reset_segment_buffer(sci);
1428 err = nilfs_segctor_collect_blocks(sci, mode);
1442 err = nilfs_segctor_extend_segments(sci, nilfs, nadd);
1447 err = nilfs_sufile_cancel_freev(nilfs->
ns_sufile,
1463 static void nilfs_list_replace_buffer(
struct buffer_head *old_bh,
1464 struct buffer_head *new_bh)
1466 BUG_ON(!list_empty(&new_bh->b_assoc_buffers));
1468 list_replace_init(&old_bh->b_assoc_buffers, &new_bh->b_assoc_buffers);
1473 nilfs_segctor_update_payload_blocknr(
struct nilfs_sc_info *sci,
1477 struct inode *inode =
NULL;
1479 unsigned long nfinfo = segbuf->
sb_sum.nfinfo;
1480 unsigned long nblocks = 0, ndatablk = 0;
1485 struct buffer_head *bh, *bh_org;
1500 finfo = nilfs_segctor_map_segsum_entry(
1501 sci, &ssp,
sizeof(*finfo));
1506 inode = bh->b_page->mapping->host;
1509 sc_op = &nilfs_sc_dsync_ops;
1511 sc_op = &nilfs_sc_dat_ops;
1513 sc_op = &nilfs_sc_file_ops;
1520 nilfs_list_replace_buffer(bh_org, bh);
1531 if (--nblocks == 0) {
1535 }
else if (ndatablk > 0)
1545 static int nilfs_segctor_assign(
struct nilfs_sc_info *sci,
int mode)
1551 err = nilfs_segctor_update_payload_blocknr(sci, segbuf, mode);
1559 static void nilfs_begin_page_io(
struct page *page)
1561 if (!page || PageWriteback(page))
1568 set_page_writeback(page);
1572 static void nilfs_segctor_prepare_write(
struct nilfs_sc_info *sci)
1575 struct page *bd_page =
NULL, *fs_page =
NULL;
1578 struct buffer_head *bh;
1582 if (bh->b_page != bd_page) {
1586 set_page_writeback(bd_page);
1589 bd_page = bh->b_page;
1596 if (bh->b_page != bd_page) {
1599 set_page_writeback(bd_page);
1601 bd_page = bh->b_page;
1605 if (bh->b_page != fs_page) {
1606 nilfs_begin_page_io(fs_page);
1607 fs_page = bh->b_page;
1614 set_page_writeback(bd_page);
1617 nilfs_begin_page_io(fs_page);
1630 static void nilfs_end_page_io(
struct page *page,
int err)
1635 if (buffer_nilfs_node(page_buffers(page)) && !PageWriteback(page)) {
1640 if (PageDirty(page)) {
1659 ClearPageError(page);
1668 static void nilfs_abort_logs(
struct list_head *logs,
int err)
1671 struct page *bd_page =
NULL, *fs_page =
NULL;
1672 struct buffer_head *bh;
1674 if (list_empty(logs))
1680 if (bh->b_page != bd_page) {
1683 bd_page = bh->b_page;
1690 if (bh->b_page != bd_page) {
1692 bd_page = bh->b_page;
1696 if (bh->b_page != fs_page) {
1697 nilfs_end_page_io(fs_page, err);
1698 fs_page = bh->b_page;
1705 nilfs_end_page_io(fs_page, err);
1708 static void nilfs_segctor_abort_construction(
struct nilfs_sc_info *sci,
1716 nilfs_abort_logs(&logs, ret ? : err);
1718 list_splice_tail_init(&sci->
sc_segbufs, &logs);
1719 nilfs_cancel_segusage(&logs, nilfs->
ns_sufile);
1720 nilfs_free_incomplete_logs(&logs, nilfs);
1723 ret = nilfs_sufile_cancel_freev(nilfs->
ns_sufile,
1730 nilfs_destroy_logs(&logs);
1733 static void nilfs_set_next_segment(
struct the_nilfs *nilfs,
1739 + segbuf->
sb_sum.nblocks;
1744 static void nilfs_segctor_complete_write(
struct nilfs_sc_info *sci)
1747 struct page *bd_page =
NULL, *fs_page =
NULL;
1749 int update_sr =
false;
1752 struct buffer_head *bh;
1756 set_buffer_uptodate(bh);
1757 clear_buffer_dirty(bh);
1758 if (bh->b_page != bd_page) {
1761 bd_page = bh->b_page;
1777 set_buffer_uptodate(bh);
1778 clear_buffer_dirty(bh);
1779 clear_buffer_delay(bh);
1780 clear_buffer_nilfs_volatile(bh);
1781 clear_buffer_nilfs_redirected(bh);
1783 if (bh->b_page != bd_page) {
1785 bd_page = bh->b_page;
1790 if (bh->b_page != fs_page) {
1791 nilfs_end_page_io(fs_page, 0);
1792 fs_page = bh->b_page;
1796 if (!nilfs_segbuf_simplex(segbuf)) {
1812 nilfs_end_page_io(fs_page, 0);
1816 if (nilfs_doing_gc())
1824 nilfs_set_next_segment(nilfs, segbuf);
1833 nilfs_segctor_clear_metadata_dirty(sci);
1844 nilfs_segctor_complete_write(sci);
1850 static int nilfs_segctor_collect_dirty_files(
struct nilfs_sc_info *sci,
1854 struct inode *ifile = sci->
sc_root->ifile;
1860 struct buffer_head *ibh;
1868 "failed to get inode block.\n");
1872 nilfs_mdt_mark_dirty(ifile);
1890 static void nilfs_segctor_drop_written_files(
struct nilfs_sc_info *sci,
1913 static int nilfs_segctor_do_construct(
struct nilfs_sc_info *sci,
int mode)
1921 err = nilfs_segctor_collect_dirty_files(sci, nilfs);
1925 if (nilfs_test_metadata_dirty(nilfs, sci->
sc_root))
1928 if (nilfs_segctor_clean(sci))
1934 err = nilfs_segctor_begin_construction(sci, nilfs);
1941 err = nilfs_segctor_collect(sci, nilfs, mode);
1948 nilfs_segctor_abort_construction(sci, nilfs, 1);
1952 err = nilfs_segctor_assign(sci, mode);
1957 nilfs_segctor_fill_in_file_bmap(sci);
1961 err = nilfs_segctor_fill_in_checkpoint(sci);
1963 goto failed_to_write;
1965 nilfs_segctor_fill_in_super_root(sci, nilfs);
1967 nilfs_segctor_update_segusage(sci, nilfs->
ns_sufile);
1970 nilfs_segctor_prepare_write(sci);
1975 err = nilfs_segctor_write(sci, nilfs);
1977 goto failed_to_write;
1988 err = nilfs_segctor_wait(sci);
1990 goto failed_to_write;
1995 nilfs_segctor_drop_written_files(sci, nilfs);
2003 if (nilfs_doing_gc())
2005 nilfs_segctor_abort_construction(sci, nilfs, err);
2017 static void nilfs_segctor_start_timer(
struct nilfs_sc_info *sci)
2028 static void nilfs_segctor_do_flush(
struct nilfs_sc_info *sci,
int bn)
2051 if (!sci || nilfs_doing_construction())
2076 init_waitqueue_entry(&wait_req.
wq,
current);
2086 if (!signal_pending(
current)) {
2097 static void nilfs_segctor_wakeup(
struct nilfs_sc_info *sci,
int err)
2100 unsigned long flags;
2149 err = nilfs_segctor_sync(sci);
2174 loff_t start, loff_t end)
2185 nilfs_transaction_lock(sb, &ti, 0);
2187 ii = NILFS_I(inode);
2191 nilfs_discontinued(nilfs)) {
2192 nilfs_transaction_unlock(sb);
2193 err = nilfs_segctor_sync(sci);
2201 nilfs_transaction_unlock(sb);
2211 nilfs_transaction_unlock(sb);
2215 #define FLUSH_FILE_BIT (0x1)
2216 #define FLUSH_DAT_BIT (1 << NILFS_DAT_INO)
2236 static void nilfs_segctor_notify(
struct nilfs_sc_info *sci,
int mode,
int err)
2244 nilfs_segctor_wakeup(sci, err);
2265 static int nilfs_segctor_construct(
struct nilfs_sc_info *sci,
int mode)
2271 nilfs_segctor_accept(sci);
2273 if (nilfs_discontinued(nilfs))
2275 if (!nilfs_segctor_confirm(sci))
2276 err = nilfs_segctor_do_construct(sci, mode);
2282 nilfs_discontinued(nilfs)) {
2286 nilfs_sb_will_flip(nilfs));
2296 nilfs_segctor_notify(sci, mode, err);
2300 static void nilfs_construction_timeout(
unsigned long data)
2332 nilfs_transaction_lock(sb, &ti, 1);
2349 err = nilfs_segctor_construct(sci,
SC_LSEG_SR);
2350 nilfs_remove_written_gcinodes(nilfs, &sci->
sc_gc_inodes);
2356 "segment construction failed. (err=%d)", err);
2365 "NILFS warning: error %d on discard request, "
2366 "turning discards off for the device\n", ret);
2375 nilfs_transaction_unlock(sb);
2379 static void nilfs_segctor_thread_construct(
struct nilfs_sc_info *sci,
int mode)
2383 nilfs_transaction_lock(sci->
sc_super, &ti, 0);
2384 nilfs_segctor_construct(sci, mode);
2392 nilfs_segctor_start_timer(sci);
2394 nilfs_transaction_unlock(sci->
sc_super);
2397 static void nilfs_segctor_do_immediate_flush(
struct nilfs_sc_info *sci)
2408 err = nilfs_segctor_do_construct(sci, mode);
2418 static int nilfs_segctor_flush_mode(
struct nilfs_sc_info *sci)
2437 static int nilfs_segctor_thread(
void *
arg)
2444 sci->
sc_timer.function = nilfs_construction_timeout;
2450 "segctord starting. Construction interval = %lu seconds, "
2451 "CP frequency < %lu seconds\n",
2467 mode = nilfs_segctor_flush_mode(sci);
2470 nilfs_segctor_thread_construct(sci, mode);
2482 int should_sleep = 1;
2504 if (nilfs_sb_dirty(nilfs) && nilfs_sb_need_update(nilfs))
2505 set_nilfs_discontinued(nilfs);
2518 static int nilfs_segctor_start_thread(
struct nilfs_sc_info *sci)
2522 t =
kthread_run(nilfs_segctor_thread, sci,
"segctord");
2524 int err = PTR_ERR(t);
2534 static void nilfs_segctor_kill_thread(
struct nilfs_sc_info *sci)
2563 nilfs_get_root(root);
2587 static void nilfs_segctor_write_out(
struct nilfs_sc_info *sci)
2596 nilfs_transaction_lock(sci->
sc_super, &ti, 0);
2597 ret = nilfs_segctor_construct(sci,
SC_LSEG_SR);
2598 nilfs_transaction_unlock(sci->
sc_super);
2600 }
while (ret && retrycount-- > 0);
2611 static void nilfs_segctor_destroy(
struct nilfs_sc_info *sci)
2619 nilfs_segctor_kill_thread(sci);
2624 if (flag || !nilfs_segctor_confirm(sci))
2625 nilfs_segctor_write_out(sci);
2629 "dirty file(s) after the final construction\n");
2671 nilfs->
ns_writer = nilfs_segctor_new(sb, root);
2675 err = nilfs_segctor_start_thread(nilfs->
ns_writer);
2697 nilfs_segctor_destroy(nilfs->
ns_writer);
2706 "Hit dirty file after stopped log writer\n");
2711 nilfs_dispose_list(nilfs, &garbage_list, 1);