arch/x86/lib/cmdline.c

   1 /*
   2  * This file is part of the Linux kernel, and is made available under
   3  * the terms of the GNU General Public License version 2.
   4  *
   5  * Misc librarized functions for cmdline poking.
   6  */
   7 #include <linux/kernel.h>
   8 #include <linux/string.h>
   9 #include <linux/ctype.h>
  10 #include <asm/setup.h>
  11
  12 static inline int myisspace(u8 c)
  13 {
  14         return c <= ' ';        /* Close enough approximation */
  15 }
  16
  17 /**
  18  * Find a boolean option (like quiet,noapic,nosmp....)
  19  *
  20  * @cmdline: the cmdline string
  21  * @option: option string to look for
  22  *
  23  * Returns the position of that @option (starts counting with 1)
  24  * or 0 on not found.  @option will only be found if it is found
  25  * as an entire word in @cmdline.  For instance, if @option="car"
  26  * then a cmdline which contains "cart" will not match.
  27  */
  28 int cmdline_find_option_bool(const char *cmdline, const char *option)
  29 {
  30         char c;
  31         int pos = 0, wstart = 0;
  32         const char *opptr = NULL;
  33         enum {
  34                 st_wordstart = 0,       /* Start of word/after whitespace */
  35                 st_wordcmp,     /* Comparing this word */
  36                 st_wordskip,    /* Miscompare, skip */
  37         } state = st_wordstart;
  38
  39         if (!cmdline)
  40                 return -1;      /* No command line */
  41
  42         /*
  43          * This 'pos' check ensures we do not overrun
  44          * a non-NULL-terminated 'cmdline'
  45          */
  46         while (pos < COMMAND_LINE_SIZE) {
  47                 c = *(char *)cmdline++;
  48                 pos++;
  49
  50                 switch (state) {
  51                 case st_wordstart:
  52                         if (!c)
  53                                 return 0;
  54                         else if (myisspace(c))
  55                                 break;
  56
  57                         state = st_wordcmp;
  58                         opptr = option;
  59                         wstart = pos;
  60                         /* fall through */
  61
  62                 case st_wordcmp:
  63                         if (!*opptr) {
  64                                 /*
  65                                  * We matched all the way to the end of the
  66                                  * option we were looking for.  If the
  67                                  * command-line has a space _or_ ends, then
  68                                  * we matched!
  69                                  */
  70                                 if (!c || myisspace(c))
  71                                         return wstart;
  72                                 /*
  73                                  * We hit the end of the option, but _not_
  74                                  * the end of a word on the cmdline.  Not
  75                                  * a match.
  76                                  */
  77                         } else if (!c) {
  78                                 /*
  79                                  * Hit the NULL terminator on the end of
  80                                  * cmdline.
  81                                  */
  82                                 return 0;
  83                         } else if (c == *opptr++) {
  84                                 /*
  85                                  * We are currently matching, so continue
  86                                  * to the next character on the cmdline.
  87                                  */
  88                                 break;
  89                         }
  90                         state = st_wordskip;
  91                         /* fall through */
  92
  93                 case st_wordskip:
  94                         if (!c)
  95                                 return 0;
  96                         else if (myisspace(c))
  97                                 state = st_wordstart;
  98                         break;
  99                 }
 100         }
 101
 102         return 0;       /* Buffer overrun */
 103 }