内核与用户空间的通信实现——ioctl（驱动+用户程序）

最新推荐文章于 2023-06-14 10:58:06 发布
最新推荐文章于 2023-06-14 10:58:06 发布
阅读量4.9k 收藏 30
点赞数 11
文章标签： 嵌入式 c语言 驱动开发 linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ljl113/article/details/127013196
版权

目录

前言

字符设备

应用程序与驱动程序间的关系

file_operations 结构体

file_operations结构体的使用，指定对应驱动函数

字符设备的注册与注销

设备号

 静态分配设备号

动态分配主设备号

ioctl-基于字符设备的代码实现

驱动模块 kernel_ioctl_demo.c

用户程序 usr_ioctl_demo.c

makefile

MISC 杂项设备驱动

MISC设备注册和注销

基于杂项设备的ioctl驱动

前言

        本文主要介绍内核空间与用户空间通信的一种方式----ioctl，用户程序可以通过调用ioctl函数来实现将一个cmd传给内核，而内核驱动根据switch case来实现预先设定好cmd对应执行的相关程序。

      学习ioctl是一个字符设备，所以在我们学习ioctl之前需要先了解一下linux设备驱动中的字符设备。

字符设备

        字符设备是 Linux 驱动中最基本的一类设备驱动，字符设备按照字节流进行读写操作的设备（一个字节一个字节地读写）。

应用程序与驱动程序间的关系

      我们常说的驱动实际上就是驱动程序。以字符设备为例，驱动函数在加载成功后，会在/dev目录下生成一个驱动名称的文件夹，即/dev/xx。应用程序通过系统调用open()打开这个文件夹，然后通过对这个文件的操作来调用相应的驱动程序去控制硬件。

      通过下图可以更直观的理解整个调用的过程。首先应用程序通过系统调用如open、read、write、close等函数进入内核空间，之后驱动程序会根据用户传递进来的信息去完成相应的操作。

file_operations 结构体

        每一个系统调用都会对应一个驱动程序中的函数。如系统调用的open会对应驱动程序中的一个open，用户使用的系统调用open在进入到内核空间后实际上执行的就是驱动程序中与open对应的函数。

        驱动往往就是去实现驱动程序系统调用对应的这些函数，那么内核怎么知道用户在使用系统调用函数时该去执行驱动程序中的哪个函数呢？

        答案就在于：Linux 内核文件 include/linux/fs.h 中有个叫做 file_operations 的结构体。通过这个结构体可以指定系统调用对应的驱动函数。

struct file_operations {
 struct module *owner; // owner表示拥有该结构体的模块的指针，基本都是THIS_MODULE。
 loff_t (*llseek) (struct file *, loff_t, int); 
 ssize_t (*read) (struct file *, char __user *, size_t, loff_t*);
 ssize_t (*write) (struct file *, const char __user *, size_t,loff_t *);
 ssize_t (*read_iter) (struct kiocb *, struct iov_iter *);
 ssize_t (*write_iter) (struct kiocb *, struct iov_iter *);
 int (*iterate) (struct file *, struct dir_context *);
 unsigned int (*poll) (struct file *, struct poll_table_struct*); /* poll轮询函数，用来查询设备是否可以进行非阻塞的读写 */
 long (*unlocked_ioctl) (struct file *, unsigned int, unsignedlong); /* 对应ioctl函数，在32位操作系统上运行32位的程序会使用unlocked_ioctl，而64位操作系统上运行32位程序会对应compat_ioctl */
 long (*compat_ioctl) (struct file *, unsigned int, unsignedlong);
 int (*mmap) (struct file *, struct vm_area_struct *);
 int (*mremap)(struct file *, struct vm_area_struct *);
 int (*open) (struct inode *, struct file *);
 int (*flush) (struct file *, fl_owner_t id);
 int (*release) (struct inode *, struct file *); // 对应close函数
 int (*fsync) (struct file *, loff_t, loff_t, int datasync); /* 用于刷新待处理的数据，用于将缓冲区中的数据刷新到磁盘中。 */
 int (*aio_fsync) (struct kiocb *, int datasync); /*与 fasync 函数的功能类似，只是 aio_fsync 是异步刷新待处理的数据 */
 int (*fasync) (int, struct file *, int);
 int (*lock) (struct file *, int, struct file_lock *);ssize_t (*sendpage) (struct file 
             *,struct page *, int, size_t,loff_t *, int);
 unsigned long (*get_unmapped_area)(struct file *, unsigned long,unsigned long, unsigned             
             long, unsigned long);
 int (*check_flags)(int);
 int (*flock) (struct file *, int, struct file_lock *);
 ssize_t (*splice_write)(struct pipe_inode_info *, struct file *,loff_t *, size_t,         
         unsigned int); 
 ssize_t (*splice_read)(struct file *, loff_t *, struct pipe_inode_info *, size_t,     
          unsigned int);
 int (*setlease)(struct file *, long, struct file_lock **, void**);
 long (*fallocate)(struct file *file, int mode, loff_t offset,loff_t len);
 void (*show_fdinfo)(struct seq_file *m, struct file *f);
#ifndef CONFIG_MMU
    unsigned (*mmap_capabilities)(struct file *);
#endif
}

