AMD-GFX Archive on lore.kernel.org
 help / color / mirror / Atom feed
* [PATCH 1/9] drm/amdgpu/mes11: add API for gang submit
@ 2026-11-17 19:24 Alex Deucher
  2026-11-17 19:24 ` [PATCH 2/9] drm/amdgpu/mes: add callback " Alex Deucher
                   ` (7 more replies)
  0 siblings, 8 replies; 13+ messages in thread
From: Alex Deucher @ 2026-11-17 19:24 UTC (permalink / raw)
  To: amd-gfx; +Cc: Alex Deucher, Yogesh Mohan Marimuthu

Add API for setting up a gang.  Gangs schedule together.

Cc: Yogesh Mohan Marimuthu <yogesh.mohanmarimuthu@amd.com>
Signed-off-by: Alex Deucher <alexander.deucher@amd.com>
---
 drivers/gpu/drm/amd/amdgpu/mes_v11_0.c        |  2 +-
 drivers/gpu/drm/amd/include/mes_v11_api_def.h | 18 ++++++++++++++++++
 2 files changed, 19 insertions(+), 1 deletion(-)

diff --git a/drivers/gpu/drm/amd/amdgpu/mes_v11_0.c b/drivers/gpu/drm/amd/amdgpu/mes_v11_0.c
index 30d3d25d59842..0242fe8135374 100644
--- a/drivers/gpu/drm/amd/amdgpu/mes_v11_0.c
+++ b/drivers/gpu/drm/amd/amdgpu/mes_v11_0.c
@@ -147,7 +147,7 @@ static const char *mes_v11_0_opcodes[] = {
 	"UPDATE_ROOT_PAGE_TABLE",
 	"AMD_LOG",
 	"unused",
-	"unused",
+	"SET_GANG_SUBMIT",
 	"SET_HW_RSRC_1",
 };
 
diff --git a/drivers/gpu/drm/amd/include/mes_v11_api_def.h b/drivers/gpu/drm/amd/include/mes_v11_api_def.h
index 6d67d015a74fb..bf2161b2328ad 100644
--- a/drivers/gpu/drm/amd/include/mes_v11_api_def.h
+++ b/drivers/gpu/drm/amd/include/mes_v11_api_def.h
@@ -64,6 +64,7 @@ enum MES_SCH_API_OPCODE {
 	MES_SCH_API_MISC			= 14,
 	MES_SCH_API_UPDATE_ROOT_PAGE_TABLE      = 15,
 	MES_SCH_API_AMD_LOG                     = 16,
+	MES_SCH_API_SET_GANG_SUBMIT             = 18,
 	MES_SCH_API_SET_HW_RSRC_1               = 19,
 	MES_SCH_API_MAX				= 0xFF
 };
@@ -688,6 +689,13 @@ struct SET_SHADER_DEBUGGER {
 	uint32_t process_context_array_index;
 };
 
+struct SET_GANG_SUBMIT {
+	uint64_t gang_context_addr;
+	uint64_t slave_gang_context_addr;
+	uint32_t gang_context_array_index;
+	uint32_t slave_gang_context_array_index;
+};
+
 enum MESAPI_MISC__CHANGE_CONFIG_OPTION {
 	MESAPI_MISC__CHANGE_CONFIG_OPTION_LIMIT_SINGLE_PROCESS = 0,
 	MESAPI_MISC__CHANGE_CONFIG_OPTION_ENABLE_HWS_LOGGING_BUFFER = 1,
@@ -775,5 +783,15 @@ union MESAPI_AMD_LOG {
 	uint32_t max_dwords_in_api[API_FRAME_SIZE_IN_DWORDS];
 };
 
+union MESAPI__SET_GANG_SUBMIT {
+	struct {
+		union MES_API_HEADER    header;
+		struct MES_API_STATUS   api_status;
+		struct SET_GANG_SUBMIT  set_gang_submit;
+	};
+
+	uint32_t max_dwords_in_api[API_FRAME_SIZE_IN_DWORDS];
+};
+
 #pragma pack(pop)
 #endif
-- 
2.56.1


^ permalink raw reply related	[flat|nested] 13+ messages in thread

* [PATCH 2/9] drm/amdgpu/mes: add callback for gang submit
  2026-11-17 19:24 [PATCH 1/9] drm/amdgpu/mes11: add API for gang submit Alex Deucher
@ 2026-11-17 19:24 ` Alex Deucher
  2026-11-17 19:24 ` [PATCH 3/9] drm/amdgpu/mes11: add support for setting " Alex Deucher
                   ` (6 subsequent siblings)
  7 siblings, 0 replies; 13+ messages in thread
From: Alex Deucher @ 2026-11-17 19:24 UTC (permalink / raw)
  To: amd-gfx; +Cc: Alex Deucher, Yogesh Mohan Marimuthu

Add function pointer for gang submit setup.

Cc: Yogesh Mohan Marimuthu <yogesh.mohanmarimuthu@amd.com>
Signed-off-by: Alex Deucher <alexander.deucher@amd.com>
---
 drivers/gpu/drm/amd/amdgpu/amdgpu_mes.h | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_mes.h b/drivers/gpu/drm/amd/amdgpu/amdgpu_mes.h
index e5dbcf8ef890a..223326669c109 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_mes.h
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_mes.h
@@ -401,6 +401,11 @@ struct mes_inv_tlbs_pasid_input {
 	uint8_t         flush_type;
 };
 
+struct mes_set_gang_submit_input {
+	uint64_t	primary_gang_context_addr;
+	uint64_t	secondary_gang_context_addr;
+};
+
 enum mes_misc_opcode {
 	MES_MISC_OP_WRITE_REG,
 	MES_MISC_OP_READ_REG,
@@ -520,6 +525,9 @@ struct amdgpu_mes_funcs {
 
 	int (*invalidate_tlbs_pasid)(struct amdgpu_mes *mes,
 			      struct mes_inv_tlbs_pasid_input *input);
+
+	int (*set_gang_submit)(struct amdgpu_mes *mes,
+			       struct mes_set_gang_submit_input *input);
 };
 
 enum amdgpu_mqd_update_flag {
-- 
2.56.1


^ permalink raw reply related	[flat|nested] 13+ messages in thread

* [PATCH 3/9] drm/amdgpu/mes11: add support for setting gang submit
  2026-11-17 19:24 [PATCH 1/9] drm/amdgpu/mes11: add API for gang submit Alex Deucher
  2026-11-17 19:24 ` [PATCH 2/9] drm/amdgpu/mes: add callback " Alex Deucher
@ 2026-11-17 19:24 ` Alex Deucher
  2026-11-17 19:37   ` sashiko-bot
  2026-11-17 19:24 ` [PATCH 4/9] drm/amdgpu/mes12: " Alex Deucher
                   ` (5 subsequent siblings)
  7 siblings, 1 reply; 13+ messages in thread
From: Alex Deucher @ 2026-11-17 19:24 UTC (permalink / raw)
  To: amd-gfx; +Cc: Alex Deucher, Yogesh Mohan Marimuthu

Enable a primary and secondary queue that schedule together.

v2: fix offset of api_status (Prike)

Cc: Yogesh Mohan Marimuthu <yogesh.mohanmarimuthu@amd.com>
Signed-off-by: Alex Deucher <alexander.deucher@amd.com>
---
 drivers/gpu/drm/amd/amdgpu/mes_v11_0.c | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)

diff --git a/drivers/gpu/drm/amd/amdgpu/mes_v11_0.c b/drivers/gpu/drm/amd/amdgpu/mes_v11_0.c
index 0242fe8135374..6b6ffc05d8145 100644
--- a/drivers/gpu/drm/amd/amdgpu/mes_v11_0.c
+++ b/drivers/gpu/drm/amd/amdgpu/mes_v11_0.c
@@ -1283,6 +1283,27 @@ static int mes_v11_0_enable_dbgext_irq(struct amdgpu_mes *mes, bool enable)
 	return 0;
 }
 
+static int mes_v11_0_set_gang_submit(struct amdgpu_mes *mes,
+				     struct mes_set_gang_submit_input *input)
+{
+	union MESAPI__SET_GANG_SUBMIT mes_gang_submit_pkt;
+
+	memset(&mes_gang_submit_pkt, 0, sizeof(mes_gang_submit_pkt));
+
+	mes_gang_submit_pkt.header.type = MES_API_TYPE_SCHEDULER;
+	mes_gang_submit_pkt.header.opcode = MES_SCH_API_SET_GANG_SUBMIT;
+	mes_gang_submit_pkt.header.dwsize = API_FRAME_SIZE_IN_DWORDS;
+
+	mes_gang_submit_pkt.set_gang_submit.gang_context_addr =
+		input->primary_gang_context_addr;
+	mes_gang_submit_pkt.set_gang_submit.slave_gang_context_addr =
+		input->secondary_gang_context_addr;
+
+	return mes_v11_0_submit_pkt_and_poll_completion(mes,
+			&mes_gang_submit_pkt, sizeof(mes_gang_submit_pkt),
+			offsetof(union MESAPI__SET_GANG_SUBMIT, api_status));
+}
+
 static const struct amdgpu_mes_funcs mes_v11_0_funcs = {
 	.add_hw_queue = mes_v11_0_add_hw_queue,
 	.remove_hw_queue = mes_v11_0_remove_hw_queue,
@@ -1294,6 +1315,7 @@ static const struct amdgpu_mes_funcs mes_v11_0_funcs = {
 	.enable_dbgext_irq = mes_v11_0_enable_dbgext_irq,
 	.reset_hw_queue = mes_v11_0_reset_hw_queue,
 	.detect_and_reset_hung_queues = mes_v11_0_detect_and_reset_hung_queues,
+	.set_gang_submit = mes_v11_0_set_gang_submit,
 };
 
 static int mes_v11_0_allocate_ucode_buffer(struct amdgpu_device *adev,
-- 
2.56.1


^ permalink raw reply related	[flat|nested] 13+ messages in thread

* [PATCH 4/9] drm/amdgpu/mes12: add support for setting gang submit
  2026-11-17 19:24 [PATCH 1/9] drm/amdgpu/mes11: add API for gang submit Alex Deucher
  2026-11-17 19:24 ` [PATCH 2/9] drm/amdgpu/mes: add callback " Alex Deucher
  2026-11-17 19:24 ` [PATCH 3/9] drm/amdgpu/mes11: add support for setting " Alex Deucher
@ 2026-11-17 19:24 ` Alex Deucher
  2026-11-17 19:24 ` [PATCH 5/9] drm/amdgpu/userq: add callback for gang setup Alex Deucher
                   ` (4 subsequent siblings)
  7 siblings, 0 replies; 13+ messages in thread
From: Alex Deucher @ 2026-11-17 19:24 UTC (permalink / raw)
  To: amd-gfx; +Cc: Alex Deucher, Yogesh Mohan Marimuthu

Enable a primary and secondary queue that schedule together.

v2: fix offset of api_status (Prike)
v3: use AMDGPU_MES_SCHED_PIPE (Michael)

Cc: Yogesh Mohan Marimuthu <yogesh.mohanmarimuthu@amd.com>
Signed-off-by: Alex Deucher <alexander.deucher@amd.com>
---
 drivers/gpu/drm/amd/amdgpu/mes_v12_0.c | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/drivers/gpu/drm/amd/amdgpu/mes_v12_0.c b/drivers/gpu/drm/amd/amdgpu/mes_v12_0.c
index 988e05823d2d7..87646eb0a9ab9 100644
--- a/drivers/gpu/drm/amd/amdgpu/mes_v12_0.c
+++ b/drivers/gpu/drm/amd/amdgpu/mes_v12_0.c
@@ -1313,7 +1313,27 @@ static int mes_v12_0_inv_tlbs_pasid(struct amdgpu_mes *mes,
 	return mes_v12_0_submit_pkt_and_poll_completion(mes, AMDGPU_MES_KIQ_PIPE,
 			&mes_inv_tlbs, sizeof(mes_inv_tlbs),
 			offsetof(union MESAPI__INV_TLBS, api_status));
+}
+
+static int mes_v12_0_set_gang_submit(struct amdgpu_mes *mes,
+				     struct mes_set_gang_submit_input *input)
+{
+	union MESAPI__SET_GANG_SUBMIT mes_gang_submit_pkt;
+
+	memset(&mes_gang_submit_pkt, 0, sizeof(mes_gang_submit_pkt));
 
+	mes_gang_submit_pkt.header.type = MES_API_TYPE_SCHEDULER;
+	mes_gang_submit_pkt.header.opcode = MES_SCH_API_SET_GANG_SUBMIT;
+	mes_gang_submit_pkt.header.dwsize = API_FRAME_SIZE_IN_DWORDS;
+
+	mes_gang_submit_pkt.set_gang_submit.gang_context_addr =
+		input->primary_gang_context_addr;
+	mes_gang_submit_pkt.set_gang_submit.slave_gang_context_addr =
+		input->secondary_gang_context_addr;
+
+	return mes_v12_0_submit_pkt_and_poll_completion(mes, AMDGPU_MES_SCHED_PIPE,
+			&mes_gang_submit_pkt, sizeof(mes_gang_submit_pkt),
+			offsetof(union MESAPI__SET_GANG_SUBMIT, api_status));
 }
 
 /*
@@ -1367,6 +1387,7 @@ static const struct amdgpu_mes_funcs mes_v12_0_funcs = {
 	.invalidate_tlbs_pasid = mes_v12_0_inv_tlbs_pasid,
 	.detect_and_reset_hung_queues = mes_v12_0_detect_and_reset_hung_queues,
 	.enable_dbgext_irq = mes_v12_0_enable_dbgext_irq,
+	.set_gang_submit = mes_v12_0_set_gang_submit,
 };
 
 static int mes_v12_0_allocate_ucode_buffer(struct amdgpu_device *adev,
-- 
2.56.1


^ permalink raw reply related	[flat|nested] 13+ messages in thread

* [PATCH 5/9] drm/amdgpu/userq: add callback for gang setup
  2026-11-17 19:24 [PATCH 1/9] drm/amdgpu/mes11: add API for gang submit Alex Deucher
                   ` (2 preceding siblings ...)
  2026-11-17 19:24 ` [PATCH 4/9] drm/amdgpu/mes12: " Alex Deucher
@ 2026-11-17 19:24 ` Alex Deucher
  2026-11-17 19:24 ` [PATCH 6/9] drm/amdgpu/userq/mes: implement set gang submit Alex Deucher
                   ` (3 subsequent siblings)
  7 siblings, 0 replies; 13+ messages in thread
From: Alex Deucher @ 2026-11-17 19:24 UTC (permalink / raw)
  To: amd-gfx; +Cc: Alex Deucher, Yogesh Mohan Marimuthu

Two queues can be ganged and will schedule together.

Cc: Yogesh Mohan Marimuthu <yogesh.mohanmarimuthu@amd.com>
Signed-off-by: Alex Deucher <alexander.deucher@amd.com>
---
 drivers/gpu/drm/amd/amdgpu/amdgpu_userq.h | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_userq.h b/drivers/gpu/drm/amd/amdgpu/amdgpu_userq.h
index 488dc21d7c81b..efaa658a26a9a 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_userq.h
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_userq.h
@@ -115,6 +115,8 @@ struct amdgpu_userq_funcs {
 	int (*preempt)(struct amdgpu_usermode_queue *queue);
 	int (*restore)(struct amdgpu_usermode_queue *queue);
 	int (*reset)(struct amdgpu_usermode_queue *queue);
+	int (*set_gang)(struct amdgpu_usermode_queue *primary_queue,
+			struct amdgpu_usermode_queue *secondary_queue);
 };
 
 /* Usermode queues for gfx */
-- 
2.56.1


^ permalink raw reply related	[flat|nested] 13+ messages in thread

* [PATCH 6/9] drm/amdgpu/userq/mes: implement set gang submit
  2026-11-17 19:24 [PATCH 1/9] drm/amdgpu/mes11: add API for gang submit Alex Deucher
                   ` (3 preceding siblings ...)
  2026-11-17 19:24 ` [PATCH 5/9] drm/amdgpu/userq: add callback for gang setup Alex Deucher
@ 2026-11-17 19:24 ` Alex Deucher
  2026-11-17 19:35   ` sashiko-bot
  2026-11-17 19:24 ` [PATCH 7/9] drm/amdgpu/userq: add handling for set_gang Alex Deucher
                   ` (2 subsequent siblings)
  7 siblings, 1 reply; 13+ messages in thread
From: Alex Deucher @ 2026-11-17 19:24 UTC (permalink / raw)
  To: amd-gfx; +Cc: Alex Deucher, Yogesh Mohan Marimuthu

Enable the userq callback for setting up gang submission.

Cc: Yogesh Mohan Marimuthu <yogesh.mohanmarimuthu@amd.com>
Signed-off-by: Alex Deucher <alexander.deucher@amd.com>
---
 drivers/gpu/drm/amd/amdgpu/mes_userqueue.c | 26 ++++++++++++++++++++++
 1 file changed, 26 insertions(+)

diff --git a/drivers/gpu/drm/amd/amdgpu/mes_userqueue.c b/drivers/gpu/drm/amd/amdgpu/mes_userqueue.c
index 7abb9d95ef59a..e186ebd08b8d2 100644
--- a/drivers/gpu/drm/amd/amdgpu/mes_userqueue.c
+++ b/drivers/gpu/drm/amd/amdgpu/mes_userqueue.c
@@ -649,6 +649,31 @@ static int mes_userq_restore(struct amdgpu_usermode_queue *queue)
 	return r;
 }
 
+static int mes_set_gang(struct amdgpu_usermode_queue *primary_queue,
+			struct amdgpu_usermode_queue *secondary_queue)
+{
+	struct amdgpu_userq_obj *primary_ctx = &primary_queue->fw_obj;
+	struct amdgpu_userq_obj *secondary_ctx = &secondary_queue->fw_obj;
+	struct amdgpu_userq_mgr *uq_mgr = primary_queue->userq_mgr;
+	struct amdgpu_device *adev = uq_mgr->adev;
+	struct mes_set_gang_submit_input input;
+	int r;
+
+	memset(&input, 0x0, sizeof(struct mes_set_gang_submit_input));
+
+	input.primary_gang_context_addr =
+		primary_ctx->gpu_addr + AMDGPU_USERQ_PROC_CTX_SZ;
+	input.secondary_gang_context_addr =
+		secondary_ctx->gpu_addr + AMDGPU_USERQ_PROC_CTX_SZ;
+
+	amdgpu_mes_lock(&adev->mes);
+	r = adev->mes.funcs->set_gang_submit(&adev->mes, &input);
+	amdgpu_mes_unlock(&adev->mes);
+	if (r)
+		dev_err(adev->dev, "Failed to set gang submit, err (%d)\n", r);
+	return r;
+}
+
 const struct amdgpu_userq_funcs userq_mes_funcs = {
 	.mqd_create = mes_userq_mqd_create,
 	.mqd_destroy = mes_userq_mqd_destroy,
@@ -657,4 +682,5 @@ const struct amdgpu_userq_funcs userq_mes_funcs = {
 	.preempt = mes_userq_preempt,
 	.restore = mes_userq_restore,
 	.reset = mes_userq_reset,
+	.set_gang = mes_set_gang,
 };
-- 
2.56.1


^ permalink raw reply related	[flat|nested] 13+ messages in thread

* [PATCH 7/9] drm/amdgpu/userq: add handling for set_gang
  2026-11-17 19:24 [PATCH 1/9] drm/amdgpu/mes11: add API for gang submit Alex Deucher
                   ` (4 preceding siblings ...)
  2026-11-17 19:24 ` [PATCH 6/9] drm/amdgpu/userq/mes: implement set gang submit Alex Deucher
@ 2026-11-17 19:24 ` Alex Deucher
  2026-11-17 19:46   ` sashiko-bot
  2026-11-17 19:24 ` [PATCH 8/9] drm/amdgpu: add UAPI to create user queue gangs Alex Deucher
  2026-11-17 19:24 ` [PATCH 9/9] drm/amdgpu/userq: enable support for creating gangs Alex Deucher
  7 siblings, 1 reply; 13+ messages in thread
From: Alex Deucher @ 2026-11-17 19:24 UTC (permalink / raw)
  To: amd-gfx; +Cc: Alex Deucher, Yogesh Mohan Marimuthu

Make sure the ganged queues are handled properly in
map, unmap, restore, and preempt.  Need to call
set_gang to make sure the queues are schedule together.

Cc: Yogesh Mohan Marimuthu <yogesh.mohanmarimuthu@amd.com>
Signed-off-by: Alex Deucher <alexander.deucher@amd.com>
---
 drivers/gpu/drm/amd/amdgpu/amdgpu_userq.c | 83 ++++++++++++++++++++++-
 drivers/gpu/drm/amd/amdgpu/amdgpu_userq.h |  3 +
 2 files changed, 84 insertions(+), 2 deletions(-)

diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_userq.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_userq.c
index ed6f3b67e8720..e41f0e10c8a36 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_userq.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_userq.c
@@ -305,12 +305,16 @@ static bool amdgpu_userq_buffer_vas_mapped(struct amdgpu_usermode_queue *queue)
 
 static int amdgpu_userq_preempt_helper(struct amdgpu_usermode_queue *queue)
 {
+	struct amdgpu_usermode_queue *secondary_queue = NULL;
 	struct amdgpu_userq_mgr *uq_mgr = queue->userq_mgr;
 	struct amdgpu_device *adev = uq_mgr->adev;
 	const struct amdgpu_userq_funcs *userq_funcs =
 		adev->userq_funcs[queue->queue_type];
 	int r;
 
+	if (queue->gang_primary)
+		secondary_queue = queue->gang_secondary;
+
 	if (queue->state == AMDGPU_USERQ_STATE_MAPPED) {
 		trace_amdgpu_userq_state_start(queue);
 
@@ -324,17 +328,36 @@ static int amdgpu_userq_preempt_helper(struct amdgpu_usermode_queue *queue)
 			queue->state = AMDGPU_USERQ_STATE_PREEMPTED;
 		}
 	}
+
+	if (secondary_queue && secondary_queue->state == AMDGPU_USERQ_STATE_MAPPED) {
+		trace_amdgpu_userq_state_start(secondary_queue);
+
+		r = userq_funcs->preempt(secondary_queue);
+		if (r) {
+			trace_amdgpu_userq_state_changed(secondary_queue, AMDGPU_USERQ_STATE_HUNG);
+			secondary_queue->state = AMDGPU_USERQ_STATE_HUNG;
+			return r;
+		} else {
+			trace_amdgpu_userq_state_changed(secondary_queue, AMDGPU_USERQ_STATE_PREEMPTED);
+			secondary_queue->state = AMDGPU_USERQ_STATE_PREEMPTED;
+		}
+	}
+
 	return 0;
 }
 
 static int amdgpu_userq_restore_helper(struct amdgpu_usermode_queue *queue)
 {
+	struct amdgpu_usermode_queue *secondary_queue = NULL;
 	struct amdgpu_userq_mgr *uq_mgr = queue->userq_mgr;
 	struct amdgpu_device *adev = uq_mgr->adev;
 	const struct amdgpu_userq_funcs *userq_funcs =
 		adev->userq_funcs[queue->queue_type];
 	int r = 0;
 
+	if (queue->gang_primary)
+		secondary_queue = queue->gang_secondary;
+
 	if (queue->state == AMDGPU_USERQ_STATE_PREEMPTED) {
 		trace_amdgpu_userq_state_start(queue);
 
@@ -348,11 +371,27 @@ static int amdgpu_userq_restore_helper(struct amdgpu_usermode_queue *queue)
 		}
 	}
 
+	if (secondary_queue &&
+	    secondary_queue->state == AMDGPU_USERQ_STATE_PREEMPTED) {
+		trace_amdgpu_userq_state_start(secondary_queue);
+
+		r = userq_funcs->restore(secondary_queue);
+		if (r) {
+			trace_amdgpu_userq_state_changed(secondary_queue, AMDGPU_USERQ_STATE_HUNG);
+			secondary_queue->state = AMDGPU_USERQ_STATE_HUNG;
+		} else {
+			trace_amdgpu_userq_state_changed(secondary_queue, AMDGPU_USERQ_STATE_MAPPED);
+			secondary_queue->state = AMDGPU_USERQ_STATE_MAPPED;
+			r = userq_funcs->set_gang(queue, secondary_queue);
+		}
+	}
+
 	return r;
 }
 
 static int amdgpu_userq_unmap_helper(struct amdgpu_usermode_queue *queue)
 {
+	struct amdgpu_usermode_queue *secondary_queue = NULL;
 	struct amdgpu_userq_mgr *uq_mgr = queue->userq_mgr;
 	struct amdgpu_device *adev = uq_mgr->adev;
 	const struct amdgpu_userq_funcs *userq_funcs =
@@ -361,6 +400,10 @@ static int amdgpu_userq_unmap_helper(struct amdgpu_usermode_queue *queue)
 
 	/* The reset changes the queue state and the MES is unusable meanwhile */
 	guard(rwsem_read)(&adev->reset_domain->sem);
+
+	if (queue->gang_primary)
+		secondary_queue = queue->gang_secondary;
+
 	if ((queue->state == AMDGPU_USERQ_STATE_MAPPED) ||
 	    (queue->state == AMDGPU_USERQ_STATE_PREEMPTED)) {
 		trace_amdgpu_userq_state_start(queue);
@@ -376,16 +419,36 @@ static int amdgpu_userq_unmap_helper(struct amdgpu_usermode_queue *queue)
 		}
 	}
 
