06_應用層和核心層實現資料互動

爱吃冰激凌的黄某某發表於2024-04-22

應用層和核心層實現資料互動

Linux一切皆檔案！

檔案對應的操作有開啟，關閉，讀寫

裝置節點對應的操作有開啟，關閉，讀寫

裝置節點

​ 在 Linux 中， 所有裝置都以檔案的形式存放在/dev 目錄下， 都是透過檔案的方式進行訪問， 裝置節點是
Linux 核心對裝置的抽象， 一個裝置節點就是一個檔案。 應用程式透過一組標準化的呼叫執行訪問裝置， 這
些呼叫獨立於任何特定的驅動程式。 而驅動程式負責將這些標準呼叫對映到實際硬體的特有操作。

file_operations 結構體是訪問驅動的函式， 它的裡面的每個結構體成員都對應一個呼叫， 這個結構體裡
面有很多的成員變數， 並且結構體中的成員函式是字元裝置驅動程式設計的主體內容， 這些函式實際會在
應用程式進行 Linux 的 open（） 、 write（） 、 read（） 、 close（） 等系統呼叫時最終被核心呼叫。

struct file_operations {
	struct module *owner;
	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 *);
	long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
	long (*compat_ioctl) (struct file *, unsigned int, unsigned long);
	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 *);
	int (*fsync) (struct file *, loff_t, loff_t, int datasync);
	int (*aio_fsync) (struct kiocb *, int datasync);
	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
};

1.如果我在應用層使用系統IO對裝置節點進行開啟，關閉，讀寫等操作會發生什麼呢？

當我們在應用層read裝置節點的時候，就會觸發我們驅動裡面read這個函式。

​ ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);

當我們在應用層write裝置節點的時候，就會觸發我們驅動裡面write這個函式。

ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);

當我們在應用層poll/select的時候，就會觸發我們驅動裡面poll這個函式。

unsigned int (*poll) (struct file *, struct poll_table_struct *);

當我們在應用層ioctl的時候，就會觸發我們驅動裡面ioctl這個函式。

long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);

當我們在應用層open的時候，就會觸發我們驅動裡面open這個函式。

int (*open) (struct inode *, struct file *);

當我們在應用層close的時候，就會觸發我們驅動裡面release這個函式。

int (*release) (struct inode *, struct file *);

image-20240420225032539

透過框圖我們可以知道：

上層應用 裝置節點 底層驅動

裝置節點就是連線上層應用和底層驅動的橋樑

2 假如我們的file_operations 裡面沒有read，我們在應用層read裝置節點的時候會發生什麼？

什麼也不會發生，也不會報錯！

3 我們的應用層和核心層是不能直接進行資料傳輸的。

image-20240420231250993

應用層向核心層傳遞資料:

標頭檔案:

#include <linux/uaccess.h>

static inline long copy_from_user(void *to, const void __user * from, unsigned long n)

image-20240420231301834

image-20240420231327954

核心層嚮應用層傳遞資料:

static inline long copy_to_user(void __user *to, const void *from, unsigned long n)

image-20240420231335694

例項

app.c

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

int main(int argc, const char *argv[])
{
    int fd;
    char buf[64] = {0};
    fd = open("/dev/hello_mise", O_RDWR);
    if (fd < 0)
    {
        perror("open error\n");
        return fd;
    }
    write(fd, buf, strlen(buf) + 1);
    read(fd, buf, sizeof(buf));
    printf("buf is %s\n", buf);
    close(fd);
    return 0;
}

file_operations.c

#include<linux/init.h>
#include<linux/module.h>
#include<linux/miscdevice.h>
#include<linux/fs.h>
#include <linux/uaccess.h>

int misc_open(struct inode *inode, struct file *file)
{
    printk("hello misc_open\n");
    return 0;
}

int misc_release(struct inode *inode, struct file *file)
{
    printk("hello mise_release bye bye\n");
    return 0;
}

ssize_t misc_read(struct file *file, char __user *ubuf, size_t size, loff_t *loff_t)
{
    char kbuf[64]="heheh";
    if(copy_to_user(ubuf, kbuf, strlen(kbuf)+1) != 0)
    {
        printk("copy_to_user error\n");
        return -1;
    }
    printk("hello misc_read bye bye\n");
    return 0;
}

ssize_t misc_write(struct file *file, const char __user *ubuf, size_t size, loff_t *loff_t)
{
    char kbuf[64]={0};
    if(copy_from_user(kbuf, ubuf, size) != 0)
    {
        printk("copy_from_user error\n");
        return -1;
    }
    printk("hello misc_write bye bye\n");
    return 0;
}

/* 檔案操作集 */
struct file_operations misc_fops = {
    .owner = THIS_MODULE, //當前模組
    .open = misc_open,
    .release = misc_release,
    .write = misc_write,
    .read = misc_read,
};

/* 雜項裝置結構體 */
struct miscdevice misc_dev = {
    .minor = MISC_DYNAMIC_MINOR, //動態分配次裝置號
    .name = "hello_mise", //裝置節點的名字
    .fops = &misc_fops //檔案操作集
    
};

static int mise_init(void)
{
    int ret;
    ret = misc_register(&misc_dev); //註冊雜項裝置
    if(ret < 0)
    {
        printk("misc register is error!\n");
        return -1;
    }
    printk("mise register is ok!\n");
    return 0;
}

static void mise_exit(void)
{
    misc_deregister(&misc_dev); //登出雜項裝置
    printk("misc gooodbye!\n");
}

module_init(mise_init);
module_exit(mise_exit);

MODULE_LICENSE("GPL");

Makefile

obj-m+=file_operations.o
KDIR:=/home/mzx/imx6ull/linux-imx-rel_imx_4.1.15_2.1.0_ga 
PWD?=$(shell pwd)

all:
	make -C $(KDIR) M=$(PWD) modules

相關文章