Cleanup AFS_*LINUX_ENV usage
[openafs.git] / src / rx / xdr_rx.c
1 /*
2  * Copyright 2000, International Business Machines Corporation and others.
3  * All Rights Reserved.
4  *
5  * This software has been released under the terms of the IBM Public
6  * License.  For details, see the LICENSE file in the top-level source
7  * directory or online at http://www.openafs.org/dl/license10.html
8  */
9
10 /*
11  * xdr_rx.c.  XDR using RX.
12  */
13
14 #include <afsconfig.h>
15 #include <afs/param.h>
16
17 #ifdef KERNEL
18 # include "afs/sysincludes.h"
19 # ifndef UKERNEL
20 #  include "h/types.h"
21 #  include "h/uio.h"
22 #  ifdef AFS_LINUX_ENV
23 #   include "h/socket.h"
24 #   ifndef quad_t
25 #    define quad_t __quad_t
26 #    define u_quad_t __u_quad_t
27 #   endif
28 #  endif
29 #  include "netinet/in.h"
30 # endif /* !UKERNEL */
31 #else /* KERNEL */
32 # include <roken.h>
33 #endif /* KERNEL */
34
35 #include "rx.h"
36 #include "xdr.h"
37
38 /* Static prototypes */
39 static bool_t xdrrx_getint32(XDR *axdrs, afs_int32 * lp);
40 static bool_t xdrrx_putint32(XDR *axdrs, afs_int32 * lp);
41 static bool_t xdrrx_getbytes(XDR *axdrs, caddr_t addr,
42                              u_int len);
43 static bool_t xdrrx_putbytes(XDR *axdrs, caddr_t addr,
44                              u_int len);
45 static afs_int32 *xdrrx_inline(XDR *axdrs, u_int len);
46
47
48 /*
49  * Ops vector for stdio type XDR
50  */
51 static struct xdr_ops xdrrx_ops = {
52 #ifndef HAVE_STRUCT_LABEL_SUPPORT
53     /* Windows does not support labeled assigments */
54     xdrrx_getint32,     /* deserialize an afs_int32 */
55     xdrrx_putint32,     /* serialize an afs_int32 */
56     xdrrx_getbytes,     /* deserialize counted bytes */
57     xdrrx_putbytes,     /* serialize counted bytes */
58     NULL,               /* get offset in the stream: not supported. */
59     NULL,               /* set offset in the stream: not supported. */
60     xdrrx_inline,       /* prime stream for inline macros */
61     NULL,               /* destroy stream */
62 #else
63     .x_getint32 = xdrrx_getint32,       /* deserialize an afs_int32 */
64     .x_putint32 = xdrrx_putint32,       /* serialize an afs_int32 */
65     .x_getbytes = xdrrx_getbytes,       /* deserialize counted bytes */
66     .x_putbytes = xdrrx_putbytes,       /* serialize counted bytes */
67     .x_getpostn = NULL,         /* get offset in the stream: not supported. */
68     .x_setpostn = NULL,         /* set offset in the stream: not supported. */
69     .x_inline = xdrrx_inline,           /* prime stream for inline macros */
70     .x_destroy = NULL,                  /* destroy stream */
71 #endif
72 };
73
74 /*
75  * Initialize an rx xdr handle, for a given rx call.  op must be XDR_ENCODE or XDR_DECODE.
76  * Call must have been returned by rx_MakeCall or rx_GetCall.
77  */
78 void
79 xdrrx_create(XDR * xdrs, struct rx_call *call,
80              enum xdr_op op)
81 {
82     xdrs->x_op = op;
83     xdrs->x_ops = &xdrrx_ops;
84     xdrs->x_private = (caddr_t) call;
85 }
86
87 #if     defined(KERNEL) && defined(AFS_AIX32_ENV)
88 #define STACK_TO_PIN    2*PAGESIZE      /* 8K */
89 int rx_pin_failed = 0;
90 #endif
91
92 static bool_t
93 xdrrx_getint32(XDR *axdrs, afs_int32 * lp)
94 {
95     afs_int32 l;
96     XDR * xdrs = (XDR *)axdrs;
97     struct rx_call *call = ((struct rx_call *)(xdrs)->x_private);
98 #if     defined(KERNEL) && defined(AFS_AIX32_ENV)
99     char *saddr = (char *)&l;
100     saddr -= STACK_TO_PIN;
101     /*
102      * Hack of hacks: Aix3.2 only guarantees that the next 2K of stack in pinned. Under
103      * splnet (disables interrupts), which is set throughout rx, we can't swap in stack
104      * pages if we need so we panic. Since sometimes, under splnet, we'll use more than
105      * 2K stack we could try to bring the next few stack pages in here before we call the rx
106      * layer. Of course this doesn't guarantee that those stack pages won't be swapped
107      * out between here and calling splnet. So we now pin (and unpin) them instead to
108      * guarantee that they remain there.
109      */
110     if (pin(saddr, STACK_TO_PIN)) {
111         /* XXX There's little we can do by continue XXX */
112         saddr = NULL;
113         rx_pin_failed++;
114     }
115 #endif
116     if (rx_Read32(call, &l) == sizeof(l)) {
117         *lp = ntohl(l);
118 #if     defined(KERNEL) && defined(AFS_AIX32_ENV)
119         if (saddr)
120             unpin(saddr, STACK_TO_PIN);
121 #endif
122         return TRUE;
123     }
124 #if     defined(KERNEL) && defined(AFS_AIX32_ENV)
125     if (saddr)
126         unpin(saddr, STACK_TO_PIN);
127 #endif
128     return FALSE;
129 }
130
131 static bool_t
132 xdrrx_putint32(XDR *axdrs, afs_int32 * lp)
133 {
134     afs_int32 code, l = htonl(*lp);
135     XDR * xdrs = (XDR *)axdrs;
136     struct rx_call *call = ((struct rx_call *)(xdrs)->x_private);
137 #if     defined(KERNEL) && defined(AFS_AIX32_ENV)
138     char *saddr = (char *)&code;
139     saddr -= STACK_TO_PIN;
140     /*
141      * Hack of hacks: Aix3.2 only guarantees that the next 2K of stack in pinned. Under
142      * splnet (disables interrupts), which is set throughout rx, we can't swap in stack
143      * pages if we need so we panic. Since sometimes, under splnet, we'll use more than
144      * 2K stack we could try to bring the next few stack pages in here before we call the rx
145      * layer. Of course this doesn't guarantee that those stack pages won't be swapped
146      * out between here and calling splnet. So we now pin (and unpin) them instead to
147      * guarantee that they remain there.
148      */
149     if (pin(saddr, STACK_TO_PIN)) {
150         saddr = NULL;
151         rx_pin_failed++;
152     }
153 #endif
154     code = (rx_Write32(call, &l) == sizeof(l));
155 #if     defined(KERNEL) && defined(AFS_AIX32_ENV)
156     if (saddr)
157         unpin(saddr, STACK_TO_PIN);
158 #endif
159     return code;
160 }
161
162 static bool_t
163 xdrrx_getbytes(XDR *axdrs, caddr_t addr, u_int len)
164 {
165     afs_int32 code;
166     XDR * xdrs = (XDR *)axdrs;
167     struct rx_call *call = ((struct rx_call *)(xdrs)->x_private);
168 #if     defined(KERNEL) && defined(AFS_AIX32_ENV)
169     char *saddr = (char *)&code;
170     saddr -= STACK_TO_PIN;
171     /*
172      * Hack of hacks: Aix3.2 only guarantees that the next 2K of stack in pinned. Under
173      * splnet (disables interrupts), which is set throughout rx, we can't swap in stack
174      * pages if we need so we panic. Since sometimes, under splnet, we'll use more than
175      * 2K stack we could try to bring the next few stack pages in here before we call the rx
176      * layer. Of course this doesn't guarantee that those stack pages won't be swapped
177      * out between here and calling splnet. So we now pin (and unpin) them instead to
178      * guarantee that they remain there.
179      */
180     if (pin(saddr, STACK_TO_PIN)) {
181         /* XXX There's little we can do by continue XXX */
182         saddr = NULL;
183         rx_pin_failed++;
184     }
185 #endif
186     code = (rx_Read(call, addr, len) == len);
187 #if     defined(KERNEL) && defined(AFS_AIX32_ENV)
188     if (saddr)
189         unpin(saddr, STACK_TO_PIN);
190 #endif
191     return code;
192 }
193
194 static bool_t
195 xdrrx_putbytes(XDR *axdrs, caddr_t addr, u_int len)
196 {
197     afs_int32 code;
198     XDR * xdrs = (XDR *)axdrs;
199     struct rx_call *call = ((struct rx_call *)(xdrs)->x_private);
200 #if     defined(KERNEL) && defined(AFS_AIX32_ENV)
201     char *saddr = (char *)&code;
202     saddr -= STACK_TO_PIN;
203     /*
204      * Hack of hacks: Aix3.2 only guarantees that the next 2K of stack in pinned. Under
205      * splnet (disables interrupts), which is set throughout rx, we can't swap in stack
206      * pages if we need so we panic. Since sometimes, under splnet, we'll use more than
207      * 2K stack we could try to bring the next few stack pages in here before we call the rx
208      * layer. Of course this doesn't guarantee that those stack pages won't be swapped
209      * out between here and calling splnet. So we now pin (and unpin) them instead to
210      * guarantee that they remain there.
211      */
212     if (pin(saddr, STACK_TO_PIN)) {
213         /* XXX There's little we can do by continue XXX */
214         saddr = NULL;
215         rx_pin_failed++;
216     }
217 #endif
218     code = (rx_Write(call, addr, len) == len);
219 #if     defined(KERNEL) && defined(AFS_AIX32_ENV)
220     if (saddr)
221         unpin(saddr, STACK_TO_PIN);
222 #endif
223     return code;
224 }
225
226 static afs_int32 *
227 xdrrx_inline(XDR *axdrs, u_int len)
228 {
229     /* I don't know what this routine is supposed to do, but the stdio module returns null, so we will, too */
230     return (0);
231 }