+	if (secondary_queue &&
+	    ((secondary_queue->state == AMDGPU_USERQ_STATE_MAPPED) ||
+	     (secondary_queue->state == AMDGPU_USERQ_STATE_PREEMPTED))) {
+		trace_amdgpu_userq_state_start(secondary_queue);
+
+		r = userq_funcs->unmap(secondary_queue);
+		if (r) {
+			trace_amdgpu_userq_state_changed(secondary_queue, AMDGPU_USERQ_STATE_HUNG);
+			secondary_queue->state = AMDGPU_USERQ_STATE_HUNG;
+			return r;
+		} else {
+			trace_amdgpu_userq_state_changed(secondary_queue, AMDGPU_USERQ_STATE_UNMAPPED);
+			secondary_queue->state = AMDGPU_USERQ_STATE_UNMAPPED;
+		}
+	}
+
 	return 0;
 }
 
 static int amdgpu_userq_map_helper(struct amdgpu_usermode_queue *queue)
 {
+	struct amdgpu_usermode_queue *secondary_queue = NULL;
 	struct amdgpu_userq_mgr *uq_mgr = queue->userq_mgr;
 	struct amdgpu_device *adev = uq_mgr->adev;
 	const struct amdgpu_userq_funcs *userq_funcs =
 		adev->userq_funcs[queue->queue_type];
-	int r;
+	int r = 0;
+
+	if (queue->gang_primary)
+		secondary_queue = queue->gang_secondary;
 
 	/* The reset changes the queue state and the MES is unusable meanwhile */
 	guard(rwsem_read)(&adev->reset_domain->sem);
@@ -403,7 +466,23 @@ static int amdgpu_userq_map_helper(struct amdgpu_usermode_queue *queue)
 		}
 	}
 
