Subversion Repositories HelenOS-historic

Rev

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

Rev Author Line No. Line
596 jermar 1
/*
2
 * Copyright (C) 2005 Jakub 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
 
1702 cejka 29
 /** @addtogroup genericconsole
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 <typedefs.h>
49
#include <arch/types.h>
788 jermar 50
#include <adt/list.h>
596 jermar 51
#include <arch.h>
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>
596 jermar 66
 
1702 cejka 67
/* Data and methods for 'help' command. */
596 jermar 68
static int cmd_help(cmd_arg_t *argv);
69
static cmd_info_t help_info = {
70
    .name = "help",
71
    .description = "List of supported commands.",
72
    .func = cmd_help,
73
    .argc = 0
74
};
75
 
609 palkovsky 76
static cmd_info_t exit_info = {
77
    .name = "exit",
78
    .description ="Exit kconsole",
79
    .argc = 0
80
};
81
 
1474 palkovsky 82
static int cmd_continue(cmd_arg_t *argv);
83
static cmd_info_t continue_info = {
84
    .name = "continue",
1695 jermar 85
    .description ="Return console back to userspace.",
1474 palkovsky 86
    .func = cmd_continue,
87
    .argc = 0
88
};
89
 
1702 cejka 90
/* Data and methods for 'description' command. */
596 jermar 91
static int cmd_desc(cmd_arg_t *argv);
92
static void desc_help(void);
93
static char desc_buf[MAX_CMDLINE+1];
94
static cmd_arg_t desc_argv = {
95
    .type = ARG_TYPE_STRING,
96
    .buffer = desc_buf,
97
    .len = sizeof(desc_buf)
98
};
99
static cmd_info_t desc_info = {
100
    .name = "describe",
101
    .description = "Describe specified command.",
102
    .help = desc_help,
103
    .func = cmd_desc,
104
    .argc = 1,
105
    .argv = &desc_argv
106
};
107
 
1702 cejka 108
/* Data and methods for 'symaddr' command. */
596 jermar 109
static int cmd_symaddr(cmd_arg_t *argv);
110
static char symaddr_buf[MAX_CMDLINE+1];
111
static cmd_arg_t symaddr_argv = {
112
    .type = ARG_TYPE_STRING,
113
    .buffer = symaddr_buf,
114
    .len = sizeof(symaddr_buf)
115
};
116
static cmd_info_t symaddr_info = {
117
    .name = "symaddr",
118
    .description = "Return symbol address.",
119
    .func = cmd_symaddr,
120
    .argc = 1,
121
    .argv = &symaddr_argv
122
};
123
 
603 palkovsky 124
static char set_buf[MAX_CMDLINE+1];
125
static int cmd_set4(cmd_arg_t *argv);
126
static cmd_arg_t set4_argv[] = {
127
    {
128
        .type = ARG_TYPE_STRING,
129
        .buffer = set_buf,
130
        .len = sizeof(set_buf)
131
    },
132
    {
133
        .type = ARG_TYPE_INT
134
    }
135
};
136
static cmd_info_t set4_info = {
137
    .name = "set4",
138
    .description = "set <dest_addr> <value> - 4byte version",
139
    .func = cmd_set4,
140
    .argc = 2,
141
    .argv = set4_argv
142
};
143
 
1702 cejka 144
/* Data and methods for 'call0' command. */
596 jermar 145
static char call0_buf[MAX_CMDLINE+1];
146
static char carg1_buf[MAX_CMDLINE+1];
147
static char carg2_buf[MAX_CMDLINE+1];
148
static char carg3_buf[MAX_CMDLINE+1];
149
 
150
static int cmd_call0(cmd_arg_t *argv);
151
static cmd_arg_t call0_argv = {
152
    .type = ARG_TYPE_STRING,
153
    .buffer = call0_buf,
154
    .len = sizeof(call0_buf)
155
};
156
static cmd_info_t call0_info = {
157
    .name = "call0",
158
    .description = "call0 <function> -> call function().",
159
    .func = cmd_call0,
160
    .argc = 1,
161
    .argv = &call0_argv
162
};
163
 
