Linux内核获取当前任务current

于 2022-05-15 17:51:15 发布
阅读量1k 收藏
点赞数 1
分类专栏： Linux内核 文章标签： linux gnu p2p
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013416923/article/details/124785320
版权

X86架构：
arch/x86/include/asm/current.h
一：定义当前任务的全局变量current_task
percpu基本原理：静态的percpu变量使用DEFINE_PER_CPU()宏来定义，目的就是把这种类型的变量都放到section(".data..percpu")

#define DECLARE_PER_CPU(type, name)                    \
    DECLARE_PER_CPU_SECTION(type, name, "")
#define DECLARE_PER_CPU_SECTION(type, name, sec)            \
    extern __PCPU_ATTRS(sec) __typeof__(type) name
#define __PCPU_ATTRS(sec)                        \
    __percpu __attribute__((section(PER_CPU_BASE_SECTION sec)))    \
    PER_CPU_ATTRIBUTES

#ifdef CONFIG_SMP
#define PER_CPU_BASE_SECTION ".data..percpu"
#else
#define PER_CPU_BASE_SECTION ".data"
#endif
#define PER_CPU_ATTRIBUTES   
例：
DECLARE_PER_CPU(struct task_struct *, current_task);
extern __attribute__((section(".data..percpu" ""))) __typeof__(struct task_struct *) current_task

static __always_inline struct task_struct *get_current(void)
{
    return this_cpu_read_stable(current_task);
}

#define current get_current()

二：x86获取当前任务宏this_cpu_read_stable
arch/x86/include/asm/percpu.h

#define this_cpu_read_stable_1(pcp)    percpu_stable_op(1, "mov", pcp)
#define this_cpu_read_stable_2(pcp)    percpu_stable_op(2, "mov", pcp)
#define this_cpu_read_stable_4(pcp)    percpu_stable_op(4, "mov", pcp)
#define this_cpu_read_stable_8(pcp)    percpu_stable_op(8, "mov", pcp)
#define this_cpu_read_stable(pcp)    __pcpu_size_call_return(this_cpu_read_stable_, pcp)

arch/x86/include/asm/percpu-defs.h
系统根据current_task指针的size返回具体的任务
#define __pcpu_size_call_return(stem, variable)                \
({                                    \
    typeof(variable) pscr_ret__;                    \
    __verify_pcpu_ptr(&(variable));                    \
    switch(sizeof(variable)) {                    \
    case 1: pscr_ret__ = stem##1(variable); break;            \
    case 2: pscr_ret__ = stem##2(variable); break;            \
    case 4: pscr_ret__ = stem##4(variable); break;            \
    case 8: pscr_ret__ = stem##8(variable); break;            \
    default:                            \
        __bad_size_call_parameter(); break;            \
    }                                \
    pscr_ret__;                            \
})


arch/x86/include/asm/percpu.h
根据具体任务size获取当前任务宏
#define percpu_stable_op(size, op, _var)                \
({                                    \
    __pcpu_type_##size pfo_val__;                    \
    asm(__pcpu_op2_##size(op, __percpu_arg(P[var]), "%[val]")    \
        : [val] __pcpu_reg_##size("=", pfo_val__)            \
        : [var] "p" (&(_var)));                    \
    (typeof(_var))(unsigned long) pfo_val__;            \
})

以X86_64架构为例展开：64bit指针size为8Byte
this_cpu_read_stable(current_task)：
-->__pcpu_size_call_return
-->this_cpu_read_stable_8
初步展开：
-->percpu_stable_op(8, "mov", current_task)
({                                    \
    __pcpu_type_8 pfo_val__;                    \
    asm(__pcpu_op2_8(mov, __percpu_arg(P[var]), "%[val]")    \
        : [val] __pcpu_reg_8("=", pfo_val__)            \
        : [var] "p" (&(_var)));                    \
    (typeof(_var))(unsigned long) pfo_val__;            \
})
进一步展开：
#define __pcpu_type_1 u8
#define __pcpu_type_2 u16
#define __pcpu_type_4 u32
#define __pcpu_type_8 u64

#define __pcpu_op2_1(op, src, dst) op "b " src ", " dst
#define __pcpu_op2_2(op, src, dst) op "w " src ", " dst
#define __pcpu_op2_4(op, src, dst) op "l " src ", " dst
#define __pcpu_op2_8(op, src, dst) op "q " src ", " dst

