static char argv0_buf[ARGV0_BUF_SIZE] = "btrfs";
+const char *get_argv0_buf(void)
+{
+ return argv0_buf;
+}
+
void fixup_argv0(char **argv, const char *token)
{
int len = strlen(argv0_buf);
return unique;
}
-int make_btrfs(int fd, const char *device, const char *label, char *fs_uuid,
- u64 blocks[7], u64 num_bytes, u32 nodesize,
- u32 leafsize, u32 sectorsize, u32 stripesize, u64 features)
+/*
+ * @fs_uuid - if NULL, generates a UUID, returns back the new filesystem UUID
+ */
+int make_btrfs(int fd, struct btrfs_mkfs_config *cfg)
{
struct btrfs_super_block super;
struct extent_buffer *buf = NULL;
u64 ref_root;
u32 array_size;
u32 item_size;
- int skinny_metadata = !!(features &
+ int skinny_metadata = !!(cfg->features &
BTRFS_FEATURE_INCOMPAT_SKINNY_METADATA);
+ u64 num_bytes;
- first_free = BTRFS_SUPER_INFO_OFFSET + sectorsize * 2 - 1;
- first_free &= ~((u64)sectorsize - 1);
+ first_free = BTRFS_SUPER_INFO_OFFSET + cfg->sectorsize * 2 - 1;
+ first_free &= ~((u64)cfg->sectorsize - 1);
memset(&super, 0, sizeof(super));
- num_bytes = (num_bytes / sectorsize) * sectorsize;
- if (fs_uuid) {
- if (uuid_parse(fs_uuid, super.fsid) != 0) {
- fprintf(stderr, "could not parse UUID: %s\n", fs_uuid);
+ num_bytes = (cfg->num_bytes / cfg->sectorsize) * cfg->sectorsize;
+ if (cfg->fs_uuid && *cfg->fs_uuid) {
+ if (uuid_parse(cfg->fs_uuid, super.fsid) != 0) {
+ fprintf(stderr, "could not parse UUID: %s\n",
+ cfg->fs_uuid);
ret = -EINVAL;
goto out;
}
- if (!test_uuid_unique(fs_uuid)) {
- fprintf(stderr, "non-unique UUID: %s\n", fs_uuid);
+ if (!test_uuid_unique(cfg->fs_uuid)) {
+ fprintf(stderr, "non-unique UUID: %s\n", cfg->fs_uuid);
ret = -EBUSY;
goto out;
}
} else {
uuid_generate(super.fsid);
+ if (cfg->fs_uuid)
+ uuid_unparse(super.fsid, cfg->fs_uuid);
}
uuid_generate(super.dev_item.uuid);
uuid_generate(chunk_tree_uuid);
- btrfs_set_super_bytenr(&super, blocks[0]);
+ btrfs_set_super_bytenr(&super, cfg->blocks[0]);
btrfs_set_super_num_devices(&super, 1);
btrfs_set_super_magic(&super, BTRFS_MAGIC);
btrfs_set_super_generation(&super, 1);
- btrfs_set_super_root(&super, blocks[1]);
- btrfs_set_super_chunk_root(&super, blocks[3]);
+ btrfs_set_super_root(&super, cfg->blocks[1]);
+ btrfs_set_super_chunk_root(&super, cfg->blocks[3]);
btrfs_set_super_total_bytes(&super, num_bytes);
- btrfs_set_super_bytes_used(&super, 6 * leafsize);
- btrfs_set_super_sectorsize(&super, sectorsize);
- btrfs_set_super_leafsize(&super, leafsize);
- btrfs_set_super_nodesize(&super, nodesize);
- btrfs_set_super_stripesize(&super, stripesize);
+ btrfs_set_super_bytes_used(&super, 6 * cfg->nodesize);
+ btrfs_set_super_sectorsize(&super, cfg->sectorsize);
+ btrfs_set_super_leafsize(&super, cfg->nodesize);
+ btrfs_set_super_nodesize(&super, cfg->nodesize);
+ btrfs_set_super_stripesize(&super, cfg->stripesize);
btrfs_set_super_csum_type(&super, BTRFS_CSUM_TYPE_CRC32);
btrfs_set_super_chunk_root_generation(&super, 1);
btrfs_set_super_cache_generation(&super, -1);
- btrfs_set_super_incompat_flags(&super, features);
- if (label)
- strncpy(super.label, label, BTRFS_LABEL_SIZE - 1);
+ btrfs_set_super_incompat_flags(&super, cfg->features);
+ if (cfg->label)
+ strncpy(super.label, cfg->label, BTRFS_LABEL_SIZE - 1);
- buf = malloc(sizeof(*buf) + max(sectorsize, leafsize));
+ buf = malloc(sizeof(*buf) + max(cfg->sectorsize, cfg->nodesize));
/* create the tree of root objects */
- memset(buf->data, 0, leafsize);
- buf->len = leafsize;
- btrfs_set_header_bytenr(buf, blocks[1]);
+ memset(buf->data, 0, cfg->nodesize);
+ buf->len = cfg->nodesize;
+ btrfs_set_header_bytenr(buf, cfg->blocks[1]);
btrfs_set_header_nritems(buf, 4);
btrfs_set_header_generation(buf, 1);
btrfs_set_header_backref_rev(buf, BTRFS_MIXED_BACKREF_REV);
btrfs_set_stack_inode_generation(inode_item, 1);
btrfs_set_stack_inode_size(inode_item, 3);
btrfs_set_stack_inode_nlink(inode_item, 1);
- btrfs_set_stack_inode_nbytes(inode_item, leafsize);
+ btrfs_set_stack_inode_nbytes(inode_item, cfg->nodesize);
btrfs_set_stack_inode_mode(inode_item, S_IFDIR | 0755);
btrfs_set_root_refs(&root_item, 1);
- btrfs_set_root_used(&root_item, leafsize);
+ btrfs_set_root_used(&root_item, cfg->nodesize);
btrfs_set_root_generation(&root_item, 1);
memset(&disk_key, 0, sizeof(disk_key));
btrfs_set_disk_key_offset(&disk_key, 0);
nritems = 0;
- itemoff = __BTRFS_LEAF_DATA_SIZE(leafsize) - sizeof(root_item);
- btrfs_set_root_bytenr(&root_item, blocks[2]);
+ itemoff = __BTRFS_LEAF_DATA_SIZE(cfg->nodesize) - sizeof(root_item);
+ btrfs_set_root_bytenr(&root_item, cfg->blocks[2]);
btrfs_set_disk_key_objectid(&disk_key, BTRFS_EXTENT_TREE_OBJECTID);
btrfs_set_item_key(buf, &disk_key, nritems);
btrfs_set_item_offset(buf, btrfs_item_nr(nritems), itemoff);
nritems++;
itemoff = itemoff - sizeof(root_item);
- btrfs_set_root_bytenr(&root_item, blocks[4]);
+ btrfs_set_root_bytenr(&root_item, cfg->blocks[4]);
btrfs_set_disk_key_objectid(&disk_key, BTRFS_DEV_TREE_OBJECTID);
btrfs_set_item_key(buf, &disk_key, nritems);
btrfs_set_item_offset(buf, btrfs_item_nr(nritems), itemoff);
nritems++;
itemoff = itemoff - sizeof(root_item);
- btrfs_set_root_bytenr(&root_item, blocks[5]);
+ btrfs_set_root_bytenr(&root_item, cfg->blocks[5]);
btrfs_set_disk_key_objectid(&disk_key, BTRFS_FS_TREE_OBJECTID);
btrfs_set_item_key(buf, &disk_key, nritems);
btrfs_set_item_offset(buf, btrfs_item_nr(nritems), itemoff);
nritems++;
itemoff = itemoff - sizeof(root_item);
- btrfs_set_root_bytenr(&root_item, blocks[6]);
+ btrfs_set_root_bytenr(&root_item, cfg->blocks[6]);
btrfs_set_disk_key_objectid(&disk_key, BTRFS_CSUM_TREE_OBJECTID);
btrfs_set_item_key(buf, &disk_key, nritems);
btrfs_set_item_offset(buf, btrfs_item_nr(nritems), itemoff);
csum_tree_block_size(buf, BTRFS_CRC32_SIZE, 0);
- ret = pwrite(fd, buf->data, leafsize, blocks[1]);
- if (ret != leafsize) {
+ ret = pwrite(fd, buf->data, cfg->nodesize, cfg->blocks[1]);
+ if (ret != cfg->nodesize) {
ret = (ret < 0 ? -errno : -EIO);
goto out;
}
/* create the items for the extent tree */
- memset(buf->data+sizeof(struct btrfs_header), 0,
- leafsize-sizeof(struct btrfs_header));
+ memset(buf->data + sizeof(struct btrfs_header), 0,
+ cfg->nodesize - sizeof(struct btrfs_header));
nritems = 0;
- itemoff = __BTRFS_LEAF_DATA_SIZE(leafsize);
+ itemoff = __BTRFS_LEAF_DATA_SIZE(cfg->nodesize);
for (i = 1; i < 7; i++) {
item_size = sizeof(struct btrfs_extent_item);
if (!skinny_metadata)
item_size += sizeof(struct btrfs_tree_block_info);
- BUG_ON(blocks[i] < first_free);
- BUG_ON(blocks[i] < blocks[i - 1]);
+ BUG_ON(cfg->blocks[i] < first_free);
+ BUG_ON(cfg->blocks[i] < cfg->blocks[i - 1]);
/* create extent item */
itemoff -= item_size;
- btrfs_set_disk_key_objectid(&disk_key, blocks[i]);
+ btrfs_set_disk_key_objectid(&disk_key, cfg->blocks[i]);
if (skinny_metadata) {
btrfs_set_disk_key_type(&disk_key,
BTRFS_METADATA_ITEM_KEY);
} else {
btrfs_set_disk_key_type(&disk_key,
BTRFS_EXTENT_ITEM_KEY);
- btrfs_set_disk_key_offset(&disk_key, leafsize);
+ btrfs_set_disk_key_offset(&disk_key, cfg->nodesize);
}
btrfs_set_item_key(buf, &disk_key, nritems);
btrfs_set_item_offset(buf, btrfs_item_nr(nritems),
/* create extent ref */
ref_root = reference_root_table[i];
- btrfs_set_disk_key_objectid(&disk_key, blocks[i]);
+ btrfs_set_disk_key_objectid(&disk_key, cfg->blocks[i]);
btrfs_set_disk_key_offset(&disk_key, ref_root);
btrfs_set_disk_key_type(&disk_key, BTRFS_TREE_BLOCK_REF_KEY);
btrfs_set_item_key(buf, &disk_key, nritems);
btrfs_set_item_size(buf, btrfs_item_nr(nritems), 0);
nritems++;
}
- btrfs_set_header_bytenr(buf, blocks[2]);
+ btrfs_set_header_bytenr(buf, cfg->blocks[2]);
btrfs_set_header_owner(buf, BTRFS_EXTENT_TREE_OBJECTID);
btrfs_set_header_nritems(buf, nritems);
csum_tree_block_size(buf, BTRFS_CRC32_SIZE, 0);
- ret = pwrite(fd, buf->data, leafsize, blocks[2]);
- if (ret != leafsize) {
+ ret = pwrite(fd, buf->data, cfg->nodesize, cfg->blocks[2]);
+ if (ret != cfg->nodesize) {
ret = (ret < 0 ? -errno : -EIO);
goto out;
}
/* create the chunk tree */
- memset(buf->data+sizeof(struct btrfs_header), 0,
- leafsize-sizeof(struct btrfs_header));
+ memset(buf->data + sizeof(struct btrfs_header), 0,
+ cfg->nodesize - sizeof(struct btrfs_header));
nritems = 0;
item_size = sizeof(*dev_item);
- itemoff = __BTRFS_LEAF_DATA_SIZE(leafsize) - item_size;
+ itemoff = __BTRFS_LEAF_DATA_SIZE(cfg->nodesize) - item_size;
/* first device 1 (there is no device 0) */
btrfs_set_disk_key_objectid(&disk_key, BTRFS_DEV_ITEMS_OBJECTID);
btrfs_set_device_total_bytes(buf, dev_item, num_bytes);
btrfs_set_device_bytes_used(buf, dev_item,
BTRFS_MKFS_SYSTEM_GROUP_SIZE);
- btrfs_set_device_io_align(buf, dev_item, sectorsize);
- btrfs_set_device_io_width(buf, dev_item, sectorsize);
- btrfs_set_device_sector_size(buf, dev_item, sectorsize);
+ btrfs_set_device_io_align(buf, dev_item, cfg->sectorsize);
+ btrfs_set_device_io_width(buf, dev_item, cfg->sectorsize);
+ btrfs_set_device_sector_size(buf, dev_item, cfg->sectorsize);
btrfs_set_device_type(buf, dev_item, 0);
write_extent_buffer(buf, super.dev_item.uuid,
btrfs_set_chunk_owner(buf, chunk, BTRFS_EXTENT_TREE_OBJECTID);
btrfs_set_chunk_stripe_len(buf, chunk, 64 * 1024);
btrfs_set_chunk_type(buf, chunk, BTRFS_BLOCK_GROUP_SYSTEM);
- btrfs_set_chunk_io_align(buf, chunk, sectorsize);
- btrfs_set_chunk_io_width(buf, chunk, sectorsize);
- btrfs_set_chunk_sector_size(buf, chunk, sectorsize);
+ btrfs_set_chunk_io_align(buf, chunk, cfg->sectorsize);
+ btrfs_set_chunk_io_width(buf, chunk, cfg->sectorsize);
+ btrfs_set_chunk_sector_size(buf, chunk, cfg->sectorsize);
btrfs_set_chunk_num_stripes(buf, chunk, 1);
btrfs_set_stripe_devid_nr(buf, chunk, 0, 1);
btrfs_set_stripe_offset_nr(buf, chunk, 0, 0);
ptr += item_size;
btrfs_set_super_sys_array_size(&super, array_size);
- btrfs_set_header_bytenr(buf, blocks[3]);
+ btrfs_set_header_bytenr(buf, cfg->blocks[3]);
btrfs_set_header_owner(buf, BTRFS_CHUNK_TREE_OBJECTID);
btrfs_set_header_nritems(buf, nritems);
csum_tree_block_size(buf, BTRFS_CRC32_SIZE, 0);
- ret = pwrite(fd, buf->data, leafsize, blocks[3]);
- if (ret != leafsize) {
+ ret = pwrite(fd, buf->data, cfg->nodesize, cfg->blocks[3]);
+ if (ret != cfg->nodesize) {
ret = (ret < 0 ? -errno : -EIO);
goto out;
}
/* create the device tree */
- memset(buf->data+sizeof(struct btrfs_header), 0,
- leafsize-sizeof(struct btrfs_header));
+ memset(buf->data + sizeof(struct btrfs_header), 0,
+ cfg->nodesize - sizeof(struct btrfs_header));
nritems = 0;
- itemoff = __BTRFS_LEAF_DATA_SIZE(leafsize) -
+ itemoff = __BTRFS_LEAF_DATA_SIZE(cfg->nodesize) -
sizeof(struct btrfs_dev_extent);
btrfs_set_disk_key_objectid(&disk_key, 1);
BTRFS_MKFS_SYSTEM_GROUP_SIZE);
nritems++;
- btrfs_set_header_bytenr(buf, blocks[4]);
+ btrfs_set_header_bytenr(buf, cfg->blocks[4]);
btrfs_set_header_owner(buf, BTRFS_DEV_TREE_OBJECTID);
btrfs_set_header_nritems(buf, nritems);
csum_tree_block_size(buf, BTRFS_CRC32_SIZE, 0);
- ret = pwrite(fd, buf->data, leafsize, blocks[4]);
- if (ret != leafsize) {
+ ret = pwrite(fd, buf->data, cfg->nodesize, cfg->blocks[4]);
+ if (ret != cfg->nodesize) {
ret = (ret < 0 ? -errno : -EIO);
goto out;
}
/* create the FS root */
- memset(buf->data+sizeof(struct btrfs_header), 0,
- leafsize-sizeof(struct btrfs_header));
- btrfs_set_header_bytenr(buf, blocks[5]);
+ memset(buf->data + sizeof(struct btrfs_header), 0,
+ cfg->nodesize - sizeof(struct btrfs_header));
+ btrfs_set_header_bytenr(buf, cfg->blocks[5]);
btrfs_set_header_owner(buf, BTRFS_FS_TREE_OBJECTID);
btrfs_set_header_nritems(buf, 0);
csum_tree_block_size(buf, BTRFS_CRC32_SIZE, 0);
- ret = pwrite(fd, buf->data, leafsize, blocks[5]);
- if (ret != leafsize) {
+ ret = pwrite(fd, buf->data, cfg->nodesize, cfg->blocks[5]);
+ if (ret != cfg->nodesize) {
ret = (ret < 0 ? -errno : -EIO);
goto out;
}
/* finally create the csum root */
- memset(buf->data+sizeof(struct btrfs_header), 0,
- leafsize-sizeof(struct btrfs_header));
- btrfs_set_header_bytenr(buf, blocks[6]);
+ memset(buf->data + sizeof(struct btrfs_header), 0,
+ cfg->nodesize - sizeof(struct btrfs_header));
+ btrfs_set_header_bytenr(buf, cfg->blocks[6]);
btrfs_set_header_owner(buf, BTRFS_CSUM_TREE_OBJECTID);
btrfs_set_header_nritems(buf, 0);
csum_tree_block_size(buf, BTRFS_CRC32_SIZE, 0);
- ret = pwrite(fd, buf->data, leafsize, blocks[6]);
- if (ret != leafsize) {
+ ret = pwrite(fd, buf->data, cfg->nodesize, cfg->blocks[6]);
+ if (ret != cfg->nodesize) {
ret = (ret < 0 ? -errno : -EIO);
goto out;
}
/* and write out the super block */
- BUG_ON(sizeof(super) > sectorsize);
- memset(buf->data, 0, sectorsize);
+ BUG_ON(sizeof(super) > cfg->sectorsize);
+ memset(buf->data, 0, cfg->sectorsize);
memcpy(buf->data, &super, sizeof(super));
- buf->len = sectorsize;
+ buf->len = cfg->sectorsize;
csum_tree_block_size(buf, BTRFS_CRC32_SIZE, 0);
- ret = pwrite(fd, buf->data, sectorsize, blocks[0]);
- if (ret != sectorsize) {
+ ret = pwrite(fd, buf->data, cfg->sectorsize, cfg->blocks[0]);
+ if (ret != cfg->sectorsize) {
ret = (ret < 0 ? -errno : -EIO);
goto out;
}
return ret;
}
+static const struct btrfs_fs_feature {
+ const char *name;
+ u64 flag;
+ const char *desc;
+} mkfs_features[] = {
+ { "mixed-bg", BTRFS_FEATURE_INCOMPAT_MIXED_GROUPS,
+ "mixed data and metadata block groups" },
+ { "extref", BTRFS_FEATURE_INCOMPAT_EXTENDED_IREF,
+ "increased hardlink limit per file to 65536" },
+ { "raid56", BTRFS_FEATURE_INCOMPAT_RAID56,
+ "raid56 extended format" },
+ { "skinny-metadata", BTRFS_FEATURE_INCOMPAT_SKINNY_METADATA,
+ "reduced-size metadata extent refs" },
+ { "no-holes", BTRFS_FEATURE_INCOMPAT_NO_HOLES,
+ "no explicit hole extents for files" },
+ /* Keep this one last */
+ { "list-all", BTRFS_FEATURE_LIST_ALL, NULL }
+};
+
+static int parse_one_fs_feature(const char *name, u64 *flags)
+{
+ int i;
+ int found = 0;
+
+ for (i = 0; i < ARRAY_SIZE(mkfs_features); i++) {
+ if (name[0] == '^' &&
+ !strcmp(mkfs_features[i].name, name + 1)) {
+ *flags &= ~ mkfs_features[i].flag;
+ found = 1;
+ } else if (!strcmp(mkfs_features[i].name, name)) {
+ *flags |= mkfs_features[i].flag;
+ found = 1;
+ }
+ }
+
+ return !found;
+}
+
+void btrfs_parse_features_to_string(char *buf, u64 flags)
+{
+ int i;
+
+ buf[0] = 0;
+
+ for (i = 0; i < ARRAY_SIZE(mkfs_features); i++) {
+ if (flags & mkfs_features[i].flag) {
+ if (*buf)
+ strcat(buf, ", ");
+ strcat(buf, mkfs_features[i].name);
+ }
+ }
+}
+
+void btrfs_process_fs_features(u64 flags)
+{
+ int i;
+
+ for (i = 0; i < ARRAY_SIZE(mkfs_features); i++) {
+ if (flags & mkfs_features[i].flag) {
+ printf("Turning ON incompat feature '%s': %s\n",
+ mkfs_features[i].name,
+ mkfs_features[i].desc);
+ }
+ }
+}
+
+void btrfs_list_all_fs_features(u64 mask_disallowed)
+{
+ int i;
+
+ fprintf(stderr, "Filesystem features available:\n");
+ for (i = 0; i < ARRAY_SIZE(mkfs_features) - 1; i++) {
+ char *is_default = "";
+
+ if (mkfs_features[i].flag & mask_disallowed)
+ continue;
+ if (mkfs_features[i].flag & BTRFS_MKFS_DEFAULT_FEATURES)
+ is_default = ", default";
+ fprintf(stderr, "%-20s- %s (0x%llx%s)\n",
+ mkfs_features[i].name,
+ mkfs_features[i].desc,
+ mkfs_features[i].flag,
+ is_default);
+ }
+}
+
+/*
+ * Return NULL if all features were parsed fine, otherwise return the name of
+ * the first unparsed.
+ */
+char* btrfs_parse_fs_features(char *namelist, u64 *flags)
+{
+ char *this_char;
+ char *save_ptr = NULL; /* Satisfy static checkers */
+
+ for (this_char = strtok_r(namelist, ",", &save_ptr);
+ this_char != NULL;
+ this_char = strtok_r(NULL, ",", &save_ptr)) {
+ if (parse_one_fs_feature(this_char, flags))
+ return this_char;
+ }
+
+ return NULL;
+}
+
u64 btrfs_device_size(int fd, struct stat *st)
{
u64 size;
device->bytes_used = 0;
device->total_ios = 0;
device->dev_root = root->fs_info->dev_root;
+ device->name = strdup(path);
ret = btrfs_add_device(trans, root, device);
BUG_ON(ret);
memcpy(disk_super, super, sizeof(*disk_super));
- printf("adding device %s id %llu\n", path,
- (unsigned long long)device->devid);
-
btrfs_set_super_bytenr(disk_super, BTRFS_SUPER_INFO_OFFSET);
btrfs_set_stack_device_id(dev_item, device->devid);
btrfs_set_stack_device_type(dev_item, device->type);
btrfs_set_stack_inode_generation(&inode_item, trans->transid);
btrfs_set_stack_inode_size(&inode_item, 0);
btrfs_set_stack_inode_nlink(&inode_item, 1);
- btrfs_set_stack_inode_nbytes(&inode_item, root->leafsize);
+ btrfs_set_stack_inode_nbytes(&inode_item, root->nodesize);
btrfs_set_stack_inode_mode(&inode_item, S_IFDIR | 0755);
btrfs_set_stack_timespec_sec(&inode_item.atime, now);
btrfs_set_stack_timespec_nsec(&inode_item.atime, 0);
*/
int open_path_or_dev_mnt(const char *path, DIR **dirstream)
{
- char mp[BTRFS_PATH_NAME_MAX + 1];
+ char mp[PATH_MAX];
int fdmnt;
if (is_block_device(path)) {
strerror(errno));
return -errno;
}
- strncpy(args.name, fname, BTRFS_PATH_NAME_MAX);
- args.name[BTRFS_PATH_NAME_MAX-1] = 0;
+ memset(&args, 0, sizeof(args));
+ strncpy_null(args.name, fname);
ret = ioctl(fd, BTRFS_IOC_SCAN_DEV, &args);
e = errno;
if (ret < 0) {
return ret;
}
+/*
+ * Note: this function uses a static per-thread buffer. Do not call this
+ * function more than 10 times within one argument list!
+ */
+const char *pretty_size_mode(u64 size, unsigned mode)
+{
+ static __thread int ps_index = 0;
+ static __thread char ps_array[10][32];
+ char *ret;
+
+ ret = ps_array[ps_index];
+ ps_index++;
+ ps_index %= 10;
+ (void)pretty_size_snprintf(size, ret, 32, mode);
+
+ return ret;
+}
+
static const char* unit_suffix_binary[] =
{ "B", "KiB", "MiB", "GiB", "TiB", "PiB", "EiB"};
static const char* unit_suffix_decimal[] =
return ret;
}
-int btrfs_scan_block_devices(int run_ioctl)
+/*
+ * Unsafe subvolume check.
+ *
+ * This only checks ino == BTRFS_FIRST_FREE_OBJECTID, even it is not in a
+ * btrfs mount point.
+ * Must use together with other reliable method like btrfs ioctl.
+ */
+static int __is_subvol(const char *path)
{
-
struct stat st;
int ret;
- int fd;
- struct btrfs_fs_devices *tmp_devices;
- u64 num_devices;
- FILE *proc_partitions;
- int i;
- char buf[1024];
- char fullpath[110];
- int scans = 0;
- int special;
-
-scan_again:
- proc_partitions = fopen("/proc/partitions","r");
- if (!proc_partitions) {
- fprintf(stderr, "Unable to open '/proc/partitions' for scanning\n");
- return -ENOENT;
- }
- /* skip the header */
- for (i = 0; i < 2; i++)
- if (!fgets(buf, 1023, proc_partitions)) {
- fprintf(stderr,
- "Unable to read '/proc/partitions' for scanning\n");
- fclose(proc_partitions);
- return -ENOENT;
- }
-
- strcpy(fullpath,"/dev/");
- while(fgets(buf, 1023, proc_partitions)) {
- ret = sscanf(buf," %*d %*d %*d %99s", fullpath + 5);
- if (ret != 1) {
- fprintf(stderr,
- "failed to scan device name from /proc/partitions\n");
- break;
- }
-
- /*
- * multipath and MD devices may register as a btrfs filesystem
- * both through the original block device and through
- * the special (/dev/mapper or /dev/mdX) entry.
- * This scans the special entries last
- */
- special = strncmp(fullpath, "/dev/dm-", strlen("/dev/dm-")) == 0;
- if (!special)
- special = strncmp(fullpath, "/dev/md", strlen("/dev/md")) == 0;
-
- if (scans == 0 && special)
- continue;
- if (scans > 0 && !special)
- continue;
-
- ret = lstat(fullpath, &st);
- if (ret < 0) {
- fprintf(stderr, "failed to stat %s\n", fullpath);
- continue;
- }
- if (!S_ISBLK(st.st_mode)) {
- continue;
- }
-
- fd = open(fullpath, O_RDONLY);
- if (fd < 0) {
- if (errno != ENOMEDIUM)
- fprintf(stderr, "failed to open %s: %s\n",
- fullpath, strerror(errno));
- continue;
- }
- ret = btrfs_scan_one_device(fd, fullpath, &tmp_devices,
- &num_devices,
- BTRFS_SUPER_INFO_OFFSET, 0);
- if (ret == 0 && run_ioctl > 0) {
- btrfs_register_one_device(fullpath);
- }
- close(fd);
- }
- fclose(proc_partitions);
+ ret = lstat(path, &st);
+ if (ret < 0)
+ return ret;
- if (scans == 0) {
- scans++;
- goto scan_again;
- }
- return 0;
+ return st.st_ino == BTRFS_FIRST_FREE_OBJECTID;
}
/*
return ret;
}
+u64 parse_qgroupid(const char *p)
+{
+ char *s = strchr(p, '/');
+ const char *ptr_src_end = p + strlen(p);
+ char *ptr_parse_end = NULL;
+ u64 level;
+ u64 id;
+ int fd;
+ int ret = 0;
+
+ if (p[0] == '/')
+ goto path;
+
+ /* Numeric format like '0/257' is the primary case */
+ if (!s) {
+ id = strtoull(p, &ptr_parse_end, 10);
+ if (ptr_parse_end != ptr_src_end)
+ goto path;
+ return id;
+ }
+ level = strtoull(p, &ptr_parse_end, 10);
+ if (ptr_parse_end != s)
+ goto path;
+
+ id = strtoull(s + 1, &ptr_parse_end, 10);
+ if (ptr_parse_end != ptr_src_end)
+ goto path;
+
+ return (level << BTRFS_QGROUP_LEVEL_SHIFT) | id;
+
+path:
+ /* Path format like subv at 'my_subvol' is the fallback case */
+ ret = __is_subvol(p);
+ if (ret < 0 || !ret)
+ goto err;
+ fd = open(p, O_RDONLY);
+ if (fd < 0)
+ goto err;
+ ret = lookup_ino_rootid(fd, &id);
+ close(fd);
+ if (ret < 0)
+ goto err;
+ return id;
+
+err:
+ fprintf(stderr, "ERROR: invalid qgroupid or subvolume path: %s\n", p);
+ exit(-1);
+}
+
int open_file_or_dir3(const char *fname, DIR **dirstream, int open_flags)
{
int ret;
}
if (fd < 0) {
fd = -1;
- if (*dirstream)
+ if (*dirstream) {
closedir(*dirstream);
+ *dirstream = NULL;
+ }
}
return fd;
}
struct btrfs_fs_devices *fs_devices_mnt = NULL;
struct btrfs_ioctl_dev_info_args *di_args;
struct btrfs_ioctl_dev_info_args tmp;
- char mp[BTRFS_PATH_NAME_MAX + 1];
+ char mp[PATH_MAX];
DIR *dirstream = NULL;
memset(fi_args, 0, sizeof(*fi_args));
}
int test_num_disk_vs_raid(u64 metadata_profile, u64 data_profile,
- u64 dev_cnt, int mixed, char *estr)
+ u64 dev_cnt, int mixed)
{
- size_t sz = 100;
u64 allowed = 0;
switch (dev_cnt) {
if (dev_cnt > 1 &&
((metadata_profile | data_profile) & BTRFS_BLOCK_GROUP_DUP)) {
- snprintf(estr, sz,
- "DUP is not allowed when FS has multiple devices\n");
+ fprintf(stderr,
+ "ERROR: DUP is not allowed when FS has multiple devices\n");
return 1;
}
if (metadata_profile & ~allowed) {
- snprintf(estr, sz,
- "unable to create FS with metadata profile %s "
+ fprintf(stderr,
+ "ERROR: unable to create FS with metadata profile %s "
"(have %llu devices but %d devices are required)\n",
btrfs_group_profile_str(metadata_profile), dev_cnt,
group_profile_devs_min(metadata_profile));
return 1;
}
if (data_profile & ~allowed) {
- snprintf(estr, sz,
- "unable to create FS with data profile %s "
+ fprintf(stderr,
+ "ERROR: unable to create FS with data profile %s "
"(have %llu devices but %d devices are required)\n",
btrfs_group_profile_str(data_profile), dev_cnt,
group_profile_devs_min(data_profile));
}
if (!mixed && (data_profile & BTRFS_BLOCK_GROUP_DUP)) {
- snprintf(estr, sz,
- "dup for data is allowed only in mixed mode");
+ fprintf(stderr,
+ "ERROR: DUP for data is allowed only in mixed mode");
return 1;
}
return 0;
}
-/* Check if disk is suitable for btrfs
+int group_profile_max_safe_loss(u64 flags)
+{
+ switch (flags & BTRFS_BLOCK_GROUP_PROFILE_MASK) {
+ case 0: /* single */
+ case BTRFS_BLOCK_GROUP_DUP:
+ case BTRFS_BLOCK_GROUP_RAID0:
+ return 0;
+ case BTRFS_BLOCK_GROUP_RAID1:
+ case BTRFS_BLOCK_GROUP_RAID5:
+ case BTRFS_BLOCK_GROUP_RAID10:
+ return 1;
+ case BTRFS_BLOCK_GROUP_RAID6:
+ return 2;
+ default:
+ return -1;
+ }
+}
+
+/*
+ * Check if a device is suitable for btrfs
* returns:
- * 1: something is wrong, estr provides the error
+ * 1: something is wrong, an error is printed
* 0: all is fine
*/
-int test_dev_for_mkfs(char *file, int force_overwrite, char *estr)
+int test_dev_for_mkfs(char *file, int force_overwrite)
{
int ret, fd;
- size_t sz = 100;
struct stat st;
ret = is_swap_device(file);
if (ret < 0) {
- snprintf(estr, sz, "error checking %s status: %s\n", file,
+ fprintf(stderr, "ERROR: checking status of %s: %s\n", file,
strerror(-ret));
return 1;
}
if (ret == 1) {
- snprintf(estr, sz, "%s is a swap device\n", file);
+ fprintf(stderr, "ERROR: %s is a swap device\n", file);
return 1;
}
if (!force_overwrite) {
if (check_overwrite(file)) {
- snprintf(estr, sz, "Use the -f option to force overwrite.\n");
+ fprintf(stderr, "Use the -f option to force overwrite.\n");
return 1;
}
}
ret = check_mounted(file);
if (ret < 0) {
- snprintf(estr, sz, "error checking %s mount status\n",
- file);
+ fprintf(stderr, "ERROR: checking mount status of %s: %s\n",
+ file, strerror(-ret));
return 1;
}
if (ret == 1) {
- snprintf(estr, sz, "%s is mounted\n", file);
+ fprintf(stderr, "ERROR: %s is mounted\n", file);
return 1;
}
/* check if the device is busy */
fd = open(file, O_RDWR|O_EXCL);
if (fd < 0) {
- snprintf(estr, sz, "unable to open %s: %s\n", file,
+ fprintf(stderr, "ERROR: unable to open %s: %s\n", file,
strerror(errno));
return 1;
}
if (fstat(fd, &st)) {
- snprintf(estr, sz, "unable to stat %s: %s\n", file,
+ fprintf(stderr, "ERROR: unable to stat %s: %s\n", file,
strerror(errno));
close(fd);
return 1;
}
if (!S_ISBLK(st.st_mode)) {
- fprintf(stderr, "'%s' is not a block device\n", file);
+ fprintf(stderr, "ERROR: %s is not a block device\n", file);
close(fd);
return 1;
}
return ret;
}
-int test_minimum_size(const char *file, u32 leafsize)
+int test_minimum_size(const char *file, u32 nodesize)
{
int fd;
struct stat statbuf;
close(fd);
return -errno;
}
- if (btrfs_device_size(fd, &statbuf) < btrfs_min_dev_size(leafsize)) {
+ if (btrfs_device_size(fd, &statbuf) < btrfs_min_dev_size(nodesize)) {
close(fd);
return 1;
}
return v2_supported;
}
-int btrfs_check_node_or_leaf_size(u32 size, u32 sectorsize)
+int btrfs_check_nodesize(u32 nodesize, u32 sectorsize)
{
- if (size < sectorsize) {
+ if (nodesize < sectorsize) {
fprintf(stderr,
- "Illegal leafsize (or nodesize) %u (smaller than %u)\n",
- size, sectorsize);
+ "ERROR: Illegal nodesize %u (smaller than %u)\n",
+ nodesize, sectorsize);
return -1;
- } else if (size > BTRFS_MAX_METADATA_BLOCKSIZE) {
+ } else if (nodesize > BTRFS_MAX_METADATA_BLOCKSIZE) {
fprintf(stderr,
- "Illegal leafsize (or nodesize) %u (larger than %u)\n",
- size, BTRFS_MAX_METADATA_BLOCKSIZE);
+ "ERROR: Illegal nodesize %u (larger than %u)\n",
+ nodesize, BTRFS_MAX_METADATA_BLOCKSIZE);
return -1;
- } else if (size & (sectorsize - 1)) {
+ } else if (nodesize & (sectorsize - 1)) {
fprintf(stderr,
- "Illegal leafsize (or nodesize) %u (not align to %u)\n",
- size, sectorsize);
+ "ERROR: Illegal nodesize %u (not aligned to %u)\n",
+ nodesize, sectorsize);
return -1;
}
return 0;
}
+
+/*
+ * Copy a path argument from SRC to DEST and check the SRC length if it's at
+ * most PATH_MAX and fits into DEST. DESTLEN is supposed to be exact size of
+ * the buffer.
+ * The destination buffer is zero terminated.
+ * Return < 0 for error, 0 otherwise.
+ */
+int arg_copy_path(char *dest, const char *src, int destlen)
+{
+ size_t len = strlen(src);
+
+ if (len >= PATH_MAX || len >= destlen)
+ return -ENAMETOOLONG;
+
+ __strncpy__null(dest, src, destlen);
+
+ return 0;
+}