Subversion Repositories HelenOS

Rev

Rev 3844 | Rev 3908 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
596 jermar 1
/*
2071 jermar 2
 * Copyright (c) 2005 Jakub Jermar
596 jermar 3
 * All rights reserved.
4
 *
5
 * Redistribution and use in source and binary forms, with or without
6
 * modification, are permitted provided that the following conditions
7
 * are met:
8
 *
9
 * - Redistributions of source code must retain the above copyright
10
 *   notice, this list of conditions and the following disclaimer.
11
 * - Redistributions in binary form must reproduce the above copyright
12
 *   notice, this list of conditions and the following disclaimer in the
13
 *   documentation and/or other materials provided with the distribution.
14
 * - The name of the author may not be used to endorse or promote products
15
 *   derived from this software without specific prior written permission.
16
 *
17
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27
 */
28
 
1888 jermar 29
/** @addtogroup genericconsole
1702 cejka 30
 * @{
31
 */
32
 
596 jermar 33
/**
1264 jermar 34
 * @file    cmd.c
35
 * @brief   Kernel console command wrappers.
36
 *
596 jermar 37
 * This file is meant to contain all wrapper functions for
38
 * all kconsole commands. The point is in separating
39
 * kconsole specific wrappers from kconsole-unaware functions
40
 * from other subsystems.
41
 */
42
 
43
#include <console/cmd.h>
1474 palkovsky 44
#include <console/console.h>
596 jermar 45
#include <console/kconsole.h>
46
#include <print.h>
47
#include <panic.h>
48
#include <arch/types.h>
788 jermar 49
#include <adt/list.h>
596 jermar 50
#include <arch.h>
2227 decky 51
#include <config.h>
596 jermar 52
#include <func.h>
53
#include <macros.h>
54
#include <debug.h>
55
#include <symtab.h>
673 jermar 56
#include <cpu.h>
596 jermar 57
#include <mm/tlb.h>
58
#include <arch/mm/tlb.h>
668 bondari 59
#include <mm/frame.h>
673 jermar 60
#include <main/version.h>
759 palkovsky 61
#include <mm/slab.h>
775 palkovsky 62
#include <proc/scheduler.h>
777 palkovsky 63
#include <proc/thread.h>
1060 palkovsky 64
#include <proc/task.h>
1573 palkovsky 65
#include <ipc/ipc.h>
1712 palkovsky 66
#include <ipc/irq.h>
596 jermar 67
 
2019 decky 68
#ifdef CONFIG_TEST
69
#include <test.h>
70
#endif
71
 
1702 cejka 72
/* Data and methods for 'help' command. */
596 jermar 73
static int cmd_help(cmd_arg_t *argv);
74
static cmd_info_t help_info = {
75
    .name = "help",
76
    .description = "List of supported commands.",
77
    .func = cmd_help,
78
    .argc = 0
79
};
80
 
609 palkovsky 81
static cmd_info_t exit_info = {
82
    .name = "exit",
2227 decky 83
    .description = "Exit kconsole.",
609 palkovsky 84
    .argc = 0
85
};
86
 
2227 decky 87
static int cmd_reboot(cmd_arg_t *argv);
88
static cmd_info_t reboot_info = {
89
    .name = "reboot",
90
    .description = "Reboot.",
91
    .func = cmd_reboot,
92
    .argc = 0
93
};
94
 
2275 decky 95
static int cmd_uptime(cmd_arg_t *argv);
96
static cmd_info_t uptime_info = {
97
    .name = "uptime",
98
    .description = "Print uptime information.",
99
    .func = cmd_uptime,
100
    .argc = 0
101
};
102
 
1474 palkovsky 103
static int cmd_continue(cmd_arg_t *argv);
104
static cmd_info_t continue_info = {
105
    .name = "continue",
2019 decky 106
    .description = "Return console back to userspace.",
1474 palkovsky 107
    .func = cmd_continue,
108
    .argc = 0
109
};
110
 
2019 decky 111
#ifdef CONFIG_TEST
112
static int cmd_tests(cmd_arg_t *argv);
113
static cmd_info_t tests_info = {
114
    .name = "tests",
115
    .description = "Print available kernel tests.",
116
    .func = cmd_tests,
117
    .argc = 0
118
};
119
 
120
static char test_buf[MAX_CMDLINE + 1];
121
static int cmd_test(cmd_arg_t *argv);
122
static cmd_arg_t test_argv[] = {
123
    {
124
        .type = ARG_TYPE_STRING,
125
        .buffer = test_buf,
126
        .len = sizeof(test_buf)
127
    }
128
};
129
static cmd_info_t test_info = {
130
    .name = "test",
131
    .description = "Run kernel test.",
132
    .func = cmd_test,
133
    .argc = 1,
134
    .argv = test_argv
135
};
2050 decky 136
 
137
static int cmd_bench(cmd_arg_t *argv);
138
static cmd_arg_t bench_argv[] = {
139
    {
140
        .type = ARG_TYPE_STRING,
141
        .buffer = test_buf,
142
        .len = sizeof(test_buf)
143
    },
144
    {
145
        .type = ARG_TYPE_INT,
146
    }
147
};
148
static cmd_info_t bench_info = {
149
    .name = "bench",
150
    .description = "Run kernel test as benchmark.",
151
    .func = cmd_bench,
152
    .argc = 2,
153
    .argv = bench_argv
154
};
2019 decky 155
#endif
156
 
