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

最新推荐文章于 2023-12-18 12:01:44 发布
最新推荐文章于 2023-12-18 12:01:44 发布
阅读量661 收藏
点赞数
分类专栏： 内核-驱动 文章标签： struct module file user asynchronous semaphore
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tiantang46800/article/details/6543185
版权

参考：宋宝华，设备驱动开发详解 。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
    <author@linuxdriver.cn>. 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);

tiantang46800
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
linux系统c读写文件函数open write read lseek用法实例
weixin_43996161的博客
10-27 1340
linux系统c读写文件函数open write read lseek用法实例
文章发布系统的设计与实现
qq_17739911的博客
03-12 7084
摘　要 随着计算机技术的迅速发展，网络正以一种前所未有的冲击力影响着人类的生产和生活。网络的快速发展，颠覆了传统的信息传播方式，冲破了传统的时间，空间的局限性，继而引发了人类阅读方式的变革。现如今，网络阅读已成为一种新的时尚，在这种趋势下，文章发布系统应运而生，该系统能以更快速有效的方式分享世界各种信息资源。 本文设计的文章发布系统是一个基于B/S模式，前台界面采用JSP语言编写，后台采用S...
课程设计：c++实现学生成绩管理系统
热门推荐
feinifi的博客
11-28 12万+
学生成绩管理系统课程设计，作为计算机科学专业学生的一门必修课，印象非常深刻，上机，编码，写报告，答辩，最后很多人勉强完成了功课，但是却很少能学到东西，算是一种遗憾吧，即使我们毕业了，仍然会想回去再做一便。 今天就来复习一遍这个课题，也让自己学习学习。 学生成绩管理系统，对于刚学编程的人来说，是有一些难度的，有循环要考虑，还需要注意界面打印，菜单管理，输入输出控制，文件读写操作，排序算法等等技巧。 学生成绩管理系统，可以分为如下几个功能： 主菜单：1、输入学生成...
操作系统 实验五 进程同步问题实现
weixin_46698891的博客
05-27 4204
实验五 进程同步问题实现 一、实验目的 利用实验四提供的方法和例子，解决进程同步相关问题，例如：生产者消费者问题，哲学家进餐等问题。 二、实验环境 硬件环境：计算机一台，局域网环境； 软件环境：Linux Ubuntu操作系统，gcc编译器 三、实验内容 运用实验四中提供的进程同步方法实现如下问题： 生产者消费者问题 问题描述：一组生产者进程向一组消费者进程提供产品，两类进程共享一个由n个缓冲区组成的有界缓冲池，生产者进程向空缓冲池中投放产品，消费者进程从放有数据的缓冲池中取得产品并消费掉。 只
基于read函数分析linux系统调用流程
生活需要深度
08-31 2455
这里名称变掉了，但是我们理解还是sys_read其实在老版本的linux内核里面，确实还是sys_read，但是由于在09年，随着大批量的64位处理器的出现，很多用户在调用的时候，无法填充64位的系统调用，就会被黑客利用，导致系统奔溃和权限升级，所以linux大牛们相处了一套通用的方法，开发出了这一套宏来避免这个bug，这个宏会对参数和系统调用名进行展开解析，从而变成我们需要的sys_read，具体如何做到的，网上有帖子，可以去参看。这里面也包含了各个系统调用的系统调用号，和calls.S是一致的。...
操作系统思考题
^_^
07-18 3263
19年国科大杨力祥老师的操作系统课作业习题的个人解答，不一定能保证正确性，仅供参考 也可以参考这个大佬的博客：https://blog.csdn.net/qq_27500493/article/details/86560421 文章目录操作系统思考题（1）操作系统思考题（2）操作系统思考题（3）操作系统思考题（四） 操作系统思考题（1） 1，为什么计算机启动最开始的时候执行的是BIOS代码而不是操作系统自身的代码？ 计算机被设计为从内存中运行程序，无法直接从软盘或者硬盘中运行。 刚开始加电过程中，内存没.
基于Linux操作系统——文件管理系统设计与实现
dogking3344的博客
12-18 2117
文档管理系统,可以高效管理文档整个生命周期:创建,修改,版本控制,审批,存储,查询,共享,重用以及归档;解决文档分散,安全控制,版本管理等大量文件管理难题。
嵌入式操作系统多任务调度原理分析与RUST参考实现
G.Q.F的专栏
06-23 2723
作为一名在软件领域工程师，在职业生涯的尽头能有幸接触到一部分硬件产品是我莫大的荣幸。秉承我一贯刨根问底，不搞清楚问题本质不罢休的作风和态度，结合基本的计算机知识加一部分FreeRTOS源码，开始了文档标题中的工作，这项工作带来的价值可以指导未来在嵌入式工程领域软件研发工作（人或事），深入而透彻，也能告诉你怎么通过硬件看清软件运行的本质；同时，也作为在嵌入式领域工程实践方面总结与回顾。文档很枯燥，大部分内容是教科书上那些呈辞滥调的重复引用/解释，可参考的部分应该就剩下那份按部就班实现的工程样板代码。我尽量用人
Android双系统实现
shi_derek的博客
04-28 3400
展开 1.前言： 刷机，似乎是安卓手机用户的一项专利，但是，会刷机的用户一般都是喜新厌旧的角色， 一个系统用久了，就想换到另一个系统，或者觉得没有原来的好，或者又觉得要换回去，这样又要重刷。 但是刷来刷去都麻烦啊，并且每次刷机也不是没有风险的，一不小心就可能造成重要数据的丢失。 没有解决办法吗?有！双系统！甚至三系统，四系统！！ 本文就是解决这个问题的，...
操作系统4---接口以及实现
weixin_43604927的博客
11-08 4775
一，接口 1.接口的定义 用户使用计算机的三种方式： 1.命令行：即通过命令程序，linux系统中常用此种方式 2.图形按钮：通过鼠标点击等操作实现对计算机的操控。windows系统在这方面做的就非常优秀。这种方式通过消息框架程序和消息处理程序实现 3.应用程序 不管采用何种方式，我们都需要让操作系统和应用程序之间建立联系。如何建立连接 ? 操作系统接口 接口其实是一种抽象，比如插排，它将内部的电路全部封装起来，只提供两个插口，用电设备插上就能用；不用管插座内部是如何实现的。 操作系统接口也具有连接两个东西
myexpos：了解和实现操作系统的基本功能
02-15
在myexpos中，你将学习如何编写和使用系统调用，如open、read、write等，了解其在操作系统的执行流程。 6. **线程和并发**： 在多核时代，线程管理和并发控制是操作系统的重要特性。myexpos可能会涉及到线程创建...
基于pxa270led计算器实现linux系统下
12-24
接着，实验的核心逻辑包括`open`、`read`和`write`函数的实现。`open`函数用于注册驱动，使得驱动可以被调用；`read`函数读取按键信息，将按下按键的值存入`buf[0]`；`write`函数则将数据写入数码管，更新显示内容。...
南京大学操作系统实验-实现接受键盘输入回显到屏幕上的程序.zip
最新发布
06-01
通常，操作系统提供了API或系统调用来处理I/O，例如在Unix/Linux系统中，我们可以使用`read()`和`write()`函数。 2. **缓冲区管理**：为了提高效率，操作系统通常会使用缓冲区来暂存输入和输出数据。在键盘输入时，...
操作系统第二章习题
12-08
每存入一消息，执行IN:=(IN+1)mod 100，每取出一消息，执行OUT:=(OUT+1)mod100，现在有多个进程并发共享该缓冲池BUF，其中输入进程一次写一个缓冲区（WRITE TO BUFFER），输出进程一次读一个缓冲区（READ FROM ...
platform 驱动 failed to claim resource 2|3|4|5 错误
tiantang46800的专栏
09-10 3855
platform 驱动  failed to claim resource 2|3|4|5  错误 platform 驱动  failed to claim resource 2|3|4|5  错误 原因是device里面的注册的resource结构体有问题，地址重复了。。。 static struct resource s5pc100_xiaozj[
开源代码的编译configure的相关选项
tiantang46800的专栏
10-16 3240
目标：移植tcpdump的文件，apt-get source tcpdump  得到源代码，配置  ./configure  --prefix=/home/apple/you/net/day01/test/bin_tcpdump/ 缺少库文件：libpcap，apt-get source libpcap    得到库的源码， 2131  ./configure --prefix=/ho
大小端转换的例子
tiantang46800的专栏
07-08 1331
Linux/include/linux/swab.h #define constant_swab32(x) \ ((uint32_t)((((uint32_t)(x) & 0x000000FFU) (((uint32_t)(x) & 0
printk打印问题
tiantang46800的专栏
06-10 706
echo 8 > /proc/sys/kernel/printk
实现简单文件系统：内存虚拟磁盘与多级目录管理
`my_open`用于打开文件，`my_close`用于关闭文件，`my_write`用于写入文件，`my_read`用于读取文件，`my_rm`用于删除文件，以及`my_exitsys`用于退出文件系统。 课程安排为授课2学时，上机实践9学时，开发平台可以...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值