*/
struct btrfs_disk_key {
__le64 objectid;
- __le32 flags;
__le64 offset;
+ __le32 flags;
} __attribute__ ((__packed__));
struct btrfs_key {
u64 objectid;
- u32 flags;
u64 offset;
+ u32 flags;
} __attribute__ ((__packed__));
/*
#define BTRFS_LEAF_DATA_SIZE(r) (__BTRFS_LEAF_DATA_SIZE(r->blocksize))
struct btrfs_buffer;
-
-struct btrfs_root_item {
- __le64 blocknr;
- __le32 flags;
- __le64 block_limit;
- __le64 blocks_used;
- __le32 refs;
-};
-
-/*
- * in ram representation of the tree. extent_root is used for all allocations
- * and for the extent tree extent_root root. current_insert is used
- * only for the extent tree.
- */
-struct btrfs_root {
- struct btrfs_buffer *node;
- struct btrfs_buffer *commit_root;
- struct btrfs_root *extent_root;
- struct btrfs_root *tree_root;
- struct btrfs_key current_insert;
- struct btrfs_key last_insert;
- int fp;
- struct radix_tree_root cache_radix;
- struct radix_tree_root pinned_radix;
- struct list_head trans;
- struct list_head cache;
- int cache_size;
- int ref_cows;
- struct btrfs_root_item root_item;
- struct btrfs_key root_key;
- u32 blocksize;
-};
-
/*
* the super block basically lists the main trees of the FS
* it currently lacks any block count etc etc
} __attribute__ ((__packed__));
/*
- * A leaf is full of items. The exact type of item is defined by
- * the key flags parameter. offset and size tell us where to find
+ * 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_ptr ptrs[];
} __attribute__ ((__packed__));
-/*
- * items in the extent btree are used to record the objectid of the
- * owner of the block and the number of references
- */
-struct btrfs_extent_item {
- __le32 refs;
- __le64 owner;
-} __attribute__ ((__packed__));
-
/*
* btrfs_paths remember the path taken from the root down to the leaf.
* level 0 is always the leaf, and nodes[1...BTRFS_MAX_LEVEL] will point
int slots[BTRFS_MAX_LEVEL];
};
+/*
+ * items in the extent btree are used to record the objectid of the
+ * owner of the block and the number of references
+ */
+struct btrfs_extent_item {
+ __le32 refs;
+ __le64 owner;
+} __attribute__ ((__packed__));
+
+struct btrfs_inode_timespec {
+ __le32 sec;
+ __le32 nsec;
+} __attribute__ ((__packed__));
+
+/*
+ * there is no padding here on purpose. If you want to extent the inode,
+ * make a new item type
+ */
+struct btrfs_inode_item {
+ __le64 generation;
+ __le64 size;
+ __le64 nblocks;
+ __le32 nlink;
+ __le32 uid;
+ __le32 gid;
+ __le32 mode;
+ __le32 rdev;
+ __le16 flags;
+ __le16 compat_flags;
+ struct btrfs_inode_timespec atime;
+ struct btrfs_inode_timespec ctime;
+ struct btrfs_inode_timespec mtime;
+ struct btrfs_inode_timespec otime;
+} __attribute__ ((__packed__));
+
+/* inline data is just a blob of bytes */
+struct btrfs_inline_data_item {
+ u8 data;
+} __attribute__ ((__packed__));
+
+struct btrfs_dir_item {
+ __le64 objectid;
+ __le16 flags;
+ u8 type;
+} __attribute__ ((__packed__));
+
+struct btrfs_root_item {
+ __le64 blocknr;
+ __le32 flags;
+ __le64 block_limit;
+ __le64 blocks_used;
+ __le32 refs;
+};
+
+/*
+ * in ram representation of the tree. extent_root is used for all allocations
+ * and for the extent tree extent_root root. current_insert is used
+ * only for the extent tree.
+ */
+struct btrfs_root {
+ struct btrfs_buffer *node;
+ struct btrfs_buffer *commit_root;
+ struct btrfs_root *extent_root;
+ struct btrfs_root *tree_root;
+ struct btrfs_key current_insert;
+ struct btrfs_key last_insert;
+ int fp;
+ struct radix_tree_root cache_radix;
+ struct radix_tree_root pinned_radix;
+ struct list_head trans;
+ struct list_head cache;
+ int cache_size;
+ int ref_cows;
+ struct btrfs_root_item root_item;
+ struct btrfs_key root_key;
+ u32 blocksize;
+};
+
+/* the lower bits in the key flags defines the item type */
+#define BTRFS_KEY_TYPE_MAX 256
+#define BTRFS_KEY_TYPE_MASK (BTRFS_KEY_TYPE_MAX - 1)
+
+/*
+ * inode items have the data typically returned from stat and store other
+ * info about object characteristics. There is one for every file and dir in
+ * the FS
+ */
+#define BTRFS_INODE_ITEM_KEY 1
+
+/*
+ * dir items are the name -> inode pointers in a directory. There is one
+ * for every name in a directory.
+ */
+#define BTRFS_DIR_ITEM_KEY 2
+/*
+ * inline data is file data that fits in the btree.
+ */
+#define BTRFS_INLINE_DATA_KEY 3
+/*
+ * extent data is for data that can't fit in the btree. It points to
+ * a (hopefully) huge chunk of disk
+ */
+#define BTRFS_EXTENT_DATA_KEY 4
+/*
+ * root items point to tree roots. There are typically in the root
+ * tree used by the super block to find all the other trees
+ */
+#define BTRFS_ROOT_ITEM_KEY 5
+/*
+ * extent items are in the extent map tree. These record which blocks
+ * are used, and how many references there are to each block
+ */
+#define BTRFS_EXTENT_ITEM_KEY 6
+/*
+ * string items are for debugging. They just store a short string of
+ * data in the FS
+ */
+#define BTRFS_STRING_ITEM_KEY 7
+
+static inline u64 btrfs_inode_generation(struct btrfs_inode_item *i)
+{
+ return le64_to_cpu(i->generation);
+}
+
+static inline void btrfs_set_inode_generation(struct btrfs_inode_item *i,
+ u64 val)
+{
+ i->generation = cpu_to_le64(val);
+}
+
+static inline u64 btrfs_inode_size(struct btrfs_inode_item *i)
+{
+ return le64_to_cpu(i->size);
+}
+
+static inline void btrfs_set_inode_size(struct btrfs_inode_item *i, u64 val)
+{
+ i->size = cpu_to_le64(val);
+}
+
+static inline u64 btrfs_inode_nblocks(struct btrfs_inode_item *i)
+{
+ return le64_to_cpu(i->nblocks);
+}
+
+static inline void btrfs_set_inode_nblocks(struct btrfs_inode_item *i, u64 val)
+{
+ i->nblocks = cpu_to_le64(val);
+}
+
+static inline u32 btrfs_inode_nlink(struct btrfs_inode_item *i)
+{
+ return le32_to_cpu(i->nlink);
+}
+
+static inline void btrfs_set_inode_nlink(struct btrfs_inode_item *i, u32 val)
+{
+ i->nlink = cpu_to_le32(val);
+}
+
+static inline u32 btrfs_inode_uid(struct btrfs_inode_item *i)
+{
+ return le32_to_cpu(i->uid);
+}
+
+static inline void btrfs_set_inode_uid(struct btrfs_inode_item *i, u32 val)
+{
+ i->uid = cpu_to_le32(val);
+}
+
+static inline u32 btrfs_inode_gid(struct btrfs_inode_item *i)
+{
+ return le32_to_cpu(i->gid);
+}
+
+static inline void btrfs_set_inode_gid(struct btrfs_inode_item *i, u32 val)
+{
+ i->gid = cpu_to_le32(val);
+}
+
+static inline u32 btrfs_inode_mode(struct btrfs_inode_item *i)
+{
+ return le32_to_cpu(i->mode);
+}
+
+static inline void btrfs_set_inode_mode(struct btrfs_inode_item *i, u32 val)
+{
+ i->mode = cpu_to_le32(val);
+}
+
+static inline u32 btrfs_inode_rdev(struct btrfs_inode_item *i)
+{
+ return le32_to_cpu(i->rdev);
+}
+
+static inline void btrfs_set_inode_rdev(struct btrfs_inode_item *i, u32 val)
+{
+ i->rdev = cpu_to_le32(val);
+}
+
+static inline u16 btrfs_inode_flags(struct btrfs_inode_item *i)
+{
+ return le16_to_cpu(i->flags);
+}
+
+static inline void btrfs_set_inode_flags(struct btrfs_inode_item *i, u16 val)
+{
+ i->flags = cpu_to_le16(val);
+}
+
+static inline u16 btrfs_inode_compat_flags(struct btrfs_inode_item *i)
+{
+ return le16_to_cpu(i->compat_flags);
+}
+
+static inline void btrfs_set_inode_compat_flags(struct btrfs_inode_item *i,
+ u16 val)
+{
+ i->compat_flags = cpu_to_le16(val);
+}
+
+
static inline u64 btrfs_extent_owner(struct btrfs_extent_item *ei)
{
return le64_to_cpu(ei->owner);
item->size = cpu_to_le16(val);
}
+static inline u64 btrfs_dir_objectid(struct btrfs_dir_item *d)
+{
+ return le64_to_cpu(d->objectid);
+}
+
+static inline void btrfs_set_dir_objectid(struct btrfs_dir_item *d, u64 val)
+{
+ d->objectid = cpu_to_le64(val);
+}
+
+static inline u16 btrfs_dir_flags(struct btrfs_dir_item *d)
+{
+ return le16_to_cpu(d->flags);
+}
+
+static inline void btrfs_set_dir_flags(struct btrfs_dir_item *d, u16 val)
+{
+ d->flags = cpu_to_le16(val);
+}
+
+static inline u8 btrfs_dir_type(struct btrfs_dir_item *d)
+{
+ return d->type;
+}
+
+static inline void btrfs_set_dir_type(struct btrfs_dir_item *d, u8 val)
+{
+ d->type = val;
+}
+
+static inline u32 btrfs_dir_name_len(struct btrfs_item *i)
+{
+ return btrfs_item_size(i) - sizeof(struct btrfs_dir_item);
+}
+
static inline void btrfs_disk_key_to_cpu(struct btrfs_key *cpu,
struct btrfs_disk_key *disk)
{
disk->objectid = cpu_to_le64(cpu->objectid);
}
-static inline u64 btrfs_key_objectid(struct btrfs_disk_key *disk)
+static inline u64 btrfs_disk_key_objectid(struct btrfs_disk_key *disk)
{
return le64_to_cpu(disk->objectid);
}
-static inline void btrfs_set_key_objectid(struct btrfs_disk_key *disk,
- u64 val)
+static inline void btrfs_set_disk_key_objectid(struct btrfs_disk_key *disk,
+ u64 val)
{
disk->objectid = cpu_to_le64(val);
}
-static inline u64 btrfs_key_offset(struct btrfs_disk_key *disk)
+static inline u64 btrfs_disk_key_offset(struct btrfs_disk_key *disk)
{
return le64_to_cpu(disk->offset);
}
-static inline void btrfs_set_key_offset(struct btrfs_disk_key *disk,
- u64 val)
+static inline void btrfs_set_disk_key_offset(struct btrfs_disk_key *disk,
+ u64 val)
{
disk->offset = cpu_to_le64(val);
}
-static inline u32 btrfs_key_flags(struct btrfs_disk_key *disk)
+static inline u32 btrfs_disk_key_flags(struct btrfs_disk_key *disk)
{
return le32_to_cpu(disk->flags);
}
-static inline void btrfs_set_key_flags(struct btrfs_disk_key *disk,
- u32 val)
+static inline void btrfs_set_disk_key_flags(struct btrfs_disk_key *disk,
+ u32 val)
{
disk->flags = cpu_to_le32(val);
}
+static inline u32 btrfs_key_type(struct btrfs_key *key)
+{
+ return key->flags & BTRFS_KEY_TYPE_MASK;
+}
+
+static inline u32 btrfs_disk_key_type(struct btrfs_disk_key *key)
+{
+ return le32_to_cpu(key->flags) & BTRFS_KEY_TYPE_MASK;
+}
+
+static inline void btrfs_set_key_type(struct btrfs_key *key, u32 type)
+{
+ BUG_ON(type >= BTRFS_KEY_TYPE_MAX);
+ key->flags = (key->flags & ~((u64)BTRFS_KEY_TYPE_MASK)) | type;
+}
+
+static inline void btrfs_set_disk_key_type(struct btrfs_disk_key *key, u32 type)
+{
+ u32 flags = btrfs_disk_key_flags(key);
+ BUG_ON(type >= BTRFS_KEY_TYPE_MAX);
+ flags = (flags & ~((u64)BTRFS_KEY_TYPE_MASK)) | type;
+ btrfs_set_disk_key_flags(key, flags);
+}
+
static inline u64 btrfs_header_blocknr(struct btrfs_header *h)
{
return le64_to_cpu(h->blocknr);
{
return (u8 *)l->items;
}
-
/* helper function to cast into the data area of the leaf. */
#define btrfs_item_ptr(leaf, slot, type) \
((type *)(btrfs_leaf_data(leaf) + \
void btrfs_init_path(struct btrfs_path *p);
int btrfs_del_item(struct btrfs_root *root, struct btrfs_path *path);
int btrfs_insert_item(struct btrfs_root *root, struct btrfs_key *key,
- void *data, int data_size);
+ void *data, u32 data_size);
+int btrfs_insert_empty_item(struct btrfs_root *root, struct btrfs_path *path,
+ struct btrfs_key *cpu_key, u32 data_size);
int btrfs_next_leaf(struct btrfs_root *root, struct btrfs_path *path);
int btrfs_leaf_free_space(struct btrfs_root *root, struct btrfs_leaf *leaf);
int btrfs_drop_snapshot(struct btrfs_root *root, struct btrfs_buffer *snap);
struct btrfs_root_item *item);
int btrfs_find_last_root(struct btrfs_root *root, u64 objectid,
struct btrfs_root_item *item, struct btrfs_key *key);
+int btrfs_insert_dir_item(struct btrfs_root *root, char *name, int name_len,
+ u64 dir, u64 objectid, u8 type);
+int btrfs_lookup_dir_item(struct btrfs_root *root, struct btrfs_path *path,
+ u64 dir, char *name, int name_len, int mod);
+int btrfs_match_dir_item_name(struct btrfs_root *root, struct btrfs_path *path,
+ char *name, int name_len);
#endif
projects / mv-sheeva.git / blobdiff