linux kernel 中进程间描述符的传递方法及原理

PS：要转载请注明出处，本人版权所有。

PS: 这个只是基于《我自己》的理解，

如果和你的原则及想法相冲突，请谅解，勿喷。

前置说明

  本文作为本人csdn blog的主站的备份。（BlogID=082）

  本文发布于 2019-03-18 15:09:28，现用MarkDown+图床做备份更新。blog原图已丢失，使用csdn所存的图进行更新。（BlogID=082）

环境说明

  无

前言

---

  无

背景

  为啥我会去找这方面的资料总结？因为我写了一篇另外的文章:《Android匿名共享内存(Anonymous Shared Memory) --- 瞎折腾记录 (驱动程序篇)》(https://blog.csdn.net/u011728480/article/details/88420467)，写着写着到了最后，其技术核心就是描述符的进程间传递，导致了我必须得去了解这方面的大致原理。

  本文也是作为那篇文章的后续补充吧。

技术大致原理

---

  这里为啥要用“大致”一词，因为还有另外一种比较特殊的传递描述符的方法，文后将会详细说明。

  描述符 定义大致可以描述为：一个进程空间中，用一个正整数来代表一个已经被此进程打开的文件，我们可以根据这个正整数来操作这个打开文件。从这里我们可以知道，这个正整数是属于这个进程的，换句话说：不同的进程打开同一个文件的描述符是可能一样的值。

  此外这里有一个关于linux 虚拟文件系统的知识需要我们知道，一个是struct node 一个是struct file。在内核中，维护了一个所有打开文件的struct file表，这个代表着这个文件当前的操作状态等等。这个struct file指向了struct node，struct node 代表的是实际数据在存储介质上的哪个位置。换句简单的话来说就是：A和B两个进程打开了同一个文件，那么内核中就会存在一个struct file的变量指向这个打开的文件，对于AB两个进程来说，都会得到一个值可能不一致的描述符，但是这两个不同的描述符指向了内核中保存的同一个struct file变量。

  经过上面的说明，我们可以知道的是，至少传递描述符的其中一种原理就是根据当前进程fd找到内核中的struct file，然后在目标进程中申请一个未使用的描述符，然后把这个申请的描述符和这个struct file 关联起来即可。

基于kernel内核态的描述符传输

---

  在上面的原理分析中，其中根据当前进程的描述符得到当前的已经打开文件的struct file 变量，以及其他操作，这些手段都只能够在内核态实现。所以合理的方案是开发一个linux 驱动(android里面就是通过binder驱动)，让这个描述符的传递通过一个驱动来完成。这样就可以利用内核态的相关接口来完成我们的事情。下面通过示例的源码来分析一波：

通过fd获取struct file 变量

  这里我在网上查到的有两种方案（肯定还有其他方案，因为工作在内核态）：一是通过运行进程的pid和fd。二是通过内核态的文件系统提供的fget（struct file *fget(unsigned int fd)）

  第一种方案：

  进程有一个进程控制块，进程控制块中放着一个当前进程打开的描述符表，这个表指向了具体的struct file。

  linux kernel ： kernel/pid.c

/*
通过以下接口：用pid得到struct pid
*/
struct pid *find_get_pid(pid_t nr)
{
	struct pid *pid;

	rcu_read_lock();
	pid = get_pid(find_vpid(nr));
	rcu_read_unlock();

	return pid;
}
/*
通过以下接口，得到进程的控制块：struct task_struct.  (PIDTYPE_PID)
*/
struct task_struct *pid_task(struct pid *pid, enum pid_type type)
{
	struct task_struct *result = NULL;
	if (pid) {
		struct hlist_node *first;
		first = rcu_dereference_check(hlist_first_rcu(&pid->tasks[type]),
					      lockdep_tasklist_lock_is_held());
		if (first)
			result = hlist_entry(first, struct task_struct, pids[(type)].node);
	}
	return result;
}

//struct task_struct的files域指向一个struct files_struct结构体。
//struct files_struct的fdt域指向了一个struct fdtable。
//struct fdtable的fd域指向了一个已经打开的struct file 数组，通过当前描述符来作为索引。
int cur_pid;
int cur_fd;

struct pid * tmp_pid = find_get_pid(cur_pid);
struct task_struct * cur_task = pid_task(tmp_pid , PIDTYPE_PID);
struct files_struct * cur_file_struct = cur_task->files;
struct file * cur_file = cur_file_struct->fdt->fd[cur_fd];

  第二种方案：

  内核态的文件系统提供了一个更简洁的方案：

  linuxkernel: fs/file.c

struct file *fget(unsigned int fd)
{
	return __fget(fd, FMODE_PATH);
}

给目标进程获取一个未使用的描述符

  linuxkernel:fs/open.c或者fs/file.c（我这里有两个内核，linux kernel和android kernel），位置不一致是kernel版本不一致，了解一下就行了。

int get_unused_fd_flags(unsigned flags)
{
	return __alloc_fd(current->files, 0, rlimit(RLIMIT_NOFILE), flags);
}

把我们获取的未使用的描述符和我们获取的struct file 关联起来

  linuxkernel:fs/open.c或者fs/file.c（我这里有两个内核，linux kernel和android kernel），位置不一致是kernel版本不一致，了解一下就行了。

void fastcall fd_install(unsigned int fd, struct file * file)
{
	struct files_struct *files = current->files;
	struct fdtable *fdt;
	spin_lock(&files->file_lock);
	fdt = files_fdtable(files);
	BUG_ON(fdt->fd[fd] != NULL);
	rcu_assign_pointer(fdt->fd[fd], file);
	spin_unlock(&files->file_lock);
}

基于用户态的描述符传输

---

  这个是在AUPE中发现的。貌似以前设计内核的人就预留了这个功能，利用unix的本地socket的一个特殊功能即可。这里用到的调用是以下两个：

  就是建立一个本地socket(AF_LOCAL,AF_UNIX)，然后通过以下两个接口的特殊功能即可完成描述符的特殊转换。这里我不做过多介绍，有兴趣的看文后的实例。

ssize_t sendmsg(int sockfd, const struct msghdr *msg, int flags);
ssize_t recvmsg(int sockfd, struct msghdr *msg, int flags);

实例分析

---

用户态实例

  userspace_way1_send.c

#include <stdio.h>
#include <sys/un.h>
#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>

int main(int argc, char * argv[]){

	struct sockaddr_un addr, addr1;

	int fd;
	if ( 0 > (fd = socket(AF_LOCAL, SOCK_STREAM, 0)) ){

		perror("socket()");
		return -1;
	}
	unlink("tmp.tmp");

	bzero(&addr, sizeof(struct sockaddr_un));
	bzero(&addr1, sizeof(struct sockaddr_un));

	addr.sun_family = AF_LOCAL;

	strncpy(addr.sun_path, "tmp.tmp", sizeof(addr.sun_path)-1);

	socklen_t addr_len = sizeof(struct sockaddr_un);

	int ret;
	if ( 0 > (ret = bind(fd, (struct sockaddr *) & addr, addr_len ))){

		perror("bind()");
		return -1;
	}

	if ( 0 > (ret = listen(fd, 3)) ){

		perror("listen()");
		return -1;
	}

	socklen_t addr1_len = sizeof(struct sockaddr_un);

	int ret_fd;
	if ( 0 > ( ret_fd = accept(fd, (struct sockaddr *)&addr1, &addr1_len))){

		perror("accept()");
		return -1;
	}

	int open_file_fd;
	if ( 0 > (open_file_fd = open("test.txt", O_RDWR))){

		perror("open()");
		return -1;
	}
	char file_content [100] = {0x00};
	int read_bytes_num = read(open_file_fd, file_content, 99);
	printf("read file content: %s\n", file_content);

	char * flags = "@!@";
	struct iovec iov = {

		.iov_base = flags,
		.iov_len = 3
	};

	union {

		struct cmsghdr cm;
		char control[CMSG_SPACE(sizeof(int))];

	}control_un;

	struct msghdr msg = {

		.msg_name = NULL,
		.msg_namelen = 0,
		.msg_iov = &iov,
		.msg_iovlen = 1,
		.msg_flags = 0,
		.msg_control = control_un.control,
		.msg_controllen = sizeof(control_un.control)
	};

	struct cmsghdr *cmsg = CMSG_FIRSTHDR(&msg);

	cmsg->cmsg_len = CMSG_LEN(sizeof(int));
	cmsg->cmsg_level = SOL_SOCKET;
	cmsg->cmsg_type = SCM_RIGHTS;

	*((int*)CMSG_DATA(cmsg)) = open_file_fd;

	if ( 0 > (ret = sendmsg(ret_fd, &msg, 0))){

		perror("sendmsg()");
		return -1;
	}
	close(open_file_fd);
	close(fd);
	return 0;
}

  userspace_way1_recv.c

#include <stdio.h>
#include <sys/un.h>
#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>

int main(int argc, char * argv[]){

	struct sockaddr_un addr, addr1;

	bzero(&addr, sizeof(struct sockaddr_un));

	addr.sun_family = AF_LOCAL;

	strncpy(addr.sun_path, "tmp.tmp", sizeof(addr.sun_path)-1);

	socklen_t addr_len = sizeof(struct sockaddr_un);

	int fd = socket(AF_LOCAL, SOCK_STREAM, 0);
	if ( fd < 0 ) {

		perror("socket() error");
		return -1;
	}
	int con_ret = connect(fd, (struct sockaddr *)&addr, addr_len);
	if ( con_ret < 0 ) {

		perror("connect() error");
		return -1;
	}

	//char * flags = "@!@";
	char  flags[3] ;
	struct iovec iov = {

		.iov_base = flags,
		.iov_len = 3
	};

	union {

		struct cmsghdr cm;
		char control[CMSG_SPACE(sizeof(int))];

	}control_un;

	struct msghdr msg = {

		.msg_name = NULL,
		.msg_namelen = 0,
		.msg_iov = &iov,
		.msg_iovlen = 1,
		.msg_flags = 0,
		.msg_control = control_un.control,
		.msg_controllen = sizeof(control_un.control)
	};

	struct cmsghdr *cmsg = CMSG_FIRSTHDR(&msg);

	cmsg->cmsg_len = CMSG_LEN(sizeof(int));
	cmsg->cmsg_level = SOL_SOCKET;
	cmsg->cmsg_type = SCM_RIGHTS;

	*((int*)CMSG_DATA(cmsg)) = -1;

	int ret_recv;
	if ( 0  > (ret_recv = recvmsg(fd, &msg, 0) )){

		perror("recvmsg()");
		return -1;
	}

	int open_file_fd = *((int*)CMSG_DATA(cmsg));

	int ret = lseek(open_file_fd, 0, SEEK_SET);

	if ( 0 > ret ){

		perror("lseek()");
	}	

	char file_content [100] = {0x00};
	int read_bytes_num;
	if ( 0 > (read_bytes_num = read(open_file_fd, file_content, 99) )){

		perror("read()");
		return -1;
	}
	else if ( 0 == read_bytes_num ){

		printf("read EOF\n");
	}

	printf("read file content: %s, fd is %d \n", file_content, open_file_fd);

	close(open_file_fd);
	close(fd);
	return 0;
}

  运行截图：(send_way1 发送，recv_way1接收，注意文件指针的重置，否则接收者打印的内容为空)

内核态实例

  建立一个trans_fd_drv驱动，然后操作驱动完成不同进程间描述符的转换。

  测试环境：

• Ubuntu 18.04
• Linux 4.15.0-46-generic #49-Ubuntu SMP Wed Feb 6 09:33:07 UTC 2019 x86_64 x86_64 x86_64 GNU/Linux

  驱动源码

  transmisson_fd_driver.c

#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/cdev.h> //struct cdev
#include <linux/fs.h>//struct file_operations
#include <linux/errno.h>
#include <linux/device.h>
#include <asm/uaccess.h>
#include <linux/file.h>

static struct class * ptr_cur_class;

MODULE_LICENSE("GPL");

static struct cdev  _cur_cdev;
static dev_t _cur_dev; 

struct file * ptr_trans_file = NULL;

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

	return 0;
}

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

	return 0;
}

