arm linux 启动时间,armlinux启动之时钟初始化

1、相关数据结构

include/linux/notifier.h

struct notifier_block {

int (*notifier_call)(struct notifier_block *, unsigned long, void *);

struct notifier_block *next;

int priority;

};

通知链中的元素，记录了当发出通知时，应该执行的操作(即回调函数)

链头中保存着指向元素链表的指针。通知链元素结构则保存着回调函数的类型以及优先级

2、时钟初始化

2.1 内核初始化部分( start_kernel 函数)和时钟相关的过程主要有以下几个：

tick_init()

init_timers()

hrtimers_init()

time_init()

其中函数 hrtimers_init() 和高精度时钟相关，下面将详细介绍这几个函数。

2.2.1 tick_init 函数

kernel/time/tick-common.c

void __init tick_init(void)

{

clockevents_register_notifier(&tick_notifier);

}

static struct notifier_block tick_notifier = {

.notifier_call = tick_notify,

};

函数 tick_init() 很简单，调用 clockevents_register_notifier 函数向 clockevents_chain 通知链注册元素： tick_notifier。这个元素的回调函数指明了当时钟事件设备信息发生变化(例如新加入一个时钟事件设备等等)时，应该执行的操作，该回调函数为 tick_notify

kernel/time/tick-common.c

static int tick_notify(struct notifier_block *nb, unsigned long reason,

void *dev)

{

switch (reason) {

case CLOCK_EVT_NOTIFY_ADD:

return tick_check_new_device(dev);

case CLOCK_EVT_NOTIFY_BROADCAST_ON:

case CLOCK_EVT_NOTIFY_BROADCAST_OFF:

case CLOCK_EVT_NOTIFY_BROADCAST_FORCE:

tick_broadcast_on_off(reason, dev);

break;

case CLOCK_EVT_NOTIFY_BROADCAST_ENTER:

case CLOCK_EVT_NOTIFY_BROADCAST_EXIT:

tick_broadcast_oneshot_control(reason);

break;

case CLOCK_EVT_NOTIFY_CPU_DYING:

tick_handover_do_timer(dev);

break;

case CLOCK_EVT_NOTIFY_CPU_DEAD:

tick_shutdown_broadcast_oneshot(dev);

tick_shutdown_broadcast(dev);

tick_shutdown(dev);

break;

case CLOCK_EVT_NOTIFY_SUSPEND:

tick_suspend();

tick_suspend_broadcast();

break;

case CLOCK_EVT_NOTIFY_RESUME:

tick_resume();

break;

default:

break;

}

return NOTIFY_OK;

}

2.2.2 init_timers 函数

函数 init_timers() 的实现如清单2-1(省略了部分和

主要功能无关的内容，以后代码同样方式处理)

kernel/timer.c

void __init init_timers(void)

{

int err = timer_cpu_notify(&timers_nb, (unsigned long)CPU_UP_PREPARE,

(void *)(long)smp_processor_id());

init_timer_stats();

BUG_ON(err != NOTIFY_OK);

register_cpu_notifier(&timers_nb);

open_softirq(TIMER_SOFTIRQ, run_timer_softirq);

}

static struct notifier_block __cpuinitdata timers_nb = {

.notifier_call = timer_cpu_notify,

};

代码解释：

初始化本 CPU 上的软件时钟相关的数据结构，参见3.2节

向 cpu_chain 通知链注册元素 timers_nb ，该元素的回调函数用于初始化指定 CPU 上的软件时钟相关的数据结构

初始化时钟的软中断处理函数

kernel/timer.c

static int __cpuinit timer_cpu_notify(struct notifier_block *self,

unsigned long action, void *hcpu)

{

long cpu = (long)hcpu;

int err;

switch(action) {

case CPU_UP_PREPARE:

case CPU_UP_PREPARE_FROZEN:

err = init_timers_cpu(cpu);

if (err < 0)

return notifier_from_errno(err);

break;

#ifdef CONFIG_HOTPLUG_CPU

case CPU_DEAD:

case CPU_DEAD_FROZEN:

migrate_timers(cpu);

break;

#endif

default:

break;

}

return NOTIFY_OK;

}

2.2.3 hrtimers_init函数

kernel/hrtimer.c

void __init hrtimers_init(void)

{

hrtimer_cpu_notify(&hrtimers_nb, (unsigned long)CPU_UP_PREPARE,

(void *)(long)smp_processor_id());

register_cpu_notifier(&hrtimers_nb);

#ifdef CONFIG_HIGH_RES_TIMERS

open_softirq(HRTIMER_SOFTIRQ, run_hrtimer_softirq);

#endif

}