#define __pcpu_reg_1(mod, x) mod "q" (x)
#define __pcpu_reg_2(mod, x) mod "r" (x)
#define __pcpu_reg_4(mod, x) mod "r" (x)
#define __pcpu_reg_8(mod, x) mod "r" (x)

#define __percpu_arg(x) __percpu_prefix "%" #x

#define __stringify_1(x...)    #x
#define __stringify(x...)    __stringify_1(x)
#define __percpu_prefix        "%%"__stringify(__percpu_seg)":"


__percpu_seg定义如下：
#ifdef CONFIG_X86_64       // CONFIG_SMP=y
#define __percpu_seg        gs
#else
#define __percpu_seg        fs
#endif
-->percpu_stable_op(8, "mov", current_task)
({
    u64 pfo_val__;
    asm("movq %%gs:%P[var]", "%[val]"
        : [val] ="r"pfo_val__
        : [var] "p" (&(current_task)));
    (typeof(current_task))(unsigned long) pfo_val__;
})
X86 PerCPU变量基址(gs寄存器)的原理：
X86下有一个快捷方法，只需一条简单的汇编指令mov %gs:var就能取出某个percpu变量在当前cpu的值，非常高效。
unsigned long get_memory_value(unsigned long addr)
{
    unsigned long value = 0 ;
    __asm__ __volatile__ ("mov %0, %%rax\n\t"::"r"(addr));
    __asm__ __volatile__ ("mov %gs:(%rax), %rax\n\t");
    __asm__ __volatile__ ("mov %%rax, %[value]\n\t" :[value]"=r"(value));
    return value;
}  

unsigned long get_ksymbol_var(void)
{
    unsigned long addr = kallsyms_lookup_name("global_symbol") ;
    if(!addr) {
        dbg("Can't found global_symbol symbols! \r\n") ;
        return 0 ;
    }
    return get_memory_value(addr) ;
}  
    

static long *get_current(void)
{
    return ({
    typeof(current_task) pscr_ret__;
    do {
        const void *__vpp_verify = (typeof((&(current_task)) + 0))((void *)0);
        (void)__vpp_verify;
    } while (0);
    switch(sizeof(current_task))
    {
        case 1: pscr_ret__ = ({
            u8 pfo_val__;
            asm("movb %%gs:%P[var], %[val]\n\t"
            : [val] "=q" (pfo_val__)
            : [var] "p" (&(current_task)));
            (typeof(current_task))(unsigned long) pfo_val__;
            });
            break;
        case 2: pscr_ret__ = ({
            u16 pfo_val__;
            asm("movw %%gs:%P[var], %[val]\n\t"
            : [val] "=r" (pfo_val__)
            : [var] "p" (&(current_task)));
            (typeof(current_task))(unsigned long) pfo_val__;
            });
            break;
        case 4: pscr_ret__ = ({
            u32 pfo_val__;
            asm("movl %%gs:%P[var], %[val]\n\t"
            : [val] "=r" (pfo_val__)
            : [var] "p" (&(current_task)));
            (typeof(current_task))(unsigned long) pfo_val__;
            });
            break;
        case 8: pscr_ret__ = ({
            u64 pfo_val__;
            asm("movq %%gs:%P[var], %[val]"
            : [val] "=r" (pfo_val__)
            : [var] "p" (&(current_task)));
            (typeof(current_task))(unsigned long) pfo_val__; });
            break;
        default:
            break;
    }
    pscr_ret__;
    });
}

宏替换后展开的代码：

#include <stdio.h>

typedef unsigned char       u8;
typedef unsigned short      u16;
typedef unsigned int        u32;
typedef unsigned long long  u64;

#define __pcpu_type_1 u8
#define __pcpu_type_2 u16
#define __pcpu_type_4 u32
#define __pcpu_type_8 u64

#define __pcpu_op2_1(op, src, dst) op "b " src ", " dst
#define __pcpu_op2_2(op, src, dst) op "w " src ", " dst
#define __pcpu_op2_4(op, src, dst) op "l " src ", " dst
#define __pcpu_op2_8(op, src, dst) op "q " src ", " dst

#define __pcpu_reg_1(mod, x) mod "q" (x)
#define __pcpu_reg_2(mod, x) mod "r" (x)
#define __pcpu_reg_4(mod, x) mod "r" (x)
#define __pcpu_reg_8(mod, x) mod "r" (x)

#define __percpu_seg		gs

