Subversion Repositories HelenOS

Rev

Rev 3908 | Rev 4011 | 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
    spinlock_lock(&cmd_lock);
518
 
3974 decky 519
    link_t *cur;
520
    size_t len = 0;
596 jermar 521
    for (cur = cmd_head.next; cur != &cmd_head; cur = cur->next) {
522
        cmd_info_t *hlp;
3974 decky 523
        hlp = list_get_instance(cur, cmd_info_t, link);
596 jermar 524
 
3974 decky 525
        spinlock_lock(&hlp->lock);
526
        if (strlen(hlp->name) > len)
527
            len = strlen(hlp->name);
528
        spinlock_unlock(&hlp->lock);
529
    }
530
 
531
    for (cur = cmd_head.next; cur != &cmd_head; cur = cur->next) {
532
        cmd_info_t *hlp;
596 jermar 533
        hlp = list_get_instance(cur, cmd_info_t, link);
3974 decky 534
 
596 jermar 535
        spinlock_lock(&hlp->lock);
3974 decky 536
        printf("%-*s %s\n", len, hlp->name, hlp->description);
596 jermar 537
        spinlock_unlock(&hlp->lock);
538
    }
539
 
3908 decky 540
    spinlock_unlock(&cmd_lock);
3974 decky 541
 
596 jermar 542
    return 1;
543
}
544
 
2227 decky 545
 
546
/** Reboot the system.
547
 *
548
 * @param argv Argument vector.
549
 *
550
 * @return 0 on failure, 1 on success.
551
 */
552
int cmd_reboot(cmd_arg_t *argv)
553
{
554
    reboot();
555
 
556
    /* Not reached */
557
    return 1;
558
}
559
 
2275 decky 560
 
561
/** Print system uptime information.
562
 *
563
 * @param argv Argument vector.
564
 *
565
 * @return 0 on failure, 1 on success.
566
 */
567
int cmd_uptime(cmd_arg_t *argv)
568
{
569
    ASSERT(uptime);
570
 
571
    /* This doesn't have to be very accurate */
572
    unative_t sec = uptime->seconds1;
573
 
3065 decky 574
    printf("Up %" PRIun " days, %" PRIun " hours, %" PRIun " minutes, %" PRIun " seconds\n",
2275 decky 575
        sec / 86400, (sec % 86400) / 3600, (sec % 3600) / 60, sec % 60);
576
 
577
    return 1;
578
}
579
 
596 jermar 580
/** Describe specified command.
581
 *
582
 * @param argv Argument vector.
583
 *
584
 * @return 0 on failure, 1 on success.
585
 */
586
int cmd_desc(cmd_arg_t *argv)
587
{
588
    link_t *cur;
589
 
590
    spinlock_lock(&cmd_lock);
591
 
592
    for (cur = cmd_head.next; cur != &cmd_head; cur = cur->next) {
593
        cmd_info_t *hlp;
594
 
595
        hlp = list_get_instance(cur, cmd_info_t, link);
596
        spinlock_lock(&hlp->lock);
597
 
598
        if (strncmp(hlp->name, (const char *) argv->buffer, strlen(hlp->name)) == 0) {
599
            printf("%s - %s\n", hlp->name, hlp->description);
600
            if (hlp->help)
601
                hlp->help();
602
            spinlock_unlock(&hlp->lock);
603
            break;
604
        }
605
 
606
        spinlock_unlock(&hlp->lock);
607
    }
608
 
609
    spinlock_unlock(&cmd_lock);
610
 
611
    return 1;
612
}
613
 
614
/** Search symbol table */
615
int cmd_symaddr(cmd_arg_t *argv)
616
{
2114 decky 617
    symtab_print_search((char *) argv->buffer);
596 jermar 618
 
619
    return 1;
620
}
621
 
