Android内核之Binder读写通信:binder_ioctl_write

简介： CSDN博客专家，专注Android/Linux系统，分享多mic语音方案、音视频、编解码等技术，与大家一起成长！

优质专栏：Audio工程师进阶系列【原创干货持续更新中……】🚀
优质专栏：多媒体系统工程师系列【原创干货持续更新中……】🚀
优质视频课程：AAOS车载系统+AOSP14系统攻城狮入门实战课【原创干货持续更新中……】🚀

人生格言： 人生从来没有捷径，只有行动才是治疗恐惧和懒惰的唯一良药.

更多原创,欢迎关注：Android系统攻城狮

欢迎关注Android系统攻城狮

🍉🍉🍉文章目录🍉🍉🍉

- 🌻1.前言
- 🌻2.Android内核之binder_ioctl_write_read介绍
- 🌻3.代码实例
- - 🐓3.1 发送Binder消息
  - 🐓3.2 接收Binder消息
  - 🐓3.3 Binder事件通知

🌻1.前言

本篇目的：Android内核之IPC通信:binder_ioctl_write_read用法实例

🌻2.Android内核之binder_ioctl_write_read介绍

binder_ioctl_write_read是Android系统中Binder驱动的关键函数之一，用于在用户空间和内核空间之间进行进程间通信（IPC）。Android的Binder机制是一种高效的IPC机制，用于在Android系统中进行进程间通信，特别是在应用程序和系统服务之间。
该函数的主要作用是通过ioctl系统调用在用户空间和内核空间之间传递数据。在Binder中，进程可以通过Binder节点向Binder驱动发送请求消息，而Binder驱动负责将这些消息传递到目标进程。在内核空间中，这些请求消息和响应消息被表示为数据结构，并通过binder_ioctl_write_read函数进行读写。
具体而言，binder_ioctl_write_read函数的作用包括：

消息传递： 通过该函数，应用程序可以向Binder驱动发送请求消息，例如调用远程服务的请求或发送数据给其他进程。
数据交换： 该函数允许应用程序和内核空间之间交换数据，实现进程间通信。数据可以是任何形式的信息，如函数调用、参数、返回值等。
事件通知： Binder机制还支持事件通知，例如进程间的状态变化或系统服务的可用性。binder_ioctl_write_read函数可以用于发送和接收这些事件通知。
错误处理： 除了消息传递外，该函数还负责处理可能发生的错误情况。例如，当发送消息失败或接收到无效的消息时，函数会返回相应的错误码，应用程序可以据此进行错误处理。

使用binder_ioctl_write_read函数需要一定的内核编程知识和经验。开发者需要了解Binder驱动的工作原理以及消息传递的机制，同时要熟悉ioctl系统调用的使用方法。在实际开发中，通常会使用高级别的API和框架来进行Binder通信，这些API和框架会封装底层的细节，简化开发过程。
binder_ioctl_write_read函数在Android系统中扮演着至关重要的角色，它为应用程序提供了一种强大的IPC机制，支持应用程序之间和应用程序与系统服务之间的通信，促进了Android系统的功能丰富和性能优化。

🌻3.代码实例

🐓3.1 发送Binder消息

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/uaccess.h>
#include <linux/android/binder.h>

#define DEVICE_NAME "binder_example"
#define BINDER_DEV_PATH "/dev/binder_example"

static int major_number;
static struct class *binder_class = NULL;
static struct device *binder_device = NULL;

// 打开Binder设备
static int binder_open(struct inode *inode, struct file *file) {
    printk(KERN_INFO "Binder device opened\n");
    return 0;
}

// 释放Binder设备
static int binder_release(struct inode *inode, struct file *file) {
    printk(KERN_INFO "Binder device closed\n");
    return 0;
}

// 实现Binder设备的ioctl操作
static long binder_ioctl(struct file *file, unsigned int cmd, unsigned long arg) {
    int ret = 0;
    struct binder_write_read bwr;

    switch (cmd) {
        case BINDER_SEND_MESSAGE:
            // 发送Binder消息
            // 在这里构造消息数据，并使用binder_ioctl_write_read发送消息
            break;
        default:
            printk(KERN_ERR "Unknown command\n");
            ret = -EINVAL;
            break;
    }

    return ret;
}

// 初始化Binder设备
static int __init binder_init(void) {
    // 分配主设备号
    major_number = register_chrdev(0, DEVICE_NAME, &binder_fops);
    if (major_number < 0) {
        printk(KERN_ALERT "Failed to register a major number\n");
        return major_number;
    }

    // 创建设备类
    binder_class = class_create(THIS_MODULE, DEVICE_NAME);
    if (IS_ERR(binder_class)) {
        unregister_chrdev(major_number, DEVICE_NAME);
        printk(KERN_ALERT "Failed to register device class\n");
        return PTR_ERR(binder_class);
    }

    // 创建设备节点
    binder_device = device_create(binder_class, NULL, MKDEV(major_number, 0), NULL, DEVICE_NAME);
    if (IS_ERR(binder_device)) {
        class_destroy(binder_class);
        unregister_chrdev(major_number, DEVICE_NAME);
        printk(KERN_ALERT "Failed to create the device\n");
        return PTR_ERR(binder_device);
    }

    printk(KERN_INFO "Binder module initialized\n");
    return 0;
}

// 卸载Binder设备
static void __exit binder_exit(void) {
    device_destroy(binder_class, MKDEV(major_number, 0));
    class_unregister(binder_class);
    class_destroy(binder_class);
    unregister_chrdev(major_number, DEVICE_NAME);
    printk(KERN_INFO "Binder module exit\n");
}

