2009-11-20 12:13:39 -07:00
|
|
|
/*
|
|
|
|
* 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 cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 02:04:11 -06:00
|
|
|
#include <linux/slab.h>
|
2009-11-20 12:13:39 -07:00
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2010-03-04 13:30:58 -07:00
|
|
|
int logfs_erase_segment(struct super_block *sb, u32 segno, int ensure_erase)
|
2009-11-20 12:13:39 -07:00
|
|
|
{
|
|
|
|
struct logfs_super *super = logfs_super(sb);
|
|
|
|
|
|
|
|
super->s_gec++;
|
|
|
|
|
|
|
|
return super->s_devops->erase(sb, (u64)segno << super->s_segshift,
|
2010-03-04 13:30:58 -07:00
|
|
|
super->s_segsize, ensure_erase);
|
2009-11-20 12:13:39 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
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);
|
2014-01-23 16:53:47 -07:00
|
|
|
if (page)
|
|
|
|
unlock_page(page);
|
2009-11-20 12:13:39 -07:00
|
|
|
}
|
|
|
|
return page;
|
|
|
|
}
|
|
|
|
|
2010-05-03 12:54:34 -06:00
|
|
|
int __logfs_buf_write(struct logfs_area *area, u64 ofs, void *buf, size_t len,
|
2009-11-20 12:13:39 -07:00
|
|
|
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);
|
2010-05-03 12:54:34 -06:00
|
|
|
if (IS_ERR(page))
|
|
|
|
return PTR_ERR(page);
|
2009-11-20 12:13:39 -07:00
|
|
|
BUG_ON(!page); /* FIXME: reserve a pool */
|
2010-05-03 12:54:34 -06:00
|
|
|
SetPageUptodate(page);
|
2009-11-20 12:13:39 -07:00
|
|
|
memcpy(page_address(page) + offset, buf, copylen);
|
2011-11-25 22:30:47 -07:00
|
|
|
|
|
|
|
if (!PagePrivate(page)) {
|
|
|
|
SetPagePrivate(page);
|
|
|
|
page_cache_get(page);
|
|
|
|
}
|
2009-11-20 12:13:39 -07:00
|
|
|
page_cache_release(page);
|
|
|
|
|
|
|
|
buf += copylen;
|
|
|
|
len -= copylen;
|
|
|
|
offset = 0;
|
|
|
|
index++;
|
|
|
|
} while (len);
|
2010-05-03 12:54:34 -06:00
|
|
|
return 0;
|
2009-11-20 12:13:39 -07:00
|
|
|
}
|
|
|
|
|
2010-03-28 04:47:09 -06:00
|
|
|
static void pad_partial_page(struct logfs_area *area)
|
2009-11-20 12:13:39 -07:00
|
|
|
{
|
|
|
|
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;
|
|
|
|
|
2010-03-28 04:47:09 -06:00
|
|
|
if (len % PAGE_SIZE) {
|
|
|
|
page = get_mapping_page(sb, index, 0);
|
2009-11-20 12:13:39 -07:00
|
|
|
BUG_ON(!page); /* FIXME: reserve a pool */
|
|
|
|
memset(page_address(page) + offset, 0xff, len);
|
2011-11-25 22:30:47 -07:00
|
|
|
if (!PagePrivate(page)) {
|
|
|
|
SetPagePrivate(page);
|
|
|
|
page_cache_get(page);
|
|
|
|
}
|
2009-11-20 12:13:39 -07:00
|
|
|
page_cache_release(page);
|
|
|
|
}
|
2010-03-28 04:47:09 -06:00
|
|
|
}
|
2009-11-20 12:13:39 -07:00
|
|
|
|
2010-03-28 04:47:09 -06:00
|
|
|
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;
|
2009-11-20 12:13:39 -07:00
|
|
|
|
2010-03-28 04:47:09 -06:00
|
|
|
while (no_indizes) {
|
|
|
|
page = get_mapping_page(sb, index, 0);
|
2009-11-20 12:13:39 -07:00
|
|
|
BUG_ON(!page); /* FIXME: reserve a pool */
|
2010-03-28 04:47:09 -06:00
|
|
|
SetPageUptodate(page);
|
|
|
|
memset(page_address(page), 0xff, PAGE_CACHE_SIZE);
|
2011-11-25 22:30:47 -07:00
|
|
|
if (!PagePrivate(page)) {
|
|
|
|
SetPagePrivate(page);
|
|
|
|
page_cache_get(page);
|
|
|
|
}
|
2009-11-20 12:13:39 -07:00
|
|
|
page_cache_release(page);
|
2010-03-28 04:47:09 -06:00
|
|
|
index++;
|
|
|
|
no_indizes--;
|
2009-11-20 12:13:39 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-03-28 04:47:09 -06:00
|
|
|
/*
|
|
|
|
* 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);
|
|
|
|
}
|
|
|
|
|
2009-11-20 12:13:39 -07:00
|
|
|
/*
|
|
|
|
* 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;
|
|
|
|
|
2010-03-04 13:36:19 -07:00
|
|
|
super->s_flags |= LOGFS_SB_FLAG_DIRTY;
|
|
|
|
BUG_ON(super->s_flags & LOGFS_SB_FLAG_SHUTDOWN);
|
2009-11-20 12:13:39 -07:00
|
|
|
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;
|
2011-11-25 22:30:47 -07:00
|
|
|
|
|
|
|
if (!PagePrivate(page)) {
|
|
|
|
SetPagePrivate(page);
|
|
|
|
page_cache_get(page);
|
|
|
|
set_page_private(page, (unsigned long) block);
|
|
|
|
}
|
2009-11-20 12:13:39 -07:00
|
|
|
block->ops = &indirect_block_ops;
|
|
|
|
initialize_block_counters(page, block, data, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This silences a false, yet annoying gcc warning. I hate it when my editor
|
|
|
|
* jumps into bitops.h each time I recompile this file.
|
|
|
|
* TODO: Complain to gcc folks about this and upgrade compiler.
|
|
|
|
*/
|
|
|
|
static unsigned long fnb(const unsigned long *addr,
|
|
|
|
unsigned long size, unsigned long offset)
|
|
|
|
{
|
|
|
|
return find_next_bit(addr, size, offset);
|
|
|
|
}
|
|
|
|
|
|
|
|
void move_page_to_btree(struct page *page)
|
|
|
|
{
|
|
|
|
struct logfs_block *block = logfs_block(page);
|
|
|
|
struct super_block *sb = block->sb;
|
|
|
|
struct logfs_super *super = logfs_super(sb);
|
|
|
|
struct object_alias_item *item;
|
|
|
|
unsigned long pos;
|
|
|
|
__be64 *child;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
if (super->s_flags & LOGFS_SB_FLAG_SHUTDOWN) {
|
|
|
|
block->ops->free_block(sb, block);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
log_blockmove("move_page_to_btree(%llx, %llx, %x)\n",
|
|
|
|
block->ino, block->bix, block->level);
|
|
|
|
super->s_flags |= LOGFS_SB_FLAG_OBJ_ALIAS;
|
|
|
|
|
|
|
|
for (pos = 0; ; pos++) {
|
|
|
|
pos = fnb(block->alias_map, LOGFS_BLOCK_FACTOR, pos);
|
|
|
|
if (pos >= LOGFS_BLOCK_FACTOR)
|
|
|
|
break;
|
|
|
|
|
|
|
|
item = mempool_alloc(super->s_alias_pool, GFP_NOFS);
|
|
|
|
BUG_ON(!item); /* mempool empty */
|
|
|
|
memset(item, 0, sizeof(*item));
|
|
|
|
|
2011-11-25 08:14:31 -07:00
|
|
|
child = kmap_atomic(page);
|
2009-11-20 12:13:39 -07:00
|
|
|
item->val = child[pos];
|
2011-11-25 08:14:31 -07:00
|
|
|
kunmap_atomic(child);
|
2009-11-20 12:13:39 -07:00
|
|
|
item->child_no = pos;
|
|
|
|
list_add(&item->list, &block->item_list);
|
|
|
|
}
|
|
|
|
block->page = NULL;
|
2011-11-25 22:30:47 -07:00
|
|
|
|
|
|
|
if (PagePrivate(page)) {
|
|
|
|
ClearPagePrivate(page);
|
|
|
|
page_cache_release(page);
|
|
|
|
set_page_private(page, 0);
|
|
|
|
}
|
2009-11-20 12:13:39 -07:00
|
|
|
block->ops = &btree_block_ops;
|
|
|
|
err = alias_tree_insert(block->sb, block->ino, block->bix, block->level,
|
|
|
|
block);
|
|
|
|
BUG_ON(err); /* mempool empty */
|
|
|
|
ClearPageUptodate(page);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int __logfs_segment_read(struct inode *inode, void *buf,
|
|
|
|
u64 ofs, u64 bix, level_t level)
|
|
|
|
{
|
|
|
|
struct super_block *sb = inode->i_sb;
|
|
|
|
void *compressor_buf = logfs_super(sb)->s_compressed_je;
|
|
|
|
struct logfs_object_header oh;
|
|
|
|
__be32 crc;
|
|
|
|
u16 len;
|
|
|
|
int err, block_len;
|
|
|
|
|
|
|
|
block_len = obj_len(sb, obj_type(inode, level));
|
|
|
|
err = read_obj_header(sb, ofs, &oh);
|
|
|
|
if (err)
|
|
|
|
goto out_err;
|
|
|
|
|
|
|
|
err = -EIO;
|
|
|
|
if (be64_to_cpu(oh.ino) != inode->i_ino
|
|
|
|
|| check_pos(sb, be64_to_cpu(oh.bix), bix, level)) {
|
|
|
|
printk(KERN_ERR"LOGFS: (ino, bix) don't match at %llx: "
|
|
|
|
"expected (%lx, %llx), got (%llx, %llx)\n",
|
|
|
|
ofs, inode->i_ino, bix,
|
|
|
|
be64_to_cpu(oh.ino), be64_to_cpu(oh.bix));
|
|
|
|
goto out_err;
|
|
|
|
}
|
|
|
|
|
|
|
|
len = be16_to_cpu(oh.len);
|
|
|
|
|
|
|
|
switch (oh.compr) {
|
|
|
|
case COMPR_NONE:
|
|
|
|
err = wbuf_read(sb, ofs + LOGFS_OBJECT_HEADERSIZE, len, buf);
|
|
|
|
if (err)
|
|
|
|
goto out_err;
|
|
|
|
crc = logfs_crc32(buf, len, 0);
|
|
|
|
if (crc != oh.data_crc) {
|
|
|
|
printk(KERN_ERR"LOGFS: uncompressed data crc error at "
|
|
|
|
"%llx: expected %x, got %x\n", ofs,
|
|
|
|
be32_to_cpu(oh.data_crc),
|
|
|
|
be32_to_cpu(crc));
|
|
|
|
goto out_err;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case COMPR_ZLIB:
|
|
|
|
mutex_lock(&logfs_super(sb)->s_journal_mutex);
|
|
|
|
err = wbuf_read(sb, ofs + LOGFS_OBJECT_HEADERSIZE, len,
|
|
|
|
compressor_buf);
|
|
|
|
if (err) {
|
|
|
|
mutex_unlock(&logfs_super(sb)->s_journal_mutex);
|
|
|
|
goto out_err;
|
|
|
|
}
|
|
|
|
crc = logfs_crc32(compressor_buf, len, 0);
|
|
|
|
if (crc != oh.data_crc) {
|
|
|
|
printk(KERN_ERR"LOGFS: compressed data crc error at "
|
|
|
|
"%llx: expected %x, got %x\n", ofs,
|
|
|
|
be32_to_cpu(oh.data_crc),
|
|
|
|
be32_to_cpu(crc));
|
|
|
|
mutex_unlock(&logfs_super(sb)->s_journal_mutex);
|
|
|
|
goto out_err;
|
|
|
|
}
|
|
|
|
err = logfs_uncompress(compressor_buf, buf, len, block_len);
|
|
|
|
mutex_unlock(&logfs_super(sb)->s_journal_mutex);
|
|
|
|
if (err) {
|
|
|
|
printk(KERN_ERR"LOGFS: uncompress error at %llx\n", ofs);
|
|
|
|
goto out_err;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
LOGFS_BUG(sb);
|
|
|
|
err = -EIO;
|
|
|
|
goto out_err;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
out_err:
|
|
|
|
logfs_set_ro(sb);
|
|
|
|
printk(KERN_ERR"LOGFS: device is read-only now\n");
|
|
|
|
LOGFS_BUG(sb);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* logfs_segment_read - read data block from object store
|
|
|
|
* @inode: inode containing data
|
|
|
|
* @buf: data buffer
|
|
|
|
* @ofs: physical data offset
|
|
|
|
* @bix: block index
|
|
|
|
* @level: block level
|
|
|
|
*
|
|
|
|
* Returns 0 on success or a negative errno.
|
|
|
|
*/
|
|
|
|
int logfs_segment_read(struct inode *inode, struct page *page,
|
|
|
|
u64 ofs, u64 bix, level_t level)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
void *buf;
|
|
|
|
|
|
|
|
if (PageUptodate(page))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
ofs &= ~LOGFS_FULLY_POPULATED;
|
|
|
|
|
|
|
|
buf = kmap(page);
|
|
|
|
err = __logfs_segment_read(inode, buf, ofs, bix, level);
|
|
|
|
if (!err) {
|
|
|
|
move_btree_to_page(inode, page, buf);
|
|
|
|
SetPageUptodate(page);
|
|
|
|
}
|
|
|
|
kunmap(page);
|
|
|
|
log_segment("logfs_segment_read(%lx, %llx, %x) %llx (%d)\n",
|
|
|
|
inode->i_ino, bix, level, ofs, err);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
int logfs_segment_delete(struct inode *inode, struct logfs_shadow *shadow)
|
|
|
|
{
|
|
|
|
struct super_block *sb = inode->i_sb;
|
2010-03-04 13:36:19 -07:00
|
|
|
struct logfs_super *super = logfs_super(sb);
|
2009-11-20 12:13:39 -07:00
|
|
|
struct logfs_object_header h;
|
|
|
|
u16 len;
|
|
|
|
int err;
|
|
|
|
|
2010-03-04 13:36:19 -07:00
|
|
|
super->s_flags |= LOGFS_SB_FLAG_DIRTY;
|
|
|
|
BUG_ON(super->s_flags & LOGFS_SB_FLAG_SHUTDOWN);
|
2009-11-20 12:13:39 -07:00
|
|
|
BUG_ON(shadow->old_ofs & LOGFS_FULLY_POPULATED);
|
|
|
|
if (!shadow->old_ofs)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
log_segment("logfs_segment_delete(%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);
|
|
|
|
err = read_obj_header(sb, shadow->old_ofs, &h);
|
|
|
|
LOGFS_BUG_ON(err, sb);
|
|
|
|
LOGFS_BUG_ON(be64_to_cpu(h.ino) != inode->i_ino, sb);
|
|
|
|
LOGFS_BUG_ON(check_pos(sb, shadow->bix, be64_to_cpu(h.bix),
|
|
|
|
shrink_level(shadow->gc_level)), sb);
|
|
|
|
|
|
|
|
if (shadow->gc_level == 0)
|
|
|
|
len = be16_to_cpu(h.len);
|
|
|
|
else
|
|
|
|
len = obj_len(sb, h.type);
|
|
|
|
shadow->old_len = len + sizeof(h);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-03-28 10:10:07 -06:00
|
|
|
void freeseg(struct super_block *sb, u32 segno)
|
2009-11-20 12:13:39 -07:00
|
|
|
{
|
|
|
|
struct logfs_super *super = logfs_super(sb);
|
|
|
|
struct address_space *mapping = super->s_mapping_inode->i_mapping;
|
|
|
|
struct page *page;
|
|
|
|
u64 ofs, start, end;
|
|
|
|
|
|
|
|
start = dev_ofs(sb, segno, 0);
|
|
|
|
end = dev_ofs(sb, segno + 1, 0);
|
|
|
|
for (ofs = start; ofs < end; ofs += PAGE_SIZE) {
|
|
|
|
page = find_get_page(mapping, ofs >> PAGE_SHIFT);
|
|
|
|
if (!page)
|
|
|
|
continue;
|
2011-11-25 22:30:47 -07:00
|
|
|
if (PagePrivate(page)) {
|
|
|
|
ClearPagePrivate(page);
|
|
|
|
page_cache_release(page);
|
|
|
|
}
|
2009-11-20 12:13:39 -07:00
|
|
|
page_cache_release(page);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
int logfs_open_area(struct logfs_area *area, size_t bytes)
|
|
|
|
{
|
|
|
|
struct super_block *sb = area->a_sb;
|
|
|
|
struct logfs_super *super = logfs_super(sb);
|
|
|
|
int err, closed = 0;
|
|
|
|
|
|
|
|
if (area->a_is_open && area->a_used_bytes + bytes <= super->s_segsize)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (area->a_is_open) {
|
|
|
|
u64 ofs = dev_ofs(sb, area->a_segno, area->a_written_bytes);
|
|
|
|
u32 len = super->s_segsize - area->a_written_bytes;
|
|
|
|
|
|
|
|
log_gc("logfs_close_area(%x)\n", area->a_segno);
|
|
|
|
pad_wbuf(area, 1);
|
|
|
|
super->s_devops->writeseg(area->a_sb, ofs, len);
|
|
|
|
freeseg(sb, area->a_segno);
|
|
|
|
closed = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
area->a_used_bytes = 0;
|
|
|
|
area->a_written_bytes = 0;
|
|
|
|
again:
|
|
|
|
area->a_ops->get_free_segment(area);
|
|
|
|
area->a_ops->get_erase_count(area);
|
|
|
|
|
|
|
|
log_gc("logfs_open_area(%x, %x)\n", area->a_segno, area->a_level);
|
|
|
|
err = area->a_ops->erase_segment(area);
|
|
|
|
if (err) {
|
|
|
|
printk(KERN_WARNING "LogFS: Error erasing segment %x\n",
|
|
|
|
area->a_segno);
|
|
|
|
logfs_mark_segment_bad(sb, area->a_segno);
|
|
|
|
goto again;
|
|
|
|
}
|
|
|
|
area->a_is_open = 1;
|
|
|
|
return closed;
|
|
|
|
}
|
|
|
|
|
|
|
|
void logfs_sync_area(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_written_bytes);
|
|
|
|
u32 len = (area->a_used_bytes - area->a_written_bytes);
|
|
|
|
|
|
|
|
if (super->s_writesize)
|
|
|
|
len &= ~(super->s_writesize - 1);
|
|
|
|
if (len == 0)
|
|
|
|
return;
|
|
|
|
pad_wbuf(area, 0);
|
|
|
|
super->s_devops->writeseg(sb, ofs, len);
|
|
|
|
area->a_written_bytes += len;
|
|
|
|
}
|
|
|
|
|
|
|
|
void logfs_sync_segments(struct super_block *sb)
|
|
|
|
{
|
|
|
|
struct logfs_super *super = logfs_super(sb);
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for_each_area(i)
|
|
|
|
logfs_sync_area(super->s_area[i]);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Pick a free segment to be used for this area. Effectively takes a
|
|
|
|
* candidate from the free list (not really a candidate anymore).
|
|
|
|
*/
|
|
|
|
static void ostore_get_free_segment(struct logfs_area *area)
|
|
|
|
{
|
|
|
|
struct super_block *sb = area->a_sb;
|
|
|
|
struct logfs_super *super = logfs_super(sb);
|
|
|
|
|
|
|
|
if (super->s_free_list.count == 0) {
|
|
|
|
printk(KERN_ERR"LOGFS: ran out of free segments\n");
|
|
|
|
LOGFS_BUG(sb);
|
|
|
|
}
|
|
|
|
|
|
|
|
area->a_segno = get_best_cand(sb, &super->s_free_list, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ostore_get_erase_count(struct logfs_area *area)
|
|
|
|
{
|
|
|
|
struct logfs_segment_entry se;
|
|
|
|
u32 ec_level;
|
|
|
|
|
|
|
|
logfs_get_segment_entry(area->a_sb, area->a_segno, &se);
|
|
|
|
BUG_ON(se.ec_level == cpu_to_be32(BADSEG) ||
|
|
|
|
se.valid == cpu_to_be32(RESERVED));
|
|
|
|
|
|
|
|
ec_level = be32_to_cpu(se.ec_level);
|
|
|
|
area->a_erase_count = (ec_level >> 4) + 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ostore_erase_segment(struct logfs_area *area)
|
|
|
|
{
|
|
|
|
struct super_block *sb = area->a_sb;
|
|
|
|
struct logfs_segment_header sh;
|
|
|
|
u64 ofs;
|
|
|
|
int err;
|
|
|
|
|
2010-03-04 13:30:58 -07:00
|
|
|
err = logfs_erase_segment(sb, area->a_segno, 0);
|
2009-11-20 12:13:39 -07:00
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
sh.pad = 0;
|
|
|
|
sh.type = SEG_OSTORE;
|
|
|
|
sh.level = (__force u8)area->a_level;
|
|
|
|
sh.segno = cpu_to_be32(area->a_segno);
|
|
|
|
sh.ec = cpu_to_be32(area->a_erase_count);
|
|
|
|
sh.gec = cpu_to_be64(logfs_super(sb)->s_gec);
|
|
|
|
sh.crc = logfs_crc32(&sh, sizeof(sh), 4);
|
|
|
|
|
|
|
|
logfs_set_segment_erased(sb, area->a_segno, area->a_erase_count,
|
|
|
|
area->a_level);
|
|
|
|
|
|
|
|
ofs = dev_ofs(sb, area->a_segno, 0);
|
|
|
|
area->a_used_bytes = sizeof(sh);
|
|
|
|
logfs_buf_write(area, ofs, &sh, sizeof(sh));
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct logfs_area_ops ostore_area_ops = {
|
|
|
|
.get_free_segment = ostore_get_free_segment,
|
|
|
|
.get_erase_count = ostore_get_erase_count,
|
|
|
|
.erase_segment = ostore_erase_segment,
|
|
|
|
};
|
|
|
|
|
|
|
|
static void free_area(struct logfs_area *area)
|
|
|
|
{
|
|
|
|
if (area)
|
|
|
|
freeseg(area->a_sb, area->a_segno);
|
|
|
|
kfree(area);
|
|
|
|
}
|
|
|
|
|
2011-08-05 03:18:19 -06:00
|
|
|
void free_areas(struct super_block *sb)
|
|
|
|
{
|
|
|
|
struct logfs_super *super = logfs_super(sb);
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for_each_area(i)
|
|
|
|
free_area(super->s_area[i]);
|
|
|
|
free_area(super->s_journal_area);
|
|
|
|
}
|
|
|
|
|
2009-11-20 12:13:39 -07:00
|
|
|
static struct logfs_area *alloc_area(struct super_block *sb)
|
|
|
|
{
|
|
|
|
struct logfs_area *area;
|
|
|
|
|
|
|
|
area = kzalloc(sizeof(*area), GFP_KERNEL);
|
|
|
|
if (!area)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
area->a_sb = sb;
|
|
|
|
return area;
|
|
|
|
}
|
|
|
|
|
2013-05-21 21:17:23 -06:00
|
|
|
static void map_invalidatepage(struct page *page, unsigned int o,
|
|
|
|
unsigned int l)
|
2009-11-20 12:13:39 -07:00
|
|
|
{
|
2012-03-08 17:57:12 -07:00
|
|
|
return;
|
2009-11-20 12:13:39 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static int map_releasepage(struct page *page, gfp_t g)
|
|
|
|
{
|
|
|
|
/* Don't release these pages */
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct address_space_operations mapping_aops = {
|
|
|
|
.invalidatepage = map_invalidatepage,
|
|
|
|
.releasepage = map_releasepage,
|
|
|
|
.set_page_dirty = __set_page_dirty_nobuffers,
|
|
|
|
};
|
|
|
|
|
|
|
|
int logfs_init_mapping(struct super_block *sb)
|
|
|
|
{
|
|
|
|
struct logfs_super *super = logfs_super(sb);
|
|
|
|
struct address_space *mapping;
|
|
|
|
struct inode *inode;
|
|
|
|
|
|
|
|
inode = logfs_new_meta_inode(sb, LOGFS_INO_MAPPING);
|
|
|
|
if (IS_ERR(inode))
|
|
|
|
return PTR_ERR(inode);
|
|
|
|
super->s_mapping_inode = inode;
|
|
|
|
mapping = inode->i_mapping;
|
|
|
|
mapping->a_ops = &mapping_aops;
|
|
|
|
/* Would it be possible to use __GFP_HIGHMEM as well? */
|
|
|
|
mapping_set_gfp_mask(mapping, GFP_NOFS);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int logfs_init_areas(struct super_block *sb)
|
|
|
|
{
|
|
|
|
struct logfs_super *super = logfs_super(sb);
|
|
|
|
int i = -1;
|
|
|
|
|
|
|
|
super->s_alias_pool = mempool_create_kmalloc_pool(600,
|
|
|
|
sizeof(struct object_alias_item));
|
|
|
|
if (!super->s_alias_pool)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
super->s_journal_area = alloc_area(sb);
|
|
|
|
if (!super->s_journal_area)
|
|
|
|
goto err;
|
|
|
|
|
|
|
|
for_each_area(i) {
|
|
|
|
super->s_area[i] = alloc_area(sb);
|
|
|
|
if (!super->s_area[i])
|
|
|
|
goto err;
|
|
|
|
super->s_area[i]->a_level = GC_LEVEL(i);
|
|
|
|
super->s_area[i]->a_ops = &ostore_area_ops;
|
|
|
|
}
|
|
|
|
btree_init_mempool128(&super->s_object_alias_tree,
|
|
|
|
super->s_btree_pool);
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
err:
|
|
|
|
for (i--; i >= 0; i--)
|
|
|
|
free_area(super->s_area[i]);
|
|
|
|
free_area(super->s_journal_area);
|
2010-04-15 00:03:57 -06:00
|
|
|
logfs_mempool_destroy(super->s_alias_pool);
|
2009-11-20 12:13:39 -07:00
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
void logfs_cleanup_areas(struct super_block *sb)
|
|
|
|
{
|
|
|
|
struct logfs_super *super = logfs_super(sb);
|
|
|
|
|
|
|
|
btree_grim_visitor128(&super->s_object_alias_tree, 0, kill_alias);
|
|
|
|
}
|