2 * fs/logfs/segment.c - Handling the Object Store
4 * As should be obvious for Linux kernel code, license is GPLv2
6 * Copyright (c) 2005-2008 Joern Engel <joern@logfs.org>
8 * Object store or ostore makes up the complete device with exception of
9 * the superblock and journal areas. Apart from its own metadata it stores
10 * three kinds of objects: inodes, dentries and blocks, both data and indirect.
13 #include <linux/slab.h>
15 static int logfs_mark_segment_bad(struct super_block
*sb
, u32 segno
)
17 struct logfs_super
*super
= logfs_super(sb
);
18 struct btree_head32
*head
= &super
->s_reserved_segments
;
21 err
= btree_insert32(head
, segno
, (void *)1, GFP_NOFS
);
24 logfs_super(sb
)->s_bad_segments
++;
25 /* FIXME: write to journal */
29 int logfs_erase_segment(struct super_block
*sb
, u32 segno
, int ensure_erase
)
31 struct logfs_super
*super
= logfs_super(sb
);
35 return super
->s_devops
->erase(sb
, (u64
)segno
<< super
->s_segshift
,
36 super
->s_segsize
, ensure_erase
);
39 static s64
logfs_get_free_bytes(struct logfs_area
*area
, size_t bytes
)
43 logfs_open_area(area
, bytes
);
45 ofs
= area
->a_used_bytes
;
46 area
->a_used_bytes
+= bytes
;
47 BUG_ON(area
->a_used_bytes
>= logfs_super(area
->a_sb
)->s_segsize
);
49 return dev_ofs(area
->a_sb
, area
->a_segno
, ofs
);
52 static struct page
*get_mapping_page(struct super_block
*sb
, pgoff_t index
,
55 struct logfs_super
*super
= logfs_super(sb
);
56 struct address_space
*mapping
= super
->s_mapping_inode
->i_mapping
;
57 filler_t
*filler
= super
->s_devops
->readpage
;
60 BUG_ON(mapping_gfp_mask(mapping
) & __GFP_FS
);
62 page
= read_cache_page(mapping
, index
, filler
, sb
);
64 page
= find_or_create_page(mapping
, index
, GFP_NOFS
);
70 void __logfs_buf_write(struct logfs_area
*area
, u64 ofs
, void *buf
, size_t len
,
73 pgoff_t index
= ofs
>> PAGE_SHIFT
;
75 long offset
= ofs
& (PAGE_SIZE
-1);
78 /* Only logfs_wbuf_recover may use len==0 */
79 BUG_ON(!len
&& !use_filler
);
81 copylen
= min((ulong
)len
, PAGE_SIZE
- offset
);
83 page
= get_mapping_page(area
->a_sb
, index
, use_filler
);
84 SetPageUptodate(page
);
85 BUG_ON(!page
); /* FIXME: reserve a pool */
86 memcpy(page_address(page
) + offset
, buf
, copylen
);
88 page_cache_release(page
);
97 static void pad_partial_page(struct logfs_area
*area
)
99 struct super_block
*sb
= area
->a_sb
;
101 u64 ofs
= dev_ofs(sb
, area
->a_segno
, area
->a_used_bytes
);
102 pgoff_t index
= ofs
>> PAGE_SHIFT
;
103 long offset
= ofs
& (PAGE_SIZE
-1);
104 u32 len
= PAGE_SIZE
- offset
;
106 if (len
% PAGE_SIZE
) {
107 page
= get_mapping_page(sb
, index
, 0);
108 BUG_ON(!page
); /* FIXME: reserve a pool */
109 memset(page_address(page
) + offset
, 0xff, len
);
110 SetPagePrivate(page
);
111 page_cache_release(page
);
115 static void pad_full_pages(struct logfs_area
*area
)
117 struct super_block
*sb
= area
->a_sb
;
118 struct logfs_super
*super
= logfs_super(sb
);
119 u64 ofs
= dev_ofs(sb
, area
->a_segno
, area
->a_used_bytes
);
120 u32 len
= super
->s_segsize
- area
->a_used_bytes
;
121 pgoff_t index
= PAGE_CACHE_ALIGN(ofs
) >> PAGE_CACHE_SHIFT
;
122 pgoff_t no_indizes
= len
>> PAGE_CACHE_SHIFT
;
126 page
= get_mapping_page(sb
, index
, 0);
127 BUG_ON(!page
); /* FIXME: reserve a pool */
128 SetPageUptodate(page
);
129 memset(page_address(page
), 0xff, PAGE_CACHE_SIZE
);
130 SetPagePrivate(page
);
131 page_cache_release(page
);
138 * bdev_writeseg will write full pages. Memset the tail to prevent data leaks.
139 * Also make sure we allocate (and memset) all pages for final writeout.
141 static void pad_wbuf(struct logfs_area
*area
, int final
)
143 pad_partial_page(area
);
145 pad_full_pages(area
);
149 * We have to be careful with the alias tree. Since lookup is done by bix,
150 * it needs to be normalized, so 14, 15, 16, etc. all match when dealing with
151 * indirect blocks. So always use it through accessor functions.
153 static void *alias_tree_lookup(struct super_block
*sb
, u64 ino
, u64 bix
,
156 struct btree_head128
*head
= &logfs_super(sb
)->s_object_alias_tree
;
157 pgoff_t index
= logfs_pack_index(bix
, level
);
159 return btree_lookup128(head
, ino
, index
);
162 static int alias_tree_insert(struct super_block
*sb
, u64 ino
, u64 bix
,
163 level_t level
, void *val
)
165 struct btree_head128
*head
= &logfs_super(sb
)->s_object_alias_tree
;
166 pgoff_t index
= logfs_pack_index(bix
, level
);
168 return btree_insert128(head
, ino
, index
, val
, GFP_NOFS
);
171 static int btree_write_alias(struct super_block
*sb
, struct logfs_block
*block
,
172 write_alias_t
*write_one_alias
)
174 struct object_alias_item
*item
;
177 list_for_each_entry(item
, &block
->item_list
, list
) {
178 err
= write_alias_journal(sb
, block
->ino
, block
->bix
,
179 block
->level
, item
->child_no
, item
->val
);
186 static gc_level_t
btree_block_level(struct logfs_block
*block
)
188 return expand_level(block
->ino
, block
->level
);
191 static struct logfs_block_ops btree_block_ops
= {
192 .write_block
= btree_write_block
,
193 .block_level
= btree_block_level
,
194 .free_block
= __free_block
,
195 .write_alias
= btree_write_alias
,
198 int logfs_load_object_aliases(struct super_block
*sb
,
199 struct logfs_obj_alias
*oa
, int count
)
201 struct logfs_super
*super
= logfs_super(sb
);
202 struct logfs_block
*block
;
203 struct object_alias_item
*item
;
208 super
->s_flags
|= LOGFS_SB_FLAG_OBJ_ALIAS
;
209 count
/= sizeof(*oa
);
210 for (i
= 0; i
< count
; i
++) {
211 item
= mempool_alloc(super
->s_alias_pool
, GFP_NOFS
);
214 memset(item
, 0, sizeof(*item
));
216 super
->s_no_object_aliases
++;
217 item
->val
= oa
[i
].val
;
218 item
->child_no
= be16_to_cpu(oa
[i
].child_no
);
220 ino
= be64_to_cpu(oa
[i
].ino
);
221 bix
= be64_to_cpu(oa
[i
].bix
);
222 level
= LEVEL(oa
[i
].level
);
224 log_aliases("logfs_load_object_aliases(%llx, %llx, %x, %x) %llx\n",
225 ino
, bix
, level
, item
->child_no
,
226 be64_to_cpu(item
->val
));
227 block
= alias_tree_lookup(sb
, ino
, bix
, level
);
229 block
= __alloc_block(sb
, ino
, bix
, level
);
230 block
->ops
= &btree_block_ops
;
231 err
= alias_tree_insert(sb
, ino
, bix
, level
, block
);
232 BUG_ON(err
); /* mempool empty */
234 if (test_and_set_bit(item
->child_no
, block
->alias_map
)) {
235 printk(KERN_ERR
"LogFS: Alias collision detected\n");
238 list_move_tail(&block
->alias_list
, &super
->s_object_alias
);
239 list_add(&item
->list
, &block
->item_list
);
244 static void kill_alias(void *_block
, unsigned long ignore0
,
245 u64 ignore1
, u64 ignore2
, size_t ignore3
)
247 struct logfs_block
*block
= _block
;
248 struct super_block
*sb
= block
->sb
;
249 struct logfs_super
*super
= logfs_super(sb
);
250 struct object_alias_item
*item
;
252 while (!list_empty(&block
->item_list
)) {
253 item
= list_entry(block
->item_list
.next
, typeof(*item
), list
);
254 list_del(&item
->list
);
255 mempool_free(item
, super
->s_alias_pool
);
257 block
->ops
->free_block(sb
, block
);
260 static int obj_type(struct inode
*inode
, level_t level
)
263 if (S_ISDIR(inode
->i_mode
))
265 if (inode
->i_ino
== LOGFS_INO_MASTER
)
271 static int obj_len(struct super_block
*sb
, int obj_type
)
275 return sizeof(struct logfs_disk_dentry
);
277 return sizeof(struct logfs_disk_inode
);
279 return sb
->s_blocksize
;
285 static int __logfs_segment_write(struct inode
*inode
, void *buf
,
286 struct logfs_shadow
*shadow
, int type
, int len
, int compr
)
288 struct logfs_area
*area
;
289 struct super_block
*sb
= inode
->i_sb
;
291 struct logfs_object_header h
;
294 if (shadow
->gc_level
== 0)
297 acc_len
= obj_len(sb
, type
);
299 area
= get_area(sb
, shadow
->gc_level
);
300 ofs
= logfs_get_free_bytes(area
, len
+ LOGFS_OBJECT_HEADERSIZE
);
301 LOGFS_BUG_ON(ofs
<= 0, sb
);
303 * Order is important. logfs_get_free_bytes(), by modifying the
304 * segment file, may modify the content of the very page we're about
305 * to write now. Which is fine, as long as the calculated crc and
306 * written data still match. So do the modifications _before_
307 * calculating the crc.
310 h
.len
= cpu_to_be16(len
);
313 h
.ino
= cpu_to_be64(inode
->i_ino
);
314 h
.bix
= cpu_to_be64(shadow
->bix
);
315 h
.crc
= logfs_crc32(&h
, sizeof(h
) - 4, 4);
316 h
.data_crc
= logfs_crc32(buf
, len
, 0);
318 logfs_buf_write(area
, ofs
, &h
, sizeof(h
));
319 logfs_buf_write(area
, ofs
+ LOGFS_OBJECT_HEADERSIZE
, buf
, len
);
321 shadow
->new_ofs
= ofs
;
322 shadow
->new_len
= acc_len
+ LOGFS_OBJECT_HEADERSIZE
;
327 static s64
logfs_segment_write_compress(struct inode
*inode
, void *buf
,
328 struct logfs_shadow
*shadow
, int type
, int len
)
330 struct super_block
*sb
= inode
->i_sb
;
331 void *compressor_buf
= logfs_super(sb
)->s_compressed_je
;
335 mutex_lock(&logfs_super(sb
)->s_journal_mutex
);
336 compr_len
= logfs_compress(buf
, compressor_buf
, len
, len
);
338 if (compr_len
>= 0) {
339 ret
= __logfs_segment_write(inode
, compressor_buf
, shadow
,
340 type
, compr_len
, COMPR_ZLIB
);
342 ret
= __logfs_segment_write(inode
, buf
, shadow
, type
, len
,
345 mutex_unlock(&logfs_super(sb
)->s_journal_mutex
);
350 * logfs_segment_write - write data block to object store
351 * @inode: inode containing data
353 * Returns an errno or zero.
355 int logfs_segment_write(struct inode
*inode
, struct page
*page
,
356 struct logfs_shadow
*shadow
)
358 struct super_block
*sb
= inode
->i_sb
;
359 struct logfs_super
*super
= logfs_super(sb
);
360 int do_compress
, type
, len
;
364 super
->s_flags
|= LOGFS_SB_FLAG_DIRTY
;
365 BUG_ON(super
->s_flags
& LOGFS_SB_FLAG_SHUTDOWN
);
366 do_compress
= logfs_inode(inode
)->li_flags
& LOGFS_IF_COMPRESSED
;
367 if (shadow
->gc_level
!= 0) {
368 /* temporarily disable compression for indirect blocks */
372 type
= obj_type(inode
, shrink_level(shadow
->gc_level
));
373 len
= obj_len(sb
, type
);
376 ret
= logfs_segment_write_compress(inode
, buf
, shadow
, type
,
379 ret
= __logfs_segment_write(inode
, buf
, shadow
, type
, len
,
383 log_segment("logfs_segment_write(%llx, %llx, %x) %llx->%llx %x->%x\n",
384 shadow
->ino
, shadow
->bix
, shadow
->gc_level
,
385 shadow
->old_ofs
, shadow
->new_ofs
,
386 shadow
->old_len
, shadow
->new_len
);
387 /* this BUG_ON did catch a locking bug. useful */
388 BUG_ON(!(shadow
->new_ofs
& (super
->s_segsize
- 1)));
392 int wbuf_read(struct super_block
*sb
, u64 ofs
, size_t len
, void *buf
)
394 pgoff_t index
= ofs
>> PAGE_SHIFT
;
396 long offset
= ofs
& (PAGE_SIZE
-1);
400 copylen
= min((ulong
)len
, PAGE_SIZE
- offset
);
402 page
= get_mapping_page(sb
, index
, 1);
404 return PTR_ERR(page
);
405 memcpy(buf
, page_address(page
) + offset
, copylen
);
406 page_cache_release(page
);
417 * The "position" of indirect blocks is ambiguous. It can be the position
418 * of any data block somewhere behind this indirect block. So we need to
419 * normalize the positions through logfs_block_mask() before comparing.
421 static int check_pos(struct super_block
*sb
, u64 pos1
, u64 pos2
, level_t level
)
423 return (pos1
& logfs_block_mask(sb
, level
)) !=
424 (pos2
& logfs_block_mask(sb
, level
));
428 static int read_seg_header(struct super_block
*sb
, u64 ofs
,
429 struct logfs_segment_header
*sh
)
434 err
= wbuf_read(sb
, ofs
, sizeof(*sh
), sh
);
437 crc
= logfs_crc32(sh
, sizeof(*sh
), 4);
438 if (crc
!= sh
->crc
) {
439 printk(KERN_ERR
"LOGFS: header crc error at %llx: expected %x, "
440 "got %x\n", ofs
, be32_to_cpu(sh
->crc
),
448 static int read_obj_header(struct super_block
*sb
, u64 ofs
,
449 struct logfs_object_header
*oh
)
454 err
= wbuf_read(sb
, ofs
, sizeof(*oh
), oh
);
457 crc
= logfs_crc32(oh
, sizeof(*oh
) - 4, 4);
458 if (crc
!= oh
->crc
) {
459 printk(KERN_ERR
"LOGFS: header crc error at %llx: expected %x, "
460 "got %x\n", ofs
, be32_to_cpu(oh
->crc
),
467 static void move_btree_to_page(struct inode
*inode
, struct page
*page
,
470 struct super_block
*sb
= inode
->i_sb
;
471 struct logfs_super
*super
= logfs_super(sb
);
472 struct btree_head128
*head
= &super
->s_object_alias_tree
;
473 struct logfs_block
*block
;
474 struct object_alias_item
*item
, *next
;
476 if (!(super
->s_flags
& LOGFS_SB_FLAG_OBJ_ALIAS
))
479 block
= btree_remove128(head
, inode
->i_ino
, page
->index
);
483 log_blockmove("move_btree_to_page(%llx, %llx, %x)\n",
484 block
->ino
, block
->bix
, block
->level
);
485 list_for_each_entry_safe(item
, next
, &block
->item_list
, list
) {
486 data
[item
->child_no
] = item
->val
;
487 list_del(&item
->list
);
488 mempool_free(item
, super
->s_alias_pool
);
491 SetPagePrivate(page
);
492 page
->private = (unsigned long)block
;
493 block
->ops
= &indirect_block_ops
;
494 initialize_block_counters(page
, block
, data
, 0);
498 * This silences a false, yet annoying gcc warning. I hate it when my editor
499 * jumps into bitops.h each time I recompile this file.
500 * TODO: Complain to gcc folks about this and upgrade compiler.
502 static unsigned long fnb(const unsigned long *addr
,
503 unsigned long size
, unsigned long offset
)
505 return find_next_bit(addr
, size
, offset
);
508 void move_page_to_btree(struct page
*page
)
510 struct logfs_block
*block
= logfs_block(page
);
511 struct super_block
*sb
= block
->sb
;
512 struct logfs_super
*super
= logfs_super(sb
);
513 struct object_alias_item
*item
;
518 if (super
->s_flags
& LOGFS_SB_FLAG_SHUTDOWN
) {
519 block
->ops
->free_block(sb
, block
);
522 log_blockmove("move_page_to_btree(%llx, %llx, %x)\n",
523 block
->ino
, block
->bix
, block
->level
);
524 super
->s_flags
|= LOGFS_SB_FLAG_OBJ_ALIAS
;
526 for (pos
= 0; ; pos
++) {
527 pos
= fnb(block
->alias_map
, LOGFS_BLOCK_FACTOR
, pos
);
528 if (pos
>= LOGFS_BLOCK_FACTOR
)
531 item
= mempool_alloc(super
->s_alias_pool
, GFP_NOFS
);
532 BUG_ON(!item
); /* mempool empty */
533 memset(item
, 0, sizeof(*item
));
535 child
= kmap_atomic(page
, KM_USER0
);
536 item
->val
= child
[pos
];
537 kunmap_atomic(child
, KM_USER0
);
538 item
->child_no
= pos
;
539 list_add(&item
->list
, &block
->item_list
);
542 ClearPagePrivate(page
);
544 block
->ops
= &btree_block_ops
;
545 err
= alias_tree_insert(block
->sb
, block
->ino
, block
->bix
, block
->level
,
547 BUG_ON(err
); /* mempool empty */
548 ClearPageUptodate(page
);
551 static int __logfs_segment_read(struct inode
*inode
, void *buf
,
552 u64 ofs
, u64 bix
, level_t level
)
554 struct super_block
*sb
= inode
->i_sb
;
555 void *compressor_buf
= logfs_super(sb
)->s_compressed_je
;
556 struct logfs_object_header oh
;
561 block_len
= obj_len(sb
, obj_type(inode
, level
));
562 err
= read_obj_header(sb
, ofs
, &oh
);
567 if (be64_to_cpu(oh
.ino
) != inode
->i_ino
568 || check_pos(sb
, be64_to_cpu(oh
.bix
), bix
, level
)) {
569 printk(KERN_ERR
"LOGFS: (ino, bix) don't match at %llx: "
570 "expected (%lx, %llx), got (%llx, %llx)\n",
571 ofs
, inode
->i_ino
, bix
,
572 be64_to_cpu(oh
.ino
), be64_to_cpu(oh
.bix
));
576 len
= be16_to_cpu(oh
.len
);
580 err
= wbuf_read(sb
, ofs
+ LOGFS_OBJECT_HEADERSIZE
, len
, buf
);
583 crc
= logfs_crc32(buf
, len
, 0);
584 if (crc
!= oh
.data_crc
) {
585 printk(KERN_ERR
"LOGFS: uncompressed data crc error at "
586 "%llx: expected %x, got %x\n", ofs
,
587 be32_to_cpu(oh
.data_crc
),
593 mutex_lock(&logfs_super(sb
)->s_journal_mutex
);
594 err
= wbuf_read(sb
, ofs
+ LOGFS_OBJECT_HEADERSIZE
, len
,
597 mutex_unlock(&logfs_super(sb
)->s_journal_mutex
);
600 crc
= logfs_crc32(compressor_buf
, len
, 0);
601 if (crc
!= oh
.data_crc
) {
602 printk(KERN_ERR
"LOGFS: compressed data crc error at "
603 "%llx: expected %x, got %x\n", ofs
,
604 be32_to_cpu(oh
.data_crc
),
606 mutex_unlock(&logfs_super(sb
)->s_journal_mutex
);
609 err
= logfs_uncompress(compressor_buf
, buf
, len
, block_len
);
610 mutex_unlock(&logfs_super(sb
)->s_journal_mutex
);
612 printk(KERN_ERR
"LOGFS: uncompress error at %llx\n", ofs
);
625 printk(KERN_ERR
"LOGFS: device is read-only now\n");
631 * logfs_segment_read - read data block from object store
632 * @inode: inode containing data
634 * @ofs: physical data offset
636 * @level: block level
638 * Returns 0 on success or a negative errno.
640 int logfs_segment_read(struct inode
*inode
, struct page
*page
,
641 u64 ofs
, u64 bix
, level_t level
)
646 if (PageUptodate(page
))
649 ofs
&= ~LOGFS_FULLY_POPULATED
;
652 err
= __logfs_segment_read(inode
, buf
, ofs
, bix
, level
);
654 move_btree_to_page(inode
, page
, buf
);
655 SetPageUptodate(page
);
658 log_segment("logfs_segment_read(%lx, %llx, %x) %llx (%d)\n",
659 inode
->i_ino
, bix
, level
, ofs
, err
);
663 int logfs_segment_delete(struct inode
*inode
, struct logfs_shadow
*shadow
)
665 struct super_block
*sb
= inode
->i_sb
;
666 struct logfs_super
*super
= logfs_super(sb
);
667 struct logfs_object_header h
;
671 super
->s_flags
|= LOGFS_SB_FLAG_DIRTY
;
672 BUG_ON(super
->s_flags
& LOGFS_SB_FLAG_SHUTDOWN
);
673 BUG_ON(shadow
->old_ofs
& LOGFS_FULLY_POPULATED
);
674 if (!shadow
->old_ofs
)
677 log_segment("logfs_segment_delete(%llx, %llx, %x) %llx->%llx %x->%x\n",
678 shadow
->ino
, shadow
->bix
, shadow
->gc_level
,
679 shadow
->old_ofs
, shadow
->new_ofs
,
680 shadow
->old_len
, shadow
->new_len
);
681 err
= read_obj_header(sb
, shadow
->old_ofs
, &h
);
682 LOGFS_BUG_ON(err
, sb
);
683 LOGFS_BUG_ON(be64_to_cpu(h
.ino
) != inode
->i_ino
, sb
);
684 LOGFS_BUG_ON(check_pos(sb
, shadow
->bix
, be64_to_cpu(h
.bix
),
685 shrink_level(shadow
->gc_level
)), sb
);
687 if (shadow
->gc_level
== 0)
688 len
= be16_to_cpu(h
.len
);
690 len
= obj_len(sb
, h
.type
);
691 shadow
->old_len
= len
+ sizeof(h
);
695 void freeseg(struct super_block
*sb
, u32 segno
)
697 struct logfs_super
*super
= logfs_super(sb
);
698 struct address_space
*mapping
= super
->s_mapping_inode
->i_mapping
;
702 start
= dev_ofs(sb
, segno
, 0);
703 end
= dev_ofs(sb
, segno
+ 1, 0);
704 for (ofs
= start
; ofs
< end
; ofs
+= PAGE_SIZE
) {
705 page
= find_get_page(mapping
, ofs
>> PAGE_SHIFT
);
708 ClearPagePrivate(page
);
709 page_cache_release(page
);
713 int logfs_open_area(struct logfs_area
*area
, size_t bytes
)
715 struct super_block
*sb
= area
->a_sb
;
716 struct logfs_super
*super
= logfs_super(sb
);
719 if (area
->a_is_open
&& area
->a_used_bytes
+ bytes
<= super
->s_segsize
)
722 if (area
->a_is_open
) {
723 u64 ofs
= dev_ofs(sb
, area
->a_segno
, area
->a_written_bytes
);
724 u32 len
= super
->s_segsize
- area
->a_written_bytes
;
726 log_gc("logfs_close_area(%x)\n", area
->a_segno
);
728 super
->s_devops
->writeseg(area
->a_sb
, ofs
, len
);
729 freeseg(sb
, area
->a_segno
);
733 area
->a_used_bytes
= 0;
734 area
->a_written_bytes
= 0;
736 area
->a_ops
->get_free_segment(area
);
737 area
->a_ops
->get_erase_count(area
);
739 log_gc("logfs_open_area(%x, %x)\n", area
->a_segno
, area
->a_level
);
740 err
= area
->a_ops
->erase_segment(area
);
742 printk(KERN_WARNING
"LogFS: Error erasing segment %x\n",
744 logfs_mark_segment_bad(sb
, area
->a_segno
);
751 void logfs_sync_area(struct logfs_area
*area
)
753 struct super_block
*sb
= area
->a_sb
;
754 struct logfs_super
*super
= logfs_super(sb
);
755 u64 ofs
= dev_ofs(sb
, area
->a_segno
, area
->a_written_bytes
);
756 u32 len
= (area
->a_used_bytes
- area
->a_written_bytes
);
758 if (super
->s_writesize
)
759 len
&= ~(super
->s_writesize
- 1);
763 super
->s_devops
->writeseg(sb
, ofs
, len
);
764 area
->a_written_bytes
+= len
;
767 void logfs_sync_segments(struct super_block
*sb
)
769 struct logfs_super
*super
= logfs_super(sb
);
773 logfs_sync_area(super
->s_area
[i
]);
777 * Pick a free segment to be used for this area. Effectively takes a
778 * candidate from the free list (not really a candidate anymore).
780 static void ostore_get_free_segment(struct logfs_area
*area
)
782 struct super_block
*sb
= area
->a_sb
;
783 struct logfs_super
*super
= logfs_super(sb
);
785 if (super
->s_free_list
.count
== 0) {
786 printk(KERN_ERR
"LOGFS: ran out of free segments\n");
790 area
->a_segno
= get_best_cand(sb
, &super
->s_free_list
, NULL
);
793 static void ostore_get_erase_count(struct logfs_area
*area
)
795 struct logfs_segment_entry se
;
798 logfs_get_segment_entry(area
->a_sb
, area
->a_segno
, &se
);
799 BUG_ON(se
.ec_level
== cpu_to_be32(BADSEG
) ||
800 se
.valid
== cpu_to_be32(RESERVED
));
802 ec_level
= be32_to_cpu(se
.ec_level
);
803 area
->a_erase_count
= (ec_level
>> 4) + 1;
806 static int ostore_erase_segment(struct logfs_area
*area
)
808 struct super_block
*sb
= area
->a_sb
;
809 struct logfs_segment_header sh
;
813 err
= logfs_erase_segment(sb
, area
->a_segno
, 0);
818 sh
.type
= SEG_OSTORE
;
819 sh
.level
= (__force u8
)area
->a_level
;
820 sh
.segno
= cpu_to_be32(area
->a_segno
);
821 sh
.ec
= cpu_to_be32(area
->a_erase_count
);
822 sh
.gec
= cpu_to_be64(logfs_super(sb
)->s_gec
);
823 sh
.crc
= logfs_crc32(&sh
, sizeof(sh
), 4);
825 logfs_set_segment_erased(sb
, area
->a_segno
, area
->a_erase_count
,
828 ofs
= dev_ofs(sb
, area
->a_segno
, 0);
829 area
->a_used_bytes
= sizeof(sh
);
830 logfs_buf_write(area
, ofs
, &sh
, sizeof(sh
));
834 static const struct logfs_area_ops ostore_area_ops
= {
835 .get_free_segment
= ostore_get_free_segment
,
836 .get_erase_count
= ostore_get_erase_count
,
837 .erase_segment
= ostore_erase_segment
,
840 static void free_area(struct logfs_area
*area
)
843 freeseg(area
->a_sb
, area
->a_segno
);
847 static struct logfs_area
*alloc_area(struct super_block
*sb
)
849 struct logfs_area
*area
;
851 area
= kzalloc(sizeof(*area
), GFP_KERNEL
);
859 static void map_invalidatepage(struct page
*page
, unsigned long l
)
864 static int map_releasepage(struct page
*page
, gfp_t g
)
866 /* Don't release these pages */
870 static const struct address_space_operations mapping_aops
= {
871 .invalidatepage
= map_invalidatepage
,
872 .releasepage
= map_releasepage
,
873 .set_page_dirty
= __set_page_dirty_nobuffers
,
876 int logfs_init_mapping(struct super_block
*sb
)
878 struct logfs_super
*super
= logfs_super(sb
);
879 struct address_space
*mapping
;
882 inode
= logfs_new_meta_inode(sb
, LOGFS_INO_MAPPING
);
884 return PTR_ERR(inode
);
885 super
->s_mapping_inode
= inode
;
886 mapping
= inode
->i_mapping
;
887 mapping
->a_ops
= &mapping_aops
;
888 /* Would it be possible to use __GFP_HIGHMEM as well? */
889 mapping_set_gfp_mask(mapping
, GFP_NOFS
);
893 int logfs_init_areas(struct super_block
*sb
)
895 struct logfs_super
*super
= logfs_super(sb
);
898 super
->s_alias_pool
= mempool_create_kmalloc_pool(600,
899 sizeof(struct object_alias_item
));
900 if (!super
->s_alias_pool
)
903 super
->s_journal_area
= alloc_area(sb
);
904 if (!super
->s_journal_area
)
908 super
->s_area
[i
] = alloc_area(sb
);
909 if (!super
->s_area
[i
])
911 super
->s_area
[i
]->a_level
= GC_LEVEL(i
);
912 super
->s_area
[i
]->a_ops
= &ostore_area_ops
;
914 btree_init_mempool128(&super
->s_object_alias_tree
,
915 super
->s_btree_pool
);
919 for (i
--; i
>= 0; i
--)
920 free_area(super
->s_area
[i
]);
921 free_area(super
->s_journal_area
);
922 mempool_destroy(super
->s_alias_pool
);
926 void logfs_cleanup_areas(struct super_block
*sb
)
928 struct logfs_super
*super
= logfs_super(sb
);
931 btree_grim_visitor128(&super
->s_object_alias_tree
, 0, kill_alias
);
933 free_area(super
->s_area
[i
]);
934 free_area(super
->s_journal_area
);
935 destroy_meta_inode(super
->s_mapping_inode
);