创建内核线程并通过内核线程调用用户态程序

最新推荐文章于 2023-03-02 17:28:22 发布
最新推荐文章于 2023-03-02 17:28:22 发布
阅读量720 收藏 1
点赞数
分类专栏： LINUNX KERNEL Linux 文章标签： usermodehelper 内核调用用户态程序 kern_table 内核线程示例
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Longyu_wlz/article/details/107435452
版权

创建内核线程并通过内核线程调用用户态程序

这里使用的内核为 linux-4.0 内核。

patch 贴到这里。

diff --git a/./linux-4.0-orig/linux-4.0/init/main.c b/./linux-4.0/init/main.c
index 6f0f1c5..88837d9 100644
--- a/./linux-4.0-orig/linux-4.0/init/main.c
+++ b/./linux-4.0/init/main.c
@@ -379,6 +379,69 @@ static void __init setup_command_line(char *command_line)
 
 static __initdata DECLARE_COMPLETION(kthreadd_done);
 
+
+static int mykthread_run_umode_handler(int event_id)
+{
+    char *argv[3], *envp[4], *buffer = NULL;
+    int i = 0, value;
+
+	 argv[i++] = myevent_handler;
+
+	 if (!(buffer = kmalloc(32, GFP_KERNEL)))
+		return -ENOMEM;
+
+	 sprintf(buffer, "TROUBLED_DS=%d", event_id);
+
+	 if (!argv[0])
+		return -EINVAL;
+
+	 argv[i] = NULL;
+
+	 i = 0;
+
+    /* minimal command environment */
+    envp[i++] = "HOME=/";
+    envp[i++] = "PATH=/sbin:/bin:/usr/sbin:/usr/bin";
+	 envp[i++] = buffer;
+	 envp[i] = NULL;
+
+    value = call_usermodehelper(argv[0], argv, envp, 0);
+
+	 kfree(buffer);
+    return 0;
+}
+
+static int mykthread(void *unused)
+{
+	 int sigusr_count = 0;
+	
+	/* Setup a clean context for our children to inherit. */
+	set_task_comm(current, "mykthread");
+
+	/* Request delivery of SIGKILL */
+
+	/* The  thread sleeps on this wait queue until it's woken up
+	 * by parts of the kernel in charge of sensing the health of
+ 	  * data structures of i nterest */
+	
+ 	while (1) {
+		set_current_state(TASK_INTERRUPTIBLE);
+		schedule();
+
+		if (signal_pending(current)) {
+			flush_signals(current);
+			sigusr_count++;
+	 	}
+		mykthread_run_umode_handler(sigusr_count);
+	} 
+	
+	set_current_state(TASK_RUNNING);	
+	
+	return 0;
+}
+
 static noinline void __init_refok rest_init(void)
 {
 	int pid;
@@ -392,6 +455,7 @@ static noinline void __init_refok rest_init(void)
 	kernel_thread(kernel_init, NULL, CLONE_FS);
 	numa_default_policy();
 	pid = kernel_thread(kthreadd, NULL, CLONE_FS | CLONE_FILES);
+	kernel_thread(mykthread, NULL, CLONE_FS | CLONE_FILES); 
 	rcu_read_lock();
 	kthreadd_task = find_task_by_pid_ns(pid, &init_pid_ns);
 	rcu_read_unlock();
diff --git a/./linux-4.0-orig/linux-4.0/include/linux/sysctl.h b/./linux-4.0/include/linux/sysctl.h
index b7361f8..7fc854e 100644
--- a/./linux-4.0-orig/linux-4.0/include/linux/sysctl.h
+++ b/./linux-4.0/include/linux/sysctl.h
@@ -34,6 +34,8 @@ struct ctl_table_root;
 struct ctl_table_header;
 struct ctl_dir;
 
+extern char myevent_handler[];
+
 typedef int proc_handler (struct ctl_table *ctl, int write,
 			  void __user *buffer, size_t *lenp, loff_t *ppos);
 
diff --git a/./linux-4.0-orig/linux-4.0/kernel/sysctl.c b/./linux-4.0/kernel/sysctl.c
index ce410bb..e02e8b0 100644
--- a/./linux-4.0-orig/linux-4.0/kernel/sysctl.c
+++ b/./linux-4.0/kernel/sysctl.c
@@ -95,6 +95,10 @@
 
 #if defined(CONFIG_SYSCTL)
 
+
+char myevent_handler[256];
+EXPORT_SYMBOL(myevent_handler);
+
 /* External variables not in a header file. */
 extern int max_threads;
 extern int suid_dumpable;
@@ -724,6 +728,13 @@ static struct ctl_table kern_table[] = {
 		.mode		= 0555,
 		.child		= usermodehelper_table,
 	},
+        {
+         .procname = "myevent_handler",
+         .data = &myevent_handler,
+         .maxlen = 256,
+         .mode = 0644,
+         .proc_handler = &proc_dostring,
+        },
 	{
 		.procname	= "overflowuid",
 		.data		= &overflowuid,

kern_table 中添加的表项中，.data 指向的是一块内存区域，myevent_handler 是一个静态数组，用来存储 handler 的命令名称。

原书中的代码存在以下几个问题：

  1. waitqueue 暂时不知道咋样测试，就用信号来搞

  2. 接收到信号后要调用 flush_signals() 来清除 task struct 中的标志字段，不然会一直触发

  3. flush_signals 函数调用前获取 sighand 自旋锁会卡死，应该是此时自旋锁已经被占用

  4. 不需要执行 signal_allow 来显示的使能信号，调用 sigismember 宏判断的时候会失败

  5. 当内核线程直接返回时，有如下 oops 信息。

    / # kill -9 3
task sighand blocked
task sighand unblocked
out
kthread mykthread exited
Unable to handle kernel NULL pointer dereference at virtual address 00000000
pgd = 80004000
[00000000] *pgd=00000000
Internal error: Oops: 80000017 [#1] SMP ARM
Modules linked in:
CPU: 0 PID: 3 Comm: mykthread Not tainted 4.0.0 #30
Hardware name: ARM-Versatile Express
task: 8c048980 ti: 8c05e000 task.ti: 8c05e000
PC is at 0x0
LR is at 0x0
pc : [<00000000>]    lr : [<00000000>]    psr: 00000013
sp : 8c05fff8  ip : 00000000  fp : 00000000
r10: 00000000  r9 : 00000000  r8 : 00000000
r7 : 00000000  r6 : 00000000  r5 : 00000000  r4 : 00000000
r3 : 00000000  r2 : 00000000  r1 : 00000000  r0 : 00000000
Flags: nzcv  IRQs on  FIQs on  Mode SVC_32  ISA ARM  Segment kernel
Control: 10c5387d  Table: 6c21806a  DAC: 00000015
Process mykthread (pid: 3, stack limit = 0x8c05e210)
Stack: (0x8c05fff8 to 0x8c060000)
ffe0:                                                       00000000 00000000
Code: bad PC value
[ end trace c752e7bdfd2aa50f ]

网上搜索的网页描述内核线程直接返回应该是正常的，在内核源码中没有搜索到线程退出的代码。

内核应该是监控某种事件或数据结构，当出现问题时，唤醒 mykthread 内核线程来调用用户态程序通知用户。这里直接以信号的形式触发事件来模拟。

原书代码要实现的逻辑如下：

  1. 在 mykthread 中创建一个 waitqueue，挂起此内核线程等待事件发生

  2. 当事件发生后，在另外的地方调用 wake_up_interruptible(&myevent_waitqueue); 来唤醒 mykthread 内核线程以调用用户态程序通知用户。

修改内核线程，在收到信号后主动调用 do_exit(0) 来退出，测试发现这种情况下不会产生 oops 但是线程退出后变为了 Zombie 进程，这应该是没有父进程的原因。在 kthreadd 中没有看到这个 do_exit(0); 的调用，其实 kthreadd 自从创建后就不会退出。

内核调用用户态程序示例

网上搜索到，除了修改 sysctl.c 来注册一个用户态 hepler 钩子之外，还可以动态的注册，相关的 demo 程序如下：

#include <linux/wait.h>
#include <linux/kmod.h>
#include <linux/module.h>
#include <linux/slab.h>

#define CMD_LENGTH 256

static char cmd_str[CMD_LENGTH];

static struct ctl_table_header *ctl_table_header;

static struct ctl_table ctl_table[] = {
    {
     .procname = "umode_helper",
     .data = cmd_str,
     .maxlen = sizeof(cmd_str),
     .mode = 0644,
     .proc_handler = proc_dostring,
     },
    {},
};

static int run_umode_handler_example(int arg)
{
    char *argv[3], *envp[4], *buffer = NULL;
    int i = 0, value;
	
	argv[i++] = cmd_str;
	
	if (!(buffer = kmalloc(32, GFP_KERNEL)))
		return -ENOMEM;

	sprintf(buffer, "TEST_VARIABLE=%s", "hello");
	
	if (!argv[0])
		return -EINVAL;

	argv[i] = NULL;

	i = 0;

    /* minimal command environment */
    envp[i++] = "HOME=/";
    envp[i++] = "PATH=/sbin:/bin:/usr/sbin:/usr/bin";
	envp[i++] = buffer;
	envp[i] = NULL;

    value = call_usermodehelper(argv[0], argv, envp, UMH_WAIT_PROC);
	
	kfree(buffer);
    return 0;
}

static int __init umode_handler_demo_init(void)
{
	ctl_table_header = register_sysctl_table(ctl_table);

    if (!ctl_table_header) {
        printk(KERN_ERR "ctl_table_header register failed\n");
		return -EINVAL;
    } 
	
	return 0;
}

static void __exit umode_handler_demo_exit(void)
{
	run_umode_handler_example(-1);

	if (ctl_table_header)
		unregister_sysctl_table(ctl_table_header);
}

module_init(umode_handler_demo_init);
module_exit(umode_handler_demo_exit);

MODULE_DESCRIPTION("umode demo");
MODULE_AUTHOR("longyu");
MODULE_LICENSE("GPL");

Makefile 文件内容如下：

MODULE_FILENAME=usermodehelper_demo

obj-m += ${MODULE_FILENAME}.o
KO_FILE=${MODULE_FILENAME}.ko

KROOT= /home/longyu/arm-linux-kernel/linux-4.0

modules:
	@${MAKE} -C ${KROOT} ARCH=arm CROSS_COMPILE=arm-none-eabi- M=${PWD} modules

clean:
	@${MAKE} -C ${KROOT} M=${PWD} clean
	rm -rf Modules.symvers modules.order

加载测试记录如下：

/tmp/host_files # insmod usermodehelper_demo.ko 
/tmp/host_files # cat /bin/test.sh 
#!/bin/sh

touch /test
echo $TEST_VARIABLE > /test
/tmp/host_files # echo "/bin/test.sh" > /proc/sys/umode_helper 
/tmp/host_files # cat /proc/sys/umode_helper 
/bin/test.sh
/tmp/host_files # 
/tmp/host_files # rmmod usermodehelper_demo.ko 
running here, argv[0] is /bin/test.sh
/tmp/host_files # cat /test
hello
longyu_wlz
关注
专栏目录
基于内核线程的创建、使用和退出以及延时宏的补充说明介绍
09-05
内核线程是操作系统内核管理的一种特殊类型的线程，它们在内核空间中运行，直接与硬件交互，不依赖用户态的线程库。在Linux内核中，内核线程主要用于系统服务，如调度器、I/O子系统、定时器等。本文将深入探讨内核...
《深入理解Linux内核》第四章 中断和异常（五）
yxw0609131056的博客
12-03 665
今天让我们来看下另一个中断下半部常用的机制----work queue 一、特性 1、先激活，在某个时间点再执行函数 2、有专用的内核线程work thread 二、与可延迟函数区别 1、可延迟函数处于中断上下文，不能调用导致睡眠的函数，而work queue处于进程上下文，可以睡眠，允许调用导致睡眠的函数 三、数据结构 1、work_struct struct work_struct { unsigned long pending; struct list_head entry;
深入理解 Linux 内核---信号
新博客：https://aping-dev.com/
12-15 6588
信号的作用 信号是很短的消息，可以被发送到一个进程或一组进程。 发送给进程的唯一信息通常是一个数，来标识信号。 前缀为 SIG 的一组宏标识信号。 如，当一个进程引用无效的内存时，SIGSEGV 宏产生发送给进程的信号标识符。 使用信号的两个目的： 让进程知道已经发生了一个特定的事件。 强迫进程执行它自己的代码中的信号处理程序。 除了一些常规信号，POSIX 标准还引入了一类新的信号，叫做实时...
linux signal 处理
热门推荐
企鹅的自我修养
06-18 3万+
源地址：http://blog.csdn.net/zhuixundelang/article/details/5979465 linuxsignal 处理   说明: 本文主要翻译自ULK 3rd chapter 11. 主要受 http://blog.csdn.net/yunsongice 影响,故发表在csdn. 另外,本文是最初版本,估计以后会有一个改进版本. 文中还有很多
LInux内核IPC通信 - 信号
生活需要深度
02-08 601
recalc_sigpending_tsk(t) 和 recalc_sigpending()： 第一个函数检查是 *t 进程描述符表示的进程有挂起信号（t->pending->signa)，还是进程所属的线程组有挂起的信号（t->signal->shared_pending->signal），然后把 t->thread_info->flags 的 TIF_SIGPENDING 标志置位。处理程序终止时，setup_frame() 或 setup_rt_frame() 放在用户态堆栈中的返回代码被执行。
Linux内核线程编程方法
07-29
内核线程与用户进程的主要区别在于它们不拥有独立的地址空间，它们的活动范围仅限于内核空间，不会进行用户态到内核态的切换。这使得内核线程在执行高优先级或低延迟的任务时特别有用，因为它们避免了上下文切换的...
易语言查看内核线程
07-22
"EnumDrivers"可能是指枚举系统驱动程序的过程，这在查看内核线程时可能不直接相关，但有时驱动程序可能会创建内核线程，因此了解正在运行的驱动可能有助于分析内核线程的来源。 "getdata_int"和"getdata_str"可能...
内核线程和进程的区别
07-22
内核线程在创建时，通常由一个现有的内核线程通过特定的系统调用（如clone()）来创建新的线程。系统调用时会指定一组特定的标志（flags），用以告诉内核需要创建一个内核线程。内核线程的创建通常涉及到将线程函数...
系统线程（内核线程）和用户线程区别 - 简书.pdf
04-29
系统线程（内核线程）是由操作系统内核创建和撤销的线程，内核维护进程及线程的上下文信息以及线程切换。系统线程的优点是当有多个处理机时，一个进程的多个线程可以同时执行，缺点是由内核进行调度，创建和销毁系统...
Linux Signal
pwl999的博客
10-11 1617
信号的基本使用场景：使用“ctrl+c”中止一个程序，或者使用”kill pid”命令杀掉一个进程。 Linux信号机制基本上每个同学都用过，但是信号的具体实现机制还是有很多人不清楚的。在很多人的概念中信号是一种异步机制，像中断一样。但是除了硬中断，信号也是由中断实现的吗？如果不是中断，系统又怎么样来利用软件机制模拟类似如异步中断的动作？
linux内核 cmpset,Linux Signal
weixin_29977617的博客
04-29 644
信号的基本使用场景：使用 ctrl+c 中止一个程序，或者使用 kill pid 命令杀掉一个进程。Linux 信号机制基本上每个同学都用过，但是信号的具体实现机制还是有很多人不清楚的。在很多人的概念中信号是一种异步机制，像中断一样。但是除了硬中断，信号也是由中断实现的吗？如果不是中断，系统又怎么样来利用软件机制模拟类似如异步中断的动作？本文的代码分析基于 Linux Kernel 3.18.22...
linux signal 内核处理
wzwind的专栏
02-03 9208
linux signal 处理   说明: 本文主要翻译自ULK 3rd chapter 11. 主要受 http://blog.csdn.net/yunsongice 影响,故发表在csdn. 另外,本文是最初版本,估计以后会有一个改进版本. 文中还有很多todo的地方. 另外,如果有版权问题,通知我,我马上删掉. 总结 信号分成两种：  regular signal(
linux内核调用用户态程序的方法call_usermodehelpere
jianjian的博客
02-28 1255
在用户态中，我们可以通过execve()直接执行应用程序；那么，在内核态，我们是否可以直接调用用户态程序呢？答案是可以的，内核提供了一个函数：call_usermodehelpere，它可以帮助我们在内核就可以执行用户态的二进制程序。准备好这两个文件，执行make就可以编译出b.ko驱动。
内核启动用户态的程序
但行好事 莫问前程
04-06 155
内核启动用户态的应用程序是通过call_usermodehelper来调用的，比较常见的调用，比如modprobe. [code="java"]static inline int call_usermodehelper(char *path, char **argv, char **envp, enum umh_wait wait)[/code] 参数说明; path : 应...
Linux内核proc sysctl
最新发布
tombaby_come的博客
03-02 1872
sysctl是一个用于运行时配置内核参数的命令，这些内核参数位于/proc/sys目录下。sysctl配置与显示在/proc/sys目录中的内核参数．可以用sysctl来设置或重新设置联网等功能，如IP转发、IP碎片去除以及源路由检查等。用户只需要编辑/etc/sysctl.conf文件，即可手工或自动执行由sysctl控制的功能。1、常见用法。
linux内核唤醒单个线程,在futex之前，如何在Linux中停放和唤醒线程/进程？
weixin_33721696的博客
04-29 170
小编典典futex的和当前实现并行线程的Linux之前，NPTL(需要内核2.6和更高版本)，此外，还有两个线程库与POSIX线程API的Linux：Linux线程这和NGPT(基于对牛羚第P。LinuxThreads中是唯一的广泛应用libpthread已有多年历史了(它仍然可以在某些陌生且未维护的micro-libc中使用，以在2.4上运行；其他micro-libc变体可能在futex + c...
内核如何阻塞与唤醒进程？
chuixue24的博客
11-05 1057
进程和线程 我们先从 Linux 的进程谈起，操作系统要运行一个可执行程序，首先要将程序文件加载到内存，然后 CPU 去读取和执行程序指令，而一个进程就是“一次程序的运行过程”，内核会给每一个进程创建一个名为task_struct的数据结构，而内核也是一段程序，系统启动时就被加载到内存中了。 进程在运行过程中要访问内存，而物理内存是有限的，比如 16GB，那怎么把有限的内存分给不同的进程使用呢？跟 CPU 的分时共享一样，内存也是共享的，Linux 给每个进程虚拟出一块很大的地址空间，比如 32 位机器
内核线程创建、使用与退出详解：延时宏补充说明
首先，我们了解到内核线程的创建是通过kthread_create()函数完成的，这个函数接收一个线程函数threadfn的地址、数据参数data以及可选的线程名称格式字符串。这个函数返回一个指向task_struct的指针，线程在创建后并...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值