printf 函数实现的深入剖析

研究printf的实现，首先来看看printf函数的函数体 
int printf(const char *fmt, ...) 
{ 
int i; 
char buf[256]; 
    
     va_list arg = (va_list)((char*)(&fmt) + 4); 
     i = vsprintf(buf, fmt, arg); 
     write(buf, i); 
    
     return i; 
    } 
    代码位置：D:/~/funny/kernel/printf.c 
    
    在形参列表里有这么一个token：... 
    这个是可变形参的一种写法。 
    当传递参数的个数不确定时，就可以用这种方式来表示。 
    很显然，我们需要一种方法，来让函数体可以知道具体调用时参数的个数。 
    
    先来看printf函数的内容： 
    
    这句： 
    
    va_list arg = (va_list)((char*)(&fmt) + 4); 
    
    va_list的定义： 
    typedef char *va_list 
    这说明它是一个字符指针。 
    其中的： (char*)(&fmt) + 4) 表示的是...中的第一个参数。 
    如果不懂，我再慢慢的解释： 
    C语言中，参数压栈的方向是从右往左。 
    也就是说，当调用printf函数的适合，先是最右边的参数入栈。 
    fmt是一个指针，这个指针指向第一个const参数（const char *fmt)中的第一个元素。 
    fmt也是个变量，它的位置，是在栈上分配的，它也有地址。 
    对于一个char *类型的变量，它入栈的是指针，而不是这个char *型变量。 
    换句话说： 
    你sizeof(p) (p是一个指针，假设p=&i,i为任何类型的变量都可以） 
    得到的都是一个固定的值。（我的计算机中都是得到的4） 
    当然，我还要补充的一点是：栈是从高地址向低地址方向增长的。 
    ok！ 
    现在我想你该明白了：为什么说(char*)(&fmt) + 4) 表示的是...中的第一个参数的地址。 
    
    下面我们来看看下一句： 
     i = vsprintf(buf, fmt, arg); 
    
    让我们来看看vsprintf(buf, fmt, arg)是什么函数。  
     
   

