/src/qemu/fsdev/9p-iov-marshal.c
Line | Count | Source |
1 | | /* |
2 | | * 9p backend |
3 | | * |
4 | | * Copyright IBM, Corp. 2010 |
5 | | * |
6 | | * Authors: |
7 | | * Anthony Liguori <aliguori@us.ibm.com> |
8 | | * |
9 | | * This work is licensed under the terms of the GNU GPL, version 2. See |
10 | | * the COPYING file in the top-level directory. |
11 | | * |
12 | | */ |
13 | | |
14 | | #include "qemu/osdep.h" |
15 | | #include <glib/gprintf.h> |
16 | | #include <utime.h> |
17 | | |
18 | | #include "9p-iov-marshal.h" |
19 | | #include "qemu/bswap.h" |
20 | | |
21 | | static ssize_t v9fs_packunpack(void *addr, struct iovec *sg, int sg_count, |
22 | | size_t offset, size_t size, int pack) |
23 | 1.88M | { |
24 | 1.88M | int i = 0; |
25 | 1.88M | size_t copied = 0; |
26 | 1.88M | size_t req_size = size; |
27 | | |
28 | | |
29 | 3.73M | for (i = 0; size && i < sg_count; i++) { |
30 | 1.85M | size_t len; |
31 | 1.85M | if (offset >= sg[i].iov_len) { |
32 | | /* skip this sg */ |
33 | 6.48k | offset -= sg[i].iov_len; |
34 | 6.48k | continue; |
35 | 1.84M | } else { |
36 | 1.84M | len = MIN(sg[i].iov_len - offset, size); |
37 | 1.84M | if (pack) { |
38 | 963k | memcpy(sg[i].iov_base + offset, addr, len); |
39 | 963k | } else { |
40 | 880k | memcpy(addr, sg[i].iov_base + offset, len); |
41 | 880k | } |
42 | 1.84M | size -= len; |
43 | 1.84M | copied += len; |
44 | 1.84M | addr += len; |
45 | 1.84M | if (size) { |
46 | 6.80k | offset = 0; |
47 | 6.80k | continue; |
48 | 6.80k | } |
49 | 1.84M | } |
50 | 1.85M | } |
51 | 1.88M | if (copied < req_size) { |
52 | | /* |
53 | | * We copied less that requested size. error out |
54 | | */ |
55 | 6.58k | return -ENOBUFS; |
56 | 6.58k | } |
57 | 1.87M | return copied; |
58 | 1.88M | } |
59 | | |
60 | | static ssize_t v9fs_unpack(void *dst, struct iovec *out_sg, int out_num, |
61 | | size_t offset, size_t size) |
62 | 920k | { |
63 | 920k | return v9fs_packunpack(dst, out_sg, out_num, offset, size, 0); |
64 | 920k | } |
65 | | |
66 | | ssize_t v9fs_pack(struct iovec *in_sg, int in_num, size_t offset, |
67 | | const void *src, size_t size) |
68 | 962k | { |
69 | 962k | return v9fs_packunpack((void *)src, in_sg, in_num, offset, size, 1); |
70 | 962k | } |
71 | | |
72 | | ssize_t v9fs_iov_vunmarshal(struct iovec *out_sg, int out_num, size_t offset, |
73 | | int bswap, const char *fmt, va_list ap) |
74 | 351k | { |
75 | 351k | int i; |
76 | 351k | ssize_t copied = 0; |
77 | 351k | size_t old_offset = offset; |
78 | | |
79 | 1.29M | for (i = 0; fmt[i]; i++) { |
80 | 945k | switch (fmt[i]) { |
81 | 3.99k | case 'b': { |
82 | 3.99k | uint8_t *valp = va_arg(ap, uint8_t *); |
83 | 3.99k | copied = v9fs_unpack(valp, out_sg, out_num, offset, sizeof(*valp)); |
84 | 3.99k | break; |
85 | 0 | } |
86 | 211k | case 'w': { |
87 | 211k | uint16_t val = 0, *valp; |
88 | 211k | valp = va_arg(ap, uint16_t *); |
89 | 211k | copied = v9fs_unpack(&val, out_sg, out_num, offset, sizeof(val)); |
90 | 211k | if (copied <= 0) { |
91 | 658 | break; |
92 | 658 | } |
93 | 210k | if (bswap) { |
94 | 210k | *valp = le16_to_cpu(val); |
95 | 210k | } else { |
96 | 0 | *valp = val; |
97 | 0 | } |
98 | 210k | break; |
99 | 211k | } |
100 | 402k | case 'd': { |
101 | 402k | uint32_t val = 0, *valp; |
102 | 402k | valp = va_arg(ap, uint32_t *); |
103 | 402k | copied = v9fs_unpack(&val, out_sg, out_num, offset, sizeof(val)); |
104 | 402k | if (copied <= 0) { |
105 | 1.02k | break; |
106 | 1.02k | } |
107 | 401k | if (bswap) { |
108 | 401k | *valp = le32_to_cpu(val); |
109 | 401k | } else { |
110 | 0 | *valp = val; |
111 | 0 | } |
112 | 401k | break; |
113 | 402k | } |
114 | 102k | case 'q': { |
115 | 102k | uint64_t val = 0, *valp; |
116 | 102k | valp = va_arg(ap, uint64_t *); |
117 | 102k | copied = v9fs_unpack(&val, out_sg, out_num, offset, sizeof(val)); |
118 | 102k | if (copied <= 0) { |
119 | 72 | break; |
120 | 72 | } |
121 | 102k | if (bswap) { |
122 | 102k | *valp = le64_to_cpu(val); |
123 | 102k | } else { |
124 | 0 | *valp = val; |
125 | 0 | } |
126 | 102k | break; |
127 | 102k | } |
128 | 199k | case 's': { |
129 | 199k | V9fsString *str = va_arg(ap, V9fsString *); |
130 | 199k | copied = v9fs_iov_unmarshal(out_sg, out_num, offset, bswap, |
131 | 199k | "w", &str->size); |
132 | 199k | if (copied > 0) { |
133 | 199k | offset += copied; |
134 | 199k | str->data = g_malloc(str->size + 1); |
135 | 199k | copied = v9fs_unpack(str->data, out_sg, out_num, offset, |
136 | 199k | str->size); |
137 | 199k | if (copied >= 0) { |
138 | 196k | str->data[str->size] = 0; |
139 | 196k | } else { |
140 | 2.29k | v9fs_string_free(str); |
141 | 2.29k | } |
142 | 199k | } |
143 | 199k | break; |
144 | 102k | } |
145 | 3.10k | case 'Q': { |
146 | 3.10k | V9fsQID *qidp = va_arg(ap, V9fsQID *); |
147 | 3.10k | copied = v9fs_iov_unmarshal(out_sg, out_num, offset, bswap, |
148 | 3.10k | "bdq", &qidp->type, &qidp->version, |
149 | 3.10k | &qidp->path); |
150 | 3.10k | break; |
151 | 102k | } |
152 | 3.10k | case 'S': { |
153 | 3.10k | V9fsStat *statp = va_arg(ap, V9fsStat *); |
154 | 3.10k | copied = v9fs_iov_unmarshal(out_sg, out_num, offset, bswap, |
155 | 3.10k | "wwdQdddqsssssddd", |
156 | 3.10k | &statp->size, &statp->type, |
157 | 3.10k | &statp->dev, &statp->qid, |
158 | 3.10k | &statp->mode, &statp->atime, |
159 | 3.10k | &statp->mtime, &statp->length, |
160 | 3.10k | &statp->name, &statp->uid, |
161 | 3.10k | &statp->gid, &statp->muid, |
162 | 3.10k | &statp->extension, |
163 | 3.10k | &statp->n_uid, &statp->n_gid, |
164 | 3.10k | &statp->n_muid); |
165 | 3.10k | break; |
166 | 102k | } |
167 | 18.5k | case 'I': { |
168 | 18.5k | V9fsIattr *iattr = va_arg(ap, V9fsIattr *); |
169 | 18.5k | copied = v9fs_iov_unmarshal(out_sg, out_num, offset, bswap, |
170 | 18.5k | "ddddqqqqq", |
171 | 18.5k | &iattr->valid, &iattr->mode, |
172 | 18.5k | &iattr->uid, &iattr->gid, |
173 | 18.5k | &iattr->size, &iattr->atime_sec, |
174 | 18.5k | &iattr->atime_nsec, |
175 | 18.5k | &iattr->mtime_sec, |
176 | 18.5k | &iattr->mtime_nsec); |
177 | 18.5k | break; |
178 | 102k | } |
179 | 0 | default: |
180 | 0 | g_assert_not_reached(); |
181 | 945k | } |
182 | 945k | if (copied < 0) { |
183 | 5.24k | return copied; |
184 | 5.24k | } |
185 | 940k | offset += copied; |
186 | 940k | } |
187 | | |
188 | 346k | return offset - old_offset; |
189 | 351k | } |
190 | | |
191 | | ssize_t v9fs_iov_unmarshal(struct iovec *out_sg, int out_num, size_t offset, |
192 | | int bswap, const char *fmt, ...) |
193 | 224k | { |
194 | 224k | ssize_t ret; |
195 | 224k | va_list ap; |
196 | | |
197 | 224k | va_start(ap, fmt); |
198 | 224k | ret = v9fs_iov_vunmarshal(out_sg, out_num, offset, bswap, fmt, ap); |
199 | 224k | va_end(ap); |
200 | | |
201 | 224k | return ret; |
202 | 224k | } |
203 | | |
204 | | ssize_t v9fs_iov_vmarshal(struct iovec *in_sg, int in_num, size_t offset, |
205 | | int bswap, const char *fmt, va_list ap) |
206 | 539k | { |
207 | 539k | int i; |
208 | 539k | ssize_t copied = 0; |
209 | 539k | size_t old_offset = offset; |
210 | | |
211 | 1.53M | for (i = 0; fmt[i]; i++) { |
212 | 995k | switch (fmt[i]) { |
213 | 227k | case 'b': { |
214 | 227k | uint8_t val = va_arg(ap, int); |
215 | 227k | copied = v9fs_pack(in_sg, in_num, offset, &val, sizeof(val)); |
216 | 227k | break; |
217 | 0 | } |
218 | 253k | case 'w': { |
219 | 253k | uint16_t val = va_arg(ap, int); |
220 | 253k | if (bswap) { |
221 | 253k | val = cpu_to_le16(val); |
222 | 253k | } |
223 | 253k | copied = v9fs_pack(in_sg, in_num, offset, &val, sizeof(val)); |
224 | 253k | break; |
225 | 0 | } |
226 | 390k | case 'd': { |
227 | 390k | uint32_t val = va_arg(ap, uint32_t); |
228 | 390k | if (bswap) { |
229 | 390k | val = cpu_to_le32(val); |
230 | 390k | } |
231 | 390k | copied = v9fs_pack(in_sg, in_num, offset, &val, sizeof(val)); |
232 | 390k | break; |
233 | 0 | } |
234 | 32.7k | case 'q': { |
235 | 32.7k | uint64_t val = va_arg(ap, uint64_t); |
236 | 32.7k | if (bswap) { |
237 | 32.7k | val = cpu_to_le64(val); |
238 | 32.7k | } |
239 | 32.7k | copied = v9fs_pack(in_sg, in_num, offset, &val, sizeof(val)); |
240 | 32.7k | break; |
241 | 0 | } |
242 | 58.8k | case 's': { |
243 | 58.8k | V9fsString *str = va_arg(ap, V9fsString *); |
244 | 58.8k | copied = v9fs_iov_marshal(in_sg, in_num, offset, bswap, |
245 | 58.8k | "w", str->size); |
246 | 58.8k | if (copied > 0) { |
247 | 58.8k | offset += copied; |
248 | 58.8k | copied = v9fs_pack(in_sg, in_num, offset, str->data, str->size); |
249 | 58.8k | } |
250 | 58.8k | break; |
251 | 0 | } |
252 | 32.7k | case 'Q': { |
253 | 32.7k | V9fsQID *qidp = va_arg(ap, V9fsQID *); |
254 | 32.7k | copied = v9fs_iov_marshal(in_sg, in_num, offset, bswap, "bdq", |
255 | 32.7k | qidp->type, qidp->version, |
256 | 32.7k | qidp->path); |
257 | 32.7k | break; |
258 | 0 | } |
259 | 0 | case 'S': { |
260 | 0 | V9fsStat *statp = va_arg(ap, V9fsStat *); |
261 | 0 | copied = v9fs_iov_marshal(in_sg, in_num, offset, bswap, |
262 | 0 | "wwdQdddqsssssddd", |
263 | 0 | statp->size, statp->type, statp->dev, |
264 | 0 | &statp->qid, statp->mode, statp->atime, |
265 | 0 | statp->mtime, statp->length, |
266 | 0 | &statp->name, |
267 | 0 | &statp->uid, &statp->gid, &statp->muid, |
268 | 0 | &statp->extension, statp->n_uid, |
269 | 0 | statp->n_gid, statp->n_muid); |
270 | 0 | break; |
271 | 0 | } |
272 | 0 | case 'A': { |
273 | 0 | V9fsStatDotl *statp = va_arg(ap, V9fsStatDotl *); |
274 | 0 | copied = v9fs_iov_marshal(in_sg, in_num, offset, bswap, |
275 | 0 | "qQdddqqqqqqqqqqqqqqq", |
276 | 0 | statp->st_result_mask, |
277 | 0 | &statp->qid, statp->st_mode, |
278 | 0 | statp->st_uid, statp->st_gid, |
279 | 0 | statp->st_nlink, statp->st_rdev, |
280 | 0 | statp->st_size, statp->st_blksize, |
281 | 0 | statp->st_blocks, statp->st_atime_sec, |
282 | 0 | statp->st_atime_nsec, |
283 | 0 | statp->st_mtime_sec, |
284 | 0 | statp->st_mtime_nsec, |
285 | 0 | statp->st_ctime_sec, |
286 | 0 | statp->st_ctime_nsec, |
287 | 0 | statp->st_btime_sec, |
288 | 0 | statp->st_btime_nsec, statp->st_gen, |
289 | 0 | statp->st_data_version); |
290 | 0 | break; |
291 | 0 | } |
292 | 0 | default: |
293 | 0 | g_assert_not_reached(); |
294 | 995k | } |
295 | 995k | if (copied < 0) { |
296 | 2.58k | return copied; |
297 | 2.58k | } |
298 | 992k | offset += copied; |
299 | 992k | } |
300 | | |
301 | 536k | return offset - old_offset; |
302 | 539k | } |
303 | | |
304 | | ssize_t v9fs_iov_marshal(struct iovec *in_sg, int in_num, size_t offset, |
305 | | int bswap, const char *fmt, ...) |
306 | 91.6k | { |
307 | 91.6k | ssize_t ret; |
308 | 91.6k | va_list ap; |
309 | | |
310 | 91.6k | va_start(ap, fmt); |
311 | 91.6k | ret = v9fs_iov_vmarshal(in_sg, in_num, offset, bswap, fmt, ap); |
312 | 91.6k | va_end(ap); |
313 | | |
314 | 91.6k | return ret; |
315 | 91.6k | } |