mirror of
https://github.com/brain-hackers/u-boot-brain
synced 2024-08-20 17:08:52 +09:00
![Tom Rini](/assets/img/avatar_default.png)
Per Pierre this change shouldn't have been applied as it was superseded by "fs: btrfs: fix btrfs_search_tree invalid results" which is also applied now as1627e5e598
. This reverts commit633967f981
. Signed-off-by: Tom Rini <trini@konsulko.com>
334 lines
8.1 KiB
C
334 lines
8.1 KiB
C
/* SPDX-License-Identifier: GPL-2.0+ */
|
|
/*
|
|
* From linux/fs/btrfs/ctree.h
|
|
* Copyright (C) 2007,2008 Oracle. All rights reserved.
|
|
*
|
|
* Modified in 2017 by Marek Behun, CZ.NIC, marek.behun@nic.cz
|
|
*/
|
|
|
|
#ifndef __BTRFS_CTREE_H__
|
|
#define __BTRFS_CTREE_H__
|
|
|
|
#include <common.h>
|
|
#include <compiler.h>
|
|
#include "btrfs_tree.h"
|
|
|
|
#define BTRFS_MAGIC 0x4D5F53665248425FULL /* ascii _BHRfS_M, no null */
|
|
|
|
#define BTRFS_MAX_MIRRORS 3
|
|
|
|
#define BTRFS_MAX_LEVEL 8
|
|
|
|
#define BTRFS_COMPAT_EXTENT_TREE_V0
|
|
|
|
/*
|
|
* the max metadata block size. This limit is somewhat artificial,
|
|
* but the memmove costs go through the roof for larger blocks.
|
|
*/
|
|
#define BTRFS_MAX_METADATA_BLOCKSIZE 65536
|
|
|
|
/*
|
|
* we can actually store much bigger names, but lets not confuse the rest
|
|
* of linux
|
|
*/
|
|
#define BTRFS_NAME_LEN 255
|
|
|
|
/*
|
|
* Theoretical limit is larger, but we keep this down to a sane
|
|
* value. That should limit greatly the possibility of collisions on
|
|
* inode ref items.
|
|
*/
|
|
#define BTRFS_LINK_MAX 65535U
|
|
|
|
static const int btrfs_csum_sizes[] = { 4 };
|
|
|
|
/* four bytes for CRC32 */
|
|
#define BTRFS_EMPTY_DIR_SIZE 0
|
|
|
|
/* ioprio of readahead is set to idle */
|
|
#define BTRFS_IOPRIO_READA (IOPRIO_PRIO_VALUE(IOPRIO_CLASS_IDLE, 0))
|
|
|
|
#define BTRFS_DIRTY_METADATA_THRESH SZ_32M
|
|
|
|
#define BTRFS_MAX_EXTENT_SIZE SZ_128M
|
|
|
|
/*
|
|
* File system states
|
|
*/
|
|
#define BTRFS_FS_STATE_ERROR 0
|
|
#define BTRFS_FS_STATE_REMOUNTING 1
|
|
#define BTRFS_FS_STATE_TRANS_ABORTED 2
|
|
#define BTRFS_FS_STATE_DEV_REPLACING 3
|
|
#define BTRFS_FS_STATE_DUMMY_FS_INFO 4
|
|
|
|
#define BTRFS_BACKREF_REV_MAX 256
|
|
#define BTRFS_BACKREF_REV_SHIFT 56
|
|
#define BTRFS_BACKREF_REV_MASK (((u64)BTRFS_BACKREF_REV_MAX - 1) << \
|
|
BTRFS_BACKREF_REV_SHIFT)
|
|
|
|
#define BTRFS_OLD_BACKREF_REV 0
|
|
#define BTRFS_MIXED_BACKREF_REV 1
|
|
|
|
/*
|
|
* every tree block (leaf or node) starts with this header.
|
|
*/
|
|
struct btrfs_header {
|
|
/* these first four must match the super block */
|
|
__u8 csum[BTRFS_CSUM_SIZE];
|
|
__u8 fsid[BTRFS_FSID_SIZE]; /* FS specific uuid */
|
|
__u64 bytenr; /* which block this node is supposed to live in */
|
|
__u64 flags;
|
|
|
|
/* allowed to be different from the super from here on down */
|
|
__u8 chunk_tree_uuid[BTRFS_UUID_SIZE];
|
|
__u64 generation;
|
|
__u64 owner;
|
|
__u32 nritems;
|
|
__u8 level;
|
|
} __attribute__ ((__packed__));
|
|
|
|
/*
|
|
* this is a very generous portion of the super block, giving us
|
|
* room to translate 14 chunks with 3 stripes each.
|
|
*/
|
|
#define BTRFS_SYSTEM_CHUNK_ARRAY_SIZE 2048
|
|
|
|
/*
|
|
* just in case we somehow lose the roots and are not able to mount,
|
|
* we store an array of the roots from previous transactions
|
|
* in the super.
|
|
*/
|
|
#define BTRFS_NUM_BACKUP_ROOTS 4
|
|
struct btrfs_root_backup {
|
|
__u64 tree_root;
|
|
__u64 tree_root_gen;
|
|
|
|
__u64 chunk_root;
|
|
__u64 chunk_root_gen;
|
|
|
|
__u64 extent_root;
|
|
__u64 extent_root_gen;
|
|
|
|
__u64 fs_root;
|
|
__u64 fs_root_gen;
|
|
|
|
__u64 dev_root;
|
|
__u64 dev_root_gen;
|
|
|
|
__u64 csum_root;
|
|
__u64 csum_root_gen;
|
|
|
|
__u64 total_bytes;
|
|
__u64 bytes_used;
|
|
__u64 num_devices;
|
|
/* future */
|
|
__u64 unused_64[4];
|
|
|
|
__u8 tree_root_level;
|
|
__u8 chunk_root_level;
|
|
__u8 extent_root_level;
|
|
__u8 fs_root_level;
|
|
__u8 dev_root_level;
|
|
__u8 csum_root_level;
|
|
/* future and to align */
|
|
__u8 unused_8[10];
|
|
} __attribute__ ((__packed__));
|
|
|
|
/*
|
|
* the super block basically lists the main trees of the FS
|
|
* it currently lacks any block count etc etc
|
|
*/
|
|
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 */
|
|
__u64 bytenr; /* this block number */
|
|
__u64 flags;
|
|
|
|
/* allowed to be different from the btrfs_header from here own down */
|
|
__u64 magic;
|
|
__u64 generation;
|
|
__u64 root;
|
|
__u64 chunk_root;
|
|
__u64 log_root;
|
|
|
|
/* this will help find the new super based on the log root */
|
|
__u64 log_root_transid;
|
|
__u64 total_bytes;
|
|
__u64 bytes_used;
|
|
__u64 root_dir_objectid;
|
|
__u64 num_devices;
|
|
__u32 sectorsize;
|
|
__u32 nodesize;
|
|
__u32 __unused_leafsize;
|
|
__u32 stripesize;
|
|
__u32 sys_chunk_array_size;
|
|
__u64 chunk_root_generation;
|
|
__u64 compat_flags;
|
|
__u64 compat_ro_flags;
|
|
__u64 incompat_flags;
|
|
__u16 csum_type;
|
|
__u8 root_level;
|
|
__u8 chunk_root_level;
|
|
__u8 log_root_level;
|
|
struct btrfs_dev_item dev_item;
|
|
|
|
char label[BTRFS_LABEL_SIZE];
|
|
|
|
__u64 cache_generation;
|
|
__u64 uuid_tree_generation;
|
|
|
|
/* future expansion */
|
|
__u64 reserved[30];
|
|
__u8 sys_chunk_array[BTRFS_SYSTEM_CHUNK_ARRAY_SIZE];
|
|
struct btrfs_root_backup super_roots[BTRFS_NUM_BACKUP_ROOTS];
|
|
} __attribute__ ((__packed__));
|
|
|
|
/*
|
|
* Compat flags that we support. If any incompat flags are set other than the
|
|
* ones specified below then we will fail to mount
|
|
*/
|
|
#define BTRFS_FEATURE_COMPAT_SUPP 0ULL
|
|
#define BTRFS_FEATURE_COMPAT_SAFE_SET 0ULL
|
|
#define BTRFS_FEATURE_COMPAT_SAFE_CLEAR 0ULL
|
|
|
|
#define BTRFS_FEATURE_COMPAT_RO_SUPP \
|
|
(BTRFS_FEATURE_COMPAT_RO_FREE_SPACE_TREE | \
|
|
BTRFS_FEATURE_COMPAT_RO_FREE_SPACE_TREE_VALID)
|
|
|
|
#define BTRFS_FEATURE_COMPAT_RO_SAFE_SET 0ULL
|
|
#define BTRFS_FEATURE_COMPAT_RO_SAFE_CLEAR 0ULL
|
|
|
|
#define BTRFS_FEATURE_INCOMPAT_SUPP \
|
|
(BTRFS_FEATURE_INCOMPAT_MIXED_BACKREF | \
|
|
BTRFS_FEATURE_INCOMPAT_DEFAULT_SUBVOL | \
|
|
BTRFS_FEATURE_INCOMPAT_MIXED_GROUPS | \
|
|
BTRFS_FEATURE_INCOMPAT_BIG_METADATA | \
|
|
BTRFS_FEATURE_INCOMPAT_COMPRESS_LZO | \
|
|
BTRFS_FEATURE_INCOMPAT_RAID56 | \
|
|
BTRFS_FEATURE_INCOMPAT_EXTENDED_IREF | \
|
|
BTRFS_FEATURE_INCOMPAT_SKINNY_METADATA | \
|
|
BTRFS_FEATURE_INCOMPAT_NO_HOLES)
|
|
|
|
#define BTRFS_FEATURE_INCOMPAT_SAFE_SET \
|
|
(BTRFS_FEATURE_INCOMPAT_EXTENDED_IREF)
|
|
#define BTRFS_FEATURE_INCOMPAT_SAFE_CLEAR 0ULL
|
|
|
|
/*
|
|
* A leaf is full of items. offset and size tell us where to find
|
|
* the item in the leaf (relative to the start of the data area)
|
|
*/
|
|
struct btrfs_item {
|
|
struct btrfs_key key;
|
|
__u32 offset;
|
|
__u32 size;
|
|
} __attribute__ ((__packed__));
|
|
|
|
/*
|
|
* leaves have an item area and a data area:
|
|
* [item0, item1....itemN] [free space] [dataN...data1, data0]
|
|
*
|
|
* The data is separate from the items to get the keys closer together
|
|
* during searches.
|
|
*/
|
|
struct btrfs_leaf {
|
|
struct btrfs_header header;
|
|
struct btrfs_item items[];
|
|
} __attribute__ ((__packed__));
|
|
|
|
/*
|
|
* all non-leaf blocks are nodes, they hold only keys and pointers to
|
|
* other blocks
|
|
*/
|
|
struct btrfs_key_ptr {
|
|
struct btrfs_key key;
|
|
__u64 blockptr;
|
|
__u64 generation;
|
|
} __attribute__ ((__packed__));
|
|
|
|
struct btrfs_node {
|
|
struct btrfs_header header;
|
|
struct btrfs_key_ptr ptrs[];
|
|
} __attribute__ ((__packed__));
|
|
|
|
union btrfs_tree_node {
|
|
struct btrfs_header header;
|
|
struct btrfs_leaf leaf;
|
|
struct btrfs_node node;
|
|
};
|
|
|
|
typedef __u8 u8;
|
|
typedef __u16 u16;
|
|
typedef __u32 u32;
|
|
typedef __u64 u64;
|
|
|
|
struct btrfs_path {
|
|
union btrfs_tree_node *nodes[BTRFS_MAX_LEVEL];
|
|
u32 slots[BTRFS_MAX_LEVEL];
|
|
};
|
|
|
|
struct btrfs_root {
|
|
u64 objectid;
|
|
u64 bytenr;
|
|
u64 root_dirid;
|
|
};
|
|
|
|
int btrfs_comp_keys(struct btrfs_key *, struct btrfs_key *);
|
|
int btrfs_comp_keys_type(struct btrfs_key *, struct btrfs_key *);
|
|
int btrfs_bin_search(union btrfs_tree_node *, struct btrfs_key *, int *);
|
|
void btrfs_free_path(struct btrfs_path *);
|
|
int btrfs_search_tree(const struct btrfs_root *, struct btrfs_key *,
|
|
struct btrfs_path *);
|
|
int btrfs_prev_slot(struct btrfs_path *);
|
|
int btrfs_next_slot(struct btrfs_path *);
|
|
|
|
static inline struct btrfs_key *btrfs_path_leaf_key(struct btrfs_path *p) {
|
|
return &p->nodes[0]->leaf.items[p->slots[0]].key;
|
|
}
|
|
|
|
static inline struct btrfs_key *
|
|
btrfs_search_tree_key_type(const struct btrfs_root *root, u64 objectid,
|
|
u8 type, struct btrfs_path *path)
|
|
{
|
|
struct btrfs_key key, *res;
|
|
|
|
key.objectid = objectid;
|
|
key.type = type;
|
|
key.offset = 0;
|
|
|
|
if (btrfs_search_tree(root, &key, path))
|
|
return NULL;
|
|
|
|
res = btrfs_path_leaf_key(path);
|
|
if (btrfs_comp_keys_type(&key, res)) {
|
|
btrfs_free_path(path);
|
|
return NULL;
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
static inline u32 btrfs_path_item_size(struct btrfs_path *p)
|
|
{
|
|
return p->nodes[0]->leaf.items[p->slots[0]].size;
|
|
}
|
|
|
|
static inline void *btrfs_leaf_data(struct btrfs_leaf *leaf, u32 slot)
|
|
{
|
|
return ((u8 *) leaf) + sizeof(struct btrfs_header)
|
|
+ leaf->items[slot].offset;
|
|
}
|
|
|
|
static inline void *btrfs_path_leaf_data(struct btrfs_path *p)
|
|
{
|
|
return btrfs_leaf_data(&p->nodes[0]->leaf, p->slots[0]);
|
|
}
|
|
|
|
#define btrfs_item_ptr(l,s,t) \
|
|
((t *) btrfs_leaf_data((l),(s)))
|
|
|
|
#define btrfs_path_item_ptr(p,t) \
|
|
((t *) btrfs_path_leaf_data((p)))
|
|
|
|
#endif /* __BTRFS_CTREE_H__ */
|