1702 cejka 164
/* Data and methods for 'call1' command. */
596 jermar 165
static int cmd_call1(cmd_arg_t *argv);
166
static cmd_arg_t call1_argv[] = {
167
    {
168
        .type = ARG_TYPE_STRING,
169
        .buffer = call0_buf,
170
        .len = sizeof(call0_buf)
171
    },
172
    {
173
        .type = ARG_TYPE_VAR,
174
        .buffer = carg1_buf,
175
        .len = sizeof(carg1_buf)
176
    }
177
};
178
static cmd_info_t call1_info = {
179
    .name = "call1",
180
    .description = "call1 <function> <arg1> -> call function(arg1).",
181
    .func = cmd_call1,
182
    .argc = 2,
183
    .argv = call1_argv
184
};
185
 
1702 cejka 186
/* Data and methods for 'call2' command. */
596 jermar 187
static int cmd_call2(cmd_arg_t *argv);
188
static cmd_arg_t call2_argv[] = {
189
    {
190
        .type = ARG_TYPE_STRING,
191
        .buffer = call0_buf,
192
        .len = sizeof(call0_buf)
193
    },
194
    {
195
        .type = ARG_TYPE_VAR,
196
        .buffer = carg1_buf,
197
        .len = sizeof(carg1_buf)
198
    },
199
    {
200
        .type = ARG_TYPE_VAR,
201
        .buffer = carg2_buf,
202
        .len = sizeof(carg2_buf)
203
    }
204
};
205
static cmd_info_t call2_info = {
206
    .name = "call2",
207
    .description = "call2 <function> <arg1> <arg2> -> call function(arg1,arg2).",
208
    .func = cmd_call2,
209
    .argc = 3,
210
    .argv = call2_argv
211
};
212
 
1702 cejka 213
/* Data and methods for 'call3' command. */
596 jermar 214
static int cmd_call3(cmd_arg_t *argv);
215
static cmd_arg_t call3_argv[] = {
216
    {
217
        .type = ARG_TYPE_STRING,
218
        .buffer = call0_buf,
219
        .len = sizeof(call0_buf)
220
    },
221
    {
222
        .type = ARG_TYPE_VAR,
223
        .buffer = carg1_buf,
224
        .len = sizeof(carg1_buf)
225
    },
226
    {
227
        .type = ARG_TYPE_VAR,
228
        .buffer = carg2_buf,
229
        .len = sizeof(carg2_buf)
230
    },
231
    {
232
        .type = ARG_TYPE_VAR,
233
        .buffer = carg3_buf,
234
        .len = sizeof(carg3_buf)
235
    }
236
 
237
};
238
static cmd_info_t call3_info = {
239
    .name = "call3",
240
    .description = "call3 <function> <arg1> <arg2> <arg3> -> call function(arg1,arg2,arg3).",
241
    .func = cmd_call3,
242
    .argc = 4,
243
    .argv = call3_argv
244
};
245
 
1702 cejka 246
/* Data and methods for 'halt' command. */
596 jermar 247
static int cmd_halt(cmd_arg_t *argv);
248
static cmd_info_t halt_info = {
249
    .name = "halt",
250
    .description = "Halt the kernel.",
251
    .func = cmd_halt,
252
    .argc = 0
253
};
254
 
1702 cejka 255
/* Data and methods for 'tlb' command. */
673 jermar 256
static int cmd_tlb(cmd_arg_t *argv);
257
cmd_info_t tlb_info = {
258
    .name = "tlb",
596 jermar 259
    .description = "Print TLB of current processor.",
260
    .help = NULL,
673 jermar 261
    .func = cmd_tlb,
596 jermar 262
    .argc = 0,
263
    .argv = NULL
264
};
265
 
777 palkovsky 266
static int cmd_threads(cmd_arg_t *argv);
267
static cmd_info_t threads_info = {
268
    .name = "threads",
1695 jermar 269
    .description = "List all threads.",
777 palkovsky 270
    .func = cmd_threads,
271
    .argc = 0
272
};
668 bondari 273
 
1060 palkovsky 274
static int cmd_tasks(cmd_arg_t *argv);
275
static cmd_info_t tasks_info = {
276
    .name = "tasks",
1695 jermar 277
    .description = "List all tasks.",
1060 palkovsky 278
    .func = cmd_tasks,
279
    .argc = 0
280
};
777 palkovsky 281
 
1060 palkovsky 282
 
775 palkovsky 283
static int cmd_sched(cmd_arg_t *argv);
284
static cmd_info_t sched_info = {
285
    .name = "scheduler",
1695 jermar 286
    .description = "List all scheduler information.",
775 palkovsky 287
    .func = cmd_sched,
288
    .argc = 0
289
};
290
 
