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