实现系统的read，write，思考实现的fangf

参考：宋宝华，设备驱动开发详解 。ldd3

作者：me

内核2.6.35.22

gcc 4.4.5

编译模块和test程序，

insmod 模块  //lsmod    //cat /dev/devices  验证加载的效果

mknod /dev/my_char c 258 0//创建设被节点

运行$echo dddff > /dev/my_char//每部运行使用dmesg看消息

运行$cat  /dev/my_char 看效果

运行test程序

root@andy-virtual-machine:/home/xiao/four/new_char/R_W_L# cat test.c
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <fcntl.h>


int main (void)
{
    int fd;
    int ret;
    char buf[] = "hello/n";
    fd = open ("/dev/my_char", O_WRONLY|O_APPEND, 0777);
    if (-1 == fd) {
        perror ("open err:");
    }
    while (1)
    {
        static int count;
    ret = write (fd, buf, sizeof(buf));
    printf ("ok count %d/n",++count);
    }
    if (-1 == fd) {
        perror ("write err:");
    }
    close (fd);
}

 

 

root@andy-virtual-machine:/home/xiao/four/new_char/R_W_L# vi test.c
root@andy-virtual-machine:/home/xiao/four/new_char/R_W_L# cat char.c
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/sched.h>
#include <linux/list.h>
#include <asm/uaccess.h>
#include <linux/mm.h>
#include <linux/cdev.h>
#include <linux/fs.h>
#include <linux/types.h>
#include <linux/slab.h>

#define  MAJOR_CHAR 258
#define  SIZE_CHAR  1024
#define  DBUG_ME 1

struct char_dev {
    struct cdev cdev;
    char mem[SIZE_CHAR];
};
struct char_dev *char_devp;
int char_major = MAJOR_CHAR;

MODULE_LICENSE ("GPL");
/*    ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
    ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);*/
static ssize_t char_read (struct file *filp, char __user *buf, size_t count, loff_t *ppos)
{
    int ret = 0;
    loff_t p = filp->f_pos;
    struct char_dev *dev = filp->private_data;
#if DBUG_ME
    printk (KERN_INFO "in char_read,befor read ,and filp->f_pos = %llu,and ppos = %llu/n", filp->f_pos,*ppos);
#endif
    if (count > SIZE_CHAR - p)
        count = SIZE_CHAR - p;
    if (copy_to_user (buf, (void *)(dev->mem + p), count))
        ret = -EFAULT;
    else {
        ret = count ;
        filp->f_pos += count;
        *ppos += count;//read end of //if not have this read will all go on , never stop; 如果不加这句话，cat时后就一直读，用test程序里写的read也是一直读
#if DBUG_ME
    printk (KERN_INFO "in char_read,after read ,and filp->f_pos = %llu , count = %d,and ppos = %llu/n", filp->f_pos, count,*ppos);
#endif
    }
    return ret;//没有实现，读走的功能，光是只读功能
}
static ssize_t char_write (struct file *filp, const char __user *buf, size_t count, loff_t *ppos)
{
    int ret = 0;
    loff_t p = filp->f_pos;
    struct char_dev *dev = filp->private_data;
#if DBUG_ME
    printk (KERN_INFO "in char_write,befor write ,and filp->f_pos = %llu,and ppos = %llu/n", filp->f_pos, *ppos);
#endif
    if (count > SIZE_CHAR - p)
        count = SIZE_CHAR - p;
    if (copy_from_user ((void *)(dev->mem + p), buf, count))   //extern inline long copy_from_user(void *to, const void __user *from, long n)
        ret = -EFAULT;
    else {
        ret = count ;
        filp->f_pos += count;
        *ppos += count;//add for 如果没有这话，用test程序里的write循环写，一直覆盖以前的东西，有了后就是一次打开中不断的追加
#if DBUG_ME
    printk (KERN_INFO "in char_write,after write ,and filp->f_pos = %llu , count = %d,and ppos = %llu/n", filp->f_pos, count, *ppos);
#endif
    }
    return ret;

//程序没有实现，关闭文件后再次打开时写也追加在文件后，看宋老师的程序，最后在struct char_dev里放了个unsigned long 的变量，用来记录现在文件的结尾标志，这个方法可以解决问题，但是不好，思考内核是如何实现的
}
static int char_open (struct inode *inode, struct file *filp)
{
    struct char_dev *char_me_devp;
    char_me_devp = container_of (inode->i_cdev, struct char_dev, cdev);
    filp->private_data = char_me_devp;
#if DBUG_ME
    printk (KERN_INFO "in char_open,and filp->f_pos = %llu/n", filp->f_pos);
#endif
    return 0;
}
static int   char_release (struct inode *inode, struct file *filp)
{
#if DBUG_ME
    printk (KERN_INFO "in char_release/n");
#endif
    return 0;
}
struct file_operations char_fops = {
    .owner   = THIS_MODULE,
    .open    = char_open,
    .release = char_release,
    .read    = char_read,
    .write   = char_write,
};
static void char_setup_cdev (struct char_dev *dev, int index)
{
    int ret;
    dev_t devno = MKDEV (char_major, index);
    cdev_init (&dev->cdev, &char_fops);
    dev->cdev.owner = THIS_MODULE;
    ret = cdev_add (&dev->cdev, devno, 1);
    if (ret)
        printk (KERN_NOTICE "error %d/n adding char_dev %d/n", ret, index);
}
static int char_me_init (void)
{
    int ret;
    dev_t devno = MKDEV (char_major, 0);
    if (char_major)
        ret = register_chrdev_region (devno, 1, "my_char");
    else {
        ret = alloc_chrdev_region (&devno, 0, 1, "my_char");
        char_major = MAJOR (devno);
    }
    if (ret < 0)
        return ret;
    char_devp = (struct char_dev*)kmalloc (sizeof(struct char_dev), GFP_KERNEL);
    if (NULL == char_devp) {
        ret = -ENOMEM;
        goto fail_kmalloc;
    }
    memset (char_devp, 0, sizeof(struct char_dev));
    char_setup_cdev (char_devp, 0);
#if DBUG_ME
    printk (KERN_INFO "in char_me_init/n");
#endif
    return 0;
fail_kmalloc:
    unregister_chrdev_region (devno, 1);
    return ret;
}
static void char_me_exit (void)
{
    dev_t devno = MKDEV (char_major, 0);
    cdev_del (&char_devp->cdev);
    kfree (char_devp);  
    unregister_chrdev_region (devno, 1);
#if DBUG_ME
    printk (KERN_INFO "in char_me_exit/n");
#endif
}
module_init (char_me_init);
module_exit (char_me_exit);

 

