Linux内核中的printf实现

从main.c中的printf开始读这个函数。

首先看printf函数的定义：

1	static int printf(const char *fmt, ...)
2	{
3	va_list args;
4	int i;
5
6	va_start(args, fmt);
7	write(1,printbuf,i=vsprintf(printbuf, fmt, args));
8	va_end(args);
9	return i;
10	}

 

参数中明显采用了可变参数的定义，而在main.c函数的后面直接调用了printf函数，我们可以看下printf函数的参数是如何使用的。

1	printf("%d buffers = %d bytes buffer space\n\r",NR_BUFFERS,
2	NR_BUFFERS*BLOCK_SIZE);
3	printf("Free mem: %d bytes\n\r",memory_end-main_memory_start);

 

先来分析第一个printf调用：

printf("%d buffers = %d bytes buffer space\n\r",NR_BUFFERS, NR_BUFFERS*BLOCK_SIZE);

可以看到*fmt等于"%d buffers = %d bytes buffer space\n\r”，是一个char 类型的指针，指向字符串的启始位置。而可变的参数在这里是NR_BUFFERS和NR_BUFFERS*BLOCK_SIZE。

其中NR_BUFFERS在buffer.c中定义为缓冲区的页面大小，类型为int；BLOCK_SIZE在fs.h中的定义为

#define BLOCK_SIZE 1024

因此两个可变参数NR_BUFFERS和NR_BUFFERS*BLOCK_SIZE都为int类型；

以前已经分析过可变参数的一系列实现函数va函数。

va_list arg_ptr；

void va_start( va_list arg_ptr, prev_param );
type va_arg( va_list arg_ptr, type );
void va_end( va_list arg_ptr );

首先在函数里定义一个va_list型的变量,这里是arg_ptr,这个变量是指向参数的指针。然后使用va_start使arg_ptr指针指向prev_param的下一位，然后使用va_args取出从arg_ptr开始的type类型长度的数据，并返回这个数据，最后使用va_end结束可变参数的获取。

在printf("%d buffers = %d bytes buffer space\n\r",NR_BUFFERS, NR_BUFFERS*BLOCK_SIZE)中，根据以上的分析fmt指向字符串，args首先指向第一个可变参数，也就是NR_BUFFERS(args在经过一次type va_arg( va_list arg_ptr, type )调用后，会根据type的长度自动增加，从而指向第二个可变参数NR_BUFFERS*BLOCK_SIZE)。

我们先不管write函数的实现，首先来看vsprint。