-	return 0;
+	if (secondary_queue &&
+	    secondary_queue->state == AMDGPU_USERQ_STATE_UNMAPPED) {
+		trace_amdgpu_userq_state_start(secondary_queue);
+
+		r = userq_funcs->map(secondary_queue);
+		if (r) {
+			trace_amdgpu_userq_state_changed(secondary_queue, AMDGPU_USERQ_STATE_HUNG);
+			secondary_queue->state = AMDGPU_USERQ_STATE_HUNG;
+			return r;
+		} else {
+			trace_amdgpu_userq_state_changed(secondary_queue, AMDGPU_USERQ_STATE_MAPPED);
+			secondary_queue->state = AMDGPU_USERQ_STATE_MAPPED;
+			r = userq_funcs->set_gang(queue, secondary_queue);
+		}
+	}
+
+	return r;
 }
 
 static void amdgpu_userq_wait_for_last_fence(struct amdgpu_usermode_queue *queue)
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_userq.h b/drivers/gpu/drm/amd/amdgpu/amdgpu_userq.h
index efaa658a26a9a..3dd63d6b9c445 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_userq.h
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_userq.h
@@ -102,6 +102,9 @@ struct amdgpu_usermode_queue {
 	} userq_vas;
 
 	uint32_t	gang_ctx_array_index;
