2017-2018-1 20155232 《信息安全系系统设计基础》实验四

Posted 2020-10-16 短爪爪爪

2017-2018-1 20155232 《信息安全系系统设计基础》实验四

实验1学习资源中全课中的“hqyj.嵌入式Linux应用程序开发标准教程.pdf”中的第十一章，提交康奈尔笔记的照片（可以多张）

实验2在Ubuntu完成资源中全课中的“hqyj.嵌入式Linux应用程序开发标准教程.pdf”中的第十一章的test试验，提交编译，加载模块，卸载模块，测试运行的截图（要多张，全屏，体现学号信息）

实验目的

该实验是编写最简单的字符驱动程序，这里的设备也就是一段内存，实现简单的读写功能，并列出常用格式的Makefile以及驱动的加载和卸载脚本。读者可以熟悉字符设备驱动的整个编写流程。

1.驱动程序的源代码test_drv.c：

/* test_drv.c */ 
#include <linux/module.h> 
#include <linux/init.h> 
#include <linux/fs.h> 
#include <linux/kernel.h> 
#include <linux/slab.h> 
#include <linux/types.h> 
#include <linux/errno.h> 
#include <linux/cdev.h> 
#include <asm/uaccess.h> 
#define     TEST_DEVICE_NAME    "test_dev" 
#define        BUFF_SZ                1024 
 
/*全局变量*/ 
static struct cdev test_dev; 
unsigned int major =0; 
static char *data = NULL; 
 
/*读函数*/ 
static ssize_t test_read(struct file *file,char *buf, size_t count, loff_t *f_pos)
 {
     int len;
     if (count < 0 ) 
    {
         return -EINVAL;
     }
     len = strlen(data);
     count = (len > count)?count:len;
     if (copy_to_user(buf, data, count)) /* 将内核缓冲的数据拷贝到用户空间*/
     {
         return -EFAULT;
     }
     return count;
 } 
/*写函数*/ 
static ssize_t test_write(struct file *file, const char *buffer, size_t count, loff_t *f_pos) 
{
     if(count < 0)
     {
         return -EINVAL;
     }
     memset(data, 0, BUFF_SZ);
         count = (BUFF_SZ > count)?count:BUFF_SZ;
     if (copy_from_user(data, buffer, count)) /* 将用户缓冲的数据复制到内核空间*/
     {
         return -EFAULT;
     }
     return count;
 }
 /*打开函数*/
 static int test_open(struct inode *inode, struct file *file)
 {
     printk("This is open operation\\n"); 
    /* 分配并初始化缓冲区*/
     data = (char*)kmalloc(sizeof(char) * BUFF_SZ, GFP_KERNEL); 
    if (!data) 
    {
         return -ENOMEM;
     } 
 memset(data, 0, BUFF_SZ);
      return 0;
 }
 /*关闭函数*/
 static int test_release(struct inode *inode,struct file *file) 
{
     printk("This is release operation\\n");
     if (data)
     {
         kfree(data);
 /* 释放缓冲区*/
         data = NULL; /* 防止出现野指针 */
     }
     return 0;
 } 
/* 创建、初始化字符设备，并且注册到系统*/ 
static void test_setup_cdev(struct cdev *dev, int minor, struct file_operations *fops) 
{
     int err, devno = MKDEV(major, minor);
     cdev_init(dev, fops);
     dev->owner = THIS_MODULE;
     dev->ops = fops;
     err = cdev_add (dev, devno, 1);
     if (err)

     {
         printk (KERN_NOTICE "Error %d adding test %d", err, minor);
     }
 } 
 
/* 虚拟设备的 file_operations 结构 */ 
static struct file_operations test_fops =
  {
     .owner   = THIS_MODULE,
     .read    = test_read, 
     .write   = test_write,
     .open    = test_open,
     .release = test_release, 
}; 
 
