Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r4ce914d4 r851f33a  
    108108
    109109#ifdef CONFIG_TEST
    110 static int cmd_tests(cmd_arg_t *argv);
    111 static cmd_info_t tests_info = {
    112         .name = "tests",
    113         .description = "Print available kernel tests.",
    114         .func = cmd_tests,
    115         .argc = 0
    116 };
    117 
    118110static char test_buf[MAX_CMDLINE + 1];
    119111static int cmd_test(cmd_arg_t *argv);
    120112static cmd_arg_t test_argv[] = {
    121113        {
    122                 .type = ARG_TYPE_STRING,
     114                .type = ARG_TYPE_STRING_OPTIONAL,
    123115                .buffer = test_buf,
    124116                .len = sizeof(test_buf)
    … …  
    127119static cmd_info_t test_info = {
    128120        .name = "test",
    129         .description = "Run kernel test.",
     121        .description = "Print list of kernel tests or run a test.",
    130122        .func = cmd_test,
    131123        .argc = 1,
    … …  
    207199};
    208200
    209 /* Data and methods for 'call0' command. */
     201/* Data and methods for 'call0' and 'mcall0' command. */
    210202static char call0_buf[MAX_CMDLINE + 1];
    211203static char carg1_buf[MAX_CMDLINE + 1];
    … …  
    355347};
    356348
     349static char flag_buf[MAX_CMDLINE + 1];
     350
    357351static int cmd_threads(cmd_arg_t *argv);
     352static cmd_arg_t threads_argv = {
     353        .type = ARG_TYPE_STRING_OPTIONAL,
     354        .buffer = flag_buf,
     355        .len = sizeof(flag_buf)
     356};
    358357static cmd_info_t threads_info = {
    359358        .name = "threads",
    360         .description = "List all threads.",
     359        .description = "List all threads (use -a for additional information).",
    361360        .func = cmd_threads,
    362         .argc = 0
     361        .argc = 1,
     362        .argv = &threads_argv
    363363};
    364364
    365365static int cmd_tasks(cmd_arg_t *argv);
     366static cmd_arg_t tasks_argv = {
     367        .type = ARG_TYPE_STRING_OPTIONAL,
     368        .buffer = flag_buf,
     369        .len = sizeof(flag_buf)
     370};
    366371static cmd_info_t tasks_info = {
    367372        .name = "tasks",
    368         .description = "List all tasks.",
     373        .description = "List all tasks (use -a for additional information).",
    369374        .func = cmd_tasks,
    370         .argc = 0
     375        .argc = 1,
     376        .argv = &tasks_argv
    371377};
    372378
    … …  
    495501        &zone_info,
    496502#ifdef CONFIG_TEST
    497         &tests_info,
    498503        &test_info,
    499504        &bench_info,
    … …  
    510515void cmd_initialize(cmd_info_t *cmd)
    511516{
    512         spinlock_initialize(&cmd->lock, "cmd");
     517        spinlock_initialize(&cmd->lock, "cmd.lock");
    513518        link_initialize(&cmd->link);
    514519}
    … …  
    658663                printf("Duplicate symbol, be more specific.\n");
    659664        } else if (rc == EOK) {
     665                ipl_t ipl;
     666
     667                ipl = interrupts_disable();
    660668                fnc = (unative_t (*)(void)) arch_construct_function(&fptr,
    661669                    (void *) symaddr, (void *) cmd_call0);
    662670                printf("Calling %s() (%p)\n", symbol, symaddr);
    663671                printf("Result: %#" PRIxn "\n", fnc());
     672                interrupts_restore(ipl);
    664673        } else {
    665674                printf("No symbol information available.\n");
    … …  
    681690                        continue;
    682691               
    683                 thread_t *t;
    684                 if ((t = thread_create((void (*)(void *)) cmd_call0, (void *) argv, TASK, THREAD_FLAG_WIRED, "call0", false))) {
    685                         spinlock_lock(&t->lock);
    686                         t->cpu = &cpus[i];
    687                         spinlock_unlock(&t->lock);
    688                         printf("cpu%u: ", i);
    689                         thread_ready(t);
    690                         thread_join(t);
    691                         thread_detach(t);
     692                thread_t *thread;
     693                if ((thread = thread_create((void (*)(void *)) cmd_call0,
     694                    (void *) argv, TASK, THREAD_FLAG_WIRED, "call0", false))) {
     695                        irq_spinlock_lock(&thread->lock, true);
     696                        thread->cpu = &cpus[i];
     697                        irq_spinlock_unlock(&thread->lock, true);
     698                       
     699                        printf("cpu%" PRIs ": ", i);
     700                       
     701                        thread_ready(thread);
     702                        thread_join(thread);
     703                        thread_detach(thread);
    692704                } else
    693                         printf("Unable to create thread for cpu%u\n", i);
     705                        printf("Unable to create thread for cpu%" PRIs "\n", i);
    694706        }
    695707       
    … …  
    716728                printf("Duplicate symbol, be more specific.\n");
    717729        } else if (rc == EOK) {
     730                ipl_t ipl;
     731
     732                ipl = interrupts_disable();
    718733                fnc = (unative_t (*)(unative_t, ...)) arch_construct_function(&fptr, (void *) symaddr, (void *) cmd_call1);
    719734                printf("Calling f(%#" PRIxn "): %p: %s\n", arg1, symaddr, symbol);
    720735                printf("Result: %#" PRIxn "\n", fnc(arg1));
     736                interrupts_restore(ipl);
    721737        } else {
    722738                printf("No symbol information available.\n");
    … …  
    746762                printf("Duplicate symbol, be more specific.\n");
    747763        } else if (rc == EOK) {
     764                ipl_t ipl;
     765
     766                ipl = interrupts_disable();
    748767                fnc = (unative_t (*)(unative_t, unative_t, ...)) arch_construct_function(&fptr, (void *) symaddr, (void *) cmd_call2);
    749768                printf("Calling f(%#" PRIxn ", %#" PRIxn "): %p: %s\n",
    750769                       arg1, arg2, symaddr, symbol);
    751770                printf("Result: %#" PRIxn "\n", fnc(arg1, arg2));
     771                interrupts_restore(ipl);
    752772        } else {
    753773                printf("No symbol information available.\n");
    … …  
    777797                printf("Duplicate symbol, be more specific.\n");
    778798        } else if (rc == EOK) {
     799                ipl_t ipl;
     800
     801                ipl = interrupts_disable();
    779802                fnc = (unative_t (*)(unative_t, unative_t, unative_t, ...)) arch_construct_function(&fptr, (void *) symaddr, (void *) cmd_call3);
    780803                printf("Calling f(%#" PRIxn ",%#" PRIxn ", %#" PRIxn "): %p: %s\n",
    781804                       arg1, arg2, arg3, symaddr, symbol);
    782805                printf("Result: %#" PRIxn "\n", fnc(arg1, arg2, arg3));
     806                interrupts_restore(ipl);
    783807        } else {
    784808                printf("No symbol information available.\n");
    … …  
    895919/** Command for listings Thread information
    896920 *
    897  * @param argv Ignores
     921 * @param argv Ignored
    898922 *
    899923 * @return Always 1
    900924 */
    901 int cmd_threads(cmd_arg_t * argv)
    902 {
    903         thread_print_list();
     925int cmd_threads(cmd_arg_t *argv)
     926{
     927        if (str_cmp(flag_buf, "-a") == 0)
     928                thread_print_list(true);
     929        else if (str_cmp(flag_buf, "") == 0)
     930                thread_print_list(false);
     931        else
     932                printf("Unknown argument \"%s\".\n", flag_buf);
     933       
    904934        return 1;
    905935}
    … …  
    907937/** Command for listings Task information
    908938 *
    909  * @param argv Ignores
     939 * @param argv Ignored
    910940 *
    911941 * @return Always 1
    912942 */
    913 int cmd_tasks(cmd_arg_t * argv)
    914 {
    915         task_print_list();
     943int cmd_tasks(cmd_arg_t *argv)
     944{
     945        if (str_cmp(flag_buf, "-a") == 0)
     946                task_print_list(true);
     947        else if (str_cmp(flag_buf, "") == 0)
     948                task_print_list(false);
     949        else
     950                printf("Unknown argument \"%s\".\n", flag_buf);
     951       
    916952        return 1;
    917953}
    … …  
    10211057
    10221058#ifdef CONFIG_TEST
    1023 /** Command for printing kernel tests list.
    1024  *
    1025  * @param argv Ignored.
    1026  *
    1027  * return Always 1.
    1028  */
    1029 int cmd_tests(cmd_arg_t *argv)
    1030 {
    1031         size_t len = 0;
    1032         test_t *test;
    1033         for (test = tests; test->name != NULL; test++) {
    1034                 if (str_length(test->name) > len)
    1035                         len = str_length(test->name);
    1036         }
    1037        
    1038         for (test = tests; test->name != NULL; test++)
    1039                 printf("%-*s %s%s\n", len, test->name, test->desc, (test->safe ? "" : " (unsafe)"));
    1040        
    1041         printf("%-*s Run all safe tests\n", len, "*");
    1042         return 1;
    1043 }
    1044 
    10451059static bool run_test(const test_t *test)
    10461060{
    … …  
    10491063        /* Update and read thread accounting
    10501064           for benchmarking */
    1051         ipl_t ipl = interrupts_disable();
    1052         spinlock_lock(&TASK->lock);
     1065        irq_spinlock_lock(&TASK->lock, true);
    10531066        uint64_t ucycles0, kcycles0;
    10541067        task_get_accounting(TASK, &ucycles0, &kcycles0);
    1055         spinlock_unlock(&TASK->lock);
    1056         interrupts_restore(ipl);
     1068        irq_spinlock_unlock(&TASK->lock, true);
    10571069       
    10581070        /* Execute the test */
    … …  
    10611073       
    10621074        /* Update and read thread accounting */
    1063         uint64_t ucycles1, kcycles1;
    1064         ipl = interrupts_disable();
    1065         spinlock_lock(&TASK->lock);
     1075        uint64_t ucycles1, kcycles1;
     1076        irq_spinlock_lock(&TASK->lock, true);
    10661077        task_get_accounting(TASK, &ucycles1, &kcycles1);
    1067         spinlock_unlock(&TASK->lock);
    1068         interrupts_restore(ipl);
     1078        irq_spinlock_unlock(&TASK->lock, true);
    10691079       
    10701080        uint64_t ucycles, kcycles;
    … …  
    10721082        order_suffix(ucycles1 - ucycles0, &ucycles, &usuffix);
    10731083        order_suffix(kcycles1 - kcycles0, &kcycles, &ksuffix);
    1074                
     1084       
    10751085        printf("Time: %" PRIu64 "%c user cycles, %" PRIu64 "%c kernel cycles\n",
    1076                         ucycles, usuffix, kcycles, ksuffix);
     1086            ucycles, usuffix, kcycles, ksuffix);
    10771087       
    10781088        if (ret == NULL) {
    … …  
    10801090                return true;
    10811091        }
    1082 
     1092       
    10831093        printf("%s\n", ret);
    10841094        return false;
    … …  
    11061116                /* Update and read thread accounting
    11071117                   for benchmarking */
    1108                 ipl_t ipl = interrupts_disable();
    1109                 spinlock_lock(&TASK->lock);
     1118                irq_spinlock_lock(&TASK->lock, true);
    11101119                uint64_t ucycles0, kcycles0;
    11111120                task_get_accounting(TASK, &ucycles0, &kcycles0);
    1112                 spinlock_unlock(&TASK->lock);
    1113                 interrupts_restore(ipl);
     1121                irq_spinlock_unlock(&TASK->lock, true);
    11141122               
    11151123                /* Execute the test */
    … …  
    11181126               
    11191127                /* Update and read thread accounting */
    1120                 ipl = interrupts_disable();
    1121                 spinlock_lock(&TASK->lock);
     1128                irq_spinlock_lock(&TASK->lock, true);
    11221129                uint64_t ucycles1, kcycles1;
    11231130                task_get_accounting(TASK, &ucycles1, &kcycles1);
    1124                 spinlock_unlock(&TASK->lock);
    1125                 interrupts_restore(ipl);
    1126 
     1131                irq_spinlock_unlock(&TASK->lock, true);
     1132               
    11271133                if (ret != NULL) {
    11281134                        printf("%s\n", ret);
    … …  
    11351141                order_suffix(kcycles1 - kcycles0, &kcycles, &ksuffix);
    11361142                printf("OK (%" PRIu64 "%c user cycles, %" PRIu64 "%c kernel cycles)\n",
    1137                                 ucycles, usuffix, kcycles, ksuffix);
     1143                    ucycles, usuffix, kcycles, ksuffix);
    11381144        }
    11391145       
    … …  
    11561162}
    11571163
    1158 /** Command for returning kernel tests
     1164static void list_tests(void)
     1165{
     1166        size_t len = 0;
     1167        test_t *test;
     1168       
     1169        for (test = tests; test->name != NULL; test++) {
     1170                if (str_length(test->name) > len)
     1171                        len = str_length(test->name);
     1172        }
     1173       
     1174        for (test = tests; test->name != NULL; test++)
     1175                printf("%-*s %s%s\n", len, test->name, test->desc, (test->safe ? "" : " (unsafe)"));
     1176       
     1177        printf("%-*s Run all safe tests\n", len, "*");
     1178}
     1179
     1180/** Command for listing and running kernel tests
    11591181 *
    11601182 * @param argv Argument vector.
    11611183 *
    11621184 * return Always 1.
     1185 *
    11631186 */
    11641187int cmd_test(cmd_arg_t *argv)
    … …  
    11741197                        }
    11751198                }
    1176         } else {
     1199        } else if (str_cmp((char *) argv->buffer, "") != 0) {
    11771200                bool fnd = false;
    11781201               
    … …  
    11871210                if (!fnd)
    11881211                        printf("Unknown test\n");
    1189         }
     1212        } else
     1213                list_tests();
    11901214       
    11911215        return 1;
Note: See TracChangeset for help on using the changeset viewer.