Subversion Repositories HelenOS

Rev

Rev 2227 | Rev 2721 | 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
 
1702 cejka 337
/* Data and methods for 'tlb' command. */
673 jermar 338
static int cmd_tlb(cmd_arg_t *argv);
339
cmd_info_t tlb_info = {
340
    .name = "tlb",
596 jermar 341
    .description = "Print TLB of current processor.",
342
    .help = NULL,
673 jermar 343
    .func = cmd_tlb,
596 jermar 344
    .argc = 0,
345
    .argv = NULL
346
};
347
 
777 palkovsky 348
static int cmd_threads(cmd_arg_t *argv);
349
static cmd_info_t threads_info = {
350
    .name = "threads",
1695 jermar 351
    .description = "List all threads.",
777 palkovsky 352
    .func = cmd_threads,
353
    .argc = 0
354
};
668 bondari 355
 
1060 palkovsky 356
static int cmd_tasks(cmd_arg_t *argv);
357
static cmd_info_t tasks_info = {
358
    .name = "tasks",
1695 jermar 359
    .description = "List all tasks.",
1060 palkovsky 360
    .func = cmd_tasks,
361
    .argc = 0
362
};
777 palkovsky 363
 
1060 palkovsky 364
 
775 palkovsky 365
static int cmd_sched(cmd_arg_t *argv);
366
static cmd_info_t sched_info = {
367
    .name = "scheduler",
1695 jermar 368
    .description = "List all scheduler information.",
775 palkovsky 369
    .func = cmd_sched,
370
    .argc = 0
371
};
372
 
759 palkovsky 373
static int cmd_slabs(cmd_arg_t *argv);
374
static cmd_info_t slabs_info = {
375
    .name = "slabs",
1695 jermar 376
    .description = "List slab caches.",
759 palkovsky 377
    .func = cmd_slabs,
378
    .argc = 0
379
};
380
 
1702 cejka 381
/* Data and methods for 'zones' command */
668 bondari 382
static int cmd_zones(cmd_arg_t *argv);
383
static cmd_info_t zones_info = {
384
    .name = "zones",
385
    .description = "List of memory zones.",
386
    .func = cmd_zones,
387
    .argc = 0
388
};
389
 
1702 cejka 390
/* Data and methods for 'ipc_task' command */
1573 palkovsky 391
static int cmd_ipc_task(cmd_arg_t *argv);
392
static cmd_arg_t ipc_task_argv = {
393
    .type = ARG_TYPE_INT,
394
};
395
static cmd_info_t ipc_task_info = {
396
    .name = "ipc_task",
1695 jermar 397
    .description = "ipc_task <taskid> Show IPC information of given task.",
1573 palkovsky 398
    .func = cmd_ipc_task,
399
    .argc = 1,
400
    .argv = &ipc_task_argv
401
};
402
 
1702 cejka 403
/* Data and methods for 'zone' command */
668 bondari 404
static int cmd_zone(cmd_arg_t *argv);
405
static cmd_arg_t zone_argv = {
406
    .type = ARG_TYPE_INT,
407
};
408
 
409
static cmd_info_t zone_info = {
410
    .name = "zone",
411
    .description = "Show memory zone structure.",
412
    .func = cmd_zone,
413
    .argc = 1,
414
    .argv = &zone_argv
415
};
416
 
1702 cejka 417
/* Data and methods for 'cpus' command. */
673 jermar 418
static int cmd_cpus(cmd_arg_t *argv);
419
cmd_info_t cpus_info = {
420
    .name = "cpus",
421
    .description = "List all processors.",
422
    .help = NULL,
423
    .func = cmd_cpus,
424
    .argc = 0,
425
    .argv = NULL
426
};
668 bondari 427
 
1702 cejka 428
/* Data and methods for 'version' command. */
673 jermar 429
static int cmd_version(cmd_arg_t *argv);
430
cmd_info_t version_info = {
431
    .name = "version",
432
    .description = "Print version information.",
433
    .help = NULL,
434
    .func = cmd_version,
435
    .argc = 0,
436
    .argv = NULL
437
};
668 bondari 438
 
