scripts/dtc/libfdt/fdt_sw.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 static int fdt_sw_probe_(void *fdt)
  14 {
  15         if (!can_assume(VALID_INPUT)) {
  16                 if (fdt_magic(fdt) == FDT_MAGIC)
  17                         return -FDT_ERR_BADSTATE;
  18                 else if (fdt_magic(fdt) != FDT_SW_MAGIC)
  19                         return -FDT_ERR_BADMAGIC;
  20         }
  21
  22         return 0;
  23 }
  24
  25 #define FDT_SW_PROBE(fdt) \
  26         { \
  27                 int err; \
  28                 if ((err = fdt_sw_probe_(fdt)) != 0) \
  29                         return err; \
  30         }
  31
  32 /* 'memrsv' state:      Initial state after fdt_create()
  33  *
  34  * Allowed functions:
  35  *      fdt_add_reservemap_entry()
  36  *      fdt_finish_reservemap()         [moves to 'struct' state]
  37  */
  38 static int fdt_sw_probe_memrsv_(void *fdt)
  39 {
  40         int err = fdt_sw_probe_(fdt);
  41         if (err)
  42                 return err;
  43
  44         if (!can_assume(VALID_INPUT) && fdt_off_dt_strings(fdt) != 0)
  45                 return -FDT_ERR_BADSTATE;
  46         return 0;
  47 }
  48
  49 #define FDT_SW_PROBE_MEMRSV(fdt) \
  50         { \
  51                 int err; \
  52                 if ((err = fdt_sw_probe_memrsv_(fdt)) != 0) \
  53                         return err; \
  54         }
  55
  56 /* 'struct' state:      Enter this state after fdt_finish_reservemap()
  57  *
  58  * Allowed functions:
  59  *      fdt_begin_node()
  60  *      fdt_end_node()
  61  *      fdt_property*()
  62  *      fdt_finish()                    [moves to 'complete' state]
  63  */
  64 static int fdt_sw_probe_struct_(void *fdt)
  65 {
  66         int err = fdt_sw_probe_(fdt);
  67         if (err)
  68                 return err;
  69
  70         if (!can_assume(VALID_INPUT) &&
  71             fdt_off_dt_strings(fdt) != fdt_totalsize(fdt))
  72                 return -FDT_ERR_BADSTATE;
  73         return 0;
  74 }
  75
  76 #define FDT_SW_PROBE_STRUCT(fdt) \
  77         { \
  78                 int err; \
  79                 if ((err = fdt_sw_probe_struct_(fdt)) != 0) \
  80                         return err; \
  81         }
  82
  83 static inline uint32_t sw_flags(void *fdt)
  84 {
  85         /* assert: (fdt_magic(fdt) == FDT_SW_MAGIC) */
  86         return fdt_last_comp_version(fdt);
  87 }
  88
  89 /* 'complete' state:    Enter this state after fdt_finish()
  90  *
  91  * Allowed functions: none
  92  */
  93
  94 static void *fdt_grab_space_(void *fdt, size_t len)
  95 {
  96         int offset = fdt_size_dt_struct(fdt);
  97         int spaceleft;
  98
  99         spaceleft = fdt_totalsize(fdt) - fdt_off_dt_struct(fdt)
 100                 - fdt_size_dt_strings(fdt);
 101
 102         if ((offset + len < offset) || (offset + len > spaceleft))
 103                 return NULL;
 104
 105         fdt_set_size_dt_struct(fdt, offset + len);
 106         return fdt_offset_ptr_w_(fdt, offset);
 107 }
 108
 109 int fdt_create_with_flags(void *buf, int bufsize, uint32_t flags)
 110 {
 111         const size_t hdrsize = FDT_ALIGN(sizeof(struct fdt_header),
 112                                          sizeof(struct fdt_reserve_entry));
 113         void *fdt = buf;
 114
 115         if (bufsize < hdrsize)
 116                 return -FDT_ERR_NOSPACE;
 117
 118         if (flags & ~FDT_CREATE_FLAGS_ALL)
 119                 return -FDT_ERR_BADFLAGS;
 120
 121         memset(buf, 0, bufsize);
 122
 123         /*
 124          * magic and last_comp_version keep intermediate state during the fdt
 125          * creation process, which is replaced with the proper FDT format by
 126          * fdt_finish().
 127          *
 128          * flags should be accessed with sw_flags().
 129          */
 130         fdt_set_magic(fdt, FDT_SW_MAGIC);
 131         fdt_set_version(fdt, FDT_LAST_SUPPORTED_VERSION);
 132         fdt_set_last_comp_version(fdt, flags);
 133
 134         fdt_set_totalsize(fdt,  bufsize);
 135
 136         fdt_set_off_mem_rsvmap(fdt, hdrsize);
 137         fdt_set_off_dt_struct(fdt, fdt_off_mem_rsvmap(fdt));
 138         fdt_set_off_dt_strings(fdt, 0);
 139
 140         return 0;
 141 }
 142
 143 int fdt_create(void *buf, int bufsize)
 144 {
 145         return fdt_create_with_flags(buf, bufsize, 0);
 146 }
 147
 148 int fdt_resize(void *fdt, void *buf, int bufsize)
 149 {
 150         size_t headsize, tailsize;
 151         char *oldtail, *newtail;
 152
 153         FDT_SW_PROBE(fdt);
 154
 155         headsize = fdt_off_dt_struct(fdt) + fdt_size_dt_struct(fdt);
 156         tailsize = fdt_size_dt_strings(fdt);
 157
 158         if (!can_assume(VALID_DTB) &&
 159             headsize + tailsize > fdt_totalsize(fdt))
 160                 return -FDT_ERR_INTERNAL;
 161
 162         if ((headsize + tailsize) > bufsize)
 163                 return -FDT_ERR_NOSPACE;
 164
 165         oldtail = (char *)fdt + fdt_totalsize(fdt) - tailsize;
 166         newtail = (char *)buf + bufsize - tailsize;
 167
 168         /* Two cases to avoid clobbering data if the old and new
 169          * buffers partially overlap */
 170         if (buf <= fdt) {
 171                 memmove(buf, fdt, headsize);
 172                 memmove(newtail, oldtail, tailsize);
 173         } else {
 174                 memmove(newtail, oldtail, tailsize);
 175                 memmove(buf, fdt, headsize);
 176         }
 177
 178         fdt_set_totalsize(buf, bufsize);
 179         if (fdt_off_dt_strings(buf))
 180                 fdt_set_off_dt_strings(buf, bufsize);
 181
 182         return 0;
 183 }
 184
 185 int fdt_add_reservemap_entry(void *fdt, uint64_t addr, uint64_t size)
 186 {
 187         struct fdt_reserve_entry *re;
 188         int offset;
 189
 190         FDT_SW_PROBE_MEMRSV(fdt);
 191
 192         offset = fdt_off_dt_struct(fdt);
 193         if ((offset + sizeof(*re)) > fdt_totalsize(fdt))
 194                 return -FDT_ERR_NOSPACE;
 195
 196         re = (struct fdt_reserve_entry *)((char *)fdt + offset);
 197         re->address = cpu_to_fdt64(addr);
 198         re->size = cpu_to_fdt64(size);
 199
 200         fdt_set_off_dt_struct(fdt, offset + sizeof(*re));
 201
 202         return 0;
 203 }
 204
 205 int fdt_finish_reservemap(void *fdt)
 206 {
 207         int err = fdt_add_reservemap_entry(fdt, 0, 0);
 208
 209         if (err)
 210                 return err;
 211
 212         fdt_set_off_dt_strings(fdt, fdt_totalsize(fdt));
 213         return 0;
 214 }
 215
 216 int fdt_begin_node(void *fdt, const char *name)
 217 {
 218         struct fdt_node_header *nh;
 219         int namelen;
 220
 221         FDT_SW_PROBE_STRUCT(fdt);
 222
 223         namelen = strlen(name) + 1;
 224         nh = fdt_grab_space_(fdt, sizeof(*nh) + FDT_TAGALIGN(namelen));
 225         if (! nh)
 226                 return -FDT_ERR_NOSPACE;
 227
 228         nh->tag = cpu_to_fdt32(FDT_BEGIN_NODE);
 229         memcpy(nh->name, name, namelen);
 230         return 0;
 231 }
 232
 233 int fdt_end_node(void *fdt)
 234 {
 235         fdt32_t *en;
 236
 237         FDT_SW_PROBE_STRUCT(fdt);
 238
 239         en = fdt_grab_space_(fdt, FDT_TAGSIZE);
 240         if (! en)
 241                 return -FDT_ERR_NOSPACE;
 242
 243         *en = cpu_to_fdt32(FDT_END_NODE);
 244         return 0;
 245 }
 246
 247 static int fdt_add_string_(void *fdt, const char *s)
 248 {
 249         char *strtab = (char *)fdt + fdt_totalsize(fdt);
 250         int strtabsize = fdt_size_dt_strings(fdt);
 251         int len = strlen(s) + 1;
 252         int struct_top, offset;
 253
 254         offset = -strtabsize - len;
 255         struct_top = fdt_off_dt_struct(fdt) + fdt_size_dt_struct(fdt);
 256         if (fdt_totalsize(fdt) + offset < struct_top)
 257                 return 0; /* no more room :( */
 258
 259         memcpy(strtab + offset, s, len);
 260         fdt_set_size_dt_strings(fdt, strtabsize + len);
 261         return offset;
 262 }
 263
 264 /* Must only be used to roll back in case of error */
 265 static void fdt_del_last_string_(void *fdt, const char *s)
 266 {
 267         int strtabsize = fdt_size_dt_strings(fdt);
 268         int len = strlen(s) + 1;
 269
 270         fdt_set_size_dt_strings(fdt, strtabsize - len);
 271 }
 272
 273 static int fdt_find_add_string_(void *fdt, const char *s, int *allocated)
 274 {
 275         char *strtab = (char *)fdt + fdt_totalsize(fdt);
 276         int strtabsize = fdt_size_dt_strings(fdt);
 277         const char *p;
 278
 279         *allocated = 0;
 280
 281         p = fdt_find_string_(strtab - strtabsize, strtabsize, s);
 282         if (p)
 283                 return p - strtab;
 284
 285         *allocated = 1;
 286
 287         return fdt_add_string_(fdt, s);
 288 }
 289
 290 int fdt_property_placeholder(void *fdt, const char *name, int len, void **valp)
 291 {
 292         struct fdt_property *prop;
 293         int nameoff;
 294         int allocated;
 295
 296         FDT_SW_PROBE_STRUCT(fdt);
 297
 298         /* String de-duplication can be slow, _NO_NAME_DEDUP skips it */
 299         if (sw_flags(fdt) & FDT_CREATE_FLAG_NO_NAME_DEDUP) {
 300                 allocated = 1;
 301                 nameoff = fdt_add_string_(fdt, name);
 302         } else {
 303                 nameoff = fdt_find_add_string_(fdt, name, &allocated);
 304         }
 305         if (nameoff == 0)
 306                 return -FDT_ERR_NOSPACE;
 307
 308         prop = fdt_grab_space_(fdt, sizeof(*prop) + FDT_TAGALIGN(len));
 309         if (! prop) {
 310                 if (allocated)
 311                         fdt_del_last_string_(fdt, name);
 312                 return -FDT_ERR_NOSPACE;
 313         }
 314
 315         prop->tag = cpu_to_fdt32(FDT_PROP);
 316         prop->nameoff = cpu_to_fdt32(nameoff);
 317         prop->len = cpu_to_fdt32(len);
 318         *valp = prop->data;
 319         return 0;
 320 }
 321
 322 int fdt_property(void *fdt, const char *name, const void *val, int len)
 323 {
 324         void *ptr;
 325         int ret;
 326
 327         ret = fdt_property_placeholder(fdt, name, len, &ptr);
 328         if (ret)
 329                 return ret;
 330         memcpy(ptr, val, len);
 331         return 0;
 332 }
 333
 334 int fdt_finish(void *fdt)
 335 {
 336         char *p = (char *)fdt;
 337         fdt32_t *end;
 338         int oldstroffset, newstroffset;
 339         uint32_t tag;
 340         int offset, nextoffset;
 341
 342         FDT_SW_PROBE_STRUCT(fdt);
 343
 344         /* Add terminator */
 345         end = fdt_grab_space_(fdt, sizeof(*end));
 346         if (! end)
 347                 return -FDT_ERR_NOSPACE;
 348         *end = cpu_to_fdt32(FDT_END);
 349
 350         /* Relocate the string table */
 351         oldstroffset = fdt_totalsize(fdt) - fdt_size_dt_strings(fdt);
 352         newstroffset = fdt_off_dt_struct(fdt) + fdt_size_dt_struct(fdt);
 353         memmove(p + newstroffset, p + oldstroffset, fdt_size_dt_strings(fdt));
 354         fdt_set_off_dt_strings(fdt, newstroffset);
 355
 356         /* Walk the structure, correcting string offsets */
 357         offset = 0;
 358         while ((tag = fdt_next_tag(fdt, offset, &nextoffset)) != FDT_END) {
 359                 if (tag == FDT_PROP) {
 360                         struct fdt_property *prop =
 361                                 fdt_offset_ptr_w_(fdt, offset);
 362                         int nameoff;
 363
 364                         nameoff = fdt32_to_cpu(prop->nameoff);
 365                         nameoff += fdt_size_dt_strings(fdt);
 366                         prop->nameoff = cpu_to_fdt32(nameoff);
 367                 }
 368                 offset = nextoffset;
 369         }
 370         if (nextoffset < 0)
 371                 return nextoffset;
 372
 373         /* Finally, adjust the header */
 374         fdt_set_totalsize(fdt, newstroffset + fdt_size_dt_strings(fdt));
 375
 376         /* And fix up fields that were keeping intermediate state. */
 377         fdt_set_last_comp_version(fdt, FDT_FIRST_SUPPORTED_VERSION);
 378         fdt_set_magic(fdt, FDT_MAGIC);
 379
 380         return 0;
 381 }