#define QVIRTIO_9P_TIMEOUT_US (10 * 1000 * 1000)
static QGuestAllocator *alloc;
+/*
+ * Used to auto generate new fids. Start with arbitrary high value to avoid
+ * collision with hard coded fids in basic test code.
+ */
+static uint32_t fid_generator = 1000;
+
+static uint32_t genfid(void)
+{
+ return fid_generator++;
+}
+
+/**
+ * Splits the @a in string by @a delim into individual (non empty) strings
+ * and outputs them to @a out. The output array @a out is NULL terminated.
+ *
+ * Output array @a out must be freed by calling split_free().
+ *
+ * @returns number of individual elements in output array @a out (without the
+ * final NULL terminating element)
+ */
+static int split(const char *in, const char *delim, char ***out)
+{
+ int n = 0, i = 0;
+ char *tmp, *p;
+
+ tmp = g_strdup(in);
+ for (p = strtok(tmp, delim); p != NULL; p = strtok(NULL, delim)) {
+ if (strlen(p) > 0) {
+ ++n;
+ }
+ }
+ g_free(tmp);
+
+ *out = g_new0(char *, n + 1); /* last element NULL delimiter */
+
+ tmp = g_strdup(in);
+ for (p = strtok(tmp, delim); p != NULL; p = strtok(NULL, delim)) {
+ if (strlen(p) > 0) {
+ (*out)[i++] = g_strdup(p);
+ }
+ }
+ g_free(tmp);
+
+ return n;
+}
+
+static void split_free(char ***out)
+{
+ int i;
+ for (i = 0; (*out)[i]; ++i) {
+ g_free((*out)[i]);
+ }
+ g_free(*out);
+ *out = NULL;
+}
+
static void pci_config(void *obj, void *data, QGuestAllocator *t_alloc)
{
QVirtio9P *v9p = obj;
id == P9_RWALK ? "RWALK" :
id == P9_RLOPEN ? "RLOPEN" :
id == P9_RWRITE ? "RWRITE" :
+ id == P9_RMKDIR ? "RMKDIR" :
id == P9_RFLUSH ? "RFLUSH" :
id == P9_RREADDIR ? "READDIR" :
"<unknown>";
v9fs_req_free(req);
}
-static void fs_version(void *obj, void *data, QGuestAllocator *t_alloc)
+static void do_version(QVirtio9P *v9p)
{
- QVirtio9P *v9p = obj;
- alloc = t_alloc;
const char *version = "9P2000.L";
uint16_t server_len;
char *server_version;
g_free(server_version);
}
-static void fs_attach(void *obj, void *data, QGuestAllocator *t_alloc)
+static void fs_version(void *obj, void *data, QGuestAllocator *t_alloc)
{
- QVirtio9P *v9p = obj;
alloc = t_alloc;
+ do_version(obj);
+}
+
+static void do_attach(QVirtio9P *v9p)
+{
P9Req *req;
- fs_version(v9p, NULL, t_alloc);
+ do_version(v9p);
req = v9fs_tattach(v9p, 0, getuid(), 0);
v9fs_req_wait_for_reply(req, NULL);
v9fs_rattach(req, NULL);
}
+static void fs_attach(void *obj, void *data, QGuestAllocator *t_alloc)
+{
+ alloc = t_alloc;
+ do_attach(obj);
+}
+
static void fs_walk(void *obj, void *data, QGuestAllocator *t_alloc)
{
QVirtio9P *v9p = obj;
wnames[i] = g_strdup_printf(QTEST_V9FS_SYNTH_WALK_FILE, i);
}
- fs_attach(v9p, NULL, t_alloc);
+ do_attach(v9p);
req = v9fs_twalk(v9p, 0, 1, P9_MAXWELEM, wnames, 0);
v9fs_req_wait_for_reply(req, NULL);
v9fs_rwalk(req, &nwqid, &wqid);
return false;
}
+/* size[4] Tmkdir tag[2] dfid[4] name[s] mode[4] gid[4] */
+static P9Req *v9fs_tmkdir(QVirtio9P *v9p, uint32_t dfid, const char *name,
+ uint32_t mode, uint32_t gid, uint16_t tag)
+{
+ P9Req *req;
+
+ uint32_t body_size = 4 + 4 + 4;
+ uint16_t string_size = v9fs_string_size(name);
+
+ g_assert_cmpint(body_size, <=, UINT32_MAX - string_size);
+ body_size += string_size;
+
+ req = v9fs_req_init(v9p, body_size, P9_TMKDIR, tag);
+ v9fs_uint32_write(req, dfid);
+ v9fs_string_write(req, name);
+ v9fs_uint32_write(req, mode);
+ v9fs_uint32_write(req, gid);
+ v9fs_req_send(req);
+ return req;
+}
+
+/* size[4] Rmkdir tag[2] qid[13] */
+static void v9fs_rmkdir(P9Req *req, v9fs_qid *qid)
+{
+ v9fs_req_recv(req, P9_RMKDIR);
+ if (qid) {
+ v9fs_memread(req, qid, 13);
+ } else {
+ v9fs_memskip(req, 13);
+ }
+ v9fs_req_free(req);
+}
+
+/* basic readdir test where reply fits into a single response message */
static void fs_readdir(void *obj, void *data, QGuestAllocator *t_alloc)
{
QVirtio9P *v9p = obj;
struct V9fsDirent *entries = NULL;
P9Req *req;
- fs_attach(v9p, NULL, t_alloc);
+ do_attach(v9p);
req = v9fs_twalk(v9p, 0, 1, 1, wnames, 0);
v9fs_req_wait_for_reply(req, NULL);
v9fs_rwalk(req, &nqid, NULL);
g_free(wnames[0]);
}
+/* readdir test where overall request is split over several messages */
+static void do_readdir_split(QVirtio9P *v9p, uint32_t count)
+{
+ char *const wnames[] = { g_strdup(QTEST_V9FS_SYNTH_READDIR_DIR) };
+ uint16_t nqid;
+ v9fs_qid qid;
+ uint32_t nentries, npartialentries;
+ struct V9fsDirent *entries, *tail, *partialentries;
+ P9Req *req;
+ int fid;
+ uint64_t offset;
+
+ do_attach(v9p);
+
+ fid = 1;
+ offset = 0;
+ entries = NULL;
+ nentries = 0;
+ tail = NULL;
+
+ req = v9fs_twalk(v9p, 0, fid, 1, wnames, 0);
+ v9fs_req_wait_for_reply(req, NULL);
+ v9fs_rwalk(req, &nqid, NULL);
+ g_assert_cmpint(nqid, ==, 1);
+
+ req = v9fs_tlopen(v9p, fid, O_DIRECTORY, 0);
+ v9fs_req_wait_for_reply(req, NULL);
+ v9fs_rlopen(req, &qid, NULL);
+
+ /*
+ * send as many Treaddir requests as required to get all directory
+ * entries
+ */
+ while (true) {
+ npartialentries = 0;
+ partialentries = NULL;
+
+ req = v9fs_treaddir(v9p, fid, offset, count, 0);
+ v9fs_req_wait_for_reply(req, NULL);
+ v9fs_rreaddir(req, &count, &npartialentries, &partialentries);
+ if (npartialentries > 0 && partialentries) {
+ if (!entries) {
+ entries = partialentries;
+ nentries = npartialentries;
+ tail = partialentries;
+ } else {
+ tail->next = partialentries;
+ nentries += npartialentries;
+ }
+ while (tail->next) {
+ tail = tail->next;
+ }
+ offset = tail->offset;
+ } else {
+ break;
+ }
+ }
+
+ g_assert_cmpint(
+ nentries, ==,
+ QTEST_V9FS_SYNTH_READDIR_NFILES + 2 /* "." and ".." */
+ );
+
+ /*
+ * Check all file names exist in returned entries, ignore their order
+ * though.
+ */
+ g_assert_cmpint(fs_dirents_contain_name(entries, "."), ==, true);
+ g_assert_cmpint(fs_dirents_contain_name(entries, ".."), ==, true);
+ for (int i = 0; i < QTEST_V9FS_SYNTH_READDIR_NFILES; ++i) {
+ char *name = g_strdup_printf(QTEST_V9FS_SYNTH_READDIR_FILE, i);
+ g_assert_cmpint(fs_dirents_contain_name(entries, name), ==, true);
+ g_free(name);
+ }
+
+ v9fs_free_dirents(entries);
+
+ g_free(wnames[0]);
+}
+
static void fs_walk_no_slash(void *obj, void *data, QGuestAllocator *t_alloc)
{
QVirtio9P *v9p = obj;
P9Req *req;
uint32_t err;
- fs_attach(v9p, NULL, t_alloc);
+ do_attach(v9p);
req = v9fs_twalk(v9p, 0, 1, 1, wnames, 0);
v9fs_req_wait_for_reply(req, NULL);
v9fs_rlerror(req, &err);
v9fs_qid root_qid, *wqid;
P9Req *req;
- fs_version(v9p, NULL, t_alloc);
+ do_version(v9p);
req = v9fs_tattach(v9p, 0, getuid(), 0);
v9fs_req_wait_for_reply(req, NULL);
v9fs_rattach(req, &root_qid);
char *const wnames[] = { g_strdup(QTEST_V9FS_SYNTH_LOPEN_FILE) };
P9Req *req;
- fs_attach(v9p, NULL, t_alloc);
+ do_attach(v9p);
req = v9fs_twalk(v9p, 0, 1, 1, wnames, 0);
v9fs_req_wait_for_reply(req, NULL);
v9fs_rwalk(req, NULL, NULL);
uint32_t count;
P9Req *req;
- fs_attach(v9p, NULL, t_alloc);
+ do_attach(v9p);
req = v9fs_twalk(v9p, 0, 1, 1, wnames, 0);
v9fs_req_wait_for_reply(req, NULL);
v9fs_rwalk(req, NULL, NULL);
uint32_t reply_len;
uint8_t should_block;
- fs_attach(v9p, NULL, t_alloc);
+ do_attach(v9p);
req = v9fs_twalk(v9p, 0, 1, 1, wnames, 0);
v9fs_req_wait_for_reply(req, NULL);
v9fs_rwalk(req, NULL, NULL);
uint32_t count;
uint8_t should_block;
- fs_attach(v9p, NULL, t_alloc);
+ do_attach(v9p);
req = v9fs_twalk(v9p, 0, 1, 1, wnames, 0);
v9fs_req_wait_for_reply(req, NULL);
v9fs_rwalk(req, NULL, NULL);
g_free(wnames[0]);
}
+static void do_mkdir(QVirtio9P *v9p, const char *path, const char *cname)
+{
+ char **wnames;
+ char *const name = g_strdup(cname);
+ P9Req *req;
+ const uint32_t fid = genfid();
+
+ int nwnames = split(path, "/", &wnames);
+
+ req = v9fs_twalk(v9p, 0, fid, nwnames, wnames, 0);
+ v9fs_req_wait_for_reply(req, NULL);
+ v9fs_rwalk(req, NULL, NULL);
+
+ req = v9fs_tmkdir(v9p, fid, name, 0750, 0, 0);
+ v9fs_req_wait_for_reply(req, NULL);
+ v9fs_rmkdir(req, NULL);
+
+ g_free(name);
+ split_free(&wnames);
+}
+
+static void fs_readdir_split_128(void *obj, void *data,
+ QGuestAllocator *t_alloc)
+{
+ alloc = t_alloc;
+ do_readdir_split(obj, 128);
+}
+
+static void fs_readdir_split_256(void *obj, void *data,
+ QGuestAllocator *t_alloc)
+{
+ alloc = t_alloc;
+ do_readdir_split(obj, 256);
+}
+
+static void fs_readdir_split_512(void *obj, void *data,
+ QGuestAllocator *t_alloc)
+{
+ alloc = t_alloc;
+ do_readdir_split(obj, 512);
+}
+
+
+/* tests using the 9pfs 'local' fs driver */
+
+static void fs_create_dir(void *obj, void *data, QGuestAllocator *t_alloc)
+{
+ QVirtio9P *v9p = obj;
+ alloc = t_alloc;
+ struct stat st;
+ char *root_path = virtio_9p_test_path("");
+ char *new_dir = virtio_9p_test_path("01");
+
+ g_assert(root_path != NULL);
+
+ do_attach(v9p);
+ do_mkdir(v9p, "/", "01");
+
+ /* check if created directory really exists now ... */
+ g_assert(stat(new_dir, &st) == 0);
+ /* ... and is actually a directory */
+ g_assert((st.st_mode & S_IFMT) == S_IFDIR);
+
+ g_free(new_dir);
+ g_free(root_path);
+}
+
+static void *assign_9p_local_driver(GString *cmd_line, void *arg)
+{
+ virtio_9p_assign_local_driver(cmd_line, "security_model=mapped-xattr");
+ return arg;
+}
+
static void register_virtio_9p_test(void)
{
- qos_add_test("config", "virtio-9p", pci_config, NULL);
- qos_add_test("fs/version/basic", "virtio-9p", fs_version, NULL);
- qos_add_test("fs/attach/basic", "virtio-9p", fs_attach, NULL);
- qos_add_test("fs/walk/basic", "virtio-9p", fs_walk, NULL);
- qos_add_test("fs/walk/no_slash", "virtio-9p", fs_walk_no_slash,
- NULL);
- qos_add_test("fs/walk/dotdot_from_root", "virtio-9p",
- fs_walk_dotdot, NULL);
- qos_add_test("fs/lopen/basic", "virtio-9p", fs_lopen, NULL);
- qos_add_test("fs/write/basic", "virtio-9p", fs_write, NULL);
- qos_add_test("fs/flush/success", "virtio-9p", fs_flush_success,
- NULL);
- qos_add_test("fs/flush/ignored", "virtio-9p", fs_flush_ignored,
- NULL);
- qos_add_test("fs/readdir/basic", "virtio-9p", fs_readdir, NULL);
+
+ QOSGraphTestOptions opts = {
+ };
+
+ /* 9pfs test cases using the 'synth' filesystem driver */
+ qos_add_test("synth/config", "virtio-9p", pci_config, &opts);
+ qos_add_test("synth/version/basic", "virtio-9p", fs_version, &opts);
+ qos_add_test("synth/attach/basic", "virtio-9p", fs_attach, &opts);
+ qos_add_test("synth/walk/basic", "virtio-9p", fs_walk, &opts);
+ qos_add_test("synth/walk/no_slash", "virtio-9p", fs_walk_no_slash,
+ &opts);
+ qos_add_test("synth/walk/dotdot_from_root", "virtio-9p",
+ fs_walk_dotdot, &opts);
+ qos_add_test("synth/lopen/basic", "virtio-9p", fs_lopen, &opts);
+ qos_add_test("synth/write/basic", "virtio-9p", fs_write, &opts);
+ qos_add_test("synth/flush/success", "virtio-9p", fs_flush_success,
+ &opts);
+ qos_add_test("synth/flush/ignored", "virtio-9p", fs_flush_ignored,
+ &opts);
+ qos_add_test("synth/readdir/basic", "virtio-9p", fs_readdir, &opts);
+ qos_add_test("synth/readdir/split_512", "virtio-9p",
+ fs_readdir_split_512, &opts);
+ qos_add_test("synth/readdir/split_256", "virtio-9p",
+ fs_readdir_split_256, &opts);
+ qos_add_test("synth/readdir/split_128", "virtio-9p",
+ fs_readdir_split_128, &opts);
+
+
+ /* 9pfs test cases using the 'local' filesystem driver */
+ opts.before = assign_9p_local_driver;
+ qos_add_test("local/config", "virtio-9p", pci_config, &opts);
+ qos_add_test("local/create_dir", "virtio-9p", fs_create_dir, &opts);
}
libqos_init(register_virtio_9p_test);
+
+static void __attribute__((constructor)) construct_9p_test(void)
+{
+ /* make sure test dir for the 'local' tests exists */
+ virtio_9p_create_local_test_dir();
+}
+
+static void __attribute__((destructor)) destruct_9p_test(void)
+{
+ /* remove previously created test dir when test suite completed */
+ virtio_9p_remove_local_test_dir();
+}
projects / mirror_qemu.git / blobdiff