#define INCLUDE_VERMAGIC

#include <linux/build-salt.h>

#include <linux/cdev.h>

#include <linux/compiler.h>

#include <linux/cred.h> /* current_uid(), current_euid() */

#include <linux/errno.h> /* error codes */

#include <linux/fcntl.h>

#include <linux/fs.h>

#include <linux/init.h>

#include <linux/ioctl.h> /* needed for the _IOW etc stuff used later */

#include <linux/kernel.h> /* printk() */

#include <linux/list.h>

#include <linux/module.h>

#include <linux/moduleparam.h>

#include <linux/poll.h>

#include <linux/proc_fs.h>

#include <linux/sched.h>

#include <linux/sched/signal.h>

#include <linux/seq_file.h>

#include <linux/slab.h> /* kmalloc() */

#include <linux/tty.h>

#include <linux/types.h> /* size_t */

#include <linux/uaccess.h> /* copy_*_user */

#include <linux/vermagic.h>

#include <linux/version.h>

#include <asm/uaccess.h>

#include <linux/atomic.h>

#if LINUX_VERSION_CODE < KERNEL_VERSION(5,0,0)

#define access_ok_wrapper(type,arg,cmd) \

access_ok(type, arg, cmd)

#define access_ok_wrapper(type,arg,cmd) \

access_ok(arg, cmd)

#if LINUX_VERSION_CODE < KERNEL_VERSION(5, 6, 0)

#define proc_ops_wrapper(fops, newname) (fops)

#define proc_ops_wrapper(fops, newname) \

({ \

static struct proc_ops newname; \

\

newname.proc_open = (fops)->open; \

newname.proc_read = (fops)->read; \

newname.proc_write = (fops)->write; \

newname.proc_release = (fops)->release; \

newname.proc_poll = (fops)->poll; \

newname.proc_ioctl = (fops)->unlocked_ioctl; \

newname.proc_mmap = (fops)->mmap; \

newname.proc_get_unmapped_area = (fops)->get_unmapped_area; \

newname.proc_lseek = (fops)->llseek; \

__add_proc_ops_compat_ioctl(&newname, fops); \

&newname; \

})

#ifdef CONFIG_COMPAT

#define __add_proc_ops_compat_ioctl(pops, fops) \

(pops)->proc_compat_ioctl = (fops)->compat_ioctl

#define __add_proc_ops_compat_ioctl(pops, fops)

#ifdef CONFIG_UNWINDER_ORC

#include <asm/orc_header.h>

ORC_HEADER;

#undef PDEBUG /* undef it, just in case */

#ifdef SCULL_DEBUG

# ifdef __KERNEL__

/* This one if debugging is on, and kernel space */

# define PDEBUG(fmt, args...) printk( KERN_DEBUG "scull: " fmt, ## args)

/* This one for user space */

# define PDEBUG(fmt, args...) fprintf(stderr, fmt, ## args)

# define PDEBUG(fmt, args...) /* not debugging: nothing */

#undef PDEBUGG

#define PDEBUGG(fmt, args...) /* nothing: it's a placeholder */

#ifndef SCULL_MAJOR

#define SCULL_MAJOR 0 /* dynamic major by default */

#ifndef SCULL_NR_DEVS

#define SCULL_NR_DEVS 4 /* scull0 through scull3 */

#ifndef SCULL_P_NR_DEVS

#define SCULL_P_NR_DEVS 4 /* scullpipe0 through scullpipe3 */

#ifndef SCULL_QUANTUM

#define SCULL_QUANTUM 4000

#ifndef SCULL_QSET

#define SCULL_QSET 1000

#ifndef SCULL_P_BUFFER

#define SCULL_P_BUFFER 4000

struct scull_qset {

void **data;

struct scull_qset *next;

};

struct scull_dev {

};

#define TYPE(minor) (((minor) >> 4) & 0xf) /* high nibble */

#define NUM(minor) ((minor) & 0xf) /* low nibble */

extern int scull_major; /* main.c */

extern int scull_nr_devs;

extern int scull_quantum;

extern int scull_qset;

extern int scull_p_buffer; /* pipe.c */

int scull_p_init(dev_t dev);