775 palkovsky 439
static cmd_info_t *basic_commands[] = {
440
    &call0_info,
2223 decky 441
    &mcall0_info,
775 palkovsky 442
    &call1_info,
443
    &call2_info,
444
    &call3_info,
1474 palkovsky 445
    &continue_info,
775 palkovsky 446
    &cpus_info,
447
    &desc_info,
448
    &exit_info,
2227 decky 449
    &reboot_info,
2275 decky 450
    &uptime_info,
775 palkovsky 451
    &halt_info,
452
    &help_info,
1573 palkovsky 453
    &ipc_task_info,
775 palkovsky 454
    &set4_info,
455
    &slabs_info,
456
    &symaddr_info,
457
    &sched_info,
777 palkovsky 458
    &threads_info,
1060 palkovsky 459
    &tasks_info,
775 palkovsky 460
    &tlb_info,
461
    &version_info,
462
    &zones_info,
463
    &zone_info,
2019 decky 464
#ifdef CONFIG_TEST
465
    &tests_info,
466
    &test_info,
2050 decky 467
    &bench_info,
2019 decky 468
#endif
775 palkovsky 469
    NULL
470
};
673 jermar 471
 
472
 
596 jermar 473
/** Initialize command info structure.
474
 *
475
 * @param cmd Command info structure.
476
 *
477
 */
478
void cmd_initialize(cmd_info_t *cmd)
479
{
480
    spinlock_initialize(&cmd->lock, "cmd");
481
    link_initialize(&cmd->link);
482
}
483
 
484
/** Initialize and register commands. */
485
void cmd_init(void)
486
{
775 palkovsky 487
    int i;
596 jermar 488
 
775 palkovsky 489
    for (i=0;basic_commands[i]; i++) {
490
        cmd_initialize(basic_commands[i]);
491
        if (!cmd_register(basic_commands[i]))
492
            panic("could not register command %s\n",
493
                  basic_commands[i]->name);
494
    }
596 jermar 495
}
496
 
497
 
498
/** List supported commands.
499
 *
500
 * @param argv Argument vector.
501
 *
502
 * @return 0 on failure, 1 on success.
503
 */
504
int cmd_help(cmd_arg_t *argv)
505
{
506
    link_t *cur;
507
 
508
    spinlock_lock(&cmd_lock);
509
 
510
    for (cur = cmd_head.next; cur != &cmd_head; cur = cur->next) {
511
        cmd_info_t *hlp;
512
 
513
        hlp = list_get_instance(cur, cmd_info_t, link);
514
        spinlock_lock(&hlp->lock);
515
 
516
        printf("%s - %s\n", hlp->name, hlp->description);
517
 
518
        spinlock_unlock(&hlp->lock);
519
    }
520
 
521
    spinlock_unlock(&cmd_lock);
522
 
523
    return 1;
524
}
525
 
2227 decky 526
 
527
/** Reboot the system.
528
 *
529
 * @param argv Argument vector.
530
 *
531
 * @return 0 on failure, 1 on success.
532
 */
533
int cmd_reboot(cmd_arg_t *argv)
534
{
535
    reboot();
536
 
537
    /* Not reached */
538
    return 1;
539
}
540
 
2275 decky 541
 
542
/** Print system uptime information.
543
 *
544
 * @param argv Argument vector.
545
 *
546
 * @return 0 on failure, 1 on success.
547
 */
548
int cmd_uptime(cmd_arg_t *argv)
549
{
550
    ASSERT(uptime);
551
 
552
    /* This doesn't have to be very accurate */
553
    unative_t sec = uptime->seconds1;
554
 
555
    printf("Up %u days, %u hours, %u minutes, %u seconds\n",
556
        sec / 86400, (sec % 86400) / 3600, (sec % 3600) / 60, sec % 60);
557
 
558
    return 1;
559
}
560
 
596 jermar 561
/** Describe specified command.
562
 *
563
 * @param argv Argument vector.
564
 *
565
 * @return 0 on failure, 1 on success.
566
 */
