[2677758] | 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 |
|
---|
[f4338d2] | 29 | #include <console/kconsole.h>
|
---|
[2677758] | 30 | #include <console/console.h>
|
---|
| 31 | #include <console/chardev.h>
|
---|
[442d0ae] | 32 | #include <console/cmd.h>
|
---|
[2677758] | 33 | #include <print.h>
|
---|
[ff3b3197] | 34 | #include <panic.h>
|
---|
[2677758] | 35 | #include <typedefs.h>
|
---|
| 36 | #include <arch/types.h>
|
---|
[ff3b3197] | 37 | #include <list.h>
|
---|
| 38 | #include <arch.h>
|
---|
| 39 | #include <macros.h>
|
---|
[f4338d2] | 40 | #include <debug.h>
|
---|
[442d0ae] | 41 | #include <func.h>
|
---|
[6e716a59] | 42 | #include <symtab.h>
|
---|
[ff3b3197] | 43 |
|
---|
| 44 | /** Simple kernel console.
|
---|
| 45 | *
|
---|
| 46 | * The console is realized by kernel thread kconsole.
|
---|
[f4338d2] | 47 | * It doesn't understand any useful command on its own,
|
---|
| 48 | * but makes it possible for other kernel subsystems to
|
---|
[ff3b3197] | 49 | * register their own commands.
|
---|
| 50 | */
|
---|
| 51 |
|
---|
| 52 | /** Locking.
|
---|
| 53 | *
|
---|
| 54 | * There is a list of cmd_info_t structures. This list
|
---|
| 55 | * is protected by cmd_lock spinlock. Note that specially
|
---|
| 56 | * the link elements of cmd_info_t are protected by
|
---|
| 57 | * this lock.
|
---|
| 58 | *
|
---|
| 59 | * Each cmd_info_t also has its own lock, which protects
|
---|
| 60 | * all elements thereof except the link element.
|
---|
| 61 | *
|
---|
| 62 | * cmd_lock must be acquired before any cmd_info lock.
|
---|
| 63 | * When locking two cmd info structures, structure with
|
---|
| 64 | * lower address must be locked first.
|
---|
| 65 | */
|
---|
| 66 |
|
---|
| 67 | spinlock_t cmd_lock; /**< Lock protecting command list. */
|
---|
| 68 | link_t cmd_head; /**< Command list. */
|
---|
| 69 |
|
---|
| 70 | static cmd_info_t *parse_cmdline(char *cmdline, size_t len);
|
---|
[f4338d2] | 71 | static bool parse_argument(char *cmdline, size_t len, index_t *start, index_t *end);
|
---|
[0c8e692] | 72 | static char history[KCONSOLE_HISTORY][MAX_CMDLINE] = {};
|
---|
[ff3b3197] | 73 |
|
---|
| 74 | /** Initialize kconsole data structures. */
|
---|
| 75 | void kconsole_init(void)
|
---|
| 76 | {
|
---|
[0c8e692] | 77 | int i;
|
---|
| 78 |
|
---|
[2d93f1f9] | 79 | spinlock_initialize(&cmd_lock, "kconsole_cmd");
|
---|
[ff3b3197] | 80 | list_initialize(&cmd_head);
|
---|
[2312685] | 81 |
|
---|
[442d0ae] | 82 | cmd_init();
|
---|
[0c8e692] | 83 | for (i=0; i<KCONSOLE_HISTORY; i++)
|
---|
| 84 | history[i][0] = '\0';
|
---|
[ff3b3197] | 85 | }
|
---|
| 86 |
|
---|
| 87 |
|
---|
| 88 | /** Register kconsole command.
|
---|
| 89 | *
|
---|
| 90 | * @param cmd Structure describing the command.
|
---|
| 91 | *
|
---|
| 92 | * @return 0 on failure, 1 on success.
|
---|
| 93 | */
|
---|
| 94 | int cmd_register(cmd_info_t *cmd)
|
---|
| 95 | {
|
---|
| 96 | ipl_t ipl;
|
---|
| 97 | link_t *cur;
|
---|
| 98 |
|
---|
| 99 | spinlock_lock(&cmd_lock);
|
---|
| 100 |
|
---|
| 101 | /*
|
---|
| 102 | * Make sure the command is not already listed.
|
---|
| 103 | */
|
---|
| 104 | for (cur = cmd_head.next; cur != &cmd_head; cur = cur->next) {
|
---|
| 105 | cmd_info_t *hlp;
|
---|
| 106 |
|
---|
| 107 | hlp = list_get_instance(cur, cmd_info_t, link);
|
---|
| 108 |
|
---|
| 109 | if (hlp == cmd) {
|
---|
| 110 | /* The command is already there. */
|
---|
| 111 | spinlock_unlock(&cmd_lock);
|
---|
| 112 | return 0;
|
---|
| 113 | }
|
---|
| 114 |
|
---|
| 115 | /* Avoid deadlock. */
|
---|
| 116 | if (hlp < cmd) {
|
---|
| 117 | spinlock_lock(&hlp->lock);
|
---|
| 118 | spinlock_lock(&cmd->lock);
|
---|
| 119 | } else {
|
---|
| 120 | spinlock_lock(&cmd->lock);
|
---|
| 121 | spinlock_lock(&hlp->lock);
|
---|
| 122 | }
|
---|
| 123 |
|
---|
[f4338d2] | 124 | if ((strncmp(hlp->name, cmd->name, strlen(cmd->name)) == 0)) {
|
---|
[ff3b3197] | 125 | /* The command is already there. */
|
---|
| 126 | spinlock_unlock(&hlp->lock);
|
---|
| 127 | spinlock_unlock(&cmd->lock);
|
---|
| 128 | spinlock_unlock(&cmd_lock);
|
---|
| 129 | return 0;
|
---|
| 130 | }
|
---|
| 131 |
|
---|
| 132 | spinlock_unlock(&hlp->lock);
|
---|
| 133 | spinlock_unlock(&cmd->lock);
|
---|
| 134 | }
|
---|
| 135 |
|
---|
| 136 | /*
|
---|
| 137 | * Now the command can be added.
|
---|
| 138 | */
|
---|
| 139 | list_append(&cmd->link, &cmd_head);
|
---|
| 140 |
|
---|
| 141 | spinlock_unlock(&cmd_lock);
|
---|
| 142 | return 1;
|
---|
| 143 | }
|
---|
[2677758] | 144 |
|
---|
[0c8e692] | 145 | static void rdln_print_c(char ch, int count)
|
---|
| 146 | {
|
---|
| 147 | int i;
|
---|
| 148 | for (i=0;i<count;i++)
|
---|
| 149 | putchar(ch);
|
---|
| 150 | }
|
---|
| 151 |
|
---|
| 152 | static void insert_char(char *str, char ch, int pos)
|
---|
| 153 | {
|
---|
| 154 | int i;
|
---|
| 155 |
|
---|
| 156 | for (i=strlen(str);i > pos; i--)
|
---|
| 157 | str[i] = str[i-1];
|
---|
| 158 | str[pos] = ch;
|
---|
| 159 | }
|
---|
| 160 |
|
---|
| 161 | static const char * cmdtab_search_one(const char *name,link_t **startpos)
|
---|
| 162 | {
|
---|
| 163 | int namelen = strlen(name);
|
---|
| 164 | const char *curname;
|
---|
| 165 | char *foundsym = NULL;
|
---|
| 166 | int foundpos = 0;
|
---|
| 167 |
|
---|
| 168 | spinlock_lock(&cmd_lock);
|
---|
| 169 |
|
---|
| 170 | if (!*startpos)
|
---|
| 171 | *startpos = cmd_head.next;
|
---|
| 172 |
|
---|
| 173 | for (;*startpos != &cmd_head;*startpos = (*startpos)->next) {
|
---|
| 174 | cmd_info_t *hlp;
|
---|
| 175 | hlp = list_get_instance(*startpos, cmd_info_t, link);
|
---|
| 176 |
|
---|
| 177 | curname = hlp->name;
|
---|
| 178 | if (strlen(curname) < namelen)
|
---|
| 179 | continue;
|
---|
| 180 | if (strncmp(curname, name, namelen) == 0) {
|
---|
| 181 | spinlock_unlock(&cmd_lock);
|
---|
| 182 | return curname+namelen;
|
---|
| 183 | }
|
---|
| 184 | }
|
---|
| 185 | spinlock_unlock(&cmd_lock);
|
---|
| 186 | return NULL;
|
---|
| 187 | }
|
---|
| 188 |
|
---|
| 189 |
|
---|
| 190 | /** Command completion of the commands
|
---|
| 191 | *
|
---|
| 192 | * @param name - string to match, changed to hint on exit
|
---|
| 193 | * @return number of found matches
|
---|
| 194 | */
|
---|
| 195 | static int cmdtab_compl(char *name)
|
---|
| 196 | {
|
---|
| 197 | char output[MAX_SYMBOL_NAME+1];
|
---|
| 198 | link_t *startpos = NULL;
|
---|
| 199 | const char *foundtxt;
|
---|
| 200 | int found = 0;
|
---|
| 201 | int i;
|
---|
| 202 |
|
---|
| 203 | output[0] = '\0';
|
---|
| 204 | while ((foundtxt = cmdtab_search_one(name, &startpos))) {
|
---|
| 205 | startpos = startpos->next;
|
---|
| 206 | if (!found)
|
---|
| 207 | strncpy(output, foundtxt, strlen(foundtxt)+1);
|
---|
| 208 | else {
|
---|
| 209 | for (i=0; output[i] && foundtxt[i] && output[i]==foundtxt[i]; i++)
|
---|
| 210 | ;
|
---|
| 211 | output[i] = '\0';
|
---|
| 212 | }
|
---|
| 213 | found++;
|
---|
| 214 | }
|
---|
| 215 | if (!found)
|
---|
| 216 | return 0;
|
---|
| 217 |
|
---|
[3550c393] | 218 | if (found > 1 && !strlen(output)) {
|
---|
[0c8e692] | 219 | printf("\n");
|
---|
| 220 | startpos = NULL;
|
---|
| 221 | while ((foundtxt = cmdtab_search_one(name, &startpos))) {
|
---|
| 222 | cmd_info_t *hlp;
|
---|
| 223 | hlp = list_get_instance(startpos, cmd_info_t, link);
|
---|
| 224 | printf("%s - %s\n", hlp->name, hlp->description);
|
---|
| 225 | startpos = startpos->next;
|
---|
| 226 | }
|
---|
| 227 | }
|
---|
| 228 | strncpy(name, output, MAX_SYMBOL_NAME);
|
---|
| 229 | return found;
|
---|
| 230 |
|
---|
| 231 | }
|
---|
| 232 |
|
---|
| 233 | static char * clever_readline(const char *prompt, chardev_t *input)
|
---|
| 234 | {
|
---|
| 235 | static int histposition = 0;
|
---|
| 236 |
|
---|
| 237 | char tmp[MAX_CMDLINE+1];
|
---|
| 238 | int curlen = 0, position = 0;
|
---|
| 239 | char *current = history[histposition];
|
---|
| 240 | int i;
|
---|
| 241 | char c;
|
---|
| 242 |
|
---|
| 243 | printf("%s> ", prompt);
|
---|
| 244 | while (1) {
|
---|
| 245 | c = _getc(input);
|
---|
| 246 | if (c == '\n') {
|
---|
| 247 | putchar(c);
|
---|
| 248 | break;
|
---|
| 249 | } if (c == '\b') {
|
---|
| 250 | if (position == 0)
|
---|
| 251 | continue;
|
---|
| 252 | for (i=position; i<curlen;i++)
|
---|
| 253 | current[i-1] = current[i];
|
---|
| 254 | curlen--;
|
---|
| 255 | position--;
|
---|
| 256 | putchar('\b');
|
---|
| 257 | for (i=position;i<curlen;i++)
|
---|
| 258 | putchar(current[i]);
|
---|
| 259 | putchar(' ');
|
---|
| 260 | rdln_print_c('\b',curlen-position+1);
|
---|
| 261 | continue;
|
---|
| 262 | }
|
---|
| 263 | if (c == '\t') {
|
---|
| 264 | int found;
|
---|
| 265 |
|
---|
| 266 | /* Move to the end of the word */
|
---|
| 267 | for (;position<curlen && current[position]!=' ';position++)
|
---|
| 268 | putchar(current[position]);
|
---|
| 269 | /* Copy to tmp last word */
|
---|
| 270 | for (i=position-1;i >= 0 && current[i]!=' ' ;i--)
|
---|
| 271 | ;
|
---|
| 272 | /* If word begins with * or &, skip it */
|
---|
| 273 | if (tmp[0] == '*' || tmp[0] == '&')
|
---|
| 274 | for (i=1;tmp[i];i++)
|
---|
| 275 | tmp[i-1] = tmp[i];
|
---|
| 276 | i++; /* I is at the start of the word */
|
---|
| 277 | strncpy(tmp, current+i, position-i+1);
|
---|
| 278 |
|
---|
| 279 | if (i==0) { /* Command completion */
|
---|
| 280 | found = cmdtab_compl(tmp);
|
---|
| 281 | } else { /* Symtab completion */
|
---|
| 282 | found = symtab_compl(tmp);
|
---|
| 283 | }
|
---|
| 284 |
|
---|
| 285 | if (found == 0)
|
---|
| 286 | continue;
|
---|
| 287 | for (i=0;tmp[i] && curlen < MAX_CMDLINE;i++,curlen++)
|
---|
| 288 | insert_char(current, tmp[i], i+position);
|
---|
[3550c393] | 289 |
|
---|
| 290 | if (strlen(tmp) || found==1) { /* If we have a hint */
|
---|
| 291 | for (i=position;i<curlen;i++)
|
---|
[0c8e692] | 292 | putchar(current[i]);
|
---|
| 293 | position += strlen(tmp);
|
---|
| 294 | /* Add space to end */
|
---|
[3550c393] | 295 | if (found == 1 && position == curlen && \
|
---|
| 296 | curlen < MAX_CMDLINE) {
|
---|
[0c8e692] | 297 | current[position] = ' ';
|
---|
| 298 | curlen++;
|
---|
| 299 | position++;
|
---|
| 300 | putchar(' ');
|
---|
| 301 | }
|
---|
[3550c393] | 302 | } else { /* No hint, table was printed */
|
---|
[0c8e692] | 303 | printf("%s> ", prompt);
|
---|
| 304 | for (i=0; i<curlen;i++)
|
---|
| 305 | putchar(current[i]);
|
---|
| 306 | position += strlen(tmp);
|
---|
| 307 | }
|
---|
| 308 | rdln_print_c('\b', curlen-position);
|
---|
| 309 | continue;
|
---|
| 310 | }
|
---|
| 311 | if (c == 0x1b) {
|
---|
| 312 | c = _getc(input);
|
---|
| 313 | if (c!= 0x5b)
|
---|
| 314 | continue;
|
---|
| 315 | c = _getc(input);
|
---|
| 316 | if (c == 0x44) { /* Left */
|
---|
| 317 | if (position > 0) {
|
---|
| 318 | putchar('\b');
|
---|
| 319 | position--;
|
---|
| 320 | }
|
---|
| 321 | continue;
|
---|
| 322 | }
|
---|
| 323 | if (c == 0x43) { /* Right */
|
---|
| 324 | if (position < curlen) {
|
---|
| 325 | putchar(current[position]);
|
---|
| 326 | position++;
|
---|
| 327 | }
|
---|
| 328 | continue;
|
---|
| 329 | }
|
---|
| 330 | if (c == 0x41 || c == 0x42) { /* Up,down */
|
---|
| 331 | rdln_print_c('\b',position);
|
---|
| 332 | rdln_print_c(' ',curlen);
|
---|
| 333 | rdln_print_c('\b',curlen);
|
---|
| 334 | if (c == 0x41)
|
---|
| 335 | histposition--;
|
---|
| 336 | else
|
---|
| 337 | histposition++;
|
---|
| 338 | if (histposition < 0)
|
---|
| 339 | histposition = KCONSOLE_HISTORY -1 ;
|
---|
| 340 | else
|
---|
| 341 | histposition = histposition % KCONSOLE_HISTORY;
|
---|
| 342 | current = history[histposition];
|
---|
| 343 | printf("%s", current);
|
---|
| 344 | curlen = strlen(current);
|
---|
| 345 | position = curlen;
|
---|
| 346 | continue;
|
---|
| 347 | }
|
---|
| 348 | continue;
|
---|
| 349 | }
|
---|
| 350 | if (curlen >= MAX_CMDLINE)
|
---|
| 351 | continue;
|
---|
| 352 |
|
---|
| 353 | insert_char(current, c, position);
|
---|
| 354 |
|
---|
| 355 | curlen++;
|
---|
| 356 | for (i=position;i<curlen;i++)
|
---|
| 357 | putchar(current[i]);
|
---|
| 358 | position++;
|
---|
| 359 | rdln_print_c('\b',curlen-position);
|
---|
| 360 | }
|
---|
[ba276f7] | 361 | if (curlen) {
|
---|
| 362 | histposition++;
|
---|
| 363 | histposition = histposition % KCONSOLE_HISTORY;
|
---|
| 364 | }
|
---|
[0c8e692] | 365 | current[curlen] = '\0';
|
---|
| 366 | return current;
|
---|
| 367 | }
|
---|
| 368 |
|
---|
[2677758] | 369 | /** Kernel console managing thread.
|
---|
| 370 | *
|
---|
| 371 | * @param arg Not used.
|
---|
| 372 | */
|
---|
| 373 | void kconsole(void *arg)
|
---|
| 374 | {
|
---|
[ff3b3197] | 375 | cmd_info_t *cmd_info;
|
---|
| 376 | count_t len;
|
---|
[0c8e692] | 377 | char *cmdline;
|
---|
[2677758] | 378 |
|
---|
| 379 | if (!stdin) {
|
---|
| 380 | printf("%s: no stdin\n", __FUNCTION__);
|
---|
| 381 | return;
|
---|
| 382 | }
|
---|
| 383 |
|
---|
| 384 | while (true) {
|
---|
[0c8e692] | 385 | cmdline = clever_readline(__FUNCTION__, stdin);
|
---|
| 386 | len = strlen(cmdline);
|
---|
| 387 | if (!len)
|
---|
[f4338d2] | 388 | continue;
|
---|
[ff3b3197] | 389 | cmd_info = parse_cmdline(cmdline, len);
|
---|
[f4338d2] | 390 | if (!cmd_info)
|
---|
[ff3b3197] | 391 | continue;
|
---|
| 392 | (void) cmd_info->func(cmd_info->argv);
|
---|
[2677758] | 393 | }
|
---|
| 394 | }
|
---|
[ff3b3197] | 395 |
|
---|
[91c78c9] | 396 | static int parse_int_arg(char *text, size_t len, __native *result)
|
---|
| 397 | {
|
---|
| 398 | char symname[MAX_SYMBOL_NAME];
|
---|
| 399 | __address symaddr;
|
---|
| 400 | bool isaddr = false;
|
---|
[e5fcf00] | 401 | bool isptr = false;
|
---|
[91c78c9] | 402 |
|
---|
| 403 | /* If we get a name, try to find it in symbol table */
|
---|
| 404 | if (text[0] < '0' | text[0] > '9') {
|
---|
| 405 | if (text[0] == '&') {
|
---|
| 406 | isaddr = true;
|
---|
| 407 | text++;len--;
|
---|
[e5fcf00] | 408 | } else if (text[0] == '*') {
|
---|
| 409 | isptr = true;
|
---|
| 410 | text++;len--;
|
---|
[91c78c9] | 411 | }
|
---|
| 412 | strncpy(symname, text, min(len+1, MAX_SYMBOL_NAME));
|
---|
| 413 | symaddr = get_symbol_addr(symname);
|
---|
| 414 | if (!symaddr) {
|
---|
| 415 | printf("Symbol %s not found.\n",symname);
|
---|
| 416 | return -1;
|
---|
| 417 | }
|
---|
| 418 | if (symaddr == (__address) -1) {
|
---|
| 419 | printf("Duplicate symbol %s.\n",symname);
|
---|
| 420 | symtab_print_search(symname);
|
---|
| 421 | return -1;
|
---|
| 422 | }
|
---|
| 423 | if (isaddr)
|
---|
| 424 | *result = (__native)symaddr;
|
---|
[e5fcf00] | 425 | else if (isptr)
|
---|
| 426 | *result = **((__native **)symaddr);
|
---|
[91c78c9] | 427 | else
|
---|
| 428 | *result = *((__native *)symaddr);
|
---|
| 429 | } else /* It's a number - convert it */
|
---|
| 430 | *result = atoi(text);
|
---|
| 431 | return 0;
|
---|
| 432 | }
|
---|
| 433 |
|
---|
[ff3b3197] | 434 | /** Parse command line.
|
---|
| 435 | *
|
---|
| 436 | * @param cmdline Command line as read from input device.
|
---|
| 437 | * @param len Command line length.
|
---|
| 438 | *
|
---|
| 439 | * @return Structure describing the command.
|
---|
| 440 | */
|
---|
| 441 | cmd_info_t *parse_cmdline(char *cmdline, size_t len)
|
---|
| 442 | {
|
---|
| 443 | index_t start = 0, end = 0;
|
---|
| 444 | cmd_info_t *cmd = NULL;
|
---|
| 445 | link_t *cur;
|
---|
| 446 | ipl_t ipl;
|
---|
| 447 | int i;
|
---|
| 448 |
|
---|
[f4338d2] | 449 | if (!parse_argument(cmdline, len, &start, &end)) {
|
---|
[ff3b3197] | 450 | /* Command line did not contain alphanumeric word. */
|
---|
| 451 | return NULL;
|
---|
| 452 | }
|
---|
| 453 |
|
---|
| 454 | spinlock_lock(&cmd_lock);
|
---|
| 455 |
|
---|
| 456 | for (cur = cmd_head.next; cur != &cmd_head; cur = cur->next) {
|
---|
| 457 | cmd_info_t *hlp;
|
---|
| 458 |
|
---|
| 459 | hlp = list_get_instance(cur, cmd_info_t, link);
|
---|
| 460 | spinlock_lock(&hlp->lock);
|
---|
| 461 |
|
---|
[f4338d2] | 462 | if (strncmp(hlp->name, &cmdline[start], (end - start) + 1) == 0) {
|
---|
[ff3b3197] | 463 | cmd = hlp;
|
---|
| 464 | break;
|
---|
| 465 | }
|
---|
| 466 |
|
---|
| 467 | spinlock_unlock(&hlp->lock);
|
---|
| 468 | }
|
---|
| 469 |
|
---|
| 470 | spinlock_unlock(&cmd_lock);
|
---|
| 471 |
|
---|
| 472 | if (!cmd) {
|
---|
| 473 | /* Unknown command. */
|
---|
[f4338d2] | 474 | printf("Unknown command.\n");
|
---|
[ff3b3197] | 475 | return NULL;
|
---|
| 476 | }
|
---|
| 477 |
|
---|
| 478 | /* cmd == hlp is locked */
|
---|
| 479 |
|
---|
| 480 | /*
|
---|
| 481 | * The command line must be further analyzed and
|
---|
| 482 | * the parameters therefrom must be matched and
|
---|
| 483 | * converted to those specified in the cmd info
|
---|
| 484 | * structure.
|
---|
| 485 | */
|
---|
[f4338d2] | 486 |
|
---|
| 487 | for (i = 0; i < cmd->argc; i++) {
|
---|
| 488 | char *buf;
|
---|
| 489 | start = end + 1;
|
---|
| 490 | if (!parse_argument(cmdline, len, &start, &end)) {
|
---|
| 491 | printf("Too few arguments.\n");
|
---|
| 492 | spinlock_unlock(&cmd->lock);
|
---|
| 493 | return NULL;
|
---|
| 494 | }
|
---|
| 495 |
|
---|
| 496 | switch (cmd->argv[i].type) {
|
---|
[6e716a59] | 497 | case ARG_TYPE_STRING:
|
---|
[f4338d2] | 498 | buf = cmd->argv[i].buffer;
|
---|
[91c78c9] | 499 | strncpy(buf, (const char *) &cmdline[start], min((end - start) + 2, cmd->argv[i].len));
|
---|
[f4338d2] | 500 | buf[min((end - start) + 1, cmd->argv[i].len - 1)] = '\0';
|
---|
| 501 | break;
|
---|
[91c78c9] | 502 | case ARG_TYPE_INT:
|
---|
| 503 | if (parse_int_arg(cmdline+start, end-start+1,
|
---|
| 504 | &cmd->argv[i].intval))
|
---|
| 505 | return NULL;
|
---|
[6e716a59] | 506 | break;
|
---|
[91c78c9] | 507 | case ARG_TYPE_VAR:
|
---|
| 508 | if (start != end && cmdline[start] == '"' && cmdline[end] == '"') {
|
---|
| 509 | buf = cmd->argv[i].buffer;
|
---|
| 510 | strncpy(buf, (const char *) &cmdline[start+1],
|
---|
| 511 | min((end-start), cmd->argv[i].len));
|
---|
| 512 | buf[min((end - start), cmd->argv[i].len - 1)] = '\0';
|
---|
| 513 | cmd->argv[i].intval = (__native) buf;
|
---|
| 514 | cmd->argv[i].vartype = ARG_TYPE_STRING;
|
---|
| 515 | } else if (!parse_int_arg(cmdline+start, end-start+1,
|
---|
| 516 | &cmd->argv[i].intval))
|
---|
| 517 | cmd->argv[i].vartype = ARG_TYPE_INT;
|
---|
| 518 | else {
|
---|
| 519 | printf("Unrecognized variable argument.\n");
|
---|
| 520 | return NULL;
|
---|
[6e716a59] | 521 | }
|
---|
[91c78c9] | 522 | break;
|
---|
[6e716a59] | 523 | case ARG_TYPE_INVALID:
|
---|
| 524 | default:
|
---|
| 525 | printf("invalid argument type\n");
|
---|
| 526 | return NULL;
|
---|
[f4338d2] | 527 | break;
|
---|
| 528 | }
|
---|
| 529 | }
|
---|
| 530 |
|
---|
| 531 | start = end + 1;
|
---|
| 532 | if (parse_argument(cmdline, len, &start, &end)) {
|
---|
| 533 | printf("Too many arguments.\n");
|
---|
| 534 | spinlock_unlock(&cmd->lock);
|
---|
| 535 | return NULL;
|
---|
| 536 | }
|
---|
[ff3b3197] | 537 |
|
---|
| 538 | spinlock_unlock(&cmd->lock);
|
---|
| 539 | return cmd;
|
---|
| 540 | }
|
---|
| 541 |
|
---|
[f4338d2] | 542 | /** Parse argument.
|
---|
| 543 | *
|
---|
| 544 | * Find start and end positions of command line argument.
|
---|
| 545 | *
|
---|
| 546 | * @param cmdline Command line as read from the input device.
|
---|
| 547 | * @param len Number of characters in cmdline.
|
---|
| 548 | * @param start On entry, 'start' contains pointer to the index
|
---|
| 549 | * of first unprocessed character of cmdline.
|
---|
| 550 | * On successful exit, it marks beginning of the next argument.
|
---|
| 551 | * @param end Undefined on entry. On exit, 'end' points to the last character
|
---|
| 552 | * of the next argument.
|
---|
| 553 | *
|
---|
| 554 | * @return false on failure, true on success.
|
---|
| 555 | */
|
---|
| 556 | bool parse_argument(char *cmdline, size_t len, index_t *start, index_t *end)
|
---|
| 557 | {
|
---|
| 558 | int i;
|
---|
| 559 | bool found_start = false;
|
---|
| 560 |
|
---|
| 561 | ASSERT(start != NULL);
|
---|
| 562 | ASSERT(end != NULL);
|
---|
| 563 |
|
---|
| 564 | for (i = *start; i < len; i++) {
|
---|
| 565 | if (!found_start) {
|
---|
| 566 | if (is_white(cmdline[i]))
|
---|
| 567 | (*start)++;
|
---|
| 568 | else
|
---|
| 569 | found_start = true;
|
---|
| 570 | } else {
|
---|
| 571 | if (is_white(cmdline[i]))
|
---|
| 572 | break;
|
---|
| 573 | }
|
---|
| 574 | }
|
---|
| 575 | *end = i - 1;
|
---|
| 576 |
|
---|
| 577 | return found_start;
|
---|
| 578 | }
|
---|