1702 cejka 157
/* Data and methods for 'description' command. */
596 jermar 158
static int cmd_desc(cmd_arg_t *argv);
159
static void desc_help(void);
160
static char desc_buf[MAX_CMDLINE+1];
161
static cmd_arg_t desc_argv = {
162
    .type = ARG_TYPE_STRING,
163
    .buffer = desc_buf,
164
    .len = sizeof(desc_buf)
165
};
166
static cmd_info_t desc_info = {
167
    .name = "describe",
168
    .description = "Describe specified command.",
169
    .help = desc_help,
170
    .func = cmd_desc,
171
    .argc = 1,
172
    .argv = &desc_argv
173
};
174
 
1702 cejka 175
/* Data and methods for 'symaddr' command. */
596 jermar 176
static int cmd_symaddr(cmd_arg_t *argv);
177
static char symaddr_buf[MAX_CMDLINE+1];
178
static cmd_arg_t symaddr_argv = {
179
    .type = ARG_TYPE_STRING,
180
    .buffer = symaddr_buf,
181
    .len = sizeof(symaddr_buf)
182
};
183
static cmd_info_t symaddr_info = {
184
    .name = "symaddr",
185
    .description = "Return symbol address.",
186
    .func = cmd_symaddr,
187
    .argc = 1,
188
    .argv = &symaddr_argv
189
};
190
 
603 palkovsky 191
static char set_buf[MAX_CMDLINE+1];
192
static int cmd_set4(cmd_arg_t *argv);
193
static cmd_arg_t set4_argv[] = {
194
    {
195
        .type = ARG_TYPE_STRING,
196
        .buffer = set_buf,
197
        .len = sizeof(set_buf)
198
    },
199
    {
200
        .type = ARG_TYPE_INT
201
    }
202
};
203
static cmd_info_t set4_info = {
204
    .name = "set4",
205
    .description = "set <dest_addr> <value> - 4byte version",
206
    .func = cmd_set4,
207
    .argc = 2,
208
    .argv = set4_argv
209
};
210
 
1702 cejka 211
/* Data and methods for 'call0' command. */
2223 decky 212
static char call0_buf[MAX_CMDLINE + 1];
213
static char carg1_buf[MAX_CMDLINE + 1];
214
static char carg2_buf[MAX_CMDLINE + 1];
215
static char carg3_buf[MAX_CMDLINE + 1];
596 jermar 216
 
217
static int cmd_call0(cmd_arg_t *argv);
218
static cmd_arg_t call0_argv = {
219
    .type = ARG_TYPE_STRING,
220
    .buffer = call0_buf,
221
    .len = sizeof(call0_buf)
222
};
223
static cmd_info_t call0_info = {
224
    .name = "call0",
225
    .description = "call0 <function> -> call function().",
226
    .func = cmd_call0,
227
    .argc = 1,
228
    .argv = &call0_argv
229
};
230
 
2223 decky 231
/* Data and methods for 'mcall0' command. */
232
static int cmd_mcall0(cmd_arg_t *argv);
233
static cmd_arg_t mcall0_argv = {
234
    .type = ARG_TYPE_STRING,
235
    .buffer = call0_buf,
236
    .len = sizeof(call0_buf)
237
};
238
static cmd_info_t mcall0_info = {
239
    .name = "mcall0",
240
    .description = "mcall0 <function> -> call function() on each CPU.",
241
    .func = cmd_mcall0,
242
    .argc = 1,
243
    .argv = &mcall0_argv
244
};
245
 
1702 cejka 246
/* Data and methods for 'call1' command. */
596 jermar 247
static int cmd_call1(cmd_arg_t *argv);
248
static cmd_arg_t call1_argv[] = {
249
    {
250
        .type = ARG_TYPE_STRING,
251
        .buffer = call0_buf,
252
        .len = sizeof(call0_buf)
253
    },
254
    {
255
        .type = ARG_TYPE_VAR,
256
        .buffer = carg1_buf,
257
        .len = sizeof(carg1_buf)
258
    }
259
};
260
static cmd_info_t call1_info = {
261
    .name = "call1",
262
    .description = "call1 <function> <arg1> -> call function(arg1).",
263
    .func = cmd_call1,
264
    .argc = 2,
265
    .argv = call1_argv
266
};
267
 
1702 cejka 268
/* Data and methods for 'call2' command. */
596 jermar 269
static int cmd_call2(cmd_arg_t *argv);
270
static cmd_arg_t call2_argv[] = {
271
    {
272
        .type = ARG_TYPE_STRING,
273
        .buffer = call0_buf,
274
        .len = sizeof(call0_buf)
275
    },
276
    {
277
        .type = ARG_TYPE_VAR,
278
        .buffer = carg1_buf,
279
        .len = sizeof(carg1_buf)
280
    },
281
    {
282
        .type = ARG_TYPE_VAR,
283
        .buffer = carg2_buf,
284
        .len = sizeof(carg2_buf)
285
    }
286
};
287
static cmd_info_t call2_info = {
288
    .name = "call2",
289
    .description = "call2 <function> <arg1> <arg2> -> call function(arg1,arg2).",
290
    .func = cmd_call2,
291
    .argc = 3,
292
    .argv = call2_argv
293
};
294
 
