printk实现分析

由于前两天在看netconsole的源码实现中，发现其跟printk的实现机制相关，加之之前一直是很普通的使用printk，从不清楚printk 到底是怎样工作的，因此就趁这个机会把printk的实现代码也给大致看了一下，代码流程并不复杂，下面就简要说明一下。

 

   printk在内核中的实现代码如下。

   asmlinkage int printk(const char *fmt, ...)
   {
      va_list args;
      int r;
 
      /*将fmt后的参数信息保存到args中*/
      va_start(args, fmt);

      /*处理printk流程的主要函数*/
      r = vprintk(fmt, args);

      /*va_end函数貌似是空函数*/
      va_end(args);

 

      return r;
   }

   

   下面就接着看vprintk函数的处理流程，vprintk实现printk的主要操作。

 

asmlinkage int vprintk(const char *fmt, va_list args)
{
    int printed_len = 0;
    int current_log_level = default_message_loglevel; //printk函数的默认输出级别

    unsigned long flags;
    int this_cpu;
    char *p;

    boot_delay_msec();

    /*禁止内核抢占*/
    preempt_disable();
    /* This stops the holder of console_sem just where we want him */
    raw_local_irq_save(flags);
    this_cpu = smp_processor_id();

    /*
     * Ouch, printk recursed into itself!
     */
     /*这一段的代码没有理解的很明白。。。*/
    /*printk的递归调用 ? 是在说printk的时候发生oops吗？ */
    if (unlikely(printk_cpu == this_cpu)) {
        /*
         * If a crash is occurring during printk() on this CPU,
         * then try to get the crash message out but make sure
         * we can't deadlock. Otherwise just return to avoid the
         * recursion and return - but flag the recursion so that
         * it can be printed at the next appropriate moment:
         */
         //oops_in_progress只有在panic函数中才为1
        if (!oops_in_progress) {
            recursion_bug = 1;
            goto out_restore_irqs;
        }
        /*如果在printk运行时，这个CPU崩溃，确信不能死锁，10秒1次初始化锁logbuf_lock和console_sem，留时间给控制台打印完全的oops信息*/
        zap_locks();
    }

    lockdep_off();
    spin_lock(&logbuf_lock);
    printk_cpu = this_cpu;

    if (recursion_bug) {
        recursion_bug = 0;
        strcpy(printk_buf, recursion_bug_msg);
        printed_len = strlen(recursion_bug_msg);
    }
    /* Emit the output into the temporary buffer */
    /*将要输出的字符串按照fmt中的格式编排好，放入printk_buf中，并返回应该输出的字符个数*/
    printed_len += vscnprintf(printk_buf + printed_len,
                 sizeof(printk_buf) - printed_len, fmt, args);


    /*
     * Copy the output into log_buf. If the caller didn't provide
     * appropriate log level tags, we insert them here
     */
     /*拷贝printk_buf数据到环形缓冲区中，如果调用者没有提供合适的日志级别，则插入默认级别*/
     /*拷贝的过程由函数emit_log_char实现，每次拷贝一个字节*/

     for (p = printk_buf; *p; p++) {
        if (new_text_line) {
            /* If a token, set current_log_level and skip over */
            if (p[0] == '<' && p[1] >= '0' && p[1] <= '7' &&
             p[2] == '>') {
                current_log_level = p[1] - '0';
                p += 3;
                printed_len -= 3;
            }

            /* Always output the token */
            emit_log_char('<');
            emit_log_char(current_log_level + '0');
            emit_log_char('>');
            printed_len += 3;
            new_text_line = 0;

            /*如果设置了此选项，则在每一条printk信息前都要加上时间参数*/
            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;
    }

    /*
     * Try to acquire and then immediately release the
     * console semaphore. The release will do all the
     * actual magic (print out buffers, wake up klogd,
     * etc).
     *
     * The acquire_console_semaphore_for_printk() function
     * will release 'logbuf_lock' regardless of whether it
     * actually gets the semaphore or not.
     */
    /*
    * 网上有这样一句话，要想对console进行操作，必须获取console结构的信号量。如果获取信号量，则可以通过log the output and call the console

    * drivers. 反之，则place the output into the log buff and return. 现有的信号量holeder在release函数中将会注意到
    * 新的output，在释放信号量前将会把output信息发送给console 

    */
    /*
    * 在acquire_console_semaphore_for_printk函数的注释中有这样一句话：此函数被调用时拥有logbuf_lock的自旋锁，并且处于禁止中断状态

    *  在返回时（无论成功get sem）应保证logbuf_lock的自旋锁被释放，但是仍然禁止中断

    */
    if (acquire_console_semaphore_for_printk(this_cpu))
        /*此函数将log_buf中的内容发送给console，并且唤醒klogd*/
        release_console_sem();

    lockdep_on();
out_restore_irqs:
    raw_local_irq_restore(flags);

    preempt_enable();
    return printed_len;
}

（自己直接贴代码总是不能对齐，还在抱怨uc对于代码支持不好呢。。第一次用这个粘贴代码。。。）

   对于printk来说，一共有两个缓冲区printk_buf以及log_buf，前者有种临时缓冲的意思，后者用来存储最终要输出的字符串。后面将详细说一下其中最主要的log_buf。

   对于vscnprintf函数来说，其就是最终通过vsnprintf()函数将printk的参数根据fmt格式进行转换，并将转换的结果暂存到printk_buf中，最终又将printk_buf中的数据保存到log_buf中。
    下面在讨论往log_buf缓冲区写数据的函数emit_log_char之前，先简要说一下printk中的log_buf缓冲区。

/*
 * The indices into log_buf are not constrained to log_buf_len - they
 * must be masked before subscripting
 */
static unsigned log_start;    /* Index into log_buf: next char to be read by syslog() */
static unsigned con_start;    /* Index into log_buf: next char to be sent to consoles */
static unsigned log_end;    /* Index into log_buf: most-recently-written-char + 1 */

   其中的log_end标志着下一个写入的位置，其是上一次写的末尾+1；而log_start和con_start则是syslog和consoles读取数据的起始位置。在缓冲区写入的时候正是通过这三个变量以及C语言的特性完成环形的实现。

   下面看一下写缓冲区的具体函数实现。

static void emit_log_char(char c)
{
    LOG_BUF(log_end) = c;
    log_end++;
    if (log_end - log_start > log_buf_len)
        log_start = log_end - log_buf_len;
    if (log_end - con_start > log_buf_len)
        con_start = log_end - log_buf_len;
    if (logged_chars < log_buf_len)
        logged_chars++;
}

   这个写入满足每次只写入一个字符，通过LOG_BUF将字符c赋值给缓冲区，通过后面的长度变化来实现环形的概念。其中的LOG_BUF是这样定义的：

   #define LOG_BUF(idx) (log_buf[(idx) & LOG_BUF_MASK])
   在写入时根据log_end的大小mod缓冲区长度，获取最终的写入位置。

   环形缓冲区在字面看来就是一个数组 static char __log_buf[__LOG_BUF_LEN]；其长度一般为4096大小(内核可修改)。而log_end长度为unsigned long范围，远远大于数组的大小，对于每一个字符的赋值log_end则只管++,在加一之后进行判断，如果log_end的值大于 log_start，则表示缓冲区的长度已经达到最大，下一次的写入就将覆盖之前最旧的位置，因此log_start = log_end - log_buf_len,将log_start的位置向后移一位（因为每次只写入一个字符，不可能超过一位）。log_end和log_start通过 unsigned long的自然溢出来实现环形的判断，而对其中每一次赋值则不再考虑环形的实现形式。（罗里啰嗦了这么多，也不知道能不能看明白，不过我是明白了。。。感 觉方法挺巧的。。）

   函数的最后，则是release_console_sem函数，在此函数中完成console相关的操作。主要过程就是将con_start与 log_end间的数据通过call_console_drivers函数来完成数据往控制台的传递，并且在最后环形klogd进程。

   而call_console_drivers函数则是遍历内核中的console链表console_driver,对于其中的每一个console结构，调用其注册的write函数。

   这两个函数的代码都比较简单，就不再多说了。

void release_console_sem(void)
{
    unsigned long flags;
    unsigned _con_start, _log_end;
    unsigned wake_klogd = 0;

    if (console_suspended) {
        up(&console_sem);
        return;
    }

    console_may_schedule = 0;

    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();
}

   call_console_drivers函数在最终是通过__call_console_drivers函数来实现的。

/*
 * Call the console drivers on a range of log_buf
 */
static void __call_console_drivers(unsigned start, unsigned end)
{
    struct console *con;

    for (con = console_drivers; con; con = con->next) {
        if ((con->flags & CON_ENABLED) && con->write &&
                (cpu_online(smp_processor_id()) ||
                (con->flags & CON_ANYTIME)))
            con->write(con, &LOG_BUF(start), end - start);
    }
}

   至此，整个printk的实现流程就已经结束了，并不复杂，流程比较清晰，嘿嘿。