622
/** Call function with zero parameters */
623
int cmd_call0(cmd_arg_t *argv)
624
{
1780 jermar 625
    uintptr_t symaddr;
596 jermar 626
    char *symbol;
3875 decky 627
    unative_t (*fnc)(void);
628
    fncptr_t fptr;
629
 
2114 decky 630
    symaddr = get_symbol_addr((char *) argv->buffer);
596 jermar 631
    if (!symaddr)
632
        printf("Symbol %s not found.\n", argv->buffer);
1780 jermar 633
    else if (symaddr == (uintptr_t) -1) {
2114 decky 634
        symtab_print_search((char *) argv->buffer);
596 jermar 635
        printf("Duplicate symbol, be more specific.\n");
636
    } else {
637
        symbol = get_symtab_entry(symaddr);
3875 decky 638
        fnc = (unative_t (*)(void)) arch_construct_function(&fptr, (void *) symaddr, (void *) cmd_call0);
3065 decky 639
        printf("Calling %s() (%p)\n", symbol, symaddr);
3875 decky 640
        printf("Result: %#" PRIxn "\n", fnc());
596 jermar 641
    }
642
 
643
    return 1;
644
}
645
 
2223 decky 646
/** Call function with zero parameters on each CPU */
647
int cmd_mcall0(cmd_arg_t *argv)
648
{
649
    /*
650
     * For each CPU, create a thread which will
651
     * call the function.
652
     */
653
 
654
    count_t i;
655
    for (i = 0; i < config.cpu_count; i++) {
2319 decky 656
        if (!cpus[i].active)
657
            continue;
658
 
2223 decky 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);
664
            printf("cpu%u: ", i);
665
            thread_ready(t);
666
            thread_join(t);
2224 decky 667
            thread_detach(t);
2223 decky 668
        } else
669
            printf("Unable to create thread for cpu%u\n", i);
670
    }
671
 
672
    return 1;
673
}
674
 
596 jermar 675
/** Call function with one parameter */
676
int cmd_call1(cmd_arg_t *argv)
677
{
1780 jermar 678
    uintptr_t symaddr;
596 jermar 679
    char *symbol;
3875 decky 680
    unative_t (*fnc)(unative_t, ...);
1780 jermar 681
    unative_t arg1 = argv[1].intval;
3875 decky 682
    fncptr_t fptr;
683
 
2114 decky 684
    symaddr = get_symbol_addr((char *) argv->buffer);
596 jermar 685
    if (!symaddr)
686
        printf("Symbol %s not found.\n", argv->buffer);
1780 jermar 687
    else if (symaddr == (uintptr_t) -1) {
2114 decky 688
        symtab_print_search((char *) argv->buffer);
596 jermar 689
        printf("Duplicate symbol, be more specific.\n");
690
    } else {
691
        symbol = get_symtab_entry(symaddr);
3875 decky 692
        fnc = (unative_t (*)(unative_t, ...)) arch_construct_function(&fptr, (void *) symaddr, (void *) cmd_call1);
3065 decky 693
        printf("Calling f(%#" PRIxn "): %p: %s\n", arg1, symaddr, symbol);
3875 decky 694
        printf("Result: %#" PRIxn "\n", fnc(arg1));
596 jermar 695
    }
696
 
697
    return 1;
698
}
699
 
700
/** Call function with two parameters */
701
int cmd_call2(cmd_arg_t *argv)
702
{
1780 jermar 703
    uintptr_t symaddr;
596 jermar 704
    char *symbol;
3875 decky 705
    unative_t (*fnc)(unative_t, unative_t, ...);
1780 jermar 706
    unative_t arg1 = argv[1].intval;
707
    unative_t arg2 = argv[2].intval;
3875 decky 708
    fncptr_t fptr;
709
 
2114 decky 710
    symaddr = get_symbol_addr((char *) argv->buffer);
596 jermar 711
    if (!symaddr)
712
        printf("Symbol %s not found.\n", argv->buffer);
1780 jermar 713
    else if (symaddr == (uintptr_t) -1) {
2114 decky 714
        symtab_print_search((char *) argv->buffer);
596 jermar 715
        printf("Duplicate symbol, be more specific.\n");
716
    } else {
717
        symbol = get_symtab_entry(symaddr);
3875 decky 718
        fnc = (unative_t (*)(unative_t, unative_t, ...)) arch_construct_function(&fptr, (void *) symaddr, (void *) cmd_call2);
3065 decky 719
        printf("Calling f(%#" PRIxn ", %#" PRIxn "): %p: %s\n",
720
               arg1, arg2, symaddr, symbol);
3875 decky 721
        printf("Result: %#" PRIxn "\n", fnc(arg1, arg2));
596 jermar 722
    }
723
 
724
    return 1;
725
}
726
 
