Annotation of sys/miscfs/portal/portal_vnops.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: portal_vnops.c,v 1.24 2007/06/18 08:30:07 jasper Exp $ */
2: /* $NetBSD: portal_vnops.c,v 1.17 1996/02/13 13:12:57 mycroft Exp $ */
3:
4: /*
5: * Copyright (c) 1992, 1993
6: * The Regents of the University of California. All rights reserved.
7: *
8: * This code is derived from software donated to Berkeley by
9: * Jan-Simon Pendry.
10: *
11: * Redistribution and use in source and binary forms, with or without
12: * modification, are permitted provided that the following conditions
13: * are met:
14: * 1. Redistributions of source code must retain the above copyright
15: * notice, this list of conditions and the following disclaimer.
16: * 2. Redistributions in binary form must reproduce the above copyright
17: * notice, this list of conditions and the following disclaimer in the
18: * documentation and/or other materials provided with the distribution.
19: * 3. Neither the name of the University nor the names of its contributors
20: * may be used to endorse or promote products derived from this software
21: * without specific prior written permission.
22: *
23: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
24: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
25: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
26: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
27: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
28: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
29: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
30: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
31: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
32: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33: * SUCH DAMAGE.
34: *
35: * from: Id: portal_vnops.c,v 1.4 1992/05/30 10:05:24 jsp Exp
36: * @(#)portal_vnops.c 8.8 (Berkeley) 1/21/94
37: */
38:
39: /*
40: * Portal Filesystem
41: */
42:
43: #include <sys/param.h>
44: #include <sys/systm.h>
45: #include <sys/kernel.h>
46: #include <sys/types.h>
47: #include <sys/time.h>
48: #include <sys/proc.h>
49: #include <sys/filedesc.h>
50: #include <sys/vnode.h>
51: #include <sys/file.h>
52: #include <sys/stat.h>
53: #include <sys/mount.h>
54: #include <sys/malloc.h>
55: #include <sys/namei.h>
56: #include <sys/mbuf.h>
57: #include <sys/poll.h>
58: #include <sys/socket.h>
59: #include <sys/socketvar.h>
60: #include <sys/un.h>
61: #include <sys/unpcb.h>
62: #include <sys/syscallargs.h>
63: #include <miscfs/portal/portal.h>
64:
65: static int portal_fileid = PORTAL_ROOTFILEID+1;
66:
67: static void portal_closefd(struct proc *, int);
68: static int portal_connect(struct socket *, struct socket *);
69:
70:
71: int portal_badop(void *);
72:
73: int portal_lookup(void *);
74: #define portal_create eopnotsupp
75: #define portal_mknod eopnotsupp
76: int portal_open(void *);
77: #define portal_close nullop
78: #define portal_access nullop
79: int portal_getattr(void *);
80: int portal_setattr(void *);
81: #define portal_read eopnotsupp
82: #define portal_write eopnotsupp
83: #define portal_ioctl (int (*)(void *))enoioctl
84: #define portal_fsync nullop
85: #define portal_remove eopnotsupp
86: int portal_link(void *);
87: #define portal_rename eopnotsupp
88: #define portal_mkdir eopnotsupp
89: #define portal_rmdir eopnotsupp
90: int portal_symlink(void *);
91: int portal_readdir(void *);
92: #define portal_revoke vop_generic_revoke
93: #define portal_readlink eopnotsupp
94: int portal_inactive(void *);
95: int portal_reclaim(void *);
96: #define portal_lock vop_generic_lock
97: #define portal_unlock vop_generic_unlock
98: #define portal_bmap portal_badop
99: #define portal_strategy portal_badop
100: int portal_print(void *);
101: #define portal_islocked vop_generic_islocked
102: int portal_pathconf(void *);
103: #define portal_advlock eopnotsupp
104: #define portal_bwrite eopnotsupp
105: int portal_poll(void *);
106:
107: int (**portal_vnodeop_p)(void *);
108: struct vnodeopv_entry_desc portal_vnodeop_entries[] = {
109: { &vop_default_desc, vn_default_error },
110: { &vop_lookup_desc, portal_lookup }, /* lookup */
111: { &vop_create_desc, portal_create }, /* create */
112: { &vop_mknod_desc, portal_mknod }, /* mknod */
113: { &vop_open_desc, portal_open }, /* open */
114: { &vop_close_desc, portal_close }, /* close */
115: { &vop_access_desc, portal_access }, /* access */
116: { &vop_getattr_desc, portal_getattr }, /* getattr */
117: { &vop_setattr_desc, portal_setattr }, /* setattr */
118: { &vop_read_desc, portal_read }, /* read */
119: { &vop_write_desc, portal_write }, /* write */
120: { &vop_ioctl_desc, portal_ioctl }, /* ioctl */
121: { &vop_poll_desc, portal_poll }, /* poll */
122: { &vop_revoke_desc, portal_revoke }, /* revoke */
123: { &vop_fsync_desc, portal_fsync }, /* fsync */
124: { &vop_remove_desc, portal_remove }, /* remove */
125: { &vop_link_desc, portal_link }, /* link */
126: { &vop_rename_desc, portal_rename }, /* rename */
127: { &vop_mkdir_desc, portal_mkdir }, /* mkdir */
128: { &vop_rmdir_desc, portal_rmdir }, /* rmdir */
129: { &vop_symlink_desc, portal_symlink }, /* symlink */
130: { &vop_readdir_desc, portal_readdir }, /* readdir */
131: { &vop_readlink_desc, portal_readlink }, /* readlink */
132: { &vop_abortop_desc, vop_generic_abortop }, /* abortop */
133: { &vop_inactive_desc, portal_inactive }, /* inactive */
134: { &vop_reclaim_desc, portal_reclaim }, /* reclaim */
135: { &vop_lock_desc, portal_lock }, /* lock */
136: { &vop_unlock_desc, portal_unlock }, /* unlock */
137: { &vop_bmap_desc, portal_bmap }, /* bmap */
138: { &vop_strategy_desc, portal_strategy }, /* strategy */
139: { &vop_print_desc, portal_print }, /* print */
140: { &vop_islocked_desc, portal_islocked }, /* islocked */
141: { &vop_pathconf_desc, portal_pathconf }, /* pathconf */
142: { &vop_advlock_desc, portal_advlock }, /* advlock */
143: { &vop_bwrite_desc, portal_bwrite }, /* bwrite */
144: { NULL, NULL }
145: };
146: struct vnodeopv_desc portal_vnodeop_opv_desc =
147: { &portal_vnodeop_p, portal_vnodeop_entries };
148:
149: static void
150: portal_closefd(struct proc *p, int fd)
151: {
152: struct sys_close_args /* {
153: syscallarg(int) fd;
154: } */ ua;
155: register_t retval[2];
156: int error;
157:
158: SCARG(&ua, fd) = fd;
159: error = sys_close(p, &ua, retval);
160: /*
161: * We should never get an error, and there isn't anything
162: * we could do if we got one, so just print a message.
163: */
164: if (error)
165: printf("portal_closefd: error = %d\n", error);
166: }
167:
168: /*
169: * vp is the current namei directory
170: * cnp is the name to locate in that directory...
171: */
172: int
173: portal_lookup(void *v)
174: {
175: struct vop_lookup_args *ap = v;
176: struct componentname *cnp = ap->a_cnp;
177: struct vnode **vpp = ap->a_vpp;
178: struct vnode *dvp = ap->a_dvp;
179: char *pname = cnp->cn_nameptr;
180: struct proc *p = cnp->cn_proc;
181: struct portalnode *pt;
182: int error;
183: struct vnode *fvp = 0;
184: char *path;
185: int size;
186:
187: *vpp = NULLVP;
188:
189: if (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME)
190: return (EROFS);
191:
192: if (cnp->cn_namelen == 1 && *pname == '.') {
193: *vpp = dvp;
194: VREF(dvp);
195: return (0);
196: }
197:
198: error = getnewvnode(VT_PORTAL, dvp->v_mount, portal_vnodeop_p, &fvp);
199: if (error)
200: goto bad;
201: fvp->v_type = VREG;
202: MALLOC(fvp->v_data, void *, sizeof(struct portalnode), M_TEMP,
203: M_WAITOK);
204:
205: pt = VTOPORTAL(fvp);
206: /*
207: * Save all of the remaining pathname and
208: * advance the namei next pointer to the end
209: * of the string.
210: */
211: for (size = 0, path = pname; *path; path++)
212: size++;
213: cnp->cn_consume = size - cnp->cn_namelen;
214:
215: pt->pt_arg = malloc(size+1, M_TEMP, M_WAITOK);
216: pt->pt_size = size+1;
217: bcopy(pname, pt->pt_arg, pt->pt_size);
218: pt->pt_fileid = portal_fileid++;
219:
220: *vpp = fvp;
221: VOP_LOCK(fvp, LK_EXCLUSIVE, p);
222: /*
223: * As we are the last component of the path name, fix up
224: * the locking on the directory node.
225: */
226: if ((cnp->cn_flags & LOCKPARENT) == 0) {
227: VOP_UNLOCK(dvp, 0, p);
228: cnp->cn_flags |= PDIRUNLOCK;
229: }
230: return (0);
231:
232: bad:;
233: if (fvp)
234: vrele(fvp);
235: return (error);
236: }
237:
238: static int
239: portal_connect(struct socket *so, struct socket *so2)
240: {
241: /* from unp_connect, bypassing the namei stuff... */
242: struct socket *so3;
243: struct unpcb *unp2;
244: struct unpcb *unp3;
245:
246: if (so2 == 0)
247: return (ECONNREFUSED);
248:
249: if (so->so_type != so2->so_type)
250: return (EPROTOTYPE);
251:
252: if ((so2->so_options & SO_ACCEPTCONN) == 0)
253: return (ECONNREFUSED);
254:
255: if ((so3 = sonewconn(so2, 0)) == 0)
256: return (ECONNREFUSED);
257:
258: unp2 = sotounpcb(so2);
259: unp3 = sotounpcb(so3);
260: if (unp2->unp_addr)
261: unp3->unp_addr = m_copy(unp2->unp_addr, 0, (int)M_COPYALL);
262:
263: so2 = so3;
264:
265:
266: return (unp_connect2(so, so2));
267: }
268:
269: int
270: portal_open(void *v)
271: {
272: struct vop_open_args *ap = v;
273: struct socket *so = 0;
274: struct portalnode *pt;
275: struct proc *p = ap->a_p;
276: struct vnode *vp = ap->a_vp;
277: int s;
278: struct uio auio;
279: struct iovec aiov[2];
280: int res;
281: struct mbuf *cm = 0;
282: struct cmsghdr *cmsg;
283: int newfds;
284: int *ip;
285: int fd;
286: int error;
287: int len;
288: struct portalmount *fmp;
289: struct file *fp;
290: struct portal_cred pcred;
291:
292: /*
293: * Nothing to do when opening the root node.
294: */
295: if (vp->v_flag & VROOT)
296: return (0);
297:
298: /*
299: * Can't be opened unless the caller is set up
300: * to deal with the side effects. Check for this
301: * by testing whether the p_dupfd has been set.
302: */
303: if (p->p_dupfd >= 0)
304: return (ENODEV);
305:
306: pt = VTOPORTAL(vp);
307: fmp = VFSTOPORTAL(vp->v_mount);
308:
309: /*
310: * Create a new socket.
311: */
312: error = socreate(AF_UNIX, &so, SOCK_STREAM, 0);
313: if (error)
314: goto bad;
315:
316: /*
317: * Reserve some buffer space
318: */
319: res = pt->pt_size + sizeof(pcred) + 512; /* XXX */
320: error = soreserve(so, res, res);
321: if (error)
322: goto bad;
323:
324: /*
325: * Kick off connection
326: */
327: s = splsoftnet();
328: error = portal_connect(so, (struct socket *)fmp->pm_server->f_data);
329: splx(s);
330: if (error)
331: goto bad;
332:
333: /*
334: * Wait for connection to complete
335: */
336: /*
337: * XXX: Since the mount point is holding a reference on the
338: * underlying server socket, it is not easy to find out whether
339: * the server process is still running. To handle this problem
340: * we loop waiting for the new socket to be connected (something
341: * which will only happen if the server is still running) or for
342: * the reference count on the server socket to drop to 1, which
343: * will happen if the server dies. Sleep for 5 second intervals
344: * and keep polling the reference count. XXX.
345: */
346: s = splsoftnet();
347: while ((so->so_state & SS_ISCONNECTING) && so->so_error == 0) {
348: if (fmp->pm_server->f_count == 1) {
349: error = ECONNREFUSED;
350: splx(s);
351: goto bad;
352: }
353: (void) tsleep(&so->so_timeo, PSOCK, "portalcon", 5 * hz);
354: }
355: splx(s);
356:
357: if (so->so_error) {
358: error = so->so_error;
359: goto bad;
360: }
361:
362: /*
363: * Set miscellaneous flags
364: */
365: so->so_rcv.sb_timeo = 0;
366: so->so_snd.sb_timeo = 0;
367: so->so_rcv.sb_flags |= SB_NOINTR;
368: so->so_snd.sb_flags |= SB_NOINTR;
369:
370:
371: pcred.pcr_flag = ap->a_mode;
372: pcred.pcr_uid = ap->a_cred->cr_uid;
373: pcred.pcr_gid = ap->a_cred->cr_gid;
374: pcred.pcr_ngroups = ap->a_cred->cr_ngroups;
375: bcopy(ap->a_cred->cr_groups, pcred.pcr_groups, NGROUPS * sizeof(gid_t));
376: aiov[0].iov_base = &pcred;
377: aiov[0].iov_len = sizeof(pcred);
378: aiov[1].iov_base = pt->pt_arg;
379: aiov[1].iov_len = pt->pt_size;
380: auio.uio_iov = aiov;
381: auio.uio_iovcnt = 2;
382: auio.uio_rw = UIO_WRITE;
383: auio.uio_segflg = UIO_SYSSPACE;
384: auio.uio_procp = p;
385: auio.uio_offset = 0;
386: auio.uio_resid = aiov[0].iov_len + aiov[1].iov_len;
387:
388: error = sosend(so, (struct mbuf *) 0, &auio,
389: (struct mbuf *) 0, (struct mbuf *) 0, 0);
390: if (error)
391: goto bad;
392:
393: len = auio.uio_resid = sizeof(int);
394: do {
395: struct mbuf *m = 0;
396: int flags = MSG_WAITALL;
397: fdpunlock(p->p_fd);
398: error = soreceive(so, (struct mbuf **) 0, &auio,
399: &m, &cm, &flags);
400: fdplock(p->p_fd);
401: if (error)
402: goto bad;
403:
404: /*
405: * Grab an error code from the mbuf.
406: */
407: if (m) {
408: m = m_pullup(m, sizeof(int)); /* Needed? */
409: if (m) {
410: error = *(mtod(m, int *));
411: m_freem(m);
412: } else {
413: error = EINVAL;
414: }
415: } else {
416: if (cm == 0) {
417: error = ECONNRESET; /* XXX */
418: #ifdef notdef
419: break;
420: #endif
421: }
422: }
423: } while (cm == 0 && auio.uio_resid == len && !error);
424:
425: if (cm == 0)
426: goto bad;
427:
428: if (auio.uio_resid) {
429: error = 0;
430: #ifdef notdef
431: error = EMSGSIZE;
432: goto bad;
433: #endif
434: }
435:
436: /*
437: * XXX: Break apart the control message, and retrieve the
438: * received file descriptor. Note that more than one descriptor
439: * may have been received, or that the rights chain may have more
440: * than a single mbuf in it. What to do?
441: */
442: cmsg = mtod(cm, struct cmsghdr *);
443: newfds = (cmsg->cmsg_len - sizeof(*cmsg)) / sizeof (int);
444: if (newfds == 0) {
445: error = ECONNREFUSED;
446: goto bad;
447: }
448: /*
449: * At this point the rights message consists of a control message
450: * header, followed by a data region containing a vector of
451: * integer file descriptors. The fds were allocated by the action
452: * of receiving the control message.
453: */
454: ip = (int *)(cmsg + 1);
455: fd = *ip++;
456: if (newfds > 1) {
457: /*
458: * Close extra fds.
459: */
460: int i;
461: printf("portal_open: %d extra fds\n", newfds - 1);
462: for (i = 1; i < newfds; i++) {
463: portal_closefd(p, *ip);
464: ip++;
465: }
466: }
467:
468: /*
469: * Check that the mode the file is being opened for is a subset
470: * of the mode of the existing descriptor.
471: */
472: if ((fp = fd_getfile(p->p_fd, fd)) == NULL) {
473: error = EBADF;
474: goto bad;
475: }
476: if (((ap->a_mode & (FREAD|FWRITE)) | fp->f_flag) != fp->f_flag) {
477: portal_closefd(p, fd);
478: error = EACCES;
479: goto bad;
480: }
481:
482: /*
483: * Save the dup fd in the proc structure then return the
484: * special error code (ENXIO) which causes magic things to
485: * happen in vn_open. The whole concept is, well, hmmm.
486: */
487: p->p_dupfd = fd;
488: error = ENXIO;
489:
490: bad:;
491: /*
492: * And discard the control message.
493: */
494: if (cm) {
495: m_freem(cm);
496: }
497:
498: if (so) {
499: soshutdown(so, 2);
500: soclose(so);
501: }
502: return (error);
503: }
504:
505: int
506: portal_getattr(void *v)
507: {
508: struct vop_getattr_args *ap = v;
509: struct vnode *vp = ap->a_vp;
510: struct vattr *vap = ap->a_vap;
511:
512: bzero(vap, sizeof(*vap));
513: vattr_null(vap);
514: vap->va_uid = 0;
515: vap->va_gid = 0;
516: vap->va_fsid = vp->v_mount->mnt_stat.f_fsid.val[0];
517: vap->va_size = DEV_BSIZE;
518: vap->va_blocksize = DEV_BSIZE;
519: getnanotime(&vap->va_atime);
520: vap->va_mtime = vap->va_atime;
521: vap->va_ctime = vap->va_atime;
522: vap->va_gen = 0;
523: vap->va_flags = 0;
524: vap->va_rdev = 0;
525: /* vap->va_qbytes = 0; */
526: vap->va_bytes = 0;
527: /* vap->va_qsize = 0; */
528: if (vp->v_flag & VROOT) {
529: vap->va_type = VDIR;
530: vap->va_mode = S_IRUSR|S_IWUSR|S_IXUSR|
531: S_IRGRP|S_IWGRP|S_IXGRP|
532: S_IROTH|S_IWOTH|S_IXOTH;
533: vap->va_nlink = 2;
534: vap->va_fileid = 2;
535: } else {
536: vap->va_type = VREG;
537: vap->va_mode = S_IRUSR|S_IWUSR|
538: S_IRGRP|S_IWGRP|
539: S_IROTH|S_IWOTH;
540: vap->va_nlink = 1;
541: vap->va_fileid = VTOPORTAL(vp)->pt_fileid;
542: }
543: return (0);
544: }
545:
546: int
547: portal_setattr(void *v)
548: {
549: struct vop_setattr_args *ap = v;
550:
551: /*
552: * Can't mess with the root vnode
553: */
554: if (ap->a_vp->v_flag & VROOT)
555: return (EACCES);
556:
557: if (ap->a_vap->va_flags != VNOVAL)
558: return (EOPNOTSUPP);
559:
560: return (0);
561: }
562:
563: /*
564: * Fake readdir, just return empty directory.
565: * It is hard to deal with '.' and '..' so don't bother.
566: */
567: /*ARGSUSED*/
568: int
569: portal_readdir(void *v)
570: {
571: return (0);
572: }
573:
574: /*ARGSUSED*/
575: int
576: portal_inactive(void *v)
577: {
578: struct vop_inactive_args *ap = v;
579:
580: VOP_UNLOCK(ap->a_vp, 0, ap->a_p);
581: return (0);
582: }
583:
584: int
585: portal_reclaim(void *v)
586: {
587: struct vop_reclaim_args *ap = v;
588: struct portalnode *pt = VTOPORTAL(ap->a_vp);
589:
590: if (pt->pt_arg) {
591: free(pt->pt_arg, M_TEMP);
592: pt->pt_arg = 0;
593: }
594: FREE(ap->a_vp->v_data, M_TEMP);
595: ap->a_vp->v_data = 0;
596:
597: return (0);
598: }
599:
600: /*
601: * Return POSIX pathconf information applicable to special devices.
602: */
603: int
604: portal_pathconf(void *v)
605: {
606: struct vop_pathconf_args *ap = v;
607:
608: switch (ap->a_name) {
609: case _PC_LINK_MAX:
610: *ap->a_retval = LINK_MAX;
611: return (0);
612: case _PC_MAX_CANON:
613: *ap->a_retval = MAX_CANON;
614: return (0);
615: case _PC_MAX_INPUT:
616: *ap->a_retval = MAX_INPUT;
617: return (0);
618: case _PC_PIPE_BUF:
619: *ap->a_retval = PIPE_BUF;
620: return (0);
621: case _PC_CHOWN_RESTRICTED:
622: *ap->a_retval = 1;
623: return (0);
624: case _PC_VDISABLE:
625: *ap->a_retval = _POSIX_VDISABLE;
626: return (0);
627: default:
628: return (EINVAL);
629: }
630: /* NOTREACHED */
631: }
632:
633: /*
634: * Print out the contents of a Portal vnode.
635: */
636: /* ARGSUSED */
637: int
638: portal_print(void *v)
639: {
640: printf("tag VT_PORTAL, portal vnode\n");
641: return (0);
642: }
643:
644: int
645: portal_link(void *v)
646: {
647: struct vop_link_args *ap = v;
648:
649: VOP_ABORTOP(ap->a_dvp, ap->a_cnp);
650: vput(ap->a_dvp);
651: return (EROFS);
652: }
653:
654: int
655: portal_symlink(void *v)
656: {
657: struct vop_symlink_args *ap = v;
658:
659: VOP_ABORTOP(ap->a_dvp, ap->a_cnp);
660: vput(ap->a_dvp);
661: return (EROFS);
662: }
663:
664: int
665: portal_badop(void *v)
666: {
667: panic ("portal: bad op");
668: return (0);
669: }
670:
671: int
672: portal_poll(void *v)
673: {
674: struct vop_poll_args *ap = v;
675:
676: return (ap->a_events & (POLLIN | POLLOUT | POLLRDNORM | POLLWRNORM));
677: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to portal_vnops.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / miscfs / portal