Hi,
On Friday 17 June 2016 11:14:34 Markus Pargmann wrote:
> The state framework grew organically over the time. Unfortunately the
> architecture and abstractions disappeared during this period.
>
> This patch refactors the framework to recreate the abstractions. The
> main focus was the backend with its storage. The main use-case was to
> offer better NAND support with less erase cycles and interchangeable
> data formats (dtb,raw).
>
> The general architecture now has a backend which consists of a data
> format and storage. The storage consists of multiple storage buckets
> each holding exactly one copy of the state data. A data format describes
> a data serialization for the state framework. This can be either dtb or
> raw. A storage bucket is a storage location which is used to store any
> data. There is a (new) circular type which writes changes behind the
> last written data and therefore reduces the number of erases. The other
> type is a direct bucket which writes directly to a storage offset for
> all non-erase storage.
>
> Furthermore this patch splits up all classes into different files in a
> subdirectory.
>
> This is currently all in one patch as I can't see a good way to split
> the changes up without having a non-working state framework in between.
We discovered some small bugs in this. I will send a new version.
Best Regards,
Markus
>
> The following diagram shows the new architecture roughly:
>
> .----------.
> | state |
> '----------'
> |
> |
> v
> .----------------------------.
> | state_backend |
> |----------------------------|
> | + state_load(*state); |
> | + state_save(*state); |
> | + state_backend_init(...); |
> | |
> | |
> '----------------------------'
> | | The format describes
> | | how the state data
> | '-------------> is serialized
> | .--------------------------------------------.
> | | state_backend_format <INTERFACE> |
> | |--------------------------------------------|
> | | + verify(*format, magic, *buf, len); |
> | | + pack(*format, *state, **buf, len); |
> | | + unpack(*format, *state, *buf, len); |
> | | + get_packed_len(*format, *state); |
> | | + free(*format); |
> | '--------------------------------------------'
> | ^ ^
> | * *
> | * *
> | .--------------------. .--------------------.
> | | backend_format_dtb | | backend_format_raw |
> | '--------------------' '--------------------'
> |
> |
> |
> v
> .----------------------------------------------------------.
> | state_backend_storage |
> |----------------------------------------------------------|
> | + init(...); |
> | + free(*storage); |
> | + read(*storage, *format, magic, **buf, *len, len_hint); |
> | + write(*storage, *buf, len); |
> | + restore_consistency(*storage, *buf, len); |
> '----------------------------------------------------------'
> |
> The backend storage is responsible to manage multiple
> data copies and distribute them onto several buckets.
> Read data is verified against the given format to
> ensure that the read data is correct.
> |
> |
> |
> |
> |
> v
> .------------------------------------------.
> | state_backend_storage_bucket <INTERFACE> |
> |------------------------------------------|
> | + init(*bucket); |
> | + write(*bucket, *buf, len); |
> | + read(*bucket, **buf, len_hint); |
> | + free(*bucket); |
> '------------------------------------------'
> ^ ^
> * *
> * *
> A storage bucket represents exactly one data copy at one
> data location. A circular bucket writes any new data to
> the end of the bucket (for reduced erases on NAND). A
> direct bucket directly writes at one location.
> * *
> * *
> * *
> .-----------------------. .-------------------------.
> | backend_bucket_direct | | backend_bucket_circular |
> '-----------------------' '-------------------------'
>
> Signed-off-by: Markus Pargmann <mpa@xxxxxxxxxxxxxx>
> ---
> common/Makefile | 2 +-
> common/state.c | 1720 --------------------------------
> common/state/Makefile | 8 +
> common/state/backend.c | 209 ++++
> common/state/backend_bucket_circular.c | 580 +++++++++++
> common/state/backend_bucket_direct.c | 180 ++++
> common/state/backend_format_dtb.c | 150 +++
> common/state/backend_format_raw.c | 327 ++++++
> common/state/backend_storage.c | 470 +++++++++
> common/state/state.c | 564 +++++++++++
> common/state/state.h | 266 +++++
> common/state/state_variables.c | 493 +++++++++
> drivers/misc/state.c | 64 +-
> include/state.h | 4 +-
> 14 files changed, 3252 insertions(+), 1785 deletions(-)
> delete mode 100644 common/state.c
> create mode 100644 common/state/Makefile
> create mode 100644 common/state/backend.c
> create mode 100644 common/state/backend_bucket_circular.c
> create mode 100644 common/state/backend_bucket_direct.c
> create mode 100644 common/state/backend_format_dtb.c
> create mode 100644 common/state/backend_format_raw.c
> create mode 100644 common/state/backend_storage.c
> create mode 100644 common/state/state.c
> create mode 100644 common/state/state.h
> create mode 100644 common/state/state_variables.c
>
> diff --git a/common/Makefile b/common/Makefile
> index 99681e21215b..17fcb5f24a04 100644
> --- a/common/Makefile
> +++ b/common/Makefile
> @@ -44,7 +44,7 @@ obj-$(CONFIG_POLLER) += poller.o
> obj-$(CONFIG_RESET_SOURCE) += reset_source.o
> obj-$(CONFIG_SHELL_HUSH) += hush.o
> obj-$(CONFIG_SHELL_SIMPLE) += parser.o
> -obj-$(CONFIG_STATE) += state.o
> +obj-$(CONFIG_STATE) += state/
> obj-$(CONFIG_RATP) += ratp.o
> obj-$(CONFIG_UIMAGE) += image.o uimage.o
> obj-$(CONFIG_FITIMAGE) += image-fit.o
> diff --git a/common/state.c b/common/state.c
> deleted file mode 100644
> index 87afff305661..000000000000
> --- a/common/state.c
> +++ /dev/null
> @@ -1,1720 +0,0 @@
> -/*
> - * Copyright (C) 2012-2014 Pengutronix, Jan Luebbe <j.luebbe@xxxxxxxxxxxxxx>
> - * Copyright (C) 2013-2014 Pengutronix, Sascha Hauer <s.hauer@xxxxxxxxxxxxxx>
> - * Copyright (C) 2015 Pengutronix, Marc Kleine-Budde <mkl@xxxxxxxxxxxxxx>
> - *
> - * This program is free software; you can redistribute it and/or modify
> - * it under the terms of the GNU General Public License as published by
> - * the Free Software Foundation; either version 2 of the License, or
> - * (at your option) any later version.
> - *
> - * This program is distributed in the hope that it will be useful,
> - * but WITHOUT ANY WARRANTY; without even the implied warranty of
> - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
> - * GNU General Public License for more details.
> - */
> -
> -#include <common.h>
> -#include <digest.h>
> -#include <environment.h>
> -#include <errno.h>
> -#include <fcntl.h>
> -#include <fs.h>
> -#include <crc.h>
> -#include <init.h>
> -#include <ioctl.h>
> -#include <libbb.h>
> -#include <libfile.h>
> -#include <malloc.h>
> -#include <net.h>
> -#include <state.h>
> -#include <xfuncs.h>
> -
> -#include <crypto/keystore.h>
> -
> -#include <linux/mtd/mtd-abi.h>
> -#include <linux/mtd/mtd.h>
> -#include <linux/list.h>
> -#include <linux/err.h>
> -
> -#include <asm/unaligned.h>
> -
> -#define RAW_BACKEND_COPIES 2
> -
> -struct state_backend;
> -
> -struct state {
> - struct device_d dev;
> - struct device_node *root;
> - struct list_head variables;
> - const char *name;
> - struct list_head list;
> - struct state_backend *backend;
> - uint32_t magic;
> - unsigned int dirty;
> -};
> -
> -struct state_backend {
> - int (*save)(struct state_backend *backend, struct state *state);
> - const char *name;
> - const char *of_path;
> - const char *path;
> - struct digest *digest;
> -};
> -
> -enum state_variable_type {
> - STATE_TYPE_INVALID = 0,
> - STATE_TYPE_ENUM,
> - STATE_TYPE_U8,
> - STATE_TYPE_U32,
> - STATE_TYPE_S32,
> - STATE_TYPE_MAC,
> - STATE_TYPE_STRING,
> -};
> -
> -/* instance of a single variable */
> -struct state_variable {
> - enum state_variable_type type;
> - struct list_head list;
> - const char *name;
> - unsigned int start;
> - unsigned int size;
> - void *raw;
> -};
> -
> -enum state_convert {
> - STATE_CONVERT_FROM_NODE,
> - STATE_CONVERT_FROM_NODE_CREATE,
> - STATE_CONVERT_TO_NODE,
> - STATE_CONVERT_FIXUP,
> -};
> -
> -/* A variable type (uint32, enum32) */
> -struct variable_type {
> - enum state_variable_type type;
> - const char *type_name;
> - struct list_head list;
> - int (*export)(struct state_variable *, struct device_node *,
> - enum state_convert);
> - int (*import)(struct state_variable *, struct device_node *);
> - struct state_variable *(*create)(struct state *state,
> - const char *name, struct device_node *);
> -};
> -
> -/* list of all registered state instances */
> -static LIST_HEAD(state_list);
> -
> -static int state_set_dirty(struct param_d *p, void *priv)
> -{
> - struct state *state = priv;
> -
> - state->dirty = 1;
> -
> - return 0;
> -}
> -
> -/*
> - * uint32
> - */
> -struct state_uint32 {
> - struct state_variable var;
> - struct param_d *param;
> - struct state *state;
> - uint32_t value;
> - uint32_t value_default;
> -};
> -
> -static int state_var_compare(struct list_head *a, struct list_head *b)
> -{
> - struct state_variable *va = list_entry(a, struct state_variable, list);
> - struct state_variable *vb = list_entry(b, struct state_variable, list);
> -
> - return va->start < vb->start ? -1 : 1;
> -}
> -
> -static void state_add_var(struct state *state, struct state_variable *var)
> -{
> - list_add_sort(&var->list, &state->variables, state_var_compare);
> -}
> -
> -static inline struct state_uint32 *to_state_uint32(struct state_variable *s)
> -{
> - return container_of(s, struct state_uint32, var);
> -}
> -
> -static int state_uint32_export(struct state_variable *var,
> - struct device_node *node, enum state_convert conv)
> -{
> - struct state_uint32 *su32 = to_state_uint32(var);
> - int ret;
> -
> - if (su32->value_default) {
> - ret = of_property_write_u32(node, "default",
> - su32->value_default);
> - if (ret)
> - return ret;
> - }
> -
> - if (conv == STATE_CONVERT_FIXUP)
> - return 0;
> -
> - return of_property_write_u32(node, "value", su32->value);
> -}
> -
> -static int state_uint32_import(struct state_variable *sv,
> - struct device_node *node)
> -{
> - struct state_uint32 *su32 = to_state_uint32(sv);
> -
> - of_property_read_u32(node, "default", &su32->value_default);
> - if (of_property_read_u32(node, "value", &su32->value))
> - su32->value = su32->value_default;
> -
> - return 0;
> -}
> -
> -static int state_uint8_set(struct param_d *p, void *priv)
> -{
> - struct state_uint32 *su32 = priv;
> - struct state *state = su32->state;
> -
> - if (su32->value > 255)
> - return -ERANGE;
> -
> - return state_set_dirty(p, state);
> -}
> -
> -static struct state_variable *state_uint8_create(struct state *state,
> - const char *name, struct device_node *node)
> -{
> - struct state_uint32 *su32;
> - struct param_d *param;
> -
> - su32 = xzalloc(sizeof(*su32));
> -
> - param = dev_add_param_int(&state->dev, name, state_uint8_set,
> - NULL, &su32->value, "%u", su32);
> - if (IS_ERR(param)) {
> - free(su32);
> - return ERR_CAST(param);
> - }
> -
> - su32->param = param;
> - su32->var.size = sizeof(uint8_t);
> -#ifdef __LITTLE_ENDIAN
> - su32->var.raw = &su32->value;
> -#else
> - su32->var.raw = &su32->value + 3;
> -#endif
> - su32->state = state;
> -
> - return &su32->var;
> -}
> -
> -static struct state_variable *state_int32_create(struct state *state,
> - const char *name, struct device_node *node, const char *format)
> -{
> - struct state_uint32 *su32;
> - struct param_d *param;
> -
> - su32 = xzalloc(sizeof(*su32));
> -
> - param = dev_add_param_int(&state->dev, name, state_set_dirty,
> - NULL, &su32->value, format, state);
> - if (IS_ERR(param)) {
> - free(su32);
> - return ERR_CAST(param);
> - }
> -
> - su32->param = param;
> - su32->var.size = sizeof(uint32_t);
> - su32->var.raw = &su32->value;
> -
> - return &su32->var;
> -}
> -
> -static struct state_variable *state_uint32_create(struct state *state,
> - const char *name, struct device_node *node)
> -{
> - return state_int32_create(state, name, node, "%u");
> -}
> -
> -static struct state_variable *state_sint32_create(struct state *state,
> - const char *name, struct device_node *node)
> -{
> - return state_int32_create(state, name, node, "%d");
> -}
> -
> -/*
> - * enum32
> - */
> -struct state_enum32 {
> - struct state_variable var;
> - struct param_d *param;
> - uint32_t value;
> - uint32_t value_default;
> - const char **names;
> - int num_names;
> -};
> -
> -static inline struct state_enum32 *to_state_enum32(struct state_variable *s)
> -{
> - return container_of(s, struct state_enum32, var);
> -}
> -
> -static int state_enum32_export(struct state_variable *var,
> - struct device_node *node, enum state_convert conv)
> -{
> - struct state_enum32 *enum32 = to_state_enum32(var);
> - int ret, i, len;
> - char *prop, *str;
> -
> - if (enum32->value_default) {
> - ret = of_property_write_u32(node, "default",
> - enum32->value_default);
> - if (ret)
> - return ret;
> - }
> -
> - len = 0;
> -
> - for (i = 0; i < enum32->num_names; i++)
> - len += strlen(enum32->names[i]) + 1;
> -
> - prop = xzalloc(len);
> - str = prop;
> -
> - for (i = 0; i < enum32->num_names; i++)
> - str += sprintf(str, "%s", enum32->names[i]) + 1;
> -
> - ret = of_set_property(node, "names", prop, len, 1);
> -
> - free(prop);
> -
> - if (conv == STATE_CONVERT_FIXUP)
> - return 0;
> -
> - ret = of_property_write_u32(node, "value", enum32->value);
> - if (ret)
> - return ret;
> -
> - return ret;
> -}
> -
> -static int state_enum32_import(struct state_variable *sv,
> - struct device_node *node)
> -{
> - struct state_enum32 *enum32 = to_state_enum32(sv);
> - int len;
> - const __be32 *value, *value_default;
> -
> - value = of_get_property(node, "value", &len);
> - if (value && len != sizeof(uint32_t))
> - return -EINVAL;
> -
> - value_default = of_get_property(node, "default", &len);
> - if (value_default && len != sizeof(uint32_t))
> - return -EINVAL;
> -
> - if (value_default)
> - enum32->value_default = be32_to_cpu(*value_default);
> - if (value)
> - enum32->value = be32_to_cpu(*value);
> - else
> - enum32->value = enum32->value_default;
> -
> - return 0;
> -}
> -
> -static struct state_variable *state_enum32_create(struct state *state,
> - const char *name, struct device_node *node)
> -{
> - struct state_enum32 *enum32;
> - int ret, i, num_names;
> -
> - enum32 = xzalloc(sizeof(*enum32));
> -
> - num_names = of_property_count_strings(node, "names");
> - if (num_names < 0) {
> - dev_err(&state->dev, "enum32 node without \"names\" property\n");
> - return ERR_PTR(-EINVAL);
> - }
> -
> - enum32->names = xzalloc(sizeof(char *) * num_names);
> - enum32->num_names = num_names;
> - enum32->var.size = sizeof(uint32_t);
> - enum32->var.raw = &enum32->value;
> -
> - for (i = 0; i < num_names; i++) {
> - const char *name;
> -
> - ret = of_property_read_string_index(node, "names", i, &name);
> - if (ret)
> - goto out;
> - enum32->names[i] = xstrdup(name);
> - }
> -
> - enum32->param = dev_add_param_enum(&state->dev, name, state_set_dirty,
> - NULL, &enum32->value, enum32->names, num_names, state);
> - if (IS_ERR(enum32->param)) {
> - ret = PTR_ERR(enum32->param);
> - goto out;
> - }
> -
> - return &enum32->var;
> -out:
> - for (i--; i >= 0; i--)
> - free((char *)enum32->names[i]);
> - free(enum32->names);
> - free(enum32);
> - return ERR_PTR(ret);
> -}
> -
> -/*
> - * MAC address
> - */
> -struct state_mac {
> - struct state_variable var;
> - struct param_d *param;
> - uint8_t value[6];
> - uint8_t value_default[6];
> -};
> -
> -static inline struct state_mac *to_state_mac(struct state_variable *s)
> -{
> - return container_of(s, struct state_mac, var);
> -}
> -
> -static int state_mac_export(struct state_variable *var,
> - struct device_node *node, enum state_convert conv)
> -{
> - struct state_mac *mac = to_state_mac(var);
> - int ret;
> -
> - if (!is_zero_ether_addr(mac->value_default)) {
> - ret = of_property_write_u8_array(node, "default", mac->value_default,
> - ARRAY_SIZE(mac->value_default));
> - if (ret)
> - return ret;
> - }
> -
> - if (conv == STATE_CONVERT_FIXUP)
> - return 0;
> -
> - return of_property_write_u8_array(node, "value", mac->value,
> - ARRAY_SIZE(mac->value));
> -}
> -
> -static int state_mac_import(struct state_variable *sv,
> - struct device_node *node)
> -{
> - struct state_mac *mac = to_state_mac(sv);
> -
> - of_property_read_u8_array(node, "default", mac->value_default,
> - ARRAY_SIZE(mac->value_default));
> - if (of_property_read_u8_array(node, "value", mac->value,
> - ARRAY_SIZE(mac->value)))
> - memcpy(mac->value, mac->value_default, ARRAY_SIZE(mac->value));
> -
> - return 0;
> -}
> -
> -static struct state_variable *state_mac_create(struct state *state,
> - const char *name, struct device_node *node)
> -{
> - struct state_mac *mac;
> - int ret;
> -
> - mac = xzalloc(sizeof(*mac));
> -
> - mac->var.size = ARRAY_SIZE(mac->value);
> - mac->var.raw = mac->value;
> -
> - mac->param = dev_add_param_mac(&state->dev, name, state_set_dirty,
> - NULL, mac->value, state);
> - if (IS_ERR(mac->param)) {
> - ret = PTR_ERR(mac->param);
> - goto out;
> - }
> -
> - return &mac->var;
> -out:
> - free(mac);
> - return ERR_PTR(ret);
> -}
> -
> -/*
> - * string
> - */
> -struct state_string {
> - struct state_variable var;
> - struct param_d *param;
> - struct state *state;
> - char *value;
> - const char *value_default;
> - char raw[];
> -};
> -
> -static inline struct state_string *to_state_string(struct state_variable *s)
> -{
> - return container_of(s, struct state_string, var);
> -}
> -
> -static int state_string_export(struct state_variable *var,
> - struct device_node *node, enum state_convert conv)
> -{
> - struct state_string *string = to_state_string(var);
> - int ret = 0;
> -
> - if (string->value_default) {
> - ret = of_set_property(node, "default", string->value_default,
> - strlen(string->value_default) + 1, 1);
> -
> - if (ret)
> - return ret;
> - }
> -
> - if (conv == STATE_CONVERT_FIXUP)
> - return 0;
> -
> - if (string->value)
> - ret = of_set_property(node, "value", string->value,
> - strlen(string->value) + 1, 1);
> -
> - return ret;
> -}
> -
> -static int state_string_copy_to_raw(struct state_string *string,
> - const char *src)
> -{
> - size_t len;
> -
> - len = strlen(src);
> - if (len > string->var.size)
> - return -EILSEQ;
> -
> - /* copy string and clear remaining contents of buffer */
> - memcpy(string->raw, src, len);
> - memset(string->raw + len, 0x0, string->var.size - len);
> -
> - return 0;
> -}
> -
> -static int state_string_import(struct state_variable *sv,
> - struct device_node *node)
> -{
> - struct state_string *string = to_state_string(sv);
> - const char *value = NULL;
> - size_t len;
> - int ret;
> -
> - of_property_read_string(node, "default", &string->value_default);
> - if (string->value_default) {
> - len = strlen(string->value_default);
> - if (len > string->var.size)
> - return -EILSEQ;
> - }
> -
> - ret = of_property_read_string(node, "value", &value);
> - if (ret)
> - value = string->value_default;
> -
> - if (value)
> - return state_string_copy_to_raw(string, value);
> -
> - return 0;
> -}
> -
> -static int state_string_set(struct param_d *p, void *priv)
> -{
> - struct state_string *string = priv;
> - struct state *state = string->state;
> - int ret;
> -
> - ret = state_string_copy_to_raw(string, string->value);
> - if (ret)
> - return ret;
> -
> - return state_set_dirty(p, state);
> -}
> -
> -static int state_string_get(struct param_d *p, void *priv)
> -{
> - struct state_string *string = priv;
> -
> - free(string->value);
> - if (string->raw[0])
> - string->value = xstrndup(string->raw, string->var.size);
> - else
> - string->value = xstrdup("");
> -
> - return 0;
> -}
> -
> -static struct state_variable *state_string_create(struct state *state,
> - const char *name, struct device_node *node)
> -{
> - struct state_string *string;
> - u32 start_size[2];
> - int ret;
> -
> - ret = of_property_read_u32_array(node, "reg", start_size,
> - ARRAY_SIZE(start_size));
> - if (ret) {
> - dev_err(&state->dev,
> - "%s: reg property not found\n", name);
> - return ERR_PTR(ret);
> - }
> -
> - /* limit to arbitrary len of 4k */
> - if (start_size[1] > 4096)
> - return ERR_PTR(-EILSEQ);
> -
> - string = xzalloc(sizeof(*string) + start_size[1]);
> - string->var.size = start_size[1];
> - string->var.raw = &string->raw;
> - string->state = state;
> -
> - string->param = dev_add_param_string(&state->dev, name, state_string_set,
> - state_string_get, &string->value, string);
> - if (IS_ERR(string->param)) {
> - ret = PTR_ERR(string->param);
> - goto out;
> - }
> -
> - return &string->var;
> -out:
> - free(string);
> - return ERR_PTR(ret);
> -}
> -
> -static struct variable_type types[] = {
> - {
> - .type = STATE_TYPE_U8,
> - .type_name = "uint8",
> - .export = state_uint32_export,
> - .import = state_uint32_import,
> - .create = state_uint8_create,
> - }, {
> - .type = STATE_TYPE_U32,
> - .type_name = "uint32",
> - .export = state_uint32_export,
> - .import = state_uint32_import,
> - .create = state_uint32_create,
> - }, {
> - .type = STATE_TYPE_ENUM,
> - .type_name = "enum32",
> - .export = state_enum32_export,
> - .import = state_enum32_import,
> - .create = state_enum32_create,
> - }, {
> - .type = STATE_TYPE_MAC,
> - .type_name = "mac",
> - .export = state_mac_export,
> - .import = state_mac_import,
> - .create = state_mac_create,
> - }, {
> - .type = STATE_TYPE_STRING,
> - .type_name = "string",
> - .export = state_string_export,
> - .import = state_string_import,
> - .create = state_string_create,
> - }, {
> - .type = STATE_TYPE_S32,
> - .type_name = "int32",
> - .export = state_uint32_export,
> - .import = state_uint32_import,
> - .create = state_sint32_create,
> - },
> -};
> -
> -static struct variable_type *state_find_type_by_name(const char *name)
> -{
> - int i;
> -
> - for (i = 0; i < ARRAY_SIZE(types); i++) {
> - if (!strcmp(name, types[i].type_name)) {
> - return &types[i];
> - }
> - }
> -
> - return NULL;
> -}
> -
> -/*
> - * Generic state functions
> - */
> -
> -static struct state *state_new(const char *name)
> -{
> - struct state *state;
> - int ret;
> -
> - state = xzalloc(sizeof(*state));
> - safe_strncpy(state->dev.name, name, MAX_DRIVER_NAME);
> - state->name = state->dev.name;
> - state->dev.id = DEVICE_ID_SINGLE;
> - INIT_LIST_HEAD(&state->variables);
> -
> - ret = register_device(&state->dev);
> - if (ret) {
> - free(state);
> - return ERR_PTR(ret);
> - }
> -
> - state->dirty = 1;
> - dev_add_param_bool(&state->dev, "dirty", NULL, NULL, &state->dirty,
> - NULL);
> -
> - list_add_tail(&state->list, &state_list);
> -
> - return state;
> -}
> -
> -static struct state_variable *state_find_var(struct state *state,
> - const char *name)
> -{
> - struct state_variable *sv;
> -
> - list_for_each_entry(sv, &state->variables, list) {
> - if (!strcmp(sv->name, name))
> - return sv;
> - }
> -
> - return ERR_PTR(-ENOENT);
> -}
> -
> -static int state_convert_node_variable(struct state *state,
> - struct device_node *node, struct device_node *parent,
> - const char *parent_name, enum state_convert conv)
> -{
> - const struct variable_type *vtype;
> - struct device_node *child;
> - struct device_node *new_node = NULL;
> - struct state_variable *sv;
> - const char *type_name;
> - char *short_name, *name, *indexs;
> - unsigned int start_size[2];
> - int ret;
> -
> - /* strip trailing @<ADDRESS> */
> - short_name = xstrdup(node->name);
> - indexs = strchr(short_name, '@');
> - if (indexs)
> - *indexs = 0;
> -
> - /* construct full name */
> - name = basprintf("%s%s%s", parent_name, parent_name[0] ? "." : "",
> - short_name);
> - free(short_name);
> -
> - if ((conv == STATE_CONVERT_TO_NODE) ||
> - (conv == STATE_CONVERT_FIXUP))
> - new_node = of_new_node(parent, node->name);
> -
> - for_each_child_of_node(node, child) {
> - ret = state_convert_node_variable(state, child, new_node, name,
> - conv);
> - if (ret)
> - goto out_free;
> - }
> -
> - /* parents are allowed to have no type */
> - ret = of_property_read_string(node, "type", &type_name);
> - if (!list_empty(&node->children) && ret == -EINVAL) {
> - if (conv == STATE_CONVERT_FIXUP) {
> - ret = of_property_write_u32(new_node, "#address-cells", 1);
> - if (ret)
> - goto out_free;
> -
> - ret = of_property_write_u32(new_node, "#size-cells", 1);
> - if (ret)
> - goto out_free;
> - }
> - ret = 0;
> - goto out_free;
> - } else if (ret) {
> - goto out_free;
> - }
> -
> - vtype = state_find_type_by_name(type_name);
> - if (!vtype) {
> - dev_err(&state->dev, "unkown type: %s in %s\n", type_name,
> - node->full_name);
> - ret = -ENOENT;
> - goto out_free;
> - }
> -
> - if (conv == STATE_CONVERT_FROM_NODE_CREATE) {
> - sv = vtype->create(state, name, node);
> - if (IS_ERR(sv)) {
> - ret = PTR_ERR(sv);
> - dev_err(&state->dev, "failed to create %s: %s\n",
> - name, strerror(-ret));
> - goto out_free;
> - }
> -
> - ret = of_property_read_u32_array(node, "reg", start_size,
> - ARRAY_SIZE(start_size));
> - if (ret) {
> - dev_err(&state->dev,
> - "%s: reg property not found\n", name);
> - goto out_free;
> - }
> -
> - if (start_size[1] != sv->size) {
> - dev_err(&state->dev,
> - "%s: size mismatch: type=%s(size=%u) size=%u\n",
> - name, type_name, sv->size, start_size[1]);
> - ret = -EOVERFLOW;
> - goto out_free;
> - }
> -
> - sv->name = name;
> - sv->start = start_size[0];
> - sv->type = vtype->type;
> - state_add_var(state, sv);
> - } else {
> - sv = state_find_var(state, name);
> - if (IS_ERR(sv)) {
> - /* we ignore this error */
> - dev_dbg(&state->dev,
> - "no such variable: %s: %s\n",
> - name, strerror(-ret));
> - ret = 0;
> - goto out_free;
> - }
> - free(name);
> -
> - if ((conv == STATE_CONVERT_TO_NODE) ||
> - (conv == STATE_CONVERT_FIXUP)) {
> - ret = of_set_property(new_node, "type",
> - vtype->type_name,
> - strlen(vtype->type_name) + 1, 1);
> - if (ret)
> - goto out;
> -
> - start_size[0] = sv->start;
> - start_size[1] = sv->size;
> - ret = of_property_write_u32_array(new_node, "reg",
> - start_size,
> - ARRAY_SIZE(start_size));
> - if (ret)
> - goto out;
> - }
> - }
> -
> - if ((conv == STATE_CONVERT_TO_NODE) ||
> - (conv == STATE_CONVERT_FIXUP))
> - ret = vtype->export(sv, new_node, conv);
> - else
> - ret = vtype->import(sv, node);
> -
> - if (ret)
> - goto out;
> -
> - return 0;
> -out_free:
> - free(name);
> -out:
> - return ret;
> -}
> -
> -static struct device_node *state_to_node(struct state *state, struct device_node *parent,
> - enum state_convert conv)
> -{
> - struct device_node *child;
> - struct device_node *root;
> - int ret;
> -
> - root = of_new_node(parent, state->root->name);
> - ret = of_property_write_u32(root, "magic", state->magic);
> - if (ret)
> - goto out;
> -
> - for_each_child_of_node(state->root, child) {
> - ret = state_convert_node_variable(state, child, root, "",
> - conv);
> - if (ret)
> - goto out;
> - }
> -
> - return root;
> -out:
> - of_delete_node(root);
> - return ERR_PTR(ret);
> -}
> -
> -static int state_from_node(struct state *state, struct device_node *node,
> - bool create)
> -{
> - struct device_node *child;
> - enum state_convert conv;
> - int ret;
> - uint32_t magic;
> -
> - ret = of_property_read_u32(node, "magic", &magic);
> - if (ret)
> - return ret;
> -
> - if (create) {
> - conv = STATE_CONVERT_FROM_NODE_CREATE;
> - state->root = node;
> - state->magic = magic;
> - } else {
> - conv = STATE_CONVERT_FROM_NODE;
> - if (state->magic && state->magic != magic) {
> - dev_err(&state->dev,
> - "invalid magic 0x%08x, should be 0x%08x\n",
> - magic, state->magic);
> - return -EINVAL;
> - }
> - }
> -
> - for_each_child_of_node(node, child) {
> - ret = state_convert_node_variable(state, child, NULL, "", conv);
> - if (ret)
> - return ret;
> - }
> -
> - /* check for overlapping variables */
> - if (create) {
> - const struct state_variable *sv;
> -
> - /* start with second entry */
> - sv = list_first_entry(&state->variables,
> - struct state_variable, list);
> -
> - list_for_each_entry_continue(sv, &state->variables, list) {
> - const struct state_variable *last_sv;
> -
> - last_sv = list_last_entry(&sv->list,
> - struct state_variable, list);
> - if ((last_sv->start + last_sv->size - 1) < sv->start)
> - continue;
> -
> - dev_err(&state->dev,
> - "ERROR: Conflicting variable position between: "
> - "%s (0x%02x..0x%02x) and %s (0x%02x..0x%02x)\n",
> - last_sv->name, last_sv->start,
> - last_sv->start + last_sv->size - 1,
> - sv->name, sv->start, sv->start + sv->size - 1);
> -
> - ret |= -EINVAL;
> - }
> - }
> -
> - return ret;
> -}
> -
> -static int of_state_fixup(struct device_node *root, void *ctx)
> -{
> - struct state *state = ctx;
> - const char *compatible = "barebox,state";
> - struct device_node *new_node, *node, *parent, *backend_node;
> - struct property *p;
> - int ret;
> - phandle phandle;
> -
> - node = of_find_node_by_path_from(root, state->root->full_name);
> - if (node) {
> - /* replace existing node - it will be deleted later */
> - parent = node->parent;
> - } else {
> - char *of_path, *c;
> -
> - /* look for parent, remove last '/' from path */
> - of_path = xstrdup(state->root->full_name);
> - c = strrchr(of_path, '/');
> - if (!c)
> - return -ENODEV;
> - *c = '0';
> - parent = of_find_node_by_path(of_path);
> - if (!parent)
> - parent = root;
> -
> - free(of_path);
> - }
> -
> - /* serialize variable definitions */
> - new_node = state_to_node(state, parent, STATE_CONVERT_FIXUP);
> - if (IS_ERR(new_node))
> - return PTR_ERR(new_node);
> -
> - /* compatible */
> - p = of_new_property(new_node, "compatible", compatible,
> - strlen(compatible) + 1);
> - if (!p) {
> - ret = -ENOMEM;
> - goto out;
> - }
> -
> - /* backend-type */
> - if (!state->backend) {
> - ret = -ENODEV;
> - goto out;
> - }
> -
> - p = of_new_property(new_node, "backend-type", state->backend->name,
> - strlen(state->backend->name) + 1);
> - if (!p) {
> - ret = -ENOMEM;
> - goto out;
> - }
> -
> - /* backend phandle */
> - backend_node = of_find_node_by_path_from(root, state->backend->of_path);
> - if (!backend_node) {
> - ret = -ENODEV;
> - goto out;
> - }
> -
> - phandle = of_node_create_phandle(backend_node);
> - ret = of_property_write_u32(new_node, "backend", phandle);
> - if (ret)
> - goto out;
> -
> - if (state->backend->digest) {
> - p = of_new_property(new_node, "algo",
> - digest_name(state->backend->digest),
> - strlen(digest_name(state->backend->digest)) + 1);
> - if (!p) {
> - ret = -ENOMEM;
> - goto out;
> - }
> - }
> -
> - /* address-cells + size-cells */
> - ret = of_property_write_u32(new_node, "#address-cells", 1);
> - if (ret)
> - goto out;
> -
> - ret = of_property_write_u32(new_node, "#size-cells", 1);
> - if (ret)
> - goto out;
> -
> - /* delete existing node */
> - if (node)
> - of_delete_node(node);
> -
> - return 0;
> -
> - out:
> - dev_err(&state->dev, "error fixing up device tree with boot state\n");
> - of_delete_node(new_node);
> - return ret;
> -}
> -
> -void state_release(struct state *state)
> -{
> - of_unregister_fixup(of_state_fixup, state);
> - list_del(&state->list);
> - unregister_device(&state->dev);
> - free(state);
> -}
> -
> -/*
> - * state_new_from_node - create a new state instance from a device_node
> - *
> - * @name The name of the new state instance
> - * @node The device_node describing the new state instance
> - */
> -struct state *state_new_from_node(const char *name, struct device_node *node)
> -{
> - struct state *state;
> - int ret;
> -
> - state = state_new(name);
> - if (IS_ERR(state))
> - return state;
> -
> - ret = state_from_node(state, node, 1);
> - if (ret) {
> - state_release(state);
> - return ERR_PTR(ret);
> - }
> -
> - ret = of_register_fixup(of_state_fixup, state);
> - if (ret) {
> - state_release(state);
> - return ERR_PTR(ret);
> - }
> -
> - return state;
> -}
> -
> -/*
> - * state_by_name - find a state instance by name
> - *
> - * @name The name of the state instance
> - */
> -struct state *state_by_name(const char *name)
> -{
> - struct state *state;
> -
> - list_for_each_entry(state, &state_list, list) {
> - if (!strcmp(name, state->name))
> - return state;
> - }
> -
> - return NULL;
> -}
> -
> -/*
> - * state_by_node - find a state instance by of node
> - *
> - * @node The of node of the state intance
> - */
> -struct state *state_by_node(const struct device_node *node)
> -{
> - struct state *state;
> -
> - list_for_each_entry(state, &state_list, list) {
> - if (state->root == node)
> - return state;
> - }
> -
> - return NULL;
> -}
> -
> -int state_get_name(const struct state *state, char const **name)
> -{
> - *name = xstrdup(state->name);
> -
> - return 0;
> -}
> -
> -/*
> - * state_save - save a state to the backing store
> - *
> - * @state The state instance to save
> - */
> -int state_save(struct state *state)
> -{
> - int ret;
> -
> - if (!state->dirty)
> - return 0;
> -
> - if (!state->backend)
> - return -ENOSYS;
> -
> - ret = state->backend->save(state->backend, state);
> - if (ret)
> - return ret;
> -
> - state->dirty = 0;
> -
> - return 0;
> -}
> -
> -void state_info(void)
> -{
> - struct state *state;
> -
> - printf("registered state instances:\n");
> -
> - list_for_each_entry(state, &state_list, list) {
> - printf("%-20s ", state->name);
> - if (state->backend)
> - printf("(backend: %s, path: %s)\n",
> - state->backend->name, state->backend->path);
> - else
> - printf("(no backend)\n");
> - }
> -}
> -
> -static int mtd_get_meminfo(const char *path, struct mtd_info_user *meminfo)
> -{
> - int fd, ret;
> -
> - fd = open(path, O_RDONLY);
> - if (fd < 0)
> - return fd;
> -
> - ret = ioctl(fd, MEMGETINFO, meminfo);
> -
> - close(fd);
> -
> - return ret;
> -}
> -
> -/*
> - * DTB backend implementation
> - */
> -struct state_backend_dtb {
> - struct state_backend backend;
> - bool need_erase;
> -};
> -
> -static int state_backend_dtb_load(struct state_backend *backend,
> - struct state *state)
> -{
> - struct device_node *root;
> - void *fdt;
> - int ret;
> - size_t len;
> -
> - fdt = read_file(backend->path, &len);
> - if (!fdt) {
> - dev_err(&state->dev, "cannot read %s\n", backend->path);
> - return -EINVAL;
> - }
> -
> - root = of_unflatten_dtb(fdt);
> -
> - free(fdt);
> -
> - if (IS_ERR(root))
> - return PTR_ERR(root);
> -
> - ret = state_from_node(state, root, 0);
> -
> - return ret;
> -}
> -
> -static int state_backend_dtb_save(struct state_backend *backend,
> - struct state *state)
> -{
> - struct state_backend_dtb *backend_dtb = container_of(backend,
> - struct state_backend_dtb, backend);
> - int ret, fd;
> - struct device_node *root;
> - struct fdt_header *fdt;
> -
> - root = state_to_node(state, NULL, STATE_CONVERT_TO_NODE);
> - if (IS_ERR(root))
> - return PTR_ERR(root);
> -
> - fdt = of_flatten_dtb(root);
> - if (!fdt)
> - return -EINVAL;
> -
> - fd = open(backend->path, O_WRONLY);
> - if (fd < 0) {
> - ret = fd;
> - goto out;
> - }
> -
> - if (backend_dtb->need_erase) {
> - ret = erase(fd, fdt32_to_cpu(fdt->totalsize), 0);
> - if (ret) {
> - close(fd);
> - goto out;
> - }
> - }
> -
> - ret = write_full(fd, fdt, fdt32_to_cpu(fdt->totalsize));
> -
> - close(fd);
> -
> - if (ret < 0)
> - goto out;
> -
> - ret = 0;
> -out:
> - free(fdt);
> - of_delete_node(root);
> -
> - return ret;
> -}
> -
> -/*
> - * state_backend_dtb_file - create a dtb backend store for a state instance
> - *
> - * @state The state instance to work on
> - * @path The path where the state will be stored to
> - */
> -int state_backend_dtb_file(struct state *state, const char *of_path, const char *path)
> -{
> - struct state_backend_dtb *backend_dtb;
> - struct state_backend *backend;
> - struct mtd_info_user meminfo;
> - int ret;
> -
> - if (state->backend)
> - return -EBUSY;
> -
> - backend_dtb = xzalloc(sizeof(*backend_dtb));
> - backend = &backend_dtb->backend;
> -
> - backend->save = state_backend_dtb_save;
> - backend->of_path = xstrdup(of_path);
> - backend->path = xstrdup(path);
> - backend->name = "dtb";
> -
> - state->backend = backend;
> -
> - ret = mtd_get_meminfo(backend->path, &meminfo);
> - if (!ret && !(meminfo.flags & MTD_NO_ERASE))
> - backend_dtb->need_erase = true;
> -
> - ret = state_backend_dtb_load(backend, state);
> - if (ret) {
> - dev_warn(&state->dev, "load failed - using defaults\n");
> - } else {
> - dev_info(&state->dev, "load successful\n");
> - state->dirty = 0;
> - }
> -
> - /* ignore return value of load() */
> - return 0;
> -}
> -
> -/*
> - * Raw backend implementation
> - */
> -struct state_backend_raw {
> - struct state_backend backend;
> - unsigned long size_data; /* The raw data size (without header) */
> - unsigned long size_full; /* The size header + raw data + hmac */
> - unsigned long stride; /* The stride size in bytes of the copies */
> - off_t offset; /* offset in the storage file */
> - size_t size; /* size of the storage area */
> - int num_copy_read; /* The first successfully read copy */
> - bool need_erase;
> -};
> -
> -struct backend_raw_header {
> - uint32_t magic;
> - uint16_t reserved;
> - uint16_t data_len;
> - uint32_t data_crc;
> - uint32_t header_crc;
> -};
> -
> -static int backend_raw_load_one(struct state_backend_raw *backend_raw,
> - struct state *state, int fd, off_t offset)
> -{
> - uint32_t crc;
> - struct state_variable *sv;
> - struct backend_raw_header header = {};
> - unsigned long max_len;
> - int d_len = 0;
> - int ret;
> - void *buf, *data, *hmac;
> -
> - max_len = backend_raw->stride;
> -
> - ret = lseek(fd, offset, SEEK_SET);
> - if (ret < 0)
> - return ret;
> -
> - ret = read_full(fd, &header, sizeof(header));
> - max_len -= sizeof(header);
> - if (ret < 0) {
> - dev_err(&state->dev,
> - "cannot read header from backend device\n");
> - return ret;
> - }
> -
> - crc = crc32(0, &header, sizeof(header) - sizeof(uint32_t));
> - if (crc != header.header_crc) {
> - dev_err(&state->dev,
> - "invalid header crc, calculated 0x%08x, found 0x%08x\n",
> - crc, header.header_crc);
> - return -EINVAL;
> - }
> -
> - if (state->magic && state->magic != header.magic) {
> - dev_err(&state->dev,
> - "invalid magic 0x%08x, should be 0x%08x\n",
> - header.magic, state->magic);
> - return -EINVAL;
> - }
> -
> - if (backend_raw->backend.digest) {
> - d_len = digest_length(backend_raw->backend.digest);
> - max_len -= d_len;
> - }
> -
> - if (header.data_len > max_len) {
> - dev_err(&state->dev,
> - "invalid data_len %u in header, max is %lu\n",
> - header.data_len, max_len);
> - return -EINVAL;
> - }
> -
> - buf = xzalloc(sizeof(header) + header.data_len + d_len);
> - data = buf + sizeof(header);
> - hmac = data + header.data_len;
> -
> - ret = lseek(fd, offset, SEEK_SET);
> - if (ret < 0)
> - goto out_free;
> -
> - ret = read_full(fd, buf, sizeof(header) + header.data_len + d_len);
> - if (ret < 0)
> - goto out_free;
> -
> - crc = crc32(0, data, header.data_len);
> - if (crc != header.data_crc) {
> - dev_err(&state->dev,
> - "invalid crc, calculated 0x%08x, found 0x%08x\n",
> - crc, header.data_crc);
> - ret = -EINVAL;
> - goto out_free;
> - }
> -
> - if (backend_raw->backend.digest) {
> - struct digest *d = backend_raw->backend.digest;
> -
> - ret = digest_init(d);
> - if (ret)
> - goto out_free;
> -
> - /* hmac over header and data */
> - ret = digest_update(d, buf, sizeof(header) + header.data_len);
> - if (ret)
> - goto out_free;
> -
> - ret = digest_verify(d, hmac);
> - if (ret < 0)
> - goto out_free;
> - }
> -
> - list_for_each_entry(sv, &state->variables, list) {
> - if (sv->start + sv->size > header.data_len)
> - break;
> - memcpy(sv->raw, data + sv->start, sv->size);
> - }
> -
> - free(buf);
> - return 0;
> -
> - out_free:
> - free(buf);
> - return ret;
> -}
> -
> -static int state_backend_raw_load(struct state_backend *backend,
> - struct state *state)
> -{
> - struct state_backend_raw *backend_raw = container_of(backend,
> - struct state_backend_raw, backend);
> - int ret = 0, fd, i;
> -
> - fd = open(backend->path, O_RDONLY);
> - if (fd < 0) {
> - dev_err(&state->dev, "cannot open %s\n", backend->path);
> - return fd;
> - }
> -
> - for (i = 0; i < RAW_BACKEND_COPIES; i++) {
> - off_t offset = backend_raw->offset + i * backend_raw->stride;
> -
> - ret = backend_raw_load_one(backend_raw, state, fd, offset);
> - if (!ret) {
> - backend_raw->num_copy_read = i;
> - dev_dbg(&state->dev,
> - "copy %d successfully loaded\n", i);
> - break;
> - }
> - }
> -
> - close(fd);
> -
> - return ret;
> -}
> -
> -static int backend_raw_save_one(struct state_backend_raw *backend_raw,
> - struct state *state, int fd, int num, void *buf, size_t size)
> -{
> - int ret;
> - off_t offset = backend_raw->offset + num * backend_raw->stride;
> -
> - dev_dbg(&state->dev, "%s: 0x%08lx 0x%08zx\n",
> - __func__, offset, size);
> -
> - ret = lseek(fd, offset, SEEK_SET);
> - if (ret < 0)
> - return ret;
> -
> - protect(fd, backend_raw->stride, offset, false);
> -
> - if (backend_raw->need_erase) {
> - ret = erase(fd, backend_raw->stride, offset);
> - if (ret)
> - return ret;
> - }
> -
> - ret = write_full(fd, buf, size);
> - if (ret < 0)
> - return ret;
> -
> - protect(fd, backend_raw->stride, offset, true);
> -
> - return 0;
> -}
> -
> -static int state_backend_raw_save(struct state_backend *backend,
> - struct state *state)
> -{
> - struct state_backend_raw *backend_raw = container_of(backend,
> - struct state_backend_raw, backend);
> - int ret = 0, fd, i;
> - void *buf, *data, *hmac;
> - struct backend_raw_header *header;
> - struct state_variable *sv;
> -
> - buf = xzalloc(backend_raw->size_full);
> -
> - header = buf;
> - data = buf + sizeof(*header);
> - hmac = data + backend_raw->size_data;
> -
> - list_for_each_entry(sv, &state->variables, list)
> - memcpy(data + sv->start, sv->raw, sv->size);
> -
> - header->magic = state->magic;
> - header->data_len = backend_raw->size_data;
> - header->data_crc = crc32(0, data, backend_raw->size_data);
> - header->header_crc = crc32(0, header,
> - sizeof(*header) - sizeof(uint32_t));
> -
> - if (backend_raw->backend.digest) {
> - struct digest *d = backend_raw->backend.digest;
> -
> - ret = digest_init(d);
> - if (ret)
> - goto out_free;
> -
> - /* hmac over header and data */
> - ret = digest_update(d, buf, sizeof(*header) + backend_raw->size_data);
> - if (ret)
> - goto out_free;
> -
> - ret = digest_final(d, hmac);
> - if (ret < 0)
> - goto out_free;
> - }
> -
> - fd = open(backend->path, O_WRONLY);
> - if (fd < 0)
> - goto out_free;
> -
> - /* save other slots first */
> - for (i = 0; i < RAW_BACKEND_COPIES; i++) {
> - if (i == backend_raw->num_copy_read)
> - continue;
> -
> - ret = backend_raw_save_one(backend_raw, state, fd,
> - i, buf, backend_raw->size_full);
> - if (ret)
> - goto out_close;
> -
> - }
> -
> - ret = backend_raw_save_one(backend_raw, state, fd,
> - backend_raw->num_copy_read, buf, backend_raw->size_full);
> - if (ret)
> - goto out_close;
> -
> - dev_dbg(&state->dev, "wrote state to %s\n", backend->path);
> -out_close:
> - close(fd);
> -out_free:
> - free(buf);
> -
> - return ret;
> -}
> -
> -#ifdef __BAREBOX__
> -#define STAT_GIVES_SIZE(s) (S_ISREG(s.st_mode) || S_ISCHR(s.st_mode))
> -#define BLKGET_GIVES_SIZE(s) 0
> -#ifndef BLKGETSIZE64
> -#define BLKGETSIZE64 -1
> -#endif
> -#else
> -#define STAT_GIVES_SIZE(s) (S_ISREG(s.st_mode))
> -#define BLKGET_GIVES_SIZE(s) (S_ISBLK(s.st_mode))
> -#endif
> -
> -static int state_backend_raw_file_get_size(const char *path, size_t *out_size)
> -{
> - struct mtd_info_user meminfo;
> - struct stat s;
> - int ret;
> -
> - ret = stat(path, &s);
> - if (ret)
> - return -errno;
> -
> - /*
> - * under Linux, stat() gives the size only on regular files
> - * under barebox, it works on char dev, too
> - */
> - if (STAT_GIVES_SIZE(s)) {
> - *out_size = s.st_size;
> - return 0;
> - }
> -
> - /* this works under Linux on block devs */
> - if (BLKGET_GIVES_SIZE(s)) {
> - int fd;
> -
> - fd = open(path, O_RDONLY);
> - if (fd < 0)
> - return -errno;
> -
> - ret = ioctl(fd, BLKGETSIZE64, out_size);
> - close(fd);
> - if (!ret)
> - return 0;
> - }
> -
> - /* try mtd next */
> - ret = mtd_get_meminfo(path, &meminfo);
> - if (!ret) {
> - *out_size = meminfo.size;
> - return 0;
> - }
> -
> - return ret;
> -}
> -
> -static int state_backend_raw_file_init_digest(struct state *state, struct state_backend_raw *backend_raw)
> -{
> - struct digest *digest;
> - struct property *p;
> - const char *algo;
> - const unsigned char *key;
> - int key_len, ret;
> -
> - p = of_find_property(state->root, "algo", NULL);
> - if (!p) /* does not exist */
> - return 0;
> -
> - ret = of_property_read_string(state->root, "algo", &algo);
> - if (ret)
> - return ret;
> -
> - if (!IS_ENABLED(CONFIG_STATE_CRYPTO)) {
> - dev_err(&state->dev,
> - "algo %s specified, but crypto support for state framework (CONFIG_STATE_CRYPTO) not enabled.\n",
> - algo);
> - return -EINVAL;
> - }
> -
> - ret = keystore_get_secret(state->name, &key, &key_len);
> - if (ret == -ENOENT) /* -ENOENT == does not exist */
> - return -EPROBE_DEFER;
> - else if (ret)
> - return ret;
> -
> - digest = digest_alloc(algo);
> - if (!digest) {
> - dev_info(&state->dev, "algo %s not found - probe deferred\n", algo);
> - return -EPROBE_DEFER;
> - }
> -
> - ret = digest_set_key(digest, key, key_len);
> - if (ret) {
> - digest_free(digest);
> - return ret;
> - }
> -
> - backend_raw->backend.digest = digest;
> - backend_raw->size_full = digest_length(digest);
> -
> - return 0;
> -}
> -
> -/*
> - * state_backend_raw_file - create a raw file backend store for a state instance
> - *
> - * @state The state instance to work on
> - * @path The path where the state will be stored to
> - * @offset The offset in the storage file
> - * @size The maximum size to use in the storage file
> - *
> - * This backend stores raw binary data from a state instance. The
> - * binary data is protected with a magic value which has to match and
> - * a crc32 that must be valid. Two copies are stored, sufficient
> - * space must be available.
> -
> - * @path can be a path to a device or a regular file. When it's a
> - * device @size may be 0. The two copies are spread to different
> - * eraseblocks if approriate for this device.
> - */
> -int state_backend_raw_file(struct state *state, const char *of_path,
> - const char *path, off_t offset, size_t size)
> -{
> - struct state_backend_raw *backend_raw;
> - struct state_backend *backend;
> - struct state_variable *sv;
> - struct mtd_info_user meminfo;
> - size_t path_size = 0;
> - int ret;
> -
> - if (state->backend)
> - return -EBUSY;
> -
> - ret = state_backend_raw_file_get_size(path, &path_size);
> - if (ret)
> - return ret;
> -
> - if (size == 0)
> - size = path_size;
> - else if (offset + size > path_size)
> - return -EINVAL;
> -
> - backend_raw = xzalloc(sizeof(*backend_raw));
> -
> - ret = state_backend_raw_file_init_digest(state, backend_raw);
> - if (ret) {
> - free(backend_raw);
> - return ret;
> - }
> -
> - backend = &backend_raw->backend;
> - backend->save = state_backend_raw_save;
> - backend->of_path = xstrdup(of_path);
> - backend->path = xstrdup(path);
> - backend->name = "raw";
> -
> - sv = list_last_entry(&state->variables, struct state_variable, list);
> - backend_raw->size_data = sv->start + sv->size;
> - backend_raw->offset = offset;
> - backend_raw->size = size;
> - backend_raw->size_full += backend_raw->size_data +
> - sizeof(struct backend_raw_header);
> -
> - state->backend = backend;
> -
> - ret = mtd_get_meminfo(backend->path, &meminfo);
> - if (!ret && !(meminfo.flags & MTD_NO_ERASE)) {
> - backend_raw->need_erase = true;
> - backend_raw->size_full = ALIGN(backend_raw->size_full,
> - meminfo.writesize);
> - backend_raw->stride = ALIGN(backend_raw->size_full,
> - meminfo.erasesize);
> - dev_dbg(&state->dev, "is a mtd, adjust stepsize to %ld\n",
> - backend_raw->stride);
> - } else {
> - backend_raw->stride = backend_raw->size_full;
> - }
> -
> - if (backend_raw->size / backend_raw->stride < RAW_BACKEND_COPIES) {
> - dev_err(&state->dev, "not enough space for two copies (%lu each)\n",
> - backend_raw->stride);
> - ret = -ENOSPC;
> - goto err;
> - }
> -
> - ret = state_backend_raw_load(backend, state);
> - if (ret) {
> - dev_warn(&state->dev, "load failed - using defaults\n");
> - } else {
> - dev_info(&state->dev, "load successful\n");
> - state->dirty = 0;
> - }
> -
> - /* ignore return value of load() */
> - return 0;
> -err:
> - digest_free(backend_raw->backend.digest);
> -
> - free(backend_raw);
> - return ret;
> -}
> diff --git a/common/state/Makefile b/common/state/Makefile
> new file mode 100644
> index 000000000000..5d6dcb26dfeb
> --- /dev/null
> +++ b/common/state/Makefile
> @@ -0,0 +1,8 @@
> +obj-y += state.o
> +obj-y += state_variables.o
> +obj-y += backend.o
> +obj-y += backend_format_dtb.o
> +obj-y += backend_format_raw.o
> +obj-y += backend_storage.o
> +obj-y += backend_bucket_direct.o
> +obj-y += backend_bucket_circular.o
> diff --git a/common/state/backend.c b/common/state/backend.c
> new file mode 100644
> index 000000000000..054f8d646679
> --- /dev/null
> +++ b/common/state/backend.c
> @@ -0,0 +1,209 @@
> +/*
> + * Copyright (C) 2016 Pengutronix, Markus Pargmann <mpa@xxxxxxxxxxxxxx>
> + *
> + * This program is free software; you can redistribute it and/or
> + * modify it under the terms of the GNU General Public License
> + * version 2, as published by the Free Software Foundation.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
> + * GNU General Public License for more details.
> + *
> + */
> +
> +#include <linux/kernel.h>
> +#include <linux/list.h>
> +#include <linux/string.h>
> +#include <malloc.h>
> +#include <printk.h>
> +
> +#include "state.h"
> +
> +
> +/**
> + * Save the state
> + * @param state
> + * @return
> + */
> +int state_save(struct state *state)
> +{
> + uint8_t *buf;
> + ssize_t len;
> + int ret;
> + struct state_backend *backend = &state->backend;
> +
> + if (!state->dirty)
> + return 0;
> +
> + ret = backend->format->pack(backend->format, state, &buf, &len);
> + if (ret) {
> + dev_err(&state->dev, "Failed to pack state with backend format %s, %d\n",
> + backend->format->name, ret);
> + return ret;
> + }
> +
> + ret = state_storage_write(&backend->storage, buf, len);
> + if (ret) {
> + dev_err(&state->dev, "Failed to write packed state, %d\n", ret);
> + goto out;
> + }
> +
> + state->dirty = 0;
> +
> +out:
> + free(buf);
> + return ret;
> +}
> +
> +/**
> + * state_load - Loads a state from the backend
> + * @param state The state that should be updated to contain the loaded data
> + * @return 0 on success, -errno on failure. If no state is loaded the previous
> + * values remain in the state.
> + *
> + * This function uses the registered storage backend to read data. All data that
> + * we read is checked for integrity by the formatter. After that we unpack the
> + * data into our state.
> + */
> +int state_load(struct state *state)
> +{
> + uint8_t *buf;
> + ssize_t len;
> + ssize_t len_hint = 0;
> + int ret;
> + struct state_backend *backend = &state->backend;
> +
> + if (backend->format->get_packed_len)
> + len_hint = backend->format->get_packed_len(backend->format,
> + state);
> + ret = state_storage_read(&backend->storage, backend->format,
> + state->magic, &buf, &len, len_hint);
> + if (ret) {
> + dev_err(&state->dev, "Failed to read state with format %s, %d\n",
> + backend->format->name, ret);
> + return ret;
> + }
> +
> + ret = backend->format->unpack(backend->format, state, buf, len);
> + if (ret) {
> + dev_err(&state->dev, "Failed to unpack read data with format %s although verified, %d\n",
> + backend->format->name, ret);
> + goto out;
> + }
> +
> + state->dirty = 0;
> +
> +out:
> + free(buf);
> + return ret;
> +}
> +
> +static int state_format_init(struct state_backend *backend,
> + struct device_d *dev, const char *backend_format,
> + struct device_node *node, const char *state_name)
> +{
> + int ret;
> +
> + if (!strcmp(backend_format, "raw")) {
> + ret = backend_format_raw_create(&backend->format, node,
> + state_name, dev);
> + } else if (!strcmp(backend_format, "dtb")) {
> + ret = backend_format_dtb_create(&backend->format, dev);
> + } else {
> + dev_err(dev, "Invalid backend format %s\n",
> + backend_format);
> + return -EINVAL;
> + }
> +
> + if (ret && ret != -EPROBE_DEFER)
> + dev_err(dev, "Failed to initialize format %s, %d\n",
> + backend_format, ret);
> +
> + return ret;
> +}
> +
> +static void state_format_free(struct state_backend_format *format)
> +{
> + if (format->free)
> + format->free(format);
> +}
> +
> +/**
> + * state_backend_init - Initiates the backend storage and format using the
> + * passed arguments
> + * @param backend state backend
> + * @param dev Device pointer used for prints
> + * @param node the DT device node corresponding to the state
> + * @param backend_format a string describing the format. Valid values are 'raw'
> + * and 'dtb' currently
> + * @param storage_path Path to the backend storage file/device/partition/...
> + * @param state_name Name of the state
> + * @param of_path Path in the devicetree
> + * @param stridesize stridesize in case we have a medium without eraseblocks.
> + * stridesize describes how far apart copies of the same data should be stored.
> + * For blockdevices it makes sense to align them on blocksize.
> + * @param storagetype Type of the storage backend. This may be NULL where we
> + * autoselect some backwardscompatible backend options
> + * @return 0 on success, -errno otherwise
> + */
> +int state_backend_init(struct state_backend *backend, struct device_d *dev,
> + struct device_node *node, const char *backend_format,
> + const char *storage_path, const char *state_name, const
> + char *of_path, off_t offset, size_t max_size,
> + uint32_t stridesize, const char *storagetype)
> +{
> + struct state_backend_storage_bucket *bucket;
> + struct state_backend_storage_bucket *bucket_tmp;
> + int ret;
> +
> + ret = state_format_init(backend, dev, backend_format, node, state_name);
> + if (ret)
> + return ret;
> +
> + ret = state_storage_init(&backend->storage, dev, storage_path, offset,
> + max_size, stridesize, storagetype);
> + if (ret)
> + goto out_free_format;
> +
> + list_for_each_entry_safe(bucket, bucket_tmp, &backend->storage.buckets,
> + bucket_list) {
> + if (!bucket->init)
> + continue;
> +
> + ret = bucket->init(bucket);
> + if (ret) {
> + dev_warn(dev, "Bucket init failed, state degraded, %d\n",
> + ret);
> + list_del(&bucket->bucket_list);
> + bucket->free(bucket);
> + continue;
> + }
> + }
> +
> + if (list_empty(&backend->storage.buckets)) {
> + dev_err(dev, "Failed to initialize any state bucket\n");
> + ret = -EIO;
> + goto out_free_storage;
> + }
> +
> +
> + backend->of_path = of_path;
> +
> + return 0;
> +
> +out_free_storage:
> + state_storage_free(&backend->storage);
> +out_free_format:
> + state_format_free(backend->format);
> + backend->format = NULL;
> +
> + return ret;
> +}
> +
> +void state_backend_free(struct state_backend *backend)
> +{
> + state_storage_free(&backend->storage);
> + if (backend->format)
> + state_format_free(backend->format);
> +}
> diff --git a/common/state/backend_bucket_circular.c b/common/state/backend_bucket_circular.c
> new file mode 100644
> index 000000000000..64e9be2e9979
> --- /dev/null
> +++ b/common/state/backend_bucket_circular.c
> @@ -0,0 +1,580 @@
> +/*
> + * Copyright (C) 2016 Pengutronix, Markus Pargmann <mpa@xxxxxxxxxxxxxx>
> + *
> + * This program is free software; you can redistribute it and/or
> + * modify it under the terms of the GNU General Public License
> + * version 2, as published by the Free Software Foundation.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
> + * GNU General Public License for more details.
> + *
> + */
> +
> +#include <asm-generic/ioctl.h>
> +#include <common.h>
> +#include <fcntl.h>
> +#include <fs.h>
> +#include <libfile.h>
> +#include <linux/kernel.h>
> +#include <linux/mtd/mtd-abi.h>
> +#include <malloc.h>
> +#include <mtd/mtd-peb.h>
> +#include <string.h>
> +
> +#include "state.h"
> +
> +
> +struct state_backend_storage_bucket_circular {
> + struct state_backend_storage_bucket bucket;
> +
> + unsigned int eraseblock; /* Which eraseblock is used */
> + ssize_t writesize; /* Alignment of writes */
> + ssize_t max_size; /* Maximum size of this bucket */
> +
> + off_t write_area; /* Start of the write area (relative offset) */
> + uint32_t last_written_length; /* Size of the data written in the storage */
> +
> +#ifdef __BAREBOX__
> + struct mtd_info *mtd; /* mtd info (used for io in Barebox)*/
> +#else
> + struct mtd_info_user *mtd;
> + int fd;
> +#endif
> +
> + /* Cached data of the last read/write */
> + u8 *current_data;
> + ssize_t current_data_len;
> +
> + bool force_rewrite; /* In case of degradation, force a rewrite */
> +
> + /* For outputs */
> + struct device_d *dev;
> +};
> +
> +struct state_backend_storage_bucket_circular_meta {
> + uint32_t magic;
> + uint32_t written_length;
> +};
> +
> +static const uint32_t circular_magic = 0x14fa2d02;
> +static const uint8_t free_pattern = 0xff;
> +
> +static inline struct state_backend_storage_bucket_circular
> + *get_bucket_circular(struct state_backend_storage_bucket *bucket)
> +{
> + return container_of(bucket,
> + struct state_backend_storage_bucket_circular,
> + bucket);
> +}
> +
> +#ifdef __BAREBOX__
> +static int state_mtd_peb_read(struct state_backend_storage_bucket_circular *circ,
> + char *buf, int offset, int len)
> +{
> + int ret;
> +
> + ret = mtd_peb_read(circ->mtd, buf, circ->eraseblock, offset, len);
> + if (ret == -EBADMSG) {
> + ret = mtd_peb_torture(circ->mtd, circ->eraseblock);
> + if (ret == -EIO) {
> + dev_err(circ->dev, "Tortured eraseblock failed and is marked bad now, PEB %u\n",
> + circ->eraseblock);
> + return -EIO;
> + } else if (ret < 0) {
> + dev_err(circ->dev, "Failed to torture eraseblock, %d\n",
> + ret);
> + return ret;
> + }
> + /*
> + * Fill with invalid data so that the next write is done
> + * behind this area
> + */
> + memset(buf, 0, len);
> + circ->force_rewrite = true;
> + circ->write_area = 0;
> + dev_dbg(circ->dev, "PEB %u has ECC error, forcing rewrite\n",
> + circ->eraseblock);
> + } else if (ret == -EUCLEAN) {
> + circ->force_rewrite = true;
> + dev_dbg(circ->dev, "PEB %u is unclean, forcing rewrite\n",
> + circ->eraseblock);
> + } else if (ret < 0) {
> + dev_err(circ->dev, "Failed to read PEB %u, %d\n",
> + circ->eraseblock, ret);
> + return ret;
> + }
> +
> + return 0;
> +}
> +
> +static int state_mtd_peb_write(struct state_backend_storage_bucket_circular *circ,
> + const char *buf, int offset, int len)
> +{
> + int ret;
> +
> + ret = mtd_peb_write(circ->mtd, buf, circ->eraseblock, offset, len);
> + if (ret == -EBADMSG) {
> + ret = mtd_peb_torture(circ->mtd, circ->eraseblock);
> + if (ret == -EIO) {
> + dev_err(circ->dev, "Tortured eraseblock failed and is marked bad now, PEB %u\n",
> + circ->eraseblock);
> + return -EIO;
> + } else if (ret < 0) {
> + dev_err(circ->dev, "Failed to torture eraseblock, %d\n",
> + ret);
> + return ret;
> + }
> + circ->force_rewrite = true;
> + } else if (ret < 0 && ret != -EUCLEAN) {
> + dev_err(circ->dev, "Failed to write PEB %u, %d\n",
> + circ->eraseblock, ret);
> + return ret;
> + }
> +
> + return 0;
> +}
> +
> +static int state_mtd_peb_erase(struct state_backend_storage_bucket_circular *circ)
> +{
> + return mtd_peb_erase(circ->mtd, circ->eraseblock);
> +}
> +#else
> +static int state_mtd_peb_read(struct state_backend_storage_bucket_circular *circ,
> + char *buf, int suboffset, int len)
> +{
> + int ret;
> + off_t offset = suboffset;
> + struct mtd_ecc_stats stat1, stat2;
> + bool nostats = false;
> +
> + offset += (off_t)circ->eraseblock * circ->mtd->erasesize;
> +
> + ret = lseek(circ->fd, offset, SEEK_SET);
> + if (ret < 0) {
> + dev_err(circ->dev, "Failed to set circular read position to %lld, %d\n",
> + offset, ret);
> + return ret;
> + }
> +
> + dev_dbg(circ->dev, "Read state from %ld length %zd\n", offset,
> + len);
> +
> + ret = ioctl(circ->fd, ECCGETSTATS, &stat1);
> + if (ret)
> + nostats = true;
> +
> + ret = read_full(circ->fd, buf, len);
> + if (ret < 0) {
> + dev_err(circ->dev, "Failed to read circular storage len %zd, %d\n",
> + len, ret);
> + free(buf);
> + return ret;
> + }
> +
> + if (nostats)
> + return 0;
> +
> + ret = ioctl(circ->fd, ECCGETSTATS, &stat2);
> + if (ret)
> + return 0;
> +
> + if (stat2.failed - stat1.failed > 0) {
> + circ->force_rewrite = true;
> + dev_dbg(circ->dev, "PEB %u has ECC error, forcing rewrite\n",
> + circ->eraseblock);
> + } else if (stat2.corrected - stat1.corrected > 0) {
> + circ->force_rewrite = true;
> + dev_dbg(circ->dev, "PEB %u is unclean, forcing rewrite\n",
> + circ->eraseblock);
> + }
> +
> + return 0;
> +}
> +
> +static int state_mtd_peb_write(struct state_backend_storage_bucket_circular *circ,
> + const char *buf, int suboffset, int len)
> +{
> + int ret;
> + off_t offset = suboffset;
> +
> + offset += circ->eraseblock * circ->mtd->erasesize;
> +
> + ret = lseek(circ->fd, offset, SEEK_SET);
> + if (ret < 0) {
> + dev_err(circ->dev, "Failed to set position for circular write %ld, %d\n",
> + offset, ret);
> + return ret;
> + }
> +
> + ret = write_full(circ->fd, buf, len);
> + if (ret < 0) {
> + dev_err(circ->dev, "Failed to write circular to %ld length %zd, %d\n",
> + offset, len, ret);
> + return ret;
> + }
> +
> + /*
> + * We keep the fd open, so flush is necessary. We ignore the return
> + * value as flush is currently not supported for mtd under linux.
> + */
> + flush(circ->fd);
> +
> + dev_dbg(circ->dev, "Written state to offset %ld length %zd data length %zd\n",
> + offset, len, len);
> +
> + return 0;
> +}
> +
> +static int state_mtd_peb_erase(struct state_backend_storage_bucket_circular *circ)
> +{
> + return erase(circ->fd, circ->mtd->erasesize,
> + (off_t)circ->eraseblock * circ->mtd->erasesize);
> +}
> +#endif
> +
> +static int state_backend_bucket_circular_fill_cache(
> + struct state_backend_storage_bucket *bucket)
> +{
> + struct state_backend_storage_bucket_circular *circ =
> + get_bucket_circular(bucket);
> + ssize_t read_len;
> + off_t offset;
> + uint8_t *buf;
> + int ret;
> +
> + /* Storage is empty */
> + if (circ->write_area == 0)
> + return -ENODATA;
> +
> + if (!circ->last_written_length) {
> + /*
> + * Last write did not contain length information, assuming old
> + * state and reading from the beginning.
> + */
> + offset = 0;
> + read_len = min(circ->write_area, (off_t)(circ->max_size -
> + sizeof(struct state_backend_storage_bucket_circular_meta)));
> + circ->write_area = 0;
> + dev_dbg(circ->dev, "Detected old on-storage format\n");
> + } else if (circ->last_written_length > circ->write_area
> + || !IS_ALIGNED(circ->last_written_length, circ->writesize)) {
> + circ->write_area = 0;
> + dev_err(circ->dev, "Error, invalid number of bytes written last time %d\n",
> + circ->last_written_length);
> + return -EINVAL;
> + } else {
> + /*
> + * Normally we read at the end of the non-free area. The length
> + * of the read is then what we read from the meta data
> + * (last_written_length)
> + */
> + read_len = circ->last_written_length;
> + offset = circ->write_area - read_len;
> + }
> +
> + buf = xmalloc(read_len);
> + if (!buf)
> + return -ENOMEM;
> +
> + dev_dbg(circ->dev, "Read state from PEB %u global offset %ld length %zd\n",
> + circ->eraseblock, offset, read_len);
> +
> + ret = state_mtd_peb_read(circ, buf, offset, read_len);
> + if (ret < 0) {
> + dev_err(circ->dev, "Failed to read circular storage len %zd, %d\n",
> + read_len, ret);
> + free(buf);
> + return ret;
> + }
> +
> + circ->current_data = buf;
> + circ->current_data_len = read_len;
> +
> + return 0;
> +}
> +
> +static int state_backend_bucket_circular_read(struct state_backend_storage_bucket *bucket,
> + uint8_t ** buf_out,
> + ssize_t * len_hint)
> +{
> + struct state_backend_storage_bucket_circular *circ =
> + get_bucket_circular(bucket);
> + int ret;
> +
> + if (!circ->current_data) {
> + ret = state_backend_bucket_circular_fill_cache(bucket);
> + if (ret)
> + return ret;
> + }
> +
> + /*
> + * We keep the internal copy in the cache and duplicate the data for
> + * external use
> + */
> + *buf_out = xmemdup(circ->current_data, circ->current_data_len);
> + if (!*buf_out)
> + return -ENOMEM;
> +
> + *len_hint = circ->current_data_len - sizeof(struct state_backend_storage_bucket_circular_meta);
> +
> + return 0;
> +}
> +
> +static int state_backend_bucket_circular_write(struct state_backend_storage_bucket *bucket,
> + const uint8_t * buf,
> + ssize_t len)
> +{
> + struct state_backend_storage_bucket_circular *circ =
> + get_bucket_circular(bucket);
> + off_t offset;
> + struct state_backend_storage_bucket_circular_meta *meta;
> + uint32_t written_length = ALIGN(len + sizeof(*meta), circ->writesize);
> + int ret;
> + uint8_t *write_buf;
> +
> + if (written_length > circ->max_size) {
> + dev_err(circ->dev, "Error, state data too big to be written, to write: %zd, writesize: %zd, length: %zd, available: %zd\n",
> + written_length, circ->writesize, len, circ->max_size);
> + return -E2BIG;
> + }
> +
> + /*
> + * We need zero initialization so that our data comparisons don't show
> + * random changes
> + */
> + write_buf = xzalloc(written_length);
> + if (!write_buf)
> + return -ENOMEM;
> +
> + memcpy(write_buf, buf, len);
> + meta = (struct state_backend_storage_bucket_circular_meta *)
> + (write_buf + written_length - sizeof(*meta));
> + meta->magic = circular_magic;
> + meta->written_length = written_length;
> +
> + /* Nothing in cache? Then read to see what is on the device currently */
> + if (!circ->current_data) {
> + state_backend_bucket_circular_fill_cache(bucket);
> + }
> +
> + /*
> + * If we would write the same data that is currently on the device, we
> + * can return successfully without writing.
> + * Note that the cache may still be empty if the storage is empty or
> + * errors occured.
> + */
> + if (circ->current_data) {
> + dev_dbg(circ->dev, "Comparing cached data, writing %zd bytes, cached %zd bytes\n",
> + written_length, circ->current_data_len);
> + if (!circ->force_rewrite &&
> + written_length == circ->current_data_len &&
> + !memcmp(circ->current_data, write_buf, written_length)) {
> + dev_dbg(circ->dev, "Data already on device, not writing again\n");
> + goto out_free;
> + } else {
> + free(circ->current_data);
> + circ->current_data = NULL;
> + }
> + }
> +
> + if (circ->write_area + written_length >= circ->max_size) {
> + circ->write_area = 0;
> + }
> + /*
> + * If the write area is at the beginning of the page, erase it and write
> + * at offset 0. As we only erase right before writing there are no
> + * conditions where we regularly erase a block multiple times without
> + * writing.
> + */
> + if (circ->write_area == 0) {
> + dev_dbg(circ->dev, "Erasing PEB %u\n", circ->eraseblock);
> + ret = state_mtd_peb_erase(circ);
> + if (ret) {
> + dev_err(circ->dev, "Failed to erase PEB %u\n",
> + circ->eraseblock);
> + goto out_free;
> + }
> + }
> +
> + offset = circ->write_area;
> +
> + /*
> + * Update write_area before writing. The write operation may put
> + * arbitrary amount of the data into the storage before failing. In this
> + * case we want to start after that area.
> + */
> + circ->write_area += written_length;
> +
> + ret = state_mtd_peb_write(circ, write_buf, offset, written_length);
> + if (ret < 0) {
> + dev_err(circ->dev, "Failed to write circular to %ld length %zd, %d\n",
> + offset, written_length, ret);
> + goto out_free;
> + }
> +
> + dev_dbg(circ->dev, "Written state to PEB %u offset %ld length %zd data length %zd\n",
> + circ->eraseblock, offset, written_length, len);
> +
> + /* Put written data into the cache */
> + WARN_ON(circ->current_data);
> + circ->current_data = write_buf;
> + circ->current_data_len = written_length;
> + write_buf = NULL;
> + circ->force_rewrite = false;
> +
> +out_free:
> + if (write_buf)
> + free(write_buf);
> + return 0;
> +}
> +
> +/**
> + * state_backend_bucket_circular_init - Initialize circular bucket
> + * @param bucket
> + * @return 0 on success, -errno otherwise
> + *
> + * This function searches for the beginning of the written area from the end of
> + * the MTD device. This way it knows where the data ends and where the free area
> + * starts.
> + */
> +static int state_backend_bucket_circular_init(
> + struct state_backend_storage_bucket *bucket)
> +{
> + struct state_backend_storage_bucket_circular *circ =
> + get_bucket_circular(bucket);
> + int sub_offset;
> + uint32_t written_length = 0;
> + uint8_t *buf;
> +
> + buf = xmalloc(circ->writesize);
> + if (!buf)
> + return -ENOMEM;
> +
> + for (sub_offset = circ->max_size - circ->writesize; sub_offset >= 0;
> + sub_offset -= circ->writesize) {
> + int ret;
> +
> + ret = state_mtd_peb_read(circ, buf, sub_offset,
> + circ->writesize);
> + if (ret)
> + return ret;
> +
> + ret = mtd_buf_all_ff(buf, circ->writesize);
> + if (!ret) {
> + struct state_backend_storage_bucket_circular_meta *meta;
> +
> + meta = (struct state_backend_storage_bucket_circular_meta *)
> + (buf + circ->writesize - sizeof(*meta));
> +
> + if (meta->magic != circular_magic)
> + written_length = 0;
> + else
> + written_length = meta->written_length;
> +
> + break;
> + }
> + }
> +
> + circ->write_area = sub_offset + circ->writesize;
> + circ->last_written_length = written_length;
> +
> + free(buf);
> +
> + return 0;
> +}
> +
> +static void state_backend_bucket_circular_free(struct
> + state_backend_storage_bucket
> + *bucket)
> +{
> + struct state_backend_storage_bucket_circular *circ =
> + get_bucket_circular(bucket);
> +
> + if (circ->current_data)
> + free(circ->current_data);
> + free(circ);
> +}
> +
> +#ifdef __BAREBOX__
> +static int bucket_circular_is_block_bad(struct state_backend_storage_bucket_circular *circ)
> +{
> + int ret;
> +
> + ret = mtd_peb_is_bad(circ->mtd, circ->eraseblock);
> + if (ret < 0)
> + dev_err(circ->dev, "Failed to determine whether eraseblock %u is bad, %d\n",
> + circ->eraseblock, ret);
> +
> + return ret;
> +}
> +#else
> +static int bucket_circular_is_block_bad(struct state_backend_storage_bucket_circular *circ)
> +{
> + int ret;
> + loff_t offs = circ->eraseblock * circ->mtd->erasesize;
> +
> + ret = ioctl(circ->fd, MEMGETBADBLOCK, &offs);
> + if (ret < 0)
> + dev_err(circ->dev, "Failed to use ioctl to check for bad block at offset %ld, %d\n",
> + offs, ret);
> +
> + return ret;
> +}
> +#endif
> +
> +int state_backend_bucket_circular_create(struct device_d *dev, const char *path,
> + struct state_backend_storage_bucket **bucket,
> + unsigned int eraseblock,
> + ssize_t writesize,
> + struct mtd_info_user *mtd_uinfo)
> +{
> + struct state_backend_storage_bucket_circular *circ;
> + int ret;
> +
> + circ = xzalloc(sizeof(*circ));
> + circ->eraseblock = eraseblock;
> + circ->writesize = writesize;
> + circ->max_size = mtd_uinfo->erasesize;
> + circ->dev = dev;
> +
> +#ifdef __BAREBOX__
> + circ->mtd = mtd_uinfo->mtd;
> +#else
> + circ->mtd = xzalloc(sizeof(*mtd_uinfo));
> + memcpy(circ->mtd, mtd_uinfo, sizeof(*mtd_uinfo));
> + circ->fd = open(path, O_RDWR);
> + if (circ->fd < 0) {
> + pr_err("Failed to open circular bucket '%s'\n", path);
> + return -errno;
> + }
> +#endif
> +
> + ret = bucket_circular_is_block_bad(circ);
> + if (ret) {
> + dev_info(dev, "Not using eraseblock %u, it is marked as bad (%d)\n",
> + circ->eraseblock, ret);
> + ret = -EIO;
> + goto out_free;
> + }
> +
> + circ->bucket.read = state_backend_bucket_circular_read;
> + circ->bucket.write = state_backend_bucket_circular_write;
> + circ->bucket.free = state_backend_bucket_circular_free;
> + *bucket = &circ->bucket;
> +
> + ret = state_backend_bucket_circular_init(*bucket);
> + if (ret)
> + goto out_free;
> +
> + return 0;
> +
> +out_free:
> +#ifndef __BAREBOX__
> + close(circ->fd);
> +#endif
> + free(circ);
> +
> + return ret;
> +}
> diff --git a/common/state/backend_bucket_direct.c b/common/state/backend_bucket_direct.c
> new file mode 100644
> index 000000000000..08892f001e25
> --- /dev/null
> +++ b/common/state/backend_bucket_direct.c
> @@ -0,0 +1,180 @@
> +/*
> + * Copyright (C) 2016 Pengutronix, Markus Pargmann <mpa@xxxxxxxxxxxxxx>
> + *
> + * This program is free software; you can redistribute it and/or
> + * modify it under the terms of the GNU General Public License
> + * version 2, as published by the Free Software Foundation.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
> + * GNU General Public License for more details.
> + *
> + */
> +
> +#include <fcntl.h>
> +#include <fs.h>
> +#include <libfile.h>
> +#include <linux/kernel.h>
> +#include <malloc.h>
> +#include <printk.h>
> +
> +#include "state.h"
> +
> +struct state_backend_storage_bucket_direct {
> + struct state_backend_storage_bucket bucket;
> +
> + ssize_t offset;
> + ssize_t max_size;
> +
> + int fd;
> +
> + struct device_d *dev;
> +};
> +
> +struct state_backend_storage_bucket_direct_meta {
> + uint32_t magic;
> + uint32_t written_length;
> +};
> +static const uint32_t direct_magic = 0x2354fdf3;
> +
> +static inline struct state_backend_storage_bucket_direct
> + *get_bucket_direct(struct state_backend_storage_bucket *bucket)
> +{
> + return container_of(bucket, struct state_backend_storage_bucket_direct,
> + bucket);
> +}
> +
> +static int state_backend_bucket_direct_read(struct state_backend_storage_bucket
> + *bucket, uint8_t ** buf_out,
> + ssize_t * len_hint)
> +{
> + struct state_backend_storage_bucket_direct *direct =
> + get_bucket_direct(bucket);
> + struct state_backend_storage_bucket_direct_meta meta;
> + ssize_t read_len;
> + uint8_t *buf;
> + int ret;
> +
> + ret = lseek(direct->fd, direct->offset, SEEK_SET);
> + if (ret < 0) {
> + dev_err(direct->dev, "Failed to seek file, %d\n", ret);
> + return ret;
> + }
> + ret = read_full(direct->fd, &meta, sizeof(meta));
> + if (ret < 0) {
> + dev_err(direct->dev, "Failed to read meta data from file, %d\n", ret);
> + return ret;
> + }
> + if (meta.magic == direct_magic) {
> + read_len = meta.written_length;
> + } else {
> + if (*len_hint)
> + read_len = *len_hint;
> + else
> + read_len = direct->max_size;
> + ret = lseek(direct->fd, direct->offset, SEEK_SET);
> + if (ret < 0) {
> + dev_err(direct->dev, "Failed to seek file, %d\n", ret);
> + return ret;
> + }
> + }
> + if (direct->max_size)
> + read_len = min(read_len, direct->max_size);
> +
> + buf = xmalloc(read_len);
> + if (!buf)
> + return -ENOMEM;
> +
> + ret = read_full(direct->fd, buf, read_len);
> + if (ret < 0) {
> + dev_err(direct->dev, "Failed to read from file, %d\n", ret);
> + free(buf);
> + return ret;
> + }
> +
> + *buf_out = buf;
> + *len_hint = read_len;
> +
> + return 0;
> +}
> +
> +static int state_backend_bucket_direct_write(struct state_backend_storage_bucket
> + *bucket, const uint8_t * buf,
> + ssize_t len)
> +{
> + struct state_backend_storage_bucket_direct *direct =
> + get_bucket_direct(bucket);
> + int ret;
> + struct state_backend_storage_bucket_direct_meta meta;
> +
> + if (direct->max_size && len > direct->max_size)
> + return -E2BIG;
> +
> + ret = lseek(direct->fd, direct->offset, SEEK_SET);
> + if (ret < 0) {
> + dev_err(direct->dev, "Failed to seek file, %d\n", ret);
> + return ret;
> + }
> +
> + meta.magic = direct_magic;
> + meta.written_length = len;
> + ret = write_full(direct->fd, &meta, sizeof(meta));
> + if (ret < 0) {
> + dev_err(direct->dev, "Failed to write metadata to file, %d\n", ret);
> + return ret;
> + }
> +
> + ret = write_full(direct->fd, buf, len);
> + if (ret < 0) {
> + dev_err(direct->dev, "Failed to write file, %d\n", ret);
> + return ret;
> + }
> +
> + ret = flush(direct->fd);
> + if (ret < 0) {
> + dev_err(direct->dev, "Failed to flush file, %d\n", ret);
> + return ret;
> + }
> +
> + return 0;
> +}
> +
> +static void state_backend_bucket_direct_free(struct
> + state_backend_storage_bucket
> + *bucket)
> +{
> + struct state_backend_storage_bucket_direct *direct =
> + get_bucket_direct(bucket);
> +
> + close(direct->fd);
> + free(direct);
> +}
> +
> +int state_backend_bucket_direct_create(struct device_d *dev, const char *path,
> + struct state_backend_storage_bucket **bucket,
> + off_t offset, ssize_t max_size)
> +{
> + int fd;
> + struct state_backend_storage_bucket_direct *direct;
> +
> + fd = open(path, O_RDWR);
> + if (fd < 0) {
> + dev_err(dev, "Failed to open file '%s', %d\n", path, -errno);
> + close(fd);
> + return -errno;
> + }
> +
> + direct = xzalloc(sizeof(*direct));
> + direct->offset = offset;
> + direct->max_size = max_size;
> + direct->fd = fd;
> + direct->dev = dev;
> +
> + direct->bucket.read = state_backend_bucket_direct_read;
> + direct->bucket.write = state_backend_bucket_direct_write;
> + direct->bucket.free = state_backend_bucket_direct_free;
> + *bucket = &direct->bucket;
> +
> + return 0;
> +}
> diff --git a/common/state/backend_format_dtb.c b/common/state/backend_format_dtb.c
> new file mode 100644
> index 000000000000..dc19c888e5b6
> --- /dev/null
> +++ b/common/state/backend_format_dtb.c
> @@ -0,0 +1,150 @@
> +/*
> + * Copyright (C) 2012-2014 Pengutronix, Jan Luebbe <j.luebbe@xxxxxxxxxxxxxx>
> + * Copyright (C) 2013-2014 Pengutronix, Sascha Hauer <s.hauer@xxxxxxxxxxxxxx>
> + * Copyright (C) 2015 Pengutronix, Marc Kleine-Budde <mkl@xxxxxxxxxxxxxx>
> + * Copyright (C) 2016 Pengutronix, Markus Pargmann <mpa@xxxxxxxxxxxxxx>
> + *
> + * This program is free software; you can redistribute it and/or
> + * modify it under the terms of the GNU General Public License
> + * version 2, as published by the Free Software Foundation.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
> + * GNU General Public License for more details.
> + *
> + */
> +
> +#include <common.h>
> +#include <of.h>
> +#include <linux/kernel.h>
> +#include <malloc.h>
> +
> +#include "state.h"
> +
> +struct state_backend_format_dtb {
> + struct state_backend_format format;
> +
> + struct device_node *root;
> +
> + /* For outputs */
> + struct device_d *dev;
> +};
> +
> +static inline struct state_backend_format_dtb *get_format_dtb(struct
> + state_backend_format
> + *format)
> +{
> + return container_of(format, struct state_backend_format_dtb, format);
> +}
> +
> +static int state_backend_format_dtb_verify(struct state_backend_format *format,
> + uint32_t magic, const uint8_t * buf,
> + ssize_t len)
> +{
> + struct state_backend_format_dtb *fdtb = get_format_dtb(format);
> + struct device_node *root;
> + struct fdt_header *fdt = (struct fdt_header *)buf;
> + size_t dtb_len = fdt32_to_cpu(fdt->totalsize);
> +
> + if (dtb_len > len) {
> + dev_err(fdtb->dev, "Error, stored DTB length (%d) longer than read buffer (%d)\n",
> + dtb_len, len);
> + return -EINVAL;
> + }
> +
> + if (fdtb->root) {
> + of_delete_node(fdtb->root);
> + fdtb->root = NULL;
> + }
> +
> + root = of_unflatten_dtb(buf);
> + if (IS_ERR(root)) {
> + dev_err(fdtb->dev, "Failed to unflatten dtb from buffer with length %zd, %ld\n",
> + len, PTR_ERR(root));
> + return PTR_ERR(root);
> + }
> +
> + fdtb->root = root;
> +
> + return 0;
> +}
> +
> +static int state_backend_format_dtb_unpack(struct state_backend_format *format,
> + struct state *state,
> + const uint8_t * buf, ssize_t len)
> +{
> + struct state_backend_format_dtb *fdtb = get_format_dtb(format);
> + int ret;
> +
> + if (!fdtb->root) {
> + state_backend_format_dtb_verify(format, 0, buf, len);
>
--
Pengutronix e.K. | |
Industrial Linux Solutions | http://www.pengutronix.de/ |
Peiner Str. 6-8, 31137 Hildesheim, Germany | Phone: +49-5121-206917-0 |
Amtsgericht Hildesheim, HRA 2686 | Fax: +49-5121-206917-5555 |
Attachment:
signature.asc
Description: This is a digitally signed message part.
_______________________________________________ barebox mailing list barebox@xxxxxxxxxxxxxxxxxxx http://lists.infradead.org/mailman/listinfo/barebox