1702 cejka 295
/* Data and methods for 'call3' command. */
596 jermar 296
static int cmd_call3(cmd_arg_t *argv);
297
static cmd_arg_t call3_argv[] = {
298
    {
299
        .type = ARG_TYPE_STRING,
300
        .buffer = call0_buf,
301
        .len = sizeof(call0_buf)
302
    },
303
    {
304
        .type = ARG_TYPE_VAR,
305
        .buffer = carg1_buf,
306
        .len = sizeof(carg1_buf)
307
    },
308
    {
309
        .type = ARG_TYPE_VAR,
310
        .buffer = carg2_buf,
311
        .len = sizeof(carg2_buf)
312
    },
313
    {
314
        .type = ARG_TYPE_VAR,
315
        .buffer = carg3_buf,
316
        .len = sizeof(carg3_buf)
317
    }
318
 
319
};
320
static cmd_info_t call3_info = {
321
    .name = "call3",
322
    .description = "call3 <function> <arg1> <arg2> <arg3> -> call function(arg1,arg2,arg3).",
323
    .func = cmd_call3,
324
    .argc = 4,
325
    .argv = call3_argv
326
};
327
 
1702 cejka 328
/* Data and methods for 'halt' command. */
596 jermar 329
static int cmd_halt(cmd_arg_t *argv);
330
static cmd_info_t halt_info = {
331
    .name = "halt",
332
    .description = "Halt the kernel.",
333
    .func = cmd_halt,
334
    .argc = 0
335
};
336
 
2721 decky 337
/* Data and methods for 'physmem' command. */
338
static int cmd_physmem(cmd_arg_t *argv);
339
cmd_info_t physmem_info = {
340
    .name = "physmem",
341
    .description = "Print physical memory configuration.",
342
    .help = NULL,
343
    .func = cmd_physmem,
344
    .argc = 0,
345
    .argv = NULL
346
};
347
 
1702 cejka 348
/* Data and methods for 'tlb' command. */
673 jermar 349
static int cmd_tlb(cmd_arg_t *argv);
350
cmd_info_t tlb_info = {
351
    .name = "tlb",
596 jermar 352
    .description = "Print TLB of current processor.",
353
    .help = NULL,
673 jermar 354
    .func = cmd_tlb,
596 jermar 355
    .argc = 0,
356
    .argv = NULL
357
};
358
 
777 palkovsky 359
static int cmd_threads(cmd_arg_t *argv);
360
static cmd_info_t threads_info = {
361
    .name = "threads",
1695 jermar 362
    .description = "List all threads.",
777 palkovsky 363
    .func = cmd_threads,
364
    .argc = 0
365
};
668 bondari 366
 
1060 palkovsky 367
static int cmd_tasks(cmd_arg_t *argv);
368
static cmd_info_t tasks_info = {
369
    .name = "tasks",
1695 jermar 370
    .description = "List all tasks.",
1060 palkovsky 371
    .func = cmd_tasks,
372
    .argc = 0
373
};
777 palkovsky 374
 
1060 palkovsky 375
 
775 palkovsky 376
static int cmd_sched(cmd_arg_t *argv);
377
static cmd_info_t sched_info = {
378
    .name = "scheduler",
1695 jermar 379
    .description = "List all scheduler information.",
775 palkovsky 380
    .func = cmd_sched,
381
    .argc = 0
382
};
383
 
759 palkovsky 384
static int cmd_slabs(cmd_arg_t *argv);
385
static cmd_info_t slabs_info = {
386
    .name = "slabs",
1695 jermar 387
    .description = "List slab caches.",
759 palkovsky 388
    .func = cmd_slabs,
389
    .argc = 0
390
};
391
 
1702 cejka 392
/* Data and methods for 'zones' command */
668 bondari 393
static int cmd_zones(cmd_arg_t *argv);
394
static cmd_info_t zones_info = {
395
    .name = "zones",
396
    .description = "List of memory zones.",
397
    .func = cmd_zones,
398
    .argc = 0
399
};
400
 
3451 jermar 401
/* Data and methods for 'ipc' command */
402
static int cmd_ipc(cmd_arg_t *argv);
403
static cmd_arg_t ipc_argv = {
1573 palkovsky 404
    .type = ARG_TYPE_INT,
405
};
3451 jermar 406
static cmd_info_t ipc_info = {
407
    .name = "ipc",
408
    .description = "ipc <taskid> Show IPC information of given task.",
409
    .func = cmd_ipc,
1573 palkovsky 410
    .argc = 1,
3451 jermar 411
    .argv = &ipc_argv
1573 palkovsky 412
};
413
 
1702 cejka 414
/* Data and methods for 'zone' command */
668 bondari 415
static int cmd_zone(cmd_arg_t *argv);
416
static cmd_arg_t zone_argv = {
417
    .type = ARG_TYPE_INT,
418
};
419
 
