LDD3 scull内存驱动程序改写

       对于第三章的内容，所用设备数据结构有点复杂，从数据操作中解脱出来应该更好理解。

       1、只建立一个设备scull

       2、将数据区域直接改成一个1000的字符数组

       3、实现功能：open，close，read，write，llseek

红色字体为改动的地方:

 

头文件源码

#ifndef _SCULL_H_
#define _SCULL_H_

#include <linux/ioctl.h> /* needed for the _IOW etc stuff used later */

#ifndef SCULL_MAJOR
#define SCULL_MAJOR 0   /* dynamic major by default */
#endif

#ifndef SCULL_NR_DEVS
#define SCULL_NR_DEVS 1    /* scull */
#endif

#ifndef SCULL_P_NR_DEVS
#define SCULL_P_NR_DEVS 1  /* scullpipe0 through scullpipe3 */
#endif

/*
 * The pipe device is a simple circular buffer. Here its default size
 */
#ifndef SCULL_P_BUFFER
#define SCULL_P_BUFFER 4000
#endif

/*
 * Representation of scull quantum sets.
 */
#define Data_Len 1000
struct scull_dev {
 char data[Data_Len];
 struct semaphore sem;     /* mutual exclusion semaphore     */
 struct cdev cdev;   /* Char device structure  */
};

/*
 * The different configurable parameters
 */
extern int scull_major;     /* main.c */
extern int scull_nr_devs;

/*
 * Prototypes for shared functions
 */

ssize_t scull_read(struct file *filp, char __user *buf, size_t count,
                   loff_t *f_pos);
ssize_t scull_write(struct file *filp, const char __user *buf, size_t count,
                    loff_t *f_pos);
loff_t  scull_llseek(struct file *filp, loff_t off, int whence);

 

 

主文件源码：

/*
 * main.c -- the bare scull char module
 *
 * Copyright (C) 2001 Alessandro Rubini and Jonathan Corbet
 * Copyright (C) 2001 O'Reilly & Associates
 *
 * The source code in this file can be freely used, adapted,
 * and redistributed in source or binary form, so long as an
 * acknowledgment appears in derived source files.  The citation
 * should list that the code comes from the book "Linux Device
 * Drivers" by Alessandro Rubini and Jonathan Corbet, published
 * by O'Reilly & Associates.   No warranty is attached;
 * we cannot take responsibility for errors or fitness for use.
 *
 */

#include <linux/config.h>
#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/proc_fs.h>
#include <linux/fcntl.h> /* O_ACCMODE */
#include <linux/seq_file.h>
#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 */

module_param(scull_major, int, S_IRUGO);
module_param(scull_minor, int, S_IRUGO);
module_param(scull_nr_devs, int, S_IRUGO);

MODULE_AUTHOR("Alessandro Rubini, Jonathan Corbet");
MODULE_LICENSE("Dual BSD/GPL");

struct scull_dev *scull_devices; /* allocated in scull_init_module */

/*
 * Open and close
 */

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) {
  if (down_interruptible(&dev->sem))
   return -ERESTARTSYS;
  up(&dev->sem);
 }
 return 0;          /* success */
}

int scull_release(struct inode *inode, struct file *filp)
{
 return 0;
}
/*
 * Data management: read and write
 */

ssize_t scull_read(struct file *filp, char __user *buf, size_t count,
                loff_t *f_pos)
{
 struct scull_dev *dev = filp->private_data;
 ssize_t retval = 0;

 if (down_interruptible(&dev->sem))
  return -ERESTARTSYS;

 if((*f_pos)>= Data_Len)
  goto out;
 if(((*f_pos)+count)>= Data_Len)
  {
   count= Data_Len-(*f_pos);
  }
 if (copy_to_user(buf, dev->data, count))
  {
   retval = -EFAULT;
   goto out;
  }
 (*f_pos)+=count;
 retval= count;

 

 out:
 up(&dev->sem);
 
 return retval;

}

