Home

File Index

All Tags

Tags by File

Tags referrers

Cross reference index

macro : DEFINE_PROC_SEQ_FILE

  File Line   Context
main.c210DEFINE_PROC_SEQ_FILE(scull_read_mem)
pipe.c290DEFINE_PROC_SEQ_FILE(scull_read_p_mem)

macro : LIMIT

  File Line   Context
pipe.c263        for(i = 0; i<scull_p_nr_devs && m->count <= LIMIT; i++) {

macro : PDEBUG

  File Line   Context
access.c266                PDEBUG("Process \"%s\" has no ctl tty\n", current->comm);
pipe.c129                PDEBUG("\"%s\" reading: going to sleep\n", current->comm);
pipe.c152        PDEBUG("\"%s\" did read %li bytes\n",current->comm, (long)count);
pipe.c166                PDEBUG("\"%s\" writing: going to sleep\n",current->comm);
pipe.c207        PDEBUG("Going to accept %li bytes to %p from %p\n", (long)count, dev->wp, buf);
pipe.c223        PDEBUG("\"%s\" did write %li bytes\n",current->comm, (long)count);
scull.h27#undef PDEBUG             /* undef it, just in case */

macro : PDEBUGG

  File Line   Context
scull.h40#undef PDEBUGG

macro : SCULL_IOCGQSET

  File Line   Context
main.c475          case SCULL_IOCGQSET:

macro : SCULL_IOCGQUANTUM

  File Line   Context
main.c440          case SCULL_IOCGQUANTUM: /* Get: arg is pointer to result */

macro : SCULL_IOCHQSET

  File Line   Context
main.c491          case SCULL_IOCHQSET:

macro : SCULL_IOCHQUANTUM

  File Line   Context
main.c456          case SCULL_IOCHQUANTUM: /* sHift: like Tell + Query */

macro : SCULL_IOCQQSET

  File Line   Context
main.c479          case SCULL_IOCQQSET:

macro : SCULL_IOCQQUANTUM

  File Line   Context
main.c444          case SCULL_IOCQQUANTUM: /* Query: return it (it's positive) */

macro : SCULL_IOCRESET

  File Line   Context
main.c423          case SCULL_IOCRESET:

macro : SCULL_IOCSQSET

  File Line   Context
main.c463          case SCULL_IOCSQSET:

macro : SCULL_IOCSQUANTUM

  File Line   Context
main.c428          case SCULL_IOCSQUANTUM: /* Set: arg points to the value */

macro : SCULL_IOCTQSET

  File Line   Context
main.c469          case SCULL_IOCTQSET:

macro : SCULL_IOCTQUANTUM

  File Line   Context
main.c434          case SCULL_IOCTQUANTUM: /* Tell: arg is the value */

macro : SCULL_IOCXQSET

  File Line   Context
main.c482          case SCULL_IOCXQSET:

macro : SCULL_IOCXQUANTUM

  File Line   Context
main.c447          case SCULL_IOCXQUANTUM: /* eXchange: use arg as pointer */

macro : SCULL_IOC_MAGIC

  File Line   Context
main.c406        if (_IOC_TYPE(cmd) != SCULL_IOC_MAGIC) return -ENOTTY;
scull.h143#define SCULL_IOCRESET    _IO(SCULL_IOC_MAGIC, 0)
scull.h153#define SCULL_IOCSQUANTUM _IOW(SCULL_IOC_MAGIC,  1, int)
scull.h154#define SCULL_IOCSQSET    _IOW(SCULL_IOC_MAGIC,  2, int)
scull.h155#define SCULL_IOCTQUANTUM _IO(SCULL_IOC_MAGIC,   3)
scull.h156#define SCULL_IOCTQSET    _IO(SCULL_IOC_MAGIC,   4)
scull.h157#define SCULL_IOCGQUANTUM _IOR(SCULL_IOC_MAGIC,  5, int)
scull.h158#define SCULL_IOCGQSET    _IOR(SCULL_IOC_MAGIC,  6, int)
scull.h159#define SCULL_IOCQQUANTUM _IO(SCULL_IOC_MAGIC,   7)
scull.h160#define SCULL_IOCQQSET    _IO(SCULL_IOC_MAGIC,   8)
scull.h161#define SCULL_IOCXQUANTUM _IOWR(SCULL_IOC_MAGIC, 9, int)
scull.h162#define SCULL_IOCXQSET    _IOWR(SCULL_IOC_MAGIC,10, int)
scull.h163#define SCULL_IOCHQUANTUM _IO(SCULL_IOC_MAGIC,  11)
scull.h164#define SCULL_IOCHQSET    _IO(SCULL_IOC_MAGIC,  12)
scull.h171#define SCULL_P_IOCTSIZE _IO(SCULL_IOC_MAGIC,   13)
scull.h172#define SCULL_P_IOCQSIZE _IO(SCULL_IOC_MAGIC,   14)

macro : SCULL_IOC_MAXNR

  File Line   Context
main.c407        if (_IOC_NR(cmd) > SCULL_IOC_MAXNR) return -ENOTTY;

macro : SCULL_MAJOR

  File Line   Context
main.c38int scull_major =   SCULL_MAJOR;
scull.h43#ifndef SCULL_MAJOR

macro : SCULL_NR_DEVS

  File Line   Context
main.c40int scull_nr_devs = SCULL_NR_DEVS;        /* number of bare scull devices */
scull.h47#ifndef SCULL_NR_DEVS

macro : SCULL_N_ADEVS

  File Line   Context
access.c355        result = register_chrdev_region (firstdev, SCULL_N_ADEVS, "sculla");
access.c363        for (i = 0; i < SCULL_N_ADEVS; i++)
access.c366        return SCULL_N_ADEVS;
access.c379        for (i = 0; i < SCULL_N_ADEVS; i++) {
access.c393        unregister_chrdev_region(scull_a_firstdev, SCULL_N_ADEVS);

macro : SCULL_P_BUFFER

  File Line   Context
pipe.c48int scull_p_buffer =  SCULL_P_BUFFER;        /* buffer size */
scull.h75#ifndef SCULL_P_BUFFER

macro : SCULL_P_IOCQSIZE

  File Line   Context
main.c508          case SCULL_P_IOCQSIZE:

macro : SCULL_P_IOCTSIZE

  File Line   Context
main.c504          case SCULL_P_IOCTSIZE:

macro : SCULL_P_NR_DEVS

  File Line   Context
pipe.c47static int scull_p_nr_devs = SCULL_P_NR_DEVS;        /* number of pipe devices */
scull.h51#ifndef SCULL_P_NR_DEVS

macro : SCULL_QSET

  File Line   Context
main.c425                scull_qset = SCULL_QSET;
main.c42int scull_qset =    SCULL_QSET;
scull.h62 * The array (quantum-set) is SCULL_QSET long.
scull.h68#ifndef SCULL_QSET

macro : SCULL_QUANTUM

  File Line   Context
main.c41int scull_quantum = SCULL_QUANTUM;
main.c424                scull_quantum = SCULL_QUANTUM;
scull.h60 * pointer refers to a memory area of SCULL_QUANTUM bytes.
scull.h64#ifndef SCULL_QUANTUM

macro : _SCULL_H_

  File Line   Context
scull.h177#endif /* _SCULL_H_ */
scull.h18#ifndef _SCULL_H_

variable : scull_a_firstdev

  File Line   Context
access.c360        scull_a_firstdev = firstdev;
access.c393        unregister_chrdev_region(scull_a_firstdev, SCULL_N_ADEVS);

function : scull_access_cleanup

  File Line   Context
main.c590        scull_access_cleanup();
scull.h122void    scull_access_cleanup(void);

variable : scull_access_devs

  File Line   Context
access.c364                scull_access_setup (firstdev + i, scull_access_devs + i);
access.c380                struct scull_dev *dev = scull_access_devs[i].sculldev;
access.c382                scull_trim(scull_access_devs[i].sculldev);

function : scull_access_init

  File Line   Context
main.c652        dev += scull_access_init(dev);
scull.h121int     scull_access_init(dev_t dev);

function : scull_access_setup

  File Line   Context
access.c364                scull_access_setup (firstdev + i, scull_access_devs + i);

struct : scull_adev_info

  File Line   Context
access.c326static void scull_access_setup (dev_t devno, struct scull_adev_info *devinfo)

variable : scull_c_device

  File Line   Context
access.c319        { "sullpriv", &scull_c_device, &scull_priv_fops }

function : scull_c_lookfor_device

  File Line   Context
access.c273        dev = scull_c_lookfor_device(key);

function : scull_c_open

  File Line   Context
access.c304        .open =     scull_c_open,

function : scull_c_release

  File Line   Context
access.c305        .release =  scull_c_release,

function : scull_cleanup_module

  File Line   Context
main.c660        scull_cleanup_module();

function : scull_create_proc

  File Line   Context
main.c655        scull_create_proc();

struct : scull_dev

  File Line   Context
access.c145static struct scull_dev scull_w_device;
access.c162        struct scull_dev *dev = &scull_w_device; /* device information */
access.c221        struct scull_dev device;
access.c231/* A placeholder scull_dev which really just holds the cdev stuff. */
access.c232static struct scull_dev scull_c_device;   
access.c235static struct scull_dev *scull_c_lookfor_device(dev_t key)
access.c262        struct scull_dev *dev;
access.c313        struct scull_dev *sculldev;
access.c328        struct scull_dev *dev = devinfo->sculldev;
access.c380                struct scull_dev *dev = scull_access_devs[i].sculldev;
access.c46static struct scull_dev scull_s_device;
access.c51        struct scull_dev *dev = &scull_s_device; /* device information */
access.c89static struct scull_dev scull_u_device;
access.c96        struct scull_dev *dev = &scull_u_device; /* device information */
main.c145        struct scull_dev *dev = (struct scull_dev *) v;
main.c145        struct scull_dev *dev = (struct scull_dev *) v;
main.c242        struct scull_dev *dev; /* device information */
main.c244        dev = container_of(inode->i_cdev, struct scull_dev, cdev);
main.c265struct scull_qset *scull_follow(struct scull_dev *dev, int n)
main.c296        struct scull_dev *dev = filp->private_data; 
main.c340        struct scull_dev *dev = filp->private_data;
main.c524        struct scull_dev *dev = filp->private_data;
main.c53struct scull_dev *scull_devices;        /* allocated in scull_init_module */
main.c596static void scull_setup_cdev(struct scull_dev *dev, int index)
main.c59int scull_trim(struct scull_dev *dev)
main.c635        scull_devices = kzalloc(scull_nr_devs * sizeof(struct scull_dev), GFP_KERNEL);
main.c92                struct scull_dev *d = &scull_devices[i];
scull.h124int     scull_trim(struct scull_dev *dev);

variable : scull_devices

  File Line   Context
main.c109                mutex_unlock(&scull_devices[i].mutex);
main.c127        return scull_devices + *pos;
main.c135        return scull_devices + *pos;
main.c152                        (int) (dev - scull_devices), dev->qset,
main.c573        if (scull_devices) {
main.c575                        scull_trim(scull_devices + i);
main.c576                        cdev_del(&scull_devices[i].cdev);
main.c578                kfree(scull_devices);
main.c635        scull_devices = kzalloc(scull_nr_devs * sizeof(struct scull_dev), GFP_KERNEL);
main.c636        if (!scull_devices) {
main.c643                scull_devices[i].quantum = scull_quantum;
main.c644                scull_devices[i].qset = scull_qset;
main.c645                mutex_init(&scull_devices[i].mutex);
main.c646                scull_setup_cdev(&scull_devices[i], i);
main.c92                struct scull_dev *d = &scull_devices[i];

function : scull_follow

  File Line   Context
main.c316        dptr = scull_follow(dev, item);
main.c357        dptr = scull_follow(dev, item);

variable : scull_fops

  File Line   Context
main.c600        cdev_init(&dev->cdev, &scull_fops);
main.c602        dev->cdev.ops = &scull_fops;

function : scull_getwritespace

  File Line   Context
pipe.c197        result = scull_getwritespace(dev, filp);
pipe.c199                return result; /* scull_getwritespace called mutex_unlock(&dev->mutex) */

function : scull_init_module

  File Line   Context
main.c53struct scull_dev *scull_devices;        /* allocated in scull_init_module */

function : scull_ioctl

  File Line   Context
access.c137        .unlocked_ioctl =      scull_ioctl,
access.c207        .unlocked_ioctl =      scull_ioctl,
access.c303        .unlocked_ioctl =    scull_ioctl,
access.c79        .unlocked_ioctl =              scull_ioctl,
main.c553        .unlocked_ioctl =    scull_ioctl,
pipe.c305        .unlocked_ioctl =        scull_ioctl,
scull.h131long     scull_ioctl(struct file *filp,

struct : scull_listitem

  File Line   Context
access.c237        struct scull_listitem *lptr;
access.c245        lptr = kzalloc(sizeof(struct scull_listitem), GFP_KERNEL);
access.c375        struct scull_listitem *lptr, *next;

function : scull_llseek

  File Line   Context
access.c134        .llseek =     scull_llseek,
access.c204        .llseek =     scull_llseek,
access.c300        .llseek =   scull_llseek,
access.c76        .llseek =             scull_llseek,
main.c550        .llseek =   scull_llseek,
scull.h130loff_t  scull_llseek(struct file *filp, loff_t off, int whence);

variable : scull_major

  File Line   Context
main.c44module_param(scull_major, int, S_IRUGO);
main.c570        dev_t devno = MKDEV(scull_major, scull_minor);
main.c598        int err, devno = MKDEV(scull_major, scull_minor + index);
main.c619        if (scull_major) {
main.c620                dev = MKDEV(scull_major, scull_minor);
main.c624                scull_major = MAJOR(dev);
main.c627                printk(KERN_WARNING "scull: can't get major %d\n", scull_major);
main.c650        dev = MKDEV(scull_major, scull_minor + scull_nr_devs);
scull.h107extern int scull_major;     /* main.c */

variable : scull_minor

  File Line   Context
main.c45module_param(scull_minor, int, S_IRUGO);
main.c570        dev_t devno = MKDEV(scull_major, scull_minor);
main.c598        int err, devno = MKDEV(scull_major, scull_minor + index);
main.c620                dev = MKDEV(scull_major, scull_minor);
main.c623                result = alloc_chrdev_region(&dev, scull_minor, scull_nr_devs, "scull");
main.c650        dev = MKDEV(scull_major, scull_minor + scull_nr_devs);

variable : scull_nr_devs

  File Line   Context
main.c125        if (*pos >= scull_nr_devs)
main.c133        if (*pos >= scull_nr_devs)
main.c46module_param(scull_nr_devs, int, S_IRUGO);
main.c574                for (i = 0; i < scull_nr_devs; i++) {
main.c586        unregister_chrdev_region(devno, scull_nr_devs);
main.c621                result = register_chrdev_region(dev, scull_nr_devs, "scull");
main.c623                result = alloc_chrdev_region(&dev, scull_minor, scull_nr_devs, "scull");
main.c635        scull_devices = kzalloc(scull_nr_devs * sizeof(struct scull_dev), GFP_KERNEL);
main.c642        for (i = 0; i < scull_nr_devs; i++) {
main.c650        dev = MKDEV(scull_major, scull_minor + scull_nr_devs);
main.c91        for (i = 0; i < scull_nr_devs && m->count <= limit; i++) {
scull.h108extern int scull_nr_devs;

function : scull_open

  File Line   Context
main.c554        .open =     scull_open,

variable : scull_p_buffer

  File Line   Context
main.c505                scull_p_buffer = arg;
main.c509                return scull_p_buffer;
pipe.c262        seq_printf(m, "Default buffersize is %i\n", scull_p_buffer);
pipe.c52module_param(scull_p_buffer, int, 0);
pipe.c74                dev->buffer = kzalloc(scull_p_buffer, GFP_KERNEL);
pipe.c80        dev->buffersize = scull_p_buffer;
scull.h112extern int scull_p_buffer;        /* pipe.c */

function : scull_p_cleanup

  File Line   Context
main.c589        scull_p_cleanup();
scull.h120void    scull_p_cleanup(void);

variable : scull_p_devices

  File Line   Context
pipe.c264                p = &scull_p_devices[i];
pipe.c339        scull_p_devices = kzalloc(scull_p_nr_devs * sizeof(struct scull_pipe), GFP_KERNEL);
pipe.c340        if (scull_p_devices == NULL) {
pipe.c345                init_waitqueue_head(&(scull_p_devices[i].inq));
pipe.c346                init_waitqueue_head(&(scull_p_devices[i].outq));
pipe.c347                mutex_init(&scull_p_devices[i].mutex);
pipe.c348                scull_p_setup_cdev(scull_p_devices + i, i);
pipe.c368        if (!scull_p_devices)
pipe.c372                cdev_del(&scull_p_devices[i].cdev);
pipe.c373                kfree(scull_p_devices[i].buffer);
pipe.c375        kfree(scull_p_devices);
pipe.c377        scull_p_devices = NULL; /* pedantic */

variable : scull_p_devno

  File Line   Context
pipe.c316        int err, devno = scull_p_devno + index;
pipe.c338        scull_p_devno = firstdev;
pipe.c376        unregister_chrdev_region(scull_p_devno, scull_p_nr_devs);

function : scull_p_fasync

  File Line   Context
pipe.c308        .fasync =        scull_p_fasync,
pipe.c56static int scull_p_fasync(int fd, struct file *filp, int mode);
pipe.c99        scull_p_fasync(-1, filp, 0);

function : scull_p_init

  File Line   Context
main.c651        dev += scull_p_init(dev);
scull.h119int     scull_p_init(dev_t dev);

variable : scull_p_nr_devs

  File Line   Context
pipe.c263        for(i = 0; i<scull_p_nr_devs && m->count <= LIMIT; i++) {
pipe.c333        result = register_chrdev_region(firstdev, scull_p_nr_devs, "scullp");
pipe.c339        scull_p_devices = kzalloc(scull_p_nr_devs * sizeof(struct scull_pipe), GFP_KERNEL);
pipe.c341                unregister_chrdev_region(firstdev, scull_p_nr_devs);
pipe.c344        for (i = 0; i < scull_p_nr_devs; i++) {
pipe.c353        return scull_p_nr_devs;
pipe.c371        for (i = 0; i < scull_p_nr_devs; i++) {
pipe.c376        unregister_chrdev_region(scull_p_devno, scull_p_nr_devs);
pipe.c51module_param(scull_p_nr_devs, int, 0);        /* FIXME check perms */

function : scull_p_open

  File Line   Context
pipe.c306        .open =                scull_p_open,

function : scull_p_poll

  File Line   Context
pipe.c304        .poll =                scull_p_poll,

function : scull_p_read

  File Line   Context
pipe.c302        .read =                scull_p_read,

function : scull_p_release

  File Line   Context
pipe.c307        .release =        scull_p_release,

function : scull_p_setup_cdev

  File Line   Context
pipe.c348                scull_p_setup_cdev(scull_p_devices + i, i);

function : scull_p_write

  File Line   Context
pipe.c303        .write =        scull_p_write,

struct : scull_pipe

  File Line   Context
pipe.c120        struct scull_pipe *dev = filp->private_data;
pipe.c158static int scull_getwritespace(struct scull_pipe *dev, struct file *filp)
pipe.c180static int spacefree(struct scull_pipe *dev)
pipe.c190        struct scull_pipe *dev = filp->private_data;
pipe.c229        struct scull_pipe *dev = filp->private_data;
pipe.c250        struct scull_pipe *dev = filp->private_data;
pipe.c259        struct scull_pipe *p;
pipe.c314static void scull_p_setup_cdev(struct scull_pipe *dev, int index)
pipe.c339        scull_p_devices = kzalloc(scull_p_nr_devs * sizeof(struct scull_pipe), GFP_KERNEL);
pipe.c54static struct scull_pipe *scull_p_devices;
pipe.c57static int spacefree(struct scull_pipe *dev);
pipe.c65        struct scull_pipe *dev;
pipe.c67        dev = container_of(inode->i_cdev, struct scull_pipe, cdev);
pipe.c96        struct scull_pipe *dev = filp->private_data;

variable : scull_priv_fops

  File Line   Context
access.c319        { "sullpriv", &scull_c_device, &scull_priv_fops }

function : scull_proc_open

  File Line   Context
main.c191        .open    = scull_proc_open,

variable : scull_proc_ops

  File Line   Context
main.c221        entry = proc_create("scullseq", 0, NULL, &scull_proc_ops);

variable : scull_qset

  File Line   Context
access.c333        dev->qset = scull_qset;
main.c146        struct scull_qset *d;
main.c265struct scull_qset *scull_follow(struct scull_dev *dev, int n)
main.c267        struct scull_qset *qs = dev->data;
main.c271                qs = dev->data = kzalloc(sizeof(struct scull_qset), GFP_KERNEL);
main.c279                        qs->next = kzalloc(sizeof(struct scull_qset), GFP_KERNEL);
main.c297        struct scull_qset *dptr;        /* the first listitem */
main.c341        struct scull_qset *dptr;
main.c425                scull_qset = SCULL_QSET;
main.c466                retval = __get_user(scull_qset, (int __user *)arg);
main.c472                scull_qset = arg;
main.c476                retval = __put_user(scull_qset, (int __user *)arg);
main.c480                return scull_qset;
main.c485                tmp = scull_qset;
main.c486                retval = __get_user(scull_qset, (int __user *)arg);
main.c48module_param(scull_qset, int, S_IRUGO);
main.c494                tmp = scull_qset;
main.c495                scull_qset = arg;
main.c61        struct scull_qset *next, *dptr;
main.c644                scull_devices[i].qset = scull_qset;
main.c77        dev->qset = scull_qset;
main.c93                struct scull_qset *qs = d->data;
scull.h110extern int scull_qset;
scull.h84        struct scull_qset *next;
scull.h88        struct scull_qset *data;  /* Pointer to first quantum set */

variable : scull_quantum

  File Line   Context
access.c332        dev->quantum = scull_quantum;
main.c424                scull_quantum = SCULL_QUANTUM;
main.c431                retval = __get_user(scull_quantum, (int __user *)arg);
main.c437                scull_quantum = arg;
main.c441                retval = __put_user(scull_quantum, (int __user *)arg);
main.c445                return scull_quantum;
main.c450                tmp = scull_quantum;
main.c451                retval = __get_user(scull_quantum, (int __user *)arg);
main.c459                tmp = scull_quantum;
main.c460                scull_quantum = arg;
main.c47module_param(scull_quantum, int, S_IRUGO);
main.c643                scull_devices[i].quantum = scull_quantum;
main.c76        dev->quantum = scull_quantum;
scull.h109extern int scull_quantum;

function : scull_read

  File Line   Context
access.c135        .read =       scull_read,
access.c205        .read =       scull_read,
access.c301        .read =     scull_read,
access.c77        .read =               scull_read,
main.c551        .read =     scull_read,
scull.h126ssize_t scull_read(struct file *filp, char __user *buf, size_t count,

function : scull_release

  File Line   Context
main.c555        .release =  scull_release,

function : scull_remove_proc

  File Line   Context
main.c582        scull_remove_proc();

variable : scull_s_available

  File Line   Context
access.c53        if (! atomic_dec_and_test (&scull_s_available)) {
access.c54                atomic_inc(&scull_s_available);
access.c67        atomic_inc(&scull_s_available); /* release the device */

variable : scull_s_device

  File Line   Context
access.c316        { "scullsingle", &scull_s_device, &scull_sngl_fops },
access.c51        struct scull_dev *dev = &scull_s_device; /* device information */

function : scull_s_open

  File Line   Context
access.c80        .open =               scull_s_open,

function : scull_s_release

  File Line   Context
access.c81        .release =            scull_s_release,

function : scull_seq_next

  File Line   Context
main.c172        .next  = scull_seq_next,

variable : scull_seq_ops

  File Line   Context
main.c183        return seq_open(file, &scull_seq_ops);

function : scull_seq_show

  File Line   Context
main.c174        .show  = scull_seq_show

function : scull_seq_start

  File Line   Context
main.c171        .start = scull_seq_start,

function : scull_seq_stop

  File Line   Context
main.c173        .stop  = scull_seq_stop,

function : scull_setup_cdev

  File Line   Context
main.c646                scull_setup_cdev(&scull_devices[i], i);

variable : scull_sngl_fops

  File Line   Context
access.c316        { "scullsingle", &scull_s_device, &scull_sngl_fops },

function : scull_trim

  File Line   Context
access.c116                scull_trim(dev);
access.c179                scull_trim(dev);
access.c251        scull_trim(&(lptr->device)); /* initialize it */
access.c281                scull_trim(dev);
access.c382                scull_trim(scull_access_devs[i].sculldev);
access.c388                scull_trim(&(lptr->device));
access.c60                scull_trim(dev);
main.c251                scull_trim(dev); /* ignore errors */
main.c575                        scull_trim(scull_devices + i);
scull.h124int     scull_trim(struct scull_dev *dev);

variable : scull_u_count

  File Line   Context
access.c107        if (scull_u_count == 0)
access.c110        scull_u_count++;
access.c99        if (scull_u_count && 

variable : scull_u_device

  File Line   Context
access.c317        { "sculluid", &scull_u_device, &scull_user_fops },
access.c96        struct scull_dev *dev = &scull_u_device; /* device information */

function : scull_u_open

  File Line   Context
access.c138        .open =       scull_u_open,

variable : scull_u_owner

  File Line   Context
access.c100                        (!uid_eq(scull_u_owner , current_uid()) ) &&  /* allow user */
access.c101                        (!uid_eq(scull_u_owner , current_euid()) ) && /* allow whoever did su */
access.c108                scull_u_owner = current_uid(); /* grab it */

function : scull_u_release

  File Line   Context
access.c139        .release =    scull_u_release,

variable : scull_user_fops

  File Line   Context
access.c317        { "sculluid", &scull_u_device, &scull_user_fops },

function : scull_w_available

  File Line   Context
access.c165        while (! scull_w_available()) {
access.c168                if (wait_event_interruptible (scull_w_wait, scull_w_available()))

variable : scull_w_count

  File Line   Context
access.c153        return scull_w_count == 0 ||
access.c172        if (scull_w_count == 0)
access.c174        scull_w_count++;
access.c190        temp = scull_w_count;

variable : scull_w_device

  File Line   Context
access.c162        struct scull_dev *dev = &scull_w_device; /* device information */
access.c318        { "scullwuid", &scull_w_device, &scull_wusr_fops },

function : scull_w_open

  File Line   Context
access.c208        .open =       scull_w_open,

variable : scull_w_owner

  File Line   Context
access.c154                uid_eq(scull_w_owner , current_uid()) ||
access.c155                uid_eq(scull_w_owner , current_euid()) ||
access.c173                scull_w_owner = current_uid(); /* grab it */

function : scull_w_release

  File Line   Context
access.c209        .release =    scull_w_release,

function : scull_write

  File Line   Context
access.c136        .write =      scull_write,
access.c206        .write =      scull_write,
access.c302        .write =    scull_write,
access.c78        .write =              scull_write,
main.c552        .write =    scull_write,
scull.h128ssize_t scull_write(struct file *filp, const char __user *buf, size_t count,

variable : scull_wusr_fops

  File Line   Context
access.c318        { "scullwuid", &scull_w_device, &scull_wusr_fops },

function : spacefree

  File Line   Context
pipe.c160        while (spacefree(dev) == 0) { /* full */
pipe.c168                if (spacefree(dev) == 0)
pipe.c202        count = min(count, (size_t)spacefree(dev));
pipe.c242        if (spacefree(dev))
pipe.c57static int spacefree(struct scull_pipe *dev);

Home

File Index

All Tags

Tags by File

Tags referrers

C to HTML Conversion by ctoohtml