file_operations结构体的使用，指定对应驱动函数

/*                   ：int ioctl_demo_open
 * @description      : 打开设备，对应open函数
 * @param – inode    : 传递给驱动的 inode
 * @param - pfilp_t  : 设备文件， file 结构体有个叫做 private_data 的成员变量
 *                   一般在 open 的时候将 private_data 指向设备结构体。
 * @return           : 0 成功;其他 失败
 */
static int ioctl_demo_open(struct inode *pinode_t, struct file *pfilp_t)
{
	// 用户实现具体功能
	return 0;
}

/*                  ：ioctl_demo_release
 * @description     : 关闭/释放设备，对应close函数
 * @param - pfilp_t : 要关闭的设备文件(文件描述符)
 * @return          : 0 成功;其他 失败
 */
static int ioctl_demo_release(struct inode *pinode_t, struct file *pfilp_t)
{
    // 用户实现具体功能
	return 0;
}

/*                   ：ioctl_demo_write
 * @description      : 向设备写数据，对应write函数
 * @param - pfilp_t  : 设备文件，表示打开的文件描述符
 * @param - pusr_buf : 要写给设备写入的数据
 * @param - cnt      : 要写入的数据长度
 * @param - pofft_t  : 相对于文件首地址的偏移
 * @return           : 写入的字节数，如果为负值，表示写入失败
 */
static ssize_t ioctl_demo_write(struct file *pfilp_t,
								const char __user *pusr_buf,
								size_t cnt, loff_t *pofft_t)
{
    // 用户实现具体功能
	return 0;
}

/*               :ioctl_demo_read
 * @description  : 从设备读文件,对应read函数
 * @param – filp : 要打开的设备文件(文件描述符)
 * @param – buf  : 返回给用户空间的数据缓冲区
 * @param – cnt  : 要读取的数据长度
 * @param – offt : 相对于文件首地址的偏移
 * @return       : 读取的字节数，如果为负值，表示读取失败
 */
static ssize_t ioctl_demo_read(struct file *filp, char __user *buf,
								size_t cnt, loff_t *offt)
{
	// 用户实现具体功能
	return 0;
}
#endif

static struct file_operations ioctl_demo_fops = {
	.owner = THIS_MODULE,
	.unlocked_ioctl = ioctl_demo_unlocked_ioctl, //指定驱动函数对应系统调用的ioctl
	.open = ioctl_demo_open,                     //指定驱动函数对应系统调用的open
	.release = ioctl_demo_release,               //指定驱动函数对应系统调用的close
	.write = ioctl_demo_write,                   //指定驱动函数对应系统调用的write
	.read = ioctl_demo_read,                     //指定驱动函数对应系统调用的read
};

字符设备的注册与注销

设备号

        为了方便管理， Linux 中每个设备都有一个设备号，设备号由主设备号和次设备号两部分组成，主设备号表示某一个具体的驱动，次设备号表示使用这个驱动的各个设备。

        Linux 提供了一个名为 dev_t 的数据类型表示设备号， dev_t 定义在文件include/linux/types.h 里面，定义如下：

typedef __u32 __kernel_dev_t;

typedef __kernel_dev_t dev_t;