567
int cmd_desc(cmd_arg_t *argv)
568
{
569
    link_t *cur;
570
 
571
    spinlock_lock(&cmd_lock);
572
 
573
    for (cur = cmd_head.next; cur != &cmd_head; cur = cur->next) {
574
        cmd_info_t *hlp;
575
 
576
        hlp = list_get_instance(cur, cmd_info_t, link);
577
        spinlock_lock(&hlp->lock);
578
 
579
        if (strncmp(hlp->name, (const char *) argv->buffer, strlen(hlp->name)) == 0) {
580
            printf("%s - %s\n", hlp->name, hlp->description);
581
            if (hlp->help)
582
                hlp->help();
583
            spinlock_unlock(&hlp->lock);
584
            break;
585
        }
586
 
587
        spinlock_unlock(&hlp->lock);
588
    }
589
 
590
    spinlock_unlock(&cmd_lock);
591
 
592
    return 1;
593
}
594
 
595
/** Search symbol table */
596
int cmd_symaddr(cmd_arg_t *argv)
597
{
2114 decky 598
    symtab_print_search((char *) argv->buffer);
596 jermar 599
 
600
    return 1;
601
}
602
 
603
/** Call function with zero parameters */
604
int cmd_call0(cmd_arg_t *argv)
605
{
1780 jermar 606
    uintptr_t symaddr;
596 jermar 607
    char *symbol;
1780 jermar 608
    unative_t (*f)(void);
1666 palkovsky 609
#ifdef ia64
610
    struct {
1780 jermar 611
        unative_t f;
612
        unative_t gp;
2223 decky 613
    } fptr;
1666 palkovsky 614
#endif
596 jermar 615
 
2114 decky 616
    symaddr = get_symbol_addr((char *) argv->buffer);
596 jermar 617
    if (!symaddr)
618
        printf("Symbol %s not found.\n", argv->buffer);
1780 jermar 619
    else if (symaddr == (uintptr_t) -1) {
2114 decky 620
        symtab_print_search((char *) argv->buffer);
596 jermar 621
        printf("Duplicate symbol, be more specific.\n");
622
    } else {
623
        symbol = get_symtab_entry(symaddr);
2223 decky 624
        printf("Calling %s() (%.*p)\n", symbol, sizeof(uintptr_t) * 2, symaddr);
1666 palkovsky 625
#ifdef ia64
626
        fptr.f = symaddr;
1780 jermar 627
        fptr.gp = ((unative_t *)cmd_call2)[1];
628
        f =  (unative_t (*)(void)) &fptr;
1666 palkovsky 629
#else
1780 jermar 630
        f =  (unative_t (*)(void)) symaddr;
1666 palkovsky 631
#endif
1224 cejka 632
        printf("Result: %#zx\n", f());
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++) {
648
        thread_t *t;
649
        if ((t = thread_create((void (*)(void *)) cmd_call0, (void *) argv, TASK, THREAD_FLAG_WIRED, "call0", false))) {
650
            spinlock_lock(&t->lock);
651
            t->cpu = &cpus[i];
652
            spinlock_unlock(&t->lock);
653
            printf("cpu%u: ", i);
654
            thread_ready(t);
655
            thread_join(t);
2224 decky 656
            thread_detach(t);
2223 decky 657
        } else
658
            printf("Unable to create thread for cpu%u\n", i);
659
    }
660
 
661
    return 1;
662
}
663
 
596 jermar 664
/** Call function with one parameter */
665
int cmd_call1(cmd_arg_t *argv)
666
{
1780 jermar 667
    uintptr_t symaddr;
596 jermar 668
    char *symbol;
1780 jermar 669
    unative_t (*f)(unative_t,...);
670
    unative_t arg1 = argv[1].intval;
1666 palkovsky 671
#ifdef ia64
672
    struct {
1780 jermar 673
        unative_t f;
674
        unative_t gp;
1666 palkovsky 675
    }fptr;
676
#endif
596 jermar 677
 
2114 decky 678
    symaddr = get_symbol_addr((char *) argv->buffer);
596 jermar 679
    if (!symaddr)
680
        printf("Symbol %s not found.\n", argv->buffer);
1780 jermar 681
    else if (symaddr == (uintptr_t) -1) {
2114 decky 682
        symtab_print_search((char *) argv->buffer);
596 jermar 683
        printf("Duplicate symbol, be more specific.\n");
684
    } else {
685
        symbol = get_symtab_entry(symaddr);
1666 palkovsky 686
 
1780 jermar 687
        printf("Calling f(%#zx): %.*p: %s\n", arg1, sizeof(uintptr_t) * 2, symaddr, symbol);
1666 palkovsky 688
#ifdef ia64
689
        fptr.f = symaddr;
1780 jermar 690
        fptr.gp = ((unative_t *)cmd_call2)[1];
691
        f =  (unative_t (*)(unative_t,...)) &fptr;
1666 palkovsky 692
#else
1780 jermar 693
        f =  (unative_t (*)(unative_t,...)) symaddr;
1666 palkovsky 694
#endif
1224 cejka 695
        printf("Result: %#zx\n", f(arg1));
596 jermar 696
    }
697
 
698
    return 1;
699
}
700
 
