From 3301c8dd529714c135da5c36da6d43981aa788e3 Mon Sep 17 00:00:00 2001 From: Kent Overstreet Date: Wed, 21 Jan 2015 23:11:47 -0800 Subject: Update for bcache superblock changes Also, drop make-bcache - it's superceded by bcacheadm Change-Id: I88ee25a1c13f2cbb0b0efa6e01bdca3f069bab62 --- .gitignore | 1 + bcache-super-show.c | 4 +- bcache.c | 103 +++++++++++++++++++++++++++------------------------- bcache.h | 6 +-- bcacheadm.c | 18 +++++---- make-bcache.c | 1 + probe-bcache.c | 2 +- 7 files changed, 73 insertions(+), 62 deletions(-) diff --git a/.gitignore b/.gitignore index 5ef727d..74da3a4 100644 --- a/.gitignore +++ b/.gitignore @@ -1,5 +1,6 @@ bcache-super-show make-bcache +bcacheadm probe-bcache bcachectl .* diff --git a/bcache-super-show.c b/bcache-super-show.c index f645af6..61c28aa 100644 --- a/bcache-super-show.c +++ b/bcache-super-show.c @@ -70,8 +70,8 @@ int main(int argc, char **argv) exit(2); } - if (sb->keys) { - bytes = sizeof(*sb) + sb->keys * sizeof(uint64_t); + if (sb->u64s) { + bytes = sizeof(*sb) + sb->u64s * sizeof(uint64_t); sb = malloc(bytes); if (pread(fd, sb, bytes, SB_START) != bytes) { diff --git a/bcache.c b/bcache.c index 55ec08f..ee4b0f7 100644 --- a/bcache.c +++ b/bcache.c @@ -452,9 +452,8 @@ static void do_write_sb(int fd, struct cache_sb *sb) } void write_backingdev_sb(int fd, unsigned block_size, unsigned *bucket_sizes, - unsigned mode, uint64_t data_offset, - const char *label, - uuid_le set_uuid) + unsigned mode, uint64_t data_offset, const char *label, + uuid_le user_uuid, uuid_le set_uuid) { char uuid_str[40], set_uuid_str[40]; struct cache_sb sb; @@ -464,12 +463,12 @@ void write_backingdev_sb(int fd, unsigned block_size, unsigned *bucket_sizes, sb.offset = SB_SECTOR; sb.version = BCACHE_SB_VERSION_BDEV; sb.magic = BCACHE_MAGIC; - uuid_generate(sb.uuid.b); + uuid_generate(sb.disk_uuid.b); + sb.user_uuid = user_uuid; sb.set_uuid = set_uuid; - sb.bucket_size = bucket_sizes[0]; sb.block_size = block_size; - uuid_unparse(sb.uuid.b, uuid_str); + uuid_unparse(sb.disk_uuid.b, uuid_str); uuid_unparse(sb.set_uuid.b, set_uuid_str); if (label) memcpy(sb.label, label, SB_LABEL_SIZE); @@ -478,7 +477,7 @@ void write_backingdev_sb(int fd, unsigned block_size, unsigned *bucket_sizes, if (data_offset != BDEV_DATA_START_DEFAULT) { sb.version = BCACHE_SB_VERSION_BDEV_WITH_OFFSET; - sb.data_offset = data_offset; + sb.bdev_data_offset = data_offset; } sb.csum = csum_set(&sb, BCH_CSUM_CRC64); @@ -558,8 +557,8 @@ static unsigned min_bucket_size(int num_bucket_sizes, unsigned *bucket_sizes) } void write_cache_sbs(int *fds, struct cache_sb *sb, - unsigned block_size, unsigned *bucket_sizes, - int num_bucket_sizes) + unsigned block_size, unsigned *bucket_sizes, + int num_bucket_sizes) { char uuid_str[40], set_uuid_str[40]; size_t i; @@ -569,7 +568,7 @@ void write_cache_sbs(int *fds, struct cache_sb *sb, sb->version = BCACHE_SB_VERSION_CDEV_V3; sb->magic = BCACHE_MAGIC; sb->block_size = block_size; - sb->keys = bch_journal_buckets_offset(sb); + sb->u64s = bch_journal_buckets_offset(sb); /* * don't have a userspace crc32c implementation handy, just always use @@ -581,34 +580,40 @@ void write_cache_sbs(int *fds, struct cache_sb *sb, struct cache_member *m = sb->members + i; if (num_bucket_sizes <= 1) { - sb->bucket_size = bucket_sizes[0]; + m->bucket_size = bucket_sizes[0]; } else { if (!bucket_sizes[i]) { printf("No bucket size specified for cache %d," " using the default of %d", i, bucket_sizes[0]); - sb->bucket_size = bucket_sizes[0]; + m->bucket_size = bucket_sizes[0]; } else { - sb->bucket_size = bucket_sizes[i]; + m->bucket_size = bucket_sizes[i]; } } - SET_CACHE_BTREE_NODE_SIZE(sb, min_size); - - sb->uuid = m->uuid; - sb->nbuckets = getblocks(fds[i]) / sb->bucket_size; - sb->nr_this_dev = i; - sb->first_bucket = (23 / sb->bucket_size) + 1; + m->nbuckets = getblocks(fds[i]) / m->bucket_size; + m->first_bucket = (23 / m->bucket_size) + 1; - if (sb->nbuckets < 1 << 7) { + if (m->nbuckets < 1 << 7) { fprintf(stderr, "Not enough buckets: %llu, need %u\n", - sb->nbuckets, 1 << 7); + m->nbuckets, 1 << 7); exit(EXIT_FAILURE); } + } + + for (i = 0; i < sb->nr_in_set; i++) { + struct cache_member *m = sb->members + i; + + SET_CACHE_BTREE_NODE_SIZE(sb, min_size); + + + sb->disk_uuid = m->uuid; + sb->nr_this_dev = i; sb->csum = csum_set(sb, CACHE_SB_CSUM_TYPE(sb)); - uuid_unparse(sb->uuid.b, uuid_str); + uuid_unparse(sb->disk_uuid.b, uuid_str); uuid_unparse(sb->set_uuid.b, set_uuid_str); printf("UUID: %s\n" "Set UUID: %s\n" @@ -621,12 +626,12 @@ void write_cache_sbs(int *fds, struct cache_sb *sb, "first_bucket: %u\n", uuid_str, set_uuid_str, (unsigned) sb->version, - sb->nbuckets, + m->nbuckets, sb->block_size, - sb->bucket_size, + m->bucket_size, sb->nr_in_set, sb->nr_this_dev, - sb->first_bucket); + m->first_bucket); do_write_sb(fds[i], sb); } @@ -716,7 +721,7 @@ static void print_encode(char *in) } static void show_uuid_only(struct cache_sb *sb, char *dev_uuid) { - uuid_unparse(sb->uuid.b, dev_uuid); + uuid_unparse(sb->disk_uuid.b, dev_uuid); } static void show_super_common(struct cache_sb *sb, bool force_csum) @@ -789,7 +794,7 @@ static void show_super_common(struct cache_sb *sb, bool force_csum) printf("(empty)"); putchar('\n'); - uuid_unparse(sb->uuid.b, uuid); + uuid_unparse(sb->disk_uuid.b, uuid); printf("dev.uuid\t\t%s\n", uuid); uuid_unparse(sb->set_uuid.b, uuid); @@ -805,7 +810,7 @@ void show_super_backingdev(struct cache_sb *sb, bool force_csum) if (sb->version == BCACHE_SB_VERSION_BDEV) { first_sector = BDEV_DATA_START_DEFAULT; } else { - first_sector = sb->data_offset; + first_sector = sb->bdev_data_offset; } printf("dev.data.first_sector\t%ju\n" @@ -818,31 +823,19 @@ void show_super_backingdev(struct cache_sb *sb, bool force_csum) static void show_cache_member(struct cache_sb *sb, unsigned i) { - struct cache_member *m = sb->members + i; - - printf("cache.state\t%s\n", cache_state[CACHE_STATE(m)]); - - printf("cache.tier\t%llu\n", CACHE_TIER(m)); - - printf("cache.replication_set\t%llu\n", CACHE_REPLICATION_SET(m)); - printf("cache.cur_meta_replicas\t%llu\n", REPLICATION_SET_CUR_META_REPLICAS(m)); - printf("cache.cur_data_replicas\t%llu\n", REPLICATION_SET_CUR_DATA_REPLICAS(m)); - printf("cache.has_metadata\t%llu\n", CACHE_HAS_METADATA(m)); - printf("cache.has_data\t%llu\n", CACHE_HAS_DATA(m)); - - printf("cache.replacement\t%s\n", replacement_policies[CACHE_REPLACEMENT(m)]); - printf("cache.discard\t%llu\n", CACHE_DISCARD(m)); } void show_super_cache(struct cache_sb *sb, bool force_csum) { + struct cache_member *m = sb->members + sb->nr_this_dev; + show_super_common(sb, force_csum); printf("dev.sectors_per_block\t%u\n" "dev.sectors_per_bucket\t%u\n", sb->block_size, - sb->bucket_size); + m->bucket_size); // total_sectors includes the superblock; printf("dev.cache.first_sector\t%u\n" @@ -851,14 +844,26 @@ void show_super_cache(struct cache_sb *sb, bool force_csum) "dev.cache.ordered\t%s\n" "dev.cache.pos\t\t%u\n" "dev.cache.setsize\t\t%u\n", - sb->bucket_size * sb->first_bucket, - sb->bucket_size * (sb->nbuckets - sb->first_bucket), - sb->bucket_size * sb->nbuckets, + m->bucket_size * m->first_bucket, + m->bucket_size * (m->nbuckets - m->first_bucket), + m->bucket_size * m->nbuckets, CACHE_SYNC(sb) ? "yes" : "no", sb->nr_this_dev, sb->nr_in_set); - show_cache_member(sb, sb->nr_this_dev); + printf("cache.state\t%s\n", cache_state[CACHE_STATE(m)]); + + printf("cache.tier\t%llu\n", CACHE_TIER(m)); + + printf("cache.replication_set\t%llu\n", CACHE_REPLICATION_SET(m)); + printf("cache.cur_meta_replicas\t%llu\n", REPLICATION_SET_CUR_META_REPLICAS(m)); + printf("cache.cur_data_replicas\t%llu\n", REPLICATION_SET_CUR_DATA_REPLICAS(m)); + + printf("cache.has_metadata\t%llu\n", CACHE_HAS_METADATA(m)); + printf("cache.has_data\t%llu\n", CACHE_HAS_DATA(m)); + + printf("cache.replacement\t%s\n", replacement_policies[CACHE_REPLACEMENT(m)]); + printf("cache.discard\t%llu\n", CACHE_DISCARD(m)); } static int __sysfs_attr_type(char *attr, const char **attr_arr) { @@ -915,7 +920,7 @@ struct cache_sb *query_dev(char *dev, bool force_csum, close(fd); free(sb); return NULL; - } else if (bytes > sizeof(sb) + sb->keys * sizeof(u64)) { + } else if (bytes > sizeof(sb) + sb->u64s * sizeof(u64)) { /* We read the whole superblock */ break; } @@ -1302,7 +1307,7 @@ char *probe(char *dev, int udev) goto err; } - uuid_unparse(sb.uuid.b, uuid); + uuid_unparse(sb.disk_uuid.b, uuid); if (udev) printf("ID_FS_UUID=%s\n" diff --git a/bcache.h b/bcache.h index 037e6c3..c9987d0 100644 --- a/bcache.h +++ b/bcache.h @@ -40,10 +40,10 @@ typedef __s64 s64; ((typeof(_k)) __bkey_idx(_k, (_k)->u64s)) #define __bset_bkey_last(_set) \ - __bkey_idx((_set), (_set)->keys) + __bkey_idx((_set), (_set)->u64s) #define bset_bkey_last(_set) \ - bkey_idx((_set), (_set)->keys) + bkey_idx((_set), (_set)->u64s) extern const char * const cache_state[]; extern const char * const replacement_policies[]; @@ -62,7 +62,7 @@ uint64_t getblocks(int); uint64_t hatoi(const char *); unsigned hatoi_validate(const char *, const char *); void write_backingdev_sb(int, unsigned, unsigned *, unsigned, uint64_t, - const char *, uuid_le); + const char *, uuid_le, uuid_le); int dev_open(const char *, bool); void write_cache_sbs(int *, struct cache_sb *, unsigned, unsigned *, int); void next_cache_device(struct cache_sb *, unsigned, int, unsigned, bool); diff --git a/bcacheadm.c b/bcacheadm.c index 9229363..f376245 100644 --- a/bcacheadm.c +++ b/bcacheadm.c @@ -297,16 +297,18 @@ int make_bcache(NihCommand *command, char *const *args) cache_set_sb = calloc(1, sizeof(*cache_set_sb) + sizeof(struct cache_member) * devs); + uuid_generate(cache_set_sb->set_uuid.b); + if (cache_set_uuid) { - if(uuid_parse(cache_set_uuid, cache_set_sb->set_uuid.b)) { + if(uuid_parse(cache_set_uuid, cache_set_sb->user_uuid.b)) { fprintf(stderr, "Bad uuid\n"); return -1; } } else { - uuid_generate(cache_set_sb->set_uuid.b); + uuid_generate(cache_set_sb->user_uuid.b); } - if (label) + if (label) memcpy(cache_set_sb->label, label, sizeof(cache_set_sb->label)); if (csum_type) { @@ -340,9 +342,10 @@ int make_bcache(NihCommand *command, char *const *args) exit(EXIT_FAILURE); } - if(!bucket_sizes[0]) bucket_sizes[0] = 1024; + if (!bucket_sizes[0]) + bucket_sizes[0] = 1024; - for(i = 0; i < nr_cache_devices; i++) + for (i = 0; i < nr_cache_devices; i++) next_cache_device(cache_set_sb, replication_set, tier_mapping[i], @@ -381,7 +384,7 @@ int make_bcache(NihCommand *command, char *const *args) backing_dev_fd[i] = dev_open(backing_devices[i], wipe_bcache); write_cache_sbs(cache_dev_fd, cache_set_sb, block_size, - bucket_sizes, num_bucket_sizes); + bucket_sizes, num_bucket_sizes); if (writeback) cache_mode = CACHE_MODE_WRITEBACK; @@ -395,6 +398,7 @@ int make_bcache(NihCommand *command, char *const *args) block_size, bucket_sizes, cache_mode, data_offset, backing_dev_labels[i], + cache_set_sb->user_uuid, cache_set_sb->set_uuid); @@ -583,7 +587,7 @@ int bcache_query_devs(NihCommand *command, char *const *args) char *clus_uuid = (char *)sb->label; uuid_unparse(sb->set_uuid.b, set_uuid_str); - uuid_unparse(sb->uuid.b, dev_uuid_str); + uuid_unparse(sb->disk_uuid.b, dev_uuid_str); if (!strcmp(clus_uuid, "")) clus_uuid = "None"; diff --git a/make-bcache.c b/make-bcache.c index 96b8d58..8a94461 100644 --- a/make-bcache.c +++ b/make-bcache.c @@ -252,6 +252,7 @@ int main(int argc, char **argv) : CACHE_MODE_WRITETHROUGH, data_offset, backing_dev_labels[i], + cache_set_sb->user_uuid, cache_set_sb->set_uuid); return 0; diff --git a/probe-bcache.c b/probe-bcache.c index 5decb9b..1b85c4a 100644 --- a/probe-bcache.c +++ b/probe-bcache.c @@ -72,7 +72,7 @@ int main(int argc, char **argv) if (memcmp(&sb.magic, &BCACHE_MAGIC, sizeof(sb.magic))) continue; - uuid_unparse(sb.uuid.b, uuid); + uuid_unparse(sb.disk_uuid.b, uuid); if (udev) printf("ID_FS_UUID=%s\n" -- cgit v1.2.3