420
static cmd_info_t zone_info = {
421
    .name = "zone",
422
    .description = "Show memory zone structure.",
423
    .func = cmd_zone,
424
    .argc = 1,
425
    .argv = &zone_argv
426
};
427
 
1702 cejka 428
/* Data and methods for 'cpus' command. */
673 jermar 429
static int cmd_cpus(cmd_arg_t *argv);
430
cmd_info_t cpus_info = {
431
    .name = "cpus",
432
    .description = "List all processors.",
433
    .help = NULL,
434
    .func = cmd_cpus,
435
    .argc = 0,
436
    .argv = NULL
437
};
668 bondari 438
 
1702 cejka 439
/* Data and methods for 'version' command. */
673 jermar 440
static int cmd_version(cmd_arg_t *argv);
441
cmd_info_t version_info = {
442
    .name = "version",
443
    .description = "Print version information.",
444
    .help = NULL,
445
    .func = cmd_version,
446
    .argc = 0,
447
    .argv = NULL
448
};
668 bondari 449
 
775 palkovsky 450
static cmd_info_t *basic_commands[] = {
451
    &call0_info,
2223 decky 452
    &mcall0_info,
775 palkovsky 453
    &call1_info,
454
    &call2_info,
455
    &call3_info,
1474 palkovsky 456
    &continue_info,
775 palkovsky 457
    &cpus_info,
458
    &desc_info,
459
    &exit_info,
2227 decky 460
    &reboot_info,
2275 decky 461
    &uptime_info,
775 palkovsky 462
    &halt_info,
463
    &help_info,
3451 jermar 464
    &ipc_info,
775 palkovsky 465
    &set4_info,
466
    &slabs_info,
467
    &symaddr_info,
468
    &sched_info,
777 palkovsky 469
    &threads_info,
1060 palkovsky 470
    &tasks_info,
2721 decky 471
    &physmem_info,
775 palkovsky 472
    &tlb_info,
473
    &version_info,
474
    &zones_info,
475
    &zone_info,
2019 decky 476
#ifdef CONFIG_TEST
477
    &tests_info,
478
    &test_info,
2050 decky 479
    &bench_info,
2019 decky 480
#endif
775 palkovsky 481
    NULL
482
};
673 jermar 483
 
484
 
596 jermar 485
/** Initialize command info structure.
486
 *
487
 * @param cmd Command info structure.
488
 *
489
 */
490
void cmd_initialize(cmd_info_t *cmd)
491
{
492
    spinlock_initialize(&cmd->lock, "cmd");
493
    link_initialize(&cmd->link);
494
}
495
 
496
/** Initialize and register commands. */
497
void cmd_init(void)
498
{
2721 decky 499
    unsigned int i;
596 jermar 500
 
2721 decky 501
    for (i = 0; basic_commands[i]; i++) {
775 palkovsky 502
        cmd_initialize(basic_commands[i]);
503
        if (!cmd_register(basic_commands[i]))
3707 decky 504
            printf("Cannot register command %s\n", basic_commands[i]->name);
775 palkovsky 505
    }
596 jermar 506
}
507
 
508
 
509
/** List supported commands.
510
 *
511
 * @param argv Argument vector.
512
 *
513
 * @return 0 on failure, 1 on success.
514
 */
515
int cmd_help(cmd_arg_t *argv)
516
{
517
    link_t *cur;
518
 
519
    spinlock_lock(&cmd_lock);
520
 
521
    for (cur = cmd_head.next; cur != &cmd_head; cur = cur->next) {
522
        cmd_info_t *hlp;
523
 
524
        hlp = list_get_instance(cur, cmd_info_t, link);
525
        spinlock_lock(&hlp->lock);
526
 
527
        printf("%s - %s\n", hlp->name, hlp->description);
528
 
529
        spinlock_unlock(&hlp->lock);
530
    }
531
 
532
    spinlock_unlock(&cmd_lock);
533
 
534
    return 1;
535
}
536
 
2227 decky 537
 
538
/** Reboot the system.
539
 *
540
 * @param argv Argument vector.
541
 *
542
 * @return 0 on failure, 1 on success.
543
 */
544
int cmd_reboot(cmd_arg_t *argv)
545
{
546
    reboot();
547
 
548
    /* Not reached */
549
    return 1;
550
}
551
 
2275 decky 552
 
553
/** Print system uptime information.
554
 *
555
 * @param argv Argument vector.
556
 *
557
 * @return 0 on failure, 1 on success.
558
 */
559
int cmd_uptime(cmd_arg_t *argv)
560
{
561
    ASSERT(uptime);
562
 
563
    /* This doesn't have to be very accurate */
564
    unative_t sec = uptime->seconds1;
565
 
3065 decky 566
    printf("Up %" PRIun " days, %" PRIun " hours, %" PRIun " minutes, %" PRIun " seconds\n",
2275 decky 567
        sec / 86400, (sec % 86400) / 3600, (sec % 3600) / 60, sec % 60);
568
 
569
    return 1;
570
}
571
 
596 jermar 572
/** Describe specified command.
573
 *
574
 * @param argv Argument vector.
575
 *
576
 * @return 0 on failure, 1 on success.
577
 */
