Linux Audio

Check our new training course

Yocto / OpenEmbedded training

Mar 24-27, 2025, special US time zones
Register
Loading...
v5.4
  1// SPDX-License-Identifier: GPL-2.0-only
  2/*
  3 * linux/lib/cmdline.c
  4 * Helper functions generally used for parsing kernel command line
  5 * and module options.
  6 *
  7 * Code and copyrights come from init/main.c and arch/i386/kernel/setup.c.
  8 *
  9 * GNU Indent formatting options for this file: -kr -i8 -npsl -pcs
 10 */
 11
 12#include <linux/export.h>
 13#include <linux/kernel.h>
 14#include <linux/string.h>
 15#include <linux/ctype.h>
 16
 17/*
 18 *	If a hyphen was found in get_option, this will handle the
 19 *	range of numbers, M-N.  This will expand the range and insert
 20 *	the values[M, M+1, ..., N] into the ints array in get_options.
 21 */
 22
 23static int get_range(char **str, int *pint, int n)
 24{
 25	int x, inc_counter, upper_range;
 26
 27	(*str)++;
 28	upper_range = simple_strtol((*str), NULL, 0);
 29	inc_counter = upper_range - *pint;
 30	for (x = *pint; n && x < upper_range; x++, n--)
 31		*pint++ = x;
 32	return inc_counter;
 33}
 34
 35/**
 36 *	get_option - Parse integer from an option string
 37 *	@str: option string
 38 *	@pint: (output) integer value parsed from @str
 39 *
 40 *	Read an int from an option string; if available accept a subsequent
 41 *	comma as well.
 42 *
 
 
 
 43 *	Return values:
 44 *	0 - no int in string
 45 *	1 - int found, no subsequent comma
 46 *	2 - int found including a subsequent comma
 47 *	3 - hyphen found to denote a range
 
 
 
 48 */
 49
 50int get_option(char **str, int *pint)
 51{
 52	char *cur = *str;
 
 53
 54	if (!cur || !(*cur))
 55		return 0;
 56	*pint = simple_strtol(cur, str, 0);
 
 
 
 
 
 57	if (cur == *str)
 58		return 0;
 59	if (**str == ',') {
 60		(*str)++;
 61		return 2;
 62	}
 63	if (**str == '-')
 64		return 3;
 65
 66	return 1;
 67}
 68EXPORT_SYMBOL(get_option);
 69
 70/**
 71 *	get_options - Parse a string into a list of integers
 72 *	@str: String to be parsed
 73 *	@nints: size of integer array
 74 *	@ints: integer array
 75 *
 76 *	This function parses a string containing a comma-separated
 77 *	list of integers, a hyphen-separated range of _positive_ integers,
 78 *	or a combination of both.  The parse halts when the array is
 79 *	full, or when no more numbers can be retrieved from the
 80 *	string.
 81 *
 
 
 
 
 
 
 
 
 82 *	Return value is the character in the string which caused
 83 *	the parse to end (typically a null terminator, if @str is
 84 *	completely parseable).
 85 */
 86
 87char *get_options(const char *str, int nints, int *ints)
 88{
 
 89	int res, i = 1;
 90
 91	while (i < nints) {
 92		res = get_option((char **)&str, ints + i);
 
 
 93		if (res == 0)
 94			break;
 95		if (res == 3) {
 
 96			int range_nums;
 97			range_nums = get_range((char **)&str, ints + i, nints - i);
 
 98			if (range_nums < 0)
 99				break;
100			/*
101			 * Decrement the result by one to leave out the
102			 * last number in the range.  The next iteration
103			 * will handle the upper number in the range
104			 */
105			i += (range_nums - 1);
106		}
107		i++;
108		if (res == 1)
109			break;
110	}
111	ints[0] = i - 1;
112	return (char *)str;
113}
114EXPORT_SYMBOL(get_options);
115
116/**
117 *	memparse - parse a string with mem suffixes into a number
118 *	@ptr: Where parse begins
119 *	@retptr: (output) Optional pointer to next char after parse completes
120 *
121 *	Parses a string into a number.  The number stored at @ptr is
122 *	potentially suffixed with K, M, G, T, P, E.
123 */
124
125unsigned long long memparse(const char *ptr, char **retptr)
126{
127	char *endptr;	/* local pointer to end of parsed string */
128
129	unsigned long long ret = simple_strtoull(ptr, &endptr, 0);
130
131	switch (*endptr) {
132	case 'E':
133	case 'e':
134		ret <<= 10;
135		/* fall through */
136	case 'P':
137	case 'p':
138		ret <<= 10;
139		/* fall through */
140	case 'T':
141	case 't':
142		ret <<= 10;
143		/* fall through */
144	case 'G':
145	case 'g':
146		ret <<= 10;
147		/* fall through */
148	case 'M':
149	case 'm':
150		ret <<= 10;
151		/* fall through */
152	case 'K':
153	case 'k':
154		ret <<= 10;
155		endptr++;
 
156	default:
157		break;
158	}
159
160	if (retptr)
161		*retptr = endptr;
162
163	return ret;
164}
165EXPORT_SYMBOL(memparse);
166
167/**
168 *	parse_option_str - Parse a string and check an option is set or not
169 *	@str: String to be parsed
170 *	@option: option name
171 *
172 *	This function parses a string containing a comma-separated list of
173 *	strings like a=b,c.
174 *
175 *	Return true if there's such option in the string, or return false.
176 */
177bool parse_option_str(const char *str, const char *option)
178{
179	while (*str) {
180		if (!strncmp(str, option, strlen(option))) {
181			str += strlen(option);
182			if (!*str || *str == ',')
183				return true;
184		}
185
186		while (*str && *str != ',')
187			str++;
188
189		if (*str == ',')
190			str++;
191	}
192
193	return false;
194}
195
196/*
197 * Parse a string to get a param value pair.
198 * You can use " around spaces, but can't escape ".
199 * Hyphens and underscores equivalent in parameter names.
200 */
201char *next_arg(char *args, char **param, char **val)
202{
203	unsigned int i, equals = 0;
204	int in_quote = 0, quoted = 0;
205	char *next;
206
207	if (*args == '"') {
208		args++;
209		in_quote = 1;
210		quoted = 1;
211	}
212
213	for (i = 0; args[i]; i++) {
214		if (isspace(args[i]) && !in_quote)
215			break;
216		if (equals == 0) {
217			if (args[i] == '=')
218				equals = i;
219		}
220		if (args[i] == '"')
221			in_quote = !in_quote;
222	}
223
224	*param = args;
225	if (!equals)
226		*val = NULL;
227	else {
228		args[equals] = '\0';
229		*val = args + equals + 1;
230
231		/* Don't include quotes in value. */
232		if (**val == '"') {
233			(*val)++;
234			if (args[i-1] == '"')
235				args[i-1] = '\0';
236		}
237	}
238	if (quoted && args[i-1] == '"')
239		args[i-1] = '\0';
240
241	if (args[i]) {
242		args[i] = '\0';
243		next = args + i + 1;
244	} else
245		next = args + i;
246
247	/* Chew up trailing spaces. */
248	return skip_spaces(next);
249}
v6.9.4
  1// SPDX-License-Identifier: GPL-2.0-only
  2/*
  3 * linux/lib/cmdline.c
  4 * Helper functions generally used for parsing kernel command line
  5 * and module options.
  6 *
  7 * Code and copyrights come from init/main.c and arch/i386/kernel/setup.c.
  8 *
  9 * GNU Indent formatting options for this file: -kr -i8 -npsl -pcs
 10 */
 11
 12#include <linux/export.h>
 13#include <linux/kernel.h>
 14#include <linux/string.h>
 15#include <linux/ctype.h>
 16
 17/*
 18 *	If a hyphen was found in get_option, this will handle the
 19 *	range of numbers, M-N.  This will expand the range and insert
 20 *	the values[M, M+1, ..., N] into the ints array in get_options.
 21 */
 22
 23static int get_range(char **str, int *pint, int n)
 24{
 25	int x, inc_counter, upper_range;
 26
 27	(*str)++;
 28	upper_range = simple_strtol((*str), NULL, 0);
 29	inc_counter = upper_range - *pint;
 30	for (x = *pint; n && x < upper_range; x++, n--)
 31		*pint++ = x;
 32	return inc_counter;
 33}
 34
 35/**
 36 *	get_option - Parse integer from an option string
 37 *	@str: option string
 38 *	@pint: (optional output) integer value parsed from @str
 39 *
 40 *	Read an int from an option string; if available accept a subsequent
 41 *	comma as well.
 42 *
 43 *	When @pint is NULL the function can be used as a validator of
 44 *	the current option in the string.
 45 *
 46 *	Return values:
 47 *	0 - no int in string
 48 *	1 - int found, no subsequent comma
 49 *	2 - int found including a subsequent comma
 50 *	3 - hyphen found to denote a range
 51 *
 52 *	Leading hyphen without integer is no integer case, but we consume it
 53 *	for the sake of simplification.
 54 */
 55
 56int get_option(char **str, int *pint)
 57{
 58	char *cur = *str;
 59	int value;
 60
 61	if (!cur || !(*cur))
 62		return 0;
 63	if (*cur == '-')
 64		value = -simple_strtoull(++cur, str, 0);
 65	else
 66		value = simple_strtoull(cur, str, 0);
 67	if (pint)
 68		*pint = value;
 69	if (cur == *str)
 70		return 0;
 71	if (**str == ',') {
 72		(*str)++;
 73		return 2;
 74	}
 75	if (**str == '-')
 76		return 3;
 77
 78	return 1;
 79}
 80EXPORT_SYMBOL(get_option);
 81
 82/**
 83 *	get_options - Parse a string into a list of integers
 84 *	@str: String to be parsed
 85 *	@nints: size of integer array
 86 *	@ints: integer array (must have room for at least one element)
 87 *
 88 *	This function parses a string containing a comma-separated
 89 *	list of integers, a hyphen-separated range of _positive_ integers,
 90 *	or a combination of both.  The parse halts when the array is
 91 *	full, or when no more numbers can be retrieved from the
 92 *	string.
 93 *
 94 *	When @nints is 0, the function just validates the given @str and
 95 *	returns the amount of parseable integers as described below.
 96 *
 97 *	Returns:
 98 *
 99 *	The first element is filled by the number of collected integers
100 *	in the range. The rest is what was parsed from the @str.
101 *
102 *	Return value is the character in the string which caused
103 *	the parse to end (typically a null terminator, if @str is
104 *	completely parseable).
105 */
106
107char *get_options(const char *str, int nints, int *ints)
108{
109	bool validate = (nints == 0);
110	int res, i = 1;
111
112	while (i < nints || validate) {
113		int *pint = validate ? ints : ints + i;
114
115		res = get_option((char **)&str, pint);
116		if (res == 0)
117			break;
118		if (res == 3) {
119			int n = validate ? 0 : nints - i;
120			int range_nums;
121
122			range_nums = get_range((char **)&str, pint, n);
123			if (range_nums < 0)
124				break;
125			/*
126			 * Decrement the result by one to leave out the
127			 * last number in the range.  The next iteration
128			 * will handle the upper number in the range
129			 */
130			i += (range_nums - 1);
131		}
132		i++;
133		if (res == 1)
134			break;
135	}
136	ints[0] = i - 1;
137	return (char *)str;
138}
139EXPORT_SYMBOL(get_options);
140
141/**
142 *	memparse - parse a string with mem suffixes into a number
143 *	@ptr: Where parse begins
144 *	@retptr: (output) Optional pointer to next char after parse completes
145 *
146 *	Parses a string into a number.  The number stored at @ptr is
147 *	potentially suffixed with K, M, G, T, P, E.
148 */
149
150unsigned long long memparse(const char *ptr, char **retptr)
151{
152	char *endptr;	/* local pointer to end of parsed string */
153
154	unsigned long long ret = simple_strtoull(ptr, &endptr, 0);
155
156	switch (*endptr) {
157	case 'E':
158	case 'e':
159		ret <<= 10;
160		fallthrough;
161	case 'P':
162	case 'p':
163		ret <<= 10;
164		fallthrough;
165	case 'T':
166	case 't':
167		ret <<= 10;
168		fallthrough;
169	case 'G':
170	case 'g':
171		ret <<= 10;
172		fallthrough;
173	case 'M':
174	case 'm':
175		ret <<= 10;
176		fallthrough;
177	case 'K':
178	case 'k':
179		ret <<= 10;
180		endptr++;
181		fallthrough;
182	default:
183		break;
184	}
185
186	if (retptr)
187		*retptr = endptr;
188
189	return ret;
190}
191EXPORT_SYMBOL(memparse);
192
193/**
194 *	parse_option_str - Parse a string and check an option is set or not
195 *	@str: String to be parsed
196 *	@option: option name
197 *
198 *	This function parses a string containing a comma-separated list of
199 *	strings like a=b,c.
200 *
201 *	Return true if there's such option in the string, or return false.
202 */
203bool parse_option_str(const char *str, const char *option)
204{
205	while (*str) {
206		if (!strncmp(str, option, strlen(option))) {
207			str += strlen(option);
208			if (!*str || *str == ',')
209				return true;
210		}
211
212		while (*str && *str != ',')
213			str++;
214
215		if (*str == ',')
216			str++;
217	}
218
219	return false;
220}
221
222/*
223 * Parse a string to get a param value pair.
224 * You can use " around spaces, but can't escape ".
225 * Hyphens and underscores equivalent in parameter names.
226 */
227char *next_arg(char *args, char **param, char **val)
228{
229	unsigned int i, equals = 0;
230	int in_quote = 0, quoted = 0;
 
231
232	if (*args == '"') {
233		args++;
234		in_quote = 1;
235		quoted = 1;
236	}
237
238	for (i = 0; args[i]; i++) {
239		if (isspace(args[i]) && !in_quote)
240			break;
241		if (equals == 0) {
242			if (args[i] == '=')
243				equals = i;
244		}
245		if (args[i] == '"')
246			in_quote = !in_quote;
247	}
248
249	*param = args;
250	if (!equals)
251		*val = NULL;
252	else {
253		args[equals] = '\0';
254		*val = args + equals + 1;
255
256		/* Don't include quotes in value. */
257		if (**val == '"') {
258			(*val)++;
259			if (args[i-1] == '"')
260				args[i-1] = '\0';
261		}
262	}
263	if (quoted && i > 0 && args[i-1] == '"')
264		args[i-1] = '\0';
265
266	if (args[i]) {
267		args[i] = '\0';
268		args += i + 1;
269	} else
270		args += i;
271
272	/* Chew up trailing spaces. */
273	return skip_spaces(args);
274}
275EXPORT_SYMBOL(next_arg);