scripts/dtc/libfdt/fdt.c

   1 // SPDX-License-Identifier: (GPL-2.0-or-later OR BSD-2-Clause)
   2 /*
   3  * libfdt - Flat Device Tree manipulation
   4  * Copyright (C) 2006 David Gibson, IBM Corporation.
   5  */
   6 #include "libfdt_env.h"
   7
   8 #include <fdt.h>
   9 #include <libfdt.h>
  10
  11 #include "libfdt_internal.h"
  12
  13 /*
  14  * Minimal sanity check for a read-only tree. fdt_ro_probe_() checks
  15  * that the given buffer contains what appears to be a flattened
  16  * device tree with sane information in its header.
  17  */
  18 int32_t fdt_ro_probe_(const void *fdt)
  19 {
  20         uint32_t totalsize = fdt_totalsize(fdt);
  21
  22         if (can_assume(VALID_DTB))
  23                 return totalsize;
  24
  25         /* The device tree must be at an 8-byte aligned address */
  26         if ((uintptr_t)fdt & 7)
  27                 return -FDT_ERR_ALIGNMENT;
  28
  29         if (fdt_magic(fdt) == FDT_MAGIC) {
  30                 /* Complete tree */
  31                 if (!can_assume(LATEST)) {
  32                         if (fdt_version(fdt) < FDT_FIRST_SUPPORTED_VERSION)
  33                                 return -FDT_ERR_BADVERSION;
  34                         if (fdt_last_comp_version(fdt) >
  35                                         FDT_LAST_SUPPORTED_VERSION)
  36                                 return -FDT_ERR_BADVERSION;
  37                 }
  38         } else if (fdt_magic(fdt) == FDT_SW_MAGIC) {
  39                 /* Unfinished sequential-write blob */
  40                 if (!can_assume(VALID_INPUT) && fdt_size_dt_struct(fdt) == 0)
  41                         return -FDT_ERR_BADSTATE;
  42         } else {
  43                 return -FDT_ERR_BADMAGIC;
  44         }
  45
  46         if (totalsize < INT32_MAX)
  47                 return totalsize;
  48         else
  49                 return -FDT_ERR_TRUNCATED;
  50 }
  51
  52 static int check_off_(uint32_t hdrsize, uint32_t totalsize, uint32_t off)
  53 {
  54         return (off >= hdrsize) && (off <= totalsize);
  55 }
  56
  57 static int check_block_(uint32_t hdrsize, uint32_t totalsize,
  58                         uint32_t base, uint32_t size)
  59 {
  60         if (!check_off_(hdrsize, totalsize, base))
  61                 return 0; /* block start out of bounds */
  62         if ((base + size) < base)
  63                 return 0; /* overflow */
  64         if (!check_off_(hdrsize, totalsize, base + size))
  65                 return 0; /* block end out of bounds */
  66         return 1;
  67 }
  68
  69 size_t fdt_header_size_(uint32_t version)
  70 {
  71         if (version <= 1)
  72                 return FDT_V1_SIZE;
  73         else if (version <= 2)
  74                 return FDT_V2_SIZE;
  75         else if (version <= 3)
  76                 return FDT_V3_SIZE;
  77         else if (version <= 16)
  78                 return FDT_V16_SIZE;
  79         else
  80                 return FDT_V17_SIZE;
  81 }
  82
  83 size_t fdt_header_size(const void *fdt)
  84 {
  85         return can_assume(LATEST) ? FDT_V17_SIZE :
  86                 fdt_header_size_(fdt_version(fdt));
  87 }
  88
  89 int fdt_check_header(const void *fdt)
  90 {
  91         size_t hdrsize;
  92
  93         /* The device tree must be at an 8-byte aligned address */
  94         if ((uintptr_t)fdt & 7)
  95                 return -FDT_ERR_ALIGNMENT;
  96
  97         if (fdt_magic(fdt) != FDT_MAGIC)
  98                 return -FDT_ERR_BADMAGIC;
  99         if (!can_assume(LATEST)) {
 100                 if ((fdt_version(fdt) < FDT_FIRST_SUPPORTED_VERSION)
 101                     || (fdt_last_comp_version(fdt) >
 102                         FDT_LAST_SUPPORTED_VERSION))
 103                         return -FDT_ERR_BADVERSION;
 104                 if (fdt_version(fdt) < fdt_last_comp_version(fdt))
 105                         return -FDT_ERR_BADVERSION;
 106         }
 107         hdrsize = fdt_header_size(fdt);
 108         if (!can_assume(VALID_DTB)) {
 109
 110                 if ((fdt_totalsize(fdt) < hdrsize)
 111                     || (fdt_totalsize(fdt) > INT_MAX))
 112                         return -FDT_ERR_TRUNCATED;
 113
 114                 /* Bounds check memrsv block */
 115                 if (!check_off_(hdrsize, fdt_totalsize(fdt),
 116                                 fdt_off_mem_rsvmap(fdt)))
 117                         return -FDT_ERR_TRUNCATED;
 118         }
 119
 120         if (!can_assume(VALID_DTB)) {
 121                 /* Bounds check structure block */
 122                 if (!can_assume(LATEST) && fdt_version(fdt) < 17) {
 123                         if (!check_off_(hdrsize, fdt_totalsize(fdt),
 124                                         fdt_off_dt_struct(fdt)))
 125                                 return -FDT_ERR_TRUNCATED;
 126                 } else {
 127                         if (!check_block_(hdrsize, fdt_totalsize(fdt),
 128                                           fdt_off_dt_struct(fdt),
 129                                           fdt_size_dt_struct(fdt)))
 130                                 return -FDT_ERR_TRUNCATED;
 131                 }
 132
 133                 /* Bounds check strings block */
 134                 if (!check_block_(hdrsize, fdt_totalsize(fdt),
 135                                   fdt_off_dt_strings(fdt),
 136                                   fdt_size_dt_strings(fdt)))
 137                         return -FDT_ERR_TRUNCATED;
 138         }
 139
 140         return 0;
 141 }
 142
 143 const void *fdt_offset_ptr(const void *fdt, int offset, unsigned int len)
 144 {
 145         unsigned int uoffset = offset;
 146         unsigned int absoffset = offset + fdt_off_dt_struct(fdt);
 147
 148         if (offset < 0)
 149                 return NULL;
 150
 151         if (!can_assume(VALID_INPUT))
 152                 if ((absoffset < uoffset)
 153                     || ((absoffset + len) < absoffset)
 154                     || (absoffset + len) > fdt_totalsize(fdt))
 155                         return NULL;
 156
 157         if (can_assume(LATEST) || fdt_version(fdt) >= 0x11)
 158                 if (((uoffset + len) < uoffset)
 159                     || ((offset + len) > fdt_size_dt_struct(fdt)))
 160                         return NULL;
 161
 162         return fdt_offset_ptr_(fdt, offset);
 163 }
 164
 165 uint32_t fdt_next_tag(const void *fdt, int startoffset, int *nextoffset)
 166 {
 167         const fdt32_t *tagp, *lenp;
 168         uint32_t tag;
 169         int offset = startoffset;
 170         const char *p;
 171
 172         *nextoffset = -FDT_ERR_TRUNCATED;
 173         tagp = fdt_offset_ptr(fdt, offset, FDT_TAGSIZE);
 174         if (!can_assume(VALID_DTB) && !tagp)
 175                 return FDT_END; /* premature end */
 176         tag = fdt32_to_cpu(*tagp);
 177         offset += FDT_TAGSIZE;
 178
 179         *nextoffset = -FDT_ERR_BADSTRUCTURE;
 180         switch (tag) {
 181         case FDT_BEGIN_NODE:
 182                 /* skip name */
 183                 do {
 184                         p = fdt_offset_ptr(fdt, offset++, 1);
 185                 } while (p && (*p != '\0'));
 186                 if (!can_assume(VALID_DTB) && !p)
 187                         return FDT_END; /* premature end */
 188                 break;
 189
 190         case FDT_PROP:
 191                 lenp = fdt_offset_ptr(fdt, offset, sizeof(*lenp));
 192                 if (!can_assume(VALID_DTB) && !lenp)
 193                         return FDT_END; /* premature end */
 194                 /* skip-name offset, length and value */
 195                 offset += sizeof(struct fdt_property) - FDT_TAGSIZE
 196                         + fdt32_to_cpu(*lenp);
 197                 if (!can_assume(LATEST) &&
 198                     fdt_version(fdt) < 0x10 && fdt32_to_cpu(*lenp) >= 8 &&
 199                     ((offset - fdt32_to_cpu(*lenp)) % 8) != 0)
 200                         offset += 4;
 201                 break;
 202
 203         case FDT_END:
 204         case FDT_END_NODE:
 205         case FDT_NOP:
 206                 break;
 207
 208         default:
 209                 return FDT_END;
 210         }
 211
 212         if (!fdt_offset_ptr(fdt, startoffset, offset - startoffset))
 213                 return FDT_END; /* premature end */
 214
 215         *nextoffset = FDT_TAGALIGN(offset);
 216         return tag;
 217 }
 218
 219 int fdt_check_node_offset_(const void *fdt, int offset)
 220 {
 221         if (!can_assume(VALID_INPUT)
 222             && ((offset < 0) || (offset % FDT_TAGSIZE)))
 223                 return -FDT_ERR_BADOFFSET;
 224
 225         if (fdt_next_tag(fdt, offset, &offset) != FDT_BEGIN_NODE)
 226                 return -FDT_ERR_BADOFFSET;
 227
 228         return offset;
 229 }
 230
 231 int fdt_check_prop_offset_(const void *fdt, int offset)
 232 {
 233         if (!can_assume(VALID_INPUT)
 234             && ((offset < 0) || (offset % FDT_TAGSIZE)))
 235                 return -FDT_ERR_BADOFFSET;
 236
 237         if (fdt_next_tag(fdt, offset, &offset) != FDT_PROP)
 238                 return -FDT_ERR_BADOFFSET;
 239
 240         return offset;
 241 }
 242
 243 int fdt_next_node(const void *fdt, int offset, int *depth)
 244 {
 245         int nextoffset = 0;
 246         uint32_t tag;
 247
 248         if (offset >= 0)
 249                 if ((nextoffset = fdt_check_node_offset_(fdt, offset)) < 0)
 250                         return nextoffset;
 251
 252         do {
 253                 offset = nextoffset;
 254                 tag = fdt_next_tag(fdt, offset, &nextoffset);
 255
 256                 switch (tag) {
 257                 case FDT_PROP:
 258                 case FDT_NOP:
 259                         break;
 260
 261                 case FDT_BEGIN_NODE:
 262                         if (depth)
 263                                 (*depth)++;
 264                         break;
 265
 266                 case FDT_END_NODE:
 267                         if (depth && ((--(*depth)) < 0))
 268                                 return nextoffset;
 269                         break;
 270
 271                 case FDT_END:
 272                         if ((nextoffset >= 0)
 273                             || ((nextoffset == -FDT_ERR_TRUNCATED) && !depth))
 274                                 return -FDT_ERR_NOTFOUND;
 275                         else
 276                                 return nextoffset;
 277                 }
 278         } while (tag != FDT_BEGIN_NODE);
 279
 280         return offset;
 281 }
 282
 283 int fdt_first_subnode(const void *fdt, int offset)
 284 {
 285         int depth = 0;
 286
 287         offset = fdt_next_node(fdt, offset, &depth);
 288         if (offset < 0 || depth != 1)
 289                 return -FDT_ERR_NOTFOUND;
 290
 291         return offset;
 292 }
 293
 294 int fdt_next_subnode(const void *fdt, int offset)
 295 {
 296         int depth = 1;
 297
 298         /*
 299          * With respect to the parent, the depth of the next subnode will be
 300          * the same as the last.
 301          */
 302         do {
 303                 offset = fdt_next_node(fdt, offset, &depth);
 304                 if (offset < 0 || depth < 1)
 305                         return -FDT_ERR_NOTFOUND;
 306         } while (depth > 1);
 307
 308         return offset;
 309 }
 310
 311 const char *fdt_find_string_(const char *strtab, int tabsize, const char *s)
 312 {
 313         int len = strlen(s) + 1;
 314         const char *last = strtab + tabsize - len;
 315         const char *p;
 316
 317         for (p = strtab; p <= last; p++)
 318                 if (memcmp(p, s, len) == 0)
 319                         return p;
 320         return NULL;
 321 }
 322
 323 int fdt_move(const void *fdt, void *buf, int bufsize)
 324 {
 325         if (!can_assume(VALID_INPUT) && bufsize < 0)
 326                 return -FDT_ERR_NOSPACE;
 327
 328         FDT_RO_PROBE(fdt);
 329
 330         if (fdt_totalsize(fdt) > (unsigned int)bufsize)
 331                 return -FDT_ERR_NOSPACE;
 332
 333         memmove(buf, fdt, fdt_totalsize(fdt));
 334         return 0;
 335 }