Version:  2.0.40 2.2.26 2.4.37 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7 4.8 4.9 4.10

Linux/lib/cpu_rmap.c

  1 /*
  2  * cpu_rmap.c: CPU affinity reverse-map support
  3  * Copyright 2011 Solarflare Communications Inc.
  4  *
  5  * This program is free software; you can redistribute it and/or modify it
  6  * under the terms of the GNU General Public License version 2 as published
  7  * by the Free Software Foundation, incorporated herein by reference.
  8  */
  9 
 10 #include <linux/cpu_rmap.h>
 11 #include <linux/interrupt.h>
 12 #include <linux/export.h>
 13 
 14 /*
 15  * These functions maintain a mapping from CPUs to some ordered set of
 16  * objects with CPU affinities.  This can be seen as a reverse-map of
 17  * CPU affinity.  However, we do not assume that the object affinities
 18  * cover all CPUs in the system.  For those CPUs not directly covered
 19  * by object affinities, we attempt to find a nearest object based on
 20  * CPU topology.
 21  */
 22 
 23 /**
 24  * alloc_cpu_rmap - allocate CPU affinity reverse-map
 25  * @size: Number of objects to be mapped
 26  * @flags: Allocation flags e.g. %GFP_KERNEL
 27  */
 28 struct cpu_rmap *alloc_cpu_rmap(unsigned int size, gfp_t flags)
 29 {
 30         struct cpu_rmap *rmap;
 31         unsigned int cpu;
 32         size_t obj_offset;
 33 
 34         /* This is a silly number of objects, and we use u16 indices. */
 35         if (size > 0xffff)
 36                 return NULL;
 37 
 38         /* Offset of object pointer array from base structure */
 39         obj_offset = ALIGN(offsetof(struct cpu_rmap, near[nr_cpu_ids]),
 40                            sizeof(void *));
 41 
 42         rmap = kzalloc(obj_offset + size * sizeof(rmap->obj[0]), flags);
 43         if (!rmap)
 44                 return NULL;
 45 
 46         kref_init(&rmap->refcount);
 47         rmap->obj = (void **)((char *)rmap + obj_offset);
 48 
 49         /* Initially assign CPUs to objects on a rota, since we have
 50          * no idea where the objects are.  Use infinite distance, so
 51          * any object with known distance is preferable.  Include the
 52          * CPUs that are not present/online, since we definitely want
 53          * any newly-hotplugged CPUs to have some object assigned.
 54          */
 55         for_each_possible_cpu(cpu) {
 56                 rmap->near[cpu].index = cpu % size;
 57                 rmap->near[cpu].dist = CPU_RMAP_DIST_INF;
 58         }
 59 
 60         rmap->size = size;
 61         return rmap;
 62 }
 63 EXPORT_SYMBOL(alloc_cpu_rmap);
 64 
 65 /**
 66  * cpu_rmap_release - internal reclaiming helper called from kref_put
 67  * @ref: kref to struct cpu_rmap
 68  */
 69 static void cpu_rmap_release(struct kref *ref)
 70 {
 71         struct cpu_rmap *rmap = container_of(ref, struct cpu_rmap, refcount);
 72         kfree(rmap);
 73 }
 74 
 75 /**
 76  * cpu_rmap_get - internal helper to get new ref on a cpu_rmap
 77  * @rmap: reverse-map allocated with alloc_cpu_rmap()
 78  */
 79 static inline void cpu_rmap_get(struct cpu_rmap *rmap)
 80 {
 81         kref_get(&rmap->refcount);
 82 }
 83 
 84 /**
 85  * cpu_rmap_put - release ref on a cpu_rmap
 86  * @rmap: reverse-map allocated with alloc_cpu_rmap()
 87  */
 88 int cpu_rmap_put(struct cpu_rmap *rmap)
 89 {
 90         return kref_put(&rmap->refcount, cpu_rmap_release);
 91 }
 92 EXPORT_SYMBOL(cpu_rmap_put);
 93 
 94 /* Reevaluate nearest object for given CPU, comparing with the given
 95  * neighbours at the given distance.
 96  */
 97 static bool cpu_rmap_copy_neigh(struct cpu_rmap *rmap, unsigned int cpu,
 98                                 const struct cpumask *mask, u16 dist)
 99 {
100         int neigh;
101 
102         for_each_cpu(neigh, mask) {
103                 if (rmap->near[cpu].dist > dist &&
104                     rmap->near[neigh].dist <= dist) {
105                         rmap->near[cpu].index = rmap->near[neigh].index;
106                         rmap->near[cpu].dist = dist;
107                         return true;
108                 }
109         }
110         return false;
111 }
112 
113 #ifdef DEBUG
114 static void debug_print_rmap(const struct cpu_rmap *rmap, const char *prefix)
115 {
116         unsigned index;
117         unsigned int cpu;
118 
119         pr_info("cpu_rmap %p, %s:\n", rmap, prefix);
120 
121         for_each_possible_cpu(cpu) {
122                 index = rmap->near[cpu].index;
123                 pr_info("cpu %d -> obj %u (distance %u)\n",
124                         cpu, index, rmap->near[cpu].dist);
125         }
126 }
127 #else
128 static inline void
129 debug_print_rmap(const struct cpu_rmap *rmap, const char *prefix)
130 {
131 }
132 #endif
133 
134 /**
135  * cpu_rmap_add - add object to a rmap
136  * @rmap: CPU rmap allocated with alloc_cpu_rmap()
137  * @obj: Object to add to rmap
138  *
139  * Return index of object.
140  */
141 int cpu_rmap_add(struct cpu_rmap *rmap, void *obj)
142 {
143         u16 index;
144 
145         BUG_ON(rmap->used >= rmap->size);
146         index = rmap->used++;
147         rmap->obj[index] = obj;
148         return index;
149 }
150 EXPORT_SYMBOL(cpu_rmap_add);
151 
152 /**
153  * cpu_rmap_update - update CPU rmap following a change of object affinity
154  * @rmap: CPU rmap to update
155  * @index: Index of object whose affinity changed
156  * @affinity: New CPU affinity of object
157  */
158 int cpu_rmap_update(struct cpu_rmap *rmap, u16 index,
159                     const struct cpumask *affinity)
160 {
161         cpumask_var_t update_mask;
162         unsigned int cpu;
163 
164         if (unlikely(!zalloc_cpumask_var(&update_mask, GFP_KERNEL)))
165                 return -ENOMEM;
166 
167         /* Invalidate distance for all CPUs for which this used to be
168          * the nearest object.  Mark those CPUs for update.
169          */
170         for_each_online_cpu(cpu) {
171                 if (rmap->near[cpu].index == index) {
172                         rmap->near[cpu].dist = CPU_RMAP_DIST_INF;
173                         cpumask_set_cpu(cpu, update_mask);
174                 }
175         }
176 
177         debug_print_rmap(rmap, "after invalidating old distances");
178 
179         /* Set distance to 0 for all CPUs in the new affinity mask.
180          * Mark all CPUs within their NUMA nodes for update.
181          */
182         for_each_cpu(cpu, affinity) {
183                 rmap->near[cpu].index = index;
184                 rmap->near[cpu].dist = 0;
185                 cpumask_or(update_mask, update_mask,
186                            cpumask_of_node(cpu_to_node(cpu)));
187         }
188 
189         debug_print_rmap(rmap, "after updating neighbours");
190 
191         /* Update distances based on topology */
192         for_each_cpu(cpu, update_mask) {
193                 if (cpu_rmap_copy_neigh(rmap, cpu,
194                                         topology_sibling_cpumask(cpu), 1))
195                         continue;
196                 if (cpu_rmap_copy_neigh(rmap, cpu,
197                                         topology_core_cpumask(cpu), 2))
198                         continue;
199                 if (cpu_rmap_copy_neigh(rmap, cpu,
200                                         cpumask_of_node(cpu_to_node(cpu)), 3))
201                         continue;
202                 /* We could continue into NUMA node distances, but for now
203                  * we give up.
204                  */
205         }
206 
207         debug_print_rmap(rmap, "after copying neighbours");
208 
209         free_cpumask_var(update_mask);
210         return 0;
211 }
212 EXPORT_SYMBOL(cpu_rmap_update);
213 
214 /* Glue between IRQ affinity notifiers and CPU rmaps */
215 
216 struct irq_glue {
217         struct irq_affinity_notify notify;
218         struct cpu_rmap *rmap;
219         u16 index;
220 };
221 
222 /**
223  * free_irq_cpu_rmap - free a CPU affinity reverse-map used for IRQs
224  * @rmap: Reverse-map allocated with alloc_irq_cpu_map(), or %NULL
225  *
226  * Must be called in process context, before freeing the IRQs.
227  */
228 void free_irq_cpu_rmap(struct cpu_rmap *rmap)
229 {
230         struct irq_glue *glue;
231         u16 index;
232 
233         if (!rmap)
234                 return;
235 
236         for (index = 0; index < rmap->used; index++) {
237                 glue = rmap->obj[index];
238                 irq_set_affinity_notifier(glue->notify.irq, NULL);
239         }
240 
241         cpu_rmap_put(rmap);
242 }
243 EXPORT_SYMBOL(free_irq_cpu_rmap);
244 
245 /**
246  * irq_cpu_rmap_notify - callback for IRQ subsystem when IRQ affinity updated
247  * @notify: struct irq_affinity_notify passed by irq/manage.c
248  * @mask: cpu mask for new SMP affinity
249  *
250  * This is executed in workqueue context.
251  */
252 static void
253 irq_cpu_rmap_notify(struct irq_affinity_notify *notify, const cpumask_t *mask)
254 {
255         struct irq_glue *glue =
256                 container_of(notify, struct irq_glue, notify);
257         int rc;
258 
259         rc = cpu_rmap_update(glue->rmap, glue->index, mask);
260         if (rc)
261                 pr_warning("irq_cpu_rmap_notify: update failed: %d\n", rc);
262 }
263 
264 /**
265  * irq_cpu_rmap_release - reclaiming callback for IRQ subsystem
266  * @ref: kref to struct irq_affinity_notify passed by irq/manage.c
267  */
268 static void irq_cpu_rmap_release(struct kref *ref)
269 {
270         struct irq_glue *glue =
271                 container_of(ref, struct irq_glue, notify.kref);
272 
273         cpu_rmap_put(glue->rmap);
274         kfree(glue);
275 }
276 
277 /**
278  * irq_cpu_rmap_add - add an IRQ to a CPU affinity reverse-map
279  * @rmap: The reverse-map
280  * @irq: The IRQ number
281  *
282  * This adds an IRQ affinity notifier that will update the reverse-map
283  * automatically.
284  *
285  * Must be called in process context, after the IRQ is allocated but
286  * before it is bound with request_irq().
287  */
288 int irq_cpu_rmap_add(struct cpu_rmap *rmap, int irq)
289 {
290         struct irq_glue *glue = kzalloc(sizeof(*glue), GFP_KERNEL);
291         int rc;
292 
293         if (!glue)
294                 return -ENOMEM;
295         glue->notify.notify = irq_cpu_rmap_notify;
296         glue->notify.release = irq_cpu_rmap_release;
297         glue->rmap = rmap;
298         cpu_rmap_get(rmap);
299         glue->index = cpu_rmap_add(rmap, glue);
300         rc = irq_set_affinity_notifier(irq, &glue->notify);
301         if (rc) {
302                 cpu_rmap_put(glue->rmap);
303                 kfree(glue);
304         }
305         return rc;
306 }
307 EXPORT_SYMBOL(irq_cpu_rmap_add);
308 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us