add boot partition size

hc

2023-12-11 d2ccde1c8e90d38cee87a1b0309ad2827f3fd30d

 kernel/fs/btrfs/struct-funcs.c
..
..
@@ -7,112 +7,152 @@
7
7
 
8
8
 #include "ctree.h"
9
9
 
10
-static inline u8 get_unaligned_le8(const void *p)
10
+static bool check_setget_bounds(const struct extent_buffer *eb,
11
+				const void *ptr, unsigned off, int size)
11
12
 {
12
-       return *(u8 *)p;
13
-}
13
+	const unsigned long member_offset = (unsigned long)ptr + off;
14
14
 
15
-static inline void put_unaligned_le8(u8 val, void *p)
16
-{
17
-       *(u8 *)p = val;
15
+	if (member_offset > eb->len) {
16
+		btrfs_warn(eb->fs_info,
17
+	"bad eb member start: ptr 0x%lx start %llu member offset %lu size %d",
18
+			(unsigned long)ptr, eb->start, member_offset, size);
19
+		return false;
20
+	}
21
+	if (member_offset + size > eb->len) {
22
+		btrfs_warn(eb->fs_info,
23
+	"bad eb member end: ptr 0x%lx start %llu member offset %lu size %d",
24
+			(unsigned long)ptr, eb->start, member_offset, size);
25
+		return false;
26
+	}
27
+
28
+	return true;
18
29
 }
19
30
 
20
31
 /*
21
- * this is some deeply nasty code.
32
+ * Macro templates that define helpers to read/write extent buffer data of a
33
+ * given size, that are also used via ctree.h for access to item members by
34
+ * specialized helpers.
22
35
  *
23
- * The end result is that anyone who #includes ctree.h gets a
24
- * declaration for the btrfs_set_foo functions and btrfs_foo functions,
25
- * which are wrappers of btrfs_set_token_#bits functions and
26
- * btrfs_get_token_#bits functions, which are defined in this file.
36
+ * Generic helpers:
37
+ * - btrfs_set_8 (for 8/16/32/64)
38
+ * - btrfs_get_8 (for 8/16/32/64)
27
39
  *
28
- * These setget functions do all the extent_buffer related mapping
29
- * required to efficiently read and write specific fields in the extent
30
- * buffers.  Every pointer to metadata items in btrfs is really just
31
- * an unsigned long offset into the extent buffer which has been
32
- * cast to a specific type.  This gives us all the gcc type checking.
40
+ * Generic helpers with a token (cached address of the most recently accessed
41
+ * page):
42
+ * - btrfs_set_token_8 (for 8/16/32/64)
43
+ * - btrfs_get_token_8 (for 8/16/32/64)
33
44
  *
34
- * The extent buffer api is used to do the page spanning work required to
35
- * have a metadata blocksize different from the page size.
45
+ * The set/get functions handle data spanning two pages transparently, in case
46
+ * metadata block size is larger than page.  Every pointer to metadata items is
47
+ * an offset into the extent buffer page array, cast to a specific type.  This
48
+ * gives us all the type checking.
49
+ *
50
+ * The extent buffer pages stored in the array pages do not form a contiguous
51
+ * phyusical range, but the API functions assume the linear offset to the range
52
+ * from 0 to metadata node size.
36
53
  */
37
54
 
38
55
 #define DEFINE_BTRFS_SETGET_BITS(bits)					\
