xref: /illumos-gate/usr/src/lib/smbsrv/libfksmbsrv/common/fake_vop.c (revision 28b6fd27d5ff75fe6fdeb119a21575b0652a7e70) 
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 }
1353