701
/** Call function with two parameters */
702
int cmd_call2(cmd_arg_t *argv)
703
{
1780 jermar 704
    uintptr_t symaddr;
596 jermar 705
    char *symbol;
1780 jermar 706
    unative_t (*f)(unative_t,unative_t,...);
707
    unative_t arg1 = argv[1].intval;
708
    unative_t arg2 = argv[2].intval;
1666 palkovsky 709
#ifdef ia64
710
    struct {
1780 jermar 711
        unative_t f;
712
        unative_t gp;
1666 palkovsky 713
    }fptr;
714
#endif
596 jermar 715
 
2114 decky 716
    symaddr = get_symbol_addr((char *) argv->buffer);
596 jermar 717
    if (!symaddr)
718
        printf("Symbol %s not found.\n", argv->buffer);
1780 jermar 719
    else if (symaddr == (uintptr_t) -1) {
2114 decky 720
        symtab_print_search((char *) argv->buffer);
596 jermar 721
        printf("Duplicate symbol, be more specific.\n");
722
    } else {
723
        symbol = get_symtab_entry(symaddr);
1224 cejka 724
        printf("Calling f(0x%zx,0x%zx): %.*p: %s\n",
1780 jermar 725
               arg1, arg2, sizeof(uintptr_t) * 2, symaddr, symbol);
1666 palkovsky 726
#ifdef ia64
727
        fptr.f = symaddr;
1780 jermar 728
        fptr.gp = ((unative_t *)cmd_call2)[1];
729
        f =  (unative_t (*)(unative_t,unative_t,...)) &fptr;
1666 palkovsky 730
#else
1780 jermar 731
        f =  (unative_t (*)(unative_t,unative_t,...)) symaddr;
1666 palkovsky 732
#endif
1224 cejka 733
        printf("Result: %#zx\n", f(arg1, arg2));
596 jermar 734
    }
735
 
736
    return 1;
737
}
738
 
739
/** Call function with three parameters */
740
int cmd_call3(cmd_arg_t *argv)
741
{
1780 jermar 742
    uintptr_t symaddr;
596 jermar 743
    char *symbol;
1780 jermar 744
    unative_t (*f)(unative_t,unative_t,unative_t,...);
745
    unative_t arg1 = argv[1].intval;
746
    unative_t arg2 = argv[2].intval;
747
    unative_t arg3 = argv[3].intval;
1666 palkovsky 748
#ifdef ia64
749
    struct {
1780 jermar 750
        unative_t f;
751
        unative_t gp;
1666 palkovsky 752
    }fptr;
753
#endif
596 jermar 754
 
2114 decky 755
    symaddr = get_symbol_addr((char *) argv->buffer);
596 jermar 756
    if (!symaddr)
757
        printf("Symbol %s not found.\n", argv->buffer);
1780 jermar 758
    else if (symaddr == (uintptr_t) -1) {
2114 decky 759
        symtab_print_search((char *) argv->buffer);
596 jermar 760
        printf("Duplicate symbol, be more specific.\n");
761
    } else {
762
        symbol = get_symtab_entry(symaddr);
1224 cejka 763
        printf("Calling f(0x%zx,0x%zx, 0x%zx): %.*p: %s\n",
1780 jermar 764
               arg1, arg2, arg3, sizeof(uintptr_t) * 2, symaddr, symbol);
1666 palkovsky 765
#ifdef ia64
766
        fptr.f = symaddr;
1780 jermar 767
        fptr.gp = ((unative_t *)cmd_call2)[1];
768
        f =  (unative_t (*)(unative_t,unative_t,unative_t,...)) &fptr;
1666 palkovsky 769
#else
1780 jermar 770
        f =  (unative_t (*)(unative_t,unative_t,unative_t,...)) symaddr;
1666 palkovsky 771
#endif
1224 cejka 772
        printf("Result: %#zx\n", f(arg1, arg2, arg3));
596 jermar 773
    }
774
 
775
    return 1;
776
}
777
 