void scull_p_cleanup(void);

int scull_access_init(dev_t dev);

void scull_access_cleanup(void);

int scull_trim(struct scull_dev *dev);

ssize_t scull_read(struct file *filp, char __user *buf, size_t count,

loff_t *f_pos);

ssize_t scull_write(struct file *filp, const char __user *buf, size_t count,

loff_t *f_pos);

loff_t scull_llseek(struct file *filp, loff_t off, int whence);

long scull_ioctl(struct file *filp, unsigned int cmd, unsigned long arg);

#define SCULL_IOC_MAGIC 'k'

#define SCULL_IOCRESET _IO(SCULL_IOC_MAGIC, 0)

#define SCULL_IOCSQUANTUM _IOW(SCULL_IOC_MAGIC, 1, int)

#define SCULL_IOCSQSET _IOW(SCULL_IOC_MAGIC, 2, int)

#define SCULL_IOCTQUANTUM _IO(SCULL_IOC_MAGIC, 3)

#define SCULL_IOCTQSET _IO(SCULL_IOC_MAGIC, 4)

#define SCULL_IOCGQUANTUM _IOR(SCULL_IOC_MAGIC, 5, int)

#define SCULL_IOCGQSET _IOR(SCULL_IOC_MAGIC, 6, int)

#define SCULL_IOCQQUANTUM _IO(SCULL_IOC_MAGIC, 7)

#define SCULL_IOCQQSET _IO(SCULL_IOC_MAGIC, 8)

#define SCULL_IOCXQUANTUM _IOWR(SCULL_IOC_MAGIC, 9, int)

#define SCULL_IOCXQSET _IOWR(SCULL_IOC_MAGIC,10, int)

#define SCULL_IOCHQUANTUM _IO(SCULL_IOC_MAGIC, 11)

#define SCULL_IOCHQSET _IO(SCULL_IOC_MAGIC, 12)

#define SCULL_P_IOCTSIZE _IO(SCULL_IOC_MAGIC, 13)

#define SCULL_P_IOCQSIZE _IO(SCULL_IOC_MAGIC, 14)

#define SCULL_IOC_MAXNR 14

static dev_t scull_a_firstdev; /* Where our range begins */

static struct scull_dev scull_s_device;

static atomic_t scull_s_available = ATOMIC_INIT(1);

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

{

struct scull_dev *dev = &scull_s_device; /* device information */

if (!atomic_dec_and_test(&scull_s_available)) {

atomic_inc(&scull_s_available);

return -EBUSY; /* already open */

}

/* then, everything else is copied from the bare scull device */

if ((filp->f_flags & O_TRUNC))

scull_trim(dev);

filp->private_data = dev;

return 0; /* success */

}

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

{

atomic_inc(&scull_s_available); /* release the device */

return 0;

}

struct file_operations scull_sngl_fops = {

.owner = THIS_MODULE,

.llseek = scull_llseek,

.read = scull_read,

.write = scull_write,

.unlocked_ioctl = scull_ioctl,

.open = scull_s_open,

.release = scull_s_release,

};

static struct scull_dev scull_u_device;

static int scull_u_count; /* initialized to 0 by default */

static uid_t scull_u_owner; /* initialized to 0 by default */

static DEFINE_SPINLOCK(scull_u_lock);

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

{

struct scull_dev *dev = &scull_u_device; /* device information */

spin_lock(&scull_u_lock);

if (scull_u_count &&

(scull_u_owner != current_uid().val) && /* allow user */

(scull_u_owner != current_euid().val) && /* allow whoever did su */

!capable(CAP_DAC_OVERRIDE)) { /* still allow root */

spin_unlock(&scull_u_lock);

return -EBUSY; /* -EPERM would confuse the user */

}

if (scull_u_count == 0)

scull_u_owner = current_uid().val; /* grab it */

scull_u_count++;

spin_unlock(&scull_u_lock);

if ((filp->f_flags & O_TRUNC))

scull_trim(dev);

filp->private_data = dev;

return 0; /* success */

}

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

{

spin_lock(&scull_u_lock);

scull_u_count--; /* nothing else */

spin_unlock(&scull_u_lock);

return 0;

}

