/* * fs/logfs/segment.c - Handling the Object Store * * As should be obvious for Linux kernel code, license is GPLv2 * * Copyright (c) 2005-2008 Joern Engel <joern@logfs.org> * * Object store or ostore makes up the complete device with exception of * the superblock and journal areas. Apart from its own metadata it stores * three kinds of objects: inodes, dentries and blocks, both data and indirect. */#include "logfs.h"#include <linux/slab.h> static int logfs_mark_segment_bad(struct super_block *sb, u32 segno){ struct logfs_super *super = logfs_super(sb); struct btree_head32 *head = &super->s_reserved_segments; int err; err = btree_insert32(head, segno, (void *)1, GFP_NOFS); if (err) return err; logfs_super(sb)->s_bad_segments++; /* FIXME: write to journal */ return 0;} int logfs_erase_segment(struct super_block *sb, u32 segno, int ensure_erase){ struct logfs_super *super = logfs_super(sb); super->s_gec++; return super->s_devops->erase(sb, (u64)segno << super->s_segshift, super->s_segsize, ensure_erase);} static s64 logfs_get_free_bytes(struct logfs_area *area, size_t bytes){ s32 ofs; logfs_open_area(area, bytes); ofs = area->a_used_bytes; area->a_used_bytes += bytes; BUG_ON(area->a_used_bytes >= logfs_super(area->a_sb)->s_segsize); return dev_ofs(area->a_sb, area->a_segno, ofs);} static struct page *get_mapping_page(struct super_block *sb, pgoff_t index, int use_filler){ struct logfs_super *super = logfs_super(sb); struct address_space *mapping = super->s_mapping_inode->i_mapping; filler_t *filler = super->s_devops->readpage; struct page *page; BUG_ON(mapping_gfp_mask(mapping) & __GFP_FS); if (use_filler) page = read_cache_page(mapping, index, filler, sb); else { page = find_or_create_page(mapping, index, GFP_NOFS); unlock_page(page); } return page;} int __logfs_buf_write(struct logfs_area *area, u64 ofs, void *buf, size_t len, int use_filler){ pgoff_t index = ofs >> PAGE_SHIFT; struct page *page; long offset = ofs & (PAGE_SIZE-1); long copylen; /* Only logfs_wbuf_recover may use len==0 */ BUG_ON(!len && !use_filler); do { copylen = min((ulong)len, PAGE_SIZE - offset); page = get_mapping_page(area->a_sb, index, use_filler); if (IS_ERR(page)) return PTR_ERR(page); BUG_ON(!page); /* FIXME: reserve a pool */ SetPageUptodate(page); memcpy(page_address(page) + offset, buf, copylen); if (!PagePrivate(page)) { SetPagePrivate(page); page_cache_get(page); } page_cache_release(page); buf += copylen; len -= copylen; offset = 0; index++; } while (len); return 0;} static void pad_partial_page(struct logfs_area *area){ struct super_block *sb = area->a_sb; struct page *page; u64 ofs = dev_ofs(sb, area->a_segno, area->a_used_bytes); pgoff_t index = ofs >> PAGE_SHIFT; long offset = ofs & (PAGE_SIZE-1); u32 len = PAGE_SIZE - offset; if (len % PAGE_SIZE) { page = get_mapping_page(sb, index, 0); BUG_ON(!page); /* FIXME: reserve a pool */ memset(page_address(page) + offset, 0xff, len); if (!PagePrivate(page)) { SetPagePrivate(page); page_cache_get(page); } page_cache_release(page); }} static void pad_full_pages(struct logfs_area *area){ struct super_block *sb = area->a_sb; struct logfs_super *super = logfs_super(sb); u64 ofs = dev_ofs(sb, area->a_segno, area->a_used_bytes); u32 len = super->s_segsize - area->a_used_bytes; pgoff_t index = PAGE_CACHE_ALIGN(ofs) >> PAGE_CACHE_SHIFT; pgoff_t no_indizes = len >> PAGE_CACHE_SHIFT; struct page *page; while (no_indizes) { page = get_mapping_page(sb, index, 0); BUG_ON(!page); /* FIXME: reserve a pool */ SetPageUptodate(page); memset(page_address(page), 0xff, PAGE_CACHE_SIZE); if (!PagePrivate(page)) { SetPagePrivate(page); page_cache_get(page); } page_cache_release(page); index++; no_indizes--; }} /* * bdev_writeseg will write full pages. Memset the tail to prevent data leaks. * Also make sure we allocate (and memset) all pages for final writeout. */static void pad_wbuf(struct logfs_area *area, int final){ pad_partial_page(area); if (final) pad_full_pages(area);} /* * We have to be careful with the alias tree. Since lookup is done by bix, * it needs to be normalized, so 14, 15, 16, etc. all match when dealing with * indirect blocks. So always use it through accessor functions. */static void *alias_tree_lookup(struct super_block *sb, u64 ino, u64 bix, level_t level){ struct btree_head128 *head = &logfs_super(sb)->s_object_alias_tree; pgoff_t index = logfs_pack_index(bix, level); return btree_lookup128(head, ino, index);} static int alias_tree_insert(struct super_block *sb, u64 ino, u64 bix, level_t level, void *val){ struct btree_head128 *head = &logfs_super(sb)->s_object_alias_tree; pgoff_t index = logfs_pack_index(bix, level); return btree_insert128(head, ino, index, val, GFP_NOFS);} static int btree_write_alias(struct super_block *sb, struct logfs_block *block, write_alias_t *write_one_alias){ struct object_alias_item *item; int err; list_for_each_entry(item, &block->item_list, list) { err = write_alias_journal(sb, block->ino, block->bix, block->level, item->child_no, item->val); if (err) return err; } return 0;} static struct logfs_block_ops btree_block_ops = { .write_block = btree_write_block, .free_block = __free_block, .write_alias = btree_write_alias,}; int logfs_load_object_aliases(struct super_block *sb, struct logfs_obj_alias *oa, int count){ struct logfs_super *super = logfs_super(sb); struct logfs_block *block; struct object_alias_item *item; u64 ino, bix; level_t level; int i, err; super->s_flags |= LOGFS_SB_FLAG_OBJ_ALIAS; count /= sizeof(*oa); for (i = 0; i < count; i++) { item = mempool_alloc(super->s_alias_pool, GFP_NOFS); if (!item) return -ENOMEM; memset(item, 0, sizeof(*item)); super->s_no_object_aliases++; item->val = oa[i].val; item->child_no = be16_to_cpu(oa[i].child_no); ino = be64_to_cpu(oa[i].ino); bix = be64_to_cpu(oa[i].bix); level = LEVEL(oa[i].level); log_aliases("logfs_load_object_aliases(%llx, %llx, %x, %x) %llx\n", ino, bix, level, item->child_no, be64_to_cpu(item->val)); block = alias_tree_lookup(sb, ino, bix, level); if (!block) { block = __alloc_block(sb, ino, bix, level); block->ops = &btree_block_ops; err = alias_tree_insert(sb, ino, bix, level, block); BUG_ON(err); /* mempool empty */ } if (test_and_set_bit(item->child_no, block->alias_map)) { printk(KERN_ERR"LogFS: Alias collision detected\n"); return -EIO; } list_move_tail(&block->alias_list, &super->s_object_alias); list_add(&item->list, &block->item_list); } return 0;} static void kill_alias(void *_block, unsigned long ignore0, u64 ignore1, u64 ignore2, size_t ignore3){ struct logfs_block *block = _block; struct super_block *sb = block->sb; struct logfs_super *super = logfs_super(sb); struct object_alias_item *item; while (!list_empty(&block->item_list)) { item = list_entry(block->item_list.next, typeof(*item), list); list_del(&item->list); mempool_free(item, super->s_alias_pool); } block->ops->free_block(sb, block);} static int obj_type(struct inode *inode, level_t level){ if (level == 0) { if (S_ISDIR(inode->i_mode)) return OBJ_DENTRY; if (inode->i_ino == LOGFS_INO_MASTER) return OBJ_INODE; } return OBJ_BLOCK;} static int obj_len(struct super_block *sb, int obj_type){ switch (obj_type) { case OBJ_DENTRY: return sizeof(struct logfs_disk_dentry); case OBJ_INODE: return sizeof(struct logfs_disk_inode); case OBJ_BLOCK: return sb->s_blocksize; default: BUG(); }} static int __logfs_segment_write(struct inode *inode, void *buf, struct logfs_shadow *shadow, int type, int len, int compr){ struct logfs_area *area; struct super_block *sb = inode->i_sb; s64 ofs; struct logfs_object_header h; int acc_len; if (shadow->gc_level == 0) acc_len = len; else acc_len = obj_len(sb, type); area = get_area(sb, shadow->gc_level); ofs = logfs_get_free_bytes(area, len + LOGFS_OBJECT_HEADERSIZE); LOGFS_BUG_ON(ofs <= 0, sb); /* * Order is important. logfs_get_free_bytes(), by modifying the * segment file, may modify the content of the very page we're about * to write now. Which is fine, as long as the calculated crc and * written data still match. So do the modifications _before_ * calculating the crc. */ h.len = cpu_to_be16(len); h.type = type; h.compr = compr; h.ino = cpu_to_be64(inode->i_ino); h.bix = cpu_to_be64(shadow->bix); h.crc = logfs_crc32(&h, sizeof(h) - 4, 4); h.data_crc = logfs_crc32(buf, len, 0); logfs_buf_write(area, ofs, &h, sizeof(h)); logfs_buf_write(area, ofs + LOGFS_OBJECT_HEADERSIZE, buf, len); shadow->new_ofs = ofs; shadow->new_len = acc_len + LOGFS_OBJECT_HEADERSIZE; return 0;} static s64 logfs_segment_write_compress(struct inode *inode, void *buf, struct logfs_shadow *shadow, int type, int len){ struct super_block *sb = inode->i_sb; void *compressor_buf = logfs_super(sb)->s_compressed_je; ssize_t compr_len; int ret; mutex_lock(&logfs_super(sb)->s_journal_mutex); compr_len = logfs_compress(buf, compressor_buf, len, len); if (compr_len >= 0) { ret = __logfs_segment_write(inode, compressor_buf, shadow, type, compr_len, COMPR_ZLIB); } else { ret = __logfs_segment_write(inode, buf, shadow, type, len, COMPR_NONE); } mutex_unlock(&logfs_super(sb)->s_journal_mutex); return ret;} /** * logfs_segment_write - write data block to object store * @inode: inode containing data * * Returns an errno or zero. */int logfs_segment_write(struct inode *inode, struct page *page, struct logfs_shadow *shadow){ struct super_block *sb = inode->i_sb; struct logfs_super *super = logfs_super(sb); int do_compress, type, len; int ret; void *buf; super->s_flags |= LOGFS_SB_FLAG_DIRTY; BUG_ON(super->s_flags & LOGFS_SB_FLAG_SHUTDOWN); do_compress = logfs_inode(inode)->li_flags & LOGFS_IF_COMPRESSED; if (shadow->gc_level != 0) { /* temporarily disable compression for indirect blocks */ do_compress = 0; } type = obj_type(inode, shrink_level(shadow->gc_level)); len = obj_len(sb, type); buf = kmap(page); if (do_compress) ret = logfs_segment_write_compress(inode, buf, shadow, type, len); else ret = __logfs_segment_write(inode, buf, shadow, type, len, COMPR_NONE); kunmap(page); log_segment("logfs_segment_write(%llx, %llx, %x) %llx->%llx %x->%x\n", shadow->ino, shadow->bix, shadow->gc_level, shadow->old_ofs, shadow->new_ofs, shadow->old_len, shadow->new_len); /* this BUG_ON did catch a locking bug. useful */ BUG_ON(!(shadow->new_ofs & (super->s_segsize - 1))); return ret;} int wbuf_read(struct super_block *sb, u64 ofs, size_t len, void *buf){ pgoff_t index = ofs >> PAGE_SHIFT; struct page *page; long offset = ofs & (PAGE_SIZE-1); long copylen; while (len) { copylen = min((ulong)len, PAGE_SIZE - offset); page = get_mapping_page(sb, index, 1); if (IS_ERR(page)) return PTR_ERR(page); memcpy(buf, page_address(page) + offset, copylen); page_cache_release(page); buf += copylen; len -= copylen; offset = 0; index++; } return 0;} /* * The "position" of indirect blocks is ambiguous. It can be the position * of any data block somewhere behind this indirect block. So we need to * normalize the positions through logfs_block_mask() before comparing. */static int check_pos(struct super_block *sb, u64 pos1, u64 pos2, level_t level){ return (pos1 & logfs_block_mask(sb, level)) != (pos2 & logfs_block_mask(sb, level));} #if 0static int read_seg_header(struct super_block *sb, u64 ofs, struct logfs_segment_header *sh){ __be32 crc; int err; err = wbuf_read(sb, ofs, sizeof(*sh), sh); if (err) return err; crc = logfs_crc32(sh, sizeof(*sh), 4); if (crc != sh->crc) { printk(KERN_ERR"LOGFS: header crc error at %llx: expected %x, " "got %x\n", ofs, be32_to_cpu(sh->crc), be32_to_cpu(crc)); return -EIO; } return 0;}#endif static int read_obj_header(struct super_block *sb, u64 ofs, struct logfs_object_header *oh){ __be32 crc; int err; err = wbuf_read(sb, ofs, sizeof(*oh), oh); if (err) return err; crc = logfs_crc32(oh, sizeof(*oh) - 4, 4); if (crc != oh->crc) { printk(KERN_ERR"LOGFS: header crc error at %llx: expected %x, " "got %x\n", ofs, be32_to_cpu(oh->crc), be32_to_cpu(crc)); return -EIO; } return 0;} static void move_btree_to_page(struct inode *inode, struct page *page, __be64 *data){ struct super_block *sb = inode->i_sb; struct logfs_super *super = logfs_super(sb); struct btree_head128 *head = &super->s_object_alias_tree; struct logfs_block *block; struct object_alias_item *item, *next; if (!(super->s_flags & LOGFS_SB_FLAG_OBJ_ALIAS)) return; block = btree_remove128(head, inode->i_ino, page->index); if (!block) return; log_blockmove("move_btree_to_page(%llx, %llx, %x)\n", block->ino, block->bix, block->level); list_for_each_entry_safe(item, next, &block->item_list, list) { data[item->child_no] = item->val; list_del(&item->list); mempool_free(item, super->s_alias_pool); } block->page = page; if (!PagePrivate(page)) { SetPagePrivate(page);Lines 1–500 of 959. Load more
/* * fs/logfs/segment.c - Handling the Object Store * * As should be obvious for Linux kernel code, license is GPLv2 * * Copyright (c) 2005-2008 Joern Engel <joern@logfs.org> * * Object store or ostore makes up the complete device with exception of * the superblock and journal areas. Apart from its own metadata it stores * three kinds of objects: inodes, dentries and blocks, both data and indirect. */ #include "logfs.h" #include <linux/slab.h> static int logfs_mark_segment_bad(struct super_block *sb, u32 segno) { struct logfs_super *super = logfs_super(sb); struct btree_head32 *head = &super->s_reserved_segments; int err; err = btree_insert32(head, segno, (void *)1, GFP_NOFS); if (err) return err; logfs_super(sb)->s_bad_segments++; /* FIXME: write to journal */ return 0; } int logfs_erase_segment(struct super_block *sb, u32 segno, int ensure_erase) { struct logfs_super *super = logfs_super(sb); super->s_gec++; return super->s_devops->erase(sb, (u64)segno << super->s_segshift, super->s_segsize, ensure_erase); } static s64 logfs_get_free_bytes(struct logfs_area *area, size_t bytes) { s32 ofs; logfs_open_area(area, bytes); ofs = area->a_used_bytes; area->a_used_bytes += bytes; BUG_ON(area->a_used_bytes >= logfs_super(area->a_sb)->s_segsize); return dev_ofs(area->a_sb, area->a_segno, ofs); } static struct page *get_mapping_page(struct super_block *sb, pgoff_t index, int use_filler) { struct logfs_super *super = logfs_super(sb); struct address_space *mapping = super->s_mapping_inode->i_mapping; filler_t *filler = super->s_devops->readpage; struct page *page; BUG_ON(mapping_gfp_mask(mapping) & __GFP_FS); if (use_filler) page = read_cache_page(mapping, index, filler, sb); else { page = find_or_create_page(mapping, index, GFP_NOFS); unlock_page(page); } return page; } int __logfs_buf_write(struct logfs_area *area, u64 ofs, void *buf, size_t len, int use_filler) { pgoff_t index = ofs >> PAGE_SHIFT; struct page *page; long offset = ofs & (PAGE_SIZE-1); long copylen; /* Only logfs_wbuf_recover may use len==0 */ BUG_ON(!len && !use_filler); do { copylen = min((ulong)len, PAGE_SIZE - offset); page = get_mapping_page(area->a_sb, index, use_filler); if (IS_ERR(page)) return PTR_ERR(page); BUG_ON(!page); /* FIXME: reserve a pool */ SetPageUptodate(page); memcpy(page_address(page) + offset, buf, copylen); if (!PagePrivate(page)) { SetPagePrivate(page); page_cache_get(page); } page_cache_release(page); buf += copylen; len -= copylen; offset = 0; index++; } while (len); return 0; } static void pad_partial_page(struct logfs_area *area) { struct super_block *sb = area->a_sb; struct page *page; u64 ofs = dev_ofs(sb, area->a_segno, area->a_used_bytes); pgoff_t index = ofs >> PAGE_SHIFT; long offset = ofs & (PAGE_SIZE-1); u32 len = PAGE_SIZE - offset; if (len % PAGE_SIZE) { page = get_mapping_page(sb, index, 0); BUG_ON(!page); /* FIXME: reserve a pool */ memset(page_address(page) + offset, 0xff, len); if (!PagePrivate(page)) { SetPagePrivate(page); page_cache_get(page); } page_cache_release(page); } } static void pad_full_pages(struct logfs_area *area) { struct super_block *sb = area->a_sb; struct logfs_super *super = logfs_super(sb); u64 ofs = dev_ofs(sb, area->a_segno, area->a_used_bytes); u32 len = super->s_segsize - area->a_used_bytes; pgoff_t index = PAGE_CACHE_ALIGN(ofs) >> PAGE_CACHE_SHIFT; pgoff_t no_indizes = len >> PAGE_CACHE_SHIFT; struct page *page; while (no_indizes) { page = get_mapping_page(sb, index, 0); BUG_ON(!page); /* FIXME: reserve a pool */ SetPageUptodate(page); memset(page_address(page), 0xff, PAGE_CACHE_SIZE); if (!PagePrivate(page)) { SetPagePrivate(page); page_cache_get(page); } page_cache_release(page); index++; no_indizes--; } } /* * bdev_writeseg will write full pages. Memset the tail to prevent data leaks. * Also make sure we allocate (and memset) all pages for final writeout. */ static void pad_wbuf(struct logfs_area *area, int final) { pad_partial_page(area); if (final) pad_full_pages(area); } /* * We have to be careful with the alias tree. Since lookup is done by bix, * it needs to be normalized, so 14, 15, 16, etc. all match when dealing with * indirect blocks. So always use it through accessor functions. */ static void *alias_tree_lookup(struct super_block *sb, u64 ino, u64 bix, level_t level) { struct btree_head128 *head = &logfs_super(sb)->s_object_alias_tree; pgoff_t index = logfs_pack_index(bix, level); return btree_lookup128(head, ino, index); } static int alias_tree_insert(struct super_block *sb, u64 ino, u64 bix, level_t level, void *val) { struct btree_head128 *head = &logfs_super(sb)->s_object_alias_tree; pgoff_t index = logfs_pack_index(bix, level); return btree_insert128(head, ino, index, val, GFP_NOFS); } static int btree_write_alias(struct super_block *sb, struct logfs_block *block, write_alias_t *write_one_alias) { struct object_alias_item *item; int err; list_for_each_entry(item, &block->item_list, list) { err = write_alias_journal(sb, block->ino, block->bix, block->level, item->child_no, item->val); if (err) return err; } return 0; } static struct logfs_block_ops btree_block_ops = { .write_block = btree_write_block, .free_block = __free_block, .write_alias = btree_write_alias, }; int logfs_load_object_aliases(struct super_block *sb, struct logfs_obj_alias *oa, int count) { struct logfs_super *super = logfs_super(sb); struct logfs_block *block; struct object_alias_item *item; u64 ino, bix; level_t level; int i, err; super->s_flags |= LOGFS_SB_FLAG_OBJ_ALIAS; count /= sizeof(*oa); for (i = 0; i < count; i++) { item = mempool_alloc(super->s_alias_pool, GFP_NOFS); if (!item) return -ENOMEM; memset(item, 0, sizeof(*item)); super->s_no_object_aliases++; item->val = oa[i].val; item->child_no = be16_to_cpu(oa[i].child_no); ino = be64_to_cpu(oa[i].ino); bix = be64_to_cpu(oa[i].bix); level = LEVEL(oa[i].level); log_aliases("logfs_load_object_aliases(%llx, %llx, %x, %x) %llx\n", ino, bix, level, item->child_no, be64_to_cpu(item->val)); block = alias_tree_lookup(sb, ino, bix, level); if (!block) { block = __alloc_block(sb, ino, bix, level); block->ops = &btree_block_ops; err = alias_tree_insert(sb, ino, bix, level, block); BUG_ON(err); /* mempool empty */ } if (test_and_set_bit(item->child_no, block->alias_map)) { printk(KERN_ERR"LogFS: Alias collision detected\n"); return -EIO; } list_move_tail(&block->alias_list, &super->s_object_alias); list_add(&item->list, &block->item_list); } return 0; } static void kill_alias(void *_block, unsigned long ignore0, u64 ignore1, u64 ignore2, size_t ignore3) { struct logfs_block *block = _block; struct super_block *sb = block->sb; struct logfs_super *super = logfs_super(sb); struct object_alias_item *item; while (!list_empty(&block->item_list)) { item = list_entry(block->item_list.next, typeof(*item), list); list_del(&item->list); mempool_free(item, super->s_alias_pool); } block->ops->free_block(sb, block); } static int obj_type(struct inode *inode, level_t level) { if (level == 0) { if (S_ISDIR(inode->i_mode)) return OBJ_DENTRY; if (inode->i_ino == LOGFS_INO_MASTER) return OBJ_INODE; } return OBJ_BLOCK; } static int obj_len(struct super_block *sb, int obj_type) { switch (obj_type) { case OBJ_DENTRY: return sizeof(struct logfs_disk_dentry); case OBJ_INODE: return sizeof(struct logfs_disk_inode); case OBJ_BLOCK: return sb->s_blocksize; default: BUG(); } } static int __logfs_segment_write(struct inode *inode, void *buf, struct logfs_shadow *shadow, int type, int len, int compr) { struct logfs_area *area; struct super_block *sb = inode->i_sb; s64 ofs; struct logfs_object_header h; int acc_len; if (shadow->gc_level == 0) acc_len = len; else acc_len = obj_len(sb, type); area = get_area(sb, shadow->gc_level); ofs = logfs_get_free_bytes(area, len + LOGFS_OBJECT_HEADERSIZE); LOGFS_BUG_ON(ofs <= 0, sb); /* * Order is important. logfs_get_free_bytes(), by modifying the * segment file, may modify the content of the very page we're about * to write now. Which is fine, as long as the calculated crc and * written data still match. So do the modifications _before_ * calculating the crc. */ h.len = cpu_to_be16(len); h.type = type; h.compr = compr; h.ino = cpu_to_be64(inode->i_ino); h.bix = cpu_to_be64(shadow->bix); h.crc = logfs_crc32(&h, sizeof(h) - 4, 4); h.data_crc = logfs_crc32(buf, len, 0); logfs_buf_write(area, ofs, &h, sizeof(h)); logfs_buf_write(area, ofs + LOGFS_OBJECT_HEADERSIZE, buf, len); shadow->new_ofs = ofs; shadow->new_len = acc_len + LOGFS_OBJECT_HEADERSIZE; return 0; } static s64 logfs_segment_write_compress(struct inode *inode, void *buf, struct logfs_shadow *shadow, int type, int len) { struct super_block *sb = inode->i_sb; void *compressor_buf = logfs_super(sb)->s_compressed_je; ssize_t compr_len; int ret; mutex_lock(&logfs_super(sb)->s_journal_mutex); compr_len = logfs_compress(buf, compressor_buf, len, len); if (compr_len >= 0) { ret = __logfs_segment_write(inode, compressor_buf, shadow, type, compr_len, COMPR_ZLIB); } else { ret = __logfs_segment_write(inode, buf, shadow, type, len, COMPR_NONE); } mutex_unlock(&logfs_super(sb)->s_journal_mutex); return ret; } /** * logfs_segment_write - write data block to object store * @inode: inode containing data * * Returns an errno or zero. */ int logfs_segment_write(struct inode *inode, struct page *page, struct logfs_shadow *shadow) { struct super_block *sb = inode->i_sb; struct logfs_super *super = logfs_super(sb); int do_compress, type, len; int ret; void *buf; super->s_flags |= LOGFS_SB_FLAG_DIRTY; BUG_ON(super->s_flags & LOGFS_SB_FLAG_SHUTDOWN); do_compress = logfs_inode(inode)->li_flags & LOGFS_IF_COMPRESSED; if (shadow->gc_level != 0) { /* temporarily disable compression for indirect blocks */ do_compress = 0; } type = obj_type(inode, shrink_level(shadow->gc_level)); len = obj_len(sb, type); buf = kmap(page); if (do_compress) ret = logfs_segment_write_compress(inode, buf, shadow, type, len); else ret = __logfs_segment_write(inode, buf, shadow, type, len, COMPR_NONE); kunmap(page); log_segment("logfs_segment_write(%llx, %llx, %x) %llx->%llx %x->%x\n", shadow->ino, shadow->bix, shadow->gc_level, shadow->old_ofs, shadow->new_ofs, shadow->old_len, shadow->new_len); /* this BUG_ON did catch a locking bug. useful */ BUG_ON(!(shadow->new_ofs & (super->s_segsize - 1))); return ret; } int wbuf_read(struct super_block *sb, u64 ofs, size_t len, void *buf) { pgoff_t index = ofs >> PAGE_SHIFT; struct page *page; long offset = ofs & (PAGE_SIZE-1); long copylen; while (len) { copylen = min((ulong)len, PAGE_SIZE - offset); page = get_mapping_page(sb, index, 1); if (IS_ERR(page)) return PTR_ERR(page); memcpy(buf, page_address(page) + offset, copylen); page_cache_release(page); buf += copylen; len -= copylen; offset = 0; index++; } return 0; } /* * The "position" of indirect blocks is ambiguous. It can be the position * of any data block somewhere behind this indirect block. So we need to * normalize the positions through logfs_block_mask() before comparing. */ static int check_pos(struct super_block *sb, u64 pos1, u64 pos2, level_t level) { return (pos1 & logfs_block_mask(sb, level)) != (pos2 & logfs_block_mask(sb, level)); } #if 0 static int read_seg_header(struct super_block *sb, u64 ofs, struct logfs_segment_header *sh) { __be32 crc; int err; err = wbuf_read(sb, ofs, sizeof(*sh), sh); if (err) return err; crc = logfs_crc32(sh, sizeof(*sh), 4); if (crc != sh->crc) { printk(KERN_ERR"LOGFS: header crc error at %llx: expected %x, " "got %x\n", ofs, be32_to_cpu(sh->crc), be32_to_cpu(crc)); return -EIO; } return 0; } #endif static int read_obj_header(struct super_block *sb, u64 ofs, struct logfs_object_header *oh) { __be32 crc; int err; err = wbuf_read(sb, ofs, sizeof(*oh), oh); if (err) return err; crc = logfs_crc32(oh, sizeof(*oh) - 4, 4); if (crc != oh->crc) { printk(KERN_ERR"LOGFS: header crc error at %llx: expected %x, " "got %x\n", ofs, be32_to_cpu(oh->crc), be32_to_cpu(crc)); return -EIO; } return 0; } static void move_btree_to_page(struct inode *inode, struct page *page, __be64 *data) { struct super_block *sb = inode->i_sb; struct logfs_super *super = logfs_super(sb); struct btree_head128 *head = &super->s_object_alias_tree; struct logfs_block *block; struct object_alias_item *item, *next; if (!(super->s_flags & LOGFS_SB_FLAG_OBJ_ALIAS)) return; block = btree_remove128(head, inode->i_ino, page->index); if (!block) return; log_blockmove("move_btree_to_page(%llx, %llx, %x)\n", block->ino, block->bix, block->level); list_for_each_entry_safe(item, next, &block->item_list, list) { data[item->child_no] = item->val; list_del(&item->list); mempool_free(item, super->s_alias_pool); } block->page = page; if (!PagePrivate(page)) { SetPagePrivate(page);