加入lseek后的代码，依据实现的代码可以看出，filp->f_pos,是定位当前读写文件指针的

test代码ruxia

root@andy-virtual-machine:/home/xiao/four/new_char/race# cat test.c
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <fcntl.h>


int main (void)
{
    int fd;
    int ret;
    char buf[] = "0";
    fd = open ("/dev/my_char", O_RDWR|O_APPEND, 0777);
    if (-1 == fd) {
        perror ("open err:");
    }
        ret = read (fd, buf, 1);
        printf ("ok count %s/n",buf);
        sleep(1);
        lseek (fd,1,SEEK_CUR);
        ret = read (fd, buf, 1);
        printf ("ok count %s/n",buf);
        sleep(1);

/*    while (1)
    {
        sleep (1);
        static int count;
    ret = write (fd, buf, sizeof(buf));
    printf ("ok count %d/n",++count);
    }*/
    if (-1 == fd) {
        perror ("write err:");
    }
    close (fd);
}

root@andy-virtual-machine:/home/xiao/four/new_char/race# cat char.c
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/sched.h>
#include <linux/list.h>
#include <asm/uaccess.h>
#include <linux/mm.h>
#include <linux/cdev.h>
#include <linux/fs.h>
#include <linux/types.h>
#include <linux/slab.h>

#define  MAJOR_CHAR 258
#define  SIZE_CHAR  1024
#define  DBUG_ME 1

struct char_dev {
    struct cdev cdev;
    char mem[SIZE_CHAR];
};
struct char_dev *char_devp;
int char_major = MAJOR_CHAR;

MODULE_LICENSE ("GPL");
/*    ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
 loff_t (*llseek) (struct file *, loff_t, int);
    ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);*/
