TIMERS

TIMERS :: All in all revolving and diff with RTOS n Non RTOS.

To analyse run time behavior and performance of software systems, accurate time measurements are needed. For this, timer methods are used, which are based on hardware timers and counters that are read and processed by several software layers. These processing layers introduce overhead and delays that impact accuracy and statistical validity of measurements, especially for fine-granular measurements. To understand and to control these impacts, the resulting accuracy of timer methods and their invocation costs must be quantified. However, quantitative properties of timer methods are mostly unavailable, as they are platform-specific due to differences in hardware, operating systems and virtual machines. Also, no algorithm exists for precisely quantifying the invocation costs and the accuracy of timer methods, so programmers have to work with coarse estimates and cannot evaluate and compare different timer methods and timer APIs.(Not in the case of RTOS, as in RTOS we can predict the Task execution and if any dead lock).

Linux Story : http://www.jeepshoe.org/205004401.htm
http://armbedded.eu/documentation/html/stamp9g20technicalreference/bk01-toc.html

In Start_kernel timer initialization will be done(   tick_init(); //初始化内核时钟系统).And remaining all other functions are also called.
Basic BUS, DRIVER, Hyper visor .....

三、系统启动C语言部分

架构相关的汇编部分代码运行完之后，就是架构相关性比较小的C语言部分，位于init/main.c里的start_kernel函数。

1、start_kernel函数

start_kernel函数对于驱动工程师来说，需要重点关注的是内核启动参数的获取与处理、setup_arch(&command_line)函数、rest_init()函数。其它是内存管理的初始化和内核各个组件的数据结构的内存申请并初始化。

点击(此处)折叠或打开

1. asmlinkage void __init start_kernel(void)
2. {
3.     char * command_line;
4.     //地址指针，指向内核启动参数在内存中的位置（虚拟地址）
5.     extern const struct kernel_param __start___param[], __stop___param[];
6. 
   
7.     smp_setup_processor_id(); //针对SMP处理器，如果不是，则是弱引用函数
8. 
   
9.     /*
10.      * Need to run as early as possible, to initialize the
11.      * lockdep hash:
12.      */
13.     lockdep_init(); //内核调试模块，用于检查内核互斥机制潜在的死锁问题
14.     debug_objects_early_init();
15. 
    
16.     /*
17.      * Set up the the initial canary ASAP:
18.      */
19.     boot_init_stack_canary(); //初始化栈canary值，canary值用于防止栈溢出攻击的堆栈的保护字
20. 
    
21.     cgroup_init_early(); //一组进程的行为控制，做数据结构和其中链表的初始化
22. 
    
23.     local_irq_disable(); //关闭系统总中断
24.     early_boot_irqs_disabled = true;
25. 
    
26. /*
27.  * Interrupts are still disabled. Do necessary setups, then
28.  * enable them
29.  */
30.     tick_init(); //初始化内核时钟系统
31.     boot_cpu_init(); //激活当前CPU
32.     page_address_init(); //高端内存相关，未定义的话为空函数
33.     printk(KERN_NOTICE "%s", linux_banner); //打印内核版本信息，内核启动的第一行信息就来自这
34.     setup_arch(&command_line); //1 内核架构相关初始化函数
35.     mm_init_owner(&init_mm, &init_task); //初始化init_mm结构体
36.     mm_init_cpumask(&init_mm);
37.     setup_command_line(command_line); //对command_line进行备份与保存
38.     setup_nr_cpu_ids(); //一下三个函数针对SMP处理器，不是SMP处理器都为空函数
39.     setup_per_cpu_areas();
40.     smp_prepare_boot_cpu();    /* arch-specific boot-cpu hooks */
41. 
    
42.     build_all_zonelists(NULL); //设置内存相关节点和其中的内存域数据结构
43.     page_alloc_init();
45.     //2 打印与解析内核启动参数
46.     printk(KERN_NOTICE "Kernel command line: %s\n", boot_command_line);
47.     parse_early_param();
48.     parse_args("Booting kernel", static_command_line, __start___param,
49.          __stop___param - __start___param,
50.          &unknown_bootoption);
51. 
    
52.     jump_label_init();
53. 
    
54.     /*
55.      * These use large bootmem allocations and must precede
56.      * kmem_cache_init()
57.      */
58.     setup_log_buf(0); //使用bootmem分配一个启动信息的缓冲区
59.     pidhash_init(); //使用bootmem分配并初始化PID散列表
60.     vfs_caches_init_early(); //前期VFS缓存初始化
61.     sort_main_extable(); //对内核异常表进行排序
62.     trap_init(); //对内核陷阱异常经行初始化，ARM架构中位空函数
63.     mm_init(); //初始化内核内存分配器，启动信息中的内存信息来自此函数中的mem_init函数
64. 
    
65.     /*
66.      * Set up the scheduler prior starting any interrupts (such as the
67.      * timer interrupt). Full topology setup happens at smp_init()
68.      * time - but meanwhile we still have a functioning scheduler.
69.      */
70.     sched_init(); //初始化调度器数据结构并创建运行队列
71.     /*
72.      * Disable preemption - early bootup scheduling is extremely
73.      * fragile until we cpu_idle() for the first time.
74.      */
75.     preempt_disable(); //禁用抢占和中断，早期启动时期，调度是极其脆弱的
76.     if (!irqs_disabled()) {
77.         printk(KERN_WARNING "start_kernel(): bug: interrupts were "
78.                 "enabled *very* early, fixing it\n");
79.         local_irq_disable();
80.     }
81.     idr_init_cache(); //为IDR机制分配缓存
82.     perf_event_init(); //CPU性能检测机制初始化
83.     rcu_init(); //内核RCU机制初始化
84.     radix_tree_init(); //内核radix树算法初始化
85.     /* init some links before init_ISA_irqs() */
86.     early_irq_init(); //前期外部中断描述符初始化
87.     init_IRQ(); //架构相关中断初始化
88.     prio_tree_init(); //基于radix树的优先级搜索树(PST)初始化
89.     init_timers(); //以下5个函数是软中断和内核时钟机制初始化
90.     hrtimers_init();
91.     softirq_init();
92.     timekeeping_init();
93.     time_init();
94.     profile_init(); //profile子系统初始化，内核的性能调试工具
95.     call_function_init();
96.     if (!irqs_disabled())
97.         printk(KERN_CRIT "start_kernel(): bug: interrupts were "
98.                  "enabled early\n");
99.     early_boot_irqs_disabled = false;
100.     local_irq_enable(); //开启总中断
101. 
     
102.     /* Interrupts are enabled now so all GFP allocations are safe. */
103.     gfp_allowed_mask = __GFP_BITS_MASK;
104. 
     
105.     kmem_cache_init_late(); //slab分配器后期初始化
106. 
     
107.     /*
108.      * HACK This is early. We're enabling the console before
109.      * we've done PCI setups etc, and console_init() must be aware of
110.      * this. But we do want output early, in case something goes wrong.
111.      */
112.     console_init(); //初始化控制台
113.     if (panic_later) //检查内核恐慌标准，如果有问题，打印信息
114.         panic(panic_later, panic_param);
115. 
     
116.     lockdep_info(); //打印lockdep调试模块信息
117. 
     
118.     /*
119.      * Need to run this when irqs are enabled, because it wants
120.      * to self-test [hard/soft]-irqs on/off lock inversion bugs
121.      * too:
122.      */
123.     locking_selftest();
124.  
125. //检查initrd的位置是否符合要求
126. #ifdef CONFIG_BLK_DEV_INITRD
127.     if (initrd_start && !initrd_below_start_ok &&
128.      page_to_pfn(virt_to_page((void *)initrd_start)) < min_low_pfn) {
129.         printk(KERN_CRIT "initrd overwritten (0x%08lx < 0x%08lx) - "
130.          "disabling it.\n",
131.          page_to_pfn(virt_to_page((void *)initrd_start)),
132.          min_low_pfn);
133.         initrd_start = 0;
134.     }
135. #endif
136.     page_cgroup_init();
137.     enable_debug_pagealloc(); //使能页分配的调试标志
138.     debug_objects_mem_init();
139.     kmemleak_init(); //内存泄露检测机制的初始化
140.     setup_per_cpu_pageset(); //设置每个CPU的页组并初始化
141.     numa_policy_init(); //分一致性内存访问(NUMA)初始化
142.     if (late_time_init)
143.         late_time_init();
144.     sched_clock_init(); //初始化调度时钟
145.     calibrate_delay();
146.     pidmap_init(); //PID分配映射初始化
147.     anon_vma_init(); //匿名虚拟内存域初始化
148. #ifdef CONFIG_X86
149.     if (efi_enabled)
150.         efi_enter_virtual_mode();
151. #endif
152.     thread_info_cache_init();
153.     cred_init(); //任务信用系统初始化
154.     fork_init(totalram_pages); //进程创建机制初始化
155.     proc_caches_init();
156.     buffer_init(); //缓存系统初始化，创建缓存头空间，并检查其大小限制
157.     key_init(); //内核密钥管理系统初始化
158.     security_init(); //内核安全框架初始化
159.     dbg_late_init(); //内核调试系统后期初始化
160.     vfs_caches_init(totalram_pages); //虚拟文件系统缓存初始化
161.     signals_init(); //信号管理系统初始化
162.     /* rootfs populating might need page-writeback */
163.     page_writeback_init(); //页回写机制初始化
164. #ifdef CONFIG_PROC_FS
165.     proc_root_init(); //proc文件系统初始化
166. #endif
167.     cgroup_init(); //control group正式初始化
168.     cpuset_init(); //CPUSET初始化
169.     taskstats_init_early(); //任务状态早期初始化函数，为任务获取高速缓存并初始化互斥机制
170.     delayacct_init(); //任务延迟机制初始化
171. 
     
172.     check_bugs();
173. 
     
174.     acpi_early_init(); /* before LAPIC and SMP init */
175.     sfi_init_late();
176. 
     
177.     ftrace_init();
178. 
     
179.     /* Do the rest non-__init'ed, we're now alive */
180.     rest_init(); //3 剩余的初始化
181. }

2、setup_arch函数

下面分析架构相关的初始化函数setup_arch函数。

点击(此处)折叠或打开

1. void __init setup_arch(char **cmdline_p)
2. {
3.     struct machine_desc *mdesc; //设备描述结构体
4. 
   
5.     setup_processor(); //再次检测处理器类型，并初始化处理器相关的底层变量，内核启动时处理器信息就是通过该函数打印
6.     mdesc = setup_machine_fdt(__atags_pointer); //检测bootloader传递的Machine ID与机器ID是否匹配。若匹配打印Machine ID，处理tagged_list；若不匹配，给出出错信息，死循环。
7.     if (!mdesc)
8.         mdesc = setup_machine_tags(machine_arch_type);
9.     machine_desc = mdesc;
10.     machine_name = mdesc->name;
11. 
    
12. #ifdef CONFIG_ZONE_DMA
13.     if (mdesc->dma_zone_size) {
14.         extern unsigned long arm_dma_zone_size;
15.         arm_dma_zone_size = mdesc->dma_zone_size;
16.     }
17. #endif
18.     if (mdesc->soft_reboot) //设置重启类型，“s”软件重启，“h”硬件重启
19.         reboot_setup("s");
20. 
    
21.     init_mm.start_code = (unsigned long) _text; //init_mm部分数据初始化
22.     init_mm.end_code = (unsigned long) _etext;
23.     init_mm.end_data = (unsigned long) _edata;
24.     init_mm.brk     = (unsigned long) _end;
25. 
    
26.     /* populate cmd_line too for later use, preserving boot_command_line */
27.     strlcpy(cmd_line, boot_command_line, COMMAND_LINE_SIZE);
28.     *cmdline_p = cmd_line;
29. 
    
30.     parse_early_param();
31. 
    
32.     sanity_check_meminfo();
33.     arm_memblock_init(&meminfo, mdesc);
34. 
    
35.     paging_init(mdesc);
36.     request_standard_resources(mdesc);
37. 
    
38.     unflatten_device_tree();
39. 
    
40. #ifdef CONFIG_SMP
41.     if (is_smp())
42.         smp_init_cpus();
43. #endif
44.     reserve_crashkernel();
45. 
    
46.     tcm_init();
47. 
    
48. #ifdef CONFIG_MULTI_IRQ_HANDLER
49.     handle_arch_irq = mdesc->handle_irq;
50. #endif
51. 
    
52. #ifdef CONFIG_VT
53. #if defined(CONFIG_VGA_CONSOLE)
54.     conswitchp = &vga_con;
55. #elif defined(CONFIG_DUMMY_CONSOLE)
56.     conswitchp = &dummy_con;
57. #endif
58. #endif
59.     early_trap_init();
60. 
    
61.     if (mdesc->init_early)
62.         mdesc->init_early();
63. }

3、rest_init函数

rest_init函数的主要功能是创建并启动内核线程init。

点击(此处)折叠或打开

1. /*
2.  * We need to finalize in a non-__init function or else race conditions
3.  * between the root thread and the init thread may cause start_kernel to
4.  * be reaped by free_initmem before the root thread has proceeded to
5.  * cpu_idle.
6.  *
7.  * gcc-3.4 accidentally inlines this function, so use noinline.
8.  */
9.  
10. //定义一个complete变量告诉init线程：kthreads线程已经创建完成。
11. static __initdata DECLARE_COMPLETION(kthreadd_done);
12. 
    
13. static noinline void __init_refok rest_init(void)
14. {
15.     int pid;
16. 
    
17.     rcu_scheduler_starting(); //内核RCU锁机制调度启动
18.     /*
19.      * We need to spawn init first so that it obtains pid 1, however
20.      * the init task will end up wanting to create kthreads, which, if
21.      * we schedule it before we create kthreadd, will OOPS.
22.      */
23.     kernel_thread(kernel_init, NULL, CLONE_FS | CLONE_SIGHAND); //创建kernel_init内核线程，PID=1
24.     numa_default_policy();
25.     pid = kernel_thread(kthreadd, NULL, CLONE_FS | CLONE_FILES); //创建kthread内核线程,PID=2
26.     rcu_read_lock();
27.     kthreadd_task = find_task_by_pid_ns(pid, &init_pid_ns); //获取kthread线程信息
28.     rcu_read_unlock();
29.     complete(&kthreadd_done); //通过complete通知kernel_init线程kthread线程已创建成功
30. 
    
31.     /*
32.      * The boot idle thread must execute schedule()
33.      * at least once to get things moving:
34.      */
35.     init_idle_bootup_task(current); //设置当前进程为idle进程类
36.     preempt_enable_no_resched(); //使能抢占，但不重新调度
37.     schedule(); //执行调度，切换进程
38. 
    
39.     /* Call into cpu_idle with preempt disabled */
40.     preempt_disable(); //进程调度完成，禁用抢占
41.     cpu_idle(); //内核本体进入idle状态，用循环消耗空闲的CPU时间
42. }

4、kernel_init函数

kernel_init函数是内核init线程运行的函数：完成设备驱动程序的初始化，并调用init_post函数启动用户空间的init进程。

点击(此处)折叠或打开

1. static int __init kernel_init(void * unused)
2. {
3.     /*
4.      * Wait until kthreadd is all set-up.
5.      */
6.     wait_for_completion(&kthreadd_done);
7.     /*
8.      * init can allocate pages on any node
9.      */
10.     set_mems_allowed(node_states[N_HIGH_MEMORY]);
11.     /*
12.      * init can run on any cpu.
13.      */
14.     set_cpus_allowed_ptr(current, cpu_all_mask);
15. 
    
16.     cad_pid = task_pid(current);
17. 
    
18.     smp_prepare_cpus(setup_max_cpus);
19. 
    
20.     do_pre_smp_initcalls();
21.     lockup_detector_init();
22. 
    
23.     smp_init();
24.     sched_init_smp();
25. 
    
26.     do_basic_setup(); //重要函数，主要是初始化设备驱动程序
27. 
    
28.     /* Open the /dev/console on the rootfs, this should never fail */
29.     //这里要打开/dev/console节点，在此出错可能的原因是：
30.     //1. 制作文件系统时忘记创建/dev/console节点；
31.     //2. 文件系统挂载问题，挂载的文件系统不是什么都没有就是挂错了节点。
32.     if (sys_open((const char __user *) "/dev/console", O_RDWR, 0) < 0)
33.         printk(KERN_WARNING "Warning: unable to open an initial console.\n");
34.  
35.     //复制两次标准输入（0），一个作为标准输出（1），一个作为标准出错（2）。 
36.     //完成后，标准输入、标准输出、标准出错都是/dev/console了
37.     (void) sys_dup(0);
38.     (void) sys_dup(0);
39.     /*
40.      * check if there is an early userspace init. If yes, let it do all
41.      * the work
42.      */
43. 
    
44.     if (!ramdisk_execute_command)
45.         ramdisk_execute_command = "/init";
46. 
    
47.     if (sys_access((const char __user *) ramdisk_execute_command, 0) != 0) {
48.         ramdisk_execute_command = NULL;
49.         prepare_namespace();
50.     }
51. 
    
52.     /*
53.      * Ok, we have completed the initial bootup, and
54.      * we're essentially up and running. Get rid of the
55.      * initmem segments and start the user-mode stuff..
56.      */
57. 
    
58.     init_post(); //启动用户空间init进程
59.     return 0;
60. }

5、init_post函数

init_post真正启动用户空间init进程。

点击(此处)折叠或打开

1. /* This is a non __init function. Force it to be noinline otherwise gcc
2.  * makes it inline to init() and it becomes part of init.text section
3.  */
4. static noinline int init_post(void)
5. {
6.     /* need to finish all async __init code before freeing the memory */
7.     async_synchronize_full();
8.     free_initmem(); //释放所有init.*段中的内存
9.     mark_rodata_ro();
10.     system_state = SYSTEM_RUNNING; //设置系统状态为运行状态
11.     numa_default_policy();
12. 
    
13. 
    
14.     current->signal->flags |= SIGNAL_UNKILLABLE; //设置当前进程（init）为不可杀进程
15. 
    
16.     if (ramdisk_execute_command) {
17.         run_init_process(ramdisk_execute_command);
18.         printk(KERN_WARNING "Failed to execute %s\n",
19.                 ramdisk_execute_command);
20.     }
21. 
    
22.     /*
23.      * We try each of these until one succeeds.
24.      *
25.      * The Bourne shell can be used instead of init if we are
26.      * trying to recover a really broken machine.
27.      */
28.     if (execute_command) {
29.         run_init_process(execute_command);
30.         printk(KERN_WARNING "Failed to execute %s. Attempting "
31.                     "defaults...\n", execute_command);
32.     }
33.     run_init_process("/sbin/init");
34.     run_init_process("/etc/init");
35.     run_init_process("/bin/init");
36.     run_init_process("/bin/sh");
37.  
38.  
39.     //检查完ramdisk_execute_command和execute_command为空的情况下，顺序执行四个初始化程序。
40.     //如果都没有找到就打印出错信息，出现该错误的可能原因是：
41.     //1. 启动参数配置有问题：指定了init进程，但是没找到，默认四个程序不在文件系统中；
42.     //2. 文件系统挂载有问题；
43.     //3. init程序没有执行权限。
44.     panic("No init found. Try passing init= option to kernel. "
45.      "See Linux Documentation/init.txt for guidance.");
46. }

6、do_basic_setup函数

内核init线程调用了do_basic_setup函数，这个函数也做了很多内核与驱动的初始化工作。

点击(此处)折叠或打开

1. /*
2.  * Ok, the machine is now initialized. None of the devices
3.  * have been touched yet, but the CPU subsystem is up and
4.  * running, and memory and process management works.
5.  *
6.  * Now we can finally start doing some real work..
7.  */
8. static void __init do_basic_setup(void)
9. {
10.     cpuset_init_smp(); //对于非SMP处理器，该函数为空
11.     usermodehelper_init(); //创建单线程工作队列khelper
12.     shmem_init();
13.     driver_init(); //初始化驱动模型中的各个子系统
14.     init_irq_proc(); //在proc文件系统中创建irq目录
15.     do_ctors(); //调用链接到所有的构造函数
16.     usermodehelper_enable(); //使能单线程工作队列khelper
17.  
18.     /*
19.      * 1. 调用所有编译进内核的驱动的初始化函数，按照各个内核模块初始化函数所定义的启动级别（1~7）， 按顺序调用初始化函数；
20.      * 2. 对于同一级别的初始化函数，安装编译是链接的顺序调用，和内核的Makefile编写有关；
21.      * 3. 基于某一子系统的驱动，其初始化函数的级别必须低于该子系统初始化函数的级别，如果编写的模块必须和依赖的模块在同一级，就必须Makefile的编写了。
22.      */
23.     do_initcalls();
24. }

7、driver_init函数

driver_init函数的作用是驱动模型的子系统初始化，位于drivers/base/init.c。

点击(此处)折叠或打开

1. /**
2.  * driver_init - initialize driver model.
3.  *
4.  * Call the driver model init functions to initialize their
5.  * subsystems. Called early from init/main.c.
6.  */
7. void __init driver_init(void)
8. {
9.     /* These are the core pieces */  
10.     devtmpfs_init();
11. 点击(此处)折叠或打开

    1. 初始化devtmpfs文件系统，驱动核心设备将在这个文件系统中添加它们的设备节点。
    2. 这个文件系统可以由内核在挂载根文件系统之后自动挂载到/dev下，也可以在文件系统的启动脚本中手动挂载。
12.      devices_init();
13. 点击(此处)折叠或打开

    1. 初始化驱动模型中的部分子系统和kobject：
    2. devices
    3. dev
    4. dev/block
    5. dev/char
14.     buses_init(); //初始化驱动模型中的bus子系统
15.     classes_init(); //初始化驱动模型中的class子系统
16.     firmware_init(); //初始化驱动模型中的firmware子系统
17.     hypervisor_init(); //初始化驱动模型中的hypervisor子系统
18. 
    
19.     /* These are also core pieces, but must come after the
20.      * core core pieces.
21.      */
22.     platform_bus_init(); //初始化驱动模型中的bus/platform子系统
23.     system_bus_init(); //初始化驱动模型中的devices/system子系统
24.     cpu_dev_init(); //初始化驱动模型中的devices/system/cpu子系统
25.     memory_dev_init(); //初始化驱动模型中的devices/system/memory子系统
26. }