/*模块注册入口*/
 int init_module(void)
 {
     int result;
     dev_t dev = MKDEV(major, 0); 
 
    if (major)
     {/* 静态注册一个设备，设备号先前指定好，并设定设备名，用 cat /proc/devices 来查看*/
      result = register_chrdev_region(dev, 1, TEST_DEVICE_NAME);
     }
     else
      {
         result = alloc_chrdev_region(&dev, 0, 1, TEST_DEVICE_NAME);
     } 
 
    if (result < 0)
      {
         printk(KERN_WARNING "Test device: unable to get major %d\\n", major);
         return result;
     }
     test_setup_cdev(&test_dev, 0, &test_fops);
     printk("The major of the test device is %d\\n", major);
     return 0;
 } 
 
/*卸载模块*/ 
void cleanup_module(void)
  {
     cdev_del(&test_dev);
     unregister_chrdev_region(MKDEV(major, 0), 1);
     printk("Test device uninstalled\\n");
 } 

2.虚拟设备的驱动程序的Makefile:

KERNELDIR=/usr/src/4.4.0-101-generic

ifeq ($(KERNELRELEASE),) 
KERNELDIR ?= /lib/modules/$(shell uname -r)/build 
PWD := $(shell pwd)
modules:
    $(MAKE) -C $(KERNELDIR) M=$(PWD) modules 
modules_install:
    $(MAKE) -C $(KERNELDIR) M=$(PWD) modules_install 
clean:
    rm -rf *.o *~ core .depend .*.cmd *.ko *.mod.c .tmp_versions 
.PHONY: modules modules_install clean 
else
    obj-m := test_drv.o   
endif 

3.加载和卸载模块。

通过下面两个脚本代码分别实现驱动模块的加载和卸载。
加载脚本

test_drv_load

如下所示：

#!/bin/sh
# 驱动模块名称
module="test_drv"    
# 设备名称。在/proc/devices中出现
device="test_dev"    
# 设备文件的属性
mode="664"            
group="david"        
 
# 删除已存在的设备节点
rm -f /dev/${device} 
# 加载驱动模块
/sbin/insmod -f ./$module.ko $* || exit 1
# 查到创建设备的主设备号
major=`cat /proc/devices | awk "\\\\$2==\\"$device\\" {print \\\\$1}"`
# 创建设备文件节点
mknod /dev/${device} c $major 0
# 设置设备文件属性
chgrp $group /dev/${device}
chmod $mode  /dev/${device}

卸载脚本test_drv_unload如下所示：

#!/bin/sh
module="test_drv"    
device="test_dev"
# 卸载驱动模块
/sbin/rmmod $module $* || exit 1
# 删除设备文件
rm -f /dev/${device}
exit 0

4.编写测试代码

/* test.c */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include <fcntl.h>
#define     TEST_DEVICE_FILENAME        "/dev/test_dev"        /* 设备文件名*/
#define        BUFF_SZ                        1024                /* 缓冲大小 */
 
int main()
{
    int fd, nwrite, nread;
    char buff[BUFF_SZ];        /*缓冲区*/
    /* 打开设备文件 */
    fd = open(TEST_DEVICE_FILENAME, O_RDWR);
    if (fd < 0)
    {
        perror("open");
        exit(1);
    }
        
    do
    {
        printf("Input some words to kernel(enter \'quit\' to exit):");
        memset(buff, 0, BUFF_SZ);
        if (fgets(buff, BUFF_SZ, stdin) == NULL)
        {
            perror("fgets");
            break;
        }
        buff[strlen(buff) - 1] = \'\\0\';
        if (write(fd, buff, strlen(buff)) < 0) /* 向设备写入数据 */
        {
            perror("write");
            break;
        }
        if (read(fd, buff, BUFF_SZ) < 0)        /* 从设备读取数据 */
        {
            perror("read");
            break;
        }
        else
        {
            printf("The read string is from kernel:%s\\n", buff);
        }
    } while(strncmp(buff, "quit", 4));
    close(fd);
    exit(0);
}

5.在命令行输入

make clean;make

6.运行

