/*
* Copyright 2000, International Business Machines Corporation and others.
* All Rights Reserved.
- *
+ *
* This software has been released under the terms of the IBM Public
* License. For details, see the LICENSE file in the top-level source
* directory or online at http://www.openafs.org/dl/license10.html
#include <afsconfig.h>
#include "afs/param.h"
-RCSID
- ("$Header$");
#include "rx/rx_kcommon.h"
+#include "rx_atomic.h"
+#include "rx_stats.h"
#ifdef AFS_HPUX110_ENV
#include "h/tihdr.h"
int (*rxk_GetPacketProc) (struct rx_packet **ahandle, int asize);
#endif
-osi_socket *rxk_NewSocketHost(struct sockaddr_storage *saddr, int salen);
+osi_socket *rxk_NewSocketHost(afs_uint32 ahost, short aport);
extern struct interfaceAddr afs_cb_interface;
rxk_ports_t rxk_ports;
int
rxk_DelPort(u_short aport)
{
- register int i;
- register unsigned short *tsp;
+ int i;
+ unsigned short *tsp;
for (i = 0, tsp = rxk_ports; i < MAXRXPORTS; i++, tsp++) {
if (*tsp == aport) {
}
osi_socket
-rxi_GetHostUDPSocket(struct sockaddr_storage *saddr, int salen)
+rxi_GetHostUDPSocket(u_int host, u_short port)
{
osi_socket *sockp;
- sockp = (osi_socket *)rxk_NewSocketHost(saddr, salen);
+ sockp = (osi_socket *)rxk_NewSocketHost(host, port);
if (sockp == (osi_socket *)0)
return OSI_NULLSOCKET;
- rxk_AddPort(rx_ss2pn(saddr), (char *)sockp);
+ rxk_AddPort(port, (char *)sockp);
return (osi_socket) sockp;
}
osi_socket
rxi_GetUDPSocket(u_short port)
{
- struct sockaddr_storage saddr;
- struct sockaddr_in *sin = (struct sockaddr_in *) &saddr;
-
- memset((void *) &saddr, 0, sizeof(saddr));
-
- sin->sin_family = AF_INET;
- sin->sin_addr.s_addr = htonl(INADDR_ANY);
- sin->sin_port = port;
-
- return rxi_GetHostUDPSocket(&saddr, sizeof(struct sockaddr_in));
-}
-
-#if !defined(AFS_LINUX26_ENV)
-void
-osi_Panic(msg, a1, a2, a3)
- char *msg;
-{
- if (!msg)
- msg = "Unknown AFS panic";
-
- printf(msg, a1, a2, a3);
-#ifdef AFS_LINUX20_ENV
- * ((char *) 0) = 0;
-#else
- panic(msg);
-#endif
+ return rxi_GetHostUDPSocket(htonl(INADDR_ANY), port);
}
/*
return 0;
}
+#ifndef AFS_LINUX26_ENV
/*
* osi_AssertFailK() -- used by the osi_Assert() macro.
*
#undef ADDBUF
- osi_Panic(buf);
-}
-#else
-void
-osi_AssertFailK(const char *expr, const char *file, int line)
-{
- printk(KERN_CRIT "assertion failed: %s, file: %s, line: %d\n", expr, file, line);
+ osi_Panic("%s", buf);
}
#endif
#ifndef UKERNEL
/* This is the server process request loop. Kernel server
* processes never become listener threads */
-void
-rx_ServerProc(void)
+void *
+rx_ServerProc(void *unused)
{
int threadID;
rxi_MorePackets(rx_maxReceiveWindow + 2); /* alloc more packets */
+ MUTEX_ENTER(&rx_quota_mutex);
rxi_dataQuota += rx_initSendWindow; /* Reserve some pkts for hard times */
/* threadID is used for making decisions in GetCall. Get it by bumping
* number of threads handling incoming calls */
threadID = rxi_availProcs++;
+ MUTEX_EXIT(&rx_quota_mutex);
#ifdef RX_ENABLE_LOCKS
AFS_GUNLOCK();
#ifdef RX_ENABLE_LOCKS
AFS_GLOCK();
#endif /* RX_ENABLE_LOCKS */
+
+ return NULL;
}
#endif /* !UKERNEL */
RX_PACKET_CLASS_RECV_CBUF)) {
rxi_FreePacket(tp);
tp = NULL;
- MUTEX_ENTER(&rx_stats_mutex);
- rx_stats.noPacketBuffersOnRead++;
- MUTEX_EXIT(&rx_stats_mutex);
+ if (rx_stats_active) {
+ rx_atomic_inc(&rx_stats.noPacketBuffersOnRead);
+ }
}
}
} else {
* should do this at a higher layer and let other
* end know we're losing.
*/
- MUTEX_ENTER(&rx_stats_mutex);
- rx_stats.bogusPacketOnRead++;
- MUTEX_EXIT(&rx_stats_mutex);
+ if (rx_stats_active) {
+ rx_atomic_inc(&rx_stats.bogusPacketOnRead);
+ }
/* I DON"T LIKE THIS PRINTF -- PRINTFS MAKE THINGS VERY VERY SLOOWWW */
dpf(("rx: packet dropped: bad ulen=%d\n", asize));
tp = NULL;
ahandle->length = asize - RX_HEADER_SIZE;
rxi_DecodePacketHeader(ahandle);
ahandle =
- rxi_ReceivePacket(ahandle, arock, (struct sockaddr_storage *) afrom,
- NULL, NULL);
+ rxi_ReceivePacket(ahandle, arock,
+ afrom->sin_addr.s_addr, afrom->sin_port, NULL,
+ NULL);
/* free the packet if it has been returned */
if (ahandle)
void
rxi_StartListener(void)
{
+#if !defined(RXK_LISTENER_ENV) && !defined(RXK_UPCALL_ENV)
/* if kernel, give name of appropriate procedures */
-#ifndef RXK_LISTENER_ENV
rxk_GetPacketProc = MyPacketProc;
rxk_PacketArrivalProc = MyArrivalProc;
rxk_init();
/* Called from rxi_FindPeer, when initializing a clear rx_peer structure,
to get interesting information. */
void
-rxi_InitPeerParams(register struct rx_peer *pp)
+rxi_InitPeerParams(struct rx_peer *pp)
{
u_short rxmtu;
- afs_int32 i, mtu;
#ifdef ADAPT_MTU
-#ifndef AFS_SUN5_ENV
-#ifdef AFS_USERSPACE_IP_ADDR
- i = rxi_Findcbi(rx_HostOf(pp));
+# ifndef AFS_SUN5_ENV
+# ifdef AFS_USERSPACE_IP_ADDR
+ afs_int32 i;
+ afs_int32 mtu;
+
+ i = rxi_Findcbi(pp->host);
if (i == -1) {
pp->timeout.sec = 3;
/* pp->timeout.usec = 0; */
- pp->ifMTU = RX_REMOTE_PACKET_SIZE;
+ pp->ifMTU = MIN(RX_REMOTE_PACKET_SIZE, rx_MyMaxSendSize);
} else {
pp->timeout.sec = 2;
/* pp->timeout.usec = 0; */
pp->ifMTU = MIN(RX_MAX_PACKET_SIZE, rx_MyMaxSendSize);
- }
- if (i != -1) {
mtu = ntohl(afs_cb_interface.mtu[i]);
/* Diminish the packet size to one based on the MTU given by
* the interface. */
if (rxmtu < pp->ifMTU)
pp->ifMTU = rxmtu;
}
- } else { /* couldn't find the interface, so assume the worst */
- pp->ifMTU = RX_REMOTE_PACKET_SIZE;
}
-#else /* AFS_USERSPACE_IP_ADDR */
- AFS_IFNET_T ifn;
+# else /* AFS_USERSPACE_IP_ADDR */
+ rx_ifnet_t ifn;
-#if !defined(AFS_SGI62_ENV)
+# if !defined(AFS_SGI62_ENV)
if (numMyNetAddrs == 0)
(void)rxi_GetIFInfo();
-#endif
+# endif
- ifn = rxi_FindIfnet(rx_HostOf(pp), NULL);
+ ifn = rxi_FindIfnet(pp->host, NULL);
if (ifn) {
pp->timeout.sec = 2;
/* pp->timeout.usec = 0; */
pp->ifMTU = MIN(RX_MAX_PACKET_SIZE, rx_MyMaxSendSize);
-#ifdef IFF_POINTOPOINT
- if (ifnet_flags(ifn) & IFF_POINTOPOINT) {
+# ifdef IFF_POINTOPOINT
+ if (rx_ifnet_flags(ifn) & IFF_POINTOPOINT) {
/* wish we knew the bit rate and the chunk size, sigh. */
pp->timeout.sec = 4;
pp->ifMTU = RX_PP_PACKET_SIZE;
}
-#endif /* IFF_POINTOPOINT */
+# endif /* IFF_POINTOPOINT */
/* Diminish the packet size to one based on the MTU given by
* the interface. */
- if (ifnet_mtu(ifn) > (RX_IPUDP_SIZE + RX_HEADER_SIZE)) {
- rxmtu = ifnet_mtu(ifn) - RX_IPUDP_SIZE;
+ if (rx_ifnet_mtu(ifn) > (RX_IPUDP_SIZE + RX_HEADER_SIZE)) {
+ rxmtu = rx_ifnet_mtu(ifn) - RX_IPUDP_SIZE;
if (rxmtu < pp->ifMTU)
pp->ifMTU = rxmtu;
}
} else { /* couldn't find the interface, so assume the worst */
pp->timeout.sec = 3;
/* pp->timeout.usec = 0; */
- pp->ifMTU = RX_REMOTE_PACKET_SIZE;
+ pp->ifMTU = MIN(RX_REMOTE_PACKET_SIZE, rx_MyMaxSendSize);
}
-#endif /* else AFS_USERSPACE_IP_ADDR */
-#else /* AFS_SUN5_ENV */
- mtu = rxi_FindIfMTU(rx_HostOf(pp));
+# endif /* else AFS_USERSPACE_IP_ADDR */
+# else /* AFS_SUN5_ENV */
+ afs_int32 mtu;
+
+ mtu = rxi_FindIfMTU(pp->host);
if (mtu <= 0) {
pp->timeout.sec = 3;
/* pp->timeout.usec = 0; */
- pp->ifMTU = RX_REMOTE_PACKET_SIZE;
+ pp->ifMTU = MIN(RX_REMOTE_PACKET_SIZE, rx_MyMaxSendSize);
} else {
pp->timeout.sec = 2;
/* pp->timeout.usec = 0; */
pp->ifMTU = MIN(RX_MAX_PACKET_SIZE, rx_MyMaxSendSize);
- }
- if (mtu > 0) {
/* Diminish the packet size to one based on the MTU given by
* the interface. */
if (mtu > (RX_IPUDP_SIZE + RX_HEADER_SIZE)) {
if (rxmtu < pp->ifMTU)
pp->ifMTU = rxmtu;
}
- } else { /* couldn't find the interface, so assume the worst */
- pp->ifMTU = RX_REMOTE_PACKET_SIZE;
}
-#endif /* AFS_SUN5_ENV */
+# endif /* AFS_SUN5_ENV */
#else /* ADAPT_MTU */
pp->rateFlag = 2; /* start timing after two full packets */
pp->timeout.sec = 2;
pp->natMTU = MIN(pp->ifMTU, OLD_MAX_PACKET_SIZE);
pp->ifDgramPackets =
MIN(rxi_nDgramPackets,
- rxi_AdjustDgramPackets(RX_MAX_FRAGS, pp->ifMTU));
+ rxi_AdjustDgramPackets(rxi_nSendFrags, pp->ifMTU));
pp->maxDgramPackets = 1;
/* Initialize slow start parameters */
void
shutdown_rxkernel(void)
{
- register struct protosw *tpro, *last;
+ struct protosw *tpro, *last;
last = inetdomain.dom_protoswNPROTOSW;
for (tpro = inetdomain.dom_protosw; tpro < last; tpro++)
if (tpro->pr_protocol == IPPROTO_UDP) {
rxk_shutdownPorts();
return;
}
- dpf(("shutdown_rxkernel: no udp proto"));
+ dpf(("shutdown_rxkernel: no udp proto\n"));
}
#endif /* !AIX && !SUN && !NCR && !UKERNEL */
int
rxi_GetcbiInfo(void)
{
- int i, j, different = 0;
+ int i, j, different = 0, num = ADDRSPERSITE;
int rxmtu, maxmtu;
afs_uint32 ifinaddr;
afs_uint32 addrs[ADDRSPERSITE];
memset((void *)addrs, 0, sizeof(addrs));
memset((void *)mtus, 0, sizeof(mtus));
- for (i = 0; i < afs_cb_interface.numberOfInterfaces; i++) {
+ if (afs_cb_interface.numberOfInterfaces < num)
+ num = afs_cb_interface.numberOfInterfaces;
+ for (i = 0; i < num; i++) {
if (!afs_cb_interface.mtu[i])
afs_cb_interface.mtu[i] = htonl(1500);
rxmtu = (ntohl(afs_cb_interface.mtu[i]) - RX_IPUDP_SIZE);
rxmtu * rxi_nRecvFrags + ((rxi_nRecvFrags - 1) * UDP_HDR_SIZE);
maxmtu = rxi_AdjustMaxMTU(rxmtu, maxmtu);
addrs[i++] = ifinaddr;
- if ((ifinaddr != 0x7f000001) && (maxmtu > rx_maxReceiveSize)) {
+ if (!rx_IsLoopbackAddr(ifinaddr) && (maxmtu > rx_maxReceiveSize)) {
rx_maxReceiveSize = MIN(RX_MAX_PACKET_SIZE, maxmtu);
rx_maxReceiveSize = MIN(rx_maxReceiveSize, rx_maxReceiveSizeUser);
}
int i = 0;
int different = 0;
- register int rxmtu, maxmtu;
+ int rxmtu, maxmtu;
afs_uint32 addrs[ADDRSPERSITE];
int mtus[ADDRSPERSITE];
afs_uint32 ifinaddr;
#if defined(AFS_DARWIN80_ENV)
errno_t t;
- int cnt=0;
- ifaddr_t *ifads, ifad;
- register ifnet_t ifn;
+ unsigned int count;
+ int cnt=0, m, j;
+ rx_ifaddr_t *ifads;
+ rx_ifnet_t *ifns;
struct sockaddr sout;
struct sockaddr_in *sin;
+ struct in_addr pin;
#else
- struct ifaddr *ifad; /* ifnet points to a if_addrlist of ifaddrs */
- register struct ifnet *ifn;
+ rx_ifaddr_t ifad; /* ifnet points to a if_addrlist of ifaddrs */
+ rx_ifnet_t ifn;
#endif
memset(addrs, 0, sizeof(addrs));
memset(mtus, 0, sizeof(mtus));
#if defined(AFS_DARWIN80_ENV)
- t = ifnet_get_address_list_family(NULL, &ifads, AF_INET);
- if (t == 0) {
- rxmtu = ifnet_mtu(ifn) - RX_IPUDP_SIZE;
- while((ifads[cnt] != NULL) && cnt < ADDRSPERSITE) {
- t = ifaddr_address(ifads[cnt], &sout, sizeof(sout));
- sin = (struct sockaddr_in *)&sout;
- ifinaddr = ntohl(sin->sin_addr.s_addr);
- if (myNetAddrs[i] != ifinaddr) {
- different++;
- }
- mtus[i] = rxmtu;
- rxmtu = rxi_AdjustIfMTU(rxmtu);
- maxmtu =
- rxmtu * rxi_nRecvFrags +
- ((rxi_nRecvFrags - 1) * UDP_HDR_SIZE);
- maxmtu = rxi_AdjustMaxMTU(rxmtu, maxmtu);
- addrs[i++] = ifinaddr;
- if ((ifinaddr != 0x7f000001) && (maxmtu > rx_maxReceiveSize)) {
- rx_maxReceiveSize = MIN(RX_MAX_PACKET_SIZE, maxmtu);
- rx_maxReceiveSize =
- MIN(rx_maxReceiveSize, rx_maxReceiveSizeUser);
+ if (!ifnet_list_get(AF_INET, &ifns, &count)) {
+ for (m = 0; m < count; m++) {
+ if (!ifnet_get_address_list(ifns[m], &ifads)) {
+ for (j = 0; ifads[j] != NULL && cnt < ADDRSPERSITE; j++) {
+ if ((t = ifaddr_address(ifads[j], &sout, sizeof(struct sockaddr))) == 0) {
+ sin = (struct sockaddr_in *)&sout;
+ rxmtu = rx_ifnet_mtu(rx_ifaddr_ifnet(ifads[j])) - RX_IPUDP_SIZE;
+ ifinaddr = ntohl(sin->sin_addr.s_addr);
+ if (myNetAddrs[i] != ifinaddr) {
+ different++;
+ }
+ mtus[i] = rxmtu;
+ rxmtu = rxi_AdjustIfMTU(rxmtu);
+ maxmtu =
+ rxmtu * rxi_nRecvFrags +
+ ((rxi_nRecvFrags - 1) * UDP_HDR_SIZE);
+ maxmtu = rxi_AdjustMaxMTU(rxmtu, maxmtu);
+ addrs[i++] = ifinaddr;
+ if (!rx_IsLoopbackAddr(ifinaddr) &&
+ (maxmtu > rx_maxReceiveSize)) {
+ rx_maxReceiveSize =
+ MIN(RX_MAX_PACKET_SIZE, maxmtu);
+ rx_maxReceiveSize =
+ MIN(rx_maxReceiveSize, rx_maxReceiveSizeUser);
+ }
+ cnt++;
+ }
+ }
+ ifnet_free_address_list(ifads);
}
- cnt++;
}
- ifnet_free_address_list(ifads);
+ ifnet_list_free(ifns);
}
#else
#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
TAILQ_FOREACH(ifn, &ifnet, if_link) {
if (i >= ADDRSPERSITE)
break;
-#elif defined(AFS_OBSD_ENV)
+#elif defined(AFS_OBSD_ENV) || defined(AFS_NBSD_ENV)
for (ifn = ifnet.tqh_first; i < ADDRSPERSITE && ifn != NULL;
ifn = ifn->if_list.tqe_next) {
#else
TAILQ_FOREACH(ifad, &ifn->if_addrhead, ifa_link) {
if (i >= ADDRSPERSITE)
break;
-#elif defined(AFS_OBSD_ENV)
+#elif defined(AFS_OBSD_ENV) || defined(AFS_NBSD_ENV)
for (ifad = ifn->if_addrlist.tqh_first;
ifad != NULL && i < ADDRSPERSITE;
ifad = ifad->ifa_list.tqe_next) {
((rxi_nRecvFrags - 1) * UDP_HDR_SIZE);
maxmtu = rxi_AdjustMaxMTU(rxmtu, maxmtu);
addrs[i++] = ifinaddr;
- if ((ifinaddr != 0x7f000001) && (maxmtu > rx_maxReceiveSize)) {
+ if (!rx_IsLoopbackAddr(ifinaddr) && (maxmtu > rx_maxReceiveSize)) {
rx_maxReceiveSize = MIN(RX_MAX_PACKET_SIZE, maxmtu);
rx_maxReceiveSize =
MIN(rx_maxReceiveSize, rx_maxReceiveSizeUser);
rx_maxJumboRecvSize = MAX(rx_maxJumboRecvSize, rx_maxReceiveSize);
if (different) {
- int j;
- for (j = 0; j < i; j++) {
- myNetMTUs[j] = mtus[j];
- myNetAddrs[j] = addrs[j];
+ int l;
+ for (l = 0; l < i; l++) {
+ myNetMTUs[l] = mtus[l];
+ myNetAddrs[l] = addrs[l];
}
}
return different;
}
-#if defined(AFS_DARWIN60_ENV) || defined(AFS_XBSD_ENV)
+#if defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
/* Returns ifnet which best matches address */
-#ifdef AFS_DARWIN80_ENV
-ifnet_t
-#else
-struct ifnet *
-#endif
+rx_ifnet_t
rxi_FindIfnet(afs_uint32 addr, afs_uint32 * maskp)
{
struct sockaddr_in s, sr;
-#ifdef AFS_DARWIN80_ENV
- ifaddr_t ifad;
-#else
- struct ifaddr *ifad;
-#endif
+ rx_ifaddr_t ifad;
s.sin_family = AF_INET;
s.sin_addr.s_addr = addr;
-#ifdef AFS_DARWIN80_ENV
- ifad = ifaddr_withnet((struct sockaddr *)&s);
-#else
- ifad = ifa_ifwithnet((struct sockaddr *)&s);
-#endif
+ ifad = rx_ifaddr_withnet((struct sockaddr *)&s);
-#ifdef AFS_DARWIN80_ENV
if (ifad && maskp) {
- ifaddr_netmask(ifad, (struct sockaddr *)&sr, sizeof(sr));
+ rx_ifaddr_netmask(ifad, (struct sockaddr *)&sr, sizeof(sr));
*maskp = sr.sin_addr.s_addr;
}
- return (ifad ? ifaddr_ifnet(ifad) : NULL);
-#else
- if (ifad && maskp)
- *maskp = ((struct sockaddr_in *)ifad->ifa_netmask)->sin_addr.s_addr;
- return (ifad ? ifad->ifa_ifp : NULL);
-#endif
+ return (ifad ? rx_ifaddr_ifnet(ifad) : NULL);
}
-#else /* DARWIN60 || XBSD */
+#else /* DARWIN || XBSD */
/* Returns ifnet which best matches address */
-struct ifnet *
+rx_ifnet_t
rxi_FindIfnet(afs_uint32 addr, afs_uint32 * maskp)
{
int match_value = 0;
*maskp = ifad->ia_subnetmask;
return (ifad ? ifad->ia_ifp : NULL);
}
-#endif /* else DARWIN60 || XBSD */
+#endif /* else DARWIN || XBSD */
#endif /* else AFS_USERSPACE_IP_ADDR */
#endif /* !SUN5 && !SGI62 */
* in network byte order.
*/
osi_socket *
-rxk_NewSocketHost(struct sockaddr_storage *saddr, int salen)
+rxk_NewSocketHost(afs_uint32 ahost, short aport)
{
- register afs_int32 code;
+ afs_int32 code;
#ifdef AFS_DARWIN80_ENV
socket_t newSocket;
#else
struct socket *newSocket;
#endif
-#if (!defined(AFS_HPUX1122_ENV) && !defined(AFS_FBSD50_ENV))
+#if (!defined(AFS_HPUX1122_ENV) && !defined(AFS_FBSD_ENV))
struct mbuf *nam;
#endif
+ struct sockaddr_in myaddr;
#ifdef AFS_HPUX110_ENV
/* prototype copied from kernel source file streams/str_proto.h */
extern MBLKP allocb_wait(int, int);
AFS_GUNLOCK();
#if defined(AFS_HPUX102_ENV)
#if defined(AFS_HPUX110_ENV)
- /* we need a file associated with the socket so sosend in NetSend
+ /* we need a file associated with the socket so sosend in NetSend
* will not fail */
/* blocking socket */
- code = socreate(rx_ssfamily(saddr), &newSocket, SOCK_DGRAM, 0, 0);
+ code = socreate(AF_INET, &newSocket, SOCK_DGRAM, 0, 0);
fp = falloc();
if (!fp)
goto bad;
newSocket->so_fp = (void *)fp;
#else /* AFS_HPUX110_ENV */
- code = socreate(rx_ssfamilty(saddr), &newSocket, SOCK_DGRAM, 0, SS_NOWAIT);
+ code = socreate(AF_INET, &newSocket, SOCK_DGRAM, 0, SS_NOWAIT);
#endif /* else AFS_HPUX110_ENV */
#elif defined(AFS_SGI65_ENV) || defined(AFS_OBSD_ENV)
- code = socreate(rx_ssfamily(saddr), &newSocket, SOCK_DGRAM, IPPROTO_UDP);
-#elif defined(AFS_FBSD50_ENV)
- code = socreate(rx_ssfamily(saddr), &newSocket, SOCK_DGRAM, IPPROTO_UDP,
+ code = socreate(AF_INET, &newSocket, SOCK_DGRAM, IPPROTO_UDP);
+#elif defined(AFS_FBSD_ENV)
+ code = socreate(AF_INET, &newSocket, SOCK_DGRAM, IPPROTO_UDP,
afs_osi_credp, curthread);
-#elif defined(AFS_FBSD40_ENV)
- code = socreate(rx_ssfamily(saddr), &newSocket, SOCK_DGRAM, IPPROTO_UDP,
- curproc);
#elif defined(AFS_DARWIN80_ENV)
- code = sock_socket(rx_ssfamily(saddr), SOCK_DGRAM, IPPROTO_UDP, NULL, NULL,
- &newSocket);
+#ifdef RXK_LISTENER_ENV
+ code = sock_socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP, NULL, NULL, &newSocket);
#else
- code = socreate(rx_ssfamily(saddr), &newSocket, SOCK_DGRAM, 0);
+ code = sock_socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP, rx_upcall, NULL, &newSocket);
+#endif
+#elif defined(AFS_NBSD50_ENV)
+ code = socreate(AF_INET, &newSocket, SOCK_DGRAM, 0, osi_curproc(), NULL);
+#elif defined(AFS_NBSD40_ENV)
+ code = socreate(AF_INET, &newSocket, SOCK_DGRAM, 0, osi_curproc());
+#else
+ code = socreate(AF_INET, &newSocket, SOCK_DGRAM, 0);
#endif /* AFS_HPUX102_ENV */
if (code)
goto bad;
+ memset(&myaddr, 0, sizeof myaddr);
+ myaddr.sin_family = AF_INET;
+ myaddr.sin_port = aport;
+ myaddr.sin_addr.s_addr = ahost;
+#ifdef STRUCT_SOCKADDR_HAS_SA_LEN
+ myaddr.sin_len = sizeof(myaddr);
+#endif
+
#ifdef AFS_HPUX110_ENV
bindnam = allocb_wait((addrsize + SO_MSGOFFSET + 1), BPRI_MED);
if (!bindnam) {
setuerror(ENOBUFS);
goto bad;
}
- memcpy((caddr_t) bindnam->b_rptr + SO_MSGOFFSET, (caddr_t) addr,
+ memcpy((caddr_t) bindnam->b_rptr + SO_MSGOFFSET, (caddr_t) & myaddr,
addrsize);
bindnam->b_wptr = bindnam->b_rptr + (addrsize + SO_MSGOFFSET + 1);
-
+#if defined(AFS_NBSD40_ENV)
+ code = sobind(newSocket, bindnam, addrsize, osi_curproc());
+#else
code = sobind(newSocket, bindnam, addrsize);
+#endif
if (code) {
soclose(newSocket);
#if !defined(AFS_HPUX1122_ENV)
freeb(bindnam);
#else /* AFS_HPUX110_ENV */
#if defined(AFS_DARWIN80_ENV)
- {
+ {
int buflen = 50000;
int i,code2;
for (i=0;i<2;i++) {
}
#endif
#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
-#if defined(AFS_FBSD50_ENV)
- code = sobind(newSocket, (struct sockaddr *) saddr, curthread);
-#elif defined(AFS_FBSD40_ENV)
- code = sobind(newSocket, (struct sockaddr *) saddr, curproc);
+#if defined(AFS_FBSD_ENV)
+ code = sobind(newSocket, (struct sockaddr *)&myaddr, curthread);
#else
- code = sobind(newSocket, (struct sockaddr *) saddr);
+ code = sobind(newSocket, (struct sockaddr *)&myaddr);
#endif
if (code) {
dpf(("sobind fails (%d)\n", (int)code));
soclose(newSocket);
- AFS_GLOCK();
goto bad;
}
#else /* defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV) */
#endif
goto bad;
}
- nam->m_len = salen;
- memcpy(mtod(nam, caddr_t), saddr, salen);
-#ifdef AFS_SGI65_ENV
+ nam->m_len = sizeof(myaddr);
+ memcpy(mtod(nam, caddr_t), &myaddr, sizeof(myaddr));
+#if defined(AFS_SGI65_ENV)
BHV_PDATA(&bhv) = (void *)newSocket;
code = sobind(&bhv, nam);
m_freem(nam);
+#elif defined(AFS_OBSD44_ENV) || defined(AFS_NBSD40_ENV)
+ code = sobind(newSocket, nam, osi_curproc());
#else
code = sobind(newSocket, nam);
#endif
osi_socket *
rxk_NewSocket(short aport)
{
- struct sockaddr_storage saddr;
- struct sockaddr_in *sin = (struct sockaddr_in *) &saddr;
-
- memset((void *) &saddr, 0, sizeof(saddr));
-
- sin->sin_family = AF_INET;
- sin->sin_addr.s_addr = 0;
- sin->sin_port = aport;
-
- return rxk_NewSocketHost(&saddr, sizeof(struct sockaddr_in));
+ return rxk_NewSocketHost(0, aport);
}
/* free socket allocated by rxk_NewSocket */
int
-rxk_FreeSocket(register struct socket *asocket)
+rxk_FreeSocket(struct socket *asocket)
{
AFS_STATCNT(osi_FreeSocket);
#if defined(AFS_DARWIN_ENV) && defined(KERNEL_FUNNEL)
if (asocket->so_fp) {
struct file *fp = asocket->so_fp;
#if !defined(AFS_HPUX1123_ENV)
- /* 11.23 still has falloc, but not FPENTRYFREE !
- * so for now if we shutdown, we will waist a file
+ /* 11.23 still has falloc, but not FPENTRYFREE !
+ * so for now if we shutdown, we will waist a file
* structure */
FPENTRYFREE(fp);
asocket->so_fp = NULL;
}
#endif /* !SUN5 && !LINUX20 */
-#if defined(RXK_LISTENER_ENV) || defined(AFS_SUN5_ENV)
+#if defined(RXK_LISTENER_ENV) || defined(AFS_SUN5_ENV) || defined(RXK_UPCALL_ENV)
+#ifdef RXK_TIMEDSLEEP_ENV
+/* Shutting down should wake us up, as should an earlier event. */
+void
+rxi_ReScheduleEvents(void)
+{
+ /* needed to allow startup */
+ int glock = ISAFS_GLOCK();
+ if (!glock)
+ AFS_GLOCK();
+ osi_rxWakeup(&afs_termState);
+ if (!glock)
+ AFS_GUNLOCK();
+}
+#endif
/*
* Run RX event daemon every second (5 times faster than rest of systems)
*/
afs_Trace1(afs_iclSetp, CM_TRACE_TIMESTAMP, ICL_TYPE_STRING,
"before afs_osi_Wait()");
#endif
+#ifdef RXK_TIMEDSLEEP_ENV
+ afs_osi_TimedSleep(&afs_termState, MAX(500, ((temp.sec * 1000) +
+ (temp.usec / 1000))), 0);
+#else
afs_osi_Wait(500, NULL, 0);
+#endif
#ifdef RX_KERNEL_TRACE
afs_Trace1(afs_iclSetp, CM_TRACE_TIMESTAMP, ICL_TYPE_STRING,
"after afs_osi_Wait()");
if (afs_termState == AFSOP_STOP_RXEVENT) {
#ifdef RXK_LISTENER_ENV
afs_termState = AFSOP_STOP_RXK_LISTENER;
+#elif defined(AFS_SUN510_ENV) || defined(RXK_UPCALL_ENV)
+ afs_termState = AFSOP_STOP_NETIF;
#else
afs_termState = AFSOP_STOP_COMPLETE;
#endif
/* rxk_ReadPacket returns 1 if valid packet, 0 on error. */
int
-rxk_ReadPacket(osi_socket so, struct rx_packet *p,
- struct sockaddr_storage *saddr, int *slen)
+rxk_ReadPacket(osi_socket so, struct rx_packet *p, int *host, int *port)
{
int code;
+ struct sockaddr_in from;
int nbytes;
afs_int32 rlen;
- register afs_int32 tlen;
+ afs_int32 tlen;
afs_int32 savelen; /* was using rlen but had aliasing problems */
rx_computelen(p, tlen);
rx_SetDataSize(p, tlen); /* this is the size of the user data area */
} else
tlen = rlen;
- /* add some padding to the last iovec, it's just to make sure that the
+ /* add some padding to the last iovec, it's just to make sure that the
* read doesn't return more data than we expect, and is done to get around
* our problems caused by the lack of a length field in the rx header. */
savelen = p->wirevec[p->niovecs - 1].iov_len;
AFS_GUNLOCK();
}
#endif
- code = osi_NetReceive(rx_socket, saddr, slen, p->wirevec, p->niovecs,
- &nbytes);
+ code = osi_NetReceive(rx_socket, &from, p->wirevec, p->niovecs, &nbytes);
#ifdef RX_KERNEL_TRACE
if (ICL_SETACTIVE(afs_iclSetp)) {
p->length = nbytes - RX_HEADER_SIZE;;
if ((nbytes > tlen) || (p->length & 0x8000)) { /* Bogus packet */
if (nbytes <= 0) {
- MUTEX_ENTER(&rx_stats_mutex);
- rx_stats.bogusPacketOnRead++;
- switch (rx_ssfamily(saddr)) {
- case AF_INET:
- rx_stats.bogusHost = rx_ss2sin(saddr)->sin_addr.s_addr;
- break;
- default:
-#ifdef AF_INET6
- case AF_INET6:
-#endif /* AF_INET6 */
- rx_stats.bogusHost = 0xffffffff;
- }
- MUTEX_EXIT(&rx_stats_mutex);
- dpf(("B: bogus packet from [%x,%d] nb=%d",
- ntohl(rx_ss2v4addr(saddr)), ntohs(rx_ss2pn(saddr)),
- nbytes));
+ if (rx_stats_active) {
+ MUTEX_ENTER(&rx_stats_mutex);
+ rx_atomic_inc(&rx_stats.bogusPacketOnRead);
+ rx_stats.bogusHost = from.sin_addr.s_addr;
+ MUTEX_EXIT(&rx_stats_mutex);
+ }
+ dpf(("B: bogus packet from [%x,%d] nb=%d\n",
+ from.sin_addr.s_addr, from.sin_port, nbytes));
}
return -1;
} else {
/* Extract packet header. */
rxi_DecodePacketHeader(p);
+ *host = from.sin_addr.s_addr;
+ *port = from.sin_port;
if (p->header.type > 0 && p->header.type < RX_N_PACKET_TYPES) {
- MUTEX_ENTER(&rx_stats_mutex);
- rx_stats.packetsRead[p->header.type - 1]++;
- MUTEX_EXIT(&rx_stats_mutex);
+ if (rx_stats_active) {
+ rx_atomic_inc(&rx_stats.packetsRead[p->header.type - 1]);
+ }
}
+#ifdef RX_TRIMDATABUFS
/* Free any empty packet buffers at the end of this packet */
rxi_TrimDataBufs(p, 1);
-
+#endif
return 0;
}
} else
return code;
}
-/* rxk_Listener()
+/* rxk_Listener()
*
* Listen for packets on socket. This thread is typically started after
* rx_Init has called rxi_StartListener(), but nevertheless, ensures that
* OS's socket receive routine returns as a result of a signal.
*/
int rxk_ListenerPid; /* Used to signal process to wakeup at shutdown */
-
-#ifdef AFS_SUN5_ENV
-/*
- * Run the listener as a kernel thread.
- */
-void
-rxk_Listener(void)
-{
- extern id_t syscid;
- void rxk_ListenerProc(void);
- if (thread_create
- (NULL, DEFAULTSTKSZ, rxk_ListenerProc, 0, 0, &p0, TS_RUN,
- minclsyspri) == NULL)
- osi_Panic("rxk_Listener: failed to start listener thread!\n");
-}
+#ifdef AFS_LINUX20_ENV
+struct task_struct *rxk_ListenerTask;
+#endif
void
-rxk_ListenerProc(void)
-#else /* AFS_SUN5_ENV */
-void
rxk_Listener(void)
-#endif /* AFS_SUN5_ENV */
{
struct rx_packet *rxp = NULL;
- struct sockaddr_storage saddr;
- int code, slen;
+ int code;
+ int host, port;
#ifdef AFS_LINUX20_ENV
rxk_ListenerPid = current->pid;
+ rxk_ListenerTask = current;
#endif
#ifdef AFS_SUN5_ENV
rxk_ListenerPid = 1; /* No PID, just a flag that we're alive */
#elif defined(AFS_DARWIN_ENV)
rxk_ListenerPid = current_proc()->p_pid;
#endif
-#if defined(RX_ENABLE_LOCKS) && !defined(AFS_SUN5_ENV)
+#ifdef RX_ENABLE_LOCKS
AFS_GUNLOCK();
-#endif /* RX_ENABLE_LOCKS && !AFS_SUN5_ENV */
+#endif /* RX_ENABLE_LOCKS */
while (afs_termState != AFSOP_STOP_RXK_LISTENER) {
+ /* See if a check for additional packets was issued */
+ rx_CheckPackets();
+
if (rxp) {
rxi_RestoreDataBufs(rxp);
} else {
if (!rxp)
osi_Panic("rxk_Listener: No more Rx buffers!\n");
}
- if (!(code = rxk_ReadPacket(rx_socket, rxp, &saddr, &slen))) {
- rxp = rxi_ReceivePacket(rxp, rx_socket, &saddr, slen, 0, 0);
+ if (!(code = rxk_ReadPacket(rx_socket, rxp, &host, &port))) {
+ rxp = rxi_ReceivePacket(rxp, rx_socket, host, port, 0, 0);
}
}
AFS_GLOCK();
#endif /* RX_ENABLE_LOCKS */
if (afs_termState == AFSOP_STOP_RXK_LISTENER) {
+#ifdef AFS_SUN510_ENV
+ afs_termState = AFSOP_STOP_NETIF;
+#else
afs_termState = AFSOP_STOP_COMPLETE;
+#endif
osi_rxWakeup(&afs_termState);
}
rxk_ListenerPid = 0;
-#if defined(AFS_LINUX22_ENV) || defined(AFS_SUN5_ENV)
+#ifdef AFS_LINUX20_ENV
+ rxk_ListenerTask = 0;
+ osi_rxWakeup(&rxk_ListenerTask);
+#endif
+#if defined(AFS_SUN5_ENV) || defined(AFS_FBSD_ENV)
osi_rxWakeup(&rxk_ListenerPid);
#endif
-#ifdef AFS_SUN5_ENV
- AFS_GUNLOCK();
-#endif /* AFS_SUN5_ENV */
}
#if !defined(AFS_LINUX20_ENV) && !defined(AFS_SUN5_ENV) && !defined(AFS_DARWIN_ENV) && !defined(AFS_XBSD_ENV)
}
#endif
#endif /* RXK_LISTENER_ENV */
-
#endif /* !NCR && !UKERNEL */
+
+#if !defined(AFS_LINUX26_ENV)
+void
+#if defined(AFS_AIX_ENV)
+osi_Panic(char *msg, void *a1, void *a2, void *a3)
+#else
+osi_Panic(char *msg, ...)
+#endif
+{
+#ifdef AFS_AIX_ENV
+ if (!msg)
+ msg = "Unknown AFS panic";
+ /*
+ * we should probably use the errsave facility here. it is not
+ * varargs-aware
+ */
+
+ printf(msg, a1, a2, a3);
+ panic(msg);
+#elif defined(AFS_SGI_ENV)
+ va_list ap;
+
+ /* Solaris has vcmn_err, Sol10 01/06 may have issues. Beware. */
+ if (!msg) {
+ cmn_err(CE_PANIC, "Unknown AFS panic");
+ } else {
+ va_start(ap, msg);
+ icmn_err(CE_PANIC, msg, ap);
+ va_end(ap);
+ }
+#elif defined(AFS_DARWIN80_ENV) || (defined(AFS_LINUX22_ENV) && !defined(AFS_LINUX_26_ENV))
+ char buf[256];
+ va_list ap;
+ if (!msg)
+ msg = "Unknown AFS panic";
+
+ va_start(ap, msg);
+ vsnprintf(buf, sizeof(buf), msg, ap);
+ va_end(ap);
+ printf("%s", buf);
+ panic(buf);
+#else
+ va_list ap;
+ if (!msg)
+ msg = "Unknown AFS panic";
+
+ va_start(ap, msg);
+ vprintf(msg, ap);
+ va_end(ap);
+# ifdef AFS_LINUX20_ENV
+ * ((char *) 0) = 0;
+# else
+ panic(msg);
+# endif
+#endif
+}
+#endif
git://git.openafs.org / openafs.git / blobdiff