39
-u##bits btrfs_get_token_##bits(const struct extent_buffer *eb,		\
40
-			       const void *ptr, unsigned long off,	\
41
-			       struct btrfs_map_token *token)		\
56
+u##bits btrfs_get_token_##bits(struct btrfs_map_token *token,		\
57
+			       const void *ptr, unsigned long off)	\
42
58
 {									\
43
-	unsigned long part_offset = (unsigned long)ptr;			\
44
-	unsigned long offset = part_offset + off;			\
45
-	void *p;							\
46
-	int err;							\
47
-	char *kaddr;							\
48
-	unsigned long map_start;					\
49
-	unsigned long map_len;						\
50
-	int size = sizeof(u##bits);					\
51
-	u##bits res;							\
59
+	const unsigned long member_offset = (unsigned long)ptr + off;	\
60
+	const unsigned long idx = member_offset >> PAGE_SHIFT;		\
61
+	const unsigned long oip = offset_in_page(member_offset);	\
62
+	const int size = sizeof(u##bits);				\
63
+	u8 lebytes[sizeof(u##bits)];					\
64
+	const int part = PAGE_SIZE - oip;				\
52
65
 									\
53
-	if (token && token->kaddr && token->offset <= offset &&		\
54
-	    token->eb == eb &&						\
55
-	   (token->offset + PAGE_SIZE >= offset + size)) {	\
56
-		kaddr = token->kaddr;					\
57
-		p = kaddr + part_offset - token->offset;		\
58
-		res = get_unaligned_le##bits(p + off);			\
59
-		return res;						\
66
+	ASSERT(token);							\
67
+	ASSERT(token->kaddr);						\
68
+	ASSERT(check_setget_bounds(token->eb, ptr, off, size));		\
69
+	if (token->offset <= member_offset &&				\
70
+	    member_offset + size <= token->offset + PAGE_SIZE) {	\
71
+		return get_unaligned_le##bits(token->kaddr + oip);	\
60
72
 	}								\
61
-	err = map_private_extent_buffer(eb, offset, size,		\
62
-					&kaddr, &map_start, &map_len);	\
63
-	if (err) {							\
64
-		__le##bits leres;					\
73
+	token->kaddr = page_address(token->eb->pages[idx]);		\
74
+	token->offset = idx << PAGE_SHIFT;				\
75
+	if (oip + size <= PAGE_SIZE)					\
76
+		return get_unaligned_le##bits(token->kaddr + oip);	\
65
77
 									\
66
-		read_extent_buffer(eb, &leres, offset, size);		\
67
-		return le##bits##_to_cpu(leres);			\
68
-	}								\
69
-	p = kaddr + part_offset - map_start;				\
70
-	res = get_unaligned_le##bits(p + off);				\
71
-	if (token) {							\
72
-		token->kaddr = kaddr;					\
73
-		token->offset = map_start;				\
74
-		token->eb = eb;						\
75
-	}								\
76
-	return res;							\
78
+	memcpy(lebytes, token->kaddr + oip, part);			\
79
+	token->kaddr = page_address(token->eb->pages[idx + 1]);		\
80
+	token->offset = (idx + 1) << PAGE_SHIFT;			\
81
+	memcpy(lebytes + part, token->kaddr, size - part);		\
82
+	return get_unaligned_le##bits(lebytes);				\
77
83
 }									\
78
-void btrfs_set_token_##bits(struct extent_buffer *eb,			\
79
-			    const void *ptr, unsigned long off,		\
80
-			    u##bits val,				\
81
-			    struct btrfs_map_token *token)		\
84
+u##bits btrfs_get_##bits(const struct extent_buffer *eb,		\
85
+			 const void *ptr, unsigned long off)		\
82
86
 {									\
83
-	unsigned long part_offset = (unsigned long)ptr;			\
84
-	unsigned long offset = part_offset + off;			\
85
-	void *p;							\
86
-	int err;							\
87
-	char *kaddr;							\
88
-	unsigned long map_start;					\
89
-	unsigned long map_len;						\
90
-	int size = sizeof(u##bits);					\
87
+	const unsigned long member_offset = (unsigned long)ptr + off;	\
88
+	const unsigned long oip = offset_in_page(member_offset);	\
89
+	const unsigned long idx = member_offset >> PAGE_SHIFT;		\
90
+	char *kaddr = page_address(eb->pages[idx]);			\
91
+	const int size = sizeof(u##bits);				\
92
+	const int part = PAGE_SIZE - oip;				\
93
+	u8 lebytes[sizeof(u##bits)];					\
91
94
 									\
92
-	if (token && token->kaddr && token->offset <= offset &&		\
93
-	    token->eb == eb &&						\
94
-	   (token->offset + PAGE_SIZE >= offset + size)) {	\
95
-		kaddr = token->kaddr;					\
96
-		p = kaddr + part_offset - token->offset;		\
97
-		put_unaligned_le##bits(val, p + off);			\
95
+	ASSERT(check_setget_bounds(eb, ptr, off, size));		\
96
+	if (oip + size <= PAGE_SIZE)					\
97
+		return get_unaligned_le##bits(kaddr + oip);		\
98
+									\
99
+	memcpy(lebytes, kaddr + oip, part);				\
100
+	kaddr = page_address(eb->pages[idx + 1]);			\
101
+	memcpy(lebytes + part, kaddr, size - part);			\
102
+	return get_unaligned_le##bits(lebytes);				\
103
+}									\
104
+void btrfs_set_token_##bits(struct btrfs_map_token *token,		\
105
+			    const void *ptr, unsigned long off,		\
106
+			    u##bits val)				\
107
+{									\
108
+	const unsigned long member_offset = (unsigned long)ptr + off;	\
109
+	const unsigned long idx = member_offset >> PAGE_SHIFT;		\
110
+	const unsigned long oip = offset_in_page(member_offset);	\
111
+	const int size = sizeof(u##bits);				\
112
+	u8 lebytes[sizeof(u##bits)];					\
113
+	const int part = PAGE_SIZE - oip;				\
114
+									\
115
+	ASSERT(token);							\
116
+	ASSERT(token->kaddr);						\
117
+	ASSERT(check_setget_bounds(token->eb, ptr, off, size));		\
118
+	if (token->offset <= member_offset &&				\
119
+	    member_offset + size <= token->offset + PAGE_SIZE) {	\
120
+		put_unaligned_le##bits(val, token->kaddr + oip);	\
98
121
 		return;							\
99
122
 	}								\
100
-	err = map_private_extent_buffer(eb, offset, size,		\
101
-			&kaddr, &map_start, &map_len);			\
102
-	if (err) {							\
103
-		__le##bits val2;					\
104
-									\
105
-		val2 = cpu_to_le##bits(val);				\
106
-		write_extent_buffer(eb, &val2, offset, size);		\
123
+	token->kaddr = page_address(token->eb->pages[idx]);		\
124
+	token->offset = idx << PAGE_SHIFT;				\
125
+	if (oip + size <= PAGE_SIZE) {					\
126
+		put_unaligned_le##bits(val, token->kaddr + oip);	\
107
127
 		return;							\
108
128
 	}								\
109
-	p = kaddr + part_offset - map_start;				\
110
-	put_unaligned_le##bits(val, p + off);				\
111
-	if (token) {							\
112
-		token->kaddr = kaddr;					\
113
-		token->offset = map_start;				\
114
-		token->eb = eb;						\
129
+	put_unaligned_le##bits(val, lebytes);				\
130
+	memcpy(token->kaddr + oip, lebytes, part);			\
131
+	token->kaddr = page_address(token->eb->pages[idx + 1]);		\
132
+	token->offset = (idx + 1) << PAGE_SHIFT;			\
133
+	memcpy(token->kaddr, lebytes + part, size - part);		\
134
+}									\
135
+void btrfs_set_##bits(const struct extent_buffer *eb, void *ptr,	\
136
+		      unsigned long off, u##bits val)			\
137
+{									\
138
+	const unsigned long member_offset = (unsigned long)ptr + off;	\
139
+	const unsigned long oip = offset_in_page(member_offset);	\
140
+	const unsigned long idx = member_offset >> PAGE_SHIFT;		\
141
+	char *kaddr = page_address(eb->pages[idx]);			\
142
+	const int size = sizeof(u##bits);				\
143
+	const int part = PAGE_SIZE - oip;				\
144
+	u8 lebytes[sizeof(u##bits)];					\
145
+									\
146
+	ASSERT(check_setget_bounds(eb, ptr, off, size));		\
147
+	if (oip + size <= PAGE_SIZE) {					\
148
+		put_unaligned_le##bits(val, kaddr + oip);		\
149
+		return;							\
115
150
 	}								\
151
+									\
152
+	put_unaligned_le##bits(val, lebytes);				\
153
+	memcpy(kaddr + oip, lebytes, part);				\
154
+	kaddr = page_address(eb->pages[idx + 1]);			\
155
+	memcpy(kaddr, lebytes + part, size - part);			\
116
156
 }
117
157
 
118
158
 DEFINE_BTRFS_SETGET_BITS(8)