sys/miscfs/kernfs/kernfs_vfsops.c

   1 /*      $NetBSD: kernfs_vfsops.c,v 1.89 2009/03/15 17:22:38 cegger Exp $        */
   2
   3 /*
   4  * Copyright (c) 1992, 1993, 1995
   5  *      The Regents of the University of California.  All rights reserved.
   6  *
   7  * This code is derived from software donated to Berkeley by
   8  * Jan-Simon Pendry.
   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  * 3. Neither the name of the University nor the names of its contributors
  19  *    may be used to endorse or promote products derived from this software
  20  *    without specific prior written permission.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  25  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  26  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  27  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  28  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  31  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  32  * SUCH DAMAGE.
  33  *
  34  *      @(#)kernfs_vfsops.c     8.10 (Berkeley) 5/14/95
  35  */
  36
  37 /*
  38  * Kernel params Filesystem
  39  */
  40
  41 #include <sys/cdefs.h>
  42 __KERNEL_RCSID(0, "$NetBSD: kernfs_vfsops.c,v 1.89 2009/03/15 17:22:38 cegger Exp $");
  43
  44 #ifdef _KERNEL_OPT
  45 #include "opt_compat_netbsd.h"
  46 #endif
  47
  48 #include <sys/param.h>
  49 #include <sys/systm.h>
  50 #include <sys/sysctl.h>
  51 #include <sys/conf.h>
  52 #include <sys/proc.h>
  53 #include <sys/vnode.h>
  54 #include <sys/mount.h>
  55 #include <sys/namei.h>
  56 #include <sys/dirent.h>
  57 #include <sys/malloc.h>
  58 #include <sys/syslog.h>
  59 #include <sys/kauth.h>
  60 #include <sys/module.h>
  61
  62 #include <miscfs/genfs/genfs.h>
  63 #include <miscfs/specfs/specdev.h>
  64 #include <miscfs/kernfs/kernfs.h>
  65
  66 MODULE(MODULE_CLASS_VFS, kernfs, NULL);
  67
  68 MALLOC_JUSTDEFINE(M_KERNFSMNT, "kernfs mount", "kernfs mount structures");
  69
  70 dev_t rrootdev = NODEV;
  71
  72 VFS_PROTOS(kernfs);
  73
  74 void    kernfs_get_rrootdev(void);
  75
  76 static struct sysctllog *kernfs_sysctl_log;
  77
  78 void
  79 kernfs_init(void)
  80 {
  81
  82         malloc_type_attach(M_KERNFSMNT);
  83         kernfs_hashinit();
  84 }
  85
  86 void
  87 kernfs_reinit(void)
  88 {
  89         kernfs_hashreinit();
  90 }
  91
  92 void
  93 kernfs_done(void)
  94 {
  95
  96         kernfs_hashdone();
  97         malloc_type_detach(M_KERNFSMNT);
  98 }
  99
 100 void
 101 kernfs_get_rrootdev(void)
 102 {
 103         static int tried = 0;
 104
 105         if (tried) {
 106                 /* Already did it once. */
 107                 return;
 108         }
 109         tried = 1;
 110
 111         if (rootdev == NODEV)
 112                 return;
 113         rrootdev = devsw_blk2chr(rootdev);
 114         if (rrootdev != NODEV)
 115                 return;
 116         rrootdev = NODEV;
 117         printf("kernfs_get_rrootdev: no raw root device\n");
 118 }
 119
 120 /*
 121  * Mount the Kernel params filesystem
 122  */
 123 int
 124 kernfs_mount(struct mount *mp, const char *path, void *data, size_t *data_len)
 125 {
 126         struct lwp *l = curlwp;
 127         int error = 0;
 128         struct kernfs_mount *fmp;
 129
 130         if (UIO_MX & (UIO_MX - 1)) {
 131                 log(LOG_ERR, "kernfs: invalid directory entry size");
 132                 return (EINVAL);
 133         }
 134
 135         if (mp->mnt_flag & MNT_GETARGS) {
 136                 *data_len = 0;
 137                 return 0;
 138         }
 139         /*
 140          * Update is a no-op
 141          */
 142         if (mp->mnt_flag & MNT_UPDATE)
 143                 return (EOPNOTSUPP);
 144
 145         fmp = malloc(sizeof(struct kernfs_mount), M_KERNFSMNT, M_WAITOK|M_ZERO);
 146         TAILQ_INIT(&fmp->nodelist);
 147
 148         mp->mnt_stat.f_namemax = MAXNAMLEN;
 149         mp->mnt_flag |= MNT_LOCAL;
 150         mp->mnt_data = fmp;
 151         vfs_getnewfsid(mp);
 152
 153         if ((error = set_statvfs_info(path, UIO_USERSPACE, "kernfs",
 154             UIO_SYSSPACE, mp->mnt_op->vfs_name, mp, l)) != 0) {
 155                 free(fmp, M_KERNFSMNT);
 156                 return error;
 157         }
 158
 159         kernfs_get_rrootdev();
 160         return 0;
 161 }
 162
 163 int
 164 kernfs_start(struct mount *mp, int flags)
 165 {
 166
 167         return (0);
 168 }
 169
 170 int
 171 kernfs_unmount(struct mount *mp, int mntflags)
 172 {
 173         int error;
 174         int flags = 0;
 175
 176         if (mntflags & MNT_FORCE)
 177                 flags |= FORCECLOSE;
 178
 179         if ((error = vflush(mp, 0, flags)) != 0)
 180                 return (error);
 181
 182         /*
 183          * Finally, throw away the kernfs_mount structure
 184          */
 185         free(mp->mnt_data, M_KERNFSMNT);
 186         mp->mnt_data = NULL;
 187         return (0);
 188 }
 189
 190 int
 191 kernfs_root(struct mount *mp, struct vnode **vpp)
 192 {
 193
 194         /* setup "." */
 195         return (kernfs_allocvp(mp, vpp, KFSkern, &kern_targets[0], 0));
 196 }
 197
 198 /*ARGSUSED*/
 199 int
 200 kernfs_sync(struct mount *mp, int waitfor,
 201     kauth_cred_t uc)
 202 {
 203
 204         return (0);
 205 }
 206
 207 /*
 208  * Kernfs flat namespace lookup.
 209  * Currently unsupported.
 210  */
 211 int
 212 kernfs_vget(struct mount *mp, ino_t ino,
 213     struct vnode **vpp)
 214 {
 215
 216         return (EOPNOTSUPP);
 217 }
 218
 219 extern const struct vnodeopv_desc kernfs_vnodeop_opv_desc;
 220
 221 const struct vnodeopv_desc * const kernfs_vnodeopv_descs[] = {
 222         &kernfs_vnodeop_opv_desc,
 223         NULL,
 224 };
 225
 226 struct vfsops kernfs_vfsops = {
 227         MOUNT_KERNFS,
 228         0,
 229         kernfs_mount,
 230         kernfs_start,
 231         kernfs_unmount,
 232         kernfs_root,
 233         (void *)eopnotsupp,             /* vfs_quotactl */
 234         genfs_statvfs,
 235         kernfs_sync,
 236         kernfs_vget,
 237         (void *)eopnotsupp,             /* vfs_fhtovp */
 238         (void *)eopnotsupp,             /* vfs_vptofh */
 239         kernfs_init,
 240         kernfs_reinit,
 241         kernfs_done,
 242         NULL,                           /* vfs_mountroot */
 243         (int (*)(struct mount *, struct vnode *, struct timespec *)) eopnotsupp,
 244         vfs_stdextattrctl,
 245         (void *)eopnotsupp,             /* vfs_suspendctl */
 246         genfs_renamelock_enter,
 247         genfs_renamelock_exit,
 248         (void *)eopnotsupp,
 249         kernfs_vnodeopv_descs,
 250         0,
 251         { NULL, NULL },
 252 };
 253
 254 static int
 255 kernfs_modcmd(modcmd_t cmd, void *arg)
 256 {
 257         int error;
 258
 259         switch (cmd) {
 260         case MODULE_CMD_INIT:
 261                 error = vfs_attach(&kernfs_vfsops);
 262                 if (error != 0)
 263                         break;
 264                 sysctl_createv(&kernfs_sysctl_log, 0, NULL, NULL,
 265                                CTLFLAG_PERMANENT,
 266                                CTLTYPE_NODE, "vfs", NULL,
 267                                NULL, 0, NULL, 0,
 268                                CTL_VFS, CTL_EOL);
 269                 sysctl_createv(&kernfs_sysctl_log, 0, NULL, NULL,
 270                                CTLFLAG_PERMANENT,
 271                                CTLTYPE_NODE, "kernfs",
 272                                SYSCTL_DESCR("/kern file system"),
 273                                NULL, 0, NULL, 0,
 274                                CTL_VFS, 11, CTL_EOL);
 275                 /*
 276                  * XXX the "11" above could be dynamic, thereby eliminating one
 277                  * more instance of the "number to vfs" mapping problem, but
 278                  * "11" is the order as taken from sys/mount.h
 279                  */
 280                 break;
 281         case MODULE_CMD_FINI:
 282                 error = vfs_detach(&kernfs_vfsops);
 283                 if (error != 0)
 284                         break;
 285                 sysctl_teardown(&kernfs_sysctl_log);
 286                 break;
 287         default:
 288                 error = ENOTTY;
 289                 break;
 290         }
 291
 292         return (error);
 293 }