static long drv_ioctl(struct file *filp, unsigned int cmd, unsigned long arg){

	switch(cmd){

		case 0:{//get data

			int get_fd = arg;

			ptr_trans_file = fget(get_fd);
			break;
		}
		case 1:{//set data

			int unused_fd = get_unused_fd_flags(0);
			fd_install(unused_fd, ptr_trans_file);
			__put_user(unused_fd, (int __user *)arg);
			break;
		}
		default:
			printk(KERN_ERR "drv_ioctl cmd error ......");
			break;
	}
	return 0;
}

static struct file_operations fops = {

	.owner = THIS_MODULE,
	.open  = drv_open,
	.release = drv_release,
	.unlocked_ioctl = drv_ioctl
}; 

static int __init trans_fd_drv_init(void)
{ 

    printk(KERN_ERR "trans_fd_drv initing ......");

//void cdev_init(struct cdev *p, const struct file_operations *p);　
    cdev_init(&_cur_cdev, &fops);

//int alloc_chrdev_region(dev_t *dev, unsigned baseminor, unsigned count, const char *name);
    int ret = alloc_chrdev_region((dev_t *)&_cur_dev, 0, 1, "trans_fd_drv");
    if ( ret < 0 ){

	printk(KERN_ERR "alloc_chrdev_region error");
	return -1;
    }
//int cdev_add(struct cdev *p, dev_t dev, unsigned count);
    dev_t major = MAJOR(_cur_dev);
    ret = cdev_add(&_cur_cdev, _cur_dev, 1);

    if ( ret < 0 ){

	printk(KERN_ERR "cdev_add error");
	return -1;
    }

    ptr_cur_class = class_create(THIS_MODULE, "trans_fd_drv");
    device_create(ptr_cur_class, NULL, _cur_dev, NULL, "trans_fd_drv");

    return 0;

}