+	bool			in_gang;
+	bool			gang_primary;
+	struct amdgpu_usermode_queue *gang_secondary;
 };
 
 struct amdgpu_userq_funcs {
-- 
2.56.1


^ permalink raw reply related	[flat|nested] 13+ messages in thread

* [PATCH 8/9] drm/amdgpu: add UAPI to create user queue gangs
  2026-11-17 19:24 [PATCH 1/9] drm/amdgpu/mes11: add API for gang submit Alex Deucher
                   ` (5 preceding siblings ...)
  2026-11-17 19:24 ` [PATCH 7/9] drm/amdgpu/userq: add handling for set_gang Alex Deucher
@ 2026-11-17 19:24 ` Alex Deucher
  2026-11-17 19:24 ` [PATCH 9/9] drm/amdgpu/userq: enable support for creating gangs Alex Deucher
  7 siblings, 0 replies; 13+ messages in thread
From: Alex Deucher @ 2026-11-17 19:24 UTC (permalink / raw)
  To: amd-gfx; +Cc: Alex Deucher, Yogesh Mohan Marimuthu

Queues in a gang will schedule together.

Cc: Yogesh Mohan Marimuthu <yogesh.mohanmarimuthu@amd.com>
Signed-off-by: Alex Deucher <alexander.deucher@amd.com>
---
 include/uapi/drm/amdgpu_drm.h | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/include/uapi/drm/amdgpu_drm.h b/include/uapi/drm/amdgpu_drm.h
index 86d42a5d683c0..bfb982f1d1757 100644
--- a/include/uapi/drm/amdgpu_drm.h
+++ b/include/uapi/drm/amdgpu_drm.h
@@ -340,6 +340,7 @@ union drm_amdgpu_ctx {
 /* user queue IOCTL operations */
 #define AMDGPU_USERQ_OP_CREATE	1
 #define AMDGPU_USERQ_OP_FREE	2
+#define AMDGPU_USERQ_OP_CREATE_GANG	3
 
 /* queue priority levels */
 /* low < normal low < normal high < high */
@@ -422,6 +423,15 @@ struct drm_amdgpu_userq_in {
 	__u64 mqd_size;
 };
 
+struct drm_amdgpu_userq_in_create_gang {
+	/** AMDGPU_USERQ_OP_* */
+	__u32	op;
+	__u32	pad;
+	/** Queue ids passed for operation USERQ_OP_CREATE_GANG */
+	__u32	primary_queue_id;
+	__u32	secondary_queue_id;
+};
+
 /* The structure to carry output of userqueue ops */
 struct drm_amdgpu_userq_out {
 	/**
@@ -435,6 +445,7 @@ struct drm_amdgpu_userq_out {
 
 union drm_amdgpu_userq {
 	struct drm_amdgpu_userq_in in;
+	struct drm_amdgpu_userq_in_create_gang in_cg;
 	struct drm_amdgpu_userq_out out;
 };
 
-- 
2.56.1


^ permalink raw reply related	[flat|nested] 13+ messages in thread

* [PATCH 9/9] drm/amdgpu/userq: enable support for creating gangs
  2026-11-17 19:24 [PATCH 1/9] drm/amdgpu/mes11: add API for gang submit Alex Deucher
                   ` (6 preceding siblings ...)
  2026-11-17 19:24 ` [PATCH 8/9] drm/amdgpu: add UAPI to create user queue gangs Alex Deucher
@ 2026-11-17 19:24 ` Alex Deucher
  2026-11-17 19:44   ` sashiko-bot
  7 siblings, 1 reply; 13+ messages in thread
From: Alex Deucher @ 2026-11-17 19:24 UTC (permalink / raw)
  To: amd-gfx; +Cc: Alex Deucher, Yogesh Mohan Marimuthu

Gangs are sets of userqs that schedule together.  You
specify the primary and secondary queues and the scheduler
will make sure they always run at the same time.

v2: handle setting up the gang again after unmaps
v3: split the UAPI part from the internal tracking

Cc: Yogesh Mohan Marimuthu <yogesh.mohanmarimuthu@amd.com>
Signed-off-by: Alex Deucher <alexander.deucher@amd.com>
---
 drivers/gpu/drm/amd/amdgpu/amdgpu_userq.c | 69 ++++++++++++++++++++++-
 1 file changed, 68 insertions(+), 1 deletion(-)

diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_userq.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_userq.c
index e41f0e10c8a36..61416518fd702 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_userq.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_userq.c
@@ -896,6 +896,67 @@ amdgpu_userq_create(struct drm_file *filp, union drm_amdgpu_userq *args)
 	return r;
 }
 
+static int
+amdgpu_userq_create_gang(struct drm_file *filp, union drm_amdgpu_userq *args)
+{
+	struct amdgpu_usermode_queue *primary_queue, *secondary_queue;
+	struct amdgpu_fpriv *fpriv = filp->driver_priv;
+	struct amdgpu_userq_mgr *uq_mgr = &fpriv->userq_mgr;
+	const struct amdgpu_userq_funcs *userq_funcs;
+	struct amdgpu_device *adev = uq_mgr->adev;
+	int primary_queue_id = args->in_cg.primary_queue_id;
+	int secondary_queue_id = args->in_cg.secondary_queue_id;
+	int r;
+
+	mutex_lock(&uq_mgr->userq_mutex);
+	primary_queue = amdgpu_userq_get(uq_mgr, primary_queue_id);
+	if (!primary_queue) {
+		dev_err(adev->dev, "Invalid gang primary queue id\n");
+		mutex_unlock(&uq_mgr->userq_mutex);
+		return -EINVAL;
+	}
+	if ((primary_queue->queue_type != AMDGPU_HW_IP_GFX) &&
+	    (primary_queue->queue_type != AMDGPU_HW_IP_COMPUTE) &&
+	    (primary_queue->queue_type != AMDGPU_HW_IP_DMA)) {
+		dev_err(adev->dev, "Invalid gang primary queue type\n");
+		mutex_unlock(&uq_mgr->userq_mutex);
+		return -EINVAL;
+	}
+	if (primary_queue->in_gang) {
+		dev_err(adev->dev, "Primary queue already in a gang\n");
+		mutex_unlock(&uq_mgr->userq_mutex);
+		return -EINVAL;
+	}
+	secondary_queue = amdgpu_userq_get(uq_mgr, secondary_queue_id);
+	if (!secondary_queue) {
+		dev_err(adev->dev, "Invalid gang secondary queue id\n");
+		mutex_unlock(&uq_mgr->userq_mutex);
+		return -EINVAL;
+	}
+	if ((secondary_queue->queue_type != AMDGPU_HW_IP_GFX) &&
+	    (secondary_queue->queue_type != AMDGPU_HW_IP_COMPUTE) &&
+	    (secondary_queue->queue_type != AMDGPU_HW_IP_DMA)) {
+		dev_err(adev->dev, "Invalid gang secondary queue type\n");
+		mutex_unlock(&uq_mgr->userq_mutex);
+		return -EINVAL;
+	}
+	if (secondary_queue->in_gang) {
+		dev_err(adev->dev, "Secondary queue already in a gang\n");
+		mutex_unlock(&uq_mgr->userq_mutex);
+		return -EINVAL;
+	}
+
+	primary_queue->gang_primary = true;
+	primary_queue->in_gang = true;
+	primary_queue->gang_secondary = secondary_queue;
+	secondary_queue->in_gang = true;
+	userq_funcs = adev->userq_funcs[primary_queue->queue_type];
+	r = userq_funcs->set_gang(primary_queue, secondary_queue);
+	mutex_unlock(&uq_mgr->userq_mutex);
+
+	return r;
+}
+
 static int amdgpu_userq_input_args_validate(struct drm_device *dev,
 					union drm_amdgpu_userq *args,
 					struct drm_file *filp)
@@ -1016,7 +1077,13 @@ int amdgpu_userq_ioctl(struct drm_device *dev, void *data,
 		amdgpu_userq_put(queue);
 		break;
 	}
-
+	case AMDGPU_USERQ_OP_CREATE_GANG:
+		if (args->in_cg.pad)
+			return -EINVAL;
+		r = amdgpu_userq_create_gang(filp, args);
+		if (r)
+			drm_file_err(filp, "Failed to create usermode queue gang\n");
+		break;
 	default:
 		drm_dbg_driver(dev, "Invalid user queue op specified: %d\n", args->in.op);
 		return -EINVAL;
-- 
2.56.1


^ permalink raw reply related	[flat|nested] 13+ messages in thread

* Re: [PATCH 6/9] drm/amdgpu/userq/mes: implement set gang submit
  2026-11-17 19:24 ` [PATCH 6/9] drm/amdgpu/userq/mes: implement set gang submit Alex Deucher
@ 2026-11-17 19:35   ` sashiko-bot
  0 siblings, 0 replies; 13+ messages in thread
From: sashiko-bot @ 2026-11-17 19:35 UTC (permalink / raw)
  To: Alex Deucher, amd-gfx

Thank you for your contribution! Sashiko AI review found 1 potential
issue to consider:
- [High] drm/amdgpu: out-of-bounds gang context address in
  mes_set_gang()
--

commit faefcb7998343e4f4e1ec3ab6ccf3f3feccc05e7
Author: Alex Deucher <alexander.deucher@amd.com>

drm/amdgpu/userq/mes: implement set gang submit

This commit adds the mes_set_gang() callback to userq_mes_funcs to
configure MES gang submission between a primary and secondary usermode
queue.

> diff --git a/drivers/gpu/drm/amd/amdgpu/mes_userqueue.c b/drivers/gpu/drm/amd/amdgpu/mes_userqueue.c
> index 7abb9d95ef59a..e186ebd08b8d2 100644
> --- a/drivers/gpu/drm/amd/amdgpu/mes_userqueue.c
> +++ b/drivers/gpu/drm/amd/amdgpu/mes_userqueue.c
> @@ -649,6 +649,31 @@ static int mes_userq_restore(struct amdgpu_usermode_queue *queue)
>  	return r;
>  }
>  
> +static int mes_set_gang(struct amdgpu_usermode_queue *primary_queue,
> +			struct amdgpu_usermode_queue *secondary_queue)
> +{
> +	struct amdgpu_userq_obj *primary_ctx = &primary_queue->fw_obj;
> +	struct amdgpu_userq_obj *secondary_ctx = &secondary_queue->fw_obj;
> +	struct amdgpu_userq_mgr *uq_mgr = primary_queue->userq_mgr;
> +	struct amdgpu_device *adev = uq_mgr->adev;
> +	struct mes_set_gang_submit_input input;
> +	int r;
> +
> +	memset(&input, 0x0, sizeof(struct mes_set_gang_submit_input));
> +
> +	input.primary_gang_context_addr =
> +		primary_ctx->gpu_addr + AMDGPU_USERQ_PROC_CTX_SZ;
> +	input.secondary_gang_context_addr =
> +		secondary_ctx->gpu_addr + AMDGPU_USERQ_PROC_CTX_SZ;

[Severity: High]
Should primary_gang_context_addr and secondary_gang_context_addr be set
to primary_ctx->gpu_addr and secondary_ctx->gpu_addr without adding
AMDGPU_USERQ_PROC_CTX_SZ?

Since 97bcaf15ad25 ("drm/amdgpu: implement per-process MES context"),
the process context is allocated separately in uq_mgr->proc_ctx_obj, and
mes_userq_create_ctx_space() allocates queue->fw_obj with size
AMDGPU_USERQ_GANG_CTX_SZ (one page) for the gang context alone:

drivers/gpu/drm/amd/amdgpu/mes_userqueue.c:mes_userq_create_ctx_space() {
	...
	/* The FW expects at least one page space allocated for gang ctx. */
	size = AMDGPU_USERQ_GANG_CTX_SZ;
	r = amdgpu_bo_create_kernel(uq_mgr->adev, size, 0,
				    AMDGPU_GEM_DOMAIN_GTT,
				    &ctx->obj, &ctx->gpu_addr,
				    &ctx->cpu_ptr);
	...
}

Adding AMDGPU_USERQ_PROC_CTX_SZ points one page past the end of each
queue's fw_obj BO and does not match the gang_context_addr (ctx->gpu_addr)
passed to MES in mes_userq_map().

-- 
Sashiko AI review · https://sashiko.dev/#/patchset/20261117192415.810117-1-alexander.deucher@amd.com?part=6

^ permalink raw reply	[flat|nested] 13+ messages in thread

* Re: [PATCH 3/9] drm/amdgpu/mes11: add support for setting gang submit
  2026-11-17 19:24 ` [PATCH 3/9] drm/amdgpu/mes11: add support for setting " Alex Deucher
@ 2026-11-17 19:37   ` sashiko-bot
  0 siblings, 0 replies; 13+ messages in thread
From: sashiko-bot @ 2026-11-17 19:37 UTC (permalink / raw)
  To: Alex Deucher, amd-gfx

Thank you for your contribution! Sashiko AI review found no new issues
in this patch, but noticed 1 related pre-existing issue it does not
introduce:
- [High] drm/amdgpu: unrolled sync_seq increment on MES error_undo paths
  [1]
--

commit 285ec5bbb9066cd84ed61683a42ebeae06434475
Author: Alex Deucher <alexander.deucher@amd.com>

drm/amdgpu/mes11: add support for setting gang submit

This commit implements the set_gang_submit callback for MES v11 to allow a
primary and secondary queue to schedule together.

> diff --git a/drivers/gpu/drm/amd/amdgpu/mes_v11_0.c b/drivers/gpu/drm/amd/amdgpu/mes_v11_0.c
> index 75e6079e6e332..d67dbc93e10d4 100644
> --- a/drivers/gpu/drm/amd/amdgpu/mes_v11_0.c
> +++ b/drivers/gpu/drm/amd/amdgpu/mes_v11_0.c
> @@ -1275,6 +1275,27 @@ static int mes_v11_0_enable_dbgext_irq(struct amdgpu_mes *mes, bool enable)
>  	return 0;
>  }
>  
> +static int mes_v11_0_set_gang_submit(struct amdgpu_mes *mes,
> +				     struct mes_set_gang_submit_input *input)
> +{
> +	union MESAPI__SET_GANG_SUBMIT mes_gang_submit_pkt;
> +
> +	memset(&mes_gang_submit_pkt, 0, sizeof(mes_gang_submit_pkt));
> +
> +	mes_gang_submit_pkt.header.type = MES_API_TYPE_SCHEDULER;
> +	mes_gang_submit_pkt.header.opcode = MES_SCH_API_SET_GANG_SUBMIT;
> +	mes_gang_submit_pkt.header.dwsize = API_FRAME_SIZE_IN_DWORDS;
> +
> +	mes_gang_submit_pkt.set_gang_submit.gang_context_addr =
> +		input->primary_gang_context_addr;
> +	mes_gang_submit_pkt.set_gang_submit.slave_gang_context_addr =
> +		input->secondary_gang_context_addr;
> +
> +	return mes_v11_0_submit_pkt_and_poll_completion(mes,
> +			&mes_gang_submit_pkt, sizeof(mes_gang_submit_pkt),
> +			offsetof(union MESAPI__SET_GANG_SUBMIT, api_status));
> +}

[Severity: High]
This problem wasn't introduced by this patch, but can
mes_v11_0_submit_pkt_and_poll_completion() leave ring->fence_drv.sync_seq
incremented when amdgpu_fence_wait_polling() times out [1]?

drivers/gpu/drm/amd/amdgpu/mes_v11_0.c:mes_v11_0_submit_pkt_and_poll_completion() {
	...
	seq = ++ring->fence_drv.sync_seq;
	r = amdgpu_fence_wait_polling(ring,
				      seq - ring->fence_drv.num_fences_mask,
				      timeout);
	if (r < 1) {
		r = -ETIMEDOUT;
		goto error_undo;
	}
	...
error_undo:
	dev_err(adev->dev, "MES ring buffer is full.\n");
	amdgpu_ring_undo(ring);
	...
}

The error_undo path rolls back the ring write pointer without decrementing
ring->fence_drv.sync_seq and without emitting the status fence packet.
Once ring->fence_drv.num_fences_mask timeouts accumulate, seq -
ring->fence_drv.num_fences_mask exceeds the highest fence sequence number
ever emitted to the ring, causing all subsequent MES submissions to time
out waiting on an unemitted fence until a GPU reset.  The same issue also
exists in mes_v12_0_submit_pkt_and_poll_completion() and
mes_v12_1_submit_pkt_and_poll_completion().

[1] https://sashiko.dev/#/bug/linux-dce92d12-1446-4f12-a395-575847569192

-- 
Sashiko AI review · https://sashiko.dev/#/patchset/20261117192415.810117-1-alexander.deucher@amd.com?part=3

^ permalink raw reply	[flat|nested] 13+ messages in thread

* Re: [PATCH 9/9] drm/amdgpu/userq: enable support for creating gangs
  2026-11-17 19:24 ` [PATCH 9/9] drm/amdgpu/userq: enable support for creating gangs Alex Deucher
@ 2026-11-17 19:44   ` sashiko-bot
  0 siblings, 0 replies; 13+ messages in thread
From: sashiko-bot @ 2026-11-17 19:44 UTC (permalink / raw)
  To: Alex Deucher, amd-gfx

Thank you for your contribution! Sashiko AI review found 8 potential
issues to consider:
- [High] drm/amdgpu/userq: missing CREATE_GANG case in
  amdgpu_userq_input_args_validate()
- [High] drm/amdgpu/userq: kref leak on queues in
  amdgpu_userq_create_gang()
- [High] drm/amdgpu/userq: missing gang_secondary teardown in
  amdgpu_userq_destroy()
- [High] drm/amdgpu/userq: out-of-bounds gang_context_addr offset in
  mes_set_gang()
- [Medium] drm/amdgpu/userq: self-ganging allowed in
  amdgpu_userq_create_gang()
- [Medium] drm/amdgpu/userq: unrolled gang state on set_gang() failure
- [Medium] drm/amdgpu/userq: set_gang() called without checking queue
  state or reset_domain
- [Medium] drm/amdgpu/userq: set_gang() skipped when secondary queue is
  mapped/restored first
--

commit 41bbabcb54c434e03323740262dcec73dc8bedd4
Author: Alex Deucher <alexander.deucher@amd.com>

drm/amdgpu/userq: enable support for creating gangs

This commit adds the AMDGPU_USERQ_OP_CREATE_GANG ioctl operation and
amdgpu_userq_create_gang() to link a primary and secondary usermode queue
into a gang.

> diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_userq.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_userq.c
> index e41f0e10c8a36..61416518fd702 100644
> --- a/drivers/gpu/drm/amd/amdgpu/amdgpu_userq.c
> +++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_userq.c
> @@ -896,6 +896,67 @@ amdgpu_userq_create(struct drm_file *filp, union drm_amdgpu_userq *args)
>  	return r;
>  }
>  
> +static int
> +amdgpu_userq_create_gang(struct drm_file *filp, union drm_amdgpu_userq *args)
> +{
> +	struct amdgpu_usermode_queue *primary_queue, *secondary_queue;
> +	struct amdgpu_fpriv *fpriv = filp->driver_priv;
> +	struct amdgpu_userq_mgr *uq_mgr = &fpriv->userq_mgr;
> +	const struct amdgpu_userq_funcs *userq_funcs;
> +	struct amdgpu_device *adev = uq_mgr->adev;
> +	int primary_queue_id = args->in_cg.primary_queue_id;
> +	int secondary_queue_id = args->in_cg.secondary_queue_id;
> +	int r;
> +
> +	mutex_lock(&uq_mgr->userq_mutex);
> +	primary_queue = amdgpu_userq_get(uq_mgr, primary_queue_id);
> +	if (!primary_queue) {
> +		dev_err(adev->dev, "Invalid gang primary queue id\n");
> +		mutex_unlock(&uq_mgr->userq_mutex);
> +		return -EINVAL;
> +	}
> +	if ((primary_queue->queue_type != AMDGPU_HW_IP_GFX) &&
> +	    (primary_queue->queue_type != AMDGPU_HW_IP_COMPUTE) &&
> +	    (primary_queue->queue_type != AMDGPU_HW_IP_DMA)) {
> +		dev_err(adev->dev, "Invalid gang primary queue type\n");
> +		mutex_unlock(&uq_mgr->userq_mutex);
> +		return -EINVAL;
> +	}
> +	if (primary_queue->in_gang) {
> +		dev_err(adev->dev, "Primary queue already in a gang\n");
> +		mutex_unlock(&uq_mgr->userq_mutex);
> +		return -EINVAL;
> +	}
> +	secondary_queue = amdgpu_userq_get(uq_mgr, secondary_queue_id);
> +	if (!secondary_queue) {
> +		dev_err(adev->dev, "Invalid gang secondary queue id\n");
> +		mutex_unlock(&uq_mgr->userq_mutex);
> +		return -EINVAL;
> +	}
> +	if ((secondary_queue->queue_type != AMDGPU_HW_IP_GFX) &&
> +	    (secondary_queue->queue_type != AMDGPU_HW_IP_COMPUTE) &&
> +	    (secondary_queue->queue_type != AMDGPU_HW_IP_DMA)) {
> +		dev_err(adev->dev, "Invalid gang secondary queue type\n");
> +		mutex_unlock(&uq_mgr->userq_mutex);
> +		return -EINVAL;
> +	}
> +	if (secondary_queue->in_gang) {
> +		dev_err(adev->dev, "Secondary queue already in a gang\n");
> +		mutex_unlock(&uq_mgr->userq_mutex);
> +		return -EINVAL;
> +	}

[Severity: Medium]
Can userspace pass primary_queue_id == secondary_queue_id to gang a queue
with itself?  primary_queue->in_gang is still false when
secondary_queue->in_gang is checked, so both lookups return the same queue
and pass validation, setting primary_queue->gang_secondary to itself and
passing identical primary and secondary gang context addresses to MES.

> +
> +	primary_queue->gang_primary = true;
> +	primary_queue->in_gang = true;
> +	primary_queue->gang_secondary = secondary_queue;

[Severity: High]
What happens to primary_queue->gang_secondary when a ganged queue is freed
in amdgpu_userq_destroy()?

amdgpu_userq_preempt_helper(), amdgpu_userq_restore_helper(),
amdgpu_userq_unmap_helper(), and amdgpu_userq_map_helper() all dereference
queue->gang_secondary whenever queue->gang_primary is set, but
amdgpu_userq_destroy() neither clears primary_queue->gang_secondary when
secondary_queue is destroyed nor releases a reference on
queue->gang_secondary when primary_queue is destroyed.  If gang_secondary
does not hold a kref on secondary_queue, freeing secondary_queue via
AMDGPU_USERQ_OP_FREE leaves primary_queue->gang_secondary as a dangling
pointer that is dereferenced on the next unmap, preempt, restore, or
destroy of primary_queue; if it does hold a kref, destroying primary_queue
leaks secondary_queue and leaves it in adev->userq_doorbell_xa after file
close.

> +	secondary_queue->in_gang = true;
> +	userq_funcs = adev->userq_funcs[primary_queue->queue_type];
> +	r = userq_funcs->set_gang(primary_queue, secondary_queue);

[Severity: High]
Does userq_funcs->set_gang() pass out-of-bounds gang context addresses to
MES?

drivers/gpu/drm/amd/amdgpu/mes_userqueue.c:mes_set_gang() {
	...
	input.primary_gang_context_addr =
		primary_ctx->gpu_addr + AMDGPU_USERQ_PROC_CTX_SZ;
	input.secondary_gang_context_addr =
		secondary_ctx->gpu_addr + AMDGPU_USERQ_PROC_CTX_SZ;
	...
}

Since 97bcaf15ad25 ("drm/amdgpu: implement per-process MES context"),
mes_userq_create_ctx_space() allocates each queue's fw_obj with size
AMDGPU_USERQ_GANG_CTX_SZ (one page), and mes_userq_map() sets
gang_context_addr to ctx->gpu_addr.  Adding AMDGPU_USERQ_PROC_CTX_SZ points
one page past the end of each 1-page fw_obj BO and does not match the
gang_context_addr registered with MES.

[Severity: Medium]
Should amdgpu_userq_create_gang() hold adev->reset_domain->sem and verify
that both queues are in AMDGPU_USERQ_STATE_MAPPED before calling
userq_funcs->set_gang()?  Unlike amdgpu_userq_map_helper() and
amdgpu_userq_unmap_helper(), this calls into MES without locking
reset_domain->sem and even when either queue is unmapped (for example,
while adev->userq_halt_for_enforce_isolation is set or while queues are
evicted), preempted, or hung.

[Severity: Medium]
Can gang scheduling also be lost when queues are remapped or restored after
eviction, suspend/resume, or reset?

drivers/gpu/drm/amd/amdgpu/amdgpu_userq.c:amdgpu_userq_map_helper() {
	...
	if (secondary_queue &&
	    secondary_queue->state == AMDGPU_USERQ_STATE_UNMAPPED) {
		...
			secondary_queue->state = AMDGPU_USERQ_STATE_MAPPED;
			r = userq_funcs->set_gang(queue, secondary_queue);
		}
	}
}

