Merge from vendor branch LESS:
[dragonfly.git] / sys / vfs / portal / portal_vnops.c
1 /*
2  * Copyright (c) 1992, 1993
3  *      The Regents of the University of California.  All rights reserved.
4  *
5  * This code is derived from software donated to Berkeley by
6  * Jan-Simon Pendry.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
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 the
15  *    documentation and/or other materials provided with the distribution.
16  * 3. All advertising materials mentioning features or use of this software
17  *    must display the following acknowledgement:
18  *      This product includes software developed by the University of
19  *      California, Berkeley and its contributors.
20  * 4. Neither the name of the University nor the names of its contributors
21  *    may be used to endorse or promote products derived from this software
22  *    without specific prior written permission.
23  *
24  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
25  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
28  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
29  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
30  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
31  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
33  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34  * SUCH DAMAGE.
35  *
36  *      @(#)portal_vnops.c      8.14 (Berkeley) 5/21/95
37  *
38  * $FreeBSD: src/sys/miscfs/portal/portal_vnops.c,v 1.38 1999/12/21 06:29:00 chris Exp $
39  * $DragonFly: src/sys/vfs/portal/portal_vnops.c,v 1.10 2004/03/05 16:57:16 hsu Exp $
40  */
41
42 /*
43  * Portal Filesystem
44  */
45
46 #include <sys/param.h>
47 #include <sys/systm.h>
48 #include <sys/sysproto.h>
49 #include <sys/kernel.h>
50 #include <sys/time.h>
51 #include <sys/proc.h>
52 #include <sys/filedesc.h>
53 #include <sys/vnode.h>
54 #include <sys/fcntl.h>
55 #include <sys/file.h>
56 #include <sys/stat.h>
57 #include <sys/mount.h>
58 #include <sys/malloc.h>
59 #include <sys/namei.h>
60 #include <sys/mbuf.h>
61 #include <sys/resourcevar.h>
62 #include <sys/socket.h>
63 #include <sys/socketvar.h>
64 #include <sys/un.h>
65 #include <sys/unpcb.h>
66 #include "portal.h"
67
68 static int portal_fileid = PORTAL_ROOTFILEID+1;
69
70 static int      portal_badop (void);
71 static void     portal_closefd (struct thread *td, int fd);
72 static int      portal_connect (struct socket *so, struct socket *so2);
73 static int      portal_getattr (struct vop_getattr_args *ap);
74 static int      portal_inactive (struct vop_inactive_args *ap);
75 static int      portal_lookup (struct vop_lookup_args *ap);
76 static int      portal_open (struct vop_open_args *ap);
77 static int      portal_print (struct vop_print_args *ap);
78 static int      portal_readdir (struct vop_readdir_args *ap);
79 static int      portal_reclaim (struct vop_reclaim_args *ap);
80 static int      portal_setattr (struct vop_setattr_args *ap);
81
82 static void
83 portal_closefd(td, fd)
84         struct thread *td;
85         int fd;
86 {
87         int error;
88         struct close_args ua;
89
90         ua.fd = fd;
91         error = close(&ua);
92         /*
93          * We should never get an error, and there isn't anything
94          * we could do if we got one, so just print a message.
95          */
96         if (error)
97                 printf("portal_closefd: error = %d\n", error);
98 }
99
100 /*
101  * vp is the current namei directory
102  * cnp is the name to locate in that directory...
103  */
104 static int
105 portal_lookup(ap)
106         struct vop_lookup_args /* {
107                 struct vnode * a_dvp;
108                 struct vnode ** a_vpp;
109                 struct componentname * a_cnp;
110         } */ *ap;
111 {
112         struct componentname *cnp = ap->a_cnp;
113         struct vnode **vpp = ap->a_vpp;
114         struct vnode *dvp = ap->a_dvp;
115         char *pname = cnp->cn_nameptr;
116         struct portalnode *pt;
117         int error;
118         struct vnode *fvp = 0;
119         char *path;
120         int size;
121
122         *vpp = NULLVP;
123
124         if (cnp->cn_nameiop == NAMEI_DELETE || cnp->cn_nameiop == NAMEI_RENAME)
125                 return (EROFS);
126
127         if (cnp->cn_namelen == 1 && *pname == '.') {
128                 *vpp = dvp;
129                 VREF(dvp);
130                 /*VOP_LOCK(dvp);*/
131                 return (0);
132         }
133
134         /*
135          * Do the MALLOC before the getnewvnode since doing so afterward
136          * might cause a bogus v_data pointer to get dereferenced
137          * elsewhere if MALLOC should block.
138          */
139         MALLOC(pt, struct portalnode *, sizeof(struct portalnode),
140                 M_TEMP, M_WAITOK);
141
142         error = getnewvnode(VT_PORTAL, dvp->v_mount, portal_vnodeop_p, &fvp);
143         if (error) {
144                 FREE(pt, M_TEMP);
145                 goto bad;
146         }
147         fvp->v_type = VREG;
148         fvp->v_data = pt;
149         /*
150          * Save all of the remaining pathname and
151          * advance the namei next pointer to the end
152          * of the string.
153          */
154         for (size = 0, path = pname; *path; path++)
155                 size++;
156         cnp->cn_consume = size - cnp->cn_namelen;
157
158         pt->pt_arg = malloc(size+1, M_TEMP, M_WAITOK);
159         pt->pt_size = size+1;
160         bcopy(pname, pt->pt_arg, pt->pt_size);
161         pt->pt_fileid = portal_fileid++;
162
163         *vpp = fvp;
164         /*VOP_LOCK(fvp);*/
165         return (0);
166
167 bad:;
168         if (fvp)
169                 vrele(fvp);
170         return (error);
171 }
172
173 static int
174 portal_connect(so, so2)
175         struct socket *so;
176         struct socket *so2;
177 {
178         /* from unp_connect, bypassing the namei stuff... */
179         struct socket *so3;
180         struct unpcb *unp2;
181         struct unpcb *unp3;
182
183         if (so2 == 0)
184                 return (ECONNREFUSED);
185
186         if (so->so_type != so2->so_type)
187                 return (EPROTOTYPE);
188
189         if ((so2->so_options & SO_ACCEPTCONN) == 0)
190                 return (ECONNREFUSED);
191
192         if ((so3 = sonewconn(so2, 0)) == 0)
193                 return (ECONNREFUSED);
194
195         unp2 = sotounpcb(so2);
196         unp3 = sotounpcb(so3);
197         if (unp2->unp_addr)
198                 unp3->unp_addr = (struct sockaddr_un *)
199                         dup_sockaddr((struct sockaddr *)unp2->unp_addr, 0);
200         so2 = so3;
201
202         return (unp_connect2(so, so2));
203 }
204
205 static int
206 portal_open(ap)
207         struct vop_open_args /* {
208                 struct vnode *a_vp;
209                 int  a_mode;
210                 struct ucred *a_cred;
211                 struct thread *a_td;
212         } */ *ap;
213 {
214         struct socket *so = 0;
215         struct portalnode *pt;
216         struct thread *td = ap->a_td;
217         struct vnode *vp = ap->a_vp;
218         int s;
219         struct uio auio;
220         struct iovec aiov[2];
221         int res;
222         struct mbuf *cm = 0;
223         struct cmsghdr *cmsg;
224         int newfds;
225         int *ip;
226         int fd;
227         int error;
228         int len;
229         struct portalmount *fmp;
230         struct file *fp;
231         struct portal_cred pcred;
232
233         /*
234          * Nothing to do when opening the root node.
235          */
236         if (vp->v_flag & VROOT)
237                 return (0);
238
239         /*
240          * Can't be opened unless the caller is set up
241          * to deal with the side effects.  Check for this
242          * by testing whether the p_dupfd has been set.
243          */
244         KKASSERT(td->td_proc);
245         if (td->td_proc->p_dupfd >= 0)
246                 return (ENODEV);
247
248         pt = VTOPORTAL(vp);
249         fmp = VFSTOPORTAL(vp->v_mount);
250
251         /*
252          * Create a new socket.
253          */
254         error = socreate(AF_UNIX, &so, SOCK_STREAM, 0, ap->a_td);
255         if (error)
256                 goto bad;
257
258         /*
259          * Reserve some buffer space
260          */
261         res = pt->pt_size + sizeof(pcred) + 512;        /* XXX */
262         error = soreserve(so, res, res, &td->td_proc->p_rlimit[RLIMIT_SBSIZE]);
263         if (error)
264                 goto bad;
265
266         /*
267          * Kick off connection
268          */
269         error = portal_connect(so, (struct socket *)fmp->pm_server->f_data);
270         if (error)
271                 goto bad;
272
273         /*
274          * Wait for connection to complete
275          */
276         /*
277          * XXX: Since the mount point is holding a reference on the
278          * underlying server socket, it is not easy to find out whether
279          * the server process is still running.  To handle this problem
280          * we loop waiting for the new socket to be connected (something
281          * which will only happen if the server is still running) or for
282          * the reference count on the server socket to drop to 1, which
283          * will happen if the server dies.  Sleep for 5 second intervals
284          * and keep polling the reference count.   XXX.
285          */
286         s = splnet();
287         while ((so->so_state & SS_ISCONNECTING) && so->so_error == 0) {
288                 if (fmp->pm_server->f_count == 1) {
289                         error = ECONNREFUSED;
290                         splx(s);
291                         goto bad;
292                 }
293                 (void) tsleep((caddr_t) &so->so_timeo, 0, "portalcon", 5 * hz);
294         }
295         splx(s);
296
297         if (so->so_error) {
298                 error = so->so_error;
299                 goto bad;
300         }
301
302         /*
303          * Set miscellaneous flags
304          */
305         so->so_rcv.sb_timeo = 0;
306         so->so_snd.sb_timeo = 0;
307         so->so_rcv.sb_flags |= SB_NOINTR;
308         so->so_snd.sb_flags |= SB_NOINTR;
309
310
311         pcred.pcr_flag = ap->a_mode;
312         pcred.pcr_uid = ap->a_cred->cr_uid;
313         pcred.pcr_ngroups = ap->a_cred->cr_ngroups;
314         bcopy(ap->a_cred->cr_groups, pcred.pcr_groups, NGROUPS * sizeof(gid_t));
315         aiov[0].iov_base = (caddr_t) &pcred;
316         aiov[0].iov_len = sizeof(pcred);
317         aiov[1].iov_base = pt->pt_arg;
318         aiov[1].iov_len = pt->pt_size;
319         auio.uio_iov = aiov;
320         auio.uio_iovcnt = 2;
321         auio.uio_rw = UIO_WRITE;
322         auio.uio_segflg = UIO_SYSSPACE;
323         auio.uio_td = td;
324         auio.uio_offset = 0;
325         auio.uio_resid = aiov[0].iov_len + aiov[1].iov_len;
326
327         error = sosend(so, (struct sockaddr *) 0, &auio,
328                         (struct mbuf *) 0, (struct mbuf *) 0, 0, td);
329         if (error)
330                 goto bad;
331
332         len = auio.uio_resid = sizeof(int);
333         do {
334                 struct mbuf *m = 0;
335                 int flags = MSG_WAITALL;
336                 error = soreceive(so, (struct sockaddr **) 0, &auio,
337                                         &m, &cm, &flags);
338                 if (error)
339                         goto bad;
340
341                 /*
342                  * Grab an error code from the mbuf.
343                  */
344                 if (m) {
345                         m = m_pullup(m, sizeof(int));   /* Needed? */
346                         if (m) {
347                                 error = *(mtod(m, int *));
348                                 m_freem(m);
349                         } else {
350                                 error = EINVAL;
351                         }
352                 } else {
353                         if (cm == 0) {
354                                 error = ECONNRESET;      /* XXX */
355 #ifdef notdef
356                                 break;
357 #endif
358                         }
359                 }
360         } while (cm == 0 && auio.uio_resid == len && !error);
361
362         if (cm == 0)
363                 goto bad;
364
365         if (auio.uio_resid) {
366                 error = 0;
367 #ifdef notdef
368                 error = EMSGSIZE;
369                 goto bad;
370 #endif
371         }
372
373         /*
374          * XXX: Break apart the control message, and retrieve the
375          * received file descriptor.  Note that more than one descriptor
376          * may have been received, or that the rights chain may have more
377          * than a single mbuf in it.  What to do?
378          */
379         cmsg = mtod(cm, struct cmsghdr *);
380         newfds = (cmsg->cmsg_len - sizeof(*cmsg)) / sizeof (int);
381         if (newfds == 0) {
382                 error = ECONNREFUSED;
383                 goto bad;
384         }
385         /*
386          * At this point the rights message consists of a control message
387          * header, followed by a data region containing a vector of
388          * integer file descriptors.  The fds were allocated by the action
389          * of receiving the control message.
390          */
391         ip = (int *) (cmsg + 1);
392         fd = *ip++;
393         if (newfds > 1) {
394                 /*
395                  * Close extra fds.
396                  */
397                 int i;
398                 printf("portal_open: %d extra fds\n", newfds - 1);
399                 for (i = 1; i < newfds; i++) {
400                         portal_closefd(td, *ip);
401                         ip++;
402                 }
403         }
404
405         /*
406          * Check that the mode the file is being opened for is a subset
407          * of the mode of the existing descriptor.
408          */
409         KKASSERT(td->td_proc);
410         fp = td->td_proc->p_fd->fd_ofiles[fd];
411         if (((ap->a_mode & (FREAD|FWRITE)) | fp->f_flag) != fp->f_flag) {
412                 portal_closefd(td, fd);
413                 error = EACCES;
414                 goto bad;
415         }
416
417         /*
418          * Save the dup fd in the proc structure then return the
419          * special error code (ENXIO) which causes magic things to
420          * happen in vn_open.  The whole concept is, well, hmmm.
421          */
422         td->td_proc->p_dupfd = fd;
423         error = ENXIO;
424
425 bad:;
426         /*
427          * And discard the control message.
428          */
429         if (cm) {
430                 m_freem(cm);
431         }
432
433         if (so) {
434                 soshutdown(so, 2);
435                 soclose(so);
436         }
437         return (error);
438 }
439
440 static int
441 portal_getattr(ap)
442         struct vop_getattr_args /* {
443                 struct vnode *a_vp;
444                 struct vattr *a_vap;
445                 struct ucred *a_cred;
446                 struct thread *a_td;
447         } */ *ap;
448 {
449         struct vnode *vp = ap->a_vp;
450         struct vattr *vap = ap->a_vap;
451
452         bzero(vap, sizeof(*vap));
453         vattr_null(vap);
454         vap->va_uid = 0;
455         vap->va_gid = 0;
456         vap->va_size = DEV_BSIZE;
457         vap->va_blocksize = DEV_BSIZE;
458         nanotime(&vap->va_atime);
459         vap->va_mtime = vap->va_atime;
460         vap->va_ctime = vap->va_mtime;
461         vap->va_gen = 0;
462         vap->va_flags = 0;
463         vap->va_rdev = 0;
464         /* vap->va_qbytes = 0; */
465         vap->va_bytes = 0;
466         /* vap->va_qsize = 0; */
467         if (vp->v_flag & VROOT) {
468                 vap->va_type = VDIR;
469                 vap->va_mode = S_IRUSR|S_IWUSR|S_IXUSR|
470                                 S_IRGRP|S_IWGRP|S_IXGRP|
471                                 S_IROTH|S_IWOTH|S_IXOTH;
472                 vap->va_nlink = 2;
473                 vap->va_fileid = 2;
474         } else {
475                 vap->va_type = VREG;
476                 vap->va_mode = S_IRUSR|S_IWUSR|
477                                 S_IRGRP|S_IWGRP|
478                                 S_IROTH|S_IWOTH;
479                 vap->va_nlink = 1;
480                 vap->va_fileid = VTOPORTAL(vp)->pt_fileid;
481         }
482         return (0);
483 }
484
485 static int
486 portal_setattr(ap)
487         struct vop_setattr_args /* {
488                 struct vnode *a_vp;
489                 struct vattr *a_vap;
490                 struct ucred *a_cred;
491                 struct thread *a_td;
492         } */ *ap;
493 {
494
495         /*
496          * Can't mess with the root vnode
497          */
498         if (ap->a_vp->v_flag & VROOT)
499                 return (EACCES);
500
501         if (ap->a_vap->va_flags != VNOVAL)
502                 return (EOPNOTSUPP);
503
504         return (0);
505 }
506
507 /*
508  * Fake readdir, just return empty directory.
509  * It is hard to deal with '.' and '..' so don't bother.
510  */
511 static int
512 portal_readdir(ap)
513         struct vop_readdir_args /* {
514                 struct vnode *a_vp;
515                 struct uio *a_uio;
516                 struct ucred *a_cred;
517                 int *a_eofflag;
518                 u_long *a_cookies;
519                 int a_ncookies;
520         } */ *ap;
521 {
522
523         /*
524          * We don't allow exporting portal mounts, and currently local
525          * requests do not need cookies.
526          */
527         if (ap->a_ncookies)
528                 panic("portal_readdir: not hungry");
529
530         return (0);
531 }
532
533 static int
534 portal_inactive(ap)
535         struct vop_inactive_args /* {
536                 struct vnode *a_vp;
537                 struct thread *a_td;
538         } */ *ap;
539 {
540
541         VOP_UNLOCK(ap->a_vp, NULL, 0, ap->a_td);
542         return (0);
543 }
544
545 static int
546 portal_reclaim(ap)
547         struct vop_reclaim_args /* {
548                 struct vnode *a_vp;
549         } */ *ap;
550 {
551         struct portalnode *pt = VTOPORTAL(ap->a_vp);
552
553         if (pt->pt_arg) {
554                 free((caddr_t) pt->pt_arg, M_TEMP);
555                 pt->pt_arg = 0;
556         }
557         FREE(ap->a_vp->v_data, M_TEMP);
558         ap->a_vp->v_data = 0;
559
560         return (0);
561 }
562
563
564 /*
565  * Print out the contents of a Portal vnode.
566  */
567 /* ARGSUSED */
568 static int
569 portal_print(ap)
570         struct vop_print_args /* {
571                 struct vnode *a_vp;
572         } */ *ap;
573 {
574
575         printf("tag VT_PORTAL, portal vnode\n");
576         return (0);
577 }
578
579
580 /*
581  * Portal "should never get here" operation
582  */
583 static int
584 portal_badop()
585 {
586
587         panic("portal: bad op");
588         /* NOTREACHED */
589 }
590
591 vop_t **portal_vnodeop_p;
592 static struct vnodeopv_entry_desc portal_vnodeop_entries[] = {
593         { &vop_default_desc,            (vop_t *) vop_defaultop },
594         { &vop_access_desc,             (vop_t *) vop_null },
595         { &vop_bmap_desc,               (vop_t *) portal_badop },
596         { &vop_getattr_desc,            (vop_t *) portal_getattr },
597         { &vop_inactive_desc,           (vop_t *) portal_inactive },
598         { &vop_lookup_desc,             (vop_t *) portal_lookup },
599         { &vop_open_desc,               (vop_t *) portal_open },
600         { &vop_pathconf_desc,           (vop_t *) vop_stdpathconf },
601         { &vop_print_desc,              (vop_t *) portal_print },
602         { &vop_readdir_desc,            (vop_t *) portal_readdir },
603         { &vop_reclaim_desc,            (vop_t *) portal_reclaim },
604         { &vop_setattr_desc,            (vop_t *) portal_setattr },
605         { NULL, NULL }
606 };
607 static struct vnodeopv_desc portal_vnodeop_opv_desc =
608         { &portal_vnodeop_p, portal_vnodeop_entries };
609
610 VNODEOP_SET(portal_vnodeop_opv_desc);