IRIX: Remove pre-65 code 30/14230/4
authorAndrew Deason <adeason@dson.org>
Mon, 25 May 2020 21:48:34 +0000 (16:48 -0500)
committerBenjamin Kaduk <kaduk@mit.edu>
Sun, 3 Oct 2021 05:25:21 +0000 (01:25 -0400)
Commit d1923139 (irix kill efs and start pruning pre-65) removed all
files that defined AFS_SGI64_ENV and earlier, but didn't remove that
code that depended on those defines. In addition, there has been code
in the tree that checks for AFS_SGI53_ENV since OpenAFS 1.0, but
nothing has ever defined Irix 5.3 support in OpenAFS.

Remove all of this obsolete code. Change all references to
AFS_SGIXX_ENV to AFS_SGI_ENV, and assume AFS_SGI_ENV is defined in all
IRIX dirs. Consolidate some of the resulting ifdef logic
appropriately.

Change-Id: I9dd426296e04801980b805a5e195063762b23189
Reviewed-on: https://gerrit.openafs.org/14230
Reviewed-by: Benjamin Kaduk <kaduk@mit.edu>
Tested-by: Benjamin Kaduk <kaduk@mit.edu>

60 files changed:
src/afs/IRIX/osi_gcpags.c
src/afs/IRIX/osi_groups.c
src/afs/IRIX/osi_idbg.c
src/afs/IRIX/osi_machdep.h
src/afs/IRIX/osi_misc.c
src/afs/IRIX/osi_vcache.c
src/afs/IRIX/osi_vfs.h
src/afs/IRIX/osi_vfsops.c
src/afs/IRIX/osi_vm.c
src/afs/IRIX/osi_vnodeops.c
src/afs/VNOPS/afs_vnop_access.c
src/afs/VNOPS/afs_vnop_attrs.c
src/afs/VNOPS/afs_vnop_create.c
src/afs/VNOPS/afs_vnop_fid.c
src/afs/VNOPS/afs_vnop_flock.c
src/afs/VNOPS/afs_vnop_open.c
src/afs/VNOPS/afs_vnop_readdir.c
src/afs/VNOPS/afs_vnop_write.c
src/afs/afs.h
src/afs/afs_analyze.c
src/afs/afs_call.c
src/afs/afs_conn.c
src/afs/afs_dcache.c
src/afs/afs_error.c
src/afs/afs_icl.c
src/afs/afs_init.c
src/afs/afs_osi.c
src/afs/afs_osi.h
src/afs/afs_osi_pag.c
src/afs/afs_pioctl.c
src/afs/afs_prototypes.h
src/afs/afs_segments.c
src/afs/afs_server.c
src/afs/afs_syscall.c
src/afs/afs_user.c
src/afs/afs_util.c
src/afs/afs_vcache.c
src/afs/afs_volume.c
src/afs/afs_warn.c
src/afs/exporter.h
src/afs/lock.h
src/afs/sysincludes.h
src/afsd/afsd.c
src/afsd/afsd_kernel.c
src/bozo/bnode.c
src/config/icl.h
src/config/param.sgi_65.h
src/dir/dir.c
src/lwp/lwp.c
src/lwp/process.c
src/rx/IRIX/rx_kmutex.h
src/rx/IRIX/rx_knet.c
src/rx/rx_kcommon.c
src/rx/rx_kcommon.h
src/rx/rx_misc.c
src/sys/afssyscalls.h
src/sys/icreate.c
src/venus/fstrace.c
src/venus/kdump.c
src/viced/viced.c

index 6b456d7..0c3616f 100644 (file)
  */
 
 
-#ifdef AFS_SGI65_ENV
 /* TODO: Fix this later. */
 static int
 SGI_ProcScanFunc(void *p, void *arg, int mode)
 {
     return 0;
 }
-#else /* AFS_SGI65_ENV */
-static int
-SGI_ProcScanFunc(proc_t * p, void *arg, int mode)
-{
-    afs_int32(*perproc_func) (afs_proc_t *) = arg;
-    int code = 0;
-    /* we pass in the function pointer for arg,
-     * mode ==0 for startup call, ==1 for each valid proc,
-     * and ==2 for terminate call.
-     */
-    if (mode == 1) {
-       code = perproc_func(p);
-    }
-    return code;
-}
-#endif /* AFS_SGI65_ENV */
 
 void
 afs_osi_TraverseProcTable(void)
@@ -57,26 +40,10 @@ afs_osi_TraverseProcTable(void)
  * subsequent calls may overwrite the previously returned value.
  */
 
-#if defined(AFS_SGI65_ENV)
 const afs_ucred_t *
 afs_osi_proc2cred(afs_proc_t * p)
 {
     return NULL;
 }
 
-#else
-const afs_ucred_t *
-afs_osi_proc2cred(afs_proc_t * pr)
-{
-    afs_ucred_t *rv = NULL;
-
-    if (pr == NULL) {
-       return NULL;
-    }
-    rv = pr->p_cred;
-
-    return rv;
-}
-#endif
-
 #endif /* AFS_GCPAGS */
index d028c20..208ddcd 100644 (file)
@@ -35,7 +35,6 @@ static int
 /* This is common code between SGI's DFS and our AFS. Do *not* alter it's
  * interface or semantics without notifying SGI.
  */
-#ifdef AFS_SGI65_ENV
 /* fixup_pags returns error code if relevant or 0 on no error.
  * Sets up the cred for the call to estgroups. This is pretty convoluted
  * in order to avoid including the private proc.h header file.
@@ -115,56 +114,6 @@ fixup_pags(int **credpp, int ngroups, gid_t * gidset, int old_afs_pag,
     }
     return 0;
 }
-#else
-/*
- * Generic routine to set the PAG in the cred for AFS and DFS.
- * If flag = 0 this is a DFS pag held in one group.
- * If flag = 1 this is a AFS pag held in two group entries
- */
-static int
-afsDFS_SetPagInCred(struct ucred *credp, int pag, int flag)
-{
-    int *gidset;
-    int i, ngrps;
-    gid_t g0, g1;
-    int n = 0;
-    struct ucred *newcredp;
-    int groups_taken = (flag ? 2 : 1);
-
-    ngrps = credp->cr_ngroups + groups_taken;
-    if (ngrps >= ngroups_max)
-       return E2BIG;
-
-
-    if (flag) {
-       /* Break out the AFS pag into two groups */
-       afs_get_groups_from_pag(pag, &g0, &g1);
-    }
-
-    newcredp = crdup(credp);
-    newcredp->cr_ngroups = ngrps;
-
-    if (flag) {
-       /* AFS case */
-       newcredp->cr_groups[0] = g0;
-       newcredp->cr_groups[1] = g1;
-    } else {
-       /* DFS case */
-       if (PagInCred(newcredp) != NOPAG) {
-           /* found an AFS PAG is set in this cred */
-           n = 2;
-       }
-       newcredp->cr_groups[n] = pag;
-    }
-    for (i = n; i < credp->cr_ngroups; i++)
-       newcredp->cr_groups[i + groups_taken] = credp->cr_groups[i];
-
-    /* estgroups sets current threads cred from newcredp and crfree's credp */
-    estgroups(credp, newcredp);
-
-    return 0;
-}
-#endif /* AFS_SGI65_ENV */
 
 /* SGI's osi_GetPagFromCred - They return a long. */
 int
@@ -187,17 +136,7 @@ osi_DFSGetPagFromCred(struct ucred *credp)
      *  This means we don't really know if our DFS PAG is in
      *  the first or third group entry.
      */
-#ifdef AFS_SGI65_ENV
     pag = credp->cr_groups[ngroups - 1];
-#else
-    pag = credp->cr_groups[0];
-    if (PagInCred(credp) != NOPAG) {
-       /* AFS has a PAG value in the first two group entries */
-       if (ngroups < 3)
-           return NOPAG;
-       pag = credp->cr_groups[2];
-    }
-#endif
     if (((pag >> 24) & 0xff) == 'A')
        return pag;
     else
@@ -223,7 +162,6 @@ Afs_xsetgroups(int ngroups, gid_t * gidset)
     if (code = setgroups(ngroups, gidset))
        return code;
 
-#ifdef AFS_SGI65_ENV
     if (old_afs_pag == NOPAG && old_dfs_pag == NOPAG)
        return 0;
 
@@ -238,27 +176,6 @@ Afs_xsetgroups(int ngroups, gid_t * gidset)
                   (old_dfs_pag == NOPAG) ? 0 : old_dfs_pag);
     if (!code && modcredp)
        estgroups(OSI_GET_CURRENT_PROCP(), modcredp);
-#else
-
-    /*
-     * The setgroups gave our curent thread a new cred pointer
-     * Get the value again
-     */
-    credp = OSI_GET_CURRENT_CRED();
-    if ((PagInCred(credp) == NOPAG) && (old_afs_pag != NOPAG)) {
-       /* reset the AFS PAG */
-       code = afsDFS_SetPagInCred(credp, old_afs_pag, 1);
-    }
-    /*
-     * Once again get the credp because the afsDFS_SetPagInCred might have
-     * assigned a new one.
-     */
-    credp = OSI_GET_CURRENT_CRED();
-    if ((osi_DFSGetPagFromCred(credp) == NOPAG)
-       && (old_dfs_pag != NOPAG)) {
-       code = afsDFS_SetPagInCred(credp, old_dfs_pag, 0);
-    }
-#endif /* AFS_SGI65_ENV */
     return code;
 }
 
@@ -342,11 +259,7 @@ afs_setgroups(struct ucred **cred, int ngroups, gid_t * gidset,
     while (ngroups--)
        *gp++ = *gidset++;
     if (!change_parent) {
-#ifdef AFS_SGI65_ENV
        estgroups(OSI_GET_CURRENT_PROCP(), newcr);
-#else
-       estgroups(cr, newcr);
-#endif
     }
     *cred = newcr;
     return (0);
index db7f64c..760c6ca 100644 (file)
@@ -14,7 +14,6 @@
 #include "afs/param.h"
 
 
-#ifdef AFS_SGI62_ENV
 #include "afs/sysincludes.h"   /* Standard vendor system headers */
 #include "afsincludes.h"       /* Afs-based standard headers */
 #include "afs/afs_stats.h"     /* statistics */
@@ -66,21 +65,12 @@ idbg_prafsnode(OSI_VC_DECL(avc))
            avc->execsOrWriters, avc->flockCount, avc->f.states);
     printflags(avc->f.states, tab_vcache);
     qprintf("\n");
-#ifdef AFS_SGI64_ENV
     qprintf("   mapcnt %llu, mvstat %d anyAcc 0x%x Access 0x%x\n",
            avc->mapcnt, avc->mvstat, avc->f.anyAccess, avc->Access);
     qprintf("   mvid 0x%x &lock 0x%x cred 0x%x\n", avc->mvid.target_root, &avc->lock,
            avc->cred);
     qprintf("   rwlock 0x%x (%d) id %llu trips %d\n", &avc->vc_rwlock,
            valusema(&avc->vc_rwlock), avc->vc_rwlockid, avc->vc_locktrips);
-#else
-    qprintf("   mapcnt %d mvstat %d anyAcc 0x%x Access 0x%x\n", avc->mapcnt,
-           avc->mvstat, avc->f.anyAccess, avc->Access);
-    qprintf("   mvid 0x%x &lock 0x%x cred 0x%x\n", avc->mvid.target_root, &avc->lock,
-           avc->cred);
-    qprintf("   rwlock 0x%x (%d) id %d trips %d\n", &avc->vc_rwlock,
-           valusema(&avc->vc_rwlock), avc->vc_rwlockid, avc->vc_locktrips);
-#endif
     AFS_GUNLOCK();
     return 0;
 }
@@ -173,5 +163,3 @@ idbg_afsuser(void *x)
     AFS_GUNLOCK();
     return 0;
 }
-
-#endif /* AFS_SGI62_ENV */
index 56defec..25e1828 100644 (file)
@@ -36,13 +36,11 @@ typedef struct proc afs_proc_t;
 #undef gop_lookupname_user
 #define gop_lookupname_user(fnamep,segflg,followlink,compvpp) lookupname((fnamep),(segflg),(followlink),NULL,(compvpp), NULL)
 
-#ifdef AFS_SGI64_ENV
 #include <sys/flock.h>
 extern flid_t osi_flid;
 #define v_op v_bh.bh_first->bd_ops
 #define v_data v_bh.bh_first->bd_pdata
 #define vfs_data vfs_bh.bh_first->bd_pdata
-#endif /* AFS_SGI64_ENV */
 
 /*
  * Global lock, semaphore, mutex and state vector support.
@@ -55,8 +53,6 @@ extern flid_t osi_flid;
 #define SPLOCK(l)              mp_mutex_spinlock(&(l))
 #define SPUNLOCK(l,s)           mp_mutex_spinunlock(&(l),s)
 #define SP_WAIT(l, s, cv, p)    mp_sv_wait_sig(cv, p, (void*)(&(l)), s)
-#ifdef AFS_SGI64_ENV
-#ifdef AFS_SGI65_ENV
 /* Add PLTWAIT for afsd's to wait so we don't rack up the load average. */
 #define AFSD_PRI() ((kt_basepri(curthreadp) == PTIME_SHARE) ? PZERO : (PZERO|PLTWAIT))
 #undef AFS_MUTEX_ENTER
@@ -72,22 +68,6 @@ extern flid_t osi_flid;
     } \
   MACRO_END
 
-#else /* AFS_SGI65_ENV */
-/* Add PLTWAIT for afsd's to wait so we don't rack up the load average. */
-#define AFSD_PRI() ((curprocp && curprocp->p_rss==0) ? (PZERO|PLTWAIT) : PZERO)
-
-#define AFS_MUTEX_ENTER(mp) \
-  MACRO_BEGIN \
-    kthread_t *kt; \
-    while(mutex_tryenter(mp) == 0) { \
-       kt = mutex_owner(mp); \
-       if (kt != NULL && kt->k_sonproc == CPU_NONE) { \
-           mutex_lock(mp, AFSD_PRI()); \
-           break; \
-       } \
-    } \
-  MACRO_END
-#endif /* AFS_SGI65_ENV */
 
 #define cv_timedwait(cv, l, t)  {                              \
                                sv_timedwait(cv, AFSD_PRI(), l, 0, 0, &(t), \
@@ -101,32 +81,6 @@ extern flid_t osi_flid;
                        sv_wait(cv, AFSD_PRI(),  l, 0); \
                        AFS_MUTEX_ENTER(l); \
                       }
-#else /* AFS_SGI64_ENV */
-#ifdef AFS_SGI62_ENV
-
-#define AFS_MUTEX_ENTER(mp) \
-  MACRO_BEGIN \
-    struct proc *_procP; \
-    while(mutex_tryenter(mp) == 0) { \
-       _procP = mutex_owner(mp); \
-       if (_procP != NULL && _procP->p_sonproc == CPU_NONE) { \
-           mutex_enter(mp); \
-           break; \
-       } \
-    } \
-  MACRO_END
-
-#else /* AFS_SGI62_ENV */
-
-#define AFS_MUTEX_ENTER(mp)    mutex_enter(mp)
-
-#endif /* AFS_SGI62_ENV */
-
-#define cv_timedwait(cv, l, t)  {                              \
-                                 sv_timedwait(cv, l, t);       \
-                                 AFS_GLOCK();                  \
-                               }
-#endif /* AFS_SGI64_ENV */
 
 #if defined(KERNEL)
 #if defined(MP)
@@ -149,29 +103,13 @@ extern flid_t osi_flid;
  *     concern no longer exists.
  */
 
-#ifdef AFS_SGI64_ENV
-#ifdef AFS_SGI65_ENV
 /* Irix does not check for deadlocks unless it's a debug kernel. */
 #define AFS_ASSERT_GNOTME() \
     (!ISAFS_GLOCK() || (panic("afs global lock held be me"), 0))
 #define AFS_GLOCK() \
        { AFS_ASSERT_GNOTME(); AFS_MUTEX_ENTER(&afs_global_lock); }
-#else
-#define AFS_GLOCK() AFS_MUTEX_ENTER(&afs_global_lock)
-#endif
 #define AFS_GUNLOCK()  { AFS_ASSERT_GLOCK(); mutex_exit(&afs_global_lock); }
 #define ISAFS_GLOCK() mutex_mine(&afs_global_lock)
-#else
-extern long afs_global_owner;
-#define AFS_GLOCK() \
-  MACRO_BEGIN \
-    AFS_MUTEX_ENTER(&afs_global_lock) ; \
-    afs_global_owner = osi_ThreadUnique(); \
-  MACRO_END
-#define AFS_GUNLOCK() \
-    { AFS_ASSERT_GLOCK(); afs_global_owner = 0; mutex_exit(&afs_global_lock); }
-#define ISAFS_GLOCK() (osi_ThreadUnique() == afs_global_owner)
-#endif /* AFS_SGI64_ENV */
 #else /* MP */
 #define AFS_GLOCK()
 #define AFS_GUNLOCK()
@@ -186,70 +124,35 @@ extern long afs_global_owner;
 
 #endif /* KERNEL  */
 
-#if defined(AFS_SGI62_ENV)
-# define osi_InitGlock() \
+#define osi_InitGlock() \
        mutex_init(&afs_global_lock, MUTEX_DEFAULT, "afs_global_lock");
-#else
-# define osi_InitGlock() \
-        mutex_init(&afs_global_lock, "afs_global_lock", MUTEX_DEFAULT, NULL);
-#endif
 
-#ifdef AFS_SGI64_ENV
 #define gop_rdwr(rw,gp,base,len,offset,segflg,ioflag,ulimit,cr,aresid) \
    vn_rdwr((rw),(gp),(base),(len),(offset),(segflg),(ioflag),(ulimit),(cr),\
           (int *)(aresid), &osi_flid)
-#else
-#define gop_rdwr(rw,gp,base,len,offset,segflg,ioflag,ulimit,cr,aresid) \
-   vn_rdwr((rw),(gp),(base),(len),(offset),(segflg),(ioflag),(ulimit),(cr), \
-          (int *)(aresid))
-#endif
 
-#ifdef AFS_SGI64_ENV
 #undef suser
 #define suser()                cap_able(CAP_DEVICE_MGT)
-#endif
 #define afs_suser(x)   suser()
 
 #define afs_hz HZ
 
-#ifdef AFS_SGI64_ENV
 #undef setuerror
 #undef getuerror
-#endif
 
 
 /* OS independent user structure stuff */
 /*
  * OSI_GET_CURRENT_PID
  */
-#if defined(AFS_SGI_ENV) && !defined(AFS_SGI64_ENV)
-#define OSI_GET_CURRENT_PID() (u.u_procp->p_pid)
-#endif /* AFS_SGI_ENV but not AFS_SGI64_ENV */
-
-#if defined(AFS_SGI64_ENV) && !defined(AFS_SGI65_ENV)
-#define OSI_GET_CURRENT_PID() current_pid()
-#endif /* AFS_SGI64_ENV */
-
-#if defined(AFS_SGI65_ENV)
 #define OSI_GET_CURRENT_PID() proc_pid(curproc())
-#endif
 
 #define getpid()  OSI_GET_CURRENT_PID()
 
 /*
  * OSI_GET_CURRENT_PROCP
  */
-#if defined(AFS_SGI_ENV) && !defined(AFS_SGI64_ENV)
-#define OSI_GET_CURRENT_PROCP() (u.u_procp)
-#endif /* AFS_SGI_ENV but not AFS_SGI64_ENV */
-
-#if defined(AFS_SGI64_ENV) && !defined(AFS_SGI65_ENV)
-#define OSI_GET_CURRENT_PROCP() curprocp
-#endif /* AFS_SGI64_ENV */
-
-#if defined(AFS_SGI65_ENV)
 #define OSI_GET_CURRENT_PROCP() UT_TO_PROC(curuthread)
-#endif
 
 
 /*
@@ -257,105 +160,48 @@ extern long afs_global_owner;
  *
  * Prior to IRIX 6.4, pid sufficed, now we need kthread.
  */
-#if defined(AFS_SGI_ENV) && !defined(AFS_SGI64_ENV)
-#define OSI_GET_LOCKID() (u.u_procp->p_pid)
-#define OSI_NO_LOCKID (-1)
-#endif /* AFS_SGI_ENV but not AFS_SGI64_ENV */
-
-#if defined(AFS_SGI64_ENV)
 /* IRIX returns k_id, but this way, we've got the thread address for debugging. */
 #define OSI_GET_LOCKID() \
        (private.p_curkthread ? (uint64_t)private.p_curkthread : (uint64_t)0)
 #define OSI_NO_LOCKID ((uint64_t)-1)
-#endif /* AFS_SGI64_ENV */
 
 /*
  * OSI_GET_CURRENT_CRED
  */
-#if defined(AFS_SGI_ENV) && !defined(AFS_SGI64_ENV)
-#define OSI_GET_CURRENT_CRED() (u.u_cred)
-#endif /* AFS_SGI_ENV but not AFS_SGI64_ENV */
-
-#if defined(AFS_SGI64_ENV)
 #define OSI_GET_CURRENT_CRED() get_current_cred()
-#endif /* AFS_SGI64_ENV */
 
 #define osi_curcred()          OSI_GET_CURRENT_CRED()
 
 /*
  * OSI_SET_CURRENT_CRED
  */
