src/afs/OBSD/osi_vfsops.c

   1 /*
   2  * OpenBSD specific assistance routines & VFS ops
   3  * Original NetBSD version for Transarc afs by John Kohl <jtk@MIT.EDU>
   4  * OpenBSD version by Jim Rees <rees@umich.edu>
   5  *
   6  * $Id$
   7  */
   8
   9 /*
  10 copyright 2002
  11 the regents of the university of michigan
  12 all rights reserved
  13
  14 permission is granted to use, copy, create derivative works
  15 and redistribute this software and such derivative works
  16 for any purpose, so long as the name of the university of
  17 michigan is not used in any advertising or publicity
  18 pertaining to the use or distribution of this software
  19 without specific, written prior authorization.  if the
  20 above copyright notice or any other identification of the
  21 university of michigan is included in any copy of any
  22 portion of this software, then the disclaimer below must
  23 also be included.
  24
  25 this software is provided as is, without representation
  26 from the university of michigan as to its fitness for any
  27 purpose, and without warranty by the university of
  28 michigan of any kind, either express or implied, including
  29 without limitation the implied warranties of
  30 merchantability and fitness for a particular purpose. the
  31 regents of the university of michigan shall not be liable
  32 for any damages, including special, indirect, incidental, or
  33 consequential damages, with respect to any claim arising
  34 out of or in connection with the use of the software, even
  35 if it has been or is hereafter advised of the possibility of
  36 such damages.
  37 */
  38
  39 /*
  40 Copyright 1995 Massachusetts Institute of Technology.  All Rights
  41 Reserved.
  42
  43 You are hereby granted a worldwide, irrevocable, paid-up, right and
  44 license to use, execute, display, modify, copy and distribute MIT's
  45 Modifications, provided that (i) you abide by the terms and conditions
  46 of the OpenAFS License Agreement, and (ii) you do not use the name
  47 of MIT in any advertising or publicity without the prior written consent
  48 of MIT.  MIT disclaims all liability for your use of MIT's
  49 Modifications.  MIT's Modifications are provided "AS IS" WITHOUT
  50 WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO,
  51 ANY WARRANTY OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR
  52 NONINFRINGEMENT.
  53 */
  54
  55 /*
  56  * Some code cribbed from ffs_vfsops and other NetBSD sources, which
  57  * are marked:
  58  */
  59 /*
  60  * Copyright (c) 1989, 1991, 1993, 1994
  61  *      The Regents of the University of California.  All rights reserved.
  62  *
  63  * Redistribution and use in source and binary forms, with or without
  64  * modification, are permitted provided that the following conditions
  65  * are met:
  66  * 1. Redistributions of source code must retain the above copyright
  67  *    notice, this list of conditions and the following disclaimer.
  68  * 2. Redistributions in binary form must reproduce the above copyright
  69  *    notice, this list of conditions and the following disclaimer in the
  70  *    documentation and/or other materials provided with the distribution.
  71  * 3. All advertising materials mentioning features or use of this software
  72  *    must display the following acknowledgement:
  73  *      This product includes software developed by the University of
  74  *      California, Berkeley and its contributors.
  75  * 4. Neither the name of the University nor the names of its contributors
  76  *    may be used to endorse or promote products derived from this software
  77  *    without specific prior written permission.
  78  *
  79  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  80  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  81  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  82  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  83  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  84  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  85  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  86  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  87  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  88  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  89  * SUCH DAMAGE.
  90  *
  91  */
  92
  93 #include <afsconfig.h>
  94 #include "afs/param.h"
  95
  96 RCSID
  97     ("$Header$");
  98
  99 #include "afs/sysincludes.h"    /* Standard vendor system headers */
 100 #include "afs/afsincludes.h"    /* Afs-based standard headers */
 101 #include "afs/afs_stats.h"      /* statistics */
 102
 103 #include <sys/conf.h>
 104 #include <sys/exec.h>
 105 #include <sys/lkm.h>
 106 #include <sys/namei.h>
 107 #include <sys/syscall.h>
 108 #include <sys/syscallargs.h>
 109
 110 /* from /usr/src/sys/kern/vfs_subr.c */
 111 extern void insmntque(struct vnode *, struct mount *);
 112
 113 extern int sys_lkmnosys(), afs3_syscall(), afs_xioctl(), Afs_xsetgroups();
 114
 115 static int lkmid = -1;
 116 static int afs_badcall(struct proc *p, void *xx, register_t * yy);
 117 static struct sysent old_sysent;
 118
 119 char afs_NetBSD_osname[] = "OpenBSD";
 120 struct osi_vfs *afs_globalVFS;
 121 struct vcache *afs_globalVp;
 122
 123 int afs_quotactl();
 124 int afs_fhtovp();
 125 int afs_vptofh();
 126 int afsinit();
 127 int afs_start();
 128 int afs_mount();
 129 int afs_unmount();
 130 int afs_root();
 131 int afs_statfs();
 132 int afs_sync();
 133 int afs_vget();
 134 int afs_sysctl();
 135 int afs_checkexp();
 136
 137 struct vfsops afs_vfsops = {
 138     afs_mount,
 139     afs_start,
 140     afs_unmount,
 141     afs_root,
 142     afs_quotactl,
 143     afs_statfs,
 144     afs_sync,
 145     afs_vget,
 146     afs_fhtovp,
 147     afs_vptofh,
 148     afsinit,
 149     afs_sysctl,
 150     afs_checkexp,
 151 };
 152
 153 int
 154 afs_nbsd_lookupname(char *fnamep, enum uio_seg segflg, int followlink,
 155                     struct vnode **dirvpp, struct vnode **compvpp)
 156 {
 157     struct nameidata nd;
 158     int niflag;
 159     int error;
 160
 161     /*
 162      * Lookup pathname "fnamep", returning parent directory in
 163      * *dirvpp (if non-null) and leaf in *compvpp.  segflg says whether the
 164      * pathname is user or system space.
 165      */
 166     /* XXX LOCKLEAF ? */
 167     niflag = followlink ? FOLLOW : NOFOLLOW;
 168     if (dirvpp)
 169         niflag |= WANTPARENT;   /* XXX LOCKPARENT? */
 170     NDINIT(&nd, LOOKUP, niflag, segflg, fnamep, osi_curproc());
 171     if ((error = namei(&nd)))
 172         return error;
 173     *compvpp = nd.ni_vp;
 174     if (dirvpp)
 175         *dirvpp = nd.ni_dvp;
 176     return error;
 177 }
 178
 179 int
 180 afs_quotactl()
 181 {
 182     return EOPNOTSUPP;
 183 }
 184
 185 int
 186 afs_sysctl()
 187 {
 188     return EOPNOTSUPP;
 189 }
 190
 191 int
 192 afs_checkexp()
 193 {
 194     return EOPNOTSUPP;
 195 }
 196
 197 int
 198 afs_fhtovp(mp, fhp, vpp)
 199      struct mount *mp;
 200      struct fid *fhp;
 201      struct vnode **vpp;
 202 {
 203
 204     return (EINVAL);
 205 }
 206
 207 int
 208 afs_vptofh(vp, fhp)
 209      struct vnode *vp;
 210      struct fid *fhp;
 211 {
 212
 213     return (EINVAL);
 214 }
 215
 216 int
 217 afs_start(mp, flags, p)
 218      struct mount *mp;
 219      int flags;
 220      struct proc *p;
 221 {
 222     return (0);                 /* nothing to do. ? */
 223 }
 224
 225 int
 226 afs_mount(mp, path, data, ndp, p)
 227      register struct mount *mp;
 228      char *path;
 229      caddr_t data;
 230      struct nameidata *ndp;
 231      struct proc *p;
 232 {
 233     /* ndp contains the mounted-from device.  Just ignore it.
 234      * we also don't care about our proc struct. */
 235     int size;
 236
 237     if (mp->mnt_flag & MNT_UPDATE)
 238         return EINVAL;
 239
 240     if (afs_globalVFS) {
 241         /* Don't allow remounts */
 242         return EBUSY;
 243     }
 244
 245     AFS_STATCNT(afs_mount);
 246     AFS_GLOCK();
 247
 248 #ifdef AFS_DISCON_ENV
 249     /* initialize the vcache entries before we start using them */
 250
 251     /* XXX find a better place for this if possible  */
 252     init_vcache_entries();
 253 #endif
 254     afs_globalVFS = mp;
 255     mp->osi_vfs_bsize = 8192;
 256     mp->osi_vfs_fsid.val[0] = AFS_VFSMAGIC;     /* magic */
 257     mp->osi_vfs_fsid.val[1] = (int)AFS_VFSFSID;
 258
 259     (void)copyinstr(path, mp->mnt_stat.f_mntonname, MNAMELEN - 1, &size);
 260     bzero(mp->mnt_stat.f_mntonname + size, MNAMELEN - size);
 261     bzero(mp->mnt_stat.f_mntfromname, MNAMELEN);
 262     strcpy(mp->mnt_stat.f_mntfromname, "AFS");
 263     /* null terminated string "AFS" will fit, just leave it be. */
 264     strcpy(mp->mnt_stat.f_fstypename, MOUNT_AFS);
 265     AFS_GUNLOCK();
 266     (void)afs_statfs(mp, &mp->mnt_stat);
 267
 268     return 0;
 269 }
 270
 271 int
 272 afs_unmount(afsp, flags, p)
 273      struct mount *afsp;
 274      int flags;
 275      struct proc *p;
 276 {
 277     extern int sys_ioctl(), sys_setgroups();
 278
 279     AFS_STATCNT(afs_unmount);
 280 #ifdef AFS_DISCON_ENV
 281     give_up_cbs();
 282 #endif
 283     if (afs_globalVFS == NULL) {
 284         printf("afs already unmounted\n");
 285         return 0;
 286     }
 287     if (afs_globalVp)
 288         vrele(AFSTOV(afs_globalVp));
 289     afs_globalVp = NULL;
 290
 291     vflush(afsp, NULLVP, 0);    /* don't support forced */
 292     afsp->mnt_data = NULL;
 293     AFS_GLOCK();
 294     afs_globalVFS = 0;
 295     afs_cold_shutdown = 1;
 296     afs_shutdown();             /* XXX */
 297     AFS_GUNLOCK();
 298
 299     /* give up syscall entries for ioctl & setgroups, which we've stolen */
 300     sysent[SYS_ioctl].sy_call = sys_ioctl;
 301     sysent[SYS_setgroups].sy_call = sys_setgroups;
 302
 303     /* give up the stolen syscall entry */
 304     sysent[AFS_SYSCALL].sy_narg = 0;
 305     sysent[AFS_SYSCALL].sy_argsize = 0;
 306     sysent[AFS_SYSCALL].sy_call = afs_badcall;
 307     printf
 308         ("AFS unmounted--use `/sbin/modunload -i %d' to unload before restarting AFS\n",
 309          lkmid);
 310     return 0;
 311 }
 312
 313 static int
 314 afs_badcall(struct proc *p, void *xx, register_t * yy)
 315 {
 316     return ENOSYS;
 317 }
 318
 319 void
 320 afs_nbsd_getnewvnode(struct vcache *tvc)
 321 {
 322     while (getnewvnode(VT_AFS, afs_globalVFS, afs_vnodeop_p, &tvc->v)) {
 323         /* no vnodes available, force an alloc (limits be damned)! */
 324         desiredvnodes++;
 325     }
 326     tvc->v->v_data = (void *)tvc;
 327 }
 328
 329 int
 330 afs_root(struct mount *mp, struct vnode **vpp)
 331 {
 332     struct vrequest treq;
 333     struct vcache *tvp;
 334     int code;
 335
 336     AFS_STATCNT(afs_root);
 337
 338     AFS_GLOCK();
 339     if (!(code = afs_InitReq(&treq, osi_curcred()))
 340         && !(code = afs_CheckInit())) {
 341         tvp = afs_GetVCache(&afs_rootFid, &treq, NULL, NULL);
 342         if (tvp) {
 343             /* There is really no reason to over-hold this bugger--it's held
 344              * by the root filesystem reference. */
 345             if (afs_globalVp != tvp) {
 346 #ifdef AFS_DONT_OVERHOLD_GLOBALVP
 347                 if (afs_globalVp)
 348                     AFS_RELE(AFSTOV(afs_globalVp));
 349 #endif
 350                 afs_globalVp = tvp;
 351                 VREF(AFSTOV(afs_globalVp));
 352             }
 353             AFSTOV(tvp)->v_flag |= VROOT;
 354             afs_globalVFS = mp;
 355             *vpp = AFSTOV(tvp);
 356         } else
 357             code = ENOENT;
 358     }
 359     AFS_GUNLOCK();
 360
 361     if (!code)
 362         vn_lock(*vpp, LK_EXCLUSIVE | LK_RETRY, curproc);        /* return it locked */
 363     return code;
 364 }
 365
 366 int
 367 afs_statfs(struct osi_vfs *afsp, struct statfs *abp)
 368 {
 369     AFS_STATCNT(afs_statfs);
 370     abp->f_bsize = afsp->osi_vfs_bsize;
 371
 372     /*
 373      * Fake a high number below to satisfy programs that use the ustat (for
 374      * * AIX), or statfs (for the rest) call to make sure that there's
 375      * enough * space in the device partition before storing something there
 376      * (like * ed(1))
 377      */
 378     abp->f_blocks = abp->f_bfree = abp->f_bavail = abp->f_files =
 379         abp->f_ffree = 9000000;
 380     abp->f_fsid.val[0] = AFS_VFSMAGIC;  /* magic */
 381     abp->f_fsid.val[1] = (int)AFS_VFSFSID;
 382     return 0;
 383 }
 384
 385 int
 386 afs_sync(struct osi_vfs *afsp)
 387 {
 388     AFS_STATCNT(afs_sync);
 389 #if defined(AFS_DISCON_ENV) && !defined(AFS_OBSD_ENV)
 390     /* Can't do this in OpenBSD 2.7, it faults when called from apm_suspend() */
 391     store_dirty_vcaches();
 392 #endif
 393     return 0;
 394 }
 395
 396 int
 397 afs_vget(vp, lfl)
 398      struct vnode *vp;
 399      int lfl;
 400 {
 401     int error;
 402
 403     if (vp->v_usecount < 0) {
 404         vprint("bad usecount", vp);
 405         panic("afs_vget");
 406     }
 407     error = vget(vp, lfl, curproc);
 408     if (!error)
 409         insmntque(vp, afs_globalVFS);   /* take off free list */
 410     return error;
 411 }
 412
 413 extern struct vfsops afs_vfsops;
 414 extern struct vnodeopv_desc afs_vnodeop_opv_desc;
 415
 416 static struct vfsconf afs_vfsconf = {
 417     &afs_vfsops,
 418     "afs",
 419     0,
 420     0,
 421     0,
 422     NULL,
 423     NULL,
 424 };
 425
 426 MOD_VFS("afs", 0, &afs_vfsconf);
 427
 428 static char afsgenmem[] = "afsgenmem";
 429 static char afsfidmem[] = "afsfidmem";
 430 static char afsbhdrmem[] = "afsbhdrmem";
 431 static char afsbfrmem[] = "afsbfrmem";
 432
 433 int
 434 afsinit()
 435 {
 436     old_sysent = sysent[AFS_SYSCALL];
 437
 438     sysent[AFS_SYSCALL].sy_call = afs3_syscall;
 439     sysent[AFS_SYSCALL].sy_narg = 6;
 440     sysent[AFS_SYSCALL].sy_argsize = 6 * sizeof(long);
 441     sysent[SYS_ioctl].sy_call = afs_xioctl;
 442     sysent[SYS_setgroups].sy_call = Afs_xsetgroups;
 443     osi_Init();
 444
 445     return 0;
 446 }
 447
 448 int
 449 afs_vfs_load(struct lkm_table *lkmtp, int cmd)
 450 {
 451     extern char *memname[];
 452
 453     vfs_opv_init_explicit(&afs_vnodeop_opv_desc);
 454     vfs_opv_init_default(&afs_vnodeop_opv_desc);
 455     if (memname[M_AFSGENERIC] == NULL)
 456         memname[M_AFSGENERIC] = afsgenmem;
 457     if (memname[M_AFSFID] == NULL)
 458         memname[M_AFSFID] = afsfidmem;
 459     if (memname[M_AFSBUFHDR] == NULL)
 460         memname[M_AFSBUFHDR] = afsbhdrmem;
 461     if (memname[M_AFSBUFFER] == NULL)
 462         memname[M_AFSBUFFER] = afsbfrmem;
 463     lkmid = lkmtp->id;
 464     printf("OpenAFS ($Revision$) lkm loaded\n");
 465     return 0;
 466 }
 467
 468 int
 469 afs_vfs_unload(struct lkm_table *lktmp, int cmd)
 470 {
 471     extern char *memname[];
 472
 473     if (afs_globalVp)
 474         return EBUSY;
 475     if (sysent[SYS_ioctl].sy_call != sys_ioctl)
 476         return EBUSY;
 477
 478     if (memname[M_AFSGENERIC] == afsgenmem)
 479         memname[M_AFSGENERIC] = NULL;
 480     if (memname[M_AFSFID] == afsfidmem)
 481         memname[M_AFSFID] = NULL;
 482     if (memname[M_AFSBUFHDR] == afsbhdrmem)
 483         memname[M_AFSBUFHDR] = NULL;
 484     if (memname[M_AFSBUFFER] == afsbfrmem)
 485         memname[M_AFSBUFFER] = NULL;
 486
 487     sysent[AFS_SYSCALL] = old_sysent;
 488     printf("OpenAFS unloaded\n");
 489     return 0;
 490 }
 491
 492 int
 493 libafs_lkmentry(struct lkm_table *lkmtp, int cmd, int ver)
 494 {
 495     if (cmd == LKM_E_LOAD) {
 496         if (strcmp(ostype, afs_NetBSD_osname)) {
 497             printf("This is %s version %s\n", ostype, osrelease);
 498             printf("This version of AFS is only for %s\n", afs_NetBSD_osname);
 499             return EPROGMISMATCH;
 500         }
 501         if (sysent[AFS_SYSCALL].sy_call == afs3_syscall
 502             || sysent[AFS_SYSCALL].sy_call == afs_badcall) {
 503             printf("AFS already loaded\n");
 504             return EINVAL;
 505         }
 506     }
 507     DISPATCH(lkmtp, cmd, ver, afs_vfs_load, afs_vfs_unload, lkm_nofunc);
 508 }