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.
14 static int logfs_mark_segment_bad(struct super_block
*sb
, u32 segno
)
16 struct logfs_super
*super
= logfs_super(sb
);
17 struct btree_head32
*head
= &super
->s_reserved_segments
;
20 err
= btree_insert32(head
, segno
, (void *)1, GFP_NOFS
);
23 logfs_super(sb
)->s_bad_segments
++;
24 /* FIXME: write to journal */
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 void __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
);
83 SetPageUptodate(page
);
84 BUG_ON(!page
); /* FIXME: reserve a pool */
85 memcpy(page_address(page
) + offset
, buf
, copylen
);
87 page_cache_release(page
);
97 * bdev_writeseg will write full pages. Memset the tail to prevent data leaks.
99 static void pad_wbuf(struct logfs_area
*area
, int final
)
101 struct super_block
*sb
= area
->a_sb
;
102 struct logfs_super
*super
= logfs_super(sb
);
104 u64 ofs
= dev_ofs(sb
, area
->a_segno
, area
->a_used_bytes
);
105 pgoff_t index
= ofs
>> PAGE_SHIFT
;
106 long offset
= ofs
& (PAGE_SIZE
-1);
107 u32 len
= PAGE_SIZE
- offset
;
109 if (len
== PAGE_SIZE
) {
110 /* The math in this function can surely use some love */
114 BUG_ON(area
->a_used_bytes
>= super
->s_segsize
);
116 page
= get_mapping_page(area
->a_sb
, index
, 0);
117 BUG_ON(!page
); /* FIXME: reserve a pool */
118 memset(page_address(page
) + offset
, 0xff, len
);
119 SetPagePrivate(page
);
120 page_cache_release(page
);
126 area
->a_used_bytes
+= len
;
127 for ( ; area
->a_used_bytes
< super
->s_segsize
;
128 area
->a_used_bytes
+= PAGE_SIZE
) {
129 /* Memset another page */
131 page
= get_mapping_page(area
->a_sb
, index
, 0);
132 BUG_ON(!page
); /* FIXME: reserve a pool */
133 memset(page_address(page
), 0xff, PAGE_SIZE
);
134 SetPagePrivate(page
);
135 page_cache_release(page
);
140 * We have to be careful with the alias tree. Since lookup is done by bix,
141 * it needs to be normalized, so 14, 15, 16, etc. all match when dealing with
142 * indirect blocks. So always use it through accessor functions.
144 static void *alias_tree_lookup(struct super_block
*sb
, u64 ino
, u64 bix
,
147 struct btree_head128
*head
= &logfs_super(sb
)->s_object_alias_tree
;
148 pgoff_t index
= logfs_pack_index(bix
, level
);
150 return btree_lookup128(head
, ino
, index
);
153 static int alias_tree_insert(struct super_block
*sb
, u64 ino
, u64 bix
,
154 level_t level
, void *val
)
156 struct btree_head128
*head
= &logfs_super(sb
)->s_object_alias_tree
;
157 pgoff_t index
= logfs_pack_index(bix
, level
);
159 return btree_insert128(head
, ino
, index
, val
, GFP_NOFS
);
162 static int btree_write_alias(struct super_block
*sb
, struct logfs_block
*block
,
163 write_alias_t
*write_one_alias
)
165 struct object_alias_item
*item
;
168 list_for_each_entry(item
, &block
->item_list
, list
) {
169 err
= write_alias_journal(sb
, block
->ino
, block
->bix
,
170 block
->level
, item
->child_no
, item
->val
);
177 static gc_level_t
btree_block_level(struct logfs_block
*block
)
179 return expand_level(block
->ino
, block
->level
);
182 static struct logfs_block_ops btree_block_ops
= {
183 .write_block
= btree_write_block
,
184 .block_level
= btree_block_level
,
185 .free_block
= __free_block
,
186 .write_alias
= btree_write_alias
,
189 int logfs_load_object_aliases(struct super_block
*sb
,
190 struct logfs_obj_alias
*oa
, int count
)
192 struct logfs_super
*super
= logfs_super(sb
);
193 struct logfs_block
*block
;
194 struct object_alias_item
*item
;
199 super
->s_flags
|= LOGFS_SB_FLAG_OBJ_ALIAS
;
200 count
/= sizeof(*oa
);
201 for (i
= 0; i
< count
; i
++) {
202 item
= mempool_alloc(super
->s_alias_pool
, GFP_NOFS
);
205 memset(item
, 0, sizeof(*item
));
207 super
->s_no_object_aliases
++;
208 item
->val
= oa
[i
].val
;
209 item
->child_no
= be16_to_cpu(oa
[i
].child_no
);
211 ino
= be64_to_cpu(oa
[i
].ino
);
212 bix
= be64_to_cpu(oa
[i
].bix
);
213 level
= LEVEL(oa
[i
].level
);
215 log_aliases("logfs_load_object_aliases(%llx, %llx, %x, %x) %llx\n",
216 ino
, bix
, level
, item
->child_no
,
217 be64_to_cpu(item
->val
));
218 block
= alias_tree_lookup(sb
, ino
, bix
, level
);
220 block
= __alloc_block(sb
, ino
, bix
, level
);
221 block
->ops
= &btree_block_ops
;
222 err
= alias_tree_insert(sb
, ino
, bix
, level
, block
);
223 BUG_ON(err
); /* mempool empty */
225 if (test_and_set_bit(item
->child_no
, block
->alias_map
)) {
226 printk(KERN_ERR
"LogFS: Alias collision detected\n");
229 list_move_tail(&block
->alias_list
, &super
->s_object_alias
);
230 list_add(&item
->list
, &block
->item_list
);
235 static void kill_alias(void *_block
, unsigned long ignore0
,
236 u64 ignore1
, u64 ignore2
, size_t ignore3
)
238 struct logfs_block
*block
= _block
;
239 struct super_block
*sb
= block
->sb
;
240 struct logfs_super
*super
= logfs_super(sb
);
241 struct object_alias_item
*item
;
243 while (!list_empty(&block
->item_list
)) {
244 item
= list_entry(block
->item_list
.next
, typeof(*item
), list
);
245 list_del(&item
->list
);
246 mempool_free(item
, super
->s_alias_pool
);
248 block
->ops
->free_block(sb
, block
);
251 static int obj_type(struct inode
*inode
, level_t level
)
254 if (S_ISDIR(inode
->i_mode
))
256 if (inode
->i_ino
== LOGFS_INO_MASTER
)
262 static int obj_len(struct super_block
*sb
, int obj_type
)
266 return sizeof(struct logfs_disk_dentry
);
268 return sizeof(struct logfs_disk_inode
);
270 return sb
->s_blocksize
;
276 static int __logfs_segment_write(struct inode
*inode
, void *buf
,
277 struct logfs_shadow
*shadow
, int type
, int len
, int compr
)
279 struct logfs_area
*area
;
280 struct super_block
*sb
= inode
->i_sb
;
282 struct logfs_object_header h
;
285 if (shadow
->gc_level
== 0)
288 acc_len
= obj_len(sb
, type
);
290 area
= get_area(sb
, shadow
->gc_level
);
291 ofs
= logfs_get_free_bytes(area
, len
+ LOGFS_OBJECT_HEADERSIZE
);
292 LOGFS_BUG_ON(ofs
<= 0, sb
);
294 * Order is important. logfs_get_free_bytes(), by modifying the
295 * segment file, may modify the content of the very page we're about
296 * to write now. Which is fine, as long as the calculated crc and
297 * written data still match. So do the modifications _before_
298 * calculating the crc.
301 h
.len
= cpu_to_be16(len
);
304 h
.ino
= cpu_to_be64(inode
->i_ino
);
305 h
.bix
= cpu_to_be64(shadow
->bix
);
306 h
.crc
= logfs_crc32(&h
, sizeof(h
) - 4, 4);
307 h
.data_crc
= logfs_crc32(buf
, len
, 0);
309 logfs_buf_write(area
, ofs
, &h
, sizeof(h
));
310 logfs_buf_write(area
, ofs
+ LOGFS_OBJECT_HEADERSIZE
, buf
, len
);
312 shadow
->new_ofs
= ofs
;
313 shadow
->new_len
= acc_len
+ LOGFS_OBJECT_HEADERSIZE
;
318 static s64
logfs_segment_write_compress(struct inode
*inode
, void *buf
,
319 struct logfs_shadow
*shadow
, int type
, int len
)
321 struct super_block
*sb
= inode
->i_sb
;
322 void *compressor_buf
= logfs_super(sb
)->s_compressed_je
;
326 mutex_lock(&logfs_super(sb
)->s_journal_mutex
);
327 compr_len
= logfs_compress(buf
, compressor_buf
, len
, len
);
329 if (compr_len
>= 0) {
330 ret
= __logfs_segment_write(inode
, compressor_buf
, shadow
,
331 type
, compr_len
, COMPR_ZLIB
);
333 ret
= __logfs_segment_write(inode
, buf
, shadow
, type
, len
,
336 mutex_unlock(&logfs_super(sb
)->s_journal_mutex
);
341 * logfs_segment_write - write data block to object store
342 * @inode: inode containing data
344 * Returns an errno or zero.
346 int logfs_segment_write(struct inode
*inode
, struct page
*page
,
347 struct logfs_shadow
*shadow
)
349 struct super_block
*sb
= inode
->i_sb
;
350 struct logfs_super
*super
= logfs_super(sb
);
351 int do_compress
, type
, len
;
355 super
->s_flags
|= LOGFS_SB_FLAG_DIRTY
;
356 BUG_ON(super
->s_flags
& LOGFS_SB_FLAG_SHUTDOWN
);
357 do_compress
= logfs_inode(inode
)->li_flags
& LOGFS_IF_COMPRESSED
;
358 if (shadow
->gc_level
!= 0) {
359 /* temporarily disable compression for indirect blocks */
363 type
= obj_type(inode
, shrink_level(shadow
->gc_level
));
364 len
= obj_len(sb
, type
);
367 ret
= logfs_segment_write_compress(inode
, buf
, shadow
, type
,
370 ret
= __logfs_segment_write(inode
, buf
, shadow
, type
, len
,
374 log_segment("logfs_segment_write(%llx, %llx, %x) %llx->%llx %x->%x\n",
375 shadow
->ino
, shadow
->bix
, shadow
->gc_level
,
376 shadow
->old_ofs
, shadow
->new_ofs
,
377 shadow
->old_len
, shadow
->new_len
);
378 /* this BUG_ON did catch a locking bug. useful */
379 BUG_ON(!(shadow
->new_ofs
& (super
->s_segsize
- 1)));
383 int wbuf_read(struct super_block
*sb
, u64 ofs
, size_t len
, void *buf
)
385 pgoff_t index
= ofs
>> PAGE_SHIFT
;
387 long offset
= ofs
& (PAGE_SIZE
-1);
391 copylen
= min((ulong
)len
, PAGE_SIZE
- offset
);
393 page
= get_mapping_page(sb
, index
, 1);
395 return PTR_ERR(page
);
396 memcpy(buf
, page_address(page
) + offset
, copylen
);
397 page_cache_release(page
);
408 * The "position" of indirect blocks is ambiguous. It can be the position
409 * of any data block somewhere behind this indirect block. So we need to
410 * normalize the positions through logfs_block_mask() before comparing.
412 static int check_pos(struct super_block
*sb
, u64 pos1
, u64 pos2
, level_t level
)
414 return (pos1
& logfs_block_mask(sb
, level
)) !=
415 (pos2
& logfs_block_mask(sb
, level
));
419 static int read_seg_header(struct super_block
*sb
, u64 ofs
,
420 struct logfs_segment_header
*sh
)
425 err
= wbuf_read(sb
, ofs
, sizeof(*sh
), sh
);
428 crc
= logfs_crc32(sh
, sizeof(*sh
), 4);
429 if (crc
!= sh
->crc
) {
430 printk(KERN_ERR
"LOGFS: header crc error at %llx: expected %x, "
431 "got %x\n", ofs
, be32_to_cpu(sh
->crc
),
439 static int read_obj_header(struct super_block
*sb
, u64 ofs
,
440 struct logfs_object_header
*oh
)
445 err
= wbuf_read(sb
, ofs
, sizeof(*oh
), oh
);
448 crc
= logfs_crc32(oh
, sizeof(*oh
) - 4, 4);
449 if (crc
!= oh
->crc
) {
450 printk(KERN_ERR
"LOGFS: header crc error at %llx: expected %x, "
451 "got %x\n", ofs
, be32_to_cpu(oh
->crc
),
458 static void move_btree_to_page(struct inode
*inode
, struct page
*page
,
461 struct super_block
*sb
= inode
->i_sb
;
462 struct logfs_super
*super
= logfs_super(sb
);
463 struct btree_head128
*head
= &super
->s_object_alias_tree
;
464 struct logfs_block
*block
;
465 struct object_alias_item
*item
, *next
;
467 if (!(super
->s_flags
& LOGFS_SB_FLAG_OBJ_ALIAS
))
470 block
= btree_remove128(head
, inode
->i_ino
, page
->index
);
474 log_blockmove("move_btree_to_page(%llx, %llx, %x)\n",
475 block
->ino
, block
->bix
, block
->level
);
476 list_for_each_entry_safe(item
, next
, &block
->item_list
, list
) {
477 data
[item
->child_no
] = item
->val
;
478 list_del(&item
->list
);
479 mempool_free(item
, super
->s_alias_pool
);
482 SetPagePrivate(page
);
483 page
->private = (unsigned long)block
;
484 block
->ops
= &indirect_block_ops
;
485 initialize_block_counters(page
, block
, data
, 0);
489 * This silences a false, yet annoying gcc warning. I hate it when my editor
490 * jumps into bitops.h each time I recompile this file.
491 * TODO: Complain to gcc folks about this and upgrade compiler.
493 static unsigned long fnb(const unsigned long *addr
,
494 unsigned long size
, unsigned long offset
)
496 return find_next_bit(addr
, size
, offset
);
499 void move_page_to_btree(struct page
*page
)
501 struct logfs_block
*block
= logfs_block(page
);
502 struct super_block
*sb
= block
->sb
;
503 struct logfs_super
*super
= logfs_super(sb
);
504 struct object_alias_item
*item
;
509 if (super
->s_flags
& LOGFS_SB_FLAG_SHUTDOWN
) {
510 block
->ops
->free_block(sb
, block
);
513 log_blockmove("move_page_to_btree(%llx, %llx, %x)\n",
514 block
->ino
, block
->bix
, block
->level
);
515 super
->s_flags
|= LOGFS_SB_FLAG_OBJ_ALIAS
;
517 for (pos
= 0; ; pos
++) {
518 pos
= fnb(block
->alias_map
, LOGFS_BLOCK_FACTOR
, pos
);
519 if (pos
>= LOGFS_BLOCK_FACTOR
)
522 item
= mempool_alloc(super
->s_alias_pool
, GFP_NOFS
);
523 BUG_ON(!item
); /* mempool empty */
524 memset(item
, 0, sizeof(*item
));
526 child
= kmap_atomic(page
, KM_USER0
);
527 item
->val
= child
[pos
];
528 kunmap_atomic(child
, KM_USER0
);
529 item
->child_no
= pos
;
530 list_add(&item
->list
, &block
->item_list
);
533 ClearPagePrivate(page
);
535 block
->ops
= &btree_block_ops
;
536 err
= alias_tree_insert(block
->sb
, block
->ino
, block
->bix
, block
->level
,
538 BUG_ON(err
); /* mempool empty */
539 ClearPageUptodate(page
);
542 static int __logfs_segment_read(struct inode
*inode
, void *buf
,
543 u64 ofs
, u64 bix
, level_t level
)
545 struct super_block
*sb
= inode
->i_sb
;
546 void *compressor_buf
= logfs_super(sb
)->s_compressed_je
;
547 struct logfs_object_header oh
;
552 block_len
= obj_len(sb
, obj_type(inode
, level
));
553 err
= read_obj_header(sb
, ofs
, &oh
);
558 if (be64_to_cpu(oh
.ino
) != inode
->i_ino
559 || check_pos(sb
, be64_to_cpu(oh
.bix
), bix
, level
)) {
560 printk(KERN_ERR
"LOGFS: (ino, bix) don't match at %llx: "
561 "expected (%lx, %llx), got (%llx, %llx)\n",
562 ofs
, inode
->i_ino
, bix
,
563 be64_to_cpu(oh
.ino
), be64_to_cpu(oh
.bix
));
567 len
= be16_to_cpu(oh
.len
);
571 err
= wbuf_read(sb
, ofs
+ LOGFS_OBJECT_HEADERSIZE
, len
, buf
);
574 crc
= logfs_crc32(buf
, len
, 0);
575 if (crc
!= oh
.data_crc
) {
576 printk(KERN_ERR
"LOGFS: uncompressed data crc error at "
577 "%llx: expected %x, got %x\n", ofs
,
578 be32_to_cpu(oh
.data_crc
),
584 mutex_lock(&logfs_super(sb
)->s_journal_mutex
);
585 err
= wbuf_read(sb
, ofs
+ LOGFS_OBJECT_HEADERSIZE
, len
,
588 mutex_unlock(&logfs_super(sb
)->s_journal_mutex
);
591 crc
= logfs_crc32(compressor_buf
, len
, 0);
592 if (crc
!= oh
.data_crc
) {
593 printk(KERN_ERR
"LOGFS: compressed data crc error at "
594 "%llx: expected %x, got %x\n", ofs
,
595 be32_to_cpu(oh
.data_crc
),
597 mutex_unlock(&logfs_super(sb
)->s_journal_mutex
);
600 err
= logfs_uncompress(compressor_buf
, buf
, len
, block_len
);
601 mutex_unlock(&logfs_super(sb
)->s_journal_mutex
);
603 printk(KERN_ERR
"LOGFS: uncompress error at %llx\n", ofs
);
616 printk(KERN_ERR
"LOGFS: device is read-only now\n");
622 * logfs_segment_read - read data block from object store
623 * @inode: inode containing data
625 * @ofs: physical data offset
627 * @level: block level
629 * Returns 0 on success or a negative errno.
631 int logfs_segment_read(struct inode
*inode
, struct page
*page
,
632 u64 ofs
, u64 bix
, level_t level
)
637 if (PageUptodate(page
))
640 ofs
&= ~LOGFS_FULLY_POPULATED
;
643 err
= __logfs_segment_read(inode
, buf
, ofs
, bix
, level
);
645 move_btree_to_page(inode
, page
, buf
);
646 SetPageUptodate(page
);
649 log_segment("logfs_segment_read(%lx, %llx, %x) %llx (%d)\n",
650 inode
->i_ino
, bix
, level
, ofs
, err
);
654 int logfs_segment_delete(struct inode
*inode
, struct logfs_shadow
*shadow
)
656 struct super_block
*sb
= inode
->i_sb
;
657 struct logfs_super
*super
= logfs_super(sb
);
658 struct logfs_object_header h
;
662 super
->s_flags
|= LOGFS_SB_FLAG_DIRTY
;
663 BUG_ON(super
->s_flags
& LOGFS_SB_FLAG_SHUTDOWN
);
664 BUG_ON(shadow
->old_ofs
& LOGFS_FULLY_POPULATED
);
665 if (!shadow
->old_ofs
)
668 log_segment("logfs_segment_delete(%llx, %llx, %x) %llx->%llx %x->%x\n",
669 shadow
->ino
, shadow
->bix
, shadow
->gc_level
,
670 shadow
->old_ofs
, shadow
->new_ofs
,
671 shadow
->old_len
, shadow
->new_len
);
672 err
= read_obj_header(sb
, shadow
->old_ofs
, &h
);
673 LOGFS_BUG_ON(err
, sb
);
674 LOGFS_BUG_ON(be64_to_cpu(h
.ino
) != inode
->i_ino
, sb
);
675 LOGFS_BUG_ON(check_pos(sb
, shadow
->bix
, be64_to_cpu(h
.bix
),
676 shrink_level(shadow
->gc_level
)), sb
);
678 if (shadow
->gc_level
== 0)
679 len
= be16_to_cpu(h
.len
);
681 len
= obj_len(sb
, h
.type
);
682 shadow
->old_len
= len
+ sizeof(h
);
686 static void freeseg(struct super_block
*sb
, u32 segno
)
688 struct logfs_super
*super
= logfs_super(sb
);
689 struct address_space
*mapping
= super
->s_mapping_inode
->i_mapping
;
693 start
= dev_ofs(sb
, segno
, 0);
694 end
= dev_ofs(sb
, segno
+ 1, 0);
695 for (ofs
= start
; ofs
< end
; ofs
+= PAGE_SIZE
) {
696 page
= find_get_page(mapping
, ofs
>> PAGE_SHIFT
);
699 ClearPagePrivate(page
);
700 page_cache_release(page
);
704 int logfs_open_area(struct logfs_area
*area
, size_t bytes
)
706 struct super_block
*sb
= area
->a_sb
;
707 struct logfs_super
*super
= logfs_super(sb
);
710 if (area
->a_is_open
&& area
->a_used_bytes
+ bytes
<= super
->s_segsize
)
713 if (area
->a_is_open
) {
714 u64 ofs
= dev_ofs(sb
, area
->a_segno
, area
->a_written_bytes
);
715 u32 len
= super
->s_segsize
- area
->a_written_bytes
;
717 log_gc("logfs_close_area(%x)\n", area
->a_segno
);
719 super
->s_devops
->writeseg(area
->a_sb
, ofs
, len
);
720 freeseg(sb
, area
->a_segno
);
724 area
->a_used_bytes
= 0;
725 area
->a_written_bytes
= 0;
727 area
->a_ops
->get_free_segment(area
);
728 area
->a_ops
->get_erase_count(area
);
730 log_gc("logfs_open_area(%x, %x)\n", area
->a_segno
, area
->a_level
);
731 err
= area
->a_ops
->erase_segment(area
);
733 printk(KERN_WARNING
"LogFS: Error erasing segment %x\n",
735 logfs_mark_segment_bad(sb
, area
->a_segno
);
742 void logfs_sync_area(struct logfs_area
*area
)
744 struct super_block
*sb
= area
->a_sb
;
745 struct logfs_super
*super
= logfs_super(sb
);
746 u64 ofs
= dev_ofs(sb
, area
->a_segno
, area
->a_written_bytes
);
747 u32 len
= (area
->a_used_bytes
- area
->a_written_bytes
);
749 if (super
->s_writesize
)
750 len
&= ~(super
->s_writesize
- 1);
754 super
->s_devops
->writeseg(sb
, ofs
, len
);
755 area
->a_written_bytes
+= len
;
758 void logfs_sync_segments(struct super_block
*sb
)
760 struct logfs_super
*super
= logfs_super(sb
);
764 logfs_sync_area(super
->s_area
[i
]);
768 * Pick a free segment to be used for this area. Effectively takes a
769 * candidate from the free list (not really a candidate anymore).
771 static void ostore_get_free_segment(struct logfs_area
*area
)
773 struct super_block
*sb
= area
->a_sb
;
774 struct logfs_super
*super
= logfs_super(sb
);
776 if (super
->s_free_list
.count
== 0) {
777 printk(KERN_ERR
"LOGFS: ran out of free segments\n");
781 area
->a_segno
= get_best_cand(sb
, &super
->s_free_list
, NULL
);
784 static void ostore_get_erase_count(struct logfs_area
*area
)
786 struct logfs_segment_entry se
;
789 logfs_get_segment_entry(area
->a_sb
, area
->a_segno
, &se
);
790 BUG_ON(se
.ec_level
== cpu_to_be32(BADSEG
) ||
791 se
.valid
== cpu_to_be32(RESERVED
));
793 ec_level
= be32_to_cpu(se
.ec_level
);
794 area
->a_erase_count
= (ec_level
>> 4) + 1;
797 static int ostore_erase_segment(struct logfs_area
*area
)
799 struct super_block
*sb
= area
->a_sb
;
800 struct logfs_segment_header sh
;
804 err
= logfs_erase_segment(sb
, area
->a_segno
, 0);
809 sh
.type
= SEG_OSTORE
;
810 sh
.level
= (__force u8
)area
->a_level
;
811 sh
.segno
= cpu_to_be32(area
->a_segno
);
812 sh
.ec
= cpu_to_be32(area
->a_erase_count
);
813 sh
.gec
= cpu_to_be64(logfs_super(sb
)->s_gec
);
814 sh
.crc
= logfs_crc32(&sh
, sizeof(sh
), 4);
816 logfs_set_segment_erased(sb
, area
->a_segno
, area
->a_erase_count
,
819 ofs
= dev_ofs(sb
, area
->a_segno
, 0);
820 area
->a_used_bytes
= sizeof(sh
);
821 logfs_buf_write(area
, ofs
, &sh
, sizeof(sh
));
825 static const struct logfs_area_ops ostore_area_ops
= {
826 .get_free_segment
= ostore_get_free_segment
,
827 .get_erase_count
= ostore_get_erase_count
,
828 .erase_segment
= ostore_erase_segment
,
831 static void free_area(struct logfs_area
*area
)
834 freeseg(area
->a_sb
, area
->a_segno
);
838 static struct logfs_area
*alloc_area(struct super_block
*sb
)
840 struct logfs_area
*area
;
842 area
= kzalloc(sizeof(*area
), GFP_KERNEL
);
850 static void map_invalidatepage(struct page
*page
, unsigned long l
)
855 static int map_releasepage(struct page
*page
, gfp_t g
)
857 /* Don't release these pages */
861 static const struct address_space_operations mapping_aops
= {
862 .invalidatepage
= map_invalidatepage
,
863 .releasepage
= map_releasepage
,
864 .set_page_dirty
= __set_page_dirty_nobuffers
,
867 int logfs_init_mapping(struct super_block
*sb
)
869 struct logfs_super
*super
= logfs_super(sb
);
870 struct address_space
*mapping
;
873 inode
= logfs_new_meta_inode(sb
, LOGFS_INO_MAPPING
);
875 return PTR_ERR(inode
);
876 super
->s_mapping_inode
= inode
;
877 mapping
= inode
->i_mapping
;
878 mapping
->a_ops
= &mapping_aops
;
879 /* Would it be possible to use __GFP_HIGHMEM as well? */
880 mapping_set_gfp_mask(mapping
, GFP_NOFS
);
884 int logfs_init_areas(struct super_block
*sb
)
886 struct logfs_super
*super
= logfs_super(sb
);
889 super
->s_alias_pool
= mempool_create_kmalloc_pool(600,
890 sizeof(struct object_alias_item
));
891 if (!super
->s_alias_pool
)
894 super
->s_journal_area
= alloc_area(sb
);
895 if (!super
->s_journal_area
)
899 super
->s_area
[i
] = alloc_area(sb
);
900 if (!super
->s_area
[i
])
902 super
->s_area
[i
]->a_level
= GC_LEVEL(i
);
903 super
->s_area
[i
]->a_ops
= &ostore_area_ops
;
905 btree_init_mempool128(&super
->s_object_alias_tree
,
906 super
->s_btree_pool
);
910 for (i
--; i
>= 0; i
--)
911 free_area(super
->s_area
[i
]);
912 free_area(super
->s_journal_area
);
913 mempool_destroy(super
->s_alias_pool
);
917 void logfs_cleanup_areas(struct super_block
*sb
)
919 struct logfs_super
*super
= logfs_super(sb
);
922 btree_grim_visitor128(&super
->s_object_alias_tree
, 0, kill_alias
);
924 free_area(super
->s_area
[i
]);
925 free_area(super
->s_journal_area
);
926 destroy_meta_inode(super
->s_mapping_inode
);