static struct notifier_block __cpuinitdata hrtimers_nb = {

.notifier_call = hrtimer_cpu_notify,

};

kernel/hrtimer.c

static int __cpuinit hrtimer_cpu_notify(struct notifier_block *self,

unsigned long action, void *hcpu)

{

int scpu = (long)hcpu;

switch (action) {

case CPU_UP_PREPARE:

case CPU_UP_PREPARE_FROZEN:

init_hrtimers_cpu(scpu);

break;

#ifdef CONFIG_HOTPLUG_CPU

case CPU_DYING:

case CPU_DYING_FROZEN:

clockevents_notify(CLOCK_EVT_NOTIFY_CPU_DYING, &scpu);

break;

case CPU_DEAD:

case CPU_DEAD_FROZEN:

{

clockevents_notify(CLOCK_EVT_NOTIFY_CPU_DEAD, &scpu);

migrate_hrtimers(scpu);

break;

}

#endif

default:

break;

}

return NOTIFY_OK;

}

2.2.4 time_init 函数

相关数据结构

system_timer定义在arch/arm/kernel/time.c文件开头

struct sys_timer *system_timer;

struct sys_timer定义在arch/arm/include/asm/mach/time.h文件

struct sys_timer {

struct sys_device dev;

void (*init)(void);

void (*suspend)(void);

void (*resume)(void);

#ifdef CONFIG_ARCH_USES_GETTIMEOFFSET

unsigned long (*offset)(void);

#endif

};

在分析time_init 函数前我们先来看看嵌入式Linux内核时钟初始化问题

首先搞清楚RTC在kernel内的作用: linux系统有两个时钟：一个是由主板电池驱动的“Real Time Clock”也叫做RTC或者叫CMOS时钟，硬件时钟。当操作系统关机的时候，用这个来记录时间，但是对于运行的系统是不用这个时间的。

另一个时间是 “System clock”也叫内核时钟或者软件时钟，是由软件根据时间中断来进行计数的，

内核时钟在系统关机的情况下是不存在的，所以，当操作系统启动的时候，内核时钟是要读取RTC时间来进行时间同步。并且在系统关机的时候将系统时间写回RTC中进行同步。 如前所述，Linux内核与RTC进行互操作的时机只有两个：

1) 内核在启动时从RTC中读取启动时的时间与日期；

2) 内核在需要时将时间与日期回写到RTC中。 系统启动时，内核通过读取RTC来初始化内核时钟,又叫墙上时间，该时间放在xtime变量中。

struct timespec {

__kernel_time_t tv_sec;   /* seconds */

long  tv_nsec;  /* nanoseconds */

};

问题1：系统启动时在哪读取RTC的值并设置内核时钟进行时间同步的呢?

最有可能读取RTC设置内核时钟的位置应该在arch/arm/kernel/time.c里的time_init函数内.time.c为系统的时钟驱动部分.time_init函数会在系统初始化时,由init/main.c里的start_kernel函数内调用.X86架构就是在这里读RTC值并初始化系统时钟xtime的. ARM架构的time_init代码如下

void __init time_init(void)

{

system_timer->init(); //这行实际执行的就是s3c2410_timer_init

}

其中system_timer与体系结构相关，对于2410它在arch/arm/plat-samsung/time.c初始化

struct sys_timer s3c24xx_timer = {

.init  = s3c2410_timer_init,

.offset  = s3c2410_gettimeoffset,

.resume  = s3c2410_timer_setup

};

system_timer在setup_arch(arch/arm/kernel/setup.c)内通过map_desc机制被初始化为s3c24xx_timer. 如上面s3c2410时钟驱动代码所示，s3c24xx_timer的init成员即指向s3c2410_timer_init函数。

s3c2410_timer_init

arch/arm/plat-samsung/time.c

static void __init s3c2410_timer_init(void)

{

s3c2410_timer_resources();//首先初始化timerclk、tin和tdiv三个结构体，后两个和pwm相关

s3c2410_timer_setup();//这里做了一些时钟初始化设置，但是针对timer4的

setup_irq(IRQ_TIMER4, &s3c2410_timer_irq);//设置中断处理函数

}

不过 s3c2410_timer_init()也没有读RTC的代码.整个时钟驱动初始化的过程大致就执行这些代码.既然在系统时钟驱动初始化的过程中没有读RTC值并设置内核时钟,那会在哪设置呢? 我搜了一下,发现内核好象只有在arch/cris/kernel/time.c里有RTC相关代码,如下

unsigned long

get_cmos_time(void)

