| /* |
| * 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" |
| |
| 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) |
| logfs_buf_recover(area, ofs, a + 1, super->s_writesize); |
| else |
| logfs_buf_recover(area, ofs, NULL, 0); |
| return 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: |
| 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); |
| destroy_meta_inode(super->s_master_inode); |
| super->s_master_inode = NULL; |
| |
| kfree(super->s_compressed_je); |
| kfree(super->s_je); |
| } |