usr/src/lib/smbsrv/libfksmbsrv/common/fake_vop.c

   1 /*
   2  * This file and its contents are supplied under the terms of the
   3  * Common Development and Distribution License ("CDDL"), version 1.0.
   4  * You may only use this file in accordance with the terms of version
   5  * 1.0 of the CDDL.
   6  *
   7  * A full copy of the text of the CDDL should have accompanied this
   8  * source.  A copy of the CDDL is also available via the Internet at
   9  * http://www.illumos.org/license/CDDL.
  10  */
  11
  12 /*
  13  * Copyright 2015 Nexenta Systems, Inc.  All rights reserved.
  14  */
  15
  16 #include <sys/types.h>
  17 #include <sys/param.h>
  18 #include <sys/t_lock.h>
  19 #include <sys/errno.h>
  20 #include <sys/cred.h>
  21 #include <sys/user.h>
  22 #include <sys/uio.h>
  23 #include <sys/file.h>
  24 #include <sys/pathname.h>
  25 #include <sys/vfs.h>
  26 #include <sys/vnode.h>
  27 #include <sys/stat.h>
  28 #include <sys/mode.h>
  29 #include <sys/kmem.h>
  30 #include <sys/debug.h>
  31 #include <sys/atomic.h>
  32 #include <sys/acl.h>
  33 #include <sys/flock.h>
  34 #include <sys/nbmlock.h>
  35 #include <sys/fcntl.h>
  36 #include <sys/poll.h>
  37 #include <sys/time.h>
  38
  39 #include <errno.h>
  40 #include <fcntl.h>
  41 #include <unistd.h>
  42
  43 #include "vncache.h"
  44
  45 #define O_RWMASK        (O_WRONLY | O_RDWR) /* == 3 */
  46
  47 int fop_shrlock_enable = 0;
  48
  49 int stat_to_vattr(const struct stat *, vattr_t *);
  50 int fop__getxvattr(vnode_t *, xvattr_t *);
  51 int fop__setxvattr(vnode_t *, xvattr_t *);
  52
  53
  54 /* ARGSUSED */
  55 int
  56 fop_open(
  57         vnode_t **vpp,
  58         int mode,
  59         cred_t *cr,
  60         caller_context_t *ct)
  61 {
  62
  63         if ((*vpp)->v_type == VREG) {
  64                 if (mode & FREAD)
  65                         atomic_add_32(&((*vpp)->v_rdcnt), 1);
  66                 if (mode & FWRITE)
  67                         atomic_add_32(&((*vpp)->v_wrcnt), 1);
  68         }
  69
  70         /* call to ->vop_open was here */
  71
  72         return (0);
  73 }
  74
  75 /* ARGSUSED */
  76 int
  77 fop_close(
  78         vnode_t *vp,
  79         int flag,
  80         int count,
  81         offset_t offset,
  82         cred_t *cr,
  83         caller_context_t *ct)
  84 {
  85
  86         /* call to ->vop_close was here */
  87
  88         /*
  89          * Check passed in count to handle possible dups. Vnode counts are only
  90          * kept on regular files
  91          */
  92         if ((vp->v_type == VREG) && (count == 1))  {
  93                 if (flag & FREAD) {
  94                         ASSERT(vp->v_rdcnt > 0);
  95                         atomic_add_32(&(vp->v_rdcnt), -1);
  96                 }
  97                 if (flag & FWRITE) {
  98                         ASSERT(vp->v_wrcnt > 0);
  99                         atomic_add_32(&(vp->v_wrcnt), -1);
 100                 }
 101         }
 102         return (0);
 103 }
 104
 105 /* ARGSUSED */
 106 int
 107 fop_read(
 108         vnode_t *vp,
 109         uio_t *uio,
 110         int ioflag,
 111         cred_t *cr,
 112         caller_context_t *ct)
 113 {
 114         struct stat st;
 115         struct iovec *iov;
 116         ssize_t resid;
 117         size_t cnt;
 118         int n;
 119
 120         /*
 121          * If that caller asks for read beyond end of file,
 122          * that causes the pread call to block.  (Ugh!)
 123          * Get the file size and return what we can.
 124          */
 125         (void) fstat(vp->v_fd, &st);
 126         resid = uio->uio_resid;
 127         if ((uio->uio_loffset + resid) > st.st_size)
 128                 resid = st.st_size - uio->uio_loffset;
 129
 130         while (resid > 0) {
 131
 132                 ASSERT(uio->uio_iovcnt > 0);
 133                 iov = uio->uio_iov;
 134
 135                 if (iov->iov_len == 0) {
 136                         uio->uio_iov++;
 137                         uio->uio_iovcnt--;
 138                         continue;
 139                 }
 140                 cnt = iov->iov_len;
 141                 if (cnt > resid)
 142                         cnt = resid;
 143
 144                 n = pread(vp->v_fd, iov->iov_base, cnt, uio->uio_loffset);
 145                 if (n < 0)
 146                         return (errno);
 147
 148                 iov->iov_base += n;
 149                 iov->iov_len -= n;
 150
 151                 uio->uio_resid -= n;
 152                 uio->uio_loffset += n;
 153
 154                 resid -= n;
 155         }
 156
 157         return (0);
 158 }
 159
 160 /* ARGSUSED */
 161 int
 162 fop_write(
 163         vnode_t *vp,
 164         uio_t *uio,
 165         int ioflag,
 166         cred_t *cr,
 167         caller_context_t *ct)
 168 {
 169         struct iovec *iov;
 170         size_t cnt;
 171         int n;
 172
 173         while (uio->uio_resid > 0) {
 174
 175                 ASSERT(uio->uio_iovcnt > 0);
 176                 iov = uio->uio_iov;
 177
 178                 if (iov->iov_len == 0) {
 179                         uio->uio_iov++;
 180                         uio->uio_iovcnt--;
 181                         continue;
 182                 }
 183                 cnt = iov->iov_len;
 184                 if (cnt > uio->uio_resid)
 185                         cnt = uio->uio_resid;
 186
 187                 n = pwrite(vp->v_fd, iov->iov_base, iov->iov_len,
 188                     uio->uio_loffset);
 189                 if (n < 0)
 190                         return (errno);
 191
 192                 iov->iov_base += n;
 193                 iov->iov_len -= n;
 194
 195                 uio->uio_resid -= n;
 196                 uio->uio_loffset += n;
 197         }
 198
 199         if (ioflag == FSYNC) {
 200                 (void) fsync(vp->v_fd);
 201         }
 202
 203         return (0);
 204 }
 205
 206 /* ARGSUSED */
 207 int
 208 fop_ioctl(
 209         vnode_t *vp,
 210         int cmd,
 211         intptr_t arg,
 212         int flag,
 213         cred_t *cr,
 214         int *rvalp,
 215         caller_context_t *ct)
 216 {
 217         return (ENOSYS);
 218 }
 219
 220 /* ARGSUSED */
 221 int
 222 fop_setfl(
 223         vnode_t *vp,
 224         int oflags,
 225         int nflags,
 226         cred_t *cr,
 227         caller_context_t *ct)
 228 {
 229         /* allow any flags? See fs_setfl */
 230         return (0);
 231 }
 232
 233 /* ARGSUSED */
 234 int
 235 fop_getattr(
 236         vnode_t *vp,
 237         vattr_t *vap,
 238         int flags,
 239         cred_t *cr,
 240         caller_context_t *ct)
 241 {
 242         int error;
 243         struct stat st;
 244
 245         if (fstat(vp->v_fd, &st) == -1)
 246                 return (errno);
 247         error = stat_to_vattr(&st, vap);
 248
 249         if (vap->va_mask & AT_XVATTR)
 250                 (void) fop__getxvattr(vp, (xvattr_t *)vap);
 251
 252         return (error);
 253 }
 254
 255 /* ARGSUSED */
 256 int
 257 fop_setattr(
 258         vnode_t *vp,
 259         vattr_t *vap,
 260         int flags,
 261         cred_t *cr,
 262         caller_context_t *ct)
 263 {
 264         timespec_t times[2];
 265
 266         if (vap->va_mask & AT_SIZE) {
 267                 if (ftruncate(vp->v_fd, vap->va_size) == -1)
 268                         return (errno);
 269         }
 270
 271         /* AT_MODE or anything else? */
 272
 273         if (vap->va_mask & AT_XVATTR)
 274                 (void) fop__setxvattr(vp, (xvattr_t *)vap);
 275
 276         if (vap->va_mask & (AT_ATIME | AT_MTIME)) {
 277                 if (vap->va_mask & AT_ATIME) {
 278                         times[0] = vap->va_atime;
 279                 } else {
 280                         times[0].tv_sec = 0;
 281                         times[0].tv_nsec = UTIME_OMIT;
 282                 }
 283                 if (vap->va_mask & AT_MTIME) {
 284                         times[1] = vap->va_mtime;
 285                 } else {
 286                         times[1].tv_sec = 0;
 287                         times[1].tv_nsec = UTIME_OMIT;
 288                 }
 289
 290                 (void) futimens(vp->v_fd, times);
 291         }
 292
 293         return (0);
 294 }
 295
 296 /* ARGSUSED */
 297 int
 298 fop_access(
 299         vnode_t *vp,
 300         int mode,
 301         int flags,
 302         cred_t *cr,
 303         caller_context_t *ct)
 304 {
 305         return (0);
 306 }
 307
 308 /* ARGSUSED */
 309 int
 310 fop_lookup(
 311         vnode_t *dvp,
 312         char *name,
 313         vnode_t **vpp,
 314         pathname_t *pnp,
 315         int flags,
 316         vnode_t *rdir,
 317         cred_t *cr,
 318         caller_context_t *ct,
 319         int *deflags,           /* Returned per-dirent flags */
 320         pathname_t *ppnp)       /* Returned case-preserved name in directory */
 321 {
 322         int fd;
 323         int omode = O_RDWR | O_NOFOLLOW;
 324         vnode_t *vp;
 325         struct stat st;
 326
 327         if (flags & LOOKUP_XATTR)
 328                 return (ENOENT);
 329
 330         /*
 331          * If lookup is for "", just return dvp.
 332          */
 333         if (name[0] == '\0') {
 334                 vn_hold(dvp);
 335                 *vpp = dvp;
 336                 return (0);
 337         }
 338
 339         if (fstatat(dvp->v_fd, name, &st, AT_SYMLINK_NOFOLLOW) == -1)
 340                 return (errno);
 341
 342         vp = vncache_lookup(&st);
 343         if (vp != NULL) {
 344                 /* lookup gave us a hold */
 345                 *vpp = vp;
 346                 return (0);
 347         }
 348
 349         if (S_ISDIR(st.st_mode))
 350                 omode = O_RDONLY | O_NOFOLLOW;
 351
 352 again:
 353         fd = openat(dvp->v_fd, name, omode, 0);
 354         if (fd < 0) {
 355                 if ((omode & O_RWMASK) == O_RDWR) {
 356                         omode &= ~O_RWMASK;
 357                         omode |= O_RDONLY;
 358                         goto again;
 359                 }
 360                 return (errno);
 361         }
 362
 363         if (fstat(fd, &st) == -1) {
 364                 (void) close(fd);
 365                 return (errno);
 366         }
 367
 368         vp = vncache_enter(&st, dvp, name, fd);
 369
 370         *vpp = vp;
 371         return (0);
 372 }
 373
 374 /* ARGSUSED */
 375 int
 376 fop_create(
 377         vnode_t *dvp,
 378         char *name,
 379         vattr_t *vap,
 380         vcexcl_t excl,
 381         int mode,
 382         vnode_t **vpp,
 383         cred_t *cr,
 384         int flags,
 385         caller_context_t *ct,
 386         vsecattr_t *vsecp)      /* ACL to set during create */
 387 {
 388         struct stat st;
 389         vnode_t *vp;
 390         int err, fd, omode;
 391
 392         /*
 393          * If creating "", just return dvp.
 394          */
 395         if (name[0] == '\0') {
 396                 vn_hold(dvp);
 397                 *vpp = dvp;
 398                 return (0);
 399         }
 400
 401         err = fstatat(dvp->v_fd, name, &st, AT_SYMLINK_NOFOLLOW);
 402         if (err != 0)
 403                 err = errno;
 404
 405         vp = NULL;
 406         if (err == 0) {
 407                 /* The file already exists. */
 408                 if (excl == EXCL)
 409                         return (EEXIST);
 410
 411                 vp = vncache_lookup(&st);
 412                 /* vp gained a hold */
 413         }
 414
 415         if (vp == NULL) {
 416                 /*
 417                  * Open it. (may or may not exist)
 418                  */
 419                 omode = O_RDWR | O_CREAT | O_NOFOLLOW;
 420                 if (excl == EXCL)
 421                         omode |= O_EXCL;
 422         open_again:
 423                 fd = openat(dvp->v_fd, name, omode, mode);
 424                 if (fd < 0) {
 425                         if ((omode & O_RWMASK) == O_RDWR) {
 426                                 omode &= ~O_RWMASK;
 427                                 omode |= O_RDONLY;
 428                                 goto open_again;
 429                         }
 430                         return (errno);
 431                 }
 432                 (void) fstat(fd, &st);
 433
 434                 vp = vncache_enter(&st, dvp, name, fd);
 435                 /* vp has its initial hold */
 436         }
 437
 438         /* Should have the vp now. */
 439         if (vp == NULL)
 440                 return (EFAULT);
 441
 442         if (vp->v_type == VDIR && vap->va_type != VDIR) {
 443                 vn_rele(vp);
 444                 return (EISDIR);
 445         }
 446         if (vp->v_type != VDIR && vap->va_type == VDIR) {
 447                 vn_rele(vp);
 448                 return (ENOTDIR);
 449         }
 450
 451         /*
 452          * Might need to set attributes.
 453          */
 454         (void) fop_setattr(vp, vap, 0, cr, ct);
 455
 456         *vpp = vp;
 457         return (0);
 458 }
 459
 460 /* ARGSUSED */
 461 int
 462 fop_remove(
 463         vnode_t *dvp,
 464         char *name,
 465         cred_t *cr,
 466         caller_context_t *ct,
 467         int flags)
 468 {
 469
 470         if (unlinkat(dvp->v_fd, name, 0))
 471                 return (errno);
 472
 473         return (0);
 474 }
 475
 476 /* ARGSUSED */
 477 int
 478 fop_link(
 479         vnode_t *to_dvp,
 480         vnode_t *fr_vp,
 481         char *to_name,
 482         cred_t *cr,
 483         caller_context_t *ct,
 484         int flags)
 485 {
 486         int err;
 487
 488         /*
 489          * Would prefer to specify "from" as the combination:
 490          * (fr_vp->v_fd, NULL) but linkat does not permit it.
 491          */
 492         err = linkat(AT_FDCWD, fr_vp->v_path, to_dvp->v_fd, to_name,
 493             AT_SYMLINK_FOLLOW);
 494         if (err == -1)
 495                 err = errno;
 496
 497         return (err);
 498 }
 499
 500 /* ARGSUSED */
 501 int
 502 fop_rename(
 503         vnode_t *from_dvp,
 504         char *from_name,
 505         vnode_t *to_dvp,
 506         char *to_name,
 507         cred_t *cr,
 508         caller_context_t *ct,
 509         int flags)
 510 {
 511         struct stat st;
 512         vnode_t *vp;
 513         int err;
 514
 515         if (fstatat(from_dvp->v_fd, from_name, &st,
 516             AT_SYMLINK_NOFOLLOW) == -1)
 517                 return (errno);
 518
 519         vp = vncache_lookup(&st);
 520         if (vp == NULL)
 521                 return (ENOENT);
 522
 523         err = renameat(from_dvp->v_fd, from_name, to_dvp->v_fd, to_name);
 524         if (err == -1)
 525                 err = errno;
 526         else
 527                 vncache_renamed(vp, to_dvp, to_name);
 528
 529         vn_rele(vp);
 530
 531         return (err);
 532 }
 533
 534 /* ARGSUSED */
 535 int
 536 fop_mkdir(
 537         vnode_t *dvp,
 538         char *name,
 539         vattr_t *vap,
 540         vnode_t **vpp,
 541         cred_t *cr,
 542         caller_context_t *ct,
 543         int flags,
 544         vsecattr_t *vsecp)      /* ACL to set during create */
 545 {
 546         struct stat st;
 547         int err, fd;
 548
 549         mode_t mode = vap->va_mode & 0777;
 550
 551         if (mkdirat(dvp->v_fd, name, mode) == -1)
 552                 return (errno);
 553
 554         if ((fd = openat(dvp->v_fd, name, O_RDONLY)) == -1)
 555                 return (errno);
 556         if (fstat(fd, &st) == -1) {
 557                 err = errno;
 558                 (void) close(fd);
 559                 return (err);
 560         }
 561
 562         *vpp = vncache_enter(&st, dvp, name, fd);
 563
 564         /*
 565          * Might need to set attributes.
 566          */
 567         (void) fop_setattr(*vpp, vap, 0, cr, ct);
 568
 569         return (0);
 570 }
 571
 572 /* ARGSUSED */
 573 int
 574 fop_rmdir(
 575         vnode_t *dvp,
 576         char *name,
 577         vnode_t *cdir,
 578         cred_t *cr,
 579         caller_context_t *ct,
 580         int flags)
 581 {
 582
 583         if (unlinkat(dvp->v_fd, name, AT_REMOVEDIR) == -1)
 584                 return (errno);
 585
 586         return (0);
 587 }
 588
 589 /* ARGSUSED */
 590 int
 591 fop_readdir(
 592         vnode_t *vp,
 593         uio_t *uiop,
 594         cred_t *cr,
 595         int *eofp,
 596         caller_context_t *ct,
 597         int flags)
 598 {
 599         struct iovec *iov;
 600         int cnt;
 601         int error = 0;
 602         int fd = vp->v_fd;
 603
 604         if (eofp) {
 605                 *eofp = 0;
 606         }
 607
 608         error = lseek(fd, uiop->uio_loffset, SEEK_SET);
 609         if (error == -1)
 610                 return (errno);
 611
 612         ASSERT(uiop->uio_iovcnt > 0);
 613         iov = uiop->uio_iov;
 614         if (iov->iov_len < sizeof (struct dirent))
 615                 return (EINVAL);
 616
 617         /* LINTED E_BAD_PTR_CAST_ALIGN */
 618         cnt = getdents(fd, (struct dirent *)(uiop->uio_iov->iov_base),
 619             uiop->uio_resid);
 620         if (cnt == -1)
 621                 return (errno);
 622         if (cnt == 0) {
 623                 if (eofp) {
 624                         *eofp = 1;
 625                 }
 626                 return (ENOENT);
 627         }
 628
 629         iov->iov_base += cnt;
 630         iov->iov_len  -= cnt;
 631         uiop->uio_resid -= cnt;
 632         uiop->uio_loffset = lseek(fd, 0LL, SEEK_CUR);
 633
 634         return (0);
 635 }
 636
 637 /* ARGSUSED */
 638 int
 639 fop_symlink(
 640         vnode_t *dvp,
 641         char *linkname,
 642         vattr_t *vap,
 643         char *target,
 644         cred_t *cr,
 645         caller_context_t *ct,
 646         int flags)
 647 {
 648         return (ENOSYS);
 649 }
 650
 651 /* ARGSUSED */
 652 int
 653 fop_readlink(
 654         vnode_t *vp,
 655         uio_t *uiop,
 656         cred_t *cr,
 657         caller_context_t *ct)
 658 {
 659         return (ENOSYS);
 660 }
 661
 662 /* ARGSUSED */
 663 int
 664 fop_fsync(
 665         vnode_t *vp,
 666         int syncflag,
 667         cred_t *cr,
 668         caller_context_t *ct)
 669 {
 670
 671         if (fsync(vp->v_fd) == -1)
 672                 return (errno);
 673
 674         return (0);
 675 }
 676
 677 /* ARGSUSED */
 678 void
 679 fop_inactive(
 680         vnode_t *vp,
 681         cred_t *cr,
 682         caller_context_t *ct)
 683 {
 684         vncache_inactive(vp);
 685 }
 686
 687 /* ARGSUSED */
 688 int
 689 fop_fid(
 690         vnode_t *vp,
 691         fid_t *fidp,
 692         caller_context_t *ct)
 693 {
 694         return (ENOSYS);
 695 }
 696
 697 /* ARGSUSED */
 698 int
 699 fop_rwlock(
 700         vnode_t *vp,
 701         int write_lock,
 702         caller_context_t *ct)
 703 {
 704         /* See: fs_rwlock */
 705         return (-1);
 706 }
 707
 708 /* ARGSUSED */
 709 void
 710 fop_rwunlock(
 711         vnode_t *vp,
 712         int write_lock,
 713         caller_context_t *ct)
 714 {
 715         /* See: fs_rwunlock */
 716 }
 717
 718 /* ARGSUSED */
 719 int
 720 fop_seek(
 721         vnode_t *vp,
 722         offset_t ooff,
 723         offset_t *noffp,
 724         caller_context_t *ct)
 725 {
 726         return (ENOSYS);
 727 }
 728
 729 /* ARGSUSED */
 730 int
 731 fop_cmp(
 732         vnode_t *vp1,
 733         vnode_t *vp2,
 734         caller_context_t *ct)
 735 {
 736         /* See fs_cmp */
 737         return (vncache_cmp(vp1, vp2));
 738 }
 739
 740 /* ARGSUSED */
 741 int
 742 fop_frlock(
 743         vnode_t *vp,
 744         int cmd,
 745         flock64_t *bfp,
 746         int flag,
 747         offset_t offset,
 748         struct flk_callback *flk_cbp,
 749         cred_t *cr,
 750         caller_context_t *ct)
 751 {
 752         /* See fs_frlock */
 753
 754         switch (cmd) {
 755         case F_GETLK:
 756         case F_SETLK_NBMAND:
 757         case F_SETLK:
 758         case F_SETLKW:
 759                 break;
 760         default:
 761                 return (EINVAL);
 762         }
 763
 764         if (fcntl(vp->v_fd, cmd, bfp) == -1)
 765                 return (errno);
 766
 767         return (0);
 768 }
 769
 770 /* ARGSUSED */
 771 int
 772 fop_space(
 773         vnode_t *vp,
 774         int cmd,
 775         flock64_t *bfp,
 776         int flag,
 777         offset_t offset,
 778         cred_t *cr,
 779         caller_context_t *ct)
 780 {
 781         /* See fs_frlock */
 782
 783         switch (cmd) {
 784         case F_ALLOCSP:
 785         case F_FREESP:
 786                 break;
 787         default:
 788                 return (EINVAL);
 789         }
 790
 791         if (fcntl(vp->v_fd, cmd, bfp) == -1)
 792                 return (errno);
 793
 794         return (0);
 795 }
 796
 797 /* ARGSUSED */
 798 int
 799 fop_realvp(
 800         vnode_t *vp,
 801         vnode_t **vpp,
 802         caller_context_t *ct)
 803 {
 804         return (ENOSYS);
 805 }
 806
 807 /* ARGSUSED */
 808 int
 809 fop_getpage(
 810         vnode_t *vp,
 811         offset_t off,
 812         size_t len,
 813         uint_t *protp,
 814         struct page **plarr,
 815         size_t plsz,
 816         struct seg *seg,
 817         caddr_t addr,
 818         enum seg_rw rw,
 819         cred_t *cr,
 820         caller_context_t *ct)
 821 {
 822         return (ENOSYS);
 823 }
 824
 825 /* ARGSUSED */
 826 int
 827 fop_putpage(
 828         vnode_t *vp,
 829         offset_t off,
 830         size_t len,
 831         int flags,
 832         cred_t *cr,
 833         caller_context_t *ct)
 834 {
 835         return (ENOSYS);
 836 }
 837
 838 /* ARGSUSED */
 839 int
 840 fop_map(
 841         vnode_t *vp,
 842         offset_t off,
 843         struct as *as,
 844         caddr_t *addrp,
 845         size_t len,
 846         uchar_t prot,
 847         uchar_t maxprot,
 848         uint_t flags,
 849         cred_t *cr,
 850         caller_context_t *ct)
 851 {
 852         return (ENOSYS);
 853 }
 854
 855 /* ARGSUSED */
 856 int
 857 fop_addmap(
 858         vnode_t *vp,
 859         offset_t off,
 860         struct as *as,
 861         caddr_t addr,
 862         size_t len,
 863         uchar_t prot,
 864         uchar_t maxprot,
 865         uint_t flags,
 866         cred_t *cr,
 867         caller_context_t *ct)
 868 {
 869         return (ENOSYS);
 870 }
 871
 872 /* ARGSUSED */
 873 int
 874 fop_delmap(
 875         vnode_t *vp,
 876         offset_t off,
 877         struct as *as,
 878         caddr_t addr,
 879         size_t len,
 880         uint_t prot,
 881         uint_t maxprot,
 882         uint_t flags,
 883         cred_t *cr,
 884         caller_context_t *ct)
 885 {
 886         return (ENOSYS);
 887 }
 888
 889 /* ARGSUSED */
 890 int
 891 fop_poll(
 892         vnode_t *vp,
 893         short events,
 894         int anyyet,
 895         short *reventsp,
 896         struct pollhead **phpp,
 897         caller_context_t *ct)
 898 {
 899         *reventsp = 0;
 900         if (events & POLLIN)
 901                 *reventsp |= POLLIN;
 902         if (events & POLLRDNORM)
 903                 *reventsp |= POLLRDNORM;
 904         if (events & POLLRDBAND)
 905                 *reventsp |= POLLRDBAND;
 906         if (events & POLLOUT)
 907                 *reventsp |= POLLOUT;
 908         if (events & POLLWRBAND)
 909                 *reventsp |= POLLWRBAND;
 910         *phpp = NULL; /* or fake_pollhead? */
 911
 912         return (0);
 913 }
 914
 915 /* ARGSUSED */
 916 int
 917 fop_dump(
 918         vnode_t *vp,
 919         caddr_t addr,
 920         offset_t lbdn,
 921         offset_t dblks,
 922         caller_context_t *ct)
 923 {
 924         return (ENOSYS);
 925 }
 926
 927 /*
 928  * See fs_pathconf
 929  */
 930 /* ARGSUSED */
 931 int
 932 fop_pathconf(
 933         vnode_t *vp,
 934         int cmd,
 935         ulong_t *valp,
 936         cred_t *cr,
 937         caller_context_t *ct)
 938 {
 939         register ulong_t val;
 940         register int error = 0;
 941
 942         switch (cmd) {
 943
 944         case _PC_LINK_MAX:
 945                 val = MAXLINK;
 946                 break;
 947
 948         case _PC_MAX_CANON:
 949                 val = MAX_CANON;
 950                 break;
 951
 952         case _PC_MAX_INPUT:
 953                 val = MAX_INPUT;
 954                 break;
 955
 956         case _PC_NAME_MAX:
 957                 val = MAXNAMELEN;
 958                 break;
 959
 960         case _PC_PATH_MAX:
 961         case _PC_SYMLINK_MAX:
 962                 val = MAXPATHLEN;
 963                 break;
 964
 965         case _PC_PIPE_BUF:
 966                 val = PIPE_BUF;
 967                 break;
 968
 969         case _PC_NO_TRUNC:
 970                 val = (ulong_t)-1;
 971                 break;
 972
 973         case _PC_VDISABLE:
 974                 val = _POSIX_VDISABLE;
 975                 break;
 976
 977         case _PC_CHOWN_RESTRICTED:
 978                 val = 1; /* chown restricted enabled */
 979                 break;
 980
 981         case _PC_FILESIZEBITS:
 982                 val = (ulong_t)-1;    /* large file support */
 983                 break;
 984
 985         case _PC_ACL_ENABLED:
 986                 val = 0;
 987                 break;
 988
 989         case _PC_CASE_BEHAVIOR:
 990                 val = _CASE_SENSITIVE;
 991                 break;
 992
 993         case _PC_SATTR_ENABLED:
 994         case _PC_SATTR_EXISTS:
 995                 val = 0;
 996                 break;
 997
 998         case _PC_ACCESS_FILTERING:
 999                 val = 0;
1000                 break;
1001
1002         default:
1003                 error = EINVAL;
1004                 break;
1005         }
1006
1007         if (error == 0)
1008                 *valp = val;
1009         return (error);
1010 }
1011
1012 /* ARGSUSED */
1013 int
1014 fop_pageio(
1015         vnode_t *vp,
1016         struct page *pp,
1017         u_offset_t io_off,
1018         size_t io_len,
1019         int flags,
1020         cred_t *cr,
1021         caller_context_t *ct)
1022 {
1023         return (ENOSYS);
1024 }
1025
1026 /* ARGSUSED */
1027 int
1028 fop_dumpctl(
1029         vnode_t *vp,
1030         int action,
1031         offset_t *blkp,
1032         caller_context_t *ct)
1033 {
1034         return (ENOSYS);
1035 }
1036
1037 /* ARGSUSED */
1038 void
1039 fop_dispose(
1040         vnode_t *vp,
1041         struct page *pp,
1042         int flag,
1043         int dn,
1044         cred_t *cr,
1045         caller_context_t *ct)
1046 {
1047 }
1048
1049 /* ARGSUSED */
1050 int
1051 fop_setsecattr(
1052         vnode_t *vp,
1053         vsecattr_t *vsap,
1054         int flag,
1055         cred_t *cr,
1056         caller_context_t *ct)
1057 {
1058         return (0);
1059 }
1060
1061 /*
1062  * Fake up just enough of this so we can test get/set SDs.
1063  */
1064 /* ARGSUSED */
1065 int
1066 fop_getsecattr(
1067         vnode_t *vp,
1068         vsecattr_t *vsecattr,
1069         int flag,
1070         cred_t *cr,
1071         caller_context_t *ct)
1072 {
1073
1074         vsecattr->vsa_aclcnt    = 0;
1075         vsecattr->vsa_aclentsz  = 0;
1076         vsecattr->vsa_aclentp   = NULL;
1077         vsecattr->vsa_dfaclcnt  = 0;    /* Default ACLs are not fabricated */
1078         vsecattr->vsa_dfaclentp = NULL;
1079
1080         if (vsecattr->vsa_mask & (VSA_ACLCNT | VSA_ACL)) {
1081                 aclent_t *aclentp;
1082                 size_t aclsize;
1083
1084                 aclsize = sizeof (aclent_t);
1085                 vsecattr->vsa_aclcnt = 1;
1086                 vsecattr->vsa_aclentp = kmem_zalloc(aclsize, KM_SLEEP);
1087                 aclentp = vsecattr->vsa_aclentp;
1088
1089                 aclentp->a_type = OTHER_OBJ;
1090                 aclentp->a_perm = 0777;
1091                 aclentp->a_id = (gid_t)-1;
1092                 aclentp++;
1093         } else if (vsecattr->vsa_mask & (VSA_ACECNT | VSA_ACE)) {
1094                 ace_t *acl;
1095
1096                 acl = kmem_alloc(sizeof (ace_t), KM_SLEEP);
1097                 acl->a_who = (uint32_t)-1;
1098                 acl->a_type = ACE_ACCESS_ALLOWED_ACE_TYPE;
1099                 acl->a_flags = ACE_EVERYONE;
1100                 acl->a_access_mask  = ACE_MODIFY_PERMS;
1101
1102                 vsecattr->vsa_aclentp = (void *)acl;
1103                 vsecattr->vsa_aclcnt = 1;
1104                 vsecattr->vsa_aclentsz = sizeof (ace_t);
1105         }
1106
1107         return (0);
1108 }
1109
1110 /* ARGSUSED */
1111 int
1112 fop_shrlock(
1113         vnode_t *vp,
1114         int cmd,
1115         struct shrlock *shr,
1116         int flag,
1117         cred_t *cr,
1118         caller_context_t *ct)
1119 {
1120
1121         switch (cmd) {
1122         case F_SHARE:
1123         case F_SHARE_NBMAND:
1124         case F_UNSHARE:
1125                 break;
1126         default:
1127                 return (EINVAL);
1128         }
1129
1130         if (!fop_shrlock_enable)
1131                 return (0);
1132
1133         if (fcntl(vp->v_fd, cmd, shr) == -1)
1134                 return (errno);
1135
1136         return (0);
1137 }
1138
1139 /* ARGSUSED */
1140 int
1141 fop_vnevent(vnode_t *vp, vnevent_t vnevent, vnode_t *dvp, char *fnm,
1142     caller_context_t *ct)
1143 {
1144         return (ENOSYS);
1145 }
1146
1147 /* ARGSUSED */
1148 int
1149 fop_reqzcbuf(vnode_t *vp, enum uio_rw ioflag, xuio_t *uiop, cred_t *cr,
1150     caller_context_t *ct)
1151 {
1152         return (ENOSYS);
1153 }
1154
1155 /* ARGSUSED */
1156 int
1157 fop_retzcbuf(vnode_t *vp, xuio_t *uiop, cred_t *cr, caller_context_t *ct)
1158 {
1159         return (ENOSYS);
1160 }
1161
1162
1163 /*
1164  * ***************************************************************
1165  * other VOP support
1166  */
1167
1168 /*
1169  * Convert stat(2) formats to vnode types and vice versa.  (Knows about
1170  * numerical order of S_IFMT and vnode types.)
1171  */
1172 enum vtype iftovt_tab[] = {
1173         VNON, VFIFO, VCHR, VNON, VDIR, VNON, VBLK, VNON,
1174         VREG, VNON, VLNK, VNON, VSOCK, VNON, VNON, VNON
1175 };
1176
1177 ushort_t vttoif_tab[] = {
1178         0, S_IFREG, S_IFDIR, S_IFBLK, S_IFCHR, S_IFLNK, S_IFIFO,
1179         S_IFDOOR, 0, S_IFSOCK, S_IFPORT, 0
1180 };
1181
1182 /*
1183  * stat_to_vattr()
1184  *
1185  * Convert from a stat structure to an vattr structure
1186  * Note: only set fields according to va_mask
1187  */
1188
1189 int
1190 stat_to_vattr(const struct stat *st, vattr_t *vap)
1191 {
1192
1193         if (vap->va_mask & AT_TYPE)
1194                 vap->va_type = IFTOVT(st->st_mode);
1195
1196         if (vap->va_mask & AT_MODE)
1197                 vap->va_mode = st->st_mode;
1198
1199         if (vap->va_mask & AT_UID)
1200                 vap->va_uid = st->st_uid;
1201
1202         if (vap->va_mask & AT_GID)
1203                 vap->va_gid = st->st_gid;
1204
1205         if (vap->va_mask & AT_FSID)
1206                 vap->va_fsid = st->st_dev;
1207
1208         if (vap->va_mask & AT_NODEID)
1209                 vap->va_nodeid = st->st_ino;
1210
1211         if (vap->va_mask & AT_NLINK)
1212                 vap->va_nlink = st->st_nlink;
1213
1214         if (vap->va_mask & AT_SIZE)
1215                 vap->va_size = (u_offset_t)st->st_size;
1216
1217         if (vap->va_mask & AT_ATIME) {
1218                 vap->va_atime.tv_sec  = st->st_atim.tv_sec;
1219                 vap->va_atime.tv_nsec = st->st_atim.tv_nsec;
1220         }
1221
1222         if (vap->va_mask & AT_MTIME) {
1223                 vap->va_mtime.tv_sec  = st->st_mtim.tv_sec;
1224                 vap->va_mtime.tv_nsec = st->st_mtim.tv_nsec;
1225         }
1226
1227         if (vap->va_mask & AT_CTIME) {
1228                 vap->va_ctime.tv_sec  = st->st_ctim.tv_sec;
1229                 vap->va_ctime.tv_nsec = st->st_ctim.tv_nsec;
1230         }
1231
1232         if (vap->va_mask & AT_RDEV)
1233                 vap->va_rdev = st->st_rdev;
1234
1235         if (vap->va_mask & AT_BLKSIZE)
1236                 vap->va_blksize = (uint_t)st->st_blksize;
1237
1238
1239         if (vap->va_mask & AT_NBLOCKS)
1240                 vap->va_nblocks = (u_longlong_t)st->st_blocks;
1241
1242         if (vap->va_mask & AT_SEQ)
1243                 vap->va_seq = 0;
1244
1245         return (0);
1246 }
1247
1248 /* ARGSUSED */
1249 void
1250 flk_init_callback(flk_callback_t *flk_cb,
1251         callb_cpr_t *(*cb_fcn)(flk_cb_when_t, void *), void *cbdata)
1252 {
1253 }
1254
1255 void
1256 vn_hold(vnode_t *vp)
1257 {
1258         mutex_enter(&vp->v_lock);
1259         vp->v_count++;
1260         mutex_exit(&vp->v_lock);
1261 }
1262
1263 void
1264 vn_rele(vnode_t *vp)
1265 {
1266         VERIFY3U(vp->v_count, !=, 0);
1267         mutex_enter(&vp->v_lock);
1268         if (vp->v_count == 1) {
1269                 mutex_exit(&vp->v_lock);
1270                 vncache_inactive(vp);
1271         } else {
1272                 vp->v_count--;
1273                 mutex_exit(&vp->v_lock);
1274         }
1275 }
1276
1277 int
1278 vn_has_other_opens(
1279         vnode_t *vp,
1280         v_mode_t mode)
1281 {
1282
1283         switch (mode) {
1284         case V_WRITE:
1285                 if (vp->v_wrcnt > 1)
1286                         return (V_TRUE);
1287                 break;
1288         case V_RDORWR:
1289                 if ((vp->v_rdcnt > 1) || (vp->v_wrcnt > 1))
1290                         return (V_TRUE);
1291                 break;
1292         case V_RDANDWR:
1293                 if ((vp->v_rdcnt > 1) && (vp->v_wrcnt > 1))
1294                         return (V_TRUE);
1295                 break;
1296         case V_READ:
1297                 if (vp->v_rdcnt > 1)
1298                         return (V_TRUE);
1299                 break;
1300         }
1301
1302         return (V_FALSE);
1303 }
1304
1305 /*
1306  * vn_is_opened() checks whether a particular file is opened and
1307  * whether the open is for read and/or write.
1308  *
1309  * Vnode counts are only kept on regular files (v_type=VREG).
1310  */
1311 int
1312 vn_is_opened(
1313         vnode_t *vp,
1314         v_mode_t mode)
1315 {
1316
1317         ASSERT(vp != NULL);
1318
1319         switch (mode) {
1320         case V_WRITE:
1321                 if (vp->v_wrcnt)
1322                         return (V_TRUE);
1323                 break;
1324         case V_RDANDWR:
1325                 if (vp->v_rdcnt && vp->v_wrcnt)
1326                         return (V_TRUE);
1327                 break;
1328         case V_RDORWR:
1329                 if (vp->v_rdcnt || vp->v_wrcnt)
1330                         return (V_TRUE);
1331                 break;
1332         case V_READ:
1333                 if (vp->v_rdcnt)
1334                         return (V_TRUE);
1335                 break;
1336         }
1337
1338         return (V_FALSE);
1339 }
1340
1341 /*
1342  * vn_is_mapped() checks whether a particular file is mapped and whether
1343  * the file is mapped read and/or write.
1344  */
1345 /* ARGSUSED */
1346 int
1347 vn_is_mapped(
1348         vnode_t *vp,
1349         v_mode_t mode)
1350 {
1351         return (V_FALSE);
1352 }