Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r851f33a r4ce914d4  
    108108
    109109#ifdef CONFIG_TEST
     110static int cmd_tests(cmd_arg_t *argv);
     111static cmd_info_t tests_info = {
     112        .name = "tests",
     113        .description = "Print available kernel tests.",
     114        .func = cmd_tests,
     115        .argc = 0
     116};
     117
    110118static char test_buf[MAX_CMDLINE + 1];
    111119static int cmd_test(cmd_arg_t *argv);
    112120static cmd_arg_t test_argv[] = {
    113121        {
    114                 .type = ARG_TYPE_STRING_OPTIONAL,
     122                .type = ARG_TYPE_STRING,
    115123                .buffer = test_buf,
    116124                .len = sizeof(test_buf)
    … …  
    119127static cmd_info_t test_info = {
    120128        .name = "test",
    121         .description = "Print list of kernel tests or run a test.",
     129        .description = "Run kernel test.",
    122130        .func = cmd_test,
    123131        .argc = 1,
    … …  
    199207};
    200208
    201 /* Data and methods for 'call0' and 'mcall0' command. */
     209/* Data and methods for 'call0' command. */
    202210static char call0_buf[MAX_CMDLINE + 1];
    203211static char carg1_buf[MAX_CMDLINE + 1];
    … …  
    347355};
    348356
    349 static char flag_buf[MAX_CMDLINE + 1];
    350 
    351357static int cmd_threads(cmd_arg_t *argv);
    352 static cmd_arg_t threads_argv = {
    353         .type = ARG_TYPE_STRING_OPTIONAL,
    354         .buffer = flag_buf,
    355         .len = sizeof(flag_buf)
    356 };
    357358static cmd_info_t threads_info = {
    358359        .name = "threads",
    359         .description = "List all threads (use -a for additional information).",
     360        .description = "List all threads.",
    360361        .func = cmd_threads,
    361         .argc = 1,
    362         .argv = &threads_argv
     362        .argc = 0
    363363};
    364364
    365365static int cmd_tasks(cmd_arg_t *argv);
    366 static cmd_arg_t tasks_argv = {
    367         .type = ARG_TYPE_STRING_OPTIONAL,
    368         .buffer = flag_buf,
    369         .len = sizeof(flag_buf)
    370 };
    371366static cmd_info_t tasks_info = {
    372367        .name = "tasks",
    373         .description = "List all tasks (use -a for additional information).",
     368        .description = "List all tasks.",
    374369        .func = cmd_tasks,
    375         .argc = 1,
    376         .argv = &tasks_argv
     370        .argc = 0
    377371};
    378372
    … …  
    501495        &zone_info,
    502496#ifdef CONFIG_TEST
     497        &tests_info,
    503498        &test_info,
    504499        &bench_info,
    … …  
    515510void cmd_initialize(cmd_info_t *cmd)
    516511{
    517         spinlock_initialize(&cmd->lock, "cmd.lock");
     512        spinlock_initialize(&cmd->lock, "cmd");
    518513        link_initialize(&cmd->link);
    519514}
    … …  
    663658                printf("Duplicate symbol, be more specific.\n");
    664659        } else if (rc == EOK) {
    665                 ipl_t ipl;
    666 
    667                 ipl = interrupts_disable();
    668660                fnc = (unative_t (*)(void)) arch_construct_function(&fptr,
    669661                    (void *) symaddr, (void *) cmd_call0);
    670662                printf("Calling %s() (%p)\n", symbol, symaddr);
    671663                printf("Result: %#" PRIxn "\n", fnc());
    672                 interrupts_restore(ipl);
    673664        } else {
    674665                printf("No symbol information available.\n");
    … …  
    690681                        continue;
    691682               
    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);
     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);
    704692                } else
    705                         printf("Unable to create thread for cpu%" PRIs "\n", i);
     693                        printf("Unable to create thread for cpu%u\n", i);
    706694        }
    707695       
    … …  
    728716                printf("Duplicate symbol, be more specific.\n");
    729717        } else if (rc == EOK) {
    730                 ipl_t ipl;
    731 
    732                 ipl = interrupts_disable();
    733718                fnc = (unative_t (*)(unative_t, ...)) arch_construct_function(&fptr, (void *) symaddr, (void *) cmd_call1);
    734719                printf("Calling f(%#" PRIxn "): %p: %s\n", arg1, symaddr, symbol);
    735720                printf("Result: %#" PRIxn "\n", fnc(arg1));
    736                 interrupts_restore(ipl);
    737721        } else {
    738722                printf("No symbol information available.\n");
    … …  
    762746                printf("Duplicate symbol, be more specific.\n");
    763747        } else if (rc == EOK) {
    764                 ipl_t ipl;
    765 
    766                 ipl = interrupts_disable();
    767748                fnc = (unative_t (*)(unative_t, unative_t, ...)) arch_construct_function(&fptr, (void *) symaddr, (void *) cmd_call2);
    768749                printf("Calling f(%#" PRIxn ", %#" PRIxn "): %p: %s\n",
    769750                       arg1, arg2, symaddr, symbol);
    770751                printf("Result: %#" PRIxn "\n", fnc(arg1, arg2));
    771                 interrupts_restore(ipl);
    772752        } else {
    773753                printf("No symbol information available.\n");
    … …  
    797777                printf("Duplicate symbol, be more specific.\n");
    798778        } else if (rc == EOK) {
    799                 ipl_t ipl;
    800 
    801                 ipl = interrupts_disable();
    802779                fnc = (unative_t (*)(unative_t, unative_t, unative_t, ...)) arch_construct_function(&fptr, (void *) symaddr, (void *) cmd_call3);
    803780                printf("Calling f(%#" PRIxn ",%#" PRIxn ", %#" PRIxn "): %p: %s\n",
    804781                       arg1, arg2, arg3, symaddr, symbol);
    805782                printf("Result: %#" PRIxn "\n", fnc(arg1, arg2, arg3));
    806                 interrupts_restore(ipl);
    807783        } else {
    808784                printf("No symbol information available.\n");
    … …  
    919895/** Command for listings Thread information
    920896 *
    921  * @param argv Ignored
     897 * @param argv Ignores
    922898 *
    923899 * @return Always 1
    924900 */
    925 int 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        
     901int cmd_threads(cmd_arg_t * argv)
     902{
     903        thread_print_list();
    934904        return 1;
    935905}
    … …  
    937907/** Command for listings Task information
    938908 *
    939  * @param argv Ignored
     909 * @param argv Ignores
    940910 *
    941911 * @return Always 1
    942912 */
    943 int 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        
     913int cmd_tasks(cmd_arg_t * argv)
     914{
     915        task_print_list();
    952916        return 1;
    953917}
    … …  
    10571021
    10581022#ifdef CONFIG_TEST
     1023/** Command for printing kernel tests list.
     1024 *
     1025 * @param argv Ignored.
     1026 *
     1027 * return Always 1.
     1028 */
     1029int 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
    10591045static bool run_test(const test_t *test)
    10601046{
    … …  
    10631049        /* Update and read thread accounting
    10641050           for benchmarking */
    1065         irq_spinlock_lock(&TASK->lock, true);
     1051        ipl_t ipl = interrupts_disable();
     1052        spinlock_lock(&TASK->lock);
    10661053        uint64_t ucycles0, kcycles0;
    10671054        task_get_accounting(TASK, &ucycles0, &kcycles0);
    1068         irq_spinlock_unlock(&TASK->lock, true);
     1055        spinlock_unlock(&TASK->lock);
     1056        interrupts_restore(ipl);
    10691057       
    10701058        /* Execute the test */
    … …  
    10731061       
    10741062        /* Update and read thread accounting */
    1075         uint64_t ucycles1, kcycles1;
    1076         irq_spinlock_lock(&TASK->lock, true);
     1063        uint64_t ucycles1, kcycles1;
     1064        ipl = interrupts_disable();
     1065        spinlock_lock(&TASK->lock);
    10771066        task_get_accounting(TASK, &ucycles1, &kcycles1);
    1078         irq_spinlock_unlock(&TASK->lock, true);
     1067        spinlock_unlock(&TASK->lock);
     1068        interrupts_restore(ipl);
    10791069       
    10801070        uint64_t ucycles, kcycles;
    … …  
    10821072        order_suffix(ucycles1 - ucycles0, &ucycles, &usuffix);
    10831073        order_suffix(kcycles1 - kcycles0, &kcycles, &ksuffix);
    1084        
     1074               
    10851075        printf("Time: %" PRIu64 "%c user cycles, %" PRIu64 "%c kernel cycles\n",
    1086             ucycles, usuffix, kcycles, ksuffix);
     1076                        ucycles, usuffix, kcycles, ksuffix);
    10871077       
    10881078        if (ret == NULL) {
    … …  
    10901080                return true;
    10911081        }
    1092        
     1082
    10931083        printf("%s\n", ret);
    10941084        return false;
    … …  
    11161106                /* Update and read thread accounting
    11171107                   for benchmarking */
    1118                 irq_spinlock_lock(&TASK->lock, true);
     1108                ipl_t ipl = interrupts_disable();
     1109                spinlock_lock(&TASK->lock);
    11191110                uint64_t ucycles0, kcycles0;
    11201111                task_get_accounting(TASK, &ucycles0, &kcycles0);
    1121                 irq_spinlock_unlock(&TASK->lock, true);
     1112                spinlock_unlock(&TASK->lock);
     1113                interrupts_restore(ipl);
    11221114               
    11231115                /* Execute the test */
    … …  
    11261118               
    11271119                /* Update and read thread accounting */
    1128                 irq_spinlock_lock(&TASK->lock, true);
     1120                ipl = interrupts_disable();
     1121                spinlock_lock(&TASK->lock);
    11291122                uint64_t ucycles1, kcycles1;
    11301123                task_get_accounting(TASK, &ucycles1, &kcycles1);
    1131                 irq_spinlock_unlock(&TASK->lock, true);
    1132                
     1124                spinlock_unlock(&TASK->lock);
     1125                interrupts_restore(ipl);
     1126
    11331127                if (ret != NULL) {
    11341128                        printf("%s\n", ret);
    … …  
    11411135                order_suffix(kcycles1 - kcycles0, &kcycles, &ksuffix);
    11421136                printf("OK (%" PRIu64 "%c user cycles, %" PRIu64 "%c kernel cycles)\n",
    1143                     ucycles, usuffix, kcycles, ksuffix);
     1137                                ucycles, usuffix, kcycles, ksuffix);
    11441138        }
    11451139       
    … …  
    11621156}
    11631157
    1164 static 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
     1158/** Command for returning kernel tests
    11811159 *
    11821160 * @param argv Argument vector.
    11831161 *
    11841162 * return Always 1.
    1185  *
    11861163 */
    11871164int cmd_test(cmd_arg_t *argv)
    … …  
    11971174                        }
    11981175                }
    1199         } else if (str_cmp((char *) argv->buffer, "") != 0) {
     1176        } else {
    12001177                bool fnd = false;
    12011178               
    … …  
    12101187                if (!fnd)
    12111188                        printf("Unknown test\n");
    1212         } else
    1213                 list_tests();
     1189        }
    12141190       
    12151191        return 1;
Note: See TracChangeset for help on using the changeset viewer.