src/afs/FBSD/osi_vfsops.c

   1 #include <afsconfig.h>
   2 #include <afs/param.h>
   3
   4
   5 #include <afs/sysincludes.h>    /* Standard vendor system headers */
   6 #include <afsincludes.h>        /* Afs-based standard headers */
   7 #include <afs/afs_stats.h>      /* statistics */
   8 #include <sys/malloc.h>
   9 #include <sys/namei.h>
  10 #include <sys/conf.h>
  11 #include <sys/module.h>
  12 #include <sys/sysproto.h>
  13 #include <sys/syscall.h>
  14 #include <sys/sysent.h>
  15
  16 struct vcache *afs_globalVp = NULL;
  17 struct mount *afs_globalVFS = NULL;
  18 int afs_pbuf_freecnt = -1;
  19
  20 extern int Afs_xsetgroups();
  21 extern int afs_xioctl();
  22
  23 #if !defined(AFS_FBSD90_ENV) && !defined(AFS_FBSD82_ENV)
  24 static sy_call_t *old_handler;
  25 #else
  26 static struct sysent old_sysent;
  27
  28 static struct sysent afs_sysent = {
  29     5,                  /* int sy_narg */
  30     (sy_call_t *) afs3_syscall, /* sy_call_t *sy_call */
  31 #ifdef AFS_FBSD60_ENV
  32     AUE_NULL,           /* au_event_t sy_auevent */
  33 #ifdef AFS_FBSD70_ENV
  34     NULL,               /* systrace_args_funt_t sy_systrace_args_func */
  35     0,                  /* u_int32_t sy_entry */
  36     0,                  /* u_int32_t sy_return */
  37 #ifdef AFS_FBSD90_ENV
  38     0,                  /* u_int32_t sy_flags */
  39     0                   /* u_int32_t sy_thrcnt */
  40 #endif
  41 #endif
  42 #endif /* FBSD60 */
  43 };
  44 #endif /* FBSD90 */
  45
  46 int
  47 afs_init(struct vfsconf *vfc)
  48 {
  49     int code;
  50     int offset = AFS_SYSCALL;
  51 #if defined(AFS_FBSD90_ENV) || defined(AFS_FBSD82_ENV)
  52 # if defined(FBSD_SYSCALL_REGISTER_FOUR_ARGS)
  53     code = syscall_register(&offset, &afs_sysent, &old_sysent, 0);
  54 # else
  55     code = syscall_register(&offset, &afs_sysent, &old_sysent);
  56 # endif
  57     if (code) {
  58         printf("AFS_SYSCALL in use, error %i. aborting\n", code);
  59         return code;
  60     }
  61 #else
  62     if (sysent[AFS_SYSCALL].sy_call != (sy_call_t *)nosys
  63         && sysent[AFS_SYSCALL].sy_call != (sy_call_t *)lkmnosys) {
  64         printf("AFS_SYSCALL in use. aborting\n");
  65         return EBUSY;
  66     }
  67 #endif
  68     osi_Init();
  69     afs_pbuf_freecnt = nswbuf / 2 + 1;
  70 #if !defined(AFS_FBSD90_ENV) && !defined(AFS_FBSD82_ENV)
  71     old_handler = sysent[AFS_SYSCALL].sy_call;
  72     sysent[AFS_SYSCALL].sy_call = afs3_syscall;
  73     sysent[AFS_SYSCALL].sy_narg = 5;
  74 #endif
  75     return 0;
  76 }
  77
  78 int
  79 afs_uninit(struct vfsconf *vfc)
  80 {
  81 #if defined(AFS_FBSD90_ENV) || defined(AFS_FBSD82_ENV)
  82     int offset = AFS_SYSCALL;
  83 #endif
  84
  85     if (afs_globalVFS)
  86         return EBUSY;
  87 #if defined(AFS_FBSD90_ENV) || defined(AFS_FBSD82_ENV)
  88     syscall_deregister(&offset, &old_sysent);
  89 #else
  90     sysent[AFS_SYSCALL].sy_narg = 0;
  91     sysent[AFS_SYSCALL].sy_call = old_handler;
  92 #endif
  93     return 0;
  94 }
  95
  96 int
  97 afs_start(struct mount *mp, int flags, struct thread *p)
  98 {
  99     return (0);                 /* nothing to do. ? */
 100 }
 101
 102 int
 103 #if defined(AFS_FBSD80_ENV)
 104 afs_omount(struct mount *mp, char *path, caddr_t data)
 105 #elif defined(AFS_FBSD53_ENV)
 106 afs_omount(struct mount *mp, char *path, caddr_t data, struct thread *p)
 107 #else
 108 afs_omount(struct mount *mp, char *path, caddr_t data, struct nameidata *ndp,
 109         struct thread *p)
 110 #endif
 111 {
 112     /* ndp contains the mounted-from device.  Just ignore it.
 113      * we also don't care about our thread struct. */
 114     size_t size;
 115
 116     if (mp->mnt_flag & MNT_UPDATE)
 117         return EINVAL;
 118
 119     AFS_GLOCK();
 120     AFS_STATCNT(afs_mount);
 121
 122     if (afs_globalVFS) {        /* Don't allow remounts. */
 123         AFS_GUNLOCK();
 124         return EBUSY;
 125     }
 126
 127     afs_globalVFS = mp;
 128     mp->vfs_bsize = 8192;
 129     vfs_getnewfsid(mp);
 130     /*
 131      * This is kind of ugly, as the interlock has grown to encompass
 132      * more fields over time and there's not a good way to group the
 133      * code without duplication.
 134      */
 135 #ifdef AFS_FBSD62_ENV
 136     MNT_ILOCK(mp);
 137 #endif
 138     mp->mnt_flag &= ~MNT_LOCAL;
 139 #if defined(AFS_FBSD61_ENV) && !defined(AFS_FBSD62_ENV)
 140     MNT_ILOCK(mp);
 141 #endif
 142 #if __FreeBSD_version < 1000021
 143     mp->mnt_kern_flag |= MNTK_MPSAFE; /* solid steel */
 144 #endif
 145 #ifndef AFS_FBSD61_ENV
 146     MNT_ILOCK(mp);
 147 #endif
 148     /*
 149      * XXX mnt_stat "is considered stable as long as a ref is held".
 150      * We should check that we hold the only ref.
 151      */
 152     mp->mnt_stat.f_iosize = 8192;
 153
 154     if (path != NULL)
 155         copyinstr(path, mp->mnt_stat.f_mntonname, MNAMELEN - 1, &size);
 156     else
 157         bcopy("/afs", mp->mnt_stat.f_mntonname, size = 4);
 158     memset(mp->mnt_stat.f_mntonname + size, 0, MNAMELEN - size);
 159     memset(mp->mnt_stat.f_mntfromname, 0, MNAMELEN);
 160     strcpy(mp->mnt_stat.f_mntfromname, "AFS");
 161     /* null terminated string "AFS" will fit, just leave it be. */
 162     strcpy(mp->mnt_stat.f_fstypename, "afs");
 163     MNT_IUNLOCK(mp);
 164     AFS_GUNLOCK();
 165 #ifdef AFS_FBSD80_ENV
 166     afs_statfs(mp, &mp->mnt_stat);
 167 #else
 168     afs_statfs(mp, &mp->mnt_stat, p);
 169 #endif
 170
 171     return 0;
 172 }
 173
 174 #ifdef AFS_FBSD53_ENV
 175 int
 176 #ifdef AFS_FBSD80_ENV
 177 afs_mount(struct mount *mp)
 178 #else
 179 afs_mount(struct mount *mp, struct thread *td)
 180 #endif
 181 {
 182 #ifdef AFS_FBSD80_ENV
 183     return afs_omount(mp, NULL, NULL);
 184 #else
 185     return afs_omount(mp, NULL, NULL, td);
 186 #endif
 187 }
 188 #endif
 189
 190 #ifdef AFS_FBSD60_ENV
 191 static int
 192 #if (__FreeBSD_version >= 900503 && __FreeBSD_version < 1000000) || __FreeBSD_version >= 1000004
 193 afs_cmount(struct mntarg *ma, void *data, uint64_t flags)
 194 #elif defined(AFS_FBSD80_ENV)
 195 afs_cmount(struct mntarg *ma, void *data, int flags)
 196 #else
 197 afs_cmount(struct mntarg *ma, void *data, int flags, struct thread *td)
 198 #endif
 199 {
 200     return kernel_mount(ma, flags);
 201 }
 202 #endif
 203
 204 int
 205 #ifdef AFS_FBSD80_ENV
 206 afs_unmount(struct mount *mp, int flags)
 207 #else
 208 afs_unmount(struct mount *mp, int flags, struct thread *p)
 209 #endif
 210 {
 211     int error = 0;
 212
 213     AFS_GLOCK();
 214     if (afs_globalVp &&
 215         ((flags & MNT_FORCE) || !VREFCOUNT_GT(afs_globalVp, 1))) {
 216         /* Put back afs_root's ref */
 217         struct vcache *gvp = afs_globalVp;
 218         afs_globalVp = NULL;
 219         afs_PutVCache(gvp);
 220     }
 221     if (afs_globalVp)
 222         error = EBUSY;
 223     AFS_GUNLOCK();
 224
 225     if (!error) {
 226         /*
 227          * Release any remaining vnodes on this mount point. The second
 228          * argument is how many refs we hold on the root vnode. Since we
 229          * released our reference to the root vnode up above, give 0.
 230          */
 231 #if defined(AFS_FBSD80_ENV)
 232         error = vflush(mp, 0, (flags & MNT_FORCE) ? FORCECLOSE : 0, curthread);
 233 #elif defined(AFS_FBSD53_ENV)
 234         error = vflush(mp, 0, (flags & MNT_FORCE) ? FORCECLOSE : 0, p);
 235 #else
 236         error = vflush(mp, 0, (flags & MNT_FORCE) ? FORCECLOSE : 0);
 237 #endif
 238     }
 239     if (error)
 240         goto out;
 241     AFS_GLOCK();
 242     AFS_STATCNT(afs_unmount);
 243     afs_globalVFS = 0;
 244     afs_shutdown();
 245     AFS_GUNLOCK();
 246
 247 out:
 248     return error;
 249 }
 250
 251 int
 252 #if defined(AFS_FBSD80_ENV)
 253 afs_root(struct mount *mp, int flags, struct vnode **vpp)
 254 #elif defined(AFS_FBSD60_ENV)
 255 afs_root(struct mount *mp, int flags, struct vnode **vpp, struct thread *td)
 256 #elif defined(AFS_FBSD53_ENV)
 257 afs_root(struct mount *mp, struct vnode **vpp, struct thread *td)
 258 #else
 259 afs_root(struct mount *mp, struct vnode **vpp)
 260 #endif
 261 {
 262     int error;
 263     struct vrequest treq;
 264     struct vcache *tvp = 0;
 265     struct vcache *gvp;
 266 #if !defined(AFS_FBSD53_ENV) || defined(AFS_FBSD80_ENV)
 267     struct thread *td = curthread;
 268 #endif
 269     struct ucred *cr = osi_curcred();
 270
 271     AFS_GLOCK();
 272     AFS_STATCNT(afs_root);
 273     crhold(cr);
 274 tryagain:
 275     if (afs_globalVp && (afs_globalVp->f.states & CStatd)) {
 276         tvp = afs_globalVp;
 277         error = 0;
 278     } else {
 279         if (!(error = afs_InitReq(&treq, cr)) && !(error = afs_CheckInit())) {
 280             tvp = afs_GetVCache(&afs_rootFid, &treq);
 281             /* we really want this to stay around */
 282             if (tvp) {
 283                 gvp = afs_globalVp;
 284                 afs_globalVp = tvp;
 285                 if (gvp) {
 286                     afs_PutVCache(gvp);
 287                     if (tvp != afs_globalVp) {
 288                         /* someone raced us and won */
 289                         afs_PutVCache(tvp);
 290                         goto tryagain;
 291                     }
 292                 }
 293             } else
 294                 error = EIO;
 295         }
 296     }
 297     if (tvp) {
 298         struct vnode *vp = AFSTOV(tvp);
 299
 300         ASSERT_VI_UNLOCKED(vp, "afs_root");
 301         AFS_GUNLOCK();
 302         error = vget(vp, LK_EXCLUSIVE | LK_RETRY, td);
 303         AFS_GLOCK();
 304         /* we dropped the glock, so re-check everything it had serialized */
 305         if (!afs_globalVp || !(afs_globalVp->f.states & CStatd) ||
 306                 tvp != afs_globalVp) {
 307             vput(vp);
 308             afs_PutVCache(tvp);
 309             goto tryagain;
 310         }
 311         if (error != 0)
 312             goto tryagain;
 313         /*
 314          * I'm uncomfortable about this.  Shouldn't this happen at a
 315          * higher level, and shouldn't we busy the top-level directory
 316          * to prevent recycling?
 317          */
 318         vp->v_vflag |= VV_ROOT;
 319
 320         afs_globalVFS = mp;
 321         *vpp = vp;
 322     }
 323
 324     afs_Trace2(afs_iclSetp, CM_TRACE_VFSROOT, ICL_TYPE_POINTER, tvp ? AFSTOV(tvp) : NULL,
 325                ICL_TYPE_INT32, error);
 326     AFS_GUNLOCK();
 327     crfree(cr);
 328     return error;
 329 }
 330
 331 int
 332 #ifdef AFS_FBSD80_ENV
 333 afs_statfs(struct mount *mp, struct statfs *abp)
 334 #else
 335 afs_statfs(struct mount *mp, struct statfs *abp, struct thread *p)
 336 #endif
 337 {
 338     AFS_GLOCK();
 339     AFS_STATCNT(afs_statfs);
 340
 341     abp->f_bsize = mp->vfs_bsize;
 342     abp->f_iosize = mp->vfs_bsize;
 343
 344     abp->f_blocks = abp->f_bfree = abp->f_bavail = abp->f_files =
 345         abp->f_ffree = AFS_VFS_FAKEFREE;
 346
 347     abp->f_fsid.val[0] = mp->mnt_stat.f_fsid.val[0];
 348     abp->f_fsid.val[1] = mp->mnt_stat.f_fsid.val[1];
 349     if (abp != &mp->mnt_stat) {
 350         abp->f_type = mp->mnt_vfc->vfc_typenum;
 351         memcpy((caddr_t) & abp->f_mntonname[0],
 352                (caddr_t) mp->mnt_stat.f_mntonname, MNAMELEN);
 353         memcpy((caddr_t) & abp->f_mntfromname[0],
 354                (caddr_t) mp->mnt_stat.f_mntfromname, MNAMELEN);
 355     }
 356
 357     AFS_GUNLOCK();
 358     return 0;
 359 }
 360
 361 int
 362 #if defined(AFS_FBSD80_ENV)
 363 afs_sync(struct mount *mp, int waitfor)
 364 #elif defined(AFS_FBSD60_ENV)
 365 afs_sync(struct mount *mp, int waitfor, struct thread *td)
 366 #else
 367 afs_sync(struct mount *mp, int waitfor, struct ucred *cred, struct thread *p)
 368 #endif
 369 {
 370     return 0;
 371 }
 372
 373 #ifdef AFS_FBSD60_ENV
 374 struct vfsops afs_vfsops = {
 375         .vfs_init =             afs_init,
 376         .vfs_mount =            afs_mount,
 377         .vfs_cmount =           afs_cmount,
 378         .vfs_root =             afs_root,
 379         .vfs_statfs =           afs_statfs,
 380         .vfs_sync =             afs_sync,
 381         .vfs_uninit =           afs_uninit,
 382         .vfs_unmount =          afs_unmount,
 383         .vfs_sysctl =           vfs_stdsysctl,
 384 };
 385 #else
 386 struct vfsops afs_vfsops = {
 387 #ifdef AFS_FBSD53_ENV
 388     afs_mount,
 389 #endif
 390     afs_omount,
 391     afs_start,
 392     afs_unmount,
 393     afs_root,
 394     vfs_stdquotactl,
 395     afs_statfs,
 396     afs_sync,
 397     vfs_stdvget,
 398     vfs_stdfhtovp,
 399     vfs_stdcheckexp,
 400     vfs_stdvptofh,
 401     afs_init,
 402     afs_uninit,
 403     vfs_stdextattrctl,
 404     vfs_stdsysctl,
 405 };
 406 #endif