bozo: bosserver man page updates
[openafs.git] / src / rx / FBSD / 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 #include <afsconfig.h>
11 #include "afs/param.h"
12
13
14 #include <sys/malloc.h>
15 #include "rx/rx_kcommon.h"
16
17 #ifdef RXK_LISTENER_ENV
18 int
19 osi_NetReceive(osi_socket asocket, struct sockaddr_in *addr,
20                struct iovec *dvec, int nvecs, int *alength)
21 {
22     struct uio u;
23     int i;
24     struct iovec iov[RX_MAXIOVECS];
25     struct sockaddr *sa = NULL;
26     int code;
27
28     int haveGlock = ISAFS_GLOCK();
29     /*AFS_STATCNT(osi_NetReceive); */
30
31     if (nvecs > RX_MAXIOVECS)
32         osi_Panic("osi_NetReceive: %d: Too many iovecs.\n", nvecs);
33
34     for (i = 0; i < nvecs; i++)
35         iov[i] = dvec[i];
36
37     u.uio_iov = &iov[0];
38     u.uio_iovcnt = nvecs;
39     u.uio_offset = 0;
40     u.uio_resid = *alength;
41     u.uio_segflg = UIO_SYSSPACE;
42     u.uio_rw = UIO_READ;
43     u.uio_td = NULL;
44
45     if (haveGlock)
46         AFS_GUNLOCK();
47     code = soreceive(asocket, &sa, &u, NULL, NULL, NULL);
48     if (haveGlock)
49         AFS_GLOCK();
50
51     if (code) {
52 #if KNET_DEBUG
53         if (code == EINVAL)
54             Debugger("afs NetReceive busted");
55         else
56             printf("y");
57 #else
58         return code;
59 #endif
60     }
61     *alength -= u.uio_resid;
62     if (sa) {
63         if (sa->sa_family == AF_INET) {
64             if (addr)
65                 *addr = *(struct sockaddr_in *)sa;
66         } else
67             printf("Unknown socket family %d in NetReceive\n", sa->sa_family);
68         FREE(sa, M_SONAME);
69     }
70     return code;
71 }
72
73 extern int rxk_ListenerPid;
74 void
75 osi_StopListener(void)
76 {
77     struct sockaddr_in taddr;
78     struct iovec dvec;
79     struct proc *p;
80     char c;
81     c = '\0';
82
83     /*
84      * Have to drop global lock to safely do this.
85      * soclose() is currently protected by Giant,
86      * but pfind and psignal are MPSAFE.
87      */
88     int haveGlock = ISAFS_GLOCK();
89     if (haveGlock)
90         AFS_GUNLOCK();
91     soshutdown(rx_socket, SHUT_RDWR);
92     p = pfind(rxk_ListenerPid);
93     if (p) {
94         afs_warn("osi_StopListener: rxk_ListenerPid %u\n", rxk_ListenerPid);
95         psignal(p, SIGUSR1);
96         PROC_UNLOCK(p);
97     } else
98         afs_warn("osi_StopListener: rxk_Listener not found (pid %u)\n",
99             rxk_ListenerPid);
100
101     /* Avoid destroying socket until osi_NetReceive has
102     * had a chance to clean up.  Otherwise we can't restart. */
103     bzero(&taddr, sizeof(taddr));
104     taddr.sin_len = sizeof(struct sockaddr_in);
105     taddr.sin_family = AF_INET;
106     taddr.sin_port = rx_port;
107     taddr.sin_addr.s_addr = htonl(0x7f000001);  /* no place like localhost */
108     bzero(&dvec, sizeof(dvec));
109     dvec.iov_base = &c;
110     dvec.iov_len = 1;
111     /* afs_osi_Sleep requires the GLOCK */
112     AFS_GLOCK();
113     while(rxk_ListenerPid) {
114         afs_warn("waiting for rxk_ListenerPid to die\n");
115         osi_NetSend(rx_socket, &taddr, &dvec, 1, 1, 0);
116         afs_osi_Sleep(&rxk_ListenerPid);
117     }
118     AFS_GUNLOCK();
119     /* in theory, we are now the only people doing anything with rx_socket */
120     soclose(rx_socket);
121
122     if (haveGlock)
123         AFS_GLOCK();
124 }
125
126 int
127 osi_NetSend(osi_socket asocket, struct sockaddr_in *addr, struct iovec *dvec,
128             int nvecs, afs_int32 alength, int istack)
129 {
130     afs_int32 code;
131     int i;
132     struct iovec iov[RX_MAXIOVECS];
133     struct uio u;
134     int haveGlock = ISAFS_GLOCK();
135
136     AFS_STATCNT(osi_NetSend);
137     if (nvecs > RX_MAXIOVECS)
138         osi_Panic("osi_NetSend: %d: Too many iovecs.\n", nvecs);
139
140     for (i = 0; i < nvecs; i++)
141         iov[i] = dvec[i];
142
143     u.uio_iov = &iov[0];
144     u.uio_iovcnt = nvecs;
145     u.uio_offset = 0;
146     u.uio_resid = alength;
147     u.uio_segflg = UIO_SYSSPACE;
148     u.uio_rw = UIO_WRITE;
149     u.uio_td = NULL;
150
151     addr->sin_len = sizeof(struct sockaddr_in);
152
153     if (haveGlock)
154         AFS_GUNLOCK();
155 #if KNET_DEBUG
156     printf("+");
157 #endif
158     code =
159         sosend(asocket, (struct sockaddr *)addr, &u, NULL, NULL, 0,
160                curthread);
161 #if KNET_DEBUG
162     if (code) {
163         if (code == EINVAL)
164             Debugger("afs NetSend busted");
165         else
166             printf("z");
167     }
168 #endif
169     if (haveGlock)
170         AFS_GLOCK();
171     return code;
172 }
173 #else
174 /* This code *almost* works :( */
175 static struct protosw parent_proto;     /* udp proto switch */
176 static void rxk_input(struct mbuf *am, int iphlen);
177 static void rxk_fasttimo(void);
178
179 /* start intercepting basic calls */
180 rxk_init()
181 {
182     struct protosw *tpro, *last;
183     if (rxk_initDone)
184         return 0;
185
186     last = inetdomain.dom_protoswNPROTOSW;
187     for (tpro = inetdomain.dom_protosw; tpro < last; tpro++)
188         if (tpro->pr_protocol == IPPROTO_UDP) {
189 #if 0                           /* not exported */
190             /* force UDP checksumming on for AFS    */
191             extern int udpcksum;
192             udpcksum = 1;
193 #endif
194             memcpy(&parent_proto, tpro, sizeof(parent_proto));
195             tpro->pr_input = rxk_input;
196             tpro->pr_fasttimo = rxk_fasttimo;
197             /*
198              * don't bother with pr_drain and pr_ctlinput
199              * until we have something to do
200              */
201             rxk_initDone = 1;
202             return 0;
203         }
204     osi_Panic("inet:no udp");
205 }
206
207
208 static void
209 rxk_input(struct mbuf *am, int iphlen)
210 {
211     void (*tproc) ();
212     unsigned short *tsp;
213     int hdr;
214     struct udphdr *tu;
215     struct ip *ti;
216     struct udpiphdr *tvu;
217     int i;
218     char *phandle;
219     afs_int32 code;
220     struct sockaddr_in taddr;
221     int tlen;
222     short port;
223     int data_len, comp_sum;
224
225     SPLVAR;
226     NETPRI;
227
228     /* make sure we have base ip and udp headers in first mbuf */
229     if (iphlen > sizeof(struct ip)) {
230         ip_stripoptions(am, NULL);
231         iphlen = sizeof(struct ip);
232     }
233
234     if (am->m_len < sizeof(struct udpiphdr)) {
235         am = m_pullup(am, sizeof(struct udpiphdr));
236         if (!am) {
237             USERPRI;
238             return;
239         }
240     }
241
242     ti = mtod(am, struct ip *);
243     /* skip basic ip hdr */
244     tu = (struct udphdr *)(((char *)ti) + sizeof(struct ip));
245
246     /* now read the port out */
247     port = tu->uh_dport;
248
249     if (port) {
250         for (tsp = rxk_ports, i = 0; i < MAXRXPORTS; i++) {
251             if (*tsp++ == port) {
252                 /* checksum the packet */
253                 /*
254                  * Make mbuf data length reflect UDP length.
255                  * If not enough data to reflect UDP length, drop.
256                  */
257                 tvu = (struct udpiphdr *)ti;
258                 tlen = ntohs((u_short) tvu->ui_ulen);
259                 if ((int)ti->ip_len != tlen) {
260                     if (tlen > (int)ti->ip_len) {
261                         m_free(am);
262                         USERPRI;
263                         return;
264                     }
265                     m_adj(am, tlen - (int)ti->ip_len);
266                 }
267                 /* deliver packet to rx */
268                 taddr.sin_family = AF_INET;     /* compute source address */
269                 taddr.sin_port = tu->uh_sport;
270                 taddr.sin_addr.s_addr = ti->ip_src.s_addr;
271                 taddr.sin_len = sizeof(taddr);
272                 tvu = (struct udpiphdr *)ti;    /* virtual udp structure, for cksum */
273                 /* handle the checksum.  Note that this code damages the actual ip
274                  * header (replacing it with the virtual one, which is the same size),
275                  * so we must ensure we get everything out we need, first */
276                 if (tu->uh_sum != 0) {
277                     /* if the checksum is there, always check it. It's crazy not
278                      * to, unless you can really be sure that your
279                      * underlying network (and interfaces and drivers and
280                      * DMA hardware, etc!) is error-free. First, fill
281                      * in entire virtual ip header. */
282                     memset(tvu->ui_i.ih_x1, 0, 9);
283                     tvu->ui_len = tvu->ui_ulen;
284                     tlen = ntohs((unsigned short)(tvu->ui_ulen));
285                     if (in_cksum(am, sizeof(struct ip) + tlen)) {
286                         /* checksum, including cksum field, doesn't come out 0, so
287                          * this packet is bad */
288                         m_freem(am);
289                         USERPRI;
290                         return;
291                     }
292                 }
293
294                 /*
295                  * 28 is IP (20) + UDP (8) header.  ulen includes
296                  * udp header, and we *don't* tell RX about udp
297                  * header either.  So, we remove those 8 as well.
298                  */
299                 data_len = ntohs(tu->uh_ulen);
300                 data_len -= 8;
301                 if (!(*rxk_GetPacketProc) (&phandle, data_len)) {
302                     if (rx_mb_to_packet(am, m_freem, 28, data_len, phandle)) {
303                         /* XXX should just increment counter here.. */
304                         printf("rx: truncated UDP packet\n");
305                         rxi_FreePacket(phandle);
306                     } else
307                         (*rxk_PacketArrivalProc) (phandle, &taddr,
308                                                   rxk_portRocks[i], data_len);
309                 } else
310                     m_freem(am);
311                 USERPRI;
312                 return;
313             }
314         }
315     }
316
317     /* if we get here, try to deliver packet to udp */
318     if (tproc = parent_proto.pr_input)
319         (*tproc) (am, iphlen);
320     USERPRI;
321     return;
322 }
323
324
325 /* 
326  * UDP fast timer to raise events for all but Solaris and NCR. 
327  * Called about 5 times per second (at unknown priority?).  Must go to
328  * splnet or obtain global lock before touching anything significant.
329  */
330 static void
331 rxk_fasttimo(void)
332 {
333     void (*tproc) ();
334     struct clock temp;
335
336     /* do rx fasttimo processing here */
337     rxevent_RaiseEvents(&temp);
338     if (tproc = parent_proto.pr_fasttimo)
339         (*tproc) ();
340 }
341
342 /* rx_NetSend - send asize bytes at adata from asocket to host at addr.
343  *
344  * Now, why do we allocate a new buffer when we could theoretically use the one
345  * pointed to by adata?  Because PRU_SEND returns after queueing the message,
346  * not after sending it.  If the sender changes the data after queueing it,
347  * we'd see the already-queued data change.  One attempt to fix this without
348  * adding a copy would be to have this function wait until the datagram is
349  * sent; however this doesn't work well.  In particular, if a host is down, and
350  * an ARP fails to that host, this packet will be queued until the ARP request
351  * comes back, which could be hours later.  We can't block in this routine that
352  * long, since it prevents RPC timeouts from happening.
353  */
354 /* XXX In the brave new world, steal the data bufs out of the rx_packet iovec,
355  * and just queue those.  XXX
356  */
357
358 /* set lock on sockbuf sb; can't call sblock since we're at interrupt level
359  * sometimes */
360 static
361 trysblock(sb)
362      struct sockbuf *sb;
363 {
364     AFS_STATCNT(trysblock);
365     if (sb->sb_flags & SB_LOCK) {
366         return -1;              /* can't lock socket */
367     }
368     sb->sb_flags |= SB_LOCK;
369     return 0;
370 }
371
372 /* We only have to do all the mbuf management ourselves if we can be called at
373    interrupt time. in RXK_LISTENER_ENV, we can just call sosend() */
374 int
375 osi_NetSend(osi_socket asocket, struct sockaddr_in *addr, struct iovec *dvec,
376             int nvec, afs_int32 asize, int istack)
377 {
378     struct mbuf *tm, *um;
379     afs_int32 code;
380     int s;
381     struct mbuf *top = 0;
382     struct mbuf *m, **mp;
383     int len;
384     char *tdata;
385     caddr_t tpa;
386     int i, tl, rlen;
387     int mlen;
388     int haveGlock;
389 #if KNET_DEBUG
390     static int before = 0;
391 #endif
392
393     AFS_STATCNT(osi_NetSend);
394 /* Actually, the Ultrix way is as good as any for us, so we don't bother with
395  * special mbufs any more.  Used to think we could get away with not copying
396  * the data to the interface, but there's no way to tell the caller not to
397  * reuse the buffers after sending, so we lost out on that trick anyway */
398     s = splnet();
399     if (trysblock(&asocket->so_snd)) {
400         splx(s);
401         return 1;
402     }
403     mp = &top;
404     i = 0;
405     tdata = dvec[i].iov_base;
406     tl = dvec[i].iov_len;
407     while (1) {
408         mlen = MLEN;
409         if (top == 0) {
410             MGETHDR(m, M_DONTWAIT, MT_DATA);
411             if (!m) {
412                 sbunlock(&asocket->so_snd);
413                 splx(s);
414                 return 1;
415             }
416             mlen = MHLEN;
417             m->m_pkthdr.len = 0;
418             m->m_pkthdr.rcvif = NULL;
419         } else
420             MGET(m, M_DONTWAIT, MT_DATA);
421         if (!m) {
422             /* can't get an mbuf, give up */
423             if (top)
424                 m_freem(top);   /* free mbuf list we're building */
425             sbunlock(&asocket->so_snd);
426             splx(s);
427             return 1;
428         }
429         /*
430          * WARNING: the `4 * MLEN' is somewhat dubious.  It is better than
431          * `NBPG', which may have no relation to `CLBYTES'.  Also, `CLBYTES'
432          * may be so large that we never use clusters, resulting in far
433          * too many mbufs being used.  It is often better to briefly use
434          * a cluster, even if we are only using a portion of it.  Since
435          * we are on the xmit side, it shouldn't end up sitting on a queue
436          * for a potentially unbounded time (except perhaps if we are talking
437          * to ourself).
438          */
439         if (asize >= 4 * MLEN) {        /* try to get cluster mbuf */
440             /* different algorithms for getting cluster mbuf */
441             MCLGET(m, M_DONTWAIT);
442             if ((m->m_flags & M_EXT) == 0)
443                 goto nopages;
444             mlen = MCLBYTES;
445
446             /* now compute usable size */
447             len = MIN(mlen, asize);
448 /* Should I look at MAPPED_MBUFS??? */
449         } else {
450           nopages:
451             len = MIN(mlen, asize);
452         }
453         m->m_len = 0;
454         *mp = m;                /* XXXX */
455         top->m_pkthdr.len += len;
456         tpa = mtod(m, caddr_t);
457         while (len) {
458             rlen = MIN(len, tl);
459             memcpy(tpa, tdata, rlen);
460             asize -= rlen;
461             len -= rlen;
462             tpa += rlen;
463             m->m_len += rlen;
464             tdata += rlen;
465             tl -= rlen;
466             if (tl <= 0) {
467                 i++;
468                 if (i > nvec) {
469                     /* shouldn't come here! */
470                     asize = 0;  /* so we make progress toward completion */
471                     break;
472                 }
473                 tdata = dvec[i].iov_base;
474                 tl = dvec[i].iov_len;
475             }
476         }
477         *mp = m;
478         mp = &m->m_next;
479         if (asize <= 0)
480             break;
481     }
482     tm = top;
483
484     tm->m_act = NULL;
485
486     /* setup mbuf corresponding to destination address */
487     um = m_get(M_DONTWAIT, MT_SONAME);
488     if (!um) {
489         if (top)
490             m_freem(top);       /* free mbuf chain */
491         sbunlock(&asocket->so_snd);
492         splx(s);
493         return 1;
494     }
495     memcpy(mtod(um, caddr_t), addr, sizeof(*addr));
496     addr->sin_len = um->m_len = sizeof(*addr);
497     /* note that udp_usrreq frees funny mbuf.  We hold onto data, but mbuf
498      * around it is gone. */
499     /*    haveGlock = ISAFS_GLOCK();
500      * if (haveGlock) {
501      * AFS_GUNLOCK();
502      * }  */
503     /* SOCKET_LOCK(asocket); */
504     /* code = (*asocket->so_proto->pr_usrreq)(asocket, PRU_SEND, tm, um, 0); */
505 #if KNET_DEBUG
506     if (before)
507         Debugger("afs NetSend before");
508 #endif
509     code =
510         (*asocket->so_proto->pr_usrreqs->pru_send) (asocket, 0, tm,
511                                                     (struct sockaddr *)
512                                                     addr, um, &proc0);
513     /* SOCKET_UNLOCK(asocket); */
514     /* if (haveGlock) {
515      * AFS_GLOCK();
516      * } */
517     sbunlock(&asocket->so_snd);
518     splx(s);
519 #if KNET_DEBUG
520     if (code) {
521         if (code == EINVAL)
522             Debugger("afs NetSend busted");
523         else
524             printf("z");
525     }
526 #endif
527     return code;
528 }
529 #endif