727
/** Call function with three parameters */
728
int cmd_call3(cmd_arg_t *argv)
729
{
1780 jermar 730
    uintptr_t symaddr;
596 jermar 731
    char *symbol;
3875 decky 732
    unative_t (*fnc)(unative_t, unative_t, unative_t, ...);
1780 jermar 733
    unative_t arg1 = argv[1].intval;
734
    unative_t arg2 = argv[2].intval;
735
    unative_t arg3 = argv[3].intval;
3875 decky 736
    fncptr_t fptr;
737
 
2114 decky 738
    symaddr = get_symbol_addr((char *) argv->buffer);
596 jermar 739
    if (!symaddr)
740
        printf("Symbol %s not found.\n", argv->buffer);
1780 jermar 741
    else if (symaddr == (uintptr_t) -1) {
2114 decky 742
        symtab_print_search((char *) argv->buffer);
596 jermar 743
        printf("Duplicate symbol, be more specific.\n");
744
    } else {
745
        symbol = get_symtab_entry(symaddr);
3875 decky 746
        fnc = (unative_t (*)(unative_t, unative_t, unative_t, ...)) arch_construct_function(&fptr, (void *) symaddr, (void *) cmd_call3);
3065 decky 747
        printf("Calling f(%#" PRIxn ",%#" PRIxn ", %#" PRIxn "): %p: %s\n",
748
               arg1, arg2, arg3, symaddr, symbol);
3875 decky 749
        printf("Result: %#" PRIxn "\n", fnc(arg1, arg2, arg3));
596 jermar 750
    }
751
 
752
    return 1;
753
}
754
 
755
 
756
/** Print detailed description of 'describe' command. */
757
void desc_help(void)
758
{
759
    printf("Syntax: describe command_name\n");
760
}
761
 
762
/** Halt the kernel.
763
 *
764
 * @param argv Argument vector (ignored).
765
 *
766
 * @return 0 on failure, 1 on success (never returns).
767
 */
768
int cmd_halt(cmd_arg_t *argv)
769
{
770
    halt();
771
    return 1;
772
}
773
 
774
/** Command for printing TLB contents.
775
 *
776
 * @param argv Not used.
777
 *
778
 * @return Always returns 1.
779
 */
673 jermar 780
int cmd_tlb(cmd_arg_t *argv)
596 jermar 781
{
782
    tlb_print();
783
    return 1;
784
}
603 palkovsky 785
 
2721 decky 786
/** Command for printing physical memory configuration.
787
 *
788
 * @param argv Not used.
789
 *
790
 * @return Always returns 1.
791
 */
792
int cmd_physmem(cmd_arg_t *argv)
793
{
794
    physmem_print();
795
    return 1;
796
}
797
 