/* 
 * 根据上面的定义可以看出dev_t是__u32类型的
 * 而在include/uapi/asm-generic/int-ll64.h给出了u__32的定义
 * typedef unsigned int __u32;
 * 由此看出dev_t实际上就是unsigned int类型的数据
 */

        dev_t 其实就是 unsigned int 类型，是一个 32 位的数据类型。这 32 位的数据构成了主设备号和次设备号两部分，其中高 12 位为主设备号， 低 20 位为次设备号。因此 Linux系统中主设备号范围为 0~4095。在include/linux/kdev_t.h 中提供了几个关于设备号的操作函数，如下所示：

#define MINORBITS 20 // 表示次设备号位数，一共是 20 位。
#define MINORMASK ((1U << MINORBITS) - 1) // 表示次设备号掩码
#define MAJOR(dev) ((unsigned int) ((dev) >> MINORBITS)) // 用于从 dev_t 中获取主设备号，将 dev_t 右移 20 位即可。
#define MINOR(dev) ((unsigned int) ((dev) & MINORMASK)) // 用于从 dev_t 中获取次设备号，取 dev_t 的低 20 位的值即可。
#define MKDEV(ma,mi) (((ma) << MINORBITS) | (mi)) // 用于将给定的主设备号和次设备号的值组合成 dev_t 类型的设备号。

 静态分配设备号

        对于字符设备驱动而言，当驱动模块加载成功以后需要注册字符设备，同样，卸载驱动模块的时候也需要注销掉字符设备。字符设备的注册和注销函数原型如下所示:

/*                   : register_chrdev
 * @description      : 字符设备注册函数，一般放在驱动模块的入口函数modlue_init
 * @param – major    : 主设备号，Linux 下每个设备都有一个主设备号和次设备号
 * @param - name     : 设备名字，指向一串字符串。即调用注册函数生成/dev/name
 * @param - fops     : 结构体 file_operations 类型指针，指向设备的操作函数集合变量          
 * @return           : 0 成功;其他 失败
 */
static inline int register_chrdev(unsigned int major, const char *name,
                                    const struct file_operations *fops)

/*                   : unregister_chrdev
 * @description      : 字符设备注销函数,一般放在驱动模块的出口函数modlue_exit
 * @param – major    : 主设备号，Linux 下每个设备都有一个主设备号和次设备号
 * @param - name     : 设备名字，指向一串字符串。         
 * @return           : 无
 */
static inline void unregister_chrdev(unsigned int major, const char *name)

主设备号查看命令：可以查看已经使用的主设备号

cat /proc/devices

动态分配主设备号

        静态分配主设备号还需要手动查看主设备号是否被占用，容易冲突，比较麻烦，所以可以使用动态分配相关的函数如下：

/*                   : alloc_chrdev_region
 * @description      : 动态分配设备号
 * @param – dev      : 传出参数，用来保存申请到的设备号。
 * @param - baseminor: 次设备号起始地址,一般 baseminor 为 0，也就是说次设备号从 0 开始。申请多 
 *                    个设备号时用
 * @param - count    : 要申请的设备号数量。
 * @param - name     : 设备名字
 * @return           : 0 成功;其他 失败
 */

int alloc_chrdev_region(dev_t *dev, unsigned baseminor, unsigned count, 
                        const char *name);

/*                   : unregister_chrdev_regio
 * @description      : 释放设备号
 * @param – from     : 需要释放的设备号。
 * @param - count    : 表示从 from 开始，要释放的设备号数量。
 * @return           : 无
 */
void unregister_chrdev_region(dev_t from, unsigned count)

ioctl-基于字符设备的代码实现

驱动模块 kernel_ioctl_demo.c

#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/ide.h>
#include <linux/init.h>
#include <linux/module.h>

#define IOCTL_DEMO_MAJOR    200           /* 主设备号 */
#define IOCTL_DEMO_NAME     "ioctl_demo"  /* 设备名 */

#define HELLO_OPEN          (0U)
#define HELLo_CLOSE         (1U)

/*                   : ioctl_demo_unlocked_ioctl
 * @description      : 驱动实现ioctl，获取用户态发送的cmd
 * @param – pfilp_t  : 设备文件
 * @param - cmd      : 用户态发送给内核的cmd
 * @param - arg      : 用户态发给内核的额外的参数
 * @return           : 0 成功;其他 失败
 */