amdgpu_userq_restore_all(), amdgpu_userq_resume(), and
amdgpu_userq_start_sched_for_enforce_isolation() iterate queues in
ascending xarray index order via xa_for_each().  Whenever secondary_queue
has a lower queue_id or doorbell_index than primary_queue, it is mapped or
restored first, so secondary_queue->state is already
AMDGPU_USERQ_STATE_MAPPED when primary_queue is processed and
userq_funcs->set_gang() is skipped in both amdgpu_userq_map_helper() and
amdgpu_userq_restore_helper().  In addition, amdgpu_userq_post_reset()
remaps hung queues via userq_funcs->map() directly without calling
set_gang().

[Severity: Medium]
If userq_funcs->set_gang() fails here, should gang_primary, in_gang, and
gang_secondary be rolled back on primary_queue and secondary_queue?
Leaving them set marks both queues as ganged even though the MES gang setup
failed, causing subsequent map, unmap, preempt, and restore helpers to
treat the failed gang as active and preventing userspace from retrying.

> +	mutex_unlock(&uq_mgr->userq_mutex);
> +
> +	return r;
> +}

[Severity: High]
Does amdgpu_userq_create_gang() leak the kref references acquired by
amdgpu_userq_get() on primary_queue and secondary_queue?

Neither the validation error returns nor the exit path calls
amdgpu_userq_put() on primary_queue or secondary_queue, so their refcounts
never drop to zero in AMDGPU_USERQ_OP_FREE or amdgpu_userq_mgr_fini().
That leaks both queues and their BOs, and leaves them registered in
adev->userq_doorbell_xa with dangling pointers to fpriv after file close.
Note that amdgpu_userq_put() will need to be called after dropping
uq_mgr->userq_mutex because amdgpu_userq_destroy() acquires
uq_mgr->userq_mutex.

