kernel
/
dtc
mirror of https://git.kernel.org/pub/scm/utils/dtc/dtc.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

libfdt: Increase namespace-pollution paranoia 

libfdt is supposed to easy to embed in projects all and sundry.
Often, it won't be practical to separate the embedded libfdt's
namespace from that of the surrounding project.  Which means there can
be namespace conflicts between even libfdt's internal/static functions
and functions or macros coming from the surrounding project's headers
via libfdt_env.h.

This patch, therefore, renames a bunch of libfdt internal functions
and macros and makes a few other chances to reduce the chances of
namespace collisions with embedding projects.  Specifically:
	- Internal functions (even static ones) are now named _fdt_*()

	- The type and (static) global for the error table in
          fdt_strerror() gain an fdt_ prefix

	- The unused macro PALIGN is removed

	- The memeq and streq macros are removed and open-coded in the
          users (they were only used once each)

	- Other macros gain an FDT_ prefix

	- To save some of the bulk from the previous change, an
          FDT_TAGALIGN() macro is introduced, where FDT_TAGALIGN(x) ==
          FDT_ALIGN(x, FDT_TAGSIZE)

Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
main
David Gibson 17 years ago committed by Jon Loeliger
parent
4d7bea7873
commit
b6d80a20fc
7 changed files with 119 additions and 122 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 8
      libfdt/fdt.c
  2. 22
      libfdt/fdt_ro.c
  3. 121
      libfdt/fdt_rw.c
  4. 34
      libfdt/fdt_strerror.c
  5. 38
      libfdt/fdt_sw.c
  6. 7
      libfdt/fdt_wip.c
  7. 11
      libfdt/libfdt_internal.h

8
libfdt/fdt.c
Unescape View File

@ -63,7 +63,7 @@ int fdt_check_header(const void *fdt)
return -FDT_ERR_BADVERSION; return -FDT_ERR_BADVERSION;
if (fdt_last_comp_version(fdt) > FDT_LAST_SUPPORTED_VERSION) if (fdt_last_comp_version(fdt) > FDT_LAST_SUPPORTED_VERSION)
return -FDT_ERR_BADVERSION; return -FDT_ERR_BADVERSION;
} else if (fdt_magic(fdt) == SW_MAGIC) { } else if (fdt_magic(fdt) == FDT_SW_MAGIC) {
/* Unfinished sequential-write blob */ /* Unfinished sequential-write blob */
if (fdt_size_dt_struct(fdt) == 0) if (fdt_size_dt_struct(fdt) == 0)
return -FDT_ERR_BADSTATE; return -FDT_ERR_BADSTATE;
@ -124,7 +124,7 @@ uint32_t fdt_next_tag(const void *fdt, int offset, int *nextoffset)
} }


if (nextoffset) if (nextoffset)
*nextoffset = ALIGN(offset, FDT_TAGSIZE); *nextoffset = FDT_TAGALIGN(offset);


return tag; return tag;
} }
@ -184,14 +184,14 @@ const char *_fdt_find_string(const char *strtab, int tabsize, const char *s)
const char *p; const char *p;


for (p = strtab; p <= last; p++) for (p = strtab; p <= last; p++)
if (memeq(p, s, len)) if (memcmp(p, s, len) == 0)
return p; return p;
return NULL; return NULL;
} }


