D16653.1789944088.diff
No OneTemporary
Actions

Size

25 KB

Referenced Files

None

Subscribers

None

D16653.1789944088.diff
View Options

	Index: sys/contrib/libfdt/fdt.c
	===================================================================
	--- sys/contrib/libfdt/fdt.c
	+++ sys/contrib/libfdt/fdt.c
	@@ -55,7 +55,12 @@

	#include "libfdt_internal.h"

	-int fdt_check_header(const void *fdt)
	+/*
	+ * Minimal sanity check for a read-only tree. fdt_ro_probe_() checks
	+ * that the given buffer contains what appears to be a flattened
	+ * device tree with sane information in its header.
	+ */
	+int fdt_ro_probe_(const void *fdt)
	{
	if (fdt_magic(fdt) == FDT_MAGIC) {
	/* Complete tree */
	@@ -74,6 +79,78 @@
	return 0;
	}

	+static int check_off_(uint32_t hdrsize, uint32_t totalsize, uint32_t off)
	+{
	+ return (off >= hdrsize) && (off <= totalsize);
	+}
	+
	+static int check_block_(uint32_t hdrsize, uint32_t totalsize,
	+ uint32_t base, uint32_t size)
	+{
	+ if (!check_off_(hdrsize, totalsize, base))
	+ return 0; /* block start out of bounds */
	+ if ((base + size) < base)
	+ return 0; /* overflow */
	+ if (!check_off_(hdrsize, totalsize, base + size))
	+ return 0; /* block end out of bounds */
	+ return 1;
	+}
	+
	+size_t fdt_header_size_(uint32_t version)
	+{
	+ if (version <= 1)
	+ return FDT_V1_SIZE;
	+ else if (version <= 2)
	+ return FDT_V2_SIZE;
	+ else if (version <= 3)
	+ return FDT_V3_SIZE;
	+ else if (version <= 16)
	+ return FDT_V16_SIZE;
	+ else
	+ return FDT_V17_SIZE;
	+}
	+
	+int fdt_check_header(const void *fdt)
	+{
	+ size_t hdrsize;
	+
	+ if (fdt_magic(fdt) != FDT_MAGIC)
	+ return -FDT_ERR_BADMAGIC;
	+ hdrsize = fdt_header_size(fdt);
	+ if ((fdt_version(fdt) < FDT_FIRST_SUPPORTED_VERSION)
	+ \|\| (fdt_last_comp_version(fdt) > FDT_LAST_SUPPORTED_VERSION))
	+ return -FDT_ERR_BADVERSION;
	+ if (fdt_version(fdt) < fdt_last_comp_version(fdt))
	+ return -FDT_ERR_BADVERSION;
	+
	+ if ((fdt_totalsize(fdt) < hdrsize)
	+ \|\| (fdt_totalsize(fdt) > INT_MAX))
	+ return -FDT_ERR_TRUNCATED;
	+
	+ /* Bounds check memrsv block */
	+ if (!check_off_(hdrsize, fdt_totalsize(fdt), fdt_off_mem_rsvmap(fdt)))
	+ return -FDT_ERR_TRUNCATED;
	+
	+ /* Bounds check structure block */
	+ if (fdt_version(fdt) < 17) {
	+ if (!check_off_(hdrsize, fdt_totalsize(fdt),
	+ fdt_off_dt_struct(fdt)))
	+ return -FDT_ERR_TRUNCATED;
	+ } else {
	+ if (!check_block_(hdrsize, fdt_totalsize(fdt),
	+ fdt_off_dt_struct(fdt),
	+ fdt_size_dt_struct(fdt)))
	+ return -FDT_ERR_TRUNCATED;
	+ }
	+
	+ /* Bounds check strings block */
	+ if (!check_block_(hdrsize, fdt_totalsize(fdt),
	+ fdt_off_dt_strings(fdt), fdt_size_dt_strings(fdt)))
	+ return -FDT_ERR_TRUNCATED;
	+
	+ return 0;
	+}
	+
	const void fdt_offset_ptr(const void fdt, int offset, unsigned int len)
	{
	unsigned absoffset = offset + fdt_off_dt_struct(fdt);
	@@ -244,7 +321,7 @@

	int fdt_move(const void fdt, void buf, int bufsize)
	{
	- FDT_CHECK_HEADER(fdt);
	+ FDT_RO_PROBE(fdt);

	if (fdt_totalsize(fdt) > bufsize)
	return -FDT_ERR_NOSPACE;
	Index: sys/contrib/libfdt/fdt_addresses.c
	===================================================================
	--- sys/contrib/libfdt/fdt_addresses.c
	+++ sys/contrib/libfdt/fdt_addresses.c
	@@ -1,6 +1,7 @@
	/*
	* libfdt - Flat Device Tree manipulation
	* Copyright (C) 2014 David Gibson <david@gibson.dropbear.id.au>
	+ * Copyright (C) 2018 embedded brains GmbH
	*
	* libfdt is dual licensed: you can use it either under the terms of
	* the GPL, or the BSD license, at your option.
	@@ -55,42 +56,32 @@

	#include "libfdt_internal.h"

	-int fdt_address_cells(const void *fdt, int nodeoffset)
	+static int fdt_cells(const void fdt, int nodeoffset, const char name)
	{
	- const fdt32_t *ac;
	+ const fdt32_t *c;
	int val;
	int len;

	- ac = fdt_getprop(fdt, nodeoffset, "#address-cells", &len);
	- if (!ac)
	+ c = fdt_getprop(fdt, nodeoffset, name, &len);
	+ if (!c)
	return 2;

	- if (len != sizeof(*ac))
	+ if (len != sizeof(*c))
	return -FDT_ERR_BADNCELLS;

	- val = fdt32_to_cpu(*ac);
	+ val = fdt32_to_cpu(*c);
	if ((val <= 0) \|\| (val > FDT_MAX_NCELLS))
	return -FDT_ERR_BADNCELLS;

	return val;
	}

	-int fdt_size_cells(const void *fdt, int nodeoffset)
	+int fdt_address_cells(const void *fdt, int nodeoffset)
	{
	- const fdt32_t *sc;
	- int val;
	- int len;
	-
	- sc = fdt_getprop(fdt, nodeoffset, "#size-cells", &len);
	- if (!sc)
	- return 2;
	-
	- if (len != sizeof(*sc))
	- return -FDT_ERR_BADNCELLS;
	-
	- val = fdt32_to_cpu(*sc);
	- if ((val < 0) \|\| (val > FDT_MAX_NCELLS))
	- return -FDT_ERR_BADNCELLS;
	+ return fdt_cells(fdt, nodeoffset, "#address-cells");
	+}

	- return val;
	+int fdt_size_cells(const void *fdt, int nodeoffset)
	+{
	+ return fdt_cells(fdt, nodeoffset, "#size-cells");
	}
	Index: sys/contrib/libfdt/fdt_overlay.c
	===================================================================
	--- sys/contrib/libfdt/fdt_overlay.c
	+++ sys/contrib/libfdt/fdt_overlay.c
	@@ -697,7 +697,7 @@
	int len = 0, namelen;
	const char *name;

	- FDT_CHECK_HEADER(fdt);
	+ FDT_RO_PROBE(fdt);

	for (;;) {
	name = fdt_get_name(fdt, nodeoffset, &namelen);
	@@ -866,8 +866,8 @@
	uint32_t delta = fdt_get_max_phandle(fdt);
	int ret;

	- FDT_CHECK_HEADER(fdt);
	- FDT_CHECK_HEADER(fdto);
	+ FDT_RO_PROBE(fdt);
	+ FDT_RO_PROBE(fdto);

	ret = overlay_adjust_local_phandles(fdto, delta);
	if (ret)
	Index: sys/contrib/libfdt/fdt_ro.c
	===================================================================
	--- sys/contrib/libfdt/fdt_ro.c
	+++ sys/contrib/libfdt/fdt_ro.c
	@@ -76,17 +76,72 @@
	return 0;
	}

	+const char fdt_get_string(const void fdt, int stroffset, int *lenp)
	+{
	+ uint32_t absoffset = stroffset + fdt_off_dt_strings(fdt);
	+ size_t len;
	+ int err;
	+ const char s, n;
	+
	+ err = fdt_ro_probe_(fdt);
	+ if (err != 0)
	+ goto fail;
	+
	+ err = -FDT_ERR_BADOFFSET;
	+ if (absoffset >= fdt_totalsize(fdt))
	+ goto fail;
	+ len = fdt_totalsize(fdt) - absoffset;
	+
	+ if (fdt_magic(fdt) == FDT_MAGIC) {
	+ if (stroffset < 0)
	+ goto fail;
	+ if (fdt_version(fdt) >= 17) {
	+ if (stroffset >= fdt_size_dt_strings(fdt))
	+ goto fail;
	+ if ((fdt_size_dt_strings(fdt) - stroffset) < len)
	+ len = fdt_size_dt_strings(fdt) - stroffset;
	+ }
	+ } else if (fdt_magic(fdt) == FDT_SW_MAGIC) {
	+ if ((stroffset >= 0)
	+ \|\| (stroffset < -fdt_size_dt_strings(fdt)))
	+ goto fail;
	+ if ((-stroffset) < len)
	+ len = -stroffset;
	+ } else {
	+ err = -FDT_ERR_INTERNAL;
	+ goto fail;
	+ }
	+
	+ s = (const char *)fdt + absoffset;
	+ n = memchr(s, '\0', len);
	+ if (!n) {
	+ /* missing terminating NULL */
	+ err = -FDT_ERR_TRUNCATED;
	+ goto fail;
	+ }
	+
	+ if (lenp)
	+ *lenp = n - s;
	+ return s;
	+
	+fail:
	+ if (lenp)
	+ *lenp = err;
	+ return NULL;
	+}
	+
	const char fdt_string(const void fdt, int stroffset)
	{
	- return (const char *)fdt + fdt_off_dt_strings(fdt) + stroffset;
	+ return fdt_get_string(fdt, stroffset, NULL);
	}

	static int fdt_string_eq_(const void *fdt, int stroffset,
	const char *s, int len)
	{
	- const char *p = fdt_string(fdt, stroffset);
	+ int slen;
	+ const char *p = fdt_get_string(fdt, stroffset, &slen);

	- return (strlen(p) == len) && (memcmp(p, s, len) == 0);
	+ return p && (slen == len) && (memcmp(p, s, len) == 0);
	}

	uint32_t fdt_get_max_phandle(const void *fdt)
	@@ -115,21 +170,42 @@
	return 0;
	}

	+static const struct fdt_reserve_entry fdt_mem_rsv(const void fdt, int n)
	+{
	+ int offset = n * sizeof(struct fdt_reserve_entry);
	+ int absoffset = fdt_off_mem_rsvmap(fdt) + offset;
	+
	+ if (absoffset < fdt_off_mem_rsvmap(fdt))
	+ return NULL;
	+ if (absoffset > fdt_totalsize(fdt) - sizeof(struct fdt_reserve_entry))
	+ return NULL;
	+ return fdt_mem_rsv_(fdt, n);
	+}
	+
	int fdt_get_mem_rsv(const void fdt, int n, uint64_t address, uint64_t *size)
	{
	- FDT_CHECK_HEADER(fdt);
	- *address = fdt64_to_cpu(fdt_mem_rsv_(fdt, n)->address);
	- *size = fdt64_to_cpu(fdt_mem_rsv_(fdt, n)->size);
	+ const struct fdt_reserve_entry *re;
	+
	+ FDT_RO_PROBE(fdt);
	+ re = fdt_mem_rsv(fdt, n);
	+ if (!re)
	+ return -FDT_ERR_BADOFFSET;
	+
	+ *address = fdt64_ld(&re->address);
	+ *size = fdt64_ld(&re->size);
	return 0;
	}

	int fdt_num_mem_rsv(const void *fdt)
	{
	- int i = 0;
	+ int i;
	+ const struct fdt_reserve_entry *re;

	- while (fdt64_to_cpu(fdt_mem_rsv_(fdt, i)->size) != 0)
	- i++;
	- return i;
	+ for (i = 0; (re = fdt_mem_rsv(fdt, i)) != NULL; i++) {
	+ if (fdt64_ld(&re->size) == 0)
	+ return i;
	+ }
	+ return -FDT_ERR_TRUNCATED;
	}

	static int nextprop_(const void *fdt, int offset)
	@@ -161,7 +237,7 @@
	{
	int depth;

	- FDT_CHECK_HEADER(fdt);
	+ FDT_RO_PROBE(fdt);

	for (depth = 0;
	(offset >= 0) && (depth >= 0);
	@@ -187,7 +263,7 @@
	const char *p = path;
	int offset = 0;

	- FDT_CHECK_HEADER(fdt);
	+ FDT_RO_PROBE(fdt);

	/* see if we have an alias */
	if (*path != '/') {
	@@ -237,7 +313,7 @@
	const char *nameptr;
	int err;

	- if (((err = fdt_check_header(fdt)) != 0)
	+ if (((err = fdt_ro_probe_(fdt)) != 0)
	\|\| ((err = fdt_check_node_offset_(fdt, nodeoffset)) < 0))
	goto fail;

	@@ -303,7 +379,7 @@
	prop = fdt_offset_ptr_(fdt, offset);

	if (lenp)
	- *lenp = fdt32_to_cpu(prop->len);
	+ *lenp = fdt32_ld(&prop->len);

	return prop;
	}
	@@ -340,7 +416,7 @@
	offset = -FDT_ERR_INTERNAL;
	break;
	}
	- if (fdt_string_eq_(fdt, fdt32_to_cpu(prop->nameoff),
	+ if (fdt_string_eq_(fdt, fdt32_ld(&prop->nameoff),
	name, namelen)) {
	if (poffset)
	*poffset = offset;
	@@ -393,7 +469,7 @@

	/* Handle realignment */
	if (fdt_version(fdt) < 0x10 && (poffset + sizeof(*prop)) % 8 &&
	- fdt32_to_cpu(prop->len) >= 8)
	+ fdt32_ld(&prop->len) >= 8)
	return prop->data + 4;
	return prop->data;
	}
	@@ -406,12 +482,22 @@
	prop = fdt_get_property_by_offset_(fdt, offset, lenp);
	if (!prop)
	return NULL;
	- if (namep)
	- *namep = fdt_string(fdt, fdt32_to_cpu(prop->nameoff));
	+ if (namep) {
	+ const char *name;
	+ int namelen;
	+ name = fdt_get_string(fdt, fdt32_ld(&prop->nameoff),
	+ &namelen);
	+ if (!name) {
	+ if (lenp)
	+ *lenp = namelen;
	+ return NULL;
	+ }
	+ *namep = name;
	+ }

	/* Handle realignment */
	if (fdt_version(fdt) < 0x10 && (offset + sizeof(*prop)) % 8 &&
	- fdt32_to_cpu(prop->len) >= 8)
	+ fdt32_ld(&prop->len) >= 8)
	return prop->data + 4;
	return prop->data;
	}
	@@ -436,7 +522,7 @@
	return 0;
	}

	- return fdt32_to_cpu(*php);
	+ return fdt32_ld(php);
	}

	const char fdt_get_alias_namelen(const void fdt,
	@@ -462,7 +548,7 @@
	int offset, depth, namelen;
	const char *name;

	- FDT_CHECK_HEADER(fdt);
	+ FDT_RO_PROBE(fdt);

	if (buflen < 2)
	return -FDT_ERR_NOSPACE;
	@@ -514,7 +600,7 @@
	int offset, depth;
	int supernodeoffset = -FDT_ERR_INTERNAL;

	- FDT_CHECK_HEADER(fdt);
	+ FDT_RO_PROBE(fdt);

	if (supernodedepth < 0)
	return -FDT_ERR_NOTFOUND;
	@@ -573,7 +659,7 @@
	const void *val;
	int len;

	- FDT_CHECK_HEADER(fdt);
	+ FDT_RO_PROBE(fdt);

	/* FIXME: The algorithm here is pretty horrible: we scan each
	* property of a node in fdt_getprop(), then if that didn't
	@@ -599,7 +685,7 @@
	if ((phandle == 0) \|\| (phandle == -1))
	return -FDT_ERR_BADPHANDLE;

	- FDT_CHECK_HEADER(fdt);
	+ FDT_RO_PROBE(fdt);

	/* FIXME: The algorithm here is pretty horrible: we
	* potentially scan each property of a node in
	@@ -752,7 +838,7 @@
	{
	int offset, err;

	- FDT_CHECK_HEADER(fdt);
	+ FDT_RO_PROBE(fdt);

	/* FIXME: The algorithm here is pretty horrible: we scan each
	* property of a node in fdt_node_check_compatible(), then if
	@@ -771,3 +857,66 @@

	return offset; /* error from fdt_next_node() */
	}
	+
	+int fdt_check_full(const void *fdt, size_t bufsize)
	+{
	+ int err;
	+ int num_memrsv;
	+ int offset, nextoffset = 0;
	+ uint32_t tag;
	+ unsigned depth = 0;
	+ const void *prop;
	+ const char *propname;
	+
	+ if (bufsize < FDT_V1_SIZE)
	+ return -FDT_ERR_TRUNCATED;
	+ err = fdt_check_header(fdt);
	+ if (err != 0)
	+ return err;
	+ if (bufsize < fdt_totalsize(fdt))
	+ return -FDT_ERR_TRUNCATED;
	+
	+ num_memrsv = fdt_num_mem_rsv(fdt);
	+ if (num_memrsv < 0)
	+ return num_memrsv;
	+
	+ while (1) {
	+ offset = nextoffset;
	+ tag = fdt_next_tag(fdt, offset, &nextoffset);
	+
	+ if (nextoffset < 0)
	+ return nextoffset;
	+
	+ switch (tag) {
	+ case FDT_NOP:
	+ break;
	+
	+ case FDT_END:
	+ if (depth != 0)
	+ return -FDT_ERR_BADSTRUCTURE;
	+ return 0;
	+
	+ case FDT_BEGIN_NODE:
	+ depth++;
	+ if (depth > INT_MAX)
	+ return -FDT_ERR_BADSTRUCTURE;
	+ break;
	+
	+ case FDT_END_NODE:
	+ if (depth == 0)
	+ return -FDT_ERR_BADSTRUCTURE;
	+ depth--;
	+ break;
	+
	+ case FDT_PROP:
	+ prop = fdt_getprop_by_offset(fdt, offset, &propname,
	+ &err);
	+ if (!prop)
	+ return err;
	+ break;
	+
	+ default:
	+ return -FDT_ERR_INTERNAL;
	+ }
	+ }
	+}
	Index: sys/contrib/libfdt/fdt_rw.c
	===================================================================
	--- sys/contrib/libfdt/fdt_rw.c
	+++ sys/contrib/libfdt/fdt_rw.c
	@@ -67,9 +67,9 @@
	(fdt_off_dt_strings(fdt) + fdt_size_dt_strings(fdt)));
	}

	-static int fdt_rw_check_header_(void *fdt)
	+static int fdt_rw_probe_(void *fdt)
	{
	- FDT_CHECK_HEADER(fdt);
	+ FDT_RO_PROBE(fdt);

	if (fdt_version(fdt) < 17)
	return -FDT_ERR_BADVERSION;
	@@ -82,10 +82,10 @@
	return 0;
	}

	-#define FDT_RW_CHECK_HEADER(fdt) \
	+#define FDT_RW_PROBE(fdt) \
	{ \
	int err_; \
	- if ((err_ = fdt_rw_check_header_(fdt)) != 0) \
	+ if ((err_ = fdt_rw_probe_(fdt)) != 0) \
	return err_; \
	}

	@@ -176,7 +176,7 @@
	struct fdt_reserve_entry *re;
	int err;

	- FDT_RW_CHECK_HEADER(fdt);
	+ FDT_RW_PROBE(fdt);

	re = fdt_mem_rsv_w_(fdt, fdt_num_mem_rsv(fdt));
	err = fdt_splice_mem_rsv_(fdt, re, 0, 1);
	@@ -192,7 +192,7 @@
	{
	struct fdt_reserve_entry *re = fdt_mem_rsv_w_(fdt, n);

	- FDT_RW_CHECK_HEADER(fdt);
	+ FDT_RW_PROBE(fdt);

	if (n >= fdt_num_mem_rsv(fdt))
	return -FDT_ERR_NOTFOUND;
	@@ -252,7 +252,7 @@
	int oldlen, newlen;
	int err;

	- FDT_RW_CHECK_HEADER(fdt);
	+ FDT_RW_PROBE(fdt);

	namep = (char *)(uintptr_t)fdt_get_name(fdt, nodeoffset, &oldlen);
	if (!namep)
	@@ -275,7 +275,7 @@
	struct fdt_property *prop;
	int err;

	- FDT_RW_CHECK_HEADER(fdt);
	+ FDT_RW_PROBE(fdt);

	err = fdt_resize_property_(fdt, nodeoffset, name, len, &prop);
	if (err == -FDT_ERR_NOTFOUND)
	@@ -308,7 +308,7 @@
	struct fdt_property *prop;
	int err, oldlen, newlen;

	- FDT_RW_CHECK_HEADER(fdt);
	+ FDT_RW_PROBE(fdt);

	prop = fdt_get_property_w(fdt, nodeoffset, name, &oldlen);
	if (prop) {
	@@ -334,7 +334,7 @@
	struct fdt_property *prop;
	int len, proplen;

	- FDT_RW_CHECK_HEADER(fdt);
	+ FDT_RW_PROBE(fdt);

	prop = fdt_get_property_w(fdt, nodeoffset, name, &len);
	if (!prop)
	@@ -354,7 +354,7 @@
	uint32_t tag;
	fdt32_t *endtag;

	- FDT_RW_CHECK_HEADER(fdt);
	+ FDT_RW_PROBE(fdt);

	offset = fdt_subnode_offset_namelen(fdt, parentoffset, name, namelen);
	if (offset >= 0)
	@@ -394,7 +394,7 @@
	{
	int endoffset;

	- FDT_RW_CHECK_HEADER(fdt);
	+ FDT_RW_PROBE(fdt);

	endoffset = fdt_node_end_offset_(fdt, nodeoffset);
	if (endoffset < 0)
	@@ -435,7 +435,7 @@
	const char *fdtend = fdtstart + fdt_totalsize(fdt);
	char *tmp;

	- FDT_CHECK_HEADER(fdt);
	+ FDT_RO_PROBE(fdt);

	mem_rsv_size = (fdt_num_mem_rsv(fdt)+1)
	* sizeof(struct fdt_reserve_entry);
	@@ -494,7 +494,7 @@
	{
	int mem_rsv_size;

	- FDT_RW_CHECK_HEADER(fdt);
	+ FDT_RW_PROBE(fdt);

	mem_rsv_size = (fdt_num_mem_rsv(fdt)+1)
	* sizeof(struct fdt_reserve_entry);
	Index: sys/contrib/libfdt/fdt_sw.c
	===================================================================
	--- sys/contrib/libfdt/fdt_sw.c
	+++ sys/contrib/libfdt/fdt_sw.c
	@@ -55,21 +55,77 @@

	#include "libfdt_internal.h"

	-static int fdt_sw_check_header_(void *fdt)
	+static int fdt_sw_probe_(void *fdt)
	{
	- if (fdt_magic(fdt) != FDT_SW_MAGIC)
	+ if (fdt_magic(fdt) == FDT_MAGIC)
	+ return -FDT_ERR_BADSTATE;
	+ else if (fdt_magic(fdt) != FDT_SW_MAGIC)
	return -FDT_ERR_BADMAGIC;
	- /* FIXME: should check more details about the header state */
	return 0;
	}

	-#define FDT_SW_CHECK_HEADER(fdt) \
	+#define FDT_SW_PROBE(fdt) \
	+ { \
	+ int err; \
	+ if ((err = fdt_sw_probe_(fdt)) != 0) \
	+ return err; \
	+ }
	+
	+/* 'memrsv' state: Initial state after fdt_create()
	+ *
	+ * Allowed functions:
	+ * fdt_add_reservmap_entry()
	+ * fdt_finish_reservemap() [moves to 'struct' state]
	+ */
	+static int fdt_sw_probe_memrsv_(void *fdt)
	+{
	+ int err = fdt_sw_probe_(fdt);
	+ if (err)
	+ return err;
	+
	+ if (fdt_off_dt_strings(fdt) != 0)
	+ return -FDT_ERR_BADSTATE;
	+ return 0;
	+}
	+
	+#define FDT_SW_PROBE_MEMRSV(fdt) \
	+ { \
	+ int err; \
	+ if ((err = fdt_sw_probe_memrsv_(fdt)) != 0) \
	+ return err; \
	+ }
	+
	+/* 'struct' state: Enter this state after fdt_finish_reservemap()
	+ *
	+ * Allowed functions:
	+ * fdt_begin_node()
	+ * fdt_end_node()
	+ * fdt_property*()
	+ * fdt_finish() [moves to 'complete' state]
	+ */
	+static int fdt_sw_probe_struct_(void *fdt)
	+{
	+ int err = fdt_sw_probe_(fdt);
	+ if (err)
	+ return err;
	+
	+ if (fdt_off_dt_strings(fdt) != fdt_totalsize(fdt))
	+ return -FDT_ERR_BADSTATE;
	+ return 0;
	+}
	+
	+#define FDT_SW_PROBE_STRUCT(fdt) \
	{ \
	int err; \
	- if ((err = fdt_sw_check_header_(fdt)) != 0) \
	+ if ((err = fdt_sw_probe_struct_(fdt)) != 0) \
	return err; \
	}

	+/* 'complete' state: Enter this state after fdt_finish()
	+ *
	+ * Allowed functions: none
	+ */
	+
	static void fdt_grab_space_(void fdt, size_t len)
	{
	int offset = fdt_size_dt_struct(fdt);
	@@ -87,9 +143,11 @@

	int fdt_create(void *buf, int bufsize)
	{
	+ const size_t hdrsize = FDT_ALIGN(sizeof(struct fdt_header),
	+ sizeof(struct fdt_reserve_entry));
	void *fdt = buf;

	- if (bufsize < sizeof(struct fdt_header))
	+ if (bufsize < hdrsize)
	return -FDT_ERR_NOSPACE;

	memset(buf, 0, bufsize);
	@@ -99,10 +157,9 @@
	fdt_set_last_comp_version(fdt, FDT_FIRST_SUPPORTED_VERSION);
	fdt_set_totalsize(fdt, bufsize);

	- fdt_set_off_mem_rsvmap(fdt, FDT_ALIGN(sizeof(struct fdt_header),
	- sizeof(struct fdt_reserve_entry)));
	+ fdt_set_off_mem_rsvmap(fdt, hdrsize);
	fdt_set_off_dt_struct(fdt, fdt_off_mem_rsvmap(fdt));
	- fdt_set_off_dt_strings(fdt, bufsize);
	+ fdt_set_off_dt_strings(fdt, 0);

	return 0;
	}
	@@ -112,11 +169,14 @@
	size_t headsize, tailsize;
	char oldtail, newtail;

	- FDT_SW_CHECK_HEADER(fdt);
	+ FDT_SW_PROBE(fdt);

	- headsize = fdt_off_dt_struct(fdt);
	+ headsize = fdt_off_dt_struct(fdt) + fdt_size_dt_struct(fdt);
	tailsize = fdt_size_dt_strings(fdt);

	+ if ((headsize + tailsize) > fdt_totalsize(fdt))
	+ return -FDT_ERR_INTERNAL;
	+
	if ((headsize + tailsize) > bufsize)
	return -FDT_ERR_NOSPACE;

	@@ -133,8 +193,9 @@
	memmove(buf, fdt, headsize);
	}

	- fdt_set_off_dt_strings(buf, bufsize);
	fdt_set_totalsize(buf, bufsize);
	+ if (fdt_off_dt_strings(buf))
	+ fdt_set_off_dt_strings(buf, bufsize);

	return 0;
	}
	@@ -144,10 +205,7 @@
	struct fdt_reserve_entry *re;
	int offset;

	- FDT_SW_CHECK_HEADER(fdt);
	-
	- if (fdt_size_dt_struct(fdt))
	- return -FDT_ERR_BADSTATE;
	+ FDT_SW_PROBE_MEMRSV(fdt);

	offset = fdt_off_dt_struct(fdt);
	if ((offset + sizeof(*re)) > fdt_totalsize(fdt))
	@@ -164,16 +222,23 @@

	int fdt_finish_reservemap(void *fdt)
	{
	- return fdt_add_reservemap_entry(fdt, 0, 0);
	+ int err = fdt_add_reservemap_entry(fdt, 0, 0);
	+
	+ if (err)
	+ return err;
	+
	+ fdt_set_off_dt_strings(fdt, fdt_totalsize(fdt));
	+ return 0;
	}

	int fdt_begin_node(void fdt, const char name)
	{
	struct fdt_node_header *nh;
	- int namelen = strlen(name) + 1;
	+ int namelen;

	- FDT_SW_CHECK_HEADER(fdt);
	+ FDT_SW_PROBE_STRUCT(fdt);

	+ namelen = strlen(name) + 1;
	nh = fdt_grab_space_(fdt, sizeof(*nh) + FDT_TAGALIGN(namelen));
	if (! nh)
	return -FDT_ERR_NOSPACE;
	@@ -187,7 +252,7 @@
	{
	fdt32_t *en;

	- FDT_SW_CHECK_HEADER(fdt);
	+ FDT_SW_PROBE_STRUCT(fdt);

	en = fdt_grab_space_(fdt, FDT_TAGSIZE);
	if (! en)
	@@ -225,7 +290,7 @@
	struct fdt_property *prop;
	int nameoff;

	- FDT_SW_CHECK_HEADER(fdt);
	+ FDT_SW_PROBE_STRUCT(fdt);

	nameoff = fdt_find_add_string_(fdt, name);
	if (nameoff == 0)
	@@ -262,7 +327,7 @@
	uint32_t tag;
	int offset, nextoffset;

	- FDT_SW_CHECK_HEADER(fdt);
	+ FDT_SW_PROBE_STRUCT(fdt);

	/* Add terminator */
	end = fdt_grab_space_(fdt, sizeof(*end));
	Index: sys/contrib/libfdt/libfdt.h
	===================================================================
	--- sys/contrib/libfdt/libfdt.h
	+++ sys/contrib/libfdt/libfdt.h
	@@ -90,8 +90,9 @@

	/* Error codes: codes for bad device tree blobs */
	#define FDT_ERR_TRUNCATED 8
	- /* FDT_ERR_TRUNCATED: Structure block of the given device tree
	- * ends without an FDT_END tag. */
	+ /* FDT_ERR_TRUNCATED: FDT or a sub-block is improperly
	+ * terminated (overflows, goes outside allowed bounds, or
	+ * isn't properly terminated). */
	#define FDT_ERR_BADMAGIC 9
	/* FDT_ERR_BADMAGIC: Given "device tree" appears not to be a
	* device tree at all - it is missing the flattened device
	@@ -153,6 +154,29 @@

	uint32_t fdt_next_tag(const void fdt, int offset, int nextoffset);

	+/*
	+ * Alignment helpers:
	+ * These helpers access words from a device tree blob. They're
	+ * built to work even with unaligned pointers on platforms (ike
	+ * ARM) that don't like unaligned loads and stores
	+ */
	+
	+static inline uint32_t fdt32_ld(const fdt32_t *p)
	+{
	+ fdt32_t v;
	+
	+ memcpy(&v, p, sizeof(v));
	+ return fdt32_to_cpu(v);
	+}
	+
	+static inline uint64_t fdt64_ld(const fdt64_t *p)
	+{
	+ fdt64_t v;
	+
	+ memcpy(&v, p, sizeof(v));
	+ return fdt64_to_cpu(v);
	+}
	+
	/**********************************************************************/
	/* Traversal functions */
	/**********************************************************************/
	@@ -213,7 +237,7 @@
	/* General functions */
	/**********************************************************************/
	#define fdt_get_header(fdt, field) \
	- (fdt32_to_cpu(((const struct fdt_header *)(fdt))->field))
	+ (fdt32_ld(&((const struct fdt_header *)(fdt))->field))
	#define fdt_magic(fdt) (fdt_get_header(fdt, magic))
	#define fdt_totalsize(fdt) (fdt_get_header(fdt, totalsize))
	#define fdt_off_dt_struct(fdt) (fdt_get_header(fdt, off_dt_struct))
	@@ -244,18 +268,31 @@
	#undef fdt_set_hdr_

	/**
	- * fdt_check_header - sanity check a device tree or possible device tree
	+ * fdt_header_size - return the size of the tree's header
	+ * @fdt: pointer to a flattened device tree
	+ */
	+size_t fdt_header_size_(uint32_t version);
	+static inline size_t fdt_header_size(const void *fdt)
	+{
	+ return fdt_header_size_(fdt_version(fdt));
	+}
	+
	+/**
	+ * fdt_check_header - sanity check a device tree header
	+
	* @fdt: pointer to data which might be a flattened device tree
	*
	* fdt_check_header() checks that the given buffer contains what
	- * appears to be a flattened device tree with sane information in its
	- * header.
	+ * appears to be a flattened device tree, and that the header contains
	+ * valid information (to the extent that can be determined from the
	+ * header alone).
	*
	* returns:
	* 0, if the buffer appears to contain a valid device tree
	* -FDT_ERR_BADMAGIC,
	* -FDT_ERR_BADVERSION,
	- * -FDT_ERR_BADSTATE, standard meanings, as above
	+ * -FDT_ERR_BADSTATE,
	+ * -FDT_ERR_TRUNCATED, standard meanings, as above
	*/
	int fdt_check_header(const void *fdt);

	@@ -284,6 +321,24 @@
	/* Read-only functions */
	/**********************************************************************/

	+int fdt_check_full(const void *fdt, size_t bufsize);
	+
	+/**
	+ * fdt_get_string - retrieve a string from the strings block of a device tree
	+ * @fdt: pointer to the device tree blob
	+ * @stroffset: offset of the string within the strings block (native endian)
	+ * @lenp: optional pointer to return the string's length
	+ *
	+ * fdt_get_string() retrieves a pointer to a single string from the
	+ * strings block of the device tree blob at fdt, and optionally also
	+ * returns the string's length in *lenp.
	+ *
	+ * returns:
	+ * a pointer to the string, on success
	+ * NULL, if stroffset is out of bounds, or doesn't point to a valid string
	+ */
	+const char fdt_get_string(const void fdt, int stroffset, int *lenp);
	+
	/**
	* fdt_string - retrieve a string from the strings block of a device tree
	* @fdt: pointer to the device tree blob
	@@ -294,7 +349,7 @@
	*
	* returns:
	* a pointer to the string, on success
	- * NULL, if stroffset is out of bounds
	+ * NULL, if stroffset is out of bounds, or doesn't point to a valid string
	*/
	const char fdt_string(const void fdt, int stroffset);

	@@ -1090,7 +1145,7 @@
	*
	* returns:
	* 0 <= n < FDT_MAX_NCELLS, on success
	- * 2, if the node has no #address-cells property
	+ * 2, if the node has no #size-cells property
	* -FDT_ERR_BADNCELLS, if the node has a badly formatted or invalid
	* #size-cells property
	* -FDT_ERR_BADMAGIC,
	@@ -1313,10 +1368,13 @@
	fdt64_t tmp = cpu_to_fdt64(val);
	return fdt_property(fdt, name, &tmp, sizeof(tmp));
	}
	+
	+#ifndef SWIG /* Not available in Python */
	static inline int fdt_property_cell(void fdt, const char name, uint32_t val)
	{
	return fdt_property_u32(fdt, name, val);
	}
	+#endif

	/**
	* fdt_property_placeholder - add a new property and return a ptr to its value
	Index: sys/contrib/libfdt/libfdt_env.h
	===================================================================
	--- sys/contrib/libfdt/libfdt_env.h
	+++ sys/contrib/libfdt/libfdt_env.h
	@@ -58,11 +58,13 @@
	#include <sys/types.h>
	#include <sys/systm.h>
	#include <sys/stdint.h>
	+#include <sys/limits.h>
	#else
	#include <stddef.h>
	#include <stdint.h>
	#include <stdlib.h>
	#include <string.h>
	+#include <limits.h>
	#endif

	#ifdef __CHECKER__
	Index: sys/contrib/libfdt/libfdt_internal.h
	===================================================================
	--- sys/contrib/libfdt/libfdt_internal.h
	+++ sys/contrib/libfdt/libfdt_internal.h
	@@ -55,10 +55,11 @@
	#define FDT_ALIGN(x, a) (((x) + (a) - 1) & ~((a) - 1))
	#define FDT_TAGALIGN(x) (FDT_ALIGN((x), FDT_TAGSIZE))

	-#define FDT_CHECK_HEADER(fdt) \
	+int fdt_ro_probe_(const void *fdt);
	+#define FDT_RO_PROBE(fdt) \
	{ \
	int err_; \
	- if ((err_ = fdt_check_header(fdt)) != 0) \
	+ if ((err_ = fdt_ro_probe_(fdt)) != 0) \
	return err_; \
	}

File Metadata

Mime Type: text/plain
Expires: Sun, Sep 20, 10:41 PM (18 h, 32 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 29827231
Default Alt Text: D16653.1789944088.diff (25 KB)

D16653.1789944088.diffNo OneTemporaryActions

D16653.1789944088.diffView Options

File Metadata

Event Timeline

D16653.1789944088.diff
No OneTemporary
Actions

D16653.1789944088.diff
View Options