long ioctl_demo_unlocked_ioctl(struct file *pfilp_t, unsigned int cmd, unsigned long arg)
{
	switch(cmd)
	{
		case HELLO_OPEN:
		{
			printk("ioctl_demo:get cmd:HELLO_OPEN from usr\n");
			break;
		}
		
		case HELLo_CLOSE:
		{
			printk("ioctl_demo:get cmd:HELLO_CLOSE from usr\n");
			break;
		}
		
		default:
		{
			printk("ioctl_demo:get cmd failure from usr\n");
			return -1;
		}
	}
	return 0;
}

/*
 * @description   : 打开设备
 * @param – inode : 传递给驱动的 inode
 * @param - filp  : 设备文件， file 结构体有个叫做 private_data 的成员变量
 *                 一般在 open 的时候将 private_data 指向设备结构体。
 * @return        : 0 成功;其他 失败
 */
static int ioctl_demo_open(struct inode *inode, struct file *filp)
{
	printk("ioctl_demo	open!\n");
	return 0;
}

/*
 * @description  : 关闭/释放设备
 * @param - filp : 要关闭的设备文件(文件描述符)
 * @return       : 0 成功;其他 失败
 */
static int ioctl_demo_release(struct inode *inode, struct file *filp)
{
    printk("ioctl_demo	close!\n");
	return 0;
}

/*
 * @description  : 向设备写数据
 * @param - filp : 设备文件，表示打开的文件描述符
 * @param - buf  : 要写给设备写入的数据
 * @param - cnt  : 要写入的数据长度
 * @param - offt : 相对于文件首地址的偏移
 * @return       : 写入的字节数，如果为负值，表示写入失败
 */
static ssize_t ioctl_demo_write(struct file *filp,
								const char __user *buf,
								size_t cnt, loff_t *offt)
{
	
	return 0;
}

/*
 * @description  : 从设备读文件
 * @param – filp : 要打开的设备文件(文件描述符)
 * @param – buf  : 返回给用户空间的数据缓冲区
 * @param – cnt  : 要读取的数据长度
 * @param – offt : 相对于文件首地址的偏移
 * @return       : 读取的字节数，如果为负值，表示读取失败
 */
static ssize_t ioctl_demo_read(struct file *filp, char __user *buf,
								size_t cnt, loff_t *offt)
{
	
	return 0;
}

static struct file_operations ioctl_demo_fops = {
	.owner = THIS MODULE,
	.open = ioctl_demo_open,
	.release = ioctl_demo_release,
	.write = ioctl_demo_write,
	.read = ioctl_demo_read,
};

static int __init ioctl_demo_init(void)
{
	int retvalue = 0;

	retvalue = register_chrdev(200, "ioctl_demo", &ioctl_demo_fops);
	if(0 > retvalue)
	{
		printk("kernel ioctl_demo register_chrdev failure\n");
		return -1;
	}
	printk("chrdev ioctl_demo is insmod, major_dev is 200\n");
	return 0;
}

static void __exit ioctl_demo_exit(void)
{
	unregister_chrdev(200, "ioctl_demo");
	printk("chrdev ioctl_demo is rmmod and unregister success\n");
}

module_init(ioctl_demo_init);
module_exit(ioctl_demo_exit);

MODULE_DESCRIPTION("a  ioctl demo");
MODULE_AUTHOR("lixuezhang");
MODULE_LICENSE("GPL");

用户程序 usr_ioctl_demo.c

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/ioctl.h>

#define MISC_NAME "/tmp/ioctl_demo"

#define HELLO_OPEN  (0UL)
#define HELLO_CLOSE (1UL)

int main(int argc, char **argv)
{
	int fd = open(MISC_NAME, O_RDWR);
	if(fd < 0)
	{
		perror("open failure\n");
		return -1;
	}
	
	while(1)
	{
		int retvalue = ioctl(fd, HELLO_OPEN);
		if(0 != retvalue)
		{
			perror("ioctl failure\n");
			break;
		}
		
		sleep(1);
		
		retvalue = ioctl(fd, HELLO_CLOSE);
		if(0 != retvalue)
		{
			perror("ioctl failure\n");
			break;
		}
	}
	
	close(fd);
	return 0;
}

makefile