759 palkovsky 291
static int cmd_slabs(cmd_arg_t *argv);
292
static cmd_info_t slabs_info = {
293
    .name = "slabs",
1695 jermar 294
    .description = "List slab caches.",
759 palkovsky 295
    .func = cmd_slabs,
296
    .argc = 0
297
};
298
 
1702 cejka 299
/* Data and methods for 'zones' command */
668 bondari 300
static int cmd_zones(cmd_arg_t *argv);
301
static cmd_info_t zones_info = {
302
    .name = "zones",
303
    .description = "List of memory zones.",
304
    .func = cmd_zones,
305
    .argc = 0
306
};
307
 
1702 cejka 308
/* Data and methods for 'ipc_task' command */
1573 palkovsky 309
static int cmd_ipc_task(cmd_arg_t *argv);
310
static cmd_arg_t ipc_task_argv = {
311
    .type = ARG_TYPE_INT,
312
};
313
static cmd_info_t ipc_task_info = {
314
    .name = "ipc_task",
1695 jermar 315
    .description = "ipc_task <taskid> Show IPC information of given task.",
1573 palkovsky 316
    .func = cmd_ipc_task,
317
    .argc = 1,
318
    .argv = &ipc_task_argv
319
};
320
 
1702 cejka 321
/* Data and methods for 'zone' command */
668 bondari 322
static int cmd_zone(cmd_arg_t *argv);
323
static cmd_arg_t zone_argv = {
324
    .type = ARG_TYPE_INT,
325
};
326
 
327
static cmd_info_t zone_info = {
328
    .name = "zone",
329
    .description = "Show memory zone structure.",
330
    .func = cmd_zone,
331
    .argc = 1,
332
    .argv = &zone_argv
333
};
334
 
1702 cejka 335
/* Data and methods for 'cpus' command. */
673 jermar 336
static int cmd_cpus(cmd_arg_t *argv);
337
cmd_info_t cpus_info = {
338
    .name = "cpus",
339
    .description = "List all processors.",
340
    .help = NULL,
341
    .func = cmd_cpus,
342
    .argc = 0,
343
    .argv = NULL
344
};
668 bondari 345
 
1702 cejka 346
/* Data and methods for 'version' command. */
673 jermar 347
static int cmd_version(cmd_arg_t *argv);
348
cmd_info_t version_info = {
349
    .name = "version",
350
    .description = "Print version information.",
351
    .help = NULL,
352
    .func = cmd_version,
353
    .argc = 0,
354
    .argv = NULL
355
};
668 bondari 356
 
775 palkovsky 357
static cmd_info_t *basic_commands[] = {
358
    &call0_info,
359
    &call1_info,
360
    &call2_info,
361
    &call3_info,
1474 palkovsky 362
    &continue_info,
775 palkovsky 363
    &cpus_info,
364
    &desc_info,
365
    &exit_info,
366
    &halt_info,
367
    &help_info,
1573 palkovsky 368
    &ipc_task_info,
775 palkovsky 369
    &set4_info,
370
    &slabs_info,
371
    &symaddr_info,
372
    &sched_info,
777 palkovsky 373
    &threads_info,
1060 palkovsky 374
    &tasks_info,
775 palkovsky 375
    &tlb_info,
376
    &version_info,
377
    &zones_info,
378
    &zone_info,
379
    NULL
380
};
673 jermar 381
 
382
 
596 jermar 383
/** Initialize command info structure.
384
 *
385
 * @param cmd Command info structure.
386
 *
387
 */
388
void cmd_initialize(cmd_info_t *cmd)
389
{
390
    spinlock_initialize(&cmd->lock, "cmd");
391
    link_initialize(&cmd->link);
392
}
393
 
394
/** Initialize and register commands. */
395
void cmd_init(void)
396
{
775 palkovsky 397
    int i;
596 jermar 398
 
775 palkovsky 399
    for (i=0;basic_commands[i]; i++) {
400
        cmd_initialize(basic_commands[i]);
401
        if (!cmd_register(basic_commands[i]))
402
            panic("could not register command %s\n",
403
                  basic_commands[i]->name);
404
    }
596 jermar 405
}
406
 
407
 
408
/** List supported commands.
409
 *
410
 * @param argv Argument vector.
411
 *
412
 * @return 0 on failure, 1 on success.
413
 */
