sys/fs/ptyfs/ptyfs_vfsops.c

   1 /*      $NetBSD: ptyfs_vfsops.c,v 1.41 2009/11/30 10:59:19 pooka 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  */
  35
  36 /*
  37  * Pseudo-tty Filesystem
  38  */
  39
  40 #include <sys/cdefs.h>
  41 __KERNEL_RCSID(0, "$NetBSD: ptyfs_vfsops.c,v 1.41 2009/11/30 10:59:19 pooka Exp $");
  42
  43 #include <sys/param.h>
  44 #include <sys/systm.h>
  45 #include <sys/sysctl.h>
  46 #include <sys/conf.h>
  47 #include <sys/proc.h>
  48 #include <sys/vnode.h>
  49 #include <sys/mount.h>
  50 #include <sys/namei.h>
  51 #include <sys/stat.h>
  52 #include <sys/dirent.h>
  53 #include <sys/malloc.h>
  54 #include <sys/syslog.h>
  55 #include <sys/select.h>
  56 #include <sys/filedesc.h>
  57 #include <sys/tty.h>
  58 #include <sys/pty.h>
  59 #include <sys/kauth.h>
  60 #include <sys/module.h>
  61
  62 #include <fs/ptyfs/ptyfs.h>
  63 #include <miscfs/genfs/genfs.h>
  64 #include <miscfs/specfs/specdev.h>
  65
  66 MODULE(MODULE_CLASS_VFS, ptyfs, NULL);
  67
  68 MALLOC_JUSTDEFINE(M_PTYFSMNT, "ptyfs mount", "ptyfs mount structures");
  69 MALLOC_JUSTDEFINE(M_PTYFSTMP, "ptyfs temp", "ptyfs temporary structures");
  70
  71 VFS_PROTOS(ptyfs);
  72
  73 static struct sysctllog *ptyfs_sysctl_log;
  74
  75 static int ptyfs__allocvp(struct ptm_pty *, struct lwp *, struct vnode **,
  76     dev_t, char);
  77 static int ptyfs__makename(struct ptm_pty *, struct lwp *, char *, size_t,
  78     dev_t, char);
  79 static void ptyfs__getvattr(struct ptm_pty *, struct lwp *, struct vattr *);
  80
  81 /*
  82  * ptm glue: When we mount, we make ptm point to us.
  83  */
  84 struct ptm_pty *ptyfs_save_ptm;
  85 static int ptyfs_count;
  86
  87 struct ptm_pty ptm_ptyfspty = {
  88         ptyfs__allocvp,
  89         ptyfs__makename,
  90         ptyfs__getvattr,
  91         NULL
  92 };
  93
  94 static const char *
  95 ptyfs__getpath(struct lwp *l, const struct mount *mp)
  96 {
  97 #define MAXBUF (sizeof(mp->mnt_stat.f_mntonname) + 32)
  98         struct cwdinfo *cwdi = l->l_proc->p_cwdi;
  99         char *buf;
 100         const char *rv;
 101         size_t len;
 102         char *bp;
 103         int error;
 104         struct ptyfsmount *pmnt = mp->mnt_data;
 105
 106         rv = mp->mnt_stat.f_mntonname;
 107         if (cwdi->cwdi_rdir == NULL ||
 108             (pmnt->pmnt_flags & PTYFSMNT_CHROOT) == 0)
 109                 return rv;
 110
 111         buf = malloc(MAXBUF, M_TEMP, M_WAITOK);
 112         bp = buf + MAXBUF;
 113         *--bp = '\0';
 114         error = getcwd_common(cwdi->cwdi_rdir, rootvnode, &bp,
 115             buf, MAXBUF / 2, 0, l);
 116         if (error)      /* XXX */
 117                 goto out;
 118
 119         len = strlen(bp);
 120         if (len < sizeof(mp->mnt_stat.f_mntonname))     /* XXX */
 121                 rv += len;
 122 out:
 123         free(buf, M_TEMP);
 124         return rv;
 125 }
 126
 127 static int
 128 ptyfs__makename(struct ptm_pty *pt, struct lwp *l, char *tbuf, size_t bufsiz,
 129     dev_t dev, char ms)
 130 {
 131         struct mount *mp = pt->arg;
 132         size_t len;
 133
 134         switch (ms) {
 135         case 'p':
 136                 /* We don't provide access to the master, should we? */
 137                 len = snprintf(tbuf, bufsiz, "/dev/null");
 138                 break;
 139         case 't':
 140                 len = snprintf(tbuf, bufsiz, "%s/%llu", ptyfs__getpath(l, mp),
 141                     (unsigned long long)minor(dev));
 142                 break;
 143         default:
 144                 return EINVAL;
 145         }
 146
 147         return len >= bufsiz ? ENOSPC : 0;
 148 }
 149
 150
 151 static int
 152 /*ARGSUSED*/
 153 ptyfs__allocvp(struct ptm_pty *pt, struct lwp *l, struct vnode **vpp,
 154     dev_t dev, char ms)
 155 {
 156         struct mount *mp = pt->arg;
 157         ptyfstype type;
 158
 159         switch (ms) {
 160         case 'p':
 161                 type = PTYFSptc;
 162                 break;
 163         case 't':
 164                 type = PTYFSpts;
 165                 break;
 166         default:
 167                 return EINVAL;
 168         }
 169
 170         return ptyfs_allocvp(mp, vpp, type, minor(dev), l);
 171 }
 172
 173
 174 static void
 175 ptyfs__getvattr(struct ptm_pty *pt, struct lwp *l, struct vattr *vattr)
 176 {
 177         struct mount *mp = pt->arg;
 178         struct ptyfsmount *pmnt = VFSTOPTY(mp);
 179         vattr_null(vattr);
 180         /* get real uid */
 181         vattr->va_uid = kauth_cred_getuid(l->l_cred);
 182         vattr->va_gid = pmnt->pmnt_gid;
 183         vattr->va_mode = pmnt->pmnt_mode;
 184 }
 185
 186
 187 void
 188 ptyfs_init(void)
 189 {
 190
 191         malloc_type_attach(M_PTYFSMNT);
 192         malloc_type_attach(M_PTYFSTMP);
 193         ptyfs_hashinit();
 194 }
 195
 196 void
 197 ptyfs_reinit(void)
 198 {
 199         ptyfs_hashreinit();
 200 }
 201
 202 void
 203 ptyfs_done(void)
 204 {
 205
 206         ptyfs_hashdone();
 207         malloc_type_detach(M_PTYFSTMP);
 208         malloc_type_detach(M_PTYFSMNT);
 209 }
 210
 211 #define OSIZE sizeof(struct { int f; gid_t g; mode_t m; })
 212 /*
 213  * Mount the Pseudo tty params filesystem
 214  */
 215 int
 216 ptyfs_mount(struct mount *mp, const char *path, void *data, size_t *data_len)
 217 {
 218         struct lwp *l = curlwp;
 219         int error = 0;
 220         struct ptyfsmount *pmnt;
 221         struct ptyfs_args *args = data;
 222
 223         if (*data_len != sizeof *args && *data_len != OSIZE)
 224                 return EINVAL;
 225
 226         if (UIO_MX & (UIO_MX - 1)) {
 227                 log(LOG_ERR, "ptyfs: invalid directory entry size");
 228                 return EINVAL;
 229         }
 230
 231         if (mp->mnt_flag & MNT_GETARGS) {
 232                 pmnt = VFSTOPTY(mp);
 233                 if (pmnt == NULL)
 234                         return EIO;
 235                 args->mode = pmnt->pmnt_mode;
 236                 args->gid = pmnt->pmnt_gid;
 237                 if (args->version >= PTYFS_ARGSVERSION) {
 238                         args->flags = pmnt->pmnt_flags;
 239                         *data_len = sizeof *args;
 240                 } else {
 241                         *data_len = OSIZE;
 242                 }
 243                 return 0;
 244         }
 245
 246         /* Don't allow more than one mount */
 247         if (ptyfs_count)
 248                 return EBUSY;
 249
 250         if (mp->mnt_flag & MNT_UPDATE)
 251                 return EOPNOTSUPP;
 252
 253         if (args->version > PTYFS_ARGSVERSION)
 254                 return EINVAL;
 255
 256         pmnt = malloc(sizeof(struct ptyfsmount), M_PTYFSMNT, M_WAITOK);
 257
 258         mp->mnt_data = pmnt;
 259         pmnt->pmnt_gid = args->gid;
 260         pmnt->pmnt_mode = args->mode;
 261         if (args->version >= PTYFS_ARGSVERSION)
 262                 pmnt->pmnt_flags = args->flags;
 263         else
 264                 pmnt->pmnt_flags = 0;
 265         mp->mnt_flag |= MNT_LOCAL;
 266         vfs_getnewfsid(mp);
 267
 268         if ((error = set_statvfs_info(path, UIO_USERSPACE, "ptyfs",
 269             UIO_SYSSPACE, mp->mnt_op->vfs_name, mp, l)) != 0) {
 270                 free(pmnt, M_PTYFSMNT);
 271                 return error;
 272         }
 273
 274         /* Point pty access to us */
 275
 276         ptm_ptyfspty.arg = mp;
 277         ptyfs_save_ptm = pty_sethandler(&ptm_ptyfspty);
 278         ptyfs_count++;
 279         return 0;
 280 }
 281
 282 /*ARGSUSED*/
 283 int
 284 ptyfs_start(struct mount *mp, int flags)
 285 {
 286         return 0;
 287 }
 288
 289 /*ARGSUSED*/
 290 int
 291 ptyfs_unmount(struct mount *mp, int mntflags)
 292 {
 293         int error;
 294         int flags = 0;
 295
 296         if (mntflags & MNT_FORCE)
 297                 flags |= FORCECLOSE;
 298
 299         if ((error = vflush(mp, 0, flags)) != 0)
 300                 return (error);
 301
 302         /* Restore where pty access was pointing */
 303         (void)pty_sethandler(ptyfs_save_ptm);
 304         ptyfs_save_ptm = NULL;
 305         ptm_ptyfspty.arg = NULL;
 306
 307         /*
 308          * Finally, throw away the ptyfsmount structure
 309          */
 310         free(mp->mnt_data, M_PTYFSMNT);
 311         mp->mnt_data = NULL;
 312         ptyfs_count--;
 313
 314         return 0;
 315 }
 316
 317 int
 318 ptyfs_root(struct mount *mp, struct vnode **vpp)
 319 {
 320         /* setup "." */
 321         return ptyfs_allocvp(mp, vpp, PTYFSroot, 0, NULL);
 322 }
 323
 324 /*ARGSUSED*/
 325 int
 326 ptyfs_sync(struct mount *mp, int waitfor,
 327     kauth_cred_t uc)
 328 {
 329         return 0;
 330 }
 331
 332 /*
 333  * Kernfs flat namespace lookup.
 334  * Currently unsupported.
 335  */
 336 /*ARGSUSED*/
 337 int
 338 ptyfs_vget(struct mount *mp, ino_t ino,
 339     struct vnode **vpp)
 340 {
 341         return EOPNOTSUPP;
 342 }
 343
 344 extern const struct vnodeopv_desc ptyfs_vnodeop_opv_desc;
 345
 346 const struct vnodeopv_desc * const ptyfs_vnodeopv_descs[] = {
 347         &ptyfs_vnodeop_opv_desc,
 348         NULL,
 349 };
 350
 351 struct vfsops ptyfs_vfsops = {
 352         MOUNT_PTYFS,
 353         sizeof (struct ptyfs_args),
 354         ptyfs_mount,
 355         ptyfs_start,
 356         ptyfs_unmount,
 357         ptyfs_root,
 358         (void *)eopnotsupp,             /* vfs_quotactl */
 359         genfs_statvfs,
 360         ptyfs_sync,
 361         ptyfs_vget,
 362         (void *)eopnotsupp,             /* vfs_fhtovp */
 363         (void *)eopnotsupp,             /* vfs_vptofp */
 364         ptyfs_init,
 365         ptyfs_reinit,
 366         ptyfs_done,
 367         NULL,                           /* vfs_mountroot */
 368         (void *)eopnotsupp,
 369         (void *)eopnotsupp,
 370         (void *)eopnotsupp,             /* vfs_suspendctl */
 371         genfs_renamelock_enter,
 372         genfs_renamelock_exit,
 373         (void *)eopnotsupp,
 374         ptyfs_vnodeopv_descs,
 375         0,
 376         { NULL, NULL },
 377 };
 378
 379 static int
 380 ptyfs_modcmd(modcmd_t cmd, void *arg)
 381 {
 382         int error;
 383
 384         switch (cmd) {
 385         case MODULE_CMD_INIT:
 386                 error = vfs_attach(&ptyfs_vfsops);
 387                 if (error != 0)
 388                         break;
 389                 sysctl_createv(&ptyfs_sysctl_log, 0, NULL, NULL,
 390                                CTLFLAG_PERMANENT,
 391                                CTLTYPE_NODE, "vfs", NULL,
 392                                NULL, 0, NULL, 0,
 393                                CTL_VFS, CTL_EOL);
 394                 sysctl_createv(&ptyfs_sysctl_log, 0, NULL, NULL,
 395                                CTLFLAG_PERMANENT,
 396                                CTLTYPE_NODE, "ptyfs",
 397                                SYSCTL_DESCR("Pty file system"),
 398                                NULL, 0, NULL, 0,
 399                                CTL_VFS, 23, CTL_EOL);
 400                 /*
 401                  * XXX the "23" above could be dynamic, thereby eliminating
 402                  * one more instance of the "number to vfs" mapping problem,
 403                  * but "23" is the order as taken from sys/mount.h
 404                  */
 405                 break;
 406         case MODULE_CMD_FINI:
 407                 error = vfs_detach(&ptyfs_vfsops);
 408                 if (error != 0)
 409                         break;
 410                 sysctl_teardown(&ptyfs_sysctl_log);
 411                 break;
 412         default:
 413                 error = ENOTTY;
 414                 break;
 415         }
 416
 417         return (error);
 418 }