-#if defined(AFS_SGI_ENV) && !defined(AFS_SGI64_ENV)
-#define OSI_SET_CURRENT_CRED(x) u.u_cred=x
-#endif /* AFS_SGI_ENV but not AFS_SGI64_ENV */
-
-#if defined(AFS_SGI64_ENV)
 #define OSI_SET_CURRENT_CRED(C) set_current_cred((C))
-#endif /* AFS_SGI64_ENV */
 
 /*
  * OSI_GET_CURRENT_ABI
  */
-#if defined(AFS_SGI_ENV) && !defined(AFS_SGI64_ENV)
-#define OSI_GET_CURRENT_ABI() (u.u_procp->p_abi)
-#endif /* AFS_SGI_ENV but not AFS_SGI64_ENV */
-
-#if defined(AFS_SGI64_ENV)
 #define OSI_GET_CURRENT_ABI() get_current_abi()
-#endif /* AFS_SGI64_ENV */
 
 /*
  * OSI_GET_CURRENT_SYSID
  */
-#if defined(AFS_SGI_ENV) && !defined(AFS_SGI64_ENV)
-#define OSI_GET_CURRENT_SYSID() (u.u_procp->p_sysid)
-#endif /* AFS_SGI_ENV but not AFS_SGI64_ENV */
-
-#if defined(AFS_SGI64_ENV)
 #define OSI_GET_CURRENT_SYSID() (curprocp->p_flid.fl_sysid)
-#endif /* AFS_SGI64_ENV */
 
 /*
  * OSI_GET_CURRENT_COMM
  */
-#if defined(AFS_SGI_ENV) && !defined(AFS_SGI64_ENV)
-#define OSI_GET_CURRENT_COMM() (u.u_comm)
-#endif /* AFS_SGI_ENV but not AFS_SGI64_ENV */
-
-#if defined(AFS_SGI64_ENV)
 #define OSI_GET_CURRENT_COMM() (curprocp->p_comm)
-#endif /* AFS_SGI64_ENV */
 
 /*
  * OSI_GET_CURRENT_CDIR
  */
-#if defined(AFS_SGI_ENV) && !defined(AFS_SGI64_ENV)
-#define OSI_GET_CURRENT_CDIR() (u.u_cdir)
-#endif /* AFS_SGI_ENV but not AFS_SGI64_ENV */
-
-#if defined(AFS_SGI64_ENV) && !defined(AFS_SGI65_ENV)
-#define OSI_GET_CURRENT_CDIR() (curprocp->p_cdir)
-#endif /* AFS_SGI64_ENV */
-
-#if defined(AFS_SGI65_ENV)
 #define OSI_GET_CURRENT_CDIR() (curuthread->ut_cdir)
-#endif /* AFS_SGI65_ENV */
 
 
 /*
  * OSI_GET_CURRENT_RDIR
  */
-#if defined(AFS_SGI_ENV) && !defined(AFS_SGI64_ENV)
-#define OSI_GET_CURRENT_RDIR() (u.u_rdir)
-#endif /* AFS_SGI_ENV but not AFS_SGI64_ENV */
-
-#if defined(AFS_SGI64_ENV) && !defined(AFS_SGI65_ENV)
-#define OSI_GET_CURRENT_RDIR() (curprocp->p_rdir)
-#endif /* AFS_SGI64_ENV */
-
-#if defined(AFS_SGI65_ENV)
 #define OSI_GET_CURRENT_RDIR() (curuthread->ut_rdir)
-#endif /* AFS_SGI65_ENV */
 
 
 
@@ -364,7 +210,6 @@ extern long afs_global_owner;
  * Note that the _CONVERT routines get the ";" here so that argument lists
  * can have arguments after the OSI_x_CONVERT macro is called.
  */
-#ifdef AFS_SGI64_ENV
 #undef OSI_VN_ARG
 #define OSI_VN_ARG(V) bhv_##V
 #undef OSI_VN_DECL
@@ -383,7 +228,6 @@ extern long afs_global_owner;
 #define OSI_VFS_DECL(V)  bhv_desc_t *bhv_##V
 #undef OSI_VFS_CONVERT
 #define OSI_VFS_CONVERT(V) struct vfs * V = (struct vfs*)bhvtovfs(bhv_##V)
-#endif /* AFS_SGI64_ENV */
 
 #define osi_procname(procname, size) strncpy(procname, proc_name(curproc()), size)
 
index d2a18bf..23f3bba 100644 (file)
@@ -14,7 +14,6 @@
 #include "afs/param.h"
 
 
-#ifdef AFS_SGI62_ENV
 #include "afs/sysincludes.h"   /* Standard vendor system headers */
 #include "afsincludes.h"       /* Afs-based standard headers */
 #include "afs/afs_stats.h"     /* statistics */
@@ -152,6 +151,3 @@ int afs_ipno = 35;
 #else
 int afs_ipno = -1;
 #endif
-
-
-#endif /* AFS_SGI62_ENV */
index 5d1cea2..51f6dae 100644 (file)
@@ -45,14 +45,6 @@ osi_NewVnode(void)
     avc->vc_rwlockid = OSI_NO_LOCKID;
     initnsema(&avc->vc_rwlock, 1,
              makesname(name, "vrw", avc->v.v_number));
-#ifndef        AFS_SGI53_ENV
-    initnsema(&avc->v.v_sync, 0,
-             makesname(name, "vsy", avc->v.v_number));
-#endif
-#ifndef AFS_SGI62_ENV
-    initnlock(&avc->v.v_lock,
-             makesname(name, "vlk", avc->v.v_number));
-#endif
     return avc;
 }
 
@@ -74,7 +66,6 @@ osi_PostPopulateVCache(struct vcache *avc)
     memset(&(avc->vc_bhv_desc), 0, sizeof(avc->vc_bhv_desc));
     bhv_desc_init(&(avc->vc_bhv_desc), avc, avc, &Afs_vnodeops);
 
-#if defined(AFS_SGI65_ENV)
     vn_bhv_head_init(&(avc->v.v_bh), "afsvp");
     vn_bhv_insert_initial(&(avc->v.v_bh), &(avc->vc_bhv_desc));
     avc->v.v_mreg = avc->v.v_mregb = (struct pregion *)avc;
@@ -85,10 +76,6 @@ osi_PostPopulateVCache(struct vcache *avc)
                 avc->v.v_number);
     init_mutex(&avc->v.v_filocksem, MUTEX_DEFAULT, "afsvfl", (long)avc);
     init_mutex(&avc->v.v_buf_lock, MUTEX_DEFAULT, "afsvnbuf", (long)avc);
-#else
-    bhv_head_init(&(avc->v.v_bh));
-    bhv_insert_initial(&(avc->v.v_bh), &(avc->vc_bhv_desc));
-#endif
 
     vnode_pcache_init(&avc->v);
 
@@ -111,14 +98,9 @@ osi_PostPopulateVCache(struct vcache *avc)
     osi_Assert(avc->mapcnt == 0 && avc->vc_locktrips == 0);
     osi_Assert(avc->vc_rwlockid == OSI_NO_LOCKID);
     osi_Assert(avc->v.v_filocks == NULL);
-# if !defined(AFS_SGI65_ENV)
-    osi_Assert(avc->v.v_filocksem == NULL);
-# endif
     osi_Assert(avc->cred == NULL);
-# if defined(AFS_SGI64_ENV)
     vnode_pcache_reinit(&avc->v);
     avc->v.v_rdev = NODEV;
-# endif
     vn_initlist((struct vnlist *)&avc->v);
     avc->lastr = 0;
 }
index cd5cfbf..64ff997 100644 (file)
@@ -31,11 +31,7 @@ struct xfs_mount;
 extern int xfs_iget(struct mount *, struct xfs_trans *, xfs_ino_t, uint,
                    xfs_inode_t **, daddr_t);
 
-#ifdef AFS_SGI64_ENV
 #define XFS_ITOV(ip) BHV_TO_VNODE((struct bhv_desc *)(((char*)(ip)) + 6*sizeof(void*)))
-#else
-#define XFS_ITOV(ip) (*((vnode_t**)((((char*)(ip)) + 6*sizeof(void*)))))
-#endif
 
 /* When we have XFS only clients, then these macros will be defined in
  * terms of the XFS inode only.
@@ -289,7 +285,7 @@ extern struct pregion *vnode_get_mreg(vnode_t *);
 #endif
 
 
-#if defined(AFS_SGI64_ENV) && defined(CKPT)
+#if defined(CKPT)
 /* This is a fid for checkpoint restart. Note that the length will be
  * greater than 10 and so afs_vget can distinguish this fid.
  */
index a41bb56..5b29ed2 100644 (file)
@@ -110,11 +110,7 @@ Afs_init(struct vfssw *vswp, int fstype)
 
 
 extern int afs_mount(), afs_unmount(), afs_root(), afs_statfs();
-#ifdef AFS_SGI65_ENV
 extern int afs_sync(OSI_VFS_DECL(afsp), int flags, struct cred *cr);
-#else
-extern int afs_sync(OSI_VFS_DECL(afsp), short flags, struct cred *cr);
-#endif
 extern int afs_vget(OSI_VFS_DECL(afsp), vnode_t ** vpp, struct fid *afidp);
 #ifdef MP
 struct vfsops afs_lockedvfsops =
@@ -122,42 +118,26 @@ struct vfsops afs_lockedvfsops =
 struct vfsops Afs_vfsops =
 #endif
 {
-#ifdef AFS_SGI64_ENV
-#ifdef AFS_SGI65_ENV
     BHV_IDENTITY_INIT_POSITION(VFS_POSITION_BASE),
-#else
-    VFS_POSITION_BASE,
-#endif
-#endif
     afs_mount,
-#ifdef AFS_SGI64_ENV
     fs_nosys,                  /* rootinit */
     fs_nosys,                  /* mntupdate */
     fs_dounmount,
-#endif
     afs_unmount,
     afs_root,
     afs_statfs,
     afs_sync,
     afs_vget,
     fs_nosys,                  /* mountroot */
-#ifdef AFS_SGI65_ENV
     fs_nosys,                  /* realvfsops */
     fs_import,                 /* import */
     fs_nosys,                  /* quotactl */
-#else
-    fs_nosys,                  /* swapvp */
-#endif
 };
 extern struct afs_q VLRU;      /*vcache LRU */
 
-#ifdef AFS_SGI64_ENV
 static bhv_desc_t afs_vfs_bhv;
