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