mirror of https://gitee.com/openkylin/linux.git
896 lines
24 KiB
C
896 lines
24 KiB
C
/*
|
|
* fs/logfs/journal.c - journal handling code
|
|
*
|
|
* As should be obvious for Linux kernel code, license is GPLv2
|
|
*
|
|
* Copyright (c) 2005-2008 Joern Engel <joern@logfs.org>
|
|
*/
|
|
#include "logfs.h"
|
|
#include <linux/slab.h>
|
|
|
|
static void logfs_calc_free(struct super_block *sb)
|
|
{
|
|
struct logfs_super *super = logfs_super(sb);
|
|
u64 reserve, no_segs = super->s_no_segs;
|
|
s64 free;
|
|
int i;
|
|
|
|
/* superblock segments */
|
|
no_segs -= 2;
|
|
super->s_no_journal_segs = 0;
|
|
/* journal */
|
|
journal_for_each(i)
|
|
if (super->s_journal_seg[i]) {
|
|
no_segs--;
|
|
super->s_no_journal_segs++;
|
|
}
|
|
|
|
/* open segments plus one extra per level for GC */
|
|
no_segs -= 2 * super->s_total_levels;
|
|
|
|
free = no_segs * (super->s_segsize - LOGFS_SEGMENT_RESERVE);
|
|
free -= super->s_used_bytes;
|
|
/* just a bit extra */
|
|
free -= super->s_total_levels * 4096;
|
|
|
|
/* Bad blocks are 'paid' for with speed reserve - the filesystem
|
|
* simply gets slower as bad blocks accumulate. Until the bad blocks
|
|
* exceed the speed reserve - then the filesystem gets smaller.
|
|
*/
|
|
reserve = super->s_bad_segments + super->s_bad_seg_reserve;
|
|
reserve *= super->s_segsize - LOGFS_SEGMENT_RESERVE;
|
|
reserve = max(reserve, super->s_speed_reserve);
|
|
free -= reserve;
|
|
if (free < 0)
|
|
free = 0;
|
|
|
|
super->s_free_bytes = free;
|
|
}
|
|
|
|
static void reserve_sb_and_journal(struct super_block *sb)
|
|
{
|
|
struct logfs_super *super = logfs_super(sb);
|
|
struct btree_head32 *head = &super->s_reserved_segments;
|
|
int i, err;
|
|
|
|
err = btree_insert32(head, seg_no(sb, super->s_sb_ofs[0]), (void *)1,
|
|
GFP_KERNEL);
|
|
BUG_ON(err);
|
|
|
|
err = btree_insert32(head, seg_no(sb, super->s_sb_ofs[1]), (void *)1,
|
|
GFP_KERNEL);
|
|
BUG_ON(err);
|
|
|
|
journal_for_each(i) {
|
|
if (!super->s_journal_seg[i])
|
|
continue;
|
|
err = btree_insert32(head, super->s_journal_seg[i], (void *)1,
|
|
GFP_KERNEL);
|
|
BUG_ON(err);
|
|
}
|
|
}
|
|
|
|
static void read_dynsb(struct super_block *sb,
|
|
struct logfs_je_dynsb *dynsb)
|
|
{
|
|
struct logfs_super *super = logfs_super(sb);
|
|
|
|
super->s_gec = be64_to_cpu(dynsb->ds_gec);
|
|
super->s_sweeper = be64_to_cpu(dynsb->ds_sweeper);
|
|
super->s_victim_ino = be64_to_cpu(dynsb->ds_victim_ino);
|
|
super->s_rename_dir = be64_to_cpu(dynsb->ds_rename_dir);
|
|
super->s_rename_pos = be64_to_cpu(dynsb->ds_rename_pos);
|
|
super->s_used_bytes = be64_to_cpu(dynsb->ds_used_bytes);
|
|
super->s_generation = be32_to_cpu(dynsb->ds_generation);
|
|
}
|
|
|
|
static void read_anchor(struct super_block *sb,
|
|
struct logfs_je_anchor *da)
|
|
{
|
|
struct logfs_super *super = logfs_super(sb);
|
|
struct inode *inode = super->s_master_inode;
|
|
struct logfs_inode *li = logfs_inode(inode);
|
|
int i;
|
|
|
|
super->s_last_ino = be64_to_cpu(da->da_last_ino);
|
|
li->li_flags = 0;
|
|
li->li_height = da->da_height;
|
|
i_size_write(inode, be64_to_cpu(da->da_size));
|
|
li->li_used_bytes = be64_to_cpu(da->da_used_bytes);
|
|
|
|
for (i = 0; i < LOGFS_EMBEDDED_FIELDS; i++)
|
|
li->li_data[i] = be64_to_cpu(da->da_data[i]);
|
|
}
|
|
|
|
static void read_erasecount(struct super_block *sb,
|
|
struct logfs_je_journal_ec *ec)
|
|
{
|
|
struct logfs_super *super = logfs_super(sb);
|
|
int i;
|
|
|
|
journal_for_each(i)
|
|
super->s_journal_ec[i] = be32_to_cpu(ec->ec[i]);
|
|
}
|
|
|
|
static int read_area(struct super_block *sb, struct logfs_je_area *a)
|
|
{
|
|
struct logfs_super *super = logfs_super(sb);
|
|
struct logfs_area *area = super->s_area[a->gc_level];
|
|
u64 ofs;
|
|
u32 writemask = ~(super->s_writesize - 1);
|
|
|
|
if (a->gc_level >= LOGFS_NO_AREAS)
|
|
return -EIO;
|
|
if (a->vim != VIM_DEFAULT)
|
|
return -EIO; /* TODO: close area and continue */
|
|
|
|
area->a_used_bytes = be32_to_cpu(a->used_bytes);
|
|
area->a_written_bytes = area->a_used_bytes & writemask;
|
|
area->a_segno = be32_to_cpu(a->segno);
|
|
if (area->a_segno)
|
|
area->a_is_open = 1;
|
|
|
|
ofs = dev_ofs(sb, area->a_segno, area->a_written_bytes);
|
|
if (super->s_writesize > 1)
|
|
return logfs_buf_recover(area, ofs, a + 1, super->s_writesize);
|
|
else
|
|
return logfs_buf_recover(area, ofs, NULL, 0);
|
|
}
|
|
|
|
static void *unpack(void *from, void *to)
|
|
{
|
|
struct logfs_journal_header *jh = from;
|
|
void *data = from + sizeof(struct logfs_journal_header);
|
|
int err;
|
|
size_t inlen, outlen;
|
|
|
|
inlen = be16_to_cpu(jh->h_len);
|
|
outlen = be16_to_cpu(jh->h_datalen);
|
|
|
|
if (jh->h_compr == COMPR_NONE)
|
|
memcpy(to, data, inlen);
|
|
else {
|
|
err = logfs_uncompress(data, to, inlen, outlen);
|
|
BUG_ON(err);
|
|
}
|
|
return to;
|
|
}
|
|
|
|
static int __read_je_header(struct super_block *sb, u64 ofs,
|
|
struct logfs_journal_header *jh)
|
|
{
|
|
struct logfs_super *super = logfs_super(sb);
|
|
size_t bufsize = max_t(size_t, sb->s_blocksize, super->s_writesize)
|
|
+ MAX_JOURNAL_HEADER;
|
|
u16 type, len, datalen;
|
|
int err;
|
|
|
|
/* read header only */
|
|
err = wbuf_read(sb, ofs, sizeof(*jh), jh);
|
|
if (err)
|
|
return err;
|
|
type = be16_to_cpu(jh->h_type);
|
|
len = be16_to_cpu(jh->h_len);
|
|
datalen = be16_to_cpu(jh->h_datalen);
|
|
if (len > sb->s_blocksize)
|
|
return -EIO;
|
|
if ((type < JE_FIRST) || (type > JE_LAST))
|
|
return -EIO;
|
|
if (datalen > bufsize)
|
|
return -EIO;
|
|
return 0;
|
|
}
|
|
|
|
static int __read_je_payload(struct super_block *sb, u64 ofs,
|
|
struct logfs_journal_header *jh)
|
|
{
|
|
u16 len;
|
|
int err;
|
|
|
|
len = be16_to_cpu(jh->h_len);
|
|
err = wbuf_read(sb, ofs + sizeof(*jh), len, jh + 1);
|
|
if (err)
|
|
return err;
|
|
if (jh->h_crc != logfs_crc32(jh, len + sizeof(*jh), 4)) {
|
|
/* Old code was confused. It forgot about the header length
|
|
* and stopped calculating the crc 16 bytes before the end
|
|
* of data - ick!
|
|
* FIXME: Remove this hack once the old code is fixed.
|
|
*/
|
|
if (jh->h_crc == logfs_crc32(jh, len, 4))
|
|
WARN_ON_ONCE(1);
|
|
else
|
|
return -EIO;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* jh needs to be large enough to hold the complete entry, not just the header
|
|
*/
|
|
static int __read_je(struct super_block *sb, u64 ofs,
|
|
struct logfs_journal_header *jh)
|
|
{
|
|
int err;
|
|
|
|
err = __read_je_header(sb, ofs, jh);
|
|
if (err)
|
|
return err;
|
|
return __read_je_payload(sb, ofs, jh);
|
|
}
|
|
|
|
static int read_je(struct super_block *sb, u64 ofs)
|
|
{
|
|
struct logfs_super *super = logfs_super(sb);
|
|
struct logfs_journal_header *jh = super->s_compressed_je;
|
|
void *scratch = super->s_je;
|
|
u16 type, datalen;
|
|
int err;
|
|
|
|
err = __read_je(sb, ofs, jh);
|
|
if (err)
|
|
return err;
|
|
type = be16_to_cpu(jh->h_type);
|
|
datalen = be16_to_cpu(jh->h_datalen);
|
|
|
|
switch (type) {
|
|
case JE_DYNSB:
|
|
read_dynsb(sb, unpack(jh, scratch));
|
|
break;
|
|
case JE_ANCHOR:
|
|
read_anchor(sb, unpack(jh, scratch));
|
|
break;
|
|
case JE_ERASECOUNT:
|
|
read_erasecount(sb, unpack(jh, scratch));
|
|
break;
|
|
case JE_AREA:
|
|
err = read_area(sb, unpack(jh, scratch));
|
|
break;
|
|
case JE_OBJ_ALIAS:
|
|
err = logfs_load_object_aliases(sb, unpack(jh, scratch),
|
|
datalen);
|
|
break;
|
|
default:
|
|
WARN_ON_ONCE(1);
|
|
return -EIO;
|
|
}
|
|
return err;
|
|
}
|
|
|
|
static int logfs_read_segment(struct super_block *sb, u32 segno)
|
|
{
|
|
struct logfs_super *super = logfs_super(sb);
|
|
struct logfs_journal_header *jh = super->s_compressed_je;
|
|
u64 ofs, seg_ofs = dev_ofs(sb, segno, 0);
|
|
u32 h_ofs, last_ofs = 0;
|
|
u16 len, datalen, last_len = 0;
|
|
int i, err;
|
|
|
|
/* search for most recent commit */
|
|
for (h_ofs = 0; h_ofs < super->s_segsize; h_ofs += sizeof(*jh)) {
|
|
ofs = seg_ofs + h_ofs;
|
|
err = __read_je_header(sb, ofs, jh);
|
|
if (err)
|
|
continue;
|
|
if (jh->h_type != cpu_to_be16(JE_COMMIT))
|
|
continue;
|
|
err = __read_je_payload(sb, ofs, jh);
|
|
if (err)
|
|
continue;
|
|
len = be16_to_cpu(jh->h_len);
|
|
datalen = be16_to_cpu(jh->h_datalen);
|
|
if ((datalen > sizeof(super->s_je_array)) ||
|
|
(datalen % sizeof(__be64)))
|
|
continue;
|
|
last_ofs = h_ofs;
|
|
last_len = datalen;
|
|
h_ofs += ALIGN(len, sizeof(*jh)) - sizeof(*jh);
|
|
}
|
|
/* read commit */
|
|
if (last_ofs == 0)
|
|
return -ENOENT;
|
|
ofs = seg_ofs + last_ofs;
|
|
log_journal("Read commit from %llx\n", ofs);
|
|
err = __read_je(sb, ofs, jh);
|
|
BUG_ON(err); /* We should have caught it in the scan loop already */
|
|
if (err)
|
|
return err;
|
|
/* uncompress */
|
|
unpack(jh, super->s_je_array);
|
|
super->s_no_je = last_len / sizeof(__be64);
|
|
/* iterate over array */
|
|
for (i = 0; i < super->s_no_je; i++) {
|
|
err = read_je(sb, be64_to_cpu(super->s_je_array[i]));
|
|
if (err)
|
|
return err;
|
|
}
|
|
super->s_journal_area->a_segno = segno;
|
|
return 0;
|
|
}
|
|
|
|
static u64 read_gec(struct super_block *sb, u32 segno)
|
|
{
|
|
struct logfs_segment_header sh;
|
|
__be32 crc;
|
|
int err;
|
|
|
|
if (!segno)
|
|
return 0;
|
|
err = wbuf_read(sb, dev_ofs(sb, segno, 0), sizeof(sh), &sh);
|
|
if (err)
|
|
return 0;
|
|
crc = logfs_crc32(&sh, sizeof(sh), 4);
|
|
if (crc != sh.crc) {
|
|
WARN_ON(sh.gec != cpu_to_be64(0xffffffffffffffffull));
|
|
/* Most likely it was just erased */
|
|
return 0;
|
|
}
|
|
return be64_to_cpu(sh.gec);
|
|
}
|
|
|
|
static int logfs_read_journal(struct super_block *sb)
|
|
{
|
|
struct logfs_super *super = logfs_super(sb);
|
|
u64 gec[LOGFS_JOURNAL_SEGS], max;
|
|
u32 segno;
|
|
int i, max_i;
|
|
|
|
max = 0;
|
|
max_i = -1;
|
|
journal_for_each(i) {
|
|
segno = super->s_journal_seg[i];
|
|
gec[i] = read_gec(sb, super->s_journal_seg[i]);
|
|
if (gec[i] > max) {
|
|
max = gec[i];
|
|
max_i = i;
|
|
}
|
|
}
|
|
if (max_i == -1)
|
|
return -EIO;
|
|
/* FIXME: Try older segments in case of error */
|
|
return logfs_read_segment(sb, super->s_journal_seg[max_i]);
|
|
}
|
|
|
|
/*
|
|
* First search the current segment (outer loop), then pick the next segment
|
|
* in the array, skipping any zero entries (inner loop).
|
|
*/
|
|
static void journal_get_free_segment(struct logfs_area *area)
|
|
{
|
|
struct logfs_super *super = logfs_super(area->a_sb);
|
|
int i;
|
|
|
|
journal_for_each(i) {
|
|
if (area->a_segno != super->s_journal_seg[i])
|
|
continue;
|
|
|
|
do {
|
|
i++;
|
|
if (i == LOGFS_JOURNAL_SEGS)
|
|
i = 0;
|
|
} while (!super->s_journal_seg[i]);
|
|
|
|
area->a_segno = super->s_journal_seg[i];
|
|
area->a_erase_count = ++(super->s_journal_ec[i]);
|
|
log_journal("Journal now at %x (ec %x)\n", area->a_segno,
|
|
area->a_erase_count);
|
|
return;
|
|
}
|
|
BUG();
|
|
}
|
|
|
|
static void journal_get_erase_count(struct logfs_area *area)
|
|
{
|
|
/* erase count is stored globally and incremented in
|
|
* journal_get_free_segment() - nothing to do here */
|
|
}
|
|
|
|
static int journal_erase_segment(struct logfs_area *area)
|
|
{
|
|
struct super_block *sb = area->a_sb;
|
|
union {
|
|
struct logfs_segment_header sh;
|
|
unsigned char c[ALIGN(sizeof(struct logfs_segment_header), 16)];
|
|
} u;
|
|
u64 ofs;
|
|
int err;
|
|
|
|
err = logfs_erase_segment(sb, area->a_segno, 1);
|
|
if (err)
|
|
return err;
|
|
|
|
memset(&u, 0, sizeof(u));
|
|
u.sh.pad = 0;
|
|
u.sh.type = SEG_JOURNAL;
|
|
u.sh.level = 0;
|
|
u.sh.segno = cpu_to_be32(area->a_segno);
|
|
u.sh.ec = cpu_to_be32(area->a_erase_count);
|
|
u.sh.gec = cpu_to_be64(logfs_super(sb)->s_gec);
|
|
u.sh.crc = logfs_crc32(&u.sh, sizeof(u.sh), 4);
|
|
|
|
/* This causes a bug in segment.c. Not yet. */
|
|
//logfs_set_segment_erased(sb, area->a_segno, area->a_erase_count, 0);
|
|
|
|
ofs = dev_ofs(sb, area->a_segno, 0);
|
|
area->a_used_bytes = sizeof(u);
|
|
logfs_buf_write(area, ofs, &u, sizeof(u));
|
|
return 0;
|
|
}
|
|
|
|
static size_t __logfs_write_header(struct logfs_super *super,
|
|
struct logfs_journal_header *jh, size_t len, size_t datalen,
|
|
u16 type, u8 compr)
|
|
{
|
|
jh->h_len = cpu_to_be16(len);
|
|
jh->h_type = cpu_to_be16(type);
|
|
jh->h_datalen = cpu_to_be16(datalen);
|
|
jh->h_compr = compr;
|
|
jh->h_pad[0] = 'H';
|
|
jh->h_pad[1] = 'E';
|
|
jh->h_pad[2] = 'A';
|
|
jh->h_pad[3] = 'D';
|
|
jh->h_pad[4] = 'R';
|
|
jh->h_crc = logfs_crc32(jh, len + sizeof(*jh), 4);
|
|
return ALIGN(len, 16) + sizeof(*jh);
|
|
}
|
|
|
|
static size_t logfs_write_header(struct logfs_super *super,
|
|
struct logfs_journal_header *jh, size_t datalen, u16 type)
|
|
{
|
|
size_t len = datalen;
|
|
|
|
return __logfs_write_header(super, jh, len, datalen, type, COMPR_NONE);
|
|
}
|
|
|
|
static inline size_t logfs_journal_erasecount_size(struct logfs_super *super)
|
|
{
|
|
return LOGFS_JOURNAL_SEGS * sizeof(__be32);
|
|
}
|
|
|
|
static void *logfs_write_erasecount(struct super_block *sb, void *_ec,
|
|
u16 *type, size_t *len)
|
|
{
|
|
struct logfs_super *super = logfs_super(sb);
|
|
struct logfs_je_journal_ec *ec = _ec;
|
|
int i;
|
|
|
|
journal_for_each(i)
|
|
ec->ec[i] = cpu_to_be32(super->s_journal_ec[i]);
|
|
*type = JE_ERASECOUNT;
|
|
*len = logfs_journal_erasecount_size(super);
|
|
return ec;
|
|
}
|
|
|
|
static void account_shadow(void *_shadow, unsigned long _sb, u64 ignore,
|
|
size_t ignore2)
|
|
{
|
|
struct logfs_shadow *shadow = _shadow;
|
|
struct super_block *sb = (void *)_sb;
|
|
struct logfs_super *super = logfs_super(sb);
|
|
|
|
/* consume new space */
|
|
super->s_free_bytes -= shadow->new_len;
|
|
super->s_used_bytes += shadow->new_len;
|
|
super->s_dirty_used_bytes -= shadow->new_len;
|
|
|
|
/* free up old space */
|
|
super->s_free_bytes += shadow->old_len;
|
|
super->s_used_bytes -= shadow->old_len;
|
|
super->s_dirty_free_bytes -= shadow->old_len;
|
|
|
|
logfs_set_segment_used(sb, shadow->old_ofs, -shadow->old_len);
|
|
logfs_set_segment_used(sb, shadow->new_ofs, shadow->new_len);
|
|
|
|
log_journal("account_shadow(%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);
|
|
mempool_free(shadow, super->s_shadow_pool);
|
|
}
|
|
|
|
static void account_shadows(struct super_block *sb)
|
|
{
|
|
struct logfs_super *super = logfs_super(sb);
|
|
struct inode *inode = super->s_master_inode;
|
|
struct logfs_inode *li = logfs_inode(inode);
|
|
struct shadow_tree *tree = &super->s_shadow_tree;
|
|
|
|
btree_grim_visitor64(&tree->new, (unsigned long)sb, account_shadow);
|
|
btree_grim_visitor64(&tree->old, (unsigned long)sb, account_shadow);
|
|
btree_grim_visitor32(&tree->segment_map, 0, NULL);
|
|
tree->no_shadowed_segments = 0;
|
|
|
|
if (li->li_block) {
|
|
/*
|
|
* We never actually use the structure, when attached to the
|
|
* master inode. But it is easier to always free it here than
|
|
* to have checks in several places elsewhere when allocating
|
|
* it.
|
|
*/
|
|
li->li_block->ops->free_block(sb, li->li_block);
|
|
}
|
|
BUG_ON((s64)li->li_used_bytes < 0);
|
|
}
|
|
|
|
static void *__logfs_write_anchor(struct super_block *sb, void *_da,
|
|
u16 *type, size_t *len)
|
|
{
|
|
struct logfs_super *super = logfs_super(sb);
|
|
struct logfs_je_anchor *da = _da;
|
|
struct inode *inode = super->s_master_inode;
|
|
struct logfs_inode *li = logfs_inode(inode);
|
|
int i;
|
|
|
|
da->da_height = li->li_height;
|
|
da->da_last_ino = cpu_to_be64(super->s_last_ino);
|
|
da->da_size = cpu_to_be64(i_size_read(inode));
|
|
da->da_used_bytes = cpu_to_be64(li->li_used_bytes);
|
|
for (i = 0; i < LOGFS_EMBEDDED_FIELDS; i++)
|
|
da->da_data[i] = cpu_to_be64(li->li_data[i]);
|
|
*type = JE_ANCHOR;
|
|
*len = sizeof(*da);
|
|
return da;
|
|
}
|
|
|
|
static void *logfs_write_dynsb(struct super_block *sb, void *_dynsb,
|
|
u16 *type, size_t *len)
|
|
{
|
|
struct logfs_super *super = logfs_super(sb);
|
|
struct logfs_je_dynsb *dynsb = _dynsb;
|
|
|
|
dynsb->ds_gec = cpu_to_be64(super->s_gec);
|
|
dynsb->ds_sweeper = cpu_to_be64(super->s_sweeper);
|
|
dynsb->ds_victim_ino = cpu_to_be64(super->s_victim_ino);
|
|
dynsb->ds_rename_dir = cpu_to_be64(super->s_rename_dir);
|
|
dynsb->ds_rename_pos = cpu_to_be64(super->s_rename_pos);
|
|
dynsb->ds_used_bytes = cpu_to_be64(super->s_used_bytes);
|
|
dynsb->ds_generation = cpu_to_be32(super->s_generation);
|
|
*type = JE_DYNSB;
|
|
*len = sizeof(*dynsb);
|
|
return dynsb;
|
|
}
|
|
|
|
static void write_wbuf(struct super_block *sb, struct logfs_area *area,
|
|
void *wbuf)
|
|
{
|
|
struct logfs_super *super = logfs_super(sb);
|
|
struct address_space *mapping = super->s_mapping_inode->i_mapping;
|
|
u64 ofs;
|
|
pgoff_t index;
|
|
int page_ofs;
|
|
struct page *page;
|
|
|
|
ofs = dev_ofs(sb, area->a_segno,
|
|
area->a_used_bytes & ~(super->s_writesize - 1));
|
|
index = ofs >> PAGE_SHIFT;
|
|
page_ofs = ofs & (PAGE_SIZE - 1);
|
|
|
|
page = find_lock_page(mapping, index);
|
|
BUG_ON(!page);
|
|
memcpy(wbuf, page_address(page) + page_ofs, super->s_writesize);
|
|
unlock_page(page);
|
|
}
|
|
|
|
static void *logfs_write_area(struct super_block *sb, void *_a,
|
|
u16 *type, size_t *len)
|
|
{
|
|
struct logfs_super *super = logfs_super(sb);
|
|
struct logfs_area *area = super->s_area[super->s_sum_index];
|
|
struct logfs_je_area *a = _a;
|
|
|
|
a->vim = VIM_DEFAULT;
|
|
a->gc_level = super->s_sum_index;
|
|
a->used_bytes = cpu_to_be32(area->a_used_bytes);
|
|
a->segno = cpu_to_be32(area->a_segno);
|
|
if (super->s_writesize > 1)
|
|
write_wbuf(sb, area, a + 1);
|
|
|
|
*type = JE_AREA;
|
|
*len = sizeof(*a) + super->s_writesize;
|
|
return a;
|
|
}
|
|
|
|
static void *logfs_write_commit(struct super_block *sb, void *h,
|
|
u16 *type, size_t *len)
|
|
{
|
|
struct logfs_super *super = logfs_super(sb);
|
|
|
|
*type = JE_COMMIT;
|
|
*len = super->s_no_je * sizeof(__be64);
|
|
return super->s_je_array;
|
|
}
|
|
|
|
static size_t __logfs_write_je(struct super_block *sb, void *buf, u16 type,
|
|
size_t len)
|
|
{
|
|
struct logfs_super *super = logfs_super(sb);
|
|
void *header = super->s_compressed_je;
|
|
void *data = header + sizeof(struct logfs_journal_header);
|
|
ssize_t compr_len, pad_len;
|
|
u8 compr = COMPR_ZLIB;
|
|
|
|
if (len == 0)
|
|
return logfs_write_header(super, header, 0, type);
|
|
|
|
BUG_ON(len > sb->s_blocksize);
|
|
compr_len = logfs_compress(buf, data, len, sb->s_blocksize);
|
|
if (compr_len < 0 || type == JE_ANCHOR) {
|
|
memcpy(data, buf, len);
|
|
compr_len = len;
|
|
compr = COMPR_NONE;
|
|
}
|
|
|
|
pad_len = ALIGN(compr_len, 16);
|
|
memset(data + compr_len, 0, pad_len - compr_len);
|
|
|
|
return __logfs_write_header(super, header, compr_len, len, type, compr);
|
|
}
|
|
|
|
static s64 logfs_get_free_bytes(struct logfs_area *area, size_t *bytes,
|
|
int must_pad)
|
|
{
|
|
u32 writesize = logfs_super(area->a_sb)->s_writesize;
|
|
s32 ofs;
|
|
int ret;
|
|
|
|
ret = logfs_open_area(area, *bytes);
|
|
if (ret)
|
|
return -EAGAIN;
|
|
|
|
ofs = area->a_used_bytes;
|
|
area->a_used_bytes += *bytes;
|
|
|
|
if (must_pad) {
|
|
area->a_used_bytes = ALIGN(area->a_used_bytes, writesize);
|
|
*bytes = area->a_used_bytes - ofs;
|
|
}
|
|
|
|
return dev_ofs(area->a_sb, area->a_segno, ofs);
|
|
}
|
|
|
|
static int logfs_write_je_buf(struct super_block *sb, void *buf, u16 type,
|
|
size_t buf_len)
|
|
{
|
|
struct logfs_super *super = logfs_super(sb);
|
|
struct logfs_area *area = super->s_journal_area;
|
|
struct logfs_journal_header *jh = super->s_compressed_je;
|
|
size_t len;
|
|
int must_pad = 0;
|
|
s64 ofs;
|
|
|
|
len = __logfs_write_je(sb, buf, type, buf_len);
|
|
if (jh->h_type == cpu_to_be16(JE_COMMIT))
|
|
must_pad = 1;
|
|
|
|
ofs = logfs_get_free_bytes(area, &len, must_pad);
|
|
if (ofs < 0)
|
|
return ofs;
|
|
logfs_buf_write(area, ofs, super->s_compressed_je, len);
|
|
BUG_ON(super->s_no_je >= MAX_JOURNAL_ENTRIES);
|
|
super->s_je_array[super->s_no_je++] = cpu_to_be64(ofs);
|
|
return 0;
|
|
}
|
|
|
|
static int logfs_write_je(struct super_block *sb,
|
|
void* (*write)(struct super_block *sb, void *scratch,
|
|
u16 *type, size_t *len))
|
|
{
|
|
void *buf;
|
|
size_t len;
|
|
u16 type;
|
|
|
|
buf = write(sb, logfs_super(sb)->s_je, &type, &len);
|
|
return logfs_write_je_buf(sb, buf, type, len);
|
|
}
|
|
|
|
int write_alias_journal(struct super_block *sb, u64 ino, u64 bix,
|
|
level_t level, int child_no, __be64 val)
|
|
{
|
|
struct logfs_super *super = logfs_super(sb);
|
|
struct logfs_obj_alias *oa = super->s_je;
|
|
int err = 0, fill = super->s_je_fill;
|
|
|
|
log_aliases("logfs_write_obj_aliases #%x(%llx, %llx, %x, %x) %llx\n",
|
|
fill, ino, bix, level, child_no, be64_to_cpu(val));
|
|
oa[fill].ino = cpu_to_be64(ino);
|
|
oa[fill].bix = cpu_to_be64(bix);
|
|
oa[fill].val = val;
|
|
oa[fill].level = (__force u8)level;
|
|
oa[fill].child_no = cpu_to_be16(child_no);
|
|
fill++;
|
|
if (fill >= sb->s_blocksize / sizeof(*oa)) {
|
|
err = logfs_write_je_buf(sb, oa, JE_OBJ_ALIAS, sb->s_blocksize);
|
|
fill = 0;
|
|
}
|
|
|
|
super->s_je_fill = fill;
|
|
return err;
|
|
}
|
|
|
|
static int logfs_write_obj_aliases(struct super_block *sb)
|
|
{
|
|
struct logfs_super *super = logfs_super(sb);
|
|
int err;
|
|
|
|
log_journal("logfs_write_obj_aliases: %d aliases to write\n",
|
|
super->s_no_object_aliases);
|
|
super->s_je_fill = 0;
|
|
err = logfs_write_obj_aliases_pagecache(sb);
|
|
if (err)
|
|
return err;
|
|
|
|
if (super->s_je_fill)
|
|
err = logfs_write_je_buf(sb, super->s_je, JE_OBJ_ALIAS,
|
|
super->s_je_fill
|
|
* sizeof(struct logfs_obj_alias));
|
|
return err;
|
|
}
|
|
|
|
/*
|
|
* Write all journal entries. The goto logic ensures that all journal entries
|
|
* are written whenever a new segment is used. It is ugly and potentially a
|
|
* bit wasteful, but robustness is more important. With this we can *always*
|
|
* erase all journal segments except the one containing the most recent commit.
|
|
*/
|
|
void logfs_write_anchor(struct super_block *sb)
|
|
{
|
|
struct logfs_super *super = logfs_super(sb);
|
|
struct logfs_area *area = super->s_journal_area;
|
|
int i, err;
|
|
|
|
if (!(super->s_flags & LOGFS_SB_FLAG_DIRTY))
|
|
return;
|
|
super->s_flags &= ~LOGFS_SB_FLAG_DIRTY;
|
|
|
|
BUG_ON(super->s_flags & LOGFS_SB_FLAG_SHUTDOWN);
|
|
mutex_lock(&super->s_journal_mutex);
|
|
|
|
/* Do this first or suffer corruption */
|
|
logfs_sync_segments(sb);
|
|
account_shadows(sb);
|
|
|
|
again:
|
|
super->s_no_je = 0;
|
|
for_each_area(i) {
|
|
if (!super->s_area[i]->a_is_open)
|
|
continue;
|
|
super->s_sum_index = i;
|
|
err = logfs_write_je(sb, logfs_write_area);
|
|
if (err)
|
|
goto again;
|
|
}
|
|
err = logfs_write_obj_aliases(sb);
|
|
if (err)
|
|
goto again;
|
|
err = logfs_write_je(sb, logfs_write_erasecount);
|
|
if (err)
|
|
goto again;
|
|
err = logfs_write_je(sb, __logfs_write_anchor);
|
|
if (err)
|
|
goto again;
|
|
err = logfs_write_je(sb, logfs_write_dynsb);
|
|
if (err)
|
|
goto again;
|
|
/*
|
|
* Order is imperative. First we sync all writes, including the
|
|
* non-committed journal writes. Then we write the final commit and
|
|
* sync the current journal segment.
|
|
* There is a theoretical bug here. Syncing the journal segment will
|
|
* write a number of journal entries and the final commit. All these
|
|
* are written in a single operation. If the device layer writes the
|
|
* data back-to-front, the commit will precede the other journal
|
|
* entries, leaving a race window.
|
|
* Two fixes are possible. Preferred is to fix the device layer to
|
|
* ensure writes happen front-to-back. Alternatively we can insert
|
|
* another logfs_sync_area() super->s_devops->sync() combo before
|
|
* writing the commit.
|
|
*/
|
|
/*
|
|
* On another subject, super->s_devops->sync is usually not necessary.
|
|
* Unless called from sys_sync or friends, a barrier would suffice.
|
|
*/
|
|
super->s_devops->sync(sb);
|
|
err = logfs_write_je(sb, logfs_write_commit);
|
|
if (err)
|
|
goto again;
|
|
log_journal("Write commit to %llx\n",
|
|
be64_to_cpu(super->s_je_array[super->s_no_je - 1]));
|
|
logfs_sync_area(area);
|
|
BUG_ON(area->a_used_bytes != area->a_written_bytes);
|
|
super->s_devops->sync(sb);
|
|
|
|
mutex_unlock(&super->s_journal_mutex);
|
|
return;
|
|
}
|
|
|
|
void do_logfs_journal_wl_pass(struct super_block *sb)
|
|
{
|
|
struct logfs_super *super = logfs_super(sb);
|
|
struct logfs_area *area = super->s_journal_area;
|
|
struct btree_head32 *head = &super->s_reserved_segments;
|
|
u32 segno, ec;
|
|
int i, err;
|
|
|
|
log_journal("Journal requires wear-leveling.\n");
|
|
/* Drop old segments */
|
|
journal_for_each(i)
|
|
if (super->s_journal_seg[i]) {
|
|
btree_remove32(head, super->s_journal_seg[i]);
|
|
logfs_set_segment_unreserved(sb,
|
|
super->s_journal_seg[i],
|
|
super->s_journal_ec[i]);
|
|
super->s_journal_seg[i] = 0;
|
|
super->s_journal_ec[i] = 0;
|
|
}
|
|
/* Get new segments */
|
|
for (i = 0; i < super->s_no_journal_segs; i++) {
|
|
segno = get_best_cand(sb, &super->s_reserve_list, &ec);
|
|
super->s_journal_seg[i] = segno;
|
|
super->s_journal_ec[i] = ec;
|
|
logfs_set_segment_reserved(sb, segno);
|
|
err = btree_insert32(head, segno, (void *)1, GFP_KERNEL);
|
|
BUG_ON(err); /* mempool should prevent this */
|
|
err = logfs_erase_segment(sb, segno, 1);
|
|
BUG_ON(err); /* FIXME: remount-ro would be nicer */
|
|
}
|
|
/* Manually move journal_area */
|
|
freeseg(sb, area->a_segno);
|
|
area->a_segno = super->s_journal_seg[0];
|
|
area->a_is_open = 0;
|
|
area->a_used_bytes = 0;
|
|
/* Write journal */
|
|
logfs_write_anchor(sb);
|
|
/* Write superblocks */
|
|
err = logfs_write_sb(sb);
|
|
BUG_ON(err);
|
|
}
|
|
|
|
static const struct logfs_area_ops journal_area_ops = {
|
|
.get_free_segment = journal_get_free_segment,
|
|
.get_erase_count = journal_get_erase_count,
|
|
.erase_segment = journal_erase_segment,
|
|
};
|
|
|
|
int logfs_init_journal(struct super_block *sb)
|
|
{
|
|
struct logfs_super *super = logfs_super(sb);
|
|
size_t bufsize = max_t(size_t, sb->s_blocksize, super->s_writesize)
|
|
+ MAX_JOURNAL_HEADER;
|
|
int ret = -ENOMEM;
|
|
|
|
mutex_init(&super->s_journal_mutex);
|
|
btree_init_mempool32(&super->s_reserved_segments, super->s_btree_pool);
|
|
|
|
super->s_je = kzalloc(bufsize, GFP_KERNEL);
|
|
if (!super->s_je)
|
|
return ret;
|
|
|
|
super->s_compressed_je = kzalloc(bufsize, GFP_KERNEL);
|
|
if (!super->s_compressed_je)
|
|
return ret;
|
|
|
|
super->s_master_inode = logfs_new_meta_inode(sb, LOGFS_INO_MASTER);
|
|
if (IS_ERR(super->s_master_inode))
|
|
return PTR_ERR(super->s_master_inode);
|
|
|
|
ret = logfs_read_journal(sb);
|
|
if (ret)
|
|
return -EIO;
|
|
|
|
reserve_sb_and_journal(sb);
|
|
logfs_calc_free(sb);
|
|
|
|
super->s_journal_area->a_ops = &journal_area_ops;
|
|
return 0;
|
|
}
|
|
|
|
void logfs_cleanup_journal(struct super_block *sb)
|
|
{
|
|
struct logfs_super *super = logfs_super(sb);
|
|
|
|
btree_grim_visitor32(&super->s_reserved_segments, 0, NULL);
|
|
|
|
kfree(super->s_compressed_je);
|
|
kfree(super->s_je);
|
|
}
|