From 3cc1ea60a32f5008873450da36f1ead5bd8c07b5 Mon Sep 17 00:00:00 2001
From: Hartmut Reuter <reuter@rzg.mpg.de>
Date: Thu, 26 Sep 2002 08:01:05 +0000
Subject: [PATCH] aix51-support-20020926

aix 5.1 support, not yet ready for prime-time
---
 Makefile.in                     |   6 +-
 src/afs/AIX/osi_config.c        |   2 +
 src/afs/AIX/osi_groups.c        |  19 ++-
 src/afs/AIX/osi_vfsops.c        |   4 +
 src/afs/AIX/osi_vnodeops.c      | 309 ++++++++++++++++++++++++++++++++++------
 src/afs/LINUX/osi_vnodeops.c    |   4 +
 src/afs/VNOPS/afs_vnop_attrs.c  |  18 +++
 src/afs/VNOPS/afs_vnop_read.c   |  30 +++-
 src/afs/VNOPS/afs_vnop_write.c  |  17 +++
 src/afs/afs.h                   |   8 ++
 src/afs/afs_daemons.c           |   2 +-
 src/afs/afs_dcache.c            |  47 +++---
 src/afs/afs_init.c              |  18 ++-
 src/afs/afs_osi.c               |  32 +++++
 src/afs/afs_osi_pag.c           |  11 ++
 src/afs/afs_pioctl.c            |  26 ++++
 src/afs/afs_trace.et            |   9 +-
 src/afs/sysincludes.h           |   3 +
 src/cf/osconf.m4                |  15 ++
 src/comerr/compile_et.c         |   4 +
 src/config/afs_sysnames.h       |   2 +
 src/export/Makefile.in          |  11 +-
 src/export/cfgexport.c          |   2 +-
 src/export/export.c             |  17 ++-
 src/libafs/MakefileProto.AIX.in |   8 +-
 src/rx/rx_getaddr.c             |  23 ++-
 src/rx/rx_kcommon.c             |  26 +++-
 src/rx/rx_kernel.h              |  10 ++
 src/tsm41/aix41_auth.c          |  42 +++++-
 src/util/snprintf.c             |   8 ++
 src/vol/fssync.c                |   4 +-
 src/vol/volume.c                |   2 +-
 src/vol/volume.h                |   2 +-
 src/volser/volprocs.c           |   8 +-
 34 files changed, 653 insertions(+), 96 deletions(-)

diff --git a/Makefile.in b/Makefile.in
index 94a4b6e..ac9ac41 100644
--- a/Makefile.in
+++ b/Makefile.in
@@ -258,7 +258,7 @@ bozo: project ntp audit
 vfsck:	vol
 	set -x; \
 	case ${SYS_NAME} in \
-	sgi_* | *linux* | rs_aix42 | ppc_darwin* | hp_ux* | *fbsd* | *_obsd* | *_nbsd* | sun*_4* ) \
+	sgi_* | *linux* | rs_aix42 | ppc_darwin* | hp_ux* | *fbsd* | *_obsd* | *_nbsd* | sun*_4* | rs_aix5* ) \
 		echo skip vfsck for ${SYS_NAME} ;; \
 	 * ) \
 		${COMPILE_PART1} vfsck ${COMPILE_PART2} ;; \
@@ -269,7 +269,7 @@ login: project kauth rxkad
 	case ${SYS_NAME} in \
 	sgi_* ) \
 		${COMPILE_PART1} sgistuff ${COMPILE_PART2} ;; \
-	rs_aix42 ) \
+	rs_aix42 | rs_aix51 ) \
 		${COMPILE_PART1} tsm41 ${COMPILE_PART2} ;; \
 	alpha_dux* ) \
 		${COMPILE_PART1} sia ${COMPILE_PART2} ;; \
@@ -279,7 +279,7 @@ login: project kauth rxkad
 		echo Skipping pam/login for parisc_linux24 ;; \
 	sun4x_* | sunx86_* | hp_ux11* | *linux* | *fbsd* ) \
 		${COMPILE_PART1} pam ${COMPILE_PART2} ;; \
-	ppc_darwin* | *_obsd* | *_nbsd* | hp_ux* ) \
+	ppc_darwin* | *_obsd* | *_nbsd* | hp_ux* | rs_aix5* ) \
 		echo Skipping login for ${SYS_NAME} ;; \
 	* ) \
 		${COMPILE_PART1} login ${COMPILE_PART2} ;; \
diff --git a/src/afs/AIX/osi_config.c b/src/afs/AIX/osi_config.c
index 3800846..4708ac0 100644
--- a/src/afs/AIX/osi_config.c
+++ b/src/afs/AIX/osi_config.c
@@ -260,7 +260,9 @@ struct k_var kvars[] = {
 	{ (void *) &vnodefops,		"vnodefops"		},
 	{ (void *) &ifnet,		"ifnet"			},
  	{ (void *) &jfs_icache_lock,	"jfs_icache_lock"	},
+#ifndef AFS_AIX51_ENV
  	{ (void *) &proc_tbl_lock,	"proc_tbl_lock"		},
+#endif
 	{ 0,				0			},
 };
 
diff --git a/src/afs/AIX/osi_groups.c b/src/afs/AIX/osi_groups.c
index c998e39..4892e51 100644
--- a/src/afs/AIX/osi_groups.c
+++ b/src/afs/AIX/osi_groups.c
@@ -36,6 +36,7 @@ afs_setgroups(
     gid_t *gidset,
     int change_parent);
 
+#ifndef AFS_AIX5_ENV
 int
 setgroups(ngroups, gidset)
     int ngroups;
@@ -77,7 +78,7 @@ setgroups(ngroups, gidset)
     }
     return code;
 }
-
+#endif
 
 int
 setpag(cred, pagvalue, newpag, change_parent)
@@ -91,6 +92,7 @@ setpag(cred, pagvalue, newpag, change_parent)
     int j;
 
     AFS_STATCNT(setpag);
+#ifndef AFS_AIX51_ENV
     ngroups = afs_getgroups(*cred, NGROUPS, gidset);
     if (afs_get_pag_from_groups(gidset[0], gidset[1]) == NOPAG) {
 	/* We will have to shift grouplist to make room for pag */
@@ -102,15 +104,29 @@ setpag(cred, pagvalue, newpag, change_parent)
  	}
 	ngroups += 2;
     }
+#endif
     *newpag = (pagvalue == -1 ? genpag(): pagvalue);
+#ifdef AFS_AIX51_ENV
+    if (change_parent) {
+	code = kcred_setpag(*cred, PAG_AFS, *newpag);
+    } else {
+	struct ucred *newcr = crdup(*cred);
+
+	crset(newcr);
+	code = kcred_setpag(newcr, PAG_AFS, *newpag);
+	*cred = newcr;
+    }
+#else
     afs_get_groups_from_pag(*newpag, &gidset[0], &gidset[1]);
     if (code = afs_setgroups(cred, ngroups, gidset, change_parent)) {
 	return (setuerror(code), code);
     }
+#endif
     return code;
 }
 
 
+#ifndef AFS_AIX51_ENV
 static int
 afs_getgroups(
     struct ucred *cred,
@@ -198,3 +214,4 @@ afs_setgroups(
     }
     return 0;
 }
+#endif
diff --git a/src/afs/AIX/osi_vfsops.c b/src/afs/AIX/osi_vfsops.c
index 12c3f39..ac1770f 100644
--- a/src/afs/AIX/osi_vfsops.c
+++ b/src/afs/AIX/osi_vfsops.c
@@ -58,6 +58,7 @@ static int afs_mount(afsp, path, data)
 
     afs_globalVFS = afsp;
     afsp->vfs_bsize = 8192;
+    afsp->vfs_count = 0;
 #ifdef AFS_64BIT_CLIENT
     afsp->vfs_flag |= VFS_DEVMOUNT;
 #endif /* AFS_64BIT_CLIENT */
@@ -236,6 +237,9 @@ struct vfsops Afs_vfsops = {
 	afs_vget,
 	afs_badop,	/* vfs_cntl */
 	afs_badop	/* vfs_quotactl */
+#ifdef AFS_AIX51_ENV
+	,afs_badop	/* vfs_syncvfs */
+#endif
 };
 
 /*
diff --git a/src/afs/AIX/osi_vnodeops.c b/src/afs/AIX/osi_vnodeops.c
index 93f7fe2..63330be 100644
--- a/src/afs/AIX/osi_vnodeops.c
+++ b/src/afs/AIX/osi_vnodeops.c
@@ -24,6 +24,9 @@ RCSID("$Header$");
 #include "../h/chownx.h"
 #include "../h/systm.h"
 #include "../h/access.h"
+#ifdef AFS_AIX51_ENV
+#include "../h/acl.h"
+#endif
 #include "../rpc/types.h"
 #include "../afs/osi_vfs.h"
 #include "../netinet/in.h"
@@ -146,13 +149,13 @@ struct vnodeops afs_gn_vnodeops = {
 	afs_gn_getpcl,
 	afs_gn_setpcl,
 	afs_gn_enosys,	/* vn_seek */
-	afs_gn_enosys,	/* vn_spare0 */
-	afs_gn_enosys,	/* vn_spare1 */
-	afs_gn_enosys,	/* vn_spare2 */
-	afs_gn_enosys,	/* vn_spare3 */
-	afs_gn_enosys,	/* vn_spare4 */
-	afs_gn_enosys,	/* vn_spare5 */
-	afs_gn_enosys,	/* vn_spare6 */
+	afs_gn_enosys,	/* vn_fsync_range */
+	afs_gn_enosys,	/* vn_create_attr */
+	afs_gn_enosys,	/* vn_finfo */ 
+	afs_gn_enosys,	/* vn_map_lloff */
+	afs_gn_enosys,	/* vn_readdir_eofp */
+	afs_gn_enosys,	/* vn_rdwr_attr */
+	afs_gn_enosys,	/* vn_memcntl */
 	afs_gn_enosys,	/* vn_spare7 */
 	afs_gn_enosys,	/* vn_spare8 */
 	afs_gn_enosys,	/* vn_spare9 */
@@ -162,6 +165,13 @@ struct vnodeops afs_gn_vnodeops = {
 	afs_gn_enosys,	/* vn_spareD */
 	afs_gn_enosys,	/* vn_spareE */
 	afs_gn_enosys	/* vn_spareF */
+#ifdef AFS_AIX51_ENV
+	,afs_gn_enosys, /* pagerBackRange */
+ 	afs_gn_enosys,  /* pagerGetFileSize */
+	afs_gn_enosys,  /* pagerReadAhead */
+	afs_gn_enosys,  /* pagerWriteBehind */
+	afs_gn_enosys   /* pagerEndCopy */
+#endif
 };
 struct vnodeops *afs_ops = &afs_gn_vnodeops;
 
@@ -184,15 +194,20 @@ struct ucred	*cred;
 
 
 int
-afs_gn_mkdir(dp, name, mode, cred)
+afs_gn_mkdir(dp, name, Mode, cred)
 struct	vnode	*dp;
 char		*name;