static loff_t char_lseek (struct file *filp, loff_t offset, int orig)
{
    struct char_dev *dev = filp->private_data;
    int ret;
    switch (orig) {
    case SEEK_SET:
        if ((offset < 0) || (((unsigned int) offset) > SIZE_CHAR)) {
            ret = -EINVAL;
            break;
        }
        filp->f_pos  = (unsigned long)offset;
        ret = filp->f_pos;
        break;
    case SEEK_CUR:
        if (((filp->f_pos + offset) > SIZE_CHAR) || ((filp->f_pos + offset) < 0)) {
            ret = -EINVAL;
            break;
        }
        filp->f_pos += offset;
        ret = filp->f_pos;
        break;
    }
    return ret;
   
}
static ssize_t char_read (struct file *filp, char __user *buf, size_t count, loff_t *ppos)
{
    int ret = 0;
    loff_t p = *ppos;
    struct char_dev *dev = filp->private_data;
    if (p >= SIZE_CHAR) {
        return 0;
    }

#if DBUG_ME
    printk (KERN_INFO "in char_read,befor read ,and filp->f_pos = %llu,and ppos = %llu/n", filp->f_pos,*ppos);
#endif
    if (count > SIZE_CHAR - p)
        count = SIZE_CHAR - p;
    if (copy_to_user (buf, (void *)(dev->mem + p), count))
        ret = -EFAULT;
    else {
        ret = count ;
        filp->f_pos += count;
        *ppos += count;//read end of //if not have this read will all go on , never stop;
#if DBUG_ME
    printk (KERN_INFO "in char_read,after read ,and filp->f_pos = %llu , count = %d,and ppos = %llu/n", filp->f_pos, count,*ppos);
#endif
    }
    return ret;
}
static ssize_t char_write (struct file *filp, const char __user *buf, size_t count, loff_t *ppos)
{
    int ret = 0;
    loff_t p = *ppos;
    struct char_dev *dev = filp->private_data;
#if DBUG_ME
    printk (KERN_INFO "in char_write,befor write ,and filp->f_pos = %llu,and ppos = %llu/n", filp->f_pos, *ppos);
#endif
    if (count > SIZE_CHAR - p)
        count = SIZE_CHAR - p;
    if (copy_from_user ((void *)(dev->mem + p), buf, count))   //extern inline long copy_from_user(void *to, const void __user *from, long n)
        ret = -EFAULT;
    else {
        ret = count ;
        filp->f_pos += count;
        *ppos += count;//add for
#if DBUG_ME
    printk (KERN_INFO "in char_write,after write ,and filp->f_pos = %llu , count = %d,and ppos = %llu/n", filp->f_pos, count, *ppos);
#endif
    }
    return ret;


}
static int char_open (struct inode *inode, struct file *filp)
{
    struct char_dev *char_me_devp;
    char_me_devp = container_of (inode->i_cdev, struct char_dev, cdev);
    filp->private_data = char_me_devp;
#if DBUG_ME
    printk (KERN_INFO "in char_open,and filp->f_pos = %llu/n", filp->f_pos);
#endif
    return 0;
}
static int   char_release (struct inode *inode, struct file *filp)
{
#if DBUG_ME
    printk (KERN_INFO "in char_release/n");
#endif
    return 0;
}
struct file_operations char_fops = {
    .owner   = THIS_MODULE,
    .open    = char_open,
    .release = char_release,
    .read    = char_read,
    .write   = char_write,
    .llseek   = char_lseek
};
static void char_setup_cdev (struct char_dev *dev, int index)
{
    int ret;
    dev_t devno = MKDEV (char_major, index);
    cdev_init (&dev->cdev, &char_fops);
    dev->cdev.owner = THIS_MODULE;
    ret = cdev_add (&dev->cdev, devno, 1);
    if (ret)
        printk (KERN_NOTICE "error %d/n adding char_dev %d/n", ret, index);
}
static int char_me_init (void)
{
    int ret;
    dev_t devno = MKDEV (char_major, 0);
    if (char_major)
        ret = register_chrdev_region (devno, 1, "my_char");
    else {
        ret = alloc_chrdev_region (&devno, 0, 1, "my_char");
        char_major = MAJOR (devno);
    }
    if (ret < 0)
        return ret;
    char_devp = (struct char_dev*)kmalloc (sizeof(struct char_dev), GFP_KERNEL);
    if (NULL == char_devp) {
        ret = -ENOMEM;
        goto fail_kmalloc;
    }
    memset (char_devp, 0, sizeof(struct char_dev));
    char_setup_cdev (char_devp, 0);
#if DBUG_ME
    printk (KERN_INFO "in char_me_init/n");
#endif
    return 0;
fail_kmalloc:
    unregister_chrdev_region (devno, 1);
    return ret;
}
static void char_me_exit (void)
{
    dev_t devno = MKDEV (char_major, 0);
    cdev_del (&char_devp->cdev);
    kfree (char_devp);
    unregister_chrdev_region (devno, 1);
#if DBUG_ME
    printk (KERN_INFO "in char_me_exit/n");
#endif
}
module_init (char_me_init);
module_exit (char_me_exit);

 

