Changeset 89c57b6 in mainline for kernel/generic/src/console/cmd.c


Ignore:
Timestamp:
2011-04-13T14:45:41Z (13 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
88634420
Parents:
cefb126 (diff), 17279ead (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge mainline changes.

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    rcefb126 r89c57b6  
    7878static cmd_info_t help_info = {
    7979        .name = "help",
    80         .description = "List of supported commands.",
     80        .description = "List supported commands.",
    8181        .func = cmd_help,
    8282        .argc = 0
    8383};
    8484
     85/* Data and methods for 'reboot' command. */
    8586static int cmd_reboot(cmd_arg_t *argv);
    8687static cmd_info_t reboot_info = {
    8788        .name = "reboot",
    88         .description = "Reboot.",
     89        .description = "Reboot system.",
    8990        .func = cmd_reboot,
    9091        .argc = 0
    9192};
    9293
     94/* Data and methods for 'uptime' command. */
    9395static int cmd_uptime(cmd_arg_t *argv);
    9496static cmd_info_t uptime_info = {
    9597        .name = "uptime",
    96         .description = "Print uptime information.",
     98        .description = "Show system uptime.",
    9799        .func = cmd_uptime,
    98100        .argc = 0
    99101};
    100102
     103/* Data and methods for 'continue' command. */
    101104static int cmd_continue(cmd_arg_t *argv);
    102105static cmd_info_t continue_info = {
    … …  
    108111
    109112#ifdef CONFIG_TEST
     113
     114/* Data and methods for 'test' command. */
    110115static char test_buf[MAX_CMDLINE + 1];
    111116static int cmd_test(cmd_arg_t *argv);
    … …  
    119124static cmd_info_t test_info = {
    120125        .name = "test",
    121         .description = "Print list of kernel tests or run a test.",
     126        .description = "<test> List kernel tests or run a test.",
    122127        .func = cmd_test,
    123128        .argc = 1,
    … …  
    125130};
    126131
     132/* Data and methods for 'bench' command. */
    127133static int cmd_bench(cmd_arg_t *argv);
    128134static cmd_arg_t bench_argv[] = {
    … …  
    138144static cmd_info_t bench_info = {
    139145        .name = "bench",
    140         .description = "Run kernel test as benchmark.",
     146        .description = "<test> <count> Run kernel test as benchmark.",
    141147        .func = cmd_bench,
    142148        .argc = 2,
    143149        .argv = bench_argv
    144150};
    145 #endif
     151
     152#endif /* CONFIG_TEST */
    146153
    147154/* Data and methods for 'description' command. */
    148155static int cmd_desc(cmd_arg_t *argv);
    149156static void desc_help(void);
    150 static char desc_buf[MAX_CMDLINE+1];
     157static char desc_buf[MAX_CMDLINE + 1];
    151158static cmd_arg_t desc_argv = {
    152159        .type = ARG_TYPE_STRING,
    … …  
    156163static cmd_info_t desc_info = {
    157164        .name = "describe",
    158         .description = "Describe specified command.",
     165        .description = "<command> Describe specified command.",
    159166        .help = desc_help,
    160167        .func = cmd_desc,
    … …  
    165172/* Data and methods for 'symaddr' command. */
    166173static int cmd_symaddr(cmd_arg_t *argv);
    167 static char symaddr_buf[MAX_CMDLINE+1];
     174static char symaddr_buf[MAX_CMDLINE + 1];
    168175static cmd_arg_t symaddr_argv = {
    169176        .type = ARG_TYPE_STRING,
    … …  
    173180static cmd_info_t symaddr_info = {
    174181        .name = "symaddr",
    175         .description = "Return symbol address.",
     182        .description = "<symbol> Return symbol address.",
    176183        .func = cmd_symaddr,
    177184        .argc = 1,
    … …  
    179186};
    180187
    181 static char set_buf[MAX_CMDLINE+1];
     188/* Data and methods for 'set4' command. */
     189static char set_buf[MAX_CMDLINE + 1];
    182190static int cmd_set4(cmd_arg_t *argv);
    183191static cmd_arg_t set4_argv[] = {
    … …  
    193201static cmd_info_t set4_info = {
    194202        .name = "set4",
    195         .description = "set <dest_addr> <value> - 4byte version",
     203        .description = "<addr> <value> Set 4B memory location to a value.",
    196204        .func = cmd_set4,
    197205        .argc = 2,
    … …  
    213221static cmd_info_t call0_info = {
    214222        .name = "call0",
    215         .description = "call0 <function> -> call function().",
     223        .description = "<function> Call function().",
    216224        .func = cmd_call0,
    217225        .argc = 1,
    … …  
    228236static cmd_info_t mcall0_info = {
    229237        .name = "mcall0",
    230         .description = "mcall0 <function> -> call function() on each CPU.",
     238        .description = "<function> Call function() on each CPU.",
    231239        .func = cmd_mcall0,
    232240        .argc = 1,
    … …  
    250258static cmd_info_t call1_info = {
    251259        .name = "call1",
    252         .description = "call1 <function> <arg1> -> call function(arg1).",
     260        .description = "<function> <arg1> Call function(arg1).",
    253261        .func = cmd_call1,
    254262        .argc = 2,
    … …  
    277285static cmd_info_t call2_info = {
    278286        .name = "call2",
    279         .description = "call2 <function> <arg1> <arg2> -> call function(arg1,arg2).",
     287        .description = "<function> <arg1> <arg2> Call function(arg1, arg2).",
    280288        .func = cmd_call2,
    281289        .argc = 3,
    … …  
    310318static cmd_info_t call3_info = {
    311319        .name = "call3",
    312         .description = "call3 <function> <arg1> <arg2> <arg3> -> call function(arg1,arg2,arg3).",
     320        .description = "<function> <arg1> <arg2> <arg3> Call function(arg1, arg2, arg3).",
    313321        .func = cmd_call3,
    314322        .argc = 4,
    … …  
    340348cmd_info_t tlb_info = {
    341349        .name = "tlb",
    342         .description = "Print TLB of current processor.",
     350        .description = "Print TLB of the current CPU.",
    343351        .help = NULL,
    344352        .func = cmd_tlb,
    … …  
    377385};
    378386
     387#ifdef CONFIG_UDEBUG
     388
     389/* Data and methods for 'btrace' command */
     390static int cmd_btrace(cmd_arg_t *argv);
     391static cmd_arg_t btrace_argv = {
     392        .type = ARG_TYPE_INT,
     393};
     394static 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 */
    379403
    380404static int cmd_sched(cmd_arg_t *argv);
    381405static cmd_info_t sched_info = {
    382406        .name = "scheduler",
    383         .description = "List all scheduler information.",
     407        .description = "Show scheduler information.",
    384408        .func = cmd_sched,
    385409        .argc = 0
    … …  
    406430static cmd_info_t zones_info = {
    407431        .name = "zones",
    408         .description = "List of memory zones.",
     432        .description = "List memory zones.",
    409433        .func = cmd_zones,
    410434        .argc = 0
     435};
     436
     437/* Data and methods for 'zone' command */
     438static int cmd_zone(cmd_arg_t *argv);
     439static cmd_arg_t zone_argv = {
     440        .type = ARG_TYPE_INT,
     441};
     442
     443static cmd_info_t zone_info = {
     444        .name = "zone",
     445        .description = "<zone> Show memory zone structure.",
     446        .func = cmd_zone,
     447        .argc = 1,
     448        .argv = &zone_argv
    411449};
    412450
    … …  
    418456static cmd_info_t ipc_info = {
    419457        .name = "ipc",
    420         .description = "ipc <taskid> Show IPC information of given task.",
     458        .description = "<taskid> Show IPC information of a task.",
    421459        .func = cmd_ipc,
    422460        .argc = 1,
    … …  
    431469static cmd_info_t kill_info = {
    432470        .name = "kill",
    433         .description = "kill <taskid> Kill a task.",
     471        .description = "<taskid> Kill a task.",
    434472        .func = cmd_kill,
    435473        .argc = 1,
    436474        .argv = &kill_argv
    437 };
    438 
    439 /* Data and methods for 'zone' command */
    440 static int cmd_zone(cmd_arg_t *argv);
    441 static cmd_arg_t zone_argv = {
    442         .type = ARG_TYPE_INT,
    443 };
    444 
    445 static cmd_info_t zone_info = {
    446         .name = "zone",
    447         .description = "Show memory zone structure.",
    448         .func = cmd_zone,
    449         .argc = 1,
    450         .argv = &zone_argv
    451475};
    452476
    … …  
    482506        &cpus_info,
    483507        &desc_info,
    484         &reboot_info,
    485         &uptime_info,
    486508        &halt_info,
    487509        &help_info,
    488510        &ipc_info,
    489511        &kill_info,
     512        &physmem_info,
     513        &reboot_info,
     514        &sched_info,
    490515        &set4_info,
    491516        &slabs_info,
     517        &symaddr_info,
    492518        &sysinfo_info,
    493         &symaddr_info,
    494         &sched_info,
     519        &tasks_info,
    495520        &threads_info,
    496         &tasks_info,
    497         &physmem_info,
    498521        &tlb_info,
     522        &uptime_info,
    499523        &version_info,
    500524        &zones_info,
    … …  
    504528        &bench_info,
    505529#endif
     530#ifdef CONFIG_UDEBUG
     531        &btrace_info,
     532#endif
    506533        NULL
    507534};
    … …  
    526553        for (i = 0; basic_commands[i]; i++) {
    527554                cmd_initialize(basic_commands[i]);
    528                 if (!cmd_register(basic_commands[i]))
    529                         printf("Cannot register command %s\n", basic_commands[i]->name);
    530         }
    531 }
    532 
     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}
    533564
    534565/** List supported commands.
    … …  
    554585        }
    555586       
     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       
    556593        for (cur = cmd_head.next; cur != &cmd_head; cur = cur->next) {
    557594                cmd_info_t *hlp;
    … …  
    559596               
    560597                spinlock_lock(&hlp->lock);
    561                 printf("%-*s %s\n", len, hlp->name, hlp->description);
     598                printf("%-*s %s\n", _len, hlp->name, hlp->description);
    562599                spinlock_unlock(&hlp->lock);
    563600        }
    … …  
    568605}
    569606
    570 
    571607/** Reboot the system.
    572608 *
    … …  
    583619}
    584620
    585 
    586621/** Print system uptime information.
    587622 *
    … …  
    595630       
    596631        /* This doesn't have to be very accurate */
    597         unative_t sec = uptime->seconds1;
     632        sysarg_t sec = uptime->seconds1;
    598633       
    599634        printf("Up %" PRIun " days, %" PRIun " hours, %" PRIun " minutes, %" PRIun " seconds\n",
    … …  
    650685        uintptr_t symaddr;
    651686        char *symbol;
    652         unative_t (*fnc)(void);
     687        sysarg_t (*fnc)(void);
    653688        fncptr_t fptr;
    654689        int rc;
    … …  
    666701
    667702                ipl = interrupts_disable();
    668                 fnc = (unative_t (*)(void)) arch_construct_function(&fptr,
     703                fnc = (sysarg_t (*)(void)) arch_construct_function(&fptr,
    669704                    (void *) symaddr, (void *) cmd_call0);
    670                 printf("Calling %s() (%p)\n", symbol, symaddr);
     705                printf("Calling %s() (%p)\n", symbol, (void *) symaddr);
    671706                printf("Result: %#" PRIxn "\n", fnc());
    672707                interrupts_restore(ipl);
    … …  
    685720         */
    686721       
    687         size_t i;
     722        unsigned int i;
    688723        for (i = 0; i < config.cpu_count; i++) {
    689724                if (!cpus[i].active)
    … …  
    697732                        irq_spinlock_unlock(&thread->lock, true);
    698733                       
    699                         printf("cpu%" PRIs ": ", i);
     734                        printf("cpu%u: ", i);
    700735                       
    701736                        thread_ready(thread);
    … …  
    703738                        thread_detach(thread);
    704739                } else
    705                         printf("Unable to create thread for cpu%" PRIs "\n", i);
     740                        printf("Unable to create thread for cpu%u\n", i);
    706741        }
    707742       
    … …  
    714749        uintptr_t symaddr;
    715750        char *symbol;
    716         unative_t (*fnc)(unative_t, ...);
    717         unative_t arg1 = argv[1].intval;
     751        sysarg_t (*fnc)(sysarg_t, ...);
     752        sysarg_t arg1 = argv[1].intval;
    718753        fncptr_t fptr;
    719754        int rc;
    … …  
    731766
    732767                ipl = interrupts_disable();
    733                 fnc = (unative_t (*)(unative_t, ...)) arch_construct_function(&fptr, (void *) symaddr, (void *) cmd_call1);
    734                 printf("Calling f(%#" PRIxn "): %p: %s\n", arg1, symaddr, symbol);
     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);
    735773                printf("Result: %#" PRIxn "\n", fnc(arg1));
    736774                interrupts_restore(ipl);
    … …  
    747785        uintptr_t symaddr;
    748786        char *symbol;
    749         unative_t (*fnc)(unative_t, unative_t, ...);
    750         unative_t arg1 = argv[1].intval;
    751         unative_t arg2 = argv[2].intval;
     787        sysarg_t (*fnc)(sysarg_t, sysarg_t, ...);
     788        sysarg_t arg1 = argv[1].intval;
     789        sysarg_t arg2 = argv[2].intval;
    752790        fncptr_t fptr;
    753791        int rc;
    … …  
    765803
    766804                ipl = interrupts_disable();
    767                 fnc = (unative_t (*)(unative_t, unative_t, ...)) arch_construct_function(&fptr, (void *) symaddr, (void *) cmd_call2);
     805                fnc = (sysarg_t (*)(sysarg_t, sysarg_t, ...))
     806                    arch_construct_function(&fptr, (void *) symaddr,
     807                    (void *) cmd_call2);
    768808                printf("Calling f(%#" PRIxn ", %#" PRIxn "): %p: %s\n",
    769                        arg1, arg2, symaddr, symbol);
     809                       arg1, arg2, (void *) symaddr, symbol);
    770810                printf("Result: %#" PRIxn "\n", fnc(arg1, arg2));
    771811                interrupts_restore(ipl);
    … …  
    781821        uintptr_t symaddr;
    782822        char *symbol;
    783         unative_t (*fnc)(unative_t, unative_t, unative_t, ...);
    784         unative_t arg1 = argv[1].intval;
    785         unative_t arg2 = argv[2].intval;
    786         unative_t arg3 = argv[3].intval;
     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;
    787827        fncptr_t fptr;
    788828        int rc;
    … …  
    800840
    801841                ipl = interrupts_disable();
    802                 fnc = (unative_t (*)(unative_t, unative_t, unative_t, ...)) arch_construct_function(&fptr, (void *) symaddr, (void *) cmd_call3);
    803                 printf("Calling f(%#" PRIxn ",%#" PRIxn ", %#" PRIxn "): %p: %s\n",
    804                        arg1, arg2, arg3, symaddr, symbol);
     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);
    805847                printf("Result: %#" PRIxn "\n", fnc(arg1, arg2, arg3));
    806848                interrupts_restore(ipl);
    … …  
    810852        return 1;
    811853}
    812 
    813854
    814855/** Print detailed description of 'describe' command. */
    … …  
    875916       
    876917        if (rc == ENOENT)
    877                 printf("Symbol %s not found.\n", argv->buffer);
     918                printf("Symbol %s not found.\n", (char *) argv->buffer);
    878919        else if (rc == EINVAL)
    879920                printf("Invalid address.\n");
    … …  
    884925                if (pointer)
    885926                        addr = *(uintptr_t *) addr;
    886                 printf("Writing %#" PRIx64 " -> %p\n", arg1, addr);
     927                printf("Writing %#" PRIx32" -> %p\n", arg1, (void *) addr);
    887928                *(uint32_t *) addr = arg1;
    888929        } else
    … …  
    898939 * @return Always 1
    899940 */
    900 int cmd_slabs(cmd_arg_t * argv)
     941int cmd_slabs(cmd_arg_t *argv)
    901942{
    902943        slab_print_list();
    … …  
    910951 * @return Always 1
    911952 */
    912 int cmd_sysinfo(cmd_arg_t * argv)
     953int cmd_sysinfo(cmd_arg_t *argv)
    913954{
    914955        sysinfo_dump(NULL);
    … …  
    916957}
    917958
    918 
    919 /** Command for listings Thread information
     959/** Command for listing thread information
    920960 *
    921961 * @param argv Ignored
    … …  
    935975}
    936976
    937 /** Command for listings Task information
     977/** Command for listing task information
    938978 *
    939979 * @param argv Ignored
    … …  
    953993}
    954994
    955 /** Command for listings Thread information
     995#ifdef CONFIG_UDEBUG
     996
     997/** Command for printing thread stack trace
     998 *
     999 * @param argv Integer argument from cmdline expected
     1000 *
     1001 * return Always 1
     1002 *
     1003 */
     1004int 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
    9561013 *
    9571014 * @param argv Ignores
    … …  
    9591016 * @return Always 1
    9601017 */
    961 int cmd_sched(cmd_arg_t * argv)
     1018int cmd_sched(cmd_arg_t *argv)
    9621019{
    9631020        sched_print_list();
    … …  
    9711028 * return Always 1
    9721029 */
    973 int cmd_zones(cmd_arg_t * argv)
     1030int cmd_zones(cmd_arg_t *argv)
    9741031{
    9751032        zones_print_list();
    … …  
    9831040 * return Always 1
    9841041 */
    985 int cmd_zone(cmd_arg_t * argv)
     1042int cmd_zone(cmd_arg_t *argv)
    9861043{
    9871044        zone_print_one(argv[0].intval);
    … …  
    9891046}
    9901047
    991 /** Command for printing task ipc details
     1048/** Command for printing task IPC details
    9921049 *
    9931050 * @param argv Integer argument from cmdline expected
    … …  
    9951052 * return Always 1
    9961053 */
    997 int cmd_ipc(cmd_arg_t * argv)
     1054int cmd_ipc(cmd_arg_t *argv)
    9981055{
    9991056        ipc_print_task(argv[0].intval);
    … …  
    10071064 * return 0 on failure, 1 on success.
    10081065 */
    1009 int cmd_kill(cmd_arg_t * argv)
     1066int cmd_kill(cmd_arg_t *argv)
    10101067{
    10111068        if (task_kill(argv[0].intval) != EOK)
    … …  
    11721229        }
    11731230       
     1231        unsigned int _len = (unsigned int) len;
     1232        if ((_len != len) || (((int) _len) < 0)) {
     1233                printf("Command length overflow\n");
     1234                return;
     1235        }
     1236       
    11741237        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, "*");
     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, "*");
    11781242}
    11791243
Note: See TracChangeset for help on using the changeset viewer.