static void __exit trans_fd_drv_exit(void)
{

	//void device_destroy(struct class *cls, dev_t devt);
	device_destroy(ptr_cur_class, _cur_dev);

	//void class_destroy(struct class *cls);
	class_destroy(ptr_cur_class);  

    //get command and pid
    printk(KERN_ERR "trans_fd_drv exiting ......");
//void unregister_chrdev_region(dev_t from, unsigned count);
    unregister_chrdev_region(_cur_dev, 1);

//void cdev_del(struct cdev *p);
    cdev_del(&_cur_cdev);
}

module_init(trans_fd_drv_init);
module_exit(trans_fd_drv_exit);

  操作驱动源码

  send_fd_from_drv.c

#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
int main(int argc, char * argv[]){

	int fd;
	if ( 0 > (fd = open("/dev/trans_fd_drv", O_RDWR)) ){

		perror("open()");
		return -1;
	}
	int show_file_fd;
	if ( 0 > (show_file_fd = open("test.txt", O_RDWR)) ){

		perror("open()");
		return -1;
	}

	char file_content [100] = {0x00};
	int read_bytes_num = read(show_file_fd, file_content, 99);
	printf("read file content: %s\n", file_content);

	int ret = 0;
	if ( 0 > (ret = ioctl(fd, 0, show_file_fd)) ){

		perror("ioctl()");
		return -1;
	}
	close(fd);
	close(show_file_fd);
	return 0;
}

  recv_fd_from_drv.c

