static void test_align(int dalign, int salign, int len)
{
char *src = aligned(buf);
char *dst = aligned(buf + 128);
char *want = aligned(buf + 256);
char *p;
int i;
if (salign + len > N || dalign + len > N)
abort();
for (i = 0; i < N; i++) {
src[i] = '#';
dst[i] = want[i] = ' ';
}
for (i = 0; i < len; i++)
src[salign+i] = want[dalign+i] = '0'+i;
p = pmemcpy(dst+dalign, src+salign, len);
if (p != dst+dalign)
t_error("memcpy(%p,...) returned %p\n", dst+dalign, p);
for (i = 0; i < N; i++)
if (dst[i] != want[i]) {
t_error("memcpy(align %d, align %d, %d) failed\n", dalign, salign, len);
t_printf("got : %.*s\n", dalign+len+1, dst);
t_printf("want: %.*s\n", dalign+len+1, want);
break;
}
}
void print_kernel_addrs(){
t_printf("%cPrinting Kernel Addresses%c\n", 9, 7);
t_printf("RAMDISK: %d\n", ramdisk_addr);
t_printf("KHEAP: %d\n", kheap_addr);
t_printf("FRAMEBUFFER: %d\n", fb_addr);
t_printf("\n");
}
void print_debug_help(){
t_printf("%c[CX] kernel debug shell, HELP%c\n\n", 9, 7);
t_printf("This is The Kernel Debug Shell, Use It Manully load and Execute procs, Print Kernel Info and Test System.\n");
t_printf("Current Supported Commands: \n");
t_printf("pkaddr - Prints the Kernel's MAJOR memory addresses\n");
t_printf("\n");
}
static int default_help (void) {
int i;
t_printf ("\n" BOLD_GREEN("TinyShell available commands:") "\n");
for (i = 0; commands[i].command_name != 0; i++) {
t_printf(BOLD_YELLOW("%s") " - " BOLD_CYAN("%s\n"), commands[i].command_name,
(commands[i].description==0)? "No desc. available" : commands[i].description);
}
t_printf ("\r\n");
return 0;
}
void shell_main(){
t_printf("\n[CX] Kernel Debug Shell, forced into due to Kernel fail or Load info said so.\n");
t_printf("Type \"help\" to get started\n\n");
while(running){
// print the prompt
t_printf("debug %s $ ", current_args);
char* c = waitforstring();
if(strEql(c, "pkaddr")){
print_kernel_addrs();
}else if(strEql(c, "help")){
print_debug_help();
}
}
}
static void debug_helper(void)
{
t_printf("[0x%x,0x%x,0x%x][0x%x,0x%x][0x%x,0x%x]\r\n",
g_kernel_image.image_base,
g_kernel_image.code_base,
g_kernel_image.data_base,
g_kernel_image.code_offset,
g_kernel_image.code_size,
g_kernel_image.data_offset,
g_kernel_image.data_size
);
t_printf("gdt: 0x%x, idt: 0x%x, tss: 0x%x\r\n",
(u32_t)(void*)&g_gdt,
(u32_t)(void*)&g_idt,
(u32_t)(void*)&g_tss);
t_printf("restart: 0x%x\r\n", restart);
}
void TinyShellRun (void) {
char cmd[COMMAND_MAX_LENGTH];
int i, ret;
while (1) {
t_printf (BOLD_GREEN("TinyShell") "> ");
t_gets (cmd, COMMAND_MAX_LENGTH);
for (i = 0; cmd[i] != 0 && i < COMMAND_MAX_LENGTH; i++)
if (cmd[i] == '\n' || cmd[i] == '\r') { cmd[i] = '\0'; break; }
ret = parse (cmd);
if (ret < 0)
t_printf (BOLD_YELLOW("Command not found: %s\n"), cmd);
else if (ret > 0)
t_printf (BOLD_RED("Error executing command: %s\n"), cmd);
}
}
static void test_align(int align, int len)
{
char *s = aligned(buf);
char *want = aligned(buf + 256);
char *p;
int i;
if (align + len > N)
abort();
for (i = 0; i < N; i++)
s[i] = want[i] = ' ';
for (i = 0; i < len; i++)
want[align+i] = '#';
p = pmemset(s+align, '#', len);
if (p != s+align)
t_error("memset(%p,...) returned %p\n", s+align, p);
for (i = 0; i < N; i++)
if (s[i] != want[i]) {
t_error("memset(align %d, '#', %d) failed\n", align, len);
t_printf("got : %.*s\n", align+len+1, s);
t_printf("want: %.*s\n", align+len+1, want);
break;
}
}
static void init_global(void)
{
u16_t* p = (u16_t*)log_start_address;
g_screen_cursor = (u16_t*)(2 * (u32_t)*p + screen_init_cursor);
g_ticks = 0;
g_reenter = 0;
g_kernel_stack_top = g_kernel_stack + kernel_stack_size;
g_addr_range_count = (int)*(u32_t*)(addr_range_start_addr - 4);
t_memcpy(g_addr_range, (void*)addr_range_start_addr, sizeof(addr_range_desc_t) * g_addr_range_count);
g_kernel_image = *(kernel_image_info_t*)0x6000;
t_printf("---- tinyos kernel ----\r\n");
}
void spurious_irq(void)
{
t_printf("!!!");
}
int main(int argc, char *argv[])
{
uint8_t str[MAXSTR+1];
long lnum, mask;
int i;
int k;
int size;
#ifdef __SIZEOF_INT128__
__uint128_t num128;
#endif
f_t f;
char *intops = "duxXo";
char *sizeops[] = { "short", "int", "long", "long long", NULL };
char *floatops = "fe";
printf("=======================\n");
printf("Start of Manual tests\n");
// Test basic type sizes
t_printf("sizeof (double) = %d\n", sizeof (double ) );
t_printf("sizeof (float) = %d\n", sizeof (float ) );
#ifdef __SIZEOF_INT128__
t_printf("sizeof (__uint128_t) = %d\n", sizeof (__uint128_t) );
#endif
t_printf("sizeof (long long) = %d\n", sizeof (long long ) );
t_printf("sizeof (long) = %d\n", sizeof (long ) );
t_printf("sizeof (short) = %d\n", sizeof (short) );
t_printf("sizeof (int) = %d\n", sizeof (int ) );
t_printf("sizeof (char) = %d\n", sizeof (char ) );
printf("=======================\n");
printf("\n");
#ifdef __SIZEOF_INT128__
printf("=======================\n");
printf("Start of 128 bit int tests\n");
// There are no 128bit int constants in gcc - sigh
num128 = 1;
for(i=0;i<128;++i)
{
t_printf("2**%03d = [%I128d]\n", i, num128);
fflush(stdout);
num128 <<= 1;
}
printf("=======================\n");
printf("\n");
printf("=======================\n");
printf("Start of 128 bit int tests - 40 field width\n");
num128 = 1;
for(i=0;i<128;++i)
{
t_printf("2**%03d = [%40I128d]\n", i, num128);
fflush(stdout);
num128 <<= 1;
}
printf("=======================\n");
printf("\n");
printf("=======================\n");
printf("Start of 128 bit int tests - 40 field width and leading 0's\n");
num128 = 1;
for(i=0;i<128;++i)
{
t_printf("2**%03d = [%+040I128d]\n", i, num128);
fflush(stdout);
num128 <<= 1;
}
printf("=======================\n");
printf("\n");
#endif
display_good = 0;
tests();
printf("\n\n");
printf("Start of random tests\n");
display_good = 0;
for(size=0;sizeops[size];++size)
{
for(k=0;intops[k];++k)
{
tp_good = 0;
tp_bad = 0;
printf("=======================\n");
printf("Start:(%c:%s)\n", intops[k], sizeops[size]);
for(i=0;i<1000000;++i)
random_tests(intops[k], sizeops[size]);
printf("End: (%c:%s)\n", intops[k], sizeops[size]);
printf("Good:%ld, Bad:%ld, fmt:%ld\n", tp_good, tp_bad, tp_fmt);
printf("=======================\n");
}
}
display_good = 0;
for(k=0;floatops[k];++k)
{
tp_good = 0;
tp_bad = 0;
printf("=======================\n");
printf("Start:(%c)\n", floatops[k]);
for(i=0;i<1000000;++i)
random_tests(floatops[k], "");
printf("End: (%c)\n", floatops[k]);
printf("Good:%ld, Bad:%ld, fmt:%ld\n", tp_good, tp_bad, tp_fmt);
printf("=======================\n");
}
printf("\n");
printf("Random done\n");
printf("=======================\n");
printf("testing binary leading 1's\n");
lnum = 0;
lnum = ~lnum;
mask = 1;
while(mask)
{
lnum &= ~mask;
mask <<= 1;
tp("%016lx", lnum);
tp("%019ld", lnum);
tp("%022lo", lnum);
}
printf("=================================\n");
printf("testing binary trailing 1's\n");
lnum = 0;
mask = 1;
while(mask)
{
lnum |= mask;
mask <<= 1;
tp("%016lx", lnum);
tp("%019ld", lnum);
tp("%022lo", lnum);
}
printf("=================================\n");
printf("testing base 10 9's\n");
lnum = 9;
while(1)
{
if(lnum & (1L << ((sizeof(lnum)*8)-1)))
break;
tp("%016lx", lnum);
tp("%019ld", lnum);
tp("%022lo", lnum);
lnum *= 10;
lnum += 9;
}
printf("\n");
printf("=================================\n");
return(0);
}
