src/afs/DARWIN/osi_vfsops.c

   1 #include <afsconfig.h>
   2 #include <afs/param.h>
   3
   4 RCSID("$Header$");
   5
   6 #include <afs/sysincludes.h>            /* Standard vendor system headers */
   7 #include <afs/afsincludes.h>            /* Afs-based standard headers */
   8 #include <afs/afs_stats.h>              /* statistics */
   9 #include <sys/malloc.h>
  10 #include <sys/namei.h>
  11 #include <sys/conf.h>
  12 #include <sys/syscall.h>
  13
  14 struct vcache *afs_globalVp = 0;
  15 struct mount *afs_globalVFS = 0;
  16
  17 int
  18 afs_quotactl()
  19 {
  20         return EOPNOTSUPP;
  21 }
  22
  23 int
  24 afs_fhtovp(mp, fhp, vpp)
  25 struct mount *mp;
  26 struct fid *fhp;
  27 struct vnode **vpp;
  28 {
  29
  30         return (EINVAL);
  31 }
  32
  33 int
  34 afs_vptofh(vp, fhp)
  35 struct vnode *vp;
  36 struct fid *fhp;
  37 {
  38
  39         return (EINVAL);
  40 }
  41
  42 int
  43 afs_start(mp, flags, p)
  44 struct mount *mp;
  45 int flags;
  46 struct proc *p;
  47 {
  48     return (0);                         /* nothing to do. ? */
  49 }
  50
  51 int
  52 afs_mount(mp, path, data, ndp, p)
  53 register struct mount *mp;
  54 char *path;
  55 caddr_t data;
  56 struct nameidata *ndp;
  57 struct proc *p;
  58 {
  59     /* ndp contains the mounted-from device.  Just ignore it.
  60        we also don't care about our proc struct. */
  61     size_t size;
  62     int error;
  63
  64     if (mp->mnt_flag & MNT_UPDATE)
  65         return EINVAL;
  66
  67     AFS_GLOCK();
  68     AFS_STATCNT(afs_mount);
  69
  70     if (afs_globalVFS) { /* Don't allow remounts. */
  71         AFS_GUNLOCK();
  72         return (EBUSY);
  73     }
  74
  75     afs_globalVFS = mp;
  76     mp->vfs_bsize = 8192;
  77     vfs_getnewfsid(mp);
  78     mp->mnt_stat.f_iosize=8192;
  79
  80     (void) copyinstr(path, mp->mnt_stat.f_mntonname, MNAMELEN-1, &size);
  81     memset(mp->mnt_stat.f_mntonname + size, 0, MNAMELEN - size);
  82     memset(mp->mnt_stat.f_mntfromname, 0, MNAMELEN);
  83     strcpy(mp->mnt_stat.f_mntfromname, "AFS");
  84     /* null terminated string "AFS" will fit, just leave it be. */
  85     strcpy(mp->mnt_stat.f_fstypename, "afs");
  86     AFS_GUNLOCK();
  87     (void) afs_statfs(mp, &mp->mnt_stat, p);
  88     return 0;
  89 }
  90
  91 int
  92 afs_unmount(mp, flags, p)
  93 struct mount *mp;
  94 int flags;
  95 struct proc *p;
  96 {
  97
  98     AFS_GLOCK();
  99     AFS_STATCNT(afs_unmount);
 100     afs_globalVFS = 0;
 101     afs_shutdown();
 102     AFS_GUNLOCK();
 103
 104     return 0;
 105 }
 106
 107 int
 108 afs_root(struct mount *mp,
 109               struct vnode **vpp)
 110 {
 111     int error;
 112     struct vrequest treq;
 113     register struct vcache *tvp=0;
 114     struct proc *p=current_proc();
 115     struct ucred cr;
 116
 117     pcred_readlock(p);
 118     cr=*p->p_cred->pc_ucred;
 119     pcred_unlock(p);
 120     AFS_GLOCK();
 121     AFS_STATCNT(afs_root);
 122     if (afs_globalVp && (afs_globalVp->states & CStatd)) {
 123         tvp = afs_globalVp;
 124         error=0;
 125     } else {
 126
 127         if (!(error = afs_InitReq(&treq, &cr)) &&
 128             !(error = afs_CheckInit())) {
 129             tvp = afs_GetVCache(&afs_rootFid, &treq, (afs_int32 *)0,
 130                                 (struct vcache*)0, WRITE_LOCK);
 131             /* we really want this to stay around */
 132             if (tvp) {
 133                 afs_globalVp = tvp;
 134             } else
 135                 error = ENOENT;
 136         }
 137     }
 138     if (tvp) {
 139         osi_vnhold(tvp,0);
 140     AFS_GUNLOCK();
 141         vn_lock(AFSTOV(tvp), LK_EXCLUSIVE | LK_RETRY, p);
 142     AFS_GLOCK();
 143         afs_globalVFS = mp;
 144         *vpp = AFSTOV(tvp);
 145         AFSTOV(tvp)->v_flag |= VROOT;
 146     }
 147
 148     afs_Trace2(afs_iclSetp, CM_TRACE_VFSROOT, ICL_TYPE_POINTER, *vpp,
 149                ICL_TYPE_INT32, error);
 150     AFS_GUNLOCK();
 151     return error;
 152 }
 153
 154 int
 155 afs_vget(mp, lfl, vp)
 156 struct mount *mp;
 157 struct vnode *vp;
 158 int lfl;
 159 {
 160     int error;
 161     printf("vget called. help!\n");
 162     if (vp->v_usecount < 0) {
 163         vprint("bad usecount", vp);
 164         panic("afs_vget");
 165     }
 166     error = vget(vp, lfl, current_proc());
 167     if (!error)
 168         insmntque(vp, afs_globalVFS);   /* take off free list */
 169     return error;
 170 }
 171
 172 int afs_statfs(struct mount *mp, struct statfs *abp, struct proc *p)
 173 {
 174     AFS_GLOCK();
 175     AFS_STATCNT(afs_statfs);
 176
 177 #if 0
 178     abp->f_type = MOUNT_AFS;
 179 #endif
 180     abp->f_bsize = mp->vfs_bsize;
 181     abp->f_iosize = mp->vfs_bsize;
 182
 183     /* Fake a high number below to satisfy programs that use the statfs call
 184      * to make sure that there's enough space in the device partition before
 185      * storing something there.
 186      */
 187     abp->f_blocks = abp->f_bfree = abp->f_bavail = abp->f_files =
 188         abp->f_ffree  = 2000000;
 189
 190     abp->f_fsid.val[0] = mp->mnt_stat.f_fsid.val[0];
 191     abp->f_fsid.val[1] = mp->mnt_stat.f_fsid.val[1];
 192     if (abp != &mp->mnt_stat) {
 193         abp->f_type = mp->mnt_vfc->vfc_typenum;
 194         memcpy((caddr_t)&abp->f_mntonname[0], (caddr_t)mp->mnt_stat.f_mntonname, MNAMELEN);
 195         memcpy((caddr_t)&abp->f_mntfromname[0], (caddr_t)mp->mnt_stat.f_mntfromname, MNAMELEN);
 196     }
 197
 198     AFS_GUNLOCK();
 199     return 0;
 200 }
 201
 202 int afs_sync(mp, waitfor, cred, p)
 203 struct mount *mp;
 204 int waitfor;
 205 struct ucred *cred;
 206 struct prioc *p;
 207 {
 208 return 0;
 209 }
 210
 211 int afs_sysctl() {
 212    return EOPNOTSUPP;
 213 }
 214
 215
 216 typedef (*PFI)();
 217 extern int vfs_opv_numops; /* The total number of defined vnode operations */
 218 extern struct vnodeopv_desc afs_vnodeop_opv_desc;
 219 int afs_init(struct vfsconf *vfc) {
 220         int j;
 221         int (**opv_desc_vector)();
 222         struct vnodeopv_entry_desc *opve_descp;
 223
 224
 225
 226         MALLOC(afs_vnodeop_p, PFI *, vfs_opv_numops*sizeof(PFI), M_TEMP, M_WAITOK);
 227
 228         memset(afs_vnodeop_p, 0, vfs_opv_numops*sizeof(PFI));
 229
 230         opv_desc_vector = afs_vnodeop_p;
 231         for (j=0; afs_vnodeop_opv_desc.opv_desc_ops[j].opve_op; j++) {
 232             opve_descp = &(afs_vnodeop_opv_desc.opv_desc_ops[j]);
 233
 234             /*
 235              * Sanity check:  is this operation listed
 236              * in the list of operations?  We check this
 237              * by seeing if its offest is zero.  Since
 238              * the default routine should always be listed
 239              * first, it should be the only one with a zero
 240              * offset.  Any other operation with a zero
 241              * offset is probably not listed in
 242              * vfs_op_descs, and so is probably an error.
 243              *
 244              * A panic here means the layer programmer
 245              * has committed the all-too common bug
 246              * of adding a new operation to the layer's
 247              * list of vnode operations but
 248              * not adding the operation to the system-wide
 249              * list of supported operations.
 250              */
 251             if (opve_descp->opve_op->vdesc_offset == 0 &&
 252                 opve_descp->opve_op->vdesc_offset != VOFFSET(vop_default)) {
 253                 printf("afs_init: operation %s not listed in %s.\n",
 254                        opve_descp->opve_op->vdesc_name,
 255                        "vfs_op_descs");
 256                panic ("load_afs: bad operation");
 257                 }
 258             /*
 259              * Fill in this entry.
 260              */
 261             opv_desc_vector[opve_descp->opve_op->vdesc_offset] =
 262                 opve_descp->opve_impl;
 263             }
 264
 265         /*
 266          * Finally, go back and replace unfilled routines
 267          * with their default.  (Sigh, an O(n^3) algorithm.  I
 268                                  * could make it better, but that'd be work, and n is small.)
 269          */
 270
 271         /*
 272          * Force every operations vector to have a default routine.
 273          */
 274         opv_desc_vector = afs_vnodeop_p;
 275         if (opv_desc_vector[VOFFSET(vop_default)]==NULL) {
 276             panic("afs_init: operation vector without default routine.");
 277             }
 278         for (j = 0;j<vfs_opv_numops; j++)
 279             if (opv_desc_vector[j] == NULL)
 280                 opv_desc_vector[j] =
 281                     opv_desc_vector[VOFFSET(vop_default)];
 282 }
 283
 284 struct vfsops afs_vfsops = {
 285   afs_mount,
 286   afs_start,
 287   afs_unmount,
 288   afs_root,
 289   afs_quotactl,
 290   afs_statfs,
 291   afs_sync,
 292   afs_vget,
 293   afs_fhtovp,
 294   afs_vptofh,
 295   afs_init,
 296   afs_sysctl
 297 };