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中每个console
		if (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);
		else
			con->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输出打印信息。