603 palkovsky 798
/** Write 4 byte value to address */
799
int cmd_set4(cmd_arg_t *argv)
800
{
2216 decky 801
    uint32_t *addr;
1780 jermar 802
    uint32_t arg1 = argv[1].intval;
603 palkovsky 803
    bool pointer = false;
804
 
805
    if (((char *)argv->buffer)[0] == '*') {
2114 decky 806
        addr = (uint32_t *) get_symbol_addr((char *) argv->buffer + 1);
603 palkovsky 807
        pointer = true;
2114 decky 808
    } else if (((char *) argv->buffer)[0] >= '0' &&
603 palkovsky 809
           ((char *)argv->buffer)[0] <= '9')
1780 jermar 810
        addr = (uint32_t *)atoi((char *)argv->buffer);
603 palkovsky 811
    else
2114 decky 812
        addr = (uint32_t *)get_symbol_addr((char *) argv->buffer);
603 palkovsky 813
 
814
    if (!addr)
815
        printf("Symbol %s not found.\n", argv->buffer);
1780 jermar 816
    else if (addr == (uint32_t *) -1) {
2114 decky 817
        symtab_print_search((char *) argv->buffer);
603 palkovsky 818
        printf("Duplicate symbol, be more specific.\n");
819
    } else {
820
        if (pointer)
1780 jermar 821
            addr = (uint32_t *)(*(unative_t *)addr);
3065 decky 822
        printf("Writing %#" PRIx64 " -> %p\n", arg1, addr);
603 palkovsky 823
        *addr = arg1;
824
 
825
    }
826
 
827
    return 1;
828
}
668 bondari 829
 
759 palkovsky 830
/** Command for listings SLAB caches
831
 *
832
 * @param argv Ignores
833
 *
834
 * @return Always 1
835
 */
836
int cmd_slabs(cmd_arg_t * argv) {
837
    slab_print_list();
838
    return 1;
839
}
840
 
777 palkovsky 841
 
775 palkovsky 842
/** Command for listings Thread information
843
 *
844
 * @param argv Ignores
845
 *
846
 * @return Always 1
847
 */
777 palkovsky 848
int cmd_threads(cmd_arg_t * argv) {
849
    thread_print_list();
850
    return 1;
851
}
852
 
1060 palkovsky 853
/** Command for listings Task information
854
 *
855
 * @param argv Ignores
856
 *
857
 * @return Always 1
858
 */
859
int cmd_tasks(cmd_arg_t * argv) {
860
    task_print_list();
861
    return 1;
862
}
863
 
777 palkovsky 864
/** Command for listings Thread information
865
 *
866
 * @param argv Ignores
867
 *
868
 * @return Always 1
869
 */
775 palkovsky 870
int cmd_sched(cmd_arg_t * argv) {
871
    sched_print_list();
872
    return 1;
873
}
874
 
677 bondari 875
/** Command for listing memory zones
876
 *
877
 * @param argv Ignored
878
 *
879
 * return Always 1
880
 */
668 bondari 881
int cmd_zones(cmd_arg_t * argv) {
676 bondari 882
    zone_print_list();
668 bondari 883
    return 1;
884
}
673 jermar 885
 
677 bondari 886
/** Command for memory zone details
887
 *
888
 * @param argv Integer argument from cmdline expected
889
 *
890
 * return Always 1
891
 */
668 bondari 892
int cmd_zone(cmd_arg_t * argv) {
676 bondari 893
    zone_print_one(argv[0].intval);
668 bondari 894
    return 1;
895
}
896
 
1573 palkovsky 897
/** Command for printing task ipc details
898
 *
899
 * @param argv Integer argument from cmdline expected
900
 *
901
 * return Always 1
902
 */
3451 jermar 903
int cmd_ipc(cmd_arg_t * argv) {
1573 palkovsky 904
    ipc_print_task(argv[0].intval);
905
    return 1;
906
}
907
 
908
 
673 jermar 909
/** Command for listing processors.
910
 *
911
 * @param argv Ignored.
912
 *
913
 * return Always 1.
914
 */
915
int cmd_cpus(cmd_arg_t *argv)
916
{
917
    cpu_list();
918
    return 1;
919
}
920
 
921
/** Command for printing kernel version.
922
 *
923
 * @param argv Ignored.
924
 *
925
 * return Always 1.
926
 */
927
int cmd_version(cmd_arg_t *argv)
928
{
929
    version_print();
930
    return 1;
931
}
1474 palkovsky 932
 