778
 
779
/** Print detailed description of 'describe' command. */
780
void desc_help(void)
781
{
782
    printf("Syntax: describe command_name\n");
783
}
784
 
785
/** Halt the kernel.
786
 *
787
 * @param argv Argument vector (ignored).
788
 *
789
 * @return 0 on failure, 1 on success (never returns).
790
 */
791
int cmd_halt(cmd_arg_t *argv)
792
{
793
    halt();
794
    return 1;
795
}
796
 
797
/** Command for printing TLB contents.
798
 *
799
 * @param argv Not used.
800
 *
801
 * @return Always returns 1.
802
 */
673 jermar 803
int cmd_tlb(cmd_arg_t *argv)
596 jermar 804
{
805
    tlb_print();
806
    return 1;
807
}
603 palkovsky 808
 
809
/** Write 4 byte value to address */
810
int cmd_set4(cmd_arg_t *argv)
811
{
2216 decky 812
    uint32_t *addr;
1780 jermar 813
    uint32_t arg1 = argv[1].intval;
603 palkovsky 814
    bool pointer = false;
815
 
816
    if (((char *)argv->buffer)[0] == '*') {
2114 decky 817
        addr = (uint32_t *) get_symbol_addr((char *) argv->buffer + 1);
603 palkovsky 818
        pointer = true;
2114 decky 819
    } else if (((char *) argv->buffer)[0] >= '0' &&
603 palkovsky 820
           ((char *)argv->buffer)[0] <= '9')
1780 jermar 821
        addr = (uint32_t *)atoi((char *)argv->buffer);
603 palkovsky 822
    else
2114 decky 823
        addr = (uint32_t *)get_symbol_addr((char *) argv->buffer);
603 palkovsky 824
 
825
    if (!addr)
826
        printf("Symbol %s not found.\n", argv->buffer);
1780 jermar 827
    else if (addr == (uint32_t *) -1) {
2114 decky 828
        symtab_print_search((char *) argv->buffer);
603 palkovsky 829
        printf("Duplicate symbol, be more specific.\n");
830
    } else {
831
        if (pointer)
1780 jermar 832
            addr = (uint32_t *)(*(unative_t *)addr);
833
        printf("Writing 0x%x -> %.*p\n", arg1, sizeof(uintptr_t) * 2, addr);
603 palkovsky 834
        *addr = arg1;
835
 
836
    }
837
 
838
    return 1;
839
}
668 bondari 840
 
759 palkovsky 841
/** Command for listings SLAB caches
842
 *
843
 * @param argv Ignores
844
 *
845
 * @return Always 1
846
 */
847
int cmd_slabs(cmd_arg_t * argv) {
848
    slab_print_list();
849
    return 1;
850
}
851
 
777 palkovsky 852
 
775 palkovsky 853
/** Command for listings Thread information
854
 *
855
 * @param argv Ignores
856
 *
857
 * @return Always 1
858
 */
777 palkovsky 859
int cmd_threads(cmd_arg_t * argv) {
860
    thread_print_list();
861
    return 1;
862
}
863
 
1060 palkovsky 864
/** Command for listings Task information
865
 *
866
 * @param argv Ignores
867
 *
868
 * @return Always 1
869
 */
870
int cmd_tasks(cmd_arg_t * argv) {
871
    task_print_list();
872
    return 1;
873
}
874
 
777 palkovsky 875
/** Command for listings Thread information
876
 *
877
 * @param argv Ignores
878
 *
879
 * @return Always 1
880
 */
775 palkovsky 881
int cmd_sched(cmd_arg_t * argv) {
882
    sched_print_list();
883
    return 1;
884
}
885
 
677 bondari 886
/** Command for listing memory zones
887
 *
888
 * @param argv Ignored
889
 *
890
 * return Always 1
891
 */
668 bondari 892
int cmd_zones(cmd_arg_t * argv) {
676 bondari 893
    zone_print_list();
668 bondari 894
    return 1;
895
}
673 jermar 896
 
