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_RUNLINKAT
? "RUNLINKAT" :
262 id
== P9_RFLUSH
? "RFLUSH" :
263 id
== P9_RREADDIR
? "READDIR" :
267 static void v9fs_req_wait_for_reply(P9Req
*req
, uint32_t *len
)
269 QVirtio9P
*v9p
= req
->v9p
;
271 qvirtio_wait_used_elem(req
->qts
, v9p
->vdev
, v9p
->vq
, req
->free_head
, len
,
272 QVIRTIO_9P_TIMEOUT_US
);
275 static void v9fs_req_recv(P9Req
*req
, uint8_t id
)
279 v9fs_memread(req
, &hdr
, 7);
280 hdr
.size
= ldl_le_p(&hdr
.size
);
281 hdr
.tag
= lduw_le_p(&hdr
.tag
);
283 g_assert_cmpint(hdr
.size
, >=, 7);
284 g_assert_cmpint(hdr
.size
, <=, P9_MAX_SIZE
);
285 g_assert_cmpint(hdr
.tag
, ==, req
->tag
);
288 g_printerr("Received response %d (%s) instead of %d (%s)\n",
289 hdr
.id
, rmessage_name(hdr
.id
), id
, rmessage_name(id
));
291 if (hdr
.id
== P9_RLERROR
) {
293 v9fs_uint32_read(req
, &err
);
294 g_printerr("Rlerror has errno %d (%s)\n", err
, strerror(err
));
297 g_assert_cmpint(hdr
.id
, ==, id
);
300 static void v9fs_req_free(P9Req
*req
)
302 guest_free(alloc
, req
->t_msg
);
303 guest_free(alloc
, req
->r_msg
);
307 /* size[4] Rlerror tag[2] ecode[4] */
308 static void v9fs_rlerror(P9Req
*req
, uint32_t *err
)
310 v9fs_req_recv(req
, P9_RLERROR
);
311 v9fs_uint32_read(req
, err
);
315 /* size[4] Tversion tag[2] msize[4] version[s] */
316 static P9Req
*v9fs_tversion(QVirtio9P
*v9p
, uint32_t msize
, const char *version
,
320 uint32_t body_size
= 4;
321 uint16_t string_size
= v9fs_string_size(version
);
323 g_assert_cmpint(body_size
, <=, UINT32_MAX
- string_size
);
324 body_size
+= string_size
;
325 req
= v9fs_req_init(v9p
, body_size
, P9_TVERSION
, tag
);
327 v9fs_uint32_write(req
, msize
);
328 v9fs_string_write(req
, version
);
333 /* size[4] Rversion tag[2] msize[4] version[s] */
334 static void v9fs_rversion(P9Req
*req
, uint16_t *len
, char **version
)
338 v9fs_req_recv(req
, P9_RVERSION
);
339 v9fs_uint32_read(req
, &msize
);
341 g_assert_cmpint(msize
, ==, P9_MAX_SIZE
);
343 if (len
|| version
) {
344 v9fs_string_read(req
, len
, version
);
350 /* size[4] Tattach tag[2] fid[4] afid[4] uname[s] aname[s] n_uname[4] */
351 static P9Req
*v9fs_tattach(QVirtio9P
*v9p
, uint32_t fid
, uint32_t n_uname
,
354 const char *uname
= ""; /* ignored by QEMU */
355 const char *aname
= ""; /* ignored by QEMU */
356 P9Req
*req
= v9fs_req_init(v9p
, 4 + 4 + 2 + 2 + 4, P9_TATTACH
, tag
);
358 v9fs_uint32_write(req
, fid
);
359 v9fs_uint32_write(req
, P9_NOFID
);
360 v9fs_string_write(req
, uname
);
361 v9fs_string_write(req
, aname
);
362 v9fs_uint32_write(req
, n_uname
);
367 typedef char v9fs_qid
[13];
369 /* size[4] Rattach tag[2] qid[13] */
370 static void v9fs_rattach(P9Req
*req
, v9fs_qid
*qid
)
372 v9fs_req_recv(req
, P9_RATTACH
);
374 v9fs_memread(req
, qid
, 13);
379 /* size[4] Twalk tag[2] fid[4] newfid[4] nwname[2] nwname*(wname[s]) */
380 static P9Req
*v9fs_twalk(QVirtio9P
*v9p
, uint32_t fid
, uint32_t newfid
,
381 uint16_t nwname
, char *const wnames
[], uint16_t tag
)
385 uint32_t body_size
= 4 + 4 + 2;
387 for (i
= 0; i
< nwname
; i
++) {
388 uint16_t wname_size
= v9fs_string_size(wnames
[i
]);
390 g_assert_cmpint(body_size
, <=, UINT32_MAX
- wname_size
);
391 body_size
+= wname_size
;
393 req
= v9fs_req_init(v9p
, body_size
, P9_TWALK
, tag
);
394 v9fs_uint32_write(req
, fid
);
395 v9fs_uint32_write(req
, newfid
);
396 v9fs_uint16_write(req
, nwname
);
397 for (i
= 0; i
< nwname
; i
++) {
398 v9fs_string_write(req
, wnames
[i
]);
404 /* size[4] Rwalk tag[2] nwqid[2] nwqid*(wqid[13]) */
405 static void v9fs_rwalk(P9Req
*req
, uint16_t *nwqid
, v9fs_qid
**wqid
)
407 uint16_t local_nwqid
;
409 v9fs_req_recv(req
, P9_RWALK
);
410 v9fs_uint16_read(req
, &local_nwqid
);
412 *nwqid
= local_nwqid
;
415 *wqid
= g_malloc(local_nwqid
* 13);
416 v9fs_memread(req
, *wqid
, local_nwqid
* 13);
421 /* size[4] Treaddir tag[2] fid[4] offset[8] count[4] */
422 static P9Req
*v9fs_treaddir(QVirtio9P
*v9p
, uint32_t fid
, uint64_t offset
,
423 uint32_t count
, uint16_t tag
)
427 req
= v9fs_req_init(v9p
, 4 + 8 + 4, P9_TREADDIR
, tag
);
428 v9fs_uint32_write(req
, fid
);
429 v9fs_uint64_write(req
, offset
);
430 v9fs_uint32_write(req
, count
);
440 struct V9fsDirent
*next
;
443 /* size[4] Rreaddir tag[2] count[4] data[count] */
444 static void v9fs_rreaddir(P9Req
*req
, uint32_t *count
, uint32_t *nentries
,
445 struct V9fsDirent
**entries
)
447 uint32_t local_count
;
448 struct V9fsDirent
*e
= NULL
;
452 v9fs_req_recv(req
, P9_RREADDIR
);
453 v9fs_uint32_read(req
, &local_count
);
456 *count
= local_count
;
459 for (int32_t togo
= (int32_t)local_count
;
460 togo
>= 13 + 8 + 1 + 2;
461 togo
-= 13 + 8 + 1 + 2 + slen
, ++n
)
464 e
= g_malloc(sizeof(struct V9fsDirent
));
469 e
= e
->next
= g_malloc(sizeof(struct V9fsDirent
));
472 /* qid[13] offset[8] type[1] name[s] */
473 v9fs_memread(req
, &e
->qid
, 13);
474 v9fs_uint64_read(req
, &e
->offset
);
475 v9fs_uint8_read(req
, &e
->type
);
476 v9fs_string_read(req
, &slen
, &e
->name
);
486 static void v9fs_free_dirents(struct V9fsDirent
*e
)
488 struct V9fsDirent
*next
= NULL
;
490 for (; e
; e
= next
) {
497 /* size[4] Tlopen tag[2] fid[4] flags[4] */
498 static P9Req
*v9fs_tlopen(QVirtio9P
*v9p
, uint32_t fid
, uint32_t flags
,
503 req
= v9fs_req_init(v9p
, 4 + 4, P9_TLOPEN
, tag
);
504 v9fs_uint32_write(req
, fid
);
505 v9fs_uint32_write(req
, flags
);
510 /* size[4] Rlopen tag[2] qid[13] iounit[4] */
511 static void v9fs_rlopen(P9Req
*req
, v9fs_qid
*qid
, uint32_t *iounit
)
513 v9fs_req_recv(req
, P9_RLOPEN
);
515 v9fs_memread(req
, qid
, 13);
517 v9fs_memskip(req
, 13);
520 v9fs_uint32_read(req
, iounit
);
525 /* size[4] Twrite tag[2] fid[4] offset[8] count[4] data[count] */
526 static P9Req
*v9fs_twrite(QVirtio9P
*v9p
, uint32_t fid
, uint64_t offset
,
527 uint32_t count
, const void *data
, uint16_t tag
)
530 uint32_t body_size
= 4 + 8 + 4;
532 g_assert_cmpint(body_size
, <=, UINT32_MAX
- count
);
534 req
= v9fs_req_init(v9p
, body_size
, P9_TWRITE
, tag
);
535 v9fs_uint32_write(req
, fid
);
536 v9fs_uint64_write(req
, offset
);
537 v9fs_uint32_write(req
, count
);
538 v9fs_memwrite(req
, data
, count
);
543 /* size[4] Rwrite tag[2] count[4] */
544 static void v9fs_rwrite(P9Req
*req
, uint32_t *count
)
546 v9fs_req_recv(req
, P9_RWRITE
);
548 v9fs_uint32_read(req
, count
);
553 /* size[4] Tflush tag[2] oldtag[2] */
554 static P9Req
*v9fs_tflush(QVirtio9P
*v9p
, uint16_t oldtag
, uint16_t tag
)
558 req
= v9fs_req_init(v9p
, 2, P9_TFLUSH
, tag
);
559 v9fs_uint32_write(req
, oldtag
);
564 /* size[4] Rflush tag[2] */
565 static void v9fs_rflush(P9Req
*req
)
567 v9fs_req_recv(req
, P9_RFLUSH
);
571 static void do_version(QVirtio9P
*v9p
)
573 const char *version
= "9P2000.L";
575 char *server_version
;
578 req
= v9fs_tversion(v9p
, P9_MAX_SIZE
, version
, P9_NOTAG
);
579 v9fs_req_wait_for_reply(req
, NULL
);
580 v9fs_rversion(req
, &server_len
, &server_version
);
582 g_assert_cmpmem(server_version
, server_len
, version
, strlen(version
));
584 g_free(server_version
);
587 /* utility function: walk to requested dir and return fid for that dir */
588 static uint32_t do_walk(QVirtio9P
*v9p
, const char *path
)
592 const uint32_t fid
= genfid();
594 int nwnames
= split(path
, "/", &wnames
);
596 req
= v9fs_twalk(v9p
, 0, fid
, nwnames
, wnames
, 0);
597 v9fs_req_wait_for_reply(req
, NULL
);
598 v9fs_rwalk(req
, NULL
, NULL
);
604 static void fs_version(void *obj
, void *data
, QGuestAllocator
*t_alloc
)
610 static void do_attach(QVirtio9P
*v9p
)
615 req
= v9fs_tattach(v9p
, 0, getuid(), 0);
616 v9fs_req_wait_for_reply(req
, NULL
);
617 v9fs_rattach(req
, NULL
);
620 static void fs_attach(void *obj
, void *data
, QGuestAllocator
*t_alloc
)
626 static void fs_walk(void *obj
, void *data
, QGuestAllocator
*t_alloc
)
628 QVirtio9P
*v9p
= obj
;
630 char *wnames
[P9_MAXWELEM
];
636 for (i
= 0; i
< P9_MAXWELEM
; i
++) {
637 wnames
[i
] = g_strdup_printf(QTEST_V9FS_SYNTH_WALK_FILE
, i
);
641 req
= v9fs_twalk(v9p
, 0, 1, P9_MAXWELEM
, wnames
, 0);
642 v9fs_req_wait_for_reply(req
, NULL
);
643 v9fs_rwalk(req
, &nwqid
, &wqid
);
645 g_assert_cmpint(nwqid
, ==, P9_MAXWELEM
);
647 for (i
= 0; i
< P9_MAXWELEM
; i
++) {
654 static bool fs_dirents_contain_name(struct V9fsDirent
*e
, const char* name
)
656 for (; e
; e
= e
->next
) {
657 if (!strcmp(e
->name
, name
)) {
664 /* size[4] Tmkdir tag[2] dfid[4] name[s] mode[4] gid[4] */
665 static P9Req
*v9fs_tmkdir(QVirtio9P
*v9p
, uint32_t dfid
, const char *name
,
666 uint32_t mode
, uint32_t gid
, uint16_t tag
)
670 uint32_t body_size
= 4 + 4 + 4;
671 uint16_t string_size
= v9fs_string_size(name
);
673 g_assert_cmpint(body_size
, <=, UINT32_MAX
- string_size
);
674 body_size
+= string_size
;
676 req
= v9fs_req_init(v9p
, body_size
, P9_TMKDIR
, tag
);
677 v9fs_uint32_write(req
, dfid
);
678 v9fs_string_write(req
, name
);
679 v9fs_uint32_write(req
, mode
);
680 v9fs_uint32_write(req
, gid
);
685 /* size[4] Rmkdir tag[2] qid[13] */
686 static void v9fs_rmkdir(P9Req
*req
, v9fs_qid
*qid
)
688 v9fs_req_recv(req
, P9_RMKDIR
);
690 v9fs_memread(req
, qid
, 13);
692 v9fs_memskip(req
, 13);
697 /* size[4] Tunlinkat tag[2] dirfd[4] name[s] flags[4] */
698 static P9Req
*v9fs_tunlinkat(QVirtio9P
*v9p
, uint32_t dirfd
, const char *name
,
699 uint32_t flags
, uint16_t tag
)
703 uint32_t body_size
= 4 + 4;
704 uint16_t string_size
= v9fs_string_size(name
);
706 g_assert_cmpint(body_size
, <=, UINT32_MAX
- string_size
);
707 body_size
+= string_size
;
709 req
= v9fs_req_init(v9p
, body_size
, P9_TUNLINKAT
, tag
);
710 v9fs_uint32_write(req
, dirfd
);
711 v9fs_string_write(req
, name
);
712 v9fs_uint32_write(req
, flags
);
717 /* size[4] Runlinkat tag[2] */
718 static void v9fs_runlinkat(P9Req
*req
)
720 v9fs_req_recv(req
, P9_RUNLINKAT
);
724 /* basic readdir test where reply fits into a single response message */
725 static void fs_readdir(void *obj
, void *data
, QGuestAllocator
*t_alloc
)
727 QVirtio9P
*v9p
= obj
;
729 char *const wnames
[] = { g_strdup(QTEST_V9FS_SYNTH_READDIR_DIR
) };
732 uint32_t count
, nentries
;
733 struct V9fsDirent
*entries
= NULL
;
737 req
= v9fs_twalk(v9p
, 0, 1, 1, wnames
, 0);
738 v9fs_req_wait_for_reply(req
, NULL
);
739 v9fs_rwalk(req
, &nqid
, NULL
);
740 g_assert_cmpint(nqid
, ==, 1);
742 req
= v9fs_tlopen(v9p
, 1, O_DIRECTORY
, 0);
743 v9fs_req_wait_for_reply(req
, NULL
);
744 v9fs_rlopen(req
, &qid
, NULL
);
747 * submit count = msize - 11, because 11 is the header size of Rreaddir
749 req
= v9fs_treaddir(v9p
, 1, 0, P9_MAX_SIZE
- 11, 0);
750 v9fs_req_wait_for_reply(req
, NULL
);
751 v9fs_rreaddir(req
, &count
, &nentries
, &entries
);
754 * Assuming msize (P9_MAX_SIZE) is large enough so we can retrieve all
755 * dir entries with only one readdir request.
759 QTEST_V9FS_SYNTH_READDIR_NFILES
+ 2 /* "." and ".." */
763 * Check all file names exist in returned entries, ignore their order
766 g_assert_cmpint(fs_dirents_contain_name(entries
, "."), ==, true);
767 g_assert_cmpint(fs_dirents_contain_name(entries
, ".."), ==, true);
768 for (int i
= 0; i
< QTEST_V9FS_SYNTH_READDIR_NFILES
; ++i
) {
769 char *name
= g_strdup_printf(QTEST_V9FS_SYNTH_READDIR_FILE
, i
);
770 g_assert_cmpint(fs_dirents_contain_name(entries
, name
), ==, true);
774 v9fs_free_dirents(entries
);
778 /* readdir test where overall request is split over several messages */
779 static void do_readdir_split(QVirtio9P
*v9p
, uint32_t count
)
781 char *const wnames
[] = { g_strdup(QTEST_V9FS_SYNTH_READDIR_DIR
) };
784 uint32_t nentries
, npartialentries
;
785 struct V9fsDirent
*entries
, *tail
, *partialentries
;
798 req
= v9fs_twalk(v9p
, 0, fid
, 1, wnames
, 0);
799 v9fs_req_wait_for_reply(req
, NULL
);
800 v9fs_rwalk(req
, &nqid
, NULL
);
801 g_assert_cmpint(nqid
, ==, 1);
803 req
= v9fs_tlopen(v9p
, fid
, O_DIRECTORY
, 0);
804 v9fs_req_wait_for_reply(req
, NULL
);
805 v9fs_rlopen(req
, &qid
, NULL
);
808 * send as many Treaddir requests as required to get all directory
813 partialentries
= NULL
;
815 req
= v9fs_treaddir(v9p
, fid
, offset
, count
, 0);
816 v9fs_req_wait_for_reply(req
, NULL
);
817 v9fs_rreaddir(req
, &count
, &npartialentries
, &partialentries
);
818 if (npartialentries
> 0 && partialentries
) {
820 entries
= partialentries
;
821 nentries
= npartialentries
;
822 tail
= partialentries
;
824 tail
->next
= partialentries
;
825 nentries
+= npartialentries
;
830 offset
= tail
->offset
;
838 QTEST_V9FS_SYNTH_READDIR_NFILES
+ 2 /* "." and ".." */
842 * Check all file names exist in returned entries, ignore their order
845 g_assert_cmpint(fs_dirents_contain_name(entries
, "."), ==, true);
846 g_assert_cmpint(fs_dirents_contain_name(entries
, ".."), ==, true);
847 for (int i
= 0; i
< QTEST_V9FS_SYNTH_READDIR_NFILES
; ++i
) {
848 char *name
= g_strdup_printf(QTEST_V9FS_SYNTH_READDIR_FILE
, i
);
849 g_assert_cmpint(fs_dirents_contain_name(entries
, name
), ==, true);
853 v9fs_free_dirents(entries
);
858 static void fs_walk_no_slash(void *obj
, void *data
, QGuestAllocator
*t_alloc
)
860 QVirtio9P
*v9p
= obj
;
862 char *const wnames
[] = { g_strdup(" /") };
867 req
= v9fs_twalk(v9p
, 0, 1, 1, wnames
, 0);
868 v9fs_req_wait_for_reply(req
, NULL
);
869 v9fs_rlerror(req
, &err
);
871 g_assert_cmpint(err
, ==, ENOENT
);
876 static void fs_walk_dotdot(void *obj
, void *data
, QGuestAllocator
*t_alloc
)
878 QVirtio9P
*v9p
= obj
;
880 char *const wnames
[] = { g_strdup("..") };
881 v9fs_qid root_qid
, *wqid
;
885 req
= v9fs_tattach(v9p
, 0, getuid(), 0);
886 v9fs_req_wait_for_reply(req
, NULL
);
887 v9fs_rattach(req
, &root_qid
);
889 req
= v9fs_twalk(v9p
, 0, 1, 1, wnames
, 0);
890 v9fs_req_wait_for_reply(req
, NULL
);
891 v9fs_rwalk(req
, NULL
, &wqid
); /* We now we'll get one qid */
893 g_assert_cmpmem(&root_qid
, 13, wqid
[0], 13);
899 static void fs_lopen(void *obj
, void *data
, QGuestAllocator
*t_alloc
)
901 QVirtio9P
*v9p
= obj
;
903 char *const wnames
[] = { g_strdup(QTEST_V9FS_SYNTH_LOPEN_FILE
) };
907 req
= v9fs_twalk(v9p
, 0, 1, 1, wnames
, 0);
908 v9fs_req_wait_for_reply(req
, NULL
);
909 v9fs_rwalk(req
, NULL
, NULL
);
911 req
= v9fs_tlopen(v9p
, 1, O_WRONLY
, 0);
912 v9fs_req_wait_for_reply(req
, NULL
);
913 v9fs_rlopen(req
, NULL
, NULL
);
918 static void fs_write(void *obj
, void *data
, QGuestAllocator
*t_alloc
)
920 QVirtio9P
*v9p
= obj
;
922 static const uint32_t write_count
= P9_MAX_SIZE
/ 2;
923 char *const wnames
[] = { g_strdup(QTEST_V9FS_SYNTH_WRITE_FILE
) };
924 char *buf
= g_malloc0(write_count
);
929 req
= v9fs_twalk(v9p
, 0, 1, 1, wnames
, 0);
930 v9fs_req_wait_for_reply(req
, NULL
);
931 v9fs_rwalk(req
, NULL
, NULL
);
933 req
= v9fs_tlopen(v9p
, 1, O_WRONLY
, 0);
934 v9fs_req_wait_for_reply(req
, NULL
);
935 v9fs_rlopen(req
, NULL
, NULL
);
937 req
= v9fs_twrite(v9p
, 1, 0, write_count
, buf
, 0);
938 v9fs_req_wait_for_reply(req
, NULL
);
939 v9fs_rwrite(req
, &count
);
940 g_assert_cmpint(count
, ==, write_count
);
946 static void fs_flush_success(void *obj
, void *data
, QGuestAllocator
*t_alloc
)
948 QVirtio9P
*v9p
= obj
;
950 char *const wnames
[] = { g_strdup(QTEST_V9FS_SYNTH_FLUSH_FILE
) };
951 P9Req
*req
, *flush_req
;
953 uint8_t should_block
;
956 req
= v9fs_twalk(v9p
, 0, 1, 1, wnames
, 0);
957 v9fs_req_wait_for_reply(req
, NULL
);
958 v9fs_rwalk(req
, NULL
, NULL
);
960 req
= v9fs_tlopen(v9p
, 1, O_WRONLY
, 0);
961 v9fs_req_wait_for_reply(req
, NULL
);
962 v9fs_rlopen(req
, NULL
, NULL
);
964 /* This will cause the 9p server to try to write data to the backend,
965 * until the write request gets cancelled.
968 req
= v9fs_twrite(v9p
, 1, 0, sizeof(should_block
), &should_block
, 0);
970 flush_req
= v9fs_tflush(v9p
, req
->tag
, 1);
972 /* The write request is supposed to be flushed: the server should just
973 * mark the write request as used and reply to the flush request.
975 v9fs_req_wait_for_reply(req
, &reply_len
);
976 g_assert_cmpint(reply_len
, ==, 0);
978 v9fs_rflush(flush_req
);
983 static void fs_flush_ignored(void *obj
, void *data
, QGuestAllocator
*t_alloc
)
985 QVirtio9P
*v9p
= obj
;
987 char *const wnames
[] = { g_strdup(QTEST_V9FS_SYNTH_FLUSH_FILE
) };
988 P9Req
*req
, *flush_req
;
990 uint8_t should_block
;
993 req
= v9fs_twalk(v9p
, 0, 1, 1, wnames
, 0);
994 v9fs_req_wait_for_reply(req
, NULL
);
995 v9fs_rwalk(req
, NULL
, NULL
);
997 req
= v9fs_tlopen(v9p
, 1, O_WRONLY
, 0);
998 v9fs_req_wait_for_reply(req
, NULL
);
999 v9fs_rlopen(req
, NULL
, NULL
);
1001 /* This will cause the write request to complete right away, before it
1002 * could be actually cancelled.
1005 req
= v9fs_twrite(v9p
, 1, 0, sizeof(should_block
), &should_block
, 0);
1007 flush_req
= v9fs_tflush(v9p
, req
->tag
, 1);
1009 /* The write request is supposed to complete. The server should
1010 * reply to the write request and the flush request.
1012 v9fs_req_wait_for_reply(req
, NULL
);
1013 v9fs_rwrite(req
, &count
);
1014 g_assert_cmpint(count
, ==, sizeof(should_block
));
1015 v9fs_rflush(flush_req
);
1020 static void do_mkdir(QVirtio9P
*v9p
, const char *path
, const char *cname
)
1022 char *const name
= g_strdup(cname
);
1026 fid
= do_walk(v9p
, path
);
1028 req
= v9fs_tmkdir(v9p
, fid
, name
, 0750, 0, 0);
1029 v9fs_req_wait_for_reply(req
, NULL
);
1030 v9fs_rmkdir(req
, NULL
);
1035 static void do_unlinkat(QVirtio9P
*v9p
, const char *atpath
, const char *rpath
,
1038 char *const name
= g_strdup(rpath
);
1042 fid
= do_walk(v9p
, atpath
);
1044 req
= v9fs_tunlinkat(v9p
, fid
, name
, flags
, 0);
1045 v9fs_req_wait_for_reply(req
, NULL
);
1046 v9fs_runlinkat(req
);
1051 static void fs_readdir_split_128(void *obj
, void *data
,
1052 QGuestAllocator
*t_alloc
)
1055 do_readdir_split(obj
, 128);
1058 static void fs_readdir_split_256(void *obj
, void *data
,
1059 QGuestAllocator
*t_alloc
)
1062 do_readdir_split(obj
, 256);
1065 static void fs_readdir_split_512(void *obj
, void *data
,
1066 QGuestAllocator
*t_alloc
)
1069 do_readdir_split(obj
, 512);
1073 /* tests using the 9pfs 'local' fs driver */
1075 static void fs_create_dir(void *obj
, void *data
, QGuestAllocator
*t_alloc
)
1077 QVirtio9P
*v9p
= obj
;
1080 char *root_path
= virtio_9p_test_path("");
1081 char *new_dir
= virtio_9p_test_path("01");
1083 g_assert(root_path
!= NULL
);
1086 do_mkdir(v9p
, "/", "01");
1088 /* check if created directory really exists now ... */
1089 g_assert(stat(new_dir
, &st
) == 0);
1090 /* ... and is actually a directory */
1091 g_assert((st
.st_mode
& S_IFMT
) == S_IFDIR
);
1097 static void fs_unlinkat_dir(void *obj
, void *data
, QGuestAllocator
*t_alloc
)
1099 QVirtio9P
*v9p
= obj
;
1102 char *root_path
= virtio_9p_test_path("");
1103 char *new_dir
= virtio_9p_test_path("02");
1105 g_assert(root_path
!= NULL
);
1108 do_mkdir(v9p
, "/", "02");
1110 /* check if created directory really exists now ... */
1111 g_assert(stat(new_dir
, &st
) == 0);
1112 /* ... and is actually a directory */
1113 g_assert((st
.st_mode
& S_IFMT
) == S_IFDIR
);
1115 do_unlinkat(v9p
, "/", "02", AT_REMOVEDIR
);
1116 /* directory should be gone now */
1117 g_assert(stat(new_dir
, &st
) != 0);
1123 static void *assign_9p_local_driver(GString
*cmd_line
, void *arg
)
1125 virtio_9p_assign_local_driver(cmd_line
, "security_model=mapped-xattr");
1129 static void register_virtio_9p_test(void)
1132 QOSGraphTestOptions opts
= {
1135 /* 9pfs test cases using the 'synth' filesystem driver */
1136 qos_add_test("synth/config", "virtio-9p", pci_config
, &opts
);
1137 qos_add_test("synth/version/basic", "virtio-9p", fs_version
, &opts
);
1138 qos_add_test("synth/attach/basic", "virtio-9p", fs_attach
, &opts
);
1139 qos_add_test("synth/walk/basic", "virtio-9p", fs_walk
, &opts
);
1140 qos_add_test("synth/walk/no_slash", "virtio-9p", fs_walk_no_slash
,
1142 qos_add_test("synth/walk/dotdot_from_root", "virtio-9p",
1143 fs_walk_dotdot
, &opts
);
1144 qos_add_test("synth/lopen/basic", "virtio-9p", fs_lopen
, &opts
);
1145 qos_add_test("synth/write/basic", "virtio-9p", fs_write
, &opts
);
1146 qos_add_test("synth/flush/success", "virtio-9p", fs_flush_success
,
1148 qos_add_test("synth/flush/ignored", "virtio-9p", fs_flush_ignored
,
1150 qos_add_test("synth/readdir/basic", "virtio-9p", fs_readdir
, &opts
);
1151 qos_add_test("synth/readdir/split_512", "virtio-9p",
1152 fs_readdir_split_512
, &opts
);
1153 qos_add_test("synth/readdir/split_256", "virtio-9p",
1154 fs_readdir_split_256
, &opts
);
1155 qos_add_test("synth/readdir/split_128", "virtio-9p",
1156 fs_readdir_split_128
, &opts
);
1159 /* 9pfs test cases using the 'local' filesystem driver */
1160 opts
.before
= assign_9p_local_driver
;
1161 qos_add_test("local/config", "virtio-9p", pci_config
, &opts
);
1162 qos_add_test("local/create_dir", "virtio-9p", fs_create_dir
, &opts
);
1163 qos_add_test("local/unlinkat_dir", "virtio-9p", fs_unlinkat_dir
, &opts
);
1166 libqos_init(register_virtio_9p_test
);
1168 static void __attribute__((constructor
)) construct_9p_test(void)
1170 /* make sure test dir for the 'local' tests exists */
1171 virtio_9p_create_local_test_dir();
1174 static void __attribute__((destructor
)) destruct_9p_test(void)
1176 /* remove previously created test dir when test suite completed */
1177 virtio_9p_remove_local_test_dir();