1 /* 2 * CDDL HEADER START 3 * 4 * This file and its contents are supplied under the terms of the 5 * Common Development and Distribution License ("CDDL"), version 1.0. 6 * You may only use this file in accordance with the terms of version 7 * 1.0 of the CDDL. 8 * 9 * A full copy of the text of the CDDL should have accompanied this 10 * source. A copy of the CDDL is also available via the Internet at 11 * http://www.illumos.org/license/CDDL. 12 * 13 * CDDL HEADER END 14 */ 15 16 /* 17 * Copyright (c) 2018 by Delphix. All rights reserved. 18 */ 19 20 #include <stdio.h> 21 #include <stdlib.h> 22 #include <string.h> 23 #include <libzfs_core.h> 24 #include <libzutil.h> 25 26 #include <sys/nvpair.h> 27 #include <sys/vdev_impl.h> 28 #include <sys/zfs_ioctl.h> 29 #include <sys/zfs_bootenv.h> 30 #include <sys/fs/zfs.h> 31 32 /* 33 * Test the nvpair inputs for the non-legacy zfs ioctl commands. 34 */ 35 36 static boolean_t unexpected_failures; 37 static int zfs_fd; 38 static const char *active_test; 39 40 /* 41 * Tracks which zfs_ioc_t commands were tested 42 */ 43 static boolean_t ioc_tested[ZFS_IOC_LAST - ZFS_IOC_FIRST]; 44 45 /* 46 * Legacy ioctls that are skipped (for now) 47 */ 48 static const zfs_ioc_t ioc_skip[] = { 49 ZFS_IOC_POOL_CREATE, 50 ZFS_IOC_POOL_DESTROY, 51 ZFS_IOC_POOL_IMPORT, 52 ZFS_IOC_POOL_EXPORT, 53 ZFS_IOC_POOL_CONFIGS, 54 ZFS_IOC_POOL_STATS, 55 ZFS_IOC_POOL_TRYIMPORT, 56 ZFS_IOC_POOL_SCAN, 57 ZFS_IOC_POOL_FREEZE, 58 ZFS_IOC_POOL_UPGRADE, 59 ZFS_IOC_POOL_GET_HISTORY, 60 61 ZFS_IOC_VDEV_ADD, 62 ZFS_IOC_VDEV_REMOVE, 63 ZFS_IOC_VDEV_SET_STATE, 64 ZFS_IOC_VDEV_ATTACH, 65 ZFS_IOC_VDEV_DETACH, 66 ZFS_IOC_VDEV_SETPATH, 67 ZFS_IOC_VDEV_SETFRU, 68 69 ZFS_IOC_OBJSET_STATS, 70 ZFS_IOC_OBJSET_ZPLPROPS, 71 ZFS_IOC_DATASET_LIST_NEXT, 72 ZFS_IOC_SNAPSHOT_LIST_NEXT, 73 ZFS_IOC_SET_PROP, 74 ZFS_IOC_DESTROY, 75 ZFS_IOC_RENAME, 76 ZFS_IOC_RECV, 77 ZFS_IOC_SEND, 78 ZFS_IOC_INJECT_FAULT, 79 ZFS_IOC_CLEAR_FAULT, 80 ZFS_IOC_INJECT_LIST_NEXT, 81 ZFS_IOC_ERROR_LOG, 82 ZFS_IOC_CLEAR, 83 ZFS_IOC_PROMOTE, 84 ZFS_IOC_DSOBJ_TO_DSNAME, 85 ZFS_IOC_OBJ_TO_PATH, 86 ZFS_IOC_POOL_SET_PROPS, 87 ZFS_IOC_POOL_GET_PROPS, 88 ZFS_IOC_SET_FSACL, 89 ZFS_IOC_GET_FSACL, 90 ZFS_IOC_SHARE, 91 ZFS_IOC_INHERIT_PROP, 92 ZFS_IOC_SMB_ACL, 93 ZFS_IOC_USERSPACE_ONE, 94 ZFS_IOC_USERSPACE_MANY, 95 ZFS_IOC_USERSPACE_UPGRADE, 96 ZFS_IOC_OBJSET_RECVD_PROPS, 97 ZFS_IOC_VDEV_SPLIT, 98 ZFS_IOC_NEXT_OBJ, 99 ZFS_IOC_DIFF, 100 ZFS_IOC_TMP_SNAPSHOT, 101 ZFS_IOC_OBJ_TO_STATS, 102 ZFS_IOC_SPACE_WRITTEN, 103 ZFS_IOC_POOL_REGUID, 104 ZFS_IOC_SEND_PROGRESS, 105 ZFS_IOC_EVENTS_NEXT, 106 ZFS_IOC_EVENTS_CLEAR, 107 ZFS_IOC_EVENTS_SEEK, 108 ZFS_IOC_NEXTBOOT, 109 ZFS_IOC_JAIL, 110 ZFS_IOC_UNJAIL, 111 }; 112 113 114 #define IOC_INPUT_TEST(ioc, name, req, opt, err) \ 115 IOC_INPUT_TEST_IMPL(ioc, name, req, opt, err, B_FALSE) 116 117 #define IOC_INPUT_TEST_WILD(ioc, name, req, opt, err) \ 118 IOC_INPUT_TEST_IMPL(ioc, name, req, opt, err, B_TRUE) 119 120 #define IOC_INPUT_TEST_IMPL(ioc, name, req, opt, err, wild) \ 121 do { \ 122 active_test = __func__ + 5; \ 123 ioc_tested[ioc - ZFS_IOC_FIRST] = B_TRUE; \ 124 lzc_ioctl_test(ioc, name, req, opt, err, wild); \ 125 } while (0) 126 127 /* 128 * run a zfs ioctl command, verify expected results and log failures 129 */ 130 static void 131 lzc_ioctl_run(zfs_ioc_t ioc, const char *name, nvlist_t *innvl, int expected) 132 { 133 zfs_cmd_t zc = {"\0"}; 134 char *packed = NULL; 135 const char *variant; 136 size_t size = 0; 137 int error = 0; 138 139 switch (expected) { 140 case ZFS_ERR_IOC_ARG_UNAVAIL: 141 variant = "unsupported input"; 142 break; 143 case ZFS_ERR_IOC_ARG_REQUIRED: 144 variant = "missing input"; 145 break; 146 case ZFS_ERR_IOC_ARG_BADTYPE: 147 variant = "invalid input type"; 148 break; 149 default: 150 variant = "valid input"; 151 break; 152 } 153 154 packed = fnvlist_pack(innvl, &size); 155 (void) strlcpy(zc.zc_name, name, sizeof (zc.zc_name)); 156 zc.zc_name[sizeof (zc.zc_name) - 1] = '\0'; 157 zc.zc_nvlist_src = (uint64_t)(uintptr_t)packed; 158 zc.zc_nvlist_src_size = size; 159 zc.zc_nvlist_dst_size = MAX(size * 2, 128 * 1024); 160 zc.zc_nvlist_dst = (uint64_t)(uintptr_t)malloc(zc.zc_nvlist_dst_size); 161 162 if (lzc_ioctl_fd(zfs_fd, ioc, &zc) != 0) 163 error = errno; 164 165 if (error != expected) { 166 unexpected_failures = B_TRUE; 167 (void) fprintf(stderr, "%s: Unexpected result with %s, " 168 "error %d (expecting %d)\n", 169 active_test, variant, error, expected); 170 } 171 172 fnvlist_pack_free(packed, size); 173 free((void *)(uintptr_t)zc.zc_nvlist_dst); 174 } 175 176 /* 177 * Test each ioc for the following ioctl input errors: 178 * ZFS_ERR_IOC_ARG_UNAVAIL an input argument is not supported by kernel 179 * ZFS_ERR_IOC_ARG_REQUIRED a required input argument is missing 180 * ZFS_ERR_IOC_ARG_BADTYPE an input argument has an invalid type 181 */ 182 static int 183 lzc_ioctl_test(zfs_ioc_t ioc, const char *name, nvlist_t *required, 184 nvlist_t *optional, int expected_error, boolean_t wildcard) 185 { 186 nvlist_t *input = fnvlist_alloc(); 187 nvlist_t *future = fnvlist_alloc(); 188 int error = 0; 189 190 if (required != NULL) { 191 for (nvpair_t *pair = nvlist_next_nvpair(required, NULL); 192 pair != NULL; pair = nvlist_next_nvpair(required, pair)) { 193 fnvlist_add_nvpair(input, pair); 194 } 195 } 196 if (optional != NULL) { 197 for (nvpair_t *pair = nvlist_next_nvpair(optional, NULL); 198 pair != NULL; pair = nvlist_next_nvpair(optional, pair)) { 199 fnvlist_add_nvpair(input, pair); 200 } 201 } 202 203 /* 204 * Generic input run with 'optional' nvlist pair 205 */ 206 if (!wildcard) 207 fnvlist_add_nvlist(input, "optional", future); 208 lzc_ioctl_run(ioc, name, input, expected_error); 209 if (!wildcard) 210 fnvlist_remove(input, "optional"); 211 212 /* 213 * Bogus input value 214 */ 215 if (!wildcard) { 216 fnvlist_add_string(input, "bogus_input", "bogus"); 217 lzc_ioctl_run(ioc, name, input, ZFS_ERR_IOC_ARG_UNAVAIL); 218 fnvlist_remove(input, "bogus_input"); 219 } 220 221 /* 222 * Missing required inputs 223 */ 224 if (required != NULL) { 225 nvlist_t *empty = fnvlist_alloc(); 226 lzc_ioctl_run(ioc, name, empty, ZFS_ERR_IOC_ARG_REQUIRED); 227 nvlist_free(empty); 228 } 229 230 /* 231 * Wrong nvpair type 232 */ 233 if (required != NULL || optional != NULL) { 234 /* 235 * switch the type of one of the input pairs 236 */ 237 for (nvpair_t *pair = nvlist_next_nvpair(input, NULL); 238 pair != NULL; pair = nvlist_next_nvpair(input, pair)) { 239 char pname[MAXNAMELEN]; 240 data_type_t ptype; 241 242 strlcpy(pname, nvpair_name(pair), sizeof (pname)); 243 pname[sizeof (pname) - 1] = '\0'; 244 ptype = nvpair_type(pair); 245 fnvlist_remove_nvpair(input, pair); 246 247 switch (ptype) { 248 case DATA_TYPE_STRING: 249 fnvlist_add_uint64(input, pname, 42); 250 break; 251 default: 252 fnvlist_add_string(input, pname, "bogus"); 253 break; 254 } 255 } 256 lzc_ioctl_run(ioc, name, input, ZFS_ERR_IOC_ARG_BADTYPE); 257 } 258 259 nvlist_free(future); 260 nvlist_free(input); 261 262 return (error); 263 } 264 265 static void 266 test_pool_sync(const char *pool) 267 { 268 nvlist_t *required = fnvlist_alloc(); 269 270 fnvlist_add_boolean_value(required, "force", B_TRUE); 271 272 IOC_INPUT_TEST(ZFS_IOC_POOL_SYNC, pool, required, NULL, 0); 273 274 nvlist_free(required); 275 } 276 277 static void 278 test_pool_reopen(const char *pool) 279 { 280 nvlist_t *optional = fnvlist_alloc(); 281 282 fnvlist_add_boolean_value(optional, "scrub_restart", B_FALSE); 283 284 IOC_INPUT_TEST(ZFS_IOC_POOL_REOPEN, pool, NULL, optional, 0); 285 286 nvlist_free(optional); 287 } 288 289 static void 290 test_pool_checkpoint(const char *pool) 291 { 292 IOC_INPUT_TEST(ZFS_IOC_POOL_CHECKPOINT, pool, NULL, NULL, 0); 293 } 294 295 static void 296 test_pool_discard_checkpoint(const char *pool) 297 { 298 int err = lzc_pool_checkpoint(pool); 299 if (err == 0 || err == ZFS_ERR_CHECKPOINT_EXISTS) 300 IOC_INPUT_TEST(ZFS_IOC_POOL_DISCARD_CHECKPOINT, pool, NULL, 301 NULL, 0); 302 } 303 304 static void 305 test_log_history(const char *pool) 306 { 307 nvlist_t *required = fnvlist_alloc(); 308 309 fnvlist_add_string(required, "message", "input check"); 310 311 IOC_INPUT_TEST(ZFS_IOC_LOG_HISTORY, pool, required, NULL, 0); 312 313 nvlist_free(required); 314 } 315 316 static void 317 test_create(const char *pool) 318 { 319 char dataset[MAXNAMELEN + 32]; 320 321 (void) snprintf(dataset, sizeof (dataset), "%s/create-fs", pool); 322 323 nvlist_t *required = fnvlist_alloc(); 324 nvlist_t *optional = fnvlist_alloc(); 325 nvlist_t *props = fnvlist_alloc(); 326 327 fnvlist_add_int32(required, "type", DMU_OST_ZFS); 328 fnvlist_add_uint64(props, "recordsize", 8192); 329 fnvlist_add_nvlist(optional, "props", props); 330 331 IOC_INPUT_TEST(ZFS_IOC_CREATE, dataset, required, optional, 0); 332 333 nvlist_free(required); 334 nvlist_free(optional); 335 } 336 337 static void 338 test_snapshot(const char *pool, const char *snapshot) 339 { 340 nvlist_t *required = fnvlist_alloc(); 341 nvlist_t *optional = fnvlist_alloc(); 342 nvlist_t *snaps = fnvlist_alloc(); 343 nvlist_t *props = fnvlist_alloc(); 344 345 fnvlist_add_boolean(snaps, snapshot); 346 fnvlist_add_nvlist(required, "snaps", snaps); 347 348 fnvlist_add_string(props, "org.openzfs:launch", "September 17th, 2013"); 349 fnvlist_add_nvlist(optional, "props", props); 350 351 IOC_INPUT_TEST(ZFS_IOC_SNAPSHOT, pool, required, optional, 0); 352 353 nvlist_free(props); 354 nvlist_free(snaps); 355 nvlist_free(optional); 356 nvlist_free(required); 357 } 358 359 static void 360 test_space_snaps(const char *snapshot) 361 { 362 nvlist_t *required = fnvlist_alloc(); 363 fnvlist_add_string(required, "firstsnap", snapshot); 364 365 IOC_INPUT_TEST(ZFS_IOC_SPACE_SNAPS, snapshot, required, NULL, 0); 366 367 nvlist_free(required); 368 } 369 370 static void 371 test_destroy_snaps(const char *pool, const char *snapshot) 372 { 373 nvlist_t *required = fnvlist_alloc(); 374 nvlist_t *snaps = fnvlist_alloc(); 375 376 fnvlist_add_boolean(snaps, snapshot); 377 fnvlist_add_nvlist(required, "snaps", snaps); 378 379 IOC_INPUT_TEST(ZFS_IOC_DESTROY_SNAPS, pool, required, NULL, 0); 380 381 nvlist_free(snaps); 382 nvlist_free(required); 383 } 384 385 386 static void 387 test_bookmark(const char *pool, const char *snapshot, const char *bookmark) 388 { 389 nvlist_t *required = fnvlist_alloc(); 390 391 fnvlist_add_string(required, bookmark, snapshot); 392 393 IOC_INPUT_TEST_WILD(ZFS_IOC_BOOKMARK, pool, required, NULL, 0); 394 395 nvlist_free(required); 396 } 397 398 static void 399 test_get_bookmarks(const char *dataset) 400 { 401 nvlist_t *optional = fnvlist_alloc(); 402 403 fnvlist_add_boolean(optional, "guid"); 404 fnvlist_add_boolean(optional, "createtxg"); 405 fnvlist_add_boolean(optional, "creation"); 406 407 IOC_INPUT_TEST_WILD(ZFS_IOC_GET_BOOKMARKS, dataset, NULL, optional, 0); 408 409 nvlist_free(optional); 410 } 411 412 static void 413 test_destroy_bookmarks(const char *pool, const char *bookmark) 414 { 415 nvlist_t *required = fnvlist_alloc(); 416 417 fnvlist_add_boolean(required, bookmark); 418 419 IOC_INPUT_TEST_WILD(ZFS_IOC_DESTROY_BOOKMARKS, pool, required, NULL, 0); 420 421 nvlist_free(required); 422 } 423 424 static void 425 test_clone(const char *snapshot, const char *clone) 426 { 427 nvlist_t *required = fnvlist_alloc(); 428 nvlist_t *optional = fnvlist_alloc(); 429 nvlist_t *props = fnvlist_alloc(); 430 431 fnvlist_add_string(required, "origin", snapshot); 432 433 IOC_INPUT_TEST(ZFS_IOC_CLONE, clone, required, NULL, 0); 434 435 nvlist_free(props); 436 nvlist_free(optional); 437 nvlist_free(required); 438 } 439 440 static void 441 test_rollback(const char *dataset, const char *snapshot) 442 { 443 nvlist_t *optional = fnvlist_alloc(); 444 445 fnvlist_add_string(optional, "target", snapshot); 446 447 IOC_INPUT_TEST(ZFS_IOC_ROLLBACK, dataset, NULL, optional, B_FALSE); 448 449 nvlist_free(optional); 450 } 451 452 static void 453 test_hold(const char *pool, const char *snapshot) 454 { 455 nvlist_t *required = fnvlist_alloc(); 456 nvlist_t *optional = fnvlist_alloc(); 457 nvlist_t *holds = fnvlist_alloc(); 458 459 fnvlist_add_string(holds, snapshot, "libzfs_check_hold"); 460 fnvlist_add_nvlist(required, "holds", holds); 461 fnvlist_add_int32(optional, "cleanup_fd", zfs_fd); 462 463 IOC_INPUT_TEST(ZFS_IOC_HOLD, pool, required, optional, 0); 464 465 nvlist_free(holds); 466 nvlist_free(optional); 467 nvlist_free(required); 468 } 469 470 static void 471 test_get_holds(const char *snapshot) 472 { 473 IOC_INPUT_TEST(ZFS_IOC_GET_HOLDS, snapshot, NULL, NULL, 0); 474 } 475 476 static void 477 test_release(const char *pool, const char *snapshot) 478 { 479 nvlist_t *required = fnvlist_alloc(); 480 nvlist_t *release = fnvlist_alloc(); 481 482 fnvlist_add_boolean(release, "libzfs_check_hold"); 483 fnvlist_add_nvlist(required, snapshot, release); 484 485 IOC_INPUT_TEST_WILD(ZFS_IOC_RELEASE, pool, required, NULL, 0); 486 487 nvlist_free(release); 488 nvlist_free(required); 489 } 490 491 492 static void 493 test_send_new(const char *snapshot, int fd) 494 { 495 nvlist_t *required = fnvlist_alloc(); 496 nvlist_t *optional = fnvlist_alloc(); 497 498 fnvlist_add_int32(required, "fd", fd); 499 500 fnvlist_add_boolean(optional, "largeblockok"); 501 fnvlist_add_boolean(optional, "embedok"); 502 fnvlist_add_boolean(optional, "compressok"); 503 fnvlist_add_boolean(optional, "rawok"); 504 505 /* 506 * TODO - Resumable send is harder to set up. So we currently 507 * ignore testing for that variant. 508 */ 509 #if 0 510 fnvlist_add_string(optional, "fromsnap", from); 511 fnvlist_add_uint64(optional, "resume_object", resumeobj); 512 fnvlist_add_uint64(optional, "resume_offset", offset); 513 fnvlist_add_boolean(optional, "savedok"); 514 #endif 515 IOC_INPUT_TEST(ZFS_IOC_SEND_NEW, snapshot, required, optional, 0); 516 517 nvlist_free(optional); 518 nvlist_free(required); 519 } 520 521 static void 522 test_recv_new(const char *dataset, int fd) 523 { 524 dmu_replay_record_t drr = { 0 }; 525 nvlist_t *required = fnvlist_alloc(); 526 nvlist_t *optional = fnvlist_alloc(); 527 nvlist_t *props = fnvlist_alloc(); 528 char snapshot[MAXNAMELEN + 32]; 529 ssize_t count; 530 531 int cleanup_fd = open(ZFS_DEV, O_RDWR); 532 if (cleanup_fd == -1) { 533 (void) fprintf(stderr, "open(%s) failed: %s\n", ZFS_DEV, 534 strerror(errno)); 535 exit(EXIT_FAILURE); 536 } 537 (void) snprintf(snapshot, sizeof (snapshot), "%s@replicant", dataset); 538 539 count = pread(fd, &drr, sizeof (drr), 0); 540 if (count != sizeof (drr)) { 541 (void) fprintf(stderr, "could not read stream: %s\n", 542 strerror(errno)); 543 } 544 545 fnvlist_add_string(required, "snapname", snapshot); 546 fnvlist_add_byte_array(required, "begin_record", (uchar_t *)&drr, 547 sizeof (drr)); 548 fnvlist_add_int32(required, "input_fd", fd); 549 550 fnvlist_add_string(props, "org.openzfs:launch", "September 17th, 2013"); 551 fnvlist_add_nvlist(optional, "localprops", props); 552 fnvlist_add_boolean(optional, "force"); 553 fnvlist_add_boolean(optional, "heal"); 554 fnvlist_add_int32(optional, "cleanup_fd", cleanup_fd); 555 556 /* 557 * TODO - Resumable receive is harder to set up. So we currently 558 * ignore testing for one. 559 */ 560 #if 0 561 fnvlist_add_nvlist(optional, "props", recvdprops); 562 fnvlist_add_string(optional, "origin", origin); 563 fnvlist_add_boolean(optional, "resumable"); 564 fnvlist_add_uint64(optional, "action_handle", *action_handle); 565 #endif 566 IOC_INPUT_TEST(ZFS_IOC_RECV_NEW, dataset, required, optional, 567 ENOTSUP); 568 569 nvlist_free(props); 570 nvlist_free(optional); 571 nvlist_free(required); 572 573 (void) close(cleanup_fd); 574 } 575 576 static void 577 test_send_space(const char *snapshot1, const char *snapshot2) 578 { 579 nvlist_t *optional = fnvlist_alloc(); 580 581 fnvlist_add_string(optional, "from", snapshot1); 582 fnvlist_add_boolean(optional, "largeblockok"); 583 fnvlist_add_boolean(optional, "embedok"); 584 fnvlist_add_boolean(optional, "compressok"); 585 fnvlist_add_boolean(optional, "rawok"); 586 587 IOC_INPUT_TEST(ZFS_IOC_SEND_SPACE, snapshot2, NULL, optional, 0); 588 589 nvlist_free(optional); 590 } 591 592 static void 593 test_remap(const char *dataset) 594 { 595 IOC_INPUT_TEST(ZFS_IOC_REMAP, dataset, NULL, NULL, 0); 596 } 597 598 static void 599 test_channel_program(const char *pool) 600 { 601 const char *program = 602 "arg = ...\n" 603 "argv = arg[\"argv\"]\n" 604 "return argv[1]"; 605 const char *const argv[1] = { "Hello World!" }; 606 nvlist_t *required = fnvlist_alloc(); 607 nvlist_t *optional = fnvlist_alloc(); 608 nvlist_t *args = fnvlist_alloc(); 609 610 fnvlist_add_string(required, "program", program); 611 fnvlist_add_string_array(args, "argv", argv, 1); 612 fnvlist_add_nvlist(required, "arg", args); 613 614 fnvlist_add_boolean_value(optional, "sync", B_TRUE); 615 fnvlist_add_uint64(optional, "instrlimit", 1000 * 1000); 616 fnvlist_add_uint64(optional, "memlimit", 8192 * 1024); 617 618 IOC_INPUT_TEST(ZFS_IOC_CHANNEL_PROGRAM, pool, required, optional, 0); 619 620 nvlist_free(args); 621 nvlist_free(optional); 622 nvlist_free(required); 623 } 624 625 #define WRAPPING_KEY_LEN 32 626 627 static void 628 test_load_key(const char *dataset) 629 { 630 nvlist_t *required = fnvlist_alloc(); 631 nvlist_t *optional = fnvlist_alloc(); 632 nvlist_t *hidden = fnvlist_alloc(); 633 uint8_t keydata[WRAPPING_KEY_LEN] = {0}; 634 635 fnvlist_add_uint8_array(hidden, "wkeydata", keydata, sizeof (keydata)); 636 fnvlist_add_nvlist(required, "hidden_args", hidden); 637 fnvlist_add_boolean(optional, "noop"); 638 639 IOC_INPUT_TEST(ZFS_IOC_LOAD_KEY, dataset, required, optional, EINVAL); 640 nvlist_free(hidden); 641 nvlist_free(optional); 642 nvlist_free(required); 643 } 644 645 static void 646 test_change_key(const char *dataset) 647 { 648 IOC_INPUT_TEST(ZFS_IOC_CHANGE_KEY, dataset, NULL, NULL, EINVAL); 649 } 650 651 static void 652 test_unload_key(const char *dataset) 653 { 654 IOC_INPUT_TEST(ZFS_IOC_UNLOAD_KEY, dataset, NULL, NULL, EACCES); 655 } 656 657 static void 658 test_vdev_initialize(const char *pool) 659 { 660 nvlist_t *required = fnvlist_alloc(); 661 nvlist_t *vdev_guids = fnvlist_alloc(); 662 663 fnvlist_add_uint64(vdev_guids, "path", 0xdeadbeefdeadbeef); 664 fnvlist_add_uint64(required, ZPOOL_INITIALIZE_COMMAND, 665 POOL_INITIALIZE_START); 666 fnvlist_add_nvlist(required, ZPOOL_INITIALIZE_VDEVS, vdev_guids); 667 668 IOC_INPUT_TEST(ZFS_IOC_POOL_INITIALIZE, pool, required, NULL, EINVAL); 669 nvlist_free(vdev_guids); 670 nvlist_free(required); 671 } 672 673 static void 674 test_vdev_trim(const char *pool) 675 { 676 nvlist_t *required = fnvlist_alloc(); 677 nvlist_t *optional = fnvlist_alloc(); 678 nvlist_t *vdev_guids = fnvlist_alloc(); 679 680 fnvlist_add_uint64(vdev_guids, "path", 0xdeadbeefdeadbeef); 681 fnvlist_add_uint64(required, ZPOOL_TRIM_COMMAND, POOL_TRIM_START); 682 fnvlist_add_nvlist(required, ZPOOL_TRIM_VDEVS, vdev_guids); 683 fnvlist_add_uint64(optional, ZPOOL_TRIM_RATE, 1ULL << 30); 684 fnvlist_add_boolean_value(optional, ZPOOL_TRIM_SECURE, B_TRUE); 685 686 IOC_INPUT_TEST(ZFS_IOC_POOL_TRIM, pool, required, optional, EINVAL); 687 nvlist_free(vdev_guids); 688 nvlist_free(optional); 689 nvlist_free(required); 690 } 691 692 /* Test with invalid values */ 693 static void 694 test_scrub(const char *pool) 695 { 696 nvlist_t *required = fnvlist_alloc(); 697 fnvlist_add_uint64(required, "scan_type", POOL_SCAN_FUNCS + 1); 698 fnvlist_add_uint64(required, "scan_command", POOL_SCRUB_FLAGS_END + 1); 699 IOC_INPUT_TEST(ZFS_IOC_POOL_SCRUB, pool, required, NULL, EINVAL); 700 nvlist_free(required); 701 } 702 703 static int 704 zfs_destroy(const char *dataset) 705 { 706 zfs_cmd_t zc = {"\0"}; 707 int err; 708 709 (void) strlcpy(zc.zc_name, dataset, sizeof (zc.zc_name)); 710 zc.zc_name[sizeof (zc.zc_name) - 1] = '\0'; 711 err = lzc_ioctl_fd(zfs_fd, ZFS_IOC_DESTROY, &zc); 712 713 return (err == 0 ? 0 : errno); 714 } 715 716 static void 717 test_redact(const char *snapshot1, const char *snapshot2) 718 { 719 nvlist_t *required = fnvlist_alloc(); 720 nvlist_t *snapnv = fnvlist_alloc(); 721 char bookmark[MAXNAMELEN + 32]; 722 723 fnvlist_add_string(required, "bookname", "testbookmark"); 724 fnvlist_add_boolean(snapnv, snapshot2); 725 fnvlist_add_nvlist(required, "snapnv", snapnv); 726 727 IOC_INPUT_TEST(ZFS_IOC_REDACT, snapshot1, required, NULL, 0); 728 729 nvlist_free(snapnv); 730 nvlist_free(required); 731 732 strlcpy(bookmark, snapshot1, sizeof (bookmark)); 733 *strchr(bookmark, '@') = '\0'; 734 strlcat(bookmark, "#testbookmark", sizeof (bookmark) - 735 strlen(bookmark)); 736 zfs_destroy(bookmark); 737 } 738 739 static void 740 test_get_bookmark_props(const char *bookmark) 741 { 742 IOC_INPUT_TEST(ZFS_IOC_GET_BOOKMARK_PROPS, bookmark, NULL, NULL, 0); 743 } 744 745 static void 746 test_wait(const char *pool) 747 { 748 nvlist_t *required = fnvlist_alloc(); 749 nvlist_t *optional = fnvlist_alloc(); 750 751 fnvlist_add_int32(required, "wait_activity", 2); 752 fnvlist_add_uint64(optional, "wait_tag", 0xdeadbeefdeadbeef); 753 754 IOC_INPUT_TEST(ZFS_IOC_WAIT, pool, required, optional, EINVAL); 755 756 nvlist_free(required); 757 nvlist_free(optional); 758 } 759 760 static void 761 test_wait_fs(const char *dataset) 762 { 763 nvlist_t *required = fnvlist_alloc(); 764 765 fnvlist_add_int32(required, "wait_activity", 2); 766 767 IOC_INPUT_TEST(ZFS_IOC_WAIT_FS, dataset, required, NULL, EINVAL); 768 769 nvlist_free(required); 770 } 771 772 static void 773 test_get_bootenv(const char *pool) 774 { 775 IOC_INPUT_TEST(ZFS_IOC_GET_BOOTENV, pool, NULL, NULL, 0); 776 } 777 778 static void 779 test_set_bootenv(const char *pool) 780 { 781 nvlist_t *required = fnvlist_alloc(); 782 783 fnvlist_add_uint64(required, "version", VB_RAW); 784 fnvlist_add_string(required, GRUB_ENVMAP, "test"); 785 786 IOC_INPUT_TEST_WILD(ZFS_IOC_SET_BOOTENV, pool, required, NULL, 0); 787 788 nvlist_free(required); 789 } 790 791 static void 792 zfs_ioc_input_tests(const char *pool) 793 { 794 char filepath[] = "/tmp/ioc_test_file_XXXXXX"; 795 char dataset[ZFS_MAX_DATASET_NAME_LEN]; 796 char snapbase[ZFS_MAX_DATASET_NAME_LEN + 32]; 797 char snapshot[ZFS_MAX_DATASET_NAME_LEN + 32]; 798 char bookmark[ZFS_MAX_DATASET_NAME_LEN + 32]; 799 char backup[ZFS_MAX_DATASET_NAME_LEN]; 800 char clone[ZFS_MAX_DATASET_NAME_LEN]; 801 char clonesnap[ZFS_MAX_DATASET_NAME_LEN + 32]; 802 int tmpfd, err; 803 804 /* 805 * Setup names and create a working dataset 806 */ 807 (void) snprintf(dataset, sizeof (dataset), "%s/test-fs", pool); 808 (void) snprintf(snapbase, sizeof (snapbase), "%s@snapbase", dataset); 809 (void) snprintf(snapshot, sizeof (snapshot), "%s@snapshot", dataset); 810 (void) snprintf(bookmark, sizeof (bookmark), "%s#bookmark", dataset); 811 (void) snprintf(clone, sizeof (clone), "%s/test-fs-clone", pool); 812 (void) snprintf(clonesnap, sizeof (clonesnap), "%s@snap", clone); 813 (void) snprintf(backup, sizeof (backup), "%s/backup", pool); 814 815 err = lzc_create(dataset, LZC_DATSET_TYPE_ZFS, NULL, NULL, -1); 816 if (err) { 817 (void) fprintf(stderr, "could not create '%s': %s\n", 818 dataset, strerror(errno)); 819 exit(2); 820 } 821 822 tmpfd = mkstemp(filepath); 823 if (tmpfd < 0) { 824 (void) fprintf(stderr, "could not create '%s': %s\n", 825 filepath, strerror(errno)); 826 exit(2); 827 } 828 829 /* 830 * run a test for each ioctl 831 * Note that some test build on previous test operations 832 */ 833 test_pool_sync(pool); 834 test_pool_reopen(pool); 835 test_pool_checkpoint(pool); 836 test_pool_discard_checkpoint(pool); 837 test_log_history(pool); 838 839 test_create(dataset); 840 test_snapshot(pool, snapbase); 841 test_snapshot(pool, snapshot); 842 843 test_space_snaps(snapshot); 844 test_send_space(snapbase, snapshot); 845 test_send_new(snapshot, tmpfd); 846 test_recv_new(backup, tmpfd); 847 848 test_bookmark(pool, snapshot, bookmark); 849 test_get_bookmarks(dataset); 850 test_get_bookmark_props(bookmark); 851 test_destroy_bookmarks(pool, bookmark); 852 853 test_hold(pool, snapshot); 854 test_get_holds(snapshot); 855 test_release(pool, snapshot); 856 857 test_clone(snapshot, clone); 858 test_snapshot(pool, clonesnap); 859 test_redact(snapshot, clonesnap); 860 zfs_destroy(clonesnap); 861 zfs_destroy(clone); 862 863 test_rollback(dataset, snapshot); 864 test_destroy_snaps(pool, snapshot); 865 test_destroy_snaps(pool, snapbase); 866 867 test_remap(dataset); 868 test_channel_program(pool); 869 870 test_load_key(dataset); 871 test_change_key(dataset); 872 test_unload_key(dataset); 873 874 test_vdev_initialize(pool); 875 test_vdev_trim(pool); 876 877 test_wait(pool); 878 test_wait_fs(dataset); 879 880 test_set_bootenv(pool); 881 test_get_bootenv(pool); 882 883 test_scrub(pool); 884 885 /* 886 * cleanup 887 */ 888 zfs_cmd_t zc = {"\0"}; 889 890 nvlist_t *snaps = fnvlist_alloc(); 891 fnvlist_add_boolean(snaps, snapshot); 892 (void) lzc_destroy_snaps(snaps, B_FALSE, NULL); 893 nvlist_free(snaps); 894 895 (void) zfs_destroy(dataset); 896 (void) zfs_destroy(backup); 897 898 (void) close(tmpfd); 899 (void) unlink(filepath); 900 901 /* 902 * All the unused slots should yield ZFS_ERR_IOC_CMD_UNAVAIL 903 */ 904 for (int i = 0; i < ARRAY_SIZE(ioc_skip); i++) { 905 if (ioc_tested[ioc_skip[i] - ZFS_IOC_FIRST]) 906 (void) fprintf(stderr, "cmd %d tested, not skipped!\n", 907 (int)(ioc_skip[i] - ZFS_IOC_FIRST)); 908 909 ioc_tested[ioc_skip[i] - ZFS_IOC_FIRST] = B_TRUE; 910 } 911 912 (void) strlcpy(zc.zc_name, pool, sizeof (zc.zc_name)); 913 zc.zc_name[sizeof (zc.zc_name) - 1] = '\0'; 914 915 for (unsigned ioc = ZFS_IOC_FIRST; ioc < ZFS_IOC_LAST; ioc++) { 916 unsigned cmd = ioc - ZFS_IOC_FIRST; 917 918 if (ioc_tested[cmd]) 919 continue; 920 921 if (lzc_ioctl_fd(zfs_fd, ioc, &zc) != 0 && 922 errno != ZFS_ERR_IOC_CMD_UNAVAIL) { 923 (void) fprintf(stderr, "cmd %d is missing a test case " 924 "(%d)\n", cmd, errno); 925 } 926 } 927 } 928 929 enum zfs_ioc_ref { 930 #ifdef __FreeBSD__ 931 ZFS_IOC_BASE = 0, 932 #else 933 ZFS_IOC_BASE = ('Z' << 8), 934 #endif 935 ZFS_IOC_PLATFORM_BASE = ZFS_IOC_BASE + 0x80, 936 }; 937 938 /* 939 * Canonical reference check of /dev/zfs ioctl numbers. 940 * These cannot change and new ioctl numbers must be appended. 941 */ 942 static boolean_t 943 validate_ioc_values(void) 944 { 945 boolean_t result = B_TRUE; 946 947 #define CHECK(expr) do { \ 948 if (!(expr)) { \ 949 result = B_FALSE; \ 950 fprintf(stderr, "(%s) === FALSE\n", #expr); \ 951 } \ 952 } while (0) 953 954 CHECK(ZFS_IOC_BASE + 0 == ZFS_IOC_POOL_CREATE); 955 CHECK(ZFS_IOC_BASE + 1 == ZFS_IOC_POOL_DESTROY); 956 CHECK(ZFS_IOC_BASE + 2 == ZFS_IOC_POOL_IMPORT); 957 CHECK(ZFS_IOC_BASE + 3 == ZFS_IOC_POOL_EXPORT); 958 CHECK(ZFS_IOC_BASE + 4 == ZFS_IOC_POOL_CONFIGS); 959 CHECK(ZFS_IOC_BASE + 5 == ZFS_IOC_POOL_STATS); 960 CHECK(ZFS_IOC_BASE + 6 == ZFS_IOC_POOL_TRYIMPORT); 961 CHECK(ZFS_IOC_BASE + 7 == ZFS_IOC_POOL_SCAN); 962 CHECK(ZFS_IOC_BASE + 8 == ZFS_IOC_POOL_FREEZE); 963 CHECK(ZFS_IOC_BASE + 9 == ZFS_IOC_POOL_UPGRADE); 964 CHECK(ZFS_IOC_BASE + 10 == ZFS_IOC_POOL_GET_HISTORY); 965 CHECK(ZFS_IOC_BASE + 11 == ZFS_IOC_VDEV_ADD); 966 CHECK(ZFS_IOC_BASE + 12 == ZFS_IOC_VDEV_REMOVE); 967 CHECK(ZFS_IOC_BASE + 13 == ZFS_IOC_VDEV_SET_STATE); 968 CHECK(ZFS_IOC_BASE + 14 == ZFS_IOC_VDEV_ATTACH); 969 CHECK(ZFS_IOC_BASE + 15 == ZFS_IOC_VDEV_DETACH); 970 CHECK(ZFS_IOC_BASE + 16 == ZFS_IOC_VDEV_SETPATH); 971 CHECK(ZFS_IOC_BASE + 17 == ZFS_IOC_VDEV_SETFRU); 972 CHECK(ZFS_IOC_BASE + 18 == ZFS_IOC_OBJSET_STATS); 973 CHECK(ZFS_IOC_BASE + 19 == ZFS_IOC_OBJSET_ZPLPROPS); 974 CHECK(ZFS_IOC_BASE + 20 == ZFS_IOC_DATASET_LIST_NEXT); 975 CHECK(ZFS_IOC_BASE + 21 == ZFS_IOC_SNAPSHOT_LIST_NEXT); 976 CHECK(ZFS_IOC_BASE + 22 == ZFS_IOC_SET_PROP); 977 CHECK(ZFS_IOC_BASE + 23 == ZFS_IOC_CREATE); 978 CHECK(ZFS_IOC_BASE + 24 == ZFS_IOC_DESTROY); 979 CHECK(ZFS_IOC_BASE + 25 == ZFS_IOC_ROLLBACK); 980 CHECK(ZFS_IOC_BASE + 26 == ZFS_IOC_RENAME); 981 CHECK(ZFS_IOC_BASE + 27 == ZFS_IOC_RECV); 982 CHECK(ZFS_IOC_BASE + 28 == ZFS_IOC_SEND); 983 CHECK(ZFS_IOC_BASE + 29 == ZFS_IOC_INJECT_FAULT); 984 CHECK(ZFS_IOC_BASE + 30 == ZFS_IOC_CLEAR_FAULT); 985 CHECK(ZFS_IOC_BASE + 31 == ZFS_IOC_INJECT_LIST_NEXT); 986 CHECK(ZFS_IOC_BASE + 32 == ZFS_IOC_ERROR_LOG); 987 CHECK(ZFS_IOC_BASE + 33 == ZFS_IOC_CLEAR); 988 CHECK(ZFS_IOC_BASE + 34 == ZFS_IOC_PROMOTE); 989 CHECK(ZFS_IOC_BASE + 35 == ZFS_IOC_SNAPSHOT); 990 CHECK(ZFS_IOC_BASE + 36 == ZFS_IOC_DSOBJ_TO_DSNAME); 991 CHECK(ZFS_IOC_BASE + 37 == ZFS_IOC_OBJ_TO_PATH); 992 CHECK(ZFS_IOC_BASE + 38 == ZFS_IOC_POOL_SET_PROPS); 993 CHECK(ZFS_IOC_BASE + 39 == ZFS_IOC_POOL_GET_PROPS); 994 CHECK(ZFS_IOC_BASE + 40 == ZFS_IOC_SET_FSACL); 995 CHECK(ZFS_IOC_BASE + 41 == ZFS_IOC_GET_FSACL); 996 CHECK(ZFS_IOC_BASE + 42 == ZFS_IOC_SHARE); 997 CHECK(ZFS_IOC_BASE + 43 == ZFS_IOC_INHERIT_PROP); 998 CHECK(ZFS_IOC_BASE + 44 == ZFS_IOC_SMB_ACL); 999 CHECK(ZFS_IOC_BASE + 45 == ZFS_IOC_USERSPACE_ONE); 1000 CHECK(ZFS_IOC_BASE + 46 == ZFS_IOC_USERSPACE_MANY); 1001 CHECK(ZFS_IOC_BASE + 47 == ZFS_IOC_USERSPACE_UPGRADE); 1002 CHECK(ZFS_IOC_BASE + 48 == ZFS_IOC_HOLD); 1003 CHECK(ZFS_IOC_BASE + 49 == ZFS_IOC_RELEASE); 1004 CHECK(ZFS_IOC_BASE + 50 == ZFS_IOC_GET_HOLDS); 1005 CHECK(ZFS_IOC_BASE + 51 == ZFS_IOC_OBJSET_RECVD_PROPS); 1006 CHECK(ZFS_IOC_BASE + 52 == ZFS_IOC_VDEV_SPLIT); 1007 CHECK(ZFS_IOC_BASE + 53 == ZFS_IOC_NEXT_OBJ); 1008 CHECK(ZFS_IOC_BASE + 54 == ZFS_IOC_DIFF); 1009 CHECK(ZFS_IOC_BASE + 55 == ZFS_IOC_TMP_SNAPSHOT); 1010 CHECK(ZFS_IOC_BASE + 56 == ZFS_IOC_OBJ_TO_STATS); 1011 CHECK(ZFS_IOC_BASE + 57 == ZFS_IOC_SPACE_WRITTEN); 1012 CHECK(ZFS_IOC_BASE + 58 == ZFS_IOC_SPACE_SNAPS); 1013 CHECK(ZFS_IOC_BASE + 59 == ZFS_IOC_DESTROY_SNAPS); 1014 CHECK(ZFS_IOC_BASE + 60 == ZFS_IOC_POOL_REGUID); 1015 CHECK(ZFS_IOC_BASE + 61 == ZFS_IOC_POOL_REOPEN); 1016 CHECK(ZFS_IOC_BASE + 62 == ZFS_IOC_SEND_PROGRESS); 1017 CHECK(ZFS_IOC_BASE + 63 == ZFS_IOC_LOG_HISTORY); 1018 CHECK(ZFS_IOC_BASE + 64 == ZFS_IOC_SEND_NEW); 1019 CHECK(ZFS_IOC_BASE + 65 == ZFS_IOC_SEND_SPACE); 1020 CHECK(ZFS_IOC_BASE + 66 == ZFS_IOC_CLONE); 1021 CHECK(ZFS_IOC_BASE + 67 == ZFS_IOC_BOOKMARK); 1022 CHECK(ZFS_IOC_BASE + 68 == ZFS_IOC_GET_BOOKMARKS); 1023 CHECK(ZFS_IOC_BASE + 69 == ZFS_IOC_DESTROY_BOOKMARKS); 1024 CHECK(ZFS_IOC_BASE + 70 == ZFS_IOC_RECV_NEW); 1025 CHECK(ZFS_IOC_BASE + 71 == ZFS_IOC_POOL_SYNC); 1026 CHECK(ZFS_IOC_BASE + 72 == ZFS_IOC_CHANNEL_PROGRAM); 1027 CHECK(ZFS_IOC_BASE + 73 == ZFS_IOC_LOAD_KEY); 1028 CHECK(ZFS_IOC_BASE + 74 == ZFS_IOC_UNLOAD_KEY); 1029 CHECK(ZFS_IOC_BASE + 75 == ZFS_IOC_CHANGE_KEY); 1030 CHECK(ZFS_IOC_BASE + 76 == ZFS_IOC_REMAP); 1031 CHECK(ZFS_IOC_BASE + 77 == ZFS_IOC_POOL_CHECKPOINT); 1032 CHECK(ZFS_IOC_BASE + 78 == ZFS_IOC_POOL_DISCARD_CHECKPOINT); 1033 CHECK(ZFS_IOC_BASE + 79 == ZFS_IOC_POOL_INITIALIZE); 1034 CHECK(ZFS_IOC_BASE + 80 == ZFS_IOC_POOL_TRIM); 1035 CHECK(ZFS_IOC_BASE + 81 == ZFS_IOC_REDACT); 1036 CHECK(ZFS_IOC_BASE + 82 == ZFS_IOC_GET_BOOKMARK_PROPS); 1037 CHECK(ZFS_IOC_BASE + 83 == ZFS_IOC_WAIT); 1038 CHECK(ZFS_IOC_BASE + 84 == ZFS_IOC_WAIT_FS); 1039 CHECK(ZFS_IOC_BASE + 87 == ZFS_IOC_POOL_SCRUB); 1040 CHECK(ZFS_IOC_PLATFORM_BASE + 1 == ZFS_IOC_EVENTS_NEXT); 1041 CHECK(ZFS_IOC_PLATFORM_BASE + 2 == ZFS_IOC_EVENTS_CLEAR); 1042 CHECK(ZFS_IOC_PLATFORM_BASE + 3 == ZFS_IOC_EVENTS_SEEK); 1043 CHECK(ZFS_IOC_PLATFORM_BASE + 4 == ZFS_IOC_NEXTBOOT); 1044 CHECK(ZFS_IOC_PLATFORM_BASE + 5 == ZFS_IOC_JAIL); 1045 CHECK(ZFS_IOC_PLATFORM_BASE + 6 == ZFS_IOC_UNJAIL); 1046 CHECK(ZFS_IOC_PLATFORM_BASE + 7 == ZFS_IOC_SET_BOOTENV); 1047 CHECK(ZFS_IOC_PLATFORM_BASE + 8 == ZFS_IOC_GET_BOOTENV); 1048 1049 #undef CHECK 1050 1051 return (result); 1052 } 1053 1054 int 1055 main(int argc, const char *argv[]) 1056 { 1057 if (argc != 2) { 1058 (void) fprintf(stderr, "usage: %s <pool>\n", argv[0]); 1059 exit(2); 1060 } 1061 1062 if (!validate_ioc_values()) { 1063 (void) fprintf(stderr, "WARNING: zfs_ioc_t has binary " 1064 "incompatible command values\n"); 1065 exit(3); 1066 } 1067 1068 (void) libzfs_core_init(); 1069 zfs_fd = open(ZFS_DEV, O_RDWR); 1070 if (zfs_fd < 0) { 1071 (void) fprintf(stderr, "open: %s\n", strerror(errno)); 1072 libzfs_core_fini(); 1073 exit(2); 1074 } 1075 1076 zfs_ioc_input_tests(argv[1]); 1077 1078 (void) close(zfs_fd); 1079 libzfs_core_fini(); 1080 1081 return (unexpected_failures); 1082 } 1083