2 * QTest testcase for VirtIO 9P
4 * Copyright (c) 2014 SUSE LINUX Products GmbH
6 * This work is licensed under the terms of the GNU GPL, version 2 or later.
7 * See the COPYING file in the top-level directory.
10 #include "qemu/osdep.h"
11 #include "libqtest-single.h"
12 #include "qemu/module.h"
13 #include "hw/9pfs/9p.h"
14 #include "hw/9pfs/9p-synth.h"
15 #include "libqos/virtio-9p.h"
16 #include "libqos/qgraph.h"
18 #define QVIRTIO_9P_TIMEOUT_US (10 * 1000 * 1000)
19 static QGuestAllocator
*alloc
;
22 * Used to auto generate new fids. Start with arbitrary high value to avoid
23 * collision with hard coded fids in basic test code.
25 static uint32_t fid_generator
= 1000;
27 static uint32_t genfid(void)
29 return fid_generator
++;
33 * Splits the @a in string by @a delim into individual (non empty) strings
34 * and outputs them to @a out. The output array @a out is NULL terminated.
36 * Output array @a out must be freed by calling split_free().
38 * @returns number of individual elements in output array @a out (without the
39 * final NULL terminating element)
41 static int split(const char *in
, const char *delim
, char ***out
)
47 for (p
= strtok(tmp
, delim
); p
!= NULL
; p
= strtok(NULL
, delim
)) {
54 *out
= g_new0(char *, n
+ 1); /* last element NULL delimiter */
57 for (p
= strtok(tmp
, delim
); p
!= NULL
; p
= strtok(NULL
, delim
)) {
59 (*out
)[i
++] = g_strdup(p
);
67 static void split_free(char ***out
)
70 for (i
= 0; (*out
)[i
]; ++i
) {
77 static void pci_config(void *obj
, void *data
, QGuestAllocator
*t_alloc
)
81 size_t tag_len
= qvirtio_config_readw(v9p
->vdev
, 0);
85 g_assert_cmpint(tag_len
, ==, strlen(MOUNT_TAG
));
87 tag
= g_malloc(tag_len
);
88 for (i
= 0; i
< tag_len
; i
++) {
89 tag
[i
] = qvirtio_config_readb(v9p
->vdev
, i
+ 2);
91 g_assert_cmpmem(tag
, tag_len
, MOUNT_TAG
, tag_len
);
95 #define P9_MAX_SIZE 4096 /* Max size of a T-message or R-message */
104 /* No r_size, it is hardcoded to P9_MAX_SIZE */
110 static void v9fs_memwrite(P9Req
*req
, const void *addr
, size_t len
)
112 qtest_memwrite(req
->qts
, req
->t_msg
+ req
->t_off
, addr
, len
);
116 static void v9fs_memskip(P9Req
*req
, size_t len
)
121 static void v9fs_memread(P9Req
*req
, void *addr
, size_t len
)
123 qtest_memread(req
->qts
, req
->r_msg
+ req
->r_off
, addr
, len
);
127 static void v9fs_uint8_read(P9Req
*req
, uint8_t *val
)
129 v9fs_memread(req
, val
, 1);
132 static void v9fs_uint16_write(P9Req
*req
, uint16_t val
)
134 uint16_t le_val
= cpu_to_le16(val
);
136 v9fs_memwrite(req
, &le_val
, 2);
139 static void v9fs_uint16_read(P9Req
*req
, uint16_t *val
)
141 v9fs_memread(req
, val
, 2);
145 static void v9fs_uint32_write(P9Req
*req
, uint32_t val
)
147 uint32_t le_val
= cpu_to_le32(val
);
149 v9fs_memwrite(req
, &le_val
, 4);
152 static void v9fs_uint64_write(P9Req
*req
, uint64_t val
)
154 uint64_t le_val
= cpu_to_le64(val
);
156 v9fs_memwrite(req
, &le_val
, 8);
159 static void v9fs_uint32_read(P9Req
*req
, uint32_t *val
)
161 v9fs_memread(req
, val
, 4);
165 static void v9fs_uint64_read(P9Req
*req
, uint64_t *val
)
167 v9fs_memread(req
, val
, 8);
171 /* len[2] string[len] */
172 static uint16_t v9fs_string_size(const char *string
)
174 size_t len
= strlen(string
);
176 g_assert_cmpint(len
, <=, UINT16_MAX
- 2);
181 static void v9fs_string_write(P9Req
*req
, const char *string
)
183 int len
= strlen(string
);
185 g_assert_cmpint(len
, <=, UINT16_MAX
);
187 v9fs_uint16_write(req
, (uint16_t) len
);
188 v9fs_memwrite(req
, string
, len
);
191 static void v9fs_string_read(P9Req
*req
, uint16_t *len
, char **string
)
195 v9fs_uint16_read(req
, &local_len
);
200 *string
= g_malloc(local_len
+ 1);
201 v9fs_memread(req
, *string
, local_len
);
202 (*string
)[local_len
] = 0;
204 v9fs_memskip(req
, local_len
);
214 static P9Req
*v9fs_req_init(QVirtio9P
*v9p
, uint32_t size
, uint8_t id
,
217 P9Req
*req
= g_new0(P9Req
, 1);
218 uint32_t total_size
= 7; /* 9P header has well-known size of 7 bytes */
221 .tag
= cpu_to_le16(tag
)
224 g_assert_cmpint(total_size
, <=, UINT32_MAX
- size
);
226 hdr
.size
= cpu_to_le32(total_size
);
228 g_assert_cmpint(total_size
, <=, P9_MAX_SIZE
);
230 req
->qts
= global_qtest
;
232 req
->t_size
= total_size
;
233 req
->t_msg
= guest_alloc(alloc
, req
->t_size
);
234 v9fs_memwrite(req
, &hdr
, 7);
239 static void v9fs_req_send(P9Req
*req
)
241 QVirtio9P
*v9p
= req
->v9p
;
243 req
->r_msg
= guest_alloc(alloc
, P9_MAX_SIZE
);
244 req
->free_head
= qvirtqueue_add(req
->qts
, v9p
->vq
, req
->t_msg
, req
->t_size
,
246 qvirtqueue_add(req
->qts
, v9p
->vq
, req
->r_msg
, P9_MAX_SIZE
, true, false);
247 qvirtqueue_kick(req
->qts
, v9p
->vdev
, v9p
->vq
, req
->free_head
);
251 static const char *rmessage_name(uint8_t id
)
254 id
== P9_RLERROR
? "RLERROR" :
255 id
== P9_RVERSION
? "RVERSION" :
256 id
== P9_RATTACH
? "RATTACH" :
257 id
== P9_RWALK
? "RWALK" :
258 id
== P9_RLOPEN
? "RLOPEN" :
259 id
== P9_RWRITE
? "RWRITE" :
260 id
== P9_RMKDIR
? "RMKDIR" :
261 id
== P9_RFLUSH
? "RFLUSH" :
262 id
== P9_RREADDIR
? "READDIR" :
266 static void v9fs_req_wait_for_reply(P9Req
*req
, uint32_t *len
)
268 QVirtio9P
*v9p
= req
->v9p
;
270 qvirtio_wait_used_elem(req
->qts
, v9p
->vdev
, v9p
->vq
, req
->free_head
, len
,
271 QVIRTIO_9P_TIMEOUT_US
);
274 static void v9fs_req_recv(P9Req
*req
, uint8_t id
)
278 v9fs_memread(req
, &hdr
, 7);
279 hdr
.size
= ldl_le_p(&hdr
.size
);
280 hdr
.tag
= lduw_le_p(&hdr
.tag
);
282 g_assert_cmpint(hdr
.size
, >=, 7);
283 g_assert_cmpint(hdr
.size
, <=, P9_MAX_SIZE
);
284 g_assert_cmpint(hdr
.tag
, ==, req
->tag
);
287 g_printerr("Received response %d (%s) instead of %d (%s)\n",
288 hdr
.id
, rmessage_name(hdr
.id
), id
, rmessage_name(id
));
290 if (hdr
.id
== P9_RLERROR
) {
292 v9fs_uint32_read(req
, &err
);
293 g_printerr("Rlerror has errno %d (%s)\n", err
, strerror(err
));
296 g_assert_cmpint(hdr
.id
, ==, id
);
299 static void v9fs_req_free(P9Req
*req
)
301 guest_free(alloc
, req
->t_msg
);
302 guest_free(alloc
, req
->r_msg
);
306 /* size[4] Rlerror tag[2] ecode[4] */
307 static void v9fs_rlerror(P9Req
*req
, uint32_t *err
)
309 v9fs_req_recv(req
, P9_RLERROR
);
310 v9fs_uint32_read(req
, err
);
314 /* size[4] Tversion tag[2] msize[4] version[s] */
315 static P9Req
*v9fs_tversion(QVirtio9P
*v9p
, uint32_t msize
, const char *version
,
319 uint32_t body_size
= 4;
320 uint16_t string_size
= v9fs_string_size(version
);
322 g_assert_cmpint(body_size
, <=, UINT32_MAX
- string_size
);
323 body_size
+= string_size
;
324 req
= v9fs_req_init(v9p
, body_size
, P9_TVERSION
, tag
);
326 v9fs_uint32_write(req
, msize
);
327 v9fs_string_write(req
, version
);
332 /* size[4] Rversion tag[2] msize[4] version[s] */
333 static void v9fs_rversion(P9Req
*req
, uint16_t *len
, char **version
)
337 v9fs_req_recv(req
, P9_RVERSION
);
338 v9fs_uint32_read(req
, &msize
);
340 g_assert_cmpint(msize
, ==, P9_MAX_SIZE
);
342 if (len
|| version
) {
343 v9fs_string_read(req
, len
, version
);
349 /* size[4] Tattach tag[2] fid[4] afid[4] uname[s] aname[s] n_uname[4] */
350 static P9Req
*v9fs_tattach(QVirtio9P
*v9p
, uint32_t fid
, uint32_t n_uname
,
353 const char *uname
= ""; /* ignored by QEMU */
354 const char *aname
= ""; /* ignored by QEMU */
355 P9Req
*req
= v9fs_req_init(v9p
, 4 + 4 + 2 + 2 + 4, P9_TATTACH
, tag
);
357 v9fs_uint32_write(req
, fid
);
358 v9fs_uint32_write(req
, P9_NOFID
);
359 v9fs_string_write(req
, uname
);
360 v9fs_string_write(req
, aname
);
361 v9fs_uint32_write(req
, n_uname
);
366 typedef char v9fs_qid
[13];
368 /* size[4] Rattach tag[2] qid[13] */
369 static void v9fs_rattach(P9Req
*req
, v9fs_qid
*qid
)
371 v9fs_req_recv(req
, P9_RATTACH
);
373 v9fs_memread(req
, qid
, 13);
378 /* size[4] Twalk tag[2] fid[4] newfid[4] nwname[2] nwname*(wname[s]) */
379 static P9Req
*v9fs_twalk(QVirtio9P
*v9p
, uint32_t fid
, uint32_t newfid
,
380 uint16_t nwname
, char *const wnames
[], uint16_t tag
)
384 uint32_t body_size
= 4 + 4 + 2;
386 for (i
= 0; i
< nwname
; i
++) {
387 uint16_t wname_size
= v9fs_string_size(wnames
[i
]);
389 g_assert_cmpint(body_size
, <=, UINT32_MAX
- wname_size
);
390 body_size
+= wname_size
;
392 req
= v9fs_req_init(v9p
, body_size
, P9_TWALK
, tag
);
393 v9fs_uint32_write(req
, fid
);
394 v9fs_uint32_write(req
, newfid
);
395 v9fs_uint16_write(req
, nwname
);
396 for (i
= 0; i
< nwname
; i
++) {
397 v9fs_string_write(req
, wnames
[i
]);
403 /* size[4] Rwalk tag[2] nwqid[2] nwqid*(wqid[13]) */
404 static void v9fs_rwalk(P9Req
*req
, uint16_t *nwqid
, v9fs_qid
**wqid
)
406 uint16_t local_nwqid
;
408 v9fs_req_recv(req
, P9_RWALK
);
409 v9fs_uint16_read(req
, &local_nwqid
);
411 *nwqid
= local_nwqid
;
414 *wqid
= g_malloc(local_nwqid
* 13);
415 v9fs_memread(req
, *wqid
, local_nwqid
* 13);
420 /* size[4] Treaddir tag[2] fid[4] offset[8] count[4] */
421 static P9Req
*v9fs_treaddir(QVirtio9P
*v9p
, uint32_t fid
, uint64_t offset
,
422 uint32_t count
, uint16_t tag
)
426 req
= v9fs_req_init(v9p
, 4 + 8 + 4, P9_TREADDIR
, tag
);
427 v9fs_uint32_write(req
, fid
);
428 v9fs_uint64_write(req
, offset
);
429 v9fs_uint32_write(req
, count
);
439 struct V9fsDirent
*next
;
442 /* size[4] Rreaddir tag[2] count[4] data[count] */
443 static void v9fs_rreaddir(P9Req
*req
, uint32_t *count
, uint32_t *nentries
,
444 struct V9fsDirent
**entries
)
446 uint32_t local_count
;
447 struct V9fsDirent
*e
= NULL
;
451 v9fs_req_recv(req
, P9_RREADDIR
);
452 v9fs_uint32_read(req
, &local_count
);
455 *count
= local_count
;
458 for (int32_t togo
= (int32_t)local_count
;
459 togo
>= 13 + 8 + 1 + 2;
460 togo
-= 13 + 8 + 1 + 2 + slen
, ++n
)
463 e
= g_malloc(sizeof(struct V9fsDirent
));
468 e
= e
->next
= g_malloc(sizeof(struct V9fsDirent
));
471 /* qid[13] offset[8] type[1] name[s] */
472 v9fs_memread(req
, &e
->qid
, 13);
473 v9fs_uint64_read(req
, &e
->offset
);
474 v9fs_uint8_read(req
, &e
->type
);
475 v9fs_string_read(req
, &slen
, &e
->name
);
485 static void v9fs_free_dirents(struct V9fsDirent
*e
)
487 struct V9fsDirent
*next
= NULL
;
489 for (; e
; e
= next
) {
496 /* size[4] Tlopen tag[2] fid[4] flags[4] */
497 static P9Req
*v9fs_tlopen(QVirtio9P
*v9p
, uint32_t fid
, uint32_t flags
,
502 req
= v9fs_req_init(v9p
, 4 + 4, P9_TLOPEN
, tag
);
503 v9fs_uint32_write(req
, fid
);
504 v9fs_uint32_write(req
, flags
);
509 /* size[4] Rlopen tag[2] qid[13] iounit[4] */
510 static void v9fs_rlopen(P9Req
*req
, v9fs_qid
*qid
, uint32_t *iounit
)
512 v9fs_req_recv(req
, P9_RLOPEN
);
514 v9fs_memread(req
, qid
, 13);
516 v9fs_memskip(req
, 13);
519 v9fs_uint32_read(req
, iounit
);
524 /* size[4] Twrite tag[2] fid[4] offset[8] count[4] data[count] */
525 static P9Req
*v9fs_twrite(QVirtio9P
*v9p
, uint32_t fid
, uint64_t offset
,
526 uint32_t count
, const void *data
, uint16_t tag
)
529 uint32_t body_size
= 4 + 8 + 4;
531 g_assert_cmpint(body_size
, <=, UINT32_MAX
- count
);
533 req
= v9fs_req_init(v9p
, body_size
, P9_TWRITE
, tag
);
534 v9fs_uint32_write(req
, fid
);
535 v9fs_uint64_write(req
, offset
);
536 v9fs_uint32_write(req
, count
);
537 v9fs_memwrite(req
, data
, count
);
542 /* size[4] Rwrite tag[2] count[4] */
543 static void v9fs_rwrite(P9Req
*req
, uint32_t *count
)
545 v9fs_req_recv(req
, P9_RWRITE
);
547 v9fs_uint32_read(req
, count
);
552 /* size[4] Tflush tag[2] oldtag[2] */
553 static P9Req
*v9fs_tflush(QVirtio9P
*v9p
, uint16_t oldtag
, uint16_t tag
)
557 req
= v9fs_req_init(v9p
, 2, P9_TFLUSH
, tag
);
558 v9fs_uint32_write(req
, oldtag
);
563 /* size[4] Rflush tag[2] */
564 static void v9fs_rflush(P9Req
*req
)
566 v9fs_req_recv(req
, P9_RFLUSH
);
570 static void do_version(QVirtio9P
*v9p
)
572 const char *version
= "9P2000.L";
574 char *server_version
;
577 req
= v9fs_tversion(v9p
, P9_MAX_SIZE
, version
, P9_NOTAG
);
578 v9fs_req_wait_for_reply(req
, NULL
);
579 v9fs_rversion(req
, &server_len
, &server_version
);
581 g_assert_cmpmem(server_version
, server_len
, version
, strlen(version
));
583 g_free(server_version
);
586 static void fs_version(void *obj
, void *data
, QGuestAllocator
*t_alloc
)
592 static void do_attach(QVirtio9P
*v9p
)
597 req
= v9fs_tattach(v9p
, 0, getuid(), 0);
598 v9fs_req_wait_for_reply(req
, NULL
);
599 v9fs_rattach(req
, NULL
);
602 static void fs_attach(void *obj
, void *data
, QGuestAllocator
*t_alloc
)
608 static void fs_walk(void *obj
, void *data
, QGuestAllocator
*t_alloc
)
610 QVirtio9P
*v9p
= obj
;
612 char *wnames
[P9_MAXWELEM
];
618 for (i
= 0; i
< P9_MAXWELEM
; i
++) {
619 wnames
[i
] = g_strdup_printf(QTEST_V9FS_SYNTH_WALK_FILE
, i
);
623 req
= v9fs_twalk(v9p
, 0, 1, P9_MAXWELEM
, wnames
, 0);
624 v9fs_req_wait_for_reply(req
, NULL
);
625 v9fs_rwalk(req
, &nwqid
, &wqid
);
627 g_assert_cmpint(nwqid
, ==, P9_MAXWELEM
);
629 for (i
= 0; i
< P9_MAXWELEM
; i
++) {
636 static bool fs_dirents_contain_name(struct V9fsDirent
*e
, const char* name
)
638 for (; e
; e
= e
->next
) {
639 if (!strcmp(e
->name
, name
)) {
646 /* size[4] Tmkdir tag[2] dfid[4] name[s] mode[4] gid[4] */
647 static P9Req
*v9fs_tmkdir(QVirtio9P
*v9p
, uint32_t dfid
, const char *name
,
648 uint32_t mode
, uint32_t gid
, uint16_t tag
)
652 uint32_t body_size
= 4 + 4 + 4;
653 uint16_t string_size
= v9fs_string_size(name
);
655 g_assert_cmpint(body_size
, <=, UINT32_MAX
- string_size
);
656 body_size
+= string_size
;
658 req
= v9fs_req_init(v9p
, body_size
, P9_TMKDIR
, tag
);
659 v9fs_uint32_write(req
, dfid
);
660 v9fs_string_write(req
, name
);
661 v9fs_uint32_write(req
, mode
);
662 v9fs_uint32_write(req
, gid
);
667 /* size[4] Rmkdir tag[2] qid[13] */
668 static void v9fs_rmkdir(P9Req
*req
, v9fs_qid
*qid
)
670 v9fs_req_recv(req
, P9_RMKDIR
);
672 v9fs_memread(req
, qid
, 13);
674 v9fs_memskip(req
, 13);
679 /* basic readdir test where reply fits into a single response message */
680 static void fs_readdir(void *obj
, void *data
, QGuestAllocator
*t_alloc
)
682 QVirtio9P
*v9p
= obj
;
684 char *const wnames
[] = { g_strdup(QTEST_V9FS_SYNTH_READDIR_DIR
) };
687 uint32_t count
, nentries
;
688 struct V9fsDirent
*entries
= NULL
;
692 req
= v9fs_twalk(v9p
, 0, 1, 1, wnames
, 0);
693 v9fs_req_wait_for_reply(req
, NULL
);
694 v9fs_rwalk(req
, &nqid
, NULL
);
695 g_assert_cmpint(nqid
, ==, 1);
697 req
= v9fs_tlopen(v9p
, 1, O_DIRECTORY
, 0);
698 v9fs_req_wait_for_reply(req
, NULL
);
699 v9fs_rlopen(req
, &qid
, NULL
);
702 * submit count = msize - 11, because 11 is the header size of Rreaddir
704 req
= v9fs_treaddir(v9p
, 1, 0, P9_MAX_SIZE
- 11, 0);
705 v9fs_req_wait_for_reply(req
, NULL
);
706 v9fs_rreaddir(req
, &count
, &nentries
, &entries
);
709 * Assuming msize (P9_MAX_SIZE) is large enough so we can retrieve all
710 * dir entries with only one readdir request.
714 QTEST_V9FS_SYNTH_READDIR_NFILES
+ 2 /* "." and ".." */
718 * Check all file names exist in returned entries, ignore their order
721 g_assert_cmpint(fs_dirents_contain_name(entries
, "."), ==, true);
722 g_assert_cmpint(fs_dirents_contain_name(entries
, ".."), ==, true);
723 for (int i
= 0; i
< QTEST_V9FS_SYNTH_READDIR_NFILES
; ++i
) {
724 char *name
= g_strdup_printf(QTEST_V9FS_SYNTH_READDIR_FILE
, i
);
725 g_assert_cmpint(fs_dirents_contain_name(entries
, name
), ==, true);
729 v9fs_free_dirents(entries
);
733 /* readdir test where overall request is split over several messages */
734 static void do_readdir_split(QVirtio9P
*v9p
, uint32_t count
)
736 char *const wnames
[] = { g_strdup(QTEST_V9FS_SYNTH_READDIR_DIR
) };
739 uint32_t nentries
, npartialentries
;
740 struct V9fsDirent
*entries
, *tail
, *partialentries
;
753 req
= v9fs_twalk(v9p
, 0, fid
, 1, wnames
, 0);
754 v9fs_req_wait_for_reply(req
, NULL
);
755 v9fs_rwalk(req
, &nqid
, NULL
);
756 g_assert_cmpint(nqid
, ==, 1);
758 req
= v9fs_tlopen(v9p
, fid
, O_DIRECTORY
, 0);
759 v9fs_req_wait_for_reply(req
, NULL
);
760 v9fs_rlopen(req
, &qid
, NULL
);
763 * send as many Treaddir requests as required to get all directory
768 partialentries
= NULL
;
770 req
= v9fs_treaddir(v9p
, fid
, offset
, count
, 0);
771 v9fs_req_wait_for_reply(req
, NULL
);
772 v9fs_rreaddir(req
, &count
, &npartialentries
, &partialentries
);
773 if (npartialentries
> 0 && partialentries
) {
775 entries
= partialentries
;
776 nentries
= npartialentries
;
777 tail
= partialentries
;
779 tail
->next
= partialentries
;
780 nentries
+= npartialentries
;
785 offset
= tail
->offset
;
793 QTEST_V9FS_SYNTH_READDIR_NFILES
+ 2 /* "." and ".." */
797 * Check all file names exist in returned entries, ignore their order
800 g_assert_cmpint(fs_dirents_contain_name(entries
, "."), ==, true);
801 g_assert_cmpint(fs_dirents_contain_name(entries
, ".."), ==, true);
802 for (int i
= 0; i
< QTEST_V9FS_SYNTH_READDIR_NFILES
; ++i
) {
803 char *name
= g_strdup_printf(QTEST_V9FS_SYNTH_READDIR_FILE
, i
);
804 g_assert_cmpint(fs_dirents_contain_name(entries
, name
), ==, true);
808 v9fs_free_dirents(entries
);
813 static void fs_walk_no_slash(void *obj
, void *data
, QGuestAllocator
*t_alloc
)
815 QVirtio9P
*v9p
= obj
;
817 char *const wnames
[] = { g_strdup(" /") };
822 req
= v9fs_twalk(v9p
, 0, 1, 1, wnames
, 0);
823 v9fs_req_wait_for_reply(req
, NULL
);
824 v9fs_rlerror(req
, &err
);
826 g_assert_cmpint(err
, ==, ENOENT
);
831 static void fs_walk_dotdot(void *obj
, void *data
, QGuestAllocator
*t_alloc
)
833 QVirtio9P
*v9p
= obj
;
835 char *const wnames
[] = { g_strdup("..") };
836 v9fs_qid root_qid
, *wqid
;
840 req
= v9fs_tattach(v9p
, 0, getuid(), 0);
841 v9fs_req_wait_for_reply(req
, NULL
);
842 v9fs_rattach(req
, &root_qid
);
844 req
= v9fs_twalk(v9p
, 0, 1, 1, wnames
, 0);
845 v9fs_req_wait_for_reply(req
, NULL
);
846 v9fs_rwalk(req
, NULL
, &wqid
); /* We now we'll get one qid */
848 g_assert_cmpmem(&root_qid
, 13, wqid
[0], 13);
854 static void fs_lopen(void *obj
, void *data
, QGuestAllocator
*t_alloc
)
856 QVirtio9P
*v9p
= obj
;
858 char *const wnames
[] = { g_strdup(QTEST_V9FS_SYNTH_LOPEN_FILE
) };
862 req
= v9fs_twalk(v9p
, 0, 1, 1, wnames
, 0);
863 v9fs_req_wait_for_reply(req
, NULL
);
864 v9fs_rwalk(req
, NULL
, NULL
);
866 req
= v9fs_tlopen(v9p
, 1, O_WRONLY
, 0);
867 v9fs_req_wait_for_reply(req
, NULL
);
868 v9fs_rlopen(req
, NULL
, NULL
);
873 static void fs_write(void *obj
, void *data
, QGuestAllocator
*t_alloc
)
875 QVirtio9P
*v9p
= obj
;
877 static const uint32_t write_count
= P9_MAX_SIZE
/ 2;
878 char *const wnames
[] = { g_strdup(QTEST_V9FS_SYNTH_WRITE_FILE
) };
879 char *buf
= g_malloc0(write_count
);
884 req
= v9fs_twalk(v9p
, 0, 1, 1, wnames
, 0);
885 v9fs_req_wait_for_reply(req
, NULL
);
886 v9fs_rwalk(req
, NULL
, NULL
);
888 req
= v9fs_tlopen(v9p
, 1, O_WRONLY
, 0);
889 v9fs_req_wait_for_reply(req
, NULL
);
890 v9fs_rlopen(req
, NULL
, NULL
);
892 req
= v9fs_twrite(v9p
, 1, 0, write_count
, buf
, 0);
893 v9fs_req_wait_for_reply(req
, NULL
);
894 v9fs_rwrite(req
, &count
);
895 g_assert_cmpint(count
, ==, write_count
);
901 static void fs_flush_success(void *obj
, void *data
, QGuestAllocator
*t_alloc
)
903 QVirtio9P
*v9p
= obj
;
905 char *const wnames
[] = { g_strdup(QTEST_V9FS_SYNTH_FLUSH_FILE
) };
906 P9Req
*req
, *flush_req
;
908 uint8_t should_block
;
911 req
= v9fs_twalk(v9p
, 0, 1, 1, wnames
, 0);
912 v9fs_req_wait_for_reply(req
, NULL
);
913 v9fs_rwalk(req
, NULL
, NULL
);
915 req
= v9fs_tlopen(v9p
, 1, O_WRONLY
, 0);
916 v9fs_req_wait_for_reply(req
, NULL
);
917 v9fs_rlopen(req
, NULL
, NULL
);
919 /* This will cause the 9p server to try to write data to the backend,
920 * until the write request gets cancelled.
923 req
= v9fs_twrite(v9p
, 1, 0, sizeof(should_block
), &should_block
, 0);
925 flush_req
= v9fs_tflush(v9p
, req
->tag
, 1);
927 /* The write request is supposed to be flushed: the server should just
928 * mark the write request as used and reply to the flush request.
930 v9fs_req_wait_for_reply(req
, &reply_len
);
931 g_assert_cmpint(reply_len
, ==, 0);
933 v9fs_rflush(flush_req
);
938 static void fs_flush_ignored(void *obj
, void *data
, QGuestAllocator
*t_alloc
)
940 QVirtio9P
*v9p
= obj
;
942 char *const wnames
[] = { g_strdup(QTEST_V9FS_SYNTH_FLUSH_FILE
) };
943 P9Req
*req
, *flush_req
;
945 uint8_t should_block
;
948 req
= v9fs_twalk(v9p
, 0, 1, 1, wnames
, 0);
949 v9fs_req_wait_for_reply(req
, NULL
);
950 v9fs_rwalk(req
, NULL
, NULL
);
952 req
= v9fs_tlopen(v9p
, 1, O_WRONLY
, 0);
953 v9fs_req_wait_for_reply(req
, NULL
);
954 v9fs_rlopen(req
, NULL
, NULL
);
956 /* This will cause the write request to complete right away, before it
957 * could be actually cancelled.
960 req
= v9fs_twrite(v9p
, 1, 0, sizeof(should_block
), &should_block
, 0);
962 flush_req
= v9fs_tflush(v9p
, req
->tag
, 1);
964 /* The write request is supposed to complete. The server should
965 * reply to the write request and the flush request.
967 v9fs_req_wait_for_reply(req
, NULL
);
968 v9fs_rwrite(req
, &count
);
969 g_assert_cmpint(count
, ==, sizeof(should_block
));
970 v9fs_rflush(flush_req
);
975 static void fs_mkdir(void *obj
, void *data
, QGuestAllocator
*t_alloc
,
976 const char *path
, const char *cname
)
978 QVirtio9P
*v9p
= obj
;
981 char *const name
= g_strdup(cname
);
983 const uint32_t fid
= genfid();
985 int nwnames
= split(path
, "/", &wnames
);
987 req
= v9fs_twalk(v9p
, 0, fid
, nwnames
, wnames
, 0);
988 v9fs_req_wait_for_reply(req
, NULL
);
989 v9fs_rwalk(req
, NULL
, NULL
);
991 req
= v9fs_tmkdir(v9p
, fid
, name
, 0750, 0, 0);
992 v9fs_req_wait_for_reply(req
, NULL
);
993 v9fs_rmkdir(req
, NULL
);
999 static void fs_readdir_split_128(void *obj
, void *data
,
1000 QGuestAllocator
*t_alloc
)
1003 do_readdir_split(obj
, 128);
1006 static void fs_readdir_split_256(void *obj
, void *data
,
1007 QGuestAllocator
*t_alloc
)
1010 do_readdir_split(obj
, 256);
1013 static void fs_readdir_split_512(void *obj
, void *data
,
1014 QGuestAllocator
*t_alloc
)
1017 do_readdir_split(obj
, 512);
1021 /* tests using the 9pfs 'local' fs driver */
1023 static void fs_create_dir(void *obj
, void *data
, QGuestAllocator
*t_alloc
)
1025 QVirtio9P
*v9p
= obj
;
1028 char *root_path
= virtio_9p_test_path("");
1029 char *new_dir
= virtio_9p_test_path("01");
1031 g_assert(root_path
!= NULL
);
1034 fs_mkdir(v9p
, data
, t_alloc
, "/", "01");
1036 /* check if created directory really exists now ... */
1037 g_assert(stat(new_dir
, &st
) == 0);
1038 /* ... and is actually a directory */
1039 g_assert((st
.st_mode
& S_IFMT
) == S_IFDIR
);
1045 static void *assign_9p_local_driver(GString
*cmd_line
, void *arg
)
1047 virtio_9p_assign_local_driver(cmd_line
, "security_model=mapped-xattr");
1051 static void register_virtio_9p_test(void)
1054 QOSGraphTestOptions opts
= {
1057 /* 9pfs test cases using the 'synth' filesystem driver */
1058 qos_add_test("synth/config", "virtio-9p", pci_config
, &opts
);
1059 qos_add_test("synth/version/basic", "virtio-9p", fs_version
, &opts
);
1060 qos_add_test("synth/attach/basic", "virtio-9p", fs_attach
, &opts
);
1061 qos_add_test("synth/walk/basic", "virtio-9p", fs_walk
, &opts
);
1062 qos_add_test("synth/walk/no_slash", "virtio-9p", fs_walk_no_slash
,
1064 qos_add_test("synth/walk/dotdot_from_root", "virtio-9p",
1065 fs_walk_dotdot
, &opts
);
1066 qos_add_test("synth/lopen/basic", "virtio-9p", fs_lopen
, &opts
);
1067 qos_add_test("synth/write/basic", "virtio-9p", fs_write
, &opts
);
1068 qos_add_test("synth/flush/success", "virtio-9p", fs_flush_success
,
1070 qos_add_test("synth/flush/ignored", "virtio-9p", fs_flush_ignored
,
1072 qos_add_test("synth/readdir/basic", "virtio-9p", fs_readdir
, &opts
);
1073 qos_add_test("synth/readdir/split_512", "virtio-9p",
1074 fs_readdir_split_512
, &opts
);
1075 qos_add_test("synth/readdir/split_256", "virtio-9p",
1076 fs_readdir_split_256
, &opts
);
1077 qos_add_test("synth/readdir/split_128", "virtio-9p",
1078 fs_readdir_split_128
, &opts
);
1081 /* 9pfs test cases using the 'local' filesystem driver */
1082 opts
.before
= assign_9p_local_driver
;
1083 qos_add_test("local/config", "virtio-9p", pci_config
, &opts
);
1084 qos_add_test("local/create_dir", "virtio-9p", fs_create_dir
, &opts
);
1087 libqos_init(register_virtio_9p_test
);
1089 static void __attribute__((constructor
)) construct_9p_test(void)
1091 /* make sure test dir for the 'local' tests exists */
1092 virtio_9p_create_local_test_dir();
1095 static void __attribute__((destructor
)) destruct_9p_test(void)
1097 /* remove previously created test dir when test suite completed */
1098 virtio_9p_remove_local_test_dir();