#define __stringify_1(x...)	#x
#define __stringify(x...)	__stringify_1(x)
#define __percpu_prefix		"%%"__stringify(__percpu_seg)":"
#define __percpu_arg(x)		__percpu_prefix "%" #x

#define percpu_stable_op(size, op, _var)				\
({									\
	__pcpu_type_##size pfo_val__;					\
	asm(__pcpu_op2_##size(op, __percpu_arg(P[var]), "%[val]")	\
	    : [val] __pcpu_reg_##size("=", pfo_val__)			\
	    : [var] "p" (&(_var)));					\
	(typeof(_var))(unsigned long) pfo_val__;			\
})

#define this_cpu_read_stable_1(pcp)	percpu_stable_op(1, "mov", pcp)
#define this_cpu_read_stable_2(pcp)	percpu_stable_op(2, "mov", pcp)
#define this_cpu_read_stable_4(pcp)	percpu_stable_op(4, "mov", pcp)
#define this_cpu_read_stable_8(pcp)	percpu_stable_op(8, "mov", pcp)

#define __verify_pcpu_ptr(ptr)						\
do {									\
	const void *__vpp_verify = (typeof((ptr) + 0))NULL;	\
	(void)__vpp_verify;						\
} while (0)

#define __pcpu_size_call_return(stem, variable)				\
({									\
	typeof(variable) pscr_ret__;					\
	__verify_pcpu_ptr(&(variable));					\
	switch(sizeof(variable)) {					\
	case 1: pscr_ret__ = stem##1(variable); break;			\
	case 2: pscr_ret__ = stem##2(variable); break;			\
	case 4: pscr_ret__ = stem##4(variable); break;			\
	case 8: pscr_ret__ = stem##8(variable); break;			\
	default:							\
		break;			\
	}								\
	pscr_ret__;							\
})
#define this_cpu_read_stable(pcp)	__pcpu_size_call_return(this_cpu_read_stable_, pcp)

long current_task_var = 0xAA55AA55BBCCDDEE;
long *current_task = &current_task_var;
#if 0
static long *get_current(void)
{
    printf("get_current==>宏替换\n");
	return this_cpu_read_stable(current_task);
}
#else 
static long *get_current(void)
{
    printf("get_current==>内联汇编\n");
    return ({
    typeof(current_task) pscr_ret__;
    do {
        const void *__vpp_verify = (typeof((&(current_task)) + 0))((void *)0); 
        (void)__vpp_verify; 
    } while (0);
    switch(sizeof(current_task)) 
    { 
        case 1: pscr_ret__ = ({ 
            u8 pfo_val__; 
            asm("movb %%gs:%P[var], %[val]\n\t" 
            : [val] "=q" (pfo_val__) 
            : [var] "p" (&(current_task))); 
            (typeof(current_task))(unsigned long) pfo_val__; 
            });
            break; 
        case 2: pscr_ret__ = ({ 
            u16 pfo_val__; 
            asm("movw %%gs:%P[var], %[val]\n\t" 
            : [val] "=r" (pfo_val__) 
            : [var] "p" (&(current_task))); 
            (typeof(current_task))(unsigned long) pfo_val__; 
            }); 
            break; 
        case 4: pscr_ret__ = ({ 
            u32 pfo_val__; 
            asm("movl %%gs:%P[var], %[val]\n\t" 
            : [val] "=r" (pfo_val__) 
            : [var] "p" (&(current_task))); 
            (typeof(current_task))(unsigned long) pfo_val__; 
            }); 
            break; 
        case 8: pscr_ret__ = ({ 
            u64 pfo_val__; 
            asm("movq %%gs:%P[var], %[val]\n\t" 
            : [val] "=r" (pfo_val__) 
            : [var] "p" (&(current_task))); 
            (typeof(current_task))(unsigned long) pfo_val__; }); 
            break; 
        default: 
            break; 
    }
    pscr_ret__;
    });
}
#endif

#define current get_current()

unsigned long get_mem_value(unsigned long addr) 
{
    unsigned long value = 0 ;
    __asm__ __volatile__ ("mov %0, %%rax\n\t"::"r"(addr));
    __asm__ __volatile__ ("mov %gs:(%rax), %rax\n\t");
    __asm__ __volatile__ ("mov %%rax, %[value]\n\t" :[value]"=r"(value)) ;
    return value ;
}

unsigned long get_ksyms_var(unsigned long addr) {
    if(!addr) {
        printf("Can't found ksyms_var symbols! \r\n") ;
        return 0 ;
    }
    return get_mem_value(addr) ;
}


