linux 内核：访问当前进程的 task

一：概述

Linux 属于单内核架构，这意味着所有驱动、调度器、内存管理、文件系统模块都运行在内核态，驱动模块也运行在与内核相同的上下文中，可以访问当前正在执行的进程，本文介绍下通过 current 宏指向的 task_struct 结构体，来获取当前正在执行进程的相关信息。

二：本例子所用内核头文件介绍

1. `<linux/init.h>`

作用：包含 module_init() 和 module_exit() 宏的定义。用于标记模块的初始化与退出函数。属于模块加载的生命周期管理。

2. `<linux/module.h>`

作用：支持编写内核模块的核心头文件。定义了 MODULE_AUTHOR、MODULE_LICENSE、MODULE_DESCRIPTION 等元信息宏。包含模块注册、注销、符号导出等功能的声明。

3. `<linux/sched.h>` （注：从 Linux 5.4 起常用 `<linux/sched/task.h>` 替代）

作用：定义了 task_struct 和 current 宏。current 是一个宏，用于获取当前运行线程的 task_struct 指针。这是访问进程上下文的关键数据结构。

4. `<linux/preempt.h>`

作用：提供了 in_task() 等宏。in_task() 判断当前是否在进程上下文中运行（非中断上下文）。与抢占模型和调度相关的定义在此。

5. `<linux/cred.h>`

作用：提供了获取当前进程的用户权限信息的接口，如：current_uid()，current_euid()。

6. `<linux/uidgid.h>`

作用：定义了 UID/GID 的处理函数，from_kuid()：将内核内部的 kuid_t 类型转换为普通用户空间可读的整数 UID。make_kuid()：反之，将整数 UID 转为 kuid_t。与用户命名空间（User Namespace）有关，确保多租户场景下权限隔离。

三：例子中的关键函数

从当前进程的内核内部凭据（credentials）结构中提取用户标识（UID 和 EUID），其中 UID 表示真实用户 ID，即当前进程是谁启动的。EUID表示有效用户 ID，即当前的权限。

	unsigned int uid = from_kuid(&init_user_ns, current_uid());
	unsigned int euid = from_kuid(&init_user_ns, current_euid());

判断当前是否是进程上下文，in_task() 是一个宏，判断当前是否是进程上下文（不是中断、软中断等）。

if (likely(in_task())) {}

打印当前任务结构信息：

pr_info(" name        : %s\n", current->comm);
pr_info(" PID         : %6d\n", task_pid_nr(current));
pr_info(" TGID        : %6d\n", task_tgid_nr(current));
pr_info(" UID         : %6u\n", uid);
pr_info(" EUID        : %6u (%s root)\n", euid, (euid == 0 ? "have" : "don't have"));
pr_info(" state       : %c\n", task_state_to_char(current));


/*
current->comm: 进程名（exec() 时被设置）
task_pid_nr(current): 进程 ID
task_tgid_nr(current): 线程组 ID
task_state_to_char(current): 返回 R、S 等状态字符
UID/EUID: 标识用户身份
*/

打印 task_struct 和 stack 地址

pr_info("current : 0x%pK (0x%px)\n", current, current);
pr_info("stack start : 0x%pK (0x%px)\n", current->stack, current->stack);

/*
%pK：如果开启了地址限制（kptr_restrict），非 root 用户会看到 0。
%px：不受 kptr_restrict 影响，调试时常用。
current->stack: 栈底地址（向下增长）
*/

判断当前是否跑在虚拟机上

//当前是否跑在虚拟 CPU 上
if (task_state_to_char(current) == 'R')
    pr_info("on virtual CPU? %s\n", (current->flags & PF_VCPU)?"yes":"no");

三：完整例子

#define pr_fmt(fmt) "%s:%s(): " fmt, KBUILD_MODNAME, __func__

#include <linux/init.h>
#include <linux/module.h>
#include <linux/sched.h>      // current
#include <linux/preempt.h>    // in_task
#include <linux/cred.h>       // current_uid, current_euid
#include <linux/uidgid.h>     // from_kuid

MODULE_AUTHOR("Anonymous");
MODULE_DESCRIPTION("Display current process task_struct info");
MODULE_LICENSE("Dual MIT/GPL");
MODULE_VERSION("0.1");

static inline void show_ctx(void)
{
    unsigned int uid = from_kuid(&init_user_ns, current_uid());
    unsigned int euid = from_kuid(&init_user_ns, current_euid());

    pr_info("\n");
    if (likely(in_task())) {
        pr_info("Running in process context:\n"
                " Name        : %s\n"
                " PID         : %6d\n"
                " TGID        : %6d\n"
                " UID         : %6u\n"
                " EUID        : %6u (%s root)\n"
                " State       : %c\n"
                " task_struct : 0x%pK (0x%px)\n"
                " Stack start : 0x%pK (0x%px)\n",
                current->comm,
                task_pid_nr(current), task_tgid_nr(current),
                uid, euid,
                (euid == 0 ? "have" : "don't have"),
                task_state_to_char(current),
                current, current, current->stack, current->stack);
    } else {
        pr_alert("Running in interrupt context! (unexpected here)\n");
    }
}

static int __init current_ctx_init(void)
{
    pr_info("Module inserted.\n");
    pr_info("sizeof(struct task_struct) = %zd\n", sizeof(struct task_struct));
    show_ctx();
    return 0;
}

static void __exit current_ctx_exit(void)
{
    show_ctx();
    pr_info("Module removed.\n");
}

module_init(current_ctx_init);
module_exit(current_ctx_exit);