Re: [RESEND PATCH v5 06/12] smp: Enable preemption early in smp_call_function_many_cond

[Sebastian Andrzej Siewior]

On 2026-05-13 20:45:18 [+0800], Chuyi Zhou wrote:
> --- a/kernel/smp.c
> +++ b/kernel/smp.c
> @@ -861,10 +861,10 @@ static void smp_call_function_many_cond(const struct cpumask *mask,
>  	int nr_cpus = 0;
>  	bool run_remote = false;
>  
> -	lockdep_assert_preemption_disabled();
> -
>  	task_mask = smp_task_ipi_mask(current);
> -	preemptible_wait = task_mask;
> +	preemptible_wait = task_mask && preemptible();

Now that I stare at this again, why is preemptible() a thing here?
You care about doing put_cpu() below before csd_lock_wait(). This can
only be done if you get a cpumask from smp_task_ipi_mask(). If
preemption or interrupts is/are disabled then you still can use the
"private" cpumask and do the early put_cpu(). It simply is no
optimisation.

This basically reduces the check to a CONFIG_PREEMPTION=y kernel because
otherwise you have no cpumask. And this is not done on !SMP kernels.
smp_task_ipi_mask() is only used here so there is no need to export it
via headers.

> +
> +	this_cpu = get_cpu();
>  	cfd = this_cpu_ptr(&cfd_data);
>  	cpumask = preemptible_wait ? task_mask : cfd->cpumask;
>  
> @@ -946,6 +946,19 @@ static void smp_call_function_many_cond(const struct cpumask *mask,
>  		local_irq_restore(flags);
>  	}
>  
> +	/*
> +	 * We may block in csd_lock_wait() for a significant amount of time,
> +	 * especially when interrupts are disabled or with a large number of
> +	 * remote CPUs. Try to enable preemption before csd_lock_wait().

If interrupts are disabled there is no gain. Also we sort of expect
interrupts to be enabled here.

   Waiting for completion can take time especially with many CPUs. On a
   PREEMPTIBLE kernel a per-task cpumask is used to track CPUs with
   pending IPI request. This allows to enable preemption and potentially
   wait while allowing task preemption. On a !PREEMPTIBLE the cpumask is
   shared and the call must block until completion to avoid modifications
   by a another caller on this CPU.

> +	 *
> +	 * Use the task_mask instead of cfd->cpumask to avoid concurrency
> +	 * modification from tasks on the same cpu. If preemption occurs during
> +	 * csd_lock_wait, other concurrent smp_call_function_many_cond() calls
> +	 * will simply block until the previous csd->func() completes.
> +	 */
> +	if (preemptible_wait)
> +		put_cpu();
> +
>  	if (run_remote && wait) {
>  		for_each_cpu(cpu, cpumask) {
>  			call_single_data_t *csd;
> @@ -954,6 +967,9 @@ static void smp_call_function_many_cond(const struct cpumask *mask,
>  			csd_lock_wait(csd);
>  		}
>  	}
> +
> +	if (!preemptible_wait)
> +		put_cpu();
>  }
>  
>  /**

Sebastian