source: mainline/kernel/generic/src/console/kconsole.c@ 1479562

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since 1479562 was a7199c2, checked in by Jakub Jermar <jakub@…>, 15 years ago

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