From 177af7f746a9c3b411e38d45dc3db6e23c3d3544 Mon Sep 17 00:00:00 2001 From: Zach Brown Date: Fri, 1 May 2020 10:29:09 -0700 Subject: [PATCH] scoutfs: use larger metadata blocks Introduce different constants for small and large metadata block sizes. The small 4KB size is used for the super block, quorum blocks, and as the granularity of file data block allocation. The larger 64KB size is used for the radix, btree, and forest bloom metadata block structures. The bulk of this are obvious transitions from the old single constant to the appropriate new constant. But there are a few more involved changes, though just barely. The block crc calculation now needs the caller to pass in the size of the block. The radix function to return free bytes instead returns free blocks and the caller is responsible for knowing how big its managed blocks are. Signed-off-by: Zach Brown --- kmod/src/block.c | 55 ++++++++++++++++++----------------- kmod/src/block.h | 4 +-- kmod/src/btree.c | 12 ++++---- kmod/src/count.h | 6 ++-- kmod/src/data.c | 31 ++++++++++---------- kmod/src/forest.c | 4 +-- kmod/src/format.h | 73 +++++++++++++++++++++++++++++------------------ kmod/src/inode.c | 7 +++-- kmod/src/ioctl.c | 16 +++++------ kmod/src/quorum.c | 18 ++++++------ kmod/src/radix.c | 14 ++++----- kmod/src/radix.h | 4 +-- kmod/src/server.c | 4 +-- kmod/src/super.c | 8 +++--- 14 files changed, 138 insertions(+), 118 deletions(-) diff --git a/kmod/src/block.c b/kmod/src/block.c index 8c8f1b5b..b7da3950 100644 --- a/kmod/src/block.c +++ b/kmod/src/block.c @@ -108,18 +108,18 @@ do { \ * be refactored away. */ -__le32 scoutfs_block_calc_crc(struct scoutfs_block_header *hdr) +__le32 scoutfs_block_calc_crc(struct scoutfs_block_header *hdr, u32 size) { int off = offsetof(struct scoutfs_block_header, crc) + FIELD_SIZEOF(struct scoutfs_block_header, crc); - u32 calc = crc32c(~0, (char *)hdr + off, SCOUTFS_BLOCK_SIZE - off); + u32 calc = crc32c(~0, (char *)hdr + off, size - off); return cpu_to_le32(calc); } -bool scoutfs_block_valid_crc(struct scoutfs_block_header *hdr) +bool scoutfs_block_valid_crc(struct scoutfs_block_header *hdr, u32 size) { - return hdr->crc == scoutfs_block_calc_crc(hdr); + return hdr->crc == scoutfs_block_calc_crc(hdr, size); } bool scoutfs_block_valid_ref(struct super_block *sb, @@ -157,19 +157,19 @@ static struct block_private *block_alloc(struct super_block *sb, u64 blkno) * more careful with a partial page allocator when allocating * blocks and would make the lru per-page instead of per-block. */ - BUILD_BUG_ON(PAGE_SIZE > SCOUTFS_BLOCK_SIZE); + BUILD_BUG_ON(PAGE_SIZE > SCOUTFS_BLOCK_LG_SIZE); bp = kzalloc(sizeof(struct block_private), GFP_NOFS); if (!bp) goto out; - bp->page = alloc_pages(GFP_NOFS, SCOUTFS_BLOCK_PAGE_ORDER); + bp->page = alloc_pages(GFP_NOFS, SCOUTFS_BLOCK_LG_PAGE_ORDER); if (bp->page) { scoutfs_inc_counter(sb, block_cache_alloc_page_order); set_bit(BLOCK_BIT_PAGE_ALLOC, &bp->bits); bp->bl.data = page_address(bp->page); } else { - bp->virt = __vmalloc(SCOUTFS_BLOCK_SIZE, + bp->virt = __vmalloc(SCOUTFS_BLOCK_LG_SIZE, GFP_NOFS | __GFP_HIGHMEM, PAGE_KERNEL); if (!bp->virt) { kfree(bp); @@ -206,7 +206,7 @@ static void block_free(struct super_block *sb, struct block_private *bp) TRACE_BLOCK(free, bp); if (test_bit(BLOCK_BIT_PAGE_ALLOC, &bp->bits)) - __free_pages(bp->page, SCOUTFS_BLOCK_PAGE_ORDER); + __free_pages(bp->page, SCOUTFS_BLOCK_LG_PAGE_ORDER); else if (test_bit(BLOCK_BIT_VIRT, &bp->bits)) vfree(bp->virt); else @@ -441,7 +441,7 @@ static int block_submit_bio(struct super_block *sb, struct block_private *bp, sector_t sector; int ret = 0; - sector = bp->bl.blkno << (SCOUTFS_BLOCK_SHIFT - 9); + sector = bp->bl.blkno << (SCOUTFS_BLOCK_LG_SHIFT - 9); WARN_ON_ONCE(bp->bl.blkno == U64_MAX); WARN_ON_ONCE(sector == U64_MAX || sector == 0); @@ -453,9 +453,9 @@ static int block_submit_bio(struct super_block *sb, struct block_private *bp, blk_start_plug(&plug); - for (off = 0; off < SCOUTFS_BLOCK_SIZE; off += PAGE_SIZE) { + for (off = 0; off < SCOUTFS_BLOCK_LG_SIZE; off += PAGE_SIZE) { if (!bio) { - bio = bio_alloc(GFP_NOFS, SCOUTFS_PAGES_PER_BLOCK); + bio = bio_alloc(GFP_NOFS, SCOUTFS_BLOCK_LG_PAGES_PER); if (!bio) { ret = -ENOMEM; break; @@ -634,6 +634,7 @@ void scoutfs_block_invalidate(struct super_block *sb, struct scoutfs_block *bl) } } +/* This is only used for large metadata blocks */ bool scoutfs_block_consistent_ref(struct super_block *sb, struct scoutfs_block *bl, __le64 seq, __le64 blkno, u32 magic) @@ -643,7 +644,8 @@ bool scoutfs_block_consistent_ref(struct super_block *sb, struct scoutfs_block_header *hdr = bl->data; if (!test_bit(BLOCK_BIT_CRC_VALID, &bp->bits)) { - if (hdr->crc != scoutfs_block_calc_crc(hdr)) + if (hdr->crc != + scoutfs_block_calc_crc(hdr, SCOUTFS_BLOCK_LG_SIZE)) return false; set_bit(BLOCK_BIT_CRC_VALID, &bp->bits); } @@ -722,7 +724,7 @@ int scoutfs_block_writer_write(struct super_block *sb, /* checksum everything to reduce time between io submission merging */ list_for_each_entry(bp, &wri->dirty_list, dirty_entry) { hdr = bp->bl.data; - hdr->crc = scoutfs_block_calc_crc(hdr); + hdr->crc = scoutfs_block_calc_crc(hdr, SCOUTFS_BLOCK_LG_SIZE); } blk_start_plug(&plug); @@ -866,7 +868,7 @@ bool scoutfs_block_writer_has_dirty(struct super_block *sb, u64 scoutfs_block_writer_dirty_bytes(struct super_block *sb, struct scoutfs_block_writer *wri) { - return wri->nr_dirty_blocks * SCOUTFS_BLOCK_SIZE; + return wri->nr_dirty_blocks * SCOUTFS_BLOCK_LG_SIZE; } /* @@ -916,12 +918,9 @@ static int block_shrink(struct shrinker *shrink, struct shrink_control *sc) spin_unlock(&binf->lock); out: - return min_t(u64, binf->lru_nr * SCOUTFS_PAGES_PER_BLOCK, INT_MAX); + return min_t(u64, binf->lru_nr * SCOUTFS_BLOCK_LG_PAGES_PER, INT_MAX); } -#define SCOUTFS_SM_BLOCK_SHIFT 12 -#define SCOUTFS_SM_BLOCK_SIZE (1 << SCOUTFS_SM_BLOCK_SHIFT) - struct sm_block_completion { struct completion comp; int err; @@ -956,11 +955,9 @@ static int sm_block_io(struct super_block *sb, int rw, u64 blkno, struct bio *bio; int ret; - BUILD_BUG_ON(PAGE_SIZE < SCOUTFS_SM_BLOCK_SIZE); - /* block calc crc is assuming block size, they'll be different later */ - BUILD_BUG_ON(SCOUTFS_SM_BLOCK_SIZE != SCOUTFS_BLOCK_SIZE); + BUILD_BUG_ON(PAGE_SIZE < SCOUTFS_BLOCK_SM_SIZE); - if (WARN_ON_ONCE(len > SCOUTFS_SM_BLOCK_SIZE) || + if (WARN_ON_ONCE(len > SCOUTFS_BLOCK_SM_SIZE) || WARN_ON_ONCE(!(rw & WRITE) && !blk_crc)) return -EINVAL; @@ -972,10 +969,11 @@ static int sm_block_io(struct super_block *sb, int rw, u64 blkno, if (rw & WRITE) { memcpy(pg_hdr, hdr, len); - if (len < SCOUTFS_SM_BLOCK_SIZE) + if (len < SCOUTFS_BLOCK_SM_SIZE) memset((char *)pg_hdr + len, 0, - SCOUTFS_SM_BLOCK_SIZE - len); - pg_hdr->crc = scoutfs_block_calc_crc(pg_hdr); + SCOUTFS_BLOCK_SM_SIZE - len); + pg_hdr->crc = scoutfs_block_calc_crc(pg_hdr, + SCOUTFS_BLOCK_SM_SIZE); } bio = bio_alloc(GFP_NOFS, 1); @@ -984,11 +982,11 @@ static int sm_block_io(struct super_block *sb, int rw, u64 blkno, goto out; } - bio->bi_sector = blkno << (SCOUTFS_SM_BLOCK_SHIFT - 9); + bio->bi_sector = blkno << (SCOUTFS_BLOCK_SM_SHIFT - 9); bio->bi_bdev = sb->s_bdev; bio->bi_end_io = sm_block_bio_end_io; bio->bi_private = &sbc; - bio_add_page(bio, page, SCOUTFS_SM_BLOCK_SIZE, 0); + bio_add_page(bio, page, SCOUTFS_BLOCK_SM_SIZE, 0); init_completion(&sbc.comp); sbc.err = 0; @@ -1000,7 +998,8 @@ static int sm_block_io(struct super_block *sb, int rw, u64 blkno, if (ret == 0 && !(rw & WRITE)) { memcpy(hdr, pg_hdr, len); - *blk_crc = scoutfs_block_calc_crc(pg_hdr); + *blk_crc = scoutfs_block_calc_crc(pg_hdr, + SCOUTFS_BLOCK_SM_SIZE); } out: __free_page(page); diff --git a/kmod/src/block.h b/kmod/src/block.h index dc62bf77..57e849a5 100644 --- a/kmod/src/block.h +++ b/kmod/src/block.h @@ -12,8 +12,8 @@ struct scoutfs_block { void *data; }; -__le32 scoutfs_block_calc_crc(struct scoutfs_block_header *hdr); -bool scoutfs_block_valid_crc(struct scoutfs_block_header *hdr); +__le32 scoutfs_block_calc_crc(struct scoutfs_block_header *hdr, u32 size); +bool scoutfs_block_valid_crc(struct scoutfs_block_header *hdr, u32 size); bool scoutfs_block_valid_ref(struct super_block *sb, struct scoutfs_block_header *hdr, __le64 seq, __le64 blkno); diff --git a/kmod/src/btree.c b/kmod/src/btree.c index 7edee5b6..969b831a 100644 --- a/kmod/src/btree.c +++ b/kmod/src/btree.c @@ -111,7 +111,7 @@ static inline unsigned int item_bytes(struct scoutfs_btree_item *item) */ static unsigned int join_low_watermark(void) { - return (SCOUTFS_BLOCK_SIZE - sizeof(struct scoutfs_btree_block)) / 4; + return (SCOUTFS_BLOCK_LG_SIZE - sizeof(struct scoutfs_btree_block)) / 4; } /* @@ -121,7 +121,7 @@ static unsigned int join_low_watermark(void) static unsigned int item_full_pct(struct scoutfs_btree_block *bt) { return (int)le16_to_cpu(bt->total_item_bytes) * 100 / - (SCOUTFS_BLOCK_SIZE - sizeof(struct scoutfs_btree_block)); + (SCOUTFS_BLOCK_LG_SIZE - sizeof(struct scoutfs_btree_block)); } static inline __le16 ptr_off(struct scoutfs_btree_block *bt, void *ptr) @@ -216,7 +216,7 @@ static int leaf_item_hash_ind(struct scoutfs_key *key) static __le16 *leaf_item_hash_buckets(struct scoutfs_btree_block *bt) { - return (void *)bt + SCOUTFS_BLOCK_SIZE - + return (void *)bt + SCOUTFS_BLOCK_LG_SIZE - SCOUTFS_BTREE_LEAF_ITEM_HASH_BYTES; } @@ -760,11 +760,11 @@ retry: if (bt) { /* returning a cow of an existing block */ - memcpy(new, bt, SCOUTFS_BLOCK_SIZE); + memcpy(new, bt, SCOUTFS_BLOCK_LG_SIZE); scoutfs_block_put(sb, bl); } else { /* returning a newly allocated block */ - memset(new, 0, SCOUTFS_BLOCK_SIZE); + memset(new, 0, SCOUTFS_BLOCK_LG_SIZE); new->hdr.fsid = super->hdr.fsid; } bl = new_bl; @@ -828,7 +828,7 @@ static void init_btree_block(struct scoutfs_btree_block *bt, int level) { int free; - free = SCOUTFS_BLOCK_SIZE - sizeof(struct scoutfs_btree_block); + free = SCOUTFS_BLOCK_LG_SIZE - sizeof(struct scoutfs_btree_block); if (level == 0) free -= SCOUTFS_BTREE_LEAF_ITEM_HASH_BYTES; diff --git a/kmod/src/count.h b/kmod/src/count.h index b2dd8152..176321d0 100644 --- a/kmod/src/count.h +++ b/kmod/src/count.h @@ -245,9 +245,9 @@ static inline const struct scoutfs_item_count SIC_XATTR_SET(unsigned old_parts, static inline const struct scoutfs_item_count SIC_WRITE_BEGIN(void) { struct scoutfs_item_count cnt = {0,}; - unsigned nr_free = (1 + SCOUTFS_BLOCKS_PER_PAGE) * 3; - unsigned nr_file = (DIV_ROUND_UP(SCOUTFS_BLOCKS_PER_PAGE, 2) + - SCOUTFS_BLOCKS_PER_PAGE) * 3; + unsigned nr_free = (1 + SCOUTFS_BLOCK_SM_PER_PAGE) * 3; + unsigned nr_file = (DIV_ROUND_UP(SCOUTFS_BLOCK_SM_PER_PAGE, 2) + + SCOUTFS_BLOCK_SM_PER_PAGE) * 3; __count_dirty_inode(&cnt); diff --git a/kmod/src/data.c b/kmod/src/data.c index b129aa42..ed42bb8a 100644 --- a/kmod/src/data.c +++ b/kmod/src/data.c @@ -803,8 +803,8 @@ int scoutfs_data_truncate_items(struct super_block *sb, struct inode *inode, WARN_ON_ONCE(inode && !mutex_is_locked(&inode->i_mutex)); /* clamp last to the last possible block? */ - if (last > SCOUTFS_BLOCK_MAX) - last = SCOUTFS_BLOCK_MAX; + if (last > SCOUTFS_BLOCK_SM_MAX) + last = SCOUTFS_BLOCK_SM_MAX; trace_scoutfs_data_truncate_items(sb, iblock, last, offline); @@ -1060,7 +1060,7 @@ out: offset = iblock - ext->iblock; map_bh(bh, inode->i_sb, ext->blkno + offset); bh->b_size = min_t(u64, bh->b_size, - (ext->count - offset) << SCOUTFS_BLOCK_SHIFT); + (ext->count - offset) << SCOUTFS_BLOCK_SM_SHIFT); } if (ext) @@ -1483,8 +1483,8 @@ long scoutfs_fallocate(struct file *file, int mode, loff_t offset, loff_t len) goto out; } - iblock = offset >> SCOUTFS_BLOCK_SHIFT; - last = (offset + len - 1) >> SCOUTFS_BLOCK_SHIFT; + iblock = offset >> SCOUTFS_BLOCK_SM_SHIFT; + last = (offset + len - 1) >> SCOUTFS_BLOCK_SM_SHIFT; while(iblock <= last) { @@ -1496,7 +1496,7 @@ long scoutfs_fallocate(struct file *file, int mode, loff_t offset, loff_t len) ret = fallocate_extents(sb, inode, iblock, last, lock); if (ret >= 0 && !(mode & FALLOC_FL_KEEP_SIZE)) { - end = (iblock + ret) << SCOUTFS_BLOCK_SHIFT; + end = (iblock + ret) << SCOUTFS_BLOCK_SM_SHIFT; if (end > offset + len) end = offset + len; if (end > i_size_read(inode)) @@ -1549,7 +1549,7 @@ int scoutfs_data_init_offline_extent(struct inode *inode, u64 size, u64 off; int ret; - blocks = DIV_ROUND_UP(size, SCOUTFS_BLOCK_SIZE); + blocks = DIV_ROUND_UP(size, SCOUTFS_BLOCK_SM_SIZE); scoutfs_inode_get_onoff(inode, &on, &off); iblock = off; @@ -1622,9 +1622,9 @@ static int fill_extent(struct fiemap_extent_info *fieinfo, flags |= FIEMAP_EXTENT_UNWRITTEN; return fiemap_fill_next_extent(fieinfo, - ext->iblock << SCOUTFS_BLOCK_SHIFT, - ext->blkno << SCOUTFS_BLOCK_SHIFT, - ext->count << SCOUTFS_BLOCK_SHIFT, + ext->iblock << SCOUTFS_BLOCK_SM_SHIFT, + ext->blkno << SCOUTFS_BLOCK_SM_SHIFT, + ext->count << SCOUTFS_BLOCK_SM_SHIFT, flags); } @@ -1666,8 +1666,8 @@ int scoutfs_data_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo, memset(&cur, 0, sizeof(cur)); last_flags = 0; - iblock = start >> SCOUTFS_BLOCK_SHIFT; - last = (start + len - 1) >> SCOUTFS_BLOCK_SHIFT; + iblock = start >> SCOUTFS_BLOCK_SM_SHIFT; + last = (start + len - 1) >> SCOUTFS_BLOCK_SM_SHIFT; for (;;) { ret = load_unpacked_extents(sb, ino, iblock, last, false, @@ -1831,8 +1831,8 @@ int scoutfs_data_wait_check(struct inode *inode, loff_t pos, loff_t len, } } - iblock = pos >> SCOUTFS_BLOCK_SHIFT; - last_block = (pos + len - 1) >> SCOUTFS_BLOCK_SHIFT; + iblock = pos >> SCOUTFS_BLOCK_SM_SHIFT; + last_block = (pos + len - 1) >> SCOUTFS_BLOCK_SM_SHIFT; while(iblock <= last_block) { @@ -2056,7 +2056,8 @@ u64 scoutfs_data_alloc_free_bytes(struct super_block *sb) { DECLARE_DATA_INFO(sb, datinf); - return scoutfs_radix_root_free_bytes(sb, &datinf->data_avail); + return scoutfs_radix_root_free_blocks(sb, &datinf->data_avail) << + SCOUTFS_BLOCK_SM_SHIFT; } int scoutfs_data_setup(struct super_block *sb) diff --git a/kmod/src/forest.c b/kmod/src/forest.c index af44204e..9bad162e 100644 --- a/kmod/src/forest.c +++ b/kmod/src/forest.c @@ -1163,9 +1163,9 @@ static int set_lock_bloom_bits(struct super_block *sb, err = scoutfs_radix_free(sb, finf->alloc, finf->wri, le64_to_cpu(ref->blkno)); BUG_ON(err); /* could have dirtied */ - memcpy(new_bl->data, bl->data, SCOUTFS_BLOCK_SIZE); + memcpy(new_bl->data, bl->data, SCOUTFS_BLOCK_LG_SIZE); } else { - memset(new_bl->data, 0, SCOUTFS_BLOCK_SIZE); + memset(new_bl->data, 0, SCOUTFS_BLOCK_LG_SIZE); } scoutfs_block_writer_mark_dirty(sb, finf->wri, new_bl); diff --git a/kmod/src/format.h b/kmod/src/format.h index 822675e6..6c667c97 100644 --- a/kmod/src/format.h +++ b/kmod/src/format.h @@ -11,24 +11,42 @@ #define SCOUTFS_BLOCK_MAGIC_RADIX 0xebeb5e65 /* - * The super block and btree blocks are fixed 4k. + * The super block, quorum block, and file data allocation granularity + * use the smaller 4KB block. */ -#define SCOUTFS_BLOCK_SHIFT 12 -#define SCOUTFS_BLOCK_SIZE (1 << SCOUTFS_BLOCK_SHIFT) -#define SCOUTFS_BLOCK_MASK (SCOUTFS_BLOCK_SIZE - 1) -#define SCOUTFS_BLOCKS_PER_PAGE (PAGE_SIZE / SCOUTFS_BLOCK_SIZE) -#define SCOUTFS_BLOCK_SECTOR_SHIFT (SCOUTFS_BLOCK_SHIFT - 9) -#define SCOUTFS_BLOCK_SECTORS (1 << SCOUTFS_BLOCK_SECTOR_SHIFT) -#define SCOUTFS_BLOCK_MAX (U64_MAX >> SCOUTFS_BLOCK_SHIFT) +#define SCOUTFS_BLOCK_SM_SHIFT 12 +#define SCOUTFS_BLOCK_SM_SIZE (1 << SCOUTFS_BLOCK_SM_SHIFT) +#define SCOUTFS_BLOCK_SM_MASK (SCOUTFS_BLOCK_SM_SIZE - 1) +#define SCOUTFS_BLOCK_SM_PER_PAGE (PAGE_SIZE / SCOUTFS_BLOCK_SM_SIZE) +#define SCOUTFS_BLOCK_SM_SECTOR_SHIFT (SCOUTFS_BLOCK_SM_SHIFT - 9) +#define SCOUTFS_BLOCK_SM_SECTORS (1 << SCOUTFS_BLOCK_SM_SECTOR_SHIFT) +#define SCOUTFS_BLOCK_SM_MAX (U64_MAX >> SCOUTFS_BLOCK_SM_SHIFT) +#define SCOUTFS_BLOCK_SM_PAGES_PER (SCOUTFS_BLOCK_SM_SIZE / PAGE_SIZE) +#define SCOUTFS_BLOCK_SM_PAGE_ORDER (SCOUTFS_BLOCK_SM_SHIFT - PAGE_SHIFT) + +/* + * The radix and btree structures, and the forest bloom block, use the + * larger 64KB metadata block size. + */ +#define SCOUTFS_BLOCK_LG_SHIFT 16 +#define SCOUTFS_BLOCK_LG_SIZE (1 << SCOUTFS_BLOCK_LG_SHIFT) +#define SCOUTFS_BLOCK_LG_MASK (SCOUTFS_BLOCK_LG_SIZE - 1) +#define SCOUTFS_BLOCK_LG_PER_PAGE (PAGE_SIZE / SCOUTFS_BLOCK_LG_SIZE) +#define SCOUTFS_BLOCK_LG_SECTOR_SHIFT (SCOUTFS_BLOCK_LG_SHIFT - 9) +#define SCOUTFS_BLOCK_LG_SECTORS (1 << SCOUTFS_BLOCK_LG_SECTOR_SHIFT) +#define SCOUTFS_BLOCK_LG_MAX (U64_MAX >> SCOUTFS_BLOCK_LG_SHIFT) +#define SCOUTFS_BLOCK_LG_PAGES_PER (SCOUTFS_BLOCK_LG_SIZE / PAGE_SIZE) +#define SCOUTFS_BLOCK_LG_PAGE_ORDER (SCOUTFS_BLOCK_LG_SHIFT - PAGE_SHIFT) + +#define SCOUTFS_BLOCK_SM_LG_SHIFT (SCOUTFS_BLOCK_LG_SHIFT - \ + SCOUTFS_BLOCK_SM_SHIFT) -#define SCOUTFS_PAGES_PER_BLOCK (SCOUTFS_BLOCK_SIZE / PAGE_SIZE) -#define SCOUTFS_BLOCK_PAGE_ORDER (SCOUTFS_BLOCK_SHIFT - PAGE_SHIFT) /* * The super block leaves some room before the first block for platform * structures like boot loaders. */ -#define SCOUTFS_SUPER_BLKNO ((64ULL * 1024) >> SCOUTFS_BLOCK_SHIFT) +#define SCOUTFS_SUPER_BLKNO ((64ULL * 1024) >> SCOUTFS_BLOCK_SM_SHIFT) /* * A reasonably large region of aligned quorum blocks follow the super @@ -38,8 +56,8 @@ * mounts that have a reasonable probability of not overwriting each * other's random block locations. */ -#define SCOUTFS_QUORUM_BLKNO ((256ULL * 1024) >> SCOUTFS_BLOCK_SHIFT) -#define SCOUTFS_QUORUM_BLOCKS ((256ULL * 1024) >> SCOUTFS_BLOCK_SHIFT) +#define SCOUTFS_QUORUM_BLKNO ((256ULL * 1024) >> SCOUTFS_BLOCK_SM_SHIFT) +#define SCOUTFS_QUORUM_BLOCKS ((256ULL * 1024) >> SCOUTFS_BLOCK_SM_SHIFT) #define SCOUTFS_UNIQUE_NAME_MAX_BYTES 64 /* includes null */ @@ -168,8 +186,9 @@ struct scoutfs_radix_root { struct scoutfs_radix_ref ref; } __packed; -#define SCOUTFS_RADIX_REFS \ - ((SCOUTFS_BLOCK_SIZE - offsetof(struct scoutfs_radix_block, refs[0])) /\ +#define SCOUTFS_RADIX_REFS \ + ((SCOUTFS_BLOCK_LG_SIZE - \ + offsetof(struct scoutfs_radix_block, refs[0])) / \ sizeof(struct scoutfs_radix_ref)) /* 8 meg regions with 4k data blocks */ @@ -178,8 +197,8 @@ struct scoutfs_radix_root { #define SCOUTFS_RADIX_LG_MASK (SCOUTFS_RADIX_LG_BITS - 1) /* round block bits down to a multiple of large ranges */ -#define SCOUTFS_RADIX_BITS \ - (((SCOUTFS_BLOCK_SIZE - \ +#define SCOUTFS_RADIX_BITS \ + (((SCOUTFS_BLOCK_LG_SIZE - \ offsetof(struct scoutfs_radix_block, bits[0])) * 8) & \ ~(__u64)SCOUTFS_RADIX_LG_MASK) #define SCOUTFS_RADIX_BITS_BYTES (SCOUTFS_RADIX_BITS / 8) @@ -247,7 +266,7 @@ struct scoutfs_btree_block { * blocks aren't full. */ #define SCOUTFS_BTREE_LEAF_ITEM_HASH_NR \ - ((SCOUTFS_BLOCK_SIZE - sizeof(struct scoutfs_btree_block)) / \ + ((SCOUTFS_BLOCK_LG_SIZE - sizeof(struct scoutfs_btree_block)) / \ (sizeof(struct scoutfs_btree_item) + (sizeof(__le16))) * 100 / 75) #define SCOUTFS_BTREE_LEAF_ITEM_HASH_BYTES \ (SCOUTFS_BTREE_LEAF_ITEM_HASH_NR * sizeof(__le16)) @@ -313,9 +332,9 @@ struct scoutfs_bloom_block { */ #define SCOUTFS_FOREST_BLOOM_NRS 7 #define SCOUTFS_FOREST_BLOOM_BITS \ - (((SCOUTFS_BLOCK_SIZE - sizeof(struct scoutfs_bloom_block)) / \ - member_sizeof(struct scoutfs_bloom_block, bits[0])) * \ - member_sizeof(struct scoutfs_bloom_block, bits[0]) * 8) \ + (((SCOUTFS_BLOCK_LG_SIZE - sizeof(struct scoutfs_bloom_block)) / \ + member_sizeof(struct scoutfs_bloom_block, bits[0])) * \ + member_sizeof(struct scoutfs_bloom_block, bits[0]) * 8) \ /* * Keys are first sorted by major key zones. @@ -380,10 +399,10 @@ struct scoutfs_packed_extent { __u8 le_blkno_diff[0]; } __packed; -#define SCOUTFS_PACKEXT_BLOCKS (8 * 1024 * 1024 / SCOUTFS_BLOCK_SIZE) -#define SCOUTFS_PACKEXT_BASE_SHIFT (ilog2(SCOUTFS_PACKEXT_BLOCKS)) -#define SCOUTFS_PACKEXT_BASE_MASK (~((__u64)SCOUTFS_PACKEXT_BLOCKS - 1)) -#define SCOUTFS_PACKEXT_MAX_BYTES SCOUTFS_MAX_VAL_SIZE +#define SCOUTFS_PACKEXT_BLOCKS (8 * 1024 * 1024 / SCOUTFS_BLOCK_SM_SIZE) +#define SCOUTFS_PACKEXT_BASE_SHIFT (ilog2(SCOUTFS_PACKEXT_BLOCKS)) +#define SCOUTFS_PACKEXT_BASE_MASK (~((__u64)SCOUTFS_PACKEXT_BLOCKS - 1)) +#define SCOUTFS_PACKEXT_MAX_BYTES SCOUTFS_MAX_VAL_SIZE #define SEF_OFFLINE (1 << 0) #define SEF_UNWRITTEN (1 << 1) @@ -445,8 +464,8 @@ struct scoutfs_quorum_block { } __packed log[0]; } __packed; -#define SCOUTFS_QUORUM_LOG_MAX \ - ((SCOUTFS_BLOCK_SIZE - sizeof(struct scoutfs_quorum_block)) / \ +#define SCOUTFS_QUORUM_LOG_MAX \ + ((SCOUTFS_BLOCK_SM_SIZE - sizeof(struct scoutfs_quorum_block)) / \ sizeof(struct scoutfs_quorum_log)) struct scoutfs_super_block { diff --git a/kmod/src/inode.c b/kmod/src/inode.c index 32ed084e..124d9375 100644 --- a/kmod/src/inode.c +++ b/kmod/src/inode.c @@ -244,7 +244,7 @@ static void load_inode(struct inode *inode, struct scoutfs_inode *cinode) * maintained as blocks come and go. */ inode->i_blocks = (ci->online_blocks + ci->offline_blocks) - << SCOUTFS_BLOCK_SECTOR_SHIFT; + << SCOUTFS_BLOCK_SM_SECTOR_SHIFT; set_item_info(ci, cinode); } @@ -390,7 +390,8 @@ int scoutfs_complete_truncate(struct inode *inode, struct scoutfs_lock *lock) if (!(ci->flags & SCOUTFS_INO_FLAG_TRUNCATE)) return 0; - start = (i_size_read(inode) + SCOUTFS_BLOCK_SIZE - 1) >> SCOUTFS_BLOCK_SHIFT; + start = (i_size_read(inode) + SCOUTFS_BLOCK_SM_SIZE - 1) >> + SCOUTFS_BLOCK_SM_SHIFT; ret = scoutfs_data_truncate_items(inode->i_sb, inode, scoutfs_ino(inode), start, ~0ULL, false, lock); @@ -573,7 +574,7 @@ void scoutfs_inode_add_onoff(struct inode *inode, s64 on, s64 off) si->online_blocks += on; si->offline_blocks += off; /* XXX not sure if this is right */ - inode->i_blocks += (on + off) * SCOUTFS_BLOCK_SECTORS; + inode->i_blocks += (on + off) * SCOUTFS_BLOCK_SM_SECTORS; trace_scoutfs_online_offline_blocks(inode, on, off, si->online_blocks, diff --git a/kmod/src/ioctl.c b/kmod/src/ioctl.c index a321a1db..c0dac183 100644 --- a/kmod/src/ioctl.c +++ b/kmod/src/ioctl.c @@ -318,8 +318,8 @@ static long scoutfs_ioc_release(struct file *file, unsigned long arg) inode_dio_wait(inode); /* drop all clean and dirty cached blocks in the range */ - start = args.block << SCOUTFS_BLOCK_SHIFT; - end_inc = ((args.block + args.count) << SCOUTFS_BLOCK_SHIFT) - 1; + start = args.block << SCOUTFS_BLOCK_SM_SHIFT; + end_inc = ((args.block + args.count) << SCOUTFS_BLOCK_SM_SHIFT) - 1; truncate_inode_pages_range(&inode->i_data, start, end_inc); ret = scoutfs_data_truncate_items(sb, inode, scoutfs_ino(inode), @@ -330,8 +330,8 @@ static long scoutfs_ioc_release(struct file *file, unsigned long arg) scoutfs_inode_get_onoff(inode, &online, &offline); isize = i_size_read(inode); if (online == 0 && isize) { - start = (isize + SCOUTFS_BLOCK_SIZE - 1) - >> SCOUTFS_BLOCK_SHIFT; + start = (isize + SCOUTFS_BLOCK_SM_SIZE - 1) + >> SCOUTFS_BLOCK_SM_SHIFT; ret = scoutfs_data_truncate_items(sb, inode, scoutfs_ino(inode), start, U64_MAX, @@ -371,8 +371,8 @@ static long scoutfs_ioc_data_wait_err(struct file *file, unsigned long arg) trace_scoutfs_ioc_data_wait_err(sb, &args); - sblock = args.offset >> SCOUTFS_BLOCK_SHIFT; - eblock = (args.offset + args.count - 1) >> SCOUTFS_BLOCK_SHIFT; + sblock = args.offset >> SCOUTFS_BLOCK_SM_SHIFT; + eblock = (args.offset + args.count - 1) >> SCOUTFS_BLOCK_SM_SHIFT; if (sblock > eblock) return -EINVAL; @@ -460,7 +460,7 @@ static long scoutfs_ioc_stage(struct file *file, unsigned long arg) /* verify arg constraints that aren't dependent on file */ if (args.count < 0 || (end_size < args.offset) || - args.offset & SCOUTFS_BLOCK_MASK) + args.offset & SCOUTFS_BLOCK_SM_MASK) return -EINVAL; if (args.count == 0) @@ -494,7 +494,7 @@ static long scoutfs_ioc_stage(struct file *file, unsigned long arg) (file->f_flags & (O_APPEND | O_DIRECT | O_DSYNC)) || IS_SYNC(file->f_mapping->host) || (end_size > isize) || - ((end_size & SCOUTFS_BLOCK_MASK) && (end_size != isize))) { + ((end_size & SCOUTFS_BLOCK_SM_MASK) && (end_size != isize))) { ret = -EINVAL; goto out; } diff --git a/kmod/src/quorum.c b/kmod/src/quorum.c index a3e7e6d2..e1960fed 100644 --- a/kmod/src/quorum.c +++ b/kmod/src/quorum.c @@ -144,7 +144,7 @@ struct quorum_block_head { struct list_head head; union { struct scoutfs_quorum_block blk; - u8 bytes[SCOUTFS_BLOCK_SIZE]; + u8 bytes[SCOUTFS_BLOCK_SM_SIZE]; }; }; @@ -184,13 +184,13 @@ static size_t quorum_block_bytes(struct scoutfs_quorum_block *blk) static bool invalid_quorum_block(struct buffer_head *bh, struct scoutfs_quorum_block *blk) { - return bh->b_size != SCOUTFS_BLOCK_SIZE || - sizeof(struct scoutfs_quorum_block) > SCOUTFS_BLOCK_SIZE || + return bh->b_size != SCOUTFS_BLOCK_SM_SIZE || + sizeof(struct scoutfs_quorum_block) > SCOUTFS_BLOCK_SM_SIZE || quorum_block_crc(blk) != blk->crc || le64_to_cpu(blk->blkno) != bh->b_blocknr || blk->term == 0 || blk->log_nr > SCOUTFS_QUORUM_LOG_MAX || - quorum_block_bytes(blk) > SCOUTFS_BLOCK_SIZE; + quorum_block_bytes(blk) > SCOUTFS_BLOCK_SM_SIZE; } /* true if a is stale and should be ignored */ @@ -296,7 +296,8 @@ static int write_quorum_block(struct super_block *sb, size_t size; int ret; - BUILD_BUG_ON(sizeof(struct scoutfs_quorum_block) > SCOUTFS_BLOCK_SIZE); + BUILD_BUG_ON(sizeof(struct scoutfs_quorum_block) > + SCOUTFS_BLOCK_SM_SIZE); bh = sb_getblk(sb, SCOUTFS_QUORUM_BLKNO + prandom_u32_max(SCOUTFS_QUORUM_BLOCKS)); @@ -306,8 +307,7 @@ static int write_quorum_block(struct super_block *sb, } size = quorum_block_bytes(our_blk); - if (WARN_ON_ONCE(size > SCOUTFS_BLOCK_SIZE || - size > bh->b_size)) { + if (WARN_ON_ONCE(size > SCOUTFS_BLOCK_SM_SIZE || size > bh->b_size)) { ret = -EIO; goto out; } @@ -530,7 +530,7 @@ int scoutfs_quorum_election(struct super_block *sb, ktime_t timeout_abs, trace_scoutfs_quorum_election(sb, prev_term); super = kmalloc(sizeof(struct scoutfs_super_block), GFP_NOFS); - our_blk = kmalloc(SCOUTFS_BLOCK_SIZE, GFP_NOFS); + our_blk = kmalloc(SCOUTFS_BLOCK_SM_SIZE, GFP_NOFS); if (!super || !our_blk) { ret = -ENOMEM; goto out; @@ -548,7 +548,7 @@ int scoutfs_quorum_election(struct super_block *sb, ktime_t timeout_abs, SCOUTFS_QUORUM_TERM_HI_MS); for (;;) { - memset(our_blk, 0, SCOUTFS_BLOCK_SIZE); + memset(our_blk, 0, SCOUTFS_BLOCK_SM_SIZE); scoutfs_inc_counter(sb, quorum_cycle); diff --git a/kmod/src/radix.c b/kmod/src/radix.c index e8e39b42..f7b61483 100644 --- a/kmod/src/radix.c +++ b/kmod/src/radix.c @@ -83,7 +83,7 @@ * stubbed out refs that reference entirely empty or full subtrees. * They're moved to properly allocated blknos. */ -#define RADIX_SYNTH_BLKNO (SCOUTFS_BLOCK_MAX + 1) +#define RADIX_SYNTH_BLKNO (SCOUTFS_BLOCK_LG_MAX + 1) struct radix_path { struct rb_node node; @@ -763,7 +763,7 @@ static void init_block(struct super_block *sb, struct scoutfs_radix_block *rdx, else memset(rdx->bits, 0, SCOUTFS_RADIX_BITS_BYTES); - tail = SCOUTFS_BLOCK_SIZE - + tail = SCOUTFS_BLOCK_LG_SIZE - offsetof(struct scoutfs_radix_block, bits) - SCOUTFS_RADIX_BITS_BYTES; } else { @@ -772,14 +772,14 @@ static void init_block(struct super_block *sb, struct scoutfs_radix_block *rdx, for (i = 0; i < SCOUTFS_RADIX_REFS; i++) memcpy(&rdx->refs[i], &ref, sizeof(ref)); - tail = SCOUTFS_BLOCK_SIZE - + tail = SCOUTFS_BLOCK_LG_SIZE - offsetof(struct scoutfs_radix_block, refs[SCOUTFS_RADIX_REFS]); } /* make sure we don't write uninitialized tail kernel memory to disk */ if (tail) - memset((void *)rdx + SCOUTFS_BLOCK_SIZE - tail, 0, tail); + memset((void *)rdx + SCOUTFS_BLOCK_LG_SIZE - tail, 0, tail); } /* get path flags */ @@ -1529,10 +1529,10 @@ void scoutfs_radix_root_init(struct super_block *sb, init_ref(&root->ref, 0, false); } -u64 scoutfs_radix_root_free_bytes(struct super_block *sb, - struct scoutfs_radix_root *root) +u64 scoutfs_radix_root_free_blocks(struct super_block *sb, + struct scoutfs_radix_root *root) { - return le64_to_cpu(root->ref.sm_total) << SCOUTFS_BLOCK_SHIFT; + return le64_to_cpu(root->ref.sm_total); } /* diff --git a/kmod/src/radix.h b/kmod/src/radix.h index 0ca79431..729e810b 100644 --- a/kmod/src/radix.h +++ b/kmod/src/radix.h @@ -38,8 +38,8 @@ void scoutfs_radix_init_alloc(struct scoutfs_radix_allocator *alloc, struct scoutfs_radix_root *freed); void scoutfs_radix_root_init(struct super_block *sb, struct scoutfs_radix_root *root, bool meta); -u64 scoutfs_radix_root_free_bytes(struct super_block *sb, - struct scoutfs_radix_root *root); +u64 scoutfs_radix_root_free_blocks(struct super_block *sb, + struct scoutfs_radix_root *root); u64 scoutfs_radix_bit_leaf_nr(u64 bit); #endif diff --git a/kmod/src/server.c b/kmod/src/server.c index f6db3179..b4097c65 100644 --- a/kmod/src/server.c +++ b/kmod/src/server.c @@ -400,7 +400,7 @@ static int server_get_log_trees(struct super_block *sb, goto unlock; /* ensure client has enough free metadata blocks for a transaction */ - target = (64*1024*1024) / SCOUTFS_BLOCK_SIZE; + target = (64*1024*1024) / SCOUTFS_BLOCK_LG_SIZE; if (le64_to_cpu(ltv.meta_avail.ref.sm_total) < target) { count = target - le64_to_cpu(ltv.meta_avail.ref.sm_total); @@ -413,7 +413,7 @@ static int server_get_log_trees(struct super_block *sb, } /* ensure client has enough free data blocks for a transaction */ - target = SCOUTFS_TRANS_DATA_ALLOC_HWM / SCOUTFS_BLOCK_SIZE; + target = SCOUTFS_TRANS_DATA_ALLOC_HWM / SCOUTFS_BLOCK_SM_SIZE; if (le64_to_cpu(ltv.data_avail.ref.sm_total) < target) { count = target - le64_to_cpu(ltv.data_avail.ref.sm_total); diff --git a/kmod/src/super.c b/kmod/src/super.c index 30cabd73..dc3ff01b 100644 --- a/kmod/src/super.c +++ b/kmod/src/super.c @@ -103,7 +103,7 @@ static int scoutfs_statfs(struct dentry *dentry, struct kstatfs *kst) kst->f_bfree = le64_to_cpu(nstatfs.bfree); kst->f_type = SCOUTFS_SUPER_MAGIC; - kst->f_bsize = SCOUTFS_BLOCK_SIZE; + kst->f_bsize = SCOUTFS_BLOCK_SM_SIZE; kst->f_blocks = le64_to_cpu(nstatfs.total_blocks); kst->f_bavail = kst->f_bfree; @@ -115,7 +115,7 @@ static int scoutfs_statfs(struct dentry *dentry, struct kstatfs *kst) kst->f_fsid.val[0] = le32_to_cpu(uuid[0]) ^ le32_to_cpu(uuid[1]); kst->f_fsid.val[1] = le32_to_cpu(uuid[2]) ^ le32_to_cpu(uuid[3]); kst->f_namelen = SCOUTFS_NAME_LEN; - kst->f_frsize = SCOUTFS_BLOCK_SIZE; + kst->f_frsize = SCOUTFS_BLOCK_SM_SIZE; /* the vfs fills f_flags */ /* @@ -379,8 +379,8 @@ static int scoutfs_fill_super(struct super_block *sb, void *data, int silent) sbi->opts = opts; - ret = sb_set_blocksize(sb, SCOUTFS_BLOCK_SIZE); - if (ret != SCOUTFS_BLOCK_SIZE) { + ret = sb_set_blocksize(sb, SCOUTFS_BLOCK_SM_SIZE); + if (ret != SCOUTFS_BLOCK_SM_SIZE) { scoutfs_err(sb, "failed to set blocksize, returned %d", ret); ret = -EIO; goto out;