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