marko10_000
/
btrfs-progs
forked from Mirrors/btrfs-progs
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Walk all block devices looking for btrfs

master
Chris Mason 2008-03-24 15:05:44 -04:00 committed by David Woodhouse
parent 26afd0f31d
commit 0dcfa3b827
12 changed files with 393 additions and 61 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
Makefile
View File

@ -4,7 +4,7 @@ CFLAGS = -g -Werror
objects = ctree.o disk-io.o radix-tree.o extent-tree.o print-tree.o \
root-tree.o dir-item.o hash.o file-item.o inode-item.o \
inode-map.o crc32c.o rbtree.o extent-cache.o extent_io.o \
volumes.o
volumes.o utils.o
#
CHECKFLAGS=-D__linux__ -Dlinux -D__STDC__ -Dunix -D__unix__ -Wbitwise \
-Wuninitialized -Wshadow -Wundef
@ -13,6 +13,7 @@ DEPFLAGS = -Wp,-MMD,$(@D)/.$(@F).d,-MT,$@
INSTALL= install
prefix ?= /usr/local
bindir = $(prefix)/bin
LIBS=-luuid
progs = btrfsctl btrfsck mkfs.btrfs debug-tree
@ -30,26 +31,26 @@ endif
all: $(progs)
btrfsctl: btrfsctl.o
gcc $(CFLAGS) -o btrfsctl btrfsctl.o $(LDFLAGS)
btrfsctl: $(objects) btrfsctl.o
gcc $(CFLAGS) -o btrfsctl btrfsctl.o $(objects) $(LDFLAGS) $(LIBS)
btrfsck: $(objects) btrfsck.o bit-radix.o
gcc $(CFLAGS) -o btrfsck btrfsck.o $(objects) bit-radix.o $(LDFLAGS)
gcc $(CFLAGS) -o btrfsck btrfsck.o $(objects) bit-radix.o $(LDFLAGS) $(LIBS)
mkfs.btrfs: $(objects) mkfs.o utils.o
gcc $(CFLAGS) -o mkfs.btrfs $(objects) mkfs.o utils.o -luuid $(LDFLAGS)
mkfs.btrfs: $(objects) mkfs.o
gcc $(CFLAGS) -o mkfs.btrfs $(objects) mkfs.o $(LDFLAGS) $(LIBS)
debug-tree: $(objects) debug-tree.o
gcc $(CFLAGS) -o debug-tree $(objects) debug-tree.o -luuid $(LDFLAGS)
gcc $(CFLAGS) -o debug-tree $(objects) debug-tree.o $(LDFLAGS) $(LIBS)
dir-test: $(objects) dir-test.o
gcc $(CFLAGS) -o dir-test $(objects) dir-test.o $(LDFLAGS)
gcc $(CFLAGS) -o dir-test $(objects) dir-test.o $(LDFLAGS) $(LIBS)
quick-test: $(objects) quick-test.o
gcc $(CFLAGS) -o quick-test $(objects) quick-test.o $(LDFLAGS)
gcc $(CFLAGS) -o quick-test $(objects) quick-test.o $(LDFLAGS) $(LIBS)
convert: $(objects) convert.o utils.o
gcc $(CFLAGS) -o btrfs-convert $(objects) convert.o utils.o -luuid -lext2fs $(LDFLAGS)
convert: $(objects) convert.o
gcc $(CFLAGS) -o btrfs-convert $(objects) convert.o -lext2fs $(LDFLAGS) $(LIBS)
clean :
rm -f $(progs) cscope.out *.o .*.d btrfs-convert

15
btrfsctl.c
View File

