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; \
}