> @@ -1016,7 +1077,13 @@ int amdgpu_userq_ioctl(struct drm_device *dev, void *data,
>  		amdgpu_userq_put(queue);
>  		break;
>  	}
> -
> +	case AMDGPU_USERQ_OP_CREATE_GANG:
> +		if (args->in_cg.pad)
> +			return -EINVAL;
> +		r = amdgpu_userq_create_gang(filp, args);
> +		if (r)
> +			drm_file_err(filp, "Failed to create usermode queue gang\n");
> +		break;
>  	default:
>  		drm_dbg_driver(dev, "Invalid user queue op specified: %d\n", args->in.op);
>  		return -EINVAL;

[Severity: High]
Is this AMDGPU_USERQ_OP_CREATE_GANG case reachable?  amdgpu_userq_ioctl()
calls amdgpu_userq_input_args_validate() before switching on args->in.op,
and amdgpu_userq_input_args_validate() only handles AMDGPU_USERQ_OP_CREATE
and AMDGPU_USERQ_OP_FREE, returning -EINVAL in its default branch for every
AMDGPU_USERQ_OP_CREATE_GANG call.

-- 
Sashiko AI review · https://sashiko.dev/#/patchset/20261117192415.810117-1-alexander.deucher@amd.com?part=9

^ permalink raw reply	[flat|nested] 13+ messages in thread

* Re: [PATCH 7/9] drm/amdgpu/userq: add handling for set_gang
  2026-11-17 19:24 ` [PATCH 7/9] drm/amdgpu/userq: add handling for set_gang Alex Deucher
@ 2026-11-17 19:46   ` sashiko-bot
  0 siblings, 0 replies; 13+ messages in thread
From: sashiko-bot @ 2026-11-17 19:46 UTC (permalink / raw)
  To: Alex Deucher, amd-gfx

Thank you for your contribution! Sashiko AI review found 4 potential
issues to consider:
- [High] drm/amdgpu/userq: standalone secondary queue ops skip
  set_gang() and VA checks
- [High] drm/amdgpu/userq: out-of-bounds gang context GPU address in
  mes_set_gang()
- [Medium] drm/amdgpu/userq: missing error return in
  amdgpu_userq_restore_helper()
- [Medium] drm/amdgpu/userq: missing set_gang() call in
  amdgpu_userq_post_reset()
--

commit ed0b4bb2f9bf97208327d7b1d43ea3cfbbf1f688
Author: Alex Deucher <alexander.deucher@amd.com>

drm/amdgpu/userq: add handling for set_gang

