tequilaOS/platform_external_dtc
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

fdtput: expand fdt if value does not fit

Browse source 
If you try to insert a new node or extend a property with large value,
using fdtput you will notice that it always fails.

example:
fdtput -v -p -ts ./tst.dtb "/node-1" "property-1" "value-1
Error at 'node-1': FDT_ERR_NOSPACE

or

fdtput -v -c ./tst.dtb "/node-1"
Error at 'node-1': FDT_ERR_NOSPACE

or

fdtput -v  -ts ./tst.dtb "/node" "property" "very big value"
Decoding value:
	string: 'very big value'
Value size 15
Error at 'property': FDT_ERR_NOSPACE

All these error are returned from libfdt, as the size of the fdt passed
has no space to accomdate these new properties.
This patch adds realloc functions in fdtput to allocate new space in fdt
when it detects a shortage in space for new value or node. With this
patch, fdtput can insert a new node or property or extend a property
with new value greater than original size. Also it packs the final blob
to clean up any extra padding.

Without this patch fdtput tool complains with FDT_ERR_NOSPACE when we
try to add a node/property or extend the value of a property.

Testcases for the new behaviour added by David Gibson.

Signed-off-by: Srinivas Kandagatla <srinivas.kandagatla@st.com>
Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
This commit is contained in:
Srinivas Kandagatla 2013-05-29 12:47:38 +10:00 committed by David Gibson
parent a58afe2eb2
commit d214655904
2 changed files with 65 additions and 15 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

74
fdtput.c
View file

@ -131,19 +131,59 @@ static int encode_value(struct display_info *disp, char **arg, int arg_count,
return 0;
}
static int store_key_value(void *blob, const char *node_name,
#define ALIGN(x) (((x) + (FDT_TAGSIZE) - 1) & ~((FDT_TAGSIZE) - 1))
static char *_realloc_fdt(char *fdt, int delta)
{
int new_sz = fdt_totalsize(fdt) + delta;
fdt = xrealloc(fdt, new_sz);
fdt_open_into(fdt, fdt, new_sz);
return fdt;
}
static char *realloc_node(char *fdt, const char *name)
{
int delta;
/* FDT_BEGIN_NODE, node name in off_struct and FDT_END_NODE */
delta = sizeof(struct fdt_node_header) + ALIGN(strlen(name) + 1)
+ FDT_TAGSIZE;
return _realloc_fdt(fdt, delta);
}
static char *realloc_property(char *fdt, int nodeoffset,
const char *name, int newlen)
{
int delta = 0;
int oldlen = 0;
if (!fdt_get_property(fdt, nodeoffset, name, &oldlen))
/* strings + property header */
delta = sizeof(struct fdt_property) + strlen(name) + 1;
if (newlen > oldlen)
/* actual value in off_struct */
delta += ALIGN(newlen) - ALIGN(oldlen);
return _realloc_fdt(fdt, delta);
}
static int store_key_value(char **blob, const char *node_name,
const char *property, const char *buf, int len)
{
int node;
int err;
node = fdt_path_offset(blob, node_name);
node = fdt_path_offset(*blob, node_name);
if (node < 0) {
report_error(node_name, -1, node);
return -1;
}
err = fdt_setprop(blob, node, property, buf, len);
err = fdt_setprop(*blob, node, property, buf, len);
if (err == -FDT_ERR_NOSPACE) {
*blob = realloc_property(*blob, node, property, len);
err = fdt_setprop(*blob, node, property, buf, len);
}
if (err) {
report_error(property, -1, err);
return -1;
@ -161,7 +201,7 @@ static int store_key_value(void *blob, const char *node_name,
* @param in_path Path to process
* @return 0 if ok, -1 on error
*/
static int create_paths(void *blob, const char *in_path)
static int create_paths(char **blob, const char *in_path)
{
const char *path = in_path;
const char *sep;
@ -177,10 +217,11 @@ static int create_paths(void *blob, const char *in_path)
if (!sep)
sep = path + strlen(path);
node = fdt_subnode_offset_namelen(blob, offset, path,
node = fdt_subnode_offset_namelen(*blob, offset, path,
sep - path);
if (node == -FDT_ERR_NOTFOUND) {
node = fdt_add_subnode_namelen(blob, offset, path,
*blob = realloc_node(*blob, path);
node = fdt_add_subnode_namelen(*blob, offset, path,
sep - path);
}
if (node < 0) {
@ -203,7 +244,7 @@ static int create_paths(void *blob, const char *in_path)
* @param node_name Name of node to create
* @return new node offset if found, or -1 on failure
*/
static int create_node(void *blob, const char *node_name)
static int create_node(char **blob, const char *node_name)
{
int node = 0;
char *p;
@ -215,15 +256,17 @@ static int create_node(void *blob, const char *node_name)
}
*p = '\0';
*blob = realloc_node(*blob, p + 1);
if (p > node_name) {
node = fdt_path_offset(blob, node_name);
node = fdt_path_offset(*blob, node_name);
if (node < 0) {
report_error(node_name, -1, node);
return -1;
}
}
node = fdt_add_subnode(blob, node, p + 1);
node = fdt_add_subnode(*blob, node, p + 1);
if (node < 0) {
report_error(p + 1, -1, node);
return -1;
@ -250,23 +293,25 @@ static int do_fdtput(struct display_info *disp, const char *filename,
* store them into the property.
*/
assert(arg_count >= 2);
if (disp->auto_path && create_paths(blob, *arg))
if (disp->auto_path && create_paths(&blob, *arg))
return -1;
if (encode_value(disp, arg + 2, arg_count - 2, &value, &len) ||
store_key_value(blob, *arg, arg[1], value, len))
store_key_value(&blob, *arg, arg[1], value, len))
ret = -1;
break;
case OPER_CREATE_NODE:
for (; ret >= 0 && arg_count--; arg++) {
if (disp->auto_path)
ret = create_paths(blob, *arg);
ret = create_paths(&blob, *arg);
else
ret = create_node(blob, *arg);
ret = create_node(&blob, *arg);
}
break;
}
if (ret >= 0)
if (ret >= 0) {
fdt_pack(blob);
ret = utilfdt_write(filename, blob);
}
free(blob);
return ret;
@ -313,7 +358,6 @@ int main(int argc, char *argv[])
* - rename node
* - pack fdt before writing
* - set amount of free space when writing
* - expand fdt if value doesn't fit
*/
switch (opt) {
case_USAGE_COMMON_FLAGS

6
tests/run_tests.sh
View file

@ -549,6 +549,9 @@ fdtput_tests () {
-tx "a0b0c0d deeaae ef000000"
run_fdtput_test "$(cat $text)" $dtb /randomnode blob -ts "$(cat $text)"
# Test expansion of the blob when insufficient room for property
run_fdtput_test "$(cat $text $text)" $dtb /randomnode blob -ts "$(cat $text $text)"
# Start again with a fresh dtb
run_dtc_test -O dtb -p $(stat -c %s $text) -o $dtb $dts
@ -570,6 +573,9 @@ fdtput_tests () {
"-ts" "fine wine"
run_wrap_test $DTPUT $dtb -p /you/are/drunk/sir/winston slurp -ts twice
# Test expansion of the blob when insufficent room for a new node
run_wrap_test $DTPUT $dtb -cp "$(cat $text $text)/longish"
# Allowed to create an existing node with -p
run_wrap_test $DTPUT $dtb -cp /chosen
run_wrap_test $DTPUT $dtb -cp /chosen/son