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 fs_version(void *obj
, void *data
, QGuestAllocator
*t_alloc
)
572 QVirtio9P
*v9p
= obj
;
574 const char *version
= "9P2000.L";
576 char *server_version
;
579 req
= v9fs_tversion(v9p
, P9_MAX_SIZE
, version
, P9_NOTAG
);
580 v9fs_req_wait_for_reply(req
, NULL
);
581 v9fs_rversion(req
, &server_len
, &server_version
);
583 g_assert_cmpmem(server_version
, server_len
, version
, strlen(version
));
585 g_free(server_version
);
588 static void fs_attach(void *obj
, void *data
, QGuestAllocator
*t_alloc
)
590 QVirtio9P
*v9p
= obj
;
594 fs_version(v9p
, NULL
, t_alloc
);
595 req
= v9fs_tattach(v9p
, 0, getuid(), 0);
596 v9fs_req_wait_for_reply(req
, NULL
);
597 v9fs_rattach(req
, NULL
);
600 static void fs_walk(void *obj
, void *data
, QGuestAllocator
*t_alloc
)
602 QVirtio9P
*v9p
= obj
;
604 char *wnames
[P9_MAXWELEM
];
610 for (i
= 0; i
< P9_MAXWELEM
; i
++) {
611 wnames
[i
] = g_strdup_printf(QTEST_V9FS_SYNTH_WALK_FILE
, i
);
614 fs_attach(v9p
, NULL
, t_alloc
);
615 req
= v9fs_twalk(v9p
, 0, 1, P9_MAXWELEM
, wnames
, 0);
616 v9fs_req_wait_for_reply(req
, NULL
);
617 v9fs_rwalk(req
, &nwqid
, &wqid
);
619 g_assert_cmpint(nwqid
, ==, P9_MAXWELEM
);
621 for (i
= 0; i
< P9_MAXWELEM
; i
++) {
628 static bool fs_dirents_contain_name(struct V9fsDirent
*e
, const char* name
)
630 for (; e
; e
= e
->next
) {
631 if (!strcmp(e
->name
, name
)) {
638 /* size[4] Tmkdir tag[2] dfid[4] name[s] mode[4] gid[4] */
639 static P9Req
*v9fs_tmkdir(QVirtio9P
*v9p
, uint32_t dfid
, const char *name
,
640 uint32_t mode
, uint32_t gid
, uint16_t tag
)
644 uint32_t body_size
= 4 + 4 + 4;
645 uint16_t string_size
= v9fs_string_size(name
);
647 g_assert_cmpint(body_size
, <=, UINT32_MAX
- string_size
);
648 body_size
+= string_size
;
650 req
= v9fs_req_init(v9p
, body_size
, P9_TMKDIR
, tag
);
651 v9fs_uint32_write(req
, dfid
);
652 v9fs_string_write(req
, name
);
653 v9fs_uint32_write(req
, mode
);
654 v9fs_uint32_write(req
, gid
);
659 /* size[4] Rmkdir tag[2] qid[13] */
660 static void v9fs_rmkdir(P9Req
*req
, v9fs_qid
*qid
)
662 v9fs_req_recv(req
, P9_RMKDIR
);
664 v9fs_memread(req
, qid
, 13);
666 v9fs_memskip(req
, 13);
671 /* basic readdir test where reply fits into a single response message */
672 static void fs_readdir(void *obj
, void *data
, QGuestAllocator
*t_alloc
)
674 QVirtio9P
*v9p
= obj
;
676 char *const wnames
[] = { g_strdup(QTEST_V9FS_SYNTH_READDIR_DIR
) };
679 uint32_t count
, nentries
;
680 struct V9fsDirent
*entries
= NULL
;
683 fs_attach(v9p
, NULL
, t_alloc
);
684 req
= v9fs_twalk(v9p
, 0, 1, 1, wnames
, 0);
685 v9fs_req_wait_for_reply(req
, NULL
);
686 v9fs_rwalk(req
, &nqid
, NULL
);
687 g_assert_cmpint(nqid
, ==, 1);
689 req
= v9fs_tlopen(v9p
, 1, O_DIRECTORY
, 0);
690 v9fs_req_wait_for_reply(req
, NULL
);
691 v9fs_rlopen(req
, &qid
, NULL
);
694 * submit count = msize - 11, because 11 is the header size of Rreaddir
696 req
= v9fs_treaddir(v9p
, 1, 0, P9_MAX_SIZE
- 11, 0);
697 v9fs_req_wait_for_reply(req
, NULL
);
698 v9fs_rreaddir(req
, &count
, &nentries
, &entries
);
701 * Assuming msize (P9_MAX_SIZE) is large enough so we can retrieve all
702 * dir entries with only one readdir request.
706 QTEST_V9FS_SYNTH_READDIR_NFILES
+ 2 /* "." and ".." */
710 * Check all file names exist in returned entries, ignore their order
713 g_assert_cmpint(fs_dirents_contain_name(entries
, "."), ==, true);
714 g_assert_cmpint(fs_dirents_contain_name(entries
, ".."), ==, true);
715 for (int i
= 0; i
< QTEST_V9FS_SYNTH_READDIR_NFILES
; ++i
) {
716 char *name
= g_strdup_printf(QTEST_V9FS_SYNTH_READDIR_FILE
, i
);
717 g_assert_cmpint(fs_dirents_contain_name(entries
, name
), ==, true);
721 v9fs_free_dirents(entries
);
725 /* readdir test where overall request is split over several messages */
726 static void fs_readdir_split(void *obj
, void *data
, QGuestAllocator
*t_alloc
,
729 QVirtio9P
*v9p
= obj
;
731 char *const wnames
[] = { g_strdup(QTEST_V9FS_SYNTH_READDIR_DIR
) };
734 uint32_t nentries
, npartialentries
;
735 struct V9fsDirent
*entries
, *tail
, *partialentries
;
740 fs_attach(v9p
, NULL
, t_alloc
);
748 req
= v9fs_twalk(v9p
, 0, fid
, 1, wnames
, 0);
749 v9fs_req_wait_for_reply(req
, NULL
);
750 v9fs_rwalk(req
, &nqid
, NULL
);
751 g_assert_cmpint(nqid
, ==, 1);
753 req
= v9fs_tlopen(v9p
, fid
, O_DIRECTORY
, 0);
754 v9fs_req_wait_for_reply(req
, NULL
);
755 v9fs_rlopen(req
, &qid
, NULL
);
758 * send as many Treaddir requests as required to get all directory
763 partialentries
= NULL
;
765 req
= v9fs_treaddir(v9p
, fid
, offset
, count
, 0);
766 v9fs_req_wait_for_reply(req
, NULL
);
767 v9fs_rreaddir(req
, &count
, &npartialentries
, &partialentries
);
768 if (npartialentries
> 0 && partialentries
) {
770 entries
= partialentries
;
771 nentries
= npartialentries
;
772 tail
= partialentries
;
774 tail
->next
= partialentries
;
775 nentries
+= npartialentries
;
780 offset
= tail
->offset
;
788 QTEST_V9FS_SYNTH_READDIR_NFILES
+ 2 /* "." and ".." */
792 * Check all file names exist in returned entries, ignore their order
795 g_assert_cmpint(fs_dirents_contain_name(entries
, "."), ==, true);
796 g_assert_cmpint(fs_dirents_contain_name(entries
, ".."), ==, true);
797 for (int i
= 0; i
< QTEST_V9FS_SYNTH_READDIR_NFILES
; ++i
) {
798 char *name
= g_strdup_printf(QTEST_V9FS_SYNTH_READDIR_FILE
, i
);
799 g_assert_cmpint(fs_dirents_contain_name(entries
, name
), ==, true);
803 v9fs_free_dirents(entries
);
808 static void fs_walk_no_slash(void *obj
, void *data
, QGuestAllocator
*t_alloc
)
810 QVirtio9P
*v9p
= obj
;
812 char *const wnames
[] = { g_strdup(" /") };
816 fs_attach(v9p
, NULL
, t_alloc
);
817 req
= v9fs_twalk(v9p
, 0, 1, 1, wnames
, 0);
818 v9fs_req_wait_for_reply(req
, NULL
);
819 v9fs_rlerror(req
, &err
);
821 g_assert_cmpint(err
, ==, ENOENT
);
826 static void fs_walk_dotdot(void *obj
, void *data
, QGuestAllocator
*t_alloc
)
828 QVirtio9P
*v9p
= obj
;
830 char *const wnames
[] = { g_strdup("..") };
831 v9fs_qid root_qid
, *wqid
;
834 fs_version(v9p
, NULL
, t_alloc
);
835 req
= v9fs_tattach(v9p
, 0, getuid(), 0);
836 v9fs_req_wait_for_reply(req
, NULL
);
837 v9fs_rattach(req
, &root_qid
);
839 req
= v9fs_twalk(v9p
, 0, 1, 1, wnames
, 0);
840 v9fs_req_wait_for_reply(req
, NULL
);
841 v9fs_rwalk(req
, NULL
, &wqid
); /* We now we'll get one qid */
843 g_assert_cmpmem(&root_qid
, 13, wqid
[0], 13);
849 static void fs_lopen(void *obj
, void *data
, QGuestAllocator
*t_alloc
)
851 QVirtio9P
*v9p
= obj
;
853 char *const wnames
[] = { g_strdup(QTEST_V9FS_SYNTH_LOPEN_FILE
) };
856 fs_attach(v9p
, NULL
, t_alloc
);
857 req
= v9fs_twalk(v9p
, 0, 1, 1, wnames
, 0);
858 v9fs_req_wait_for_reply(req
, NULL
);
859 v9fs_rwalk(req
, NULL
, NULL
);
861 req
= v9fs_tlopen(v9p
, 1, O_WRONLY
, 0);
862 v9fs_req_wait_for_reply(req
, NULL
);
863 v9fs_rlopen(req
, NULL
, NULL
);
868 static void fs_write(void *obj
, void *data
, QGuestAllocator
*t_alloc
)
870 QVirtio9P
*v9p
= obj
;
872 static const uint32_t write_count
= P9_MAX_SIZE
/ 2;
873 char *const wnames
[] = { g_strdup(QTEST_V9FS_SYNTH_WRITE_FILE
) };
874 char *buf
= g_malloc0(write_count
);
878 fs_attach(v9p
, NULL
, t_alloc
);
879 req
= v9fs_twalk(v9p
, 0, 1, 1, wnames
, 0);
880 v9fs_req_wait_for_reply(req
, NULL
);
881 v9fs_rwalk(req
, NULL
, NULL
);
883 req
= v9fs_tlopen(v9p
, 1, O_WRONLY
, 0);
884 v9fs_req_wait_for_reply(req
, NULL
);
885 v9fs_rlopen(req
, NULL
, NULL
);
887 req
= v9fs_twrite(v9p
, 1, 0, write_count
, buf
, 0);
888 v9fs_req_wait_for_reply(req
, NULL
);
889 v9fs_rwrite(req
, &count
);
890 g_assert_cmpint(count
, ==, write_count
);
896 static void fs_flush_success(void *obj
, void *data
, QGuestAllocator
*t_alloc
)
898 QVirtio9P
*v9p
= obj
;
900 char *const wnames
[] = { g_strdup(QTEST_V9FS_SYNTH_FLUSH_FILE
) };
901 P9Req
*req
, *flush_req
;
903 uint8_t should_block
;
905 fs_attach(v9p
, NULL
, t_alloc
);
906 req
= v9fs_twalk(v9p
, 0, 1, 1, wnames
, 0);
907 v9fs_req_wait_for_reply(req
, NULL
);
908 v9fs_rwalk(req
, NULL
, NULL
);
910 req
= v9fs_tlopen(v9p
, 1, O_WRONLY
, 0);
911 v9fs_req_wait_for_reply(req
, NULL
);
912 v9fs_rlopen(req
, NULL
, NULL
);
914 /* This will cause the 9p server to try to write data to the backend,
915 * until the write request gets cancelled.
918 req
= v9fs_twrite(v9p
, 1, 0, sizeof(should_block
), &should_block
, 0);
920 flush_req
= v9fs_tflush(v9p
, req
->tag
, 1);
922 /* The write request is supposed to be flushed: the server should just
923 * mark the write request as used and reply to the flush request.
925 v9fs_req_wait_for_reply(req
, &reply_len
);
926 g_assert_cmpint(reply_len
, ==, 0);
928 v9fs_rflush(flush_req
);
933 static void fs_flush_ignored(void *obj
, void *data
, QGuestAllocator
*t_alloc
)
935 QVirtio9P
*v9p
= obj
;
937 char *const wnames
[] = { g_strdup(QTEST_V9FS_SYNTH_FLUSH_FILE
) };
938 P9Req
*req
, *flush_req
;
940 uint8_t should_block
;
942 fs_attach(v9p
, NULL
, t_alloc
);
943 req
= v9fs_twalk(v9p
, 0, 1, 1, wnames
, 0);
944 v9fs_req_wait_for_reply(req
, NULL
);
945 v9fs_rwalk(req
, NULL
, NULL
);
947 req
= v9fs_tlopen(v9p
, 1, O_WRONLY
, 0);
948 v9fs_req_wait_for_reply(req
, NULL
);
949 v9fs_rlopen(req
, NULL
, NULL
);
951 /* This will cause the write request to complete right away, before it
952 * could be actually cancelled.
955 req
= v9fs_twrite(v9p
, 1, 0, sizeof(should_block
), &should_block
, 0);
957 flush_req
= v9fs_tflush(v9p
, req
->tag
, 1);
959 /* The write request is supposed to complete. The server should
960 * reply to the write request and the flush request.
962 v9fs_req_wait_for_reply(req
, NULL
);
963 v9fs_rwrite(req
, &count
);
964 g_assert_cmpint(count
, ==, sizeof(should_block
));
965 v9fs_rflush(flush_req
);
970 static void fs_mkdir(void *obj
, void *data
, QGuestAllocator
*t_alloc
,
971 const char *path
, const char *cname
)
973 QVirtio9P
*v9p
= obj
;
976 char *const name
= g_strdup(cname
);
978 const uint32_t fid
= genfid();
980 int nwnames
= split(path
, "/", &wnames
);
982 req
= v9fs_twalk(v9p
, 0, fid
, nwnames
, wnames
, 0);
983 v9fs_req_wait_for_reply(req
, NULL
);
984 v9fs_rwalk(req
, NULL
, NULL
);
986 req
= v9fs_tmkdir(v9p
, fid
, name
, 0750, 0, 0);
987 v9fs_req_wait_for_reply(req
, NULL
);
988 v9fs_rmkdir(req
, NULL
);
994 static void fs_readdir_split_128(void *obj
, void *data
,
995 QGuestAllocator
*t_alloc
)
997 fs_readdir_split(obj
, data
, t_alloc
, 128);
1000 static void fs_readdir_split_256(void *obj
, void *data
,
1001 QGuestAllocator
*t_alloc
)
1003 fs_readdir_split(obj
, data
, t_alloc
, 256);
1006 static void fs_readdir_split_512(void *obj
, void *data
,
1007 QGuestAllocator
*t_alloc
)
1009 fs_readdir_split(obj
, data
, t_alloc
, 512);
1013 /* tests using the 9pfs 'local' fs driver */
1015 static void fs_create_dir(void *obj
, void *data
, QGuestAllocator
*t_alloc
)
1017 QVirtio9P
*v9p
= obj
;
1019 char *root_path
= virtio_9p_test_path("");
1020 char *new_dir
= virtio_9p_test_path("01");
1022 g_assert(root_path
!= NULL
);
1024 fs_attach(v9p
, NULL
, t_alloc
);
1025 fs_mkdir(v9p
, data
, t_alloc
, "/", "01");
1027 /* check if created directory really exists now ... */
1028 g_assert(stat(new_dir
, &st
) == 0);
1029 /* ... and is actually a directory */
1030 g_assert((st
.st_mode
& S_IFMT
) == S_IFDIR
);
1036 static void *assign_9p_local_driver(GString
*cmd_line
, void *arg
)
1038 virtio_9p_assign_local_driver(cmd_line
, "security_model=mapped-xattr");
1042 static void register_virtio_9p_test(void)
1045 QOSGraphTestOptions opts
= {
1048 /* 9pfs test cases using the 'synth' filesystem driver */
1049 qos_add_test("synth/config", "virtio-9p", pci_config
, &opts
);
1050 qos_add_test("synth/version/basic", "virtio-9p", fs_version
, &opts
);
1051 qos_add_test("synth/attach/basic", "virtio-9p", fs_attach
, &opts
);
1052 qos_add_test("synth/walk/basic", "virtio-9p", fs_walk
, &opts
);
1053 qos_add_test("synth/walk/no_slash", "virtio-9p", fs_walk_no_slash
,
1055 qos_add_test("synth/walk/dotdot_from_root", "virtio-9p",
1056 fs_walk_dotdot
, &opts
);
1057 qos_add_test("synth/lopen/basic", "virtio-9p", fs_lopen
, &opts
);
1058 qos_add_test("synth/write/basic", "virtio-9p", fs_write
, &opts
);
1059 qos_add_test("synth/flush/success", "virtio-9p", fs_flush_success
,
1061 qos_add_test("synth/flush/ignored", "virtio-9p", fs_flush_ignored
,
1063 qos_add_test("synth/readdir/basic", "virtio-9p", fs_readdir
, &opts
);
1064 qos_add_test("synth/readdir/split_512", "virtio-9p",
1065 fs_readdir_split_512
, &opts
);
1066 qos_add_test("synth/readdir/split_256", "virtio-9p",
1067 fs_readdir_split_256
, &opts
);
1068 qos_add_test("synth/readdir/split_128", "virtio-9p",
1069 fs_readdir_split_128
, &opts
);
1072 /* 9pfs test cases using the 'local' filesystem driver */
1073 opts
.before
= assign_9p_local_driver
;
1074 qos_add_test("local/config", "virtio-9p", pci_config
, &opts
);
1075 qos_add_test("local/create_dir", "virtio-9p", fs_create_dir
, &opts
);
1078 libqos_init(register_virtio_9p_test
);
1080 static void __attribute__((constructor
)) construct_9p_test(void)
1082 /* make sure test dir for the 'local' tests exists */
1083 virtio_9p_create_local_test_dir();
1086 static void __attribute__((destructor
)) destruct_9p_test(void)
1088 /* remove previously created test dir when test suite completed */
1089 virtio_9p_remove_local_test_dir();