From c206977d93116adf1d8ff79f2fd6374fa5a728fc Mon Sep 17 00:00:00 2001 From: Chaskiel M Grundman Date: Sun, 8 May 2005 07:49:43 +0000 Subject: [PATCH] macos-104-not-yet-20050508 shadow@dementia.org to blame for some of this. --- acinclude.m4 | 3 ++ src/afs/DARWIN/osi_machdep.h | 32 ++++++++++++++++++++ src/afs/DARWIN/osi_module.c | 8 +++++ src/afs/DARWIN/osi_vfsops.c | 8 +++++ src/afs/DARWIN/osi_vnodeops.c | 7 +++++ src/afs/VNOPS/afs_vnop_lookup.c | 18 ++++++++++++ src/afs/VNOPS/afs_vnop_remove.c | 7 +++++ src/afs/afs.h | 8 +++++ src/afs/afs_callback.c | 8 +++++ src/afs/afs_osi.c | 2 ++ src/afs/afs_prototypes.h | 2 ++ src/afs/afs_util.c | 4 +++ src/afs/afs_vcache.c | 23 ++++++++++++++- src/afs/lock.h | 4 +++ src/afs/sysincludes.h | 8 ++++- src/rx/DARWIN/rx_kmutex.c | 20 +++++++++++++ src/rx/DARWIN/rx_kmutex.h | 52 ++++++++++++++++++++++++++++++--- src/rx/xdr_prototypes.h | 8 +---- 18 files changed, 209 insertions(+), 13 deletions(-) diff --git a/acinclude.m4 b/acinclude.m4 index bf446a9b3..7c3d27b2f 100644 --- a/acinclude.m4 +++ b/acinclude.m4 @@ -404,6 +404,9 @@ else powerpc-apple-darwin7.5*) AFS_SYSNAME="ppc_darwin_70" ;; + powerpc-apple-darwin8.0*) + AFS_SYSNAME="ppc_darwin_80" + ;; sparc-sun-solaris2.5*) AFS_SYSNAME="sun4x_55" enable_login="yes" diff --git a/src/afs/DARWIN/osi_machdep.h b/src/afs/DARWIN/osi_machdep.h index 409d64d85..af96c105e 100644 --- a/src/afs/DARWIN/osi_machdep.h +++ b/src/afs/DARWIN/osi_machdep.h @@ -25,12 +25,21 @@ typedef unsigned short etap_event_t; #endif #endif +#ifdef AFS_DARWIN80_ENV +#include +#else #include +#endif #include #include +#ifdef AFS_DARWIN80_ENV +#define getpid() proc_selfpid() +#define getppid() proc_selfppid() +#else #define getpid() current_proc()->p_pid #define getppid() current_proc()->p_pptr->p_pid +#endif #undef gop_lookupname #define gop_lookupname osi_lookupname @@ -39,6 +48,12 @@ typedef unsigned short etap_event_t; /* vcexcl - used only by afs_create */ enum vcexcl { EXCL, NONEXCL }; +#ifdef AFS_DARWIN80_ENV +#define vrele vnode_rele +#define vput vnode_put +#define vref vnode_ref +#endif + /* * Time related macros */ @@ -67,6 +82,22 @@ extern struct timeval time; #ifdef KERNEL extern thread_t afs_global_owner; /* simple locks cannot be used since sleep can happen at any time */ +#ifdef AFS_DARWIN80_ENV +/* mach locks still don't have an exported try, but we are forced to use them */ +extern lck_mtx_t *afs_global_lock; +#define AFS_GLOCK() \ + do { \ + lk_mtx_lock(afs_global_lock); \ + osi_Assert(afs_global_owner == 0); \ + afs_global_owner = current_thread(); \ + } while (0) +#define AFS_GUNLOCK() \ + do { \ + osi_Assert(afs_global_owner == current_thread()); \ + afs_global_owner = 0; \ + lk_mtx_unlock(afs_global_lock); \ + } while(0) +#else /* Should probably use mach locks rather than bsd locks, since we use the mach thread control api's elsewhere (mach locks not used for consistency with rx, since rx needs lock_write_try() in order to use mach locks @@ -84,6 +115,7 @@ extern struct lock__bsd__ afs_global_lock; afs_global_owner = 0; \ lockmgr(&afs_global_lock, LK_RELEASE, 0, current_proc()); \ } while(0) +#endif #define ISAFS_GLOCK() (afs_global_owner == current_thread()) #define SPLVAR diff --git a/src/afs/DARWIN/osi_module.c b/src/afs/DARWIN/osi_module.c index d4e1136ef..cc8b86b44 100644 --- a/src/afs/DARWIN/osi_module.c +++ b/src/afs/DARWIN/osi_module.c @@ -48,6 +48,10 @@ afs_modload(struct kmod_info *ki, void *data) sysent[AFS_SYSCALL].sy_parallel = 0; #ifdef KERNEL_FUNNEL sysent[AFS_SYSCALL].sy_funnel = KERNEL_FUNNEL; +#endif +#ifdef AFS_DARWIN80_ENV + MUTEX_SETUP(); + afs_global_lock = lck_mtx_alloc(openafs_lck_grp, 0); #endif return KERN_SUCCESS; } @@ -67,6 +71,10 @@ afs_modunload(struct kmod_info * ki, void *data) /* give up the stolen syscall entry */ sysent[AFS_SYSCALL].sy_narg = 0; sysent[AFS_SYSCALL].sy_call = nosys; +#ifdef AFS_DARWIN80_ENV + MUTEX_FINISH(); + lck_mtx_free(afs_global_lock); +#endif return KERN_SUCCESS; } diff --git a/src/afs/DARWIN/osi_vfsops.c b/src/afs/DARWIN/osi_vfsops.c index 64d085eda..74b9bd4ce 100644 --- a/src/afs/DARWIN/osi_vfsops.c +++ b/src/afs/DARWIN/osi_vfsops.c @@ -156,7 +156,11 @@ afs_unmount(mp, flags, p) if (flags & MNT_FORCE) { if (afs_globalVp) { AFS_GUNLOCK(); +#ifdef AFS_DARWIN80_ENV + vnode_rele(AFSTOV(afs_globalVp)); +#else vrele(AFSTOV(afs_globalVp)); +#endif AFS_GLOCK(); } afs_globalVp = NULL; @@ -248,7 +252,11 @@ afs_vget(mp, lfl, vp) vprint("bad usecount", vp); panic("afs_vget"); } +#ifdef AFS_DARWIN80_ENV + error = vnode_get(vp); +#else error = vget(vp, lfl, current_proc()); +#endif if (!error) insmntque(vp, mp); /* take off free list */ return error; diff --git a/src/afs/DARWIN/osi_vnodeops.c b/src/afs/DARWIN/osi_vnodeops.c index 8fa5e0f91..d632336bc 100644 --- a/src/afs/DARWIN/osi_vnodeops.c +++ b/src/afs/DARWIN/osi_vnodeops.c @@ -153,10 +153,17 @@ darwin_vn_hold(struct vnode *vp) ourselves during vop_inactive, except we also need to not reinst the ubc... so we just call VREF there now anyway. */ +#ifdef AFS_DARWIN80_ENV + if (vnode_isinuse(vp)) + vnode_ref(vp); + else + vnode_get(vp); +#else if (VREFCOUNT(tvc) > 0) VREF(((struct vnode *)(vp))); else afs_vget(afs_globalVFS, 0, (vp)); +#endif if (UBCINFOMISSING(vp) || UBCINFORECLAIMED(vp)) { ubc_info_init(vp); diff --git a/src/afs/VNOPS/afs_vnop_lookup.c b/src/afs/VNOPS/afs_vnop_lookup.c index c82496a47..271b639e3 100644 --- a/src/afs/VNOPS/afs_vnop_lookup.c +++ b/src/afs/VNOPS/afs_vnop_lookup.c @@ -1177,9 +1177,15 @@ afs_lookup(OSI_VC_DECL(adp), char *aname, struct vcache **avcp, struct AFS_UCRED *avcp = tvc; code = (tvc ? 0 : ENOENT); hit = 1; +#ifdef AFS_DARWIN80_ENV + if (tvc && !vnode_isinuse(AFSTOV(tvc))) { + osi_Panic("TT1"); + } +#else if (tvc && !VREFCOUNT(tvc)) { osi_Panic("TT1"); } +#endif if (code) { /*printf("LOOKUP GETVCDOTDOT -> %d\n", code); */ } @@ -1213,9 +1219,15 @@ afs_lookup(OSI_VC_DECL(adp), char *aname, struct vcache **avcp, struct AFS_UCRED code = 0; *avcp = tvc = adp; hit = 1; +#ifdef AFS_DARWIN80_ENV + if (adp && !vnode_isinuse(AFSTOV(adp))) { + osi_Panic("TT2"); + } +#else if (adp && !VREFCOUNT(adp)) { osi_Panic("TT2"); } +#endif goto done; } @@ -1497,9 +1509,15 @@ afs_lookup(OSI_VC_DECL(adp), char *aname, struct vcache **avcp, struct AFS_UCRED } } *avcp = tvc; +#ifdef AFS_DARWIN80_ENV + if (tvc && !vnode_isinuse(AFSTOV(tvc))) { + osi_Panic("TT3"); + } +#else if (tvc && !VREFCOUNT(tvc)) { osi_Panic("TT3"); } +#endif code = 0; } else { /* if we get here, we found something in a directory that couldn't diff --git a/src/afs/VNOPS/afs_vnop_remove.c b/src/afs/VNOPS/afs_vnop_remove.c index 301e4e936..8a6323120 100644 --- a/src/afs/VNOPS/afs_vnop_remove.c +++ b/src/afs/VNOPS/afs_vnop_remove.c @@ -366,11 +366,14 @@ afs_remove(OSI_VC_ARG(adp), aname, acred) afs_symhint_inval(tvc); Tadp1 = adp; +#ifndef AFS_DARWIN80_ENV Tadpr = VREFCOUNT(adp); +#endif Ttvc = tvc; Tnam = aname; Tnam1 = 0; if (tvc) +#ifndef AFS_DARWIN80_ENV Ttvcr = VREFCOUNT(tvc); #ifdef AFS_AIX_ENV if (tvc && (VREFCOUNT(tvc) > 2) && tvc->opens > 0 @@ -378,6 +381,10 @@ afs_remove(OSI_VC_ARG(adp), aname, acred) #else if (tvc && (VREFCOUNT(tvc) > 1) && tvc->opens > 0 && !(tvc->states & CUnlinked)) +#endif +#else + if (tvc && (vnode_isinuse(AFSTOV(tvc))) && tvc->opens > 0 + && !(tvc->states & CUnlinked)) #endif { char *unlname = afs_newname(); diff --git a/src/afs/afs.h b/src/afs/afs.h index 0205b758b..ab81b9b0a 100644 --- a/src/afs/afs.h +++ b/src/afs/afs.h @@ -595,7 +595,11 @@ extern afs_uint32 afs_stampValue; /* stamp for pair's usage */ #define MakeStamp() (++afs_stampValue) #if defined(AFS_XBSD_ENV) || defined(AFS_DARWIN_ENV) +#ifdef AFS_DARWIN80_ENV +#define VTOAFS(v) ((struct vcache *)vnode_fsnode((v))) +#else #define VTOAFS(v) ((struct vcache *)(v)->v_data) +#endif #define AFSTOV(vc) ((vc)->v) #else #define VTOAFS(V) ((struct vcache *)(V)) @@ -658,8 +662,12 @@ struct vcache { int ownslock; /* pid of owner of excl lock, else 0 - defect 3083 */ #endif #ifdef AFS_DARWIN_ENV +#ifdef AFS_DARWIN80_ENV + lck_mtx_t *rwlock; +#else struct lock__bsd__ rwlock; #endif +#endif #ifdef AFS_XBSD_ENV struct lock rwlock; #endif diff --git a/src/afs/afs_callback.c b/src/afs/afs_callback.c index bc044c252..9bc96530e 100644 --- a/src/afs/afs_callback.c +++ b/src/afs/afs_callback.c @@ -151,7 +151,11 @@ SRXAFSCB_GetCE(struct rx_call *a_call, afs_int32 a_index, a_result->DataVersion = hgetlo(tvc->m.DataVersion); a_result->callback = afs_data_pointer_to_int32(tvc->callback); /* XXXX Now a pointer; change it XXXX */ a_result->cbExpires = tvc->cbExpires; +#ifdef AFS_DARWIN80_ENV + a_result->refCount = vnode_isinuse(AFSTOV(tvc))?1:0; /* XXX fix */ +#else a_result->refCount = VREFCOUNT(tvc); +#endif a_result->opens = tvc->opens; a_result->writers = tvc->execsOrWriters; a_result->mvstat = tvc->mvstat; @@ -230,7 +234,11 @@ SRXAFSCB_GetCE64(struct rx_call *a_call, afs_int32 a_index, a_result->DataVersion = hgetlo(tvc->m.DataVersion); a_result->callback = afs_data_pointer_to_int32(tvc->callback); /* XXXX Now a pointer; change it XXXX */ a_result->cbExpires = tvc->cbExpires; +#ifdef AFS_DARWIN80_ENV + a_result->refCount = vnode_isinuse(AFSTOV(tvc))?1:0; /* XXX fix */ +#else a_result->refCount = VREFCOUNT(tvc); +#endif a_result->opens = tvc->opens; a_result->writers = tvc->execsOrWriters; a_result->mvstat = tvc->mvstat; diff --git a/src/afs/afs_osi.c b/src/afs/afs_osi.c index 3ea337ace..344391393 100644 --- a/src/afs/afs_osi.c +++ b/src/afs/afs_osi.c @@ -60,7 +60,9 @@ osi_Init(void) #elif defined(AFS_FBSD50_ENV) mtx_init(&afs_global_mtx, "AFS global lock", NULL, MTX_DEF); #elif defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV) +#if !defined(AFS_DARWIN80_ENV) lockinit(&afs_global_lock, PLOCK, "afs global lock", 0, 0); +#endif afs_global_owner = 0; #elif defined(AFS_AIX41_ENV) lock_alloc((void *)&afs_global_lock, LOCK_ALLOC_PIN, 1, 1); diff --git a/src/afs/afs_prototypes.h b/src/afs/afs_prototypes.h index 1fc969e13..f2e9e0e49 100644 --- a/src/afs/afs_prototypes.h +++ b/src/afs/afs_prototypes.h @@ -532,7 +532,9 @@ extern int afsio_skip(struct uio *auio, afs_int32 asize); /* ARCH/osi_misc.c */ +#ifdef AFS_LINUX20_ENV extern void osi_iput(struct inode *ip); +#endif extern void afs_osi_SetTime(osi_timeval_t * atv); /* LINUX/osi_misc.c */ diff --git a/src/afs/afs_util.c b/src/afs/afs_util.c index 0d6e37c99..bdca1dc7c 100644 --- a/src/afs/afs_util.c +++ b/src/afs/afs_util.c @@ -273,7 +273,11 @@ afs_CheckLocks(void) #ifdef AFS_OSF_ENV if (VREFCOUNT(tvc) > 1) #else /* AFS_OSF_ENV */ +#ifdef AFS_DARWIN80_ENV + if (vnode_isinuse(AFSTOV(tvc))) +#else if (VREFCOUNT(tvc)) +#endif #endif afs_warn("Stat cache entry at %x is held\n", tvc); if (CheckLock(&tvc->lock)) diff --git a/src/afs/afs_vcache.c b/src/afs/afs_vcache.c index 820de0263..5f6040d55 100644 --- a/src/afs/afs_vcache.c +++ b/src/afs/afs_vcache.c @@ -231,7 +231,11 @@ afs_FlushVCache(struct vcache *avc, int *slept) /* This should put it back on the vnode free list since usecount is 1 */ afs_vcount--; vSetType(avc, VREG); +#ifdef AFS_DARWIN80_ENV + if (vnode_isinuse(AFSTOV(avc))) { +#else if (VREFCOUNT(avc) > 0) { +#endif VN_UNLOCK(AFSTOV(avc)); AFS_RELE(AFSTOV(avc)); } else { @@ -615,10 +619,19 @@ afs_NewVCache(struct VenusFid *afid, struct server *serverp) refpanic("Exceeded pool of AFS vnodes(VLRU cycle?)"); else if (QNext(uq) != tq) refpanic("VLRU inconsistent"); +#ifdef AFS_DARWIN80_ENV + else if (!vnode_isinuse(AFSTOV(tvc))) +#else else if (VREFCOUNT(tvc) < 1) +#endif refpanic("refcnt 0 on VLRU"); - if (VREFCOUNT(tvc) == 1 && tvc->opens == 0 +#ifdef AFS_DARWIN80_ENV + if (vnode_isinuse(AFSTOV(tvc)) && +#else + if (VREFCOUNT(tvc) == 1 && +#endif + tvc->opens == 0 && (tvc->states & CUnlinkedDel) == 0) { code = afs_FlushVCache(tvc, &fv_slept); if (code == 0) { @@ -711,10 +724,14 @@ restart: } #endif +#ifdef AFS_DARWIN80_ENV + if (!vnode_isinuse(AFSTOV(tvc) +#else if (((VREFCOUNT(tvc) == 0) #if defined(AFS_DARWIN_ENV) && !defined(UKERNEL) || ((VREFCOUNT(tvc) == 1) && (UBCINFOEXISTS(AFSTOV(tvc)))) +#endif #endif ) && tvc->opens == 0 && (tvc->states & CUnlinkedDel) == 0) { #if defined (AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV) @@ -807,8 +824,12 @@ restart: AFS_GUNLOCK(); afs_darwin_getnewvnode(tvc); /* includes one refcount */ AFS_GLOCK(); +#ifdef AFS_DARWIN80_ENV + LOCKINIT(tvc->rwlock); +#else lockinit(&tvc->rwlock, PINOD, "vcache", 0, 0); #endif +#endif #ifdef AFS_FBSD_ENV { struct vnode *vp; diff --git a/src/afs/lock.h b/src/afs/lock.h index a5d8253d7..80e3b7923 100644 --- a/src/afs/lock.h +++ b/src/afs/lock.h @@ -107,7 +107,11 @@ extern tid_t thread_self(); #define MyPidxx current->pid #else #if defined(AFS_DARWIN_ENV) +#if defined(AFS_DARWIN80_ENV) +#define MyPidxx (proc_selfpid()) +#else #define MyPidxx (current_proc()->p_pid ) +#endif #else #if defined(AFS_FBSD_ENV) #define MyPidxx (curproc->p_pid ) diff --git a/src/afs/sysincludes.h b/src/afs/sysincludes.h index 33c049db6..ade3cdc77 100644 --- a/src/afs/sysincludes.h +++ b/src/afs/sysincludes.h @@ -214,7 +214,7 @@ typedef unsigned short etap_event_t; # include "h/dir.h" #endif /* SGI || SUN || HPUX */ -#if !defined(AFS_SGI64_ENV) && !defined(AFS_FBSD_ENV) +#if !defined(AFS_SGI64_ENV) && !defined(AFS_FBSD_ENV) && !defined(AFS_DARWIN80_ENV) #include "h/user.h" #endif /* AFS_SGI64_ENV */ #define MACH_USER_API 1 @@ -251,7 +251,11 @@ struct vop_getwritemount_args; # include # include # include +#ifdef AFS_DARWIN80_ENV +# include +#else # include +#endif # include # include #ifndef AFS_FBSD_ENV @@ -271,9 +275,11 @@ MALLOC_DECLARE(M_AFS); #undef timeout_fcn_t #define _DIR_H_ #define doff_t int32_t +#ifndef AFS_DARWIN80_ENV # include # include # include +#endif #else # include "h/vfs.h" # include "h/vnode.h" diff --git a/src/rx/DARWIN/rx_kmutex.c b/src/rx/DARWIN/rx_kmutex.c index f4c7f7bb3..e7514eea7 100644 --- a/src/rx/DARWIN/rx_kmutex.c +++ b/src/rx/DARWIN/rx_kmutex.c @@ -19,6 +19,26 @@ RCSID ("$Header$"); +#ifndef AFS_DARWIN80_ENV /* * Currently everything is implemented in rx_kmutex.h */ +#else +lck_grp_t * openafs_lck_grp; +static lck_grp_attr_t * openafs_lck_grp_attr; +void rx_kmutex_setup(void) { + openafs_lck_grp_attr= lck_grp_attr_alloc_init(); + lck_grp_attr_setstat(openafs_lck_grp_attr); + + openafs_lck_grp = lck_grp_alloc_init("openafs", openafs_lck_grp_attr); + lck_grp_attr_free(openafs_lck_grp_attr); + +} + +void rx_kmutex_finish(void) { + lck_grp_free(openafs_lck_grp); +} + +#endif + + diff --git a/src/rx/DARWIN/rx_kmutex.h b/src/rx/DARWIN/rx_kmutex.h index 563c3a2a1..92275d03d 100644 --- a/src/rx/DARWIN/rx_kmutex.h +++ b/src/rx/DARWIN/rx_kmutex.h @@ -82,13 +82,58 @@ #define CV_BROADCAST(cv) thread_wakeup((event_t)(cv)) #endif +#ifdef AFS_DARWIN80_ENV typedef struct { - struct lock__bsd__ lock; + lck_mtx_t *lock; thread_t owner; } afs_kmutex_t; typedef int afs_kcondvar_t; -#define osi_rxWakeup(cv) thread_wakeup((event_t)(cv)) +extern lck_grp_t * openafs_lck_grp; + +#define MUTEX_SETUP() rx_kmutex_setup() +#define MUTEX_FINISH() rx_kmutex_finish() +#define LOCKINIT(a) \ + do { \ + lck_attr_t * openafs_lck_attr = lck_attr_alloc_init(); \ + (a) = lck_mtx_alloc_init(openafs_lck_grp, openafs_lck_attr); \ + lck_attr_free(openafs_lck_attr); \ + } while(0); +#define MUTEX_INIT(a,b,c,d) \ + do { \ + lck_attr_t * openafs_lck_attr = lck_attr_alloc_init(); \ + (a)->lock = lck_mtx_alloc_init(openafs_lck_grp, openafs_lck_attr); \ + lck_attr_free(openafs_lck_attr); \ + (a)->owner = (thread_t)0; \ + } while(0); +#define MUTEX_DESTROY(a) \ + do { \ + lck_mtx_destroy((a)->lock, openafs_lck_grp); \ + (a)->owner = (thread_t)-1; \ + } while(0); +#define MUTEX_ENTER(a) \ + do { \ + lck_mtx_lock(&(a)->lock); \ + osi_Assert((a)->owner == (thread_t)0); \ + (a)->owner = current_thread(); \ + } while(0); +#define MUTEX_TRYENTER(a) \ + (lck_mtx_try_lock(&(a)->lock) ? ((a)->owner = current_thread(), 1) : 0) +#define MUTEX_EXIT(a) \ + do { \ + osi_Assert((a)->owner == current_thread()); \ + (a)->owner = (thread_t)0; \ + lck_mtx_unlock(&(a)->lock); \ + } while(0); + +#undef MUTEX_ISMINE +#define MUTEX_ISMINE(a) (((afs_kmutex_t *)(a))->owner == current_thread()) +#else +typedef struct { + struct lock__bsd__ lock; + thread_t owner; +} afs_kmutex_t; +typedef int afs_kcondvar_t; #define LOCK_INIT(a,b) \ do { \ @@ -112,8 +157,6 @@ typedef int afs_kcondvar_t; } while(0); #define MUTEX_TRYENTER(a) \ ( lockmgr(&(a)->lock, LK_EXCLUSIVE|LK_NOWAIT, 0, current_proc()) ? 0 : ((a)->owner = current_thread(), 1) ) -#define xMUTEX_TRYENTER(a) \ - ( osi_Assert((a)->owner == (thread_t)0), (a)->owner = current_thread(), 1) #define MUTEX_EXIT(a) \ do { \ osi_Assert((a)->owner == current_thread()); \ @@ -123,6 +166,7 @@ typedef int afs_kcondvar_t; #undef MUTEX_ISMINE #define MUTEX_ISMINE(a) (((afs_kmutex_t *)(a))->owner == current_thread()) +#endif #undef osirx_AssertMine extern void osirx_AssertMine(afs_kmutex_t * lockaddr, char *msg); diff --git a/src/rx/xdr_prototypes.h b/src/rx/xdr_prototypes.h index 8d0870eae..5c1898ee3 100644 --- a/src/rx/xdr_prototypes.h +++ b/src/rx/xdr_prototypes.h @@ -10,13 +10,7 @@ #ifndef _XDR_PROTOTYPES_H #define _XDR_PROTOTYPES_H -/* I don't like this, but some of these defs depend on rx.h */ -#if defined(KERNEL) && defined(UKERNEL) -#include "afs/sysincludes.h" -#include "rx/rx.h" -#else -#include "rx/rx.h" -#endif +struct rx_call; /* xdr_afsuuid.c */ extern int xdr_afsUUID(XDR * xdrs, afsUUID * objp); -- 2.39.5