settings: add an API function to load only one settings entry

Add a a function settings_load_one that allows to load only one settings
entry instead of a complete subtree.
Add as well its implementation for ZMS backend.
This will allow a faster return if the Settings entry doesn't exist in
the persistent storage.

Signed-off-by: Riadh Ghaddab <rghaddab@baylibre.com>

Author: rghaddab

include/zephyr/settings/settings.h

@@ -278,6 +278,17 @@ int settings_load(void);
  */
 int settings_load_subtree(const char *subtree);
 
+/**
+ * Load one serialized item from registered persistence sources.
+ *
+ * @param[in]  name    Name/key of the settings item.
+ * @param[out] buf     Pointer to the buffer where the data is going to be loaded
+ * @param[in]  buf_len Length of the allocated buffer.
+ * @return     actual size of value that corresponds to name on success, negative
+ *             value on failure.
+ */
+ssize_t settings_load_one(const char *name, void *buf, size_t buf_len);
+
 /**
  * Callback function used for direct loading.
  * Used by @ref settings_load_subtree_direct function.
@@ -457,6 +468,17 @@ struct settings_store_itf {
 	 * load callback only on the final entity.
 	 */
 
+	ssize_t (*csi_load_one)(struct settings_store *cs, const char *name,
+				char *buf, size_t buf_len);
+	/**< Loads one value from storage that corresponds to the key defined by name.
+	 *
+	 * Parameters:
+	 *  - cs - Corresponding backend handler node.
+	 *  - name - Key in string format.
+	 *  - buf - Buffer where data should be copied.
+	 *  - buf_len - Length of buf.
+	 */
+
 	int (*csi_save_start)(struct settings_store *cs);
 	/**< Handler called before an export operation.
 	 *

subsys/settings/src/settings_store.c

@@ -88,6 +88,67 @@ int settings_load_subtree_direct(
 	return 0;
 }
 
+struct default_param {
+	void *buf;
+	size_t buf_len;
+	size_t *val_len;
+};
+
+static int settings_set_default_cb(const char *name, size_t len, settings_read_cb read_cb,
+				   void *cb_arg, void *param)
+{
+	int rc = 0;
+	const char *next;
+	size_t name_len;
+	struct default_param *dest = (struct default_param *)param;
+
+	name_len = settings_name_next(name, &next);
+	if (name_len == 0) {
+		rc = read_cb(cb_arg, dest->buf, MIN(dest->buf_len, len));
+		*dest->val_len = len;
+	}
+
+	return rc;
+}
+
+/* Load a single key/value from persistent storage */
+ssize_t settings_load_one(const char *name, void *buf, size_t buf_len)
+{
+	struct settings_store *cs;
+	size_t val_len = 0;
+	int rc = 0;
+
+	/*
+	 * For every config store that defines csi_load_one() function use it.
+	 * Otherwise, use the csi_load() function to load the key/value pair
+	 */
+	k_mutex_lock(&settings_lock, K_FOREVER);
+	SYS_SLIST_FOR_EACH_CONTAINER(&settings_load_srcs, cs, cs_next) {
+		if (cs->cs_itf->csi_load_one) {
+			rc = cs->cs_itf->csi_load_one(cs, name, (char *)buf, buf_len);
+			val_len = (rc >= 0) ? rc : 0;
+		} else {
+			struct default_param param = {
+				.buf = buf,
+				.buf_len = buf_len,
+				.val_len = &val_len
+			};
+			const struct settings_load_arg arg = {
+				.subtree = name,
+				.cb = &settings_set_default_cb,
+				.param = &param
+			};
+			rc = cs->cs_itf->csi_load(cs, &arg);
+		}
+	}
+	k_mutex_unlock(&settings_lock);
+
+	if (rc >= 0) {
+		return val_len;
+	}
+	return rc;
+}
+
 /*
  * Append a single value to persisted config. Don't store duplicate value.
  */

subsys/settings/src/settings_zms.c

@@ -27,12 +27,15 @@ struct settings_zms_read_fn_arg {
 };
 
 static int settings_zms_load(struct settings_store *cs, const struct settings_load_arg *arg);
+static ssize_t settings_zms_load_one(struct settings_store *cs, const char *name, char *buf,
+				     size_t buf_len);
 static int settings_zms_save(struct settings_store *cs, const char *name, const char *value,
 			     size_t val_len);
 static void *settings_zms_storage_get(struct settings_store *cs);
 static int settings_zms_get_last_hash_ids(struct settings_zms *cf);
 
 static struct settings_store_itf settings_zms_itf = {.csi_load = settings_zms_load,
+						     .csi_load_one = settings_zms_load_one,
 						     .csi_save = settings_zms_save,
 						     .csi_storage_get = settings_zms_storage_get};
 
@@ -203,6 +206,50 @@ static int settings_zms_load_subtree(struct settings_store *cs, const struct set
 }
 #endif /* CONFIG_SETTINGS_ZMS_LOAD_SUBTREE_PATH */
 
+static ssize_t settings_zms_load_one(struct settings_store *cs, const char *name, char *buf,
+				     size_t buf_len)
+{
+	struct settings_zms *cf = CONTAINER_OF(cs, struct settings_zms, cf_store);
+	char r_name[SETTINGS_MAX_NAME_LEN + SETTINGS_EXTRA_LEN + 1];
+	ssize_t rc = 0;
+	uint32_t name_hash;
+	uint32_t value_id;
+
+	/* verify that name is not NULL */
+	if (!name || !buf) {
+		return -EINVAL;
+	}
+
+	name_hash = sys_hash32(name, strlen(name)) & ZMS_HASH_MASK;
+	for (int i = 0; i <= cf->hash_collision_num; i++) {
+		name_hash = ZMS_UPDATE_COLLISION_NUM(name_hash, i);
+		/* Get the name entry from ZMS */
+		rc = zms_read(&cf->cf_zms, ZMS_NAME_ID_FROM_HASH(name_hash), r_name,
+			      sizeof(r_name) - 1);
+		if (rc <= 0) {
+			/* Name with current collision number doesn't exist, but there might be
+			 * one with a higher collision number */
+			continue;
+		}
+		/* Found a name, this might not include a trailing \0 */
+		r_name[rc] = '\0';
+		if (strcmp(name, r_name)) {
+			/* Names are not equal let's continue to the next collision hash
+			 * if it exists.
+			 */
+			continue;
+		}
+
+		/* At this steps the names are equal, let's read the data */
+		value_id = ZMS_NAME_ID_FROM_HASH(name_hash) + ZMS_DATA_ID_OFFSET;
+		rc = zms_read(&cf->cf_zms, value_id, buf, buf_len);
+
+		return rc == buf_len ? zms_get_data_length(&cf->cf_zms, value_id) : rc;
+	}
+
+	return rc;
+}
+
 static int settings_zms_load(struct settings_store *cs, const struct settings_load_arg *arg)
 {
 	int ret = 0;