1 /* 2 * QTest testcase for VirtIO 9P 3 * 4 * Copyright (c) 2014 SUSE LINUX Products GmbH 5 * 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. 8 */ 9 10 /* 11 * Not so fast! You might want to read the 9p developer docs first: 12 * https://wiki.qemu.org/Documentation/9p 13 */ 14 15 #include "qemu/osdep.h" 16 #include "qemu/module.h" 17 #include "libqos/virtio-9p-client.h" 18 19 #define twalk(...) v9fs_twalk((TWalkOpt) __VA_ARGS__) 20 #define tversion(...) v9fs_tversion((TVersionOpt) __VA_ARGS__) 21 #define tattach(...) v9fs_tattach((TAttachOpt) __VA_ARGS__) 22 #define tgetattr(...) v9fs_tgetattr((TGetAttrOpt) __VA_ARGS__) 23 24 static void pci_config(void *obj, void *data, QGuestAllocator *t_alloc) 25 { 26 QVirtio9P *v9p = obj; 27 v9fs_set_allocator(t_alloc); 28 size_t tag_len = qvirtio_config_readw(v9p->vdev, 0); 29 g_autofree char *tag = NULL; 30 int i; 31 32 g_assert_cmpint(tag_len, ==, strlen(MOUNT_TAG)); 33 34 tag = g_malloc(tag_len); 35 for (i = 0; i < tag_len; i++) { 36 tag[i] = qvirtio_config_readb(v9p->vdev, i + 2); 37 } 38 g_assert_cmpmem(tag, tag_len, MOUNT_TAG, tag_len); 39 } 40 41 static inline bool is_same_qid(v9fs_qid a, v9fs_qid b) 42 { 43 /* don't compare QID version for checking for file ID equalness */ 44 return a[0] == b[0] && memcmp(&a[5], &b[5], 8) == 0; 45 } 46 47 static void fs_version(void *obj, void *data, QGuestAllocator *t_alloc) 48 { 49 v9fs_set_allocator(t_alloc); 50 tversion({ .client = obj }); 51 } 52 53 static void fs_attach(void *obj, void *data, QGuestAllocator *t_alloc) 54 { 55 v9fs_set_allocator(t_alloc); 56 tattach({ .client = obj }); 57 } 58 59 static void fs_walk(void *obj, void *data, QGuestAllocator *t_alloc) 60 { 61 QVirtio9P *v9p = obj; 62 v9fs_set_allocator(t_alloc); 63 char *wnames[P9_MAXWELEM]; 64 uint16_t nwqid; 65 g_autofree v9fs_qid *wqid = NULL; 66 int i; 67 68 for (i = 0; i < P9_MAXWELEM; i++) { 69 wnames[i] = g_strdup_printf(QTEST_V9FS_SYNTH_WALK_FILE, i); 70 } 71 72 tattach({ .client = v9p }); 73 twalk({ 74 .client = v9p, .fid = 0, .newfid = 1, 75 .nwname = P9_MAXWELEM, .wnames = wnames, 76 .rwalk = { .nwqid = &nwqid, .wqid = &wqid } 77 }); 78 79 g_assert_cmpint(nwqid, ==, P9_MAXWELEM); 80 81 for (i = 0; i < P9_MAXWELEM; i++) { 82 g_free(wnames[i]); 83 } 84 } 85 86 static bool fs_dirents_contain_name(struct V9fsDirent *e, const char* name) 87 { 88 for (; e; e = e->next) { 89 if (!strcmp(e->name, name)) { 90 return true; 91 } 92 } 93 return false; 94 } 95 96 /* basic readdir test where reply fits into a single response message */ 97 static void fs_readdir(void *obj, void *data, QGuestAllocator *t_alloc) 98 { 99 QVirtio9P *v9p = obj; 100 v9fs_set_allocator(t_alloc); 101 char *wnames[] = { g_strdup(QTEST_V9FS_SYNTH_READDIR_DIR) }; 102 uint16_t nqid; 103 v9fs_qid qid; 104 uint32_t count, nentries; 105 struct V9fsDirent *entries = NULL; 106 P9Req *req; 107 108 tattach({ .client = v9p }); 109 twalk({ 110 .client = v9p, .fid = 0, .newfid = 1, 111 .nwname = 1, .wnames = wnames, .rwalk.nwqid = &nqid 112 }); 113 g_assert_cmpint(nqid, ==, 1); 114 115 req = v9fs_tlopen(v9p, 1, O_DIRECTORY, 0); 116 v9fs_req_wait_for_reply(req, NULL); 117 v9fs_rlopen(req, &qid, NULL); 118 119 /* 120 * submit count = msize - 11, because 11 is the header size of Rreaddir 121 */ 122 req = v9fs_treaddir(v9p, 1, 0, P9_MAX_SIZE - 11, 0); 123 v9fs_req_wait_for_reply(req, NULL); 124 v9fs_rreaddir(req, &count, &nentries, &entries); 125 126 /* 127 * Assuming msize (P9_MAX_SIZE) is large enough so we can retrieve all 128 * dir entries with only one readdir request. 129 */ 130 g_assert_cmpint( 131 nentries, ==, 132 QTEST_V9FS_SYNTH_READDIR_NFILES + 2 /* "." and ".." */ 133 ); 134 135 /* 136 * Check all file names exist in returned entries, ignore their order 137 * though. 138 */ 139 g_assert_cmpint(fs_dirents_contain_name(entries, "."), ==, true); 140 g_assert_cmpint(fs_dirents_contain_name(entries, ".."), ==, true); 141 for (int i = 0; i < QTEST_V9FS_SYNTH_READDIR_NFILES; ++i) { 142 g_autofree char *name = 143 g_strdup_printf(QTEST_V9FS_SYNTH_READDIR_FILE, i); 144 g_assert_cmpint(fs_dirents_contain_name(entries, name), ==, true); 145 } 146 147 v9fs_free_dirents(entries); 148 g_free(wnames[0]); 149 } 150 151 /* readdir test where overall request is split over several messages */ 152 static void do_readdir_split(QVirtio9P *v9p, uint32_t count) 153 { 154 char *wnames[] = { g_strdup(QTEST_V9FS_SYNTH_READDIR_DIR) }; 155 uint16_t nqid; 156 v9fs_qid qid; 157 uint32_t nentries, npartialentries; 158 struct V9fsDirent *entries, *tail, *partialentries; 159 P9Req *req; 160 int fid; 161 uint64_t offset; 162 163 tattach({ .client = v9p }); 164 165 fid = 1; 166 offset = 0; 167 entries = NULL; 168 nentries = 0; 169 tail = NULL; 170 171 twalk({ 172 .client = v9p, .fid = 0, .newfid = fid, 173 .nwname = 1, .wnames = wnames, .rwalk.nwqid = &nqid 174 }); 175 g_assert_cmpint(nqid, ==, 1); 176 177 req = v9fs_tlopen(v9p, fid, O_DIRECTORY, 0); 178 v9fs_req_wait_for_reply(req, NULL); 179 v9fs_rlopen(req, &qid, NULL); 180 181 /* 182 * send as many Treaddir requests as required to get all directory 183 * entries 184 */ 185 while (true) { 186 npartialentries = 0; 187 partialentries = NULL; 188 189 req = v9fs_treaddir(v9p, fid, offset, count, 0); 190 v9fs_req_wait_for_reply(req, NULL); 191 v9fs_rreaddir(req, &count, &npartialentries, &partialentries); 192 if (npartialentries > 0 && partialentries) { 193 if (!entries) { 194 entries = partialentries; 195 nentries = npartialentries; 196 tail = partialentries; 197 } else { 198 tail->next = partialentries; 199 nentries += npartialentries; 200 } 201 while (tail->next) { 202 tail = tail->next; 203 } 204 offset = tail->offset; 205 } else { 206 break; 207 } 208 } 209 210 g_assert_cmpint( 211 nentries, ==, 212 QTEST_V9FS_SYNTH_READDIR_NFILES + 2 /* "." and ".." */ 213 ); 214 215 /* 216 * Check all file names exist in returned entries, ignore their order 217 * though. 218 */ 219 g_assert_cmpint(fs_dirents_contain_name(entries, "."), ==, true); 220 g_assert_cmpint(fs_dirents_contain_name(entries, ".."), ==, true); 221 for (int i = 0; i < QTEST_V9FS_SYNTH_READDIR_NFILES; ++i) { 222 char *name = g_strdup_printf(QTEST_V9FS_SYNTH_READDIR_FILE, i); 223 g_assert_cmpint(fs_dirents_contain_name(entries, name), ==, true); 224 g_free(name); 225 } 226 227 v9fs_free_dirents(entries); 228 229 g_free(wnames[0]); 230 } 231 232 static void fs_walk_no_slash(void *obj, void *data, QGuestAllocator *t_alloc) 233 { 234 QVirtio9P *v9p = obj; 235 v9fs_set_allocator(t_alloc); 236 char *wnames[] = { g_strdup(" /") }; 237 238 tattach({ .client = v9p }); 239 twalk({ 240 .client = v9p, .fid = 0, .newfid = 1, .nwname = 1, .wnames = wnames, 241 .expectErr = ENOENT 242 }); 243 244 g_free(wnames[0]); 245 } 246 247 static void fs_walk_nonexistent(void *obj, void *data, QGuestAllocator *t_alloc) 248 { 249 QVirtio9P *v9p = obj; 250 v9fs_set_allocator(t_alloc); 251 252 tattach({ .client = v9p }); 253 /* 254 * The 9p2000 protocol spec says: "If the first element cannot be walked 255 * for any reason, Rerror is returned." 256 */ 257 twalk({ .client = v9p, .path = "non-existent", .expectErr = ENOENT }); 258 } 259 260 static void fs_walk_2nd_nonexistent(void *obj, void *data, 261 QGuestAllocator *t_alloc) 262 { 263 QVirtio9P *v9p = obj; 264 v9fs_set_allocator(t_alloc); 265 v9fs_qid root_qid; 266 uint16_t nwqid; 267 uint32_t fid; 268 g_autofree v9fs_qid *wqid = NULL; 269 g_autofree char *path = g_strdup_printf( 270 QTEST_V9FS_SYNTH_WALK_FILE "/non-existent", 0 271 ); 272 273 tattach({ .client = v9p, .rattach.qid = &root_qid }); 274 fid = twalk({ 275 .client = v9p, .path = path, 276 .rwalk = { .nwqid = &nwqid, .wqid = &wqid } 277 }).newfid; 278 /* 279 * The 9p2000 protocol spec says: "nwqid is therefore either nwname or the 280 * index of the first elementwise walk that failed." 281 */ 282 assert(nwqid == 1); 283 284 /* returned QID wqid[0] is file ID of 1st subdir */ 285 g_assert(wqid && wqid[0] && !is_same_qid(root_qid, wqid[0])); 286 287 /* expect fid being unaffected by walk above */ 288 tgetattr({ 289 .client = v9p, .fid = fid, .request_mask = P9_GETATTR_BASIC, 290 .expectErr = ENOENT 291 }); 292 } 293 294 static void fs_walk_none(void *obj, void *data, QGuestAllocator *t_alloc) 295 { 296 QVirtio9P *v9p = obj; 297 v9fs_set_allocator(t_alloc); 298 v9fs_qid root_qid; 299 g_autofree v9fs_qid *wqid = NULL; 300 struct v9fs_attr attr; 301 302 tversion({ .client = v9p }); 303 tattach({ 304 .client = v9p, .fid = 0, .n_uname = getuid(), 305 .rattach.qid = &root_qid 306 }); 307 308 twalk({ 309 .client = v9p, .fid = 0, .newfid = 1, .nwname = 0, .wnames = NULL, 310 .rwalk.wqid = &wqid 311 }); 312 313 /* special case: no QID is returned if nwname=0 was sent */ 314 g_assert(wqid == NULL); 315 316 tgetattr({ 317 .client = v9p, .fid = 1, .request_mask = P9_GETATTR_BASIC, 318 .rgetattr.attr = &attr 319 }); 320 321 g_assert(is_same_qid(root_qid, attr.qid)); 322 } 323 324 static void fs_walk_dotdot(void *obj, void *data, QGuestAllocator *t_alloc) 325 { 326 QVirtio9P *v9p = obj; 327 v9fs_set_allocator(t_alloc); 328 char *wnames[] = { g_strdup("..") }; 329 v9fs_qid root_qid; 330 g_autofree v9fs_qid *wqid = NULL; 331 332 tversion({ .client = v9p }); 333 tattach({ 334 .client = v9p, .fid = 0, .n_uname = getuid(), 335 .rattach.qid = &root_qid 336 }); 337 338 twalk({ 339 .client = v9p, .fid = 0, .newfid = 1, .nwname = 1, .wnames = wnames, 340 .rwalk.wqid = &wqid /* We now we'll get one qid */ 341 }); 342 343 g_assert_cmpmem(&root_qid, 13, wqid[0], 13); 344 345 g_free(wnames[0]); 346 } 347 348 static void fs_lopen(void *obj, void *data, QGuestAllocator *t_alloc) 349 { 350 QVirtio9P *v9p = obj; 351 v9fs_set_allocator(t_alloc); 352 char *wnames[] = { g_strdup(QTEST_V9FS_SYNTH_LOPEN_FILE) }; 353 P9Req *req; 354 355 tattach({ .client = v9p }); 356 twalk({ 357 .client = v9p, .fid = 0, .newfid = 1, .nwname = 1, .wnames = wnames 358 }); 359 360 req = v9fs_tlopen(v9p, 1, O_WRONLY, 0); 361 v9fs_req_wait_for_reply(req, NULL); 362 v9fs_rlopen(req, NULL, NULL); 363 364 g_free(wnames[0]); 365 } 366 367 static void fs_write(void *obj, void *data, QGuestAllocator *t_alloc) 368 { 369 QVirtio9P *v9p = obj; 370 v9fs_set_allocator(t_alloc); 371 static const uint32_t write_count = P9_MAX_SIZE / 2; 372 char *wnames[] = { g_strdup(QTEST_V9FS_SYNTH_WRITE_FILE) }; 373 g_autofree char *buf = g_malloc0(write_count); 374 uint32_t count; 375 P9Req *req; 376 377 tattach({ .client = v9p }); 378 twalk({ 379 .client = v9p, .fid = 0, .newfid = 1, .nwname = 1, .wnames = wnames 380 }); 381 382 req = v9fs_tlopen(v9p, 1, O_WRONLY, 0); 383 v9fs_req_wait_for_reply(req, NULL); 384 v9fs_rlopen(req, NULL, NULL); 385 386 req = v9fs_twrite(v9p, 1, 0, write_count, buf, 0); 387 v9fs_req_wait_for_reply(req, NULL); 388 v9fs_rwrite(req, &count); 389 g_assert_cmpint(count, ==, write_count); 390 391 g_free(wnames[0]); 392 } 393 394 static void fs_flush_success(void *obj, void *data, QGuestAllocator *t_alloc) 395 { 396 QVirtio9P *v9p = obj; 397 v9fs_set_allocator(t_alloc); 398 char *wnames[] = { g_strdup(QTEST_V9FS_SYNTH_FLUSH_FILE) }; 399 P9Req *req, *flush_req; 400 uint32_t reply_len; 401 uint8_t should_block; 402 403 tattach({ .client = v9p }); 404 twalk({ 405 .client = v9p, .fid = 0, .newfid = 1, .nwname = 1, .wnames = wnames 406 }); 407 408 req = v9fs_tlopen(v9p, 1, O_WRONLY, 0); 409 v9fs_req_wait_for_reply(req, NULL); 410 v9fs_rlopen(req, NULL, NULL); 411 412 /* This will cause the 9p server to try to write data to the backend, 413 * until the write request gets cancelled. 414 */ 415 should_block = 1; 416 req = v9fs_twrite(v9p, 1, 0, sizeof(should_block), &should_block, 0); 417 418 flush_req = v9fs_tflush(v9p, req->tag, 1); 419 420 /* The write request is supposed to be flushed: the server should just 421 * mark the write request as used and reply to the flush request. 422 */ 423 v9fs_req_wait_for_reply(req, &reply_len); 424 g_assert_cmpint(reply_len, ==, 0); 425 v9fs_req_free(req); 426 v9fs_rflush(flush_req); 427 428 g_free(wnames[0]); 429 } 430 431 static void fs_flush_ignored(void *obj, void *data, QGuestAllocator *t_alloc) 432 { 433 QVirtio9P *v9p = obj; 434 v9fs_set_allocator(t_alloc); 435 char *wnames[] = { g_strdup(QTEST_V9FS_SYNTH_FLUSH_FILE) }; 436 P9Req *req, *flush_req; 437 uint32_t count; 438 uint8_t should_block; 439 440 tattach({ .client = v9p }); 441 twalk({ 442 .client = v9p, .fid = 0, .newfid = 1, .nwname = 1, .wnames = wnames 443 }); 444 445 req = v9fs_tlopen(v9p, 1, O_WRONLY, 0); 446 v9fs_req_wait_for_reply(req, NULL); 447 v9fs_rlopen(req, NULL, NULL); 448 449 /* This will cause the write request to complete right away, before it 450 * could be actually cancelled. 451 */ 452 should_block = 0; 453 req = v9fs_twrite(v9p, 1, 0, sizeof(should_block), &should_block, 0); 454 455 flush_req = v9fs_tflush(v9p, req->tag, 1); 456 457 /* The write request is supposed to complete. The server should 458 * reply to the write request and the flush request. 459 */ 460 v9fs_req_wait_for_reply(req, NULL); 461 v9fs_rwrite(req, &count); 462 g_assert_cmpint(count, ==, sizeof(should_block)); 463 v9fs_rflush(flush_req); 464 465 g_free(wnames[0]); 466 } 467 468 static void do_mkdir(QVirtio9P *v9p, const char *path, const char *cname) 469 { 470 g_autofree char *name = g_strdup(cname); 471 uint32_t fid; 472 P9Req *req; 473 474 fid = twalk({ .client = v9p, .path = path }).newfid; 475 476 req = v9fs_tmkdir(v9p, fid, name, 0750, 0, 0); 477 v9fs_req_wait_for_reply(req, NULL); 478 v9fs_rmkdir(req, NULL); 479 } 480 481 /* create a regular file with Tlcreate and return file's fid */ 482 static uint32_t do_lcreate(QVirtio9P *v9p, const char *path, 483 const char *cname) 484 { 485 g_autofree char *name = g_strdup(cname); 486 uint32_t fid; 487 P9Req *req; 488 489 fid = twalk({ .client = v9p, .path = path }).newfid; 490 491 req = v9fs_tlcreate(v9p, fid, name, 0, 0750, 0, 0); 492 v9fs_req_wait_for_reply(req, NULL); 493 v9fs_rlcreate(req, NULL, NULL); 494 495 return fid; 496 } 497 498 /* create symlink named @a clink in directory @a path pointing to @a to */ 499 static void do_symlink(QVirtio9P *v9p, const char *path, const char *clink, 500 const char *to) 501 { 502 g_autofree char *name = g_strdup(clink); 503 g_autofree char *dst = g_strdup(to); 504 uint32_t fid; 505 P9Req *req; 506 507 fid = twalk({ .client = v9p, .path = path }).newfid; 508 509 req = v9fs_tsymlink(v9p, fid, name, dst, 0, 0); 510 v9fs_req_wait_for_reply(req, NULL); 511 v9fs_rsymlink(req, NULL); 512 } 513 514 /* create a hard link named @a clink in directory @a path pointing to @a to */ 515 static void do_hardlink(QVirtio9P *v9p, const char *path, const char *clink, 516 const char *to) 517 { 518 uint32_t dfid, fid; 519 P9Req *req; 520 521 dfid = twalk({ .client = v9p, .path = path }).newfid; 522 fid = twalk({ .client = v9p, .path = to }).newfid; 523 524 req = v9fs_tlink(v9p, dfid, fid, clink, 0); 525 v9fs_req_wait_for_reply(req, NULL); 526 v9fs_rlink(req); 527 } 528 529 static void do_unlinkat(QVirtio9P *v9p, const char *atpath, const char *rpath, 530 uint32_t flags) 531 { 532 g_autofree char *name = g_strdup(rpath); 533 uint32_t fid; 534 P9Req *req; 535 536 fid = twalk({ .client = v9p, .path = atpath }).newfid; 537 538 req = v9fs_tunlinkat(v9p, fid, name, flags, 0); 539 v9fs_req_wait_for_reply(req, NULL); 540 v9fs_runlinkat(req); 541 } 542 543 static void fs_readdir_split_128(void *obj, void *data, 544 QGuestAllocator *t_alloc) 545 { 546 v9fs_set_allocator(t_alloc); 547 do_readdir_split(obj, 128); 548 } 549 550 static void fs_readdir_split_256(void *obj, void *data, 551 QGuestAllocator *t_alloc) 552 { 553 v9fs_set_allocator(t_alloc); 554 do_readdir_split(obj, 256); 555 } 556 557 static void fs_readdir_split_512(void *obj, void *data, 558 QGuestAllocator *t_alloc) 559 { 560 v9fs_set_allocator(t_alloc); 561 do_readdir_split(obj, 512); 562 } 563 564 565 /* tests using the 9pfs 'local' fs driver */ 566 567 static void fs_create_dir(void *obj, void *data, QGuestAllocator *t_alloc) 568 { 569 QVirtio9P *v9p = obj; 570 v9fs_set_allocator(t_alloc); 571 struct stat st; 572 g_autofree char *root_path = virtio_9p_test_path(""); 573 g_autofree char *new_dir = virtio_9p_test_path("01"); 574 575 g_assert(root_path != NULL); 576 577 tattach({ .client = v9p }); 578 do_mkdir(v9p, "/", "01"); 579 580 /* check if created directory really exists now ... */ 581 g_assert(stat(new_dir, &st) == 0); 582 /* ... and is actually a directory */ 583 g_assert((st.st_mode & S_IFMT) == S_IFDIR); 584 } 585 586 static void fs_unlinkat_dir(void *obj, void *data, QGuestAllocator *t_alloc) 587 { 588 QVirtio9P *v9p = obj; 589 v9fs_set_allocator(t_alloc); 590 struct stat st; 591 g_autofree char *root_path = virtio_9p_test_path(""); 592 g_autofree char *new_dir = virtio_9p_test_path("02"); 593 594 g_assert(root_path != NULL); 595 596 tattach({ .client = v9p }); 597 do_mkdir(v9p, "/", "02"); 598 599 /* check if created directory really exists now ... */ 600 g_assert(stat(new_dir, &st) == 0); 601 /* ... and is actually a directory */ 602 g_assert((st.st_mode & S_IFMT) == S_IFDIR); 603 604 do_unlinkat(v9p, "/", "02", P9_DOTL_AT_REMOVEDIR); 605 /* directory should be gone now */ 606 g_assert(stat(new_dir, &st) != 0); 607 } 608 609 static void fs_create_file(void *obj, void *data, QGuestAllocator *t_alloc) 610 { 611 QVirtio9P *v9p = obj; 612 v9fs_set_allocator(t_alloc); 613 struct stat st; 614 g_autofree char *new_file = virtio_9p_test_path("03/1st_file"); 615 616 tattach({ .client = v9p }); 617 do_mkdir(v9p, "/", "03"); 618 do_lcreate(v9p, "03", "1st_file"); 619 620 /* check if created file exists now ... */ 621 g_assert(stat(new_file, &st) == 0); 622 /* ... and is a regular file */ 623 g_assert((st.st_mode & S_IFMT) == S_IFREG); 624 } 625 626 static void fs_unlinkat_file(void *obj, void *data, QGuestAllocator *t_alloc) 627 { 628 QVirtio9P *v9p = obj; 629 v9fs_set_allocator(t_alloc); 630 struct stat st; 631 g_autofree char *new_file = virtio_9p_test_path("04/doa_file"); 632 633 tattach({ .client = v9p }); 634 do_mkdir(v9p, "/", "04"); 635 do_lcreate(v9p, "04", "doa_file"); 636 637 /* check if created file exists now ... */ 638 g_assert(stat(new_file, &st) == 0); 639 /* ... and is a regular file */ 640 g_assert((st.st_mode & S_IFMT) == S_IFREG); 641 642 do_unlinkat(v9p, "04", "doa_file", 0); 643 /* file should be gone now */ 644 g_assert(stat(new_file, &st) != 0); 645 } 646 647 static void fs_symlink_file(void *obj, void *data, QGuestAllocator *t_alloc) 648 { 649 QVirtio9P *v9p = obj; 650 v9fs_set_allocator(t_alloc); 651 struct stat st; 652 g_autofree char *real_file = virtio_9p_test_path("05/real_file"); 653 g_autofree char *symlink_file = virtio_9p_test_path("05/symlink_file"); 654 655 tattach({ .client = v9p }); 656 do_mkdir(v9p, "/", "05"); 657 do_lcreate(v9p, "05", "real_file"); 658 g_assert(stat(real_file, &st) == 0); 659 g_assert((st.st_mode & S_IFMT) == S_IFREG); 660 661 do_symlink(v9p, "05", "symlink_file", "real_file"); 662 663 /* check if created link exists now */ 664 g_assert(stat(symlink_file, &st) == 0); 665 } 666 667 static void fs_unlinkat_symlink(void *obj, void *data, 668 QGuestAllocator *t_alloc) 669 { 670 QVirtio9P *v9p = obj; 671 v9fs_set_allocator(t_alloc); 672 struct stat st; 673 g_autofree char *real_file = virtio_9p_test_path("06/real_file"); 674 g_autofree char *symlink_file = virtio_9p_test_path("06/symlink_file"); 675 676 tattach({ .client = v9p }); 677 do_mkdir(v9p, "/", "06"); 678 do_lcreate(v9p, "06", "real_file"); 679 g_assert(stat(real_file, &st) == 0); 680 g_assert((st.st_mode & S_IFMT) == S_IFREG); 681 682 do_symlink(v9p, "06", "symlink_file", "real_file"); 683 g_assert(stat(symlink_file, &st) == 0); 684 685 do_unlinkat(v9p, "06", "symlink_file", 0); 686 /* symlink should be gone now */ 687 g_assert(stat(symlink_file, &st) != 0); 688 } 689 690 static void fs_hardlink_file(void *obj, void *data, QGuestAllocator *t_alloc) 691 { 692 QVirtio9P *v9p = obj; 693 v9fs_set_allocator(t_alloc); 694 struct stat st_real, st_link; 695 g_autofree char *real_file = virtio_9p_test_path("07/real_file"); 696 g_autofree char *hardlink_file = virtio_9p_test_path("07/hardlink_file"); 697 698 tattach({ .client = v9p }); 699 do_mkdir(v9p, "/", "07"); 700 do_lcreate(v9p, "07", "real_file"); 701 g_assert(stat(real_file, &st_real) == 0); 702 g_assert((st_real.st_mode & S_IFMT) == S_IFREG); 703 704 do_hardlink(v9p, "07", "hardlink_file", "07/real_file"); 705 706 /* check if link exists now ... */ 707 g_assert(stat(hardlink_file, &st_link) == 0); 708 /* ... and it's a hard link, right? */ 709 g_assert((st_link.st_mode & S_IFMT) == S_IFREG); 710 g_assert(st_link.st_dev == st_real.st_dev); 711 g_assert(st_link.st_ino == st_real.st_ino); 712 } 713 714 static void fs_unlinkat_hardlink(void *obj, void *data, 715 QGuestAllocator *t_alloc) 716 { 717 QVirtio9P *v9p = obj; 718 v9fs_set_allocator(t_alloc); 719 struct stat st_real, st_link; 720 g_autofree char *real_file = virtio_9p_test_path("08/real_file"); 721 g_autofree char *hardlink_file = virtio_9p_test_path("08/hardlink_file"); 722 723 tattach({ .client = v9p }); 724 do_mkdir(v9p, "/", "08"); 725 do_lcreate(v9p, "08", "real_file"); 726 g_assert(stat(real_file, &st_real) == 0); 727 g_assert((st_real.st_mode & S_IFMT) == S_IFREG); 728 729 do_hardlink(v9p, "08", "hardlink_file", "08/real_file"); 730 g_assert(stat(hardlink_file, &st_link) == 0); 731 732 do_unlinkat(v9p, "08", "hardlink_file", 0); 733 /* symlink should be gone now */ 734 g_assert(stat(hardlink_file, &st_link) != 0); 735 /* and old file should still exist */ 736 g_assert(stat(real_file, &st_real) == 0); 737 } 738 739 static void *assign_9p_local_driver(GString *cmd_line, void *arg) 740 { 741 virtio_9p_assign_local_driver(cmd_line, "security_model=mapped-xattr"); 742 return arg; 743 } 744 745 static void register_virtio_9p_test(void) 746 { 747 748 QOSGraphTestOptions opts = { 749 }; 750 751 /* 9pfs test cases using the 'synth' filesystem driver */ 752 qos_add_test("synth/config", "virtio-9p", pci_config, &opts); 753 qos_add_test("synth/version/basic", "virtio-9p", fs_version, &opts); 754 qos_add_test("synth/attach/basic", "virtio-9p", fs_attach, &opts); 755 qos_add_test("synth/walk/basic", "virtio-9p", fs_walk, &opts); 756 qos_add_test("synth/walk/no_slash", "virtio-9p", fs_walk_no_slash, 757 &opts); 758 qos_add_test("synth/walk/none", "virtio-9p", fs_walk_none, &opts); 759 qos_add_test("synth/walk/dotdot_from_root", "virtio-9p", 760 fs_walk_dotdot, &opts); 761 qos_add_test("synth/walk/non_existent", "virtio-9p", fs_walk_nonexistent, 762 &opts); 763 qos_add_test("synth/walk/2nd_non_existent", "virtio-9p", 764 fs_walk_2nd_nonexistent, &opts); 765 qos_add_test("synth/lopen/basic", "virtio-9p", fs_lopen, &opts); 766 qos_add_test("synth/write/basic", "virtio-9p", fs_write, &opts); 767 qos_add_test("synth/flush/success", "virtio-9p", fs_flush_success, 768 &opts); 769 qos_add_test("synth/flush/ignored", "virtio-9p", fs_flush_ignored, 770 &opts); 771 qos_add_test("synth/readdir/basic", "virtio-9p", fs_readdir, &opts); 772 qos_add_test("synth/readdir/split_512", "virtio-9p", 773 fs_readdir_split_512, &opts); 774 qos_add_test("synth/readdir/split_256", "virtio-9p", 775 fs_readdir_split_256, &opts); 776 qos_add_test("synth/readdir/split_128", "virtio-9p", 777 fs_readdir_split_128, &opts); 778 779 780 /* 9pfs test cases using the 'local' filesystem driver */ 781 782 /* 783 * XXX: Until we are sure that these tests can run everywhere, 784 * keep them as "slow" so that they aren't run with "make check". 785 */ 786 if (!g_test_slow()) { 787 return; 788 } 789 790 opts.before = assign_9p_local_driver; 791 qos_add_test("local/config", "virtio-9p", pci_config, &opts); 792 qos_add_test("local/create_dir", "virtio-9p", fs_create_dir, &opts); 793 qos_add_test("local/unlinkat_dir", "virtio-9p", fs_unlinkat_dir, &opts); 794 qos_add_test("local/create_file", "virtio-9p", fs_create_file, &opts); 795 qos_add_test("local/unlinkat_file", "virtio-9p", fs_unlinkat_file, &opts); 796 qos_add_test("local/symlink_file", "virtio-9p", fs_symlink_file, &opts); 797 qos_add_test("local/unlinkat_symlink", "virtio-9p", fs_unlinkat_symlink, 798 &opts); 799 qos_add_test("local/hardlink_file", "virtio-9p", fs_hardlink_file, &opts); 800 qos_add_test("local/unlinkat_hardlink", "virtio-9p", fs_unlinkat_hardlink, 801 &opts); 802 } 803 804 libqos_init(register_virtio_9p_test); 805 806 static void __attribute__((constructor)) construct_9p_test(void) 807 { 808 /* make sure test dir for the 'local' tests exists */ 809 virtio_9p_create_local_test_dir(); 810 } 811 812 static void __attribute__((destructor)) destruct_9p_test(void) 813 { 814 /* remove previously created test dir when test suite completed */ 815 virtio_9p_remove_local_test_dir(); 816 } 817