KERNEL_DIR := /XX/XX/linux-3.10 #指定内核的路径
CURRENT_PATH := $(shell pwd)    #当前路径
obj-m += kernel_ioctl_demo.o    #编译kernel_ioctl_demo.c生成.ko文件

build:ioctl_module              #总目标

ioctl_module:
	$(MAKE) -C $(KERNEL_DIR) ARCH=XXX CROSS_COMPILE=XXX M=$(CURRENT_PATH) modules
    #-C [CPATH]表示make要跳转到CPATH路径执行make
    #-M [MPATH]表示执行完CPATH路径下的make后再回到MPATH继续执行剩下的
    #ARCH 指定处理器架构
    #CROSS_COMPILE 指定交叉编译器

clean:
	$(MAKE) -C $(KERNEL_DIR) M=$(CURRENT_PATH) clean

MISC 杂项设备驱动

       MISC 驱动也叫做杂项驱动，当某些外设无法进行分类的时候就可以使用 MISC 驱动。 MISC 驱动其实就是最简单的字符设备驱动，通常嵌套使用来实现复杂的驱动。

        所有的 MISC 设备驱动的主设备号都为 10，不同的设备使用不同的次设备号。 MISC 设备会自动创建 cdev，不需要像我们以前那样手动创建，因此采用 MISC 设备驱动可以简化字符设备驱动的编写。我们需要向 Linux 注册一个 miscdevice 设备， miscdevice是一个结构体，定义在文件 include/linux/miscdevice.h 中，内容如下：

struct miscdevice {
    int minor;                           // 次设备号 
    const char *name;                    // 设备名
    const struct file_operations *fops;  // 指向file_operations操作集
    struct list_head list;
    struct device *parent;
    struct device *this_device;
    const struct attribute_group **groups;
    const char *nodename;
    umode_t mode;
};

        minor 表示子设备号，需要我们指定。在linux中已经预定义了一些 MISC 设备的子设备号，这些预定义的子设备号定义在include/linux/miscdevice.h文件中，当然也可以自己定义，只要这个子设备号没有被其他设备使用接口。

//include/linux/miscdevice.h

#define PSMOUSE_MINOR 1
#define MS_BUSMOUSE_MINOR 2 /* unused */
#define ATIXL_BUSMOUSE_MINOR 3 /* unused */
#define ATARIMOUSE_MINOR 5 /* unused */
#define SUN_MOUSE_MINOR 6 /* unused */
......
#define MISC_DYNAMIC_MINOR 255

        name 就是此 MISC 设备名字，当此设备注册成功以后就会在/dev 目录下生成一个名为 name
的设备文件。

        fops 就是字符设备的操作集合， MISC 设备驱动最终是需要使用用户提供的 fops操作集合。

MISC设备注册和注销

/*                   : misc_register
 * @description      : 注册MISC杂项设备
 * @param – misc     : 要注册的 MISC 设备。
 * @return           : 0，成功，其他失败。
 */
int misc_register(struct miscdevice * misc)

/*                   : misc_deregister
 * @description      : 注销MISC杂项设备
 * @param – misc     : 要注销的 MISC 设备。
 * @return           : 0，成功，其他失败。
 */
int misc_deregister(struct miscdevice *misc)

基于杂项设备的ioctl驱动

#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/ide.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/uaccess.h>
#include <linux/device.h>
#include <linux/semaphore.h>
#include <linux/string.h>
#include <linux/miscdevice.h>

#define IOCTL_DEMO_NAME     "ioctl_demo"  /* 设备名 */

#define HELLO_OPEN          (0U)
#define HELLo_CLOSE         (1U)

/*
 * @description      : 驱动实现ioctl，获取用户态发送的cmd
 * @param – pfilp_t  : 设备文件
 * @param - cmd      : 用户态发送给内核的cmd
 * @param - arg      : 用户态发给内核的额外的参数
 * @return           : 0 成功;其他 失败
 */
long ioctl_demo_unlocked_ioctl(struct file *pfilp_t, unsigned int cmd, unsigned long arg)
{
	switch(cmd)
	{
		case HELLO_OPEN:
		{
			printk("ioctl_demo:get cmd:HELLO_OPEN from usr\n");
			break;
		}
		
		case HELLo_CLOSE:
		{
			printk("ioctl_demo:get cmd:HELLO_CLOSE from usr\n");
			break;
		}
		
		default:
		{
			printk("ioctl_demo:get cmd failure from usr\n");
			return -1;
		}
	}
	return 0;
}

