From nobody Wed Feb 11 02:54:09 2026 Received: from out-184.mta0.migadu.com (out-184.mta0.migadu.com [91.218.175.184]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id A516A223323 for ; Sun, 18 Jan 2026 16:41:01 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=91.218.175.184 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1768754463; cv=none; b=fx7XDock4AUbi89I0p6gaZ49zJG1kEJ5P+WLpZrAhgcb9nAOAs/+OYznup6Pf0j8SklKfGv/2vRP15VhYppXGQX5s/rxRqpwwqFMDKHGq0ou4BktHYzdhJf6k43fecyYsptaDmkCOI1PKkMzcGOorgOO1nRoyzDEi5y4Hs74iYw= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1768754463; c=relaxed/simple; bh=WShuIAPyE68nfy0UjiL2DWEKFe79X2KK4RQCP1VjDNE=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=gDDUdmwySAaxNeRhtRYLKHqORA1159AF70MRVC1AYuq7/aDvtg3OUk13VrhW58xqYuA7l3mQehouQjrw2XIt7/KihvQwy4lrew5OgoOD6eOgIHhhIMuaqhXdgAA4BTdkkpzYoiLP2Xe0JQiY2CAA60YW6X+avQv9nr0f4Fbs5T8= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=linux.dev; spf=pass smtp.mailfrom=linux.dev; dkim=pass (1024-bit key) header.d=linux.dev header.i=@linux.dev header.b=XDxqmXnC; arc=none smtp.client-ip=91.218.175.184 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=linux.dev Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=linux.dev Authentication-Results: smtp.subspace.kernel.org; dkim=pass (1024-bit key) header.d=linux.dev header.i=@linux.dev header.b="XDxqmXnC" X-Report-Abuse: Please report any abuse attempt to abuse@migadu.com and include these headers. DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linux.dev; s=key1; t=1768754459; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=T65OoKpCdEFFVP2+DiaAhKdFuag7lvxT1ZvELnGzBuM=; b=XDxqmXnCuH/JRYGM1O3YmnQvJdD5IkHuTPYgNlZTIrKzbgTF/xsrUKLNxn8n7pCsP1e0Ez GyWIZbQ1PoS7Q57MIkuqHH6ZzKB27QVPrt839tIYcBWFa9Qo5Fp+XnhqJ8Wn05PLWjKRTj 1t5+vc2JSaUkIOkbrk1su7vOrIuY01U= From: wen.yang@linux.dev To: Greg Kroah-Hartman Cc: stable@vger.kernel.org, linux-kernel@vger.kernel.org, Eric Dumazet , Jason Xing , Paolo Abeni , Wen Yang Subject: [PATCH 6.1 1/3] net: napi_schedule_rps() cleanup Date: Mon, 19 Jan 2026 00:40:31 +0800 Message-Id: <72f1345baff9fe5a296915d4b5a7a18bd304df68.1768754220.git.wen.yang@linux.dev> In-Reply-To: References: Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-Migadu-Flow: FLOW_OUT Content-Type: text/plain; charset="utf-8" From: Eric Dumazet commit 8fcb76b934daff12cde76adeab3d502eeb0734b1 upstream. napi_schedule_rps() return value is ignored, remove it. Change the comment to clarify the intent. Signed-off-by: Eric Dumazet Reviewed-by: Jason Xing Tested-by: Jason Xing Signed-off-by: Paolo Abeni Signed-off-by: Wen Yang --- net/core/dev.c | 18 ++++++++++++------ 1 file changed, 12 insertions(+), 6 deletions(-) diff --git a/net/core/dev.c b/net/core/dev.c index 114fc8bc37f8..e35f41e75bdd 100644 --- a/net/core/dev.c +++ b/net/core/dev.c @@ -4684,11 +4684,18 @@ static void trigger_rx_softirq(void *data) } =20 /* - * Check if this softnet_data structure is another cpu one - * If yes, queue it to our IPI list and return 1 - * If no, return 0 + * After we queued a packet into sd->input_pkt_queue, + * we need to make sure this queue is serviced soon. + * + * - If this is another cpu queue, link it to our rps_ipi_list, + * and make sure we will process rps_ipi_list from net_rx_action(). + * As we do not know yet if we are called from net_rx_action(), + * we have to raise NET_RX_SOFTIRQ. This might change in the future. + * + * - If this is our own queue, NAPI schedule our backlog. + * Note that this also raises NET_RX_SOFTIRQ. */ -static int napi_schedule_rps(struct softnet_data *sd) +static void napi_schedule_rps(struct softnet_data *sd) { struct softnet_data *mysd =3D this_cpu_ptr(&softnet_data); =20 @@ -4698,11 +4705,10 @@ static int napi_schedule_rps(struct softnet_data *s= d) mysd->rps_ipi_list =3D sd; =20 __raise_softirq_irqoff(NET_RX_SOFTIRQ); - return 1; + return; } #endif /* CONFIG_RPS */ __napi_schedule_irqoff(&mysd->backlog); - return 0; } =20 #ifdef CONFIG_NET_FLOW_LIMIT --=20 2.25.1 From nobody Wed Feb 11 02:54:09 2026 Received: from out-179.mta0.migadu.com (out-179.mta0.migadu.com [91.218.175.179]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 8BE0A207A20 for ; Sun, 18 Jan 2026 16:41:11 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=91.218.175.179 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1768754473; cv=none; b=L6DSzzx6J6WZ5dl1dvO8vw21CfJyt+Mv5nMteGi+A+uE45VJJp40wfN9Kdx0vaL/VXxTQBgkN0pCccm5djfZ1vNIhsrb+GVflDv2PkZU1sj66bHfh5kTBB90BYH+hZI5FcDju7UCtMj8B1pmN1H4RHX8C8LI5u5CVH4Zx04uWe4= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1768754473; c=relaxed/simple; bh=5M8+PnOkLtsD+OxYNuVjmuhn7pOypAI779/sOab/aEs=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=WC+9sQ/hOhAs6HUsSx0PZzrgFU1loNC2VyqrapmGbxKLHc4aAk36OorFlJqqW8vXRs9CI8+H+9sbQSuKmXfG3VnxpQNtmBTcf0Xa5Oi8hoVOd1DAK6U4JnppwWXsemrLBXb8gf1YsnIpy80nK7IGzDlYpWEx8NjLJ2U66MO7ETU= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=linux.dev; spf=pass smtp.mailfrom=linux.dev; dkim=pass (1024-bit key) header.d=linux.dev header.i=@linux.dev header.b=IOPwH/rP; arc=none smtp.client-ip=91.218.175.179 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=linux.dev Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=linux.dev Authentication-Results: smtp.subspace.kernel.org; dkim=pass (1024-bit key) header.d=linux.dev header.i=@linux.dev header.b="IOPwH/rP" X-Report-Abuse: Please report any abuse attempt to abuse@migadu.com and include these headers. DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linux.dev; s=key1; t=1768754469; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=EFttAqFki6nqWJoMTJuJeWJm16rSKpHxYccKyXV1eEI=; b=IOPwH/rPRM1XV1BSPs0DlW++N3vcK1+XWfiAao9nG/IRb6RIycxk453je5uC8qQzU8vSqc w9u5D0XUAs8i8oxo7xIvG7oZPDlpUAZsZf6+VBMxRwAmFCZlou40s+DNSbett4HwlRZdBe MzOQU60EfBCYOlLqouaM//3FFlbJ4NY= From: wen.yang@linux.dev To: Greg Kroah-Hartman Cc: stable@vger.kernel.org, linux-kernel@vger.kernel.org, Sebastian Andrzej Siewior , Jakub Kicinski , Paolo Abeni , Wen Yang Subject: [PATCH 6.1 2/3] net: Remove conditional threaded-NAPI wakeup based on task state. Date: Mon, 19 Jan 2026 00:40:32 +0800 Message-Id: In-Reply-To: References: Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-Migadu-Flow: FLOW_OUT Content-Type: text/plain; charset="utf-8" From: Sebastian Andrzej Siewior commit 56364c910691f6d10ba88c964c9041b9ab777bd6 upstream. A NAPI thread is scheduled by first setting NAPI_STATE_SCHED bit. If successful (the bit was not yet set) then the NAPI_STATE_SCHED_THREADED is set but only if thread's state is not TASK_INTERRUPTIBLE (is TASK_RUNNING) followed by task wakeup. If the task is idle (TASK_INTERRUPTIBLE) then the NAPI_STATE_SCHED_THREADED bit is not set. The thread is no relying on the bit but always leaving the wait-loop after returning from schedule() because there must have been a wakeup. The smpboot-threads implementation for per-CPU threads requires an explicit condition and does not support "if we get out of schedule() then there must be something to do". Removing this optimisation simplifies the following integration. Set NAPI_STATE_SCHED_THREADED unconditionally on wakeup and rely on it in the wait path by removing the `woken' condition. Acked-by: Jakub Kicinski Signed-off-by: Sebastian Andrzej Siewior Signed-off-by: Paolo Abeni Signed-off-by: Wen Yang --- net/core/dev.c | 14 ++------------ 1 file changed, 2 insertions(+), 12 deletions(-) diff --git a/net/core/dev.c b/net/core/dev.c index e35f41e75bdd..83475b8b3e9d 100644 --- a/net/core/dev.c +++ b/net/core/dev.c @@ -4447,13 +4447,7 @@ static inline void ____napi_schedule(struct softnet_= data *sd, */ thread =3D READ_ONCE(napi->thread); if (thread) { - /* Avoid doing set_bit() if the thread is in - * INTERRUPTIBLE state, cause napi_thread_wait() - * makes sure to proceed with napi polling - * if the thread is explicitly woken from here. - */ - if (READ_ONCE(thread->__state) !=3D TASK_INTERRUPTIBLE) - set_bit(NAPI_STATE_SCHED_THREADED, &napi->state); + set_bit(NAPI_STATE_SCHED_THREADED, &napi->state); wake_up_process(thread); return; } @@ -6672,8 +6666,6 @@ static int napi_poll(struct napi_struct *n, struct li= st_head *repoll) =20 static int napi_thread_wait(struct napi_struct *napi) { - bool woken =3D false; - set_current_state(TASK_INTERRUPTIBLE); =20 while (!kthread_should_stop()) { @@ -6682,15 +6674,13 @@ static int napi_thread_wait(struct napi_struct *nap= i) * Testing SCHED bit is not enough because SCHED bit might be * set by some other busy poll thread or by napi_disable(). */ - if (test_bit(NAPI_STATE_SCHED_THREADED, &napi->state) || woken) { + if (test_bit(NAPI_STATE_SCHED_THREADED, &napi->state)) { WARN_ON(!list_empty(&napi->poll_list)); __set_current_state(TASK_RUNNING); return 0; } =20 schedule(); - /* woken being true indicates this thread owns this napi. */ - woken =3D true; set_current_state(TASK_INTERRUPTIBLE); } __set_current_state(TASK_RUNNING); --=20 2.25.1 From nobody Wed Feb 11 02:54:09 2026 Received: from out-185.mta0.migadu.com (out-185.mta0.migadu.com [91.218.175.185]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id EBF16231A21 for ; Sun, 18 Jan 2026 16:41:18 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=91.218.175.185 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1768754480; cv=none; b=qgWOHpJ+mk4hMPFZ4JztqafDaA/W7dr5QPH2gzYDlxz/+L/ciMhiV2Qr6K6TGHDGiCKr22ZBu1nRpsQp6Fzm8fjr9QHz7wTfQYpsqjj1DsUZC2i9AZupZSTV0nF8q9Cq5k+7TcHL8dKp5X/F+zACUX/S8/CqioW2WvRQqU8jbeU= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1768754480; c=relaxed/simple; bh=6wXP1LR54sHqLQuuvws+SCHfq+U909va1VrcCDVpiuI=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=E2I6EJVbpQ8B6aUCPbpH1ybqIIjNDrjrizplNwP2V0EYokaFIbPCwBK8oewSmyAosQ7yf42T7HSJ10R4bDkctxwMEOjg8F+lpS/eYt1K+v4jB2rVi+shOT/R7jbYvWud/Qor5U1Drmb4MTj6qvqR2JlQdpItvlHvWqjWcGegWlQ= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=linux.dev; spf=pass smtp.mailfrom=linux.dev; dkim=pass (1024-bit key) header.d=linux.dev header.i=@linux.dev header.b=FkQgglza; arc=none smtp.client-ip=91.218.175.185 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=linux.dev Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=linux.dev Authentication-Results: smtp.subspace.kernel.org; dkim=pass (1024-bit key) header.d=linux.dev header.i=@linux.dev header.b="FkQgglza" X-Report-Abuse: Please report any abuse attempt to abuse@migadu.com and include these headers. DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linux.dev; s=key1; t=1768754477; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=bEA5kumbe6+CLic5avtlE1pQHjl/O4RKdWmfyHolhz0=; b=FkQgglzaUENEMFUuvBrAWD5NMTETncWQ3ZujCx6zUGfozZU8vVj+pcRiF12nE3OkQDYib5 yaxjjVizBigX8MkbKE7BCqhSy3GW2NsP+iregAumlP9wnY+M5y1/YcWyJtWxmivAIzDVyh CMzxUAPkLW2vA4ZmIoLnFEsgRIRb0q0= From: wen.yang@linux.dev To: Greg Kroah-Hartman Cc: stable@vger.kernel.org, linux-kernel@vger.kernel.org, Sebastian Andrzej Siewior , Jakub Kicinski , Paolo Abeni , Wen Yang Subject: [PATCH 6.1 3/3] net: Allow to use SMP threads for backlog NAPI. Date: Mon, 19 Jan 2026 00:40:33 +0800 Message-Id: <7f6344848b554afba64529d461904951e387011e.1768754220.git.wen.yang@linux.dev> In-Reply-To: References: Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-Migadu-Flow: FLOW_OUT Content-Type: text/plain; charset="utf-8" From: Sebastian Andrzej Siewior commit dad6b97702639fba27a2bd3e986982ad6f0db3a7 upstream. Backlog NAPI is a per-CPU NAPI struct only (with no device behind it) used by drivers which don't do NAPI them self, RPS and parts of the stack which need to avoid recursive deadlocks while processing a packet. The non-NAPI driver use the CPU local backlog NAPI. If RPS is enabled then a flow for the skb is computed and based on the flow the skb can be enqueued on a remote CPU. Scheduling/ raising the softirq (for backlog's NAPI) on the remote CPU isn't trivial because the softirq is only scheduled on the local CPU and performed after the hardirq is done. In order to schedule a softirq on the remote CPU, an IPI is sent to the remote CPU which schedules the backlog-NAPI on the then local CPU. On PREEMPT_RT interrupts are force-threaded. The soft interrupts are raised within the interrupt thread and processed after the interrupt handler completed still within the context of the interrupt thread. The softirq is handled in the context where it originated. With force-threaded interrupts enabled, ksoftirqd is woken up if a softirq is raised from hardirq context. This is the case if it is raised from an IPI. Additionally there is a warning on PREEMPT_RT if the softirq is raised from the idle thread. This was done for two reasons: - With threaded interrupts the processing should happen in thread context (where it originated) and ksoftirqd is the only thread for this context if raised from hardirq. Using the currently running task instead would "punish" a random task. - Once ksoftirqd is active it consumes all further softirqs until it stops running. This changed recently and is no longer the case. Instead of keeping the backlog NAPI in ksoftirqd (in force-threaded/ PREEMPT_RT setups) I am proposing NAPI-threads for backlog. The "proper" setup with threaded-NAPI is not doable because the threads are not pinned to an individual CPU and can be modified by the user. Additionally a dummy network device would have to be assigned. Also CPU-hotplug has to be considered if additional CPUs show up. All this can be probably done/ solved but the smpboot-threads already provide this infrastructure. Sending UDP packets over loopback expects that the packet is processed within the call. Delaying it by handing it over to the thread hurts performance. It is not beneficial to the outcome if the context switch happens immediately after enqueue or after a while to process a few packets in a batch. There is no need to always use the thread if the backlog NAPI is requested on the local CPU. This restores the loopback throuput. The performance drops mostly to the same value after enabling RPS on the loopback comparing the IPI and the tread result. Create NAPI-threads for backlog if request during boot. The thread runs the inner loop from napi_threaded_poll(), the wait part is different. It checks for NAPI_STATE_SCHED (the backlog NAPI can not be disabled). The NAPI threads for backlog are optional, it has to be enabled via the boot argument "thread_backlog_napi". It is mandatory for PREEMPT_RT to avoid the wakeup of ksoftirqd from the IPI. Acked-by: Jakub Kicinski Signed-off-by: Sebastian Andrzej Siewior Signed-off-by: Paolo Abeni Signed-off-by: Wen Yang --- net/core/dev.c | 130 +++++++++++++++++++++++++++++++++++++++---------- 1 file changed, 104 insertions(+), 26 deletions(-) diff --git a/net/core/dev.c b/net/core/dev.c index 83475b8b3e9d..678848e116d2 100644 --- a/net/core/dev.c +++ b/net/core/dev.c @@ -78,6 +78,7 @@ #include #include #include +#include #include #include #include @@ -217,6 +218,31 @@ static inline struct hlist_head *dev_index_hash(struct= net *net, int ifindex) return &net->dev_index_head[ifindex & (NETDEV_HASHENTRIES - 1)]; } =20 +#ifndef CONFIG_PREEMPT_RT + +static DEFINE_STATIC_KEY_FALSE(use_backlog_threads_key); + +static int __init setup_backlog_napi_threads(char *arg) +{ + static_branch_enable(&use_backlog_threads_key); + return 0; +} +early_param("thread_backlog_napi", setup_backlog_napi_threads); + +static bool use_backlog_threads(void) +{ + return static_branch_unlikely(&use_backlog_threads_key); +} + +#else + +static bool use_backlog_threads(void) +{ + return true; +} + +#endif + static inline void rps_lock_irqsave(struct softnet_data *sd, unsigned long *flags) { @@ -4415,6 +4441,7 @@ EXPORT_SYMBOL(__dev_direct_xmit); /************************************************************************* * Receiver routines *************************************************************************/ +static DEFINE_PER_CPU(struct task_struct *, backlog_napi); =20 int netdev_max_backlog __read_mostly =3D 1000; EXPORT_SYMBOL(netdev_max_backlog); @@ -4447,12 +4474,16 @@ static inline void ____napi_schedule(struct softnet= _data *sd, */ thread =3D READ_ONCE(napi->thread); if (thread) { + if (use_backlog_threads() && thread =3D=3D raw_cpu_read(backlog_napi)) + goto use_local_napi; + set_bit(NAPI_STATE_SCHED_THREADED, &napi->state); wake_up_process(thread); return; } } =20 +use_local_napi: list_add_tail(&napi->poll_list, &sd->poll_list); __raise_softirq_irqoff(NET_RX_SOFTIRQ); } @@ -4695,6 +4726,11 @@ static void napi_schedule_rps(struct softnet_data *s= d) =20 #ifdef CONFIG_RPS if (sd !=3D mysd) { + if (use_backlog_threads()) { + __napi_schedule_irqoff(&sd->backlog); + return; + } + sd->rps_ipi_next =3D mysd->rps_ipi_list; mysd->rps_ipi_list =3D sd; =20 @@ -5979,7 +6015,7 @@ static void net_rps_action_and_irq_enable(struct soft= net_data *sd) #ifdef CONFIG_RPS struct softnet_data *remsd =3D sd->rps_ipi_list; =20 - if (remsd) { + if (!use_backlog_threads() && remsd) { sd->rps_ipi_list =3D NULL; =20 local_irq_enable(); @@ -5994,7 +6030,7 @@ static void net_rps_action_and_irq_enable(struct soft= net_data *sd) static bool sd_has_rps_ipi_waiting(struct softnet_data *sd) { #ifdef CONFIG_RPS - return sd->rps_ipi_list !=3D NULL; + return !use_backlog_threads() && sd->rps_ipi_list; #else return false; #endif @@ -6038,7 +6074,7 @@ static int process_backlog(struct napi_struct *napi, = int quota) * We can use a plain write instead of clear_bit(), * and we dont need an smp_mb() memory barrier. */ - napi->state =3D 0; + napi->state &=3D NAPIF_STATE_THREADED; again =3D false; } else { skb_queue_splice_tail_init(&sd->input_pkt_queue, @@ -6688,32 +6724,37 @@ static int napi_thread_wait(struct napi_struct *nap= i) return -1; } =20 -static int napi_threaded_poll(void *data) +static void napi_threaded_poll_loop(struct napi_struct *napi) { - struct napi_struct *napi =3D data; - void *have; - - while (!napi_thread_wait(napi)) { - unsigned long last_qs =3D jiffies; + unsigned long last_qs =3D jiffies; =20 - for (;;) { - bool repoll =3D false; + for (;;) { + bool repoll =3D false; + void *have; =20 - local_bh_disable(); + local_bh_disable(); =20 - have =3D netpoll_poll_lock(napi); - __napi_poll(napi, &repoll); - netpoll_poll_unlock(have); + have =3D netpoll_poll_lock(napi); + __napi_poll(napi, &repoll); + netpoll_poll_unlock(have); =20 - local_bh_enable(); + local_bh_enable(); =20 - if (!repoll) - break; + if (!repoll) + break; =20 - rcu_softirq_qs_periodic(last_qs); - cond_resched(); - } + rcu_softirq_qs_periodic(last_qs); + cond_resched(); } +} + +static int napi_threaded_poll(void *data) +{ + struct napi_struct *napi =3D data; + + while (!napi_thread_wait(napi)) + napi_threaded_poll_loop(napi); + return 0; } =20 @@ -11238,7 +11279,7 @@ static int dev_cpu_dead(unsigned int oldcpu) =20 list_del_init(&napi->poll_list); if (napi->poll =3D=3D process_backlog) - napi->state =3D 0; + napi->state &=3D NAPIF_STATE_THREADED; else ____napi_schedule(sd, napi); } @@ -11246,12 +11287,14 @@ static int dev_cpu_dead(unsigned int oldcpu) raise_softirq_irqoff(NET_TX_SOFTIRQ); local_irq_enable(); =20 + if (!use_backlog_threads()) { #ifdef CONFIG_RPS - remsd =3D oldsd->rps_ipi_list; - oldsd->rps_ipi_list =3D NULL; + remsd =3D oldsd->rps_ipi_list; + oldsd->rps_ipi_list =3D NULL; #endif - /* send out pending IPI's on offline CPU */ - net_rps_send_ipi(remsd); + /* send out pending IPI's on offline CPU */ + net_rps_send_ipi(remsd); + } =20 /* Process offline CPU's input_pkt_queue */ while ((skb =3D __skb_dequeue(&oldsd->process_queue))) { @@ -11511,6 +11554,38 @@ static struct pernet_operations __net_initdata def= ault_device_ops =3D { * */ =20 +static int backlog_napi_should_run(unsigned int cpu) +{ + struct softnet_data *sd =3D per_cpu_ptr(&softnet_data, cpu); + struct napi_struct *napi =3D &sd->backlog; + + return test_bit(NAPI_STATE_SCHED_THREADED, &napi->state); +} + +static void run_backlog_napi(unsigned int cpu) +{ + struct softnet_data *sd =3D per_cpu_ptr(&softnet_data, cpu); + + napi_threaded_poll_loop(&sd->backlog); +} + +static void backlog_napi_setup(unsigned int cpu) +{ + struct softnet_data *sd =3D per_cpu_ptr(&softnet_data, cpu); + struct napi_struct *napi =3D &sd->backlog; + + napi->thread =3D this_cpu_read(backlog_napi); + set_bit(NAPI_STATE_THREADED, &napi->state); +} + +static struct smp_hotplug_thread backlog_threads =3D { + .store =3D &backlog_napi, + .thread_should_run =3D backlog_napi_should_run, + .thread_fn =3D run_backlog_napi, + .thread_comm =3D "backlog_napi/%u", + .setup =3D backlog_napi_setup, +}; + /* * This is called single threaded during boot, so no need * to take the rtnl semaphore. @@ -11561,7 +11636,10 @@ static int __init net_dev_init(void) init_gro_hash(&sd->backlog); sd->backlog.poll =3D process_backlog; sd->backlog.weight =3D weight_p; + INIT_LIST_HEAD(&sd->backlog.poll_list); } + if (use_backlog_threads()) + smpboot_register_percpu_thread(&backlog_threads); =20 dev_boot_phase =3D 0; =20 --=20 2.25.1