/* * 日22:49:50 * 作者:张超 * email: * Linux2.6.32.25中如何获得当前进程的指针？ */
//Thread_info.h //申明per_cpu_kernel_stack变量，它在其它位置定义，见下文内容.
DECLARE_PER_CPU(unsigned long, kernel_stack);
static inline struct thread_info *current_thread_info(void)
struct thread_info *//存放thread_info的指针
ti = (void *)(percpu_read_stable(kernel_stack) +
KERNEL_STACK_OFFSET - THREAD_SIZE);
//取得相应当前cpu上thread_info所在的地址，返回值是整数
//Percpu.h
#define percpu_read_stable(var) percpu_from_op("mov", per_cpu__##var, \
"p" (&per_cpu__##var))
//下层实际的操作
&#define percpu_from_op(op, var, constraint) \
typeof(var) ret__; \
switch (sizeof(var)) { \
asm(op "b "__percpu_arg(1)",%0" \
: "=q" (ret__) \
: constraint); \
asm(op "w "__percpu_arg(1)",%0" \
: "=r" (ret__) \
: constraint); \
asm(op "l "__percpu_arg(1)",%0" \
: "=r" (ret__) \
: constraint); \
asm(op "q "__percpu_arg(1)",%0" \
: "=r" (ret__) \
: constraint); \
default: __bad_percpu_size(); \
per_cpu__kernel_stack是在下面的代码中定义的：
&DEFINE_PER_CPU(unsigned long, kernel_stack) =
(unsigned long)&init_thread_union - KERNEL_STACK_OFFSET + THREAD_SIZE;
extern union thread_union init_thread_
union thread_union {
struct thread_info thread_
unsigned long stack[THREAD_SIZE /sizeof(long)];
thread_union是一个联合体，里面定义了thread_info结构和堆栈结构，THREAD_SIZE在32位平台上一般定义为4K，所以stack的大小其实就是4KB，这就是初始任务在核心里所拥有的所有空间，除去thread_info和KERNEL_STACK_OFFSET占用的空间后，就是任务在核心里实际拥有堆栈的大小。KERNEL_STACK_OFFSET定义为5*8，由于是unsigned long,所以堆栈底部以上还有5*8*4B=200B的空间用来存放程序运行时相关的环境参数。
//Init_task.c 23
* Initial thread structure.
* We need to make sure that this is THREAD_SIZE aligned due to the
* way process stacks are handled. This is done by having a special
* "init_task" linker map entry..
*/ //Init_task.cstruct task_struct init_task = INIT_TASK(init_task);
union thread_union init_thread_union __init_task_data =
{ INIT_THREAD_INFO(init_task) };
//Sched.h thread_union
union thread_union {
struct thread_info thread_
unsigned long stack[THREAD_SIZE/sizeof(long)];
* INIT_TASK is used to set up the first task table, touch at
* your own risk!. Base=0, limit=0x1fffff (=2MB)
*/#define INIT_TASK(tsk) \
.state = 0, \
.stack = &init_thread_info, \
.usage = ATOMIC_INIT(2), \
.flags = PF_KTHREAD, \
.lock_depth = -1, \
.prio = MAX_PRIO-20, \
.static_prio = MAX_PRIO-20, \
.normal_prio = MAX_PRIO-20, \
.policy = SCHED_NORMAL, \
.cpus_allowed = CPU_MASK_ALL, \
.mm = NULL, \
.active_mm = &init_mm, \
.group_node = LIST_HEAD_INIT(tsk.se.group_node), \
.run_list = LIST_HEAD_INIT(tsk.rt.run_list), \
.time_slice = HZ, \
.nr_cpus_allowed = NR_CPUS, \
.tasks = LIST_HEAD_INIT(tsk.tasks), \
.pushable_tasks = PLIST_NODE_INIT(tsk.pushable_tasks, MAX_PRIO), \
.ptraced = LIST_HEAD_INIT(tsk.ptraced), \
.ptrace_entry = LIST_HEAD_INIT(tsk.ptrace_entry), \
.real_parent = &tsk, \
.parent = &tsk, \
.children = LIST_HEAD_INIT(tsk.children), \
.sibling = LIST_HEAD_INIT(tsk.sibling), \
.group_leader = &tsk, \
.real_cred = &init_cred, \
.cred = &init_cred, \
.cred_guard_mutex = \
__MUTEX_INITIALIZER(tsk.cred_guard_mutex), \
.comm = "swapper", \
.thread = INIT_THREAD, \
.fs = &init_fs, \
.files = &init_files, \
.signal = &init_signals, \
.sighand = &init_sighand, \
.nsproxy = &init_nsproxy, \
.pending = { \
.list = LIST_HEAD_INIT(tsk.pending.list), \
.signal = {{0}}}, \
.blocked = {{0}}, \
.alloc_lock = __SPIN_LOCK_UNLOCKED(tsk.alloc_lock), \
.journal_info = NULL, \
.cpu_timers = INIT_CPU_TIMERS(tsk.cpu_timers), \
.fs_excl = ATOMIC_INIT(0), \
.pi_lock = __SPIN_LOCK_UNLOCKED(tsk.pi_lock), \
.timer_slack_ns = 50000, /* 50 usec default slack */ \
.pids = { \
[PIDTYPE_PID] = INIT_PID_LINK(PIDTYPE_PID), \
[PIDTYPE_PGID] = INIT_PID_LINK(PIDTYPE_PGID), \
[PIDTYPE_SID] = INIT_PID_LINK(PIDTYPE_SID), \
.dirties = INIT_PROP_LOCAL_SINGLE(dirties), \
INIT_IDS \
INIT_PERF_EVENTS(tsk) \
INIT_TRACE_IRQFLAGS \
INIT_LOCKDEP \
INIT_FTRACE_GRAPH \
INIT_TRACE_RECURSION \
INIT_TASK_RCU_PREEMPT(tsk) \
初始化thread_info，传入参数是任务结构体
&#define INIT_THREAD_INFO(tsk) \
.task = &tsk, \
.exec_domain = &default_exec_domain, \
.flags = 0, \
.cpu = 0, \
.preempt_count = INIT_PREEMPT_COUNT, \
.addr_limit = KERNEL_DS, \
.restart_block = { \
.fn = do_no_restart_syscall, \
//宏定义展开过后的结果
struct thread_info *
ti = ( void * ) ( ( { typeof ( per_cpu__kernel_stack ) ret__ ;
switch ( sizeof ( per_cpu__kernel_stack ) ) {
case 1 : __asm ( "movb %%fs:%P1,%0" : "=q" ( ret__ ) : "p" ( & per_cpu__kernel_stack ) ) ; break ;
case 2 : __asm ( "movw %%fs:%P1,%0" : "=r" ( ret__ ) : "p" ( & per_cpu__kernel_stack ) ) ; break ;
case 4 : __asm ( "movl %%fs:%P1,%0" : "=r" ( ret__ ) : "p" ( & per_cpu__kernel_stack ) ) ; break ;
case 8 : __asm ( "movq %%fs:%P1,%0" : "=r" ( ret__ ) : "p" ( & per_cpu__kernel_stack ) ) ; break ;
default : __bad_percpu_size ( ) ; } ret__ ; } ) + KERNEL_STACK_OFFSET - THREAD_SIZE ) ;
& 总结：该版本内核和以前版本的内核在获得当前任务指针的方法上有很大的不同，以前是通过如下汇编指令实现的：movl $-8192,% andl %esp, %eax来实现的，执行完这两条指令后，eax中存放的就是thread_info的地址。而现在的代码中再也找不到这样的指令了，以前SMP共享数据很多依靠自旋锁来达到目的，自旋锁是一种忙等锁，在一定程度上造成了进行自旋的CPU上CPU利用率的下降，随着内核的不断发展，更多的使用每个CPU数据（per_cpu_data）的概念，在每一个处理器中各自维护一个以前在多个CPU之间进行共享的数据，如当前运行的任务结构体，以前就是在多个CPU之间共享的。
阅读(...) 评论()linux根据pid获取进程名和获取进程pid(c语言获取pid)
字体：[ ] 类型：转载 时间：
status文件，第一行的Name即为进程名,C程序实现根据PID获取进程名和根据进程名获取PID，大家参考使用吧
Liunx中通过进程名查找进程PID可以通过 pidof [进程名] 来查找。反过来 ，相同通过PID查找进程名则没有相关命令。在linux根目录中，有一个/proc的VFS(虚拟文件系统)，系统当前运行的所有进程都对应于该目录下的一个以进程PID命名的文件夹，其中存放进程运行的N多信息。其中有一个status文件，cat显示该文件， 第一行的Name即为进程名。
打开stardict程序，进程名为stardict；
shell中分别根据Pid获取进程名、根据进程名获取Pid
1）查找stardict的pid：pidof stardict
2）根据1）的pid查找进程名： grep "Name:" /proc/5884/status
应用：kill一个进程需要指定该进程的pid，所以我们需要先根据进程名找到pid，然后再kill；killall命令则只需要给定进程名即可，应该是封装了这个过程。
C程序中实现上述过程
代码如下:#include &sys/types.h&#include &dirent.h&#include &stdio.h&#include &string.h&
#define BUF_SIZE 1024
void getPidByName(char* task_name){&&& DIR *&&& struct dirent *&&& FILE *&&& char filepath[50];//大小随意，能装下cmdline文件的路径即可&&& char cur_task_name[50];//大小随意，能装下要识别的命令行文本即可&&& char buf[BUF_SIZE];&&& dir = opendir("/proc"); //打开路径&&& if (NULL != dir)&&& {&&&&&&& while ((ptr = readdir(dir)) != NULL) //循环读取路径下的每一个文件/文件夹&&&&&&& {&&&&&&&&&&& //如果读取到的是"."或者".."则跳过，读取到的不是文件夹名字也跳过&&&&&&&&&&& if ((strcmp(ptr-&d_name, ".") == 0) || (strcmp(ptr-&d_name, "..") == 0))&&&&&&&&&&&& 　　　　　　　　　　　　&&&&&&&&&&& if (DT_DIR != ptr-&d_type) &&&&&&& 　　　　　&&&&&&&&&&& sprintf(filepath, "/proc/%s/status", ptr-&d_name);//生成要读取的文件的路径&&&&&&&&&&& fp = fopen(filepath, "r");//打开文件&&&&&&&&&&& if (NULL != fp)&&&&&&&&&&& {&&&&&&&&&&&&&&& if( fgets(buf, BUF_SIZE-1, fp)== NULL ){&&&&&&&&&&& 　　　　fclose(fp);&&&&&&&&&&& 　　　　&&&&&&& 　　　　 }&&&&&&& 　　　　sscanf(buf, "%*s %s", cur_task_name);&&&&&&&&&&&&&&& //如果文件内容满足要求则打印路径的名字（即进程的PID）&&&&&&&&&&&&&&& if (!strcmp(task_name, cur_task_name))&&&&&&&&&& 　　　　 printf("PID:& %s\n", ptr-&d_name);&&&&&&&&&&&&&&& fclose(fp);&&&&&&&&&&& }&&&&&&& }&&&&&&& closedir(dir);//关闭路径&&& }}
void getNameByPid(pid_t pid, char *task_name) {&&& char proc_pid_path[BUF_SIZE];&&& char buf[BUF_SIZE];
&&& sprintf(proc_pid_path, "/proc/%d/status", pid);&&& FILE* fp = fopen(proc_pid_path, "r");&&& if(NULL != fp){&&&&&&& if( fgets(buf, BUF_SIZE-1, fp)== NULL ){&&&&&&&&&&& fclose(fp);&&&&&&& }&&&&&&& fclose(fp);&&&&&&& sscanf(buf, "%*s %s", task_name);&&& }}
void main(int argc, char** argv){&&& char task_name[50];&&& pid_t pid = getpid();
&&& printf("pid of this process:%d\n", pid);&&& getNameByPid(pid, task_name);&&& /*&&& strcpy(task_name, argv[0]+2);&&& printf("task name is %s\n", task_name);&&& getPidByName(task_name);&&& */&&& printf("task name is %s\n", task_name);&&& getPidByName(task_name);&&& sleep(15);}
运行结果：
进入/proc/9674/status查看文件内容，一切对应。
代码如下:Name: testState:&S (sleeping)Tgid:&9674Pid:&9674PPid:&7438TracerPid:&0Uid:&00&1000Gid:&00&1000FDSize:&256Groups:&4 24 27 30 46 112 124 1000 VmPeak:& 4340 kBVmSize:& 4336 kBVmLck:& 0 kBVmPin:& 0 kBVmHWM:& 600 kBVmRSS:& 600 kBVmData:& 184 kBVmStk:& 136 kBVmExe:& 4 kBVmLib:& 1920 kBVmPTE:& 32 kBVmSwap:& 0 kBThreads:&1SigQ:&0/15776SigPnd:&0000ShdPnd:&0000SigBlk:&0000SigIgn:&0000SigCgt:&0000CapInh:&0000CapPrm:&0000CapEff:&0000CapBnd:&0000001fffffffffSeccomp:&0Cpus_allowed:&fCpus_allowed_list:&0-3Mems_allowed:&00001Mems_allowed_list:&0voluntary_ctxt_switches:&1nonvoluntary_ctxt_switches:&4
您可能感兴趣的文章:
大家感兴趣的内容
12345678910
最近更新的内容
常用在线小工具Linux内核怎样获取当前进程(current)任务结构task&struct
Linux内核怎样获取进程任务结构
今天Linux是一个一体化内核（monolithic
kernel）系统。设备驱动程序可以完全访问硬件。Linux内的设备驱动程序可以方便地以模块化（modularize）的形式设置，并在系统运行期间可直接装载或卸载。我们就来看看Linux内核怎样获取进程任务结构的。
我们现在来看看linux内核是如何获取当前进程的任务结构指针的，以下代码均参照linux内核2.4.0的源码。
在include\asm-i386\ current.h中
_I386_CURRENT_H
_I386_CURRENT_H
inline struct task_struct *
get_current(void)
struct task_struct
__asm__("andl
%%esp,%0; ":"=r" (current)
: "0" (~8191UL));
#define current
get_current()
每个进程都有一个task_struct任务结构，和一片用于系统空间堆栈的存储空间，他们在物理内存空间中也是联系在一起的，当给进程申请task_struct任务结构空间时，系统将连同系统的堆栈空间一起分配，如下图为某个进程切换时刻的内存图：
注意:上图椎栈增长方向应该是从高地址--&低地址,也就是说task
struct结构在栈的最顶部
下面针对代码实现来分析一下系统如何通过一系列操作获取进程在内核中的任务结构指针的：
由于linux内核分配进程任务结构空间时，是以8KB(2个页面空间，即2^1*4KB，linux对物理内存空间和虚拟内存空间管理时，均规定其页面单位的尺寸为4KB)为单位来分配的，所以内存应用地址是8KB(2^13)的整数倍，即指针地址的低13位全为0，所以根据小端字节序，分配内存返回地址应该是指向struct
task_struct结构，如图中的0xc2342000地址所指，至于为何采用代码中的做法而不是直接将此指针保存在全局变量中以供应用，内核是从其自身的效率方面来考虑的，我们在此只针对代码解释：
根据上图，此刻内存esp内容必定在0xcxc2344000之间的一个数值，我们假设取0xc2343ffe(即堆栈压栈EIP、返回地址、内部数据等相关数据了，地址值要减小；只要符合0xc2342xxx
、0xc2343xxx的地址指针都是正确的)，来通过代码运算看是否current的指针是0xc2342000。
__asm__("andl %%esp,%0; ":"=r" (current) : "0" (~8191UL));
语句的意思是将ESP的内容与8191UL的反码按位进行与操作，之后再把结果赋值给current，其中8191UL=^13-1,计算过程如下：
8192UL=2^13 00 00
8191UL 00 11
~8191UL(反码) 11 00
0xc2343ffe 11 11
andl结果： 11 00
|| (对照着看)
0x c 2 3 4 2 0 0 0
所以按位与操作之后的结果位0xc2342000，正好是struct
task_struct结构的地址指针.通过观察可知，只要符合0xc2342xxx
、0xc2343xxx的地址指针经过相同的计算，都可以得到内核进程任务结构的指针。
另外,X86主要实现代码如下:
movl $-8192, %
andl %esp, %
其原理与上述描述也是一致的。
已投稿到：
以上网友发言只代表其个人观点，不代表新浪网的观点或立场。14:46 提问
android 5.0之后如何获取当前运行的应用包名？
1，先看看android5.0之前的获取方法：
// 1、得到当前运行的任务栈，参数就是得到多少个任务栈，1就是只拿一个任务栈
// 对应的也就是正在运行的任务栈啦 ,注意别忘了在清单文件中添加获取的权限
List runTaskInfos =
activityManager.getRunningTasks(1);
//拿到当前运行的任务栈
ActivityManager.RunningTaskInfo runningTaskInfo = runTaskInfos.get(0);
//拿到要运行的Activity的包名
runningpackageName = runningTaskInfo.baseActivity.getPackageName();
2，但是5.0之后这个方法失效了。搜索到如下解决方法：
public static String getCurrentPkgName(Context context) {
ActivityManager.RunningAppProcessInfo currentInfo =
Field field =
int START_TASK_TO_FRONT = 2;
String pkgName =
field = ActivityManager.RunningAppProcessInfo.class.getDeclaredField("processState");
} catch (Exception e) { e.printStackTrace(); }
ActivityManager am = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
List appList = am.getRunningAppProcesses();
for (ActivityManager.RunningAppProcessInfo app : appList) {
if (app.importance == ActivityManager.RunningAppProcessInfo.IMPORTANCE_FOREGROUND) {
Integer state =
state = field.getInt( app );
} catch (Exception e) { e.printStackTrace(); }
if (state != null && state == START_TASK_TO_FRONT) {
currentInfo =
if (currentInfo != null) {
pkgName = currentInfo.processN
return pkgN
3，然而上面的方法是得到却是当前Activity的进程名，一般进程名就是包名，但是如果在Manifest设置Activity的进程名，上面方法就无效了，如：
android:name="com.xxx.demo.DemoActivity"
android:process=".aaa" /&
Log.d(TAG, "当前包名：" + runningpackageName );
06-05 11:09:44.284
/com.xxx.demo D/AppService﹕ 当前包名：.aaa
4，除了上面获取方法，，求android 5.0之后获取当前运行的activity的包名的方法。
按赞数排序
你想得到什么包名，是本app的包名么？直接在Activity中
this.getPackageName();
请问你是怎么解决的？？求方法
我有一个折中的办法，在JAVA端运行ps程序，拿到结果，根据结果把进程名比对，可以获得进程pid和uid，Android上应用都有自己的uid，然后通过pid和uid获取包名
可以通过RunningAppProcessInfo对象拿到uid，通过下面方法就能拿到包名
getPackageManager().getPackagesForUid(uid);
题主你好，最近碰巧也在做类似的功能。我是这么获取的：
ActivityManager activityManager = (ActivityManager) getContext().getSystemService(Context.ACTIVITY_SERVICE);
String _pkgName = activityManager.getRunningTasks(1).get(0).topActivity.getPackageName();
在MX4（Flyme5.0 基于Android5.1）上测试可行。
弱弱的问一下，这个getSystemService报错，需要引进什么包？
两种方法都测试了
还是取不到
上一条整错地方了……
ListappList = am.getRunningAppProcesses();
打漏了泛型了
ListappList = am.getRunningAppProcesses();
打漏了泛型了
其他相似问题