]>
git.proxmox.com Git - qemu.git/blob - hw/9pfs/virtio-9p.c
4 * Copyright IBM, Corp. 2010
7 * Anthony Liguori <aliguori@us.ibm.com>
9 * This work is licensed under the terms of the GNU GPL, version 2. See
10 * the COPYING file in the top-level directory.
14 #include "hw/virtio.h"
16 #include "qemu_socket.h"
17 #include "hw/virtio-pci.h"
18 #include "virtio-9p.h"
19 #include "fsdev/qemu-fsdev.h"
20 #include "virtio-9p-debug.h"
21 #include "virtio-9p-xattr.h"
22 #include "virtio-9p-coth.h"
38 static int omode_to_uflags(int8_t mode
)
72 void cred_init(FsCred
*credp
)
80 static void v9fs_string_init(V9fsString
*str
)
86 static void v9fs_string_free(V9fsString
*str
)
93 static void v9fs_string_null(V9fsString
*str
)
95 v9fs_string_free(str
);
98 static int number_to_string(void *arg
, char type
)
100 unsigned int ret
= 0;
104 unsigned int num
= *(unsigned int *)arg
;
113 unsigned long num
= *(unsigned long *)arg
;
121 printf("Number_to_string: Unknown number format\n");
128 static int GCC_FMT_ATTR(2, 0)
129 v9fs_string_alloc_printf(char **strp
, const char *fmt
, va_list ap
)
132 char *iter
= (char *)fmt
;
136 unsigned int arg_uint
;
137 unsigned long arg_ulong
;
139 /* Find the number of %'s that denotes an argument */
140 for (iter
= strstr(iter
, "%"); iter
; iter
= strstr(iter
, "%")) {
145 len
= strlen(fmt
) - 2*nr_args
;
155 /* Now parse the format string */
156 for (iter
= strstr(iter
, "%"); iter
; iter
= strstr(iter
, "%")) {
160 arg_uint
= va_arg(ap2
, unsigned int);
161 len
+= number_to_string((void *)&arg_uint
, 'u');
164 if (*++iter
== 'u') {
165 arg_ulong
= va_arg(ap2
, unsigned long);
166 len
+= number_to_string((void *)&arg_ulong
, 'U');
172 arg_char_ptr
= va_arg(ap2
, char *);
173 len
+= strlen(arg_char_ptr
);
180 "v9fs_string_alloc_printf:Incorrect format %c", *iter
);
187 *strp
= g_malloc((len
+ 1) * sizeof(**strp
));
189 return vsprintf(*strp
, fmt
, ap
);
192 static void GCC_FMT_ATTR(2, 3)
193 v9fs_string_sprintf(V9fsString
*str
, const char *fmt
, ...)
198 v9fs_string_free(str
);
201 err
= v9fs_string_alloc_printf(&str
->data
, fmt
, ap
);
208 static void v9fs_string_copy(V9fsString
*lhs
, V9fsString
*rhs
)
210 v9fs_string_free(lhs
);
211 v9fs_string_sprintf(lhs
, "%s", rhs
->data
);
215 * Return TRUE if s1 is an ancestor of s2.
217 * E.g. "a/b" is an ancestor of "a/b/c" but not of "a/bc/d".
218 * As a special case, We treat s1 as ancestor of s2 if they are same!
220 static int v9fs_path_is_ancestor(V9fsString
*s1
, V9fsString
*s2
)
222 if (!strncmp(s1
->data
, s2
->data
, s1
->size
)) {
223 if (s2
->data
[s1
->size
] == '\0' || s2
->data
[s1
->size
] == '/') {
230 static size_t v9fs_string_size(V9fsString
*str
)
235 static V9fsFidState
*get_fid(V9fsState
*s
, int32_t fid
)
239 for (f
= s
->fid_list
; f
; f
= f
->next
) {
249 static V9fsFidState
*alloc_fid(V9fsState
*s
, int32_t fid
)
253 for (f
= s
->fid_list
; f
; f
= f
->next
) {
254 /* If fid is already there return NULL */
260 f
= g_malloc0(sizeof(V9fsFidState
));
262 f
->fid_type
= P9_FID_NONE
;
264 f
->next
= s
->fid_list
;
270 static int v9fs_xattr_fid_clunk(V9fsState
*s
, V9fsFidState
*fidp
)
274 if (fidp
->fs
.xattr
.copied_len
== -1) {
275 /* getxattr/listxattr fid */
279 * if this is fid for setxattr. clunk should
280 * result in setxattr localcall
282 if (fidp
->fs
.xattr
.len
!= fidp
->fs
.xattr
.copied_len
) {
283 /* clunk after partial write */
287 if (fidp
->fs
.xattr
.len
) {
288 retval
= v9fs_co_lsetxattr(s
, &fidp
->path
, &fidp
->fs
.xattr
.name
,
289 fidp
->fs
.xattr
.value
,
291 fidp
->fs
.xattr
.flags
);
293 retval
= v9fs_co_lremovexattr(s
, &fidp
->path
, &fidp
->fs
.xattr
.name
);
296 v9fs_string_free(&fidp
->fs
.xattr
.name
);
298 if (fidp
->fs
.xattr
.value
) {
299 g_free(fidp
->fs
.xattr
.value
);
304 static int free_fid(V9fsState
*s
, V9fsFidState
*fidp
)
308 if (fidp
->fid_type
== P9_FID_FILE
) {
309 retval
= v9fs_co_close(s
, fidp
);
310 } else if (fidp
->fid_type
== P9_FID_DIR
) {
311 retval
= v9fs_co_closedir(s
, fidp
);
312 } else if (fidp
->fid_type
== P9_FID_XATTR
) {
313 retval
= v9fs_xattr_fid_clunk(s
, fidp
);
315 v9fs_string_free(&fidp
->path
);
320 static void put_fid(V9fsState
*s
, V9fsFidState
*fidp
)
324 if (!fidp
->ref
&& fidp
->clunked
) {
329 static int clunk_fid(V9fsState
*s
, int32_t fid
)
331 V9fsFidState
**fidpp
, *fidp
;
333 for (fidpp
= &s
->fid_list
; *fidpp
; fidpp
= &(*fidpp
)->next
) {
334 if ((*fidpp
)->fid
== fid
) {
339 if (*fidpp
== NULL
) {
348 #define P9_QID_TYPE_DIR 0x80
349 #define P9_QID_TYPE_SYMLINK 0x02
351 #define P9_STAT_MODE_DIR 0x80000000
352 #define P9_STAT_MODE_APPEND 0x40000000
353 #define P9_STAT_MODE_EXCL 0x20000000
354 #define P9_STAT_MODE_MOUNT 0x10000000
355 #define P9_STAT_MODE_AUTH 0x08000000
356 #define P9_STAT_MODE_TMP 0x04000000
357 #define P9_STAT_MODE_SYMLINK 0x02000000
358 #define P9_STAT_MODE_LINK 0x01000000
359 #define P9_STAT_MODE_DEVICE 0x00800000
360 #define P9_STAT_MODE_NAMED_PIPE 0x00200000
361 #define P9_STAT_MODE_SOCKET 0x00100000
362 #define P9_STAT_MODE_SETUID 0x00080000
363 #define P9_STAT_MODE_SETGID 0x00040000
364 #define P9_STAT_MODE_SETVTX 0x00010000
366 #define P9_STAT_MODE_TYPE_BITS (P9_STAT_MODE_DIR | \
367 P9_STAT_MODE_SYMLINK | \
368 P9_STAT_MODE_LINK | \
369 P9_STAT_MODE_DEVICE | \
370 P9_STAT_MODE_NAMED_PIPE | \
373 /* This is the algorithm from ufs in spfs */
374 static void stat_to_qid(const struct stat
*stbuf
, V9fsQID
*qidp
)
378 size
= MIN(sizeof(stbuf
->st_ino
), sizeof(qidp
->path
));
379 memcpy(&qidp
->path
, &stbuf
->st_ino
, size
);
380 qidp
->version
= stbuf
->st_mtime
^ (stbuf
->st_size
<< 8);
382 if (S_ISDIR(stbuf
->st_mode
)) {
383 qidp
->type
|= P9_QID_TYPE_DIR
;
385 if (S_ISLNK(stbuf
->st_mode
)) {
386 qidp
->type
|= P9_QID_TYPE_SYMLINK
;
390 static int fid_to_qid(V9fsState
*s
, V9fsFidState
*fidp
, V9fsQID
*qidp
)
395 err
= v9fs_co_lstat(s
, &fidp
->path
, &stbuf
);
399 stat_to_qid(&stbuf
, qidp
);
403 static V9fsPDU
*alloc_pdu(V9fsState
*s
)
407 if (!QLIST_EMPTY(&s
->free_list
)) {
408 pdu
= QLIST_FIRST(&s
->free_list
);
409 QLIST_REMOVE(pdu
, next
);
414 static void free_pdu(V9fsState
*s
, V9fsPDU
*pdu
)
420 QLIST_INSERT_HEAD(&s
->free_list
, pdu
, next
);
424 size_t pdu_packunpack(void *addr
, struct iovec
*sg
, int sg_count
,
425 size_t offset
, size_t size
, int pack
)
430 for (i
= 0; size
&& i
< sg_count
; i
++) {
432 if (offset
>= sg
[i
].iov_len
) {
434 offset
-= sg
[i
].iov_len
;
437 len
= MIN(sg
[i
].iov_len
- offset
, size
);
439 memcpy(sg
[i
].iov_base
+ offset
, addr
, len
);
441 memcpy(addr
, sg
[i
].iov_base
+ offset
, len
);
456 static size_t pdu_unpack(void *dst
, V9fsPDU
*pdu
, size_t offset
, size_t size
)
458 return pdu_packunpack(dst
, pdu
->elem
.out_sg
, pdu
->elem
.out_num
,
462 static size_t pdu_pack(V9fsPDU
*pdu
, size_t offset
, const void *src
,
465 return pdu_packunpack((void *)src
, pdu
->elem
.in_sg
, pdu
->elem
.in_num
,
469 static int pdu_copy_sg(V9fsPDU
*pdu
, size_t offset
, int rx
, struct iovec
*sg
)
473 struct iovec
*src_sg
;
477 src_sg
= pdu
->elem
.in_sg
;
478 num
= pdu
->elem
.in_num
;
480 src_sg
= pdu
->elem
.out_sg
;
481 num
= pdu
->elem
.out_num
;
485 for (i
= 0; i
< num
; i
++) {
487 sg
[j
].iov_base
= src_sg
[i
].iov_base
;
488 sg
[j
].iov_len
= src_sg
[i
].iov_len
;
490 } else if (offset
< (src_sg
[i
].iov_len
+ pos
)) {
491 sg
[j
].iov_base
= src_sg
[i
].iov_base
;
492 sg
[j
].iov_len
= src_sg
[i
].iov_len
;
493 sg
[j
].iov_base
+= (offset
- pos
);
494 sg
[j
].iov_len
-= (offset
- pos
);
497 pos
+= src_sg
[i
].iov_len
;
503 static size_t pdu_unmarshal(V9fsPDU
*pdu
, size_t offset
, const char *fmt
, ...)
505 size_t old_offset
= offset
;
510 for (i
= 0; fmt
[i
]; i
++) {
513 uint8_t *valp
= va_arg(ap
, uint8_t *);
514 offset
+= pdu_unpack(valp
, pdu
, offset
, sizeof(*valp
));
519 valp
= va_arg(ap
, uint16_t *);
520 offset
+= pdu_unpack(&val
, pdu
, offset
, sizeof(val
));
521 *valp
= le16_to_cpu(val
);
526 valp
= va_arg(ap
, uint32_t *);
527 offset
+= pdu_unpack(&val
, pdu
, offset
, sizeof(val
));
528 *valp
= le32_to_cpu(val
);
533 valp
= va_arg(ap
, uint64_t *);
534 offset
+= pdu_unpack(&val
, pdu
, offset
, sizeof(val
));
535 *valp
= le64_to_cpu(val
);
539 struct iovec
*iov
= va_arg(ap
, struct iovec
*);
540 int *iovcnt
= va_arg(ap
, int *);
541 *iovcnt
= pdu_copy_sg(pdu
, offset
, 0, iov
);
545 V9fsString
*str
= va_arg(ap
, V9fsString
*);
546 offset
+= pdu_unmarshal(pdu
, offset
, "w", &str
->size
);
547 /* FIXME: sanity check str->size */
548 str
->data
= g_malloc(str
->size
+ 1);
549 offset
+= pdu_unpack(str
->data
, pdu
, offset
, str
->size
);
550 str
->data
[str
->size
] = 0;
554 V9fsQID
*qidp
= va_arg(ap
, V9fsQID
*);
555 offset
+= pdu_unmarshal(pdu
, offset
, "bdq",
556 &qidp
->type
, &qidp
->version
, &qidp
->path
);
560 V9fsStat
*statp
= va_arg(ap
, V9fsStat
*);
561 offset
+= pdu_unmarshal(pdu
, offset
, "wwdQdddqsssssddd",
562 &statp
->size
, &statp
->type
, &statp
->dev
,
563 &statp
->qid
, &statp
->mode
, &statp
->atime
,
564 &statp
->mtime
, &statp
->length
,
565 &statp
->name
, &statp
->uid
, &statp
->gid
,
566 &statp
->muid
, &statp
->extension
,
567 &statp
->n_uid
, &statp
->n_gid
,
572 V9fsIattr
*iattr
= va_arg(ap
, V9fsIattr
*);
573 offset
+= pdu_unmarshal(pdu
, offset
, "ddddqqqqq",
574 &iattr
->valid
, &iattr
->mode
,
575 &iattr
->uid
, &iattr
->gid
, &iattr
->size
,
576 &iattr
->atime_sec
, &iattr
->atime_nsec
,
577 &iattr
->mtime_sec
, &iattr
->mtime_nsec
);
587 return offset
- old_offset
;
590 static size_t pdu_marshal(V9fsPDU
*pdu
, size_t offset
, const char *fmt
, ...)
592 size_t old_offset
= offset
;
597 for (i
= 0; fmt
[i
]; i
++) {
600 uint8_t val
= va_arg(ap
, int);
601 offset
+= pdu_pack(pdu
, offset
, &val
, sizeof(val
));
606 cpu_to_le16w(&val
, va_arg(ap
, int));
607 offset
+= pdu_pack(pdu
, offset
, &val
, sizeof(val
));
612 cpu_to_le32w(&val
, va_arg(ap
, uint32_t));
613 offset
+= pdu_pack(pdu
, offset
, &val
, sizeof(val
));
618 cpu_to_le64w(&val
, va_arg(ap
, uint64_t));
619 offset
+= pdu_pack(pdu
, offset
, &val
, sizeof(val
));
623 struct iovec
*iov
= va_arg(ap
, struct iovec
*);
624 int *iovcnt
= va_arg(ap
, int *);
625 *iovcnt
= pdu_copy_sg(pdu
, offset
, 1, iov
);
629 V9fsString
*str
= va_arg(ap
, V9fsString
*);
630 offset
+= pdu_marshal(pdu
, offset
, "w", str
->size
);
631 offset
+= pdu_pack(pdu
, offset
, str
->data
, str
->size
);
635 V9fsQID
*qidp
= va_arg(ap
, V9fsQID
*);
636 offset
+= pdu_marshal(pdu
, offset
, "bdq",
637 qidp
->type
, qidp
->version
, qidp
->path
);
641 V9fsStat
*statp
= va_arg(ap
, V9fsStat
*);
642 offset
+= pdu_marshal(pdu
, offset
, "wwdQdddqsssssddd",
643 statp
->size
, statp
->type
, statp
->dev
,
644 &statp
->qid
, statp
->mode
, statp
->atime
,
645 statp
->mtime
, statp
->length
, &statp
->name
,
646 &statp
->uid
, &statp
->gid
, &statp
->muid
,
647 &statp
->extension
, statp
->n_uid
,
648 statp
->n_gid
, statp
->n_muid
);
652 V9fsStatDotl
*statp
= va_arg(ap
, V9fsStatDotl
*);
653 offset
+= pdu_marshal(pdu
, offset
, "qQdddqqqqqqqqqqqqqqq",
654 statp
->st_result_mask
,
655 &statp
->qid
, statp
->st_mode
,
656 statp
->st_uid
, statp
->st_gid
,
657 statp
->st_nlink
, statp
->st_rdev
,
658 statp
->st_size
, statp
->st_blksize
, statp
->st_blocks
,
659 statp
->st_atime_sec
, statp
->st_atime_nsec
,
660 statp
->st_mtime_sec
, statp
->st_mtime_nsec
,
661 statp
->st_ctime_sec
, statp
->st_ctime_nsec
,
662 statp
->st_btime_sec
, statp
->st_btime_nsec
,
663 statp
->st_gen
, statp
->st_data_version
);
672 return offset
- old_offset
;
675 static void complete_pdu(V9fsState
*s
, V9fsPDU
*pdu
, ssize_t len
)
677 int8_t id
= pdu
->id
+ 1; /* Response */
683 if (s
->proto_version
!= V9FS_PROTO_2000L
) {
686 str
.data
= strerror(err
);
687 str
.size
= strlen(str
.data
);
689 len
+= pdu_marshal(pdu
, len
, "s", &str
);
693 len
+= pdu_marshal(pdu
, len
, "d", err
);
695 if (s
->proto_version
== V9FS_PROTO_2000L
) {
700 /* fill out the header */
701 pdu_marshal(pdu
, 0, "dbw", (int32_t)len
, id
, pdu
->tag
);
703 /* keep these in sync */
707 /* push onto queue and notify */
708 virtqueue_push(s
->vq
, &pdu
->elem
, len
);
710 /* FIXME: we should batch these completions */
711 virtio_notify(&s
->vdev
, s
->vq
);
716 static mode_t
v9mode_to_mode(uint32_t mode
, V9fsString
*extension
)
721 if (mode
& P9_STAT_MODE_DIR
) {
725 if (mode
& P9_STAT_MODE_SYMLINK
) {
728 if (mode
& P9_STAT_MODE_SOCKET
) {
731 if (mode
& P9_STAT_MODE_NAMED_PIPE
) {
734 if (mode
& P9_STAT_MODE_DEVICE
) {
735 if (extension
&& extension
->data
[0] == 'c') {
746 if (mode
& P9_STAT_MODE_SETUID
) {
749 if (mode
& P9_STAT_MODE_SETGID
) {
752 if (mode
& P9_STAT_MODE_SETVTX
) {
759 static int donttouch_stat(V9fsStat
*stat
)
761 if (stat
->type
== -1 &&
763 stat
->qid
.type
== -1 &&
764 stat
->qid
.version
== -1 &&
765 stat
->qid
.path
== -1 &&
769 stat
->length
== -1 &&
776 stat
->n_muid
== -1) {
783 static void v9fs_stat_free(V9fsStat
*stat
)
785 v9fs_string_free(&stat
->name
);
786 v9fs_string_free(&stat
->uid
);
787 v9fs_string_free(&stat
->gid
);
788 v9fs_string_free(&stat
->muid
);
789 v9fs_string_free(&stat
->extension
);
792 static uint32_t stat_to_v9mode(const struct stat
*stbuf
)
796 mode
= stbuf
->st_mode
& 0777;
797 if (S_ISDIR(stbuf
->st_mode
)) {
798 mode
|= P9_STAT_MODE_DIR
;
801 if (S_ISLNK(stbuf
->st_mode
)) {
802 mode
|= P9_STAT_MODE_SYMLINK
;
805 if (S_ISSOCK(stbuf
->st_mode
)) {
806 mode
|= P9_STAT_MODE_SOCKET
;
809 if (S_ISFIFO(stbuf
->st_mode
)) {
810 mode
|= P9_STAT_MODE_NAMED_PIPE
;
813 if (S_ISBLK(stbuf
->st_mode
) || S_ISCHR(stbuf
->st_mode
)) {
814 mode
|= P9_STAT_MODE_DEVICE
;
817 if (stbuf
->st_mode
& S_ISUID
) {
818 mode
|= P9_STAT_MODE_SETUID
;
821 if (stbuf
->st_mode
& S_ISGID
) {
822 mode
|= P9_STAT_MODE_SETGID
;
825 if (stbuf
->st_mode
& S_ISVTX
) {
826 mode
|= P9_STAT_MODE_SETVTX
;
832 static int stat_to_v9stat(V9fsState
*s
, V9fsString
*name
,
833 const struct stat
*stbuf
,
839 memset(v9stat
, 0, sizeof(*v9stat
));
841 stat_to_qid(stbuf
, &v9stat
->qid
);
842 v9stat
->mode
= stat_to_v9mode(stbuf
);
843 v9stat
->atime
= stbuf
->st_atime
;
844 v9stat
->mtime
= stbuf
->st_mtime
;
845 v9stat
->length
= stbuf
->st_size
;
847 v9fs_string_null(&v9stat
->uid
);
848 v9fs_string_null(&v9stat
->gid
);
849 v9fs_string_null(&v9stat
->muid
);
851 v9stat
->n_uid
= stbuf
->st_uid
;
852 v9stat
->n_gid
= stbuf
->st_gid
;
855 v9fs_string_null(&v9stat
->extension
);
857 if (v9stat
->mode
& P9_STAT_MODE_SYMLINK
) {
858 err
= v9fs_co_readlink(s
, name
, &v9stat
->extension
);
862 } else if (v9stat
->mode
& P9_STAT_MODE_DEVICE
) {
863 v9fs_string_sprintf(&v9stat
->extension
, "%c %u %u",
864 S_ISCHR(stbuf
->st_mode
) ? 'c' : 'b',
865 major(stbuf
->st_rdev
), minor(stbuf
->st_rdev
));
866 } else if (S_ISDIR(stbuf
->st_mode
) || S_ISREG(stbuf
->st_mode
)) {
867 v9fs_string_sprintf(&v9stat
->extension
, "%s %lu",
868 "HARDLINKCOUNT", (unsigned long)stbuf
->st_nlink
);
871 str
= strrchr(name
->data
, '/');
878 v9fs_string_sprintf(&v9stat
->name
, "%s", str
);
881 v9fs_string_size(&v9stat
->name
) +
882 v9fs_string_size(&v9stat
->uid
) +
883 v9fs_string_size(&v9stat
->gid
) +
884 v9fs_string_size(&v9stat
->muid
) +
885 v9fs_string_size(&v9stat
->extension
);
889 #define P9_STATS_MODE 0x00000001ULL
890 #define P9_STATS_NLINK 0x00000002ULL
891 #define P9_STATS_UID 0x00000004ULL
892 #define P9_STATS_GID 0x00000008ULL
893 #define P9_STATS_RDEV 0x00000010ULL
894 #define P9_STATS_ATIME 0x00000020ULL
895 #define P9_STATS_MTIME 0x00000040ULL
896 #define P9_STATS_CTIME 0x00000080ULL
897 #define P9_STATS_INO 0x00000100ULL
898 #define P9_STATS_SIZE 0x00000200ULL
899 #define P9_STATS_BLOCKS 0x00000400ULL
901 #define P9_STATS_BTIME 0x00000800ULL
902 #define P9_STATS_GEN 0x00001000ULL
903 #define P9_STATS_DATA_VERSION 0x00002000ULL
905 #define P9_STATS_BASIC 0x000007ffULL /* Mask for fields up to BLOCKS */
906 #define P9_STATS_ALL 0x00003fffULL /* Mask for All fields above */
909 static void stat_to_v9stat_dotl(V9fsState
*s
, const struct stat
*stbuf
,
910 V9fsStatDotl
*v9lstat
)
912 memset(v9lstat
, 0, sizeof(*v9lstat
));
914 v9lstat
->st_mode
= stbuf
->st_mode
;
915 v9lstat
->st_nlink
= stbuf
->st_nlink
;
916 v9lstat
->st_uid
= stbuf
->st_uid
;
917 v9lstat
->st_gid
= stbuf
->st_gid
;
918 v9lstat
->st_rdev
= stbuf
->st_rdev
;
919 v9lstat
->st_size
= stbuf
->st_size
;
920 v9lstat
->st_blksize
= stbuf
->st_blksize
;
921 v9lstat
->st_blocks
= stbuf
->st_blocks
;
922 v9lstat
->st_atime_sec
= stbuf
->st_atime
;
923 v9lstat
->st_atime_nsec
= stbuf
->st_atim
.tv_nsec
;
924 v9lstat
->st_mtime_sec
= stbuf
->st_mtime
;
925 v9lstat
->st_mtime_nsec
= stbuf
->st_mtim
.tv_nsec
;
926 v9lstat
->st_ctime_sec
= stbuf
->st_ctime
;
927 v9lstat
->st_ctime_nsec
= stbuf
->st_ctim
.tv_nsec
;
928 /* Currently we only support BASIC fields in stat */
929 v9lstat
->st_result_mask
= P9_STATS_BASIC
;
931 stat_to_qid(stbuf
, &v9lstat
->qid
);
934 static struct iovec
*adjust_sg(struct iovec
*sg
, int len
, int *iovcnt
)
936 while (len
&& *iovcnt
) {
937 if (len
< sg
->iov_len
) {
951 static struct iovec
*cap_sg(struct iovec
*sg
, int cap
, int *cnt
)
956 for (i
= 0; i
< *cnt
; i
++) {
957 if ((total
+ sg
[i
].iov_len
) > cap
) {
958 sg
[i
].iov_len
-= ((total
+ sg
[i
].iov_len
) - cap
);
962 total
+= sg
[i
].iov_len
;
970 static void print_sg(struct iovec
*sg
, int cnt
)
974 printf("sg[%d]: {", cnt
);
975 for (i
= 0; i
< cnt
; i
++) {
979 printf("(%p, %zd)", sg
[i
].iov_base
, sg
[i
].iov_len
);
984 static void v9fs_fix_path(V9fsString
*dst
, V9fsString
*src
, int len
)
987 v9fs_string_init(&str
);
988 v9fs_string_copy(&str
, dst
);
989 v9fs_string_sprintf(dst
, "%s%s", src
->data
, str
.data
+len
);
990 v9fs_string_free(&str
);
993 static void v9fs_version(void *opaque
)
995 V9fsPDU
*pdu
= opaque
;
996 V9fsState
*s
= pdu
->s
;
1000 pdu_unmarshal(pdu
, offset
, "ds", &s
->msize
, &version
);
1002 if (!strcmp(version
.data
, "9P2000.u")) {
1003 s
->proto_version
= V9FS_PROTO_2000U
;
1004 } else if (!strcmp(version
.data
, "9P2000.L")) {
1005 s
->proto_version
= V9FS_PROTO_2000L
;
1007 v9fs_string_sprintf(&version
, "unknown");
1010 offset
+= pdu_marshal(pdu
, offset
, "ds", s
->msize
, &version
);
1011 complete_pdu(s
, pdu
, offset
);
1013 v9fs_string_free(&version
);
1017 static void v9fs_attach(void *opaque
)
1019 V9fsPDU
*pdu
= opaque
;
1020 V9fsState
*s
= pdu
->s
;
1021 int32_t fid
, afid
, n_uname
;
1022 V9fsString uname
, aname
;
1028 pdu_unmarshal(pdu
, offset
, "ddssd", &fid
, &afid
, &uname
, &aname
, &n_uname
);
1030 fidp
= alloc_fid(s
, fid
);
1035 fidp
->uid
= n_uname
;
1036 v9fs_string_sprintf(&fidp
->path
, "%s", "/");
1037 err
= fid_to_qid(s
, fidp
, &qid
);
1043 offset
+= pdu_marshal(pdu
, offset
, "Q", &qid
);
1048 complete_pdu(s
, pdu
, err
);
1049 v9fs_string_free(&uname
);
1050 v9fs_string_free(&aname
);
1053 static void v9fs_stat(void *opaque
)
1061 V9fsPDU
*pdu
= opaque
;
1062 V9fsState
*s
= pdu
->s
;
1064 pdu_unmarshal(pdu
, offset
, "d", &fid
);
1066 fidp
= get_fid(s
, fid
);
1071 err
= v9fs_co_lstat(s
, &fidp
->path
, &stbuf
);
1075 err
= stat_to_v9stat(s
, &fidp
->path
, &stbuf
, &v9stat
);
1079 offset
+= pdu_marshal(pdu
, offset
, "wS", 0, &v9stat
);
1081 v9fs_stat_free(&v9stat
);
1085 complete_pdu(s
, pdu
, err
);
1088 static void v9fs_getattr(void *opaque
)
1095 uint64_t request_mask
;
1096 V9fsStatDotl v9stat_dotl
;
1097 V9fsPDU
*pdu
= opaque
;
1098 V9fsState
*s
= pdu
->s
;
1100 pdu_unmarshal(pdu
, offset
, "dq", &fid
, &request_mask
);
1102 fidp
= get_fid(s
, fid
);
1108 * Currently we only support BASIC fields in stat, so there is no
1109 * need to look at request_mask.
1111 retval
= v9fs_co_lstat(s
, &fidp
->path
, &stbuf
);
1115 stat_to_v9stat_dotl(s
, &stbuf
, &v9stat_dotl
);
1117 retval
+= pdu_marshal(pdu
, offset
, "A", &v9stat_dotl
);
1121 complete_pdu(s
, pdu
, retval
);
1124 /* From Linux kernel code */
1125 #define ATTR_MODE (1 << 0)
1126 #define ATTR_UID (1 << 1)
1127 #define ATTR_GID (1 << 2)
1128 #define ATTR_SIZE (1 << 3)
1129 #define ATTR_ATIME (1 << 4)
1130 #define ATTR_MTIME (1 << 5)
1131 #define ATTR_CTIME (1 << 6)
1132 #define ATTR_MASK 127
1133 #define ATTR_ATIME_SET (1 << 7)
1134 #define ATTR_MTIME_SET (1 << 8)
1136 static void v9fs_setattr(void *opaque
)
1143 V9fsPDU
*pdu
= opaque
;
1144 V9fsState
*s
= pdu
->s
;
1146 pdu_unmarshal(pdu
, offset
, "dI", &fid
, &v9iattr
);
1148 fidp
= get_fid(s
, fid
);
1153 if (v9iattr
.valid
& ATTR_MODE
) {
1154 err
= v9fs_co_chmod(s
, &fidp
->path
, v9iattr
.mode
);
1159 if (v9iattr
.valid
& (ATTR_ATIME
| ATTR_MTIME
)) {
1160 struct timespec times
[2];
1161 if (v9iattr
.valid
& ATTR_ATIME
) {
1162 if (v9iattr
.valid
& ATTR_ATIME_SET
) {
1163 times
[0].tv_sec
= v9iattr
.atime_sec
;
1164 times
[0].tv_nsec
= v9iattr
.atime_nsec
;
1166 times
[0].tv_nsec
= UTIME_NOW
;
1169 times
[0].tv_nsec
= UTIME_OMIT
;
1171 if (v9iattr
.valid
& ATTR_MTIME
) {
1172 if (v9iattr
.valid
& ATTR_MTIME_SET
) {
1173 times
[1].tv_sec
= v9iattr
.mtime_sec
;
1174 times
[1].tv_nsec
= v9iattr
.mtime_nsec
;
1176 times
[1].tv_nsec
= UTIME_NOW
;
1179 times
[1].tv_nsec
= UTIME_OMIT
;
1181 err
= v9fs_co_utimensat(s
, &fidp
->path
, times
);
1187 * If the only valid entry in iattr is ctime we can call
1188 * chown(-1,-1) to update the ctime of the file
1190 if ((v9iattr
.valid
& (ATTR_UID
| ATTR_GID
)) ||
1191 ((v9iattr
.valid
& ATTR_CTIME
)
1192 && !((v9iattr
.valid
& ATTR_MASK
) & ~ATTR_CTIME
))) {
1193 if (!(v9iattr
.valid
& ATTR_UID
)) {
1196 if (!(v9iattr
.valid
& ATTR_GID
)) {
1199 err
= v9fs_co_chown(s
, &fidp
->path
, v9iattr
.uid
,
1205 if (v9iattr
.valid
& (ATTR_SIZE
)) {
1206 err
= v9fs_co_truncate(s
, &fidp
->path
, v9iattr
.size
);
1215 complete_pdu(s
, pdu
, err
);
1218 static int v9fs_walk_marshal(V9fsPDU
*pdu
, uint16_t nwnames
, V9fsQID
*qids
)
1222 offset
+= pdu_marshal(pdu
, offset
, "w", nwnames
);
1223 for (i
= 0; i
< nwnames
; i
++) {
1224 offset
+= pdu_marshal(pdu
, offset
, "Q", &qids
[i
]);
1229 static void v9fs_walk(void *opaque
)
1232 V9fsQID
*qids
= NULL
;
1238 int32_t fid
, newfid
;
1239 V9fsString
*wnames
= NULL
;
1241 V9fsFidState
*newfidp
= NULL
;;
1242 V9fsPDU
*pdu
= opaque
;
1243 V9fsState
*s
= pdu
->s
;
1245 offset
+= pdu_unmarshal(pdu
, offset
, "ddw", &fid
,
1248 if (nwnames
&& nwnames
<= P9_MAXWELEM
) {
1249 wnames
= g_malloc0(sizeof(wnames
[0]) * nwnames
);
1250 qids
= g_malloc0(sizeof(qids
[0]) * nwnames
);
1251 for (i
= 0; i
< nwnames
; i
++) {
1252 offset
+= pdu_unmarshal(pdu
, offset
, "s", &wnames
[i
]);
1255 } else if (nwnames
> P9_MAXWELEM
) {
1259 fidp
= get_fid(s
, fid
);
1264 if (fid
== newfid
) {
1265 BUG_ON(fidp
->fid_type
!= P9_FID_NONE
);
1266 v9fs_string_init(&path
);
1267 for (name_idx
= 0; name_idx
< nwnames
; name_idx
++) {
1268 v9fs_string_sprintf(&path
, "%s/%s",
1269 fidp
->path
.data
, wnames
[name_idx
].data
);
1270 v9fs_string_copy(&fidp
->path
, &path
);
1272 err
= v9fs_co_lstat(s
, &fidp
->path
, &stbuf
);
1274 v9fs_string_free(&path
);
1277 stat_to_qid(&stbuf
, &qids
[name_idx
]);
1279 v9fs_string_free(&path
);
1281 newfidp
= alloc_fid(s
, newfid
);
1282 if (newfidp
== NULL
) {
1286 newfidp
->uid
= fidp
->uid
;
1287 v9fs_string_init(&path
);
1288 v9fs_string_copy(&newfidp
->path
, &fidp
->path
);
1289 for (name_idx
= 0; name_idx
< nwnames
; name_idx
++) {
1290 v9fs_string_sprintf(&path
, "%s/%s", newfidp
->path
.data
,
1291 wnames
[name_idx
].data
);
1292 v9fs_string_copy(&newfidp
->path
, &path
);
1293 err
= v9fs_co_lstat(s
, &newfidp
->path
, &stbuf
);
1295 clunk_fid(s
, newfidp
->fid
);
1296 v9fs_string_free(&path
);
1299 stat_to_qid(&stbuf
, &qids
[name_idx
]);
1301 v9fs_string_free(&path
);
1303 err
= v9fs_walk_marshal(pdu
, nwnames
, qids
);
1307 put_fid(s
, newfidp
);
1310 complete_pdu(s
, pdu
, err
);
1311 if (nwnames
&& nwnames
<= P9_MAXWELEM
) {
1312 for (name_idx
= 0; name_idx
< nwnames
; name_idx
++) {
1313 v9fs_string_free(&wnames
[name_idx
]);
1320 static int32_t get_iounit(V9fsState
*s
, V9fsString
*name
)
1322 struct statfs stbuf
;
1326 * iounit should be multiples of f_bsize (host filesystem block size
1327 * and as well as less than (client msize - P9_IOHDRSZ))
1329 if (!v9fs_co_statfs(s
, name
, &stbuf
)) {
1330 iounit
= stbuf
.f_bsize
;
1331 iounit
*= (s
->msize
- P9_IOHDRSZ
)/stbuf
.f_bsize
;
1334 iounit
= s
->msize
- P9_IOHDRSZ
;
1339 static void v9fs_open(void *opaque
)
1350 V9fsPDU
*pdu
= opaque
;
1351 V9fsState
*s
= pdu
->s
;
1353 if (s
->proto_version
== V9FS_PROTO_2000L
) {
1354 pdu_unmarshal(pdu
, offset
, "dd", &fid
, &mode
);
1356 pdu_unmarshal(pdu
, offset
, "db", &fid
, &mode
);
1358 fidp
= get_fid(s
, fid
);
1363 BUG_ON(fidp
->fid_type
!= P9_FID_NONE
);
1365 err
= v9fs_co_lstat(s
, &fidp
->path
, &stbuf
);
1369 stat_to_qid(&stbuf
, &qid
);
1370 if (S_ISDIR(stbuf
.st_mode
)) {
1371 err
= v9fs_co_opendir(s
, fidp
);
1375 fidp
->fid_type
= P9_FID_DIR
;
1376 offset
+= pdu_marshal(pdu
, offset
, "Qd", &qid
, 0);
1379 if (s
->proto_version
== V9FS_PROTO_2000L
) {
1381 flags
&= ~(O_NOCTTY
| O_ASYNC
| O_CREAT
);
1382 /* Ignore direct disk access hint until the server supports it. */
1385 flags
= omode_to_uflags(mode
);
1387 err
= v9fs_co_open(s
, fidp
, flags
);
1391 fidp
->fid_type
= P9_FID_FILE
;
1392 iounit
= get_iounit(s
, &fidp
->path
);
1393 offset
+= pdu_marshal(pdu
, offset
, "Qd", &qid
, iounit
);
1399 complete_pdu(s
, pdu
, err
);
1402 static void v9fs_lcreate(void *opaque
)
1404 int32_t dfid
, flags
, mode
;
1408 V9fsString fullname
;
1414 V9fsPDU
*pdu
= opaque
;
1416 v9fs_string_init(&fullname
);
1417 pdu_unmarshal(pdu
, offset
, "dsddd", &dfid
, &name
, &flags
,
1420 fidp
= get_fid(pdu
->s
, dfid
);
1425 v9fs_string_sprintf(&fullname
, "%s/%s", fidp
->path
.data
, name
.data
);
1427 /* Ignore direct disk access hint until the server supports it. */
1430 err
= v9fs_co_open2(pdu
->s
, fidp
, fullname
.data
, gid
, flags
, mode
);
1434 fidp
->fid_type
= P9_FID_FILE
;
1435 iounit
= get_iounit(pdu
->s
, &fullname
);
1437 err
= v9fs_co_lstat(pdu
->s
, &fullname
, &stbuf
);
1439 fidp
->fid_type
= P9_FID_NONE
;
1440 if (fidp
->fs
.fd
> 0) {
1445 v9fs_string_copy(&fidp
->path
, &fullname
);
1446 stat_to_qid(&stbuf
, &qid
);
1447 offset
+= pdu_marshal(pdu
, offset
, "Qd", &qid
, iounit
);
1450 put_fid(pdu
->s
, fidp
);
1452 complete_pdu(pdu
->s
, pdu
, err
);
1453 v9fs_string_free(&name
);
1454 v9fs_string_free(&fullname
);
1457 static void v9fs_fsync(void *opaque
)
1464 V9fsPDU
*pdu
= opaque
;
1465 V9fsState
*s
= pdu
->s
;
1467 pdu_unmarshal(pdu
, offset
, "dd", &fid
, &datasync
);
1468 fidp
= get_fid(s
, fid
);
1473 err
= v9fs_co_fsync(s
, fidp
, datasync
);
1479 complete_pdu(s
, pdu
, err
);
1482 static void v9fs_clunk(void *opaque
)
1488 V9fsPDU
*pdu
= opaque
;
1489 V9fsState
*s
= pdu
->s
;
1491 pdu_unmarshal(pdu
, offset
, "d", &fid
);
1493 fidp
= get_fid(s
, fid
);
1498 err
= clunk_fid(s
, fidp
->fid
);
1506 complete_pdu(s
, pdu
, err
);
1509 static int v9fs_xattr_read(V9fsState
*s
, V9fsPDU
*pdu
,
1510 V9fsFidState
*fidp
, int64_t off
, int32_t max_count
)
1516 xattr_len
= fidp
->fs
.xattr
.len
;
1517 read_count
= xattr_len
- off
;
1518 if (read_count
> max_count
) {
1519 read_count
= max_count
;
1520 } else if (read_count
< 0) {
1522 * read beyond XATTR value
1526 offset
+= pdu_marshal(pdu
, offset
, "d", read_count
);
1527 offset
+= pdu_pack(pdu
, offset
,
1528 ((char *)fidp
->fs
.xattr
.value
) + off
,
1533 static int v9fs_do_readdir_with_stat(V9fsState
*s
, V9fsPDU
*pdu
,
1534 V9fsFidState
*fidp
, int32_t max_count
)
1541 off_t saved_dir_pos
;
1542 struct dirent
*dent
, *result
;
1544 /* save the directory position */
1545 saved_dir_pos
= v9fs_co_telldir(s
, fidp
);
1546 if (saved_dir_pos
< 0) {
1547 return saved_dir_pos
;
1550 dent
= g_malloc(sizeof(struct dirent
));
1553 v9fs_string_init(&name
);
1554 err
= v9fs_co_readdir_r(s
, fidp
, dent
, &result
);
1555 if (err
|| !result
) {
1558 v9fs_string_sprintf(&name
, "%s/%s", fidp
->path
.data
, dent
->d_name
);
1559 err
= v9fs_co_lstat(s
, &name
, &stbuf
);
1563 err
= stat_to_v9stat(s
, &name
, &stbuf
, &v9stat
);
1567 /* 11 = 7 + 4 (7 = start offset, 4 = space for storing count) */
1568 len
= pdu_marshal(pdu
, 11 + count
, "S", &v9stat
);
1569 if ((len
!= (v9stat
.size
+ 2)) || ((count
+ len
) > max_count
)) {
1570 /* Ran out of buffer. Set dir back to old position and return */
1571 v9fs_co_seekdir(s
, fidp
, saved_dir_pos
);
1572 v9fs_stat_free(&v9stat
);
1573 v9fs_string_free(&name
);
1578 v9fs_stat_free(&v9stat
);
1579 v9fs_string_free(&name
);
1580 saved_dir_pos
= dent
->d_off
;
1584 v9fs_string_free(&name
);
1591 static void v9fs_read(void *opaque
)
1600 V9fsPDU
*pdu
= opaque
;
1601 V9fsState
*s
= pdu
->s
;
1603 pdu_unmarshal(pdu
, offset
, "dqd", &fid
, &off
, &max_count
);
1605 fidp
= get_fid(s
, fid
);
1610 if (fidp
->fid_type
== P9_FID_DIR
) {
1613 v9fs_co_rewinddir(s
, fidp
);
1615 count
= v9fs_do_readdir_with_stat(s
, pdu
, fidp
, max_count
);
1621 err
+= pdu_marshal(pdu
, offset
, "d", count
);
1623 } else if (fidp
->fid_type
== P9_FID_FILE
) {
1627 struct iovec iov
[128]; /* FIXME: bad, bad, bad */
1630 pdu_marshal(pdu
, offset
+ 4, "v", sg
, &cnt
);
1631 sg
= cap_sg(sg
, max_count
, &cnt
);
1636 /* Loop in case of EINTR */
1638 len
= v9fs_co_preadv(s
, fidp
, sg
, cnt
, off
);
1643 } while (len
== -EINTR
);
1645 /* IO error return the error */
1649 sg
= adjust_sg(sg
, len
, &cnt
);
1650 } while (count
< max_count
&& len
> 0);
1652 err
+= pdu_marshal(pdu
, offset
, "d", count
);
1654 } else if (fidp
->fid_type
== P9_FID_XATTR
) {
1655 err
= v9fs_xattr_read(s
, pdu
, fidp
, off
, max_count
);
1662 complete_pdu(s
, pdu
, err
);
1665 static size_t v9fs_readdir_data_size(V9fsString
*name
)
1668 * Size of each dirent on the wire: size of qid (13) + size of offset (8)
1669 * size of type (1) + size of name.size (2) + strlen(name.data)
1671 return 24 + v9fs_string_size(name
);
1674 static int v9fs_do_readdir(V9fsState
*s
, V9fsPDU
*pdu
,
1675 V9fsFidState
*fidp
, int32_t max_count
)
1682 off_t saved_dir_pos
;
1683 struct dirent
*dent
, *result
;
1685 /* save the directory position */
1686 saved_dir_pos
= v9fs_co_telldir(s
, fidp
);
1687 if (saved_dir_pos
< 0) {
1688 return saved_dir_pos
;
1691 dent
= g_malloc(sizeof(struct dirent
));
1694 err
= v9fs_co_readdir_r(s
, fidp
, dent
, &result
);
1695 if (err
|| !result
) {
1698 v9fs_string_init(&name
);
1699 v9fs_string_sprintf(&name
, "%s", dent
->d_name
);
1700 if ((count
+ v9fs_readdir_data_size(&name
)) > max_count
) {
1701 /* Ran out of buffer. Set dir back to old position and return */
1702 v9fs_co_seekdir(s
, fidp
, saved_dir_pos
);
1703 v9fs_string_free(&name
);
1708 * Fill up just the path field of qid because the client uses
1709 * only that. To fill the entire qid structure we will have
1710 * to stat each dirent found, which is expensive
1712 size
= MIN(sizeof(dent
->d_ino
), sizeof(qid
.path
));
1713 memcpy(&qid
.path
, &dent
->d_ino
, size
);
1714 /* Fill the other fields with dummy values */
1718 /* 11 = 7 + 4 (7 = start offset, 4 = space for storing count) */
1719 len
= pdu_marshal(pdu
, 11 + count
, "Qqbs",
1721 dent
->d_type
, &name
);
1723 v9fs_string_free(&name
);
1724 saved_dir_pos
= dent
->d_off
;
1733 static void v9fs_readdir(void *opaque
)
1739 int64_t initial_offset
;
1740 int32_t count
, max_count
;
1741 V9fsPDU
*pdu
= opaque
;
1742 V9fsState
*s
= pdu
->s
;
1744 pdu_unmarshal(pdu
, offset
, "dqd", &fid
, &initial_offset
, &max_count
);
1746 fidp
= get_fid(s
, fid
);
1751 if (!fidp
->fs
.dir
) {
1755 if (initial_offset
== 0) {
1756 v9fs_co_rewinddir(s
, fidp
);
1758 v9fs_co_seekdir(s
, fidp
, initial_offset
);
1760 count
= v9fs_do_readdir(s
, pdu
, fidp
, max_count
);
1766 retval
+= pdu_marshal(pdu
, offset
, "d", count
);
1771 complete_pdu(s
, pdu
, retval
);
1774 static int v9fs_xattr_write(V9fsState
*s
, V9fsPDU
*pdu
, V9fsFidState
*fidp
,
1775 int64_t off
, int32_t count
,
1776 struct iovec
*sg
, int cnt
)
1785 xattr_len
= fidp
->fs
.xattr
.len
;
1786 write_count
= xattr_len
- off
;
1787 if (write_count
> count
) {
1788 write_count
= count
;
1789 } else if (write_count
< 0) {
1791 * write beyond XATTR value len specified in
1797 offset
+= pdu_marshal(pdu
, offset
, "d", write_count
);
1799 fidp
->fs
.xattr
.copied_len
+= write_count
;
1801 * Now copy the content from sg list
1803 for (i
= 0; i
< cnt
; i
++) {
1804 if (write_count
> sg
[i
].iov_len
) {
1805 to_copy
= sg
[i
].iov_len
;
1807 to_copy
= write_count
;
1809 memcpy((char *)fidp
->fs
.xattr
.value
+ off
, sg
[i
].iov_base
, to_copy
);
1810 /* updating vs->off since we are not using below */
1812 write_count
-= to_copy
;
1818 static void v9fs_write(void *opaque
)
1829 struct iovec iov
[128]; /* FIXME: bad, bad, bad */
1830 struct iovec
*sg
= iov
;
1831 V9fsPDU
*pdu
= opaque
;
1832 V9fsState
*s
= pdu
->s
;
1834 pdu_unmarshal(pdu
, offset
, "dqdv", &fid
, &off
, &count
, sg
, &cnt
);
1836 fidp
= get_fid(s
, fid
);
1841 if (fidp
->fid_type
== P9_FID_FILE
) {
1842 if (fidp
->fs
.fd
== -1) {
1846 } else if (fidp
->fid_type
== P9_FID_XATTR
) {
1848 * setxattr operation
1850 err
= v9fs_xattr_write(s
, pdu
, fidp
, off
, count
, sg
, cnt
);
1856 sg
= cap_sg(sg
, count
, &cnt
);
1861 /* Loop in case of EINTR */
1863 len
= v9fs_co_pwritev(s
, fidp
, sg
, cnt
, off
);
1868 } while (len
== -EINTR
);
1870 /* IO error return the error */
1874 sg
= adjust_sg(sg
, len
, &cnt
);
1875 } while (total
< count
&& len
> 0);
1876 offset
+= pdu_marshal(pdu
, offset
, "d", total
);
1881 complete_pdu(s
, pdu
, err
);
1884 static void v9fs_create(void *opaque
)
1895 V9fsString extension
;
1896 V9fsString fullname
;
1898 V9fsPDU
*pdu
= opaque
;
1900 v9fs_string_init(&fullname
);
1902 pdu_unmarshal(pdu
, offset
, "dsdbs", &fid
, &name
,
1903 &perm
, &mode
, &extension
);
1905 fidp
= get_fid(pdu
->s
, fid
);
1911 v9fs_string_sprintf(&fullname
, "%s/%s", fidp
->path
.data
, name
.data
);
1912 err
= v9fs_co_lstat(pdu
->s
, &fullname
, &stbuf
);
1916 } else if (err
!= -ENOENT
) {
1919 if (perm
& P9_STAT_MODE_DIR
) {
1920 err
= v9fs_co_mkdir(pdu
->s
, fullname
.data
, perm
& 0777,
1925 err
= v9fs_co_opendir(pdu
->s
, fidp
);
1929 fidp
->fid_type
= P9_FID_DIR
;
1930 } else if (perm
& P9_STAT_MODE_SYMLINK
) {
1931 err
= v9fs_co_symlink(pdu
->s
, fidp
, extension
.data
,
1936 } else if (perm
& P9_STAT_MODE_LINK
) {
1937 int32_t nfid
= atoi(extension
.data
);
1938 V9fsFidState
*nfidp
= get_fid(pdu
->s
, nfid
);
1939 if (nfidp
== NULL
) {
1943 err
= v9fs_co_link(pdu
->s
, &nfidp
->path
, &fullname
);
1945 put_fid(pdu
->s
, nfidp
);
1948 put_fid(pdu
->s
, nfidp
);
1949 } else if (perm
& P9_STAT_MODE_DEVICE
) {
1951 uint32_t major
, minor
;
1954 if (sscanf(extension
.data
, "%c %u %u", &ctype
, &major
, &minor
) != 3) {
1971 nmode
|= perm
& 0777;
1972 err
= v9fs_co_mknod(pdu
->s
, &fullname
, fidp
->uid
, -1,
1973 makedev(major
, minor
), nmode
);
1977 } else if (perm
& P9_STAT_MODE_NAMED_PIPE
) {
1978 err
= v9fs_co_mknod(pdu
->s
, &fullname
, fidp
->uid
, -1,
1979 0, S_IFIFO
| (perm
& 0777));
1983 } else if (perm
& P9_STAT_MODE_SOCKET
) {
1984 err
= v9fs_co_mknod(pdu
->s
, &fullname
, fidp
->uid
, -1,
1985 0, S_IFSOCK
| (perm
& 0777));
1990 err
= v9fs_co_open2(pdu
->s
, fidp
, fullname
.data
, -1,
1991 omode_to_uflags(mode
)|O_CREAT
, perm
);
1995 fidp
->fid_type
= P9_FID_FILE
;
1997 err
= v9fs_co_lstat(pdu
->s
, &fullname
, &stbuf
);
1999 fidp
->fid_type
= P9_FID_NONE
;
2005 iounit
= get_iounit(pdu
->s
, &fidp
->path
);
2006 v9fs_string_copy(&fidp
->path
, &fullname
);
2007 stat_to_qid(&stbuf
, &qid
);
2008 offset
+= pdu_marshal(pdu
, offset
, "Qd", &qid
, iounit
);
2011 put_fid(pdu
->s
, fidp
);
2013 complete_pdu(pdu
->s
, pdu
, err
);
2014 v9fs_string_free(&name
);
2015 v9fs_string_free(&extension
);
2016 v9fs_string_free(&fullname
);
2019 static void v9fs_symlink(void *opaque
)
2021 V9fsPDU
*pdu
= opaque
;
2024 V9fsString fullname
;
2025 V9fsFidState
*dfidp
;
2033 v9fs_string_init(&fullname
);
2034 pdu_unmarshal(pdu
, offset
, "dssd", &dfid
, &name
, &symname
, &gid
);
2036 dfidp
= get_fid(pdu
->s
, dfid
);
2037 if (dfidp
== NULL
) {
2042 v9fs_string_sprintf(&fullname
, "%s/%s", dfidp
->path
.data
, name
.data
);
2043 err
= v9fs_co_symlink(pdu
->s
, dfidp
, symname
.data
, fullname
.data
, gid
);
2047 err
= v9fs_co_lstat(pdu
->s
, &fullname
, &stbuf
);
2051 stat_to_qid(&stbuf
, &qid
);
2052 offset
+= pdu_marshal(pdu
, offset
, "Q", &qid
);
2055 put_fid(pdu
->s
, dfidp
);
2057 complete_pdu(pdu
->s
, pdu
, err
);
2058 v9fs_string_free(&name
);
2059 v9fs_string_free(&symname
);
2060 v9fs_string_free(&fullname
);
2063 static void v9fs_flush(void *opaque
)
2065 V9fsPDU
*pdu
= opaque
;
2066 V9fsState
*s
= pdu
->s
;
2067 /* A nop call with no return */
2068 complete_pdu(s
, pdu
, 7);
2072 static void v9fs_link(void *opaque
)
2074 V9fsPDU
*pdu
= opaque
;
2075 V9fsState
*s
= pdu
->s
;
2076 int32_t dfid
, oldfid
;
2077 V9fsFidState
*dfidp
, *oldfidp
;
2078 V9fsString name
, fullname
;
2082 v9fs_string_init(&fullname
);
2084 pdu_unmarshal(pdu
, offset
, "dds", &dfid
, &oldfid
, &name
);
2086 dfidp
= get_fid(s
, dfid
);
2087 if (dfidp
== NULL
) {
2092 oldfidp
= get_fid(s
, oldfid
);
2093 if (oldfidp
== NULL
) {
2098 v9fs_string_sprintf(&fullname
, "%s/%s", dfidp
->path
.data
, name
.data
);
2099 err
= v9fs_co_link(s
, &oldfidp
->path
, &fullname
);
2103 v9fs_string_free(&fullname
);
2108 v9fs_string_free(&name
);
2109 complete_pdu(s
, pdu
, err
);
2112 static void v9fs_remove(void *opaque
)
2118 V9fsPDU
*pdu
= opaque
;
2120 pdu_unmarshal(pdu
, offset
, "d", &fid
);
2122 fidp
= get_fid(pdu
->s
, fid
);
2127 err
= v9fs_co_remove(pdu
->s
, &fidp
->path
);
2132 /* For TREMOVE we need to clunk the fid even on failed remove */
2133 clunk_fid(pdu
->s
, fidp
->fid
);
2134 put_fid(pdu
->s
, fidp
);
2136 complete_pdu(pdu
->s
, pdu
, err
);
2139 static int v9fs_complete_rename(V9fsState
*s
, V9fsFidState
*fidp
,
2140 int32_t newdirfid
, V9fsString
*name
)
2144 V9fsFidState
*dirfidp
= NULL
;
2145 char *old_name
, *new_name
;
2147 if (newdirfid
!= -1) {
2148 dirfidp
= get_fid(s
, newdirfid
);
2149 if (dirfidp
== NULL
) {
2153 BUG_ON(dirfidp
->fid_type
!= P9_FID_NONE
);
2155 new_name
= g_malloc0(dirfidp
->path
.size
+ name
->size
+ 2);
2157 strcpy(new_name
, dirfidp
->path
.data
);
2158 strcat(new_name
, "/");
2159 strcat(new_name
+ dirfidp
->path
.size
, name
->data
);
2161 old_name
= fidp
->path
.data
;
2162 end
= strrchr(old_name
, '/');
2168 new_name
= g_malloc0(end
- old_name
+ name
->size
+ 1);
2170 strncat(new_name
, old_name
, end
- old_name
);
2171 strncat(new_name
+ (end
- old_name
), name
->data
, name
->size
);
2174 v9fs_string_free(name
);
2175 name
->data
= new_name
;
2176 name
->size
= strlen(new_name
);
2178 if (strcmp(new_name
, fidp
->path
.data
) != 0) {
2179 err
= v9fs_co_rename(s
, &fidp
->path
, name
);
2183 V9fsFidState
*tfidp
;
2185 * Fixup fid's pointing to the old name to
2186 * start pointing to the new name
2188 for (tfidp
= s
->fid_list
; tfidp
; tfidp
= tfidp
->next
) {
2189 if (fidp
== tfidp
) {
2191 * we replace name of this fid towards the end
2192 * so that our below strcmp will work
2196 if (v9fs_path_is_ancestor(&fidp
->path
, &tfidp
->path
)) {
2197 /* replace the name */
2198 v9fs_fix_path(&tfidp
->path
, name
, strlen(fidp
->path
.data
));
2201 v9fs_string_copy(&fidp
->path
, name
);
2205 put_fid(s
, dirfidp
);
2211 static void v9fs_rename(void *opaque
)
2219 V9fsPDU
*pdu
= opaque
;
2220 V9fsState
*s
= pdu
->s
;
2222 pdu_unmarshal(pdu
, offset
, "dds", &fid
, &newdirfid
, &name
);
2224 fidp
= get_fid(s
, fid
);
2229 BUG_ON(fidp
->fid_type
!= P9_FID_NONE
);
2231 err
= v9fs_complete_rename(s
, fidp
, newdirfid
, &name
);
2237 complete_pdu(s
, pdu
, err
);
2238 v9fs_string_free(&name
);
2241 static void v9fs_wstat(void *opaque
)
2250 V9fsPDU
*pdu
= opaque
;
2251 V9fsState
*s
= pdu
->s
;
2253 pdu_unmarshal(pdu
, offset
, "dwS", &fid
, &unused
, &v9stat
);
2255 fidp
= get_fid(s
, fid
);
2260 /* do we need to sync the file? */
2261 if (donttouch_stat(&v9stat
)) {
2262 err
= v9fs_co_fsync(s
, fidp
, 0);
2265 if (v9stat
.mode
!= -1) {
2267 err
= v9fs_co_lstat(s
, &fidp
->path
, &stbuf
);
2271 v9_mode
= stat_to_v9mode(&stbuf
);
2272 if ((v9stat
.mode
& P9_STAT_MODE_TYPE_BITS
) !=
2273 (v9_mode
& P9_STAT_MODE_TYPE_BITS
)) {
2274 /* Attempting to change the type */
2278 err
= v9fs_co_chmod(s
, &fidp
->path
,
2279 v9mode_to_mode(v9stat
.mode
,
2280 &v9stat
.extension
));
2285 if (v9stat
.mtime
!= -1 || v9stat
.atime
!= -1) {
2286 struct timespec times
[2];
2287 if (v9stat
.atime
!= -1) {
2288 times
[0].tv_sec
= v9stat
.atime
;
2289 times
[0].tv_nsec
= 0;
2291 times
[0].tv_nsec
= UTIME_OMIT
;
2293 if (v9stat
.mtime
!= -1) {
2294 times
[1].tv_sec
= v9stat
.mtime
;
2295 times
[1].tv_nsec
= 0;
2297 times
[1].tv_nsec
= UTIME_OMIT
;
2299 err
= v9fs_co_utimensat(s
, &fidp
->path
, times
);
2304 if (v9stat
.n_gid
!= -1 || v9stat
.n_uid
!= -1) {
2305 err
= v9fs_co_chown(s
, &fidp
->path
, v9stat
.n_uid
, v9stat
.n_gid
);
2310 if (v9stat
.name
.size
!= 0) {
2311 err
= v9fs_complete_rename(s
, fidp
, -1, &v9stat
.name
);
2316 if (v9stat
.length
!= -1) {
2317 err
= v9fs_co_truncate(s
, &fidp
->path
, v9stat
.length
);
2326 v9fs_stat_free(&v9stat
);
2327 complete_pdu(s
, pdu
, err
);
2330 static int v9fs_fill_statfs(V9fsState
*s
, V9fsPDU
*pdu
, struct statfs
*stbuf
)
2342 int32_t bsize_factor
;
2345 * compute bsize factor based on host file system block size
2348 bsize_factor
= (s
->msize
- P9_IOHDRSZ
)/stbuf
->f_bsize
;
2349 if (!bsize_factor
) {
2352 f_type
= stbuf
->f_type
;
2353 f_bsize
= stbuf
->f_bsize
;
2354 f_bsize
*= bsize_factor
;
2356 * f_bsize is adjusted(multiplied) by bsize factor, so we need to
2357 * adjust(divide) the number of blocks, free blocks and available
2358 * blocks by bsize factor
2360 f_blocks
= stbuf
->f_blocks
/bsize_factor
;
2361 f_bfree
= stbuf
->f_bfree
/bsize_factor
;
2362 f_bavail
= stbuf
->f_bavail
/bsize_factor
;
2363 f_files
= stbuf
->f_files
;
2364 f_ffree
= stbuf
->f_ffree
;
2365 fsid_val
= (unsigned int) stbuf
->f_fsid
.__val
[0] |
2366 (unsigned long long)stbuf
->f_fsid
.__val
[1] << 32;
2367 f_namelen
= stbuf
->f_namelen
;
2369 return pdu_marshal(pdu
, offset
, "ddqqqqqqd",
2370 f_type
, f_bsize
, f_blocks
, f_bfree
,
2371 f_bavail
, f_files
, f_ffree
,
2372 fsid_val
, f_namelen
);
2375 static void v9fs_statfs(void *opaque
)
2381 struct statfs stbuf
;
2382 V9fsPDU
*pdu
= opaque
;
2383 V9fsState
*s
= pdu
->s
;
2385 pdu_unmarshal(pdu
, offset
, "d", &fid
);
2386 fidp
= get_fid(s
, fid
);
2391 retval
= v9fs_co_statfs(s
, &fidp
->path
, &stbuf
);
2396 retval
+= v9fs_fill_statfs(s
, pdu
, &stbuf
);
2400 complete_pdu(s
, pdu
, retval
);
2404 static void v9fs_mknod(void *opaque
)
2416 V9fsString fullname
;
2418 V9fsPDU
*pdu
= opaque
;
2419 V9fsState
*s
= pdu
->s
;
2421 v9fs_string_init(&fullname
);
2422 pdu_unmarshal(pdu
, offset
, "dsdddd", &fid
, &name
, &mode
,
2423 &major
, &minor
, &gid
);
2425 fidp
= get_fid(s
, fid
);
2430 v9fs_string_sprintf(&fullname
, "%s/%s", fidp
->path
.data
, name
.data
);
2431 err
= v9fs_co_mknod(s
, &fullname
, fidp
->uid
, gid
,
2432 makedev(major
, minor
), mode
);
2436 err
= v9fs_co_lstat(s
, &fullname
, &stbuf
);
2440 stat_to_qid(&stbuf
, &qid
);
2442 err
+= pdu_marshal(pdu
, offset
, "Q", &qid
);
2446 complete_pdu(s
, pdu
, err
);
2447 v9fs_string_free(&fullname
);
2448 v9fs_string_free(&name
);
2452 * Implement posix byte range locking code
2453 * Server side handling of locking code is very simple, because 9p server in
2454 * QEMU can handle only one client. And most of the lock handling
2455 * (like conflict, merging) etc is done by the VFS layer itself, so no need to
2456 * do any thing in * qemu 9p server side lock code path.
2457 * So when a TLOCK request comes, always return success
2459 static void v9fs_lock(void *opaque
)
2466 int32_t fid
, err
= 0;
2467 V9fsPDU
*pdu
= opaque
;
2468 V9fsState
*s
= pdu
->s
;
2470 flock
= g_malloc(sizeof(*flock
));
2471 pdu_unmarshal(pdu
, offset
, "dbdqqds", &fid
, &flock
->type
,
2472 &flock
->flags
, &flock
->start
, &flock
->length
,
2473 &flock
->proc_id
, &flock
->client_id
);
2474 status
= P9_LOCK_ERROR
;
2476 /* We support only block flag now (that too ignored currently) */
2477 if (flock
->flags
& ~P9_LOCK_FLAGS_BLOCK
) {
2481 fidp
= get_fid(s
, fid
);
2486 err
= v9fs_co_fstat(s
, fidp
->fs
.fd
, &stbuf
);
2490 status
= P9_LOCK_SUCCESS
;
2495 err
+= pdu_marshal(pdu
, offset
, "b", status
);
2496 complete_pdu(s
, pdu
, err
);
2501 * When a TGETLOCK request comes, always return success because all lock
2502 * handling is done by client's VFS layer.
2504 static void v9fs_getlock(void *opaque
)
2510 int32_t fid
, err
= 0;
2511 V9fsPDU
*pdu
= opaque
;
2512 V9fsState
*s
= pdu
->s
;
2514 glock
= g_malloc(sizeof(*glock
));
2515 pdu_unmarshal(pdu
, offset
, "dbqqds", &fid
, &glock
->type
,
2516 &glock
->start
, &glock
->length
, &glock
->proc_id
,
2519 fidp
= get_fid(s
, fid
);
2524 err
= v9fs_co_fstat(s
, fidp
->fs
.fd
, &stbuf
);
2528 glock
->type
= F_UNLCK
;
2529 offset
+= pdu_marshal(pdu
, offset
, "bqqds", glock
->type
,
2530 glock
->start
, glock
->length
, glock
->proc_id
,
2536 complete_pdu(s
, pdu
, err
);
2540 static void v9fs_mkdir(void *opaque
)
2542 V9fsPDU
*pdu
= opaque
;
2546 V9fsString name
, fullname
;
2553 v9fs_string_init(&fullname
);
2554 pdu_unmarshal(pdu
, offset
, "dsdd", &fid
, &name
, &mode
, &gid
);
2556 fidp
= get_fid(pdu
->s
, fid
);
2561 v9fs_string_sprintf(&fullname
, "%s/%s", fidp
->path
.data
, name
.data
);
2562 err
= v9fs_co_mkdir(pdu
->s
, fullname
.data
, mode
, fidp
->uid
, gid
);
2566 err
= v9fs_co_lstat(pdu
->s
, &fullname
, &stbuf
);
2570 stat_to_qid(&stbuf
, &qid
);
2571 offset
+= pdu_marshal(pdu
, offset
, "Q", &qid
);
2574 put_fid(pdu
->s
, fidp
);
2576 complete_pdu(pdu
->s
, pdu
, err
);
2577 v9fs_string_free(&fullname
);
2578 v9fs_string_free(&name
);
2581 static void v9fs_xattrwalk(void *opaque
)
2587 int32_t fid
, newfid
;
2588 V9fsFidState
*file_fidp
;
2589 V9fsFidState
*xattr_fidp
= NULL
;
2590 V9fsPDU
*pdu
= opaque
;
2591 V9fsState
*s
= pdu
->s
;
2593 pdu_unmarshal(pdu
, offset
, "dds", &fid
, &newfid
, &name
);
2594 file_fidp
= get_fid(s
, fid
);
2595 if (file_fidp
== NULL
) {
2599 xattr_fidp
= alloc_fid(s
, newfid
);
2600 if (xattr_fidp
== NULL
) {
2604 v9fs_string_copy(&xattr_fidp
->path
, &file_fidp
->path
);
2605 if (name
.data
[0] == 0) {
2607 * listxattr request. Get the size first
2609 size
= v9fs_co_llistxattr(s
, &xattr_fidp
->path
, NULL
, 0);
2612 clunk_fid(s
, xattr_fidp
->fid
);
2616 * Read the xattr value
2618 xattr_fidp
->fs
.xattr
.len
= size
;
2619 xattr_fidp
->fid_type
= P9_FID_XATTR
;
2620 xattr_fidp
->fs
.xattr
.copied_len
= -1;
2622 xattr_fidp
->fs
.xattr
.value
= g_malloc(size
);
2623 err
= v9fs_co_llistxattr(s
, &xattr_fidp
->path
,
2624 xattr_fidp
->fs
.xattr
.value
,
2625 xattr_fidp
->fs
.xattr
.len
);
2627 clunk_fid(s
, xattr_fidp
->fid
);
2631 offset
+= pdu_marshal(pdu
, offset
, "q", size
);
2635 * specific xattr fid. We check for xattr
2636 * presence also collect the xattr size
2638 size
= v9fs_co_lgetxattr(s
, &xattr_fidp
->path
,
2642 clunk_fid(s
, xattr_fidp
->fid
);
2646 * Read the xattr value
2648 xattr_fidp
->fs
.xattr
.len
= size
;
2649 xattr_fidp
->fid_type
= P9_FID_XATTR
;
2650 xattr_fidp
->fs
.xattr
.copied_len
= -1;
2652 xattr_fidp
->fs
.xattr
.value
= g_malloc(size
);
2653 err
= v9fs_co_lgetxattr(s
, &xattr_fidp
->path
,
2654 &name
, xattr_fidp
->fs
.xattr
.value
,
2655 xattr_fidp
->fs
.xattr
.len
);
2657 clunk_fid(s
, xattr_fidp
->fid
);
2661 offset
+= pdu_marshal(pdu
, offset
, "q", size
);
2665 put_fid(s
, file_fidp
);
2667 put_fid(s
, xattr_fidp
);
2670 complete_pdu(s
, pdu
, err
);
2671 v9fs_string_free(&name
);
2674 static void v9fs_xattrcreate(void *opaque
)
2682 V9fsFidState
*file_fidp
;
2683 V9fsFidState
*xattr_fidp
;
2684 V9fsPDU
*pdu
= opaque
;
2685 V9fsState
*s
= pdu
->s
;
2687 pdu_unmarshal(pdu
, offset
, "dsqd",
2688 &fid
, &name
, &size
, &flags
);
2690 file_fidp
= get_fid(s
, fid
);
2691 if (file_fidp
== NULL
) {
2695 /* Make the file fid point to xattr */
2696 xattr_fidp
= file_fidp
;
2697 xattr_fidp
->fid_type
= P9_FID_XATTR
;
2698 xattr_fidp
->fs
.xattr
.copied_len
= 0;
2699 xattr_fidp
->fs
.xattr
.len
= size
;
2700 xattr_fidp
->fs
.xattr
.flags
= flags
;
2701 v9fs_string_init(&xattr_fidp
->fs
.xattr
.name
);
2702 v9fs_string_copy(&xattr_fidp
->fs
.xattr
.name
, &name
);
2704 xattr_fidp
->fs
.xattr
.value
= g_malloc(size
);
2706 xattr_fidp
->fs
.xattr
.value
= NULL
;
2709 put_fid(s
, file_fidp
);
2711 complete_pdu(s
, pdu
, err
);
2712 v9fs_string_free(&name
);
2715 static void v9fs_readlink(void *opaque
)
2717 V9fsPDU
*pdu
= opaque
;
2724 pdu_unmarshal(pdu
, offset
, "d", &fid
);
2725 fidp
= get_fid(pdu
->s
, fid
);
2731 v9fs_string_init(&target
);
2732 err
= v9fs_co_readlink(pdu
->s
, &fidp
->path
, &target
);
2736 offset
+= pdu_marshal(pdu
, offset
, "s", &target
);
2738 v9fs_string_free(&target
);
2740 put_fid(pdu
->s
, fidp
);
2742 complete_pdu(pdu
->s
, pdu
, err
);
2745 static CoroutineEntry
*pdu_co_handlers
[] = {
2746 [P9_TREADDIR
] = v9fs_readdir
,
2747 [P9_TSTATFS
] = v9fs_statfs
,
2748 [P9_TGETATTR
] = v9fs_getattr
,
2749 [P9_TSETATTR
] = v9fs_setattr
,
2750 [P9_TXATTRWALK
] = v9fs_xattrwalk
,
2751 [P9_TXATTRCREATE
] = v9fs_xattrcreate
,
2752 [P9_TMKNOD
] = v9fs_mknod
,
2753 [P9_TRENAME
] = v9fs_rename
,
2754 [P9_TLOCK
] = v9fs_lock
,
2755 [P9_TGETLOCK
] = v9fs_getlock
,
2756 [P9_TREADLINK
] = v9fs_readlink
,
2757 [P9_TMKDIR
] = v9fs_mkdir
,
2758 [P9_TVERSION
] = v9fs_version
,
2759 [P9_TLOPEN
] = v9fs_open
,
2760 [P9_TATTACH
] = v9fs_attach
,
2761 [P9_TSTAT
] = v9fs_stat
,
2762 [P9_TWALK
] = v9fs_walk
,
2763 [P9_TCLUNK
] = v9fs_clunk
,
2764 [P9_TFSYNC
] = v9fs_fsync
,
2765 [P9_TOPEN
] = v9fs_open
,
2766 [P9_TREAD
] = v9fs_read
,
2768 [P9_TAUTH
] = v9fs_auth
,
2770 [P9_TFLUSH
] = v9fs_flush
,
2771 [P9_TLINK
] = v9fs_link
,
2772 [P9_TSYMLINK
] = v9fs_symlink
,
2773 [P9_TCREATE
] = v9fs_create
,
2774 [P9_TLCREATE
] = v9fs_lcreate
,
2775 [P9_TWRITE
] = v9fs_write
,
2776 [P9_TWSTAT
] = v9fs_wstat
,
2777 [P9_TREMOVE
] = v9fs_remove
,
2780 static void v9fs_op_not_supp(void *opaque
)
2782 V9fsPDU
*pdu
= opaque
;
2783 complete_pdu(pdu
->s
, pdu
, -EOPNOTSUPP
);
2786 static void submit_pdu(V9fsState
*s
, V9fsPDU
*pdu
)
2789 CoroutineEntry
*handler
;
2794 if (pdu
->id
>= ARRAY_SIZE(pdu_co_handlers
) ||
2795 (pdu_co_handlers
[pdu
->id
] == NULL
)) {
2796 handler
= v9fs_op_not_supp
;
2798 handler
= pdu_co_handlers
[pdu
->id
];
2800 co
= qemu_coroutine_create(handler
);
2801 qemu_coroutine_enter(co
, pdu
);
2804 void handle_9p_output(VirtIODevice
*vdev
, VirtQueue
*vq
)
2806 V9fsState
*s
= (V9fsState
*)vdev
;
2810 while ((pdu
= alloc_pdu(s
)) &&
2811 (len
= virtqueue_pop(vq
, &pdu
->elem
)) != 0) {
2814 BUG_ON(pdu
->elem
.out_num
== 0 || pdu
->elem
.in_num
== 0);
2815 BUG_ON(pdu
->elem
.out_sg
[0].iov_len
< 7);
2817 ptr
= pdu
->elem
.out_sg
[0].iov_base
;
2819 memcpy(&pdu
->size
, ptr
, 4);
2821 memcpy(&pdu
->tag
, ptr
+ 5, 2);