1	int vsprintf(char *buf, const char *fmt, va_list args)
2	{
3	int len;
4	int i;
5	char * str;
6	char *s;
7	int *ip;
8
9	int flags;        /* flags to number() */
10
11	int field_width;    /* width of output field */
12	int precision;        /* min. # of digits for integers; max
13	number of chars for from string */
14	int qualifier;        /* 'h', 'l', or 'L' for integer fields */
15
16	for (str=buf ; *fmt ; ++fmt) {    //str为最终存放字符串的位置但是他随着字符串增长而增长，buf始终指向最终字符串的启始位置。fmt为格式字符串
17	if (*fmt != '%') {
18	*str++ = *fmt;              //如果不是%则表示这是需要原样打印的字符串，直接复制即可
19	continue;
20	}
21
22	/* process flags */
23	flags = 0;
24	repeat:
25	++fmt;        /* this also skips first '%' */                            //fmt指向%的后一位
26	switch (*fmt) {
27	case '-': flags |= LEFT; goto repeat;
28	case '+': flags |= PLUS; goto repeat;
29	case ' ': flags |= SPACE; goto repeat;                         //判断标志位，并设置flags
30	case '#': flags |= SPECIAL; goto repeat;
31	case '0': flags |= ZEROPAD; goto repeat;
32	}
33
34	/* get field width */
35	field_width = -1;
36	if (is_digit(*fmt))
37	field_width = skip_atoi(&fmt);
38	else if (*fmt == '*') {
39	/* it's the next argument */
40	field_width = va_arg(args, int);
41	if (field_width < 0) {
42	field_width = -field_width;
43	flags |= LEFT;
44	}
45	}
46
47	/* get the precision */
48	precision = -1;
49	if (*fmt == '.') {
50	++fmt;
51	if (is_digit(*fmt))
52	precision = skip_atoi(&fmt);
53	else if (*fmt == '*') {
54	/* it's the next argument */
55	precision = va_arg(args, int);
56	}
57	if (precision < 0)
58	precision = 0;
59	}
60
61	/* get the conversion qualifier */
62	qualifier = -1;
63	if (*fmt == 'h' || *fmt == 'l' || *fmt == 'L') {
64	qualifier = *fmt;
65	++fmt;
66	}
67
68	switch (*fmt) {                                  //如果没有上面奇怪的标志位(*/./h/l/L)则fmt仍然指向%的后一位，下面判断这个标志位
69	case 'c':
70	if (!(flags & LEFT))
71	while (--field_width > 0)
72	*str++ = ' ';
73	*str++ = (unsigned char) va_arg(args, int);
74	while (--field_width > 0)
75	*str++ = ' ';
76	break;
77
78	case 's':
79	s = va_arg(args, char *);
80	len = strlen(s);
81	if (precision < 0)
82	precision = len;
83	else if (len > precision)
84	len = precision;
85
86	if (!(flags & LEFT))
87	while (len < field_width--)
88	*str++ = ' ';
89	for (i = 0; i < len; ++i)
90	*str++ = *s++;
91	while (len < field_width--)
92	*str++ = ' ';
93	break;
94
95	case 'o':
96	str = number(str, va_arg(args, unsigned long), 8,
97	field_width, precision, flags);
98	break;
99
100	case 'p':
101	if (field_width == -1) {
102	field_width = 8;
103	flags |= ZEROPAD;
104	}
105	str = number(str,
106	(unsigned long) va_arg(args, void *), 16,
107	field_width, precision, flags);
108	break;
109
110	case 'x':
111	flags |= SMALL;
112	case 'X':
113	str = number(str, va_arg(args, unsigned long), 16,
114	field_width, precision, flags);
115	break;
116
117	case 'd':                                    //如果是整型，首先设定flags，然后利用number函数将可变参数取出，并根据base(这里是10)然后转换成字符串，赋给str
118	case 'i':
119	flags |= SIGN;
120	case 'u':
121	str = number(str, va_arg(args, unsigned long), 10,
122	field_width, precision, flags);
123	break;
124
125	case 'n':
126	ip = va_arg(args, int *);
127	*ip = (str - buf);
128	break;
129
130	default:
131	if (*fmt != '%')//如果格式转换符不是%，则表示出错，直接打印一个%。如果是%，那么格式转换符就是%%，就由下面if(*fmt)只输出一个%
132	*str++ = '%';
133	if (*fmt)
134	*str++ = *fmt;//如果格式转换符不正确则输出%+不正确的格式转换符。如果是%%，则只输出一个%
135	else
136	--fmt;//如果转换格式符不是上面这些正确的，也不是空，那么直接输出，并返回到判断fmt的for语句；否则就指向末尾了，fmt后退一位，这样在for循环自动再加1进行判断时*fmt的条件就不满足，退出for循环
137	break;
138	}
139	}
140	*str = '\0';//设定str字符串的最后一位为'\0'
141	return str-buf;//返回值为字符串的长度
142

 

这样我们就实现了根据fmt中的格式转换符将可变参数转换到相应的格式，利用write函数进行输出的目的。

而后者的可变参数memory_end-main_memory_start，根据main.c中的定义

static long buffer_memory_end = 0;
static long main_memory_start = 0;可见为主内存的大小，类型为long。分析同上

而write函数跟fork函数一样是由_syscall*来实现的，内嵌汇编就不多解释了，直接展开就行

write.c

_syscall3(int,write,int,fd,const char *,buf,off_t,count)

unistd.h

#define _syscall3(type,name,atype,a,btype,b,ctype,c) \
type name(atype a,btype b,ctype c) \
{ \
long __res; \
__asm__ volatile ("int $0x80" \
    : "=a" (__res) \
    : "0" (__NR_##name),"b" ((long)(a)),"c" ((long)(b)),"d" ((long)(c))); \
if (__res>=0) \
    return (type) __res; \
errno=-__res; \
return -1; \
}