DAOS-18625 utils: interpret key based to object's type for ddb output

Current ddb logic may print some integer keys' output as not-readable,
for example dkey 10, 60 will be printed as following:
DKEY: (/[4]/[2]/[0]) /b2b37b1a-2894-4970-b51c-1a964526bb02/948289433254841843.256.535.2/ {8}
DKEY: (/[4]/[2]/[2]) /b2b37b1a-2894-4970-b51c-1a964526bb02/948289433254841843.256.535.2/<{8}

That is very confused. The patch defines new ddb_key_to_printable_buf()
interface that will interpret key based to object's type and generate
more readable ddb output.

Signed-off-by: Xuezhao Liu <xuezhao.liu@hpe.com>
Signed-off-by: Fan Yong <fan.yong@hpe.com>

Author: Nasf-Fan

src/utils/ddb/ddb_commands.c

@@ -306,7 +306,7 @@ print_value_cb(void *cb_args, d_iov_t *value)
 		return 0;
 	}
 
-	ddb_iov_to_printable_buf(value, buf, ARRAY_SIZE(buf));
+	ddb_iov_to_printable_buf(value, buf, ARRAY_SIZE(buf), NULL);
 	ddb_printf(ctx, "Value (size: %lu):\n", value->iov_len);
 	ddb_printf(ctx, "%s\n", buf);
 	return 0;

src/utils/ddb/ddb_parse.h

@@ -44,7 +44,7 @@ void ddb_str2argv_free(struct argv_parsed *parse_args);
 int ddb_parse_program_args(struct ddb_ctx *ctx, uint32_t argc, char **argv,
 			   struct program_args *pa);
 
-/* See ddb_iov_to_printable_buf for how the keys will be printed */
+/* See ddb_key_to_printable_buf for how the keys will be printed */
 int ddb_parse_key(const char *input, daos_key_t *key);
 
 /* Parse a string into the parts of a dtx_id. See DF_DTIF for how the format of the dtx_id is

src/utils/ddb/ddb_printer.c

@@ -24,69 +24,93 @@ ddb_can_print(d_iov_t *iov)
 	uint32_t len = iov->iov_len;
 	int	 i;
 
-	for (i = 0 ; i < len ; i++) {
+	for (i = 0; i < len; i++) {
 		if (str[i] == '\0')
 			return true;
-		if (!isprint(str[i]) && str[i] != '\n' && str[i] != '\r')
+
+		if (!isprint(str[i]))
 			return false;
 	}
+
 	return true;
 }
 
 /*
- * Converts contents of an iov to something that is more printable.
+ * Converts contents of an @iov to something that is more printable.
  *
- * Returns number of characters that would have been written if buf_len was long
- * enough, not including null terminator
+ * Returns number of characters that would have been written if @buf is large enough,
+ * not including the null terminator.
  */
