btrfs-progs: parser related cleanups
v2 cover btrfs-progs: parser related cleanups
[CHANGELOG]
v2:
- Properly return the parsed value for parse_u64_with_suffix() Facepalm, I forgot to assign the result to @value_ret, and only relied on cli-tests to catch them, but they are not enough to catch.
- Avoid outputting any error message inside parse_u64_with_suffix() One error message and exit(1) call is left from previous function. Need to be consistent with all other error situations.
- Rebased using the patch from devel branch
So that the modification David did won't need to be redone.
Btrfs-progs has two types of parsers:
- parse_*()
Those would return 0 for a good parse, and save the value into a pointer.
Callers are responsible to handle the error.
- arg_strto*()
Those would directly return the parsed value, and call exit(1) directly for errors.
However this split is not perfect:
- A lot of code can be shared between them
In fact, mostly arg_strto*() can be implement using parse_*(). The only difference is in how detailed the error string would be.
- parse_size_from_string() doesn't follow the scheme It follows arg_strto*() behavior but has the parse_*() name.
This patch would:
- Use parse_u64() to implement arg_strtou64()
The first patch.
- Use parse_u64_with_suffix() to implement arg_strtou64_with_suffix() The new helper parse_u64_with_suffix() would replace the old parse_size_from_string() and do the proper error handling.
Qu Wenruo (2):
btrfs-progs: use parse_u64() to implement arg_strtou64()
btrfs-progs: implement arg_strtou64_with_suffix() with a new helper
cmds/filesystem.c | 15 ++++---- cmds/qgroup.c | 3 +- cmds/reflink.c | 7 ++-- cmds/scrub.c | 2 +- common/parse-utils.c | 90 +++++++++++++++++++++++++++---------------- common/parse-utils.h | 2 +- common/string-utils.c | 45 ++++++++++++++-------- common/string-utils.h | 9 +++++ convert/main.c | 3 +- kernel-shared/zoned.c | 4 +- mkfs/main.c | 6 +-- 11 files changed, 118 insertions(+), 68 deletions(-)
--
2.43.0
PATCH v2 1/2 btrfs-progs: use parse_u64() to implement arg_strtou64()
Both functions are just doing the same thing, the only difference is only in error handling, as parse_u64() requires callers to handle it, meanwhile arg_strtou64() would call exit(1).
This patch would convert arg_strtou64() to utilize parse_u64(), and use the return value to output different error messages.
This also means the return value of parse_u64() would be more than just 0 or 1, but -EINVAL for invalid string (including no numeric string at all, has any tailing characters, or minus value), and -ERANGE for overflow.
The existing callers are only checking if the return value is 0, thus not really affected.
--- common/parse-utils.c | 19 ++++++++++++++++++- common/string-utils.c | 26 ++++++++++---------------- common/string-utils.h | 2 ++ 3 files changed, 30 insertions(+), 17 deletions(-)
common/parse-utils.c +18 -1
@@ -31,14 +31,31 @@#include "common/messages.h" #include "common/utils.h" +/* +* Parse a string to u64. +* +* Return 0 if there is a valid numeric string and result would be stored in +* @result. +* Return -EINVAL if the string is not valid (no numeric string at all, or +* has any tailing characters, or a negative value). +* Return -ERANGE if the value is too larger for u64. +*/ int parse_u64 (const char *str,u64 *result) {char *endptr;u64 val; +/* +* Although strtoull accepts a negative number and converts it u64, we +* don't really want to utilize this as the helper is meant for u64 only. +*/ +if (str[0 ] =='-' ) +return -EINVAL ; val =strtoull (str, &endptr,10 );if (*endptr) -return 1 ; +return -EINVAL ; +if (val ==ULLONG_MAX && errno ==ERANGE ) +return -ERANGE ; *result = val;return 0 ;
common/string-utils.c +10 -16
@@ -20,6 +20,7 @@#include <limits.h> #include "common/string-utils.h" #include "common/messages.h" +#include "common/parse-utils.h" int string_is_numerical (const char *str) {
@@ -50,25 +51,18 @@ int string_has_prefix(const char *str, const char *prefix)u64 arg_strtou64 (const char *str) {u64 value; -char *ptr_parse_end =NULL ; +int ret; - value =strtoull (str, &ptr_parse_end,0 ); -if (ptr_parse_end && *ptr_parse_end !='\0' ) { -error ("%s is not a valid numeric value" , str); -exit (1 ); - } - -/* -* if we pass a negative number to strtoull, it will return an -* unexpected number to us, so let's do the check ourselves. -*/ -if (str[0 ] =='-' ) { -error ("%s: negative value is invalid" , str); -exit (1 ); - } -if (value ==ULLONG_MAX ) { + ret =parse_u64 (str, &value); +if (ret == -ERANGE ) {error ("%s is too large" , str);exit (1 ); + }else if (ret == -EINVAL ) { +if (str[0 ] =='-' ) +error ("%s: negative value is invalid" , str); +else +error ("%s is not a valid numeric value" , str); +exit (1 ); }return value; }
common/string-utils.h +2 -0
@@ -17,6 +17,8 @@#ifndef __BTRFS_STRING_UTILS_H__#define __BTRFS_STRING_UTILS_H__ +#include "kerncompat.h" +int string_is_numerical (const char *str);int string_has_prefix (const char *str,const char *prefix);u64 arg_strtou64 (const char *str);
Signature · 1 line
2.43.0