578
int cmd_desc(cmd_arg_t *argv)
579
{
580
    link_t *cur;
581
 
582
    spinlock_lock(&cmd_lock);
583
 
584
    for (cur = cmd_head.next; cur != &cmd_head; cur = cur->next) {
585
        cmd_info_t *hlp;
586
 
587
        hlp = list_get_instance(cur, cmd_info_t, link);
588
        spinlock_lock(&hlp->lock);
589
 
590
        if (strncmp(hlp->name, (const char *) argv->buffer, strlen(hlp->name)) == 0) {
591
            printf("%s - %s\n", hlp->name, hlp->description);
592
            if (hlp->help)
593
                hlp->help();
594
            spinlock_unlock(&hlp->lock);
595
            break;
596
        }
597
 
598
        spinlock_unlock(&hlp->lock);
599
    }
600
 
601
    spinlock_unlock(&cmd_lock);
602
 
603
    return 1;
604
}
605
 
606
/** Search symbol table */
607
int cmd_symaddr(cmd_arg_t *argv)
608
{
2114 decky 609
    symtab_print_search((char *) argv->buffer);
596 jermar 610
 
611
    return 1;
612
}
613
 
614
/** Call function with zero parameters */
615
int cmd_call0(cmd_arg_t *argv)
616
{
1780 jermar 617
    uintptr_t symaddr;
596 jermar 618
    char *symbol;
3875 decky 619
    unative_t (*fnc)(void);
620
    fncptr_t fptr;
621
 
2114 decky 622
    symaddr = get_symbol_addr((char *) argv->buffer);
596 jermar 623
    if (!symaddr)
624
        printf("Symbol %s not found.\n", argv->buffer);
1780 jermar 625
    else if (symaddr == (uintptr_t) -1) {
2114 decky 626
        symtab_print_search((char *) argv->buffer);
596 jermar 627
        printf("Duplicate symbol, be more specific.\n");
628
    } else {
629
        symbol = get_symtab_entry(symaddr);
3875 decky 630
        fnc = (unative_t (*)(void)) arch_construct_function(&fptr, (void *) symaddr, (void *) cmd_call0);
3065 decky 631
        printf("Calling %s() (%p)\n", symbol, symaddr);
3875 decky 632
        printf("Result: %#" PRIxn "\n", fnc());
596 jermar 633
    }
634
 
635
    return 1;
636
}
637
 
2223 decky 638
/** Call function with zero parameters on each CPU */
639
int cmd_mcall0(cmd_arg_t *argv)
640
{
641
    /*
642
     * For each CPU, create a thread which will
643
     * call the function.
644
     */
645
 
646
    count_t i;
647
    for (i = 0; i < config.cpu_count; i++) {
2319 decky 648
        if (!cpus[i].active)
649
            continue;
650
 
2223 decky 651
        thread_t *t;
652
        if ((t = thread_create((void (*)(void *)) cmd_call0, (void *) argv, TASK, THREAD_FLAG_WIRED, "call0", false))) {
653
            spinlock_lock(&t->lock);
654
            t->cpu = &cpus[i];
655
            spinlock_unlock(&t->lock);
656
            printf("cpu%u: ", i);
657
            thread_ready(t);
658
            thread_join(t);
2224 decky 659
            thread_detach(t);
2223 decky 660
        } else
661
            printf("Unable to create thread for cpu%u\n", i);
662
    }
663
 
664
    return 1;
665
}
666
 
596 jermar 667
/** Call function with one parameter */
668
int cmd_call1(cmd_arg_t *argv)
669
{
1780 jermar 670
    uintptr_t symaddr;
596 jermar 671
    char *symbol;
3875 decky 672
    unative_t (*fnc)(unative_t, ...);
1780 jermar 673
    unative_t arg1 = argv[1].intval;
3875 decky 674
    fncptr_t fptr;
675
 
2114 decky 676
    symaddr = get_symbol_addr((char *) argv->buffer);
596 jermar 677
    if (!symaddr)
678
        printf("Symbol %s not found.\n", argv->buffer);
1780 jermar 679
    else if (symaddr == (uintptr_t) -1) {
2114 decky 680
        symtab_print_search((char *) argv->buffer);
596 jermar 681
        printf("Duplicate symbol, be more specific.\n");
682
    } else {
683
        symbol = get_symtab_entry(symaddr);
3875 decky 684
        fnc = (unative_t (*)(unative_t, ...)) arch_construct_function(&fptr, (void *) symaddr, (void *) cmd_call1);
3065 decky 685
        printf("Calling f(%#" PRIxn "): %p: %s\n", arg1, symaddr, symbol);
3875 decky 686
        printf("Result: %#" PRIxn "\n", fnc(arg1));
596 jermar 687
    }
688
 
689
    return 1;
690
}
691
 
