Re: [PATCH v3 1/2] cxl: Add mechanism for delivering AFU driver specific events

On Mar 9, 2016, at 8:37 AM, Vaibhav Jain [off-list ref] =

wrote:

quoted

+/*
+ * AFU driver ops allows an AFU driver to create their own events to =

pass to

quoted

+ * userspace through the file descriptor as a simpler alternative to =

overriding

quoted

+ * the read() and poll() calls that works with the generic cxl =

events. These

quoted

+ * events are given priority over the generic cxl events, so they =

will be

quoted

+ * delivered first if multiple types of events are pending.
+ *
+ * event_pending() will be called by the cxl driver to check if an =

event is

quoted

+ * pending (e.g. in select/poll/read calls).
+ *
+ * deliver_event() will be called to fill out a cxl_event structure =

with the

quoted

+ * driver specific event. The header will already have the type and
+ * process_element fields filled in, and header.size will be set to
+ * sizeof(struct cxl_event_header). The AFU driver can extend that =

size up to

quoted

+ * max_size (if an afu driver requires more space, they should =

submit a patch

quoted

+ * increasing the size in the struct cxl_event_afu_driver_reserved =

definition).

quoted

+ *
+ * Both of these calls are made with a spin lock held, so they must =

not sleep.

quoted

+ */
+struct cxl_afu_driver_ops {
+	bool (*event_pending) (struct cxl_context *ctx);
+	void (*deliver_event) (struct cxl_context *ctx,
+			struct cxl_event *event, size_t max_size);
+};
+

=20
I would propose these two apis.
=20
/*
*  fetches an event from the driver event queue. NULL means that queue
*  is empty. Can sleep if needed. The memory for cxl_event is =

allocated

*  by module being called. Hence it can be potentially be larger then
*  sizeof(struct cxl_event). Multiple calls to this should return same
*  pointer untill ack_event is called.
*/
struct cxl_event * fetch_event(struct cxl_context * ctx);
=20
/*
* Returns and acknowledge the struct cxl_event * back to the driver
* which can then free it or maybe put it back in a kmem_cache. This
* should be called once we have completely returned the current
* struct cxl_event from the readcall
*/
void ack_event(struct cxl_context * ctx, struct cxl_event *);
=20
I think above apis would give us more flexbility in the future when
drivers would want to send larger events without breaking the abi.

=46rom a cxlflash perspective, I think we'd be fine with this model as
long as the driver events are still prioritized. I do like the removal =
of
the no-sleep requirement and this would allow us to simply hand off
an already populated event reference.