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;
271 struct nilfs_sc_info *sci = nilfs->ns_writer;
274 nilfs_segctor_start_timer(sci);
275 if (atomic_read(&nilfs->ns_ndirtyblks) > sci->sc_watermark)
276 nilfs_segctor_do_flush(sci, 0);
318 struct nilfs_sc_info *sci = nilfs->ns_writer;
320 if (sb_rdonly(sb) || unlikely(!sci) || !sci->sc_flush_request)
323 set_bit(NILFS_SC_PRIOR_FLUSH, &sci->sc_flags);
327 if (sci->sc_flush_request &&
328 test_bit(NILFS_SC_PRIOR_FLUSH, &sci->sc_flags)) {
332 nilfs_segctor_do_immediate_flush(sci);
344 struct nilfs_sc_info *sci = nilfs->ns_writer;
358 if (!test_bit(NILFS_SC_PRIOR_FLUSH, &sci->sc_flags))
361 nilfs_segctor_do_immediate_flush(sci);
388 static void *nilfs_segctor_map_segsum_entry(struct nilfs_sc_info *sci,
392 struct nilfs_segment_buffer *segbuf = sci->sc_curseg;
393 unsigned int blocksize = sci->sc_super->s_blocksize;
409 * @sci: nilfs_sc_info
411 static int nilfs_segctor_reset_segment_buffer(struct nilfs_sc_info *sci)
413 struct nilfs_segment_buffer *segbuf = sci->sc_curseg;
421 err = nilfs_segbuf_reset(segbuf, flags, sci->sc_seg_ctime, sci->sc_cno);
427 sci->sc_finfo_ptr.bh = sumbh; sci->sc_finfo_ptr.offset = sumbytes;
428 sci->sc_binfo_ptr.bh = sumbh; sci->sc_binfo_ptr.offset = sumbytes;
429 sci->sc_blk_cnt = sci->sc_datablk_cnt = 0;
435 * @sci: segment constructor object
440 static void nilfs_segctor_zeropad_segsum(struct nilfs_sc_info *sci)
444 ssp = sci->sc_blk_cnt > 0 ? &sci->sc_binfo_ptr : &sci->sc_finfo_ptr;
450 static int nilfs_segctor_feed_segment(struct nilfs_sc_info *sci)
452 sci->sc_nblk_this_inc += sci->sc_curseg->sb_sum.nblocks;
453 if (NILFS_SEGBUF_IS_LAST(sci->sc_curseg, &sci->sc_segbufs))
458 nilfs_segctor_zeropad_segsum(sci);
459 sci->sc_curseg = NILFS_NEXT_SEGBUF(sci->sc_curseg);
460 return nilfs_segctor_reset_segment_buffer(sci);
463 static int nilfs_segctor_add_super_root(struct nilfs_sc_info *sci)
465 struct nilfs_segment_buffer *segbuf = sci->sc_curseg;
469 err = nilfs_segctor_feed_segment(sci);
472 segbuf = sci->sc_curseg;
484 struct nilfs_sc_info *sci, const struct nilfs_segsum_pointer *ssp,
487 unsigned int blocksize = sci->sc_super->s_blocksize;
491 (!sci->sc_blk_cnt ? sizeof(struct nilfs_finfo) : 0) >
495 static void nilfs_segctor_begin_finfo(struct nilfs_sc_info *sci,
498 sci->sc_curseg->sb_sum.nfinfo++;
499 sci->sc_binfo_ptr = sci->sc_finfo_ptr;
501 sci, &sci->sc_binfo_ptr, sizeof(struct nilfs_finfo));
504 !test_bit(NILFS_SC_HAVE_DELTA, &sci->sc_flags))
505 set_bit(NILFS_SC_HAVE_DELTA, &sci->sc_flags);
509 static void nilfs_segctor_end_finfo(struct nilfs_sc_info *sci,
517 if (sci->sc_blk_cnt == 0)
527 cno = sci->sc_cno;
529 finfo = nilfs_segctor_map_segsum_entry(sci, &sci->sc_finfo_ptr,
532 finfo->fi_nblocks = cpu_to_le32(sci->sc_blk_cnt);
533 finfo->fi_ndatablk = cpu_to_le32(sci->sc_datablk_cnt);
536 segbuf = sci->sc_curseg;
537 segbuf->sb_sum.sumbytes = sci->sc_binfo_ptr.offset +
538 sci->sc_super->s_blocksize * (segbuf->sb_sum.nsumblk - 1);
539 sci->sc_finfo_ptr = sci->sc_binfo_ptr;
540 sci->sc_blk_cnt = sci->sc_datablk_cnt = 0;
543 static int nilfs_segctor_add_file_block(struct nilfs_sc_info *sci,
552 segbuf = sci->sc_curseg;
554 sci, &sci->sc_binfo_ptr, binfo_size);
556 nilfs_segctor_end_finfo(sci, inode);
557 err = nilfs_segctor_feed_segment(sci);
563 nilfs_segctor_zeropad_segsum(sci);
568 if (sci->sc_blk_cnt == 0)
569 nilfs_segctor_begin_finfo(sci, inode);
571 nilfs_segctor_map_segsum_entry(sci, &sci->sc_binfo_ptr, binfo_size);
574 sci->sc_blk_cnt++;
582 static int nilfs_collect_file_data(struct nilfs_sc_info *sci,
591 err = nilfs_segctor_add_file_block(sci, bh, inode,
594 sci->sc_datablk_cnt++;
598 static int nilfs_collect_file_node(struct nilfs_sc_info *sci,
605 static int nilfs_collect_file_bmap(struct nilfs_sc_info *sci,
610 return nilfs_segctor_add_file_block(sci, bh, inode, sizeof(__le64));
613 static void nilfs_write_file_data_binfo(struct nilfs_sc_info *sci,
618 sci, ssp, sizeof(*binfo_v));
622 static void nilfs_write_file_node_binfo(struct nilfs_sc_info *sci,
627 sci, ssp, sizeof(*vblocknr));
639 static int nilfs_collect_dat_data(struct nilfs_sc_info *sci,
648 err = nilfs_segctor_add_file_block(sci, bh, inode, sizeof(__le64));
650 sci->sc_datablk_cnt++;
654 static int nilfs_collect_dat_bmap(struct nilfs_sc_info *sci,
658 return nilfs_segctor_add_file_block(sci, bh, inode,
662 static void nilfs_write_dat_data_binfo(struct nilfs_sc_info *sci,
666 __le64 *blkoff = nilfs_segctor_map_segsum_entry(sci, ssp,
671 static void nilfs_write_dat_node_binfo(struct nilfs_sc_info *sci,
676 nilfs_segctor_map_segsum_entry(sci, ssp, sizeof(*binfo_dat));
827 struct nilfs_sc_info *sci = container_of(work, struct nilfs_sc_info,
829 struct the_nilfs *nilfs = sci->sc_super->s_fs_info;
831 nilfs_dispose_list(nilfs, &sci->sc_iput_queue, 0);
850 static int nilfs_segctor_clean(struct nilfs_sc_info *sci)
852 return list_empty(&sci->sc_dirty_files) &&
853 !test_bit(NILFS_SC_DIRTY, &sci->sc_flags) &&
854 sci->sc_nfreesegs == 0 &&
855 (!nilfs_doing_gc() || list_empty(&sci->sc_gc_inodes));
858 static int nilfs_segctor_confirm(struct nilfs_sc_info *sci)
860 struct the_nilfs *nilfs = sci->sc_super->s_fs_info;
863 if (nilfs_test_metadata_dirty(nilfs, sci->sc_root))
864 set_bit(NILFS_SC_DIRTY, &sci->sc_flags);
867 if (list_empty(&nilfs->ns_dirty_files) && nilfs_segctor_clean(sci))
874 static void nilfs_segctor_clear_metadata_dirty(struct nilfs_sc_info *sci)
876 struct the_nilfs *nilfs = sci->sc_super->s_fs_info;
878 nilfs_mdt_clear_dirty(sci->sc_root->ifile);
884 static int nilfs_segctor_create_checkpoint(struct nilfs_sc_info *sci)
886 struct the_nilfs *nilfs = sci->sc_super->s_fs_info;
905 nilfs_error(sci->sc_super,
912 static int nilfs_segctor_fill_in_checkpoint(struct nilfs_sc_info *sci)
914 struct the_nilfs *nilfs = sci->sc_super->s_fs_info;
923 nilfs_error(sci->sc_super,
932 cpu_to_le64(atomic64_read(&sci->sc_root->inodes_count));
934 cpu_to_le64(atomic64_read(&sci->sc_root->blocks_count));
936 cpu_to_le64(sci->sc_nblk_inc + sci->sc_nblk_this_inc);
937 raw_cp->cp_create = cpu_to_le64(sci->sc_seg_ctime);
940 if (test_bit(NILFS_SC_HAVE_DELTA, &sci->sc_flags))
945 nilfs_write_inode_common(sci->sc_root->ifile,
971 static void nilfs_segctor_fill_in_file_bmap(struct nilfs_sc_info *sci)
975 list_for_each_entry(ii, &sci->sc_dirty_files, i_dirty) {
976 nilfs_fill_in_file_bmap(sci->sc_root->ifile, ii);
981 static void nilfs_segctor_fill_in_super_root(struct nilfs_sc_info *sci,
988 bh_sr = NILFS_LAST_SEGBUF(&sci->sc_segbufs)->sb_super_root;
999 nilfs->ns_nongc_ctime : sci->sc_seg_ctime);
1036 static int nilfs_segctor_apply_buffers(struct nilfs_sc_info *sci,
1049 err = collect(sci, bh, inode);
1067 static size_t nilfs_segctor_buffer_rest(struct nilfs_sc_info *sci)
1070 return sci->sc_segbuf_nblocks -
1071 (sci->sc_nblk_this_inc + sci->sc_curseg->sb_sum.nblocks);
1074 static int nilfs_segctor_scan_file(struct nilfs_sc_info *sci,
1082 if (!(sci->sc_stage.flags & NILFS_CF_NODE)) {
1083 size_t n, rest = nilfs_segctor_buffer_rest(sci);
1089 sci, inode, &data_buffers,
1097 if (!(sci->sc_stage.flags & NILFS_CF_NODE)) {
1099 sci, inode, &data_buffers, sc_ops->collect_data);
1103 sci, inode, &node_buffers, NULL);
1106 sci->sc_stage.flags |= NILFS_CF_NODE;
1110 sci, inode, &node_buffers, sc_ops->collect_node);
1116 sci, inode, &node_buffers, sc_ops->collect_bmap);
1120 nilfs_segctor_end_finfo(sci, inode);
1121 sci->sc_stage.flags &= ~NILFS_CF_NODE;
1127 static int nilfs_segctor_scan_file_dsync(struct nilfs_sc_info *sci,
1131 size_t n, rest = nilfs_segctor_buffer_rest(sci);
1135 sci->sc_dsync_start,
1136 sci->sc_dsync_end);
1138 err = nilfs_segctor_apply_buffers(sci, inode, &data_buffers,
1141 nilfs_segctor_end_finfo(sci, inode);
1148 static int nilfs_segctor_collect_blocks(struct nilfs_sc_info *sci, int mode)
1150 struct the_nilfs *nilfs = sci->sc_super->s_fs_info;
1156 switch (nilfs_sc_cstage_get(sci)) {
1159 sci->sc_stage.flags = 0;
1161 if (!test_bit(NILFS_SC_UNCLOSED, &sci->sc_flags)) {
1162 sci->sc_nblk_inc = 0;
1163 sci->sc_curseg->sb_sum.flags = NILFS_SS_LOGBGN;
1165 nilfs_sc_cstage_set(sci, NILFS_ST_DSYNC);
1170 sci->sc_stage.dirty_file_ptr = NULL;
1171 sci->sc_stage.gc_inode_ptr = NULL;
1173 nilfs_sc_cstage_set(sci, NILFS_ST_DAT);
1176 nilfs_sc_cstage_inc(sci);
1180 head = &sci->sc_gc_inodes;
1181 ii = list_prepare_entry(sci->sc_stage.gc_inode_ptr,
1185 sci, &ii->vfs_inode,
1188 sci->sc_stage.gc_inode_ptr = list_entry(
1196 sci->sc_stage.gc_inode_ptr = NULL;
1198 nilfs_sc_cstage_inc(sci);
1201 head = &sci->sc_dirty_files;
1202 ii = list_prepare_entry(sci->sc_stage.dirty_file_ptr, head,
1207 err = nilfs_segctor_scan_file(sci, &ii->vfs_inode,
1210 sci->sc_stage.dirty_file_ptr =
1216 /* sci->sc_stage.dirty_file_ptr = NILFS_I(inode); */
1219 sci->sc_stage.dirty_file_ptr = NULL;
1221 nilfs_sc_cstage_set(sci, NILFS_ST_DONE);
1224 nilfs_sc_cstage_inc(sci);
1225 sci->sc_stage.flags |= NILFS_CF_IFILE_STARTED;
1228 err = nilfs_segctor_scan_file(sci, sci->sc_root->ifile,
1232 nilfs_sc_cstage_inc(sci);
1234 err = nilfs_segctor_create_checkpoint(sci);
1239 err = nilfs_segctor_scan_file(sci, nilfs->ns_cpfile,
1243 nilfs_sc_cstage_inc(sci);
1246 err = nilfs_sufile_freev(nilfs->ns_sufile, sci->sc_freesegs,
1247 sci->sc_nfreesegs, &ndone);
1250 sci->sc_freesegs, ndone,
1254 sci->sc_stage.flags |= NILFS_CF_SUFREED;
1256 err = nilfs_segctor_scan_file(sci, nilfs->ns_sufile,
1260 nilfs_sc_cstage_inc(sci);
1264 err = nilfs_segctor_scan_file(sci, nilfs->ns_dat,
1269 nilfs_sc_cstage_set(sci, NILFS_ST_DONE);
1272 nilfs_sc_cstage_inc(sci);
1277 err = nilfs_segctor_add_super_root(sci);
1282 sci->sc_curseg->sb_sum.flags |= NILFS_SS_LOGEND;
1283 nilfs_sc_cstage_set(sci, NILFS_ST_DONE);
1287 sci->sc_curseg->sb_sum.flags |= NILFS_SS_SYNDT;
1288 ii = sci->sc_dsync_inode;
1292 err = nilfs_segctor_scan_file_dsync(sci, &ii->vfs_inode);
1295 sci->sc_curseg->sb_sum.flags |= NILFS_SS_LOGEND;
1296 nilfs_sc_cstage_set(sci, NILFS_ST_DONE);
1310 * @sci: nilfs_sc_info
1313 static int nilfs_segctor_begin_construction(struct nilfs_sc_info *sci,
1320 segbuf = nilfs_segbuf_new(sci->sc_super);
1324 if (list_empty(&sci->sc_write_logs)) {
1340 prev = NILFS_LAST_SEGBUF(&sci->sc_write_logs);
1363 BUG_ON(!list_empty(&sci->sc_segbufs));
1364 list_add_tail(&segbuf->sb_list, &sci->sc_segbufs);
1365 sci->sc_segbuf_nblocks = segbuf->sb_rest_blocks;
1373 static int nilfs_segctor_extend_segments(struct nilfs_sc_info *sci,
1382 prev = NILFS_LAST_SEGBUF(&sci->sc_segbufs);
1396 segbuf = nilfs_segbuf_new(sci->sc_super);
1402 sci->sc_segbuf_nblocks += segbuf->sb_rest_blocks;
1415 list_splice_tail(&list, &sci->sc_segbufs);
1468 static void nilfs_segctor_update_segusage(struct nilfs_sc_info *sci,
1475 list_for_each_entry(segbuf, &sci->sc_segbufs, sb_list) {
1480 sci->sc_seg_ctime);
1503 static void nilfs_segctor_truncate_segments(struct nilfs_sc_info *sci,
1510 list_for_each_entry_continue(segbuf, &sci->sc_segbufs, sb_list) {
1511 sci->sc_segbuf_nblocks -= segbuf->sb_rest_blocks;
1515 nilfs_truncate_logs(&sci->sc_segbufs, last);
1519 static int nilfs_segctor_collect(struct nilfs_sc_info *sci,
1522 struct nilfs_cstage prev_stage = sci->sc_stage;
1527 sci->sc_nblk_this_inc = 0;
1528 sci->sc_curseg = NILFS_FIRST_SEGBUF(&sci->sc_segbufs);
1530 err = nilfs_segctor_reset_segment_buffer(sci);
1534 err = nilfs_segctor_collect_blocks(sci, mode);
1535 sci->sc_nblk_this_inc += sci->sc_curseg->sb_sum.nblocks;
1544 nilfs_sc_cstage_get(sci) < NILFS_ST_CPFILE)
1547 nilfs_clear_logs(&sci->sc_segbufs);
1549 if (sci->sc_stage.flags & NILFS_CF_SUFREED) {
1551 sci->sc_freesegs,
1552 sci->sc_nfreesegs,
1555 sci->sc_stage.flags &= ~NILFS_CF_SUFREED;
1558 err = nilfs_segctor_extend_segments(sci, nilfs, nadd);
1563 sci->sc_stage = prev_stage;
1565 nilfs_segctor_zeropad_segsum(sci);
1566 nilfs_segctor_truncate_segments(sci, sci->sc_curseg, nilfs->ns_sufile);
1583 nilfs_segctor_update_payload_blocknr(struct nilfs_sc_info *sci,
1611 sci, &ssp, sizeof(*finfo));
1636 sc_op->write_data_binfo(sci, &ssp, &binfo);
1638 sc_op->write_node_binfo(sci, &ssp, &binfo);
1655 static int nilfs_segctor_assign(struct nilfs_sc_info *sci, int mode)
1660 list_for_each_entry(segbuf, &sci->sc_segbufs, sb_list) {
1661 err = nilfs_segctor_update_payload_blocknr(sci, segbuf, mode);
1684 static void nilfs_segctor_prepare_write(struct nilfs_sc_info *sci)
1689 list_for_each_entry(segbuf, &sci->sc_segbufs, sb_list) {
1733 static int nilfs_segctor_write(struct nilfs_sc_info *sci,
1738 ret = nilfs_write_logs(&sci->sc_segbufs, nilfs);
1739 list_splice_tail_init(&sci->sc_segbufs, &sci->sc_write_logs);
1824 static void nilfs_segctor_abort_construction(struct nilfs_sc_info *sci,
1830 list_splice_tail_init(&sci->sc_write_logs, &logs);
1834 list_splice_tail_init(&sci->sc_segbufs, &logs);
1838 if (sci->sc_stage.flags & NILFS_CF_SUFREED) {
1840 sci->sc_freesegs,
1841 sci->sc_nfreesegs,
1860 static void nilfs_segctor_complete_write(struct nilfs_sc_info *sci)
1864 struct the_nilfs *nilfs = sci->sc_super->s_fs_info;
1867 list_for_each_entry(segbuf, &sci->sc_write_logs, sb_list) {
1918 set_bit(NILFS_SC_UNCLOSED, &sci->sc_flags);
1919 sci->sc_lseg_stime = jiffies;
1922 clear_bit(NILFS_SC_UNCLOSED, &sci->sc_flags);
1934 nilfs_drop_collected_inodes(&sci->sc_dirty_files);
1937 nilfs_drop_collected_inodes(&sci->sc_gc_inodes);
1939 nilfs->ns_nongc_ctime = sci->sc_seg_ctime;
1941 sci->sc_nblk_inc += sci->sc_nblk_this_inc;
1943 segbuf = NILFS_LAST_SEGBUF(&sci->sc_write_logs);
1951 clear_bit(NILFS_SC_HAVE_DELTA, &sci->sc_flags);
1952 clear_bit(NILFS_SC_DIRTY, &sci->sc_flags);
1953 set_bit(NILFS_SC_SUPER_ROOT, &sci->sc_flags);
1954 nilfs_segctor_clear_metadata_dirty(sci);
1956 clear_bit(NILFS_SC_SUPER_ROOT, &sci->sc_flags);
1959 static int nilfs_segctor_wait(struct nilfs_sc_info *sci)
1963 ret = nilfs_wait_on_logs(&sci->sc_write_logs);
1965 nilfs_segctor_complete_write(sci);
1966 nilfs_destroy_logs(&sci->sc_write_logs);
1971 static int nilfs_segctor_collect_dirty_files(struct nilfs_sc_info *sci,
1975 struct inode *ifile = sci->sc_root->ifile;
1988 nilfs_warn(sci->sc_super,
2007 list_move_tail(&ii->i_dirty, &sci->sc_dirty_files);
2014 static void nilfs_segctor_drop_written_files(struct nilfs_sc_info *sci,
2018 int during_mount = !(sci->sc_super->s_flags & SB_ACTIVE);
2022 list_for_each_entry_safe(ii, n, &sci->sc_dirty_files, i_dirty) {
2036 list_add_tail(&ii->i_dirty, &sci->sc_iput_queue);
2047 schedule_work(&sci->sc_iput_work);
2053 static int nilfs_segctor_do_construct(struct nilfs_sc_info *sci, int mode)
2055 struct the_nilfs *nilfs = sci->sc_super->s_fs_info;
2058 if (sb_rdonly(sci->sc_super))
2061 nilfs_sc_cstage_set(sci, NILFS_ST_INIT);
2062 sci->sc_cno = nilfs->ns_cno;
2064 err = nilfs_segctor_collect_dirty_files(sci, nilfs);
2068 if (nilfs_test_metadata_dirty(nilfs, sci->sc_root))
2069 set_bit(NILFS_SC_DIRTY, &sci->sc_flags);
2071 if (nilfs_segctor_clean(sci))
2075 sci->sc_stage.flags &= ~NILFS_CF_HISTORY_MASK;
2077 err = nilfs_segctor_begin_construction(sci, nilfs);
2082 sci->sc_seg_ctime = ktime_get_real_seconds();
2084 err = nilfs_segctor_collect(sci, nilfs, mode);
2089 if (nilfs_sc_cstage_get(sci) == NILFS_ST_DONE &&
2090 nilfs_segbuf_empty(sci->sc_curseg)) {
2091 nilfs_segctor_abort_construction(sci, nilfs, 1);
2095 err = nilfs_segctor_assign(sci, mode);
2099 if (sci->sc_stage.flags & NILFS_CF_IFILE_STARTED)
2100 nilfs_segctor_fill_in_file_bmap(sci);
2103 nilfs_sc_cstage_get(sci) >= NILFS_ST_CPFILE) {
2104 err = nilfs_segctor_fill_in_checkpoint(sci);
2108 nilfs_segctor_fill_in_super_root(sci, nilfs);
2110 nilfs_segctor_update_segusage(sci, nilfs->ns_sufile);
2113 nilfs_segctor_prepare_write(sci);
2115 nilfs_add_checksums_on_logs(&sci->sc_segbufs,
2118 err = nilfs_segctor_write(sci, nilfs);
2122 if (nilfs_sc_cstage_get(sci) == NILFS_ST_DONE ||
2131 err = nilfs_segctor_wait(sci);
2135 } while (nilfs_sc_cstage_get(sci) != NILFS_ST_DONE);
2138 nilfs_segctor_drop_written_files(sci, nilfs);
2142 if (sci->sc_stage.flags & NILFS_CF_IFILE_STARTED)
2143 nilfs_redirty_inodes(&sci->sc_dirty_files);
2147 nilfs_redirty_inodes(&sci->sc_gc_inodes);
2148 nilfs_segctor_abort_construction(sci, nilfs, err);
2154 * @sci: nilfs_sc_info
2160 static void nilfs_segctor_start_timer(struct nilfs_sc_info *sci)
2162 spin_lock(&sci->sc_state_lock);
2163 if (!(sci->sc_state & NILFS_SEGCTOR_COMMIT)) {
2164 sci->sc_timer.expires = jiffies + sci->sc_interval;
2165 add_timer(&sci->sc_timer);
2166 sci->sc_state |= NILFS_SEGCTOR_COMMIT;
2168 spin_unlock(&sci->sc_state_lock);
2171 static void nilfs_segctor_do_flush(struct nilfs_sc_info *sci, int bn)
2173 spin_lock(&sci->sc_state_lock);
2174 if (!(sci->sc_flush_request & BIT(bn))) {
2175 unsigned long prev_req = sci->sc_flush_request;
2177 sci->sc_flush_request |= BIT(bn);
2179 wake_up(&sci->sc_wait_daemon);
2181 spin_unlock(&sci->sc_state_lock);
2192 struct nilfs_sc_info *sci = nilfs->ns_writer;
2194 if (!sci || nilfs_doing_construction())
2196 nilfs_segctor_do_flush(sci, NILFS_MDT_INODE(sb, ino) ? ino : 0);
2207 static int nilfs_segctor_sync(struct nilfs_sc_info *sci)
2212 spin_lock(&sci->sc_state_lock);
2216 wait_req.seq = ++sci->sc_seq_request;
2217 spin_unlock(&sci->sc_state_lock);
2220 add_wait_queue(&sci->sc_wait_request, &wait_req.wq);
2222 wake_up(&sci->sc_wait_daemon);
2236 finish_wait(&sci->sc_wait_request, &wait_req.wq);
2240 static void nilfs_segctor_wakeup(struct nilfs_sc_info *sci, int err)
2245 spin_lock_irqsave(&sci->sc_wait_request.lock, flags);
2246 list_for_each_entry_safe(wrq, n, &sci->sc_wait_request.head, wq.entry) {
2248 nilfs_cnt32_ge(sci->sc_seq_done, wrq->seq)) {
2258 spin_unlock_irqrestore(&sci->sc_wait_request.lock, flags);
2281 struct nilfs_sc_info *sci = nilfs->ns_writer;
2284 if (sb_rdonly(sb) || unlikely(!sci))
2290 return nilfs_segctor_sync(sci);
2317 struct nilfs_sc_info *sci = nilfs->ns_writer;
2322 if (sb_rdonly(sb) || unlikely(!sci))
2330 test_bit(NILFS_SC_UNCLOSED, &sci->sc_flags) ||
2333 err = nilfs_segctor_sync(sci);
2345 sci->sc_dsync_inode = ii;
2346 sci->sc_dsync_start = start;
2347 sci->sc_dsync_end = end;
2349 err = nilfs_segctor_do_construct(sci, SC_LSEG_DSYNC);
2362 * @sci: segment constructor object
2364 static void nilfs_segctor_accept(struct nilfs_sc_info *sci)
2366 spin_lock(&sci->sc_state_lock);
2367 sci->sc_seq_accepted = sci->sc_seq_request;
2368 spin_unlock(&sci->sc_state_lock);
2369 del_timer_sync(&sci->sc_timer);
2374 * @sci: segment constructor object
2378 static void nilfs_segctor_notify(struct nilfs_sc_info *sci, int mode, int err)
2381 spin_lock(&sci->sc_state_lock);
2384 sci->sc_state &= ~NILFS_SEGCTOR_COMMIT;
2385 sci->sc_seq_done = sci->sc_seq_accepted;
2386 nilfs_segctor_wakeup(sci, err);
2387 sci->sc_flush_request = 0;
2390 sci->sc_flush_request &= ~FLUSH_FILE_BIT;
2392 sci->sc_flush_request &= ~FLUSH_DAT_BIT;
2395 if ((sci->sc_state & NILFS_SEGCTOR_COMMIT) &&
2396 time_before(jiffies, sci->sc_timer.expires))
2397 add_timer(&sci->sc_timer);
2399 spin_unlock(&sci->sc_state_lock);
2404 * @sci: segment constructor object
2407 static int nilfs_segctor_construct(struct nilfs_sc_info *sci, int mode)
2409 struct the_nilfs *nilfs = sci->sc_super->s_fs_info;
2413 nilfs_segctor_accept(sci);
2417 if (!nilfs_segctor_confirm(sci))
2418 err = nilfs_segctor_do_construct(sci, mode);
2423 if (test_bit(NILFS_SC_SUPER_ROOT, &sci->sc_flags) &&
2427 sbp = nilfs_prepare_super(sci->sc_super,
2431 err = nilfs_commit_super(sci->sc_super,
2438 nilfs_segctor_notify(sci, mode, err);
2444 struct nilfs_sc_info *sci = from_timer(sci, t, sc_timer);
2446 wake_up_process(sci->sc_timer_task);
2468 struct nilfs_sc_info *sci = nilfs->ns_writer;
2472 if (unlikely(!sci))
2487 sci->sc_freesegs = kbufs[4];
2488 sci->sc_nfreesegs = argv[4].v_nmembs;
2489 list_splice_tail_init(&nilfs->ns_gc_inodes, &sci->sc_gc_inodes);
2492 err = nilfs_segctor_construct(sci, SC_LSEG_SR);
2493 nilfs_remove_written_gcinodes(nilfs, &sci->sc_gc_inodes);
2500 schedule_timeout(sci->sc_interval);
2503 int ret = nilfs_discard_segments(nilfs, sci->sc_freesegs,
2504 sci->sc_nfreesegs);
2514 sci->sc_freesegs = NULL;
2515 sci->sc_nfreesegs = 0;
2521 static void nilfs_segctor_thread_construct(struct nilfs_sc_info *sci, int mode)
2525 nilfs_transaction_lock(sci->sc_super, &ti, 0);
2526 nilfs_segctor_construct(sci, mode);
2533 if (test_bit(NILFS_SC_UNCLOSED, &sci->sc_flags))
2534 nilfs_segctor_start_timer(sci);
2536 nilfs_transaction_unlock(sci->sc_super);
2539 static void nilfs_segctor_do_immediate_flush(struct nilfs_sc_info *sci)
2543 spin_lock(&sci->sc_state_lock);
2544 mode = (sci->sc_flush_request & FLUSH_DAT_BIT) ?
2546 spin_unlock(&sci->sc_state_lock);
2549 nilfs_segctor_do_construct(sci, mode);
2551 spin_lock(&sci->sc_state_lock);
2552 sci->sc_flush_request &= (mode == SC_FLUSH_FILE) ?
2554 spin_unlock(&sci->sc_state_lock);
2556 clear_bit(NILFS_SC_PRIOR_FLUSH, &sci->sc_flags);
2559 static int nilfs_segctor_flush_mode(struct nilfs_sc_info *sci)
2561 if (!test_bit(NILFS_SC_UNCLOSED, &sci->sc_flags) ||
2562 time_before(jiffies, sci->sc_lseg_stime + sci->sc_mjcp_freq)) {
2563 if (!(sci->sc_flush_request & ~FLUSH_FILE_BIT))
2565 else if (!(sci->sc_flush_request & ~FLUSH_DAT_BIT))
2580 struct nilfs_sc_info *sci = (struct nilfs_sc_info *)arg;
2581 struct the_nilfs *nilfs = sci->sc_super->s_fs_info;
2584 sci->sc_timer_task = current;
2587 sci->sc_task = current;
2588 wake_up(&sci->sc_wait_task); /* for nilfs_segctor_start_thread() */
2589 nilfs_info(sci->sc_super,
2591 sci->sc_interval / HZ, sci->sc_mjcp_freq / HZ);
2593 spin_lock(&sci->sc_state_lock);
2598 if (sci->sc_state & NILFS_SEGCTOR_QUIT)
2601 if (timeout || sci->sc_seq_request != sci->sc_seq_done)
2603 else if (sci->sc_flush_request)
2604 mode = nilfs_segctor_flush_mode(sci);
2608 spin_unlock(&sci->sc_state_lock);
2609 nilfs_segctor_thread_construct(sci, mode);
2610 spin_lock(&sci->sc_state_lock);
2616 spin_unlock(&sci->sc_state_lock);
2618 spin_lock(&sci->sc_state_lock);
2623 prepare_to_wait(&sci->sc_wait_daemon, &wait,
2626 if (sci->sc_seq_request != sci->sc_seq_done)
2628 else if (sci->sc_flush_request)
2630 else if (sci->sc_state & NILFS_SEGCTOR_COMMIT)
2632 sci->sc_timer.expires);
2635 spin_unlock(&sci->sc_state_lock);
2637 spin_lock(&sci->sc_state_lock);
2639 finish_wait(&sci->sc_wait_daemon, &wait);
2640 timeout = ((sci->sc_state & NILFS_SEGCTOR_COMMIT) &&
2641 time_after_eq(jiffies, sci->sc_timer.expires));
2650 sci->sc_task = NULL;
2651 wake_up(&sci->sc_wait_task); /* for nilfs_segctor_kill_thread() */
2652 spin_unlock(&sci->sc_state_lock);
2656 static int nilfs_segctor_start_thread(struct nilfs_sc_info *sci)
2660 t = kthread_run(nilfs_segctor_thread, sci, "segctord");
2664 nilfs_err(sci->sc_super, "error %d creating segctord thread",
2668 wait_event(sci->sc_wait_task, sci->sc_task != NULL);
2672 static void nilfs_segctor_kill_thread(struct nilfs_sc_info *sci)
2673 __acquires(&sci->sc_state_lock)
2674 __releases(&sci->sc_state_lock)
2676 sci->sc_state |= NILFS_SEGCTOR_QUIT;
2678 while (sci->sc_task) {
2679 wake_up(&sci->sc_wait_daemon);
2680 spin_unlock(&sci->sc_state_lock);
2681 wait_event(sci->sc_wait_task, sci->sc_task == NULL);
2682 spin_lock(&sci->sc_state_lock);
2693 struct nilfs_sc_info *sci;
2695 sci = kzalloc(sizeof(*sci), GFP_KERNEL);
2696 if (!sci)
2699 sci->sc_super = sb;
2702 sci->sc_root = root;
2704 init_waitqueue_head(&sci->sc_wait_request);
2705 init_waitqueue_head(&sci->sc_wait_daemon);
2706 init_waitqueue_head(&sci->sc_wait_task);
2707 spin_lock_init(&sci->sc_state_lock);
2708 INIT_LIST_HEAD(&sci->sc_dirty_files);
2709 INIT_LIST_HEAD(&sci->sc_segbufs);
2710 INIT_LIST_HEAD(&sci->sc_write_logs);
2711 INIT_LIST_HEAD(&sci->sc_gc_inodes);
2712 INIT_LIST_HEAD(&sci->sc_iput_queue);
2713 INIT_WORK(&sci->sc_iput_work, nilfs_iput_work_func);
2714 timer_setup(&sci->sc_timer, nilfs_construction_timeout, 0);
2716 sci->sc_interval = HZ * NILFS_SC_DEFAULT_TIMEOUT;
2717 sci->sc_mjcp_freq = HZ * NILFS_SC_DEFAULT_SR_FREQ;
2718 sci->sc_watermark = NILFS_SC_DEFAULT_WATERMARK;
2721 sci->sc_interval = HZ * nilfs->ns_interval;
2723 sci->sc_watermark = nilfs->ns_watermark;
2724 return sci;
2727 static void nilfs_segctor_write_out(struct nilfs_sc_info *sci)
2738 nilfs_transaction_lock(sci->sc_super, &ti, 0);
2739 ret = nilfs_segctor_construct(sci, SC_LSEG_SR);
2740 nilfs_transaction_unlock(sci->sc_super);
2742 flush_work(&sci->sc_iput_work);
2749 * @sci: nilfs_sc_info
2755 static void nilfs_segctor_destroy(struct nilfs_sc_info *sci)
2757 struct the_nilfs *nilfs = sci->sc_super->s_fs_info;
2762 spin_lock(&sci->sc_state_lock);
2763 nilfs_segctor_kill_thread(sci);
2764 flag = ((sci->sc_state & NILFS_SEGCTOR_COMMIT) || sci->sc_flush_request
2765 || sci->sc_seq_request != sci->sc_seq_done);
2766 spin_unlock(&sci->sc_state_lock);
2768 if (flush_work(&sci->sc_iput_work))
2771 if (flag || !nilfs_segctor_confirm(sci))
2772 nilfs_segctor_write_out(sci);
2774 if (!list_empty(&sci->sc_dirty_files)) {
2775 nilfs_warn(sci->sc_super,
2777 nilfs_dispose_list(nilfs, &sci->sc_dirty_files, 1);
2780 if (!list_empty(&sci->sc_iput_queue)) {
2781 nilfs_warn(sci->sc_super,
2783 nilfs_dispose_list(nilfs, &sci->sc_iput_queue, 1);
2786 WARN_ON(!list_empty(&sci->sc_segbufs));
2787 WARN_ON(!list_empty(&sci->sc_write_logs));
2789 nilfs_put_root(sci->sc_root);
2793 timer_shutdown_sync(&sci->sc_timer);
2794 kfree(sci);