677 bondari 897
/** Command for memory zone details
898
 *
899
 * @param argv Integer argument from cmdline expected
900
 *
901
 * return Always 1
902
 */
668 bondari 903
int cmd_zone(cmd_arg_t * argv) {
676 bondari 904
    zone_print_one(argv[0].intval);
668 bondari 905
    return 1;
906
}
907
 
1573 palkovsky 908
/** Command for printing task ipc details
909
 *
910
 * @param argv Integer argument from cmdline expected
911
 *
912
 * return Always 1
913
 */
914
int cmd_ipc_task(cmd_arg_t * argv) {
915
    ipc_print_task(argv[0].intval);
916
    return 1;
917
}
918
 
919
 
673 jermar 920
/** Command for listing processors.
921
 *
922
 * @param argv Ignored.
923
 *
924
 * return Always 1.
925
 */
926
int cmd_cpus(cmd_arg_t *argv)
927
{
928
    cpu_list();
929
    return 1;
930
}
931
 
932
/** Command for printing kernel version.
933
 *
934
 * @param argv Ignored.
935
 *
936
 * return Always 1.
937
 */
938
int cmd_version(cmd_arg_t *argv)
939
{
940
    version_print();
941
    return 1;
942
}
1474 palkovsky 943
 
944
/** Command for returning console back to userspace.
945
 *
946
 * @param argv Ignored.
947
 *
948
 * return Always 1.
949
 */
950
int cmd_continue(cmd_arg_t *argv)
951
{
1695 jermar 952
    printf("The kernel will now relinquish the console.\n");
953
    printf("Use userspace controls to redraw the screen.\n");
1474 palkovsky 954
    arch_release_console();
955
    return 1;
956
}
1702 cejka 957
 
2020 decky 958
#ifdef CONFIG_TEST
2019 decky 959
/** Command for printing kernel tests list.
960
 *
961
 * @param argv Ignored.
962
 *
963
 * return Always 1.
964
 */
965
int cmd_tests(cmd_arg_t *argv)
966
{
967
    test_t *test;
968
 
969
    for (test = tests; test->name != NULL; test++)
2020 decky 970
        printf("%s\t\t%s%s\n", test->name, test->desc, (test->safe ? "" : " (unsafe)"));
2019 decky 971
 
2020 decky 972
    printf("*\t\tRun all safe tests\n");
2019 decky 973
    return 1;
974
}
975
 
2042 decky 976
static bool run_test(const test_t *test)
2027 decky 977
{
2042 decky 978
    printf("%s\t\t%s\n", test->name, test->desc);
2030 decky 979
 
980
    /* Update and read thread accounting
981
       for benchmarking */
982
    ipl_t ipl = interrupts_disable();
2039 decky 983
    spinlock_lock(&TASK->lock);
984
    uint64_t t0 = task_get_accounting(TASK);
985
    spinlock_unlock(&TASK->lock);
2030 decky 986
    interrupts_restore(ipl);
987
 
988
    /* Execute the test */
2050 decky 989
    char * ret = test->entry(false);
2030 decky 990
 
991
    /* Update and read thread accounting */
992
    ipl = interrupts_disable();
2039 decky 993
    spinlock_lock(&TASK->lock);
994
    uint64_t dt = task_get_accounting(TASK) - t0;
995
    spinlock_unlock(&TASK->lock);
2030 decky 996
    interrupts_restore(ipl);
997
 
2050 decky 998
    uint64_t cycles;
999
    char suffix;
1000
    order(dt, &cycles, &suffix);
1001
 
1002
    printf("Time: %llu%c cycles\n", cycles, suffix);
2027 decky 1003
 
1004
    if (ret == NULL) {
1005
        printf("Test passed\n");
2042 decky 1006
        return true;
2027 decky 1007
    }
1008
 
1009
    printf("%s\n", ret);
2042 decky 1010
    return false;
2027 decky 1011
}
1012
 
