编写自己的内核打印函数

原创文章,转载写明出处

作者Crazii @ CSDN

我看了minix的内核printf函数之后,发现它里面的goto有语句...我就读不下去了,于是自己写了一个.kprintf

首先要了解的就是printf的变参.这得从c调用规则讲起.回顾一下c(cdecl)调用规则(vc里面__cdecl关键字,MASM里面的.model c)除了命名要加下划线之外,还有函数的调用:参数是从右至左入栈,并且是调用者恢复栈.

;printf(fmt,s);假定fmt和s是指针变量

push s

push fmt

call _printf

add esp 8

嗯,这里还有一个问题,就是栈对齐问题.如果是char型参数,或者是short型参数,那么压栈的数据宽度是多少?16位下我们知道,最小得是一个word,也就是short型,char型数据入栈时,也是按word.而32位下,压栈的默认大小跟段描述符里面的描述有关,如果段是16位段,则按16位入栈,如果是32位段,则按32位入栈.这里当然要说32位的栈了,push 0xFF,这样的立即数是按32位对齐,push ds这样的16位段寄存器也是按32位对齐.好了.ok到这里,感觉离题有点远了..

 

正因为cdecl调用跟stdcall不同,它是调用者负责恢复栈的,所以调用者想压几个参数就压几个参数,调用完了自己在平衡堆栈就OK了,所以可以支持变参,但是stdcall是被调用函数在结束时ret n来维护栈的,调用者不能随便压参数.总之,cdecl支持可变参数vararg,所以才有现在的printf

嗯,根据C调用规则,就知道了栈上的参数分布,这样在读取可变参数时,就好办了.

1. /******************************************************
2. stdarg.h
3. standard argument header for NGOS
4. *******************************************************
5. C语言参数头文件
6. Author: ZZU-Crazii
7. */
9. typedef char    *var_list;  //VC里面也是这样写的,跟我想的一样
11. /*  参考VC里的头文件,栈的对齐,是sizeof(int)的整数倍  */
12. #define INT_SIZEOF(n)   ( (sizeof(n) + sizeof(int) - 1) & ~(sizeof(int) - 1) )
14. /* 按对齐,取下一个参数 */
15. #define var_start(arg_ptr,arg_list) (  (void) (arg_ptr = (var_list)(&arg_list)+INT_SIZEOF(arg_list)) )
17. /* 将取出的参数强制转换为指定的Type,并指向下一个参数 */
18. #define var_arg(arg_ptr,type)   (*(type*)   ( (arg_ptr +=INT_SIZEOF(type))-INT_SIZEOF(type) )   )
20. #define var_end(arg_ptr) ((void)(arg_ptr=NULL)

 

需要说明的是,我自己写的stdarg之前的版本,栈取参数后的增量是++操作(+sizeof(type)),那么如果取出的类型是char,则varptr是+1的,这显然不符合栈对齐原则.应该将sizeof(type)对齐到INT长度的倍数,就像VC的crt头文件里面一样.这样,如果取出的参数是char,那么varptr将+4,来指向下一个参数好了,可以看kprintf了:

