~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/kernel/irq/ipi.c

Version: ~ [ linux-5.8-rc3 ] ~ [ linux-5.7.5 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.48 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.129 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.185 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.228 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.228 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * linux/kernel/irq/ipi.c
  3  *
  4  * Copyright (C) 2015 Imagination Technologies Ltd
  5  * Author: Qais Yousef <qais.yousef@imgtec.com>
  6  *
  7  * This file contains driver APIs to the IPI subsystem.
  8  */
  9 
 10 #define pr_fmt(fmt) "genirq/ipi: " fmt
 11 
 12 #include <linux/irqdomain.h>
 13 #include <linux/irq.h>
 14 
 15 /**
 16  * irq_reserve_ipi() - Setup an IPI to destination cpumask
 17  * @domain:     IPI domain
 18  * @dest:       cpumask of cpus which can receive the IPI
 19  *
 20  * Allocate a virq that can be used to send IPI to any CPU in dest mask.
 21  *
 22  * On success it'll return linux irq number and error code on failure
 23  */
 24 int irq_reserve_ipi(struct irq_domain *domain,
 25                              const struct cpumask *dest)
 26 {
 27         unsigned int nr_irqs, offset;
 28         struct irq_data *data;
 29         int virq, i;
 30 
 31         if (!domain ||!irq_domain_is_ipi(domain)) {
 32                 pr_warn("Reservation on a non IPI domain\n");
 33                 return -EINVAL;
 34         }
 35 
 36         if (!cpumask_subset(dest, cpu_possible_mask)) {
 37                 pr_warn("Reservation is not in possible_cpu_mask\n");
 38                 return -EINVAL;
 39         }
 40 
 41         nr_irqs = cpumask_weight(dest);
 42         if (!nr_irqs) {
 43                 pr_warn("Reservation for empty destination mask\n");
 44                 return -EINVAL;
 45         }
 46 
 47         if (irq_domain_is_ipi_single(domain)) {
 48                 /*
 49                  * If the underlying implementation uses a single HW irq on
 50                  * all cpus then we only need a single Linux irq number for
 51                  * it. We have no restrictions vs. the destination mask. The
 52                  * underlying implementation can deal with holes nicely.
 53                  */
 54                 nr_irqs = 1;
 55                 offset = 0;
 56         } else {
 57                 unsigned int next;
 58 
 59                 /*
 60                  * The IPI requires a seperate HW irq on each CPU. We require
 61                  * that the destination mask is consecutive. If an
 62                  * implementation needs to support holes, it can reserve
 63                  * several IPI ranges.
 64                  */
 65                 offset = cpumask_first(dest);
 66                 /*
 67                  * Find a hole and if found look for another set bit after the
 68                  * hole. For now we don't support this scenario.
 69                  */
 70                 next = cpumask_next_zero(offset, dest);
 71                 if (next < nr_cpu_ids)
 72                         next = cpumask_next(next, dest);
 73                 if (next < nr_cpu_ids) {
 74                         pr_warn("Destination mask has holes\n");
 75                         return -EINVAL;
 76                 }
 77         }
 78 
 79         virq = irq_domain_alloc_descs(-1, nr_irqs, 0, NUMA_NO_NODE);
 80         if (virq <= 0) {
 81                 pr_warn("Can't reserve IPI, failed to alloc descs\n");
 82                 return -ENOMEM;
 83         }
 84 
 85         virq = __irq_domain_alloc_irqs(domain, virq, nr_irqs, NUMA_NO_NODE,
 86                                        (void *) dest, true);
 87 
 88         if (virq <= 0) {
 89                 pr_warn("Can't reserve IPI, failed to alloc hw irqs\n");
 90                 goto free_descs;
 91         }
 92 
 93         for (i = 0; i < nr_irqs; i++) {
 94                 data = irq_get_irq_data(virq + i);
 95                 cpumask_copy(data->common->affinity, dest);
 96                 data->common->ipi_offset = offset;
 97                 irq_set_status_flags(virq + i, IRQ_NO_BALANCING);
 98         }
 99         return virq;
100 
101 free_descs:
102         irq_free_descs(virq, nr_irqs);
103         return -EBUSY;
104 }
105 
106 /**
107  * irq_destroy_ipi() - unreserve an IPI that was previously allocated
108  * @irq:        linux irq number to be destroyed
109  * @dest:       cpumask of cpus which should have the IPI removed
110  *
111  * The IPIs allocated with irq_reserve_ipi() are retuerned to the system
112  * destroying all virqs associated with them.
113  *
114  * Return 0 on success or error code on failure.
115  */
116 int irq_destroy_ipi(unsigned int irq, const struct cpumask *dest)
117 {
118         struct irq_data *data = irq_get_irq_data(irq);
119         struct cpumask *ipimask = data ? irq_data_get_affinity_mask(data) : NULL;
120         struct irq_domain *domain;
121         unsigned int nr_irqs;
122 
123         if (!irq || !data || !ipimask)
124                 return -EINVAL;
125 
126         domain = data->domain;
127         if (WARN_ON(domain == NULL))
128                 return -EINVAL;
129 
130         if (!irq_domain_is_ipi(domain)) {
131                 pr_warn("Trying to destroy a non IPI domain!\n");
132                 return -EINVAL;
133         }
134 
135         if (WARN_ON(!cpumask_subset(dest, ipimask)))
136                 /*
137                  * Must be destroying a subset of CPUs to which this IPI
138                  * was set up to target
139                  */
140                 return -EINVAL;
141 
142         if (irq_domain_is_ipi_per_cpu(domain)) {
143                 irq = irq + cpumask_first(dest) - data->common->ipi_offset;
144                 nr_irqs = cpumask_weight(dest);
145         } else {
146                 nr_irqs = 1;
147         }
148 
149         irq_domain_free_irqs(irq, nr_irqs);
150         return 0;
151 }
152 
153 /**
154  * ipi_get_hwirq - Get the hwirq associated with an IPI to a cpu
155  * @irq:        linux irq number
156  * @cpu:        the target cpu
157  *
158  * When dealing with coprocessors IPI, we need to inform the coprocessor of
159  * the hwirq it needs to use to receive and send IPIs.
160  *
161  * Returns hwirq value on success and INVALID_HWIRQ on failure.
162  */
163 irq_hw_number_t ipi_get_hwirq(unsigned int irq, unsigned int cpu)
164 {
165         struct irq_data *data = irq_get_irq_data(irq);
166         struct cpumask *ipimask = data ? irq_data_get_affinity_mask(data) : NULL;
167 
168         if (!data || !ipimask || cpu > nr_cpu_ids)
169                 return INVALID_HWIRQ;
170 
171         if (!cpumask_test_cpu(cpu, ipimask))
172                 return INVALID_HWIRQ;
173 
174         /*
175          * Get the real hardware irq number if the underlying implementation
176          * uses a seperate irq per cpu. If the underlying implementation uses
177          * a single hardware irq for all cpus then the IPI send mechanism
178          * needs to take care of the cpu destinations.
179          */
180         if (irq_domain_is_ipi_per_cpu(data->domain))
181                 data = irq_get_irq_data(irq + cpu - data->common->ipi_offset);
182 
183         return data ? irqd_to_hwirq(data) : INVALID_HWIRQ;
184 }
185 EXPORT_SYMBOL_GPL(ipi_get_hwirq);
186 
187 static int ipi_send_verify(struct irq_chip *chip, struct irq_data *data,
188                            const struct cpumask *dest, unsigned int cpu)
189 {
190         struct cpumask *ipimask = irq_data_get_affinity_mask(data);
191 
192         if (!chip || !ipimask)
193                 return -EINVAL;
194 
195         if (!chip->ipi_send_single && !chip->ipi_send_mask)
196                 return -EINVAL;
197 
198         if (cpu > nr_cpu_ids)
199                 return -EINVAL;
200 
201         if (dest) {
202                 if (!cpumask_subset(dest, ipimask))
203                         return -EINVAL;
204         } else {
205                 if (!cpumask_test_cpu(cpu, ipimask))
206                         return -EINVAL;
207         }
208         return 0;
209 }
210 
211 /**
212  * __ipi_send_single - send an IPI to a target Linux SMP CPU
213  * @desc:       pointer to irq_desc of the IRQ
214  * @cpu:        destination CPU, must in the destination mask passed to
215  *              irq_reserve_ipi()
216  *
217  * This function is for architecture or core code to speed up IPI sending. Not
218  * usable from driver code.
219  *
220  * Returns zero on success and negative error number on failure.
221  */
222 int __ipi_send_single(struct irq_desc *desc, unsigned int cpu)
223 {
224         struct irq_data *data = irq_desc_get_irq_data(desc);
225         struct irq_chip *chip = irq_data_get_irq_chip(data);
226 
227 #ifdef DEBUG
228         /*
229          * Minimise the overhead by omitting the checks for Linux SMP IPIs.
230          * Since the callers should be arch or core code which is generally
231          * trusted, only check for errors when debugging.
232          */
233         if (WARN_ON_ONCE(ipi_send_verify(chip, data, NULL, cpu)))
234                 return -EINVAL;
235 #endif
236         if (!chip->ipi_send_single) {
237                 chip->ipi_send_mask(data, cpumask_of(cpu));
238                 return 0;
239         }
240 
241         /* FIXME: Store this information in irqdata flags */
242         if (irq_domain_is_ipi_per_cpu(data->domain) &&
243             cpu != data->common->ipi_offset) {
244                 /* use the correct data for that cpu */
245                 unsigned irq = data->irq + cpu - data->common->ipi_offset;
246 
247                 data = irq_get_irq_data(irq);
248         }
249         chip->ipi_send_single(data, cpu);
250         return 0;
251 }
252 
253 /**
254  * ipi_send_mask - send an IPI to target Linux SMP CPU(s)
255  * @desc:       pointer to irq_desc of the IRQ
256  * @dest:       dest CPU(s), must be a subset of the mask passed to
257  *              irq_reserve_ipi()
258  *
259  * This function is for architecture or core code to speed up IPI sending. Not
260  * usable from driver code.
261  *
262  * Returns zero on success and negative error number on failure.
263  */
264 int __ipi_send_mask(struct irq_desc *desc, const struct cpumask *dest)
265 {
266         struct irq_data *data = irq_desc_get_irq_data(desc);
267         struct irq_chip *chip = irq_data_get_irq_chip(data);
268         unsigned int cpu;
269 
270 #ifdef DEBUG
271         /*
272          * Minimise the overhead by omitting the checks for Linux SMP IPIs.
273          * Since the callers should be arch or core code which is generally
274          * trusted, only check for errors when debugging.
275          */
276         if (WARN_ON_ONCE(ipi_send_verify(chip, data, dest, 0)))
277                 return -EINVAL;
278 #endif
279         if (chip->ipi_send_mask) {
280                 chip->ipi_send_mask(data, dest);
281                 return 0;
282         }
283 
284         if (irq_domain_is_ipi_per_cpu(data->domain)) {
285                 unsigned int base = data->irq;
286 
287                 for_each_cpu(cpu, dest) {
288                         unsigned irq = base + cpu - data->common->ipi_offset;
289 
290                         data = irq_get_irq_data(irq);
291                         chip->ipi_send_single(data, cpu);
292                 }
293         } else {
294                 for_each_cpu(cpu, dest)
295                         chip->ipi_send_single(data, cpu);
296         }
297         return 0;
298 }
299 
300 /**
301  * ipi_send_single - Send an IPI to a single CPU
302  * @virq:       linux irq number from irq_reserve_ipi()
303  * @cpu:        destination CPU, must in the destination mask passed to
304  *              irq_reserve_ipi()
305  *
306  * Returns zero on success and negative error number on failure.
307  */
308 int ipi_send_single(unsigned int virq, unsigned int cpu)
309 {
310         struct irq_desc *desc = irq_to_desc(virq);
311         struct irq_data *data = desc ? irq_desc_get_irq_data(desc) : NULL;
312         struct irq_chip *chip = data ? irq_data_get_irq_chip(data) : NULL;
313 
314         if (WARN_ON_ONCE(ipi_send_verify(chip, data, NULL, cpu)))
315                 return -EINVAL;
316 
317         return __ipi_send_single(desc, cpu);
318 }
319 EXPORT_SYMBOL_GPL(ipi_send_single);
320 
321 /**
322  * ipi_send_mask - Send an IPI to target CPU(s)
323  * @virq:       linux irq number from irq_reserve_ipi()
324  * @dest:       dest CPU(s), must be a subset of the mask passed to
325  *              irq_reserve_ipi()
326  *
327  * Returns zero on success and negative error number on failure.
328  */
329 int ipi_send_mask(unsigned int virq, const struct cpumask *dest)
330 {
331         struct irq_desc *desc = irq_to_desc(virq);
332         struct irq_data *data = desc ? irq_desc_get_irq_data(desc) : NULL;
333         struct irq_chip *chip = data ? irq_data_get_irq_chip(data) : NULL;
334 
335         if (WARN_ON_ONCE(ipi_send_verify(chip, data, dest, 0)))
336                 return -EINVAL;
337 
338         return __ipi_send_mask(desc, dest);
339 }
340 EXPORT_SYMBOL_GPL(ipi_send_mask);
341 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp