mrafs-client-extensions-including-afs-int64-20010210
authorHartmut Reuter <reuter@rzg.mpg.de>
Sat, 10 Feb 2001 21:26:14 +0000 (21:26 +0000)
committerDerrick Brashear <shadow@dementia.org>
Sat, 10 Feb 2001 21:26:14 +0000 (21:26 +0000)
"       Extensions used by MR-AFS in the client. I have added only two
        pioctl-calls which are used by the "fs"-command for a large number
        of MR-AFS specific subcommands. With this modification also the
        data type afs_int64 is introduced because MR-AFS supports large files.
        afs_int64 is either "long long" or a structure consisting of two
        32-bit numbers. We are already running on rs_aix42 a fully large-file
        capable AFS-client, but these changes are still in a beta test and
        not yet added here."

16 files changed:
src/afs/afs_pioctl.c
src/afs/afs_stats.h
src/afs/afs_trace.et
src/config/param.i386_linux22.h
src/config/stds.h
src/config/venus.h
src/fsint/afsint.xg
src/libafs/MakefileProto.AIX
src/libafs/MakefileProto.LINUX
src/libafsrpc/Makefile
src/libuafs/Makefile.common
src/rx/Makefile
src/rx/xdr.h
src/rx/xdr_int64.c [new file with mode: 0644]
src/rxgen/rpc_main.c
src/viced/afsfileprocs.c

index 314f617..d4d0037 100644 (file)
@@ -61,6 +61,7 @@ static int PSetSPrefs33(), PStoreBehind(), PGCPAGs();
 static int PGetCPrefs(), PSetCPrefs(); /* client network addresses */
 static int PGetInitParams(), PFlushMount(), PRxStatProc(), PRxStatPeer();
 static int PGetRxkcrypt(), PSetRxkcrypt();
+static int PPrefetchFromTape(), PResidencyCmd();
 int PExportAfs();
 
 static int HandleClientContext(struct afs_ioctl *ablob, int *com, struct AFS_UCRED **acred, struct AFS_UCRED *credp);
@@ -134,6 +135,8 @@ static int (*(pioctlSw[]))() = {
   PNoop,                       /* 63 -- arla: print xfs status */
   PNoop,                       /* 64 -- arla: force cache check */
   PNoop,                       /* 65 -- arla: break callback */
+  PPrefetchFromTape,            /* 66 -- MR-AFS: prefetch file from tape */
+  PResidencyCmd,                /* 67 -- MR-AFS: generic commnd interface */
 };
 
 #define PSetClientContext 99   /*  Special pioctl to setup caller's creds  */
@@ -3555,3 +3558,163 @@ out:
     return code;
 }
 
