移去rt

hc

2023-12-08 01573e231f18eb2d99162747186f59511f56b64d

 kernel/include/linux/cpumask.h
..
..
@@ -10,6 +10,7 @@
10
10
 #include <linux/kernel.h>
11
11
 #include <linux/threads.h>
12
12
 #include <linux/bitmap.h>
13
+#include <linux/atomic.h>
13
14
 #include <linux/bug.h>
14
15
 
15
16
 /* Don't assign or return these: may not be this big! */
..
..
@@ -95,8 +96,21 @@
95
96
 #define cpu_present_mask  ((const struct cpumask *)&__cpu_present_mask)
96
97
 #define cpu_active_mask   ((const struct cpumask *)&__cpu_active_mask)
97
98
 
99
+extern atomic_t __num_online_cpus;
100
+
98
101
 #if NR_CPUS > 1
99
-#define num_online_cpus()	cpumask_weight(cpu_online_mask)
102
+/**
103
+ * num_online_cpus() - Read the number of online CPUs
104
+ *
105
+ * Despite the fact that __num_online_cpus is of type atomic_t, this
106
+ * interface gives only a momentary snapshot and is not protected against
107
+ * concurrent CPU hotplug operations unless invoked from a cpuhp_lock held
108
+ * region.
109
+ */
110
+static inline unsigned int num_online_cpus(void)
111
+{
112
+	return atomic_read(&__num_online_cpus);
113
+}
100
114
 #define num_possible_cpus()	cpumask_weight(cpu_possible_mask)
101
115
 #define num_present_cpus()	cpumask_weight(cpu_present_mask)
102
116
 #define num_active_cpus()	cpumask_weight(cpu_active_mask)
..
..
@@ -114,6 +128,8 @@
114
128
 #define cpu_present(cpu)	((cpu) == 0)
115
129
 #define cpu_active(cpu)		((cpu) == 0)
116
130
 #endif
131
+
132
+extern cpumask_t cpus_booted_once_mask;
117
133
 
118
134
 static inline void cpu_max_bits_warn(unsigned int cpu, unsigned int bits)
119
135
 {
..
..
@@ -178,14 +194,24 @@
178
194
 	return 0;
179
195
 }
180
196
 
197
+static inline int cpumask_any_and_distribute(const struct cpumask *src1p,
198
+					     const struct cpumask *src2p) {
199
+	return cpumask_next_and(-1, src1p, src2p);
200
+}
201
+
202
+static inline int cpumask_any_distribute(const struct cpumask *srcp)
203
+{
204
+	return cpumask_first(srcp);
205
+}
206
+
181
207
 #define for_each_cpu(cpu, mask)			\
182
208
 	for ((cpu) = 0; (cpu) < 1; (cpu)++, (void)mask)
183
209
 #define for_each_cpu_not(cpu, mask)		\
184
210
 	for ((cpu) = 0; (cpu) < 1; (cpu)++, (void)mask)
185
211
 #define for_each_cpu_wrap(cpu, mask, start)	\
186
212
 	for ((cpu) = 0; (cpu) < 1; (cpu)++, (void)mask, (void)(start))
187
-#define for_each_cpu_and(cpu, mask, and)	\
188
-	for ((cpu) = 0; (cpu) < 1; (cpu)++, (void)mask, (void)and)
213
+#define for_each_cpu_and(cpu, mask1, mask2)	\
214
+	for ((cpu) = 0; (cpu) < 1; (cpu)++, (void)mask1, (void)mask2)
189
215
 #else
190
216
 /**
191
217
  * cpumask_first - get the first cpu in a cpumask
..
..
@@ -229,6 +255,9 @@
229
255
 int cpumask_next_and(int n, const struct cpumask *, const struct cpumask *);
230
256
 int cpumask_any_but(const struct cpumask *mask, unsigned int cpu);
231
257
 unsigned int cpumask_local_spread(unsigned int i, int node);
258
+int cpumask_any_and_distribute(const struct cpumask *src1p,
259
+			       const struct cpumask *src2p);
260
+int cpumask_any_distribute(const struct cpumask *srcp);
232
261
 
233
262
 /**
234
263
  * for_each_cpu - iterate over every cpu in a mask
..
..
@@ -274,20 +303,20 @@
274
303
 /**
275
304
  * for_each_cpu_and - iterate over every cpu in both masks
276
305
  * @cpu: the (optionally unsigned) integer iterator
277
- * @mask: the first cpumask pointer
278
- * @and: the second cpumask pointer
306
+ * @mask1: the first cpumask pointer
307
+ * @mask2: the second cpumask pointer
279
308
  *
280
309
  * This saves a temporary CPU mask in many places.  It is equivalent to:
281
310
  *	struct cpumask tmp;
282
- *	cpumask_and(&tmp, &mask, &and);
311
+ *	cpumask_and(&tmp, &mask1, &mask2);
283
312
  *	for_each_cpu(cpu, &tmp)
284
313
  *		...
285
314
  *
286
315
  * After the loop, cpu is >= nr_cpu_ids.
287
316
  */
288
-#define for_each_cpu_and(cpu, mask, and)				\
317
+#define for_each_cpu_and(cpu, mask1, mask2)				\
289
318
 	for ((cpu) = -1;						\
290
-		(cpu) = cpumask_next_and((cpu), (mask), (and)),		\
319
+		(cpu) = cpumask_next_and((cpu), (mask1), (mask2)),	\
291
320
 		(cpu) < nr_cpu_ids;)
292
321
 #endif /* SMP */
293
322
 
..
..
@@ -474,6 +503,20 @@
474
503
 }
475
504
 
476
505
 /**
506
+ * cpumask_or_equal - *src1p | *src2p == *src3p
507
+ * @src1p: the first input
508
+ * @src2p: the second input
509
+ * @src3p: the third input
510
+ */
511
+static inline bool cpumask_or_equal(const struct cpumask *src1p,
512
+				    const struct cpumask *src2p,
513
+				    const struct cpumask *src3p)
514
+{
515
+	return bitmap_or_equal(cpumask_bits(src1p), cpumask_bits(src2p),
516
+			       cpumask_bits(src3p), nr_cpumask_bits);
517
+}
518
+
519
+/**
477
520
  * cpumask_intersects - (*src1p & *src2p) != 0
478
521
  * @src1p: the first input
479
522
  * @src2p: the second input
..
..
@@ -633,10 +676,7 @@
633
676
  */
634
677
 static inline int cpumask_parse(const char *buf, struct cpumask *dstp)
635
678
 {
636
-	char *nl = strchr(buf, '\n');
637
-	unsigned int len = nl ? (unsigned int)(nl - buf) : strlen(buf);
638
-
639
-	return bitmap_parse(buf, len, cpumask_bits(dstp), nr_cpumask_bits);
679
+	return bitmap_parse(buf, UINT_MAX, cpumask_bits(dstp), nr_cpumask_bits);
640
680
 }
641
681
 
642
682
 /**
..
..
@@ -806,14 +846,7 @@
806
846
 		cpumask_clear_cpu(cpu, &__cpu_present_mask);
807
847
 }
808
848
 
809
-static inline void
810
-set_cpu_online(unsigned int cpu, bool online)
811
-{
812
-	if (online)
813
-		cpumask_set_cpu(cpu, &__cpu_online_mask);
814
-	else
815
-		cpumask_clear_cpu(cpu, &__cpu_online_mask);
816
-}
849
+void set_cpu_online(unsigned int cpu, bool online);
817
850
 
818
851
 static inline void
819
852
 set_cpu_active(unsigned int cpu, bool active)