Lines Matching refs:sci
90 static inline void nilfs_sc_cstage_inc(struct nilfs_sc_info *sci)
92 sci->sc_stage.scnt++;
93 trace_nilfs2_collection_stage_transition(sci);
96 static inline void nilfs_sc_cstage_set(struct nilfs_sc_info *sci, int next_scnt)
98 sci->sc_stage.scnt = next_scnt;
99 trace_nilfs2_collection_stage_transition(sci);
102 static inline int nilfs_sc_cstage_get(struct nilfs_sc_info *sci)
104 return sci->sc_stage.scnt;
276 struct nilfs_sc_info *sci = nilfs->ns_writer;
279 nilfs_segctor_start_timer(sci);
280 if (atomic_read(&nilfs->ns_ndirtyblks) > sci->sc_watermark)
281 nilfs_segctor_do_flush(sci, 0);
323 struct nilfs_sc_info *sci = nilfs->ns_writer;
325 if (sb_rdonly(sb) || unlikely(!sci) || !sci->sc_flush_request)
328 set_bit(NILFS_SC_PRIOR_FLUSH, &sci->sc_flags);
332 if (sci->sc_flush_request &&
333 test_bit(NILFS_SC_PRIOR_FLUSH, &sci->sc_flags)) {
337 nilfs_segctor_do_immediate_flush(sci);
349 struct nilfs_sc_info *sci = nilfs->ns_writer;
363 if (!test_bit(NILFS_SC_PRIOR_FLUSH, &sci->sc_flags))
366 nilfs_segctor_do_immediate_flush(sci);
393 static void *nilfs_segctor_map_segsum_entry(struct nilfs_sc_info *sci,
397 struct nilfs_segment_buffer *segbuf = sci->sc_curseg;
398 unsigned int blocksize = sci->sc_super->s_blocksize;
414 * @sci: nilfs_sc_info
416 static int nilfs_segctor_reset_segment_buffer(struct nilfs_sc_info *sci)
418 struct nilfs_segment_buffer *segbuf = sci->sc_curseg;
426 err = nilfs_segbuf_reset(segbuf, flags, sci->sc_seg_ctime, sci->sc_cno);
432 sci->sc_finfo_ptr.bh = sumbh; sci->sc_finfo_ptr.offset = sumbytes;
433 sci->sc_binfo_ptr.bh = sumbh; sci->sc_binfo_ptr.offset = sumbytes;
434 sci->sc_blk_cnt = sci->sc_datablk_cnt = 0;
440 * @sci: segment constructor object
445 static void nilfs_segctor_zeropad_segsum(struct nilfs_sc_info *sci)
449 ssp = sci->sc_blk_cnt > 0 ? &sci->sc_binfo_ptr : &sci->sc_finfo_ptr;
455 static int nilfs_segctor_feed_segment(struct nilfs_sc_info *sci)
457 sci->sc_nblk_this_inc += sci->sc_curseg->sb_sum.nblocks;
458 if (NILFS_SEGBUF_IS_LAST(sci->sc_curseg, &sci->sc_segbufs))
463 nilfs_segctor_zeropad_segsum(sci);
464 sci->sc_curseg = NILFS_NEXT_SEGBUF(sci->sc_curseg);
465 return nilfs_segctor_reset_segment_buffer(sci);
468 static int nilfs_segctor_add_super_root(struct nilfs_sc_info *sci)
470 struct nilfs_segment_buffer *segbuf = sci->sc_curseg;
474 err = nilfs_segctor_feed_segment(sci);
477 segbuf = sci->sc_curseg;
489 struct nilfs_sc_info *sci, const struct nilfs_segsum_pointer *ssp,
492 unsigned int blocksize = sci->sc_super->s_blocksize;
496 (!sci->sc_blk_cnt ? sizeof(struct nilfs_finfo) : 0) >
500 static void nilfs_segctor_begin_finfo(struct nilfs_sc_info *sci,
503 sci->sc_curseg->sb_sum.nfinfo++;
504 sci->sc_binfo_ptr = sci->sc_finfo_ptr;
506 sci, &sci->sc_binfo_ptr, sizeof(struct nilfs_finfo));
509 !test_bit(NILFS_SC_HAVE_DELTA, &sci->sc_flags))
510 set_bit(NILFS_SC_HAVE_DELTA, &sci->sc_flags);
514 static void nilfs_segctor_end_finfo(struct nilfs_sc_info *sci,
522 if (sci->sc_blk_cnt == 0)
532 cno = sci->sc_cno;
534 finfo = nilfs_segctor_map_segsum_entry(sci, &sci->sc_finfo_ptr,
537 finfo->fi_nblocks = cpu_to_le32(sci->sc_blk_cnt);
538 finfo->fi_ndatablk = cpu_to_le32(sci->sc_datablk_cnt);
541 segbuf = sci->sc_curseg;
542 segbuf->sb_sum.sumbytes = sci->sc_binfo_ptr.offset +
543 sci->sc_super->s_blocksize * (segbuf->sb_sum.nsumblk - 1);
544 sci->sc_finfo_ptr = sci->sc_binfo_ptr;
545 sci->sc_blk_cnt = sci->sc_datablk_cnt = 0;
548 static int nilfs_segctor_add_file_block(struct nilfs_sc_info *sci,
557 segbuf = sci->sc_curseg;
559 sci, &sci->sc_binfo_ptr, binfo_size);
561 nilfs_segctor_end_finfo(sci, inode);
562 err = nilfs_segctor_feed_segment(sci);
568 nilfs_segctor_zeropad_segsum(sci);
573 if (sci->sc_blk_cnt == 0)
574 nilfs_segctor_begin_finfo(sci, inode);
576 nilfs_segctor_map_segsum_entry(sci, &sci->sc_binfo_ptr, binfo_size);
579 sci->sc_blk_cnt++;
587 static int nilfs_collect_file_data(struct nilfs_sc_info *sci,
596 err = nilfs_segctor_add_file_block(sci, bh, inode,
599 sci->sc_datablk_cnt++;
603 static int nilfs_collect_file_node(struct nilfs_sc_info *sci,
610 static int nilfs_collect_file_bmap(struct nilfs_sc_info *sci,
615 return nilfs_segctor_add_file_block(sci, bh, inode, sizeof(__le64));
618 static void nilfs_write_file_data_binfo(struct nilfs_sc_info *sci,
623 sci, ssp, sizeof(*binfo_v));
627 static void nilfs_write_file_node_binfo(struct nilfs_sc_info *sci,
632 sci, ssp, sizeof(*vblocknr));
644 static int nilfs_collect_dat_data(struct nilfs_sc_info *sci,
653 err = nilfs_segctor_add_file_block(sci, bh, inode, sizeof(__le64));
655 sci->sc_datablk_cnt++;
659 static int nilfs_collect_dat_bmap(struct nilfs_sc_info *sci,
663 return nilfs_segctor_add_file_block(sci, bh, inode,
667 static void nilfs_write_dat_data_binfo(struct nilfs_sc_info *sci,
671 __le64 *blkoff = nilfs_segctor_map_segsum_entry(sci, ssp,
676 static void nilfs_write_dat_node_binfo(struct nilfs_sc_info *sci,
681 nilfs_segctor_map_segsum_entry(sci, ssp, sizeof(*binfo_dat));
830 struct nilfs_sc_info *sci = container_of(work, struct nilfs_sc_info,
832 struct the_nilfs *nilfs = sci->sc_super->s_fs_info;
834 nilfs_dispose_list(nilfs, &sci->sc_iput_queue, 0);
853 static int nilfs_segctor_clean(struct nilfs_sc_info *sci)
855 return list_empty(&sci->sc_dirty_files) &&
856 !test_bit(NILFS_SC_DIRTY, &sci->sc_flags) &&
857 sci->sc_nfreesegs == 0 &&
858 (!nilfs_doing_gc() || list_empty(&sci->sc_gc_inodes));
861 static int nilfs_segctor_confirm(struct nilfs_sc_info *sci)
863 struct the_nilfs *nilfs = sci->sc_super->s_fs_info;
866 if (nilfs_test_metadata_dirty(nilfs, sci->sc_root))
867 set_bit(NILFS_SC_DIRTY, &sci->sc_flags);
870 if (list_empty(&nilfs->ns_dirty_files) && nilfs_segctor_clean(sci))
877 static void nilfs_segctor_clear_metadata_dirty(struct nilfs_sc_info *sci)
879 struct the_nilfs *nilfs = sci->sc_super->s_fs_info;
881 nilfs_mdt_clear_dirty(sci->sc_root->ifile);
887 static int nilfs_segctor_create_checkpoint(struct nilfs_sc_info *sci)
889 struct the_nilfs *nilfs = sci->sc_super->s_fs_info;
908 nilfs_error(sci->sc_super,
915 static int nilfs_segctor_fill_in_checkpoint(struct nilfs_sc_info *sci)
917 struct the_nilfs *nilfs = sci->sc_super->s_fs_info;
926 nilfs_error(sci->sc_super,
935 cpu_to_le64(atomic64_read(&sci->sc_root->inodes_count));
937 cpu_to_le64(atomic64_read(&sci->sc_root->blocks_count));
939 cpu_to_le64(sci->sc_nblk_inc + sci->sc_nblk_this_inc);
940 raw_cp->cp_create = cpu_to_le64(sci->sc_seg_ctime);
943 if (test_bit(NILFS_SC_HAVE_DELTA, &sci->sc_flags))
948 nilfs_write_inode_common(sci->sc_root->ifile,
974 static void nilfs_segctor_fill_in_file_bmap(struct nilfs_sc_info *sci)
978 list_for_each_entry(ii, &sci->sc_dirty_files, i_dirty) {
979 nilfs_fill_in_file_bmap(sci->sc_root->ifile, ii);
984 static void nilfs_segctor_fill_in_super_root(struct nilfs_sc_info *sci,
991 bh_sr = NILFS_LAST_SEGBUF(&sci->sc_segbufs)->sb_super_root;
1002 nilfs->ns_nongc_ctime : sci->sc_seg_ctime);
1039 static int nilfs_segctor_apply_buffers(struct nilfs_sc_info *sci,
1052 err = collect(sci, bh, inode);
1070 static size_t nilfs_segctor_buffer_rest(struct nilfs_sc_info *sci)
1073 return sci->sc_segbuf_nblocks -
1074 (sci->sc_nblk_this_inc + sci->sc_curseg->sb_sum.nblocks);
1077 static int nilfs_segctor_scan_file(struct nilfs_sc_info *sci,
1085 if (!(sci->sc_stage.flags & NILFS_CF_NODE)) {
1086 size_t n, rest = nilfs_segctor_buffer_rest(sci);
1092 sci, inode, &data_buffers,
1100 if (!(sci->sc_stage.flags & NILFS_CF_NODE)) {
1102 sci, inode, &data_buffers, sc_ops->collect_data);
1106 sci, inode, &node_buffers, NULL);
1109 sci->sc_stage.flags |= NILFS_CF_NODE;
1113 sci, inode, &node_buffers, sc_ops->collect_node);
1119 sci, inode, &node_buffers, sc_ops->collect_bmap);
1123 nilfs_segctor_end_finfo(sci, inode);
1124 sci->sc_stage.flags &= ~NILFS_CF_NODE;
1130 static int nilfs_segctor_scan_file_dsync(struct nilfs_sc_info *sci,
1134 size_t n, rest = nilfs_segctor_buffer_rest(sci);
1138 sci->sc_dsync_start,
1139 sci->sc_dsync_end);
1141 err = nilfs_segctor_apply_buffers(sci, inode, &data_buffers,
1144 nilfs_segctor_end_finfo(sci, inode);
1151 static int nilfs_segctor_collect_blocks(struct nilfs_sc_info *sci, int mode)
1153 struct the_nilfs *nilfs = sci->sc_super->s_fs_info;
1159 switch (nilfs_sc_cstage_get(sci)) {
1162 sci->sc_stage.flags = 0;
1164 if (!test_bit(NILFS_SC_UNCLOSED, &sci->sc_flags)) {
1165 sci->sc_nblk_inc = 0;
1166 sci->sc_curseg->sb_sum.flags = NILFS_SS_LOGBGN;
1168 nilfs_sc_cstage_set(sci, NILFS_ST_DSYNC);
1173 sci->sc_stage.dirty_file_ptr = NULL;
1174 sci->sc_stage.gc_inode_ptr = NULL;
1176 nilfs_sc_cstage_set(sci, NILFS_ST_DAT);
1179 nilfs_sc_cstage_inc(sci);
1183 head = &sci->sc_gc_inodes;
1184 ii = list_prepare_entry(sci->sc_stage.gc_inode_ptr,
1188 sci, &ii->vfs_inode,
1191 sci->sc_stage.gc_inode_ptr = list_entry(
1199 sci->sc_stage.gc_inode_ptr = NULL;
1201 nilfs_sc_cstage_inc(sci);
1204 head = &sci->sc_dirty_files;
1205 ii = list_prepare_entry(sci->sc_stage.dirty_file_ptr, head,
1210 err = nilfs_segctor_scan_file(sci, &ii->vfs_inode,
1213 sci->sc_stage.dirty_file_ptr =
1219 /* sci->sc_stage.dirty_file_ptr = NILFS_I(inode); */
1222 sci->sc_stage.dirty_file_ptr = NULL;
1224 nilfs_sc_cstage_set(sci, NILFS_ST_DONE);
1227 nilfs_sc_cstage_inc(sci);
1228 sci->sc_stage.flags |= NILFS_CF_IFILE_STARTED;
1231 err = nilfs_segctor_scan_file(sci, sci->sc_root->ifile,
1235 nilfs_sc_cstage_inc(sci);
1237 err = nilfs_segctor_create_checkpoint(sci);
1242 err = nilfs_segctor_scan_file(sci, nilfs->ns_cpfile,
1246 nilfs_sc_cstage_inc(sci);
1249 err = nilfs_sufile_freev(nilfs->ns_sufile, sci->sc_freesegs,
1250 sci->sc_nfreesegs, &ndone);
1253 sci->sc_freesegs, ndone,
1257 sci->sc_stage.flags |= NILFS_CF_SUFREED;
1259 err = nilfs_segctor_scan_file(sci, nilfs->ns_sufile,
1263 nilfs_sc_cstage_inc(sci);
1267 err = nilfs_segctor_scan_file(sci, nilfs->ns_dat,
1272 nilfs_sc_cstage_set(sci, NILFS_ST_DONE);
1275 nilfs_sc_cstage_inc(sci);
1280 err = nilfs_segctor_add_super_root(sci);
1285 sci->sc_curseg->sb_sum.flags |= NILFS_SS_LOGEND;
1286 nilfs_sc_cstage_set(sci, NILFS_ST_DONE);
1290 sci->sc_curseg->sb_sum.flags |= NILFS_SS_SYNDT;
1291 ii = sci->sc_dsync_inode;
1295 err = nilfs_segctor_scan_file_dsync(sci, &ii->vfs_inode);
1298 sci->sc_curseg->sb_sum.flags |= NILFS_SS_LOGEND;
1299 nilfs_sc_cstage_set(sci, NILFS_ST_DONE);
1313 * @sci: nilfs_sc_info
1316 static int nilfs_segctor_begin_construction(struct nilfs_sc_info *sci,
1323 segbuf = nilfs_segbuf_new(sci->sc_super);
1327 if (list_empty(&sci->sc_write_logs)) {
1343 prev = NILFS_LAST_SEGBUF(&sci->sc_write_logs);
1366 BUG_ON(!list_empty(&sci->sc_segbufs));
1367 list_add_tail(&segbuf->sb_list, &sci->sc_segbufs);
1368 sci->sc_segbuf_nblocks = segbuf->sb_rest_blocks;
1376 static int nilfs_segctor_extend_segments(struct nilfs_sc_info *sci,
1385 prev = NILFS_LAST_SEGBUF(&sci->sc_segbufs);
1399 segbuf = nilfs_segbuf_new(sci->sc_super);
1405 sci->sc_segbuf_nblocks += segbuf->sb_rest_blocks;
1418 list_splice_tail(&list, &sci->sc_segbufs);
1471 static void nilfs_segctor_update_segusage(struct nilfs_sc_info *sci,
1478 list_for_each_entry(segbuf, &sci->sc_segbufs, sb_list) {
1483 sci->sc_seg_ctime);
1506 static void nilfs_segctor_truncate_segments(struct nilfs_sc_info *sci,
1513 list_for_each_entry_continue(segbuf, &sci->sc_segbufs, sb_list) {
1514 sci->sc_segbuf_nblocks -= segbuf->sb_rest_blocks;
1518 nilfs_truncate_logs(&sci->sc_segbufs, last);
1522 static int nilfs_segctor_collect(struct nilfs_sc_info *sci,
1525 struct nilfs_cstage prev_stage = sci->sc_stage;
1530 sci->sc_nblk_this_inc = 0;
1531 sci->sc_curseg = NILFS_FIRST_SEGBUF(&sci->sc_segbufs);
1533 err = nilfs_segctor_reset_segment_buffer(sci);
1537 err = nilfs_segctor_collect_blocks(sci, mode);
1538 sci->sc_nblk_this_inc += sci->sc_curseg->sb_sum.nblocks;
1547 nilfs_sc_cstage_get(sci) < NILFS_ST_CPFILE)
1550 nilfs_clear_logs(&sci->sc_segbufs);
1552 if (sci->sc_stage.flags & NILFS_CF_SUFREED) {
1554 sci->sc_freesegs,
1555 sci->sc_nfreesegs,
1558 sci->sc_stage.flags &= ~NILFS_CF_SUFREED;
1561 err = nilfs_segctor_extend_segments(sci, nilfs, nadd);
1566 sci->sc_stage = prev_stage;
1568 nilfs_segctor_zeropad_segsum(sci);
1569 nilfs_segctor_truncate_segments(sci, sci->sc_curseg, nilfs->ns_sufile);
1586 nilfs_segctor_update_payload_blocknr(struct nilfs_sc_info *sci,
1614 sci, &ssp, sizeof(*finfo));
1639 sc_op->write_data_binfo(sci, &ssp, &binfo);
1641 sc_op->write_node_binfo(sci, &ssp, &binfo);
1658 static int nilfs_segctor_assign(struct nilfs_sc_info *sci, int mode)
1663 list_for_each_entry(segbuf, &sci->sc_segbufs, sb_list) {
1664 err = nilfs_segctor_update_payload_blocknr(sci, segbuf, mode);
1687 static void nilfs_segctor_prepare_write(struct nilfs_sc_info *sci)
1692 list_for_each_entry(segbuf, &sci->sc_segbufs, sb_list) {
1736 static int nilfs_segctor_write(struct nilfs_sc_info *sci,
1741 ret = nilfs_write_logs(&sci->sc_segbufs, nilfs);
1742 list_splice_tail_init(&sci->sc_segbufs, &sci->sc_write_logs);
1827 static void nilfs_segctor_abort_construction(struct nilfs_sc_info *sci,
1833 list_splice_tail_init(&sci->sc_write_logs, &logs);
1837 list_splice_tail_init(&sci->sc_segbufs, &logs);
1841 if (sci->sc_stage.flags & NILFS_CF_SUFREED) {
1843 sci->sc_freesegs,
1844 sci->sc_nfreesegs,
1863 static void nilfs_segctor_complete_write(struct nilfs_sc_info *sci)
1867 struct the_nilfs *nilfs = sci->sc_super->s_fs_info;
1870 list_for_each_entry(segbuf, &sci->sc_write_logs, sb_list) {
1921 set_bit(NILFS_SC_UNCLOSED, &sci->sc_flags);
1922 sci->sc_lseg_stime = jiffies;
1925 clear_bit(NILFS_SC_UNCLOSED, &sci->sc_flags);
1937 nilfs_drop_collected_inodes(&sci->sc_dirty_files);
1940 nilfs_drop_collected_inodes(&sci->sc_gc_inodes);
1942 nilfs->ns_nongc_ctime = sci->sc_seg_ctime;
1944 sci->sc_nblk_inc += sci->sc_nblk_this_inc;
1946 segbuf = NILFS_LAST_SEGBUF(&sci->sc_write_logs);
1954 clear_bit(NILFS_SC_HAVE_DELTA, &sci->sc_flags);
1955 clear_bit(NILFS_SC_DIRTY, &sci->sc_flags);
1956 set_bit(NILFS_SC_SUPER_ROOT, &sci->sc_flags);
1957 nilfs_segctor_clear_metadata_dirty(sci);
1959 clear_bit(NILFS_SC_SUPER_ROOT, &sci->sc_flags);
1962 static int nilfs_segctor_wait(struct nilfs_sc_info *sci)
1966 ret = nilfs_wait_on_logs(&sci->sc_write_logs);
1968 nilfs_segctor_complete_write(sci);
1969 nilfs_destroy_logs(&sci->sc_write_logs);
1974 static int nilfs_segctor_collect_dirty_files(struct nilfs_sc_info *sci,
1978 struct inode *ifile = sci->sc_root->ifile;
1991 nilfs_warn(sci->sc_super,
2010 list_move_tail(&ii->i_dirty, &sci->sc_dirty_files);
2017 static void nilfs_segctor_drop_written_files(struct nilfs_sc_info *sci,
2021 int during_mount = !(sci->sc_super->s_flags & SB_ACTIVE);
2025 list_for_each_entry_safe(ii, n, &sci->sc_dirty_files, i_dirty) {
2039 list_add_tail(&ii->i_dirty, &sci->sc_iput_queue);
2050 schedule_work(&sci->sc_iput_work);
2056 static int nilfs_segctor_do_construct(struct nilfs_sc_info *sci, int mode)
2058 struct the_nilfs *nilfs = sci->sc_super->s_fs_info;
2061 if (sb_rdonly(sci->sc_super))
2064 nilfs_sc_cstage_set(sci, NILFS_ST_INIT);
2065 sci->sc_cno = nilfs->ns_cno;
2067 err = nilfs_segctor_collect_dirty_files(sci, nilfs);
2071 if (nilfs_test_metadata_dirty(nilfs, sci->sc_root))
2072 set_bit(NILFS_SC_DIRTY, &sci->sc_flags);
2074 if (nilfs_segctor_clean(sci))
2078 sci->sc_stage.flags &= ~NILFS_CF_HISTORY_MASK;
2080 err = nilfs_segctor_begin_construction(sci, nilfs);
2085 sci->sc_seg_ctime = ktime_get_real_seconds();
2087 err = nilfs_segctor_collect(sci, nilfs, mode);
2092 if (nilfs_sc_cstage_get(sci) == NILFS_ST_DONE &&
2093 nilfs_segbuf_empty(sci->sc_curseg)) {
2094 nilfs_segctor_abort_construction(sci, nilfs, 1);
2098 err = nilfs_segctor_assign(sci, mode);
2102 if (sci->sc_stage.flags & NILFS_CF_IFILE_STARTED)
2103 nilfs_segctor_fill_in_file_bmap(sci);
2106 nilfs_sc_cstage_get(sci) >= NILFS_ST_CPFILE) {
2107 err = nilfs_segctor_fill_in_checkpoint(sci);
2111 nilfs_segctor_fill_in_super_root(sci, nilfs);
2113 nilfs_segctor_update_segusage(sci, nilfs->ns_sufile);
2116 nilfs_segctor_prepare_write(sci);
2118 nilfs_add_checksums_on_logs(&sci->sc_segbufs,
2121 err = nilfs_segctor_write(sci, nilfs);
2125 if (nilfs_sc_cstage_get(sci) == NILFS_ST_DONE ||
2134 err = nilfs_segctor_wait(sci);
2138 } while (nilfs_sc_cstage_get(sci) != NILFS_ST_DONE);
2141 nilfs_segctor_drop_written_files(sci, nilfs);
2145 if (sci->sc_stage.flags & NILFS_CF_IFILE_STARTED)
2146 nilfs_redirty_inodes(&sci->sc_dirty_files);
2150 nilfs_redirty_inodes(&sci->sc_gc_inodes);
2151 nilfs_segctor_abort_construction(sci, nilfs, err);
2157 * @sci: nilfs_sc_info
2163 static void nilfs_segctor_start_timer(struct nilfs_sc_info *sci)
2165 spin_lock(&sci->sc_state_lock);
2166 if (!(sci->sc_state & NILFS_SEGCTOR_COMMIT)) {
2167 sci->sc_timer.expires = jiffies + sci->sc_interval;
2168 add_timer(&sci->sc_timer);
2169 sci->sc_state |= NILFS_SEGCTOR_COMMIT;
2171 spin_unlock(&sci->sc_state_lock);
2174 static void nilfs_segctor_do_flush(struct nilfs_sc_info *sci, int bn)
2176 spin_lock(&sci->sc_state_lock);
2177 if (!(sci->sc_flush_request & BIT(bn))) {
2178 unsigned long prev_req = sci->sc_flush_request;
2180 sci->sc_flush_request |= BIT(bn);
2182 wake_up(&sci->sc_wait_daemon);
2184 spin_unlock(&sci->sc_state_lock);
2195 struct nilfs_sc_info *sci = nilfs->ns_writer;
2197 if (!sci || nilfs_doing_construction())
2199 nilfs_segctor_do_flush(sci, NILFS_MDT_INODE(sb, ino) ? ino : 0);
2210 static int nilfs_segctor_sync(struct nilfs_sc_info *sci)
2215 spin_lock(&sci->sc_state_lock);
2219 wait_req.seq = ++sci->sc_seq_request;
2220 spin_unlock(&sci->sc_state_lock);
2223 add_wait_queue(&sci->sc_wait_request, &wait_req.wq);
2225 wake_up(&sci->sc_wait_daemon);
2239 finish_wait(&sci->sc_wait_request, &wait_req.wq);
2243 static void nilfs_segctor_wakeup(struct nilfs_sc_info *sci, int err)
2248 spin_lock_irqsave(&sci->sc_wait_request.lock, flags);
2249 list_for_each_entry_safe(wrq, n, &sci->sc_wait_request.head, wq.entry) {
2251 nilfs_cnt32_ge(sci->sc_seq_done, wrq->seq)) {
2261 spin_unlock_irqrestore(&sci->sc_wait_request.lock, flags);
2284 struct nilfs_sc_info *sci = nilfs->ns_writer;
2288 if (sb_rdonly(sb) || unlikely(!sci))
2294 err = nilfs_segctor_sync(sci);
2322 struct nilfs_sc_info *sci = nilfs->ns_writer;
2327 if (sb_rdonly(sb) || unlikely(!sci))
2335 test_bit(NILFS_SC_UNCLOSED, &sci->sc_flags) ||
2338 err = nilfs_segctor_sync(sci);
2350 sci->sc_dsync_inode = ii;
2351 sci->sc_dsync_start = start;
2352 sci->sc_dsync_end = end;
2354 err = nilfs_segctor_do_construct(sci, SC_LSEG_DSYNC);
2367 * @sci: segment constructor object
2369 static void nilfs_segctor_accept(struct nilfs_sc_info *sci)
2371 spin_lock(&sci->sc_state_lock);
2372 sci->sc_seq_accepted = sci->sc_seq_request;
2373 spin_unlock(&sci->sc_state_lock);
2374 del_timer_sync(&sci->sc_timer);
2379 * @sci: segment constructor object
2383 static void nilfs_segctor_notify(struct nilfs_sc_info *sci, int mode, int err)
2386 spin_lock(&sci->sc_state_lock);
2389 sci->sc_state &= ~NILFS_SEGCTOR_COMMIT;
2390 sci->sc_seq_done = sci->sc_seq_accepted;
2391 nilfs_segctor_wakeup(sci, err);
2392 sci->sc_flush_request = 0;
2395 sci->sc_flush_request &= ~FLUSH_FILE_BIT;
2397 sci->sc_flush_request &= ~FLUSH_DAT_BIT;
2400 if ((sci->sc_state & NILFS_SEGCTOR_COMMIT) &&
2401 time_before(jiffies, sci->sc_timer.expires))
2402 add_timer(&sci->sc_timer);
2404 spin_unlock(&sci->sc_state_lock);
2409 * @sci: segment constructor object
2412 static int nilfs_segctor_construct(struct nilfs_sc_info *sci, int mode)
2414 struct the_nilfs *nilfs = sci->sc_super->s_fs_info;
2418 nilfs_segctor_accept(sci);
2422 if (!nilfs_segctor_confirm(sci))
2423 err = nilfs_segctor_do_construct(sci, mode);
2428 if (test_bit(NILFS_SC_SUPER_ROOT, &sci->sc_flags) &&
2432 sbp = nilfs_prepare_super(sci->sc_super,
2436 err = nilfs_commit_super(sci->sc_super,
2443 nilfs_segctor_notify(sci, mode, err);
2449 struct nilfs_sc_info *sci = from_timer(sci, t, sc_timer);
2451 wake_up_process(sci->sc_timer_task);
2473 struct nilfs_sc_info *sci = nilfs->ns_writer;
2477 if (unlikely(!sci))
2492 sci->sc_freesegs = kbufs[4];
2493 sci->sc_nfreesegs = argv[4].v_nmembs;
2494 list_splice_tail_init(&nilfs->ns_gc_inodes, &sci->sc_gc_inodes);
2497 err = nilfs_segctor_construct(sci, SC_LSEG_SR);
2498 nilfs_remove_written_gcinodes(nilfs, &sci->sc_gc_inodes);
2505 schedule_timeout(sci->sc_interval);
2508 int ret = nilfs_discard_segments(nilfs, sci->sc_freesegs,
2509 sci->sc_nfreesegs);
2519 sci->sc_freesegs = NULL;
2520 sci->sc_nfreesegs = 0;
2526 static void nilfs_segctor_thread_construct(struct nilfs_sc_info *sci, int mode)
2530 nilfs_transaction_lock(sci->sc_super, &ti, 0);
2531 nilfs_segctor_construct(sci, mode);
2538 if (test_bit(NILFS_SC_UNCLOSED, &sci->sc_flags))
2539 nilfs_segctor_start_timer(sci);
2541 nilfs_transaction_unlock(sci->sc_super);
2544 static void nilfs_segctor_do_immediate_flush(struct nilfs_sc_info *sci)
2548 spin_lock(&sci->sc_state_lock);
2549 mode = (sci->sc_flush_request & FLUSH_DAT_BIT) ?
2551 spin_unlock(&sci->sc_state_lock);
2554 nilfs_segctor_do_construct(sci, mode);
2556 spin_lock(&sci->sc_state_lock);
2557 sci->sc_flush_request &= (mode == SC_FLUSH_FILE) ?
2559 spin_unlock(&sci->sc_state_lock);
2561 clear_bit(NILFS_SC_PRIOR_FLUSH, &sci->sc_flags);
2564 static int nilfs_segctor_flush_mode(struct nilfs_sc_info *sci)
2566 if (!test_bit(NILFS_SC_UNCLOSED, &sci->sc_flags) ||
2567 time_before(jiffies, sci->sc_lseg_stime + sci->sc_mjcp_freq)) {
2568 if (!(sci->sc_flush_request & ~FLUSH_FILE_BIT))
2570 else if (!(sci->sc_flush_request & ~FLUSH_DAT_BIT))
2585 struct nilfs_sc_info *sci = (struct nilfs_sc_info *)arg;
2586 struct the_nilfs *nilfs = sci->sc_super->s_fs_info;
2589 sci->sc_timer_task = current;
2592 sci->sc_task = current;
2593 wake_up(&sci->sc_wait_task); /* for nilfs_segctor_start_thread() */
2594 nilfs_info(sci->sc_super,
2596 sci->sc_interval / HZ, sci->sc_mjcp_freq / HZ);
2598 spin_lock(&sci->sc_state_lock);
2603 if (sci->sc_state & NILFS_SEGCTOR_QUIT)
2606 if (timeout || sci->sc_seq_request != sci->sc_seq_done)
2608 else if (sci->sc_flush_request)
2609 mode = nilfs_segctor_flush_mode(sci);
2613 spin_unlock(&sci->sc_state_lock);
2614 nilfs_segctor_thread_construct(sci, mode);
2615 spin_lock(&sci->sc_state_lock);
2621 spin_unlock(&sci->sc_state_lock);
2623 spin_lock(&sci->sc_state_lock);
2628 prepare_to_wait(&sci->sc_wait_daemon, &wait,
2631 if (sci->sc_seq_request != sci->sc_seq_done)
2633 else if (sci->sc_flush_request)
2635 else if (sci->sc_state & NILFS_SEGCTOR_COMMIT)
2637 sci->sc_timer.expires);
2640 spin_unlock(&sci->sc_state_lock);
2642 spin_lock(&sci->sc_state_lock);
2644 finish_wait(&sci->sc_wait_daemon, &wait);
2645 timeout = ((sci->sc_state & NILFS_SEGCTOR_COMMIT) &&
2646 time_after_eq(jiffies, sci->sc_timer.expires));
2655 sci->sc_task = NULL;
2656 wake_up(&sci->sc_wait_task); /* for nilfs_segctor_kill_thread() */
2657 spin_unlock(&sci->sc_state_lock);
2661 static int nilfs_segctor_start_thread(struct nilfs_sc_info *sci)
2665 t = kthread_run(nilfs_segctor_thread, sci, "segctord");
2669 nilfs_err(sci->sc_super, "error %d creating segctord thread",
2673 wait_event(sci->sc_wait_task, sci->sc_task != NULL);
2677 static void nilfs_segctor_kill_thread(struct nilfs_sc_info *sci)
2678 __acquires(&sci->sc_state_lock)
2679 __releases(&sci->sc_state_lock)
2681 sci->sc_state |= NILFS_SEGCTOR_QUIT;
2683 while (sci->sc_task) {
2684 wake_up(&sci->sc_wait_daemon);
2685 spin_unlock(&sci->sc_state_lock);
2686 wait_event(sci->sc_wait_task, sci->sc_task == NULL);
2687 spin_lock(&sci->sc_state_lock);
2698 struct nilfs_sc_info *sci;
2700 sci = kzalloc(sizeof(*sci), GFP_KERNEL);
2701 if (!sci)
2704 sci->sc_super = sb;
2707 sci->sc_root = root;
2709 init_waitqueue_head(&sci->sc_wait_request);
2710 init_waitqueue_head(&sci->sc_wait_daemon);
2711 init_waitqueue_head(&sci->sc_wait_task);
2712 spin_lock_init(&sci->sc_state_lock);
2713 INIT_LIST_HEAD(&sci->sc_dirty_files);
2714 INIT_LIST_HEAD(&sci->sc_segbufs);
2715 INIT_LIST_HEAD(&sci->sc_write_logs);
2716 INIT_LIST_HEAD(&sci->sc_gc_inodes);
2717 INIT_LIST_HEAD(&sci->sc_iput_queue);
2718 INIT_WORK(&sci->sc_iput_work, nilfs_iput_work_func);
2719 timer_setup(&sci->sc_timer, nilfs_construction_timeout, 0);
2721 sci->sc_interval = HZ * NILFS_SC_DEFAULT_TIMEOUT;
2722 sci->sc_mjcp_freq = HZ * NILFS_SC_DEFAULT_SR_FREQ;
2723 sci->sc_watermark = NILFS_SC_DEFAULT_WATERMARK;
2726 sci->sc_interval = HZ * nilfs->ns_interval;
2728 sci->sc_watermark = nilfs->ns_watermark;
2729 return sci;
2732 static void nilfs_segctor_write_out(struct nilfs_sc_info *sci)
2743 nilfs_transaction_lock(sci->sc_super, &ti, 0);
2744 ret = nilfs_segctor_construct(sci, SC_LSEG_SR);
2745 nilfs_transaction_unlock(sci->sc_super);
2747 flush_work(&sci->sc_iput_work);
2754 * @sci: nilfs_sc_info
2760 static void nilfs_segctor_destroy(struct nilfs_sc_info *sci)
2762 struct the_nilfs *nilfs = sci->sc_super->s_fs_info;
2767 spin_lock(&sci->sc_state_lock);
2768 nilfs_segctor_kill_thread(sci);
2769 flag = ((sci->sc_state & NILFS_SEGCTOR_COMMIT) || sci->sc_flush_request
2770 || sci->sc_seq_request != sci->sc_seq_done);
2771 spin_unlock(&sci->sc_state_lock);
2773 if (flush_work(&sci->sc_iput_work))
2776 if (flag || !nilfs_segctor_confirm(sci))
2777 nilfs_segctor_write_out(sci);
2779 if (!list_empty(&sci->sc_dirty_files)) {
2780 nilfs_warn(sci->sc_super,
2782 nilfs_dispose_list(nilfs, &sci->sc_dirty_files, 1);
2785 if (!list_empty(&sci->sc_iput_queue)) {
2786 nilfs_warn(sci->sc_super,
2788 nilfs_dispose_list(nilfs, &sci->sc_iput_queue, 1);
2791 WARN_ON(!list_empty(&sci->sc_segbufs));
2792 WARN_ON(!list_empty(&sci->sc_write_logs));
2794 nilfs_put_root(sci->sc_root);
2798 del_timer_sync(&sci->sc_timer);
2799 kfree(sci);