【轉】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; \ }