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