struct file_operations scull_user_fops = {

.owner = THIS_MODULE,

.llseek = scull_llseek,

.read = scull_read,

.write = scull_write,

.unlocked_ioctl = scull_ioctl,

.open = scull_u_open,

.release = scull_u_release,

};

static struct scull_dev scull_w_device;

static int scull_w_count; /* initialized to 0 by default */

static uid_t scull_w_owner; /* initialized to 0 by default */

static DECLARE_WAIT_QUEUE_HEAD(scull_w_wait);

static DEFINE_SPINLOCK(scull_w_lock);

static inline int scull_w_available(void)

{

return scull_w_count == 0 ||

scull_w_owner == current_uid().val ||

scull_w_owner == current_euid().val ||

capable(CAP_DAC_OVERRIDE);

}

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

{

struct scull_dev *dev = &scull_w_device; /* device information */

spin_lock(&scull_w_lock);

while (! scull_w_available()) {

spin_unlock(&scull_w_lock);

if (filp->f_flags & O_NONBLOCK) return -EAGAIN;

if (wait_event_interruptible (scull_w_wait, scull_w_available()))

return -ERESTARTSYS; /* tell the fs layer to handle it */

spin_lock(&scull_w_lock);

}

if (scull_w_count == 0)

scull_w_owner = current_uid().val; /* grab it */

scull_w_count++;

spin_unlock(&scull_w_lock);

/* then, everything else is copied from the bare scull device */

if ((filp->f_flags & O_TRUNC))

scull_trim(dev);

filp->private_data = dev;

return 0; /* success */

}

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

{

int temp;

spin_lock(&scull_w_lock);

scull_w_count--;

temp = scull_w_count;

spin_unlock(&scull_w_lock);

if (temp == 0)

wake_up_interruptible_sync(&scull_w_wait); /* awake other uid's */

return 0;

}

struct file_operations scull_wusr_fops = {

.owner = THIS_MODULE,

.llseek = scull_llseek,

.read = scull_read,

.write = scull_write,

.unlocked_ioctl = scull_ioctl,

.open = scull_w_open,

.release = scull_w_release,

};

struct scull_listitem {

};

static LIST_HEAD(scull_c_list);

static DEFINE_SPINLOCK(scull_c_lock);

static struct scull_dev scull_c_device;

static struct scull_dev *scull_c_lookfor_device(dev_t key)

{

struct scull_listitem *lptr;

list_for_each_entry(lptr, &scull_c_list, list) {

if (lptr->key == key)

return &(lptr->device);

}

/* not found */

lptr = kmalloc(sizeof(struct scull_listitem), GFP_KERNEL);

if (!lptr)

return NULL;

/* initialize the device */

memset(lptr, 0, sizeof(struct scull_listitem));

lptr->key = key;

scull_trim(&(lptr->device)); /* initialize it */

mutex_init(&lptr->device.lock);

/* place it in the list */

list_add(&lptr->list, &scull_c_list);

return &(lptr->device);

}

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

{

struct scull_dev *dev;

dev_t key;

if (!current->signal->tty) {

PDEBUG("Process \"%s\" has no ctl tty\n", current->comm);

return -EINVAL;

}

key = tty_devnum(current->signal->tty);

/* look for a scullc device in the list */

spin_lock(&scull_c_lock);

dev = scull_c_lookfor_device(key);

spin_unlock(&scull_c_lock);

if (!dev)

return -ENOMEM;

/* then, everything else is copied from the bare scull device */

if ((filp->f_flags & O_TRUNC))

scull_trim(dev);

filp->private_data = dev;

return 0; /* success */

}

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

