测试程序中系统调用如何调用到驱动程序函数

linux操作系统，分为kernel层和user层，那么user层是如何通过系统调用最终调用到底层驱动接口呢？下面将以实测案例进行讲解。

底层驱动代码：

----------------------------------------------------------------start--------------------------------------------------------------------

#include <linux/kernel.h>
#include <linux/unistd.h>
#include <linux/types.h>
#include <linux/string.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/i2c.h>
#include <linux/input.h>
#include <linux/workqueue.h>
#include <linux/mutex.h>
#include <linux/slab.h>
#include <linux/mutex.h>
#include <linux/interrupt.h>
#include <linux/delay.h>
#include <asm/irq.h>
#include <linux/cdev.h>
#include <linux/uaccess.h>
#include <linux/device.h>
#include <linux/kobject.h>
#include <linux/fs.h>
#include <../../../include/linux/sysfs.h>
#include <linux/dcache.h>
#include <linux/namei.h>
#include <linux/err.h>
#include <linux/proc_fs.h>


#define NAME "fyl_test"
#define MAX_SIZE 255
#define TEST_BUF "Welcome to LongCheer"
static struct kobject *kobj = NULL;
static int major = 100;
static struct cdev *test_cdev = NULL;


#define SYSFS "The message is sent by sysfs "




static ssize_t fyl_test_show(struct device *dev, struct device_attribute *attr, char *buf)
{
int ret  = 0;
printk(KERN_ALERT"[fyl] %s %d\n", __func__, __LINE__);
ret = sprintf(buf, SYSFS);
ret = strlen(buf) + 1;
printk(KERN_ALERT"[fyl] ret = %d \n", ret);
return 0;
}


static ssize_t fyl_test_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count )
{
printk(KERN_ALERT"[fyl] %s %d\n", __func__, __LINE__);
return 0;
}


DEVICE_ATTR(fyl_test, S_IRUGO | S_IWUSR | S_IWGRP | S_IWOTH, fyl_test_show, fyl_test_store);




static struct attribute * attr_test[] = {
&dev_attr_fyl_test.attr,
NULL
};


static struct attribute_group test_attgrp = {
.attrs = attr_test,
//.name = NAME
};




static int test_open(struct inode *inode, struct file *filp)
{


printk(KERN_ALERT"%s\n", __func__);
return 0;
}


static int test_close(struct inode *inode, struct file *filp)
{


printk(KERN_ALERT"%s\n", __func__);
return 0;
}


static int test_read(struct file *filp, char __user* buf, size_t size, loff_t * lof)
{
int cnt = 0;
char buffer[MAX_SIZE] = TEST_BUF;
cnt = copy_to_user(buf, buffer, size);
if (cnt) 
printk("the buffer has %d left\n", cnt);


printk(KERN_ALERT"%s cnt = %d\n", __func__, cnt);
printk(KERN_ALERT"%s , send buf:%s\n", __func__, buffer);


printk(KERN_ALERT"%s\n", __func__);
return 0;
}


static int test_write(struct file *filp, const char __user* buf, size_t size, loff_t * lof)
{
int cnt = 0;
char buffer[MAX_SIZE] = {0};
cnt = copy_from_user(buffer, buf, size);
if (cnt) 
printk("the buffer has %d left\n", cnt);

printk(KERN_ALERT"%s cnt = %d\n", __func__, cnt);
printk(KERN_ALERT"%s , receive buf:%s\n", __func__, buffer);


printk(KERN_ALERT"%s\n", __func__);
return 0;
}




static struct file_operations file_ops = {
.owner = THIS_MODULE,
.open = test_open,
.release = test_close,
.read = test_read,
.write = test_write,
};




static struct class *test_class = NULL;
static struct proc_dir_entry *proc_test = NULL;


