lib/libpuffs/dispatcher.c

   1 /*      $NetBSD: dispatcher.c,v 1.32 2008/08/12 19:44:39 pooka Exp $    */
   2
   3 /*
   4  * Copyright (c) 2006, 2007, 2008 Antti Kantee.  All Rights Reserved.
   5  *
   6  * Development of this software was supported by the
   7  * Ulla Tuominen Foundation, the Finnish Cultural Foundation and
   8  * Research Foundation of Helsinki University of Technology.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
  20  * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  21  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  22  * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  25  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  29  * SUCH DAMAGE.
  30  */
  31
  32 #include <sys/cdefs.h>
  33 #if !defined(lint)
  34 __RCSID("$NetBSD: dispatcher.c,v 1.32 2008/08/12 19:44:39 pooka Exp $");
  35 #endif /* !lint */
  36
  37 #include <sys/types.h>
  38 #include <sys/poll.h>
  39
  40 #include <assert.h>
  41 #include <errno.h>
  42 #ifdef PUFFS_WITH_THREADS
  43 #include <pthread.h>
  44 #endif
  45 #include <puffs.h>
  46 #include <puffsdump.h>
  47 #include <stdio.h>
  48 #include <stdlib.h>
  49 #include <unistd.h>
  50
  51 #include "puffs_priv.h"
  52
  53 #if 0 /* me not worka now */
  54 /*
  55  * Set the following to 1 to handle each request in a separate pthread.
  56  * This is not exported as it should not be used yet unless having a
  57  * very good knowledge of what you're signing up for (libpuffs is not
  58  * threadsafe).
  59  */
  60 int puffs_usethreads;
  61 #endif
  62
  63 static void dispatch(struct puffs_cc *);
  64
  65 /* for our eyes only */
  66 void
  67 puffs__ml_dispatch(struct puffs_usermount *pu, struct puffs_framebuf *pb)
  68 {
  69         struct puffs_cc *pcc = puffs_cc_getcc(pu);
  70         struct puffs_req *preq;
  71
  72         pcc->pcc_pb = pb;
  73         pcc->pcc_flags |= PCC_MLCONT;
  74         dispatch(pcc);
  75
  76         /* Put result to kernel sendqueue if necessary */
  77         preq = puffs__framebuf_getdataptr(pcc->pcc_pb);
  78         if (PUFFSOP_WANTREPLY(preq->preq_opclass)) {
  79                 if (pu->pu_flags & PUFFS_FLAG_OPDUMP)
  80                         puffsdump_rv(preq);
  81
  82                 puffs_framev_enqueue_justsend(pu, pu->pu_fd,
  83                     pcc->pcc_pb, 0, 0);
  84         } else {
  85                 puffs_framebuf_destroy(pcc->pcc_pb);
  86         }
  87
  88         /* who needs information when you're living on borrowed time? */
  89         if (pcc->pcc_flags & PCC_BORROWED) {
  90                 puffs_cc_yield(pcc); /* back to borrow source */
  91         }
  92         pcc->pcc_flags = 0;
  93 }
  94
  95 /* public, but not really tested and only semi-supported */
  96 int
  97 puffs_dispatch_create(struct puffs_usermount *pu, struct puffs_framebuf *pb,
  98         struct puffs_cc **pccp)
  99 {
 100         struct puffs_cc *pcc;
 101
 102         if (puffs__cc_create(pu, dispatch, &pcc) == -1)
 103                 return -1;
 104
 105         pcc->pcc_pb = pb;
 106         *pccp = pcc;
 107
 108         return 0;
 109 }
 110
 111 int
 112 puffs_dispatch_exec(struct puffs_cc *pcc, struct puffs_framebuf **pbp)
 113 {
 114         int rv;
 115
 116         puffs_cc_continue(pcc);
 117
 118         if (pcc->pcc_flags & PCC_DONE) {
 119                 rv = 1;
 120                 *pbp = pcc->pcc_pb;
 121                 pcc->pcc_flags = 0;
 122                 puffs__cc_destroy(pcc, 0);
 123         } else {
 124                 rv = 0;
 125         }
 126
 127         return rv;
 128 }
 129
 130 static void
 131 dispatch(struct puffs_cc *pcc)
 132 {
 133         struct puffs_usermount *pu = pcc->pcc_pu;
 134         struct puffs_ops *pops = &pu->pu_ops;
 135         struct puffs_req *preq = puffs__framebuf_getdataptr(pcc->pcc_pb);
 136         void *auxbuf; /* help with typecasting */
 137         puffs_cookie_t opcookie;
 138         int error = 0, buildpath;
 139
 140         /* XXX: smaller hammer, please */
 141         if ((PUFFSOP_OPCLASS(preq->preq_opclass == PUFFSOP_VFS &&
 142             preq->preq_optype == PUFFS_VFS_VPTOFH)) ||
 143             (PUFFSOP_OPCLASS(preq->preq_opclass) == PUFFSOP_VN &&
 144             (preq->preq_optype == PUFFS_VN_READDIR
 145             || preq->preq_optype == PUFFS_VN_READ))) {
 146                 if (puffs_framebuf_reserve_space(pcc->pcc_pb,
 147                     PUFFS_MSG_MAXSIZE) == -1)
 148                         error = errno;
 149                 preq = puffs__framebuf_getdataptr(pcc->pcc_pb);
 150         }
 151
 152         auxbuf = preq;
 153         opcookie = preq->preq_cookie;
 154
 155         assert((pcc->pcc_flags & PCC_DONE) == 0);
 156
 157         buildpath = pu->pu_flags & PUFFS_FLAG_BUILDPATH;
 158         preq->preq_setbacks = 0;
 159
 160         if (pu->pu_flags & PUFFS_FLAG_OPDUMP)
 161                 puffsdump_req(preq);
 162
 163         puffs__cc_setcaller(pcc, preq->preq_pid, preq->preq_lid);
 164
 165         /* pre-operation */
 166         if (pu->pu_oppre)
 167                 pu->pu_oppre(pu);
 168
 169         if (error)
 170                 goto out;
 171
 172         /* Execute actual operation */
 173         if (PUFFSOP_OPCLASS(preq->preq_opclass) == PUFFSOP_VFS) {
 174                 switch (preq->preq_optype) {
 175                 case PUFFS_VFS_UNMOUNT:
 176                 {
 177                         struct puffs_vfsmsg_unmount *auxt = auxbuf;
 178
 179                         PU_SETSTATE(pu, PUFFS_STATE_UNMOUNTING);
 180                         error = pops->puffs_fs_unmount(pu, auxt->pvfsr_flags);
 181                         if (!error)
 182                                 PU_SETSTATE(pu, PUFFS_STATE_UNMOUNTED);
 183                         else
 184                                 PU_SETSTATE(pu, PUFFS_STATE_RUNNING);
 185                         break;
 186                 }
 187
 188                 case PUFFS_VFS_STATVFS:
 189                 {
 190                         struct puffs_vfsmsg_statvfs *auxt = auxbuf;
 191
 192                         error = pops->puffs_fs_statvfs(pu, &auxt->pvfsr_sb);
 193                         break;
 194                 }
 195
 196                 case PUFFS_VFS_SYNC:
 197                 {
 198                         struct puffs_vfsmsg_sync *auxt = auxbuf;
 199                         PUFFS_MAKECRED(pcr, &auxt->pvfsr_cred);
 200
 201                         error = pops->puffs_fs_sync(pu,
 202                             auxt->pvfsr_waitfor, pcr);
 203                         break;
 204                 }
 205
 206                 case PUFFS_VFS_FHTOVP:
 207                 {
 208                         struct puffs_vfsmsg_fhtonode *auxt = auxbuf;
 209                         struct puffs_newinfo pni;
 210
 211                         pni.pni_cookie = &auxt->pvfsr_fhcookie;
 212                         pni.pni_vtype = &auxt->pvfsr_vtype;
 213                         pni.pni_size = &auxt->pvfsr_size;
 214                         pni.pni_rdev = &auxt->pvfsr_rdev;
 215
 216                         error = pops->puffs_fs_fhtonode(pu, auxt->pvfsr_data,
 217                             auxt->pvfsr_dsize, &pni);
 218
 219                         break;
 220                 }
 221
 222                 case PUFFS_VFS_VPTOFH:
 223                 {
 224                         struct puffs_vfsmsg_nodetofh *auxt = auxbuf;
 225
 226                         error = pops->puffs_fs_nodetofh(pu,
 227                             auxt->pvfsr_fhcookie, auxt->pvfsr_data,
 228                             &auxt->pvfsr_dsize);
 229
 230                         break;
 231                 }
 232
 233                 case PUFFS_VFS_SUSPEND:
 234                 {
 235                         struct puffs_vfsmsg_suspend *auxt = auxbuf;
 236
 237                         error = 0;
 238                         if (pops->puffs_fs_suspend == NULL)
 239                                 break;
 240
 241                         pops->puffs_fs_suspend(pu, auxt->pvfsr_status);
 242                         break;
 243                 }
 244
 245                 default:
 246                         /*
 247                          * I guess the kernel sees this one coming
 248                          */
 249                         error = EINVAL;
 250                         break;
 251                 }
 252
 253         /* XXX: audit return values */
 254         /* XXX: sync with kernel */
 255         } else if (PUFFSOP_OPCLASS(preq->preq_opclass) == PUFFSOP_VN) {
 256                 switch (preq->preq_optype) {
 257                 case PUFFS_VN_LOOKUP:
 258                 {
 259                         struct puffs_vnmsg_lookup *auxt = auxbuf;
 260                         struct puffs_newinfo pni;
 261                         struct puffs_cn pcn;
 262
 263                         pcn.pcn_pkcnp = &auxt->pvnr_cn;
 264                         PUFFS_KCREDTOCRED(pcn.pcn_cred, &auxt->pvnr_cn_cred);
 265                         pni.pni_cookie = &auxt->pvnr_newnode;
 266                         pni.pni_vtype = &auxt->pvnr_vtype;
 267                         pni.pni_size = &auxt->pvnr_size;
 268                         pni.pni_rdev = &auxt->pvnr_rdev;
 269
 270                         if (buildpath) {
 271                                 error = puffs_path_pcnbuild(pu, &pcn, opcookie);
 272                                 if (error)
 273                                         break;
 274                         }
 275
 276                         /* lookup *must* be present */
 277                         error = pops->puffs_node_lookup(pu, opcookie,
 278                             &pni, &pcn);
 279
 280                         if (buildpath) {
 281                                 if (error) {
 282                                         pu->pu_pathfree(pu, &pcn.pcn_po_full);
 283                                 } else {
 284                                         struct puffs_node *pn;
 285
 286                                         /*
 287                                          * did we get a new node or a
 288                                          * recycled node?
 289                                          */
 290                                         pn = PU_CMAP(pu, auxt->pvnr_newnode);
 291                                         if (pn->pn_po.po_path == NULL)
 292                                                 pn->pn_po = pcn.pcn_po_full;
 293                                         else
 294                                                 pu->pu_pathfree(pu,
 295                                                     &pcn.pcn_po_full);
 296                                 }
 297                         }
 298
 299                         break;
 300                 }
 301
 302                 case PUFFS_VN_CREATE:
 303                 {
 304                         struct puffs_vnmsg_create *auxt = auxbuf;
 305                         struct puffs_newinfo pni;
 306                         struct puffs_cn pcn;
 307
 308                         if (pops->puffs_node_create == NULL) {
 309                                 error = 0;
 310                                 break;
 311                         }
 312
 313                         pcn.pcn_pkcnp = &auxt->pvnr_cn;
 314                         PUFFS_KCREDTOCRED(pcn.pcn_cred, &auxt->pvnr_cn_cred);
 315
 316                         memset(&pni, 0, sizeof(pni));
 317                         pni.pni_cookie = &auxt->pvnr_newnode;
 318
 319                         if (buildpath) {
 320                                 error = puffs_path_pcnbuild(pu, &pcn, opcookie);
 321                                 if (error)
 322                                         break;
 323                         }
 324
 325                         error = pops->puffs_node_create(pu,
 326                             opcookie, &pni, &pcn, &auxt->pvnr_va);
 327
 328                         if (buildpath) {
 329                                 if (error) {
 330                                         pu->pu_pathfree(pu, &pcn.pcn_po_full);
 331                                 } else {
 332                                         struct puffs_node *pn;
 333
 334                                         pn = PU_CMAP(pu, auxt->pvnr_newnode);
 335                                         pn->pn_po = pcn.pcn_po_full;
 336                                 }
 337                         }
 338
 339                         break;
 340                 }
 341
 342                 case PUFFS_VN_MKNOD:
 343                 {
 344                         struct puffs_vnmsg_mknod *auxt = auxbuf;
 345                         struct puffs_newinfo pni;
 346                         struct puffs_cn pcn;
 347
 348                         if (pops->puffs_node_mknod == NULL) {
 349                                 error = 0;
 350                                 break;
 351                         }
 352
 353                         pcn.pcn_pkcnp = &auxt->pvnr_cn;
 354                         PUFFS_KCREDTOCRED(pcn.pcn_cred, &auxt->pvnr_cn_cred);
 355
 356                         memset(&pni, 0, sizeof(pni));
 357                         pni.pni_cookie = &auxt->pvnr_newnode;
 358
 359                         if (buildpath) {
 360                                 error = puffs_path_pcnbuild(pu, &pcn, opcookie);
 361                                 if (error)
 362                                         break;
 363                         }
 364
 365                         error = pops->puffs_node_mknod(pu,
 366                             opcookie, &pni, &pcn, &auxt->pvnr_va);
 367
 368                         if (buildpath) {
 369                                 if (error) {
 370                                         pu->pu_pathfree(pu, &pcn.pcn_po_full);
 371                                 } else {
 372                                         struct puffs_node *pn;
 373
 374                                         pn = PU_CMAP(pu, auxt->pvnr_newnode);
 375                                         pn->pn_po = pcn.pcn_po_full;
 376                                 }
 377                         }
 378
 379                         break;
 380                 }
 381
 382                 case PUFFS_VN_OPEN:
 383                 {
 384                         struct puffs_vnmsg_open *auxt = auxbuf;
 385                         PUFFS_MAKECRED(pcr, &auxt->pvnr_cred);
 386
 387                         if (pops->puffs_node_open == NULL) {
 388                                 error = 0;
 389                                 break;
 390                         }
 391
 392                         error = pops->puffs_node_open(pu,
 393                             opcookie, auxt->pvnr_mode, pcr);
 394                         break;
 395                 }
 396
 397                 case PUFFS_VN_CLOSE:
 398                 {
 399                         struct puffs_vnmsg_close *auxt = auxbuf;
 400                         PUFFS_MAKECRED(pcr, &auxt->pvnr_cred);
 401
 402                         if (pops->puffs_node_close == NULL) {
 403                                 error = 0;
 404                                 break;
 405                         }
 406
 407                         error = pops->puffs_node_close(pu,
 408                             opcookie, auxt->pvnr_fflag, pcr);
 409                         break;
 410                 }
 411
 412                 case PUFFS_VN_ACCESS:
 413                 {
 414                         struct puffs_vnmsg_access *auxt = auxbuf;
 415                         PUFFS_MAKECRED(pcr, &auxt->pvnr_cred);
 416
 417                         if (pops->puffs_node_access == NULL) {
 418                                 error = 0;
 419                                 break;
 420                         }
 421
 422                         error = pops->puffs_node_access(pu,
 423                             opcookie, auxt->pvnr_mode, pcr);
 424                         break;
 425                 }
 426
 427                 case PUFFS_VN_GETATTR:
 428                 {
 429                         struct puffs_vnmsg_getattr *auxt = auxbuf;
 430                         PUFFS_MAKECRED(pcr, &auxt->pvnr_cred);
 431
 432                         if (pops->puffs_node_getattr == NULL) {
 433                                 error = EOPNOTSUPP;
 434                                 break;
 435                         }
 436
 437                         error = pops->puffs_node_getattr(pu,
 438                             opcookie, &auxt->pvnr_va, pcr);
 439                         break;
 440                 }
 441
 442                 case PUFFS_VN_SETATTR:
 443                 {
 444                         struct puffs_vnmsg_setattr *auxt = auxbuf;
 445                         PUFFS_MAKECRED(pcr, &auxt->pvnr_cred);
 446
 447                         if (pops->puffs_node_setattr == NULL) {
 448                                 error = EOPNOTSUPP;
 449                                 break;
 450                         }
 451
 452                         error = pops->puffs_node_setattr(pu,
 453                             opcookie, &auxt->pvnr_va, pcr);
 454                         break;
 455                 }
 456
 457                 case PUFFS_VN_MMAP:
 458                 {
 459                         struct puffs_vnmsg_mmap *auxt = auxbuf;
 460                         PUFFS_MAKECRED(pcr, &auxt->pvnr_cred);
 461
 462                         if (pops->puffs_node_mmap == NULL) {
 463                                 error = 0;
 464                                 break;
 465                         }
 466
 467                         error = pops->puffs_node_mmap(pu,
 468                             opcookie, auxt->pvnr_prot, pcr);
 469                         break;
 470                 }
 471
 472                 case PUFFS_VN_FSYNC:
 473                 {
 474                         struct puffs_vnmsg_fsync *auxt = auxbuf;
 475                         PUFFS_MAKECRED(pcr, &auxt->pvnr_cred);
 476
 477                         if (pops->puffs_node_fsync == NULL) {
 478                                 error = 0;
 479                                 break;
 480                         }
 481
 482                         error = pops->puffs_node_fsync(pu, opcookie, pcr,
 483                             auxt->pvnr_flags, auxt->pvnr_offlo,
 484                             auxt->pvnr_offhi);
 485                         break;
 486                 }
 487
 488                 case PUFFS_VN_SEEK:
 489                 {
 490                         struct puffs_vnmsg_seek *auxt = auxbuf;
 491                         PUFFS_MAKECRED(pcr, &auxt->pvnr_cred);
 492
 493                         if (pops->puffs_node_seek == NULL) {
 494                                 error = 0;
 495                                 break;
 496                         }
 497
 498                         error = pops->puffs_node_seek(pu,
 499                             opcookie, auxt->pvnr_oldoff,
 500                             auxt->pvnr_newoff, pcr);
 501                         break;
 502                 }
 503
 504                 case PUFFS_VN_REMOVE:
 505                 {
 506                         struct puffs_vnmsg_remove *auxt = auxbuf;
 507                         struct puffs_cn pcn;
 508                         if (pops->puffs_node_remove == NULL) {
 509                                 error = 0;
 510                                 break;
 511                         }
 512
 513                         pcn.pcn_pkcnp = &auxt->pvnr_cn;
 514                         PUFFS_KCREDTOCRED(pcn.pcn_cred, &auxt->pvnr_cn_cred);
 515
 516                         error = pops->puffs_node_remove(pu,
 517                             opcookie, auxt->pvnr_cookie_targ, &pcn);
 518                         break;
 519                 }
 520
 521                 case PUFFS_VN_LINK:
 522                 {
 523                         struct puffs_vnmsg_link *auxt = auxbuf;
 524                         struct puffs_cn pcn;
 525                         if (pops->puffs_node_link == NULL) {
 526                                 error = 0;
 527                                 break;
 528                         }
 529
 530                         pcn.pcn_pkcnp = &auxt->pvnr_cn;
 531                         PUFFS_KCREDTOCRED(pcn.pcn_cred, &auxt->pvnr_cn_cred);
 532
 533                         if (buildpath) {
 534                                 error = puffs_path_pcnbuild(pu, &pcn, opcookie);
 535                                 if (error)
 536                                         break;
 537                         }
 538
 539                         error = pops->puffs_node_link(pu,
 540                             opcookie, auxt->pvnr_cookie_targ, &pcn);
 541                         if (buildpath)
 542                                 pu->pu_pathfree(pu, &pcn.pcn_po_full);
 543
 544                         break;
 545                 }
 546
 547                 case PUFFS_VN_RENAME:
 548                 {
 549                         struct puffs_vnmsg_rename *auxt = auxbuf;
 550                         struct puffs_cn pcn_src, pcn_targ;
 551                         struct puffs_node *pn_src;
 552
 553                         if (pops->puffs_node_rename == NULL) {
 554                                 error = 0;
 555                                 break;
 556                         }
 557
 558                         pcn_src.pcn_pkcnp = &auxt->pvnr_cn_src;
 559                         PUFFS_KCREDTOCRED(pcn_src.pcn_cred,
 560                             &auxt->pvnr_cn_src_cred);
 561
 562                         pcn_targ.pcn_pkcnp = &auxt->pvnr_cn_targ;
 563                         PUFFS_KCREDTOCRED(pcn_targ.pcn_cred,
 564                             &auxt->pvnr_cn_targ_cred);
 565
 566                         if (buildpath) {
 567                                 pn_src = auxt->pvnr_cookie_src;
 568                                 pcn_src.pcn_po_full = pn_src->pn_po;
 569
 570                                 error = puffs_path_pcnbuild(pu, &pcn_targ,
 571                                     auxt->pvnr_cookie_targdir);
 572                                 if (error)
 573                                         break;
 574                         }
 575
 576                         error = pops->puffs_node_rename(pu,
 577                             opcookie, auxt->pvnr_cookie_src,
 578                             &pcn_src, auxt->pvnr_cookie_targdir,
 579                             auxt->pvnr_cookie_targ, &pcn_targ);
 580
 581                         if (buildpath) {
 582                                 if (error) {
 583                                         pu->pu_pathfree(pu,
 584                                             &pcn_targ.pcn_po_full);
 585                                 } else {
 586                                         struct puffs_pathinfo pi;
 587                                         struct puffs_pathobj po_old;
 588
 589                                         /* handle this node */
 590                                         po_old = pn_src->pn_po;
 591                                         pn_src->pn_po = pcn_targ.pcn_po_full;
 592
 593                                         if (pn_src->pn_va.va_type != VDIR) {
 594                                                 pu->pu_pathfree(pu, &po_old);
 595                                                 break;
 596                                         }
 597
 598                                         /* handle all child nodes for DIRs */
 599                                         pi.pi_old = &pcn_src.pcn_po_full;
 600                                         pi.pi_new = &pcn_targ.pcn_po_full;
 601
 602                                         PU_LOCK();
 603                                         if (puffs_pn_nodewalk(pu,
 604                                             puffs_path_prefixadj, &pi) != NULL)
 605                                                 error = ENOMEM;
 606                                         PU_UNLOCK();
 607                                         pu->pu_pathfree(pu, &po_old);
 608                                 }
 609                         }
 610                         break;
 611                 }
 612
 613                 case PUFFS_VN_MKDIR:
 614                 {
 615                         struct puffs_vnmsg_mkdir *auxt = auxbuf;
 616                         struct puffs_newinfo pni;
 617                         struct puffs_cn pcn;
 618
 619                         if (pops->puffs_node_mkdir == NULL) {
 620                                 error = 0;
 621                                 break;
 622                         }
 623
 624                         pcn.pcn_pkcnp = &auxt->pvnr_cn;
 625                         PUFFS_KCREDTOCRED(pcn.pcn_cred, &auxt->pvnr_cn_cred);
 626
 627                         memset(&pni, 0, sizeof(pni));
 628                         pni.pni_cookie = &auxt->pvnr_newnode;
 629
 630                         if (buildpath) {
 631                                 error = puffs_path_pcnbuild(pu, &pcn, opcookie);
 632                                 if (error)
 633                                         break;
 634                         }
 635
 636                         error = pops->puffs_node_mkdir(pu,
 637                             opcookie, &pni, &pcn, &auxt->pvnr_va);
 638
 639                         if (buildpath) {
 640                                 if (error) {
 641                                         pu->pu_pathfree(pu, &pcn.pcn_po_full);
 642                                 } else {
 643                                         struct puffs_node *pn;
 644
 645                                         pn = PU_CMAP(pu, auxt->pvnr_newnode);
 646                                         pn->pn_po = pcn.pcn_po_full;
 647                                 }
 648                         }
 649
 650                         break;
 651                 }
 652
 653                 case PUFFS_VN_RMDIR:
 654                 {
 655                         struct puffs_vnmsg_rmdir *auxt = auxbuf;
 656                         struct puffs_cn pcn;
 657                         if (pops->puffs_node_rmdir == NULL) {
 658                                 error = 0;
 659                                 break;
 660                         }
 661
 662                         pcn.pcn_pkcnp = &auxt->pvnr_cn;
 663                         PUFFS_KCREDTOCRED(pcn.pcn_cred, &auxt->pvnr_cn_cred);
 664
 665                         error = pops->puffs_node_rmdir(pu,
 666                             opcookie, auxt->pvnr_cookie_targ, &pcn);
 667                         break;
 668                 }
 669
 670                 case PUFFS_VN_SYMLINK:
 671                 {
 672                         struct puffs_vnmsg_symlink *auxt = auxbuf;
 673                         struct puffs_newinfo pni;
 674                         struct puffs_cn pcn;
 675
 676                         if (pops->puffs_node_symlink == NULL) {
 677                                 error = 0;
 678                                 break;
 679                         }
 680
 681                         pcn.pcn_pkcnp = &auxt->pvnr_cn;
 682                         PUFFS_KCREDTOCRED(pcn.pcn_cred, &auxt->pvnr_cn_cred);
 683
 684                         memset(&pni, 0, sizeof(pni));
 685                         pni.pni_cookie = &auxt->pvnr_newnode;
 686
 687                         if (buildpath) {
 688                                 error = puffs_path_pcnbuild(pu, &pcn, opcookie);
 689                                 if (error)
 690                                         break;
 691                         }
 692
 693                         error = pops->puffs_node_symlink(pu,
 694                             opcookie, &pni, &pcn,
 695                             &auxt->pvnr_va, auxt->pvnr_link);
 696
 697                         if (buildpath) {
 698                                 if (error) {
 699                                         pu->pu_pathfree(pu, &pcn.pcn_po_full);
 700                                 } else {
 701                                         struct puffs_node *pn;
 702
 703                                         pn = PU_CMAP(pu, auxt->pvnr_newnode);
 704                                         pn->pn_po = pcn.pcn_po_full;
 705                                 }
 706                         }
 707
 708                         break;
 709                 }
 710
 711                 case PUFFS_VN_READDIR:
 712                 {
 713                         struct puffs_vnmsg_readdir *auxt = auxbuf;
 714                         PUFFS_MAKECRED(pcr, &auxt->pvnr_cred);
 715                         struct dirent *dent;
 716                         off_t *cookies;
 717                         size_t res, origcookies;
 718
 719                         if (pops->puffs_node_readdir == NULL) {
 720                                 error = 0;
 721                                 break;
 722                         }
 723
 724                         if (auxt->pvnr_ncookies) {
 725                                 /* LINTED: pvnr_data is __aligned() */
 726                                 cookies = (off_t *)auxt->pvnr_data;
 727                                 origcookies = auxt->pvnr_ncookies;
 728                         } else {
 729                                 cookies = NULL;
 730                                 origcookies = 0;
 731                         }
 732                         /* LINTED: dentoff is aligned in the kernel */
 733                         dent = (struct dirent *)
 734                             (auxt->pvnr_data + auxt->pvnr_dentoff);
 735
 736                         res = auxt->pvnr_resid;
 737                         error = pops->puffs_node_readdir(pu,
 738                             opcookie, dent, &auxt->pvnr_offset,
 739                             &auxt->pvnr_resid, pcr, &auxt->pvnr_eofflag,
 740                             cookies, &auxt->pvnr_ncookies);
 741
 742                         /* much easier to track non-working NFS */
 743                         assert(auxt->pvnr_ncookies <= origcookies);
 744
 745                         /* need to move a bit more */
 746                         preq->preq_buflen = sizeof(struct puffs_vnmsg_readdir)
 747                             + auxt->pvnr_dentoff + (res - auxt->pvnr_resid);
 748                         break;
 749                 }
 750
 751                 case PUFFS_VN_READLINK:
 752                 {
 753                         struct puffs_vnmsg_readlink *auxt = auxbuf;
 754                         PUFFS_MAKECRED(pcr, &auxt->pvnr_cred);
 755
 756                         if (pops->puffs_node_readlink == NULL) {
 757                                 error = EOPNOTSUPP;
 758                                 break;
 759                         }
 760
 761                         /*LINTED*/
 762                         error = pops->puffs_node_readlink(pu, opcookie, pcr,
 763                             auxt->pvnr_link, &auxt->pvnr_linklen);
 764                         break;
 765                 }
 766
 767                 case PUFFS_VN_RECLAIM:
 768                 {
 769
 770                         if (pops->puffs_node_reclaim == NULL) {
 771                                 error = 0;
 772                                 break;
 773                         }
 774
 775                         error = pops->puffs_node_reclaim(pu, opcookie);
 776                         break;
 777                 }
 778
 779                 case PUFFS_VN_INACTIVE:
 780                 {
 781
 782                         if (pops->puffs_node_inactive == NULL) {
 783                                 error = EOPNOTSUPP;
 784                                 break;
 785                         }
 786
 787                         error = pops->puffs_node_inactive(pu, opcookie);
 788                         break;
 789                 }
 790
 791                 case PUFFS_VN_PATHCONF:
 792                 {
 793                         struct puffs_vnmsg_pathconf *auxt = auxbuf;
 794                         if (pops->puffs_node_pathconf == NULL) {
 795                                 error = 0;
 796                                 break;
 797                         }
 798
 799                         error = pops->puffs_node_pathconf(pu,
 800                             opcookie, auxt->pvnr_name,
 801                             &auxt->pvnr_retval);
 802                         break;
 803                 }
 804
 805                 case PUFFS_VN_ADVLOCK:
 806                 {
 807                         struct puffs_vnmsg_advlock *auxt = auxbuf;
 808                         if (pops->puffs_node_advlock == NULL) {
 809                                 error = 0;
 810                                 break;
 811                         }
 812
 813                         error = pops->puffs_node_advlock(pu,
 814                             opcookie, auxt->pvnr_id, auxt->pvnr_op,
 815                             &auxt->pvnr_fl, auxt->pvnr_flags);
 816                         break;
 817                 }
 818
 819                 case PUFFS_VN_PRINT:
 820                 {
 821                         if (pops->puffs_node_print == NULL) {
 822                                 error = 0;
 823                                 break;
 824                         }
 825
 826                         error = pops->puffs_node_print(pu,
 827                             opcookie);
 828                         break;
 829                 }
 830
 831                 case PUFFS_VN_ABORTOP:
 832                 {
 833                         struct puffs_vnmsg_abortop *auxt = auxbuf;
 834                         struct puffs_cn pcn;
 835
 836                         if (pops->puffs_node_abortop == NULL) {
 837                                 error = 0;
 838                                 break;
 839                         }
 840
 841                         pcn.pcn_pkcnp = &auxt->pvnr_cn;
 842                         PUFFS_KCREDTOCRED(pcn.pcn_cred, &auxt->pvnr_cn_cred);
 843
 844                         error = pops->puffs_node_abortop(pu, opcookie, &pcn);
 845
 846                         break;
 847                 }
 848
 849                 case PUFFS_VN_READ:
 850                 {
 851                         struct puffs_vnmsg_read *auxt = auxbuf;
 852                         PUFFS_MAKECRED(pcr, &auxt->pvnr_cred);
 853                         size_t res;
 854
 855                         if (pops->puffs_node_read == NULL) {
 856                                 error = EIO;
 857                                 break;
 858                         }
 859
 860                         res = auxt->pvnr_resid;
 861                         error = pops->puffs_node_read(pu,
 862                             opcookie, auxt->pvnr_data,
 863                             auxt->pvnr_offset, &auxt->pvnr_resid,
 864                             pcr, auxt->pvnr_ioflag);
 865
 866                         /* need to move a bit more */
 867                         preq->preq_buflen = sizeof(struct puffs_vnmsg_read)
 868                             + (res - auxt->pvnr_resid);
 869                         break;
 870                 }
 871
 872                 case PUFFS_VN_WRITE:
 873                 {
 874                         struct puffs_vnmsg_write *auxt = auxbuf;
 875                         PUFFS_MAKECRED(pcr, &auxt->pvnr_cred);
 876
 877                         if (pops->puffs_node_write == NULL) {
 878                                 error = EIO;
 879                                 break;
 880                         }
 881
 882                         error = pops->puffs_node_write(pu,
 883                             opcookie, auxt->pvnr_data,
 884                             auxt->pvnr_offset, &auxt->pvnr_resid,
 885                             pcr, auxt->pvnr_ioflag);
 886
 887                         /* don't need to move data back to the kernel */
 888                         preq->preq_buflen = sizeof(struct puffs_vnmsg_write);
 889                         break;
 890                 }
 891
 892                 case PUFFS_VN_POLL:
 893                 {
 894                         struct puffs_vnmsg_poll *auxt = auxbuf;
 895
 896                         if (pops->puffs_node_poll == NULL) {
 897                                 error = 0;
 898
 899                                 /* emulate genfs_poll() */
 900                                 auxt->pvnr_events &= (POLLIN | POLLOUT
 901                                                     | POLLRDNORM | POLLWRNORM);
 902
 903                                 break;
 904                         }
 905
 906                         error = pops->puffs_node_poll(pu,
 907                             opcookie, &auxt->pvnr_events);
 908                         break;
 909                 }
 910
 911                 default:
 912                         printf("inval op %d\n", preq->preq_optype);
 913                         error = EINVAL;
 914                         break;
 915                 }
 916
 917 #if 0
 918         /* not issued by kernel currently */
 919         } else if (PUFFSOP_OPCLASS(preq->preq_opclass) == PUFFSOP_CACHE) {
 920                 struct puffs_cacheinfo *pci = (void *)preq;
 921
 922                 if (pu->pu_ops.puffs_cache_write) {
 923                         pu->pu_ops.puffs_cache_write(pu, preq->preq_cookie,
 924                             pci->pcache_nruns, pci->pcache_runs);
 925                 }
 926                 error = 0;
 927 #endif
 928
 929         } else if (PUFFSOP_OPCLASS(preq->preq_opclass) == PUFFSOP_ERROR) {
 930                 struct puffs_error *perr = (void *)preq;
 931
 932                 pu->pu_errnotify(pu, preq->preq_optype,
 933                     perr->perr_error, perr->perr_str, preq->preq_cookie);
 934                 error = 0;
 935         } else {
 936                 /*
 937                  * I guess the kernel sees this one coming also
 938                  */
 939                 error = EINVAL;
 940         }
 941
 942  out:
 943         preq->preq_rv = error;
 944
 945         if (pu->pu_oppost)
 946                 pu->pu_oppost(pu);
 947
 948         pcc->pcc_flags |= PCC_DONE;
 949 }