write in 30M

hc

2024-02-20 ea08eeccae9297f7aabd2ef7f0c2517ac4549acc

 kernel/lib/find_bit.c
..
..
@@ -1,3 +1,4 @@
1
+// SPDX-License-Identifier: GPL-2.0-or-later
1
2
 /* bit search implementation
2
3
  *
3
4
  * Copyright (C) 2004 Red Hat, Inc. All Rights Reserved.
..
..
@@ -9,21 +10,17 @@
9
10
  *
10
11
  * Rewritten by Yury Norov <yury.norov@gmail.com> to decrease
11
12
  * size and improve performance, 2015.
12
- *
13
- * This program is free software; you can redistribute it and/or
14
- * modify it under the terms of the GNU General Public License
15
- * as published by the Free Software Foundation; either version
16
- * 2 of the License, or (at your option) any later version.
17
13
  */
18
14
 
19
15
 #include <linux/bitops.h>
20
16
 #include <linux/bitmap.h>
21
17
 #include <linux/export.h>
22
18
 #include <linux/kernel.h>
19
+#include <linux/minmax.h>
23
20
 
24
-#if !defined(find_next_bit) || !defined(find_next_zero_bit) || \
25
-		!defined(find_next_and_bit)
26
-
21
+#if !defined(find_next_bit) || !defined(find_next_zero_bit) ||			\
22
+	!defined(find_next_bit_le) || !defined(find_next_zero_bit_le) ||	\
23
+	!defined(find_next_and_bit)
27
24
 /*
28
25
  * This is a common helper function for find_next_bit, find_next_zero_bit, and
29
26
  * find_next_and_bit. The differences are:
..
..
@@ -31,11 +28,11 @@
31
28
  *    searching it for one bits.
32
29
  *  - The optional "addr2", which is anded with "addr1" if present.
33
30
  */
34
-static inline unsigned long _find_next_bit(const unsigned long *addr1,
31
+static unsigned long _find_next_bit(const unsigned long *addr1,
35
32
 		const unsigned long *addr2, unsigned long nbits,
36
-		unsigned long start, unsigned long invert)
33
+		unsigned long start, unsigned long invert, unsigned long le)
37
34
 {
38
-	unsigned long tmp;
35
+	unsigned long tmp, mask;
39
36
 
40
37
 	if (unlikely(start >= nbits))
41
38
 		return nbits;
..
..
@@ -46,7 +43,12 @@
46
43
 	tmp ^= invert;
47
44
 
48
45
 	/* Handle 1st word. */
49
-	tmp &= BITMAP_FIRST_WORD_MASK(start);
46
+	mask = BITMAP_FIRST_WORD_MASK(start);
47
+	if (le)
48
+		mask = swab(mask);
49
+
50
+	tmp &= mask;
51
+
50
52
 	start = round_down(start, BITS_PER_LONG);
51
53
 
52
54
 	while (!tmp) {
..
..
@@ -60,6 +62,9 @@
60
62
 		tmp ^= invert;
61
63
 	}
62
64
 
65
+	if (le)
66
+		tmp = swab(tmp);
67
+
63
68
 	return min(start + __ffs(tmp), nbits);
64
69
 }
65
70
 #endif
..
..
@@ -71,7 +76,7 @@
71
76
 unsigned long find_next_bit(const unsigned long *addr, unsigned long size,
72
77
 			    unsigned long offset)
73
78
 {
74
-	return _find_next_bit(addr, NULL, size, offset, 0UL);
79
+	return _find_next_bit(addr, NULL, size, offset, 0UL, 0);
75
80
 }
76
81
 EXPORT_SYMBOL(find_next_bit);
77
82
 #endif
..
..
@@ -80,7 +85,7 @@
80
85
 unsigned long find_next_zero_bit(const unsigned long *addr, unsigned long size,
81
86
 				 unsigned long offset)
82
87
 {
83
-	return _find_next_bit(addr, NULL, size, offset, ~0UL);
88
+	return _find_next_bit(addr, NULL, size, offset, ~0UL, 0);
84
89
 }
85
90
 EXPORT_SYMBOL(find_next_zero_bit);
86
91
 #endif
..
..
@@ -90,7 +95,7 @@
90
95
 		const unsigned long *addr2, unsigned long size,
91
96
 		unsigned long offset)
92
97
 {
93
-	return _find_next_bit(addr1, addr2, size, offset, 0UL);
98
+	return _find_next_bit(addr1, addr2, size, offset, 0UL, 0);
94
99
 }
95
100
 EXPORT_SYMBOL(find_next_and_bit);
96
101
 #endif
..
..
@@ -153,45 +158,11 @@
153
158
 
154
159
 #ifdef __BIG_ENDIAN
155
160
 
156
-#if !defined(find_next_bit_le) || !defined(find_next_zero_bit_le)
157
-static inline unsigned long _find_next_bit_le(const unsigned long *addr1,
158
-		const unsigned long *addr2, unsigned long nbits,
159
-		unsigned long start, unsigned long invert)
160
-{
161
-	unsigned long tmp;
162
-
163
-	if (unlikely(start >= nbits))
164
-		return nbits;
165
-
166
-	tmp = addr1[start / BITS_PER_LONG];
167
-	if (addr2)
168
-		tmp &= addr2[start / BITS_PER_LONG];
169
-	tmp ^= invert;
170
-
171
-	/* Handle 1st word. */
172
-	tmp &= swab(BITMAP_FIRST_WORD_MASK(start));
173
-	start = round_down(start, BITS_PER_LONG);
174
-
175
-	while (!tmp) {
176
-		start += BITS_PER_LONG;
177
-		if (start >= nbits)
178
-			return nbits;
179
-
180
-		tmp = addr1[start / BITS_PER_LONG];
181
-		if (addr2)
182
-			tmp &= addr2[start / BITS_PER_LONG];
183
-		tmp ^= invert;
184
-	}
185
-
186
-	return min(start + __ffs(swab(tmp)), nbits);
187
-}
188
-#endif
189
-
190
161
 #ifndef find_next_zero_bit_le
191
162
 unsigned long find_next_zero_bit_le(const void *addr, unsigned
192
163
 		long size, unsigned long offset)
193
164
 {
194
-	return _find_next_bit_le(addr, NULL, size, offset, ~0UL);
165
+	return _find_next_bit(addr, NULL, size, offset, ~0UL, 1);
195
166
 }
196
167
 EXPORT_SYMBOL(find_next_zero_bit_le);
197
168
 #endif
..
..
@@ -200,9 +171,23 @@
200
171
 unsigned long find_next_bit_le(const void *addr, unsigned
201
172
 		long size, unsigned long offset)
202
173
 {
203
-	return _find_next_bit_le(addr, NULL, size, offset, 0UL);
174
+	return _find_next_bit(addr, NULL, size, offset, 0UL, 1);
204
175
 }
205
176
 EXPORT_SYMBOL(find_next_bit_le);
206
177
 #endif
207
178
 
208
179
 #endif /* __BIG_ENDIAN */
180
+
181
+unsigned long find_next_clump8(unsigned long *clump, const unsigned long *addr,
182
+			       unsigned long size, unsigned long offset)
183
+{
184
+	offset = find_next_bit(addr, size, offset);
185
+	if (offset == size)
186
+		return size;
187
+
188
+	offset = round_down(offset, 8);
189
+	*clump = bitmap_get_value8(addr, offset);
190
+
191
+	return offset;
192
+}
193
+EXPORT_SYMBOL(find_next_clump8);