{

/*

return 0;

}

struct file_operations scull_priv_fops = {

.owner = THIS_MODULE,

.llseek = scull_llseek,

.read = scull_read,

.write = scull_write,

.unlocked_ioctl = scull_ioctl,

.open = scull_c_open,

.release = scull_c_release,

};

static struct scull_adev_info {

} scull_access_devs[] = {

{ "scullsingle", &scull_s_device, &scull_sngl_fops },

{ "sculluid", &scull_u_device, &scull_user_fops },

{ "scullwuid", &scull_w_device, &scull_wusr_fops },

{ "scullpriv", &scull_c_device, &scull_priv_fops }

};

#define SCULL_N_ADEVS 4

static void scull_access_setup (dev_t devno, struct scull_adev_info *devinfo)

{

struct scull_dev *dev = devinfo->sculldev;

int err;

/* Initialize the device structure */

dev->quantum = scull_quantum;

dev->qset = scull_qset;

mutex_init(&dev->lock);

/* Do the cdev stuff. */

cdev_init(&dev->cdev, devinfo->fops);

kobject_set_name(&dev->cdev.kobj, devinfo->name);

dev->cdev.owner = THIS_MODULE;

err = cdev_add (&dev->cdev, devno, 1);

/* Fail gracefully if need be */

if (err) {

printk(KERN_NOTICE "Error %d adding %s\n", err, devinfo->name);

kobject_put(&dev->cdev.kobj);

} else

printk(KERN_NOTICE "%s registered at %x\n", devinfo->name, devno);

}

int scull_access_init(dev_t firstdev)

{

int result, i;

/* Get our number space */

result = register_chrdev_region (firstdev, SCULL_N_ADEVS, "sculla");

if (result < 0) {

printk(KERN_WARNING "sculla: device number registration failed\n");

return 0;

}

scull_a_firstdev = firstdev;

/* Set up each device. */

for (i = 0; i < SCULL_N_ADEVS; i++)

scull_access_setup (firstdev + i, scull_access_devs + i);

return SCULL_N_ADEVS;

}

void scull_access_cleanup(void)

{

struct scull_listitem *lptr, *next;

int i;

/* Clean up the static devs */

for (i = 0; i < SCULL_N_ADEVS; i++) {

struct scull_dev *dev = scull_access_devs[i].sculldev;

cdev_del(&dev->cdev);

scull_trim(scull_access_devs[i].sculldev);

}

/* And all the cloned devices */

list_for_each_entry_safe(lptr, next, &scull_c_list, list) {

list_del(&lptr->list);

scull_trim(&(lptr->device));

kfree(lptr);

}

/* Free up our number space */

unregister_chrdev_region(scull_a_firstdev, SCULL_N_ADEVS);

return;

}

int scull_major = SCULL_MAJOR;

int scull_minor = 0;

int scull_nr_devs = SCULL_NR_DEVS; /* number of bare scull devices */

int scull_quantum = SCULL_QUANTUM;

int scull_qset = SCULL_QSET;

module_param(scull_major, int, S_IRUGO);

module_param(scull_minor, int, S_IRUGO);

module_param(scull_nr_devs, int, S_IRUGO);

module_param(scull_quantum, int, S_IRUGO);

module_param(scull_qset, int, S_IRUGO);

struct scull_dev *scull_devices; /* allocated in scull_init_module */

int scull_trim(struct scull_dev *dev)

{

struct scull_qset *next, *dptr;

int qset = dev->qset; /* "dev" is not-null */

int i;

for (dptr = dev->data; dptr; dptr = next) { /* all the list items */

if (dptr->data) {

for (i = 0; i < qset; i++)

kfree(dptr->data[i]);

kfree(dptr->data);

dptr->data = NULL;

}

next = dptr->next;

kfree(dptr);

}

dev->size = 0;

dev->quantum = scull_quantum;

dev->qset = scull_qset;

dev->data = NULL;

return 0;

}

int scull_open(struct inode *inode, struct file *filp);

int scull_open(struct inode *inode, struct file *filp)

{

struct scull_dev *dev; /* device information */

dev = container_of(inode->i_cdev, struct scull_dev, cdev);

filp->private_data = dev; /* for other methods */

/* Trim to 0 the length of the device was open with truncation */

if ((filp->f_flags & O_TRUNC)) {

pr_info("write O_TRUNC\n");

if (mutex_lock_interruptible(&dev->lock))

return -ERESTARTSYS;

scull_trim(dev); /* ignore errors */

mutex_unlock(&dev->lock);

}

return 0; /* success */

}

struct scull_qset *scull_follow(struct scull_dev *dev, int n);

struct scull_qset *scull_follow(struct scull_dev *dev, int n)

