Skip to contentSkip to conversation

btrfs-progs: parser related cleanups

PATCH Superseded Qu Wenruo 1 participant 2 messages Jan 17, 2024 Btrfs file system

lore
Share & tools
lore

Qu Wenruo

author
#0 lore raw

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

author
#1 lore raw

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
index 3d9a6d637a7f..9b34f95d64df 100644
@@ -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
index e338afa75711..ba5cc55a6daa 100644
@@ -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
index ade8fcd1f66b..a7ac8f5c7efa 100644
@@ -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