基于2.6.11内核init进程

最新推荐文章于 2021-05-13 00:13:59 发布

jerry6699

最新推荐文章于 2021-05-13 00:13:59 发布

阅读量184

点赞数

分类专栏：进程

本文链接：https://blog.csdn.net/chengbeng1745/article/details/104454899

版权

进程专栏收录该内容

13 篇文章 1 订阅

订阅专栏

1. 流程

start_kernel()---->rest_init()

rest_init的定义如下:

371 static void noinline rest_init(void)                                            
372         __releases(kernel_lock)                                                 
373 {                                                                               
374         kernel_thread(init, NULL, CLONE_FS | CLONE_SIGHAND);      //进程的入口函数是init函数              
375         printk(KERN_ERR "tom rest_init=%x",init);                                                                                                          
376         numa_default_policy();                                                  
377         unlock_kernel();                                                        
378         preempt_enable_no_resched();                                            
379         cpu_idle();                                                             
380 }

2. kernel_thread

在kernel_thread的参数:
fn: 函数入口
arg:
flags:

297 int kernel_thread(int (*fn)(void *), void * arg, unsigned long flags)           
298 {                                                                               
299         if(flags==(CLONE_FS | CLONE_SIGHAND))                                   
300             printk(KERN_ERR "tom  kernel_thread\n");                            
301         struct pt_regs regs;                                                    
302                                                                                 
303         memset(&regs, 0, sizeof(regs));                                         
304                                                                                 
305         regs.ebx = (unsigned long) fn;                                          
306         regs.edx = (unsigned long) arg;                                         
307                                                                                 
308         regs.xds = __USER_DS;                                                   
309         regs.xes = __USER_DS;                                                   
310         regs.orig_eax = -1;                                                     
311         regs.eip = (unsigned long) kernel_thread_helper;                        
312         regs.xcs = __KERNEL_CS;                                                 
313         regs.eflags = X86_EFLAGS_IF | X86_EFLAGS_SF | X86_EFLAGS_PF | 0x2;      
314                                                                                 
315         /* Ok, create the new process.. */                                      
316         return do_fork(flags | CLONE_VM | CLONE_UNTRACED, 0, &regs, 0, NULL, NULL);
317 }

dup_task_struct

 134 static struct task_struct *dup_task_struct(struct task_struct *orig)            
 135 {                                                                                                        
 136         if ( !strcmp(orig->comm, "swapper"))                                                             
 137                             printk(KERN_ERR "tom dup_task_struct\n");           
 138         struct task_struct *tsk;                                                
 139         struct thread_info *ti;                                                 
 140                                                                                 
 141         prepare_to_copy(orig);                                                  
 142                                                                                 
 143         tsk = alloc_task_struct();                                              
 144         if (!tsk)                                                               
 145                 return NULL;                                                    
 146                                                                                 
 147         ti = alloc_thread_info(tsk);                                            
 148         if (!ti) {                                                              
 149                 free_task_struct(tsk);                                          
 150                 return NULL;                                                    
 151         }                                                                                                                                                 
 152                                                                                 
 153         *ti = *orig->thread_info;                                               
 154         *tsk = *orig;                                                           
 155         tsk->thread_info = ti;                                                  
 156         ti->task = tsk;                                                         
 157                                                                                 
 158         /* One for us, one for whoever does the "release_task()" (usually parent) */
 159         atomic_set(&tsk->usage,2);                                              
 160         return tsk;                                                             
 161 }