+static PPrefetchFromTape(avc, afun, areq, ain, aout, ainSize, aoutSize)
+  struct vcache *avc;
+  int afun;
+  struct vrequest *areq;
+  char *ain, *aout;
+  afs_int32 ainSize;
+  afs_int32 *aoutSize;  /* set this */
+{
+    register afs_int32 code, code1;
+    afs_int32 bytes;
+    struct conn *tc;
+    struct rx_call *tcall;
+    struct AFSVolSync tsync;
+    struct AFSFetchStatus OutStatus;
+    struct AFSCallBack CallBack;
+    struct VenusFid tfid;
+    struct AFSFid *Fid;
+    struct vcache *tvc;
+    XSTATS_DECLS;
+
+    AFS_STATCNT(PSetAcl);
+    if (!avc)
+      return EINVAL;
+
+    if (ain && (ainSize == 3 * sizeof(afs_int32)))
+        Fid = (struct AFSFid *) ain;
+    else
+        Fid = &avc->fid.Fid;
+    tfid.Cell = avc->fid.Cell;
+    tfid.Fid.Volume = Fid->Volume;
+    tfid.Fid.Vnode = Fid->Vnode;
+    tfid.Fid.Unique = Fid->Unique;
+
+    tvc = afs_GetVCache(&tfid, areq, (afs_int32 *)0, (struct vcache *)0,
+                                WRITE_LOCK);
+    if (!tvc) {
+        afs_Trace3(afs_iclSetp, CM_TRACE_PREFETCHCMD,
+                ICL_TYPE_POINTER, tvc,
+                ICL_TYPE_FID, &tfid,
+                ICL_TYPE_FID, &avc->fid);
+        return ENOENT;
+    }
+    afs_Trace3(afs_iclSetp, CM_TRACE_PREFETCHCMD,
+                ICL_TYPE_POINTER, tvc,
+                ICL_TYPE_FID, &tfid,
+                ICL_TYPE_FID, &tvc->fid);
+
+    do {
+        tc = afs_Conn(&tvc->fid, areq, SHARED_LOCK);
+        if (tc) {
+
+#ifdef RX_ENABLE_LOCKS
+            AFS_GUNLOCK();
+#endif /* RX_ENABLE_LOCKS */
+            tcall = rx_NewCall(tc->id);
+            code = StartRXAFS_FetchData(tcall,
+                                (struct AFSFid *) &tvc->fid.Fid, 0, 0);
+            if (!code) {
+                bytes = rx_Read(tcall, (char *) aout, sizeof(afs_int32));
+                code = EndRXAFS_FetchData(tcall, &OutStatus, &CallBack, &tsync);
+            }
+            code1 = rx_EndCall(tcall, code);
+#ifdef RX_ENABLE_LOCKS
+            AFS_GLOCK();
+#endif /* RX_ENABLE_LOCKS */
+        } else
+            code = -1;
+    } while
+        (afs_Analyze(tc, code, &tvc->fid, areq, 
+               AFS_STATS_FS_RPCIDX_RESIDENCYRPCS, SHARED_LOCK, 
+               (struct cell *)0));
+    /* This call is done only to have the callback things handled correctly */
+    afs_FetchStatus(tvc, &tfid, areq, &OutStatus);
+    afs_PutVCache(tvc, WRITE_LOCK);
+
+    if (!code) {
+        *aoutSize = sizeof(afs_int32);
+    }
+    return code;
+}
+
+static PResidencyCmd(avc, afun, areq, ain, aout, ainSize, aoutSize)
+struct vcache *avc;
+int afun;
+struct vrequest *areq;
+char *ain, *aout;
+afs_int32 ainSize;
+afs_int32 *aoutSize;        /* set this */
+{
+    register afs_int32 code;
+    struct conn *tc;
+    struct vcache *tvc;
+    struct ResidencyCmdInputs *Inputs;
+    struct ResidencyCmdOutputs *Outputs;
+    struct VenusFid tfid;
+    struct AFSFid *Fid;
+
+    Inputs = (struct ResidencyCmdInputs *) ain;
+    Outputs = (struct ResidencyCmdOutputs *) aout;
+    if (!avc) return EINVAL;
+    if (!ain || ainSize != sizeof(struct ResidencyCmdInputs)) return EINVAL;
+
+    Fid = &Inputs->fid;
+    if (!Fid->Volume)
+        Fid = &avc->fid.Fid;
+
+    tfid.Cell = avc->fid.Cell;
+    tfid.Fid.Volume = Fid->Volume;
+    tfid.Fid.Vnode = Fid->Vnode;
+    tfid.Fid.Unique = Fid->Unique;
+
+    tvc = afs_GetVCache(&tfid, areq, (afs_int32 *)0, (struct vcache *)0,
+                                WRITE_LOCK);
+    afs_Trace3(afs_iclSetp, CM_TRACE_RESIDCMD,
+                ICL_TYPE_POINTER, tvc,
+                ICL_TYPE_INT32, Inputs->command,
+                ICL_TYPE_FID, &tfid);
+    if (!tvc)
+        return ENOENT;
+
+    if (Inputs->command) {
+        do {
+            tc = afs_Conn(&tvc->fid, areq, SHARED_LOCK);
+            if (tc) {
+#ifdef RX_ENABLE_LOCKS
+                AFS_GUNLOCK();
+#endif /* RX_ENABLE_LOCKS */
+                code = RXAFS_ResidencyCmd(tc->id, Fid,
+                                 Inputs,
+                                 (struct ResidencyCmdOutputs *) aout);
+#ifdef RX_ENABLE_LOCKS
+                AFS_GLOCK();
+#endif /* RX_ENABLE_LOCKS */
+            } else
+                code = -1;
+        } while
+          (afs_Analyze(tc, code, &tvc->fid, areq, 
+               AFS_STATS_FS_RPCIDX_RESIDENCYRPCS, SHARED_LOCK,
+                (struct cell *)0));
+       /* This call is done to have the callback things handled correctly */
+       afs_FetchStatus(tvc, &tfid, areq, &Outputs->status);
+    } else { /* just a status request, return also link data */
+        code = 0;
+        Outputs->code = afs_FetchStatus(tvc, &tfid, areq, &Outputs->status);
+        Outputs->chars[0] = 0;
+        if (vType(tvc) == VLNK) {
+            ObtainWriteLock(&tvc->lock,555);
+            if (afs_HandleLink(tvc, areq) == 0)
+                strncpy((char *) &Outputs->chars, tvc->linkData, MAXCMDCHARS);
+            ReleaseWriteLock(&tvc->lock);
+        }
+    }
+
+    afs_PutVCache(tvc, WRITE_LOCK);
+
+    if (!code) {
+        *aoutSize = sizeof(struct ResidencyCmdOutputs);
+    }
+    return code;
+}                                  
index 1703b2c..a0919dc 100644 (file)
@@ -838,6 +838,7 @@ struct afs_stats_CMPerf {
 #define AFS_STATS_FS_RPCIDX_XSTATSVERSION      26
 #define AFS_STATS_FS_RPCIDX_GETXSTATS          27
 #define AFS_STATS_FS_RPCIDX_XLOOKUP             28
+#define AFS_STATS_FS_RPCIDX_RESIDENCYRPCS       29
 
 #define AFS_STATS_NUM_FS_RPC_OPS               29
 
index cc0e31d..ad4fc97 100644 (file)
@@ -127,5 +127,7 @@ error_table 2 zcm
        ec      CM_TRACE_READPAGE, "Ireadpage ip 0x%lx pp 0x%x count 0x%x code %x"
        ec      CM_TRACE_UPDATEPAGE, "Iupdatepage ip 0x%lx pp 0x%x count 0x%x code %d"
        ec      CM_TRACE_VM_CLOSE, "VMclose ip 0x%lx mapcnt %d opens %d XoW %d"
+       ec      CM_TRACE_PREFETCHCMD, "PrefetchCmd tvc 0x%x tfid (%d:%d.%d.%d) fid (%d:%d.%d.%d)"
+       ec      CM_TRACE_RESIDCMD, "ResidencyCmd tvc 0x%x command %d fid (%d:%d.%d.%d)"
 end
 
index 3d0c197..76a4939 100644 (file)
@@ -25,6 +25,7 @@
 
 #define AFS_MOUNT_AFS "afs"    /* The name of the filesystem type. */
 #define AFS_SYSCALL 137
+#define AFS_64BIT_ENV
 #define AFS_64BIT_IOPS_ENV  1
 #define AFS_NAMEI_ENV     1   /* User space interface to file system */
 #include <afs/afs_sysnames.h>
index de40ca9..6c59c8a 100644 (file)
@@ -55,11 +55,50 @@ typedef unsigned short   afs_uint16;
 #ifdef  AFS_64BIT_ENV
 typedef int              afs_int32;
 typedef unsigned int     afs_uint32;
+typedef long long       afs_int64;
+typedef  unsigned long long afs_uint64;
+ #define ZeroInt64(a)       (a) = 0
+ #define AssignInt64(a, b)   *(a) = (b)
+ #define AddInt64(a,b,c) *(c) = (a) + (b)
+ #define SubtractInt64(a,b,c) *(c) = (a) - (b)
+ #define CompareInt64(a,b) (a) - (b)
+ #define NonZeroInt64(a)                (a)
+ #define Int64ToInt32(a)    (a) & 0xFFFFFFFFL
+ #define FillInt64(t,h,l) (t) = (h); (t) <<= 32; (t) |= (l);
+ #define SplitInt64(t,h,l) (h) = (t) >> 32; (l) = (t) & 0xFFFFFFFF;
 #else   /* AFS_64BIT_ENV */
 typedef long             afs_int32;
 typedef unsigned long    afs_uint32;
+
+ struct Int64 {
+    afs_int32 high;
+    afs_uint32 low;
+ };
+ typedef struct Int64 afs_int64;
+
+ struct u_Int64 {
+    afs_uint32 high;
+    afs_uint32 low;
+ };
+ typedef struct u_Int64 afs_uint64;
+ #define ZeroInt64(a) (a).high = (a).low = 0
+ #define AssignInt64(a, b) (b)->high = (a).high; (b)->low = (a).low
+ #define NonZeroInt64(a)   (a).low || (a).high
+ #define Int64ToInt32(a)    (a).low
+ #define FillInt64(t,h,l) (t).high = (h); (t).low = (l);
+ #define SplitInt64(t,h,l) (h) = (t).high; (l) = (t).low;
 #endif  /* AFS_64BIT_ENV */
 
+/* AFS_64BIT_CLIENT should presently be set only for AFS_64BIT_ENV systems */
+
+#ifdef AFS_64BIT_CLIENT
+typedef afs_int64 afs_size_t;
+typedef afs_uint64 afs_offs_t;
+#else /* AFS_64BIT_CLIENT */
+typedef afs_int32 afs_size_t;
+typedef afs_uint32 afs_offs_t;
+#endif /* AFS_64BIT_CLIENT */
+
 /* you still have to include <netinet/in.h> to make these work */
 
 #define hton32 htonl
index 1b019a1..ec1263a 100644 (file)
@@ -176,5 +176,6 @@ struct cm_initparams {
 #define VIOC_RXSTAT_PEER       _VICEIOCTL(54)  /* Control peer RX stats */
 #define VIOC_GETRXKCRYPT        _VICEIOCTL(55)  /* Set rxkad enc flag */
 #define VIOC_SETRXKCRYPT        _VICEIOCTL(56)  /* Set rxkad enc flag */
-
+#define VIOC_PREFETCHTAPE       _VICEIOCTL(66)  /* MR-AFS prefetch from tape */
+#define VIOC_RESIDENCY_CMD      _VICEIOCTL(67)  /* generic MR-AFS cmds */
 #endif /* AFS_VENUS_H */
index c55fe08..bb3e516 100644 (file)
@@ -298,6 +298,26 @@ const FLUSHMAX = 10;
 typedef afs_int32 ViceIds<FLUSHMAX>;
 typedef        afs_int32 IPAddrs<FLUSHMAX>;
 
+%#define MAXCMDINT64S                           3
+%#define MAXCMDINT32S                           200
+%#define MAXCMDCHARS                            256
+
+struct ResidencyCmdInputs {
+    afs_int32  command;
+    struct AFSFid fid;
+    afs_int64  int64s[MAXCMDINT64S];
+    afs_uint32 int32s[MAXCMDINT32S];
+    char       chars[MAXCMDCHARS];
+};
+
+struct ResidencyCmdOutputs {
+    afs_int32  code;
+    struct AFSFetchStatus status;
+    afs_int64  int64s[MAXCMDINT64S];
+    afs_uint32 int32s[MAXCMDINT32S];
+    char       chars[MAXCMDCHARS];
+}; 
+
 package RXAFS_
 prefix S
 statindex 7
@@ -544,3 +564,9 @@ DFSSymlink(
   AFSCallBack *CallBack,
   AFSVolSync *Sync
 ) = 163;
+
+ResidencyCmd(
+  IN AFSFid *Fid,
+  IN struct ResidencyCmdInputs *Inputs,
+  OUT struct ResidencyCmdOutputs *Outputs
+) = 220; 
index d518d95..b3f6544 100644 (file)
@@ -23,6 +23,7 @@ AFS_OS_OBJS = \
        osi_timeout.o \
        osi_vm.o \
        xdr.o \
+       xdr_int64.o \
        xdr_array.o
 
 AFSNOIAUTHOBJS = \
@@ -129,6 +130,8 @@ libafs: $(DEST_LIBAFS) $(DEST_LIBAFSIAUTH)
 # Common objects
 xdr.o: $(RX)/xdr.c
        $(CRULE1);
+xdr_int64.o: $(RX)/xdr_int64.c
+       $(CRULE1);
 
 xdr_array.o: $(RX)/xdr_array.c
        $(CRULE1);
index cb6cd68..6e141c2 100644 (file)
@@ -25,6 +25,7 @@ AFS_OS_OBJS = \
        osi_vm.o \
        osi_vnodeops.o \
        xdr.o \
+       xdr_int64.o \
        xdr_array.o
 
 AFS_OS_NFSOBJS =
@@ -190,5 +191,7 @@ osi_vnodeops.o: $(AFS)/osi_vnodeops.c
        $(CRULE1);
 xdr.o: $(RX)/xdr.c
        $(CRULE1);
+xdr_int64.o: $(RX)/xdr_int64.c
+       $(CRULE1);
 xdr_array.o: $(RX)/xdr_array.c
        $(CRULE1);
index eec9a2a..fbc116a 100644 (file)
@@ -41,6 +41,7 @@ COMERROBJS =\
 XDROBJS =\
        xdr_arrayn.o \
        xdr_rx.o \
+       xdr_int64.o \
        xdr_afsuuid.o \
        AFS_component_version_number.o
 
@@ -192,6 +193,9 @@ AFS_component_version_number.o: ${RX}/AFS_component_version_number.c
 xdr.o: ${RX}/xdr.c
        ${CCRULE};
 
+xdr_int64.o: ${RX}/xdr_int64.c
+       ${CCRULE};
+
 xdr_array.o: ${RX}/xdr_array.c
        ${CCRULE};
 
index 2b13b6e..3957c7f 100644 (file)
@@ -155,7 +155,8 @@ UAFSOBJ = \
        $(UOBJ)/hostparse.o \
        $(UOBJ)/Krxstat.ss.o \
        $(UOBJ)/Krxstat.xdr.o \
-       $(UOBJ)/rxstat.o
+       $(UOBJ)/rxstat.o \
+       $(UOBJ)/xdr_int64.o
 
 AFSWEBOBJ = \
        $(WEBOBJ)/afs_atomlist.o \
@@ -521,6 +522,8 @@ $(UOBJ)/rx_conncache.o: $(RX)/rx_conncache.c
        $(CRULE1);
 $(UOBJ)/xdr_rx.o: $(RX)/xdr_rx.c
        $(CRULE1);
+$(UOBJ)/xdr_int64.o: $(RX)/xdr_int64.c
+       $(CRULE1);
 $(UOBJ)/afs_usrops.o: $(AFS)/afs_usrops.c
        $(CRULE1);
 $(UOBJ)/afs_uuid.o: $(AFS)/afs_uuid.c
index bc09d2d..f4af352 100644 (file)
@@ -24,7 +24,8 @@ CFLAGS = ${OPTMZ} -I${SRCDIR}include -DRXDEBUG ${XCFLAGS}
 XDROBJS = xdr_arrayn.o xdr_rx.o xdr_afsuuid.o
 
 RXOBJS = rx_clock.o rx_event.o rx_user.o rx_lwp.o rx.o rx_null.o rx_globals.o \
-       rx_getaddr.o rx_misc.o rx_packet.o rx_rdwr.o  rx_trace.o rx_conncache.o
+       rx_getaddr.o rx_misc.o rx_packet.o rx_rdwr.o  rx_trace.o rx_conncache.o \
+       xdr_int64.o
 
 MULTIOBJS = rx_multi.o
 
@@ -43,7 +44,7 @@ KSRCS = rx.c rx.h rx_clock.c rx_clock.h rx_event.c rx_event.h \
        rx_null.c rx_null.h rx_queue.h rx_getaddr.c rx_packet.c rx_packet.h \
        rx_multi.h rx_kcommon.h rx_kcommon.c \
        xdr.c xdr.h xdr_array.c xdr_arrayn.c xdr_rx.c rx_misc.c rx_rdwr.c \
-       xdr_afsuuid.c rx_trace.h
+       xdr_afsuuid.c rx_trace.h xdr_int64.c
 UKSRCS = $(KSRCS) rx_conncache.c
 
 include ../config/Makefile.version
index 7fb7781..0953350 100644 (file)
@@ -304,6 +304,8 @@ extern bool_t       xdr_double();
 extern bool_t  xdr_reference();
 extern bool_t  xdr_wrapstring();
 extern bool_t  xdr_vector();
+extern bool_t   xdr_int64();
+extern bool_t   xdr_uint64();
 
 /*
  * These are the public routines for the various implementations of
diff --git a/src/rx/xdr_int64.c b/src/rx/xdr_int64.c
new file mode 100644 (file)
index 0000000..62c40c9
--- /dev/null
@@ -0,0 +1,131 @@
+
+/*
+ *  XDR routine for int64 (long long or struct)
+ */
+
+#if defined(KERNEL) && !defined(UKERNEL)
+#include "afs/param.h"
+#ifdef AFS_LINUX20_ENV
+#include "../h/string.h"
+#define bzero(A,C) memset((A), 0, (C))
+#else
+#include <sys/param.h>
+#include <sys/systm.h>
+#endif
+#else
+#include <stdio.h>
+#endif
+#include "xdr.h"
+#if defined(KERNEL) && !defined(UKERNEL)
+#ifdef        AFS_DEC_ENV
+#include <afs/longc_procs.h>
+#endif
+#endif
+
+#ifndef lint
+static char sccsid[] = "@(#)xdr_array.c 1.1 86/02/03 Copyr 1984 Sun Micro";
+#endif
+
+#ifdef AFS_64BIT_ENV
+/*
+ * XDR afs_int64 integers
+ */
+bool_t
+xdr_int64(xdrs, ulp)
+        register XDR *xdrs;
+        afs_int64 *ulp;
+{
+        static afs_int32 high;
+        static afs_uint32 low;
+
+        if (xdrs->x_op == XDR_DECODE) {
+                if (!XDR_GETINT32(xdrs, (afs_int32 *) &high)) return (FALSE);
+                if (!XDR_GETINT32(xdrs, (afs_int32 *) &low)) return (FALSE);
+                *ulp = high;
+                *ulp <<= 32;
+                *ulp += low;
+                return (TRUE);
+        }
+        if (xdrs->x_op == XDR_ENCODE) {
+                high = (*ulp >> 32);
+                low = *ulp & 0xFFFFFFFFL;
+                if (!XDR_PUTINT32(xdrs, (afs_int32 *) &high)) return (FALSE);
+                return (XDR_PUTINT32(xdrs, (afs_int32 *) &low));
+        }
+        if (xdrs->x_op == XDR_FREE)
+                return (TRUE);
+        return (FALSE);
+}
+
+/*
+ * XDR afs_int64 integers
+ */
+bool_t
+xdr_uint64(xdrs, ulp)
+        register XDR *xdrs;
+        afs_uint64 *ulp;
+{
+        static afs_uint32 high;
+        static afs_uint32 low;
+
+        if (xdrs->x_op == XDR_DECODE) {
+                if (!XDR_GETINT32(xdrs, (afs_uint32 *) &high)) return (FALSE);
+                if (!XDR_GETINT32(xdrs, (afs_uint32 *) &low)) return (FALSE);
+                *ulp = high;
+                *ulp <<= 32;
+                *ulp += low;
+                return (TRUE);
+        }
+        if (xdrs->x_op == XDR_ENCODE) {
+                high = (*ulp >> 32);
+                low = *ulp & 0xFFFFFFFFL;
+                if (!XDR_PUTINT32(xdrs, (afs_uint32 *) &high)) return (FALSE);
+                return (XDR_PUTINT32(xdrs, (afs_uint32 *) &low));
+        }
+        if (xdrs->x_op == XDR_FREE)
+                return (TRUE);
+        return (FALSE);
+}
+#else /* AFS_64BIT_ENV */
+/*
+ * XDR afs_int64 integers
+ */
+bool_t
+xdr_int64(xdrs, ulp)
+        register XDR *xdrs;
+        afs_int64 *ulp;
+{
+        if (xdrs->x_op == XDR_DECODE) {
+                if (!XDR_GETINT32(xdrs, (afs_int32 *) &ulp->high)) return (FALSE);
+                return (XDR_GETINT32(xdrs, (afs_int32 *) &ulp->low));
+        }
+        if (xdrs->x_op == XDR_ENCODE) {
+                if (!XDR_PUTINT32(xdrs, (afs_int32 *) &ulp->high)) return (FALSE);
+                return (XDR_PUTINT32(xdrs, (afs_int32 *) &ulp->low));
+        }
+        if (xdrs->x_op == XDR_FREE)
+                return (TRUE);
+        return (FALSE);
+}
+
+/*
+ * XDR afs_uint64 integers
+ */
+bool_t
+xdr_uint64(xdrs, ulp)
+        register XDR *xdrs;
+        afs_uint64 *ulp;
+{
+        if (xdrs->x_op == XDR_DECODE) {
+                if (!XDR_GETINT32(xdrs, (afs_uint32 *) &ulp->high)) return (FALSE);
+                return (XDR_GETINT32(xdrs, (afs_uint32 *) &ulp->low));
+        }
+        if (xdrs->x_op == XDR_ENCODE) {
+                if (!XDR_PUTINT32(xdrs, (afs_uint32 *) &ulp->high)) return (FALSE);
+                return (XDR_PUTINT32(xdrs, (afs_uint32 *) &ulp->low));
+        }
+        if (xdrs->x_op == XDR_FREE)
+                return (TRUE);
+        return (FALSE);
+}
+#endif /* AFS_64BIT_ENV */
index 7b3a454..15d771f 100644 (file)
@@ -251,6 +251,12 @@ write_int32_macros(fout)
        f_print(fout, "#ifndef xdr_afs_uint32\n");
        f_print(fout, "#define xdr_afs_uint32 xdr_u_int\n");
        f_print(fout, "#endif\n");
+        f_print(fout, "#ifndef xdr_afs_int64\n");
+        f_print(fout, "#define xdr_afs_int64 xdr_int64\n");
+        f_print(fout, "#endif\n");
+        f_print(fout, "#ifndef xdr_afs_uint64\n");
+        f_print(fout, "#define xdr_afs_uint64 xdr_uint64\n");
+        f_print(fout, "#endif\n");
 #else
 #error Need to do some work here...
 #endif
@@ -560,6 +566,8 @@ h_output(infile, define, extend, outfile, append)
        f_print(fout, "#ifdef AFS_LINUX22_ENV\n");
        f_print(fout, "#include \"../rx/xdr.h\"\n");
        f_print(fout, "#else /* AFS_LINUX22_ENV */\n");
+       f_print(fout, "extern bool_t xdr_int64();\n");
+       f_print(fout, "extern bool_t xdr_uint64();\n");
        f_print(fout, "#include \"../rpc/xdr.h\"\n");
        f_print(fout, "#endif /* AFS_LINUX22_ENV */\n");
        f_print(fout, "#endif /* XDR_GETLONG */\n");
index ac0a9a1..d92e55b 100644 (file)
@@ -6896,3 +6896,11 @@ SRXAFS_DFSSymlink (tcon, DirFid, Name, LinkContents, InStatus, OutFid, OutFidSta
     return EINVAL;
 }
 
+SRXAFS_ResidencyCmd (tcon, Fid, Inputs, Outputs)
+    struct rx_connection *tcon;
+    struct AFSFid *Fid;
+    struct ResidencyCmdInputs *Inputs;
+    struct ResidencyCmdOutputs *Outputs;
+{
+    return EINVAL;
+}