riscv架构下linux4.15实现early打印

在高版本linux6.12.7源码中，early console介绍，可参考《riscv架构下linux6.12.7实现early打印》文章。

1 什么是early打印

适配内核到新的平台，基本环境搭建好之后，首要的就是要调通串口，方便后面的信息打印。
正常流程 init/main.c 中 start_kernel 入口，要到 console_init 之后才能真正打印，前面的打印，都是缓存在 printk 的 ringbuffer 中的。
如果在 console_init 前就异常了，此时就看不到打印信息，为了调试 console_init 前的状态，需要能更早的打印，内核提供了一种 early 打印的方式，尤其是 riscv 平台我们可以直接 ecall 调用 opensbi 的打印，这样 opensbi 适配好之后，这里就可以直接使用。

earlyprintk 的实现依赖于特定的硬件平台，并且通常与特定固件配合使用。
earlyprintk 是一个高级功能，主要用于内核开发和调试。在生产环境中，通常不需要启用此功能，因为它可能会干扰系统的正常启动过程，或暴露潜在的敏感信息。

从 earlyprintk 到串行控制台的转换，通常发生在内核初始化过程中，特别是在 register_console 函数被调用之后。这个函数负责注册串行控制台，并使其成为内核默认的打印信息输出设备。一旦串行控制台被注册，内核就会开始使用它来输出打印信息，而 earlyprintk 则不再被需要。

2 printk函数实现

printk函数代码实现，如下所示：

// 1.riscv-linux-4.15/include/linux/printk.h：
#define pr_info(fmt, ...) \printk(KERN_INFO pr_fmt(fmt), ##__VA_ARGS__)  调用==>// 2.riscv-linux-4.15/kernel/printk/printk.c：
asmlinkage __visible int printk(const char *fmt, ...)
{va_list args;int r;va_start(args, fmt);r = vprintk_func(fmt, args);   调用==>va_end(args);return r;
}// 3.riscv-linux-4.15/kernel/printk/printk_safe.c：
__printf(1, 0) int vprintk_func(const char *fmt, va_list args)
{...return vprintk_default(fmt, args);    调用==>
}// 4.riscv-linux-4.15/kernel/printk/printk.c：
int vprintk_default(const char *fmt, va_list args)
{...r = vprintk_emit(0, LOGLEVEL_DEFAULT, NULL, 0, fmt, args);    调用==>return r;
}// 5.riscv-linux-4.15/kernel/printk/printk.c：
asmlinkage int vprintk_emit(int facility, int level,const char *dict, size_t dictlen,const char *fmt, va_list args)
{...printed_len = log_output(facility, level, lflags, dict, dictlen, text, text_len);...console_unlock();    调用==>...
}// 6.riscv-linux-4.15/kernel/printk/printk.c：
void console_unlock(void)
{...call_console_drivers(ext_text, ext_len, text, len);    调用==>...
}// 7.riscv-linux-4.15/kernel/printk/printk.c：
static void call_console_drivers(const char *ext_text, size_t ext_len,const char *text, size_t len)
{struct console *con;trace_console_rcuidle(text, len); if (!console_drivers)return;for_each_console(con) {  // 遍历console_drivers中每个consoleif (exclusive_console && con != exclusive_console)continue;if (!(con->flags & CON_ENABLED))continue;if (!con->write)continue;if (!cpu_online(smp_processor_id()) &&!(con->flags & CON_ANYTIME))continue;if (con->flags & CON_EXTENDED)con->write(con, ext_text, ext_len);elsecon->write(con, text, len); // 通过console的write函数打印内容}
}

在代码中，从printk开始，层层分析，最后在call_console_drivers函数中，会遍历console_drivers中每个console，并调用console的write函数来完成内容打印。

pr_info ==>
printk ==>
vprintk_func ==>
vprintk_default ==>
vprintk_emit ==>
console_unlock ==>
call_console_drivers ==>
con->write

3 console注册

console结构体定义：

// riscv-linux-4.15/include/linux/console.h：
struct console {char	name[16];void	(*write)(struct console *, const char *, unsigned);int	(*read)(struct console *, char *, unsigned);struct tty_driver *(*device)(struct console *, int *);void	(*unblank)(void);int	(*setup)(struct console *, char *);int	(*match)(struct console *, char *name, int idx, char *options);short	flags;short	index;int	cflag;void	*data;struct	 console *next;
};

通过register_console函数，可以将一个console进行注册，放入console_drivers链表中，如下：

// riscv-linux-4.15/arch/riscv/kernel/setup.c：
void __init setup_arch(char **cmdline_p)
{
#if defined(CONFIG_EARLY_PRINTK)if (likely(early_console == NULL)) {early_console = &riscv_sbi_early_console_dev;register_console(early_console); // 注册early console}
#endif*cmdline_p = boot_command_line;...
}// early console定义
struct console riscv_sbi_early_console_dev __initdata = {.name	= "early",.write	= sbi_console_write,.flags	= CON_PRINTBUFFER | CON_BOOT | CON_ANYTIME,.index	= -1
};// early console的write函数
static void sbi_console_write(struct console *co, const char *buf,unsigned int n)
{int i;for (i = 0; i < n; ++i) {if (buf[i] == '\n')sbi_console_putchar('\r');sbi_console_putchar(buf[i]);}
}// riscv-linux-4.15/arch/riscv/include/asm/sbi.h：
#define SBI_CALL(which, arg0, arg1, arg2) ({			\register uintptr_t a0 asm ("a0") = (uintptr_t)(arg0);	\register uintptr_t a1 asm ("a1") = (uintptr_t)(arg1);	\register uintptr_t a2 asm ("a2") = (uintptr_t)(arg2);	\register uintptr_t a7 asm ("a7") = (uintptr_t)(which);	\asm volatile ("ecall"					\: "+r" (a0)				\: "r" (a1), "r" (a2), "r" (a7)		\: "memory");				\a0;							\
})/* Lazy implementations until SBI is finalized */
#define SBI_CALL_0(which) SBI_CALL(which, 0, 0, 0)
#define SBI_CALL_1(which, arg0) SBI_CALL(which, arg0, 0, 0)
#define SBI_CALL_2(which, arg0, arg1) SBI_CALL(which, arg0, arg1, 0)static inline void sbi_console_putchar(int ch)
{SBI_CALL_1(SBI_CONSOLE_PUTCHAR, ch);
}static inline int sbi_console_getchar(void)
{return SBI_CALL_0(SBI_CONSOLE_GETCHAR);
}