{

unsigned int year, mon, day, hour, min, sec;

if(!have_rtc)

return 0;

sec = CMOS_READ(RTC_SECONDS);

min = CMOS_READ(RTC_MINUTES);

hour = CMOS_READ(RTC_HOURS);

day = CMOS_READ(RTC_DAY_OF_MONTH);

mon = CMOS_READ(RTC_MONTH);

year = CMOS_READ(RTC_YEAR);

sec = bcd2bin(sec);

min = bcd2bin(min);

hour = bcd2bin(hour);

day = bcd2bin(day);

mon = bcd2bin(mon);

year = bcd2bin(year);

if ((year += 1900) < 1970)

year += 100;

return mktime(year, mon, day, hour, min, sec);

}

这个函数会在read_persistent_clock内被调用：

void read_persistent_clock(struct timespec *ts)

{

ts->tv_sec = get_cmos_time();

ts->tv_nsec = 0;

}

另外还有设置rtc的函数

int set_rtc_mmss(unsigned long nowtime); /* write time into RTC chip */ 不过我加了printk测试了一下，好象arch/cris/kernel/time.c这个文件和这两个函数只是适用与X86？

arm平台启动时并不走这边.因此执行不到这些函数。那arm平台启动时，系统是在哪读RTC的值并对内核时钟(WallTime)进行初始化的呢？

嵌入式Linux内核(arm)是在系统启动时执行/etc/init.d/hwclock.sh脚本,这个脚本会调用hwclock小程序读取RTC的值并设置系统时钟。

(换句话说，这要取决于你制作的文件系统里是否有这样的脚本)

/* /etc/init.d/hwclock.sh */DAEMON1=/sbin/hwclock

start() {

local RET ERROR=    [ ! -f /etc/adjtime ] &&  echo "0.0 0 0.0" > /etc/adjtime

log_status_msg "Setting the System Clock using the Hardware Clock as reference..." -n    # Copies Hardware Clock time to System Clock using the correct

# timezone for hardware clocks in local time, and sets kernel

# timezone. DO NOT REMOVE.

[ "$HWCLOCKACCESS" != no ] && $DAEMON1 --hctosys $GMT $BADYEAR    #

# Now that /usr/share/zoneinfo should be available,

# announce the local time.

#

log_status_msg "System Clock set. Local time: `date`"

log_status_msg ""

return 0

}

hwclock最先读取的设备文件是 /dev/rtc  ，busybox里面的hwclock是这样实现的：

static int xopen_rtc(int flags)

{

int rtc; if (!rtcname) {

rtc = open("/dev/rtc", flags);

if (rtc >= 0)

return rtc;

rtc = open("/dev/rtc0", flags);

if (rtc >= 0)

return rtc;

rtcname = "/dev/misc/rtc";

}

return xopen(rtcname, flags);

}

2. 内核如何更新RTC时钟?

通过set_rtc函数指针指向的函数,set_rtc在arch/arm/kernel/time.c内

/* arch/arm/kernel/time.c */

/*

* hook for setting the RTC's idea of the current time.

*/

int (*set_rtc)(void);但是set_rtc函数指针在哪初始化的呢？set_rtc应该是和RTC驱动相关的函数.搜索kernel源码后发现，好象内核其他地方并没有对其初始化。待解决！

set_rtc在do_set_rtc内调用

do_set_rtc在timer_tick里调用

void timer_tick(struct pt_regs *regs)

{

profile_tick(CPU_PROFILING, regs);

do_leds();

do_set_rtc();

do_timer(1);

……

}

arch/arm/kernel/time.c

#ifndef CONFIG_GENERIC_CLOCKEVENTS

/*

* Kernel system timer support.

*/

void timer_tick(void)

{

profile_tick(CPU_PROFILING);

do_leds();

write_seqlock(&xtime_lock);

do_timer(1);

write_sequnlock(&xtime_lock);

#ifndef CONFIG_SMP

update_process_times(user_mode(get_irq_regs()));

#endif

}

#endif

timer_tick为Kernel提供的体系架构无关的时钟中断处理函数,通常会在体系架构相关的时钟中断处理函数内调用它。如s3c2410是这样的:在arch/arm/plat-samsung/time.c中

static irqreturn_t

s3c2410_timer_interrupt(int irq, void *dev_id)

{

timer_tick();

return IRQ_HANDLED;

}

static struct irqaction s3c2410_timer_irq = {

.name  = "S3C2410 Timer Tick",

.flags  = IRQF_DISABLED | IRQF_TIMER | IRQF_IRQPOLL,

.handler = s3c2410_timer_interrupt,

};