宋老师代码/ *======================================================================
    A globalfifo driver as an example of char device drivers 
    This example is to introduce asynchronous notifier
     
    The initial developer of the original code is Baohua Song
    <[email protected]>. All Rights Reserved.
======================================================================*/
#include <linux/module.h>
#include <linux/types.h>
#include <linux/fs.h>
#include <linux/errno.h>
#include <linux/mm.h>
#include <linux/sched.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/cdev.h>
#include <asm/io.h>
#include <asm/system.h>
#include <asm/uaccess.h>
#include <linux/poll.h>

#define GLOBALFIFO_SIZE    0x1000    /*È«ŸÖfifo×îŽó4K×ÖœÚ*/
#define FIFO_CLEAR 0x1  /*Çå0È«ŸÖÄÚŽæµÄ³€¶È*/
#define GLOBALFIFO_MAJOR 250    /*Ô€ÉèµÄglobalfifoµÄÖ÷É豞ºÅ*/
static int globalfifo_fasync(int fd, struct file *filp, int mode); //add by lht
static int globalfifo_major = GLOBALFIFO_MAJOR;
/*globalfifoÉ豞œá¹¹Ìå*/
struct globalfifo_dev                                    
{                                                       
  struct cdev cdev; /*cdevœá¹¹Ìå*/                      
  unsigned int current_len;    /*fifoÓÐЧÊýŸÝ³€¶È*/
  unsigned char mem[GLOBALFIFO_SIZE]; /*È«ŸÖÄÚŽæ*/       
  struct semaphore sem; /*²¢·¢¿ØÖÆÓõÄÐźÅÁ¿*/          
  wait_queue_head_t r_wait; /*×èÈû¶ÁÓõĵȎý¶ÓÁÐÍ·*/    
  wait_queue_head_t w_wait; /*×èÈûÐŽÓõĵȎý¶ÓÁÐÍ·*/   
  struct fasync_struct *async_queue; /* Ò천œá¹¹ÌåÖžÕ룬ÓÃÓÚ¶Á */
};

struct globalfifo_dev *globalfifo_devp; /*É豞œá¹¹ÌåÖžÕë*/
/*ÎÄŒþŽò¿ªº¯Êý*/
int globalfifo_open(struct inode *inode, struct file *filp)
{
  /*œ«É豞œá¹¹ÌåÖžÕëž³ÖµžøÎÄŒþËœÓÐÊýŸÝÖžÕë*/
  filp->private_data = globalfifo_devp;
  return 0;
}
/*ÎÄŒþÊͷź¯Êý*/
int globalfifo_release(struct inode *inode, struct file *filp)
{
    /* œ«ÎÄŒþŽÓÒ천͚֪ÁбíÖÐÉŸ³ý */
  //globalmem_fasync( - 1, filp, 0);//modified by lht
   globalfifo_fasync( - 1, filp, 0);
 
  return 0;
}

/* ioctlÉ豞¿ØÖƺ¯Êý */
static int globalfifo_ioctl(struct inode *inodep, struct file *filp, unsigned
  int cmd, unsigned long arg)
{
  struct globalfifo_dev *dev = filp->private_data;/*»ñµÃÉ豞œá¹¹ÌåÖžÕë*/

  switch (cmd)
  {
    case FIFO_CLEAR:
        down(&dev->sem); //»ñµÃÐźÅÁ¿       
      dev->current_len = 0;
      memset(dev->mem,0,GLOBALFIFO_SIZE);
      up(&dev->sem); //ÊÍ·ÅÐźÅÁ¿
        
      printk(KERN_INFO "globalfifo is set to zero/n");     
      break;

    default:
      return  - EINVAL;
  }
  return 0;
}

static unsigned int globalfifo_poll(struct file *filp, poll_table *wait)
{
  unsigned int mask = 0;
  struct globalfifo_dev *dev = filp->private_data; /*»ñµÃÉ豞œá¹¹ÌåÖžÕë*/
 
  down(&dev->sem);
 
  poll_wait(filp, &dev->r_wait, wait);
  poll_wait(filp, &dev->w_wait, wait); 
  /*fifo·Ç¿Õ*/
  if (dev->current_len != 0)
  {
    mask |= POLLIN | POLLRDNORM; /*±êÊŸÊýŸÝ¿É»ñµÃ*/
  }
  /*fifo·ÇÂú*/
  if (dev->current_len != GLOBALFIFO_SIZE)
  {
    mask |= POLLOUT | POLLWRNORM; /*±êÊŸÊýŸÝ¿ÉÐŽÈë*/
  }
    
  up(&dev->sem);
  return mask;
}

