【第8章】追踪ASSERT宏

   终于开始下篇的旅途了，没想到作者在下篇严重高估了读者，全然不像上篇那样把80%的代码拿出来讲解。刚看到第8章的开头偶就云里雾里了，这种感觉很像是第一次看上篇时的感觉，不过还好还好，偶这不是挺过上篇了么，关键还是方法问题。作者在下篇大概只拿出来了5,60%的代码出来讲，这样偶就必须在他的源代码里翻来翻去，全给扒拉出来，他的代码还好有注释，偶还得根据偶的思路来重写并加上注释。。真是辛苦。。下篇只占用了整本书的1/3，还以为很快就能搞定，看来偶真是太天真了。

 

   万事开头难，为了方便调试，首先祭出了ASSERT宏和PANIC宏，这两个宏就是拿来调试的。这次先把ASSERT宏搞定吧。这个宏在C++中相信很多人也用过吧。

 

   首先把此宏的定义找出来，

   在include/const.h中：

/* the assert macro */ #define ASSERT #ifdef ASSERT void assertion_failure(char *exp, char *file, char *base_file, int line); #define assert(exp) if (exp) ; / else assertion_failure(#exp, __FILE__, __BASE_FILE__, __LINE__) #else #define assert(exp) #endif

 

   首先是一个预处理，避免重复定义此宏。如果define了ASSERT，则先是一个函数声明：

void assertion_failure(char *exp, char *file, char *base_file, int line);

 

   此宏有一个参数，如果这个参数为真，则不做处理，如果不为真，则调用先前声明的函数。 

 

   接着就调用它，把1个表达式转化为字符串，传进此函数，其它3个参数是被展开的文件名，传递给编译器的那个文件名，和展开成当前的行号，这样就可以方便的知道异常出现的地点。

 

   接着跟进到assertion_failure函数，

   lib/misc.c:

/***************************************************************************** * assertion_failure *************************************************************************//** * Invoked by assert(). * * @param exp The failure expression itself. * @param file __FILE__ * @param base_file __BASE_FILE__ * @param line __LINE__ *****************************************************************************/ PUBLIC void assertion_failure(char *exp, char *file, char *base_file, int line) { printl("%c assert(%s) failed: file: %s, base_file: %s, ln%d", MAG_CH_ASSERT, exp, file, base_file, line); /** * If assertion fails in a TASK, the system will halt before * printl() returns. If it happens in a USER PROC, printl() will * return like a common routine and arrive here. * @see sys_printx() * * We use a forever loop to prevent the proc from going on: */ spin("assertion_failure()"); /* should never arrive here */ __asm__ __volatile__("ud2"); }

 

   首先调用了printl函数，这个函数其实就是printf函数的宏，等于调用了printf函数，printf函数是改进过了的，这个等会再说。函数返回以后，出现一个陀注释，意思是说，如果在系统进程中ASSERT失败，在系统会在printl函数返回halt掉，如果发生在用户进程中，则printl会正常的返回，但是随后又调用了一个spin函数，来看看这个函数：

   lib/misc.c:

/***************************************************************************** * spin *****************************************************************************/ PUBLIC void spin(char * func_name) { printl("/nspinning in %s .../n", func_name); while (1) {} }

 

   这个函数调用了printl把参数的串打印出来后就进入了1个死循环。后面的嵌入汇编永远不会执行。

   现在就很明了了，就是printl函数也就是printf函数做了什么改进呢，把代码贴出来。

   kernel/printf.c

/*======================================================================* printf *======================================================================*/ int printf(const char *fmt, ...) { int i; char buf[256]; va_list arg = (va_list)((char*)(&fmt) + 4); /*4是参数fmt所占堆栈中的大小*/ i = vsprintf(buf, fmt, arg); buf[i] = 0; printx(buf); return i; }

 

   调用的vsprintf函数是关键，贴出来先，注释是我加的。。。乱是乱了点。。

   kernel/vsprintf.c