{

struct scull_qset *qs = dev->data;

/* Allocate first qset explicitly if need be */

if (! qs) {

qs = dev->data = kmalloc(sizeof(struct scull_qset), GFP_KERNEL);

if (qs == NULL)

return NULL; /* Never mind */

memset(qs, 0, sizeof(struct scull_qset));

}

/* Then follow the list */

while (n--) {

if (!qs->next) {

qs->next = kmalloc(sizeof(struct scull_qset), GFP_KERNEL);

if (qs->next == NULL)

return NULL; /* Never mind */

memset(qs->next, 0, sizeof(struct scull_qset));

}

qs = qs->next;

continue;

}

return qs;

}

int scull_release(struct inode *inode, struct file *filp);

int scull_release(struct inode *inode, struct file *filp)

{

return 0;

}

ssize_t scull_read(struct file *filp, char __user *buf, size_t count,

loff_t *f_pos);

ssize_t scull_read(struct file *filp, char __user *buf, size_t count,

loff_t *f_pos)

{

struct scull_dev *dev = filp->private_data;

struct scull_qset *dptr; /* the first listitem */

int quantum = dev->quantum;

int qset = dev->qset;

int itemsize = quantum * qset; /* how many bytes in the listitem */

int item, s_pos, q_pos, rest;

ssize_t retval = 0;

if (mutex_lock_interruptible(&dev->lock))

return -ERESTARTSYS;

if (*f_pos >= dev->size)

goto out;

if (*f_pos + count > dev->size)

count = dev->size - *f_pos;

/* find listitem, qset index, and offset in the quantum */

item = (long)*f_pos / itemsize;

rest = (long)*f_pos % itemsize;

s_pos = rest / quantum;

q_pos = rest % quantum;

/* follow the list up to the right position (defined elsewhere) */

dptr = scull_follow(dev, item);

if (dptr == NULL || !dptr->data || ! dptr->data[s_pos])

goto out; /* don't fill holes */

/* read only up to the end of this quantum */

if (count > quantum - q_pos)

count = quantum - q_pos;

if (copy_to_user(buf, dptr->data[s_pos] + q_pos, count)) {

retval = -EFAULT;

goto out;

}

*f_pos += count;

retval = count;

out:

mutex_unlock(&dev->lock);

return retval;

}

ssize_t scull_write(struct file *filp, const char __user *buf, size_t count,

loff_t *f_pos);

ssize_t scull_write(struct file *filp, const char __user *buf, size_t count,

loff_t *f_pos)

{

struct scull_dev *dev = filp->private_data;

struct scull_qset *dptr;

int quantum = dev->quantum;

int qset = dev->qset;

int itemsize = quantum * qset;

int item, s_pos, q_pos, rest;

ssize_t retval = -ENOMEM; /* value used in "goto out" statements */

if (mutex_lock_interruptible(&dev->lock))

return -ERESTARTSYS;

/* find listitem, qset index and offset in the quantum */

item = (long)*f_pos / itemsize;

rest = (long)*f_pos % itemsize;

s_pos = rest / quantum;

q_pos = rest % quantum;

/* follow the list up to the right position */

dptr = scull_follow(dev, item);

if (dptr == NULL)

goto out;

if (!dptr->data) {

dptr->data = kmalloc(qset * sizeof(char *), GFP_KERNEL);

if (!dptr->data)

goto out;

memset(dptr->data, 0, qset * sizeof(char *));

}

if (!dptr->data[s_pos]) {

dptr->data[s_pos] = kmalloc(quantum, GFP_KERNEL);

if (!dptr->data[s_pos])

goto out;

}

/* write only up to the end of this quantum */

if (count > quantum - q_pos)

count = quantum - q_pos;

if (copy_from_user(dptr->data[s_pos]+q_pos, buf, count)) {

retval = -EFAULT;

goto out;

}

*f_pos += count;

retval = count;

/* update the size */

if (dev->size < *f_pos)

dev->size = *f_pos;

out:

mutex_unlock(&dev->lock);

return retval;

}

long scull_ioctl(struct file *filp, unsigned int cmd, unsigned long arg);

long scull_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)