414
int cmd_help(cmd_arg_t *argv)
415
{
416
    link_t *cur;
417
 
418
    spinlock_lock(&cmd_lock);
419
 
420
    for (cur = cmd_head.next; cur != &cmd_head; cur = cur->next) {
421
        cmd_info_t *hlp;
422
 
423
        hlp = list_get_instance(cur, cmd_info_t, link);
424
        spinlock_lock(&hlp->lock);
425
 
426
        printf("%s - %s\n", hlp->name, hlp->description);
427
 
428
        spinlock_unlock(&hlp->lock);
429
    }
430
 
431
    spinlock_unlock(&cmd_lock);
432
 
433
    return 1;
434
}
435
 
436
/** Describe specified command.
437
 *
438
 * @param argv Argument vector.
439
 *
440
 * @return 0 on failure, 1 on success.
441
 */
442
int cmd_desc(cmd_arg_t *argv)
443
{
444
    link_t *cur;
445
 
446
    spinlock_lock(&cmd_lock);
447
 
448
    for (cur = cmd_head.next; cur != &cmd_head; cur = cur->next) {
449
        cmd_info_t *hlp;
450
 
451
        hlp = list_get_instance(cur, cmd_info_t, link);
452
        spinlock_lock(&hlp->lock);
453
 
454
        if (strncmp(hlp->name, (const char *) argv->buffer, strlen(hlp->name)) == 0) {
455
            printf("%s - %s\n", hlp->name, hlp->description);
456
            if (hlp->help)
457
                hlp->help();
458
            spinlock_unlock(&hlp->lock);
459
            break;
460
        }
461
 
462
        spinlock_unlock(&hlp->lock);
463
    }
464
 
465
    spinlock_unlock(&cmd_lock);
466
 
467
    return 1;
468
}
469
 
470
/** Search symbol table */
471
int cmd_symaddr(cmd_arg_t *argv)
472
{
473
    symtab_print_search(argv->buffer);
474
 
475
    return 1;
476
}
477
 
478
/** Call function with zero parameters */
479
int cmd_call0(cmd_arg_t *argv)
480
{
481
    __address symaddr;
482
    char *symbol;
483
    __native (*f)(void);
1666 palkovsky 484
#ifdef ia64
485
    struct {
486
        __native f;
487
        __native gp;
488
    }fptr;
489
#endif
596 jermar 490
 
491
    symaddr = get_symbol_addr(argv->buffer);
492
    if (!symaddr)
493
        printf("Symbol %s not found.\n", argv->buffer);
494
    else if (symaddr == (__address) -1) {
495
        symtab_print_search(argv->buffer);
496
        printf("Duplicate symbol, be more specific.\n");
497
    } else {
498
        symbol = get_symtab_entry(symaddr);
1224 cejka 499
        printf("Calling f(): %.*p: %s\n", sizeof(__address) * 2, symaddr, symbol);
1666 palkovsky 500
#ifdef ia64
501
        fptr.f = symaddr;
502
        fptr.gp = ((__native *)cmd_call2)[1];
503
        f =  (__native (*)(void)) &fptr;
504
#else
596 jermar 505
        f =  (__native (*)(void)) symaddr;
1666 palkovsky 506
#endif
1224 cejka 507
        printf("Result: %#zx\n", f());
596 jermar 508
    }
509
 
510
    return 1;
511
}
512
 
513
/** Call function with one parameter */
514
int cmd_call1(cmd_arg_t *argv)
515
{
516
    __address symaddr;
517
    char *symbol;
775 palkovsky 518
    __native (*f)(__native,...);
596 jermar 519
    __native arg1 = argv[1].intval;
1666 palkovsky 520
#ifdef ia64
521
    struct {
522
        __native f;
523
        __native gp;
524
    }fptr;
525
#endif
596 jermar 526
 
527
    symaddr = get_symbol_addr(argv->buffer);
528
    if (!symaddr)
529
        printf("Symbol %s not found.\n", argv->buffer);
530
    else if (symaddr == (__address) -1) {
531
        symtab_print_search(argv->buffer);
532
        printf("Duplicate symbol, be more specific.\n");
533
    } else {
534
        symbol = get_symtab_entry(symaddr);
1666 palkovsky 535
 
1224 cejka 536
        printf("Calling f(0x%zX): %.*p: %s\n", arg1, sizeof(__address) * 2, symaddr, symbol);
1666 palkovsky 537
#ifdef ia64
538
        fptr.f = symaddr;
539
        fptr.gp = ((__native *)cmd_call2)[1];
540
        f =  (__native (*)(__native,...)) &fptr;
541
#else
775 palkovsky 542
        f =  (__native (*)(__native,...)) symaddr;
1666 palkovsky 543
#endif
1224 cejka 544
        printf("Result: %#zx\n", f(arg1));
596 jermar 545
    }
546
 
547
    return 1;
548
}
549
 
550
/** Call function with two parameters */
551
int cmd_call2(cmd_arg_t *argv)
552
{
553
    __address symaddr;
554
    char *symbol;
775 palkovsky 555
    __native (*f)(__native,__native,...);
596 jermar 556
    __native arg1 = argv[1].intval;
557
    __native arg2 = argv[2].intval;
1666 palkovsky 558
#ifdef ia64
559
    struct {
560
        __native f;
561
        __native gp;
562
    }fptr;
563
#endif
596 jermar 564
 
565
    symaddr = get_symbol_addr(argv->buffer);
566
    if (!symaddr)
567
        printf("Symbol %s not found.\n", argv->buffer);
568
    else if (symaddr == (__address) -1) {
569
        symtab_print_search(argv->buffer);
570
        printf("Duplicate symbol, be more specific.\n");
571
    } else {
572
        symbol = get_symtab_entry(symaddr);
1224 cejka 573
        printf("Calling f(0x%zx,0x%zx): %.*p: %s\n",
574
               arg1, arg2, sizeof(__address) * 2, symaddr, symbol);
1666 palkovsky 575
#ifdef ia64
576
        fptr.f = symaddr;
577
        fptr.gp = ((__native *)cmd_call2)[1];
578
        f =  (__native (*)(__native,__native,...)) &fptr;
579
#else
775 palkovsky 580
        f =  (__native (*)(__native,__native,...)) symaddr;
1666 palkovsky 581
#endif
1224 cejka 582
        printf("Result: %#zx\n", f(arg1, arg2));
596 jermar 583
    }
584
 
585
    return 1;
586
}
587
 
588
/** Call function with three parameters */
589
int cmd_call3(cmd_arg_t *argv)
590
{
591
    __address symaddr;
592
    char *symbol;
775 palkovsky 593
    __native (*f)(__native,__native,__native,...);
596 jermar 594
    __native arg1 = argv[1].intval;
595
    __native arg2 = argv[2].intval;
596
    __native arg3 = argv[3].intval;
1666 palkovsky 597
#ifdef ia64
598
    struct {
599
        __native f;
600
        __native gp;
601
    }fptr;
602
#endif
596 jermar 603
 
604
    symaddr = get_symbol_addr(argv->buffer);
605
    if (!symaddr)
606
        printf("Symbol %s not found.\n", argv->buffer);
607
    else if (symaddr == (__address) -1) {
608
        symtab_print_search(argv->buffer);
609
        printf("Duplicate symbol, be more specific.\n");
610
    } else {
611
        symbol = get_symtab_entry(symaddr);
1224 cejka 612
        printf("Calling f(0x%zx,0x%zx, 0x%zx): %.*p: %s\n",
613
               arg1, arg2, arg3, sizeof(__address) * 2, symaddr, symbol);
1666 palkovsky 614
#ifdef ia64
615
        fptr.f = symaddr;
616
        fptr.gp = ((__native *)cmd_call2)[1];
617
        f =  (__native (*)(__native,__native,__native,...)) &fptr;
618
#else
775 palkovsky 619
        f =  (__native (*)(__native,__native,__native,...)) symaddr;
1666 palkovsky 620
#endif
1224 cejka 621
        printf("Result: %#zx\n", f(arg1, arg2, arg3));
596 jermar 622
    }
623
 
624
    return 1;
625
}
626
 
627
 
628
/** Print detailed description of 'describe' command. */
629
void desc_help(void)
630
{
631
    printf("Syntax: describe command_name\n");
632
}
633
 
634
/** Halt the kernel.
635
 *
636
 * @param argv Argument vector (ignored).
637
 *
638
 * @return 0 on failure, 1 on success (never returns).
639
 */
640
int cmd_halt(cmd_arg_t *argv)
641
{
642
    halt();
643
    return 1;
644
}
645
 
646
/** Command for printing TLB contents.
647
 *
648
 * @param argv Not used.
649
 *
650
 * @return Always returns 1.
651
 */
673 jermar 652
int cmd_tlb(cmd_arg_t *argv)
596 jermar 653
{
654
    tlb_print();
655
    return 1;
656
}
603 palkovsky 657
 
658
/** Write 4 byte value to address */
659
int cmd_set4(cmd_arg_t *argv)
660
{
661
    __u32 *addr ;
662
    __u32 arg1 = argv[1].intval;
663
    bool pointer = false;
664
 
665
    if (((char *)argv->buffer)[0] == '*') {
666
        addr = (__u32 *) get_symbol_addr(argv->buffer+1);
667
        pointer = true;
668
    } else if (((char *)argv->buffer)[0] >= '0' &&
669
           ((char *)argv->buffer)[0] <= '9')
670
        addr = (__u32 *)atoi((char *)argv->buffer);
671
    else
672
        addr = (__u32 *)get_symbol_addr(argv->buffer);
673
 
674
    if (!addr)
675
        printf("Symbol %s not found.\n", argv->buffer);
676
    else if (addr == (__u32 *) -1) {
677
        symtab_print_search(argv->buffer);
678
        printf("Duplicate symbol, be more specific.\n");
679
    } else {
680
        if (pointer)
608 palkovsky 681
            addr = (__u32 *)(*(__native *)addr);
1224 cejka 682
        printf("Writing 0x%x -> %.*p\n", arg1, sizeof(__address) * 2, addr);
603 palkovsky 683
        *addr = arg1;
684
 
685
    }
686
 
687
    return 1;
688
}
668 bondari 689
 
759 palkovsky 690
/** Command for listings SLAB caches
691
 *
692
 * @param argv Ignores
693
 *
694
 * @return Always 1
695
 */
696
int cmd_slabs(cmd_arg_t * argv) {
697
    slab_print_list();
698
    return 1;
699
}
700
 
777 palkovsky 701
 
775 palkovsky 702
/** Command for listings Thread information
703
 *
704
 * @param argv Ignores
705
 *
706
 * @return Always 1
707
 */
777 palkovsky 708
int cmd_threads(cmd_arg_t * argv) {
709
    thread_print_list();
710
    return 1;
711
}
712
 
1060 palkovsky 713
/** Command for listings Task information
714
 *
715
 * @param argv Ignores
716
 *
717
 * @return Always 1
718
 */
719
int cmd_tasks(cmd_arg_t * argv) {
720
    task_print_list();
721
    return 1;
722
}
723
 
777 palkovsky 724
/** Command for listings Thread information
725
 *
726
 * @param argv Ignores
727
 *
728
 * @return Always 1
729
 */
775 palkovsky 730
int cmd_sched(cmd_arg_t * argv) {
731
    sched_print_list();
732
    return 1;
733
}
734
 
677 bondari 735
/** Command for listing memory zones
736
 *
737
 * @param argv Ignored
738
 *
739
 * return Always 1
740
 */
668 bondari 741
int cmd_zones(cmd_arg_t * argv) {
676 bondari 742
    zone_print_list();
668 bondari 743
    return 1;
744
}
673 jermar 745
 
677 bondari 746
/** Command for memory zone details
747
 *
748
 * @param argv Integer argument from cmdline expected
749
 *
750
 * return Always 1
751
 */
668 bondari 752
int cmd_zone(cmd_arg_t * argv) {
676 bondari 753
    zone_print_one(argv[0].intval);
668 bondari 754
    return 1;
755
}
756
 
1573 palkovsky 757
/** Command for printing task ipc details
758
 *
759
 * @param argv Integer argument from cmdline expected
760
 *
761
 * return Always 1
762
 */
763
int cmd_ipc_task(cmd_arg_t * argv) {
764
    ipc_print_task(argv[0].intval);
765
    return 1;
766
}
767
 
768
 
673 jermar 769
/** Command for listing processors.
770
 *
771
 * @param argv Ignored.
772
 *
773
 * return Always 1.
774
 */
775
int cmd_cpus(cmd_arg_t *argv)
776
{
777
    cpu_list();
778
    return 1;
779
}
780
 
781
/** Command for printing kernel version.
782
 *
783
 * @param argv Ignored.
784
 *
785
 * return Always 1.
786
 */
787
int cmd_version(cmd_arg_t *argv)
788
{
789
    version_print();
790
    return 1;
791
}
1474 palkovsky 792
 
793
/** Command for returning console back to userspace.
794
 *
795
 * @param argv Ignored.
796
 *
797
 * return Always 1.
798
 */
799
int cmd_continue(cmd_arg_t *argv)
800
{
1695 jermar 801
    printf("The kernel will now relinquish the console.\n");
802
    printf("Use userspace controls to redraw the screen.\n");
1474 palkovsky 803
    arch_release_console();
804
    return 1;
805
}
1702 cejka 806
 
807
 /** @}
808
 */
809