Lines Matching +full:sci +full:- +full:reset
1 // SPDX-License-Identifier: GPL-2.0+
5 * Copyright (C) 2005-2008 Nippon Telegraph and Telephone Corporation.
18 #include <linux/backing-dev.h>
82 * wrapper functions of stage count (nilfs_sc_info->sc_stage.scnt). Users of
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;
139 ((__s32)((a) - (b)) >= 0))
144 struct nilfs_transaction_info *cur_ti = current->journal_info;
148 if (cur_ti->ti_magic == NILFS_TI_MAGIC)
149 return ++cur_ti->ti_count;
157 save = current->journal_info;
162 return -ENOMEM;
163 ti->ti_flags = NILFS_TI_DYNAMIC_ALLOC;
165 ti->ti_flags = 0;
167 ti->ti_count = 0;
168 ti->ti_save = save;
169 ti->ti_magic = NILFS_TI_MAGIC;
170 current->journal_info = ti;
175 * nilfs_transaction_begin - start indivisible file operations.
188 * the outermost call. If a pre-allocated struct is given to @ti, it is used
196 * * %-ENOMEM - Insufficient memory available.
197 * * %-ENOSPC - No space left on device (if checking free space).
210 trace_ti = current->journal_info;
213 trace_ti->ti_count, trace_ti->ti_flags,
220 nilfs = sb->s_fs_info;
221 down_read(&nilfs->ns_segctor_sem);
223 up_read(&nilfs->ns_segctor_sem);
224 ret = -ENOSPC;
228 trace_ti = current->journal_info;
229 trace_nilfs2_transaction_transition(sb, trace_ti, trace_ti->ti_count,
230 trace_ti->ti_flags,
235 ti = current->journal_info;
236 current->journal_info = ti->ti_save;
237 if (ti->ti_flags & NILFS_TI_DYNAMIC_ALLOC)
244 * nilfs_transaction_commit - commit indivisible file operations.
258 struct nilfs_transaction_info *ti = current->journal_info;
259 struct the_nilfs *nilfs = sb->s_fs_info;
262 BUG_ON(ti == NULL || ti->ti_magic != NILFS_TI_MAGIC);
263 ti->ti_flags |= NILFS_TI_COMMIT;
264 if (ti->ti_count > 0) {
265 ti->ti_count--;
266 trace_nilfs2_transaction_transition(sb, ti, ti->ti_count,
267 ti->ti_flags, TRACE_NILFS2_TRANSACTION_COMMIT);
270 if (nilfs->ns_writer) {
271 struct nilfs_sc_info *sci = nilfs->ns_writer;
273 if (ti->ti_flags & NILFS_TI_COMMIT)
274 nilfs_segctor_start_timer(sci);
275 if (atomic_read(&nilfs->ns_ndirtyblks) > sci->sc_watermark)
276 nilfs_segctor_do_flush(sci, 0);
278 up_read(&nilfs->ns_segctor_sem);
279 trace_nilfs2_transaction_transition(sb, ti, ti->ti_count,
280 ti->ti_flags, TRACE_NILFS2_TRANSACTION_COMMIT);
282 current->journal_info = ti->ti_save;
284 if (ti->ti_flags & NILFS_TI_SYNC)
286 if (ti->ti_flags & NILFS_TI_DYNAMIC_ALLOC)
294 struct nilfs_transaction_info *ti = current->journal_info;
295 struct the_nilfs *nilfs = sb->s_fs_info;
297 BUG_ON(ti == NULL || ti->ti_magic != NILFS_TI_MAGIC);
298 if (ti->ti_count > 0) {
299 ti->ti_count--;
300 trace_nilfs2_transaction_transition(sb, ti, ti->ti_count,
301 ti->ti_flags, TRACE_NILFS2_TRANSACTION_ABORT);
304 up_read(&nilfs->ns_segctor_sem);
306 trace_nilfs2_transaction_transition(sb, ti, ti->ti_count,
307 ti->ti_flags, TRACE_NILFS2_TRANSACTION_ABORT);
309 current->journal_info = ti->ti_save;
310 if (ti->ti_flags & NILFS_TI_DYNAMIC_ALLOC)
317 struct the_nilfs *nilfs = sb->s_fs_info;
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);
324 up_read(&nilfs->ns_segctor_sem);
326 down_write(&nilfs->ns_segctor_sem);
327 if (sci->sc_flush_request &&
328 test_bit(NILFS_SC_PRIOR_FLUSH, &sci->sc_flags)) {
329 struct nilfs_transaction_info *ti = current->journal_info;
331 ti->ti_flags |= NILFS_TI_WRITER;
332 nilfs_segctor_do_immediate_flush(sci);
333 ti->ti_flags &= ~NILFS_TI_WRITER;
335 downgrade_write(&nilfs->ns_segctor_sem);
342 struct nilfs_transaction_info *cur_ti = current->journal_info;
343 struct the_nilfs *nilfs = sb->s_fs_info;
344 struct nilfs_sc_info *sci = nilfs->ns_writer;
347 ti->ti_flags = NILFS_TI_WRITER;
348 ti->ti_count = 0;
349 ti->ti_save = cur_ti;
350 ti->ti_magic = NILFS_TI_MAGIC;
351 current->journal_info = ti;
354 trace_nilfs2_transaction_transition(sb, ti, ti->ti_count,
355 ti->ti_flags, TRACE_NILFS2_TRANSACTION_TRYLOCK);
357 down_write(&nilfs->ns_segctor_sem);
358 if (!test_bit(NILFS_SC_PRIOR_FLUSH, &sci->sc_flags))
361 nilfs_segctor_do_immediate_flush(sci);
363 up_write(&nilfs->ns_segctor_sem);
367 ti->ti_flags |= NILFS_TI_GC;
369 trace_nilfs2_transaction_transition(sb, ti, ti->ti_count,
370 ti->ti_flags, TRACE_NILFS2_TRANSACTION_LOCK);
375 struct nilfs_transaction_info *ti = current->journal_info;
376 struct the_nilfs *nilfs = sb->s_fs_info;
378 BUG_ON(ti == NULL || ti->ti_magic != NILFS_TI_MAGIC);
379 BUG_ON(ti->ti_count > 0);
381 up_write(&nilfs->ns_segctor_sem);
382 current->journal_info = ti->ti_save;
384 trace_nilfs2_transaction_transition(sb, ti, ti->ti_count,
385 ti->ti_flags, TRACE_NILFS2_TRANSACTION_UNLOCK);
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;
396 if (unlikely(ssp->offset + bytes > blocksize)) {
397 ssp->offset = 0;
398 BUG_ON(NILFS_SEGBUF_BH_IS_LAST(ssp->bh,
399 &segbuf->sb_segsum_buffers));
400 ssp->bh = NILFS_SEGBUF_NEXT_BH(ssp->bh);
402 p = ssp->bh->b_data + ssp->offset;
403 ssp->offset += bytes;
408 * nilfs_segctor_reset_segment_buffer - reset the current segment buffer
409 * @sci: nilfs_sc_info
413 static int nilfs_segctor_reset_segment_buffer(struct nilfs_sc_info *sci)
415 struct nilfs_segment_buffer *segbuf = sci->sc_curseg;
423 err = nilfs_segbuf_reset(segbuf, flags, sci->sc_seg_ctime, sci->sc_cno);
427 sumbh = NILFS_SEGBUF_FIRST_BH(&segbuf->sb_segsum_buffers);
428 sumbytes = segbuf->sb_sum.sumbytes;
429 sci->sc_finfo_ptr.bh = sumbh; sci->sc_finfo_ptr.offset = sumbytes;
430 sci->sc_binfo_ptr.bh = sumbh; sci->sc_binfo_ptr.offset = sumbytes;
431 sci->sc_blk_cnt = sci->sc_datablk_cnt = 0;
436 * nilfs_segctor_zeropad_segsum - zero pad the rest of the segment summary area
437 * @sci: segment constructor object
439 * nilfs_segctor_zeropad_segsum() zero-fills unallocated space at the end of
442 static void nilfs_segctor_zeropad_segsum(struct nilfs_sc_info *sci)
446 ssp = sci->sc_blk_cnt > 0 ? &sci->sc_binfo_ptr : &sci->sc_finfo_ptr;
447 if (ssp->offset < ssp->bh->b_size)
448 memset(ssp->bh->b_data + ssp->offset, 0,
449 ssp->bh->b_size - ssp->offset);
452 static int nilfs_segctor_feed_segment(struct nilfs_sc_info *sci)
454 sci->sc_nblk_this_inc += sci->sc_curseg->sb_sum.nblocks;
455 if (NILFS_SEGBUF_IS_LAST(sci->sc_curseg, &sci->sc_segbufs))
456 return -E2BIG; /*
460 nilfs_segctor_zeropad_segsum(sci);
461 sci->sc_curseg = NILFS_NEXT_SEGBUF(sci->sc_curseg);
462 return nilfs_segctor_reset_segment_buffer(sci);
465 static int nilfs_segctor_add_super_root(struct nilfs_sc_info *sci)
467 struct nilfs_segment_buffer *segbuf = sci->sc_curseg;
470 if (segbuf->sb_sum.nblocks >= segbuf->sb_rest_blocks) {
471 err = nilfs_segctor_feed_segment(sci);
474 segbuf = sci->sc_curseg;
476 err = nilfs_segbuf_extend_payload(segbuf, &segbuf->sb_super_root);
478 segbuf->sb_sum.flags |= NILFS_SS_SR;
486 struct nilfs_sc_info *sci, const struct nilfs_segsum_pointer *ssp,
489 unsigned int blocksize = sci->sc_super->s_blocksize;
492 return ssp->offset + binfo_size +
493 (!sci->sc_blk_cnt ? sizeof(struct nilfs_finfo) : 0) >
497 static void nilfs_segctor_begin_finfo(struct nilfs_sc_info *sci,
500 sci->sc_curseg->sb_sum.nfinfo++;
501 sci->sc_binfo_ptr = sci->sc_finfo_ptr;
503 sci, &sci->sc_binfo_ptr, sizeof(struct nilfs_finfo));
505 if (NILFS_I(inode)->i_root &&
506 !test_bit(NILFS_SC_HAVE_DELTA, &sci->sc_flags))
507 set_bit(NILFS_SC_HAVE_DELTA, &sci->sc_flags);
511 static void nilfs_segctor_end_finfo(struct nilfs_sc_info *sci,
519 if (sci->sc_blk_cnt == 0)
524 if (ii->i_type & NILFS_I_TYPE_GC)
525 cno = ii->i_cno;
526 else if (NILFS_ROOT_METADATA_FILE(inode->i_ino))
529 cno = sci->sc_cno;
531 finfo = nilfs_segctor_map_segsum_entry(sci, &sci->sc_finfo_ptr,
533 finfo->fi_ino = cpu_to_le64(inode->i_ino);
534 finfo->fi_nblocks = cpu_to_le32(sci->sc_blk_cnt);
535 finfo->fi_ndatablk = cpu_to_le32(sci->sc_datablk_cnt);
536 finfo->fi_cno = cpu_to_le64(cno);
538 segbuf = sci->sc_curseg;
539 segbuf->sb_sum.sumbytes = sci->sc_binfo_ptr.offset +
540 sci->sc_super->s_blocksize * (segbuf->sb_sum.nsumblk - 1);
541 sci->sc_finfo_ptr = sci->sc_binfo_ptr;
542 sci->sc_blk_cnt = sci->sc_datablk_cnt = 0;
545 static int nilfs_segctor_add_file_block(struct nilfs_sc_info *sci,
554 segbuf = sci->sc_curseg;
556 sci, &sci->sc_binfo_ptr, binfo_size);
557 if (segbuf->sb_sum.nblocks + required + 1 > segbuf->sb_rest_blocks) {
558 nilfs_segctor_end_finfo(sci, inode);
559 err = nilfs_segctor_feed_segment(sci);
565 nilfs_segctor_zeropad_segsum(sci);
570 if (sci->sc_blk_cnt == 0)
571 nilfs_segctor_begin_finfo(sci, inode);
573 nilfs_segctor_map_segsum_entry(sci, &sci->sc_binfo_ptr, binfo_size);
576 sci->sc_blk_cnt++;
584 static int nilfs_collect_file_data(struct nilfs_sc_info *sci,
589 err = nilfs_bmap_propagate(NILFS_I(inode)->i_bmap, bh);
593 err = nilfs_segctor_add_file_block(sci, bh, inode,
596 sci->sc_datablk_cnt++;
600 static int nilfs_collect_file_node(struct nilfs_sc_info *sci,
604 return nilfs_bmap_propagate(NILFS_I(inode)->i_bmap, bh);
607 static int nilfs_collect_file_bmap(struct nilfs_sc_info *sci,
612 return nilfs_segctor_add_file_block(sci, bh, inode, sizeof(__le64));
615 static void nilfs_write_file_data_binfo(struct nilfs_sc_info *sci,
620 sci, ssp, sizeof(*binfo_v));
621 *binfo_v = binfo->bi_v;
624 static void nilfs_write_file_node_binfo(struct nilfs_sc_info *sci,
629 sci, ssp, sizeof(*vblocknr));
630 *vblocknr = binfo->bi_v.bi_vblocknr;
641 static int nilfs_collect_dat_data(struct nilfs_sc_info *sci,
646 err = nilfs_bmap_propagate(NILFS_I(inode)->i_bmap, bh);
650 err = nilfs_segctor_add_file_block(sci, bh, inode, sizeof(__le64));
652 sci->sc_datablk_cnt++;
656 static int nilfs_collect_dat_bmap(struct nilfs_sc_info *sci,
660 return nilfs_segctor_add_file_block(sci, bh, inode,
664 static void nilfs_write_dat_data_binfo(struct nilfs_sc_info *sci,
668 __le64 *blkoff = nilfs_segctor_map_segsum_entry(sci, ssp,
670 *blkoff = binfo->bi_dat.bi_blkoff;
673 static void nilfs_write_dat_node_binfo(struct nilfs_sc_info *sci,
678 nilfs_segctor_map_segsum_entry(sci, ssp, sizeof(*binfo_dat));
679 *binfo_dat = binfo->bi_dat;
703 struct address_space *mapping = inode->i_mapping;
711 * A valid range is given for sync-ing data pages. The
712 * range is rounded to per-page; extra dirty buffers
730 if (unlikely(folio->mapping != mapping)) {
745 list_add_tail(&bh->b_assoc_buffers, listp);
753 } while (bh = bh->b_this_page, bh != head);
766 struct inode *btnc_inode = ii->i_assoc_inode;
776 while (filemap_get_folios_tag(btnc_inode->i_mapping, &index,
777 (pgoff_t)-1, PAGECACHE_TAG_DIRTY, &fbatch)) {
784 list_add_tail(&bh->b_assoc_buffers,
787 bh = bh->b_this_page;
803 spin_lock(&nilfs->ns_inode_lock);
805 list_del_init(&ii->i_dirty);
807 if (unlikely(ii->i_bh)) {
808 brelse(ii->i_bh);
809 ii->i_bh = NULL;
811 } else if (test_bit(NILFS_I_DIRTY, &ii->i_state)) {
812 set_bit(NILFS_I_QUEUED, &ii->i_state);
813 list_add_tail(&ii->i_dirty,
814 &nilfs->ns_dirty_files);
821 spin_unlock(&nilfs->ns_inode_lock);
823 for (pii = ivec; nv > 0; pii++, nv--)
824 iput(&(*pii)->vfs_inode);
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);
842 if (nilfs_mdt_fetch_dirty(root->ifile))
844 if (nilfs_mdt_fetch_dirty(nilfs->ns_cpfile))
846 if (nilfs_mdt_fetch_dirty(nilfs->ns_sufile))
848 if ((ret || nilfs_doing_gc()) && nilfs_mdt_fetch_dirty(nilfs->ns_dat))
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);
869 spin_lock(&nilfs->ns_inode_lock);
870 if (list_empty(&nilfs->ns_dirty_files) && nilfs_segctor_clean(sci))
873 spin_unlock(&nilfs->ns_inode_lock);
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);
882 nilfs_mdt_clear_dirty(nilfs->ns_cpfile);
883 nilfs_mdt_clear_dirty(nilfs->ns_sufile);
884 nilfs_mdt_clear_dirty(nilfs->ns_dat);
894 if (test_bit(NILFS_I_BMAP, &ii->i_state)) {
895 ibh = ii->i_bh;
897 raw_inode = nilfs_ifile_map_inode(ifile, ii->vfs_inode.i_ino,
899 nilfs_bmap_write(ii->i_bmap, raw_inode);
904 static void nilfs_segctor_fill_in_file_bmap(struct nilfs_sc_info *sci)
908 list_for_each_entry(ii, &sci->sc_dirty_files, i_dirty) {
909 nilfs_fill_in_file_bmap(sci->sc_root->ifile, ii);
910 set_bit(NILFS_I_COLLECTED, &ii->i_state);
915 * nilfs_write_root_mdt_inode - export root metadata inode information to
916 * the on-disk inode
918 * @raw_inode: on-disk inode
923 * each time, this function zero-fills the unused area of @raw_inode.
928 struct the_nilfs *nilfs = inode->i_sb->s_fs_info;
932 /* zero-fill unused portion of raw_inode */
933 raw_inode->i_xattr = 0;
934 raw_inode->i_pad = 0;
936 nilfs->ns_inode_size - sizeof(*raw_inode));
938 nilfs_bmap_write(NILFS_I(inode)->i_bmap, raw_inode);
941 static void nilfs_segctor_fill_in_super_root(struct nilfs_sc_info *sci,
948 bh_sr = NILFS_LAST_SEGBUF(&sci->sc_segbufs)->sb_super_root;
951 raw_sr = (struct nilfs_super_root *)bh_sr->b_data;
952 isz = nilfs->ns_inode_size;
955 raw_sr->sr_sum = 0; /* Ensure initialization within this update */
956 raw_sr->sr_bytes = cpu_to_le16(srsz);
957 raw_sr->sr_nongc_ctime
959 nilfs->ns_nongc_ctime : sci->sc_seg_ctime);
960 raw_sr->sr_flags = 0;
962 nilfs_write_root_mdt_inode(nilfs->ns_dat, (void *)raw_sr +
964 nilfs_write_root_mdt_inode(nilfs->ns_cpfile, (void *)raw_sr +
966 nilfs_write_root_mdt_inode(nilfs->ns_sufile, (void *)raw_sr +
969 memset((void *)raw_sr + srsz, 0, nilfs->ns_blocksize - srsz);
979 if (test_bit(NILFS_I_COLLECTED, &ii->i_state))
980 clear_bit(NILFS_I_COLLECTED, &ii->i_state);
989 if (!test_and_clear_bit(NILFS_I_COLLECTED, &ii->i_state))
992 clear_bit(NILFS_I_INODE_SYNC, &ii->i_state);
993 set_bit(NILFS_I_UPDATED, &ii->i_state);
997 static int nilfs_segctor_apply_buffers(struct nilfs_sc_info *sci,
1009 list_del_init(&bh->b_assoc_buffers);
1010 err = collect(sci, bh, inode);
1022 list_del_init(&bh->b_assoc_buffers);
1028 static size_t nilfs_segctor_buffer_rest(struct nilfs_sc_info *sci)
1031 return sci->sc_segbuf_nblocks -
1032 (sci->sc_nblk_this_inc + sci->sc_curseg->sb_sum.nblocks);
1035 static int nilfs_segctor_scan_file(struct nilfs_sc_info *sci,
1043 if (!(sci->sc_stage.flags & NILFS_CF_NODE)) {
1044 size_t n, rest = nilfs_segctor_buffer_rest(sci);
1050 sci, inode, &data_buffers,
1051 sc_ops->collect_data);
1052 BUG_ON(!err); /* always receive -E2BIG or true error */
1058 if (!(sci->sc_stage.flags & NILFS_CF_NODE)) {
1060 sci, inode, &data_buffers, sc_ops->collect_data);
1064 sci, inode, &node_buffers, NULL);
1067 sci->sc_stage.flags |= NILFS_CF_NODE;
1071 sci, inode, &node_buffers, sc_ops->collect_node);
1075 nilfs_bmap_lookup_dirty_buffers(NILFS_I(inode)->i_bmap, &node_buffers);
1077 sci, inode, &node_buffers, sc_ops->collect_bmap);
1081 nilfs_segctor_end_finfo(sci, inode);
1082 sci->sc_stage.flags &= ~NILFS_CF_NODE;
1088 static int nilfs_segctor_scan_file_dsync(struct nilfs_sc_info *sci,
1092 size_t n, rest = nilfs_segctor_buffer_rest(sci);
1096 sci->sc_dsync_start,
1097 sci->sc_dsync_end);
1099 err = nilfs_segctor_apply_buffers(sci, inode, &data_buffers,
1102 nilfs_segctor_end_finfo(sci, inode);
1104 /* always receive -E2BIG or true error if n > rest */
1110 * nilfs_free_segments - free the segments given by an array of segment numbers
1127 * * %-EINVAL - Invalid segment number.
1128 * * %-EIO - I/O error (including metadata corruption).
1129 * * %-ENOMEM - Insufficient memory available.
1140 ret = nilfs_sufile_freev(nilfs->ns_sufile, segnumv, nsegs, &ndone);
1142 nilfs_sufile_cancel_freev(nilfs->ns_sufile, segnumv, ndone,
1146 * hole block, nilfs_sufile_freev() will return -ENOENT.
1147 * In this case, -EINVAL should be returned to the caller
1153 if (ret == -ENOENT) {
1154 nilfs_err(nilfs->ns_sb,
1157 ret = -EINVAL;
1163 static int nilfs_segctor_collect_blocks(struct nilfs_sc_info *sci, int mode)
1165 struct the_nilfs *nilfs = sci->sc_super->s_fs_info;
1170 switch (nilfs_sc_cstage_get(sci)) {
1172 /* Pre-processes */
1173 sci->sc_stage.flags = 0;
1175 if (!test_bit(NILFS_SC_UNCLOSED, &sci->sc_flags)) {
1176 sci->sc_nblk_inc = 0;
1177 sci->sc_curseg->sb_sum.flags = NILFS_SS_LOGBGN;
1179 nilfs_sc_cstage_set(sci, NILFS_ST_DSYNC);
1184 sci->sc_stage.dirty_file_ptr = NULL;
1185 sci->sc_stage.gc_inode_ptr = NULL;
1187 nilfs_sc_cstage_set(sci, NILFS_ST_DAT);
1190 nilfs_sc_cstage_inc(sci);
1194 head = &sci->sc_gc_inodes;
1195 ii = list_prepare_entry(sci->sc_stage.gc_inode_ptr,
1199 sci, &ii->vfs_inode,
1202 sci->sc_stage.gc_inode_ptr = list_entry(
1203 ii->i_dirty.prev,
1208 set_bit(NILFS_I_COLLECTED, &ii->i_state);
1210 sci->sc_stage.gc_inode_ptr = NULL;
1212 nilfs_sc_cstage_inc(sci);
1215 head = &sci->sc_dirty_files;
1216 ii = list_prepare_entry(sci->sc_stage.dirty_file_ptr, head,
1219 clear_bit(NILFS_I_DIRTY, &ii->i_state);
1221 err = nilfs_segctor_scan_file(sci, &ii->vfs_inode,
1224 sci->sc_stage.dirty_file_ptr =
1225 list_entry(ii->i_dirty.prev,
1230 /* sci->sc_stage.dirty_file_ptr = NILFS_I(inode); */
1233 sci->sc_stage.dirty_file_ptr = NULL;
1235 nilfs_sc_cstage_set(sci, NILFS_ST_DONE);
1238 nilfs_sc_cstage_inc(sci);
1239 sci->sc_stage.flags |= NILFS_CF_IFILE_STARTED;
1242 err = nilfs_segctor_scan_file(sci, sci->sc_root->ifile,
1246 nilfs_sc_cstage_inc(sci);
1248 err = nilfs_cpfile_create_checkpoint(nilfs->ns_cpfile,
1249 nilfs->ns_cno);
1254 err = nilfs_segctor_scan_file(sci, nilfs->ns_cpfile,
1258 nilfs_sc_cstage_inc(sci);
1261 err = nilfs_free_segments(nilfs, sci->sc_freesegs,
1262 sci->sc_nfreesegs);
1265 sci->sc_stage.flags |= NILFS_CF_SUFREED;
1267 err = nilfs_segctor_scan_file(sci, nilfs->ns_sufile,
1271 nilfs_sc_cstage_inc(sci);
1275 err = nilfs_segctor_scan_file(sci, nilfs->ns_dat,
1280 nilfs_sc_cstage_set(sci, NILFS_ST_DONE);
1283 nilfs_sc_cstage_inc(sci);
1288 err = nilfs_segctor_add_super_root(sci);
1293 sci->sc_curseg->sb_sum.flags |= NILFS_SS_LOGEND;
1294 nilfs_sc_cstage_set(sci, NILFS_ST_DONE);
1298 sci->sc_curseg->sb_sum.flags |= NILFS_SS_SYNDT;
1299 ii = sci->sc_dsync_inode;
1300 if (!test_bit(NILFS_I_BUSY, &ii->i_state))
1303 err = nilfs_segctor_scan_file_dsync(sci, &ii->vfs_inode);
1306 sci->sc_curseg->sb_sum.flags |= NILFS_SS_LOGEND;
1307 nilfs_sc_cstage_set(sci, NILFS_ST_DONE);
1320 * nilfs_segctor_begin_construction - setup segment buffer to make a new log
1321 * @sci: nilfs_sc_info
1326 static int nilfs_segctor_begin_construction(struct nilfs_sc_info *sci,
1333 segbuf = nilfs_segbuf_new(sci->sc_super);
1335 return -ENOMEM;
1337 if (list_empty(&sci->sc_write_logs)) {
1338 nilfs_segbuf_map(segbuf, nilfs->ns_segnum,
1339 nilfs->ns_pseg_offset, nilfs);
1340 if (segbuf->sb_rest_blocks < NILFS_PSEG_MIN_BLOCKS) {
1342 nilfs_segbuf_map(segbuf, nilfs->ns_segnum, 0, nilfs);
1345 segbuf->sb_sum.seg_seq = nilfs->ns_seg_seq;
1346 nextnum = nilfs->ns_nextnum;
1348 if (nilfs->ns_segnum == nilfs->ns_nextnum)
1353 prev = NILFS_LAST_SEGBUF(&sci->sc_write_logs);
1355 segbuf->sb_sum.seg_seq = prev->sb_sum.seg_seq;
1356 nextnum = prev->sb_nextnum;
1358 if (segbuf->sb_rest_blocks < NILFS_PSEG_MIN_BLOCKS) {
1359 nilfs_segbuf_map(segbuf, prev->sb_nextnum, 0, nilfs);
1360 segbuf->sb_sum.seg_seq++;
1365 err = nilfs_sufile_mark_dirty(nilfs->ns_sufile, segbuf->sb_segnum);
1370 err = nilfs_sufile_alloc(nilfs->ns_sufile, &nextnum);
1376 BUG_ON(!list_empty(&sci->sc_segbufs));
1377 list_add_tail(&segbuf->sb_list, &sci->sc_segbufs);
1378 sci->sc_segbuf_nblocks = segbuf->sb_rest_blocks;
1386 static int nilfs_segctor_extend_segments(struct nilfs_sc_info *sci,
1390 struct inode *sufile = nilfs->ns_sufile;
1395 prev = NILFS_LAST_SEGBUF(&sci->sc_segbufs);
1402 err = nilfs_sufile_mark_dirty(sufile, prev->sb_nextnum);
1408 err = -ENOMEM;
1409 segbuf = nilfs_segbuf_new(sci->sc_super);
1413 /* map this buffer to region of segment on-disk */
1414 nilfs_segbuf_map(segbuf, prev->sb_nextnum, 0, nilfs);
1415 sci->sc_segbuf_nblocks += segbuf->sb_rest_blocks;
1422 segbuf->sb_sum.seg_seq = prev->sb_sum.seg_seq + 1;
1425 list_add_tail(&segbuf->sb_list, &list);
1428 list_splice_tail(&list, &sci->sc_segbufs);
1435 ret = nilfs_sufile_free(sufile, segbuf->sb_nextnum);
1446 struct inode *sufile = nilfs->ns_sufile;
1450 if (nilfs->ns_nextnum != segbuf->sb_nextnum) {
1451 ret = nilfs_sufile_free(sufile, segbuf->sb_nextnum);
1454 if (atomic_read(&segbuf->sb_err)) {
1456 if (segbuf->sb_pseg_start != segbuf->sb_fseg_start)
1461 nilfs_terminate_segment(nilfs, segbuf->sb_fseg_start,
1462 segbuf->sb_fseg_end);
1469 if (prev->sb_nextnum != segbuf->sb_nextnum) {
1470 ret = nilfs_sufile_free(sufile, segbuf->sb_nextnum);
1473 if (atomic_read(&segbuf->sb_err) &&
1474 segbuf->sb_segnum != nilfs->ns_nextnum)
1476 nilfs_sufile_set_error(sufile, segbuf->sb_segnum);
1481 static void nilfs_segctor_update_segusage(struct nilfs_sc_info *sci,
1488 list_for_each_entry(segbuf, &sci->sc_segbufs, sb_list) {
1489 live_blocks = segbuf->sb_sum.nblocks +
1490 (segbuf->sb_pseg_start - segbuf->sb_fseg_start);
1491 ret = nilfs_sufile_set_segment_usage(sufile, segbuf->sb_segnum,
1493 sci->sc_seg_ctime);
1504 ret = nilfs_sufile_set_segment_usage(sufile, segbuf->sb_segnum,
1505 segbuf->sb_pseg_start -
1506 segbuf->sb_fseg_start, 0);
1510 ret = nilfs_sufile_set_segment_usage(sufile, segbuf->sb_segnum,
1516 static void nilfs_segctor_truncate_segments(struct nilfs_sc_info *sci,
1523 list_for_each_entry_continue(segbuf, &sci->sc_segbufs, sb_list) {
1524 sci->sc_segbuf_nblocks -= segbuf->sb_rest_blocks;
1525 ret = nilfs_sufile_free(sufile, segbuf->sb_nextnum);
1528 nilfs_truncate_logs(&sci->sc_segbufs, last);
1532 static int nilfs_segctor_collect(struct nilfs_sc_info *sci,
1535 struct nilfs_cstage prev_stage = sci->sc_stage;
1540 sci->sc_nblk_this_inc = 0;
1541 sci->sc_curseg = NILFS_FIRST_SEGBUF(&sci->sc_segbufs);
1543 err = nilfs_segctor_reset_segment_buffer(sci);
1547 err = nilfs_segctor_collect_blocks(sci, mode);
1548 sci->sc_nblk_this_inc += sci->sc_curseg->sb_sum.nblocks;
1552 if (unlikely(err != -E2BIG))
1557 nilfs_sc_cstage_get(sci) < NILFS_ST_CPFILE)
1560 nilfs_clear_logs(&sci->sc_segbufs);
1562 if (sci->sc_stage.flags & NILFS_CF_SUFREED) {
1563 err = nilfs_sufile_cancel_freev(nilfs->ns_sufile,
1564 sci->sc_freesegs,
1565 sci->sc_nfreesegs,
1568 sci->sc_stage.flags &= ~NILFS_CF_SUFREED;
1571 err = nilfs_segctor_extend_segments(sci, nilfs, nadd);
1576 sci->sc_stage = prev_stage;
1578 nilfs_segctor_zeropad_segsum(sci);
1579 nilfs_segctor_truncate_segments(sci, sci->sc_curseg, nilfs->ns_sufile);
1589 BUG_ON(!list_empty(&new_bh->b_assoc_buffers));
1591 list_replace_init(&old_bh->b_assoc_buffers, &new_bh->b_assoc_buffers);
1596 nilfs_segctor_update_payload_blocknr(struct nilfs_sc_info *sci,
1602 unsigned long nfinfo = segbuf->sb_sum.nfinfo;
1615 blocknr = segbuf->sb_pseg_start + segbuf->sb_sum.nsumblk;
1616 ssp.bh = NILFS_SEGBUF_FIRST_BH(&segbuf->sb_segsum_buffers);
1619 list_for_each_entry(bh, &segbuf->sb_payload_buffers, b_assoc_buffers) {
1620 if (bh == segbuf->sb_super_root)
1624 sci, &ssp, sizeof(*finfo));
1625 ino = le64_to_cpu(finfo->fi_ino);
1626 nblocks = le32_to_cpu(finfo->fi_nblocks);
1627 ndatablk = le32_to_cpu(finfo->fi_ndatablk);
1629 inode = bh->b_folio->mapping->host;
1640 err = nilfs_bmap_assign(NILFS_I(inode)->i_bmap, &bh, blocknr,
1649 sc_op->write_data_binfo(sci, &ssp, &binfo);
1651 sc_op->write_node_binfo(sci, &ssp, &binfo);
1654 if (--nblocks == 0) {
1656 if (--nfinfo == 0)
1659 ndatablk--;
1668 static int nilfs_segctor_assign(struct nilfs_sc_info *sci, int mode)
1673 list_for_each_entry(segbuf, &sci->sc_segbufs, sb_list) {
1674 err = nilfs_segctor_update_payload_blocknr(sci, segbuf, mode);
1686 * For split b-tree node pages, this function may be called
1698 * nilfs_prepare_write_logs - prepare to write logs
1704 * memory-mapped file blocks by putting them in writeback state before
1717 list_for_each_entry(bh, &segbuf->sb_payload_buffers,
1719 if (bh == segbuf->sb_super_root)
1722 if (bh->b_folio != fs_folio) {
1724 fs_folio = bh->b_folio;
1734 list_for_each_entry(bh, &segbuf->sb_segsum_buffers,
1737 if (bh->b_folio == bd_folio)
1746 bd_folio = bh->b_folio;
1751 bh = NILFS_LAST_SEGBUF(logs)->sb_super_root;
1754 if (bh->b_folio != bd_folio) {
1760 bd_folio = bh->b_folio;
1773 static int nilfs_segctor_write(struct nilfs_sc_info *sci,
1778 ret = nilfs_write_logs(&sci->sc_segbufs, nilfs);
1779 list_splice_tail_init(&sci->sc_segbufs, &sci->sc_write_logs);
1791 * For b-tree node pages, this function may be called twice
1796 * For pages holding split b-tree node buffers, dirty
1811 filemap_dirty_folio(folio->mapping, folio);
1826 list_for_each_entry(bh, &segbuf->sb_segsum_buffers,
1829 if (bh->b_folio != bd_folio) {
1832 bd_folio = bh->b_folio;
1836 list_for_each_entry(bh, &segbuf->sb_payload_buffers,
1838 if (bh == segbuf->sb_super_root) {
1840 if (bh->b_folio != bd_folio) {
1842 bd_folio = bh->b_folio;
1847 if (bh->b_folio != fs_folio) {
1849 fs_folio = bh->b_folio;
1859 static void nilfs_segctor_abort_construction(struct nilfs_sc_info *sci,
1865 list_splice_tail_init(&sci->sc_write_logs, &logs);
1869 list_splice_tail_init(&sci->sc_segbufs, &logs);
1873 nilfs_cancel_segusage(&logs, nilfs->ns_sufile);
1876 if (sci->sc_stage.flags & NILFS_CF_SUFREED) {
1877 ret = nilfs_sufile_cancel_freev(nilfs->ns_sufile,
1878 sci->sc_freesegs,
1879 sci->sc_nfreesegs,
1890 nilfs->ns_segnum = segbuf->sb_segnum;
1891 nilfs->ns_nextnum = segbuf->sb_nextnum;
1892 nilfs->ns_pseg_offset = segbuf->sb_pseg_start - segbuf->sb_fseg_start
1893 + segbuf->sb_sum.nblocks;
1894 nilfs->ns_seg_seq = segbuf->sb_sum.seg_seq;
1895 nilfs->ns_ctime = segbuf->sb_sum.ctime;
1898 static void nilfs_segctor_complete_write(struct nilfs_sc_info *sci)
1902 struct the_nilfs *nilfs = sci->sc_super->s_fs_info;
1905 list_for_each_entry(segbuf, &sci->sc_write_logs, sb_list) {
1908 list_for_each_entry(bh, &segbuf->sb_segsum_buffers,
1912 if (bh->b_folio != bd_folio) {
1915 bd_folio = bh->b_folio;
1922 * identifiable by the discontinuity of bh->b_folio
1925 * For B-tree node blocks, however, this assumption is not
1926 * guaranteed. The cleanup code of B-tree node folios needs
1929 list_for_each_entry(bh, &segbuf->sb_payload_buffers,
1937 if (bh == segbuf->sb_super_root) {
1940 if (bh->b_folio != bd_folio) {
1942 bd_folio = bh->b_folio;
1947 set_mask_bits(&bh->b_state, clear_bits, set_bits);
1948 if (bh->b_folio != fs_folio) {
1950 fs_folio = bh->b_folio;
1955 if (segbuf->sb_sum.flags & NILFS_SS_LOGBGN) {
1956 set_bit(NILFS_SC_UNCLOSED, &sci->sc_flags);
1957 sci->sc_lseg_stime = jiffies;
1959 if (segbuf->sb_sum.flags & NILFS_SS_LOGEND)
1960 clear_bit(NILFS_SC_UNCLOSED, &sci->sc_flags);
1972 nilfs_drop_collected_inodes(&sci->sc_dirty_files);
1975 nilfs_drop_collected_inodes(&sci->sc_gc_inodes);
1977 nilfs->ns_nongc_ctime = sci->sc_seg_ctime;
1979 sci->sc_nblk_inc += sci->sc_nblk_this_inc;
1981 segbuf = NILFS_LAST_SEGBUF(&sci->sc_write_logs);
1985 nilfs->ns_flushed_device = 0;
1986 nilfs_set_last_segment(nilfs, segbuf->sb_pseg_start,
1987 segbuf->sb_sum.seg_seq, nilfs->ns_cno++);
1989 clear_bit(NILFS_SC_HAVE_DELTA, &sci->sc_flags);
1990 clear_bit(NILFS_SC_DIRTY, &sci->sc_flags);
1991 set_bit(NILFS_SC_SUPER_ROOT, &sci->sc_flags);
1992 nilfs_segctor_clear_metadata_dirty(sci);
1994 clear_bit(NILFS_SC_SUPER_ROOT, &sci->sc_flags);
1997 static int nilfs_segctor_wait(struct nilfs_sc_info *sci)
2001 ret = nilfs_wait_on_logs(&sci->sc_write_logs);
2003 nilfs_segctor_complete_write(sci);
2004 nilfs_destroy_logs(&sci->sc_write_logs);
2009 static int nilfs_segctor_collect_dirty_files(struct nilfs_sc_info *sci,
2013 struct inode *ifile = sci->sc_root->ifile;
2015 spin_lock(&nilfs->ns_inode_lock);
2017 list_for_each_entry_safe(ii, n, &nilfs->ns_dirty_files, i_dirty) {
2018 if (!ii->i_bh) {
2022 spin_unlock(&nilfs->ns_inode_lock);
2024 ifile, ii->vfs_inode.i_ino, &ibh);
2026 nilfs_warn(sci->sc_super,
2028 err, ii->vfs_inode.i_ino);
2031 spin_lock(&nilfs->ns_inode_lock);
2032 if (likely(!ii->i_bh))
2033 ii->i_bh = ibh;
2040 mark_buffer_dirty(ii->i_bh);
2043 clear_bit(NILFS_I_QUEUED, &ii->i_state);
2044 set_bit(NILFS_I_BUSY, &ii->i_state);
2045 list_move_tail(&ii->i_dirty, &sci->sc_dirty_files);
2047 spin_unlock(&nilfs->ns_inode_lock);
2052 static void nilfs_segctor_drop_written_files(struct nilfs_sc_info *sci,
2056 int during_mount = !(sci->sc_super->s_flags & SB_ACTIVE);
2059 spin_lock(&nilfs->ns_inode_lock);
2060 list_for_each_entry_safe(ii, n, &sci->sc_dirty_files, i_dirty) {
2061 if (!test_and_clear_bit(NILFS_I_UPDATED, &ii->i_state) ||
2062 test_bit(NILFS_I_DIRTY, &ii->i_state))
2065 clear_bit(NILFS_I_BUSY, &ii->i_state);
2066 brelse(ii->i_bh);
2067 ii->i_bh = NULL;
2068 list_del_init(&ii->i_dirty);
2069 if (!ii->vfs_inode.i_nlink || during_mount) {
2074 list_add_tail(&ii->i_dirty, &sci->sc_iput_queue);
2077 spin_unlock(&nilfs->ns_inode_lock);
2078 iput(&ii->vfs_inode);
2079 spin_lock(&nilfs->ns_inode_lock);
2082 spin_unlock(&nilfs->ns_inode_lock);
2085 schedule_work(&sci->sc_iput_work);
2091 static int nilfs_segctor_do_construct(struct nilfs_sc_info *sci, int mode)
2093 struct the_nilfs *nilfs = sci->sc_super->s_fs_info;
2096 if (sb_rdonly(sci->sc_super))
2097 return -EROFS;
2099 nilfs_sc_cstage_set(sci, NILFS_ST_INIT);
2100 sci->sc_cno = nilfs->ns_cno;
2102 err = nilfs_segctor_collect_dirty_files(sci, nilfs);
2106 if (nilfs_test_metadata_dirty(nilfs, sci->sc_root))
2107 set_bit(NILFS_SC_DIRTY, &sci->sc_flags);
2109 if (nilfs_segctor_clean(sci))
2113 sci->sc_stage.flags &= ~NILFS_CF_HISTORY_MASK;
2115 err = nilfs_segctor_begin_construction(sci, nilfs);
2120 sci->sc_seg_ctime = ktime_get_real_seconds();
2122 err = nilfs_segctor_collect(sci, nilfs, mode);
2127 if (nilfs_sc_cstage_get(sci) == NILFS_ST_DONE &&
2128 nilfs_segbuf_empty(sci->sc_curseg)) {
2129 nilfs_segctor_abort_construction(sci, nilfs, 1);
2133 err = nilfs_segctor_assign(sci, mode);
2137 if (sci->sc_stage.flags & NILFS_CF_IFILE_STARTED)
2138 nilfs_segctor_fill_in_file_bmap(sci);
2141 nilfs_sc_cstage_get(sci) >= NILFS_ST_CPFILE) {
2143 nilfs->ns_cpfile, nilfs->ns_cno, sci->sc_root,
2144 sci->sc_nblk_inc + sci->sc_nblk_this_inc,
2145 sci->sc_seg_ctime,
2146 !test_bit(NILFS_SC_HAVE_DELTA, &sci->sc_flags));
2150 nilfs_segctor_fill_in_super_root(sci, nilfs);
2152 nilfs_segctor_update_segusage(sci, nilfs->ns_sufile);
2155 nilfs_prepare_write_logs(&sci->sc_segbufs, nilfs->ns_crc_seed);
2157 err = nilfs_segctor_write(sci, nilfs);
2161 if (nilfs_sc_cstage_get(sci) == NILFS_ST_DONE ||
2162 nilfs->ns_blocksize_bits != PAGE_SHIFT) {
2170 err = nilfs_segctor_wait(sci);
2174 } while (nilfs_sc_cstage_get(sci) != NILFS_ST_DONE);
2177 nilfs_segctor_drop_written_files(sci, nilfs);
2182 if (mode == SC_LSEG_SR && nilfs_sc_cstage_get(sci) >= NILFS_ST_IFILE)
2183 nilfs_redirty_inodes(&sci->sc_dirty_files);
2185 nilfs_redirty_inodes(&sci->sc_gc_inodes);
2186 nilfs_segctor_abort_construction(sci, nilfs, err);
2191 * nilfs_segctor_start_timer - set timer of background write
2192 * @sci: nilfs_sc_info
2198 static void nilfs_segctor_start_timer(struct nilfs_sc_info *sci)
2200 spin_lock(&sci->sc_state_lock);
2201 if (!(sci->sc_state & NILFS_SEGCTOR_COMMIT)) {
2202 if (sci->sc_task) {
2203 sci->sc_timer.expires = jiffies + sci->sc_interval;
2204 add_timer(&sci->sc_timer);
2206 sci->sc_state |= NILFS_SEGCTOR_COMMIT;
2208 spin_unlock(&sci->sc_state_lock);
2211 static void nilfs_segctor_do_flush(struct nilfs_sc_info *sci, int bn)
2213 spin_lock(&sci->sc_state_lock);
2214 if (!(sci->sc_flush_request & BIT(bn))) {
2215 unsigned long prev_req = sci->sc_flush_request;
2217 sci->sc_flush_request |= BIT(bn);
2219 wake_up(&sci->sc_wait_daemon);
2221 spin_unlock(&sci->sc_state_lock);
2225 * nilfs_flush_segment - trigger a segment construction for resource control
2231 struct the_nilfs *nilfs = sb->s_fs_info;
2232 struct nilfs_sc_info *sci = nilfs->ns_writer;
2234 if (!sci || nilfs_doing_construction())
2236 nilfs_segctor_do_flush(sci, NILFS_MDT_INODE(sb, ino) ? ino : 0);
2247 static int nilfs_segctor_sync(struct nilfs_sc_info *sci)
2264 spin_lock(&sci->sc_state_lock);
2265 wait_req.seq = ++sci->sc_seq_request;
2266 add_wait_queue(&sci->sc_wait_request, &wait_req.wq);
2267 spin_unlock(&sci->sc_state_lock);
2269 wake_up(&sci->sc_wait_daemon);
2279 if (!sci->sc_task)
2290 err = -ERESTARTSYS;
2293 finish_wait(&sci->sc_wait_request, &wait_req.wq);
2297 static void nilfs_segctor_wakeup(struct nilfs_sc_info *sci, int err, bool force)
2302 spin_lock_irqsave(&sci->sc_wait_request.lock, flags);
2303 list_for_each_entry_safe(wrq, n, &sci->sc_wait_request.head, wq.entry) {
2304 if (!atomic_read(&wrq->done) &&
2305 (force || nilfs_cnt32_ge(sci->sc_seq_done, wrq->seq))) {
2306 wrq->err = err;
2307 atomic_set(&wrq->done, 1);
2309 if (atomic_read(&wrq->done)) {
2310 wrq->wq.func(&wrq->wq,
2315 spin_unlock_irqrestore(&sci->sc_wait_request.lock, flags);
2319 * nilfs_construct_segment - construct a logical segment
2324 * * %-EIO - I/O error (including metadata corruption).
2325 * * %-ENOMEM - Insufficient memory available.
2326 * * %-ENOSPC - No space left on device (only in a panic state).
2327 * * %-ERESTARTSYS - Interrupted.
2328 * * %-EROFS - Read only filesystem.
2332 struct the_nilfs *nilfs = sb->s_fs_info;
2333 struct nilfs_sc_info *sci = nilfs->ns_writer;
2336 if (sb_rdonly(sb) || unlikely(!sci))
2337 return -EROFS;
2340 BUG_ON((ti = current->journal_info) && ti->ti_magic == NILFS_TI_MAGIC);
2342 return nilfs_segctor_sync(sci);
2346 * nilfs_construct_dsync_segment - construct a data-only logical segment
2354 * * %-EIO - I/O error (including metadata corruption).
2355 * * %-ENOMEM - Insufficient memory available.
2356 * * %-ENOSPC - No space left on device (only in a panic state).
2357 * * %-ERESTARTSYS - Interrupted.
2358 * * %-EROFS - Read only filesystem.
2363 struct the_nilfs *nilfs = sb->s_fs_info;
2364 struct nilfs_sc_info *sci = nilfs->ns_writer;
2369 if (sb_rdonly(sb) || unlikely(!sci))
2370 return -EROFS;
2375 if (test_bit(NILFS_I_INODE_SYNC, &ii->i_state) ||
2377 test_bit(NILFS_SC_UNCLOSED, &sci->sc_flags) ||
2380 err = nilfs_segctor_sync(sci);
2384 spin_lock(&nilfs->ns_inode_lock);
2385 if (!test_bit(NILFS_I_QUEUED, &ii->i_state) &&
2386 !test_bit(NILFS_I_BUSY, &ii->i_state)) {
2387 spin_unlock(&nilfs->ns_inode_lock);
2391 spin_unlock(&nilfs->ns_inode_lock);
2392 sci->sc_dsync_inode = ii;
2393 sci->sc_dsync_start = start;
2394 sci->sc_dsync_end = end;
2396 err = nilfs_segctor_do_construct(sci, SC_LSEG_DSYNC);
2398 nilfs->ns_flushed_device = 0;
2408 * nilfs_segctor_accept - record accepted sequence count of log-write requests
2409 * @sci: segment constructor object
2411 static void nilfs_segctor_accept(struct nilfs_sc_info *sci)
2415 spin_lock(&sci->sc_state_lock);
2416 sci->sc_seq_accepted = sci->sc_seq_request;
2417 thread_is_alive = (bool)sci->sc_task;
2418 spin_unlock(&sci->sc_state_lock);
2427 del_timer_sync(&sci->sc_timer);
2431 * nilfs_segctor_notify - notify the result of request to caller threads
2432 * @sci: segment constructor object
2436 static void nilfs_segctor_notify(struct nilfs_sc_info *sci, int mode, int err)
2439 spin_lock(&sci->sc_state_lock);
2442 sci->sc_state &= ~NILFS_SEGCTOR_COMMIT;
2443 sci->sc_seq_done = sci->sc_seq_accepted;
2444 nilfs_segctor_wakeup(sci, err, false);
2445 sci->sc_flush_request = 0;
2448 sci->sc_flush_request &= ~FLUSH_FILE_BIT;
2450 sci->sc_flush_request &= ~FLUSH_DAT_BIT;
2452 /* re-enable timer if checkpoint creation was not done */
2453 if ((sci->sc_state & NILFS_SEGCTOR_COMMIT) && sci->sc_task &&
2454 time_before(jiffies, sci->sc_timer.expires))
2455 add_timer(&sci->sc_timer);
2457 spin_unlock(&sci->sc_state_lock);
2461 * nilfs_segctor_construct - form logs and write them to disk
2462 * @sci: segment constructor object
2467 static int nilfs_segctor_construct(struct nilfs_sc_info *sci, int mode)
2469 struct the_nilfs *nilfs = sci->sc_super->s_fs_info;
2473 nilfs_segctor_accept(sci);
2477 if (!nilfs_segctor_confirm(sci))
2478 err = nilfs_segctor_do_construct(sci, mode);
2482 atomic_set(&nilfs->ns_ndirtyblks, 0);
2483 if (test_bit(NILFS_SC_SUPER_ROOT, &sci->sc_flags) &&
2485 down_write(&nilfs->ns_sem);
2486 err = -EIO;
2487 sbp = nilfs_prepare_super(sci->sc_super,
2491 err = nilfs_commit_super(sci->sc_super,
2494 up_write(&nilfs->ns_sem);
2498 nilfs_segctor_notify(sci, mode, err);
2504 struct nilfs_sc_info *sci = from_timer(sci, t, sc_timer);
2506 wake_up_process(sci->sc_task);
2515 if (!test_bit(NILFS_I_UPDATED, &ii->i_state))
2517 list_del_init(&ii->i_dirty);
2518 truncate_inode_pages(&ii->vfs_inode.i_data, 0);
2519 nilfs_btnode_cache_clear(ii->i_assoc_inode->i_mapping);
2520 iput(&ii->vfs_inode);
2527 struct the_nilfs *nilfs = sb->s_fs_info;
2528 struct nilfs_sc_info *sci = nilfs->ns_writer;
2532 if (unlikely(!sci))
2533 return -EROFS;
2537 err = nilfs_mdt_save_to_shadow_map(nilfs->ns_dat);
2543 nilfs_mdt_restore_from_shadow_map(nilfs->ns_dat);
2547 sci->sc_freesegs = kbufs[4];
2548 sci->sc_nfreesegs = argv[4].v_nmembs;
2549 list_splice_tail_init(&nilfs->ns_gc_inodes, &sci->sc_gc_inodes);
2552 err = nilfs_segctor_construct(sci, SC_LSEG_SR);
2553 nilfs_remove_written_gcinodes(nilfs, &sci->sc_gc_inodes);
2560 schedule_timeout(sci->sc_interval);
2563 int ret = nilfs_discard_segments(nilfs, sci->sc_freesegs,
2564 sci->sc_nfreesegs);
2574 sci->sc_freesegs = NULL;
2575 sci->sc_nfreesegs = 0;
2576 nilfs_mdt_clear_shadow_map(nilfs->ns_dat);
2581 static void nilfs_segctor_thread_construct(struct nilfs_sc_info *sci, int mode)
2585 nilfs_transaction_lock(sci->sc_super, &ti, 0);
2586 nilfs_segctor_construct(sci, mode);
2593 if (test_bit(NILFS_SC_UNCLOSED, &sci->sc_flags))
2594 nilfs_segctor_start_timer(sci);
2596 nilfs_transaction_unlock(sci->sc_super);
2599 static void nilfs_segctor_do_immediate_flush(struct nilfs_sc_info *sci)
2603 spin_lock(&sci->sc_state_lock);
2604 mode = (sci->sc_flush_request & FLUSH_DAT_BIT) ?
2606 spin_unlock(&sci->sc_state_lock);
2609 nilfs_segctor_do_construct(sci, mode);
2611 spin_lock(&sci->sc_state_lock);
2612 sci->sc_flush_request &= (mode == SC_FLUSH_FILE) ?
2614 spin_unlock(&sci->sc_state_lock);
2616 clear_bit(NILFS_SC_PRIOR_FLUSH, &sci->sc_flags);
2619 static int nilfs_segctor_flush_mode(struct nilfs_sc_info *sci)
2621 if (!test_bit(NILFS_SC_UNCLOSED, &sci->sc_flags) ||
2622 time_before(jiffies, sci->sc_lseg_stime + sci->sc_mjcp_freq)) {
2623 if (!(sci->sc_flush_request & ~FLUSH_FILE_BIT))
2625 else if (!(sci->sc_flush_request & ~FLUSH_DAT_BIT))
2632 * nilfs_log_write_required - determine whether log writing is required
2633 * @sci: nilfs_sc_info struct
2639 static bool nilfs_log_write_required(struct nilfs_sc_info *sci, int *modep)
2643 spin_lock(&sci->sc_state_lock);
2644 timedout = ((sci->sc_state & NILFS_SEGCTOR_COMMIT) &&
2645 time_after_eq(jiffies, sci->sc_timer.expires));
2646 if (timedout || sci->sc_seq_request != sci->sc_seq_done)
2648 else if (sci->sc_flush_request)
2649 *modep = nilfs_segctor_flush_mode(sci);
2653 spin_unlock(&sci->sc_state_lock);
2658 * nilfs_segctor_thread - main loop of the log writer thread
2670 struct nilfs_sc_info *sci = (struct nilfs_sc_info *)arg;
2671 struct the_nilfs *nilfs = sci->sc_super->s_fs_info;
2673 nilfs_info(sci->sc_super,
2675 sci->sc_interval / HZ, sci->sc_mjcp_freq / HZ);
2689 prepare_to_wait(&sci->sc_wait_daemon, &wait,
2691 should_write = nilfs_log_write_required(sci, &mode);
2694 finish_wait(&sci->sc_wait_daemon, &wait);
2700 nilfs_segctor_thread_construct(sci, mode);
2704 spin_lock(&sci->sc_state_lock);
2705 sci->sc_task = NULL;
2706 timer_shutdown_sync(&sci->sc_timer);
2707 spin_unlock(&sci->sc_state_lock);
2712 * Setup & clean-up functions
2717 struct the_nilfs *nilfs = sb->s_fs_info;
2718 struct nilfs_sc_info *sci;
2720 sci = kzalloc(sizeof(*sci), GFP_KERNEL);
2721 if (!sci)
2724 sci->sc_super = sb;
2727 sci->sc_root = root;
2729 init_waitqueue_head(&sci->sc_wait_request);
2730 init_waitqueue_head(&sci->sc_wait_daemon);
2731 spin_lock_init(&sci->sc_state_lock);
2732 INIT_LIST_HEAD(&sci->sc_dirty_files);
2733 INIT_LIST_HEAD(&sci->sc_segbufs);
2734 INIT_LIST_HEAD(&sci->sc_write_logs);
2735 INIT_LIST_HEAD(&sci->sc_gc_inodes);
2736 INIT_LIST_HEAD(&sci->sc_iput_queue);
2737 INIT_WORK(&sci->sc_iput_work, nilfs_iput_work_func);
2739 sci->sc_interval = HZ * NILFS_SC_DEFAULT_TIMEOUT;
2740 sci->sc_mjcp_freq = HZ * NILFS_SC_DEFAULT_SR_FREQ;
2741 sci->sc_watermark = NILFS_SC_DEFAULT_WATERMARK;
2743 if (nilfs->ns_interval)
2744 sci->sc_interval = HZ * nilfs->ns_interval;
2745 if (nilfs->ns_watermark)
2746 sci->sc_watermark = nilfs->ns_watermark;
2747 return sci;
2750 static void nilfs_segctor_write_out(struct nilfs_sc_info *sci)
2761 nilfs_transaction_lock(sci->sc_super, &ti, 0);
2762 ret = nilfs_segctor_construct(sci, SC_LSEG_SR);
2763 nilfs_transaction_unlock(sci->sc_super);
2765 flush_work(&sci->sc_iput_work);
2767 } while (ret && ret != -EROFS && retrycount-- > 0);
2771 * nilfs_segctor_destroy - destroy the segment constructor.
2772 * @sci: nilfs_sc_info
2778 static void nilfs_segctor_destroy(struct nilfs_sc_info *sci)
2780 struct the_nilfs *nilfs = sci->sc_super->s_fs_info;
2783 up_write(&nilfs->ns_segctor_sem);
2785 if (sci->sc_task) {
2786 wake_up(&sci->sc_wait_daemon);
2787 kthread_stop(sci->sc_task);
2790 spin_lock(&sci->sc_state_lock);
2791 flag = ((sci->sc_state & NILFS_SEGCTOR_COMMIT) || sci->sc_flush_request
2792 || sci->sc_seq_request != sci->sc_seq_done);
2793 spin_unlock(&sci->sc_state_lock);
2800 nilfs_segctor_wakeup(sci, 0, true);
2802 if (flush_work(&sci->sc_iput_work))
2805 if (flag || !nilfs_segctor_confirm(sci))
2806 nilfs_segctor_write_out(sci);
2808 if (!list_empty(&sci->sc_dirty_files)) {
2809 nilfs_warn(sci->sc_super,
2811 nilfs_dispose_list(nilfs, &sci->sc_dirty_files, 1);
2814 if (!list_empty(&sci->sc_iput_queue)) {
2815 nilfs_warn(sci->sc_super,
2817 nilfs_dispose_list(nilfs, &sci->sc_iput_queue, 1);
2820 WARN_ON(!list_empty(&sci->sc_segbufs));
2821 WARN_ON(!list_empty(&sci->sc_write_logs));
2823 nilfs_put_root(sci->sc_root);
2825 down_write(&nilfs->ns_segctor_sem);
2827 kfree(sci);
2831 * nilfs_attach_log_writer - attach log writer
2840 * * %-EINTR - Log writer thread creation failed due to interruption.
2841 * * %-ENOMEM - Insufficient memory available.
2845 struct the_nilfs *nilfs = sb->s_fs_info;
2846 struct nilfs_sc_info *sci;
2850 if (nilfs->ns_writer) {
2852 * This happens if the filesystem is made read-only by
2860 sci = nilfs_segctor_new(sb, root);
2861 if (unlikely(!sci))
2862 return -ENOMEM;
2864 nilfs->ns_writer = sci;
2865 t = kthread_create(nilfs_segctor_thread, sci, "segctord");
2872 sci->sc_task = t;
2873 timer_setup(&sci->sc_timer, nilfs_construction_timeout, 0);
2875 wake_up_process(sci->sc_task);
2880 * nilfs_detach_log_writer - destroy log writer
2888 struct the_nilfs *nilfs = sb->s_fs_info;
2891 down_write(&nilfs->ns_segctor_sem);
2892 if (nilfs->ns_writer) {
2893 nilfs_segctor_destroy(nilfs->ns_writer);
2894 nilfs->ns_writer = NULL;
2899 spin_lock(&nilfs->ns_inode_lock);
2900 if (!list_empty(&nilfs->ns_dirty_files)) {
2901 list_splice_init(&nilfs->ns_dirty_files, &garbage_list);
2905 spin_unlock(&nilfs->ns_inode_lock);
2906 up_write(&nilfs->ns_segctor_sem);