module_init(binder_init);
module_exit(binder_exit);
MODULE_LICENSE("GPL");

🐓3.2 接收Binder消息

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/uaccess.h>
#include <linux/android/binder.h>

#define DEVICE_NAME "binder_example"
#define BINDER_DEV_PATH "/dev/binder_example"

static int major_number;
static struct class *binder_class = NULL;
static struct device *binder_device = NULL;

// 打开Binder设备
static int binder_open(struct inode *inode, struct file *file) {
    printk(KERN_INFO "Binder device opened\n");
    return 0;
}

// 释放Binder设备
static int binder_release(struct inode *inode, struct file *file) {
    printk(KERN_INFO "Binder device closed\n");
    return 0;
}

// 实现Binder设备的ioctl操作
static long binder_ioctl(struct file *file, unsigned int cmd, unsigned long arg) {
    int ret = 0;
    struct binder_write_read bwr;

    switch (cmd) {
        case BINDER_RECEIVE_MESSAGE:
            // 接收Binder消息
            // 在这里构造消息数据，并使用binder_ioctl_write_read接收消息
            break;
        default:
            printk(KERN_ERR "Unknown command\n");
            ret = -EINVAL;
            break;
    }

    return ret;
}

// 初始化Binder设备
static int __init binder_init(void) {
    // 分配主设备号
    major_number = register_chrdev(0, DEVICE_NAME, &binder_fops);
    if (major_number < 0) {
        printk(KERN_ALERT "Failed to register a major number\n");
        return major_number;
    }

    // 创建设备类
    binder_class = class_create(THIS_MODULE, DEVICE_NAME);
    if (IS_ERR(binder_class)) {
        unregister_chrdev(major_number, DEVICE_NAME);
        printk(KERN_ALERT "Failed to register device class\n");
        return PTR_ERR(binder_class);
    }

    // 创建设备节点
    binder_device = device_create(binder_class, NULL, MKDEV(major_number, 0), NULL, DEVICE_NAME);
    if (IS_ERR(binder_device)) {
        class_destroy(binder_class);
        unregister_chrdev(major_number, DEVICE_NAME);
        printk(KERN_ALERT "Failed to create the device\n");
        return PTR_ERR(binder_device);
    }

    printk(KERN_INFO "Binder module initialized\n");
    return 0;
}

// 卸载Binder设备
static void __exit binder_exit(void) {
    device_destroy(binder_class, MKDEV(major_number, 0));
    class_unregister(binder_class);
    class_destroy(binder_class);
    unregister_chrdev(major_number, DEVICE_NAME);
    printk(KERN_INFO "Binder module exit\n");
}

module_init(binder_init);
module_exit(binder_exit);
MODULE_LICENSE("GPL");

🐓3.3 Binder事件通知

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/uaccess.h>
#include <linux/android/binder.h>

#define DEVICE_NAME "binder_example"
#define BINDER_DEV_PATH "/dev/binder_example"

static int major_number;
static struct class *binder_class = NULL;
static struct device *binder_device = NULL;

// 打开Binder设备
static int binder_open(struct inode *inode, struct file *file) {
    printk(KERN_INFO "Binder device opened\n");
    return 0;
}

// 释放Binder设备
static int binder_release(struct inode *inode, struct file *file) {
    printk(KERN_INFO "Binder device closed\n");
    return 0;
}

// 实现Binder设备的ioctl操作
static long binder_ioctl(struct file *file, unsigned int cmd, unsigned long arg) {
    int ret = 0;
    struct binder_write_read bwr;

    switch (cmd) {
        case BINDER_RECEIVE_EVENT:
            // 接收Binder事件通知
            // 在这里构造事件数据，并使用binder_ioctl_write_read接收事件
            break;
        default:
            printk(KERN_ERR "Unknown command\n");
            ret = -EINVAL;
            break;
    }

    return ret;
}

// 初始化Binder设备
static int __init binder_init(void) {
    // 分配主设备号
    major_number = register_chrdev(0, DEVICE_NAME, &binder_fops);
    if (major_number < 0) {
        printk(KERN_ALERT "Failed to register a major number\n");
        return major_number;
    }

    // 创建设备类
    binder_class = class_create(THIS_MODULE, DEVICE_NAME);
    if (IS_ERR(binder_class)) {
        unregister_chrdev(major_number, DEVICE_NAME);
        printk(KERN_ALERT "Failed to register device class\n");
        return PTR_ERR(binder_class);
    }

    // 创建设备节点
    binder_device = device_create(binder_class, NULL, MKDEV(major_number, 0), NULL, DEVICE_NAME);
    if (IS_ERR(binder_device)) {
        class_destroy(binder_class);
        unregister_chrdev(major_number, DEVICE_NAME);
        printk(KERN_ALERT "Failed to create the device\n");
        return PTR_ERR(binder_device);
    }

    printk(KERN_INFO "Binder module initialized\n");
    return 0;
}

// 卸载Binder设备
static void __exit binder_exit(void) {
    device_destroy(binder_class, MKDEV(major_number, 0));
    class_unregister(binder_class);
    class_destroy(binder_class);
    unregister_chrdev(major_number, DEVICE_NAME);
    printk(KERN_INFO "Binder module exit\n");
}

module_init(binder_init);
module_exit(binder_exit);
MODULE_LICENSE("GPL");