/* globalfifo fasyncº¯Êý*/
static int globalfifo_fasync(int fd, struct file *filp, int mode)
{
    struct globalfifo_dev *dev = filp->private_data;
    return fasync_helper(fd, filp, mode, &dev->async_queue);
}


/*globalfifo¶Áº¯Êý*/
static ssize_t globalfifo_read(struct file *filp, char __user *buf, size_t count,
  loff_t *ppos)
{
  int ret;
  struct globalfifo_dev *dev = filp->private_data; //»ñµÃÉ豞œá¹¹ÌåÖžÕë
  DECLARE_WAITQUEUE(wait, current); //¶šÒåµÈŽý¶ÓÁÐ

  down(&dev->sem); //»ñµÃÐźÅÁ¿
  add_wait_queue(&dev->r_wait, &wait); //œøÈë¶ÁµÈŽý¶ÓÁÐÍ·

  /* µÈŽýFIFO·Ç¿Õ */
  if (dev->current_len == 0)
  {
    if (filp->f_flags &O_NONBLOCK)
    {
      ret =  - EAGAIN;
      goto out;
    }
    __set_current_state(TASK_INTERRUPTIBLE); //žÄ±äœø³Ì׎̬Ϊ˯Ãß
    up(&dev->sem);

    schedule(); //µ÷¶ÈÆäËûœø³ÌÖŽÐÐ
    if (signal_pending(current))
    //Èç¹ûÊÇÒòΪÐźŻœÐÑ
    {
      ret =  - ERESTARTSYS;
      goto out2;
    }

    down(&dev->sem);
  }

  /* ¿œ±ŽµœÓû§¿ÕŒä */
  if (count > dev->current_len)
    count = dev->current_len;

  if (copy_to_user(buf, dev->mem, count))
  {
    ret =  - EFAULT;
    goto out;
  }
  else
  {
    memcpy(dev->mem, dev->mem + count, dev->current_len - count); //fifoÊýŸÝÇ°ÒÆ
    dev->current_len -= count; //ÓÐЧÊýŸÝ³€¶ÈŒõÉÙ
    printk(KERN_INFO "read %d bytes(s),current_len:%d/n", count, dev->current_len);
    
    wake_up_interruptible(&dev->w_wait); //»œÐÑÐŽµÈŽý¶ÓÁÐ
   
    ret = count;
  }
  out: up(&dev->sem); //ÊÍ·ÅÐźÅÁ¿
  out2:remove_wait_queue(&dev->w_wait, &wait); //ŽÓžœÊôµÄµÈŽý¶ÓÁÐÍ·ÒƳý
  set_current_state(TASK_RUNNING);
  return ret;
}


/*globalfifoÐŽ²Ù×÷*/
static ssize_t globalfifo_write(struct file *filp, const char __user *buf,
  size_t count, loff_t *ppos)
{
  struct globalfifo_dev *dev = filp->private_data; //»ñµÃÉ豞œá¹¹ÌåÖžÕë
  int ret;
  DECLARE_WAITQUEUE(wait, current); //¶šÒåµÈŽý¶ÓÁÐ

  down(&dev->sem); //»ñÈ¡ÐźÅÁ¿
  add_wait_queue(&dev->w_wait, &wait); //œøÈëÐŽµÈŽý¶ÓÁÐÍ·

  /* µÈŽýFIFO·ÇÂú */
  if (dev->current_len == GLOBALFIFO_SIZE)
  {
    if (filp->f_flags &O_NONBLOCK)
    //Èç¹ûÊÇ·Ç×èÈû·ÃÎÊ
    {
      ret =  - EAGAIN;
      goto out;
    }
    __set_current_state(TASK_INTERRUPTIBLE); //žÄ±äœø³Ì׎̬Ϊ˯Ãß
    up(&dev->sem);

    schedule(); //µ÷¶ÈÆäËûœø³ÌÖŽÐÐ
    if (signal_pending(current))
    //Èç¹ûÊÇÒòΪÐźŻœÐÑ
    {
      ret =  - ERESTARTSYS;
      goto out2;
    }

    down(&dev->sem); //»ñµÃÐźÅÁ¿
  }

  /*ŽÓÓû§¿ÕŒä¿œ±ŽµœÄں˿Ռä*/
  if (count > GLOBALFIFO_SIZE - dev->current_len)
    count = GLOBALFIFO_SIZE - dev->current_len;

  if (copy_from_user(dev->mem + dev->current_len, buf, count))
  {
    ret =  - EFAULT;
    goto out;
  }
  else
  {
    dev->current_len += count;
    printk(KERN_INFO "written %d bytes(s),current_len:%d/n", count, dev
      ->current_len);

    wake_up_interruptible(&dev->r_wait); //»œÐѶÁµÈŽý¶ÓÁÐ
    /* ²úÉúÒ천¶ÁÐźŠ*/
    if (dev->async_queue)
       kill_fasync(&dev->async_queue, SIGIO, POLL_IN);
   
    ret = count;
  }

  out: up(&dev->sem); //ÊÍ·ÅÐźÅÁ¿
  out2:remove_wait_queue(&dev->w_wait, &wait); //ŽÓžœÊôµÄµÈŽý¶ÓÁÐÍ·ÒƳý
  set_current_state(TASK_RUNNING);
  return ret;
}


