Lines Matching +full:ti +full:- +full:sci
1 // SPDX-License-Identifier: GPL-2.0+
3 * segment.c - NILFS segment constructor.
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) in nilfs_sc_cstage_inc() argument
92 sci->sc_stage.scnt++; in nilfs_sc_cstage_inc()
93 trace_nilfs2_collection_stage_transition(sci); in nilfs_sc_cstage_inc()
96 static inline void nilfs_sc_cstage_set(struct nilfs_sc_info *sci, int next_scnt) in nilfs_sc_cstage_set() argument
98 sci->sc_stage.scnt = next_scnt; in nilfs_sc_cstage_set()
99 trace_nilfs2_collection_stage_transition(sci); in nilfs_sc_cstage_set()
102 static inline int nilfs_sc_cstage_get(struct nilfs_sc_info *sci) in nilfs_sc_cstage_get() argument
104 return sci->sc_stage.scnt; in nilfs_sc_cstage_get()
139 ((__s32)(b) - (__s32)(a) < 0))
142 ((__s32)(a) - (__s32)(b) >= 0))
147 struct nilfs_transaction_info *ti) in nilfs_prepare_segment_lock() argument
149 struct nilfs_transaction_info *cur_ti = current->journal_info; in nilfs_prepare_segment_lock()
153 if (cur_ti->ti_magic == NILFS_TI_MAGIC) in nilfs_prepare_segment_lock()
154 return ++cur_ti->ti_count; in nilfs_prepare_segment_lock()
162 save = current->journal_info; in nilfs_prepare_segment_lock()
164 if (!ti) { in nilfs_prepare_segment_lock()
165 ti = kmem_cache_alloc(nilfs_transaction_cachep, GFP_NOFS); in nilfs_prepare_segment_lock()
166 if (!ti) in nilfs_prepare_segment_lock()
167 return -ENOMEM; in nilfs_prepare_segment_lock()
168 ti->ti_flags = NILFS_TI_DYNAMIC_ALLOC; in nilfs_prepare_segment_lock()
170 ti->ti_flags = 0; in nilfs_prepare_segment_lock()
172 ti->ti_count = 0; in nilfs_prepare_segment_lock()
173 ti->ti_save = save; in nilfs_prepare_segment_lock()
174 ti->ti_magic = NILFS_TI_MAGIC; in nilfs_prepare_segment_lock()
175 current->journal_info = ti; in nilfs_prepare_segment_lock()
180 * nilfs_transaction_begin - start indivisible file operations.
182 * @ti: nilfs_transaction_info
193 * the outermost call. If a pre-allocated struct is given to @ti, it is used
202 * %-ENOMEM - Insufficient memory available.
204 * %-ENOSPC - No space left on device
207 struct nilfs_transaction_info *ti, in nilfs_transaction_begin() argument
211 int ret = nilfs_prepare_segment_lock(sb, ti); in nilfs_transaction_begin()
217 trace_ti = current->journal_info; in nilfs_transaction_begin()
220 trace_ti->ti_count, trace_ti->ti_flags, in nilfs_transaction_begin()
227 nilfs = sb->s_fs_info; in nilfs_transaction_begin()
228 down_read(&nilfs->ns_segctor_sem); in nilfs_transaction_begin()
230 up_read(&nilfs->ns_segctor_sem); in nilfs_transaction_begin()
231 ret = -ENOSPC; in nilfs_transaction_begin()
235 trace_ti = current->journal_info; in nilfs_transaction_begin()
236 trace_nilfs2_transaction_transition(sb, trace_ti, trace_ti->ti_count, in nilfs_transaction_begin()
237 trace_ti->ti_flags, in nilfs_transaction_begin()
242 ti = current->journal_info; in nilfs_transaction_begin()
243 current->journal_info = ti->ti_save; in nilfs_transaction_begin()
244 if (ti->ti_flags & NILFS_TI_DYNAMIC_ALLOC) in nilfs_transaction_begin()
245 kmem_cache_free(nilfs_transaction_cachep, ti); in nilfs_transaction_begin()
251 * nilfs_transaction_commit - commit indivisible file operations.
263 struct nilfs_transaction_info *ti = current->journal_info; in nilfs_transaction_commit() local
264 struct the_nilfs *nilfs = sb->s_fs_info; in nilfs_transaction_commit()
267 BUG_ON(ti == NULL || ti->ti_magic != NILFS_TI_MAGIC); in nilfs_transaction_commit()
268 ti->ti_flags |= NILFS_TI_COMMIT; in nilfs_transaction_commit()
269 if (ti->ti_count > 0) { in nilfs_transaction_commit()
270 ti->ti_count--; in nilfs_transaction_commit()
271 trace_nilfs2_transaction_transition(sb, ti, ti->ti_count, in nilfs_transaction_commit()
272 ti->ti_flags, TRACE_NILFS2_TRANSACTION_COMMIT); in nilfs_transaction_commit()
275 if (nilfs->ns_writer) { in nilfs_transaction_commit()
276 struct nilfs_sc_info *sci = nilfs->ns_writer; in nilfs_transaction_commit() local
278 if (ti->ti_flags & NILFS_TI_COMMIT) in nilfs_transaction_commit()
279 nilfs_segctor_start_timer(sci); in nilfs_transaction_commit()
280 if (atomic_read(&nilfs->ns_ndirtyblks) > sci->sc_watermark) in nilfs_transaction_commit()
281 nilfs_segctor_do_flush(sci, 0); in nilfs_transaction_commit()
283 up_read(&nilfs->ns_segctor_sem); in nilfs_transaction_commit()
284 trace_nilfs2_transaction_transition(sb, ti, ti->ti_count, in nilfs_transaction_commit()
285 ti->ti_flags, TRACE_NILFS2_TRANSACTION_COMMIT); in nilfs_transaction_commit()
287 current->journal_info = ti->ti_save; in nilfs_transaction_commit()
289 if (ti->ti_flags & NILFS_TI_SYNC) in nilfs_transaction_commit()
291 if (ti->ti_flags & NILFS_TI_DYNAMIC_ALLOC) in nilfs_transaction_commit()
292 kmem_cache_free(nilfs_transaction_cachep, ti); in nilfs_transaction_commit()
299 struct nilfs_transaction_info *ti = current->journal_info; in nilfs_transaction_abort() local
300 struct the_nilfs *nilfs = sb->s_fs_info; in nilfs_transaction_abort()
302 BUG_ON(ti == NULL || ti->ti_magic != NILFS_TI_MAGIC); in nilfs_transaction_abort()
303 if (ti->ti_count > 0) { in nilfs_transaction_abort()
304 ti->ti_count--; in nilfs_transaction_abort()
305 trace_nilfs2_transaction_transition(sb, ti, ti->ti_count, in nilfs_transaction_abort()
306 ti->ti_flags, TRACE_NILFS2_TRANSACTION_ABORT); in nilfs_transaction_abort()
309 up_read(&nilfs->ns_segctor_sem); in nilfs_transaction_abort()
311 trace_nilfs2_transaction_transition(sb, ti, ti->ti_count, in nilfs_transaction_abort()
312 ti->ti_flags, TRACE_NILFS2_TRANSACTION_ABORT); in nilfs_transaction_abort()
314 current->journal_info = ti->ti_save; in nilfs_transaction_abort()
315 if (ti->ti_flags & NILFS_TI_DYNAMIC_ALLOC) in nilfs_transaction_abort()
316 kmem_cache_free(nilfs_transaction_cachep, ti); in nilfs_transaction_abort()
322 struct the_nilfs *nilfs = sb->s_fs_info; in nilfs_relax_pressure_in_lock()
323 struct nilfs_sc_info *sci = nilfs->ns_writer; in nilfs_relax_pressure_in_lock() local
325 if (sb_rdonly(sb) || unlikely(!sci) || !sci->sc_flush_request) in nilfs_relax_pressure_in_lock()
328 set_bit(NILFS_SC_PRIOR_FLUSH, &sci->sc_flags); in nilfs_relax_pressure_in_lock()
329 up_read(&nilfs->ns_segctor_sem); in nilfs_relax_pressure_in_lock()
331 down_write(&nilfs->ns_segctor_sem); in nilfs_relax_pressure_in_lock()
332 if (sci->sc_flush_request && in nilfs_relax_pressure_in_lock()
333 test_bit(NILFS_SC_PRIOR_FLUSH, &sci->sc_flags)) { in nilfs_relax_pressure_in_lock()
334 struct nilfs_transaction_info *ti = current->journal_info; in nilfs_relax_pressure_in_lock() local
336 ti->ti_flags |= NILFS_TI_WRITER; in nilfs_relax_pressure_in_lock()
337 nilfs_segctor_do_immediate_flush(sci); in nilfs_relax_pressure_in_lock()
338 ti->ti_flags &= ~NILFS_TI_WRITER; in nilfs_relax_pressure_in_lock()
340 downgrade_write(&nilfs->ns_segctor_sem); in nilfs_relax_pressure_in_lock()
344 struct nilfs_transaction_info *ti, in nilfs_transaction_lock() argument
347 struct nilfs_transaction_info *cur_ti = current->journal_info; in nilfs_transaction_lock()
348 struct the_nilfs *nilfs = sb->s_fs_info; in nilfs_transaction_lock()
349 struct nilfs_sc_info *sci = nilfs->ns_writer; in nilfs_transaction_lock() local
352 ti->ti_flags = NILFS_TI_WRITER; in nilfs_transaction_lock()
353 ti->ti_count = 0; in nilfs_transaction_lock()
354 ti->ti_save = cur_ti; in nilfs_transaction_lock()
355 ti->ti_magic = NILFS_TI_MAGIC; in nilfs_transaction_lock()
356 current->journal_info = ti; in nilfs_transaction_lock()
359 trace_nilfs2_transaction_transition(sb, ti, ti->ti_count, in nilfs_transaction_lock()
360 ti->ti_flags, TRACE_NILFS2_TRANSACTION_TRYLOCK); in nilfs_transaction_lock()
362 down_write(&nilfs->ns_segctor_sem); in nilfs_transaction_lock()
363 if (!test_bit(NILFS_SC_PRIOR_FLUSH, &sci->sc_flags)) in nilfs_transaction_lock()
366 nilfs_segctor_do_immediate_flush(sci); in nilfs_transaction_lock()
368 up_write(&nilfs->ns_segctor_sem); in nilfs_transaction_lock()
372 ti->ti_flags |= NILFS_TI_GC; in nilfs_transaction_lock()
374 trace_nilfs2_transaction_transition(sb, ti, ti->ti_count, in nilfs_transaction_lock()
375 ti->ti_flags, TRACE_NILFS2_TRANSACTION_LOCK); in nilfs_transaction_lock()
380 struct nilfs_transaction_info *ti = current->journal_info; in nilfs_transaction_unlock() local
381 struct the_nilfs *nilfs = sb->s_fs_info; in nilfs_transaction_unlock()
383 BUG_ON(ti == NULL || ti->ti_magic != NILFS_TI_MAGIC); in nilfs_transaction_unlock()
384 BUG_ON(ti->ti_count > 0); in nilfs_transaction_unlock()
386 up_write(&nilfs->ns_segctor_sem); in nilfs_transaction_unlock()
387 current->journal_info = ti->ti_save; in nilfs_transaction_unlock()
389 trace_nilfs2_transaction_transition(sb, ti, ti->ti_count, in nilfs_transaction_unlock()
390 ti->ti_flags, TRACE_NILFS2_TRANSACTION_UNLOCK); in nilfs_transaction_unlock()
393 static void *nilfs_segctor_map_segsum_entry(struct nilfs_sc_info *sci, in nilfs_segctor_map_segsum_entry() argument
397 struct nilfs_segment_buffer *segbuf = sci->sc_curseg; in nilfs_segctor_map_segsum_entry()
398 unsigned int blocksize = sci->sc_super->s_blocksize; in nilfs_segctor_map_segsum_entry()
401 if (unlikely(ssp->offset + bytes > blocksize)) { in nilfs_segctor_map_segsum_entry()
402 ssp->offset = 0; in nilfs_segctor_map_segsum_entry()
403 BUG_ON(NILFS_SEGBUF_BH_IS_LAST(ssp->bh, in nilfs_segctor_map_segsum_entry()
404 &segbuf->sb_segsum_buffers)); in nilfs_segctor_map_segsum_entry()
405 ssp->bh = NILFS_SEGBUF_NEXT_BH(ssp->bh); in nilfs_segctor_map_segsum_entry()
407 p = ssp->bh->b_data + ssp->offset; in nilfs_segctor_map_segsum_entry()
408 ssp->offset += bytes; in nilfs_segctor_map_segsum_entry()
413 * nilfs_segctor_reset_segment_buffer - reset the current segment buffer
414 * @sci: nilfs_sc_info
416 static int nilfs_segctor_reset_segment_buffer(struct nilfs_sc_info *sci) in nilfs_segctor_reset_segment_buffer() argument
418 struct nilfs_segment_buffer *segbuf = sci->sc_curseg; in nilfs_segctor_reset_segment_buffer()
426 err = nilfs_segbuf_reset(segbuf, flags, sci->sc_seg_ctime, sci->sc_cno); in nilfs_segctor_reset_segment_buffer()
430 sumbh = NILFS_SEGBUF_FIRST_BH(&segbuf->sb_segsum_buffers); in nilfs_segctor_reset_segment_buffer()
431 sumbytes = segbuf->sb_sum.sumbytes; in nilfs_segctor_reset_segment_buffer()
432 sci->sc_finfo_ptr.bh = sumbh; sci->sc_finfo_ptr.offset = sumbytes; in nilfs_segctor_reset_segment_buffer()
433 sci->sc_binfo_ptr.bh = sumbh; sci->sc_binfo_ptr.offset = sumbytes; in nilfs_segctor_reset_segment_buffer()
434 sci->sc_blk_cnt = sci->sc_datablk_cnt = 0; in nilfs_segctor_reset_segment_buffer()
439 * nilfs_segctor_zeropad_segsum - zero pad the rest of the segment summary area
440 * @sci: segment constructor object
442 * nilfs_segctor_zeropad_segsum() zero-fills unallocated space at the end of
445 static void nilfs_segctor_zeropad_segsum(struct nilfs_sc_info *sci) in nilfs_segctor_zeropad_segsum() argument
449 ssp = sci->sc_blk_cnt > 0 ? &sci->sc_binfo_ptr : &sci->sc_finfo_ptr; in nilfs_segctor_zeropad_segsum()
450 if (ssp->offset < ssp->bh->b_size) in nilfs_segctor_zeropad_segsum()
451 memset(ssp->bh->b_data + ssp->offset, 0, in nilfs_segctor_zeropad_segsum()
452 ssp->bh->b_size - ssp->offset); in nilfs_segctor_zeropad_segsum()
455 static int nilfs_segctor_feed_segment(struct nilfs_sc_info *sci) in nilfs_segctor_feed_segment() argument
457 sci->sc_nblk_this_inc += sci->sc_curseg->sb_sum.nblocks; in nilfs_segctor_feed_segment()
458 if (NILFS_SEGBUF_IS_LAST(sci->sc_curseg, &sci->sc_segbufs)) in nilfs_segctor_feed_segment()
459 return -E2BIG; /* in nilfs_segctor_feed_segment()
463 nilfs_segctor_zeropad_segsum(sci); in nilfs_segctor_feed_segment()
464 sci->sc_curseg = NILFS_NEXT_SEGBUF(sci->sc_curseg); in nilfs_segctor_feed_segment()
465 return nilfs_segctor_reset_segment_buffer(sci); in nilfs_segctor_feed_segment()
468 static int nilfs_segctor_add_super_root(struct nilfs_sc_info *sci) in nilfs_segctor_add_super_root() argument
470 struct nilfs_segment_buffer *segbuf = sci->sc_curseg; in nilfs_segctor_add_super_root()
473 if (segbuf->sb_sum.nblocks >= segbuf->sb_rest_blocks) { in nilfs_segctor_add_super_root()
474 err = nilfs_segctor_feed_segment(sci); in nilfs_segctor_add_super_root()
477 segbuf = sci->sc_curseg; in nilfs_segctor_add_super_root()
479 err = nilfs_segbuf_extend_payload(segbuf, &segbuf->sb_super_root); in nilfs_segctor_add_super_root()
481 segbuf->sb_sum.flags |= NILFS_SS_SR; in nilfs_segctor_add_super_root()
489 struct nilfs_sc_info *sci, const struct nilfs_segsum_pointer *ssp, in nilfs_segctor_segsum_block_required() argument
492 unsigned int blocksize = sci->sc_super->s_blocksize; in nilfs_segctor_segsum_block_required()
495 return ssp->offset + binfo_size + in nilfs_segctor_segsum_block_required()
496 (!sci->sc_blk_cnt ? sizeof(struct nilfs_finfo) : 0) > in nilfs_segctor_segsum_block_required()
500 static void nilfs_segctor_begin_finfo(struct nilfs_sc_info *sci, in nilfs_segctor_begin_finfo() argument
503 sci->sc_curseg->sb_sum.nfinfo++; in nilfs_segctor_begin_finfo()
504 sci->sc_binfo_ptr = sci->sc_finfo_ptr; in nilfs_segctor_begin_finfo()
506 sci, &sci->sc_binfo_ptr, sizeof(struct nilfs_finfo)); in nilfs_segctor_begin_finfo()
508 if (NILFS_I(inode)->i_root && in nilfs_segctor_begin_finfo()
509 !test_bit(NILFS_SC_HAVE_DELTA, &sci->sc_flags)) in nilfs_segctor_begin_finfo()
510 set_bit(NILFS_SC_HAVE_DELTA, &sci->sc_flags); in nilfs_segctor_begin_finfo()
514 static void nilfs_segctor_end_finfo(struct nilfs_sc_info *sci, in nilfs_segctor_end_finfo() argument
522 if (sci->sc_blk_cnt == 0) in nilfs_segctor_end_finfo()
527 if (test_bit(NILFS_I_GCINODE, &ii->i_state)) in nilfs_segctor_end_finfo()
528 cno = ii->i_cno; in nilfs_segctor_end_finfo()
529 else if (NILFS_ROOT_METADATA_FILE(inode->i_ino)) in nilfs_segctor_end_finfo()
532 cno = sci->sc_cno; in nilfs_segctor_end_finfo()
534 finfo = nilfs_segctor_map_segsum_entry(sci, &sci->sc_finfo_ptr, in nilfs_segctor_end_finfo()
536 finfo->fi_ino = cpu_to_le64(inode->i_ino); in nilfs_segctor_end_finfo()
537 finfo->fi_nblocks = cpu_to_le32(sci->sc_blk_cnt); in nilfs_segctor_end_finfo()
538 finfo->fi_ndatablk = cpu_to_le32(sci->sc_datablk_cnt); in nilfs_segctor_end_finfo()
539 finfo->fi_cno = cpu_to_le64(cno); in nilfs_segctor_end_finfo()
541 segbuf = sci->sc_curseg; in nilfs_segctor_end_finfo()
542 segbuf->sb_sum.sumbytes = sci->sc_binfo_ptr.offset + in nilfs_segctor_end_finfo()
543 sci->sc_super->s_blocksize * (segbuf->sb_sum.nsumblk - 1); in nilfs_segctor_end_finfo()
544 sci->sc_finfo_ptr = sci->sc_binfo_ptr; in nilfs_segctor_end_finfo()
545 sci->sc_blk_cnt = sci->sc_datablk_cnt = 0; in nilfs_segctor_end_finfo()
548 static int nilfs_segctor_add_file_block(struct nilfs_sc_info *sci, in nilfs_segctor_add_file_block() argument
557 segbuf = sci->sc_curseg; in nilfs_segctor_add_file_block()
559 sci, &sci->sc_binfo_ptr, binfo_size); in nilfs_segctor_add_file_block()
560 if (segbuf->sb_sum.nblocks + required + 1 > segbuf->sb_rest_blocks) { in nilfs_segctor_add_file_block()
561 nilfs_segctor_end_finfo(sci, inode); in nilfs_segctor_add_file_block()
562 err = nilfs_segctor_feed_segment(sci); in nilfs_segctor_add_file_block()
568 nilfs_segctor_zeropad_segsum(sci); in nilfs_segctor_add_file_block()
573 if (sci->sc_blk_cnt == 0) in nilfs_segctor_add_file_block()
574 nilfs_segctor_begin_finfo(sci, inode); in nilfs_segctor_add_file_block()
576 nilfs_segctor_map_segsum_entry(sci, &sci->sc_binfo_ptr, binfo_size); in nilfs_segctor_add_file_block()
579 sci->sc_blk_cnt++; in nilfs_segctor_add_file_block()
587 static int nilfs_collect_file_data(struct nilfs_sc_info *sci, in nilfs_collect_file_data() argument
592 err = nilfs_bmap_propagate(NILFS_I(inode)->i_bmap, bh); in nilfs_collect_file_data()
596 err = nilfs_segctor_add_file_block(sci, bh, inode, in nilfs_collect_file_data()
599 sci->sc_datablk_cnt++; in nilfs_collect_file_data()
603 static int nilfs_collect_file_node(struct nilfs_sc_info *sci, in nilfs_collect_file_node() argument
607 return nilfs_bmap_propagate(NILFS_I(inode)->i_bmap, bh); in nilfs_collect_file_node()
610 static int nilfs_collect_file_bmap(struct nilfs_sc_info *sci, in nilfs_collect_file_bmap() argument
615 return nilfs_segctor_add_file_block(sci, bh, inode, sizeof(__le64)); in nilfs_collect_file_bmap()
618 static void nilfs_write_file_data_binfo(struct nilfs_sc_info *sci, in nilfs_write_file_data_binfo() argument
623 sci, ssp, sizeof(*binfo_v)); in nilfs_write_file_data_binfo()
624 *binfo_v = binfo->bi_v; in nilfs_write_file_data_binfo()
627 static void nilfs_write_file_node_binfo(struct nilfs_sc_info *sci, in nilfs_write_file_node_binfo() argument
632 sci, ssp, sizeof(*vblocknr)); in nilfs_write_file_node_binfo()
633 *vblocknr = binfo->bi_v.bi_vblocknr; in nilfs_write_file_node_binfo()
644 static int nilfs_collect_dat_data(struct nilfs_sc_info *sci, in nilfs_collect_dat_data() argument
649 err = nilfs_bmap_propagate(NILFS_I(inode)->i_bmap, bh); in nilfs_collect_dat_data()
653 err = nilfs_segctor_add_file_block(sci, bh, inode, sizeof(__le64)); in nilfs_collect_dat_data()
655 sci->sc_datablk_cnt++; in nilfs_collect_dat_data()
659 static int nilfs_collect_dat_bmap(struct nilfs_sc_info *sci, in nilfs_collect_dat_bmap() argument
663 return nilfs_segctor_add_file_block(sci, bh, inode, in nilfs_collect_dat_bmap()
667 static void nilfs_write_dat_data_binfo(struct nilfs_sc_info *sci, in nilfs_write_dat_data_binfo() argument
671 __le64 *blkoff = nilfs_segctor_map_segsum_entry(sci, ssp, in nilfs_write_dat_data_binfo()
673 *blkoff = binfo->bi_dat.bi_blkoff; in nilfs_write_dat_data_binfo()
676 static void nilfs_write_dat_node_binfo(struct nilfs_sc_info *sci, in nilfs_write_dat_node_binfo() argument
681 nilfs_segctor_map_segsum_entry(sci, ssp, sizeof(*binfo_dat)); in nilfs_write_dat_node_binfo()
682 *binfo_dat = binfo->bi_dat; in nilfs_write_dat_node_binfo()
706 struct address_space *mapping = inode->i_mapping; in nilfs_lookup_dirty_data_buffers()
714 * A valid range is given for sync-ing data pages. The in nilfs_lookup_dirty_data_buffers()
715 * range is rounded to per-page; extra dirty buffers in nilfs_lookup_dirty_data_buffers()
742 list_add_tail(&bh->b_assoc_buffers, listp); in nilfs_lookup_dirty_data_buffers()
749 } while (bh = bh->b_this_page, bh != head); in nilfs_lookup_dirty_data_buffers()
760 struct inode *btnc_inode = ii->i_assoc_inode; in nilfs_lookup_dirty_node_buffers()
771 while (pagevec_lookup_tag(&pvec, btnc_inode->i_mapping, &index, in nilfs_lookup_dirty_node_buffers()
779 list_add_tail(&bh->b_assoc_buffers, in nilfs_lookup_dirty_node_buffers()
782 bh = bh->b_this_page; in nilfs_lookup_dirty_node_buffers()
798 spin_lock(&nilfs->ns_inode_lock); in nilfs_dispose_list()
800 list_del_init(&ii->i_dirty); in nilfs_dispose_list()
802 if (unlikely(ii->i_bh)) { in nilfs_dispose_list()
803 brelse(ii->i_bh); in nilfs_dispose_list()
804 ii->i_bh = NULL; in nilfs_dispose_list()
806 } else if (test_bit(NILFS_I_DIRTY, &ii->i_state)) { in nilfs_dispose_list()
807 set_bit(NILFS_I_QUEUED, &ii->i_state); in nilfs_dispose_list()
808 list_add_tail(&ii->i_dirty, in nilfs_dispose_list()
809 &nilfs->ns_dirty_files); in nilfs_dispose_list()
816 spin_unlock(&nilfs->ns_inode_lock); in nilfs_dispose_list()
818 for (pii = ivec; nv > 0; pii++, nv--) in nilfs_dispose_list()
819 iput(&(*pii)->vfs_inode); in nilfs_dispose_list()
825 struct nilfs_sc_info *sci = container_of(work, struct nilfs_sc_info, in nilfs_iput_work_func() local
827 struct the_nilfs *nilfs = sci->sc_super->s_fs_info; in nilfs_iput_work_func()
829 nilfs_dispose_list(nilfs, &sci->sc_iput_queue, 0); in nilfs_iput_work_func()
837 if (nilfs_mdt_fetch_dirty(root->ifile)) in nilfs_test_metadata_dirty()
839 if (nilfs_mdt_fetch_dirty(nilfs->ns_cpfile)) in nilfs_test_metadata_dirty()
841 if (nilfs_mdt_fetch_dirty(nilfs->ns_sufile)) in nilfs_test_metadata_dirty()
843 if ((ret || nilfs_doing_gc()) && nilfs_mdt_fetch_dirty(nilfs->ns_dat)) in nilfs_test_metadata_dirty()
848 static int nilfs_segctor_clean(struct nilfs_sc_info *sci) in nilfs_segctor_clean() argument
850 return list_empty(&sci->sc_dirty_files) && in nilfs_segctor_clean()
851 !test_bit(NILFS_SC_DIRTY, &sci->sc_flags) && in nilfs_segctor_clean()
852 sci->sc_nfreesegs == 0 && in nilfs_segctor_clean()
853 (!nilfs_doing_gc() || list_empty(&sci->sc_gc_inodes)); in nilfs_segctor_clean()
856 static int nilfs_segctor_confirm(struct nilfs_sc_info *sci) in nilfs_segctor_confirm() argument
858 struct the_nilfs *nilfs = sci->sc_super->s_fs_info; in nilfs_segctor_confirm()
861 if (nilfs_test_metadata_dirty(nilfs, sci->sc_root)) in nilfs_segctor_confirm()
862 set_bit(NILFS_SC_DIRTY, &sci->sc_flags); in nilfs_segctor_confirm()
864 spin_lock(&nilfs->ns_inode_lock); in nilfs_segctor_confirm()
865 if (list_empty(&nilfs->ns_dirty_files) && nilfs_segctor_clean(sci)) in nilfs_segctor_confirm()
868 spin_unlock(&nilfs->ns_inode_lock); in nilfs_segctor_confirm()
872 static void nilfs_segctor_clear_metadata_dirty(struct nilfs_sc_info *sci) in nilfs_segctor_clear_metadata_dirty() argument
874 struct the_nilfs *nilfs = sci->sc_super->s_fs_info; in nilfs_segctor_clear_metadata_dirty()
876 nilfs_mdt_clear_dirty(sci->sc_root->ifile); in nilfs_segctor_clear_metadata_dirty()
877 nilfs_mdt_clear_dirty(nilfs->ns_cpfile); in nilfs_segctor_clear_metadata_dirty()
878 nilfs_mdt_clear_dirty(nilfs->ns_sufile); in nilfs_segctor_clear_metadata_dirty()
879 nilfs_mdt_clear_dirty(nilfs->ns_dat); in nilfs_segctor_clear_metadata_dirty()
882 static int nilfs_segctor_create_checkpoint(struct nilfs_sc_info *sci) in nilfs_segctor_create_checkpoint() argument
884 struct the_nilfs *nilfs = sci->sc_super->s_fs_info; in nilfs_segctor_create_checkpoint()
890 err = nilfs_cpfile_get_checkpoint(nilfs->ns_cpfile, nilfs->ns_cno, 1, in nilfs_segctor_create_checkpoint()
899 nilfs_mdt_mark_dirty(nilfs->ns_cpfile); in nilfs_segctor_create_checkpoint()
901 nilfs->ns_cpfile, nilfs->ns_cno, bh_cp); in nilfs_segctor_create_checkpoint()
902 } else if (err == -EINVAL || err == -ENOENT) { in nilfs_segctor_create_checkpoint()
903 nilfs_error(sci->sc_super, in nilfs_segctor_create_checkpoint()
905 err = -EIO; in nilfs_segctor_create_checkpoint()
910 static int nilfs_segctor_fill_in_checkpoint(struct nilfs_sc_info *sci) in nilfs_segctor_fill_in_checkpoint() argument
912 struct the_nilfs *nilfs = sci->sc_super->s_fs_info; in nilfs_segctor_fill_in_checkpoint()
917 err = nilfs_cpfile_get_checkpoint(nilfs->ns_cpfile, nilfs->ns_cno, 0, in nilfs_segctor_fill_in_checkpoint()
920 if (err == -EINVAL || err == -ENOENT) { in nilfs_segctor_fill_in_checkpoint()
921 nilfs_error(sci->sc_super, in nilfs_segctor_fill_in_checkpoint()
923 err = -EIO; in nilfs_segctor_fill_in_checkpoint()
927 raw_cp->cp_snapshot_list.ssl_next = 0; in nilfs_segctor_fill_in_checkpoint()
928 raw_cp->cp_snapshot_list.ssl_prev = 0; in nilfs_segctor_fill_in_checkpoint()
929 raw_cp->cp_inodes_count = in nilfs_segctor_fill_in_checkpoint()
930 cpu_to_le64(atomic64_read(&sci->sc_root->inodes_count)); in nilfs_segctor_fill_in_checkpoint()
931 raw_cp->cp_blocks_count = in nilfs_segctor_fill_in_checkpoint()
932 cpu_to_le64(atomic64_read(&sci->sc_root->blocks_count)); in nilfs_segctor_fill_in_checkpoint()
933 raw_cp->cp_nblk_inc = in nilfs_segctor_fill_in_checkpoint()
934 cpu_to_le64(sci->sc_nblk_inc + sci->sc_nblk_this_inc); in nilfs_segctor_fill_in_checkpoint()
935 raw_cp->cp_create = cpu_to_le64(sci->sc_seg_ctime); in nilfs_segctor_fill_in_checkpoint()
936 raw_cp->cp_cno = cpu_to_le64(nilfs->ns_cno); in nilfs_segctor_fill_in_checkpoint()
938 if (test_bit(NILFS_SC_HAVE_DELTA, &sci->sc_flags)) in nilfs_segctor_fill_in_checkpoint()
943 nilfs_write_inode_common(sci->sc_root->ifile, in nilfs_segctor_fill_in_checkpoint()
944 &raw_cp->cp_ifile_inode, 1); in nilfs_segctor_fill_in_checkpoint()
945 nilfs_cpfile_put_checkpoint(nilfs->ns_cpfile, nilfs->ns_cno, bh_cp); in nilfs_segctor_fill_in_checkpoint()
959 if (test_bit(NILFS_I_BMAP, &ii->i_state)) { in nilfs_fill_in_file_bmap()
960 ibh = ii->i_bh; in nilfs_fill_in_file_bmap()
962 raw_inode = nilfs_ifile_map_inode(ifile, ii->vfs_inode.i_ino, in nilfs_fill_in_file_bmap()
964 nilfs_bmap_write(ii->i_bmap, raw_inode); in nilfs_fill_in_file_bmap()
965 nilfs_ifile_unmap_inode(ifile, ii->vfs_inode.i_ino, ibh); in nilfs_fill_in_file_bmap()
969 static void nilfs_segctor_fill_in_file_bmap(struct nilfs_sc_info *sci) in nilfs_segctor_fill_in_file_bmap() argument
973 list_for_each_entry(ii, &sci->sc_dirty_files, i_dirty) { in nilfs_segctor_fill_in_file_bmap()
974 nilfs_fill_in_file_bmap(sci->sc_root->ifile, ii); in nilfs_segctor_fill_in_file_bmap()
975 set_bit(NILFS_I_COLLECTED, &ii->i_state); in nilfs_segctor_fill_in_file_bmap()
979 static void nilfs_segctor_fill_in_super_root(struct nilfs_sc_info *sci, in nilfs_segctor_fill_in_super_root() argument
986 bh_sr = NILFS_LAST_SEGBUF(&sci->sc_segbufs)->sb_super_root; in nilfs_segctor_fill_in_super_root()
987 raw_sr = (struct nilfs_super_root *)bh_sr->b_data; in nilfs_segctor_fill_in_super_root()
988 isz = nilfs->ns_inode_size; in nilfs_segctor_fill_in_super_root()
991 raw_sr->sr_bytes = cpu_to_le16(srsz); in nilfs_segctor_fill_in_super_root()
992 raw_sr->sr_nongc_ctime in nilfs_segctor_fill_in_super_root()
994 nilfs->ns_nongc_ctime : sci->sc_seg_ctime); in nilfs_segctor_fill_in_super_root()
995 raw_sr->sr_flags = 0; in nilfs_segctor_fill_in_super_root()
997 nilfs_write_inode_common(nilfs->ns_dat, (void *)raw_sr + in nilfs_segctor_fill_in_super_root()
999 nilfs_write_inode_common(nilfs->ns_cpfile, (void *)raw_sr + in nilfs_segctor_fill_in_super_root()
1001 nilfs_write_inode_common(nilfs->ns_sufile, (void *)raw_sr + in nilfs_segctor_fill_in_super_root()
1003 memset((void *)raw_sr + srsz, 0, nilfs->ns_blocksize - srsz); in nilfs_segctor_fill_in_super_root()
1011 if (test_bit(NILFS_I_COLLECTED, &ii->i_state)) in nilfs_redirty_inodes()
1012 clear_bit(NILFS_I_COLLECTED, &ii->i_state); in nilfs_redirty_inodes()
1021 if (!test_and_clear_bit(NILFS_I_COLLECTED, &ii->i_state)) in nilfs_drop_collected_inodes()
1024 clear_bit(NILFS_I_INODE_SYNC, &ii->i_state); in nilfs_drop_collected_inodes()
1025 set_bit(NILFS_I_UPDATED, &ii->i_state); in nilfs_drop_collected_inodes()
1029 static int nilfs_segctor_apply_buffers(struct nilfs_sc_info *sci, in nilfs_segctor_apply_buffers() argument
1041 list_del_init(&bh->b_assoc_buffers); in nilfs_segctor_apply_buffers()
1042 err = collect(sci, bh, inode); in nilfs_segctor_apply_buffers()
1054 list_del_init(&bh->b_assoc_buffers); in nilfs_segctor_apply_buffers()
1060 static size_t nilfs_segctor_buffer_rest(struct nilfs_sc_info *sci) in nilfs_segctor_buffer_rest() argument
1063 return sci->sc_segbuf_nblocks - in nilfs_segctor_buffer_rest()
1064 (sci->sc_nblk_this_inc + sci->sc_curseg->sb_sum.nblocks); in nilfs_segctor_buffer_rest()
1067 static int nilfs_segctor_scan_file(struct nilfs_sc_info *sci, in nilfs_segctor_scan_file() argument
1075 if (!(sci->sc_stage.flags & NILFS_CF_NODE)) { in nilfs_segctor_scan_file()
1076 size_t n, rest = nilfs_segctor_buffer_rest(sci); in nilfs_segctor_scan_file()
1082 sci, inode, &data_buffers, in nilfs_segctor_scan_file()
1083 sc_ops->collect_data); in nilfs_segctor_scan_file()
1084 BUG_ON(!err); /* always receive -E2BIG or true error */ in nilfs_segctor_scan_file()
1090 if (!(sci->sc_stage.flags & NILFS_CF_NODE)) { in nilfs_segctor_scan_file()
1092 sci, inode, &data_buffers, sc_ops->collect_data); in nilfs_segctor_scan_file()
1096 sci, inode, &node_buffers, NULL); in nilfs_segctor_scan_file()
1099 sci->sc_stage.flags |= NILFS_CF_NODE; in nilfs_segctor_scan_file()
1103 sci, inode, &node_buffers, sc_ops->collect_node); in nilfs_segctor_scan_file()
1107 nilfs_bmap_lookup_dirty_buffers(NILFS_I(inode)->i_bmap, &node_buffers); in nilfs_segctor_scan_file()
1109 sci, inode, &node_buffers, sc_ops->collect_bmap); in nilfs_segctor_scan_file()
1113 nilfs_segctor_end_finfo(sci, inode); in nilfs_segctor_scan_file()
1114 sci->sc_stage.flags &= ~NILFS_CF_NODE; in nilfs_segctor_scan_file()
1120 static int nilfs_segctor_scan_file_dsync(struct nilfs_sc_info *sci, in nilfs_segctor_scan_file_dsync() argument
1124 size_t n, rest = nilfs_segctor_buffer_rest(sci); in nilfs_segctor_scan_file_dsync()
1128 sci->sc_dsync_start, in nilfs_segctor_scan_file_dsync()
1129 sci->sc_dsync_end); in nilfs_segctor_scan_file_dsync()
1131 err = nilfs_segctor_apply_buffers(sci, inode, &data_buffers, in nilfs_segctor_scan_file_dsync()
1134 nilfs_segctor_end_finfo(sci, inode); in nilfs_segctor_scan_file_dsync()
1136 /* always receive -E2BIG or true error if n > rest */ in nilfs_segctor_scan_file_dsync()
1141 static int nilfs_segctor_collect_blocks(struct nilfs_sc_info *sci, int mode) in nilfs_segctor_collect_blocks() argument
1143 struct the_nilfs *nilfs = sci->sc_super->s_fs_info; in nilfs_segctor_collect_blocks()
1149 switch (nilfs_sc_cstage_get(sci)) { in nilfs_segctor_collect_blocks()
1151 /* Pre-processes */ in nilfs_segctor_collect_blocks()
1152 sci->sc_stage.flags = 0; in nilfs_segctor_collect_blocks()
1154 if (!test_bit(NILFS_SC_UNCLOSED, &sci->sc_flags)) { in nilfs_segctor_collect_blocks()
1155 sci->sc_nblk_inc = 0; in nilfs_segctor_collect_blocks()
1156 sci->sc_curseg->sb_sum.flags = NILFS_SS_LOGBGN; in nilfs_segctor_collect_blocks()
1158 nilfs_sc_cstage_set(sci, NILFS_ST_DSYNC); in nilfs_segctor_collect_blocks()
1163 sci->sc_stage.dirty_file_ptr = NULL; in nilfs_segctor_collect_blocks()
1164 sci->sc_stage.gc_inode_ptr = NULL; in nilfs_segctor_collect_blocks()
1166 nilfs_sc_cstage_set(sci, NILFS_ST_DAT); in nilfs_segctor_collect_blocks()
1169 nilfs_sc_cstage_inc(sci); in nilfs_segctor_collect_blocks()
1173 head = &sci->sc_gc_inodes; in nilfs_segctor_collect_blocks()
1174 ii = list_prepare_entry(sci->sc_stage.gc_inode_ptr, in nilfs_segctor_collect_blocks()
1178 sci, &ii->vfs_inode, in nilfs_segctor_collect_blocks()
1181 sci->sc_stage.gc_inode_ptr = list_entry( in nilfs_segctor_collect_blocks()
1182 ii->i_dirty.prev, in nilfs_segctor_collect_blocks()
1187 set_bit(NILFS_I_COLLECTED, &ii->i_state); in nilfs_segctor_collect_blocks()
1189 sci->sc_stage.gc_inode_ptr = NULL; in nilfs_segctor_collect_blocks()
1191 nilfs_sc_cstage_inc(sci); in nilfs_segctor_collect_blocks()
1194 head = &sci->sc_dirty_files; in nilfs_segctor_collect_blocks()
1195 ii = list_prepare_entry(sci->sc_stage.dirty_file_ptr, head, in nilfs_segctor_collect_blocks()
1198 clear_bit(NILFS_I_DIRTY, &ii->i_state); in nilfs_segctor_collect_blocks()
1200 err = nilfs_segctor_scan_file(sci, &ii->vfs_inode, in nilfs_segctor_collect_blocks()
1203 sci->sc_stage.dirty_file_ptr = in nilfs_segctor_collect_blocks()
1204 list_entry(ii->i_dirty.prev, in nilfs_segctor_collect_blocks()
1209 /* sci->sc_stage.dirty_file_ptr = NILFS_I(inode); */ in nilfs_segctor_collect_blocks()
1212 sci->sc_stage.dirty_file_ptr = NULL; in nilfs_segctor_collect_blocks()
1214 nilfs_sc_cstage_set(sci, NILFS_ST_DONE); in nilfs_segctor_collect_blocks()
1217 nilfs_sc_cstage_inc(sci); in nilfs_segctor_collect_blocks()
1218 sci->sc_stage.flags |= NILFS_CF_IFILE_STARTED; in nilfs_segctor_collect_blocks()
1221 err = nilfs_segctor_scan_file(sci, sci->sc_root->ifile, in nilfs_segctor_collect_blocks()
1225 nilfs_sc_cstage_inc(sci); in nilfs_segctor_collect_blocks()
1227 err = nilfs_segctor_create_checkpoint(sci); in nilfs_segctor_collect_blocks()
1232 err = nilfs_segctor_scan_file(sci, nilfs->ns_cpfile, in nilfs_segctor_collect_blocks()
1236 nilfs_sc_cstage_inc(sci); in nilfs_segctor_collect_blocks()
1239 err = nilfs_sufile_freev(nilfs->ns_sufile, sci->sc_freesegs, in nilfs_segctor_collect_blocks()
1240 sci->sc_nfreesegs, &ndone); in nilfs_segctor_collect_blocks()
1242 nilfs_sufile_cancel_freev(nilfs->ns_sufile, in nilfs_segctor_collect_blocks()
1243 sci->sc_freesegs, ndone, in nilfs_segctor_collect_blocks()
1247 sci->sc_stage.flags |= NILFS_CF_SUFREED; in nilfs_segctor_collect_blocks()
1249 err = nilfs_segctor_scan_file(sci, nilfs->ns_sufile, in nilfs_segctor_collect_blocks()
1253 nilfs_sc_cstage_inc(sci); in nilfs_segctor_collect_blocks()
1257 err = nilfs_segctor_scan_file(sci, nilfs->ns_dat, in nilfs_segctor_collect_blocks()
1262 nilfs_sc_cstage_set(sci, NILFS_ST_DONE); in nilfs_segctor_collect_blocks()
1265 nilfs_sc_cstage_inc(sci); in nilfs_segctor_collect_blocks()
1270 err = nilfs_segctor_add_super_root(sci); in nilfs_segctor_collect_blocks()
1275 sci->sc_curseg->sb_sum.flags |= NILFS_SS_LOGEND; in nilfs_segctor_collect_blocks()
1276 nilfs_sc_cstage_set(sci, NILFS_ST_DONE); in nilfs_segctor_collect_blocks()
1280 sci->sc_curseg->sb_sum.flags |= NILFS_SS_SYNDT; in nilfs_segctor_collect_blocks()
1281 ii = sci->sc_dsync_inode; in nilfs_segctor_collect_blocks()
1282 if (!test_bit(NILFS_I_BUSY, &ii->i_state)) in nilfs_segctor_collect_blocks()
1285 err = nilfs_segctor_scan_file_dsync(sci, &ii->vfs_inode); in nilfs_segctor_collect_blocks()
1288 sci->sc_curseg->sb_sum.flags |= NILFS_SS_LOGEND; in nilfs_segctor_collect_blocks()
1289 nilfs_sc_cstage_set(sci, NILFS_ST_DONE); in nilfs_segctor_collect_blocks()
1302 * nilfs_segctor_begin_construction - setup segment buffer to make a new log
1303 * @sci: nilfs_sc_info
1306 static int nilfs_segctor_begin_construction(struct nilfs_sc_info *sci, in nilfs_segctor_begin_construction() argument
1313 segbuf = nilfs_segbuf_new(sci->sc_super); in nilfs_segctor_begin_construction()
1315 return -ENOMEM; in nilfs_segctor_begin_construction()
1317 if (list_empty(&sci->sc_write_logs)) { in nilfs_segctor_begin_construction()
1318 nilfs_segbuf_map(segbuf, nilfs->ns_segnum, in nilfs_segctor_begin_construction()
1319 nilfs->ns_pseg_offset, nilfs); in nilfs_segctor_begin_construction()
1320 if (segbuf->sb_rest_blocks < NILFS_PSEG_MIN_BLOCKS) { in nilfs_segctor_begin_construction()
1322 nilfs_segbuf_map(segbuf, nilfs->ns_segnum, 0, nilfs); in nilfs_segctor_begin_construction()
1325 segbuf->sb_sum.seg_seq = nilfs->ns_seg_seq; in nilfs_segctor_begin_construction()
1326 nextnum = nilfs->ns_nextnum; in nilfs_segctor_begin_construction()
1328 if (nilfs->ns_segnum == nilfs->ns_nextnum) in nilfs_segctor_begin_construction()
1333 prev = NILFS_LAST_SEGBUF(&sci->sc_write_logs); in nilfs_segctor_begin_construction()
1335 segbuf->sb_sum.seg_seq = prev->sb_sum.seg_seq; in nilfs_segctor_begin_construction()
1336 nextnum = prev->sb_nextnum; in nilfs_segctor_begin_construction()
1338 if (segbuf->sb_rest_blocks < NILFS_PSEG_MIN_BLOCKS) { in nilfs_segctor_begin_construction()
1339 nilfs_segbuf_map(segbuf, prev->sb_nextnum, 0, nilfs); in nilfs_segctor_begin_construction()
1340 segbuf->sb_sum.seg_seq++; in nilfs_segctor_begin_construction()
1345 err = nilfs_sufile_mark_dirty(nilfs->ns_sufile, segbuf->sb_segnum); in nilfs_segctor_begin_construction()
1350 err = nilfs_sufile_alloc(nilfs->ns_sufile, &nextnum); in nilfs_segctor_begin_construction()
1356 BUG_ON(!list_empty(&sci->sc_segbufs)); in nilfs_segctor_begin_construction()
1357 list_add_tail(&segbuf->sb_list, &sci->sc_segbufs); in nilfs_segctor_begin_construction()
1358 sci->sc_segbuf_nblocks = segbuf->sb_rest_blocks; in nilfs_segctor_begin_construction()
1366 static int nilfs_segctor_extend_segments(struct nilfs_sc_info *sci, in nilfs_segctor_extend_segments() argument
1370 struct inode *sufile = nilfs->ns_sufile; in nilfs_segctor_extend_segments()
1375 prev = NILFS_LAST_SEGBUF(&sci->sc_segbufs); in nilfs_segctor_extend_segments()
1382 err = nilfs_sufile_mark_dirty(sufile, prev->sb_nextnum); in nilfs_segctor_extend_segments()
1388 err = -ENOMEM; in nilfs_segctor_extend_segments()
1389 segbuf = nilfs_segbuf_new(sci->sc_super); in nilfs_segctor_extend_segments()
1393 /* map this buffer to region of segment on-disk */ in nilfs_segctor_extend_segments()
1394 nilfs_segbuf_map(segbuf, prev->sb_nextnum, 0, nilfs); in nilfs_segctor_extend_segments()
1395 sci->sc_segbuf_nblocks += segbuf->sb_rest_blocks; in nilfs_segctor_extend_segments()
1402 segbuf->sb_sum.seg_seq = prev->sb_sum.seg_seq + 1; in nilfs_segctor_extend_segments()
1405 list_add_tail(&segbuf->sb_list, &list); in nilfs_segctor_extend_segments()
1408 list_splice_tail(&list, &sci->sc_segbufs); in nilfs_segctor_extend_segments()
1415 ret = nilfs_sufile_free(sufile, segbuf->sb_nextnum); in nilfs_segctor_extend_segments()
1426 struct inode *sufile = nilfs->ns_sufile; in nilfs_free_incomplete_logs()
1430 if (nilfs->ns_nextnum != segbuf->sb_nextnum) { in nilfs_free_incomplete_logs()
1431 ret = nilfs_sufile_free(sufile, segbuf->sb_nextnum); in nilfs_free_incomplete_logs()
1434 if (atomic_read(&segbuf->sb_err)) { in nilfs_free_incomplete_logs()
1436 if (segbuf->sb_pseg_start != segbuf->sb_fseg_start) in nilfs_free_incomplete_logs()
1441 nilfs_terminate_segment(nilfs, segbuf->sb_fseg_start, in nilfs_free_incomplete_logs()
1442 segbuf->sb_fseg_end); in nilfs_free_incomplete_logs()
1449 if (prev->sb_nextnum != segbuf->sb_nextnum) { in nilfs_free_incomplete_logs()
1450 ret = nilfs_sufile_free(sufile, segbuf->sb_nextnum); in nilfs_free_incomplete_logs()
1453 if (atomic_read(&segbuf->sb_err) && in nilfs_free_incomplete_logs()
1454 segbuf->sb_segnum != nilfs->ns_nextnum) in nilfs_free_incomplete_logs()
1456 nilfs_sufile_set_error(sufile, segbuf->sb_segnum); in nilfs_free_incomplete_logs()
1461 static void nilfs_segctor_update_segusage(struct nilfs_sc_info *sci, in nilfs_segctor_update_segusage() argument
1468 list_for_each_entry(segbuf, &sci->sc_segbufs, sb_list) { in nilfs_segctor_update_segusage()
1469 live_blocks = segbuf->sb_sum.nblocks + in nilfs_segctor_update_segusage()
1470 (segbuf->sb_pseg_start - segbuf->sb_fseg_start); in nilfs_segctor_update_segusage()
1471 ret = nilfs_sufile_set_segment_usage(sufile, segbuf->sb_segnum, in nilfs_segctor_update_segusage()
1473 sci->sc_seg_ctime); in nilfs_segctor_update_segusage()
1484 ret = nilfs_sufile_set_segment_usage(sufile, segbuf->sb_segnum, in nilfs_cancel_segusage()
1485 segbuf->sb_pseg_start - in nilfs_cancel_segusage()
1486 segbuf->sb_fseg_start, 0); in nilfs_cancel_segusage()
1490 ret = nilfs_sufile_set_segment_usage(sufile, segbuf->sb_segnum, in nilfs_cancel_segusage()
1496 static void nilfs_segctor_truncate_segments(struct nilfs_sc_info *sci, in nilfs_segctor_truncate_segments() argument
1503 list_for_each_entry_continue(segbuf, &sci->sc_segbufs, sb_list) { in nilfs_segctor_truncate_segments()
1504 sci->sc_segbuf_nblocks -= segbuf->sb_rest_blocks; in nilfs_segctor_truncate_segments()
1505 ret = nilfs_sufile_free(sufile, segbuf->sb_nextnum); in nilfs_segctor_truncate_segments()
1508 nilfs_truncate_logs(&sci->sc_segbufs, last); in nilfs_segctor_truncate_segments()
1512 static int nilfs_segctor_collect(struct nilfs_sc_info *sci, in nilfs_segctor_collect() argument
1515 struct nilfs_cstage prev_stage = sci->sc_stage; in nilfs_segctor_collect()
1520 sci->sc_nblk_this_inc = 0; in nilfs_segctor_collect()
1521 sci->sc_curseg = NILFS_FIRST_SEGBUF(&sci->sc_segbufs); in nilfs_segctor_collect()
1523 err = nilfs_segctor_reset_segment_buffer(sci); in nilfs_segctor_collect()
1527 err = nilfs_segctor_collect_blocks(sci, mode); in nilfs_segctor_collect()
1528 sci->sc_nblk_this_inc += sci->sc_curseg->sb_sum.nblocks; in nilfs_segctor_collect()
1532 if (unlikely(err != -E2BIG)) in nilfs_segctor_collect()
1537 nilfs_sc_cstage_get(sci) < NILFS_ST_CPFILE) in nilfs_segctor_collect()
1540 nilfs_clear_logs(&sci->sc_segbufs); in nilfs_segctor_collect()
1542 if (sci->sc_stage.flags & NILFS_CF_SUFREED) { in nilfs_segctor_collect()
1543 err = nilfs_sufile_cancel_freev(nilfs->ns_sufile, in nilfs_segctor_collect()
1544 sci->sc_freesegs, in nilfs_segctor_collect()
1545 sci->sc_nfreesegs, in nilfs_segctor_collect()
1548 sci->sc_stage.flags &= ~NILFS_CF_SUFREED; in nilfs_segctor_collect()
1551 err = nilfs_segctor_extend_segments(sci, nilfs, nadd); in nilfs_segctor_collect()
1556 sci->sc_stage = prev_stage; in nilfs_segctor_collect()
1558 nilfs_segctor_zeropad_segsum(sci); in nilfs_segctor_collect()
1559 nilfs_segctor_truncate_segments(sci, sci->sc_curseg, nilfs->ns_sufile); in nilfs_segctor_collect()
1569 BUG_ON(!list_empty(&new_bh->b_assoc_buffers)); in nilfs_list_replace_buffer()
1571 list_replace_init(&old_bh->b_assoc_buffers, &new_bh->b_assoc_buffers); in nilfs_list_replace_buffer()
1576 nilfs_segctor_update_payload_blocknr(struct nilfs_sc_info *sci, in nilfs_segctor_update_payload_blocknr() argument
1582 unsigned long nfinfo = segbuf->sb_sum.nfinfo; in nilfs_segctor_update_payload_blocknr()
1595 blocknr = segbuf->sb_pseg_start + segbuf->sb_sum.nsumblk; in nilfs_segctor_update_payload_blocknr()
1596 ssp.bh = NILFS_SEGBUF_FIRST_BH(&segbuf->sb_segsum_buffers); in nilfs_segctor_update_payload_blocknr()
1599 list_for_each_entry(bh, &segbuf->sb_payload_buffers, b_assoc_buffers) { in nilfs_segctor_update_payload_blocknr()
1600 if (bh == segbuf->sb_super_root) in nilfs_segctor_update_payload_blocknr()
1604 sci, &ssp, sizeof(*finfo)); in nilfs_segctor_update_payload_blocknr()
1605 ino = le64_to_cpu(finfo->fi_ino); in nilfs_segctor_update_payload_blocknr()
1606 nblocks = le32_to_cpu(finfo->fi_nblocks); in nilfs_segctor_update_payload_blocknr()
1607 ndatablk = le32_to_cpu(finfo->fi_ndatablk); in nilfs_segctor_update_payload_blocknr()
1609 inode = bh->b_page->mapping->host; in nilfs_segctor_update_payload_blocknr()
1620 err = nilfs_bmap_assign(NILFS_I(inode)->i_bmap, &bh, blocknr, in nilfs_segctor_update_payload_blocknr()
1629 sc_op->write_data_binfo(sci, &ssp, &binfo); in nilfs_segctor_update_payload_blocknr()
1631 sc_op->write_node_binfo(sci, &ssp, &binfo); in nilfs_segctor_update_payload_blocknr()
1634 if (--nblocks == 0) { in nilfs_segctor_update_payload_blocknr()
1636 if (--nfinfo == 0) in nilfs_segctor_update_payload_blocknr()
1639 ndatablk--; in nilfs_segctor_update_payload_blocknr()
1648 static int nilfs_segctor_assign(struct nilfs_sc_info *sci, int mode) in nilfs_segctor_assign() argument
1653 list_for_each_entry(segbuf, &sci->sc_segbufs, sb_list) { in nilfs_segctor_assign()
1654 err = nilfs_segctor_update_payload_blocknr(sci, segbuf, mode); in nilfs_segctor_assign()
1666 * For split b-tree node pages, this function may be called in nilfs_begin_page_io()
1677 static void nilfs_segctor_prepare_write(struct nilfs_sc_info *sci) in nilfs_segctor_prepare_write() argument
1682 list_for_each_entry(segbuf, &sci->sc_segbufs, sb_list) { in nilfs_segctor_prepare_write()
1685 list_for_each_entry(bh, &segbuf->sb_segsum_buffers, in nilfs_segctor_prepare_write()
1687 if (bh->b_page != bd_page) { in nilfs_segctor_prepare_write()
1694 bd_page = bh->b_page; in nilfs_segctor_prepare_write()
1698 list_for_each_entry(bh, &segbuf->sb_payload_buffers, in nilfs_segctor_prepare_write()
1701 if (bh == segbuf->sb_super_root) { in nilfs_segctor_prepare_write()
1702 if (bh->b_page != bd_page) { in nilfs_segctor_prepare_write()
1707 bd_page = bh->b_page; in nilfs_segctor_prepare_write()
1711 if (bh->b_page != fs_page) { in nilfs_segctor_prepare_write()
1713 fs_page = bh->b_page; in nilfs_segctor_prepare_write()
1726 static int nilfs_segctor_write(struct nilfs_sc_info *sci, in nilfs_segctor_write() argument
1731 ret = nilfs_write_logs(&sci->sc_segbufs, nilfs); in nilfs_segctor_write()
1732 list_splice_tail_init(&sci->sc_segbufs, &sci->sc_write_logs); in nilfs_segctor_write()
1743 * For b-tree node pages, this function may be called twice in nilfs_end_page_io()
1748 * For pages holding split b-tree node buffers, dirty in nilfs_end_page_io()
1784 list_for_each_entry(bh, &segbuf->sb_segsum_buffers, in nilfs_abort_logs()
1786 if (bh->b_page != bd_page) { in nilfs_abort_logs()
1789 bd_page = bh->b_page; in nilfs_abort_logs()
1793 list_for_each_entry(bh, &segbuf->sb_payload_buffers, in nilfs_abort_logs()
1796 if (bh == segbuf->sb_super_root) { in nilfs_abort_logs()
1797 if (bh->b_page != bd_page) { in nilfs_abort_logs()
1799 bd_page = bh->b_page; in nilfs_abort_logs()
1803 if (bh->b_page != fs_page) { in nilfs_abort_logs()
1805 fs_page = bh->b_page; in nilfs_abort_logs()
1815 static void nilfs_segctor_abort_construction(struct nilfs_sc_info *sci, in nilfs_segctor_abort_construction() argument
1821 list_splice_tail_init(&sci->sc_write_logs, &logs); in nilfs_segctor_abort_construction()
1825 list_splice_tail_init(&sci->sc_segbufs, &logs); in nilfs_segctor_abort_construction()
1826 nilfs_cancel_segusage(&logs, nilfs->ns_sufile); in nilfs_segctor_abort_construction()
1829 if (sci->sc_stage.flags & NILFS_CF_SUFREED) { in nilfs_segctor_abort_construction()
1830 ret = nilfs_sufile_cancel_freev(nilfs->ns_sufile, in nilfs_segctor_abort_construction()
1831 sci->sc_freesegs, in nilfs_segctor_abort_construction()
1832 sci->sc_nfreesegs, in nilfs_segctor_abort_construction()
1843 nilfs->ns_segnum = segbuf->sb_segnum; in nilfs_set_next_segment()
1844 nilfs->ns_nextnum = segbuf->sb_nextnum; in nilfs_set_next_segment()
1845 nilfs->ns_pseg_offset = segbuf->sb_pseg_start - segbuf->sb_fseg_start in nilfs_set_next_segment()
1846 + segbuf->sb_sum.nblocks; in nilfs_set_next_segment()
1847 nilfs->ns_seg_seq = segbuf->sb_sum.seg_seq; in nilfs_set_next_segment()
1848 nilfs->ns_ctime = segbuf->sb_sum.ctime; in nilfs_set_next_segment()
1851 static void nilfs_segctor_complete_write(struct nilfs_sc_info *sci) in nilfs_segctor_complete_write() argument
1855 struct the_nilfs *nilfs = sci->sc_super->s_fs_info; in nilfs_segctor_complete_write()
1858 list_for_each_entry(segbuf, &sci->sc_write_logs, sb_list) { in nilfs_segctor_complete_write()
1861 list_for_each_entry(bh, &segbuf->sb_segsum_buffers, in nilfs_segctor_complete_write()
1865 if (bh->b_page != bd_page) { in nilfs_segctor_complete_write()
1868 bd_page = bh->b_page; in nilfs_segctor_complete_write()
1875 * identifiable by the discontinuity of bh->b_page in nilfs_segctor_complete_write()
1878 * For B-tree node blocks, however, this assumption is not in nilfs_segctor_complete_write()
1879 * guaranteed. The cleanup code of B-tree node pages needs in nilfs_segctor_complete_write()
1882 list_for_each_entry(bh, &segbuf->sb_payload_buffers, in nilfs_segctor_complete_write()
1890 set_mask_bits(&bh->b_state, clear_bits, set_bits); in nilfs_segctor_complete_write()
1891 if (bh == segbuf->sb_super_root) { in nilfs_segctor_complete_write()
1892 if (bh->b_page != bd_page) { in nilfs_segctor_complete_write()
1894 bd_page = bh->b_page; in nilfs_segctor_complete_write()
1899 if (bh->b_page != fs_page) { in nilfs_segctor_complete_write()
1901 fs_page = bh->b_page; in nilfs_segctor_complete_write()
1906 if (segbuf->sb_sum.flags & NILFS_SS_LOGBGN) { in nilfs_segctor_complete_write()
1907 set_bit(NILFS_SC_UNCLOSED, &sci->sc_flags); in nilfs_segctor_complete_write()
1908 sci->sc_lseg_stime = jiffies; in nilfs_segctor_complete_write()
1910 if (segbuf->sb_sum.flags & NILFS_SS_LOGEND) in nilfs_segctor_complete_write()
1911 clear_bit(NILFS_SC_UNCLOSED, &sci->sc_flags); in nilfs_segctor_complete_write()
1923 nilfs_drop_collected_inodes(&sci->sc_dirty_files); in nilfs_segctor_complete_write()
1926 nilfs_drop_collected_inodes(&sci->sc_gc_inodes); in nilfs_segctor_complete_write()
1928 nilfs->ns_nongc_ctime = sci->sc_seg_ctime; in nilfs_segctor_complete_write()
1930 sci->sc_nblk_inc += sci->sc_nblk_this_inc; in nilfs_segctor_complete_write()
1932 segbuf = NILFS_LAST_SEGBUF(&sci->sc_write_logs); in nilfs_segctor_complete_write()
1936 nilfs->ns_flushed_device = 0; in nilfs_segctor_complete_write()
1937 nilfs_set_last_segment(nilfs, segbuf->sb_pseg_start, in nilfs_segctor_complete_write()
1938 segbuf->sb_sum.seg_seq, nilfs->ns_cno++); in nilfs_segctor_complete_write()
1940 clear_bit(NILFS_SC_HAVE_DELTA, &sci->sc_flags); in nilfs_segctor_complete_write()
1941 clear_bit(NILFS_SC_DIRTY, &sci->sc_flags); in nilfs_segctor_complete_write()
1942 set_bit(NILFS_SC_SUPER_ROOT, &sci->sc_flags); in nilfs_segctor_complete_write()
1943 nilfs_segctor_clear_metadata_dirty(sci); in nilfs_segctor_complete_write()
1945 clear_bit(NILFS_SC_SUPER_ROOT, &sci->sc_flags); in nilfs_segctor_complete_write()
1948 static int nilfs_segctor_wait(struct nilfs_sc_info *sci) in nilfs_segctor_wait() argument
1952 ret = nilfs_wait_on_logs(&sci->sc_write_logs); in nilfs_segctor_wait()
1954 nilfs_segctor_complete_write(sci); in nilfs_segctor_wait()
1955 nilfs_destroy_logs(&sci->sc_write_logs); in nilfs_segctor_wait()
1960 static int nilfs_segctor_collect_dirty_files(struct nilfs_sc_info *sci, in nilfs_segctor_collect_dirty_files() argument
1964 struct inode *ifile = sci->sc_root->ifile; in nilfs_segctor_collect_dirty_files()
1966 spin_lock(&nilfs->ns_inode_lock); in nilfs_segctor_collect_dirty_files()
1968 list_for_each_entry_safe(ii, n, &nilfs->ns_dirty_files, i_dirty) { in nilfs_segctor_collect_dirty_files()
1969 if (!ii->i_bh) { in nilfs_segctor_collect_dirty_files()
1973 spin_unlock(&nilfs->ns_inode_lock); in nilfs_segctor_collect_dirty_files()
1975 ifile, ii->vfs_inode.i_ino, &ibh); in nilfs_segctor_collect_dirty_files()
1977 nilfs_warn(sci->sc_super, in nilfs_segctor_collect_dirty_files()
1979 err, ii->vfs_inode.i_ino); in nilfs_segctor_collect_dirty_files()
1982 spin_lock(&nilfs->ns_inode_lock); in nilfs_segctor_collect_dirty_files()
1983 if (likely(!ii->i_bh)) in nilfs_segctor_collect_dirty_files()
1984 ii->i_bh = ibh; in nilfs_segctor_collect_dirty_files()
1991 mark_buffer_dirty(ii->i_bh); in nilfs_segctor_collect_dirty_files()
1994 clear_bit(NILFS_I_QUEUED, &ii->i_state); in nilfs_segctor_collect_dirty_files()
1995 set_bit(NILFS_I_BUSY, &ii->i_state); in nilfs_segctor_collect_dirty_files()
1996 list_move_tail(&ii->i_dirty, &sci->sc_dirty_files); in nilfs_segctor_collect_dirty_files()
1998 spin_unlock(&nilfs->ns_inode_lock); in nilfs_segctor_collect_dirty_files()
2003 static void nilfs_segctor_drop_written_files(struct nilfs_sc_info *sci, in nilfs_segctor_drop_written_files() argument
2007 int during_mount = !(sci->sc_super->s_flags & SB_ACTIVE); in nilfs_segctor_drop_written_files()
2010 spin_lock(&nilfs->ns_inode_lock); in nilfs_segctor_drop_written_files()
2011 list_for_each_entry_safe(ii, n, &sci->sc_dirty_files, i_dirty) { in nilfs_segctor_drop_written_files()
2012 if (!test_and_clear_bit(NILFS_I_UPDATED, &ii->i_state) || in nilfs_segctor_drop_written_files()
2013 test_bit(NILFS_I_DIRTY, &ii->i_state)) in nilfs_segctor_drop_written_files()
2016 clear_bit(NILFS_I_BUSY, &ii->i_state); in nilfs_segctor_drop_written_files()
2017 brelse(ii->i_bh); in nilfs_segctor_drop_written_files()
2018 ii->i_bh = NULL; in nilfs_segctor_drop_written_files()
2019 list_del_init(&ii->i_dirty); in nilfs_segctor_drop_written_files()
2020 if (!ii->vfs_inode.i_nlink || during_mount) { in nilfs_segctor_drop_written_files()
2025 list_add_tail(&ii->i_dirty, &sci->sc_iput_queue); in nilfs_segctor_drop_written_files()
2028 spin_unlock(&nilfs->ns_inode_lock); in nilfs_segctor_drop_written_files()
2029 iput(&ii->vfs_inode); in nilfs_segctor_drop_written_files()
2030 spin_lock(&nilfs->ns_inode_lock); in nilfs_segctor_drop_written_files()
2033 spin_unlock(&nilfs->ns_inode_lock); in nilfs_segctor_drop_written_files()
2036 schedule_work(&sci->sc_iput_work); in nilfs_segctor_drop_written_files()
2042 static int nilfs_segctor_do_construct(struct nilfs_sc_info *sci, int mode) in nilfs_segctor_do_construct() argument
2044 struct the_nilfs *nilfs = sci->sc_super->s_fs_info; in nilfs_segctor_do_construct()
2047 if (sb_rdonly(sci->sc_super)) in nilfs_segctor_do_construct()
2048 return -EROFS; in nilfs_segctor_do_construct()
2050 nilfs_sc_cstage_set(sci, NILFS_ST_INIT); in nilfs_segctor_do_construct()
2051 sci->sc_cno = nilfs->ns_cno; in nilfs_segctor_do_construct()
2053 err = nilfs_segctor_collect_dirty_files(sci, nilfs); in nilfs_segctor_do_construct()
2057 if (nilfs_test_metadata_dirty(nilfs, sci->sc_root)) in nilfs_segctor_do_construct()
2058 set_bit(NILFS_SC_DIRTY, &sci->sc_flags); in nilfs_segctor_do_construct()
2060 if (nilfs_segctor_clean(sci)) in nilfs_segctor_do_construct()
2064 sci->sc_stage.flags &= ~NILFS_CF_HISTORY_MASK; in nilfs_segctor_do_construct()
2066 err = nilfs_segctor_begin_construction(sci, nilfs); in nilfs_segctor_do_construct()
2071 sci->sc_seg_ctime = ktime_get_real_seconds(); in nilfs_segctor_do_construct()
2073 err = nilfs_segctor_collect(sci, nilfs, mode); in nilfs_segctor_do_construct()
2078 if (nilfs_sc_cstage_get(sci) == NILFS_ST_DONE && in nilfs_segctor_do_construct()
2079 nilfs_segbuf_empty(sci->sc_curseg)) { in nilfs_segctor_do_construct()
2080 nilfs_segctor_abort_construction(sci, nilfs, 1); in nilfs_segctor_do_construct()
2084 err = nilfs_segctor_assign(sci, mode); in nilfs_segctor_do_construct()
2088 if (sci->sc_stage.flags & NILFS_CF_IFILE_STARTED) in nilfs_segctor_do_construct()
2089 nilfs_segctor_fill_in_file_bmap(sci); in nilfs_segctor_do_construct()
2092 nilfs_sc_cstage_get(sci) >= NILFS_ST_CPFILE) { in nilfs_segctor_do_construct()
2093 err = nilfs_segctor_fill_in_checkpoint(sci); in nilfs_segctor_do_construct()
2097 nilfs_segctor_fill_in_super_root(sci, nilfs); in nilfs_segctor_do_construct()
2099 nilfs_segctor_update_segusage(sci, nilfs->ns_sufile); in nilfs_segctor_do_construct()
2102 nilfs_segctor_prepare_write(sci); in nilfs_segctor_do_construct()
2104 nilfs_add_checksums_on_logs(&sci->sc_segbufs, in nilfs_segctor_do_construct()
2105 nilfs->ns_crc_seed); in nilfs_segctor_do_construct()
2107 err = nilfs_segctor_write(sci, nilfs); in nilfs_segctor_do_construct()
2111 if (nilfs_sc_cstage_get(sci) == NILFS_ST_DONE || in nilfs_segctor_do_construct()
2112 nilfs->ns_blocksize_bits != PAGE_SHIFT) { in nilfs_segctor_do_construct()
2120 err = nilfs_segctor_wait(sci); in nilfs_segctor_do_construct()
2124 } while (nilfs_sc_cstage_get(sci) != NILFS_ST_DONE); in nilfs_segctor_do_construct()
2127 nilfs_segctor_drop_written_files(sci, nilfs); in nilfs_segctor_do_construct()
2131 if (sci->sc_stage.flags & NILFS_CF_IFILE_STARTED) in nilfs_segctor_do_construct()
2132 nilfs_redirty_inodes(&sci->sc_dirty_files); in nilfs_segctor_do_construct()
2136 nilfs_redirty_inodes(&sci->sc_gc_inodes); in nilfs_segctor_do_construct()
2137 nilfs_segctor_abort_construction(sci, nilfs, err); in nilfs_segctor_do_construct()
2142 * nilfs_segctor_start_timer - set timer of background write
2143 * @sci: nilfs_sc_info
2149 static void nilfs_segctor_start_timer(struct nilfs_sc_info *sci) in nilfs_segctor_start_timer() argument
2151 spin_lock(&sci->sc_state_lock); in nilfs_segctor_start_timer()
2152 if (!(sci->sc_state & NILFS_SEGCTOR_COMMIT)) { in nilfs_segctor_start_timer()
2153 sci->sc_timer.expires = jiffies + sci->sc_interval; in nilfs_segctor_start_timer()
2154 add_timer(&sci->sc_timer); in nilfs_segctor_start_timer()
2155 sci->sc_state |= NILFS_SEGCTOR_COMMIT; in nilfs_segctor_start_timer()
2157 spin_unlock(&sci->sc_state_lock); in nilfs_segctor_start_timer()
2160 static void nilfs_segctor_do_flush(struct nilfs_sc_info *sci, int bn) in nilfs_segctor_do_flush() argument
2162 spin_lock(&sci->sc_state_lock); in nilfs_segctor_do_flush()
2163 if (!(sci->sc_flush_request & BIT(bn))) { in nilfs_segctor_do_flush()
2164 unsigned long prev_req = sci->sc_flush_request; in nilfs_segctor_do_flush()
2166 sci->sc_flush_request |= BIT(bn); in nilfs_segctor_do_flush()
2168 wake_up(&sci->sc_wait_daemon); in nilfs_segctor_do_flush()
2170 spin_unlock(&sci->sc_state_lock); in nilfs_segctor_do_flush()
2174 * nilfs_flush_segment - trigger a segment construction for resource control
2180 struct the_nilfs *nilfs = sb->s_fs_info; in nilfs_flush_segment()
2181 struct nilfs_sc_info *sci = nilfs->ns_writer; in nilfs_flush_segment() local
2183 if (!sci || nilfs_doing_construction()) in nilfs_flush_segment()
2185 nilfs_segctor_do_flush(sci, NILFS_MDT_INODE(sb, ino) ? ino : 0); in nilfs_flush_segment()
2196 static int nilfs_segctor_sync(struct nilfs_sc_info *sci) in nilfs_segctor_sync() argument
2201 spin_lock(&sci->sc_state_lock); in nilfs_segctor_sync()
2205 wait_req.seq = ++sci->sc_seq_request; in nilfs_segctor_sync()
2206 spin_unlock(&sci->sc_state_lock); in nilfs_segctor_sync()
2209 add_wait_queue(&sci->sc_wait_request, &wait_req.wq); in nilfs_segctor_sync()
2211 wake_up(&sci->sc_wait_daemon); in nilfs_segctor_sync()
2222 err = -ERESTARTSYS; in nilfs_segctor_sync()
2225 finish_wait(&sci->sc_wait_request, &wait_req.wq); in nilfs_segctor_sync()
2229 static void nilfs_segctor_wakeup(struct nilfs_sc_info *sci, int err) in nilfs_segctor_wakeup() argument
2234 spin_lock_irqsave(&sci->sc_wait_request.lock, flags); in nilfs_segctor_wakeup()
2235 list_for_each_entry_safe(wrq, n, &sci->sc_wait_request.head, wq.entry) { in nilfs_segctor_wakeup()
2236 if (!atomic_read(&wrq->done) && in nilfs_segctor_wakeup()
2237 nilfs_cnt32_ge(sci->sc_seq_done, wrq->seq)) { in nilfs_segctor_wakeup()
2238 wrq->err = err; in nilfs_segctor_wakeup()
2239 atomic_set(&wrq->done, 1); in nilfs_segctor_wakeup()
2241 if (atomic_read(&wrq->done)) { in nilfs_segctor_wakeup()
2242 wrq->wq.func(&wrq->wq, in nilfs_segctor_wakeup()
2247 spin_unlock_irqrestore(&sci->sc_wait_request.lock, flags); in nilfs_segctor_wakeup()
2251 * nilfs_construct_segment - construct a logical segment
2257 * %-EROFS - Read only filesystem.
2259 * %-EIO - I/O error
2261 * %-ENOSPC - No space left on device (only in a panic state).
2263 * %-ERESTARTSYS - Interrupted.
2265 * %-ENOMEM - Insufficient memory available.
2269 struct the_nilfs *nilfs = sb->s_fs_info; in nilfs_construct_segment()
2270 struct nilfs_sc_info *sci = nilfs->ns_writer; in nilfs_construct_segment() local
2271 struct nilfs_transaction_info *ti; in nilfs_construct_segment() local
2274 if (sb_rdonly(sb) || unlikely(!sci)) in nilfs_construct_segment()
2275 return -EROFS; in nilfs_construct_segment()
2278 BUG_ON((ti = current->journal_info) && ti->ti_magic == NILFS_TI_MAGIC); in nilfs_construct_segment()
2280 err = nilfs_segctor_sync(sci); in nilfs_construct_segment()
2285 * nilfs_construct_dsync_segment - construct a data-only logical segment
2294 * %-EROFS - Read only filesystem.
2296 * %-EIO - I/O error
2298 * %-ENOSPC - No space left on device (only in a panic state).
2300 * %-ERESTARTSYS - Interrupted.
2302 * %-ENOMEM - Insufficient memory available.
2307 struct the_nilfs *nilfs = sb->s_fs_info; in nilfs_construct_dsync_segment()
2308 struct nilfs_sc_info *sci = nilfs->ns_writer; in nilfs_construct_dsync_segment() local
2310 struct nilfs_transaction_info ti; in nilfs_construct_dsync_segment() local
2313 if (sb_rdonly(sb) || unlikely(!sci)) in nilfs_construct_dsync_segment()
2314 return -EROFS; in nilfs_construct_dsync_segment()
2316 nilfs_transaction_lock(sb, &ti, 0); in nilfs_construct_dsync_segment()
2319 if (test_bit(NILFS_I_INODE_SYNC, &ii->i_state) || in nilfs_construct_dsync_segment()
2321 test_bit(NILFS_SC_UNCLOSED, &sci->sc_flags) || in nilfs_construct_dsync_segment()
2324 err = nilfs_segctor_sync(sci); in nilfs_construct_dsync_segment()
2328 spin_lock(&nilfs->ns_inode_lock); in nilfs_construct_dsync_segment()
2329 if (!test_bit(NILFS_I_QUEUED, &ii->i_state) && in nilfs_construct_dsync_segment()
2330 !test_bit(NILFS_I_BUSY, &ii->i_state)) { in nilfs_construct_dsync_segment()
2331 spin_unlock(&nilfs->ns_inode_lock); in nilfs_construct_dsync_segment()
2335 spin_unlock(&nilfs->ns_inode_lock); in nilfs_construct_dsync_segment()
2336 sci->sc_dsync_inode = ii; in nilfs_construct_dsync_segment()
2337 sci->sc_dsync_start = start; in nilfs_construct_dsync_segment()
2338 sci->sc_dsync_end = end; in nilfs_construct_dsync_segment()
2340 err = nilfs_segctor_do_construct(sci, SC_LSEG_DSYNC); in nilfs_construct_dsync_segment()
2342 nilfs->ns_flushed_device = 0; in nilfs_construct_dsync_segment()
2352 * nilfs_segctor_accept - record accepted sequence count of log-write requests
2353 * @sci: segment constructor object
2355 static void nilfs_segctor_accept(struct nilfs_sc_info *sci) in nilfs_segctor_accept() argument
2357 spin_lock(&sci->sc_state_lock); in nilfs_segctor_accept()
2358 sci->sc_seq_accepted = sci->sc_seq_request; in nilfs_segctor_accept()
2359 spin_unlock(&sci->sc_state_lock); in nilfs_segctor_accept()
2360 del_timer_sync(&sci->sc_timer); in nilfs_segctor_accept()
2364 * nilfs_segctor_notify - notify the result of request to caller threads
2365 * @sci: segment constructor object
2369 static void nilfs_segctor_notify(struct nilfs_sc_info *sci, int mode, int err) in nilfs_segctor_notify() argument
2372 spin_lock(&sci->sc_state_lock); in nilfs_segctor_notify()
2375 sci->sc_state &= ~NILFS_SEGCTOR_COMMIT; in nilfs_segctor_notify()
2376 sci->sc_seq_done = sci->sc_seq_accepted; in nilfs_segctor_notify()
2377 nilfs_segctor_wakeup(sci, err); in nilfs_segctor_notify()
2378 sci->sc_flush_request = 0; in nilfs_segctor_notify()
2381 sci->sc_flush_request &= ~FLUSH_FILE_BIT; in nilfs_segctor_notify()
2383 sci->sc_flush_request &= ~FLUSH_DAT_BIT; in nilfs_segctor_notify()
2385 /* re-enable timer if checkpoint creation was not done */ in nilfs_segctor_notify()
2386 if ((sci->sc_state & NILFS_SEGCTOR_COMMIT) && in nilfs_segctor_notify()
2387 time_before(jiffies, sci->sc_timer.expires)) in nilfs_segctor_notify()
2388 add_timer(&sci->sc_timer); in nilfs_segctor_notify()
2390 spin_unlock(&sci->sc_state_lock); in nilfs_segctor_notify()
2394 * nilfs_segctor_construct - form logs and write them to disk
2395 * @sci: segment constructor object
2398 static int nilfs_segctor_construct(struct nilfs_sc_info *sci, int mode) in nilfs_segctor_construct() argument
2400 struct the_nilfs *nilfs = sci->sc_super->s_fs_info; in nilfs_segctor_construct()
2404 nilfs_segctor_accept(sci); in nilfs_segctor_construct()
2408 if (!nilfs_segctor_confirm(sci)) in nilfs_segctor_construct()
2409 err = nilfs_segctor_do_construct(sci, mode); in nilfs_segctor_construct()
2413 atomic_set(&nilfs->ns_ndirtyblks, 0); in nilfs_segctor_construct()
2414 if (test_bit(NILFS_SC_SUPER_ROOT, &sci->sc_flags) && in nilfs_segctor_construct()
2416 down_write(&nilfs->ns_sem); in nilfs_segctor_construct()
2417 err = -EIO; in nilfs_segctor_construct()
2418 sbp = nilfs_prepare_super(sci->sc_super, in nilfs_segctor_construct()
2422 err = nilfs_commit_super(sci->sc_super, in nilfs_segctor_construct()
2425 up_write(&nilfs->ns_sem); in nilfs_segctor_construct()
2429 nilfs_segctor_notify(sci, mode, err); in nilfs_segctor_construct()
2435 struct nilfs_sc_info *sci = from_timer(sci, t, sc_timer); in nilfs_construction_timeout() local
2437 wake_up_process(sci->sc_timer_task); in nilfs_construction_timeout()
2446 if (!test_bit(NILFS_I_UPDATED, &ii->i_state)) in nilfs_remove_written_gcinodes()
2448 list_del_init(&ii->i_dirty); in nilfs_remove_written_gcinodes()
2449 truncate_inode_pages(&ii->vfs_inode.i_data, 0); in nilfs_remove_written_gcinodes()
2450 nilfs_btnode_cache_clear(ii->i_assoc_inode->i_mapping); in nilfs_remove_written_gcinodes()
2451 iput(&ii->vfs_inode); in nilfs_remove_written_gcinodes()
2458 struct the_nilfs *nilfs = sb->s_fs_info; in nilfs_clean_segments()
2459 struct nilfs_sc_info *sci = nilfs->ns_writer; in nilfs_clean_segments() local
2460 struct nilfs_transaction_info ti; in nilfs_clean_segments() local
2463 if (unlikely(!sci)) in nilfs_clean_segments()
2464 return -EROFS; in nilfs_clean_segments()
2466 nilfs_transaction_lock(sb, &ti, 1); in nilfs_clean_segments()
2468 err = nilfs_mdt_save_to_shadow_map(nilfs->ns_dat); in nilfs_clean_segments()
2474 nilfs_mdt_restore_from_shadow_map(nilfs->ns_dat); in nilfs_clean_segments()
2478 sci->sc_freesegs = kbufs[4]; in nilfs_clean_segments()
2479 sci->sc_nfreesegs = argv[4].v_nmembs; in nilfs_clean_segments()
2480 list_splice_tail_init(&nilfs->ns_gc_inodes, &sci->sc_gc_inodes); in nilfs_clean_segments()
2483 err = nilfs_segctor_construct(sci, SC_LSEG_SR); in nilfs_clean_segments()
2484 nilfs_remove_written_gcinodes(nilfs, &sci->sc_gc_inodes); in nilfs_clean_segments()
2491 schedule_timeout(sci->sc_interval); in nilfs_clean_segments()
2494 int ret = nilfs_discard_segments(nilfs, sci->sc_freesegs, in nilfs_clean_segments()
2495 sci->sc_nfreesegs); in nilfs_clean_segments()
2505 sci->sc_freesegs = NULL; in nilfs_clean_segments()
2506 sci->sc_nfreesegs = 0; in nilfs_clean_segments()
2507 nilfs_mdt_clear_shadow_map(nilfs->ns_dat); in nilfs_clean_segments()
2512 static void nilfs_segctor_thread_construct(struct nilfs_sc_info *sci, int mode) in nilfs_segctor_thread_construct() argument
2514 struct nilfs_transaction_info ti; in nilfs_segctor_thread_construct() local
2516 nilfs_transaction_lock(sci->sc_super, &ti, 0); in nilfs_segctor_thread_construct()
2517 nilfs_segctor_construct(sci, mode); in nilfs_segctor_thread_construct()
2524 if (test_bit(NILFS_SC_UNCLOSED, &sci->sc_flags)) in nilfs_segctor_thread_construct()
2525 nilfs_segctor_start_timer(sci); in nilfs_segctor_thread_construct()
2527 nilfs_transaction_unlock(sci->sc_super); in nilfs_segctor_thread_construct()
2530 static void nilfs_segctor_do_immediate_flush(struct nilfs_sc_info *sci) in nilfs_segctor_do_immediate_flush() argument
2534 spin_lock(&sci->sc_state_lock); in nilfs_segctor_do_immediate_flush()
2535 mode = (sci->sc_flush_request & FLUSH_DAT_BIT) ? in nilfs_segctor_do_immediate_flush()
2537 spin_unlock(&sci->sc_state_lock); in nilfs_segctor_do_immediate_flush()
2540 nilfs_segctor_do_construct(sci, mode); in nilfs_segctor_do_immediate_flush()
2542 spin_lock(&sci->sc_state_lock); in nilfs_segctor_do_immediate_flush()
2543 sci->sc_flush_request &= (mode == SC_FLUSH_FILE) ? in nilfs_segctor_do_immediate_flush()
2545 spin_unlock(&sci->sc_state_lock); in nilfs_segctor_do_immediate_flush()
2547 clear_bit(NILFS_SC_PRIOR_FLUSH, &sci->sc_flags); in nilfs_segctor_do_immediate_flush()
2550 static int nilfs_segctor_flush_mode(struct nilfs_sc_info *sci) in nilfs_segctor_flush_mode() argument
2552 if (!test_bit(NILFS_SC_UNCLOSED, &sci->sc_flags) || in nilfs_segctor_flush_mode()
2553 time_before(jiffies, sci->sc_lseg_stime + sci->sc_mjcp_freq)) { in nilfs_segctor_flush_mode()
2554 if (!(sci->sc_flush_request & ~FLUSH_FILE_BIT)) in nilfs_segctor_flush_mode()
2556 else if (!(sci->sc_flush_request & ~FLUSH_DAT_BIT)) in nilfs_segctor_flush_mode()
2563 * nilfs_segctor_thread - main loop of the segment constructor thread.
2571 struct nilfs_sc_info *sci = (struct nilfs_sc_info *)arg; in nilfs_segctor_thread() local
2572 struct the_nilfs *nilfs = sci->sc_super->s_fs_info; in nilfs_segctor_thread()
2575 sci->sc_timer_task = current; in nilfs_segctor_thread()
2578 sci->sc_task = current; in nilfs_segctor_thread()
2579 wake_up(&sci->sc_wait_task); /* for nilfs_segctor_start_thread() */ in nilfs_segctor_thread()
2580 nilfs_info(sci->sc_super, in nilfs_segctor_thread()
2582 sci->sc_interval / HZ, sci->sc_mjcp_freq / HZ); in nilfs_segctor_thread()
2584 spin_lock(&sci->sc_state_lock); in nilfs_segctor_thread()
2589 if (sci->sc_state & NILFS_SEGCTOR_QUIT) in nilfs_segctor_thread()
2592 if (timeout || sci->sc_seq_request != sci->sc_seq_done) in nilfs_segctor_thread()
2594 else if (sci->sc_flush_request) in nilfs_segctor_thread()
2595 mode = nilfs_segctor_flush_mode(sci); in nilfs_segctor_thread()
2599 spin_unlock(&sci->sc_state_lock); in nilfs_segctor_thread()
2600 nilfs_segctor_thread_construct(sci, mode); in nilfs_segctor_thread()
2601 spin_lock(&sci->sc_state_lock); in nilfs_segctor_thread()
2607 spin_unlock(&sci->sc_state_lock); in nilfs_segctor_thread()
2609 spin_lock(&sci->sc_state_lock); in nilfs_segctor_thread()
2614 prepare_to_wait(&sci->sc_wait_daemon, &wait, in nilfs_segctor_thread()
2617 if (sci->sc_seq_request != sci->sc_seq_done) in nilfs_segctor_thread()
2619 else if (sci->sc_flush_request) in nilfs_segctor_thread()
2621 else if (sci->sc_state & NILFS_SEGCTOR_COMMIT) in nilfs_segctor_thread()
2623 sci->sc_timer.expires); in nilfs_segctor_thread()
2626 spin_unlock(&sci->sc_state_lock); in nilfs_segctor_thread()
2628 spin_lock(&sci->sc_state_lock); in nilfs_segctor_thread()
2630 finish_wait(&sci->sc_wait_daemon, &wait); in nilfs_segctor_thread()
2631 timeout = ((sci->sc_state & NILFS_SEGCTOR_COMMIT) && in nilfs_segctor_thread()
2632 time_after_eq(jiffies, sci->sc_timer.expires)); in nilfs_segctor_thread()
2641 sci->sc_task = NULL; in nilfs_segctor_thread()
2642 wake_up(&sci->sc_wait_task); /* for nilfs_segctor_kill_thread() */ in nilfs_segctor_thread()
2643 spin_unlock(&sci->sc_state_lock); in nilfs_segctor_thread()
2647 static int nilfs_segctor_start_thread(struct nilfs_sc_info *sci) in nilfs_segctor_start_thread() argument
2651 t = kthread_run(nilfs_segctor_thread, sci, "segctord"); in nilfs_segctor_start_thread()
2655 nilfs_err(sci->sc_super, "error %d creating segctord thread", in nilfs_segctor_start_thread()
2659 wait_event(sci->sc_wait_task, sci->sc_task != NULL); in nilfs_segctor_start_thread()
2663 static void nilfs_segctor_kill_thread(struct nilfs_sc_info *sci) in nilfs_segctor_kill_thread() argument
2664 __acquires(&sci->sc_state_lock) in nilfs_segctor_kill_thread()
2665 __releases(&sci->sc_state_lock) in nilfs_segctor_kill_thread()
2667 sci->sc_state |= NILFS_SEGCTOR_QUIT; in nilfs_segctor_kill_thread()
2669 while (sci->sc_task) { in nilfs_segctor_kill_thread()
2670 wake_up(&sci->sc_wait_daemon); in nilfs_segctor_kill_thread()
2671 spin_unlock(&sci->sc_state_lock); in nilfs_segctor_kill_thread()
2672 wait_event(sci->sc_wait_task, sci->sc_task == NULL); in nilfs_segctor_kill_thread()
2673 spin_lock(&sci->sc_state_lock); in nilfs_segctor_kill_thread()
2678 * Setup & clean-up functions
2683 struct the_nilfs *nilfs = sb->s_fs_info; in nilfs_segctor_new()
2684 struct nilfs_sc_info *sci; in nilfs_segctor_new() local
2686 sci = kzalloc(sizeof(*sci), GFP_KERNEL); in nilfs_segctor_new()
2687 if (!sci) in nilfs_segctor_new()
2690 sci->sc_super = sb; in nilfs_segctor_new()
2693 sci->sc_root = root; in nilfs_segctor_new()
2695 init_waitqueue_head(&sci->sc_wait_request); in nilfs_segctor_new()
2696 init_waitqueue_head(&sci->sc_wait_daemon); in nilfs_segctor_new()
2697 init_waitqueue_head(&sci->sc_wait_task); in nilfs_segctor_new()
2698 spin_lock_init(&sci->sc_state_lock); in nilfs_segctor_new()
2699 INIT_LIST_HEAD(&sci->sc_dirty_files); in nilfs_segctor_new()
2700 INIT_LIST_HEAD(&sci->sc_segbufs); in nilfs_segctor_new()
2701 INIT_LIST_HEAD(&sci->sc_write_logs); in nilfs_segctor_new()
2702 INIT_LIST_HEAD(&sci->sc_gc_inodes); in nilfs_segctor_new()
2703 INIT_LIST_HEAD(&sci->sc_iput_queue); in nilfs_segctor_new()
2704 INIT_WORK(&sci->sc_iput_work, nilfs_iput_work_func); in nilfs_segctor_new()
2705 timer_setup(&sci->sc_timer, nilfs_construction_timeout, 0); in nilfs_segctor_new()
2707 sci->sc_interval = HZ * NILFS_SC_DEFAULT_TIMEOUT; in nilfs_segctor_new()
2708 sci->sc_mjcp_freq = HZ * NILFS_SC_DEFAULT_SR_FREQ; in nilfs_segctor_new()
2709 sci->sc_watermark = NILFS_SC_DEFAULT_WATERMARK; in nilfs_segctor_new()
2711 if (nilfs->ns_interval) in nilfs_segctor_new()
2712 sci->sc_interval = HZ * nilfs->ns_interval; in nilfs_segctor_new()
2713 if (nilfs->ns_watermark) in nilfs_segctor_new()
2714 sci->sc_watermark = nilfs->ns_watermark; in nilfs_segctor_new()
2715 return sci; in nilfs_segctor_new()
2718 static void nilfs_segctor_write_out(struct nilfs_sc_info *sci) in nilfs_segctor_write_out() argument
2727 struct nilfs_transaction_info ti; in nilfs_segctor_write_out() local
2729 nilfs_transaction_lock(sci->sc_super, &ti, 0); in nilfs_segctor_write_out()
2730 ret = nilfs_segctor_construct(sci, SC_LSEG_SR); in nilfs_segctor_write_out()
2731 nilfs_transaction_unlock(sci->sc_super); in nilfs_segctor_write_out()
2733 flush_work(&sci->sc_iput_work); in nilfs_segctor_write_out()
2735 } while (ret && ret != -EROFS && retrycount-- > 0); in nilfs_segctor_write_out()
2739 * nilfs_segctor_destroy - destroy the segment constructor.
2740 * @sci: nilfs_sc_info
2746 static void nilfs_segctor_destroy(struct nilfs_sc_info *sci) in nilfs_segctor_destroy() argument
2748 struct the_nilfs *nilfs = sci->sc_super->s_fs_info; in nilfs_segctor_destroy()
2751 up_write(&nilfs->ns_segctor_sem); in nilfs_segctor_destroy()
2753 spin_lock(&sci->sc_state_lock); in nilfs_segctor_destroy()
2754 nilfs_segctor_kill_thread(sci); in nilfs_segctor_destroy()
2755 flag = ((sci->sc_state & NILFS_SEGCTOR_COMMIT) || sci->sc_flush_request in nilfs_segctor_destroy()
2756 || sci->sc_seq_request != sci->sc_seq_done); in nilfs_segctor_destroy()
2757 spin_unlock(&sci->sc_state_lock); in nilfs_segctor_destroy()
2759 if (flush_work(&sci->sc_iput_work)) in nilfs_segctor_destroy()
2762 if (flag || !nilfs_segctor_confirm(sci)) in nilfs_segctor_destroy()
2763 nilfs_segctor_write_out(sci); in nilfs_segctor_destroy()
2765 if (!list_empty(&sci->sc_dirty_files)) { in nilfs_segctor_destroy()
2766 nilfs_warn(sci->sc_super, in nilfs_segctor_destroy()
2768 nilfs_dispose_list(nilfs, &sci->sc_dirty_files, 1); in nilfs_segctor_destroy()
2771 if (!list_empty(&sci->sc_iput_queue)) { in nilfs_segctor_destroy()
2772 nilfs_warn(sci->sc_super, in nilfs_segctor_destroy()
2774 nilfs_dispose_list(nilfs, &sci->sc_iput_queue, 1); in nilfs_segctor_destroy()
2777 WARN_ON(!list_empty(&sci->sc_segbufs)); in nilfs_segctor_destroy()
2778 WARN_ON(!list_empty(&sci->sc_write_logs)); in nilfs_segctor_destroy()
2780 nilfs_put_root(sci->sc_root); in nilfs_segctor_destroy()
2782 down_write(&nilfs->ns_segctor_sem); in nilfs_segctor_destroy()
2784 del_timer_sync(&sci->sc_timer); in nilfs_segctor_destroy()
2785 kfree(sci); in nilfs_segctor_destroy()
2789 * nilfs_attach_log_writer - attach log writer
2799 * %-ENOMEM - Insufficient memory available.
2803 struct the_nilfs *nilfs = sb->s_fs_info; in nilfs_attach_log_writer()
2806 if (nilfs->ns_writer) { in nilfs_attach_log_writer()
2808 * This happens if the filesystem is made read-only by in nilfs_attach_log_writer()
2816 nilfs->ns_writer = nilfs_segctor_new(sb, root); in nilfs_attach_log_writer()
2817 if (!nilfs->ns_writer) in nilfs_attach_log_writer()
2818 return -ENOMEM; in nilfs_attach_log_writer()
2820 inode_attach_wb(nilfs->ns_bdev->bd_inode, NULL); in nilfs_attach_log_writer()
2822 err = nilfs_segctor_start_thread(nilfs->ns_writer); in nilfs_attach_log_writer()
2830 * nilfs_detach_log_writer - destroy log writer
2838 struct the_nilfs *nilfs = sb->s_fs_info; in nilfs_detach_log_writer()
2841 down_write(&nilfs->ns_segctor_sem); in nilfs_detach_log_writer()
2842 if (nilfs->ns_writer) { in nilfs_detach_log_writer()
2843 nilfs_segctor_destroy(nilfs->ns_writer); in nilfs_detach_log_writer()
2844 nilfs->ns_writer = NULL; in nilfs_detach_log_writer()
2848 spin_lock(&nilfs->ns_inode_lock); in nilfs_detach_log_writer()
2849 if (!list_empty(&nilfs->ns_dirty_files)) { in nilfs_detach_log_writer()
2850 list_splice_init(&nilfs->ns_dirty_files, &garbage_list); in nilfs_detach_log_writer()
2854 spin_unlock(&nilfs->ns_inode_lock); in nilfs_detach_log_writer()
2855 up_write(&nilfs->ns_segctor_sem); in nilfs_detach_log_writer()