cregit-Linux how code gets into the kernel

Release 4.11 drivers/sbus/char/openprom.c

/*
 * Linux/SPARC PROM Configuration Driver
 * Copyright (C) 1996 Thomas K. Dyas (tdyas@noc.rutgers.edu)
 * Copyright (C) 1996 Eddie C. Dost  (ecd@skynet.be)
 *
 * This character device driver allows user programs to access the
 * PROM device tree. It is compatible with the SunOS /dev/openprom
 * driver and the NetBSD /dev/openprom driver. The SunOS eeprom
 * utility works without any modifications.
 *
 * The driver uses a minor number under the misc device major. The
 * file read/write mode determines the type of access to the PROM.
 * Interrupts are disabled whenever the driver calls into the PROM for
 * sanity's sake.
 */

/* This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 
 */

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/slab.h>
#include <linux/mutex.h>
#include <linux/string.h>
#include <linux/miscdevice.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <asm/oplib.h>
#include <asm/prom.h>
#include <linux/uaccess.h>
#include <asm/openpromio.h>
#ifdef CONFIG_PCI
#include <linux/pci.h>
#endif

MODULE_AUTHOR("Thomas K. Dyas (tdyas@noc.rutgers.edu) and Eddie C. Dost  (ecd@skynet.be)");
MODULE_DESCRIPTION("OPENPROM Configuration Driver");
MODULE_LICENSE("GPL");
MODULE_VERSION("1.0");

MODULE_ALIAS_MISCDEV(SUN_OPENPROM_MINOR);

/* Private data kept by the driver for each descriptor. */

typedef struct openprom_private_data
{
	
struct device_node *current_node; /* Current node for SunOS ioctls. */
	
struct device_node *lastnode; /* Last valid node used by BSD ioctls. */
} 
DATA;

/* ID of the PROM node containing all of the EEPROM options. */
static DEFINE_MUTEX(openprom_mutex);

static struct device_node *options_node;

/*
 * Copy an openpromio structure into kernel space from user space.
 * This routine does error checking to make sure that all memory
 * accesses are within bounds. A pointer to the allocated openpromio
 * structure will be placed in "*opp_p". Return value is the length
 * of the user supplied buffer.
 */

static int copyin(struct openpromio __user *info, struct openpromio **opp_p) { unsigned int bufsize; if (!info || !opp_p) return -EFAULT; if (get_user(bufsize, &info->oprom_size)) return -EFAULT; if (bufsize == 0) return -EINVAL; /* If the bufsize is too large, just limit it. * Fix from Jason Rappleye. */ if (bufsize > OPROMMAXPARAM) bufsize = OPROMMAXPARAM; if (!(*opp_p = kzalloc(sizeof(int) + bufsize + 1, GFP_KERNEL))) return -ENOMEM; if (copy_from_user(&(*opp_p)->oprom_array, &info->oprom_array, bufsize)) { kfree(*opp_p); return -EFAULT; } return bufsize; }

Contributors

PersonTokensPropCommitsCommitProp
Linus Torvalds (pre-git)12997.73%350.00%
David S. Miller21.52%233.33%
Al Viro10.76%116.67%
Total132100.00%6100.00%


static int getstrings(struct openpromio __user *info, struct openpromio **opp_p) { int n, bufsize; char c; if (!info || !opp_p) return -EFAULT; if (!(*opp_p = kzalloc(sizeof(int) + OPROMMAXPARAM + 1, GFP_KERNEL))) return -ENOMEM; (*opp_p)->oprom_size = 0; n = bufsize = 0; while ((n < 2) && (bufsize < OPROMMAXPARAM)) { if (get_user(c, &info->oprom_array[bufsize])) { kfree(*opp_p); return -EFAULT; } if (c == '\0') n++; (*opp_p)->oprom_array[bufsize++] = c; } if (!n) { kfree(*opp_p); return -EINVAL; } return bufsize; }

Contributors

PersonTokensPropCommitsCommitProp
Linus Torvalds (pre-git)16298.78%133.33%
Al Viro10.61%133.33%
David S. Miller10.61%133.33%
Total164100.00%3100.00%

