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);
98 * bdev_writeseg will write full pages. Memset the tail to prevent data leaks.
100 static void pad_wbuf(struct logfs_area *area, int final)
102 struct super_block *sb = area->a_sb;
103 struct logfs_super *super = logfs_super(sb);
105 u64 ofs = dev_ofs(sb, area->a_segno, area->a_used_bytes);
106 pgoff_t index = ofs >> PAGE_SHIFT;
107 long offset = ofs & (PAGE_SIZE-1);
108 u32 len = PAGE_SIZE - offset;
110 if (len == PAGE_SIZE) {
111 /* The math in this function can surely use some love */
115 BUG_ON(area->a_used_bytes >= super->s_segsize);
117 page = get_mapping_page(area->a_sb, index, 0);
118 BUG_ON(!page); /* FIXME: reserve a pool */
119 memset(page_address(page) + offset, 0xff, len);
120 SetPagePrivate(page);
121 page_cache_release(page);
127 area->a_used_bytes += len;
128 for ( ; area->a_used_bytes < super->s_segsize;
129 area->a_used_bytes += PAGE_SIZE) {
130 /* Memset another page */
132 page = get_mapping_page(area->a_sb, index, 0);
133 BUG_ON(!page); /* FIXME: reserve a pool */
134 memset(page_address(page), 0xff, PAGE_SIZE);
135 SetPagePrivate(page);
136 page_cache_release(page);
141 * We have to be careful with the alias tree. Since lookup is done by bix,
142 * it needs to be normalized, so 14, 15, 16, etc. all match when dealing with
143 * indirect blocks. So always use it through accessor functions.
145 static void *alias_tree_lookup(struct super_block *sb, u64 ino, u64 bix,
148 struct btree_head128 *head = &logfs_super(sb)->s_object_alias_tree;
149 pgoff_t index = logfs_pack_index(bix, level);
151 return btree_lookup128(head, ino, index);
154 static int alias_tree_insert(struct super_block *sb, u64 ino, u64 bix,
155 level_t level, void *val)
157 struct btree_head128 *head = &logfs_super(sb)->s_object_alias_tree;
158 pgoff_t index = logfs_pack_index(bix, level);
160 return btree_insert128(head, ino, index, val, GFP_NOFS);
163 static int btree_write_alias(struct super_block *sb, struct logfs_block *block,
164 write_alias_t *write_one_alias)
166 struct object_alias_item *item;
169 list_for_each_entry(item, &block->item_list, list) {
170 err = write_alias_journal(sb, block->ino, block->bix,
171 block->level, item->child_no, item->val);
178 static gc_level_t btree_block_level(struct logfs_block *block)
180 return expand_level(block->ino, block->level);
183 static struct logfs_block_ops btree_block_ops = {
184 .write_block = btree_write_block,
185 .block_level = btree_block_level,
186 .free_block = __free_block,
187 .write_alias = btree_write_alias,
190 int logfs_load_object_aliases(struct super_block *sb,
191 struct logfs_obj_alias *oa, int count)
193 struct logfs_super *super = logfs_super(sb);
194 struct logfs_block *block;
195 struct object_alias_item *item;
200 super->s_flags |= LOGFS_SB_FLAG_OBJ_ALIAS;
201 count /= sizeof(*oa);
202 for (i = 0; i < count; i++) {
203 item = mempool_alloc(super->s_alias_pool, GFP_NOFS);
206 memset(item, 0, sizeof(*item));
208 super->s_no_object_aliases++;
209 item->val = oa[i].val;
210 item->child_no = be16_to_cpu(oa[i].child_no);
212 ino = be64_to_cpu(oa[i].ino);
213 bix = be64_to_cpu(oa[i].bix);
214 level = LEVEL(oa[i].level);
216 log_aliases("logfs_load_object_aliases(%llx, %llx, %x, %x) %llx\n",
217 ino, bix, level, item->child_no,
218 be64_to_cpu(item->val));
219 block = alias_tree_lookup(sb, ino, bix, level);
221 block = __alloc_block(sb, ino, bix, level);
222 block->ops = &btree_block_ops;
223 err = alias_tree_insert(sb, ino, bix, level, block);
224 BUG_ON(err); /* mempool empty */
226 if (test_and_set_bit(item->child_no, block->alias_map)) {
227 printk(KERN_ERR"LogFS: Alias collision detected\n");
230 list_move_tail(&block->alias_list, &super->s_object_alias);
231 list_add(&item->list, &block->item_list);
236 static void kill_alias(void *_block, unsigned long ignore0,
237 u64 ignore1, u64 ignore2, size_t ignore3)
239 struct logfs_block *block = _block;
240 struct super_block *sb = block->sb;
241 struct logfs_super *super = logfs_super(sb);
242 struct object_alias_item *item;
244 while (!list_empty(&block->item_list)) {
245 item = list_entry(block->item_list.next, typeof(*item), list);
246 list_del(&item->list);
247 mempool_free(item, super->s_alias_pool);
249 block->ops->free_block(sb, block);
252 static int obj_type(struct inode *inode, level_t level)
255 if (S_ISDIR(inode->i_mode))
257 if (inode->i_ino == LOGFS_INO_MASTER)
263 static int obj_len(struct super_block *sb, int obj_type)
267 return sizeof(struct logfs_disk_dentry);
269 return sizeof(struct logfs_disk_inode);
271 return sb->s_blocksize;
277 static int __logfs_segment_write(struct inode *inode, void *buf,
278 struct logfs_shadow *shadow, int type, int len, int compr)
280 struct logfs_area *area;
281 struct super_block *sb = inode->i_sb;
283 struct logfs_object_header h;
286 if (shadow->gc_level == 0)
289 acc_len = obj_len(sb, type);
291 area = get_area(sb, shadow->gc_level);
292 ofs = logfs_get_free_bytes(area, len + LOGFS_OBJECT_HEADERSIZE);
293 LOGFS_BUG_ON(ofs <= 0, sb);
295 * Order is important. logfs_get_free_bytes(), by modifying the
296 * segment file, may modify the content of the very page we're about
297 * to write now. Which is fine, as long as the calculated crc and
298 * written data still match. So do the modifications _before_
299 * calculating the crc.
302 h.len = cpu_to_be16(len);
305 h.ino = cpu_to_be64(inode->i_ino);
306 h.bix = cpu_to_be64(shadow->bix);
307 h.crc = logfs_crc32(&h, sizeof(h) - 4, 4);
308 h.data_crc = logfs_crc32(buf, len, 0);
310 logfs_buf_write(area, ofs, &h, sizeof(h));
311 logfs_buf_write(area, ofs + LOGFS_OBJECT_HEADERSIZE, buf, len);
313 shadow->new_ofs = ofs;
314 shadow->new_len = acc_len + LOGFS_OBJECT_HEADERSIZE;
319 static s64 logfs_segment_write_compress(struct inode *inode, void *buf,
320 struct logfs_shadow *shadow, int type, int len)
322 struct super_block *sb = inode->i_sb;
323 void *compressor_buf = logfs_super(sb)->s_compressed_je;
327 mutex_lock(&logfs_super(sb)->s_journal_mutex);
328 compr_len = logfs_compress(buf, compressor_buf, len, len);
330 if (compr_len >= 0) {
331 ret = __logfs_segment_write(inode, compressor_buf, shadow,
332 type, compr_len, COMPR_ZLIB);
334 ret = __logfs_segment_write(inode, buf, shadow, type, len,
337 mutex_unlock(&logfs_super(sb)->s_journal_mutex);
342 * logfs_segment_write - write data block to object store
343 * @inode: inode containing data
345 * Returns an errno or zero.
347 int logfs_segment_write(struct inode *inode, struct page *page,
348 struct logfs_shadow *shadow)
350 struct super_block *sb = inode->i_sb;
351 struct logfs_super *super = logfs_super(sb);
352 int do_compress, type, len;
356 super->s_flags |= LOGFS_SB_FLAG_DIRTY;
357 BUG_ON(super->s_flags & LOGFS_SB_FLAG_SHUTDOWN);
358 do_compress = logfs_inode(inode)->li_flags & LOGFS_IF_COMPRESSED;
359 if (shadow->gc_level != 0) {
360 /* temporarily disable compression for indirect blocks */
364 type = obj_type(inode, shrink_level(shadow->gc_level));
365 len = obj_len(sb, type);
368 ret = logfs_segment_write_compress(inode, buf, shadow, type,
371 ret = __logfs_segment_write(inode, buf, shadow, type, len,
375 log_segment("logfs_segment_write(%llx, %llx, %x) %llx->%llx %x->%x\n",
376 shadow->ino, shadow->bix, shadow->gc_level,
377 shadow->old_ofs, shadow->new_ofs,
378 shadow->old_len, shadow->new_len);
379 /* this BUG_ON did catch a locking bug. useful */
380 BUG_ON(!(shadow->new_ofs & (super->s_segsize - 1)));
384 int wbuf_read(struct super_block *sb, u64 ofs, size_t len, void *buf)
386 pgoff_t index = ofs >> PAGE_SHIFT;
388 long offset = ofs & (PAGE_SIZE-1);
392 copylen = min((ulong)len, PAGE_SIZE - offset);
394 page = get_mapping_page(sb, index, 1);
396 return PTR_ERR(page);
397 memcpy(buf, page_address(page) + offset, copylen);
398 page_cache_release(page);
409 * The "position" of indirect blocks is ambiguous. It can be the position
410 * of any data block somewhere behind this indirect block. So we need to
411 * normalize the positions through logfs_block_mask() before comparing.
413 static int check_pos(struct super_block *sb, u64 pos1, u64 pos2, level_t level)
415 return (pos1 & logfs_block_mask(sb, level)) !=
416 (pos2 & logfs_block_mask(sb, level));
420 static int read_seg_header(struct super_block *sb, u64 ofs,
421 struct logfs_segment_header *sh)
426 err = wbuf_read(sb, ofs, sizeof(*sh), sh);
429 crc = logfs_crc32(sh, sizeof(*sh), 4);
430 if (crc != sh->crc) {
431 printk(KERN_ERR"LOGFS: header crc error at %llx: expected %x, "
432 "got %x\n", ofs, be32_to_cpu(sh->crc),
440 static int read_obj_header(struct super_block *sb, u64 ofs,
441 struct logfs_object_header *oh)
446 err = wbuf_read(sb, ofs, sizeof(*oh), oh);
449 crc = logfs_crc32(oh, sizeof(*oh) - 4, 4);
450 if (crc != oh->crc) {
451 printk(KERN_ERR"LOGFS: header crc error at %llx: expected %x, "
452 "got %x\n", ofs, be32_to_cpu(oh->crc),
459 static void move_btree_to_page(struct inode *inode, struct page *page,
462 struct super_block *sb = inode->i_sb;
463 struct logfs_super *super = logfs_super(sb);
464 struct btree_head128 *head = &super->s_object_alias_tree;
465 struct logfs_block *block;
466 struct object_alias_item *item, *next;
468 if (!(super->s_flags & LOGFS_SB_FLAG_OBJ_ALIAS))
471 block = btree_remove128(head, inode->i_ino, page->index);
475 log_blockmove("move_btree_to_page(%llx, %llx, %x)\n",
476 block->ino, block->bix, block->level);
477 list_for_each_entry_safe(item, next, &block->item_list, list) {
478 data[item->child_no] = item->val;
479 list_del(&item->list);
480 mempool_free(item, super->s_alias_pool);
483 SetPagePrivate(page);
484 page->private = (unsigned long)block;
485 block->ops = &indirect_block_ops;
486 initialize_block_counters(page, block, data, 0);
490 * This silences a false, yet annoying gcc warning. I hate it when my editor
491 * jumps into bitops.h each time I recompile this file.
492 * TODO: Complain to gcc folks about this and upgrade compiler.
494 static unsigned long fnb(const unsigned long *addr,
495 unsigned long size, unsigned long offset)
497 return find_next_bit(addr, size, offset);
500 void move_page_to_btree(struct page *page)
502 struct logfs_block *block = logfs_block(page);
503 struct super_block *sb = block->sb;
504 struct logfs_super *super = logfs_super(sb);
505 struct object_alias_item *item;
510 if (super->s_flags & LOGFS_SB_FLAG_SHUTDOWN) {
511 block->ops->free_block(sb, block);
514 log_blockmove("move_page_to_btree(%llx, %llx, %x)\n",
515 block->ino, block->bix, block->level);
516 super->s_flags |= LOGFS_SB_FLAG_OBJ_ALIAS;
518 for (pos = 0; ; pos++) {
519 pos = fnb(block->alias_map, LOGFS_BLOCK_FACTOR, pos);
520 if (pos >= LOGFS_BLOCK_FACTOR)
523 item = mempool_alloc(super->s_alias_pool, GFP_NOFS);
524 BUG_ON(!item); /* mempool empty */
525 memset(item, 0, sizeof(*item));
527 child = kmap_atomic(page, KM_USER0);
528 item->val = child[pos];
529 kunmap_atomic(child, KM_USER0);
530 item->child_no = pos;
531 list_add(&item->list, &block->item_list);
534 ClearPagePrivate(page);
536 block->ops = &btree_block_ops;
537 err = alias_tree_insert(block->sb, block->ino, block->bix, block->level,
539 BUG_ON(err); /* mempool empty */
540 ClearPageUptodate(page);
543 static int __logfs_segment_read(struct inode *inode, void *buf,
544 u64 ofs, u64 bix, level_t level)
546 struct super_block *sb = inode->i_sb;
547 void *compressor_buf = logfs_super(sb)->s_compressed_je;
548 struct logfs_object_header oh;
553 block_len = obj_len(sb, obj_type(inode, level));
554 err = read_obj_header(sb, ofs, &oh);
559 if (be64_to_cpu(oh.ino) != inode->i_ino
560 || check_pos(sb, be64_to_cpu(oh.bix), bix, level)) {
561 printk(KERN_ERR"LOGFS: (ino, bix) don't match at %llx: "
562 "expected (%lx, %llx), got (%llx, %llx)\n",
563 ofs, inode->i_ino, bix,
564 be64_to_cpu(oh.ino), be64_to_cpu(oh.bix));
568 len = be16_to_cpu(oh.len);
572 err = wbuf_read(sb, ofs + LOGFS_OBJECT_HEADERSIZE, len, buf);
575 crc = logfs_crc32(buf, len, 0);
576 if (crc != oh.data_crc) {
577 printk(KERN_ERR"LOGFS: uncompressed data crc error at "
578 "%llx: expected %x, got %x\n", ofs,
579 be32_to_cpu(oh.data_crc),
585 mutex_lock(&logfs_super(sb)->s_journal_mutex);
586 err = wbuf_read(sb, ofs + LOGFS_OBJECT_HEADERSIZE, len,
589 mutex_unlock(&logfs_super(sb)->s_journal_mutex);
592 crc = logfs_crc32(compressor_buf, len, 0);
593 if (crc != oh.data_crc) {
594 printk(KERN_ERR"LOGFS: compressed data crc error at "
595 "%llx: expected %x, got %x\n", ofs,
596 be32_to_cpu(oh.data_crc),
598 mutex_unlock(&logfs_super(sb)->s_journal_mutex);
601 err = logfs_uncompress(compressor_buf, buf, len, block_len);
602 mutex_unlock(&logfs_super(sb)->s_journal_mutex);
604 printk(KERN_ERR"LOGFS: uncompress error at %llx\n", ofs);
617 printk(KERN_ERR"LOGFS: device is read-only now\n");
623 * logfs_segment_read - read data block from object store
624 * @inode: inode containing data
626 * @ofs: physical data offset
628 * @level: block level
630 * Returns 0 on success or a negative errno.
632 int logfs_segment_read(struct inode *inode, struct page *page,
633 u64 ofs, u64 bix, level_t level)
638 if (PageUptodate(page))
641 ofs &= ~LOGFS_FULLY_POPULATED;
644 err = __logfs_segment_read(inode, buf, ofs, bix, level);
646 move_btree_to_page(inode, page, buf);
647 SetPageUptodate(page);
650 log_segment("logfs_segment_read(%lx, %llx, %x) %llx (%d)\n",
651 inode->i_ino, bix, level, ofs, err);
655 int logfs_segment_delete(struct inode *inode, struct logfs_shadow *shadow)
657 struct super_block *sb = inode->i_sb;
658 struct logfs_super *super = logfs_super(sb);
659 struct logfs_object_header h;
663 super->s_flags |= LOGFS_SB_FLAG_DIRTY;
664 BUG_ON(super->s_flags & LOGFS_SB_FLAG_SHUTDOWN);
665 BUG_ON(shadow->old_ofs & LOGFS_FULLY_POPULATED);
666 if (!shadow->old_ofs)
669 log_segment("logfs_segment_delete(%llx, %llx, %x) %llx->%llx %x->%x\n",
670 shadow->ino, shadow->bix, shadow->gc_level,
671 shadow->old_ofs, shadow->new_ofs,
672 shadow->old_len, shadow->new_len);
673 err = read_obj_header(sb, shadow->old_ofs, &h);
674 LOGFS_BUG_ON(err, sb);
675 LOGFS_BUG_ON(be64_to_cpu(h.ino) != inode->i_ino, sb);
676 LOGFS_BUG_ON(check_pos(sb, shadow->bix, be64_to_cpu(h.bix),
677 shrink_level(shadow->gc_level)), sb);
679 if (shadow->gc_level == 0)
680 len = be16_to_cpu(h.len);
682 len = obj_len(sb, h.type);
683 shadow->old_len = len + sizeof(h);
687 static void freeseg(struct super_block *sb, u32 segno)
689 struct logfs_super *super = logfs_super(sb);
690 struct address_space *mapping = super->s_mapping_inode->i_mapping;
694 start = dev_ofs(sb, segno, 0);
695 end = dev_ofs(sb, segno + 1, 0);
696 for (ofs = start; ofs < end; ofs += PAGE_SIZE) {
697 page = find_get_page(mapping, ofs >> PAGE_SHIFT);
700 ClearPagePrivate(page);
701 page_cache_release(page);
705 int logfs_open_area(struct logfs_area *area, size_t bytes)
707 struct super_block *sb = area->a_sb;
708 struct logfs_super *super = logfs_super(sb);
711 if (area->a_is_open && area->a_used_bytes + bytes <= super->s_segsize)
714 if (area->a_is_open) {
715 u64 ofs = dev_ofs(sb, area->a_segno, area->a_written_bytes);
716 u32 len = super->s_segsize - area->a_written_bytes;
718 log_gc("logfs_close_area(%x)\n", area->a_segno);
720 super->s_devops->writeseg(area->a_sb, ofs, len);
721 freeseg(sb, area->a_segno);
725 area->a_used_bytes = 0;
726 area->a_written_bytes = 0;
728 area->a_ops->get_free_segment(area);
729 area->a_ops->get_erase_count(area);
731 log_gc("logfs_open_area(%x, %x)\n", area->a_segno, area->a_level);
732 err = area->a_ops->erase_segment(area);
734 printk(KERN_WARNING "LogFS: Error erasing segment %x\n",
736 logfs_mark_segment_bad(sb, area->a_segno);
743 void logfs_sync_area(struct logfs_area *area)
745 struct super_block *sb = area->a_sb;
746 struct logfs_super *super = logfs_super(sb);
747 u64 ofs = dev_ofs(sb, area->a_segno, area->a_written_bytes);
748 u32 len = (area->a_used_bytes - area->a_written_bytes);
750 if (super->s_writesize)
751 len &= ~(super->s_writesize - 1);
755 super->s_devops->writeseg(sb, ofs, len);
756 area->a_written_bytes += len;
759 void logfs_sync_segments(struct super_block *sb)
761 struct logfs_super *super = logfs_super(sb);
765 logfs_sync_area(super->s_area[i]);
769 * Pick a free segment to be used for this area. Effectively takes a
770 * candidate from the free list (not really a candidate anymore).
772 static void ostore_get_free_segment(struct logfs_area *area)
774 struct super_block *sb = area->a_sb;
775 struct logfs_super *super = logfs_super(sb);
777 if (super->s_free_list.count == 0) {
778 printk(KERN_ERR"LOGFS: ran out of free segments\n");
782 area->a_segno = get_best_cand(sb, &super->s_free_list, NULL);
785 static void ostore_get_erase_count(struct logfs_area *area)
787 struct logfs_segment_entry se;
790 logfs_get_segment_entry(area->a_sb, area->a_segno, &se);
791 BUG_ON(se.ec_level == cpu_to_be32(BADSEG) ||
792 se.valid == cpu_to_be32(RESERVED));
794 ec_level = be32_to_cpu(se.ec_level);
795 area->a_erase_count = (ec_level >> 4) + 1;
798 static int ostore_erase_segment(struct logfs_area *area)
800 struct super_block *sb = area->a_sb;
801 struct logfs_segment_header sh;
805 err = logfs_erase_segment(sb, area->a_segno, 0);
810 sh.type = SEG_OSTORE;
811 sh.level = (__force u8)area->a_level;
812 sh.segno = cpu_to_be32(area->a_segno);
813 sh.ec = cpu_to_be32(area->a_erase_count);
814 sh.gec = cpu_to_be64(logfs_super(sb)->s_gec);
815 sh.crc = logfs_crc32(&sh, sizeof(sh), 4);
817 logfs_set_segment_erased(sb, area->a_segno, area->a_erase_count,
820 ofs = dev_ofs(sb, area->a_segno, 0);
821 area->a_used_bytes = sizeof(sh);
822 logfs_buf_write(area, ofs, &sh, sizeof(sh));
826 static const struct logfs_area_ops ostore_area_ops = {
827 .get_free_segment = ostore_get_free_segment,
828 .get_erase_count = ostore_get_erase_count,
829 .erase_segment = ostore_erase_segment,
832 static void free_area(struct logfs_area *area)
835 freeseg(area->a_sb, area->a_segno);
839 static struct logfs_area *alloc_area(struct super_block *sb)
841 struct logfs_area *area;
843 area = kzalloc(sizeof(*area), GFP_KERNEL);
851 static void map_invalidatepage(struct page *page, unsigned long l)
856 static int map_releasepage(struct page *page, gfp_t g)
858 /* Don't release these pages */
862 static const struct address_space_operations mapping_aops = {
863 .invalidatepage = map_invalidatepage,
864 .releasepage = map_releasepage,
865 .set_page_dirty = __set_page_dirty_nobuffers,
868 int logfs_init_mapping(struct super_block *sb)
870 struct logfs_super *super = logfs_super(sb);
871 struct address_space *mapping;
874 inode = logfs_new_meta_inode(sb, LOGFS_INO_MAPPING);
876 return PTR_ERR(inode);
877 super->s_mapping_inode = inode;
878 mapping = inode->i_mapping;
879 mapping->a_ops = &mapping_aops;
880 /* Would it be possible to use __GFP_HIGHMEM as well? */
881 mapping_set_gfp_mask(mapping, GFP_NOFS);
885 int logfs_init_areas(struct super_block *sb)
887 struct logfs_super *super = logfs_super(sb);
890 super->s_alias_pool = mempool_create_kmalloc_pool(600,
891 sizeof(struct object_alias_item));
892 if (!super->s_alias_pool)
895 super->s_journal_area = alloc_area(sb);
896 if (!super->s_journal_area)
900 super->s_area[i] = alloc_area(sb);
901 if (!super->s_area[i])
903 super->s_area[i]->a_level = GC_LEVEL(i);
904 super->s_area[i]->a_ops = &ostore_area_ops;
906 btree_init_mempool128(&super->s_object_alias_tree,
907 super->s_btree_pool);
911 for (i--; i >= 0; i--)
912 free_area(super->s_area[i]);
913 free_area(super->s_journal_area);
914 mempool_destroy(super->s_alias_pool);
918 void logfs_cleanup_areas(struct super_block *sb)
920 struct logfs_super *super = logfs_super(sb);
923 btree_grim_visitor128(&super->s_object_alias_tree, 0, kill_alias);
925 free_area(super->s_area[i]);
926 free_area(super->s_journal_area);
927 destroy_meta_inode(super->s_mapping_inode);