692
/** Call function with two parameters */
693
int cmd_call2(cmd_arg_t *argv)
694
{
1780 jermar 695
    uintptr_t symaddr;
596 jermar 696
    char *symbol;
3875 decky 697
    unative_t (*fnc)(unative_t, unative_t, ...);
1780 jermar 698
    unative_t arg1 = argv[1].intval;
699
    unative_t arg2 = argv[2].intval;
3875 decky 700
    fncptr_t fptr;
701
 
2114 decky 702
    symaddr = get_symbol_addr((char *) argv->buffer);
596 jermar 703
    if (!symaddr)
704
        printf("Symbol %s not found.\n", argv->buffer);
1780 jermar 705
    else if (symaddr == (uintptr_t) -1) {
2114 decky 706
        symtab_print_search((char *) argv->buffer);
596 jermar 707
        printf("Duplicate symbol, be more specific.\n");
708
    } else {
709
        symbol = get_symtab_entry(symaddr);
3875 decky 710
        fnc = (unative_t (*)(unative_t, unative_t, ...)) arch_construct_function(&fptr, (void *) symaddr, (void *) cmd_call2);
3065 decky 711
        printf("Calling f(%#" PRIxn ", %#" PRIxn "): %p: %s\n",
712
               arg1, arg2, symaddr, symbol);
3875 decky 713
        printf("Result: %#" PRIxn "\n", fnc(arg1, arg2));
596 jermar 714
    }
715
 
716
    return 1;
717
}
718
 
719
/** Call function with three parameters */
720
int cmd_call3(cmd_arg_t *argv)
721
{
1780 jermar 722
    uintptr_t symaddr;
596 jermar 723
    char *symbol;
3875 decky 724
    unative_t (*fnc)(unative_t, unative_t, unative_t, ...);
1780 jermar 725
    unative_t arg1 = argv[1].intval;
726
    unative_t arg2 = argv[2].intval;
727
    unative_t arg3 = argv[3].intval;
3875 decky 728
    fncptr_t fptr;
729
 
2114 decky 730
    symaddr = get_symbol_addr((char *) argv->buffer);
596 jermar 731
    if (!symaddr)
732
        printf("Symbol %s not found.\n", argv->buffer);
1780 jermar 733
    else if (symaddr == (uintptr_t) -1) {
2114 decky 734
        symtab_print_search((char *) argv->buffer);
596 jermar 735
        printf("Duplicate symbol, be more specific.\n");
736
    } else {
737
        symbol = get_symtab_entry(symaddr);
3875 decky 738
        fnc = (unative_t (*)(unative_t, unative_t, unative_t, ...)) arch_construct_function(&fptr, (void *) symaddr, (void *) cmd_call3);
3065 decky 739
        printf("Calling f(%#" PRIxn ",%#" PRIxn ", %#" PRIxn "): %p: %s\n",
740
               arg1, arg2, arg3, symaddr, symbol);
3875 decky 741
        printf("Result: %#" PRIxn "\n", fnc(arg1, arg2, arg3));
596 jermar 742
    }
743
 
744
    return 1;
745
}
746
 
747
 
748
/** Print detailed description of 'describe' command. */
749
void desc_help(void)
750
{
751
    printf("Syntax: describe command_name\n");
752
}
753
 
754
/** Halt the kernel.
755
 *
756
 * @param argv Argument vector (ignored).
757
 *
758
 * @return 0 on failure, 1 on success (never returns).
759
 */
760
int cmd_halt(cmd_arg_t *argv)
761
{
762
    halt();
763
    return 1;
764
}
765
 
766
/** Command for printing TLB contents.
767
 *
768
 * @param argv Not used.
769
 *
770
 * @return Always returns 1.
771
 */
673 jermar 772
int cmd_tlb(cmd_arg_t *argv)
596 jermar 773
{
774
    tlb_print();
775
    return 1;
776
}
603 palkovsky 777
 
2721 decky 778
/** Command for printing physical memory configuration.
779
 *
780
 * @param argv Not used.
781
 *
782
 * @return Always returns 1.
783
 */
784
int cmd_physmem(cmd_arg_t *argv)
785
{
786
    physmem_print();
787
    return 1;
788
}
789
 
603 palkovsky 790
/** Write 4 byte value to address */
791
int cmd_set4(cmd_arg_t *argv)
792
{
2216 decky 793
    uint32_t *addr;
1780 jermar 794
    uint32_t arg1 = argv[1].intval;
603 palkovsky 795
    bool pointer = false;
796
 
797
    if (((char *)argv->buffer)[0] == '*') {
2114 decky 798
        addr = (uint32_t *) get_symbol_addr((char *) argv->buffer + 1);
603 palkovsky 799
        pointer = true;
2114 decky 800
    } else if (((char *) argv->buffer)[0] >= '0' &&
603 palkovsky 801
           ((char *)argv->buffer)[0] <= '9')
1780 jermar 802
        addr = (uint32_t *)atoi((char *)argv->buffer);
603 palkovsky 803
    else
2114 decky 804
        addr = (uint32_t *)get_symbol_addr((char *) argv->buffer);
603 palkovsky 805
 
806
    if (!addr)
807
        printf("Symbol %s not found.\n", argv->buffer);
1780 jermar 808
    else if (addr == (uint32_t *) -1) {
2114 decky 809
        symtab_print_search((char *) argv->buffer);
603 palkovsky 810
        printf("Duplicate symbol, be more specific.\n");
811
    } else {
812
        if (pointer)
1780 jermar 813
            addr = (uint32_t *)(*(unative_t *)addr);
3065 decky 814
        printf("Writing %#" PRIx64 " -> %p\n", arg1, addr);
603 palkovsky 815
        *addr = arg1;
816
 
817
    }
818
 
819
    return 1;
820
}
668 bondari 821
 
