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

Fix option parsing so that passing --bucket_size after the device works

Browse Source 
This makes supporting -U more annoying; dropping that for the moment,
unless someone complains
This commit is contained in:
Kent Overstreet 2013-04-09 13:29:06 -07:00
parent 445032e1b6
commit 335ac31ba5
1 changed files with 103 additions and 80 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

183
make-bcache.c
View File

@ -136,7 +136,7 @@ void usage()
" -B, --bdev Format a backing device\n" " -B, --bdev Format a backing device\n"
" -b, --bucket bucket size\n" " -b, --bucket bucket size\n"
" -w, --block block size (hard sector size of SSD, often 2k)\n" " -w, --block block size (hard sector size of SSD, often 2k)\n"
" -U UUID\n" // " -U UUID\n"
" --writeback enable writeback\n" " --writeback enable writeback\n"
" --discard enable discards\n" " --discard enable discards\n"
" --cache_replacement_policy=(lru|fifo)\n" " --cache_replacement_policy=(lru|fifo)\n"
@ -151,37 +151,36 @@ const char * const cache_replacement_policies[] = {
NULL NULL
}; };
int writeback; static void write_sb(char *dev, unsigned block_size, unsigned bucket_size,
int discard; bool writeback, bool discard,
unsigned cache_replacement_policy; unsigned cache_replacement_policy,
uint64_t data_offset = BDEV_DATA_START; uint64_t data_offset,
uuid_t set_uuid, bool bdev)
struct option opts[] = {
{ "cache", 0, NULL, 'C' },
{ "bdev", 0, NULL, 'B' },
{ "bucket", 1, NULL, 'b' },
{ "block", 1, NULL, 'w' },
{ "writeback", 0, &writeback, 1 },
{ "discard", 0, &discard, 1 },
{ "cache_replacement_policy", 1, NULL, 'p' },
// { "data_offset", 1, NULL, 'o' },
{ "help", 0, NULL, 'h' },
{ NULL, 0, NULL, 0 },
};
void write_sb(char *dev, struct cache_sb *sb)
{ {
int fd; int fd;
char uuid[40], set_uuid[40]; char uuid_str[40], set_uuid_str[40];
struct cache_sb sb;
if (sb->version > BCACHE_SB_MAX_VERSION) { memset(&sb, 0, sizeof(struct cache_sb));
printf("Must specify one of -C or -B\n");
usage();
}
if (sb->bucket_size < sb->block_size) { sb.version = bdev ? CACHE_BACKING_DEV : 0;
printf("Bucket size cannot be smaller than block size\n"); sb.bucket_size = bucket_size;
exit(EXIT_FAILURE); sb.block_size = block_size;
uuid_generate(sb.uuid);
memcpy(sb.set_uuid, set_uuid, sizeof(sb.set_uuid));
if (SB_BDEV(&sb)) {
SET_BDEV_WRITEBACK(&sb, writeback);
if (data_offset != BDEV_DATA_START) {
sb.version = BCACHE_SB_BDEV_VERSION;
sb.keys = 1;
sb.d[0] = data_offset;
}
} else {
SET_CACHE_DISCARD(&sb, discard);
SET_CACHE_REPLACEMENT(&sb, cache_replacement_policy);
} }
if ((fd = open(dev, O_RDWR|O_EXCL)) == -1) { if ((fd = open(dev, O_RDWR|O_EXCL)) == -1) {
@ -189,106 +188,108 @@ void write_sb(char *dev, struct cache_sb *sb)
exit(EXIT_FAILURE); exit(EXIT_FAILURE);
} }
sb->flags = 0; sb.offset = SB_SECTOR;
memcpy(sb.magic, bcache_magic, 16);
sb.nbuckets = getblocks(fd) / sb.bucket_size;
sb.nr_in_set = 1;
sb.first_bucket = (23 / sb.bucket_size) + 1;
sb.csum = csum_set(&sb);
if (SB_BDEV(sb)) { if (sb.nbuckets < 1 << 7) {
SET_BDEV_WRITEBACK(sb, writeback);
if (data_offset != BDEV_DATA_START) {
sb->version = BCACHE_SB_BDEV_VERSION;
sb->keys = 1;
sb->d[0] = data_offset;
}
} else {
SET_CACHE_DISCARD(sb, discard);
SET_CACHE_REPLACEMENT(sb, cache_replacement_policy);
}
sb->offset = SB_SECTOR;
memcpy(sb->magic, bcache_magic, 16);
sb->nbuckets = getblocks(fd) / sb->bucket_size;
sb->nr_in_set = 1;
sb->first_bucket = (23 / sb->bucket_size) + 1;
uuid_unparse(sb->uuid, uuid);
uuid_unparse(sb->set_uuid, set_uuid);
sb->csum = csum_set(sb);
if (sb->nbuckets < 1 << 7) {
printf("Not enough buckets: %ju, need %u\n", printf("Not enough buckets: %ju, need %u\n",
sb->nbuckets, 1 << 7); sb.nbuckets, 1 << 7);
exit(EXIT_FAILURE); exit(EXIT_FAILURE);
} }
uuid_unparse(sb.uuid, uuid_str);
uuid_unparse(sb.set_uuid, set_uuid_str);
printf("UUID: %s\n" printf("UUID: %s\n"
"Set UUID: %s\n" "Set UUID: %s\n"
"version: %u\n"
"nbuckets: %ju\n" "nbuckets: %ju\n"
"block_size: %u\n" "block_size: %u\n"
"bucket_size: %u\n" "bucket_size: %u\n"
"nr_in_set: %u\n" "nr_in_set: %u\n"
"nr_this_dev: %u\n" "nr_this_dev: %u\n"
"first_bucket: %u\n", "first_bucket: %u\n",
uuid, set_uuid, uuid_str, set_uuid_str,
sb->nbuckets, (unsigned) sb.version,
sb->block_size, sb.nbuckets,
sb->bucket_size, sb.block_size,
sb->nr_in_set, sb.bucket_size,
sb->nr_this_dev, sb.nr_in_set,
sb->first_bucket); sb.nr_this_dev,
sb.first_bucket);
if (pwrite(fd, sb, sizeof(*sb), SB_SECTOR << 9) != sizeof(*sb)) { if (pwrite(fd, &sb, sizeof(sb), SB_SECTOR << 9) != sizeof(sb)) {
perror("write error\n"); perror("write error\n");
exit(EXIT_FAILURE); exit(EXIT_FAILURE);
} }
fsync(fd); fsync(fd);
close(fd); close(fd);
uuid_generate(sb->uuid);
} }
int main(int argc, char **argv) int main(int argc, char **argv)
{ {
bool written = false; int c, bdev = -1;
int c; unsigned i, ncache_devices = 0, nbacking_devices = 0;
struct cache_sb sb; char *cache_devices[argc];
char *backing_devices[argc];
memset(&sb, 0, sizeof(struct cache_sb)); unsigned block_size = 1, bucket_size = 1024;
sb.version = -1; int writeback = 0, discard = 0;
sb.block_size = 1; unsigned cache_replacement_policy = 0;
sb.bucket_size = 1024; uint64_t data_offset = BDEV_DATA_START;
uuid_t set_uuid;
uuid_generate(sb.uuid); uuid_generate(set_uuid);
uuid_generate(sb.set_uuid);
struct option opts[] = {
{ "cache", 0, NULL, 'C' },
{ "bdev", 0, NULL, 'B' },
{ "bucket", 1, NULL, 'b' },
{ "block", 1, NULL, 'w' },
{ "writeback", 0, &writeback, 1 },
{ "discard", 0, &discard, 1 },
{ "cache_replacement_policy", 1, NULL, 'p' },
{ "data_offset", 1, NULL, 'o' },
{ "help", 0, NULL, 'h' },
{ NULL, 0, NULL, 0 },
};
while ((c = getopt_long(argc, argv, while ((c = getopt_long(argc, argv,
"-hCBU:w:b:", "-hCBU:w:b:",
opts, NULL)) != -1) opts, NULL)) != -1)
switch (c) { switch (c) {
case 'C': case 'C':
sb.version = 0; bdev = 0;
break; break;
case 'B': case 'B':
sb.version = CACHE_BACKING_DEV; bdev = 1;
break; break;
case 'b': case 'b':
sb.bucket_size = hatoi_validate(optarg, "bucket size"); bucket_size = hatoi_validate(optarg, "bucket size");
break; break;
case 'w': case 'w':
sb.block_size = hatoi_validate(optarg, "block size"); block_size = hatoi_validate(optarg, "block size");
break; break;
#if 0
case 'U': case 'U':
if (uuid_parse(optarg, sb.uuid)) { if (uuid_parse(optarg, sb.uuid)) {
printf("Bad uuid\n"); printf("Bad uuid\n");
exit(EXIT_FAILURE); exit(EXIT_FAILURE);
} }
break; break;
#endif
case 'p': case 'p':
cache_replacement_policy = read_string_list(optarg, cache_replacement_policy = read_string_list(optarg,
cache_replacement_policies); cache_replacement_policies);
break; break;
case 'o': case 'o':
data_offset = atoll(optarg); data_offset = atoll(optarg);
if (sb.d[0] < BDEV_DATA_START) { if (data_offset < BDEV_DATA_START) {
printf("Bad data offset; minimum %d sectors\n", BDEV_DATA_START); printf("Bad data offset; minimum %d sectors\n", BDEV_DATA_START);
exit(EXIT_FAILURE); exit(EXIT_FAILURE);
} }
@ -297,15 +298,37 @@ int main(int argc, char **argv)
usage(); usage();
break; break;
case 1: case 1:
write_sb(optarg, &sb); if (bdev == -1) {
written = true; printf("Please specify -C or -B\n");
exit(EXIT_FAILURE);
}
if (bdev)
backing_devices[nbacking_devices++] = optarg;
else
cache_devices[ncache_devices++] = optarg;
break; break;
} }
if (!written) { if (!ncache_devices && !nbacking_devices) {
printf("Please supply a device\n"); printf("Please supply a device\n");
usage(); usage();
} }
if (bucket_size < block_size) {
printf("Bucket size cannot be smaller than block size\n");
exit(EXIT_FAILURE);
}
for (i = 0; i < ncache_devices; i++)
write_sb(cache_devices[i], block_size, bucket_size,
writeback, discard, cache_replacement_policy,
data_offset, set_uuid, false);
for (i = 0; i < nbacking_devices; i++)
write_sb(backing_devices[i], block_size, bucket_size,
writeback, discard, cache_replacement_policy,
data_offset, set_uuid, true);
return 0; return 0;
} }