Loading...
1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 *
4 * Misc librarized functions for cmdline poking.
5 */
6#include <linux/kernel.h>
7#include <linux/string.h>
8#include <linux/ctype.h>
9
10#include <asm/setup.h>
11#include <asm/cmdline.h>
12#include <asm/bug.h>
13
14static inline int myisspace(u8 c)
15{
16 return c <= ' '; /* Close enough approximation */
17}
18
19/*
20 * Find a boolean option (like quiet,noapic,nosmp....)
21 *
22 * @cmdline: the cmdline string
23 * @max_cmdline_size: the maximum size of cmdline
24 * @option: option string to look for
25 *
26 * Returns the position of that @option (starts counting with 1)
27 * or 0 on not found. @option will only be found if it is found
28 * as an entire word in @cmdline. For instance, if @option="car"
29 * then a cmdline which contains "cart" will not match.
30 */
31static int
32__cmdline_find_option_bool(const char *cmdline, int max_cmdline_size,
33 const char *option)
34{
35 char c;
36 int pos = 0, wstart = 0;
37 const char *opptr = NULL;
38 enum {
39 st_wordstart = 0, /* Start of word/after whitespace */
40 st_wordcmp, /* Comparing this word */
41 st_wordskip, /* Miscompare, skip */
42 } state = st_wordstart;
43
44 if (!cmdline)
45 return -1; /* No command line */
46
47 /*
48 * This 'pos' check ensures we do not overrun
49 * a non-NULL-terminated 'cmdline'
50 */
51 while (pos < max_cmdline_size) {
52 c = *(char *)cmdline++;
53 pos++;
54
55 switch (state) {
56 case st_wordstart:
57 if (!c)
58 return 0;
59 else if (myisspace(c))
60 break;
61
62 state = st_wordcmp;
63 opptr = option;
64 wstart = pos;
65 fallthrough;
66
67 case st_wordcmp:
68 if (!*opptr) {
69 /*
70 * We matched all the way to the end of the
71 * option we were looking for. If the
72 * command-line has a space _or_ ends, then
73 * we matched!
74 */
75 if (!c || myisspace(c))
76 return wstart;
77 /*
78 * We hit the end of the option, but _not_
79 * the end of a word on the cmdline. Not
80 * a match.
81 */
82 } else if (!c) {
83 /*
84 * Hit the NULL terminator on the end of
85 * cmdline.
86 */
87 return 0;
88 } else if (c == *opptr++) {
89 /*
90 * We are currently matching, so continue
91 * to the next character on the cmdline.
92 */
93 break;
94 }
95 state = st_wordskip;
96 fallthrough;
97
98 case st_wordskip:
99 if (!c)
100 return 0;
101 else if (myisspace(c))
102 state = st_wordstart;
103 break;
104 }
105 }
106
107 return 0; /* Buffer overrun */
108}
109
110/*
111 * Find a non-boolean option (i.e. option=argument). In accordance with
112 * standard Linux practice, if this option is repeated, this returns the
113 * last instance on the command line.
114 *
115 * @cmdline: the cmdline string
116 * @max_cmdline_size: the maximum size of cmdline
117 * @option: option string to look for
118 * @buffer: memory buffer to return the option argument
119 * @bufsize: size of the supplied memory buffer
120 *
121 * Returns the length of the argument (regardless of if it was
122 * truncated to fit in the buffer), or -1 on not found.
123 */
124static int
125__cmdline_find_option(const char *cmdline, int max_cmdline_size,
126 const char *option, char *buffer, int bufsize)
127{
128 char c;
129 int pos = 0, len = -1;
130 const char *opptr = NULL;
131 char *bufptr = buffer;
132 enum {
133 st_wordstart = 0, /* Start of word/after whitespace */
134 st_wordcmp, /* Comparing this word */
135 st_wordskip, /* Miscompare, skip */
136 st_bufcpy, /* Copying this to buffer */
137 } state = st_wordstart;
138
139 if (!cmdline)
140 return -1; /* No command line */
141
142 /*
143 * This 'pos' check ensures we do not overrun
144 * a non-NULL-terminated 'cmdline'
145 */
146 while (pos++ < max_cmdline_size) {
147 c = *(char *)cmdline++;
148 if (!c)
149 break;
150
151 switch (state) {
152 case st_wordstart:
153 if (myisspace(c))
154 break;
155
156 state = st_wordcmp;
157 opptr = option;
158 fallthrough;
159
160 case st_wordcmp:
161 if ((c == '=') && !*opptr) {
162 /*
163 * We matched all the way to the end of the
164 * option we were looking for, prepare to
165 * copy the argument.
166 */
167 len = 0;
168 bufptr = buffer;
169 state = st_bufcpy;
170 break;
171 } else if (c == *opptr++) {
172 /*
173 * We are currently matching, so continue
174 * to the next character on the cmdline.
175 */
176 break;
177 }
178 state = st_wordskip;
179 fallthrough;
180
181 case st_wordskip:
182 if (myisspace(c))
183 state = st_wordstart;
184 break;
185
186 case st_bufcpy:
187 if (myisspace(c)) {
188 state = st_wordstart;
189 } else {
190 /*
191 * Increment len, but don't overrun the
192 * supplied buffer and leave room for the
193 * NULL terminator.
194 */
195 if (++len < bufsize)
196 *bufptr++ = c;
197 }
198 break;
199 }
200 }
201
202 if (bufsize)
203 *bufptr = '\0';
204
205 return len;
206}
207
208int cmdline_find_option_bool(const char *cmdline, const char *option)
209{
210 int ret;
211
212 ret = __cmdline_find_option_bool(cmdline, COMMAND_LINE_SIZE, option);
213 if (ret > 0)
214 return ret;
215
216 if (IS_ENABLED(CONFIG_CMDLINE_BOOL) && !builtin_cmdline_added)
217 return __cmdline_find_option_bool(builtin_cmdline, COMMAND_LINE_SIZE, option);
218
219 return ret;
220}
221
222int cmdline_find_option(const char *cmdline, const char *option, char *buffer,
223 int bufsize)
224{
225 int ret;
226
227 ret = __cmdline_find_option(cmdline, COMMAND_LINE_SIZE, option, buffer, bufsize);
228 if (ret > 0)
229 return ret;
230
231 if (IS_ENABLED(CONFIG_CMDLINE_BOOL) && !builtin_cmdline_added)
232 return __cmdline_find_option(builtin_cmdline, COMMAND_LINE_SIZE, option, buffer, bufsize);
233
234 return ret;
235}
1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 *
4 * Misc librarized functions for cmdline poking.
5 */
6#include <linux/kernel.h>
7#include <linux/string.h>
8#include <linux/ctype.h>
9#include <asm/setup.h>
10
11static inline int myisspace(u8 c)
12{
13 return c <= ' '; /* Close enough approximation */
14}
15
16/**
17 * Find a boolean option (like quiet,noapic,nosmp....)
18 *
19 * @cmdline: the cmdline string
20 * @option: option string to look for
21 *
22 * Returns the position of that @option (starts counting with 1)
23 * or 0 on not found. @option will only be found if it is found
24 * as an entire word in @cmdline. For instance, if @option="car"
25 * then a cmdline which contains "cart" will not match.
26 */
27static int
28__cmdline_find_option_bool(const char *cmdline, int max_cmdline_size,
29 const char *option)
30{
31 char c;
32 int pos = 0, wstart = 0;
33 const char *opptr = NULL;
34 enum {
35 st_wordstart = 0, /* Start of word/after whitespace */
36 st_wordcmp, /* Comparing this word */
37 st_wordskip, /* Miscompare, skip */
38 } state = st_wordstart;
39
40 if (!cmdline)
41 return -1; /* No command line */
42
43 /*
44 * This 'pos' check ensures we do not overrun
45 * a non-NULL-terminated 'cmdline'
46 */
47 while (pos < max_cmdline_size) {
48 c = *(char *)cmdline++;
49 pos++;
50
51 switch (state) {
52 case st_wordstart:
53 if (!c)
54 return 0;
55 else if (myisspace(c))
56 break;
57
58 state = st_wordcmp;
59 opptr = option;
60 wstart = pos;
61 /* fall through */
62
63 case st_wordcmp:
64 if (!*opptr) {
65 /*
66 * We matched all the way to the end of the
67 * option we were looking for. If the
68 * command-line has a space _or_ ends, then
69 * we matched!
70 */
71 if (!c || myisspace(c))
72 return wstart;
73 /*
74 * We hit the end of the option, but _not_
75 * the end of a word on the cmdline. Not
76 * a match.
77 */
78 } else if (!c) {
79 /*
80 * Hit the NULL terminator on the end of
81 * cmdline.
82 */
83 return 0;
84 } else if (c == *opptr++) {
85 /*
86 * We are currently matching, so continue
87 * to the next character on the cmdline.
88 */
89 break;
90 }
91 state = st_wordskip;
92 /* fall through */
93
94 case st_wordskip:
95 if (!c)
96 return 0;
97 else if (myisspace(c))
98 state = st_wordstart;
99 break;
100 }
101 }
102
103 return 0; /* Buffer overrun */
104}
105
106/*
107 * Find a non-boolean option (i.e. option=argument). In accordance with
108 * standard Linux practice, if this option is repeated, this returns the
109 * last instance on the command line.
110 *
111 * @cmdline: the cmdline string
112 * @max_cmdline_size: the maximum size of cmdline
113 * @option: option string to look for
114 * @buffer: memory buffer to return the option argument
115 * @bufsize: size of the supplied memory buffer
116 *
117 * Returns the length of the argument (regardless of if it was
118 * truncated to fit in the buffer), or -1 on not found.
119 */
120static int
121__cmdline_find_option(const char *cmdline, int max_cmdline_size,
122 const char *option, char *buffer, int bufsize)
123{
124 char c;
125 int pos = 0, len = -1;
126 const char *opptr = NULL;
127 char *bufptr = buffer;
128 enum {
129 st_wordstart = 0, /* Start of word/after whitespace */
130 st_wordcmp, /* Comparing this word */
131 st_wordskip, /* Miscompare, skip */
132 st_bufcpy, /* Copying this to buffer */
133 } state = st_wordstart;
134
135 if (!cmdline)
136 return -1; /* No command line */
137
138 /*
139 * This 'pos' check ensures we do not overrun
140 * a non-NULL-terminated 'cmdline'
141 */
142 while (pos++ < max_cmdline_size) {
143 c = *(char *)cmdline++;
144 if (!c)
145 break;
146
147 switch (state) {
148 case st_wordstart:
149 if (myisspace(c))
150 break;
151
152 state = st_wordcmp;
153 opptr = option;
154 /* fall through */
155
156 case st_wordcmp:
157 if ((c == '=') && !*opptr) {
158 /*
159 * We matched all the way to the end of the
160 * option we were looking for, prepare to
161 * copy the argument.
162 */
163 len = 0;
164 bufptr = buffer;
165 state = st_bufcpy;
166 break;
167 } else if (c == *opptr++) {
168 /*
169 * We are currently matching, so continue
170 * to the next character on the cmdline.
171 */
172 break;
173 }
174 state = st_wordskip;
175 /* fall through */
176
177 case st_wordskip:
178 if (myisspace(c))
179 state = st_wordstart;
180 break;
181
182 case st_bufcpy:
183 if (myisspace(c)) {
184 state = st_wordstart;
185 } else {
186 /*
187 * Increment len, but don't overrun the
188 * supplied buffer and leave room for the
189 * NULL terminator.
190 */
191 if (++len < bufsize)
192 *bufptr++ = c;
193 }
194 break;
195 }
196 }
197
198 if (bufsize)
199 *bufptr = '\0';
200
201 return len;
202}
203
204int cmdline_find_option_bool(const char *cmdline, const char *option)
205{
206 return __cmdline_find_option_bool(cmdline, COMMAND_LINE_SIZE, option);
207}
208
209int cmdline_find_option(const char *cmdline, const char *option, char *buffer,
210 int bufsize)
211{
212 return __cmdline_find_option(cmdline, COMMAND_LINE_SIZE, option,
213 buffer, bufsize);
214}