aix51-support-20020926
authorHartmut Reuter <reuter@rzg.mpg.de>
Thu, 26 Sep 2002 08:01:05 +0000 (08:01 +0000)
committerDerrick Brashear <shadow@dementia.org>
Thu, 26 Sep 2002 08:01:05 +0000 (08:01 +0000)
aix 5.1 support, not yet ready for prime-time

34 files changed:
Makefile.in
src/afs/AIX/osi_config.c
src/afs/AIX/osi_groups.c
src/afs/AIX/osi_vfsops.c
src/afs/AIX/osi_vnodeops.c
src/afs/LINUX/osi_vnodeops.c
src/afs/VNOPS/afs_vnop_attrs.c
src/afs/VNOPS/afs_vnop_read.c
src/afs/VNOPS/afs_vnop_write.c
src/afs/afs.h
src/afs/afs_daemons.c
src/afs/afs_dcache.c
src/afs/afs_init.c
src/afs/afs_osi.c
src/afs/afs_osi_pag.c
src/afs/afs_pioctl.c
src/afs/afs_trace.et
src/afs/sysincludes.h
src/cf/osconf.m4
src/comerr/compile_et.c
src/config/afs_sysnames.h
src/export/Makefile.in
src/export/cfgexport.c
src/export/export.c
src/libafs/MakefileProto.AIX.in
src/rx/rx_getaddr.c
src/rx/rx_kcommon.c
src/rx/rx_kernel.h
src/tsm41/aix41_auth.c
src/util/snprintf.c
src/vol/fssync.c
src/vol/volume.c
src/vol/volume.h
src/volser/volprocs.c

index 94a4b6e..ac9ac41 100644 (file)
@@ -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} ;; \
index 3800846..4708ac0 100644 (file)
@@ -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                       },
 };
 
index c998e39..4892e51 100644 (file)
@@ -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
index 12c3f39..ac1770f 100644 (file)
@@ -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
 };
 
 /*
index 93f7fe2..63330be 100644 (file)
@@ -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 = {
index efc5c04..99112c4 100644 (file)
@@ -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 {
index 6d903aa..98c8e86 100644 (file)
@@ -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;
 }
 
index 7334eac..e4475cb 100644 (file)
@@ -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 */
index 653ccc8..ceaab48 100644 (file)
@@ -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);
index 0f9e6da..fde6ae7 100644 (file)
@@ -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? */
 };
index b628379..fb3d4e9 100644 (file)
@@ -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
index 2a1027e..0bcd42a 100644 (file)
@@ -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.
index 5989acf..01e3d9d 100644 (file)
@@ -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
 
 /*
index 468655f..4fbce99 100644 (file)
@@ -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) {
index cb0adba..4b4f521 100644 (file)
@@ -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;
 }
index 463c703..a832050 100644 (file)
@@ -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
index 727ec0a..2f3f0c2 100644 (file)
@@ -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
 
index 92e6626..1d89b9f 100644 (file)
@@ -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"
index 367fa1f..8184567 100644 (file)
@@ -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"
index 16d09b4..6f869b9 100644 (file)
@@ -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)
 {
index 58e86d4..dd52090 100644 (file)
@@ -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
index 2c2f9b3..bedb6e4 100644 (file)
@@ -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
index 16f85c4..a5bfcc9 100644 (file)
@@ -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"
index 98d7b6d..439f79c 100644 (file)
@@ -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);
 }
 
index 76a047c..481e77c 100644 (file)
@@ -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)
index 5aaf681..5f3039e 100644 (file)
@@ -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. */
            }
index 18e8ee3..51e7046 100644 (file)
@@ -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();
index fb5b094..46fbeef 100644 (file)
@@ -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);
index dadb0fe..054aaed 100644 (file)
@@ -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) {
     /*
index 3a626d1..a508db6 100644 (file)
@@ -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;
 
index d833bff..b911a16 100644 (file)
@@ -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;
index dd75104..4394ffd 100644 (file)
@@ -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", 
index cd15545..2750b10 100644 (file)
@@ -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 */
index 15bf1a1..438f2f8 100644 (file)
@@ -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);