/* * Copy an openpromio structure in kernel space back to user space. */
static int copyout(void __user *info, struct openpromio *opp, int len) { if (copy_to_user(info, opp, len)) return -EFAULT; return 0; }

Contributors

PersonTokensPropCommitsCommitProp
Linus Torvalds (pre-git)3697.30%266.67%
Al Viro12.70%133.33%
Total37100.00%3100.00%


static int opromgetprop(void __user *argp, struct device_node *dp, struct openpromio *op, int bufsize) { const void *pval; int len; if (!dp || !(pval = of_get_property(dp, op->oprom_array, &len)) || len <= 0 || len > bufsize) return copyout(argp, op, sizeof(int)); memcpy(op->oprom_array, pval, len); op->oprom_array[len] = '\0'; op->oprom_size = len; return copyout(argp, op, sizeof(int) + bufsize); }

Contributors

PersonTokensPropCommitsCommitProp
Linus Torvalds (pre-git)7362.93%120.00%
David S. Miller3933.62%240.00%
Al Viro32.59%120.00%
Stephen Rothwell10.86%120.00%
Total116100.00%5100.00%


static int opromnxtprop(void __user *argp, struct device_node *dp, struct openpromio *op, int bufsize) { struct property *prop; int len; if (!dp) return copyout(argp, op, sizeof(int)); if (op->oprom_array[0] == '\0') { prop = dp->properties; if (!prop) return copyout(argp, op, sizeof(int)); len = strlen(prop->name); } else { prop = of_find_property(dp, op->oprom_array, NULL); if (!prop || !prop->next || (len = strlen(prop->next->name)) + 1 > bufsize) return copyout(argp, op, sizeof(int)); prop = prop->next; } memcpy(op->oprom_array, prop->name, len); op->oprom_array[len] = '\0'; op->oprom_size = ++len; return copyout(argp, op, sizeof(int) + bufsize); }

Contributors

PersonTokensPropCommitsCommitProp
David S. Miller14270.30%250.00%
Linus Torvalds (pre-git)5828.71%125.00%
Al Viro20.99%125.00%
Total202100.00%4100.00%


static int opromsetopt(struct device_node *dp, struct openpromio *op, int bufsize) { char *buf = op->oprom_array + strlen(op->oprom_array) + 1; int len = op->oprom_array + bufsize - buf; return of_set_property(options_node, op->oprom_array, buf, len); }

Contributors

PersonTokensPropCommitsCommitProp
David S. Miller3354.10%150.00%
Linus Torvalds (pre-git)2845.90%150.00%
Total61100.00%2100.00%


static int opromnext(void __user *argp, unsigned int cmd, struct device_node *dp, struct openpromio *op, int bufsize, DATA *data) { phandle ph; BUILD_BUG_ON(sizeof(phandle) != sizeof(int)); if (bufsize < sizeof(phandle)) return -EINVAL; ph = *((int *) op->oprom_array); if (ph) { dp = of_find_node_by_phandle(ph); if (!dp) return -EINVAL; switch (cmd) { case OPROMNEXT: dp = dp->sibling; break; case OPROMCHILD: dp = dp->child; break; case OPROMSETCUR: default: break; } } else { /* Sibling of node zero is the root node. */ if (cmd != OPROMNEXT) return -EINVAL; dp = of_find_node_by_path("/"); } ph = 0; if (dp) ph = dp->phandle; data->current_node = dp; *((int *) op->oprom_array) = ph; op->oprom_size = sizeof(phandle); return copyout(argp, op, bufsize + sizeof(int)); }

Contributors

PersonTokensPropCommitsCommitProp
David S. Miller13364.88%120.00%
Linus Torvalds (pre-git)7034.15%240.00%
Grant C. Likely10.49%120.00%
Al Viro10.49%120.00%
Total205100.00%5100.00%


