xref: /linux/scripts/dtc/data.c (revision d0034a7a4ac7fae708146ac0059b9c47a1543f0d)
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  
data_free(struct data d)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(m->ref);
16  		free(m);
17  		m = nm;
18  	}
19  
20  	if (d.val)
21  		free(d.val);
22  }
23  
data_grow_for(struct data d,unsigned int xlen)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(d.val, newsize);
40  
41  	return nd;
42  }
43  
data_copy_mem(const char * mem,int len)44  struct data data_copy_mem(const char *mem, int len)
45  {
46  	struct data d;
47  
48  	d = data_grow_for(empty_data, len);
49  
50  	d.len = len;
51  	memcpy(d.val, mem, len);
52  
53  	return d;
54  }
55  
data_copy_escape_string(const char * s,int len)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_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  
data_copy_file(FILE * f,size_t maxlen)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_NONE, NULL);
84  	while (!feof(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, chunksize);
93  		ret = fread(d.val + d.len, 1, chunksize, f);
94  
95  		if (ferror(f))
96  			die("Error reading file into data: %s", strerror(errno));
97  
98  		if (d.len + ret < d.len)
99  			die("Overflow reading file into data\n");
100  
101  		d.len += ret;
102  	}
103  
104  	return d;
105  }
106  
data_append_data(struct data d,const void * p,int len)107  struct data data_append_data(struct data d, const void *p, int len)
108  {
109  	d = data_grow_for(d, len);
110  	memcpy(d.val + d.len, p, len);
111  	d.len += len;
112  	return d;
113  }
114  
data_insert_at_marker(struct data d,struct marker * m,const void * p,int len)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, len);
119  	memmove(d.val + m->offset + len, d.val + m->offset, d.len - m->offset);
120  	memcpy(d.val + m->offset, p, 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  
data_append_markers(struct data d,struct marker * m)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  
data_merge(struct data d1,struct data d2)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(data_append_data(d1, d2.val, d2.len), 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(d2);
154  
155  	return d;
156  }
157  
data_append_integer(struct data d,uint64_t value,int bits)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, &value_8, 1);
169  
170  	case 16:
171  		value_16 = cpu_to_fdt16(value);
172  		return data_append_data(d, &value_16, 2);
173  
174  	case 32:
175  		value_32 = cpu_to_fdt32(value);
176  		return data_append_data(d, &value_32, 4);
177  
178  	case 64:
179  		value_64 = cpu_to_fdt64(value);
180  		return data_append_data(d, &value_64, 8);
181  
182  	default:
183  		die("Invalid literal size (%d)\n", bits);
184  	}
185  }
186  
data_append_re(struct data d,uint64_t address,uint64_t size)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, &re, sizeof(re));
195  }
196  
data_append_cell(struct data d,cell_t word)197  struct data data_append_cell(struct data d, cell_t word)
198  {
199  	return data_append_integer(d, word, sizeof(word) * 8);
200  }
201  
data_append_addr(struct data d,uint64_t addr)202  struct data data_append_addr(struct data d, uint64_t addr)
203  {
204  	return data_append_integer(d, addr, sizeof(addr) * 8);
205  }
206  
data_append_byte(struct data d,uint8_t byte)207  struct data data_append_byte(struct data d, uint8_t byte)
208  {
209  	return data_append_data(d, &byte, 1);
210  }
211  
data_append_zeroes(struct data d,int len)212  struct data data_append_zeroes(struct data d, int len)
213  {
214  	d = data_grow_for(d, len);
215  
216  	memset(d.val + d.len, 0, len);
217  	d.len += len;
218  	return d;
219  }
220  
data_append_align(struct data d,int align)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, newlen - d.len);
225  }
226  
data_add_marker(struct data d,enum markertype type,char * ref)227  struct data data_add_marker(struct data d, enum markertype type, char *ref)
228  {
229  	struct marker *m;
230  
231  	m = xmalloc(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  
data_is_one_string(struct data d)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