1 /* 2 * (C) Copyright David Gibson <dwg@au1.ibm.com>, IBM Corporation. 2005. 3 * 4 * 5 * This program is free software; you can redistribute it and/or 6 * modify it under the terms of the GNU General Public License as 7 * published by the Free Software Foundation; either version 2 of the 8 * License, or (at your option) any later version. 9 * 10 * This program is distributed in the hope that it will be useful, 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 13 * General Public License for more details. 14 * 15 * You should have received a copy of the GNU General Public License 16 * along with this program; if not, write to the Free Software 17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 18 * USA 19 */ 20 21 #include "dtc.h" 22 23 void data_free(struct data d) 24 { 25 struct marker *m, *nm; 26 27 m = d.markers; 28 while (m) { 29 nm = m->next; 30 free(m->ref); 31 free(m); 32 m = nm; 33 } 34 35 if (d.val) 36 free(d.val); 37 } 38 39 struct data data_grow_for(struct data d, int xlen) 40 { 41 struct data nd; 42 int newsize; 43 44 if (xlen == 0) 45 return d; 46 47 nd = d; 48 49 newsize = xlen; 50 51 while ((d.len + xlen) > newsize) 52 newsize *= 2; 53 54 nd.val = xrealloc(d.val, newsize); 55 56 return nd; 57 } 58 59 struct data data_copy_mem(const char *mem, int len) 60 { 61 struct data d; 62 63 d = data_grow_for(empty_data, len); 64 65 d.len = len; 66 memcpy(d.val, mem, len); 67 68 return d; 69 } 70 71 struct data data_copy_escape_string(const char *s, int len) 72 { 73 int i = 0; 74 struct data d; 75 char *q; 76 77 d = data_add_marker(empty_data, TYPE_STRING, NULL); 78 d = data_grow_for(d, len + 1); 79 80 q = d.val; 81 while (i < len) { 82 char c = s[i++]; 83 84 if (c == '\\') 85 c = get_escape_char(s, &i); 86 87 q[d.len++] = c; 88 } 89 90 q[d.len++] = '\0'; 91 return d; 92 } 93 94 struct data data_copy_file(FILE *f, size_t maxlen) 95 { 96 struct data d = empty_data; 97 98 d = data_add_marker(d, TYPE_NONE, NULL); 99 while (!feof(f) && (d.len < maxlen)) { 100 size_t chunksize, ret; 101 102 if (maxlen == -1) 103 chunksize = 4096; 104 else 105 chunksize = maxlen - d.len; 106 107 d = data_grow_for(d, chunksize); 108 ret = fread(d.val + d.len, 1, chunksize, f); 109 110 if (ferror(f)) 111 die("Error reading file into data: %s", strerror(errno)); 112 113 if (d.len + ret < d.len) 114 die("Overflow reading file into data\n"); 115 116 d.len += ret; 117 } 118 119 return d; 120 } 121 122 struct data data_append_data(struct data d, const void *p, int len) 123 { 124 d = data_grow_for(d, len); 125 memcpy(d.val + d.len, p, len); 126 d.len += len; 127 return d; 128 } 129 130 struct data data_insert_at_marker(struct data d, struct marker *m, 131 const void *p, int len) 132 { 133 d = data_grow_for(d, len); 134 memmove(d.val + m->offset + len, d.val + m->offset, d.len - m->offset); 135 memcpy(d.val + m->offset, p, len); 136 d.len += len; 137 138 /* Adjust all markers after the one we're inserting at */ 139 m = m->next; 140 for_each_marker(m) 141 m->offset += len; 142 return d; 143 } 144 145 static struct data data_append_markers(struct data d, struct marker *m) 146 { 147 struct marker **mp = &d.markers; 148 149 /* Find the end of the markerlist */ 150 while (*mp) 151 mp = &((*mp)->next); 152 *mp = m; 153 return d; 154 } 155 156 struct data data_merge(struct data d1, struct data d2) 157 { 158 struct data d; 159 struct marker *m2 = d2.markers; 160 161 d = data_append_markers(data_append_data(d1, d2.val, d2.len), m2); 162 163 /* Adjust for the length of d1 */ 164 for_each_marker(m2) 165 m2->offset += d1.len; 166 167 d2.markers = NULL; /* So data_free() doesn't clobber them */ 168 data_free(d2); 169 170 return d; 171 } 172 173 struct data data_append_integer(struct data d, uint64_t value, int bits) 174 { 175 uint8_t value_8; 176 fdt16_t value_16; 177 fdt32_t value_32; 178 fdt64_t value_64; 179 180 switch (bits) { 181 case 8: 182 value_8 = value; 183 return data_append_data(d, &value_8, 1); 184 185 case 16: 186 value_16 = cpu_to_fdt16(value); 187 return data_append_data(d, &value_16, 2); 188 189 case 32: 190 value_32 = cpu_to_fdt32(value); 191 return data_append_data(d, &value_32, 4); 192 193 case 64: 194 value_64 = cpu_to_fdt64(value); 195 return data_append_data(d, &value_64, 8); 196 197 default: 198 die("Invalid literal size (%d)\n", bits); 199 } 200 } 201 202 struct data data_append_re(struct data d, uint64_t address, uint64_t size) 203 { 204 struct fdt_reserve_entry re; 205 206 re.address = cpu_to_fdt64(address); 207 re.size = cpu_to_fdt64(size); 208 209 return data_append_data(d, &re, sizeof(re)); 210 } 211 212 struct data data_append_cell(struct data d, cell_t word) 213 { 214 return data_append_integer(d, word, sizeof(word) * 8); 215 } 216 217 struct data data_append_addr(struct data d, uint64_t addr) 218 { 219 return data_append_integer(d, addr, sizeof(addr) * 8); 220 } 221 222 struct data data_append_byte(struct data d, uint8_t byte) 223 { 224 return data_append_data(d, &byte, 1); 225 } 226 227 struct data data_append_zeroes(struct data d, int len) 228 { 229 d = data_grow_for(d, len); 230 231 memset(d.val + d.len, 0, len); 232 d.len += len; 233 return d; 234 } 235 236 struct data data_append_align(struct data d, int align) 237 { 238 int newlen = ALIGN(d.len, align); 239 return data_append_zeroes(d, newlen - d.len); 240 } 241 242 struct data data_add_marker(struct data d, enum markertype type, char *ref) 243 { 244 struct marker *m; 245 246 m = xmalloc(sizeof(*m)); 247 m->offset = d.len; 248 m->type = type; 249 m->ref = ref; 250 m->next = NULL; 251 252 return data_append_markers(d, m); 253 } 254 255 bool data_is_one_string(struct data d) 256 { 257 int i; 258 int len = d.len; 259 260 if (len == 0) 261 return false; 262 263 for (i = 0; i < len-1; i++) 264 if (d.val[i] == '\0') 265 return false; 266 267 if (d.val[len-1] != '\0') 268 return false; 269 270 return true; 271 } 272