933
/** Command for returning console back to userspace.
934
 *
935
 * @param argv Ignored.
936
 *
937
 * return Always 1.
938
 */
939
int cmd_continue(cmd_arg_t *argv)
940
{
1695 jermar 941
    printf("The kernel will now relinquish the console.\n");
3844 decky 942
    release_console();
3761 decky 943
 
944
    if ((kconsole_notify) && (kconsole_irq.notif_cfg.notify))
945
        ipc_irq_send_msg_0(&kconsole_irq);
946
 
1474 palkovsky 947
    return 1;
948
}
1702 cejka 949
 
2020 decky 950
#ifdef CONFIG_TEST
2019 decky 951
/** Command for printing kernel tests list.
952
 *
953
 * @param argv Ignored.
954
 *
955
 * return Always 1.
956
 */
957
int cmd_tests(cmd_arg_t *argv)
958
{
3974 decky 959
    size_t len = 0;
2019 decky 960
    test_t *test;
3974 decky 961
    for (test = tests; test->name != NULL; test++) {
962
        if (strlen(test->name) > len)
963
            len = strlen(test->name);
964
    }
2019 decky 965
 
966
    for (test = tests; test->name != NULL; test++)
3974 decky 967
        printf("%-*s %s%s\n", len, test->name, test->desc, (test->safe ? "" : " (unsafe)"));
2019 decky 968
 
3974 decky 969
    printf("%-*s Run all safe tests\n", len, "*");
2019 decky 970
    return 1;
971
}
972
 
2042 decky 973
static bool run_test(const test_t *test)
2027 decky 974
{
3974 decky 975
    printf("%s (%s)\n", test->name, test->desc);
2030 decky 976
 
977
    /* Update and read thread accounting
978
       for benchmarking */
979
    ipl_t ipl = interrupts_disable();
2039 decky 980
    spinlock_lock(&TASK->lock);
981
    uint64_t t0 = task_get_accounting(TASK);
982
    spinlock_unlock(&TASK->lock);
2030 decky 983
    interrupts_restore(ipl);
984
 
985
    /* Execute the test */
2050 decky 986
    char * ret = test->entry(false);
2030 decky 987
 
988
    /* Update and read thread accounting */
989
    ipl = interrupts_disable();
2039 decky 990
    spinlock_lock(&TASK->lock);
991
    uint64_t dt = task_get_accounting(TASK) - t0;
992
    spinlock_unlock(&TASK->lock);
2030 decky 993
    interrupts_restore(ipl);
994
 
2050 decky 995
    uint64_t cycles;
996
    char suffix;
997
    order(dt, &cycles, &suffix);
998
 
3065 decky 999
    printf("Time: %" PRIu64 "%c cycles\n", cycles, suffix);
2027 decky 1000
 
1001
    if (ret == NULL) {
1002
        printf("Test passed\n");
2042 decky 1003
        return true;
2027 decky 1004
    }
1005
 
1006
    printf("%s\n", ret);
2042 decky 1007
    return false;
2027 decky 1008
}
1009
 
