2 * segbuf.c - NILFS segment buffer
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/buffer_head.h>
25 #include <linux/writeback.h>
26 #include <linux/crc32.h>
27 #include <linux/backing-dev.h>
32 struct nilfs_write_info
{
33 struct the_nilfs
*nilfs
;
35 int start
, end
; /* The region to be submitted */
43 static int nilfs_segbuf_write(struct nilfs_segment_buffer
*segbuf
,
44 struct the_nilfs
*nilfs
);
45 static int nilfs_segbuf_wait(struct nilfs_segment_buffer
*segbuf
);
48 static struct kmem_cache
*nilfs_segbuf_cachep
;
50 static void nilfs_segbuf_init_once(void *obj
)
52 memset(obj
, 0, sizeof(struct nilfs_segment_buffer
));
55 int __init
nilfs_init_segbuf_cache(void)
58 kmem_cache_create("nilfs2_segbuf_cache",
59 sizeof(struct nilfs_segment_buffer
),
60 0, SLAB_RECLAIM_ACCOUNT
,
61 nilfs_segbuf_init_once
);
63 return (nilfs_segbuf_cachep
== NULL
) ? -ENOMEM
: 0;
66 void nilfs_destroy_segbuf_cache(void)
68 kmem_cache_destroy(nilfs_segbuf_cachep
);
71 struct nilfs_segment_buffer
*nilfs_segbuf_new(struct super_block
*sb
)
73 struct nilfs_segment_buffer
*segbuf
;
75 segbuf
= kmem_cache_alloc(nilfs_segbuf_cachep
, GFP_NOFS
);
76 if (unlikely(!segbuf
))
79 segbuf
->sb_super
= sb
;
80 INIT_LIST_HEAD(&segbuf
->sb_list
);
81 INIT_LIST_HEAD(&segbuf
->sb_segsum_buffers
);
82 INIT_LIST_HEAD(&segbuf
->sb_payload_buffers
);
84 init_completion(&segbuf
->sb_bio_event
);
85 atomic_set(&segbuf
->sb_err
, 0);
91 void nilfs_segbuf_free(struct nilfs_segment_buffer
*segbuf
)
93 kmem_cache_free(nilfs_segbuf_cachep
, segbuf
);
96 void nilfs_segbuf_map(struct nilfs_segment_buffer
*segbuf
, __u64 segnum
,
97 unsigned long offset
, struct the_nilfs
*nilfs
)
99 segbuf
->sb_segnum
= segnum
;
100 nilfs_get_segment_range(nilfs
, segnum
, &segbuf
->sb_fseg_start
,
101 &segbuf
->sb_fseg_end
);
103 segbuf
->sb_pseg_start
= segbuf
->sb_fseg_start
+ offset
;
104 segbuf
->sb_rest_blocks
=
105 segbuf
->sb_fseg_end
- segbuf
->sb_pseg_start
+ 1;
109 * nilfs_segbuf_map_cont - map a new log behind a given log
110 * @segbuf: new segment buffer
111 * @prev: segment buffer containing a log to be continued
113 void nilfs_segbuf_map_cont(struct nilfs_segment_buffer
*segbuf
,
114 struct nilfs_segment_buffer
*prev
)
116 segbuf
->sb_segnum
= prev
->sb_segnum
;
117 segbuf
->sb_fseg_start
= prev
->sb_fseg_start
;
118 segbuf
->sb_fseg_end
= prev
->sb_fseg_end
;
119 segbuf
->sb_pseg_start
= prev
->sb_pseg_start
+ prev
->sb_sum
.nblocks
;
120 segbuf
->sb_rest_blocks
=
121 segbuf
->sb_fseg_end
- segbuf
->sb_pseg_start
+ 1;
124 void nilfs_segbuf_set_next_segnum(struct nilfs_segment_buffer
*segbuf
,
125 __u64 nextnum
, struct the_nilfs
*nilfs
)
127 segbuf
->sb_nextnum
= nextnum
;
128 segbuf
->sb_sum
.next
= nilfs_get_segment_start_blocknr(nilfs
, nextnum
);
131 int nilfs_segbuf_extend_segsum(struct nilfs_segment_buffer
*segbuf
)
133 struct buffer_head
*bh
;
135 bh
= sb_getblk(segbuf
->sb_super
,
136 segbuf
->sb_pseg_start
+ segbuf
->sb_sum
.nsumblk
);
140 nilfs_segbuf_add_segsum_buffer(segbuf
, bh
);
144 int nilfs_segbuf_extend_payload(struct nilfs_segment_buffer
*segbuf
,
145 struct buffer_head
**bhp
)
147 struct buffer_head
*bh
;
149 bh
= sb_getblk(segbuf
->sb_super
,
150 segbuf
->sb_pseg_start
+ segbuf
->sb_sum
.nblocks
);
154 nilfs_segbuf_add_payload_buffer(segbuf
, bh
);
159 int nilfs_segbuf_reset(struct nilfs_segment_buffer
*segbuf
, unsigned flags
,
164 segbuf
->sb_sum
.nblocks
= segbuf
->sb_sum
.nsumblk
= 0;
165 err
= nilfs_segbuf_extend_segsum(segbuf
);
169 segbuf
->sb_sum
.flags
= flags
;
170 segbuf
->sb_sum
.sumbytes
= sizeof(struct nilfs_segment_summary
);
171 segbuf
->sb_sum
.nfinfo
= segbuf
->sb_sum
.nfileblk
= 0;
172 segbuf
->sb_sum
.ctime
= ctime
;
177 * Setup segment summary
179 void nilfs_segbuf_fill_in_segsum(struct nilfs_segment_buffer
*segbuf
)
181 struct nilfs_segment_summary
*raw_sum
;
182 struct buffer_head
*bh_sum
;
184 bh_sum
= list_entry(segbuf
->sb_segsum_buffers
.next
,
185 struct buffer_head
, b_assoc_buffers
);
186 raw_sum
= (struct nilfs_segment_summary
*)bh_sum
->b_data
;
188 raw_sum
->ss_magic
= cpu_to_le32(NILFS_SEGSUM_MAGIC
);
189 raw_sum
->ss_bytes
= cpu_to_le16(sizeof(*raw_sum
));
190 raw_sum
->ss_flags
= cpu_to_le16(segbuf
->sb_sum
.flags
);
191 raw_sum
->ss_seq
= cpu_to_le64(segbuf
->sb_sum
.seg_seq
);
192 raw_sum
->ss_create
= cpu_to_le64(segbuf
->sb_sum
.ctime
);
193 raw_sum
->ss_next
= cpu_to_le64(segbuf
->sb_sum
.next
);
194 raw_sum
->ss_nblocks
= cpu_to_le32(segbuf
->sb_sum
.nblocks
);
195 raw_sum
->ss_nfinfo
= cpu_to_le32(segbuf
->sb_sum
.nfinfo
);
196 raw_sum
->ss_sumbytes
= cpu_to_le32(segbuf
->sb_sum
.sumbytes
);
201 * CRC calculation routines
203 void nilfs_segbuf_fill_in_segsum_crc(struct nilfs_segment_buffer
*segbuf
,
206 struct buffer_head
*bh
;
207 struct nilfs_segment_summary
*raw_sum
;
208 unsigned long size
, bytes
= segbuf
->sb_sum
.sumbytes
;
211 bh
= list_entry(segbuf
->sb_segsum_buffers
.next
, struct buffer_head
,
214 raw_sum
= (struct nilfs_segment_summary
*)bh
->b_data
;
215 size
= min_t(unsigned long, bytes
, bh
->b_size
);
217 (unsigned char *)raw_sum
+
218 sizeof(raw_sum
->ss_datasum
) + sizeof(raw_sum
->ss_sumsum
),
219 size
- (sizeof(raw_sum
->ss_datasum
) +
220 sizeof(raw_sum
->ss_sumsum
)));
222 list_for_each_entry_continue(bh
, &segbuf
->sb_segsum_buffers
,
225 size
= min_t(unsigned long, bytes
, bh
->b_size
);
226 crc
= crc32_le(crc
, bh
->b_data
, size
);
228 raw_sum
->ss_sumsum
= cpu_to_le32(crc
);
231 void nilfs_segbuf_fill_in_data_crc(struct nilfs_segment_buffer
*segbuf
,
234 struct buffer_head
*bh
;
235 struct nilfs_segment_summary
*raw_sum
;
239 bh
= list_entry(segbuf
->sb_segsum_buffers
.next
, struct buffer_head
,
241 raw_sum
= (struct nilfs_segment_summary
*)bh
->b_data
;
243 (unsigned char *)raw_sum
+ sizeof(raw_sum
->ss_datasum
),
244 bh
->b_size
- sizeof(raw_sum
->ss_datasum
));
246 list_for_each_entry_continue(bh
, &segbuf
->sb_segsum_buffers
,
248 crc
= crc32_le(crc
, bh
->b_data
, bh
->b_size
);
250 list_for_each_entry(bh
, &segbuf
->sb_payload_buffers
, b_assoc_buffers
) {
251 kaddr
= kmap_atomic(bh
->b_page
, KM_USER0
);
252 crc
= crc32_le(crc
, kaddr
+ bh_offset(bh
), bh
->b_size
);
253 kunmap_atomic(kaddr
, KM_USER0
);
255 raw_sum
->ss_datasum
= cpu_to_le32(crc
);
258 static void nilfs_release_buffers(struct list_head
*list
)
260 struct buffer_head
*bh
, *n
;
262 list_for_each_entry_safe(bh
, n
, list
, b_assoc_buffers
) {
263 list_del_init(&bh
->b_assoc_buffers
);
264 if (buffer_nilfs_allocated(bh
)) {
265 struct page
*clone_page
= bh
->b_page
;
267 /* remove clone page */
269 page_cache_release(clone_page
); /* for each bh */
270 if (page_count(clone_page
) <= 2) {
271 lock_page(clone_page
);
272 nilfs_free_private_page(clone_page
);
280 static void nilfs_segbuf_clear(struct nilfs_segment_buffer
*segbuf
)
282 nilfs_release_buffers(&segbuf
->sb_segsum_buffers
);
283 nilfs_release_buffers(&segbuf
->sb_payload_buffers
);
287 * Iterators for segment buffers
289 void nilfs_clear_logs(struct list_head
*logs
)
291 struct nilfs_segment_buffer
*segbuf
;
293 list_for_each_entry(segbuf
, logs
, sb_list
)
294 nilfs_segbuf_clear(segbuf
);
297 void nilfs_truncate_logs(struct list_head
*logs
,
298 struct nilfs_segment_buffer
*last
)
300 struct nilfs_segment_buffer
*n
, *segbuf
;
302 segbuf
= list_prepare_entry(last
, logs
, sb_list
);
303 list_for_each_entry_safe_continue(segbuf
, n
, logs
, sb_list
) {
304 list_del_init(&segbuf
->sb_list
);
305 nilfs_segbuf_clear(segbuf
);
306 nilfs_segbuf_free(segbuf
);
310 int nilfs_write_logs(struct list_head
*logs
, struct the_nilfs
*nilfs
)
312 struct nilfs_segment_buffer
*segbuf
;
315 list_for_each_entry(segbuf
, logs
, sb_list
) {
316 ret
= nilfs_segbuf_write(segbuf
, nilfs
);
323 int nilfs_wait_on_logs(struct list_head
*logs
)
325 struct nilfs_segment_buffer
*segbuf
;
328 list_for_each_entry(segbuf
, logs
, sb_list
) {
329 err
= nilfs_segbuf_wait(segbuf
);
339 static void nilfs_end_bio_write(struct bio
*bio
, int err
)
341 const int uptodate
= test_bit(BIO_UPTODATE
, &bio
->bi_flags
);
342 struct nilfs_segment_buffer
*segbuf
= bio
->bi_private
;
344 if (err
== -EOPNOTSUPP
) {
345 set_bit(BIO_EOPNOTSUPP
, &bio
->bi_flags
);
347 /* to be detected by submit_seg_bio() */
351 atomic_inc(&segbuf
->sb_err
);
354 complete(&segbuf
->sb_bio_event
);
357 static int nilfs_segbuf_submit_bio(struct nilfs_segment_buffer
*segbuf
,
358 struct nilfs_write_info
*wi
, int mode
)
360 struct bio
*bio
= wi
->bio
;
363 if (segbuf
->sb_nbio
> 0 && bdi_write_congested(wi
->nilfs
->ns_bdi
)) {
364 wait_for_completion(&segbuf
->sb_bio_event
);
366 if (unlikely(atomic_read(&segbuf
->sb_err
))) {
373 bio
->bi_end_io
= nilfs_end_bio_write
;
374 bio
->bi_private
= segbuf
;
376 submit_bio(mode
, bio
);
377 if (bio_flagged(bio
, BIO_EOPNOTSUPP
)) {
386 wi
->rest_blocks
-= wi
->end
- wi
->start
;
387 wi
->nr_vecs
= min(wi
->max_pages
, wi
->rest_blocks
);
397 * nilfs_alloc_seg_bio - allocate a new bio for writing log
398 * @nilfs: nilfs object
399 * @start: start block number of the bio
400 * @nr_vecs: request size of page vector.
402 * Return Value: On success, pointer to the struct bio is returned.
403 * On error, NULL is returned.
405 static struct bio
*nilfs_alloc_seg_bio(struct the_nilfs
*nilfs
, sector_t start
,
410 bio
= bio_alloc(GFP_NOIO
, nr_vecs
);
412 while (!bio
&& (nr_vecs
>>= 1))
413 bio
= bio_alloc(GFP_NOIO
, nr_vecs
);
416 bio
->bi_bdev
= nilfs
->ns_bdev
;
417 bio
->bi_sector
= start
<< (nilfs
->ns_blocksize_bits
- 9);
422 static void nilfs_segbuf_prepare_write(struct nilfs_segment_buffer
*segbuf
,
423 struct nilfs_write_info
*wi
)
426 wi
->rest_blocks
= segbuf
->sb_sum
.nblocks
;
427 wi
->max_pages
= bio_get_nr_vecs(wi
->nilfs
->ns_bdev
);
428 wi
->nr_vecs
= min(wi
->max_pages
, wi
->rest_blocks
);
429 wi
->start
= wi
->end
= 0;
430 wi
->blocknr
= segbuf
->sb_pseg_start
;
433 static int nilfs_segbuf_submit_bh(struct nilfs_segment_buffer
*segbuf
,
434 struct nilfs_write_info
*wi
,
435 struct buffer_head
*bh
, int mode
)
439 BUG_ON(wi
->nr_vecs
<= 0);
442 wi
->bio
= nilfs_alloc_seg_bio(wi
->nilfs
, wi
->blocknr
+ wi
->end
,
444 if (unlikely(!wi
->bio
))
448 len
= bio_add_page(wi
->bio
, bh
->b_page
, bh
->b_size
, bh_offset(bh
));
449 if (len
== bh
->b_size
) {
454 err
= nilfs_segbuf_submit_bio(segbuf
, wi
, mode
);
455 /* never submit current bh */
462 * nilfs_segbuf_write - submit write requests of a log
463 * @segbuf: buffer storing a log to be written
464 * @nilfs: nilfs object
466 * Return Value: On Success, 0 is returned. On Error, one of the following
467 * negative error code is returned.
471 * %-ENOMEM - Insufficient memory available.
473 static int nilfs_segbuf_write(struct nilfs_segment_buffer
*segbuf
,
474 struct the_nilfs
*nilfs
)
476 struct nilfs_write_info wi
;
477 struct buffer_head
*bh
;
478 int res
= 0, rw
= WRITE
;
481 nilfs_segbuf_prepare_write(segbuf
, &wi
);
483 list_for_each_entry(bh
, &segbuf
->sb_segsum_buffers
, b_assoc_buffers
) {
484 res
= nilfs_segbuf_submit_bh(segbuf
, &wi
, bh
, rw
);
489 list_for_each_entry(bh
, &segbuf
->sb_payload_buffers
, b_assoc_buffers
) {
490 res
= nilfs_segbuf_submit_bh(segbuf
, &wi
, bh
, rw
);
497 * Last BIO is always sent through the following
500 rw
|= (1 << BIO_RW_SYNCIO
) | (1 << BIO_RW_UNPLUG
);
501 res
= nilfs_segbuf_submit_bio(segbuf
, &wi
, rw
);
509 * nilfs_segbuf_wait - wait for completion of requested BIOs
510 * @segbuf: segment buffer
512 * Return Value: On Success, 0 is returned. On Error, one of the following
513 * negative error code is returned.
517 static int nilfs_segbuf_wait(struct nilfs_segment_buffer
*segbuf
)
521 if (!segbuf
->sb_nbio
)
525 wait_for_completion(&segbuf
->sb_bio_event
);
526 } while (--segbuf
->sb_nbio
> 0);
528 if (unlikely(atomic_read(&segbuf
->sb_err
) > 0)) {
529 printk(KERN_ERR
"NILFS: IO error writing segment\n");