1. //这个宏来自minix
2. #define isdigit(c)  ( (unsigned)( (unsigned)(c) - '0') <= (unsigned)9 )
4. #define BUFFER_SIZE 32  /* 将数字转化为字符串的缓冲 */
5. /*****************kprintf*************************/
6. #include <stdarg.h> /* 自己做的头文件 */
7. /* 支持%s, %d,%u 的简单版*/
8. /* 3.26,添加%x,长度,对齐.等 */
9. /* 3.26 稍作修改,添加%X */
10. void kprintf(const char *fmt,...)
11. {
12.     var_list    argp;
13.     int c;
14.     /*const char *pString;*/
15.     const char *Ostring;
16.     union
17.     {
18.         int     s;  /* 有符号 */
19.         unsigned    uns;    /* 无符号 */
20.     }num;
21.     int i;
22.     unsigned int len;   
23.     static char tmp[BUFFER_SIZE];
24.     static const char null_pointer[] ="(NULL)";
25.     
26.     int width;      /* 指定显示长度 */
27.     unsigned int limit; /* 截断显示长度 */
28.     int align_left;
29.     char    fill_prefix;
30.     
31.     if( fmt == NULL ) return;
32.     var_start(argp,fmt);
33.     
34.     while( (c=*(fmt++)) !=NULL )
35.     {
36.         if( c!='%' )
37.         {
38.             kputchar(c);
39.             continue;
40.         }
41.         num.uns = 0;
42.         Ostring = NULL;
43.         
44.         c = *(fmt++);       /* 跳过 '%' */
45.         
46.         /* 对齐方式 */
47.         align_left = FALSE;
48.         if( c == '-' )
49.         {
50.             align_left = TRUE;
51.             c = *(fmt++);
52.         }
53.         
54.         /* '0'前缀 */
55.         fill_prefix =' ';
56.         if( c == '0')
57.         {
58.             fill_prefix = '0';
59.             c = *(fmt++);
60.         }
61.         
62.         /* 宽度 */
63.         width = 0;
64.         if( c == '*' )
65.         {
66.             width = var_arg(argp,int);
67.             c = *(fmt++);
68.         }
69.         else while ( isdigit(c) )
70.         {
71.             width= width * 10 + (c - '0');
72.             c = *(fmt++);
73.         }
74.         
75.         /* 截断 */ /* 修复BUG,limit=0,串不能显示 */
76.         limit = ULONG_MAX;
77.         if( c == '.' )
78.         {
79.             c = *(fmt++);
80.             if( isdigit(c) )
81.             {
82.                 limit = 0;
83.                 while( isdigit(c) )
84.                 {
85.                     limit= limit * 10 + (c - '0');
86.                     c = *(fmt++);
87.                 }
88.             }
89.         }
90.         
91.         switch(c)
92.         {
93.             case 's':   /* %s */
94.                 Ostring=var_arg(argp,char*);
95.                 if( Ostring == NULL )
96.                     Ostring=null_pointer;
97.                 
98.                 /* 计算字符串长度 */
99.                 for( i=0; Ostring[i]!=0; i++);
100.                 len = i;
101.                 break;
102.             case 'd':   /* %d */
103.                 num.s=var_arg(argp,int);
104.                 
105.                 if(num.s==0)
106.                 {
107.                     tmp[0] ='0';
108.                     Ostring = tmp;
109.                     len =1;
110.                     break;
111.                 }
112.                 if( num.s<0 )       /* 将负数转换成正数 */
113.                 {
114.                     kputchar('-');
115.                     num.s = -num.s;
116.                 }
117.                 /* !!!没有break,继续,作为无符号数处理 */
118.             case 'u':   /* %u */
119.                 if( num.uns == 0 ) num.uns = var_arg(argp,unsigned int);
121.                 if(num.uns==0)
122.                 {
123.                     tmp[0] ='0';
124.                     Ostring = tmp;
125.                     len =1;
126.                     break;
127.                 }
128.                 /* 3.26 改成从高字节(BUFFER_SIZE-1)开始写入字符 */
129.                 for(i=0; num.uns/10 !=0 || num.uns%10 !=0;num.uns/=10,i++)
130.                     tmp[BUFFER_SIZE-1-i] = (char)(num.uns%10) + '0';
131.                 
132.                 /****************************
133.                 字符串: H=结束字节,第一个写入,
134.                     L=开始字节,最后一个被写入,
135.                     B=缓冲区开始位置
136.                     |<-长度i->|
137.                 |B|.....|L|.....|H|
138.                      ^
139.                      |
140.                     (BUFFER_SIZE-i)索引的最终位置
141.                 *****************************/
142.                 Ostring = tmp+ (BUFFER_SIZE - i);
143.                 len = i;
144.                 /* 数字不做截断处理 */
145.                 limit = ULONG_MAX;
146.                 break;
147.             case 'x': case'X':
148.                 num.uns = var_arg(argp,unsigned int);
149.                 if(num.uns==0)
150.                 {
151.                     tmp[0] ='0';
152.                     Ostring = tmp;
153.                     len =1;
154.                     break;
155.                 }
156.                 for(i=0; num.uns/16 !=0 || num.uns%16 !=0;num.uns/=16,i++)
157.                 {
158.                     if( (num.uns%16) < 10 )
159.                         tmp[BUFFER_SIZE-1-i] = (char)(num.uns%16) + '0';
160.                     else        /* 'x'-'a' == 'X'-'a' 嘎嘎~ */
161.                         tmp[BUFFER_SIZE-1-i] = (char)((num.uns%16)-10)+c-('x'-'a');
162.                 }
163.                 Ostring = tmp+ (BUFFER_SIZE - i);
164.                 len = i;
165.                 /* 数字不做截断处理 */
166.                 limit = ULONG_MAX;
167.                 break;
168.             default:
169.                 kputchar('%');
170.                 kputchar(c);
171.                 break;
172.         }
173.         /* 问题:数字缓冲是倒序,但是字符串是正序排列... */
174.         /* 把数字缓冲改成正序.OK */
175.         if( Ostring != NULL )
176.         {
177.             /* 计算对齐并输出 */
178.             if( !align_left && len< width )
179.             {
180.                 do
181.                 {
182.                     kputchar(fill_prefix);
183.                     width--;
184.                 }while( len<width );
185.             }
186.             
187.             /* 截断处理 */
188.             if( len > limit )
189.                 len = limit;
190.                 
191.             for(i=0;i<len;i++)
192.                 kputchar( Ostring[i] );
193.                 
194.             if( align_left && len< width )
195.             {
196.                 do
197.                 {
198.                     kputchar(' ');
199.                     width--;
200.                 }while( len<width );
201.             }
203.         }
204.     }
205.     var_end(argp);
206.     kputchar( NULL );        /* 释放缓冲,显示 */        
207. }