-int		mode;
+#ifdef AFS_AIX51_ENV
+int32long64_t	Mode;
+#else
+int		Mode;
+#endif
 struct ucred	*cred;
 {
     struct	vattr	va;
     struct	vnode	*vp;
     int		error;
+    int 	mode = Mode;
 
     AFS_STATCNT(afs_gn_mkdir);
     VATTR_NULL(&va);
@@ -209,16 +224,21 @@ struct ucred	*cred;
 
 
 int
-afs_gn_mknod(dp, name, mode, dev, cred)
+afs_gn_mknod(dp, name, Mode, dev, cred)
 struct	vnode	*dp;
 char		*name;
-int		mode;
+#ifdef AFS_AIX51_ENV
+int		Mode;
+#else
+int		Mode;
+#endif
 dev_t		dev;
 struct ucred	*cred;
 {
     struct	vattr	va;
     struct	vnode	*vp;
     int		error;
+    int 	mode = Mode;
 
     AFS_STATCNT(afs_gn_mknod);
     VATTR_NULL(&va);
@@ -310,15 +330,20 @@ struct ucred	*cred;
 
 
 int
-afs_gn_lookup(dp, vpp, name, flags, vattrp, cred)
+afs_gn_lookup(dp, vpp, name, Flags, vattrp, cred)
 struct	vattr	*vattrp;
 struct	vnode	*dp;
 struct	vnode	**vpp;
 char		*name;
-afs_uint32         flags;  /* includes FOLLOW... */
+#ifdef AFS_AIX51_ENV
+int32long64_t      Flags;  /* includes FOLLOW... */
+#else
+afs_uint32         Flags;  /* includes FOLLOW... */
+#endif
 struct ucred	*cred;
 {
    int		error;
+   int		flags = Flags;
 
    AFS_STATCNT(afs_gn_lookup);
     error = afs_lookup(dp, name, vpp, cred);
@@ -347,10 +372,15 @@ struct ucred	*cred;
 
 
 int
-afs_gn_open(vp, flags, ext, vinfop, cred)
+afs_gn_open(vp, Flags, ext, vinfop, cred)
 struct	vnode	*vp;
-int		flags;
+#ifdef AFS_AIX51_ENV
+int32long64_t	Flags;
+ext_t		ext;		/* Ignored in AFS */
+#else
+int		Flags;
 int		ext;		/* Ignored in AFS */
+#endif
 struct ucred	**vinfop;	/* return ptr for fp->f_vinfo, used as fp->f_cred */
 struct ucred	*cred;
 {
@@ -358,6 +388,7 @@ struct ucred	*cred;
     struct vattr	va;
     struct vcache *tvp = VTOAFS(vp);
     afs_int32 modes;
+    int 	flags = Flags;
 
     AFS_STATCNT(afs_gn_open);
     modes = 0;
@@ -410,18 +441,25 @@ abort:
 
 
 int
-afs_gn_create(dp, vpp, flags, name, mode, vinfop, cred)
+afs_gn_create(dp, vpp, Flags, name, Mode, vinfop, cred)
 struct	vnode	*dp;
 struct	vnode	**vpp;
-int		flags;
 char		*name;
-int		mode;
+#ifdef AFS_AIX51_ENV
+int32long64_t	Flags;
+int32long64_t	Mode;
+#else
+int		Flags;
+int		Mode;
+#endif
 struct ucred	**vinfop; /* return ptr for fp->f_vinfo, used as fp->f_cred */
 struct ucred	*cred;
 {
     struct	vattr	va;
     enum	vcexcl	exclusive;
     int		error, modes=0;
+    int 	flags = Flags;
+    int 	mode = Mode;
 
     AFS_STATCNT(afs_gn_create);
     if ((flags & (O_EXCL|O_CREAT)) == (O_EXCL|O_CREAT))
@@ -496,14 +534,19 @@ struct	vnode	*vp;
 
 
 int
-afs_gn_close(vp, flags, vinfo, cred)
+afs_gn_close(vp, Flags, vinfo, cred)
 struct	vnode	*vp;
-int		flags;
+#ifdef AFS_AIX51_ENV
+int32long64_t	Flags;
+#else
+int		Flags;
+#endif
 caddr_t		vinfo;		/* Ignored in AFS */
 struct ucred	*cred;
 {
     int		error;
     struct vcache *tvp = VTOAFS(vp);
+    int 	flags = Flags;
 
     AFS_STATCNT(afs_gn_close);
 
@@ -520,15 +563,23 @@ struct ucred	*cred;
 
 
 int
-afs_gn_map(vp, addr, len, off, flag, cred)
+afs_gn_map(vp, addr, Len, Off, Flag, cred)
 struct	vnode	*vp;
 caddr_t		addr;
-u_int 		len, off, flag;
+#ifdef AFS_AIX51_ENV
+uint32long64_t  Len, Off, Flag;
+#else
+u_int 		Len, Off, Flag;
+#endif
 struct ucred	*cred;
 {
     struct vcache *vcp = VTOAFS(vp);
     struct vrequest treq;
     afs_int32 error;
+    afs_int32 len = Len;
+    afs_int32 off = Off;
+    afs_int32 flag = Flag;
+
     AFS_STATCNT(afs_gn_map);
 #ifdef	notdef
     if (error = afs_InitReq(&treq, cred)) return error;
@@ -581,7 +632,11 @@ struct ucred	*cred;
 int
 afs_gn_unmap(vp, flag, cred)
 struct	vnode	*vp;
+#ifdef AFS_AIX51_ENV
+int32long64_t	flag;
+#else
 int 		flag;
+#endif
 struct ucred	*cred;
 {
     struct vcache *vcp = VTOAFS(vp);
@@ -603,18 +658,27 @@ struct ucred	*cred;
 
 
 int
-afs_gn_access(vp, mode, who, cred)
+afs_gn_access(vp, Mode, Who, cred)
 struct	vnode		*vp;
-int			mode;
-int			who;
+#ifdef AFS_AIX51_ENV
+int32long64_t		Mode;
+int32long64_t		Who;
+#else
+int			Mode;
+int			Who;
+#endif
 struct ucred		*cred;
 {
     int	error;
     struct vattr vattr;
+    int mode = Mode;
+    int who = Who;
 
     AFS_STATCNT(afs_gn_access);
-    if (mode & ~0x7)
-	return(EINVAL);
+    if (mode & ~0x7) {
+	error = EINVAL;
+	goto out;
+    }
 
     error = afs_access(vp, mode, cred);
     if (!error) {
@@ -669,16 +733,27 @@ struct ucred	*cred;
 
 
 int
-afs_gn_setattr(vp, op, arg1, arg2, arg3, cred)
+afs_gn_setattr(vp, Op, Arg1, Arg2, Arg3, cred)
 struct	vnode	*vp;
-int		op;
-int		arg1;
-int		arg2;
-int		arg3;
+#ifdef AFS_AIX51_ENV
+int32long64_t	Op;
+int32long64_t	Arg1;
+int32long64_t	Arg2;
+int32long64_t	Arg3;
+#else
+int		Op;
+int		Arg1;
+int		Arg2;
+int		Arg3;
+#endif
 struct ucred	*cred;
 {
     struct	vattr	va;
     int		error = 0;
+    int		op = Op;
+    int		arg1 = Arg1;
+    int		arg2 = Arg2;
+    int		arg3 = Arg3;
 
    AFS_STATCNT(afs_gn_setattr);
     VATTR_NULL(&va);
@@ -697,7 +772,7 @@ struct ucred	*cred;
 #ifdef	notdef
 	    error = afs_access(vp, VWRITE, cred);
 	    if (error) 
-		return(error);
+		goto out;
 #endif
 	    if (arg1 & T_SETTIME) {
 		va.va_atime.tv_sec = time;
@@ -708,10 +783,12 @@ struct ucred	*cred;
 	    }
 	    break;
 	default:
-	    return(EINVAL);
+	    error = EINVAL;
+	    goto out;
     }
 
     error = afs_setattr(vp, &va, cred);
+out:
     afs_Trace2(afs_iclSetp, CM_TRACE_GSETATTR, ICL_TYPE_POINTER, (afs_int32)vp,
 	       ICL_TYPE_LONG, error);
     return(error);
@@ -722,7 +799,11 @@ char zero_buffer[PAGESIZE];
 int
 afs_gn_fclear(vp, flags, offset, length, vinfo, cred) 
 struct	vnode	*vp;
+#ifdef AFS_AIX51_ENV
+int32long64_t	flags;
+#else
 int		flags;
+#endif
 offset_t	offset;
 offset_t	length;
 caddr_t		vinfo;
@@ -773,8 +854,13 @@ struct ucred	*cred;
 int
 afs_gn_fsync(vp, flags, vinfo, cred)
 struct	vnode	*vp;
+#ifdef AFS_AIX51_ENV
+int32long64_t	flags;	    /* Not used by AFS */
+int32long64_t	vinfo;	    /* Not used by AFS */
+#else
 int		flags;	    /* Not used by AFS */
 caddr_t		vinfo;	    /* Not used by AFS */
+#endif
 struct ucred	*cred;
 {
    int		error;
@@ -790,7 +876,11 @@ struct ucred	*cred;
 int
 afs_gn_ftrunc(vp, flags, length, vinfo, cred)
 struct	vnode	*vp;
+#ifdef AFS_AIX51_ENV
+int32long64_t	flags;	    /* Ignored in AFS */
+#else
 int		flags;	    /* Ignored in AFS */
+#endif
 offset_t	length;
 caddr_t		vinfo;	    /* Ignored in AFS */
 struct ucred	*cred;
@@ -812,12 +902,17 @@ struct ucred	*cred;
 /* Min size of a file which is dumping core before we declare it a page hog. */
 #define MIN_PAGE_HOG_SIZE 8388608
 
-int afs_gn_rdwr(vp, op, flags, ubuf, ext, vinfo, vattrp, cred)
+int afs_gn_rdwr(vp, op, Flags, ubuf, ext, vinfo, vattrp, cred)
 struct	vnode	*vp;
 enum	uio_rw	op;
-int		flags;
-struct	uio	*ubuf;
+#ifdef AFS_AIX51_ENV
+int32long64_t	Flags;
+ext_t		ext;	    /* Ignored in AFS */
+#else
+int		Flags;
 int		ext;	    /* Ignored in AFS */
+#endif
+struct	uio	*ubuf;
 caddr_t		vinfo;	    /* Ignored in AFS */
 struct	vattr	*vattrp;
 struct ucred	*cred;
@@ -826,6 +921,7 @@ struct ucred	*cred;
     struct vrequest treq;
     int error=0;
     int free_cred = 0;
+    int flags = Flags;
 
     AFS_STATCNT(afs_gn_rdwr);
 
@@ -1142,6 +1238,8 @@ afs_vm_rdwr(vp, uiop, rw, ioflag, credp)
 	     */
 	    if (counter > 0 && code == 0 && xfrOffset == offset) {
 		ObtainWriteLock(&vcp->lock,403);
+		if (xfrOffset > vcp->m.Length)
+		    vcp->m.Length = xfrOffset;
 	        code = afs_DoPartialWrite(vcp, &treq);
 		vcp->states |= CDirty;
 		ReleaseWriteLock(&vcp->lock);
@@ -1327,7 +1425,8 @@ static int lock_normalize(vp, lckdat, offset, cred)
 	    if (code != 0) return code;
 	    lckdat->l_start += (off_t) vattr.va_size;
 	    break;
-	default: return EINVAL;
+	default: 
+	    return EINVAL;
     }
     lckdat->l_whence = 0;
     return 0;
@@ -1342,6 +1441,11 @@ struct	vnode	*vp;
 offset_t	offset;
 struct	eflock	*lckdat;
 struct ucred	*cred;
+#ifdef AFS_AIX51_ENV
+int32long64_t	cmd;
+#else
+int		cmd;
+#endif
 {
    int		error, ncmd=0;
    struct flock	flkd;
@@ -1381,15 +1485,21 @@ struct ucred	*cred;
 
 
 /* NOTE: In the nfs glue routine (nfs_gn2sun.c) the order was wrong (vp, flags, cmd, arg, ext); was that another typo? */
-int afs_gn_ioctl(vp, cmd, arg, flags, channel, ext)
+int afs_gn_ioctl(vp, Cmd, arg, flags, channel, ext)
 struct	vnode	*vp;
-int		cmd;
+#ifdef AFS_AIX51_ENV
+int32long64_t	Cmd;
+#else
+int		Cmd;
+#endif
 int		arg;
 int		flags;		/* Ignored in AFS */
 int		channel;	/* Ignored in AFS */
 int		ext;		/* Ignored in AFS */
 {
     int	error;
+    int cmd = Cmd;
+
     AFS_STATCNT(afs_gn_ioctl);
     /* This seems to be a perfect fit for our ioctl redirection (afs_xioctl hack); thus the ioctl(2) entry in sysent.c is unaffected in the aix/afs port. */ 
     error = afs_ioctl(vp, cmd, arg);
@@ -1807,6 +1917,23 @@ vfs_quotactl(struct vfs *a, int b, uid_t c, caddr_t d
 	return ret;
 }
 
+#ifdef AFS_AIX51_ENV
+static
+vfs_syncvfs(struct gfs *a, struct vfs *b, int c, struct ucred *d)
+{
+	register glockOwner, ret;
+
+	glockOwner = ISAFS_GLOCK();
+	if (!glockOwner)
+	    AFS_GLOCK();
+	ret = (*Afs_vfsops.vfs_syncvfs)(a, b, c, d);
+	if (!glockOwner)
+	    AFS_GUNLOCK();
+
+	return ret;
+}
+#endif
+
 
 struct vfsops locked_Afs_vfsops = {
 	vfs_mount,
@@ -1817,6 +1944,9 @@ struct vfsops locked_Afs_vfsops = {
 	vfs_vget,
 	vfs_cntl,
 	vfs_quotactl,
+#ifdef AFS_AIX51_ENV
+	vfs_syncvfs
+#endif
 };
 
 static
@@ -1834,7 +1964,11 @@ vn_link(struct vnode *a, struct vnode *b, char *c, struct ucred *d) {
 }
 
 static
+#ifdef AFS_AIX51_ENV
+vn_mkdir(struct vnode *a, char *b, int32long64_t c, struct ucred *d) {
+#else
 vn_mkdir(struct vnode *a, char *b, int c, struct ucred *d) {
+#endif
 	register glockOwner, ret;
 
 	glockOwner = ISAFS_GLOCK();
@@ -1848,7 +1982,11 @@ vn_mkdir(struct vnode *a, char *b, int c, struct ucred *d) {
 }
 
 static
+#ifdef AFS_AIX51_ENV
+vn_mknod(struct vnode *a, caddr_t b, int32long64_t c, dev_t d, struct ucred *e) {
+#else
 vn_mknod(struct vnode *a, caddr_t b, int c, dev_t d, struct ucred *e) {
+#endif
 	register glockOwner, ret;
 
 	glockOwner = ISAFS_GLOCK();
@@ -1905,7 +2043,11 @@ vn_rmdir(struct vnode *a, struct vnode *b, char *c, struct ucred *d) {
 }
 
 static
+#ifdef AFS_AIX51_ENV
+vn_lookup(struct vnode *a, struct vnode **b, char *c, int32long64_t d,
+#else
 vn_lookup(struct vnode *a, struct vnode **b, char *c, int d,
+#endif
 	  struct vattr *v, struct ucred *e) {
 	register glockOwner, ret;
 
@@ -1934,7 +2076,11 @@ vn_fid(struct vnode *a, struct fileid *b, struct ucred *c) {
 }
 
 static
+#ifdef AFS_AIX51_ENV
 vn_open(struct vnode *a, int b, int c, caddr_t *d, struct ucred *e) {
+#else
+vn_open(struct vnode *a, int32long64_t b, ext_t c, caddr_t *d, struct ucred *e) {
+#endif
 	register glockOwner, ret;
 
 	glockOwner = ISAFS_GLOCK();
@@ -1948,8 +2094,13 @@ vn_open(struct vnode *a, int b, int c, caddr_t *d, struct ucred *e) {
 }
 
 static
+#ifdef AFS_AIX51_ENV
+vn_create(struct vnode *a, struct vnode **b, int32long64_t c, caddr_t d
+	  , int32long64_t e, caddr_t *f, struct ucred *g) {
+#else
 vn_create(struct vnode *a, struct vnode **b, int c, caddr_t d
 	  , int e, caddr_t *f, struct ucred *g) {
+#endif
 	register glockOwner, ret;
 
 	glockOwner = ISAFS_GLOCK();
@@ -1991,7 +2142,11 @@ vn_rele(struct vnode *a) {
 }
 
 static
+#ifdef AFS_AIX51_ENV
+vn_close(struct vnode *a, int32long64_t b, caddr_t c, struct ucred *d) {
+#else
 vn_close(struct vnode *a, int b, caddr_t c, struct ucred *d) {
+#endif
 	register glockOwner, ret;
 
 	glockOwner = ISAFS_GLOCK();
@@ -2005,7 +2160,11 @@ vn_close(struct vnode *a, int b, caddr_t c, struct ucred *d) {
 }
 
 static
+#ifdef AFS_AIX51_ENV
+vn_map(struct vnode *a, caddr_t b, uint32long64_t c, uint32long64_t d, uint32long64_t e, struct ucred *f) {
+#else
 vn_map(struct vnode *a, caddr_t b, uint c, uint d, uint e, struct ucred *f) {
+#endif
 	register glockOwner, ret;
 
 	glockOwner = ISAFS_GLOCK();
@@ -2019,7 +2178,11 @@ vn_map(struct vnode *a, caddr_t b, uint c, uint d, uint e, struct ucred *f) {
 }
 
 static
+#ifdef AFS_AIX51_ENV
+vn_unmap(struct vnode *a, int32long64_t b, struct ucred *c) {
+#else
 vn_unmap(struct vnode *a, int b, struct ucred *c) {
+#endif
 	register glockOwner, ret;
 
 	glockOwner = ISAFS_GLOCK();
@@ -2033,7 +2196,11 @@ vn_unmap(struct vnode *a, int b, struct ucred *c) {
 }
 
 static
+#ifdef AFS_AIX51_ENV
+vn_access(struct vnode *a, int32long64_t b, int32long64_t c, struct ucred *d) {
+#else
 vn_access(struct vnode *a, int b, int c, struct ucred *d) {
+#endif
 	register glockOwner, ret;
 
 	glockOwner = ISAFS_GLOCK();
@@ -2061,7 +2228,11 @@ vn_getattr(struct vnode *a, struct vattr *b, struct ucred *c) {
 }
 
 static
+#ifdef AFS_AIX51_ENV
+vn_setattr(struct vnode *a, int32long64_t b, int32long64_t c, int32long64_t d, int32long64_t e, struct ucred *f) {
+#else
 vn_setattr(struct vnode *a, int b, int c, int d, int e, struct ucred *f) {
+#endif
 	register glockOwner, ret;
 
 	glockOwner = ISAFS_GLOCK();
@@ -2075,7 +2246,11 @@ vn_setattr(struct vnode *a, int b, int c, int d, int e, struct ucred *f) {
 }
 
 static
+#ifdef AFS_AIX51_ENV
+vn_fclear(struct vnode *a, int32long64_t b, offset_t c, offset_t d
+#else
 vn_fclear(struct vnode *a, int b, offset_t c, offset_t d
+#endif
 	  , caddr_t e, struct ucred *f) {
 	register glockOwner, ret;
 
@@ -2090,7 +2265,11 @@ vn_fclear(struct vnode *a, int b, offset_t c, offset_t d
 }
 
 static
+#ifdef AFS_AIX51_ENV
+vn_fsync(struct vnode *a, int32long64_t b, int32long64_t c, struct ucred *d) {
+#else
 vn_fsync(struct vnode *a, int b, int c, struct ucred *d) {
+#endif
 	register glockOwner, ret;
 
 	glockOwner = ISAFS_GLOCK();
@@ -2104,7 +2283,11 @@ vn_fsync(struct vnode *a, int b, int c, struct ucred *d) {
 }
 
 static
+#ifdef AFS_AIX51_ENV
+vn_ftrunc(struct vnode *a, int32long64_t b, offset_t c, caddr_t d, struct ucred *e) {
+#else
 vn_ftrunc(struct vnode *a, int b, offset_t c, caddr_t d, struct ucred *e) {
+#endif
 	register glockOwner, ret;
 
 	glockOwner = ISAFS_GLOCK();
@@ -2118,8 +2301,13 @@ vn_ftrunc(struct vnode *a, int b, offset_t c, caddr_t d, struct ucred *e) {
 }
 
 static
+#ifdef AFS_AIX51_ENV
+vn_rdwr(struct vnode *a, enum uio_rw b, int32long64_t c, struct uio *d
+	, ext_t e, caddr_t f, struct vattr *v, struct ucred *g) {
+#else
 vn_rdwr(struct vnode *a, enum uio_rw b, int c, struct uio *d
 	, int e, caddr_t f, struct vattr *v, struct ucred *g) {
+#endif
 	register glockOwner, ret;
 
 	glockOwner = ISAFS_GLOCK();
@@ -2133,8 +2321,13 @@ vn_rdwr(struct vnode *a, enum uio_rw b, int c, struct uio *d
 }
 
 static
+#ifdef AFS_AIX51_ENV
+vn_lockctl(struct vnode *a, offset_t b, struct eflock *c, int32long64_t d
+	   , int (*e)(), ulong32int64_t *f, struct ucred *g) {
+#else
 vn_lockctl(struct vnode *a, offset_t b, struct eflock *c, int d
 	   , int (*e)(), ulong *f, struct ucred *g) {
+#endif
 	register glockOwner, ret;
 
 	glockOwner = ISAFS_GLOCK();
@@ -2148,7 +2341,11 @@ vn_lockctl(struct vnode *a, offset_t b, struct eflock *c, int d
 }
 
 static
+#ifdef AFS_AIX51_ENV
+vn_ioctl(struct vnode *a, int32long64_t b, caddr_t c, size_t d, ext_t e, struct ucred *f) {
+#else
 vn_ioctl(struct vnode *a, int b, caddr_t c, size_t d, int e, struct ucred *f) {
+#endif
 	register glockOwner, ret;
 
 	glockOwner = ISAFS_GLOCK();
@@ -2176,7 +2373,11 @@ vn_readlink(struct vnode *a, struct uio *b, struct ucred *c) {
 }
 
 static
+#ifdef AFS_AIX51_ENV
+vn_select(struct vnode *a, int32long64_t b, ushort c, ushort *d, void (*e)()
+#else
 vn_select(struct vnode *a, int b, ushort c, ushort *d, void (*e)()
+#endif
 	  , caddr_t f, struct ucred *g) {
 	register glockOwner, ret;
 
@@ -2219,7 +2420,11 @@ vn_readdir(struct vnode *a, struct uio *b, struct ucred *c) {
 }
 
 static
+#ifdef AFS_AIX51_ENV
+vn_revoke(struct vnode *a, int32long64_t b, int32long64_t c, struct vattr *d, struct ucred *e) {
+#else
 vn_revoke(struct vnode *a, int b, int c, struct vattr *d, struct ucred *e) {
+#endif
 	register glockOwner, ret;
 
 	glockOwner = ISAFS_GLOCK();
@@ -2325,6 +2530,30 @@ struct vnodeops locked_afs_gn_vnodeops = {
 	vn_setacl,
 	vn_getpcl,
 	vn_setpcl,
+	afs_gn_enosys,	/* vn_seek */
+	afs_gn_enosys,	/* vn_fsync_range */
+	afs_gn_enosys,	/* vn_create_attr */
+	afs_gn_enosys,	/* vn_finfo */ 
+	afs_gn_enosys,	/* vn_map_lloff */
+	afs_gn_enosys,	/* vn_readdir_eofp */
+	afs_gn_enosys,	/* vn_rdwr_attr */
+	afs_gn_enosys,	/* vn_memcntl */
+	afs_gn_enosys,	/* vn_spare7 */
+	afs_gn_enosys,	/* vn_spare8 */
+	afs_gn_enosys,	/* vn_spare9 */
+	afs_gn_enosys,	/* vn_spareA */
+	afs_gn_enosys,	/* vn_spareB */
+	afs_gn_enosys,	/* vn_spareC */
+	afs_gn_enosys,	/* vn_spareD */
+	afs_gn_enosys,	/* vn_spareE */
+	afs_gn_enosys	/* vn_spareF */
+#ifdef AFS_AIX51_ENV
+	,afs_gn_enosys, /* pagerBackRange */
+ 	afs_gn_enosys,  /* pagerGetFileSize */
+	afs_gn_enosys,  /* pagerReadAhead */
+	afs_gn_enosys,  /* pagerWriteBehind */
+	afs_gn_enosys   /* pagerEndCopy */
+#endif
 };
 
 struct gfs afs_gfs = {
diff --git a/src/afs/LINUX/osi_vnodeops.c b/src/afs/LINUX/osi_vnodeops.c
index efc5c04..99112c4 100644
--- a/src/afs/LINUX/osi_vnodeops.c
+++ b/src/afs/LINUX/osi_vnodeops.c
@@ -105,6 +105,10 @@ static ssize_t afs_linux_read(struct file *fp, char *buf, size_t count,
             code = afs_read(vcp, &tuio, credp, 0, 0, 0);
 	    xfered += count - tuio.uio_resid;
 	    if (code != 0) {
+    		afs_Trace4(afs_iclSetp, CM_TRACE_READOP, ICL_TYPE_POINTER, vcp,
+	       		ICL_TYPE_OFFSET, offp,
+	       		ICL_TYPE_INT32, -1,
+	       		ICL_TYPE_INT32, code);
 		code = xfered;
 		*offp += count - tuio.uio_resid;
 	    } else {
diff --git a/src/afs/VNOPS/afs_vnop_attrs.c b/src/afs/VNOPS/afs_vnop_attrs.c
index 6d903aa..98c8e86 100644
--- a/src/afs/VNOPS/afs_vnop_attrs.c
+++ b/src/afs/VNOPS/afs_vnop_attrs.c
@@ -179,6 +179,24 @@ int afs_CopyOutAttrs(register struct vcache *avc, register struct vattr *attrs)
     /* And linux has it's own stash as well. */
     vattr2inode(AFSTOV(avc), attrs);
 #endif
+#ifdef notdef
+#ifdef AFS_AIX51_ENV
+    afs_Trace2(afs_iclSetp, CM_TRACE_STATACLX, 
+		ICL_TYPE_POINTER, attrs->va_acl, 
+		ICL_TYPE_INT32, attrs->va_aclsiz);
+    if (attrs->va_acl && attrs->va_aclsiz >= 12) {
+	struct acl *ap;
+
+	ap = (struct acl *) attrs->va_acl;
+	ap->acl_len = 8;
+	ap->acl_mode = ACL_MODE;
+	ap->acl_rsvd = 0;
+	ap->u_access = 7;
+    }
+    /* temporary fix ? */
+    attrs->va_aclsiz = 1;
+#endif
+#endif
     return 0;
 }
 
diff --git a/src/afs/VNOPS/afs_vnop_read.c b/src/afs/VNOPS/afs_vnop_read.c
index 7334eac..e4475cb 100644
--- a/src/afs/VNOPS/afs_vnop_read.c
+++ b/src/afs/VNOPS/afs_vnop_read.c
@@ -190,6 +190,11 @@ tagain:
 		    code = 0;
 		    ConvertSToRLock(&tdc->mflock);
 		    while (!code && tdc->mflags & DFFetchReq) {
+			afs_Trace4(afs_iclSetp, CM_TRACE_DCACHEWAIT,
+				ICL_TYPE_STRING, __FILE__,
+				ICL_TYPE_INT32, __LINE__,
+				ICL_TYPE_POINTER, tdc,
+				ICL_TYPE_INT32, tdc->dflags);
 			/* don't need waiting flag on this one */
 			ReleaseReadLock(&tdc->mflock);
 			ReleaseReadLock(&tdc->lock);
@@ -243,6 +248,10 @@ tagain:
 		}
 		else {
 		    /* don't have current data, so get it below */
+		    afs_Trace3(afs_iclSetp, CM_TRACE_VERSIONNO,
+				ICL_TYPE_INT64, ICL_HANDLE_OFFSET(filePos),
+				ICL_TYPE_HYPER, &avc->m.DataVersion,
+				ICL_TYPE_HYPER, &tdc->f.versionNo);
 		    ReleaseReadLock(&tdc->lock);
 		    afs_PutDCache(tdc);
 		    tdc = NULL;
@@ -720,6 +729,11 @@ tagain:
 		    code = 0;
 		    ConvertSToRLock(&tdc->mflock);
 		    while (!code && tdc->mflags & DFFetchReq) {
+			afs_Trace4(afs_iclSetp, CM_TRACE_DCACHEWAIT,
+				ICL_TYPE_STRING, __FILE__,
+				ICL_TYPE_INT32, __LINE__,
+				ICL_TYPE_POINTER, tdc,
+				ICL_TYPE_INT32, tdc->dflags);
 			/* don't need waiting flag on this one */
 			ReleaseReadLock(&tdc->mflock);
 			ReleaseReadLock(&tdc->lock);
@@ -770,12 +784,17 @@ tagain:
 	    else {
 		/* no longer fetching, verify data version (avoid new
 		 * GetDCache call) */
-		if (hsame(avc->m.DataVersion, tdc->f.versionNo)) {
+		if (hsame(avc->m.DataVersion, tdc->f.versionNo) 
+							&& tdc->f.chunkBytes) {
 		    offset = filePos - AFS_CHUNKTOBASE(tdc->f.chunk);
 		    len = tdc->f.chunkBytes - offset;
 		}
 		else {
 		    /* don't have current data, so get it below */
+		    afs_Trace3(afs_iclSetp, CM_TRACE_VERSIONNO,
+				ICL_TYPE_INT64, ICL_HANDLE_OFFSET(filePos),
+				ICL_TYPE_HYPER, &avc->m.DataVersion,
+				ICL_TYPE_HYPER, &tdc->f.versionNo);
 		    ReleaseReadLock(&tdc->lock);
 		    afs_PutDCache(tdc);
 		    tdc = NULL;
@@ -783,6 +802,10 @@ tagain:
 	    }
 
 	    if (!tdc) {
+		/* If we get, it was not possible to start the 
+		 * background daemon. With flag == 1 afs_GetDCache
+		 * does the FetchData rpc synchronously.
+		 */
 		ReleaseReadLock(&avc->lock);
 		tdc = afs_GetDCache(avc, filePos, &treq, &offset, &len, 1);
 		ObtainReadLock(&avc->lock);
@@ -800,6 +823,11 @@ tagain:
 	}
 	if (len	> totalLength) len = totalLength;   /* will read len bytes */
 	if (len	<= 0) {	/* shouldn't get here if DFFetching is on */
+	    afs_Trace4(afs_iclSetp, CM_TRACE_VNODEREAD2,
+			ICL_TYPE_POINTER, tdc,
+			ICL_TYPE_OFFSET, ICL_HANDLE_OFFSET(tdc->validPos),
+			ICL_TYPE_INT32, tdc->f.chunkBytes,
+			ICL_TYPE_INT32, tdc->dflags);
 	    /* read past the end of a chunk, may not be at next chunk yet, and yet
 		also not at eof, so may have to supply fake zeros */
 	    len	= AFS_CHUNKTOSIZE(tdc->f.chunk) - offset; /* bytes left in chunk addr space */
diff --git a/src/afs/VNOPS/afs_vnop_write.c b/src/afs/VNOPS/afs_vnop_write.c
index 653ccc8..ceaab48 100644
--- a/src/afs/VNOPS/afs_vnop_write.c
+++ b/src/afs/VNOPS/afs_vnop_write.c
@@ -427,6 +427,23 @@ int afs_UFSWrite(register struct vcache *avc, struct uio *auio,
     avc->states |= CDirty;
     tvec = (struct iovec *) osi_AllocSmallSpace(sizeof(struct iovec));
     while (totalLength > 0) {
+#if 0 /* Can't call without tdc. Can't call later since GetDCache can be 
+	 called with !tdc. Leaving it out for now. */
+        /* 
+         *  The following lines are necessary because afs_GetDCache with
+	 *  flag == 4 expects the length field to be filled. It decides
+	 *  from this whether it's necessary to fetch data into the chunk
+	 *  before writing or not (when the whole chunk is overwritten!).
+	 */
+	len = totalLength;	/* write this amount by default */
+	offset = filePos - AFS_CHUNKTOBASE(tdc->f.chunk);
+	max = AFS_CHUNKTOSIZE(tdc->f.chunk);	/* max size of this chunk */
+	if (max	<= len + offset)	{   /*if we'd go past the end of this chunk */
+	    /* it won't all fit in this chunk, so write as much
+		as will fit */
+	    len = max - offset;
+	}
+#endif
 	/* read the cached info */
 	if (noLock) {
 	    tdc = afs_FindDCache(avc, filePos);
diff --git a/src/afs/afs.h b/src/afs/afs.h
index 0f9e6da..fde6ae7 100644
--- a/src/afs/afs.h
+++ b/src/afs/afs.h
@@ -645,7 +645,11 @@ struct vcache {
 #ifdef	AFS_AIX32_ENV
     afs_lock_t pvmlock;
     vmhandle_t vmh;
+#if defined(AFS_AIX51_ENV)
+    vmid_t segid;
+#else
     int  segid;
+#endif
     struct ucred *credp;
 #endif
 #ifdef AFS_AIX_ENV
@@ -897,9 +901,13 @@ struct fcache {
 #if defined(AFS_LINUX_64BIT_KERNEL)
     long inode;	 		/* Unix inode for this chunk */
 #else
+#if defined(AFS_AIX51_ENV)
+    ino_t     inode;		/* Unix inode for this chunk */
+#else
     afs_int32 inode;		/* Unix inode for this chunk */
 #endif
 #endif
+#endif
     afs_int32 chunkBytes;	/* Num bytes in this chunk */
     char states;		/* Has this chunk been modified? */
 };
diff --git a/src/afs/afs_daemons.c b/src/afs/afs_daemons.c
index b628379..fb3d4e9 100644
--- a/src/afs/afs_daemons.c
+++ b/src/afs/afs_daemons.c
@@ -37,7 +37,7 @@ static int rxepoch_checked=0;
 /* PAG garbage collection */
 /* We induce a compile error if param.h does not define AFS_GCPAGS */
 afs_int32 afs_gcpags=AFS_GCPAGS;
-afs_int32 afs_gcpags_procsize;
+afs_int32 afs_gcpags_procsize = 0;
 
 afs_int32 afs_CheckServerDaemonStarted = 0;
 #ifdef DEFAULT_PROBE_INTERVAL
diff --git a/src/afs/afs_dcache.c b/src/afs/afs_dcache.c
index 2a1027e..0bcd42a 100644
--- a/src/afs/afs_dcache.c
+++ b/src/afs/afs_dcache.c
@@ -1,6 +1,6 @@
 /*
  * Copyright 2000, International Business Machines Corporation and others.
- * All Rights Reserved.
+ *$All Rights Reserved.
  * 
  * This software has been released under the terms of the IBM Public
  * License.  For details, see the LICENSE file in the top-level source
@@ -1265,7 +1265,9 @@ static int afs_UFSCacheStoreProc(register struct rx_call *acall,
 	    osi_FreeLargeSpace(tbuffer);
 	    return EIO;
 	}
-	afs_Trace1(afs_iclSetp, CM_TRACE_STOREPROC2, ICL_TYPE_INT32, got);
+	afs_Trace2(afs_iclSetp, CM_TRACE_STOREPROC2, 
+			ICL_TYPE_OFFSET, ICL_HANDLE_OFFSET(*tbuffer),
+			ICL_TYPE_INT32, got);
 	RX_AFS_GUNLOCK();
 	code = rx_Write(acall, tbuffer, got);  /* writing 0 bytes will
 	* push a short packet.  Is that really what we want, just because the
@@ -1375,9 +1377,17 @@ static int afs_UFSCacheFetchProc(register struct rx_call *acall,
 #endif				/* AFS_NOSTATS */
 	while (length > 0) {
 	    tlen = (length > AFS_LRALLOCSIZ ? AFS_LRALLOCSIZ : length);
+#ifdef RX_KERNEL_TRACE
+	    afs_Trace1(afs_iclSetp, CM_TRACE_TIMESTAMP,
+			ICL_TYPE_STRING, "before rx_Read");
+#endif
 	    RX_AFS_GUNLOCK();
 	    code = rx_Read(acall, tbuffer, tlen);
 	    RX_AFS_GLOCK();
+#ifdef RX_KERNEL_TRACE
+	    afs_Trace1(afs_iclSetp, CM_TRACE_TIMESTAMP,
+			ICL_TYPE_STRING, "after rx_Read");
+#endif
 #ifndef AFS_NOSTATS
 	    (*abytesXferredP) += code;
 #endif				/* AFS_NOSTATS */
@@ -1396,12 +1406,12 @@ static int afs_UFSCacheFetchProc(register struct rx_call *acall,
 	    abase += tlen;
 	    length -= tlen;
 	    adc->validPos = abase;
-	    afs_Trace4(afs_iclSetp, CM_TRACE_DCACHEWAKE,
-		       ICL_TYPE_STRING, __FILE__,
-		       ICL_TYPE_INT32, __LINE__,
-		       ICL_TYPE_POINTER, adc,
-		       ICL_TYPE_INT32, adc->dflags);
-	    afs_osi_Wakeup(&adc->validPos);
+	    if (afs_osi_Wakeup(&adc->validPos) == 0)
+		afs_Trace4(afs_iclSetp, CM_TRACE_DCACHEWAKE,
+			   ICL_TYPE_STRING, __FILE__,
+			   ICL_TYPE_INT32, __LINE__,
+			   ICL_TYPE_POINTER, adc,
+			   ICL_TYPE_INT32, adc->dflags);
 	}
     } while (moredata);
     osi_FreeLargeSpace(tbuffer);
@@ -2011,7 +2021,12 @@ RetryLookup:
 	tdc->validPos = Position;	/*  which is AFS_CHUNKBASE(abyte) */
 	if (tdc->mflags & DFFetchReq) {
 	    tdc->mflags &= ~DFFetchReq;
-	    afs_osi_Wakeup(&tdc->validPos);
+	    if (afs_osi_Wakeup(&tdc->validPos) == 0)
+	        afs_Trace4(afs_iclSetp, CM_TRACE_DCACHEWAKE,
+		       ICL_TYPE_STRING, __FILE__,
+		       ICL_TYPE_INT32, __LINE__,
+		       ICL_TYPE_POINTER, tdc,
+		       ICL_TYPE_INT32, tdc->dflags);
 	}
 	tsmall = (struct tlocal1 *) osi_AllocLargeSpace(sizeof(struct tlocal1));
 	setVcacheStatus = 0;
@@ -2108,8 +2123,6 @@ RetryLookup:
 		    } else {
 		        bytes = rx_Read(tcall, (char *)&length_hi, sizeof(afs_int32));
 			RX_AFS_GLOCK();
-			afs_Trace2(afs_iclSetp, CM_TRACE_FETCH64CODE,
-				   ICL_TYPE_POINTER, avc, ICL_TYPE_INT32, code);
 		        if (bytes == sizeof(afs_int32)) {
 			    length_hi = ntohl(length_hi);
 		        } else {
@@ -2319,12 +2332,12 @@ RetryLookup:
 #endif /* AFS_NOSTATS */
 
 	tdc->dflags &= ~DFFetching;
-	afs_Trace4(afs_iclSetp, CM_TRACE_DCACHEWAKE,
-		   ICL_TYPE_STRING, __FILE__,
-		   ICL_TYPE_INT32, __LINE__,
-		   ICL_TYPE_POINTER, tdc,
-		   ICL_TYPE_INT32, tdc->dflags);
-	afs_osi_Wakeup(&tdc->validPos);
+	if (afs_osi_Wakeup(&tdc->validPos) == 0)
+	    afs_Trace4(afs_iclSetp, CM_TRACE_DCACHEWAKE,
+		       ICL_TYPE_STRING, __FILE__,
+		       ICL_TYPE_INT32, __LINE__,
+		       ICL_TYPE_POINTER, tdc,
+		       ICL_TYPE_INT32, tdc->dflags);
 	if (avc->execsOrWriters == 0) tdc->f.states &= ~DWriting;
 
 	/* now, if code != 0, we have an error and should punt.
diff --git a/src/afs/afs_init.c b/src/afs/afs_init.c
index 5989acf..01e3d9d 100644
--- a/src/afs/afs_init.c
+++ b/src/afs/afs_init.c
@@ -145,7 +145,7 @@ int afs_CacheInit(afs_int32 astatSize, afs_int32 afiles, afs_int32
 #endif /* AFS_VM_RDWR_ENV */
 #endif /* AFS_64BIT_CLIENT */
 
-#if defined(AFS_AIX_ENV)
+#if defined(AFS_AIX_ENV) && !defined(AFS_AIX51_ENV)
     {
 	static void afs_procsize_init(void);
 
@@ -491,7 +491,7 @@ int afs_ResourceInit(int preallocs)
 
 } /*afs_ResourceInit*/
 
-#if defined(AFS_AIX_ENV)
+#if defined(AFS_AIX_ENV) && !defined(AFS_AIX51_ENV)
 
 /*
  * AIX dynamic sizeof(struct proc)
@@ -537,6 +537,9 @@ static void afs_procsize_init(void)
 {
     struct proc *p0;	/* pointer to process 0 */
     struct proc *pN;	/* pointer to process 0's first child */
+#ifdef AFS_AIX51_ENV
+    struct pvproc *pV;
+#endif
     int pN_index;
     ptrdiff_t pN_offset;
     int procsize;
@@ -547,7 +550,17 @@ static void afs_procsize_init(void)
 	return;
     }
 
+#ifdef AFS_AIX51_ENV
+    pN = (struct proc *)0;
+    pV = p0->p_pvprocp;
+    if (pV) {
+	pV = pV->pv_child;
+	if (pV)
+	    pN = pV->pv_procp;
+    }
+#else
     pN = p0->p_child;
+#endif
     if (!pN) {
 	afs_gcpags = AFS_GCPAGS_EPROCN;
 	return;
@@ -584,7 +597,6 @@ static void afs_procsize_init(void)
 
     afs_gcpags_procsize = procsize;
 }
-
 #endif
 
 /*
diff --git a/src/afs/afs_osi.c b/src/afs/afs_osi.c
index 468655f..4fbce99 100644
--- a/src/afs/afs_osi.c
+++ b/src/afs/afs_osi.c
@@ -709,6 +709,9 @@ void afs_osi_TraverseProcTable(void)
 #endif	/* AFS_SGI_ENV */
 
 #if defined(AFS_AIX_ENV)
+#ifdef AFS_AIX51_ENV
+#define max_proc v.ve_proc
+#endif
 void afs_osi_TraverseProcTable(void)
 {
     struct proc *p;
@@ -722,17 +725,28 @@ void afs_osi_TraverseProcTable(void)
     if (!afs_gcpags_procsize)
 	return;
 
+#ifndef AFS_AIX51_ENV
     simple_lock(&proc_tbl_lock);
+#endif
     for (p = (struct proc *)v.vb_proc, i = 0;
          p < max_proc;
 	 p = (struct proc *)((char *)p + afs_gcpags_procsize), i++) {
 
+#ifdef AFS_AIX51_ENV
+	if (p->p_pvprocp->pv_stat == SNONE)
+	    continue;
+	if (p->p_pvprocp->pv_stat == SIDL)
+	    continue;
+	if (p->p_pvprocp->pv_stat == SEXIT)
+	    continue;
+#else
 	if (p->p_stat == SNONE)
 	    continue;
 	if (p->p_stat == SIDL)
 	    continue;
 	if (p->p_stat == SEXIT)
 	    continue;
+#endif
 
 	/* sanity check */
 
@@ -750,7 +764,9 @@ void afs_osi_TraverseProcTable(void)
 
 	afs_GCPAGs_perproc_func(p);
     }
+#ifndef AFS_AIX51_ENV
     simple_unlock(&proc_tbl_lock);
+#endif
 }
 #endif
 
@@ -887,16 +903,28 @@ const struct AFS_UCRED *afs_osi_proc2cred(AFS_PROC *pproc)
     /* simple_lock(&proc_tbl_lock); */
     if (pproc->p_adspace != NULLSEGVAL) {
 
+#ifdef AFS_AIX51_ENV
+	simple_lock(&pproc->p_pvprocp->pv_lock);
+#else
 	simple_lock(&pproc->p_lock);
+#endif
 
 	if (pproc->p_threadcount &&
+#ifdef AFS_AIX51_ENV
+	    pproc->p_pvprocp->pv_threadlist) {
+#else
 	    pproc->p_threadlist) {
+#endif
 
 	    /*
 	     * arbitrarily pick the first thread in pproc
 	     */
 	    struct thread *pproc_thread =
+#ifdef AFS_AIX51_ENV
+	        pproc->p_pvprocp->pv_threadlist;
+#else
 		pproc->p_threadlist;
+#endif
 
 	    /*
 	     * location of 'struct user' in pproc's
@@ -919,7 +947,11 @@ const struct AFS_UCRED *afs_osi_proc2cred(AFS_PROC *pproc)
 			  &dp, SYS_ADSPACE);
 	}
 
+#ifdef AFS_AIX51_ENV
+	simple_unlock(&pproc->p_pvprocp->pv_lock);
+#else
 	simple_unlock(&pproc->p_lock);
+#endif
     }
     /* simple_unlock(&proc_tbl_lock); */
     if (xm == XMEM_SUCC) {
diff --git a/src/afs/afs_osi_pag.c b/src/afs/afs_osi_pag.c
index cb0adba..4b4f521 100644
--- a/src/afs/afs_osi_pag.c
+++ b/src/afs/afs_osi_pag.c
@@ -440,17 +440,28 @@ afs_int32 PagInCred(const struct AFS_UCRED *cred)
     g1 = cred->cr_groups[2];
 #else
 #ifdef	AFS_AIX_ENV
+#ifdef AFS_AIX51_ENV
+    if (kcred_getpag(cred, PAG_AFS, &pag) < 0 || pag == 0)
+	pag = NOPAG;
+    return pag;
+#else
     if (cred->cr_ngrps < 2) {
 	return NOPAG;
     }
+#endif
 #else
 #if defined(AFS_SGI_ENV) || defined(AFS_SUN5_ENV) || defined(AFS_DUX40_ENV) || defined(AFS_LINUX_ENV) || defined(AFS_FBSD_ENV)
     if (cred->cr_ngroups < 2) return NOPAG;
 #endif
 #endif
+#ifdef AFS_AIX51_ENV
+    g0 = cred->cr_groupset.gs_union.un_groups[0];
+    g1 = cred->cr_groupset.gs_union.un_groups[1];
+#else
     g0 = cred->cr_groups[0];
     g1 = cred->cr_groups[1];
 #endif
+#endif
     pag = (afs_int32)afs_get_pag_from_groups(g0, g1);
     return pag;
 }
diff --git a/src/afs/afs_pioctl.c b/src/afs/afs_pioctl.c
index 463c703..a832050 100644
--- a/src/afs/afs_pioctl.c
+++ b/src/afs/afs_pioctl.c
@@ -301,6 +301,9 @@ int HandleIoctl(register struct vcache *avc, register afs_int32 acom, struct afs
        default:
 
 	 code = EINVAL;
+#ifdef AFS_AIX51_ENV
+	 code = ENOSYS;
+#endif
 	 break;
        }
        return code;		/* so far, none implemented */
@@ -374,13 +377,21 @@ afs_ioctl(OSI_VN_DECL(tvc), int cmd, void * arg, int flag, cred_t *cr, rval_t *r
 #ifndef AFS_HPUX102_ENV
 #if !defined(AFS_SGI_ENV)
 #ifdef	AFS_AIX32_ENV
+#ifdef AFS_AIX51_ENV
+kioctl(fdes, com, arg, ext, arg2, arg3)
+     caddr_t arg2, arg3;
+#else
 kioctl(fdes, com, arg, ext)
+#endif
      int fdes, com;
      caddr_t arg, ext;
 {
   struct a {
     int fd, com;
     caddr_t arg, ext;
+#ifdef AFS_AIX51_ENV
+     caddr_t arg2, arg3;
+#endif
   } u_uap, *uap = &u_uap;
 #else
 #ifdef	AFS_SUN5_ENV
@@ -476,6 +487,12 @@ int afs_xioctl (void)
       uap->fd = fdes;
       uap->com = com;
       uap->arg = arg;
+#ifdef AFS_AIX51_ENV
+      uap->arg2 = arg2;
+      uap->arg3 = arg3;
+#endif
+
+  
       if (setuerror(getf(uap->fd, &fd))) {
 	return -1;
     }
@@ -597,7 +614,11 @@ int afs_xioctl (void)
       if (!ioctlDone) {
 #ifdef	AFS_AIX41_ENV
 	  ufdrele(uap->fd);
+#ifdef AFS_AIX51_ENV
+	  code = okioctl(fdes, com, arg, ext, arg2, arg3);
+#else
 	  code = okioctl(fdes, com, arg, ext);
+#endif
 	  return code;
 #else
 #ifdef	AFS_AIX32_ENV
@@ -3202,8 +3223,13 @@ static int HandleClientContext(struct afs_ioctl *ablob, int *com, struct AFS_UCR
     setuerror(0);	
 #endif
     newcred->cr_gid = RMTUSER_REQ;
+#ifdef AFS_AIX51_ENV
+    newcred->cr_groupset.gs_union.un_groups[0] = g0;
+    newcred->cr_groupset.gs_union.un_groups[1] = g1;
+#else
     newcred->cr_groups[0] = g0;
     newcred->cr_groups[1] = g1;
+#endif
 #ifdef AFS_AIX_ENV
     newcred->cr_ngrps = 2;
 #else
diff --git a/src/afs/afs_trace.et b/src/afs/afs_trace.et
index 727ec0a..2f3f0c2 100644
--- a/src/afs/afs_trace.et
+++ b/src/afs/afs_trace.et
@@ -150,7 +150,7 @@ error_table 2 ZCM
 	ec	CM_TRACE_STOREDATA64, "StoreData64: fid (%d:%d.%d.%d) offs (0x%x, 0x%x) len (0x%x, 0x%x) file length (0x%x, 0x%x)"
 	ec	CM_TRACE_RESIDCMD, "ResidencyCmd tvc 0x%x command %d fid (%d:%d.%d.%d)"
 	ec	CM_TRACE_PREFETCHCMD, "PrefetchCmd tvc 0x%x tfid (%d:%d.%d.%d) fid (%d:%d.%d.%d)"
-	ec	CM_TRACE_STOREPROC2, "StoreProc got 0x%x"
+	ec	CM_TRACE_STOREPROC2, "StoreProc got (0x%x, 0x%x) length 0x%x"
 	ec	CM_TRACE_ADJUSTSIZE, "AdjustSize index %d oldSize %d newSize %d blocksUsed %d"
 	ec	CM_TRACE_SETLENGTH, "%s line %d: m.Length was (0x%x, 0x%x), now (0x%x, 0x%x)"
 	ec	CM_TRACE_DCACHEWAIT, "%s line %d: waiting for 0x%x flags 0x%x" 
@@ -161,5 +161,12 @@ error_table 2 ZCM
 	ec	CM_TRACE_DENTRYIPUT, "d_iput inode 0x%x d_name %s/%s"
 	ec	CM_TRACE_TRYFLUSHDCACHECHILDREN, "TryFlushDcacheChildren ip 0x%x name %s parent %s"
 	ec	CM_TRACE_DCACHEWAKE, "%s line %d: waking up waiters for 0x%x flags 0x%x"
+	ec      CM_TRACE_VERSIONNO, "At offset (0x%x, 0x%x) vc shows (0x%x, 0x%x), dc (0x%x, 0x%x)"
+	ec      CM_TRACE_TIMESTAMP, "%s"
+	ec      CM_TRACE_RXSLEEP, "osi_rxSleep() at %s line %d"
+	ec      CM_TRACE_RXWAKE, "osi_rxWakeup() at %s line %d"
+	ec      CM_TRACE_GNGETACL, "Gn_getacl vp 0x%lx (returns 0x%x)"
+	ec      CM_TRACE_EINVAL, "EINVAL in %s at line %d"
+	ec      CM_TRACE_VNODEREAD2, "negative length tdc 0x%lx validPos (0x%x, 0x%x) chunkBytes 0x%x dflags 0x%x"
 end
 
diff --git a/src/afs/sysincludes.h b/src/afs/sysincludes.h
index 92e6626..1d89b9f 100644
--- a/src/afs/sysincludes.h
+++ b/src/afs/sysincludes.h
@@ -104,6 +104,9 @@ typedef unsigned short                  etap_event_t;
 #ifdef AFS_AIX41_ENV
 #include "sys/statfs.h"
 #endif
+#ifdef AFS_AIX51_ENV
+#include "sys/acl.h"
+#endif
 #include "../h/file.h"
 #include "../h/fullstat.h"
 #include "../h/vattr.h"
diff --git a/src/cf/osconf.m4 b/src/cf/osconf.m4
index 367fa1f..8184567 100644
--- a/src/cf/osconf.m4
+++ b/src/cf/osconf.m4
@@ -287,6 +287,21 @@ case $AFS_SYSNAME in
 		SHLIB_LINKER="${MT_CC} -bM:SRE -berok"
 		;;
 
+	rs_aix51)
+		DBG=""
+		LEX="lex"
+		LIBSYS_AIX_EXP="afsl.exp"
+		LWP_OPTMZ="-O"
+		MT_CC="xlc_r"
+		MT_CFLAGS='-DAFS_PTHREAD_ENV ${XCFLAGS}'
+		MT_LIBS="-lpthreads"
+		OPTMZ="-O"
+		SHLIB_SUFFIX="o"
+		TXLIBS="-lcurses"
+		XCFLAGS="-K -D_NO_PROTO -D_NONSTD_TYPES -D_MBI=void"
+		XLIBS="${LIB_AFSDB} -ldl"
+		;;
+
 	s390_linux22)
 		CC="gcc"
 		LD="gcc"
diff --git a/src/comerr/compile_et.c b/src/comerr/compile_et.c
index 16d09b4..6f869b9 100644
--- a/src/comerr/compile_et.c
+++ b/src/comerr/compile_et.c
@@ -47,7 +47,11 @@ int use_msf = 0;
 /* lex stuff */
 extern FILE *yyin;
 extern FILE *yyout;
+#ifdef AFS_AIX51_ENV
+int yylineno = 0;
+#else
 extern int yylineno;
+#endif
 
 char * xmalloc (unsigned int size)
 {
diff --git a/src/config/afs_sysnames.h b/src/config/afs_sysnames.h
index 58e86d4..dd52090 100644
--- a/src/config/afs_sysnames.h
+++ b/src/config/afs_sysnames.h
@@ -58,6 +58,8 @@
 #define SYS_NAME_ID_rs_aix32		 701
 #define SYS_NAME_ID_rs_aix41		 702
 #define SYS_NAME_ID_rs_aix42		 703
+#define SYS_NAME_ID_rs_aix51		 704
+#define SYS_NAME_ID_rs_aix43		 705
 
 #define SYS_NAME_ID_sun3_411		 906
 #define SYS_NAME_ID_sun3x_411		 912
diff --git a/src/export/Makefile.in b/src/export/Makefile.in
index 2c2f9b3..bedb6e4 100644
--- a/src/export/Makefile.in
+++ b/src/export/Makefile.in
@@ -12,6 +12,7 @@ include @TOP_OBJDIR@/src/config/Makefile.config
      INCS = -I${TOP_OBJDIR}/src/config -I${TOP_INCDIR}
    CFLAGS = ${OPTMZ} ${DEFS} ${INCS}
   EXPORTS = -bexport:export.exp
+  EXPORTS5 = -bexport:export5.exp
   IMPORTS = /lib/kernex.exp /lib/syscalls.exp extras.exp
      KOBJ = export.o symtab.o
 
@@ -32,10 +33,16 @@ ukinstall webinstall:
 	${INSTALL} ${srcdir}/export.exp ${UKERNELDIR}
 
 export.ext: ${KOBJ}
-	${LD} -o export.ext -eexport ${IMPORTS} ${KOBJ} ${EXPORTS} -lcsys
+	case ${SYS_NAME} in \
+	rs_aix4* ) \
+		${LD} -o export.ext -eexport ${IMPORTS} ${KOBJ} ${EXPORTS} -lcsys ;; \
+	rs_aix5* ) \
+		${LD} -o export.ext -eexport ${IMPORTS} ${KOBJ} ${EXPORTS5} -lcsys ;; \
+	esac
 
 export.ext.nonfs: export.nonfs.o symtab.o
-	${LD} -o export.ext.nonfs -eexport ${IMPORTS} export.nonfs.o symtab.o ${EXPORTS} -lcsys
+	${LD} -o export.ext.nonfs -eexport ${IMPORTS} export.nonfs.o \
+		symtab.o ${EXPORTS} -lcsys
 
 export.nonfs.o:
 	${CC} ${INCS} -DAFS_NONFSTRANS -c export.c
diff --git a/src/export/cfgexport.c b/src/export/cfgexport.c
index 16f85c4..a5bfcc9 100644
--- a/src/export/cfgexport.c
+++ b/src/export/cfgexport.c
@@ -32,7 +32,7 @@ extern char    *malloc(), *optarg;
 extern int	errno;
 extern int	sysconfig(int cmd, void *arg, int len);
 
-int debug;
+int debug = 0 ;
 char *syms = "/unix";
 
 #include "AFS_component_version_number.c"
diff --git a/src/export/export.c b/src/export/export.c
index 98d7b6d..439f79c 100644
--- a/src/export/export.c
+++ b/src/export/export.c
@@ -90,7 +90,11 @@ register struct uio *uiop; {
 
 	if (toc_nsyms * sizeof (sym_t) != conf.symt_sz
 	    || toc_size > (1024 * 1024))
+#ifdef AFS_AIX51_ENV
+		return EFBIG;
+#else
 		return EINVAL;
+#endif
 
 	toc_syms = (sym_t *) xmalloc(toc_size, 2, kernel_heap);
 
@@ -227,6 +231,7 @@ import_kvar(struct k_var *kvp, caddr_t *toc) {
 /*
  * Call vanilla syscalls
  */
+#ifndef AFS_AIX51_ENV
 osetgroups(ngroups, gidset)
     int ngroups;
     gid_t *gidset;
@@ -236,15 +241,25 @@ osetgroups(ngroups, gidset)
     error = setgroups(ngroups, gidset);
     return (error);
 }
+#endif
 
-
+#ifdef AFS_AIX51_ENV
+okioctl(fdes, cmd, arg, ext, arg2, arg3)
+    int fdes, cmd;
+    caddr_t ext, arg, arg2, arg3;
+#else
 okioctl(fdes, cmd, arg, ext)
     int fdes, cmd, arg;
     caddr_t ext;
+#endif
 {
     int error;
     
+#ifdef AFS_AIX51_ENV
+    error = kioctl(fdes, cmd, arg, ext, arg2, arg3);
+#else
     error = kioctl(fdes, cmd, arg, ext);
+#endif
     return (error);
 }
 
diff --git a/src/libafs/MakefileProto.AIX.in b/src/libafs/MakefileProto.AIX.in
index 76a047c..481e77c 100644
--- a/src/libafs/MakefileProto.AIX.in
+++ b/src/libafs/MakefileProto.AIX.in
@@ -121,13 +121,13 @@ $(INST_LIBAFSIAUTH): $(LIBAFSIAUTH)
 
 $(LIBAFSIAUTH): $(AFSAOBJS) $(AFSIAUTHOBJS)
 	${LD} ${LDSTUFF} -bloadmap:afs.ext.iauth.loadmap \
-	 -bmap:afs.ext.iauth.map -o afs.ext.iauth \
-	${AFSAOBJS} ${AFSIAUTHOBJS} ${LIBS} ${LDFLAGS}
+		-bmap:afs.ext.iauth.map -o afs.ext.iauth \
+		${AFSAOBJS} ${AFSIAUTHOBJS} ${LIBS} ${LDFLAGS} 
 
 $(LIBAFS): $(AFSAOBJS) $(AFSNOIAUTHOBJS)
 	${LD} ${LDSTUFF} -bloadmap:afs.ext.loadmap \
-	 -bmap:afs.ext.map -o afs.ext \
-	${AFSAOBJS} $(AFSNOIAUTHOBJS) ${LIBS} ${LDFLAGS}
+	 	-bmap:afs.ext.map -o afs.ext \
+		${AFSAOBJS} ${AFSNOIAUTHOBJS} ${LIBS} ${LDFLAGS}
 
 libafs: $(LIBAFS) $(LIBAFSIAUTH)
 install_libafs: $(INST_LIBAFS) $(INST_LIBAFSIAUTH)
diff --git a/src/rx/rx_getaddr.c b/src/rx/rx_getaddr.c
index 5aaf681..5f3039e 100644
--- a/src/rx/rx_getaddr.c
+++ b/src/rx/rx_getaddr.c
@@ -326,8 +326,8 @@ int    maxSize;        /* sizeof of buffer in afs_int32 units */
     struct ifconf   ifc;
     struct ifreq    ifs[NIFS], *ifr;
     struct sockaddr_in *a;
-#if     defined(AFS_AIX41_ENV) || defined(AFS_USR_AIX_ENV)
-    char	*cp, *cplim;	/* used only for AIX 41 */
+#if    defined(AFS_AIX41_ENV) || defined (AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
+    char	*cp, *cplim, *cpnext;	/* used only for AIX 41 */
 #endif
 
     s = socket(AF_INET, SOCK_DGRAM, 0);
@@ -350,8 +350,12 @@ int    maxSize;        /* sizeof of buffer in afs_int32 units */
 #if defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
 	        cp += _SIZEOF_ADDR_IFREQ(*ifr))
 #else
+#ifdef AFS_AIX51_ENV
+                cp = cpnext)
+#else
                 cp += sizeof(ifr->ifr_name) + MAX(a->sin_len, sizeof(*a)))
 #endif
+#endif
        {
 	ifr = (struct ifreq *)cp;
 #else
@@ -359,11 +363,16 @@ int    maxSize;        /* sizeof of buffer in afs_int32 units */
 	ifr = &ifs[i];
 #endif
 	a = (struct sockaddr_in *) &ifr->ifr_addr;
-	if (a->sin_addr.s_addr != 0 && a->sin_family == AF_INET) {
-	    if ( ioctl(s, SIOCGIFFLAGS, ifr) < 0 ) {
-		perror("SIOCGIFFLAGS");
-		continue; /* ignore this address */
-	    }
+#ifdef AFS_AIX51_ENV
+	cpnext = cp + sizeof(ifr->ifr_name) + MAX(a->sin_len, sizeof(*a));
+#endif
+	if (a->sin_family != AF_INET)
+	    continue;
+	if ( ioctl(s, SIOCGIFFLAGS, ifr) < 0 ) {
+	    perror("SIOCGIFFLAGS");
+	    continue; /* ignore this address */
+	}
+	if (a->sin_addr.s_addr != 0) {
 	    if (ifr->ifr_flags & IFF_LOOPBACK) {
 		continue;	 /* skip aliased loopbacks as well. */
 	    }
diff --git a/src/rx/rx_kcommon.c b/src/rx/rx_kcommon.c
index 18e8ee3..51e7046 100644
--- a/src/rx/rx_kcommon.c
+++ b/src/rx/rx_kcommon.c
@@ -907,7 +907,15 @@ void afs_rxevent_daemon(void)
 #ifdef RX_ENABLE_LOCKS
 	AFS_GLOCK();
 #endif /* RX_ENABLE_LOCKS */
+#ifdef RX_KERNEL_TRACE
+	afs_Trace1(afs_iclSetp, CM_TRACE_TIMESTAMP,
+		   ICL_TYPE_STRING, "before afs_osi_Wait()");
+#endif
 	afs_osi_Wait(500, NULL, 0);
+#ifdef RX_KERNEL_TRACE
+	afs_Trace1(afs_iclSetp, CM_TRACE_TIMESTAMP,
+		   ICL_TYPE_STRING, "after afs_osi_Wait()");
+#endif
 	if (afs_termState == AFSOP_STOP_RXEVENT )
 	{
 #ifdef RXK_LISTENER_ENV
@@ -915,7 +923,7 @@ void afs_rxevent_daemon(void)
 #else
 		afs_termState = AFSOP_STOP_COMPLETE;
 #endif
-		afs_osi_Wakeup(&afs_termState);
+		osi_rxWakeup(&afs_termState);
 		return;
 	}
     }
@@ -956,9 +964,21 @@ int rxk_ReadPacket(osi_socket so, struct rx_packet *p, int *host, int *port)
     p->wirevec[p->niovecs-1].iov_len = savelen + RX_EXTRABUFFERSIZE;
 
     nbytes = tlen + sizeof(afs_int32);
+#ifdef RX_KERNEL_TRACE
+    AFS_GLOCK();
+    afs_Trace1(afs_iclSetp, CM_TRACE_TIMESTAMP,
+		ICL_TYPE_STRING, "before osi_NetRecive()");
+    AFS_GUNLOCK();
+#endif
     code = osi_NetReceive(rx_socket, &from, p->wirevec, p->niovecs,
 			    &nbytes);
 
+#ifdef RX_KERNEL_TRACE
+    AFS_GLOCK();
+    afs_Trace1(afs_iclSetp, CM_TRACE_TIMESTAMP,
+		ICL_TYPE_STRING, "after osi_NetRecive()");
+    AFS_GUNLOCK();
+#endif
    /* restore the vec to its correct state */
     p->wirevec[p->niovecs-1].iov_len = savelen;
 
@@ -1074,11 +1094,11 @@ void rxk_Listener(void)
 #endif /* RX_ENABLE_LOCKS */
     if (afs_termState == AFSOP_STOP_RXK_LISTENER) {
 	afs_termState = AFSOP_STOP_COMPLETE;
-	afs_osi_Wakeup(&afs_termState);
+	osi_rxWakeup(&afs_termState);
     }
     rxk_ListenerPid = 0;
 #if defined(AFS_LINUX22_ENV) || defined(AFS_SUN5_ENV)
-    afs_osi_Wakeup(&rxk_ListenerPid);
+    osi_rxWakeup(&rxk_ListenerPid);
 #endif
 #ifdef AFS_SUN5_ENV
     AFS_GUNLOCK();
diff --git a/src/rx/rx_kernel.h b/src/rx/rx_kernel.h
index fb5b094..46fbeef 100644
--- a/src/rx/rx_kernel.h
+++ b/src/rx/rx_kernel.h
@@ -25,8 +25,18 @@ typedef struct socket *osi_socket;
 #define	OSI_NULLSOCKET	((osi_socket) 0)
 
 #if (!defined(AFS_GLOBAL_SUNLOCK) && !defined(RX_ENABLE_LOCKS)) || (defined(AFS_HPUX_ENV) && !defined(RX_ENABLE_LOCKS))
+#define RX_KERNEL_TRACE 1
+#ifdef RX_KERNEL_TRACE
+#include "../afs/icl.h"
+#include "../afs/afs_trace.h"
+#define osi_rxSleep(a)  afs_Trace2(afs_iclSetp, CM_TRACE_RXSLEEP, \
+        ICL_TYPE_STRING, __FILE__, ICL_TYPE_INT32, __LINE__); afs_osi_Sleep(a)
+#define osi_rxWakeup(a) if (afs_osi_Wakeup(a) == 0) afs_Trace2(afs_iclSetp, \
+        CM_TRACE_RXWAKE, ICL_TYPE_STRING, __FILE__, ICL_TYPE_INT32, __LINE__)
+#else /* RX_KERNEL_TRACE */
 #define	osi_rxSleep(a)	afs_osi_Sleep(a)
 #define	osi_rxWakeup(a)	afs_osi_Wakeup(a)
+#endif /* RX_KERNEL_TRACE */
 #endif
 
 extern int osi_utoa(char *buf, size_t len, unsigned long val);
diff --git a/src/tsm41/aix41_auth.c b/src/tsm41/aix41_auth.c
index dadb0fe..054aaed 100644
--- a/src/tsm41/aix41_auth.c
+++ b/src/tsm41/aix41_auth.c
@@ -28,7 +28,6 @@ RCSID("$Header$");
 #include <afs/kauth.h>
 #include <afs/kautils.h>
 
-
 int afs_authenticate (char *userName, char *response, int  *reenter, char **message) {
     char *reason, *pword, prompt[256];
     struct passwd *pwd;
@@ -83,23 +82,60 @@ int afs_getgrset (char *userName) {
     return NULL;
 }
 
-int afs_getgrgid (int id) {
+struct group *afs_getgrgid (int id) {
     return NULL;
 }
 
-int afs_getgrnam (char *name) {
+struct group *afs_getgrnam (char *name) {
     return NULL;
 }
 
+#ifdef AFS_AIX51_ENV
+/*
+ *  This is a nasty hack. It seems getpwnam calls this routine and is not
+ *  happy with NULL as result. Trying to call here getpwnam in order to get
+ *  a reasonable result kills the whole program. So I tried to return
+ *  a dummy pwd and it seems to work!
+ */
+struct passwd *afs_getpwnam (char *user) {
+    char name[64];
+    char *passwd = "*";
+    char *gecos = "";
+    char *dir = "/";
+    char *shell = "/bin/sh";
+    char *nobody = "nobody";
+    struct passwd p;
+
+    strncpy((char *)&name, user, sizeof(name));
+    name[63] = 0;
+    p.pw_name = &name;
+    p.pw_name = nobody;
+    p.pw_passwd = passwd;
+    p.pw_uid = 4294967294;
+    p.pw_gid = 4294967294;
+    p.pw_gecos = gecos;
+    p.pw_dir = dir;
+    p.pw_shell = shell;
+
+    return &p;
+}
+#else
 int afs_getpwnam(int id)
 {
     return NULL;
 }
+#endif
 
+#ifdef AFS_AIX52_ENV
+struct passwd *afs_getpwuid (uid_t uid) {
+    return pwd;
+}
+#else
 int afs_getpwuid(char *name)
 {
     return NULL;
 }
+#endif
 
 int afs_initialize(struct secmethod_table *meths) {
     /*
diff --git a/src/util/snprintf.c b/src/util/snprintf.c
index 3a626d1..a508db6 100644
--- a/src/util/snprintf.c
+++ b/src/util/snprintf.c
@@ -118,7 +118,11 @@ static void mkint(char *buf, unsigned long val, int base, int uc, int prec)
  *       both '0' and ' ' are given, the ' ' flag will be ignored.
  *     + The '#' and '+' flags have no effect.
  */
+#ifdef AFS_AIX51_ENV
+static int  vsnprintf(char *p, size_t avail, const char *fmt, va_list ap)
+#else
 static void vsnprintf(char *p, unsigned int avail, char *fmt, va_list ap)
+#endif
 {
   unsigned int width, precision, haveprec, len;
   int ljust, plsign, spsign, altform, zfill;
@@ -382,7 +386,11 @@ static void vsnprintf(char *p, unsigned int avail, char *fmt, va_list ap)
 }
 
 
+#ifdef AFS_AIX51_ENV
+int snprintf(char *p, size_t avail, const char *fmt, ...)
+#else
 void snprintf(char *p, unsigned int avail, char *fmt, ...)
+#endif
 {
   va_list ap;
 
diff --git a/src/vol/fssync.c b/src/vol/fssync.c
index d833bff..b911a16 100644
--- a/src/vol/fssync.c
+++ b/src/vol/fssync.c
@@ -426,7 +426,7 @@ defect #2080 for details.
 	    tvolName[0] = '/';
 	    sprintf(&tvolName[1], VFORMAT, command.volume);
 
-	    vp = VAttachVolumeByName_r(&error, command.partName, tvolName, V_UPDATE);
+	    vp = VAttachVolumeByName_r(&error, command.partName, tvolName, V_VOLUPD);
 	    if (vp)
 	        VPutVolume_r(vp);
 	    break;
@@ -580,7 +580,7 @@ static void FSYNC_Drop(fd)
 
 	    tvolName[0] = '/';
 	    sprintf(&tvolName[1], VFORMAT, p[i].volumeID);
-	    vp = VAttachVolumeByName_r(&error, p[i].partName, tvolName, V_UPDATE);
+	    vp = VAttachVolumeByName_r(&error, p[i].partName, tvolName, V_VOLUPD);
 	    if (vp)
 	        VPutVolume_r(vp);
 	    p[i].volumeID = 0;
diff --git a/src/vol/volume.c b/src/vol/volume.c
index dd75104..4394ffd 100644
--- a/src/vol/volume.c
+++ b/src/vol/volume.c
@@ -280,7 +280,7 @@ int VInitVolumePackage(ProgramType pt, int nLargeVnodes, int nSmallVnodes,
 		    Error error;
 		    Volume *vp;
 		    vp = VAttachVolumeByName(&error, diskP->name, dp->d_name,
-					     V_UPDATE);
+					     V_VOLUPD);
 		    (*(vp?&nAttached:&nUnattached))++;
 		    if (error == VOFFLINE)
 			Log("Volume %u stays offline (/vice/offline/%s exists)\n", 
diff --git a/src/vol/volume.h b/src/vol/volume.h
index cd15545..2750b10 100644
--- a/src/vol/volume.h
+++ b/src/vol/volume.h
@@ -460,7 +460,7 @@ extern void VolumeHeaderToDisk(VolumeDiskHeader_t *dh, VolumeHeader_t *h);
 			   the volume is read-only, the file server may continue to
 			   server it; it may also continue to server it in read/write
 			   mode if the writes are deferred */
-#define V_UPDATE   3	/* General update or volume purge is possible.  Volume must
+#define V_VOLUPD   3	/* General update or volume purge is possible.  Volume must
 			   go offline */
 #define V_DUMP	   4	/* A dump of the volume is requested; the volume can be served
 			   read-only during this time */
diff --git a/src/volser/volprocs.c b/src/volser/volprocs.c
index 15bf1a1..438f2f8 100644
--- a/src/volser/volprocs.c
+++ b/src/volser/volprocs.c
@@ -329,7 +329,7 @@ afs_int32 apartID, avolID;
      * server doesn't try to use it (and abort) while (or after) we delete it.
      * If we don't get the volume, that's fine, too.  We just won't put it back.
      */
-    tvp = XAttachVolume(&error, avolID, apartID, V_UPDATE);
+    tvp = XAttachVolume(&error, avolID, apartID, V_VOLUPD);
     code = nuke(partName, avolID);
     if (tvp) VDetachVolume(&error, tvp);
     return code;
@@ -553,7 +553,7 @@ char *newName;
     
     
     if (purgeId) {
-	purgevp = VAttachVolume(&error, purgeId, V_UPDATE);
+	purgevp = VAttachVolume(&error, purgeId, V_VOLUPD);
 	if (error) {
 	    Log("1 Volser: Clone: Could not attach 'purge' volume %u; clone aborted\n", purgeId);
 	    goto fail;
@@ -731,7 +731,7 @@ afs_int32 cloneId;
        goto fail;
     }
 
-    clonevp = VAttachVolume(&error, cloneId, V_UPDATE);
+    clonevp = VAttachVolume(&error, cloneId, V_VOLUPD);
     if (error) {
 	Log("1 Volser: can't attach clone %d\n", cloneId);
 	goto fail;
@@ -868,7 +868,7 @@ afs_int32 *ttid;
     if (iflags & ITCreate) mode = V_SECRETLY;
     else if (iflags & ITBusy) mode = V_CLONE;
     else if (iflags & ITReadOnly) mode = V_READONLY;
-    else if (iflags & ITOffline) mode = V_UPDATE;
+    else if (iflags & ITOffline) mode = V_VOLUPD;
     else  { 
 	Log("1 Volser: TransCreate: Could not create trans, error %u\n",EINVAL);
 	LogError(EINVAL);
-- 
1.9.4