static int __init fyl_init(void)
{
int ret = 0;
dev_t dev_num = 0;
struct device *dev = NULL;




  /* sysfs operation */
kobj = kobject_create_and_add(NAME, NULL);
if (IS_ERR(kobj) || !kobj) {
printk(KERN_ALERT"[fyl] %s %d allocate kobj faild\n", __func__, __LINE__);
return 0;
}
ret = sysfs_create_group(kobj, &test_attgrp);


  /* proc operation */
proc_test = proc_create(NAME, 0666, NULL, &file_ops);
if (IS_ERR(proc_test) || !proc_test) {
printk(KERN_ALERT"[fyl]%d ,proc_create failed\n", __LINE__);
return -ENOMEM;
}








  /* dev node operation */
dev_num = MKDEV(major, 0);
ret = register_chrdev_region(dev_num, 1, NAME);
if (ret != 0) {
printk(KERN_ALERT"[fyl] %s %d register_chrdev_region failed\n", __func__, __LINE__);
return 0;
}


test_cdev = cdev_alloc();
if (IS_ERR(test_cdev) || !test_cdev) {
printk(KERN_ALERT"[fyl] %s %d allocate cdev failed\n", __func__, __LINE__);
return 0;
}
cdev_init(test_cdev, &file_ops);
ret = cdev_add(test_cdev, dev_num, 1);
if (ret != 0) {
printk(KERN_ALERT"[fyl] %s %d cdev_add failed\n", __func__, __LINE__);
return 0;
}

test_class = class_create(THIS_MODULE, "test_class");
if (IS_ERR(test_class) || !test_class) {
printk(KERN_ALERT"[fyl] %s %d allocate class faild\n", __func__, __LINE__);
return 0;
}


dev = device_create(test_class, NULL, dev_num, NULL, NAME);
if (IS_ERR(dev) || !dev) {
printk(KERN_ALERT"[fyl] %s %d generate dev/fyl_test faild\n", __func__, __LINE__);
return 0;
}




printk(KERN_ALERT"fyl_init\n");
return 0;
}


static void __exit fyl_exit(void)
{
printk(KERN_ALERT"fyl_exit\n");
}


module_init(fyl_init);
module_exit(fyl_exit);


MODULE_AUTHOR("fanyanlai@blongcheer.net");
MODULE_DESCRIPTION("fyl driver test");
MODULE_LICENSE("GPL v2");

----------------------------------------------------------------end---------------------------------------------------------------------

用户层测试程序：

----------------------------------------------------------------start--------------------------------------------------------------------

#include <stdio.h>
#include <string.h>
#include <strings.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include <fcntl.h>


#define NAME "/dev/fyl_test"
#define MAX_SIZE 255


int main(int argc, char *argv[])
{
int cnt = argc;
int i = 0;
int ret = 0;
char buf_r[MAX_SIZE] = {0};
char buf_w[] = "Get the information";
printf("fyl test \n");
printf("[fyl] cnt = %d\n", cnt);

for(i=cnt; i > 0 && argv[--i]; ) 
printf("[fyl]argv[%d]:%s\n", i, argv[i]);


int fd = 0;
fd = open(NAME, O_RDWR);
if (fd < 0) {
printf("open faild\n");
return 0;
}


ret = read(fd, buf, 21);
if (ret)
printf("the buffer has %d left\n", ret);
printf("buf_r:%s ,ret = %d\n", buf_r, ret);
sleep(1);

ret = write(fd, buf_w, sizeof(buf_w));
if (ret)
printf("the buffer has %d left\n", ret);
printf("buf_w:%s ,ret = %d\n", buf_w, ret);

sleep(2);
close(fd);


return 0;
}

----------------------------------------------------------------end---------------------------------------------------------------------

测试结果：

root@vegetalte:/system/bin # ./fyl_main_test
./fyl_main_test
fyl test
[fyl] cnt = 1
[fyl]argv[0]:./fyl_main_test
buf_r:Welcome to LongCheer ,ret = 0
buf_w:Get the information ,ret = 0

将测试程序中的宏定义

#define NAME "/dev/fyl_test"

换成

#define NAME "dev/fyl_test"

然后进行测试：

测试结果一：

root@vegetalte:/system/bin # ./fyl_main_test
./fyl_main_test
fyl test
[fyl] cnt = 1
[fyl]argv[0]:./fyl_main_test
open faild

测试结果二：

root@vegetalte:/ # ./system/bin/fyl_main_test
./system/bin/fyl_main_test
fyl test
[fyl] cnt = 1
[fyl]argv[0]:./system/bin/fyl_main_test
buf_r:Welcome to LongCheer ,ret = 0
buf_w:Get the information ,ret = 0

分析：

1、如果测试程序中文件节点不是绝对路径，运行程序就会报错；

2、测试程序会以所在运行路径去查找文件节点。