#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
int main(int argc, char * argv[]){

	int fd;
	if ( 0 > (fd = open("/dev/trans_fd_drv", O_RDWR)) ){

		perror("open()");
		return -1;
	}
	int show_file_fd;
	int ret = 0;
	if ( 0 > (ret = ioctl(fd, 1, &show_file_fd)) ){

		perror("ioctl()");
		return -1;
	}

	int ret = lseek(show_file_fd, 0, SEEK_SET);

	if ( 0 > ret ){

		perror("lseek()");
		return -1;
	}	

	char file_content [100] = {0x00};
	int read_bytes_num = read(show_file_fd, file_content, 99);
	printf("read file content: %s\n", file_content);

	close(fd);
	close(show_file_fd);
	return 0;
}

  测试截图

后记

---

  总结

1. 使自己对用户态和内核态的理解更加的深刻。
2. 通过实现一个驱动的方式来直接操作内核态内容，这是一个不错的idea。
3. 我发现，很多时候只有亲自动手来试试，才能实际体会到成就感。
4. 不折腾，怎么能够进步。

  注意：这里关于描述符的转换可以是任意描述符，不一定要是文件描述符（网络描述符等等都可以转换，因为linux的设计原则是：一切皆是文件。有vfs的存在，很多操作都被接口化了。）。

  如果有需求：本文所有测试代码可在这里下载（不建议下载，除了makefile我都把代码全部贴出来了的，csdn的积分我没有找到怎么编辑，默认要5分）：https://download.csdn.net/download/u011728480/11033121

参考文献

• 无

---

打赏、订阅、收藏、丢香蕉、硬币，请关注公众号（攻城狮的搬砖之路）

PS: 请尊重原创，不喜勿喷。

PS: 要转载请注明出处，本人版权所有。

PS: 有问题请留言，看到后我会第一时间回复。