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
++;
28 int logfs_erase_segment(struct super_block
*sb
, u32 segno
, int ensure_erase
)
30 struct logfs_super
*super
= logfs_super(sb
);
34 return super
->s_devops
->erase(sb
, (u64
)segno
<< super
->s_segshift
,
35 super
->s_segsize
, ensure_erase
);
38 static s64
logfs_get_free_bytes(struct logfs_area
*area
, size_t bytes
)
42 logfs_open_area(area
, bytes
);
44 ofs
= area
->a_used_bytes
;
45 area
->a_used_bytes
+= bytes
;
46 BUG_ON(area
->a_used_bytes
>= logfs_super(area
->a_sb
)->s_segsize
);
48 return dev_ofs(area
->a_sb
, area
->a_segno
, ofs
);
51 static struct page
*get_mapping_page(struct super_block
*sb
, pgoff_t index
,
54 struct logfs_super
*super
= logfs_super(sb
);
55 struct address_space
*mapping
= super
->s_mapping_inode
->i_mapping
;
56 filler_t
*filler
= super
->s_devops
->readpage
;
59 BUG_ON(mapping_gfp_mask(mapping
) & __GFP_FS
);
61 page
= read_cache_page(mapping
, index
, filler
, sb
);
63 page
= find_or_create_page(mapping
, index
, GFP_NOFS
);
69 int __logfs_buf_write(struct logfs_area
*area
, u64 ofs
, void *buf
, size_t len
,
72 pgoff_t index
= ofs
>> PAGE_SHIFT
;
74 long offset
= ofs
& (PAGE_SIZE
-1);
77 /* Only logfs_wbuf_recover may use len==0 */
78 BUG_ON(!len
&& !use_filler
);
80 copylen
= min((ulong
)len
, PAGE_SIZE
- offset
);
82 page
= get_mapping_page(area
->a_sb
, index
, use_filler
);
86 SetPageUptodate(page
);
87 memcpy(page_address(page
) + offset
, buf
, copylen
);
89 page_cache_release(page
);
99 static void pad_partial_page(struct logfs_area
*area
)
101 struct super_block
*sb
= area
->a_sb
;
103 u64 ofs
= dev_ofs(sb
, area
->a_segno
, area
->a_used_bytes
);
104 pgoff_t index
= ofs
>> PAGE_SHIFT
;
105 long offset
= ofs
& (PAGE_SIZE
-1);
106 u32 len
= PAGE_SIZE
- offset
;
108 if (len
% PAGE_SIZE
) {
109 page
= get_mapping_page(sb
, index
, 0);
111 memset(page_address(page
) + offset
, 0xff, len
);
112 SetPagePrivate(page
);
113 page_cache_release(page
);
117 static void pad_full_pages(struct logfs_area
*area
)
119 struct super_block
*sb
= area
->a_sb
;
120 struct logfs_super
*super
= logfs_super(sb
);
121 u64 ofs
= dev_ofs(sb
, area
->a_segno
, area
->a_used_bytes
);
122 u32 len
= super
->s_segsize
- area
->a_used_bytes
;
123 pgoff_t index
= PAGE_CACHE_ALIGN(ofs
) >> PAGE_CACHE_SHIFT
;
124 pgoff_t no_indizes
= len
>> PAGE_CACHE_SHIFT
;
128 page
= get_mapping_page(sb
, index
, 0);
130 SetPageUptodate(page
);
131 memset(page_address(page
), 0xff, PAGE_CACHE_SIZE
);
132 SetPagePrivate(page
);
133 page_cache_release(page
);
140 * bdev_writeseg will write full pages. Memset the tail to prevent data leaks.
141 * Also make sure we allocate (and memset) all pages for final writeout.
143 static void pad_wbuf(struct logfs_area
*area
, int final
)
145 pad_partial_page(area
);
147 pad_full_pages(area
);
151 * We have to be careful with the alias tree. Since lookup is done by bix,
152 * it needs to be normalized, so 14, 15, 16, etc. all match when dealing with
153 * indirect blocks. So always use it through accessor functions.
155 static void *alias_tree_lookup(struct super_block
*sb
, u64 ino
, u64 bix
,
158 struct btree_head128
*head
= &logfs_super(sb
)->s_object_alias_tree
;
159 pgoff_t index
= logfs_pack_index(bix
, level
);
161 return btree_lookup128(head
, ino
, index
);
164 static int alias_tree_insert(struct super_block
*sb
, u64 ino
, u64 bix
,
165 level_t level
, void *val
)
167 struct btree_head128
*head
= &logfs_super(sb
)->s_object_alias_tree
;
168 pgoff_t index
= logfs_pack_index(bix
, level
);
170 return btree_insert128(head
, ino
, index
, val
, GFP_NOFS
);
173 static int btree_write_alias(struct super_block
*sb
, struct logfs_block
*block
,
174 write_alias_t
*write_one_alias
)
176 struct object_alias_item
*item
;
179 list_for_each_entry(item
, &block
->item_list
, list
) {
180 err
= write_alias_journal(sb
, block
->ino
, block
->bix
,
181 block
->level
, item
->child_no
, item
->val
);
188 static struct logfs_block_ops btree_block_ops
= {
189 .write_block
= btree_write_block
,
190 .free_block
= __free_block
,
191 .write_alias
= btree_write_alias
,
194 int logfs_load_object_aliases(struct super_block
*sb
,
195 struct logfs_obj_alias
*oa
, int count
)
197 struct logfs_super
*super
= logfs_super(sb
);
198 struct logfs_block
*block
;
199 struct object_alias_item
*item
;
204 super
->s_flags
|= LOGFS_SB_FLAG_OBJ_ALIAS
;
205 count
/= sizeof(*oa
);
206 for (i
= 0; i
< count
; i
++) {
207 item
= mempool_alloc(super
->s_alias_pool
, GFP_NOFS
);
210 memset(item
, 0, sizeof(*item
));
212 super
->s_no_object_aliases
++;
213 item
->val
= oa
[i
].val
;
214 item
->child_no
= be16_to_cpu(oa
[i
].child_no
);
216 ino
= be64_to_cpu(oa
[i
].ino
);
217 bix
= be64_to_cpu(oa
[i
].bix
);
218 level
= LEVEL(oa
[i
].level
);
220 log_aliases("logfs_load_object_aliases(%llx, %llx, %x, %x) %llx\n",
221 ino
, bix
, level
, item
->child_no
,
222 be64_to_cpu(item
->val
));
223 block
= alias_tree_lookup(sb
, ino
, bix
, level
);
225 block
= __alloc_block(sb
, ino
, bix
, level
);
226 block
->ops
= &btree_block_ops
;
227 err
= alias_tree_insert(sb
, ino
, bix
, level
, block
);
228 BUG_ON(err
); /* mempool empty */
230 if (test_and_set_bit(item
->child_no
, block
->alias_map
)) {
231 printk(KERN_ERR
"LogFS: Alias collision detected\n");
234 list_move_tail(&block
->alias_list
, &super
->s_object_alias
);
235 list_add(&item
->list
, &block
->item_list
);
240 static void kill_alias(void *_block
, unsigned long ignore0
,
241 u64 ignore1
, u64 ignore2
, size_t ignore3
)
243 struct logfs_block
*block
= _block
;
244 struct super_block
*sb
= block
->sb
;
245 struct logfs_super
*super
= logfs_super(sb
);
246 struct object_alias_item
*item
;
248 while (!list_empty(&block
->item_list
)) {
249 item
= list_entry(block
->item_list
.next
, typeof(*item
), list
);
250 list_del(&item
->list
);
251 mempool_free(item
, super
->s_alias_pool
);
253 block
->ops
->free_block(sb
, block
);
256 static int obj_type(struct inode
*inode
, level_t level
)
259 if (S_ISDIR(inode
->i_mode
))
261 if (inode
->i_ino
== LOGFS_INO_MASTER
)
267 static int obj_len(struct super_block
*sb
, int obj_type
)
271 return sizeof(struct logfs_disk_dentry
);
273 return sizeof(struct logfs_disk_inode
);
275 return sb
->s_blocksize
;
281 static int __logfs_segment_write(struct inode
*inode
, void *buf
,
282 struct logfs_shadow
*shadow
, int type
, int len
, int compr
)
284 struct logfs_area
*area
;
285 struct super_block
*sb
= inode
->i_sb
;
287 struct logfs_object_header h
;
290 if (shadow
->gc_level
== 0)
293 acc_len
= obj_len(sb
, type
);
295 area
= get_area(sb
, shadow
->gc_level
);
296 ofs
= logfs_get_free_bytes(area
, len
+ LOGFS_OBJECT_HEADERSIZE
);
297 LOGFS_BUG_ON(ofs
<= 0, sb
);
299 * Order is important. logfs_get_free_bytes(), by modifying the
300 * segment file, may modify the content of the very page we're about
301 * to write now. Which is fine, as long as the calculated crc and
302 * written data still match. So do the modifications _before_
303 * calculating the crc.
306 h
.len
= cpu_to_be16(len
);
309 h
.ino
= cpu_to_be64(inode
->i_ino
);
310 h
.bix
= cpu_to_be64(shadow
->bix
);
311 h
.crc
= logfs_crc32(&h
, sizeof(h
) - 4, 4);
312 h
.data_crc
= logfs_crc32(buf
, len
, 0);
314 logfs_buf_write(area
, ofs
, &h
, sizeof(h
));
315 logfs_buf_write(area
, ofs
+ LOGFS_OBJECT_HEADERSIZE
, buf
, len
);
317 shadow
->new_ofs
= ofs
;
318 shadow
->new_len
= acc_len
+ LOGFS_OBJECT_HEADERSIZE
;
323 static s64
logfs_segment_write_compress(struct inode
*inode
, void *buf
,
324 struct logfs_shadow
*shadow
, int type
, int len
)
326 struct super_block
*sb
= inode
->i_sb
;
327 void *compressor_buf
= logfs_super(sb
)->s_compressed_je
;
331 mutex_lock(&logfs_super(sb
)->s_journal_mutex
);
332 compr_len
= logfs_compress(buf
, compressor_buf
, len
, len
);
334 if (compr_len
>= 0) {
335 ret
= __logfs_segment_write(inode
, compressor_buf
, shadow
,
336 type
, compr_len
, COMPR_ZLIB
);
338 ret
= __logfs_segment_write(inode
, buf
, shadow
, type
, len
,
341 mutex_unlock(&logfs_super(sb
)->s_journal_mutex
);
346 * logfs_segment_write - write data block to object store
347 * @inode: inode containing data
349 * Returns an errno or zero.
351 int logfs_segment_write(struct inode
*inode
, struct page
*page
,
352 struct logfs_shadow
*shadow
)
354 struct super_block
*sb
= inode
->i_sb
;
355 struct logfs_super
*super
= logfs_super(sb
);
356 int do_compress
, type
, len
;
360 super
->s_flags
|= LOGFS_SB_FLAG_DIRTY
;
361 BUG_ON(super
->s_flags
& LOGFS_SB_FLAG_SHUTDOWN
);
362 do_compress
= logfs_inode(inode
)->li_flags
& LOGFS_IF_COMPRESSED
;
363 if (shadow
->gc_level
!= 0) {
364 /* temporarily disable compression for indirect blocks */
368 type
= obj_type(inode
, shrink_level(shadow
->gc_level
));
369 len
= obj_len(sb
, type
);
372 ret
= logfs_segment_write_compress(inode
, buf
, shadow
, type
,
375 ret
= __logfs_segment_write(inode
, buf
, shadow
, type
, len
,
379 log_segment("logfs_segment_write(%llx, %llx, %x) %llx->%llx %x->%x\n",
380 shadow
->ino
, shadow
->bix
, shadow
->gc_level
,
381 shadow
->old_ofs
, shadow
->new_ofs
,
382 shadow
->old_len
, shadow
->new_len
);
383 /* this BUG_ON did catch a locking bug. useful */
384 BUG_ON(!(shadow
->new_ofs
& (super
->s_segsize
- 1)));
388 int wbuf_read(struct super_block
*sb
, u64 ofs
, size_t len
, void *buf
)
390 pgoff_t index
= ofs
>> PAGE_SHIFT
;
392 long offset
= ofs
& (PAGE_SIZE
-1);
396 copylen
= min((ulong
)len
, PAGE_SIZE
- offset
);
398 page
= get_mapping_page(sb
, index
, 1);
400 return PTR_ERR(page
);
401 memcpy(buf
, page_address(page
) + offset
, copylen
);
402 page_cache_release(page
);
413 * The "position" of indirect blocks is ambiguous. It can be the position
414 * of any data block somewhere behind this indirect block. So we need to
415 * normalize the positions through logfs_block_mask() before comparing.
417 static int check_pos(struct super_block
*sb
, u64 pos1
, u64 pos2
, level_t level
)
419 return (pos1
& logfs_block_mask(sb
, level
)) !=
420 (pos2
& logfs_block_mask(sb
, level
));
424 static int read_obj_header(struct super_block
*sb
, u64 ofs
,
425 struct logfs_object_header
*oh
)
430 err
= wbuf_read(sb
, ofs
, sizeof(*oh
), oh
);
433 crc
= logfs_crc32(oh
, sizeof(*oh
) - 4, 4);
434 if (crc
!= oh
->crc
) {
435 printk(KERN_ERR
"LOGFS: header crc error at %llx: expected %x, "
436 "got %x\n", ofs
, be32_to_cpu(oh
->crc
),
443 static void move_btree_to_page(struct inode
*inode
, struct page
*page
,
446 struct super_block
*sb
= inode
->i_sb
;
447 struct logfs_super
*super
= logfs_super(sb
);
448 struct btree_head128
*head
= &super
->s_object_alias_tree
;
449 struct logfs_block
*block
;
450 struct object_alias_item
*item
, *next
;
452 if (!(super
->s_flags
& LOGFS_SB_FLAG_OBJ_ALIAS
))
455 block
= btree_remove128(head
, inode
->i_ino
, page
->index
);
459 log_blockmove("move_btree_to_page(%llx, %llx, %x)\n",
460 block
->ino
, block
->bix
, block
->level
);
461 list_for_each_entry_safe(item
, next
, &block
->item_list
, list
) {
462 data
[item
->child_no
] = item
->val
;
463 list_del(&item
->list
);
464 mempool_free(item
, super
->s_alias_pool
);
467 SetPagePrivate(page
);
468 page
->private = (unsigned long)block
;
469 block
->ops
= &indirect_block_ops
;
470 initialize_block_counters(page
, block
, data
, 0);
474 * This silences a false, yet annoying gcc warning. I hate it when my editor
475 * jumps into bitops.h each time I recompile this file.
476 * TODO: Complain to gcc folks about this and upgrade compiler.
478 static unsigned long fnb(const unsigned long *addr
,
479 unsigned long size
, unsigned long offset
)
481 return find_next_bit(addr
, size
, offset
);
484 void move_page_to_btree(struct page
*page
)
486 struct logfs_block
*block
= logfs_block(page
);
487 struct super_block
*sb
= block
->sb
;
488 struct logfs_super
*super
= logfs_super(sb
);
489 struct object_alias_item
*item
;
494 if (super
->s_flags
& LOGFS_SB_FLAG_SHUTDOWN
) {
495 block
->ops
->free_block(sb
, block
);
498 log_blockmove("move_page_to_btree(%llx, %llx, %x)\n",
499 block
->ino
, block
->bix
, block
->level
);
500 super
->s_flags
|= LOGFS_SB_FLAG_OBJ_ALIAS
;
502 for (pos
= 0; ; pos
++) {
503 pos
= fnb(block
->alias_map
, LOGFS_BLOCK_FACTOR
, pos
);
504 if (pos
>= LOGFS_BLOCK_FACTOR
)
507 item
= mempool_alloc(super
->s_alias_pool
, GFP_NOFS
);
508 BUG_ON(!item
); /* mempool empty */
509 memset(item
, 0, sizeof(*item
));
511 child
= kmap_atomic(page
, KM_USER0
);
512 item
->val
= child
[pos
];
513 kunmap_atomic(child
, KM_USER0
);
514 item
->child_no
= pos
;
515 list_add(&item
->list
, &block
->item_list
);
518 ClearPagePrivate(page
);
520 block
->ops
= &btree_block_ops
;
521 err
= alias_tree_insert(block
->sb
, block
->ino
, block
->bix
, block
->level
,
523 BUG_ON(err
); /* mempool empty */
524 ClearPageUptodate(page
);
527 static int __logfs_segment_read(struct inode
*inode
, void *buf
,
528 u64 ofs
, u64 bix
, level_t level
)
530 struct super_block
*sb
= inode
->i_sb
;
531 void *compressor_buf
= logfs_super(sb
)->s_compressed_je
;
532 struct logfs_object_header oh
;
537 block_len
= obj_len(sb
, obj_type(inode
, level
));
538 err
= read_obj_header(sb
, ofs
, &oh
);
543 if (be64_to_cpu(oh
.ino
) != inode
->i_ino
544 || check_pos(sb
, be64_to_cpu(oh
.bix
), bix
, level
)) {
545 printk(KERN_ERR
"LOGFS: (ino, bix) don't match at %llx: "
546 "expected (%lx, %llx), got (%llx, %llx)\n",
547 ofs
, inode
->i_ino
, bix
,
548 be64_to_cpu(oh
.ino
), be64_to_cpu(oh
.bix
));
552 len
= be16_to_cpu(oh
.len
);
556 err
= wbuf_read(sb
, ofs
+ LOGFS_OBJECT_HEADERSIZE
, len
, buf
);
559 crc
= logfs_crc32(buf
, len
, 0);
560 if (crc
!= oh
.data_crc
) {
561 printk(KERN_ERR
"LOGFS: uncompressed data crc error at "
562 "%llx: expected %x, got %x\n", ofs
,
563 be32_to_cpu(oh
.data_crc
),
569 mutex_lock(&logfs_super(sb
)->s_journal_mutex
);
570 err
= wbuf_read(sb
, ofs
+ LOGFS_OBJECT_HEADERSIZE
, len
,
573 mutex_unlock(&logfs_super(sb
)->s_journal_mutex
);
576 crc
= logfs_crc32(compressor_buf
, len
, 0);
577 if (crc
!= oh
.data_crc
) {
578 printk(KERN_ERR
"LOGFS: compressed data crc error at "
579 "%llx: expected %x, got %x\n", ofs
,
580 be32_to_cpu(oh
.data_crc
),
582 mutex_unlock(&logfs_super(sb
)->s_journal_mutex
);
585 err
= logfs_uncompress(compressor_buf
, buf
, len
, block_len
);
586 mutex_unlock(&logfs_super(sb
)->s_journal_mutex
);
588 printk(KERN_ERR
"LOGFS: uncompress error at %llx\n", ofs
);
601 printk(KERN_ERR
"LOGFS: device is read-only now\n");
607 * logfs_segment_read - read data block from object store
608 * @inode: inode containing data
610 * @ofs: physical data offset
612 * @level: block level
614 * Returns 0 on success or a negative errno.
616 int logfs_segment_read(struct inode
*inode
, struct page
*page
,
617 u64 ofs
, u64 bix
, level_t level
)
622 if (PageUptodate(page
))
625 ofs
&= ~LOGFS_FULLY_POPULATED
;
628 err
= __logfs_segment_read(inode
, buf
, ofs
, bix
, level
);
630 move_btree_to_page(inode
, page
, buf
);
631 SetPageUptodate(page
);
634 log_segment("logfs_segment_read(%lx, %llx, %x) %llx (%d)\n",
635 inode
->i_ino
, bix
, level
, ofs
, err
);
639 int logfs_segment_delete(struct inode
*inode
, struct logfs_shadow
*shadow
)
641 struct super_block
*sb
= inode
->i_sb
;
642 struct logfs_super
*super
= logfs_super(sb
);
643 struct logfs_object_header h
;
647 super
->s_flags
|= LOGFS_SB_FLAG_DIRTY
;
648 BUG_ON(super
->s_flags
& LOGFS_SB_FLAG_SHUTDOWN
);
649 BUG_ON(shadow
->old_ofs
& LOGFS_FULLY_POPULATED
);
650 if (!shadow
->old_ofs
)
653 log_segment("logfs_segment_delete(%llx, %llx, %x) %llx->%llx %x->%x\n",
654 shadow
->ino
, shadow
->bix
, shadow
->gc_level
,
655 shadow
->old_ofs
, shadow
->new_ofs
,
656 shadow
->old_len
, shadow
->new_len
);
657 err
= read_obj_header(sb
, shadow
->old_ofs
, &h
);
658 LOGFS_BUG_ON(err
, sb
);
659 LOGFS_BUG_ON(be64_to_cpu(h
.ino
) != inode
->i_ino
, sb
);
660 LOGFS_BUG_ON(check_pos(sb
, shadow
->bix
, be64_to_cpu(h
.bix
),
661 shrink_level(shadow
->gc_level
)), sb
);
663 if (shadow
->gc_level
== 0)
664 len
= be16_to_cpu(h
.len
);
666 len
= obj_len(sb
, h
.type
);
667 shadow
->old_len
= len
+ sizeof(h
);
671 void freeseg(struct super_block
*sb
, u32 segno
)
673 struct logfs_super
*super
= logfs_super(sb
);
674 struct address_space
*mapping
= super
->s_mapping_inode
->i_mapping
;
678 start
= dev_ofs(sb
, segno
, 0);
679 end
= dev_ofs(sb
, segno
+ 1, 0);
680 for (ofs
= start
; ofs
< end
; ofs
+= PAGE_SIZE
) {
681 page
= find_get_page(mapping
, ofs
>> PAGE_SHIFT
);
684 ClearPagePrivate(page
);
685 page_cache_release(page
);
689 int logfs_open_area(struct logfs_area
*area
, size_t bytes
)
691 struct super_block
*sb
= area
->a_sb
;
692 struct logfs_super
*super
= logfs_super(sb
);
695 if (area
->a_is_open
&& area
->a_used_bytes
+ bytes
<= super
->s_segsize
)
698 if (area
->a_is_open
) {
699 u64 ofs
= dev_ofs(sb
, area
->a_segno
, area
->a_written_bytes
);
700 u32 len
= super
->s_segsize
- area
->a_written_bytes
;
702 log_gc("logfs_close_area(%x)\n", area
->a_segno
);
704 super
->s_devops
->writeseg(area
->a_sb
, ofs
, len
);
705 freeseg(sb
, area
->a_segno
);
709 area
->a_used_bytes
= 0;
710 area
->a_written_bytes
= 0;
712 area
->a_ops
->get_free_segment(area
);
713 area
->a_ops
->get_erase_count(area
);
715 log_gc("logfs_open_area(%x, %x)\n", area
->a_segno
, area
->a_level
);
716 err
= area
->a_ops
->erase_segment(area
);
718 printk(KERN_WARNING
"LogFS: Error erasing segment %x\n",
720 logfs_mark_segment_bad(sb
, area
->a_segno
);
727 void logfs_sync_area(struct logfs_area
*area
)
729 struct super_block
*sb
= area
->a_sb
;
730 struct logfs_super
*super
= logfs_super(sb
);
731 u64 ofs
= dev_ofs(sb
, area
->a_segno
, area
->a_written_bytes
);
732 u32 len
= (area
->a_used_bytes
- area
->a_written_bytes
);
734 if (super
->s_writesize
)
735 len
&= ~(super
->s_writesize
- 1);
739 super
->s_devops
->writeseg(sb
, ofs
, len
);
740 area
->a_written_bytes
+= len
;
743 void logfs_sync_segments(struct super_block
*sb
)
745 struct logfs_super
*super
= logfs_super(sb
);
749 logfs_sync_area(super
->s_area
[i
]);
753 * Pick a free segment to be used for this area. Effectively takes a
754 * candidate from the free list (not really a candidate anymore).
756 static void ostore_get_free_segment(struct logfs_area
*area
)
758 struct super_block
*sb
= area
->a_sb
;
759 struct logfs_super
*super
= logfs_super(sb
);
761 if (super
->s_free_list
.count
== 0) {
762 printk(KERN_ERR
"LOGFS: ran out of free segments\n");
766 area
->a_segno
= get_best_cand(sb
, &super
->s_free_list
, NULL
);
769 static void ostore_get_erase_count(struct logfs_area
*area
)
771 struct logfs_segment_entry se
;
774 logfs_get_segment_entry(area
->a_sb
, area
->a_segno
, &se
);
775 BUG_ON(se
.ec_level
== cpu_to_be32(BADSEG
) ||
776 se
.valid
== cpu_to_be32(RESERVED
));
778 ec_level
= be32_to_cpu(se
.ec_level
);
779 area
->a_erase_count
= (ec_level
>> 4) + 1;
782 static int ostore_erase_segment(struct logfs_area
*area
)
784 struct super_block
*sb
= area
->a_sb
;
785 struct logfs_segment_header sh
;
789 err
= logfs_erase_segment(sb
, area
->a_segno
, 0);
794 sh
.type
= SEG_OSTORE
;
795 sh
.level
= (__force u8
)area
->a_level
;
796 sh
.segno
= cpu_to_be32(area
->a_segno
);
797 sh
.ec
= cpu_to_be32(area
->a_erase_count
);
798 sh
.gec
= cpu_to_be64(logfs_super(sb
)->s_gec
);
799 sh
.crc
= logfs_crc32(&sh
, sizeof(sh
), 4);
801 logfs_set_segment_erased(sb
, area
->a_segno
, area
->a_erase_count
,
804 ofs
= dev_ofs(sb
, area
->a_segno
, 0);
805 area
->a_used_bytes
= sizeof(sh
);
806 logfs_buf_write(area
, ofs
, &sh
, sizeof(sh
));
810 static const struct logfs_area_ops ostore_area_ops
= {
811 .get_free_segment
= ostore_get_free_segment
,
812 .get_erase_count
= ostore_get_erase_count
,
813 .erase_segment
= ostore_erase_segment
,
816 static void free_area(struct logfs_area
*area
)
819 freeseg(area
->a_sb
, area
->a_segno
);
823 static struct logfs_area
*alloc_area(struct super_block
*sb
)
825 struct logfs_area
*area
;
827 area
= kzalloc(sizeof(*area
), GFP_KERNEL
);
835 static void map_invalidatepage(struct page
*page
, unsigned long l
)
840 static int map_releasepage(struct page
*page
, gfp_t g
)
842 /* Don't release these pages */
846 static const struct address_space_operations mapping_aops
= {
847 .invalidatepage
= map_invalidatepage
,
848 .releasepage
= map_releasepage
,
849 .set_page_dirty
= __set_page_dirty_nobuffers
,
852 int logfs_init_mapping(struct super_block
*sb
)
854 struct logfs_super
*super
= logfs_super(sb
);
855 struct address_space
*mapping
;
858 inode
= logfs_new_meta_inode(sb
, LOGFS_INO_MAPPING
);
860 return PTR_ERR(inode
);
861 super
->s_mapping_inode
= inode
;
862 mapping
= inode
->i_mapping
;
863 mapping
->a_ops
= &mapping_aops
;
864 /* Would it be possible to use __GFP_HIGHMEM as well? */
865 mapping_set_gfp_mask(mapping
, GFP_NOFS
);
869 int logfs_init_areas(struct super_block
*sb
)
871 struct logfs_super
*super
= logfs_super(sb
);
874 super
->s_alias_pool
= mempool_create_kmalloc_pool(600,
875 sizeof(struct object_alias_item
));
876 if (!super
->s_alias_pool
)
879 super
->s_journal_area
= alloc_area(sb
);
880 if (!super
->s_journal_area
)
884 super
->s_area
[i
] = alloc_area(sb
);
885 if (!super
->s_area
[i
])
887 super
->s_area
[i
]->a_level
= GC_LEVEL(i
);
888 super
->s_area
[i
]->a_ops
= &ostore_area_ops
;
890 btree_init_mempool128(&super
->s_object_alias_tree
,
891 super
->s_btree_pool
);
895 for (i
--; i
>= 0; i
--)
896 free_area(super
->s_area
[i
]);
897 free_area(super
->s_journal_area
);
898 logfs_mempool_destroy(super
->s_alias_pool
);
902 void logfs_cleanup_areas(struct super_block
*sb
)
904 struct logfs_super
*super
= logfs_super(sb
);
907 btree_grim_visitor128(&super
->s_object_alias_tree
, 0, kill_alias
);
909 free_area(super
->s_area
[i
]);
910 free_area(super
->s_journal_area
);