ssize_t scull_write(struct file *filp, const char __user *buf, size_t count,
                loff_t *f_pos)
{
 struct scull_dev *dev = filp->private_data;
 ssize_t retval = -ENOMEM; /* value used in "goto out" statements */

 if (down_interruptible(&dev->sem))
  return -ERESTARTSYS;

 if((*f_pos+count)>=Data_Len)
  {
  count= Data_Len-(*f_pos);
  }
   if (copy_from_user(&(dev->data[*f_pos]), buf, count)) {
    retval = -EFAULT;
    goto out;
   }
   *f_pos += count;
   retval = count;

 
 out:
   up(&dev->sem);
   return retval;

}

/*
 * The "extended" operations -- only seek
 */

loff_t scull_llseek(struct file *filp, loff_t off, int whence)
{
 struct scull_dev *dev = filp->private_data;
 loff_t newpos;

 switch(whence) {
   case 0: /* SEEK_SET */
  newpos = off;
  break;

   case 1: /* SEEK_CUR */
  newpos = filp->f_pos + off;
  break;

   case 2: /* SEEK_END */
  newpos = Data_Len;
  break;

   default: /* can't happen */
  return -EINVAL;
 }
 if (newpos < 0) return -EINVAL;
 filp->f_pos = newpos;
 return newpos;
}

 

struct file_operations scull_fops = {
 .owner   =   THIS_MODULE,
 .llseek  = scull_llseek,
 .read    =  scull_read,
 .write   =   scull_write,
 .ioctl   =   NULL,//  scull_ioctl,
 .open   =   scull_open,
 .release  =   scull_release,
};

/*
 * 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++) {
   cdev_del(&scull_devices[i].cdev);
  }
  kfree(scull_devices);
 }

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

}

/*
 * 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;
 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 scull_init_module(void)
{
 int result, i;
 dev_t dev = 0;

/*
 * Get a range of minor numbers to work with, asking for a dynamic
 * major unless directed otherwise at load time.
 */
 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;
 }

        /*
  * allocate the devices -- we can't have them static, as the number
  * can be specified at load time
  */
 scull_devices = kmalloc(scull_nr_devs * sizeof(struct scull_dev), GFP_KERNEL);
 if (!scull_devices) {
  result = -ENOMEM;
  goto fail;  /* Make this more graceful */
 }
 memset(scull_devices, 0, scull_nr_devs * sizeof(struct scull_dev));

        /* Initialize each device. */
 init_MUTEX(scull_devices->sem);
 scull_setup_cdev(scull_devices, 0);

 return 0; /* succeed */

  fail:
 scull_cleanup_module();
 return result;
}

module_init(scull_init_module);
module_exit(scull_cleanup_module);

 

测试程序：

#include <stdio.h>
#include <fcntl.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#define Scull_Device "/dev/scull"
#define Data_Num 100
int main(void)
{
 int fscull;
 int bytesize=0;
 char buff[Data_Num]="i am here ,ericjiang";
 
 fscull=open(Scull_Device,O_RDWR);
 if(fscull== -1)
  {
   perror("open scull device fail!/n");
   return -1;
  }
 sleep(5);
 bytesize=write(fscull,buff,strlen(buff));
 printf("write data byte==%d/n",bytesize);
 buff[0]='a';
 buff[1]='a';
 buff[2]='a';
 buff[3]='a';
 buff[4]='a';
 buff[5]='a';
 buff[6]='a';
 buff[7]='a';
 buff[8]='a';
 buff[9]='a'; 
 lseek(fscull,0,SEEK_SET);
 bytesize=read(fscull,buff,5);
 sleep(5);
 printf("read data byte==%d/n",bytesize);
 printf("str==%s/n",buff);

 close(fscull);
 return 0;

}

 

试验：

make

insmod scull.ko                                  //插入模块

mknod /dev/scull c 253 0                   //建立节点 

 

gcc -o scull_test scull_test.c             //编译测试程序

./scull_test                                        //测试

write data byte==20

read data byte==5

str==i am aaaaa ericjiang