fwctl: FWCTL_INFO to return basic information about the device
authorJason Gunthorpe <jgg@nvidia.com>
Fri, 28 Feb 2025 00:26:31 +0000 (20:26 -0400)
committerJason Gunthorpe <jgg@nvidia.com>
Thu, 6 Mar 2025 19:13:13 +0000 (15:13 -0400)
Userspace will need to know some details about the fwctl interface being
used to locate the correct userspace code to communicate with the
kernel. Provide a simple device_type enum indicating what the kernel
driver is.

Allow the device to provide a device specific info struct that contains
any additional information that the driver may need to provide to
userspace.

Link: https://patch.msgid.link/r/3-v5-642aa0c94070+4447f-fwctl_jgg@nvidia.com
Reviewed-by: Jonathan Cameron <Jonathan.Cameron@huawei.com>
Reviewed-by: Dave Jiang <dave.jiang@intel.com>
Reviewed-by: Shannon Nelson <shannon.nelson@amd.com>
Tested-by: Dave Jiang <dave.jiang@intel.com>
Tested-by: Shannon Nelson <shannon.nelson@amd.com>
Signed-off-by: Jason Gunthorpe <jgg@nvidia.com>
drivers/fwctl/main.c
include/linux/fwctl.h
include/uapi/fwctl/fwctl.h

index 4bba6109712e4285f2205b80217de8436992f0b4..bd84c4e5b3b92e33a35b56c5d888def57d9f5bbb 100644 (file)
@@ -27,8 +27,62 @@ struct fwctl_ucmd {
        u32 user_size;
 };
 
+static int ucmd_respond(struct fwctl_ucmd *ucmd, size_t cmd_len)
+{
+       if (copy_to_user(ucmd->ubuffer, ucmd->cmd,
+                        min_t(size_t, ucmd->user_size, cmd_len)))
+               return -EFAULT;
+       return 0;
+}
+
+static int copy_to_user_zero_pad(void __user *to, const void *from,
+                                size_t from_len, size_t user_len)
+{
+       size_t copy_len;
+
+       copy_len = min(from_len, user_len);
+       if (copy_to_user(to, from, copy_len))
+               return -EFAULT;
+       if (copy_len < user_len) {
+               if (clear_user(to + copy_len, user_len - copy_len))
+                       return -EFAULT;
+       }
+       return 0;
+}
+
+static int fwctl_cmd_info(struct fwctl_ucmd *ucmd)
+{
+       struct fwctl_device *fwctl = ucmd->uctx->fwctl;
+       struct fwctl_info *cmd = ucmd->cmd;
+       size_t driver_info_len = 0;
+
+       if (cmd->flags)
+               return -EOPNOTSUPP;
+
+       if (!fwctl->ops->info && cmd->device_data_len) {
+               if (clear_user(u64_to_user_ptr(cmd->out_device_data),
+                              cmd->device_data_len))
+                       return -EFAULT;
+       } else if (cmd->device_data_len) {
+               void *driver_info __free(kfree) =
+                       fwctl->ops->info(ucmd->uctx, &driver_info_len);
+               if (IS_ERR(driver_info))
+                       return PTR_ERR(driver_info);
+
+               if (copy_to_user_zero_pad(u64_to_user_ptr(cmd->out_device_data),
+                                         driver_info, driver_info_len,
+                                         cmd->device_data_len))
+                       return -EFAULT;
+       }
+
+       cmd->out_device_type = fwctl->ops->device_type;
+       cmd->device_data_len = driver_info_len;
+       return ucmd_respond(ucmd, sizeof(*cmd));
+}
+
 /* On stack memory for the ioctl structs */
 union fwctl_ucmd_buffer {
+       struct fwctl_info info;
 };
 
 struct fwctl_ioctl_op {
@@ -48,6 +102,7 @@ struct fwctl_ioctl_op {
                .execute = _fn,                                             \
        }
 static const struct fwctl_ioctl_op fwctl_ioctl_ops[] = {
+       IOCTL_OP(FWCTL_INFO, fwctl_cmd_info, struct fwctl_info, out_device_data),
 };
 
 static long fwctl_fops_ioctl(struct file *filp, unsigned int cmd,
index faa4b2c780e0c69666a44f4cecb13086fa677cfe..700a5be940e365f1491c443f070d983561f9334f 100644 (file)
@@ -7,6 +7,7 @@
 #include <linux/device.h>
 #include <linux/cdev.h>
 #include <linux/cleanup.h>
+#include <uapi/fwctl/fwctl.h>
 
 struct fwctl_device;
 struct fwctl_uctx;
@@ -19,6 +20,10 @@ struct fwctl_uctx;
  * it will block device hot unplug and module unloading.
  */
 struct fwctl_ops {
+       /**
+        * @device_type: The drivers assigned device_type number. This is uABI.
+        */
+       enum fwctl_device_type device_type;
        /**
         * @uctx_size: The size of the fwctl_uctx struct to allocate. The first
         * bytes of this memory will be a fwctl_uctx. The driver can use the
@@ -35,6 +40,13 @@ struct fwctl_ops {
         * is closed.
         */
        void (*close_uctx)(struct fwctl_uctx *uctx);
+       /**
+        * @info: Implement FWCTL_INFO. Return a kmalloc() memory that is copied
+        * to out_device_data. On input length indicates the size of the user
+        * buffer on output it indicates the size of the memory. The driver can
+        * ignore length on input, the core code will handle everything.
+        */
+       void *(*info)(struct fwctl_uctx *uctx, size_t *length);
 };
 
 /**
index 8f5fe821cf286e586ee5375345737b11b4623626..4052df63f66dc681037bc30c2f73a22f273d9c02 100644 (file)
@@ -4,6 +4,9 @@
 #ifndef _UAPI_FWCTL_H
 #define _UAPI_FWCTL_H
 
+#include <linux/types.h>
+#include <linux/ioctl.h>
+
 #define FWCTL_TYPE 0x9A
 
 /**
  */
 enum {
        FWCTL_CMD_BASE = 0,
+       FWCTL_CMD_INFO = 0,
+};
+
+enum fwctl_device_type {
+       FWCTL_DEVICE_TYPE_ERROR = 0,
+};
+
+/**
+ * struct fwctl_info - ioctl(FWCTL_INFO)
+ * @size: sizeof(struct fwctl_info)
+ * @flags: Must be 0
+ * @out_device_type: Returns the type of the device from enum fwctl_device_type
+ * @device_data_len: On input the length of the out_device_data memory. On
+ *     output the size of the kernel's device_data which may be larger or
+ *     smaller than the input. Maybe 0 on input.
+ * @out_device_data: Pointer to a memory of device_data_len bytes. Kernel will
+ *     fill the entire memory, zeroing as required.
+ *
+ * Returns basic information about this fwctl instance, particularly what driver
+ * is being used to define the device_data format.
+ */
+struct fwctl_info {
+       __u32 size;
+       __u32 flags;
+       __u32 out_device_type;
+       __u32 device_data_len;
+       __aligned_u64 out_device_data;
 };
+#define FWCTL_INFO _IO(FWCTL_TYPE, FWCTL_CMD_INFO)
 
 #endif