This commit updates the usermode queue preempt, restore, unmap, and map
helpers to operate on a ganged secondary queue and invoke the set_gang
callback when mapping or restoring a gang.

> diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_userq.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_userq.c
> index ed6f3b67e8720..e41f0e10c8a36 100644
> --- a/drivers/gpu/drm/amd/amdgpu/amdgpu_userq.c
> +++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_userq.c
[ ... ]
> @@ -348,11 +371,27 @@ static int amdgpu_userq_restore_helper(struct amdgpu_usermode_queue *queue)
>  		}
>  	}
>  
> +	if (secondary_queue &&
> +	    secondary_queue->state == AMDGPU_USERQ_STATE_PREEMPTED) {
> +		trace_amdgpu_userq_state_start(secondary_queue);
> +
> +		r = userq_funcs->restore(secondary_queue);
> +		if (r) {
> +			trace_amdgpu_userq_state_changed(secondary_queue, AMDGPU_USERQ_STATE_HUNG);
> +			secondary_queue->state = AMDGPU_USERQ_STATE_HUNG;
> +		} else {
> +			trace_amdgpu_userq_state_changed(secondary_queue, AMDGPU_USERQ_STATE_MAPPED);
> +			secondary_queue->state = AMDGPU_USERQ_STATE_MAPPED;
> +			r = userq_funcs->set_gang(queue, secondary_queue);
> +		}
> +	}
> +
>  	return r;
>  }

[Severity: Medium]
Should amdgpu_userq_restore_helper() return immediately when restoring the
primary queue fails, as the other helpers do?

Without an early return in the primary queue error branch, a failed
userq_funcs->restore(queue) sets queue->state to AMDGPU_USERQ_STATE_HUNG
and falls through to the secondary_queue block.  Restoring secondary_queue
then overwrites r, calls userq_funcs->set_gang() with a hung primary queue,
and returns 0 to the caller if set_gang() succeeds.

[ ... ]

> @@ -403,7 +466,23 @@ static int amdgpu_userq_map_helper(struct amdgpu_usermode_queue *queue)
>  		}
>  	}
>  
> -	return 0;
> +	if (secondary_queue &&
> +	    secondary_queue->state == AMDGPU_USERQ_STATE_UNMAPPED) {
> +		trace_amdgpu_userq_state_start(secondary_queue);
> +
> +		r = userq_funcs->map(secondary_queue);
> +		if (r) {
> +			trace_amdgpu_userq_state_changed(secondary_queue, AMDGPU_USERQ_STATE_HUNG);
> +			secondary_queue->state = AMDGPU_USERQ_STATE_HUNG;
> +			return r;
> +		} else {
> +			trace_amdgpu_userq_state_changed(secondary_queue, AMDGPU_USERQ_STATE_MAPPED);
> +			secondary_queue->state = AMDGPU_USERQ_STATE_MAPPED;
> +			r = userq_funcs->set_gang(queue, secondary_queue);
> +		}
> +	}
> +
> +	return r;
>  }

[Severity: High]
Does calling userq_funcs->set_gang() here pass out-of-bounds gang context
GPU addresses to MES?

mes_userq_create_ctx_space() allocates queue->fw_obj with only one page
(AMDGPU_USERQ_GANG_CTX_SZ), and mes_userq_map() registers ctx->gpu_addr at
offset 0 as gang_context_addr.  However, mes_set_gang() adds
AMDGPU_USERQ_PROC_CTX_SZ (PAGE_SIZE) to both GPU addresses:

drivers/gpu/drm/amd/amdgpu/mes_userqueue.c:mes_set_gang() {
    ...
	input.primary_gang_context_addr =
		primary_ctx->gpu_addr + AMDGPU_USERQ_PROC_CTX_SZ;
	input.secondary_gang_context_addr =
		secondary_ctx->gpu_addr + AMDGPU_USERQ_PROC_CTX_SZ;
    ...
}

This points one page past the end of each 1-page fw_obj BO and does not
match the gang_context_addr registered with MES.

[Severity: Medium]
Should amdgpu_userq_post_reset() also call userq_funcs->set_gang() when
remapping ganged queues after a GPU reset?

When VRAM is not lost, amdgpu_userq_post_reset() remaps hung queues
directly via userq_funcs->map(queue) without using
amdgpu_userq_map_helper() or calling userq_funcs->set_gang(), leaving
ganged queues unlinked in MES after recovery.

> diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_userq.h b/drivers/gpu/drm/amd/amdgpu/amdgpu_userq.h
> index efaa658a26a9a..3dd63d6b9c445 100644
> --- a/drivers/gpu/drm/amd/amdgpu/amdgpu_userq.h
> +++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_userq.h
> @@ -102,6 +102,9 @@ struct amdgpu_usermode_queue {
>  	} userq_vas;
>  
>  	uint32_t	gang_ctx_array_index;
> +	bool			in_gang;
> +	bool			gang_primary;
> +	struct amdgpu_usermode_queue *gang_secondary;
>  };

[Severity: High]
What prevents callers iterating uq_mgr->userq_xa or
adev->userq_doorbell_xa from operating on a secondary gang queue directly?

Both queues remain in the XArrays, and neither the helpers nor the
xa_for_each() loops check queue->in_gang && !queue->gang_primary.

If xa_for_each() in amdgpu_userq_restore_all(), amdgpu_userq_resume(), or
amdgpu_userq_start_sched_for_enforce_isolation() visits secondary_queue
before primary_queue, secondary_queue is mapped or restored to
AMDGPU_USERQ_STATE_MAPPED on its own.  When primary_queue is visited next,
secondary_queue->state is no longer UNMAPPED or PREEMPTED, so
userq_funcs->set_gang() is skipped.

Conversely, if primary_queue is visited first in
amdgpu_userq_restore_all(), amdgpu_userq_map_helper(primary_queue) maps
secondary_queue in MES before amdgpu_userq_buffer_vas_mapped() is checked
on secondary_queue:

drivers/gpu/drm/amd/amdgpu/amdgpu_userq.c:amdgpu_userq_restore_all() {
    ...
	xa_for_each(&uq_mgr->userq_xa, queue_id, queue) {
		if (!amdgpu_userq_buffer_vas_mapped(queue)) {
			drm_file_err(uq_mgr->file,
				     "trying restore queue without va mapping\n");
			trace_amdgpu_userq_state_changed(queue, AMDGPU_USERQ_STATE_INVALID_VA);
			queue->state = AMDGPU_USERQ_STATE_INVALID_VA;
			continue;
		}

		r = amdgpu_userq_map_helper(queue);
    ...
}

If secondary_queue has unmapped VAs, the later loop iteration sets
secondary_queue->state to AMDGPU_USERQ_STATE_INVALID_VA while it remains
mapped in MES, so subsequent unmap and queue destruction skip unmapping it
from hardware before freeing its MQD and context BOs.

-- 
Sashiko AI review · https://sashiko.dev/#/patchset/20261117192415.810117-1-alexander.deucher@amd.com?part=7

^ permalink raw reply	[flat|nested] 13+ messages in thread

end of thread, other threads:[~2026-11-17 19:46 UTC | newest]

Thread overview: 13+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2026-11-17 19:24 [PATCH 1/9] drm/amdgpu/mes11: add API for gang submit Alex Deucher
2026-11-17 19:24 ` [PATCH 2/9] drm/amdgpu/mes: add callback " Alex Deucher
2026-11-17 19:24 ` [PATCH 3/9] drm/amdgpu/mes11: add support for setting " Alex Deucher
2026-11-17 19:37   ` sashiko-bot
2026-11-17 19:24 ` [PATCH 4/9] drm/amdgpu/mes12: " Alex Deucher
2026-11-17 19:24 ` [PATCH 5/9] drm/amdgpu/userq: add callback for gang setup Alex Deucher
2026-11-17 19:24 ` [PATCH 6/9] drm/amdgpu/userq/mes: implement set gang submit Alex Deucher
2026-11-17 19:35   ` sashiko-bot
2026-11-17 19:24 ` [PATCH 7/9] drm/amdgpu/userq: add handling for set_gang Alex Deucher
2026-11-17 19:46   ` sashiko-bot
2026-11-17 19:24 ` [PATCH 8/9] drm/amdgpu: add UAPI to create user queue gangs Alex Deucher
2026-11-17 19:24 ` [PATCH 9/9] drm/amdgpu/userq: enable support for creating gangs Alex Deucher
2026-11-17 19:44   ` sashiko-bot

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox