Subversion Repositories HelenOS

Rev

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

Rev Author Line No. Line
510 jermar 1
/*
2071 jermar 2
 * Copyright (c) 2005 Jakub Jermar
510 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
 
1264 jermar 33
/**
4217 decky 34
 * @file  kconsole.c
35
 * @brief Kernel console.
1264 jermar 36
 *
37
 * This file contains kernel thread managing the kernel console.
4217 decky 38
 *
1264 jermar 39
 */
40
 
518 jermar 41
#include <console/kconsole.h>
510 jermar 42
#include <console/console.h>
43
#include <console/chardev.h>
596 jermar 44
#include <console/cmd.h>
510 jermar 45
#include <print.h>
517 jermar 46
#include <panic.h>
510 jermar 47
#include <arch/types.h>
788 jermar 48
#include <adt/list.h>
517 jermar 49
#include <arch.h>
50
#include <macros.h>
518 jermar 51
#include <debug.h>
596 jermar 52
#include <func.h>
4011 svoboda 53
#include <string.h>
609 palkovsky 54
#include <macros.h>
3761 decky 55
#include <sysinfo/sysinfo.h>
56
#include <ddi/device.h>
4132 svoboda 57
#include <symtab.h>
4137 svoboda 58
#include <errno.h>
4180 decky 59
#include <putchar.h>
4217 decky 60
#include <string.h>
4132 svoboda 61
 
517 jermar 62
/** Simple kernel console.
63
 *
64
 * The console is realized by kernel thread kconsole.
518 jermar 65
 * It doesn't understand any useful command on its own,
66
 * but makes it possible for other kernel subsystems to
517 jermar 67
 * register their own commands.
68
 */
4217 decky 69
 
517 jermar 70
/** Locking.
71
 *
72
 * There is a list of cmd_info_t structures. This list
73
 * is protected by cmd_lock spinlock. Note that specially
74
 * the link elements of cmd_info_t are protected by
75
 * this lock.
76
 *
77
 * Each cmd_info_t also has its own lock, which protects
78
 * all elements thereof except the link element.
79
 *
80
 * cmd_lock must be acquired before any cmd_info lock.
81
 * When locking two cmd info structures, structure with
82
 * lower address must be locked first.
83
 */
84
 
4217 decky 85
SPINLOCK_INITIALIZE(cmd_lock);  /**< Lock protecting command list. */
86
LIST_INITIALIZE(cmd_head);      /**< Command list. */
517 jermar 87
 
4217 decky 88
static wchar_t history[KCONSOLE_HISTORY][MAX_CMDLINE] = {};
89
static count_t history_pos = 0;
90
 
3761 decky 91
/** Initialize kconsole data structures
92
 *
93
 * This is the most basic initialization, almost no
94
 * other kernel subsystem is ready yet.
95
 *
96
 */
517 jermar 97
void kconsole_init(void)
98
{
3761 decky 99
    unsigned int i;
4217 decky 100
 
596 jermar 101
    cmd_init();
2108 jermar 102
    for (i = 0; i < KCONSOLE_HISTORY; i++)
4217 decky 103
        history[i][0] = 0;
517 jermar 104
}
105
 
106
/** Register kconsole command.
107
 *
108
 * @param cmd Structure describing the command.
109
 *
4217 decky 110
 * @return False on failure, true on success.
111
 *
517 jermar 112
 */
4217 decky 113
bool cmd_register(cmd_info_t *cmd)
517 jermar 114
{
115
    link_t *cur;
116
 
117
    spinlock_lock(&cmd_lock);
118
 
119
    /*
120
     * Make sure the command is not already listed.
121
     */
122
    for (cur = cmd_head.next; cur != &cmd_head; cur = cur->next) {
4217 decky 123
        cmd_info_t *hlp = list_get_instance(cur, cmd_info_t, link);
517 jermar 124
 
125
        if (hlp == cmd) {
126
            /* The command is already there. */
127
            spinlock_unlock(&cmd_lock);
4217 decky 128
            return false;
517 jermar 129
        }
4217 decky 130
 
517 jermar 131
        /* Avoid deadlock. */
132
        if (hlp < cmd) {
133
            spinlock_lock(&hlp->lock);
134
            spinlock_lock(&cmd->lock);
135
        } else {
136
            spinlock_lock(&cmd->lock);
137
            spinlock_lock(&hlp->lock);
138
        }
4217 decky 139
 
140
        if (str_cmp(hlp->name, cmd->name) == 0) {
517 jermar 141
            /* The command is already there. */
142
            spinlock_unlock(&hlp->lock);
143
            spinlock_unlock(&cmd->lock);
144
            spinlock_unlock(&cmd_lock);
4217 decky 145
            return false;
517 jermar 146
        }
147
 
148
        spinlock_unlock(&hlp->lock);
149
        spinlock_unlock(&cmd->lock);
150
    }
151
 
152
    /*
153
     * Now the command can be added.
154
     */
155
    list_append(&cmd->link, &cmd_head);
156
 
157
    spinlock_unlock(&cmd_lock);
4217 decky 158
    return true;
517 jermar 159
}
160
 
635 palkovsky 161
/** Print count times a character */
4217 decky 162
static void print_cc(wchar_t ch, count_t count)
601 palkovsky 163
{
4180 decky 164
    count_t i;
2108 jermar 165
    for (i = 0; i < count; i++)
601 palkovsky 166
        putchar(ch);
167
}
168
 
4217 decky 169
/** Try to find a command beginning with prefix */
170
static const char *cmdtab_search_one(const char *name, link_t **startpos)
601 palkovsky 171
{
4217 decky 172
    count_t namelen = str_length(name);
601 palkovsky 173
 
174
    spinlock_lock(&cmd_lock);
4217 decky 175
 
176
    if (*startpos == NULL)
601 palkovsky 177
        *startpos = cmd_head.next;
4217 decky 178
 
2108 jermar 179
    for (; *startpos != &cmd_head; *startpos = (*startpos)->next) {
4217 decky 180
        cmd_info_t *hlp = list_get_instance(*startpos, cmd_info_t, link);
181
 
182
        const char *curname = hlp->name;
183
        if (str_length(curname) < namelen)
601 palkovsky 184
            continue;
4217 decky 185
 
186
        if (str_lcmp(curname, name, namelen) == 0) {
187
            spinlock_unlock(&cmd_lock);
188
            return (curname + str_lsize(curname, namelen));
601 palkovsky 189
        }
190
    }
4217 decky 191
 
192
    spinlock_unlock(&cmd_lock);
601 palkovsky 193
    return NULL;
194
}
195
 
4217 decky 196
/** Command completion of the commands
601 palkovsky 197
 *
4217 decky 198
 * @param name String to match, changed to hint on exit
199
 * @param size Input buffer size
200
 *
201
 * @return Number of found matches
202
 *
601 palkovsky 203
 */
4217 decky 204
static int cmdtab_compl(char *input, size_t size)
601 palkovsky 205
{
4217 decky 206
    const char *name = input;
207
 
208
    count_t found = 0;
209
    link_t *pos = NULL;
210
    const char *hint;
211
    char output[MAX_CMDLINE];
212
 
213
    output[0] = 0;
214
 
215
    while ((hint = cmdtab_search_one(name, &pos))) {
216
        if ((found == 0) || (str_length(output) > str_length(hint)))
4267 svoboda 217
            str_cpy(output, MAX_CMDLINE, hint);
4217 decky 218
 
219
        pos = pos->next;
601 palkovsky 220
        found++;
221
    }
4217 decky 222
 
223
    if ((found > 1) && (str_length(output) != 0)) {
601 palkovsky 224
        printf("\n");
4217 decky 225
        pos = NULL;
226
        while ((hint = cmdtab_search_one(name, &pos))) {
227
            cmd_info_t *hlp = list_get_instance(pos, cmd_info_t, link);
228
            printf("%s (%s)\n", hlp->name, hlp->description);
229
            pos = pos->next;
601 palkovsky 230
        }
231
    }
4217 decky 232
 
233
    if (found > 0)
4267 svoboda 234
        str_cpy(input, size, output);
4217 decky 235
 
601 palkovsky 236
    return found;
237
}
238
 
4217 decky 239
static wchar_t *clever_readline(const char *prompt, indev_t *indev)
601 palkovsky 240
{
241
    printf("%s> ", prompt);
4217 decky 242
 
243
    count_t position = 0;
244
    wchar_t *current = history[history_pos];
245
    current[0] = 0;
246
 
247
    while (true) {
248
        wchar_t ch = _getc(indev);
249
 
250
        if (ch == '\n') {
251
            /* Enter */
252
            putchar(ch);
601 palkovsky 253
            break;
3193 jermar 254
        }
4217 decky 255
 
256
        if (ch == '\b') {
257
            /* Backspace */
601 palkovsky 258
            if (position == 0)
259
                continue;
4217 decky 260
 
261
            if (wstr_remove(current, position - 1)) {
4223 decky 262
                position--;
4217 decky 263
                putchar('\b');
4223 decky 264
                printf("%ls ", current + position);
265
                print_cc('\b', wstr_length(current) - position + 1);
4217 decky 266
                continue;
267
            }
601 palkovsky 268
        }
4217 decky 269
 
270
        if (ch == '\t') {
271
            /* Tab completion */
272
 
601 palkovsky 273
            /* Move to the end of the word */
4217 decky 274
            for (; (current[position] != 0) && (!isspace(current[position]));
2108 jermar 275
                position++)
601 palkovsky 276
                putchar(current[position]);
4217 decky 277
 
278
            if (position == 0)
279
                continue;
280
 
281
            /* Find the beginning of the word
282
               and copy it to tmp */
283
            count_t beg;
284
            for (beg = position - 1; (beg > 0) && (!isspace(current[beg]));
285
                beg--);
286
 
287
            if (isspace(current[beg]))
288
                beg++;
289
 
290
            char tmp[STR_BOUNDS(MAX_CMDLINE)];
291
            wstr_nstr(tmp, current + beg, position - beg + 1);
292
 
293
            int found;
294
            if (beg == 0) {
295
                /* Command completion */
296
                found = cmdtab_compl(tmp, STR_BOUNDS(MAX_CMDLINE));
297
            } else {
298
                /* Symbol completion */
299
                found = symtab_compl(tmp, STR_BOUNDS(MAX_CMDLINE));
601 palkovsky 300
            }
4217 decky 301
 
302
            if (found == 0)
601 palkovsky 303
                continue;
4217 decky 304
 
305
            size_t off = 0;
306
            count_t i = 0;
307
            while ((ch = str_decode(tmp, &off, STR_NO_LIMIT)) != 0) {
308
                if (!wstr_linsert(current, ch, position + i, MAX_CMDLINE))
309
                    break;
310
                i++;
311
            }
312
 
313
            if ((str_length(tmp) > 0) || (found == 1)) {
314
                /* We have a hint */
315
                printf("%ls", current + position);
316
                print_cc('\b', wstr_length(current) - position);
317
                position += str_length(tmp);
318
 
319
                if ((found == 1) && (position == wstr_length(current))) {
320
                    if (wstr_linsert(current, ' ', position, MAX_CMDLINE)) {
321
                        printf("%ls", current + position);
322
                        position++;
323
                    }
601 palkovsky 324
                }
4217 decky 325
            } else {
326
                /* No unique hint, list was printed */
601 palkovsky 327
                printf("%s> ", prompt);
4217 decky 328
                printf("%ls", current);
329
                position += str_length(tmp);
601 palkovsky 330
            }
4217 decky 331
 
332
            print_cc('\b', wstr_length(current) - position);
601 palkovsky 333
            continue;
334
        }
4217 decky 335
 
4223 decky 336
        if (ch == U_LEFT_ARROW) {
337
            /* Left */
338
            if (position > 0) {
339
                putchar('\b');
340
                position--;
341
            }
342
            continue;
343
        }
344
 
345
        if (ch == U_RIGHT_ARROW) {
346
            /* Right */
347
            if (position < wstr_length(current)) {
348
                putchar(current[position]);
349
                position++;
350
            }
351
            continue;
352
        }
353
 
354
        if ((ch == U_UP_ARROW) || (ch == U_DOWN_ARROW)) {
355
            /* Up, down */
356
            print_cc('\b', position);
357
            print_cc(' ', wstr_length(current));
358
            print_cc('\b', wstr_length(current));
4217 decky 359
 
4223 decky 360
            if (ch == U_UP_ARROW) {
361
                /* Up */
362
                if (history_pos == 0)
363
                    history_pos = KCONSOLE_HISTORY - 1;
364
                else
365
                    history_pos--;
366
            } else {
367
                /* Down */
368
                history_pos++;
369
                history_pos = history_pos % KCONSOLE_HISTORY;
370
            }
371
            current = history[history_pos];
372
            printf("%ls", current);
373
            position = wstr_length(current);
374
            continue;
375
        }
376
 
377
        if (ch == U_HOME_ARROW) {
378
            /* Home */
379
            print_cc('\b', position);
380
            position = 0;
381
            continue;
382
        }
383
 
384
        if (ch == U_END_ARROW) {
385
            /* End */
386
            printf("%ls", current + position);
387
            position = wstr_length(current);
388
            continue;
389
        }
390
 
391
        if (ch == U_DELETE) {
392
            /* Delete */
393
            if (position == wstr_length(current))
601 palkovsky 394
                continue;
4217 decky 395
 
4223 decky 396
            if (wstr_remove(current, position)) {
397
                printf("%ls ", current + position);
398
                print_cc('\b', wstr_length(current) - position + 1);
601 palkovsky 399
            }
400
            continue;
401
        }
4217 decky 402
 
403
        if (wstr_linsert(current, ch, position, MAX_CMDLINE)) {
404
            printf("%ls", current + position);
405
            position++;
406
            print_cc('\b', wstr_length(current) - position);
407
        }
603 palkovsky 408
    }
4217 decky 409
 
410
    if (wstr_length(current) > 0) {
411
        history_pos++;
412
        history_pos = history_pos % KCONSOLE_HISTORY;
413
    }
414
 
601 palkovsky 415
    return current;
416
}
417
 
4089 decky 418
bool kconsole_check_poll(void)
419
{
420
    return check_poll(stdin);
421
}
422
 
4217 decky 423
static bool parse_int_arg(const char *text, size_t len, unative_t *result)
510 jermar 424
{
585 palkovsky 425
    bool isaddr = false;
589 palkovsky 426
    bool isptr = false;
585 palkovsky 427
 
428
    /* If we get a name, try to find it in symbol table */
931 palkovsky 429
    if (text[0] == '&') {
430
        isaddr = true;
2108 jermar 431
        text++;
432
        len--;
931 palkovsky 433
    } else if (text[0] == '*') {
434
        isptr = true;
2108 jermar 435
        text++;
436
        len--;
931 palkovsky 437
    }
4217 decky 438
 
439
    if ((text[0] < '0') || (text[0] > '9')) {
440
        char symname[MAX_SYMBOL_NAME];
4267 svoboda 441
        str_ncpy(symname, MAX_SYMBOL_NAME, text, len + 1);
4217 decky 442
 
443
        uintptr_t symaddr;
444
        int rc = symtab_addr_lookup(symname, &symaddr);
4137 svoboda 445
        switch (rc) {
446
        case ENOENT:
2108 jermar 447
            printf("Symbol %s not found.\n", symname);
4217 decky 448
            return false;
4137 svoboda 449
        case EOVERFLOW:
2108 jermar 450
            printf("Duplicate symbol %s.\n", symname);
585 palkovsky 451
            symtab_print_search(symname);
4217 decky 452
            return false;
453
        case ENOTSUP:
4137 svoboda 454
            printf("No symbol information available.\n");
4217 decky 455
            return false;
585 palkovsky 456
        }
4217 decky 457
 
932 palkovsky 458
        if (isaddr)
4217 decky 459
            *result = (unative_t) symaddr;
932 palkovsky 460
        else if (isptr)
4217 decky 461
            *result = **((unative_t **) symaddr);
932 palkovsky 462
        else
4217 decky 463
            *result = *((unative_t *) symaddr);
464
    } else {
465
        /* It's a number - convert it */
585 palkovsky 466
        *result = atoi(text);
932 palkovsky 467
        if (isptr)
4217 decky 468
            *result = *((unative_t *) *result);
932 palkovsky 469
    }
4217 decky 470
 
471
    return true;
472
}
931 palkovsky 473
 
