linux-imx

// SPDX-License-Identifier: GPL-2.0-only

/*

 * linux/drivers/char/raw.c

 *

 * Front-end raw character devices.  These can be bound to any block

 * devices to provide genuine Unix raw character device semantics.

 *

 * We reserve minor number 0 for a control interface.  ioctl()s on this

 * device are used to bind the other minor numbers to block devices.

 */

​

#include <linux/init.h>

#include <linux/fs.h>

#include <linux/major.h>

#include <linux/blkdev.h>

#include <linux/backing-dev.h>

#include <linux/module.h>

#include <linux/raw.h>

#include <linux/capability.h>

#include <linux/uio.h>

#include <linux/cdev.h>

#include <linux/device.h>

#include <linux/mutex.h>

#include <linux/gfp.h>

#include <linux/compat.h>

#include <linux/vmalloc.h>

​

#include <linux/uaccess.h>

​

struct raw_device_data {

    struct block_device *binding;

    int inuse;

};

​

static struct class *raw_class;

static struct raw_device_data *raw_devices;

static DEFINE_MUTEX(raw_mutex);

static const struct file_operations raw_ctl_fops; /* forward declaration */

​

static int max_raw_minors = MAX_RAW_MINORS;

​

module_param(max_raw_minors, int, 0);

MODULE_PARM_DESC(max_raw_minors, "Maximum number of raw devices (1-65536)");

​

/*

 * Open/close code for raw IO.

 *

 * We just rewrite the i_mapping for the /dev/raw/rawN file descriptor to

 * point at the blockdev's address_space and set the file handle to use

 * O_DIRECT.

 *

 * Set the device's soft blocksize to the minimum possible.  This gives the

 * finest possible alignment and has no adverse impact on performance.

 */

static int raw_open(struct inode *inode, struct file *filp)

{

    const int minor = iminor(inode);

    struct block_device *bdev;

    int err;

​

    if (minor == 0) {   /* It is the control device */

        filp->f_op = &raw_ctl_fops;

        return 0;

    }

​

    mutex_lock(&raw_mutex);

​

    /*

     * All we need to do on open is check that the device is bound.

     */

    bdev = raw_devices[minor].binding;

    err = -ENODEV;

    if (!bdev)

        goto out;

    bdgrab(bdev);

    err = blkdev_get(bdev, filp->f_mode | FMODE_EXCL, raw_open);

    if (err)

        goto out;

    err = set_blocksize(bdev, bdev_logical_block_size(bdev));

    if (err)

        goto out1;

    filp->f_flags |= O_DIRECT;

    filp->f_mapping = bdev->bd_inode->i_mapping;

    if (++raw_devices[minor].inuse == 1)

        file_inode(filp)->i_mapping =

            bdev->bd_inode->i_mapping;

    filp->private_data = bdev;

    mutex_unlock(&raw_mutex);

    return 0;

​

out1:

    blkdev_put(bdev, filp->f_mode | FMODE_EXCL);