static int oprompci2node(void __user *argp, struct device_node *dp, struct openpromio *op, int bufsize, DATA *data) { int err = -EINVAL; if (bufsize >= 2*sizeof(int)) { #ifdef CONFIG_PCI struct pci_dev *pdev; struct device_node *dp; pdev = pci_get_bus_and_slot (((int *) op->oprom_array)[0], ((int *) op->oprom_array)[1]); dp = pci_device_to_OF_node(pdev); data->current_node = dp; *((int *)op->oprom_array) = dp->phandle; op->oprom_size = sizeof(int); err = copyout(argp, op, bufsize + sizeof(int)); pci_dev_put(pdev); #endif } return err; }

Contributors

PersonTokensPropCommitsCommitProp
David S. Miller9259.74%350.00%
Linus Torvalds (pre-git)5535.71%116.67%
Alan Cox63.90%116.67%
Grant C. Likely10.65%116.67%
Total154100.00%6100.00%


static int oprompath2node(void __user *argp, struct device_node *dp, struct openpromio *op, int bufsize, DATA *data) { phandle ph = 0; dp = of_find_node_by_path(op->oprom_array); if (dp) ph = dp->phandle; data->current_node = dp; *((int *)op->oprom_array) = ph; op->oprom_size = sizeof(int); return copyout(argp, op, bufsize + sizeof(int)); }

Contributors

PersonTokensPropCommitsCommitProp
David S. Miller7882.11%250.00%
Linus Torvalds (pre-git)1616.84%125.00%
Grant C. Likely11.05%125.00%
Total95100.00%4100.00%


static int opromgetbootargs(void __user *argp, struct openpromio *op, int bufsize) { char *buf = saved_command_line; int len = strlen(buf); if (len > bufsize) return -EINVAL; strcpy(op->oprom_array, buf); op->oprom_size = len; return copyout(argp, op, bufsize + sizeof(int)); }

Contributors

PersonTokensPropCommitsCommitProp
David S. Miller6690.41%150.00%
Linus Torvalds (pre-git)79.59%150.00%
Total73100.00%2100.00%

/* * SunOS and Solaris /dev/openprom ioctl calls. */
static long openprom_sunos_ioctl(struct file * file, unsigned int cmd, unsigned long arg, struct device_node *dp) { DATA *data = file->private_data; struct openpromio *opp = NULL; int bufsize, error = 0; static int cnt; void __user *argp = (void __user *)arg; if (cmd == OPROMSETOPT) bufsize = getstrings(argp, &opp); else bufsize = copyin(argp, &opp); if (bufsize < 0) return bufsize; mutex_lock(&openprom_mutex); switch (cmd) { case OPROMGETOPT: case OPROMGETPROP: error = opromgetprop(argp, dp, opp, bufsize); break; case OPROMNXTOPT: case OPROMNXTPROP: error = opromnxtprop(argp, dp, opp, bufsize); break; case OPROMSETOPT: case OPROMSETOPT2: error = opromsetopt(dp, opp, bufsize); break; case OPROMNEXT: case OPROMCHILD: case OPROMSETCUR: error = opromnext(argp, cmd, dp, opp, bufsize, data); break; case OPROMPCI2NODE: error = oprompci2node(argp, dp, opp, bufsize, data); break; case OPROMPATH2NODE: error = oprompath2node(argp, dp, opp, bufsize, data); break; case OPROMGETBOOTARGS: error = opromgetbootargs(argp, opp, bufsize); break; case OPROMU2P: case OPROMGETCONS: case OPROMGETFBNAME: if (cnt++ < 10) printk(KERN_INFO "openprom_sunos_ioctl: unimplemented ioctl\n"); error = -EINVAL; break; default: if (cnt++ < 10) printk(KERN_INFO "openprom_sunos_ioctl: cmd 0x%X, arg 0x%lX\n", cmd, arg); error = -EINVAL; break; } kfree(opp); mutex_unlock(&openprom_mutex); return error; }

Contributors

PersonTokensPropCommitsCommitProp
David S. Miller18558.92%228.57%
Linus Torvalds (pre-git)11335.99%228.57%
Arnd Bergmann134.14%228.57%
Al Viro30.96%114.29%
Total314100.00%7100.00%


static struct device_node *get_node(phandle n, DATA *data) { struct device_node *dp = of_find_node_by_phandle(n); if (dp) data->lastnode = dp; return dp; }

Contributors

PersonTokensPropCommitsCommitProp
Linus Torvalds (pre-git)2155.26%150.00%
David S. Miller1744.74%150.00%
Total38100.00%2100.00%

/* Copy in a whole string from userspace into kernelspace. */
static char * copyin_string(char __user *user, size_t len) { if ((ssize_t)len < 0 || (ssize_t)(len + 1) < 0) return ERR_PTR(-EINVAL); return memdup_user_nul(user, len); }

Contributors

PersonTokensPropCommitsCommitProp
David S. Miller2448.00%120.00%
Linus Torvalds (pre-git)1632.00%120.00%
Sam Ravnborg612.00%120.00%
Al Viro48.00%240.00%
Total50100.00%5100.00%

/* * NetBSD /dev/openprom ioctl calls. */
static int opiocget(void __user *argp, DATA *data) { struct opiocdesc op; struct device_node *dp; char *str; const void *pval; int err, len; if (copy_from_user(&op, argp, sizeof(op))) return -EFAULT; dp = get_node(op.op_nodeid, data); str = copyin_string(op.op_name, op.op_namelen); if (IS_ERR(str)) return PTR_ERR(str); pval = of_get_property(dp, str, &len); err = 0; if (!pval || len > op.op_buflen) { err = -EINVAL; } else { op.op_buflen = len; if (copy_to_user(argp, &op, sizeof(op)) || copy_to_user(op.op_buf, pval, len)) err = -EFAULT; } kfree(str); return err; }

Contributors

PersonTokensPropCommitsCommitProp
Linus Torvalds (pre-git)9855.68%440.00%
David S. Miller4525.57%110.00%
Martin Habets105.68%110.00%
Sam Ravnborg95.11%110.00%
Rusty Russell73.98%110.00%
Al Viro63.41%110.00%
Stephen Rothwell10.57%110.00%
Total176100.00%10100.00%


static int opiocnextprop(void __user *argp, DATA *data) { struct opiocdesc op; struct device_node *dp; struct property *prop; char *str; int len; if (copy_from_user(&op, argp, sizeof(op))) return -EFAULT; dp = get_node(op.op_nodeid, data); if (!dp) return -EINVAL; str = copyin_string(op.op_name, op.op_namelen); if (IS_ERR(str)) return PTR_ERR(str); if (str[0] == '\0') { prop = dp->properties; } else { prop = of_find_property(dp, str, NULL); if (prop) prop = prop->next; } kfree(str); if (!prop) len = 0; else len = prop->length; if (len > op.op_buflen) len = op.op_buflen; if (copy_to_user(argp, &op, sizeof(op))) return -EFAULT; if (len && copy_to_user(op.op_buf, prop->value, len)) return -EFAULT; return 0; }

Contributors

PersonTokensPropCommitsCommitProp
David S. Miller10447.27%114.29%
Linus Torvalds (pre-git)9744.09%342.86%
Sam Ravnborg94.09%114.29%
Jesper Juhl83.64%114.29%
Al Viro20.91%114.29%
Total220100.00%7100.00%


static int opiocset(void __user *argp, DATA *data) { struct opiocdesc op; struct device_node *dp; char *str, *tmp; int err; if (copy_from_user(&op, argp, sizeof(op))) return -EFAULT; dp = get_node(op.op_nodeid, data); if (!dp) return -EINVAL; str = copyin_string(op.op_name, op.op_namelen); if (IS_ERR(str)) return PTR_ERR(str); tmp = copyin_string(op.op_buf, op.op_buflen); if (IS_ERR(tmp)) { kfree(str); return PTR_ERR(tmp); } err = of_set_property(dp, str, tmp, op.op_buflen); kfree(str); kfree(tmp); return err; }

Contributors

PersonTokensPropCommitsCommitProp
Linus Torvalds (pre-git)8351.88%240.00%
David S. Miller5735.62%120.00%
Sam Ravnborg1811.25%120.00%
Al Viro21.25%120.00%
Total160100.00%5100.00%


static int opiocgetnext(unsigned int cmd, void __user *argp) { struct device_node *dp; phandle nd; BUILD_BUG_ON(sizeof(phandle) != sizeof(int)); if (copy_from_user(&nd, argp, sizeof(phandle))) return -EFAULT; if (nd == 0) { if (cmd != OPIOCGETNEXT) return -EINVAL; dp = of_find_node_by_path("/"); } else { dp = of_find_node_by_phandle(nd); nd = 0; if (dp) { if (cmd == OPIOCGETNEXT) dp = dp->sibling; else dp = dp->child; } } if (dp) nd = dp->phandle; if (copy_to_user(argp, &nd, sizeof(phandle))) return -EFAULT; return 0; }

Contributors

PersonTokensPropCommitsCommitProp
David S. Miller11475.50%120.00%
Linus Torvalds (pre-git)3523.18%240.00%
Al Viro10.66%120.00%
Grant C. Likely10.66%120.00%
Total151100.00%5100.00%


static int openprom_bsd_ioctl(struct file * file, unsigned int cmd, unsigned long arg) { DATA *data = file->private_data; void __user *argp = (void __user *)arg; int err; mutex_lock(&openprom_mutex); switch (cmd) { case OPIOCGET: err = opiocget(argp, data); break; case OPIOCNEXTPROP: err = opiocnextprop(argp, data); break; case OPIOCSET: err = opiocset(argp, data); break; case OPIOCGETOPTNODE: BUILD_BUG_ON(sizeof(phandle) != sizeof(int)); err = 0; if (copy_to_user(argp, &options_node->phandle, sizeof(phandle))) err = -EFAULT; break; case OPIOCGETNEXT: case OPIOCGETCHILD: err = opiocgetnext(cmd, argp); break; default: err = -EINVAL; break; } mutex_unlock(&openprom_mutex); return err; }

Contributors

PersonTokensPropCommitsCommitProp
David S. Miller10663.10%114.29%
Linus Torvalds (pre-git)3520.83%228.57%
Arnd Bergmann2414.29%228.57%
Al Viro21.19%114.29%
Grant C. Likely10.60%114.29%
Total168100.00%7100.00%

/* * Handoff control to the correct ioctl handler. */
static long openprom_ioctl(struct file * file, unsigned int cmd, unsigned long arg) { DATA *data = file->private_data; switch (cmd) { case OPROMGETOPT: case OPROMNXTOPT: if ((file->f_mode & FMODE_READ) == 0) return -EPERM; return openprom_sunos_ioctl(file, cmd, arg, options_node); case OPROMSETOPT: case OPROMSETOPT2: if ((file->f_mode & FMODE_WRITE) == 0) return -EPERM; return openprom_sunos_ioctl(file, cmd, arg, options_node); case OPROMNEXT: case OPROMCHILD: case OPROMGETPROP: case OPROMNXTPROP: if ((file->f_mode & FMODE_READ) == 0) return -EPERM; return openprom_sunos_ioctl(file, cmd, arg, data->current_node); case OPROMU2P: case OPROMGETCONS: case OPROMGETFBNAME: case OPROMGETBOOTARGS: case OPROMSETCUR: case OPROMPCI2NODE: case OPROMPATH2NODE: if ((file->f_mode & FMODE_READ) == 0) return -EPERM; return openprom_sunos_ioctl(file, cmd, arg, NULL); case OPIOCGET: case OPIOCNEXTPROP: case OPIOCGETOPTNODE: case OPIOCGETNEXT: case OPIOCGETCHILD: if ((file->f_mode & FMODE_READ) == 0) return -EBADF; return openprom_bsd_ioctl(file,cmd,arg); case OPIOCSET: if ((file->f_mode & FMODE_WRITE) == 0) return -EBADF; return openprom_bsd_ioctl(file,cmd,arg); default: return -EINVAL; }; }

Contributors

PersonTokensPropCommitsCommitProp
Linus Torvalds (pre-git)26598.88%240.00%
Arnd Bergmann10.37%120.00%
David S. Miller10.37%120.00%
Al Viro10.37%120.00%
Total268100.00%5100.00%


static long openprom_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg) { long rval = -ENOTTY; /* * SunOS/Solaris only, the NetBSD one's have embedded pointers in * the arg which we'd need to clean up... */ switch (cmd) { case OPROMGETOPT: case OPROMSETOPT: case OPROMNXTOPT: case OPROMSETOPT2: case OPROMNEXT: case OPROMCHILD: case OPROMGETPROP: case OPROMNXTPROP: case OPROMU2P: case OPROMGETCONS: case OPROMGETFBNAME: case OPROMGETBOOTARGS: case OPROMSETCUR: case OPROMPCI2NODE: case OPROMPATH2NODE: rval = openprom_ioctl(file, cmd, arg); break; } return rval; }

Contributors

PersonTokensPropCommitsCommitProp
Christoph Hellwig8996.74%150.00%
David S. Miller33.26%150.00%
Total92100.00%2100.00%


static int openprom_open(struct inode * inode, struct file * file) { DATA *data; data = kmalloc(sizeof(DATA), GFP_KERNEL); if (!data) return -ENOMEM; mutex_lock(&openprom_mutex); data->current_node = of_find_node_by_path("/"); data->lastnode = data->current_node; file->private_data = (void *) data; mutex_unlock(&openprom_mutex); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
Linus Torvalds (pre-git)6477.11%125.00%
Arnd Bergmann1214.46%250.00%
David S. Miller78.43%125.00%
Total83100.00%4100.00%


static int openprom_release(struct inode * inode, struct file * file) { kfree(file->private_data); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
Linus Torvalds (pre-git)26100.00%3100.00%
Total26100.00%3100.00%

static const struct file_operations openprom_fops = { .owner = THIS_MODULE, .llseek = no_llseek, .unlocked_ioctl = openprom_ioctl, .compat_ioctl = openprom_compat_ioctl, .open = openprom_open, .release = openprom_release, }; static struct miscdevice openprom_dev = { .minor = SUN_OPENPROM_MINOR, .name = "openprom", .fops = &openprom_fops, };
static int __init openprom_init(void) { struct device_node *dp; int err; err = misc_register(&openprom_dev); if (err) return err; dp = of_find_node_by_path("/"); dp = dp->child; while (dp) { if (!strcmp(dp->name, "options")) break; dp = dp->sibling; } options_node = dp; if (!options_node) { misc_deregister(&openprom_dev); return -EIO; } return 0; }

Contributors

PersonTokensPropCommitsCommitProp
Linus Torvalds (pre-git)5255.32%480.00%
David S. Miller4244.68%120.00%
Total94100.00%5100.00%


static void __exit openprom_cleanup(void) { misc_deregister(&openprom_dev); }

Contributors

PersonTokensPropCommitsCommitProp
Linus Torvalds (pre-git)15100.00%3100.00%
Total15100.00%3100.00%

module_init(openprom_init); module_exit(openprom_cleanup);

Overall Contributors

PersonTokensPropCommitsCommitProp
Linus Torvalds (pre-git)165650.52%1229.27%
David S. Miller134040.88%819.51%
Christoph Hellwig912.78%12.44%
Arnd Bergmann601.83%37.32%
Sam Ravnborg421.28%12.44%
Al Viro300.92%37.32%
Rusty Russell170.52%24.88%
Martin Habets100.31%12.44%
Jesper Juhl80.24%12.44%
Alan Cox60.18%12.44%
Scott James Remnant50.15%12.44%
Grant C. Likely50.15%12.44%
Linus Torvalds30.09%37.32%
Pete Zaitcev20.06%12.44%
Stephen Rothwell20.06%12.44%
Arjan van de Ven10.03%12.44%
Total3278100.00%41100.00%
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with cregit.