Update for bcache superblock changes

Also, drop make-bcache - it's superceded by bcacheadm

Change-Id: I88ee25a1c13f2cbb0b0efa6e01bdca3f069bab62

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"