src/afs/HPUX/osi_vfsops.c

   1 /*
   2  * Copyright 2000, International Business Machines Corporation and others.
   3  * All Rights Reserved.
   4  *
   5  * This software has been released under the terms of the IBM Public
   6  * License.  For details, see the LICENSE file in the top-level source
   7  * directory or online at http://www.openafs.org/dl/license10.html
   8  */
   9
  10 /*
  11  * osi_vfsops.c for HPUX
  12  */
  13 #include <afsconfig.h>
  14 #include "../afs/param.h"
  15
  16 RCSID("$Header$");
  17
  18 #include "../afs/sysincludes.h" /* Standard vendor system headers */
  19 #include "../afs/afsincludes.h" /* Afs-based standard headers */
  20 #include "../afs/afs_stats.h"   /* statistics stuff */
  21 #include <sys/scall_kernprivate.h>
  22
  23
  24 static char afs_mountpath[512];
  25 struct vfs *afs_globalVFS = 0;
  26 struct vcache *afs_globalVp = 0;
  27
  28 int afs_mount(struct vfs *afsp, char *path, smountargs_t *data)
  29 {
  30     AFS_GLOCK();
  31     AFS_STATCNT(afs_mount);
  32
  33     if (afs_globalVFS) { /* Don't allow remounts. */
  34         AFS_GUNLOCK();
  35         return (setuerror(EBUSY));
  36     }
  37
  38     afs_globalVFS = afsp;
  39     afsp->vfs_bsize = 8192;
  40     afsp->vfs_fsid[0] = AFS_VFSMAGIC; /* magic */
  41     afsp->vfs_fsid[1] = AFS_VFSFSID;
  42     strcpy(afsp->vfs_name, "AFS");
  43     afsp->vfs_name[3] = '\0';
  44
  45     strncpy(afs_mountpath, path, sizeof(afs_mountpath));
  46     afs_mountpath[sizeof afs_mountpath - 1] = '\0';
  47
  48 #ifndef AFS_NONFSTRANS
  49     /* Set up the xlator in case it wasn't done elsewhere */
  50     afs_xlatorinit_v2();
  51 #endif
  52
  53     AFS_GUNLOCK();
  54     return 0;
  55 }
  56
  57
  58 int afs_unmount(struct vfs *afsp)
  59 {
  60     AFS_GLOCK();
  61     AFS_STATCNT(afs_unmount);
  62
  63     afs_globalVFS = 0;
  64     afs_shutdown();
  65
  66     AFS_GUNLOCK();
  67     return 0;
  68 }
  69
  70 int afs_root (struct vfs *afsp, struct vnode **avpp, char *unused1)
  71 {
  72     int code = 0;
  73     struct vrequest treq;
  74     register struct vcache *tvp=0;
  75     AFS_GLOCK();
  76     AFS_STATCNT(afs_root);
  77
  78     if (afs_globalVp && (afs_globalVp->states & CStatd)) {
  79         tvp = afs_globalVp;
  80     } else {
  81         if (afs_globalVp) {
  82             afs_PutVCache(afs_globalVp);
  83             afs_globalVp = NULL;
  84         }
  85
  86         if (!(code = afs_InitReq(&treq,  p_cred(u.u_procp))) &&
  87             !(code = afs_CheckInit())) {
  88             tvp = afs_GetVCache(&afs_rootFid, &treq, (afs_int32 *)0,
  89                                 (struct vcache*)0, WRITE_LOCK);
  90             /* we really want this to stay around */
  91             if (tvp) {
  92                 afs_globalVp = tvp;
  93             } else
  94                 code = ENOENT;
  95         }
  96     }
  97     if (tvp) {
  98         VN_HOLD(AFSTOV(tvp));
  99         SET_V_FLAG(AFSTOV(tvp), VROOT);
 100
 101         afs_globalVFS = afsp;
 102         *avpp = AFSTOV(tvp);
 103     }
 104
 105     afs_Trace2(afs_iclSetp, CM_TRACE_VFSROOT, ICL_TYPE_POINTER, *avpp,
 106                ICL_TYPE_INT32, code);
 107
 108     AFS_GUNLOCK();
 109     return code;
 110 }
 111
 112 int afs_statfs(register struct vfs *afsp, struct k_statvfs *abp)
 113 {
 114     AFS_GLOCK();
 115     AFS_STATCNT(afs_statfs);
 116
 117     abp->f_type = 0;
 118     abp->f_frsize = 1024;
 119     abp->f_bsize = afsp->vfs_bsize;
 120     /* Fake a high number below to satisfy programs that use the statfs
 121      * call to make sure that there's enough space in the device partition
 122      * before storing something there.
 123      */
 124     abp->f_blocks = abp->f_bfree = abp->f_bavail = abp->f_files =
 125         abp->f_ffree = abp->f_favail = 9000000;
 126     abp->f_fsid = (AFS_VFSMAGIC << 16) || AFS_VFSFSID;
 127
 128     AFS_GUNLOCK();
 129     return 0;
 130 }
 131
 132 int afs_sync(struct vfs *unused1, int unused2)
 133 {
 134     AFS_STATCNT(afs_sync);
 135     return 0;
 136 }
 137
 138 int afs_vget(struct vfs *afsp, struct vnode **avcp, struct fid *fidp)
 139 {
 140     int code;
 141     struct vrequest treq;
 142     AFS_GLOCK();
 143     AFS_STATCNT(afs_vget);
 144
 145     * avcp = NULL;
 146
 147     if ((code = afs_InitReq(&treq, p_cred(u.u_procp)))==0) {
 148         code = afs_osi_vget((struct vcache**)avcp, fidp, &treq);
 149     }
 150
 151     afs_Trace3(afs_iclSetp, CM_TRACE_VGET, ICL_TYPE_POINTER, *avcp,
 152                ICL_TYPE_INT32, treq.uid, ICL_TYPE_FID, fidp);
 153     code = afs_CheckCode(code, &treq, 42);
 154
 155     AFS_GUNLOCK();
 156     return code;
 157 }
 158
 159 int afs_getmount(struct vfs *vfsp, char *fsmntdir, struct mount_data *mdp, char *unused1)
 160 {
 161     int l;
 162
 163     mdp->md_msite = 0;
 164     mdp->md_dev = 0;
 165     mdp->md_rdev = 0;
 166     return(copyoutstr(afs_mountpath, fsmntdir, strlen(afs_mountpath)+1, &l));
 167 }
 168
 169
 170 struct vfsops Afs_vfsops = {
 171     afs_mount,
 172     afs_unmount,
 173     afs_root,
 174     afs_statfs,
 175     afs_sync,
 176     afs_vget,
 177     afs_getmount,
 178     (vfs_freeze_t *)0,  /* vfs_freeze */
 179     (vfs_thaw_t *)0,    /* vfs_thaw */
 180     (vfs_quota_t *)0,   /* vfs_quota */
 181     (vfs_mountroot_t *)0,               /* vfs_mountroot. Note: afs_mountroot_nullop in this
 182                          *                position panicked HP 11.00+
 183                          */
 184     (vfs_size_t *)0     /* vfs_size */
 185 };
 186
 187 static int afs_Starting = 0;
 188
 189 #pragma align 64
 190 sema_t afs_global_sema = {
 191    NULL, 0, NULL, NULL, NULL, NULL, 0, 0, 0, 0, 0, 0, 0, /* sa_type */
 192    0, 0, 0, 0, 0, 0, 0, NULL, /* sa_link */
 193    NULL, NULL
 194 #ifdef SEMA_COUNTING
 195    , 0, 0, 0, NULL
 196 #endif
 197   };
 198
 199 void
 200 osi_InitGlock()
 201 {
 202     register ulong_t context;
 203
 204     SPINLOCK_USAV(sched_lock, context);
 205     if ( !afs_Starting ) {
 206         afs_Starting = 1;
 207         SPINUNLOCK_USAV(sched_lock, context);
 208         initsema(&afs_global_sema, 1, FILESYS_SEMA_PRI, FILESYS_SEMA_ORDER);
 209         afsHash(64);    /* 64 buckets */
 210     } else {
 211         SPINUNLOCK_USAV(sched_lock, context);
 212     }
 213     if (!afs_Starting) {
 214         osi_Panic("osi_Init lost initialization race");
 215     }
 216 }
 217
 218 /*
 219  * afsc_link - Initialize VFS
 220  */
 221 int afs_vfs_slot=-1;
 222
 223
 224 afsc_link()
 225 {
 226     extern int Afs_syscall(), afs_xioctl(), Afs_xsetgroups();
 227
 228     /* For now nothing special is required during AFS initialization. */
 229     AFS_STATCNT(afsc_link);
 230     osi_Init();
 231     if ( (afs_vfs_slot=add_vfs_type("afs", &Afs_vfsops)) < 0 )
 232         return;
 233     sysent_assign_function(AFS_SYSCALL, 7, (void (*)())Afs_syscall, "Afs_syscall");
 234     sysent_define_arg(AFS_SYSCALL, 0, longArg);
 235     sysent_define_arg(AFS_SYSCALL, 1, longArg);
 236     sysent_define_arg(AFS_SYSCALL, 2, longArg);
 237     sysent_define_arg(AFS_SYSCALL, 3, longArg);
 238     sysent_define_arg(AFS_SYSCALL, 4, longArg);
 239     sysent_define_arg(AFS_SYSCALL, 5, longArg);
 240     sysent_define_arg(AFS_SYSCALL, 6, longArg);
 241     sysent_returns_long(AFS_SYSCALL);
 242
 243     sysent_delete(80);
 244     sysent_assign_function(80, 2, (void (*)())Afs_xsetgroups, "setgroups");
 245     sysent_define_arg(80, 0, longArg);
 246     sysent_define_arg(80, 1, longArg);
 247     sysent_returns_long(80);
 248     return 0;
 249 }
 250