4217 decky 474
/** Parse argument.
475
 *
476
 * Find start and end positions of command line argument.
477
 *
478
 * @param cmdline Command line as read from the input device.
479
 * @param size    Size (in bytes) of the string.
480
 * @param start   On entry, 'start' contains pointer to the offset
481
 *                of the first unprocessed character of cmdline.
482
 *                On successful exit, it marks beginning of the next argument.
483
 * @param end     Undefined on entry. On exit, 'end' is the offset of the first
484
 *                character behind the next argument.
485
 *
486
 * @return False on failure, true on success.
487
 *
488
 */
489
static bool parse_argument(const char *cmdline, size_t size, size_t *start, size_t *end)
490
{
491
    ASSERT(start != NULL);
492
    ASSERT(end != NULL);
493
 
494
    bool found_start = false;
495
    size_t offset = *start;
496
    size_t prev = *start;
497
    wchar_t ch;
498
 
499
    while ((ch = str_decode(cmdline, &offset, size)) != 0) {
500
        if (!found_start) {
501
            if (!isspace(ch)) {
502
                *start = prev;
503
                found_start = true;
504
            }
505
        } else {
506
            if (isspace(ch))
507
                break;
508
        }
509
 
510
        prev = offset;
511
    }
4224 svoboda 512
    *end = prev;
4217 decky 513
 
514
    return found_start;
585 palkovsky 515
}
516
 
517 jermar 517
/** Parse command line.
518
 *
4217 decky 519
 * @param cmdline Command line as read from input device.
520
 * @param size    Size (in bytes) of the string.
517 jermar 521
 *
522
 * @return Structure describing the command.
4217 decky 523
 *
517 jermar 524
 */
4217 decky 525
static cmd_info_t *parse_cmdline(const char *cmdline, size_t size)
517 jermar 526
{
4217 decky 527
    size_t start = 0;
528
    size_t end = 0;
529
    if (!parse_argument(cmdline, size, &start, &end)) {
517 jermar 530
        /* Command line did not contain alphanumeric word. */
531
        return NULL;
532
    }
533
    spinlock_lock(&cmd_lock);
534
 
4217 decky 535
    cmd_info_t *cmd = NULL;
536
    link_t *cur;
537
 
517 jermar 538
    for (cur = cmd_head.next; cur != &cmd_head; cur = cur->next) {
4217 decky 539
        cmd_info_t *hlp = list_get_instance(cur, cmd_info_t, link);
517 jermar 540
        spinlock_lock(&hlp->lock);
541
 
4217 decky 542
        if (str_lcmp(hlp->name, cmdline + start,
543
            max(str_length(hlp->name),
544
            str_nlength(cmdline + start, (count_t) (end - start) - 1))) == 0) {
517 jermar 545
            cmd = hlp;
546
            break;
547
        }
548
 
549
        spinlock_unlock(&hlp->lock);
550
    }
551
 
4217 decky 552
    spinlock_unlock(&cmd_lock);
517 jermar 553
 
554
    if (!cmd) {
555
        /* Unknown command. */
518 jermar 556
        printf("Unknown command.\n");
517 jermar 557
        return NULL;
558
    }
4217 decky 559
 
517 jermar 560
    /* cmd == hlp is locked */
561
 
562
    /*
563
     * The command line must be further analyzed and
564
     * the parameters therefrom must be matched and
565
     * converted to those specified in the cmd info
566
     * structure.
567
     */
4217 decky 568
 
569
    bool error = false;
570
    count_t i;
518 jermar 571
    for (i = 0; i < cmd->argc; i++) {
4217 decky 572
        start = end;
573
        if (!parse_argument(cmdline, size, &start, &end)) {
518 jermar 574
            printf("Too few arguments.\n");
575
            spinlock_unlock(&cmd->lock);
576
            return NULL;
577
        }
578
 
4217 decky 579
        char *buf;
518 jermar 580
        switch (cmd->argv[i].type) {
582 palkovsky 581
        case ARG_TYPE_STRING:
2113 decky 582
            buf = (char *) cmd->argv[i].buffer;
4267 svoboda 583
            str_ncpy(buf, cmd->argv[i].len, cmdline + start,
584
                (end - start) + 1);
518 jermar 585
            break;
4217 decky 586
        case ARG_TYPE_INT:
587
            if (!parse_int_arg(cmdline + start, end - start,
2108 jermar 588
                &cmd->argv[i].intval))
4217 decky 589
                error = true;
518 jermar 590
            break;
585 palkovsky 591
        case ARG_TYPE_VAR:
4217 decky 592
            if ((start < end - 1) && (cmdline[start] == '"')) {
593
                if (cmdline[end - 1] == '"') {
594
                    buf = (char *) cmd->argv[i].buffer;
4267 svoboda 595
                    str_ncpy(buf, cmd->argv[i].len,
596
                        cmdline + start + 1,
597
                        (end - start) - 1);
4217 decky 598
                    cmd->argv[i].intval = (unative_t) buf;
599
                    cmd->argv[i].vartype = ARG_TYPE_STRING;
600
                } else {
601
                    printf("Wrong synxtax.\n");
602
                    error = true;
603
                }
604
            } else if (parse_int_arg(cmdline + start,
605
                end - start, &cmd->argv[i].intval)) {
585 palkovsky 606
                cmd->argv[i].vartype = ARG_TYPE_INT;
2108 jermar 607
            } else {
585 palkovsky 608
                printf("Unrecognized variable argument.\n");
4217 decky 609
                error = true;
582 palkovsky 610
            }
585 palkovsky 611
            break;
582 palkovsky 612
        case ARG_TYPE_INVALID:
613
        default:
4217 decky 614
            printf("Invalid argument type\n");
615
            error = true;
582 palkovsky 616
            break;
518 jermar 617
        }
618
    }
517 jermar 619
 
668 bondari 620
    if (error) {
621
        spinlock_unlock(&cmd->lock);
622
        return NULL;
623
    }
624
 
4217 decky 625
    start = end;
626
    if (parse_argument(cmdline, size, &start, &end)) {
518 jermar 627
        printf("Too many arguments.\n");
628
        spinlock_unlock(&cmd->lock);
629
        return NULL;
630
    }
631
 
517 jermar 632
    spinlock_unlock(&cmd->lock);
633
    return cmd;
634
}
635
 
