Re: [PATCH 04/12] misc: xilinx_sdfec: Add open, close and ioctl

[Arnd Bergmann]

On Tue, Mar 19, 2019 at 1:05 PM Dragan Cvetic <dragan.cvetic@xxxxxxxxxx> wrote:
>
> Add char device interface per DT node present and support
> file operations:
> - open(), which keeps only one open per device at a time,
> - close(), which release the open for this device,
> - ioctl(), which provides infrastructure for a specific driver
> control.

>  drivers/misc/xilinx_sdfec.c      | 79 ++++++++++++++++++++++++++++++++++++++++
>  include/uapi/misc/xilinx_sdfec.h |  4 ++
>  2 files changed, 83 insertions(+)
>
> diff --git a/drivers/misc/xilinx_sdfec.c b/drivers/misc/xilinx_sdfec.c
> index a52a5c6..3407de4 100644
> --- a/drivers/misc/xilinx_sdfec.c
> +++ b/drivers/misc/xilinx_sdfec.c
> @@ -81,8 +81,87 @@ struct xsdfec_dev {
>         struct xsdfec_clks clks;
>  };
>
> +static int xsdfec_dev_open(struct inode *iptr, struct file *fptr)
> +{
> +       struct xsdfec_dev *xsdfec;
> +
> +       xsdfec = container_of(iptr->i_cdev, struct xsdfec_dev, xsdfec_cdev);
> +       if (!xsdfec)
> +               return -EAGAIN;

The result of container_of() will not be NULL here.
Did you mean to check i_cdev? That probably also won't
be NULL, but that check would be more reasonable.

> +       /* Only one open per device at a time */
> +       if (!atomic_dec_and_test(&xsdfec->open_count)) {
> +               atomic_inc(&xsdfec->open_count);
> +               return -EBUSY;
> +       }

What is that limitation for? Is it worse to open it twice than
to dup() or fork()?

Note that the test is not really atomic either: if three processes
try to open the file at the same time, it gets decremented from
1 to -2, so only the second one sees 0 and increments it back
to -1 afterwards...

> +static long xsdfec_dev_ioctl(struct file *fptr, unsigned int cmd,
> +                            unsigned long data)
> +{
> +       struct xsdfec_dev *xsdfec = fptr->private_data;
> +       void __user *arg = NULL;
> +       int rval = -EINVAL;
> +       int err = 0;
> +
> +       if (!xsdfec)
> +               return rval;
> +
> +       if (_IOC_TYPE(cmd) != XSDFEC_MAGIC) {
> +               dev_err(xsdfec->dev, "Not a xilinx sdfec ioctl");
> +               return -ENOTTY;
> +       }

remove the error messages here as well.

> +       /* Access check of the argument if present */
> +       if (_IOC_DIR(cmd) & _IOC_READ)
> +               err = !access_ok((void *)arg, _IOC_SIZE(cmd));
> +       else if (_IOC_DIR(cmd) & _IOC_WRITE)
> +               err = !access_ok((void *)arg, _IOC_SIZE(cmd));

This seems odd. Why two separate checks, and why the access_ok()
check when you do a copy_from_user() that contains the same check
later?

If you want to get fancy here, you could just copy the data in the main
ioctl handler based on _IOC_SIZE, and pass around normal kernel
pointers from there.

>  static const struct file_operations xsdfec_fops = {
>         .owner = THIS_MODULE,
> +       .open = xsdfec_dev_open,
> +       .release = xsdfec_dev_release,
> +       .unlocked_ioctl = xsdfec_dev_ioctl,
>  };

This lacks a .compat_ioctl pointer.

       Arnd