modules/splat/splat-vnode.c

   1 /*
   2  *  This file is part of the SPL: Solaris Porting Layer.
   3  *
   4  *  Copyright (c) 2008 Lawrence Livermore National Security, LLC.
   5  *  Produced at Lawrence Livermore National Laboratory
   6  *  Written by:
   7  *          Brian Behlendorf <behlendorf1@llnl.gov>,
   8  *          Herb Wartens <wartens2@llnl.gov>,
   9  *          Jim Garlick <garlick@llnl.gov>
  10  *  UCRL-CODE-235197
  11  *
  12  *  This is free software; you can redistribute it and/or modify it
  13  *  under the terms of the GNU General Public License as published by
  14  *  the Free Software Foundation; either version 2 of the License, or
  15  *  (at your option) any later version.
  16  *
  17  *  This is distributed in the hope that it will be useful, but WITHOUT
  18  *  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  19  *  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  20  *  for more details.
  21  *
  22  *  You should have received a copy of the GNU General Public License along
  23  *  with this program; if not, write to the Free Software Foundation, Inc.,
  24  *  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA.
  25  */
  26
  27 #include "splat-internal.h"
  28 #include <linux/rcupdate.h>
  29
  30 #define SPLAT_SUBSYSTEM_VNODE           0x0900
  31 #define SPLAT_VNODE_NAME                "vnode"
  32 #define SPLAT_VNODE_DESC                "Kernel Vnode Tests"
  33
  34 #define SPLAT_VNODE_TEST1_ID            0x0901
  35 #define SPLAT_VNODE_TEST1_NAME          "vn_open"
  36 #define SPLAT_VNODE_TEST1_DESC          "Vn_open Test"
  37
  38 #define SPLAT_VNODE_TEST2_ID            0x0902
  39 #define SPLAT_VNODE_TEST2_NAME          "vn_openat"
  40 #define SPLAT_VNODE_TEST2_DESC          "Vn_openat Test"
  41
  42 #define SPLAT_VNODE_TEST3_ID            0x0903
  43 #define SPLAT_VNODE_TEST3_NAME          "vn_rdwr"
  44 #define SPLAT_VNODE_TEST3_DESC          "Vn_rdwrt Test"
  45
  46 #define SPLAT_VNODE_TEST4_ID            0x0904
  47 #define SPLAT_VNODE_TEST4_NAME          "vn_rename"
  48 #define SPLAT_VNODE_TEST4_DESC          "Vn_rename Test"
  49
  50 #define SPLAT_VNODE_TEST5_ID            0x0905
  51 #define SPLAT_VNODE_TEST5_NAME          "vn_getattr"
  52 #define SPLAT_VNODE_TEST5_DESC          "Vn_getattr Test"
  53
  54 #define SPLAT_VNODE_TEST6_ID            0x0906
  55 #define SPLAT_VNODE_TEST6_NAME          "vn_sync"
  56 #define SPLAT_VNODE_TEST6_DESC          "Vn_sync Test"
  57
  58 #define SPLAT_VNODE_TEST7_ID            0x0907
  59 #define SPLAT_VNODE_TEST7_NAME          "vn_getf"
  60 #define SPLAT_VNODE_TEST7_DESC          "vn_getf/vn_releasef Test"
  61
  62 #define SPLAT_VNODE_TEST_FILE           "/etc/fstab"
  63 #define SPLAT_VNODE_TEST_FILE_AT        "etc/fstab"
  64 #define SPLAT_VNODE_TEST_FILE_RW        "/tmp/spl.vnode.tmp"
  65 #define SPLAT_VNODE_TEST_FILE_RW1       "/tmp/spl.vnode.tmp.1"
  66 #define SPLAT_VNODE_TEST_FILE_RW2       "/tmp/spl.vnode.tmp.2"
  67
  68 static int
  69 splat_vnode_test1(struct file *file, void *arg)
  70 {
  71         vnode_t *vp;
  72         int rc;
  73
  74         if ((rc = vn_open(SPLAT_VNODE_TEST_FILE, UIO_SYSSPACE,
  75                           FREAD, 0644, &vp, 0, 0))) {
  76                 splat_vprint(file, SPLAT_VNODE_TEST1_NAME,
  77                              "Failed to vn_open test file: %s (%d)\n",
  78                              SPLAT_VNODE_TEST_FILE, rc);
  79                 return rc;
  80         }
  81
  82         rc = VOP_CLOSE(vp, 0, 0, 0, 0, 0);
  83         VN_RELE(vp);
  84
  85         if (rc) {
  86                 splat_vprint(file, SPLAT_VNODE_TEST1_NAME,
  87                              "Failed to vn_close test file: %s (%d)\n",
  88                              SPLAT_VNODE_TEST_FILE, rc);
  89                 return rc;
  90         }
  91
  92         splat_vprint(file, SPLAT_VNODE_TEST1_NAME, "Successfully vn_open'ed "
  93                      "and vn_closed test file: %s\n", SPLAT_VNODE_TEST_FILE);
  94
  95         return rc;
  96 } /* splat_vnode_test1() */
  97
  98 static int
  99 splat_vnode_test2(struct file *file, void *arg)
 100 {
 101         vnode_t *vp;
 102         int rc;
 103
 104         if ((rc = vn_openat(SPLAT_VNODE_TEST_FILE_AT, UIO_SYSSPACE,
 105                             FREAD, 0644, &vp, 0, 0, rootdir, 0))) {
 106                 splat_vprint(file, SPLAT_VNODE_TEST2_NAME,
 107                              "Failed to vn_openat test file: %s (%d)\n",
 108                              SPLAT_VNODE_TEST_FILE, rc);
 109                 return rc;
 110         }
 111
 112         rc = VOP_CLOSE(vp, 0, 0, 0, 0, 0);
 113         VN_RELE(vp);
 114
 115         if (rc) {
 116                 splat_vprint(file, SPLAT_VNODE_TEST2_NAME,
 117                              "Failed to vn_close test file: %s (%d)\n",
 118                              SPLAT_VNODE_TEST_FILE, rc);
 119                 return rc;
 120         }
 121
 122         splat_vprint(file, SPLAT_VNODE_TEST2_NAME, "Successfully vn_openat'ed "
 123                      "and vn_closed test file: %s\n", SPLAT_VNODE_TEST_FILE);
 124
 125         return rc;
 126 } /* splat_vnode_test2() */
 127
 128 static int
 129 splat_vnode_test3(struct file *file, void *arg)
 130 {
 131         vnode_t *vp;
 132         char buf1[32] = "SPL VNode Interface Test File\n";
 133         char buf2[32] = "";
 134         int rc;
 135
 136         if ((rc = vn_open(SPLAT_VNODE_TEST_FILE_RW, UIO_SYSSPACE,
 137                           FWRITE | FREAD | FCREAT | FEXCL,
 138                           0644, &vp, 0, 0))) {
 139                 splat_vprint(file, SPLAT_VNODE_TEST3_NAME,
 140                              "Failed to vn_open test file: %s (%d)\n",
 141                              SPLAT_VNODE_TEST_FILE_RW, rc);
 142                 return rc;
 143         }
 144
 145         rc = vn_rdwr(UIO_WRITE, vp, buf1, strlen(buf1), 0,
 146                      UIO_SYSSPACE, 0, RLIM64_INFINITY, 0, NULL);
 147         if (rc < 0) {
 148                 splat_vprint(file, SPLAT_VNODE_TEST3_NAME,
 149                              "Failed vn_rdwr write of test file: %s (%d)\n",
 150                              SPLAT_VNODE_TEST_FILE_RW, rc);
 151                 goto out;
 152         }
 153
 154         rc = vn_rdwr(UIO_READ, vp, buf2, strlen(buf1), 0,
 155                      UIO_SYSSPACE, 0, RLIM64_INFINITY, 0, NULL);
 156         if (rc < 0) {
 157                 splat_vprint(file, SPLAT_VNODE_TEST3_NAME,
 158                              "Failed vn_rdwr read of test file: %s (%d)\n",
 159                              SPLAT_VNODE_TEST_FILE_RW, rc);
 160                 goto out;
 161         }
 162
 163         if (strncmp(buf1, buf2, strlen(buf1))) {
 164                 rc = -EINVAL;
 165                 splat_vprint(file, SPLAT_VNODE_TEST3_NAME,
 166                              "Failed strncmp data written does not match "
 167                              "data read\nWrote: %sRead:  %s\n", buf1, buf2);
 168                 goto out;
 169         }
 170
 171         rc = 0;
 172         splat_vprint(file, SPLAT_VNODE_TEST3_NAME, "Wrote: %s", buf1);
 173         splat_vprint(file, SPLAT_VNODE_TEST3_NAME, "Read:  %s", buf2);
 174         splat_vprint(file, SPLAT_VNODE_TEST3_NAME, "Successfully wrote and "
 175                      "read expected data pattern to test file: %s\n",
 176                      SPLAT_VNODE_TEST_FILE_RW);
 177
 178 out:
 179         VOP_CLOSE(vp, 0, 0, 0, 0, 0);
 180         VN_RELE(vp);
 181         vn_remove(SPLAT_VNODE_TEST_FILE_RW, UIO_SYSSPACE, RMFILE);
 182
 183         return rc;
 184 } /* splat_vnode_test3() */
 185
 186 static int
 187 splat_vnode_test4(struct file *file, void *arg)
 188 {
 189         vnode_t *vp;
 190         char buf1[32] = "SPL VNode Interface Test File\n";
 191         char buf2[32] = "";
 192         int rc;
 193
 194         if ((rc = vn_open(SPLAT_VNODE_TEST_FILE_RW1, UIO_SYSSPACE,
 195                           FWRITE | FREAD | FCREAT | FEXCL, 0644, &vp, 0, 0))) {
 196                 splat_vprint(file, SPLAT_VNODE_TEST4_NAME,
 197                              "Failed to vn_open test file: %s (%d)\n",
 198                              SPLAT_VNODE_TEST_FILE_RW1, rc);
 199                 goto out;
 200         }
 201
 202         rc = vn_rdwr(UIO_WRITE, vp, buf1, strlen(buf1), 0,
 203                      UIO_SYSSPACE, 0, RLIM64_INFINITY, 0, NULL);
 204         if (rc < 0) {
 205                 splat_vprint(file, SPLAT_VNODE_TEST4_NAME,
 206                              "Failed vn_rdwr write of test file: %s (%d)\n",
 207                              SPLAT_VNODE_TEST_FILE_RW1, rc);
 208                 goto out2;
 209         }
 210
 211         VOP_CLOSE(vp, 0, 0, 0, 0, 0);
 212         VN_RELE(vp);
 213
 214         rc = vn_rename(SPLAT_VNODE_TEST_FILE_RW1,SPLAT_VNODE_TEST_FILE_RW2,0);
 215         if (rc) {
 216                 splat_vprint(file, SPLAT_VNODE_TEST4_NAME, "Failed vn_rename "
 217                              "%s -> %s (%d)\n",
 218                              SPLAT_VNODE_TEST_FILE_RW1,
 219                              SPLAT_VNODE_TEST_FILE_RW2, rc);
 220                 goto out;
 221         }
 222
 223         if ((rc = vn_open(SPLAT_VNODE_TEST_FILE_RW2, UIO_SYSSPACE,
 224                           FREAD | FEXCL, 0644, &vp, 0, 0))) {
 225                 splat_vprint(file, SPLAT_VNODE_TEST4_NAME,
 226                              "Failed to vn_open test file: %s (%d)\n",
 227                              SPLAT_VNODE_TEST_FILE_RW2, rc);
 228                 goto out;
 229         }
 230
 231         rc = vn_rdwr(UIO_READ, vp, buf2, strlen(buf1), 0,
 232                      UIO_SYSSPACE, 0, RLIM64_INFINITY, 0, NULL);
 233         if (rc < 0) {
 234                 splat_vprint(file, SPLAT_VNODE_TEST4_NAME,
 235                              "Failed vn_rdwr read of test file: %s (%d)\n",
 236                              SPLAT_VNODE_TEST_FILE_RW2, rc);
 237                 goto out2;
 238         }
 239
 240         if (strncmp(buf1, buf2, strlen(buf1))) {
 241                 rc = EINVAL;
 242                 splat_vprint(file, SPLAT_VNODE_TEST4_NAME,
 243                              "Failed strncmp data written does not match "
 244                              "data read\nWrote: %sRead:  %s\n", buf1, buf2);
 245                 goto out2;
 246         }
 247
 248         rc = 0;
 249         splat_vprint(file, SPLAT_VNODE_TEST4_NAME, "Wrote to %s:  %s",
 250                      SPLAT_VNODE_TEST_FILE_RW1, buf1);
 251         splat_vprint(file, SPLAT_VNODE_TEST4_NAME, "Read from %s: %s",
 252                      SPLAT_VNODE_TEST_FILE_RW2, buf2);
 253         splat_vprint(file, SPLAT_VNODE_TEST4_NAME, "Successfully renamed "
 254                      "test file %s -> %s and verified data pattern\n",
 255                      SPLAT_VNODE_TEST_FILE_RW1, SPLAT_VNODE_TEST_FILE_RW2);
 256 out2:
 257         VOP_CLOSE(vp, 0, 0, 0, 0, 0);
 258         VN_RELE(vp);
 259 out:
 260         vn_remove(SPLAT_VNODE_TEST_FILE_RW1, UIO_SYSSPACE, RMFILE);
 261         vn_remove(SPLAT_VNODE_TEST_FILE_RW2, UIO_SYSSPACE, RMFILE);
 262
 263         return rc;
 264 } /* splat_vnode_test4() */
 265
 266 static int
 267 splat_vnode_test5(struct file *file, void *arg)
 268 {
 269         vnode_t *vp;
 270         vattr_t vap;
 271         int rc;
 272
 273         if ((rc = vn_open(SPLAT_VNODE_TEST_FILE, UIO_SYSSPACE,
 274                           FREAD, 0644, &vp, 0, 0))) {
 275                 splat_vprint(file, SPLAT_VNODE_TEST5_NAME,
 276                              "Failed to vn_open test file: %s (%d)\n",
 277                              SPLAT_VNODE_TEST_FILE, rc);
 278                 return rc;
 279         }
 280
 281         rc = VOP_GETATTR(vp, &vap, 0, 0, NULL);
 282         if (rc) {
 283                 splat_vprint(file, SPLAT_VNODE_TEST5_NAME,
 284                              "Failed to vn_getattr test file: %s (%d)\n",
 285                              SPLAT_VNODE_TEST_FILE, rc);
 286                 goto out;
 287         }
 288
 289         if (vap.va_type != VREG) {
 290                 rc = -EINVAL;
 291                 splat_vprint(file, SPLAT_VNODE_TEST5_NAME,
 292                              "Failed expected regular file type "
 293                              "(%d != VREG): %s (%d)\n", vap.va_type,
 294                              SPLAT_VNODE_TEST_FILE, rc);
 295                 goto out;
 296         }
 297
 298         splat_vprint(file, SPLAT_VNODE_TEST1_NAME, "Successfully "
 299                      "vn_getattr'ed test file: %s\n", SPLAT_VNODE_TEST_FILE);
 300
 301 out:
 302         VOP_CLOSE(vp, 0, 0, 0, 0, 0);
 303         VN_RELE(vp);
 304
 305         return rc;
 306 } /* splat_vnode_test5() */
 307
 308 static int
 309 splat_vnode_test6(struct file *file, void *arg)
 310 {
 311         vnode_t *vp;
 312         char buf[32] = "SPL VNode Interface Test File\n";
 313         int rc;
 314
 315         if ((rc = vn_open(SPLAT_VNODE_TEST_FILE_RW, UIO_SYSSPACE,
 316                           FWRITE | FCREAT | FEXCL, 0644, &vp, 0, 0))) {
 317                 splat_vprint(file, SPLAT_VNODE_TEST6_NAME,
 318                              "Failed to vn_open test file: %s (%d)\n",
 319                              SPLAT_VNODE_TEST_FILE_RW, rc);
 320                 return rc;
 321         }
 322
 323         rc = vn_rdwr(UIO_WRITE, vp, buf, strlen(buf), 0,
 324                      UIO_SYSSPACE, 0, RLIM64_INFINITY, 0, NULL);
 325         if (rc < 0) {
 326                 splat_vprint(file, SPLAT_VNODE_TEST6_NAME,
 327                              "Failed vn_rdwr write of test file: %s (%d)\n",
 328                              SPLAT_VNODE_TEST_FILE_RW, rc);
 329                 goto out;
 330         }
 331
 332         rc = vn_fsync(vp, 0, 0, 0);
 333         if (rc) {
 334                 splat_vprint(file, SPLAT_VNODE_TEST6_NAME,
 335                              "Failed vn_fsync of test file: %s (%d)\n",
 336                              SPLAT_VNODE_TEST_FILE_RW, rc);
 337                 goto out;
 338         }
 339
 340         rc = 0;
 341         splat_vprint(file, SPLAT_VNODE_TEST6_NAME, "Successfully "
 342                      "fsync'ed test file %s\n", SPLAT_VNODE_TEST_FILE_RW);
 343 out:
 344         VOP_CLOSE(vp, 0, 0, 0, 0, 0);
 345         VN_RELE(vp);
 346         vn_remove(SPLAT_VNODE_TEST_FILE_RW, UIO_SYSSPACE, RMFILE);
 347
 348         return rc;
 349 } /* splat_vnode_test6() */
 350
 351 /* Basically a slightly modified version of sys_close() */
 352 static int
 353 fd_uninstall(int fd)
 354 {
 355         struct file *fp;
 356         struct files_struct *files = current->files;
 357         struct fdtable *fdt;
 358
 359         spin_lock(&files->file_lock);
 360         fdt = files_fdtable(files);
 361
 362         if (fd >= fdt->max_fds)
 363                 goto out_unlock;
 364
 365         fp = fdt->fd[fd];
 366         if (!fp)
 367                 goto out_unlock;
 368
 369         rcu_assign_pointer(fdt->fd[fd], NULL);
 370         FD_CLR(fd, fdt->close_on_exec);
 371
 372          /* Dropping the lock here exposes a minor race but it allows me
 373           * to use the existing kernel interfaces for this, and for a test
 374           * case I think that's reasonable. */
 375         spin_unlock(&files->file_lock);
 376         put_unused_fd(fd);
 377         return 0;
 378
 379 out_unlock:
 380         spin_unlock(&files->file_lock);
 381         return -EBADF;
 382 } /* fd_uninstall() */
 383
 384 static int
 385 splat_vnode_test7(struct file *file, void *arg)
 386 {
 387         char buf1[32] = "SPL VNode Interface Test File\n";
 388         char buf2[32] = "";
 389         struct file *lfp;
 390         file_t *fp;
 391         int rc, fd;
 392
 393         /* Prep work needed to test getf/releasef */
 394         fd = get_unused_fd();
 395         if (fd < 0) {
 396                 splat_vprint(file, SPLAT_VNODE_TEST7_NAME,
 397                              "Failed to get unused fd (%d)\n", fd);
 398                 return fd;
 399         }
 400
 401         lfp = filp_open(SPLAT_VNODE_TEST_FILE_RW, O_RDWR|O_CREAT|O_EXCL, 0644);
 402         if (IS_ERR(lfp)) {
 403                 put_unused_fd(fd);
 404                 rc = PTR_ERR(lfp);
 405                 splat_vprint(file, SPLAT_VNODE_TEST7_NAME,
 406                              "Failed to filp_open: %s (%d)\n",
 407                              SPLAT_VNODE_TEST_FILE_RW, rc);
 408                 return rc;
 409         }
 410
 411         /* Pair up the new fd and lfp in the current context, this allows
 412          * getf to lookup the file struct simply by the known open fd */
 413         fd_install(fd, lfp);
 414
 415         /* Actual getf()/releasef() test */
 416         fp = vn_getf(fd);
 417         if (fp == NULL) {
 418                 rc = -EINVAL;
 419                 splat_vprint(file, SPLAT_VNODE_TEST7_NAME,
 420                              "Failed to getf fd %d: (%d)\n", fd, rc);
 421                 goto out;
 422         }
 423
 424         rc = vn_rdwr(UIO_WRITE, fp->f_vnode, buf1, strlen(buf1), 0,
 425                      UIO_SYSSPACE, 0, RLIM64_INFINITY, 0, NULL);
 426         if (rc < 0) {
 427                 splat_vprint(file, SPLAT_VNODE_TEST7_NAME,
 428                              "Failed vn_rdwr write of test file: %s (%d)\n",
 429                              SPLAT_VNODE_TEST_FILE_RW, rc);
 430                 goto out;
 431         }
 432
 433         rc = vn_rdwr(UIO_READ, fp->f_vnode, buf2, strlen(buf1), 0,
 434                      UIO_SYSSPACE, 0, RLIM64_INFINITY, 0, NULL);
 435         if (rc < 0) {
 436                 splat_vprint(file, SPLAT_VNODE_TEST7_NAME,
 437                              "Failed vn_rdwr read of test file: %s (%d)\n",
 438                              SPLAT_VNODE_TEST_FILE_RW, rc);
 439                 goto out;
 440         }
 441
 442         if (strncmp(buf1, buf2, strlen(buf1))) {
 443                 rc = -EINVAL;
 444                 splat_vprint(file, SPLAT_VNODE_TEST7_NAME,
 445                              "Failed strncmp data written does not match "
 446                              "data read\nWrote: %sRead:  %s\n", buf1, buf2);
 447                 goto out;
 448         }
 449
 450         rc = 0;
 451         splat_vprint(file, SPLAT_VNODE_TEST3_NAME, "Wrote: %s", buf1);
 452         splat_vprint(file, SPLAT_VNODE_TEST3_NAME, "Read:  %s", buf2);
 453         splat_vprint(file, SPLAT_VNODE_TEST3_NAME, "Successfully wrote and "
 454                      "read expected data pattern to test file: %s\n",
 455                      SPLAT_VNODE_TEST_FILE_RW);
 456 out:
 457         vn_releasef(fd);
 458         fd_uninstall(fd);
 459         filp_close(lfp, 0);
 460         vn_remove(SPLAT_VNODE_TEST_FILE_RW, UIO_SYSSPACE, RMFILE);
 461
 462         return rc;
 463 } /* splat_vnode_test7() */
 464
 465 splat_subsystem_t *
 466 splat_vnode_init(void)
 467 {
 468         splat_subsystem_t *sub;
 469
 470         sub = kmalloc(sizeof(*sub), GFP_KERNEL);
 471         if (sub == NULL)
 472                 return NULL;
 473
 474         memset(sub, 0, sizeof(*sub));
 475         strncpy(sub->desc.name, SPLAT_VNODE_NAME, SPLAT_NAME_SIZE);
 476         strncpy(sub->desc.desc, SPLAT_VNODE_DESC, SPLAT_DESC_SIZE);
 477         INIT_LIST_HEAD(&sub->subsystem_list);
 478         INIT_LIST_HEAD(&sub->test_list);
 479         spin_lock_init(&sub->test_lock);
 480         sub->desc.id = SPLAT_SUBSYSTEM_VNODE;
 481
 482         SPLAT_TEST_INIT(sub, SPLAT_VNODE_TEST1_NAME, SPLAT_VNODE_TEST1_DESC,
 483                         SPLAT_VNODE_TEST1_ID, splat_vnode_test1);
 484         SPLAT_TEST_INIT(sub, SPLAT_VNODE_TEST2_NAME, SPLAT_VNODE_TEST2_DESC,
 485                         SPLAT_VNODE_TEST2_ID, splat_vnode_test2);
 486         SPLAT_TEST_INIT(sub, SPLAT_VNODE_TEST3_NAME, SPLAT_VNODE_TEST3_DESC,
 487                         SPLAT_VNODE_TEST3_ID, splat_vnode_test3);
 488         SPLAT_TEST_INIT(sub, SPLAT_VNODE_TEST4_NAME, SPLAT_VNODE_TEST4_DESC,
 489                         SPLAT_VNODE_TEST4_ID, splat_vnode_test4);
 490         SPLAT_TEST_INIT(sub, SPLAT_VNODE_TEST5_NAME, SPLAT_VNODE_TEST5_DESC,
 491                         SPLAT_VNODE_TEST5_ID, splat_vnode_test5);
 492         SPLAT_TEST_INIT(sub, SPLAT_VNODE_TEST6_NAME, SPLAT_VNODE_TEST6_DESC,
 493                         SPLAT_VNODE_TEST6_ID, splat_vnode_test6);
 494         SPLAT_TEST_INIT(sub, SPLAT_VNODE_TEST7_NAME, SPLAT_VNODE_TEST7_DESC,
 495                         SPLAT_VNODE_TEST7_ID, splat_vnode_test7);
 496
 497         return sub;
 498 } /* splat_vnode_init() */
 499
 500 void
 501 splat_vnode_fini(splat_subsystem_t *sub)
 502 {
 503         ASSERT(sub);
 504
 505         SPLAT_TEST_FINI(sub, SPLAT_VNODE_TEST7_ID);
 506         SPLAT_TEST_FINI(sub, SPLAT_VNODE_TEST6_ID);
 507         SPLAT_TEST_FINI(sub, SPLAT_VNODE_TEST5_ID);
 508         SPLAT_TEST_FINI(sub, SPLAT_VNODE_TEST4_ID);
 509         SPLAT_TEST_FINI(sub, SPLAT_VNODE_TEST3_ID);
 510         SPLAT_TEST_FINI(sub, SPLAT_VNODE_TEST2_ID);
 511         SPLAT_TEST_FINI(sub, SPLAT_VNODE_TEST1_ID);
 512
 513         kfree(sub);
 514 } /* splat_vnode_fini() */
 515
 516 int
 517 splat_vnode_id(void)
 518 {
 519         return SPLAT_SUBSYSTEM_VNODE;
 520 } /* splat_vnode_id() */