btrfs2 1.2.2

Interface for BTRFS ioctls etc | fork of the btrfs-crate containing fixes. Intent to yank crate once fixes are accepted upstream!
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141

use std::mem;

use diskformat::*;

#[ derive (Clone) ]
pub struct BtrfsLeafNode <'a> {
	/*position: usize,*/
	bytes: & 'a [u8],
}

pub struct BtrfsLeafNodeItems <'a> {
	node: BtrfsLeafNode <'a>,
	index: u32,
}

impl <'a> BtrfsLeafNode <'a> {

	pub fn new (
		/*position: usize,*/
		bytes: & 'a [u8],
	) -> BtrfsLeafNode <'a> {

		BtrfsLeafNode {
			/*position: position,*/
			bytes: bytes,
		}

	}

	pub fn header (
		& 'a self,
	) -> & 'a BtrfsNodeHeader {

		unsafe {
			& * (self.bytes.as_ptr () as * const BtrfsNodeHeader)
		}

	}

	pub fn is_leaf (
		& self,
	) -> bool {
		self.header ().level () == 0
	}

	pub fn items (
		self,
	) -> BtrfsLeafNodeItems <'a> {

		BtrfsLeafNodeItems {
			node: self,
			index: 0,
		}

	}

	pub fn checksum (& self) -> BtrfsChecksum {
		self.header ().checksum ()
	}

	pub fn fs_uuid (& self) -> BtrfsUuid {
		self.header ().fs_uuid ()
	}

	pub fn tree_id (& self) -> u64 {
		self.header ().tree_id ()
	}

	pub fn num_items (& self) -> u32 {
		self.header ().num_items ()
	}

	pub fn level (& self) -> u8 {
		self.header ().level ()
	}

}

impl <'a> Iterator for BtrfsLeafNodeItems <'a> {

	type Item = BtrfsLeafItem <'a>;

	fn next (
		& mut self,
	) -> Option <BtrfsLeafItem <'a>> {

		if self.index < self.node.num_items () {

			// read header

			let header_start =
				mem::size_of::<BtrfsNodeHeader> ()
				+ self.index as usize
					* mem::size_of::<BtrfsLeafItemHeader> ();

			let header_end =
				mem::size_of::<BtrfsNodeHeader> ()
				+ self.index as usize
					* mem::size_of::<BtrfsLeafItemHeader> ()
				+ mem::size_of::<BtrfsLeafItemHeader> ();

			let item_header_bytes =
				& self.node.bytes [
					header_start .. header_end];

			let item_header =
				BtrfsLeafItemHeader::from_bytes (
					item_header_bytes,
				).unwrap ();

			// read data

			let item_data =
				& self.node.bytes [
					mem::size_of::<BtrfsNodeHeader> ()
					+ item_header.data_offset () as usize
				..
					mem::size_of::<BtrfsNodeHeader> ()
					+ item_header.data_offset () as usize
					+ item_header.data_size () as usize
				];

			self.index += 1;

			Some (
				BtrfsLeafItem::from_bytes (
					item_header,
					item_data)
			)

		} else {

			None

		}

	}

}

// ex: noet ts=4 filetype=rust