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.
16 #include "qemu_socket.h"
17 #include "virtio-9p.h"
18 #include "fsdev/qemu-fsdev.h"
19 #include "virtio-9p-debug.h"
20 #include "virtio-9p-xattr.h"
36 static int omode_to_uflags(int8_t mode
)
70 void cred_init(FsCred
*credp
)
78 static int v9fs_do_lstat(V9fsState
*s
, V9fsString
*path
, struct stat
*stbuf
)
80 return s
->ops
->lstat(&s
->ctx
, path
->data
, stbuf
);
83 static ssize_t
v9fs_do_readlink(V9fsState
*s
, V9fsString
*path
, V9fsString
*buf
)
87 buf
->data
= qemu_malloc(1024);
89 len
= s
->ops
->readlink(&s
->ctx
, path
->data
, buf
->data
, 1024 - 1);
98 static int v9fs_do_close(V9fsState
*s
, int fd
)
100 return s
->ops
->close(&s
->ctx
, fd
);
103 static int v9fs_do_closedir(V9fsState
*s
, DIR *dir
)
105 return s
->ops
->closedir(&s
->ctx
, dir
);
108 static int v9fs_do_open(V9fsState
*s
, V9fsString
*path
, int flags
)
110 return s
->ops
->open(&s
->ctx
, path
->data
, flags
);
113 static DIR *v9fs_do_opendir(V9fsState
*s
, V9fsString
*path
)
115 return s
->ops
->opendir(&s
->ctx
, path
->data
);
118 static void v9fs_do_rewinddir(V9fsState
*s
, DIR *dir
)
120 return s
->ops
->rewinddir(&s
->ctx
, dir
);
123 static off_t
v9fs_do_telldir(V9fsState
*s
, DIR *dir
)
125 return s
->ops
->telldir(&s
->ctx
, dir
);
128 static struct dirent
*v9fs_do_readdir(V9fsState
*s
, DIR *dir
)
130 return s
->ops
->readdir(&s
->ctx
, dir
);
133 static void v9fs_do_seekdir(V9fsState
*s
, DIR *dir
, off_t off
)
135 return s
->ops
->seekdir(&s
->ctx
, dir
, off
);
138 static int v9fs_do_preadv(V9fsState
*s
, int fd
, const struct iovec
*iov
,
139 int iovcnt
, int64_t offset
)
141 return s
->ops
->preadv(&s
->ctx
, fd
, iov
, iovcnt
, offset
);
144 static int v9fs_do_pwritev(V9fsState
*s
, int fd
, const struct iovec
*iov
,
145 int iovcnt
, int64_t offset
)
147 return s
->ops
->pwritev(&s
->ctx
, fd
, iov
, iovcnt
, offset
);
150 static int v9fs_do_chmod(V9fsState
*s
, V9fsString
*path
, mode_t mode
)
155 return s
->ops
->chmod(&s
->ctx
, path
->data
, &cred
);
158 static int v9fs_do_mknod(V9fsState
*s
, char *name
,
159 mode_t mode
, dev_t dev
, uid_t uid
, gid_t gid
)
167 return s
->ops
->mknod(&s
->ctx
, name
, &cred
);
170 static int v9fs_do_mkdir(V9fsState
*s
, char *name
, mode_t mode
,
171 uid_t uid
, gid_t gid
)
180 return s
->ops
->mkdir(&s
->ctx
, name
, &cred
);
183 static int v9fs_do_fstat(V9fsState
*s
, int fd
, struct stat
*stbuf
)
185 return s
->ops
->fstat(&s
->ctx
, fd
, stbuf
);
188 static int v9fs_do_open2(V9fsState
*s
, char *fullname
, uid_t uid
, gid_t gid
,
196 cred
.fc_mode
= mode
& 07777;
199 return s
->ops
->open2(&s
->ctx
, fullname
, flags
, &cred
);
202 static int v9fs_do_symlink(V9fsState
*s
, V9fsFidState
*fidp
,
203 const char *oldpath
, const char *newpath
, gid_t gid
)
207 cred
.fc_uid
= fidp
->uid
;
211 return s
->ops
->symlink(&s
->ctx
, oldpath
, newpath
, &cred
);
214 static int v9fs_do_link(V9fsState
*s
, V9fsString
*oldpath
, V9fsString
*newpath
)
216 return s
->ops
->link(&s
->ctx
, oldpath
->data
, newpath
->data
);
219 static int v9fs_do_truncate(V9fsState
*s
, V9fsString
*path
, off_t size
)
221 return s
->ops
->truncate(&s
->ctx
, path
->data
, size
);
224 static int v9fs_do_rename(V9fsState
*s
, V9fsString
*oldpath
,
227 return s
->ops
->rename(&s
->ctx
, oldpath
->data
, newpath
->data
);
230 static int v9fs_do_chown(V9fsState
*s
, V9fsString
*path
, uid_t uid
, gid_t gid
)
237 return s
->ops
->chown(&s
->ctx
, path
->data
, &cred
);
240 static int v9fs_do_utimensat(V9fsState
*s
, V9fsString
*path
,
241 const struct timespec times
[2])
243 return s
->ops
->utimensat(&s
->ctx
, path
->data
, times
);
246 static int v9fs_do_remove(V9fsState
*s
, V9fsString
*path
)
248 return s
->ops
->remove(&s
->ctx
, path
->data
);
251 static int v9fs_do_fsync(V9fsState
*s
, int fd
, int datasync
)
253 return s
->ops
->fsync(&s
->ctx
, fd
, datasync
);
256 static int v9fs_do_statfs(V9fsState
*s
, V9fsString
*path
, struct statfs
*stbuf
)
258 return s
->ops
->statfs(&s
->ctx
, path
->data
, stbuf
);
261 static ssize_t
v9fs_do_lgetxattr(V9fsState
*s
, V9fsString
*path
,
262 V9fsString
*xattr_name
,
263 void *value
, size_t size
)
265 return s
->ops
->lgetxattr(&s
->ctx
, path
->data
,
266 xattr_name
->data
, value
, size
);
269 static ssize_t
v9fs_do_llistxattr(V9fsState
*s
, V9fsString
*path
,
270 void *value
, size_t size
)
272 return s
->ops
->llistxattr(&s
->ctx
, path
->data
,
276 static int v9fs_do_lsetxattr(V9fsState
*s
, V9fsString
*path
,
277 V9fsString
*xattr_name
,
278 void *value
, size_t size
, int flags
)
280 return s
->ops
->lsetxattr(&s
->ctx
, path
->data
,
281 xattr_name
->data
, value
, size
, flags
);
284 static int v9fs_do_lremovexattr(V9fsState
*s
, V9fsString
*path
,
285 V9fsString
*xattr_name
)
287 return s
->ops
->lremovexattr(&s
->ctx
, path
->data
,
292 static void v9fs_string_init(V9fsString
*str
)
298 static void v9fs_string_free(V9fsString
*str
)
300 qemu_free(str
->data
);
305 static void v9fs_string_null(V9fsString
*str
)
307 v9fs_string_free(str
);
310 static int number_to_string(void *arg
, char type
)
312 unsigned int ret
= 0;
316 unsigned int num
= *(unsigned int *)arg
;
325 unsigned long num
= *(unsigned long *)arg
;
333 printf("Number_to_string: Unknown number format\n");
340 static int GCC_FMT_ATTR(2, 0)
341 v9fs_string_alloc_printf(char **strp
, const char *fmt
, va_list ap
)
344 char *iter
= (char *)fmt
;
348 unsigned int arg_uint
;
349 unsigned long arg_ulong
;
351 /* Find the number of %'s that denotes an argument */
352 for (iter
= strstr(iter
, "%"); iter
; iter
= strstr(iter
, "%")) {
357 len
= strlen(fmt
) - 2*nr_args
;
367 /* Now parse the format string */
368 for (iter
= strstr(iter
, "%"); iter
; iter
= strstr(iter
, "%")) {
372 arg_uint
= va_arg(ap2
, unsigned int);
373 len
+= number_to_string((void *)&arg_uint
, 'u');
376 if (*++iter
== 'u') {
377 arg_ulong
= va_arg(ap2
, unsigned long);
378 len
+= number_to_string((void *)&arg_ulong
, 'U');
384 arg_char_ptr
= va_arg(ap2
, char *);
385 len
+= strlen(arg_char_ptr
);
392 "v9fs_string_alloc_printf:Incorrect format %c", *iter
);
399 *strp
= qemu_malloc((len
+ 1) * sizeof(**strp
));
401 return vsprintf(*strp
, fmt
, ap
);
404 static void GCC_FMT_ATTR(2, 3)
405 v9fs_string_sprintf(V9fsString
*str
, const char *fmt
, ...)
410 v9fs_string_free(str
);
413 err
= v9fs_string_alloc_printf(&str
->data
, fmt
, ap
);
420 static void v9fs_string_copy(V9fsString
*lhs
, V9fsString
*rhs
)
422 v9fs_string_free(lhs
);
423 v9fs_string_sprintf(lhs
, "%s", rhs
->data
);
426 static size_t v9fs_string_size(V9fsString
*str
)
431 static V9fsFidState
*lookup_fid(V9fsState
*s
, int32_t fid
)
435 for (f
= s
->fid_list
; f
; f
= f
->next
) {
444 static V9fsFidState
*alloc_fid(V9fsState
*s
, int32_t fid
)
448 f
= lookup_fid(s
, fid
);
453 f
= qemu_mallocz(sizeof(V9fsFidState
));
456 f
->fid_type
= P9_FID_NONE
;
458 f
->next
= s
->fid_list
;
464 static int v9fs_xattr_fid_clunk(V9fsState
*s
, V9fsFidState
*fidp
)
468 if (fidp
->fs
.xattr
.copied_len
== -1) {
469 /* getxattr/listxattr fid */
473 * if this is fid for setxattr. clunk should
474 * result in setxattr localcall
476 if (fidp
->fs
.xattr
.len
!= fidp
->fs
.xattr
.copied_len
) {
477 /* clunk after partial write */
481 if (fidp
->fs
.xattr
.len
) {
482 retval
= v9fs_do_lsetxattr(s
, &fidp
->path
, &fidp
->fs
.xattr
.name
,
483 fidp
->fs
.xattr
.value
,
485 fidp
->fs
.xattr
.flags
);
487 retval
= v9fs_do_lremovexattr(s
, &fidp
->path
, &fidp
->fs
.xattr
.name
);
490 v9fs_string_free(&fidp
->fs
.xattr
.name
);
492 if (fidp
->fs
.xattr
.value
) {
493 qemu_free(fidp
->fs
.xattr
.value
);
498 static int free_fid(V9fsState
*s
, int32_t fid
)
501 V9fsFidState
**fidpp
, *fidp
;
503 for (fidpp
= &s
->fid_list
; *fidpp
; fidpp
= &(*fidpp
)->next
) {
504 if ((*fidpp
)->fid
== fid
) {
509 if (*fidpp
== NULL
) {
516 if (fidp
->fid_type
== P9_FID_FILE
) {
517 v9fs_do_close(s
, fidp
->fs
.fd
);
518 } else if (fidp
->fid_type
== P9_FID_DIR
) {
519 v9fs_do_closedir(s
, fidp
->fs
.dir
);
520 } else if (fidp
->fid_type
== P9_FID_XATTR
) {
521 retval
= v9fs_xattr_fid_clunk(s
, fidp
);
523 v9fs_string_free(&fidp
->path
);
529 #define P9_QID_TYPE_DIR 0x80
530 #define P9_QID_TYPE_SYMLINK 0x02
532 #define P9_STAT_MODE_DIR 0x80000000
533 #define P9_STAT_MODE_APPEND 0x40000000
534 #define P9_STAT_MODE_EXCL 0x20000000
535 #define P9_STAT_MODE_MOUNT 0x10000000
536 #define P9_STAT_MODE_AUTH 0x08000000
537 #define P9_STAT_MODE_TMP 0x04000000
538 #define P9_STAT_MODE_SYMLINK 0x02000000
539 #define P9_STAT_MODE_LINK 0x01000000
540 #define P9_STAT_MODE_DEVICE 0x00800000
541 #define P9_STAT_MODE_NAMED_PIPE 0x00200000
542 #define P9_STAT_MODE_SOCKET 0x00100000
543 #define P9_STAT_MODE_SETUID 0x00080000
544 #define P9_STAT_MODE_SETGID 0x00040000
545 #define P9_STAT_MODE_SETVTX 0x00010000
547 #define P9_STAT_MODE_TYPE_BITS (P9_STAT_MODE_DIR | \
548 P9_STAT_MODE_SYMLINK | \
549 P9_STAT_MODE_LINK | \
550 P9_STAT_MODE_DEVICE | \
551 P9_STAT_MODE_NAMED_PIPE | \
554 /* This is the algorithm from ufs in spfs */
555 static void stat_to_qid(const struct stat
*stbuf
, V9fsQID
*qidp
)
559 size
= MIN(sizeof(stbuf
->st_ino
), sizeof(qidp
->path
));
560 memcpy(&qidp
->path
, &stbuf
->st_ino
, size
);
561 qidp
->version
= stbuf
->st_mtime
^ (stbuf
->st_size
<< 8);
563 if (S_ISDIR(stbuf
->st_mode
)) {
564 qidp
->type
|= P9_QID_TYPE_DIR
;
566 if (S_ISLNK(stbuf
->st_mode
)) {
567 qidp
->type
|= P9_QID_TYPE_SYMLINK
;
571 static int fid_to_qid(V9fsState
*s
, V9fsFidState
*fidp
, V9fsQID
*qidp
)
576 err
= v9fs_do_lstat(s
, &fidp
->path
, &stbuf
);
581 stat_to_qid(&stbuf
, qidp
);
585 static V9fsPDU
*alloc_pdu(V9fsState
*s
)
589 if (!QLIST_EMPTY(&s
->free_list
)) {
590 pdu
= QLIST_FIRST(&s
->free_list
);
591 QLIST_REMOVE(pdu
, next
);
596 static void free_pdu(V9fsState
*s
, V9fsPDU
*pdu
)
599 QLIST_INSERT_HEAD(&s
->free_list
, pdu
, next
);
603 size_t pdu_packunpack(void *addr
, struct iovec
*sg
, int sg_count
,
604 size_t offset
, size_t size
, int pack
)
609 for (i
= 0; size
&& i
< sg_count
; i
++) {
611 if (offset
>= sg
[i
].iov_len
) {
613 offset
-= sg
[i
].iov_len
;
616 len
= MIN(sg
[i
].iov_len
- offset
, size
);
618 memcpy(sg
[i
].iov_base
+ offset
, addr
, len
);
620 memcpy(addr
, sg
[i
].iov_base
+ offset
, len
);
635 static size_t pdu_unpack(void *dst
, V9fsPDU
*pdu
, size_t offset
, size_t size
)
637 return pdu_packunpack(dst
, pdu
->elem
.out_sg
, pdu
->elem
.out_num
,
641 static size_t pdu_pack(V9fsPDU
*pdu
, size_t offset
, const void *src
,
644 return pdu_packunpack((void *)src
, pdu
->elem
.in_sg
, pdu
->elem
.in_num
,
648 static int pdu_copy_sg(V9fsPDU
*pdu
, size_t offset
, int rx
, struct iovec
*sg
)
652 struct iovec
*src_sg
;
656 src_sg
= pdu
->elem
.in_sg
;
657 num
= pdu
->elem
.in_num
;
659 src_sg
= pdu
->elem
.out_sg
;
660 num
= pdu
->elem
.out_num
;
664 for (i
= 0; i
< num
; i
++) {
666 sg
[j
].iov_base
= src_sg
[i
].iov_base
;
667 sg
[j
].iov_len
= src_sg
[i
].iov_len
;
669 } else if (offset
< (src_sg
[i
].iov_len
+ pos
)) {
670 sg
[j
].iov_base
= src_sg
[i
].iov_base
;
671 sg
[j
].iov_len
= src_sg
[i
].iov_len
;
672 sg
[j
].iov_base
+= (offset
- pos
);
673 sg
[j
].iov_len
-= (offset
- pos
);
676 pos
+= src_sg
[i
].iov_len
;
682 static size_t pdu_unmarshal(V9fsPDU
*pdu
, size_t offset
, const char *fmt
, ...)
684 size_t old_offset
= offset
;
689 for (i
= 0; fmt
[i
]; i
++) {
692 uint8_t *valp
= va_arg(ap
, uint8_t *);
693 offset
+= pdu_unpack(valp
, pdu
, offset
, sizeof(*valp
));
698 valp
= va_arg(ap
, uint16_t *);
699 offset
+= pdu_unpack(&val
, pdu
, offset
, sizeof(val
));
700 *valp
= le16_to_cpu(val
);
705 valp
= va_arg(ap
, uint32_t *);
706 offset
+= pdu_unpack(&val
, pdu
, offset
, sizeof(val
));
707 *valp
= le32_to_cpu(val
);
712 valp
= va_arg(ap
, uint64_t *);
713 offset
+= pdu_unpack(&val
, pdu
, offset
, sizeof(val
));
714 *valp
= le64_to_cpu(val
);
718 struct iovec
*iov
= va_arg(ap
, struct iovec
*);
719 int *iovcnt
= va_arg(ap
, int *);
720 *iovcnt
= pdu_copy_sg(pdu
, offset
, 0, iov
);
724 V9fsString
*str
= va_arg(ap
, V9fsString
*);
725 offset
+= pdu_unmarshal(pdu
, offset
, "w", &str
->size
);
726 /* FIXME: sanity check str->size */
727 str
->data
= qemu_malloc(str
->size
+ 1);
728 offset
+= pdu_unpack(str
->data
, pdu
, offset
, str
->size
);
729 str
->data
[str
->size
] = 0;
733 V9fsQID
*qidp
= va_arg(ap
, V9fsQID
*);
734 offset
+= pdu_unmarshal(pdu
, offset
, "bdq",
735 &qidp
->type
, &qidp
->version
, &qidp
->path
);
739 V9fsStat
*statp
= va_arg(ap
, V9fsStat
*);
740 offset
+= pdu_unmarshal(pdu
, offset
, "wwdQdddqsssssddd",
741 &statp
->size
, &statp
->type
, &statp
->dev
,
742 &statp
->qid
, &statp
->mode
, &statp
->atime
,
743 &statp
->mtime
, &statp
->length
,
744 &statp
->name
, &statp
->uid
, &statp
->gid
,
745 &statp
->muid
, &statp
->extension
,
746 &statp
->n_uid
, &statp
->n_gid
,
751 V9fsIattr
*iattr
= va_arg(ap
, V9fsIattr
*);
752 offset
+= pdu_unmarshal(pdu
, offset
, "ddddqqqqq",
753 &iattr
->valid
, &iattr
->mode
,
754 &iattr
->uid
, &iattr
->gid
, &iattr
->size
,
755 &iattr
->atime_sec
, &iattr
->atime_nsec
,
756 &iattr
->mtime_sec
, &iattr
->mtime_nsec
);
766 return offset
- old_offset
;
769 static size_t pdu_marshal(V9fsPDU
*pdu
, size_t offset
, const char *fmt
, ...)
771 size_t old_offset
= offset
;
776 for (i
= 0; fmt
[i
]; i
++) {
779 uint8_t val
= va_arg(ap
, int);
780 offset
+= pdu_pack(pdu
, offset
, &val
, sizeof(val
));
785 cpu_to_le16w(&val
, va_arg(ap
, int));
786 offset
+= pdu_pack(pdu
, offset
, &val
, sizeof(val
));
791 cpu_to_le32w(&val
, va_arg(ap
, uint32_t));
792 offset
+= pdu_pack(pdu
, offset
, &val
, sizeof(val
));
797 cpu_to_le64w(&val
, va_arg(ap
, uint64_t));
798 offset
+= pdu_pack(pdu
, offset
, &val
, sizeof(val
));
802 struct iovec
*iov
= va_arg(ap
, struct iovec
*);
803 int *iovcnt
= va_arg(ap
, int *);
804 *iovcnt
= pdu_copy_sg(pdu
, offset
, 1, iov
);
808 V9fsString
*str
= va_arg(ap
, V9fsString
*);
809 offset
+= pdu_marshal(pdu
, offset
, "w", str
->size
);
810 offset
+= pdu_pack(pdu
, offset
, str
->data
, str
->size
);
814 V9fsQID
*qidp
= va_arg(ap
, V9fsQID
*);
815 offset
+= pdu_marshal(pdu
, offset
, "bdq",
816 qidp
->type
, qidp
->version
, qidp
->path
);
820 V9fsStat
*statp
= va_arg(ap
, V9fsStat
*);
821 offset
+= pdu_marshal(pdu
, offset
, "wwdQdddqsssssddd",
822 statp
->size
, statp
->type
, statp
->dev
,
823 &statp
->qid
, statp
->mode
, statp
->atime
,
824 statp
->mtime
, statp
->length
, &statp
->name
,
825 &statp
->uid
, &statp
->gid
, &statp
->muid
,
826 &statp
->extension
, statp
->n_uid
,
827 statp
->n_gid
, statp
->n_muid
);
831 V9fsStatDotl
*statp
= va_arg(ap
, V9fsStatDotl
*);
832 offset
+= pdu_marshal(pdu
, offset
, "qQdddqqqqqqqqqqqqqqq",
833 statp
->st_result_mask
,
834 &statp
->qid
, statp
->st_mode
,
835 statp
->st_uid
, statp
->st_gid
,
836 statp
->st_nlink
, statp
->st_rdev
,
837 statp
->st_size
, statp
->st_blksize
, statp
->st_blocks
,
838 statp
->st_atime_sec
, statp
->st_atime_nsec
,
839 statp
->st_mtime_sec
, statp
->st_mtime_nsec
,
840 statp
->st_ctime_sec
, statp
->st_ctime_nsec
,
841 statp
->st_btime_sec
, statp
->st_btime_nsec
,
842 statp
->st_gen
, statp
->st_data_version
);
851 return offset
- old_offset
;
854 static void complete_pdu(V9fsState
*s
, V9fsPDU
*pdu
, ssize_t len
)
856 int8_t id
= pdu
->id
+ 1; /* Response */
862 if (s
->proto_version
!= V9FS_PROTO_2000L
) {
865 str
.data
= strerror(err
);
866 str
.size
= strlen(str
.data
);
868 len
+= pdu_marshal(pdu
, len
, "s", &str
);
872 len
+= pdu_marshal(pdu
, len
, "d", err
);
874 if (s
->proto_version
== V9FS_PROTO_2000L
) {
879 /* fill out the header */
880 pdu_marshal(pdu
, 0, "dbw", (int32_t)len
, id
, pdu
->tag
);
882 /* keep these in sync */
886 /* push onto queue and notify */
887 virtqueue_push(s
->vq
, &pdu
->elem
, len
);
889 /* FIXME: we should batch these completions */
890 virtio_notify(&s
->vdev
, s
->vq
);
895 static mode_t
v9mode_to_mode(uint32_t mode
, V9fsString
*extension
)
900 if (mode
& P9_STAT_MODE_DIR
) {
904 if (mode
& P9_STAT_MODE_SYMLINK
) {
907 if (mode
& P9_STAT_MODE_SOCKET
) {
910 if (mode
& P9_STAT_MODE_NAMED_PIPE
) {
913 if (mode
& P9_STAT_MODE_DEVICE
) {
914 if (extension
&& extension
->data
[0] == 'c') {
925 if (mode
& P9_STAT_MODE_SETUID
) {
928 if (mode
& P9_STAT_MODE_SETGID
) {
931 if (mode
& P9_STAT_MODE_SETVTX
) {
938 static int donttouch_stat(V9fsStat
*stat
)
940 if (stat
->type
== -1 &&
942 stat
->qid
.type
== -1 &&
943 stat
->qid
.version
== -1 &&
944 stat
->qid
.path
== -1 &&
948 stat
->length
== -1 &&
955 stat
->n_muid
== -1) {
962 static void v9fs_stat_free(V9fsStat
*stat
)
964 v9fs_string_free(&stat
->name
);
965 v9fs_string_free(&stat
->uid
);
966 v9fs_string_free(&stat
->gid
);
967 v9fs_string_free(&stat
->muid
);
968 v9fs_string_free(&stat
->extension
);
971 static uint32_t stat_to_v9mode(const struct stat
*stbuf
)
975 mode
= stbuf
->st_mode
& 0777;
976 if (S_ISDIR(stbuf
->st_mode
)) {
977 mode
|= P9_STAT_MODE_DIR
;
980 if (S_ISLNK(stbuf
->st_mode
)) {
981 mode
|= P9_STAT_MODE_SYMLINK
;
984 if (S_ISSOCK(stbuf
->st_mode
)) {
985 mode
|= P9_STAT_MODE_SOCKET
;
988 if (S_ISFIFO(stbuf
->st_mode
)) {
989 mode
|= P9_STAT_MODE_NAMED_PIPE
;
992 if (S_ISBLK(stbuf
->st_mode
) || S_ISCHR(stbuf
->st_mode
)) {
993 mode
|= P9_STAT_MODE_DEVICE
;
996 if (stbuf
->st_mode
& S_ISUID
) {
997 mode
|= P9_STAT_MODE_SETUID
;
1000 if (stbuf
->st_mode
& S_ISGID
) {
1001 mode
|= P9_STAT_MODE_SETGID
;
1004 if (stbuf
->st_mode
& S_ISVTX
) {
1005 mode
|= P9_STAT_MODE_SETVTX
;
1011 static int stat_to_v9stat(V9fsState
*s
, V9fsString
*name
,
1012 const struct stat
*stbuf
,
1018 memset(v9stat
, 0, sizeof(*v9stat
));
1020 stat_to_qid(stbuf
, &v9stat
->qid
);
1021 v9stat
->mode
= stat_to_v9mode(stbuf
);
1022 v9stat
->atime
= stbuf
->st_atime
;
1023 v9stat
->mtime
= stbuf
->st_mtime
;
1024 v9stat
->length
= stbuf
->st_size
;
1026 v9fs_string_null(&v9stat
->uid
);
1027 v9fs_string_null(&v9stat
->gid
);
1028 v9fs_string_null(&v9stat
->muid
);
1030 v9stat
->n_uid
= stbuf
->st_uid
;
1031 v9stat
->n_gid
= stbuf
->st_gid
;
1034 v9fs_string_null(&v9stat
->extension
);
1036 if (v9stat
->mode
& P9_STAT_MODE_SYMLINK
) {
1037 err
= v9fs_do_readlink(s
, name
, &v9stat
->extension
);
1042 v9stat
->extension
.data
[err
] = 0;
1043 v9stat
->extension
.size
= err
;
1044 } else if (v9stat
->mode
& P9_STAT_MODE_DEVICE
) {
1045 v9fs_string_sprintf(&v9stat
->extension
, "%c %u %u",
1046 S_ISCHR(stbuf
->st_mode
) ? 'c' : 'b',
1047 major(stbuf
->st_rdev
), minor(stbuf
->st_rdev
));
1048 } else if (S_ISDIR(stbuf
->st_mode
) || S_ISREG(stbuf
->st_mode
)) {
1049 v9fs_string_sprintf(&v9stat
->extension
, "%s %lu",
1050 "HARDLINKCOUNT", (unsigned long)stbuf
->st_nlink
);
1053 str
= strrchr(name
->data
, '/');
1060 v9fs_string_sprintf(&v9stat
->name
, "%s", str
);
1063 v9fs_string_size(&v9stat
->name
) +
1064 v9fs_string_size(&v9stat
->uid
) +
1065 v9fs_string_size(&v9stat
->gid
) +
1066 v9fs_string_size(&v9stat
->muid
) +
1067 v9fs_string_size(&v9stat
->extension
);
1071 #define P9_STATS_MODE 0x00000001ULL
1072 #define P9_STATS_NLINK 0x00000002ULL
1073 #define P9_STATS_UID 0x00000004ULL
1074 #define P9_STATS_GID 0x00000008ULL
1075 #define P9_STATS_RDEV 0x00000010ULL
1076 #define P9_STATS_ATIME 0x00000020ULL
1077 #define P9_STATS_MTIME 0x00000040ULL
1078 #define P9_STATS_CTIME 0x00000080ULL
1079 #define P9_STATS_INO 0x00000100ULL
1080 #define P9_STATS_SIZE 0x00000200ULL
1081 #define P9_STATS_BLOCKS 0x00000400ULL
1083 #define P9_STATS_BTIME 0x00000800ULL
1084 #define P9_STATS_GEN 0x00001000ULL
1085 #define P9_STATS_DATA_VERSION 0x00002000ULL
1087 #define P9_STATS_BASIC 0x000007ffULL /* Mask for fields up to BLOCKS */
1088 #define P9_STATS_ALL 0x00003fffULL /* Mask for All fields above */
1091 static void stat_to_v9stat_dotl(V9fsState
*s
, const struct stat
*stbuf
,
1092 V9fsStatDotl
*v9lstat
)
1094 memset(v9lstat
, 0, sizeof(*v9lstat
));
1096 v9lstat
->st_mode
= stbuf
->st_mode
;
1097 v9lstat
->st_nlink
= stbuf
->st_nlink
;
1098 v9lstat
->st_uid
= stbuf
->st_uid
;
1099 v9lstat
->st_gid
= stbuf
->st_gid
;
1100 v9lstat
->st_rdev
= stbuf
->st_rdev
;
1101 v9lstat
->st_size
= stbuf
->st_size
;
1102 v9lstat
->st_blksize
= stbuf
->st_blksize
;
1103 v9lstat
->st_blocks
= stbuf
->st_blocks
;
1104 v9lstat
->st_atime_sec
= stbuf
->st_atime
;
1105 v9lstat
->st_atime_nsec
= stbuf
->st_atim
.tv_nsec
;
1106 v9lstat
->st_mtime_sec
= stbuf
->st_mtime
;
1107 v9lstat
->st_mtime_nsec
= stbuf
->st_mtim
.tv_nsec
;
1108 v9lstat
->st_ctime_sec
= stbuf
->st_ctime
;
1109 v9lstat
->st_ctime_nsec
= stbuf
->st_ctim
.tv_nsec
;
1110 /* Currently we only support BASIC fields in stat */
1111 v9lstat
->st_result_mask
= P9_STATS_BASIC
;
1113 stat_to_qid(stbuf
, &v9lstat
->qid
);
1116 static struct iovec
*adjust_sg(struct iovec
*sg
, int len
, int *iovcnt
)
1118 while (len
&& *iovcnt
) {
1119 if (len
< sg
->iov_len
) {
1121 sg
->iov_base
+= len
;
1133 static struct iovec
*cap_sg(struct iovec
*sg
, int cap
, int *cnt
)
1138 for (i
= 0; i
< *cnt
; i
++) {
1139 if ((total
+ sg
[i
].iov_len
) > cap
) {
1140 sg
[i
].iov_len
-= ((total
+ sg
[i
].iov_len
) - cap
);
1144 total
+= sg
[i
].iov_len
;
1152 static void print_sg(struct iovec
*sg
, int cnt
)
1156 printf("sg[%d]: {", cnt
);
1157 for (i
= 0; i
< cnt
; i
++) {
1161 printf("(%p, %zd)", sg
[i
].iov_base
, sg
[i
].iov_len
);
1166 static void v9fs_fix_path(V9fsString
*dst
, V9fsString
*src
, int len
)
1169 v9fs_string_init(&str
);
1170 v9fs_string_copy(&str
, dst
);
1171 v9fs_string_sprintf(dst
, "%s%s", src
->data
, str
.data
+len
);
1172 v9fs_string_free(&str
);
1175 static void v9fs_version(V9fsState
*s
, V9fsPDU
*pdu
)
1180 pdu_unmarshal(pdu
, offset
, "ds", &s
->msize
, &version
);
1182 if (!strcmp(version
.data
, "9P2000.u")) {
1183 s
->proto_version
= V9FS_PROTO_2000U
;
1184 } else if (!strcmp(version
.data
, "9P2000.L")) {
1185 s
->proto_version
= V9FS_PROTO_2000L
;
1187 v9fs_string_sprintf(&version
, "unknown");
1190 offset
+= pdu_marshal(pdu
, offset
, "ds", s
->msize
, &version
);
1191 complete_pdu(s
, pdu
, offset
);
1193 v9fs_string_free(&version
);
1196 static void v9fs_attach(V9fsState
*s
, V9fsPDU
*pdu
)
1198 int32_t fid
, afid
, n_uname
;
1199 V9fsString uname
, aname
;
1205 pdu_unmarshal(pdu
, offset
, "ddssd", &fid
, &afid
, &uname
, &aname
, &n_uname
);
1207 fidp
= alloc_fid(s
, fid
);
1213 fidp
->uid
= n_uname
;
1215 v9fs_string_sprintf(&fidp
->path
, "%s", "/");
1216 err
= fid_to_qid(s
, fidp
, &qid
);
1223 offset
+= pdu_marshal(pdu
, offset
, "Q", &qid
);
1227 complete_pdu(s
, pdu
, err
);
1228 v9fs_string_free(&uname
);
1229 v9fs_string_free(&aname
);
1232 static void v9fs_stat_post_lstat(V9fsState
*s
, V9fsStatState
*vs
, int err
)
1239 err
= stat_to_v9stat(s
, &vs
->fidp
->path
, &vs
->stbuf
, &vs
->v9stat
);
1243 vs
->offset
+= pdu_marshal(vs
->pdu
, vs
->offset
, "wS", 0, &vs
->v9stat
);
1247 complete_pdu(s
, vs
->pdu
, err
);
1248 v9fs_stat_free(&vs
->v9stat
);
1252 static void v9fs_stat(V9fsState
*s
, V9fsPDU
*pdu
)
1258 vs
= qemu_malloc(sizeof(*vs
));
1262 memset(&vs
->v9stat
, 0, sizeof(vs
->v9stat
));
1264 pdu_unmarshal(vs
->pdu
, vs
->offset
, "d", &fid
);
1266 vs
->fidp
= lookup_fid(s
, fid
);
1267 if (vs
->fidp
== NULL
) {
1272 err
= v9fs_do_lstat(s
, &vs
->fidp
->path
, &vs
->stbuf
);
1273 v9fs_stat_post_lstat(s
, vs
, err
);
1277 complete_pdu(s
, vs
->pdu
, err
);
1278 v9fs_stat_free(&vs
->v9stat
);
1282 static void v9fs_getattr_post_lstat(V9fsState
*s
, V9fsStatStateDotl
*vs
,
1290 stat_to_v9stat_dotl(s
, &vs
->stbuf
, &vs
->v9stat_dotl
);
1291 vs
->offset
+= pdu_marshal(vs
->pdu
, vs
->offset
, "A", &vs
->v9stat_dotl
);
1295 complete_pdu(s
, vs
->pdu
, err
);
1299 static void v9fs_getattr(V9fsState
*s
, V9fsPDU
*pdu
)
1302 V9fsStatStateDotl
*vs
;
1305 uint64_t request_mask
;
1307 vs
= qemu_malloc(sizeof(*vs
));
1311 memset(&vs
->v9stat_dotl
, 0, sizeof(vs
->v9stat_dotl
));
1313 pdu_unmarshal(vs
->pdu
, vs
->offset
, "dq", &fid
, &request_mask
);
1315 fidp
= lookup_fid(s
, fid
);
1321 /* Currently we only support BASIC fields in stat, so there is no
1322 * need to look at request_mask.
1324 err
= v9fs_do_lstat(s
, &fidp
->path
, &vs
->stbuf
);
1325 v9fs_getattr_post_lstat(s
, vs
, err
);
1329 complete_pdu(s
, vs
->pdu
, err
);
1333 /* From Linux kernel code */
1334 #define ATTR_MODE (1 << 0)
1335 #define ATTR_UID (1 << 1)
1336 #define ATTR_GID (1 << 2)
1337 #define ATTR_SIZE (1 << 3)
1338 #define ATTR_ATIME (1 << 4)
1339 #define ATTR_MTIME (1 << 5)
1340 #define ATTR_CTIME (1 << 6)
1341 #define ATTR_MASK 127
1342 #define ATTR_ATIME_SET (1 << 7)
1343 #define ATTR_MTIME_SET (1 << 8)
1345 static void v9fs_setattr_post_truncate(V9fsState
*s
, V9fsSetattrState
*vs
,
1355 complete_pdu(s
, vs
->pdu
, err
);
1359 static void v9fs_setattr_post_chown(V9fsState
*s
, V9fsSetattrState
*vs
, int err
)
1366 if (vs
->v9iattr
.valid
& (ATTR_SIZE
)) {
1367 err
= v9fs_do_truncate(s
, &vs
->fidp
->path
, vs
->v9iattr
.size
);
1369 v9fs_setattr_post_truncate(s
, vs
, err
);
1373 complete_pdu(s
, vs
->pdu
, err
);
1377 static void v9fs_setattr_post_utimensat(V9fsState
*s
, V9fsSetattrState
*vs
,
1385 /* If the only valid entry in iattr is ctime we can call
1386 * chown(-1,-1) to update the ctime of the file
1388 if ((vs
->v9iattr
.valid
& (ATTR_UID
| ATTR_GID
)) ||
1389 ((vs
->v9iattr
.valid
& ATTR_CTIME
)
1390 && !((vs
->v9iattr
.valid
& ATTR_MASK
) & ~ATTR_CTIME
))) {
1391 if (!(vs
->v9iattr
.valid
& ATTR_UID
)) {
1392 vs
->v9iattr
.uid
= -1;
1394 if (!(vs
->v9iattr
.valid
& ATTR_GID
)) {
1395 vs
->v9iattr
.gid
= -1;
1397 err
= v9fs_do_chown(s
, &vs
->fidp
->path
, vs
->v9iattr
.uid
,
1400 v9fs_setattr_post_chown(s
, vs
, err
);
1404 complete_pdu(s
, vs
->pdu
, err
);
1408 static void v9fs_setattr_post_chmod(V9fsState
*s
, V9fsSetattrState
*vs
, int err
)
1415 if (vs
->v9iattr
.valid
& (ATTR_ATIME
| ATTR_MTIME
)) {
1416 struct timespec times
[2];
1417 if (vs
->v9iattr
.valid
& ATTR_ATIME
) {
1418 if (vs
->v9iattr
.valid
& ATTR_ATIME_SET
) {
1419 times
[0].tv_sec
= vs
->v9iattr
.atime_sec
;
1420 times
[0].tv_nsec
= vs
->v9iattr
.atime_nsec
;
1422 times
[0].tv_nsec
= UTIME_NOW
;
1425 times
[0].tv_nsec
= UTIME_OMIT
;
1428 if (vs
->v9iattr
.valid
& ATTR_MTIME
) {
1429 if (vs
->v9iattr
.valid
& ATTR_MTIME_SET
) {
1430 times
[1].tv_sec
= vs
->v9iattr
.mtime_sec
;
1431 times
[1].tv_nsec
= vs
->v9iattr
.mtime_nsec
;
1433 times
[1].tv_nsec
= UTIME_NOW
;
1436 times
[1].tv_nsec
= UTIME_OMIT
;
1438 err
= v9fs_do_utimensat(s
, &vs
->fidp
->path
, times
);
1440 v9fs_setattr_post_utimensat(s
, vs
, err
);
1444 complete_pdu(s
, vs
->pdu
, err
);
1448 static void v9fs_setattr(V9fsState
*s
, V9fsPDU
*pdu
)
1451 V9fsSetattrState
*vs
;
1454 vs
= qemu_malloc(sizeof(*vs
));
1458 pdu_unmarshal(pdu
, vs
->offset
, "dI", &fid
, &vs
->v9iattr
);
1460 vs
->fidp
= lookup_fid(s
, fid
);
1461 if (vs
->fidp
== NULL
) {
1466 if (vs
->v9iattr
.valid
& ATTR_MODE
) {
1467 err
= v9fs_do_chmod(s
, &vs
->fidp
->path
, vs
->v9iattr
.mode
);
1470 v9fs_setattr_post_chmod(s
, vs
, err
);
1474 complete_pdu(s
, vs
->pdu
, err
);
1478 static void v9fs_walk_complete(V9fsState
*s
, V9fsWalkState
*vs
, int err
)
1480 complete_pdu(s
, vs
->pdu
, err
);
1483 for (vs
->name_idx
= 0; vs
->name_idx
< vs
->nwnames
; vs
->name_idx
++) {
1484 v9fs_string_free(&vs
->wnames
[vs
->name_idx
]);
1487 qemu_free(vs
->wnames
);
1488 qemu_free(vs
->qids
);
1492 static void v9fs_walk_marshal(V9fsWalkState
*vs
)
1496 vs
->offset
+= pdu_marshal(vs
->pdu
, vs
->offset
, "w", vs
->nwnames
);
1498 for (i
= 0; i
< vs
->nwnames
; i
++) {
1499 vs
->offset
+= pdu_marshal(vs
->pdu
, vs
->offset
, "Q", &vs
->qids
[i
]);
1503 static void v9fs_walk_post_newfid_lstat(V9fsState
*s
, V9fsWalkState
*vs
,
1507 free_fid(s
, vs
->newfidp
->fid
);
1508 v9fs_string_free(&vs
->path
);
1513 stat_to_qid(&vs
->stbuf
, &vs
->qids
[vs
->name_idx
]);
1516 if (vs
->name_idx
< vs
->nwnames
) {
1517 v9fs_string_sprintf(&vs
->path
, "%s/%s", vs
->newfidp
->path
.data
,
1518 vs
->wnames
[vs
->name_idx
].data
);
1519 v9fs_string_copy(&vs
->newfidp
->path
, &vs
->path
);
1521 err
= v9fs_do_lstat(s
, &vs
->newfidp
->path
, &vs
->stbuf
);
1522 v9fs_walk_post_newfid_lstat(s
, vs
, err
);
1526 v9fs_string_free(&vs
->path
);
1527 v9fs_walk_marshal(vs
);
1530 v9fs_walk_complete(s
, vs
, err
);
1533 static void v9fs_walk_post_oldfid_lstat(V9fsState
*s
, V9fsWalkState
*vs
,
1537 v9fs_string_free(&vs
->path
);
1542 stat_to_qid(&vs
->stbuf
, &vs
->qids
[vs
->name_idx
]);
1544 if (vs
->name_idx
< vs
->nwnames
) {
1546 v9fs_string_sprintf(&vs
->path
, "%s/%s",
1547 vs
->fidp
->path
.data
, vs
->wnames
[vs
->name_idx
].data
);
1548 v9fs_string_copy(&vs
->fidp
->path
, &vs
->path
);
1550 err
= v9fs_do_lstat(s
, &vs
->fidp
->path
, &vs
->stbuf
);
1551 v9fs_walk_post_oldfid_lstat(s
, vs
, err
);
1555 v9fs_string_free(&vs
->path
);
1556 v9fs_walk_marshal(vs
);
1559 v9fs_walk_complete(s
, vs
, err
);
1562 static void v9fs_walk(V9fsState
*s
, V9fsPDU
*pdu
)
1564 int32_t fid
, newfid
;
1569 vs
= qemu_malloc(sizeof(*vs
));
1575 vs
->offset
+= pdu_unmarshal(vs
->pdu
, vs
->offset
, "ddw", &fid
,
1576 &newfid
, &vs
->nwnames
);
1579 vs
->wnames
= qemu_mallocz(sizeof(vs
->wnames
[0]) * vs
->nwnames
);
1581 vs
->qids
= qemu_mallocz(sizeof(vs
->qids
[0]) * vs
->nwnames
);
1583 for (i
= 0; i
< vs
->nwnames
; i
++) {
1584 vs
->offset
+= pdu_unmarshal(vs
->pdu
, vs
->offset
, "s",
1589 vs
->fidp
= lookup_fid(s
, fid
);
1590 if (vs
->fidp
== NULL
) {
1595 /* FIXME: is this really valid? */
1596 if (fid
== newfid
) {
1598 BUG_ON(vs
->fidp
->fid_type
!= P9_FID_NONE
);
1599 v9fs_string_init(&vs
->path
);
1602 if (vs
->name_idx
< vs
->nwnames
) {
1603 v9fs_string_sprintf(&vs
->path
, "%s/%s",
1604 vs
->fidp
->path
.data
, vs
->wnames
[vs
->name_idx
].data
);
1605 v9fs_string_copy(&vs
->fidp
->path
, &vs
->path
);
1607 err
= v9fs_do_lstat(s
, &vs
->fidp
->path
, &vs
->stbuf
);
1608 v9fs_walk_post_oldfid_lstat(s
, vs
, err
);
1612 vs
->newfidp
= alloc_fid(s
, newfid
);
1613 if (vs
->newfidp
== NULL
) {
1618 vs
->newfidp
->uid
= vs
->fidp
->uid
;
1619 v9fs_string_init(&vs
->path
);
1621 v9fs_string_copy(&vs
->newfidp
->path
, &vs
->fidp
->path
);
1623 if (vs
->name_idx
< vs
->nwnames
) {
1624 v9fs_string_sprintf(&vs
->path
, "%s/%s", vs
->newfidp
->path
.data
,
1625 vs
->wnames
[vs
->name_idx
].data
);
1626 v9fs_string_copy(&vs
->newfidp
->path
, &vs
->path
);
1628 err
= v9fs_do_lstat(s
, &vs
->newfidp
->path
, &vs
->stbuf
);
1629 v9fs_walk_post_newfid_lstat(s
, vs
, err
);
1634 v9fs_walk_marshal(vs
);
1637 v9fs_walk_complete(s
, vs
, err
);
1640 static int32_t get_iounit(V9fsState
*s
, V9fsString
*name
)
1642 struct statfs stbuf
;
1646 * iounit should be multiples of f_bsize (host filesystem block size
1647 * and as well as less than (client msize - P9_IOHDRSZ))
1649 if (!v9fs_do_statfs(s
, name
, &stbuf
)) {
1650 iounit
= stbuf
.f_bsize
;
1651 iounit
*= (s
->msize
- P9_IOHDRSZ
)/stbuf
.f_bsize
;
1655 iounit
= s
->msize
- P9_IOHDRSZ
;
1660 static void v9fs_open_post_opendir(V9fsState
*s
, V9fsOpenState
*vs
, int err
)
1662 if (vs
->fidp
->fs
.dir
== NULL
) {
1666 vs
->fidp
->fid_type
= P9_FID_DIR
;
1667 vs
->offset
+= pdu_marshal(vs
->pdu
, vs
->offset
, "Qd", &vs
->qid
, 0);
1670 complete_pdu(s
, vs
->pdu
, err
);
1675 static void v9fs_open_post_getiounit(V9fsState
*s
, V9fsOpenState
*vs
)
1678 vs
->offset
+= pdu_marshal(vs
->pdu
, vs
->offset
, "Qd", &vs
->qid
, vs
->iounit
);
1680 complete_pdu(s
, vs
->pdu
, err
);
1684 static void v9fs_open_post_open(V9fsState
*s
, V9fsOpenState
*vs
, int err
)
1686 if (vs
->fidp
->fs
.fd
== -1) {
1690 vs
->fidp
->fid_type
= P9_FID_FILE
;
1691 vs
->iounit
= get_iounit(s
, &vs
->fidp
->path
);
1692 v9fs_open_post_getiounit(s
, vs
);
1695 complete_pdu(s
, vs
->pdu
, err
);
1699 static void v9fs_open_post_lstat(V9fsState
*s
, V9fsOpenState
*vs
, int err
)
1708 stat_to_qid(&vs
->stbuf
, &vs
->qid
);
1710 if (S_ISDIR(vs
->stbuf
.st_mode
)) {
1711 vs
->fidp
->fs
.dir
= v9fs_do_opendir(s
, &vs
->fidp
->path
);
1712 v9fs_open_post_opendir(s
, vs
, err
);
1714 if (s
->proto_version
== V9FS_PROTO_2000L
) {
1716 flags
&= ~(O_NOCTTY
| O_ASYNC
| O_CREAT
);
1717 /* Ignore direct disk access hint until the server supports it. */
1720 flags
= omode_to_uflags(vs
->mode
);
1722 vs
->fidp
->fs
.fd
= v9fs_do_open(s
, &vs
->fidp
->path
, flags
);
1723 v9fs_open_post_open(s
, vs
, err
);
1727 complete_pdu(s
, vs
->pdu
, err
);
1731 static void v9fs_open(V9fsState
*s
, V9fsPDU
*pdu
)
1737 vs
= qemu_malloc(sizeof(*vs
));
1742 if (s
->proto_version
== V9FS_PROTO_2000L
) {
1743 pdu_unmarshal(vs
->pdu
, vs
->offset
, "dd", &fid
, &vs
->mode
);
1745 pdu_unmarshal(vs
->pdu
, vs
->offset
, "db", &fid
, &vs
->mode
);
1748 vs
->fidp
= lookup_fid(s
, fid
);
1749 if (vs
->fidp
== NULL
) {
1754 BUG_ON(vs
->fidp
->fid_type
!= P9_FID_NONE
);
1756 err
= v9fs_do_lstat(s
, &vs
->fidp
->path
, &vs
->stbuf
);
1758 v9fs_open_post_lstat(s
, vs
, err
);
1761 complete_pdu(s
, pdu
, err
);
1765 static void v9fs_post_lcreate(V9fsState
*s
, V9fsLcreateState
*vs
, int err
)
1768 v9fs_string_copy(&vs
->fidp
->path
, &vs
->fullname
);
1769 stat_to_qid(&vs
->stbuf
, &vs
->qid
);
1770 vs
->offset
+= pdu_marshal(vs
->pdu
, vs
->offset
, "Qd", &vs
->qid
,
1774 vs
->fidp
->fid_type
= P9_FID_NONE
;
1776 if (vs
->fidp
->fs
.fd
> 0) {
1777 close(vs
->fidp
->fs
.fd
);
1781 complete_pdu(s
, vs
->pdu
, err
);
1782 v9fs_string_free(&vs
->name
);
1783 v9fs_string_free(&vs
->fullname
);
1787 static void v9fs_lcreate_post_get_iounit(V9fsState
*s
, V9fsLcreateState
*vs
,
1794 err
= v9fs_do_lstat(s
, &vs
->fullname
, &vs
->stbuf
);
1797 v9fs_post_lcreate(s
, vs
, err
);
1800 static void v9fs_lcreate_post_do_open2(V9fsState
*s
, V9fsLcreateState
*vs
,
1803 if (vs
->fidp
->fs
.fd
== -1) {
1807 vs
->fidp
->fid_type
= P9_FID_FILE
;
1808 vs
->iounit
= get_iounit(s
, &vs
->fullname
);
1809 v9fs_lcreate_post_get_iounit(s
, vs
, err
);
1813 v9fs_post_lcreate(s
, vs
, err
);
1816 static void v9fs_lcreate(V9fsState
*s
, V9fsPDU
*pdu
)
1818 int32_t dfid
, flags
, mode
;
1820 V9fsLcreateState
*vs
;
1823 vs
= qemu_malloc(sizeof(*vs
));
1827 v9fs_string_init(&vs
->fullname
);
1829 pdu_unmarshal(vs
->pdu
, vs
->offset
, "dsddd", &dfid
, &vs
->name
, &flags
,
1832 vs
->fidp
= lookup_fid(s
, dfid
);
1833 if (vs
->fidp
== NULL
) {
1838 v9fs_string_sprintf(&vs
->fullname
, "%s/%s", vs
->fidp
->path
.data
,
1841 /* Ignore direct disk access hint until the server supports it. */
1844 vs
->fidp
->fs
.fd
= v9fs_do_open2(s
, vs
->fullname
.data
, vs
->fidp
->uid
,
1846 v9fs_lcreate_post_do_open2(s
, vs
, err
);
1850 complete_pdu(s
, vs
->pdu
, err
);
1851 v9fs_string_free(&vs
->name
);
1855 static void v9fs_post_do_fsync(V9fsState
*s
, V9fsPDU
*pdu
, int err
)
1860 complete_pdu(s
, pdu
, err
);
1863 static void v9fs_fsync(V9fsState
*s
, V9fsPDU
*pdu
)
1871 pdu_unmarshal(pdu
, offset
, "dd", &fid
, &datasync
);
1872 fidp
= lookup_fid(s
, fid
);
1875 v9fs_post_do_fsync(s
, pdu
, err
);
1878 err
= v9fs_do_fsync(s
, fidp
->fs
.fd
, datasync
);
1879 v9fs_post_do_fsync(s
, pdu
, err
);
1882 static void v9fs_clunk(V9fsState
*s
, V9fsPDU
*pdu
)
1888 pdu_unmarshal(pdu
, offset
, "d", &fid
);
1890 err
= free_fid(s
, fid
);
1898 complete_pdu(s
, pdu
, err
);
1901 static void v9fs_read_post_readdir(V9fsState
*, V9fsReadState
*, ssize_t
);
1903 static void v9fs_read_post_seekdir(V9fsState
*s
, V9fsReadState
*vs
, ssize_t err
)
1908 v9fs_stat_free(&vs
->v9stat
);
1909 v9fs_string_free(&vs
->name
);
1910 vs
->offset
+= pdu_marshal(vs
->pdu
, vs
->offset
, "d", vs
->count
);
1911 vs
->offset
+= vs
->count
;
1914 complete_pdu(s
, vs
->pdu
, err
);
1919 static void v9fs_read_post_dir_lstat(V9fsState
*s
, V9fsReadState
*vs
,
1926 err
= stat_to_v9stat(s
, &vs
->name
, &vs
->stbuf
, &vs
->v9stat
);
1931 vs
->len
= pdu_marshal(vs
->pdu
, vs
->offset
+ 4 + vs
->count
, "S",
1933 if ((vs
->len
!= (vs
->v9stat
.size
+ 2)) ||
1934 ((vs
->count
+ vs
->len
) > vs
->max_count
)) {
1935 v9fs_do_seekdir(s
, vs
->fidp
->fs
.dir
, vs
->dir_pos
);
1936 v9fs_read_post_seekdir(s
, vs
, err
);
1939 vs
->count
+= vs
->len
;
1940 v9fs_stat_free(&vs
->v9stat
);
1941 v9fs_string_free(&vs
->name
);
1942 vs
->dir_pos
= vs
->dent
->d_off
;
1943 vs
->dent
= v9fs_do_readdir(s
, vs
->fidp
->fs
.dir
);
1944 v9fs_read_post_readdir(s
, vs
, err
);
1947 v9fs_do_seekdir(s
, vs
->fidp
->fs
.dir
, vs
->dir_pos
);
1948 v9fs_read_post_seekdir(s
, vs
, err
);
1953 static void v9fs_read_post_readdir(V9fsState
*s
, V9fsReadState
*vs
, ssize_t err
)
1956 memset(&vs
->v9stat
, 0, sizeof(vs
->v9stat
));
1957 v9fs_string_init(&vs
->name
);
1958 v9fs_string_sprintf(&vs
->name
, "%s/%s", vs
->fidp
->path
.data
,
1960 err
= v9fs_do_lstat(s
, &vs
->name
, &vs
->stbuf
);
1961 v9fs_read_post_dir_lstat(s
, vs
, err
);
1965 vs
->offset
+= pdu_marshal(vs
->pdu
, vs
->offset
, "d", vs
->count
);
1966 vs
->offset
+= vs
->count
;
1968 complete_pdu(s
, vs
->pdu
, err
);
1973 static void v9fs_read_post_telldir(V9fsState
*s
, V9fsReadState
*vs
, ssize_t err
)
1975 vs
->dent
= v9fs_do_readdir(s
, vs
->fidp
->fs
.dir
);
1976 v9fs_read_post_readdir(s
, vs
, err
);
1980 static void v9fs_read_post_rewinddir(V9fsState
*s
, V9fsReadState
*vs
,
1983 vs
->dir_pos
= v9fs_do_telldir(s
, vs
->fidp
->fs
.dir
);
1984 v9fs_read_post_telldir(s
, vs
, err
);
1988 static void v9fs_read_post_preadv(V9fsState
*s
, V9fsReadState
*vs
, ssize_t err
)
1991 /* IO error return the error */
1995 vs
->total
+= vs
->len
;
1996 vs
->sg
= adjust_sg(vs
->sg
, vs
->len
, &vs
->cnt
);
1997 if (vs
->total
< vs
->count
&& vs
->len
> 0) {
2000 print_sg(vs
->sg
, vs
->cnt
);
2002 vs
->len
= v9fs_do_preadv(s
, vs
->fidp
->fs
.fd
, vs
->sg
, vs
->cnt
,
2007 } while (vs
->len
== -1 && errno
== EINTR
);
2008 if (vs
->len
== -1) {
2011 v9fs_read_post_preadv(s
, vs
, err
);
2014 vs
->offset
+= pdu_marshal(vs
->pdu
, vs
->offset
, "d", vs
->total
);
2015 vs
->offset
+= vs
->count
;
2019 complete_pdu(s
, vs
->pdu
, err
);
2023 static void v9fs_xattr_read(V9fsState
*s
, V9fsReadState
*vs
)
2029 xattr_len
= vs
->fidp
->fs
.xattr
.len
;
2030 read_count
= xattr_len
- vs
->off
;
2031 if (read_count
> vs
->count
) {
2032 read_count
= vs
->count
;
2033 } else if (read_count
< 0) {
2035 * read beyond XATTR value
2039 vs
->offset
+= pdu_marshal(vs
->pdu
, vs
->offset
, "d", read_count
);
2040 vs
->offset
+= pdu_pack(vs
->pdu
, vs
->offset
,
2041 ((char *)vs
->fidp
->fs
.xattr
.value
) + vs
->off
,
2044 complete_pdu(s
, vs
->pdu
, err
);
2048 static void v9fs_read(V9fsState
*s
, V9fsPDU
*pdu
)
2054 vs
= qemu_malloc(sizeof(*vs
));
2061 pdu_unmarshal(vs
->pdu
, vs
->offset
, "dqd", &fid
, &vs
->off
, &vs
->count
);
2063 vs
->fidp
= lookup_fid(s
, fid
);
2064 if (vs
->fidp
== NULL
) {
2069 if (vs
->fidp
->fid_type
== P9_FID_DIR
) {
2070 vs
->max_count
= vs
->count
;
2073 v9fs_do_rewinddir(s
, vs
->fidp
->fs
.dir
);
2075 v9fs_read_post_rewinddir(s
, vs
, err
);
2077 } else if (vs
->fidp
->fid_type
== P9_FID_FILE
) {
2079 pdu_marshal(vs
->pdu
, vs
->offset
+ 4, "v", vs
->sg
, &vs
->cnt
);
2080 vs
->sg
= cap_sg(vs
->sg
, vs
->count
, &vs
->cnt
);
2081 if (vs
->total
<= vs
->count
) {
2082 vs
->len
= v9fs_do_preadv(s
, vs
->fidp
->fs
.fd
, vs
->sg
, vs
->cnt
,
2088 v9fs_read_post_preadv(s
, vs
, err
);
2091 } else if (vs
->fidp
->fid_type
== P9_FID_XATTR
) {
2092 v9fs_xattr_read(s
, vs
);
2098 complete_pdu(s
, pdu
, err
);
2102 typedef struct V9fsReadDirState
{
2106 off_t saved_dir_pos
;
2107 struct dirent
*dent
;
2111 int64_t initial_offset
;
2115 static void v9fs_readdir_post_seekdir(V9fsState
*s
, V9fsReadDirState
*vs
)
2117 vs
->offset
+= pdu_marshal(vs
->pdu
, vs
->offset
, "d", vs
->count
);
2118 vs
->offset
+= vs
->count
;
2119 complete_pdu(s
, vs
->pdu
, vs
->offset
);
2124 /* Size of each dirent on the wire: size of qid (13) + size of offset (8)
2125 * size of type (1) + size of name.size (2) + strlen(name.data)
2127 #define V9_READDIR_DATA_SZ (24 + strlen(vs->name.data))
2129 static void v9fs_readdir_post_readdir(V9fsState
*s
, V9fsReadDirState
*vs
)
2135 v9fs_string_init(&vs
->name
);
2136 v9fs_string_sprintf(&vs
->name
, "%s", vs
->dent
->d_name
);
2138 if ((vs
->count
+ V9_READDIR_DATA_SZ
) > vs
->max_count
) {
2139 /* Ran out of buffer. Set dir back to old position and return */
2140 v9fs_do_seekdir(s
, vs
->fidp
->fs
.dir
, vs
->saved_dir_pos
);
2141 v9fs_readdir_post_seekdir(s
, vs
);
2145 /* Fill up just the path field of qid because the client uses
2146 * only that. To fill the entire qid structure we will have
2147 * to stat each dirent found, which is expensive
2149 size
= MIN(sizeof(vs
->dent
->d_ino
), sizeof(vs
->qid
.path
));
2150 memcpy(&vs
->qid
.path
, &vs
->dent
->d_ino
, size
);
2151 /* Fill the other fields with dummy values */
2153 vs
->qid
.version
= 0;
2155 len
= pdu_marshal(vs
->pdu
, vs
->offset
+4+vs
->count
, "Qqbs",
2156 &vs
->qid
, vs
->dent
->d_off
,
2157 vs
->dent
->d_type
, &vs
->name
);
2159 v9fs_string_free(&vs
->name
);
2160 vs
->saved_dir_pos
= vs
->dent
->d_off
;
2161 vs
->dent
= v9fs_do_readdir(s
, vs
->fidp
->fs
.dir
);
2162 v9fs_readdir_post_readdir(s
, vs
);
2166 vs
->offset
+= pdu_marshal(vs
->pdu
, vs
->offset
, "d", vs
->count
);
2167 vs
->offset
+= vs
->count
;
2168 complete_pdu(s
, vs
->pdu
, vs
->offset
);
2173 static void v9fs_readdir_post_telldir(V9fsState
*s
, V9fsReadDirState
*vs
)
2175 vs
->dent
= v9fs_do_readdir(s
, vs
->fidp
->fs
.dir
);
2176 v9fs_readdir_post_readdir(s
, vs
);
2180 static void v9fs_readdir_post_setdir(V9fsState
*s
, V9fsReadDirState
*vs
)
2182 vs
->saved_dir_pos
= v9fs_do_telldir(s
, vs
->fidp
->fs
.dir
);
2183 v9fs_readdir_post_telldir(s
, vs
);
2187 static void v9fs_readdir(V9fsState
*s
, V9fsPDU
*pdu
)
2190 V9fsReadDirState
*vs
;
2194 vs
= qemu_malloc(sizeof(*vs
));
2199 pdu_unmarshal(vs
->pdu
, offset
, "dqd", &fid
, &vs
->initial_offset
,
2202 vs
->fidp
= lookup_fid(s
, fid
);
2203 if (vs
->fidp
== NULL
|| !(vs
->fidp
->fs
.dir
)) {
2208 if (vs
->initial_offset
== 0) {
2209 v9fs_do_rewinddir(s
, vs
->fidp
->fs
.dir
);
2211 v9fs_do_seekdir(s
, vs
->fidp
->fs
.dir
, vs
->initial_offset
);
2214 v9fs_readdir_post_setdir(s
, vs
);
2218 complete_pdu(s
, pdu
, err
);
2223 static void v9fs_write_post_pwritev(V9fsState
*s
, V9fsWriteState
*vs
,
2227 /* IO error return the error */
2231 vs
->total
+= vs
->len
;
2232 vs
->sg
= adjust_sg(vs
->sg
, vs
->len
, &vs
->cnt
);
2233 if (vs
->total
< vs
->count
&& vs
->len
> 0) {
2236 print_sg(vs
->sg
, vs
->cnt
);
2238 vs
->len
= v9fs_do_pwritev(s
, vs
->fidp
->fs
.fd
, vs
->sg
, vs
->cnt
,
2243 } while (vs
->len
== -1 && errno
== EINTR
);
2244 if (vs
->len
== -1) {
2247 v9fs_write_post_pwritev(s
, vs
, err
);
2250 vs
->offset
+= pdu_marshal(vs
->pdu
, vs
->offset
, "d", vs
->total
);
2253 complete_pdu(s
, vs
->pdu
, err
);
2257 static void v9fs_xattr_write(V9fsState
*s
, V9fsWriteState
*vs
)
2264 xattr_len
= vs
->fidp
->fs
.xattr
.len
;
2265 write_count
= xattr_len
- vs
->off
;
2266 if (write_count
> vs
->count
) {
2267 write_count
= vs
->count
;
2268 } else if (write_count
< 0) {
2270 * write beyond XATTR value len specified in
2276 vs
->offset
+= pdu_marshal(vs
->pdu
, vs
->offset
, "d", write_count
);
2278 vs
->fidp
->fs
.xattr
.copied_len
+= write_count
;
2280 * Now copy the content from sg list
2282 for (i
= 0; i
< vs
->cnt
; i
++) {
2283 if (write_count
> vs
->sg
[i
].iov_len
) {
2284 to_copy
= vs
->sg
[i
].iov_len
;
2286 to_copy
= write_count
;
2288 memcpy((char *)vs
->fidp
->fs
.xattr
.value
+ vs
->off
,
2289 vs
->sg
[i
].iov_base
, to_copy
);
2290 /* updating vs->off since we are not using below */
2292 write_count
-= to_copy
;
2295 complete_pdu(s
, vs
->pdu
, err
);
2299 static void v9fs_write(V9fsState
*s
, V9fsPDU
*pdu
)
2305 vs
= qemu_malloc(sizeof(*vs
));
2313 pdu_unmarshal(vs
->pdu
, vs
->offset
, "dqdv", &fid
, &vs
->off
, &vs
->count
,
2316 vs
->fidp
= lookup_fid(s
, fid
);
2317 if (vs
->fidp
== NULL
) {
2322 if (vs
->fidp
->fid_type
== P9_FID_FILE
) {
2323 if (vs
->fidp
->fs
.fd
== -1) {
2327 } else if (vs
->fidp
->fid_type
== P9_FID_XATTR
) {
2329 * setxattr operation
2331 v9fs_xattr_write(s
, vs
);
2337 vs
->sg
= cap_sg(vs
->sg
, vs
->count
, &vs
->cnt
);
2338 if (vs
->total
<= vs
->count
) {
2339 vs
->len
= v9fs_do_pwritev(s
, vs
->fidp
->fs
.fd
, vs
->sg
, vs
->cnt
, vs
->off
);
2344 v9fs_write_post_pwritev(s
, vs
, err
);
2348 complete_pdu(s
, vs
->pdu
, err
);
2352 static void v9fs_create_post_getiounit(V9fsState
*s
, V9fsCreateState
*vs
)
2355 v9fs_string_copy(&vs
->fidp
->path
, &vs
->fullname
);
2356 stat_to_qid(&vs
->stbuf
, &vs
->qid
);
2358 vs
->offset
+= pdu_marshal(vs
->pdu
, vs
->offset
, "Qd", &vs
->qid
, vs
->iounit
);
2361 complete_pdu(s
, vs
->pdu
, err
);
2362 v9fs_string_free(&vs
->name
);
2363 v9fs_string_free(&vs
->extension
);
2364 v9fs_string_free(&vs
->fullname
);
2368 static void v9fs_post_create(V9fsState
*s
, V9fsCreateState
*vs
, int err
)
2371 vs
->iounit
= get_iounit(s
, &vs
->fidp
->path
);
2372 v9fs_create_post_getiounit(s
, vs
);
2376 complete_pdu(s
, vs
->pdu
, err
);
2377 v9fs_string_free(&vs
->name
);
2378 v9fs_string_free(&vs
->extension
);
2379 v9fs_string_free(&vs
->fullname
);
2383 static void v9fs_create_post_perms(V9fsState
*s
, V9fsCreateState
*vs
, int err
)
2388 v9fs_post_create(s
, vs
, err
);
2391 static void v9fs_create_post_opendir(V9fsState
*s
, V9fsCreateState
*vs
,
2394 if (!vs
->fidp
->fs
.dir
) {
2397 vs
->fidp
->fid_type
= P9_FID_DIR
;
2398 v9fs_post_create(s
, vs
, err
);
2401 static void v9fs_create_post_dir_lstat(V9fsState
*s
, V9fsCreateState
*vs
,
2409 vs
->fidp
->fs
.dir
= v9fs_do_opendir(s
, &vs
->fullname
);
2410 v9fs_create_post_opendir(s
, vs
, err
);
2414 v9fs_post_create(s
, vs
, err
);
2417 static void v9fs_create_post_mkdir(V9fsState
*s
, V9fsCreateState
*vs
, int err
)
2424 err
= v9fs_do_lstat(s
, &vs
->fullname
, &vs
->stbuf
);
2425 v9fs_create_post_dir_lstat(s
, vs
, err
);
2429 v9fs_post_create(s
, vs
, err
);
2432 static void v9fs_create_post_fstat(V9fsState
*s
, V9fsCreateState
*vs
, int err
)
2435 vs
->fidp
->fid_type
= P9_FID_NONE
;
2436 close(vs
->fidp
->fs
.fd
);
2439 v9fs_post_create(s
, vs
, err
);
2443 static void v9fs_create_post_open2(V9fsState
*s
, V9fsCreateState
*vs
, int err
)
2445 if (vs
->fidp
->fs
.fd
== -1) {
2449 vs
->fidp
->fid_type
= P9_FID_FILE
;
2450 err
= v9fs_do_fstat(s
, vs
->fidp
->fs
.fd
, &vs
->stbuf
);
2451 v9fs_create_post_fstat(s
, vs
, err
);
2456 v9fs_post_create(s
, vs
, err
);
2460 static void v9fs_create_post_lstat(V9fsState
*s
, V9fsCreateState
*vs
, int err
)
2463 if (err
== 0 || errno
!= ENOENT
) {
2468 if (vs
->perm
& P9_STAT_MODE_DIR
) {
2469 err
= v9fs_do_mkdir(s
, vs
->fullname
.data
, vs
->perm
& 0777,
2471 v9fs_create_post_mkdir(s
, vs
, err
);
2472 } else if (vs
->perm
& P9_STAT_MODE_SYMLINK
) {
2473 err
= v9fs_do_symlink(s
, vs
->fidp
, vs
->extension
.data
,
2474 vs
->fullname
.data
, -1);
2475 v9fs_create_post_perms(s
, vs
, err
);
2476 } else if (vs
->perm
& P9_STAT_MODE_LINK
) {
2477 int32_t nfid
= atoi(vs
->extension
.data
);
2478 V9fsFidState
*nfidp
= lookup_fid(s
, nfid
);
2479 if (nfidp
== NULL
) {
2481 v9fs_post_create(s
, vs
, err
);
2483 err
= v9fs_do_link(s
, &nfidp
->path
, &vs
->fullname
);
2484 v9fs_create_post_perms(s
, vs
, err
);
2485 } else if (vs
->perm
& P9_STAT_MODE_DEVICE
) {
2487 uint32_t major
, minor
;
2490 if (sscanf(vs
->extension
.data
, "%c %u %u", &ctype
, &major
,
2493 v9fs_post_create(s
, vs
, err
);
2505 v9fs_post_create(s
, vs
, err
);
2508 nmode
|= vs
->perm
& 0777;
2509 err
= v9fs_do_mknod(s
, vs
->fullname
.data
, nmode
,
2510 makedev(major
, minor
), vs
->fidp
->uid
, -1);
2511 v9fs_create_post_perms(s
, vs
, err
);
2512 } else if (vs
->perm
& P9_STAT_MODE_NAMED_PIPE
) {
2513 err
= v9fs_do_mknod(s
, vs
->fullname
.data
, S_IFIFO
| (vs
->perm
& 0777),
2514 0, vs
->fidp
->uid
, -1);
2515 v9fs_post_create(s
, vs
, err
);
2516 } else if (vs
->perm
& P9_STAT_MODE_SOCKET
) {
2517 err
= v9fs_do_mknod(s
, vs
->fullname
.data
, S_IFSOCK
| (vs
->perm
& 0777),
2518 0, vs
->fidp
->uid
, -1);
2519 v9fs_post_create(s
, vs
, err
);
2521 vs
->fidp
->fs
.fd
= v9fs_do_open2(s
, vs
->fullname
.data
, vs
->fidp
->uid
,
2522 -1, omode_to_uflags(vs
->mode
)|O_CREAT
, vs
->perm
);
2524 v9fs_create_post_open2(s
, vs
, err
);
2530 v9fs_post_create(s
, vs
, err
);
2533 static void v9fs_create(V9fsState
*s
, V9fsPDU
*pdu
)
2536 V9fsCreateState
*vs
;
2539 vs
= qemu_malloc(sizeof(*vs
));
2543 v9fs_string_init(&vs
->fullname
);
2545 pdu_unmarshal(vs
->pdu
, vs
->offset
, "dsdbs", &fid
, &vs
->name
,
2546 &vs
->perm
, &vs
->mode
, &vs
->extension
);
2548 vs
->fidp
= lookup_fid(s
, fid
);
2549 if (vs
->fidp
== NULL
) {
2554 v9fs_string_sprintf(&vs
->fullname
, "%s/%s", vs
->fidp
->path
.data
,
2557 err
= v9fs_do_lstat(s
, &vs
->fullname
, &vs
->stbuf
);
2558 v9fs_create_post_lstat(s
, vs
, err
);
2562 complete_pdu(s
, vs
->pdu
, err
);
2563 v9fs_string_free(&vs
->name
);
2564 v9fs_string_free(&vs
->extension
);
2568 static void v9fs_post_symlink(V9fsState
*s
, V9fsSymlinkState
*vs
, int err
)
2571 stat_to_qid(&vs
->stbuf
, &vs
->qid
);
2572 vs
->offset
+= pdu_marshal(vs
->pdu
, vs
->offset
, "Q", &vs
->qid
);
2577 complete_pdu(s
, vs
->pdu
, err
);
2578 v9fs_string_free(&vs
->name
);
2579 v9fs_string_free(&vs
->symname
);
2580 v9fs_string_free(&vs
->fullname
);
2584 static void v9fs_symlink_post_do_symlink(V9fsState
*s
, V9fsSymlinkState
*vs
,
2590 err
= v9fs_do_lstat(s
, &vs
->fullname
, &vs
->stbuf
);
2592 v9fs_post_symlink(s
, vs
, err
);
2595 static void v9fs_symlink(V9fsState
*s
, V9fsPDU
*pdu
)
2598 V9fsSymlinkState
*vs
;
2602 vs
= qemu_malloc(sizeof(*vs
));
2606 v9fs_string_init(&vs
->fullname
);
2608 pdu_unmarshal(vs
->pdu
, vs
->offset
, "dssd", &dfid
, &vs
->name
,
2609 &vs
->symname
, &gid
);
2611 vs
->dfidp
= lookup_fid(s
, dfid
);
2612 if (vs
->dfidp
== NULL
) {
2617 v9fs_string_sprintf(&vs
->fullname
, "%s/%s", vs
->dfidp
->path
.data
,
2619 err
= v9fs_do_symlink(s
, vs
->dfidp
, vs
->symname
.data
,
2620 vs
->fullname
.data
, gid
);
2621 v9fs_symlink_post_do_symlink(s
, vs
, err
);
2625 complete_pdu(s
, vs
->pdu
, err
);
2626 v9fs_string_free(&vs
->name
);
2627 v9fs_string_free(&vs
->symname
);
2631 static void v9fs_flush(V9fsState
*s
, V9fsPDU
*pdu
)
2633 /* A nop call with no return */
2634 complete_pdu(s
, pdu
, 7);
2637 static void v9fs_link(V9fsState
*s
, V9fsPDU
*pdu
)
2639 int32_t dfid
, oldfid
;
2640 V9fsFidState
*dfidp
, *oldfidp
;
2641 V9fsString name
, fullname
;
2645 v9fs_string_init(&fullname
);
2647 pdu_unmarshal(pdu
, offset
, "dds", &dfid
, &oldfid
, &name
);
2649 dfidp
= lookup_fid(s
, dfid
);
2650 if (dfidp
== NULL
) {
2655 oldfidp
= lookup_fid(s
, oldfid
);
2656 if (oldfidp
== NULL
) {
2661 v9fs_string_sprintf(&fullname
, "%s/%s", dfidp
->path
.data
, name
.data
);
2663 err
= v9fs_do_link(s
, &oldfidp
->path
, &fullname
);
2667 v9fs_string_free(&fullname
);
2670 v9fs_string_free(&name
);
2671 complete_pdu(s
, pdu
, err
);
2674 static void v9fs_remove_post_remove(V9fsState
*s
, V9fsRemoveState
*vs
,
2683 /* For TREMOVE we need to clunk the fid even on failed remove */
2684 free_fid(s
, vs
->fidp
->fid
);
2686 complete_pdu(s
, vs
->pdu
, err
);
2690 static void v9fs_remove(V9fsState
*s
, V9fsPDU
*pdu
)
2693 V9fsRemoveState
*vs
;
2696 vs
= qemu_malloc(sizeof(*vs
));
2700 pdu_unmarshal(vs
->pdu
, vs
->offset
, "d", &fid
);
2702 vs
->fidp
= lookup_fid(s
, fid
);
2703 if (vs
->fidp
== NULL
) {
2708 err
= v9fs_do_remove(s
, &vs
->fidp
->path
);
2709 v9fs_remove_post_remove(s
, vs
, err
);
2713 complete_pdu(s
, pdu
, err
);
2717 static void v9fs_wstat_post_truncate(V9fsState
*s
, V9fsWstatState
*vs
, int err
)
2726 v9fs_stat_free(&vs
->v9stat
);
2727 complete_pdu(s
, vs
->pdu
, err
);
2731 static void v9fs_wstat_post_rename(V9fsState
*s
, V9fsWstatState
*vs
, int err
)
2736 if (vs
->v9stat
.length
!= -1) {
2737 if (v9fs_do_truncate(s
, &vs
->fidp
->path
, vs
->v9stat
.length
) < 0) {
2741 v9fs_wstat_post_truncate(s
, vs
, err
);
2745 v9fs_stat_free(&vs
->v9stat
);
2746 complete_pdu(s
, vs
->pdu
, err
);
2750 static int v9fs_complete_rename(V9fsState
*s
, V9fsRenameState
*vs
)
2753 char *old_name
, *new_name
;
2756 if (vs
->newdirfid
!= -1) {
2757 V9fsFidState
*dirfidp
;
2758 dirfidp
= lookup_fid(s
, vs
->newdirfid
);
2760 if (dirfidp
== NULL
) {
2765 BUG_ON(dirfidp
->fid_type
!= P9_FID_NONE
);
2767 new_name
= qemu_mallocz(dirfidp
->path
.size
+ vs
->name
.size
+ 2);
2769 strcpy(new_name
, dirfidp
->path
.data
);
2770 strcat(new_name
, "/");
2771 strcat(new_name
+ dirfidp
->path
.size
, vs
->name
.data
);
2773 old_name
= vs
->fidp
->path
.data
;
2774 end
= strrchr(old_name
, '/');
2780 new_name
= qemu_mallocz(end
- old_name
+ vs
->name
.size
+ 1);
2782 strncat(new_name
, old_name
, end
- old_name
);
2783 strncat(new_name
+ (end
- old_name
), vs
->name
.data
, vs
->name
.size
);
2786 v9fs_string_free(&vs
->name
);
2787 vs
->name
.data
= qemu_strdup(new_name
);
2788 vs
->name
.size
= strlen(new_name
);
2790 if (strcmp(new_name
, vs
->fidp
->path
.data
) != 0) {
2791 if (v9fs_do_rename(s
, &vs
->fidp
->path
, &vs
->name
)) {
2796 * Fixup fid's pointing to the old name to
2797 * start pointing to the new name
2799 for (fidp
= s
->fid_list
; fidp
; fidp
= fidp
->next
) {
2800 if (vs
->fidp
== fidp
) {
2802 * we replace name of this fid towards the end
2803 * so that our below strcmp will work
2807 if (!strncmp(vs
->fidp
->path
.data
, fidp
->path
.data
,
2808 strlen(vs
->fidp
->path
.data
))) {
2809 /* replace the name */
2810 v9fs_fix_path(&fidp
->path
, &vs
->name
,
2811 strlen(vs
->fidp
->path
.data
));
2814 v9fs_string_copy(&vs
->fidp
->path
, &vs
->name
);
2818 v9fs_string_free(&vs
->name
);
2822 static void v9fs_rename_post_rename(V9fsState
*s
, V9fsRenameState
*vs
, int err
)
2824 complete_pdu(s
, vs
->pdu
, err
);
2828 static void v9fs_wstat_post_chown(V9fsState
*s
, V9fsWstatState
*vs
, int err
)
2834 if (vs
->v9stat
.name
.size
!= 0) {
2835 V9fsRenameState
*vr
;
2837 vr
= qemu_mallocz(sizeof(V9fsRenameState
));
2840 vr
->fidp
= vs
->fidp
;
2841 vr
->offset
= vs
->offset
;
2842 vr
->name
.size
= vs
->v9stat
.name
.size
;
2843 vr
->name
.data
= qemu_strdup(vs
->v9stat
.name
.data
);
2845 err
= v9fs_complete_rename(s
, vr
);
2848 v9fs_wstat_post_rename(s
, vs
, err
);
2852 v9fs_stat_free(&vs
->v9stat
);
2853 complete_pdu(s
, vs
->pdu
, err
);
2857 static void v9fs_rename(V9fsState
*s
, V9fsPDU
*pdu
)
2860 V9fsRenameState
*vs
;
2863 vs
= qemu_malloc(sizeof(*vs
));
2867 pdu_unmarshal(vs
->pdu
, vs
->offset
, "dds", &fid
, &vs
->newdirfid
, &vs
->name
);
2869 vs
->fidp
= lookup_fid(s
, fid
);
2870 if (vs
->fidp
== NULL
) {
2875 BUG_ON(vs
->fidp
->fid_type
!= P9_FID_NONE
);
2877 err
= v9fs_complete_rename(s
, vs
);
2878 v9fs_rename_post_rename(s
, vs
, err
);
2881 complete_pdu(s
, vs
->pdu
, err
);
2885 static void v9fs_wstat_post_utime(V9fsState
*s
, V9fsWstatState
*vs
, int err
)
2891 if (vs
->v9stat
.n_gid
!= -1 || vs
->v9stat
.n_uid
!= -1) {
2892 if (v9fs_do_chown(s
, &vs
->fidp
->path
, vs
->v9stat
.n_uid
,
2893 vs
->v9stat
.n_gid
)) {
2897 v9fs_wstat_post_chown(s
, vs
, err
);
2901 v9fs_stat_free(&vs
->v9stat
);
2902 complete_pdu(s
, vs
->pdu
, err
);
2906 static void v9fs_wstat_post_chmod(V9fsState
*s
, V9fsWstatState
*vs
, int err
)
2912 if (vs
->v9stat
.mtime
!= -1 || vs
->v9stat
.atime
!= -1) {
2913 struct timespec times
[2];
2914 if (vs
->v9stat
.atime
!= -1) {
2915 times
[0].tv_sec
= vs
->v9stat
.atime
;
2916 times
[0].tv_nsec
= 0;
2918 times
[0].tv_nsec
= UTIME_OMIT
;
2920 if (vs
->v9stat
.mtime
!= -1) {
2921 times
[1].tv_sec
= vs
->v9stat
.mtime
;
2922 times
[1].tv_nsec
= 0;
2924 times
[1].tv_nsec
= UTIME_OMIT
;
2927 if (v9fs_do_utimensat(s
, &vs
->fidp
->path
, times
)) {
2932 v9fs_wstat_post_utime(s
, vs
, err
);
2936 v9fs_stat_free(&vs
->v9stat
);
2937 complete_pdu(s
, vs
->pdu
, err
);
2941 static void v9fs_wstat_post_fsync(V9fsState
*s
, V9fsWstatState
*vs
, int err
)
2946 v9fs_stat_free(&vs
->v9stat
);
2947 complete_pdu(s
, vs
->pdu
, err
);
2951 static void v9fs_wstat_post_lstat(V9fsState
*s
, V9fsWstatState
*vs
, int err
)
2960 v9_mode
= stat_to_v9mode(&vs
->stbuf
);
2962 if ((vs
->v9stat
.mode
& P9_STAT_MODE_TYPE_BITS
) !=
2963 (v9_mode
& P9_STAT_MODE_TYPE_BITS
)) {
2964 /* Attempting to change the type */
2969 if (v9fs_do_chmod(s
, &vs
->fidp
->path
, v9mode_to_mode(vs
->v9stat
.mode
,
2970 &vs
->v9stat
.extension
))) {
2973 v9fs_wstat_post_chmod(s
, vs
, err
);
2977 v9fs_stat_free(&vs
->v9stat
);
2978 complete_pdu(s
, vs
->pdu
, err
);
2982 static void v9fs_wstat(V9fsState
*s
, V9fsPDU
*pdu
)
2988 vs
= qemu_malloc(sizeof(*vs
));
2992 pdu_unmarshal(pdu
, vs
->offset
, "dwS", &fid
, &vs
->unused
, &vs
->v9stat
);
2994 vs
->fidp
= lookup_fid(s
, fid
);
2995 if (vs
->fidp
== NULL
) {
3000 /* do we need to sync the file? */
3001 if (donttouch_stat(&vs
->v9stat
)) {
3002 err
= v9fs_do_fsync(s
, vs
->fidp
->fs
.fd
, 0);
3003 v9fs_wstat_post_fsync(s
, vs
, err
);
3007 if (vs
->v9stat
.mode
!= -1) {
3008 err
= v9fs_do_lstat(s
, &vs
->fidp
->path
, &vs
->stbuf
);
3009 v9fs_wstat_post_lstat(s
, vs
, err
);
3013 v9fs_wstat_post_chmod(s
, vs
, err
);
3017 v9fs_stat_free(&vs
->v9stat
);
3018 complete_pdu(s
, vs
->pdu
, err
);
3022 static void v9fs_statfs_post_statfs(V9fsState
*s
, V9fsStatfsState
*vs
, int err
)
3024 int32_t bsize_factor
;
3032 * compute bsize factor based on host file system block size
3035 bsize_factor
= (s
->msize
- P9_IOHDRSZ
)/vs
->stbuf
.f_bsize
;
3036 if (!bsize_factor
) {
3039 vs
->v9statfs
.f_type
= vs
->stbuf
.f_type
;
3040 vs
->v9statfs
.f_bsize
= vs
->stbuf
.f_bsize
;
3041 vs
->v9statfs
.f_bsize
*= bsize_factor
;
3043 * f_bsize is adjusted(multiplied) by bsize factor, so we need to
3044 * adjust(divide) the number of blocks, free blocks and available
3045 * blocks by bsize factor
3047 vs
->v9statfs
.f_blocks
= vs
->stbuf
.f_blocks
/bsize_factor
;
3048 vs
->v9statfs
.f_bfree
= vs
->stbuf
.f_bfree
/bsize_factor
;
3049 vs
->v9statfs
.f_bavail
= vs
->stbuf
.f_bavail
/bsize_factor
;
3050 vs
->v9statfs
.f_files
= vs
->stbuf
.f_files
;
3051 vs
->v9statfs
.f_ffree
= vs
->stbuf
.f_ffree
;
3052 vs
->v9statfs
.fsid_val
= (unsigned int) vs
->stbuf
.f_fsid
.__val
[0] |
3053 (unsigned long long)vs
->stbuf
.f_fsid
.__val
[1] << 32;
3054 vs
->v9statfs
.f_namelen
= vs
->stbuf
.f_namelen
;
3056 vs
->offset
+= pdu_marshal(vs
->pdu
, vs
->offset
, "ddqqqqqqd",
3057 vs
->v9statfs
.f_type
, vs
->v9statfs
.f_bsize
, vs
->v9statfs
.f_blocks
,
3058 vs
->v9statfs
.f_bfree
, vs
->v9statfs
.f_bavail
, vs
->v9statfs
.f_files
,
3059 vs
->v9statfs
.f_ffree
, vs
->v9statfs
.fsid_val
,
3060 vs
->v9statfs
.f_namelen
);
3063 complete_pdu(s
, vs
->pdu
, vs
->offset
);
3067 static void v9fs_statfs(V9fsState
*s
, V9fsPDU
*pdu
)
3069 V9fsStatfsState
*vs
;
3072 vs
= qemu_malloc(sizeof(*vs
));
3076 memset(&vs
->v9statfs
, 0, sizeof(vs
->v9statfs
));
3078 pdu_unmarshal(vs
->pdu
, vs
->offset
, "d", &vs
->fid
);
3080 vs
->fidp
= lookup_fid(s
, vs
->fid
);
3081 if (vs
->fidp
== NULL
) {
3086 err
= v9fs_do_statfs(s
, &vs
->fidp
->path
, &vs
->stbuf
);
3087 v9fs_statfs_post_statfs(s
, vs
, err
);
3091 complete_pdu(s
, vs
->pdu
, err
);
3095 static void v9fs_mknod_post_lstat(V9fsState
*s
, V9fsMkState
*vs
, int err
)
3102 stat_to_qid(&vs
->stbuf
, &vs
->qid
);
3103 vs
->offset
+= pdu_marshal(vs
->pdu
, vs
->offset
, "Q", &vs
->qid
);
3106 complete_pdu(s
, vs
->pdu
, err
);
3107 v9fs_string_free(&vs
->fullname
);
3108 v9fs_string_free(&vs
->name
);
3112 static void v9fs_mknod_post_mknod(V9fsState
*s
, V9fsMkState
*vs
, int err
)
3119 err
= v9fs_do_lstat(s
, &vs
->fullname
, &vs
->stbuf
);
3120 v9fs_mknod_post_lstat(s
, vs
, err
);
3123 complete_pdu(s
, vs
->pdu
, err
);
3124 v9fs_string_free(&vs
->fullname
);
3125 v9fs_string_free(&vs
->name
);
3129 static void v9fs_mknod(V9fsState
*s
, V9fsPDU
*pdu
)
3139 vs
= qemu_malloc(sizeof(*vs
));
3143 v9fs_string_init(&vs
->fullname
);
3144 pdu_unmarshal(vs
->pdu
, vs
->offset
, "dsdddd", &fid
, &vs
->name
, &mode
,
3145 &major
, &minor
, &gid
);
3147 fidp
= lookup_fid(s
, fid
);
3153 v9fs_string_sprintf(&vs
->fullname
, "%s/%s", fidp
->path
.data
, vs
->name
.data
);
3154 err
= v9fs_do_mknod(s
, vs
->fullname
.data
, mode
, makedev(major
, minor
),
3156 v9fs_mknod_post_mknod(s
, vs
, err
);
3160 complete_pdu(s
, vs
->pdu
, err
);
3161 v9fs_string_free(&vs
->fullname
);
3162 v9fs_string_free(&vs
->name
);
3167 * Implement posix byte range locking code
3168 * Server side handling of locking code is very simple, because 9p server in
3169 * QEMU can handle only one client. And most of the lock handling
3170 * (like conflict, merging) etc is done by the VFS layer itself, so no need to
3171 * do any thing in * qemu 9p server side lock code path.
3172 * So when a TLOCK request comes, always return success
3175 static void v9fs_lock(V9fsState
*s
, V9fsPDU
*pdu
)
3177 int32_t fid
, err
= 0;
3180 vs
= qemu_mallocz(sizeof(*vs
));
3184 vs
->flock
= qemu_malloc(sizeof(*vs
->flock
));
3185 pdu_unmarshal(vs
->pdu
, vs
->offset
, "dbdqqds", &fid
, &vs
->flock
->type
,
3186 &vs
->flock
->flags
, &vs
->flock
->start
, &vs
->flock
->length
,
3187 &vs
->flock
->proc_id
, &vs
->flock
->client_id
);
3189 vs
->status
= P9_LOCK_ERROR
;
3191 /* We support only block flag now (that too ignored currently) */
3192 if (vs
->flock
->flags
& ~P9_LOCK_FLAGS_BLOCK
) {
3196 vs
->fidp
= lookup_fid(s
, fid
);
3197 if (vs
->fidp
== NULL
) {
3202 err
= v9fs_do_fstat(s
, vs
->fidp
->fs
.fd
, &vs
->stbuf
);
3207 vs
->status
= P9_LOCK_SUCCESS
;
3209 vs
->offset
+= pdu_marshal(vs
->pdu
, vs
->offset
, "b", vs
->status
);
3210 complete_pdu(s
, vs
->pdu
, err
);
3211 qemu_free(vs
->flock
);
3216 * When a TGETLOCK request comes, always return success because all lock
3217 * handling is done by client's VFS layer.
3220 static void v9fs_getlock(V9fsState
*s
, V9fsPDU
*pdu
)
3222 int32_t fid
, err
= 0;
3223 V9fsGetlockState
*vs
;
3225 vs
= qemu_mallocz(sizeof(*vs
));
3229 vs
->glock
= qemu_malloc(sizeof(*vs
->glock
));
3230 pdu_unmarshal(vs
->pdu
, vs
->offset
, "dbqqds", &fid
, &vs
->glock
->type
,
3231 &vs
->glock
->start
, &vs
->glock
->length
, &vs
->glock
->proc_id
,
3232 &vs
->glock
->client_id
);
3234 vs
->fidp
= lookup_fid(s
, fid
);
3235 if (vs
->fidp
== NULL
) {
3240 err
= v9fs_do_fstat(s
, vs
->fidp
->fs
.fd
, &vs
->stbuf
);
3245 vs
->glock
->type
= F_UNLCK
;
3246 vs
->offset
+= pdu_marshal(vs
->pdu
, vs
->offset
, "bqqds", vs
->glock
->type
,
3247 vs
->glock
->start
, vs
->glock
->length
, vs
->glock
->proc_id
,
3248 &vs
->glock
->client_id
);
3250 complete_pdu(s
, vs
->pdu
, err
);
3251 qemu_free(vs
->glock
);
3255 static void v9fs_mkdir_post_lstat(V9fsState
*s
, V9fsMkState
*vs
, int err
)
3262 stat_to_qid(&vs
->stbuf
, &vs
->qid
);
3263 vs
->offset
+= pdu_marshal(vs
->pdu
, vs
->offset
, "Q", &vs
->qid
);
3266 complete_pdu(s
, vs
->pdu
, err
);
3267 v9fs_string_free(&vs
->fullname
);
3268 v9fs_string_free(&vs
->name
);
3272 static void v9fs_mkdir_post_mkdir(V9fsState
*s
, V9fsMkState
*vs
, int err
)
3279 err
= v9fs_do_lstat(s
, &vs
->fullname
, &vs
->stbuf
);
3280 v9fs_mkdir_post_lstat(s
, vs
, err
);
3283 complete_pdu(s
, vs
->pdu
, err
);
3284 v9fs_string_free(&vs
->fullname
);
3285 v9fs_string_free(&vs
->name
);
3289 static void v9fs_mkdir(V9fsState
*s
, V9fsPDU
*pdu
)
3298 vs
= qemu_malloc(sizeof(*vs
));
3302 v9fs_string_init(&vs
->fullname
);
3303 pdu_unmarshal(vs
->pdu
, vs
->offset
, "dsdd", &fid
, &vs
->name
, &mode
,
3306 fidp
= lookup_fid(s
, fid
);
3312 v9fs_string_sprintf(&vs
->fullname
, "%s/%s", fidp
->path
.data
, vs
->name
.data
);
3313 err
= v9fs_do_mkdir(s
, vs
->fullname
.data
, mode
, fidp
->uid
, gid
);
3314 v9fs_mkdir_post_mkdir(s
, vs
, err
);
3318 complete_pdu(s
, vs
->pdu
, err
);
3319 v9fs_string_free(&vs
->fullname
);
3320 v9fs_string_free(&vs
->name
);
3324 static void v9fs_post_xattr_getvalue(V9fsState
*s
, V9fsXattrState
*vs
, int err
)
3329 free_fid(s
, vs
->xattr_fidp
->fid
);
3332 vs
->offset
+= pdu_marshal(vs
->pdu
, vs
->offset
, "q", vs
->size
);
3335 complete_pdu(s
, vs
->pdu
, err
);
3336 v9fs_string_free(&vs
->name
);
3341 static void v9fs_post_xattr_check(V9fsState
*s
, V9fsXattrState
*vs
, ssize_t err
)
3345 free_fid(s
, vs
->xattr_fidp
->fid
);
3349 * Read the xattr value
3351 vs
->xattr_fidp
->fs
.xattr
.len
= vs
->size
;
3352 vs
->xattr_fidp
->fid_type
= P9_FID_XATTR
;
3353 vs
->xattr_fidp
->fs
.xattr
.copied_len
= -1;
3355 vs
->xattr_fidp
->fs
.xattr
.value
= qemu_malloc(vs
->size
);
3356 err
= v9fs_do_lgetxattr(s
, &vs
->xattr_fidp
->path
,
3357 &vs
->name
, vs
->xattr_fidp
->fs
.xattr
.value
,
3358 vs
->xattr_fidp
->fs
.xattr
.len
);
3360 v9fs_post_xattr_getvalue(s
, vs
, err
);
3363 complete_pdu(s
, vs
->pdu
, err
);
3364 v9fs_string_free(&vs
->name
);
3368 static void v9fs_post_lxattr_getvalue(V9fsState
*s
,
3369 V9fsXattrState
*vs
, int err
)
3373 free_fid(s
, vs
->xattr_fidp
->fid
);
3376 vs
->offset
+= pdu_marshal(vs
->pdu
, vs
->offset
, "q", vs
->size
);
3379 complete_pdu(s
, vs
->pdu
, err
);
3380 v9fs_string_free(&vs
->name
);
3385 static void v9fs_post_lxattr_check(V9fsState
*s
,
3386 V9fsXattrState
*vs
, ssize_t err
)
3390 free_fid(s
, vs
->xattr_fidp
->fid
);
3394 * Read the xattr value
3396 vs
->xattr_fidp
->fs
.xattr
.len
= vs
->size
;
3397 vs
->xattr_fidp
->fid_type
= P9_FID_XATTR
;
3398 vs
->xattr_fidp
->fs
.xattr
.copied_len
= -1;
3400 vs
->xattr_fidp
->fs
.xattr
.value
= qemu_malloc(vs
->size
);
3401 err
= v9fs_do_llistxattr(s
, &vs
->xattr_fidp
->path
,
3402 vs
->xattr_fidp
->fs
.xattr
.value
,
3403 vs
->xattr_fidp
->fs
.xattr
.len
);
3405 v9fs_post_lxattr_getvalue(s
, vs
, err
);
3408 complete_pdu(s
, vs
->pdu
, err
);
3409 v9fs_string_free(&vs
->name
);
3413 static void v9fs_xattrwalk(V9fsState
*s
, V9fsPDU
*pdu
)
3417 int32_t fid
, newfid
;
3419 vs
= qemu_malloc(sizeof(*vs
));
3423 pdu_unmarshal(vs
->pdu
, vs
->offset
, "dds", &fid
, &newfid
, &vs
->name
);
3424 vs
->file_fidp
= lookup_fid(s
, fid
);
3425 if (vs
->file_fidp
== NULL
) {
3430 vs
->xattr_fidp
= alloc_fid(s
, newfid
);
3431 if (vs
->xattr_fidp
== NULL
) {
3436 v9fs_string_copy(&vs
->xattr_fidp
->path
, &vs
->file_fidp
->path
);
3437 if (vs
->name
.data
[0] == 0) {
3439 * listxattr request. Get the size first
3441 vs
->size
= v9fs_do_llistxattr(s
, &vs
->xattr_fidp
->path
,
3446 v9fs_post_lxattr_check(s
, vs
, err
);
3450 * specific xattr fid. We check for xattr
3451 * presence also collect the xattr size
3453 vs
->size
= v9fs_do_lgetxattr(s
, &vs
->xattr_fidp
->path
,
3454 &vs
->name
, NULL
, 0);
3458 v9fs_post_xattr_check(s
, vs
, err
);
3462 complete_pdu(s
, vs
->pdu
, err
);
3463 v9fs_string_free(&vs
->name
);
3467 static void v9fs_xattrcreate(V9fsState
*s
, V9fsPDU
*pdu
)
3474 vs
= qemu_malloc(sizeof(*vs
));
3478 pdu_unmarshal(vs
->pdu
, vs
->offset
, "dsqd",
3479 &fid
, &vs
->name
, &vs
->size
, &flags
);
3481 vs
->file_fidp
= lookup_fid(s
, fid
);
3482 if (vs
->file_fidp
== NULL
) {
3487 /* Make the file fid point to xattr */
3488 vs
->xattr_fidp
= vs
->file_fidp
;
3489 vs
->xattr_fidp
->fid_type
= P9_FID_XATTR
;
3490 vs
->xattr_fidp
->fs
.xattr
.copied_len
= 0;
3491 vs
->xattr_fidp
->fs
.xattr
.len
= vs
->size
;
3492 vs
->xattr_fidp
->fs
.xattr
.flags
= flags
;
3493 v9fs_string_init(&vs
->xattr_fidp
->fs
.xattr
.name
);
3494 v9fs_string_copy(&vs
->xattr_fidp
->fs
.xattr
.name
, &vs
->name
);
3496 vs
->xattr_fidp
->fs
.xattr
.value
= qemu_malloc(vs
->size
);
3498 vs
->xattr_fidp
->fs
.xattr
.value
= NULL
;
3501 complete_pdu(s
, vs
->pdu
, err
);
3502 v9fs_string_free(&vs
->name
);
3506 static void v9fs_readlink_post_readlink(V9fsState
*s
, V9fsReadLinkState
*vs
,
3513 vs
->offset
+= pdu_marshal(vs
->pdu
, vs
->offset
, "s", &vs
->target
);
3516 complete_pdu(s
, vs
->pdu
, err
);
3517 v9fs_string_free(&vs
->target
);
3521 static void v9fs_readlink(V9fsState
*s
, V9fsPDU
*pdu
)
3524 V9fsReadLinkState
*vs
;
3528 vs
= qemu_malloc(sizeof(*vs
));
3532 pdu_unmarshal(vs
->pdu
, vs
->offset
, "d", &fid
);
3534 fidp
= lookup_fid(s
, fid
);
3540 v9fs_string_init(&vs
->target
);
3541 err
= v9fs_do_readlink(s
, &fidp
->path
, &vs
->target
);
3542 v9fs_readlink_post_readlink(s
, vs
, err
);
3545 complete_pdu(s
, vs
->pdu
, err
);
3549 typedef void (pdu_handler_t
)(V9fsState
*s
, V9fsPDU
*pdu
);
3551 static pdu_handler_t
*pdu_handlers
[] = {
3552 [P9_TREADDIR
] = v9fs_readdir
,
3553 [P9_TSTATFS
] = v9fs_statfs
,
3554 [P9_TGETATTR
] = v9fs_getattr
,
3555 [P9_TSETATTR
] = v9fs_setattr
,
3556 [P9_TXATTRWALK
] = v9fs_xattrwalk
,
3557 [P9_TXATTRCREATE
] = v9fs_xattrcreate
,
3558 [P9_TMKNOD
] = v9fs_mknod
,
3559 [P9_TRENAME
] = v9fs_rename
,
3560 [P9_TLOCK
] = v9fs_lock
,
3561 [P9_TGETLOCK
] = v9fs_getlock
,
3562 [P9_TREADLINK
] = v9fs_readlink
,
3563 [P9_TMKDIR
] = v9fs_mkdir
,
3564 [P9_TVERSION
] = v9fs_version
,
3565 [P9_TLOPEN
] = v9fs_open
,
3566 [P9_TATTACH
] = v9fs_attach
,
3567 [P9_TSTAT
] = v9fs_stat
,
3568 [P9_TWALK
] = v9fs_walk
,
3569 [P9_TCLUNK
] = v9fs_clunk
,
3570 [P9_TFSYNC
] = v9fs_fsync
,
3571 [P9_TOPEN
] = v9fs_open
,
3572 [P9_TREAD
] = v9fs_read
,
3574 [P9_TAUTH
] = v9fs_auth
,
3576 [P9_TFLUSH
] = v9fs_flush
,
3577 [P9_TLINK
] = v9fs_link
,
3578 [P9_TSYMLINK
] = v9fs_symlink
,
3579 [P9_TCREATE
] = v9fs_create
,
3580 [P9_TLCREATE
] = v9fs_lcreate
,
3581 [P9_TWRITE
] = v9fs_write
,
3582 [P9_TWSTAT
] = v9fs_wstat
,
3583 [P9_TREMOVE
] = v9fs_remove
,
3586 static void submit_pdu(V9fsState
*s
, V9fsPDU
*pdu
)
3588 pdu_handler_t
*handler
;
3594 BUG_ON(pdu
->id
>= ARRAY_SIZE(pdu_handlers
));
3596 handler
= pdu_handlers
[pdu
->id
];
3597 BUG_ON(handler
== NULL
);
3602 static void handle_9p_output(VirtIODevice
*vdev
, VirtQueue
*vq
)
3604 V9fsState
*s
= (V9fsState
*)vdev
;
3608 while ((pdu
= alloc_pdu(s
)) &&
3609 (len
= virtqueue_pop(vq
, &pdu
->elem
)) != 0) {
3612 BUG_ON(pdu
->elem
.out_num
== 0 || pdu
->elem
.in_num
== 0);
3613 BUG_ON(pdu
->elem
.out_sg
[0].iov_len
< 7);
3615 ptr
= pdu
->elem
.out_sg
[0].iov_base
;
3617 memcpy(&pdu
->size
, ptr
, 4);
3619 memcpy(&pdu
->tag
, ptr
+ 5, 2);
3627 static uint32_t virtio_9p_get_features(VirtIODevice
*vdev
, uint32_t features
)
3629 features
|= 1 << VIRTIO_9P_MOUNT_TAG
;
3633 static V9fsState
*to_virtio_9p(VirtIODevice
*vdev
)
3635 return (V9fsState
*)vdev
;
3638 static void virtio_9p_get_config(VirtIODevice
*vdev
, uint8_t *config
)
3640 struct virtio_9p_config
*cfg
;
3641 V9fsState
*s
= to_virtio_9p(vdev
);
3643 cfg
= qemu_mallocz(sizeof(struct virtio_9p_config
) +
3645 stw_raw(&cfg
->tag_len
, s
->tag_len
);
3646 memcpy(cfg
->tag
, s
->tag
, s
->tag_len
);
3647 memcpy(config
, cfg
, s
->config_size
);
3651 VirtIODevice
*virtio_9p_init(DeviceState
*dev
, V9fsConf
*conf
)
3659 s
= (V9fsState
*)virtio_common_init("virtio-9p",
3661 sizeof(struct virtio_9p_config
)+
3665 /* initialize pdu allocator */
3666 QLIST_INIT(&s
->free_list
);
3667 for (i
= 0; i
< (MAX_REQ
- 1); i
++) {
3668 QLIST_INSERT_HEAD(&s
->free_list
, &s
->pdus
[i
], next
);
3671 s
->vq
= virtio_add_queue(&s
->vdev
, MAX_REQ
, handle_9p_output
);
3673 fse
= get_fsdev_fsentry(conf
->fsdev_id
);
3676 /* We don't have a fsdev identified by fsdev_id */
3677 fprintf(stderr
, "Virtio-9p device couldn't find fsdev with the "
3678 "id = %s\n", conf
->fsdev_id
? conf
->fsdev_id
: "NULL");
3682 if (!fse
->path
|| !conf
->tag
) {
3683 /* we haven't specified a mount_tag or the path */
3684 fprintf(stderr
, "fsdev with id %s needs path "
3685 "and Virtio-9p device needs mount_tag arguments\n",
3690 if (!strcmp(fse
->security_model
, "passthrough")) {
3691 /* Files on the Fileserver set to client user credentials */
3692 s
->ctx
.fs_sm
= SM_PASSTHROUGH
;
3693 s
->ctx
.xops
= passthrough_xattr_ops
;
3694 } else if (!strcmp(fse
->security_model
, "mapped")) {
3695 /* Files on the fileserver are set to QEMU credentials.
3696 * Client user credentials are saved in extended attributes.
3698 s
->ctx
.fs_sm
= SM_MAPPED
;
3699 s
->ctx
.xops
= mapped_xattr_ops
;
3700 } else if (!strcmp(fse
->security_model
, "none")) {
3702 * Files on the fileserver are set to QEMU credentials.
3704 s
->ctx
.fs_sm
= SM_NONE
;
3705 s
->ctx
.xops
= none_xattr_ops
;
3707 fprintf(stderr
, "Default to security_model=none. You may want"
3708 " enable advanced security model using "
3709 "security option:\n\t security_model=passthrough \n\t "
3710 "security_model=mapped\n");
3711 s
->ctx
.fs_sm
= SM_NONE
;
3712 s
->ctx
.xops
= none_xattr_ops
;
3715 if (lstat(fse
->path
, &stat
)) {
3716 fprintf(stderr
, "share path %s does not exist\n", fse
->path
);
3718 } else if (!S_ISDIR(stat
.st_mode
)) {
3719 fprintf(stderr
, "share path %s is not a directory \n", fse
->path
);
3723 s
->ctx
.fs_root
= qemu_strdup(fse
->path
);
3724 len
= strlen(conf
->tag
);
3725 if (len
> MAX_TAG_LEN
) {
3728 /* s->tag is non-NULL terminated string */
3729 s
->tag
= qemu_malloc(len
);
3730 memcpy(s
->tag
, conf
->tag
, len
);
3735 s
->vdev
.get_features
= virtio_9p_get_features
;
3736 s
->config_size
= sizeof(struct virtio_9p_config
) +
3738 s
->vdev
.get_config
= virtio_9p_get_config
;