Branch data     Line data    Source code

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