// SPDX-License-Identifier: GPL-2.0/* * Copyright (C) 2016 Thomas Gleixner. * Copyright (C) 2016-2017 Christoph Hellwig. */#include <linux/interrupt.h>#include <linux/kernel.h>#include <linux/slab.h>#include <linux/cpu.h>#include <linux/group_cpus.h> static void default_calc_sets(struct irq_affinity *affd, unsigned int affvecs){	affd->nr_sets = 1;	affd->set_size[0] = affvecs;} /** * irq_create_affinity_masks - Create affinity masks for multiqueue spreading * @nvecs:	The total number of vectors * @affd:	Description of the affinity requirements * * Returns the irq_affinity_desc pointer or NULL if allocation failed. */struct irq_affinity_desc *irq_create_affinity_masks(unsigned int nvecs, struct irq_affinity *affd){	unsigned int affvecs, curvec, usedvecs, i;	struct irq_affinity_desc *masks = NULL; 	/*	 * Determine the number of vectors which need interrupt affinities	 * assigned. If the pre/post request exhausts the available vectors	 * then nothing to do here except for invoking the calc_sets()	 * callback so the device driver can adjust to the situation.	 */	if (nvecs > affd->pre_vectors + affd->post_vectors)		affvecs = nvecs - affd->pre_vectors - affd->post_vectors;	else		affvecs = 0; 	/*	 * Simple invocations do not provide a calc_sets() callback. Install	 * the generic one.	 */	if (!affd->calc_sets)		affd->calc_sets = default_calc_sets; 	/* Recalculate the sets */	affd->calc_sets(affd, affvecs); 	if (WARN_ON_ONCE(affd->nr_sets > IRQ_AFFINITY_MAX_SETS))		return NULL; 	/* Nothing to assign? */	if (!affvecs)		return NULL; 	masks = kcalloc(nvecs, sizeof(*masks), GFP_KERNEL);	if (!masks)		return NULL; 	/* Fill out vectors at the beginning that don't need affinity */	for (curvec = 0; curvec < affd->pre_vectors; curvec++)		cpumask_copy(&masks[curvec].mask, irq_default_affinity); 	/*	 * Spread on present CPUs starting from affd->pre_vectors. If we	 * have multiple sets, build each sets affinity mask separately.	 */	for (i = 0, usedvecs = 0; i < affd->nr_sets; i++) {		unsigned int this_vecs = affd->set_size[i];		int j;		struct cpumask *result = group_cpus_evenly(this_vecs); 		if (!result) {			kfree(masks);			return NULL;		} 		for (j = 0; j < this_vecs; j++)			cpumask_copy(&masks[curvec + j].mask, &result[j]);		kfree(result); 		curvec += this_vecs;		usedvecs += this_vecs;	} 	/* Fill out vectors at the end that don't need affinity */	if (usedvecs >= affvecs)		curvec = affd->pre_vectors + affvecs;	else		curvec = affd->pre_vectors + usedvecs;	for (; curvec < nvecs; curvec++)		cpumask_copy(&masks[curvec].mask, irq_default_affinity); 	/* Mark the managed interrupts */	for (i = affd->pre_vectors; i < nvecs - affd->post_vectors; i++)		masks[i].is_managed = 1; 	return masks;} /** * irq_calc_affinity_vectors - Calculate the optimal number of vectors * @minvec:	The minimum number of vectors available * @maxvec:	The maximum number of vectors available * @affd:	Description of the affinity requirements */unsigned int irq_calc_affinity_vectors(unsigned int minvec, unsigned int maxvec,				       const struct irq_affinity *affd){	unsigned int resv = affd->pre_vectors + affd->post_vectors;	unsigned int set_vecs; 	if (resv > minvec)		return 0; 	if (affd->calc_sets) {		set_vecs = maxvec - resv;	} else {		cpus_read_lock();		set_vecs = cpumask_weight(cpu_possible_mask);		cpus_read_unlock();	} 	return resv + min(set_vecs, maxvec - resv);}