sys/vfs/userfs/userfs_vnops.c

   1 /*
   2  * Copyright (c) 2007 The DragonFly Project.  All rights reserved.
   3  *
   4  * This code is derived from software contributed to The DragonFly Project
   5  * by Matthew Dillon <dillon@backplane.com>
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  *
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in
  15  *    the documentation and/or other materials provided with the
  16  *    distribution.
  17  * 3. Neither the name of The DragonFly Project nor the names of its
  18  *    contributors may be used to endorse or promote products derived
  19  *    from this software without specific, prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  22  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  23  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  24  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
  25  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  26  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
  27  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  28  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  29  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  30  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  31  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  32  * SUCH DAMAGE.
  33  *
  34  * $DragonFly: src/sys/vfs/userfs/userfs_vnops.c,v 1.4 2007/11/20 21:03:51 dillon Exp $
  35  */
  36
  37 #include <sys/param.h>
  38 #include <sys/systm.h>
  39 #include <sys/kernel.h>
  40 #include <sys/fcntl.h>
  41 #include <sys/namecache.h>
  42 #include <sys/vnode.h>
  43 #include <sys/lockf.h>
  44 #include <sys/event.h>
  45 #include <sys/stat.h>
  46 #include <sys/syslink.h>
  47 #include <sys/syslink_vfs.h>
  48 #include <sys/unistd.h>
  49 #include <vm/vnode_pager.h>
  50 #include "userfs.h"
  51
  52 /*
  53  * USERFS VNOPS
  54  */
  55 /*static int user_vop_vnoperate(struct vop_generic_args *);*/
  56 static int user_vop_fsync (struct vop_fsync_args *);
  57 static int user_vop_read (struct vop_read_args *);
  58 static int user_vop_write (struct vop_write_args *);
  59 static int user_vop_access (struct vop_access_args *);
  60 static int user_vop_advlock (struct vop_advlock_args *);
  61 static int user_vop_close (struct vop_close_args *);
  62 static int user_vop_ncreate (struct vop_ncreate_args *);
  63 static int user_vop_getattr (struct vop_getattr_args *);
  64 static int user_vop_nresolve (struct vop_nresolve_args *);
  65 static int user_vop_nlookupdotdot (struct vop_nlookupdotdot_args *);
  66 static int user_vop_nlink (struct vop_nlink_args *);
  67 static int user_vop_nmkdir (struct vop_nmkdir_args *);
  68 static int user_vop_nmknod (struct vop_nmknod_args *);
  69 static int user_vop_open (struct vop_open_args *);
  70 static int user_vop_pathconf (struct vop_pathconf_args *);
  71 static int user_vop_print (struct vop_print_args *);
  72 static int user_vop_readdir (struct vop_readdir_args *);
  73 static int user_vop_readlink (struct vop_readlink_args *);
  74 static int user_vop_nremove (struct vop_nremove_args *);
  75 static int user_vop_nrename (struct vop_nrename_args *);
  76 static int user_vop_nrmdir (struct vop_nrmdir_args *);
  77 static int user_vop_setattr (struct vop_setattr_args *);
  78 static int user_vop_strategy (struct vop_strategy_args *);
  79 static int user_vop_nsymlink (struct vop_nsymlink_args *);
  80 static int user_vop_nwhiteout (struct vop_nwhiteout_args *);
  81 static int user_vop_bmap (struct vop_bmap_args *);
  82
  83 struct vop_ops userfs_vnode_vops = {
  84         .vop_default =          vop_defaultop,
  85         .vop_fsync =            user_vop_fsync,
  86         .vop_getpages =         vop_stdgetpages,
  87         .vop_putpages =         vop_stdputpages,
  88         .vop_read =             user_vop_read,
  89         .vop_write =            user_vop_write,
  90         .vop_access =           user_vop_access,
  91         .vop_advlock =          user_vop_advlock,
  92         .vop_close =            user_vop_close,
  93         .vop_ncreate =          user_vop_ncreate,
  94         .vop_getattr =          user_vop_getattr,
  95         .vop_inactive =         user_vop_inactive,
  96         .vop_reclaim =          user_vop_reclaim,
  97         .vop_nresolve =         user_vop_nresolve,
  98         .vop_nlookupdotdot =    user_vop_nlookupdotdot,
  99         .vop_nlink =            user_vop_nlink,
 100         .vop_nmkdir =           user_vop_nmkdir,
 101         .vop_nmknod =           user_vop_nmknod,
 102         .vop_open =             user_vop_open,
 103         .vop_pathconf =         user_vop_pathconf,
 104         .vop_print =            user_vop_print,
 105         .vop_readdir =          user_vop_readdir,
 106         .vop_readlink =         user_vop_readlink,
 107         .vop_nremove =          user_vop_nremove,
 108         .vop_nrename =          user_vop_nrename,
 109         .vop_nrmdir =           user_vop_nrmdir,
 110         .vop_setattr =          user_vop_setattr,
 111         .vop_strategy =         user_vop_strategy,
 112         .vop_nsymlink =         user_vop_nsymlink,
 113         .vop_nwhiteout =        user_vop_nwhiteout,
 114         .vop_bmap =             user_vop_bmap
 115 };
 116
 117 #if 0
 118 static
 119 int
 120 user_vop_vnoperate(struct vop_generic_args *)
 121 {
 122         return (VOCALL(&userfs_vnode_vops, ap));
 123 }
 124 #endif
 125
 126 /*
 127  * vop_fsync(struct vnode *vp, int waitfor)
 128  */
 129 static
 130 int
 131 user_vop_fsync (struct vop_fsync_args *ap)
 132 {
 133         struct user_mount *ump;
 134         struct user_inode *ip;
 135         struct vnode *vp;
 136         struct slmsg *slmsg;
 137         syslink_elm_t par;
 138         int error;
 139
 140         vp = ap->a_vp;
 141         ip = vp->v_data;
 142         ump = ip->ump;
 143
 144         slmsg = syslink_kallocmsg();
 145         par = sl_msg_init_cmd(slmsg->msg, SMPROTO_BSDVFS,
 146                               SLVFS_CMD_VOP_FSYNC);
 147         user_elm_push_vnode(par, ap->a_vp);
 148         sl_msg_fini(slmsg->msg);
 149
 150         kprintf("userfs_fsync\n");
 151         if ((error = syslink_kdomsg(ump->sldesc, slmsg)) == 0) {
 152                 par = &slmsg->rep->msg->sm_head;
 153
 154                 if (par->se_cmd == (SLVFS_CMD_VOP_FSYNC|SE_CMDF_REPLY)) {
 155                         ;
 156                 } else {
 157                         error = EBADRPC;
 158                 }
 159         }
 160         syslink_kfreemsg(ump->sldesc, slmsg);
 161         kprintf("error %d\n", error);
 162         return(error);
 163 }
 164
 165 /*
 166  * vop_read(struct vnode *vp, struct uio *uio, int ioflag, struct ucred *cred)
 167  */
 168 static
 169 int
 170 user_vop_read (struct vop_read_args *ap)
 171 {
 172         struct user_mount *ump;
 173         struct user_inode *ip;
 174         struct vnode *vp;
 175         struct uio *uio;
 176         struct buf *bp;
 177         int error;
 178         int offset;
 179         int n;
 180
 181         vp = ap->a_vp;
 182         ip = vp->v_data;
 183         ump = ip->ump;
 184         uio = ap->a_uio;
 185
 186         if (uio->uio_offset < 0)
 187                 return (EINVAL);
 188         if (vp->v_type != VREG)
 189                 return (EINVAL);
 190
 191         kprintf("userfs_read\n");
 192         error = 0;
 193         while (uio->uio_resid > 0 && uio->uio_offset < ip->filesize) {
 194                 /*
 195                  * Use buffer cache I/O (via user_vop_strategy), aligned
 196                  * on USERFS_BSIZE boundaries.
 197                  */
 198                 offset = (int)uio->uio_offset & USERFS_BMASK;
 199                 error = bread(vp, uio->uio_offset - offset, USERFS_BSIZE, &bp);
 200                 if (error) {
 201                         brelse(bp);
 202                         break;
 203                 }
 204
 205                 /*
 206                  * Figure out how many bytes we can actually copy this loop.
 207                  */
 208                 n = USERFS_BSIZE - offset;
 209                 if (n > uio->uio_resid)
 210                         n = uio->uio_resid;
 211                 if (n > ip->filesize - uio->uio_offset)
 212                         n = (int)(ip->filesize - uio->uio_offset);
 213
 214                 error = uiomove((char *)bp->b_data + offset, n, uio);
 215                 bqrelse(bp);
 216                 if (error)
 217                         break;
 218         }
 219         kprintf("userfs_read error %d\n", error);
 220         return(error);
 221 }
 222
 223 /*
 224  * vop_write(struct vnode *vp, struct uio *uio, int ioflag, struct ucred *cred)
 225  */
 226 static
 227 int
 228 user_vop_write (struct vop_write_args *ap)
 229 {
 230         struct user_mount *ump;
 231         struct user_inode *ip;
 232         struct vnode *vp;
 233         struct buf *bp;
 234         struct uio *uio;
 235         int error;
 236         off_t loffset;
 237         size_t offset;
 238         size_t n;
 239
 240         vp = ap->a_vp;
 241         ip = vp->v_data;
 242         ump = ip->ump;
 243         uio = ap->a_uio;
 244
 245         if (vp->v_type != VREG)
 246                 return (EINVAL);
 247         if (ap->a_ioflag & IO_APPEND)
 248                 uio->uio_offset = ip->filesize;
 249
 250         /*
 251          * Check for illegal write offsets.  Valid range is 0...2^63-1
 252          */
 253         loffset = uio->uio_offset;
 254         if (loffset < 0)
 255                 return (EFBIG);
 256         if (uio->uio_resid) {
 257                 /* GCC4 - workaround optimization */
 258                 loffset += uio->uio_resid;
 259                 if (loffset <= 0)
 260                         return (EFBIG);
 261         }
 262
 263         kprintf("userfs_write\n");
 264         error = 0;
 265         while (uio->uio_resid > 0) {
 266                 /*
 267                  * Use buffer cache I/O (via user_vop_strategy), aligned
 268                  * on USERFS_BSIZE boundaries.
 269                  *
 270                  * XXX not optimized for complete write-overs or file
 271                  * extensions.  Note: must bread on UIO_NOCOPY writes.
 272                  *
 273                  * XXX No need to read if strictly appending.
 274                  */
 275                 offset = (size_t)uio->uio_offset & USERFS_BMASK;
 276                 /* if offset == ip->filesize use getblk instead */
 277                 error = bread(vp, uio->uio_offset - offset, USERFS_BSIZE, &bp);
 278                 if (error) {
 279                         brelse(bp);
 280                         break;
 281                 }
 282
 283                 /*
 284                  * Figure out how many bytes we can actually copy this loop.
 285                  */
 286                 n = USERFS_BSIZE - offset;
 287                 if (n > uio->uio_resid)
 288                         n = uio->uio_resid;
 289                 if (n > ip->filesize - uio->uio_offset)
 290                         n = (size_t)(ip->filesize - uio->uio_offset);
 291
 292                 error = uiomove((char *)bp->b_data + offset, n, uio);
 293                 if (error) {
 294                         brelse(bp);
 295                         break;
 296                 }
 297
 298                 /*
 299                  * Extend the file's size if necessary
 300                  */
 301                 if (ip->filesize < uio->uio_offset)
 302                         ip->filesize = uio->uio_offset;
 303
 304                 /*
 305                  * The data has been loaded into the buffer, write it out.
 306                  */
 307                 if (ap->a_ioflag & IO_SYNC) {
 308                         bwrite(bp);
 309                 } else if (ap->a_ioflag & IO_DIRECT) {
 310                         bp->b_flags |= B_CLUSTEROK;
 311                         bawrite(bp);
 312                 } else {
 313                         bp->b_flags |= B_CLUSTEROK;
 314                         bdwrite(bp);
 315                 }
 316         }
 317         kprintf("userfs_write error %d\n", error);
 318         return(error);
 319 }
 320
 321 /*
 322  * vop_access(struct vnode *vp, int mode, struct ucred *cred)
 323  */
 324 static
 325 int
 326 user_vop_access (struct vop_access_args *ap)
 327 {
 328         struct user_mount *ump;
 329         struct user_inode *ip;
 330         struct vnode *vp;
 331         struct slmsg *slmsg;
 332         syslink_elm_t par;
 333         int error;
 334
 335         vp = ap->a_vp;
 336         ip = vp->v_data;
 337         ump = ip->ump;
 338
 339         slmsg = syslink_kallocmsg();
 340         par = sl_msg_init_cmd(slmsg->msg, SMPROTO_BSDVFS,
 341                               SLVFS_CMD_VOP_ACCESS);
 342         user_elm_push_vnode(par, vp);
 343         user_elm_push_mode(par, ap->a_mode);
 344         user_elm_push_cred(par, ap->a_cred);
 345         sl_msg_fini(slmsg->msg);
 346
 347         /*
 348          * Issue the request and do basic validation of the response
 349          */
 350         kprintf("userfs_access\n");
 351         if ((error = syslink_kdomsg(ump->sldesc, slmsg)) != 0)
 352                 goto done;
 353         par = &slmsg->rep->msg->sm_head;
 354         if (par->se_cmd != (SLVFS_CMD_VOP_ACCESS|SE_CMDF_REPLY)) {
 355                 error = EBADRPC;
 356                 goto done;
 357         }
 358
 359 done:
 360         syslink_kfreemsg(ump->sldesc, slmsg);
 361         kprintf("error %d\n", error);
 362         return(error);
 363 }
 364
 365 /*
 366  * vop_advlock(struct vnode *vp, caddr_t id, int op, struct flock *fl,
 367  *             int flags)
 368  *
 369  * This vop is handled directly by the kernel.
 370  */
 371 static
 372 int
 373 user_vop_advlock (struct vop_advlock_args *ap)
 374 {
 375         struct user_inode *ip;
 376         struct vnode *vp;
 377
 378         vp = ap->a_vp;
 379         ip = vp->v_data;
 380
 381         return (lf_advlock(ap, &ip->lockf, ip->filesize));
 382 }
 383
 384 /*
 385  * vop_open(struct vnode *vp, int mode, struct ucred *cred, struct file *file)
 386  *
 387  * This vop is handled directly by the kernel.
 388  */
 389 static
 390 int
 391 user_vop_open (struct vop_open_args *ap)
 392 {
 393         return (vop_stdopen(ap));
 394 }
 395
 396 /*
 397  * vop_close(struct vnode *vp, int fflag)
 398  *
 399  * This vop is handled directly by the kernel.
 400  */
 401 static
 402 int
 403 user_vop_close (struct vop_close_args *ap)
 404 {
 405         return (vop_stdclose(ap));
 406 }
 407
 408 /*
 409  * vop_getattr(struct vnode *vp, struct vattr *vap)
 410  */
 411 static
 412 int
 413 user_vop_getattr (struct vop_getattr_args *ap)
 414 {
 415         struct user_mount *ump;
 416         struct user_inode *ip;
 417         struct vnode *vp;
 418         struct slmsg *slmsg;
 419         syslink_elm_t par;
 420         syslink_elm_t elm;
 421         int error;
 422
 423         vp = ap->a_vp;
 424         ip = vp->v_data;
 425         ump = ip->ump;
 426
 427         slmsg = syslink_kallocmsg();
 428         par = sl_msg_init_cmd(slmsg->msg, SMPROTO_BSDVFS,
 429                               SLVFS_CMD_VOP_GETATTR);
 430         sl_msg_fini(slmsg->msg);
 431
 432         kprintf("userfs_getattr\n");
 433         if ((error = syslink_kdomsg(ump->sldesc, slmsg)) != 0)
 434                 goto done;
 435         par = &slmsg->rep->msg->sm_head;
 436         if (par->se_cmd != (SLVFS_CMD_VOP_GETATTR|SE_CMDF_REPLY)) {
 437                 error = EBADRPC;
 438                 goto done;
 439         }
 440
 441         /*
 442          * Parse reply content
 443          */
 444         SL_FOREACH_ELEMENT(par, elm) {
 445                 switch(elm->se_cmd) {
 446                 case SLVFS_ELM_VATTR:
 447                         error = user_elm_parse_vattr(elm, ap->a_vap);
 448                         break;
 449                 default:
 450                         break;
 451                 }
 452                 if (error)
 453                         break;
 454         }
 455 done:
 456         syslink_kfreemsg(ump->sldesc, slmsg);
 457         kprintf("error %d\n", error);
 458         return(error);
 459 }
 460
 461 /*
 462  * vop_pathconf(int name, int *retval)
 463  *
 464  * This vop is handled directly by the kernel.
 465  */
 466 static
 467 int
 468 user_vop_pathconf (struct vop_pathconf_args *ap)
 469 {
 470         int error = 0;
 471
 472         switch(ap->a_name) {
 473         case _PC_LINK_MAX:
 474                 *ap->a_retval = LINK_MAX;
 475                 break;
 476         case _PC_MAX_CANON:
 477                 *ap->a_retval = MAX_CANON;
 478                 break;
 479         case _PC_MAX_INPUT:
 480                 *ap->a_retval = MAX_INPUT;
 481                 break;
 482         case _PC_PIPE_BUF:
 483                 *ap->a_retval = PIPE_BUF;
 484                 break;
 485         case _PC_CHOWN_RESTRICTED:
 486                 *ap->a_retval = 1;
 487                 break;
 488         case _PC_VDISABLE:
 489                 *ap->a_retval = _POSIX_VDISABLE;
 490                 break;
 491         default:
 492                 error = EINVAL;
 493                 break;
 494         }
 495         return (error);
 496 }
 497
 498 /*
 499  * vop_print(int name, int *retval)
 500  *
 501  * This vop is handled directly by the kernel.
 502  */
 503 static
 504 int
 505 user_vop_print (struct vop_print_args *ap)
 506 {
 507         return(0);
 508 }
 509
 510 /*
 511  * vop_readdir(struct vnode *vp, struct uio *uio, struct ucred *cred,
 512  *             int *eofflag, int *ncookies, off_t **a_cookies)
 513  */
 514 static
 515 int
 516 user_vop_readdir (struct vop_readdir_args *ap)
 517 {
 518         struct user_mount *ump;
 519         struct user_inode *ip;
 520         struct vnode *vp;
 521         struct slmsg *slmsg;
 522         syslink_elm_t par;
 523         int error;
 524
 525         vp = ap->a_vp;
 526         ip = vp->v_data;
 527         ump = ip->ump;
 528
 529         slmsg = syslink_kallocmsg();
 530         par = sl_msg_init_cmd(slmsg->msg, SMPROTO_BSDVFS,
 531                               SLVFS_CMD_VOP_READDIR);
 532         sl_msg_fini(slmsg->msg);
 533
 534         kprintf("userfs_readdir\n");
 535         if ((error = syslink_kdomsg(ump->sldesc, slmsg)) == 0) {
 536                 par = &slmsg->rep->msg->sm_head;
 537
 538                 if (par->se_cmd == (SLVFS_CMD_VOP_READDIR|SE_CMDF_REPLY)) {
 539                         ;
 540                 } else {
 541                         error = EBADRPC;
 542                 }
 543         }
 544         syslink_kfreemsg(ump->sldesc, slmsg);
 545         kprintf("error %d\n", error);
 546         return(error);
 547 }
 548
 549 /*
 550  * vop_readlink(struct vnode *vp, struct uio *uio, struct ucred *cred)
 551  */
 552 static
 553 int
 554 user_vop_readlink (struct vop_readlink_args *ap)
 555 {
 556         struct user_mount *ump;
 557         struct user_inode *ip;
 558         struct vnode *vp;
 559         struct slmsg *slmsg;
 560         syslink_elm_t par;
 561         int error;
 562
 563         vp = ap->a_vp;
 564         ip = vp->v_data;
 565         ump = ip->ump;
 566
 567         slmsg = syslink_kallocmsg();
 568         par = sl_msg_init_cmd(slmsg->msg, SMPROTO_BSDVFS,
 569                               SLVFS_CMD_VOP_READLINK);
 570         sl_msg_fini(slmsg->msg);
 571
 572         kprintf("userfs_readlink\n");
 573         if ((error = syslink_kdomsg(ump->sldesc, slmsg)) == 0) {
 574                 par = &slmsg->rep->msg->sm_head;
 575
 576                 if (par->se_cmd == (SLVFS_CMD_VOP_READLINK|SE_CMDF_REPLY)) {
 577                         ;
 578                 } else {
 579                         error = EBADRPC;
 580                 }
 581         }
 582         syslink_kfreemsg(ump->sldesc, slmsg);
 583         kprintf("error %d\n", error);
 584         return(error);
 585 }
 586
 587 /*
 588  * vop_setattr(struct vnode *vp, struct vattr *vap, struct ucred *cred)
 589  */
 590 static
 591 int
 592 user_vop_setattr (struct vop_setattr_args *ap)
 593 {
 594         struct user_mount *ump;
 595         struct user_inode *ip;
 596         struct vnode *vp;
 597         struct slmsg *slmsg;
 598         syslink_elm_t par;
 599         int error;
 600
 601         vp = ap->a_vp;
 602         ip = vp->v_data;
 603         ump = ip->ump;
 604
 605         slmsg = syslink_kallocmsg();
 606         par = sl_msg_init_cmd(slmsg->msg, SMPROTO_BSDVFS,
 607                               SLVFS_CMD_VOP_SETATTR);
 608         sl_msg_fini(slmsg->msg);
 609
 610         kprintf("userfs_setattr\n");
 611         if ((error = syslink_kdomsg(ump->sldesc, slmsg)) == 0) {
 612                 par = &slmsg->rep->msg->sm_head;
 613
 614                 if (par->se_cmd == (SLVFS_CMD_VOP_SETATTR|SE_CMDF_REPLY)) {
 615                         ;
 616                 } else {
 617                         error = EBADRPC;
 618                 }
 619         }
 620         syslink_kfreemsg(ump->sldesc, slmsg);
 621         kprintf("error %d\n", error);
 622         return(error);
 623 }
 624
 625 /*
 626  * user_vop_strategy() - I/O strategy routine.
 627  *
 628  * Note that userfs interfaces fake-up BMAP so the strategy call just
 629  * uses the passed bio instead of pushing a bio to get to the (faked)
 630  * device block cache.
 631  */
 632 static void user_strategy_callback(struct slmsg *msg, void *arg, int error);
 633
 634 static
 635 int
 636 user_vop_strategy (struct vop_strategy_args *ap)
 637 {
 638         struct user_mount *ump;
 639         struct user_inode *ip;
 640         struct vnode *vp;
 641         struct bio *bio;
 642         struct buf *bp;
 643         struct slmsg *slmsg;
 644         syslink_elm_t par;
 645         int error;
 646
 647         vp = ap->a_vp;
 648         ip = vp->v_data;
 649         ump = ip->ump;
 650         bio = ap->a_bio;
 651         bp = bio->bio_buf;
 652
 653         bio->bio_driver_info = ump;
 654
 655         slmsg = syslink_kallocmsg();
 656         switch(bp->b_cmd) {
 657         case BUF_CMD_READ:
 658                 par = sl_msg_init_cmd(slmsg->msg, SMPROTO_BSDVFS,
 659                                       SLVFS_CMD_VOP_STRATEGY_READ);
 660                 break;
 661         case BUF_CMD_WRITE:
 662                 par = sl_msg_init_cmd(slmsg->msg, SMPROTO_BSDVFS,
 663                                       SLVFS_CMD_VOP_STRATEGY_WRITE);
 664                 break;
 665         default:
 666                 par = sl_msg_init_cmd(slmsg->msg, SMPROTO_BSDVFS,
 667                                       SLVFS_CMD_VOP_STRATEGY_MISC);
 668                 break;
 669         }
 670         user_elm_push_vnode(par, vp);
 671         user_elm_push_offset(par, bio->bio_offset);
 672         user_elm_push_bio(par, bp->b_cmd, bp->b_bcount);
 673         syslink_kdmabuf_data(slmsg, bp->b_data, bp->b_bcount);
 674         sl_msg_fini(slmsg->msg);
 675
 676         kprintf("userfs_strategy\n");
 677         error = syslink_ksendmsg(ump->sldesc, slmsg,
 678                                  user_strategy_callback, bio);
 679         if (error)
 680                 syslink_kfreemsg(ump->sldesc, slmsg);
 681         kprintf("error %d\n", error);
 682         return(error);
 683 }
 684
 685 /*
 686  * This callback is made in the context of the responding process which
 687  * may or may not be the process the message was sent to.
 688  */
 689 static void
 690 user_strategy_callback(struct slmsg *slmsg, void *arg, int error)
 691 {
 692         struct bio *bio = arg;
 693         struct buf *bp = bio->bio_buf;
 694         struct user_mount *ump;
 695         syslink_elm_t par;
 696
 697         kprintf("user_strategy_callback\n");
 698         if (error == 0) {
 699                 par = &slmsg->rep->msg->sm_head;
 700                 if (par->se_cmd != (slmsg->msg->sm_head.se_cmd | SE_CMDF_REPLY)) {
 701                         error = EBADRPC;
 702                 }
 703         }
 704         if (error) {
 705                 bp->b_error = error;
 706                 bp->b_flags |= B_ERROR;
 707         }
 708         ump = bio->bio_driver_info;
 709         syslink_kfreemsg(ump->sldesc, slmsg);
 710         biodone(bio);
 711 }
 712
 713 /*
 714  * vop_bmap(struct vnode *vp, off_t loffset, off_t *doffsetp,
 715  *          int *runp, int *runb)
 716  *
 717  * Dummy up the bmap op so the kernel will cluster I/Os.  The strategy
 718  * code will ignore the dummied up device block translation.
 719  */
 720 static
 721 int
 722 user_vop_bmap(struct vop_bmap_args *ap)
 723 {
 724         int cluster_off;
 725
 726         *ap->a_doffsetp = ap->a_loffset;
 727         cluster_off = (int)(*ap->a_doffsetp & (MAXPHYS - 1));
 728
 729         if (ap->a_runp)
 730                 *ap->a_runp = MAXPHYS - cluster_off;
 731         if (ap->a_runb)
 732                 *ap->a_runb = cluster_off;
 733         return(0);
 734 }
 735
 736
 737 /*
 738  * vop_ncreate(struct nchandle *nch, struct vnode *dvp, struct vnode **vpp,
 739  *             struct ucred *cred, struct vattr *vap)
 740  */
 741 static
 742 int
 743 user_vop_ncreate (struct vop_ncreate_args *ap)
 744 {
 745         struct user_mount *ump;
 746         struct user_inode *ip;
 747         struct namecache *ncp;
 748         struct ucred *cred;
 749         struct vnode *dvp;
 750         struct slmsg *slmsg;
 751         syslink_elm_t par;
 752         syslink_elm_t elm;
 753         int error;
 754
 755         cred = ap->a_cred;
 756         ncp = ap->a_nch->ncp;
 757         dvp = ap->a_dvp;
 758
 759         if ((error = vget(dvp, LK_SHARED)) != 0)
 760                 return (error);
 761
 762         ip = dvp->v_data;
 763         ump = ip->ump;
 764
 765         slmsg = syslink_kallocmsg();
 766         par = sl_msg_init_cmd(slmsg->msg, SMPROTO_BSDVFS,
 767                               SLVFS_CMD_VOP_NCREATE);
 768         user_elm_push_nch(par, ap->a_nch);
 769         user_elm_push_vnode(par, dvp);
 770         user_elm_push_cred(par, ap->a_cred);
 771         user_elm_push_vattr(par, ap->a_vap);
 772         sl_msg_fini(slmsg->msg);
 773
 774         kprintf("userfs_ncreate\n");
 775         if ((error = syslink_kdomsg(ump->sldesc, slmsg)) != 0)
 776                 goto done;
 777         par = &slmsg->rep->msg->sm_head;
 778         if (par->se_cmd != (SLVFS_CMD_VOP_NCREATE|SE_CMDF_REPLY)) {
 779                 error = EBADRPC;
 780                 goto done;
 781         }
 782
 783         /*
 784          * Parse reply - extract the inode number of the newly created
 785          * object and construct a vnode using it.
 786          */
 787         SL_FOREACH_ELEMENT(par, elm) {
 788                 switch(elm->se_cmd) {
 789                 case SLVFS_ELM_INUM:
 790                         /* XXX */
 791                         break;
 792                 default:
 793                         break;
 794                 }
 795                 if (error)
 796                         break;
 797         }
 798         /* XXX construct vnode using fileid */
 799         error = EINVAL;
 800
 801 done:
 802         syslink_kfreemsg(ump->sldesc, slmsg);
 803         kprintf("error %d\n", error);
 804         vput(dvp);
 805         return(error);
 806 }
 807
 808 /*
 809  * vop_nresolve(struct nchandle *nch, struct vnode *dvp, struct ucred *cred)
 810  */
 811 static
 812 int
 813 user_vop_nresolve (struct vop_nresolve_args *ap)
 814 {
 815         struct user_mount *ump;
 816         struct user_inode *ip;
 817         struct namecache *ncp;
 818         struct ucred *cred;
 819         struct vnode *dvp;
 820         struct slmsg *slmsg;
 821         syslink_elm_t par;
 822         syslink_elm_t elm;
 823         int error;
 824         int flags;
 825         ino_t inum;
 826
 827         cred = ap->a_cred;
 828         ncp = ap->a_nch->ncp;
 829         dvp = ap->a_dvp;
 830         if ((error = vget(dvp, LK_SHARED)) != 0)
 831                 return (error);
 832         vn_unlock(dvp);
 833
 834         ip = dvp->v_data;
 835         ump = ip->ump;
 836
 837         slmsg = syslink_kallocmsg();
 838         par = sl_msg_init_cmd(slmsg->msg, SMPROTO_BSDVFS,
 839                               SLVFS_CMD_VOP_NRESOLVE);
 840         user_elm_push_nch(par, ap->a_nch);
 841         user_elm_push_vnode(par, dvp);
 842         user_elm_push_cred(par, ap->a_cred);
 843         sl_msg_fini(slmsg->msg);
 844
 845         /*
 846          * Run the RPC.  The response must still be parsed for a ENOENT
 847          * error to extract the whiteout flag.
 848          */
 849         kprintf("userfs_nresolve\n");
 850         error = syslink_kdomsg(ump->sldesc, slmsg);
 851         if (error && error != ENOENT)
 852                 goto done;
 853         par = &slmsg->rep->msg->sm_head;
 854         if (par->se_cmd != (SLVFS_CMD_VOP_NRESOLVE|SE_CMDF_REPLY)) {
 855                 error = EBADRPC;
 856                 goto done;
 857         }
 858
 859         /*
 860          * Parse reply - returns inode number of resolved vnode
 861          */
 862         flags = 0;
 863         inum = 0;
 864         SL_FOREACH_ELEMENT(par, elm) {
 865                 switch(elm->se_cmd) {
 866                 case SLVFS_ELM_INUM:
 867                         /* XXX */
 868                         break;
 869                 case SLVFS_ELM_NCPFLAG:
 870                         /* flags = & NCF_WHITEOUT */
 871                         break;
 872                 default:
 873                         break;
 874                 }
 875         }
 876
 877         if (error == 0) {
 878                 error = EINVAL;
 879                 /*vp = user_getvp(inum);*/
 880                 /* XXX construct vp cache_setvp(nch, vp); */
 881         } else {
 882                 ncp->nc_flag |= flags;
 883                 cache_setvp(ap->a_nch, NULL);
 884         }
 885 done:
 886         syslink_kfreemsg(ump->sldesc, slmsg);
 887         vrele(dvp);
 888         kprintf("error %d\n", error);
 889         return(error);
 890 }
 891
 892 /*
 893  * vop_nlookupdotdot(struct vnode *dvp, struct vnode **vpp, struct ucred *cred)
 894  *
 895  * Lookup the parent of dvp. dvp is ref'd but not locked.  The returned
 896  * vnode should be ref'd and locked.
 897  */
 898 static
 899 int
 900 user_vop_nlookupdotdot (struct vop_nlookupdotdot_args *ap)
 901 {
 902         struct user_mount *ump;
 903         struct user_inode *ip;
 904         struct ucred *cred;
 905         struct vnode *dvp;
 906         struct vnode *vp;
 907         struct slmsg *slmsg;
 908         syslink_elm_t par;
 909         syslink_elm_t elm;
 910         int error;
 911         ino_t inum;
 912
 913         cred = ap->a_cred;
 914         dvp = ap->a_dvp;
 915         vp = NULL;      /* XXX */
 916         ip = vp->v_data;
 917         ump = ip->ump;
 918
 919         slmsg = syslink_kallocmsg();
 920         par = sl_msg_init_cmd(slmsg->msg, SMPROTO_BSDVFS,
 921                               SLVFS_CMD_VOP_NLOOKUPDOTDOT);
 922         sl_msg_fini(slmsg->msg);
 923
 924         kprintf("userfs_nlookupdotdot\n");
 925         if ((error = syslink_kdomsg(ump->sldesc, slmsg)) != 0)
 926                 goto done;
 927         par = &slmsg->rep->msg->sm_head;
 928
 929         if (par->se_cmd != (SLVFS_CMD_VOP_NLOOKUPDOTDOT|SE_CMDF_REPLY)) {
 930                 error = EBADRPC;
 931                 goto done;
 932         }
 933
 934         /*
 935          * Parse reply - inumber of parent directory
 936          */
 937         inum = 0;
 938         SL_FOREACH_ELEMENT(par, elm) {
 939                 switch(elm->se_cmd) {
 940                 case SLVFS_ELM_INUM:
 941                         /* XXX */
 942                         break;
 943                 case SLVFS_ELM_NCPFLAG:
 944                         /* flags = & NCF_WHITEOUT */
 945                         break;
 946                 default:
 947                         break;
 948                 }
 949         }
 950
 951         /* construct parent vnode */
 952
 953 done:
 954         syslink_kfreemsg(ump->sldesc, slmsg);
 955         kprintf("error %d\n", error);
 956         return(error);
 957 }
 958
 959 /*
 960  * vop_nlink(struct nchandle *nch, struct vnode *dvp, struct vnode *vp,
 961  *           struct ucred *cred)
 962  */
 963 static
 964 int
 965 user_vop_nlink (struct vop_nlink_args *ap)
 966 {
 967         struct user_mount *ump;
 968         struct user_inode *ip;
 969         struct vnode *vp;
 970         struct slmsg *slmsg;
 971         syslink_elm_t par;
 972         int error;
 973
 974         vp = ap->a_vp;
 975         ip = vp->v_data;
 976         ump = ip->ump;
 977
 978         slmsg = syslink_kallocmsg();
 979         par = sl_msg_init_cmd(slmsg->msg, SMPROTO_BSDVFS,
 980                               SLVFS_CMD_VOP_NLINK);
 981         sl_msg_fini(slmsg->msg);
 982
 983         kprintf("userfs_nlink\n");
 984         if ((error = syslink_kdomsg(ump->sldesc, slmsg)) == 0) {
 985                 par = &slmsg->rep->msg->sm_head;
 986
 987                 if (par->se_cmd == (SLVFS_CMD_VOP_NLINK|SE_CMDF_REPLY)) {
 988                         ;
 989                 } else {
 990                         error = EBADRPC;
 991                 }
 992         }
 993         syslink_kfreemsg(ump->sldesc, slmsg);
 994         kprintf("error %d\n", error);
 995         return(error);
 996 }
 997
 998 /*
 999  * vop_nmkdir(struct nchandle *nch, struct vnode *dvp, struct vnode **vpp,
1000  *           struct ucred *cred, struct vattr *vap)
1001  */
1002 static
1003 int
1004 user_vop_nmkdir (struct vop_nmkdir_args *ap)
1005 {
1006         struct user_mount *ump;
1007         struct user_inode *ip;
1008         struct namecache *ncp;
1009         struct ucred *cred;
1010         struct vnode *dvp;
1011         struct vnode *vp;
1012         struct slmsg *slmsg;
1013         syslink_elm_t par;
1014         int error;
1015
1016         cred = ap->a_cred;
1017         ncp = ap->a_nch->ncp;
1018         dvp = ap->a_dvp;
1019         if ((error = vget(dvp, LK_SHARED)) != 0)
1020                 return (error);
1021
1022         vp = NULL;      /* XXX */
1023
1024         ip = vp->v_data;
1025         ump = ip->ump;
1026
1027         slmsg = syslink_kallocmsg();
1028         par = sl_msg_init_cmd(slmsg->msg, SMPROTO_BSDVFS,
1029                               SLVFS_CMD_VOP_NMKDIR);
1030         sl_msg_fini(slmsg->msg);
1031
1032         kprintf("userfs_nmkdir\n");
1033         if ((error = syslink_kdomsg(ump->sldesc, slmsg)) == 0) {
1034                 par = &slmsg->rep->msg->sm_head;
1035
1036                 if (par->se_cmd == (SLVFS_CMD_VOP_NMKDIR|SE_CMDF_REPLY)) {
1037                         ;
1038                 } else {
1039                         error = EBADRPC;
1040                 }
1041         }
1042         syslink_kfreemsg(ump->sldesc, slmsg);
1043         kprintf("error %d\n", error);
1044         vput(dvp);
1045         return(error);
1046 }
1047
1048 /*
1049  * vop_nmknod(struct nchandle *nch, struct vnode *dvp, struct vnode **vpp,
1050  *           struct ucred *cred, struct vattr *vap)
1051  */
1052 static
1053 int
1054 user_vop_nmknod (struct vop_nmknod_args *ap)
1055 {
1056         struct user_mount *ump;
1057         struct user_inode *ip;
1058         struct namecache *ncp;
1059         struct ucred *cred;
1060         struct vnode *dvp;
1061         struct vnode *vp;
1062         struct slmsg *slmsg;
1063         syslink_elm_t par;
1064         int error;
1065
1066         cred = ap->a_cred;
1067         ncp = ap->a_nch->ncp;
1068         dvp = ncp->nc_parent->nc_vp;    /* needs vget */
1069
1070         vp = NULL;      /* XXX */
1071
1072         ip = vp->v_data;
1073         ump = ip->ump;
1074
1075         slmsg = syslink_kallocmsg();
1076         par = sl_msg_init_cmd(slmsg->msg, SMPROTO_BSDVFS,
1077                               SLVFS_CMD_VOP_NMKNOD);
1078         sl_msg_fini(slmsg->msg);
1079
1080         kprintf("userfs_nmknod\n");
1081         if ((error = syslink_kdomsg(ump->sldesc, slmsg)) == 0) {
1082                 par = &slmsg->rep->msg->sm_head;
1083
1084                 if (par->se_cmd == (SLVFS_CMD_VOP_NMKNOD|SE_CMDF_REPLY)) {
1085                         ;
1086                 } else {
1087                         error = EBADRPC;
1088                 }
1089         }
1090         syslink_kfreemsg(ump->sldesc, slmsg);
1091         kprintf("error %d\n", error);
1092         return(error);
1093 }
1094
1095 /*
1096  * vop_nremove(struct nchandle *nch, struct vnode *dvp, struct ucred *cred)
1097  */
1098 static
1099 int
1100 user_vop_nremove (struct vop_nremove_args *ap)
1101 {
1102         struct user_mount *ump;
1103         struct user_inode *ip;
1104         struct namecache *ncp;
1105         struct ucred *cred;
1106         struct vnode *dvp;
1107         struct vnode *vp;
1108         struct slmsg *slmsg;
1109         syslink_elm_t par;
1110         int error;
1111
1112         cred = ap->a_cred;
1113         ncp = ap->a_nch->ncp;
1114         dvp = ncp->nc_parent->nc_vp;    /* needs vget */
1115
1116         vp = NULL;      /* XXX */
1117
1118         ip = vp->v_data;
1119         ump = ip->ump;
1120
1121         slmsg = syslink_kallocmsg();
1122         par = sl_msg_init_cmd(slmsg->msg, SMPROTO_BSDVFS,
1123                               SLVFS_CMD_VOP_NREMOVE);
1124         sl_msg_fini(slmsg->msg);
1125
1126         kprintf("userfs_nremove\n");
1127         if ((error = syslink_kdomsg(ump->sldesc, slmsg)) == 0) {
1128                 par = &slmsg->rep->msg->sm_head;
1129
1130                 if (par->se_cmd == (SLVFS_CMD_VOP_NREMOVE|SE_CMDF_REPLY)) {
1131                         ;
1132                 } else {
1133                         error = EBADRPC;
1134                 }
1135         }
1136         syslink_kfreemsg(ump->sldesc, slmsg);
1137         kprintf("error %d\n", error);
1138         return(error);
1139 }
1140
1141 /*
1142  * vop_nrename(struct nchandle *fnch, struct nchandle *tnch,
1143  *             struct vnode *fdvp, struct vnode *tdvp,
1144  *             struct ucred *cred)
1145  */
1146 static
1147 int
1148 user_vop_nrename (struct vop_nrename_args *ap)
1149 {
1150         struct user_mount *ump;
1151         struct user_inode *ip;
1152         struct namecache *fncp;
1153         struct namecache *tncp;
1154         struct ucred *cred;
1155         struct vnode *fdvp;
1156         struct vnode *tdvp;
1157         struct vnode *vp;
1158         struct slmsg *slmsg;
1159         syslink_elm_t par;
1160         int error;
1161
1162         cred = ap->a_cred;
1163         fncp = ap->a_fnch->ncp;
1164         fdvp = ap->a_fdvp;      /* XXX needs vget */
1165         tncp = ap->a_tnch->ncp;
1166         tdvp = ap->a_tdvp;      /* XXX needs vget */
1167
1168         vp = NULL;      /* XXX */
1169
1170         ip = vp->v_data;
1171         ump = ip->ump;
1172
1173         slmsg = syslink_kallocmsg();
1174         par = sl_msg_init_cmd(slmsg->msg, SMPROTO_BSDVFS,
1175                               SLVFS_CMD_VOP_NRENAME);
1176         sl_msg_fini(slmsg->msg);
1177
1178         kprintf("userfs_nrename\n");
1179         if ((error = syslink_kdomsg(ump->sldesc, slmsg)) == 0) {
1180                 par = &slmsg->rep->msg->sm_head;
1181
1182                 if (par->se_cmd == (SLVFS_CMD_VOP_NRENAME|SE_CMDF_REPLY)) {
1183                         ;
1184                 } else {
1185                         error = EBADRPC;
1186                 }
1187         }
1188         syslink_kfreemsg(ump->sldesc, slmsg);
1189         kprintf("error %d\n", error);
1190         return(error);
1191 }
1192
1193 /*
1194  * vop_nrmdir(struct nchandle *nch, struct vnode *dvp, struct ucred *cred)
1195  */
1196 static
1197 int
1198 user_vop_nrmdir (struct vop_nrmdir_args *ap)
1199 {
1200         struct user_mount *ump;
1201         struct user_inode *ip;
1202         struct namecache *ncp;
1203         struct ucred *cred;
1204         struct vnode *dvp;
1205         struct vnode *vp;
1206         struct slmsg *slmsg;
1207         syslink_elm_t par;
1208         int error;
1209
1210         cred = ap->a_cred;
1211         ncp = ap->a_nch->ncp;
1212         dvp = ncp->nc_parent->nc_vp;    /* needs vget */
1213
1214         vp = NULL;      /* XXX */
1215
1216         ip = vp->v_data;
1217         ump = ip->ump;
1218
1219         slmsg = syslink_kallocmsg();
1220         par = sl_msg_init_cmd(slmsg->msg, SMPROTO_BSDVFS,
1221                               SLVFS_CMD_VOP_NRMDIR);
1222         sl_msg_fini(slmsg->msg);
1223
1224         kprintf("userfs_nrmdir\n");
1225         if ((error = syslink_kdomsg(ump->sldesc, slmsg)) == 0) {
1226                 par = &slmsg->rep->msg->sm_head;
1227
1228                 if (par->se_cmd == (SLVFS_CMD_VOP_NRMDIR|SE_CMDF_REPLY)) {
1229                         ;
1230                 } else {
1231                         error = EBADRPC;
1232                 }
1233         }
1234         syslink_kfreemsg(ump->sldesc, slmsg);
1235         kprintf("error %d\n", error);
1236         return(error);
1237 }
1238
1239 static
1240 int
1241 user_vop_nsymlink (struct vop_nsymlink_args *ap)
1242 {
1243         struct user_mount *ump;
1244         struct user_inode *ip;
1245         struct namecache *ncp;
1246         struct ucred *cred;
1247         struct vnode *dvp;
1248         struct vnode *vp;
1249         struct slmsg *slmsg;
1250         syslink_elm_t par;
1251         int error;
1252
1253         cred = ap->a_cred;
1254         ncp = ap->a_nch->ncp;
1255         dvp = ncp->nc_parent->nc_vp;    /* needs vget */
1256
1257         vp = NULL;      /* XXX */
1258
1259         ip = vp->v_data;
1260         ump = ip->ump;
1261
1262         slmsg = syslink_kallocmsg();
1263         par = sl_msg_init_cmd(slmsg->msg, SMPROTO_BSDVFS,
1264                               SLVFS_CMD_VOP_NSYMLINK);
1265         sl_msg_fini(slmsg->msg);
1266
1267         kprintf("userfs_nsymlink\n");
1268         if ((error = syslink_kdomsg(ump->sldesc, slmsg)) == 0) {
1269                 par = &slmsg->rep->msg->sm_head;
1270
1271                 if (par->se_cmd == (SLVFS_CMD_VOP_NSYMLINK|SE_CMDF_REPLY)) {
1272                         ;
1273                 } else {
1274                         error = EBADRPC;
1275                 }
1276         }
1277         syslink_kfreemsg(ump->sldesc, slmsg);
1278         kprintf("error %d\n", error);
1279         return(error);
1280 }
1281
1282 static
1283 int
1284 user_vop_nwhiteout (struct vop_nwhiteout_args *ap)
1285 {
1286         struct user_mount *ump;
1287         struct user_inode *ip;
1288         struct namecache *ncp;
1289         struct ucred *cred;
1290         struct vnode *dvp;
1291         struct vnode *vp;
1292         struct slmsg *slmsg;
1293         syslink_elm_t par;
1294         int error;
1295
1296         cred = ap->a_cred;
1297         ncp = ap->a_nch->ncp;
1298         dvp = ncp->nc_parent->nc_vp;    /* needs vget */
1299
1300         vp = NULL;      /* XXX */
1301
1302         ip = vp->v_data;
1303         ump = ip->ump;
1304
1305         slmsg = syslink_kallocmsg();
1306         par = sl_msg_init_cmd(slmsg->msg, SMPROTO_BSDVFS,
1307                               SLVFS_CMD_VOP_NWHITEOUT);
1308         sl_msg_fini(slmsg->msg);
1309
1310         kprintf("userfs_nwhiteout\n");
1311         if ((error = syslink_kdomsg(ump->sldesc, slmsg)) == 0) {
1312                 par = &slmsg->rep->msg->sm_head;
1313
1314                 if (par->se_cmd == (SLVFS_CMD_VOP_NWHITEOUT|SE_CMDF_REPLY)) {
1315                         ;
1316                 } else {
1317                         error = EBADRPC;
1318                 }
1319         }
1320         syslink_kfreemsg(ump->sldesc, slmsg);
1321         kprintf("error %d\n", error);
1322         return(error);
1323 }
1324