* [U-Boot] [PATCH v3] btrfs addition to uboot @ 2013-02-25 12:24 Adnan Ali 2013-02-25 12:24 ` [U-Boot] [PATCH v3] Introduced btrfs file-system with btrload command Adnan Ali 0 siblings, 1 reply; 16+ messages in thread From: Adnan Ali @ 2013-02-25 12:24 UTC (permalink / raw) To: u-boot Adnan Ali (1): Introduced btrfs file-system with btrload command Makefile | 1 + common/Makefile | 1 + common/cmd_btr.c | 53 +++ fs/btrfs/Makefile | 51 ++ fs/btrfs/btrfs.c | 1131 ++++++++++++++++++++++++++++++++++++++++++++ fs/fs.c | 86 +++- include/btrfs.h | 398 ++++++++++++++++ include/config_fallbacks.h | 4 + include/crc32c.h | 48 ++ include/fs.h | 1 + 10 files changed, 1769 insertions(+), 5 deletions(-) create mode 100644 common/cmd_btr.c create mode 100644 fs/btrfs/Makefile create mode 100644 fs/btrfs/btrfs.c create mode 100644 include/btrfs.h create mode 100644 include/crc32c.h -- 1.7.9.5 ^ permalink raw reply [flat|nested] 16+ messages in thread
* [U-Boot] [PATCH v3] Introduced btrfs file-system with btrload command 2013-02-25 12:24 [U-Boot] [PATCH v3] btrfs addition to uboot Adnan Ali @ 2013-02-25 12:24 ` Adnan Ali 2013-02-25 15:04 ` Tom Rini 2013-03-01 22:53 ` Wolfgang Denk 0 siblings, 2 replies; 16+ messages in thread From: Adnan Ali @ 2013-02-25 12:24 UTC (permalink / raw) To: u-boot Introduces btrfs file-system to read file from volume/sub-volumes with btrload command. This implementation has read-only support. This btrfs implementation is based on syslinux btrfs code, commit 269ebc845ebc8b46ef4b0be7fa0005c7fdb95b8d. Signed-off-by: Adnan Ali <adnan.ali@codethink.co.uk> --- Makefile | 1 + common/Makefile | 1 + common/cmd_btr.c | 53 +++ fs/btrfs/Makefile | 51 ++ fs/btrfs/btrfs.c | 1131 ++++++++++++++++++++++++++++++++++++++++++++ fs/fs.c | 86 +++- include/btrfs.h | 398 ++++++++++++++++ include/config_fallbacks.h | 4 + include/crc32c.h | 48 ++ include/fs.h | 1 + 10 files changed, 1769 insertions(+), 5 deletions(-) create mode 100644 common/cmd_btr.c create mode 100644 fs/btrfs/Makefile create mode 100644 fs/btrfs/btrfs.c create mode 100644 include/btrfs.h create mode 100644 include/crc32c.h diff --git a/Makefile b/Makefile index 3305e8c..cc35e7b 100644 --- a/Makefile +++ b/Makefile @@ -261,6 +261,7 @@ endif LIBS-$(CONFIG_OF_EMBED) += dts/libdts.o LIBS-y += arch/$(ARCH)/lib/lib$(ARCH).o LIBS-y += fs/libfs.o \ + fs/btrfs/libbtrfs.o \ fs/cbfs/libcbfs.o \ fs/cramfs/libcramfs.o \ fs/ext4/libext4fs.o \ diff --git a/common/Makefile b/common/Makefile index 54fcc81..093dd35 100644 --- a/common/Makefile +++ b/common/Makefile @@ -73,6 +73,7 @@ COBJS-$(CONFIG_CMD_BEDBUG) += bedbug.o cmd_bedbug.o COBJS-$(CONFIG_CMD_BMP) += cmd_bmp.o COBJS-$(CONFIG_CMD_BOOTLDR) += cmd_bootldr.o COBJS-$(CONFIG_CMD_BOOTSTAGE) += cmd_bootstage.o +COBJS-$(CONFIG_CMD_BTR) += cmd_btr.o COBJS-$(CONFIG_CMD_CACHE) += cmd_cache.o COBJS-$(CONFIG_CMD_CBFS) += cmd_cbfs.o COBJS-$(CONFIG_CMD_CONSOLE) += cmd_console.o diff --git a/common/cmd_btr.c b/common/cmd_btr.c new file mode 100644 index 0000000..faea625 --- /dev/null +++ b/common/cmd_btr.c @@ -0,0 +1,53 @@ +/* + * (C) Copyright 2013 Codethink Limited + * Btrfs port to Uboot by + * Adnan Ali <adnan.ali@codethink.co.uk> + * See file CREDITS for list of people who contributed to this + * project. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation; either version 2 of + * the License, or (at your option) any later version. + * + * 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 02111-1307 USA + */ + +/* + * Boot support + */ +#include <fs.h> +#include <btrfs.h> + +char subvolname[MAX_SUBVOL_NAME]; + +int do_btr_fsload(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) +{ + if (argc > 5) + strcpy(subvolname, argv[5]); + else + strcpy(subvolname, ""); + + return do_load(cmdtp, flag, argc, argv, FS_TYPE_BTR, 16); +} + + +U_BOOT_CMD( + btrload, 7, 0, do_btr_fsload, + "load binary file from a btr filesystem", + "<interface> [<dev[:part]>] <addr> <filename> [subvol_name]\n" + " - Load binary file 'filename' from 'dev' on 'interface'\n" + " to address 'addr' from better filesystem.\n" + " the load stops on end of file.\n" + " subvol_name is used read that file from this subvolume.\n" + " All numeric parameters are assumed to be hex." +); + diff --git a/fs/btrfs/Makefile b/fs/btrfs/Makefile new file mode 100644 index 0000000..a9e2021 --- /dev/null +++ b/fs/btrfs/Makefile @@ -0,0 +1,51 @@ +# +# (C) Copyright 2006 +# Wolfgang Denk, DENX Software Engineering, wd at denx.de. +# +# (C) Copyright 2003 +# Pavel Bartusek, Sysgo Real-Time Solutions AG, pba at sysgo.de +# +# +# See file CREDITS for list of people who contributed to this +# project. +# +# This program is free software; you can redistribute it and/or +# modify it under the terms of the GNU General Public License as +# published by the Free Software Foundation; either version 2 of +# the License, or (at your option) any later version. +# +# 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 02111-1307 USA +# + +include $(TOPDIR)/config.mk + +LIB = $(obj)libbtrfs.o + +AOBJS = +COBJS-$(CONFIG_FS_BTR) := btrfs.o + +SRCS := $(AOBJS:.o=.S) $(COBJS-y:.o=.c) +OBJS := $(addprefix $(obj),$(AOBJS) $(COBJS-y)) + + +all: $(LIB) $(AOBJS) + +$(LIB): $(obj).depend $(OBJS) + $(call cmd_link_o_target, $(OBJS)) + +######################################################################### + +# defines $(obj).depend target +include $(SRCTREE)/rules.mk + +sinclude $(obj).depend + +######################################################################### diff --git a/fs/btrfs/btrfs.c b/fs/btrfs/btrfs.c new file mode 100644 index 0000000..9568042 --- /dev/null +++ b/fs/btrfs/btrfs.c @@ -0,0 +1,1131 @@ +/* + * (C) Copyright 2013 Codethink Limited + * Btrfs port to Uboot by + * Adnan Ali <adnan.ali@codethink.co.uk> + + * btrfs.c -- readonly btrfs support for syslinux + * Some data structures are derivated from btrfs-tools-0.19 ctree.h + * Copyright 2009 Intel Corporation; author: alek.du at intel.com + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, Inc., 53 Temple Place Ste 330, + * Boston MA 02111-1307, USA; either version 2 of the License, or + * (at your option) any later version; incorporated herein by reference. + * + */ + +#include <linux/stat.h> +#include <command.h> +#include <asm/byteorder.h> +#include <linux/compiler.h> +#include <common.h> +#include <config.h> +#include <fs.h> +#include <btrfs.h> + +unsigned long btr_part_offset; +/* Actual file structures (we don't have malloc yet...) */ +struct file files[MAX_OPEN]; +static u32 btrfs_crc32_table[256]; +static block_dev_desc_t *btrfs_block_dev_desc; +static disk_partition_t *part_info; +struct inode parent_inode; +extern char subvolname[MAX_SUBVOL_NAME]; + +static void btrfs_init_crc32c(void) +{ + /* Bit-reflected CRC32C polynomial */ + crc32c_init(btrfs_crc32_table, 0x82F63B78); +} + +static inline u32 crc32c_le(u32 crc, const char *data, size_t length) +{ + return crc32c_cal(crc, data, length, btrfs_crc32_table); +} + +void btrfs_set_blk_dev(block_dev_desc_t *rbdd, disk_partition_t *info) +{ + btrfs_block_dev_desc = rbdd; + part_info = info; + btr_part_offset = info->start; +} + + +/* compare function used for bin_search */ +typedef int (*cmp_func)(void *ptr1, void *ptr2); + +static int bin_search(void *ptr, int item_size, void *cmp_item, cmp_func func, + int min, int max, int *slot) +{ + int low = min; + int high = max; + int mid; + int ret; + unsigned long offset; + void *item; + + while (low < high) { + mid = (low + high) / 2; + offset = mid * item_size; + + item = ptr + offset; + ret = func(item, cmp_item); + + if (ret < 0) + low = mid + 1; + else if (ret > 0) + high = mid; + else { + *slot = mid; + return 0; + } + } + *slot = low; + return 1; +} + +/* XXX: these should go into the filesystem instance structure */ +static struct btrfs_chunk_map chunk_map; +static struct btrfs_super_block sb; +static u64 fs_tree; + +static int btrfs_comp_chunk_map(struct btrfs_chunk_map_item *m1, + struct btrfs_chunk_map_item *m2) +{ + if (__le64_to_cpu(m1->logical) > __le64_to_cpu(m2->logical)) + return 1; + if (__le64_to_cpu(m1->logical) < __le64_to_cpu(m2->logical)) + return -1; + return 0; +} + +/* insert a new chunk mapping item */ +static void insert_map(struct btrfs_chunk_map_item *item) +{ + int ret; + int slot; + int i; + + if (chunk_map.map == NULL) { /* first item */ + chunk_map.map_length = BTRFS_MAX_CHUNK_ENTRIES; + chunk_map.map = (struct btrfs_chunk_map_item *) + malloc(chunk_map.map_length * sizeof(*chunk_map.map)); + chunk_map.map[0] = *item; + chunk_map.cur_length = 1; + return; + } + ret = bin_search(chunk_map.map, sizeof(*item), item, + (cmp_func)btrfs_comp_chunk_map, 0, + chunk_map.cur_length, &slot); + if (ret == 0)/* already in map */ + return; + if (chunk_map.cur_length == BTRFS_MAX_CHUNK_ENTRIES) { + /* should be impossible */ + printf("too many chunk items\n"); + return; + } + for (i = chunk_map.cur_length; i > slot; i--) + chunk_map.map[i] = chunk_map.map[i-1]; + chunk_map.map[slot] = *item; + chunk_map.cur_length++; +} + +/* + * from sys_chunk_array or chunk_tree, we can convert a logical address to + * a physical address we can not support multi device case yet + */ +static u64 logical_physical(u64 logical) +{ + struct btrfs_chunk_map_item item; + int slot, ret; + + item.logical = logical; + ret = bin_search(chunk_map.map, sizeof(*chunk_map.map), &item, + (cmp_func)btrfs_comp_chunk_map, 0, + chunk_map.cur_length, &slot); + if (ret == 0) + slot++; + else if (slot == 0) + return -1; + if (logical >= + chunk_map.map[slot-1].logical + chunk_map.map[slot-1].length) + return -1; + return chunk_map.map[slot-1].physical + logical - + chunk_map.map[slot-1].logical; +} + +int btrfs_devread(int sector, int byte_offset, int byte_len, char* buf) +{ + ALLOC_CACHE_ALIGN_BUFFER(char, sec_buf, SECTOR_SIZE); + unsigned block_len; + + /* Get the read to the beginning of a partition */ + sector += byte_offset >> SECTOR_BITS; + byte_offset &= SECTOR_SIZE - 1; + + if (btrfs_block_dev_desc == NULL) { + printf("** Invalid Block Device Descriptor (NULL)\n"); + return 0; + } + if (byte_offset != 0) { + /* read first part which isn't aligned with start of sector */ + if (btrfs_block_dev_desc-> + block_read(btrfs_block_dev_desc->dev, + part_info->start + sector, 1, + (unsigned long *) sec_buf) != 1) { + printf(" ** btrfs_devread() read error **\n"); + return 0; + } + memcpy(buf, sec_buf + byte_offset, + min(SECTOR_SIZE - byte_offset, byte_len)); + buf += min(SECTOR_SIZE - byte_offset, byte_len); + byte_len -= min(SECTOR_SIZE - byte_offset, byte_len); + sector++; + } + /* read sector aligned part */ + + block_len = byte_len & ~(SECTOR_SIZE - 1); + + if (block_len == 0) { + ALLOC_CACHE_ALIGN_BUFFER(u8, p, SECTOR_SIZE); + + block_len = SECTOR_SIZE; + btrfs_block_dev_desc->block_read(btrfs_block_dev_desc->dev, + part_info->start + sector, + 1, (unsigned long *)p); + memcpy(buf, p, byte_len); + return 1; + } + ALLOC_CACHE_ALIGN_BUFFER(u8, t, block_len); + if (btrfs_block_dev_desc->block_read(btrfs_block_dev_desc->dev, + part_info->start + sector, + block_len / SECTOR_SIZE, + (unsigned long *) t) != + block_len / SECTOR_SIZE) { + printf(" ** %s read error - block\n", __func__); + return 0; + } + + memcpy(buf, t, block_len); + block_len = byte_len & ~(SECTOR_SIZE - 1); + buf += block_len; + byte_len -= block_len; + sector += block_len / SECTOR_SIZE; + if (byte_len != 0) { + /* read rest of data which are not in whole sector */ + if (btrfs_block_dev_desc-> + block_read(btrfs_block_dev_desc->dev, + part_info->start + sector, 1, + (unsigned long *) sec_buf) != 1) { + printf("* %s read error - last part\n", __func__); + return 0; + } + memcpy(buf, sec_buf, byte_len); + } + + + return 1; +} +/* btrfs has several super block mirrors, need to calculate their location */ +static inline u64 btrfs_sb_offset(int mirror) +{ + u64 start = 16 * 1024; + if (mirror) + return start << (BTRFS_SUPER_MIRROR_SHIFT * mirror); + return BTRFS_SUPER_INFO_OFFSET; +} + +/* find the most recent super block */ +static int btrfs_read_super_block(struct fs_info *fs) +{ + int i; + int ret; + u8 fsid[BTRFS_FSID_SIZE]; + u8 boots[512]; + u64 offset; + u64 transid = 0; + struct btrfs_super_block buf; + + sb.total_bytes = ~0; /* Unknown as of yet */ + + /*Only first header is checked for filesystem verification + mirror of this header can be used if required*/ + offset = btrfs_sb_offset(0); + + if ( btrfs_devread(128, 0, sizeof(struct btrfs_super_block), (char*)&buf)!=1) + return -1; + + + if (buf.bytenr != offset || + strncmp((char *)(&buf.magic), BTRFS_MAGIC, sizeof(buf.magic))) + { + return -1; + } + + if (i == 0) + memcpy(fsid, buf.fsid, sizeof(fsid)); + else if (memcmp(fsid, buf.fsid, sizeof(fsid))) + return -1; + + if (buf.generation > transid) { + memcpy(&sb, &buf, sizeof(sb)); + transid = buf.generation; + } + return 0; +} + +static inline unsigned long btrfs_chunk_item_size(int num_stripes) +{ + return sizeof(struct btrfs_chunk) + + sizeof(struct btrfs_stripe) * (num_stripes - 1); +} + +static void clear_path(struct btrfs_path *path) +{ + memset(path, 0, sizeof(*path)); +} + +static int btrfs_comp_keys(struct btrfs_disk_key *k1, struct btrfs_disk_key *k2) +{ + if (k1->objectid > k2->objectid) + return 1; + if (k1->objectid < k2->objectid) + return -1; + if (k1->type > k2->type) + return 1; + if (k1->type < k2->type) + return -1; + if (k1->offset > k2->offset) + return 1; + if (k1->offset < k2->offset) + return -1; + return 0; +} + +/* compare keys but ignore offset, is useful to enumerate all same kind keys */ +static int btrfs_comp_keys_type(struct btrfs_disk_key *k1, + struct btrfs_disk_key *k2) +{ + if (k1->objectid > k2->objectid) + return 1; + if (k1->objectid < k2->objectid) + return -1; + if (k1->type > k2->type) + return 1; + if (k1->type < k2->type) + return -1; + return 0; +} + +/* seach tree directly on disk ... */ +static int search_tree(struct fs_info *fs, u64 loffset, + struct btrfs_disk_key *key, struct btrfs_path *path) +{ + u8 buf[BTRFS_MAX_LEAF_SIZE]; + struct btrfs_header *header = (struct btrfs_header *)buf; + struct btrfs_node *node = (struct btrfs_node *)buf; + struct btrfs_leaf *leaf = (struct btrfs_leaf *)buf; + int slot, ret; + u64 offset; + + offset = logical_physical(loffset); + btrfs_devread(offset/SECTOR_SIZE, (offset%SECTOR_SIZE), sizeof(*header), (char*)header); + if (header->level) {/*node*/ + btrfs_devread(((offset+sizeof(*header))/SECTOR_SIZE),((offset+sizeof(*header))%SECTOR_SIZE) , + __le32_to_cpu(sb.nodesize) - sizeof(*header), (char *)&node->ptrs[0]); + path->itemsnr[header->level] = header->nritems; + path->offsets[header->level] = loffset; + ret = bin_search(&node->ptrs[0], sizeof(struct btrfs_key_ptr), + key, (cmp_func)btrfs_comp_keys, + path->slots[header->level], header->nritems, &slot); + if (ret && slot > path->slots[header->level]) + slot--; + path->slots[header->level] = slot; + ret = search_tree(fs, node->ptrs[slot].blockptr, key, path); + } else {/*leaf*/ + + btrfs_devread(((offset+sizeof(*header))/SECTOR_SIZE), ((offset+sizeof(*header))%SECTOR_SIZE), + (sb.leafsize) - sizeof(*header), (char *)&leaf->items); + path->itemsnr[header->level] = header->nritems; + path->offsets[0] = loffset; + ret = bin_search(&leaf->items[0], sizeof(struct btrfs_item), + key, (cmp_func)btrfs_comp_keys, path->slots[0], + header->nritems, &slot); + if (ret && slot > path->slots[header->level]) + slot--; + path->slots[0] = slot; + path->item = leaf->items[slot]; + btrfs_devread(((offset + sizeof(*header) + leaf->items[slot].offset)/SECTOR_SIZE), + ((offset + sizeof(*header) + leaf->items[slot].offset)%SECTOR_SIZE), + leaf->items[slot].size, (char*)&path->data); + } + return ret; +} + +/* return 0 if leaf found */ +static int next_leaf(struct fs_info *fs, struct btrfs_disk_key *key, struct btrfs_path *path) +{ + int slot; + int level = 1; + + while (level < BTRFS_MAX_LEVEL) { + if (!path->itemsnr[level]) /* no more nodes */ + return 1; + slot = path->slots[level] + 1; + if (slot >= path->itemsnr[level]) { + level++; + continue;; + } + path->slots[level] = slot; + path->slots[level-1] = 0; /* reset low level slots info */ + search_tree(fs, path->offsets[level], key, path); + break; + } + if (level == BTRFS_MAX_LEVEL) + return 1; + return 0; +} + +/* return 0 if slot found */ +static int next_slot(struct fs_info *fs, struct btrfs_disk_key *key, struct btrfs_path *path) +{ + int slot; + + if (!path->itemsnr[0]) + return 1; + slot = path->slots[0] + 1; + if (slot >= path->itemsnr[0]) + return 1; + path->slots[0] = slot; + search_tree(fs, path->offsets[0], key, path); + return 0; +} + +/* + * read chunk_array in super block + */ +static void btrfs_read_sys_chunk_array(void) +{ + struct btrfs_chunk_map_item item; + struct btrfs_disk_key *key; + struct btrfs_chunk *chunk; + int cur; + + /* read chunk array in superblock */ + cur = 0; + + while (cur < __le32_to_cpu(sb.sys_chunk_array_size)) { + key = (struct btrfs_disk_key *)(sb.sys_chunk_array + cur); + cur += sizeof(*key); + chunk = (struct btrfs_chunk *)(sb.sys_chunk_array + cur); + cur += btrfs_chunk_item_size(chunk->num_stripes); + /* insert to mapping table, ignore multi stripes */ + item.logical = key->offset; + item.length = chunk->length; + item.devid = chunk->stripe.devid; + item.physical = chunk->stripe.offset;/*ignore other stripes */ + + + insert_map(&item); + } +} + +/* read chunk items from chunk_tree and insert them to chunk map */ +static void btrfs_read_chunk_tree(struct fs_info *fs) +{ + struct btrfs_disk_key search_key; + struct btrfs_chunk *chunk; + struct btrfs_chunk_map_item item; + struct btrfs_path path; + int status; + + if (!(__le64_to_cpu(sb.flags) & BTRFS_SUPER_FLAG_METADUMP)) { + if (__le64_to_cpu(sb.num_devices) > 1) + { + printf("warning: only support one btrfs device %d\n", + __le64_to_cpu(sb.num_devices)); + return; + } + /* read chunk from chunk_tree */ + search_key.objectid = BTRFS_FIRST_CHUNK_TREE_OBJECTID; + search_key.type = BTRFS_CHUNK_ITEM_KEY; + search_key.offset = 0; + clear_path(&path); + search_tree(fs, (sb.chunk_root), &search_key, &path); + do { + do { + + if (status=btrfs_comp_keys_type(&search_key, + &path.item.key)) + break; + chunk = (struct btrfs_chunk *)(path.data); + /* insert to mapping table, ignore stripes */ + item.logical = path.item.key.offset; + item.length = chunk->length; + item.devid = chunk->stripe.devid; + item.physical = chunk->stripe.offset; + insert_map(&item); + } while (!next_slot(fs, &search_key, &path)); + if (btrfs_comp_keys_type(&search_key, &path.item.key)) + break; + } while (!next_leaf(fs, &search_key, &path)); + } +} + +static inline u64 btrfs_name_hash(const char *name, int len) +{ + return btrfs_crc32c((u32)~1, name, len); +} + +static struct inode *btrfs_iget_by_inr(struct fs_info *fs, u64 inr) +{ + struct inode *inode; + struct btrfs_inode_item inode_item; + struct btrfs_disk_key search_key; + struct btrfs_path path; + int ret; + + /* FIXME: some BTRFS inode member are u64, while our logical inode + is u32, we may need change them to u64 later */ + search_key.objectid = inr; + search_key.type = BTRFS_INODE_ITEM_KEY; + search_key.offset = 0; + clear_path(&path); + ret = search_tree(fs, fs_tree, &search_key, &path); + if (ret) + { + printf("%s search_tree failed\n", __func__); + return NULL; + } + + inode_item = *(struct btrfs_inode_item *)path.data; + if (!(inode = alloc_inode(fs, inr, sizeof(struct btrfs_pvt_inode)))) + { + printf("%s alloc_inode failed\n", __func__); + return NULL; + } + inode->ino = inr; + inode->size = inode_item.size; + inode->mode = IFTODT(inode_item.mode); + if (inode->mode == DT_REG || inode->mode == DT_LNK) { + struct btrfs_file_extent_item extent_item; + u64 offset; + + /* get file_extent_item */ + search_key.type = BTRFS_EXTENT_DATA_KEY; + search_key.offset = 0; + clear_path(&path); + ret = search_tree(fs, fs_tree, &search_key, &path); + if (ret) + return NULL; /* impossible */ + extent_item = *(struct btrfs_file_extent_item *)path.data; + if (extent_item.type == BTRFS_FILE_EXTENT_INLINE)/* inline file */ + offset = path.offsets[0] + sizeof(struct btrfs_header) + + path.item.offset + + offsetof(struct btrfs_file_extent_item, disk_bytenr); + else + offset = extent_item.disk_bytenr; + PVT(inode)->offset = offset; + } + return inode; +} + +static struct inode *btrfs_iget_root(struct fs_info *fs) +{ + /* BTRFS_FIRST_CHUNK_TREE_OBJECTID(256) actually is first OBJECTID for FS_TREE */ + return btrfs_iget_by_inr(fs, BTRFS_FIRST_CHUNK_TREE_OBJECTID); +} + +static struct inode *btrfs_iget(const char *name, struct inode *parent) +{ + struct fs_info *fs = parent->fs; + struct btrfs_disk_key search_key; + struct btrfs_path path; + struct btrfs_dir_item dir_item; + int ret; + + search_key.objectid = parent->ino; + search_key.type = BTRFS_DIR_ITEM_KEY; + search_key.offset = btrfs_name_hash(name, strlen(name)); + clear_path(&path); + ret = search_tree(fs, fs_tree, &search_key, &path); + if (ret) + return NULL; + dir_item = *(struct btrfs_dir_item *)path.data; + + return btrfs_iget_by_inr(fs, dir_item.location.objectid); +} + +static int btrfs_readlink(struct inode *inode, char *buf) +{ + btrfs_devread((logical_physical(PVT(inode)->offset)/SECTOR_SIZE), + (logical_physical(PVT(inode)->offset)%SECTOR_SIZE), inode->size, (char*)buf); + buf[inode->size] = '\0'; + return inode->size; +} + +static int btrfs_readdir(struct file *file, struct dirent *dirent) +{ + struct fs_info *fs = file->fs; + struct inode *inode = file->inode; + struct btrfs_disk_key search_key; + struct btrfs_path path; + struct btrfs_dir_item *dir_item; + int ret; + + /* + * we use file->offset to store last search key.offset, will will search + * key that lower that offset, 0 means first search and we will search + * -1UL, which is the biggest possible key + */ + search_key.objectid = inode->ino; + search_key.type = BTRFS_DIR_ITEM_KEY; + search_key.offset = file->offset - 1; + clear_path(&path); + ret = search_tree(fs, fs_tree, &search_key, &path); + + if (ret) { + if (btrfs_comp_keys_type(&search_key, &path.item.key)) + return -1; + } + + dir_item = (struct btrfs_dir_item *)path.data; + file->offset = path.item.key.offset; + dirent->d_ino = dir_item->location.objectid; + dirent->d_off = file->offset; + dirent->d_reclen = offsetof(struct dirent, d_name) + + dir_item->name_len + 1; + dirent->d_type = IFTODT(dir_item->type); + memcpy(dirent->d_name, dir_item + 1, dir_item->name_len); + dirent->d_name[dir_item->name_len] = '\0'; + + return 0; +} + +static int btrfs_next_extent(struct inode *inode, uint32_t lstart) +{ + struct btrfs_disk_key search_key; + struct btrfs_file_extent_item extent_item; + struct btrfs_path path; + int ret; + u64 offset; + struct fs_info *fs = inode->fs; + u32 sec_shift = SECTOR_BITS; + u32 sec_size = SECTOR_SIZE; + + search_key.objectid = inode->ino; + search_key.type = BTRFS_EXTENT_DATA_KEY; + search_key.offset = lstart << sec_shift; + clear_path(&path); + ret = search_tree(fs, fs_tree, &search_key, &path); + if (ret) { /* impossible */ + printf("btrfs: search extent data error\n"); + return -1; + } + extent_item = *(struct btrfs_file_extent_item *)path.data; + + if (extent_item.encryption) { + printf("btrfs: found encrypted data, cannot continue\n"); + return -1; + } + if (extent_item.compression) { + printf("btrfs: found compressed data, cannot continue\n"); + return -1; + } + + if (extent_item.type == BTRFS_FILE_EXTENT_INLINE) {/* inline file */ + /* we fake a extent here, and PVT of inode will tell us */ + offset = path.offsets[0] + sizeof(struct btrfs_header) + + path.item.offset + + offsetof(struct btrfs_file_extent_item, disk_bytenr); + inode->next_extent.len = + (inode->size + sec_size -1) >> sec_shift; + } else { + offset = extent_item.disk_bytenr + extent_item.offset; + inode->next_extent.len = + (extent_item.num_bytes + sec_size - 1) >> sec_shift; + } + inode->next_extent.pstart = + logical_physical(offset) >> sec_shift; + PVT(inode)->offset = offset; + return 0; +} + +static uint32_t btrfs_getfssec(struct file *file, char *buf, int sectors, + char *have_more) +{ + u32 ret; + struct fs_info *fs = file->fs; + u32 off = PVT(file->inode)->offset % SECTOR_SIZE; + char handle_inline = 0; + + if (off && !file->offset) {/* inline file first read patch */ + file->inode->size += off; + handle_inline = 1; + } + ret = generic_getfssec(file, buf, sectors, have_more); + if (!ret) + return ret; + off = PVT(file->inode)->offset % SECTOR_SIZE; + if (handle_inline) {/* inline file patch */ + ret -= off; + memcpy(buf, buf + off, ret); + } + return ret; +} + +static void btrfs_get_fs_tree(struct fs_info *fs) +{ + struct btrfs_disk_key search_key; + struct btrfs_path path; + struct btrfs_root_item *tree; + char subvol_ok = 0; + + /* check if subvol is filled by installer */ + if (*subvolname) { + search_key.objectid = BTRFS_FS_TREE_OBJECTID; + search_key.type = BTRFS_ROOT_REF_KEY; + search_key.offset = 0; + clear_path(&path); + if (search_tree(fs, __le64_to_cpu(sb.root), &search_key, &path)) + next_slot(fs, &search_key, &path); + do { + do { + struct btrfs_root_ref *ref; + int pathlen, status; + + if (status=btrfs_comp_keys_type(&search_key, + &path.item.key)) + break; + ref = (struct btrfs_root_ref *)path.data; + pathlen = path.item.size - sizeof(struct btrfs_root_ref); + printf("sub_vol found %s\n", (char*)(ref+1)); + if (!strncmp((char*)(ref + 1), subvolname, pathlen)) { + subvol_ok = 1; + break; + } + } while (!next_slot(fs, &search_key, &path)); + if (subvol_ok) + break; + if (btrfs_comp_keys_type(&search_key, &path.item.key)) + break; + } while (!next_leaf(fs, &search_key, &path)); + if (!subvol_ok) /* should be impossible */ + printf("no subvol found\n"); + } + /* find fs_tree from tree_root */ + if (subvol_ok) + search_key.objectid = path.item.key.offset; + else /* "default" volume */ + search_key.objectid = BTRFS_FS_TREE_OBJECTID; + search_key.type = BTRFS_ROOT_ITEM_KEY; + search_key.offset =-1; + clear_path(&path); + search_tree(fs, (sb.root), &search_key, &path); + tree = (struct btrfs_root_item *)path.data; + fs_tree = tree->bytenr; +} + +/* init. the fs meta data, return the block size shift bits. */ +int btrfs_fs_init(struct fs_info *fs) +{ + + btrfs_init_crc32c(); + btrfs_read_super_block(fs); + if (strncmp((char *)(&sb.magic), BTRFS_MAGIC, sizeof(sb.magic))) + return -1; + + btrfs_read_sys_chunk_array(); + btrfs_read_chunk_tree(fs); + btrfs_get_fs_tree(fs); + fs->root = btrfs_iget_root(fs); + parent_inode=*(fs->root); + + return 1; +} +static inline uint16_t file_to_handle(struct file *file) +{ + return file ? (file - files)+1 : 0; +} + +static inline struct file *handle_to_file(uint16_t handle) +{ + return handle ? &files[handle-1] : NULL; +} + +/* + * Free a refcounted inode + */ +void put_inode(struct inode *inode) +{ + while (inode && --inode->refcnt == 0) { + struct inode *dead = inode; + inode = inode->parent; + if (dead->name) + free((char *)dead->name); + free(dead); + } +} + +/* + * Get a new inode structure + */ +struct inode *alloc_inode(struct fs_info *fs, uint32_t ino, size_t data) +{ + struct inode *inode = malloc(sizeof(struct inode) + data); + if (inode) { + inode->fs = fs; + inode->ino = ino; + inode->refcnt = 1; + } + return inode; +} + +/* + * Get an empty file structure + */ +static struct file *alloc_file(void) +{ + int i; + struct file *file = files; + + for (i = 0; i < MAX_OPEN; i++) { + if (!file->fs) + return file; + file++; + } + + return NULL; +} + +/* + * Close and free a file structure + */ +static inline void free_file(struct file *file) +{ + memset(file, 0, sizeof *file); +} + +void generic_close_file(struct file *file) +{ + if (file->inode) { + file->offset = 0; + put_inode(file->inode); + } +} + +void _close_file(struct file *file) +{ + if (file->fs) + generic_close_file(file); + free_file(file); +} + +void btrfs_mangle_name(char *dst, const char *src) +{ + char *p = dst; + int i = FILENAME_MAX-1; + + while (not_whitespace(*src)) { + if (*src == '/') { + if (src[1] == '/') { + src++; + i--; + continue; + } + } + i--; + *dst++ = *src++; + } + while (1) { + if (dst == p) + break; + if (dst[-1] != '/') + break; + if ((dst[-1] == '/') && ((dst - 1) == p)) + break; + + dst--; + i++; + } + + i++; + for (; i > 0; i --) + *dst++ = '\0'; + +} +int btrfs_open_file(const char *name, struct com32_filedata *filedata) +{ + int rv; + struct file *file; + char mangled_name[FILENAME_MAX]; + + btrfs_mangle_name(mangled_name, name); + rv = searchdir(mangled_name); + if (rv < 0) + return rv; + + file = handle_to_file(rv); + filedata->size = file->inode->size; + filedata->handle = rv; + return rv; +} + +int searchdir(const char *name) +{ + struct inode *inode = NULL; + struct inode *parent = &parent_inode; + struct file *file; + char *pathbuf = NULL; + char *part, *p, echar; + int symlink_count = MAX_SYMLINK_CNT; + + if (!(file = alloc_file())) + goto err_no_close; + + p = pathbuf = strdup(name); + if (!pathbuf) + goto err; + + do { + got_link: + if (*p == '/') { + put_inode(parent); + parent = &parent_inode;// get_inode(this_fs->root); + } + + do { + inode = get_inode(parent); + + while (*p == '/') + p++; + + if (!*p) + break; + + part = p; + while ((echar = *p) && echar != '/') + p++; + *p++ = '\0'; + if (part[0] == '.' && part[1] == '.' && part[2] == '\0') { + if (inode->parent) { + put_inode(parent); + parent = get_inode(inode->parent); + put_inode(inode); + inode = NULL; + if (!echar) { + /* Terminal double dots */ + inode = parent; + parent = inode->parent ? + get_inode(inode->parent) : NULL; + } + } + } else if (part[0] != '.' || part[1] != '\0') { + inode = btrfs_iget(part, parent); + if (!inode) + goto err; + if (inode->mode == DT_LNK) { + char *linkbuf, *q; + int name_len = echar ? strlen(p) : 0; + int total_len = inode->size + name_len + 2; + int link_len; + + if (/*!this_fs->fs_ops->readlink ||*/ + --symlink_count == 0 || /* limit check */ + total_len > MAX_SYMLINK_BUF) + goto err; + + linkbuf = malloc(total_len); + if (!linkbuf) + goto err; + + link_len = btrfs_readlink(inode, linkbuf); + if (link_len <= 0) { + free(linkbuf); + goto err; + } + + q = linkbuf + link_len; + + if (echar) { + if (link_len > 0 && q[-1] != '/') + *q++ = '/'; + + memcpy(q, p, name_len+1); + } else { + *q = '\0'; + } + + free(pathbuf); + p = pathbuf = linkbuf; + put_inode(inode); + inode = NULL; + goto got_link; + } + + inode->name = strdup(part); + + inode->parent = parent; + parent = NULL; + + if (!echar) + break; + + if (inode->mode != DT_DIR) + goto err; + + parent = inode; + inode = NULL; + } + } while (echar); + } while (0); + + free(pathbuf); + pathbuf = NULL; + put_inode(parent); + parent = NULL; + + if (!inode) + goto err; + + file->inode = inode; + file->offset = 0; + return file_to_handle(file); + +err: + put_inode(inode); + put_inode(parent); + if (pathbuf) + free(pathbuf); + _close_file(file); +err_no_close: + return -1; +} + +static void get_next_extent(struct inode *inode) +{ + /* The logical start address that we care about... */ + uint32_t lstart = inode->this_extent.lstart + inode->this_extent.len; + + if (btrfs_next_extent(inode, lstart)) + inode->next_extent.len = 0; /* ERROR */ + inode->next_extent.lstart = lstart; +} + +int getfssec(struct com32_filedata *filedata, char * buf) +{ + int sectors; + char have_more; + uint32_t bytes_read; + struct file *file; + uint16_t handle; + if(filedata->size>=512) + { + sectors = filedata->size/SECTOR_SIZE; + sectors += (filedata->size%SECTOR_SIZE)?1:0; + } + else sectors=2; + + file = handle_to_file(filedata->handle); + + bytes_read = btrfs_getfssec(file, buf, sectors, &have_more); + if (!have_more) { + } + return bytes_read; +} + +uint32_t generic_getfssec(struct file *file, char *buf, + int sectors, char *have_more) +{ + struct inode *inode = file->inode; + struct fs_info *fs = file->fs; + uint32_t bytes_read = 0; + uint32_t bytes_left = inode->size - file->offset; + uint32_t sectors_left = + (bytes_left + SECTOR_SIZE - 1) >> 9; + uint32_t lsector; + + if (sectors > sectors_left) + sectors = sectors_left; + + if (!sectors) + return 0; + + lsector = file->offset >> 9; + + if (lsector < inode->this_extent.lstart || + lsector >= inode->this_extent.lstart + inode->this_extent.len) { + /* inode->this_extent unusable, maybe next_extent is... */ + inode->this_extent = inode->next_extent; + } + + if (lsector < inode->this_extent.lstart || + lsector >= inode->this_extent.lstart + inode->this_extent.len) { + /* Still nothing useful... */ + inode->this_extent.lstart = lsector; + inode->this_extent.len = 0; + } else { + /* We have some usable information */ + uint32_t delta = lsector - inode->this_extent.lstart; + inode->this_extent.lstart = lsector; + inode->this_extent.len -= delta; + inode->this_extent.pstart + = next_psector(inode->this_extent.pstart, delta); + } + + + while (sectors) { + uint32_t chunk; + size_t len; + + while (sectors > inode->this_extent.len) { + if (!inode->next_extent.len || + inode->next_extent.lstart != + inode->this_extent.lstart + inode->this_extent.len) + get_next_extent(inode); + if (!inode->this_extent.len) { + /* Doesn't matter if it's contiguous... */ + inode->this_extent = inode->next_extent; + if (!inode->next_extent.len) { + sectors = 0; /* Failed to get anything... we're dead */ + break; + } + } else if (inode->next_extent.len && + inode->next_extent.pstart == next_pstart(&inode->this_extent)) { + /* Coalesce extents and loop */ + inode->this_extent.len += inode->next_extent.len; + } else { + /* Discontiguous extents */ + break; + } + } + + + chunk = min(sectors, inode->this_extent.len); + len = chunk << 9;//SECTOR_SHIFT(fs); + + + if (inode->this_extent.pstart == EXTENT_ZERO) { + memset(buf, 0, len); + } else { + btrfs_block_dev_desc->block_read( btrfs_block_dev_desc->dev, + part_info->start+(inode->this_extent.pstart), chunk, buf); + inode->this_extent.pstart += chunk; + } + + buf += len; + sectors -= chunk; + bytes_read += len; + inode->this_extent.lstart += chunk; + inode->this_extent.len -= chunk; + } + + bytes_read = min(bytes_read, bytes_left); + file->offset += bytes_read; + + if (have_more) + *have_more = bytes_read < bytes_left; + + return bytes_read; +} diff --git a/fs/fs.c b/fs/fs.c index 023e7ef..b662a25 100644 --- a/fs/fs.c +++ b/fs/fs.c @@ -20,9 +20,8 @@ #include <ext4fs.h> #include <fat.h> #include <fs.h> - +#include <btrfs.h> DECLARE_GLOBAL_DATA_PTR; - static block_dev_desc_t *fs_dev_desc; static disk_partition_t fs_partition; static int fs_type = FS_TYPE_ANY; @@ -79,6 +78,73 @@ static inline void fs_close_fat(void) #define fs_read_fat fs_read_unsupported #endif + +#ifdef CONFIG_FS_BTR +struct fs_info fs; +static int fs_probe_btr(void) +{ + + btrfs_set_blk_dev(fs_dev_desc, &fs_partition); + + if (btrfs_fs_init(&fs)==-1) { + printf("btrfs probe failed\n"); + return -1; + } + + return 0; +} + +static void fs_close_btr(void) +{ +} + +#define fs_ls_btr btrfs_ls +static int fs_read_btr(const char *filename, ulong addr, int offset, int len) +{ + int file_len=0; + int len_read; + struct com32_filedata filedata; + int handle; + if (offset != 0) { + printf("** Cannot support non-zero offset **\n"); + return -1; + } + + handle=btrfs_open_file(filename, &filedata); + if (handle < 0) { + printf("** File not found %s Invalid handle**\n", filename); + return -1; + } + //file handle is valid get the size of the file + len=filedata.size; + if (len == 0) + len = file_len; + + len_read = getfssec(&filedata, (char *)addr); + if (len_read != len) { + printf("** Unable to read file %s **\n", filename); + return -1; + } + + return len_read; +} + +#else +static inline int fs_probe_btr(void) +{ + return -1; +} + +static inline void fs_close_btr(void) +{ +} + +#define fs_ls_btr fs_ls_unsupported +#define fs_read_btr fs_read_unsupported +#endif + + + #ifdef CONFIG_FS_EXT4 static int fs_probe_ext(void) { @@ -155,6 +221,10 @@ static struct { .fstype = FS_TYPE_EXT, .probe = fs_probe_ext, }, + { + .fstype = FS_TYPE_BTR, + .probe = fs_probe_btr, + }, }; int fs_set_blk_dev(const char *ifname, const char *dev_part_str, int fstype) @@ -178,7 +248,6 @@ int fs_set_blk_dev(const char *ifname, const char *dev_part_str, int fstype) for (i = 0; i < ARRAY_SIZE(fstypes); i++) { if ((fstype != FS_TYPE_ANY) && (fstype != fstypes[i].fstype)) continue; - if (!fstypes[i].probe()) { fs_type = fstypes[i].fstype; return 0; @@ -198,6 +267,9 @@ static void fs_close(void) case FS_TYPE_EXT: fs_close_ext(); break; + case FS_TYPE_BTR: + fs_close_btr(); + break; default: break; } @@ -208,7 +280,6 @@ static void fs_close(void) int fs_ls(const char *dirname) { int ret; - switch (fs_type) { case FS_TYPE_FAT: ret = fs_ls_fat(dirname); @@ -216,6 +287,9 @@ int fs_ls(const char *dirname) case FS_TYPE_EXT: ret = fs_ls_ext(dirname); break; + case FS_TYPE_BTR: + ret = fs_ls_unsupported(dirname); + break; default: ret = fs_ls_unsupported(dirname); break; @@ -237,11 +311,13 @@ int fs_read(const char *filename, ulong addr, int offset, int len) case FS_TYPE_EXT: ret = fs_read_ext(filename, addr, offset, len); break; + case FS_TYPE_BTR: + ret = fs_read_btr(filename, addr, offset, len); + break; default: ret = fs_read_unsupported(filename, addr, offset, len); break; } - fs_close(); return ret; diff --git a/include/btrfs.h b/include/btrfs.h new file mode 100644 index 0000000..4124ca6 --- /dev/null +++ b/include/btrfs.h @@ -0,0 +1,398 @@ +#ifndef _BTRFS_H_ +#define _BTRFS_H_ + +#include <asm/byteorder.h> +/* type that store on disk, but it is same as cpu type for i386 arch */ + +#define CURRENTDIR_MAX 15 +#define MAX_OPEN 5 +#define FILENAME_MAX 20 +#define MAX_SYMLINK_CNT 20 +#define MAX_SYMLINK_BUF 4096 +#define SECTOR_SHIFT(fs) ((fs)->sector_shift) +#define IFTODT(mode) (((mode) & 0170000) >> 12) +#define SECTOR_SIZE 0x200 +#define SECTOR_BITS 9 +#define EXTENT_ZERO ((__le32)-1) /* All-zero extent */ +#define EXTENT_VOID ((__le32)-2) /* Invalid information */ +#define DT_LNK 10 +#define DT_REG 8 +#define DT_DIR 4 + + +#define EXTENT_SPECIAL(x) ((x) >= EXTENT_VOID) +#define MAX_SUBVOL_NAME 50 +struct com32_filedata { + size_t size; /* File size */ + int blocklg2; /* log2(block size) */ + uint16_t handle; /* File handle */ +}; + +struct fs_info { + const struct fs_ops *fs_ops; + struct device *fs_dev; + void *fs_info; /* The fs-specific information */ + int sector_shift, sector_size; + int block_shift, block_size; + struct inode *root, *cwd; /* Root and current directories */ + char cwd_name[CURRENTDIR_MAX]; /* Current directory by name */ +}; +/* + * Extent structure: contains the mapping of some chunk of a file + * that is contiguous on disk. + */ +struct extent { + //sector_t pstart; /* Physical start sector */ + __le64 pstart; + __le32 lstart; /* Logical start sector */ + __le32 len; /* Number of contiguous sectors */ +}__attribute__ ((__packed__)); + + +struct inode { + struct fs_info *fs; /* The filesystem this inode is associated with */ + struct inode *parent; /* Parent directory, if any */ + const u8 *name; /* Name, valid for generic path search only */ + __le32 refcnt; + __le32 mode; /* FILE , DIR or SYMLINK */ + __le32 size; + __le32 blocks; /* How many blocks the file take */ + __le32 ino; /* Inode number */ + __le32 atime; /* Access time */ + __le32 mtime; /* Modify time */ + __le32 ctime; /* Create time */ + __le32 dtime; /* Delete time */ + __le32 flags; + __le32 file_acl; + struct extent this_extent, next_extent; + u8 pvt[0]; /* Private filesystem data */ +}__attribute__ ((__packed__)); +struct file { + struct fs_info *fs; + __le64 offset; /* for next read */ + struct inode *inode; /* The file-specific information */ +}__attribute__ ((__packed__)); + +#define NAME_MAX 20 +struct dirent { + uint32_t d_ino; + uint32_t d_off; + uint16_t d_reclen; + uint16_t d_type; + char d_name[NAME_MAX + 1]; +}; + + +#include "crc32c.h" +#define btrfs_crc32c crc32c_le + +#define BTRFS_SUPER_INFO_OFFSET (64 * 1024) +#define BTRFS_SUPER_INFO_SIZE 4096 +#define BTRFS_MAX_LEAF_SIZE 4096 +#define BTRFS_BLOCK_SHIFT 12 + +#define BTRFS_SUPER_MIRROR_MAX 3 +#define BTRFS_SUPER_MIRROR_SHIFT 12 +#define BTRFS_CSUM_SIZE 32 +#define BTRFS_FSID_SIZE 16 +#define BTRFS_LABEL_SIZE 256 +#define BTRFS_SYSTEM_CHUNK_ARRAY_SIZE 2048 +#define BTRFS_UUID_SIZE 16 + +#define BTRFS_MAGIC "_BHRfS_M" + +#define BTRFS_SUPER_FLAG_METADUMP (1ULL << 33) + +#define BTRFS_DEV_ITEM_KEY 216 +#define BTRFS_CHUNK_ITEM_KEY 228 +#define BTRFS_ROOT_REF_KEY 156 +#define BTRFS_ROOT_ITEM_KEY 132 +#define BTRFS_EXTENT_DATA_KEY 108 +#define BTRFS_DIR_ITEM_KEY 84 +#define BTRFS_INODE_ITEM_KEY 1 + +#define BTRFS_EXTENT_TREE_OBJECTID 2ULL +#define BTRFS_FS_TREE_OBJECTID 5ULL + +#define BTRFS_FIRST_CHUNK_TREE_OBJECTID 256ULL + +#define BTRFS_FILE_EXTENT_INLINE 0 +#define BTRFS_FILE_EXTENT_REG 1 +#define BTRFS_FILE_EXTENT_PREALLOC 2 + +#define BTRFS_MAX_LEVEL 8 +#define BTRFS_MAX_CHUNK_ENTRIES 256 + +#define BTRFS_FT_REG_FILE 1 +#define BTRFS_FT_DIR 2 +#define BTRFS_FT_SYMLINK 7 + +#define ROOT_DIR_WORD 0x002f + +struct btrfs_dev_item { + __le64 devid; + __le64 total_bytes; + __le64 bytes_used; + __le32 io_align; + __le32 io_width; + __le32 sector_size; + __le64 type; + __le64 generation; + __le64 start_offset; + __le32 dev_group; + u8 seek_speed; + u8 bandwidth; + u8 uuid[BTRFS_UUID_SIZE]; + u8 fsid[BTRFS_UUID_SIZE]; +} __attribute__ ((__packed__)); + +struct btrfs_super_block { + u8 csum[BTRFS_CSUM_SIZE]; + /* the first 4 fields must match struct btrfs_header */ + u8 fsid[BTRFS_FSID_SIZE]; /* FS specific uuid */ + __le64 bytenr; /* this block number */ + __le64 flags; + + /* allowed to be different from the btrfs_header from here own down */ + __le64 magic; + __le64 generation; + __le64 root; + __le64 chunk_root; + __le64 log_root; + + /* this will help find the new super based on the log root */ + __le64 log_root_transid; + __le64 total_bytes; + __le64 bytes_used; + __le64 root_dir_objectid; + __le64 num_devices; + __le32 sectorsize; + __le32 nodesize; + __le32 leafsize; + __le32 stripesize; + __le32 sys_chunk_array_size; + __le64 chunk_root_generation; + __le64 compat_flags; + __le64 compat_ro_flags; + __le64 incompat_flags; + __le16 csum_type; + u8 root_level; + u8 chunk_root_level; + u8 log_root_level; + struct btrfs_dev_item dev_item; + + char label[BTRFS_LABEL_SIZE]; + + __le64 cache_generation; + + /* future expansion */ + __le64 reserved[31]; + u8 sys_chunk_array[BTRFS_SYSTEM_CHUNK_ARRAY_SIZE]; +} __attribute__ ((__packed__)); +struct btrfs_disk_key { + __le64 objectid; + u8 type; + __le64 offset; +} __attribute__ ((__packed__)); + +struct btrfs_stripe { + __le64 devid; + __le64 offset; + u8 dev_uuid[BTRFS_UUID_SIZE]; +} __attribute__ ((__packed__)); + +struct btrfs_chunk { + __le64 length; + __le64 owner; + __le64 stripe_len; + __le64 type; + __le32 io_align; + __le32 io_width; + __le32 sector_size; + __le16 num_stripes; + __le16 sub_stripes; + struct btrfs_stripe stripe; +} __attribute__ ((__packed__)); + +struct btrfs_header { + /* these first four must match the super block */ + u8 csum[BTRFS_CSUM_SIZE]; + u8 fsid[BTRFS_FSID_SIZE]; /* FS specific uuid */ + __le64 bytenr; /* which block this node is supposed to live in */ + __le64 flags; + + /* allowed to be different from the super from here on down */ + u8 chunk_tree_uuid[BTRFS_UUID_SIZE]; + __le64 generation; + __le64 owner; + __le32 nritems; + u8 level; +} __attribute__ ((__packed__)); + +struct btrfs_item { + struct btrfs_disk_key key; + __le32 offset; + __le32 size; +} __attribute__ ((__packed__)); + +struct btrfs_leaf { + struct btrfs_header header; + struct btrfs_item items[]; +} __attribute__ ((__packed__)); + +struct btrfs_key_ptr { + struct btrfs_disk_key key; + __le64 blockptr; + __le64 generation; +} __attribute__ ((__packed__)); + +struct btrfs_node { + struct btrfs_header header; + struct btrfs_key_ptr ptrs[]; +} __attribute__ ((__packed__)); + +/* remember how we get to a node/leaf */ +struct btrfs_path { + __le64 offsets[BTRFS_MAX_LEVEL]; + __le32 itemsnr[BTRFS_MAX_LEVEL]; + __le32 slots[BTRFS_MAX_LEVEL]; + /* remember last slot's item and data */ + struct btrfs_item item; + u8 data[BTRFS_MAX_LEAF_SIZE]; +}__attribute__ ((__packed__)); + +/* store logical offset to physical offset mapping */ +struct btrfs_chunk_map_item { + __le64 logical; + __le64 length; + __le64 devid; + __le64 physical; +} __attribute__ ((__packed__)); + +struct btrfs_chunk_map { + struct btrfs_chunk_map_item *map; + __le32 map_length; + __le32 cur_length; +} __attribute__ ((__packed__));; + +struct btrfs_timespec { + __le64 sec; + __le32 nsec; +} __attribute__ ((__packed__)); + +struct btrfs_inode_item { + /* nfs style generation number */ + __le64 generation; + /* transid that last touched this inode */ + __le64 transid; + __le64 size; + __le64 nbytes; + __le64 block_group; + __le32 nlink; + __le32 uid; + __le32 gid; + __le32 mode; + __le64 rdev; + __le64 flags; + + /* modification sequence number for NFS */ + __le64 sequence; + + /* + * a little future expansion, for more than this we can + * just grow the inode item and version it + */ + __le64 reserved[4]; + struct btrfs_timespec atime; + struct btrfs_timespec ctime; + struct btrfs_timespec mtime; + struct btrfs_timespec otime; +} __attribute__ ((__packed__)); + +struct btrfs_root_item { + struct btrfs_inode_item inode; + __le64 generation; + __le64 root_dirid; + __le64 bytenr; + __le64 byte_limit; + __le64 bytes_used; + __le64 last_snapshot; + __le64 flags; + __le32 refs; + struct btrfs_disk_key drop_progress; + u8 drop_level; + u8 level; +} __attribute__ ((__packed__)); + +struct btrfs_dir_item { + struct btrfs_disk_key location; + __le64 transid; + __le16 data_len; + __le16 name_len; + u8 type; +} __attribute__ ((__packed__)); + +struct btrfs_file_extent_item { + __le64 generation; + __le64 ram_bytes; + u8 compression; + u8 encryption; + __le16 other_encoding; /* spare for later use */ + u8 type; + __le64 disk_bytenr; + __le64 disk_num_bytes; + __le64 offset; + __le64 num_bytes; +} __attribute__ ((__packed__)); + +struct btrfs_root_ref { + __le64 dirid; + __le64 sequence; + __le16 name_len; +} __attribute__ ((__packed__)); + +/* + * btrfs private inode information + */ +struct btrfs_pvt_inode { + __le64 offset; +}__attribute__ ((__packed__)); + +void btrfs_set_blk_dev(block_dev_desc_t* rbdd , disk_partition_t *info); +int btrfs_fs_init(struct fs_info *fs); +void put_inode(struct inode *inode); +struct inode *alloc_inode(struct fs_info *fs, uint32_t ino, size_t data); +int btrfs_open_file(const char *name, struct com32_filedata *filedata); +int getfssec(struct com32_filedata *filedata, char * buf); +uint32_t generic_getfssec(struct file *file, char *buf, + int sectors, char *have_more); +#define PVT(i) ((struct btrfs_pvt_inode *)((i)->pvt)) +static inline __le32 next_psector(__le32 psector, uint32_t skip) +{ + if (EXTENT_SPECIAL(psector)) + return psector; + else + return psector + skip; +} + +static inline __le32 next_pstart(const struct extent *e) +{ + return next_psector(e->pstart, e->len); +} + +/* + * Our definition of "not whitespace" + */ +static inline char not_whitespace(char c) +{ + return (unsigned char)c > ' '; +} + +static inline struct inode *get_inode(struct inode *inode) +{ + inode->refcnt++; + return inode; +} + + +#endif diff --git a/include/config_fallbacks.h b/include/config_fallbacks.h index bfb9680..28a0a66 100644 --- a/include/config_fallbacks.h +++ b/include/config_fallbacks.h @@ -26,4 +26,8 @@ #define CONFIG_EXT4_WRITE #endif +#if defined(CONFIG_CMD_BTR) && !defined(CONFIG_FS_BTR) +#define CONFIG_FS_BTR +#endif + #endif /* __CONFIG_FALLBACKS_H */ diff --git a/include/crc32c.h b/include/crc32c.h new file mode 100644 index 0000000..d04916e --- /dev/null +++ b/include/crc32c.h @@ -0,0 +1,48 @@ +/* + * Copied from Linux kernel crypto/crc32c.c + * Copyright (c) 2004 Cisco Systems, Inc. + * Copyright (c) 2008 Herbert Xu <herbert@gondor.apana.org.au> + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published by the Free + * Software Foundation; either version 2 of the License, or (at your option) + * any later version. + * + */ + +/* + * This is the CRC-32C table + * Generated with: + * width = 32 bits + * poly = 0x1EDC6F41 + * reflect input bytes = true + * reflect output bytes = true + */ + +/* + * Steps through buffer one byte at at time, calculates reflected + * crc using table. + */ + +static inline u32 crc32c_cal(u32 crc, const char *data, size_t length, u32 *crc32c_table) +{ + while (length--) + crc = crc32c_table[(u8)(crc ^ *data++)] ^ (crc >> 8); + + return crc; +} + +static inline void crc32c_init(u32 *crc32c_table, u32 pol) +{ + int i, j; + u32 v; + const u32 poly = pol; /* Bit-reflected CRC32C polynomial */ + + for (i = 0; i < 256; i++) { + v = i; + for (j = 0; j < 8; j++) { + v = (v >> 1) ^ ((v & 1) ? poly : 0); + } + crc32c_table[i] = v; + } +} diff --git a/include/fs.h b/include/fs.h index 4f30a38..3a0e7d4 100644 --- a/include/fs.h +++ b/include/fs.h @@ -21,6 +21,7 @@ #define FS_TYPE_ANY 0 #define FS_TYPE_FAT 1 #define FS_TYPE_EXT 2 +#define FS_TYPE_BTR 3 /* * Tell the fs layer which block device an partition to use for future -- 1.7.9.5 ^ permalink raw reply related [flat|nested] 16+ messages in thread
* [U-Boot] [PATCH v3] Introduced btrfs file-system with btrload command 2013-02-25 12:24 ` [U-Boot] [PATCH v3] Introduced btrfs file-system with btrload command Adnan Ali @ 2013-02-25 15:04 ` Tom Rini 2013-02-25 16:08 ` Adnan Ali 2013-02-25 23:02 ` Simon Glass 2013-03-01 22:53 ` Wolfgang Denk 1 sibling, 2 replies; 16+ messages in thread From: Tom Rini @ 2013-02-25 15:04 UTC (permalink / raw) To: u-boot On Mon, Feb 25, 2013 at 12:24:37PM +0000, Adnan Ali wrote: > Introduces btrfs file-system to read file > from volume/sub-volumes with btrload command. This > implementation has read-only support. > This btrfs implementation is based on syslinux btrfs > code, commit 269ebc845ebc8b46ef4b0be7fa0005c7fdb95b8d. > > Signed-off-by: Adnan Ali <adnan.ali@codethink.co.uk> A few things: - In general in fs/btrfs/btrfs.c I see some coding style problems (lack of spacing, non-printf's longer than 80-wide). Do these come from syslinux and thus will make any re-syncs easier? - It looks like you added support for CONFIG_CMD_FS_GENERIC, if so did you test that? - Can you please enable this support code on at least one platform, preferably the one you've tested and developed with? [snip] > diff --git a/fs/fs.c b/fs/fs.c [snip] > + //file handle is valid get the size of the file /* Style comments only */ > + len=filedata.size; And spacing between variable and assignment. > @@ -178,7 +248,6 @@ int fs_set_blk_dev(const char *ifname, const char *dev_part_str, int fstype) > for (i = 0; i < ARRAY_SIZE(fstypes); i++) { > if ((fstype != FS_TYPE_ANY) && (fstype != fstypes[i].fstype)) > continue; > - > if (!fstypes[i].probe()) { > fs_type = fstypes[i].fstype; > return 0; [snip] > @@ -208,7 +280,6 @@ static void fs_close(void) > int fs_ls(const char *dirname) > { > int ret; > - > switch (fs_type) { > case FS_TYPE_FAT: > ret = fs_ls_fat(dirname); Unrelated, please drop. > @@ -237,11 +311,13 @@ int fs_read(const char *filename, ulong addr, int offset, int len) > case FS_TYPE_EXT: > ret = fs_read_ext(filename, addr, offset, len); > break; > + case FS_TYPE_BTR: > + ret = fs_read_btr(filename, addr, offset, len); > + break; > default: > ret = fs_read_unsupported(filename, addr, offset, len); > break; > } > - > fs_close(); And unrelated whitespace changes here as well. > diff --git a/include/btrfs.h b/include/btrfs.h [snip] > +/* > + * Extent structure: contains the mapping of some chunk of a file > + * that is contiguous on disk. > + */ > +struct extent { > + //sector_t pstart; /* Physical start sector */ > + __le64 pstart; Fix please. > +/* > + * Our definition of "not whitespace" > + */ > +static inline char not_whitespace(char c) > +{ > + return (unsigned char)c > ' '; > +} Can't you just use isspace from <linux/ctypes.h> ? > diff --git a/include/crc32c.h b/include/crc32c.h > new file mode 100644 > index 0000000..d04916e > --- /dev/null > +++ b/include/crc32c.h > @@ -0,0 +1,48 @@ > +/* > + * Copied from Linux kernel crypto/crc32c.c > + * Copyright (c) 2004 Cisco Systems, Inc. > + * Copyright (c) 2008 Herbert Xu <herbert@gondor.apana.org.au> > + * > + * This program is free software; you can redistribute it and/or modify it > + * under the terms of the GNU General Public License as published by the Free > + * Software Foundation; either version 2 of the License, or (at your option) > + * any later version. > + * > + */ > + > +/* > + * This is the CRC-32C table > + * Generated with: > + * width = 32 bits > + * poly = 0x1EDC6F41 > + * reflect input bytes = true > + * reflect output bytes = true > + */ > + > +/* > + * Steps through buffer one byte at at time, calculates reflected > + * crc using table. > + */ > + > +static inline u32 crc32c_cal(u32 crc, const char *data, size_t length, u32 *crc32c_table) > +{ > + while (length--) > + crc = crc32c_table[(u8)(crc ^ *data++)] ^ (crc >> 8); > + > + return crc; > +} > + > +static inline void crc32c_init(u32 *crc32c_table, u32 pol) > +{ > + int i, j; > + u32 v; > + const u32 poly = pol; /* Bit-reflected CRC32C polynomial */ > + > + for (i = 0; i < 256; i++) { > + v = i; > + for (j = 0; j < 8; j++) { > + v = (v >> 1) ^ ((v & 1) ? poly : 0); > + } > + crc32c_table[i] = v; > + } > +} Simon, since you've just been over all the crc32 recently, do we have these functions somewhere already that can be easily tapped in to? Thanks! -- Tom -------------- next part -------------- A non-text attachment was scrubbed... Name: not available Type: application/pgp-signature Size: 836 bytes Desc: Digital signature URL: <http://lists.denx.de/pipermail/u-boot/attachments/20130225/e1521cf0/attachment.pgp> ^ permalink raw reply [flat|nested] 16+ messages in thread
* [U-Boot] [PATCH v3] Introduced btrfs file-system with btrload command 2013-02-25 15:04 ` Tom Rini @ 2013-02-25 16:08 ` Adnan Ali 2013-02-25 16:29 ` Tom Rini 2013-02-25 23:02 ` Simon Glass 1 sibling, 1 reply; 16+ messages in thread From: Adnan Ali @ 2013-02-25 16:08 UTC (permalink / raw) To: u-boot On 25/02/13 15:04, Tom Rini wrote: > On Mon, Feb 25, 2013 at 12:24:37PM +0000, Adnan Ali wrote: > >> Introduces btrfs file-system to read file >> from volume/sub-volumes with btrload command. This >> implementation has read-only support. >> This btrfs implementation is based on syslinux btrfs >> code, commit 269ebc845ebc8b46ef4b0be7fa0005c7fdb95b8d. >> >> Signed-off-by: Adnan Ali <adnan.ali@codethink.co.uk> > A few things: > - In general in fs/btrfs/btrfs.c I see some coding style problems (lack > of spacing, non-printf's longer than 80-wide). Do these come from > syslinux and thus will make any re-syncs easier? Most of the ported code is unmodified so its coding style should be same as syslinux. > - It looks like you added support for CONFIG_CMD_FS_GENERIC, if so did > you test that? This command wasn't enabled in my configs. I haven't added any command i.e btrls for this as this feature is not supported yet. > - Can you please enable this support code on at least one platform, > preferably the one you've tested and developed with? Even if do enable support for this, it will also debug 'Unsupported filesystem type.' For the rest of changes you proposed i will change them and send as v4 patch. > > [snip] >> diff --git a/fs/fs.c b/fs/fs.c > [snip] >> + //file handle is valid get the size of the file > /* Style comments only */ > >> + len=filedata.size; > And spacing between variable and assignment. > >> @@ -178,7 +248,6 @@ int fs_set_blk_dev(const char *ifname, const char *dev_part_str, int fstype) >> for (i = 0; i < ARRAY_SIZE(fstypes); i++) { >> if ((fstype != FS_TYPE_ANY) && (fstype != fstypes[i].fstype)) >> continue; >> - >> if (!fstypes[i].probe()) { >> fs_type = fstypes[i].fstype; >> return 0; > [snip] >> @@ -208,7 +280,6 @@ static void fs_close(void) >> int fs_ls(const char *dirname) >> { >> int ret; >> - >> switch (fs_type) { >> case FS_TYPE_FAT: >> ret = fs_ls_fat(dirname); > Unrelated, please drop. > >> @@ -237,11 +311,13 @@ int fs_read(const char *filename, ulong addr, int offset, int len) >> case FS_TYPE_EXT: >> ret = fs_read_ext(filename, addr, offset, len); >> break; >> + case FS_TYPE_BTR: >> + ret = fs_read_btr(filename, addr, offset, len); >> + break; >> default: >> ret = fs_read_unsupported(filename, addr, offset, len); >> break; >> } >> - >> fs_close(); > And unrelated whitespace changes here as well. > >> diff --git a/include/btrfs.h b/include/btrfs.h > [snip] >> +/* >> + * Extent structure: contains the mapping of some chunk of a file >> + * that is contiguous on disk. >> + */ >> +struct extent { >> + //sector_t pstart; /* Physical start sector */ >> + __le64 pstart; > Fix please. > >> +/* >> + * Our definition of "not whitespace" >> + */ >> +static inline char not_whitespace(char c) >> +{ >> + return (unsigned char)c > ' '; >> +} > Can't you just use isspace from <linux/ctypes.h> ? > >> diff --git a/include/crc32c.h b/include/crc32c.h >> new file mode 100644 >> index 0000000..d04916e >> --- /dev/null >> +++ b/include/crc32c.h >> @@ -0,0 +1,48 @@ >> +/* >> + * Copied from Linux kernel crypto/crc32c.c >> + * Copyright (c) 2004 Cisco Systems, Inc. >> + * Copyright (c) 2008 Herbert Xu <herbert@gondor.apana.org.au> >> + * >> + * This program is free software; you can redistribute it and/or modify it >> + * under the terms of the GNU General Public License as published by the Free >> + * Software Foundation; either version 2 of the License, or (at your option) >> + * any later version. >> + * >> + */ >> + >> +/* >> + * This is the CRC-32C table >> + * Generated with: >> + * width = 32 bits >> + * poly = 0x1EDC6F41 >> + * reflect input bytes = true >> + * reflect output bytes = true >> + */ >> + >> +/* >> + * Steps through buffer one byte at at time, calculates reflected >> + * crc using table. >> + */ >> + >> +static inline u32 crc32c_cal(u32 crc, const char *data, size_t length, u32 *crc32c_table) >> +{ >> + while (length--) >> + crc = crc32c_table[(u8)(crc ^ *data++)] ^ (crc >> 8); >> + >> + return crc; >> +} >> + >> +static inline void crc32c_init(u32 *crc32c_table, u32 pol) >> +{ >> + int i, j; >> + u32 v; >> + const u32 poly = pol; /* Bit-reflected CRC32C polynomial */ >> + >> + for (i = 0; i < 256; i++) { >> + v = i; >> + for (j = 0; j < 8; j++) { >> + v = (v >> 1) ^ ((v & 1) ? poly : 0); >> + } >> + crc32c_table[i] = v; >> + } >> +} > Simon, since you've just been over all the crc32 recently, do we have > these functions somewhere already that can be easily tapped in to? > Thanks! > Thanks Adnan ^ permalink raw reply [flat|nested] 16+ messages in thread
* [U-Boot] [PATCH v3] Introduced btrfs file-system with btrload command 2013-02-25 16:08 ` Adnan Ali @ 2013-02-25 16:29 ` Tom Rini 2013-02-25 16:44 ` Adnan Ali 0 siblings, 1 reply; 16+ messages in thread From: Tom Rini @ 2013-02-25 16:29 UTC (permalink / raw) To: u-boot -----BEGIN PGP SIGNED MESSAGE----- Hash: SHA1 On 02/25/2013 11:08 AM, Adnan Ali wrote: > On 25/02/13 15:04, Tom Rini wrote: >> On Mon, Feb 25, 2013 at 12:24:37PM +0000, Adnan Ali wrote: >> >>> Introduces btrfs file-system to read file from >>> volume/sub-volumes with btrload command. This implementation >>> has read-only support. This btrfs implementation is based on >>> syslinux btrfs code, commit >>> 269ebc845ebc8b46ef4b0be7fa0005c7fdb95b8d. >>> >>> Signed-off-by: Adnan Ali <adnan.ali@codethink.co.uk> >> A few things: - In general in fs/btrfs/btrfs.c I see some coding >> style problems (lack of spacing, non-printf's longer than >> 80-wide). Do these come from syslinux and thus will make any >> re-syncs easier? > Most of the ported code is unmodified so its coding style should be > same as syslinux. That's what I thought. >> - It looks like you added support for CONFIG_CMD_FS_GENERIC, if >> so did you test that? > This command wasn't enabled in my configs. I haven't added any > command i.e btrls for this as this feature is not supported yet. Can you then please? Thanks. >> - Can you please enable this support code on at least one >> platform, preferably the one you've tested and developed with? > Even if do enable support for this, it will also debug 'Unsupported > filesystem type.' I don't understand. > For the rest of changes you proposed i will change them and send as > v4 patch. Thanks! - -- Tom -----BEGIN PGP SIGNATURE----- Version: GnuPG v1.4.11 (GNU/Linux) Comment: Using GnuPG with Thunderbird - http://www.enigmail.net/ iQIcBAEBAgAGBQJRK5FtAAoJENk4IS6UOR1WLbYP/i/c8s10TIoya1UnLiCX87tt u/DRhip4/HBhyCtZmxCejLM6VrgJ8GBACq7hP6eXY3BE5zRB11rKnaypOdc1EA6h WG87W+6LDOQEvFPzuyXRpXIGvUwq5gHsa95rM0pq/k5WnUJwl4eRAyuhU0JFilQ8 p83GUbYH3Ss1ZX6sr2O+LNkGrIW/PNw1TVioJYyfUUQvcqVYw8CIBLSusxCkY445 ps2QD3Np4XvYXkGFoHUkb0t+Lp0m87PaHBAuABr+TqUEne+QT3GU1E6xN4jcoasX 2Bd0LQFnIhoU6hiH/EuAsQs8tt48ByEliug0Yvr7iK4Cb5sQen21LjXUagarvArF RKkg/SThdqwYStfkX5/+z73m2F3lcGGF9IobVuz9HWi2VvXEYM500+pGYcOzjP+3 V+deSp0PReW4lbFRnFgxcArETIumd4+deCQzX9XHUC20iC/Xf2N+s6L5VTGqQf0g 33+QDPaUo1SdCZmKiCpVuBa0hzZsQPRhFOHRUpGbEZRbf45iHl5Ewhm88K6dTiz4 vsr7YJDs4rJcph0q6tKSLVVGioPpa3EqpWZrXGB4JTwc6GHbluAvL7GXrHWxtbtX AZOxNEegmljq+l+6g+n2sZ+RDlyynU/x9NvKVEM8ucqmMGrcrTKG5fUc536U2sWL 8xEfGHfYMZ9AxbF0DEXY =FPEv -----END PGP SIGNATURE----- ^ permalink raw reply [flat|nested] 16+ messages in thread
* [U-Boot] [PATCH v3] Introduced btrfs file-system with btrload command 2013-02-25 16:29 ` Tom Rini @ 2013-02-25 16:44 ` Adnan Ali 2013-02-25 16:48 ` Tom Rini 0 siblings, 1 reply; 16+ messages in thread From: Adnan Ali @ 2013-02-25 16:44 UTC (permalink / raw) To: u-boot On 25/02/13 16:29, Tom Rini wrote: > -----BEGIN PGP SIGNED MESSAGE----- > Hash: SHA1 > > On 02/25/2013 11:08 AM, Adnan Ali wrote: >> On 25/02/13 15:04, Tom Rini wrote: >>> On Mon, Feb 25, 2013 at 12:24:37PM +0000, Adnan Ali wrote: >>> >>>> Introduces btrfs file-system to read file from >>>> volume/sub-volumes with btrload command. This implementation >>>> has read-only support. This btrfs implementation is based on >>>> syslinux btrfs code, commit >>>> 269ebc845ebc8b46ef4b0be7fa0005c7fdb95b8d. >>>> >>>> Signed-off-by: Adnan Ali <adnan.ali@codethink.co.uk> >>> A few things: - In general in fs/btrfs/btrfs.c I see some coding >>> style problems (lack of spacing, non-printf's longer than >>> 80-wide). Do these come from syslinux and thus will make any >>> re-syncs easier? >> Most of the ported code is unmodified so its coding style should be >> same as syslinux. > That's what I thought. > >>> - It looks like you added support for CONFIG_CMD_FS_GENERIC, if >>> so did you test that? >> This command wasn't enabled in my configs. I haven't added any >> command i.e btrls for this as this feature is not supported yet. > Can you then please? Thanks. I have added support for this in my configs, build and flashed on my mx53loco hardware it booted fine. When i type LS gives me ** Unrecognized filesystem type **. which is what i have done it in code. Any ls should print above message when its using btrfs. > >>> - Can you please enable this support code on at least one >>> platform, preferably the one you've tested and developed with? >> Even if do enable support for this, it will also debug 'Unsupported >> filesystem type.' > I don't understand. I'm assuming that you are asking me to test it on atleast one hardware platform with CONFIG_CMD_FS_GENERIC enabled. Which i done it on mx53loco. If my assumption is wrong can you please rephrase your question. > >> For the rest of changes you proposed i will change them and send as >> v4 patch. > Thanks! > > - -- > Tom > -----BEGIN PGP SIGNATURE----- > Version: GnuPG v1.4.11 (GNU/Linux) > Comment: Using GnuPG with Thunderbird - http://www.enigmail.net/ > > iQIcBAEBAgAGBQJRK5FtAAoJENk4IS6UOR1WLbYP/i/c8s10TIoya1UnLiCX87tt > u/DRhip4/HBhyCtZmxCejLM6VrgJ8GBACq7hP6eXY3BE5zRB11rKnaypOdc1EA6h > WG87W+6LDOQEvFPzuyXRpXIGvUwq5gHsa95rM0pq/k5WnUJwl4eRAyuhU0JFilQ8 > p83GUbYH3Ss1ZX6sr2O+LNkGrIW/PNw1TVioJYyfUUQvcqVYw8CIBLSusxCkY445 > ps2QD3Np4XvYXkGFoHUkb0t+Lp0m87PaHBAuABr+TqUEne+QT3GU1E6xN4jcoasX > 2Bd0LQFnIhoU6hiH/EuAsQs8tt48ByEliug0Yvr7iK4Cb5sQen21LjXUagarvArF > RKkg/SThdqwYStfkX5/+z73m2F3lcGGF9IobVuz9HWi2VvXEYM500+pGYcOzjP+3 > V+deSp0PReW4lbFRnFgxcArETIumd4+deCQzX9XHUC20iC/Xf2N+s6L5VTGqQf0g > 33+QDPaUo1SdCZmKiCpVuBa0hzZsQPRhFOHRUpGbEZRbf45iHl5Ewhm88K6dTiz4 > vsr7YJDs4rJcph0q6tKSLVVGioPpa3EqpWZrXGB4JTwc6GHbluAvL7GXrHWxtbtX > AZOxNEegmljq+l+6g+n2sZ+RDlyynU/x9NvKVEM8ucqmMGrcrTKG5fUc536U2sWL > 8xEfGHfYMZ9AxbF0DEXY > =FPEv > -----END PGP SIGNATURE----- Thanks Adnan ^ permalink raw reply [flat|nested] 16+ messages in thread
* [U-Boot] [PATCH v3] Introduced btrfs file-system with btrload command 2013-02-25 16:44 ` Adnan Ali @ 2013-02-25 16:48 ` Tom Rini 2013-02-25 23:04 ` Simon Glass 0 siblings, 1 reply; 16+ messages in thread From: Tom Rini @ 2013-02-25 16:48 UTC (permalink / raw) To: u-boot -----BEGIN PGP SIGNED MESSAGE----- Hash: SHA1 On 02/25/2013 11:44 AM, Adnan Ali wrote: > On 25/02/13 16:29, Tom Rini wrote: [snip] >>>>> - It looks like you added support for >>>>> CONFIG_CMD_FS_GENERIC, if so did you test that? >>>> This command wasn't enabled in my configs. I haven't added >>>> any command i.e btrls for this as this feature is not >>>> supported yet. > Can you then please? Thanks. >> I have added support for this in my configs, build and flashed on >> my mx53loco hardware it booted fine. When i type LS gives me ** >> Unrecognized filesystem type **. which is what i have done it in >> code. Any ls should print above message when its using btrfs. > >>>>> - Can you please enable this support code on at least one >>>>> platform, preferably the one you've tested and developed >>>>> with? >>>> Even if do enable support for this, it will also debug >>>> 'Unsupported filesystem type.' > I don't understand. >> I'm assuming that you are asking me to test it on atleast one >> hardware platform with CONFIG_CMD_FS_GENERIC enabled. Which i >> done it on mx53loco. If my assumption is wrong can you please >> rephrase your question. OK. Can you please add btrfs support to CONFIG_CMD_FS_GENERIC? Or try and point out that it's quite difficult / annoying / we need to fix our interface? You'd be the first person other than the author of the original changes to do so, so your feedback here would be quite useful. Thanks! - -- Tom -----BEGIN PGP SIGNATURE----- Version: GnuPG v1.4.11 (GNU/Linux) Comment: Using GnuPG with Thunderbird - http://www.enigmail.net/ iQIcBAEBAgAGBQJRK5X2AAoJENk4IS6UOR1WFqAP/0DStonfADUwZTzyxwT22spZ xGrJGUCVBBpiZ+xoO3ZRuKYG/DAkD3kYATV2DqgM/kqVuusHyiPeh4z1qcO78tWk Quwce9sIU5uhMkQey0sCbIX5YHgxY0DbrcxpNLedQLKLo1NOZY3/uJUDRNt8uIeP B3PH5uNXR8hVwwC0ML8dC8ZK7/XbPBZvdr0jjhYR8RzfHVxbpFKNL1vjxsN9TZiS ZAp+DyIP389FPRQd2zt4bhzNHGuJ2TkwewEXi00MCO8vKkRKvuPZbV7hc0w9t+d7 m1VbAzLL/FZ9ld8r3CvowgBg91vP/y8Vjr5bnX9CaZzaf96vPTVldx/UmZ9xtWtb TzPxPaYkHXEmtdGfxfYI/v1CHu9rkjiDOrZMPbXNx2XzjYdwp5kk8Hlfqi+F8d+m wFt+q2kHZdAEPDoIcvsi4buAbiqyehH03K0QpaH1UaEH01lVvw8S9U1p9/iLcSrV c1kN4GMySKdPTIoTv97S4SpHUcijI1aMOaqc462M4YKroRg54iMMHCFkQBy0HF4U n6B+yZv1Yy5IWf4Z5b143V8FN8yOSvfzG+gEMICc/NZU09nT6fwfPRfMWj2lIPj8 wsDYpdL7amDAl2TUCLEB8vbue5ELjB2Bu2S25wKrsKrN9mPvh1LvFyHhO4HJ49Ly +1SAb04CSBOhgXOzO+SZ =pYZr -----END PGP SIGNATURE----- ^ permalink raw reply [flat|nested] 16+ messages in thread
* [U-Boot] [PATCH v3] Introduced btrfs file-system with btrload command 2013-02-25 16:48 ` Tom Rini @ 2013-02-25 23:04 ` Simon Glass 0 siblings, 0 replies; 16+ messages in thread From: Simon Glass @ 2013-02-25 23:04 UTC (permalink / raw) To: u-boot Hi, On Mon, Feb 25, 2013 at 8:48 AM, Tom Rini <trini@ti.com> wrote: > -----BEGIN PGP SIGNED MESSAGE----- > Hash: SHA1 > > On 02/25/2013 11:44 AM, Adnan Ali wrote: >> On 25/02/13 16:29, Tom Rini wrote: > [snip] >>>>>> - It looks like you added support for >>>>>> CONFIG_CMD_FS_GENERIC, if so did you test that? >>>>> This command wasn't enabled in my configs. I haven't added >>>>> any command i.e btrls for this as this feature is not >>>>> supported yet. >> Can you then please? Thanks. >>> I have added support for this in my configs, build and flashed on >>> my mx53loco hardware it booted fine. When i type LS gives me ** >>> Unrecognized filesystem type **. which is what i have done it in >>> code. Any ls should print above message when its using btrfs. >> >>>>>> - Can you please enable this support code on at least one >>>>>> platform, preferably the one you've tested and developed >>>>>> with? >>>>> Even if do enable support for this, it will also debug >>>>> 'Unsupported filesystem type.' >> I don't understand. >>> I'm assuming that you are asking me to test it on atleast one >>> hardware platform with CONFIG_CMD_FS_GENERIC enabled. Which i >>> done it on mx53loco. If my assumption is wrong can you please >>> rephrase your question. > > OK. Can you please add btrfs support to CONFIG_CMD_FS_GENERIC? Or > try and point out that it's quite difficult / annoying / we need to > fix our interface? You'd be the first person other than the author of > the original changes to do so, so your feedback here would be quite > useful. Thanks! Actually please see my series starting here, which adds more support to that layer: http://patchwork.ozlabs.org/patch/208215/ Perhaps btrfs could fit in there too? Regards, Simon > > - -- > Tom > -----BEGIN PGP SIGNATURE----- > Version: GnuPG v1.4.11 (GNU/Linux) > Comment: Using GnuPG with Thunderbird - http://www.enigmail.net/ > > iQIcBAEBAgAGBQJRK5X2AAoJENk4IS6UOR1WFqAP/0DStonfADUwZTzyxwT22spZ > xGrJGUCVBBpiZ+xoO3ZRuKYG/DAkD3kYATV2DqgM/kqVuusHyiPeh4z1qcO78tWk > Quwce9sIU5uhMkQey0sCbIX5YHgxY0DbrcxpNLedQLKLo1NOZY3/uJUDRNt8uIeP > B3PH5uNXR8hVwwC0ML8dC8ZK7/XbPBZvdr0jjhYR8RzfHVxbpFKNL1vjxsN9TZiS > ZAp+DyIP389FPRQd2zt4bhzNHGuJ2TkwewEXi00MCO8vKkRKvuPZbV7hc0w9t+d7 > m1VbAzLL/FZ9ld8r3CvowgBg91vP/y8Vjr5bnX9CaZzaf96vPTVldx/UmZ9xtWtb > TzPxPaYkHXEmtdGfxfYI/v1CHu9rkjiDOrZMPbXNx2XzjYdwp5kk8Hlfqi+F8d+m > wFt+q2kHZdAEPDoIcvsi4buAbiqyehH03K0QpaH1UaEH01lVvw8S9U1p9/iLcSrV > c1kN4GMySKdPTIoTv97S4SpHUcijI1aMOaqc462M4YKroRg54iMMHCFkQBy0HF4U > n6B+yZv1Yy5IWf4Z5b143V8FN8yOSvfzG+gEMICc/NZU09nT6fwfPRfMWj2lIPj8 > wsDYpdL7amDAl2TUCLEB8vbue5ELjB2Bu2S25wKrsKrN9mPvh1LvFyHhO4HJ49Ly > +1SAb04CSBOhgXOzO+SZ > =pYZr > -----END PGP SIGNATURE----- ^ permalink raw reply [flat|nested] 16+ messages in thread
* [U-Boot] [PATCH v3] Introduced btrfs file-system with btrload command 2013-02-25 15:04 ` Tom Rini 2013-02-25 16:08 ` Adnan Ali @ 2013-02-25 23:02 ` Simon Glass 2013-02-26 12:54 ` Adnan Ali 1 sibling, 1 reply; 16+ messages in thread From: Simon Glass @ 2013-02-25 23:02 UTC (permalink / raw) To: u-boot Hi, On Mon, Feb 25, 2013 at 7:04 AM, Tom Rini <trini@ti.com> wrote: > On Mon, Feb 25, 2013 at 12:24:37PM +0000, Adnan Ali wrote: > >> Introduces btrfs file-system to read file >> from volume/sub-volumes with btrload command. This >> implementation has read-only support. >> This btrfs implementation is based on syslinux btrfs >> code, commit 269ebc845ebc8b46ef4b0be7fa0005c7fdb95b8d. >> >> Signed-off-by: Adnan Ali <adnan.ali@codethink.co.uk> > > A few things: > - In general in fs/btrfs/btrfs.c I see some coding style problems (lack > of spacing, non-printf's longer than 80-wide). Do these come from > syslinux and thus will make any re-syncs easier? > - It looks like you added support for CONFIG_CMD_FS_GENERIC, if so did > you test that? > - Can you please enable this support code on at least one platform, > preferably the one you've tested and developed with? > > [snip] >> diff --git a/fs/fs.c b/fs/fs.c > [snip] >> + //file handle is valid get the size of the file > > /* Style comments only */ > >> + len=filedata.size; > > And spacing between variable and assignment. > >> @@ -178,7 +248,6 @@ int fs_set_blk_dev(const char *ifname, const char *dev_part_str, int fstype) >> for (i = 0; i < ARRAY_SIZE(fstypes); i++) { >> if ((fstype != FS_TYPE_ANY) && (fstype != fstypes[i].fstype)) >> continue; >> - >> if (!fstypes[i].probe()) { >> fs_type = fstypes[i].fstype; >> return 0; > [snip] >> @@ -208,7 +280,6 @@ static void fs_close(void) >> int fs_ls(const char *dirname) >> { >> int ret; >> - >> switch (fs_type) { >> case FS_TYPE_FAT: >> ret = fs_ls_fat(dirname); > > Unrelated, please drop. > >> @@ -237,11 +311,13 @@ int fs_read(const char *filename, ulong addr, int offset, int len) >> case FS_TYPE_EXT: >> ret = fs_read_ext(filename, addr, offset, len); >> break; >> + case FS_TYPE_BTR: >> + ret = fs_read_btr(filename, addr, offset, len); >> + break; >> default: >> ret = fs_read_unsupported(filename, addr, offset, len); >> break; >> } >> - >> fs_close(); > > And unrelated whitespace changes here as well. > >> diff --git a/include/btrfs.h b/include/btrfs.h > [snip] >> +/* >> + * Extent structure: contains the mapping of some chunk of a file >> + * that is contiguous on disk. >> + */ >> +struct extent { >> + //sector_t pstart; /* Physical start sector */ >> + __le64 pstart; > > Fix please. > >> +/* >> + * Our definition of "not whitespace" >> + */ >> +static inline char not_whitespace(char c) >> +{ >> + return (unsigned char)c > ' '; >> +} > > Can't you just use isspace from <linux/ctypes.h> ? > >> diff --git a/include/crc32c.h b/include/crc32c.h >> new file mode 100644 >> index 0000000..d04916e >> --- /dev/null >> +++ b/include/crc32c.h >> @@ -0,0 +1,48 @@ >> +/* >> + * Copied from Linux kernel crypto/crc32c.c >> + * Copyright (c) 2004 Cisco Systems, Inc. >> + * Copyright (c) 2008 Herbert Xu <herbert@gondor.apana.org.au> >> + * >> + * This program is free software; you can redistribute it and/or modify it >> + * under the terms of the GNU General Public License as published by the Free >> + * Software Foundation; either version 2 of the License, or (at your option) >> + * any later version. >> + * >> + */ >> + >> +/* >> + * This is the CRC-32C table >> + * Generated with: >> + * width = 32 bits >> + * poly = 0x1EDC6F41 >> + * reflect input bytes = true >> + * reflect output bytes = true >> + */ >> + >> +/* >> + * Steps through buffer one byte at at time, calculates reflected >> + * crc using table. >> + */ >> + >> +static inline u32 crc32c_cal(u32 crc, const char *data, size_t length, u32 *crc32c_table) >> +{ >> + while (length--) >> + crc = crc32c_table[(u8)(crc ^ *data++)] ^ (crc >> 8); >> + >> + return crc; >> +} >> + >> +static inline void crc32c_init(u32 *crc32c_table, u32 pol) >> +{ >> + int i, j; >> + u32 v; >> + const u32 poly = pol; /* Bit-reflected CRC32C polynomial */ >> + >> + for (i = 0; i < 256; i++) { >> + v = i; >> + for (j = 0; j < 8; j++) { >> + v = (v >> 1) ^ ((v & 1) ? poly : 0); >> + } >> + crc32c_table[i] = v; >> + } >> +} > > Simon, since you've just been over all the crc32 recently, do we have > these functions somewhere already that can be easily tapped in to? > Thanks! Should be - see lib/crc32.c. There is already at least one other copy (ubifs I think) so we should try to avoid adding more. Maybe the polynomial is different here? But even so it should go with the existing code I think. Regards, Simon > > -- > Tom ^ permalink raw reply [flat|nested] 16+ messages in thread
* [U-Boot] [PATCH v3] Introduced btrfs file-system with btrload command 2013-02-25 23:02 ` Simon Glass @ 2013-02-26 12:54 ` Adnan Ali 2013-02-26 16:19 ` Simon Glass 0 siblings, 1 reply; 16+ messages in thread From: Adnan Ali @ 2013-02-26 12:54 UTC (permalink / raw) To: u-boot On 25/02/13 23:02, Simon Glass wrote: > Hi, > > On Mon, Feb 25, 2013 at 7:04 AM, Tom Rini <trini@ti.com> wrote: >> On Mon, Feb 25, 2013 at 12:24:37PM +0000, Adnan Ali wrote: >> >>> Introduces btrfs file-system to read file >>> from volume/sub-volumes with btrload command. This >>> implementation has read-only support. >>> This btrfs implementation is based on syslinux btrfs >>> code, commit 269ebc845ebc8b46ef4b0be7fa0005c7fdb95b8d. >>> >>> Signed-off-by: Adnan Ali <adnan.ali@codethink.co.uk> >> A few things: >> - In general in fs/btrfs/btrfs.c I see some coding style problems (lack >> of spacing, non-printf's longer than 80-wide). Do these come from >> syslinux and thus will make any re-syncs easier? >> - It looks like you added support for CONFIG_CMD_FS_GENERIC, if so did >> you test that? >> - Can you please enable this support code on at least one platform, >> preferably the one you've tested and developed with? >> >> [snip] >>> diff --git a/fs/fs.c b/fs/fs.c >> [snip] >>> + //file handle is valid get the size of the file >> /* Style comments only */ >> >>> + len=filedata.size; >> And spacing between variable and assignment. >> >>> @@ -178,7 +248,6 @@ int fs_set_blk_dev(const char *ifname, const char *dev_part_str, int fstype) >>> for (i = 0; i < ARRAY_SIZE(fstypes); i++) { >>> if ((fstype != FS_TYPE_ANY) && (fstype != fstypes[i].fstype)) >>> continue; >>> - >>> if (!fstypes[i].probe()) { >>> fs_type = fstypes[i].fstype; >>> return 0; >> [snip] >>> @@ -208,7 +280,6 @@ static void fs_close(void) >>> int fs_ls(const char *dirname) >>> { >>> int ret; >>> - >>> switch (fs_type) { >>> case FS_TYPE_FAT: >>> ret = fs_ls_fat(dirname); >> Unrelated, please drop. >> >>> @@ -237,11 +311,13 @@ int fs_read(const char *filename, ulong addr, int offset, int len) >>> case FS_TYPE_EXT: >>> ret = fs_read_ext(filename, addr, offset, len); >>> break; >>> + case FS_TYPE_BTR: >>> + ret = fs_read_btr(filename, addr, offset, len); >>> + break; >>> default: >>> ret = fs_read_unsupported(filename, addr, offset, len); >>> break; >>> } >>> - >>> fs_close(); >> And unrelated whitespace changes here as well. >> >>> diff --git a/include/btrfs.h b/include/btrfs.h >> [snip] >>> +/* >>> + * Extent structure: contains the mapping of some chunk of a file >>> + * that is contiguous on disk. >>> + */ >>> +struct extent { >>> + //sector_t pstart; /* Physical start sector */ >>> + __le64 pstart; >> Fix please. >> >>> +/* >>> + * Our definition of "not whitespace" >>> + */ >>> +static inline char not_whitespace(char c) >>> +{ >>> + return (unsigned char)c > ' '; >>> +} >> Can't you just use isspace from <linux/ctypes.h> ? >> >>> diff --git a/include/crc32c.h b/include/crc32c.h >>> new file mode 100644 >>> index 0000000..d04916e >>> --- /dev/null >>> +++ b/include/crc32c.h >>> @@ -0,0 +1,48 @@ >>> +/* >>> + * Copied from Linux kernel crypto/crc32c.c >>> + * Copyright (c) 2004 Cisco Systems, Inc. >>> + * Copyright (c) 2008 Herbert Xu <herbert@gondor.apana.org.au> >>> + * >>> + * This program is free software; you can redistribute it and/or modify it >>> + * under the terms of the GNU General Public License as published by the Free >>> + * Software Foundation; either version 2 of the License, or (at your option) >>> + * any later version. >>> + * >>> + */ >>> + >>> +/* >>> + * This is the CRC-32C table >>> + * Generated with: >>> + * width = 32 bits >>> + * poly = 0x1EDC6F41 >>> + * reflect input bytes = true >>> + * reflect output bytes = true >>> + */ >>> + >>> +/* >>> + * Steps through buffer one byte at at time, calculates reflected >>> + * crc using table. >>> + */ >>> + >>> +static inline u32 crc32c_cal(u32 crc, const char *data, size_t length, u32 *crc32c_table) >>> +{ >>> + while (length--) >>> + crc = crc32c_table[(u8)(crc ^ *data++)] ^ (crc >> 8); >>> + >>> + return crc; >>> +} >>> + >>> +static inline void crc32c_init(u32 *crc32c_table, u32 pol) >>> +{ >>> + int i, j; >>> + u32 v; >>> + const u32 poly = pol; /* Bit-reflected CRC32C polynomial */ >>> + >>> + for (i = 0; i < 256; i++) { >>> + v = i; >>> + for (j = 0; j < 8; j++) { >>> + v = (v >> 1) ^ ((v & 1) ? poly : 0); >>> + } >>> + crc32c_table[i] = v; >>> + } >>> +} >> Simon, since you've just been over all the crc32 recently, do we have >> these functions somewhere already that can be easily tapped in to? >> Thanks! > Should be - see lib/crc32.c. There is already at least one other copy > (ubifs I think) so we should try to avoid adding more. > > Maybe the polynomial is different here? But even so it should go with > the existing code I think. I have tried using crc code lib/crc32.c but it always failed even though i did change the polynomial but still result is search for file on btrfs fails due to bad crc calculation. I have also enable dynamic table creation but still result is same. so should add my my crc code under ifdef in lib/crc32.c what do you suggest? > Regards, > Simon > > >> -- >> Tom ^ permalink raw reply [flat|nested] 16+ messages in thread
* [U-Boot] [PATCH v3] Introduced btrfs file-system with btrload command 2013-02-26 12:54 ` Adnan Ali @ 2013-02-26 16:19 ` Simon Glass 0 siblings, 0 replies; 16+ messages in thread From: Simon Glass @ 2013-02-26 16:19 UTC (permalink / raw) To: u-boot Hi Adnan, On Tue, Feb 26, 2013 at 4:54 AM, Adnan Ali <adnan.ali@codethink.co.uk> wrote: > On 25/02/13 23:02, Simon Glass wrote: >> >> Hi, >> >> On Mon, Feb 25, 2013 at 7:04 AM, Tom Rini <trini@ti.com> wrote: >>> >>> On Mon, Feb 25, 2013 at 12:24:37PM +0000, Adnan Ali wrote: >>> >>>> Introduces btrfs file-system to read file >>>> from volume/sub-volumes with btrload command. This >>>> implementation has read-only support. >>>> This btrfs implementation is based on syslinux btrfs >>>> code, commit 269ebc845ebc8b46ef4b0be7fa0005c7fdb95b8d. >>>> >>>> Signed-off-by: Adnan Ali <adnan.ali@codethink.co.uk> >>> >>> A few things: >>> - In general in fs/btrfs/btrfs.c I see some coding style problems (lack >>> of spacing, non-printf's longer than 80-wide). Do these come from >>> syslinux and thus will make any re-syncs easier? >>> - It looks like you added support for CONFIG_CMD_FS_GENERIC, if so did >>> you test that? >>> - Can you please enable this support code on at least one platform, >>> preferably the one you've tested and developed with? >>> >>> [snip] >>>> >>>> diff --git a/fs/fs.c b/fs/fs.c >>> >>> [snip] >>>> >>>> + //file handle is valid get the size of the file >>> >>> /* Style comments only */ >>> >>>> + len=filedata.size; >>> >>> And spacing between variable and assignment. >>> >>>> @@ -178,7 +248,6 @@ int fs_set_blk_dev(const char *ifname, const char >>>> *dev_part_str, int fstype) >>>> for (i = 0; i < ARRAY_SIZE(fstypes); i++) { >>>> if ((fstype != FS_TYPE_ANY) && (fstype != >>>> fstypes[i].fstype)) >>>> continue; >>>> - >>>> if (!fstypes[i].probe()) { >>>> fs_type = fstypes[i].fstype; >>>> return 0; >>> >>> [snip] >>>> >>>> @@ -208,7 +280,6 @@ static void fs_close(void) >>>> int fs_ls(const char *dirname) >>>> { >>>> int ret; >>>> - >>>> switch (fs_type) { >>>> case FS_TYPE_FAT: >>>> ret = fs_ls_fat(dirname); >>> >>> Unrelated, please drop. >>> >>>> @@ -237,11 +311,13 @@ int fs_read(const char *filename, ulong addr, int >>>> offset, int len) >>>> case FS_TYPE_EXT: >>>> ret = fs_read_ext(filename, addr, offset, len); >>>> break; >>>> + case FS_TYPE_BTR: >>>> + ret = fs_read_btr(filename, addr, offset, len); >>>> + break; >>>> default: >>>> ret = fs_read_unsupported(filename, addr, offset, len); >>>> break; >>>> } >>>> - >>>> fs_close(); >>> >>> And unrelated whitespace changes here as well. >>> >>>> diff --git a/include/btrfs.h b/include/btrfs.h >>> >>> [snip] >>>> >>>> +/* >>>> + * Extent structure: contains the mapping of some chunk of a file >>>> + * that is contiguous on disk. >>>> + */ >>>> +struct extent { >>>> + //sector_t pstart; /* Physical start sector */ >>>> + __le64 pstart; >>> >>> Fix please. >>> >>>> +/* >>>> + * Our definition of "not whitespace" >>>> + */ >>>> +static inline char not_whitespace(char c) >>>> +{ >>>> + return (unsigned char)c > ' '; >>>> +} >>> >>> Can't you just use isspace from <linux/ctypes.h> ? >>> >>>> diff --git a/include/crc32c.h b/include/crc32c.h >>>> new file mode 100644 >>>> index 0000000..d04916e >>>> --- /dev/null >>>> +++ b/include/crc32c.h >>>> @@ -0,0 +1,48 @@ >>>> +/* >>>> + * Copied from Linux kernel crypto/crc32c.c >>>> + * Copyright (c) 2004 Cisco Systems, Inc. >>>> + * Copyright (c) 2008 Herbert Xu <herbert@gondor.apana.org.au> >>>> + * >>>> + * This program is free software; you can redistribute it and/or modify >>>> it >>>> + * under the terms of the GNU General Public License as published by >>>> the Free >>>> + * Software Foundation; either version 2 of the License, or (at your >>>> option) >>>> + * any later version. >>>> + * >>>> + */ >>>> + >>>> +/* >>>> + * This is the CRC-32C table >>>> + * Generated with: >>>> + * width = 32 bits >>>> + * poly = 0x1EDC6F41 >>>> + * reflect input bytes = true >>>> + * reflect output bytes = true >>>> + */ >>>> + >>>> +/* >>>> + * Steps through buffer one byte at at time, calculates reflected >>>> + * crc using table. >>>> + */ >>>> + >>>> +static inline u32 crc32c_cal(u32 crc, const char *data, size_t length, >>>> u32 *crc32c_table) >>>> +{ >>>> + while (length--) >>>> + crc = crc32c_table[(u8)(crc ^ *data++)] ^ (crc >> 8); >>>> + >>>> + return crc; >>>> +} >>>> + >>>> +static inline void crc32c_init(u32 *crc32c_table, u32 pol) >>>> +{ >>>> + int i, j; >>>> + u32 v; >>>> + const u32 poly = pol; /* Bit-reflected CRC32C polynomial */ >>>> + >>>> + for (i = 0; i < 256; i++) { >>>> + v = i; >>>> + for (j = 0; j < 8; j++) { >>>> + v = (v >> 1) ^ ((v & 1) ? poly : 0); >>>> + } >>>> + crc32c_table[i] = v; >>>> + } >>>> +} >>> >>> Simon, since you've just been over all the crc32 recently, do we have >>> these functions somewhere already that can be easily tapped in to? >>> Thanks! >> >> Should be - see lib/crc32.c. There is already at least one other copy >> (ubifs I think) so we should try to avoid adding more. >> >> Maybe the polynomial is different here? But even so it should go with >> the existing code I think. > > I have tried using crc code lib/crc32.c but it always failed even > though i did change the polynomial but still result is search for file > on btrfs fails due to bad crc calculation. I have also enable dynamic > table creation but still result is same. so should add my my crc code > under ifdef in lib/crc32.c what do you suggest? I suggest you pull the two functions out and try to see what is different. You might need to define DYNAMIC_CRC_TABLE if the polynomial has changed. 'sandbox' might help here (make sandbox_config) since you can build and run on your linux box. If you have changed the polynomial and it still doesn't work then something is wrong... I think adding the code to lib/crc32 with a new CONFIG is OK - but probably better if you put it in a new file like crc32_c.c or similar. Hopefully there is some common element to the algorithms? Regards, Simon >> >> Regards, >> Simon >> >> >>> -- >>> Tom > > ^ permalink raw reply [flat|nested] 16+ messages in thread
* [U-Boot] [PATCH v3] Introduced btrfs file-system with btrload command 2013-02-25 12:24 ` [U-Boot] [PATCH v3] Introduced btrfs file-system with btrload command Adnan Ali 2013-02-25 15:04 ` Tom Rini @ 2013-03-01 22:53 ` Wolfgang Denk 2013-03-01 22:56 ` Tom Rini 1 sibling, 1 reply; 16+ messages in thread From: Wolfgang Denk @ 2013-03-01 22:53 UTC (permalink / raw) To: u-boot Dear Adnan Ali, In message <1361795077-3674-2-git-send-email-adnan.ali@codethink.co.uk> you wrote: > Introduces btrfs file-system to read file > from volume/sub-volumes with btrload command. This > implementation has read-only support. > This btrfs implementation is based on syslinux btrfs > code, commit 269ebc845ebc8b46ef4b0be7fa0005c7fdb95b8d. > > Signed-off-by: Adnan Ali <adnan.ali@codethink.co.uk> Checkpatch says: total: 410 errors, 527 warnings, 1849 lines checked Can you fix these, please? Also, you say this is patch version 3, but I see no history of changes anywhere. Please read http://www.denx.de/wiki/view/U-Boot/Patches#Sending_updated_patch_versions Best regards, Wolfgang Denk -- DENX Software Engineering GmbH, MD: Wolfgang Denk & Detlev Zundel HRB 165235 Munich, Office: Kirchenstr.5, D-82194 Groebenzell, Germany Phone: (+49)-8142-66989-10 Fax: (+49)-8142-66989-80 Email: wd at denx.de Let's say the docs present a simplified view of reality... :-) - Larry Wall in <6940@jpl-devvax.JPL.NASA.GOV> ^ permalink raw reply [flat|nested] 16+ messages in thread
* [U-Boot] [PATCH v3] Introduced btrfs file-system with btrload command 2013-03-01 22:53 ` Wolfgang Denk @ 2013-03-01 22:56 ` Tom Rini 2013-03-01 23:06 ` Wolfgang Denk 0 siblings, 1 reply; 16+ messages in thread From: Tom Rini @ 2013-03-01 22:56 UTC (permalink / raw) To: u-boot -----BEGIN PGP SIGNED MESSAGE----- Hash: SHA1 On 03/01/2013 05:53 PM, Wolfgang Denk wrote: > Dear Adnan Ali, > > In message > <1361795077-3674-2-git-send-email-adnan.ali@codethink.co.uk> you > wrote: >> Introduces btrfs file-system to read file from volume/sub-volumes >> with btrload command. This implementation has read-only support. >> This btrfs implementation is based on syslinux btrfs code, commit >> 269ebc845ebc8b46ef4b0be7fa0005c7fdb95b8d. >> >> Signed-off-by: Adnan Ali <adnan.ali@codethink.co.uk> > > Checkpatch says: > > total: 410 errors, 527 warnings, 1849 lines checked > > > Can you fix these, please? Some number of these are following upstream errors which we should take so future resyncs aren't as painful. - -- Tom -----BEGIN PGP SIGNATURE----- Version: GnuPG v1.4.11 (GNU/Linux) Comment: Using GnuPG with Thunderbird - http://www.enigmail.net/ iQIcBAEBAgAGBQJRMTI1AAoJENk4IS6UOR1WKtAQAJoMEuQM3HL3amkzbZfWA8TD wRr0bWMdWPUgzp+DqVggubYdKe7Yj3hrjlw+aXrjmFJmJNuO+vub+jAhMBOasMOG SU0A5rxjIebRwcGzwZcdCHZ0wc5960uJs/ZJa13D8TPUUlG30lL8dUVVpkrfiLnX frrGhraaL2xBaf3PXiZaFrQ1bicDrMIwwPdGadUl3h5/xmukFvmuteQZgMk4c/Sv 8R4r7G1zD+wmbIOY49GUCuetfncy4mQhtaUIXbicMUs7+RLEyA9PieknxxHbKx70 fm9utmQyzXyU/lE/cpxOpz112TzuQPFn+qanr6PzTBYsd46YqaJpw7CVO6u1xv31 KzBslg8/SSZmGEbGrkgrXPO0Ey/T3Gw9tfOaWM/2SPEumBsS1KDQWuo2yPH1LiZs O/b3VbjBiUTWvc/Djlov/9ebVzi1kTbqd8I0HSKC8qF2FwqmKU4O9qxHC2Gr9ioX 0E6rOA4w7OXN0wsfn3X7woq+l05dtT9ZOlFyNEm9BVhmeytge3RSWrvMkj6Ll+pv WF4hS6GW/xwY1Wttg2RHoNAGpkKa8pnk9BC0g3XTYyXdP7Qgb66wjoTfIK5TuXOB pKYMwiPb3b2XG3qY+zraXpS+dXed3/BD9rAbpov4YHrPDEnOAYIa+sQVgA6UZsod mJkTQrcYujpB5RFfHgh2 =RQIq -----END PGP SIGNATURE----- ^ permalink raw reply [flat|nested] 16+ messages in thread
* [U-Boot] [PATCH v3] Introduced btrfs file-system with btrload command 2013-03-01 22:56 ` Tom Rini @ 2013-03-01 23:06 ` Wolfgang Denk 2013-03-01 23:11 ` Tom Rini 0 siblings, 1 reply; 16+ messages in thread From: Wolfgang Denk @ 2013-03-01 23:06 UTC (permalink / raw) To: u-boot Dear Tom, In message <51313235.8080409@ti.com> you wrote: > > > Can you fix these, please? > > Some number of these are following upstream errors which we should > take so future resyncs aren't as painful. Maybe - but then this should be explained in the patch, at least. Best regards, Wolfgang Denk -- DENX Software Engineering GmbH, MD: Wolfgang Denk & Detlev Zundel HRB 165235 Munich, Office: Kirchenstr.5, D-82194 Groebenzell, Germany Phone: (+49)-8142-66989-10 Fax: (+49)-8142-66989-80 Email: wd at denx.de Doubt is a pain too lonely to know that faith is his twin brother. - Kahlil Gibran ^ permalink raw reply [flat|nested] 16+ messages in thread
* [U-Boot] [PATCH v3] Introduced btrfs file-system with btrload command 2013-03-01 23:06 ` Wolfgang Denk @ 2013-03-01 23:11 ` Tom Rini 0 siblings, 0 replies; 16+ messages in thread From: Tom Rini @ 2013-03-01 23:11 UTC (permalink / raw) To: u-boot -----BEGIN PGP SIGNED MESSAGE----- Hash: SHA1 On 03/01/2013 06:06 PM, Wolfgang Denk wrote: > Dear Tom, > > In message <51313235.8080409@ti.com> you wrote: >> >>> Can you fix these, please? >> >> Some number of these are following upstream errors which we >> should take so future resyncs aren't as painful. > > Maybe - but then this should be explained in the patch, at least. Agreed. - -- Tom -----BEGIN PGP SIGNATURE----- Version: GnuPG v1.4.11 (GNU/Linux) Comment: Using GnuPG with Thunderbird - http://www.enigmail.net/ iQIcBAEBAgAGBQJRMTWXAAoJENk4IS6UOR1WJ7EP/A8WCfiwQ6jpyvv39rJ8xp6h grJ7TNsCMApIMD5geor3ttifOw6omo2uOEPslvwqsBGkSrwMpeDTmpe75pWvb/AS iTStKIGiPeWJh09V5yyaT98WY8p3QCMrKjGPACOQX9LK/LgYuvtE2K5L+s6CZKXE S0WsHwslGlqjVia6Z0KCInLIiKmNLgC70Zyd9ASinGLWedhsSm6UE3l2rNxZKvXU H9D/PyDewlkLerFA6mcFAA5H+YQMBOHIjVpf3x7k/QYUHfQwU4LOls3Wn9Mn21sO ksOXnOCjYXv8jEhyZQSuW4CerBBwl210WeclDpMRLRaCzp3ayCyoR9shxqYoOOR+ f40mfrfkgmd9GYunorSC1KZ6TYlaRm3k//okk0ELRt0HjlcX3pvrRBJosmJW0Rcv pu3f268wc9lusTnJTcQ+XSLraxb21SzjHCeAoJd0EUwVirnrC6i0o7Na10VVFE56 h631W5kiyNYMevsCvZ282Eb+EFB8GAMkoroI8A2JHVjvh79c53D5WPRPQ1Sg8Fjs mG58gA17TGQgNFWM438vuppRKHqhumMQtjuzY8pAR9yweR3/KKjFD+/EUeVNd0qS NG9QW4WzaNkrMAuUIYFuSQy3Qth/nW0nk8IQplHCousNSRpWFMOwEU8tr0miQIsU EOL0UYD1QTdl4E6OLHOC =JR43 -----END PGP SIGNATURE----- ^ permalink raw reply [flat|nested] 16+ messages in thread
* [U-Boot] [PATCH v3] btrfs addition to uboot @ 2013-02-15 12:10 Adnan Ali 2013-02-15 12:10 ` [U-Boot] [PATCH v3] Introduced btrfs file-system with btrload command Adnan Ali 0 siblings, 1 reply; 16+ messages in thread From: Adnan Ali @ 2013-02-15 12:10 UTC (permalink / raw) To: u-boot Adnan Ali (1): Introduced btrfs file-system with btrload command Makefile | 1 + common/Makefile | 1 + common/cmd_btr.c | 53 +++ fs/btrfs/Makefile | 51 ++ fs/btrfs/btrfs.c | 1131 ++++++++++++++++++++++++++++++++++++++++++++ fs/fs.c | 86 +++- include/btrfs.h | 398 ++++++++++++++++ include/config_fallbacks.h | 4 + include/crc32c.h | 48 ++ include/fs.h | 1 + 10 files changed, 1769 insertions(+), 5 deletions(-) create mode 100644 common/cmd_btr.c create mode 100644 fs/btrfs/Makefile create mode 100644 fs/btrfs/btrfs.c create mode 100644 include/btrfs.h create mode 100644 include/crc32c.h -- 1.7.9.5 ^ permalink raw reply [flat|nested] 16+ messages in thread
* [U-Boot] [PATCH v3] Introduced btrfs file-system with btrload command 2013-02-15 12:10 [U-Boot] [PATCH v3] btrfs addition to uboot Adnan Ali @ 2013-02-15 12:10 ` Adnan Ali 0 siblings, 0 replies; 16+ messages in thread From: Adnan Ali @ 2013-02-15 12:10 UTC (permalink / raw) To: u-boot Introduces btrfs file-system to read file from volume/sub-volumes with btrload command. This implementation has read-only support. This btrfs implementation is based on syslinux btrfs code, commit 269ebc845ebc8b46ef4b0be7fa0005c7fdb95b8d. Signed-off-by: Adnan Ali <adnan.ali@codethink.co.uk> --- Makefile | 1 + common/Makefile | 1 + common/cmd_btr.c | 53 +++ fs/btrfs/Makefile | 51 ++ fs/btrfs/btrfs.c | 1131 ++++++++++++++++++++++++++++++++++++++++++++ fs/fs.c | 86 +++- include/btrfs.h | 398 ++++++++++++++++ include/config_fallbacks.h | 4 + include/crc32c.h | 48 ++ include/fs.h | 1 + 10 files changed, 1769 insertions(+), 5 deletions(-) create mode 100644 common/cmd_btr.c create mode 100644 fs/btrfs/Makefile create mode 100644 fs/btrfs/btrfs.c create mode 100644 include/btrfs.h create mode 100644 include/crc32c.h diff --git a/Makefile b/Makefile index 3305e8c..cc35e7b 100644 --- a/Makefile +++ b/Makefile @@ -261,6 +261,7 @@ endif LIBS-$(CONFIG_OF_EMBED) += dts/libdts.o LIBS-y += arch/$(ARCH)/lib/lib$(ARCH).o LIBS-y += fs/libfs.o \ + fs/btrfs/libbtrfs.o \ fs/cbfs/libcbfs.o \ fs/cramfs/libcramfs.o \ fs/ext4/libext4fs.o \ diff --git a/common/Makefile b/common/Makefile index 54fcc81..093dd35 100644 --- a/common/Makefile +++ b/common/Makefile @@ -73,6 +73,7 @@ COBJS-$(CONFIG_CMD_BEDBUG) += bedbug.o cmd_bedbug.o COBJS-$(CONFIG_CMD_BMP) += cmd_bmp.o COBJS-$(CONFIG_CMD_BOOTLDR) += cmd_bootldr.o COBJS-$(CONFIG_CMD_BOOTSTAGE) += cmd_bootstage.o +COBJS-$(CONFIG_CMD_BTR) += cmd_btr.o COBJS-$(CONFIG_CMD_CACHE) += cmd_cache.o COBJS-$(CONFIG_CMD_CBFS) += cmd_cbfs.o COBJS-$(CONFIG_CMD_CONSOLE) += cmd_console.o diff --git a/common/cmd_btr.c b/common/cmd_btr.c new file mode 100644 index 0000000..faea625 --- /dev/null +++ b/common/cmd_btr.c @@ -0,0 +1,53 @@ +/* + * (C) Copyright 2013 Codethink Limited + * Btrfs port to Uboot by + * Adnan Ali <adnan.ali@codethink.co.uk> + * See file CREDITS for list of people who contributed to this + * project. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation; either version 2 of + * the License, or (at your option) any later version. + * + * 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 02111-1307 USA + */ + +/* + * Boot support + */ +#include <fs.h> +#include <btrfs.h> + +char subvolname[MAX_SUBVOL_NAME]; + +int do_btr_fsload(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) +{ + if (argc > 5) + strcpy(subvolname, argv[5]); + else + strcpy(subvolname, ""); + + return do_load(cmdtp, flag, argc, argv, FS_TYPE_BTR, 16); +} + + +U_BOOT_CMD( + btrload, 7, 0, do_btr_fsload, + "load binary file from a btr filesystem", + "<interface> [<dev[:part]>] <addr> <filename> [subvol_name]\n" + " - Load binary file 'filename' from 'dev' on 'interface'\n" + " to address 'addr' from better filesystem.\n" + " the load stops on end of file.\n" + " subvol_name is used read that file from this subvolume.\n" + " All numeric parameters are assumed to be hex." +); + diff --git a/fs/btrfs/Makefile b/fs/btrfs/Makefile new file mode 100644 index 0000000..a9e2021 --- /dev/null +++ b/fs/btrfs/Makefile @@ -0,0 +1,51 @@ +# +# (C) Copyright 2006 +# Wolfgang Denk, DENX Software Engineering, wd at denx.de. +# +# (C) Copyright 2003 +# Pavel Bartusek, Sysgo Real-Time Solutions AG, pba at sysgo.de +# +# +# See file CREDITS for list of people who contributed to this +# project. +# +# This program is free software; you can redistribute it and/or +# modify it under the terms of the GNU General Public License as +# published by the Free Software Foundation; either version 2 of +# the License, or (at your option) any later version. +# +# 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 02111-1307 USA +# + +include $(TOPDIR)/config.mk + +LIB = $(obj)libbtrfs.o + +AOBJS = +COBJS-$(CONFIG_FS_BTR) := btrfs.o + +SRCS := $(AOBJS:.o=.S) $(COBJS-y:.o=.c) +OBJS := $(addprefix $(obj),$(AOBJS) $(COBJS-y)) + + +all: $(LIB) $(AOBJS) + +$(LIB): $(obj).depend $(OBJS) + $(call cmd_link_o_target, $(OBJS)) + +######################################################################### + +# defines $(obj).depend target +include $(SRCTREE)/rules.mk + +sinclude $(obj).depend + +######################################################################### diff --git a/fs/btrfs/btrfs.c b/fs/btrfs/btrfs.c new file mode 100644 index 0000000..9568042 --- /dev/null +++ b/fs/btrfs/btrfs.c @@ -0,0 +1,1131 @@ +/* + * (C) Copyright 2013 Codethink Limited + * Btrfs port to Uboot by + * Adnan Ali <adnan.ali@codethink.co.uk> + + * btrfs.c -- readonly btrfs support for syslinux + * Some data structures are derivated from btrfs-tools-0.19 ctree.h + * Copyright 2009 Intel Corporation; author: alek.du at intel.com + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, Inc., 53 Temple Place Ste 330, + * Boston MA 02111-1307, USA; either version 2 of the License, or + * (at your option) any later version; incorporated herein by reference. + * + */ + +#include <linux/stat.h> +#include <command.h> +#include <asm/byteorder.h> +#include <linux/compiler.h> +#include <common.h> +#include <config.h> +#include <fs.h> +#include <btrfs.h> + +unsigned long btr_part_offset; +/* Actual file structures (we don't have malloc yet...) */ +struct file files[MAX_OPEN]; +static u32 btrfs_crc32_table[256]; +static block_dev_desc_t *btrfs_block_dev_desc; +static disk_partition_t *part_info; +struct inode parent_inode; +extern char subvolname[MAX_SUBVOL_NAME]; + +static void btrfs_init_crc32c(void) +{ + /* Bit-reflected CRC32C polynomial */ + crc32c_init(btrfs_crc32_table, 0x82F63B78); +} + +static inline u32 crc32c_le(u32 crc, const char *data, size_t length) +{ + return crc32c_cal(crc, data, length, btrfs_crc32_table); +} + +void btrfs_set_blk_dev(block_dev_desc_t *rbdd, disk_partition_t *info) +{ + btrfs_block_dev_desc = rbdd; + part_info = info; + btr_part_offset = info->start; +} + + +/* compare function used for bin_search */ +typedef int (*cmp_func)(void *ptr1, void *ptr2); + +static int bin_search(void *ptr, int item_size, void *cmp_item, cmp_func func, + int min, int max, int *slot) +{ + int low = min; + int high = max; + int mid; + int ret; + unsigned long offset; + void *item; + + while (low < high) { + mid = (low + high) / 2; + offset = mid * item_size; + + item = ptr + offset; + ret = func(item, cmp_item); + + if (ret < 0) + low = mid + 1; + else if (ret > 0) + high = mid; + else { + *slot = mid; + return 0; + } + } + *slot = low; + return 1; +} + +/* XXX: these should go into the filesystem instance structure */ +static struct btrfs_chunk_map chunk_map; +static struct btrfs_super_block sb; +static u64 fs_tree; + +static int btrfs_comp_chunk_map(struct btrfs_chunk_map_item *m1, + struct btrfs_chunk_map_item *m2) +{ + if (__le64_to_cpu(m1->logical) > __le64_to_cpu(m2->logical)) + return 1; + if (__le64_to_cpu(m1->logical) < __le64_to_cpu(m2->logical)) + return -1; + return 0; +} + +/* insert a new chunk mapping item */ +static void insert_map(struct btrfs_chunk_map_item *item) +{ + int ret; + int slot; + int i; + + if (chunk_map.map == NULL) { /* first item */ + chunk_map.map_length = BTRFS_MAX_CHUNK_ENTRIES; + chunk_map.map = (struct btrfs_chunk_map_item *) + malloc(chunk_map.map_length * sizeof(*chunk_map.map)); + chunk_map.map[0] = *item; + chunk_map.cur_length = 1; + return; + } + ret = bin_search(chunk_map.map, sizeof(*item), item, + (cmp_func)btrfs_comp_chunk_map, 0, + chunk_map.cur_length, &slot); + if (ret == 0)/* already in map */ + return; + if (chunk_map.cur_length == BTRFS_MAX_CHUNK_ENTRIES) { + /* should be impossible */ + printf("too many chunk items\n"); + return; + } + for (i = chunk_map.cur_length; i > slot; i--) + chunk_map.map[i] = chunk_map.map[i-1]; + chunk_map.map[slot] = *item; + chunk_map.cur_length++; +} + +/* + * from sys_chunk_array or chunk_tree, we can convert a logical address to + * a physical address we can not support multi device case yet + */ +static u64 logical_physical(u64 logical) +{ + struct btrfs_chunk_map_item item; + int slot, ret; + + item.logical = logical; + ret = bin_search(chunk_map.map, sizeof(*chunk_map.map), &item, + (cmp_func)btrfs_comp_chunk_map, 0, + chunk_map.cur_length, &slot); + if (ret == 0) + slot++; + else if (slot == 0) + return -1; + if (logical >= + chunk_map.map[slot-1].logical + chunk_map.map[slot-1].length) + return -1; + return chunk_map.map[slot-1].physical + logical - + chunk_map.map[slot-1].logical; +} + +int btrfs_devread(int sector, int byte_offset, int byte_len, char* buf) +{ + ALLOC_CACHE_ALIGN_BUFFER(char, sec_buf, SECTOR_SIZE); + unsigned block_len; + + /* Get the read to the beginning of a partition */ + sector += byte_offset >> SECTOR_BITS; + byte_offset &= SECTOR_SIZE - 1; + + if (btrfs_block_dev_desc == NULL) { + printf("** Invalid Block Device Descriptor (NULL)\n"); + return 0; + } + if (byte_offset != 0) { + /* read first part which isn't aligned with start of sector */ + if (btrfs_block_dev_desc-> + block_read(btrfs_block_dev_desc->dev, + part_info->start + sector, 1, + (unsigned long *) sec_buf) != 1) { + printf(" ** btrfs_devread() read error **\n"); + return 0; + } + memcpy(buf, sec_buf + byte_offset, + min(SECTOR_SIZE - byte_offset, byte_len)); + buf += min(SECTOR_SIZE - byte_offset, byte_len); + byte_len -= min(SECTOR_SIZE - byte_offset, byte_len); + sector++; + } + /* read sector aligned part */ + + block_len = byte_len & ~(SECTOR_SIZE - 1); + + if (block_len == 0) { + ALLOC_CACHE_ALIGN_BUFFER(u8, p, SECTOR_SIZE); + + block_len = SECTOR_SIZE; + btrfs_block_dev_desc->block_read(btrfs_block_dev_desc->dev, + part_info->start + sector, + 1, (unsigned long *)p); + memcpy(buf, p, byte_len); + return 1; + } + ALLOC_CACHE_ALIGN_BUFFER(u8, t, block_len); + if (btrfs_block_dev_desc->block_read(btrfs_block_dev_desc->dev, + part_info->start + sector, + block_len / SECTOR_SIZE, + (unsigned long *) t) != + block_len / SECTOR_SIZE) { + printf(" ** %s read error - block\n", __func__); + return 0; + } + + memcpy(buf, t, block_len); + block_len = byte_len & ~(SECTOR_SIZE - 1); + buf += block_len; + byte_len -= block_len; + sector += block_len / SECTOR_SIZE; + if (byte_len != 0) { + /* read rest of data which are not in whole sector */ + if (btrfs_block_dev_desc-> + block_read(btrfs_block_dev_desc->dev, + part_info->start + sector, 1, + (unsigned long *) sec_buf) != 1) { + printf("* %s read error - last part\n", __func__); + return 0; + } + memcpy(buf, sec_buf, byte_len); + } + + + return 1; +} +/* btrfs has several super block mirrors, need to calculate their location */ +static inline u64 btrfs_sb_offset(int mirror) +{ + u64 start = 16 * 1024; + if (mirror) + return start << (BTRFS_SUPER_MIRROR_SHIFT * mirror); + return BTRFS_SUPER_INFO_OFFSET; +} + +/* find the most recent super block */ +static int btrfs_read_super_block(struct fs_info *fs) +{ + int i; + int ret; + u8 fsid[BTRFS_FSID_SIZE]; + u8 boots[512]; + u64 offset; + u64 transid = 0; + struct btrfs_super_block buf; + + sb.total_bytes = ~0; /* Unknown as of yet */ + + /*Only first header is checked for filesystem verification + mirror of this header can be used if required*/ + offset = btrfs_sb_offset(0); + + if ( btrfs_devread(128, 0, sizeof(struct btrfs_super_block), (char*)&buf)!=1) + return -1; + + + if (buf.bytenr != offset || + strncmp((char *)(&buf.magic), BTRFS_MAGIC, sizeof(buf.magic))) + { + return -1; + } + + if (i == 0) + memcpy(fsid, buf.fsid, sizeof(fsid)); + else if (memcmp(fsid, buf.fsid, sizeof(fsid))) + return -1; + + if (buf.generation > transid) { + memcpy(&sb, &buf, sizeof(sb)); + transid = buf.generation; + } + return 0; +} + +static inline unsigned long btrfs_chunk_item_size(int num_stripes) +{ + return sizeof(struct btrfs_chunk) + + sizeof(struct btrfs_stripe) * (num_stripes - 1); +} + +static void clear_path(struct btrfs_path *path) +{ + memset(path, 0, sizeof(*path)); +} + +static int btrfs_comp_keys(struct btrfs_disk_key *k1, struct btrfs_disk_key *k2) +{ + if (k1->objectid > k2->objectid) + return 1; + if (k1->objectid < k2->objectid) + return -1; + if (k1->type > k2->type) + return 1; + if (k1->type < k2->type) + return -1; + if (k1->offset > k2->offset) + return 1; + if (k1->offset < k2->offset) + return -1; + return 0; +} + +/* compare keys but ignore offset, is useful to enumerate all same kind keys */ +static int btrfs_comp_keys_type(struct btrfs_disk_key *k1, + struct btrfs_disk_key *k2) +{ + if (k1->objectid > k2->objectid) + return 1; + if (k1->objectid < k2->objectid) + return -1; + if (k1->type > k2->type) + return 1; + if (k1->type < k2->type) + return -1; + return 0; +} + +/* seach tree directly on disk ... */ +static int search_tree(struct fs_info *fs, u64 loffset, + struct btrfs_disk_key *key, struct btrfs_path *path) +{ + u8 buf[BTRFS_MAX_LEAF_SIZE]; + struct btrfs_header *header = (struct btrfs_header *)buf; + struct btrfs_node *node = (struct btrfs_node *)buf; + struct btrfs_leaf *leaf = (struct btrfs_leaf *)buf; + int slot, ret; + u64 offset; + + offset = logical_physical(loffset); + btrfs_devread(offset/SECTOR_SIZE, (offset%SECTOR_SIZE), sizeof(*header), (char*)header); + if (header->level) {/*node*/ + btrfs_devread(((offset+sizeof(*header))/SECTOR_SIZE),((offset+sizeof(*header))%SECTOR_SIZE) , + __le32_to_cpu(sb.nodesize) - sizeof(*header), (char *)&node->ptrs[0]); + path->itemsnr[header->level] = header->nritems; + path->offsets[header->level] = loffset; + ret = bin_search(&node->ptrs[0], sizeof(struct btrfs_key_ptr), + key, (cmp_func)btrfs_comp_keys, + path->slots[header->level], header->nritems, &slot); + if (ret && slot > path->slots[header->level]) + slot--; + path->slots[header->level] = slot; + ret = search_tree(fs, node->ptrs[slot].blockptr, key, path); + } else {/*leaf*/ + + btrfs_devread(((offset+sizeof(*header))/SECTOR_SIZE), ((offset+sizeof(*header))%SECTOR_SIZE), + (sb.leafsize) - sizeof(*header), (char *)&leaf->items); + path->itemsnr[header->level] = header->nritems; + path->offsets[0] = loffset; + ret = bin_search(&leaf->items[0], sizeof(struct btrfs_item), + key, (cmp_func)btrfs_comp_keys, path->slots[0], + header->nritems, &slot); + if (ret && slot > path->slots[header->level]) + slot--; + path->slots[0] = slot; + path->item = leaf->items[slot]; + btrfs_devread(((offset + sizeof(*header) + leaf->items[slot].offset)/SECTOR_SIZE), + ((offset + sizeof(*header) + leaf->items[slot].offset)%SECTOR_SIZE), + leaf->items[slot].size, (char*)&path->data); + } + return ret; +} + +/* return 0 if leaf found */ +static int next_leaf(struct fs_info *fs, struct btrfs_disk_key *key, struct btrfs_path *path) +{ + int slot; + int level = 1; + + while (level < BTRFS_MAX_LEVEL) { + if (!path->itemsnr[level]) /* no more nodes */ + return 1; + slot = path->slots[level] + 1; + if (slot >= path->itemsnr[level]) { + level++; + continue;; + } + path->slots[level] = slot; + path->slots[level-1] = 0; /* reset low level slots info */ + search_tree(fs, path->offsets[level], key, path); + break; + } + if (level == BTRFS_MAX_LEVEL) + return 1; + return 0; +} + +/* return 0 if slot found */ +static int next_slot(struct fs_info *fs, struct btrfs_disk_key *key, struct btrfs_path *path) +{ + int slot; + + if (!path->itemsnr[0]) + return 1; + slot = path->slots[0] + 1; + if (slot >= path->itemsnr[0]) + return 1; + path->slots[0] = slot; + search_tree(fs, path->offsets[0], key, path); + return 0; +} + +/* + * read chunk_array in super block + */ +static void btrfs_read_sys_chunk_array(void) +{ + struct btrfs_chunk_map_item item; + struct btrfs_disk_key *key; + struct btrfs_chunk *chunk; + int cur; + + /* read chunk array in superblock */ + cur = 0; + + while (cur < __le32_to_cpu(sb.sys_chunk_array_size)) { + key = (struct btrfs_disk_key *)(sb.sys_chunk_array + cur); + cur += sizeof(*key); + chunk = (struct btrfs_chunk *)(sb.sys_chunk_array + cur); + cur += btrfs_chunk_item_size(chunk->num_stripes); + /* insert to mapping table, ignore multi stripes */ + item.logical = key->offset; + item.length = chunk->length; + item.devid = chunk->stripe.devid; + item.physical = chunk->stripe.offset;/*ignore other stripes */ + + + insert_map(&item); + } +} + +/* read chunk items from chunk_tree and insert them to chunk map */ +static void btrfs_read_chunk_tree(struct fs_info *fs) +{ + struct btrfs_disk_key search_key; + struct btrfs_chunk *chunk; + struct btrfs_chunk_map_item item; + struct btrfs_path path; + int status; + + if (!(__le64_to_cpu(sb.flags) & BTRFS_SUPER_FLAG_METADUMP)) { + if (__le64_to_cpu(sb.num_devices) > 1) + { + printf("warning: only support one btrfs device %d\n", + __le64_to_cpu(sb.num_devices)); + return; + } + /* read chunk from chunk_tree */ + search_key.objectid = BTRFS_FIRST_CHUNK_TREE_OBJECTID; + search_key.type = BTRFS_CHUNK_ITEM_KEY; + search_key.offset = 0; + clear_path(&path); + search_tree(fs, (sb.chunk_root), &search_key, &path); + do { + do { + + if (status=btrfs_comp_keys_type(&search_key, + &path.item.key)) + break; + chunk = (struct btrfs_chunk *)(path.data); + /* insert to mapping table, ignore stripes */ + item.logical = path.item.key.offset; + item.length = chunk->length; + item.devid = chunk->stripe.devid; + item.physical = chunk->stripe.offset; + insert_map(&item); + } while (!next_slot(fs, &search_key, &path)); + if (btrfs_comp_keys_type(&search_key, &path.item.key)) + break; + } while (!next_leaf(fs, &search_key, &path)); + } +} + +static inline u64 btrfs_name_hash(const char *name, int len) +{ + return btrfs_crc32c((u32)~1, name, len); +} + +static struct inode *btrfs_iget_by_inr(struct fs_info *fs, u64 inr) +{ + struct inode *inode; + struct btrfs_inode_item inode_item; + struct btrfs_disk_key search_key; + struct btrfs_path path; + int ret; + + /* FIXME: some BTRFS inode member are u64, while our logical inode + is u32, we may need change them to u64 later */ + search_key.objectid = inr; + search_key.type = BTRFS_INODE_ITEM_KEY; + search_key.offset = 0; + clear_path(&path); + ret = search_tree(fs, fs_tree, &search_key, &path); + if (ret) + { + printf("%s search_tree failed\n", __func__); + return NULL; + } + + inode_item = *(struct btrfs_inode_item *)path.data; + if (!(inode = alloc_inode(fs, inr, sizeof(struct btrfs_pvt_inode)))) + { + printf("%s alloc_inode failed\n", __func__); + return NULL; + } + inode->ino = inr; + inode->size = inode_item.size; + inode->mode = IFTODT(inode_item.mode); + if (inode->mode == DT_REG || inode->mode == DT_LNK) { + struct btrfs_file_extent_item extent_item; + u64 offset; + + /* get file_extent_item */ + search_key.type = BTRFS_EXTENT_DATA_KEY; + search_key.offset = 0; + clear_path(&path); + ret = search_tree(fs, fs_tree, &search_key, &path); + if (ret) + return NULL; /* impossible */ + extent_item = *(struct btrfs_file_extent_item *)path.data; + if (extent_item.type == BTRFS_FILE_EXTENT_INLINE)/* inline file */ + offset = path.offsets[0] + sizeof(struct btrfs_header) + + path.item.offset + + offsetof(struct btrfs_file_extent_item, disk_bytenr); + else + offset = extent_item.disk_bytenr; + PVT(inode)->offset = offset; + } + return inode; +} + +static struct inode *btrfs_iget_root(struct fs_info *fs) +{ + /* BTRFS_FIRST_CHUNK_TREE_OBJECTID(256) actually is first OBJECTID for FS_TREE */ + return btrfs_iget_by_inr(fs, BTRFS_FIRST_CHUNK_TREE_OBJECTID); +} + +static struct inode *btrfs_iget(const char *name, struct inode *parent) +{ + struct fs_info *fs = parent->fs; + struct btrfs_disk_key search_key; + struct btrfs_path path; + struct btrfs_dir_item dir_item; + int ret; + + search_key.objectid = parent->ino; + search_key.type = BTRFS_DIR_ITEM_KEY; + search_key.offset = btrfs_name_hash(name, strlen(name)); + clear_path(&path); + ret = search_tree(fs, fs_tree, &search_key, &path); + if (ret) + return NULL; + dir_item = *(struct btrfs_dir_item *)path.data; + + return btrfs_iget_by_inr(fs, dir_item.location.objectid); +} + +static int btrfs_readlink(struct inode *inode, char *buf) +{ + btrfs_devread((logical_physical(PVT(inode)->offset)/SECTOR_SIZE), + (logical_physical(PVT(inode)->offset)%SECTOR_SIZE), inode->size, (char*)buf); + buf[inode->size] = '\0'; + return inode->size; +} + +static int btrfs_readdir(struct file *file, struct dirent *dirent) +{ + struct fs_info *fs = file->fs; + struct inode *inode = file->inode; + struct btrfs_disk_key search_key; + struct btrfs_path path; + struct btrfs_dir_item *dir_item; + int ret; + + /* + * we use file->offset to store last search key.offset, will will search + * key that lower that offset, 0 means first search and we will search + * -1UL, which is the biggest possible key + */ + search_key.objectid = inode->ino; + search_key.type = BTRFS_DIR_ITEM_KEY; + search_key.offset = file->offset - 1; + clear_path(&path); + ret = search_tree(fs, fs_tree, &search_key, &path); + + if (ret) { + if (btrfs_comp_keys_type(&search_key, &path.item.key)) + return -1; + } + + dir_item = (struct btrfs_dir_item *)path.data; + file->offset = path.item.key.offset; + dirent->d_ino = dir_item->location.objectid; + dirent->d_off = file->offset; + dirent->d_reclen = offsetof(struct dirent, d_name) + + dir_item->name_len + 1; + dirent->d_type = IFTODT(dir_item->type); + memcpy(dirent->d_name, dir_item + 1, dir_item->name_len); + dirent->d_name[dir_item->name_len] = '\0'; + + return 0; +} + +static int btrfs_next_extent(struct inode *inode, uint32_t lstart) +{ + struct btrfs_disk_key search_key; + struct btrfs_file_extent_item extent_item; + struct btrfs_path path; + int ret; + u64 offset; + struct fs_info *fs = inode->fs; + u32 sec_shift = SECTOR_BITS; + u32 sec_size = SECTOR_SIZE; + + search_key.objectid = inode->ino; + search_key.type = BTRFS_EXTENT_DATA_KEY; + search_key.offset = lstart << sec_shift; + clear_path(&path); + ret = search_tree(fs, fs_tree, &search_key, &path); + if (ret) { /* impossible */ + printf("btrfs: search extent data error\n"); + return -1; + } + extent_item = *(struct btrfs_file_extent_item *)path.data; + + if (extent_item.encryption) { + printf("btrfs: found encrypted data, cannot continue\n"); + return -1; + } + if (extent_item.compression) { + printf("btrfs: found compressed data, cannot continue\n"); + return -1; + } + + if (extent_item.type == BTRFS_FILE_EXTENT_INLINE) {/* inline file */ + /* we fake a extent here, and PVT of inode will tell us */ + offset = path.offsets[0] + sizeof(struct btrfs_header) + + path.item.offset + + offsetof(struct btrfs_file_extent_item, disk_bytenr); + inode->next_extent.len = + (inode->size + sec_size -1) >> sec_shift; + } else { + offset = extent_item.disk_bytenr + extent_item.offset; + inode->next_extent.len = + (extent_item.num_bytes + sec_size - 1) >> sec_shift; + } + inode->next_extent.pstart = + logical_physical(offset) >> sec_shift; + PVT(inode)->offset = offset; + return 0; +} + +static uint32_t btrfs_getfssec(struct file *file, char *buf, int sectors, + char *have_more) +{ + u32 ret; + struct fs_info *fs = file->fs; + u32 off = PVT(file->inode)->offset % SECTOR_SIZE; + char handle_inline = 0; + + if (off && !file->offset) {/* inline file first read patch */ + file->inode->size += off; + handle_inline = 1; + } + ret = generic_getfssec(file, buf, sectors, have_more); + if (!ret) + return ret; + off = PVT(file->inode)->offset % SECTOR_SIZE; + if (handle_inline) {/* inline file patch */ + ret -= off; + memcpy(buf, buf + off, ret); + } + return ret; +} + +static void btrfs_get_fs_tree(struct fs_info *fs) +{ + struct btrfs_disk_key search_key; + struct btrfs_path path; + struct btrfs_root_item *tree; + char subvol_ok = 0; + + /* check if subvol is filled by installer */ + if (*subvolname) { + search_key.objectid = BTRFS_FS_TREE_OBJECTID; + search_key.type = BTRFS_ROOT_REF_KEY; + search_key.offset = 0; + clear_path(&path); + if (search_tree(fs, __le64_to_cpu(sb.root), &search_key, &path)) + next_slot(fs, &search_key, &path); + do { + do { + struct btrfs_root_ref *ref; + int pathlen, status; + + if (status=btrfs_comp_keys_type(&search_key, + &path.item.key)) + break; + ref = (struct btrfs_root_ref *)path.data; + pathlen = path.item.size - sizeof(struct btrfs_root_ref); + printf("sub_vol found %s\n", (char*)(ref+1)); + if (!strncmp((char*)(ref + 1), subvolname, pathlen)) { + subvol_ok = 1; + break; + } + } while (!next_slot(fs, &search_key, &path)); + if (subvol_ok) + break; + if (btrfs_comp_keys_type(&search_key, &path.item.key)) + break; + } while (!next_leaf(fs, &search_key, &path)); + if (!subvol_ok) /* should be impossible */ + printf("no subvol found\n"); + } + /* find fs_tree from tree_root */ + if (subvol_ok) + search_key.objectid = path.item.key.offset; + else /* "default" volume */ + search_key.objectid = BTRFS_FS_TREE_OBJECTID; + search_key.type = BTRFS_ROOT_ITEM_KEY; + search_key.offset =-1; + clear_path(&path); + search_tree(fs, (sb.root), &search_key, &path); + tree = (struct btrfs_root_item *)path.data; + fs_tree = tree->bytenr; +} + +/* init. the fs meta data, return the block size shift bits. */ +int btrfs_fs_init(struct fs_info *fs) +{ + + btrfs_init_crc32c(); + btrfs_read_super_block(fs); + if (strncmp((char *)(&sb.magic), BTRFS_MAGIC, sizeof(sb.magic))) + return -1; + + btrfs_read_sys_chunk_array(); + btrfs_read_chunk_tree(fs); + btrfs_get_fs_tree(fs); + fs->root = btrfs_iget_root(fs); + parent_inode=*(fs->root); + + return 1; +} +static inline uint16_t file_to_handle(struct file *file) +{ + return file ? (file - files)+1 : 0; +} + +static inline struct file *handle_to_file(uint16_t handle) +{ + return handle ? &files[handle-1] : NULL; +} + +/* + * Free a refcounted inode + */ +void put_inode(struct inode *inode) +{ + while (inode && --inode->refcnt == 0) { + struct inode *dead = inode; + inode = inode->parent; + if (dead->name) + free((char *)dead->name); + free(dead); + } +} + +/* + * Get a new inode structure + */ +struct inode *alloc_inode(struct fs_info *fs, uint32_t ino, size_t data) +{ + struct inode *inode = malloc(sizeof(struct inode) + data); + if (inode) { + inode->fs = fs; + inode->ino = ino; + inode->refcnt = 1; + } + return inode; +} + +/* + * Get an empty file structure + */ +static struct file *alloc_file(void) +{ + int i; + struct file *file = files; + + for (i = 0; i < MAX_OPEN; i++) { + if (!file->fs) + return file; + file++; + } + + return NULL; +} + +/* + * Close and free a file structure + */ +static inline void free_file(struct file *file) +{ + memset(file, 0, sizeof *file); +} + +void generic_close_file(struct file *file) +{ + if (file->inode) { + file->offset = 0; + put_inode(file->inode); + } +} + +void _close_file(struct file *file) +{ + if (file->fs) + generic_close_file(file); + free_file(file); +} + +void btrfs_mangle_name(char *dst, const char *src) +{ + char *p = dst; + int i = FILENAME_MAX-1; + + while (not_whitespace(*src)) { + if (*src == '/') { + if (src[1] == '/') { + src++; + i--; + continue; + } + } + i--; + *dst++ = *src++; + } + while (1) { + if (dst == p) + break; + if (dst[-1] != '/') + break; + if ((dst[-1] == '/') && ((dst - 1) == p)) + break; + + dst--; + i++; + } + + i++; + for (; i > 0; i --) + *dst++ = '\0'; + +} +int btrfs_open_file(const char *name, struct com32_filedata *filedata) +{ + int rv; + struct file *file; + char mangled_name[FILENAME_MAX]; + + btrfs_mangle_name(mangled_name, name); + rv = searchdir(mangled_name); + if (rv < 0) + return rv; + + file = handle_to_file(rv); + filedata->size = file->inode->size; + filedata->handle = rv; + return rv; +} + +int searchdir(const char *name) +{ + struct inode *inode = NULL; + struct inode *parent = &parent_inode; + struct file *file; + char *pathbuf = NULL; + char *part, *p, echar; + int symlink_count = MAX_SYMLINK_CNT; + + if (!(file = alloc_file())) + goto err_no_close; + + p = pathbuf = strdup(name); + if (!pathbuf) + goto err; + + do { + got_link: + if (*p == '/') { + put_inode(parent); + parent = &parent_inode;// get_inode(this_fs->root); + } + + do { + inode = get_inode(parent); + + while (*p == '/') + p++; + + if (!*p) + break; + + part = p; + while ((echar = *p) && echar != '/') + p++; + *p++ = '\0'; + if (part[0] == '.' && part[1] == '.' && part[2] == '\0') { + if (inode->parent) { + put_inode(parent); + parent = get_inode(inode->parent); + put_inode(inode); + inode = NULL; + if (!echar) { + /* Terminal double dots */ + inode = parent; + parent = inode->parent ? + get_inode(inode->parent) : NULL; + } + } + } else if (part[0] != '.' || part[1] != '\0') { + inode = btrfs_iget(part, parent); + if (!inode) + goto err; + if (inode->mode == DT_LNK) { + char *linkbuf, *q; + int name_len = echar ? strlen(p) : 0; + int total_len = inode->size + name_len + 2; + int link_len; + + if (/*!this_fs->fs_ops->readlink ||*/ + --symlink_count == 0 || /* limit check */ + total_len > MAX_SYMLINK_BUF) + goto err; + + linkbuf = malloc(total_len); + if (!linkbuf) + goto err; + + link_len = btrfs_readlink(inode, linkbuf); + if (link_len <= 0) { + free(linkbuf); + goto err; + } + + q = linkbuf + link_len; + + if (echar) { + if (link_len > 0 && q[-1] != '/') + *q++ = '/'; + + memcpy(q, p, name_len+1); + } else { + *q = '\0'; + } + + free(pathbuf); + p = pathbuf = linkbuf; + put_inode(inode); + inode = NULL; + goto got_link; + } + + inode->name = strdup(part); + + inode->parent = parent; + parent = NULL; + + if (!echar) + break; + + if (inode->mode != DT_DIR) + goto err; + + parent = inode; + inode = NULL; + } + } while (echar); + } while (0); + + free(pathbuf); + pathbuf = NULL; + put_inode(parent); + parent = NULL; + + if (!inode) + goto err; + + file->inode = inode; + file->offset = 0; + return file_to_handle(file); + +err: + put_inode(inode); + put_inode(parent); + if (pathbuf) + free(pathbuf); + _close_file(file); +err_no_close: + return -1; +} + +static void get_next_extent(struct inode *inode) +{ + /* The logical start address that we care about... */ + uint32_t lstart = inode->this_extent.lstart + inode->this_extent.len; + + if (btrfs_next_extent(inode, lstart)) + inode->next_extent.len = 0; /* ERROR */ + inode->next_extent.lstart = lstart; +} + +int getfssec(struct com32_filedata *filedata, char * buf) +{ + int sectors; + char have_more; + uint32_t bytes_read; + struct file *file; + uint16_t handle; + if(filedata->size>=512) + { + sectors = filedata->size/SECTOR_SIZE; + sectors += (filedata->size%SECTOR_SIZE)?1:0; + } + else sectors=2; + + file = handle_to_file(filedata->handle); + + bytes_read = btrfs_getfssec(file, buf, sectors, &have_more); + if (!have_more) { + } + return bytes_read; +} + +uint32_t generic_getfssec(struct file *file, char *buf, + int sectors, char *have_more) +{ + struct inode *inode = file->inode; + struct fs_info *fs = file->fs; + uint32_t bytes_read = 0; + uint32_t bytes_left = inode->size - file->offset; + uint32_t sectors_left = + (bytes_left + SECTOR_SIZE - 1) >> 9; + uint32_t lsector; + + if (sectors > sectors_left) + sectors = sectors_left; + + if (!sectors) + return 0; + + lsector = file->offset >> 9; + + if (lsector < inode->this_extent.lstart || + lsector >= inode->this_extent.lstart + inode->this_extent.len) { + /* inode->this_extent unusable, maybe next_extent is... */ + inode->this_extent = inode->next_extent; + } + + if (lsector < inode->this_extent.lstart || + lsector >= inode->this_extent.lstart + inode->this_extent.len) { + /* Still nothing useful... */ + inode->this_extent.lstart = lsector; + inode->this_extent.len = 0; + } else { + /* We have some usable information */ + uint32_t delta = lsector - inode->this_extent.lstart; + inode->this_extent.lstart = lsector; + inode->this_extent.len -= delta; + inode->this_extent.pstart + = next_psector(inode->this_extent.pstart, delta); + } + + + while (sectors) { + uint32_t chunk; + size_t len; + + while (sectors > inode->this_extent.len) { + if (!inode->next_extent.len || + inode->next_extent.lstart != + inode->this_extent.lstart + inode->this_extent.len) + get_next_extent(inode); + if (!inode->this_extent.len) { + /* Doesn't matter if it's contiguous... */ + inode->this_extent = inode->next_extent; + if (!inode->next_extent.len) { + sectors = 0; /* Failed to get anything... we're dead */ + break; + } + } else if (inode->next_extent.len && + inode->next_extent.pstart == next_pstart(&inode->this_extent)) { + /* Coalesce extents and loop */ + inode->this_extent.len += inode->next_extent.len; + } else { + /* Discontiguous extents */ + break; + } + } + + + chunk = min(sectors, inode->this_extent.len); + len = chunk << 9;//SECTOR_SHIFT(fs); + + + if (inode->this_extent.pstart == EXTENT_ZERO) { + memset(buf, 0, len); + } else { + btrfs_block_dev_desc->block_read( btrfs_block_dev_desc->dev, + part_info->start+(inode->this_extent.pstart), chunk, buf); + inode->this_extent.pstart += chunk; + } + + buf += len; + sectors -= chunk; + bytes_read += len; + inode->this_extent.lstart += chunk; + inode->this_extent.len -= chunk; + } + + bytes_read = min(bytes_read, bytes_left); + file->offset += bytes_read; + + if (have_more) + *have_more = bytes_read < bytes_left; + + return bytes_read; +} diff --git a/fs/fs.c b/fs/fs.c index 023e7ef..b662a25 100644 --- a/fs/fs.c +++ b/fs/fs.c @@ -20,9 +20,8 @@ #include <ext4fs.h> #include <fat.h> #include <fs.h> - +#include <btrfs.h> DECLARE_GLOBAL_DATA_PTR; - static block_dev_desc_t *fs_dev_desc; static disk_partition_t fs_partition; static int fs_type = FS_TYPE_ANY; @@ -79,6 +78,73 @@ static inline void fs_close_fat(void) #define fs_read_fat fs_read_unsupported #endif + +#ifdef CONFIG_FS_BTR +struct fs_info fs; +static int fs_probe_btr(void) +{ + + btrfs_set_blk_dev(fs_dev_desc, &fs_partition); + + if (btrfs_fs_init(&fs)==-1) { + printf("btrfs probe failed\n"); + return -1; + } + + return 0; +} + +static void fs_close_btr(void) +{ +} + +#define fs_ls_btr btrfs_ls +static int fs_read_btr(const char *filename, ulong addr, int offset, int len) +{ + int file_len=0; + int len_read; + struct com32_filedata filedata; + int handle; + if (offset != 0) { + printf("** Cannot support non-zero offset **\n"); + return -1; + } + + handle=btrfs_open_file(filename, &filedata); + if (handle < 0) { + printf("** File not found %s Invalid handle**\n", filename); + return -1; + } + //file handle is valid get the size of the file + len=filedata.size; + if (len == 0) + len = file_len; + + len_read = getfssec(&filedata, (char *)addr); + if (len_read != len) { + printf("** Unable to read file %s **\n", filename); + return -1; + } + + return len_read; +} + +#else +static inline int fs_probe_btr(void) +{ + return -1; +} + +static inline void fs_close_btr(void) +{ +} + +#define fs_ls_btr fs_ls_unsupported +#define fs_read_btr fs_read_unsupported +#endif + + + #ifdef CONFIG_FS_EXT4 static int fs_probe_ext(void) { @@ -155,6 +221,10 @@ static struct { .fstype = FS_TYPE_EXT, .probe = fs_probe_ext, }, + { + .fstype = FS_TYPE_BTR, + .probe = fs_probe_btr, + }, }; int fs_set_blk_dev(const char *ifname, const char *dev_part_str, int fstype) @@ -178,7 +248,6 @@ int fs_set_blk_dev(const char *ifname, const char *dev_part_str, int fstype) for (i = 0; i < ARRAY_SIZE(fstypes); i++) { if ((fstype != FS_TYPE_ANY) && (fstype != fstypes[i].fstype)) continue; - if (!fstypes[i].probe()) { fs_type = fstypes[i].fstype; return 0; @@ -198,6 +267,9 @@ static void fs_close(void) case FS_TYPE_EXT: fs_close_ext(); break; + case FS_TYPE_BTR: + fs_close_btr(); + break; default: break; } @@ -208,7 +280,6 @@ static void fs_close(void) int fs_ls(const char *dirname) { int ret; - switch (fs_type) { case FS_TYPE_FAT: ret = fs_ls_fat(dirname); @@ -216,6 +287,9 @@ int fs_ls(const char *dirname) case FS_TYPE_EXT: ret = fs_ls_ext(dirname); break; + case FS_TYPE_BTR: + ret = fs_ls_unsupported(dirname); + break; default: ret = fs_ls_unsupported(dirname); break; @@ -237,11 +311,13 @@ int fs_read(const char *filename, ulong addr, int offset, int len) case FS_TYPE_EXT: ret = fs_read_ext(filename, addr, offset, len); break; + case FS_TYPE_BTR: + ret = fs_read_btr(filename, addr, offset, len); + break; default: ret = fs_read_unsupported(filename, addr, offset, len); break; } - fs_close(); return ret; diff --git a/include/btrfs.h b/include/btrfs.h new file mode 100644 index 0000000..4124ca6 --- /dev/null +++ b/include/btrfs.h @@ -0,0 +1,398 @@ +#ifndef _BTRFS_H_ +#define _BTRFS_H_ + +#include <asm/byteorder.h> +/* type that store on disk, but it is same as cpu type for i386 arch */ + +#define CURRENTDIR_MAX 15 +#define MAX_OPEN 5 +#define FILENAME_MAX 20 +#define MAX_SYMLINK_CNT 20 +#define MAX_SYMLINK_BUF 4096 +#define SECTOR_SHIFT(fs) ((fs)->sector_shift) +#define IFTODT(mode) (((mode) & 0170000) >> 12) +#define SECTOR_SIZE 0x200 +#define SECTOR_BITS 9 +#define EXTENT_ZERO ((__le32)-1) /* All-zero extent */ +#define EXTENT_VOID ((__le32)-2) /* Invalid information */ +#define DT_LNK 10 +#define DT_REG 8 +#define DT_DIR 4 + + +#define EXTENT_SPECIAL(x) ((x) >= EXTENT_VOID) +#define MAX_SUBVOL_NAME 50 +struct com32_filedata { + size_t size; /* File size */ + int blocklg2; /* log2(block size) */ + uint16_t handle; /* File handle */ +}; + +struct fs_info { + const struct fs_ops *fs_ops; + struct device *fs_dev; + void *fs_info; /* The fs-specific information */ + int sector_shift, sector_size; + int block_shift, block_size; + struct inode *root, *cwd; /* Root and current directories */ + char cwd_name[CURRENTDIR_MAX]; /* Current directory by name */ +}; +/* + * Extent structure: contains the mapping of some chunk of a file + * that is contiguous on disk. + */ +struct extent { + //sector_t pstart; /* Physical start sector */ + __le64 pstart; + __le32 lstart; /* Logical start sector */ + __le32 len; /* Number of contiguous sectors */ +}__attribute__ ((__packed__)); + + +struct inode { + struct fs_info *fs; /* The filesystem this inode is associated with */ + struct inode *parent; /* Parent directory, if any */ + const u8 *name; /* Name, valid for generic path search only */ + __le32 refcnt; + __le32 mode; /* FILE , DIR or SYMLINK */ + __le32 size; + __le32 blocks; /* How many blocks the file take */ + __le32 ino; /* Inode number */ + __le32 atime; /* Access time */ + __le32 mtime; /* Modify time */ + __le32 ctime; /* Create time */ + __le32 dtime; /* Delete time */ + __le32 flags; + __le32 file_acl; + struct extent this_extent, next_extent; + u8 pvt[0]; /* Private filesystem data */ +}__attribute__ ((__packed__)); +struct file { + struct fs_info *fs; + __le64 offset; /* for next read */ + struct inode *inode; /* The file-specific information */ +}__attribute__ ((__packed__)); + +#define NAME_MAX 20 +struct dirent { + uint32_t d_ino; + uint32_t d_off; + uint16_t d_reclen; + uint16_t d_type; + char d_name[NAME_MAX + 1]; +}; + + +#include "crc32c.h" +#define btrfs_crc32c crc32c_le + +#define BTRFS_SUPER_INFO_OFFSET (64 * 1024) +#define BTRFS_SUPER_INFO_SIZE 4096 +#define BTRFS_MAX_LEAF_SIZE 4096 +#define BTRFS_BLOCK_SHIFT 12 + +#define BTRFS_SUPER_MIRROR_MAX 3 +#define BTRFS_SUPER_MIRROR_SHIFT 12 +#define BTRFS_CSUM_SIZE 32 +#define BTRFS_FSID_SIZE 16 +#define BTRFS_LABEL_SIZE 256 +#define BTRFS_SYSTEM_CHUNK_ARRAY_SIZE 2048 +#define BTRFS_UUID_SIZE 16 + +#define BTRFS_MAGIC "_BHRfS_M" + +#define BTRFS_SUPER_FLAG_METADUMP (1ULL << 33) + +#define BTRFS_DEV_ITEM_KEY 216 +#define BTRFS_CHUNK_ITEM_KEY 228 +#define BTRFS_ROOT_REF_KEY 156 +#define BTRFS_ROOT_ITEM_KEY 132 +#define BTRFS_EXTENT_DATA_KEY 108 +#define BTRFS_DIR_ITEM_KEY 84 +#define BTRFS_INODE_ITEM_KEY 1 + +#define BTRFS_EXTENT_TREE_OBJECTID 2ULL +#define BTRFS_FS_TREE_OBJECTID 5ULL + +#define BTRFS_FIRST_CHUNK_TREE_OBJECTID 256ULL + +#define BTRFS_FILE_EXTENT_INLINE 0 +#define BTRFS_FILE_EXTENT_REG 1 +#define BTRFS_FILE_EXTENT_PREALLOC 2 + +#define BTRFS_MAX_LEVEL 8 +#define BTRFS_MAX_CHUNK_ENTRIES 256 + +#define BTRFS_FT_REG_FILE 1 +#define BTRFS_FT_DIR 2 +#define BTRFS_FT_SYMLINK 7 + +#define ROOT_DIR_WORD 0x002f + +struct btrfs_dev_item { + __le64 devid; + __le64 total_bytes; + __le64 bytes_used; + __le32 io_align; + __le32 io_width; + __le32 sector_size; + __le64 type; + __le64 generation; + __le64 start_offset; + __le32 dev_group; + u8 seek_speed; + u8 bandwidth; + u8 uuid[BTRFS_UUID_SIZE]; + u8 fsid[BTRFS_UUID_SIZE]; +} __attribute__ ((__packed__)); + +struct btrfs_super_block { + u8 csum[BTRFS_CSUM_SIZE]; + /* the first 4 fields must match struct btrfs_header */ + u8 fsid[BTRFS_FSID_SIZE]; /* FS specific uuid */ + __le64 bytenr; /* this block number */ + __le64 flags; + + /* allowed to be different from the btrfs_header from here own down */ + __le64 magic; + __le64 generation; + __le64 root; + __le64 chunk_root; + __le64 log_root; + + /* this will help find the new super based on the log root */ + __le64 log_root_transid; + __le64 total_bytes; + __le64 bytes_used; + __le64 root_dir_objectid; + __le64 num_devices; + __le32 sectorsize; + __le32 nodesize; + __le32 leafsize; + __le32 stripesize; + __le32 sys_chunk_array_size; + __le64 chunk_root_generation; + __le64 compat_flags; + __le64 compat_ro_flags; + __le64 incompat_flags; + __le16 csum_type; + u8 root_level; + u8 chunk_root_level; + u8 log_root_level; + struct btrfs_dev_item dev_item; + + char label[BTRFS_LABEL_SIZE]; + + __le64 cache_generation; + + /* future expansion */ + __le64 reserved[31]; + u8 sys_chunk_array[BTRFS_SYSTEM_CHUNK_ARRAY_SIZE]; +} __attribute__ ((__packed__)); +struct btrfs_disk_key { + __le64 objectid; + u8 type; + __le64 offset; +} __attribute__ ((__packed__)); + +struct btrfs_stripe { + __le64 devid; + __le64 offset; + u8 dev_uuid[BTRFS_UUID_SIZE]; +} __attribute__ ((__packed__)); + +struct btrfs_chunk { + __le64 length; + __le64 owner; + __le64 stripe_len; + __le64 type; + __le32 io_align; + __le32 io_width; + __le32 sector_size; + __le16 num_stripes; + __le16 sub_stripes; + struct btrfs_stripe stripe; +} __attribute__ ((__packed__)); + +struct btrfs_header { + /* these first four must match the super block */ + u8 csum[BTRFS_CSUM_SIZE]; + u8 fsid[BTRFS_FSID_SIZE]; /* FS specific uuid */ + __le64 bytenr; /* which block this node is supposed to live in */ + __le64 flags; + + /* allowed to be different from the super from here on down */ + u8 chunk_tree_uuid[BTRFS_UUID_SIZE]; + __le64 generation; + __le64 owner; + __le32 nritems; + u8 level; +} __attribute__ ((__packed__)); + +struct btrfs_item { + struct btrfs_disk_key key; + __le32 offset; + __le32 size; +} __attribute__ ((__packed__)); + +struct btrfs_leaf { + struct btrfs_header header; + struct btrfs_item items[]; +} __attribute__ ((__packed__)); + +struct btrfs_key_ptr { + struct btrfs_disk_key key; + __le64 blockptr; + __le64 generation; +} __attribute__ ((__packed__)); + +struct btrfs_node { + struct btrfs_header header; + struct btrfs_key_ptr ptrs[]; +} __attribute__ ((__packed__)); + +/* remember how we get to a node/leaf */ +struct btrfs_path { + __le64 offsets[BTRFS_MAX_LEVEL]; + __le32 itemsnr[BTRFS_MAX_LEVEL]; + __le32 slots[BTRFS_MAX_LEVEL]; + /* remember last slot's item and data */ + struct btrfs_item item; + u8 data[BTRFS_MAX_LEAF_SIZE]; +}__attribute__ ((__packed__)); + +/* store logical offset to physical offset mapping */ +struct btrfs_chunk_map_item { + __le64 logical; + __le64 length; + __le64 devid; + __le64 physical; +} __attribute__ ((__packed__)); + +struct btrfs_chunk_map { + struct btrfs_chunk_map_item *map; + __le32 map_length; + __le32 cur_length; +} __attribute__ ((__packed__));; + +struct btrfs_timespec { + __le64 sec; + __le32 nsec; +} __attribute__ ((__packed__)); + +struct btrfs_inode_item { + /* nfs style generation number */ + __le64 generation; + /* transid that last touched this inode */ + __le64 transid; + __le64 size; + __le64 nbytes; + __le64 block_group; + __le32 nlink; + __le32 uid; + __le32 gid; + __le32 mode; + __le64 rdev; + __le64 flags; + + /* modification sequence number for NFS */ + __le64 sequence; + + /* + * a little future expansion, for more than this we can + * just grow the inode item and version it + */ + __le64 reserved[4]; + struct btrfs_timespec atime; + struct btrfs_timespec ctime; + struct btrfs_timespec mtime; + struct btrfs_timespec otime; +} __attribute__ ((__packed__)); + +struct btrfs_root_item { + struct btrfs_inode_item inode; + __le64 generation; + __le64 root_dirid; + __le64 bytenr; + __le64 byte_limit; + __le64 bytes_used; + __le64 last_snapshot; + __le64 flags; + __le32 refs; + struct btrfs_disk_key drop_progress; + u8 drop_level; + u8 level; +} __attribute__ ((__packed__)); + +struct btrfs_dir_item { + struct btrfs_disk_key location; + __le64 transid; + __le16 data_len; + __le16 name_len; + u8 type; +} __attribute__ ((__packed__)); + +struct btrfs_file_extent_item { + __le64 generation; + __le64 ram_bytes; + u8 compression; + u8 encryption; + __le16 other_encoding; /* spare for later use */ + u8 type; + __le64 disk_bytenr; + __le64 disk_num_bytes; + __le64 offset; + __le64 num_bytes; +} __attribute__ ((__packed__)); + +struct btrfs_root_ref { + __le64 dirid; + __le64 sequence; + __le16 name_len; +} __attribute__ ((__packed__)); + +/* + * btrfs private inode information + */ +struct btrfs_pvt_inode { + __le64 offset; +}__attribute__ ((__packed__)); + +void btrfs_set_blk_dev(block_dev_desc_t* rbdd , disk_partition_t *info); +int btrfs_fs_init(struct fs_info *fs); +void put_inode(struct inode *inode); +struct inode *alloc_inode(struct fs_info *fs, uint32_t ino, size_t data); +int btrfs_open_file(const char *name, struct com32_filedata *filedata); +int getfssec(struct com32_filedata *filedata, char * buf); +uint32_t generic_getfssec(struct file *file, char *buf, + int sectors, char *have_more); +#define PVT(i) ((struct btrfs_pvt_inode *)((i)->pvt)) +static inline __le32 next_psector(__le32 psector, uint32_t skip) +{ + if (EXTENT_SPECIAL(psector)) + return psector; + else + return psector + skip; +} + +static inline __le32 next_pstart(const struct extent *e) +{ + return next_psector(e->pstart, e->len); +} + +/* + * Our definition of "not whitespace" + */ +static inline char not_whitespace(char c) +{ + return (unsigned char)c > ' '; +} + +static inline struct inode *get_inode(struct inode *inode) +{ + inode->refcnt++; + return inode; +} + + +#endif diff --git a/include/config_fallbacks.h b/include/config_fallbacks.h index bfb9680..28a0a66 100644 --- a/include/config_fallbacks.h +++ b/include/config_fallbacks.h @@ -26,4 +26,8 @@ #define CONFIG_EXT4_WRITE #endif +#if defined(CONFIG_CMD_BTR) && !defined(CONFIG_FS_BTR) +#define CONFIG_FS_BTR +#endif + #endif /* __CONFIG_FALLBACKS_H */ diff --git a/include/crc32c.h b/include/crc32c.h new file mode 100644 index 0000000..d04916e --- /dev/null +++ b/include/crc32c.h @@ -0,0 +1,48 @@ +/* + * Copied from Linux kernel crypto/crc32c.c + * Copyright (c) 2004 Cisco Systems, Inc. + * Copyright (c) 2008 Herbert Xu <herbert@gondor.apana.org.au> + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published by the Free + * Software Foundation; either version 2 of the License, or (at your option) + * any later version. + * + */ + +/* + * This is the CRC-32C table + * Generated with: + * width = 32 bits + * poly = 0x1EDC6F41 + * reflect input bytes = true + * reflect output bytes = true + */ + +/* + * Steps through buffer one byte at at time, calculates reflected + * crc using table. + */ + +static inline u32 crc32c_cal(u32 crc, const char *data, size_t length, u32 *crc32c_table) +{ + while (length--) + crc = crc32c_table[(u8)(crc ^ *data++)] ^ (crc >> 8); + + return crc; +} + +static inline void crc32c_init(u32 *crc32c_table, u32 pol) +{ + int i, j; + u32 v; + const u32 poly = pol; /* Bit-reflected CRC32C polynomial */ + + for (i = 0; i < 256; i++) { + v = i; + for (j = 0; j < 8; j++) { + v = (v >> 1) ^ ((v & 1) ? poly : 0); + } + crc32c_table[i] = v; + } +} diff --git a/include/fs.h b/include/fs.h index 4f30a38..3a0e7d4 100644 --- a/include/fs.h +++ b/include/fs.h @@ -21,6 +21,7 @@ #define FS_TYPE_ANY 0 #define FS_TYPE_FAT 1 #define FS_TYPE_EXT 2 +#define FS_TYPE_BTR 3 /* * Tell the fs layer which block device an partition to use for future -- 1.7.9.5 ^ permalink raw reply related [flat|nested] 16+ messages in thread
end of thread, other threads:[~2013-03-01 23:11 UTC | newest] Thread overview: 16+ messages (download: mbox.gz follow: Atom feed -- links below jump to the message on this page -- 2013-02-25 12:24 [U-Boot] [PATCH v3] btrfs addition to uboot Adnan Ali 2013-02-25 12:24 ` [U-Boot] [PATCH v3] Introduced btrfs file-system with btrload command Adnan Ali 2013-02-25 15:04 ` Tom Rini 2013-02-25 16:08 ` Adnan Ali 2013-02-25 16:29 ` Tom Rini 2013-02-25 16:44 ` Adnan Ali 2013-02-25 16:48 ` Tom Rini 2013-02-25 23:04 ` Simon Glass 2013-02-25 23:02 ` Simon Glass 2013-02-26 12:54 ` Adnan Ali 2013-02-26 16:19 ` Simon Glass 2013-03-01 22:53 ` Wolfgang Denk 2013-03-01 22:56 ` Tom Rini 2013-03-01 23:06 ` Wolfgang Denk 2013-03-01 23:11 ` Tom Rini -- strict thread matches above, loose matches on Subject: below -- 2013-02-15 12:10 [U-Boot] [PATCH v3] btrfs addition to uboot Adnan Ali 2013-02-15 12:10 ` [U-Boot] [PATCH v3] Introduced btrfs file-system with btrload command Adnan Ali
This is an external index of several public inboxes, see mirroring instructions on how to clone and mirror all data and code used by this external index.