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