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