/*======================================================================* vsprintf *======================================================================*/ /* * 为更好地理解此函数的原理，可参考 printf 的注释部分。 */ PUBLIC int vsprintf(char *buf, const char *fmt, va_list args) { char* p; /* 指向解析好的串的空间的首地址 */ va_list p_next_arg = args; /* 指向第一个可变参数 */ /* 暂时未知的局部变量 */ int m; /* 存放转换好的数字 */ char inner_buf[STR_DEFAULT_LEN]; char cs /* 用做对齐的填充的字符，后面被设为空格 */; int align_nr; /* 对齐所占的字符的宽度 */ /* 遍历格式字符串 */ for (p=buf;*fmt;fmt++) { /* 如果不是%，则代表不是格式占位符，直接把字符拷到解析串中 */ if (*fmt != '%') { *p++ = *fmt; continue; /* 继续下一轮循环 */ } else { /* 如果是%，则表明是占位符 */ align_nr = 0; /* 暂时未知的赋值 */ } fmt++; /* 指向格式字符串的下一个字符 */ /* 如果还是占位符则当作普通字符处理 */ if (*fmt == '%') { *p++ = *fmt; continue; } /* 如果是'0' */ else if (*fmt == '0') { cs = '0'; /* 暂时未知的赋值 */ fmt++; /* 指向格式字符串的下一个字符 */ } else { cs = ' '; /* 暂时未知的赋值 */ } /* 此时指向的格式字符串的字符是数字的话，则循环继续 */ while (((unsigned char)(*fmt) >= '0') && ((unsigned char)(*fmt) <= '9')) { align_nr *= 10; /* 未知 */ align_nr += *fmt - '0'; /* 未知 */ fmt++; /* 指向格式字符串的下一个字符 */ } /* 临时未知数组首地址给q，并把此数组初始化为0 */ char * q = inner_buf; memset(q, 0, sizeof(inner_buf)); /* 总算开始这里了。。 */ switch (*fmt) { /* 处理字符 */ case 'c': *q++ = *((char*)p_next_arg); /* 塞进q中 */ p_next_arg += 4; /* 指向下一个可变参数 */ break; /* 处理16进制数 */ case 'x': m = *((int*)p_next_arg); /* 把当前可变参数解释成整数给m */ i2a(m, 16, &q); /* 把m转换成串送到q中，以16进制的形式 */ p_next_arg += 4; /* 指向下一个可变参数 */ break; /* 处理10进制数 */ case 'd': m = *((int*)p_next_arg); /* 把当前可变参数解释成整数给m */ /* 如果是负数则在q中写一个负号再转换成正数 */ if (m < 0) { m = m * (-1); *q++ = '-'; } i2a(m, 10, &q); /* 把m转换成串送到q中，以10进制的形式 */ p_next_arg += 4; /* 指向下一个可变参数 */ break; /* 处理字符串 */ case 's': strcpy(q, (*((char**)p_next_arg))); /* 串拷贝 */ q += strlen(*((char**)p_next_arg)); /* 移动q指针 */ p_next_arg += 4; /* 指向下一个可变参数 */ break; default: break; } /* 填充对齐所缺的占位符，就是空格 */ int k; for (k = 0; k < ((align_nr > strlen(inner_buf)) ? (align_nr - strlen(inner_buf)) : 0); k++) { *p++ = cs; } /* 将q中的数据拷到p中 */ q = inner_buf; while (*q) { *p++ = *q++; } } /* p的末尾赋'/0'，标志串结束 */ *p = 0; /* 返回解析好的字符串个数 */ return (p - buf); }

 

 

   逻辑很清晰，总之是把格式字符串给解析好喽返回去，其中用了一个i2a函数，可以随意设置要转化的进制数，其中用到了递归。。很好。。贴出来先。

   kernel/vsprintf.c

/*======================================================================* i2a *======================================================================*/ PRIVATE char* i2a(int val, int base, char ** ps) { int m = val % base; /* 得到当前要转换的数与基数的模 */ int q = val / base; /* 得到当前要转换的数与基数的除数 */ /* 如果除数不为0，则递归调用 */ if (q) { i2a(q, base, ps); } /* 如果大于9则转换为16进制字母赋给参数指向的数组 */ *(*ps)++ = (m < 10) ? (m + '0') : (m - 10 + 'A'); return *ps; }

 

   printf函数最后调用了printx函数，printx函数就是系统调用咯，跟进去看。

   kernel/syscall.asm

; ==================================================================================== ; void printx(char* s); ; ==================================================================================== printx: mov eax, _NR_printx mov edx, [esp + 4] int INT_VECTOR_SYS_CALL ret

 

   把栈中的解析好的串的地址放到edx中给内核使用，接着跟进到内核。

   kernel/kernel.asm

; ============================================================================= ; sys_call ; ============================================================================= sys_call: call save sti push esi push dword [p_proc_ready] push edx push ecx push ebx call [sys_call_table + eax * 4] add esp, 4 * 4 pop esi mov [esi + EAXREG - P_STACKBASE], eax cli ret

 

   先把当前指针压了进去，再把edx压了进去，我们知道这是解析好的串的地址，再把ecx,ebx压了进去，这两个参数在printx函数中是用不着的，这是为了与其它系统调用兼容，日后再说，接着就是中断调用实质性的工作了，跟入。

   kernel/proc.c

