NULL
};
+const char * const set_attrs[] = {
+ "btree_flush_delay",
+ "btree_scan_ratelimit",
+ "bucket_reserve_percent",
+ "cache_reserve_percent",
+ "checksum_type",
+ "congested_read_threshold_us",
+ "congested_write_threshold_us",
+ "data_replicas",
+ "errors",
+ "foreground_target_percent",
+ "gc_sector_percent",
+ "journal_delay_ms",
+ "meta_replicas",
+ "sector_reserve_percent",
+ "tiering_percent",
+ NULL
+};
+
+const char * const cache_attrs[] = {
+ "cache_replacement_policy",
+ "discard",
+ "state",
+ "tier",
+ NULL
+};
+
+const char * const internal_attrs[] = {
+ "btree_shrinker_disabled",
+ "copy_gc_enabled",
+ "foreground_write_rate",
+ "tiering_enabled",
+ "tiering_rate",
+ NULL
+};
+
char *skip_spaces(const char *str)
{
while (isspace(*str))
static void do_write_sb(int fd, struct cache_sb *sb)
{
char zeroes[SB_START] = {0};
- size_t bytes = ((void *) bset_bkey_last(sb)) - (void *) sb;
+ size_t bytes = ((void *) __bset_bkey_last(sb)) - (void *) sb;
/* Zero start of disk */
if (pwrite(fd, zeroes, SB_START, 0) != SB_START) {
}
void write_backingdev_sb(int fd, unsigned block_size, unsigned *bucket_sizes,
- bool writeback, 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;
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);
- SET_BDEV_CACHE_MODE(&sb, writeback
- ? CACHE_MODE_WRITEBACK
- : CACHE_MODE_WRITETHROUGH);
+ SET_BDEV_CACHE_MODE(&sb, mode);
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);
}
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;
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
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",
+ printf("No bucket size specified for cache %zu,"
+ " using the default of %u",
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"
"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);
}
}
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)
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);
if (sb->version == BCACHE_SB_VERSION_BDEV) {
first_sector = BDEV_DATA_START_DEFAULT;
} else {
- if (sb->keys == 1 || sb->d[0]) {
- fprintf(stderr,
- "Possible experimental format detected, bailing\n");
- exit(3);
- }
- first_sector = sb->data_offset;
+ first_sector = sb->bdev_data_offset;
}
printf("dev.data.first_sector\t%ju\n"
bdev_state[BDEV_STATE(sb)]);
}
-static void show_cache_member(struct cache_sb *sb, unsigned i)
-{
- struct cache_member *m = ((struct cache_member *) sb->d) + 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"
"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) {
- int i, j;
- for(i = 0; attr_arr[i] != NULL; i++)
+static int __sysfs_attr_type(const char *attr, const char * const *attr_arr)
+{
+ for (unsigned i = 0; attr_arr[i] != NULL; i++)
if(!strcmp(attr, attr_arr[i]))
return 1;
return 0;
}
-enum sysfs_attr sysfs_attr_type(char *attr) {
- int ret;
+enum sysfs_attr sysfs_attr_type(const char *attr)
+{
if(__sysfs_attr_type(attr, set_attrs))
return SET_ATTR;
if(__sysfs_attr_type(attr, cache_attrs))
return -1;
}
-static void __sysfs_attr_list(const char **attr_arr) {
- int i, j;
- for (i = 0; attr_arr[i] != NULL; i++)
+static void __sysfs_attr_list(const char * const *attr_arr)
+{
+ for (unsigned i = 0; attr_arr[i] != NULL; i++)
printf("%s\n", attr_arr[i]);
}
-void sysfs_attr_list() {
+void sysfs_attr_list()
+{
__sysfs_attr_list(set_attrs);
__sysfs_attr_list(cache_attrs);
__sysfs_attr_list(internal_attrs);
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;
}
return sb;
}
-static char *dev_name(const char *ugly_path) {
+char *dev_name(const char *ugly_path) {
char buf[32];
int i, end = strlen(ugly_path);
return strdup(buf);
}
-static void list_cacheset_devs(char *cset_dir, char *cset_name, bool parse_dev_name) {
- int i = 0;
+static void list_cacheset_devs(char *cset_dir, char *cset_name, bool parse_dev_name)
+{
DIR *cachedir, *dir;
struct stat cache_stat;
char entry[MAX_PATH];
}
}
-char *find_matching_uuid(char *stats_dir, char *subdir, const char *stats_dev_uuid) {
+char *find_matching_uuid(char *stats_dir, char *subdir, const char *stats_dev_uuid)
+{
/* Do a query-dev --uuid only to get the uuid
* repeat on each dev until we find a matching one
* append that cache# to subdir and return
int ret, bcachefd;
char *err = NULL;
- bcachefd = open("/dev/bcache", O_RDWR);
+ bcachefd = open("/dev/bcache_extent0", O_RDWR);
if (bcachefd < 0) {
err = "Can't open bcache device";
goto err;
}
- ret = ioctl(bcachefd, BCH_IOCTL_UNREGISTER, devs);
+ ret = ioctl(bcachefd, BCH_IOCTL_STOP);
if (ret < 0) {
char tmp[64];
snprintf(tmp, 64, "ioctl unregister error: %s\n",
return err;
}
-char *add_devices(char *const *devs, char *uuid)
+char *add_devices(char *const *devs)
{
int ret, bcachefd;
char *err = NULL;
- bcachefd = open("/dev/bcache", O_RDWR);
+ bcachefd = open("/dev/bcache_extent0", O_RDWR);
if (bcachefd < 0) {
err = "Can't open bcache device";
goto err;
struct bch_ioctl_add_disks ia;
ia.devs = devs;
- ia.uuid = uuid;
ret = ioctl(bcachefd, BCH_IOCTL_ADD_DISKS, &ia);
if (ret < 0) {
int ret, bcachefd;
char *err = NULL;
- bcachefd = open("/dev/bcache", O_RDWR);
+ bcachefd = open("/dev/bcache_extent0", O_RDWR);
if (bcachefd < 0) {
err = "Can't open bcache device";
goto err;
return err;
}
+char *device_set_failed(const char *dev_uuid) {
+ int ret, bcachefd;
+ char *err = NULL;
+ uuid_le dev;
+ struct bch_ioctl_disk_failed df;
+
+ bcachefd = open("/dev/bcache_extent0", O_RDWR);
+ if (bcachefd < 0) {
+ err = "Can't open bcache device";
+ goto err;
+ }
+
+ uuid_parse(dev_uuid, dev.b);
+ df.dev_uuid = dev;
+
+ ret = ioctl(bcachefd, BCH_IOCTL_SET_DISK_FAILED, &df);
+ if (ret < 0) {
+ char tmp[128];
+ snprintf(tmp, 128, "ioctl set disk failed error %s\n",
+ strerror(ret));
+ err = strdup(tmp);
+ }
+
+err:
+ close(bcachefd);
+ return err;
+}
+
char *probe(char *dev, int udev)
{
struct cache_sb sb;
goto err;
}
- uuid_unparse(sb.uuid.b, uuid);
+ uuid_unparse(sb.disk_uuid.b, uuid);
if (udev)
printf("ID_FS_UUID=%s\n"
}
if (S_ISREG(statbuf.st_mode)) {
- char buf[MAX_PATH];
FILE *fp = NULL;
fp = fopen(entry, "r");
}
char *bcache_get_capacity(const char *cset_dir, const char *capacity_uuid,
- bool show_devs)
+ bool show_devs)
{
char *err = NULL;
char bucket_size_path[MAX_PATH];
double total_cap = 0, total_free = 0;
int precision = 2;
- snprintf(intbuf, 4, "%d", i);
snprintf(bucket_size_path, MAX_PATH, "%s/%s/%s/%s", cset_dir,
capacity_uuid, "cache0", "bucket_size_bytes");
snprintf(nbuckets_path, MAX_PATH, "%s/%s/%s/%s", cset_dir,
snprintf(cache_path, MAX_PATH, "%s/%s/%s", cset_dir, capacity_uuid,
"cache0");
- while(true) {
+ while (true) {
char buf[MAX_PATH];
int len;
DIR *cache_dir;
dev_names[dev_count] = dev_name(buf);
}
+ snprintf(intbuf, 4, "%d", dev_count);
+
/* remove i/stat and append i++/stat */
bucket_size_path[strlen(cache_path) - strlen(intbuf)] = 0;
nbuckets_path[strlen(cache_path) - strlen(intbuf)] = 0;
dev_count++;
- snprintf(intbuf, 4, "%d", dev_count);
strcat(cache_path, intbuf);
strcat(bucket_size_path, intbuf);
strcat(nbuckets_path, intbuf);
projects / bcachefs-tools-debian / blobdiff