2007-06-12 13:07:11 +00:00
|
|
|
/*
|
|
|
|
* Copyright (C) 2007 Oracle. All rights reserved.
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public
|
|
|
|
* License v2 as published by the Free Software Foundation.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
* General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public
|
|
|
|
* License along with this program; if not, write to the
|
|
|
|
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
|
|
* Boston, MA 021110-1307, USA.
|
|
|
|
*/
|
|
|
|
|
2007-02-20 21:41:09 +00:00
|
|
|
#define _XOPEN_SOURCE 500
|
2008-04-01 15:08:13 +00:00
|
|
|
#define _GNU_SOURCE
|
2008-04-28 20:44:22 +00:00
|
|
|
|
|
|
|
#ifndef __CHECKER__
|
|
|
|
#include <sys/ioctl.h>
|
|
|
|
#include <sys/mount.h>
|
|
|
|
#include "ioctl.h"
|
|
|
|
#endif
|
|
|
|
|
2007-02-20 21:41:09 +00:00
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <sys/types.h>
|
|
|
|
#include <sys/stat.h>
|
2010-07-08 09:17:59 +00:00
|
|
|
#include <sys/dir.h>
|
2007-02-20 21:41:09 +00:00
|
|
|
#include <fcntl.h>
|
|
|
|
#include <unistd.h>
|
2008-04-01 15:08:13 +00:00
|
|
|
#include <getopt.h>
|
2007-04-05 18:29:12 +00:00
|
|
|
#include <uuid/uuid.h>
|
2007-06-12 15:39:09 +00:00
|
|
|
#include <linux/fs.h>
|
2007-12-21 21:25:35 +00:00
|
|
|
#include <ctype.h>
|
2010-07-08 09:17:59 +00:00
|
|
|
#include <attr/xattr.h>
|
2007-06-12 15:39:09 +00:00
|
|
|
#include "kerncompat.h"
|
2007-02-20 21:41:09 +00:00
|
|
|
#include "ctree.h"
|
|
|
|
#include "disk-io.h"
|
2008-03-24 19:03:18 +00:00
|
|
|
#include "volumes.h"
|
2007-03-21 15:13:29 +00:00
|
|
|
#include "transaction.h"
|
2008-01-04 15:38:22 +00:00
|
|
|
#include "utils.h"
|
2008-07-24 16:13:30 +00:00
|
|
|
#include "version.h"
|
2007-02-20 21:41:09 +00:00
|
|
|
|
2010-07-08 09:17:59 +00:00
|
|
|
static u64 index_cnt = 2;
|
|
|
|
|
|
|
|
struct directory_name_entry {
|
|
|
|
char *dir_name;
|
|
|
|
char *path;
|
|
|
|
ino_t inum;
|
|
|
|
struct list_head list;
|
|
|
|
};
|
|
|
|
|
2007-12-21 21:25:35 +00:00
|
|
|
static u64 parse_size(char *s)
|
|
|
|
{
|
|
|
|
int len = strlen(s);
|
|
|
|
char c;
|
|
|
|
u64 mult = 1;
|
|
|
|
|
|
|
|
if (!isdigit(s[len - 1])) {
|
|
|
|
c = tolower(s[len - 1]);
|
|
|
|
switch (c) {
|
|
|
|
case 'g':
|
|
|
|
mult *= 1024;
|
|
|
|
case 'm':
|
|
|
|
mult *= 1024;
|
|
|
|
case 'k':
|
|
|
|
mult *= 1024;
|
|
|
|
case 'b':
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
fprintf(stderr, "Unknown size descriptor %c\n", c);
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
s[len - 1] = '\0';
|
|
|
|
}
|
|
|
|
return atol(s) * mult;
|
|
|
|
}
|
|
|
|
|
2010-12-09 18:31:08 +00:00
|
|
|
static int make_root_dir(struct btrfs_root *root, int mixed)
|
2008-09-23 16:29:10 +00:00
|
|
|
{
|
2007-04-06 19:39:12 +00:00
|
|
|
struct btrfs_trans_handle *trans;
|
|
|
|
struct btrfs_key location;
|
2008-03-24 19:03:18 +00:00
|
|
|
u64 bytes_used;
|
|
|
|
u64 chunk_start = 0;
|
|
|
|
u64 chunk_size = 0;
|
2008-01-04 15:38:22 +00:00
|
|
|
int ret;
|
2007-04-06 19:39:12 +00:00
|
|
|
|
|
|
|
trans = btrfs_start_transaction(root, 1);
|
2008-03-24 19:03:18 +00:00
|
|
|
bytes_used = btrfs_super_bytes_used(&root->fs_info->super_copy);
|
|
|
|
|
2008-04-22 18:06:56 +00:00
|
|
|
root->fs_info->system_allocs = 1;
|
2008-03-24 19:03:18 +00:00
|
|
|
ret = btrfs_make_block_group(trans, root, bytes_used,
|
|
|
|
BTRFS_BLOCK_GROUP_SYSTEM,
|
2008-04-15 19:42:08 +00:00
|
|
|
BTRFS_FIRST_CHUNK_TREE_OBJECTID,
|
2008-03-24 19:03:18 +00:00
|
|
|
0, BTRFS_MKFS_SYSTEM_GROUP_SIZE);
|
|
|
|
BUG_ON(ret);
|
2008-04-15 19:42:08 +00:00
|
|
|
|
2010-12-09 18:31:08 +00:00
|
|
|
if (mixed) {
|
|
|
|
ret = btrfs_alloc_chunk(trans, root->fs_info->extent_root,
|
|
|
|
&chunk_start, &chunk_size,
|
|
|
|
BTRFS_BLOCK_GROUP_METADATA |
|
|
|
|
BTRFS_BLOCK_GROUP_DATA);
|
|
|
|
BUG_ON(ret);
|
|
|
|
ret = btrfs_make_block_group(trans, root, 0,
|
|
|
|
BTRFS_BLOCK_GROUP_METADATA |
|
|
|
|
BTRFS_BLOCK_GROUP_DATA,
|
|
|
|
BTRFS_FIRST_CHUNK_TREE_OBJECTID,
|
|
|
|
chunk_start, chunk_size);
|
|
|
|
BUG_ON(ret);
|
|
|
|
printf("Created a data/metadata chunk of size %llu\n", chunk_size);
|
|
|
|
} else {
|
|
|
|
ret = btrfs_alloc_chunk(trans, root->fs_info->extent_root,
|
|
|
|
&chunk_start, &chunk_size,
|
|
|
|
BTRFS_BLOCK_GROUP_METADATA);
|
|
|
|
BUG_ON(ret);
|
|
|
|
ret = btrfs_make_block_group(trans, root, 0,
|
|
|
|
BTRFS_BLOCK_GROUP_METADATA,
|
|
|
|
BTRFS_FIRST_CHUNK_TREE_OBJECTID,
|
|
|
|
chunk_start, chunk_size);
|
|
|
|
BUG_ON(ret);
|
|
|
|
}
|
2008-03-24 19:03:18 +00:00
|
|
|
|
2008-04-22 18:06:56 +00:00
|
|
|
root->fs_info->system_allocs = 0;
|
2008-03-24 19:03:18 +00:00
|
|
|
btrfs_commit_transaction(trans, root);
|
|
|
|
trans = btrfs_start_transaction(root, 1);
|
|
|
|
BUG_ON(!trans);
|
|
|
|
|
2010-12-09 18:31:08 +00:00
|
|
|
if (!mixed) {
|
|
|
|
ret = btrfs_alloc_chunk(trans, root->fs_info->extent_root,
|
|
|
|
&chunk_start, &chunk_size,
|
|
|
|
BTRFS_BLOCK_GROUP_DATA);
|
|
|
|
BUG_ON(ret);
|
|
|
|
ret = btrfs_make_block_group(trans, root, 0,
|
|
|
|
BTRFS_BLOCK_GROUP_DATA,
|
|
|
|
BTRFS_FIRST_CHUNK_TREE_OBJECTID,
|
|
|
|
chunk_start, chunk_size);
|
|
|
|
BUG_ON(ret);
|
|
|
|
}
|
2008-03-24 19:03:18 +00:00
|
|
|
|
2008-01-04 15:38:22 +00:00
|
|
|
ret = btrfs_make_root_dir(trans, root->fs_info->tree_root,
|
2007-04-11 12:58:53 +00:00
|
|
|
BTRFS_ROOT_TREE_DIR_OBJECTID);
|
2007-03-21 15:13:29 +00:00
|
|
|
if (ret)
|
2007-04-06 19:39:12 +00:00
|
|
|
goto err;
|
2008-01-04 15:38:22 +00:00
|
|
|
ret = btrfs_make_root_dir(trans, root, BTRFS_FIRST_FREE_OBJECTID);
|
2007-04-06 19:39:12 +00:00
|
|
|
if (ret)
|
|
|
|
goto err;
|
|
|
|
memcpy(&location, &root->fs_info->fs_root->root_key, sizeof(location));
|
|
|
|
location.offset = (u64)-1;
|
|
|
|
ret = btrfs_insert_dir_item(trans, root->fs_info->tree_root,
|
2007-08-29 19:56:44 +00:00
|
|
|
"default", 7,
|
2008-01-04 15:38:22 +00:00
|
|
|
btrfs_super_root_dir(&root->fs_info->super_copy),
|
2008-12-17 21:10:07 +00:00
|
|
|
&location, BTRFS_FT_DIR, 0);
|
2007-04-06 19:39:12 +00:00
|
|
|
if (ret)
|
|
|
|
goto err;
|
2007-12-12 19:39:46 +00:00
|
|
|
|
|
|
|
ret = btrfs_insert_inode_ref(trans, root->fs_info->tree_root,
|
|
|
|
"default", 7, location.objectid,
|
2008-07-24 16:13:32 +00:00
|
|
|
BTRFS_ROOT_TREE_DIR_OBJECTID, 0);
|
2007-12-12 19:39:46 +00:00
|
|
|
if (ret)
|
|
|
|
goto err;
|
|
|
|
|
2008-01-04 15:38:22 +00:00
|
|
|
btrfs_commit_transaction(trans, root);
|
2007-04-06 19:39:12 +00:00
|
|
|
err:
|
2007-03-21 15:13:29 +00:00
|
|
|
return ret;
|
|
|
|
}
|
2007-03-21 00:35:03 +00:00
|
|
|
|
2008-04-04 19:42:17 +00:00
|
|
|
static int recow_roots(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_root *root)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
struct extent_buffer *tmp;
|
|
|
|
struct btrfs_fs_info *info = root->fs_info;
|
|
|
|
|
|
|
|
ret = __btrfs_cow_block(trans, info->fs_root, info->fs_root->node,
|
|
|
|
NULL, 0, &tmp, 0, 0);
|
|
|
|
BUG_ON(ret);
|
|
|
|
free_extent_buffer(tmp);
|
|
|
|
|
|
|
|
ret = __btrfs_cow_block(trans, info->tree_root, info->tree_root->node,
|
|
|
|
NULL, 0, &tmp, 0, 0);
|
|
|
|
BUG_ON(ret);
|
|
|
|
free_extent_buffer(tmp);
|
|
|
|
|
|
|
|
ret = __btrfs_cow_block(trans, info->extent_root,
|
|
|
|
info->extent_root->node, NULL, 0, &tmp, 0, 0);
|
|
|
|
BUG_ON(ret);
|
|
|
|
free_extent_buffer(tmp);
|
|
|
|
|
|
|
|
ret = __btrfs_cow_block(trans, info->chunk_root, info->chunk_root->node,
|
|
|
|
NULL, 0, &tmp, 0, 0);
|
|
|
|
BUG_ON(ret);
|
|
|
|
free_extent_buffer(tmp);
|
|
|
|
|
|
|
|
|
|
|
|
ret = __btrfs_cow_block(trans, info->dev_root, info->dev_root->node,
|
|
|
|
NULL, 0, &tmp, 0, 0);
|
|
|
|
BUG_ON(ret);
|
|
|
|
free_extent_buffer(tmp);
|
|
|
|
|
2009-05-29 20:35:30 +00:00
|
|
|
ret = __btrfs_cow_block(trans, info->csum_root, info->csum_root->node,
|
|
|
|
NULL, 0, &tmp, 0, 0);
|
|
|
|
BUG_ON(ret);
|
|
|
|
free_extent_buffer(tmp);
|
|
|
|
|
2008-04-04 19:42:17 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-04-03 20:35:48 +00:00
|
|
|
static int create_one_raid_group(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_root *root, u64 type)
|
|
|
|
{
|
|
|
|
u64 chunk_start;
|
|
|
|
u64 chunk_size;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = btrfs_alloc_chunk(trans, root->fs_info->extent_root,
|
|
|
|
&chunk_start, &chunk_size, type);
|
|
|
|
BUG_ON(ret);
|
|
|
|
ret = btrfs_make_block_group(trans, root->fs_info->extent_root, 0,
|
2008-04-15 19:42:08 +00:00
|
|
|
type, BTRFS_FIRST_CHUNK_TREE_OBJECTID,
|
2008-04-03 20:35:48 +00:00
|
|
|
chunk_start, chunk_size);
|
|
|
|
BUG_ON(ret);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int create_raid_groups(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_root *root, u64 data_profile,
|
2010-12-09 18:31:08 +00:00
|
|
|
u64 metadata_profile, int mixed)
|
2008-04-03 20:35:48 +00:00
|
|
|
{
|
|
|
|
u64 num_devices = btrfs_super_num_devices(&root->fs_info->super_copy);
|
|
|
|
u64 allowed;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (num_devices == 1)
|
|
|
|
allowed = BTRFS_BLOCK_GROUP_DUP;
|
2008-04-16 15:14:21 +00:00
|
|
|
else if (num_devices >= 4) {
|
|
|
|
allowed = BTRFS_BLOCK_GROUP_RAID0 | BTRFS_BLOCK_GROUP_RAID1 |
|
|
|
|
BTRFS_BLOCK_GROUP_RAID10;
|
|
|
|
} else
|
2008-04-03 20:35:48 +00:00
|
|
|
allowed = BTRFS_BLOCK_GROUP_RAID0 | BTRFS_BLOCK_GROUP_RAID1;
|
|
|
|
|
2008-04-03 20:35:48 +00:00
|
|
|
if (allowed & metadata_profile) {
|
2010-12-09 18:31:08 +00:00
|
|
|
u64 meta_flags = BTRFS_BLOCK_GROUP_METADATA;
|
|
|
|
|
2008-04-04 19:42:17 +00:00
|
|
|
ret = create_one_raid_group(trans, root,
|
|
|
|
BTRFS_BLOCK_GROUP_SYSTEM |
|
|
|
|
(allowed & metadata_profile));
|
|
|
|
BUG_ON(ret);
|
|
|
|
|
2010-12-09 18:31:08 +00:00
|
|
|
if (mixed)
|
|
|
|
meta_flags |= BTRFS_BLOCK_GROUP_DATA;
|
|
|
|
|
|
|
|
ret = create_one_raid_group(trans, root, meta_flags |
|
2008-04-03 20:35:48 +00:00
|
|
|
(allowed & metadata_profile));
|
|
|
|
BUG_ON(ret);
|
2008-04-04 19:42:17 +00:00
|
|
|
|
|
|
|
ret = recow_roots(trans, root);
|
|
|
|
BUG_ON(ret);
|
2008-04-03 20:35:48 +00:00
|
|
|
}
|
2010-12-09 18:31:08 +00:00
|
|
|
if (!mixed && num_devices > 1 && (allowed & data_profile)) {
|
2008-04-03 20:35:48 +00:00
|
|
|
ret = create_one_raid_group(trans, root,
|
|
|
|
BTRFS_BLOCK_GROUP_DATA |
|
|
|
|
(allowed & data_profile));
|
|
|
|
BUG_ON(ret);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-09-26 14:26:53 +00:00
|
|
|
static int create_data_reloc_tree(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_root *root)
|
|
|
|
{
|
|
|
|
struct btrfs_key location;
|
|
|
|
struct btrfs_root_item root_item;
|
|
|
|
struct extent_buffer *tmp;
|
|
|
|
u64 objectid = BTRFS_DATA_RELOC_TREE_OBJECTID;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = btrfs_copy_root(trans, root, root->node, &tmp, objectid);
|
|
|
|
BUG_ON(ret);
|
|
|
|
|
|
|
|
memcpy(&root_item, &root->root_item, sizeof(root_item));
|
|
|
|
btrfs_set_root_bytenr(&root_item, tmp->start);
|
|
|
|
btrfs_set_root_level(&root_item, btrfs_header_level(tmp));
|
2008-10-29 18:07:47 +00:00
|
|
|
btrfs_set_root_generation(&root_item, trans->transid);
|
2008-09-26 14:26:53 +00:00
|
|
|
free_extent_buffer(tmp);
|
|
|
|
|
|
|
|
location.objectid = objectid;
|
|
|
|
location.type = BTRFS_ROOT_ITEM_KEY;
|
2009-05-29 20:35:30 +00:00
|
|
|
location.offset = 0;
|
2008-09-26 14:26:53 +00:00
|
|
|
ret = btrfs_insert_root(trans, root->fs_info->tree_root,
|
|
|
|
&location, &root_item);
|
|
|
|
BUG_ON(ret);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-10-15 20:25:14 +00:00
|
|
|
static void print_usage(void)
|
|
|
|
{
|
2008-04-01 15:08:13 +00:00
|
|
|
fprintf(stderr, "usage: mkfs.btrfs [options] dev [ dev ... ]\n");
|
|
|
|
fprintf(stderr, "options:\n");
|
2009-01-07 19:57:12 +00:00
|
|
|
fprintf(stderr, "\t -A --alloc-start the offset to start the FS\n");
|
2008-04-01 15:08:13 +00:00
|
|
|
fprintf(stderr, "\t -b --byte-count total number of bytes in the FS\n");
|
2009-01-07 19:57:12 +00:00
|
|
|
fprintf(stderr, "\t -d --data data profile, raid0, raid1, raid10 or single\n");
|
2008-04-01 15:08:13 +00:00
|
|
|
fprintf(stderr, "\t -l --leafsize size of btree leaves\n");
|
2009-01-07 19:57:12 +00:00
|
|
|
fprintf(stderr, "\t -L --label set a label\n");
|
|
|
|
fprintf(stderr, "\t -m --metadata metadata profile, values like data profile\n");
|
2010-12-09 18:31:08 +00:00
|
|
|
fprintf(stderr, "\t -M --mixed mix metadata and data together\n");
|
2009-01-07 19:57:12 +00:00
|
|
|
fprintf(stderr, "\t -n --nodesize size of btree nodes\n");
|
2008-04-01 15:08:13 +00:00
|
|
|
fprintf(stderr, "\t -s --sectorsize min block allocation\n");
|
2010-07-08 09:17:59 +00:00
|
|
|
fprintf(stderr, "\t -r --rootdir the source directory\n");
|
2008-07-24 16:13:30 +00:00
|
|
|
fprintf(stderr, "%s\n", BTRFS_BUILD_VERSION);
|
2007-10-15 20:25:14 +00:00
|
|
|
exit(1);
|
|
|
|
}
|
2007-03-21 00:35:03 +00:00
|
|
|
|
2009-06-03 16:00:20 +00:00
|
|
|
static void print_version(void)
|
|
|
|
{
|
|
|
|
fprintf(stderr, "mkfs.btrfs, part of %s\n", BTRFS_BUILD_VERSION);
|
|
|
|
exit(0);
|
|
|
|
}
|
|
|
|
|
2008-04-03 20:35:48 +00:00
|
|
|
static u64 parse_profile(char *s)
|
|
|
|
{
|
|
|
|
if (strcmp(s, "raid0") == 0) {
|
|
|
|
return BTRFS_BLOCK_GROUP_RAID0;
|
|
|
|
} else if (strcmp(s, "raid1") == 0) {
|
|
|
|
return BTRFS_BLOCK_GROUP_RAID1 | BTRFS_BLOCK_GROUP_DUP;
|
2008-04-16 15:14:21 +00:00
|
|
|
} else if (strcmp(s, "raid10") == 0) {
|
|
|
|
return BTRFS_BLOCK_GROUP_RAID10 | BTRFS_BLOCK_GROUP_DUP;
|
2008-04-03 20:35:48 +00:00
|
|
|
} else if (strcmp(s, "single") == 0) {
|
|
|
|
return 0;
|
|
|
|
} else {
|
|
|
|
fprintf(stderr, "Unknown option %s\n", s);
|
|
|
|
print_usage();
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-04-18 14:31:42 +00:00
|
|
|
static char *parse_label(char *input)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
int len = strlen(input);
|
|
|
|
|
|
|
|
if (len > BTRFS_LABEL_SIZE) {
|
|
|
|
fprintf(stderr, "Label %s is too long (max %d)\n", input,
|
|
|
|
BTRFS_LABEL_SIZE);
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
for (i = 0; i < len; i++) {
|
|
|
|
if (input[i] == '/' || input[i] == '\\') {
|
|
|
|
fprintf(stderr, "invalid label %s\n", input);
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return strdup(input);
|
|
|
|
}
|
|
|
|
|
2008-04-01 15:08:13 +00:00
|
|
|
static struct option long_options[] = {
|
2008-04-25 20:55:21 +00:00
|
|
|
{ "alloc-start", 1, NULL, 'A'},
|
2008-04-01 15:08:13 +00:00
|
|
|
{ "byte-count", 1, NULL, 'b' },
|
|
|
|
{ "leafsize", 1, NULL, 'l' },
|
2008-04-18 14:31:42 +00:00
|
|
|
{ "label", 1, NULL, 'L'},
|
|
|
|
{ "metadata", 1, NULL, 'm' },
|
2010-12-09 18:31:08 +00:00
|
|
|
{ "mixed", 0, NULL, 'M' },
|
2008-04-01 15:08:13 +00:00
|
|
|
{ "nodesize", 1, NULL, 'n' },
|
|
|
|
{ "sectorsize", 1, NULL, 's' },
|
2008-04-03 20:35:48 +00:00
|
|
|
{ "data", 1, NULL, 'd' },
|
2009-06-03 16:00:20 +00:00
|
|
|
{ "version", 0, NULL, 'V' },
|
2010-07-08 09:17:59 +00:00
|
|
|
{ "rootdir", 1, NULL, 'r' },
|
2008-04-01 15:08:13 +00:00
|
|
|
{ 0, 0, 0, 0}
|
|
|
|
};
|
|
|
|
|
2010-07-08 09:17:59 +00:00
|
|
|
static int add_directory_items(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_root *root, u64 objectid,
|
|
|
|
ino_t parent_inum, const char *name,
|
|
|
|
struct stat *st, int *dir_index_cnt)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
int name_len;
|
|
|
|
struct btrfs_key location;
|
|
|
|
u8 filetype = 0;
|
|
|
|
|
|
|
|
name_len = strlen(name);
|
|
|
|
|
|
|
|
location.objectid = objectid;
|
|
|
|
location.offset = 0;
|
|
|
|
btrfs_set_key_type(&location, BTRFS_INODE_ITEM_KEY);
|
|
|
|
|
|
|
|
if (S_ISDIR(st->st_mode))
|
|
|
|
filetype = BTRFS_FT_DIR;
|
|
|
|
if (S_ISREG(st->st_mode))
|
|
|
|
filetype = BTRFS_FT_REG_FILE;
|
|
|
|
if (S_ISLNK(st->st_mode))
|
|
|
|
filetype = BTRFS_FT_SYMLINK;
|
|
|
|
|
|
|
|
ret = btrfs_insert_dir_item(trans, root, name, name_len,
|
|
|
|
parent_inum, &location,
|
|
|
|
filetype, index_cnt);
|
|
|
|
|
|
|
|
*dir_index_cnt = index_cnt;
|
|
|
|
index_cnt++;
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int fill_inode_item(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_root *root,
|
|
|
|
struct btrfs_inode_item *dst, struct stat *src)
|
|
|
|
{
|
|
|
|
u64 blocks = 0;
|
|
|
|
u64 sectorsize = root->sectorsize;
|
|
|
|
|
|
|
|
btrfs_set_stack_inode_generation(dst, trans->transid);
|
|
|
|
btrfs_set_stack_inode_size(dst, src->st_size);
|
|
|
|
btrfs_set_stack_inode_nbytes(dst, 0);
|
|
|
|
btrfs_set_stack_inode_block_group(dst, 0);
|
|
|
|
btrfs_set_stack_inode_nlink(dst, src->st_nlink);
|
|
|
|
btrfs_set_stack_inode_uid(dst, src->st_uid);
|
|
|
|
btrfs_set_stack_inode_gid(dst, src->st_gid);
|
|
|
|
btrfs_set_stack_inode_mode(dst, src->st_mode);
|
|
|
|
btrfs_set_stack_inode_rdev(dst, 0);
|
|
|
|
btrfs_set_stack_inode_flags(dst, 0);
|
|
|
|
btrfs_set_stack_timespec_sec(&dst->atime, src->st_atime);
|
|
|
|
btrfs_set_stack_timespec_nsec(&dst->atime, 0);
|
|
|
|
btrfs_set_stack_timespec_sec(&dst->ctime, src->st_ctime);
|
|
|
|
btrfs_set_stack_timespec_nsec(&dst->ctime, 0);
|
|
|
|
btrfs_set_stack_timespec_sec(&dst->mtime, src->st_mtime);
|
|
|
|
btrfs_set_stack_timespec_nsec(&dst->mtime, 0);
|
|
|
|
btrfs_set_stack_timespec_sec(&dst->otime, 0);
|
|
|
|
btrfs_set_stack_timespec_nsec(&dst->otime, 0);
|
|
|
|
|
|
|
|
if (S_ISDIR(src->st_mode)) {
|
|
|
|
btrfs_set_stack_inode_size(dst, 0);
|
|
|
|
btrfs_set_stack_inode_nlink(dst, 1);
|
|
|
|
}
|
|
|
|
if (S_ISREG(src->st_mode)) {
|
|
|
|
btrfs_set_stack_inode_size(dst, (u64)src->st_size);
|
|
|
|
if (src->st_size <= BTRFS_MAX_INLINE_DATA_SIZE(root))
|
|
|
|
btrfs_set_stack_inode_nbytes(dst, src->st_size);
|
|
|
|
else {
|
|
|
|
blocks = src->st_size / sectorsize;
|
|
|
|
if (src->st_size % sectorsize)
|
|
|
|
blocks += 1;
|
|
|
|
blocks *= sectorsize;
|
|
|
|
btrfs_set_stack_inode_nbytes(dst, blocks);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (S_ISLNK(src->st_mode))
|
|
|
|
btrfs_set_stack_inode_nbytes(dst, src->st_size + 1);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int directory_select(const struct direct *entry)
|
|
|
|
{
|
|
|
|
if ((strncmp(entry->d_name, ".", entry->d_reclen) == 0) ||
|
|
|
|
(strncmp(entry->d_name, "..", entry->d_reclen) == 0))
|
|
|
|
return 0;
|
|
|
|
else
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static u64 calculate_dir_inode_size(char *dirname)
|
|
|
|
{
|
|
|
|
int count, i;
|
|
|
|
struct direct **files, *cur_file;
|
|
|
|
u64 dir_inode_size = 0;
|
|
|
|
|
|
|
|
count = scandir(dirname, &files, directory_select, NULL);
|
|
|
|
|
|
|
|
for (i = 0; i < count; i++) {
|
|
|
|
cur_file = files[i];
|
|
|
|
dir_inode_size += strlen(cur_file->d_name);
|
|
|
|
}
|
|
|
|
|
|
|
|
dir_inode_size *= 2;
|
|
|
|
return dir_inode_size;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int add_inode_items(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_root *root,
|
|
|
|
struct stat *st, char *name,
|
|
|
|
u64 self_objectid, ino_t parent_inum,
|
|
|
|
int dir_index_cnt, struct btrfs_inode_item *inode_ret)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
struct btrfs_key inode_key;
|
|
|
|
struct btrfs_inode_item btrfs_inode;
|
|
|
|
u64 objectid;
|
|
|
|
u64 inode_size = 0;
|
|
|
|
int name_len;
|
|
|
|
|
|
|
|
name_len = strlen(name);
|
|
|
|
fill_inode_item(trans, root, &btrfs_inode, st);
|
|
|
|
objectid = self_objectid;
|
|
|
|
|
|
|
|
if (S_ISDIR(st->st_mode)) {
|
|
|
|
inode_size = calculate_dir_inode_size(name);
|
|
|
|
btrfs_set_stack_inode_size(&btrfs_inode, inode_size);
|
|
|
|
}
|
|
|
|
|
|
|
|
inode_key.objectid = objectid;
|
|
|
|
inode_key.offset = 0;
|
|
|
|
btrfs_set_key_type(&inode_key, BTRFS_INODE_ITEM_KEY);
|
|
|
|
|
|
|
|
ret = btrfs_insert_inode(trans, root, objectid, &btrfs_inode);
|
|
|
|
if (ret)
|
|
|
|
goto fail;
|
|
|
|
|
|
|
|
ret = btrfs_insert_inode_ref(trans, root, name, name_len,
|
|
|
|
objectid, parent_inum, dir_index_cnt);
|
|
|
|
if (ret)
|
|
|
|
goto fail;
|
|
|
|
|
|
|
|
*inode_ret = btrfs_inode;
|
|
|
|
fail:
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int add_xattr_item(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_root *root, u64 objectid,
|
|
|
|
const char *file_name)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
int cur_name_len;
|
|
|
|
char xattr_list[XATTR_LIST_MAX];
|
|
|
|
char *cur_name;
|
|
|
|
char cur_value[XATTR_SIZE_MAX];
|
|
|
|
char delimiter = '\0';
|
|
|
|
char *next_location = xattr_list;
|
|
|
|
|
|
|
|
ret = llistxattr(file_name, xattr_list, XATTR_LIST_MAX);
|
|
|
|
if (ret < 0) {
|
|
|
|
fprintf(stderr, "get a list of xattr failed for %s\n",
|
|
|
|
file_name);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
if (ret == 0)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
cur_name = strtok(xattr_list, &delimiter);
|
|
|
|
while (cur_name != NULL) {
|
|
|
|
cur_name_len = strlen(cur_name);
|
|
|
|
next_location += cur_name_len + 1;
|
|
|
|
|
|
|
|
ret = getxattr(file_name, cur_name, cur_value, XATTR_SIZE_MAX);
|
|
|
|
if (ret < 0) {
|
|
|
|
fprintf(stderr, "get a xattr value failed for %s\n",
|
|
|
|
cur_name);
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = btrfs_insert_xattr_item(trans, root, cur_name,
|
|
|
|
cur_name_len, cur_value,
|
|
|
|
ret, objectid);
|
|
|
|
if (ret) {
|
|
|
|
fprintf(stderr, "insert a xattr item failed for %s\n",
|
|
|
|
file_name);
|
|
|
|
}
|
|
|
|
|
|
|
|
cur_name = strtok(next_location, &delimiter);
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int custom_alloc_extent(struct btrfs_root *root, u64 num_bytes,
|
|
|
|
u64 hint_byte, struct btrfs_key *ins)
|
|
|
|
{
|
|
|
|
u64 start;
|
|
|
|
u64 end;
|
|
|
|
u64 last = hint_byte;
|
|
|
|
int ret;
|
|
|
|
int wrapped = 0;
|
|
|
|
struct btrfs_block_group_cache *cache;
|
|
|
|
|
|
|
|
while (1) {
|
|
|
|
ret = find_first_extent_bit(&root->fs_info->free_space_cache,
|
|
|
|
last, &start, &end, EXTENT_DIRTY);
|
|
|
|
if (ret) {
|
|
|
|
if (wrapped++ == 0) {
|
|
|
|
last = 0;
|
|
|
|
continue;
|
|
|
|
} else {
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
start = max(last, start);
|
|
|
|
last = end + 1;
|
|
|
|
if (last - start < num_bytes)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
last = start + num_bytes;
|
|
|
|
if (test_range_bit(&root->fs_info->pinned_extents,
|
|
|
|
start, last - 1, EXTENT_DIRTY, 0))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
cache = btrfs_lookup_block_group(root->fs_info, start);
|
|
|
|
BUG_ON(!cache);
|
|
|
|
if (cache->flags & BTRFS_BLOCK_GROUP_SYSTEM ||
|
|
|
|
last > cache->key.objectid + cache->key.offset) {
|
|
|
|
last = cache->key.objectid + cache->key.offset;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (cache->flags & (BTRFS_BLOCK_GROUP_SYSTEM |
|
|
|
|
BTRFS_BLOCK_GROUP_METADATA)) {
|
|
|
|
last = cache->key.objectid + cache->key.offset;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
clear_extent_dirty(&root->fs_info->free_space_cache,
|
|
|
|
start, start + num_bytes - 1, 0);
|
|
|
|
|
|
|
|
ins->objectid = start;
|
|
|
|
ins->offset = num_bytes;
|
|
|
|
ins->type = BTRFS_EXTENT_ITEM_KEY;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
fail:
|
|
|
|
fprintf(stderr, "not enough free space\n");
|
|
|
|
return -ENOSPC;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int record_file_extent(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_root *root, u64 objectid,
|
|
|
|
struct btrfs_inode_item *inode,
|
|
|
|
u64 file_pos, u64 disk_bytenr,
|
|
|
|
u64 num_bytes)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
struct btrfs_fs_info *info = root->fs_info;
|
|
|
|
struct btrfs_root *extent_root = info->extent_root;
|
|
|
|
struct extent_buffer *leaf;
|
|
|
|
struct btrfs_file_extent_item *fi;
|
|
|
|
struct btrfs_key ins_key;
|
|
|
|
struct btrfs_path path;
|
|
|
|
struct btrfs_extent_item *ei;
|
|
|
|
|
|
|
|
btrfs_init_path(&path);
|
|
|
|
|
|
|
|
ins_key.objectid = objectid;
|
|
|
|
ins_key.offset = 0;
|
|
|
|
btrfs_set_key_type(&ins_key, BTRFS_EXTENT_DATA_KEY);
|
|
|
|
ret = btrfs_insert_empty_item(trans, root, &path, &ins_key,
|
|
|
|
sizeof(*fi));
|
|
|
|
if (ret)
|
|
|
|
goto fail;
|
|
|
|
leaf = path.nodes[0];
|
|
|
|
fi = btrfs_item_ptr(leaf, path.slots[0],
|
|
|
|
struct btrfs_file_extent_item);
|
|
|
|
btrfs_set_file_extent_generation(leaf, fi, trans->transid);
|
|
|
|
btrfs_set_file_extent_type(leaf, fi, BTRFS_FILE_EXTENT_REG);
|
|
|
|
btrfs_set_file_extent_disk_bytenr(leaf, fi, disk_bytenr);
|
|
|
|
btrfs_set_file_extent_disk_num_bytes(leaf, fi, num_bytes);
|
|
|
|
btrfs_set_file_extent_offset(leaf, fi, 0);
|
|
|
|
btrfs_set_file_extent_num_bytes(leaf, fi, num_bytes);
|
|
|
|
btrfs_set_file_extent_ram_bytes(leaf, fi, num_bytes);
|
|
|
|
btrfs_set_file_extent_compression(leaf, fi, 0);
|
|
|
|
btrfs_set_file_extent_encryption(leaf, fi, 0);
|
|
|
|
btrfs_set_file_extent_other_encoding(leaf, fi, 0);
|
|
|
|
btrfs_mark_buffer_dirty(leaf);
|
|
|
|
|
|
|
|
btrfs_release_path(root, &path);
|
|
|
|
|
|
|
|
ins_key.objectid = disk_bytenr;
|
|
|
|
ins_key.offset = num_bytes;
|
|
|
|
ins_key.type = BTRFS_EXTENT_ITEM_KEY;
|
|
|
|
|
|
|
|
ret = btrfs_insert_empty_item(trans, extent_root, &path,
|
|
|
|
&ins_key, sizeof(*ei));
|
|
|
|
if (ret == 0) {
|
|
|
|
leaf = path.nodes[0];
|
|
|
|
ei = btrfs_item_ptr(leaf, path.slots[0],
|
|
|
|
struct btrfs_extent_item);
|
|
|
|
|
|
|
|
btrfs_set_extent_refs(leaf, ei, 0);
|
|
|
|
btrfs_set_extent_generation(leaf, ei, trans->transid);
|
|
|
|
btrfs_set_extent_flags(leaf, ei, BTRFS_EXTENT_FLAG_DATA);
|
|
|
|
|
|
|
|
btrfs_mark_buffer_dirty(leaf);
|
|
|
|
ret = btrfs_update_block_group(trans, root, disk_bytenr,
|
|
|
|
num_bytes, 1, 0);
|
|
|
|
if (ret)
|
|
|
|
goto fail;
|
|
|
|
} else if (ret != -EEXIST) {
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = btrfs_inc_extent_ref(trans, root, disk_bytenr, num_bytes, 0,
|
|
|
|
root->root_key.objectid,
|
|
|
|
objectid, 0);
|
|
|
|
fail:
|
|
|
|
btrfs_release_path(root, &path);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int add_symbolic_link(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_root *root,
|
|
|
|
u64 objectid, const char *path_name)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
u64 sectorsize = root->sectorsize;
|
|
|
|
char *buf = malloc(sectorsize);
|
|
|
|
|
|
|
|
ret = readlink(path_name, buf, sectorsize);
|
|
|
|
if (ret <= 0) {
|
|
|
|
fprintf(stderr, "readlink failed for %s\n", path_name);
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
if (ret > sectorsize) {
|
|
|
|
fprintf(stderr, "symlink too long for %s", path_name);
|
|
|
|
ret = -1;
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
ret = btrfs_insert_inline_extent(trans, root, objectid, 0,
|
|
|
|
buf, ret + 1);
|
|
|
|
fail:
|
|
|
|
free(buf);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int add_file_items(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_root *root,
|
|
|
|
struct btrfs_inode_item *btrfs_inode, u64 objectid,
|
|
|
|
ino_t parent_inum, struct stat *st,
|
|
|
|
const char *path_name, int out_fd)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
ssize_t ret_read;
|
|
|
|
u64 bytes_read = 0;
|
|
|
|
char *buffer = NULL;
|
|
|
|
struct btrfs_key key;
|
|
|
|
int blocks;
|
|
|
|
u32 sectorsize = root->sectorsize;
|
|
|
|
u64 first_block = 0;
|
|
|
|
u64 num_blocks = 0;
|
|
|
|
int fd;
|
|
|
|
|
|
|
|
fd = open(path_name, O_RDONLY);
|
|
|
|
if (fd == -1) {
|
|
|
|
fprintf(stderr, "%s open failed\n", path_name);
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
|
|
|
|
blocks = st->st_size / sectorsize;
|
|
|
|
if (st->st_size % sectorsize)
|
|
|
|
blocks += 1;
|
|
|
|
|
|
|
|
if (st->st_size <= BTRFS_MAX_INLINE_DATA_SIZE(root)) {
|
|
|
|
buffer = malloc(st->st_size);
|
|
|
|
ret_read = pread64(fd, buffer, st->st_size, bytes_read);
|
|
|
|
if (ret_read == -1) {
|
|
|
|
fprintf(stderr, "%s read failed\n", path_name);
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = btrfs_insert_inline_extent(trans, root, objectid, 0,
|
|
|
|
buffer, st->st_size);
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = custom_alloc_extent(root, blocks * sectorsize, 0, &key);
|
|
|
|
if (ret)
|
|
|
|
goto end;
|
|
|
|
|
|
|
|
first_block = key.objectid;
|
|
|
|
bytes_read = 0;
|
|
|
|
buffer = malloc(sectorsize);
|
|
|
|
|
|
|
|
do {
|
|
|
|
memset(buffer, 0, sectorsize);
|
|
|
|
ret_read = pread64(fd, buffer, sectorsize, bytes_read);
|
|
|
|
if (ret_read == -1) {
|
|
|
|
fprintf(stderr, "%s read failed\n", path_name);
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = pwrite64(out_fd, buffer, sectorsize,
|
|
|
|
first_block + bytes_read);
|
|
|
|
if (ret != sectorsize) {
|
|
|
|
fprintf(stderr, "output file write failed\n");
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* checksum for file data */
|
|
|
|
ret = btrfs_csum_file_block(trans, root->fs_info->csum_root,
|
|
|
|
first_block + (blocks * sectorsize),
|
|
|
|
first_block + bytes_read,
|
|
|
|
buffer, sectorsize);
|
|
|
|
if (ret) {
|
|
|
|
fprintf(stderr, "%s checksum failed\n", path_name);
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
|
|
|
|
bytes_read += ret_read;
|
|
|
|
num_blocks++;
|
|
|
|
} while (ret_read == sectorsize);
|
|
|
|
|
|
|
|
if (num_blocks > 0) {
|
|
|
|
ret = record_file_extent(trans, root, objectid, btrfs_inode,
|
|
|
|
first_block, first_block,
|
|
|
|
blocks * sectorsize);
|
|
|
|
if (ret)
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
|
|
|
|
end:
|
|
|
|
if (buffer)
|
|
|
|
free(buffer);
|
|
|
|
close(fd);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static char *make_path(char *dir, char *name)
|
|
|
|
{
|
|
|
|
char *path;
|
|
|
|
|
|
|
|
path = malloc(strlen(dir) + strlen(name) + 2);
|
|
|
|
if (!path)
|
|
|
|
return NULL;
|
|
|
|
strcpy(path, dir);
|
|
|
|
if (dir[strlen(dir) - 1] != '/')
|
|
|
|
strcat(path, "/");
|
|
|
|
strcat(path, name);
|
|
|
|
return path;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int traverse_directory(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_root *root, char *dir_name,
|
|
|
|
struct directory_name_entry *dir_head, int out_fd)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
struct btrfs_inode_item cur_inode;
|
|
|
|
struct btrfs_inode_item *inode_item;
|
|
|
|
int count, i, dir_index_cnt;
|
|
|
|
struct direct **files;
|
|
|
|
struct stat st;
|
|
|
|
struct directory_name_entry *dir_entry, *parent_dir_entry;
|
|
|
|
struct direct *cur_file;
|
|
|
|
ino_t parent_inum, cur_inum;
|
|
|
|
ino_t highest_inum = 0;
|
|
|
|
char *parent_dir_name;
|
|
|
|
struct btrfs_path path;
|
|
|
|
struct extent_buffer *leaf;
|
|
|
|
struct btrfs_key root_dir_key;
|
|
|
|
u64 root_dir_inode_size = 0;
|
|
|
|
|
|
|
|
/* Add list for source directory */
|
|
|
|
dir_entry = malloc(sizeof(struct directory_name_entry));
|
|
|
|
dir_entry->dir_name = dir_name;
|
|
|
|
dir_entry->path = malloc(strlen(dir_name) + 1);
|
|
|
|
strcpy(dir_entry->path, dir_name);
|
|
|
|
|
|
|
|
parent_inum = highest_inum + BTRFS_FIRST_FREE_OBJECTID;
|
|
|
|
dir_entry->inum = parent_inum;
|
|
|
|
list_add_tail(&dir_entry->list, &dir_head->list);
|
|
|
|
|
|
|
|
btrfs_init_path(&path);
|
|
|
|
|
|
|
|
root_dir_key.objectid = btrfs_root_dirid(&root->root_item);
|
|
|
|
root_dir_key.offset = 0;
|
|
|
|
btrfs_set_key_type(&root_dir_key, BTRFS_INODE_ITEM_KEY);
|
|
|
|
ret = btrfs_lookup_inode(trans, root, &path, &root_dir_key, 1);
|
|
|
|
if (ret) {
|
|
|
|
fprintf(stderr, "root dir lookup error\n");
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
|
|
|
leaf = path.nodes[0];
|
|
|
|
inode_item = btrfs_item_ptr(leaf, path.slots[0],
|
|
|
|
struct btrfs_inode_item);
|
|
|
|
|
|
|
|
root_dir_inode_size = calculate_dir_inode_size(dir_name);
|
|
|
|
btrfs_set_inode_size(leaf, inode_item, root_dir_inode_size);
|
|
|
|
btrfs_mark_buffer_dirty(leaf);
|
|
|
|
|
|
|
|
btrfs_release_path(root, &path);
|
|
|
|
|
|
|
|
do {
|
|
|
|
parent_dir_entry = list_entry(dir_head->list.next,
|
|
|
|
struct directory_name_entry,
|
|
|
|
list);
|
|
|
|
list_del(&parent_dir_entry->list);
|
|
|
|
|
|
|
|
parent_inum = parent_dir_entry->inum;
|
|
|
|
parent_dir_name = parent_dir_entry->dir_name;
|
|
|
|
if (chdir(parent_dir_entry->path)) {
|
|
|
|
fprintf(stderr, "chdir error for %s\n",
|
|
|
|
parent_dir_name);
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
|
|
|
count = scandir(parent_dir_entry->path, &files,
|
|
|
|
directory_select, NULL);
|
2011-06-04 08:19:18 +00:00
|
|
|
if (count == -1)
|
|
|
|
{
|
|
|
|
fprintf(stderr, "scandir for %s failed: %s\n",
|
|
|
|
parent_dir_name, strerror (errno));
|
|
|
|
goto fail;
|
|
|
|
}
|
2010-07-08 09:17:59 +00:00
|
|
|
|
|
|
|
for (i = 0; i < count; i++) {
|
|
|
|
cur_file = files[i];
|
|
|
|
|
|
|
|
if (lstat(cur_file->d_name, &st) == -1) {
|
|
|
|
fprintf(stderr, "lstat failed for file %s\n",
|
|
|
|
cur_file->d_name);
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
|
|
|
cur_inum = ++highest_inum + BTRFS_FIRST_FREE_OBJECTID;
|
|
|
|
ret = add_directory_items(trans, root,
|
|
|
|
cur_inum, parent_inum,
|
|
|
|
cur_file->d_name,
|
|
|
|
&st, &dir_index_cnt);
|
|
|
|
if (ret) {
|
|
|
|
fprintf(stderr, "add_directory_items failed\n");
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = add_inode_items(trans, root, &st,
|
|
|
|
cur_file->d_name, cur_inum,
|
|
|
|
parent_inum, dir_index_cnt,
|
|
|
|
&cur_inode);
|
|
|
|
if (ret) {
|
|
|
|
fprintf(stderr, "add_inode_items failed\n");
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = add_xattr_item(trans, root,
|
|
|
|
cur_inum, cur_file->d_name);
|
|
|
|
if (ret) {
|
|
|
|
fprintf(stderr, "add_xattr_item failed\n");
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (S_ISDIR(st.st_mode)) {
|
|
|
|
dir_entry = malloc(sizeof(struct directory_name_entry));
|
|
|
|
dir_entry->dir_name = cur_file->d_name;
|
|
|
|
dir_entry->path = make_path(parent_dir_entry->path,
|
|
|
|
cur_file->d_name);
|
|
|
|
dir_entry->inum = cur_inum;
|
|
|
|
list_add_tail(&dir_entry->list, &dir_head->list);
|
|
|
|
} else if (S_ISREG(st.st_mode)) {
|
|
|
|
ret = add_file_items(trans, root, &cur_inode,
|
|
|
|
cur_inum, parent_inum, &st,
|
|
|
|
cur_file->d_name, out_fd);
|
|
|
|
if (ret) {
|
|
|
|
fprintf(stderr, "add_file_items failed\n");
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
} else if (S_ISLNK(st.st_mode)) {
|
|
|
|
ret = add_symbolic_link(trans, root,
|
|
|
|
cur_inum, cur_file->d_name);
|
|
|
|
if (ret) {
|
|
|
|
fprintf(stderr, "add_symbolic_link failed\n");
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
free(parent_dir_entry->path);
|
|
|
|
free(parent_dir_entry);
|
|
|
|
|
|
|
|
index_cnt = 2;
|
|
|
|
|
|
|
|
} while (!list_empty(&dir_head->list));
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
fail:
|
|
|
|
free(parent_dir_entry->path);
|
|
|
|
free(parent_dir_entry);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int open_target(char *output_name)
|
|
|
|
{
|
|
|
|
int output_fd;
|
|
|
|
output_fd = open(output_name, O_CREAT | O_RDWR | O_TRUNC,
|
|
|
|
S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH);
|
|
|
|
|
|
|
|
return output_fd;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int create_chunks(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_root *root, u64 num_of_meta_chunks,
|
|
|
|
u64 size_of_data)
|
|
|
|
{
|
|
|
|
u64 chunk_start;
|
|
|
|
u64 chunk_size;
|
|
|
|
u64 meta_type = BTRFS_BLOCK_GROUP_METADATA;
|
|
|
|
u64 data_type = BTRFS_BLOCK_GROUP_DATA;
|
|
|
|
u64 minimum_data_chunk_size = 64 * 1024 * 1024;
|
|
|
|
u64 i;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
for (i = 0; i < num_of_meta_chunks; i++) {
|
|
|
|
ret = btrfs_alloc_chunk(trans, root->fs_info->extent_root,
|
|
|
|
&chunk_start, &chunk_size, meta_type);
|
|
|
|
BUG_ON(ret);
|
|
|
|
ret = btrfs_make_block_group(trans, root->fs_info->extent_root, 0,
|
|
|
|
meta_type, BTRFS_FIRST_CHUNK_TREE_OBJECTID,
|
|
|
|
chunk_start, chunk_size);
|
|
|
|
BUG_ON(ret);
|
|
|
|
set_extent_dirty(&root->fs_info->free_space_cache,
|
|
|
|
chunk_start, chunk_start + chunk_size - 1, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (size_of_data < minimum_data_chunk_size)
|
|
|
|
size_of_data = minimum_data_chunk_size;
|
|
|
|
ret = btrfs_alloc_data_chunk(trans, root->fs_info->extent_root,
|
|
|
|
&chunk_start, size_of_data, data_type);
|
|
|
|
BUG_ON(ret);
|
|
|
|
ret = btrfs_make_block_group(trans, root->fs_info->extent_root, 0,
|
|
|
|
data_type, BTRFS_FIRST_CHUNK_TREE_OBJECTID,
|
|
|
|
chunk_start, size_of_data);
|
|
|
|
BUG_ON(ret);
|
|
|
|
set_extent_dirty(&root->fs_info->free_space_cache,
|
|
|
|
chunk_start, chunk_start + size_of_data - 1, 0);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int make_image(char *source_dir, struct btrfs_root *root, int out_fd)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
struct btrfs_trans_handle *trans;
|
|
|
|
|
|
|
|
struct stat root_st;
|
|
|
|
int root_len;
|
|
|
|
|
|
|
|
struct directory_name_entry dir_head;
|
|
|
|
|
|
|
|
ret = lstat(source_dir, &root_st);
|
|
|
|
if (ret) {
|
|
|
|
fprintf(stderr, "unable to lstat the %s\n", source_dir);
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
|
|
|
root_len = strlen(source_dir);
|
|
|
|
|
|
|
|
INIT_LIST_HEAD(&dir_head.list);
|
|
|
|
|
|
|
|
trans = btrfs_start_transaction(root, 1);
|
|
|
|
ret = traverse_directory(trans, root, source_dir, &dir_head, out_fd);
|
|
|
|
if (ret) {
|
|
|
|
fprintf(stderr, "unable to traverse_directory\n");
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
btrfs_commit_transaction(trans, root);
|
|
|
|
|
|
|
|
printf("Making image is completed.\n");
|
|
|
|
return 0;
|
|
|
|
fail:
|
|
|
|
fprintf(stderr, "Making image is aborted.\n");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static u64 size_sourcedir(char *dir_name, u64 sectorsize,
|
|
|
|
u64 *num_of_meta_chunks_ret, u64 *size_of_data_ret)
|
|
|
|
{
|
|
|
|
u64 dir_size = 0;
|
|
|
|
u64 total_size = 0;
|
|
|
|
int ret;
|
|
|
|
char command[1024];
|
|
|
|
char path[512];
|
|
|
|
char *file_name = "temp_file";
|
|
|
|
FILE *file;
|
|
|
|
u64 minimum_data_size = 256 * 1024 * 1024; /* 256MB */
|
|
|
|
u64 default_chunk_size = 8 * 1024 * 1024; /* 8MB */
|
|
|
|
u64 allocated_meta_size = 8 * 1024 * 1024; /* 8MB */
|
|
|
|
u64 allocated_total_size = 20 * 1024 * 1024; /* 20MB */
|
|
|
|
u64 num_of_meta_chunks = 0;
|
|
|
|
u64 num_of_allocated_meta_chunks =
|
|
|
|
allocated_meta_size / default_chunk_size;
|
|
|
|
|
|
|
|
ret = sprintf(command, "du -B 4096 -s ");
|
|
|
|
if (ret < 0) {
|
|
|
|
fprintf(stderr, "error executing sprintf for du command\n");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
strcat(command, dir_name);
|
|
|
|
strcat(command, " > ");
|
|
|
|
strcat(command, file_name);
|
|
|
|
ret = system(command);
|
|
|
|
|
|
|
|
file = fopen(file_name, "r");
|
|
|
|
ret = fscanf(file, "%lld %s\n", &dir_size, path);
|
|
|
|
fclose(file);
|
|
|
|
remove(file_name);
|
|
|
|
|
|
|
|
dir_size *= sectorsize;
|
|
|
|
*size_of_data_ret = dir_size;
|
|
|
|
|
|
|
|
num_of_meta_chunks = (dir_size / 2) / default_chunk_size;
|
|
|
|
if (((dir_size / 2) % default_chunk_size) != 0)
|
|
|
|
num_of_meta_chunks++;
|
|
|
|
if (num_of_meta_chunks <= num_of_allocated_meta_chunks)
|
|
|
|
num_of_meta_chunks = 0;
|
|
|
|
else
|
|
|
|
num_of_meta_chunks -= num_of_allocated_meta_chunks;
|
|
|
|
|
|
|
|
total_size = allocated_total_size + dir_size +
|
|
|
|
(num_of_meta_chunks * default_chunk_size);
|
|
|
|
|
|
|
|
*num_of_meta_chunks_ret = num_of_meta_chunks;
|
|
|
|
|
|
|
|
if (total_size < minimum_data_size)
|
|
|
|
total_size = minimum_data_size;
|
|
|
|
|
|
|
|
return total_size;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int zero_output_file(int out_fd, u64 size, u32 sectorsize)
|
|
|
|
{
|
|
|
|
int len = sectorsize;
|
|
|
|
int loop_num = size / sectorsize;
|
|
|
|
u64 location = 0;
|
|
|
|
char *buf = malloc(len);
|
|
|
|
int ret = 0, i;
|
|
|
|
ssize_t written;
|
|
|
|
|
|
|
|
if (!buf)
|
|
|
|
return -ENOMEM;
|
|
|
|
memset(buf, 0, len);
|
|
|
|
for (i = 0; i < loop_num; i++) {
|
|
|
|
written = pwrite64(out_fd, buf, len, location);
|
|
|
|
if (written != len)
|
|
|
|
ret = -EIO;
|
|
|
|
location += sectorsize;
|
|
|
|
}
|
|
|
|
free(buf);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2007-03-21 00:35:03 +00:00
|
|
|
int main(int ac, char **av)
|
|
|
|
{
|
|
|
|
char *file;
|
2008-04-18 14:31:42 +00:00
|
|
|
struct btrfs_root *root;
|
|
|
|
struct btrfs_trans_handle *trans;
|
|
|
|
char *label = NULL;
|
2008-04-22 18:06:31 +00:00
|
|
|
char *first_file;
|
2007-03-21 00:35:03 +00:00
|
|
|
u64 block_count = 0;
|
2008-03-24 19:04:49 +00:00
|
|
|
u64 dev_block_count = 0;
|
Btrfs: move data checksumming into a dedicated tree
Btrfs stores checksums for each data block. Until now, they have
been stored in the subvolume trees, indexed by the inode that is
referencing the data block. This means that when we read the inode,
we've probably read in at least some checksums as well.
But, this has a few problems:
* The checksums are indexed by logical offset in the file. When
compression is on, this means we have to do the expensive checksumming
on the uncompressed data. It would be faster if we could checksum
the compressed data instead.
* If we implement encryption, we'll be checksumming the plain text and
storing that on disk. This is significantly less secure.
* For either compression or encryption, we have to get the plain text
back before we can verify the checksum as correct. This makes the raid
layer balancing and extent moving much more expensive.
* It makes the front end caching code more complex, as we have touch
the subvolume and inodes as we cache extents.
* There is potentitally one copy of the checksum in each subvolume
referencing an extent.
The solution used here is to store the extent checksums in a dedicated
tree. This allows us to index the checksums by phyiscal extent
start and length. It means:
* The checksum is against the data stored on disk, after any compression
or encryption is done.
* The checksum is stored in a central location, and can be verified without
following back references, or reading inodes.
This makes compression significantly faster by reducing the amount of
data that needs to be checksummed. It will also allow much faster
raid management code in general.
The checksums are indexed by a key with a fixed objectid (a magic value
in ctree.h) and offset set to the starting byte of the extent. This
allows us to copy the checksum items into the fsync log tree directly (or
any other tree), without having to invent a second format for them.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-12-08 22:00:31 +00:00
|
|
|
u64 blocks[7];
|
2008-05-01 14:22:47 +00:00
|
|
|
u64 alloc_start = 0;
|
2008-04-18 14:31:42 +00:00
|
|
|
u64 metadata_profile = BTRFS_BLOCK_GROUP_RAID1 | BTRFS_BLOCK_GROUP_DUP;
|
|
|
|
u64 data_profile = BTRFS_BLOCK_GROUP_RAID0;
|
2008-04-09 23:49:01 +00:00
|
|
|
u32 leafsize = getpagesize();
|
2007-10-15 20:25:14 +00:00
|
|
|
u32 sectorsize = 4096;
|
2008-04-09 23:49:01 +00:00
|
|
|
u32 nodesize = leafsize;
|
2007-11-30 16:30:24 +00:00
|
|
|
u32 stripesize = 4096;
|
2008-03-24 19:04:49 +00:00
|
|
|
int zero_end = 1;
|
2008-04-01 15:08:13 +00:00
|
|
|
int option_index = 0;
|
2008-04-18 14:31:42 +00:00
|
|
|
int fd;
|
|
|
|
int ret;
|
|
|
|
int i;
|
2010-12-09 18:31:08 +00:00
|
|
|
int mixed = 0;
|
|
|
|
int data_profile_opt = 0;
|
|
|
|
int metadata_profile_opt = 0;
|
2007-03-21 15:13:29 +00:00
|
|
|
|
2010-07-08 09:17:59 +00:00
|
|
|
char *source_dir = NULL;
|
|
|
|
int source_dir_set = 0;
|
|
|
|
char *output = "output.img";
|
|
|
|
u64 num_of_meta_chunks = 0;
|
|
|
|
u64 size_of_data = 0;
|
|
|
|
|
2007-10-15 20:25:14 +00:00
|
|
|
while(1) {
|
|
|
|
int c;
|
2010-07-08 09:17:59 +00:00
|
|
|
c = getopt_long(ac, av, "A:b:l:n:s:m:d:L:r:VM", long_options,
|
2008-04-01 15:08:13 +00:00
|
|
|
&option_index);
|
2007-10-15 20:25:14 +00:00
|
|
|
if (c < 0)
|
|
|
|
break;
|
|
|
|
switch(c) {
|
2008-04-25 20:55:21 +00:00
|
|
|
case 'A':
|
|
|
|
alloc_start = parse_size(optarg);
|
|
|
|
break;
|
2008-04-03 20:35:48 +00:00
|
|
|
case 'd':
|
|
|
|
data_profile = parse_profile(optarg);
|
2010-12-09 18:31:08 +00:00
|
|
|
data_profile_opt = 1;
|
2008-04-03 20:35:48 +00:00
|
|
|
break;
|
2007-10-15 20:25:14 +00:00
|
|
|
case 'l':
|
2007-12-21 21:25:35 +00:00
|
|
|
leafsize = parse_size(optarg);
|
2007-10-15 20:25:14 +00:00
|
|
|
break;
|
2008-04-18 14:31:42 +00:00
|
|
|
case 'L':
|
|
|
|
label = parse_label(optarg);
|
|
|
|
break;
|
|
|
|
case 'm':
|
|
|
|
metadata_profile = parse_profile(optarg);
|
2010-12-09 18:31:08 +00:00
|
|
|
metadata_profile_opt = 1;
|
|
|
|
break;
|
|
|
|
case 'M':
|
|
|
|
mixed = 1;
|
2008-04-18 14:31:42 +00:00
|
|
|
break;
|
2007-10-15 20:25:14 +00:00
|
|
|
case 'n':
|
2007-12-21 21:25:35 +00:00
|
|
|
nodesize = parse_size(optarg);
|
2007-10-15 20:25:14 +00:00
|
|
|
break;
|
2007-11-30 16:30:24 +00:00
|
|
|
case 's':
|
2008-04-01 15:08:13 +00:00
|
|
|
sectorsize = parse_size(optarg);
|
2007-11-30 16:30:24 +00:00
|
|
|
break;
|
2008-03-24 19:04:49 +00:00
|
|
|
case 'b':
|
|
|
|
block_count = parse_size(optarg);
|
2010-12-09 18:31:08 +00:00
|
|
|
if (block_count <= 1024*1024*1024) {
|
|
|
|
printf("SMALL VOLUME: forcing mixed "
|
|
|
|
"metadata/data groups\n");
|
|
|
|
mixed = 1;
|
2009-01-07 19:57:12 +00:00
|
|
|
}
|
2008-03-24 19:04:49 +00:00
|
|
|
zero_end = 0;
|
|
|
|
break;
|
2009-06-03 16:00:20 +00:00
|
|
|
case 'V':
|
|
|
|
print_version();
|
|
|
|
break;
|
2010-07-08 09:17:59 +00:00
|
|
|
case 'r':
|
|
|
|
source_dir = optarg;
|
|
|
|
source_dir_set = 1;
|
|
|
|
break;
|
2007-10-15 20:25:14 +00:00
|
|
|
default:
|
|
|
|
print_usage();
|
|
|
|
}
|
|
|
|
}
|
2008-04-01 15:08:13 +00:00
|
|
|
sectorsize = max(sectorsize, (u32)getpagesize());
|
2007-10-15 20:25:14 +00:00
|
|
|
if (leafsize < sectorsize || (leafsize & (sectorsize - 1))) {
|
|
|
|
fprintf(stderr, "Illegal leafsize %u\n", leafsize);
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
if (nodesize < sectorsize || (nodesize & (sectorsize - 1))) {
|
|
|
|
fprintf(stderr, "Illegal nodesize %u\n", nodesize);
|
|
|
|
exit(1);
|
|
|
|
}
|
2010-07-08 09:17:59 +00:00
|
|
|
if (source_dir_set)
|
|
|
|
ac++;
|
2007-10-15 20:25:14 +00:00
|
|
|
ac = ac - optind;
|
2008-03-24 19:04:49 +00:00
|
|
|
if (ac == 0)
|
2007-10-15 20:25:14 +00:00
|
|
|
print_usage();
|
2008-03-24 19:04:49 +00:00
|
|
|
|
2009-01-11 12:58:35 +00:00
|
|
|
printf("\nWARNING! - %s IS EXPERIMENTAL\n", BTRFS_BUILD_VERSION);
|
|
|
|
printf("WARNING! - see http://btrfs.wiki.kernel.org before using\n\n");
|
|
|
|
|
2010-07-08 09:17:59 +00:00
|
|
|
if (source_dir == 0) {
|
|
|
|
file = av[optind++];
|
|
|
|
ret = check_mounted(file);
|
|
|
|
if (ret < 0) {
|
|
|
|
fprintf(stderr, "error checking %s mount status\n", file);
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
if (ret == 1) {
|
|
|
|
fprintf(stderr, "%s is mounted\n", file);
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
ac--;
|
|
|
|
fd = open(file, O_RDWR);
|
|
|
|
if (fd < 0) {
|
|
|
|
fprintf(stderr, "unable to open %s\n", file);
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
first_file = file;
|
|
|
|
ret = btrfs_prepare_device(fd, file, zero_end, &dev_block_count, &mixed);
|
|
|
|
if (block_count == 0)
|
|
|
|
block_count = dev_block_count;
|
|
|
|
} else {
|
|
|
|
ac = 0;
|
|
|
|
fd = open_target(output);
|
|
|
|
if (fd < 0) {
|
|
|
|
fprintf(stderr, "unable to open the %s\n", file);
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
|
|
|
|
file = output;
|
|
|
|
first_file = file;
|
|
|
|
block_count = size_sourcedir(source_dir, sectorsize,
|
|
|
|
&num_of_meta_chunks, &size_of_data);
|
|
|
|
ret = zero_output_file(fd, block_count, sectorsize);
|
|
|
|
if (ret) {
|
|
|
|
fprintf(stderr, "unable to zero the output file\n");
|
|
|
|
exit(1);
|
|
|
|
}
|
2007-03-21 00:35:03 +00:00
|
|
|
}
|
2010-12-09 18:31:08 +00:00
|
|
|
if (mixed) {
|
|
|
|
if (!metadata_profile_opt)
|
|
|
|
metadata_profile = 0;
|
|
|
|
if (!data_profile_opt)
|
|
|
|
data_profile = 0;
|
|
|
|
|
|
|
|
if (metadata_profile != data_profile) {
|
|
|
|
fprintf(stderr, "With mixed block groups data and metadata "
|
|
|
|
"profiles must be the same\n");
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
}
|
2008-02-15 16:19:26 +00:00
|
|
|
|
2008-12-05 17:21:31 +00:00
|
|
|
blocks[0] = BTRFS_SUPER_INFO_OFFSET;
|
|
|
|
for (i = 1; i < 7; i++) {
|
|
|
|
blocks[i] = BTRFS_SUPER_INFO_OFFSET + 1024 * 1024 +
|
|
|
|
leafsize * i;
|
|
|
|
}
|
2008-02-15 16:19:26 +00:00
|
|
|
|
2008-04-18 14:31:42 +00:00
|
|
|
ret = make_btrfs(fd, file, label, blocks, block_count,
|
|
|
|
nodesize, leafsize,
|
2008-01-04 15:38:22 +00:00
|
|
|
sectorsize, stripesize);
|
2007-03-21 00:35:03 +00:00
|
|
|
if (ret) {
|
|
|
|
fprintf(stderr, "error during mkfs %d\n", ret);
|
|
|
|
exit(1);
|
|
|
|
}
|
2008-09-23 16:29:10 +00:00
|
|
|
root = open_ctree(file, 0, O_RDWR);
|
|
|
|
root->fs_info->alloc_start = alloc_start;
|
|
|
|
|
2010-12-09 18:31:08 +00:00
|
|
|
ret = make_root_dir(root, mixed);
|
2007-03-21 15:13:29 +00:00
|
|
|
if (ret) {
|
|
|
|
fprintf(stderr, "failed to setup the root directory\n");
|
|
|
|
exit(1);
|
|
|
|
}
|
2008-09-23 16:29:10 +00:00
|
|
|
|
2008-04-03 20:35:48 +00:00
|
|
|
trans = btrfs_start_transaction(root, 1);
|
|
|
|
|
2008-03-24 19:04:49 +00:00
|
|
|
if (ac == 0)
|
2008-04-03 20:35:48 +00:00
|
|
|
goto raid_groups;
|
2008-03-24 19:04:49 +00:00
|
|
|
|
2008-03-24 19:05:44 +00:00
|
|
|
btrfs_register_one_device(file);
|
2008-03-24 19:04:49 +00:00
|
|
|
if (!root) {
|
|
|
|
fprintf(stderr, "ctree init failed\n");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
zero_end = 1;
|
|
|
|
while(ac-- > 0) {
|
2010-12-09 18:31:08 +00:00
|
|
|
int old_mixed = mixed;
|
|
|
|
|
2008-03-24 19:04:49 +00:00
|
|
|
file = av[optind++];
|
2008-04-01 14:36:46 +00:00
|
|
|
ret = check_mounted(file);
|
|
|
|
if (ret < 0) {
|
|
|
|
fprintf(stderr, "error checking %s mount status\n",
|
|
|
|
file);
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
if (ret == 1) {
|
|
|
|
fprintf(stderr, "%s is mounted\n", file);
|
|
|
|
exit(1);
|
|
|
|
}
|
2008-03-24 19:04:49 +00:00
|
|
|
fd = open(file, O_RDWR);
|
|
|
|
if (fd < 0) {
|
|
|
|
fprintf(stderr, "unable to open %s\n", file);
|
|
|
|
exit(1);
|
|
|
|
}
|
2008-04-18 14:45:17 +00:00
|
|
|
ret = btrfs_device_already_in_root(root, fd,
|
|
|
|
BTRFS_SUPER_INFO_OFFSET);
|
|
|
|
if (ret) {
|
|
|
|
fprintf(stderr, "skipping duplicate device %s in FS\n",
|
|
|
|
file);
|
|
|
|
close(fd);
|
|
|
|
continue;
|
|
|
|
}
|
2008-03-24 19:04:49 +00:00
|
|
|
ret = btrfs_prepare_device(fd, file, zero_end,
|
2010-12-09 18:31:08 +00:00
|
|
|
&dev_block_count, &mixed);
|
|
|
|
mixed = old_mixed;
|
2008-03-24 19:04:49 +00:00
|
|
|
BUG_ON(ret);
|
|
|
|
|
2008-04-18 14:31:42 +00:00
|
|
|
ret = btrfs_add_to_fsid(trans, root, fd, file, dev_block_count,
|
2008-03-24 19:04:49 +00:00
|
|
|
sectorsize, sectorsize, sectorsize);
|
|
|
|
BUG_ON(ret);
|
2008-03-24 19:05:44 +00:00
|
|
|
btrfs_register_one_device(file);
|
2008-03-24 19:04:49 +00:00
|
|
|
}
|
2008-04-03 20:35:48 +00:00
|
|
|
|
2008-04-03 20:35:48 +00:00
|
|
|
raid_groups:
|
2010-07-08 09:17:59 +00:00
|
|
|
if (!source_dir_set) {
|
|
|
|
ret = create_raid_groups(trans, root, data_profile,
|
2010-12-09 18:31:08 +00:00
|
|
|
metadata_profile, mixed);
|
2010-07-08 09:17:59 +00:00
|
|
|
BUG_ON(ret);
|
|
|
|
}
|
2008-04-22 18:06:31 +00:00
|
|
|
|
2008-09-26 14:26:53 +00:00
|
|
|
ret = create_data_reloc_tree(trans, root);
|
|
|
|
BUG_ON(ret);
|
|
|
|
|
2010-12-09 18:31:08 +00:00
|
|
|
if (mixed) {
|
|
|
|
struct btrfs_super_block *super = &root->fs_info->super_copy;
|
|
|
|
u64 flags = btrfs_super_incompat_flags(super);
|
|
|
|
|
|
|
|
flags |= BTRFS_FEATURE_INCOMPAT_MIXED_GROUPS;
|
|
|
|
btrfs_set_super_incompat_flags(super, flags);
|
|
|
|
}
|
|
|
|
|
2008-04-22 18:06:31 +00:00
|
|
|
printf("fs created label %s on %s\n\tnodesize %u leafsize %u "
|
|
|
|
"sectorsize %u size %s\n",
|
|
|
|
label, first_file, nodesize, leafsize, sectorsize,
|
|
|
|
pretty_sizes(btrfs_super_total_bytes(&root->fs_info->super_copy)));
|
|
|
|
|
2008-07-24 16:13:30 +00:00
|
|
|
printf("%s\n", BTRFS_BUILD_VERSION);
|
2008-03-24 19:04:49 +00:00
|
|
|
btrfs_commit_transaction(trans, root);
|
2010-07-08 09:17:59 +00:00
|
|
|
|
|
|
|
if (source_dir_set) {
|
|
|
|
trans = btrfs_start_transaction(root, 1);
|
|
|
|
ret = create_chunks(trans, root,
|
|
|
|
num_of_meta_chunks, size_of_data);
|
|
|
|
BUG_ON(ret);
|
|
|
|
btrfs_commit_transaction(trans, root);
|
|
|
|
|
|
|
|
ret = make_image(source_dir, root, fd);
|
|
|
|
BUG_ON(ret);
|
|
|
|
}
|
|
|
|
|
2008-03-24 19:04:49 +00:00
|
|
|
ret = close_ctree(root);
|
|
|
|
BUG_ON(ret);
|
2008-04-22 18:06:31 +00:00
|
|
|
|
|
|
|
free(label);
|
2007-03-21 00:35:03 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|