走读printk代码

智慧书仓 2013-03-04

展开全文

http://www./Linux/2011-09/43677.htm

在我们书写内核代码的时候通常会使用printk，这里我们看下printk是如何和uart关联起来的。关于uart的相关的硬件知识不介绍了，so easy。我们这里只是走读下printk的代码，看看和uart的驱动的关联。

printk---函数实现在kernel/printk.c文件中。接下来的很多的函数都是在这个文件中。

这是一个神奇的函数哦，参数中的“...”可以让你参数输入的比较随意了。在函数体中声明一个va_list，然后用va_start函数来获取参数列表中的参数，使用完毕后调用va_end()结束。

asmlinkage int printk(const char *fmt, ...)
{
va_list args;
int r;
#ifdef CONFIG_KGDB_KDB
if (unlikely(kdb_trap_printk)) {
va_start(args, fmt);
r = vkdb_printf(fmt, args);
va_end(args);
return r;
}
#endif
va_start(args, fmt);
_trace_kernel_printk(_RET_IP_);
r = vprintk(fmt, args);
va_end(args);
return r;
}

这里就是对数据的规整，最终走到了vprintk这个函数中。

asmlinkage int vprintk(const char *fmt, va_list args)
{
........................
spin_lock(&logbuf_lock); //申请到对log buffer的锁，锁的使用对防止并发有很好的作用
........................
/* 这里会看到我们的输入的log level的处理 */
if (p[0] == '<') {
unsigned char c = p[1];
if (c && p[2] == '>') {
switch (c) {
case '0' ... '7': /* loglevel */
current_log_level = c - '0';
/* Fallthrough - make sure we're on a new line */
case 'd': /* KERN_DEFAULT */
if (!new_text_line) {
emit_log_char('\n');
new_text_line = 1;
}
/* Fallthrough - skip the loglevel */
case 'c': /* KERN_CONT */
p += 3;
break;
}
}
}
/*
* 在这里就把所要输出的内容copy to log_buf。然后判断是否需要打印log tag，和时间戳。
*/
for ( ; *p; p++) {
if (new_text_line) {
/* Always output the token */
emit_log_char('<');
emit_log_char(current_log_level + '0');
emit_log_char('>');
printed_len += 3;
new_text_line = 0;
if (printk_time) {
/* Follow the token with the time */
char tbuf[50], *tp;
unsigned tlen;
unsigned long long t;
unsigned long nanosec_rem;
t = cpu_clock(printk_cpu);
nanosec_rem = do_div(t, 1000000000);
tlen = sprintf(tbuf, "[%5lu.%06lu] ",
(unsigned long) t,
nanosec_rem / 1000);
for (tp = tbuf; tp < tbuf + tlen; tp++)
emit_log_char(*tp);
printed_len += tlen;
}
if (!*p)
break;
}
emit_log_char(*p);
if (*p == '\n')
new_text_line = 1;
}
/*
*取得console的使用标志并且要立即释放掉，释放函数会做输出的动作
*
* 在前面看到的spin_lock(&logbuf_lock)，在函数acquire_console_semaphore_for_printk函数中也会得到释放
*重申：对于锁一定要记得去释放
*/
if (acquire_console_semaphore_for_printk(this_cpu))
release_console_sem();
............................
}

那么下面我们看看release_console_sem是如何实现输出的。
release_console_sem的作用是解锁console系统

