DAOS-17321 ddb: Checksum management with ddb

First commit.

Signed-off-by: Cedric Koch-Hofer <[email protected]>

Author: kanard38

src/control/cmd/ddb/commands_wrapper.go

@@ -349,3 +349,14 @@ func ddbDtxAggr(ctx *DdbContext, path string, cmt_time uint64, cmt_date string)
 	/* Run the c code command */
 	return daosError(C.ddb_run_dtx_aggr(&ctx.ctx, &options))
 }
+
+func ddbCsumDump(ctx *DdbContext, path string, dst string) error {
+	/* Set up the options */
+	options := C.struct_csum_dump_options{}
+	options.path = C.CString(path)
+	defer freeString(options.path)
+	options.dst = C.CString(dst)
+	defer freeString(options.dst)
+	/* Run the c code command */
+	return daosError(C.ddb_run_csum_dump(&ctx.ctx, &options))
+}

src/control/cmd/ddb/ddb_commands.go

@@ -442,4 +442,23 @@ the path must include the extent, otherwise, it must not.`,
 		},
 		Completer: nil,
 	})
+	// Command dtx_aggr
+	app.AddCommand(&grumble.Command{
+		Name:    "csum_dump",
+		Aliases: nil,
+		Help:    "Dump checksum information",
+		LongHelp: `Dump a checksum to the screen or file. The vos path should be a complete path,
+including the akey and if the value is an array value it should include the
+extent. If a path to a file was provided then the value will be written to the
+file, else it will be printed to the screen.`,
+		HelpGroup: "vos",
+		Args: func(a *grumble.Args) {
+			a.String("path", "VOS tree path to dump.")
+			a.String("dst", "Optional, destination vos tree path to a value.", grumble.Default(""))
+		},
+		Run: func(c *grumble.Context) error {
+			return ddbCsumDump(ctx, c.Args.String("path"), c.Args.String("dst"))
+		},
+		Completer: nil,
+	})
 }

src/include/daos_srv/vos.h

@@ -723,6 +723,13 @@ vos_obj_fetch_ex(daos_handle_t coh, daos_unit_oid_t oid, daos_epoch_t epoch,
 		 uint64_t flags, daos_key_t *dkey, unsigned int iod_nr,
 		 daos_iod_t *iods, d_sg_list_t *sgls, struct dtx_handle *dth);
 
+/**
+ * TODO DAOS-17321
+ */
+int
+vos_csum_fetch(daos_handle_t coh, daos_key_t *dkey, daos_unit_oid_t oid, daos_iod_t *iod,
+	       struct dcs_ci_list *cil);
+
 /**
  * Update records for the specified object.
  * If input buffer is not provided in \a sgl, then this function returns

src/include/daos_srv/vos_types.h

@@ -258,49 +258,51 @@ typedef enum {
 
 enum {
 	/** Conditional Op: Punch key if it exists, fail otherwise */
-	VOS_OF_COND_PUNCH		= DAOS_COND_PUNCH,
+	VOS_OF_COND_PUNCH = DAOS_COND_PUNCH,
 	/** Conditional Op: Insert dkey if it doesn't exist, fail otherwise */
-	VOS_OF_COND_DKEY_INSERT		= DAOS_COND_DKEY_INSERT,
+	VOS_OF_COND_DKEY_INSERT = DAOS_COND_DKEY_INSERT,
 	/** Conditional Op: Update dkey if it exists, fail otherwise */
-	VOS_OF_COND_DKEY_UPDATE		= DAOS_COND_DKEY_UPDATE,
+	VOS_OF_COND_DKEY_UPDATE = DAOS_COND_DKEY_UPDATE,
 	/** Conditional Op: Fetch dkey if it exists, fail otherwise */
-	VOS_OF_COND_DKEY_FETCH		= DAOS_COND_DKEY_FETCH,
+	VOS_OF_COND_DKEY_FETCH = DAOS_COND_DKEY_FETCH,
 	/** Conditional Op: Insert akey if it doesn't exist, fail otherwise */
-	VOS_OF_COND_AKEY_INSERT		= DAOS_COND_AKEY_INSERT,
+	VOS_OF_COND_AKEY_INSERT = DAOS_COND_AKEY_INSERT,
 	/** Conditional Op: Update akey if it exists, fail otherwise */
-	VOS_OF_COND_AKEY_UPDATE		= DAOS_COND_AKEY_UPDATE,
+	VOS_OF_COND_AKEY_UPDATE = DAOS_COND_AKEY_UPDATE,
 	/** Conditional Op: Fetch akey if it exists, fail otherwise */
-	VOS_OF_COND_AKEY_FETCH		= DAOS_COND_AKEY_FETCH,
+	VOS_OF_COND_AKEY_FETCH = DAOS_COND_AKEY_FETCH,
 	/** Indicates akey conditions are specified in iod_flags */
-	VOS_OF_COND_PER_AKEY		= DAOS_COND_PER_AKEY,
+	VOS_OF_COND_PER_AKEY = DAOS_COND_PER_AKEY,
 	/* critical update - skip checks on SCM system/held space */
-	VOS_OF_CRIT			= (1 << 8),
+	VOS_OF_CRIT = (1 << 8),
 	/** Instead of update or punch of extents, remove all extents
 	 * under the specified range. Intended for internal use only.
 	 */
-	VOS_OF_REMOVE			= (1 << 9),
+	VOS_OF_REMOVE = (1 << 9),
 	/* only query iod_size */
-	VOS_OF_FETCH_SIZE_ONLY		= (1 << 10),
+	VOS_OF_FETCH_SIZE_ONLY = (1 << 10),
 	/* query recx list */
-	VOS_OF_FETCH_RECX_LIST		= (1 << 11),
+	VOS_OF_FETCH_RECX_LIST = (1 << 11),
 	/* only set read TS */
-	VOS_OF_FETCH_SET_TS_ONLY	= (1 << 12),
+	VOS_OF_FETCH_SET_TS_ONLY = (1 << 12),
 	/* check the target (obj/dkey/akey) existence */
-	VOS_OF_FETCH_CHECK_EXISTENCE	= (1 << 13),
+	VOS_OF_FETCH_CHECK_EXISTENCE = (1 << 13),
 	/** Set when propagating a punch that results in empty subtree */
-	VOS_OF_PUNCH_PROPAGATE		= (1 << 14),
+	VOS_OF_PUNCH_PROPAGATE = (1 << 14),
 	/** replay punch (underwrite) */
-	VOS_OF_REPLAY_PC		= (1 << 15),
+	VOS_OF_REPLAY_PC = (1 << 15),
 	/** Dedup update mode */
-	VOS_OF_DEDUP			= (1 << 16),
+	VOS_OF_DEDUP = (1 << 16),
 	/** Dedup update with memcmp verify mode */
-	VOS_OF_DEDUP_VERIFY		= (1 << 17),
+	VOS_OF_DEDUP_VERIFY = (1 << 17),
 	/** Ignore fetch only used by shadow fetch to ignore the evt fetch */
-	VOS_OF_SKIP_FETCH		= (1 << 18),
+	VOS_OF_SKIP_FETCH = (1 << 18),
 	/** Operation on EC object (currently only applies to update) */
-	VOS_OF_EC			= (1 << 19),
+	VOS_OF_EC = (1 << 19),
 	/** Update from rebuild */
-	VOS_OF_REBUILD			= (1 << 20),
+	VOS_OF_REBUILD = (1 << 20),
+	/* only query iod_size */
+	VOS_OF_FETCH_CSUM_ONLY = (1 << 21),
 };
 
 enum {

src/utils/ddb/ddb.h

@@ -236,6 +236,11 @@ struct dtx_aggr_options {
 	char                *cmt_date;
 };
 
+struct csum_dump_options {
+	char *path;
+	char *dst;
+};
+
 struct ddb_cmd_info {
 	enum ddb_cmd dci_cmd;
 	union {
@@ -330,6 +335,8 @@ int
 ddb_run_prov_mem(struct ddb_ctx *ctx, struct prov_mem_options *opt);
 int
 ddb_run_dtx_aggr(struct ddb_ctx *ctx, struct dtx_aggr_options *opt);
+int
+ddb_run_csum_dump(struct ddb_ctx *ctx, struct csum_dump_options *opt);
 
 void
 ddb_program_help(struct ddb_ctx *ctx);

src/utils/ddb/ddb_commands.c

@@ -366,6 +366,150 @@ ddb_run_value_dump(struct ddb_ctx *ctx, struct value_dump_options *opt)
 	return rc;
 }
 
+struct dump_csum_args {
+	struct ddb_ctx              *dca_ctx;
+	struct dv_indexed_tree_path *dca_vtp;
+	char                        *dca_dst_path;
+};
+
+struct dump_csum_value {
+	char    *dcv_type;
+	uint16_t dcv_length;
+	uint8_t *dcv_buf;
+};
+
+static int
+dump_csum_wrap(struct dump_csum_args *args, struct dcs_ci_list *cil, struct dump_csum_value *dcv)
+{
+	struct dcs_csum_info *ci;
+	struct hash_ft       *hf;
+
+	if (cil->dcl_csum_infos_nr == 0)
+		return -DER_NONEXIST;
+	D_ASSERT(cil->dcl_csum_infos_nr == 1);
+
+	ci = dcs_csum_info_get(cil, 0);
+	D_ASSERT(ci_is_valid(ci));
+	D_ASSERT(ci->cs_nr == 1);
+	hf = daos_mhash_type2algo(ci->cs_type);
+
+	dcv->dcv_type   = hf->cf_name;
+	dcv->dcv_length = ci->cs_len;
+	dcv->dcv_buf    = ci_idx2csum(ci, 0);
+
+	return 0;
+}
+
+static int
+print_csum_cb(void *cb_args, struct dcs_ci_list *cil)
+{
+	struct dump_csum_args *args;
+	struct ddb_ctx        *ctx;
+	struct dump_csum_value dcv;
+	int                    i;
+	int                    rc;
+
+	args = cb_args;
+	ctx  = args->dca_ctx;
+
+	rc = dump_csum_wrap(cb_args, cil, &dcv);
+	if (!SUCCESS(rc)) {
+		D_ASSERT(-DER_NONEXIST);
+
+		ddb_print(ctx, "No check-sum at: ");
+		itp_print_full(ctx, args->dca_vtp);
+		ddb_print(ctx, "\n");
+		return 0;
+	}
+
+	itp_print_full(ctx, args->dca_vtp);
+	ddb_print(ctx, "\n");
+	ddb_printf(ctx, "Type: %s, Length: %" PRIu16 ", Value: 0x", dcv.dcv_type, dcv.dcv_length);
+	for (i = 0; i < dcv.dcv_length; i++)
+		ddb_printf(ctx, "%02" PRIx8, dcv.dcv_buf[i]);
+	ddb_print(ctx, "\n");
+
+	return 0;
+}
+
+static int
+write_file_csum_cb(void *cb_args, struct dcs_ci_list *cil)
+{
+	struct dump_csum_args *args;
+	struct ddb_ctx        *ctx;
+	struct dump_csum_value dcv;
+	d_iov_t                value;
+	int                    rc;
+
+	args = cb_args;
+	ctx  = args->dca_ctx;
+
+	D_ASSERT(ctx->dc_io_ft.ddb_write_file);
+
+	rc = dump_csum_wrap(cb_args, cil, &dcv);
+	if (!SUCCESS(rc)) {
+		D_ASSERT(-DER_NONEXIST);
+
+		ddb_print(ctx, "No check-sum at: ");
+		itp_print_full(ctx, args->dca_vtp);
+		ddb_print(ctx, "\n");
+		return 0;
+	}
+	value.iov_buf     = dcv.dcv_buf;
+	value.iov_len     = dcv.dcv_length;
+	value.iov_buf_len = dcv.dcv_length;
+
+	ddb_printf(ctx, "Dumping chekck-sum (type: %s, length: %" PRIu16 ") to %s\n", dcv.dcv_type,
+		   dcv.dcv_length, args->dca_dst_path);
+	rc = ctx->dc_io_ft.ddb_write_file(args->dca_dst_path, &value);
+	return rc;
+}
+
+int
+ddb_run_csum_dump(struct ddb_ctx *ctx, struct csum_dump_options *opt)
+{
+	struct dv_indexed_tree_path itp = {0};
+	struct dv_tree_path         vtp;
+	struct dump_csum_args       dca = {0};
+	dv_dump_csum_cb             cb  = NULL;
+	int                         rc;
+
+	if (!opt->path) {
+		ddb_error(ctx, "A VOS path to dump is required.\n");
+		rc = -DER_INVAL;
+		goto out;
+	}
+
+	rc = init_path(ctx, opt->path, &itp);
+	if (!SUCCESS(rc))
+		goto out;
+
+	if (!itp_has_value(&itp)) {
+		ddb_errorf(ctx, "Path [%s] is incomplete.\n", opt->path);
+		rc = -DDBER_INCOMPLETE_PATH_VALUE;
+		goto out_itp;
+	}
+
+	if (opt->dst && opt->dst[0] != '\0')
+		cb = write_file_csum_cb;
+	else
+		cb = print_csum_cb;
+
+	dca.dca_dst_path = opt->dst;
+	dca.dca_ctx      = ctx;
+	dca.dca_vtp      = &itp;
+
+	itp_to_vos_path(&itp, &vtp);
+
+	rc = dv_dump_csum(ctx->dc_poh, &vtp, cb, &dca);
+
+out_itp:
+	itp_free(&itp);
+
+out:
+	return rc;
+}
+
 static int
 dump_ilog_entry_cb(void *cb_arg, struct ddb_ilog_entry *entry)
 {

src/utils/ddb/ddb_vos.c

@@ -1027,6 +1027,55 @@ dv_dump_value(daos_handle_t poh, struct dv_tree_path *path, dv_dump_value_cb dum
 	return rc;
 }
 
+int
+dv_dump_csum(daos_handle_t poh, struct dv_tree_path *path, dv_dump_csum_cb dump_cb, void *cb_arg)
+{
+	daos_iod_t         iod = {0};
+	daos_handle_t      coh;
+	struct dcs_ci_list cil;
+	int                rc;
+
+	rc = vos_cont_open(poh, path->vtp_cont, &coh);
+	if (!SUCCESS(rc)) {
+		D_ERROR("Unable to fetch object: " DF_RC "\n", DP_RC(rc));
+		goto out;
+	}
+
+	iod.iod_name  = path->vtp_akey;
+	iod.iod_recxs = &path->vtp_recx;
+	iod.iod_nr    = 1;
+	iod.iod_size  = 0;
+	iod.iod_type  = path->vtp_recx.rx_nr == 0 ? DAOS_IOD_SINGLE : DAOS_IOD_ARRAY;
+
+	rc = dcs_csum_info_list_init(&cil, 0);
+	if (!SUCCESS(rc)) {
+		D_ERROR("Unable to init csum list: " DF_RC "\n", DP_RC(rc));
+		goto out_cont;
+	}
+
+	rc = vos_csum_fetch(coh, &path->vtp_dkey, path->vtp_oid, &iod, &cil);
+	if (!SUCCESS(rc)) {
+		D_ERROR("Unable to fetch csum: " DF_RC "\n", DP_RC(rc));
+		goto out_cil;
+	}
+
+	if (!dump_cb)
+		goto out_cil;
+	rc = dump_cb(cb_arg, &cil);
+	if (!SUCCESS(rc)) {
+		D_ERROR("Unable to dump csum: " DF_RC "\n", DP_RC(rc));
+	}
+
+out_cil:
+	dcs_csum_info_list_fini(&cil);
+
+out_cont:
+	vos_cont_close(coh);
+
+out:
+	return rc;
+}
+
 static void
 ilog_entry_status(enum ilog_status status, char *status_str, uint32_t status_str_len)
 {

src/utils/ddb/ddb_vos.h

@@ -139,6 +139,11 @@ typedef int (*dv_dump_value_cb)(void *cb_arg, d_iov_t *value);
 int dv_dump_value(daos_handle_t poh, struct dv_tree_path *path, dv_dump_value_cb dump_cb,
 		  void *cb_arg);
 
+typedef int (*dv_dump_csum_cb)(void *cb_arg, struct dcs_ci_list *cil);
+
+int
+dv_dump_csum(daos_handle_t poh, struct dv_tree_path *path, dv_dump_csum_cb dump_cb, void *cb_arg);
+
 struct ddb_ilog_entry {
 	uint32_t	die_idx;
 	int32_t		die_status;