./**test_drv_load**

7.编译并运行测试程序

 gcc –o test test.c
 ./test

8.运行截图

9.卸载驱动程序

./test_drv_unload**

实验三

在实验箱中通过交叉编译完成test实验，提交编译，加载模块，卸载模块，测试运行的截图（要多张，全屏，体现学号信息）

因实验室电脑没有网络，实验箱和电脑的超级终端始终无法ping通，因此无法完成。老师说不用完成此实验。

实验中出现的问题

makefile文件中出现的错误：

解决：

将里面的空格换成tab键即可解决。

在实验二中，加载驱动模块时总是出现权限不够的问题，无法执行。

解决：

在每条命令前加上sudo，以此来提高权限便可正常运行。

运行加载模块脚本提示Opeation not permitted

解决

使用

sudo

尝试，提示

david

无效的组，修改脚本

test_drv_load

，将david改成root后，再次运行，还是提示错误，

在询问同学后，重启后即可解决。

康奈尔学习笔记问题整理

• 中断号的作用
• 中断号也叫中断类型号，或者中断请求号。
  中断是指在CPU运行期间，被CPU内部或外部事件所打断、暂停当前程序的执行而转去执行一段特定的处理内部或外部时间程序的过程。外部设备进行I/O操作时，会随机产生中断请求信号。这个信号中会有特定的标志，使计算机能够判断是哪个设备提出中断请求，这个信号就叫做中断号。

各个中断号和设备之间的对应关系如下：

中断号　使用此设备的硬件

00　系统计时器

01　键盘

02　可编程的中断控制器

03　通讯端口 COM2

04　通讯端口 COM1

05　声卡或未分配

06　标准软盘控制器

07　打印机端口 LPT1

08　系统CMOS实时钟

09　打印机端口 LPT1

10　未分配

11　显卡

12　通用串行总线控制器

13　数值数据处理器

14、15　硬盘控制器

malloc()

和

kmalloc()

函数有什么区别？

• 在网上查资料的时候，还看到了一个新的函数

vmalloc

于是一起进行了学习：

1、kmalloc和vmalloc是分配的是内核的内存,malloc分配的是用户的内存

2、kmalloc保证分配的内存在物理上是连续的,内存只有在要被DMA访问的时候才需要物理上连续，malloc和vmalloc保证的是在虚拟地址空间上的连续

3、kmalloc能分配的大小有限,vmalloc和malloc能分配的大小相对较大

4、vmalloc比kmalloc要慢。 尽管在某些情况下才需要物理上连续的内存块，但是很多内核代码都用kmalloc来获得内存，而不是vmalloc。这主要是出于性能的考虑。vmalloc函数为了把物理内存上不连续的页转换为虚拟地址空间上连续的页，必须专门建立页表项。糟糕的是，通过vmalloc获得的页必须一个个地进行映射，因为它们物理上是不连续的，这就会导致比直接内存映射大得多的TLB抖动，vmalloc仅在不得已时才会用--典型的就是为了获得大块内存时。

• 为什么内核空间用printk函数不用printf？
• printk()函数负责把格式化好的字符串拷贝到内核日志缓冲上，这样syslog程序就可 以通过读取该缓冲区来获取内核信息。
  printk()的用法很像printf()：

printk("Hello world!A string:%s and an integer:%d\\n",a_string,an_integer);

printk()和printf()之间的一个显著区别在于printk()允许通过指定一个标志来设置优先级。syslog会根据这个优先级标 志来决定在什么地方显示这条系统信息。

下面是一个使用这种优先级标志的例子：

printk(KERN_ERR "this is an error!\\n");

printk()

函数是直接使用了向终端写函数tty_write()。而printf()函数是调用write()系统调用函数向标准输出设备写。所以 在用户态（如进程0）不能够直接使用printk()函数，而在内核态由于他已是特权级，所以无需系统调用来改变特权级，因而能够直接使用 printk()函数。
printf是使用了标准的C库函数的时候才能使用的，而内核中无法使用标准的C库函数，所以就连最常见的printf都不能使用。

• 下面给出一个具体例子的参考链接

用函数printk打印内核信息的方法

收获

1.设备驱动程序概念

2.字符设备驱动程序编写流程

3.块设备驱动程序的编写流程

4.proc文件系统

5.虚拟设备驱动程序编写、编译、加载、卸载

6.使用printk打印内核信息