sysvbfs_vfsops.c revision 1.37
1 /* $NetBSD: sysvbfs_vfsops.c,v 1.37 2011/07/13 19:51:29 njoly Exp $ */ 2 3 /*- 4 * Copyright (c) 2004 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by UCHIYAMA Yasushi. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 29 * POSSIBILITY OF SUCH DAMAGE. 30 */ 31 32 #include <sys/cdefs.h> 33 __KERNEL_RCSID(0, "$NetBSD: sysvbfs_vfsops.c,v 1.37 2011/07/13 19:51:29 njoly Exp $"); 34 35 #include <sys/types.h> 36 #include <sys/param.h> 37 #include <sys/systm.h> 38 #include <sys/pool.h> 39 #include <sys/time.h> 40 #include <sys/ucred.h> 41 #include <sys/mount.h> 42 #include <sys/disklabel.h> 43 #include <sys/fcntl.h> 44 #include <sys/malloc.h> 45 #include <sys/kauth.h> 46 #include <sys/proc.h> 47 48 /* v-node */ 49 #include <sys/namei.h> 50 #include <sys/vnode.h> 51 /* devsw */ 52 #include <sys/conf.h> 53 54 #include <fs/sysvbfs/sysvbfs.h> /* external interface */ 55 #include <fs/sysvbfs/bfs.h> /* internal interface */ 56 57 #ifdef SYSVBFS_VNOPS_DEBUG 58 #define DPRINTF(fmt, args...) printf(fmt, ##args) 59 #else 60 #define DPRINTF(arg...) ((void)0) 61 #endif 62 63 MALLOC_JUSTDEFINE(M_SYSVBFS_VFS, "sysvbfs vfs", "sysvbfs vfs structures"); 64 65 struct pool sysvbfs_node_pool; 66 67 int sysvbfs_mountfs(struct vnode *, struct mount *, struct lwp *); 68 69 int 70 sysvbfs_mount(struct mount *mp, const char *path, void *data, size_t *data_len) 71 { 72 struct lwp *l = curlwp; 73 struct sysvbfs_args *args = data; 74 struct sysvbfs_mount *bmp = NULL; 75 struct vnode *devvp = NULL; 76 int error; 77 bool update; 78 79 DPRINTF("%s: mnt_flag=%x\n", __func__, mp->mnt_flag); 80 81 if (*data_len < sizeof *args) 82 return EINVAL; 83 84 if (mp->mnt_flag & MNT_GETARGS) { 85 if ((bmp = (void *)mp->mnt_data) == NULL) 86 return EIO; 87 args->fspec = NULL; 88 *data_len = sizeof *args; 89 return 0; 90 } 91 92 93 DPRINTF("%s: args->fspec=%s\n", __func__, args->fspec); 94 update = mp->mnt_flag & MNT_UPDATE; 95 if (args->fspec == NULL) { 96 /* nothing to do. */ 97 return EINVAL; 98 } 99 100 if (args->fspec != NULL) { 101 /* Look up the name and verify that it's sane. */ 102 error = namei_simple_user(args->fspec, 103 NSM_FOLLOW_NOEMULROOT, &devvp); 104 if (error != 0) 105 return (error); 106 107 if (!update) { 108 /* 109 * Be sure this is a valid block device 110 */ 111 if (devvp->v_type != VBLK) 112 error = ENOTBLK; 113 else if (bdevsw_lookup(devvp->v_rdev) == NULL) 114 error = ENXIO; 115 } else { 116 /* 117 * Be sure we're still naming the same device 118 * used for our initial mount 119 */ 120 if (devvp != bmp->devvp) 121 error = EINVAL; 122 } 123 } 124 125 /* 126 * If mount by non-root, then verify that user has necessary 127 * permissions on the device. 128 * 129 * Permission to update a mount is checked higher, so here we presume 130 * updating the mount is okay (for example, as far as securelevel goes) 131 * which leaves us with the normal check. 132 */ 133 if (error == 0) { 134 int accessmode = VREAD; 135 if (update ? 136 (mp->mnt_iflag & IMNT_WANTRDWR) != 0 : 137 (mp->mnt_flag & MNT_RDONLY) == 0) 138 accessmode |= VWRITE; 139 140 error = genfs_can_mount(devvp, accessmode, l->l_cred); 141 } 142 143 if (error) { 144 vrele(devvp); 145 return error; 146 } 147 148 if (!update) { 149 if ((error = sysvbfs_mountfs(devvp, mp, l)) != 0) { 150 vrele(devvp); 151 return error; 152 } 153 } else if (mp->mnt_flag & MNT_RDONLY) { 154 /* XXX: r/w -> read only */ 155 } 156 157 return set_statvfs_info(path, UIO_USERSPACE, args->fspec, UIO_USERSPACE, 158 mp->mnt_op->vfs_name, mp, l); 159 } 160 161 int 162 sysvbfs_mountfs(struct vnode *devvp, struct mount *mp, struct lwp *l) 163 { 164 kauth_cred_t cred = l->l_cred; 165 struct sysvbfs_mount *bmp; 166 struct partinfo dpart; 167 int error, oflags; 168 bool devopen = false; 169 170 vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY); 171 error = vinvalbuf(devvp, V_SAVE, cred, l, 0, 0); 172 if (error) 173 goto out; 174 175 /* Open block device */ 176 oflags = FREAD; 177 if ((mp->mnt_flag & MNT_RDONLY) == 0) 178 oflags |= FWRITE; 179 if ((error = VOP_OPEN(devvp, oflags, NOCRED)) != 0) 180 goto out; 181 devopen = true; 182 183 /* Get partition information */ 184 if ((error = VOP_IOCTL(devvp, DIOCGPART, &dpart, FREAD, cred)) != 0) { 185 goto out; 186 } 187 188 bmp = malloc(sizeof(struct sysvbfs_mount), M_SYSVBFS_VFS, M_WAITOK); 189 if (bmp == NULL) { 190 error = ENOMEM; 191 goto out; 192 } 193 bmp->devvp = devvp; 194 bmp->mountp = mp; 195 if ((error = sysvbfs_bfs_init(&bmp->bfs, devvp)) != 0) { 196 free(bmp, M_SYSVBFS_VFS); 197 goto out; 198 } 199 LIST_INIT(&bmp->bnode_head); 200 201 mp->mnt_data = bmp; 202 mp->mnt_stat.f_fsidx.__fsid_val[0] = (long)devvp->v_rdev; 203 mp->mnt_stat.f_fsidx.__fsid_val[1] = makefstype(MOUNT_SYSVBFS); 204 mp->mnt_stat.f_fsid = mp->mnt_stat.f_fsidx.__fsid_val[0]; 205 mp->mnt_stat.f_namemax = BFS_FILENAME_MAXLEN; 206 mp->mnt_flag |= MNT_LOCAL; 207 mp->mnt_dev_bshift = BFS_BSHIFT; 208 mp->mnt_fs_bshift = BFS_BSHIFT; 209 210 DPRINTF("%s: fstype=%d dtype=%d bsize=%d\n", __func__, 211 dpart.part->p_fstype, dpart.disklab->d_type, 212 dpart.disklab->d_secsize); 213 214 out: 215 if (devopen && error) 216 VOP_CLOSE(devvp, oflags, NOCRED); 217 VOP_UNLOCK(devvp); 218 return error; 219 } 220 221 int 222 sysvbfs_start(struct mount *mp, int flags) 223 { 224 225 DPRINTF("%s:\n", __func__); 226 /* Nothing to do. */ 227 return 0; 228 } 229 230 int 231 sysvbfs_unmount(struct mount *mp, int mntflags) 232 { 233 struct sysvbfs_mount *bmp = (void *)mp->mnt_data; 234 int error; 235 236 DPRINTF("%s: %p\n", __func__, bmp); 237 238 if ((error = vflush(mp, NULLVP, 239 mntflags & MNT_FORCE ? FORCECLOSE : 0)) != 0) 240 return error; 241 242 vn_lock(bmp->devvp, LK_EXCLUSIVE | LK_RETRY); 243 error = VOP_CLOSE(bmp->devvp, FREAD, NOCRED); 244 vput(bmp->devvp); 245 246 sysvbfs_bfs_fini(bmp->bfs); 247 248 free(bmp, M_SYSVBFS_VFS); 249 mp->mnt_data = NULL; 250 mp->mnt_flag &= ~MNT_LOCAL; 251 252 return 0; 253 } 254 255 int 256 sysvbfs_root(struct mount *mp, struct vnode **vpp) 257 { 258 struct vnode *vp; 259 int error; 260 261 DPRINTF("%s:\n", __func__); 262 if ((error = VFS_VGET(mp, BFS_ROOT_INODE, &vp)) != 0) 263 return error; 264 *vpp = vp; 265 266 return 0; 267 } 268 269 int 270 sysvbfs_statvfs(struct mount *mp, struct statvfs *f) 271 { 272 struct sysvbfs_mount *bmp = mp->mnt_data; 273 struct bfs *bfs = bmp->bfs; 274 int free_block; 275 size_t data_block; 276 277 data_block = (bfs->data_end - bfs->data_start) >> BFS_BSHIFT; 278 if (bfs_inode_alloc(bfs, 0, 0, &free_block) != 0) 279 free_block = 0; 280 else 281 free_block = (bfs->data_end >> BFS_BSHIFT) - free_block; 282 283 DPRINTF("%s: %d %d %d\n", __func__, bfs->data_start, 284 bfs->data_end, free_block); 285 286 f->f_bsize = BFS_BSIZE; 287 f->f_frsize = BFS_BSIZE; 288 f->f_iosize = BFS_BSIZE; 289 f->f_blocks = data_block; 290 f->f_bfree = free_block; 291 f->f_bavail = f->f_bfree; 292 f->f_bresvd = 0; 293 f->f_files = bfs->n_inode; 294 f->f_ffree = bfs->max_inode - f->f_files; 295 f->f_favail = f->f_ffree; 296 f->f_fresvd = 0; 297 copy_statvfs_info(f, mp); 298 299 return 0; 300 } 301 302 int 303 sysvbfs_sync(struct mount *mp, int waitfor, kauth_cred_t cred) 304 { 305 struct sysvbfs_mount *bmp = mp->mnt_data; 306 struct sysvbfs_node *bnode; 307 struct vnode *v; 308 int err, error; 309 310 DPRINTF("%s:\n", __func__); 311 error = 0; 312 mutex_enter(&mntvnode_lock); 313 for (bnode = LIST_FIRST(&bmp->bnode_head); bnode != NULL; 314 bnode = LIST_NEXT(bnode, link)) { 315 v = bnode->vnode; 316 mutex_enter(v->v_interlock); 317 mutex_exit(&mntvnode_lock); 318 err = vget(v, LK_EXCLUSIVE | LK_NOWAIT); 319 if (err == 0) { 320 err = VOP_FSYNC(v, cred, FSYNC_WAIT, 0, 0); 321 vput(v); 322 } 323 if (err != 0) 324 error = err; 325 mutex_enter(&mntvnode_lock); 326 } 327 mutex_exit(&mntvnode_lock); 328 329 return error; 330 } 331 332 int 333 sysvbfs_vget(struct mount *mp, ino_t ino, struct vnode **vpp) 334 { 335 struct sysvbfs_mount *bmp = mp->mnt_data; 336 struct bfs *bfs = bmp->bfs; 337 struct vnode *vp; 338 struct sysvbfs_node *bnode; 339 struct bfs_inode *inode; 340 int error; 341 342 DPRINTF("%s: i-node=%lld\n", __func__, (long long)ino); 343 /* Lookup requested i-node */ 344 if (!bfs_inode_lookup(bfs, ino, &inode)) { 345 DPRINTF("%s: bfs_inode_lookup failed.\n", __func__); 346 return ENOENT; 347 } 348 349 retry: 350 mutex_enter(&mntvnode_lock); 351 for (bnode = LIST_FIRST(&bmp->bnode_head); bnode != NULL; 352 bnode = LIST_NEXT(bnode, link)) { 353 if (bnode->inode->number == ino) { 354 vp = bnode->vnode; 355 mutex_enter(vp->v_interlock); 356 mutex_exit(&mntvnode_lock); 357 if (vget(vp, LK_EXCLUSIVE) == 0) { 358 *vpp = vp; 359 return 0; 360 } else { 361 goto retry; 362 } 363 } 364 } 365 mutex_exit(&mntvnode_lock); 366 367 /* Allocate v-node. */ 368 error = getnewvnode(VT_SYSVBFS, mp, sysvbfs_vnodeop_p, NULL, &vp); 369 if (error) { 370 DPRINTF("%s: getnewvnode error.\n", __func__); 371 return error; 372 } 373 /* Lock vnode here */ 374 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY); 375 376 /* Allocate i-node */ 377 vp->v_data = pool_get(&sysvbfs_node_pool, PR_WAITOK); 378 memset(vp->v_data, 0, sizeof(struct sysvbfs_node)); 379 bnode = vp->v_data; 380 mutex_enter(&mntvnode_lock); 381 LIST_INSERT_HEAD(&bmp->bnode_head, bnode, link); 382 mutex_exit(&mntvnode_lock); 383 bnode->vnode = vp; 384 bnode->bmp = bmp; 385 bnode->inode = inode; 386 bnode->lockf = NULL; /* advlock */ 387 388 if (ino == BFS_ROOT_INODE) { /* BFS is flat filesystem */ 389 vp->v_type = VDIR; 390 vp->v_vflag |= VV_ROOT; 391 } else { 392 vp->v_type = VREG; 393 } 394 395 genfs_node_init(vp, &sysvbfs_genfsops); 396 uvm_vnp_setsize(vp, bfs_file_size(inode)); 397 *vpp = vp; 398 399 return 0; 400 } 401 402 int 403 sysvbfs_fhtovp(struct mount *mp, struct fid *fid, struct vnode **vpp) 404 { 405 406 DPRINTF("%s:\n", __func__); 407 /* notyet */ 408 return EOPNOTSUPP; 409 } 410 411 int 412 sysvbfs_vptofh(struct vnode *vpp, struct fid *fid, size_t *fh_size) 413 { 414 415 DPRINTF("%s:\n", __func__); 416 /* notyet */ 417 return EOPNOTSUPP; 418 } 419 420 MALLOC_DECLARE(M_BFS); 421 MALLOC_DECLARE(M_SYSVBFS_VNODE); 422 423 void 424 sysvbfs_init(void) 425 { 426 427 DPRINTF("%s:\n", __func__); 428 malloc_type_attach(M_SYSVBFS_VFS); 429 malloc_type_attach(M_BFS); 430 malloc_type_attach(M_SYSVBFS_VNODE); 431 pool_init(&sysvbfs_node_pool, sizeof(struct sysvbfs_node), 0, 0, 0, 432 "sysvbfs_node_pool", &pool_allocator_nointr, IPL_NONE); 433 } 434 435 void 436 sysvbfs_reinit(void) 437 { 438 439 /* Nothing to do. */ 440 DPRINTF("%s:\n", __func__); 441 } 442 443 void 444 sysvbfs_done(void) 445 { 446 447 DPRINTF("%s:\n", __func__); 448 pool_destroy(&sysvbfs_node_pool); 449 malloc_type_detach(M_BFS); 450 malloc_type_detach(M_SYSVBFS_VFS); 451 malloc_type_detach(M_SYSVBFS_VNODE); 452 } 453 454 int 455 sysvbfs_gop_alloc(struct vnode *vp, off_t off, off_t len, int flags, 456 kauth_cred_t cred) 457 { 458 459 return 0; 460 } 461
Indexes created Tue Sep 23 02:09:52 GMT 2025