int vsprintf(char *buf, const char *fmt, va_list args) 

   { 

    char* p; 

    char tmp[256]; 

    va_list p_next_arg = args; 

    for (p=buf;*fmt;fmt++) { 

    if (*fmt != '%') { 

    *p++ = *fmt; 

    continue; 

    } 

    fmt++; 

    switch (*fmt) { 

    case 'x': 

    itoa(tmp, *((int*)p_next_arg)); 

    strcpy(p, tmp); 

    p_next_arg += 4; 

    p += strlen(tmp); 

    break; 

    case 's': 

    break; 

    default: 

    break; 

    } 

    } 

    return (p - buf); 

   } 

       
    我们还是先不看看它的具体内容。 
    想想printf要左什么吧 
    它接受一个格式化的命令，并把指定的匹配的参数格式化输出。 
    
    ok，看看i = vsprintf(buf, fmt, arg); 
     vsprintf返回的是一个长度，我想你已经猜到了：是的，返回的是要打印出来的字符串的长度 
    其实看看printf中后面的一句：write(buf, i);你也该猜出来了。 
    write，顾名思义：写操作，把buf中的i个元素的值写到终端。 
    
    所以说：vsprintf的作用就是格式化。它接受确定输出格式的格式字符串fmt。用格式字符串对个数变化的参数进行格式化，产生格式化输出。 
    我代码中的vsprintf只实现了对16进制的格式化。 
    
    你只要明白vsprintf的功能是什么，就会很容易弄懂上面的代码。 
    
    下面的write(buf, i);的实现就有点复杂了 
    
    如果你是os，一个用户程序需要你打印一些数据。很显然：打印的最底层操作肯定和硬件有关。 
    所以你就必须得对程序的权限进行一些限制： 
    
    让我们假设个情景： 
    一个应用程序对你说：os先生，我需要把存在buf中的i个数据打印出来，可以帮我么？ 
    os说：好的，咱俩谁跟谁，没问题啦！把buf给我吧。 
    
    然后，os就把buf拿过来。交给自己的小弟（和硬件操作的函数）来完成。 
    只好通知这个应用程序：兄弟，你的事我办的妥妥当当！（os果然大大的狡猾 ^_^） 
    这样 应用程序就不会取得一些超级权限，防止它做一些违法的事。（安全啊安全） 
    
    让我们追踪下write吧： 
    
    write: 
     mov eax, _NR_write 
     mov ebx, [esp + 4] 
     mov ecx, [esp + 8] 
     int INT_VECTOR_SYS_CALL 
    
    位置：d:~/kernel/syscall.asm 
    
    这里是给几个寄存器传递了几个参数，然后一个int结束 
    
    想想我们汇编里面学的，比如返回到dos状态： 
    我们这样用的 
    
    mov ax,4c00h 
    int 21h 
    
    为什么用后面的int 21h呢？ 
    这是为了告诉编译器：号外，号外，我要按照给你的方式（传递的各个寄存器的值）变形了。 
    编译器一查表：哦，你是要变成这个样子啊。no problem！ 
    
    其实这么说并不严紧，如果你看了一些关于保护模式编程的书，你就会知道，这样的int表示要调用中断门了。通过中断门，来实现特定的系统服务。 
    
    我们可以找到INT_VECTOR_SYS_CALL的实现： 
    init_idt_desc(INT_VECTOR_SYS_CALL, DA_386IGate, sys_call, PRIVILEGE_USER); 
    
    位置：d:~/kernel/protect.c 
    
    如果你不懂，没关系，你只需要知道一个int INT_VECTOR_SYS_CALL表示要通过系统来调用sys_call这个函数。（从上面的参数列表中也该能够猜出大概） 
    
    好了，再来看看sys_call的实现： 
    sys_call: 
     call save 
    
     push dword [p_proc_ready] 
    
     sti 
    
     push ecx 
     push ebx 
     call [sys_call_table + eax * 4] 
     add esp, 4 * 3 
    
     mov [esi + EAXREG - P_STACKBASE], eax 
    
     cli 
    
     ret 
    
    
    位置：～/kernel/kernel.asm 
    
    一个call save，是为了保存中断前进程的状态。 
    靠！ 
    太复杂了，如果详细的讲，设计到的东西实在太多了。 
    我只在乎我所在乎的东西。sys_call实现很麻烦，我们不妨不分析funny os这个操作系统了 
    先假设这个sys_call就一单纯的小女孩。她只有实现一个功能：显示格式化了的字符串。 
    
    这样，如果只是理解printf的实现的话，我们完全可以这样写sys_call： 
    sys_call: 
     
     ;ecx中是要打印出的元素个数 
     ;ebx中的是要打印的buf字符数组中的第一个元素 
     ;这个函数的功能就是不断的打印出字符，直到遇到：'\0' 
     ;[gs:edi]对应的是0x80000h：0采用直接写显存的方法显示字符串 
     xor si,si 
     mov ah,0Fh 
     mov al,[ebx+si] 
     cmp al,'\0' 
     je .end 
     mov [gs:edi],ax 
     inc si 
    loop: 
     sys_call 
    
    .end: 
     ret 
     
    
    ok!就这么简单！ 
    恭喜你，重要弄明白了printf的最最底层的实现！ 
    
    
    如果你有机会看linux的源代码的话，你会发现，其实它的实现也是这种思路。 
    freedos的实现也是这样 
    比如在linux里，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; 
    } 
    
     va_start 
     va_end 这两个函数在我的blog里有解释，这里就不多说了 
    
    它里面的vsprintf和我们的vsprintf是一样的功能。 
    不过它的write和我们的不同，它还有个参数：1 
    这里我可以告诉你：1表示的是tty所对应的一个文件句柄。 
    在linux里，所有设备都是被当作文件来看待的。你只需要知道这个1就是表示往当前显示器里写入数据 
    
    在freedos里面，printf是这样的： 
    
     int VA_CDECL printf(const char *fmt, ...) 
    { 
     va_list arg; 
     va_start(arg, fmt); 
     charp = 0; 
     do_printf(fmt, arg); 
     return 0; 
    } 
    
    看起来似乎是do_printf实现了格式化和输出。 
    我们来看看do_printf的实现： 
    STATIC void do_printf(CONST BYTE * fmt, va_list arg) 
    { 
     int base; 
     BYTE s[11], FAR * p; 
     int size; 
     unsigned char flags; 
    
     for (;*fmt != '\0'; fmt++) 
     { 
     if (*fmt != '%') 
     { 
     handle_char(*fmt); 
     continue; 
     } 
    
     fmt++; 
     flags = RIGHT; 
    
     if (*fmt == '-') 
     { 
     flags = LEFT; 
     fmt++; 
     } 
    
     if (*fmt == '0') 
     { 
     flags |= ZEROSFILL; 
     fmt++; 
     } 
    
     size = 0; 
     while (1) 
     { 
     unsigned c = (unsigned char)(*fmt - '0'); 
     if (c > 9) 
     break; 
     fmt++; 
     size = size * 10 + c; 
     } 
    
     if (*fmt == 'l') 
     { 
     flags |= LONGARG; 
     fmt++; 
     } 
    
     switch (*fmt) 
     { 
     case '\0': 
     va_end(arg); 
     return; 
    
     case 'c': 
     handle_char(va_arg(arg, int)); 
     continue; 
    
     case 'p': 
     { 
     UWORD w0 = va_arg(arg, unsigned); 
     char *tmp = charp; 
     sprintf(s, "%04x:%04x", va_arg(arg, unsigned), w0); 
     p = s; 
     charp = tmp; 
     break; 
     } 
    
     case 's': 
     p = va_arg(arg, char *); 
     break; 
    
     case 'F': 
     fmt++; 
     /* we assume %Fs here */ 
     case 'S': 
     p = va_arg(arg, char FAR *); 
     break; 
    
     case 'i': 
     case 'd': 
     base = -10; 
     goto lprt; 
    
     case 'o': 
     base = 8; 
     goto lprt; 
    
     case 'u': 
     base = 10; 
     goto lprt; 
    
     case 'X': 
     case 'x': 
     base = 16; 
    
     lprt: 
     { 
     long currentArg; 
     if (flags & LONGARG) 
     currentArg = va_arg(arg, long); 
     else 
     { 
     currentArg = va_arg(arg, int); 
     if (base >= 0) 
     currentArg = (long)(unsigned)currentArg; 
     } 
     ltob(currentArg, s, base); 
     p = s; 
     } 
     break; 
    
     default: 
     handle_char('?'); 
    
     handle_char(*fmt); 
     continue; 
    
     } 
     { 
     size_t i = 0; 
     while(p[i]) i++; 
     size -= i; 
     } 
    
     if (flags & RIGHT) 
     { 
     int ch = ' '; 
     if (flags & ZEROSFILL) ch = '0'; 
     for (; size > 0; size--) 
     handle_char(ch); 
     } 
     for (; *p != '\0'; p++) 
     handle_char(*p); 
    
     for (; size > 0; size--) 
     handle_char(' '); 
     } 
     va_end(arg); 
    } 
    
    
    这个就是比较完整的格式化函数 
    里面多次调用一个函数：handle_char 
    来看看它的定义： 
    STATIC VOID handle_char(COUNT c) 
    { 
     if (charp == 0) 
     put_console(c); 
     else 
     *charp++ = c; 
    } 
    
    里面又调用了put_console 
    显然，从函数名就可以看出来：它是用来显示的 
    void put_console(int c) 
    { 
     if (buff_offset >= MAX_BUFSIZE) 
     { 
     buff_offset = 0; 
     printf("Printf buffer overflow!\n"); 
     } 
     if (c == '\n') 
     { 
     buff[buff_offset] = 0; 
     buff_offset = 0; 
    #ifdef __TURBOC__ 
     _ES = FP_SEG(buff); 
     _DX = FP_OFF(buff); 
     _AX = 0x13; 
     __int__(0xe6); 
    #elif defined(I86) 
     asm 
     { 
     push ds; 
     pop es; 
     mov dx, offset buff; 
     mov ax, 0x13; 
     int 0xe6; 
     } 
    #endif 
     } 
     else 
     { 
     buff[buff_offset] = c; 
     buff_offset++; 
     } 
    } 
    
    
    注意：这里用递规调用了printf，不过这次没有格式化，所以不会出现死循环。 
    
    好了，现在你该更清楚的知道：printf的实现了 
    
    现在再说另一个问题： 
    无论如何printf()函数都不能确定参数...究竟在什么地方结束，也就是说，它不知 
    道参数的个数。它只会根据format中的打印格式的数目依次打印堆栈中参数format后面地址 
    的内容。 
    
    这样就存在一个可能的缓冲区溢出问题。。。