759 palkovsky 822
/** Command for listings SLAB caches
823
 *
824
 * @param argv Ignores
825
 *
826
 * @return Always 1
827
 */
828
int cmd_slabs(cmd_arg_t * argv) {
829
    slab_print_list();
830
    return 1;
831
}
832
 
777 palkovsky 833
 
775 palkovsky 834
/** Command for listings Thread information
835
 *
836
 * @param argv Ignores
837
 *
838
 * @return Always 1
839
 */
777 palkovsky 840
int cmd_threads(cmd_arg_t * argv) {
841
    thread_print_list();
842
    return 1;
843
}
844
 
1060 palkovsky 845
/** Command for listings Task information
846
 *
847
 * @param argv Ignores
848
 *
849
 * @return Always 1
850
 */
851
int cmd_tasks(cmd_arg_t * argv) {
852
    task_print_list();
853
    return 1;
854
}
855
 
777 palkovsky 856
/** Command for listings Thread information
857
 *
858
 * @param argv Ignores
859
 *
860
 * @return Always 1
861
 */
775 palkovsky 862
int cmd_sched(cmd_arg_t * argv) {
863
    sched_print_list();
864
    return 1;
865
}
866
 
677 bondari 867
/** Command for listing memory zones
868
 *
869
 * @param argv Ignored
870
 *
871
 * return Always 1
872
 */
668 bondari 873
int cmd_zones(cmd_arg_t * argv) {
676 bondari 874
    zone_print_list();
668 bondari 875
    return 1;
876
}
673 jermar 877
 
677 bondari 878
/** Command for memory zone details
879
 *
880
 * @param argv Integer argument from cmdline expected
881
 *
882
 * return Always 1
883
 */
668 bondari 884
int cmd_zone(cmd_arg_t * argv) {
676 bondari 885
    zone_print_one(argv[0].intval);
668 bondari 886
    return 1;
887
}
888
 
1573 palkovsky 889
/** Command for printing task ipc details
890
 *
891
 * @param argv Integer argument from cmdline expected
892
 *
893
 * return Always 1
894
 */
3451 jermar 895
int cmd_ipc(cmd_arg_t * argv) {
1573 palkovsky 896
    ipc_print_task(argv[0].intval);
897
    return 1;
898
}
899
 
900
 
673 jermar 901
/** Command for listing processors.
902
 *
903
 * @param argv Ignored.
904
 *
905
 * return Always 1.
906
 */
907
int cmd_cpus(cmd_arg_t *argv)
908
{
909
    cpu_list();
910
    return 1;
911
}
912
 
913
/** Command for printing kernel version.
914
 *
915
 * @param argv Ignored.
916
 *
917
 * return Always 1.
918
 */
919
int cmd_version(cmd_arg_t *argv)
920
{
921
    version_print();
922
    return 1;
923
}
1474 palkovsky 924
 
925
/** Command for returning console back to userspace.
926
 *
927
 * @param argv Ignored.
928
 *
929
 * return Always 1.
930
 */
931
int cmd_continue(cmd_arg_t *argv)
932
{
1695 jermar 933
    printf("The kernel will now relinquish the console.\n");
3844 decky 934
    release_console();
3761 decky 935
 
936
    if ((kconsole_notify) && (kconsole_irq.notif_cfg.notify))
937
        ipc_irq_send_msg_0(&kconsole_irq);
938
 
1474 palkovsky 939
    return 1;
940
}
1702 cejka 941
 
2020 decky 942
#ifdef CONFIG_TEST
2019 decky 943
/** Command for printing kernel tests list.
944
 *
945
 * @param argv Ignored.
946
 *
947
 * return Always 1.
948
 */
949
int cmd_tests(cmd_arg_t *argv)
950
{
951
    test_t *test;
952
 
953
    for (test = tests; test->name != NULL; test++)
3875 decky 954
        printf("%-10s %s%s\n", test->name, test->desc, (test->safe ? "" : " (unsafe)"));
2019 decky 955
 
3875 decky 956
    printf("%-10s Run all safe tests\n", "*");
2019 decky 957
    return 1;
958
}
959
 
2042 decky 960
static bool run_test(const test_t *test)
2027 decky 961
{
2042 decky 962
    printf("%s\t\t%s\n", test->name, test->desc);
2030 decky 963
 
964
    /* Update and read thread accounting
965
       for benchmarking */
966
    ipl_t ipl = interrupts_disable();
2039 decky 967
    spinlock_lock(&TASK->lock);
968
    uint64_t t0 = task_get_accounting(TASK);
969
    spinlock_unlock(&TASK->lock);
2030 decky 970
    interrupts_restore(ipl);
971
 
972
    /* Execute the test */
2050 decky 973
    char * ret = test->entry(false);
2030 decky 974
 
975
    /* Update and read thread accounting */
976
    ipl = interrupts_disable();
2039 decky 977
    spinlock_lock(&TASK->lock);
978
    uint64_t dt = task_get_accounting(TASK) - t0;
979
    spinlock_unlock(&TASK->lock);
2030 decky 980
    interrupts_restore(ipl);
981
 
2050 decky 982
    uint64_t cycles;
983
    char suffix;
984
    order(dt, &cycles, &suffix);
985
 
3065 decky 986
    printf("Time: %" PRIu64 "%c cycles\n", cycles, suffix);
2027 decky 987
 
988
    if (ret == NULL) {
989
        printf("Test passed\n");
2042 decky 990
        return true;
2027 decky 991
    }
992
 
993
    printf("%s\n", ret);
2042 decky 994
    return false;
2027 decky 995
}
996
 