Request_irq和setup_irq的区别

request_irq在2.6.36核中它是request_threaded_irq的封装，如下：

include/linux/interrupt.h

static inline int __must_check

request_irq(unsigned int irq, irq_handler_t handler, unsigned long flags,

const char *name, void *dev)

{

return request_threaded_irq(irq, handler, NULL, flags, name, dev);

}

因此，Linux内核提供了两个注册中断处理函数的接口：setup_irq和request_threaded_irq。这两个函数都定义在kernel/irq/manage.c里。

这两个函数有什么样的区别呢？

先看看setup_irq

Setup_irq通常用在系统时钟(GP Timer)驱动里，注册系统时钟驱动的中断处理函数。

源码如下：

int setup_irq(unsigned int irq, struct irqaction *act)

{

struct irq_desc *desc = irq_to_desc(irq);

return __setup_irq(irq, desc, act);

}

EXPORT_SYMBOL_GPL(setup_irq);

下面举个列子, 如s3c2410 timer驱动：

arch/arm/plat-samsung/time.c初始化

static struct irqaction s3c2410_timer_irq = {

.name  = "S3C2410 Timer Tick",

.flags  = IRQF_DISABLED | IRQF_TIMER | IRQF_IRQPOLL,

.handler = s3c2410_timer_interrupt,

};

static void __init s3c2410_timer_init(void)

{

s3c2410_timer_resources();

s3c2410_timer_setup();

setup_irq(IRQ_TIMER4, &s3c2410_timer_irq);

}

struct sys_timer s3c24xx_timer = {

.init  = s3c2410_timer_init,

.offset  = s3c2410_gettimeoffset,

.resume  = s3c2410_timer_setup

};

可以看到，setup_irq的使用流程很简单。首先定义s3c2410 timer驱动的irqaction结构体，该结构体用于描述timer中断的基本属性包括中断名、类别以及该中断handler等。然后通过setup_irq函数将timer的irqaction注册进内核。其中，IRQ_TIMER4为s3c2410 timer的中断号。

再看看request_threaded_irq

request_threaded_irq源码如下：

/* kernel/irq/manage.c */

int request_threaded_irq(unsigned int irq, irq_handler_t handler,

irq_handler_t thread_fn, unsigned long irqflags,

const char *devname, void *dev_id)

{

struct irqaction *action;

struct irq_desc *desc;

int retval;

/*

* Sanity-check: shared interrupts must pass in a real dev-ID,

* otherwise we'll have trouble later trying to figure out

* which interrupt is which (messes up the interrupt freeing

* logic etc).

*/

if ((irqflags & IRQF_SHARED) && !dev_id)/* 使用共享中断但没有提供非NULL的dev_id则返回错误 */

return -EINVAL;

desc = irq_to_desc(irq);

if (!desc)

return -EINVAL;

if (desc->status & IRQ_NOREQUEST) /* 该中断号已被使用并且未共享 */

return -EINVAL;

if (!handler) {

if (!thread_fn)

return -EINVAL;

handler = irq_default_primary_handler;

}

action = kzalloc(sizeof(struct irqaction), GFP_KERNEL); /* 动态创建一个irqaction */

if (!action)

return -ENOMEM;

/* 下面几行是根据request_threaded_irq传进来的参数对irqaction结构体赋值 */

action->handler = handler;

action->thread_fn = thread_fn;

action->flags = irqflags;

action->name = devname;

action->dev_id = dev_id;

chip_bus_lock(irq, desc);

retval = __setup_irq(irq, desc, action);/* 调用__setup_irq注册该中断的irqaction结构体 */

chip_bus_sync_unlock(irq, desc);

if (retval)

kfree(action);

#ifdef CONFIG_DEBUG_SHIRQ

if (!retval && (irqflags & IRQF_SHARED)) {

/*

* It's a shared IRQ -- the driver ought to be prepared for it

* to happen immediately, so let's make sure....

* We disable the irq to make sure that a 'real' IRQ doesn't

* run in parallel with our fake.

*/

unsigned long flags;

disable_irq(irq);

local_irq_save(flags);

handler(irq, dev_id);

local_irq_restore(flags);

enable_irq(irq);

}

#endif

return retval;

}

由上可以看出，request_threaded_irq的大致流程为先对申请的中断线进行安全检测，然后根据request_threaded_irq传进来的参数，动态创建该中断对应的irqaction结构体，最后通过setup_irq函数将该irqaction注册进内核适当的位置。

这两个函数的使用流程搞清楚了，那么两者之间的联系也就清楚了：

1) setup_irq的注册过程包含__setup_irq，最终是调用__setup_irq。