@ -29,6 +29,9 @@
#include <unistd.h>
#include <dirent.h>
#include "kerncompat.h"
#include "ctree.h"
#include "transaction.h"
#include "utils.h"
#ifdef __CHECKER__
#define BLKGETSIZE64 0
@ -47,7 +50,8 @@ void print_usage(void)
printf("\t-s snap_name existing_subvol creates a new snapshot\n");
printf("\t-s snap_name tree_root creates a new subvolume\n");
printf("\t-r [+-]size[gkm] resize the FS\n");
printf("\t-a device scans the device for a Btrfs filesystem\n");
printf("\t-A device scans the device for a Btrfs filesystem\n");
printf("\t-a scans all devices for a Btrfs filesystems\n");
exit(1);
}
@ -64,6 +68,11 @@ int main(int ac, char **av)
unsigned long command = 0;
int len;
if (ac == 2 && strcmp(av[1], "-a") == 0) {
fprintf(stderr, "Scanning for Btrfs filesystems\n");
btrfs_scan_one_dir("/dev", 1);
exit(0);
}
for (i = 1; i < ac - 1; i++) {
if (strcmp(av[i], "-s") == 0) {
if (i + 1 >= ac - 1) {
@ -89,9 +98,9 @@ int main(int ac, char **av)
print_usage();
}
command = BTRFS_IOC_DEFRAG;
} else if (strcmp(av[i], "-a") == 0) {
} else if (strcmp(av[i], "-A") == 0) {
if (i >= ac - 1) {
fprintf(stderr, "-a requires an arg\n");
fprintf(stderr, "-A requires an arg\n");
print_usage();
}
command = BTRFS_IOC_SCAN_DEV;

5
ctree.h
View File

@ -27,7 +27,7 @@
struct btrfs_root;
struct btrfs_trans_handle;
#define BTRFS_MAGIC "_B4RfS_M"
#define BTRFS_MAGIC "_B5RfS_M"
#define BTRFS_MAX_LEVEL 8
@ -437,6 +437,7 @@ struct btrfs_extent_ops {
};
struct btrfs_device;
struct btrfs_fs_devices;
struct btrfs_fs_info {
u8 fsid[BTRFS_FSID_SIZE];
struct btrfs_root *fs_root;
@ -466,7 +467,7 @@ struct btrfs_fs_info {
struct btrfs_extent_ops *extent_ops;
struct list_head dirty_cowonly_roots;
struct list_head devices;
struct btrfs_fs_devices *fs_devices;
struct list_head space_info;
int fp;
int force_system_allocs;

50
disk-io.c
View File

@ -31,11 +31,7 @@
#include "volumes.h"
#include "transaction.h"
#include "crc32c.h"
int btrfs_open_device(struct btrfs_device *dev)
{
return 0;
}
#include "utils.h"
int btrfs_map_bh_to_logical(struct btrfs_root *root, struct extent_buffer *buf,
u64 logical)
@ -394,7 +390,7 @@ insert:
return root;
}
struct btrfs_root *open_ctree(char *filename, u64 sb_bytenr)
struct btrfs_root *open_ctree(const char *filename, u64 sb_bytenr)
{
int fp;
@ -402,10 +398,10 @@ struct btrfs_root *open_ctree(char *filename, u64 sb_bytenr)
if (fp < 0) {
return NULL;
}
return open_ctree_fd(fp, sb_bytenr);
return open_ctree_fd(fp, filename, sb_bytenr);
}
struct btrfs_root *open_ctree_fd(int fp, u64 sb_bytenr)
struct btrfs_root *open_ctree_fd(int fp, const char *path, u64 sb_bytenr)
{
u32 sectorsize;
u32 nodesize;
@ -420,11 +416,28 @@ struct btrfs_root *open_ctree_fd(int fp, u64 sb_bytenr)
struct btrfs_fs_info *fs_info = malloc(sizeof(*fs_info));
int ret;
struct btrfs_super_block *disk_super;
struct btrfs_fs_devices *fs_devices = NULL;
u64 total_devs;
if (sb_bytenr == 0)
sb_bytenr = BTRFS_SUPER_INFO_OFFSET;
fs_info->fp = fp;
ret = btrfs_scan_one_device(fp, path, &fs_devices,
&total_devs, sb_bytenr);
if (ret) {
fprintf(stderr, "No valid Btrfs found on %s\n", path);
return NULL;
}
fprintf(stderr, "found Btrfs on %s with %Lu devices\n", path,
total_devs);
if (total_devs != 1) {
ret = btrfs_scan_for_fsid(fs_devices, total_devs, 1);
BUG_ON(ret);
}
fs_info->fp = fs_devices->lowest_bdev;
fs_info->running_transaction = NULL;
fs_info->fs_root = root;
fs_info->tree_root = tree_root;
@ -445,17 +458,20 @@ struct btrfs_root *open_ctree_fd(int fp, u64 sb_bytenr)
cache_tree_init(&fs_info->mapping_tree.cache_tree);
mutex_init(&fs_info->fs_mutex);
fs_info->fs_devices = fs_devices;
INIT_LIST_HEAD(&fs_info->dirty_cowonly_roots);
INIT_LIST_HEAD(&fs_info->devices);
INIT_LIST_HEAD(&fs_info->space_info);
__setup_root(4096, 4096, 4096, 4096, tree_root,
fs_info, BTRFS_ROOT_TREE_OBJECTID);
ret = btrfs_open_devices(fs_devices, O_RDWR);
BUG_ON(ret);
fs_info->sb_buffer = btrfs_find_create_tree_block(tree_root, sb_bytenr,
4096);
BUG_ON(!fs_info->sb_buffer);
fs_info->sb_buffer->fd = fp;
fs_info->sb_buffer->fd = fs_devices->lowest_bdev;
fs_info->sb_buffer->dev_bytenr = sb_bytenr;
ret = read_extent_from_disk(fs_info->sb_buffer);
BUG_ON(ret);
@ -484,7 +500,6 @@ struct btrfs_root *open_ctree_fd(int fp, u64 sb_bytenr)
ret = btrfs_read_super_device(tree_root, fs_info->sb_buffer);
BUG_ON(ret);
ret = btrfs_read_sys_array(tree_root);
BUG_ON(ret);
blocksize = btrfs_level_size(tree_root,
@ -492,11 +507,13 @@ struct btrfs_root *open_ctree_fd(int fp, u64 sb_bytenr)
__setup_root(nodesize, leafsize, sectorsize, stripesize,
chunk_root, fs_info, BTRFS_CHUNK_TREE_OBJECTID);
chunk_root->node = read_tree_block(chunk_root,
btrfs_super_chunk_root(disk_super),
blocksize);
BUG_ON(!chunk_root->node);
ret = btrfs_read_chunk_tree(chunk_root);
BUG_ON(ret);
@ -557,13 +574,12 @@ static int close_all_devices(struct btrfs_fs_info *fs_info)
struct list_head *next;
struct btrfs_device *device;
list = &fs_info->devices;
while(!list_empty(list)) {
next = list->next;
list_del(next);
return 0;
list = &fs_info->fs_devices->devices;
list_for_each(next, list) {
device = list_entry(next, struct btrfs_device, dev_list);
// close(device->fd);
kfree(device);
}
return 0;
}

4
disk-io.h
View File

@ -29,8 +29,8 @@ struct extent_buffer *btrfs_find_create_tree_block(struct btrfs_root *root,
u64 bytenr, u32 blocksize);
int clean_tree_block(struct btrfs_trans_handle *trans,
struct btrfs_root *root, struct extent_buffer *buf);
struct btrfs_root *open_ctree(char *filename, u64 sb_bytenr);
struct btrfs_root *open_ctree_fd(int fp, u64 sb_bytenr);
struct btrfs_root *open_ctree(const char *filename, u64 sb_bytenr);
struct btrfs_root *open_ctree_fd(int fp, const char *path, u64 sb_bytenr);
int close_ctree(struct btrfs_root *root);
int write_ctree_super(struct btrfs_trans_handle *trans,
struct btrfs_root *root);

4
extent-tree.c
View File

@ -356,10 +356,6 @@ again:
found_group = cache;
goto found;
}
if (full_search) {
printk("failed on cache %Lu used %Lu total %Lu\n",
cache->key.objectid, used, cache->key.offset);
}
cond_resched();
}
if (!full_search) {

2
kerncompat.h
View File

@ -189,6 +189,8 @@ static inline long IS_ERR(const void *ptr)
* kmalloc/kfree
*/
#define kmalloc(x, y) malloc(x)
#define kzalloc(x, y) calloc(1, x)
#define kstrdup(x, y) strdup(x)
#define kfree(x) free(x)
#define BUG_ON(c) do { if (c) abort(); } while (0)

8
mkfs.c
View File

@ -59,7 +59,7 @@ static u64 parse_size(char *s)
return atol(s) * mult;
}
static int make_root_dir(int fd) {
static int make_root_dir(int fd, const char *device_name) {
struct btrfs_root *root;
struct btrfs_trans_handle *trans;
struct btrfs_key location;
@ -68,7 +68,7 @@ static int make_root_dir(int fd) {
u64 chunk_size = 0;
int ret;
root = open_ctree_fd(fd, 0);
root = open_ctree_fd(fd, device_name, 0);
if (!root) {
fprintf(stderr, "ctree init failed\n");
@ -217,7 +217,7 @@ int main(int ac, char **av)
fprintf(stderr, "error during mkfs %d\n", ret);
exit(1);
}
ret = make_root_dir(fd);
ret = make_root_dir(fd, file);
if (ret) {
fprintf(stderr, "failed to setup the root directory\n");
exit(1);
@ -229,6 +229,7 @@ int main(int ac, char **av)
if (ac == 0)
goto done;
btrfs_register_one_device(file);
root = open_ctree(file, 0);
if (!root) {
@ -255,6 +256,7 @@ int main(int ac, char **av)
sectorsize, sectorsize, sectorsize);
BUG_ON(ret);
close(fd);
btrfs_register_one_device(file);
}
btrfs_commit_transaction(trans, root);
ret = close_ctree(root);

123
utils.c
View File

@ -27,6 +27,7 @@
#include <sys/types.h>
#include <sys/stat.h>
#include <uuid/uuid.h>
#include <dirent.h>
#include <fcntl.h>
#include <unistd.h>
#include "kerncompat.h"
@ -37,6 +38,7 @@
#include "crc32c.h"
#include "utils.h"
#include "volumes.h"
#include "ioctl.h"
#ifdef __CHECKER__
#define BLKGETSIZE64 0
@ -522,3 +524,124 @@ int btrfs_make_root_dir(struct btrfs_trans_handle *trans,
error:
return ret;
}
struct pending_dir {
struct list_head list;
char name[256];
};
int btrfs_register_one_device(char *fname)
{
struct btrfs_ioctl_vol_args args;
int fd;
int ret;
fd = open("/dev/btrfs-control", O_RDONLY);
if (fd < 0)
return -EINVAL;
strcpy(args.name, fname);
ret = ioctl(fd, BTRFS_IOC_SCAN_DEV, &args);
close(fd);
return ret;
}
int btrfs_scan_one_dir(char *dirname, int run_ioctl)
{
DIR *dirp;
struct dirent *dirent;
struct pending_dir *pending;
struct stat st;
int ret;
int fd;
int dirname_len;
int pathlen;
char *fullpath;
struct list_head pending_list;
struct btrfs_fs_devices *tmp_devices;
u64 num_devices;
INIT_LIST_HEAD(&pending_list);
pending = malloc(sizeof(*pending));
if (!pending)
return -ENOMEM;
strcpy(pending->name, dirname);
again:
dirname_len = strlen(pending->name);
pathlen = 1024;
fullpath = malloc(pathlen);
dirname = pending->name;
if (!fullpath) {
ret = -ENOMEM;
goto fail;
}
dirp = opendir(dirname);
if (!dirp) {
fprintf(stderr, "Unable to open /sys/block for scanning\n");
return -ENOENT;
}
while(1) {
dirent = readdir(dirp);
if (!dirent)
break;
if (dirent->d_name[0] == '.')
continue;
if (dirname_len + strlen(dirent->d_name) + 2 > pathlen) {
ret = -EFAULT;
goto fail;
}
snprintf(fullpath, pathlen, "%s/%s", dirname, dirent->d_name);
ret = lstat(fullpath, &st);
if (ret < 0) {
fprintf(stderr, "failed to stat %s\n", fullpath);
continue;
}
if (S_ISLNK(st.st_mode))
continue;
if (S_ISDIR(st.st_mode)) {
struct pending_dir *next = malloc(sizeof(*next));
if (!next) {
ret = -ENOMEM;
goto fail;
}
strcpy(next->name, fullpath);
list_add_tail(&next->list, &pending_list);
}
if (!S_ISBLK(st.st_mode)) {
continue;
}
fd = open(fullpath, O_RDONLY);
if (fd < 0) {
fprintf(stderr, "failed to read %s\n", fullpath);
continue;
}
ret = btrfs_scan_one_device(fd, fullpath, &tmp_devices,
&num_devices,
BTRFS_SUPER_INFO_OFFSET);
if (ret == 0 && run_ioctl > 0) {
btrfs_register_one_device(fullpath);
}
close(fd);
}
if (!list_empty(&pending_list)) {
free(pending);
pending = list_entry(pending_list.next, struct pending_dir,
list);
list_del(&pending->list);
closedir(dirp);
goto again;
}
ret = 0;
fail:
free(pending);
closedir(dirp);
return ret;
}
int btrfs_scan_for_fsid(struct btrfs_fs_devices *fs_devices, u64 total_devs,
int run_ioctls)
{
return btrfs_scan_one_dir("/dev", run_ioctls);
}

4
utils.h
View File

@ -31,4 +31,8 @@ int btrfs_prepare_device(int fd, char *file, int zero_end,
int btrfs_add_to_fsid(struct btrfs_trans_handle *trans,
struct btrfs_root *root, int fd, u64 block_count,
u32 io_width, u32 io_align, u32 sectorsize);
int btrfs_scan_for_fsid(struct btrfs_fs_devices *fs_devices, u64 total_devs,
int run_ioctls);
int btrfs_register_one_device(char *fname);
int btrfs_scan_one_dir(char *dirname, int run_ioctl);
#endif

192
volumes.c
View File

@ -15,6 +15,15 @@
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 021110-1307, USA.
*/
#define _XOPEN_SOURCE 600
#define __USE_XOPEN2K
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <uuid/uuid.h>
#include <fcntl.h>
#include <unistd.h>
#include "ctree.h"
#include "disk-io.h"
#include "transaction.h"
@ -26,6 +35,160 @@ struct map_lookup {
struct btrfs_device *dev;
u64 physical;
};
static LIST_HEAD(fs_uuids);
static struct btrfs_device *__find_device(struct list_head *head, u64 devid)
{
struct btrfs_device *dev;
struct list_head *cur;
list_for_each(cur, head) {
dev = list_entry(cur, struct btrfs_device, dev_list);
if (dev->devid == devid)
return dev;
}
return NULL;
}
static struct btrfs_fs_devices *find_fsid(u8 *fsid)
{
struct list_head *cur;
struct btrfs_fs_devices *fs_devices;
list_for_each(cur, &fs_uuids) {
fs_devices = list_entry(cur, struct btrfs_fs_devices, list);
if (memcmp(fsid, fs_devices->fsid, BTRFS_FSID_SIZE) == 0)
return fs_devices;
}
return NULL;
}
static int device_list_add(const char *path,
struct btrfs_super_block *disk_super,
u64 devid, struct btrfs_fs_devices **fs_devices_ret)
{
struct btrfs_device *device;
struct btrfs_fs_devices *fs_devices;
u64 found_transid = btrfs_super_generation(disk_super);
fs_devices = find_fsid(disk_super->fsid);
if (!fs_devices) {
fs_devices = kmalloc(sizeof(*fs_devices), GFP_NOFS);
if (!fs_devices)
return -ENOMEM;
INIT_LIST_HEAD(&fs_devices->devices);
list_add(&fs_devices->list, &fs_uuids);
memcpy(fs_devices->fsid, disk_super->fsid, BTRFS_FSID_SIZE);
fs_devices->latest_devid = devid;
fs_devices->latest_trans = found_transid;
fs_devices->lowest_devid = (u64)-1;
device = NULL;
} else {
device = __find_device(&fs_devices->devices, devid);
}
if (!device) {
device = kzalloc(sizeof(*device), GFP_NOFS);
if (!device) {
/* we can safely leave the fs_devices entry around */
return -ENOMEM;
}
device->devid = devid;
device->name = kstrdup(path, GFP_NOFS);
if (!device->name) {
kfree(device);
return -ENOMEM;
}
list_add(&device->dev_list, &fs_devices->devices);
}
if (found_transid > fs_devices->latest_trans) {
fs_devices->latest_devid = devid;
fs_devices->latest_trans = found_transid;
}
if (fs_devices->lowest_devid > devid) {
fs_devices->lowest_devid = devid;
printk("lowest devid now %Lu\n", devid);
}
*fs_devices_ret = fs_devices;
return 0;
}
int btrfs_close_devices(struct btrfs_fs_devices *fs_devices)
{
struct list_head *head = &fs_devices->devices;
struct list_head *cur;
struct btrfs_device *device;
list_for_each(cur, head) {
device = list_entry(cur, struct btrfs_device, dev_list);
device->fd = 0;
}
return 0;
}
int btrfs_open_devices(struct btrfs_fs_devices *fs_devices, int flags)
{
int fd;
struct list_head *head = &fs_devices->devices;
struct list_head *cur;
struct btrfs_device *device;
int ret;
list_for_each(cur, head) {
device = list_entry(cur, struct btrfs_device, dev_list);
fd = open(device->name, flags);
printk("opening %s devid %Lu fd %d\n", device->name, device->devid, fd);
if (fd < 0) {
ret = -errno;
goto fail;
}
if (device->devid == fs_devices->latest_devid)
fs_devices->latest_bdev = fd;
if (device->devid == fs_devices->lowest_devid)
fs_devices->lowest_bdev = fd;
device->fd = fd;
}
return 0;
fail:
btrfs_close_devices(fs_devices);
return ret;
}
int btrfs_scan_one_device(int fd, const char *path,
struct btrfs_fs_devices **fs_devices_ret,
u64 *total_devs, u64 super_offset)
{
struct btrfs_super_block *disk_super;
char *buf;
int ret;
u64 devid;
buf = malloc(4096);
if (!buf) {
ret = -ENOMEM;
goto error;
}
ret = pread(fd, buf, 4096, super_offset);
if (ret != 4096) {
ret = -EIO;
goto error;
}
disk_super = (struct btrfs_super_block *)buf;
if (strncmp((char *)(&disk_super->magic), BTRFS_MAGIC,
sizeof(disk_super->magic))) {
ret = -ENOENT;
goto error_brelse;
}
devid = le64_to_cpu(disk_super->dev_item.devid);
*total_devs = btrfs_super_num_devices(disk_super);
printk("found device %Lu on %s\n", devid, path);
ret = device_list_add(path, disk_super, devid, fs_devices_ret);
error_brelse:
free(buf);
error:
return ret;
}
/*
* this uses a pretty simple search, the expectation is that it is
@ -301,6 +464,7 @@ out:
btrfs_free_path(path);
return ret;
}
int btrfs_update_device(struct btrfs_trans_handle *trans,
struct btrfs_device *device)
{
@ -381,11 +545,11 @@ int btrfs_alloc_chunk(struct btrfs_trans_handle *trans,
struct btrfs_device *device = NULL;
struct btrfs_chunk *chunk;
struct list_head private_devs;
struct list_head *dev_list = &extent_root->fs_info->devices;
struct list_head *dev_list = &extent_root->fs_info->fs_devices->devices;
struct list_head *cur;
struct map_lookup *map;
u64 physical;
u64 calc_size = 1024 * 1024 * 1024;
u64 calc_size = 128 * 1024 * 1024;
u64 avail;
u64 max_avail = 0;
int num_stripes = 1;
@ -446,7 +610,7 @@ again:
key.objectid,
calc_size, &dev_offset);
BUG_ON(ret);
printk("alloc chunk size %Lu from dev %Lu\n", calc_size, device->devid);
device->bytes_used += calc_size;
ret = btrfs_update_device(trans, device);
BUG_ON(ret);
@ -523,17 +687,9 @@ int btrfs_map_block(struct btrfs_mapping_tree *map_tree,
struct btrfs_device *btrfs_find_device(struct btrfs_root *root, u64 devid)
{
struct btrfs_device *dev;
struct list_head *cur = root->fs_info->devices.next;
struct list_head *head = &root->fs_info->devices;
struct list_head *head = &root->fs_info->fs_devices->devices;
while(cur != head) {
dev = list_entry(cur, struct btrfs_device, dev_list);
if (dev->devid == devid)
return dev;
cur = cur->next;
}
return NULL;
return __find_device(head, devid);
}
static int read_one_chunk(struct btrfs_root *root, struct btrfs_key *key,
@ -565,6 +721,7 @@ static int read_one_chunk(struct btrfs_root *root, struct btrfs_key *key,
map->ce.size = length;
map->physical = btrfs_stripe_offset_nr(leaf, chunk, 0);
devid = btrfs_stripe_devid_nr(leaf, chunk, 0);
map->dev = btrfs_find_device(root, devid);
@ -609,19 +766,16 @@ static int read_one_dev(struct btrfs_root *root,
devid = btrfs_device_id(leaf, dev_item);
device = btrfs_find_device(root, devid);
if (!device) {
printk("warning devid %Lu not found already\n", devid);
device = kmalloc(sizeof(*device), GFP_NOFS);
if (!device)
return -ENOMEM;
list_add(&device->dev_list, &root->fs_info->devices);
list_add(&device->dev_list,
&root->fs_info->fs_devices->devices);
}
fill_device_from_item(leaf, dev_item, device);
device->dev_root = root->fs_info->dev_root;
device->fd = root->fs_info->fp;
ret = btrfs_open_device(device);
if (ret) {
kfree(device);
}
return ret;
}

24
volumes.h
View File

@ -24,6 +24,8 @@ struct btrfs_device {
int fd;
char *name;
/* the internal btrfs device id */
u64 devid;
@ -49,6 +51,19 @@ struct btrfs_device {
u8 uuid[BTRFS_DEV_UUID_SIZE];
};
struct btrfs_fs_devices {
u8 fsid[BTRFS_FSID_SIZE]; /* FS specific uuid */
/* the device with this id has the most recent coyp of the super */
u64 latest_devid;
u64 latest_trans;
u64 lowest_devid;
int latest_bdev;
int lowest_bdev;
struct list_head devices;
struct list_head list;
};
int btrfs_alloc_dev_extent(struct btrfs_trans_handle *trans,
struct btrfs_device *device,
u64 owner, u64 num_bytes, u64 *start);
@ -64,4 +79,13 @@ int btrfs_read_super_device(struct btrfs_root *root, struct extent_buffer *buf);
int btrfs_add_device(struct btrfs_trans_handle *trans,
struct btrfs_root *root,
struct btrfs_device *device);
int btrfs_open_devices(struct btrfs_fs_devices *fs_devices,
int flags);
int btrfs_close_devices(struct btrfs_fs_devices *fs_devices);
int btrfs_add_device(struct btrfs_trans_handle *trans,
struct btrfs_root *root,
struct btrfs_device *device);
int btrfs_scan_one_device(int fd, const char *path,
struct btrfs_fs_devices **fs_devices_ret,
u64 *total_devs, u64 super_offset);
#endif