diff --git a/arch/arm64/configs/openeuler_defconfig b/arch/arm64/configs/openeuler_defconfig
index 7560b47d69fc93c1f01f7f6ad4d905890a469f81..f8ccedacafd0c0927652cf0e8b2b5397bd33a62c 100644
--- a/arch/arm64/configs/openeuler_defconfig
+++ b/arch/arm64/configs/openeuler_defconfig
@@ -2479,6 +2479,7 @@ CONFIG_CHR_DEV_SCH=m
 CONFIG_SCSI_ENCLOSURE=m
 CONFIG_SCSI_CONSTANTS=y
 CONFIG_SCSI_LOGGING=y
+CONFIG_SCSI_KWORKER=y
 CONFIG_SCSI_SCAN_ASYNC=y
 
 #
diff --git a/arch/x86/configs/openeuler_defconfig b/arch/x86/configs/openeuler_defconfig
index 627a08ecbf4adfea6d2b76ddf8a4e7f647c752b6..9c12b2633cdf0a780a4dcf0d83be196a551776b7 100644
--- a/arch/x86/configs/openeuler_defconfig
+++ b/arch/x86/configs/openeuler_defconfig
@@ -2477,6 +2477,7 @@ CONFIG_CHR_DEV_SCH=m
 CONFIG_SCSI_ENCLOSURE=m
 CONFIG_SCSI_CONSTANTS=y
 CONFIG_SCSI_LOGGING=y
+CONFIG_SCSI_KWORKER=y
 CONFIG_SCSI_SCAN_ASYNC=y
 
 #
diff --git a/drivers/scsi/Kconfig b/drivers/scsi/Kconfig
index 695a57d894cdd0cba13bd1462ca7f2bf4a368b9a..cc44558fd1f6d378bcce3c22d47caf147d7d8b3b 100644
--- a/drivers/scsi/Kconfig
+++ b/drivers/scsi/Kconfig
@@ -218,6 +218,23 @@ config SCSI_LOGGING
 	  there should be no noticeable performance impact as long as you have
 	  logging turned off.
 
+config SCSI_KWORKER
+	tristate "kworker NUMA affinity "
+	default n
+	help
+	  kworker: Fix the problem of ipsan performance degradation on ARM
+          architecture.
+
+	  When the current downstream FS tests IPSAN, it is found that the
+	  performance on ARM is much worse than that on X86, and the test data
+	  of IPSAN fluctuates greatly. After analysis, the reason is that when
+	  iscsi issues IO, the task is sent to kworker for processing by
+	  iscsi_xmitworker.
+
+	  The workqueue created by iscsi can automatically identify the CPU of
+	  the soft interrupt currently processed by iscsi, and automatically
+	  schedule the workqueue to the corresponding NUMA node.
+
 config SCSI_SCAN_ASYNC
 	bool "Asynchronous SCSI scanning"
 	depends on SCSI
diff --git a/drivers/scsi/iscsi_tcp.c b/drivers/scsi/iscsi_tcp.c
index 8e14cea15f980829e99afa2c43bf6872fcfd965c..de6dfb1a47bb66fe8332baccdd8c5c8b14bb055c 100644
--- a/drivers/scsi/iscsi_tcp.c
+++ b/drivers/scsi/iscsi_tcp.c
@@ -170,6 +170,9 @@ static void iscsi_sw_tcp_data_ready(struct sock *sk)
 	struct iscsi_sw_tcp_conn *tcp_sw_conn;
 	struct iscsi_tcp_conn *tcp_conn;
 	struct iscsi_conn *conn;
+#ifdef CONFIG_SCSI_KWORKER
+	int current_cpu;
+#endif
 
 	trace_sk_data_ready(sk);
 
@@ -180,6 +183,16 @@ static void iscsi_sw_tcp_data_ready(struct sock *sk)
 		return;
 	}
 	tcp_conn = conn->dd_data;
+
+#ifdef CONFIG_SCSI_KWORKER
+        /* save intimate cpu when in softirq */
+        if (!sock_owned_by_user_nocheck(sk)) {
+                current_cpu = smp_processor_id();
+                if (conn->intimate_cpu != current_cpu)
+                        conn->intimate_cpu = current_cpu;
+        }
+#endif
+
 	tcp_sw_conn = tcp_conn->dd_data;
 
 	if (tcp_sw_conn->queue_recv)
diff --git a/drivers/scsi/libiscsi.c b/drivers/scsi/libiscsi.c
index 0fda8905eabd8278f578e54a8f502ab2996629ed..a64922409be8bde201c4e0ce37914094ec225880 100644
--- a/drivers/scsi/libiscsi.c
+++ b/drivers/scsi/libiscsi.c
@@ -89,9 +89,20 @@ inline void iscsi_conn_queue_xmit(struct iscsi_conn *conn)
 {
 	struct Scsi_Host *shost = conn->session->host;
 	struct iscsi_host *ihost = shost_priv(shost);
+#ifdef CONFIG_SCSI_KWORKER
+	int intimate_cpu = conn->intimate_cpu;
 
+	if (ihost->workq) {
+	        /* we expect it to be excuted on the same numa of the intimate cpu */
+	        if ((intimate_cpu >= 0) && cpu_possible(intimate_cpu))
+	                queue_work_on(intimate_cpu, ihost->workq, &conn->xmitwork);
+	        else
+	                queue_work(ihost->workq, &conn->xmitwork);
+	}
+#else
 	if (ihost->workq)
 		queue_work(ihost->workq, &conn->xmitwork);
+#endif
 }
 EXPORT_SYMBOL_GPL(iscsi_conn_queue_xmit);
 
