armlinux启动之时钟初始化

谁践踏了优雅 2022-03-26 15:48 316阅读 0赞

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失败，从而造成系统时钟驱动的中断未注册成功，进而内核挂掉。