mirror of
https://github.com/brain-hackers/u-boot-brain
synced 2024-08-27 04:18:51 +09:00
![Tom Rini](/assets/img/avatar_default.png)
When U-Boot started using SPDX tags we were among the early adopters and there weren't a lot of other examples to borrow from. So we picked the area of the file that usually had a full license text and replaced it with an appropriate SPDX-License-Identifier: entry. Since then, the Linux Kernel has adopted SPDX tags and they place it as the very first line in a file (except where shebangs are used, then it's second line) and with slightly different comment styles than us. In part due to community overlap, in part due to better tag visibility and in part for other minor reasons, switch over to that style. This commit changes all instances where we have a single declared license in the tag as both the before and after are identical in tag contents. There's also a few places where I found we did not have a tag and have introduced one. 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__ */
|