@@ -2907,9 +2918,15 @@ struct Scsi_Host *iscsi_host_alloc(const struct scsi_host_template *sht,
 	ihost = shost_priv(shost);
 
 	if (xmit_can_sleep) {
+#ifdef CONFIG_SCSI_KWORKER
+		/* this kind of workqueue only support single work */
+		ihost->workq = alloc_ordered_workqueue("iscsi_q_%d", __WQ_LEGACY | WQ_MEM_RECLAIM |
+				                        __WQ_DYNAMIC, shost->host_no);
+#else
 		ihost->workq = alloc_workqueue("iscsi_q_%d",
-			WQ_SYSFS | __WQ_LEGACY | WQ_MEM_RECLAIM | WQ_UNBOUND,
+		        WQ_SYSFS | __WQ_LEGACY | WQ_MEM_RECLAIM | WQ_UNBOUND,
 			1, shost->host_no);
+#endif
 		if (!ihost->workq)
 			goto free_host;
 	}
@@ -3190,6 +3207,9 @@ iscsi_conn_setup(struct iscsi_cls_session *cls_session, int dd_size,
 	conn->c_stage = ISCSI_CONN_INITIAL_STAGE;
 	conn->id = conn_idx;
 	conn->exp_statsn = 0;
+#ifdef CONFIG_SCSI_KWORKER
+	conn->intimate_cpu = -1;
+#endif
 
 	timer_setup(&conn->transport_timer, iscsi_check_transport_timeouts, 0);
 
diff --git a/include/linux/workqueue.h b/include/linux/workqueue.h
index 9619098755fb3d24fb3bf24b4d0ca43c992035ad..485c0f5b251882d5ce3dc30e5c65f02d08043609 100644
--- a/include/linux/workqueue.h
+++ b/include/linux/workqueue.h
@@ -415,6 +415,7 @@ enum {
 	__WQ_ORDERED		= 1 << 17, /* internal: workqueue is ordered */
 	__WQ_LEGACY		= 1 << 18, /* internal: create*_workqueue() */
 	__WQ_ORDERED_EXPLICIT	= 1 << 19, /* internal: alloc_ordered_workqueue() */
+	__WQ_DYNAMIC            = 1 << 25, /* internal: only support single work order WQ */
 
 	WQ_MAX_ACTIVE		= 512,	  /* I like 512, better ideas? */
 	WQ_UNBOUND_MAX_ACTIVE	= WQ_MAX_ACTIVE,
diff --git a/include/scsi/libiscsi.h b/include/scsi/libiscsi.h
index d253b82e973e43e08721bfaab14ef2b9503d1000..ead17d2224a1f231b072265ffe8c2bca5705b44c 100644
--- a/include/scsi/libiscsi.h
+++ b/include/scsi/libiscsi.h
@@ -266,6 +266,7 @@ struct iscsi_conn {
 	/* custom statistics */
 	uint32_t		eh_abort_cnt;
 	uint32_t		fmr_unalign_cnt;
+	int			intimate_cpu;
 
 	KABI_RESERVE(1)
 	KABI_RESERVE(2)
diff --git a/kernel/workqueue.c b/kernel/workqueue.c
index 1888741f5edd79e6cbf88f4a82e16e44e36f0f7f..2ee454ae898cf56a9442997eb3895ee7c6659d9c 100644
--- a/kernel/workqueue.c
+++ b/kernel/workqueue.c
@@ -4355,6 +4355,11 @@ apply_wqattrs_prepare(struct workqueue_struct *wq,
 	 * it even if we don't use it immediately.
 	 */
 	copy_workqueue_attrs(new_attrs, attrs);
+#ifdef CONFIG_SCSI_KWORKER
+	if (wq->flags & __WQ_DYNAMIC)
+		new_attrs->ordered = false;
+#endif
+
 	wqattrs_actualize_cpumask(new_attrs, unbound_cpumask);
 	cpumask_copy(new_attrs->__pod_cpumask, new_attrs->cpumask);
 	ctx->dfl_pwq = alloc_unbound_pwq(wq, new_attrs);
@@ -4591,10 +4596,19 @@ static int alloc_and_link_pwqs(struct workqueue_struct *wq)
 	cpus_read_lock();
 	if (wq->flags & __WQ_ORDERED) {
 		ret = apply_workqueue_attrs(wq, ordered_wq_attrs[highpri]);
+#ifdef CONFIG_SCSI_KWORKER
+		if (!(wq->flags & __WQ_DYNAMIC)) {
+                       /* there should only be single pwq for ordering guarantee */
+                       WARN(!ret && (wq->pwqs.next != &wq->dfl_pwq->pwqs_node ||
+                                       wq->pwqs.prev != &wq->dfl_pwq->pwqs_node),
+                                       "ordering guarantee broken for workqueue %s\n", wq->name);
+               }
+#else
 		/* there should only be single pwq for ordering guarantee */
 		WARN(!ret && (wq->pwqs.next != &wq->dfl_pwq->pwqs_node ||
 			      wq->pwqs.prev != &wq->dfl_pwq->pwqs_node),
 		     "ordering guarantee broken for workqueue %s\n", wq->name);
+#endif
 	} else {
 		ret = apply_workqueue_attrs(wq, unbound_std_wq_attrs[highpri]);
 	}
@@ -5798,7 +5812,11 @@ static int workqueue_apply_unbound_cpumask(const cpumask_var_t unbound_cpumask)
 			continue;
 
 		/* creating multiple pwqs breaks ordering guarantee */
+#ifdef CONFIG_SCSI_KWORKER
+		if (!list_empty(&wq->pwqs) && !(wq->flags & __WQ_DYNAMIC)) {
+#else
 		if (!list_empty(&wq->pwqs)) {
+#endif
 			if (wq->flags & __WQ_ORDERED_EXPLICIT)
 				continue;
 			wq->flags &= ~__WQ_ORDERED;