2019-06-04 11:11:30 +03:00
// SPDX-License-Identifier: GPL-2.0-only
2014-05-19 22:59:16 +04:00
/*
*
* Misc librarized functions for cmdline poking .
*/
# include <linux/kernel.h>
# include <linux/string.h>
# include <linux/ctype.h>
# include <asm/setup.h>
static inline int myisspace ( u8 c )
{
return c < = ' ' ; /* Close enough approximation */
}
/**
* Find a boolean option ( like quiet , noapic , nosmp . . . . )
*
* @ cmdline : the cmdline string
* @ option : option string to look for
*
* Returns the position of that @ option ( starts counting with 1 )
2015-12-23 01:52:38 +03:00
* or 0 on not found . @ option will only be found if it is found
* as an entire word in @ cmdline . For instance , if @ option = " car "
* then a cmdline which contains " cart " will not match .
2014-05-19 22:59:16 +04:00
*/
2015-12-23 01:52:43 +03:00
static int
__cmdline_find_option_bool ( const char * cmdline , int max_cmdline_size ,
const char * option )
2014-05-19 22:59:16 +04:00
{
char c ;
2015-12-23 01:52:38 +03:00
int pos = 0 , wstart = 0 ;
2014-05-19 22:59:16 +04:00
const char * opptr = NULL ;
enum {
st_wordstart = 0 , /* Start of word/after whitespace */
st_wordcmp , /* Comparing this word */
st_wordskip , /* Miscompare, skip */
} state = st_wordstart ;
if ( ! cmdline )
return - 1 ; /* No command line */
2015-12-23 01:52:38 +03:00
/*
* This ' pos ' check ensures we do not overrun
* a non - NULL - terminated ' cmdline '
*/
2015-12-23 01:52:43 +03:00
while ( pos < max_cmdline_size ) {
2014-05-19 22:59:16 +04:00
c = * ( char * ) cmdline + + ;
pos + + ;
switch ( state ) {
case st_wordstart :
if ( ! c )
return 0 ;
else if ( myisspace ( c ) )
break ;
state = st_wordcmp ;
opptr = option ;
wstart = pos ;
2020-08-24 01:36:59 +03:00
fallthrough ;
2014-05-19 22:59:16 +04:00
case st_wordcmp :
2015-12-23 01:52:38 +03:00
if ( ! * opptr ) {
/*
* We matched all the way to the end of the
* option we were looking for . If the
* command - line has a space _or_ ends , then
* we matched !
*/
2014-05-19 22:59:16 +04:00
if ( ! c | | myisspace ( c ) )
return wstart ;
x86/boot: Fix early command-line parsing when partial word matches
cmdline_find_option_bool() keeps track of position in two strings:
1. the command-line
2. the option we are searchign for in the command-line
We plow through each character in the command-line one at a time, always
moving forward. We move forward in the option ('opptr') when we match
characters in 'cmdline'. We reset the 'opptr' only when we go in to the
'st_wordstart' state.
But, if we fail to match an option because we see a space
(state=st_wordcmp, *opptr='\0',c=' '), we set state='st_wordskip' and
'break', moving to the next character. But, that move to the next
character is the one *after* the ' '. This means that we will miss a
'st_wordstart' state.
For instance, if we have
cmdline = "foo fool";
and are searching for "fool", we have:
"fool"
opptr = ----^
"foo fool"
c = --------^
We see that 'l' != ' ', set state=st_wordskip, break, and then move 'c', so:
"foo fool"
c = ---------^
and are still in state=st_wordskip. We will stay in wordskip until we
have skipped "fool", thus missing the option we were looking for. This
*only* happens when you have a partially- matching word followed by a
matching one.
To fix this, we always fall *into* the 'st_wordskip' state when we set
it.
Signed-off-by: Dave Hansen <dave.hansen@linux.intel.com>
Signed-off-by: Borislav Petkov <bp@suse.de>
Cc: Andy Lutomirski <luto@amacapital.net>
Cc: Borislav Petkov <bp@alien8.de>
Cc: Brian Gerst <brgerst@gmail.com>
Cc: Denys Vlasenko <dvlasenk@redhat.com>
Cc: H. Peter Anvin <hpa@zytor.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: fenghua.yu@intel.com
Cc: yu-cheng.yu@intel.com
Link: http://lkml.kernel.org/r/20151222225239.8E1DCA58@viggo.jf.intel.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2015-12-23 01:52:39 +03:00
/*
* We hit the end of the option , but _not_
* the end of a word on the cmdline . Not
* a match .
*/
2015-12-23 01:52:38 +03:00
} else if ( ! c ) {
/*
* Hit the NULL terminator on the end of
* cmdline .
*/
2014-05-19 22:59:16 +04:00
return 0 ;
x86/boot: Fix early command-line parsing when partial word matches
cmdline_find_option_bool() keeps track of position in two strings:
1. the command-line
2. the option we are searchign for in the command-line
We plow through each character in the command-line one at a time, always
moving forward. We move forward in the option ('opptr') when we match
characters in 'cmdline'. We reset the 'opptr' only when we go in to the
'st_wordstart' state.
But, if we fail to match an option because we see a space
(state=st_wordcmp, *opptr='\0',c=' '), we set state='st_wordskip' and
'break', moving to the next character. But, that move to the next
character is the one *after* the ' '. This means that we will miss a
'st_wordstart' state.
For instance, if we have
cmdline = "foo fool";
and are searching for "fool", we have:
"fool"
opptr = ----^
"foo fool"
c = --------^
We see that 'l' != ' ', set state=st_wordskip, break, and then move 'c', so:
"foo fool"
c = ---------^
and are still in state=st_wordskip. We will stay in wordskip until we
have skipped "fool", thus missing the option we were looking for. This
*only* happens when you have a partially- matching word followed by a
matching one.
To fix this, we always fall *into* the 'st_wordskip' state when we set
it.
Signed-off-by: Dave Hansen <dave.hansen@linux.intel.com>
Signed-off-by: Borislav Petkov <bp@suse.de>
Cc: Andy Lutomirski <luto@amacapital.net>
Cc: Borislav Petkov <bp@alien8.de>
Cc: Brian Gerst <brgerst@gmail.com>
Cc: Denys Vlasenko <dvlasenk@redhat.com>
Cc: H. Peter Anvin <hpa@zytor.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: fenghua.yu@intel.com
Cc: yu-cheng.yu@intel.com
Link: http://lkml.kernel.org/r/20151222225239.8E1DCA58@viggo.jf.intel.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2015-12-23 01:52:39 +03:00
} else if ( c = = * opptr + + ) {
/*
* We are currently matching , so continue
* to the next character on the cmdline .
*/
break ;
2015-12-23 01:52:38 +03:00
}
x86/boot: Fix early command-line parsing when partial word matches
cmdline_find_option_bool() keeps track of position in two strings:
1. the command-line
2. the option we are searchign for in the command-line
We plow through each character in the command-line one at a time, always
moving forward. We move forward in the option ('opptr') when we match
characters in 'cmdline'. We reset the 'opptr' only when we go in to the
'st_wordstart' state.
But, if we fail to match an option because we see a space
(state=st_wordcmp, *opptr='\0',c=' '), we set state='st_wordskip' and
'break', moving to the next character. But, that move to the next
character is the one *after* the ' '. This means that we will miss a
'st_wordstart' state.
For instance, if we have
cmdline = "foo fool";
and are searching for "fool", we have:
"fool"
opptr = ----^
"foo fool"
c = --------^
We see that 'l' != ' ', set state=st_wordskip, break, and then move 'c', so:
"foo fool"
c = ---------^
and are still in state=st_wordskip. We will stay in wordskip until we
have skipped "fool", thus missing the option we were looking for. This
*only* happens when you have a partially- matching word followed by a
matching one.
To fix this, we always fall *into* the 'st_wordskip' state when we set
it.
Signed-off-by: Dave Hansen <dave.hansen@linux.intel.com>
Signed-off-by: Borislav Petkov <bp@suse.de>
Cc: Andy Lutomirski <luto@amacapital.net>
Cc: Borislav Petkov <bp@alien8.de>
Cc: Brian Gerst <brgerst@gmail.com>
Cc: Denys Vlasenko <dvlasenk@redhat.com>
Cc: H. Peter Anvin <hpa@zytor.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: fenghua.yu@intel.com
Cc: yu-cheng.yu@intel.com
Link: http://lkml.kernel.org/r/20151222225239.8E1DCA58@viggo.jf.intel.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2015-12-23 01:52:39 +03:00
state = st_wordskip ;
2020-08-24 01:36:59 +03:00
fallthrough ;
2014-05-19 22:59:16 +04:00
case st_wordskip :
if ( ! c )
return 0 ;
else if ( myisspace ( c ) )
state = st_wordstart ;
break ;
}
}
return 0 ; /* Buffer overrun */
}
2015-12-23 01:52:43 +03:00
2017-07-18 00:10:33 +03:00
/*
* Find a non - boolean option ( i . e . option = argument ) . In accordance with
* standard Linux practice , if this option is repeated , this returns the
* last instance on the command line .
*
* @ cmdline : the cmdline string
* @ max_cmdline_size : the maximum size of cmdline
* @ option : option string to look for
* @ buffer : memory buffer to return the option argument
* @ bufsize : size of the supplied memory buffer
*
* Returns the length of the argument ( regardless of if it was
* truncated to fit in the buffer ) , or - 1 on not found .
*/
static int
__cmdline_find_option ( const char * cmdline , int max_cmdline_size ,
const char * option , char * buffer , int bufsize )
{
char c ;
int pos = 0 , len = - 1 ;
const char * opptr = NULL ;
char * bufptr = buffer ;
enum {
st_wordstart = 0 , /* Start of word/after whitespace */
st_wordcmp , /* Comparing this word */
st_wordskip , /* Miscompare, skip */
st_bufcpy , /* Copying this to buffer */
} state = st_wordstart ;
if ( ! cmdline )
return - 1 ; /* No command line */
/*
* This ' pos ' check ensures we do not overrun
* a non - NULL - terminated ' cmdline '
*/
while ( pos + + < max_cmdline_size ) {
c = * ( char * ) cmdline + + ;
if ( ! c )
break ;
switch ( state ) {
case st_wordstart :
if ( myisspace ( c ) )
break ;
state = st_wordcmp ;
opptr = option ;
2020-08-24 01:36:59 +03:00
fallthrough ;
2017-07-18 00:10:33 +03:00
case st_wordcmp :
if ( ( c = = ' = ' ) & & ! * opptr ) {
/*
* We matched all the way to the end of the
* option we were looking for , prepare to
* copy the argument .
*/
len = 0 ;
bufptr = buffer ;
state = st_bufcpy ;
break ;
} else if ( c = = * opptr + + ) {
/*
* We are currently matching , so continue
* to the next character on the cmdline .
*/
break ;
}
state = st_wordskip ;
2020-08-24 01:36:59 +03:00
fallthrough ;
2017-07-18 00:10:33 +03:00
case st_wordskip :
if ( myisspace ( c ) )
state = st_wordstart ;
break ;
case st_bufcpy :
if ( myisspace ( c ) ) {
state = st_wordstart ;
} else {
/*
* Increment len , but don ' t overrun the
* supplied buffer and leave room for the
* NULL terminator .
*/
if ( + + len < bufsize )
* bufptr + + = c ;
}
break ;
}
}
if ( bufsize )
* bufptr = ' \0 ' ;
return len ;
}
2015-12-23 01:52:43 +03:00
int cmdline_find_option_bool ( const char * cmdline , const char * option )
{
return __cmdline_find_option_bool ( cmdline , COMMAND_LINE_SIZE , option ) ;
}
2017-07-18 00:10:33 +03:00
int cmdline_find_option ( const char * cmdline , const char * option , char * buffer ,
int bufsize )
{
return __cmdline_find_option ( cmdline , COMMAND_LINE_SIZE , option ,
buffer , bufsize ) ;
}