void release_console_sem(void)
{
//先判断了下是否系统需要休眠，需要休眠则离开
for ( ; ; ) {
spin_lock_irqsave(&logbuf_lock, flags);
wake_klogd |= log_start - log_end;
if (con_start == log_end)
break; /* Nothing to print */
_con_start = con_start;
_log_end = log_end;
con_start = log_end; /* Flush */
spin_unlock(&logbuf_lock);
stop_critical_timings(); /* don't trace print latency */
//在把数据拿出来之后，这里终于看到了调用串口驱动的接口
call_console_drivers(_con_start, _log_end);
start_critical_timings();
local_irq_restore(flags);
}
console_locked = 0;
up(&console_sem);
spin_unlock_irqrestore(&logbuf_lock, flags);
if (wake_klogd)
wake_up_klogd();
}
EXPORT_SYMBOL(release_console_sem);
so，从上面的函数我们去看看call_console_drivers函数中到底有何门道。
1. /*
2. * 调用console的驱动，首先要先将log_buf[start]到log_buf[end-1]的数据拿出来
3. *在这个过程中，要把console的标志一直保持住
4. */
5. static void call_console_drivers(unsigned start, unsigned end)
6. {
7. unsigned cur_index, start_print;
8. static int msg_level = -1;
11. BUG_ON(((int)(start - end)) > 0);
14. cur_index = start;
15. startstart_print = start;
16. while (cur_index != end) {
17. if (msg_level < 0 && ((end - cur_index) > 2) &&
18. LOG_BUF(cur_index + 0) == '<' &&
19. LOG_BUF(cur_index + 1) >= '0' &&
20. LOG_BUF(cur_index + 1) <= '7' &&
21. LOG_BUF(cur_index + 2) == '>') {
22. msg_level = LOG_BUF(cur_index + 1) - '0';
23. cur_index += 3;
24. start_print = cur_index;
25. }
26. while (cur_index != end) {
27. char c = LOG_BUF(cur_index);
30. cur_index++;
31. if (c == '\n') {
32. if (msg_level < 0) {
33. /*
34. * printk() has already given us loglevel tags in
35. * the buffer. This code is here in case the
36. * log buffer has wrapped right round and scribbled
37. * on those tags
38. */
39. msg_level = default_message_loglevel;
40. }
41. _call_console_drivers(start_print, cur_index, msg_level);
42. msg_level = -1;
43. start_print = cur_index;
44. break;
45. }
46. }
47. }
48. _call_console_drivers(start_print, end, msg_level);
49. }
这里还没用看到，但是看到更加深入的接口_call_console_drivers。这个函数里面一探究竟吧。
1. static void _call_console_drivers(unsigned start,
2. unsigned end, int msg_log_level)
3. {
4. if ((msg_log_level < console_loglevel || ignore_loglevel) &&
5. console_drivers && start != end) {
6. if ((start & LOG_BUF_MASK) > (end & LOG_BUF_MASK)) {
7. /* wrapped write */
8. __call_console_drivers(start & LOG_BUF_MASK,
9. log_buf_len);
10. __call_console_drivers(0, end & LOG_BUF_MASK);
11. } else {
12. __call_console_drivers(start, end);
13. }
14. }
15. }
紧接着的__call_console_drivers是不是呢？
1. static void __call_console_drivers(unsigned start, unsigned end)
2. {
3. struct console *con;
6. for_each_console(con) {
7. if ((con->flags & CON_ENABLED) && con->write &&
8. (cpu_online(smp_processor_id()) ||
9. (con->flags & CON_ANYTIME)))
10. con->write(con, &LOG_BUF(start), end - start);
11. }
12. }
你以为躲起来就找不到你了吗？没有用的，你是那样拉风的函数，不管在什么地方，就好象漆黑中的萤火虫一样，那样的鲜明，那样的出众，你那忧郁的眼神，唏嘘的胡碴子，神乎奇迹的刀法，还有那杯DRY MARTINE，都深深的迷住了我。不过虽然你是这样的出色，但是行有行规，我也要剖析你的内心了con->write。

到了这里，我们先暂时忍耐下，先看看这个拉轰的结构体
1. struct console {
2. char name[16];
3. void (*write)(struct console *, const char *, unsigned);
4. int (*read)(struct console *, char *, unsigned);
5. struct tty_driver *(*device)(struct console *, int *);
6. void (*unblank)(void);
7. int (*setup)(struct console *, char *);
8. int (*early_setup)(void);
9. short flags;
10. short index;
11. int cflag;
12. void *data;
13. struct console *next;
14. };
哈哈，你一定也注意到了，这里有write，是的，这就是在上面con->write中调用的。
在你的UART的驱动中你一定看到了register_console(&arch-xxx_uart_console);这个函数了，里面的write就是注册在此让printk使用的。write中的实现就是UART的那些小case了，这里不多说了。
当然这里还有这个console_initcall(arch—xxx_uart_console_init);将你的uart加入起来的了。

你可能在看arch-xxx_uart_console这个结构体定义的时候注意到没用read函数？这是什么原因呢？
在LDD中有这个答案，“当tty驱动程序接收到数据后，它将负责把从硬件获得的任何数据传递给tty核心，而不使用传统的read函数。tty核心将缓冲数据直接接到来自用户的请求。由于tty核心已经提供了缓冲逻辑，因此没用必要为每个tty驱动程序实现他们自己的缓冲区逻辑。”。当然这段话是教材这么说的，后续在看的时候会把这部分源码在展开来读读看。

当然printk不一定非得是串口输出，这里只是一个例子，今天就先到这里了，下面会把如何指定printk的输出给看看，这里先说下在__call_console_drivers()函数中的for_each_console()是个关键。见http://www./Linux/2011-09/43676.htm。