/*
 * @description      : 打开设备
 * @param – inode    : 传递给驱动的 inode
 * @param - pfilp_t  : 设备文件， file 结构体有个叫做 private_data 的成员变量
 *                   一般在 open 的时候将 private_data 指向设备结构体。
 * @return           : 0 成功;其他 失败
 */
static int ioctl_demo_open(struct inode *pinode_t, struct file *pfilp_t)
{
	printk("ioctl_demo	open!\n");
	return 0;
}

/*
 * @description     : 关闭/释放设备
 * @param - pfilp_t : 要关闭的设备文件(文件描述符)
 * @return          : 0 成功;其他 失败
 */
static int ioctl_demo_release(struct inode *pinode_t, struct file *pfilp_t)
{
	
	return 0;
}

/*
 * @description      : 向设备写数据
 * @param - pfilp_t  : 设备文件，表示打开的文件描述符
 * @param - pusr_buf : 要写给设备写入的数据
 * @param - cnt      : 要写入的数据长度
 * @param - pofft_t  : 相对于文件首地址的偏移
 * @return           : 写入的字节数，如果为负值，表示写入失败
 */
static ssize_t ioctl_demo_write(struct file *pfilp_t,
								const char __user *pusr_buf,
								size_t cnt, loff_t *pofft_t)
{
	return 0;
}

/*
 * @description  : 从设备读文件
 * @param – filp : 要打开的设备文件(文件描述符)
 * @param – buf  : 返回给用户空间的数据缓冲区
 * @param – cnt  : 要读取的数据长度
 * @param – offt : 相对于文件首地址的偏移
 * @return       : 读取的字节数，如果为负值，表示读取失败
 */
static ssize_t ioctl_demo_read(struct file *filp, char __user *buf,
								size_t cnt, loff_t *offt)
{
	
	return 0;
}

static struct file_operations ioctl_demo_fops = {
	.owner = THIS_MODULE,
	.unlocked_ioctl = ioctl_demo_unlocked_ioctl,
	.open = ioctl_demo_open,
	.release = ioctl_demo_release,
	.write = ioctl_demo_write,
	.read = ioctl_demo_read,
};

static struct miscdevice ioctl_misc = {
	.minor = MISC_DYNAMIC_MINOR,
	.name = IOCTL_DEMO_NAME,
	.fops = &ioctl_demo_fops,
};

static int __init ioctl_demo_init(void)
{
	int retvalue = 0;

	retvalue = misc_register(&ioctl_misc);
	if(0 != retvalue)
	{
		printk("kernel ioctl_demo register_chrdev failure\n");
		return -1;
	}
	printk("miscdevice ioctl_demo is insmod, \n");
	return 0;
}

static void __exit ioctl_demo_exit(void)
{
	misc_deregister(&ioctl_misc);
	printk("miscdevice ioctl_demo is rmmod and deregister success\n");
}

module_init(ioctl_demo_init);
module_exit(ioctl_demo_exit);

MODULE_DESCRIPTION("a miscdevice ioctl");
MODULE_AUTHOR("lixuezhang");
MODULE_LICENSE("GPL");


 

