From: Vyacheslav Dubeyko <[email protected]> Subject: [PATCH 07/24] nilfs2: implement segments subsystem debugging output
This patch adds debugging output by means of nilfs2_debug() method into modules that are grouped by segments subsystem debugging output option (CONFIG_NILFS2_DEBUG_SEGMENTS_SUBSYSTEM). Signed-off-by: Vyacheslav Dubeyko <[email protected]> CC: Ryusuke Konishi <[email protected]> --- fs/nilfs2/segbuf.c | 30 +++++++ fs/nilfs2/segment.c | 247 ++++++++++++++++++++++++++++++++++++++++++++++++++- 2 files changed, 274 insertions(+), 3 deletions(-) diff --git a/fs/nilfs2/segbuf.c b/fs/nilfs2/segbuf.c index dc9a913..6ee75b1 100644 --- a/fs/nilfs2/segbuf.c +++ b/fs/nilfs2/segbuf.c @@ -73,6 +73,10 @@ void nilfs_segbuf_free(struct nilfs_segment_buffer *segbuf) void nilfs_segbuf_map(struct nilfs_segment_buffer *segbuf, __u64 segnum, unsigned long offset, struct the_nilfs *nilfs) { + nilfs2_debug(DBG_SEGBUF, + "segbuf %p, segnum %llu, offset %lu, nilfs %p\n", + segbuf, segnum, offset, nilfs); + segbuf->sb_segnum = segnum; nilfs_get_segment_range(nilfs, segnum, &segbuf->sb_fseg_start, &segbuf->sb_fseg_end); @@ -90,6 +94,10 @@ void nilfs_segbuf_map(struct nilfs_segment_buffer *segbuf, __u64 segnum, void nilfs_segbuf_map_cont(struct nilfs_segment_buffer *segbuf, struct nilfs_segment_buffer *prev) { + nilfs2_debug(DBG_SEGBUF, + "prev->sb_segnum %llu, prev->sb_pseg_start %lu\n", + prev->sb_segnum, prev->sb_pseg_start); + segbuf->sb_segnum = prev->sb_segnum; segbuf->sb_fseg_start = prev->sb_fseg_start; segbuf->sb_fseg_end = prev->sb_fseg_end; @@ -109,6 +117,10 @@ int nilfs_segbuf_extend_segsum(struct nilfs_segment_buffer *segbuf) { struct buffer_head *bh; + nilfs2_debug(DBG_SEGBUF, + "sb_segnum %llu, sb_pseg_start %lu\n", + segbuf->sb_segnum, segbuf->sb_pseg_start); + bh = sb_getblk(segbuf->sb_super, segbuf->sb_pseg_start + segbuf->sb_sum.nsumblk); if (unlikely(!bh)) @@ -123,6 +135,10 @@ int nilfs_segbuf_extend_payload(struct nilfs_segment_buffer *segbuf, { struct buffer_head *bh; + nilfs2_debug(DBG_SEGBUF, + "sb_segnum %llu, sb_pseg_start %lu, bhp %p\n", + segbuf->sb_segnum, segbuf->sb_pseg_start, bhp); + bh = sb_getblk(segbuf->sb_super, segbuf->sb_pseg_start + segbuf->sb_sum.nblocks); if (unlikely(!bh)) @@ -138,6 +154,12 @@ int nilfs_segbuf_reset(struct nilfs_segment_buffer *segbuf, unsigned flags, { int err; + nilfs2_debug(DBG_SEGBUF, + "sb_segnum %llu, sb_pseg_start %lu, " + "flags %#x, ctime %lu, cno %llu\n", + segbuf->sb_segnum, segbuf->sb_pseg_start, + flags, ctime, cno); + segbuf->sb_sum.nblocks = segbuf->sb_sum.nsumblk = 0; err = nilfs_segbuf_extend_segsum(segbuf); if (unlikely(err)) @@ -159,6 +181,10 @@ void nilfs_segbuf_fill_in_segsum(struct nilfs_segment_buffer *segbuf) struct nilfs_segment_summary *raw_sum; struct buffer_head *bh_sum; + nilfs2_debug(DBG_SEGBUF, + "sb_segnum %llu, sb_pseg_start %lu\n", + segbuf->sb_segnum, segbuf->sb_pseg_start); + bh_sum = list_entry(segbuf->sb_segsum_buffers.next, struct buffer_head, b_assoc_buffers); raw_sum = (struct nilfs_segment_summary *)bh_sum->b_data; @@ -263,6 +289,10 @@ static void nilfs_release_buffers(struct list_head *list) static void nilfs_segbuf_clear(struct nilfs_segment_buffer *segbuf) { + nilfs2_debug(DBG_SEGBUF, + "sb_segnum %llu, sb_pseg_start %lu\n", + segbuf->sb_segnum, segbuf->sb_pseg_start); + nilfs_release_buffers(&segbuf->sb_segsum_buffers); nilfs_release_buffers(&segbuf->sb_payload_buffers); segbuf->sb_super_root = NULL; diff --git a/fs/nilfs2/segment.c b/fs/nilfs2/segment.c index a5752a58..98b3f96 100644 --- a/fs/nilfs2/segment.c +++ b/fs/nilfs2/segment.c @@ -147,6 +147,11 @@ static int nilfs_prepare_segment_lock(struct nilfs_transaction_info *ti) ti->ti_save = save; ti->ti_magic = NILFS_TI_MAGIC; current->journal_info = ti; + + nilfs2_debug(DBG_SEGMENT, + "ti_magic %#x, ti_flags %#hx, ti_count %hu\n", + ti->ti_magic, ti->ti_flags, ti->ti_count); + return 0; } @@ -182,8 +187,13 @@ int nilfs_transaction_begin(struct super_block *sb, int vacancy_check) { struct the_nilfs *nilfs; - int ret = nilfs_prepare_segment_lock(ti); + int ret; + nilfs2_debug(DBG_SEGMENT, + "sb %p, ti %p, vacancy_check %d\n", + sb, ti, vacancy_check); + + ret = nilfs_prepare_segment_lock(ti); if (unlikely(ret < 0)) return ret; if (ret > 0) @@ -227,6 +237,11 @@ int nilfs_transaction_commit(struct super_block *sb) int err = 0; BUG_ON(ti == NULL || ti->ti_magic != NILFS_TI_MAGIC); + + nilfs2_debug(DBG_SEGMENT, + "ti_magic %#x, ti_flags %#hx, ti_count %hu\n", + ti->ti_magic, ti->ti_flags, ti->ti_count); + ti->ti_flags |= NILFS_TI_COMMIT; if (ti->ti_count > 0) { ti->ti_count--; @@ -257,6 +272,11 @@ void nilfs_transaction_abort(struct super_block *sb) struct the_nilfs *nilfs = sb->s_fs_info; BUG_ON(ti == NULL || ti->ti_magic != NILFS_TI_MAGIC); + + nilfs2_debug(DBG_SEGMENT, + "ti_magic %#x, ti_flags %#hx, ti_count %hu\n", + ti->ti_magic, ti->ti_flags, ti->ti_count); + if (ti->ti_count > 0) { ti->ti_count--; return; @@ -308,6 +328,12 @@ static void nilfs_transaction_lock(struct super_block *sb, INIT_LIST_HEAD(&ti->ti_garbage); current->journal_info = ti; + nilfs2_debug(DBG_SEGMENT, + "ti_magic %#x, ti_flags %#hx, " + "ti_count %hu, gcflag %d\n", + ti->ti_magic, ti->ti_flags, + ti->ti_count, gcflag); + for (;;) { down_write(&nilfs->ns_segctor_sem); if (!test_bit(NILFS_SC_PRIOR_FLUSH, &sci->sc_flags)) @@ -330,6 +356,10 @@ static void nilfs_transaction_unlock(struct super_block *sb) BUG_ON(ti == NULL || ti->ti_magic != NILFS_TI_MAGIC); BUG_ON(ti->ti_count > 0); + nilfs2_debug(DBG_SEGMENT, + "ti_magic %#x, ti_flags %#hx, ti_count %hu\n", + ti->ti_magic, ti->ti_flags, ti->ti_count); + up_write(&nilfs->ns_segctor_sem); current->journal_info = ti->ti_save; if (!list_empty(&ti->ti_garbage)) @@ -344,6 +374,10 @@ static void *nilfs_segctor_map_segsum_entry(struct nilfs_sc_info *sci, unsigned blocksize = sci->sc_super->s_blocksize; void *p; + nilfs2_debug(DBG_SEGMENT, + "sci %p, segnum %llu, ssp->offset %u, bytes %u\n", + sci, segbuf->sb_segnum, ssp->offset, bytes); + if (unlikely(ssp->offset + bytes > blocksize)) { ssp->offset = 0; BUG_ON(NILFS_SEGBUF_BH_IS_LAST(ssp->bh, @@ -367,6 +401,10 @@ static int nilfs_segctor_reset_segment_buffer(struct nilfs_sc_info *sci) unsigned flags = 0; int err; + nilfs2_debug(DBG_SEGMENT, + "sci %p, segnum %llu, cno %llu\n", + sci, segbuf->sb_segnum, sci->sc_cno); + if (nilfs_doing_gc()) flags = NILFS_SS_GC; err = nilfs_segbuf_reset(segbuf, flags, sci->sc_seg_ctime, sci->sc_cno); @@ -383,6 +421,8 @@ static int nilfs_segctor_reset_segment_buffer(struct nilfs_sc_info *sci) static int nilfs_segctor_feed_segment(struct nilfs_sc_info *sci) { + nilfs2_debug(DBG_SEGMENT, "sci %p\n", sci); + sci->sc_nblk_this_inc += sci->sc_curseg->sb_sum.nblocks; if (NILFS_SEGBUF_IS_LAST(sci->sc_curseg, &sci->sc_segbufs)) return -E2BIG; /* The current segment is filled up @@ -396,6 +436,9 @@ static int nilfs_segctor_add_super_root(struct nilfs_sc_info *sci) struct nilfs_segment_buffer *segbuf = sci->sc_curseg; int err; + nilfs2_debug(DBG_SEGMENT, + "sci %p, segnum %llu\n", sci, segbuf->sb_segnum); + if (segbuf->sb_sum.nblocks >= segbuf->sb_rest_blocks) { err = nilfs_segctor_feed_segment(sci); if (err) @@ -426,6 +469,9 @@ static int nilfs_segctor_segsum_block_required( static void nilfs_segctor_begin_finfo(struct nilfs_sc_info *sci, struct inode *inode) { + nilfs2_debug(DBG_SEGMENT, + "sci %p, i_ino %lu\n", sci, inode->i_ino); + sci->sc_curseg->sb_sum.nfinfo++; sci->sc_binfo_ptr = sci->sc_finfo_ptr; nilfs_segctor_map_segsum_entry( @@ -445,6 +491,10 @@ static void nilfs_segctor_end_finfo(struct nilfs_sc_info *sci, struct nilfs_segment_buffer *segbuf; __u64 cno; + nilfs2_debug(DBG_SEGMENT, + "sci %p, i_ino %lu, segnum %llu\n", + sci, inode->i_ino, sci->sc_curseg->sb_segnum); + if (sci->sc_blk_cnt == 0) return; @@ -479,6 +529,11 @@ static int nilfs_segctor_add_file_block(struct nilfs_sc_info *sci, struct nilfs_segment_buffer *segbuf; int required, err = 0; + nilfs2_debug(DBG_SEGMENT, + "sci %p, ino %lu, segnum %llu, bh %p, binfo_size %u\n", + sci, inode->i_ino, sci->sc_curseg->sb_segnum, + bh, binfo_size); + retry: segbuf = sci->sc_curseg; required = nilfs_segctor_segsum_block_required( @@ -514,6 +569,9 @@ static int nilfs_collect_file_data(struct nilfs_sc_info *sci, { int err; + nilfs2_debug(DBG_SEGMENT, + "sci %p, i_ino %lu, bh %p\n", sci, inode->i_ino, bh); + err = nilfs_bmap_propagate(NILFS_I(inode)->i_bmap, bh); if (err < 0) return err; @@ -529,6 +587,9 @@ static int nilfs_collect_file_node(struct nilfs_sc_info *sci, struct buffer_head *bh, struct inode *inode) { + nilfs2_debug(DBG_SEGMENT, + "sci %p, i_ino %lu, bh %p\n", sci, inode->i_ino, bh); + return nilfs_bmap_propagate(NILFS_I(inode)->i_bmap, bh); } @@ -536,6 +597,9 @@ static int nilfs_collect_file_bmap(struct nilfs_sc_info *sci, struct buffer_head *bh, struct inode *inode) { + nilfs2_debug(DBG_SEGMENT, + "sci %p, i_ino %lu, bh %p\n", sci, inode->i_ino, bh); + WARN_ON(!buffer_dirty(bh)); return nilfs_segctor_add_file_block(sci, bh, inode, sizeof(__le64)); } @@ -571,6 +635,9 @@ static int nilfs_collect_dat_data(struct nilfs_sc_info *sci, { int err; + nilfs2_debug(DBG_SEGMENT, + "sci %p, i_ino %lu, bh %p\n", sci, inode->i_ino, bh); + err = nilfs_bmap_propagate(NILFS_I(inode)->i_bmap, bh); if (err < 0) return err; @@ -634,6 +701,10 @@ static size_t nilfs_lookup_dirty_data_buffers(struct inode *inode, size_t ndirties = 0; int i; + nilfs2_debug(DBG_SEGMENT, + "i_ino %lu, nlimit %zu, start %llu, end %llu\n", + inode->i_ino, nlimit, start, end); + if (unlikely(start != 0 || end != LLONG_MAX)) { /* * A valid range is given for sync-ing data pages. The @@ -692,6 +763,9 @@ static void nilfs_lookup_dirty_node_buffers(struct inode *inode, unsigned int i; pgoff_t index = 0; + nilfs2_debug(DBG_SEGMENT, + "i_ino %lu, listp %p\n", inode->i_ino, listp); + pagevec_init(&pvec, 0); while (pagevec_lookup_tag(&pvec, mapping, &index, PAGECACHE_TAG_DIRTY, @@ -719,6 +793,9 @@ static void nilfs_dispose_list(struct the_nilfs *nilfs, struct nilfs_inode_info *ivec[SC_N_INODEVEC], **pii; unsigned nv = 0; + nilfs2_debug(DBG_SEGMENT, + "nilfs %p, head %p, force %d\n", nilfs, head, force); + while (!list_empty(head)) { spin_lock(&nilfs->ns_inode_lock); list_for_each_entry_safe(ii, n, head, i_dirty) { @@ -758,6 +835,9 @@ static int nilfs_test_metadata_dirty(struct the_nilfs *nilfs, ret++; if ((ret || nilfs_doing_gc()) && nilfs_mdt_fetch_dirty(nilfs->ns_dat)) ret++; + + nilfs2_debug(DBG_SEGMENT, "ret %d\n", ret); + return ret; } @@ -782,6 +862,9 @@ static int nilfs_segctor_confirm(struct nilfs_sc_info *sci) ret++; spin_unlock(&nilfs->ns_inode_lock); + + nilfs2_debug(DBG_SEGMENT, "ret %d\n", ret); + return ret; } @@ -789,6 +872,8 @@ static void nilfs_segctor_clear_metadata_dirty(struct nilfs_sc_info *sci) { struct the_nilfs *nilfs = sci->sc_super->s_fs_info; + nilfs2_debug(DBG_SEGMENT, "sci %p\n", sci); + nilfs_mdt_clear_dirty(sci->sc_root->ifile); nilfs_mdt_clear_dirty(nilfs->ns_cpfile); nilfs_mdt_clear_dirty(nilfs->ns_sufile); @@ -802,6 +887,8 @@ static int nilfs_segctor_create_checkpoint(struct nilfs_sc_info *sci) struct nilfs_checkpoint *raw_cp; int err; + nilfs2_debug(DBG_SEGMENT, "sci %p\n", sci); + /* XXX: this interface will be changed */ err = nilfs_cpfile_get_checkpoint(nilfs->ns_cpfile, nilfs->ns_cno, 1, &raw_cp, &bh_cp); @@ -826,6 +913,8 @@ static int nilfs_segctor_fill_in_checkpoint(struct nilfs_sc_info *sci) struct nilfs_checkpoint *raw_cp; int err; + nilfs2_debug(DBG_SEGMENT, "sci %p\n", sci); + err = nilfs_cpfile_get_checkpoint(nilfs->ns_cpfile, nilfs->ns_cno, 0, &raw_cp, &bh_cp); if (unlikely(err)) { @@ -864,6 +953,9 @@ static void nilfs_fill_in_file_bmap(struct inode *ifile, struct buffer_head *ibh; struct nilfs_inode *raw_inode; + nilfs2_debug(DBG_SEGMENT, + "i_ino %lu\n", ii->vfs_inode.i_ino); + if (test_bit(NILFS_I_BMAP, &ii->i_state)) { ibh = ii->i_bh; BUG_ON(!ibh); @@ -878,6 +970,8 @@ static void nilfs_segctor_fill_in_file_bmap(struct nilfs_sc_info *sci) { struct nilfs_inode_info *ii; + nilfs2_debug(DBG_SEGMENT, "sci %p\n", sci); + list_for_each_entry(ii, &sci->sc_dirty_files, i_dirty) { nilfs_fill_in_file_bmap(sci->sc_root->ifile, ii); set_bit(NILFS_I_COLLECTED, &ii->i_state); @@ -891,6 +985,9 @@ static void nilfs_segctor_fill_in_super_root(struct nilfs_sc_info *sci, struct nilfs_super_root *raw_sr; unsigned isz, srsz; + nilfs2_debug(DBG_SEGMENT, + "sci %p, nilfs %p\n", sci, nilfs); + bh_sr = NILFS_LAST_SEGBUF(&sci->sc_segbufs)->sb_super_root; raw_sr = (struct nilfs_super_root *)bh_sr->b_data; isz = nilfs->ns_inode_size; @@ -916,8 +1013,11 @@ static void nilfs_redirty_inodes(struct list_head *head) struct nilfs_inode_info *ii; list_for_each_entry(ii, head, i_dirty) { - if (test_bit(NILFS_I_COLLECTED, &ii->i_state)) + if (test_bit(NILFS_I_COLLECTED, &ii->i_state)) { + nilfs2_debug(DBG_SEGMENT, + "i_ino %lu\n", ii->vfs_inode.i_ino); clear_bit(NILFS_I_COLLECTED, &ii->i_state); + } } } @@ -929,6 +1029,7 @@ static void nilfs_drop_collected_inodes(struct list_head *head) if (!test_and_clear_bit(NILFS_I_COLLECTED, &ii->i_state)) continue; + nilfs2_debug(DBG_SEGMENT, "i_ino %lu\n", ii->vfs_inode.i_ino); clear_bit(NILFS_I_INODE_DIRTY, &ii->i_state); set_bit(NILFS_I_UPDATED, &ii->i_state); } @@ -944,6 +1045,10 @@ static int nilfs_segctor_apply_buffers(struct nilfs_sc_info *sci, struct buffer_head *bh, *n; int err = 0; + nilfs2_debug(DBG_SEGMENT, + "sci %p, i_ino %lu, listp %p, collect %p\n", + sci, inode->i_ino, listp, collect); + if (collect) { list_for_each_entry_safe(bh, n, listp, b_assoc_buffers) { list_del_init(&bh->b_assoc_buffers); @@ -980,6 +1085,10 @@ static int nilfs_segctor_scan_file(struct nilfs_sc_info *sci, LIST_HEAD(node_buffers); int err; + nilfs2_debug(DBG_SEGMENT, + "sci %p, i_ino %lu, sc_ops %p\n", + sci, inode->i_ino, sc_ops); + if (!(sci->sc_stage.flags & NILFS_CF_NODE)) { size_t n, rest = nilfs_segctor_buffer_rest(sci); @@ -1032,6 +1141,9 @@ static int nilfs_segctor_scan_file_dsync(struct nilfs_sc_info *sci, size_t n, rest = nilfs_segctor_buffer_rest(sci); int err; + nilfs2_debug(DBG_SEGMENT, + "sci %p, i_ino %lu\n", sci, inode->i_ino); + n = nilfs_lookup_dirty_data_buffers(inode, &data_buffers, rest + 1, sci->sc_dsync_start, sci->sc_dsync_end); @@ -1054,6 +1166,10 @@ static int nilfs_segctor_collect_blocks(struct nilfs_sc_info *sci, int mode) size_t ndone; int err = 0; + nilfs2_debug(DBG_SEGMENT, + "sci %p, sci->sc_stage.scnt %d, mode %#x\n", + sci, sci->sc_stage.scnt, mode); + switch (sci->sc_stage.scnt) { case NILFS_ST_INIT: /* Pre-processes */ @@ -1213,6 +1329,9 @@ static int nilfs_segctor_begin_construction(struct nilfs_sc_info *sci, __u64 nextnum; int err, alloc = 0; + nilfs2_debug(DBG_SEGMENT, + "sci %p, nilfs %p\n", sci, nilfs); + segbuf = nilfs_segbuf_new(sci->sc_super); if (unlikely(!segbuf)) return -ENOMEM; @@ -1275,6 +1394,9 @@ static int nilfs_segctor_extend_segments(struct nilfs_sc_info *sci, LIST_HEAD(list); int err, ret, i; + nilfs2_debug(DBG_SEGMENT, + "sci %p, nilfs %p, nadd %d\n", sci, nilfs, nadd); + prev = NILFS_LAST_SEGBUF(&sci->sc_segbufs); /* * Since the segment specified with nextnum might be allocated during @@ -1329,6 +1451,9 @@ static void nilfs_free_incomplete_logs(struct list_head *logs, struct inode *sufile = nilfs->ns_sufile; int ret; + nilfs2_debug(DBG_SEGMENT, + "logs %p, nilfs %p\n", logs, nilfs); + segbuf = NILFS_FIRST_SEGBUF(logs); if (nilfs->ns_nextnum != segbuf->sb_nextnum) { ret = nilfs_sufile_free(sufile, segbuf->sb_nextnum); @@ -1366,6 +1491,9 @@ static void nilfs_segctor_update_segusage(struct nilfs_sc_info *sci, unsigned long live_blocks; int ret; + nilfs2_debug(DBG_SEGMENT, + "sci %p, sufile %p\n", sci, sufile); + list_for_each_entry(segbuf, &sci->sc_segbufs, sb_list) { live_blocks = segbuf->sb_sum.nblocks + (segbuf->sb_pseg_start - segbuf->sb_fseg_start); @@ -1381,6 +1509,9 @@ static void nilfs_cancel_segusage(struct list_head *logs, struct inode *sufile) struct nilfs_segment_buffer *segbuf; int ret; + nilfs2_debug(DBG_SEGMENT, + "logs %p, sufile %p\n", logs, sufile); + segbuf = NILFS_FIRST_SEGBUF(logs); ret = nilfs_sufile_set_segment_usage(sufile, segbuf->sb_segnum, segbuf->sb_pseg_start - @@ -1401,6 +1532,9 @@ static void nilfs_segctor_truncate_segments(struct nilfs_sc_info *sci, struct nilfs_segment_buffer *segbuf = last; int ret; + nilfs2_debug(DBG_SEGMENT, + "sci %p, last %p, sufile %p\n", sci, last, sufile); + list_for_each_entry_continue(segbuf, &sci->sc_segbufs, sb_list) { sci->sc_segbuf_nblocks -= segbuf->sb_rest_blocks; ret = nilfs_sufile_free(sufile, segbuf->sb_nextnum); @@ -1416,6 +1550,9 @@ static int nilfs_segctor_collect(struct nilfs_sc_info *sci, struct nilfs_cstage prev_stage = sci->sc_stage; int err, nadd = 1; + nilfs2_debug(DBG_SEGMENT, + "sci %p, nilfs %p, mode %#x\n", sci, nilfs, mode); + /* Collection retry loop */ for (;;) { sci->sc_nblk_this_inc = 0; @@ -1486,6 +1623,9 @@ nilfs_segctor_update_payload_blocknr(struct nilfs_sc_info *sci, ino_t ino = 0; int err = 0; + nilfs2_debug(DBG_SEGMENT, + "sci %p, segbuf %p, mode %#x\n", sci, segbuf, mode); + if (!nfinfo) goto out; @@ -1547,6 +1687,9 @@ static int nilfs_segctor_assign(struct nilfs_sc_info *sci, int mode) struct nilfs_segment_buffer *segbuf; int err; + nilfs2_debug(DBG_SEGMENT, + "sci %p, mode %#x\n", sci, mode); + list_for_each_entry(segbuf, &sci->sc_segbufs, sb_list) { err = nilfs_segctor_update_payload_blocknr(sci, segbuf, mode); if (unlikely(err)) @@ -1563,6 +1706,9 @@ static void nilfs_begin_page_io(struct page *page) twice. We ignore the 2nd or later calls by this check. */ return; + nilfs2_debug(DBG_SEGMENT, + "i_ino %lu\n", page->mapping->host->i_ino); + lock_page(page); clear_page_dirty_for_io(page); set_page_writeback(page); @@ -1574,6 +1720,8 @@ static void nilfs_segctor_prepare_write(struct nilfs_sc_info *sci) struct nilfs_segment_buffer *segbuf; struct page *bd_page = NULL, *fs_page = NULL; + nilfs2_debug(DBG_SEGMENT, "sci %p\n", sci); + list_for_each_entry(segbuf, &sci->sc_segbufs, sb_list) { struct buffer_head *bh; @@ -1622,6 +1770,9 @@ static int nilfs_segctor_write(struct nilfs_sc_info *sci, { int ret; + nilfs2_debug(DBG_SEGMENT, + "sci %p, nilfs %p\n", sci, nilfs); + ret = nilfs_write_logs(&sci->sc_segbufs, nilfs); list_splice_tail_init(&sci->sc_segbufs, &sci->sc_write_logs); return ret; @@ -1632,6 +1783,10 @@ static void nilfs_end_page_io(struct page *page, int err) if (!page) return; + nilfs2_debug(DBG_SEGMENT, + "i_ino %lu, offset %llu, err %d\n", + page->mapping->host->i_ino, page_offset(page), err); + if (buffer_nilfs_node(page_buffers(page)) && !PageWriteback(page)) { /* * For b-tree node pages, this function may be called twice @@ -1674,6 +1829,9 @@ static void nilfs_abort_logs(struct list_head *logs, int err) if (list_empty(logs)) return; + nilfs2_debug(DBG_SEGMENT, + "logs %p, err %d\n", logs, err); + list_for_each_entry(segbuf, logs, sb_list) { list_for_each_entry(bh, &segbuf->sb_segsum_buffers, b_assoc_buffers) { @@ -1686,6 +1844,13 @@ static void nilfs_abort_logs(struct list_head *logs, int err) list_for_each_entry(bh, &segbuf->sb_payload_buffers, b_assoc_buffers) { + + nilfs2_debug(DBG_SEGMENT, + "segnum %llu, ino %lu, blocknr %lu\n", + segbuf->sb_segnum, + bh->b_page->mapping->host->i_ino, + bh->b_blocknr); + if (bh == segbuf->sb_super_root) { if (bh->b_page != bd_page) { end_page_writeback(bd_page); @@ -1711,6 +1876,9 @@ static void nilfs_segctor_abort_construction(struct nilfs_sc_info *sci, LIST_HEAD(logs); int ret; + nilfs2_debug(DBG_SEGMENT, + "sci %p, nilfs %p, err %d\n", sci, nilfs, err); + list_splice_tail_init(&sci->sc_write_logs, &logs); ret = nilfs_wait_on_logs(&logs); nilfs_abort_logs(&logs, ret ? : err); @@ -1748,9 +1916,13 @@ static void nilfs_segctor_complete_write(struct nilfs_sc_info *sci) struct the_nilfs *nilfs = sci->sc_super->s_fs_info; int update_sr = false; + nilfs2_debug(DBG_SEGMENT, "sci %p\n", sci); + list_for_each_entry(segbuf, &sci->sc_write_logs, sb_list) { struct buffer_head *bh; + nilfs2_debug(DBG_SEGMENT, "segnum %llu\n", segbuf->sb_segnum); + list_for_each_entry(bh, &segbuf->sb_segsum_buffers, b_assoc_buffers) { set_buffer_uptodate(bh); @@ -1839,6 +2011,8 @@ static int nilfs_segctor_wait(struct nilfs_sc_info *sci) { int ret; + nilfs2_debug(DBG_SEGMENT, "sci %p\n", sci); + ret = nilfs_wait_on_logs(&sci->sc_write_logs); if (!ret) { nilfs_segctor_complete_write(sci); @@ -1853,6 +2027,9 @@ static int nilfs_segctor_collect_dirty_files(struct nilfs_sc_info *sci, struct nilfs_inode_info *ii, *n; struct inode *ifile = sci->sc_root->ifile; + nilfs2_debug(DBG_SEGMENT, + "sci %p, nilfs %p\n", sci, nilfs); + spin_lock(&nilfs->ns_inode_lock); retry: list_for_each_entry_safe(ii, n, &nilfs->ns_dirty_files, i_dirty) { @@ -1860,6 +2037,9 @@ static int nilfs_segctor_collect_dirty_files(struct nilfs_sc_info *sci, struct buffer_head *ibh; int err; + nilfs2_debug(DBG_SEGMENT, + "ino %lu\n", ii->vfs_inode.i_ino); + spin_unlock(&nilfs->ns_inode_lock); err = nilfs_ifile_get_inode_block( ifile, ii->vfs_inode.i_ino, &ibh); @@ -1893,12 +2073,18 @@ static void nilfs_segctor_drop_written_files(struct nilfs_sc_info *sci, struct nilfs_transaction_info *ti = current->journal_info; struct nilfs_inode_info *ii, *n; + nilfs2_debug(DBG_SEGMENT, + "sci %p, nilfs %p\n", sci, nilfs); + spin_lock(&nilfs->ns_inode_lock); list_for_each_entry_safe(ii, n, &sci->sc_dirty_files, i_dirty) { if (!test_and_clear_bit(NILFS_I_UPDATED, &ii->i_state) || test_bit(NILFS_I_DIRTY, &ii->i_state)) continue; + nilfs2_debug(DBG_SEGMENT, + "ino %lu\n", ii->vfs_inode.i_ino); + clear_bit(NILFS_I_BUSY, &ii->i_state); brelse(ii->i_bh); ii->i_bh = NULL; @@ -1915,6 +2101,9 @@ static int nilfs_segctor_do_construct(struct nilfs_sc_info *sci, int mode) struct the_nilfs *nilfs = sci->sc_super->s_fs_info; int err; + nilfs2_debug(DBG_SEGMENT, + "sci %p, mode %#x\n", sci, mode); + sci->sc_stage.scnt = NILFS_ST_INIT; sci->sc_cno = nilfs->ns_cno; @@ -2027,6 +2216,8 @@ static void nilfs_segctor_start_timer(struct nilfs_sc_info *sci) static void nilfs_segctor_do_flush(struct nilfs_sc_info *sci, int bn) { + nilfs2_debug(DBG_SEGMENT, "sci %p, bn %d\n", sci, bn); + spin_lock(&sci->sc_state_lock); if (!(sci->sc_flush_request & (1 << bn))) { unsigned long prev_req = sci->sc_flush_request; @@ -2048,6 +2239,8 @@ void nilfs_flush_segment(struct super_block *sb, ino_t ino) struct the_nilfs *nilfs = sb->s_fs_info; struct nilfs_sc_info *sci = nilfs->ns_writer; + nilfs2_debug(DBG_SEGMENT, "ino %lu\n", ino); + if (!sci || nilfs_doing_construction()) return; nilfs_segctor_do_flush(sci, NILFS_MDT_INODE(sb, ino) ? ino : 0); @@ -2066,6 +2259,8 @@ static int nilfs_segctor_sync(struct nilfs_sc_info *sci) struct nilfs_segctor_wait_request wait_req; int err = 0; + nilfs2_debug(DBG_SEGMENT, "sci %p\n", sci); + spin_lock(&sci->sc_state_lock); init_wait(&wait_req.wq); wait_req.err = 0; @@ -2099,6 +2294,9 @@ static void nilfs_segctor_wakeup(struct nilfs_sc_info *sci, int err) struct nilfs_segctor_wait_request *wrq, *n; unsigned long flags; + nilfs2_debug(DBG_SEGMENT, + "sci %p, err %d\n", sci, err); + spin_lock_irqsave(&sci->sc_wait_request.lock, flags); list_for_each_entry_safe(wrq, n, &sci->sc_wait_request.task_list, wq.task_list) { @@ -2143,6 +2341,8 @@ int nilfs_construct_segment(struct super_block *sb) if (!sci) return -EROFS; + nilfs2_debug(DBG_SEGMENT, "sb %p\n", sb); + /* A call inside transactions causes a deadlock. */ BUG_ON((ti = current->journal_info) && ti->ti_magic == NILFS_TI_MAGIC); @@ -2182,6 +2382,10 @@ int nilfs_construct_dsync_segment(struct super_block *sb, struct inode *inode, if (!sci) return -EROFS; + nilfs2_debug(DBG_SEGMENT, + "segnum %llu, ino %lu, start %llu, end %llu\n", + sci->sc_curseg->sb_segnum, inode->i_ino, start, end); + nilfs_transaction_lock(sb, &ti, 0); ii = NILFS_I(inode); @@ -2235,6 +2439,9 @@ static void nilfs_segctor_accept(struct nilfs_sc_info *sci) */ static void nilfs_segctor_notify(struct nilfs_sc_info *sci, int mode, int err) { + nilfs2_debug(DBG_SEGMENT, + "sci %p, mode %#x, err %d\n", sci, mode, err); + /* Clear requests (even when the construction failed) */ spin_lock(&sci->sc_state_lock); @@ -2268,6 +2475,9 @@ static int nilfs_segctor_construct(struct nilfs_sc_info *sci, int mode) struct nilfs_super_block **sbp; int err = 0; + nilfs2_debug(DBG_SEGMENT, + "sci %p, mode %#x\n", sci, mode); + nilfs_segctor_accept(sci); if (nilfs_discontinued(nilfs)) @@ -2308,9 +2518,15 @@ nilfs_remove_written_gcinodes(struct the_nilfs *nilfs, struct list_head *head) { struct nilfs_inode_info *ii, *n; + nilfs2_debug(DBG_SEGMENT, + "nilfs %p, head %p\n", nilfs, head); + list_for_each_entry_safe(ii, n, head, i_dirty) { if (!test_bit(NILFS_I_UPDATED, &ii->i_state)) continue; + + nilfs2_debug(DBG_SEGMENT, "ino %lu\n", ii->vfs_inode.i_ino); + list_del_init(&ii->i_dirty); truncate_inode_pages(&ii->vfs_inode.i_data, 0); nilfs_btnode_cache_clear(&ii->i_btnode_cache); @@ -2326,6 +2542,9 @@ int nilfs_clean_segments(struct super_block *sb, struct nilfs_argv *argv, struct nilfs_transaction_info ti; int err; + nilfs2_debug(DBG_SEGMENT, + "sb %p, argv %p, kbufs %p\n", sb, argv, kbufs); + if (unlikely(!sci)) return -EROFS; @@ -2380,6 +2599,9 @@ static void nilfs_segctor_thread_construct(struct nilfs_sc_info *sci, int mode) { struct nilfs_transaction_info ti; + nilfs2_debug(DBG_SEGMENT, + "sci %p, mode %#x\n", sci, mode); + nilfs_transaction_lock(sci->sc_super, &ti, 0); nilfs_segctor_construct(sci, mode); @@ -2399,6 +2621,8 @@ static void nilfs_segctor_do_immediate_flush(struct nilfs_sc_info *sci) int mode = 0; int err; + nilfs2_debug(DBG_SEGMENT, "sci %p\n", sci); + spin_lock(&sci->sc_state_lock); mode = (sci->sc_flush_request & FLUSH_DAT_BIT) ? SC_FLUSH_DAT : SC_FLUSH_FILE; @@ -2440,6 +2664,8 @@ static int nilfs_segctor_thread(void *arg) struct the_nilfs *nilfs = sci->sc_super->s_fs_info; int timeout = 0; + nilfs2_debug(DBG_SEGMENT, "arg %p\n", arg); + sci->sc_timer.data = (unsigned long)current; sci->sc_timer.function = nilfs_construction_timeout; @@ -2472,7 +2698,6 @@ static int nilfs_segctor_thread(void *arg) timeout = 0; } - if (freezing(current)) { spin_unlock(&sci->sc_state_lock); try_to_freeze(); @@ -2519,6 +2744,8 @@ static int nilfs_segctor_start_thread(struct nilfs_sc_info *sci) { struct task_struct *t; + nilfs2_debug(DBG_SEGMENT, "sci %p\n", sci); + t = kthread_run(nilfs_segctor_thread, sci, "segctord"); if (IS_ERR(t)) { int err = PTR_ERR(t); @@ -2537,6 +2764,8 @@ static void nilfs_segctor_kill_thread(struct nilfs_sc_info *sci) { sci->sc_state |= NILFS_SEGCTOR_QUIT; + nilfs2_debug(DBG_SEGMENT, "sci %p\n", sci); + while (sci->sc_task) { wake_up(&sci->sc_wait_daemon); spin_unlock(&sci->sc_state_lock); @@ -2554,6 +2783,9 @@ static struct nilfs_sc_info *nilfs_segctor_new(struct super_block *sb, struct the_nilfs *nilfs = sb->s_fs_info; struct nilfs_sc_info *sci; + nilfs2_debug(DBG_SEGMENT, + "sb %p, root %p\n", sb, root); + sci = kzalloc(sizeof(*sci), GFP_KERNEL); if (!sci) return NULL; @@ -2588,6 +2820,8 @@ static void nilfs_segctor_write_out(struct nilfs_sc_info *sci) { int ret, retrycount = NILFS_SC_CLEANUP_RETRY; + nilfs2_debug(DBG_SEGMENT, "sci %p\n", sci); + /* The segctord thread was stopped and its timer was removed. But some tasks remain. */ do { @@ -2613,6 +2847,8 @@ static void nilfs_segctor_destroy(struct nilfs_sc_info *sci) struct the_nilfs *nilfs = sci->sc_super->s_fs_info; int flag; + nilfs2_debug(DBG_SEGMENT, "sci %p\n", sci); + up_write(&nilfs->ns_segctor_sem); spin_lock(&sci->sc_state_lock); @@ -2659,6 +2895,9 @@ int nilfs_attach_log_writer(struct super_block *sb, struct nilfs_root *root) struct the_nilfs *nilfs = sb->s_fs_info; int err; + nilfs2_debug(DBG_SEGMENT, + "sb %p, root %p\n", sb, root); + if (nilfs->ns_writer) { /* * This happens if the filesystem was remounted @@ -2692,6 +2931,8 @@ void nilfs_detach_log_writer(struct super_block *sb) struct the_nilfs *nilfs = sb->s_fs_info; LIST_HEAD(garbage_list); + nilfs2_debug(DBG_SEGMENT, "sb %p\n", sb); + down_write(&nilfs->ns_segctor_sem); if (nilfs->ns_writer) { nilfs_segctor_destroy(nilfs->ns_writer); -- 1.7.9.5 -- To unsubscribe from this list: send the line "unsubscribe linux-nilfs" in the body of a message to [email protected] More majordomo info at http://vger.kernel.org/majordomo-info.html
