【转】Linux内核中的printf实现

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

首先看printf函数的定义：

static int printf(const char *fmt, ...)
{
    va_list args;
    int i;
 
    va_start(args, fmt);
    write(1,printbuf,i=vsprintf(printbuf, fmt, args));
    va_end(args);
    return i;
}

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

printf("%d buffers = %d bytes buffer space\n\r",NR_BUFFERS,

NR_BUFFERS*BLOCK_SIZE);

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。

int vsprintf(char *buf, const char *fmt, va_list args)
{
    int len;
    int i;
    char * str;
    char *s;
    int *ip;
 
    int flags;        /* flags to number() */
	 
	    int field_width;    /* width of output field */
	    int precision;        /* min. # of digits for integers; max
	                   number of chars for from string */
	    int qualifier;        /* 'h', 'l', or 'L' for integer fields */
	 
	    for (str=buf ; *fmt ; ++fmt) {    //str为最终存放字符串的位置但是他随着字符串增长而增长，buf始终指向最终字符串的启始位置。fmt为格式字符串
	        if (*fmt != '%') {                        
	            *str++ = *fmt;              //如果不是%则表示这是需要原样打印的字符串，直接复制即可
	            continue;
	        }
	           
	        /* process flags */
	        flags = ;
	        repeat:
	            ++fmt;        /* this also skips first '%' */                            //fmt指向%的后一位
	            switch (*fmt) {
	                case '-': flags |= LEFT; goto repeat;
	                case '+': flags |= PLUS; goto repeat;
	                case ' ': flags |= SPACE; goto repeat;                         //判断标志位，并设置flags
	                case '#': flags |= SPECIAL; goto repeat;
	                case '': flags |= ZEROPAD; goto repeat;
	                }
	       
	        /* get field width */
	        field_width = -1;
	        if (is_digit(*fmt))
	            field_width = skip_atoi(&fmt);
	        else if (*fmt == '*') {
	            /* it's the next argument */
	            field_width = va_arg(args, int);
	            if (field_width < ) {
	                field_width = -field_width;
	                flags |= LEFT;
	            }
	        }
	 
	        /* get the precision */
	        precision = -1;
	        if (*fmt == '.') {
	            ++fmt;   
	            if (is_digit(*fmt))
	                precision = skip_atoi(&fmt);
	            else if (*fmt == '*') {
	                /* it's the next argument */
	                precision = va_arg(args, int);
	            }
	            if (precision < )
	                precision = ;
	        }
	 
	        /* get the conversion qualifier */
	        qualifier = -1;
	        if (*fmt == 'h' || *fmt == 'l' || *fmt == 'L') {
	            qualifier = *fmt;
	            ++fmt;
	        }
	 
	        switch (*fmt) {                                  //如果没有上面奇怪的标志位(*/./h/l/L)则fmt仍然指向%的后一位，下面判断这个标志位
	        case 'c':
	            if (!(flags & LEFT))
	                while (--field_width > )
	                    *str++ = ' ';
	            *str++ = (unsigned char) va_arg(args, int);
	            while (--field_width > )
	                *str++ = ' ';
	            break;
	 
	        case 's':
	            s = va_arg(args, char *);
	            len = strlen(s);
	            if (precision < )
	                precision = len;
	            else if (len > precision)
	                len = precision;
	 
	            if (!(flags & LEFT))
	                while (len < field_width--)
	                    *str++ = ' ';
	            for (i = ; i < len; ++i)
	                *str++ = *s++;
	            while (len < field_width--)
	                *str++ = ' ';
	            break;
	 
	        case 'o':
	            str = number(str, va_arg(args, unsigned long), 8,
	                field_width, precision, flags);
	            break;
	 
 	        case 'p':
 	            if (field_width == -1) {
 	                field_width = 8;
 	                flags |= ZEROPAD;
 	            }
 	            str = number(str,
 	                (unsigned long) va_arg(args, void *), 16,
 	                field_width, precision, flags);
 	            break;
 	 
 	        case 'x':
 	            flags |= SMALL;
 	        case 'X':
 	            str = number(str, va_arg(args, unsigned long), 16,
 	                field_width, precision, flags);
 	            break;
 	 
 	

    case 'd':                                    //如果是整型，首先设定flags，然后利用number函数将可变参数取出，并根据base(这里是10)然后转换成字符串，赋给str
 	        case 'i':
 	            flags |= SIGN;
 	        case 'u':
 	            str = number(str, va_arg(args, unsigned long), 10,
 	                field_width, precision, flags);
 	            break;
 	 
 	        case 'n':
 	            ip = va_arg(args, int *);
 	            *ip = (str - buf);
 	            break;
 	 
 	        default:
 	            if (*fmt != '%')//如果格式转换符不是%，则表示出错，直接打印一个%。如果是%，那么格式转换符就是%%，就由下面if(*fmt)只输出一个%
 	                *str++ = '%';
 	            if (*fmt)
 	                *str++ = *fmt;//如果格式转换符不正确则输出%+不正确的格式转换符。如果是%%，则只输出一个%
 	            else
 	                --fmt;//如果转换格式符不是上面这些正确的，也不是空，那么直接输出，并返回到判断fmt的for语句；否则就指向末尾了，fmt后退一位，这样在for循环自动再加1进行判断时*fmt的条件就不满足，退出for循环
 	            break;
 	        }
 	    }
 	    *str = '\0';//设定str字符串的最后一位为'\0'
 	    return str-buf;//返回值为字符串的长度

 

这样我们就实现了根据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; \
}

转载于:https://my.oschina.net/left/blog/31897