alex/bcachefs-tools
1
0
Fork 0
mirror of https://github.com/koverstreet/bcachefs-tools.git synced 2025-02-22 00:00:03 +03:00
Code Issues Actions 2 Packages Projects Releases Wiki Activity

Update for bcache superblock changes

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

Change-Id: I88ee25a1c13f2cbb0b0efa6e01bdca3f069bab62
This commit is contained in:
Kent Overstreet 2015-01-21 23:11:47 -08:00
parent 7243fbd22d
commit 3301c8dd52
7 changed files with 82 additions and 71 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored
View File

@ -1,5 +1,6 @@
bcache-super-show
make-bcache
bcacheadm
probe-bcache
bcachectl
.*

4
bcache-super-show.c
View File

@ -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) {

117
bcache.c
View File

@ -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);
@ -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];
}
}
m->nbuckets = getblocks(fds[i]) / m->bucket_size;
m->first_bucket = (23 / m->bucket_size) + 1;
if (m->nbuckets < 1 << 7) {
fprintf(stderr, "Not enough buckets: %llu, need %u\n",
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->uuid = m->uuid;
sb->nbuckets = getblocks(fds[i]) / sb->bucket_size;
sb->disk_uuid = m->uuid;
sb->nr_this_dev = i;
sb->first_bucket = (23 / sb->bucket_size) + 1;
if (sb->nbuckets < 1 << 7) {
fprintf(stderr, "Not enough buckets: %llu, need %u\n",
sb->nbuckets, 1 << 7);
exit(EXIT_FAILURE);
}
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,7 +823,33 @@ 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;
}
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,
m->bucket_size);
// total_sectors includes the superblock;
printf("dev.cache.first_sector\t%u\n"
"dev.cache.cache_sectors\t%llu\n"
"dev.cache.total_sectors\t%llu\n"
"dev.cache.ordered\t%s\n"
"dev.cache.pos\t\t%u\n"
"dev.cache.setsize\t\t%u\n",
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);
printf("cache.state\t%s\n", cache_state[CACHE_STATE(m)]);
@ -835,32 +866,6 @@ static void show_cache_member(struct cache_sb *sb, unsigned i)
printf("cache.discard\t%llu\n", CACHE_DISCARD(m));
}
void show_super_cache(struct cache_sb *sb, bool force_csum)
{
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);
// total_sectors includes the superblock;
printf("dev.cache.first_sector\t%u\n"
"dev.cache.cache_sectors\t%llu\n"
"dev.cache.total_sectors\t%llu\n"
"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,
CACHE_SYNC(sb) ? "yes" : "no",
sb->nr_this_dev,
sb->nr_in_set);
show_cache_member(sb, sb->nr_this_dev);
}
static int __sysfs_attr_type(char *attr, const char **attr_arr) {
int i, j;
for(i = 0; attr_arr[i] != NULL; i++)
@ -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"

6
bcache.h
View File

@ -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);

12
bcacheadm.c
View File

@ -297,13 +297,15 @@ 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)
@ -340,7 +342,8 @@ 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++)
next_cache_device(cache_set_sb,
@ -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";

1
make-bcache.c
View File

@ -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;

2
probe-bcache.c
View File

@ -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"