Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • kernel/generic/src/console/cmd.c

    r40fb017 r98000fb  
    4646#include <print.h>
    4747#include <panic.h>
    48 #include <typedefs.h>
     48#include <arch/types.h>
    4949#include <adt/list.h>
    5050#include <arch.h>
    5151#include <config.h>
    5252#include <func.h>
    53 #include <str.h>
     53#include <string.h>
    5454#include <macros.h>
    5555#include <debug.h>
    … …  
    6666#include <ipc/irq.h>
    6767#include <ipc/event.h>
    68 #include <sysinfo/sysinfo.h>
    6968#include <symtab.h>
    7069#include <errno.h>
    … …  
    7877static cmd_info_t help_info = {
    7978        .name = "help",
    80         .description = "List supported commands.",
     79        .description = "List of supported commands.",
    8180        .func = cmd_help,
    8281        .argc = 0
    8382};
    8483
    85 /* Data and methods for 'reboot' command. */
    8684static int cmd_reboot(cmd_arg_t *argv);
    8785static cmd_info_t reboot_info = {
    8886        .name = "reboot",
    89         .description = "Reboot system.",
     87        .description = "Reboot.",
    9088        .func = cmd_reboot,
    9189        .argc = 0
    9290};
    9391
    94 /* Data and methods for 'uptime' command. */
    9592static int cmd_uptime(cmd_arg_t *argv);
    9693static cmd_info_t uptime_info = {
    9794        .name = "uptime",
    98         .description = "Show system uptime.",
     95        .description = "Print uptime information.",
    9996        .func = cmd_uptime,
    10097        .argc = 0
    10198};
    10299
    103 /* Data and methods for 'continue' command. */
    104100static int cmd_continue(cmd_arg_t *argv);
    105101static cmd_info_t continue_info = {
    … …  
    111107
    112108#ifdef CONFIG_TEST
    113 
    114 /* Data and methods for 'test' command. */
     109static int cmd_tests(cmd_arg_t *argv);
     110static cmd_info_t tests_info = {
     111        .name = "tests",
     112        .description = "Print available kernel tests.",
     113        .func = cmd_tests,
     114        .argc = 0
     115};
     116
    115117static char test_buf[MAX_CMDLINE + 1];
    116118static int cmd_test(cmd_arg_t *argv);
    117119static cmd_arg_t test_argv[] = {
    118120        {
    119                 .type = ARG_TYPE_STRING_OPTIONAL,
     121                .type = ARG_TYPE_STRING,
    120122                .buffer = test_buf,
    121123                .len = sizeof(test_buf)
    … …  
    124126static cmd_info_t test_info = {
    125127        .name = "test",
    126         .description = "<test> List kernel tests or run a test.",
     128        .description = "Run kernel test.",
    127129        .func = cmd_test,
    128130        .argc = 1,
    … …  
    130132};
    131133
    132 /* Data and methods for 'bench' command. */
    133134static int cmd_bench(cmd_arg_t *argv);
    134135static cmd_arg_t bench_argv[] = {
    … …  
    144145static cmd_info_t bench_info = {
    145146        .name = "bench",
    146         .description = "<test> <count> Run kernel test as benchmark.",
     147        .description = "Run kernel test as benchmark.",
    147148        .func = cmd_bench,
    148149        .argc = 2,
    149150        .argv = bench_argv
    150151};
    151 
    152 #endif /* CONFIG_TEST */
     152#endif
    153153
    154154/* Data and methods for 'description' command. */
    155155static int cmd_desc(cmd_arg_t *argv);
    156156static void desc_help(void);
    157 static char desc_buf[MAX_CMDLINE + 1];
     157static char desc_buf[MAX_CMDLINE+1];
    158158static cmd_arg_t desc_argv = {
    159159        .type = ARG_TYPE_STRING,
    … …  
    163163static cmd_info_t desc_info = {
    164164        .name = "describe",
    165         .description = "<command> Describe specified command.",
     165        .description = "Describe specified command.",
    166166        .help = desc_help,
    167167        .func = cmd_desc,
    … …  
    172172/* Data and methods for 'symaddr' command. */
    173173static int cmd_symaddr(cmd_arg_t *argv);
    174 static char symaddr_buf[MAX_CMDLINE + 1];
     174static char symaddr_buf[MAX_CMDLINE+1];
    175175static cmd_arg_t symaddr_argv = {
    176176        .type = ARG_TYPE_STRING,
    … …  
    180180static cmd_info_t symaddr_info = {
    181181        .name = "symaddr",
    182         .description = "<symbol> Return symbol address.",
     182        .description = "Return symbol address.",
    183183        .func = cmd_symaddr,
    184184        .argc = 1,
    … …  
    186186};
    187187
    188 /* Data and methods for 'set4' command. */
    189 static char set_buf[MAX_CMDLINE + 1];
     188static char set_buf[MAX_CMDLINE+1];
    190189static int cmd_set4(cmd_arg_t *argv);
    191190static cmd_arg_t set4_argv[] = {
    … …  
    201200static cmd_info_t set4_info = {
    202201        .name = "set4",
    203         .description = "<addr> <value> Set 4B memory location to a value.",
     202        .description = "set <dest_addr> <value> - 4byte version",
    204203        .func = cmd_set4,
    205204        .argc = 2,
    … …  
    207206};
    208207
    209 /* Data and methods for 'call0' and 'mcall0' command. */
     208/* Data and methods for 'call0' command. */
    210209static char call0_buf[MAX_CMDLINE + 1];
    211210static char carg1_buf[MAX_CMDLINE + 1];
    … …  
    221220static cmd_info_t call0_info = {
    222221        .name = "call0",
    223         .description = "<function> Call function().",
     222        .description = "call0 <function> -> call function().",
    224223        .func = cmd_call0,
    225224        .argc = 1,
    … …  
    236235static cmd_info_t mcall0_info = {
    237236        .name = "mcall0",
    238         .description = "<function> Call function() on each CPU.",
     237        .description = "mcall0 <function> -> call function() on each CPU.",
    239238        .func = cmd_mcall0,
    240239        .argc = 1,
    … …  
    258257static cmd_info_t call1_info = {
    259258        .name = "call1",
    260         .description = "<function> <arg1> Call function(arg1).",
     259        .description = "call1 <function> <arg1> -> call function(arg1).",
    261260        .func = cmd_call1,
    262261        .argc = 2,
    … …  
    285284static cmd_info_t call2_info = {
    286285        .name = "call2",
    287         .description = "<function> <arg1> <arg2> Call function(arg1, arg2).",
     286        .description = "call2 <function> <arg1> <arg2> -> call function(arg1,arg2).",
    288287        .func = cmd_call2,
    289288        .argc = 3,
    … …  
    318317static cmd_info_t call3_info = {
    319318        .name = "call3",
    320         .description = "<function> <arg1> <arg2> <arg3> Call function(arg1, arg2, arg3).",
     319        .description = "call3 <function> <arg1> <arg2> <arg3> -> call function(arg1,arg2,arg3).",
    321320        .func = cmd_call3,
    322321        .argc = 4,
    … …  
    348347cmd_info_t tlb_info = {
    349348        .name = "tlb",
    350         .description = "Print TLB of the current CPU.",
     349        .description = "Print TLB of current processor.",
    351350        .help = NULL,
    352351        .func = cmd_tlb,
    … …  
    355354};
    356355
    357 static char flag_buf[MAX_CMDLINE + 1];
    358 
    359356static int cmd_threads(cmd_arg_t *argv);
    360 static cmd_arg_t threads_argv = {
    361         .type = ARG_TYPE_STRING_OPTIONAL,
    362         .buffer = flag_buf,
    363         .len = sizeof(flag_buf)
    364 };
    365357static cmd_info_t threads_info = {
    366358        .name = "threads",
    367         .description = "List all threads (use -a for additional information).",
     359        .description = "List all threads.",
    368360        .func = cmd_threads,
    369         .argc = 1,
    370         .argv = &threads_argv
     361        .argc = 0
    371362};
    372363
    373364static int cmd_tasks(cmd_arg_t *argv);
    374 static cmd_arg_t tasks_argv = {
    375         .type = ARG_TYPE_STRING_OPTIONAL,
    376         .buffer = flag_buf,
    377         .len = sizeof(flag_buf)
    378 };
    379365static cmd_info_t tasks_info = {
    380366        .name = "tasks",
    381         .description = "List all tasks (use -a for additional information).",
     367        .description = "List all tasks.",
    382368        .func = cmd_tasks,
    383         .argc = 1,
    384         .argv = &tasks_argv
    385 };
    386 
    387 #ifdef CONFIG_UDEBUG
    388 
    389 /* Data and methods for 'btrace' command */
    390 static int cmd_btrace(cmd_arg_t *argv);
    391 static cmd_arg_t btrace_argv = {
    392         .type = ARG_TYPE_INT,
    393 };
    394 static cmd_info_t btrace_info = {
    395         .name = "btrace",
    396         .description = "<threadid> Show thread stack trace.",
    397         .func = cmd_btrace,
    398         .argc = 1,
    399         .argv = &btrace_argv
    400 };
    401 
    402 #endif /* CONFIG_UDEBUG */
     369        .argc = 0
     370};
     371
    403372
    404373static int cmd_sched(cmd_arg_t *argv);
    405374static cmd_info_t sched_info = {
    406375        .name = "scheduler",
    407         .description = "Show scheduler information.",
     376        .description = "List all scheduler information.",
    408377        .func = cmd_sched,
    409378        .argc = 0
    … …  
    418387};
    419388
    420 static int cmd_sysinfo(cmd_arg_t *argv);
    421 static cmd_info_t sysinfo_info = {
    422         .name = "sysinfo",
    423         .description = "Dump sysinfo.",
    424         .func = cmd_sysinfo,
    425         .argc = 0
    426 };
    427 
    428389/* Data and methods for 'zones' command */
    429390static int cmd_zones(cmd_arg_t *argv);
    430391static cmd_info_t zones_info = {
    431392        .name = "zones",
    432         .description = "List memory zones.",
     393        .description = "List of memory zones.",
    433394        .func = cmd_zones,
    434395        .argc = 0
     396};
     397
     398/* Data and methods for 'ipc' command */
     399static int cmd_ipc(cmd_arg_t *argv);
     400static cmd_arg_t ipc_argv = {
     401        .type = ARG_TYPE_INT,
     402};
     403static cmd_info_t ipc_info = {
     404        .name = "ipc",
     405        .description = "ipc <taskid> Show IPC information of given task.",
     406        .func = cmd_ipc,
     407        .argc = 1,
     408        .argv = &ipc_argv
    435409};
    436410
    … …  
    443417static cmd_info_t zone_info = {
    444418        .name = "zone",
    445         .description = "<zone> Show memory zone structure.",
     419        .description = "Show memory zone structure.",
    446420        .func = cmd_zone,
    447421        .argc = 1,
    448422        .argv = &zone_argv
    449 };
    450 
    451 /* Data and methods for 'ipc' command */
    452 static int cmd_ipc(cmd_arg_t *argv);
    453 static cmd_arg_t ipc_argv = {
    454         .type = ARG_TYPE_INT,
    455 };
    456 static cmd_info_t ipc_info = {
    457         .name = "ipc",
    458         .description = "<taskid> Show IPC information of a task.",
    459         .func = cmd_ipc,
    460         .argc = 1,
    461         .argv = &ipc_argv
    462 };
    463 
    464 /* Data and methods for 'kill' command */
    465 static int cmd_kill(cmd_arg_t *argv);
    466 static cmd_arg_t kill_argv = {
    467         .type = ARG_TYPE_INT,
    468 };
    469 static cmd_info_t kill_info = {
    470         .name = "kill",
    471         .description = "<taskid> Kill a task.",
    472         .func = cmd_kill,
    473         .argc = 1,
    474         .argv = &kill_argv
    475423};
    476424
    … …  
    506454        &cpus_info,
    507455        &desc_info,
     456        &reboot_info,
     457        &uptime_info,
    508458        &halt_info,
    509459        &help_info,
    510460        &ipc_info,
    511         &kill_info,
    512         &physmem_info,
    513         &reboot_info,
    514         &sched_info,
    515461        &set4_info,
    516462        &slabs_info,
    517463        &symaddr_info,
    518         &sysinfo_info,
     464        &sched_info,
     465        &threads_info,
    519466        &tasks_info,
    520         &threads_info,
     467        &physmem_info,
    521468        &tlb_info,
    522         &uptime_info,
    523469        &version_info,
    524470        &zones_info,
    525471        &zone_info,
    526472#ifdef CONFIG_TEST
     473        &tests_info,
    527474        &test_info,
    528475        &bench_info,
    529476#endif
    530 #ifdef CONFIG_UDEBUG
    531         &btrace_info,
    532 #endif
    533477        NULL
    534478};
    … …  
    542486void cmd_initialize(cmd_info_t *cmd)
    543487{
    544         spinlock_initialize(&cmd->lock, "cmd.lock");
     488        spinlock_initialize(&cmd->lock, "cmd");
    545489        link_initialize(&cmd->link);
    546490}
    … …  
    553497        for (i = 0; basic_commands[i]; i++) {
    554498                cmd_initialize(basic_commands[i]);
    555         }
    556 
    557         for (i = 0; basic_commands[i]; i++) {
    558                 if (!cmd_register(basic_commands[i])) {
    559                         printf("Cannot register command %s\n",
    560                             basic_commands[i]->name);
    561                 }
    562         }
    563 }
     499                if (!cmd_register(basic_commands[i]))
     500                        printf("Cannot register command %s\n", basic_commands[i]->name);
     501        }
     502}
     503
    564504
    565505/** List supported commands.
    … …  
    585525        }
    586526       
    587         unsigned int _len = (unsigned int) len;
    588         if ((_len != len) || (((int) _len) < 0)) {
    589                 printf("Command length overflow\n");
    590                 return 1;
    591         }
    592        
    593527        for (cur = cmd_head.next; cur != &cmd_head; cur = cur->next) {
    594528                cmd_info_t *hlp;
    … …  
    596530               
    597531                spinlock_lock(&hlp->lock);
    598                 printf("%-*s %s\n", _len, hlp->name, hlp->description);
     532                printf("%-*s %s\n", len, hlp->name, hlp->description);
    599533                spinlock_unlock(&hlp->lock);
    600534        }
    … …  
    605539}
    606540
     541
    607542/** Reboot the system.
    608543 *
    … …  
    619554}
    620555
     556
    621557/** Print system uptime information.
    622558 *
    … …  
    630566       
    631567        /* This doesn't have to be very accurate */
    632         sysarg_t sec = uptime->seconds1;
     568        unative_t sec = uptime->seconds1;
    633569       
    634570        printf("Up %" PRIun " days, %" PRIun " hours, %" PRIun " minutes, %" PRIun " seconds\n",
    … …  
    685621        uintptr_t symaddr;
    686622        char *symbol;
    687         sysarg_t (*fnc)(void);
     623        unative_t (*fnc)(void);
    688624        fncptr_t fptr;
    689625        int rc;
    … …  
    698634                printf("Duplicate symbol, be more specific.\n");
    699635        } else if (rc == EOK) {
    700                 ipl_t ipl;
    701 
    702                 ipl = interrupts_disable();
    703                 fnc = (sysarg_t (*)(void)) arch_construct_function(&fptr,
     636                fnc = (unative_t (*)(void)) arch_construct_function(&fptr,
    704637                    (void *) symaddr, (void *) cmd_call0);
    705                 printf("Calling %s() (%p)\n", symbol, (void *) symaddr);
     638                printf("Calling %s() (%p)\n", symbol, symaddr);
    706639                printf("Result: %#" PRIxn "\n", fnc());
    707                 interrupts_restore(ipl);
    708640        } else {
    709641                printf("No symbol information available.\n");
    … …  
    720652         */
    721653       
    722         unsigned int i;
     654        size_t i;
    723655        for (i = 0; i < config.cpu_count; i++) {
    724656                if (!cpus[i].active)
    725657                        continue;
    726658               
    727                 thread_t *thread;
    728                 if ((thread = thread_create((void (*)(void *)) cmd_call0,
    729                     (void *) argv, TASK, THREAD_FLAG_WIRED, "call0", false))) {
    730                         irq_spinlock_lock(&thread->lock, true);
    731                         thread->cpu = &cpus[i];
    732                         irq_spinlock_unlock(&thread->lock, true);
    733                        
     659                thread_t *t;
     660                if ((t = thread_create((void (*)(void *)) cmd_call0, (void *) argv, TASK, THREAD_FLAG_WIRED, "call0", false))) {
     661                        spinlock_lock(&t->lock);
     662                        t->cpu = &cpus[i];
     663                        spinlock_unlock(&t->lock);
    734664                        printf("cpu%u: ", i);
    735                        
    736                         thread_ready(thread);
    737                         thread_join(thread);
    738                         thread_detach(thread);
     665                        thread_ready(t);
     666                        thread_join(t);
     667                        thread_detach(t);
    739668                } else
    740669                        printf("Unable to create thread for cpu%u\n", i);
    … …  
    749678        uintptr_t symaddr;
    750679        char *symbol;
    751         sysarg_t (*fnc)(sysarg_t, ...);
    752         sysarg_t arg1 = argv[1].intval;
     680        unative_t (*fnc)(unative_t, ...);
     681        unative_t arg1 = argv[1].intval;
    753682        fncptr_t fptr;
    754683        int rc;
    … …  
    763692                printf("Duplicate symbol, be more specific.\n");
    764693        } else if (rc == EOK) {
    765                 ipl_t ipl;
    766 
    767                 ipl = interrupts_disable();
    768                 fnc = (sysarg_t (*)(sysarg_t, ...))
    769                     arch_construct_function(&fptr, (void *) symaddr,
    770                     (void *) cmd_call1);
    771                 printf("Calling f(%#" PRIxn "): %p: %s\n", arg1,
    772                     (void *) symaddr, symbol);
     694                fnc = (unative_t (*)(unative_t, ...)) arch_construct_function(&fptr, (void *) symaddr, (void *) cmd_call1);
     695                printf("Calling f(%#" PRIxn "): %p: %s\n", arg1, symaddr, symbol);
    773696                printf("Result: %#" PRIxn "\n", fnc(arg1));
    774                 interrupts_restore(ipl);
    775697        } else {
    776698                printf("No symbol information available.\n");
    … …  
    785707        uintptr_t symaddr;
    786708        char *symbol;
    787         sysarg_t (*fnc)(sysarg_t, sysarg_t, ...);
    788         sysarg_t arg1 = argv[1].intval;
    789         sysarg_t arg2 = argv[2].intval;
     709        unative_t (*fnc)(unative_t, unative_t, ...);
     710        unative_t arg1 = argv[1].intval;
     711        unative_t arg2 = argv[2].intval;
    790712        fncptr_t fptr;
    791713        int rc;
    … …  
    800722                printf("Duplicate symbol, be more specific.\n");
    801723        } else if (rc == EOK) {
    802                 ipl_t ipl;
    803 
    804                 ipl = interrupts_disable();
    805                 fnc = (sysarg_t (*)(sysarg_t, sysarg_t, ...))
    806                     arch_construct_function(&fptr, (void *) symaddr,
    807                     (void *) cmd_call2);
     724                fnc = (unative_t (*)(unative_t, unative_t, ...)) arch_construct_function(&fptr, (void *) symaddr, (void *) cmd_call2);
    808725                printf("Calling f(%#" PRIxn ", %#" PRIxn "): %p: %s\n",
    809                        arg1, arg2, (void *) symaddr, symbol);
     726                       arg1, arg2, symaddr, symbol);
    810727                printf("Result: %#" PRIxn "\n", fnc(arg1, arg2));
    811                 interrupts_restore(ipl);
    812728        } else {
    813729                printf("No symbol information available.\n");
    … …  
    821737        uintptr_t symaddr;
    822738        char *symbol;
    823         sysarg_t (*fnc)(sysarg_t, sysarg_t, sysarg_t, ...);
    824         sysarg_t arg1 = argv[1].intval;
    825         sysarg_t arg2 = argv[2].intval;
    826         sysarg_t arg3 = argv[3].intval;
     739        unative_t (*fnc)(unative_t, unative_t, unative_t, ...);
     740        unative_t arg1 = argv[1].intval;
     741        unative_t arg2 = argv[2].intval;
     742        unative_t arg3 = argv[3].intval;
    827743        fncptr_t fptr;
    828744        int rc;
    … …  
    837753                printf("Duplicate symbol, be more specific.\n");
    838754        } else if (rc == EOK) {
    839                 ipl_t ipl;
    840 
    841                 ipl = interrupts_disable();
    842                 fnc = (sysarg_t (*)(sysarg_t, sysarg_t, sysarg_t, ...))
    843                     arch_construct_function(&fptr, (void *) symaddr,
    844                     (void *) cmd_call3);
    845                 printf("Calling f(%#" PRIxn ",%#" PRIxn ", %#" PRIxn "): %p: %s\n",
    846                        arg1, arg2, arg3, (void *) symaddr, symbol);
     755                fnc = (unative_t (*)(unative_t, unative_t, unative_t, ...)) arch_construct_function(&fptr, (void *) symaddr, (void *) cmd_call3);
     756                printf("Calling f(%#" PRIxn ",%#" PRIxn ", %#" PRIxn "): %p: %s\n",
     757                       arg1, arg2, arg3, symaddr, symbol);
    847758                printf("Result: %#" PRIxn "\n", fnc(arg1, arg2, arg3));
    848                 interrupts_restore(ipl);
    849759        } else {
    850760                printf("No symbol information available.\n");
    … …  
    852762        return 1;
    853763}
     764
    854765
    855766/** Print detailed description of 'describe' command. */
    … …  
    902813        bool pointer = false;
    903814        int rc;
    904        
    905         if (((char *) argv->buffer)[0] == '*') {
     815
     816        if (((char *)argv->buffer)[0] == '*') {
    906817                rc = symtab_addr_lookup((char *) argv->buffer + 1, &addr);
    907818                pointer = true;
    908         } else if (((char *) argv->buffer)[0] >= '0' &&
    909                    ((char *) argv->buffer)[0] <= '9') {
    910                 uint64_t value;
    911                 rc = str_uint64((char *) argv->buffer, NULL, 0, true, &value);
    912                 if (rc == EOK)
    913                         addr = (uintptr_t) value;
    914         } else
     819        } else if (((char *) argv->buffer)[0] >= '0' &&
     820                   ((char *)argv->buffer)[0] <= '9') {
     821                rc = EOK;
     822                addr = atoi((char *)argv->buffer);
     823        } else {
    915824                rc = symtab_addr_lookup((char *) argv->buffer, &addr);
    916        
     825        }
     826
    917827        if (rc == ENOENT)
    918                 printf("Symbol %s not found.\n", (char *) argv->buffer);
    919         else if (rc == EINVAL)
    920                 printf("Invalid address.\n");
     828                printf("Symbol %s not found.\n", argv->buffer);
    921829        else if (rc == EOVERFLOW) {
    922830                symtab_print_search((char *) argv->buffer);
    923                 printf("Duplicate symbol (be more specific) or address overflow.\n");
     831                printf("Duplicate symbol, be more specific.\n");
    924832        } else if (rc == EOK) {
    925833                if (pointer)
    926834                        addr = *(uintptr_t *) addr;
    927                 printf("Writing %#" PRIx32" -> %p\n", arg1, (void *) addr);
     835                printf("Writing %#" PRIx64 " -> %p\n", arg1, addr);
    928836                *(uint32_t *) addr = arg1;
    929         } else
     837        } else {
    930838                printf("No symbol information available.\n");
     839        }
    931840       
    932841        return 1;
    … …  
    939848 * @return Always 1
    940849 */
    941 int cmd_slabs(cmd_arg_t *argv)
    942 {
     850int cmd_slabs(cmd_arg_t * argv) {
    943851        slab_print_list();
    944852        return 1;
    945853}
    946854
    947 /** Command for dumping sysinfo
     855
     856/** Command for listings Thread information
    948857 *
    949858 * @param argv Ignores
    … …  
    951860 * @return Always 1
    952861 */
    953 int cmd_sysinfo(cmd_arg_t *argv)
    954 {
    955         sysinfo_dump(NULL);
    956         return 1;
    957 }
    958 
    959 /** Command for listing thread information
     862int cmd_threads(cmd_arg_t * argv) {
     863        thread_print_list();
     864        return 1;
     865}
     866
     867/** Command for listings Task information
     868 *
     869 * @param argv Ignores
     870 *
     871 * @return Always 1
     872 */
     873int cmd_tasks(cmd_arg_t * argv) {
     874        task_print_list();
     875        return 1;
     876}
     877
     878/** Command for listings Thread information
     879 *
     880 * @param argv Ignores
     881 *
     882 * @return Always 1
     883 */
     884int cmd_sched(cmd_arg_t * argv) {
     885        sched_print_list();
     886        return 1;
     887}
     888
     889/** Command for listing memory zones
    960890 *
    961891 * @param argv Ignored
    962892 *
    963  * @return Always 1
    964  */
    965 int cmd_threads(cmd_arg_t *argv)
    966 {
    967         if (str_cmp(flag_buf, "-a") == 0)
    968                 thread_print_list(true);
    969         else if (str_cmp(flag_buf, "") == 0)
    970                 thread_print_list(false);
    971         else
    972                 printf("Unknown argument \"%s\".\n", flag_buf);
    973        
    974         return 1;
    975 }
    976 
    977 /** Command for listing task information
    978  *
    979  * @param argv Ignored
    980  *
    981  * @return Always 1
    982  */
    983 int cmd_tasks(cmd_arg_t *argv)
    984 {
    985         if (str_cmp(flag_buf, "-a") == 0)
    986                 task_print_list(true);
    987         else if (str_cmp(flag_buf, "") == 0)
    988                 task_print_list(false);
    989         else
    990                 printf("Unknown argument \"%s\".\n", flag_buf);
    991        
    992         return 1;
    993 }
    994 
    995 #ifdef CONFIG_UDEBUG
    996 
    997 /** Command for printing thread stack trace
     893 * return Always 1
     894 */
     895int cmd_zones(cmd_arg_t * argv) {
     896        zone_print_list();
     897        return 1;
     898}
     899
     900/** Command for memory zone details
    998901 *
    999902 * @param argv Integer argument from cmdline expected
    1000903 *
    1001904 * return Always 1
    1002  *
    1003  */
    1004 int cmd_btrace(cmd_arg_t *argv)
    1005 {
    1006         thread_stack_trace(argv[0].intval);
    1007         return 1;
    1008 }
    1009 
    1010 #endif /* CONFIG_UDEBUG */
    1011 
    1012 /** Command for printing scheduler information
    1013  *
    1014  * @param argv Ignores
    1015  *
    1016  * @return Always 1
    1017  */
    1018 int cmd_sched(cmd_arg_t *argv)
    1019 {
    1020         sched_print_list();
    1021         return 1;
    1022 }
    1023 
    1024 /** Command for listing memory zones
    1025  *
    1026  * @param argv Ignored
     905 */
     906int cmd_zone(cmd_arg_t * argv) {
     907        zone_print_one(argv[0].intval);
     908        return 1;
     909}
     910
     911/** Command for printing task ipc details
     912 *
     913 * @param argv Integer argument from cmdline expected
    1027914 *
    1028915 * return Always 1
    1029916 */
    1030 int cmd_zones(cmd_arg_t *argv)
    1031 {
    1032         zones_print_list();
    1033         return 1;
    1034 }
    1035 
    1036 /** Command for memory zone details
    1037  *
    1038  * @param argv Integer argument from cmdline expected
    1039  *
    1040  * return Always 1
    1041  */
    1042 int cmd_zone(cmd_arg_t *argv)
    1043 {
    1044         zone_print_one(argv[0].intval);
    1045         return 1;
    1046 }
    1047 
    1048 /** Command for printing task IPC details
    1049  *
    1050  * @param argv Integer argument from cmdline expected
    1051  *
    1052  * return Always 1
    1053  */
    1054 int cmd_ipc(cmd_arg_t *argv)
    1055 {
     917int cmd_ipc(cmd_arg_t * argv) {
    1056918        ipc_print_task(argv[0].intval);
    1057919        return 1;
    1058920}
    1059921
    1060 /** Command for killing a task
    1061  *
    1062  * @param argv Integer argument from cmdline expected
    1063  *
    1064  * return 0 on failure, 1 on success.
    1065  */
    1066 int cmd_kill(cmd_arg_t *argv)
    1067 {
    1068         if (task_kill(argv[0].intval) != EOK)
    1069                 return 0;
    1070 
    1071         return 1;
    1072 }
    1073922
    1074923/** Command for listing processors.
    … …  
    1114963
    1115964#ifdef CONFIG_TEST
     965/** Command for printing kernel tests list.
     966 *
     967 * @param argv Ignored.
     968 *
     969 * return Always 1.
     970 */
     971int cmd_tests(cmd_arg_t *argv)
     972{
     973        size_t len = 0;
     974        test_t *test;
     975        for (test = tests; test->name != NULL; test++) {
     976                if (str_length(test->name) > len)
     977                        len = str_length(test->name);
     978        }
     979       
     980        for (test = tests; test->name != NULL; test++)
     981                printf("%-*s %s%s\n", len, test->name, test->desc, (test->safe ? "" : " (unsafe)"));
     982       
     983        printf("%-*s Run all safe tests\n", len, "*");
     984        return 1;
     985}
     986
    1116987static bool run_test(const test_t *test)
    1117988{
    … …  
    1120991        /* Update and read thread accounting
    1121992           for benchmarking */
    1122         irq_spinlock_lock(&TASK->lock, true);
    1123         uint64_t ucycles0, kcycles0;
    1124         task_get_accounting(TASK, &ucycles0, &kcycles0);
    1125         irq_spinlock_unlock(&TASK->lock, true);
     993        ipl_t ipl = interrupts_disable();
     994        spinlock_lock(&TASK->lock);
     995        uint64_t t0 = task_get_accounting(TASK);
     996        spinlock_unlock(&TASK->lock);
     997        interrupts_restore(ipl);
    1126998       
    1127999        /* Execute the test */
    11281000        test_quiet = false;
    1129         const char *ret = test->entry();
     1001        char *ret = test->entry();
    11301002       
    11311003        /* Update and read thread accounting */
    1132         uint64_t ucycles1, kcycles1;
    1133         irq_spinlock_lock(&TASK->lock, true);
    1134         task_get_accounting(TASK, &ucycles1, &kcycles1);
    1135         irq_spinlock_unlock(&TASK->lock, true);
    1136        
    1137         uint64_t ucycles, kcycles;
    1138         char usuffix, ksuffix;
    1139         order_suffix(ucycles1 - ucycles0, &ucycles, &usuffix);
    1140         order_suffix(kcycles1 - kcycles0, &kcycles, &ksuffix);
    1141        
    1142         printf("Time: %" PRIu64 "%c user cycles, %" PRIu64 "%c kernel cycles\n",
    1143             ucycles, usuffix, kcycles, ksuffix);
     1004        ipl = interrupts_disable();
     1005        spinlock_lock(&TASK->lock);
     1006        uint64_t dt = task_get_accounting(TASK) - t0;
     1007        spinlock_unlock(&TASK->lock);
     1008        interrupts_restore(ipl);
     1009       
     1010        uint64_t cycles;
     1011        char suffix;
     1012        order(dt, &cycles, &suffix);
     1013               
     1014        printf("Time: %" PRIu64 "%c cycles\n", cycles, suffix);
    11441015       
    11451016        if (ret == NULL) {
    … …  
    11471018                return true;
    11481019        }
    1149        
     1020
    11501021        printf("%s\n", ret);
    11511022        return false;
    … …  
    11561027        uint32_t i;
    11571028        bool ret = true;
    1158         uint64_t ucycles, kcycles;
    1159         char usuffix, ksuffix;
     1029        uint64_t cycles;
     1030        char suffix;
    11601031       
    11611032        if (cnt < 1)
    … …  
    11731044                /* Update and read thread accounting
    11741045                   for benchmarking */
    1175                 irq_spinlock_lock(&TASK->lock, true);
    1176                 uint64_t ucycles0, kcycles0;
    1177                 task_get_accounting(TASK, &ucycles0, &kcycles0);
    1178                 irq_spinlock_unlock(&TASK->lock, true);
     1046                ipl_t ipl = interrupts_disable();
     1047                spinlock_lock(&TASK->lock);
     1048                uint64_t t0 = task_get_accounting(TASK);
     1049                spinlock_unlock(&TASK->lock);
     1050                interrupts_restore(ipl);
    11791051               
    11801052                /* Execute the test */
    11811053                test_quiet = true;
    1182                 const char *ret = test->entry();
     1054                char * ret = test->entry();
    11831055               
    11841056                /* Update and read thread accounting */
    1185                 irq_spinlock_lock(&TASK->lock, true);
    1186                 uint64_t ucycles1, kcycles1;
    1187                 task_get_accounting(TASK, &ucycles1, &kcycles1);
    1188                 irq_spinlock_unlock(&TASK->lock, true);
     1057                ipl = interrupts_disable();
     1058                spinlock_lock(&TASK->lock);
     1059                uint64_t dt = task_get_accounting(TASK) - t0;
     1060                spinlock_unlock(&TASK->lock);
     1061                interrupts_restore(ipl);
    11891062               
    11901063                if (ret != NULL) {
    … …  
    11941067                }
    11951068               
    1196                 data[i] = ucycles1 - ucycles0 + kcycles1 - kcycles0;
    1197                 order_suffix(ucycles1 - ucycles0, &ucycles, &usuffix);
    1198                 order_suffix(kcycles1 - kcycles0, &kcycles, &ksuffix);
    1199                 printf("OK (%" PRIu64 "%c user cycles, %" PRIu64 "%c kernel cycles)\n",
    1200                     ucycles, usuffix, kcycles, ksuffix);
     1069                data[i] = dt;
     1070                order(dt, &cycles, &suffix);
     1071                printf("OK (%" PRIu64 "%c cycles)\n", cycles, suffix);
    12011072        }
    12021073       
    … …  
    12101081                }
    12111082               
    1212                 order_suffix(sum / (uint64_t) cnt, &ucycles, &usuffix);
    1213                 printf("Average\t\t%" PRIu64 "%c\n", ucycles, usuffix);
     1083                order(sum / (uint64_t) cnt, &cycles, &suffix);
     1084                printf("Average\t\t%" PRIu64 "%c\n", cycles, suffix);
    12141085        }
    12151086       
    … …  
    12191090}
    12201091
    1221 static void list_tests(void)
    1222 {
    1223         size_t len = 0;
    1224         test_t *test;
    1225        
    1226         for (test = tests; test->name != NULL; test++) {
    1227                 if (str_length(test->name) > len)
    1228                         len = str_length(test->name);
    1229         }
    1230        
    1231         unsigned int _len = (unsigned int) len;
    1232         if ((_len != len) || (((int) _len) < 0)) {
    1233                 printf("Command length overflow\n");
    1234                 return;
    1235         }
    1236        
    1237         for (test = tests; test->name != NULL; test++)
    1238                 printf("%-*s %s%s\n", _len, test->name, test->desc,
    1239                     (test->safe ? "" : " (unsafe)"));
    1240        
    1241         printf("%-*s Run all safe tests\n", _len, "*");
    1242 }
    1243 
    1244 /** Command for listing and running kernel tests
     1092/** Command for returning kernel tests
    12451093 *
    12461094 * @param argv Argument vector.
    12471095 *
    12481096 * return Always 1.
    1249  *
    12501097 */
    12511098int cmd_test(cmd_arg_t *argv)
    … …  
    12611108                        }
    12621109                }
    1263         } else if (str_cmp((char *) argv->buffer, "") != 0) {
     1110        } else {
    12641111                bool fnd = false;
    12651112               
    … …  
    12741121                if (!fnd)
    12751122                        printf("Unknown test\n");
    1276         } else
    1277                 list_tests();
     1123        }
    12781124       
    12791125        return 1;
Note: See TracChangeset for help on using the changeset viewer.