diff --git a/Makefile b/Makefile index 8097b5a..525676e 100644 --- a/Makefile +++ b/Makefile @@ -4,7 +4,7 @@ CFLAGS = -g -Werror -Os objects = ctree.o disk-io.o radix-tree.o extent-tree.o print-tree.o \ root-tree.o dir-item.o file-item.o inode-item.o \ inode-map.o crc32c.o rbtree.o extent-cache.o extent_io.o \ - volumes.o utils.o + volumes.o utils.o btrfs-list.o # CHECKFLAGS=-D__linux__ -Dlinux -D__STDC__ -Dunix -D__unix__ -Wbitwise \ @@ -16,7 +16,9 @@ prefix ?= /usr/local bindir = $(prefix)/bin LIBS=-luuid -progs = btrfsctl mkfs.btrfs btrfs-debug-tree btrfs-show btrfs-vol btrfsck +progs = btrfsctl mkfs.btrfs btrfs-debug-tree btrfs-show btrfs-vol btrfsck \ + btrfs \ + btrfs-map-logical # make C=1 to enable sparse ifdef C @@ -35,6 +37,10 @@ all: version $(progs) manpages version: bash version.sh +btrfs: $(objects) btrfs.o btrfs_cmds.o + gcc $(CFLAGS) -o btrfs btrfs.o btrfs_cmds.o \ + $(objects) $(LDFLAGS) $(LIBS) + btrfsctl: $(objects) btrfsctl.o gcc $(CFLAGS) -o btrfsctl btrfsctl.o $(objects) $(LDFLAGS) $(LIBS) @@ -56,6 +62,9 @@ btrfs-debug-tree: $(objects) debug-tree.o btrfstune: $(objects) btrfstune.o gcc $(CFLAGS) -o btrfstune $(objects) btrfstune.o $(LDFLAGS) $(LIBS) +btrfs-map-logical: $(objects) btrfs-map-logical.o + gcc $(CFLAGS) -o btrfs-map-logical $(objects) btrfs-map-logical.o $(LDFLAGS) $(LIBS) + btrfs-image: $(objects) btrfs-image.o gcc $(CFLAGS) -o btrfs-image $(objects) btrfs-image.o -lpthread -lz $(LDFLAGS) $(LIBS) @@ -68,6 +77,9 @@ quick-test: $(objects) quick-test.o convert: $(objects) convert.o gcc $(CFLAGS) -o btrfs-convert $(objects) convert.o -lext2fs $(LDFLAGS) $(LIBS) +ioctl-test: $(objects) ioctl-test.o + gcc $(CFLAGS) -o ioctl-test $(objects) ioctl-test.o $(LDFLAGS) $(LIBS) + manpages: cd man; make diff --git a/btrfs-defrag.c b/btrfs-defrag.c new file mode 100644 index 0000000..8f1525a --- /dev/null +++ b/btrfs-defrag.c @@ -0,0 +1,39 @@ +/* + * Copyright (C) 2010 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. + */ + +#ifndef __CHECKER__ +#include <sys/ioctl.h> +#include <sys/mount.h> +#include "ioctl.h" +#endif +#include <stdio.h> +#include <stdlib.h> +#include <sys/types.h> +#include <sys/stat.h> +#include <fcntl.h> +#include <ctype.h> +#include <unistd.h> +#include <dirent.h> +#include <libgen.h> +#include <getopt.h> +#include "kerncompat.h" +#include "ctree.h" +#include "transaction.h" +#include "utils.h" +#include "version.h" + diff --git a/btrfs-list.c b/btrfs-list.c new file mode 100644 index 0000000..7741705 --- /dev/null +++ b/btrfs-list.c @@ -0,0 +1,825 @@ +/* + * Copyright (C) 2010 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. + */ + +#ifndef __CHECKER__ +#include <sys/ioctl.h> +#include <sys/mount.h> +#include "ioctl.h" +#endif +#include <stdio.h> +#include <stdlib.h> +#include <sys/types.h> +#include <sys/stat.h> +#include <fcntl.h> +#include <unistd.h> +#include <dirent.h> +#include <libgen.h> +#include "kerncompat.h" +#include "ctree.h" +#include "transaction.h" +#include "utils.h" +#include "version.h" + +/* we store all the roots we find in an rbtree so that we can + * search for them later. + */ +struct root_lookup { + struct rb_root root; +}; + +/* + * one of these for each root we find. + */ +struct root_info { + struct rb_node rb_node; + + /* this root's id */ + u64 root_id; + + /* the id of the root that references this one */ + u64 ref_tree; + + /* the dir id we're in from ref_tree */ + u64 dir_id; + + /* path from the subvol we live in to this root, including the + * root's name. This is null until we do the extra lookup ioctl. + */ + char *path; + + /* the name of this root in the directory it lives in */ + char name[]; +}; + +static void root_lookup_init(struct root_lookup *tree) +{ + tree->root.rb_node = NULL; +} + +static int comp_entry(struct root_info *entry, u64 root_id, u64 ref_tree) +{ + if (entry->root_id > root_id) + return 1; + if (entry->root_id < root_id) + return -1; + if (entry->ref_tree > ref_tree) + return 1; + if (entry->ref_tree < ref_tree) + return -1; + return 0; +} + +/* + * insert a new root into the tree. returns the existing root entry + * if one is already there. Both root_id and ref_tree are used + * as the key + */ +static struct rb_node *tree_insert(struct rb_root *root, u64 root_id, + u64 ref_tree, struct rb_node *node) +{ + struct rb_node ** p = &root->rb_node; + struct rb_node * parent = NULL; + struct root_info *entry; + int comp; + + while(*p) { + parent = *p; + entry = rb_entry(parent, struct root_info, rb_node); + + comp = comp_entry(entry, root_id, ref_tree); + + if (comp < 0) + p = &(*p)->rb_left; + else if (comp > 0) + p = &(*p)->rb_right; + else + return parent; + } + + entry = rb_entry(parent, struct root_info, rb_node); + rb_link_node(node, parent, p); + rb_insert_color(node, root); + return NULL; +} + +/* + * find a given root id in the tree. We return the smallest one, + * rb_next can be used to move forward looking for more if required + */ +static struct root_info *tree_search(struct rb_root *root, u64 root_id) +{ + struct rb_node * n = root->rb_node; + struct root_info *entry; + + while(n) { + entry = rb_entry(n, struct root_info, rb_node); + + if (entry->root_id < root_id) + n = n->rb_left; + else if (entry->root_id > root_id) + n = n->rb_right; + else { + struct root_info *prev; + struct rb_node *prev_n; + while (1) { + prev_n = rb_prev(n); + if (!prev_n) + break; + prev = rb_entry(prev_n, struct root_info, + rb_node); + if (prev->root_id != root_id) + break; + entry = prev; + n = prev_n; + } + return entry; + } + } + return NULL; +} + +/* + * this allocates a new root in the lookup tree. + * + * root_id should be the object id of the root + * + * ref_tree is the objectid of the referring root. + * + * dir_id is the directory in ref_tree where this root_id can be found. + * + * name is the name of root_id in that directory + * + * name_len is the length of name + */ +static int add_root(struct root_lookup *root_lookup, + u64 root_id, u64 ref_tree, u64 dir_id, char *name, + int name_len) +{ + struct root_info *ri; + struct rb_node *ret; + ri = malloc(sizeof(*ri) + name_len + 1); + if (!ri) { + printf("memory allocation failed\n"); + exit(1); + } + memset(ri, 0, sizeof(*ri) + name_len + 1); + ri->path = NULL; + ri->dir_id = dir_id; + ri->root_id = root_id; + ri->ref_tree = ref_tree; + strncpy(ri->name, name, name_len); + + ret = tree_insert(&root_lookup->root, root_id, ref_tree, &ri->rb_node); + if (ret) { + printf("failed to insert tree %llu\n", (unsigned long long)root_id); + exit(1); + } + return 0; +} + +/* + * for a given root_info, search through the root_lookup tree to construct + * the full path name to it. + * + * This can't be called until all the root_info->path fields are filled + * in by lookup_ino_path + */ +static int resolve_root(struct root_lookup *rl, struct root_info *ri) +{ + u64 top_id; + char *full_path = NULL; + int len = 0; + struct root_info *found; + + /* + * we go backwards from the root_info object and add pathnames + * from parent directories as we go. + */ + found = ri; + while (1) { + char *tmp; + u64 next; + int add_len = strlen(found->path); + + /* room for / and for null */ + tmp = malloc(add_len + 2 + len); + if (full_path) { + memcpy(tmp + add_len + 1, full_path, len); + tmp[add_len] = '/'; + memcpy(tmp, found->path, add_len); + tmp [add_len + len + 1] = '\0'; + free(full_path); + full_path = tmp; + len += add_len + 1; + } else { + full_path = strdup(found->path); + len = add_len; + } + + next = found->ref_tree; + /* if the ref_tree refers to ourselves, we're at the top */ + if (next == found->root_id) { + top_id = next; + break; + } + + /* + * if the ref_tree wasn't in our tree of roots, we're + * at the top + */ + found = tree_search(&rl->root, next); + if (!found) { + top_id = next; + break; + } + } + printf("ID %llu top level %llu path %s\n", ri->root_id, top_id, + full_path); + free(full_path); + return 0; +} + +/* + * for a single root_info, ask the kernel to give us a path name + * inside it's ref_root for the dir_id where it lives. + * + * This fills in root_info->path with the path to the directory and and + * appends this root's name. + */ +static int lookup_ino_path(int fd, struct root_info *ri) +{ + struct btrfs_ioctl_ino_lookup_args args; + int ret; + + if (ri->path) + return 0; + + memset(&args, 0, sizeof(args)); + args.treeid = ri->ref_tree; + args.objectid = ri->dir_id; + + ret = ioctl(fd, BTRFS_IOC_INO_LOOKUP, &args); + if (ret) { + fprintf(stderr, "ERROR: Failed to lookup path for root %llu\n", + (unsigned long long)ri->ref_tree); + return ret; + } + + if (args.name[0]) { + /* + * we're in a subdirectory of ref_tree, the kernel ioctl + * puts a / in there for us + */ + ri->path = malloc(strlen(ri->name) + strlen(args.name) + 1); + if (!ri->path) { + perror("malloc failed"); + exit(1); + } + strcpy(ri->path, args.name); + strcat(ri->path, ri->name); + } else { + /* we're at the root of ref_tree */ + ri->path = strdup(ri->name); + if (!ri->path) { + perror("strdup failed"); + exit(1); + } + } + return 0; +} + +/* finding the generation for a given path is a two step process. + * First we use the inode loookup routine to find out the root id + * + * Then we use the tree search ioctl to scan all the root items for a + * given root id and spit out the latest generation we can find + */ +static u64 find_root_gen(int fd) +{ + struct btrfs_ioctl_ino_lookup_args ino_args; + int ret; + struct btrfs_ioctl_search_args args; + struct btrfs_ioctl_search_key *sk = &args.key; + struct btrfs_ioctl_search_header *sh; + unsigned long off = 0; + u64 max_found = 0; + int i; + + memset(&ino_args, 0, sizeof(ino_args)); + ino_args.objectid = BTRFS_FIRST_FREE_OBJECTID; + + /* this ioctl fills in ino_args->treeid */ + ret = ioctl(fd, BTRFS_IOC_INO_LOOKUP, &ino_args); + if (ret) { + fprintf(stderr, "ERROR: Failed to lookup path for dirid %llu\n", + (unsigned long long)BTRFS_FIRST_FREE_OBJECTID); + return 0; + } + + memset(&args, 0, sizeof(args)); + + sk->tree_id = 1; + + /* + * there may be more than one ROOT_ITEM key if there are + * snapshots pending deletion, we have to loop through + * them. + */ + sk->min_objectid = ino_args.treeid; + sk->max_objectid = ino_args.treeid; + sk->max_type = BTRFS_ROOT_ITEM_KEY; + sk->min_type = BTRFS_ROOT_ITEM_KEY; + sk->max_offset = (u64)-1; + sk->max_transid = (u64)-1; + sk->nr_items = 4096; + + while (1) { + ret = ioctl(fd, BTRFS_IOC_TREE_SEARCH, &args); + if (ret < 0) { + fprintf(stderr, "ERROR: can't perform the search\n"); + return 0; + } + /* the ioctl returns the number of item it found in nr_items */ + if (sk->nr_items == 0) + break; + + off = 0; + for (i = 0; i < sk->nr_items; i++) { + struct btrfs_root_item *item; + sh = (struct btrfs_ioctl_search_header *)(args.buf + + off); + + off += sizeof(*sh); + item = (struct btrfs_root_item *)(args.buf + off); + off += sh->len; + + sk->min_objectid = sh->objectid; + sk->min_type = sh->type; + sk->min_offset = sh->offset; + + if (sh->objectid > ino_args.treeid) + break; + + if (sh->objectid == ino_args.treeid && + sh->type == BTRFS_ROOT_ITEM_KEY) { + max_found = max(max_found, + btrfs_root_generation(item)); + } + } + if (sk->min_offset < (u64)-1) + sk->min_offset++; + else + break; + + if (sk->min_type != BTRFS_ROOT_ITEM_KEY) + break; + if (sk->min_objectid != BTRFS_ROOT_ITEM_KEY) + break; + } + return max_found; +} + +/* pass in a directory id and this will return + * the full path of the parent directory inside its + * subvolume root. + * + * It may return NULL if it is in the root, or an ERR_PTR if things + * go badly. + */ +static char *__ino_resolve(int fd, u64 dirid) +{ + struct btrfs_ioctl_ino_lookup_args args; + int ret; + char *full; + + memset(&args, 0, sizeof(args)); + args.objectid = dirid; + + ret = ioctl(fd, BTRFS_IOC_INO_LOOKUP, &args); + if (ret) { + fprintf(stderr, "ERROR: Failed to lookup path for dirid %llu\n", + (unsigned long long)dirid); + return ERR_PTR(ret); + } + + if (args.name[0]) { + /* + * we're in a subdirectory of ref_tree, the kernel ioctl + * puts a / in there for us + */ + full = strdup(args.name); + if (!full) { + perror("malloc failed"); + return ERR_PTR(-ENOMEM); + } + } else { + /* we're at the root of ref_tree */ + full = NULL; + } + return full; +} + +/* + * simple string builder, returning a new string with both + * dirid and name + */ +char *build_name(char *dirid, char *name) +{ + char *full; + if (!dirid) + return strdup(name); + + full = malloc(strlen(dirid) + strlen(name) + 1); + if (!full) + return NULL; + strcpy(full, dirid); + strcat(full, name); + return full; +} + +/* + * given an inode number, this returns the full path name inside the subvolume + * to that file/directory. cache_dirid and cache_name are used to + * cache the results so we can avoid tree searches if a later call goes + * to the same directory or file name + */ +static char *ino_resolve(int fd, u64 ino, u64 *cache_dirid, char **cache_name) + +{ + u64 dirid; + char *dirname; + char *name; + char *full; + int ret; + struct btrfs_ioctl_search_args args; + struct btrfs_ioctl_search_key *sk = &args.key; + struct btrfs_ioctl_search_header *sh; + unsigned long off = 0; + int namelen; + + memset(&args, 0, sizeof(args)); + + sk->tree_id = 0; + + /* + * step one, we search for the inode back ref. We just use the first + * one + */ + sk->min_objectid = ino; + sk->max_objectid = ino; + sk->max_type = BTRFS_INODE_REF_KEY; + sk->max_offset = (u64)-1; + sk->min_type = BTRFS_INODE_REF_KEY; + sk->max_transid = (u64)-1; + sk->nr_items = 1; + + ret = ioctl(fd, BTRFS_IOC_TREE_SEARCH, &args); + if (ret < 0) { + fprintf(stderr, "ERROR: can't perform the search\n"); + return NULL; + } + /* the ioctl returns the number of item it found in nr_items */ + if (sk->nr_items == 0) + return NULL; + + off = 0; + sh = (struct btrfs_ioctl_search_header *)(args.buf + off); + + if (sh->type == BTRFS_INODE_REF_KEY) { + struct btrfs_inode_ref *ref; + dirid = sh->offset; + + ref = (struct btrfs_inode_ref *)(sh + 1); + namelen = btrfs_stack_inode_ref_name_len(ref); + + name = (char *)(ref + 1); + name = strndup(name, namelen); + + /* use our cached value */ + if (dirid == *cache_dirid && *cache_name) { + dirname = *cache_name; + goto build; + } + } else { + return NULL; + } + /* + * the inode backref gives us the file name and the parent directory id. + * From here we use __ino_resolve to get the path to the parent + */ + dirname = __ino_resolve(fd, dirid); +build: + full = build_name(dirname, name); + if (*cache_name && dirname != *cache_name) + free(*cache_name); + + *cache_name = dirname; + *cache_dirid = dirid; + free(name); + + return full; +} + +int list_subvols(int fd) +{ + struct root_lookup root_lookup; + struct rb_node *n; + int ret; + struct btrfs_ioctl_search_args args; + struct btrfs_ioctl_search_key *sk = &args.key; + struct btrfs_ioctl_search_header *sh; + struct btrfs_root_ref *ref; + unsigned long off = 0; + int name_len; + char *name; + u64 dir_id; + int i; + + root_lookup_init(&root_lookup); + + memset(&args, 0, sizeof(args)); + + /* search in the tree of tree roots */ + sk->tree_id = 1; + + /* + * set the min and max to backref keys. The search will + * only send back this type of key now. + */ + sk->max_type = BTRFS_ROOT_BACKREF_KEY; + sk->min_type = BTRFS_ROOT_BACKREF_KEY; + + /* + * set all the other params to the max, we'll take any objectid + * and any trans + */ + sk->max_objectid = (u64)-1; + sk->max_offset = (u64)-1; + sk->max_transid = (u64)-1; + + /* just a big number, doesn't matter much */ + sk->nr_items = 4096; + + while(1) { + ret = ioctl(fd, BTRFS_IOC_TREE_SEARCH, &args); + if (ret < 0) { + fprintf(stderr, "ERROR: can't perform the search\n"); + return ret; + } + /* the ioctl returns the number of item it found in nr_items */ + if (sk->nr_items == 0) + break; + + off = 0; + + /* + * for each item, pull the key out of the header and then + * read the root_ref item it contains + */ + for (i = 0; i < sk->nr_items; i++) { + sh = (struct btrfs_ioctl_search_header *)(args.buf + + off); + off += sizeof(*sh); + if (sh->type == BTRFS_ROOT_BACKREF_KEY) { + ref = (struct btrfs_root_ref *)(args.buf + off); + name_len = btrfs_stack_root_ref_name_len(ref); + name = (char *)(ref + 1); + dir_id = btrfs_stack_root_ref_dirid(ref); + + add_root(&root_lookup, sh->objectid, sh->offset, + dir_id, name, name_len); + } + + off += sh->len; + + /* + * record the mins in sk so we can make sure the + * next search doesn't repeat this root + */ + sk->min_objectid = sh->objectid; + sk->min_type = sh->type; + sk->min_offset = sh->offset; + } + sk->nr_items = 4096; + /* this iteration is done, step forward one root for the next + * ioctl + */ + if (sk->min_objectid < (u64)-1) { + sk->min_objectid++; + sk->min_type = BTRFS_ROOT_BACKREF_KEY; + sk->min_offset = 0; + } else + break; + } + /* + * now we have an rbtree full of root_info objects, but we need to fill + * in their path names within the subvol that is referencing each one. + */ + n = rb_first(&root_lookup.root); + while (n) { + struct root_info *entry; + int ret; + entry = rb_entry(n, struct root_info, rb_node); + ret = lookup_ino_path(fd, entry); + if(ret < 0) + return ret; + n = rb_next(n); + } + + /* now that we have all the subvol-relative paths filled in, + * we have to string the subvols together so that we can get + * a path all the way back to the FS root + */ + n = rb_last(&root_lookup.root); + while (n) { + struct root_info *entry; + entry = rb_entry(n, struct root_info, rb_node); + resolve_root(&root_lookup, entry); + n = rb_prev(n); + } + + return ret; +} + +static int print_one_extent(int fd, struct btrfs_ioctl_search_header *sh, + struct btrfs_file_extent_item *item, + u64 found_gen, u64 *cache_dirid, + char **cache_dir_name, u64 *cache_ino, + char **cache_full_name) +{ + u64 len; + u64 disk_start; + u64 disk_offset; + u8 type; + int compressed = 0; + int flags = 0; + char *name = NULL; + + if (sh->objectid == *cache_ino) { + name = *cache_full_name; + } else if (*cache_full_name) { + free(*cache_full_name); + *cache_full_name = NULL; + } + if (!name) { + name = ino_resolve(fd, sh->objectid, cache_dirid, + cache_dir_name); + *cache_full_name = name; + *cache_ino = sh->objectid; + } + if (!name) + return -EIO; + + type = btrfs_stack_file_extent_type(item); + compressed = btrfs_stack_file_extent_compression(item); + + if (type == BTRFS_FILE_EXTENT_REG || + type == BTRFS_FILE_EXTENT_PREALLOC) { + disk_start = btrfs_stack_file_extent_disk_bytenr(item); + disk_offset = btrfs_stack_file_extent_offset(item); + len = btrfs_stack_file_extent_num_bytes(item); + } else if (type == BTRFS_FILE_EXTENT_INLINE) { + disk_start = 0; + disk_offset = 0; + len = btrfs_stack_file_extent_ram_bytes(item); + } + printf("inode %llu file offset %llu len %llu disk start %llu " + "offset %llu gen %llu flags ", + (unsigned long long)sh->objectid, + (unsigned long long)sh->offset, + (unsigned long long)len, + (unsigned long long)disk_start, + (unsigned long long)disk_offset, + (unsigned long long)found_gen); + + if (compressed) { + printf("COMPRESS"); + flags++; + } + if (type == BTRFS_FILE_EXTENT_PREALLOC) { + printf("%sPREALLOC", flags ? "|" : ""); + flags++; + } + if (type == BTRFS_FILE_EXTENT_INLINE) { + printf("%sINLINE", flags ? "|" : ""); + flags++; + } + if (!flags) + printf("NONE"); + + printf(" %s\n", name); + return 0; +} + +int find_updated_files(int fd, u64 root_id, u64 oldest_gen) +{ + int ret; + struct btrfs_ioctl_search_args args; + struct btrfs_ioctl_search_key *sk = &args.key; + struct btrfs_ioctl_search_header *sh; + struct btrfs_file_extent_item *item; + unsigned long off = 0; + u64 found_gen; + u64 max_found = 0; + int i; + u64 cache_dirid = 0; + u64 cache_ino = 0; + char *cache_dir_name = NULL; + char *cache_full_name = NULL; + struct btrfs_file_extent_item backup; + + memset(&backup, 0, sizeof(backup)); + memset(&args, 0, sizeof(args)); + + sk->tree_id = root_id; + + /* + * set all the other params to the max, we'll take any objectid + * and any trans + */ + sk->max_objectid = (u64)-1; + sk->max_offset = (u64)-1; + sk->max_transid = (u64)-1; + sk->max_type = BTRFS_EXTENT_DATA_KEY; + sk->min_transid = oldest_gen; + /* just a big number, doesn't matter much */ + sk->nr_items = 4096; + + max_found = find_root_gen(fd); + while(1) { + ret = ioctl(fd, BTRFS_IOC_TREE_SEARCH, &args); + if (ret < 0) { + fprintf(stderr, "ERROR: can't perform the search\n"); + return ret; + } + /* the ioctl returns the number of item it found in nr_items */ + if (sk->nr_items == 0) + break; + + off = 0; + + /* + * for each item, pull the key out of the header and then + * read the root_ref item it contains + */ + for (i = 0; i < sk->nr_items; i++) { + sh = (struct btrfs_ioctl_search_header *)(args.buf + + off); + off += sizeof(*sh); + + /* + * just in case the item was too big, pass something other + * than garbage + */ + if (sh->len == 0) + item = &backup; + else + item = (struct btrfs_file_extent_item *)(args.buf + + off); + found_gen = btrfs_stack_file_extent_generation(item); + if (sh->type == BTRFS_EXTENT_DATA_KEY && + found_gen >= oldest_gen) { + print_one_extent(fd, sh, item, found_gen, + &cache_dirid, &cache_dir_name, + &cache_ino, &cache_full_name); + } + off += sh->len; + + /* + * record the mins in sk so we can make sure the + * next search doesn't repeat this root + */ + sk->min_objectid = sh->objectid; + sk->min_offset = sh->offset; + sk->min_type = sh->type; + } + sk->nr_items = 4096; + if (sk->min_offset < (u64)-1) + sk->min_offset++; + else if (sk->min_objectid < (u64)-1) { + sk->min_objectid++; + sk->min_offset = 0; + sk->min_type = 0; + } else + break; + } + free(cache_dir_name); + free(cache_full_name); + printf("transid marker was %llu\n", (unsigned long long)max_found); + return ret; +} diff --git a/btrfs-map-logical.c b/btrfs-map-logical.c new file mode 100644 index 0000000..a109c6a --- /dev/null +++ b/btrfs-map-logical.c @@ -0,0 +1,221 @@ +/* + * Copyright (C) 2009 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. + */ + +#define _XOPEN_SOURCE 500 +#define _GNU_SOURCE 1 +#include <stdio.h> +#include <stdlib.h> +#include <fcntl.h> +#include <unistd.h> +#include <getopt.h> +#include "kerncompat.h" +#include "ctree.h" +#include "volumes.h" +#include "disk-io.h" +#include "print-tree.h" +#include "transaction.h" +#include "list.h" +#include "version.h" + +/* we write the mirror info to stdout unless they are dumping the data + * to stdout + * */ +static FILE *info_file; + +struct extent_buffer *debug_read_block(struct btrfs_root *root, u64 bytenr, + u32 blocksize, int copy) +{ + int ret; + int dev_nr; + struct extent_buffer *eb; + u64 length; + struct btrfs_multi_bio *multi = NULL; + struct btrfs_device *device; + int num_copies; + int mirror_num = 1; + + eb = btrfs_find_create_tree_block(root, bytenr, blocksize); + if (!eb) + return NULL; + + dev_nr = 0; + length = blocksize; + while (1) { + ret = btrfs_map_block(&root->fs_info->mapping_tree, READ, + eb->start, &length, &multi, mirror_num); + BUG_ON(ret); + device = multi->stripes[0].dev; + eb->fd = device->fd; + device->total_ios++; + eb->dev_bytenr = multi->stripes[0].physical; + + fprintf(info_file, "mirror %d logical %Lu physical %Lu " + "device %s\n", mirror_num, bytenr, eb->dev_bytenr, + device->name); + kfree(multi); + + if (!copy || mirror_num == copy) + ret = read_extent_from_disk(eb); + + num_copies = btrfs_num_copies(&root->fs_info->mapping_tree, + eb->start, eb->len); + if (num_copies == 1) + break; + + mirror_num++; + if (mirror_num > num_copies) + break; + } + return eb; +} + +static void print_usage(void) +{ + fprintf(stderr, "usage: btrfs-map-logical [options] mount_point\n"); + fprintf(stderr, "\t-l Logical extent to map\n"); + fprintf(stderr, "\t-c Copy of the extent to read (usually 1 or 2)\n"); + fprintf(stderr, "\t-o Output file to hold the extent\n"); + fprintf(stderr, "\t-s Number of bytes to read\n"); + exit(1); +} + +static struct option long_options[] = { + /* { "byte-count", 1, NULL, 'b' }, */ + { "logical", 1, NULL, 'l' }, + { "copy", 1, NULL, 'c' }, + { "output", 1, NULL, 'c' }, + { "bytes", 1, NULL, 'b' }, + { 0, 0, 0, 0} +}; + +int main(int ac, char **av) +{ + struct cache_tree root_cache; + struct btrfs_root *root; + struct extent_buffer *eb; + char *dev; + char *output_file = NULL; + u64 logical = 0; + int ret = 0; + int option_index = 0; + int copy = 0; + u64 bytes = 0; + int out_fd = 0; + int err; + + while(1) { + int c; + c = getopt_long(ac, av, "l:c:o:b:", long_options, + &option_index); + if (c < 0) + break; + switch(c) { + case 'l': + logical = atoll(optarg); + if (logical == 0) { + fprintf(stderr, + "invalid extent number\n"); + print_usage(); + } + break; + case 'c': + copy = atoi(optarg); + if (copy == 0) { + fprintf(stderr, + "invalid copy number\n"); + print_usage(); + } + break; + case 'b': + bytes = atoll(optarg); + if (bytes == 0) { + fprintf(stderr, + "invalid byte count\n"); + print_usage(); + } + break; + case 'o': + output_file = strdup(optarg); + break; + default: + print_usage(); + } + } + ac = ac - optind; + if (ac == 0) + print_usage(); + if (logical == 0) + print_usage(); + if (copy < 0) + print_usage(); + + dev = av[optind]; + + radix_tree_init(); + cache_tree_init(&root_cache); + + root = open_ctree(dev, 0, 0); + if (!root) { + fprintf(stderr, "Open ctree failed\n"); + exit(1); + } + + if (output_file) { + if (strcmp(output_file, "-") == 0) { + out_fd = 1; + info_file = stderr; + } else { + out_fd = open(output_file, O_RDWR | O_CREAT, 0600); + if (out_fd < 0) + goto close; + err = ftruncate(out_fd, 0); + if (err) { + close(out_fd); + goto close; + } + info_file = stdout; + } + } + + if (bytes == 0) + bytes = root->sectorsize; + + bytes = (bytes + root->sectorsize - 1) / root->sectorsize; + bytes *= root->sectorsize; + + while (bytes > 0) { + eb = debug_read_block(root, logical, root->sectorsize, copy); + if (eb && output_file) { + err = write(out_fd, eb->data, eb->len); + if (err < 0 || err != eb->len) { + fprintf(stderr, "output file write failed\n"); + goto out_close_fd; + } + } + free_extent_buffer(eb); + logical += root->sectorsize; + bytes -= root->sectorsize; + } + +out_close_fd: + if (output_file && out_fd != 1) + close(out_fd); +close: + close_ctree(root); + return ret; +} diff --git a/btrfs.c b/btrfs.c new file mode 100644 index 0000000..ab5e57f --- /dev/null +++ b/btrfs.c @@ -0,0 +1,387 @@ +/* + * 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. + */ + + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +#include "kerncompat.h" +#include "btrfs_cmds.h" +#include "version.h" + +typedef int (*CommandFunction)(int argc, char **argv); + +struct Command { + CommandFunction func; /* function which implements the command */ + int nargs; /* if == 999, any number of arguments + if >= 0, number of arguments, + if < 0, _minimum_ number of arguments */ + char *verb; /* verb */ + char *help; /* help lines; form the 2nd onward they are + indented */ + + /* the following fields are run-time filled by the program */ + char **cmds; /* array of subcommands */ + int ncmds; /* number of subcommand */ +}; + +static struct Command commands[] = { + + /* + avoid short commands different for the case only + */ + { do_clone, 2, + "subvolume snapshot", "<source> [<dest>/]<name>\n" + "Create a writable snapshot of the subvolume <source> with\n" + "the name <name> in the <dest> directory." + }, + { do_delete_subvolume, 1, + "subvolume delete", "<subvolume>\n" + "Delete the subvolume <subvolume>." + }, + { do_create_subvol, 1, + "subvolume create", "[<dest>/]<name>\n" + "Create a subvolume in <dest> (or the current directory if\n" + "not passed)." + }, + { do_subvol_list, 1, "subvolume list", "<path>\n" + "List the snapshot/subvolume of a filesystem." + }, + { do_find_newer, 2, "subvolume find-new", "<path> <last_gen>\n" + "List the recently modified files in a filesystem." + }, + { do_defrag, -1, + "filesystem defragment", "[-vcf] [-s start] [-l len] [-t size] <file>|<dir> [<file>|<dir>...]\n" + "Defragment a file or a directory." + }, + { do_set_default_subvol, 2, + "subvolume set-default", "<id> <path>\n" + "Set the subvolume of the filesystem <path> which will be mounted\n" + "as default." + }, + { do_fssync, 1, + "filesystem sync", "<path>\n" + "Force a sync on the filesystem <path>." + }, + { do_resize, 2, + "filesystem resize", "[+/-]<newsize>[gkm]|max <filesystem>\n" + "Resize the file system. If 'max' is passed, the filesystem\n" + "will occupe all available space on the device." + }, + { do_show_filesystem, 999, + "filesystem show", "[<uuid>|<label>]\n" + "Show the info of a btrfs filesystem. If no <uuid> or <label>\n" + "is passed, info of all the btrfs filesystem are shown." + }, + { do_df_filesystem, 1, + "filesystem df", "<path>\n" + "Show space usage information for a mount point\n." + }, + { do_balance, 1, + "filesystem balance", "<path>\n" + "Balance the chunks across the device." + }, + { do_scan, + 999, "device scan", "[<device> [<device>..]\n" + "Scan all device for or the passed device for a btrfs\n" + "filesystem." + }, + { do_add_volume, -2, + "device add", "<dev> [<dev>..] <path>\n" + "Add a device to a filesystem." + }, + { do_remove_volume, -2, + "device delete", "<dev> [<dev>..] <path>\n" + "Remove a device from a filesystem." + }, + /* coming soon + { 2, "filesystem label", "<label> <path>\n" + "Set the label of a filesystem" + } + */ + { 0, 0 , 0 } +}; + +static char *get_prgname(char *programname) +{ + char *np; + np = strrchr(programname,'/'); + if(!np) + np = programname; + else + np++; + + return np; +} + +static void print_help(char *programname, struct Command *cmd) +{ + char *pc; + + printf("\t%s %s ", programname, cmd->verb ); + + for(pc = cmd->help; *pc; pc++){ + putchar(*pc); + if(*pc == '\n') + printf("\t\t"); + } + putchar('\n'); +} + +static void help(char *np) +{ + struct Command *cp; + + printf("Usage:\n"); + for( cp = commands; cp->verb; cp++ ) + print_help(np, cp); + + printf("\n\t%s help|--help|-h\n\t\tShow the help.\n",np); + printf("\n%s\n", BTRFS_BUILD_VERSION); +} + +static int split_command(char *cmd, char ***commands) +{ + int c, l; + char *p, *s; + + for( *commands = 0, l = c = 0, p = s = cmd ; ; p++, l++ ){ + if ( *p && *p != ' ' ) + continue; + + /* c + 2 so that we have room for the null */ + (*commands) = realloc( (*commands), sizeof(char *)*(c + 2)); + (*commands)[c] = strndup(s, l); + c++; + l = 0; + s = p+1; + if( !*p ) break; + } + + (*commands)[c] = 0; + return c; +} + +/* + This function checks if the passed command is ambiguous +*/ +static int check_ambiguity(struct Command *cmd, char **argv){ + int i; + struct Command *cp; + /* check for ambiguity */ + for( i = 0 ; i < cmd->ncmds ; i++ ){ + int match; + for( match = 0, cp = commands; cp->verb; cp++ ){ + int j, skip; + char *s1, *s2; + + if( cp->ncmds < i ) + continue; + + for( skip = 0, j = 0 ; j < i ; j++ ) + if( strcmp(cmd->cmds[j], cp->cmds[j])){ + skip=1; + break; + } + if(skip) + continue; + + if( !strcmp(cmd->cmds[i], cp->cmds[i])) + continue; + for(s2 = cp->cmds[i], s1 = argv[i+1]; + *s1 == *s2 && *s1; s1++, s2++ ) ; + if( !*s1 ) + match++; + } + if(match){ + int j; + fprintf(stderr, "ERROR: in command '"); + for( j = 0 ; j <= i ; j++ ) + fprintf(stderr, "%s%s",j?" ":"", argv[j+1]); + fprintf(stderr, "', '%s' is ambiguous\n",argv[j]); + return -2; + } + } + return 0; +} + +/* + * This function, compacts the program name and the command in the first + * element of the '*av' array + */ +static int prepare_args(int *ac, char ***av, char *prgname, struct Command *cmd ){ + + char **ret; + int i; + char *newname; + + ret = (char **)malloc(sizeof(char*)*(*ac+1)); + newname = (char*)malloc(strlen(prgname)+strlen(cmd->verb)+2); + if( !ret || !newname ){ + free(ret); + free(newname); + return -1; + } + + ret[0] = newname; + for(i=0; i < *ac ; i++ ) + ret[i+1] = (*av)[i]; + + strcpy(newname, prgname); + strcat(newname, " "); + strcat(newname, cmd->verb); + + (*ac)++; + *av = ret; + + return 0; + +} + + + +/* + + This function perform the following jobs: + - show the help if '--help' or 'help' or '-h' are passed + - verify that a command is not ambiguous, otherwise show which + part of the command is ambiguous + - if after a (even partial) command there is '--help' show the help + for all the matching commands + - if the command doesn't' match show an error + - finally, if a command match, they return which command is matched and + the arguments + + The function return 0 in case of help is requested; <0 in case + of uncorrect command; >0 in case of matching commands + argc, argv are the arg-counter and arg-vector (input) + *nargs_ is the number of the arguments after the command (output) + **cmd_ is the invoked command (output) + ***args_ are the arguments after the command + +*/ +static int parse_args(int argc, char **argv, + CommandFunction *func_, + int *nargs_, char **cmd_, char ***args_ ) +{ + struct Command *cp; + struct Command *matchcmd=0; + char *prgname = get_prgname(argv[0]); + int i=0, helprequested=0; + + if( argc < 2 || !strcmp(argv[1], "help") || + !strcmp(argv[1], "-h") || !strcmp(argv[1], "--help")){ + help(prgname); + return 0; + } + + for( cp = commands; cp->verb; cp++ ) + if( !cp->ncmds) + cp->ncmds = split_command(cp->verb, &(cp->cmds)); + + for( cp = commands; cp->verb; cp++ ){ + int match; + + if( argc-1 < cp->ncmds ) + continue; + for( match = 1, i = 0 ; i < cp->ncmds ; i++ ){ + char *s1, *s2; + s1 = cp->cmds[i]; + s2 = argv[i+1]; + + for(s2 = cp->cmds[i], s1 = argv[i+1]; + *s1 == *s2 && *s1; + s1++, s2++ ) ; + if( *s1 ){ + match=0; + break; + } + } + + /* If you understand why this code works ... + you are a genious !! */ + if(argc>i+1 && !strcmp(argv[i+1],"--help")){ + if(!helprequested) + printf("Usage:\n"); + print_help(prgname, cp); + helprequested=1; + continue; + } + + if(!match) + continue; + + matchcmd = cp; + *nargs_ = argc-matchcmd->ncmds-1; + *cmd_ = matchcmd->verb; + *args_ = argv+matchcmd->ncmds+1; + *func_ = cp->func; + + break; + } + + if(helprequested){ + printf("\n%s\n", BTRFS_BUILD_VERSION); + return 0; + } + + if(!matchcmd){ + fprintf( stderr, "ERROR: unknown command '%s'\n",argv[1]); + help(prgname); + return -1; + } + + if(check_ambiguity(matchcmd, argv)) + return -2; + + /* check the number of argument */ + if (matchcmd->nargs < 0 && matchcmd->nargs < -*nargs_ ){ + fprintf(stderr, "ERROR: '%s' requires minimum %d arg(s)\n", + matchcmd->verb, -matchcmd->nargs); + return -2; + } + if(matchcmd->nargs >= 0 && matchcmd->nargs != *nargs_ && matchcmd->nargs != 999){ + fprintf(stderr, "ERROR: '%s' requires %d arg(s)\n", + matchcmd->verb, matchcmd->nargs); + return -2; + } + + if (prepare_args( nargs_, args_, prgname, matchcmd )){ + fprintf(stderr, "ERROR: not enough memory\\n"); + return -20; + } + + + return 1; +} +int main(int ac, char **av ) +{ + + char *cmd=0, **args=0; + int nargs=0, r; + CommandFunction func=0; + + r = parse_args(ac, av, &func, &nargs, &cmd, &args); + if( r <= 0 ){ + /* error or no command to parse*/ + exit(-r); + } + + exit(func(nargs, args)); + +} + diff --git a/btrfs_cmds.c b/btrfs_cmds.c new file mode 100644 index 0000000..8031c58 --- /dev/null +++ b/btrfs_cmds.c @@ -0,0 +1,924 @@ +/* + * 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. + */ + + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <sys/ioctl.h> +#include <sys/types.h> +#include <dirent.h> +#include <sys/stat.h> +#include <unistd.h> +#include <fcntl.h> +#include <libgen.h> +#include <limits.h> +#include <uuid/uuid.h> +#include <ctype.h> + +#undef ULONG_MAX + +#include "kerncompat.h" +#include "ctree.h" +#include "transaction.h" +#include "utils.h" +#include "version.h" +#include "ioctl.h" +#include "volumes.h" + +#include "btrfs_cmds.h" + +#ifdef __CHECKER__ +#define BLKGETSIZE64 0 +#define BTRFS_IOC_SNAP_CREATE 0 +#define BTRFS_VOL_NAME_MAX 255 +struct btrfs_ioctl_vol_args { char name[BTRFS_VOL_NAME_MAX]; }; +static inline int ioctl(int fd, int define, void *arg) { return 0; } +#endif + +/* + * test if path is a subvolume: + * this function return + * 0-> path exists but it is not a subvolume + * 1-> path exists and it is a subvolume + * -1 -> path is unaccessible + */ +static int test_issubvolume(char *path) +{ + + struct stat st; + int res; + + res = stat(path, &st); + if(res < 0 ) + return -1; + + return (st.st_ino == 256) && S_ISDIR(st.st_mode); + +} + +/* + * test if path is a directory + * this function return + * 0-> path exists but it is not a directory + * 1-> path exists and it is a directory + * -1 -> path is unaccessible + */ +static int test_isdir(char *path) +{ + struct stat st; + int res; + + res = stat(path, &st); + if(res < 0 ) + return -1; + + return S_ISDIR(st.st_mode); + +} + +static int open_file_or_dir(const char *fname) +{ + int ret; + struct stat st; + DIR *dirstream; + int fd; + + ret = stat(fname, &st); + if (ret < 0) { + return -1; + } + if (S_ISDIR(st.st_mode)) { + dirstream = opendir(fname); + if (!dirstream) { + return -2; + } + fd = dirfd(dirstream); + } else { + fd = open(fname, O_RDWR); + } + if (fd < 0) { + return -3; + } + return fd; +} + +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 atoll(s) * mult; +} + +int do_defrag(int ac, char **av) +{ + int fd; + int compress = 0; + int flush = 0; + u64 start = 0; + u64 len = (u64)-1; + u32 thresh = 0; + int i; + int errors = 0; + int ret = 0; + int verbose = 0; + int fancy_ioctl = 0; + struct btrfs_ioctl_defrag_range_args range; + + optind = 1; + while(1) { + int c = getopt(ac, av, "vcfs:l:t:"); + if (c < 0) + break; + switch(c) { + case 'c': + compress = 1; + fancy_ioctl = 1; + break; + case 'f': + flush = 1; + fancy_ioctl = 1; + break; + case 'v': + verbose = 1; + break; + case 's': + start = parse_size(optarg); + fancy_ioctl = 1; + break; + case 'l': + len = parse_size(optarg); + fancy_ioctl = 1; + break; + case 't': + thresh = parse_size(optarg); + fancy_ioctl = 1; + break; + default: + fprintf(stderr, "Invalid arguments for defragment\n"); + free(av); + return 1; + } + } + if (ac - optind == 0) { + fprintf(stderr, "Invalid arguments for defragment\n"); + free(av); + return 1; + } + + memset(&range, 0, sizeof(range)); + range.start = start; + range.len = len; + range.extent_thresh = thresh; + if (compress) + range.flags |= BTRFS_DEFRAG_RANGE_COMPRESS; + if (flush) + range.flags |= BTRFS_DEFRAG_RANGE_START_IO; + + for (i = optind; i < ac; i++) { + if (verbose) + printf("%s\n", av[i]); + fd = open_file_or_dir(av[i]); + if (fd < 0) { + fprintf(stderr, "failed to open %s\n", av[i]); + perror("open:"); + errors++; + continue; + } + if (!fancy_ioctl) { + ret = ioctl(fd, BTRFS_IOC_DEFRAG, NULL); + } else { + ret = ioctl(fd, BTRFS_IOC_DEFRAG_RANGE, &range); + if (ret && errno == ENOTTY) { + fprintf(stderr, "defrag range ioctl not " + "supported in this kernel, please try " + "without any options.\n"); + errors++; + break; + } + } + if (ret) { + fprintf(stderr, "ioctl failed on %s ret %d errno %d\n", + av[i], ret, errno); + errors++; + } + close(fd); + } + if (verbose) + printf("%s\n", BTRFS_BUILD_VERSION); + if (errors) { + fprintf(stderr, "total %d failures\n", errors); + exit(1); + } + + free(av); + return errors + 20; +} + +int do_find_newer(int argc, char **argv) +{ + int fd; + int ret; + char *subvol; + u64 last_gen; + + subvol = argv[1]; + last_gen = atoll(argv[2]); + + ret = test_issubvolume(subvol); + if (ret < 0) { + fprintf(stderr, "ERROR: error accessing '%s'\n", subvol); + return 12; + } + if (!ret) { + fprintf(stderr, "ERROR: '%s' is not a subvolume\n", subvol); + return 13; + } + + fd = open_file_or_dir(subvol); + if (fd < 0) { + fprintf(stderr, "ERROR: can't access '%s'\n", subvol); + return 12; + } + ret = find_updated_files(fd, 0, last_gen); + if (ret) + return 19; + return 0; +} + +int do_subvol_list(int argc, char **argv) +{ + int fd; + int ret; + char *subvol; + + subvol = argv[1]; + + ret = test_issubvolume(subvol); + if (ret < 0) { + fprintf(stderr, "ERROR: error accessing '%s'\n", subvol); + return 12; + } + if (!ret) { + fprintf(stderr, "ERROR: '%s' is not a subvolume\n", subvol); + return 13; + } + + fd = open_file_or_dir(subvol); + if (fd < 0) { + fprintf(stderr, "ERROR: can't access '%s'\n", subvol); + return 12; + } + ret = list_subvols(fd); + if (ret) + return 19; + return 0; +} + +int do_clone(int argc, char **argv) +{ + char *subvol, *dst; + int res, fd, fddst, len; + char *newname; + char *dstdir; + + subvol = argv[1]; + dst = argv[2]; + struct btrfs_ioctl_vol_args args; + + res = test_issubvolume(subvol); + if(res<0){ + fprintf(stderr, "ERROR: error accessing '%s'\n", subvol); + return 12; + } + if(!res){ + fprintf(stderr, "ERROR: '%s' is not a subvolume\n", subvol); + return 13; + } + + res = test_isdir(dst); + if(res == 0 ){ + fprintf(stderr, "ERROR: '%s' exists and it is not a directory\n", dst); + return 12; + } + + if(res>0){ + newname = strdup(subvol); + newname = basename(newname); + dstdir = dst; + }else{ + newname = strdup(dst); + newname = basename(newname); + dstdir = strdup(dst); + dstdir = dirname(dstdir); + } + + if( !strcmp(newname,".") || !strcmp(newname,"..") || + strchr(newname, '/') ){ + fprintf(stderr, "ERROR: incorrect snapshot name ('%s')\n", + newname); + return 14; + } + + len = strlen(newname); + if (len == 0 || len >= BTRFS_VOL_NAME_MAX) { + fprintf(stderr, "ERROR: snapshot name too long ('%s)\n", + newname); + return 14; + } + + fddst = open_file_or_dir(dstdir); + if (fddst < 0) { + fprintf(stderr, "ERROR: can't access to '%s'\n", dstdir); + return 12; + } + + fd = open_file_or_dir(subvol); + if (fd < 0) { + close(fddst); + fprintf(stderr, "ERROR: can't access to '%s'\n", dstdir); + return 12; + } + + printf("Create a snapshot of '%s' in '%s/%s'\n", + subvol, dstdir, newname); + args.fd = fd; + strcpy(args.name, newname); + res = ioctl(fddst, BTRFS_IOC_SNAP_CREATE, &args); + + close(fd); + close(fddst); + + if(res < 0 ){ + fprintf( stderr, "ERROR: cannot snapshot '%s'\n",subvol); + return 11; + } + + return 0; + +} + +int do_delete_subvolume(int argc, char **argv) +{ + int res, fd, len; + struct btrfs_ioctl_vol_args args; + char *dname, *vname, *cpath; + char *path = argv[1]; + + res = test_issubvolume(path); + if(res<0){ + fprintf(stderr, "ERROR: error accessing '%s'\n", path); + return 12; + } + if(!res){ + fprintf(stderr, "ERROR: '%s' is not a subvolume\n", path); + return 13; + } + + cpath = realpath(path, 0); + dname = strdup(cpath); + dname = dirname(dname); + vname = strdup(cpath); + vname = basename(vname); + free(cpath); + + if( !strcmp(vname,".") || !strcmp(vname,"..") || + strchr(vname, '/') ){ + fprintf(stderr, "ERROR: incorrect subvolume name ('%s')\n", + vname); + return 14; + } + + len = strlen(vname); + if (len == 0 || len >= BTRFS_VOL_NAME_MAX) { + fprintf(stderr, "ERROR: snapshot name too long ('%s)\n", + vname); + return 14; + } + + fd = open_file_or_dir(dname); + if (fd < 0) { + close(fd); + fprintf(stderr, "ERROR: can't access to '%s'\n", dname); + return 12; + } + + printf("Delete subvolume '%s/%s'\n", dname, vname); + strcpy(args.name, vname); + res = ioctl(fd, BTRFS_IOC_SNAP_DESTROY, &args); + + close(fd); + + if(res < 0 ){ + fprintf( stderr, "ERROR: cannot delete '%s/%s'\n",dname, vname); + return 11; + } + + return 0; + +} + +int do_create_subvol(int argc, char **argv) +{ + int res, fddst, len; + char *newname; + char *dstdir; + struct btrfs_ioctl_vol_args args; + char *dst = argv[1]; + + res = test_isdir(dst); + if(res >= 0 ){ + fprintf(stderr, "ERROR: '%s' exists\n", dst); + return 12; + } + + newname = strdup(dst); + newname = basename(newname); + dstdir = strdup(dst); + dstdir = dirname(dstdir); + + if( !strcmp(newname,".") || !strcmp(newname,"..") || + strchr(newname, '/') ){ + fprintf(stderr, "ERROR: uncorrect subvolume name ('%s')\n", + newname); + return 14; + } + + len = strlen(newname); + if (len == 0 || len >= BTRFS_VOL_NAME_MAX) { + fprintf(stderr, "ERROR: subvolume name too long ('%s)\n", + newname); + return 14; + } + + fddst = open_file_or_dir(dstdir); + if (fddst < 0) { + fprintf(stderr, "ERROR: can't access to '%s'\n", dstdir); + return 12; + } + + printf("Create subvolume '%s/%s'\n", dstdir, newname); + strcpy(args.name, newname); + res = ioctl(fddst, BTRFS_IOC_SUBVOL_CREATE, &args); + + close(fddst); + + if(res < 0 ){ + fprintf( stderr, "ERROR: cannot create subvolume\n"); + return 11; + } + + return 0; + +} + +int do_fssync(int argc, char **argv) +{ + int fd, res; + char *path = argv[1]; + + fd = open_file_or_dir(path); + if (fd < 0) { + fprintf(stderr, "ERROR: can't access to '%s'\n", path); + return 12; + } + + printf("FSSync '%s'\n", path); + res = ioctl(fd, BTRFS_IOC_SYNC); + close(fd); + if( res < 0 ){ + fprintf(stderr, "ERROR: unable to fs-syncing '%s'\n", path); + return 16; + } + + return 0; +} + +int do_scan(int argc, char **argv) +{ + int i, fd; + if(argc<=1){ + int ret; + + printf("Scanning for Btrfs filesystems\n"); + ret = btrfs_scan_one_dir("/dev", 1); + if (ret){ + fprintf(stderr, "ERROR: error %d while scanning\n", ret); + return 18; + } + return 0; + } + + fd = open("/dev/btrfs-control", O_RDWR); + if (fd < 0) { + perror("failed to open /dev/btrfs-control"); + return 10; + } + + for( i = 1 ; i < argc ; i++ ){ + struct btrfs_ioctl_vol_args args; + int ret; + + printf("Scanning for Btrfs filesystems in '%s'\n", argv[i]); + + strcpy(args.name, argv[i]); + /* + * FIXME: which are the error code returned by this ioctl ? + * it seems that is impossible to understand if there no is + * a btrfs filesystem from an I/O error !!! + */ + ret = ioctl(fd, BTRFS_IOC_SCAN_DEV, &args); + + if( ret < 0 ){ + close(fd); + fprintf(stderr, "ERROR: unable to scan the device '%s'\n", argv[i]); + return 11; + } + } + + close(fd); + return 0; + +} + +int do_resize(int argc, char **argv) +{ + + struct btrfs_ioctl_vol_args args; + int fd, res, len; + char *amount=argv[1], *path=argv[2]; + + fd = open_file_or_dir(path); + if (fd < 0) { + fprintf(stderr, "ERROR: can't access to '%s'\n", path); + return 12; + } + len = strlen(amount); + if (len == 0 || len >= BTRFS_VOL_NAME_MAX) { + fprintf(stderr, "ERROR: size value too long ('%s)\n", + amount); + return 14; + } + + printf("Resize '%s' of '%s'\n", path, amount); + strcpy(args.name, amount); + res = ioctl(fd, BTRFS_IOC_RESIZE, &args); + close(fd); + if( res < 0 ){ + fprintf(stderr, "ERROR: unable to resize '%s'\n", path); + return 30; + } + return 0; +} + +static int uuid_search(struct btrfs_fs_devices *fs_devices, char *search) +{ + struct list_head *cur; + struct btrfs_device *device; + + list_for_each(cur, &fs_devices->devices) { + device = list_entry(cur, struct btrfs_device, dev_list); + if ((device->label && strcmp(device->label, search) == 0) || + strcmp(device->name, search) == 0) + return 1; + } + return 0; +} + +static void print_one_uuid(struct btrfs_fs_devices *fs_devices) +{ + char uuidbuf[37]; + struct list_head *cur; + struct btrfs_device *device; + char *super_bytes_used; + u64 devs_found = 0; + u64 total; + + uuid_unparse(fs_devices->fsid, uuidbuf); + device = list_entry(fs_devices->devices.next, struct btrfs_device, + dev_list); + if (device->label && device->label[0]) + printf("Label: '%s' ", device->label); + else + printf("Label: none "); + + super_bytes_used = pretty_sizes(device->super_bytes_used); + + total = device->total_devs; + printf(" uuid: %s\n\tTotal devices %llu FS bytes used %s\n", uuidbuf, + (unsigned long long)total, super_bytes_used); + + free(super_bytes_used); + + list_for_each(cur, &fs_devices->devices) { + char *total_bytes; + char *bytes_used; + device = list_entry(cur, struct btrfs_device, dev_list); + total_bytes = pretty_sizes(device->total_bytes); + bytes_used = pretty_sizes(device->bytes_used); + printf("\tdevid %4llu size %s used %s path %s\n", + (unsigned long long)device->devid, + total_bytes, bytes_used, device->name); + free(total_bytes); + free(bytes_used); + devs_found++; + } + if (devs_found < total) { + printf("\t*** Some devices missing\n"); + } + printf("\n"); +} + +int do_show_filesystem(int argc, char **argv) +{ + struct list_head *all_uuids; + struct btrfs_fs_devices *fs_devices; + struct list_head *cur_uuid; + char *search = argv[1]; + int ret; + + ret = btrfs_scan_one_dir("/dev", 0); + if (ret){ + fprintf(stderr, "ERROR: error %d while scanning\n", ret); + return 18; + } + + all_uuids = btrfs_scanned_uuids(); + list_for_each(cur_uuid, all_uuids) { + fs_devices = list_entry(cur_uuid, struct btrfs_fs_devices, + list); + if (search && uuid_search(fs_devices, search) == 0) + continue; + print_one_uuid(fs_devices); + } + printf("%s\n", BTRFS_BUILD_VERSION); + return 0; +} + +int do_add_volume(int nargs, char **args) +{ + + char *mntpnt = args[nargs-1]; + int i, fdmnt, ret=0; + + + fdmnt = open_file_or_dir(mntpnt); + if (fdmnt < 0) { + fprintf(stderr, "ERROR: can't access to '%s'\n", mntpnt); + return 12; + } + + for(i=1 ; i < (nargs-1) ; i++ ){ + struct btrfs_ioctl_vol_args ioctl_args; + int devfd, res; + u64 dev_block_count = 0; + struct stat st; + + devfd = open(args[i], O_RDWR); + if (!devfd) { + fprintf(stderr, "ERROR: Unable to open device '%s'\n", args[i]); + close(devfd); + ret++; + continue; + } + ret = fstat(devfd, &st); + if (ret) { + fprintf(stderr, "ERROR: Unable to stat '%s'\n", args[i]); + close(devfd); + ret++; + continue; + } + if (!S_ISBLK(st.st_mode)) { + fprintf(stderr, "ERROR: '%s' is not a block device\n", args[i]); + close(devfd); + ret++; + continue; + } + + res = btrfs_prepare_device(devfd, args[i], 1, &dev_block_count); + if (res) { + fprintf(stderr, "ERROR: Unable to init '%s'\n", args[i]); + close(devfd); + ret++; + continue; + } + close(devfd); + + strcpy(ioctl_args.name, args[i]); + res = ioctl(fdmnt, BTRFS_IOC_ADD_DEV, &ioctl_args); + if(res<0){ + fprintf(stderr, "ERROR: error adding the device '%s'\n", args[i]); + ret++; + } + + } + + close(fdmnt); + if( ret) + return ret+20; + else + return 0; + +} + +int do_balance(int argc, char **argv) +{ + + int fdmnt, ret=0; + struct btrfs_ioctl_vol_args args; + char *path = argv[1]; + + fdmnt = open_file_or_dir(path); + if (fdmnt < 0) { + fprintf(stderr, "ERROR: can't access to '%s'\n", path); + return 12; + } + + memset(&args, 0, sizeof(args)); + ret = ioctl(fdmnt, BTRFS_IOC_BALANCE, &args); + close(fdmnt); + if(ret<0){ + fprintf(stderr, "ERROR: balancing '%s'\n", path); + + return 19; + } + return 0; +} +int do_remove_volume(int nargs, char **args) +{ + + char *mntpnt = args[nargs-1]; + int i, fdmnt, ret=0; + + fdmnt = open_file_or_dir(mntpnt); + if (fdmnt < 0) { + fprintf(stderr, "ERROR: can't access to '%s'\n", mntpnt); + return 12; + } + + for(i=1 ; i < (nargs-1) ; i++ ){ + struct btrfs_ioctl_vol_args arg; + int res; + + strcpy(arg.name, args[i]); + res = ioctl(fdmnt, BTRFS_IOC_RM_DEV, &arg); + if(res<0){ + fprintf(stderr, "ERROR: error removing the device '%s'\n", args[i]); + ret++; + } + } + + close(fdmnt); + if( ret) + return ret+20; + else + return 0; +} + +int do_set_default_subvol(int nargs, char **argv) +{ + int ret=0, fd; + u64 objectid; + char *path = argv[2]; + char *subvolid = argv[1]; + + fd = open_file_or_dir(path); + if (fd < 0) { + fprintf(stderr, "ERROR: can't access to '%s'\n", path); + return 12; + } + + objectid = (unsigned long long)strtoll(subvolid, NULL, 0); + if (errno == ERANGE) { + fprintf(stderr, "ERROR: invalid tree id (%s)\n",subvolid); + return 30; + } + ret = ioctl(fd, BTRFS_IOC_DEFAULT_SUBVOL, &objectid); + close(fd); + if( ret < 0 ){ + fprintf(stderr, "ERROR: unable to set a new default subvolume\n"); + return 30; + } + return 0; +} + +int do_df_filesystem(int nargs, char **argv) +{ + struct btrfs_ioctl_space_args *sargs; + u64 count = 0, i; + int ret; + int fd; + char *path = argv[1]; + + fd = open_file_or_dir(path); + if (fd < 0) { + fprintf(stderr, "ERROR: can't access to '%s'\n", path); + return 12; + } + + sargs = malloc(sizeof(struct btrfs_ioctl_space_args)); + if (!sargs) + return -ENOMEM; + + sargs->space_slots = 0; + sargs->total_spaces = 0; + + ret = ioctl(fd, BTRFS_IOC_SPACE_INFO, sargs); + if (ret) { + free(sargs); + return ret; + } + if (!sargs->total_spaces) + return 0; + + count = sargs->total_spaces; + + sargs = realloc(sargs, sizeof(struct btrfs_ioctl_space_args) + + (count * sizeof(struct btrfs_ioctl_space_info))); + if (!sargs) + return -ENOMEM; + + sargs->space_slots = count; + sargs->total_spaces = 0; + + ret = ioctl(fd, BTRFS_IOC_SPACE_INFO, sargs); + if (ret) { + free(sargs); + return ret; + } + + for (i = 0; i < sargs->total_spaces; i++) { + char description[80]; + char *total_bytes; + char *used_bytes; + int written = 0; + u64 flags = sargs->spaces[i].flags; + + memset(description, 0, 80); + + if (flags & BTRFS_BLOCK_GROUP_DATA) { + snprintf(description, 5, "%s", "Data"); + written += 4; + } else if (flags & BTRFS_BLOCK_GROUP_SYSTEM) { + snprintf(description, 7, "%s", "System"); + written += 6; + } else if (flags & BTRFS_BLOCK_GROUP_METADATA) { + snprintf(description, 9, "%s", "Metadata"); + written += 8; + } + + if (flags & BTRFS_BLOCK_GROUP_RAID0) { + snprintf(description+written, 8, "%s", ", RAID0"); + written += 7; + } else if (flags & BTRFS_BLOCK_GROUP_RAID1) { + snprintf(description+written, 8, "%s", ", RAID1"); + written += 7; + } else if (flags & BTRFS_BLOCK_GROUP_DUP) { + snprintf(description+written, 6, "%s", ", DUP"); + written += 5; + } else if (flags & BTRFS_BLOCK_GROUP_RAID10) { + snprintf(description+written, 9, "%s", ", RAID10"); + written += 8; + } + + total_bytes = pretty_sizes(sargs->spaces[i].total_bytes); + used_bytes = pretty_sizes(sargs->spaces[i].used_bytes); + printf("%s: total=%s, used=%s\n", description, total_bytes, + used_bytes); + } + free(sargs); + + return 0; +} diff --git a/btrfs_cmds.h b/btrfs_cmds.h new file mode 100644 index 0000000..7bde191 --- /dev/null +++ b/btrfs_cmds.h @@ -0,0 +1,34 @@ +/* + * 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. + */ + +/* btrfs_cmds.c*/ +int do_clone(int nargs, char **argv); +int do_delete_subvolume(int nargs, char **argv); +int do_create_subvol(int nargs, char **argv); +int do_fssync(int nargs, char **argv); +int do_defrag(int argc, char **argv); +int do_show_filesystem(int nargs, char **argv); +int do_add_volume(int nargs, char **args); +int do_balance(int nargs, char **argv); +int do_remove_volume(int nargs, char **args); +int do_scan(int nargs, char **argv); +int do_resize(int nargs, char **argv); +int do_subvol_list(int nargs, char **argv); +int do_set_default_subvol(int nargs, char **argv); +int list_subvols(int fd); +int do_df_filesystem(int nargs, char **argv); +int find_updated_files(int fd, u64 root_id, u64 oldest_gen); +int do_find_newer(int argc, char **argv); diff --git a/btrfsck.c b/btrfsck.c index 40c90f8..73f1836 100644 --- a/btrfsck.c +++ b/btrfsck.c @@ -36,7 +36,7 @@ static u64 total_fs_tree_bytes = 0; static u64 btree_space_waste = 0; static u64 data_bytes_allocated = 0; static u64 data_bytes_referenced = 0; -int found_old_backref = 0; +static int found_old_backref = 0; struct extent_backref { struct list_head list; @@ -100,7 +100,11 @@ struct inode_backref { #define REF_ERR_DUP_INODE_REF (1 << 5) #define REF_ERR_INDEX_UNMATCH (1 << 6) #define REF_ERR_FILETYPE_UNMATCH (1 << 7) -#define REF_ERR_NAME_TOO_LONG (1 << 8) +#define REF_ERR_NAME_TOO_LONG (1 << 8) // 100 +#define REF_ERR_NO_ROOT_REF (1 << 9) +#define REF_ERR_NO_ROOT_BACKREF (1 << 10) +#define REF_ERR_DUP_ROOT_REF (1 << 11) +#define REF_ERR_DUP_ROOT_BACKREF (1 << 12) struct inode_record { struct list_head backrefs; @@ -144,6 +148,29 @@ struct inode_record { #define I_ERR_SOME_CSUM_MISSING (1 << 12) #define I_ERR_LINK_COUNT_WRONG (1 << 13) +struct root_backref { + struct list_head list; + unsigned int found_dir_item:1; + unsigned int found_dir_index:1; + unsigned int found_back_ref:1; + unsigned int found_forward_ref:1; + unsigned int reachable:1; + int errors; + u64 ref_root; + u64 dir; + u64 index; + u16 namelen; + char name[0]; +}; + +struct root_record { + struct list_head backrefs; + struct cache_extent cache; + unsigned int found_root_item:1; + u64 objectid; + u32 found_ref; +}; + struct ptr_node { struct cache_extent cache; void *data; @@ -151,6 +178,7 @@ struct ptr_node { struct shared_node { struct cache_extent cache; + struct cache_tree root_cache; struct cache_tree inode_cache; struct inode_record *current; u32 refs; @@ -258,6 +286,14 @@ static void free_inode_rec(struct inode_record *rec) free(rec); } +static int can_free_inode_rec(struct inode_record *rec) +{ + if (!rec->errors && rec->checked && rec->found_inode_item && + rec->nlink == rec->found_link && list_empty(&rec->backrefs)) + return 1; + return 0; +} + static void maybe_free_inode_rec(struct cache_tree *inode_cache, struct inode_record *rec) { @@ -309,8 +345,7 @@ static void maybe_free_inode_rec(struct cache_tree *inode_cache, } BUG_ON(rec->refs != 1); - if (!rec->errors && rec->nlink == rec->found_link && - list_empty(&rec->backrefs)) { + if (can_free_inode_rec(rec)) { cache = find_cache_extent(inode_cache, rec->ino, 1); node = container_of(cache, struct ptr_node, cache); BUG_ON(node->data != rec); @@ -338,14 +373,12 @@ static int check_orphan_item(struct btrfs_root *root, u64 ino) return ret; } -static int process_inode_item(struct btrfs_root *root, - struct extent_buffer *eb, +static int process_inode_item(struct extent_buffer *eb, int slot, struct btrfs_key *key, struct shared_node *active_node) { struct inode_record *rec; struct btrfs_inode_item *item; - int ret; rec = active_node->current; BUG_ON(rec->ino != key->objectid || rec->refs > 1); @@ -361,11 +394,8 @@ static int process_inode_item(struct btrfs_root *root, if (btrfs_inode_flags(eb, item) & BTRFS_INODE_NODATASUM) rec->nodatasum = 1; rec->found_inode_item = 1; - if (rec->nlink == 0) { - ret = check_orphan_item(root, rec->ino); - if (ret == -ENOENT) - rec->errors |= I_ERR_NO_ORPHAN_ITEM; - } + if (rec->nlink == 0) + rec->errors |= I_ERR_NO_ORPHAN_ITEM; maybe_free_inode_rec(&active_node->inode_cache, rec); return 0; } @@ -443,10 +473,9 @@ static int add_inode_backref(struct cache_tree *inode_cache, } static int merge_inode_recs(struct inode_record *src, struct inode_record *dst, - struct shared_node *dst_node) + struct cache_tree *dst_cache) { struct inode_backref *backref; - struct cache_tree *dst_cache = &dst_node->inode_cache; dst->merging = 1; list_for_each_entry(backref, &src->backrefs, list) { @@ -510,14 +539,8 @@ static int merge_inode_recs(struct inode_record *src, struct inode_record *dst, dst->errors |= I_ERR_DUP_INODE_ITEM; } } - - if (src->checked) { - dst->checked = 1; - if (dst_node->current == dst) - dst_node->current = NULL; - } dst->merging = 0; - maybe_free_inode_rec(dst_cache, dst); + return 0; } @@ -537,8 +560,9 @@ static int splice_shared_node(struct shared_node *src_node, if (src_node->current) current_ino = src_node->current->ino; - src = &src_node->inode_cache; - dst = &dst_node->inode_cache; + src = &src_node->root_cache; + dst = &dst_node->root_cache; +again: cache = find_first_cache_extent(src, 0); while (cache) { node = container_of(cache, struct ptr_node, cache); @@ -557,14 +581,28 @@ static int splice_shared_node(struct shared_node *src_node, } ret = insert_existing_cache_extent(dst, &ins->cache); if (ret == -EEXIST) { + WARN_ON(src == &src_node->root_cache); conflict = get_inode_rec(dst, rec->ino, 1); - merge_inode_recs(rec, conflict, dst_node); + merge_inode_recs(rec, conflict, dst); + if (rec->checked) { + conflict->checked = 1; + if (dst_node->current == conflict) + dst_node->current = NULL; + } + maybe_free_inode_rec(dst, conflict); free_inode_rec(rec); free(ins); } else { BUG_ON(ret); } } + + if (src == &src_node->root_cache) { + src = &src_node->inode_cache; + dst = &dst_node->inode_cache; + goto again; + } + if (current_ino > 0 && (!dst_node->current || current_ino > dst_node->current->ino)) { if (dst_node->current) { @@ -616,6 +654,7 @@ static int add_shared_node(struct cache_tree *shared, u64 bytenr, u32 refs) node = calloc(1, sizeof(*node)); node->cache.start = bytenr; node->cache.size = 1; + cache_tree_init(&node->root_cache); cache_tree_init(&node->inode_cache); node->refs = refs; @@ -646,6 +685,7 @@ static int enter_shared_node(struct btrfs_root *root, u64 bytenr, u32 refs, if (wc->root_level == wc->active_node && btrfs_root_refs(&root->root_item) == 0) { if (--node->refs == 0) { + free_inode_recs(&node->root_cache); free_inode_recs(&node->inode_cache); remove_cache_extent(&wc->shared, &node->cache); free(node); @@ -708,10 +748,12 @@ static int process_dir_item(struct extent_buffer *eb, int filetype; struct btrfs_dir_item *di; struct inode_record *rec; + struct cache_tree *root_cache; struct cache_tree *inode_cache; struct btrfs_key location; char namebuf[BTRFS_NAME_LEN]; + root_cache = &active_node->root_cache; inode_cache = &active_node->inode_cache; rec = active_node->current; rec->found_dir_item = 1; @@ -740,7 +782,9 @@ static int process_dir_item(struct extent_buffer *eb, key->objectid, key->offset, namebuf, len, filetype, key->type, error); } else if (location.type == BTRFS_ROOT_ITEM_KEY) { - /* fixme: check root back & forward references */ + add_inode_backref(root_cache, location.objectid, + key->objectid, key->offset, namebuf, + len, filetype, key->type, error); } else { fprintf(stderr, "warning line %d\n", __LINE__); } @@ -977,8 +1021,7 @@ static int process_one_leaf(struct btrfs_root *root, struct extent_buffer *eb, ret = process_inode_ref(eb, i, &key, active_node); break; case BTRFS_INODE_ITEM_KEY: - ret = process_inode_item(root, eb, i, &key, - active_node); + ret = process_inode_item(eb, i, &key, active_node); break; case BTRFS_EXTENT_DATA_KEY: ret = process_file_extent(root, eb, i, &key, @@ -1176,13 +1219,23 @@ static int check_inode_recs(struct btrfs_root *root, node = container_of(cache, struct ptr_node, cache); rec = node->data; remove_cache_extent(inode_cache, &node->cache); + free(node); if (rec->ino == root_dirid || rec->ino == BTRFS_ORPHAN_OBJECTID) { - free(node); free_inode_rec(rec); continue; } + if (rec->errors & I_ERR_NO_ORPHAN_ITEM) { + ret = check_orphan_item(root, rec->ino); + if (ret == 0) + rec->errors &= ~I_ERR_NO_ORPHAN_ITEM; + if (can_free_inode_rec(rec)) { + free_inode_rec(rec); + continue; + } + } + error++; if (!rec->found_inode_item) rec->errors |= I_ERR_NO_INODE_ITEM; @@ -1205,13 +1258,314 @@ static int check_inode_recs(struct btrfs_root *root, backref->namelen, backref->name, backref->filetype, backref->errors); } - free(node); free_inode_rec(rec); } return (error > 0) ? -1 : 0; } +static struct root_record *get_root_rec(struct cache_tree *root_cache, + u64 objectid) +{ + struct cache_extent *cache; + struct root_record *rec = NULL; + int ret; + + cache = find_cache_extent(root_cache, objectid, 1); + if (cache) { + rec = container_of(cache, struct root_record, cache); + } else { + rec = calloc(1, sizeof(*rec)); + rec->objectid = objectid; + INIT_LIST_HEAD(&rec->backrefs); + rec->cache.start = objectid; + rec->cache.size = 1; + + ret = insert_existing_cache_extent(root_cache, &rec->cache); + BUG_ON(ret); + } + return rec; +} + +static struct root_backref *get_root_backref(struct root_record *rec, + u64 ref_root, u64 dir, u64 index, + const char *name, int namelen) +{ + struct root_backref *backref; + + list_for_each_entry(backref, &rec->backrefs, list) { + if (backref->ref_root != ref_root || backref->dir != dir || + backref->namelen != namelen) + continue; + if (memcmp(name, backref->name, namelen)) + continue; + return backref; + } + + backref = malloc(sizeof(*backref) + namelen + 1); + memset(backref, 0, sizeof(*backref)); + backref->ref_root = ref_root; + backref->dir = dir; + backref->index = index; + backref->namelen = namelen; + memcpy(backref->name, name, namelen); + backref->name[namelen] = '\0'; + list_add_tail(&backref->list, &rec->backrefs); + return backref; +} + +static void free_root_recs(struct cache_tree *root_cache) +{ + struct cache_extent *cache; + struct root_record *rec; + struct root_backref *backref; + + while (1) { + cache = find_first_cache_extent(root_cache, 0); + if (!cache) + break; + rec = container_of(cache, struct root_record, cache); + remove_cache_extent(root_cache, &rec->cache); + + while (!list_empty(&rec->backrefs)) { + backref = list_entry(rec->backrefs.next, + struct root_backref, list); + list_del(&backref->list); + free(backref); + } + kfree(rec); + } +} + +static int add_root_backref(struct cache_tree *root_cache, + u64 root_id, u64 ref_root, u64 dir, u64 index, + const char *name, int namelen, + int item_type, int errors) +{ + struct root_record *rec; + struct root_backref *backref; + + rec = get_root_rec(root_cache, root_id); + backref = get_root_backref(rec, ref_root, dir, index, name, namelen); + + backref->errors |= errors; + + if (item_type != BTRFS_DIR_ITEM_KEY) { + if (backref->found_dir_index || backref->found_back_ref || + backref->found_forward_ref) { + if (backref->index != index) + backref->errors |= REF_ERR_INDEX_UNMATCH; + } else { + backref->index = index; + } + } + + if (item_type == BTRFS_DIR_ITEM_KEY) { + backref->found_dir_item = 1; + backref->reachable = 1; + rec->found_ref++; + } else if (item_type == BTRFS_DIR_INDEX_KEY) { + backref->found_dir_index = 1; + } else if (item_type == BTRFS_ROOT_REF_KEY) { + if (backref->found_forward_ref) + backref->errors |= REF_ERR_DUP_ROOT_REF; + backref->found_forward_ref = 1; + } else if (item_type == BTRFS_ROOT_BACKREF_KEY) { + if (backref->found_back_ref) + backref->errors |= REF_ERR_DUP_ROOT_BACKREF; + backref->found_back_ref = 1; + } else { + BUG_ON(1); + } + + return 0; +} + +static int merge_root_recs(struct btrfs_root *root, + struct cache_tree *src_cache, + struct cache_tree *dst_cache) +{ + struct cache_extent *cache; + struct ptr_node *node; + struct inode_record *rec; + struct inode_backref *backref; + + if (root->root_key.objectid == BTRFS_TREE_RELOC_OBJECTID) { + free_inode_recs(src_cache); + return 0; + } + + while (1) { + cache = find_first_cache_extent(src_cache, 0); + if (!cache) + break; + node = container_of(cache, struct ptr_node, cache); + rec = node->data; + remove_cache_extent(src_cache, &node->cache); + free(node); + + list_for_each_entry(backref, &rec->backrefs, list) { + BUG_ON(backref->found_inode_ref); + if (backref->found_dir_item) + add_root_backref(dst_cache, rec->ino, + root->root_key.objectid, backref->dir, + backref->index, backref->name, + backref->namelen, BTRFS_DIR_ITEM_KEY, + backref->errors); + if (backref->found_dir_index) + add_root_backref(dst_cache, rec->ino, + root->root_key.objectid, backref->dir, + backref->index, backref->name, + backref->namelen, BTRFS_DIR_INDEX_KEY, + backref->errors); + } + free_inode_rec(rec); + } + return 0; +} + +static int check_root_refs(struct btrfs_root *root, + struct cache_tree *root_cache) +{ + struct root_record *rec; + struct root_record *ref_root; + struct root_backref *backref; + struct cache_extent *cache; + int loop = 1; + int ret; + int error; + int errors = 0; + + rec = get_root_rec(root_cache, BTRFS_FS_TREE_OBJECTID); + rec->found_ref = 1; + + /* fixme: this can not detect circular references */ + while (loop) { + loop = 0; + cache = find_first_cache_extent(root_cache, 0); + while (1) { + if (!cache) + break; + rec = container_of(cache, struct root_record, cache); + cache = next_cache_extent(cache); + + if (rec->found_ref == 0) + continue; + + list_for_each_entry(backref, &rec->backrefs, list) { + if (!backref->reachable) + continue; + + ref_root = get_root_rec(root_cache, + backref->ref_root); + if (ref_root->found_ref > 0) + continue; + + backref->reachable = 0; + rec->found_ref--; + if (rec->found_ref == 0) + loop = 1; + } + } + } + + cache = find_first_cache_extent(root_cache, 0); + while (1) { + if (!cache) + break; + rec = container_of(cache, struct root_record, cache); + cache = next_cache_extent(cache); + + if (rec->found_ref == 0 && + rec->objectid >= BTRFS_FIRST_FREE_OBJECTID && + rec->objectid <= BTRFS_LAST_FREE_OBJECTID) { + ret = check_orphan_item(root->fs_info->tree_root, + rec->objectid); + if (ret == 0) + continue; + errors++; + fprintf(stderr, "fs tree %llu not referenced\n", + (unsigned long long)rec->objectid); + } + + error = 0; + if (rec->found_ref > 0 && !rec->found_root_item) + error = 1; + list_for_each_entry(backref, &rec->backrefs, list) { + if (!backref->found_dir_item) + backref->errors |= REF_ERR_NO_DIR_ITEM; + if (!backref->found_dir_index) + backref->errors |= REF_ERR_NO_DIR_INDEX; + if (!backref->found_back_ref) + backref->errors |= REF_ERR_NO_ROOT_BACKREF; + if (!backref->found_forward_ref) + backref->errors |= REF_ERR_NO_ROOT_REF; + if (backref->reachable && backref->errors) + error = 1; + } + if (!error) + continue; + + errors++; + fprintf(stderr, "fs tree %llu refs %u %s\n", + (unsigned long long)rec->objectid, rec->found_ref, + rec->found_root_item ? "" : "not found"); + + list_for_each_entry(backref, &rec->backrefs, list) { + if (!backref->reachable) + continue; + if (!backref->errors && rec->found_root_item) + continue; + fprintf(stderr, "\tunresolved ref root %llu dir %llu" + " index %llu namelen %u name %s error %x\n", + (unsigned long long)backref->ref_root, + (unsigned long long)backref->dir, + (unsigned long long)backref->index, + backref->namelen, backref->name, + backref->errors); + } + } + return errors > 0 ? 1 : 0; +} + +static int process_root_ref(struct extent_buffer *eb, int slot, + struct btrfs_key *key, + struct cache_tree *root_cache) +{ + u64 dirid; + u64 index; + u32 len; + u32 name_len; + struct btrfs_root_ref *ref; + char namebuf[BTRFS_NAME_LEN]; + int error; + + ref = btrfs_item_ptr(eb, slot, struct btrfs_root_ref); + + dirid = btrfs_root_ref_dirid(eb, ref); + index = btrfs_root_ref_sequence(eb, ref); + name_len = btrfs_root_ref_name_len(eb, ref); + + if (name_len <= BTRFS_NAME_LEN) { + len = name_len; + error = 0; + } else { + len = BTRFS_NAME_LEN; + error = REF_ERR_NAME_TOO_LONG; + } + read_extent_buffer(eb, namebuf, (unsigned long)(ref + 1), len); + + if (key->type == BTRFS_ROOT_REF_KEY) { + add_root_backref(root_cache, key->offset, key->objectid, dirid, + index, namebuf, len, key->type, error); + } else { + add_root_backref(root_cache, key->objectid, key->offset, dirid, + index, namebuf, len, key->type, error); + } + return 0; +} + static int check_fs_root(struct btrfs_root *root, + struct cache_tree *root_cache, struct walk_control *wc) { int ret = 0; @@ -1219,10 +1573,18 @@ static int check_fs_root(struct btrfs_root *root, int level; struct btrfs_path path; struct shared_node root_node; + struct root_record *rec; struct btrfs_root_item *root_item = &root->root_item; + if (root->root_key.objectid != BTRFS_TREE_RELOC_OBJECTID) { + rec = get_root_rec(root_cache, root->root_key.objectid); + if (btrfs_root_refs(root_item) > 0) + rec->found_root_item = 1; + } + btrfs_init_path(&path); memset(&root_node, 0, sizeof(root_node)); + cache_tree_init(&root_node.root_cache); cache_tree_init(&root_node.inode_cache); level = btrfs_header_level(root->node); @@ -1266,6 +1628,8 @@ static int check_fs_root(struct btrfs_root *root, } btrfs_release_path(root, &path); + merge_root_recs(root, &root_node.root_cache, root_cache); + if (root_node.current) { root_node.current->checked = 1; maybe_free_inode_rec(&root_node.inode_cache, @@ -1280,13 +1644,15 @@ static int fs_root_objectid(u64 objectid) { if (objectid == BTRFS_FS_TREE_OBJECTID || objectid == BTRFS_TREE_RELOC_OBJECTID || + objectid == BTRFS_DATA_RELOC_TREE_OBJECTID || (objectid >= BTRFS_FIRST_FREE_OBJECTID && - objectid < BTRFS_LAST_FREE_OBJECTID)) + objectid <= BTRFS_LAST_FREE_OBJECTID)) return 1; return 0; } -static int check_fs_roots(struct btrfs_root *root) +static int check_fs_roots(struct btrfs_root *root, + struct cache_tree *root_cache) { struct btrfs_path path; struct btrfs_key key; @@ -1319,10 +1685,14 @@ static int check_fs_roots(struct btrfs_root *root) fs_root_objectid(key.objectid)) { tmp_root = btrfs_read_fs_root_no_cache(root->fs_info, &key); - ret = check_fs_root(tmp_root, &wc); + ret = check_fs_root(tmp_root, root_cache, &wc); if (ret) err = 1; btrfs_free_fs_root(root->fs_info, tmp_root); + } else if (key.type == BTRFS_ROOT_REF_KEY || + key.type == BTRFS_ROOT_BACKREF_KEY) { + process_root_ref(leaf, path.slots[0], &key, + root_cache); } path.slots[0]++; } @@ -1895,7 +2265,6 @@ static int add_data_backref(struct cache_tree *extent_cache, u64 bytenr, return 0; } - static int add_pending(struct cache_tree *pending, struct cache_tree *seen, u64 bytenr, u32 size) { @@ -2443,6 +2812,7 @@ static void print_usage(void) int main(int ac, char **av) { + struct cache_tree root_cache; struct btrfs_root *root; int ret; @@ -2450,6 +2820,7 @@ int main(int ac, char **av) print_usage(); radix_tree_init(); + cache_tree_init(&root_cache); root = open_ctree(av[1], 0, 0); if (root == NULL) @@ -2458,10 +2829,15 @@ int main(int ac, char **av) ret = check_extents(root); if (ret) goto out; - ret = check_fs_roots(root); + ret = check_fs_roots(root, &root_cache); + if (ret) + goto out; + ret = check_root_refs(root, &root_cache); out: + free_root_recs(&root_cache); close_ctree(root); + if (found_old_backref) { /* * there was a disk format change when mixed diff --git a/btrfsctl.c b/btrfsctl.c index b323818..be6bf25 100644 --- a/btrfsctl.c +++ b/btrfsctl.c @@ -29,6 +29,7 @@ #include <unistd.h> #include <dirent.h> #include <libgen.h> +#include <stdlib.h> #include "kerncompat.h" #include "ctree.h" #include "transaction.h" @@ -46,7 +47,7 @@ static inline int ioctl(int fd, int define, void *arg) { return 0; } static void print_usage(void) { printf("usage: btrfsctl [ -d file|dir] [ -s snap_name subvol|tree ]\n"); - printf(" [-r size] [-A device] [-a] [-c]\n"); + printf(" [-r size] [-A device] [-a] [-c] [-D dir .]\n"); printf("\t-d filename: defragments one file\n"); printf("\t-d directory: defragments the entire Btree\n"); printf("\t-s snap_name dir: creates a new snapshot of dir\n"); @@ -55,6 +56,9 @@ static void print_usage(void) printf("\t-A device: scans the device file for a Btrfs filesystem\n"); printf("\t-a: scans all devices for Btrfs filesystems\n"); printf("\t-c: forces a single FS sync\n"); + printf("\t-D: delete snapshot\n"); + printf("\t-m [tree id] directory: set the default mounted subvolume" + " to the [tree id] or the directory\n"); printf("%s\n", BTRFS_BUILD_VERSION); exit(1); } @@ -100,6 +104,7 @@ int main(int ac, char **av) unsigned long command = 0; int len; char *fullpath; + u64 objectid = 0; if (ac == 2 && strcmp(av[1], "-a") == 0) { fprintf(stderr, "Scanning for Btrfs filesystems\n"); @@ -158,6 +163,18 @@ int main(int ac, char **av) print_usage(); } command = BTRFS_IOC_DEFRAG; + } else if (strcmp(av[i], "-D") == 0) { + if (i >= ac - 1) { + fprintf(stderr, "-D requires an arg\n"); + print_usage(); + } + command = BTRFS_IOC_SNAP_DESTROY; + name = av[i + 1]; + len = strlen(name); + if (len == 0 || len >= BTRFS_VOL_NAME_MAX) { + fprintf(stderr, "-D size too long\n"); + exit(1); + } } else if (strcmp(av[i], "-A") == 0) { if (i >= ac - 1) { fprintf(stderr, "-A requires an arg\n"); @@ -178,6 +195,16 @@ int main(int ac, char **av) command = BTRFS_IOC_RESIZE; } else if (strcmp(av[i], "-c") == 0) { command = BTRFS_IOC_SYNC; + } else if (strcmp(av[i], "-m") == 0) { + command = BTRFS_IOC_DEFAULT_SUBVOL; + if (i == ac - 3) { + objectid = (unsigned long long) + strtoll(av[i + 1], NULL, 0); + if (errno == ERANGE) { + fprintf(stderr, "invalid tree id\n"); + exit(1); + } + } } } if (command == 0) { @@ -206,6 +233,9 @@ int main(int ac, char **av) if (command == BTRFS_IOC_SNAP_CREATE) { args.fd = fd; ret = ioctl(snap_fd, command, &args); + } else if (command == BTRFS_IOC_DEFAULT_SUBVOL) { + printf("objectid is %llu\n", objectid); + ret = ioctl(fd, command, &objectid); } else ret = ioctl(fd, command, &args); if (ret < 0) { diff --git a/convert.c b/convert.c index d2c9efa..d037c98 100644 --- a/convert.c +++ b/convert.c @@ -370,7 +370,6 @@ static int record_file_extent(struct btrfs_trans_handle *trans, struct btrfs_extent_item *ei; u32 blocksize = root->sectorsize; u64 nbytes; - u64 bytes_used; if (disk_bytenr == 0) { ret = btrfs_insert_file_extent(trans, root, objectid, @@ -432,9 +431,6 @@ static int record_file_extent(struct btrfs_trans_handle *trans, nbytes = btrfs_stack_inode_nbytes(inode) + num_bytes; btrfs_set_stack_inode_nbytes(inode, nbytes); - bytes_used = btrfs_root_used(&root->root_item); - btrfs_set_root_used(&root->root_item, bytes_used + num_bytes); - btrfs_release_path(root, &path); ins_key.objectid = disk_bytenr; @@ -454,9 +450,6 @@ static int record_file_extent(struct btrfs_trans_handle *trans, btrfs_mark_buffer_dirty(leaf); - bytes_used = btrfs_super_bytes_used(&info->super_copy); - btrfs_set_super_bytes_used(&info->super_copy, bytes_used + - num_bytes); ret = btrfs_update_block_group(trans, root, disk_bytenr, num_bytes, 1, 0); if (ret) diff --git a/ctree.h b/ctree.h index a9062ea..64ecf12 100644 --- a/ctree.h +++ b/ctree.h @@ -1047,6 +1047,7 @@ BTRFS_SETGET_STACK_FUNCS(block_group_flags, /* struct btrfs_inode_ref */ BTRFS_SETGET_FUNCS(inode_ref_name_len, struct btrfs_inode_ref, name_len, 16); +BTRFS_SETGET_STACK_FUNCS(stack_inode_ref_name_len, struct btrfs_inode_ref, name_len, 16); BTRFS_SETGET_FUNCS(inode_ref_index, struct btrfs_inode_ref, index, 64); /* struct btrfs_inode_item */ @@ -1325,6 +1326,10 @@ BTRFS_SETGET_FUNCS(root_ref_dirid, struct btrfs_root_ref, dirid, 64); BTRFS_SETGET_FUNCS(root_ref_sequence, struct btrfs_root_ref, sequence, 64); BTRFS_SETGET_FUNCS(root_ref_name_len, struct btrfs_root_ref, name_len, 16); +BTRFS_SETGET_STACK_FUNCS(stack_root_ref_dirid, struct btrfs_root_ref, dirid, 64); +BTRFS_SETGET_STACK_FUNCS(stack_root_ref_sequence, struct btrfs_root_ref, sequence, 64); +BTRFS_SETGET_STACK_FUNCS(stack_root_ref_name_len, struct btrfs_root_ref, name_len, 16); + /* struct btrfs_dir_item */ BTRFS_SETGET_FUNCS(dir_data_len, struct btrfs_dir_item, data_len, 16); BTRFS_SETGET_FUNCS(dir_type, struct btrfs_dir_item, type, 8); @@ -1572,6 +1577,7 @@ static inline unsigned long btrfs_leaf_data(struct extent_buffer *l) /* struct btrfs_file_extent_item */ BTRFS_SETGET_FUNCS(file_extent_type, struct btrfs_file_extent_item, type, 8); +BTRFS_SETGET_STACK_FUNCS(stack_file_extent_type, struct btrfs_file_extent_item, type, 8); static inline unsigned long btrfs_file_extent_inline_start(struct btrfs_file_extent_item *e) @@ -1588,18 +1594,30 @@ static inline u32 btrfs_file_extent_calc_inline_size(u32 datasize) BTRFS_SETGET_FUNCS(file_extent_disk_bytenr, struct btrfs_file_extent_item, disk_bytenr, 64); +BTRFS_SETGET_STACK_FUNCS(stack_file_extent_disk_bytenr, struct btrfs_file_extent_item, + disk_bytenr, 64); BTRFS_SETGET_FUNCS(file_extent_generation, struct btrfs_file_extent_item, generation, 64); +BTRFS_SETGET_STACK_FUNCS(stack_file_extent_generation, struct btrfs_file_extent_item, + generation, 64); BTRFS_SETGET_FUNCS(file_extent_disk_num_bytes, struct btrfs_file_extent_item, disk_num_bytes, 64); BTRFS_SETGET_FUNCS(file_extent_offset, struct btrfs_file_extent_item, offset, 64); +BTRFS_SETGET_STACK_FUNCS(stack_file_extent_offset, struct btrfs_file_extent_item, + offset, 64); BTRFS_SETGET_FUNCS(file_extent_num_bytes, struct btrfs_file_extent_item, num_bytes, 64); +BTRFS_SETGET_STACK_FUNCS(stack_file_extent_num_bytes, struct btrfs_file_extent_item, + num_bytes, 64); BTRFS_SETGET_FUNCS(file_extent_ram_bytes, struct btrfs_file_extent_item, ram_bytes, 64); +BTRFS_SETGET_STACK_FUNCS(stack_file_extent_ram_bytes, struct btrfs_file_extent_item, + ram_bytes, 64); BTRFS_SETGET_FUNCS(file_extent_compression, struct btrfs_file_extent_item, compression, 8); +BTRFS_SETGET_STACK_FUNCS(stack_file_extent_compression, struct btrfs_file_extent_item, + compression, 8); BTRFS_SETGET_FUNCS(file_extent_encryption, struct btrfs_file_extent_item, encryption, 8); BTRFS_SETGET_FUNCS(file_extent_other_encoding, struct btrfs_file_extent_item, diff --git a/ioctl-test.c b/ioctl-test.c new file mode 100644 index 0000000..7cf3bc2 --- /dev/null +++ b/ioctl-test.c @@ -0,0 +1,36 @@ +#include <stdio.h> +#include <stdlib.h> +#include "kerncompat.h" +#include "ioctl.h" + +unsigned long ioctls[] = { + BTRFS_IOC_SNAP_CREATE, + BTRFS_IOC_DEFRAG, + BTRFS_IOC_RESIZE, + BTRFS_IOC_SCAN_DEV, + BTRFS_IOC_TRANS_START, + BTRFS_IOC_TRANS_END, + BTRFS_IOC_SYNC, + BTRFS_IOC_CLONE, + BTRFS_IOC_ADD_DEV, + BTRFS_IOC_RM_DEV, + BTRFS_IOC_BALANCE, + BTRFS_IOC_SUBVOL_CREATE, + BTRFS_IOC_SNAP_DESTROY, + BTRFS_IOC_DEFRAG_RANGE, + BTRFS_IOC_TREE_SEARCH, + BTRFS_IOC_INO_LOOKUP, + BTRFS_IOC_DEFAULT_SUBVOL, + BTRFS_IOC_SPACE_INFO, + 0 }; + +int main(int ac, char **av) +{ + int i = 0; + while(ioctls[i]) { + printf("%lu\n" ,ioctls[i]); + i++; + } + return 0; +} + diff --git a/ioctl.h b/ioctl.h index a084f33..776d7a9 100644 --- a/ioctl.h +++ b/ioctl.h @@ -30,6 +30,108 @@ struct btrfs_ioctl_vol_args { char name[BTRFS_PATH_NAME_MAX + 1]; }; +struct btrfs_ioctl_search_key { + /* which root are we searching. 0 is the tree of tree roots */ + __u64 tree_id; + + /* keys returned will be >= min and <= max */ + __u64 min_objectid; + __u64 max_objectid; + + /* keys returned will be >= min and <= max */ + __u64 min_offset; + __u64 max_offset; + + /* max and min transids to search for */ + __u64 min_transid; + __u64 max_transid; + + /* keys returned will be >= min and <= max */ + __u32 min_type; + __u32 max_type; + + /* + * how many items did userland ask for, and how many are we + * returning + */ + __u32 nr_items; + + /* align to 64 bits */ + __u32 unused; + + /* some extra for later */ + __u64 unused1; + __u64 unused2; + __u64 unused3; + __u64 unused4; +}; + +struct btrfs_ioctl_search_header { + __u64 transid; + __u64 objectid; + __u64 offset; + __u32 type; + __u32 len; +} __attribute__((may_alias)); + +#define BTRFS_SEARCH_ARGS_BUFSIZE (4096 - sizeof(struct btrfs_ioctl_search_key)) +/* + * the buf is an array of search headers where + * each header is followed by the actual item + * the type field is expanded to 32 bits for alignment + */ +struct btrfs_ioctl_search_args { + struct btrfs_ioctl_search_key key; + char buf[BTRFS_SEARCH_ARGS_BUFSIZE]; +}; + +#define BTRFS_INO_LOOKUP_PATH_MAX 4080 +struct btrfs_ioctl_ino_lookup_args { + __u64 treeid; + __u64 objectid; + char name[BTRFS_INO_LOOKUP_PATH_MAX]; +}; + +/* flags for the defrag range ioctl */ +#define BTRFS_DEFRAG_RANGE_COMPRESS 1 +#define BTRFS_DEFRAG_RANGE_START_IO 2 + +struct btrfs_ioctl_defrag_range_args { + /* start of the defrag operation */ + __u64 start; + + /* number of bytes to defrag, use (u64)-1 to say all */ + __u64 len; + + /* + * flags for the operation, which can include turning + * on compression for this one defrag + */ + __u64 flags; + + /* + * any extent bigger than this will be considered + * already defragged. Use 0 to take the kernel default + * Use 1 to say every single extent must be rewritten + */ + __u32 extent_thresh; + + /* spare for later */ + __u32 unused[5]; +}; + +struct btrfs_ioctl_space_info { + __u64 flags; + __u64 total_bytes; + __u64 used_bytes; +}; + +struct btrfs_ioctl_space_args { + __u64 space_slots; + __u64 total_spaces; + struct btrfs_ioctl_space_info spaces[0]; +}; + #define BTRFS_IOC_SNAP_CREATE _IOW(BTRFS_IOCTL_MAGIC, 1, \ struct btrfs_ioctl_vol_args) #define BTRFS_IOC_DEFRAG _IOW(BTRFS_IOCTL_MAGIC, 2, \ @@ -56,4 +158,15 @@ struct btrfs_ioctl_vol_args { /* 13 is for CLONE_RANGE */ #define BTRFS_IOC_SUBVOL_CREATE _IOW(BTRFS_IOCTL_MAGIC, 14, \ struct btrfs_ioctl_vol_args) +#define BTRFS_IOC_SNAP_DESTROY _IOW(BTRFS_IOCTL_MAGIC, 15, \ + struct btrfs_ioctl_vol_args) +#define BTRFS_IOC_DEFRAG_RANGE _IOW(BTRFS_IOCTL_MAGIC, 16, \ + struct btrfs_ioctl_defrag_range_args) +#define BTRFS_IOC_TREE_SEARCH _IOWR(BTRFS_IOCTL_MAGIC, 17, \ + struct btrfs_ioctl_search_args) +#define BTRFS_IOC_INO_LOOKUP _IOWR(BTRFS_IOCTL_MAGIC, 18, \ + struct btrfs_ioctl_ino_lookup_args) +#define BTRFS_IOC_DEFAULT_SUBVOL _IOW(BTRFS_IOCTL_MAGIC, 19, u64) +#define BTRFS_IOC_SPACE_INFO _IOWR(BTRFS_IOCTL_MAGIC, 20, \ + struct btrfs_ioctl_space_args) #endif diff --git a/man/Makefile b/man/Makefile index 4e8893b..4a90b75 100644 --- a/man/Makefile +++ b/man/Makefile @@ -7,13 +7,16 @@ mandir = $(prefix)/man man8dir = $(mandir)/man8 MANPAGES = mkfs.btrfs.8.gz btrfsctl.8.gz btrfsck.8.gz btrfs-image.8.gz \ - btrfs-show.8.gz + btrfs-show.8.gz btrfs.8.gz all: $(MANPAGES) mkfs.btrfs.8.gz: mkfs.btrfs.8.in $(GZIP) -n -c mkfs.btrfs.8.in > mkfs.btrfs.8.gz +btrfs.8.gz: btrfs.8.in + $(GZIP) -n -c btrfs.8.in > btrfs.8.gz + btrfsctl.8.gz: btrfsctl.8.in $(GZIP) -n -c btrfsctl.8.in > btrfsctl.8.gz diff --git a/man/btrfs.8.in b/man/btrfs.8.in new file mode 100644 index 0000000..26ef982 --- /dev/null +++ b/man/btrfs.8.in @@ -0,0 +1,170 @@ +.TH BTRFS 8 "" "btrfs" "btrfs" +.\" +.\" Man page written by Goffredo Baroncelli <kreijack@inwind.it> (Feb 2010) +.\" +.SH NAME +btrfs \- control a btrfs filesystem +.SH SYNOPSIS +\fBbtrfs\fP \fBsubvolume snapshot\fP\fI <source> [<dest>/]<name>\fP +.PP +\fBbtrfs\fP \fBsubvolume delete\fP\fI <subvolume>\fP +.PP +\fBbtrfs\fP \fBsubvolume create\fP\fI [<dest>/]<name>\fP +.PP +\fBbtrfs\fP \fBsubvolume list\fP\fI <path>\fP +.PP +\fBbtrfs\fP \fBsubvolume set-default\fP\fI <id> <path>\fP +.PP +\fBbtrfs\fP \fBfilesystem defrag\fP\fI <file>|<dir> [<file>|<dir>...]\fP +.PP +\fBbtrfs\fP \fBfilesystem sync\fP\fI <path> \fP +.PP +\fBbtrfs\fP \fBfilesystem resize\fP\fI [+/\-]<size>[gkm]|max <filesystem>\fP +.PP +\fBbtrfs\fP \fBdevice scan\fP\fI [<device> [<device>..]]\fP +.PP +\fBbtrfs\fP \fBdevice show\fP\fI <dev>|<label> [<dev>|<label>...]\fP +.PP +\fBbtrfs\fP \fBdevice balance\fP\fI <path> \fP +.PP +\fBbtrfs\fP \fBdevice add\fP\fI <dev> [<dev>..] <path> \fP +.PP +\fBbtrfs\fP \fBdevice delete\fP\fI <dev> [<dev>..] <path> \fP] + +.PP +\fBbtrfs\fP \fBhelp|\-\-help|\-h \fP\fI\fP +.PP +.SH DESCRIPTION +.B btrfs +is used to control the filesystem and the files and directories stored. It is +the tool to create or destroy a snapshot or a subvolume for the +filesystem, to defrag a file or a directory, flush the data to the disk, +to resize the filesystem, to scan the device. + +It is possible to abbreviate the commands unless the commands are ambiguous. +For example: it is possible to run +.I btrfs sub snaps +instead of +.I btrfs subvolume snapshot. +But +.I btrfs dev s +is not allowed, because +.I dev s +may be interpreted both as +.I device show +and as +.I device scan. +In this case +.I btrfs +returns an error. + +If a command is terminated by +.I --help +, the relevant help is showed. If the passed command matches more commands, +the help of all the matched commands are showed. For example +.I btrfs dev --help +shows the help of all +.I device* +command. + +.SH COMMANDS +.TP + +\fBsubvolume snapshot\fR\fI <source> [<dest>/]<name>\fR +Create a writable snapshot of the subvolume \fI<source>\fR with the name +\fI<name>\fR in the \fI<dest>\fR directory. If \fI<source>\fR is not a +subvolume, \fBbtrfs\fR returns an error. +.TP + +\fBsubvolume delete\fR\fI <subvolume>\fR +Delete the subvolume \fI<subvolume>\fR. If \fI<subvolume>\fR is not a +subvolume, \fBbtrfs\fR returns an error. +.TP + +\fBsubvolume create\fR\fI [<dest>/]<name>\fR +Create a subvolume in \fI<dest>\fR (or in the current directory if +\fI<dest>\fR is omitted). +.TP + +\fBsubvolume list\fR\fI <path>\fR +List the subvolumes present in the filesystem \fI<path>\fR. For every +subvolume is showed the subvolume ID (second column), +the ID of the \fItop level\fR +subvolume (fifth column), and the path (seventh column) relative to the +\fItop level\fR subvolume. +These <ID> may be used by the \fBsubvolume set-default\fR command, or at +mount time via the \fIsubvol=\fR option. +.TP + +\fBsubvolume set-default\fR\fI <id> <path>\fR +Set the subvolume of the filesystem \fI<path>\fR which is mounted as +\fIdefault\fR. The subvolume is identified by \fB<id>\fR, which +is returned by the \fBsubvolume list\fR command. +.TP + +\fBfilesystem defragment\fP\fI <file>|<dir> [<file>|<dir>...]\fR +Defragment files and/or directories. +.TP + +\fBdevice scan\fR \fI[<device> [<device>..]]\fR +Scan devices for a btrfs filesystem. If no devices are passed, \fBbtrfs\fR scans +all the block devices. +.TP + +\fBfilesystem sync\fR\fI <path> \fR +Force a sync for the filesystem identified by \fI<path>\fR. +.TP + +.\" +.\" Some wording are extracted by the resize2fs man page +.\" + +\fBfilesystem resize\fR\fI [+/\-]<size>[gkm]|max <path>\fR +Resize a filesystem identified by \fI<path>\fR. +The \fI<size>\fR parameter specifies the new size of the filesystem. +If the prefix \fI+\fR or \fI\-\fR is present the size is increased or decreased +by the quantity \fI<size>\fR. +If no units are specified, the unit of the \fI<size>\fR parameter defaults to +bytes. Optionally, the size parameter may be suffixed by one of the following +the units designators: 'K', 'M', or 'G', kilobytes, megabytes, or gigabytes, +respectively. + +If 'max' is passed, the filesystem will occupy all available space on the +volume(s). + +The \fBresize\fR command \fBdoes not\fR manipulate the size of underlying +partition. If you wish to enlarge/reduce a filesystem, you must make sure you +can expand the partition before enlarging the filesystem and shrink the +partition after reducing the size of the filesystem. +.TP + +\fBfilesystem show\fR [<uuid>|<label>]\fR +Show the btrfs filesystem with some additional info. If no UUID or label is +passed, \fBbtrfs\fR show info of all the btrfs filesystem. +.TP + +\fBdevice balance\fR \fI<path>\fR +Balance the chunks of the filesystem identified by \fI<path>\fR +across the devices. +.TP + +\fBdevice add\fR\fI <dev> [<dev>..] <path>\fR +Add device(s) to the filesystem identified by \fI<path>\fR. +.TP + +\fBdevice delete\fR\fI <dev> [<dev>..] <path>\fR +Remove device(s) from a filesystem identified by \fI<path>\fR. +.PP + +.SH EXIT STATUS +\fBbtrfs\fR returns a zero exist status if it succeeds. Non zero is returned in +case of failure. + +.SH AVAILABILITY +.B btrfs +is part of btrfs-progs. Btrfs filesystem is currently under heavy development, +and not suitable for any uses other than benchmarking and review. +Please refer to the btrfs wiki http://btrfs.wiki.kernel.org for +further details. +.SH SEE ALSO +.BR mkfs.btrfs (8)