2) request_threaded_irq比setup_irq多一套错误检测机制，即kzalloc前面3行if语句。

而setup_irq通常是直接注册irqaction，并没针对相应中断线进行错误检测,如该irq 线是否已经被占用等。因此setup_irq通常只用在特定的中断线上，如System timer。除系统时钟驱动外，大部份驱动还是通过request_threaded_irq注册中断。

这里有个小问题：

既然request_threaded_irq实际上就是包含了__setup_irq的注册过程，那系统时钟驱动(GP Timer Driver)中断可以用request_threaded_irq来注册吗？

做个小试验, 将s3c2410 timer驱动的setup_irq那行去掉，改为用request_irq注册。

修改后代码如下：

static void __init s3c2410_timer_init(void)

{

s3c2410_timer_resources();//首先初始化timerclk、tin和tdiv三个结构体，后两个和pwm相关

s3c2410_timer_setup();//这里做了一些时钟初始化设置，但是针对timer4的

//setup_irq(IRQ_TIMER4, &s3c2410_timer_irq);

request_irq(IRQ_TIMER4, &s3c2410_timer_irq,IRQF_DISABLED | IRQF_TIMER, "S3C2410 Timer Tick", NULL);

}

编译运行。

结果：内核挂掉

为什么呢？很明显，系统时钟驱动中断不能用request_irq注册，大致搜了一下源码也发现，看到其他平台相关的时钟驱动中断部分都是用的setup_irq注册的。

我们来分析一下原因。

看看request_threaded_irq和setup_irq 还有哪些细节不一样？

仔细观察后注意到request_irq内有这么一行代码：

action = kzalloc(sizeof(struct irqaction), GFP_KERNEL);

作用为动态创建一个irqaction。

kzalloc实际上是调用了 kmalloc进行分配的。源码如下：

/* include/linux/slab.h */

static inline void *kzalloc(size_t size, gfp_t flags)

{

return kmalloc(size, flags | __GFP_ZERO);

}

而kmalloc实际上也是使用的slab机制进行分配的。源码如下：

/* include/linux/slab.h */

static inline void *kmalloc(size_t size, gfp_t flags)

{

if (__builtin_constant_p(size)) {

int i = 0;

#define CACHE(x) \

if (size <= x) \

goto found; \

else \

i++;

#include "kmalloc_sizes.h"

#undef CACHE

{

extern void __you_cannot_kmalloc_that_much(void);

__you_cannot_kmalloc_that_much();

}

found:

return kmem_cache_alloc((flags & GFP_DMA) ?

malloc_sizes[i].cs_dmacachep :

malloc_sizes[i].cs_cachep, flags);

}

return __kmalloc(size, flags);

}

使用slab机制分配内存必须先对slab进行初始化,包括mem_init和kmem_cache_init。

看看kernel的初始化流程:

/* init/main.c */

asmlinkage void __init start_kernel(void)

{

……

time_init();

……

time_init();

profile_init();

if (!irqs_disabled())

printk(KERN_CRIT "start_kernel(): bug: interrupts were "

"enabled early\n");

early_boot_irqs_on();

local_irq_enable();

/* Interrupts are enabled now so all GFP allocations are safe. */

gfp_allowed_mask = __GFP_BITS_MASK;

kmem_cache_init_late();---- set up the general caches

……

}

Time_init函数在kmem_cache_init_late之前被调用，而time_init会调用体系结构相关部分系统时钟驱动的初始化函数。拿s3c2410的例子来说，time_init最终会调用s3c2410_timer_init函数，进行s3c2410时钟驱动的初始化和注册中断处理函数。

具体过程如下：

time_init函数定义在arch/arm/kernel/time.c内:

void __init time_init(void)

{

system_timer->init(); //这行实际执行的就是s3c2410_timer_init

}

system_timer在setup_arch(arch/arm/kernel/setup.c)内通过map_desc机制被初始化为s3c24xx_timer. 如上面s3c2410时钟驱动代码所示，s3c24xx_timer的init成员即指向s3c2410_timer_init函数。

现在我们搞清楚了，我们大概的估计是系统时钟驱动(GP Timer Driver)的中断处理函数不能用request_irq注册是因为request_irq内会调用kmalloc动态分配内存创建timer的irqaction结构体。而kmalloc也是使用的slab内存分配机制，使用kmalloc前必须先对kernel的slab以及mem data structure进行初始化。而这部分初始化工作是在系统时钟驱动初始化之后才进行的，所以造成kmalloc失败，从而造成系统时钟驱动的中断未注册成功，进而内核挂掉。