2050 decky 1010
static bool run_bench(const test_t *test, const uint32_t cnt)
1011
{
1012
    uint32_t i;
1013
    bool ret = true;
1014
    uint64_t cycles;
1015
    char suffix;
1016
 
1017
    if (cnt < 1)
1018
        return true;
1019
 
2114 decky 1020
    uint64_t *data = (uint64_t *) malloc(sizeof(uint64_t) * cnt, 0);
2050 decky 1021
    if (data == NULL) {
1022
        printf("Error allocating memory for statistics\n");
1023
        return false;
1024
    }
1025
 
1026
    for (i = 0; i < cnt; i++) {
3065 decky 1027
        printf("%s (%u/%u) ... ", test->name, i + 1, cnt);
2050 decky 1028
 
1029
        /* Update and read thread accounting
1030
           for benchmarking */
1031
        ipl_t ipl = interrupts_disable();
1032
        spinlock_lock(&TASK->lock);
1033
        uint64_t t0 = task_get_accounting(TASK);
1034
        spinlock_unlock(&TASK->lock);
1035
        interrupts_restore(ipl);
1036
 
1037
        /* Execute the test */
1038
        char * ret = test->entry(true);
1039
 
1040
        /* Update and read thread accounting */
1041
        ipl = interrupts_disable();
1042
        spinlock_lock(&TASK->lock);
1043
        uint64_t dt = task_get_accounting(TASK) - t0;
1044
        spinlock_unlock(&TASK->lock);
1045
        interrupts_restore(ipl);
1046
 
1047
        if (ret != NULL) {
1048
            printf("%s\n", ret);
1049
            ret = false;
1050
            break;
1051
        }
1052
 
1053
        data[i] = dt;
1054
        order(dt, &cycles, &suffix);
3065 decky 1055
        printf("OK (%" PRIu64 "%c cycles)\n", cycles, suffix);
2050 decky 1056
    }
1057
 
1058
    if (ret) {
1059
        printf("\n");
1060
 
1061
        uint64_t sum = 0;
1062
 
1063
        for (i = 0; i < cnt; i++) {
1064
            sum += data[i];
1065
        }
1066
 
1067
        order(sum / (uint64_t) cnt, &cycles, &suffix);
3065 decky 1068
        printf("Average\t\t%" PRIu64 "%c\n", cycles, suffix);
2050 decky 1069
    }
1070
 
1071
    free(data);
1072
 
1073
    return ret;
1074
}
1075
 
2019 decky 1076
/** Command for returning kernel tests
1077
 *
1078
 * @param argv Argument vector.
1079
 *
1080
 * return Always 1.
1081
 */
1082
int cmd_test(cmd_arg_t *argv)
1083
{
1084
    test_t *test;
1085
 
2114 decky 1086
    if (strcmp((char *) argv->buffer, "*") == 0) {
2020 decky 1087
        for (test = tests; test->name != NULL; test++) {
1088
            if (test->safe) {
2027 decky 1089
                printf("\n");
1090
                if (!run_test(test))
1091
                    break;
2020 decky 1092
            }
2019 decky 1093
        }
2020 decky 1094
    } else {
1095
        bool fnd = false;
1096
 
1097
        for (test = tests; test->name != NULL; test++) {
2114 decky 1098
            if (strcmp(test->name, (char *) argv->buffer) == 0) {
2020 decky 1099
                fnd = true;
2027 decky 1100
                run_test(test);
2020 decky 1101
                break;
1102
            }
1103
        }
1104
 
1105
        if (!fnd)
2027 decky 1106
            printf("Unknown test\n");
2019 decky 1107
    }
1108
 
1109
    return 1;
1110
}
2050 decky 1111
 
1112
/** Command for returning kernel tests as benchmarks
1113
 *
1114
 * @param argv Argument vector.
1115
 *
1116
 * return Always 1.
1117
 */
1118
int cmd_bench(cmd_arg_t *argv)
1119
{
1120
    test_t *test;
1121
    uint32_t cnt = argv[1].intval;
1122
 
1123
    bool fnd = false;
1124
 
1125
    for (test = tests; test->name != NULL; test++) {
2114 decky 1126
        if (strcmp(test->name, (char *) argv->buffer) == 0) {
2050 decky 1127
            fnd = true;
2051 decky 1128
 
1129
            if (test->safe)
1130
                run_bench(test, cnt);
1131
            else
1132
                printf("Unsafe test\n");
1133
 
2050 decky 1134
            break;
1135
        }
1136
    }
1137
 
1138
    if (!fnd)
1139
        printf("Unknown test\n");
1140
 
1141
    return 1;
1142
}
1143
 
2020 decky 1144
#endif
2019 decky 1145
 
1888 jermar 1146
/** @}
1702 cejka 1147
 */