2 * segment.c - NILFS segment constructor.
4 * Copyright (C) 2005-2008 Nippon Telegraph and Telephone Corporation.
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
20 * Written by Ryusuke Konishi <ryusuke@osrg.net>
24 #include <linux/pagemap.h>
25 #include <linux/buffer_head.h>
26 #include <linux/writeback.h>
27 #include <linux/bio.h>
28 #include <linux/completion.h>
29 #include <linux/blkdev.h>
30 #include <linux/backing-dev.h>
31 #include <linux/freezer.h>
32 #include <linux/kthread.h>
33 #include <linux/crc32.h>
34 #include <linux/pagevec.h>
35 #include <linux/slab.h>
49 #define SC_N_INODEVEC 16 /* Size of locally allocated inode vector */
51 #define SC_MAX_SEGDELTA 64 /* Upper limit of the number of segments
52 appended in collection retry loop */
54 /* Construction mode */
56 SC_LSEG_SR
= 1, /* Make a logical segment having a super root */
57 SC_LSEG_DSYNC
, /* Flush data blocks of a given file and make
58 a logical segment without a super root */
59 SC_FLUSH_FILE
, /* Flush data files, leads to segment writes without
60 creating a checkpoint */
61 SC_FLUSH_DAT
, /* Flush DAT file. This also creates segments without
65 /* Stage numbers of dirty block collection */
68 NILFS_ST_GC
, /* Collecting dirty blocks for GC */
74 NILFS_ST_SR
, /* Super root */
75 NILFS_ST_DSYNC
, /* Data sync blocks */
79 /* State flags of collection */
80 #define NILFS_CF_NODE 0x0001 /* Collecting node blocks */
81 #define NILFS_CF_IFILE_STARTED 0x0002 /* IFILE stage has started */
82 #define NILFS_CF_SUFREED 0x0004 /* segment usages has been freed */
83 #define NILFS_CF_HISTORY_MASK (NILFS_CF_IFILE_STARTED | NILFS_CF_SUFREED)
85 /* Operations depending on the construction mode and file type */
86 struct nilfs_sc_operations
{
87 int (*collect_data
)(struct nilfs_sc_info
*, struct buffer_head
*,
89 int (*collect_node
)(struct nilfs_sc_info
*, struct buffer_head
*,
91 int (*collect_bmap
)(struct nilfs_sc_info
*, struct buffer_head
*,
93 void (*write_data_binfo
)(struct nilfs_sc_info
*,
94 struct nilfs_segsum_pointer
*,
96 void (*write_node_binfo
)(struct nilfs_sc_info
*,
97 struct nilfs_segsum_pointer
*,
104 static void nilfs_segctor_start_timer(struct nilfs_sc_info
*);
105 static void nilfs_segctor_do_flush(struct nilfs_sc_info
*, int);
106 static void nilfs_segctor_do_immediate_flush(struct nilfs_sc_info
*);
107 static void nilfs_dispose_list(struct the_nilfs
*, struct list_head
*, int);
109 #define nilfs_cnt32_gt(a, b) \
110 (typecheck(__u32, a) && typecheck(__u32, b) && \
111 ((__s32)(b) - (__s32)(a) < 0))
112 #define nilfs_cnt32_ge(a, b) \
113 (typecheck(__u32, a) && typecheck(__u32, b) && \
114 ((__s32)(a) - (__s32)(b) >= 0))
115 #define nilfs_cnt32_lt(a, b) nilfs_cnt32_gt(b, a)
116 #define nilfs_cnt32_le(a, b) nilfs_cnt32_ge(b, a)
118 static int nilfs_prepare_segment_lock(struct nilfs_transaction_info
*ti
)
120 struct nilfs_transaction_info
*cur_ti
= current
->journal_info
;
124 if (cur_ti
->ti_magic
== NILFS_TI_MAGIC
)
125 return ++cur_ti
->ti_count
;
128 * If journal_info field is occupied by other FS,
129 * it is saved and will be restored on
130 * nilfs_transaction_commit().
133 "NILFS warning: journal info from a different "
135 save
= current
->journal_info
;
139 ti
= kmem_cache_alloc(nilfs_transaction_cachep
, GFP_NOFS
);
142 ti
->ti_flags
= NILFS_TI_DYNAMIC_ALLOC
;
148 ti
->ti_magic
= NILFS_TI_MAGIC
;
149 current
->journal_info
= ti
;
154 * nilfs_transaction_begin - start indivisible file operations.
156 * @ti: nilfs_transaction_info
157 * @vacancy_check: flags for vacancy rate checks
159 * nilfs_transaction_begin() acquires a reader/writer semaphore, called
160 * the segment semaphore, to make a segment construction and write tasks
161 * exclusive. The function is used with nilfs_transaction_commit() in pairs.
162 * The region enclosed by these two functions can be nested. To avoid a
163 * deadlock, the semaphore is only acquired or released in the outermost call.
165 * This function allocates a nilfs_transaction_info struct to keep context
166 * information on it. It is initialized and hooked onto the current task in
167 * the outermost call. If a pre-allocated struct is given to @ti, it is used
168 * instead; otherwise a new struct is assigned from a slab.
170 * When @vacancy_check flag is set, this function will check the amount of
171 * free space, and will wait for the GC to reclaim disk space if low capacity.
173 * Return Value: On success, 0 is returned. On error, one of the following
174 * negative error code is returned.
176 * %-ENOMEM - Insufficient memory available.
178 * %-ENOSPC - No space left on device
180 int nilfs_transaction_begin(struct super_block
*sb
,
181 struct nilfs_transaction_info
*ti
,
184 struct the_nilfs
*nilfs
;
185 int ret
= nilfs_prepare_segment_lock(ti
);
187 if (unlikely(ret
< 0))
192 sb_start_intwrite(sb
);
194 nilfs
= sb
->s_fs_info
;
195 down_read(&nilfs
->ns_segctor_sem
);
196 if (vacancy_check
&& nilfs_near_disk_full(nilfs
)) {
197 up_read(&nilfs
->ns_segctor_sem
);
204 ti
= current
->journal_info
;
205 current
->journal_info
= ti
->ti_save
;
206 if (ti
->ti_flags
& NILFS_TI_DYNAMIC_ALLOC
)
207 kmem_cache_free(nilfs_transaction_cachep
, ti
);
213 * nilfs_transaction_commit - commit indivisible file operations.
216 * nilfs_transaction_commit() releases the read semaphore which is
217 * acquired by nilfs_transaction_begin(). This is only performed
218 * in outermost call of this function. If a commit flag is set,
219 * nilfs_transaction_commit() sets a timer to start the segment
220 * constructor. If a sync flag is set, it starts construction
223 int nilfs_transaction_commit(struct super_block
*sb
)
225 struct nilfs_transaction_info
*ti
= current
->journal_info
;
226 struct the_nilfs
*nilfs
= sb
->s_fs_info
;
229 BUG_ON(ti
== NULL
|| ti
->ti_magic
!= NILFS_TI_MAGIC
);
230 ti
->ti_flags
|= NILFS_TI_COMMIT
;
231 if (ti
->ti_count
> 0) {
235 if (nilfs
->ns_writer
) {
236 struct nilfs_sc_info
*sci
= nilfs
->ns_writer
;
238 if (ti
->ti_flags
& NILFS_TI_COMMIT
)
239 nilfs_segctor_start_timer(sci
);
240 if (atomic_read(&nilfs
->ns_ndirtyblks
) > sci
->sc_watermark
)
241 nilfs_segctor_do_flush(sci
, 0);
243 up_read(&nilfs
->ns_segctor_sem
);
244 current
->journal_info
= ti
->ti_save
;
246 if (ti
->ti_flags
& NILFS_TI_SYNC
)
247 err
= nilfs_construct_segment(sb
);
248 if (ti
->ti_flags
& NILFS_TI_DYNAMIC_ALLOC
)
249 kmem_cache_free(nilfs_transaction_cachep
, ti
);
254 void nilfs_transaction_abort(struct super_block
*sb
)
256 struct nilfs_transaction_info
*ti
= current
->journal_info
;
257 struct the_nilfs
*nilfs
= sb
->s_fs_info
;
259 BUG_ON(ti
== NULL
|| ti
->ti_magic
!= NILFS_TI_MAGIC
);
260 if (ti
->ti_count
> 0) {
264 up_read(&nilfs
->ns_segctor_sem
);
266 current
->journal_info
= ti
->ti_save
;
267 if (ti
->ti_flags
& NILFS_TI_DYNAMIC_ALLOC
)
268 kmem_cache_free(nilfs_transaction_cachep
, ti
);
272 void nilfs_relax_pressure_in_lock(struct super_block
*sb
)
274 struct the_nilfs
*nilfs
= sb
->s_fs_info
;
275 struct nilfs_sc_info
*sci
= nilfs
->ns_writer
;
277 if (!sci
|| !sci
->sc_flush_request
)
280 set_bit(NILFS_SC_PRIOR_FLUSH
, &sci
->sc_flags
);
281 up_read(&nilfs
->ns_segctor_sem
);
283 down_write(&nilfs
->ns_segctor_sem
);
284 if (sci
->sc_flush_request
&&
285 test_bit(NILFS_SC_PRIOR_FLUSH
, &sci
->sc_flags
)) {
286 struct nilfs_transaction_info
*ti
= current
->journal_info
;
288 ti
->ti_flags
|= NILFS_TI_WRITER
;
289 nilfs_segctor_do_immediate_flush(sci
);
290 ti
->ti_flags
&= ~NILFS_TI_WRITER
;
292 downgrade_write(&nilfs
->ns_segctor_sem
);
295 static void nilfs_transaction_lock(struct super_block
*sb
,
296 struct nilfs_transaction_info
*ti
,
299 struct nilfs_transaction_info
*cur_ti
= current
->journal_info
;
300 struct the_nilfs
*nilfs
= sb
->s_fs_info
;
301 struct nilfs_sc_info
*sci
= nilfs
->ns_writer
;
304 ti
->ti_flags
= NILFS_TI_WRITER
;
306 ti
->ti_save
= cur_ti
;
307 ti
->ti_magic
= NILFS_TI_MAGIC
;
308 INIT_LIST_HEAD(&ti
->ti_garbage
);
309 current
->journal_info
= ti
;
312 down_write(&nilfs
->ns_segctor_sem
);
313 if (!test_bit(NILFS_SC_PRIOR_FLUSH
, &sci
->sc_flags
))
316 nilfs_segctor_do_immediate_flush(sci
);
318 up_write(&nilfs
->ns_segctor_sem
);
322 ti
->ti_flags
|= NILFS_TI_GC
;
325 static void nilfs_transaction_unlock(struct super_block
*sb
)
327 struct nilfs_transaction_info
*ti
= current
->journal_info
;
328 struct the_nilfs
*nilfs
= sb
->s_fs_info
;
330 BUG_ON(ti
== NULL
|| ti
->ti_magic
!= NILFS_TI_MAGIC
);
331 BUG_ON(ti
->ti_count
> 0);
333 up_write(&nilfs
->ns_segctor_sem
);
334 current
->journal_info
= ti
->ti_save
;
335 if (!list_empty(&ti
->ti_garbage
))
336 nilfs_dispose_list(nilfs
, &ti
->ti_garbage
, 0);
339 static void *nilfs_segctor_map_segsum_entry(struct nilfs_sc_info
*sci
,
340 struct nilfs_segsum_pointer
*ssp
,
343 struct nilfs_segment_buffer
*segbuf
= sci
->sc_curseg
;
344 unsigned blocksize
= sci
->sc_super
->s_blocksize
;
347 if (unlikely(ssp
->offset
+ bytes
> blocksize
)) {
349 BUG_ON(NILFS_SEGBUF_BH_IS_LAST(ssp
->bh
,
350 &segbuf
->sb_segsum_buffers
));
351 ssp
->bh
= NILFS_SEGBUF_NEXT_BH(ssp
->bh
);
353 p
= ssp
->bh
->b_data
+ ssp
->offset
;
354 ssp
->offset
+= bytes
;
359 * nilfs_segctor_reset_segment_buffer - reset the current segment buffer
360 * @sci: nilfs_sc_info
362 static int nilfs_segctor_reset_segment_buffer(struct nilfs_sc_info
*sci
)
364 struct nilfs_segment_buffer
*segbuf
= sci
->sc_curseg
;
365 struct buffer_head
*sumbh
;
370 if (nilfs_doing_gc())
372 err
= nilfs_segbuf_reset(segbuf
, flags
, sci
->sc_seg_ctime
, sci
->sc_cno
);
376 sumbh
= NILFS_SEGBUF_FIRST_BH(&segbuf
->sb_segsum_buffers
);
377 sumbytes
= segbuf
->sb_sum
.sumbytes
;
378 sci
->sc_finfo_ptr
.bh
= sumbh
; sci
->sc_finfo_ptr
.offset
= sumbytes
;
379 sci
->sc_binfo_ptr
.bh
= sumbh
; sci
->sc_binfo_ptr
.offset
= sumbytes
;
380 sci
->sc_blk_cnt
= sci
->sc_datablk_cnt
= 0;
384 static int nilfs_segctor_feed_segment(struct nilfs_sc_info
*sci
)
386 sci
->sc_nblk_this_inc
+= sci
->sc_curseg
->sb_sum
.nblocks
;
387 if (NILFS_SEGBUF_IS_LAST(sci
->sc_curseg
, &sci
->sc_segbufs
))
388 return -E2BIG
; /* The current segment is filled up
390 sci
->sc_curseg
= NILFS_NEXT_SEGBUF(sci
->sc_curseg
);
391 return nilfs_segctor_reset_segment_buffer(sci
);
394 static int nilfs_segctor_add_super_root(struct nilfs_sc_info
*sci
)
396 struct nilfs_segment_buffer
*segbuf
= sci
->sc_curseg
;
399 if (segbuf
->sb_sum
.nblocks
>= segbuf
->sb_rest_blocks
) {
400 err
= nilfs_segctor_feed_segment(sci
);
403 segbuf
= sci
->sc_curseg
;
405 err
= nilfs_segbuf_extend_payload(segbuf
, &segbuf
->sb_super_root
);
407 segbuf
->sb_sum
.flags
|= NILFS_SS_SR
;
412 * Functions for making segment summary and payloads
414 static int nilfs_segctor_segsum_block_required(
415 struct nilfs_sc_info
*sci
, const struct nilfs_segsum_pointer
*ssp
,
418 unsigned blocksize
= sci
->sc_super
->s_blocksize
;
419 /* Size of finfo and binfo is enough small against blocksize */
421 return ssp
->offset
+ binfo_size
+
422 (!sci
->sc_blk_cnt
? sizeof(struct nilfs_finfo
) : 0) >
426 static void nilfs_segctor_begin_finfo(struct nilfs_sc_info
*sci
,
429 sci
->sc_curseg
->sb_sum
.nfinfo
++;
430 sci
->sc_binfo_ptr
= sci
->sc_finfo_ptr
;
431 nilfs_segctor_map_segsum_entry(
432 sci
, &sci
->sc_binfo_ptr
, sizeof(struct nilfs_finfo
));
434 if (NILFS_I(inode
)->i_root
&&
435 !test_bit(NILFS_SC_HAVE_DELTA
, &sci
->sc_flags
))
436 set_bit(NILFS_SC_HAVE_DELTA
, &sci
->sc_flags
);
440 static void nilfs_segctor_end_finfo(struct nilfs_sc_info
*sci
,
443 struct nilfs_finfo
*finfo
;
444 struct nilfs_inode_info
*ii
;
445 struct nilfs_segment_buffer
*segbuf
;
448 if (sci
->sc_blk_cnt
== 0)
453 if (test_bit(NILFS_I_GCINODE
, &ii
->i_state
))
455 else if (NILFS_ROOT_METADATA_FILE(inode
->i_ino
))
460 finfo
= nilfs_segctor_map_segsum_entry(sci
, &sci
->sc_finfo_ptr
,
462 finfo
->fi_ino
= cpu_to_le64(inode
->i_ino
);
463 finfo
->fi_nblocks
= cpu_to_le32(sci
->sc_blk_cnt
);
464 finfo
->fi_ndatablk
= cpu_to_le32(sci
->sc_datablk_cnt
);
465 finfo
->fi_cno
= cpu_to_le64(cno
);
467 segbuf
= sci
->sc_curseg
;
468 segbuf
->sb_sum
.sumbytes
= sci
->sc_binfo_ptr
.offset
+
469 sci
->sc_super
->s_blocksize
* (segbuf
->sb_sum
.nsumblk
- 1);
470 sci
->sc_finfo_ptr
= sci
->sc_binfo_ptr
;
471 sci
->sc_blk_cnt
= sci
->sc_datablk_cnt
= 0;
474 static int nilfs_segctor_add_file_block(struct nilfs_sc_info
*sci
,
475 struct buffer_head
*bh
,
479 struct nilfs_segment_buffer
*segbuf
;
480 int required
, err
= 0;
483 segbuf
= sci
->sc_curseg
;
484 required
= nilfs_segctor_segsum_block_required(
485 sci
, &sci
->sc_binfo_ptr
, binfo_size
);
486 if (segbuf
->sb_sum
.nblocks
+ required
+ 1 > segbuf
->sb_rest_blocks
) {
487 nilfs_segctor_end_finfo(sci
, inode
);
488 err
= nilfs_segctor_feed_segment(sci
);
493 if (unlikely(required
)) {
494 err
= nilfs_segbuf_extend_segsum(segbuf
);
498 if (sci
->sc_blk_cnt
== 0)
499 nilfs_segctor_begin_finfo(sci
, inode
);
501 nilfs_segctor_map_segsum_entry(sci
, &sci
->sc_binfo_ptr
, binfo_size
);
502 /* Substitution to vblocknr is delayed until update_blocknr() */
503 nilfs_segbuf_add_file_buffer(segbuf
, bh
);
510 * Callback functions that enumerate, mark, and collect dirty blocks
512 static int nilfs_collect_file_data(struct nilfs_sc_info
*sci
,
513 struct buffer_head
*bh
, struct inode
*inode
)
517 err
= nilfs_bmap_propagate(NILFS_I(inode
)->i_bmap
, bh
);
521 err
= nilfs_segctor_add_file_block(sci
, bh
, inode
,
522 sizeof(struct nilfs_binfo_v
));
524 sci
->sc_datablk_cnt
++;
528 static int nilfs_collect_file_node(struct nilfs_sc_info
*sci
,
529 struct buffer_head
*bh
,
532 return nilfs_bmap_propagate(NILFS_I(inode
)->i_bmap
, bh
);
535 static int nilfs_collect_file_bmap(struct nilfs_sc_info
*sci
,
536 struct buffer_head
*bh
,
539 WARN_ON(!buffer_dirty(bh
));
540 return nilfs_segctor_add_file_block(sci
, bh
, inode
, sizeof(__le64
));
543 static void nilfs_write_file_data_binfo(struct nilfs_sc_info
*sci
,
544 struct nilfs_segsum_pointer
*ssp
,
545 union nilfs_binfo
*binfo
)
547 struct nilfs_binfo_v
*binfo_v
= nilfs_segctor_map_segsum_entry(
548 sci
, ssp
, sizeof(*binfo_v
));
549 *binfo_v
= binfo
->bi_v
;
552 static void nilfs_write_file_node_binfo(struct nilfs_sc_info
*sci
,
553 struct nilfs_segsum_pointer
*ssp
,
554 union nilfs_binfo
*binfo
)
556 __le64
*vblocknr
= nilfs_segctor_map_segsum_entry(
557 sci
, ssp
, sizeof(*vblocknr
));
558 *vblocknr
= binfo
->bi_v
.bi_vblocknr
;
561 static struct nilfs_sc_operations nilfs_sc_file_ops
= {
562 .collect_data
= nilfs_collect_file_data
,
563 .collect_node
= nilfs_collect_file_node
,
564 .collect_bmap
= nilfs_collect_file_bmap
,
565 .write_data_binfo
= nilfs_write_file_data_binfo
,
566 .write_node_binfo
= nilfs_write_file_node_binfo
,
569 static int nilfs_collect_dat_data(struct nilfs_sc_info
*sci
,
570 struct buffer_head
*bh
, struct inode
*inode
)
574 err
= nilfs_bmap_propagate(NILFS_I(inode
)->i_bmap
, bh
);
578 err
= nilfs_segctor_add_file_block(sci
, bh
, inode
, sizeof(__le64
));
580 sci
->sc_datablk_cnt
++;
584 static int nilfs_collect_dat_bmap(struct nilfs_sc_info
*sci
,
585 struct buffer_head
*bh
, struct inode
*inode
)
587 WARN_ON(!buffer_dirty(bh
));
588 return nilfs_segctor_add_file_block(sci
, bh
, inode
,
589 sizeof(struct nilfs_binfo_dat
));
592 static void nilfs_write_dat_data_binfo(struct nilfs_sc_info
*sci
,
593 struct nilfs_segsum_pointer
*ssp
,
594 union nilfs_binfo
*binfo
)
596 __le64
*blkoff
= nilfs_segctor_map_segsum_entry(sci
, ssp
,
598 *blkoff
= binfo
->bi_dat
.bi_blkoff
;
601 static void nilfs_write_dat_node_binfo(struct nilfs_sc_info
*sci
,
602 struct nilfs_segsum_pointer
*ssp
,
603 union nilfs_binfo
*binfo
)
605 struct nilfs_binfo_dat
*binfo_dat
=
606 nilfs_segctor_map_segsum_entry(sci
, ssp
, sizeof(*binfo_dat
));
607 *binfo_dat
= binfo
->bi_dat
;
610 static struct nilfs_sc_operations nilfs_sc_dat_ops
= {
611 .collect_data
= nilfs_collect_dat_data
,
612 .collect_node
= nilfs_collect_file_node
,
613 .collect_bmap
= nilfs_collect_dat_bmap
,
614 .write_data_binfo
= nilfs_write_dat_data_binfo
,
615 .write_node_binfo
= nilfs_write_dat_node_binfo
,
618 static struct nilfs_sc_operations nilfs_sc_dsync_ops
= {
619 .collect_data
= nilfs_collect_file_data
,
620 .collect_node
= NULL
,
621 .collect_bmap
= NULL
,
622 .write_data_binfo
= nilfs_write_file_data_binfo
,
623 .write_node_binfo
= NULL
,
626 static size_t nilfs_lookup_dirty_data_buffers(struct inode
*inode
,
627 struct list_head
*listp
,
629 loff_t start
, loff_t end
)
631 struct address_space
*mapping
= inode
->i_mapping
;
633 pgoff_t index
= 0, last
= ULONG_MAX
;
637 if (unlikely(start
!= 0 || end
!= LLONG_MAX
)) {
639 * A valid range is given for sync-ing data pages. The
640 * range is rounded to per-page; extra dirty buffers
641 * may be included if blocksize < pagesize.
643 index
= start
>> PAGE_SHIFT
;
644 last
= end
>> PAGE_SHIFT
;
646 pagevec_init(&pvec
, 0);
648 if (unlikely(index
> last
) ||
649 !pagevec_lookup_tag(&pvec
, mapping
, &index
, PAGECACHE_TAG_DIRTY
,
650 min_t(pgoff_t
, last
- index
,
651 PAGEVEC_SIZE
- 1) + 1))
654 for (i
= 0; i
< pagevec_count(&pvec
); i
++) {
655 struct buffer_head
*bh
, *head
;
656 struct page
*page
= pvec
.pages
[i
];
658 if (unlikely(page
->index
> last
))
662 if (!page_has_buffers(page
))
663 create_empty_buffers(page
, 1 << inode
->i_blkbits
, 0);
666 bh
= head
= page_buffers(page
);
668 if (!buffer_dirty(bh
) || buffer_async_write(bh
))
671 list_add_tail(&bh
->b_assoc_buffers
, listp
);
673 if (unlikely(ndirties
>= nlimit
)) {
674 pagevec_release(&pvec
);
678 } while (bh
= bh
->b_this_page
, bh
!= head
);
680 pagevec_release(&pvec
);
685 static void nilfs_lookup_dirty_node_buffers(struct inode
*inode
,
686 struct list_head
*listp
)
688 struct nilfs_inode_info
*ii
= NILFS_I(inode
);
689 struct address_space
*mapping
= &ii
->i_btnode_cache
;
691 struct buffer_head
*bh
, *head
;
695 pagevec_init(&pvec
, 0);
697 while (pagevec_lookup_tag(&pvec
, mapping
, &index
, PAGECACHE_TAG_DIRTY
,
699 for (i
= 0; i
< pagevec_count(&pvec
); i
++) {
700 bh
= head
= page_buffers(pvec
.pages
[i
]);
702 if (buffer_dirty(bh
) &&
703 !buffer_async_write(bh
)) {
705 list_add_tail(&bh
->b_assoc_buffers
,
708 bh
= bh
->b_this_page
;
709 } while (bh
!= head
);
711 pagevec_release(&pvec
);
716 static void nilfs_dispose_list(struct the_nilfs
*nilfs
,
717 struct list_head
*head
, int force
)
719 struct nilfs_inode_info
*ii
, *n
;
720 struct nilfs_inode_info
*ivec
[SC_N_INODEVEC
], **pii
;
723 while (!list_empty(head
)) {
724 spin_lock(&nilfs
->ns_inode_lock
);
725 list_for_each_entry_safe(ii
, n
, head
, i_dirty
) {
726 list_del_init(&ii
->i_dirty
);
728 if (unlikely(ii
->i_bh
)) {
732 } else if (test_bit(NILFS_I_DIRTY
, &ii
->i_state
)) {
733 set_bit(NILFS_I_QUEUED
, &ii
->i_state
);
734 list_add_tail(&ii
->i_dirty
,
735 &nilfs
->ns_dirty_files
);
739 if (nv
== SC_N_INODEVEC
)
742 spin_unlock(&nilfs
->ns_inode_lock
);
744 for (pii
= ivec
; nv
> 0; pii
++, nv
--)
745 iput(&(*pii
)->vfs_inode
);
749 static int nilfs_test_metadata_dirty(struct the_nilfs
*nilfs
,
750 struct nilfs_root
*root
)
754 if (nilfs_mdt_fetch_dirty(root
->ifile
))
756 if (nilfs_mdt_fetch_dirty(nilfs
->ns_cpfile
))
758 if (nilfs_mdt_fetch_dirty(nilfs
->ns_sufile
))
760 if ((ret
|| nilfs_doing_gc()) && nilfs_mdt_fetch_dirty(nilfs
->ns_dat
))
765 static int nilfs_segctor_clean(struct nilfs_sc_info
*sci
)
767 return list_empty(&sci
->sc_dirty_files
) &&
768 !test_bit(NILFS_SC_DIRTY
, &sci
->sc_flags
) &&
769 sci
->sc_nfreesegs
== 0 &&
770 (!nilfs_doing_gc() || list_empty(&sci
->sc_gc_inodes
));
773 static int nilfs_segctor_confirm(struct nilfs_sc_info
*sci
)
775 struct the_nilfs
*nilfs
= sci
->sc_super
->s_fs_info
;
778 if (nilfs_test_metadata_dirty(nilfs
, sci
->sc_root
))
779 set_bit(NILFS_SC_DIRTY
, &sci
->sc_flags
);
781 spin_lock(&nilfs
->ns_inode_lock
);
782 if (list_empty(&nilfs
->ns_dirty_files
) && nilfs_segctor_clean(sci
))
785 spin_unlock(&nilfs
->ns_inode_lock
);
789 static void nilfs_segctor_clear_metadata_dirty(struct nilfs_sc_info
*sci
)
791 struct the_nilfs
*nilfs
= sci
->sc_super
->s_fs_info
;
793 nilfs_mdt_clear_dirty(sci
->sc_root
->ifile
);
794 nilfs_mdt_clear_dirty(nilfs
->ns_cpfile
);
795 nilfs_mdt_clear_dirty(nilfs
->ns_sufile
);
796 nilfs_mdt_clear_dirty(nilfs
->ns_dat
);
799 static int nilfs_segctor_create_checkpoint(struct nilfs_sc_info
*sci
)
801 struct the_nilfs
*nilfs
= sci
->sc_super
->s_fs_info
;
802 struct buffer_head
*bh_cp
;
803 struct nilfs_checkpoint
*raw_cp
;
806 /* XXX: this interface will be changed */
807 err
= nilfs_cpfile_get_checkpoint(nilfs
->ns_cpfile
, nilfs
->ns_cno
, 1,
810 /* The following code is duplicated with cpfile. But, it is
811 needed to collect the checkpoint even if it was not newly
813 mark_buffer_dirty(bh_cp
);
814 nilfs_mdt_mark_dirty(nilfs
->ns_cpfile
);
815 nilfs_cpfile_put_checkpoint(
816 nilfs
->ns_cpfile
, nilfs
->ns_cno
, bh_cp
);
818 WARN_ON(err
== -EINVAL
|| err
== -ENOENT
);
823 static int nilfs_segctor_fill_in_checkpoint(struct nilfs_sc_info
*sci
)
825 struct the_nilfs
*nilfs
= sci
->sc_super
->s_fs_info
;
826 struct buffer_head
*bh_cp
;
827 struct nilfs_checkpoint
*raw_cp
;
830 err
= nilfs_cpfile_get_checkpoint(nilfs
->ns_cpfile
, nilfs
->ns_cno
, 0,
833 WARN_ON(err
== -EINVAL
|| err
== -ENOENT
);
836 raw_cp
->cp_snapshot_list
.ssl_next
= 0;
837 raw_cp
->cp_snapshot_list
.ssl_prev
= 0;
838 raw_cp
->cp_inodes_count
=
839 cpu_to_le64(atomic64_read(&sci
->sc_root
->inodes_count
));
840 raw_cp
->cp_blocks_count
=
841 cpu_to_le64(atomic64_read(&sci
->sc_root
->blocks_count
));
842 raw_cp
->cp_nblk_inc
=
843 cpu_to_le64(sci
->sc_nblk_inc
+ sci
->sc_nblk_this_inc
);
844 raw_cp
->cp_create
= cpu_to_le64(sci
->sc_seg_ctime
);
845 raw_cp
->cp_cno
= cpu_to_le64(nilfs
->ns_cno
);
847 if (test_bit(NILFS_SC_HAVE_DELTA
, &sci
->sc_flags
))
848 nilfs_checkpoint_clear_minor(raw_cp
);
850 nilfs_checkpoint_set_minor(raw_cp
);
852 nilfs_write_inode_common(sci
->sc_root
->ifile
,
853 &raw_cp
->cp_ifile_inode
, 1);
854 nilfs_cpfile_put_checkpoint(nilfs
->ns_cpfile
, nilfs
->ns_cno
, bh_cp
);
861 static void nilfs_fill_in_file_bmap(struct inode
*ifile
,
862 struct nilfs_inode_info
*ii
)
865 struct buffer_head
*ibh
;
866 struct nilfs_inode
*raw_inode
;
868 if (test_bit(NILFS_I_BMAP
, &ii
->i_state
)) {
871 raw_inode
= nilfs_ifile_map_inode(ifile
, ii
->vfs_inode
.i_ino
,
873 nilfs_bmap_write(ii
->i_bmap
, raw_inode
);
874 nilfs_ifile_unmap_inode(ifile
, ii
->vfs_inode
.i_ino
, ibh
);
878 static void nilfs_segctor_fill_in_file_bmap(struct nilfs_sc_info
*sci
)
880 struct nilfs_inode_info
*ii
;
882 list_for_each_entry(ii
, &sci
->sc_dirty_files
, i_dirty
) {
883 nilfs_fill_in_file_bmap(sci
->sc_root
->ifile
, ii
);
884 set_bit(NILFS_I_COLLECTED
, &ii
->i_state
);
888 static void nilfs_segctor_fill_in_super_root(struct nilfs_sc_info
*sci
,
889 struct the_nilfs
*nilfs
)
891 struct buffer_head
*bh_sr
;
892 struct nilfs_super_root
*raw_sr
;
895 bh_sr
= NILFS_LAST_SEGBUF(&sci
->sc_segbufs
)->sb_super_root
;
896 raw_sr
= (struct nilfs_super_root
*)bh_sr
->b_data
;
897 isz
= nilfs
->ns_inode_size
;
898 srsz
= NILFS_SR_BYTES(isz
);
900 raw_sr
->sr_bytes
= cpu_to_le16(srsz
);
901 raw_sr
->sr_nongc_ctime
902 = cpu_to_le64(nilfs_doing_gc() ?
903 nilfs
->ns_nongc_ctime
: sci
->sc_seg_ctime
);
904 raw_sr
->sr_flags
= 0;
906 nilfs_write_inode_common(nilfs
->ns_dat
, (void *)raw_sr
+
907 NILFS_SR_DAT_OFFSET(isz
), 1);
908 nilfs_write_inode_common(nilfs
->ns_cpfile
, (void *)raw_sr
+
909 NILFS_SR_CPFILE_OFFSET(isz
), 1);
910 nilfs_write_inode_common(nilfs
->ns_sufile
, (void *)raw_sr
+
911 NILFS_SR_SUFILE_OFFSET(isz
), 1);
912 memset((void *)raw_sr
+ srsz
, 0, nilfs
->ns_blocksize
- srsz
);
915 static void nilfs_redirty_inodes(struct list_head
*head
)
917 struct nilfs_inode_info
*ii
;
919 list_for_each_entry(ii
, head
, i_dirty
) {
920 if (test_bit(NILFS_I_COLLECTED
, &ii
->i_state
))
921 clear_bit(NILFS_I_COLLECTED
, &ii
->i_state
);
925 static void nilfs_drop_collected_inodes(struct list_head
*head
)
927 struct nilfs_inode_info
*ii
;
929 list_for_each_entry(ii
, head
, i_dirty
) {
930 if (!test_and_clear_bit(NILFS_I_COLLECTED
, &ii
->i_state
))
933 clear_bit(NILFS_I_INODE_DIRTY
, &ii
->i_state
);
934 set_bit(NILFS_I_UPDATED
, &ii
->i_state
);
938 static int nilfs_segctor_apply_buffers(struct nilfs_sc_info
*sci
,
940 struct list_head
*listp
,
941 int (*collect
)(struct nilfs_sc_info
*,
942 struct buffer_head
*,
945 struct buffer_head
*bh
, *n
;
949 list_for_each_entry_safe(bh
, n
, listp
, b_assoc_buffers
) {
950 list_del_init(&bh
->b_assoc_buffers
);
951 err
= collect(sci
, bh
, inode
);
954 goto dispose_buffers
;
960 while (!list_empty(listp
)) {
961 bh
= list_first_entry(listp
, struct buffer_head
,
963 list_del_init(&bh
->b_assoc_buffers
);
969 static size_t nilfs_segctor_buffer_rest(struct nilfs_sc_info
*sci
)
971 /* Remaining number of blocks within segment buffer */
972 return sci
->sc_segbuf_nblocks
-
973 (sci
->sc_nblk_this_inc
+ sci
->sc_curseg
->sb_sum
.nblocks
);
976 static int nilfs_segctor_scan_file(struct nilfs_sc_info
*sci
,
978 struct nilfs_sc_operations
*sc_ops
)
980 LIST_HEAD(data_buffers
);
981 LIST_HEAD(node_buffers
);
984 if (!(sci
->sc_stage
.flags
& NILFS_CF_NODE
)) {
985 size_t n
, rest
= nilfs_segctor_buffer_rest(sci
);
987 n
= nilfs_lookup_dirty_data_buffers(
988 inode
, &data_buffers
, rest
+ 1, 0, LLONG_MAX
);
990 err
= nilfs_segctor_apply_buffers(
991 sci
, inode
, &data_buffers
,
992 sc_ops
->collect_data
);
993 BUG_ON(!err
); /* always receive -E2BIG or true error */
997 nilfs_lookup_dirty_node_buffers(inode
, &node_buffers
);
999 if (!(sci
->sc_stage
.flags
& NILFS_CF_NODE
)) {
1000 err
= nilfs_segctor_apply_buffers(
1001 sci
, inode
, &data_buffers
, sc_ops
->collect_data
);
1002 if (unlikely(err
)) {
1003 /* dispose node list */
1004 nilfs_segctor_apply_buffers(
1005 sci
, inode
, &node_buffers
, NULL
);
1008 sci
->sc_stage
.flags
|= NILFS_CF_NODE
;
1011 err
= nilfs_segctor_apply_buffers(
1012 sci
, inode
, &node_buffers
, sc_ops
->collect_node
);
1016 nilfs_bmap_lookup_dirty_buffers(NILFS_I(inode
)->i_bmap
, &node_buffers
);
1017 err
= nilfs_segctor_apply_buffers(
1018 sci
, inode
, &node_buffers
, sc_ops
->collect_bmap
);
1022 nilfs_segctor_end_finfo(sci
, inode
);
1023 sci
->sc_stage
.flags
&= ~NILFS_CF_NODE
;
1029 static int nilfs_segctor_scan_file_dsync(struct nilfs_sc_info
*sci
,
1030 struct inode
*inode
)
1032 LIST_HEAD(data_buffers
);
1033 size_t n
, rest
= nilfs_segctor_buffer_rest(sci
);
1036 n
= nilfs_lookup_dirty_data_buffers(inode
, &data_buffers
, rest
+ 1,
1037 sci
->sc_dsync_start
,
1040 err
= nilfs_segctor_apply_buffers(sci
, inode
, &data_buffers
,
1041 nilfs_collect_file_data
);
1043 nilfs_segctor_end_finfo(sci
, inode
);
1045 /* always receive -E2BIG or true error if n > rest */
1050 static int nilfs_segctor_collect_blocks(struct nilfs_sc_info
*sci
, int mode
)
1052 struct the_nilfs
*nilfs
= sci
->sc_super
->s_fs_info
;
1053 struct list_head
*head
;
1054 struct nilfs_inode_info
*ii
;
1058 switch (sci
->sc_stage
.scnt
) {
1061 sci
->sc_stage
.flags
= 0;
1063 if (!test_bit(NILFS_SC_UNCLOSED
, &sci
->sc_flags
)) {
1064 sci
->sc_nblk_inc
= 0;
1065 sci
->sc_curseg
->sb_sum
.flags
= NILFS_SS_LOGBGN
;
1066 if (mode
== SC_LSEG_DSYNC
) {
1067 sci
->sc_stage
.scnt
= NILFS_ST_DSYNC
;
1072 sci
->sc_stage
.dirty_file_ptr
= NULL
;
1073 sci
->sc_stage
.gc_inode_ptr
= NULL
;
1074 if (mode
== SC_FLUSH_DAT
) {
1075 sci
->sc_stage
.scnt
= NILFS_ST_DAT
;
1078 sci
->sc_stage
.scnt
++; /* Fall through */
1080 if (nilfs_doing_gc()) {
1081 head
= &sci
->sc_gc_inodes
;
1082 ii
= list_prepare_entry(sci
->sc_stage
.gc_inode_ptr
,
1084 list_for_each_entry_continue(ii
, head
, i_dirty
) {
1085 err
= nilfs_segctor_scan_file(
1086 sci
, &ii
->vfs_inode
,
1087 &nilfs_sc_file_ops
);
1088 if (unlikely(err
)) {
1089 sci
->sc_stage
.gc_inode_ptr
= list_entry(
1091 struct nilfs_inode_info
,
1095 set_bit(NILFS_I_COLLECTED
, &ii
->i_state
);
1097 sci
->sc_stage
.gc_inode_ptr
= NULL
;
1099 sci
->sc_stage
.scnt
++; /* Fall through */
1101 head
= &sci
->sc_dirty_files
;
1102 ii
= list_prepare_entry(sci
->sc_stage
.dirty_file_ptr
, head
,
1104 list_for_each_entry_continue(ii
, head
, i_dirty
) {
1105 clear_bit(NILFS_I_DIRTY
, &ii
->i_state
);
1107 err
= nilfs_segctor_scan_file(sci
, &ii
->vfs_inode
,
1108 &nilfs_sc_file_ops
);
1109 if (unlikely(err
)) {
1110 sci
->sc_stage
.dirty_file_ptr
=
1111 list_entry(ii
->i_dirty
.prev
,
1112 struct nilfs_inode_info
,
1116 /* sci->sc_stage.dirty_file_ptr = NILFS_I(inode); */
1117 /* XXX: required ? */
1119 sci
->sc_stage
.dirty_file_ptr
= NULL
;
1120 if (mode
== SC_FLUSH_FILE
) {
1121 sci
->sc_stage
.scnt
= NILFS_ST_DONE
;
1124 sci
->sc_stage
.scnt
++;
1125 sci
->sc_stage
.flags
|= NILFS_CF_IFILE_STARTED
;
1127 case NILFS_ST_IFILE
:
1128 err
= nilfs_segctor_scan_file(sci
, sci
->sc_root
->ifile
,
1129 &nilfs_sc_file_ops
);
1132 sci
->sc_stage
.scnt
++;
1133 /* Creating a checkpoint */
1134 err
= nilfs_segctor_create_checkpoint(sci
);
1138 case NILFS_ST_CPFILE
:
1139 err
= nilfs_segctor_scan_file(sci
, nilfs
->ns_cpfile
,
1140 &nilfs_sc_file_ops
);
1143 sci
->sc_stage
.scnt
++; /* Fall through */
1144 case NILFS_ST_SUFILE
:
1145 err
= nilfs_sufile_freev(nilfs
->ns_sufile
, sci
->sc_freesegs
,
1146 sci
->sc_nfreesegs
, &ndone
);
1147 if (unlikely(err
)) {
1148 nilfs_sufile_cancel_freev(nilfs
->ns_sufile
,
1149 sci
->sc_freesegs
, ndone
,
1153 sci
->sc_stage
.flags
|= NILFS_CF_SUFREED
;
1155 err
= nilfs_segctor_scan_file(sci
, nilfs
->ns_sufile
,
1156 &nilfs_sc_file_ops
);
1159 sci
->sc_stage
.scnt
++; /* Fall through */
1162 err
= nilfs_segctor_scan_file(sci
, nilfs
->ns_dat
,
1166 if (mode
== SC_FLUSH_DAT
) {
1167 sci
->sc_stage
.scnt
= NILFS_ST_DONE
;
1170 sci
->sc_stage
.scnt
++; /* Fall through */
1172 if (mode
== SC_LSEG_SR
) {
1173 /* Appending a super root */
1174 err
= nilfs_segctor_add_super_root(sci
);
1178 /* End of a logical segment */
1179 sci
->sc_curseg
->sb_sum
.flags
|= NILFS_SS_LOGEND
;
1180 sci
->sc_stage
.scnt
= NILFS_ST_DONE
;
1182 case NILFS_ST_DSYNC
:
1184 sci
->sc_curseg
->sb_sum
.flags
|= NILFS_SS_SYNDT
;
1185 ii
= sci
->sc_dsync_inode
;
1186 if (!test_bit(NILFS_I_BUSY
, &ii
->i_state
))
1189 err
= nilfs_segctor_scan_file_dsync(sci
, &ii
->vfs_inode
);
1192 sci
->sc_curseg
->sb_sum
.flags
|= NILFS_SS_LOGEND
;
1193 sci
->sc_stage
.scnt
= NILFS_ST_DONE
;
1206 * nilfs_segctor_begin_construction - setup segment buffer to make a new log
1207 * @sci: nilfs_sc_info
1208 * @nilfs: nilfs object
1210 static int nilfs_segctor_begin_construction(struct nilfs_sc_info
*sci
,
1211 struct the_nilfs
*nilfs
)
1213 struct nilfs_segment_buffer
*segbuf
, *prev
;
1217 segbuf
= nilfs_segbuf_new(sci
->sc_super
);
1218 if (unlikely(!segbuf
))
1221 if (list_empty(&sci
->sc_write_logs
)) {
1222 nilfs_segbuf_map(segbuf
, nilfs
->ns_segnum
,
1223 nilfs
->ns_pseg_offset
, nilfs
);
1224 if (segbuf
->sb_rest_blocks
< NILFS_PSEG_MIN_BLOCKS
) {
1225 nilfs_shift_to_next_segment(nilfs
);
1226 nilfs_segbuf_map(segbuf
, nilfs
->ns_segnum
, 0, nilfs
);
1229 segbuf
->sb_sum
.seg_seq
= nilfs
->ns_seg_seq
;
1230 nextnum
= nilfs
->ns_nextnum
;
1232 if (nilfs
->ns_segnum
== nilfs
->ns_nextnum
)
1233 /* Start from the head of a new full segment */
1237 prev
= NILFS_LAST_SEGBUF(&sci
->sc_write_logs
);
1238 nilfs_segbuf_map_cont(segbuf
, prev
);
1239 segbuf
->sb_sum
.seg_seq
= prev
->sb_sum
.seg_seq
;
1240 nextnum
= prev
->sb_nextnum
;
1242 if (segbuf
->sb_rest_blocks
< NILFS_PSEG_MIN_BLOCKS
) {
1243 nilfs_segbuf_map(segbuf
, prev
->sb_nextnum
, 0, nilfs
);
1244 segbuf
->sb_sum
.seg_seq
++;
1249 err
= nilfs_sufile_mark_dirty(nilfs
->ns_sufile
, segbuf
->sb_segnum
);
1254 err
= nilfs_sufile_alloc(nilfs
->ns_sufile
, &nextnum
);
1258 nilfs_segbuf_set_next_segnum(segbuf
, nextnum
, nilfs
);
1260 BUG_ON(!list_empty(&sci
->sc_segbufs
));
1261 list_add_tail(&segbuf
->sb_list
, &sci
->sc_segbufs
);
1262 sci
->sc_segbuf_nblocks
= segbuf
->sb_rest_blocks
;
1266 nilfs_segbuf_free(segbuf
);
1270 static int nilfs_segctor_extend_segments(struct nilfs_sc_info
*sci
,
1271 struct the_nilfs
*nilfs
, int nadd
)
1273 struct nilfs_segment_buffer
*segbuf
, *prev
;
1274 struct inode
*sufile
= nilfs
->ns_sufile
;
1279 prev
= NILFS_LAST_SEGBUF(&sci
->sc_segbufs
);
1281 * Since the segment specified with nextnum might be allocated during
1282 * the previous construction, the buffer including its segusage may
1283 * not be dirty. The following call ensures that the buffer is dirty
1284 * and will pin the buffer on memory until the sufile is written.
1286 err
= nilfs_sufile_mark_dirty(sufile
, prev
->sb_nextnum
);
1290 for (i
= 0; i
< nadd
; i
++) {
1291 /* extend segment info */
1293 segbuf
= nilfs_segbuf_new(sci
->sc_super
);
1294 if (unlikely(!segbuf
))
1297 /* map this buffer to region of segment on-disk */
1298 nilfs_segbuf_map(segbuf
, prev
->sb_nextnum
, 0, nilfs
);
1299 sci
->sc_segbuf_nblocks
+= segbuf
->sb_rest_blocks
;
1301 /* allocate the next next full segment */
1302 err
= nilfs_sufile_alloc(sufile
, &nextnextnum
);
1306 segbuf
->sb_sum
.seg_seq
= prev
->sb_sum
.seg_seq
+ 1;
1307 nilfs_segbuf_set_next_segnum(segbuf
, nextnextnum
, nilfs
);
1309 list_add_tail(&segbuf
->sb_list
, &list
);
1312 list_splice_tail(&list
, &sci
->sc_segbufs
);
1316 nilfs_segbuf_free(segbuf
);
1318 list_for_each_entry(segbuf
, &list
, sb_list
) {
1319 ret
= nilfs_sufile_free(sufile
, segbuf
->sb_nextnum
);
1320 WARN_ON(ret
); /* never fails */
1322 nilfs_destroy_logs(&list
);
1326 static void nilfs_free_incomplete_logs(struct list_head
*logs
,
1327 struct the_nilfs
*nilfs
)
1329 struct nilfs_segment_buffer
*segbuf
, *prev
;
1330 struct inode
*sufile
= nilfs
->ns_sufile
;
1333 segbuf
= NILFS_FIRST_SEGBUF(logs
);
1334 if (nilfs
->ns_nextnum
!= segbuf
->sb_nextnum
) {
1335 ret
= nilfs_sufile_free(sufile
, segbuf
->sb_nextnum
);
1336 WARN_ON(ret
); /* never fails */
1338 if (atomic_read(&segbuf
->sb_err
)) {
1339 /* Case 1: The first segment failed */
1340 if (segbuf
->sb_pseg_start
!= segbuf
->sb_fseg_start
)
1341 /* Case 1a: Partial segment appended into an existing
1343 nilfs_terminate_segment(nilfs
, segbuf
->sb_fseg_start
,
1344 segbuf
->sb_fseg_end
);
1345 else /* Case 1b: New full segment */
1346 set_nilfs_discontinued(nilfs
);
1350 list_for_each_entry_continue(segbuf
, logs
, sb_list
) {
1351 if (prev
->sb_nextnum
!= segbuf
->sb_nextnum
) {
1352 ret
= nilfs_sufile_free(sufile
, segbuf
->sb_nextnum
);
1353 WARN_ON(ret
); /* never fails */
1355 if (atomic_read(&segbuf
->sb_err
) &&
1356 segbuf
->sb_segnum
!= nilfs
->ns_nextnum
)
1357 /* Case 2: extended segment (!= next) failed */
1358 nilfs_sufile_set_error(sufile
, segbuf
->sb_segnum
);
1363 static void nilfs_segctor_update_segusage(struct nilfs_sc_info
*sci
,
1364 struct inode
*sufile
)
1366 struct nilfs_segment_buffer
*segbuf
;
1367 unsigned long live_blocks
;
1370 list_for_each_entry(segbuf
, &sci
->sc_segbufs
, sb_list
) {
1371 live_blocks
= segbuf
->sb_sum
.nblocks
+
1372 (segbuf
->sb_pseg_start
- segbuf
->sb_fseg_start
);
1373 ret
= nilfs_sufile_set_segment_usage(sufile
, segbuf
->sb_segnum
,
1376 WARN_ON(ret
); /* always succeed because the segusage is dirty */
1380 static void nilfs_cancel_segusage(struct list_head
*logs
, struct inode
*sufile
)
1382 struct nilfs_segment_buffer
*segbuf
;
1385 segbuf
= NILFS_FIRST_SEGBUF(logs
);
1386 ret
= nilfs_sufile_set_segment_usage(sufile
, segbuf
->sb_segnum
,
1387 segbuf
->sb_pseg_start
-
1388 segbuf
->sb_fseg_start
, 0);
1389 WARN_ON(ret
); /* always succeed because the segusage is dirty */
1391 list_for_each_entry_continue(segbuf
, logs
, sb_list
) {
1392 ret
= nilfs_sufile_set_segment_usage(sufile
, segbuf
->sb_segnum
,
1394 WARN_ON(ret
); /* always succeed */
1398 static void nilfs_segctor_truncate_segments(struct nilfs_sc_info
*sci
,
1399 struct nilfs_segment_buffer
*last
,
1400 struct inode
*sufile
)
1402 struct nilfs_segment_buffer
*segbuf
= last
;
1405 list_for_each_entry_continue(segbuf
, &sci
->sc_segbufs
, sb_list
) {
1406 sci
->sc_segbuf_nblocks
-= segbuf
->sb_rest_blocks
;
1407 ret
= nilfs_sufile_free(sufile
, segbuf
->sb_nextnum
);
1410 nilfs_truncate_logs(&sci
->sc_segbufs
, last
);
1414 static int nilfs_segctor_collect(struct nilfs_sc_info
*sci
,
1415 struct the_nilfs
*nilfs
, int mode
)
1417 struct nilfs_cstage prev_stage
= sci
->sc_stage
;
1420 /* Collection retry loop */
1422 sci
->sc_nblk_this_inc
= 0;
1423 sci
->sc_curseg
= NILFS_FIRST_SEGBUF(&sci
->sc_segbufs
);
1425 err
= nilfs_segctor_reset_segment_buffer(sci
);
1429 err
= nilfs_segctor_collect_blocks(sci
, mode
);
1430 sci
->sc_nblk_this_inc
+= sci
->sc_curseg
->sb_sum
.nblocks
;
1434 if (unlikely(err
!= -E2BIG
))
1437 /* The current segment is filled up */
1438 if (mode
!= SC_LSEG_SR
|| sci
->sc_stage
.scnt
< NILFS_ST_CPFILE
)
1441 nilfs_clear_logs(&sci
->sc_segbufs
);
1443 err
= nilfs_segctor_extend_segments(sci
, nilfs
, nadd
);
1447 if (sci
->sc_stage
.flags
& NILFS_CF_SUFREED
) {
1448 err
= nilfs_sufile_cancel_freev(nilfs
->ns_sufile
,
1452 WARN_ON(err
); /* do not happen */
1454 nadd
= min_t(int, nadd
<< 1, SC_MAX_SEGDELTA
);
1455 sci
->sc_stage
= prev_stage
;
1457 nilfs_segctor_truncate_segments(sci
, sci
->sc_curseg
, nilfs
->ns_sufile
);
1464 static void nilfs_list_replace_buffer(struct buffer_head
*old_bh
,
1465 struct buffer_head
*new_bh
)
1467 BUG_ON(!list_empty(&new_bh
->b_assoc_buffers
));
1469 list_replace_init(&old_bh
->b_assoc_buffers
, &new_bh
->b_assoc_buffers
);
1470 /* The caller must release old_bh */
1474 nilfs_segctor_update_payload_blocknr(struct nilfs_sc_info
*sci
,
1475 struct nilfs_segment_buffer
*segbuf
,
1478 struct inode
*inode
= NULL
;
1480 unsigned long nfinfo
= segbuf
->sb_sum
.nfinfo
;
1481 unsigned long nblocks
= 0, ndatablk
= 0;
1482 struct nilfs_sc_operations
*sc_op
= NULL
;
1483 struct nilfs_segsum_pointer ssp
;
1484 struct nilfs_finfo
*finfo
= NULL
;
1485 union nilfs_binfo binfo
;
1486 struct buffer_head
*bh
, *bh_org
;
1493 blocknr
= segbuf
->sb_pseg_start
+ segbuf
->sb_sum
.nsumblk
;
1494 ssp
.bh
= NILFS_SEGBUF_FIRST_BH(&segbuf
->sb_segsum_buffers
);
1495 ssp
.offset
= sizeof(struct nilfs_segment_summary
);
1497 list_for_each_entry(bh
, &segbuf
->sb_payload_buffers
, b_assoc_buffers
) {
1498 if (bh
== segbuf
->sb_super_root
)
1501 finfo
= nilfs_segctor_map_segsum_entry(
1502 sci
, &ssp
, sizeof(*finfo
));
1503 ino
= le64_to_cpu(finfo
->fi_ino
);
1504 nblocks
= le32_to_cpu(finfo
->fi_nblocks
);
1505 ndatablk
= le32_to_cpu(finfo
->fi_ndatablk
);
1507 inode
= bh
->b_page
->mapping
->host
;
1509 if (mode
== SC_LSEG_DSYNC
)
1510 sc_op
= &nilfs_sc_dsync_ops
;
1511 else if (ino
== NILFS_DAT_INO
)
1512 sc_op
= &nilfs_sc_dat_ops
;
1513 else /* file blocks */
1514 sc_op
= &nilfs_sc_file_ops
;
1518 err
= nilfs_bmap_assign(NILFS_I(inode
)->i_bmap
, &bh
, blocknr
,
1521 nilfs_list_replace_buffer(bh_org
, bh
);
1527 sc_op
->write_data_binfo(sci
, &ssp
, &binfo
);
1529 sc_op
->write_node_binfo(sci
, &ssp
, &binfo
);
1532 if (--nblocks
== 0) {
1536 } else if (ndatablk
> 0)
1546 static int nilfs_segctor_assign(struct nilfs_sc_info
*sci
, int mode
)
1548 struct nilfs_segment_buffer
*segbuf
;
1551 list_for_each_entry(segbuf
, &sci
->sc_segbufs
, sb_list
) {
1552 err
= nilfs_segctor_update_payload_blocknr(sci
, segbuf
, mode
);
1555 nilfs_segbuf_fill_in_segsum(segbuf
);
1560 static void nilfs_begin_page_io(struct page
*page
)
1562 if (!page
|| PageWriteback(page
))
1563 /* For split b-tree node pages, this function may be called
1564 twice. We ignore the 2nd or later calls by this check. */
1568 clear_page_dirty_for_io(page
);
1569 set_page_writeback(page
);
1573 static void nilfs_segctor_prepare_write(struct nilfs_sc_info
*sci
)
1575 struct nilfs_segment_buffer
*segbuf
;
1576 struct page
*bd_page
= NULL
, *fs_page
= NULL
;
1578 list_for_each_entry(segbuf
, &sci
->sc_segbufs
, sb_list
) {
1579 struct buffer_head
*bh
;
1581 list_for_each_entry(bh
, &segbuf
->sb_segsum_buffers
,
1583 set_buffer_async_write(bh
);
1584 if (bh
->b_page
!= bd_page
) {
1587 clear_page_dirty_for_io(bd_page
);
1588 set_page_writeback(bd_page
);
1589 unlock_page(bd_page
);
1591 bd_page
= bh
->b_page
;
1595 list_for_each_entry(bh
, &segbuf
->sb_payload_buffers
,
1597 set_buffer_async_write(bh
);
1598 if (bh
== segbuf
->sb_super_root
) {
1599 if (bh
->b_page
!= bd_page
) {
1601 clear_page_dirty_for_io(bd_page
);
1602 set_page_writeback(bd_page
);
1603 unlock_page(bd_page
);
1604 bd_page
= bh
->b_page
;
1608 if (bh
->b_page
!= fs_page
) {
1609 nilfs_begin_page_io(fs_page
);
1610 fs_page
= bh
->b_page
;
1616 clear_page_dirty_for_io(bd_page
);
1617 set_page_writeback(bd_page
);
1618 unlock_page(bd_page
);
1620 nilfs_begin_page_io(fs_page
);
1623 static int nilfs_segctor_write(struct nilfs_sc_info
*sci
,
1624 struct the_nilfs
*nilfs
)
1628 ret
= nilfs_write_logs(&sci
->sc_segbufs
, nilfs
);
1629 list_splice_tail_init(&sci
->sc_segbufs
, &sci
->sc_write_logs
);
1633 static void nilfs_end_page_io(struct page
*page
, int err
)
1638 if (buffer_nilfs_node(page_buffers(page
)) && !PageWriteback(page
)) {
1640 * For b-tree node pages, this function may be called twice
1641 * or more because they might be split in a segment.
1643 if (PageDirty(page
)) {
1645 * For pages holding split b-tree node buffers, dirty
1646 * flag on the buffers may be cleared discretely.
1647 * In that case, the page is once redirtied for
1648 * remaining buffers, and it must be cancelled if
1649 * all the buffers get cleaned later.
1652 if (nilfs_page_buffers_clean(page
))
1653 __nilfs_clear_page_dirty(page
);
1660 if (!nilfs_page_buffers_clean(page
))
1661 __set_page_dirty_nobuffers(page
);
1662 ClearPageError(page
);
1664 __set_page_dirty_nobuffers(page
);
1668 end_page_writeback(page
);
1671 static void nilfs_abort_logs(struct list_head
*logs
, int err
)
1673 struct nilfs_segment_buffer
*segbuf
;
1674 struct page
*bd_page
= NULL
, *fs_page
= NULL
;
1675 struct buffer_head
*bh
;
1677 if (list_empty(logs
))
1680 list_for_each_entry(segbuf
, logs
, sb_list
) {
1681 list_for_each_entry(bh
, &segbuf
->sb_segsum_buffers
,
1683 clear_buffer_async_write(bh
);
1684 if (bh
->b_page
!= bd_page
) {
1686 end_page_writeback(bd_page
);
1687 bd_page
= bh
->b_page
;
1691 list_for_each_entry(bh
, &segbuf
->sb_payload_buffers
,
1693 clear_buffer_async_write(bh
);
1694 if (bh
== segbuf
->sb_super_root
) {
1695 if (bh
->b_page
!= bd_page
) {
1696 end_page_writeback(bd_page
);
1697 bd_page
= bh
->b_page
;
1701 if (bh
->b_page
!= fs_page
) {
1702 nilfs_end_page_io(fs_page
, err
);
1703 fs_page
= bh
->b_page
;
1708 end_page_writeback(bd_page
);
1710 nilfs_end_page_io(fs_page
, err
);
1713 static void nilfs_segctor_abort_construction(struct nilfs_sc_info
*sci
,
1714 struct the_nilfs
*nilfs
, int err
)
1719 list_splice_tail_init(&sci
->sc_write_logs
, &logs
);
1720 ret
= nilfs_wait_on_logs(&logs
);
1721 nilfs_abort_logs(&logs
, ret
? : err
);
1723 list_splice_tail_init(&sci
->sc_segbufs
, &logs
);
1724 nilfs_cancel_segusage(&logs
, nilfs
->ns_sufile
);
1725 nilfs_free_incomplete_logs(&logs
, nilfs
);
1727 if (sci
->sc_stage
.flags
& NILFS_CF_SUFREED
) {
1728 ret
= nilfs_sufile_cancel_freev(nilfs
->ns_sufile
,
1732 WARN_ON(ret
); /* do not happen */
1735 nilfs_destroy_logs(&logs
);
1738 static void nilfs_set_next_segment(struct the_nilfs
*nilfs
,
1739 struct nilfs_segment_buffer
*segbuf
)
1741 nilfs
->ns_segnum
= segbuf
->sb_segnum
;
1742 nilfs
->ns_nextnum
= segbuf
->sb_nextnum
;
1743 nilfs
->ns_pseg_offset
= segbuf
->sb_pseg_start
- segbuf
->sb_fseg_start
1744 + segbuf
->sb_sum
.nblocks
;
1745 nilfs
->ns_seg_seq
= segbuf
->sb_sum
.seg_seq
;
1746 nilfs
->ns_ctime
= segbuf
->sb_sum
.ctime
;
1749 static void nilfs_segctor_complete_write(struct nilfs_sc_info
*sci
)
1751 struct nilfs_segment_buffer
*segbuf
;
1752 struct page
*bd_page
= NULL
, *fs_page
= NULL
;
1753 struct the_nilfs
*nilfs
= sci
->sc_super
->s_fs_info
;
1754 int update_sr
= false;
1756 list_for_each_entry(segbuf
, &sci
->sc_write_logs
, sb_list
) {
1757 struct buffer_head
*bh
;
1759 list_for_each_entry(bh
, &segbuf
->sb_segsum_buffers
,
1761 set_buffer_uptodate(bh
);
1762 clear_buffer_dirty(bh
);
1763 clear_buffer_async_write(bh
);
1764 if (bh
->b_page
!= bd_page
) {
1766 end_page_writeback(bd_page
);
1767 bd_page
= bh
->b_page
;
1771 * We assume that the buffers which belong to the same page
1772 * continue over the buffer list.
1773 * Under this assumption, the last BHs of pages is
1774 * identifiable by the discontinuity of bh->b_page
1775 * (page != fs_page).
1777 * For B-tree node blocks, however, this assumption is not
1778 * guaranteed. The cleanup code of B-tree node pages needs
1781 list_for_each_entry(bh
, &segbuf
->sb_payload_buffers
,
1783 set_buffer_uptodate(bh
);
1784 clear_buffer_dirty(bh
);
1785 clear_buffer_async_write(bh
);
1786 clear_buffer_delay(bh
);
1787 clear_buffer_nilfs_volatile(bh
);
1788 clear_buffer_nilfs_redirected(bh
);
1789 if (bh
== segbuf
->sb_super_root
) {
1790 if (bh
->b_page
!= bd_page
) {
1791 end_page_writeback(bd_page
);
1792 bd_page
= bh
->b_page
;
1797 if (bh
->b_page
!= fs_page
) {
1798 nilfs_end_page_io(fs_page
, 0);
1799 fs_page
= bh
->b_page
;
1803 if (!nilfs_segbuf_simplex(segbuf
)) {
1804 if (segbuf
->sb_sum
.flags
& NILFS_SS_LOGBGN
) {
1805 set_bit(NILFS_SC_UNCLOSED
, &sci
->sc_flags
);
1806 sci
->sc_lseg_stime
= jiffies
;
1808 if (segbuf
->sb_sum
.flags
& NILFS_SS_LOGEND
)
1809 clear_bit(NILFS_SC_UNCLOSED
, &sci
->sc_flags
);
1813 * Since pages may continue over multiple segment buffers,
1814 * end of the last page must be checked outside of the loop.
1817 end_page_writeback(bd_page
);
1819 nilfs_end_page_io(fs_page
, 0);
1821 nilfs_drop_collected_inodes(&sci
->sc_dirty_files
);
1823 if (nilfs_doing_gc())
1824 nilfs_drop_collected_inodes(&sci
->sc_gc_inodes
);
1826 nilfs
->ns_nongc_ctime
= sci
->sc_seg_ctime
;
1828 sci
->sc_nblk_inc
+= sci
->sc_nblk_this_inc
;
1830 segbuf
= NILFS_LAST_SEGBUF(&sci
->sc_write_logs
);
1831 nilfs_set_next_segment(nilfs
, segbuf
);
1834 nilfs_set_last_segment(nilfs
, segbuf
->sb_pseg_start
,
1835 segbuf
->sb_sum
.seg_seq
, nilfs
->ns_cno
++);
1837 clear_bit(NILFS_SC_HAVE_DELTA
, &sci
->sc_flags
);
1838 clear_bit(NILFS_SC_DIRTY
, &sci
->sc_flags
);
1839 set_bit(NILFS_SC_SUPER_ROOT
, &sci
->sc_flags
);
1840 nilfs_segctor_clear_metadata_dirty(sci
);
1842 clear_bit(NILFS_SC_SUPER_ROOT
, &sci
->sc_flags
);
1845 static int nilfs_segctor_wait(struct nilfs_sc_info
*sci
)
1849 ret
= nilfs_wait_on_logs(&sci
->sc_write_logs
);
1851 nilfs_segctor_complete_write(sci
);
1852 nilfs_destroy_logs(&sci
->sc_write_logs
);
1857 static int nilfs_segctor_collect_dirty_files(struct nilfs_sc_info
*sci
,
1858 struct the_nilfs
*nilfs
)
1860 struct nilfs_inode_info
*ii
, *n
;
1861 struct inode
*ifile
= sci
->sc_root
->ifile
;
1863 spin_lock(&nilfs
->ns_inode_lock
);
1865 list_for_each_entry_safe(ii
, n
, &nilfs
->ns_dirty_files
, i_dirty
) {
1867 struct buffer_head
*ibh
;
1870 spin_unlock(&nilfs
->ns_inode_lock
);
1871 err
= nilfs_ifile_get_inode_block(
1872 ifile
, ii
->vfs_inode
.i_ino
, &ibh
);
1873 if (unlikely(err
)) {
1874 nilfs_warning(sci
->sc_super
, __func__
,
1875 "failed to get inode block.\n");
1878 mark_buffer_dirty(ibh
);
1879 nilfs_mdt_mark_dirty(ifile
);
1880 spin_lock(&nilfs
->ns_inode_lock
);
1881 if (likely(!ii
->i_bh
))
1888 clear_bit(NILFS_I_QUEUED
, &ii
->i_state
);
1889 set_bit(NILFS_I_BUSY
, &ii
->i_state
);
1890 list_move_tail(&ii
->i_dirty
, &sci
->sc_dirty_files
);
1892 spin_unlock(&nilfs
->ns_inode_lock
);
1897 static void nilfs_segctor_drop_written_files(struct nilfs_sc_info
*sci
,
1898 struct the_nilfs
*nilfs
)
1900 struct nilfs_transaction_info
*ti
= current
->journal_info
;
1901 struct nilfs_inode_info
*ii
, *n
;
1903 spin_lock(&nilfs
->ns_inode_lock
);
1904 list_for_each_entry_safe(ii
, n
, &sci
->sc_dirty_files
, i_dirty
) {
1905 if (!test_and_clear_bit(NILFS_I_UPDATED
, &ii
->i_state
) ||
1906 test_bit(NILFS_I_DIRTY
, &ii
->i_state
))
1909 clear_bit(NILFS_I_BUSY
, &ii
->i_state
);
1912 list_move_tail(&ii
->i_dirty
, &ti
->ti_garbage
);
1914 spin_unlock(&nilfs
->ns_inode_lock
);
1918 * Main procedure of segment constructor
1920 static int nilfs_segctor_do_construct(struct nilfs_sc_info
*sci
, int mode
)
1922 struct the_nilfs
*nilfs
= sci
->sc_super
->s_fs_info
;
1925 sci
->sc_stage
.scnt
= NILFS_ST_INIT
;
1926 sci
->sc_cno
= nilfs
->ns_cno
;
1928 err
= nilfs_segctor_collect_dirty_files(sci
, nilfs
);
1932 if (nilfs_test_metadata_dirty(nilfs
, sci
->sc_root
))
1933 set_bit(NILFS_SC_DIRTY
, &sci
->sc_flags
);
1935 if (nilfs_segctor_clean(sci
))
1939 sci
->sc_stage
.flags
&= ~NILFS_CF_HISTORY_MASK
;
1941 err
= nilfs_segctor_begin_construction(sci
, nilfs
);
1945 /* Update time stamp */
1946 sci
->sc_seg_ctime
= get_seconds();
1948 err
= nilfs_segctor_collect(sci
, nilfs
, mode
);
1952 /* Avoid empty segment */
1953 if (sci
->sc_stage
.scnt
== NILFS_ST_DONE
&&
1954 nilfs_segbuf_empty(sci
->sc_curseg
)) {
1955 nilfs_segctor_abort_construction(sci
, nilfs
, 1);
1959 err
= nilfs_segctor_assign(sci
, mode
);
1963 if (sci
->sc_stage
.flags
& NILFS_CF_IFILE_STARTED
)
1964 nilfs_segctor_fill_in_file_bmap(sci
);
1966 if (mode
== SC_LSEG_SR
&&
1967 sci
->sc_stage
.scnt
>= NILFS_ST_CPFILE
) {
1968 err
= nilfs_segctor_fill_in_checkpoint(sci
);
1970 goto failed_to_write
;
1972 nilfs_segctor_fill_in_super_root(sci
, nilfs
);
1974 nilfs_segctor_update_segusage(sci
, nilfs
->ns_sufile
);
1976 /* Write partial segments */
1977 nilfs_segctor_prepare_write(sci
);
1979 nilfs_add_checksums_on_logs(&sci
->sc_segbufs
,
1980 nilfs
->ns_crc_seed
);
1982 err
= nilfs_segctor_write(sci
, nilfs
);
1984 goto failed_to_write
;
1986 if (sci
->sc_stage
.scnt
== NILFS_ST_DONE
||
1987 nilfs
->ns_blocksize_bits
!= PAGE_CACHE_SHIFT
) {
1989 * At this point, we avoid double buffering
1990 * for blocksize < pagesize because page dirty
1991 * flag is turned off during write and dirty
1992 * buffers are not properly collected for
1993 * pages crossing over segments.
1995 err
= nilfs_segctor_wait(sci
);
1997 goto failed_to_write
;
1999 } while (sci
->sc_stage
.scnt
!= NILFS_ST_DONE
);
2002 nilfs_segctor_drop_written_files(sci
, nilfs
);
2006 if (sci
->sc_stage
.flags
& NILFS_CF_IFILE_STARTED
)
2007 nilfs_redirty_inodes(&sci
->sc_dirty_files
);
2010 if (nilfs_doing_gc())
2011 nilfs_redirty_inodes(&sci
->sc_gc_inodes
);
2012 nilfs_segctor_abort_construction(sci
, nilfs
, err
);
2017 * nilfs_segctor_start_timer - set timer of background write
2018 * @sci: nilfs_sc_info
2020 * If the timer has already been set, it ignores the new request.
2021 * This function MUST be called within a section locking the segment
2024 static void nilfs_segctor_start_timer(struct nilfs_sc_info
*sci
)
2026 spin_lock(&sci
->sc_state_lock
);
2027 if (!(sci
->sc_state
& NILFS_SEGCTOR_COMMIT
)) {
2028 sci
->sc_timer
.expires
= jiffies
+ sci
->sc_interval
;
2029 add_timer(&sci
->sc_timer
);
2030 sci
->sc_state
|= NILFS_SEGCTOR_COMMIT
;
2032 spin_unlock(&sci
->sc_state_lock
);
2035 static void nilfs_segctor_do_flush(struct nilfs_sc_info
*sci
, int bn
)
2037 spin_lock(&sci
->sc_state_lock
);
2038 if (!(sci
->sc_flush_request
& (1 << bn
))) {
2039 unsigned long prev_req
= sci
->sc_flush_request
;
2041 sci
->sc_flush_request
|= (1 << bn
);
2043 wake_up(&sci
->sc_wait_daemon
);
2045 spin_unlock(&sci
->sc_state_lock
);
2049 * nilfs_flush_segment - trigger a segment construction for resource control
2051 * @ino: inode number of the file to be flushed out.
2053 void nilfs_flush_segment(struct super_block
*sb
, ino_t ino
)
2055 struct the_nilfs
*nilfs
= sb
->s_fs_info
;
2056 struct nilfs_sc_info
*sci
= nilfs
->ns_writer
;
2058 if (!sci
|| nilfs_doing_construction())
2060 nilfs_segctor_do_flush(sci
, NILFS_MDT_INODE(sb
, ino
) ? ino
: 0);
2061 /* assign bit 0 to data files */
2064 struct nilfs_segctor_wait_request
{
2071 static int nilfs_segctor_sync(struct nilfs_sc_info
*sci
)
2073 struct nilfs_segctor_wait_request wait_req
;
2076 spin_lock(&sci
->sc_state_lock
);
2077 init_wait(&wait_req
.wq
);
2079 atomic_set(&wait_req
.done
, 0);
2080 wait_req
.seq
= ++sci
->sc_seq_request
;
2081 spin_unlock(&sci
->sc_state_lock
);
2083 init_waitqueue_entry(&wait_req
.wq
, current
);
2084 add_wait_queue(&sci
->sc_wait_request
, &wait_req
.wq
);
2085 set_current_state(TASK_INTERRUPTIBLE
);
2086 wake_up(&sci
->sc_wait_daemon
);
2089 if (atomic_read(&wait_req
.done
)) {
2093 if (!signal_pending(current
)) {
2100 finish_wait(&sci
->sc_wait_request
, &wait_req
.wq
);
2104 static void nilfs_segctor_wakeup(struct nilfs_sc_info
*sci
, int err
)
2106 struct nilfs_segctor_wait_request
*wrq
, *n
;
2107 unsigned long flags
;
2109 spin_lock_irqsave(&sci
->sc_wait_request
.lock
, flags
);
2110 list_for_each_entry_safe(wrq
, n
, &sci
->sc_wait_request
.task_list
,
2112 if (!atomic_read(&wrq
->done
) &&
2113 nilfs_cnt32_ge(sci
->sc_seq_done
, wrq
->seq
)) {
2115 atomic_set(&wrq
->done
, 1);
2117 if (atomic_read(&wrq
->done
)) {
2118 wrq
->wq
.func(&wrq
->wq
,
2119 TASK_UNINTERRUPTIBLE
| TASK_INTERRUPTIBLE
,
2123 spin_unlock_irqrestore(&sci
->sc_wait_request
.lock
, flags
);
2127 * nilfs_construct_segment - construct a logical segment
2130 * Return Value: On success, 0 is retured. On errors, one of the following
2131 * negative error code is returned.
2133 * %-EROFS - Read only filesystem.
2137 * %-ENOSPC - No space left on device (only in a panic state).
2139 * %-ERESTARTSYS - Interrupted.
2141 * %-ENOMEM - Insufficient memory available.
2143 int nilfs_construct_segment(struct super_block
*sb
)
2145 struct the_nilfs
*nilfs
= sb
->s_fs_info
;
2146 struct nilfs_sc_info
*sci
= nilfs
->ns_writer
;
2147 struct nilfs_transaction_info
*ti
;
2153 /* A call inside transactions causes a deadlock. */
2154 BUG_ON((ti
= current
->journal_info
) && ti
->ti_magic
== NILFS_TI_MAGIC
);
2156 err
= nilfs_segctor_sync(sci
);
2161 * nilfs_construct_dsync_segment - construct a data-only logical segment
2163 * @inode: inode whose data blocks should be written out
2164 * @start: start byte offset
2165 * @end: end byte offset (inclusive)
2167 * Return Value: On success, 0 is retured. On errors, one of the following
2168 * negative error code is returned.
2170 * %-EROFS - Read only filesystem.
2174 * %-ENOSPC - No space left on device (only in a panic state).
2176 * %-ERESTARTSYS - Interrupted.
2178 * %-ENOMEM - Insufficient memory available.
2180 int nilfs_construct_dsync_segment(struct super_block
*sb
, struct inode
*inode
,
2181 loff_t start
, loff_t end
)
2183 struct the_nilfs
*nilfs
= sb
->s_fs_info
;
2184 struct nilfs_sc_info
*sci
= nilfs
->ns_writer
;
2185 struct nilfs_inode_info
*ii
;
2186 struct nilfs_transaction_info ti
;
2192 nilfs_transaction_lock(sb
, &ti
, 0);
2194 ii
= NILFS_I(inode
);
2195 if (test_bit(NILFS_I_INODE_DIRTY
, &ii
->i_state
) ||
2196 nilfs_test_opt(nilfs
, STRICT_ORDER
) ||
2197 test_bit(NILFS_SC_UNCLOSED
, &sci
->sc_flags
) ||
2198 nilfs_discontinued(nilfs
)) {
2199 nilfs_transaction_unlock(sb
);
2200 err
= nilfs_segctor_sync(sci
);
2204 spin_lock(&nilfs
->ns_inode_lock
);
2205 if (!test_bit(NILFS_I_QUEUED
, &ii
->i_state
) &&
2206 !test_bit(NILFS_I_BUSY
, &ii
->i_state
)) {
2207 spin_unlock(&nilfs
->ns_inode_lock
);
2208 nilfs_transaction_unlock(sb
);
2211 spin_unlock(&nilfs
->ns_inode_lock
);
2212 sci
->sc_dsync_inode
= ii
;
2213 sci
->sc_dsync_start
= start
;
2214 sci
->sc_dsync_end
= end
;
2216 err
= nilfs_segctor_do_construct(sci
, SC_LSEG_DSYNC
);
2218 nilfs_transaction_unlock(sb
);
2222 #define FLUSH_FILE_BIT (0x1) /* data file only */
2223 #define FLUSH_DAT_BIT (1 << NILFS_DAT_INO) /* DAT only */
2226 * nilfs_segctor_accept - record accepted sequence count of log-write requests
2227 * @sci: segment constructor object
2229 static void nilfs_segctor_accept(struct nilfs_sc_info
*sci
)
2231 spin_lock(&sci
->sc_state_lock
);
2232 sci
->sc_seq_accepted
= sci
->sc_seq_request
;
2233 spin_unlock(&sci
->sc_state_lock
);
2234 del_timer_sync(&sci
->sc_timer
);
2238 * nilfs_segctor_notify - notify the result of request to caller threads
2239 * @sci: segment constructor object
2240 * @mode: mode of log forming
2241 * @err: error code to be notified
2243 static void nilfs_segctor_notify(struct nilfs_sc_info
*sci
, int mode
, int err
)
2245 /* Clear requests (even when the construction failed) */
2246 spin_lock(&sci
->sc_state_lock
);
2248 if (mode
== SC_LSEG_SR
) {
2249 sci
->sc_state
&= ~NILFS_SEGCTOR_COMMIT
;
2250 sci
->sc_seq_done
= sci
->sc_seq_accepted
;
2251 nilfs_segctor_wakeup(sci
, err
);
2252 sci
->sc_flush_request
= 0;
2254 if (mode
== SC_FLUSH_FILE
)
2255 sci
->sc_flush_request
&= ~FLUSH_FILE_BIT
;
2256 else if (mode
== SC_FLUSH_DAT
)
2257 sci
->sc_flush_request
&= ~FLUSH_DAT_BIT
;
2259 /* re-enable timer if checkpoint creation was not done */
2260 if ((sci
->sc_state
& NILFS_SEGCTOR_COMMIT
) &&
2261 time_before(jiffies
, sci
->sc_timer
.expires
))
2262 add_timer(&sci
->sc_timer
);
2264 spin_unlock(&sci
->sc_state_lock
);
2268 * nilfs_segctor_construct - form logs and write them to disk
2269 * @sci: segment constructor object
2270 * @mode: mode of log forming
2272 static int nilfs_segctor_construct(struct nilfs_sc_info
*sci
, int mode
)
2274 struct the_nilfs
*nilfs
= sci
->sc_super
->s_fs_info
;
2275 struct nilfs_super_block
**sbp
;
2278 nilfs_segctor_accept(sci
);
2280 if (nilfs_discontinued(nilfs
))
2282 if (!nilfs_segctor_confirm(sci
))
2283 err
= nilfs_segctor_do_construct(sci
, mode
);
2286 if (mode
!= SC_FLUSH_DAT
)
2287 atomic_set(&nilfs
->ns_ndirtyblks
, 0);
2288 if (test_bit(NILFS_SC_SUPER_ROOT
, &sci
->sc_flags
) &&
2289 nilfs_discontinued(nilfs
)) {
2290 down_write(&nilfs
->ns_sem
);
2292 sbp
= nilfs_prepare_super(sci
->sc_super
,
2293 nilfs_sb_will_flip(nilfs
));
2295 nilfs_set_log_cursor(sbp
[0], nilfs
);
2296 err
= nilfs_commit_super(sci
->sc_super
,
2299 up_write(&nilfs
->ns_sem
);
2303 nilfs_segctor_notify(sci
, mode
, err
);
2307 static void nilfs_construction_timeout(unsigned long data
)
2309 struct task_struct
*p
= (struct task_struct
*)data
;
2314 nilfs_remove_written_gcinodes(struct the_nilfs
*nilfs
, struct list_head
*head
)
2316 struct nilfs_inode_info
*ii
, *n
;
2318 list_for_each_entry_safe(ii
, n
, head
, i_dirty
) {
2319 if (!test_bit(NILFS_I_UPDATED
, &ii
->i_state
))
2321 list_del_init(&ii
->i_dirty
);
2322 truncate_inode_pages(&ii
->vfs_inode
.i_data
, 0);
2323 nilfs_btnode_cache_clear(&ii
->i_btnode_cache
);
2324 iput(&ii
->vfs_inode
);
2328 int nilfs_clean_segments(struct super_block
*sb
, struct nilfs_argv
*argv
,
2331 struct the_nilfs
*nilfs
= sb
->s_fs_info
;
2332 struct nilfs_sc_info
*sci
= nilfs
->ns_writer
;
2333 struct nilfs_transaction_info ti
;
2339 nilfs_transaction_lock(sb
, &ti
, 1);
2341 err
= nilfs_mdt_save_to_shadow_map(nilfs
->ns_dat
);
2345 err
= nilfs_ioctl_prepare_clean_segments(nilfs
, argv
, kbufs
);
2346 if (unlikely(err
)) {
2347 nilfs_mdt_restore_from_shadow_map(nilfs
->ns_dat
);
2351 sci
->sc_freesegs
= kbufs
[4];
2352 sci
->sc_nfreesegs
= argv
[4].v_nmembs
;
2353 list_splice_tail_init(&nilfs
->ns_gc_inodes
, &sci
->sc_gc_inodes
);
2356 err
= nilfs_segctor_construct(sci
, SC_LSEG_SR
);
2357 nilfs_remove_written_gcinodes(nilfs
, &sci
->sc_gc_inodes
);
2362 nilfs_warning(sb
, __func__
,
2363 "segment construction failed. (err=%d)", err
);
2364 set_current_state(TASK_INTERRUPTIBLE
);
2365 schedule_timeout(sci
->sc_interval
);
2367 if (nilfs_test_opt(nilfs
, DISCARD
)) {
2368 int ret
= nilfs_discard_segments(nilfs
, sci
->sc_freesegs
,
2372 "NILFS warning: error %d on discard request, "
2373 "turning discards off for the device\n", ret
);
2374 nilfs_clear_opt(nilfs
, DISCARD
);
2379 sci
->sc_freesegs
= NULL
;
2380 sci
->sc_nfreesegs
= 0;
2381 nilfs_mdt_clear_shadow_map(nilfs
->ns_dat
);
2382 nilfs_transaction_unlock(sb
);
2386 static void nilfs_segctor_thread_construct(struct nilfs_sc_info
*sci
, int mode
)
2388 struct nilfs_transaction_info ti
;
2390 nilfs_transaction_lock(sci
->sc_super
, &ti
, 0);
2391 nilfs_segctor_construct(sci
, mode
);
2394 * Unclosed segment should be retried. We do this using sc_timer.
2395 * Timeout of sc_timer will invoke complete construction which leads
2396 * to close the current logical segment.
2398 if (test_bit(NILFS_SC_UNCLOSED
, &sci
->sc_flags
))
2399 nilfs_segctor_start_timer(sci
);
2401 nilfs_transaction_unlock(sci
->sc_super
);
2404 static void nilfs_segctor_do_immediate_flush(struct nilfs_sc_info
*sci
)
2409 spin_lock(&sci
->sc_state_lock
);
2410 mode
= (sci
->sc_flush_request
& FLUSH_DAT_BIT
) ?
2411 SC_FLUSH_DAT
: SC_FLUSH_FILE
;
2412 spin_unlock(&sci
->sc_state_lock
);
2415 err
= nilfs_segctor_do_construct(sci
, mode
);
2417 spin_lock(&sci
->sc_state_lock
);
2418 sci
->sc_flush_request
&= (mode
== SC_FLUSH_FILE
) ?
2419 ~FLUSH_FILE_BIT
: ~FLUSH_DAT_BIT
;
2420 spin_unlock(&sci
->sc_state_lock
);
2422 clear_bit(NILFS_SC_PRIOR_FLUSH
, &sci
->sc_flags
);
2425 static int nilfs_segctor_flush_mode(struct nilfs_sc_info
*sci
)
2427 if (!test_bit(NILFS_SC_UNCLOSED
, &sci
->sc_flags
) ||
2428 time_before(jiffies
, sci
->sc_lseg_stime
+ sci
->sc_mjcp_freq
)) {
2429 if (!(sci
->sc_flush_request
& ~FLUSH_FILE_BIT
))
2430 return SC_FLUSH_FILE
;
2431 else if (!(sci
->sc_flush_request
& ~FLUSH_DAT_BIT
))
2432 return SC_FLUSH_DAT
;
2438 * nilfs_segctor_thread - main loop of the segment constructor thread.
2439 * @arg: pointer to a struct nilfs_sc_info.
2441 * nilfs_segctor_thread() initializes a timer and serves as a daemon
2442 * to execute segment constructions.
2444 static int nilfs_segctor_thread(void *arg
)
2446 struct nilfs_sc_info
*sci
= (struct nilfs_sc_info
*)arg
;
2447 struct the_nilfs
*nilfs
= sci
->sc_super
->s_fs_info
;
2450 sci
->sc_timer
.data
= (unsigned long)current
;
2451 sci
->sc_timer
.function
= nilfs_construction_timeout
;
2454 sci
->sc_task
= current
;
2455 wake_up(&sci
->sc_wait_task
); /* for nilfs_segctor_start_thread() */
2457 "segctord starting. Construction interval = %lu seconds, "
2458 "CP frequency < %lu seconds\n",
2459 sci
->sc_interval
/ HZ
, sci
->sc_mjcp_freq
/ HZ
);
2461 spin_lock(&sci
->sc_state_lock
);
2466 if (sci
->sc_state
& NILFS_SEGCTOR_QUIT
)
2469 if (timeout
|| sci
->sc_seq_request
!= sci
->sc_seq_done
)
2471 else if (!sci
->sc_flush_request
)
2474 mode
= nilfs_segctor_flush_mode(sci
);
2476 spin_unlock(&sci
->sc_state_lock
);
2477 nilfs_segctor_thread_construct(sci
, mode
);
2478 spin_lock(&sci
->sc_state_lock
);
2483 if (freezing(current
)) {
2484 spin_unlock(&sci
->sc_state_lock
);
2486 spin_lock(&sci
->sc_state_lock
);
2489 int should_sleep
= 1;
2491 prepare_to_wait(&sci
->sc_wait_daemon
, &wait
,
2492 TASK_INTERRUPTIBLE
);
2494 if (sci
->sc_seq_request
!= sci
->sc_seq_done
)
2496 else if (sci
->sc_flush_request
)
2498 else if (sci
->sc_state
& NILFS_SEGCTOR_COMMIT
)
2499 should_sleep
= time_before(jiffies
,
2500 sci
->sc_timer
.expires
);
2503 spin_unlock(&sci
->sc_state_lock
);
2505 spin_lock(&sci
->sc_state_lock
);
2507 finish_wait(&sci
->sc_wait_daemon
, &wait
);
2508 timeout
= ((sci
->sc_state
& NILFS_SEGCTOR_COMMIT
) &&
2509 time_after_eq(jiffies
, sci
->sc_timer
.expires
));
2511 if (nilfs_sb_dirty(nilfs
) && nilfs_sb_need_update(nilfs
))
2512 set_nilfs_discontinued(nilfs
);
2517 spin_unlock(&sci
->sc_state_lock
);
2520 sci
->sc_task
= NULL
;
2521 wake_up(&sci
->sc_wait_task
); /* for nilfs_segctor_kill_thread() */
2525 static int nilfs_segctor_start_thread(struct nilfs_sc_info
*sci
)
2527 struct task_struct
*t
;
2529 t
= kthread_run(nilfs_segctor_thread
, sci
, "segctord");
2531 int err
= PTR_ERR(t
);
2533 printk(KERN_ERR
"NILFS: error %d creating segctord thread\n",
2537 wait_event(sci
->sc_wait_task
, sci
->sc_task
!= NULL
);
2541 static void nilfs_segctor_kill_thread(struct nilfs_sc_info
*sci
)
2542 __acquires(&sci
->sc_state_lock
)
2543 __releases(&sci
->sc_state_lock
)
2545 sci
->sc_state
|= NILFS_SEGCTOR_QUIT
;
2547 while (sci
->sc_task
) {
2548 wake_up(&sci
->sc_wait_daemon
);
2549 spin_unlock(&sci
->sc_state_lock
);
2550 wait_event(sci
->sc_wait_task
, sci
->sc_task
== NULL
);
2551 spin_lock(&sci
->sc_state_lock
);
2556 * Setup & clean-up functions
2558 static struct nilfs_sc_info
*nilfs_segctor_new(struct super_block
*sb
,
2559 struct nilfs_root
*root
)
2561 struct the_nilfs
*nilfs
= sb
->s_fs_info
;
2562 struct nilfs_sc_info
*sci
;
2564 sci
= kzalloc(sizeof(*sci
), GFP_KERNEL
);
2570 nilfs_get_root(root
);
2571 sci
->sc_root
= root
;
2573 init_waitqueue_head(&sci
->sc_wait_request
);
2574 init_waitqueue_head(&sci
->sc_wait_daemon
);
2575 init_waitqueue_head(&sci
->sc_wait_task
);
2576 spin_lock_init(&sci
->sc_state_lock
);
2577 INIT_LIST_HEAD(&sci
->sc_dirty_files
);
2578 INIT_LIST_HEAD(&sci
->sc_segbufs
);
2579 INIT_LIST_HEAD(&sci
->sc_write_logs
);
2580 INIT_LIST_HEAD(&sci
->sc_gc_inodes
);
2581 init_timer(&sci
->sc_timer
);
2583 sci
->sc_interval
= HZ
* NILFS_SC_DEFAULT_TIMEOUT
;
2584 sci
->sc_mjcp_freq
= HZ
* NILFS_SC_DEFAULT_SR_FREQ
;
2585 sci
->sc_watermark
= NILFS_SC_DEFAULT_WATERMARK
;
2587 if (nilfs
->ns_interval
)
2588 sci
->sc_interval
= HZ
* nilfs
->ns_interval
;
2589 if (nilfs
->ns_watermark
)
2590 sci
->sc_watermark
= nilfs
->ns_watermark
;
2594 static void nilfs_segctor_write_out(struct nilfs_sc_info
*sci
)
2596 int ret
, retrycount
= NILFS_SC_CLEANUP_RETRY
;
2598 /* The segctord thread was stopped and its timer was removed.
2599 But some tasks remain. */
2601 struct nilfs_transaction_info ti
;
2603 nilfs_transaction_lock(sci
->sc_super
, &ti
, 0);
2604 ret
= nilfs_segctor_construct(sci
, SC_LSEG_SR
);
2605 nilfs_transaction_unlock(sci
->sc_super
);
2607 } while (ret
&& retrycount
-- > 0);
2611 * nilfs_segctor_destroy - destroy the segment constructor.
2612 * @sci: nilfs_sc_info
2614 * nilfs_segctor_destroy() kills the segctord thread and frees
2615 * the nilfs_sc_info struct.
2616 * Caller must hold the segment semaphore.
2618 static void nilfs_segctor_destroy(struct nilfs_sc_info
*sci
)
2620 struct the_nilfs
*nilfs
= sci
->sc_super
->s_fs_info
;
2623 up_write(&nilfs
->ns_segctor_sem
);
2625 spin_lock(&sci
->sc_state_lock
);
2626 nilfs_segctor_kill_thread(sci
);
2627 flag
= ((sci
->sc_state
& NILFS_SEGCTOR_COMMIT
) || sci
->sc_flush_request
2628 || sci
->sc_seq_request
!= sci
->sc_seq_done
);
2629 spin_unlock(&sci
->sc_state_lock
);
2631 if (flag
|| !nilfs_segctor_confirm(sci
))
2632 nilfs_segctor_write_out(sci
);
2634 if (!list_empty(&sci
->sc_dirty_files
)) {
2635 nilfs_warning(sci
->sc_super
, __func__
,
2636 "dirty file(s) after the final construction\n");
2637 nilfs_dispose_list(nilfs
, &sci
->sc_dirty_files
, 1);
2640 WARN_ON(!list_empty(&sci
->sc_segbufs
));
2641 WARN_ON(!list_empty(&sci
->sc_write_logs
));
2643 nilfs_put_root(sci
->sc_root
);
2645 down_write(&nilfs
->ns_segctor_sem
);
2647 del_timer_sync(&sci
->sc_timer
);
2652 * nilfs_attach_log_writer - attach log writer
2653 * @sb: super block instance
2654 * @root: root object of the current filesystem tree
2656 * This allocates a log writer object, initializes it, and starts the
2659 * Return Value: On success, 0 is returned. On error, one of the following
2660 * negative error code is returned.
2662 * %-ENOMEM - Insufficient memory available.
2664 int nilfs_attach_log_writer(struct super_block
*sb
, struct nilfs_root
*root
)
2666 struct the_nilfs
*nilfs
= sb
->s_fs_info
;
2669 if (nilfs
->ns_writer
) {
2671 * This happens if the filesystem was remounted
2672 * read/write after nilfs_error degenerated it into a
2675 nilfs_detach_log_writer(sb
);
2678 nilfs
->ns_writer
= nilfs_segctor_new(sb
, root
);
2679 if (!nilfs
->ns_writer
)
2682 err
= nilfs_segctor_start_thread(nilfs
->ns_writer
);
2684 kfree(nilfs
->ns_writer
);
2685 nilfs
->ns_writer
= NULL
;
2691 * nilfs_detach_log_writer - destroy log writer
2692 * @sb: super block instance
2694 * This kills log writer daemon, frees the log writer object, and
2695 * destroys list of dirty files.
2697 void nilfs_detach_log_writer(struct super_block
*sb
)
2699 struct the_nilfs
*nilfs
= sb
->s_fs_info
;
2700 LIST_HEAD(garbage_list
);
2702 down_write(&nilfs
->ns_segctor_sem
);
2703 if (nilfs
->ns_writer
) {
2704 nilfs_segctor_destroy(nilfs
->ns_writer
);
2705 nilfs
->ns_writer
= NULL
;
2708 /* Force to free the list of dirty files */
2709 spin_lock(&nilfs
->ns_inode_lock
);
2710 if (!list_empty(&nilfs
->ns_dirty_files
)) {
2711 list_splice_init(&nilfs
->ns_dirty_files
, &garbage_list
);
2712 nilfs_warning(sb
, __func__
,
2713 "Hit dirty file after stopped log writer\n");
2715 spin_unlock(&nilfs
->ns_inode_lock
);
2716 up_write(&nilfs
->ns_segctor_sem
);
2718 nilfs_dispose_list(nilfs
, &garbage_list
, 1);