lkml.org 
[lkml]   [2019]   [Mar]   [19]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    /
    From
    Date
    SubjectRe: [PATCH 04/12] misc: xilinx_sdfec: Add open, close and ioctl
    On Tue, Mar 19, 2019 at 1:05 PM Dragan Cvetic <dragan.cvetic@xilinx.com> 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

    \
     
     \ /
      Last update: 2019-03-19 14:19    [W:2.791 / U:0.252 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site