1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright (C) 2016 Thomas Gleixner. 4 * Copyright (C) 2016-2017 Christoph Hellwig. 5 */ 6 #include <linux/interrupt.h> 7 #include <linux/kernel.h> 8 #include <linux/slab.h> 9 #include <linux/cpu.h> 10 #include <linux/group_cpus.h> 11 12 static void default_calc_sets(struct irq_affinity *affd, unsigned int affvecs) 13 { 14 affd->nr_sets = 1; 15 affd->set_size[0] = affvecs; 16 } 17 18 /** 19 * irq_create_affinity_masks - Create affinity masks for multiqueue spreading 20 * @nvecs: The total number of vectors 21 * @affd: Description of the affinity requirements 22 * 23 * Returns the irq_affinity_desc pointer or NULL if allocation failed. 24 */ 25 struct irq_affinity_desc * 26 irq_create_affinity_masks(unsigned int nvecs, struct irq_affinity *affd) 27 { 28 unsigned int affvecs, curvec, usedvecs, i; 29 struct irq_affinity_desc *masks = NULL; 30 31 /* 32 * Determine the number of vectors which need interrupt affinities 33 * assigned. If the pre/post request exhausts the available vectors 34 * then nothing to do here except for invoking the calc_sets() 35 * callback so the device driver can adjust to the situation. 36 */ 37 if (nvecs > affd->pre_vectors + affd->post_vectors) 38 affvecs = nvecs - affd->pre_vectors - affd->post_vectors; 39 else 40 affvecs = 0; 41 42 /* 43 * Simple invocations do not provide a calc_sets() callback. Install 44 * the generic one. 45 */ 46 if (!affd->calc_sets) 47 affd->calc_sets = default_calc_sets; 48 49 /* Recalculate the sets */ 50 affd->calc_sets(affd, affvecs); 51 52 if (WARN_ON_ONCE(affd->nr_sets > IRQ_AFFINITY_MAX_SETS)) 53 return NULL; 54 55 /* Nothing to assign? */ 56 if (!affvecs) 57 return NULL; 58 59 masks = kcalloc(nvecs, sizeof(*masks), GFP_KERNEL); 60 if (!masks) 61 return NULL; 62 63 /* Fill out vectors at the beginning that don't need affinity */ 64 for (curvec = 0; curvec < affd->pre_vectors; curvec++) 65 cpumask_copy(&masks[curvec].mask, irq_default_affinity); 66 67 /* 68 * Spread on present CPUs starting from affd->pre_vectors. If we 69 * have multiple sets, build each sets affinity mask separately. 70 */ 71 for (i = 0, usedvecs = 0; i < affd->nr_sets; i++) { 72 unsigned int this_vecs = affd->set_size[i]; 73 int j; 74 struct cpumask *result = group_cpus_evenly(this_vecs); 75 76 if (!result) { 77 kfree(masks); 78 return NULL; 79 } 80 81 for (j = 0; j < this_vecs; j++) 82 cpumask_copy(&masks[curvec + j].mask, &result[j]); 83 kfree(result); 84 85 curvec += this_vecs; 86 usedvecs += this_vecs; 87 } 88 89 /* Fill out vectors at the end that don't need affinity */ 90 if (usedvecs >= affvecs) 91 curvec = affd->pre_vectors + affvecs; 92 else 93 curvec = affd->pre_vectors + usedvecs; 94 for (; curvec < nvecs; curvec++) 95 cpumask_copy(&masks[curvec].mask, irq_default_affinity); 96 97 /* Mark the managed interrupts */ 98 for (i = affd->pre_vectors; i < nvecs - affd->post_vectors; i++) 99 masks[i].is_managed = 1; 100 101 return masks; 102 } 103 104 /** 105 * irq_calc_affinity_vectors - Calculate the optimal number of vectors 106 * @minvec: The minimum number of vectors available 107 * @maxvec: The maximum number of vectors available 108 * @affd: Description of the affinity requirements 109 */ 110 unsigned int irq_calc_affinity_vectors(unsigned int minvec, unsigned int maxvec, 111 const struct irq_affinity *affd) 112 { 113 unsigned int resv = affd->pre_vectors + affd->post_vectors; 114 unsigned int set_vecs; 115 116 if (resv > minvec) 117 return 0; 118 119 if (affd->calc_sets) { 120 set_vecs = maxvec - resv; 121 } else { 122 cpus_read_lock(); 123 set_vecs = cpumask_weight(cpu_possible_mask); 124 cpus_read_unlock(); 125 } 126 127 return resv + min(set_vecs, maxvec - resv); 128 } 129