-#endif
 afs_mount(struct vfs *afsp, vnode_t * mvp, struct mounta *uap,
-#ifdef AFS_SGI65_ENV
          char *attrs,
-#endif
          cred_t * cr)
 {
     AFS_STATCNT(afs_mount);
@@ -176,11 +156,7 @@ afs_mount(struct vfs *afsp, vnode_t * mvp, struct mounta *uap,
     afsp->vfs_bsize = 8192;
     afsp->vfs_fsid.val[0] = AFS_VFSMAGIC;      /* magic */
     afsp->vfs_fsid.val[1] = afs_fstype;
-#ifdef AFS_SGI64_ENV
     vfs_insertbhv(afsp, &afs_vfs_bhv, &Afs_vfsops, &afs_vfs_bhv);
-#else
-    afsp->vfs_data = NULL;
-#endif
     afsp->vfs_fstype = afs_fstype;
     afsp->vfs_dev = 0xbabebabe;        /* XXX this should be unique */
 
@@ -246,9 +222,7 @@ afs_unmount(OSI_VFS_ARG(afsp), flags, cr)
     ReleaseWriteLock(&afs_xvcache);
     afs_globalVFS = 0;
     afs_shutdown(AFS_WARM);
-#ifdef AFS_SGI65_ENV
     VFS_REMOVEBHV(afsp, &afs_vfs_bhv);
-#endif
     return 0;
 }
 
@@ -347,17 +321,11 @@ afs_statfs(OSI_VFS_ARG(afsp), abp, avp)
 
 extern afs_int32 vcachegen;
 #define PREEMPT_MASK    0x7f
-#ifdef AFS_SGI64_ENV
 #define PREEMPT()
-#endif
 
 int
 afs_sync(OSI_VFS_DECL(afsp),
-#ifdef AFS_SGI65_ENV
         int flags,
-#else
-        short flags,
-#endif
         struct cred *cr)
 {
     /* Why enable the vfs sync operation?? */
@@ -374,13 +342,8 @@ afs_sync(OSI_VFS_DECL(afsp),
     /*
      * if not interested in vnodes, skip all this
      */
-#ifdef AFS_SGI61_ENV
     if ((flags & (SYNC_CLOSE | SYNC_DELWRI | SYNC_PDFLUSH)) == 0)
        goto end;
-#else /* AFS_SGI61_ENV */
-    if ((flags & (SYNC_CLOSE | SYNC_DELWRI | SYNC_ATTR)) == 0)
-       goto end;
-#endif /* AFS_SGI61_ENV */
   loop:
     ObtainReadLock(&afs_xvcache);
     for (tq = VLRU.prev; tq != &VLRU; tq = uq) {
@@ -411,14 +374,12 @@ afs_sync(OSI_VFS_DECL(afsp),
                continue;
            }
        }
-#ifdef AFS_SGI61_ENV
        else if (flags & SYNC_PDFLUSH) {
            if (!VN_GET_DPAGES(vp)) {
                VN_UNLOCK(vp, s);
                continue;
            }
        }
-#endif /* AFS_SGI61_ENV */
 
        vp->v_count++;
        VN_UNLOCK(vp, s);
@@ -430,11 +391,7 @@ afs_sync(OSI_VFS_DECL(afsp),
         * sleep for rwlock.
         */
        if (afs_rwlock_nowait(vp, 1) == 0) {
-#ifdef AFS_SGI61_ENV
            if (flags & (SYNC_BDFLUSH | SYNC_PDFLUSH))
-#else /* AFS_SGI61_ENV */
-           if (flags & SYNC_BDFLUSH)
-#endif /* AFS_SGI61_ENV */
            {
                AFS_RELE(vp);
                ObtainReadLock(&afs_xvcache);
@@ -451,31 +408,16 @@ afs_sync(OSI_VFS_DECL(afsp),
        if (flags & SYNC_CLOSE) {
            PFLUSHINVALVP(vp, (off_t) 0, (off_t) tvc->f.m.Length);
        }
-#ifdef AFS_SGI61_ENV
        else if (flags & SYNC_PDFLUSH) {
            if (VN_GET_DPAGES(vp)) {
                pdflush(vp, B_ASYNC);
            }
        }
-#endif /* AFS_SGI61_ENV */
 
 
        if ((flags & SYNC_DELWRI) && AFS_VN_DIRTY(vp)) {
-#ifdef AFS_SGI61_ENV
            PFLUSHVP(vp, (off_t) tvc->f.m.Length,
                     (flags & SYNC_WAIT) ? 0 : B_ASYNC, error);
-#else /* AFS_SGI61_ENV */
-           if (flags & SYNC_WAIT)
-               /* push all and wait */
-               PFLUSHVP(vp, (off_t) tvc->f.m.Length, (off_t) 0, error);
-           else if (flags & SYNC_BDFLUSH) {
-               /* push oldest */
-               error = pdflush(vp, B_ASYNC);
-           } else {
-               /* push all but don't wait */
-               PFLUSHVP(vp, (off_t) tvc->f.m.Length, (off_t) B_ASYNC, error);
-           }
-#endif /* AFS_SGI61_ENV */
        }
 
        /*
@@ -513,7 +455,7 @@ afs_vget(OSI_VFS_DECL(afsp), vnode_t ** avcp, struct fid * fidp)
     afs_int32 code = 0;
     afs_int32 ret;
 
-#if defined(AFS_SGI64_ENV) && defined(CKPT) && !defined(_R5000_CVT_WAR)
+#if defined(CKPT) && !defined(_R5000_CVT_WAR)
     afs_fid2_t *afid2;
 #endif
 
@@ -523,7 +465,7 @@ afs_vget(OSI_VFS_DECL(afsp), vnode_t ** avcp, struct fid * fidp)
 
     *avcp = NULL;
 
-#if defined(AFS_SGI64_ENV) && defined(CKPT) && !defined(_R5000_CVT_WAR)
+#if defined(CKPT) && !defined(_R5000_CVT_WAR)
     afid2 = (afs_fid2_t *) fidp;
     if (afid2->af_len == sizeof(afs_fid2_t) - sizeof(afid2->af_len)) {
        /* It's a checkpoint restart fid. */
@@ -564,25 +506,17 @@ afs_vget(OSI_VFS_DECL(afsp), vnode_t ** avcp, struct fid * fidp)
 #ifdef MP                      /* locked versions of vfs operations. */
 
 /* wrappers for vfs calls */
-#ifdef AFS_SGI64_ENV
 #define AFS_MP_VFS_ARG(A) bhv_desc_t A
-#else
-#define AFS_MP_VFS_ARG(A) struct vfs A
-#endif
 
 int
 mp_afs_mount(struct vfs *a, struct vnode *b, struct mounta *c,
-#ifdef AFS_SGI65_ENV
             char *d,
-#endif
             struct cred *e)
 {
     int rv;
     AFS_GLOCK();
     rv = afs_lockedvfsops.vfs_mount(a, b, c, d
-#ifdef AFS_SGI65_ENV
                                    , e
-#endif
        );
     AFS_GUNLOCK();
     return rv;
@@ -620,11 +554,7 @@ mp_afs_statvfs(AFS_MP_VFS_ARG(*a), struct statvfs *b, struct vnode *c)
 
 int
 mp_afs_sync(AFS_MP_VFS_ARG(*a),
-#ifdef AFS_SGI65_ENV
            int b,
-#else
-           short b,
-#endif
            struct cred *c)
 {
     int rv;
@@ -645,32 +575,20 @@ mp_afs_vget(AFS_MP_VFS_ARG(*a), struct vnode **b, struct fid *c)
 }
 
 struct vfsops Afs_vfsops = {
-#ifdef AFS_SGI64_ENV
-#ifdef AFS_SGI65_ENV
     BHV_IDENTITY_INIT_POSITION(VFS_POSITION_BASE),
-#else
-    VFS_POSITION_BASE,
-#endif
-#endif
     mp_afs_mount,
-#ifdef AFS_SGI64_ENV
     fs_nosys,                  /* rootinit */
     fs_nosys,                  /* mntupdate */
     fs_dounmount,
-#endif
     mp_afs_unmount,
     mp_afs_root,
     mp_afs_statvfs,
     mp_afs_sync,
     mp_afs_vget,
     fs_nosys,                  /* mountroot */
-#ifdef AFS_SGI65_ENV
     fs_nosys,                  /* realvfsops */
     fs_import,                 /* import */
     fs_nosys,                  /* quotactl */
-#else
-    fs_nosys,                  /* swapvp */
-#endif
 };
 
 #endif /* MP */
index 7d07be0..f07d7f1 100644 (file)
@@ -75,28 +75,12 @@ osi_VM_FlushVCache(struct vcache *avc)
     osi_Assert(!AFS_VN_MAPPED(vp));
     osi_Assert(!AFS_VN_DIRTY(&avc->v));
 
-#if defined(AFS_SGI65_ENV)
     if (vp->v_filocks)
        cleanlocks(vp, IGN_PID, 0);
     mutex_destroy(&vp->v_filocksem);
-#else /* AFS_SGI65_ENV */
-    if (vp->v_filocksem) {
-       if (vp->v_filocks)
-#ifdef AFS_SGI64_ENV
-           cleanlocks(vp, &curprocp->p_flid);
-#else
-           cleanlocks(vp, IGN_PID, 0);
-#endif
-       osi_Assert(vp->v_filocks == NULL);
-       mutex_destroy(vp->v_filocksem);
-       kmem_free(vp->v_filocksem, sizeof *vp->v_filocksem);
-       vp->v_filocksem = NULL;
-    }
-#endif /* AFS_SGI65_ENV */
 
     if (avc->vrefCount)
        osi_Panic("flushVcache: vm race");
-#ifdef AFS_SGI64_ENV
     AFS_GUNLOCK();
     vnode_pcache_reclaim(vp);  /* this can sleep */
     vnode_pcache_free(vp);
@@ -104,7 +88,6 @@ osi_VM_FlushVCache(struct vcache *avc)
        VOP_RECLAIM(vp, FSYNC_WAIT, code);
     }
     AFS_GLOCK();
-#ifdef AFS_SGI65_ENV
 #ifdef VNODE_TRACING
     ktrace_free(vp->v_trace);
 #endif /* VNODE_TRACING */
@@ -112,10 +95,6 @@ osi_VM_FlushVCache(struct vcache *avc)
     vn_bhv_head_destroy(&(vp->v_bh));
     destroy_bitlock(&vp->v_pcacheflag);
     mutex_destroy(&vp->v_buf_lock);
-#else
-    bhv_remove(VN_BHV_HEAD(vp), &(avc->vc_bhv_desc));
-    bhv_head_destroy(&(vp->v_bh));
-#endif
     vp->v_flag = 0;            /* debug */
 #if defined(DEBUG) && defined(VNODE_INIT_BITLOCK)
     destroy_bitlock(&vp->v_flag);
@@ -123,7 +102,6 @@ osi_VM_FlushVCache(struct vcache *avc)
 #ifdef INTR_KTHREADS
     AFS_VN_DESTROY_BUF_LOCK(vp);
 #endif
-#endif /* AFS_SGI64_ENV */
 
     return 0;
 }
index 29aab4a..1d4a26c 100644 (file)
@@ -14,7 +14,6 @@
 #include "afs/param.h"
 
 
-#ifdef AFS_SGI62_ENV
 #include "afs/sysincludes.h"   /* Standard vendor system headers */
 #include "afsincludes.h"       /* Afs-based standard headers */
 #include "afs/afs_stats.h"     /* statistics */
@@ -31,9 +30,6 @@ extern void afs_chkpgoob(vnode_t *, pgno_t);
 static void afs_strategy();
 static int afs_xread(), afs_xwrite();
 static int afs_xbmap(), afs_map(), afs_reclaim();
-#ifndef AFS_SGI65_ENV
-static int afs_addmap(), afs_delmap();
-#endif
 extern int afs_open(), afs_close(), afs_ioctl(), afs_getattr(), afs_setattr();
 extern int afs_access(), afs_lookup();
 extern int afs_create(), afs_remove(), afs_link(), afs_rename();
@@ -41,11 +37,7 @@ extern int afs_mkdir(), afs_rmdir(), afs_readdir();
 extern int afs_symlink(), afs_readlink(), afs_fsync(), afs_fid(),
 afs_frlock();
 static int afs_seek(OSI_VC_DECL(a), off_t b, off_t * c);
-#ifdef AFS_SGI64_ENV
 extern int afs_xinactive();
-#else
-extern void afs_xinactive();
-#endif
 
 extern void afs_rwlock(OSI_VN_DECL(vp), AFS_RWLOCK_T b);
 extern void afs_rwunlock(OSI_VN_DECL(vp), AFS_RWLOCK_T b);
@@ -54,11 +46,7 @@ extern int afs_fid2();
 
 static int afsrwvp(struct vcache *avc, struct uio *uio,
                   enum uio_rw rw, int ioflag,
-#ifdef AFS_SGI64_ENV
                   struct cred *cr, struct flid *flp);
-#else
-                  struct cred *cr);
-#endif
 #ifdef MP
 static void mp_afs_rwlock(OSI_VN_DECL(a), AFS_RWLOCK_T b);
 static void mp_afs_rwunlock(OSI_VN_DECL(a), AFS_RWLOCK_T b);
@@ -67,13 +55,7 @@ struct vnodeops afs_lockedvnodeops =
 struct vnodeops Afs_vnodeops =
 #endif
 {
-#ifdef AFS_SGI64_ENV
-#ifdef AFS_SGI65_ENV
     BHV_IDENTITY_INIT_POSITION(VNODE_POSITION_BASE),
-#else
-    VNODE_POSITION_BASE,
-#endif
-#endif
     afs_open,
     afs_close,
     afs_xread,
@@ -106,13 +88,8 @@ struct vnodeops Afs_vnodeops =
     afs_xbmap,
     afs_strategy,
     afs_map,
-#ifdef AFS_SGI65_ENV
     fs_noerr,                  /* addmap - devices only */
     fs_noerr,                  /* delmap - devices only */
-#else
-    afs_addmap,
-    afs_delmap,
-#endif
     fs_poll,                   /* poll */
     fs_nosys,                  /* dump */
     fs_pathconf,
@@ -123,8 +100,6 @@ struct vnodeops Afs_vnodeops =
     fs_nosys,                  /* attr_set */
     fs_nosys,                  /* attr_remove */
     fs_nosys,                  /* attr_list */
-#ifdef AFS_SGI64_ENV
-#ifdef AFS_SGI65_ENV
     fs_cover,
     (vop_link_removed_t) fs_noval,
     fs_vnode_change,
@@ -137,10 +112,6 @@ struct vnodeops Afs_vnodeops =
     (vop_readbuf_t) fs_nosys,
     fs_strgetmsg,
     fs_strputmsg,
-#else
-    fs_mount,
-#endif
-#endif
 };
 
 #ifndef MP
@@ -150,19 +121,15 @@ struct vnodeops *afs_ops = &Afs_vnodeops;
 int
 afs_frlock(OSI_VN_DECL(vp), int cmd, struct flock *lfp, int flag,
           off_t offset,
-#ifdef AFS_SGI65_ENV
           vrwlock_t vrwlock,
-#endif
           cred_t * cr)
 {
     int error;
     OSI_VN_CONVERT(vp);
-#ifdef AFS_SGI65_ENV
     struct flid flid;
     int pid;
     get_current_flid(&flid);
     pid = flid.fl_pid;
-#endif
 
     /*
      * Since AFS doesn't support byte-wise locks (and simply
@@ -180,12 +147,8 @@ afs_frlock(OSI_VN_DECL(vp), int cmd, struct flock *lfp, int flag,
        || (lfp->l_len != MAXEND && lfp->l_len != 0)) {
        AFS_RWLOCK(vp, VRWLOCK_WRITE);
        AFS_GUNLOCK();
-#ifdef AFS_SGI65_ENV
        error =
            fs_frlock(OSI_VN_ARG(vp), cmd, lfp, flag, offset, vrwlock, cr);
-#else
-       error = fs_frlock(vp, cmd, lfp, flag, offset, cr);
-#endif
        AFS_GLOCK();
        AFS_RWUNLOCK(vp, VRWLOCK_WRITE);
        if (error || cmd != F_GETLK)
@@ -222,18 +185,12 @@ afs_frlock(OSI_VN_DECL(vp), int cmd, struct flock *lfp, int flag,
     AFS_GUNLOCK();
 
     error = convoff(vp, lfp, 0, offset, SEEKLIMIT
-#ifdef AFS_SGI64_ENV
                    , OSI_GET_CURRENT_CRED()
-#endif /* AFS_SGI64_ENV */
        );
 
     AFS_GLOCK();
     if (!error) {
-#ifdef AFS_SGI65_ENV
        error = afs_lockctl(vp, lfp, cmd, cr, pid);
-#else
-       error = afs_lockctl(vp, lfp, cmd, cr, OSI_GET_CURRENT_PID());
-#endif
     }
     return error;
 }
@@ -260,14 +217,9 @@ afs_frlock(OSI_VN_DECL(vp), int cmd, struct flock *lfp, int flag,
  * doing direct I/O on the read side....
  */
 /* ARGSUSED */
-#ifdef AFS_SGI64_ENV
 static int
 afs_xread(OSI_VC_ARG(avc), uiop, ioflag, cr, flp)
      struct flid *flp;
-#else
-static int
-afs_xread(OSI_VC_ARG(avc), uiop, ioflag, cr)
-#endif
 OSI_VC_DECL(avc);
      struct uio *uiop;
      int ioflag;
@@ -280,31 +232,18 @@ OSI_VC_DECL(avc);
     if (avc->v.v_type != VREG)
        return EISDIR;
 
-#ifdef AFS_SGI64_ENV
-#ifdef AFS_SGI65_ENV
     if (!(ioflag & IO_ISLOCKED))
        AFS_RWLOCK((vnode_t *) avc, VRWLOCK_READ);
-#endif
     code = afsrwvp(avc, uiop, UIO_READ, ioflag, cr, flp);
-#ifdef AFS_SGI65_ENV
     if (!(ioflag & IO_ISLOCKED))
        AFS_RWUNLOCK((vnode_t *) avc, VRWLOCK_READ);
-#endif
-#else
-    code = afsrwvp(avc, uiop, UIO_READ, ioflag, cr);
-#endif
     return code;
 }
 
 /* ARGSUSED */
-#ifdef AFS_SGI64_ENV
 static int
 afs_xwrite(OSI_VC_ARG(avc), uiop, ioflag, cr, flp)
      struct flid *flp;
-#else
-static int
-afs_xwrite(OSI_VC_ARG(avc), uiop, ioflag, cr)
-#endif
 OSI_VC_DECL(avc);
      struct uio *uiop;
      int ioflag;
@@ -319,19 +258,11 @@ OSI_VC_DECL(avc);
 
     if (ioflag & IO_APPEND)
        uiop->uio_offset = avc->f.m.Length;
-#ifdef AFS_SGI64_ENV
-#ifdef AFS_SGI65_ENV
     if (!(ioflag & IO_ISLOCKED))
        AFS_RWLOCK(((vnode_t *) avc), VRWLOCK_WRITE);
-#endif
     code = afsrwvp(avc, uiop, UIO_WRITE, ioflag, cr, flp);
-#ifdef AFS_SGI65_ENV
     if (!(ioflag & IO_ISLOCKED))
        AFS_RWUNLOCK((vnode_t *) avc, VRWLOCK_WRITE);
-#endif
-#else
-    code = afsrwvp(avc, uiop, UIO_WRITE, ioflag, cr);
-#endif
     return code;
 }
 
@@ -343,11 +274,7 @@ static int acdrop = 0;
 static int
 afsrwvp(struct vcache *avc, struct uio *uio, enum uio_rw rw,
        int ioflag,
-#ifdef AFS_SGI64_ENV
        struct cred *cr, struct flid *flp)
-#else
-       struct cred *cr)
-#endif
 {
     struct vnode *vp = AFSTOV(avc);
     struct buf *bp;
@@ -492,10 +419,8 @@ afsrwvp(struct vcache *avc, struct uio *uio, enum uio_rw rw,
            bmv[0].pboff = off;
            bmv[0].pbsize = MIN(cnt, uio->uio_resid);
            bmv[0].eof = 0;
-#ifdef AFS_SGI64_ENV
            bmv[0].pbdev = vp->v_rdev;
            bmv[0].pmp = uio->uio_pmp;
-#endif
            osi_Assert(cnt > 0);
            /*
             * initiate read-ahead if it looks like
@@ -507,11 +432,7 @@ afsrwvp(struct vcache *avc, struct uio *uio, enum uio_rw rw,
             */
            if ((avc->lastr + BTOBB(AFSBSIZE) == bn
                 || uio->uio_resid > AFSBSIZE)
-#ifdef AFS_SGI61_ENV
                && (!AFS_VN_MAPPED(vp))
-#else /* AFS_SGI61_ENV */
-               && ((vp->v_flag & VWASMAP) == 0)
-#endif /* AFS_SGI61_ENV */
                ) {
                rem -= cnt;
                if (rem > 0) {
@@ -527,10 +448,8 @@ afsrwvp(struct vcache *avc, struct uio *uio, enum uio_rw rw,
                    bmv[1].bsize = bsize;
                    bmv[1].pboff = 0;
                    bmv[1].pbsize = acnt;
-#ifdef AFS_SGI64_ENV
                    bmv[1].pmp = uio->uio_pmp;
                    bmv[1].pbdev = vp->v_rdev;
-#endif
                }
            }
 #ifdef DEBUG
@@ -591,9 +510,7 @@ afsrwvp(struct vcache *avc, struct uio *uio, enum uio_rw rw,
            bmv[0].bsize = bsize;
            bmv[0].pboff = off;
            bmv[0].pbsize = cnt;
-#ifdef AFS_SGI64_ENV
            bmv[0].pmp = uio->uio_pmp;
-#endif
 
            if (cnt == bsize)
                bp = getchunk(vp, bmv, cr);
@@ -677,20 +594,12 @@ afsrwvp(struct vcache *avc, struct uio *uio, enum uio_rw rw,
     }
 
     if (!error) {
-#ifdef AFS_SGI61_ENV
        if (((ioflag & IO_SYNC) || (ioflag & IO_DSYNC)) && (rw == UIO_WRITE)
            && !AFS_NFSXLATORREQ(cr)) {
            error = afs_fsync(avc, 0, cr
-#ifdef AFS_SGI65_ENV
                              , 0, 0
-#endif
                              );
        }
-#else /* AFS_SGI61_ENV */
-       if ((ioflag & IO_SYNC) && (rw == UIO_WRITE) && !AFS_NFSXLATORREQ(cr)) {
-           error = afs_fsync(avc, 0, cr);
-       }
-#endif /* AFS_SGI61_ENV */
     }
     if (didFakeOpen) {
        ObtainWriteLock(&avc->lock, 236);
@@ -743,10 +652,8 @@ OSI_VC_DECL(avc);
     bsize = ctob(btoc(off + cnt));
     bmv->pbsize = MIN(cnt, count);
     bmv->eof = 0;
-#ifdef AFS_SGI64_ENV
     bmv->pmp = NULL;
     bmv->pbdev = avc->v.v_rdev;
-#endif
     bmv->bsize = bsize;
     bmv->length = BTOBBT(bsize);
     *nbmv = 1;
@@ -843,9 +750,7 @@ OSI_VC_DECL(avc);
     uio->uio_offset = BBTOB(bp->b_blkno);
     uio->uio_segflg = UIO_SYSSPACE;
     uio->uio_limit = RLIM_INFINITY;    /* we checked the limit earlier */
-#ifdef AFS_SGI64_ENV
     uio->uio_pmp = NULL;
-#endif
 
     if (bp->b_flags & B_READ) {
        uio->uio_fmode = FREAD;
@@ -883,128 +788,11 @@ OSI_VC_DECL(avc);
     return *noffp < 0 ? EINVAL : 0;
 }
 
-#if !defined(AFS_SGI65_ENV)
-/* Irix 6.5 uses addmap/delmap only for devices. */
-/* ARGSUSED */
-static int
-afs_addmap(OSI_VC_ARG(avc), off, prp, addr, len, prot, maxprot, flags, cr)
-     off_t off;
-OSI_VC_DECL(avc);
-     struct pregion *prp;
-     addr_t addr;
-     size_t len;
-     u_int prot, maxprot;
-     u_int flags;
-     struct cred *cr;
-{
-    OSI_VC_CONVERT(avc);
-    struct vnode *vp = AFSTOV(avc);
-
-    if (vp->v_flag & VNOMAP)
-       return ENOSYS;
-    if (len == 0)
-       return 0;
-    AFS_RWLOCK(vp, VRWLOCK_WRITE);
-    if (avc->mapcnt == 0) {
-       /* on first mapping add a open reference */
-       ObtainWriteLock(&avc->lock, 237);
-       avc->execsOrWriters++;
-       avc->opens++;
-       ReleaseWriteLock(&avc->lock);
-    }
-    avc->mapcnt += btoc(len);
-    AFS_RWUNLOCK(vp, VRWLOCK_WRITE);
-    return 0;
-}
-
- /*ARGSUSED*/ static int
-afs_delmap(OSI_VC_ARG(avc), off, prp, addr, len, prot, maxprot, flags, acred)
-     off_t off;
-OSI_VC_DECL(avc);
-     struct pregion *prp;
-     addr_t addr;
-     size_t len;
-     u_int prot, maxprot;
-     u_int flags;
-     struct cred *acred;
-{
-    OSI_VC_CONVERT(avc);
-    struct vnode *vp = AFSTOV(avc);
-    struct brequest *tb;
-    struct vrequest treq;
-    afs_int32 code;
-
-    if (vp->v_flag & VNOMAP)
-       return ENOSYS;
-    if (len == 0)
-       return 0;
-    AFS_RWLOCK(vp, VRWLOCK_WRITE);
-    osi_Assert(avc->mapcnt > 0);
-    avc->mapcnt -= btoc(len);
-    osi_Assert(avc->mapcnt >= 0);
-    if (avc->mapcnt == 0) {
-       /* on last mapping push back and remove our reference */
-       osi_Assert(avc->execsOrWriters > 0);
-       osi_Assert(avc->opens > 0);
-       if (avc->f.m.LinkCount == 0) {
-           ObtainWriteLock(&avc->lock, 238);
-           AFS_GUNLOCK();
-           PTOSSVP(vp, (off_t) 0, (off_t) MAXLONG);
-           AFS_GLOCK();
-           ReleaseWriteLock(&avc->lock);
-       }
-       /*
-        * mimic afs_close
-        */
-       code = afs_InitReq(&treq, acred);
-       if (code) {
-           code = afs_CheckCode(code, NULL, 64);
-           AFS_RWUNLOCK(vp, VRWLOCK_WRITE);
-       } else if (afs_BBusy()) {
-           /* do it yourself if daemons are all busy */
-           ObtainWriteLock(&avc->lock, 239);
-           code = afs_StoreOnLastReference(avc, &treq);
-           ReleaseWriteLock(&avc->lock);
-           /* BStore does CheckCode so we should also */
-           /* VNOVNODE is "acceptable" error code from close, since
-            * may happen when deleting a file on another machine while
-            * it is open here. */
-           if (code == VNOVNODE)
-               code = 0;
-           if (code) {
-               afs_StoreWarn(code, avc->f.fid.Fid.Volume,      /* /dev/console */
-                             1);
-           }
-           code = afs_CheckCode(code, &treq, 52);
-           AFS_RWUNLOCK(vp, VRWLOCK_WRITE);
-       } else {
-           AFS_RWUNLOCK(vp, VRWLOCK_WRITE);
-           /* at least one daemon is idle, so ask it to do the store.
-            * Also, note that  we don't lock it any more... */
-           tb = afs_BQueue(BOP_STORE, avc, 0, 1, acred,
-                           (afs_size_t) afs_cr_uid(acred), 0L, (void *)0,
-                           (void *)0, (void *)0);
-           /* sleep waiting for the store to start, then retrieve error code */
-           while ((tb->flags & BUVALID) == 0) {
-               tb->flags |= BUWAIT;
-               afs_osi_Sleep(tb);
-           }
-           afs_BRelease(tb);
-       }
-    } else {
-       AFS_RWUNLOCK(vp, VRWLOCK_WRITE);
-    }
-    return 0;
-}
-#endif /* ! AFS_SGI65_ENV */
-
-
 /* ARGSUSED */
 /*
  * Note - if mapping in an ELF interpreter, one can get called without vp
  * ever having been 'opened'
  */
-#ifdef AFS_SGI65_ENV
 static int
 afs_map(OSI_VC_ARG(avc), off, len, prot, flags, cr, vpp)
      off_t off;
@@ -1014,18 +802,6 @@ OSI_VC_DECL(avc);
      u_int flags;
      struct cred *cr;
      vnode_t **vpp;
-#else
-static int
-afs_map(OSI_VC_ARG(avc), off, prp, addrp, len, prot, maxprot, flags, cr)
-     off_t off;
-OSI_VC_DECL(avc);
-     struct pregion *prp;
-     addr_t *addrp;
-     size_t len;
-     u_int prot, maxprot;
-     u_int flags;
-     struct cred *cr;
-#endif
 {
     OSI_VC_CONVERT(avc);
     struct vnode *vp = AFSTOV(avc);
@@ -1042,7 +818,6 @@ OSI_VC_DECL(avc);
        return afs_CheckCode(error, &treq, 53);
 
     osi_FlushPages(avc, cr);   /* ensure old pages are gone */
-#ifdef AFS_SGI65_ENV
     /* If the vnode is currently opened for write, there's the potential
      * that this mapping might (now or in the future) have PROT_WRITE.
      * So assume it does and we'll have to call afs_StoreOnLastReference.
@@ -1056,21 +831,8 @@ OSI_VC_DECL(avc);
     }
     ReleaseWriteLock(&avc->lock);
     AFS_RWUNLOCK(vp, VRWLOCK_WRITE);
-#else
-    AFS_RWLOCK(vp, VRWLOCK_WRITE);
-    AFS_GUNLOCK();
-    error =
-       fs_map_subr(vp, (off_t) avc->f.m.Length, (u_int) avc->f.m.Mode, off, prp,
-                   *addrp, len, prot, maxprot, flags, cr);
-    AFS_GLOCK();
-    AFS_RWUNLOCK(vp, VRWLOCK_WRITE);
-#endif /* AFS_SGI65_ENV */
     afs_Trace4(afs_iclSetp, CM_TRACE_GMAP, ICL_TYPE_POINTER, vp,
-#ifdef AFS_SGI65_ENV
               ICL_TYPE_POINTER, NULL,
-#else
-              ICL_TYPE_POINTER, *addrp,
-#endif
               ICL_TYPE_INT32, len, ICL_TYPE_INT32, off);
     return error;
 }
@@ -1078,11 +840,7 @@ OSI_VC_DECL(avc);
 
 extern afs_rwlock_t afs_xvcache;
 extern afs_lock_t afs_xdcache;
-#ifdef AFS_SGI64_ENV
 int
-#else
-void
-#endif
 afs_xinactive(OSI_VC_ARG(avc), acred)
 OSI_VC_DECL(avc);
      struct ucred *acred;
@@ -1099,11 +857,7 @@ OSI_VC_DECL(avc);
        /* inactive was already done, or someone did a VN_HOLD; just return */
        vp->v_flag &= ~VINACT;
        VN_UNLOCK(vp, s);
-#ifdef AFS_SGI64_ENV
        return VN_INACTIVE_CACHE;
-#else
-       return;
-#endif
     }
     osi_Assert((vp->v_flag & VSHARE) == 0);
     vp->v_flag &= ~VINACT;
@@ -1112,7 +866,6 @@ OSI_VC_DECL(avc);
      */
     VN_UNLOCK(vp, s);
 
-#ifdef AFS_SGI65_ENV
     /* In Irix 6.5, the last unmap of a dirty mmap'd file does not
      * get an explicit vnode op. Instead we only find out at VOP_INACTIVE.
      */
@@ -1176,7 +929,6 @@ OSI_VC_DECL(avc);
            }
        }
     }
-#endif
 
     osi_Assert((avc->f.states & (CCore | CMAPPED)) == 0);
 
@@ -1196,33 +948,14 @@ OSI_VC_DECL(avc);
        PTOSSVP(vp, (off_t) 0, (off_t) MAXLONG);
        AFS_GLOCK();
     }
-#ifndef AFS_SGI65_ENV
-    osi_Assert(avc->mapcnt == 0);
-    afs_chkpgoob(&avc->v, btoc(avc->f.m.Length));
-
-    avc->f.states &= ~CDirty;  /* Give up on store-backs */
-    if (avc->f.states & CUnlinked) {
-       if (CheckLock(&afs_xvcache) || CheckLock(&afs_xdcache)) {
-           avc->f.states |= CUnlinkedDel;
-       } else {
-           afs_remunlink(avc, 1);      /* ignore any return code */
-       }
-    }
-#endif
-#ifdef AFS_SGI64_ENV
     return VN_INACTIVE_CACHE;
-#endif
 }
 
 static int
 afs_reclaim(OSI_VC_DECL(avc), int flag)
 {
-#ifdef AFS_SGI64_ENV
     /* Get's called via VOP_RELCAIM in afs_FlushVCache to clear repl_vnodeops */
     return 0;
-#else
-    panic("afs_reclaim");
-#endif
 }
 
 void
@@ -1280,7 +1013,7 @@ afs_rwlock_nowait(vnode_t * vp, AFS_RWLOCK_T flag)
     return 0;
 }
 
