* [PATCH for-next v9 3/6] RDMA/core: Expose Completion Counter capabilities to userspace
2026-07-20 7:58 [PATCH for-next v9 2/6] RDMA/core: Prevent destroying in-use completion counters Michael Margolin
@ 2026-07-20 7:58 ` Michael Margolin
2026-07-20 7:58 ` [PATCH for-next v9 4/6] RDMA/core: Add Completion Counters to resource tracking Michael Margolin
` (2 subsequent siblings)
3 siblings, 0 replies; 5+ messages in thread
From: Michael Margolin @ 2026-07-20 7:58 UTC (permalink / raw)
To: jgg, leon, linux-rdma; +Cc: sleybo, matua, gal.pressman, Yonatan Nachum
Add a dedicated query interface for completion counter capabilities
via UVERBS_METHOD_QUERY_COMP_CNTR_CAPS on the device object.
The query returns the maximum number of counters, maximum counter
value, and a bitmask of supported QP attach operations. Each field
is an optional ioctl attribute, allowing userspace to request only
the capabilities it needs.
Drivers implement the query_comp_cntr_caps operation to report
device-specific capabilities.
Reviewed-by: Yonatan Nachum <ynachum@amazon.com>
Signed-off-by: Michael Margolin <mrgolin@amazon.com>
---
drivers/infiniband/core/device.c | 1 +
.../infiniband/core/uverbs_std_types_device.c | 51 ++++++++++++++++++-
include/rdma/ib_verbs.h | 9 ++++
include/uapi/rdma/ib_user_ioctl_cmds.h | 7 +++
4 files changed, 67 insertions(+), 1 deletion(-)
diff --git a/drivers/infiniband/core/device.c b/drivers/infiniband/core/device.c
index a4c57279f19d..ddf75867ac61 100644
--- a/drivers/infiniband/core/device.c
+++ b/drivers/infiniband/core/device.c
@@ -2829,6 +2829,7 @@ void ib_set_device_ops(struct ib_device *dev, const struct ib_device_ops *ops)
SET_DEVICE_OP(dev_ops, post_srq_recv);
SET_DEVICE_OP(dev_ops, process_mad);
SET_DEVICE_OP(dev_ops, query_ah);
+ SET_DEVICE_OP(dev_ops, query_comp_cntr_caps);
SET_DEVICE_OP(dev_ops, query_device);
SET_DEVICE_OP(dev_ops, query_gid);
SET_DEVICE_OP(dev_ops, query_pkey);
diff --git a/drivers/infiniband/core/uverbs_std_types_device.c b/drivers/infiniband/core/uverbs_std_types_device.c
index 12ca15739cd2..ce0a7de00405 100644
--- a/drivers/infiniband/core/uverbs_std_types_device.c
+++ b/drivers/infiniband/core/uverbs_std_types_device.c
@@ -472,6 +472,42 @@ static int UVERBS_HANDLER(UVERBS_METHOD_QUERY_GID_ENTRY)(
return ret;
}
+static int UVERBS_HANDLER(UVERBS_METHOD_QUERY_COMP_CNTR_CAPS)(
+ struct uverbs_attr_bundle *attrs)
+{
+ struct ib_comp_cntr_caps caps = {};
+ struct ib_ucontext *ucontext;
+ struct ib_device *ib_dev;
+ int ret;
+
+ ucontext = ib_uverbs_get_ucontext(attrs);
+ if (IS_ERR(ucontext))
+ return PTR_ERR(ucontext);
+ ib_dev = ucontext->device;
+
+ if (!ib_dev->ops.query_comp_cntr_caps)
+ return -EOPNOTSUPP;
+
+ ret = ib_dev->ops.query_comp_cntr_caps(ib_dev, &caps, attrs);
+ if (ret)
+ return ret;
+
+ ret = uverbs_copy_to(attrs, UVERBS_ATTR_QUERY_COMP_CNTR_CAPS_MAX_COUNTERS,
+ &caps.max_counters, sizeof(caps.max_counters));
+ if (IS_UVERBS_COPY_ERR(ret))
+ return ret;
+
+ ret = uverbs_copy_to(attrs, UVERBS_ATTR_QUERY_COMP_CNTR_CAPS_MAX_VALUE,
+ &caps.max_value, sizeof(caps.max_value));
+ if (IS_UVERBS_COPY_ERR(ret))
+ return ret;
+
+ ret = uverbs_copy_to(attrs, UVERBS_ATTR_QUERY_COMP_CNTR_CAPS_SUPPORTED_QP_ATTACH_OPS,
+ &caps.supported_qp_attach_ops,
+ sizeof(caps.supported_qp_attach_ops));
+ return IS_UVERBS_COPY_ERR(ret) ? ret : 0;
+}
+
DECLARE_UVERBS_NAMED_METHOD(
UVERBS_METHOD_GET_CONTEXT,
UVERBS_ATTR_PTR_OUT(UVERBS_ATTR_GET_CONTEXT_NUM_COMP_VECTORS,
@@ -542,6 +578,18 @@ DECLARE_UVERBS_NAMED_METHOD(
netdev_ifindex),
UA_MANDATORY));
+DECLARE_UVERBS_NAMED_METHOD(
+ UVERBS_METHOD_QUERY_COMP_CNTR_CAPS,
+ UVERBS_ATTR_PTR_OUT(UVERBS_ATTR_QUERY_COMP_CNTR_CAPS_MAX_COUNTERS,
+ UVERBS_ATTR_TYPE(u32),
+ UA_OPTIONAL),
+ UVERBS_ATTR_PTR_OUT(UVERBS_ATTR_QUERY_COMP_CNTR_CAPS_MAX_VALUE,
+ UVERBS_ATTR_TYPE(u64),
+ UA_OPTIONAL),
+ UVERBS_ATTR_PTR_OUT(UVERBS_ATTR_QUERY_COMP_CNTR_CAPS_SUPPORTED_QP_ATTACH_OPS,
+ UVERBS_ATTR_TYPE(u32),
+ UA_OPTIONAL));
+
DECLARE_UVERBS_GLOBAL_METHODS(UVERBS_OBJECT_DEVICE,
&UVERBS_METHOD(UVERBS_METHOD_GET_CONTEXT),
&UVERBS_METHOD(UVERBS_METHOD_INVOKE_WRITE),
@@ -550,7 +598,8 @@ DECLARE_UVERBS_GLOBAL_METHODS(UVERBS_OBJECT_DEVICE,
&UVERBS_METHOD(UVERBS_METHOD_QUERY_PORT_SPEED),
&UVERBS_METHOD(UVERBS_METHOD_QUERY_CONTEXT),
&UVERBS_METHOD(UVERBS_METHOD_QUERY_GID_TABLE),
- &UVERBS_METHOD(UVERBS_METHOD_QUERY_GID_ENTRY));
+ &UVERBS_METHOD(UVERBS_METHOD_QUERY_GID_ENTRY),
+ &UVERBS_METHOD(UVERBS_METHOD_QUERY_COMP_CNTR_CAPS));
const struct uapi_definition uverbs_def_obj_device[] = {
UAPI_DEF_CHAIN_OBJ_TREE_NAMED(UVERBS_OBJECT_DEVICE),
diff --git a/include/rdma/ib_verbs.h b/include/rdma/ib_verbs.h
index 84a8904fbad4..033f4a2c965f 100644
--- a/include/rdma/ib_verbs.h
+++ b/include/rdma/ib_verbs.h
@@ -1755,6 +1755,12 @@ enum ib_qp_attach_comp_cntr_op {
IB_QP_ATTACH_COMP_CNTR_OP_REMOTE_RDMA_WRITE = IB_UVERBS_QP_ATTACH_COMP_CNTR_OP_REMOTE_RDMA_WRITE,
};
+struct ib_comp_cntr_caps {
+ u64 max_value;
+ u32 max_counters;
+ u32 supported_qp_attach_ops; /* Bitmask of enum ib_qp_attach_comp_cntr_op */
+};
+
struct ib_comp_cntr {
struct ib_device *device;
struct ib_uobject *uobject;
@@ -2689,6 +2695,9 @@ struct ib_device_ops {
int (*modify_comp_cntr)(struct ib_comp_cntr *cc, enum ib_comp_cntr_entry entry,
enum ib_comp_cntr_modify_op op, u64 value);
int (*read_comp_cntr)(struct ib_comp_cntr *cc, enum ib_comp_cntr_entry entry, u64 *value);
+ int (*query_comp_cntr_caps)(struct ib_device *dev,
+ struct ib_comp_cntr_caps *caps,
+ struct uverbs_attr_bundle *attrs);
struct ib_mr *(*get_dma_mr)(struct ib_pd *pd, int mr_access_flags);
struct ib_mr *(*reg_user_mr)(struct ib_pd *pd, u64 start, u64 length,
u64 virt_addr, int mr_access_flags,
diff --git a/include/uapi/rdma/ib_user_ioctl_cmds.h b/include/uapi/rdma/ib_user_ioctl_cmds.h
index 19a94b91987e..6a3d59d03f54 100644
--- a/include/uapi/rdma/ib_user_ioctl_cmds.h
+++ b/include/uapi/rdma/ib_user_ioctl_cmds.h
@@ -76,6 +76,7 @@ enum uverbs_methods_device {
UVERBS_METHOD_QUERY_GID_TABLE,
UVERBS_METHOD_QUERY_GID_ENTRY,
UVERBS_METHOD_QUERY_PORT_SPEED,
+ UVERBS_METHOD_QUERY_COMP_CNTR_CAPS,
};
enum uverbs_attrs_invoke_write_cmd_attr_ids {
@@ -94,6 +95,12 @@ enum uverbs_attrs_query_port_speed_cmd_attr_ids {
UVERBS_ATTR_QUERY_PORT_SPEED_RESP,
};
+enum uverbs_attrs_query_comp_cntr_caps_attr_ids {
+ UVERBS_ATTR_QUERY_COMP_CNTR_CAPS_MAX_COUNTERS,
+ UVERBS_ATTR_QUERY_COMP_CNTR_CAPS_MAX_VALUE,
+ UVERBS_ATTR_QUERY_COMP_CNTR_CAPS_SUPPORTED_QP_ATTACH_OPS,
+};
+
enum uverbs_attrs_get_context_attr_ids {
UVERBS_ATTR_GET_CONTEXT_NUM_COMP_VECTORS,
UVERBS_ATTR_GET_CONTEXT_CORE_SUPPORT,
--
2.47.3
^ permalink raw reply related [flat|nested] 5+ messages in thread* [PATCH for-next v9 5/6] RDMA/efa: Update device interface
2026-07-20 7:58 [PATCH for-next v9 2/6] RDMA/core: Prevent destroying in-use completion counters Michael Margolin
2026-07-20 7:58 ` [PATCH for-next v9 3/6] RDMA/core: Expose Completion Counter capabilities to userspace Michael Margolin
2026-07-20 7:58 ` [PATCH for-next v9 4/6] RDMA/core: Add Completion Counters to resource tracking Michael Margolin
@ 2026-07-20 7:58 ` Michael Margolin
2026-07-20 7:58 ` [PATCH for-next v9 6/6] RDMA/efa: Add Completion Counters support Michael Margolin
3 siblings, 0 replies; 5+ messages in thread
From: Michael Margolin @ 2026-07-20 7:58 UTC (permalink / raw)
To: jgg, leon, linux-rdma
Cc: sleybo, matua, gal.pressman, Daniel Kinsbursky, Yonatan Nachum
Align device interface definitions.
Reviewed-by: Daniel Kinsbursky <dkinsb@amazon.com>
Reviewed-by: Yonatan Nachum <ynachum@amazon.com>
Signed-off-by: Michael Margolin <mrgolin@amazon.com>
---
.../infiniband/hw/efa/efa_admin_cmds_defs.h | 186 +++++++++++++++++-
drivers/infiniband/hw/efa/efa_io_defs.h | 20 +-
2 files changed, 202 insertions(+), 4 deletions(-)
diff --git a/drivers/infiniband/hw/efa/efa_admin_cmds_defs.h b/drivers/infiniband/hw/efa/efa_admin_cmds_defs.h
index 3eb3a4de8912..fc07213e26af 100644
--- a/drivers/infiniband/hw/efa/efa_admin_cmds_defs.h
+++ b/drivers/infiniband/hw/efa/efa_admin_cmds_defs.h
@@ -28,7 +28,13 @@ enum efa_admin_aq_opcode {
EFA_ADMIN_CREATE_EQ = 18,
EFA_ADMIN_DESTROY_EQ = 19,
EFA_ADMIN_ALLOC_MR = 20,
- EFA_ADMIN_MAX_OPCODE = 20,
+ EFA_ADMIN_SERVICE = 21,
+ EFA_ADMIN_CREATE_EVENT_COUNTER = 25,
+ EFA_ADMIN_DESTROY_EVENT_COUNTER = 26,
+ EFA_ADMIN_ATTACH_EVENT_COUNTER = 27,
+ EFA_ADMIN_MODIFY_EVENT_COUNTER = 28,
+ EFA_ADMIN_DETACH_EVENT_COUNTER = 29,
+ EFA_ADMIN_MAX_OPCODE = 29,
};
enum efa_admin_aq_feature_id {
@@ -722,7 +728,9 @@ struct efa_admin_feature_device_attr_desc {
* on TX queues
* 4 : unsolicited_write_recv - If set, unsolicited
* write with imm. receive is supported
- * 31:5 : reserved - MBZ
+ * 5 : event_counters - If set, event counters are
+ * supported
+ * 31:6 : reserved - MBZ
*/
u32 device_caps;
@@ -811,6 +819,34 @@ struct efa_admin_feature_queue_attr_desc_1 {
struct efa_admin_feature_queue_attr_desc_2 {
/* Maximum size of data that can be sent inline in a Send WQE */
u16 inline_buf_size_ex;
+
+ /* MBZ */
+ u8 reserved[6];
+
+ /*
+ * Supported counter QP events
+ * 0 : send_comp
+ * 1 : send_comp_err
+ * 2 : recv_comp
+ * 3 : recv_comp_err
+ * 4 : read_comp
+ * 5 : read_comp_err
+ * 6 : write_comp
+ * 7 : write_comp_err
+ * 8 : remote_read_comp
+ * 9 : remote_write_comp
+ * 31:10 : reserved - MBZ
+ */
+ u32 supported_event_counter_qp_events;
+
+ /* Maximum number of counters */
+ u32 max_event_counters;
+
+ /*
+ * Maximum counter value, counter wraps around to 0 after reaching
+ * this value
+ */
+ u64 event_counter_max_val;
};
struct efa_admin_event_queue_attr_desc {
@@ -1089,6 +1125,127 @@ struct efa_admin_host_info {
u32 flags;
};
+struct efa_admin_service_cmd {
+ struct efa_admin_aq_common_desc aq_common_descriptor;
+
+ u8 buffer[60];
+};
+
+struct efa_admin_service_resp {
+ struct efa_admin_acq_common_desc acq_common_desc;
+
+ u8 buffer[56];
+};
+
+/* Create Counter command */
+struct efa_admin_create_event_counter_cmd {
+ struct efa_admin_aq_common_desc aq_common_descriptor;
+
+ /* UAR number */
+ u16 uar;
+
+ /* MBZ */
+ u16 reserved;
+
+ /* Counter physical address */
+ u64 paddr;
+};
+
+struct efa_admin_create_event_counter_resp {
+ struct efa_admin_acq_common_desc acq_common_desc;
+
+ /* Counter handle */
+ u32 cntr_handle;
+
+ /* MBZ */
+ u32 reserved;
+};
+
+struct efa_admin_destroy_event_counter_cmd {
+ struct efa_admin_aq_common_desc aq_common_descriptor;
+
+ /* Counter handle */
+ u32 cntr_handle;
+};
+
+struct efa_admin_destroy_event_counter_resp {
+ struct efa_admin_acq_common_desc acq_common_desc;
+};
+
+enum efa_admin_event_counter_attach_type {
+ EFA_ADMIN_EVENT_COUNTER_ATTACH_QP_EVENTS = 0,
+};
+
+struct efa_admin_event_counter_attach_qp_events {
+ /* QP handle */
+ u32 qp_handle;
+
+ /*
+ * Bitmask of counter QP events
+ * 0 : send_comp
+ * 1 : send_comp_err
+ * 2 : recv_comp
+ * 3 : recv_comp_err
+ * 4 : read_comp
+ * 5 : read_comp_err
+ * 6 : write_comp
+ * 7 : write_comp_err
+ * 8 : remote_read_comp
+ * 9 : remote_write_comp
+ * 31:10 : reserved - MBZ
+ */
+ u32 events;
+};
+
+struct efa_admin_attach_detach_event_counter_cmd {
+ struct efa_admin_aq_common_desc aq_common_descriptor;
+
+ /* Counter handle */
+ u32 cntr_handle;
+
+ /* efa_admin_event_counter_attach_type */
+ u8 attach_type;
+
+ /* MBZ */
+ u8 reserved[3];
+
+ union {
+ struct efa_admin_event_counter_attach_qp_events qp_events;
+ } u;
+};
+
+struct efa_admin_attach_detach_event_counter_resp {
+ struct efa_admin_acq_common_desc acq_common_desc;
+};
+
+/* Counter modify operations */
+enum efa_admin_event_counter_modify_ops {
+ /* Set counter value */
+ EFA_ADMIN_EVENT_COUNTER_MODIFY_SET = 0,
+ /* Add to counter value */
+ EFA_ADMIN_EVENT_COUNTER_MODIFY_ADD = 1,
+};
+
+struct efa_admin_modify_event_counter_cmd {
+ struct efa_admin_aq_common_desc aq_common_descriptor;
+
+ /* Counter handle */
+ u32 cntr_handle;
+
+ /* Counter operation type (efa_admin_event_counter_modify_ops) */
+ u8 operation;
+
+ /* MBZ */
+ u8 reserved[7];
+
+ /* Value for SET or ADD */
+ u64 value;
+};
+
+struct efa_admin_modify_event_counter_resp {
+ struct efa_admin_acq_common_desc acq_common_desc;
+};
+
/* create_qp_cmd */
#define EFA_ADMIN_CREATE_QP_CMD_SQ_VIRT_MASK BIT(0)
#define EFA_ADMIN_CREATE_QP_CMD_RQ_VIRT_MASK BIT(1)
@@ -1129,6 +1286,19 @@ struct efa_admin_host_info {
#define EFA_ADMIN_FEATURE_DEVICE_ATTR_DESC_DATA_POLLING_128_MASK BIT(2)
#define EFA_ADMIN_FEATURE_DEVICE_ATTR_DESC_RDMA_WRITE_MASK BIT(3)
#define EFA_ADMIN_FEATURE_DEVICE_ATTR_DESC_UNSOLICITED_WRITE_RECV_MASK BIT(4)
+#define EFA_ADMIN_FEATURE_DEVICE_ATTR_DESC_EVENT_COUNTERS_MASK BIT(5)
+
+/* feature_queue_attr_desc_2 */
+#define EFA_ADMIN_FEATURE_QUEUE_ATTR_DESC_2_SEND_COMP_MASK BIT(0)
+#define EFA_ADMIN_FEATURE_QUEUE_ATTR_DESC_2_SEND_COMP_ERR_MASK BIT(1)
+#define EFA_ADMIN_FEATURE_QUEUE_ATTR_DESC_2_RECV_COMP_MASK BIT(2)
+#define EFA_ADMIN_FEATURE_QUEUE_ATTR_DESC_2_RECV_COMP_ERR_MASK BIT(3)
+#define EFA_ADMIN_FEATURE_QUEUE_ATTR_DESC_2_READ_COMP_MASK BIT(4)
+#define EFA_ADMIN_FEATURE_QUEUE_ATTR_DESC_2_READ_COMP_ERR_MASK BIT(5)
+#define EFA_ADMIN_FEATURE_QUEUE_ATTR_DESC_2_WRITE_COMP_MASK BIT(6)
+#define EFA_ADMIN_FEATURE_QUEUE_ATTR_DESC_2_WRITE_COMP_ERR_MASK BIT(7)
+#define EFA_ADMIN_FEATURE_QUEUE_ATTR_DESC_2_REMOTE_READ_COMP_MASK BIT(8)
+#define EFA_ADMIN_FEATURE_QUEUE_ATTR_DESC_2_REMOTE_WRITE_COMP_MASK BIT(9)
/* create_eq_cmd */
#define EFA_ADMIN_CREATE_EQ_CMD_ENTRY_SIZE_WORDS_MASK GENMASK(4, 0)
@@ -1147,4 +1317,16 @@ struct efa_admin_host_info {
#define EFA_ADMIN_HOST_INFO_INTREE_MASK BIT(0)
#define EFA_ADMIN_HOST_INFO_GDR_MASK BIT(1)
+/* counter_attach_qp_events */
+#define EFA_ADMIN_EVENT_COUNTER_ATTACH_QP_EVENTS_SEND_COMP_MASK BIT(0)
+#define EFA_ADMIN_EVENT_COUNTER_ATTACH_QP_EVENTS_SEND_COMP_ERR_MASK BIT(1)
+#define EFA_ADMIN_EVENT_COUNTER_ATTACH_QP_EVENTS_RECV_COMP_MASK BIT(2)
+#define EFA_ADMIN_EVENT_COUNTER_ATTACH_QP_EVENTS_RECV_COMP_ERR_MASK BIT(3)
+#define EFA_ADMIN_EVENT_COUNTER_ATTACH_QP_EVENTS_READ_COMP_MASK BIT(4)
+#define EFA_ADMIN_EVENT_COUNTER_ATTACH_QP_EVENTS_READ_COMP_ERR_MASK BIT(5)
+#define EFA_ADMIN_EVENT_COUNTER_ATTACH_QP_EVENTS_WRITE_COMP_MASK BIT(6)
+#define EFA_ADMIN_EVENT_COUNTER_ATTACH_QP_EVENTS_WRITE_COMP_ERR_MASK BIT(7)
+#define EFA_ADMIN_EVENT_COUNTER_ATTACH_QP_EVENTS_REMOTE_READ_COMP_MASK BIT(8)
+#define EFA_ADMIN_EVENT_COUNTER_ATTACH_QP_EVENTS_REMOTE_WRITE_COMP_MASK BIT(9)
+
#endif /* _EFA_ADMIN_CMDS_H_ */
diff --git a/drivers/infiniband/hw/efa/efa_io_defs.h b/drivers/infiniband/hw/efa/efa_io_defs.h
index a4c9fd33da38..a849d92a6eb6 100644
--- a/drivers/infiniband/hw/efa/efa_io_defs.h
+++ b/drivers/infiniband/hw/efa/efa_io_defs.h
@@ -1,6 +1,6 @@
/* SPDX-License-Identifier: GPL-2.0 OR BSD-2-Clause */
/*
- * Copyright 2018-2024 Amazon.com, Inc. or its affiliates. All rights reserved.
+ * Copyright 2018-2026 Amazon.com, Inc. or its affiliates. All rights reserved.
*/
#ifndef _EFA_IO_H_
@@ -65,6 +65,8 @@ enum efa_io_comp_status {
EFA_IO_COMP_STATUS_REMOTE_ERROR_UNKNOWN_PEER = 14,
/* Unreachable remote - never received a response */
EFA_IO_COMP_STATUS_LOCAL_ERROR_UNREACH_REMOTE = 15,
+ /* Remote feature mismatch */
+ EFA_IO_COMP_STATUS_REMOTE_ERROR_FEATURE_MISMATCH = 18,
};
enum efa_io_frwr_pbl_mode {
@@ -72,6 +74,11 @@ enum efa_io_frwr_pbl_mode {
EFA_IO_FRWR_DIRECT_PBL = 1,
};
+enum efa_io_processing_hint {
+ /* Optimize for throughput */
+ EFA_IO_PROCESSING_HINT_BURST_PPS_SENSITIVE = 1 << 0,
+};
+
struct efa_io_tx_meta_desc {
/* Verbs-generated Request ID */
u16 req_id;
@@ -121,7 +128,15 @@ struct efa_io_tx_meta_desc {
u16 ah;
- u16 reserved;
+ /*
+ * control flags
+ * 1:0 : processing_hints - Bitmask of enum
+ * efa_io_processing_hint
+ * 7:2 : reserved - MBZ
+ */
+ u8 ctrl3;
+
+ u8 reserved;
/* Queue key */
u32 qkey;
@@ -365,6 +380,7 @@ struct efa_io_rx_cdesc_ex {
#define EFA_IO_TX_META_DESC_FIRST_MASK BIT(2)
#define EFA_IO_TX_META_DESC_LAST_MASK BIT(3)
#define EFA_IO_TX_META_DESC_COMP_REQ_MASK BIT(4)
+#define EFA_IO_TX_META_DESC_PROCESSING_HINTS_MASK GENMASK(1, 0)
/* tx_buf_desc */
#define EFA_IO_TX_BUF_DESC_LKEY_MASK GENMASK(23, 0)
--
2.47.3
^ permalink raw reply related [flat|nested] 5+ messages in thread* [PATCH for-next v9 6/6] RDMA/efa: Add Completion Counters support
2026-07-20 7:58 [PATCH for-next v9 2/6] RDMA/core: Prevent destroying in-use completion counters Michael Margolin
` (2 preceding siblings ...)
2026-07-20 7:58 ` [PATCH for-next v9 5/6] RDMA/efa: Update device interface Michael Margolin
@ 2026-07-20 7:58 ` Michael Margolin
3 siblings, 0 replies; 5+ messages in thread
From: Michael Margolin @ 2026-07-20 7:58 UTC (permalink / raw)
To: jgg, leon, linux-rdma; +Cc: sleybo, matua, gal.pressman, Yonatan Nachum
Implement completion counters for the EFA device. Each completion
counter is backed by two EFA event counters, one for success
completions and one for error completions.
The driver creates umem for counters from private descriptor ioctl
attributes using core utility.
Read operations are not implemented as the counter values are accessed
directly from userspace through the mapped memory.
Reviewed-by: Yonatan Nachum <ynachum@amazon.com>
Signed-off-by: Michael Margolin <mrgolin@amazon.com>
---
drivers/infiniband/hw/efa/efa.h | 20 +-
drivers/infiniband/hw/efa/efa_com_cmd.c | 136 ++++++++++++++
drivers/infiniband/hw/efa/efa_com_cmd.h | 45 +++++
drivers/infiniband/hw/efa/efa_main.c | 8 +-
drivers/infiniband/hw/efa/efa_verbs.c | 237 ++++++++++++++++++++++++
include/uapi/rdma/efa-abi.h | 6 +
6 files changed, 450 insertions(+), 2 deletions(-)
diff --git a/drivers/infiniband/hw/efa/efa.h b/drivers/infiniband/hw/efa/efa.h
index f4586bb170c1..6f6686eefb1a 100644
--- a/drivers/infiniband/hw/efa/efa.h
+++ b/drivers/infiniband/hw/efa/efa.h
@@ -1,6 +1,6 @@
/* SPDX-License-Identifier: GPL-2.0 OR BSD-2-Clause */
/*
- * Copyright 2018-2025 Amazon.com, Inc. or its affiliates. All rights reserved.
+ * Copyright 2018-2026 Amazon.com, Inc. or its affiliates. All rights reserved.
*/
#ifndef _EFA_H_
@@ -110,6 +110,14 @@ struct efa_cq {
struct ib_umem *umem;
};
+struct efa_comp_cntr {
+ struct ib_comp_cntr ibcc;
+ struct ib_umem *comp_umem;
+ struct ib_umem *err_umem;
+ u32 comp_handle;
+ u32 err_handle;
+};
+
struct efa_qp {
struct ib_qp ibqp;
dma_addr_t rq_dma_addr;
@@ -164,6 +172,16 @@ int efa_create_qp(struct ib_qp *ibqp, struct ib_qp_init_attr *init_attr,
int efa_destroy_cq(struct ib_cq *ibcq, struct ib_udata *udata);
int efa_create_user_cq(struct ib_cq *ibcq, const struct ib_cq_init_attr *attr,
struct uverbs_attr_bundle *attrs);
+int efa_query_comp_cntr_caps(struct ib_device *ibdev,
+ struct ib_comp_cntr_caps *caps,
+ struct uverbs_attr_bundle *attrs);
+int efa_create_comp_cntr(struct ib_comp_cntr *ibcc,
+ struct uverbs_attr_bundle *attrs);
+int efa_destroy_comp_cntr(struct ib_comp_cntr *ibcc);
+int efa_modify_comp_cntr(struct ib_comp_cntr *ibcc, enum ib_comp_cntr_entry entry,
+ enum ib_comp_cntr_modify_op op, u64 value);
+int efa_qp_attach_comp_cntr(struct ib_qp *ibqp, struct ib_comp_cntr *ibcc,
+ struct ib_qp_attach_comp_cntr_attr *attr);
struct ib_mr *efa_reg_mr(struct ib_pd *ibpd, u64 start, u64 length,
u64 virt_addr, int access_flags,
struct ib_dmah *dmah,
diff --git a/drivers/infiniband/hw/efa/efa_com_cmd.c b/drivers/infiniband/hw/efa/efa_com_cmd.c
index 0b96862c2787..a9fd44b4debf 100644
--- a/drivers/infiniband/hw/efa/efa_com_cmd.c
+++ b/drivers/infiniband/hw/efa/efa_com_cmd.c
@@ -553,6 +553,10 @@ int efa_com_get_device_attr(struct efa_com_dev *edev,
}
result->inline_buf_size_ex = resp.u.queue_attr_2.inline_buf_size_ex;
+ result->max_event_counters = resp.u.queue_attr_2.max_event_counters;
+ result->event_counter_max_val = resp.u.queue_attr_2.event_counter_max_val;
+ result->supported_event_counter_qp_events =
+ resp.u.queue_attr_2.supported_event_counter_qp_events;
} else {
result->inline_buf_size_ex = result->inline_buf_size;
}
@@ -888,3 +892,135 @@ int efa_com_get_stats(struct efa_com_dev *edev,
return 0;
}
+
+int efa_com_create_event_counter(struct efa_com_dev *edev,
+ struct efa_com_create_event_counter_params *params,
+ struct efa_com_create_event_counter_result *result)
+{
+ struct efa_admin_create_event_counter_cmd cmd = {};
+ struct efa_admin_create_event_counter_resp resp;
+ struct efa_com_admin_queue *aq = &edev->aq;
+ int err;
+
+ cmd.aq_common_descriptor.opcode = EFA_ADMIN_CREATE_EVENT_COUNTER;
+ cmd.uar = params->uarn;
+ cmd.paddr = params->dma_addr;
+
+ err = efa_com_cmd_exec(aq, (struct efa_admin_aq_entry *)&cmd,
+ sizeof(cmd),
+ (struct efa_admin_acq_entry *)&resp,
+ sizeof(resp));
+ if (err) {
+ ibdev_err_ratelimited(edev->efa_dev,
+ "Failed to create event counter [%d]\n",
+ err);
+ return err;
+ }
+
+ result->cntr_handle = resp.cntr_handle;
+ return 0;
+}
+
+int efa_com_destroy_event_counter(struct efa_com_dev *edev,
+ struct efa_com_destroy_event_counter_params *params)
+{
+ struct efa_admin_destroy_event_counter_cmd cmd = {};
+ struct efa_admin_destroy_event_counter_resp resp;
+ struct efa_com_admin_queue *aq = &edev->aq;
+ int err;
+
+ cmd.aq_common_descriptor.opcode = EFA_ADMIN_DESTROY_EVENT_COUNTER;
+ cmd.cntr_handle = params->cntr_handle;
+
+ err = efa_com_cmd_exec(aq, (struct efa_admin_aq_entry *)&cmd,
+ sizeof(cmd),
+ (struct efa_admin_acq_entry *)&resp,
+ sizeof(resp));
+ if (err) {
+ ibdev_err_ratelimited(edev->efa_dev,
+ "Failed to destroy event counter [%d]\n",
+ err);
+ return err;
+ }
+
+ return 0;
+}
+
+static int efa_com_attach_detach_event_counter(struct efa_com_dev *edev, u8 opcode,
+ u32 cntr_handle, u32 qp_handle,
+ u32 events)
+{
+ struct efa_admin_attach_detach_event_counter_cmd cmd = {};
+ struct efa_admin_attach_detach_event_counter_resp resp;
+ struct efa_com_admin_queue *aq = &edev->aq;
+ int err;
+
+ cmd.aq_common_descriptor.opcode = opcode;
+ cmd.cntr_handle = cntr_handle;
+ cmd.attach_type = EFA_ADMIN_EVENT_COUNTER_ATTACH_QP_EVENTS;
+ cmd.u.qp_events.qp_handle = qp_handle;
+ cmd.u.qp_events.events = events;
+
+ err = efa_com_cmd_exec(aq, (struct efa_admin_aq_entry *)&cmd,
+ sizeof(cmd),
+ (struct efa_admin_acq_entry *)&resp,
+ sizeof(resp));
+ if (err) {
+ ibdev_err_ratelimited(edev->efa_dev,
+ "Failed to %s event counter [%d]\n",
+ opcode == EFA_ADMIN_ATTACH_EVENT_COUNTER
+ ? "attach"
+ : "detach",
+ err);
+ return err;
+ }
+
+ return 0;
+}
+
+int efa_com_attach_event_counter(struct efa_com_dev *edev,
+ struct efa_com_attach_event_counter_params *params)
+{
+ return efa_com_attach_detach_event_counter(edev,
+ EFA_ADMIN_ATTACH_EVENT_COUNTER,
+ params->cntr_handle,
+ params->qp_handle,
+ params->events);
+}
+
+int efa_com_detach_event_counter(struct efa_com_dev *edev,
+ struct efa_com_detach_event_counter_params *params)
+{
+ return efa_com_attach_detach_event_counter(edev,
+ EFA_ADMIN_DETACH_EVENT_COUNTER,
+ params->cntr_handle,
+ params->qp_handle,
+ params->events);
+}
+
+int efa_com_modify_event_counter(struct efa_com_dev *edev,
+ struct efa_com_modify_event_counter_params *params)
+{
+ struct efa_admin_modify_event_counter_cmd cmd = {};
+ struct efa_admin_modify_event_counter_resp resp;
+ struct efa_com_admin_queue *aq = &edev->aq;
+ int err;
+
+ cmd.aq_common_descriptor.opcode = EFA_ADMIN_MODIFY_EVENT_COUNTER;
+ cmd.cntr_handle = params->cntr_handle;
+ cmd.operation = params->operation;
+ cmd.value = params->value;
+
+ err = efa_com_cmd_exec(aq, (struct efa_admin_aq_entry *)&cmd,
+ sizeof(cmd),
+ (struct efa_admin_acq_entry *)&resp,
+ sizeof(resp));
+ if (err) {
+ ibdev_err_ratelimited(edev->efa_dev,
+ "Failed to modify event counter [%d]\n",
+ err);
+ return err;
+ }
+
+ return 0;
+}
diff --git a/drivers/infiniband/hw/efa/efa_com_cmd.h b/drivers/infiniband/hw/efa/efa_com_cmd.h
index 39bd4e06684a..3e7380fa0abb 100644
--- a/drivers/infiniband/hw/efa/efa_com_cmd.h
+++ b/drivers/infiniband/hw/efa/efa_com_cmd.h
@@ -146,6 +146,9 @@ struct efa_com_get_device_attr_result {
u16 min_sq_depth;
u16 max_link_speed_gbps;
u8 db_bar;
+ u32 max_event_counters;
+ u64 event_counter_max_val;
+ u32 supported_event_counter_qp_events;
};
struct efa_com_get_hw_hints_result {
@@ -301,6 +304,37 @@ union efa_com_get_stats_result {
struct efa_com_network_stats network_stats;
};
+struct efa_com_create_event_counter_params {
+ dma_addr_t dma_addr;
+ u16 uarn;
+};
+
+struct efa_com_create_event_counter_result {
+ u32 cntr_handle;
+};
+
+struct efa_com_destroy_event_counter_params {
+ u32 cntr_handle;
+};
+
+struct efa_com_attach_event_counter_params {
+ u32 cntr_handle;
+ u32 qp_handle;
+ u32 events;
+};
+
+struct efa_com_detach_event_counter_params {
+ u32 cntr_handle;
+ u32 qp_handle;
+ u32 events;
+};
+
+struct efa_com_modify_event_counter_params {
+ u32 cntr_handle;
+ u8 operation;
+ u64 value;
+};
+
int efa_com_create_qp(struct efa_com_dev *edev,
struct efa_com_create_qp_params *params,
struct efa_com_create_qp_result *res);
@@ -351,5 +385,16 @@ int efa_com_dealloc_uar(struct efa_com_dev *edev,
int efa_com_get_stats(struct efa_com_dev *edev,
struct efa_com_get_stats_params *params,
union efa_com_get_stats_result *result);
+int efa_com_create_event_counter(struct efa_com_dev *edev,
+ struct efa_com_create_event_counter_params *params,
+ struct efa_com_create_event_counter_result *result);
+int efa_com_destroy_event_counter(struct efa_com_dev *edev,
+ struct efa_com_destroy_event_counter_params *params);
+int efa_com_attach_event_counter(struct efa_com_dev *edev,
+ struct efa_com_attach_event_counter_params *params);
+int efa_com_detach_event_counter(struct efa_com_dev *edev,
+ struct efa_com_detach_event_counter_params *params);
+int efa_com_modify_event_counter(struct efa_com_dev *edev,
+ struct efa_com_modify_event_counter_params *params);
#endif /* _EFA_COM_CMD_H_ */
diff --git a/drivers/infiniband/hw/efa/efa_main.c b/drivers/infiniband/hw/efa/efa_main.c
index ee09dc1e0b43..4cd80727dcd2 100644
--- a/drivers/infiniband/hw/efa/efa_main.c
+++ b/drivers/infiniband/hw/efa/efa_main.c
@@ -1,6 +1,6 @@
// SPDX-License-Identifier: GPL-2.0 OR BSD-2-Clause
/*
- * Copyright 2018-2025 Amazon.com, Inc. or its affiliates. All rights reserved.
+ * Copyright 2018-2026 Amazon.com, Inc. or its affiliates. All rights reserved.
*/
#include <linux/module.h>
@@ -374,20 +374,25 @@ static const struct ib_device_ops efa_dev_ops = {
.alloc_pd = efa_alloc_pd,
.alloc_ucontext = efa_alloc_ucontext,
.create_user_cq = efa_create_user_cq,
+ .create_comp_cntr = efa_create_comp_cntr,
.create_qp = efa_create_qp,
.create_user_ah = efa_create_ah,
.dealloc_pd = efa_dealloc_pd,
.dealloc_ucontext = efa_dealloc_ucontext,
.dereg_mr = efa_dereg_mr,
.destroy_ah = efa_destroy_ah,
+ .destroy_comp_cntr = efa_destroy_comp_cntr,
.destroy_cq = efa_destroy_cq,
.destroy_qp = efa_destroy_qp,
.get_hw_stats = efa_get_hw_stats,
.get_link_layer = efa_port_link_layer,
.get_port_immutable = efa_get_port_immutable,
+ .modify_comp_cntr = efa_modify_comp_cntr,
.mmap = efa_mmap,
.mmap_free = efa_mmap_free,
.modify_qp = efa_modify_qp,
+ .qp_attach_comp_cntr = efa_qp_attach_comp_cntr,
+ .query_comp_cntr_caps = efa_query_comp_cntr_caps,
.query_device = efa_query_device,
.query_gid = efa_query_gid,
.query_pkey = efa_query_pkey,
@@ -399,6 +404,7 @@ static const struct ib_device_ops efa_dev_ops = {
INIT_RDMA_OBJ_SIZE(ib_ah, efa_ah, ibah),
INIT_RDMA_OBJ_SIZE(ib_cq, efa_cq, ibcq),
+ INIT_RDMA_OBJ_SIZE(ib_comp_cntr, efa_comp_cntr, ibcc),
INIT_RDMA_OBJ_SIZE(ib_pd, efa_pd, ibpd),
INIT_RDMA_OBJ_SIZE(ib_qp, efa_qp, ibqp),
INIT_RDMA_OBJ_SIZE(ib_ucontext, efa_ucontext, ibucontext),
diff --git a/drivers/infiniband/hw/efa/efa_verbs.c b/drivers/infiniband/hw/efa/efa_verbs.c
index 6be8ec53dcb3..9bc8199b60bf 100644
--- a/drivers/infiniband/hw/efa/efa_verbs.c
+++ b/drivers/infiniband/hw/efa/efa_verbs.c
@@ -167,6 +167,11 @@ static inline struct efa_ah *to_eah(struct ib_ah *ibah)
return container_of(ibah, struct efa_ah, ibah);
}
+static inline struct efa_comp_cntr *to_ecc(struct ib_comp_cntr *ibcc)
+{
+ return container_of(ibcc, struct efa_comp_cntr, ibcc);
+}
+
static inline struct efa_user_mmap_entry *
to_emmap(struct rdma_user_mmap_entry *rdma_entry)
{
@@ -264,6 +269,9 @@ int efa_query_device(struct ib_device *ibdev,
if (EFA_DEV_CAP(dev, UNSOLICITED_WRITE_RECV))
resp.device_caps |= EFA_QUERY_DEVICE_CAPS_UNSOLICITED_WRITE_RECV;
+ if (EFA_DEV_CAP(dev, EVENT_COUNTERS))
+ resp.device_caps |= EFA_QUERY_DEVICE_CAPS_COMP_CNTR;
+
if (dev->neqs)
resp.device_caps |= EFA_QUERY_DEVICE_CAPS_CQ_NOTIFICATIONS;
@@ -2260,6 +2268,220 @@ enum rdma_link_layer efa_port_link_layer(struct ib_device *ibdev,
return IB_LINK_LAYER_UNSPECIFIED;
}
+int efa_query_comp_cntr_caps(struct ib_device *ibdev,
+ struct ib_comp_cntr_caps *caps,
+ struct uverbs_attr_bundle *attrs)
+{
+ struct efa_dev *dev = to_edev(ibdev);
+ u32 dev_ops = dev->dev_attr.supported_event_counter_qp_events;
+
+ caps->max_counters = dev->dev_attr.max_event_counters / 2;
+ caps->max_value = dev->dev_attr.event_counter_max_val;
+
+ caps->supported_qp_attach_ops = 0;
+ if (EFA_GET(&dev_ops, EFA_ADMIN_EVENT_COUNTER_ATTACH_QP_EVENTS_SEND_COMP) &&
+ EFA_GET(&dev_ops, EFA_ADMIN_EVENT_COUNTER_ATTACH_QP_EVENTS_SEND_COMP_ERR))
+ caps->supported_qp_attach_ops |= IB_QP_ATTACH_COMP_CNTR_OP_SEND;
+ if (EFA_GET(&dev_ops, EFA_ADMIN_EVENT_COUNTER_ATTACH_QP_EVENTS_RECV_COMP) &&
+ EFA_GET(&dev_ops, EFA_ADMIN_EVENT_COUNTER_ATTACH_QP_EVENTS_RECV_COMP_ERR))
+ caps->supported_qp_attach_ops |= IB_QP_ATTACH_COMP_CNTR_OP_RECV;
+ if (EFA_GET(&dev_ops, EFA_ADMIN_EVENT_COUNTER_ATTACH_QP_EVENTS_READ_COMP) &&
+ EFA_GET(&dev_ops, EFA_ADMIN_EVENT_COUNTER_ATTACH_QP_EVENTS_READ_COMP_ERR))
+ caps->supported_qp_attach_ops |= IB_QP_ATTACH_COMP_CNTR_OP_RDMA_READ;
+ if (EFA_GET(&dev_ops, EFA_ADMIN_EVENT_COUNTER_ATTACH_QP_EVENTS_WRITE_COMP) &&
+ EFA_GET(&dev_ops, EFA_ADMIN_EVENT_COUNTER_ATTACH_QP_EVENTS_WRITE_COMP_ERR))
+ caps->supported_qp_attach_ops |= IB_QP_ATTACH_COMP_CNTR_OP_RDMA_WRITE;
+ if (EFA_GET(&dev_ops, EFA_ADMIN_EVENT_COUNTER_ATTACH_QP_EVENTS_REMOTE_READ_COMP))
+ caps->supported_qp_attach_ops |= IB_QP_ATTACH_COMP_CNTR_OP_REMOTE_RDMA_READ;
+ if (EFA_GET(&dev_ops, EFA_ADMIN_EVENT_COUNTER_ATTACH_QP_EVENTS_REMOTE_WRITE_COMP))
+ caps->supported_qp_attach_ops |= IB_QP_ATTACH_COMP_CNTR_OP_REMOTE_RDMA_WRITE;
+
+ return 0;
+}
+
+static int efa_create_event_counter(struct efa_dev *dev, u16 uarn, dma_addr_t addr, u32 *handle)
+{
+ struct efa_com_create_event_counter_params params = {};
+ struct efa_com_create_event_counter_result result;
+ int err;
+
+ params.uarn = uarn;
+ params.dma_addr = addr;
+
+ err = efa_com_create_event_counter(&dev->edev, ¶ms, &result);
+ if (err)
+ return err;
+
+ *handle = result.cntr_handle;
+ return 0;
+}
+
+static int efa_destroy_event_counter(struct efa_dev *dev, u32 handle)
+{
+ struct efa_com_destroy_event_counter_params params = {
+ .cntr_handle = handle,
+ };
+
+ return efa_com_destroy_event_counter(&dev->edev, ¶ms);
+}
+
+int efa_create_comp_cntr(struct ib_comp_cntr *ibcc, struct uverbs_attr_bundle *attrs)
+{
+ struct efa_dev *dev = to_edev(ibcc->device);
+ struct efa_comp_cntr *cc = to_ecc(ibcc);
+ struct efa_ucontext *ucontext;
+ struct ib_umem *comp_umem;
+ struct ib_umem *err_umem;
+ dma_addr_t comp_addr;
+ dma_addr_t err_addr;
+ int err;
+
+ ucontext = rdma_udata_to_drv_context(&attrs->driver_udata, struct efa_ucontext,
+ ibucontext);
+
+ comp_umem = ib_umem_get_attr(ibcc->device, attrs, EFA_IB_ATTR_CREATE_COMP_CNTR_COMP_BUFFER,
+ sizeof(u64), IB_ACCESS_LOCAL_WRITE);
+ if (IS_ERR(comp_umem))
+ return PTR_ERR(comp_umem);
+
+ err_umem = ib_umem_get_attr(ibcc->device, attrs, EFA_IB_ATTR_CREATE_COMP_CNTR_ERR_BUFFER,
+ sizeof(u64), IB_ACCESS_LOCAL_WRITE);
+ if (IS_ERR(err_umem)) {
+ err = PTR_ERR(err_umem);
+ goto err_comp_umem;
+ }
+
+ comp_addr = ib_umem_start_dma_addr(comp_umem);
+ err_addr = ib_umem_start_dma_addr(err_umem);
+
+ if (!IS_ALIGNED(comp_addr, sizeof(u64)) || !IS_ALIGNED(err_addr, sizeof(u64))) {
+ ibdev_dbg(&dev->ibdev, "Completion Counter memory is unaligned\n");
+ err = -EINVAL;
+ goto err_err_umem;
+ }
+
+ err = efa_create_event_counter(dev, ucontext->uarn, comp_addr, &cc->comp_handle);
+ if (err) {
+ ibdev_dbg(&dev->ibdev, "Failed to create comp event counter [%d]\n", err);
+ goto err_err_umem;
+ }
+
+ err = efa_create_event_counter(dev, ucontext->uarn, err_addr, &cc->err_handle);
+ if (err) {
+ ibdev_dbg(&dev->ibdev, "Failed to create err event counter [%d]\n", err);
+ goto err_destroy_comp_event_cntr;
+ }
+
+ cc->comp_umem = comp_umem;
+ cc->err_umem = err_umem;
+
+ return 0;
+
+err_destroy_comp_event_cntr:
+ efa_destroy_event_counter(dev, cc->comp_handle);
+err_err_umem:
+ ib_umem_release(err_umem);
+err_comp_umem:
+ ib_umem_release(comp_umem);
+ return err;
+}
+
+int efa_destroy_comp_cntr(struct ib_comp_cntr *ibcc)
+{
+ struct efa_dev *dev = to_edev(ibcc->device);
+ struct efa_comp_cntr *cc = to_ecc(ibcc);
+
+ efa_destroy_event_counter(dev, cc->comp_handle);
+ efa_destroy_event_counter(dev, cc->err_handle);
+
+ ib_umem_release(cc->comp_umem);
+ ib_umem_release(cc->err_umem);
+ return 0;
+}
+
+int efa_modify_comp_cntr(struct ib_comp_cntr *ibcc, enum ib_comp_cntr_entry entry,
+ enum ib_comp_cntr_modify_op op, u64 value)
+{
+ struct efa_com_modify_event_counter_params params = {};
+ struct efa_comp_cntr *cc = to_ecc(ibcc);
+
+ params.cntr_handle = entry == IB_COMP_CNTR_ENTRY_ERR ? cc->err_handle : cc->comp_handle;
+ params.operation = op == IB_COMP_CNTR_MODIFY_OP_SET ?
+ EFA_ADMIN_EVENT_COUNTER_MODIFY_SET : EFA_ADMIN_EVENT_COUNTER_MODIFY_ADD;
+ params.value = value;
+
+ return efa_com_modify_event_counter(&to_edev(ibcc->device)->edev, ¶ms);
+}
+
+static u32 efa_comp_cntr_op_to_comp_events(u32 op_mask)
+{
+ u32 events = 0;
+
+ if (op_mask & IB_QP_ATTACH_COMP_CNTR_OP_SEND)
+ EFA_SET(&events, EFA_ADMIN_EVENT_COUNTER_ATTACH_QP_EVENTS_SEND_COMP, 1);
+ if (op_mask & IB_QP_ATTACH_COMP_CNTR_OP_RECV)
+ EFA_SET(&events, EFA_ADMIN_EVENT_COUNTER_ATTACH_QP_EVENTS_RECV_COMP, 1);
+ if (op_mask & IB_QP_ATTACH_COMP_CNTR_OP_RDMA_READ)
+ EFA_SET(&events, EFA_ADMIN_EVENT_COUNTER_ATTACH_QP_EVENTS_READ_COMP, 1);
+ if (op_mask & IB_QP_ATTACH_COMP_CNTR_OP_REMOTE_RDMA_READ)
+ EFA_SET(&events, EFA_ADMIN_EVENT_COUNTER_ATTACH_QP_EVENTS_REMOTE_READ_COMP, 1);
+ if (op_mask & IB_QP_ATTACH_COMP_CNTR_OP_RDMA_WRITE)
+ EFA_SET(&events, EFA_ADMIN_EVENT_COUNTER_ATTACH_QP_EVENTS_WRITE_COMP, 1);
+ if (op_mask & IB_QP_ATTACH_COMP_CNTR_OP_REMOTE_RDMA_WRITE)
+ EFA_SET(&events, EFA_ADMIN_EVENT_COUNTER_ATTACH_QP_EVENTS_REMOTE_WRITE_COMP, 1);
+
+ return events;
+}
+
+static u32 efa_comp_cntr_op_to_err_events(u32 op_mask)
+{
+ u32 events = 0;
+
+ if (op_mask & IB_QP_ATTACH_COMP_CNTR_OP_SEND)
+ EFA_SET(&events, EFA_ADMIN_EVENT_COUNTER_ATTACH_QP_EVENTS_SEND_COMP_ERR, 1);
+ if (op_mask & IB_QP_ATTACH_COMP_CNTR_OP_RECV)
+ EFA_SET(&events, EFA_ADMIN_EVENT_COUNTER_ATTACH_QP_EVENTS_RECV_COMP_ERR, 1);
+ if (op_mask & IB_QP_ATTACH_COMP_CNTR_OP_RDMA_READ)
+ EFA_SET(&events, EFA_ADMIN_EVENT_COUNTER_ATTACH_QP_EVENTS_READ_COMP_ERR, 1);
+ if (op_mask & IB_QP_ATTACH_COMP_CNTR_OP_RDMA_WRITE)
+ EFA_SET(&events, EFA_ADMIN_EVENT_COUNTER_ATTACH_QP_EVENTS_WRITE_COMP_ERR, 1);
+
+ return events;
+}
+
+int efa_qp_attach_comp_cntr(struct ib_qp *ibqp, struct ib_comp_cntr *ibcc,
+ struct ib_qp_attach_comp_cntr_attr *attr)
+{
+ struct efa_com_detach_event_counter_params detach_params = {};
+ struct efa_com_attach_event_counter_params params = {};
+ struct efa_dev *dev = to_edev(ibqp->device);
+ struct efa_comp_cntr *cc = to_ecc(ibcc);
+ struct efa_qp *qp = to_eqp(ibqp);
+ int err;
+
+ params.cntr_handle = cc->comp_handle;
+ params.qp_handle = qp->qp_handle;
+ params.events = efa_comp_cntr_op_to_comp_events(attr->op_mask);
+
+ err = efa_com_attach_event_counter(&dev->edev, ¶ms);
+ if (err)
+ return err;
+
+ params.cntr_handle = cc->err_handle;
+ params.events = efa_comp_cntr_op_to_err_events(attr->op_mask);
+
+ err = efa_com_attach_event_counter(&dev->edev, ¶ms);
+ if (err) {
+ detach_params.cntr_handle = cc->comp_handle;
+ detach_params.qp_handle = qp->qp_handle;
+ detach_params.events = efa_comp_cntr_op_to_comp_events(attr->op_mask);
+ efa_com_detach_event_counter(&dev->edev, &detach_params);
+ return err;
+ }
+
+ return 0;
+}
+
DECLARE_UVERBS_NAMED_METHOD(EFA_IB_METHOD_MR_QUERY,
UVERBS_ATTR_IDR(EFA_IB_ATTR_QUERY_MR_HANDLE,
UVERBS_OBJECT_MR,
@@ -2282,8 +2504,23 @@ ADD_UVERBS_METHODS(efa_mr,
UVERBS_OBJECT_MR,
&UVERBS_METHOD(EFA_IB_METHOD_MR_QUERY));
+ADD_UVERBS_ATTRIBUTES_SIMPLE(
+ efa_comp_cntr_create,
+ UVERBS_OBJECT_COMP_CNTR,
+ UVERBS_METHOD_COMP_CNTR_CREATE,
+ UVERBS_ATTR_PTR_IN(
+ EFA_IB_ATTR_CREATE_COMP_CNTR_COMP_BUFFER,
+ UVERBS_ATTR_STRUCT(struct ib_uverbs_buffer_desc, length),
+ UA_MANDATORY),
+ UVERBS_ATTR_PTR_IN(
+ EFA_IB_ATTR_CREATE_COMP_CNTR_ERR_BUFFER,
+ UVERBS_ATTR_STRUCT(struct ib_uverbs_buffer_desc, length),
+ UA_MANDATORY));
+
const struct uapi_definition efa_uapi_defs[] = {
UAPI_DEF_CHAIN_OBJ_TREE(UVERBS_OBJECT_MR,
&efa_mr),
+ UAPI_DEF_CHAIN_OBJ_TREE(UVERBS_OBJECT_COMP_CNTR,
+ &efa_comp_cntr_create),
{},
};
diff --git a/include/uapi/rdma/efa-abi.h b/include/uapi/rdma/efa-abi.h
index d5c18f8de182..c79b54aade23 100644
--- a/include/uapi/rdma/efa-abi.h
+++ b/include/uapi/rdma/efa-abi.h
@@ -133,6 +133,7 @@ enum {
EFA_QUERY_DEVICE_CAPS_RDMA_WRITE = 1 << 5,
EFA_QUERY_DEVICE_CAPS_UNSOLICITED_WRITE_RECV = 1 << 6,
EFA_QUERY_DEVICE_CAPS_CQ_WITH_EXT_MEM = 1 << 7,
+ EFA_QUERY_DEVICE_CAPS_COMP_CNTR = 1 << 8,
};
struct efa_ibv_ex_query_device_resp {
@@ -163,4 +164,9 @@ enum efa_mr_methods {
EFA_IB_METHOD_MR_QUERY = (1U << UVERBS_ID_NS_SHIFT),
};
+enum efa_comp_cntr_create_attrs {
+ EFA_IB_ATTR_CREATE_COMP_CNTR_COMP_BUFFER = (1U << UVERBS_ID_NS_SHIFT),
+ EFA_IB_ATTR_CREATE_COMP_CNTR_ERR_BUFFER,
+};
+
#endif /* EFA_ABI_USER_H */
--
2.47.3
^ permalink raw reply related [flat|nested] 5+ messages in thread