rumpfs.c revision 1.9
1 /* $NetBSD: rumpfs.c,v 1.9 2009/03/19 09:14:37 pooka Exp $ */ 2 3 /* 4 * Copyright (c) 2007 Antti Kantee. All Rights Reserved. 5 * 6 * Development of this software was supported by Google Summer of Code. 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 * 17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS 18 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 19 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 20 * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 23 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 27 * SUCH DAMAGE. 28 */ 29 30 #include <sys/cdefs.h> 31 __KERNEL_RCSID(0, "$NetBSD: rumpfs.c,v 1.9 2009/03/19 09:14:37 pooka Exp $"); 32 33 #include <sys/param.h> 34 #include <sys/mount.h> 35 #include <sys/vnode.h> 36 #include <sys/errno.h> 37 #include <sys/kauth.h> 38 #include <sys/lock.h> 39 #include <sys/lockf.h> 40 #include <sys/stat.h> 41 #include <sys/namei.h> 42 #include <sys/queue.h> 43 #include <sys/filedesc.h> 44 #include <sys/syscallargs.h> 45 46 #include <miscfs/fifofs/fifo.h> 47 #include <miscfs/specfs/specdev.h> 48 #include <miscfs/genfs/genfs.h> 49 50 #include <rump/rumpuser.h> 51 52 #include "rump_private.h" 53 #include "rump_vfs_private.h" 54 55 static int rump_vop_lookup(void *); 56 static int rump_vop_getattr(void *); 57 static int rump_vop_success(void *); 58 59 int (**dead_vnodeop_p)(void *); 60 const struct vnodeopv_entry_desc dead_vnodeop_entries[] = { 61 { &vop_default_desc, vn_default_error }, 62 { NULL, NULL } 63 }; 64 const struct vnodeopv_desc dead_vnodeop_opv_desc = 65 { &dead_vnodeop_p, dead_vnodeop_entries }; 66 67 int (**fifo_vnodeop_p)(void *); 68 const struct vnodeopv_entry_desc fifo_vnodeop_entries[] = { 69 { &vop_default_desc, vn_default_error }, 70 { NULL, NULL } 71 }; 72 const struct vnodeopv_desc fifo_vnodeop_opv_desc = 73 { &fifo_vnodeop_p, fifo_vnodeop_entries }; 74 75 int (**rump_vnodeop_p)(void *); 76 const struct vnodeopv_entry_desc rump_vnodeop_entries[] = { 77 { &vop_default_desc, vn_default_error }, 78 { &vop_lookup_desc, rump_vop_lookup }, 79 { &vop_getattr_desc, rump_vop_getattr }, 80 { &vop_putpages_desc, rump_vop_success }, 81 { &vop_fsync_desc, rump_vop_success }, 82 { &vop_lock_desc, genfs_lock }, 83 { &vop_unlock_desc, genfs_unlock }, 84 { NULL, NULL } 85 }; 86 const struct vnodeopv_desc rump_vnodeop_opv_desc = 87 { &rump_vnodeop_p, rump_vnodeop_entries }; 88 const struct vnodeopv_desc * const rump_opv_descs[] = { 89 &rump_vnodeop_opv_desc, 90 NULL 91 }; 92 93 static struct mount rump_mnt; 94 static int lastino = 1; 95 96 static struct vattr * 97 makevattr(enum vtype vt) 98 { 99 struct vattr *va; 100 struct timespec ts; 101 102 nanotime(&ts); 103 104 va = kmem_alloc(sizeof(*va), KM_SLEEP); 105 va->va_type = vt; 106 va->va_mode = 0755; 107 va->va_nlink = 2; 108 va->va_uid = 0; 109 va->va_gid = 0; 110 va->va_fsid = 111 va->va_fileid = atomic_inc_uint_nv(&lastino); 112 va->va_size = 512; 113 va->va_blocksize = 512; 114 va->va_atime = ts; 115 va->va_mtime = ts; 116 va->va_ctime = ts; 117 va->va_birthtime = ts; 118 va->va_gen = 0; 119 va->va_flags = 0; 120 va->va_rdev = -1; 121 va->va_bytes = 512; 122 va->va_filerev = 0; 123 va->va_vaflags = 0; 124 125 return va; 126 } 127 128 static int 129 rump_makevnode(const char *path, size_t size, enum vtype vt, struct vnode **vpp) 130 { 131 struct vnode *vp; 132 int rv; 133 134 vp = kmem_alloc(sizeof(struct vnode), KM_SLEEP); 135 vp->v_size = vp->v_writesize = size; 136 vp->v_type = vt; 137 if (vp->v_type == VREG) 138 vp->v_type = VBLK; 139 140 if (vp->v_type != VBLK && vp->v_type != VDIR) 141 panic("rump_makevnode: only VBLK/VDIR vnodes supported"); 142 143 if (vp->v_type == VBLK) { 144 rv = rumpblk_register(path); 145 if (rv == -1) { 146 rv = EINVAL; 147 goto bad; 148 } 149 spec_node_init(vp, makedev(RUMPBLK, rv)); 150 vp->v_op = spec_vnodeop_p; 151 } else { 152 vp->v_op = rump_vnodeop_p; 153 } 154 vp->v_tag = VT_RUMP; 155 vp->v_mount = &rump_mnt; 156 vp->v_vnlock = &vp->v_lock; 157 vp->v_usecount = 1; 158 vp->v_data = makevattr(vp->v_type); 159 mutex_init(&vp->v_interlock, MUTEX_DEFAULT, IPL_NONE); 160 memset(&vp->v_lock, 0, sizeof(vp->v_lock)); 161 rw_init(&vp->v_lock.vl_lock); 162 cv_init(&vp->v_cv, "vnode"); 163 *vpp = vp; 164 165 return 0; 166 167 bad: 168 kmem_free(vp, sizeof(*vp)); 169 return rv; 170 } 171 172 /* 173 * Simple lookup for faking lookup of device entry for rump file systems 174 */ 175 static int 176 rump_vop_lookup(void *v) 177 { 178 struct vop_lookup_args /* { 179 struct vnode *a_dvp; 180 struct vnode **a_vpp; 181 struct componentname *a_cnp; 182 }; */ *ap = v; 183 struct componentname *cnp = ap->a_cnp; 184 uint64_t fsize; 185 enum vtype vt; 186 int rv, error, ft; 187 188 /* we handle only some "non-special" cases */ 189 KASSERT(cnp->cn_nameiop == LOOKUP); 190 KASSERT(cnp->cn_flags & FOLLOW); 191 KASSERT((cnp->cn_flags & ISDOTDOT) == 0); 192 KASSERT(cnp->cn_namelen != 0 && cnp->cn_pnbuf[0] != '.'); 193 194 rv = rumpuser_getfileinfo(cnp->cn_pnbuf, &fsize, &ft, &error); 195 if (rv) 196 return error; 197 switch (ft) { 198 case RUMPUSER_FT_DIR: 199 vt = VDIR; 200 break; 201 case RUMPUSER_FT_REG: 202 vt = VREG; 203 break; 204 case RUMPUSER_FT_BLK: 205 vt = VBLK; 206 break; 207 default: 208 vt = VBAD; 209 break; 210 } 211 212 error = rump_makevnode(cnp->cn_pnbuf, fsize, vt, ap->a_vpp); 213 if (error) 214 return error; 215 216 vn_lock(*ap->a_vpp, LK_RETRY | LK_EXCLUSIVE); 217 cnp->cn_consume = strlen(cnp->cn_nameptr + cnp->cn_namelen); 218 cnp->cn_flags &= ~REQUIREDIR; 219 220 return 0; 221 } 222 223 static int 224 rump_vop_getattr(void *v) 225 { 226 struct vop_getattr_args /* { 227 struct vnode *a_vp; 228 struct vattr *a_vap; 229 kauth_cred_t a_cred; 230 } */ *ap = v; 231 232 memcpy(ap->a_vap, ap->a_vp->v_data, sizeof(struct vattr)); 233 return 0; 234 } 235 236 static int 237 rump_vop_success(void *v) 238 { 239 240 return 0; 241 } 242 243 void 244 rumpfs_init(void) 245 { 246 int rv; 247 248 vfs_opv_init(rump_opv_descs); 249 rv = rump_makevnode("/", 0, VDIR, &rootvnode); 250 if (rv) 251 panic("could not create root vnode: %d", rv); 252 rootvnode->v_vflag |= VV_ROOT; 253 } 254
Indexes created Tue Sep 30 11:09:46 GMT 2025