{

int err = 0, tmp;

int retval = 0;

/*

if (_IOC_TYPE(cmd) != SCULL_IOC_MAGIC) return -ENOTTY;

if (_IOC_NR(cmd) > SCULL_IOC_MAXNR) return -ENOTTY;

/*

if (_IOC_DIR(cmd) & _IOC_READ)

err = !access_ok_wrapper(VERIFY_WRITE, (void __user *)arg, _IOC_SIZE(cmd));

else if (_IOC_DIR(cmd) & _IOC_WRITE)

err = !access_ok_wrapper(VERIFY_READ, (void __user *)arg, _IOC_SIZE(cmd));

if (err) return -EFAULT;

switch(cmd) {

case SCULL_IOCRESET:

scull_quantum = SCULL_QUANTUM;

scull_qset = SCULL_QSET;

break;

case SCULL_IOCSQUANTUM: /* Set: arg points to the value */

if (! capable (CAP_SYS_ADMIN))

return -EPERM;

retval = __get_user(scull_quantum, (int __user *)arg);

break;

case SCULL_IOCTQUANTUM: /* Tell: arg is the value */

if (! capable (CAP_SYS_ADMIN))

return -EPERM;

scull_quantum = arg;

break;

case SCULL_IOCGQUANTUM: /* Get: arg is pointer to result */

retval = __put_user(scull_quantum, (int __user *)arg);

break;

case SCULL_IOCQQUANTUM: /* Query: return it (it's positive) */

return scull_quantum;

case SCULL_IOCXQUANTUM: /* eXchange: use arg as pointer */

if (! capable (CAP_SYS_ADMIN))

return -EPERM;

tmp = scull_quantum;

retval = __get_user(scull_quantum, (int __user *)arg);

if (retval == 0)

retval = __put_user(tmp, (int __user *)arg);

break;

case SCULL_IOCHQUANTUM: /* sHift: like Tell + Query */

if (! capable (CAP_SYS_ADMIN))

return -EPERM;

tmp = scull_quantum;

scull_quantum = arg;

return tmp;

case SCULL_IOCSQSET:

if (! capable (CAP_SYS_ADMIN))

return -EPERM;

retval = __get_user(scull_qset, (int __user *)arg);

break;

case SCULL_IOCTQSET:

if (! capable (CAP_SYS_ADMIN))

return -EPERM;

scull_qset = arg;

break;

case SCULL_IOCGQSET:

retval = __put_user(scull_qset, (int __user *)arg);

break;

case SCULL_IOCQQSET:

return scull_qset;

case SCULL_IOCXQSET:

if (! capable (CAP_SYS_ADMIN))

return -EPERM;

tmp = scull_qset;

retval = __get_user(scull_qset, (int __user *)arg);

if (retval == 0)

retval = put_user(tmp, (int __user *)arg);

break;

case SCULL_IOCHQSET:

if (! capable (CAP_SYS_ADMIN))

return -EPERM;

tmp = scull_qset;

scull_qset = arg;

return tmp;

/*

case SCULL_P_IOCTSIZE:

scull_p_buffer = arg;

break;

case SCULL_P_IOCQSIZE:

return scull_p_buffer;

default: /* redundant, as cmd was checked against MAXNR */

return -ENOTTY;

}

return retval;

}

loff_t scull_llseek(struct file *filp, loff_t off, int whence);

loff_t scull_llseek(struct file *filp, loff_t off, int whence)

{

struct scull_dev *dev = filp->private_data;

loff_t newpos;

switch(whence) {

case 0: /* SEEK_SET */

newpos = off;

break;

case 1: /* SEEK_CUR */

newpos = filp->f_pos + off;

break;

case 2: /* SEEK_END */

newpos = dev->size + off;

break;

default: /* can't happen */

return -EINVAL;

}

if (newpos < 0) return -EINVAL;

filp->f_pos = newpos;

return newpos;

}

struct file_operations scull_fops = {

.owner = THIS_MODULE,

.llseek = scull_llseek,

.read = scull_read,

.write = scull_write,

.unlocked_ioctl = scull_ioctl,

.open = scull_open,

.release = scull_release,

};

#ifdef SCULL_DEBUG /* use proc only if debugging */