/*ÎÄŒþ²Ù×÷œá¹¹Ìå*/
static const struct file_operations globalfifo_fops =
{
  .owner = THIS_MODULE,
  .read = globalfifo_read,
  .write = globalfifo_write,
  .ioctl = globalfifo_ioctl,
  .poll = globalfifo_poll,
  .open = globalfifo_open,
  .release = globalfifo_release,
  .fasync = globalfifo_fasync,
};

/*³õÊŒ»¯²¢×¢²ácdev*/
static void globalfifo_setup_cdev(struct globalfifo_dev *dev, int index)
{
  int err, devno = MKDEV(globalfifo_major, index);

  cdev_init(&dev->cdev, &globalfifo_fops);
  dev->cdev.owner = THIS_MODULE;
  dev->cdev.ops = &globalfifo_fops;
  err = cdev_add(&dev->cdev, devno, 1);
  if (err)
    printk(KERN_NOTICE "Error %d adding LED%d", err, index);
}

/*É豞Çý¶¯Ä£¿éŒÓÔغ¯Êý*/
int globalfifo_init(void)
{
  int ret;
  dev_t devno = MKDEV(globalfifo_major, 0);

  /* ÉêÇëÉ豞ºÅ*/
  if (globalfifo_major)
    ret = register_chrdev_region(devno, 1, "globalfifo");
  else  /* ¶¯Ì¬ÉêÇëÉ豞ºÅ */
  {
    ret = alloc_chrdev_region(&devno, 0, 1, "globalfifo");
    globalfifo_major = MAJOR(devno);
  }
  if (ret < 0)
    return ret;
  /* ¶¯Ì¬ÉêÇëÉ豞œá¹¹ÌåµÄÄÚŽæ*/
  globalfifo_devp = kmalloc(sizeof(struct globalfifo_dev), GFP_KERNEL);
  if (!globalfifo_devp)    /*ÉêÇëʧ°Ü*/
  {
    ret =  - ENOMEM;
    goto fail_malloc;
  }

  memset(globalfifo_devp, 0, sizeof(struct globalfifo_dev));

  globalfifo_setup_cdev(globalfifo_devp, 0);

  init_MUTEX(&globalfifo_devp->sem);   /*³õÊŒ»¯ÐźÅÁ¿*/
  init_waitqueue_head(&globalfifo_devp->r_wait); /*³õÊŒ»¯¶ÁµÈŽý¶ÓÁÐÍ·*/
  init_waitqueue_head(&globalfifo_devp->w_wait); /*³õÊŒ»¯ÐŽµÈŽý¶ÓÁÐÍ·*/

  return 0;

  fail_malloc: unregister_chrdev_region(devno, 1);
  return ret;
}


/*Ä£¿éжÔغ¯Êý*/
void globalfifo_exit(void)
{
  cdev_del(&globalfifo_devp->cdev);   /*×¢Ïúcdev*/
  kfree(globalfifo_devp);     /*ÊÍ·ÅÉ豞œá¹¹ÌåÄÚŽæ*/
  unregister_chrdev_region(MKDEV(globalfifo_major, 0), 1); /*ÊÍ·ÅÉ豞ºÅ*/
}

MODULE_AUTHOR("Song Baohua");
MODULE_LICENSE("Dual BSD/GPL");

module_param(globalfifo_major, int, S_IRUGO);

module_init(globalfifo_init);
module_exit(globalfifo_exit);