add new system file

hc

2024-02-20 102a0743326a03cd1a1202ceda21e175b7d3575c

 kernel/fs/xfs/scrub/bitmap.c
..
..
@@ -10,11 +10,6 @@
10
10
 #include "xfs_trans_resv.h"
11
11
 #include "xfs_mount.h"
12
12
 #include "xfs_btree.h"
13
-#include "scrub/xfs_scrub.h"
14
-#include "scrub/scrub.h"
15
-#include "scrub/common.h"
16
-#include "scrub/trace.h"
17
-#include "scrub/repair.h"
18
13
 #include "scrub/bitmap.h"
19
14
 
20
15
 /*
..
..
@@ -23,14 +18,14 @@
23
18
  * This is the logical equivalent of bitmap |= mask(start, len).
24
19
  */
25
20
 int
26
-xfs_bitmap_set(
27
-	struct xfs_bitmap	*bitmap,
21
+xbitmap_set(
22
+	struct xbitmap		*bitmap,
28
23
 	uint64_t		start,
29
24
 	uint64_t		len)
30
25
 {
31
-	struct xfs_bitmap_range	*bmr;
26
+	struct xbitmap_range	*bmr;
32
27
 
33
-	bmr = kmem_alloc(sizeof(struct xfs_bitmap_range), KM_MAYFAIL);
28
+	bmr = kmem_alloc(sizeof(struct xbitmap_range), KM_MAYFAIL);
34
29
 	if (!bmr)
35
30
 		return -ENOMEM;
36
31
 
..
..
@@ -44,13 +39,13 @@
44
39
 
45
40
 /* Free everything related to this bitmap. */
46
41
 void
47
-xfs_bitmap_destroy(
48
-	struct xfs_bitmap	*bitmap)
42
+xbitmap_destroy(
43
+	struct xbitmap		*bitmap)
49
44
 {
50
-	struct xfs_bitmap_range	*bmr;
51
-	struct xfs_bitmap_range	*n;
45
+	struct xbitmap_range	*bmr;
46
+	struct xbitmap_range	*n;
52
47
 
53
-	for_each_xfs_bitmap_extent(bmr, n, bitmap) {
48
+	for_each_xbitmap_extent(bmr, n, bitmap) {
54
49
 		list_del(&bmr->list);
55
50
 		kmem_free(bmr);
56
51
 	}
..
..
@@ -58,24 +53,24 @@
58
53
 
59
54
 /* Set up a per-AG block bitmap. */
60
55
 void
61
-xfs_bitmap_init(
62
-	struct xfs_bitmap	*bitmap)
56
+xbitmap_init(
57
+	struct xbitmap		*bitmap)
63
58
 {
64
59
 	INIT_LIST_HEAD(&bitmap->list);
65
60
 }
66
61
 
67
62
 /* Compare two btree extents. */
68
63
 static int
69
-xfs_bitmap_range_cmp(
64
+xbitmap_range_cmp(
70
65
 	void			*priv,
71
66
 	struct list_head	*a,
72
67
 	struct list_head	*b)
73
68
 {
74
-	struct xfs_bitmap_range	*ap;
75
-	struct xfs_bitmap_range	*bp;
69
+	struct xbitmap_range	*ap;
70
+	struct xbitmap_range	*bp;
76
71
 
77
-	ap = container_of(a, struct xfs_bitmap_range, list);
78
-	bp = container_of(b, struct xfs_bitmap_range, list);
72
+	ap = container_of(a, struct xbitmap_range, list);
73
+	bp = container_of(b, struct xbitmap_range, list);
79
74
 
80
75
 	if (ap->start > bp->start)
81
76
 		return 1;
..
..
@@ -101,14 +96,14 @@
101
96
 #define LEFT_ALIGNED	(1 << 0)
102
97
 #define RIGHT_ALIGNED	(1 << 1)
103
98
 int
104
-xfs_bitmap_disunion(
105
-	struct xfs_bitmap	*bitmap,
106
-	struct xfs_bitmap	*sub)
99
+xbitmap_disunion(
100
+	struct xbitmap		*bitmap,
101
+	struct xbitmap		*sub)
107
102
 {
108
103
 	struct list_head	*lp;
109
-	struct xfs_bitmap_range	*br;
110
-	struct xfs_bitmap_range	*new_br;
111
-	struct xfs_bitmap_range	*sub_br;
104
+	struct xbitmap_range	*br;
105
+	struct xbitmap_range	*new_br;
106
+	struct xbitmap_range	*sub_br;
112
107
 	uint64_t		sub_start;
113
108
 	uint64_t		sub_len;
114
109
 	int			state;
..
..
@@ -118,8 +113,8 @@
118
113
 		return 0;
119
114
 	ASSERT(!list_empty(&sub->list));
120
115
 
121
-	list_sort(NULL, &bitmap->list, xfs_bitmap_range_cmp);
122
-	list_sort(NULL, &sub->list, xfs_bitmap_range_cmp);
116
+	list_sort(NULL, &bitmap->list, xbitmap_range_cmp);
117
+	list_sort(NULL, &sub->list, xbitmap_range_cmp);
123
118
 
124
119
 	/*
125
120
 	 * Now that we've sorted both lists, we iterate bitmap once, rolling
..
..
@@ -129,11 +124,11 @@
129
124
 	 * list traversal is similar to merge sort, but we're deleting
130
125
 	 * instead.  In this manner we avoid O(n^2) operations.
131
126
 	 */
132
-	sub_br = list_first_entry(&sub->list, struct xfs_bitmap_range,
127
+	sub_br = list_first_entry(&sub->list, struct xbitmap_range,
133
128
 			list);
134
129
 	lp = bitmap->list.next;
135
130
 	while (lp != &bitmap->list) {
136
-		br = list_entry(lp, struct xfs_bitmap_range, list);
131
+		br = list_entry(lp, struct xbitmap_range, list);
137
132
 
138
133
 		/*
139
134
 		 * Advance sub_br and/or br until we find a pair that
..
..
@@ -186,7 +181,7 @@
186
181
 			 * Deleting from the middle: add the new right extent
187
182
 			 * and then shrink the left extent.
188
183
 			 */
189
-			new_br = kmem_alloc(sizeof(struct xfs_bitmap_range),
184
+			new_br = kmem_alloc(sizeof(struct xbitmap_range),
190
185
 					KM_MAYFAIL);
191
186
 			if (!new_br) {
192
187
 				error = -ENOMEM;
..
..
@@ -252,8 +247,8 @@
252
247
  * blocks going from the leaf towards the root.
253
248
  */
254
249
 int
255
-xfs_bitmap_set_btcur_path(
256
-	struct xfs_bitmap	*bitmap,
250
+xbitmap_set_btcur_path(
251
+	struct xbitmap		*bitmap,
257
252
 	struct xfs_btree_cur	*cur)
258
253
 {
259
254
 	struct xfs_buf		*bp;
..
..
@@ -266,7 +261,7 @@
266
261
 		if (!bp)
267
262
 			continue;
268
263
 		fsb = XFS_DADDR_TO_FSB(cur->bc_mp, bp->b_bn);
269
-		error = xfs_bitmap_set(bitmap, fsb, 1);
264
+		error = xbitmap_set(bitmap, fsb, 1);
270
265
 		if (error)
271
266
 			return error;
272
267
 	}
..
..
@@ -276,12 +271,12 @@
276
271
 
277
272
 /* Collect a btree's block in the bitmap. */
278
273
 STATIC int
279
-xfs_bitmap_collect_btblock(
274
+xbitmap_collect_btblock(
280
275
 	struct xfs_btree_cur	*cur,
281
276
 	int			level,
282
277
 	void			*priv)
283
278
 {
284
-	struct xfs_bitmap	*bitmap = priv;
279
+	struct xbitmap		*bitmap = priv;
285
280
 	struct xfs_buf		*bp;
286
281
 	xfs_fsblock_t		fsbno;
287
282
 
..
..
@@ -290,14 +285,30 @@
290
285
 		return 0;
291
286
 
292
287
 	fsbno = XFS_DADDR_TO_FSB(cur->bc_mp, bp->b_bn);
293
-	return xfs_bitmap_set(bitmap, fsbno, 1);
288
+	return xbitmap_set(bitmap, fsbno, 1);
294
289
 }
295
290
 
296
291
 /* Walk the btree and mark the bitmap wherever a btree block is found. */
297
292
 int
298
-xfs_bitmap_set_btblocks(
299
-	struct xfs_bitmap	*bitmap,
293
+xbitmap_set_btblocks(
294
+	struct xbitmap		*bitmap,
300
295
 	struct xfs_btree_cur	*cur)
301
296
 {
302
-	return xfs_btree_visit_blocks(cur, xfs_bitmap_collect_btblock, bitmap);
297
+	return xfs_btree_visit_blocks(cur, xbitmap_collect_btblock,
298
+			XFS_BTREE_VISIT_ALL, bitmap);
299
+}
300
+
301
+/* How many bits are set in this bitmap? */
302
+uint64_t
303
+xbitmap_hweight(
304
+	struct xbitmap		*bitmap)
305
+{
306
+	struct xbitmap_range	*bmr;
307
+	struct xbitmap_range	*n;
308
+	uint64_t		ret = 0;
309
+
310
+	for_each_xbitmap_extent(bmr, n, bitmap)
311
+		ret += bmr->len;
312
+
313
+	return ret;
303
314
 }