Loading...
1// SPDX-License-Identifier: GPL-2.0
2// Copyright (C) 2017 Thomas Gleixner <tglx@linutronix.de>
3
4#include <linux/spinlock.h>
5#include <linux/seq_file.h>
6#include <linux/bitmap.h>
7#include <linux/percpu.h>
8#include <linux/cpu.h>
9#include <linux/irq.h>
10
11#define IRQ_MATRIX_SIZE (BITS_TO_LONGS(IRQ_MATRIX_BITS) * sizeof(unsigned long))
12
13struct cpumap {
14 unsigned int available;
15 unsigned int allocated;
16 unsigned int managed;
17 bool initialized;
18 bool online;
19 unsigned long alloc_map[IRQ_MATRIX_SIZE];
20 unsigned long managed_map[IRQ_MATRIX_SIZE];
21};
22
23struct irq_matrix {
24 unsigned int matrix_bits;
25 unsigned int alloc_start;
26 unsigned int alloc_end;
27 unsigned int alloc_size;
28 unsigned int global_available;
29 unsigned int global_reserved;
30 unsigned int systembits_inalloc;
31 unsigned int total_allocated;
32 unsigned int online_maps;
33 struct cpumap __percpu *maps;
34 unsigned long scratch_map[IRQ_MATRIX_SIZE];
35 unsigned long system_map[IRQ_MATRIX_SIZE];
36};
37
38#define CREATE_TRACE_POINTS
39#include <trace/events/irq_matrix.h>
40
41/**
42 * irq_alloc_matrix - Allocate a irq_matrix structure and initialize it
43 * @matrix_bits: Number of matrix bits must be <= IRQ_MATRIX_BITS
44 * @alloc_start: From which bit the allocation search starts
45 * @alloc_end: At which bit the allocation search ends, i.e first
46 * invalid bit
47 */
48__init struct irq_matrix *irq_alloc_matrix(unsigned int matrix_bits,
49 unsigned int alloc_start,
50 unsigned int alloc_end)
51{
52 struct irq_matrix *m;
53
54 if (matrix_bits > IRQ_MATRIX_BITS)
55 return NULL;
56
57 m = kzalloc(sizeof(*m), GFP_KERNEL);
58 if (!m)
59 return NULL;
60
61 m->matrix_bits = matrix_bits;
62 m->alloc_start = alloc_start;
63 m->alloc_end = alloc_end;
64 m->alloc_size = alloc_end - alloc_start;
65 m->maps = alloc_percpu(*m->maps);
66 if (!m->maps) {
67 kfree(m);
68 return NULL;
69 }
70 return m;
71}
72
73/**
74 * irq_matrix_online - Bring the local CPU matrix online
75 * @m: Matrix pointer
76 */
77void irq_matrix_online(struct irq_matrix *m)
78{
79 struct cpumap *cm = this_cpu_ptr(m->maps);
80
81 BUG_ON(cm->online);
82
83 if (!cm->initialized) {
84 cm->available = m->alloc_size;
85 cm->available -= cm->managed + m->systembits_inalloc;
86 cm->initialized = true;
87 }
88 m->global_available += cm->available;
89 cm->online = true;
90 m->online_maps++;
91 trace_irq_matrix_online(m);
92}
93
94/**
95 * irq_matrix_offline - Bring the local CPU matrix offline
96 * @m: Matrix pointer
97 */
98void irq_matrix_offline(struct irq_matrix *m)
99{
100 struct cpumap *cm = this_cpu_ptr(m->maps);
101
102 /* Update the global available size */
103 m->global_available -= cm->available;
104 cm->online = false;
105 m->online_maps--;
106 trace_irq_matrix_offline(m);
107}
108
109static unsigned int matrix_alloc_area(struct irq_matrix *m, struct cpumap *cm,
110 unsigned int num, bool managed)
111{
112 unsigned int area, start = m->alloc_start;
113 unsigned int end = m->alloc_end;
114
115 bitmap_or(m->scratch_map, cm->managed_map, m->system_map, end);
116 bitmap_or(m->scratch_map, m->scratch_map, cm->alloc_map, end);
117 area = bitmap_find_next_zero_area(m->scratch_map, end, start, num, 0);
118 if (area >= end)
119 return area;
120 if (managed)
121 bitmap_set(cm->managed_map, area, num);
122 else
123 bitmap_set(cm->alloc_map, area, num);
124 return area;
125}
126
127/**
128 * irq_matrix_assign_system - Assign system wide entry in the matrix
129 * @m: Matrix pointer
130 * @bit: Which bit to reserve
131 * @replace: Replace an already allocated vector with a system
132 * vector at the same bit position.
133 *
134 * The BUG_ON()s below are on purpose. If this goes wrong in the
135 * early boot process, then the chance to survive is about zero.
136 * If this happens when the system is life, it's not much better.
137 */
138void irq_matrix_assign_system(struct irq_matrix *m, unsigned int bit,
139 bool replace)
140{
141 struct cpumap *cm = this_cpu_ptr(m->maps);
142
143 BUG_ON(bit > m->matrix_bits);
144 BUG_ON(m->online_maps > 1 || (m->online_maps && !replace));
145
146 set_bit(bit, m->system_map);
147 if (replace) {
148 BUG_ON(!test_and_clear_bit(bit, cm->alloc_map));
149 cm->allocated--;
150 m->total_allocated--;
151 }
152 if (bit >= m->alloc_start && bit < m->alloc_end)
153 m->systembits_inalloc++;
154
155 trace_irq_matrix_assign_system(bit, m);
156}
157
158/**
159 * irq_matrix_reserve_managed - Reserve a managed interrupt in a CPU map
160 * @m: Matrix pointer
161 * @msk: On which CPUs the bits should be reserved.
162 *
163 * Can be called for offline CPUs. Note, this will only reserve one bit
164 * on all CPUs in @msk, but it's not guaranteed that the bits are at the
165 * same offset on all CPUs
166 */
167int irq_matrix_reserve_managed(struct irq_matrix *m, const struct cpumask *msk)
168{
169 unsigned int cpu, failed_cpu;
170
171 for_each_cpu(cpu, msk) {
172 struct cpumap *cm = per_cpu_ptr(m->maps, cpu);
173 unsigned int bit;
174
175 bit = matrix_alloc_area(m, cm, 1, true);
176 if (bit >= m->alloc_end)
177 goto cleanup;
178 cm->managed++;
179 if (cm->online) {
180 cm->available--;
181 m->global_available--;
182 }
183 trace_irq_matrix_reserve_managed(bit, cpu, m, cm);
184 }
185 return 0;
186cleanup:
187 failed_cpu = cpu;
188 for_each_cpu(cpu, msk) {
189 if (cpu == failed_cpu)
190 break;
191 irq_matrix_remove_managed(m, cpumask_of(cpu));
192 }
193 return -ENOSPC;
194}
195
196/**
197 * irq_matrix_remove_managed - Remove managed interrupts in a CPU map
198 * @m: Matrix pointer
199 * @msk: On which CPUs the bits should be removed
200 *
201 * Can be called for offline CPUs
202 *
203 * This removes not allocated managed interrupts from the map. It does
204 * not matter which one because the managed interrupts free their
205 * allocation when they shut down. If not, the accounting is screwed,
206 * but all what can be done at this point is warn about it.
207 */
208void irq_matrix_remove_managed(struct irq_matrix *m, const struct cpumask *msk)
209{
210 unsigned int cpu;
211
212 for_each_cpu(cpu, msk) {
213 struct cpumap *cm = per_cpu_ptr(m->maps, cpu);
214 unsigned int bit, end = m->alloc_end;
215
216 if (WARN_ON_ONCE(!cm->managed))
217 continue;
218
219 /* Get managed bit which are not allocated */
220 bitmap_andnot(m->scratch_map, cm->managed_map, cm->alloc_map, end);
221
222 bit = find_first_bit(m->scratch_map, end);
223 if (WARN_ON_ONCE(bit >= end))
224 continue;
225
226 clear_bit(bit, cm->managed_map);
227
228 cm->managed--;
229 if (cm->online) {
230 cm->available++;
231 m->global_available++;
232 }
233 trace_irq_matrix_remove_managed(bit, cpu, m, cm);
234 }
235}
236
237/**
238 * irq_matrix_alloc_managed - Allocate a managed interrupt in a CPU map
239 * @m: Matrix pointer
240 * @cpu: On which CPU the interrupt should be allocated
241 */
242int irq_matrix_alloc_managed(struct irq_matrix *m, unsigned int cpu)
243{
244 struct cpumap *cm = per_cpu_ptr(m->maps, cpu);
245 unsigned int bit, end = m->alloc_end;
246
247 /* Get managed bit which are not allocated */
248 bitmap_andnot(m->scratch_map, cm->managed_map, cm->alloc_map, end);
249 bit = find_first_bit(m->scratch_map, end);
250 if (bit >= end)
251 return -ENOSPC;
252 set_bit(bit, cm->alloc_map);
253 cm->allocated++;
254 m->total_allocated++;
255 trace_irq_matrix_alloc_managed(bit, cpu, m, cm);
256 return bit;
257}
258
259/**
260 * irq_matrix_assign - Assign a preallocated interrupt in the local CPU map
261 * @m: Matrix pointer
262 * @bit: Which bit to mark
263 *
264 * This should only be used to mark preallocated vectors
265 */
266void irq_matrix_assign(struct irq_matrix *m, unsigned int bit)
267{
268 struct cpumap *cm = this_cpu_ptr(m->maps);
269
270 if (WARN_ON_ONCE(bit < m->alloc_start || bit >= m->alloc_end))
271 return;
272 if (WARN_ON_ONCE(test_and_set_bit(bit, cm->alloc_map)))
273 return;
274 cm->allocated++;
275 m->total_allocated++;
276 cm->available--;
277 m->global_available--;
278 trace_irq_matrix_assign(bit, smp_processor_id(), m, cm);
279}
280
281/**
282 * irq_matrix_reserve - Reserve interrupts
283 * @m: Matrix pointer
284 *
285 * This is merily a book keeping call. It increments the number of globally
286 * reserved interrupt bits w/o actually allocating them. This allows to
287 * setup interrupt descriptors w/o assigning low level resources to it.
288 * The actual allocation happens when the interrupt gets activated.
289 */
290void irq_matrix_reserve(struct irq_matrix *m)
291{
292 if (m->global_reserved <= m->global_available &&
293 m->global_reserved + 1 > m->global_available)
294 pr_warn("Interrupt reservation exceeds available resources\n");
295
296 m->global_reserved++;
297 trace_irq_matrix_reserve(m);
298}
299
300/**
301 * irq_matrix_remove_reserved - Remove interrupt reservation
302 * @m: Matrix pointer
303 *
304 * This is merily a book keeping call. It decrements the number of globally
305 * reserved interrupt bits. This is used to undo irq_matrix_reserve() when the
306 * interrupt was never in use and a real vector allocated, which undid the
307 * reservation.
308 */
309void irq_matrix_remove_reserved(struct irq_matrix *m)
310{
311 m->global_reserved--;
312 trace_irq_matrix_remove_reserved(m);
313}
314
315/**
316 * irq_matrix_alloc - Allocate a regular interrupt in a CPU map
317 * @m: Matrix pointer
318 * @msk: Which CPUs to search in
319 * @reserved: Allocate previously reserved interrupts
320 * @mapped_cpu: Pointer to store the CPU for which the irq was allocated
321 */
322int irq_matrix_alloc(struct irq_matrix *m, const struct cpumask *msk,
323 bool reserved, unsigned int *mapped_cpu)
324{
325 unsigned int cpu, best_cpu, maxavl = 0;
326 struct cpumap *cm;
327 unsigned int bit;
328
329 best_cpu = UINT_MAX;
330 for_each_cpu(cpu, msk) {
331 cm = per_cpu_ptr(m->maps, cpu);
332
333 if (!cm->online || cm->available <= maxavl)
334 continue;
335
336 best_cpu = cpu;
337 maxavl = cm->available;
338 }
339
340 if (maxavl) {
341 cm = per_cpu_ptr(m->maps, best_cpu);
342 bit = matrix_alloc_area(m, cm, 1, false);
343 if (bit < m->alloc_end) {
344 cm->allocated++;
345 cm->available--;
346 m->total_allocated++;
347 m->global_available--;
348 if (reserved)
349 m->global_reserved--;
350 *mapped_cpu = best_cpu;
351 trace_irq_matrix_alloc(bit, best_cpu, m, cm);
352 return bit;
353 }
354 }
355 return -ENOSPC;
356}
357
358/**
359 * irq_matrix_free - Free allocated interrupt in the matrix
360 * @m: Matrix pointer
361 * @cpu: Which CPU map needs be updated
362 * @bit: The bit to remove
363 * @managed: If true, the interrupt is managed and not accounted
364 * as available.
365 */
366void irq_matrix_free(struct irq_matrix *m, unsigned int cpu,
367 unsigned int bit, bool managed)
368{
369 struct cpumap *cm = per_cpu_ptr(m->maps, cpu);
370
371 if (WARN_ON_ONCE(bit < m->alloc_start || bit >= m->alloc_end))
372 return;
373
374 clear_bit(bit, cm->alloc_map);
375 cm->allocated--;
376
377 if (cm->online)
378 m->total_allocated--;
379
380 if (!managed) {
381 cm->available++;
382 if (cm->online)
383 m->global_available++;
384 }
385 trace_irq_matrix_free(bit, cpu, m, cm);
386}
387
388/**
389 * irq_matrix_available - Get the number of globally available irqs
390 * @m: Pointer to the matrix to query
391 * @cpudown: If true, the local CPU is about to go down, adjust
392 * the number of available irqs accordingly
393 */
394unsigned int irq_matrix_available(struct irq_matrix *m, bool cpudown)
395{
396 struct cpumap *cm = this_cpu_ptr(m->maps);
397
398 if (!cpudown)
399 return m->global_available;
400 return m->global_available - cm->available;
401}
402
403/**
404 * irq_matrix_reserved - Get the number of globally reserved irqs
405 * @m: Pointer to the matrix to query
406 */
407unsigned int irq_matrix_reserved(struct irq_matrix *m)
408{
409 return m->global_reserved;
410}
411
412/**
413 * irq_matrix_allocated - Get the number of allocated irqs on the local cpu
414 * @m: Pointer to the matrix to search
415 *
416 * This returns number of allocated irqs
417 */
418unsigned int irq_matrix_allocated(struct irq_matrix *m)
419{
420 struct cpumap *cm = this_cpu_ptr(m->maps);
421
422 return cm->allocated;
423}
424
425#ifdef CONFIG_GENERIC_IRQ_DEBUGFS
426/**
427 * irq_matrix_debug_show - Show detailed allocation information
428 * @sf: Pointer to the seq_file to print to
429 * @m: Pointer to the matrix allocator
430 * @ind: Indentation for the print format
431 *
432 * Note, this is a lockless snapshot.
433 */
434void irq_matrix_debug_show(struct seq_file *sf, struct irq_matrix *m, int ind)
435{
436 unsigned int nsys = bitmap_weight(m->system_map, m->matrix_bits);
437 int cpu;
438
439 seq_printf(sf, "Online bitmaps: %6u\n", m->online_maps);
440 seq_printf(sf, "Global available: %6u\n", m->global_available);
441 seq_printf(sf, "Global reserved: %6u\n", m->global_reserved);
442 seq_printf(sf, "Total allocated: %6u\n", m->total_allocated);
443 seq_printf(sf, "System: %u: %*pbl\n", nsys, m->matrix_bits,
444 m->system_map);
445 seq_printf(sf, "%*s| CPU | avl | man | act | vectors\n", ind, " ");
446 cpus_read_lock();
447 for_each_online_cpu(cpu) {
448 struct cpumap *cm = per_cpu_ptr(m->maps, cpu);
449
450 seq_printf(sf, "%*s %4d %4u %4u %4u %*pbl\n", ind, " ",
451 cpu, cm->available, cm->managed, cm->allocated,
452 m->matrix_bits, cm->alloc_map);
453 }
454 cpus_read_unlock();
455}
456#endif
1// SPDX-License-Identifier: GPL-2.0
2// Copyright (C) 2017 Thomas Gleixner <tglx@linutronix.de>
3
4#include <linux/spinlock.h>
5#include <linux/seq_file.h>
6#include <linux/bitmap.h>
7#include <linux/percpu.h>
8#include <linux/cpu.h>
9#include <linux/irq.h>
10
11struct cpumap {
12 unsigned int available;
13 unsigned int allocated;
14 unsigned int managed;
15 unsigned int managed_allocated;
16 bool initialized;
17 bool online;
18 unsigned long *managed_map;
19 unsigned long alloc_map[];
20};
21
22struct irq_matrix {
23 unsigned int matrix_bits;
24 unsigned int alloc_start;
25 unsigned int alloc_end;
26 unsigned int alloc_size;
27 unsigned int global_available;
28 unsigned int global_reserved;
29 unsigned int systembits_inalloc;
30 unsigned int total_allocated;
31 unsigned int online_maps;
32 struct cpumap __percpu *maps;
33 unsigned long *system_map;
34 unsigned long scratch_map[];
35};
36
37#define CREATE_TRACE_POINTS
38#include <trace/events/irq_matrix.h>
39
40/**
41 * irq_alloc_matrix - Allocate a irq_matrix structure and initialize it
42 * @matrix_bits: Number of matrix bits must be <= IRQ_MATRIX_BITS
43 * @alloc_start: From which bit the allocation search starts
44 * @alloc_end: At which bit the allocation search ends, i.e first
45 * invalid bit
46 */
47__init struct irq_matrix *irq_alloc_matrix(unsigned int matrix_bits,
48 unsigned int alloc_start,
49 unsigned int alloc_end)
50{
51 unsigned int cpu, matrix_size = BITS_TO_LONGS(matrix_bits);
52 struct irq_matrix *m;
53
54 m = kzalloc(struct_size(m, scratch_map, matrix_size * 2), GFP_KERNEL);
55 if (!m)
56 return NULL;
57
58 m->system_map = &m->scratch_map[matrix_size];
59
60 m->matrix_bits = matrix_bits;
61 m->alloc_start = alloc_start;
62 m->alloc_end = alloc_end;
63 m->alloc_size = alloc_end - alloc_start;
64 m->maps = __alloc_percpu(struct_size(m->maps, alloc_map, matrix_size * 2),
65 __alignof__(*m->maps));
66 if (!m->maps) {
67 kfree(m);
68 return NULL;
69 }
70
71 for_each_possible_cpu(cpu) {
72 struct cpumap *cm = per_cpu_ptr(m->maps, cpu);
73
74 cm->managed_map = &cm->alloc_map[matrix_size];
75 }
76
77 return m;
78}
79
80/**
81 * irq_matrix_online - Bring the local CPU matrix online
82 * @m: Matrix pointer
83 */
84void irq_matrix_online(struct irq_matrix *m)
85{
86 struct cpumap *cm = this_cpu_ptr(m->maps);
87
88 BUG_ON(cm->online);
89
90 if (!cm->initialized) {
91 cm->available = m->alloc_size;
92 cm->available -= cm->managed + m->systembits_inalloc;
93 cm->initialized = true;
94 }
95 m->global_available += cm->available;
96 cm->online = true;
97 m->online_maps++;
98 trace_irq_matrix_online(m);
99}
100
101/**
102 * irq_matrix_offline - Bring the local CPU matrix offline
103 * @m: Matrix pointer
104 */
105void irq_matrix_offline(struct irq_matrix *m)
106{
107 struct cpumap *cm = this_cpu_ptr(m->maps);
108
109 /* Update the global available size */
110 m->global_available -= cm->available;
111 cm->online = false;
112 m->online_maps--;
113 trace_irq_matrix_offline(m);
114}
115
116static unsigned int matrix_alloc_area(struct irq_matrix *m, struct cpumap *cm,
117 unsigned int num, bool managed)
118{
119 unsigned int area, start = m->alloc_start;
120 unsigned int end = m->alloc_end;
121
122 bitmap_or(m->scratch_map, cm->managed_map, m->system_map, end);
123 bitmap_or(m->scratch_map, m->scratch_map, cm->alloc_map, end);
124 area = bitmap_find_next_zero_area(m->scratch_map, end, start, num, 0);
125 if (area >= end)
126 return area;
127 if (managed)
128 bitmap_set(cm->managed_map, area, num);
129 else
130 bitmap_set(cm->alloc_map, area, num);
131 return area;
132}
133
134/* Find the best CPU which has the lowest vector allocation count */
135static unsigned int matrix_find_best_cpu(struct irq_matrix *m,
136 const struct cpumask *msk)
137{
138 unsigned int cpu, best_cpu, maxavl = 0;
139 struct cpumap *cm;
140
141 best_cpu = UINT_MAX;
142
143 for_each_cpu(cpu, msk) {
144 cm = per_cpu_ptr(m->maps, cpu);
145
146 if (!cm->online || cm->available <= maxavl)
147 continue;
148
149 best_cpu = cpu;
150 maxavl = cm->available;
151 }
152 return best_cpu;
153}
154
155/* Find the best CPU which has the lowest number of managed IRQs allocated */
156static unsigned int matrix_find_best_cpu_managed(struct irq_matrix *m,
157 const struct cpumask *msk)
158{
159 unsigned int cpu, best_cpu, allocated = UINT_MAX;
160 struct cpumap *cm;
161
162 best_cpu = UINT_MAX;
163
164 for_each_cpu(cpu, msk) {
165 cm = per_cpu_ptr(m->maps, cpu);
166
167 if (!cm->online || cm->managed_allocated > allocated)
168 continue;
169
170 best_cpu = cpu;
171 allocated = cm->managed_allocated;
172 }
173 return best_cpu;
174}
175
176/**
177 * irq_matrix_assign_system - Assign system wide entry in the matrix
178 * @m: Matrix pointer
179 * @bit: Which bit to reserve
180 * @replace: Replace an already allocated vector with a system
181 * vector at the same bit position.
182 *
183 * The BUG_ON()s below are on purpose. If this goes wrong in the
184 * early boot process, then the chance to survive is about zero.
185 * If this happens when the system is life, it's not much better.
186 */
187void irq_matrix_assign_system(struct irq_matrix *m, unsigned int bit,
188 bool replace)
189{
190 struct cpumap *cm = this_cpu_ptr(m->maps);
191
192 BUG_ON(bit > m->matrix_bits);
193 BUG_ON(m->online_maps > 1 || (m->online_maps && !replace));
194
195 set_bit(bit, m->system_map);
196 if (replace) {
197 BUG_ON(!test_and_clear_bit(bit, cm->alloc_map));
198 cm->allocated--;
199 m->total_allocated--;
200 }
201 if (bit >= m->alloc_start && bit < m->alloc_end)
202 m->systembits_inalloc++;
203
204 trace_irq_matrix_assign_system(bit, m);
205}
206
207/**
208 * irq_matrix_reserve_managed - Reserve a managed interrupt in a CPU map
209 * @m: Matrix pointer
210 * @msk: On which CPUs the bits should be reserved.
211 *
212 * Can be called for offline CPUs. Note, this will only reserve one bit
213 * on all CPUs in @msk, but it's not guaranteed that the bits are at the
214 * same offset on all CPUs
215 */
216int irq_matrix_reserve_managed(struct irq_matrix *m, const struct cpumask *msk)
217{
218 unsigned int cpu, failed_cpu;
219
220 for_each_cpu(cpu, msk) {
221 struct cpumap *cm = per_cpu_ptr(m->maps, cpu);
222 unsigned int bit;
223
224 bit = matrix_alloc_area(m, cm, 1, true);
225 if (bit >= m->alloc_end)
226 goto cleanup;
227 cm->managed++;
228 if (cm->online) {
229 cm->available--;
230 m->global_available--;
231 }
232 trace_irq_matrix_reserve_managed(bit, cpu, m, cm);
233 }
234 return 0;
235cleanup:
236 failed_cpu = cpu;
237 for_each_cpu(cpu, msk) {
238 if (cpu == failed_cpu)
239 break;
240 irq_matrix_remove_managed(m, cpumask_of(cpu));
241 }
242 return -ENOSPC;
243}
244
245/**
246 * irq_matrix_remove_managed - Remove managed interrupts in a CPU map
247 * @m: Matrix pointer
248 * @msk: On which CPUs the bits should be removed
249 *
250 * Can be called for offline CPUs
251 *
252 * This removes not allocated managed interrupts from the map. It does
253 * not matter which one because the managed interrupts free their
254 * allocation when they shut down. If not, the accounting is screwed,
255 * but all what can be done at this point is warn about it.
256 */
257void irq_matrix_remove_managed(struct irq_matrix *m, const struct cpumask *msk)
258{
259 unsigned int cpu;
260
261 for_each_cpu(cpu, msk) {
262 struct cpumap *cm = per_cpu_ptr(m->maps, cpu);
263 unsigned int bit, end = m->alloc_end;
264
265 if (WARN_ON_ONCE(!cm->managed))
266 continue;
267
268 /* Get managed bit which are not allocated */
269 bitmap_andnot(m->scratch_map, cm->managed_map, cm->alloc_map, end);
270
271 bit = find_first_bit(m->scratch_map, end);
272 if (WARN_ON_ONCE(bit >= end))
273 continue;
274
275 clear_bit(bit, cm->managed_map);
276
277 cm->managed--;
278 if (cm->online) {
279 cm->available++;
280 m->global_available++;
281 }
282 trace_irq_matrix_remove_managed(bit, cpu, m, cm);
283 }
284}
285
286/**
287 * irq_matrix_alloc_managed - Allocate a managed interrupt in a CPU map
288 * @m: Matrix pointer
289 * @msk: Which CPUs to search in
290 * @mapped_cpu: Pointer to store the CPU for which the irq was allocated
291 */
292int irq_matrix_alloc_managed(struct irq_matrix *m, const struct cpumask *msk,
293 unsigned int *mapped_cpu)
294{
295 unsigned int bit, cpu, end;
296 struct cpumap *cm;
297
298 if (cpumask_empty(msk))
299 return -EINVAL;
300
301 cpu = matrix_find_best_cpu_managed(m, msk);
302 if (cpu == UINT_MAX)
303 return -ENOSPC;
304
305 cm = per_cpu_ptr(m->maps, cpu);
306 end = m->alloc_end;
307 /* Get managed bit which are not allocated */
308 bitmap_andnot(m->scratch_map, cm->managed_map, cm->alloc_map, end);
309 bit = find_first_bit(m->scratch_map, end);
310 if (bit >= end)
311 return -ENOSPC;
312 set_bit(bit, cm->alloc_map);
313 cm->allocated++;
314 cm->managed_allocated++;
315 m->total_allocated++;
316 *mapped_cpu = cpu;
317 trace_irq_matrix_alloc_managed(bit, cpu, m, cm);
318 return bit;
319}
320
321/**
322 * irq_matrix_assign - Assign a preallocated interrupt in the local CPU map
323 * @m: Matrix pointer
324 * @bit: Which bit to mark
325 *
326 * This should only be used to mark preallocated vectors
327 */
328void irq_matrix_assign(struct irq_matrix *m, unsigned int bit)
329{
330 struct cpumap *cm = this_cpu_ptr(m->maps);
331
332 if (WARN_ON_ONCE(bit < m->alloc_start || bit >= m->alloc_end))
333 return;
334 if (WARN_ON_ONCE(test_and_set_bit(bit, cm->alloc_map)))
335 return;
336 cm->allocated++;
337 m->total_allocated++;
338 cm->available--;
339 m->global_available--;
340 trace_irq_matrix_assign(bit, smp_processor_id(), m, cm);
341}
342
343/**
344 * irq_matrix_reserve - Reserve interrupts
345 * @m: Matrix pointer
346 *
347 * This is merely a book keeping call. It increments the number of globally
348 * reserved interrupt bits w/o actually allocating them. This allows to
349 * setup interrupt descriptors w/o assigning low level resources to it.
350 * The actual allocation happens when the interrupt gets activated.
351 */
352void irq_matrix_reserve(struct irq_matrix *m)
353{
354 if (m->global_reserved == m->global_available)
355 pr_warn("Interrupt reservation exceeds available resources\n");
356
357 m->global_reserved++;
358 trace_irq_matrix_reserve(m);
359}
360
361/**
362 * irq_matrix_remove_reserved - Remove interrupt reservation
363 * @m: Matrix pointer
364 *
365 * This is merely a book keeping call. It decrements the number of globally
366 * reserved interrupt bits. This is used to undo irq_matrix_reserve() when the
367 * interrupt was never in use and a real vector allocated, which undid the
368 * reservation.
369 */
370void irq_matrix_remove_reserved(struct irq_matrix *m)
371{
372 m->global_reserved--;
373 trace_irq_matrix_remove_reserved(m);
374}
375
376/**
377 * irq_matrix_alloc - Allocate a regular interrupt in a CPU map
378 * @m: Matrix pointer
379 * @msk: Which CPUs to search in
380 * @reserved: Allocate previously reserved interrupts
381 * @mapped_cpu: Pointer to store the CPU for which the irq was allocated
382 */
383int irq_matrix_alloc(struct irq_matrix *m, const struct cpumask *msk,
384 bool reserved, unsigned int *mapped_cpu)
385{
386 unsigned int cpu, bit;
387 struct cpumap *cm;
388
389 /*
390 * Not required in theory, but matrix_find_best_cpu() uses
391 * for_each_cpu() which ignores the cpumask on UP .
392 */
393 if (cpumask_empty(msk))
394 return -EINVAL;
395
396 cpu = matrix_find_best_cpu(m, msk);
397 if (cpu == UINT_MAX)
398 return -ENOSPC;
399
400 cm = per_cpu_ptr(m->maps, cpu);
401 bit = matrix_alloc_area(m, cm, 1, false);
402 if (bit >= m->alloc_end)
403 return -ENOSPC;
404 cm->allocated++;
405 cm->available--;
406 m->total_allocated++;
407 m->global_available--;
408 if (reserved)
409 m->global_reserved--;
410 *mapped_cpu = cpu;
411 trace_irq_matrix_alloc(bit, cpu, m, cm);
412 return bit;
413
414}
415
416/**
417 * irq_matrix_free - Free allocated interrupt in the matrix
418 * @m: Matrix pointer
419 * @cpu: Which CPU map needs be updated
420 * @bit: The bit to remove
421 * @managed: If true, the interrupt is managed and not accounted
422 * as available.
423 */
424void irq_matrix_free(struct irq_matrix *m, unsigned int cpu,
425 unsigned int bit, bool managed)
426{
427 struct cpumap *cm = per_cpu_ptr(m->maps, cpu);
428
429 if (WARN_ON_ONCE(bit < m->alloc_start || bit >= m->alloc_end))
430 return;
431
432 if (WARN_ON_ONCE(!test_and_clear_bit(bit, cm->alloc_map)))
433 return;
434
435 cm->allocated--;
436 if(managed)
437 cm->managed_allocated--;
438
439 if (cm->online)
440 m->total_allocated--;
441
442 if (!managed) {
443 cm->available++;
444 if (cm->online)
445 m->global_available++;
446 }
447 trace_irq_matrix_free(bit, cpu, m, cm);
448}
449
450/**
451 * irq_matrix_available - Get the number of globally available irqs
452 * @m: Pointer to the matrix to query
453 * @cpudown: If true, the local CPU is about to go down, adjust
454 * the number of available irqs accordingly
455 */
456unsigned int irq_matrix_available(struct irq_matrix *m, bool cpudown)
457{
458 struct cpumap *cm = this_cpu_ptr(m->maps);
459
460 if (!cpudown)
461 return m->global_available;
462 return m->global_available - cm->available;
463}
464
465/**
466 * irq_matrix_reserved - Get the number of globally reserved irqs
467 * @m: Pointer to the matrix to query
468 */
469unsigned int irq_matrix_reserved(struct irq_matrix *m)
470{
471 return m->global_reserved;
472}
473
474/**
475 * irq_matrix_allocated - Get the number of allocated non-managed irqs on the local CPU
476 * @m: Pointer to the matrix to search
477 *
478 * This returns number of allocated non-managed interrupts.
479 */
480unsigned int irq_matrix_allocated(struct irq_matrix *m)
481{
482 struct cpumap *cm = this_cpu_ptr(m->maps);
483
484 return cm->allocated - cm->managed_allocated;
485}
486
487#ifdef CONFIG_GENERIC_IRQ_DEBUGFS
488/**
489 * irq_matrix_debug_show - Show detailed allocation information
490 * @sf: Pointer to the seq_file to print to
491 * @m: Pointer to the matrix allocator
492 * @ind: Indentation for the print format
493 *
494 * Note, this is a lockless snapshot.
495 */
496void irq_matrix_debug_show(struct seq_file *sf, struct irq_matrix *m, int ind)
497{
498 unsigned int nsys = bitmap_weight(m->system_map, m->matrix_bits);
499 int cpu;
500
501 seq_printf(sf, "Online bitmaps: %6u\n", m->online_maps);
502 seq_printf(sf, "Global available: %6u\n", m->global_available);
503 seq_printf(sf, "Global reserved: %6u\n", m->global_reserved);
504 seq_printf(sf, "Total allocated: %6u\n", m->total_allocated);
505 seq_printf(sf, "System: %u: %*pbl\n", nsys, m->matrix_bits,
506 m->system_map);
507 seq_printf(sf, "%*s| CPU | avl | man | mac | act | vectors\n", ind, " ");
508 cpus_read_lock();
509 for_each_online_cpu(cpu) {
510 struct cpumap *cm = per_cpu_ptr(m->maps, cpu);
511
512 seq_printf(sf, "%*s %4d %4u %4u %4u %4u %*pbl\n", ind, " ",
513 cpu, cm->available, cm->managed,
514 cm->managed_allocated, cm->allocated,
515 m->matrix_bits, cm->alloc_map);
516 }
517 cpus_read_unlock();
518}
519#endif