4 SBI_CALL

console的write函数：先调用sbi_console_putchar，再调SBI_CALL。
SBI_CALL实现的功能，可大致理解为：

SBI_CALL(which, arg0, arg1, arg2) 
{			a0寄存器 = (uintptr_t)(arg0);	a1寄存器 = (uintptr_t)(arg1);	a2寄存器 = (uintptr_t)(arg2);	a7寄存器 = (uintptr_t)(which);	执行ecall指令；					
}

SBI_CALL宏，通过在RISC-V处理器上，执行ecall指令来调用一个服务：

它通过将参数，放入特定的寄存器（a0、a1、a2）；
并将服务标识符（调用号），放入a7寄存器；
然后，它执行ecall指令，并返回a0寄存器的值作为结果。

ecall系统调用，会触发异常（mcause寄存器定义的异常8或9）。只不过这种异常，是由U或S模式下，程序通过ecall指令，软件触发的异常，主要用于系统调用，实现一些底层调用，例如输出打印信息到串口等。

可以看到，这里定义了很多调用号Timer、Console、IPI、Shutdown等，如下：

// riscv-linux-4.15/arch/riscv/include/asm/sbi.h：
#define SBI_SET_TIMER 0
#define SBI_CONSOLE_PUTCHAR 1
#define SBI_CONSOLE_GETCHAR 2
#define SBI_CLEAR_IPI 3
#define SBI_SEND_IPI 4
#define SBI_REMOTE_FENCE_I 5
#define SBI_REMOTE_SFENCE_VMA 6
#define SBI_REMOTE_SFENCE_VMA_ASID 7
#define SBI_SHUTDOWN 8

在这里，就是：

将调用号1放入a7寄存器，将欲打印字符ch放入a0寄存器，然后CPU执行ecall指令，就会触发一个异常；
然后CPU会处理该异常，由于当前kernel运行在S模式，因此CPU会进入M模式，并跳转到M模式异常处理入口（Open SBI），在固件OpenSBI的处理代码中，会判断当调用号为1时，将字符ch打印出来（打印的方式，可以通过Uart或HTIF）。

在riscv-pk开源项目中，也支持通过ecall指令，来使用Uart或HTIF输出打印信息。