4217 decky 636
/** Kernel console prompt.
518 jermar 637
 *
4217 decky 638
 * @param prompt Kernel console prompt (e.g kconsole/panic).
639
 * @param msg    Message to display in the beginning.
640
 * @param kcon   Wait for keypress to show the prompt
641
 *               and never exit.
518 jermar 642
 *
643
 */
4217 decky 644
void kconsole(char *prompt, char *msg, bool kcon)
518 jermar 645
{
4217 decky 646
    if (!stdin) {
647
        LOG("No stdin for kernel console");
648
        return;
649
    }
518 jermar 650
 
4217 decky 651
    if (msg)
652
        printf("%s", msg);
518 jermar 653
 
4217 decky 654
    if (kcon)
655
        _getc(stdin);
656
    else
657
        printf("Type \"exit\" to leave the console.\n");
658
 
659
    while (true) {
660
        wchar_t *tmp = clever_readline((char *) prompt, stdin);
661
        count_t len = wstr_length(tmp);
662
        if (!len)
663
            continue;
664
 
665
        char cmdline[STR_BOUNDS(MAX_CMDLINE)];
666
        wstr_nstr(cmdline, tmp, STR_BOUNDS(MAX_CMDLINE));
667
 
668
        if ((!kcon) && (len == 4) && (str_lcmp(cmdline, "exit", 4) == 0))
669
            break;
670
 
671
        cmd_info_t *cmd_info = parse_cmdline(cmdline, STR_BOUNDS(MAX_CMDLINE));
672
        if (!cmd_info)
673
            continue;
674
 
675
        (void) cmd_info->func(cmd_info->argv);
518 jermar 676
    }
4217 decky 677
}
518 jermar 678
 
4217 decky 679
/** Kernel console managing thread.
680
 *
681
 */
682
void kconsole_thread(void *data)
683
{
684
    kconsole("kconsole", "Kernel console ready (press any key to activate)\n", true);
518 jermar 685
}
1702 cejka 686
 
1888 jermar 687
/** @}
1702 cejka 688
 */