-int
-ddb_iov_to_printable_buf(d_iov_t *iov, char buf[], uint32_t buf_len)
+uint32_t
+ddb_iov_to_printable_buf(d_iov_t *iov, char buf[], uint32_t buf_len, const char *prefix)
 {
+	char     tmp[32];
+	uint32_t new_len;
+	uint32_t result = 0;
+	int      i;
+
 	if (iov->iov_len == 0 || iov->iov_buf == NULL)
 		return 0;
 
 	if (ddb_can_print(iov))
 		return snprintf(buf, buf_len, "%.*s", (int)iov->iov_len, (char *)iov->iov_buf);
 
-	switch (iov->iov_len) {
-	case sizeof(uint8_t):
-		return snprintf(buf, buf_len, "uint8:0x%x", ((uint8_t *)iov->iov_buf)[0]);
-	case sizeof(uint16_t):
-		return snprintf(buf, buf_len, "uint16:0x%04hx", ((uint16_t *)iov->iov_buf)[0]);
-	case sizeof(uint32_t):
-		return snprintf(buf, buf_len, "uint32:0x%x", ((uint32_t *)iov->iov_buf)[0]);
-	case sizeof(uint64_t):
-		return snprintf(buf, buf_len, "uint64:0x%lx", ((uint64_t *)iov->iov_buf)[0]);
-	default:
-	{
-		char		tmp_buf[32];
-		uint32_t	new_len;
-		uint32_t	result = 0;
-		int		i;
-
-		result += snprintf(buf, buf_len, "bin(%lu):0x", iov->iov_len);
-
-		for (i = 0; i < iov->iov_len; i++) {
-			new_len = snprintf(tmp_buf, ARRAY_SIZE(tmp_buf), "%02x",
-					   ((uint8_t *)iov->iov_buf)[i]);
-			if (new_len + result > buf_len) {
-				/* Buffer not big enough */
-				result += new_len;
-			} else {
-				result += sprintf(buf + result, "%s", tmp_buf);
-			}
-		}
+	if (prefix != NULL)
+		result = snprintf(buf, buf_len, "%s", prefix);
 
-		if (result > buf_len) {
-			buf[buf_len - 1] = '\0';
-			buf[buf_len - 2] = '.';
-			buf[buf_len - 3] = '.';
-			buf[buf_len - 4] = '.';
+	for (i = 0; i < iov->iov_len; i++) {
+		new_len = snprintf(tmp, ARRAY_SIZE(tmp), "%02x", ((uint8_t *)iov->iov_buf)[i]);
+		if (new_len + result > buf_len)
+			result += new_len; /* Buffer is not big enough. */
+		else
+			result += sprintf(buf + result, "%s", tmp);
+	}
 
-		}
-		return result;
+	if (result > buf_len) {
+		buf[buf_len - 1] = '\0';
+		for (i = 2; buf_len >= i && i <= 4; i++)
+			buf[buf_len - i] = '.';
 	}
+
+	return result;
+}
+
+/*
+ * Converts contents of an @key to something that is more printable.
+ *
+ * Returns number of characters that would have been written if @buf is long enough,
+ * not including the null terminator.
+ */
+uint32_t
+ddb_key_to_printable_buf(daos_key_t *key, enum daos_otype_t otype, char buf[], uint32_t buf_len)
+{
+	char tmp[32];
+
+	if (key->iov_len == 0 || key->iov_buf == NULL)
+		return 0;
+
+	if (ddb_key_is_lexical(otype))
+		return snprintf(buf, buf_len, "%.*s", (int)key->iov_len, (char *)key->iov_buf);
+
+	if (ddb_key_is_int(otype)) {
+		switch (key->iov_len) {
+		case sizeof(uint8_t):
+			return snprintf(buf, buf_len, "uint8:0x%x", ((uint8_t *)key->iov_buf)[0]);
+		case sizeof(uint16_t):
+			return snprintf(buf, buf_len, "uint16:0x%04hx",
+					((uint16_t *)key->iov_buf)[0]);
+		case sizeof(uint32_t):
+			return snprintf(buf, buf_len, "uint32:0x%x", ((uint32_t *)key->iov_buf)[0]);
+		case sizeof(uint64_t):
+			return snprintf(buf, buf_len, "uint64:0x%lx",
+					((uint64_t *)key->iov_buf)[0]);
+			/* Fall through. */
+		}
 	}
+
+	snprintf(tmp, ARRAY_SIZE(tmp), "bin(%lu):0x", key->iov_len);
+
+	return ddb_iov_to_printable_buf(key, buf, buf_len, tmp);
 }
 
 void
@@ -115,22 +139,22 @@ ddb_print_key(struct ddb_ctx *ctx, struct ddb_key *key, uint32_t indent)
 
 	memset(buf, 0, buf_len);
 
-	ddb_iov_to_printable_buf(&key->ddbk_key, buf, buf_len);
+	ddb_key_to_printable_buf(&key->ddbk_key, key->ddbk_otype, buf, buf_len);
 
 	print_indent(ctx, indent);
-	if (ddb_can_print(&key->ddbk_key)) {
-		ddb_printf(ctx, DF_IDX" '%s' (%lu)%s\n",
-			   DP_IDX(key->ddbk_idx),
-			   buf,
-			   key->ddbk_key.iov_len,
-			   key->ddbk_child_type == VOS_ITER_SINGLE ? " (SV)" :
-			   key->ddbk_child_type == VOS_ITER_RECX ? " (ARRAY)" : "");
-		return;
-	}
 
-	ddb_printf(ctx, DF_IDX" {%s}%s\n", DP_IDX(key->ddbk_idx), buf,
-		   key->ddbk_child_type == VOS_ITER_SINGLE ? " (SV)" :
-		   key->ddbk_child_type == VOS_ITER_RECX ? " (ARRAY)" : "");
+	if (ddb_key_is_lexical(key->ddbk_otype) ||
+	    (!ddb_key_is_int(key->ddbk_otype) && ddb_can_print(&key->ddbk_key)))
+		ddb_printf(ctx, DF_IDX " '%s' (%lu)%s\n", DP_IDX(key->ddbk_idx), buf,
+			   key->ddbk_key.iov_len,
+			   key->ddbk_child_type == VOS_ITER_SINGLE ? " (SV)"
+			   : key->ddbk_child_type == VOS_ITER_RECX ? " (ARRAY)"
+								   : "");
+	else
+		ddb_printf(ctx, DF_IDX " {%s}%s\n", DP_IDX(key->ddbk_idx), buf,
+			   key->ddbk_child_type == VOS_ITER_SINGLE ? " (SV)"
+			   : key->ddbk_child_type == VOS_ITER_RECX ? " (ARRAY)"
+								   : "");
 }
 
 void

src/utils/ddb/ddb_printer.h

@@ -1,5 +1,6 @@
 /**
  * (C) Copyright 2022 Intel Corporation.
+ * (C) Copyright 2025-2026 Hewlett Packard Enterprise Development LP
  *
  * SPDX-License-Identifier: BSD-2-Clause-Patent
  */
@@ -12,7 +13,10 @@
 #define DF_IDX "[%d]"
 #define DP_IDX(idx) idx
 
-int ddb_iov_to_printable_buf(d_iov_t *iov, char buf[], uint32_t buf_len);
+uint32_t
+ddb_iov_to_printable_buf(d_iov_t *iov, char buf[], uint32_t buf_len, const char *prefix);
+uint32_t
+ddb_key_to_printable_buf(daos_key_t *key, enum daos_otype_t otype, char buf[], uint32_t buf_len);
 void ddb_print_cont(struct ddb_ctx *ctx, struct ddb_cont *cont);
 void ddb_print_obj(struct ddb_ctx *ctx, struct ddb_obj *obj, uint32_t indent);
 void ddb_print_key(struct ddb_ctx *ctx, struct ddb_key *key, uint32_t indent);
@@ -29,5 +33,16 @@ bool ddb_can_print(d_iov_t *iov);
 /* some utility functions helpful for printing */
 void ddb_bytes_hr(uint64_t bytes, char *buf, uint32_t buf_len);
 
+static inline bool
+ddb_key_is_lexical(enum daos_otype_t otype)
+{
+	return daos_is_dkey_lexical_type(otype) || daos_is_akey_lexical_type(otype);
+}
+
+static inline bool
+ddb_key_is_int(enum daos_otype_t otype)
+{
+	return daos_is_dkey_uint64_type(otype) || daos_is_akey_uint64_type(otype);
+}
 
 #endif /* DAOS_DDB_PRINTER_H */