mirror of
https://github.com/edk2-porting/linux-next.git
synced 2024-12-05 20:04:19 +08:00
ddb24bbac3
While writing the partial journal entries we assumed that the page associated with the journal would always in locatable. This incorrect assumption resulted in the following BUG kernel BUG at /home/benixon/WD_SMR/kernels/linux-3.3.7-logfs/fs/logfs/journal.c:569! EIP is at logfs_write_area+0xb6/0x109 [logfs] EAX: 00000000 EBX: 00000000 ECX: ef6efea4 EDX: 00000000 ESI: 001b9000 EDI: f009e000 EBP: c3c13f14 ESP: c3c13ef0 DS: 007b ES: 007b FS: 00d8 GS: 00e0 SS: 0068 Process sync (pid: 1799, ti=c3c12000 task=f07825b0 task.ti=c3c12000) Stack: 01001000 c3c13f26 781b9000 00000000 f009e000 f7286000 f1f83400 f8445071 f1f83400 c3c13f30 f8445ae9 c3c13f20 0000100a 000ee000 f009e000 00000001 c3c13f5c f8445d17 c05eb0ee 00000000 f1f83400 ef718000 f009e25c ea9c3d80 Call Trace: [<f8445071>] ? account_shadow+0x16d/0x16d [logfs] [<f8445ae9>] logfs_write_je+0x2a/0x44 [logfs] [<f8445d17>] logfs_write_anchor+0x114/0x228 [logfs] [<c05eb0ee>] ? empty+0x5/0x5 [<f8444522>] logfs_sync_fs+0x1e/0x31 [logfs] [<c051be66>] __sync_filesystem+0x5d/0x6f [<c051be8d>] sync_one_sb+0x15/0x17 [<c04ff8b0>] iterate_supers+0x59/0x9a [<c051be78>] ? __sync_filesystem+0x6f/0x6f [<c051befc>] sys_sync+0x29/0x4f [<c084285f>] sysenter_do_call+0x12/0x28 EIP: [<f8445127>] logfs_write_area+0xb6/0x109 [logfs] SS:ESP 0068:c3c13ef0 ---[ end trace ef6e9ef52601a945 ]--- The fix is to create the pagecache page if it is not locatable. Reported-and-tested-by: Benixon Dhas <Benixon.Dhas@wdc.com> Signed-off-by: Prasad Joshi <prasadjoshi.linux@gmail.com>
895 lines
24 KiB
C
895 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_or_create_page(mapping, index, GFP_NOFS);
|
|
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);
|
|
|
|
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_NOFS);
|
|
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);
|
|
}
|