int main(int argc, char *argv[])
{
    printf("current_task: %p\n", current_task);
	printf("current: %p\n", current);
    
    printf("get_mem_value: 0x%lx\n", get_mem_value((unsigned long)&current_task_var));
	return 0;
}

IT笔记
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
linux获取当前进程进程号,Linux内核获取当前进程结构的current宏
weixin_31440053的博客
04-28 2319
上篇文章Linux内核的源码结构简介(1)简单介绍了Linux内核源码的目录结构，以及和进程的task_struct的几个关键变量，最后提到了在内核里获取当前进程的pid的代码：current->pid。current，属于内核的一个宏，指向get_current()函数。#define current get_current()所以代码current，实际是获取get_current()函...
linux内核current宏实现原理,分析内核中的current宏，并自己实现
weixin_39592137的博客
05-01 670
说明：current宏，是一个全局指针，指向当前进程的struct task_struct结构体，即表示当前进程。例如current->pid就能得到当前进程的pid，current-comm就能得到当前进程的名称。每个进程会有两个栈，一个用户栈，存在于用户空间，一个内核栈，存在于内核空间。当进程在用户空间运行时，cpu堆栈指针寄存器里面的内容是用户堆栈地址，使用用户栈；当进程在内核空间时，...
Linux内核中GET_CURRENT()函数
游手好弦 信步涂鸦
03-20 5707
进程描述符存放在大小为8k的进程栈的顶部(低地址, intel系统中栈是由高地址向低地址伸展的). 而esp寄存器存放着当前进程的栈基址. 所以将esp中的指针的低13位(8k)清零即可得到当前进程描述符的地址. 把嵌入汇编写成AT&T汇编如下: movl $0xffffe000 %ecx andl %esp %ecx movl %ecx current
linux get current,FAQ/get_current - Linux Kernel Newbies
weixin_34109083的博客
05-26 147
NOTE: this FAQ answer applies to the 2.4 kernel. 2.6 with 4kB stacks works differently and this FAQ should be updated.How does get_current() work?static inline struct task_struct * get_current(void){...
linux 返回结构体,linux – get_current()在这个内核模块中返回什么？
weixin_32503531的博客
05-14 531
我编写了一个读取和写入/ proc文件的内核模块,它工作正常.现在我想使用它的权限,但是当我为下面显示的权限编写函数时,它给了我一个错误.目标是让每个人都能够读取文件,但只有root才能写入文件.int my_permission(struct inode *inode, int op){if(op == 4||(op == 2 && current->euid = 0)) ...
解析Linux内核获取当前进程指针的方法
03-04
Linux 内核获取当前进程指针的方法 在了解 Linux 内核获取当前进程指针的方法之前，我们先需要了解内存数据的表示方式。在 Intel X86 系列计算机中，系统采用小端字节序来存放数据，即低序字节低地址，高序字节高...
Linux内核延时研究与函数代码分析
07-29
Linux内核还提供了三种方法来实现任务延迟：任务队列、tasklet和内核定时器。任务队列是一种异步编程机制，允许驱动程序将任务延迟到以后处理。tasklet是一种轻量级的任务队列，可以用于实现短期延迟。内核定时器是...
进程讲解linux内核
07-16
在Linux中，当前运行的进程记录在全局变量`current`中，当需要切换时，这个变量会由`kernel/sched.c`中的调度器更新。`for_each_task`这样的循环帮助快速遍历所有进程，优化了搜索效率。 **用户进程与内核线程**...
linux进程调度与进程切换1
08-08
- 保存当前进程`current`的状态到`prev`，并获取与当前CPU相关的运行队列`rq`。 - 如果`prev`持有大内核锁`kernel_sem`，则释放它，因为调度可能导致进程切换，不再需要锁。 - 通过`sched_clock()`获取当前时间戳`...
内核线程优先级设置的方法介绍
09-05
Linux内核提供了三种主要的调度策略： 1. **SCHED_NORMAL**：这是非实时调度策略，也是默认策略。它根据进程的`nice`值来确定优先级，范围通常在100到139之间。`nice`值越低，优先级越高，可以获取更多的CPU时间。 ...
linux中的thread_info
zhichaosong的专栏
01-11 1274
对每个进程，Linux内核都把两个不同的数据结构紧凑的存放在一个单独为进程分配的内存区域中：一个是内核态的进程堆栈，另一个是紧挨着进程描述符的小数据结构thread_info，叫做线程描述符。在较新的内核代码中，这个存储区域的大小通常为8192个字节（两个页框）。在linux/arch/x86/include/asm/page_32_types.h中， #define THR
linux 进程 current,解析 进程 current 指针
weixin_39615257的博客
04-29 546
在linux 内核中有一宏 : current (获取当前正在运行的进程)linux 2.4.0点击(此处)折叠或打开struct task_struct;static inline struct task_struct * get_current(void){struct task_struct *current;__asm__("andl %%esp,%0; ":"=r" (current) ...
xml_get_current_line_number() 函数
冷月醉雪的博客
04-18 160
查看更多 https://www.yuque.com/docs/share/5fcd98eb-6eee-450e-b4aa-f5a6818f5b8e
关于get_current的笔记
qq_34696349的博客
06-27 1664
在刚开始看这个代码的时候有些不解，经过查看多篇文章大致理解了含义，想把自己的理解简单的叙述出来。 static inline struct task_struct *get_current(void) { return current_thread_info()->task; } static inline struct thread_info *current_thread_info(void) { register unsigned long sp asm ("sp"); re
linux current
04-08 4632
尽管内核模块不象应用程序一样顺序执行, 内核做的大部分动作是代表一个特定进程的. 内核代码可以引用当前进程, 通过存取全局项 current, 它在 中定义, 它产生一个指针指向结构 task_struct, 在 定义. current 指针指向当前在运行的进程. 在一个系统调用执行期间, 例如 open 或者 read, 当前进程是发出调用的进程. 内核代码可以通过使用 current 来使
linux 进程 current,Linux——不同体系结构下获取current
weixin_29614791的博客
04-29 1414
current的含义：内核代码可以引用当前进程, 通过存取全局项 current, 它在 中定义, 它产生一个指针指向结构 task_struct, 在 定义. current 指针指向当前在运行的进程. 在一个系统调用执行期间, 例如 open 或者 read, 当前进程是发出调用的进程. 内核代码可以通过使用 current 来使用进程特定的信息, 如果它需要这样. 实际上, curren...
xml_get_current_byte_index() 函数
冷月醉雪的博客
04-18 162
查看更多 https://www.yuque.com/docs/share/71dab89b-e496-45ae-8fef-e142fcd1d80d
linux 内核 current全局变量
热门推荐
chenliang0224的专栏
06-20 1万+
task_struct内核路径：include/linux/sched.hstruct task_struct { volatile long state; /* -1 unrunnable, 0 runnable, &gt;0 stopped */ void *stack; atomic_t usage; unsigned int flags; /* per process flags,...
linux内核current宏实现原理,current宏的作用
weixin_28750421的博客
05-01 429
在2.6的内核上允许内核栈的大小在4K和8K之间选择，于是，根据内核的配置，在thread_info.h中，加入了下面的一段代码#ifdef CONFIG_4KSTACKS#define THREAD_SIZE (4096)#else#define THREAD_SIZE (8192)这个大小的不同会影响内核堆栈的表示方法和current宏的实现，详见下面首先，...
linux 内核添加定时任务
最新发布
09-09
在Linux内核中，要添加定时任务需要使用crontab命令。crontab是一个用来创建和管理定时任务的工具。通过编辑crontab文件，可以设置任务的执行时间和要执行的命令。具体步骤如下： 1. 打开终端，输入命令 crontab -e 来编辑当前用户的crontab文件。 2. 在打开的文件中，每一行代表一个定时任务。每行由时间设置和要执行的命令组成。 3. 时间设置采用类似于表达式的格式，由分、时、日、月、周几五个字段组成。通过设置这些字段的值，可以指定任务的执行时间。例如，* * * * * 表示每分钟执行一次任务。 4. 在时间设置后面，添加要执行的命令。可以是系统命令、脚本、可执行文件等。 5. 编辑完毕后，保存并关闭文件。 6. 定时任务会在设定的时间自动执行。 请注意，添加定时任务需要具有足够的权限。如果不能编辑当前用户的crontab文件，可以尝试使用sudo crontab -e命令以管理员权限编辑系统全局的crontab文件。 总结起来，要在Linux内核中添加定时任务，可以使用crontab命令编辑crontab文件，设置任务的执行时间和要执行的命令。<span class="em">1</span><span class="em">2</span><span class="em">3</span><span class="em">4</span>

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值