NULL
};
+const char * const error_actions[] = {
+ "continue",
+ "readonly",
+ "panic",
+ NULL
+};
+
const char * const bdev_cache_mode[] = {
"writethrough",
"writeback",
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))
const char *msg)
{
ssize_t v = read_string_list(opt, list);
- if (v < 0) {
- fprintf(stderr, "Bad %s %s\n", msg, opt);
- exit(EXIT_FAILURE);
-
- }
+ if (v < 0)
+ die("Bad %s %s", msg, opt);
return v;
}
case BCH_CSUM_CRC64:
return bch_crc64_update(crc, data, len);
default:
- fprintf(stderr, "Unknown checksum type %u\n", type);
- exit(EXIT_FAILURE);
+ die("Unknown checksum type %u", type);
}
}
uint64_t ret;
struct stat statbuf;
if (fstat(fd, &statbuf)) {
- perror("stat error\n");
+ perror("getblocks: stat error\n");
exit(EXIT_FAILURE);
}
ret = statbuf.st_size / 512;
if (S_ISBLK(statbuf.st_mode))
if (ioctl(fd, BLKGETSIZE, &ret)) {
- perror("ioctl error");
+ perror("ioctl error getting blksize");
exit(EXIT_FAILURE);
}
return ret;
{
uint64_t v = hatoi(s);
- if (v & (v - 1)) {
- fprintf(stderr, "%s must be a power of two\n", msg);
- exit(EXIT_FAILURE);
- }
+ if (v & (v - 1))
+ die("%s must be a power of two", msg);
v /= 512;
- if (v > USHRT_MAX) {
- fprintf(stderr, "%s too large\n", msg);
- exit(EXIT_FAILURE);
- }
+ if (v > USHRT_MAX)
+ die("%s too large\n", msg);
- if (!v) {
- fprintf(stderr, "%s too small\n", msg);
- exit(EXIT_FAILURE);
- }
+ if (!v)
+ die("%s too small\n", msg);
return v;
}
-static void do_write_sb(int fd, struct cache_sb *sb)
+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) {
- perror("write error\n");
+ perror("write error trying to zero start of disk\n");
exit(EXIT_FAILURE);
}
/* Write superblock */
if (pwrite(fd, sb, bytes, SB_START) != bytes) {
- perror("write error\n");
+ perror("write error trying to write superblock\n");
exit(EXIT_FAILURE);
}
close(fd);
}
-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)
+void write_backingdev_sb(int fd, unsigned block_size, 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.set_uuid.b, set_uuid_str);
+ uuid_unparse(sb.disk_uuid.b, uuid_str);
+ uuid_unparse(sb.user_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);
do_write_sb(fd, &sb);
}
-int dev_open(const char *dev, bool wipe_bcache)
+int dev_open(const char *dev)
{
- struct cache_sb sb;
blkid_probe pr;
int fd;
- if ((fd = open(dev, O_RDWR|O_EXCL)) == -1) {
- fprintf(stderr, "Can't open dev %s: %s\n", dev, strerror(errno));
- exit(EXIT_FAILURE);
- }
-
- if (pread(fd, &sb, sizeof(sb), SB_START) != sizeof(sb))
- exit(EXIT_FAILURE);
-
- if (!memcmp(&sb.magic, &BCACHE_MAGIC, 16) && !wipe_bcache) {
- fprintf(stderr, "Already a bcache device on %s, "
- "overwrite with --wipe-bcache\n", dev);
- exit(EXIT_FAILURE);
- }
+ if ((fd = open(dev, O_RDWR|O_EXCL)) == -1)
+ die("Can't open dev %s: %s\n", dev, strerror(errno));
if (!(pr = blkid_new_probe()))
- exit(EXIT_FAILURE);
+ die("Failed to create a new probe");
if (blkid_probe_set_device(pr, fd, 0, 0))
- exit(EXIT_FAILURE);
+ die("failed to set probe to device");
+
/* enable ptable probing; superblock probing is enabled by default */
if (blkid_probe_enable_partitions(pr, true))
- exit(EXIT_FAILURE);
- if (!blkid_do_probe(pr)) {
+ die("Failed to enable partitions on probe");
+
+ if (!blkid_do_probe(pr))
/* XXX wipefs doesn't know how to remove partition tables */
- fprintf(stderr, "Device %s already has a non-bcache superblock, "
- "remove it using wipefs and wipefs -a\n", dev);
- exit(EXIT_FAILURE);
- }
+ die("Device %s already has a non-bcache superblock, "
+ "remove it using wipefs and wipefs -a\n", dev);
return fd;
}
-static unsigned min_bucket_size(int num_bucket_sizes, unsigned *bucket_sizes)
-{
- int i;
- unsigned min = bucket_sizes[0];
-
- for (i = 0; i < num_bucket_sizes; i++)
- min = bucket_sizes[i] < min ? bucket_sizes[i] : min;
-
- return min;
-}
-
-static unsigned node_size(unsigned bucket_size) {
-
- if (bucket_size <= 256)
- return bucket_size;
- else if (bucket_size <= 512)
- return bucket_size / 2;
- else
- return bucket_size / 4;
-}
-
-void write_cache_sbs(int *fds, struct cache_sb *sb,
- unsigned block_size, unsigned *bucket_sizes,
- int num_bucket_sizes)
-{
- char uuid_str[40], set_uuid_str[40];
- size_t i;
- unsigned min_size = min_bucket_size(num_bucket_sizes, bucket_sizes);
-
- sb->offset = SB_SECTOR;
- sb->version = BCACHE_SB_VERSION_CDEV_V3;
- sb->magic = BCACHE_MAGIC;
- sb->block_size = block_size;
- sb->keys = bch_journal_buckets_offset(sb);
-
- /*
- * don't have a userspace crc32c implementation handy, just always use
- * crc64
- */
- SET_CACHE_SB_CSUM_TYPE(sb, BCH_CSUM_CRC64);
-
- for (i = 0; i < sb->nr_in_set; i++) {
- struct cache_member *m = sb->members + i;
-
- if (num_bucket_sizes <= 1)
- sb->bucket_size = bucket_sizes[0];
- else
- sb->bucket_size = bucket_sizes[i];
- SET_CACHE_BTREE_NODE_SIZE(sb, node_size(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;
-
- 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->set_uuid.b, set_uuid_str);
- printf("UUID: %s\n"
- "Set UUID: %s\n"
- "version: %u\n"
- "nbuckets: %llu\n"
- "block_size: %u\n"
- "bucket_size: %u\n"
- "nr_in_set: %u\n"
- "nr_this_dev: %u\n"
- "first_bucket: %u\n",
- uuid_str, set_uuid_str,
- (unsigned) sb->version,
- sb->nbuckets,
- sb->block_size,
- sb->bucket_size,
- sb->nr_in_set,
- sb->nr_this_dev,
- sb->first_bucket);
-
- do_write_sb(fds[i], sb);
- }
-}
-
-void next_cache_device(struct cache_sb *sb,
- unsigned replication_set,
- unsigned tier,
- unsigned replacement_policy,
- bool discard)
-{
- struct cache_member *m = sb->members + sb->nr_in_set;
-
- SET_CACHE_REPLICATION_SET(m, replication_set);
- SET_CACHE_TIER(m, tier);
- SET_CACHE_REPLACEMENT(m, replacement_policy);
- SET_CACHE_DISCARD(m, discard);
- uuid_generate(m->uuid.b);
-
- sb->nr_in_set++;
-}
-
-unsigned get_blocksize(const char *path)
+unsigned get_blocksize(const char *path, int fd)
{
struct stat statbuf;
- if (stat(path, &statbuf)) {
- fprintf(stderr, "Error statting %s: %s\n",
- path, strerror(errno));
- exit(EXIT_FAILURE);
- }
+ if (fstat(fd, &statbuf))
+ die("Error statting %s: %s", path, strerror(errno));
if (S_ISBLK(statbuf.st_mode)) {
/* check IO limits:
* we want to use logical_block_size.
*/
unsigned int logical_block_size;
- int fd = open(path, O_RDONLY);
+ if (ioctl(fd, BLKSSZGET, &logical_block_size))
+ die("ioctl(%s, BLKSSZGET) failed: %m", path);
- if (fd < 0) {
- fprintf(stderr, "open(%s) failed: %m\n", path);
- exit(EXIT_FAILURE);
- }
- if (ioctl(fd, BLKSSZGET, &logical_block_size)) {
- fprintf(stderr, "ioctl(%s, BLKSSZGET) failed: %m\n", path);
- exit(EXIT_FAILURE);
- }
- close(fd);
return logical_block_size / 512;
}
long strtoul_or_die(const char *p, size_t max, const char *msg)
{
errno = 0;
- long v = strtol(optarg, NULL, 10);
- if (errno || v < 0 || v >= max) {
- fprintf(stderr, "Invalid %s %zi\n", msg, v);
- exit(EXIT_FAILURE);
- }
+ long v = strtol(p, NULL, 10);
+ if (errno || v < 0 || v >= max)
+ die("Invalid %s %zi", msg, v);
return v;
}
printf("%%%x", *pos);
}
+static void show_uuid_only(struct cache_sb *sb, char *dev_uuid) {
+ uuid_unparse(sb->disk_uuid.b, dev_uuid);
+}
+
static void show_super_common(struct cache_sb *sb, bool force_csum)
{
char uuid[40];
printf("ok\n");
} else {
printf("bad magic\n");
- fprintf(stderr, "Invalid superblock (bad magic)\n");
- exit(2);
+ die("Invalid superblock (bad magic)");
}
printf("sb.first_sector\t\t%ju", (uint64_t) sb->offset);
printf(" [match]\n");
} else {
printf(" [expected %ds]\n", SB_SECTOR);
- fprintf(stderr, "Invalid superblock (bad sector)\n");
- exit(2);
+ die("Invalid superblock (bad sector)");
}
printf("sb.csum\t\t\t%ju", (uint64_t) sb->csum);
printf(" [match]\n");
} else {
printf(" [expected %" PRIX64 "]\n", expected_csum);
- if (!force_csum) {
- fprintf(stderr, "Corrupt superblock (bad csum)\n");
- exit(2);
- }
+ if (force_csum)
+ die("Corrupt superblock (bad csum)");
}
printf("sb.version\t\t%ju", (uint64_t) sb->version);
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);
+ uuid_unparse(sb->user_uuid.b, uuid);
printf("cset.uuid\t\t%s\n", uuid);
+
+ uuid_unparse(sb->set_uuid.b, uuid);
+ printf("internal.uuid\t%s\n", uuid);
+
}
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 {
- 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;
+ char uuid[16];
+
show_super_common(sb, force_csum);
+ uuid_unparse(m->uuid.b, uuid);
+ printf("dev.cache.uuid\t%s\n", uuid);
+
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.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(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;
}
-struct cache_sb *query_dev(char *dev, bool force_csum)
+enum sysfs_attr sysfs_attr_type(const char *attr)
{
- struct cache_sb sb_stack, *sb = &sb_stack;
- size_t bytes = sizeof(*sb);
+ if(__sysfs_attr_type(attr, set_attrs))
+ return SET_ATTR;
+ if(__sysfs_attr_type(attr, cache_attrs))
+ return CACHE_ATTR;
+ if(__sysfs_attr_type(attr, internal_attrs))
+ return INTERNAL_ATTR;
- int fd = open(dev, O_RDONLY);
+ printf("No attribute called %s, try --list to see options\n", attr);
+
+ return -1;
+}
+
+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()
+{
+ __sysfs_attr_list(set_attrs);
+ __sysfs_attr_list(cache_attrs);
+ __sysfs_attr_list(internal_attrs);
+}
+
+struct cache_sb *query_dev(char *dev, bool force_csum,
+ bool print_sb, bool uuid_only, char *dev_uuid)
+{
+ size_t bytes = 4096;
+ struct cache_sb *sb = aligned_alloc(bytes, bytes);
+
+ int fd = open(dev, O_RDONLY|O_DIRECT);
if (fd < 0) {
printf("Can't open dev %s: %s\n", dev, strerror(errno));
- exit(2);
+ return NULL;
}
- if (pread(fd, sb, bytes, SB_START) != bytes) {
- fprintf(stderr, "Couldn't read\n");
- exit(2);
+ while (true) {
+ int ret = pread(fd, sb, bytes, SB_START);
+ if (ret < 0) {
+ fprintf(stderr, "Couldn't read superblock: %s\n",
+ strerror(errno));
+ close(fd);
+ free(sb);
+ return NULL;
+ } else if (bytes > sizeof(sb) + sb->u64s * sizeof(u64)) {
+ /* We read the whole superblock */
+ break;
+ }
+
+ /*
+ * otherwise double the size of our dest
+ * and read again
+ */
+ free(sb);
+ bytes *= 2;
+ sb = aligned_alloc(4096, bytes);
}
- if (sb->keys) {
- bytes = sizeof(*sb) + sb->keys * sizeof(uint64_t);
- sb = malloc(bytes);
+ close(fd);
- if (pread(fd, sb, bytes, SB_START) != bytes) {
- fprintf(stderr, "Couldn't read\n");
- exit(2);
- }
+ if(uuid_only) {
+ show_uuid_only(sb, dev_uuid);
+ return sb;
+ }
+
+ if(print_sb) {
+ if (!SB_IS_BDEV(sb))
+ show_super_cache(sb, force_csum);
+ else
+ show_super_backingdev(sb, force_csum);
}
return sb;
}
-void print_dev_info(struct cache_sb *sb, bool force_csum)
+char *dev_name(const char *ugly_path) {
+ char buf[32];
+ int i, end = strlen(ugly_path);
+
+ //Chop off "/bcache", then look for the next '/' from the end
+ for (i = end - 8; ; i--)
+ if(ugly_path[i] == '/')
+ break;
+
+ strcpy(buf, ugly_path + i);
+ buf[end - i - 7] = 0;
+
+ // Is the dev guaranteed to be in /dev?
+ // This is needed for finding the superblock with a query-dev
+ return strdup(buf);
+}
+
+static void list_cacheset_devs(char *cset_dir, char *cset_name, bool parse_dev_name)
{
- if (!SB_IS_BDEV(sb))
- show_super_cache(sb, force_csum);
- else
- show_super_backingdev(sb, force_csum);
+ DIR *cachedir, *dir;
+ struct stat cache_stat;
+ char entry[MAX_PATH];
+ struct dirent *ent;
+ snprintf(entry, MAX_PATH, "%s/%s", cset_dir, cset_name);
+
+ if((dir = opendir(entry)) != NULL) {
+ while((ent = readdir(dir)) != NULL) {
+ char buf[MAX_PATH];
+ int len;
+ char *tmp;
+
+ /*
+ * We are looking for all cache# directories
+ * do a strlen < 9 to skip over other entries
+ * that also start with "cache"
+ */
+ if(strncmp(ent->d_name, "cache", 5) ||
+ !(strlen(ent->d_name) < 9))
+ continue;
+
+ snprintf(entry, MAX_PATH, "%s/%s/%s",
+ cset_dir,
+ cset_name,
+ ent->d_name);
+
+ if((cachedir = opendir(entry)) == NULL)
+ continue;
+
+ if(stat(entry, &cache_stat))
+ continue;
+
+ if((len = readlink(entry, buf, sizeof(buf) - 1)) !=
+ -1) {
+ buf[len] = '\0';
+ if(parse_dev_name) {
+ tmp = dev_name(buf);
+ printf("/dev%s\n", tmp);
+ free(tmp);
+ } else {
+ printf("\t%s\n", buf);
+ }
+ }
+ }
+ }
+}
+
+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 i = 0;
+ DIR *cachedir;
+ struct stat cache_stat;
+ char intbuf[4];
+ char entry[MAX_PATH];
+ char *err = NULL;
+
+ snprintf(entry, MAX_PATH, "%s%s", stats_dir, subdir);
+ snprintf(intbuf, 4, "%d", i);
+ strcat(entry, intbuf);
+
+ while(true) {
+ char buf[MAX_PATH];
+ int len;
+
+ if((cachedir = opendir(entry)) == NULL)
+ break;
+
+ if(stat(entry, &cache_stat))
+ break;
+
+ if((len = readlink(entry, buf, sizeof(buf) - 1)) != -1) {
+ char dev_uuid[40];
+ buf[len] = '\0';
+ int i, end = strlen(buf);
+ char tmp[32], devname[32];
+ struct cache_sb *sb;
+
+ /* Chop off "/bcache", then look for the
+ * next '/' from the end
+ */
+ for (i = end - 8; ; i--)
+ if(buf[i] == '/')
+ break;
+
+ strcpy(tmp, buf + i);
+ tmp[end - i - 7] = 0;
+ strcpy(devname, "/dev");
+ strcat(devname, tmp);
+
+ err = "Unable to open superblock";
+ sb = query_dev(devname, false, false, true, dev_uuid);
+ if(!sb)
+ return err;
+ else
+ free(sb);
+
+ if(!strcmp(stats_dev_uuid, dev_uuid)) {
+ strcat(subdir, intbuf);
+ return NULL;
+ }
+ }
+
+ /* remove i from end and append i++ */
+ entry[strlen(entry)-strlen(intbuf)] = 0;
+ i++;
+ snprintf(intbuf, 4, "%d", i);
+ strcat(entry, intbuf);
+ }
+
+
+ err = "dev uuid doesn't exist in cache_set";
+ return err;
}
-int list_cachesets(char *cset_dir)
+char *list_cachesets(char *cset_dir, bool list_devs)
{
struct dirent *ent;
- DIR *dir = opendir(cset_dir);
+ DIR *dir;
+ char *err = NULL;
+
+ dir = opendir(cset_dir);
if (!dir) {
- fprintf(stderr, "Failed to open dir %s\n", cset_dir);
- return 1;
+ err = "Failed to open cacheset dir";
+ goto err;
}
- printf("cachesets:\n");
while ((ent = readdir(dir)) != NULL) {
struct stat statbuf;
- char entry[100];
+ char entry[MAX_PATH];
if (!strcmp(ent->d_name, ".") || !strcmp(ent->d_name, ".."))
continue;
- strcpy(entry, cset_dir);
- strcat(entry, "/");
- strcat(entry, ent->d_name);
+ snprintf(entry, MAX_PATH, "%s/%s", cset_dir, ent->d_name);
if(stat(entry, &statbuf) == -1) {
- fprintf(stderr, "Failed to stat %s\n", entry);
- return 1;
+ err = "Failed to stat cacheset subdir";
+ goto err;
}
+
if (S_ISDIR(statbuf.st_mode)) {
- printf("\t%s\n", ent->d_name);
+ printf("%s\n", ent->d_name);
+
+ if(list_devs) {
+ list_cacheset_devs(cset_dir, ent->d_name, true);
+ }
}
}
+err:
closedir(dir);
+ return err;
+}
- return 0;
+char *register_bcache(char *const *devs)
+{
+ int ret, bcachefd;
+ char *err = NULL;
+
+ bcachefd = open("/dev/bcache", O_RDWR);
+ if (bcachefd < 0) {
+ err = "Can't open bcache device";
+ goto err;
+ }
+
+ ret = ioctl(bcachefd, BCH_IOCTL_REGISTER, devs);
+ if (ret < 0) {
+ char tmp[64];
+ snprintf(tmp, 64, "ioctl register error: %s\n",
+ strerror(ret));
+ err = strdup(tmp);
+ goto err;
+ }
+
+err:
+ if (bcachefd)
+ close(bcachefd);
+ return err;
+}
+
+char *unregister_bcache(char *const *devs)
+{
+ int ret, bcachefd;
+ char *err = NULL;
+
+ bcachefd = open("/dev/bcache_extent0", O_RDWR);
+ if (bcachefd < 0) {
+ err = "Can't open bcache device";
+ goto err;
+ }
+
+ ret = ioctl(bcachefd, BCH_IOCTL_STOP);
+ if (ret < 0) {
+ char tmp[64];
+ snprintf(tmp, 64, "ioctl unregister error: %s\n",
+ strerror(ret));
+ err = strdup(tmp);
+ goto err;
+ }
+
+err:
+ close(bcachefd);
+ return err;
}
-char *parse_array_to_list(char *const *args)
+char *add_devices(char *const *devs)
{
- int i, len = 0;
- char *space = " ";
- for(i=0; args[i] != NULL; i++) {
- len+=strlen(args[i]) + 1;
+ int ret, bcachefd;
+ char *err = NULL;
+
+ bcachefd = open("/dev/bcache_extent0", O_RDWR);
+ if (bcachefd < 0) {
+ err = "Can't open bcache device";
+ goto err;
}
- char *arg_list = (char*)malloc(sizeof(char)*len);
- strcpy(arg_list, args[0]);
- strcat(arg_list, space);
+ struct bch_ioctl_add_disks ia;
+ ia.devs = devs;
- for(i=1; args[i] != NULL; i++) {
- strcat(arg_list, args[i]);
- strcat(arg_list, space);
+ ret = ioctl(bcachefd, BCH_IOCTL_ADD_DISKS, &ia);
+ if (ret < 0) {
+ char tmp[128];
+ snprintf(tmp, 128, "ioctl add disk error: %s\n",
+ strerror(ret));
+ err = strdup(tmp);
}
- return arg_list;
+err:
+ close(bcachefd);
+ return err;
}
-int register_bcache(char *devs)
+char *remove_device(const char *dev, bool force)
{
int ret, bcachefd;
+ char *err = NULL;
- bcachefd = open("/dev/bcache", O_RDWR);
+ bcachefd = open("/dev/bcache_extent0", O_RDWR);
if (bcachefd < 0) {
- perror("Can't open bcache device");
- exit(EXIT_FAILURE);
+ err = "Can't open bcache device";
+ goto err;
}
- ret = ioctl(bcachefd, BCH_IOCTL_REGISTER, devs);
+ struct bch_ioctl_rm_disk ir;
+ ir.dev = dev;
+ ir.force = force ? 1 : 0;
+
+ ret = ioctl(bcachefd, BCH_IOCTL_RM_DISK, &ir);
if (ret < 0) {
- fprintf(stderr, "ioctl error %d", ret);
- exit(EXIT_FAILURE);
+ char tmp[128];
+ snprintf(tmp, 128, "ioctl add disk error: %s\n",
+ strerror(ret));
+ err = strdup(tmp);
}
- return 0;
+err:
+ close(bcachefd);
+ 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;
}
-int probe(char *dev, int udev)
+char *probe(char *dev, int udev)
{
struct cache_sb sb;
char uuid[40];
blkid_probe pr;
+ char *err = NULL;
int fd = open(dev, O_RDONLY);
- if (fd == -1)
- return -1;
+ if (fd == -1) {
+ err = "Got file descriptor -1 trying to open dev";
+ goto err;
+ }
+
+ if (!(pr = blkid_new_probe())) {
+ err = "Failed trying to get a blkid for new probe";
+ goto err;
+ }
+
+ if (blkid_probe_set_device(pr, fd, 0, 0)) {
+ err = "Failed blkid probe set device";
+ goto err;
+ }
- if (!(pr = blkid_new_probe()))
- return -1;
- if (blkid_probe_set_device(pr, fd, 0, 0))
- return -1;
/* probe partitions too */
- if (blkid_probe_enable_partitions(pr, true))
- return -1;
+ if (blkid_probe_enable_partitions(pr, true)) {
+ err = "Enable probe partitions";
+ goto err;
+ }
+
/* bail if anything was found
* probe-bcache isn't needed once blkid recognizes bcache */
if (!blkid_do_probe(pr)) {
- return -1;
+ err = "blkid recognizes bcache";
+ goto err;
}
- if (pread(fd, &sb, sizeof(sb), SB_START) != sizeof(sb))
- return -1;
+ if (pread(fd, &sb, sizeof(sb), SB_START) != sizeof(sb)) {
+ err = "Failed to read superblock";
+ goto err;
+ }
- if (memcmp(&sb.magic, &BCACHE_MAGIC, sizeof(sb.magic)))
- return -1;
+ if (memcmp(&sb.magic, &BCACHE_MAGIC, sizeof(sb.magic))) {
+ err = "Bcache magic incorrect";
+ goto err;
+ }
- uuid_unparse(sb.uuid.b, uuid);
+ uuid_unparse(sb.disk_uuid.b, uuid);
if (udev)
printf("ID_FS_UUID=%s\n"
printf("%s: UUID=\"\" TYPE=\"bcache\"\n", uuid);
return 0;
+
+err:
+ return err;
+}
+
+char *read_stat_dir(DIR *dir, char *stats_dir, char *stat_name, char *ret)
+{
+ struct stat statbuf;
+ char entry[MAX_PATH];
+ char *err = NULL;
+
+ snprintf(entry, MAX_PATH, "%s/%s", stats_dir, stat_name);
+ if(stat(entry, &statbuf) == -1) {
+ char tmp[MAX_PATH];
+ snprintf(tmp, MAX_PATH, "Failed to stat %s\n", entry);
+ err = strdup(tmp);
+ goto err;
+ }
+
+ if (S_ISREG(statbuf.st_mode)) {
+ FILE *fp = NULL;
+
+ fp = fopen(entry, "r");
+ if(!fp) {
+ /* If we can't open the file, this is probably because
+ * of permissions, just move to the next file */
+ return NULL;
+ }
+
+ while(fgets(ret, MAX_PATH, fp));
+ fclose(fp);
+ }
+err:
+ return err;
}
-void sb_state(struct cache_sb *sb, char *dev)
+char *bcache_get_capacity(const char *cset_dir, const char *capacity_uuid,
+ bool show_devs)
{
- struct cache_member *m = ((struct cache_member *) sb->d) +
- sb->nr_this_dev;
+ char *err = NULL;
+ char bucket_size_path[MAX_PATH];
+ char nbuckets_path[MAX_PATH];
+ char avail_buckets_path[MAX_PATH];
+ char cache_path[MAX_PATH];
+
+ double bucket_sizes[MAX_DEVS];
+ double nbuckets[MAX_DEVS];
+ double avail_buckets[MAX_DEVS];
+ char *dev_names[MAX_DEVS];
+ int dev_count = 0, i;
+ double total_cap = 0, total_free = 0;
+ int precision = 2;
+
+
+ while (true) {
+ char buf[MAX_PATH];
+ int len;
+ DIR *cache_dir;
+
+ snprintf(bucket_size_path, sizeof(bucket_size_path), "%s/%s/%s%d/%s", cset_dir,
+ capacity_uuid, "cache", dev_count, "bucket_size_bytes");
+ snprintf(nbuckets_path, sizeof(nbuckets_path), "%s/%s/%s%d/%s", cset_dir,
+ capacity_uuid, "cache", dev_count, "nbuckets");
+ snprintf(avail_buckets_path, sizeof(avail_buckets_path), "%s/%s/%s%d/%s", cset_dir,
+ capacity_uuid, "cache", dev_count, "available_buckets");
+ snprintf(cache_path, sizeof(cache_path), "%s/%s/%s%d", cset_dir, capacity_uuid,
+ "cache", dev_count);
+
+ if((cache_dir = opendir(cache_path)) == NULL)
+ break;
+
+ err = read_stat_dir(cache_dir, cache_path,
+ "bucket_size_bytes", buf);
+ if (err)
+ goto err;
+ else
+ bucket_sizes[dev_count] = atof(buf);
+
+ err = read_stat_dir(cache_dir, cache_path,
+ "nbuckets", buf);
+ if (err)
+ goto err;
+ else
+ nbuckets[dev_count] = atof(buf);
+
+ err = read_stat_dir(cache_dir, cache_path,
+ "available_buckets", buf);
+ if (err)
+ goto err;
+ else
+ avail_buckets[dev_count] = atof(buf);
+
+ if((len = readlink(cache_path, buf, sizeof(buf) - 1)) != -1) {
+ buf[len] = '\0';
+ dev_names[dev_count] = dev_name(buf);
+ }
+
+ dev_count++;
+ }
+
+ printf("%-15s%-25s%-25s\n", "Device Name", "Capacity (512 Blocks)", "Free (512 Blocks)");
+
+ if (show_devs) {
+ for (i = 0; i < dev_count; i++) {
+ printf("%s%-11s%-25.*f%-25.*f\n", "/dev", dev_names[i],
+ precision,
+ (bucket_sizes[i] * nbuckets[i]) / 512,
+ precision,
+ (bucket_sizes[i] * avail_buckets[i]) / 512);
+ }
+ }
+
+ for (i = 0; i < dev_count; i++) {
+ total_cap += (bucket_sizes[i] * nbuckets[i]) / 512;
+ total_free += (bucket_sizes[i] * avail_buckets[i]) / 512;
+
+ }
- printf("device %s\n", dev);
- printf("\tcache state\t%s\n", cache_state[CACHE_STATE(m)]);
- printf("\tcache_tier\t%llu\n", CACHE_TIER(m));
- printf("\tseq#: \t%llu\n", sb->seq);
+ printf("%-15s%-25.*f%-25.*f\n", "Total", precision, total_cap,
+ precision, total_free);
+err:
+ for (i = 0; i < dev_count; i++)
+ if (dev_names[i])
+ free(dev_names[i]);
+ return err;
}
projects / bcachefs-tools-debian / blobdiff