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