-#if defined(AFS_SGI64_ENV) && defined(CKPT) && !defined(_R5000_CVT_WAR)
+#if defined(CKPT) && !defined(_R5000_CVT_WAR)
 int
 afs_fid2(OSI_VC_DECL(avc), struct fid *fidp)
 {
@@ -1323,7 +1056,7 @@ afs_fid2(OSI_VC_DECL(avc), struct fid *fidp)
     return EINVAL;
 #endif
 }
-#endif /* AFS_SGI64_ENV && CKPT */
+#endif /* CKPT */
 
 
 /*
@@ -1345,114 +1078,62 @@ afs_chkpgoob(vnode_t * vp, pgno_t pgno)
 
 #ifdef MP
 
-#ifdef AFS_SGI64_ENV
 #define AFS_MP_VC_ARG(A) bhv_desc_t A
-#else
-#define AFS_MP_VC_ARG(A) vnode_t A
-#endif
 
-#ifdef AFS_SGI64_ENV
 int
 mp_afs_open(bhv_desc_t * bhp, vnode_t ** a, mode_t b, struct cred *c)
-#else
-int
-mp_afs_open(vnode_t ** a, mode_t b, struct cred *c)
-#endif
 {
     int rv;
     AFS_GLOCK();
-#ifdef AFS_SGI64_ENV
     rv = afs_lockedvnodeops.vop_open(bhp, a, b, c);
-#else
-    rv = afs_lockedvnodeops.vop_open(a, b, c);
-#endif
     AFS_GUNLOCK();
     return rv;
 }
 
-#if defined(AFS_SGI64_ENV)
-#if defined(AFS_SGI65_ENV)
 int
 mp_afs_close(AFS_MP_VC_ARG(*a), int b, lastclose_t c, struct cred *d)
-#else
-int
-mp_afs_close(AFS_MP_VC_ARG(*a), int b, lastclose_t c, off_t d, struct cred *e,
-            struct flid *f)
-#endif
-#else
-int
-mp_afs_close(AFS_MP_VC_ARG(*a), int b, lastclose_t c, off_t d, struct cred *e)
-#endif
 {
     int rv;
     AFS_GLOCK();
     rv = afs_lockedvnodeops.vop_close(a, b, c, d
-#if !defined(AFS_SGI65_ENV)
-                                     , e
-#if defined(AFS_SGI64_ENV)
-                                     , f
-#endif
-#endif
        );
 
     AFS_GUNLOCK();
     return rv;
 }
 
-#ifdef AFS_SGI64_ENV
 int
 mp_afs_read(AFS_MP_VC_ARG(*a), struct uio *b, int c, struct cred *d,
            struct flid *f)
-#else
-int
-mp_afs_read(AFS_MP_VC_ARG(*a), struct uio *b, int c, struct cred *d)
-#endif
 {
     int rv;
     AFS_GLOCK();
-#ifdef AFS_SGI64_ENV
     rv = afs_lockedvnodeops.vop_read(a, b, c, d, f);
-#else
-    rv = afs_lockedvnodeops.vop_read(a, b, c, d);
-#endif
     AFS_GUNLOCK();
     return rv;
 }
 
 
-#ifdef AFS_SGI64_ENV
 int
 mp_afs_write(AFS_MP_VC_ARG(*a), struct uio *b, int c, struct cred *d,
             struct flid *f)
-#else
-int
-mp_afs_write(AFS_MP_VC_ARG(*a), struct uio *b, int c, struct cred *d)
-#endif
 {
     int rv;
     AFS_GLOCK();
-#ifdef AFS_SGI64_ENV
     rv = afs_lockedvnodeops.vop_write(a, b, c, d, f);
-#else
-    rv = afs_lockedvnodeops.vop_write(a, b, c, d);
-#endif
     AFS_GUNLOCK();
     return rv;
 }
 
 int
 mp_afs_ioctl(AFS_MP_VC_ARG(*a), int b, void *c, int d, struct cred *e, int *f
-#ifdef AFS_SGI65_ENV
             , struct vopbd *vbds
-#endif
     )
 {
     int rv;
     AFS_GLOCK();
     rv = afs_lockedvnodeops.vop_ioctl(a, b, c, d, e, f
-#ifdef AFS_SGI65_ENV
                                      , vbds
-#endif
        );
     AFS_GUNLOCK();
     return rv;
@@ -1490,17 +1171,11 @@ mp_afs_setattr(AFS_MP_VC_ARG(*a), struct vattr *b, int c, struct cred *d)
 
 int
 mp_afs_access(AFS_MP_VC_ARG(*a), int b,
-#ifndef AFS_SGI65_ENV
-             int c,
-#endif
              struct cred *d)
 {
     int rv;
     AFS_GLOCK();
     rv = afs_lockedvnodeops.vop_access(a, b,
-#ifndef AFS_SGI65_ENV
-                                      c,
-#endif
                                       d);
     AFS_GUNLOCK();
     return rv;
@@ -1517,15 +1192,9 @@ mp_afs_lookup(AFS_MP_VC_ARG(*a), char *b, vnode_t ** c, struct pathname *d,
     return rv;
 }
 
-#ifdef AFS_SGI64_ENV
 int
 mp_afs_create(AFS_MP_VC_ARG(*a), char *b, struct vattr *c, int d, int e,
              vnode_t ** f, struct cred *g)
-#else
-int
-mp_afs_create(AFS_MP_VC_ARG(*a), char *b, struct vattr *c, enum vcexcl d,
-             int e, vnode_t ** f, struct cred *g)
-#endif
 {
     int rv;
     AFS_GLOCK();
@@ -1619,17 +1288,13 @@ mp_afs_readlink(AFS_MP_VC_ARG(*a), struct uio *b, struct cred *c)
 
 int
 mp_afs_fsync(AFS_MP_VC_ARG(*a), int b, struct cred *c
-#ifdef AFS_SGI65_ENV
             , off_t start, off_t stop
-#endif
     )
 {
     int rv;
     AFS_GLOCK();
     rv = afs_lockedvnodeops.vop_fsync(a, b, c
-#ifdef AFS_SGI65_ENV
                                      , start, stop
-#endif
        );
     AFS_GUNLOCK();
     return rv;
@@ -1702,17 +1367,13 @@ mp_fs_cmp(AFS_MP_VC_ARG(*a), vnode_t * b)
 
 int
 mp_afs_frlock(AFS_MP_VC_ARG(*a), int b, struct flock *c, int d, off_t e,
-#ifdef AFS_SGI65_ENV
              vrwlock_t vrwlock,
-#endif
              struct cred *f)
 {
     int rv;
     AFS_GLOCK();
     rv = afs_lockedvnodeops.vop_frlock(a, b, c, d, e,
-#ifdef AFS_SGI65_ENV
                                       vrwlock,
-#endif
                                       f);
     AFS_GUNLOCK();
     return rv;
@@ -1749,66 +1410,28 @@ mp_afs_strategy(AFS_MP_VC_ARG(*a), struct buf *b)
     return;
 }
 
-#ifdef AFS_SGI65_ENV
 int
 mp_afs_map(AFS_MP_VC_ARG(*a), off_t b, size_t c, mprot_t d, u_int e,
           struct cred *f, vnode_t ** g)
-#else
-int
-mp_afs_map(AFS_MP_VC_ARG(*a), off_t b, struct pregion *c, char **d, size_t e,
-          u_int f, u_int g, u_int h, struct cred *i)
-#endif
 {
     int rv;
     AFS_GLOCK();
     rv = afs_lockedvnodeops.vop_map(a, b, c, d, e, f, g
-#ifndef AFS_SGI65_ENV
-                                   , h, i
-#endif
        );
     AFS_GUNLOCK();
     return rv;
 }
 
 
-#ifndef AFS_SGI65_ENV
-/* As of Irix 6.5, addmap and delmap are only for devices */
-int
-mp_afs_addmap(AFS_MP_VC_ARG(*a), off_t b, struct pregion *c, addr_t d,
-             size_t e, u_int f, u_int g, u_int h, struct cred *i)
-{
-    int rv;
-    AFS_GLOCK();
-    rv = afs_lockedvnodeops.vop_addmap(a, b, c, d, e, f, g, h, i);
-    AFS_GUNLOCK();
-    return rv;
-}
-
-int
-mp_afs_delmap(AFS_MP_VC_ARG(*a), off_t b, struct pregion *c, addr_t d,
-             size_t e, u_int f, u_int g, u_int h, struct cred *i)
-{
-    int rv;
-    AFS_GLOCK();
-    rv = afs_lockedvnodeops.vop_delmap(a, b, c, d, e, f, g, h, i);
-    AFS_GUNLOCK();
-    return rv;
-}
-#endif /* ! AFS_SGI65_ENV */
-
 int
 mp_fs_poll(AFS_MP_VC_ARG(*a), short b, int c, short *d, struct pollhead **e
-#ifdef AFS_SGI65_ENV
           , unsigned int *f
-#endif
     )
 {
     int rv;
     AFS_GLOCK();
     rv = afs_lockedvnodeops.vop_poll(a, b, c, d, e
-#ifdef AFS_SGI65_ENV
                                     , f
-#endif
        );
     AFS_GUNLOCK();
     return rv;
@@ -1816,13 +1439,7 @@ mp_fs_poll(AFS_MP_VC_ARG(*a), short b, int c, short *d, struct pollhead **e
 
 
 struct vnodeops Afs_vnodeops = {
-#ifdef AFS_SGI64_ENV
-#ifdef AFS_SGI65_ENV
     BHV_IDENTITY_INIT_POSITION(VNODE_POSITION_BASE),
-#else
-    VNODE_POSITION_BASE,
-#endif
-#endif
     mp_afs_open,
     mp_afs_close,
     mp_afs_read,
@@ -1855,13 +1472,8 @@ struct vnodeops Afs_vnodeops = {
     mp_afs_bmap,
     mp_afs_strategy,
     mp_afs_map,
-#ifdef AFS_SGI65_ENV
     fs_noerr,                  /* addmap - devices only */
     fs_noerr,                  /* delmap - devices only */
-#else
-    mp_afs_addmap,
-    mp_afs_delmap,
-#endif
     mp_fs_poll,                        /* poll */
     fs_nosys,                  /* dump */
     fs_pathconf,
@@ -1872,8 +1484,6 @@ struct vnodeops Afs_vnodeops = {
     fs_nosys,                  /* attr_set */
     fs_nosys,                  /* attr_remove */
     fs_nosys,                  /* attr_list */
-#ifdef AFS_SGI64_ENV
-#ifdef AFS_SGI65_ENV
     fs_cover,
     (vop_link_removed_t) fs_noval,
     fs_vnode_change,
@@ -1886,10 +1496,6 @@ struct vnodeops Afs_vnodeops = {
     (vop_readbuf_t) fs_nosys,
     fs_strgetmsg,
     fs_strputmsg,
-#else
-    fs_mount,
-#endif
-#endif
 };
 struct vnodeops *afs_ops = &Afs_vnodeops;
 #endif /* MP */
@@ -1949,4 +1555,3 @@ VnodeToSize(vnode_t * vp)
     }
     return vattr.va_size;
 }
-#endif /* AFS_SGI62_ENV */
index 8dd885b..042d781 100644 (file)
@@ -187,7 +187,7 @@ afs_AccessOK(struct vcache *avc, afs_int32 arights, struct vrequest *areq,
 }
 
 
-#if defined(AFS_SUN5_ENV) || (defined(AFS_SGI_ENV) && !defined(AFS_SGI65_ENV))
+#if defined(AFS_SUN5_ENV)
 int
 afs_access(OSI_VC_DECL(avc), afs_int32 amode, int flags,
           afs_ucred_t *acred)
index 3432508..6765e2b 100644 (file)
@@ -320,7 +320,7 @@ afs_getattr(OSI_VC_DECL(avc), struct vattr *attrs, afs_ucred_t *acred)
 # else
                        vp = vp->v_vfsp->vfs_vnodecovered;
                        if (vp) {       /* Ignore weird failures */
-#  ifdef AFS_SGI62_ENV
+#  ifdef AFS_SGI_ENV
                            attrs->va_nodeid = VnodeToIno(vp);
 #  else
                            struct inode *ip;
@@ -328,7 +328,7 @@ afs_getattr(OSI_VC_DECL(avc), struct vattr *attrs, afs_ucred_t *acred)
                            ip = (struct inode *)VTOI(vp);
                            if (ip)     /* Ignore weird failures */
                                attrs->va_nodeid = ip->i_number;
-#  endif /* AFS_SGI62_ENV */
+#  endif /* AFS_SGI_ENV */
                        }
 # endif /* AFS_DARWIN80_ENV */
                    }
index 2c07897..abd5684 100644 (file)
  * I think we can get away without it, but I'm not sure.  Note that
  * afs_setattr is called in here for truncation.
  */
-#ifdef AFS_SGI64_ENV
+#ifdef AFS_SGI_ENV
 int
 afs_create(OSI_VC_DECL(adp), char *aname, struct vattr *attrs, int flags,
           int amode, struct vcache **avcp, afs_ucred_t *acred)
-#else /* AFS_SGI64_ENV */
+#else /* AFS_SGI_ENV */
 int
 afs_create(OSI_VC_DECL(adp), char *aname, struct vattr *attrs,
           enum vcexcl aexcl, int amode, struct vcache **avcp,
           afs_ucred_t *acred)
-#endif                         /* AFS_SGI64_ENV */
+#endif                         /* AFS_SGI_ENV */
 {
     afs_int32 origCBs, origZaps, finalZaps;
     struct vrequest *treq = NULL;
@@ -74,7 +74,7 @@ afs_create(OSI_VC_DECL(adp), char *aname, struct vattr *attrs,
 
     afs_InitFakeStat(&fakestate);
 
-#ifdef AFS_SGI65_ENV
+#ifdef AFS_SGI_ENV
     /* If avcp is passed not null, it's the old reference to this file.
      * We can use this to avoid create races. For now, just decrement
      * the reference count on it.
@@ -165,7 +165,7 @@ afs_create(OSI_VC_DECL(adp), char *aname, struct vattr *attrs,
            ReleaseSharedLock(&tdc->lock);
            afs_PutDCache(tdc);
            ReleaseWriteLock(&adp->lock);
-#ifdef AFS_SGI64_ENV
+#ifdef AFS_SGI_ENV
            if (flags & VEXCL) {
 #else
            if (aexcl != NONEXCL) {
@@ -247,17 +247,15 @@ afs_create(OSI_VC_DECL(adp), char *aname, struct vattr *attrs,
                    ObtainWriteLock(&tvc->lock, 136);
                    tvc->f.states |= CCreating;
                    ReleaseWriteLock(&tvc->lock);
-#if defined(AFS_SUN5_ENV) || defined(AFS_SGI_ENV)
-#if defined(AFS_SGI64_ENV)
+#if defined(AFS_SGI_ENV)
                    code =
                        afs_setattr(VNODE_TO_FIRST_BHV((vnode_t *) tvc),
                                    attrs, 0, acred);
-#else
+#elif defined(AFS_SUN5_ENV)
                    code = afs_setattr(tvc, attrs, 0, acred);
-#endif /* AFS_SGI64_ENV */
-#else /* SUN5 || SGI */
+#else
                    code = afs_setattr(tvc, attrs, acred);
-#endif /* SUN5 || SGI */
+#endif
                    ObtainWriteLock(&tvc->lock, 137);
                    tvc->f.states &= ~CCreating;
                    ReleaseWriteLock(&tvc->lock);
@@ -336,9 +334,9 @@ afs_create(OSI_VC_DECL(adp), char *aname, struct vattr *attrs,
                  SHARED_LOCK, NULL));
 
        if ((code == EEXIST || code == UAEEXIST) &&
-#ifdef AFS_SGI64_ENV
+#ifdef AFS_SGI_ENV
        !(flags & VEXCL)
-#else /* AFS_SGI64_ENV */
+#else /* AFS_SGI_ENV */
        aexcl == NONEXCL
 #endif
        ) {
@@ -350,10 +348,10 @@ afs_create(OSI_VC_DECL(adp), char *aname, struct vattr *attrs,
            ReleaseWriteLock(&adp->lock);
 
 
-#if defined(AFS_SGI64_ENV)
+#if defined(AFS_SGI_ENV)
            code = afs_lookup(VNODE_TO_FIRST_BHV((vnode_t *) adp), aname, avcp,
                                  NULL, 0, NULL, acred);
-#elif defined(AFS_SUN5_ENV) || defined(AFS_SGI_ENV)
+#elif defined(AFS_SUN5_ENV)
            code = afs_lookup(adp, aname, avcp, NULL, 0, NULL, acred);
 #elif defined(UKERNEL)
            code = afs_lookup(adp, aname, avcp, acred, 0);
index 54e1956..ed435e4 100644 (file)
@@ -104,12 +104,12 @@ afs_fid(OSI_VC_DECL(avc), struct fid **fidpp)
        if (avc->f.fid.Fid.Unique > 0xffffff)
            afs_fid_uniqueoverflow++;
     } else {
-#if defined(AFS_SUN5_64BIT_ENV) || (defined(AFS_SGI61_ENV) && (_MIPS_SZPTR == 64))
+#if defined(AFS_SUN5_64BIT_ENV) || (defined(AFS_SGI_ENV) && (_MIPS_SZPTR == 64))
        addr[1] = (long)AFS_XLATOR_MAGIC << 48;
-#else /* defined(AFS_SGI61_ENV) && (_MIPS_SZPTR == 64) */
+#else /* defined(AFS_SGI_ENV) && (_MIPS_SZPTR == 64) */
        addr[1] = AFS_XLATOR_MAGIC;
        SizeOfSmallFid = sizeof(addr);
-#endif /* defined(AFS_SGI61_ENV) && (_MIPS_SZPTR == 64) */
+#endif /* defined(AFS_SGI_ENV) && (_MIPS_SZPTR == 64) */
        addr[0] = (long)avc;
 #ifndef AFS_AIX41_ENV
        /* No post processing, so don't hold ref count. */
index 45cc53f..8ef8600 100644 (file)
@@ -57,26 +57,14 @@ lockIdSet(struct AFS_FLOCK *flock, struct SimpleLocks *slp, int clid)
 void
 lockIdSet(struct AFS_FLOCK *flock, struct SimpleLocks *slp, int clid)
 {
-# if defined(AFS_SGI65_ENV)
     flid_t flid;
     get_current_flid(&flid);
-# else
-    afs_proc_t *procp = OSI_GET_CURRENT_PROCP();
-# endif
 
     if (slp) {
-# ifdef AFS_SGI65_ENV
        slp->sysid = flid.fl_sysid;
-# else
-       slp->sysid = OSI_GET_CURRENT_SYSID();
-# endif
        slp->pid = clid;
     } else {
-# ifdef AFS_SGI65_ENV
        flock->l_sysid = flid.fl_sysid;
-# else
-       flock->l_sysid = OSI_GET_CURRENT_SYSID();
-# endif
        flock->l_pid = clid;
     }
 }
@@ -173,14 +161,12 @@ lockIdcmp2(struct AFS_FLOCK *flock1, struct vcache *vp,
 #if    defined(AFS_SUN5_ENV)
     proc_t *procp = ttoproc(curthread);
 #else
-#if !defined(AFS_AIX41_ENV) && !defined(AFS_LINUX_ENV) && !defined(AFS_SGI65_ENV) && !defined(AFS_DARWIN_ENV) && !defined(AFS_XBSD_ENV)
-#ifdef AFS_SGI64_ENV
-    afs_proc_t *procp = curprocp;
-#elif defined(UKERNEL)
+#if !defined(AFS_AIX41_ENV) && !defined(AFS_LINUX_ENV) && !defined(AFS_SGI_ENV) && !defined(AFS_DARWIN_ENV) && !defined(AFS_XBSD_ENV)
+#if defined(UKERNEL)
     afs_proc_t *procp = get_user_struct()->u_procp;
 #else
     afs_proc_t *procp = u.u_procp;
-#endif /* AFS_SGI64_ENV */
+#endif /* UKERNEL */
 #endif
 #endif
 
@@ -194,7 +180,7 @@ lockIdcmp2(struct AFS_FLOCK *flock1, struct vcache *vp,
 #if defined(AFS_AIX41_ENV) || defined(AFS_LINUX_ENV) || defined(AFS_HPUX_ENV)
            (!onlymine && (flock1->l_pid == getppid()))
 #else
-#if defined(AFS_SGI65_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
+#if defined(AFS_SGI_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
            /* XXX check this. used to be *only* irix for some reason. */
            (!onlymine && (flock1->l_pid == clid))
 #else
index 43e2210..1ded555 100644 (file)
@@ -32,7 +32,7 @@
  * both called by the vn_open call.
  */
 int
-#ifdef AFS_SGI64_ENV
+#ifdef AFS_SGI_ENV
 afs_open(bhv_desc_t * bhv, struct vcache **avcp, afs_int32 aflags,
         afs_ucred_t *acred)
 #else
@@ -48,7 +48,7 @@ afs_open(struct vcache **avcp, afs_int32 aflags, afs_ucred_t *acred)
     AFS_STATCNT(afs_open);
     if ((code = afs_CreateReq(&treq, acred)))
        return code;
-#ifdef AFS_SGI64_ENV
+#ifdef AFS_SGI_ENV
     /* avcpp can be, but is not necesarily, bhp's vnode. */
     tvc = VTOAFS(BHV_TO_VNODE(bhv));
 #else
index 09b5762..320f04f 100644 (file)
@@ -138,14 +138,9 @@ struct irix5_min_dirent {  /* miniature dirent structure */
     afs_int32 d_off;
     u_short d_reclen;
 };
-#ifdef AFS_SGI62_ENV
 #define AFS_DIRENT32BASESIZE IRIX5_DIRENTBASESIZE
 #define AFS_DIRENT64BASESIZE DIRENT64BASESIZE
 #else
-#define AFS_DIRENT32BASESIZE IRIX5_DIRENTBASESIZE
-#define AFS_DIRENT64BASESIZE DIRENTBASESIZE
-#endif /* AFS_SGI62_ENV */
-#else
 struct min_direct {            /* miniature direct structure */
     /* If struct direct changes, this must too */
 #if defined(AFS_DARWIN80_ENV)
@@ -238,12 +233,7 @@ int afs_rd_stash_i = 0;
 #define DIRSIZ_LEN(len) \
     ((sizeof (struct dirent) - (MAXNAMLEN+1)) + (((len)+1 + 3) &~ 3))
 #else
-#if defined(AFS_SGI_ENV)
-#ifndef AFS_SGI53_ENV
-/* SGI 5.3 and later use 32/64 bit versions of directory size. */
-#define DIRSIZ_LEN(len)                DIRENTSIZE(len)
-#endif
-#else /* AFS_SGI_ENV */
+#ifndef AFS_SGI_ENV
 #define DIRSIZ_LEN(len) \
     ((sizeof (struct direct) - (MAXNAMLEN+1)) + (((len)+1 + 3) &~ 3))
 #endif /* AFS_SGI_ENV */
@@ -303,7 +293,7 @@ afs_readdir_type(struct vcache *avc, struct DirEntry *ade)
 #endif
 char bufofzeros[64];           /* gotta fill with something */
 
-#ifdef AFS_SGI65_ENV
+#ifdef AFS_SGI_ENV
 int
 afs_readdir_move(struct DirEntry *de, struct vcache *vc, struct uio *auio, 
                 int slen, ssize_t rlen, afs_size_t off)
@@ -324,10 +314,10 @@ afs_readdir_move(struct DirEntry *de, struct vcache *vc, struct uio *auio,
     struct dirent *direntp;
 #endif
 #endif /* AFS_SUN5_ENV */
-#ifndef        AFS_SGI53_ENV
+#ifndef        AFS_SGI_ENV
     struct min_direct sdirEntry;
     memset(&sdirEntry, 0, sizeof(sdirEntry));
-#endif /* AFS_SGI53_ENV */
+#endif /* AFS_SGI_ENV */
 
     AFS_STATCNT(afs_readdir_move);
 
@@ -403,27 +393,12 @@ afs_readdir_move(struct DirEntry *de, struct vcache *vc, struct uio *auio,
     }
 #endif
 
-#ifdef AFS_SGI53_ENV
+#ifdef AFS_SGI_ENV
     {
        afs_int32 use64BitDirent;
 
-#ifdef AFS_SGI61_ENV
-#ifdef AFS_SGI62_ENV
        use64BitDirent =
            ABI_IS(ABI_IRIX5_64, GETDENTS_ABI(OSI_GET_CURRENT_ABI(), auio));
-#else
-       use64BitDirent =
-           (auio->uio_segflg !=
-            UIO_USERSPACE) ? ABI_IRIX5_64 : (ABI_IS(ABI_IRIX5_64 |
-                                                    ABI_IRIX5_N32,
-                                                    u.u_procp->p_abi));
-#endif
-#else /* AFS_SGI61_ENV */
-       use64BitDirent =
-           (auio->uio_segflg !=
-            UIO_USERSPACE) ? ABI_IRIX5_64 : (ABI_IS(ABI_IRIX5_64,
-                                                    u.u_procp->p_abi));
-#endif /* AFS_SGI61_ENV */
 
        if (use64BitDirent) {
            struct min_dirent sdirEntry;
@@ -474,7 +449,7 @@ afs_readdir_move(struct DirEntry *de, struct vcache *vc, struct uio *auio,
            }
        }
     }
-#else /* AFS_SGI53_ENV */
+#else /* AFS_SGI_ENV */
 #if  defined(AFS_SUN5_ENV) || (defined(AFS_AIX51_ENV) && defined(AFS_64BIT_KERNEL))
     direntp = osi_AllocLargeSpace(AFS_LRALLOCSIZ);
     direntp->d_ino = afs_calc_inum(vc->f.fid.Cell, Volume, ntohl(Vnode));
@@ -557,7 +532,7 @@ afs_readdir_move(struct DirEntry *de, struct vcache *vc, struct uio *auio,
     }
 #endif
 #endif /* AFS_SUN5_ENV */
-#endif /* AFS_SGI53_ENV */
+#endif /* AFS_SGI_ENV */
     return (code);
 }
 
@@ -611,9 +586,9 @@ afs_readdir(OSI_VC_DECL(avc), struct uio *auio, afs_ucred_t *acred)
     int o_slen = 0, n_slen = 0;
     afs_int32 us;
     struct afs_fakestat_state fakestate;
-#if defined(AFS_SGI53_ENV)
+#if defined(AFS_SGI_ENV)
     afs_int32 use64BitDirent, dirsiz;
-#endif /* defined(AFS_SGI53_ENV) */
+#endif /* defined(AFS_SGI_ENV) */
 #ifndef        AFS_HPUX_ENV
     OSI_VC_CONVERT(avc);
 #else
@@ -637,24 +612,10 @@ afs_readdir(OSI_VC_DECL(avc), struct uio *auio, afs_ucred_t *acred)
     memset(&oldEntry, 0, sizeof(struct DirBuffer));
     memset(&nextEntry, 0, sizeof(struct DirBuffer));
 
-#if defined(AFS_SGI53_ENV)
-#ifdef AFS_SGI61_ENV
-#ifdef AFS_SGI62_ENV
+#if defined(AFS_SGI_ENV)
     use64BitDirent =
        ABI_IS(ABI_IRIX5_64, GETDENTS_ABI(OSI_GET_CURRENT_ABI(), auio));
-#else
-    use64BitDirent =
-       (auio->uio_segflg !=
-        UIO_USERSPACE) ? ABI_IRIX5_64 : (ABI_IS(ABI_IRIX5_64 | ABI_IRIX5_N32,
-                                                u.u_procp->p_abi));
-#endif /* AFS_SGI62_ENV */
-#else /* AFS_SGI61_ENV */
-    use64BitDirent =
-       (auio->uio_segflg !=
-        UIO_USERSPACE) ? ABI_IRIX5_64 : (ABI_IS(ABI_IRIX5_64,
-                                                u.u_procp->p_abi));
-#endif /* AFS_SGI61_ENV */
-#endif /* defined(AFS_SGI53_ENV) */
+#endif /* defined(AFS_SGI_ENV) */
 
 #if    defined(AFS_SUN5_ENV) || defined(AFS_SGI_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
     /* Not really used by the callee so we ignore it for now */
@@ -821,13 +782,13 @@ afs_readdir(OSI_VC_DECL(avc), struct uio *auio, afs_ucred_t *acred)
 #else
        n_slen = strlen(nde->name);
 #endif
-#ifdef AFS_SGI53_ENV
+#ifdef AFS_SGI_ENV
        dirsiz =
            use64BitDirent ? DIRENTSIZE(n_slen) : IRIX5_DIRENTSIZE(n_slen);
        if (dirsiz >= (AFS_UIO_RESID(auio) - len)) {
 #else
        if (DIRSIZ_LEN(n_slen) >= (AFS_UIO_RESID(auio) - len)) {
-#endif /* AFS_SGI53_ENV */
+#endif /* AFS_SGI_ENV */
            /* No can do no more now; ya know... at this time */
            DRelease(&nextEntry, 0);    /* can't use this one. */
            if (len) {
@@ -920,13 +881,13 @@ afs_readdir(OSI_VC_DECL(avc), struct uio *auio, afs_ucred_t *acred)
            code = afs_readdir_move(ode, avc, auio, o_slen, len, origOffset);
 #endif /* AFS_HPUX_ENV */
        }
-#ifdef AFS_SGI53_ENV
+#ifdef AFS_SGI_ENV
        len = use64BitDirent ? DIRENTSIZE(o_slen =
                                          n_slen) : IRIX5_DIRENTSIZE(o_slen =
                                                                     n_slen);
 #else
        len = DIRSIZ_LEN(o_slen = n_slen);
-#endif /* AFS_SGI53_ENV */
+#endif /* AFS_SGI_ENV */
        
        DRelease(&oldEntry, 0);
        oldEntry = nextEntry;
index 400b479..45c1d5a 100644 (file)
@@ -461,15 +461,9 @@ static int bkg_store_disabled = 0;
 
 /* handle any closing cleanup stuff */
 int
-#if defined(AFS_SGI65_ENV)
+#if defined(AFS_SGI_ENV)
 afs_close(OSI_VC_DECL(avc), afs_int32 aflags, lastclose_t lastclose,
          afs_ucred_t *acred)
-#elif defined(AFS_SGI64_ENV)
-afs_close(OSI_VC_DECL(avc), afs_int32 aflags, lastclose_t lastclose,
-         off_t offset, afs_ucred_t *acred, struct flid *flp)
-#elif defined(AFS_SGI_ENV)
-afs_close(OSI_VC_DECL(avc), afs_int32 aflags, lastclose_t lastclose
-         off_t offset, afs_ucred_t *acred)
 #elif defined(AFS_SUN5_ENV)
 afs_close(OSI_VC_DECL(avc), afs_int32 aflags, int count, offset_t offset, 
         afs_ucred_t *acred)
@@ -481,7 +475,7 @@ afs_close(OSI_VC_DECL(avc), afs_int32 aflags, afs_ucred_t *acred)
     afs_int32 code_checkcode = 0;
     struct brequest *tb;
     struct vrequest *treq = NULL;
-#ifdef AFS_SGI65_ENV
+#ifdef AFS_SGI_ENV
     struct flid flid;
 #endif
     struct afs_fakestat_state fakestat;
@@ -515,18 +509,9 @@ afs_close(OSI_VC_DECL(avc), afs_int32 aflags, afs_ucred_t *acred)
     }
     /* unlock any locks for pid - could be wrong for child .. */
     AFS_RWLOCK((vnode_t *) avc, VRWLOCK_WRITE);
-# ifdef AFS_SGI65_ENV
     get_current_flid(&flid);
     cleanlocks((vnode_t *) avc, flid.fl_pid, flid.fl_sysid);
     HandleFlock(avc, LOCK_UN, treq, flid.fl_pid, 1 /*onlymine */ );
-# else
-#  ifdef AFS_SGI64_ENV
-    cleanlocks((vnode_t *) avc, flp);
-#  else /* AFS_SGI64_ENV */
-    cleanlocks((vnode_t *) avc, u.u_procp->p_epid, u.u_procp->p_sysid);
-#  endif /* AFS_SGI64_ENV */
-    HandleFlock(avc, LOCK_UN, treq, OSI_GET_CURRENT_PID(), 1 /*onlymine */ );
-# endif /* AFS_SGI65_ENV */
     /* afs_chkpgoob will drop and re-acquire the global lock. */
     afs_chkpgoob(&avc->v, btoc(avc->f.m.Length));
 #elif defined(AFS_SUN5_ENV)
@@ -670,9 +655,9 @@ afs_close(OSI_VC_DECL(avc), afs_int32 aflags, afs_ucred_t *acred)
 int
 #if defined(AFS_SGI_ENV) || defined(AFS_SUN5_ENV)
 afs_fsync(OSI_VC_DECL(avc), int flag, afs_ucred_t *acred
-# ifdef AFS_SGI65_ENV
+# ifdef AFS_SGI_ENV
          , off_t start, off_t stop
-# endif /* AFS_SGI65_ENV */
+# endif /* AFS_SGI_ENV */
     )
 #else /* !SUN5 && !SGI */
 afs_fsync(OSI_VC_DECL(avc), afs_ucred_t *acred)
index 7d04d24..6109e94 100644 (file)
@@ -944,7 +944,7 @@ struct vcache {
 
 #if defined(AFS_LINUX_ENV)
     off_t next_seq_offset;     /* Next sequential offset (used by prefetch/readahead) */
-#elif defined(AFS_SUN5_ENV) || defined(AFS_SGI65_ENV)
+#elif defined(AFS_SUN5_ENV) || defined(AFS_SGI_ENV)
     off_t next_seq_blk_offset; /* accounted in blocks for Solaris & IRIX */
 #endif
 
@@ -956,18 +956,12 @@ struct vcache {
     unsigned int readdir_pid;   /* pid of the thread in readdir */
 #if defined(AFS_SGI_ENV)
     daddr_t lastr;             /* for read-ahead */
-#ifdef AFS_SGI64_ENV
     uint64_t vc_rwlockid;      /* kthread owning rwlock */
-#else
-    short vc_rwlockid;         /* pid of process owning rwlock */
-#endif
     short vc_locktrips;                /* # of rwlock reacquisitions */
     sema_t vc_rwlock;          /* vop_rwlock for afs */
     pgno_t mapcnt;             /* # of pages mapped */
     struct cred *cred;         /* last writer's cred */
-#ifdef AFS_SGI64_ENV
     struct bhv_desc vc_bhv_desc;       /* vnode's behavior data. */
-#endif
 #endif                         /* AFS_SGI_ENV */
 #if defined(AFS_LINUX_ENV) || defined(AFS_FBSD_ENV)
     afs_ucred_t *cred;         /* last writer's cred */
@@ -1011,35 +1005,13 @@ struct pagewriter {
 #if defined(AFS_SGI_ENV)
 #define AVCRWLOCK(avc)         (valusema(&(avc)->vc_rwlock) <= 0)
 
-/* SGI vnode rwlock macros and flags. */
-#ifndef AFS_SGI62_ENV
-/* The following are defined here. SGI 6.2 declares them in vnode.h */
-#define VRWLOCK_READ           0
-#define VRWLOCK_WRITE          1
-#define VRWLOCK_WRITE_DIRECT   2
-#endif
-
-#ifdef AFS_SGI53_ENV
-#ifdef AFS_SGI62_ENV
 #define AFS_RWLOCK_T vrwlock_t
-#else
-#define AFS_RWLOCK_T int
-#endif /* AFS_SGI62_ENV */
-#ifdef AFS_SGI64_ENV
 #include <ksys/behavior.h>
 #define AFS_RWLOCK(V,F) \
        afs_rwlock(&VTOAFS(V)->vc_bhv_desc, (F));
 #define AFS_RWUNLOCK(V,F) \
        afs_rwunlock(&VTOAFS(V)->vc_bhv_desc, (F));
 
-#else
-#define AFS_RWLOCK(V,F) afs_rwlock((vnode_t *)(V), (F) )
-#define AFS_RWUNLOCK(V,F) afs_rwunlock((vnode_t *)(V), (F) )
-#endif
-#else /* AFS_SGI53_ENV */
-#define AFS_RWLOCK(V,F) afs_rwlock((V))
-#define AFS_RWUNLOCK(V,F) afs_rwunlock((V))
-#endif /* AFS_SGI53_ENV */
 #endif /* AFS_SGI_ENV */
 
 struct vcxstat {
@@ -1142,7 +1114,7 @@ typedef user_addr_t iparmtype; /* 64 bit */
 typedef user_addr_t uparmtype; /* 64 bit */
 #else
 typedef char * uparmtype;
-#ifdef AFS_SGI65_ENV
+#ifdef AFS_SGI_ENV
 typedef afs_uint32 iparmtype;
 #else
 typedef long iparmtype;
@@ -1197,7 +1169,7 @@ struct afs_fheader {
 
 #if defined(AFS_CACHE_VNODE_PATH)
 typedef char *afs_ufs_dcache_id_t;
-#elif defined(AFS_SGI61_ENV) || defined(AFS_SUN5_64BIT_ENV)
+#elif defined(AFS_SGI_ENV) || defined(AFS_SUN5_64BIT_ENV)
 /* Using ino64_t here so that user level debugging programs compile
  * the size correctly.
  */
@@ -1480,16 +1452,16 @@ extern struct brequest afs_brs[NBRS];   /* request structures */
 
 /* get a file's serial number from a vnode */
 #ifndef afs_vnodeToInumber
-#if defined(AFS_SGI62_ENV) || defined(AFS_HAVE_VXFS) || defined(AFS_DARWIN_ENV)
+#if defined(AFS_SGI_ENV) || defined(AFS_HAVE_VXFS) || defined(AFS_DARWIN_ENV)
 #define afs_vnodeToInumber(V) VnodeToIno(V)
 #else
 #define afs_vnodeToInumber(V) (VTOI(V)->i_number)
-#endif /* AFS_SGI62_ENV */
+#endif /* AFS_SGI_ENV */
 #endif
 
 /* get a file's device number from a vnode */
 #ifndef afs_vnodeToDev
-#if defined(AFS_SGI62_ENV) || defined(AFS_HAVE_VXFS) || defined(AFS_DARWIN_ENV)
+#if defined(AFS_SGI_ENV) || defined(AFS_HAVE_VXFS) || defined(AFS_DARWIN_ENV)
 #define afs_vnodeToDev(V) VnodeToDev(V)
 #elif defined(UKERNEL)
 #define afs_vnodeToDev(V) (VTOI(V) ? (VTOI(V)->i_dev) : (-1))
index 0ccf711..4f06a5c 100644 (file)
@@ -23,7 +23,7 @@
 #include <netinet/in.h>
 #endif
 
-#ifdef AFS_SGI62_ENV
+#ifdef AFS_SGI_ENV
 #include "h/hashing.h"
 #endif
 #if !defined(AFS_HPUX110_ENV) && !defined(AFS_LINUX_ENV) && !defined(AFS_FBSD_ENV) && !defined(AFS_DARWIN_ENV)
index b99a286..928afdc 100644 (file)
@@ -21,7 +21,7 @@
 #if !defined(UKERNEL)
 # if !defined(AFS_LINUX_ENV)
 #  include "net/if.h"
-#  ifdef AFS_SGI62_ENV
+#  ifdef AFS_SGI_ENV
 #   include "h/hashing.h"
 #  endif
 #  if !defined(AFS_HPUX110_ENV) && !defined(AFS_DARWIN_ENV)
@@ -897,11 +897,11 @@ afs_syscall_call(long parm, long parm2, long parm3,
 #endif
 {
     afs_int32 code = 0;
-#if defined(AFS_SGI61_ENV) || defined(AFS_SUN5_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
+#if defined(AFS_SGI_ENV) || defined(AFS_SUN5_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
     size_t bufferSize;
-#else /* AFS_SGI61_ENV */
+#else /* AFS_SGI_ENV */
     u_int bufferSize;
-#endif /* AFS_SGI61_ENV */
+#endif /* AFS_SGI_ENV */
 #ifdef AFS_DARWIN100_ENV
     /* AFSKPTR macro relies on this name format/mapping */
     afs_uint32 parm = (afs_uint32)kparm;
@@ -1290,7 +1290,7 @@ afs_syscall_call(long parm, long parm2, long parm3,
        get_vfs_context();
 #endif
        /* do it by inode */
-#ifdef AFS_SGI62_ENV
+#ifdef AFS_SGI_ENV
        ainode = (ainode << 32) | (parm3 & 0xffffffff);
 #endif
        code = afs_InitCacheFile(NULL, ainode);
index 668190a..d7e6761 100644 (file)
@@ -23,7 +23,7 @@
 #endif
 #include <netinet/in.h>
 
-#ifdef AFS_SGI62_ENV
+#ifdef AFS_SGI_ENV
 #include "h/hashing.h"
 #endif
 #if !defined(AFS_HPUX110_ENV) && !defined(AFS_LINUX_ENV) && !defined(AFS_DARWIN_ENV)
index 73b6a9d..fe41dfd 100644 (file)
@@ -2280,13 +2280,8 @@ afs_GetDCache(struct vcache *avc, afs_size_t abyte,
     if (doAdjustSize || overWriteWholeChunk) {
 #if    defined(AFS_AIX32_ENV) || defined(AFS_SGI_ENV)
 #ifdef AFS_SGI_ENV
-#ifdef AFS_SGI64_ENV
        if (doAdjustSize)
            adjustsize = NBPP;
-#else /* AFS_SGI64_ENV */
-       if (doAdjustSize)
-           adjustsize = 8192;
-#endif /* AFS_SGI64_ENV */
 #else /* AFS_SGI_ENV */
        if (doAdjustSize)
            adjustsize = 4096;
index 24cc3e9..7bb51a0 100644 (file)
@@ -23,7 +23,7 @@
 #include <netinet/in.h>
 #endif
 
-#ifdef AFS_SGI62_ENV
+#ifdef AFS_SGI_ENV
 #include "h/hashing.h"
 #endif
 #if !defined(AFS_HPUX110_ENV) && !defined(AFS_LINUX_ENV) && !defined(AFS_FBSD_ENV) && !defined(AFS_DARWIN_ENV)
index 8432b88..2cf15e2 100644 (file)
@@ -17,7 +17,7 @@
 #include "rx/rx_globals.h"
 #if !defined(UKERNEL) && !defined(AFS_LINUX_ENV)
 #include "net/if.h"
-#ifdef AFS_SGI62_ENV
+#ifdef AFS_SGI_ENV
 #include "h/hashing.h"
 #endif
 #if !defined(AFS_HPUX110_ENV) && !defined(AFS_DARWIN_ENV)
@@ -120,15 +120,15 @@ Afscall_icl(long opcode, long p1, long p2, long p3, long p4, long *retval)
     afs_int32 code;
     struct afs_icl_log *logp;
     struct afs_icl_set *setp;
-#if defined(AFS_SGI61_ENV) || defined(AFS_SUN5_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
+#if defined(AFS_SGI_ENV) || defined(AFS_SUN5_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
     size_t temp;
-#else /* AFS_SGI61_ENV */
+#else /* AFS_SGI_ENV */
 #if defined(AFS_AIX51_ENV) && defined(AFS_64BIT_KERNEL)
     afs_uint64 temp;
 #else
     afs_uint32 temp;
 #endif
-#endif /* AFS_SGI61_ENV */
+#endif /* AFS_SGI_ENV */
     char tname[65];
     afs_int32 startCookie;
     afs_int32 allocated;
index 4d1984c..066ca30 100644 (file)
@@ -413,12 +413,8 @@ afs_InitCacheInfo(char *afile)
 # endif /* AFS_SUN5_ENV */
 
 # if defined(AFS_SGI_ENV)
-#  ifdef AFS_SGI65_ENV
        VFS_STATVFS(filevp->v_vfsp, &st, NULL, code);
        if (!code)
-#  else
-       if (!VFS_STATFS(filevp->v_vfsp, &st, NULL))
-#  endif /* AFS_SGI65_ENV */
 # elif defined(AFS_SUN5_ENV) || defined(AFS_HPUX100_ENV)
        if (!VFS_STATVFS(filevp->v_vfsp, &st))
 # elif defined(AFS_AIX41_ENV)
index b11e6dc..1a634e8 100644 (file)
@@ -31,11 +31,8 @@ extern void init_hckernel_mutex(void);
 
 afs_lock_t afs_ftf;            /* flush text lock */
 
-#ifdef AFS_SGI53_ENV
+#ifdef AFS_SGI_ENV
 lock_t afs_event_lock;
-#endif
-
-#ifdef AFS_SGI64_ENV
 flid_t osi_flid;
 #endif
 
@@ -45,10 +42,6 @@ afs_ucred_t *afs_osi_credp;
 kmutex_t afs_global_lock;
 #endif
 
-#if defined(AFS_SGI_ENV) && !defined(AFS_SGI64_ENV)
-long afs_global_owner;
-#endif
-
 #if defined(AFS_DARWIN_ENV)
 thread_t afs_global_owner;
 #ifdef AFS_DARWIN80_ENV
@@ -118,7 +111,7 @@ osi_Init(void)
 #endif
        afs_osicred_initialized = 1;
     }
-#ifdef AFS_SGI64_ENV
+#ifdef AFS_SGI_ENV
     osi_flid.fl_pid = osi_flid.fl_sysid = 0;
 #endif
 
index f8a6316..17f301e 100644 (file)
@@ -167,7 +167,7 @@ extern int osi_vnhold(struct vcache *);
  * Is DEBUG only for turning the ASSERT() macro?  If so, we should
  * be able to eliminate DEBUG entirely.
  */
-#if !defined(AFS_SGI65_ENV) && !defined(AFS_NBSD_ENV)
+#if !defined(AFS_SGI_ENV) && !defined(AFS_NBSD_ENV)
 #ifndef        DEBUG
 #define        DEBUG   1               /* Default is to enable debugging/logging */
 #endif
index f29fea6..162735b 100644 (file)
@@ -206,10 +206,10 @@ afs_setpag(void)
 
     int code = 0;
 
-#if defined(AFS_SGI53_ENV) && defined(MP)
+#if defined(AFS_SGI_ENV) && defined(MP)
     /* This is our first chance to get the global lock. */
     AFS_GLOCK();
-#endif /* defined(AFS_SGI53_ENV) && defined(MP) */
+#endif /* defined(AFS_SGI_ENV) && defined(MP) */
 
     AFS_STATCNT(afs_setpag);
 
@@ -283,9 +283,9 @@ afs_setpag(void)
        setuerror(code);
 #endif
 
-#if defined(AFS_SGI53_ENV) && defined(MP)
+#if defined(AFS_SGI_ENV) && defined(MP)
     AFS_GUNLOCK();
-#endif /* defined(AFS_SGI53_ENV) && defined(MP) */
+#endif /* defined(AFS_SGI_ENV) && defined(MP) */
 
     return (code);
 }
@@ -320,10 +320,10 @@ afs_setpag_val(int pagval)
 
     int code = 0;
 
-#if defined(AFS_SGI53_ENV) && defined(MP)
+#if defined(AFS_SGI_ENV) && defined(MP)
     /* This is our first chance to get the global lock. */
     AFS_GLOCK();
-#endif /* defined(AFS_SGI53_ENV) && defined(MP) */
+#endif /* defined(AFS_SGI_ENV) && defined(MP) */
 
     AFS_STATCNT(afs_setpag);
 
@@ -386,9 +386,9 @@ afs_setpag_val(int pagval)
     if (!getuerror())
        setuerror(code);
 #endif
-#if defined(AFS_SGI53_ENV) && defined(MP)
+#if defined(AFS_SGI_ENV) && defined(MP)
     AFS_GUNLOCK();
-#endif /* defined(AFS_SGI53_ENV) && defined(MP) */
+#endif /* defined(AFS_SGI_ENV) && defined(MP) */
     return (code);
 }
 
index 66c7f12..9f0b257 100644 (file)
@@ -630,13 +630,8 @@ kioctl(int fdes, int com, caddr_t arg, caddr_t ext)
 # endif
 
 #elif defined(AFS_SGI_ENV)
-# if defined(AFS_SGI65_ENV)
 afs_ioctl(OSI_VN_DECL(tvc), int cmd, void *arg, int flag, cred_t * cr,
          rval_t * rvalp, struct vopbd * vbds)
-# else
-afs_ioctl(OSI_VN_DECL(tvc), int cmd, void *arg, int flag, cred_t * cr,
-         rval_t * rvalp, struct vopbd * vbds)
-# endif
 {
     struct afs_ioctl data;
     int error = 0;
@@ -966,11 +961,7 @@ afs_pioctl(struct pioctlargs *uap, rval_t * rvp)
     AFS_GLOCK();
     code = afs_syscall_pioctl(uap->path, uap->cmd, uap->cmarg, uap->follow);
     AFS_GUNLOCK();
-# ifdef AFS_SGI64_ENV
     return code;
-# else
-    return u.u_error;
-# endif
 }
 
 #elif defined(AFS_FBSD_ENV)
@@ -2784,7 +2775,7 @@ Prefetch(uparmtype apath, struct afs_ioctl *adata, int afollow,
 {
     char *tp;
     afs_int32 code;
-#if defined(AFS_SGI61_ENV) || defined(AFS_SUN5_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
+#if defined(AFS_SGI_ENV) || defined(AFS_SUN5_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
     size_t bufferSize;
 #else
     u_int bufferSize;
@@ -4508,7 +4499,7 @@ DECL_PIOCTL(PGetInitParams)
                           sizeof(struct cm_initparams));
 }
 
-#ifdef AFS_SGI65_ENV
+#ifdef AFS_SGI_ENV
 /* They took crget() from us, so fake it. */
 static cred_t *
 crget(void)
@@ -4634,10 +4625,6 @@ HandleClientContext(struct afs_ioctl *ablob, int *com,
      */
     i = (*com) & 0xff;
     if (!afs_osi_suser(credp)) {
-#if defined(AFS_SGI_ENV) && !defined(AFS_SGI64_ENV)
-       /* Since SGI's suser() returns explicit failure after the call.. */
-       u.u_error = 0;
-#endif
        /* check for acceptable opcodes for normal folks, which are, so far,
         * get/set tokens, sysname, and unlog.
         */
index 60be3f4..51a5360 100644 (file)
@@ -648,7 +648,7 @@ extern int afs_syscall_icreate(dev_t, long, long, long, long, long,
 extern int afs_syscall_iopen(dev_t, int, int, rval_t *, afs_ucred_t *);
 extern int afs_syscall_iincdec(dev_t, int, int, int, rval_t *,
                               afs_ucred_t *);
-#elif defined(AFS_SGI65_ENV)
+#elif defined(AFS_SGI_ENV)
 extern int afs_syscall_icreate(afs_uint32, afs_uint32, afs_uint32, afs_uint32, afs_uint32, afs_uint32, rval_t *);
 extern int afs_syscall_iopen(int, ino_t, int, rval_t *);
 extern int afs_syscall_iincdec(int, int, int, int);
@@ -1135,7 +1135,7 @@ extern afs_int32 afs_GetAccessBits(struct vcache *avc,
                                   struct vrequest *areq);
 extern int afs_AccessOK(struct vcache *avc, afs_int32 arights,
                        struct vrequest *areq, afs_int32 check_mode_bits);
-#if defined(AFS_SUN5_ENV) || (defined(AFS_SGI_ENV) && !defined(AFS_SGI65_ENV))
+#if defined(AFS_SUN5_ENV)
 extern int afs_access(OSI_VC_DECL(avc), afs_int32 amode, int flags,
                      afs_ucred_t *acred);
 #else
@@ -1169,15 +1169,15 @@ extern int afs_CreateAttr(struct vattr **out);
 extern void afs_DestroyAttr(struct vattr *vattr);
 
 /* VNOPS/afs_vnop_create.c */
-#ifdef AFS_SGI64_ENV
+#ifdef AFS_SGI_ENV
 extern int afs_create(OSI_VC_DECL(adp), char *aname, struct vattr *attrs,
                      int flags, int amode, struct vcache **avcp,
                      afs_ucred_t *acred);
-#else /* AFS_SGI64_ENV */
+#else /* AFS_SGI_ENV */
 extern int afs_create(OSI_VC_DECL(adp), char *aname, struct vattr *attrs,
                      enum vcexcl aexcl, int amode, struct vcache **avcp,
                      afs_ucred_t *acred);
-#endif /* AFS_SGI64_ENV */
+#endif /* AFS_SGI_ENV */
 extern int afs_LocalHero(struct vcache *avc,
                         struct dcache *adc,
                         AFSFetchStatus * astat, int aincr);
@@ -1259,7 +1259,7 @@ extern int afs_lookup(OSI_VC_DECL(adp), char *aname, struct vcache **avcp,
 #endif
 
 /* VNOPS/afs_vnop_open.c */
-#ifdef AFS_SGI64_ENV
+#ifdef AFS_SGI_ENV
 extern int afs_open(bhv_desc_t * bhv, struct vcache **avcp, afs_int32 aflags,
                    afs_ucred_t *acred);
 #else
@@ -1342,17 +1342,9 @@ extern int afs_DoPartialWrite(struct vcache *avc,
                              struct vrequest *areq);
 extern int afs_closex(struct file *afd);
 
-#ifdef AFS_SGI65_ENV
+#ifdef AFS_SGI_ENV
 extern int afs_close(OSI_VC_DECL(avc), afs_int32 aflags,
                     lastclose_t lastclose, afs_ucred_t *acred);
-#elif defined(AFS_SGI64_ENV)
-extern int afs_close(OSI_VC_DECL(avc), afs_int32 aflags,
-                    lastclose_t lastclose, off_t offset,
-                    afs_ucred_t *acred, struct flid *flp);
-#elif defined(AFS_SGI_ENV)
-extern int afs_close(OSI_VC_DECL(avc), afs_int32 aflags,
-                    lastclose_t lastclose, off_t offset,
-                    afs_ucred_t *acred);
 #elif defined(AFS_SUN5_ENV)
 extern int afs_close(OSI_VC_DECL(avc), afs_int32 aflags, int count,
                     offset_t offset, afs_ucred_t *acred);
@@ -1361,10 +1353,10 @@ extern int afs_close(OSI_VC_DECL(avc), afs_int32 aflags,
                     afs_ucred_t *acred);
 #endif
 
-#if defined(AFS_SGI65_ENV)
+#if defined(AFS_SGI_ENV)
 extern int afs_fsync(OSI_VC_DECL(avc), int flags, afs_ucred_t *acred,
                     off_t start, off_t stop);
-#elif defined(AFS_SGI_ENV) || defined(AFS_SUN5_ENV)
+#elif defined(AFS_SUN5_ENV)
 extern int afs_fsync(OSI_VC_DECL(avc), int flag, afs_ucred_t *acred);
 #else
 extern int afs_fsync(OSI_VC_DECL(avc), afs_ucred_t *acred);
@@ -1411,7 +1403,7 @@ extern void afs_ntohuuid(afsUUID * uuidp);
 extern afs_int32 afs_uuid_create(afsUUID * uuid);
 extern u_short afs_uuid_hash(afsUUID * uuid);
 
-#if defined(AFS_SUN5_ENV) || defined(AFS_LINUX_ENV) || defined(AFS_AIX_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV) || defined(AFS_HPUX_ENV) || defined(AFS_SGI62_ENV) || defined(UKERNEL)
+#if defined(AFS_SUN5_ENV) || defined(AFS_LINUX_ENV) || defined(AFS_AIX_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV) || defined(AFS_HPUX_ENV) || defined(AFS_SGI_ENV) || defined(UKERNEL)
 #include "osi_prototypes.h"
 #endif
 
index 2d79ef5..db66d8b 100644 (file)
@@ -180,7 +180,7 @@ afs_StoreAllSegments(struct vcache *avc, struct vrequest *areq,
     dcList = osi_AllocLargeSpace(AFS_LRALLOCSIZ);
     afs_Trace2(afs_iclSetp, CM_TRACE_STOREALL, ICL_TYPE_POINTER, avc,
               ICL_TYPE_OFFSET, ICL_HANDLE_OFFSET(avc->f.m.Length));
-#if !defined(AFS_AIX32_ENV) && !defined(AFS_SGI65_ENV)
+#if !defined(AFS_AIX32_ENV) && !defined(AFS_SGI_ENV)
     /* In the aix vm implementation we need to do the vm_writep even
      * on the memcache case since that's we adjust the file's size
      * and finish flushing partial vm pages.
@@ -191,7 +191,7 @@ afs_StoreAllSegments(struct vcache *avc, struct vrequest *areq,
     } else if ((cacheDiskType != AFS_FCACHE_TYPE_MEM) ||
        (sync & AFS_VMSYNC_INVAL) || (sync & AFS_VMSYNC) ||
        (sync & AFS_LASTSTORE))
-#endif /* !AFS_AIX32_ENV && !AFS_SGI65_ENV */
+#endif /* !AFS_AIX32_ENV && !AFS_SGI_ENV */
     {
        /* If we're not diskless, reading a file may stress the VM
         * system enough to cause a pageout, and this vnode would be
index 27c06f3..71cfef2 100644 (file)
@@ -42,7 +42,7 @@
 # endif
 # include <netinet/in.h>
 
-# ifdef AFS_SGI62_ENV
+# ifdef AFS_SGI_ENV
 #  include "h/hashing.h"
 # endif
 # if !defined(AFS_HPUX110_ENV) && !defined(AFS_LINUX_ENV) && !defined(AFS_DARWIN_ENV)
@@ -1155,7 +1155,7 @@ afsi_SetServerIPRank(struct srvAddr *sa, rx_ifaddr_t ifa)
 # endif /* (DARWIN || OBSD47 || FBSD) && USEIFADDR */
 #endif /* AFS_USERSPACE_IP_ADDR */
 
-#ifdef AFS_SGI62_ENV
+#ifdef AFS_SGI_ENV
 static int
 afsi_enum_set_rank(struct hashbucket *h, caddr_t mkey, caddr_t arg1,
                   caddr_t arg2)
@@ -1163,7 +1163,7 @@ afsi_enum_set_rank(struct hashbucket *h, caddr_t mkey, caddr_t arg1,
     afsi_SetServerIPRank((struct srvAddr *)arg1, (struct in_ifaddr *)h);
     return 0;                  /* Never match, so we enumerate everyone */
 }
-#endif                         /* AFS_SGI62_ENV */
+#endif                         /* AFS_SGI_ENV */
 static int
 afs_SetServerPrefs(struct srvAddr *const sa)
 {
@@ -1329,7 +1329,7 @@ afs_SetServerPrefs(struct srvAddr *const sa)
 #  else /* USEIFADDR */
 
     sa->sa_iprank = LO;
-#   ifdef AFS_SGI62_ENV
+#   ifdef AFS_SGI_ENV
     (void)hash_enum(&hashinfo_inaddr, afsi_enum_set_rank, HTF_INET, NULL,
                    (caddr_t) sa, NULL);
 #   elif defined(AFS_DARWIN80_ENV)
index ebb0d14..03a70da 100644 (file)
@@ -21,7 +21,7 @@
 #include "rx/rx_globals.h"
 #if !defined(UKERNEL) && !defined(AFS_LINUX_ENV)
 #include "net/if.h"
-#ifdef AFS_SGI62_ENV
+#ifdef AFS_SGI_ENV
 #include "h/hashing.h"
 #endif
 #if !defined(AFS_HPUX110_ENV) && !defined(AFS_DARWIN_ENV)
index 8afc01d..23cd454 100644 (file)
@@ -23,7 +23,7 @@
 #endif
 #include <netinet/in.h>
 
-#ifdef AFS_SGI62_ENV
+#ifdef AFS_SGI_ENV
 #include "h/hashing.h"
 #endif
 #if !defined(AFS_HPUX110_ENV) && !defined(AFS_LINUX_ENV) && !defined(AFS_DARWIN_ENV)
index c20a1c8..0d8d2c1 100644 (file)
@@ -25,7 +25,7 @@
 #endif
 #include <netinet/in.h>
 
-#ifdef AFS_SGI62_ENV
+#ifdef AFS_SGI_ENV
 #include "h/hashing.h"
 #endif
 #if !defined(AFS_HPUX110_ENV) && !defined(AFS_LINUX_ENV) && !defined(AFS_DARWIN_ENV)
index aff7faf..3e991a7 100644 (file)
@@ -52,9 +52,9 @@ afs_int32 afs_vcount = 0;     /* number of vcache in use now */
 int afsvnumbers = 0;
 #endif
 
-#ifdef AFS_SGI64_ENV
+#ifdef AFS_SGI_ENV
 char *makesname();
-#endif /* AFS_SGI64_ENV */
+#endif /* AFS_SGI_ENV */
 
 /* Exported variables */
 afs_rwlock_t afs_xvcdirty;     /*Lock: discon vcache dirty list mgmt */
@@ -2918,12 +2918,6 @@ afs_vcacheInit(int astatSize)
        tvc->vc_rwlockid = OSI_NO_LOCKID;
        initnsema(&tvc->vc_rwlock, 1,
                  makesname(name, "vrw", tvc->v.v_number));
-# ifndef       AFS_SGI53_ENV
-       initnsema(&tvc->v.v_sync, 0, makesname(name, "vsy", tvc->v.v_number));
-# endif
-# ifndef AFS_SGI62_ENV
-       initnlock(&tvc->v.v_lock, makesname(name, "vlk", tvc->v.v_number));
-# endif /* AFS_SGI62_ENV */
     }
 #endif
     QInit(&VLRU);
index 1f4a7b6..1faeef1 100644 (file)
@@ -28,7 +28,7 @@
 #endif
 #include <netinet/in.h>
 
-#ifdef AFS_SGI62_ENV
+#ifdef AFS_SGI_ENV
 #include "h/hashing.h"
 #endif
 #if !defined(AFS_HPUX110_ENV) && !defined(AFS_LINUX_ENV) && !defined(AFS_DARWIN_ENV)
index 074e53f..07d044c 100644 (file)
@@ -33,7 +33,7 @@
 #endif
 #include <netinet/in.h>
 
-#ifdef AFS_SGI62_ENV
+#ifdef AFS_SGI_ENV
 #include "h/hashing.h"
 #endif
 #if !defined(AFS_HPUX110_ENV) && !defined(AFS_LINUX_ENV) && !defined(AFS_DARWIN_ENV)
index c6ba0c6..237bc6c 100644 (file)
@@ -34,7 +34,7 @@
   * up 2 bytes
   */
 
-#if defined(AFS_SUN5_64BIT_ENV) || (defined(AFS_SGI61_ENV) && (_MIPS_SZPTR==64)) || defined(AFS_LINUX_64BIT_KERNEL)
+#if defined(AFS_SUN5_64BIT_ENV) || (defined(AFS_SGI_ENV) && (_MIPS_SZPTR==64)) || defined(AFS_LINUX_64BIT_KERNEL)
 #define        AFS_XLATOR_MAGIC        0x8765  /* XXX */
 #else
 #define        AFS_XLATOR_MAGIC        0x87654321
index cedd1d6..2ec077a 100644 (file)
@@ -69,16 +69,10 @@ typedef afs_proc_t * afs_lock_tracker_t;
 #  define MyPidxx (u.u_procp)
 #  define MyPidxx2Pid(x) (x ? (afs_int32)p_pid(x) : 0)
 # endif
-#elif defined(AFS_SGI64_ENV)
-# if defined(AFS_SGI65_ENV)
+#elif defined(AFS_SGI_ENV)
 typedef unsigned int afs_lock_tracker_t;
-#  define MyPidxx proc_pid(curproc())
-#  define MyPidxx2Pid(x) (x)
-# else
-typedef unsigned int afs_lock_tracker_t;
-#  define MyPidxx current_pid()
-#  define MyPidxx2Pid(x) (x)
-# endif
+# define MyPidxx proc_pid(curproc())
+# define MyPidxx2Pid(x) (x)
 #elif defined(AFS_LINUX_ENV)
 typedef struct task_struct * afs_lock_tracker_t;
 # define MyPidxx (current)
index bea5aab..9b3c6ce 100644 (file)
@@ -223,15 +223,13 @@ struct xfs_inode_info {
 #  include "values.h"
 #  include "sys/sema.h"
 #  include "sys/cmn_err.h"
-#  ifdef AFS_SGI64_ENV
-#   include <ksys/behavior.h>
+#  include <ksys/behavior.h>
 /* in 6.5.20f, ksys/behavior.h doesn't bother to define BHV_IS_BHVL,
  * but sys/vnode.h uses it in VNODE_TO_FIRST_BHV. It looks like from
  * older headers like we want the old behavior, so we fake it. */
-#   if defined(BHV_PREPARE) && !defined(CELL_CAPABLE)
-#    define BHV_IS_BHVL(bhp) (0)
-#   endif
-#  endif /* AFS_SGI64_ENV */
+#  if defined(BHV_PREPARE) && !defined(CELL_CAPABLE)
+#   define BHV_IS_BHVL(bhp) (0)
+#  endif
 #  include "fs/efs_inode.h"
 #  include "sys/kmem.h"
 #  include "sys/cred.h"
@@ -246,7 +244,7 @@ struct xfs_inode_info {
  *
  * Instead of using ASSERT(), we use our own osi_Assert().
  */
-#  if defined(AFS_SGI65_ENV) && !defined(DEBUG)
+#  if !defined(DEBUG)
 #   define DEBUG
 #   include "sys/debug.h"
 #   undef DEBUG
@@ -300,10 +298,10 @@ struct xfs_inode_info {
 #  include "h/dir.h"
 # endif /* SGI || SUN || HPUX */
 
-# if !defined(AFS_SGI64_ENV) && !defined(AFS_FBSD_ENV) && !defined(AFS_DARWIN80_ENV) && \
+# if !defined(AFS_SGI_ENV) && !defined(AFS_FBSD_ENV) && !defined(AFS_DARWIN80_ENV) && \
   !defined(AFS_NBSD40_ENV)
 #  include "h/user.h"
-# endif /* AFS_SGI64_ENV */
+# endif /* AFS_SGI_ENV */
 # define       MACH_USER_API   1
 # if defined(AFS_FBSD_ENV)
 #  include "h/bio.h"
index bd14fd6..8743bce 100644 (file)
 #include <afs/afsutil.h>
 #include <afs/sys_prototypes.h>
 
-#if defined(AFS_SGI62_ENV) && !defined(AFS_SGI65_ENV)
-#include <sym.h>
-#include <symconst.h>
-#endif
-#ifdef AFS_SGI65_ENV
+#ifdef AFS_SGI_ENV
 #include <sched.h>
 #endif
 
@@ -290,7 +286,7 @@ static int rxmaxmtu = 0;       /* Are we forcing a limit on the mtu? */
 static int rxmaxfrags = 0;      /* Are we forcing a limit on frags? */
 static int volume_ttl = 0;      /* enable vldb cache timeout support */
 
-#ifdef AFS_SGI62_ENV
+#ifdef AFS_SGI_ENV
 #define AFSD_INO_T ino64_t
 #else
 #define AFSD_INO_T afs_uint32
@@ -980,7 +976,7 @@ doSweepAFSCache(int *vFilesFound,
     char fullpn_FileToDelete[1024];    /*File to be deleted from cache */
     char *fileToDelete;                /*Ptr to last component of above */
     DIR *cdirp;                        /*Ptr to cache directory structure */
-#ifdef AFS_SGI62_ENV
+#ifdef AFS_SGI_ENV
     struct dirent64 *currp;    /*Current directory entry */
 #else
     struct dirent *currp;      /*Current directory entry */
@@ -1013,7 +1009,7 @@ doSweepAFSCache(int *vFilesFound,
     sprintf(fullpn_FileToDelete, "%s/", directory);
     fileToDelete = fullpn_FileToDelete + strlen(fullpn_FileToDelete);
 
-#ifdef AFS_SGI62_ENV
+#ifdef AFS_SGI_ENV
     for (currp = readdir64(cdirp); currp; currp = readdir64(cdirp))
 #else
     for (currp = readdir(cdirp); currp; currp = readdir(cdirp))
@@ -1021,7 +1017,7 @@ doSweepAFSCache(int *vFilesFound,
     {
        if (afsd_debug) {
            printf("%s: Current directory entry:\n", rn);
-#if defined(AFS_SGI62_ENV) || defined(AFS_DARWIN90_ENV)
+#if defined(AFS_SGI_ENV) || defined(AFS_DARWIN90_ENV)
            printf("\tinode=%" AFS_INT64_FMT ", reclen=%d, name='%s'\n", currp->d_ino,
                   currp->d_reclen, currp->d_name);
 #elif defined(AFS_DFBSD_ENV) || defined(AFS_USR_DFBSD_ENV)
@@ -2156,7 +2152,7 @@ CheckOptions(struct cmd_syndesc *as)
 #ifdef AFS_SUN5_ENV
     struct stat st;
 #endif
-#ifdef AFS_SGI65_ENV
+#ifdef AFS_SGI_ENV
     struct sched_param sp;
 #endif
 
@@ -2942,7 +2938,7 @@ afsd_run(void)
                }
                /* fall through to setup-by-inode */
            }
-#if defined(AFS_SGI62_ENV) || !(defined(AFS_LINUX_ENV) || defined(AFS_CACHE_VNODE_PATH))
+#if defined(AFS_SGI_ENV) || !(defined(AFS_LINUX_ENV) || defined(AFS_CACHE_VNODE_PATH))
            afsd_syscall(AFSOP_CACHEINODE, inode_for_V[currVFile]);
 #else
            printf
@@ -3228,7 +3224,7 @@ afsd_syscall_populate(struct afsd_syscall_args *args, int syscall, va_list ap)
        params[3] = CAST_SYSCALL_PARAM((va_arg(ap, void *)));
        break;
     case AFSOP_CACHEINODE:
-#if defined AFS_SGI62_ENV
+#if defined AFS_SGI_ENV
        {
            afs_int64 tmp = va_arg(ap, afs_int64);
            params[0] = CAST_SYSCALL_PARAM((afs_uint32)(tmp >> 32));
index a973dc7..c45c64f 100644 (file)
@@ -101,7 +101,7 @@ kern_return_t DiskArbDiskAppearedWithMountpointPing_auto(char *, unsigned int,
 #define        MOUNT_AFS AFS_MOUNT_STR
 #endif /* MOUNT_AFS */
 
-#ifdef AFS_SGI65_ENV
+#ifdef AFS_SGI_ENV
 # include <sched.h>
 # define SET_RTPRI(P) {  \
     struct sched_param sp; \
index b97fea5..0f430ce 100644 (file)
@@ -770,7 +770,7 @@ hdl_notifier(struct bnode_proc *tp)
        FILE *fout;
        struct bnode *tb = tp->bnode;
 
-#if defined(AFS_HPUX_ENV) || defined(AFS_SUN5_ENV) || defined(AFS_SGI51_ENV)
+#if defined(AFS_HPUX_ENV) || defined(AFS_SUN5_ENV) || defined(AFS_SGI_ENV)
        setsid();
 #elif defined(AFS_DARWIN90_ENV)
        setpgid(0, 0);
index 3189855..af2b131 100644 (file)
@@ -23,7 +23,7 @@
 typedef struct Lock afs_lock_t;
 #endif
 
-#if (defined(AFS_SGI61_ENV) && (_MIPS_SZLONG==64)) || (defined(AFS_AIX51_ENV) && defined(AFS_64BIT_KERNEL)) || (defined(AFS_DARWIN_ENV) && defined(__amd64__))
+#if (defined(AFS_SGI_ENV) && (_MIPS_SZLONG==64)) || (defined(AFS_AIX51_ENV) && defined(AFS_64BIT_KERNEL)) || (defined(AFS_DARWIN_ENV) && defined(__amd64__))
 #define ICL_LONG 2
 #else
 #define ICL_LONG 1
index eadf80f..517c33b 100644 (file)
 #define AFS_ENV                        1       /* NOBODY uses this.... */
 #define CMUSTD_ENV             1       /* NOBODY uses this.... */
 #define AFS_SGI_ENV            1
-#define AFS_SGI51_ENV          1       /* Dist from 5.0.1 */
-#define        AFS_SGI52_ENV           1
-#define        AFS_SGI53_ENV           1
-#define AFS_SGI61_ENV          1
-#define AFS_SGI62_ENV          1
-#define AFS_SGI63_ENV          1
-#define AFS_SGI64_ENV          1
 #define AFS_SGI65_ENV          1
 #define AFS_SGI_EXMAG          1       /* use magic fields in extents for AFS extra fields */
 /* AFS_SGI_SHORTSTACK not required since we have a 16K stack. */
 #define AFS_GREEDY43_ENV       1       /* Used only in rx/rx_user.c */
 #define AFS_ENV                        1
 #define AFS_USR_SGI_ENV                1
-#define AFS_USR_SGI62_ENV      1
-#define AFS_USR_SGI63_ENV      1
-#define AFS_USR_SGI64_ENV      1
 #define AFS_USR_SGI65_ENV      1
 
                                                                                                               /*#define AFS_GLOBAL_SUNLOCK    1 *//* For global locking */
index 8872cbe..51c200a 100644 (file)
@@ -34,9 +34,9 @@
 #  if  defined(AFS_SUN5_ENV) || defined(AFS_HPUX_ENV) || defined(AFS_FBSD_ENV) || defined(AFS_DARWIN80_ENV)
 #   include "afs/sysincludes.h"
 #  endif
-#  if !defined(AFS_SGI64_ENV) && !defined(AFS_DARWIN_ENV) && !defined(AFS_OBSD48_ENV) && !defined(AFS_NBSD_ENV)
+#  if !defined(AFS_SGI_ENV) && !defined(AFS_DARWIN_ENV) && !defined(AFS_OBSD48_ENV) && !defined(AFS_NBSD_ENV)
 #   include "h/user.h"
-#  endif /* AFS_SGI64_ENV */
+#  endif /* AFS_SGI_ENV */
 #  include "h/uio.h"
 #  if !defined(AFS_SUN5_ENV) && !defined(AFS_LINUX_ENV) && !defined(AFS_HPUX110_ENV)
 #   include "h/mbuf.h"
index 9733d3f..d554fa7 100644 (file)
@@ -377,7 +377,7 @@ LWP_CreateProcess(void *(*ep) (void *), int stacksize, int priority, void *parm,
        savecontext(Create_Process_Part2, &temp2->context,
                    stackptr + MINFRAME);
 #else
-#if defined(AFS_SGI62_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
+#if defined(AFS_SGI_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
 #ifdef sys_x86_darwin_80
        savecontext(Create_Process_Part2, &temp2->context, stackptr + stacksize - 16 - sizeof(void *)); /* 16 = 2 * jmp_buf_type */
 #else /* !sys_x86_darwin_80 */
@@ -397,7 +397,7 @@ LWP_CreateProcess(void *(*ep) (void *), int stacksize, int priority, void *parm,
                    stackptr + stacksize - sizeof(void *));
 #endif /* AFS_S390_LINUX_ENV */
 #endif /* AFS_SPARC64_LINUX_ENV || AFS_SPARC_LINUX_ENV */
-#endif /* AFS_SGI62_ENV */
+#endif /* AFS_SGI_ENV */
 #endif
        /* End of gross hack */
 
@@ -517,7 +517,7 @@ LWP_DestroyProcess(PROCESS pid)
 #if defined(__hp9000s800)
            savecontext(Dispatcher, &(temp->context),
                        &(LWPANCHOR.dsptchstack[MINFRAME]));
-#elif defined(AFS_SGI62_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
+#elif defined(AFS_SGI_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
            savecontext(Dispatcher, &(temp->context),
                        &(LWPANCHOR.
                          dsptchstack[(sizeof LWPANCHOR.dsptchstack) - 8]));
index 7130c3e..75026e2 100644 (file)
@@ -82,7 +82,7 @@ returnto(struct lwp_context *savearea)
 /*
  * Magic stack pointer
  */
-#if    defined(AFS_SGI64_ENV)
+#if    defined(AFS_SGI_ENV)
 # ifdef _BSD_COMPAT
 #  define LWP_SP 34
 # else
@@ -122,7 +122,7 @@ Need offset to SP in jmp_buf for this platform.
   * differs based on the ISA chosen. It is int for mips1 and mips2 and
   * __uint64_t for mips3 and mips4
   */
-#ifdef AFS_SGI64_ENV
+#ifdef AFS_SGI_ENV
 #if (_MIPS_ISA == _MIPS_ISA_MIPS3 || _MIPS_ISA == _MIPS_ISA_MIPS4)
 typedef __uint64_t jmp_buf_type;
 #endif
index 5767a55..06c6ac0 100644 (file)
@@ -16,8 +16,6 @@
 #ifndef _RX_KMUTEX_H_
 #define _RX_KMUTEX_H_
 
-#ifdef AFS_SGI62_ENV
-
 #ifdef MP
 #define        RX_ENABLE_LOCKS 1
 
@@ -36,30 +34,20 @@ typedef kcondvar_t afs_kcondvar_t;
 #define        MUTEX_DEFAULT   0
 #endif
 
-#ifdef AFS_SGI62_ENV
 #define MUTEX_INIT(m, nm, type , a)  mutex_init(m, type, nm)
-#else
-#define MUTEX_INIT(a,b,c,d)  mutex_init(a,b,c,d)
-#endif
 #define MUTEX_DESTROY(a) mutex_destroy(a)
 #define MUTEX_ASSERT(a)
 #define CV_INIT(cv, a,b,c)     cv_init(cv, a, b, c)
 #define CV_SIGNAL(_cv)         cv_signal(_cv)
 #define CV_BROADCAST(_cv)      cv_broadcast(_cv)
 #define CV_DESTROY(_cv)                cv_destroy(_cv)
-#ifdef AFS_SGI64_ENV
 /* Add PLTWAIT for afsd's to wait so we don't rack up the load average. */
-#ifdef AFS_SGI65_ENV
 #define AFSD_PRI() ((kt_basepri(curthreadp) == PTIME_SHARE) ? PZERO : (PZERO|PLTWAIT))
-#else
-#define AFSD_PRI() ((curprocp && curprocp->p_rss==0) ? (PZERO|PLTWAIT) : PZERO)
-#endif /* SGI65 */
 #undef cv_wait
 #define cv_wait(cv, mp)        { \
        sv_wait(cv, AFSD_PRI(), mp, 0); \
        AFS_MUTEX_ENTER(mp); \
 }
-#endif /* AFS_SGI64_ENV */
 #ifdef RX_LOCKS_DB
 #define MUTEX_ENTER(a)         do { \
                                     AFS_MUTEX_ENTER(a); \
@@ -155,6 +143,4 @@ typedef kcondvar_t afs_kcondvar_t;
 
 #endif /* MP */
 
-#endif /* SGI62 */
-
 #endif /* _RX_KMUTEX_H_ */
index 42d9b4d..788c5e2 100644 (file)
@@ -53,10 +53,8 @@ osi_NetReceive(osi_socket so, struct sockaddr_in *addr, struct iovec *dvec,
     struct mbuf *maddr = NULL;
     struct sockaddr_in *taddr;
     struct iovec tmpvec[RX_MAXWVECS + 2];
-#ifdef AFS_SGI65_ENV
     bhv_desc_t bhv;
     BHV_PDATA(&bhv) = (void *)so;
-#endif
 
     memset(&tuio, 0, sizeof(tuio));
     memset(&tmpvec, 0, sizeof(tmpvec));
@@ -74,14 +72,9 @@ osi_NetReceive(osi_socket so, struct sockaddr_in *addr, struct iovec *dvec,
        osi_Panic("Too many (%d) iovecs passed to osi_NetReceive\n", nvecs);
     }
     memcpy(tmpvec, (char *)dvec, (RX_MAXWVECS + 1) * sizeof(struct iovec));
-#ifdef AFS_SGI65_ENV
     code = soreceive(&bhv, &maddr, &tuio, NULL, NULL);
-#else
-    code = soreceive(so, &maddr, &tuio, NULL, NULL);
-#endif
 
     if (code) {
-#ifdef AFS_SGI65_ENV
        /* Clear the error before using the socket again. I've tried being nice
         * and blocking SIGKILL and SIGSTOP from the kernel, but they get
         * delivered anyway. So, time to be crude and just clear the signals
@@ -97,7 +90,6 @@ osi_NetReceive(osi_socket so, struct sockaddr_in *addr, struct iovec *dvec,
            ut_unlock(ut, s);
            rxk_nSignalsCleared++;
        }
-#endif
        /* Clear the error before using the socket again. */
        so->so_error = 0;
        rxk_lastSocketError = code;
@@ -124,13 +116,8 @@ static struct protosw parent_proto;        /* udp proto switch */
  * RX input, fast timer and initialization routines. 
  */
 
-#ifdef AFS_SGI64_ENV
 static void
 rxk_input(struct mbuf *am, struct ifnet *aif, struct ipsec *spec)
-#else
-static void
-rxk_input(struct mbuf *am, struct ifnet *aif)
-#endif
 {
     void (*tproc) ();
     unsigned short *tsp;
@@ -416,7 +403,6 @@ rxi_GetIFInfo()
 #define _MP_NETLOCKS
 #endif
 
-#ifdef AFS_SGI65_ENV
 osi_NetSend(asocket, addr, dvec, nvec, asize, istack)
      osi_socket *asocket;
      struct iovec *dvec;
@@ -464,132 +450,3 @@ osi_NetSend(asocket, addr, dvec, nvec, asize, istack)
     m_freem(to);
     return code;
 }
-#else /* AFS_SGI65_ENV */
-
-int
-dummy_sblock(struct sockbuf *a, int b, struct socket *c, int *d, int e)
-{
-    afs_warn
-       ("sblock was called before it was installed. Install proper afsd.\n");
-}
-
-void
-dummy_sbunlock(struct sockbuf *a, int b, struct socket *c, int d)
-{
-    afs_warn
-       ("sbunlock was called before it was installed. Install proper afsd.\n");
-}
-
-int (*afs_sblockp) (struct sockbuf *, int, struct socket *, int *, int) =
-    dummy_sblock;
-void (*afs_sbunlockp) (struct sockbuf *, int, struct socket *, int) =
-    dummy_sbunlock;
-#define AFS_SBUNLOCK(SB, EV, SO, O) (*afs_sbunlockp)(SB, EV, SO, O)
-
-/* osi_NetSend - send asize bytes at adata from asocket to host at addr.
- *
- * Now, why do we allocate a new buffer when we could theoretically use the one
- * pointed to by adata?  Because PRU_SEND returns after queueing the message,
- * not after sending it.  If the sender changes the data after queueing it,
- * we'd see the already-queued data change.  One attempt to fix this without
- * adding a copy would be to have this function wait until the datagram is
- * sent; however this doesn't work well.  In particular, if a host is down, and
- * an ARP fails to that host, this packet will be queued until the ARP request
- * comes back, which could be hours later.  We can't block in this routine that
- * long, since it prevents RPC timeouts from happening.
- */
-/* XXX In the brave new world, steal the data bufs out of the rx_packet iovec,
- * and just queue those.  XXX
- */
-int
-osi_NetSend(asocket, addr, dvec, nvec, asize, istack)
-     struct socket *asocket;
-     struct iovec *dvec;
-     int nvec;
-     afs_int32 asize;
-     struct sockaddr_in *addr;
-     int istack;
-{
-    struct mbuf *tm, *um;
-    afs_int32 code;
-    int s;
-    struct mbuf *top = 0;
-    struct mbuf *m, **mp;
-    int len;
-    char *tdata;
-    caddr_t tpa;
-    int i, tl, rlen;
-
-    NETSPL_DECL(s1)
-       AFS_STATCNT(osi_NetSend);
-
-    (*afs_sblockp) (&asocket->so_snd, NETEVENT_SODOWN, asocket, &s1, istack);
-
-    s = splnet();
-    mp = &top;
-    i = 0;
-    tdata = dvec[i].iov_base;
-    tl = dvec[i].iov_len;
-    while (1) {
-       if ((m = m_vget(M_DONTWAIT, MIN(asize, VCL_MAX), MT_DATA)) == NULL) {
-           if (top)
-               m_freem(top);
-           splx(s);
-           AFS_SBUNLOCK(&asocket->so_snd, NETEVENT_SODOWN, asocket, s1);
-           return 1;
-       }
-       len = MIN(m->m_len, asize);
-       m->m_len = 0;
-       tpa = mtod(m, caddr_t);
-       while (len) {
-           rlen = MIN(len, tl);
-           memcpy(tpa, tdata, rlen);
-           asize -= rlen;
-           len -= rlen;
-           tpa += rlen;
-           m->m_len += rlen;
-           tdata += rlen;
-           tl -= rlen;
-           if (tl <= 0) {
-               i++;
-               if (i > nvec) {
-                   /* shouldn't come here! */
-                   asize = 0;  /* so we make progress toward completion */
-                   break;
-               }
-               tdata = dvec[i].iov_base;
-               tl = dvec[i].iov_len;
-           }
-       }
-       *mp = m;
-       mp = &m->m_next;
-       if (asize <= 0)
-           break;
-    }
-    tm = top;
-
-    tm->m_act = NULL;
-
-    /* setup mbuf corresponding to destination address */
-    um = m_get(M_DONTWAIT, MT_SONAME);
-    if (!um) {
-       if (top)
-           m_freem(top);       /* free mbuf chain */
-       /* if this were vfs40, we'd do sbunlock(asocket, &asocket->so_snd), but
-        * we don't do the locking at all for vfs40 systems */
-       splx(s);
-       AFS_SBUNLOCK(&asocket->so_snd, NETEVENT_SODOWN, asocket, s1);
-       return 1;
-    }
-    memcpy(mtod(um, caddr_t), addr, sizeof(*addr));
-    um->m_len = sizeof(*addr);
-    /* note that udp_usrreq frees funny mbuf.  We hold onto data, but mbuf
-     * around it is gone.  we free address ourselves.  */
-    code = (*asocket->so_proto->pr_usrreq) (asocket, PRU_SEND, tm, um, 0);
-    splx(s);
-    m_free(um);
-    AFS_SBUNLOCK(&asocket->so_snd, NETEVENT_SODOWN, asocket, s1);
-
-    return code;
-}
-#endif /* AFS_SGI65_ENV */
index 5783777..263e657 100644 (file)
@@ -41,7 +41,7 @@ rxk_portRocks_t rxk_portRocks;
 
 int rxk_initDone = 0;
 
-#if !defined(AFS_SUN5_ENV) && !defined(AFS_SGI62_ENV)
+#if !defined(AFS_SUN5_ENV) && !defined(AFS_SGI_ENV)
 # define ADDRSPERSITE 16
 static afs_uint32 myNetAddrs[ADDRSPERSITE];
 static int myNetMTUs[ADDRSPERSITE];
@@ -391,7 +391,7 @@ rxi_InitPeerParams(struct rx_peer *pp)
 
     RX_NET_EPOCH_ENTER();
 
-#  if !defined(AFS_SGI62_ENV)
+#  if !defined(AFS_SGI_ENV)
     if (numMyNetAddrs == 0)
        (void)rxi_GetIFInfo();
 #  endif
@@ -488,7 +488,7 @@ shutdown_rxkernel(void)
 }
 #endif /* !AIX && !SUN && !NCR  && !UKERNEL */
 
-#if !defined(AFS_SUN5_ENV) && !defined(AFS_SGI62_ENV)
+#if !defined(AFS_SUN5_ENV) && !defined(AFS_SGI_ENV)
 /* Determine what the network interfaces are for this machine. */
 
 # ifdef AFS_USERSPACE_IP_ADDR
@@ -815,7 +815,7 @@ rxi_FindIfnet(afs_uint32 addr, afs_uint32 * maskp)
 }
 #  endif /* else DARWIN || XBSD */
 # endif /* else AFS_USERSPACE_IP_ADDR */
-#endif /* !SUN5 && !SGI62 */
+#endif /* !SUN5 && !SGI */
 
 
 /* rxk_NewSocket, rxk_FreeSocket and osi_NetSend are from the now defunct
@@ -849,7 +849,7 @@ rxk_NewSocketHost(afs_uint32 ahost, short aport)
     struct file *fp;
     extern struct fileops socketops;
 #  endif
-#  ifdef AFS_SGI65_ENV
+#  ifdef AFS_SGI_ENV
     bhv_desc_t bhv;
 #  endif
 
@@ -878,7 +878,7 @@ rxk_NewSocketHost(afs_uint32 ahost, short aport)
 #   else /* AFS_HPUX110_ENV */
     code = socreate(AF_INET, &newSocket, SOCK_DGRAM, 0, SS_NOWAIT);
 #   endif /* else AFS_HPUX110_ENV */
-#  elif defined(AFS_SGI65_ENV) || defined(AFS_OBSD_ENV)
+#  elif defined(AFS_SGI_ENV) || defined(AFS_OBSD_ENV)
     code = socreate(AF_INET, &newSocket, SOCK_DGRAM, IPPROTO_UDP);
 #  elif defined(AFS_FBSD_ENV)
     code = socreate(AF_INET, &newSocket, SOCK_DGRAM, IPPROTO_UDP,
@@ -978,7 +978,7 @@ rxk_NewSocketHost(afs_uint32 ahost, short aport)
     }
     nam->m_len = sizeof(myaddr);
     memcpy(mtod(nam, caddr_t), &myaddr, sizeof(myaddr));
-#    if defined(AFS_SGI65_ENV)
+#    if defined(AFS_SGI_ENV)
     BHV_PDATA(&bhv) = (void *)newSocket;
     code = sobind(&bhv, nam);
     m_freem(nam);
@@ -990,7 +990,7 @@ rxk_NewSocketHost(afs_uint32 ahost, short aport)
     if (code) {
        dpf(("sobind fails (%d)\n", (int)code));
        soclose(newSocket);
-#    ifndef AFS_SGI65_ENV
+#    ifndef AFS_SGI_ENV
        m_freem(nam);
 #    endif
        goto bad;
index 18bca30..6a640e6 100644 (file)
@@ -69,7 +69,7 @@ struct coda_inode_info {
 #endif
 #endif /* !defined(AFS_SUN5_ENV) && !defined(AFS_XBSD_ENV) */
 #endif /* !defined(AFS_LINUX_ENV) && !defined(AFS_OBSD_ENV) */
-#ifdef AFS_SGI62_ENV
+#ifdef AFS_SGI_ENV
 #include "h/hashing.h"
 #endif
 #ifdef AFS_FBSD_ENV
@@ -102,10 +102,10 @@ struct coda_inode_info {
 #include "netinet/ip_icmp.h"
 #endif /* AFS_LINUX_ENV */
 #include "netinet/udp.h"
-#if !defined(AFS_SGI62_ENV) && !defined(AFS_LINUX_ENV) && !defined(AFS_DARWIN_ENV)
+#if !defined(AFS_SGI_ENV) && !defined(AFS_LINUX_ENV) && !defined(AFS_DARWIN_ENV)
 #include "netinet/udp_var.h"
 #endif
-#if defined(AFS_HPUX102_ENV) || (defined(AFS_SGI62_ENV) && !defined(AFS_SGI64_ENV))
+#if defined(AFS_HPUX102_ENV)
 #include "h/user.h"
 #endif
 #ifdef AFS_LINUX_ENV
index ff132d9..9d6d4ee 100644 (file)
@@ -121,7 +121,7 @@ int rx_callHoldType = 0;
  * RX_LOCKS_DB versions of MUTEX_{ENTER, EXIT, TRYENTER} and CV_*WAIT to
  * rx_kmutex.h and define lock macros below.
  */
-#if (defined(AFS_AIX41_ENV) || (defined(AFS_SGI53_ENV) && defined(MP))) && defined(KERNEL)
+#if (defined(AFS_AIX41_ENV) || (defined(AFS_SGI_ENV) && defined(MP))) && defined(KERNEL)
 
 #ifdef AFS_AIX41_ENV
 Simple_lock rxdb_lock;
@@ -130,12 +130,12 @@ Simple_lock rxdb_lock;
 #define RXDB_LOCK_ENTER()      simple_lock(&rxdb_lock)
 #define RXDB_LOCK_EXIT()       simple_unlock(&rxdb_lock)
 #else /* AFS_AIX41_ENV */
-#ifdef AFS_SGI53_ENV
+#ifdef AFS_SGI_ENV
 afs_kmutex_t rxdb_lock;
 #define RXDB_LOCK_INIT()       mutex_init(&rxdb_lock, "rxdb lock", 0, 0)
 #define RXDB_LOCK_ENTER()      AFS_MUTEX_ENTER(&rxdb_lock)
 #define RXDB_LOCK_EXIT()       mutex_exit(&rxdb_lock)
-#endif /* AFS_SGI53_ENV */
+#endif /* AFS_SGI_ENV */
 #endif /* AFS_AIX41_ENV */
 
 
@@ -350,6 +350,6 @@ rxdb_droplock(a, id, fileId, line)
     RXDB_LOCK_EXIT();
 }
 
-#endif /* (AIX41 || SGI53) && KERNEL */
+#endif /* (AIX41 || SGI) && KERNEL */
 
 #endif /* RX_LOCKS_DB */
index 6a9391c..df37c42 100644 (file)
@@ -21,12 +21,12 @@ typedef afs_uint64 Inode;
 
 #else /* AFS_NAMEI_ENV */
 #ifdef AFS_64BIT_IOPS_ENV
-#ifdef AFS_SGI62_ENV
+#ifdef AFS_SGI_ENV
 typedef uint64_t Inode;
 #else
 #include <sys/types.h>
 typedef afs_uint64 Inode;
-#endif                         /* AFS_SGI62_ENV */
+#endif                         /* AFS_SGI_ENV */
 #else /* AFS_64BIT_IOPS_ENV */
 typedef unsigned int Inode;
 #endif
index 0924436..35f99ca 100644 (file)
@@ -19,11 +19,11 @@ main(argc, argv)
 {
     int inode;
     struct stat status;
-#ifdef AFS_SGI61_ENV
+#ifdef AFS_SGI_ENV
     int vnode, unique, datav;
-#else /* AFS_SGI61_ENV */
+#else /* AFS_SGI_ENV */
     afs_int32 vnode, unique, datav;
-#endif /* AFS_SGI61_ENV */
+#endif /* AFS_SGI_ENV */
 
     if (stat("/vicepa", &status) == -1) {
        perror("stat");
index 39ba6ee..2420df5 100644 (file)
@@ -29,7 +29,7 @@ int afs_icl_sizeofLong = ICL_LONG;
 
 #if ICL_LONG == 2
 int afs_64bit_kernel = 1;      /* Default for 6.2+, and always for 6.1 */
-#ifdef AFS_SGI62_ENV
+#ifdef AFS_SGI_ENV
 
 /* If _SC_KERN_POINTERS not in sysconf, then we can assume a 32 bit abi. */
 void
@@ -48,7 +48,7 @@ set_kernel_sizeof_long(void)
     }
 }
 
-#endif /* AFS_SGI62_ENV */
+#endif /* AFS_SGI_ENV */
 #endif /* ICL_LONG == 2 */
 
 int afs_syscall(long call, long parm0, long parm1, long parm2, long parm3,
@@ -211,9 +211,6 @@ CheckTypes(char *bufferp, int *typesp, int typeCount)
  * alp points at the first word in the array to be interpreted
  * rsize gives the # of words in the array
  */
-#if defined(AFS_SGI61_ENV) && !defined(AFS_SGI62_ENV)
-#define uint64_t long long
-#endif
 static void
 DisplayRecord(FILE *outFilep, afs_int32 *alp, afs_int32 rsize)
 {
@@ -1163,7 +1160,7 @@ DoDump(struct cmd_syndesc *as, void *arock)
            return 1;
        }
     }
-#ifdef AFS_SGI64_ENV
+#ifdef AFS_SGI_ENV
     startTime = time((time_t *) 0);
 #else
     startTime = time(0);
@@ -1563,7 +1560,7 @@ int
 main(int argc, char *argv[])
 {
     setlocale(LC_ALL, "");
-#ifdef AFS_SGI62_ENV
+#ifdef AFS_SGI_ENV
     set_kernel_sizeof_long();
 #endif
 
index ad722f6..58c29cf 100644 (file)
@@ -98,11 +98,11 @@ struct ncp_sb_info {
 #include <netdb.h>
 #endif
 
-/* For AFS_SGI61_ENV and a 64 bit OS, _KMEMUSER should be defined on the
+/* For AFS_SGI_ENV and a 64 bit OS, _KMEMUSER should be defined on the
  * compile line for kdump.o in the Makefile. This lets us pick up
  * app32_ptr_t from types.h when included from afs/param.h.
  */
-#ifdef AFS_SGI62_ENV
+#ifdef AFS_SGI_ENV
 #define _KERNEL 1
 #endif
 
@@ -121,15 +121,9 @@ struct ncp_sb_info {
 struct vnode foo;
 #endif
 
-#ifdef AFS_SGI53_ENV
+#ifdef AFS_SGI_ENV
 #define _KERNEL 1
 #include <sys/sema.h>
-#ifndef AFS_SGI62_ENV
-#undef _KERNEL 1
-#endif
-#endif
-
-#ifdef AFS_SGI62_ENV
 #include <sys/fcntl.h>
 #ifndef L_SET
 #define L_SET 0
@@ -138,7 +132,7 @@ struct vnode foo;
 
 #include <sys/param.h>
 
-#ifndef AFS_SGI64_ENV
+#ifndef AFS_SGI_ENV
 #include <sys/user.h>
 #endif
 
@@ -327,7 +321,7 @@ typedef struct {
 typedef char *afs_kcondvar_t;
 #endif /* AFS_HPUX110_ENV */
 
-#ifdef AFS_SGI65_ENV
+#ifdef AFS_SGI_ENV
 #define RX_ENABLE_LOCKS 1
 typedef struct {
     __psunsigned_t opaque1;
@@ -336,7 +330,7 @@ typedef struct {
 typedef struct {
     __psunsigned_t opaque;
 } afs_kcondvar_t;
-#endif /* AFS_SGI65_ENV */
+#endif /* AFS_SGI_ENV */
 
 #ifdef AFS_LINUX_ENV
 #include <asm/atomic.h>
@@ -377,12 +371,12 @@ typedef struct {
 #endif
 
 
-#ifdef AFS_SGI61_ENV
+#ifdef AFS_SGI_ENV
 extern off64_t lseek64();
 #define KDUMP_SIZE_T size_t
-#else /* AFS_SGI61_ENV */
+#else /* AFS_SGI_ENV */
 #define KDUMP_SIZE_T int
-#endif /* AFS_SGI61_ENV */
+#endif /* AFS_SGI_ENV */
 
 #include "afs/afs.h"           /* XXXX Getting it from the obj tree XXX */
 #include "afs/afs_axscache.h"  /* XXXX Getting it from the obj tree XXX */
@@ -474,7 +468,7 @@ int opencore();
 #define afs_nlist nlist64
 #define AFSNLIST(N, C) nlist64((N), (C))
 #else /* defined(AFS_HPUX_ENV) && defined(__LP64__) */
-#ifdef AFS_SGI61_ENV
+#ifdef AFS_SGI_ENV
 #ifdef AFS_32BIT_KERNEL_ENV
 #define afs_nlist nlist
 #define AFSNLIST(N, C) nlist((N), (C))
@@ -482,7 +476,7 @@ int opencore();
 #define afs_nlist nlist64
 #define AFSNLIST(N, C) nlist64((N), (C))
 #endif /* AFS_32BIT_KERNEL_ENV */
-#else /* AFS_SGI61_ENV */
+#else /* AFS_SGI_ENV */
 #ifdef AFS_LINUX_ENV
 struct afs_nlist {
     char *n_name;
@@ -492,7 +486,7 @@ struct afs_nlist {
 #define afs_nlist nlist
 #endif /* AFS_LINUX_ENV */
 #define AFSNLIST(N, C) nlist((N), (C))
-#endif /* AFS_SGI61_ENV */
+#endif /* AFS_SGI_ENV */
 #endif /* defined(AFS_HPUX_ENV) && defined(__LP64__) */
 
 char *obj = UNIX, *core = CORE;
@@ -1003,13 +997,9 @@ kdump(void)
 
 #ifdef KDUMP_RX_LOCK
     /* Test to see if kernel is using RX_ENABLE_LOCKS in rx structs. */
-#ifdef AFS_SGI53_ENV
-#ifdef AFS_SGI64_ENV
+#ifdef AFS_SGI_ENV
     use_rx_lock = 1;           /* Always using fine gain locking. */
-#else
-    use_rx_lock = (sysmp(MP_NPROCS) > 1) ? 1 : 0;
-#endif
-#endif /* AFS_SGI53_ENV */
+#endif /* AFS_SGI_ENV */
 #endif /* KDUMP_RX_LOCK */
 
     if (Dcells || Dall) {
@@ -1699,7 +1689,7 @@ print_buffers(int pnt)
     kread(kmem, table, buffers, count * sizeof(struct buffer));
     bp = (struct buffer *)buffers;
     for (i = 0, j = 0; i < count; i++, bp++) {
-#ifdef AFS_SGI62_ENV
+#ifdef AFS_SGI_ENV
        if (pnt)
            printf
                ("Buffer #%d:\tfid=%llu page=%d, accTime=%d,\n\tHash=%x, data=%x, lockers=%x, dirty=%d, hashI=%d\n",
@@ -2138,7 +2128,7 @@ kread(int kmem, off_t loc, void *buf, KDUMP_SIZE_T len)
 #endif
 #endif
 #if    ! defined(AFS_SUN5_ENV)
-#if defined(AFS_SGI61_ENV) && !defined(AFS_32BIT_KERNEL_ENV)
+#if defined(AFS_SGI_ENV) && !defined(AFS_32BIT_KERNEL_ENV)
     if (lseek64(kmem, loc, L_SET /*0 */ ) != loc)
 #else
     if (lseek(kmem, loc, L_SET /*0 */ ) != loc)
@@ -2563,7 +2553,7 @@ print_vnode(int kmem, struct vnode *vep, struct vnode *ptr, int pnt)
 #ifdef AFS_AIX_ENV
     vep->v_gnode = save_gnode;
 #endif /* AFS_AIX_ENV */
-#ifdef AFS_SGI65_ENV
+#ifdef AFS_SGI_ENV
 #if defined(AFS_32BIT_KERNEL_ENV)
     printf("%lx: v_mreg=0x%lx", ptr, vep->v_mreg);
 #else
@@ -2745,7 +2735,7 @@ print_dcache(int kmem, struct dcache *dcp, struct dcache *dp, int pnt)
     printf("\tf.hvn=%d, f.hcn=%d, f.modtime=%d, f.versNo=%d\n",
           dcp->f.hvNextp, dcp->f.hcNextp, dcp->f.modTime, dcp->f.versionNo);
 #endif
-#ifdef AFS_SGI62_ENV
+#ifdef AFS_SGI_ENV
     printf
        ("\tf.chunk=%d, f.inode=%" AFS_INT64_FMT ", f.chunkBytes=%d, f.states=%x",
         dcp->f.chunk, dcp->f.inode, dcp->f.chunkBytes, dcp->f.states);
@@ -3005,7 +2995,7 @@ print_global_afs_resource(int kmem)
     kread(kmem, (off_t) addr, sysname, (KDUMP_SIZE_T) 30);
     printf("\tafs_sysname = %s\n", sysname);
 #endif
-#ifdef AFS_SGI65_ENV
+#ifdef AFS_SGI_ENV
     findsym("afs_ipno", &symoff);
     kread(kmem, symoff, (char *)&count, sizeof count);
     printf("\tCPU BOARD = IP%d\n", count);
@@ -3019,7 +3009,7 @@ print_global_afs_cache(int kmem)
     off_t symoff;
     char sysname[100];
     afs_int32 count;
-#ifdef AFS_SGI62_ENV
+#ifdef AFS_SGI_ENV
     ino64_t inode;
 #endif
 #ifndef        AFS32
@@ -3048,7 +3038,7 @@ print_global_afs_cache(int kmem)
     findsym("afs_freeDSList", &symoff);
     kread(kmem, symoff, (char *)&count, sizeof count);
     printf("\tfreeDSList= 0x%x XXXX\n", count);
-#ifdef AFS_SGI62_ENV
+#ifdef AFS_SGI_ENV
     findsym("cacheInode", &symoff);
     kread(kmem, symoff, (char *)&inode, sizeof inode);
     printf("\tcacheInode = 0x%llx (%" AFS_INT64_FMT ")\n", inode, inode);
index 957a92b..f67cb0f 100644 (file)
@@ -2001,7 +2001,7 @@ main(int argc, char *argv[])
     else if (stackSize > 44000)
        stackSize = 44000;
 #endif
-#if defined(AFS_HPUX_ENV) || defined(AFS_SUN_ENV) || defined(AFS_SGI51_ENV) || defined(AFS_XBSD_ENV)
+#if defined(AFS_HPUX_ENV) || defined(AFS_SUN_ENV) || defined(AFS_SGI_ENV) || defined(AFS_XBSD_ENV)
     rx_SetStackSize(1, stackSize);
 #endif
     if (udpBufSize)