#define TTY_FIRST (tty_table) #define TTY_END (tty_table + NR_CONSOLES) /*======================================================================* sys_printx *======================================================================*/ PUBLIC int sys_printx(int _unused1, int _unused2, char* s, struct proc* p_proc) { const char * p; char ch; char reenter_err[] = "? k_reenter is incorrect for unknown reason"; reenter_err[0] = MAG_CH_PANIC; /** * @note Code in both Ring 0 and Ring 1~3 may invoke printx(). * If this happens in Ring 0, no linear-physical address mapping * is needed. * * @attention The value of `k_reenter' is tricky here. When * -# printx() is called in Ring 0 * - k_reenter > 0. When code in Ring 0 calls printx(), * an `interrupt re-enter' will occur (printx() generates * a software interrupt). Thus `k_reenter' will be increased * by `kernel.asm::save' and be greater than 0. * -# printx() is called in Ring 1~3 * - k_reenter == 0. */ if (k_reenter == 0) /* printx() called in Ring<1~3> */ p = va2la(proc2pid(p_proc), s); else if (k_reenter > 0) /* printx() called in Ring<0> */ p = s; else /* this should NOT happen */ p = reenter_err; /** * @note if assertion fails in any TASK, the system will be halted; * if it fails in a USER PROC, it'll return like any normal syscall * does. */ if ((*p == MAG_CH_PANIC) || (*p == MAG_CH_ASSERT && p_proc_ready < &proc_table[NR_TASKS])) { disable_int(); char * v = (char*)V_MEM_BASE; const char * q = p + 1; /* +1: skip the magic char */ while (v < (char*)(V_MEM_BASE + V_MEM_SIZE)) { *v++ = *q++; *v++ = RED_CHAR; if (!*q) { while (((int)v - V_MEM_BASE) % (SCR_WIDTH * 16)) { /* *v++ = ' '; */ v++; *v++ = GRAY_CHAR; } q = p + 1; } } __asm__ __volatile__("hlt"); } while ((ch = *p++) != 0) { if (ch == MAG_CH_PANIC || ch == MAG_CH_ASSERT) continue; /* skip the magic char */ out_char(tty_table[p_proc->nr_tty].p_console, ch); } return 0; }

 

   这里用了一个技巧，如果k_reenter的值为0，则表示ASSERT是在用户进程中调用的，如果k_reenter的值大于0，则表示是在系统进程发生的。在用户进程发生就要把解析好的串的虚拟地址转换为线性地址，由于每个进程的LDT中的段描述符是从GDT中拷来的，只是DPL不一样，所以这里的操作暂时没什么意义，不过也要跟进一下。

 

   这个宏是根据进程的PCB指针得到相对PCB表的偏移

   include/proc.h

#define proc2pid(x) (x - proc_table)

 

   kernel/proc.c

   ldt_seg_linear函数是根据PCB指针和此PCB的LDT的选择子偏移得到此选择子的基地址。

   va2la函数是根据进程号即相对PCB表的偏移得到参数void指针的线性地址。

/***************************************************************************** * ldt_seg_linear *****************************************************************************/ /** * <Ring 0~1> Calculate the linear address of a certain segment of a given * proc. * * @param p Whose (the proc ptr). * @param idx Which (one proc has more than one segments). * * @return The required linear address. *****************************************************************************/ PUBLIC int ldt_seg_linear(struct proc* p, int idx) { struct descriptor * d = &p->ldts[idx]; return d->base_high << 24 | d->base_mid << 16 | d->base_low; } /***************************************************************************** * va2la *****************************************************************************/ /** * <Ring 0~1> Virtual addr --> Linear addr. * * @param pid PID of the proc whose address is to be calculated. * @param va Virtual address. * * @return The linear address for the given virtual address. *****************************************************************************/ PUBLIC void* va2la(int pid, void* va) { struct proc* p = &proc_table[pid]; u32 seg_base = ldt_seg_linear(p, INDEX_LDT_RW); u32 la = seg_base + (u32)va; if (pid < NR_TASKS + NR_PROCS) { assert(la == (u32)va); } return (void*)la; }

 

   回到sys_printx接着判断解析好的串的第一个字符是否是约定好的字符，如果是PANIC或者ASSERT且在系统进程发生的，则往显存中一直写入解析好的串直到超过显存范围为止。写完后就嵌入汇编halt。

   如果是普通的输出或者是在用户进程发生的ASSERT则逐个字符把解析好的串叫给OutChar打印，正常退出。而用户进程的ASSERT结束输出后回到assertion_failure后调用spin函数进入死循环。

    

     这只是非常简单的把作者的代码过了一遍，还得自己写呢。。不过总算有了大概的思路。。明天继续。。