]>
Commit | Line | Data |
---|---|---|
4c793dda | 1 | /* |
494a8ebe | 2 | * 9p Proxy callback |
4c793dda MK |
3 | * |
4 | * Copyright IBM, Corp. 2011 | |
5 | * | |
6 | * Authors: | |
7 | * M. Mohan Kumar <mohan@in.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 | */ | |
e688df6b | 12 | |
fbc04127 | 13 | #include "qemu/osdep.h" |
4c793dda MK |
14 | #include <sys/socket.h> |
15 | #include <sys/un.h> | |
a8d25326 | 16 | #include "qemu-common.h" |
ebe74f8b | 17 | #include "9p.h" |
e688df6b | 18 | #include "qapi/error.h" |
f348b6d1 | 19 | #include "qemu/cutils.h" |
b4a42f81 | 20 | #include "qemu/error-report.h" |
922a01a0 | 21 | #include "qemu/option.h" |
4c793dda | 22 | #include "fsdev/qemu-fsdev.h" |
494a8ebe | 23 | #include "9p-proxy.h" |
4c793dda MK |
24 | |
25 | typedef struct V9fsProxy { | |
26 | int sockfd; | |
27 | QemuMutex mutex; | |
39f8c32c MK |
28 | struct iovec in_iovec; |
29 | struct iovec out_iovec; | |
4c793dda MK |
30 | } V9fsProxy; |
31 | ||
daf0b9ac MK |
32 | /* |
33 | * Return received file descriptor on success in *status. | |
34 | * errno is also returned on *status (which will be < 0) | |
35 | * return < 0 on transport error. | |
36 | */ | |
37 | static int v9fs_receivefd(int sockfd, int *status) | |
38 | { | |
39 | struct iovec iov; | |
40 | struct msghdr msg; | |
41 | struct cmsghdr *cmsg; | |
42 | int retval, data, fd; | |
43 | union MsgControl msg_control; | |
44 | ||
45 | iov.iov_base = &data; | |
46 | iov.iov_len = sizeof(data); | |
47 | ||
48 | memset(&msg, 0, sizeof(msg)); | |
49 | msg.msg_iov = &iov; | |
50 | msg.msg_iovlen = 1; | |
51 | msg.msg_control = &msg_control; | |
52 | msg.msg_controllen = sizeof(msg_control); | |
53 | ||
54 | do { | |
55 | retval = recvmsg(sockfd, &msg, 0); | |
56 | } while (retval < 0 && errno == EINTR); | |
57 | if (retval <= 0) { | |
58 | return retval; | |
59 | } | |
60 | /* | |
61 | * data is set to V9FS_FD_VALID, if ancillary data is sent. If this | |
62 | * request doesn't need ancillary data (fd) or an error occurred, | |
63 | * data is set to negative errno value. | |
64 | */ | |
65 | if (data != V9FS_FD_VALID) { | |
66 | *status = data; | |
67 | return 0; | |
68 | } | |
69 | /* | |
70 | * File descriptor (fd) is sent in the ancillary data. Check if we | |
71 | * indeed received it. One of the reasons to fail to receive it is if | |
72 | * we exceeded the maximum number of file descriptors! | |
73 | */ | |
74 | for (cmsg = CMSG_FIRSTHDR(&msg); cmsg; cmsg = CMSG_NXTHDR(&msg, cmsg)) { | |
75 | if (cmsg->cmsg_len != CMSG_LEN(sizeof(int)) || | |
76 | cmsg->cmsg_level != SOL_SOCKET || | |
77 | cmsg->cmsg_type != SCM_RIGHTS) { | |
78 | continue; | |
79 | } | |
80 | fd = *((int *)CMSG_DATA(cmsg)); | |
81 | *status = fd; | |
82 | return 0; | |
83 | } | |
84 | *status = -ENFILE; /* Ancillary data sent but not received */ | |
85 | return 0; | |
86 | } | |
87 | ||
39f8c32c MK |
88 | static ssize_t socket_read(int sockfd, void *buff, size_t size) |
89 | { | |
90 | ssize_t retval, total = 0; | |
91 | ||
92 | while (size) { | |
93 | retval = read(sockfd, buff, size); | |
94 | if (retval == 0) { | |
95 | return -EIO; | |
96 | } | |
97 | if (retval < 0) { | |
98 | if (errno == EINTR) { | |
99 | continue; | |
100 | } | |
101 | return -errno; | |
102 | } | |
103 | size -= retval; | |
104 | buff += retval; | |
105 | total += retval; | |
106 | } | |
107 | return total; | |
108 | } | |
109 | ||
b178adc3 MK |
110 | /* Converts proxy_statfs to VFS statfs structure */ |
111 | static void prstatfs_to_statfs(struct statfs *stfs, ProxyStatFS *prstfs) | |
112 | { | |
113 | memset(stfs, 0, sizeof(*stfs)); | |
114 | stfs->f_type = prstfs->f_type; | |
115 | stfs->f_bsize = prstfs->f_bsize; | |
116 | stfs->f_blocks = prstfs->f_blocks; | |
117 | stfs->f_bfree = prstfs->f_bfree; | |
118 | stfs->f_bavail = prstfs->f_bavail; | |
119 | stfs->f_files = prstfs->f_files; | |
120 | stfs->f_ffree = prstfs->f_ffree; | |
2afee49f PM |
121 | stfs->f_fsid.__val[0] = prstfs->f_fsid[0] & 0xFFFFFFFFU; |
122 | stfs->f_fsid.__val[1] = prstfs->f_fsid[1] >> 32 & 0xFFFFFFFFU; | |
b178adc3 MK |
123 | stfs->f_namelen = prstfs->f_namelen; |
124 | stfs->f_frsize = prstfs->f_frsize; | |
125 | } | |
126 | ||
127 | /* Converts proxy_stat structure to VFS stat structure */ | |
128 | static void prstat_to_stat(struct stat *stbuf, ProxyStat *prstat) | |
129 | { | |
130 | memset(stbuf, 0, sizeof(*stbuf)); | |
131 | stbuf->st_dev = prstat->st_dev; | |
132 | stbuf->st_ino = prstat->st_ino; | |
133 | stbuf->st_nlink = prstat->st_nlink; | |
134 | stbuf->st_mode = prstat->st_mode; | |
135 | stbuf->st_uid = prstat->st_uid; | |
136 | stbuf->st_gid = prstat->st_gid; | |
137 | stbuf->st_rdev = prstat->st_rdev; | |
138 | stbuf->st_size = prstat->st_size; | |
139 | stbuf->st_blksize = prstat->st_blksize; | |
140 | stbuf->st_blocks = prstat->st_blocks; | |
141 | stbuf->st_atim.tv_sec = prstat->st_atim_sec; | |
142 | stbuf->st_atim.tv_nsec = prstat->st_atim_nsec; | |
143 | stbuf->st_mtime = prstat->st_mtim_sec; | |
144 | stbuf->st_mtim.tv_nsec = prstat->st_mtim_nsec; | |
145 | stbuf->st_ctime = prstat->st_ctim_sec; | |
146 | stbuf->st_ctim.tv_nsec = prstat->st_ctim_nsec; | |
147 | } | |
148 | ||
149 | /* | |
150 | * Response contains two parts | |
151 | * {header, data} | |
152 | * header.type == T_ERROR, data -> -errno | |
153 | * header.type == T_SUCCESS, data -> response | |
154 | * size of errno/response is given by header.size | |
155 | * returns < 0, on transport error. response is | |
156 | * valid only if status >= 0. | |
157 | */ | |
158 | static int v9fs_receive_response(V9fsProxy *proxy, int type, | |
159 | int *status, void *response) | |
160 | { | |
161 | int retval; | |
162 | ProxyHeader header; | |
163 | struct iovec *reply = &proxy->in_iovec; | |
164 | ||
165 | *status = 0; | |
166 | reply->iov_len = 0; | |
167 | retval = socket_read(proxy->sockfd, reply->iov_base, PROXY_HDR_SZ); | |
168 | if (retval < 0) { | |
169 | return retval; | |
170 | } | |
171 | reply->iov_len = PROXY_HDR_SZ; | |
262169ab GK |
172 | retval = proxy_unmarshal(reply, 0, "dd", &header.type, &header.size); |
173 | assert(retval == 4 * 2); | |
b178adc3 MK |
174 | /* |
175 | * if response size > PROXY_MAX_IO_SZ, read the response but ignore it and | |
176 | * return -ENOBUFS | |
177 | */ | |
178 | if (header.size > PROXY_MAX_IO_SZ) { | |
179 | int count; | |
180 | while (header.size > 0) { | |
181 | count = MIN(PROXY_MAX_IO_SZ, header.size); | |
182 | count = socket_read(proxy->sockfd, reply->iov_base, count); | |
183 | if (count < 0) { | |
184 | return count; | |
185 | } | |
186 | header.size -= count; | |
187 | } | |
188 | *status = -ENOBUFS; | |
189 | return 0; | |
190 | } | |
191 | ||
192 | retval = socket_read(proxy->sockfd, | |
193 | reply->iov_base + PROXY_HDR_SZ, header.size); | |
194 | if (retval < 0) { | |
195 | return retval; | |
196 | } | |
197 | reply->iov_len += header.size; | |
198 | /* there was an error during processing request */ | |
199 | if (header.type == T_ERROR) { | |
200 | int ret; | |
201 | ret = proxy_unmarshal(reply, PROXY_HDR_SZ, "d", status); | |
262169ab | 202 | assert(ret == 4); |
b178adc3 MK |
203 | return 0; |
204 | } | |
205 | ||
206 | switch (type) { | |
207 | case T_LSTAT: { | |
208 | ProxyStat prstat; | |
209 | retval = proxy_unmarshal(reply, PROXY_HDR_SZ, | |
210 | "qqqdddqqqqqqqqqq", &prstat.st_dev, | |
211 | &prstat.st_ino, &prstat.st_nlink, | |
212 | &prstat.st_mode, &prstat.st_uid, | |
213 | &prstat.st_gid, &prstat.st_rdev, | |
214 | &prstat.st_size, &prstat.st_blksize, | |
215 | &prstat.st_blocks, | |
216 | &prstat.st_atim_sec, &prstat.st_atim_nsec, | |
217 | &prstat.st_mtim_sec, &prstat.st_mtim_nsec, | |
218 | &prstat.st_ctim_sec, &prstat.st_ctim_nsec); | |
262169ab | 219 | assert(retval == 8 * 3 + 4 * 3 + 8 * 10); |
b178adc3 MK |
220 | prstat_to_stat(response, &prstat); |
221 | break; | |
222 | } | |
223 | case T_STATFS: { | |
224 | ProxyStatFS prstfs; | |
225 | retval = proxy_unmarshal(reply, PROXY_HDR_SZ, | |
226 | "qqqqqqqqqqq", &prstfs.f_type, | |
227 | &prstfs.f_bsize, &prstfs.f_blocks, | |
228 | &prstfs.f_bfree, &prstfs.f_bavail, | |
229 | &prstfs.f_files, &prstfs.f_ffree, | |
230 | &prstfs.f_fsid[0], &prstfs.f_fsid[1], | |
231 | &prstfs.f_namelen, &prstfs.f_frsize); | |
262169ab | 232 | assert(retval == 8 * 11); |
b178adc3 MK |
233 | prstatfs_to_statfs(response, &prstfs); |
234 | break; | |
235 | } | |
236 | case T_READLINK: { | |
237 | V9fsString target; | |
238 | v9fs_string_init(&target); | |
239 | retval = proxy_unmarshal(reply, PROXY_HDR_SZ, "s", &target); | |
240 | strcpy(response, target.data); | |
241 | v9fs_string_free(&target); | |
242 | break; | |
243 | } | |
d52b09e4 MK |
244 | case T_LGETXATTR: |
245 | case T_LLISTXATTR: { | |
246 | V9fsString xattr; | |
247 | v9fs_string_init(&xattr); | |
248 | retval = proxy_unmarshal(reply, PROXY_HDR_SZ, "s", &xattr); | |
249 | memcpy(response, xattr.data, xattr.size); | |
250 | v9fs_string_free(&xattr); | |
251 | break; | |
252 | } | |
d090e452 | 253 | case T_GETVERSION: |
262169ab GK |
254 | retval = proxy_unmarshal(reply, PROXY_HDR_SZ, "q", response); |
255 | assert(retval == 8); | |
d090e452 | 256 | break; |
b178adc3 MK |
257 | default: |
258 | return -1; | |
259 | } | |
260 | if (retval < 0) { | |
261 | *status = retval; | |
262 | } | |
263 | return 0; | |
264 | } | |
265 | ||
39f8c32c MK |
266 | /* |
267 | * return < 0 on transport error. | |
268 | * *status is valid only if return >= 0 | |
269 | */ | |
270 | static int v9fs_receive_status(V9fsProxy *proxy, | |
271 | struct iovec *reply, int *status) | |
272 | { | |
273 | int retval; | |
274 | ProxyHeader header; | |
275 | ||
276 | *status = 0; | |
277 | reply->iov_len = 0; | |
278 | retval = socket_read(proxy->sockfd, reply->iov_base, PROXY_HDR_SZ); | |
279 | if (retval < 0) { | |
280 | return retval; | |
281 | } | |
282 | reply->iov_len = PROXY_HDR_SZ; | |
262169ab GK |
283 | retval = proxy_unmarshal(reply, 0, "dd", &header.type, &header.size); |
284 | assert(retval == 4 * 2); | |
39f8c32c MK |
285 | retval = socket_read(proxy->sockfd, |
286 | reply->iov_base + PROXY_HDR_SZ, header.size); | |
287 | if (retval < 0) { | |
288 | return retval; | |
289 | } | |
290 | reply->iov_len += header.size; | |
262169ab GK |
291 | retval = proxy_unmarshal(reply, PROXY_HDR_SZ, "d", status); |
292 | assert(retval == 4); | |
39f8c32c MK |
293 | return 0; |
294 | } | |
295 | ||
daf0b9ac MK |
296 | /* |
297 | * Proxy->header and proxy->request written to socket by QEMU process. | |
298 | * This request read by proxy helper process | |
299 | * returns 0 on success and -errno on error | |
300 | */ | |
799fe087 | 301 | static int v9fs_request(V9fsProxy *proxy, int type, void *response, ...) |
daf0b9ac | 302 | { |
39f8c32c | 303 | dev_t rdev; |
daf0b9ac | 304 | va_list ap; |
b178adc3 | 305 | int size = 0; |
daf0b9ac | 306 | int retval = 0; |
ea75fc4e | 307 | uint64_t offset; |
daf0b9ac | 308 | ProxyHeader header = { 0, 0}; |
ea75fc4e | 309 | struct timespec spec[2]; |
daf0b9ac | 310 | int flags, mode, uid, gid; |
d52b09e4 | 311 | V9fsString *name, *value; |
39f8c32c MK |
312 | V9fsString *path, *oldpath; |
313 | struct iovec *iovec = NULL, *reply = NULL; | |
daf0b9ac MK |
314 | |
315 | qemu_mutex_lock(&proxy->mutex); | |
316 | ||
317 | if (proxy->sockfd == -1) { | |
318 | retval = -EIO; | |
319 | goto err_out; | |
320 | } | |
39f8c32c MK |
321 | iovec = &proxy->out_iovec; |
322 | reply = &proxy->in_iovec; | |
799fe087 | 323 | va_start(ap, response); |
daf0b9ac MK |
324 | switch (type) { |
325 | case T_OPEN: | |
326 | path = va_arg(ap, V9fsString *); | |
327 | flags = va_arg(ap, int); | |
328 | retval = proxy_marshal(iovec, PROXY_HDR_SZ, "sd", path, flags); | |
329 | if (retval > 0) { | |
330 | header.size = retval; | |
331 | header.type = T_OPEN; | |
332 | } | |
333 | break; | |
334 | case T_CREATE: | |
335 | path = va_arg(ap, V9fsString *); | |
336 | flags = va_arg(ap, int); | |
337 | mode = va_arg(ap, int); | |
338 | uid = va_arg(ap, int); | |
339 | gid = va_arg(ap, int); | |
340 | retval = proxy_marshal(iovec, PROXY_HDR_SZ, "sdddd", path, | |
341 | flags, mode, uid, gid); | |
342 | if (retval > 0) { | |
343 | header.size = retval; | |
344 | header.type = T_CREATE; | |
345 | } | |
346 | break; | |
39f8c32c MK |
347 | case T_MKNOD: |
348 | path = va_arg(ap, V9fsString *); | |
349 | mode = va_arg(ap, int); | |
350 | rdev = va_arg(ap, long int); | |
351 | uid = va_arg(ap, int); | |
352 | gid = va_arg(ap, int); | |
353 | retval = proxy_marshal(iovec, PROXY_HDR_SZ, "ddsdq", | |
354 | uid, gid, path, mode, rdev); | |
355 | if (retval > 0) { | |
356 | header.size = retval; | |
357 | header.type = T_MKNOD; | |
358 | } | |
359 | break; | |
360 | case T_MKDIR: | |
361 | path = va_arg(ap, V9fsString *); | |
362 | mode = va_arg(ap, int); | |
363 | uid = va_arg(ap, int); | |
364 | gid = va_arg(ap, int); | |
365 | retval = proxy_marshal(iovec, PROXY_HDR_SZ, "ddsd", | |
366 | uid, gid, path, mode); | |
367 | if (retval > 0) { | |
368 | header.size = retval; | |
369 | header.type = T_MKDIR; | |
370 | } | |
371 | break; | |
372 | case T_SYMLINK: | |
373 | oldpath = va_arg(ap, V9fsString *); | |
374 | path = va_arg(ap, V9fsString *); | |
375 | uid = va_arg(ap, int); | |
376 | gid = va_arg(ap, int); | |
377 | retval = proxy_marshal(iovec, PROXY_HDR_SZ, "ddss", | |
378 | uid, gid, oldpath, path); | |
379 | if (retval > 0) { | |
380 | header.size = retval; | |
381 | header.type = T_SYMLINK; | |
382 | } | |
383 | break; | |
384 | case T_LINK: | |
385 | oldpath = va_arg(ap, V9fsString *); | |
386 | path = va_arg(ap, V9fsString *); | |
387 | retval = proxy_marshal(iovec, PROXY_HDR_SZ, "ss", | |
388 | oldpath, path); | |
389 | if (retval > 0) { | |
390 | header.size = retval; | |
391 | header.type = T_LINK; | |
392 | } | |
393 | break; | |
b178adc3 MK |
394 | case T_LSTAT: |
395 | path = va_arg(ap, V9fsString *); | |
396 | retval = proxy_marshal(iovec, PROXY_HDR_SZ, "s", path); | |
397 | if (retval > 0) { | |
398 | header.size = retval; | |
399 | header.type = T_LSTAT; | |
400 | } | |
401 | break; | |
402 | case T_READLINK: | |
403 | path = va_arg(ap, V9fsString *); | |
404 | size = va_arg(ap, int); | |
405 | retval = proxy_marshal(iovec, PROXY_HDR_SZ, "sd", path, size); | |
406 | if (retval > 0) { | |
407 | header.size = retval; | |
408 | header.type = T_READLINK; | |
409 | } | |
410 | break; | |
411 | case T_STATFS: | |
412 | path = va_arg(ap, V9fsString *); | |
413 | retval = proxy_marshal(iovec, PROXY_HDR_SZ, "s", path); | |
414 | if (retval > 0) { | |
415 | header.size = retval; | |
416 | header.type = T_STATFS; | |
417 | } | |
418 | break; | |
ea75fc4e MK |
419 | case T_CHMOD: |
420 | path = va_arg(ap, V9fsString *); | |
421 | mode = va_arg(ap, int); | |
422 | retval = proxy_marshal(iovec, PROXY_HDR_SZ, "sd", path, mode); | |
423 | if (retval > 0) { | |
424 | header.size = retval; | |
425 | header.type = T_CHMOD; | |
426 | } | |
427 | break; | |
428 | case T_CHOWN: | |
429 | path = va_arg(ap, V9fsString *); | |
430 | uid = va_arg(ap, int); | |
431 | gid = va_arg(ap, int); | |
432 | retval = proxy_marshal(iovec, PROXY_HDR_SZ, "sdd", path, uid, gid); | |
433 | if (retval > 0) { | |
434 | header.size = retval; | |
435 | header.type = T_CHOWN; | |
436 | } | |
437 | break; | |
438 | case T_TRUNCATE: | |
439 | path = va_arg(ap, V9fsString *); | |
440 | offset = va_arg(ap, uint64_t); | |
441 | retval = proxy_marshal(iovec, PROXY_HDR_SZ, "sq", path, offset); | |
442 | if (retval > 0) { | |
443 | header.size = retval; | |
444 | header.type = T_TRUNCATE; | |
445 | } | |
446 | break; | |
447 | case T_UTIME: | |
448 | path = va_arg(ap, V9fsString *); | |
449 | spec[0].tv_sec = va_arg(ap, long); | |
450 | spec[0].tv_nsec = va_arg(ap, long); | |
451 | spec[1].tv_sec = va_arg(ap, long); | |
452 | spec[1].tv_nsec = va_arg(ap, long); | |
453 | retval = proxy_marshal(iovec, PROXY_HDR_SZ, "sqqqq", path, | |
454 | spec[0].tv_sec, spec[1].tv_nsec, | |
455 | spec[1].tv_sec, spec[1].tv_nsec); | |
456 | if (retval > 0) { | |
457 | header.size = retval; | |
458 | header.type = T_UTIME; | |
459 | } | |
460 | break; | |
461 | case T_RENAME: | |
462 | oldpath = va_arg(ap, V9fsString *); | |
463 | path = va_arg(ap, V9fsString *); | |
464 | retval = proxy_marshal(iovec, PROXY_HDR_SZ, "ss", oldpath, path); | |
465 | if (retval > 0) { | |
466 | header.size = retval; | |
467 | header.type = T_RENAME; | |
468 | } | |
469 | break; | |
470 | case T_REMOVE: | |
471 | path = va_arg(ap, V9fsString *); | |
472 | retval = proxy_marshal(iovec, PROXY_HDR_SZ, "s", path); | |
473 | if (retval > 0) { | |
474 | header.size = retval; | |
475 | header.type = T_REMOVE; | |
476 | } | |
477 | break; | |
d52b09e4 MK |
478 | case T_LGETXATTR: |
479 | size = va_arg(ap, int); | |
480 | path = va_arg(ap, V9fsString *); | |
481 | name = va_arg(ap, V9fsString *); | |
482 | retval = proxy_marshal(iovec, PROXY_HDR_SZ, | |
483 | "dss", size, path, name); | |
484 | if (retval > 0) { | |
485 | header.size = retval; | |
486 | header.type = T_LGETXATTR; | |
487 | } | |
488 | break; | |
489 | case T_LLISTXATTR: | |
490 | size = va_arg(ap, int); | |
491 | path = va_arg(ap, V9fsString *); | |
492 | retval = proxy_marshal(iovec, PROXY_HDR_SZ, "ds", size, path); | |
493 | if (retval > 0) { | |
494 | header.size = retval; | |
495 | header.type = T_LLISTXATTR; | |
496 | } | |
497 | break; | |
498 | case T_LSETXATTR: | |
499 | path = va_arg(ap, V9fsString *); | |
500 | name = va_arg(ap, V9fsString *); | |
501 | value = va_arg(ap, V9fsString *); | |
502 | size = va_arg(ap, int); | |
503 | flags = va_arg(ap, int); | |
504 | retval = proxy_marshal(iovec, PROXY_HDR_SZ, "sssdd", | |
505 | path, name, value, size, flags); | |
506 | if (retval > 0) { | |
507 | header.size = retval; | |
508 | header.type = T_LSETXATTR; | |
509 | } | |
510 | break; | |
511 | case T_LREMOVEXATTR: | |
512 | path = va_arg(ap, V9fsString *); | |
513 | name = va_arg(ap, V9fsString *); | |
514 | retval = proxy_marshal(iovec, PROXY_HDR_SZ, "ss", path, name); | |
515 | if (retval > 0) { | |
516 | header.size = retval; | |
517 | header.type = T_LREMOVEXATTR; | |
518 | } | |
519 | break; | |
d090e452 MK |
520 | case T_GETVERSION: |
521 | path = va_arg(ap, V9fsString *); | |
522 | retval = proxy_marshal(iovec, PROXY_HDR_SZ, "s", path); | |
523 | if (retval > 0) { | |
524 | header.size = retval; | |
525 | header.type = T_GETVERSION; | |
526 | } | |
527 | break; | |
daf0b9ac | 528 | default: |
312fd5f2 | 529 | error_report("Invalid type %d", type); |
daf0b9ac MK |
530 | retval = -EINVAL; |
531 | break; | |
532 | } | |
533 | va_end(ap); | |
534 | ||
535 | if (retval < 0) { | |
536 | goto err_out; | |
537 | } | |
538 | ||
539 | /* marshal the header details */ | |
540 | proxy_marshal(iovec, 0, "dd", header.type, header.size); | |
541 | header.size += PROXY_HDR_SZ; | |
542 | ||
543 | retval = qemu_write_full(proxy->sockfd, iovec->iov_base, header.size); | |
544 | if (retval != header.size) { | |
545 | goto close_error; | |
546 | } | |
547 | ||
548 | switch (type) { | |
549 | case T_OPEN: | |
550 | case T_CREATE: | |
551 | /* | |
552 | * A file descriptor is returned as response for | |
553 | * T_OPEN,T_CREATE on success | |
554 | */ | |
555 | if (v9fs_receivefd(proxy->sockfd, &retval) < 0) { | |
556 | goto close_error; | |
557 | } | |
558 | break; | |
39f8c32c MK |
559 | case T_MKNOD: |
560 | case T_MKDIR: | |
561 | case T_SYMLINK: | |
562 | case T_LINK: | |
ea75fc4e MK |
563 | case T_CHMOD: |
564 | case T_CHOWN: | |
565 | case T_RENAME: | |
566 | case T_TRUNCATE: | |
567 | case T_UTIME: | |
568 | case T_REMOVE: | |
d52b09e4 MK |
569 | case T_LSETXATTR: |
570 | case T_LREMOVEXATTR: | |
39f8c32c MK |
571 | if (v9fs_receive_status(proxy, reply, &retval) < 0) { |
572 | goto close_error; | |
573 | } | |
574 | break; | |
b178adc3 MK |
575 | case T_LSTAT: |
576 | case T_READLINK: | |
577 | case T_STATFS: | |
d090e452 | 578 | case T_GETVERSION: |
b178adc3 MK |
579 | if (v9fs_receive_response(proxy, type, &retval, response) < 0) { |
580 | goto close_error; | |
581 | } | |
582 | break; | |
d52b09e4 MK |
583 | case T_LGETXATTR: |
584 | case T_LLISTXATTR: | |
585 | if (!size) { | |
586 | if (v9fs_receive_status(proxy, reply, &retval) < 0) { | |
587 | goto close_error; | |
588 | } | |
589 | } else { | |
590 | if (v9fs_receive_response(proxy, type, &retval, response) < 0) { | |
591 | goto close_error; | |
592 | } | |
593 | } | |
594 | break; | |
daf0b9ac MK |
595 | } |
596 | ||
597 | err_out: | |
598 | qemu_mutex_unlock(&proxy->mutex); | |
599 | return retval; | |
600 | ||
601 | close_error: | |
602 | close(proxy->sockfd); | |
603 | proxy->sockfd = -1; | |
604 | qemu_mutex_unlock(&proxy->mutex); | |
605 | return -EIO; | |
606 | } | |
607 | ||
4c793dda MK |
608 | static int proxy_lstat(FsContext *fs_ctx, V9fsPath *fs_path, struct stat *stbuf) |
609 | { | |
b178adc3 | 610 | int retval; |
799fe087 | 611 | retval = v9fs_request(fs_ctx->private, T_LSTAT, stbuf, fs_path); |
b178adc3 MK |
612 | if (retval < 0) { |
613 | errno = -retval; | |
614 | return -1; | |
615 | } | |
616 | return retval; | |
4c793dda MK |
617 | } |
618 | ||
619 | static ssize_t proxy_readlink(FsContext *fs_ctx, V9fsPath *fs_path, | |
620 | char *buf, size_t bufsz) | |
621 | { | |
b178adc3 | 622 | int retval; |
799fe087 | 623 | retval = v9fs_request(fs_ctx->private, T_READLINK, buf, fs_path, bufsz); |
b178adc3 MK |
624 | if (retval < 0) { |
625 | errno = -retval; | |
626 | return -1; | |
627 | } | |
628 | return strlen(buf); | |
4c793dda MK |
629 | } |
630 | ||
631 | static int proxy_close(FsContext *ctx, V9fsFidOpenState *fs) | |
632 | { | |
633 | return close(fs->fd); | |
634 | } | |
635 | ||
636 | static int proxy_closedir(FsContext *ctx, V9fsFidOpenState *fs) | |
637 | { | |
f314ea4e | 638 | return closedir(fs->dir.stream); |
4c793dda MK |
639 | } |
640 | ||
641 | static int proxy_open(FsContext *ctx, V9fsPath *fs_path, | |
642 | int flags, V9fsFidOpenState *fs) | |
643 | { | |
799fe087 | 644 | fs->fd = v9fs_request(ctx->private, T_OPEN, NULL, fs_path, flags); |
daf0b9ac MK |
645 | if (fs->fd < 0) { |
646 | errno = -fs->fd; | |
647 | fs->fd = -1; | |
648 | } | |
4c793dda MK |
649 | return fs->fd; |
650 | } | |
651 | ||
652 | static int proxy_opendir(FsContext *ctx, | |
653 | V9fsPath *fs_path, V9fsFidOpenState *fs) | |
654 | { | |
daf0b9ac MK |
655 | int serrno, fd; |
656 | ||
f314ea4e | 657 | fs->dir.stream = NULL; |
799fe087 | 658 | fd = v9fs_request(ctx->private, T_OPEN, NULL, fs_path, O_DIRECTORY); |
daf0b9ac MK |
659 | if (fd < 0) { |
660 | errno = -fd; | |
661 | return -1; | |
662 | } | |
f314ea4e GK |
663 | fs->dir.stream = fdopendir(fd); |
664 | if (!fs->dir.stream) { | |
daf0b9ac MK |
665 | serrno = errno; |
666 | close(fd); | |
667 | errno = serrno; | |
668 | return -1; | |
669 | } | |
670 | return 0; | |
4c793dda MK |
671 | } |
672 | ||
673 | static void proxy_rewinddir(FsContext *ctx, V9fsFidOpenState *fs) | |
674 | { | |
f314ea4e | 675 | rewinddir(fs->dir.stream); |
4c793dda MK |
676 | } |
677 | ||
678 | static off_t proxy_telldir(FsContext *ctx, V9fsFidOpenState *fs) | |
679 | { | |
f314ea4e | 680 | return telldir(fs->dir.stream); |
4c793dda MK |
681 | } |
682 | ||
635324e8 | 683 | static struct dirent *proxy_readdir(FsContext *ctx, V9fsFidOpenState *fs) |
4c793dda | 684 | { |
635324e8 | 685 | return readdir(fs->dir.stream); |
4c793dda MK |
686 | } |
687 | ||
688 | static void proxy_seekdir(FsContext *ctx, V9fsFidOpenState *fs, off_t off) | |
689 | { | |
f314ea4e | 690 | seekdir(fs->dir.stream, off); |
4c793dda MK |
691 | } |
692 | ||
693 | static ssize_t proxy_preadv(FsContext *ctx, V9fsFidOpenState *fs, | |
694 | const struct iovec *iov, | |
695 | int iovcnt, off_t offset) | |
696 | { | |
7752efca | 697 | ssize_t ret; |
4c793dda | 698 | #ifdef CONFIG_PREADV |
7752efca | 699 | ret = preadv(fs->fd, iov, iovcnt, offset); |
4c793dda | 700 | #else |
7752efca MT |
701 | ret = lseek(fs->fd, offset, SEEK_SET); |
702 | if (ret >= 0) { | |
703 | ret = readv(fs->fd, iov, iovcnt); | |
4c793dda MK |
704 | } |
705 | #endif | |
7752efca | 706 | return ret; |
4c793dda MK |
707 | } |
708 | ||
709 | static ssize_t proxy_pwritev(FsContext *ctx, V9fsFidOpenState *fs, | |
710 | const struct iovec *iov, | |
711 | int iovcnt, off_t offset) | |
712 | { | |
713 | ssize_t ret; | |
714 | ||
715 | #ifdef CONFIG_PREADV | |
716 | ret = pwritev(fs->fd, iov, iovcnt, offset); | |
717 | #else | |
7752efca MT |
718 | ret = lseek(fs->fd, offset, SEEK_SET); |
719 | if (ret >= 0) { | |
4c793dda MK |
720 | ret = writev(fs->fd, iov, iovcnt); |
721 | } | |
722 | #endif | |
723 | #ifdef CONFIG_SYNC_FILE_RANGE | |
724 | if (ret > 0 && ctx->export_flags & V9FS_IMMEDIATE_WRITEOUT) { | |
725 | /* | |
726 | * Initiate a writeback. This is not a data integrity sync. | |
727 | * We want to ensure that we don't leave dirty pages in the cache | |
728 | * after write when writeout=immediate is sepcified. | |
729 | */ | |
730 | sync_file_range(fs->fd, offset, ret, | |
731 | SYNC_FILE_RANGE_WAIT_BEFORE | SYNC_FILE_RANGE_WRITE); | |
732 | } | |
733 | #endif | |
734 | return ret; | |
735 | } | |
736 | ||
737 | static int proxy_chmod(FsContext *fs_ctx, V9fsPath *fs_path, FsCred *credp) | |
738 | { | |
ea75fc4e | 739 | int retval; |
799fe087 GK |
740 | retval = v9fs_request(fs_ctx->private, T_CHMOD, NULL, fs_path, |
741 | credp->fc_mode); | |
ea75fc4e MK |
742 | if (retval < 0) { |
743 | errno = -retval; | |
744 | } | |
745 | return retval; | |
4c793dda MK |
746 | } |
747 | ||
748 | static int proxy_mknod(FsContext *fs_ctx, V9fsPath *dir_path, | |
749 | const char *name, FsCred *credp) | |
750 | { | |
39f8c32c MK |
751 | int retval; |
752 | V9fsString fullname; | |
753 | ||
754 | v9fs_string_init(&fullname); | |
755 | v9fs_string_sprintf(&fullname, "%s/%s", dir_path->data, name); | |
756 | ||
799fe087 GK |
757 | retval = v9fs_request(fs_ctx->private, T_MKNOD, NULL, &fullname, |
758 | credp->fc_mode, credp->fc_rdev, | |
39f8c32c MK |
759 | credp->fc_uid, credp->fc_gid); |
760 | v9fs_string_free(&fullname); | |
761 | if (retval < 0) { | |
762 | errno = -retval; | |
763 | retval = -1; | |
764 | } | |
765 | return retval; | |
4c793dda MK |
766 | } |
767 | ||
768 | static int proxy_mkdir(FsContext *fs_ctx, V9fsPath *dir_path, | |
769 | const char *name, FsCred *credp) | |
770 | { | |
39f8c32c MK |
771 | int retval; |
772 | V9fsString fullname; | |
773 | ||
774 | v9fs_string_init(&fullname); | |
775 | v9fs_string_sprintf(&fullname, "%s/%s", dir_path->data, name); | |
776 | ||
799fe087 | 777 | retval = v9fs_request(fs_ctx->private, T_MKDIR, NULL, &fullname, |
39f8c32c MK |
778 | credp->fc_mode, credp->fc_uid, credp->fc_gid); |
779 | v9fs_string_free(&fullname); | |
780 | if (retval < 0) { | |
781 | errno = -retval; | |
782 | retval = -1; | |
783 | } | |
39f8c32c | 784 | return retval; |
4c793dda MK |
785 | } |
786 | ||
787 | static int proxy_fstat(FsContext *fs_ctx, int fid_type, | |
788 | V9fsFidOpenState *fs, struct stat *stbuf) | |
789 | { | |
790 | int fd; | |
791 | ||
792 | if (fid_type == P9_FID_DIR) { | |
f314ea4e | 793 | fd = dirfd(fs->dir.stream); |
4c793dda MK |
794 | } else { |
795 | fd = fs->fd; | |
796 | } | |
797 | return fstat(fd, stbuf); | |
798 | } | |
799 | ||
800 | static int proxy_open2(FsContext *fs_ctx, V9fsPath *dir_path, const char *name, | |
801 | int flags, FsCred *credp, V9fsFidOpenState *fs) | |
802 | { | |
daf0b9ac MK |
803 | V9fsString fullname; |
804 | ||
805 | v9fs_string_init(&fullname); | |
806 | v9fs_string_sprintf(&fullname, "%s/%s", dir_path->data, name); | |
807 | ||
799fe087 GK |
808 | fs->fd = v9fs_request(fs_ctx->private, T_CREATE, NULL, &fullname, flags, |
809 | credp->fc_mode, credp->fc_uid, credp->fc_gid); | |
daf0b9ac MK |
810 | v9fs_string_free(&fullname); |
811 | if (fs->fd < 0) { | |
812 | errno = -fs->fd; | |
813 | fs->fd = -1; | |
814 | } | |
815 | return fs->fd; | |
4c793dda MK |
816 | } |
817 | ||
4c793dda MK |
818 | static int proxy_symlink(FsContext *fs_ctx, const char *oldpath, |
819 | V9fsPath *dir_path, const char *name, FsCred *credp) | |
820 | { | |
39f8c32c MK |
821 | int retval; |
822 | V9fsString fullname, target; | |
823 | ||
824 | v9fs_string_init(&fullname); | |
825 | v9fs_string_init(&target); | |
826 | ||
827 | v9fs_string_sprintf(&fullname, "%s/%s", dir_path->data, name); | |
828 | v9fs_string_sprintf(&target, "%s", oldpath); | |
829 | ||
799fe087 GK |
830 | retval = v9fs_request(fs_ctx->private, T_SYMLINK, NULL, &target, &fullname, |
831 | credp->fc_uid, credp->fc_gid); | |
39f8c32c MK |
832 | v9fs_string_free(&fullname); |
833 | v9fs_string_free(&target); | |
834 | if (retval < 0) { | |
835 | errno = -retval; | |
836 | retval = -1; | |
837 | } | |
838 | return retval; | |
4c793dda MK |
839 | } |
840 | ||
841 | static int proxy_link(FsContext *ctx, V9fsPath *oldpath, | |
842 | V9fsPath *dirpath, const char *name) | |
843 | { | |
39f8c32c MK |
844 | int retval; |
845 | V9fsString newpath; | |
846 | ||
847 | v9fs_string_init(&newpath); | |
848 | v9fs_string_sprintf(&newpath, "%s/%s", dirpath->data, name); | |
849 | ||
799fe087 | 850 | retval = v9fs_request(ctx->private, T_LINK, NULL, oldpath, &newpath); |
39f8c32c MK |
851 | v9fs_string_free(&newpath); |
852 | if (retval < 0) { | |
853 | errno = -retval; | |
854 | retval = -1; | |
855 | } | |
856 | return retval; | |
4c793dda MK |
857 | } |
858 | ||
859 | static int proxy_truncate(FsContext *ctx, V9fsPath *fs_path, off_t size) | |
860 | { | |
ea75fc4e MK |
861 | int retval; |
862 | ||
799fe087 | 863 | retval = v9fs_request(ctx->private, T_TRUNCATE, NULL, fs_path, size); |
ea75fc4e MK |
864 | if (retval < 0) { |
865 | errno = -retval; | |
866 | return -1; | |
867 | } | |
868 | return 0; | |
4c793dda MK |
869 | } |
870 | ||
871 | static int proxy_rename(FsContext *ctx, const char *oldpath, | |
872 | const char *newpath) | |
873 | { | |
ea75fc4e MK |
874 | int retval; |
875 | V9fsString oldname, newname; | |
876 | ||
877 | v9fs_string_init(&oldname); | |
878 | v9fs_string_init(&newname); | |
879 | ||
880 | v9fs_string_sprintf(&oldname, "%s", oldpath); | |
881 | v9fs_string_sprintf(&newname, "%s", newpath); | |
799fe087 | 882 | retval = v9fs_request(ctx->private, T_RENAME, NULL, &oldname, &newname); |
ea75fc4e MK |
883 | v9fs_string_free(&oldname); |
884 | v9fs_string_free(&newname); | |
885 | if (retval < 0) { | |
886 | errno = -retval; | |
887 | } | |
888 | return retval; | |
4c793dda MK |
889 | } |
890 | ||
891 | static int proxy_chown(FsContext *fs_ctx, V9fsPath *fs_path, FsCred *credp) | |
892 | { | |
ea75fc4e | 893 | int retval; |
799fe087 GK |
894 | retval = v9fs_request(fs_ctx->private, T_CHOWN, NULL, fs_path, |
895 | credp->fc_uid, credp->fc_gid); | |
ea75fc4e MK |
896 | if (retval < 0) { |
897 | errno = -retval; | |
898 | } | |
899 | return retval; | |
4c793dda MK |
900 | } |
901 | ||
902 | static int proxy_utimensat(FsContext *s, V9fsPath *fs_path, | |
903 | const struct timespec *buf) | |
904 | { | |
ea75fc4e | 905 | int retval; |
799fe087 | 906 | retval = v9fs_request(s->private, T_UTIME, NULL, fs_path, |
ea75fc4e MK |
907 | buf[0].tv_sec, buf[0].tv_nsec, |
908 | buf[1].tv_sec, buf[1].tv_nsec); | |
909 | if (retval < 0) { | |
910 | errno = -retval; | |
911 | } | |
912 | return retval; | |
4c793dda MK |
913 | } |
914 | ||
915 | static int proxy_remove(FsContext *ctx, const char *path) | |
916 | { | |
ea75fc4e MK |
917 | int retval; |
918 | V9fsString name; | |
919 | v9fs_string_init(&name); | |
920 | v9fs_string_sprintf(&name, "%s", path); | |
799fe087 | 921 | retval = v9fs_request(ctx->private, T_REMOVE, NULL, &name); |
ea75fc4e MK |
922 | v9fs_string_free(&name); |
923 | if (retval < 0) { | |
924 | errno = -retval; | |
925 | } | |
926 | return retval; | |
4c793dda MK |
927 | } |
928 | ||
929 | static int proxy_fsync(FsContext *ctx, int fid_type, | |
930 | V9fsFidOpenState *fs, int datasync) | |
931 | { | |
932 | int fd; | |
933 | ||
934 | if (fid_type == P9_FID_DIR) { | |
f314ea4e | 935 | fd = dirfd(fs->dir.stream); |
4c793dda MK |
936 | } else { |
937 | fd = fs->fd; | |
938 | } | |
939 | ||
940 | if (datasync) { | |
941 | return qemu_fdatasync(fd); | |
942 | } else { | |
943 | return fsync(fd); | |
944 | } | |
945 | } | |
946 | ||
947 | static int proxy_statfs(FsContext *s, V9fsPath *fs_path, struct statfs *stbuf) | |
948 | { | |
b178adc3 | 949 | int retval; |
799fe087 | 950 | retval = v9fs_request(s->private, T_STATFS, stbuf, fs_path); |
b178adc3 MK |
951 | if (retval < 0) { |
952 | errno = -retval; | |
953 | return -1; | |
954 | } | |
955 | return retval; | |
4c793dda MK |
956 | } |
957 | ||
958 | static ssize_t proxy_lgetxattr(FsContext *ctx, V9fsPath *fs_path, | |
959 | const char *name, void *value, size_t size) | |
960 | { | |
d52b09e4 MK |
961 | int retval; |
962 | V9fsString xname; | |
963 | ||
964 | v9fs_string_init(&xname); | |
965 | v9fs_string_sprintf(&xname, "%s", name); | |
799fe087 GK |
966 | retval = v9fs_request(ctx->private, T_LGETXATTR, value, size, fs_path, |
967 | &xname); | |
d52b09e4 MK |
968 | v9fs_string_free(&xname); |
969 | if (retval < 0) { | |
970 | errno = -retval; | |
971 | } | |
972 | return retval; | |
4c793dda MK |
973 | } |
974 | ||
975 | static ssize_t proxy_llistxattr(FsContext *ctx, V9fsPath *fs_path, | |
976 | void *value, size_t size) | |
977 | { | |
d52b09e4 | 978 | int retval; |
799fe087 | 979 | retval = v9fs_request(ctx->private, T_LLISTXATTR, value, size, fs_path); |
d52b09e4 MK |
980 | if (retval < 0) { |
981 | errno = -retval; | |
982 | } | |
983 | return retval; | |
4c793dda MK |
984 | } |
985 | ||
986 | static int proxy_lsetxattr(FsContext *ctx, V9fsPath *fs_path, const char *name, | |
987 | void *value, size_t size, int flags) | |
988 | { | |
d52b09e4 MK |
989 | int retval; |
990 | V9fsString xname, xvalue; | |
991 | ||
992 | v9fs_string_init(&xname); | |
993 | v9fs_string_sprintf(&xname, "%s", name); | |
994 | ||
995 | v9fs_string_init(&xvalue); | |
996 | xvalue.size = size; | |
997 | xvalue.data = g_malloc(size); | |
998 | memcpy(xvalue.data, value, size); | |
999 | ||
799fe087 GK |
1000 | retval = v9fs_request(ctx->private, T_LSETXATTR, value, fs_path, &xname, |
1001 | &xvalue, size, flags); | |
d52b09e4 MK |
1002 | v9fs_string_free(&xname); |
1003 | v9fs_string_free(&xvalue); | |
1004 | if (retval < 0) { | |
1005 | errno = -retval; | |
1006 | } | |
1007 | return retval; | |
4c793dda MK |
1008 | } |
1009 | ||
1010 | static int proxy_lremovexattr(FsContext *ctx, V9fsPath *fs_path, | |
1011 | const char *name) | |
1012 | { | |
d52b09e4 MK |
1013 | int retval; |
1014 | V9fsString xname; | |
1015 | ||
1016 | v9fs_string_init(&xname); | |
1017 | v9fs_string_sprintf(&xname, "%s", name); | |
799fe087 | 1018 | retval = v9fs_request(ctx->private, T_LREMOVEXATTR, NULL, fs_path, &xname); |
d52b09e4 MK |
1019 | v9fs_string_free(&xname); |
1020 | if (retval < 0) { | |
1021 | errno = -retval; | |
1022 | } | |
1023 | return retval; | |
4c793dda MK |
1024 | } |
1025 | ||
1026 | static int proxy_name_to_path(FsContext *ctx, V9fsPath *dir_path, | |
1027 | const char *name, V9fsPath *target) | |
1028 | { | |
1029 | if (dir_path) { | |
e3e83f2e | 1030 | v9fs_path_sprintf(target, "%s/%s", dir_path->data, name); |
4c793dda | 1031 | } else { |
e3e83f2e | 1032 | v9fs_path_sprintf(target, "%s", name); |
4c793dda | 1033 | } |
4c793dda MK |
1034 | return 0; |
1035 | } | |
1036 | ||
1037 | static int proxy_renameat(FsContext *ctx, V9fsPath *olddir, | |
1038 | const char *old_name, V9fsPath *newdir, | |
1039 | const char *new_name) | |
1040 | { | |
1041 | int ret; | |
1042 | V9fsString old_full_name, new_full_name; | |
1043 | ||
1044 | v9fs_string_init(&old_full_name); | |
1045 | v9fs_string_init(&new_full_name); | |
1046 | ||
1047 | v9fs_string_sprintf(&old_full_name, "%s/%s", olddir->data, old_name); | |
1048 | v9fs_string_sprintf(&new_full_name, "%s/%s", newdir->data, new_name); | |
1049 | ||
1050 | ret = proxy_rename(ctx, old_full_name.data, new_full_name.data); | |
1051 | v9fs_string_free(&old_full_name); | |
1052 | v9fs_string_free(&new_full_name); | |
1053 | return ret; | |
1054 | } | |
1055 | ||
1056 | static int proxy_unlinkat(FsContext *ctx, V9fsPath *dir, | |
1057 | const char *name, int flags) | |
1058 | { | |
1059 | int ret; | |
1060 | V9fsString fullname; | |
1061 | v9fs_string_init(&fullname); | |
1062 | ||
1063 | v9fs_string_sprintf(&fullname, "%s/%s", dir->data, name); | |
1064 | ret = proxy_remove(ctx, fullname.data); | |
1065 | v9fs_string_free(&fullname); | |
1066 | ||
1067 | return ret; | |
1068 | } | |
1069 | ||
d090e452 MK |
1070 | static int proxy_ioc_getversion(FsContext *fs_ctx, V9fsPath *path, |
1071 | mode_t st_mode, uint64_t *st_gen) | |
1072 | { | |
1073 | int err; | |
1074 | ||
1075 | /* Do not try to open special files like device nodes, fifos etc | |
1076 | * we can get fd for regular files and directories only | |
1077 | */ | |
1078 | if (!S_ISREG(st_mode) && !S_ISDIR(st_mode)) { | |
1a9978a5 KS |
1079 | errno = ENOTTY; |
1080 | return -1; | |
d090e452 | 1081 | } |
799fe087 | 1082 | err = v9fs_request(fs_ctx->private, T_GETVERSION, st_gen, path); |
d090e452 MK |
1083 | if (err < 0) { |
1084 | errno = -err; | |
1085 | err = -1; | |
1086 | } | |
1087 | return err; | |
1088 | } | |
1089 | ||
65603a80 | 1090 | static int connect_namedsocket(const char *path, Error **errp) |
84a87cc4 | 1091 | { |
fde1f3e4 | 1092 | int sockfd; |
84a87cc4 MK |
1093 | struct sockaddr_un helper; |
1094 | ||
25ee9a7f | 1095 | if (strlen(path) >= sizeof(helper.sun_path)) { |
65603a80 | 1096 | error_setg(errp, "socket name too long"); |
25ee9a7f SZ |
1097 | return -1; |
1098 | } | |
84a87cc4 MK |
1099 | sockfd = socket(AF_UNIX, SOCK_STREAM, 0); |
1100 | if (sockfd < 0) { | |
65603a80 | 1101 | error_setg_errno(errp, errno, "failed to create client socket"); |
84a87cc4 MK |
1102 | return -1; |
1103 | } | |
1104 | strcpy(helper.sun_path, path); | |
1105 | helper.sun_family = AF_UNIX; | |
fde1f3e4 | 1106 | if (connect(sockfd, (struct sockaddr *)&helper, sizeof(helper)) < 0) { |
65603a80 | 1107 | error_setg_errno(errp, errno, "failed to connect to '%s'", path); |
660edd4e | 1108 | close(sockfd); |
84a87cc4 MK |
1109 | return -1; |
1110 | } | |
1111 | ||
1112 | /* remove the socket for security reasons */ | |
1113 | unlink(path); | |
1114 | return sockfd; | |
1115 | } | |
1116 | ||
91cda4e8 GK |
1117 | static void error_append_socket_sockfd_hint(Error **errp) |
1118 | { | |
1119 | error_append_hint(errp, "Either specify socket=/some/path where /some/path" | |
1120 | " points to a listening AF_UNIX socket or sock_fd=fd" | |
1121 | " where fd is a file descriptor to a connected AF_UNIX" | |
1122 | " socket\n"); | |
1123 | } | |
1124 | ||
1125 | static int proxy_parse_opts(QemuOpts *opts, FsDriverEntry *fs, Error **errp) | |
4c793dda | 1126 | { |
84a87cc4 | 1127 | const char *socket = qemu_opt_get(opts, "socket"); |
4c793dda MK |
1128 | const char *sock_fd = qemu_opt_get(opts, "sock_fd"); |
1129 | ||
84a87cc4 | 1130 | if (!socket && !sock_fd) { |
91cda4e8 GK |
1131 | error_setg(errp, "both socket and sock_fd properties are missing"); |
1132 | error_append_socket_sockfd_hint(errp); | |
84a87cc4 MK |
1133 | return -1; |
1134 | } | |
1135 | if (socket && sock_fd) { | |
91cda4e8 GK |
1136 | error_setg(errp, "both socket and sock_fd properties are set"); |
1137 | error_append_socket_sockfd_hint(errp); | |
4c793dda MK |
1138 | return -1; |
1139 | } | |
84a87cc4 MK |
1140 | if (socket) { |
1141 | fs->path = g_strdup(socket); | |
1142 | fs->export_flags = V9FS_PROXY_SOCK_NAME; | |
1143 | } else { | |
1144 | fs->path = g_strdup(sock_fd); | |
1145 | fs->export_flags = V9FS_PROXY_SOCK_FD; | |
1146 | } | |
4c793dda MK |
1147 | return 0; |
1148 | } | |
1149 | ||
65603a80 | 1150 | static int proxy_init(FsContext *ctx, Error **errp) |
4c793dda MK |
1151 | { |
1152 | V9fsProxy *proxy = g_malloc(sizeof(V9fsProxy)); | |
1153 | int sock_id; | |
1154 | ||
84a87cc4 | 1155 | if (ctx->export_flags & V9FS_PROXY_SOCK_NAME) { |
65603a80 | 1156 | sock_id = connect_namedsocket(ctx->fs_root, errp); |
84a87cc4 MK |
1157 | } else { |
1158 | sock_id = atoi(ctx->fs_root); | |
1159 | if (sock_id < 0) { | |
65603a80 | 1160 | error_setg(errp, "socket descriptor not initialized"); |
84a87cc4 | 1161 | } |
4c793dda | 1162 | } |
6af76c6f MT |
1163 | if (sock_id < 0) { |
1164 | g_free(proxy); | |
1165 | return -1; | |
1166 | } | |
4c793dda | 1167 | g_free(ctx->fs_root); |
80cba1b7 | 1168 | ctx->fs_root = NULL; |
4c793dda | 1169 | |
39f8c32c MK |
1170 | proxy->in_iovec.iov_base = g_malloc(PROXY_MAX_IO_SZ + PROXY_HDR_SZ); |
1171 | proxy->in_iovec.iov_len = PROXY_MAX_IO_SZ + PROXY_HDR_SZ; | |
1172 | proxy->out_iovec.iov_base = g_malloc(PROXY_MAX_IO_SZ + PROXY_HDR_SZ); | |
1173 | proxy->out_iovec.iov_len = PROXY_MAX_IO_SZ + PROXY_HDR_SZ; | |
1174 | ||
4c793dda MK |
1175 | ctx->private = proxy; |
1176 | proxy->sockfd = sock_id; | |
1177 | qemu_mutex_init(&proxy->mutex); | |
1178 | ||
1179 | ctx->export_flags |= V9FS_PATHNAME_FSCONTEXT; | |
d090e452 | 1180 | ctx->exops.get_st_gen = proxy_ioc_getversion; |
4c793dda MK |
1181 | return 0; |
1182 | } | |
1183 | ||
898ae90a LQ |
1184 | static void proxy_cleanup(FsContext *ctx) |
1185 | { | |
1186 | V9fsProxy *proxy = ctx->private; | |
1187 | ||
1188 | g_free(proxy->out_iovec.iov_base); | |
1189 | g_free(proxy->in_iovec.iov_base); | |
1190 | if (ctx->export_flags & V9FS_PROXY_SOCK_NAME) { | |
1191 | close(proxy->sockfd); | |
1192 | } | |
1193 | g_free(proxy); | |
1194 | } | |
1195 | ||
4c793dda MK |
1196 | FileOperations proxy_ops = { |
1197 | .parse_opts = proxy_parse_opts, | |
1198 | .init = proxy_init, | |
898ae90a | 1199 | .cleanup = proxy_cleanup, |
4c793dda MK |
1200 | .lstat = proxy_lstat, |
1201 | .readlink = proxy_readlink, | |
1202 | .close = proxy_close, | |
1203 | .closedir = proxy_closedir, | |
1204 | .open = proxy_open, | |
1205 | .opendir = proxy_opendir, | |
1206 | .rewinddir = proxy_rewinddir, | |
1207 | .telldir = proxy_telldir, | |
635324e8 | 1208 | .readdir = proxy_readdir, |
4c793dda MK |
1209 | .seekdir = proxy_seekdir, |
1210 | .preadv = proxy_preadv, | |
1211 | .pwritev = proxy_pwritev, | |
1212 | .chmod = proxy_chmod, | |
1213 | .mknod = proxy_mknod, | |
1214 | .mkdir = proxy_mkdir, | |
1215 | .fstat = proxy_fstat, | |
1216 | .open2 = proxy_open2, | |
1217 | .symlink = proxy_symlink, | |
1218 | .link = proxy_link, | |
1219 | .truncate = proxy_truncate, | |
1220 | .rename = proxy_rename, | |
1221 | .chown = proxy_chown, | |
1222 | .utimensat = proxy_utimensat, | |
1223 | .remove = proxy_remove, | |
1224 | .fsync = proxy_fsync, | |
1225 | .statfs = proxy_statfs, | |
1226 | .lgetxattr = proxy_lgetxattr, | |
1227 | .llistxattr = proxy_llistxattr, | |
1228 | .lsetxattr = proxy_lsetxattr, | |
1229 | .lremovexattr = proxy_lremovexattr, | |
1230 | .name_to_path = proxy_name_to_path, | |
1231 | .renameat = proxy_renameat, | |
1232 | .unlinkat = proxy_unlinkat, | |
1233 | }; |