(dev_t)-->主设备号、次设备号

 MAJOR(dev_t
dev)
 MINOR(dev_t dev)

 主设备号、次设备号-->(dev_t)

 MKDEV(int major,int
minor) 

int
register_chrdev_region(dev_t
first,
unsigned
int
count,
char
*name);  
//指定设备编号

int
alloc_chrdev_region(dev_t
*dev,
unsigned
int
firstminor,
unsigned
int
count,
char
*name);  
//动态生成设备编号

void
unregister_chrdev_region(dev_t
first,
unsigned
int
count);  
   //释放设备编号

if
(scull_major)
{
   
dev =
MKDEV(scull_major,
scull_minor);
   
result =
register_chrdev_region(dev,
scull_nr_devs,
"scull");
}
else
{
   
result =
alloc_chrdev_region(&dev,
scull_minor,
scull_nr_devs,"scull");
   
scull_major = MAJOR(dev);
}
if
(result
< 0)
{
   
printk(KERN_WARNING
"scull:
can't get major %d\n",
scull_major);
   
return result;
}

struct
file_operations scull_fops = {
.owner = THIS_MODULE,

.llseek = scull_llseek,
.read = scull_read,
.write
= scull_write,
.ioctl = scull_ioctl,
.open =
scull_open,
.release = scull_release,
};

/*
 *
Set up the char_dev structure for this device.
 */
static
void
scull_setup_cdev(struct
scull_dev *dev,
int
index)
{
    int
err,
devno =
MKDEV(scull_major,
scull_minor +
index);
    
    cdev_init(&dev->cdev,
&scull_fops);
    dev->cdev.owner
=
THIS_MODULE;
    dev->cdev.ops
=
&scull_fops;  //这句可以省略，在cdev_init中已经做过
    err
=
cdev_add (&dev->cdev,
devno,
1);
    /*
Fail gracefully if need be 这步值得注意*/
    if
(err)
        printk(KERN_NOTICE
"Error
%d adding scull%d",
err,
index);
}

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

container_of(pointer,
container_type, container_field);

struct
scull_dev *dev; /* device information */
dev =
container_of(inode->i_cdev, struct scull_dev,
cdev);
filp->private_data = dev; /* for other methods */

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 */
/* now
trim to 0 the length of the device if open was write-only */

if ( (filp->f_flags & O_ACCMODE) = = O_WRONLY) {

scull_trim(dev); /* ignore errors */
}
return 0;
/* success */
}

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

return 0;
}

/*
 *
Representation of scull quantum sets.
 */
struct
scull_qset {
    void
**data;
    struct
scull_qset *next;
};

struct
scull_dev {
    struct
scull_qset *data;
/*
Pointer to first quantum set */
    int
quantum;
/*
the current quantum size */
    int
qset;
/*
the current array size */
    unsigned
long
size;
/*
amount of data stored here */
    unsigned
int
access_key;
/*
used by sculluid and scullpriv */
    struct
semaphore sem;
/*
mutual exclusion semaphore */
    struct
cdev cdev;    
/*
Char device structure        */
};

void
*kmalloc(size_t
size,
int
flags);
void
kfree(void
*ptr);

int
scull_trim(struct
scull_dev *dev)
{
 
struct
scull_qset *next,
*dptr;
    
int
qset =
dev->qset;
/*
量子集中量子的个数*/
    
int
i;
    
for
(dptr
=
dev->data;
dptr;
dptr =
next)
{
/*
循环scull_set个数次，直到dptr为NULL为止。*/
        
if
(dptr->data)
{
              
for
(i
=
0;
i <
qset;
i++)/*
循环一个量子集中量子的个数次*/
                   
kfree(dptr->data[i]);/*
释放其中一个量子的空间*/

              
kfree(dptr->data);/*
释放当前的scull_set的量子集的空间*/
              
dptr->data
=
NULL;/*
释放一个scull_set中的void
**data指针*/
         
}
     
next =
dptr->next;
/*
准备下个scull_set的指针*/
     
kfree(dptr);/*
释放当前的scull_set*/
     
}
 
dev->size
=
0;
/*
当前的scull_device所存的数据为0字节*/
 
dev->quantum
=
scull_quantum;/*
初始化一个量子的大小*/
 
dev->qset
=
scull_qset;/*
初始化一个量子集中量子的个数*/
 
dev->data
=
NULL;/*
释放当前的scull_device的struct
scull_qset *data指针*/
 
return
0;
}

/*Follow
the list*/
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;
}

ssize_t
read(struct file *filp, char __user *buff,
size_t count,
loff_t *offp);
ssize_t write(struct file *filp, const char
__user *buff,
size_t count, loff_t *offp);

unsigned
long copy_to_user(void __user *to,

const void *from,
unsigned long
count);
unsigned long copy_from_user(void *to,

const void __user *from,

unsigned long count);

#define
__copy_from_user(to,from,n)
(memcpy(to,
(void
__force *)from,
n),
0)
#define
__copy_to_user(to,from,n)    (memcpy((void
__force *)to,
from,
n),
0)

/*
copy
by 压子
*/

#include
<linux/module.h>
//#include <linux/moduleparam.h> //test
moduleparam
#include <linux/init.h>
#include
<linux/slab.h>

/*

* Our parameters which can be set at load time.
*/

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;

/*

* Finally, the module stuff
*/

/*

* The cleanup function is used to handle initialization failures
as well.
* Thefore, it must be careful to work correctly even
if some of the items
* have not been initialized
*/

void
scull_cleanup_module(void)
{
int i;
dev_t devno =
MKDEV(scull_major, scull_minor);

/* Get rid of our char
dev entries */
if (scull_devices) {
for (i = 0; i <
scull_nr_devs; i++) {
scull_trim(scull_devices +
i);
cdev_del(&scull_devices.cdev);
}
kfree(scull_devices);
}

/*
cleanup_module is never called if registering failed
*/
unregister_chrdev_region(devno, scull_nr_devs);
}

/*

copy
by 压子

*/

#include
<linux/module.h>

//#include
<linux/moduleparam.h> //test moduleparam

#include
<linux/init.h>

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

/*

*
Empty out the scull device; must be called with the device

*
semaphore held.

*/

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);

/*

copy
by 压子

*/

#include
<linux/module.h>

#include
<linux/moduleparam.h>

#include
<linux/init.h>

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

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

#include
<linux/fs.h> /* everything... */

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

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

#include
<linux/fcntl.h> /* O_ACCMODE */

#include
<linux/cdev.h>

#include
<asm/system.h> /* cli(), *_flags */

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

#include
"scull.h" /* local definitions */

/*

*
Our parameters which can be set at load time.

*/

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 */

/*

*
Empty out the scull device; must be called with the device

*
semaphore held.

*/

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);