2050 decky 1013
static bool run_bench(const test_t *test, const uint32_t cnt)
1014
{
1015
    uint32_t i;
1016
    bool ret = true;
1017
    uint64_t cycles;
1018
    char suffix;
1019
 
1020
    if (cnt < 1)
1021
        return true;
1022
 
2114 decky 1023
    uint64_t *data = (uint64_t *) malloc(sizeof(uint64_t) * cnt, 0);
2050 decky 1024
    if (data == NULL) {
1025
        printf("Error allocating memory for statistics\n");
1026
        return false;
1027
    }
1028
 
1029
    for (i = 0; i < cnt; i++) {
1030
        printf("%s (%d/%d) ... ", test->name, i + 1, cnt);
1031
 
1032
        /* Update and read thread accounting
1033
           for benchmarking */
1034
        ipl_t ipl = interrupts_disable();
1035
        spinlock_lock(&TASK->lock);
1036
        uint64_t t0 = task_get_accounting(TASK);
1037
        spinlock_unlock(&TASK->lock);
1038
        interrupts_restore(ipl);
1039
 
1040
        /* Execute the test */
1041
        char * ret = test->entry(true);
1042
 
1043
        /* Update and read thread accounting */
1044
        ipl = interrupts_disable();
1045
        spinlock_lock(&TASK->lock);
1046
        uint64_t dt = task_get_accounting(TASK) - t0;
1047
        spinlock_unlock(&TASK->lock);
1048
        interrupts_restore(ipl);
1049
 
1050
        if (ret != NULL) {
1051
            printf("%s\n", ret);
1052
            ret = false;
1053
            break;
1054
        }
1055
 
1056
        data[i] = dt;
1057
        order(dt, &cycles, &suffix);
1058
        printf("OK (%llu%c cycles)\n", cycles, suffix);
1059
    }
1060
 
1061
    if (ret) {
1062
        printf("\n");
1063
 
1064
        uint64_t sum = 0;
1065
 
1066
        for (i = 0; i < cnt; i++) {
1067
            sum += data[i];
1068
        }
1069
 
1070
        order(sum / (uint64_t) cnt, &cycles, &suffix);
1071
        printf("Average\t\t%llu%c\n", cycles, suffix);
1072
    }
1073
 
1074
    free(data);
1075
 
1076
    return ret;
1077
}
1078
 
2019 decky 1079
/** Command for returning kernel tests
1080
 *
1081
 * @param argv Argument vector.
1082
 *
1083
 * return Always 1.
1084
 */
1085
int cmd_test(cmd_arg_t *argv)
1086
{
1087
    test_t *test;
1088
 
2114 decky 1089
    if (strcmp((char *) argv->buffer, "*") == 0) {
2020 decky 1090
        for (test = tests; test->name != NULL; test++) {
1091
            if (test->safe) {
2027 decky 1092
                printf("\n");
1093
                if (!run_test(test))
1094
                    break;
2020 decky 1095
            }
2019 decky 1096
        }
2020 decky 1097
    } else {
1098
        bool fnd = false;
1099
 
1100
        for (test = tests; test->name != NULL; test++) {
2114 decky 1101
            if (strcmp(test->name, (char *) argv->buffer) == 0) {
2020 decky 1102
                fnd = true;
2027 decky 1103
                run_test(test);
2020 decky 1104
                break;
1105
            }
1106
        }
1107
 
1108
        if (!fnd)
2027 decky 1109
            printf("Unknown test\n");
2019 decky 1110
    }
1111
 
1112
    return 1;
1113
}
2050 decky 1114
 
1115
/** Command for returning kernel tests as benchmarks
1116
 *
1117
 * @param argv Argument vector.
1118
 *
1119
 * return Always 1.
1120
 */
1121
int cmd_bench(cmd_arg_t *argv)
1122
{
1123
    test_t *test;
1124
    uint32_t cnt = argv[1].intval;
1125
 
1126
    bool fnd = false;
1127
 
1128
    for (test = tests; test->name != NULL; test++) {
2114 decky 1129
        if (strcmp(test->name, (char *) argv->buffer) == 0) {
2050 decky 1130
            fnd = true;
2051 decky 1131
 
1132
            if (test->safe)
1133
                run_bench(test, cnt);
1134
            else
1135
                printf("Unsafe test\n");
1136
 
2050 decky 1137
            break;
1138
        }
1139
    }
1140
 
1141
    if (!fnd)
1142
        printf("Unknown test\n");
1143
 
1144
    return 1;
1145
}
1146
 
2020 decky 1147
#endif
2019 decky 1148
 
1888 jermar 1149
/** @}
1702 cejka 1150
 */