执行tasklet任务的进程ID是多少？

印随

1. 
   
2. #include <linux/module.h>
   
3. #include <linux/moduleparam.h>
   
4. #include <linux/init.h>
   
5. 
   
6. #include <linux/time.h>
   
7. #include <linux/timer.h>
   
8. #include <linux/kernel.h>
   
9. #include <linux/proc_fs.h>
   
10. #include <linux/types.h>
    
11. #include <linux/spinlock.h>
    
12. #include <linux/interrupt.h>
    
13. 
    
14. #include <asm/hardirq.h>
    
15. /*
    
16. * This module is a silly one: it only embeds short code fragments
    
17. * that show how time delays can be handled in the kernel.
    
18. */
    
19. 
    
20. int delay = HZ; /* the default delay, expressed in jiffies */
    
21. 
    
22. module_param(delay, int, 0);
    
23. 
    
24. MODULE_AUTHOR("Alessandro Rubini");
    
25. MODULE_LICENSE("Dual BSD/GPL");
    
26. 
    
27. /* This data structure used as "data" for the timer and tasklet functions */
    
28. struct jit_data {
    
29.         struct timer_list timer;
    
30.         struct tasklet_struct tlet;
    
31.         int hi; /* tasklet or tasklet_hi */
    
32.         wait_queue_head_t wait;
    
33.         unsigned long prevjiffies;
    
34.         unsigned char *buf;
    
35.         int loops;
    
36. };
    
37. #define JIT_ASYNC_LOOPS 5
    
38. 
    
39. 
    
40. void jit_tasklet_fn(unsigned long arg)
    
41. {
    
42.         struct jit_data *data = (struct jit_data *)arg;
    
43.         unsigned long j = jiffies;
    
44.         data->buf += sprintf(data->buf, "%9li  %3li     %i    %6i   %i   %s\n",
    
45.                              j, j - data->prevjiffies, in_interrupt() ? 1 : 0,
    
46.                              current->pid, smp_processor_id(), current->comm);
    
47. 
    
48.         if (--data->loops) {
    
49.                 data->prevjiffies = j;
    
50.                 if (data->hi)
    
51.                         tasklet_hi_schedule(&data->tlet);
    
52.                 else
    
53.                         tasklet_schedule(&data->tlet);
    
54.         } else {
    
55.                 wake_up_interruptible(&data->wait);
    
56.         }
    
57. }
    
58. 
    
59. /* the /proc function: allocate everything to allow concurrency */
    
60. int jit_tasklet(char *buf, char **start, off_t offset,
    
61.               int len, int *eof, void *arg)
    
62. {
    
63.         struct jit_data *data;
    
64.         char *buf2 = buf;
    
65.         unsigned long j = jiffies;
    
66.         long hi = (long)arg;
    
67. 
    
68.         data = kmalloc(sizeof(*data), GFP_KERNEL);
    
69.         if (!data)
    
70.                 return -ENOMEM;
    
71. 
    
72.         init_waitqueue_head (&data->wait);
    
73. 
    
74.         /* write the first lines in the buffer */
    
75.         buf2 += sprintf(buf2, "   time   delta  inirq    pid   cpu command\n");
    
76.         buf2 += sprintf(buf2, "%9li  %3li     %i    %6i   %i   %s\n",
    
77.                         j, 0L, in_interrupt() ? 1 : 0,
    
78.                         current->pid, smp_processor_id(), current->comm);
    
79. 
    
80.         /* fill the data for our tasklet function */
    
81.         data->prevjiffies = j;
    
82.         data->buf = buf2;
    
83.         data->loops = JIT_ASYNC_LOOPS;
    
84.        
    
85.         /* register the tasklet */
    
86.         tasklet_init(&data->tlet, jit_tasklet_fn, (unsigned long)data);
    
87.         data->hi = hi;
    
88.         if (hi)
    
89.                 tasklet_hi_schedule(&data->tlet);
    
90.         else
    
91.                 tasklet_schedule(&data->tlet);
    
92. 
    
93.         /* wait for the buffer to fill */
    
94.         wait_event_interruptible(data->wait, !data->loops);
    
95. 
    
96.         if (signal_pending(current))
    
97.                 return -ERESTARTSYS;
    
98.         buf2 = data->buf;
    
99.         kfree(data);
    
100.         *eof = 1;
     
101.         return buf2 - buf;
     
102. }
     
103. 
     
104. 
     
105. 
     
106. int __init jit_init(void)
     
107. {
     
108.         create_proc_read_entry("jitasklet", 0, NULL, jit_tasklet, NULL);
     
109.         create_proc_read_entry("jitasklethi", 0, NULL, jit_tasklet, (void *)1);
     
110. 
     
111.         return 0; /* success */
     
112. }
     
113. 
     
114. void __exit jit_cleanup(void)
     
115. {
     
116.         remove_proc_entry("jitasklet", NULL);
     
117.         remove_proc_entry("jitasklethi", NULL);
     
118. }
     
119. 
     
120. module_init(jit_init);
     
121. module_exit(jit_cleanup);
     

复制代码

印随

#cat /proc/jitasklet
   time   delta  inirq    pid   cpu command
   724884    0     0      3006   0   cat
   724884    0     1         3   0   ksoftirqd/0
   724884    0     1         3   0   ksoftirqd/0
   724884    0     1         3   0   ksoftirqd/0
   724884    0     1         3   0   ksoftirqd/0
   724884    0     1         3   0   ksoftirqd/0

印随

其中最后5行 pid为什么是3呢？

从我的经验来看，pid应该是0才对啊？

哪位大侠能帮我看看？（代码是摘自LDD）

[ 本帖最后由 印随 于 2009-10-21 22:24 编辑 ]

zyr-linux

0——swapper
1——init

写个tasklet打下pid不就知道了？

印随

上面的代码就是tasklet打印pid，结果是3， 很是不解

peimichael

tasklet有PID么？
他根本不是一个进程,taskstruct都没有，应该是在中断上下文执行的把
打印3应该是因为中断打断的是三号进程？
还有一个原因，可能是在ksoftirqd中执行的，看看3是不是ksoftirqd的进程号？

纯属个人猜测。

peimichael

我晕，我怎么变成新手了，积分和帖子怎么都没了？

peimichael

换个ID登下把_cu去掉，试试看
总算恢复了，两个id显示的名字居然一样。。。
这个id的编号怎么是负的。。。

[ 本帖最后由 peimichael 于 2009-10-22 14:21 编辑 ]

xiaozhe2000

tasklet应该有专门的kernel thread来运行，pid=3应该是合理的的

xiaozhe2000

啊，发现我的编号也成负的了