ljl113
关注
  • 11
    点赞
  • 踩
  • 30
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
Linux用户态/内核态通信方式汇总
zhengyuchao_的博客
04-19 1113
用户态和内核态之间的通信方式主要有以下几种：系统调用（System Call）：这是最常见的方式，用户态程序通过系统调用接口（如open、read、write、fork等）请求内核执行特定的动作。系统调用是用户态和内核态之间进行交互的桥梁，它允许用户态程序请求内核提供服务。中断（Interrupts）：中断包括软中断和硬中断。当中断到来时，CPU会暂停当前执行的用户态代码，切换到内核态来处理中断。中断机制允许内核在适当的时候介入用户态程序的执行，处理一些紧急或特殊的情况。
Linux驱动入门(五)——简单的字符设备驱动程序
最新发布
m0_56145255的博客
07-09 1179
在Linux设备驱动程序的家族中，字符设备驱动程序是较为简单的驱动程序，同时也是应用非常广泛的驱动程序。所以学习字符设备驱动程序，对构建Linux设备驱动程序的知识结构非常重要。本篇博客将带领读者编写一个完整的字符设备驱动程序。
驱动与用户层通信之ioctl的使用
krokodil98的博客
01-28 2606
驱动与用户层通信之ioctl的使用一、 驱动中注册netdev二、 驱动中的处理ioctl通信的函数三、 内核中相关定义规范四、 驱动中存取ifreq中数据五、 用户层的软件代码：总结 一、 驱动中注册netdev 驱动中注册net_device_ops全局变量结构体： static const struct net_device_ops myNetDeviceOptions = { .ndo_open = ..., .ndo_stop
Ioctl()方式实现与驱动交互简洁框架
weixin_42271802的博客
06-14 1588
ioctl是linux中一种除read和write之外的数据传递机制以上函数参数的含义如下。inode和fp用来确定被操作的设备。request就是用户程序下发的命令。args就是用户程序在必要时传递的参数。在2.6.36以后ioctl函数已经不存在了，用unlocked_ioctl和compat_ioctl两个函数代替。参数去除了原来ioctl中的structinode参数，返回值也发生了改变。新的代码。
kernel ioctl操作
qq_31893087的博客
06-19 512
ioctl 有的需要参数，有的不需要参数。 比如： #define INIT_DEV _IO('g', 0) #define RESET_DEV _IOW('g', 1, int) #define READ_DEV _IOR('g', 2, int) int fd = open('/dev/g_dev', O_RDWR); (1) ioctl(fd, INIT_DEV); (2) ...
嵌入式Linux 开发经验：编写用户态应用程序 ioctl 控制 misc 设备
坚韧与专注
12-04 822
嵌入式Linux 开发经验：编写用户态应用程序 ioctl 控制 misc 设备
linux中file_operations结构体详解
android_hasen博客
10-30 3482
/** * author:hasen * 参考：《linux设备驱动开发详解》和sunsea1026的CSDN博客 * 作用：方便自己参考查阅 */ struct file_operations{ struct module *owner //第一个 file_operations 成员根本不是一个操作; 它是一个指向拥有这个结构的模块的指针. 这个成员用来在它的操作还在被使用时阻止模
linux设备驱动归纳总结（三）：4.ioctl的实现
12-24
本篇文章将深入探讨Linux设备驱动中的一个重要特性——ioctl接口的实现，这是设备驱动程序与用户空间进行复杂交互的主要手段。 ioctl（Input/Output Control）是一种特殊的I/O控制命令，允许用户空间程序对设备进行...
ZYNQ 7010-7020实现I2C通信驱动（Linux驱动）.zip
03-21
本项目提供的驱动程序主要涉及如何在Linux系统下为ZYNQ 7010-7020实现I2C通信。 I2C通信协议是一种多主控、串行、双向总线，由Philips（现NXP）在1982年推出。它只需要两根线——SDA（数据线）和SCL（时钟线）就能...
Linux驱动之i2c用户态调用.pdf
11-01
在用户空间编写I2C驱动程序时，需要包含`<linux/i2c-dev.h>`头文件，以便使用内核提供的API。 #### 2. 打开设备节点 首先，打开设备节点`/dev/i2c-x`，`x`为适配器编号。打开设备后，系统会为当前线程创建一个临时...
i.MX6ULL驱动V4L2摄像头【Linux C驱动】.zip
02-21
接着，驱动程序需要实现V4L2的ioctl接口，这是用户空间应用程序与驱动交互的主要方式。ioctl命令可以用来配置摄像头参数，如分辨率、帧率、格式等。例如，使用V4L2_IOCTL_S_FMT命令设置视频格式，V4L2_IOCTL_REQBUF...
Linux驱动之i2c用户态调用[收集].pdf
10-11
I2C驱动在Linux内核中扮演着重要的角色，使得用户空间程序能够与I2C总线上的设备进行通信。 在Linux内核的`i2c-dev.c`文件中，实现了I2C适配器的设备文件功能，为每个适配器创建一个主设备号为89的设备节点，次设备...
hello_world-3.1之增加操作函数fops(一）概念介绍
doublenian的专栏
12-15 3066
hello_world-3.1之增加操作函数fops(一）概念介绍 1.我们对常见的file_operations 进行讨论，下面是file_operations的结构体 struct file_operations { struct module *owner; loff_t (*llseek) (struct file *, loff_t, int); ssize_t
file_operations数据结构分析
weixin_30609287的博客
01-11 277
一、引言 struct file代表一个打开的文件，在执行file_operation中的open操作时被创建，这里需要注意的是与用户空间inode指针的区别，一个在内核，而file指针在用户空间，由c库来定义。 file结构体是文件系统的主要数据结构，每个file实例都包含一个指向file_operations结构体的指针，该结构保存了指向所有可能...
ioctl和内核通信传值例子
jason的专栏
01-29 697
应用层: static int write_i2c_data(unsigned char *writedata, unsigned char *returndata) {     char nm[16]; int fd, i; unsigned char data[10];     sprintf(data,"%s",writedata); snprintf(nm, 16, "/de
ioctl之用户空间与内核的通信
liangds的专栏
04-12 1471
内核部分代码 在include\uapi\linux\sockios.h文件内增加如下消息定义 #define SIOCGIFBRCM 0x8984 /* */ #define SIOCSIFBRCM 0x8985 /* */   在net\socket.c文件内增加 static DEFINE_MUTEX(brcm_ioctl_mutex); static int (*br
linux驱动学习之ioctl接口
热门推荐
fontlose的专栏
11-30 1万+
这里先用例子介绍一下ioctrl接口的使用， 应用层的ioctl函数传入的cmd和arg参数会直接传入驱动层的ioctl接口，ioctl接口的命令有一定规范详细查看ioctl-number.txt文件，这里命令的定义不在规范内，先看下面测试的例子，驱动只实现ioctrl接口并使用ioctl修改和读取内核中的一个整型参数为例，使用两个不同方式读取（值传递和地址传递）。    应用程序测试代
linux驱动ioctl数据传递机制
万波的技术博客
06-06 2520
ioctl是linux中一种除read和write之外的数据传递机制， 通信双方是应用层和内核层。 简单描述这个机制就是， 应用程序调用ioctl函数发送一个数字给内核层驱动程序 驱动程序接收到数字， 执行对应的操作。 难点： ioctl所发送的数字， 是有一定规则的， 必须符合这个规则， 驱动层才能正确解析这个数字指令。 这个数字也叫指令码 应用层的ioctl是个变参函数， 但是变参并不意味着它可以传任意多个参数进去，它的意思是第三个参数可传可不传。 既然是机制， 那么ioctl的机制如下 //
驱动使用ioctl将内核空间信息传递到用户空间
06-07
驱动使用ioctl将内核空间信息传递到用户空间的流程如下： 1. 在驱动程序中定义ioctl命令，其中包含需要传递的信息。例如： ```c #define IOCTL_GET_INFO _IOR('x', 1, struct my_info) ``` 其中，_IOR代表是从设备中读取信息，'x'代表一个唯一的驱动程序标识符，1代表命令号，struct my_info代表需要传递的信息结构体。 2. 在驱动程序中实现ioctl函数，处理用户空间传来的ioctl命令。例如： ```c static long my_ioctl(struct file *filep, unsigned int cmd, unsigned long arg) { struct my_info info; switch (cmd) { case IOCTL_GET_INFO: /* 将内核空间信息保存到info结构体中 */ info.value1 = kernel_value1; info.value2 = kernel_value2; /* 将info结构体传递给用户空间 */ if (copy_to_user((void __user *)arg, &info, sizeof(struct my_info))) return -EFAULT; break; default: return -ENOTTY; } return 0; } ``` 3. 在用户空间中使用ioctl命令读取内核空间信息。例如： ```c int fd; struct my_info info; fd = open("/dev/my_device", O_RDONLY); /* 读取内核空间信息 */ if (ioctl(fd, IOCTL_GET_INFO, &info)) return -1; /* 使用读取到的信息 */ printf("value1: %d, value2: %d\n", info.value1, info.value2); close(fd); ``` 其中，fd是设备文件描述符，/dev/my_device是设备节点路径，IOCTL_GET_INFO是ioctl命令，&info是接收信息的结构体。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值