2050 decky 997
static bool run_bench(const test_t *test, const uint32_t cnt)
998
{
999
    uint32_t i;
1000
    bool ret = true;
1001
    uint64_t cycles;
1002
    char suffix;
1003
 
1004
    if (cnt < 1)
1005
        return true;
1006
 
2114 decky 1007
    uint64_t *data = (uint64_t *) malloc(sizeof(uint64_t) * cnt, 0);
2050 decky 1008
    if (data == NULL) {
1009
        printf("Error allocating memory for statistics\n");
1010
        return false;
1011
    }
1012
 
1013
    for (i = 0; i < cnt; i++) {
3065 decky 1014
        printf("%s (%u/%u) ... ", test->name, i + 1, cnt);
2050 decky 1015
 
1016
        /* Update and read thread accounting
1017
           for benchmarking */
1018
        ipl_t ipl = interrupts_disable();
1019
        spinlock_lock(&TASK->lock);
1020
        uint64_t t0 = task_get_accounting(TASK);
1021
        spinlock_unlock(&TASK->lock);
1022
        interrupts_restore(ipl);
1023
 
1024
        /* Execute the test */
1025
        char * ret = test->entry(true);
1026
 
1027
        /* Update and read thread accounting */
1028
        ipl = interrupts_disable();
1029
        spinlock_lock(&TASK->lock);
1030
        uint64_t dt = task_get_accounting(TASK) - t0;
1031
        spinlock_unlock(&TASK->lock);
1032
        interrupts_restore(ipl);
1033
 
1034
        if (ret != NULL) {
1035
            printf("%s\n", ret);
1036
            ret = false;
1037
            break;
1038
        }
1039
 
1040
        data[i] = dt;
1041
        order(dt, &cycles, &suffix);
3065 decky 1042
        printf("OK (%" PRIu64 "%c cycles)\n", cycles, suffix);
2050 decky 1043
    }
1044
 
1045
    if (ret) {
1046
        printf("\n");
1047
 
1048
        uint64_t sum = 0;
1049
 
1050
        for (i = 0; i < cnt; i++) {
1051
            sum += data[i];
1052
        }
1053
 
1054
        order(sum / (uint64_t) cnt, &cycles, &suffix);
3065 decky 1055
        printf("Average\t\t%" PRIu64 "%c\n", cycles, suffix);
2050 decky 1056
    }
1057
 
1058
    free(data);
1059
 
1060
    return ret;
1061
}
1062
 
2019 decky 1063
/** Command for returning kernel tests
1064
 *
1065
 * @param argv Argument vector.
1066
 *
1067
 * return Always 1.
1068
 */
1069
int cmd_test(cmd_arg_t *argv)
1070
{
1071
    test_t *test;
1072
 
2114 decky 1073
    if (strcmp((char *) argv->buffer, "*") == 0) {
2020 decky 1074
        for (test = tests; test->name != NULL; test++) {
1075
            if (test->safe) {
2027 decky 1076
                printf("\n");
1077
                if (!run_test(test))
1078
                    break;
2020 decky 1079
            }
2019 decky 1080
        }
2020 decky 1081
    } else {
1082
        bool fnd = false;
1083
 
1084
        for (test = tests; test->name != NULL; test++) {
2114 decky 1085
            if (strcmp(test->name, (char *) argv->buffer) == 0) {
2020 decky 1086
                fnd = true;
2027 decky 1087
                run_test(test);
2020 decky 1088
                break;
1089
            }
1090
        }
1091
 
1092
        if (!fnd)
2027 decky 1093
            printf("Unknown test\n");
2019 decky 1094
    }
1095
 
1096
    return 1;
1097
}
2050 decky 1098
 
1099
/** Command for returning kernel tests as benchmarks
1100
 *
1101
 * @param argv Argument vector.
1102
 *
1103
 * return Always 1.
1104
 */
1105
int cmd_bench(cmd_arg_t *argv)
1106
{
1107
    test_t *test;
1108
    uint32_t cnt = argv[1].intval;
1109
 
1110
    bool fnd = false;
1111
 
1112
    for (test = tests; test->name != NULL; test++) {
2114 decky 1113
        if (strcmp(test->name, (char *) argv->buffer) == 0) {
2050 decky 1114
            fnd = true;
2051 decky 1115
 
1116
            if (test->safe)
1117
                run_bench(test, cnt);
1118
            else
1119
                printf("Unsafe test\n");
1120
 
2050 decky 1121
            break;
1122
        }
1123
    }
1124
 
1125
    if (!fnd)
1126
        printf("Unknown test\n");
1127
 
1128
    return 1;
1129
}
1130
 
2020 decky 1131
#endif
2019 decky 1132
 
1888 jermar 1133
/** @}
1702 cejka 1134
 */