int fdt_move(const void *fdt, void *buf, int bufsize) int fdt_move(const void *fdt, void *buf, int bufsize)
{ {
CHECK_HEADER(fdt); FDT_CHECK_HEADER(fdt);


if (fdt_totalsize(fdt) > bufsize) if (fdt_totalsize(fdt) > bufsize)
return -FDT_ERR_NOSPACE; return -FDT_ERR_NOSPACE;

22
libfdt/fdt_ro.c
Unescape View File

@ -55,8 +55,8 @@


#include "libfdt_internal.h" #include "libfdt_internal.h"


static int nodename_eq(const void *fdt, int offset, static int _fdt_nodename_eq(const void *fdt, int offset,
const char *s, int len) const char *s, int len)
{ {
const char *p = fdt_offset_ptr(fdt, offset + FDT_TAGSIZE, len+1); const char *p = fdt_offset_ptr(fdt, offset + FDT_TAGSIZE, len+1);


@ -82,7 +82,7 @@ const char *fdt_string(const void *fdt, int stroffset)


int fdt_get_mem_rsv(const void *fdt, int n, uint64_t *address, uint64_t *size) int fdt_get_mem_rsv(const void *fdt, int n, uint64_t *address, uint64_t *size)
{ {
CHECK_HEADER(fdt); FDT_CHECK_HEADER(fdt);
*address = fdt64_to_cpu(_fdt_mem_rsv(fdt, n)->address); *address = fdt64_to_cpu(_fdt_mem_rsv(fdt, n)->address);
*size = fdt64_to_cpu(_fdt_mem_rsv(fdt, n)->size); *size = fdt64_to_cpu(_fdt_mem_rsv(fdt, n)->size);
return 0; return 0;
@ -102,7 +102,7 @@ int fdt_subnode_offset_namelen(const void *fdt, int offset,
{ {
int depth; int depth;


CHECK_HEADER(fdt); FDT_CHECK_HEADER(fdt);


for (depth = 0; for (depth = 0;
offset >= 0; offset >= 0;
@ -110,7 +110,7 @@ int fdt_subnode_offset_namelen(const void *fdt, int offset,
if (depth < 0) if (depth < 0)
return -FDT_ERR_NOTFOUND; return -FDT_ERR_NOTFOUND;
else if ((depth == 1) else if ((depth == 1)
&& nodename_eq(fdt, offset, name, namelen)) && _fdt_nodename_eq(fdt, offset, name, namelen))
return offset; return offset;
} }


@ -129,7 +129,7 @@ int fdt_path_offset(const void *fdt, const char *path)
const char *p = path; const char *p = path;
int offset = 0; int offset = 0;


CHECK_HEADER(fdt); FDT_CHECK_HEADER(fdt);


if (*path != '/') if (*path != '/')
return -FDT_ERR_BADPATH; return -FDT_ERR_BADPATH;
@ -210,7 +210,7 @@ const struct fdt_property *fdt_get_property(const void *fdt,
if (! prop) if (! prop)
goto fail; goto fail;
namestroff = fdt32_to_cpu(prop->nameoff); namestroff = fdt32_to_cpu(prop->nameoff);
if (streq(fdt_string(fdt, namestroff), name)) { if (strcmp(fdt_string(fdt, namestroff), name) == 0) {
/* Found it! */ /* Found it! */
int len = fdt32_to_cpu(prop->len); int len = fdt32_to_cpu(prop->len);
prop = fdt_offset_ptr(fdt, offset, prop = fdt_offset_ptr(fdt, offset,
@ -268,7 +268,7 @@ int fdt_get_path(const void *fdt, int nodeoffset, char *buf, int buflen)
int offset, depth, namelen; int offset, depth, namelen;
const char *name; const char *name;


CHECK_HEADER(fdt); FDT_CHECK_HEADER(fdt);


if (buflen < 2) if (buflen < 2)
return -FDT_ERR_NOSPACE; return -FDT_ERR_NOSPACE;
@ -321,7 +321,7 @@ int fdt_supernode_atdepth_offset(const void *fdt, int nodeoffset,
int offset, depth; int offset, depth;
int supernodeoffset = -FDT_ERR_INTERNAL; int supernodeoffset = -FDT_ERR_INTERNAL;


CHECK_HEADER(fdt); FDT_CHECK_HEADER(fdt);


if (supernodedepth < 0) if (supernodedepth < 0)
return -FDT_ERR_NOTFOUND; return -FDT_ERR_NOTFOUND;
@ -380,7 +380,7 @@ int fdt_node_offset_by_prop_value(const void *fdt, int startoffset,
const void *val; const void *val;
int len; int len;


CHECK_HEADER(fdt); FDT_CHECK_HEADER(fdt);


/* FIXME: The algorithm here is pretty horrible: we scan each /* FIXME: The algorithm here is pretty horrible: we scan each
* property of a node in fdt_getprop(), then if that didn't * property of a node in fdt_getprop(), then if that didn't
@ -445,7 +445,7 @@ int fdt_node_offset_by_compatible(const void *fdt, int startoffset,
{ {
int offset, err; int offset, err;


CHECK_HEADER(fdt); FDT_CHECK_HEADER(fdt);


/* FIXME: The algorithm here is pretty horrible: we scan each /* FIXME: The algorithm here is pretty horrible: we scan each
* property of a node in fdt_node_check_compatible(), then if * property of a node in fdt_node_check_compatible(), then if

121
libfdt/fdt_rw.c
Unescape View File

@ -55,10 +55,10 @@


#include "libfdt_internal.h" #include "libfdt_internal.h"


static int _blocks_misordered(const void *fdt, static int _fdt_blocks_misordered(const void *fdt,
int mem_rsv_size, int struct_size) int mem_rsv_size, int struct_size)
{ {
return (fdt_off_mem_rsvmap(fdt) < ALIGN(sizeof(struct fdt_header), 8)) return (fdt_off_mem_rsvmap(fdt) < FDT_ALIGN(sizeof(struct fdt_header), 8))
|| (fdt_off_dt_struct(fdt) < || (fdt_off_dt_struct(fdt) <
(fdt_off_mem_rsvmap(fdt) + mem_rsv_size)) (fdt_off_mem_rsvmap(fdt) + mem_rsv_size))
|| (fdt_off_dt_strings(fdt) < || (fdt_off_dt_strings(fdt) <
@ -67,14 +67,14 @@ static int _blocks_misordered(const void *fdt,
(fdt_off_dt_strings(fdt) + fdt_size_dt_strings(fdt))); (fdt_off_dt_strings(fdt) + fdt_size_dt_strings(fdt)));
} }


static int rw_check_header(void *fdt) static int _fdt_rw_check_header(void *fdt)
{ {
CHECK_HEADER(fdt); FDT_CHECK_HEADER(fdt);


if (fdt_version(fdt) < 17) if (fdt_version(fdt) < 17)
return -FDT_ERR_BADVERSION; return -FDT_ERR_BADVERSION;
if (_blocks_misordered(fdt, sizeof(struct fdt_reserve_entry), if (_fdt_blocks_misordered(fdt, sizeof(struct fdt_reserve_entry),
fdt_size_dt_struct(fdt))) fdt_size_dt_struct(fdt)))
return -FDT_ERR_BADLAYOUT; return -FDT_ERR_BADLAYOUT;
if (fdt_version(fdt) > 17) if (fdt_version(fdt) > 17)
fdt_set_version(fdt, 17); fdt_set_version(fdt, 17);
@ -82,22 +82,22 @@ static int rw_check_header(void *fdt)
return 0; return 0;
} }


#define RW_CHECK_HEADER(fdt) \ #define FDT_RW_CHECK_HEADER(fdt) \
{ \ { \
int err; \ int err; \
if ((err = rw_check_header(fdt)) != 0) \ if ((err = _fdt_rw_check_header(fdt)) != 0) \
return err; \ return err; \
} }


static inline int _blob_data_size(void *fdt) static inline int _fdt_data_size(void *fdt)
{ {
return fdt_off_dt_strings(fdt) + fdt_size_dt_strings(fdt); return fdt_off_dt_strings(fdt) + fdt_size_dt_strings(fdt);
} }


static int _blob_splice(void *fdt, void *splicepoint, int oldlen, int newlen) static int _fdt_splice(void *fdt, void *splicepoint, int oldlen, int newlen)
{ {
char *p = splicepoint; char *p = splicepoint;
char *end = (char *)fdt + _blob_data_size(fdt); char *end = (char *)fdt + _fdt_data_size(fdt);


if (((p + oldlen) < p) || ((p + oldlen) > end)) if (((p + oldlen) < p) || ((p + oldlen) > end))
return -FDT_ERR_BADOFFSET; return -FDT_ERR_BADOFFSET;
@ -107,12 +107,12 @@ static int _blob_splice(void *fdt, void *splicepoint, int oldlen, int newlen)
return 0; return 0;
} }


static int _blob_splice_mem_rsv(void *fdt, struct fdt_reserve_entry *p, static int _fdt_splice_mem_rsv(void *fdt, struct fdt_reserve_entry *p,
int oldn, int newn) int oldn, int newn)
{ {
int delta = (newn - oldn) * sizeof(*p); int delta = (newn - oldn) * sizeof(*p);
int err; int err;
err = _blob_splice(fdt, p, oldn * sizeof(*p), newn * sizeof(*p)); err = _fdt_splice(fdt, p, oldn * sizeof(*p), newn * sizeof(*p));
if (err) if (err)
return err; return err;
fdt_set_off_dt_struct(fdt, fdt_off_dt_struct(fdt) + delta); fdt_set_off_dt_struct(fdt, fdt_off_dt_struct(fdt) + delta);
@ -120,13 +120,13 @@ static int _blob_splice_mem_rsv(void *fdt, struct fdt_reserve_entry *p,
return 0; return 0;
} }


static int _blob_splice_struct(void *fdt, void *p, static int _fdt_splice_struct(void *fdt, void *p,
int oldlen, int newlen) int oldlen, int newlen)
{ {
int delta = newlen - oldlen; int delta = newlen - oldlen;
int err; int err;


if ((err = _blob_splice(fdt, p, oldlen, newlen))) if ((err = _fdt_splice(fdt, p, oldlen, newlen)))
return err; return err;


fdt_set_size_dt_struct(fdt, fdt_size_dt_struct(fdt) + delta); fdt_set_size_dt_struct(fdt, fdt_size_dt_struct(fdt) + delta);
@ -134,20 +134,20 @@ static int _blob_splice_struct(void *fdt, void *p,
return 0; return 0;
} }


static int _blob_splice_string(void *fdt, int newlen) static int _fdt_splice_string(void *fdt, int newlen)
{ {
void *p = (char *)fdt void *p = (char *)fdt
+ fdt_off_dt_strings(fdt) + fdt_size_dt_strings(fdt); + fdt_off_dt_strings(fdt) + fdt_size_dt_strings(fdt);
int err; int err;


if ((err = _blob_splice(fdt, p, 0, newlen))) if ((err = _fdt_splice(fdt, p, 0, newlen)))
return err; return err;


fdt_set_size_dt_strings(fdt, fdt_size_dt_strings(fdt) + newlen); fdt_set_size_dt_strings(fdt, fdt_size_dt_strings(fdt) + newlen);
return 0; return 0;
} }


static int _find_add_string(void *fdt, const char *s) static int _fdt_find_add_string(void *fdt, const char *s)
{ {
char *strtab = (char *)fdt + fdt_off_dt_strings(fdt); char *strtab = (char *)fdt + fdt_off_dt_strings(fdt);
const char *p; const char *p;
@ -161,7 +161,7 @@ static int _find_add_string(void *fdt, const char *s)
return (p - strtab); return (p - strtab);


new = strtab + fdt_size_dt_strings(fdt); new = strtab + fdt_size_dt_strings(fdt);
err = _blob_splice_string(fdt, len); err = _fdt_splice_string(fdt, len);
if (err) if (err)
return err; return err;


@ -174,10 +174,10 @@ int fdt_add_mem_rsv(void *fdt, uint64_t address, uint64_t size)
struct fdt_reserve_entry *re; struct fdt_reserve_entry *re;
int err; int err;


RW_CHECK_HEADER(fdt); FDT_RW_CHECK_HEADER(fdt);


re = _fdt_mem_rsv_w(fdt, fdt_num_mem_rsv(fdt)); re = _fdt_mem_rsv_w(fdt, fdt_num_mem_rsv(fdt));
err = _blob_splice_mem_rsv(fdt, re, 0, 1); err = _fdt_splice_mem_rsv(fdt, re, 0, 1);
if (err) if (err)
return err; return err;


@ -191,19 +191,19 @@ int fdt_del_mem_rsv(void *fdt, int n)
struct fdt_reserve_entry *re = _fdt_mem_rsv_w(fdt, n); struct fdt_reserve_entry *re = _fdt_mem_rsv_w(fdt, n);
int err; int err;


RW_CHECK_HEADER(fdt); FDT_RW_CHECK_HEADER(fdt);


if (n >= fdt_num_mem_rsv(fdt)) if (n >= fdt_num_mem_rsv(fdt))
return -FDT_ERR_NOTFOUND; return -FDT_ERR_NOTFOUND;


err = _blob_splice_mem_rsv(fdt, re, 1, 0); err = _fdt_splice_mem_rsv(fdt, re, 1, 0);
if (err) if (err)
return err; return err;
return 0; return 0;
} }


static int _resize_property(void *fdt, int nodeoffset, const char *name, int len, static int _fdt_resize_property(void *fdt, int nodeoffset, const char *name,
struct fdt_property **prop) int len, struct fdt_property **prop)
{ {
int oldlen; int oldlen;
int err; int err;
@ -212,17 +212,16 @@ static int _resize_property(void *fdt, int nodeoffset, const char *name, int len
if (! (*prop)) if (! (*prop))
return oldlen; return oldlen;


if ((err = _blob_splice_struct(fdt, (*prop)->data, if ((err = _fdt_splice_struct(fdt, (*prop)->data, FDT_TAGALIGN(oldlen),
ALIGN(oldlen, FDT_TAGSIZE), FDT_TAGALIGN(len))))
ALIGN(len, FDT_TAGSIZE))))
return err; return err;


(*prop)->len = cpu_to_fdt32(len); (*prop)->len = cpu_to_fdt32(len);
return 0; return 0;
} }


static int _add_property(void *fdt, int nodeoffset, const char *name, int len, static int _fdt_add_property(void *fdt, int nodeoffset, const char *name,
struct fdt_property **prop) int len, struct fdt_property **prop)
{ {
int proplen; int proplen;
int nextoffset; int nextoffset;
@ -232,14 +231,14 @@ static int _add_property(void *fdt, int nodeoffset, const char *name, int len,
if ((nextoffset = _fdt_check_node_offset(fdt, nodeoffset)) < 0) if ((nextoffset = _fdt_check_node_offset(fdt, nodeoffset)) < 0)
return nextoffset; return nextoffset;


namestroff = _find_add_string(fdt, name); namestroff = _fdt_find_add_string(fdt, name);
if (namestroff < 0) if (namestroff < 0)
return namestroff; return namestroff;


*prop = _fdt_offset_ptr_w(fdt, nextoffset); *prop = _fdt_offset_ptr_w(fdt, nextoffset);
proplen = sizeof(**prop) + ALIGN(len, FDT_TAGSIZE); proplen = sizeof(**prop) + FDT_TAGALIGN(len);


err = _blob_splice_struct(fdt, *prop, 0, proplen); err = _fdt_splice_struct(fdt, *prop, 0, proplen);
if (err) if (err)
return err; return err;


@ -255,7 +254,7 @@ int fdt_set_name(void *fdt, int nodeoffset, const char *name)
int oldlen, newlen; int oldlen, newlen;
int err; int err;


RW_CHECK_HEADER(fdt); FDT_RW_CHECK_HEADER(fdt);


namep = (char *)(uintptr_t)fdt_get_name(fdt, nodeoffset, &oldlen); namep = (char *)(uintptr_t)fdt_get_name(fdt, nodeoffset, &oldlen);
if (!namep) if (!namep)
@ -263,8 +262,8 @@ int fdt_set_name(void *fdt, int nodeoffset, const char *name)


newlen = strlen(name); newlen = strlen(name);


err = _blob_splice_struct(fdt, namep, ALIGN(oldlen+1, FDT_TAGSIZE), err = _fdt_splice_struct(fdt, namep, FDT_TAGALIGN(oldlen+1),
ALIGN(newlen+1, FDT_TAGSIZE)); FDT_TAGALIGN(newlen+1));
if (err) if (err)
return err; return err;


@ -278,11 +277,11 @@ int fdt_setprop(void *fdt, int nodeoffset, const char *name,
struct fdt_property *prop; struct fdt_property *prop;
int err; int err;


RW_CHECK_HEADER(fdt); FDT_RW_CHECK_HEADER(fdt);


err = _resize_property(fdt, nodeoffset, name, len, &prop); err = _fdt_resize_property(fdt, nodeoffset, name, len, &prop);
if (err == -FDT_ERR_NOTFOUND) if (err == -FDT_ERR_NOTFOUND)
err = _add_property(fdt, nodeoffset, name, len, &prop); err = _fdt_add_property(fdt, nodeoffset, name, len, &prop);
if (err) if (err)
return err; return err;


@ -295,14 +294,14 @@ int fdt_delprop(void *fdt, int nodeoffset, const char *name)
struct fdt_property *prop; struct fdt_property *prop;
int len, proplen; int len, proplen;


RW_CHECK_HEADER(fdt); FDT_RW_CHECK_HEADER(fdt);


prop = fdt_get_property_w(fdt, nodeoffset, name, &len); prop = fdt_get_property_w(fdt, nodeoffset, name, &len);
if (! prop) if (! prop)
return len; return len;


proplen = sizeof(*prop) + ALIGN(len, FDT_TAGSIZE); proplen = sizeof(*prop) + FDT_TAGALIGN(len);
return _blob_splice_struct(fdt, prop, proplen, 0); return _fdt_splice_struct(fdt, prop, proplen, 0);
} }


int fdt_add_subnode_namelen(void *fdt, int parentoffset, int fdt_add_subnode_namelen(void *fdt, int parentoffset,
@ -315,7 +314,7 @@ int fdt_add_subnode_namelen(void *fdt, int parentoffset,
uint32_t tag; uint32_t tag;
uint32_t *endtag; uint32_t *endtag;


RW_CHECK_HEADER(fdt); FDT_RW_CHECK_HEADER(fdt);


offset = fdt_subnode_offset_namelen(fdt, parentoffset, name, namelen); offset = fdt_subnode_offset_namelen(fdt, parentoffset, name, namelen);
if (offset >= 0) if (offset >= 0)
@ -331,14 +330,14 @@ int fdt_add_subnode_namelen(void *fdt, int parentoffset,
} while ((tag == FDT_PROP) || (tag == FDT_NOP)); } while ((tag == FDT_PROP) || (tag == FDT_NOP));


nh = _fdt_offset_ptr_w(fdt, offset); nh = _fdt_offset_ptr_w(fdt, offset);
nodelen = sizeof(*nh) + ALIGN(namelen+1, FDT_TAGSIZE) + FDT_TAGSIZE; nodelen = sizeof(*nh) + FDT_TAGALIGN(namelen+1) + FDT_TAGSIZE;


err = _blob_splice_struct(fdt, nh, 0, nodelen); err = _fdt_splice_struct(fdt, nh, 0, nodelen);
if (err) if (err)
return err; return err;


nh->tag = cpu_to_fdt32(FDT_BEGIN_NODE); nh->tag = cpu_to_fdt32(FDT_BEGIN_NODE);
memset(nh->name, 0, ALIGN(namelen+1, FDT_TAGSIZE)); memset(nh->name, 0, FDT_TAGALIGN(namelen+1));
memcpy(nh->name, name, namelen); memcpy(nh->name, name, namelen);
endtag = (uint32_t *)((char *)nh + nodelen - FDT_TAGSIZE); endtag = (uint32_t *)((char *)nh + nodelen - FDT_TAGSIZE);
*endtag = cpu_to_fdt32(FDT_END_NODE); *endtag = cpu_to_fdt32(FDT_END_NODE);
@ -355,22 +354,22 @@ int fdt_del_node(void *fdt, int nodeoffset)
{ {
int endoffset; int endoffset;


RW_CHECK_HEADER(fdt); FDT_RW_CHECK_HEADER(fdt);


endoffset = _fdt_node_end_offset(fdt, nodeoffset); endoffset = _fdt_node_end_offset(fdt, nodeoffset);
if (endoffset < 0) if (endoffset < 0)
return endoffset; return endoffset;


return _blob_splice_struct(fdt, _fdt_offset_ptr_w(fdt, nodeoffset), return _fdt_splice_struct(fdt, _fdt_offset_ptr_w(fdt, nodeoffset),
endoffset - nodeoffset, 0); endoffset - nodeoffset, 0);
} }


static void _packblocks(const char *old, char *new, static void _fdt_packblocks(const char *old, char *new,
int mem_rsv_size, int struct_size) int mem_rsv_size, int struct_size)
{ {
int mem_rsv_off, struct_off, strings_off; int mem_rsv_off, struct_off, strings_off;


mem_rsv_off = ALIGN(sizeof(struct fdt_header), 8); mem_rsv_off = FDT_ALIGN(sizeof(struct fdt_header), 8);
struct_off = mem_rsv_off + mem_rsv_size; struct_off = mem_rsv_off + mem_rsv_size;
strings_off = struct_off + struct_size; strings_off = struct_off + struct_size;


@ -396,7 +395,7 @@ int fdt_open_into(const void *fdt, void *buf, int bufsize)
const char *fdtend = fdtstart + fdt_totalsize(fdt); const char *fdtend = fdtstart + fdt_totalsize(fdt);
char *tmp; char *tmp;


CHECK_HEADER(fdt); FDT_CHECK_HEADER(fdt);


mem_rsv_size = (fdt_num_mem_rsv(fdt)+1) mem_rsv_size = (fdt_num_mem_rsv(fdt)+1)
* sizeof(struct fdt_reserve_entry); * sizeof(struct fdt_reserve_entry);
@ -409,7 +408,7 @@ int fdt_open_into(const void *fdt, void *buf, int bufsize)
; ;
} }


if (!_blocks_misordered(fdt, mem_rsv_size, struct_size)) { if (!_fdt_blocks_misordered(fdt, mem_rsv_size, struct_size)) {
/* no further work necessary */ /* no further work necessary */
err = fdt_move(fdt, buf, bufsize); err = fdt_move(fdt, buf, bufsize);
if (err) if (err)
@ -421,7 +420,7 @@ int fdt_open_into(const void *fdt, void *buf, int bufsize)
} }


/* Need to reorder */ /* Need to reorder */
newsize = ALIGN(sizeof(struct fdt_header), 8) + mem_rsv_size newsize = FDT_ALIGN(sizeof(struct fdt_header), 8) + mem_rsv_size
+ struct_size + fdt_size_dt_strings(fdt); + struct_size + fdt_size_dt_strings(fdt);


if (bufsize < newsize) if (bufsize < newsize)
@ -437,7 +436,7 @@ int fdt_open_into(const void *fdt, void *buf, int bufsize)
return -FDT_ERR_NOSPACE; return -FDT_ERR_NOSPACE;
} }


_packblocks(fdt, tmp, mem_rsv_size, struct_size); _fdt_packblocks(fdt, tmp, mem_rsv_size, struct_size);
memmove(buf, tmp, newsize); memmove(buf, tmp, newsize);


fdt_set_magic(buf, FDT_MAGIC); fdt_set_magic(buf, FDT_MAGIC);
@ -453,12 +452,12 @@ int fdt_pack(void *fdt)
{ {
int mem_rsv_size; int mem_rsv_size;


RW_CHECK_HEADER(fdt); FDT_RW_CHECK_HEADER(fdt);


mem_rsv_size = (fdt_num_mem_rsv(fdt)+1) mem_rsv_size = (fdt_num_mem_rsv(fdt)+1)
* sizeof(struct fdt_reserve_entry); * sizeof(struct fdt_reserve_entry);
_packblocks(fdt, fdt, mem_rsv_size, fdt_size_dt_struct(fdt)); _fdt_packblocks(fdt, fdt, mem_rsv_size, fdt_size_dt_struct(fdt));
fdt_set_totalsize(fdt, _blob_data_size(fdt)); fdt_set_totalsize(fdt, _fdt_data_size(fdt));


return 0; return 0;
} }

34
libfdt/fdt_strerror.c
Unescape View File

@ -55,29 +55,29 @@


#include "libfdt_internal.h" #include "libfdt_internal.h"


struct errtabent { struct fdt_errtabent {
const char *str; const char *str;
}; };


#define ERRTABENT(val) \ #define FDT_ERRTABENT(val) \
[(val)] = { .str = #val, } [(val)] = { .str = #val, }


static struct errtabent errtable[] = { static struct fdt_errtabent fdt_errtable[] = {
ERRTABENT(FDT_ERR_NOTFOUND), FDT_ERRTABENT(FDT_ERR_NOTFOUND),
ERRTABENT(FDT_ERR_EXISTS), FDT_ERRTABENT(FDT_ERR_EXISTS),
ERRTABENT(FDT_ERR_NOSPACE), FDT_ERRTABENT(FDT_ERR_NOSPACE),


ERRTABENT(FDT_ERR_BADOFFSET), FDT_ERRTABENT(FDT_ERR_BADOFFSET),
ERRTABENT(FDT_ERR_BADPATH), FDT_ERRTABENT(FDT_ERR_BADPATH),
ERRTABENT(FDT_ERR_BADSTATE), FDT_ERRTABENT(FDT_ERR_BADSTATE),


ERRTABENT(FDT_ERR_TRUNCATED), FDT_ERRTABENT(FDT_ERR_TRUNCATED),
ERRTABENT(FDT_ERR_BADMAGIC), FDT_ERRTABENT(FDT_ERR_BADMAGIC),
ERRTABENT(FDT_ERR_BADVERSION), FDT_ERRTABENT(FDT_ERR_BADVERSION),
ERRTABENT(FDT_ERR_BADSTRUCTURE), FDT_ERRTABENT(FDT_ERR_BADSTRUCTURE),
ERRTABENT(FDT_ERR_BADLAYOUT), FDT_ERRTABENT(FDT_ERR_BADLAYOUT),
}; };
#define ERRTABSIZE (sizeof(errtable) / sizeof(errtable[0])) #define FDT_ERRTABSIZE (sizeof(fdt_errtable) / sizeof(fdt_errtable[0]))


const char *fdt_strerror(int errval) const char *fdt_strerror(int errval)
{ {
@ -85,8 +85,8 @@ const char *fdt_strerror(int errval)
return "<valid offset/length>"; return "<valid offset/length>";
else if (errval == 0) else if (errval == 0)
return "<no error>"; return "<no error>";
else if (errval > -ERRTABSIZE) { else if (errval > -FDT_ERRTABSIZE) {
const char *s = errtable[-errval].str; const char *s = fdt_errtable[-errval].str;


if (s) if (s)
return s; return s;

38
libfdt/fdt_sw.c
Unescape View File

@ -55,22 +55,22 @@


#include "libfdt_internal.h" #include "libfdt_internal.h"


static int sw_check_header(void *fdt) static int _fdt_sw_check_header(void *fdt)
{ {
if (fdt_magic(fdt) != SW_MAGIC) if (fdt_magic(fdt) != FDT_SW_MAGIC)
return -FDT_ERR_BADMAGIC; return -FDT_ERR_BADMAGIC;
/* FIXME: should check more details about the header state */ /* FIXME: should check more details about the header state */
return 0; return 0;
} }


#define SW_CHECK_HEADER(fdt) \ #define FDT_SW_CHECK_HEADER(fdt) \
{ \ { \
int err; \ int err; \
if ((err = sw_check_header(fdt)) != 0) \ if ((err = _fdt_sw_check_header(fdt)) != 0) \
return err; \ return err; \
} }


static void *grab_space(void *fdt, int len) static void *_fdt_grab_space(void *fdt, int len)
{ {
int offset = fdt_size_dt_struct(fdt); int offset = fdt_size_dt_struct(fdt);
int spaceleft; int spaceleft;
@ -94,13 +94,13 @@ int fdt_create(void *buf, int bufsize)


memset(buf, 0, bufsize); memset(buf, 0, bufsize);


fdt_set_magic(fdt, SW_MAGIC); fdt_set_magic(fdt, FDT_SW_MAGIC);
fdt_set_version(fdt, FDT_LAST_SUPPORTED_VERSION); fdt_set_version(fdt, FDT_LAST_SUPPORTED_VERSION);
fdt_set_last_comp_version(fdt, FDT_FIRST_SUPPORTED_VERSION); fdt_set_last_comp_version(fdt, FDT_FIRST_SUPPORTED_VERSION);
fdt_set_totalsize(fdt, bufsize); fdt_set_totalsize(fdt, bufsize);


fdt_set_off_mem_rsvmap(fdt, ALIGN(sizeof(struct fdt_header), fdt_set_off_mem_rsvmap(fdt, FDT_ALIGN(sizeof(struct fdt_header),
sizeof(struct fdt_reserve_entry))); sizeof(struct fdt_reserve_entry)));
fdt_set_off_dt_struct(fdt, fdt_off_mem_rsvmap(fdt)); fdt_set_off_dt_struct(fdt, fdt_off_mem_rsvmap(fdt));
fdt_set_off_dt_strings(fdt, bufsize); fdt_set_off_dt_strings(fdt, bufsize);


@ -112,7 +112,7 @@ int fdt_add_reservemap_entry(void *fdt, uint64_t addr, uint64_t size)
struct fdt_reserve_entry *re; struct fdt_reserve_entry *re;
int offset; int offset;


SW_CHECK_HEADER(fdt); FDT_SW_CHECK_HEADER(fdt);


if (fdt_size_dt_struct(fdt)) if (fdt_size_dt_struct(fdt))
return -FDT_ERR_BADSTATE; return -FDT_ERR_BADSTATE;
@ -140,9 +140,9 @@ int fdt_begin_node(void *fdt, const char *name)
struct fdt_node_header *nh; struct fdt_node_header *nh;
int namelen = strlen(name) + 1; int namelen = strlen(name) + 1;


SW_CHECK_HEADER(fdt); FDT_SW_CHECK_HEADER(fdt);


nh = grab_space(fdt, sizeof(*nh) + ALIGN(namelen, FDT_TAGSIZE)); nh = _fdt_grab_space(fdt, sizeof(*nh) + FDT_TAGALIGN(namelen));
if (! nh) if (! nh)
return -FDT_ERR_NOSPACE; return -FDT_ERR_NOSPACE;


@ -155,9 +155,9 @@ int fdt_end_node(void *fdt)
{ {
uint32_t *en; uint32_t *en;


SW_CHECK_HEADER(fdt); FDT_SW_CHECK_HEADER(fdt);


en = grab_space(fdt, FDT_TAGSIZE); en = _fdt_grab_space(fdt, FDT_TAGSIZE);
if (! en) if (! en)
return -FDT_ERR_NOSPACE; return -FDT_ERR_NOSPACE;


@ -165,7 +165,7 @@ int fdt_end_node(void *fdt)
return 0; return 0;
} }


static int find_add_string(void *fdt, const char *s) static int _fdt_find_add_string(void *fdt, const char *s)
{ {
char *strtab = (char *)fdt + fdt_totalsize(fdt); char *strtab = (char *)fdt + fdt_totalsize(fdt);
const char *p; const char *p;
@ -193,13 +193,13 @@ int fdt_property(void *fdt, const char *name, const void *val, int len)
struct fdt_property *prop; struct fdt_property *prop;
int nameoff; int nameoff;


SW_CHECK_HEADER(fdt); FDT_SW_CHECK_HEADER(fdt);


nameoff = find_add_string(fdt, name); nameoff = _fdt_find_add_string(fdt, name);
if (nameoff == 0) if (nameoff == 0)
return -FDT_ERR_NOSPACE; return -FDT_ERR_NOSPACE;


prop = grab_space(fdt, sizeof(*prop) + ALIGN(len, FDT_TAGSIZE)); prop = _fdt_grab_space(fdt, sizeof(*prop) + FDT_TAGALIGN(len));
if (! prop) if (! prop)
return -FDT_ERR_NOSPACE; return -FDT_ERR_NOSPACE;


@ -218,10 +218,10 @@ int fdt_finish(void *fdt)
uint32_t tag; uint32_t tag;
int offset, nextoffset; int offset, nextoffset;


SW_CHECK_HEADER(fdt); FDT_SW_CHECK_HEADER(fdt);


/* Add terminator */ /* Add terminator */
end = grab_space(fdt, sizeof(*end)); end = _fdt_grab_space(fdt, sizeof(*end));
if (! end) if (! end)
return -FDT_ERR_NOSPACE; return -FDT_ERR_NOSPACE;
*end = cpu_to_fdt32(FDT_END); *end = cpu_to_fdt32(FDT_END);

7
libfdt/fdt_wip.c
Unescape View File

@ -72,7 +72,7 @@ int fdt_setprop_inplace(void *fdt, int nodeoffset, const char *name,
return 0; return 0;
} }


static void nop_region(void *start, int len) static void _fdt_nop_region(void *start, int len)
{ {
uint32_t *p; uint32_t *p;


@ -89,7 +89,7 @@ int fdt_nop_property(void *fdt, int nodeoffset, const char *name)
if (! prop) if (! prop)
return len; return len;


nop_region(prop, len + sizeof(*prop)); _fdt_nop_region(prop, len + sizeof(*prop));


return 0; return 0;
} }
@ -139,6 +139,7 @@ int fdt_nop_node(void *fdt, int nodeoffset)
if (endoffset < 0) if (endoffset < 0)
return endoffset; return endoffset;


nop_region(fdt_offset_ptr_w(fdt, nodeoffset, 0), endoffset - nodeoffset); _fdt_nop_region(fdt_offset_ptr_w(fdt, nodeoffset, 0),
endoffset - nodeoffset);
return 0; return 0;
} }

11
libfdt/libfdt_internal.h
Unescape View File

@ -52,13 +52,10 @@
*/ */
#include <fdt.h> #include <fdt.h>


#define ALIGN(x, a) (((x) + (a) - 1) & ~((a) - 1)) #define FDT_ALIGN(x, a) (((x) + (a) - 1) & ~((a) - 1))
#define PALIGN(p, a) ((void *)ALIGN((unsigned long)(p), (a))) #define FDT_TAGALIGN(x) (FDT_ALIGN((x), FDT_TAGSIZE))


#define memeq(p, q, n) (memcmp((p), (q), (n)) == 0) #define FDT_CHECK_HEADER(fdt) \
#define streq(p, q) (strcmp((p), (q)) == 0)

#define CHECK_HEADER(fdt) \
{ \ { \
int err; \ int err; \
if ((err = fdt_check_header(fdt)) != 0) \ if ((err = fdt_check_header(fdt)) != 0) \
@ -93,6 +90,6 @@ static inline struct fdt_reserve_entry *_fdt_mem_rsv_w(void *fdt, int n)
return (void *)(uintptr_t)_fdt_mem_rsv(fdt, n); return (void *)(uintptr_t)_fdt_mem_rsv(fdt, n);
} }


#define SW_MAGIC (~FDT_MAGIC) #define FDT_SW_MAGIC (~FDT_MAGIC)


#endif /* _LIBFDT_INTERNAL_H */ #endif /* _LIBFDT_INTERNAL_H */

Write Preview
Loading…
Cancel
Save