054152c323479099b6b628c289320f203b71f77a
[openafs.git] / src / rx / LINUX / rx_knet.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  * rx_knet.c - RX kernel send, receive and timer routines.
12  *
13  * Linux implementation.
14  */
15 #include <afsconfig.h>
16 #include "afs/param.h"
17
18 RCSID
19     ("$Header$");
20
21 #include <linux/version.h>
22 #ifdef AFS_LINUX22_ENV
23 #include "rx/rx_kcommon.h"
24 #if defined(AFS_LINUX24_ENV)
25 #include "h/smp_lock.h"
26 #endif
27 #include <asm/uaccess.h>
28 #ifdef ADAPT_PMTU
29 #include <linux/errqueue.h>
30 #include <linux/icmp.h>
31 #endif
32
33 /* rxk_NewSocket
34  * open and bind RX socket
35  */
36 osi_socket *
37 rxk_NewSocketHost(afs_uint32 ahost, short aport)
38 {
39     struct socket *sockp;
40     struct sockaddr_in myaddr;
41     int code;
42     KERNEL_SPACE_DECL;
43 #ifdef ADAPT_PMTU
44     int pmtu = IP_PMTUDISC_WANT;
45     int do_recverr = 1;
46 #else
47     int pmtu = IP_PMTUDISC_DONT;
48 #endif
49
50     /* We need a better test for this. if you need it back, tell us
51      * how to detect it. 
52      */
53 #ifdef LINUX_KERNEL_SOCK_CREATE_V
54     code = sock_create(AF_INET, SOCK_DGRAM, IPPROTO_UDP, &sockp, 0);
55 #else
56     code = sock_create(AF_INET, SOCK_DGRAM, IPPROTO_UDP, &sockp);
57 #endif
58     if (code < 0)
59         return NULL;
60
61     /* Bind socket */
62     myaddr.sin_family = AF_INET;
63     myaddr.sin_addr.s_addr = ahost;
64     myaddr.sin_port = aport;
65     code =
66         sockp->ops->bind(sockp, (struct sockaddr *)&myaddr, sizeof(myaddr));
67
68     if (code < 0) {
69 #if defined(AFS_LINUX24_ENV)
70         printk("sock_release(rx_socket) FIXME\n");
71 #else
72         sock_release(sockp);
73 #endif
74         return NULL;
75     }
76
77     TO_USER_SPACE();
78     sockp->ops->setsockopt(sockp, SOL_IP, IP_MTU_DISCOVER, (char *)&pmtu,
79                            sizeof(pmtu));
80 #ifdef ADAPT_PMTU
81     sockp->ops->setsockopt(sockp, SOL_IP, IP_RECVERR, (char *)&do_recverr,
82                            sizeof(do_recverr));
83 #endif
84     TO_KERNEL_SPACE();
85     return (osi_socket *)sockp;
86 }
87
88 osi_socket *
89 rxk_NewSocket(short aport)
90 {
91     return rxk_NewSocketHost(htonl(INADDR_ANY), aport);
92 }
93
94 /* free socket allocated by osi_NetSocket */
95 int
96 rxk_FreeSocket(register struct socket *asocket)
97 {
98     AFS_STATCNT(osi_FreeSocket);
99     return 0;
100 }
101
102 #ifdef ADAPT_PMTU
103 void
104 handle_socket_error(osi_socket so)
105 {
106     KERNEL_SPACE_DECL;
107     struct msghdr msg;
108     struct cmsghdr *cmsg;
109     struct sock_extended_err *err;
110     struct sockaddr_in addr;
111     struct sockaddr *offender;
112     char *controlmsgbuf;
113     int code;
114     struct socket *sop = (struct socket *)so;
115
116     if (!(controlmsgbuf=rxi_Alloc(256)))
117         return;
118     msg.msg_name = &addr;
119     msg.msg_namelen = sizeof(addr);
120     msg.msg_iov = NULL;
121     msg.msg_iovlen = 0;
122     msg.msg_control = controlmsgbuf;
123     msg.msg_controllen = 256;
124     msg.msg_flags = 0;
125
126     TO_USER_SPACE();
127     code = sock_recvmsg(sop, &msg, 256, MSG_ERRQUEUE|MSG_DONTWAIT|MSG_TRUNC);
128     TO_KERNEL_SPACE();
129
130     if (code < 0 || !(msg.msg_flags & MSG_ERRQUEUE))
131         goto out;
132
133     for (cmsg = CMSG_FIRSTHDR(&msg); cmsg; cmsg = CMSG_NXTHDR(&msg, cmsg)) {
134         if (CMSG_OK(&msg, cmsg) && cmsg->cmsg_level == SOL_IP &&
135             cmsg->cmsg_type == IP_RECVERR)
136             break;
137     }
138     if (!cmsg)
139         goto out;
140     err = CMSG_DATA(cmsg);
141     offender = SO_EE_OFFENDER(err);
142     
143     if (offender->sa_family != AF_INET)
144        goto out;
145
146     memcpy(&addr, offender, sizeof(addr));
147
148     if (err->ee_origin == SO_EE_ORIGIN_ICMP &&
149         err->ee_type == ICMP_DEST_UNREACH &&
150         err->ee_code == ICMP_FRAG_NEEDED) {
151         rxi_SetPeerMtu(ntohl(addr.sin_addr.s_addr), ntohs(addr.sin_port),
152                        err->ee_info);
153     }
154     /* other DEST_UNREACH's and TIME_EXCEEDED should be dealt with too */
155
156 out:
157     rxi_Free(controlmsgbuf, 256);
158     return;
159 }
160 #endif
161
162 /* osi_NetSend
163  *
164  * Return codes:
165  * 0 = success
166  * non-zero = failure
167  */
168 int
169 osi_NetSend(osi_socket sop, struct sockaddr_in *to, struct iovec *iovec,
170             int iovcnt, afs_int32 size, int istack)
171 {
172     KERNEL_SPACE_DECL;
173     struct msghdr msg;
174     int code, sockerr;
175     size_t esize;
176
177 #ifdef ADAPT_PMTU
178     while (1) {
179         sockerr=0;
180         esize = sizeof(sockerr);
181         TO_USER_SPACE();
182         sop->ops->getsockopt(sop, SOL_SOCKET, SO_ERROR, (char *)&sockerr,
183                            &esize);
184         TO_KERNEL_SPACE();
185         if (sockerr == 0)
186            break;
187         handle_socket_error(sop);
188     }
189 #endif
190
191     msg.msg_iovlen = iovcnt;
192     msg.msg_iov = iovec;
193     msg.msg_name = to;
194     msg.msg_namelen = sizeof(*to);
195     msg.msg_control = NULL;
196     msg.msg_controllen = 0;
197     msg.msg_flags = 0;
198
199     TO_USER_SPACE();
200     code = sock_sendmsg(sop, &msg, size);
201     TO_KERNEL_SPACE();
202     return (code < 0) ? code : 0;
203 }
204
205
206 /* osi_NetReceive
207  * OS dependent part of kernel RX listener thread.
208  *
209  * Arguments:
210  *      so      socket to receive on, typically rx_socket
211  *      from    pointer to a sockaddr_in. 
212  *      iov     array of iovecs to fill in.
213  *      iovcnt  how many iovecs there are.
214  *      lengthp IN/OUT in: total space available in iovecs. out: size of read.
215  *
216  * Return
217  * 0 if successful
218  * error code (such as EINTER) if not
219  *
220  * Environment
221  *      Note that the maximum number of iovecs is 2 + RX_MAXWVECS. This is
222  *      so we have a little space to look for packets larger than 
223  *      rx_maxReceiveSize.
224  */
225 int rxk_lastSocketError;
226 int rxk_nSocketErrors;
227 int
228 osi_NetReceive(osi_socket so, struct sockaddr_in *from, struct iovec *iov,
229                int iovcnt, int *lengthp)
230 {
231     KERNEL_SPACE_DECL;
232     struct msghdr msg;
233     int code, sockerr;
234     size_t esize;
235     struct iovec tmpvec[RX_MAXWVECS + 2];
236     struct socket *sop = (struct socket *)so;
237
238     if (iovcnt > RX_MAXWVECS + 2) {
239         osi_Panic("Too many (%d) iovecs passed to osi_NetReceive\n", iovcnt);
240     }
241 #ifdef ADAPT_PMTU
242     while (1) {
243         sockerr=0;
244         esize = sizeof(sockerr);
245         TO_USER_SPACE();
246         sop->ops->getsockopt(sop, SOL_SOCKET, SO_ERROR, (char *)&sockerr,
247                            &esize);
248         TO_KERNEL_SPACE();
249         if (sockerr == 0)
250            break;
251         handle_socket_error(so);
252     }
253 #endif
254     memcpy(tmpvec, iov, iovcnt * sizeof(struct iovec));
255     msg.msg_name = from;
256     msg.msg_iov = tmpvec;
257     msg.msg_iovlen = iovcnt;
258     msg.msg_control = NULL;
259     msg.msg_controllen = 0;
260     msg.msg_flags = 0;
261
262     TO_USER_SPACE();
263     code = sock_recvmsg(sop, &msg, *lengthp, 0);
264     TO_KERNEL_SPACE();
265
266     if (code < 0) {
267 #ifdef AFS_LINUX26_ENV
268 #ifdef CONFIG_PM
269         if (
270 #ifdef PF_FREEZE
271             current->flags & PF_FREEZE
272 #else
273 #if defined(STRUCT_TASK_STRUCT_HAS_TODO)
274             !current->todo
275 #else
276 #if defined(STRUCT_TASK_STRUCT_HAS_THREAD_INFO)
277             test_ti_thread_flag(current->thread_info, TIF_FREEZE)
278 #else
279             test_ti_thread_flag(task_thread_info(current), TIF_FREEZE)
280 #endif
281 #endif
282 #endif
283             )
284 #ifdef LINUX_REFRIGERATOR_TAKES_PF_FREEZE
285             refrigerator(PF_FREEZE);
286 #else
287             refrigerator();
288 #endif
289             set_current_state(TASK_INTERRUPTIBLE);
290 #endif
291 #endif
292
293         /* Clear the error before using the socket again.
294          * Oh joy, Linux has hidden header files as well. It appears we can
295          * simply call again and have it clear itself via sock_error().
296          */
297 #ifdef AFS_LINUX22_ENV
298         flush_signals(current); /* We don't want no stinkin' signals. */
299 #else
300         current->signal = 0;    /* We don't want no stinkin' signals. */
301 #endif
302         rxk_lastSocketError = code;
303         rxk_nSocketErrors++;
304     } else {
305         *lengthp = code;
306         code = 0;
307     }
308
309     return code;
310 }
311 #ifdef EXPORTED_TASKLIST_LOCK
312 extern rwlock_t tasklist_lock __attribute__((weak));
313 #endif
314 void
315 osi_StopListener(void)
316 {
317     struct task_struct *listener;
318     extern int rxk_ListenerPid;
319     extern struct task_struct *rxk_ListenerTask;
320
321     while (rxk_ListenerTask) {
322         if (rxk_ListenerTask) {
323             flush_signals(rxk_ListenerTask);
324             force_sig(SIGKILL, rxk_ListenerTask);
325         }
326         if (!rxk_ListenerTask)
327             break;
328         afs_osi_Sleep(&rxk_ListenerTask);
329     }
330     sock_release(rx_socket);
331     rx_socket = NULL;
332 }
333
334 #endif /* AFS_LINUX22_ENV */