sys/fs/sysvbfs/sysvbfs_vfsops.c

   1 /*      $NetBSD: sysvbfs_vfsops.c,v 1.30 2009/06/29 05:08:17 dholland 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.30 2009/06/29 05:08:17 dholland 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_flag |= MNT_LOCAL;
 206         mp->mnt_dev_bshift = BFS_BSHIFT;
 207         mp->mnt_fs_bshift = BFS_BSHIFT;
 208
 209         DPRINTF("fstype=%d dtype=%d bsize=%d\n", dpart.part->p_fstype,
 210             dpart.disklab->d_type, dpart.disklab->d_secsize);
 211
 212  out:
 213         if (devopen && error)
 214                 VOP_CLOSE(devvp, oflags, NOCRED);
 215         VOP_UNLOCK(devvp, 0);
 216         return error;
 217 }
 218
 219 int
 220 sysvbfs_start(struct mount *mp, int flags)
 221 {
 222
 223         DPRINTF("%s:\n", __func__);
 224         /* Nothing to do. */
 225         return 0;
 226 }
 227
 228 int
 229 sysvbfs_unmount(struct mount *mp, int mntflags)
 230 {
 231         struct sysvbfs_mount *bmp = (void *)mp->mnt_data;
 232         int error;
 233
 234         DPRINTF("%s: %p\n", __func__, bmp);
 235
 236         if ((error = vflush(mp, NULLVP,
 237             mntflags & MNT_FORCE ? FORCECLOSE : 0)) != 0)
 238                 return error;
 239
 240         vn_lock(bmp->devvp, LK_EXCLUSIVE | LK_RETRY);
 241         error = VOP_CLOSE(bmp->devvp, FREAD, NOCRED);
 242         vput(bmp->devvp);
 243
 244         sysvbfs_bfs_fini(bmp->bfs);
 245
 246         free(bmp, M_SYSVBFS_VFS);
 247         mp->mnt_data = NULL;
 248         mp->mnt_flag &= ~MNT_LOCAL;
 249
 250         return 0;
 251 }
 252
 253 int
 254 sysvbfs_root(struct mount *mp, struct vnode **vpp)
 255 {
 256         struct vnode *vp;
 257         int error;
 258
 259         DPRINTF("%s:\n", __func__);
 260         if ((error = VFS_VGET(mp, BFS_ROOT_INODE, &vp)) != 0)
 261                 return error;
 262         *vpp = vp;
 263
 264         return 0;
 265 }
 266
 267 int
 268 sysvbfs_statvfs(struct mount *mp, struct statvfs *f)
 269 {
 270         struct sysvbfs_mount *bmp = mp->mnt_data;
 271         struct bfs *bfs = bmp->bfs;
 272         int free_block;
 273         size_t data_block;
 274
 275         data_block = (bfs->data_end - bfs->data_start) >> BFS_BSHIFT;
 276         if (bfs_inode_alloc(bfs, 0, 0, &free_block) != 0)
 277                 free_block = 0;
 278         else
 279                 free_block = (bfs->data_end >> BFS_BSHIFT) - free_block;
 280
 281         DPRINTF("%s: %d %d %d\n", __func__, bfs->data_start,
 282             bfs->data_end, free_block);
 283
 284         f->f_bsize = BFS_BSIZE;
 285         f->f_frsize = BFS_BSIZE;
 286         f->f_iosize = BFS_BSIZE;
 287         f->f_blocks = data_block;
 288         f->f_bfree = free_block;
 289         f->f_bavail = f->f_bfree;
 290         f->f_bresvd = 0;
 291         f->f_files = bfs->n_inode;
 292         f->f_ffree = bfs->max_inode - f->f_files;
 293         f->f_favail = f->f_ffree;
 294         f->f_fresvd = 0;
 295         copy_statvfs_info(f, mp);
 296
 297         return 0;
 298 }
 299
 300 int
 301 sysvbfs_sync(struct mount *mp, int waitfor, kauth_cred_t cred)
 302 {
 303         struct sysvbfs_mount *bmp = mp->mnt_data;
 304         struct sysvbfs_node *bnode;
 305         struct vnode *v;
 306         int err, error;
 307
 308         DPRINTF("%s:\n", __func__);
 309         error = 0;
 310         mutex_enter(&mntvnode_lock);
 311         for (bnode = LIST_FIRST(&bmp->bnode_head); bnode != NULL;
 312             bnode = LIST_NEXT(bnode, link)) {
 313                 v = bnode->vnode;
 314                 mutex_enter(&v->v_interlock);
 315                 mutex_exit(&mntvnode_lock);
 316                 err = vget(v, LK_EXCLUSIVE | LK_NOWAIT | LK_INTERLOCK);
 317                 if (err == 0) {
 318                         err = VOP_FSYNC(v, cred, FSYNC_WAIT, 0, 0);
 319                         vput(v);
 320                 }
 321                 if (err != 0)
 322                         error = err;
 323                 mutex_enter(&mntvnode_lock);
 324         }
 325         mutex_exit(&mntvnode_lock);
 326
 327         return error;
 328 }
 329
 330 int
 331 sysvbfs_vget(struct mount *mp, ino_t ino, struct vnode **vpp)
 332 {
 333         struct sysvbfs_mount *bmp = mp->mnt_data;
 334         struct bfs *bfs = bmp->bfs;
 335         struct vnode *vp;
 336         struct sysvbfs_node *bnode;
 337         struct bfs_inode *inode;
 338         int error;
 339
 340         DPRINTF("%s: i-node=%lld\n", __func__, (long long)ino);
 341         /* Lookup requested i-node */
 342         if (!bfs_inode_lookup(bfs, ino, &inode)) {
 343                 DPRINTF("bfs_inode_lookup failed.\n");
 344                 return ENOENT;
 345         }
 346
 347  retry:
 348         mutex_enter(&mntvnode_lock);
 349         for (bnode = LIST_FIRST(&bmp->bnode_head); bnode != NULL;
 350             bnode = LIST_NEXT(bnode, link)) {
 351                 if (bnode->inode->number == ino) {
 352                         vp = bnode->vnode;
 353                         mutex_enter(&vp->v_interlock);
 354                         mutex_exit(&mntvnode_lock);
 355                         if (vget(vp, LK_EXCLUSIVE|LK_RETRY|LK_INTERLOCK) == 0) {
 356                                 *vpp = vp;
 357                                 return 0;
 358                         } else {
 359                                 goto retry;
 360                         }
 361                 }
 362         }
 363         mutex_exit(&mntvnode_lock);
 364
 365         /* Allocate v-node. */
 366         if ((error = getnewvnode(VT_SYSVBFS, mp, sysvbfs_vnodeop_p, &vp)) !=
 367             0) {
 368                 DPRINTF("%s: getnewvnode error.\n", __func__);
 369                 return error;
 370         }
 371         /* Lock vnode here */
 372         vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
 373
 374         /* Allocate i-node */
 375         vp->v_data = pool_get(&sysvbfs_node_pool, PR_WAITOK);
 376         memset(vp->v_data, 0, sizeof(struct sysvbfs_node));
 377         bnode = vp->v_data;
 378         mutex_enter(&mntvnode_lock);
 379         LIST_INSERT_HEAD(&bmp->bnode_head, bnode, link);
 380         mutex_exit(&mntvnode_lock);
 381         bnode->vnode = vp;
 382         bnode->bmp = bmp;
 383         bnode->inode = inode;
 384         bnode->lockf = NULL; /* advlock */
 385
 386         if (ino == BFS_ROOT_INODE) {    /* BFS is flat filesystem */
 387                 vp->v_type = VDIR;
 388                 vp->v_vflag |= VV_ROOT;
 389         } else {
 390                 vp->v_type = VREG;
 391         }
 392
 393         genfs_node_init(vp, &sysvbfs_genfsops);
 394         uvm_vnp_setsize(vp, bfs_file_size(inode));
 395         *vpp = vp;
 396
 397         return 0;
 398 }
 399
 400 int
 401 sysvbfs_fhtovp(struct mount *mp, struct fid *fid, struct vnode **vpp)
 402 {
 403
 404         DPRINTF("%s:\n", __func__);
 405         /* notyet */
 406         return EOPNOTSUPP;
 407 }
 408
 409 int
 410 sysvbfs_vptofh(struct vnode *vpp, struct fid *fid, size_t *fh_size)
 411 {
 412
 413         DPRINTF("%s:\n", __func__);
 414         /* notyet */
 415         return EOPNOTSUPP;
 416 }
 417
 418 MALLOC_DECLARE(M_BFS);
 419 MALLOC_DECLARE(M_SYSVBFS_VNODE);
 420
 421 void
 422 sysvbfs_init(void)
 423 {
 424
 425         DPRINTF("%s:\n", __func__);
 426         malloc_type_attach(M_SYSVBFS_VFS);
 427         malloc_type_attach(M_BFS);
 428         malloc_type_attach(M_SYSVBFS_VNODE);
 429         pool_init(&sysvbfs_node_pool, sizeof(struct sysvbfs_node), 0, 0, 0,
 430             "sysvbfs_node_pool", &pool_allocator_nointr, IPL_NONE);
 431 }
 432
 433 void
 434 sysvbfs_reinit(void)
 435 {
 436
 437         /* Nothing to do. */
 438         DPRINTF("%s:\n", __func__);
 439 }
 440
 441 void
 442 sysvbfs_done(void)
 443 {
 444
 445         DPRINTF("%s:\n", __func__);
 446         pool_destroy(&sysvbfs_node_pool);
 447         malloc_type_detach(M_BFS);
 448         malloc_type_detach(M_SYSVBFS_VFS);
 449         malloc_type_detach(M_SYSVBFS_VNODE);
 450 }
 451
 452 int
 453 sysvbfs_gop_alloc(struct vnode *vp, off_t off, off_t len, int flags,
 454     kauth_cred_t cred)
 455 {
 456
 457         return 0;
 458 }