Changeset View
Changeset View
Standalone View
Standalone View
sys/net/rss_config.c
- This file was copied from sys/netinet/in_rss.c.
Show All 23 Lines | |||||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||||
* SUCH DAMAGE. | * SUCH DAMAGE. | ||||
*/ | */ | ||||
#include <sys/cdefs.h> | #include <sys/cdefs.h> | ||||
__FBSDID("$FreeBSD: head/sys/netinet/in_rss.c 276484 2014-12-31 22:52:43Z adrian $"); | __FBSDID("$FreeBSD: 276484 2014-12-31 22:52:43Z adrian $"); | ||||
bz: This probably just wants to become $FreeBSD$ | |||||
#include "opt_inet6.h" | #include "opt_inet6.h" | ||||
#include "opt_pcbgroup.h" | #include "opt_pcbgroup.h" | ||||
#ifndef PCBGROUP | #ifndef PCBGROUP | ||||
#error "options RSS depends on options PCBGROUP" | #error "options RSS depends on options PCBGROUP" | ||||
#endif | #endif | ||||
#include <sys/param.h> | #include <sys/param.h> | ||||
#include <sys/mbuf.h> | #include <sys/mbuf.h> | ||||
#include <sys/socket.h> | #include <sys/socket.h> | ||||
#include <sys/priv.h> | #include <sys/priv.h> | ||||
#include <sys/kernel.h> | #include <sys/kernel.h> | ||||
#include <sys/smp.h> | #include <sys/smp.h> | ||||
#include <sys/sysctl.h> | #include <sys/sysctl.h> | ||||
#include <sys/sbuf.h> | #include <sys/sbuf.h> | ||||
#include <net/if.h> | #include <net/if.h> | ||||
#include <net/if_var.h> | #include <net/if_var.h> | ||||
#include <net/netisr.h> | #include <net/netisr.h> | ||||
#include <net/rss_config.h> | |||||
#include <net/toeplitz.h> | |||||
#if 0 | |||||
#include <netinet/in.h> | #include <netinet/in.h> | ||||
#include <netinet/in_pcb.h> | #include <netinet/in_pcb.h> | ||||
#include <netinet/in_rss.h> | #include <netinet/in_rss.h> | ||||
#include <netinet/in_var.h> | #include <netinet/in_var.h> | ||||
#include <netinet/toeplitz.h> | |||||
/* for software rss hash support */ | /* for software rss hash support */ | ||||
#include <netinet/ip.h> | #include <netinet/ip.h> | ||||
#include <netinet/tcp.h> | #include <netinet/tcp.h> | ||||
#include <netinet/udp.h> | #include <netinet/udp.h> | ||||
#endif | |||||
/*- | /*- | ||||
* Operating system parts of receiver-side scaling (RSS), which allows | * Operating system parts of receiver-side scaling (RSS), which allows | ||||
* network cards to direct flows to particular receive queues based on hashes | * network cards to direct flows to particular receive queues based on hashes | ||||
* of header tuples. This implementation aligns RSS buckets with connection | * of header tuples. This implementation aligns RSS buckets with connection | ||||
* groups at the TCP/IP layer, so each bucket is associated with exactly one | * groups at the TCP/IP layer, so each bucket is associated with exactly one | ||||
* group. As a result, the group lookup structures (and lock) should have an | * group. As a result, the group lookup structures (and lock) should have an | ||||
* effective affinity with exactly one CPU. | * effective affinity with exactly one CPU. | ||||
Show All 12 Lines | |||||
* - Event handler drivers can register to pick up RSS configuration changes. | * - Event handler drivers can register to pick up RSS configuration changes. | ||||
* - Should we allow rss_basecpu to be configured? | * - Should we allow rss_basecpu to be configured? | ||||
* - Randomize key on boot. | * - Randomize key on boot. | ||||
* - IPv6 support. | * - IPv6 support. | ||||
* - Statistics on how often there's a misalignment between hardware | * - Statistics on how often there's a misalignment between hardware | ||||
* placement and pcbgroup expectations. | * placement and pcbgroup expectations. | ||||
*/ | */ | ||||
SYSCTL_DECL(_net_inet); | |||||
SYSCTL_NODE(_net_inet, OID_AUTO, rss, CTLFLAG_RW, 0, "Receive-side steering"); | SYSCTL_NODE(_net_inet, OID_AUTO, rss, CTLFLAG_RW, 0, "Receive-side steering"); | ||||
/* | /* | ||||
* Toeplitz is the only required hash function in the RSS spec, so use it by | * Toeplitz is the only required hash function in the RSS spec, so use it by | ||||
* default. | * default. | ||||
*/ | */ | ||||
static u_int rss_hashalgo = RSS_HASH_TOEPLITZ; | static u_int rss_hashalgo = RSS_HASH_TOEPLITZ; | ||||
SYSCTL_INT(_net_inet_rss, OID_AUTO, hashalgo, CTLFLAG_RDTUN, &rss_hashalgo, 0, | SYSCTL_INT(_net_inet_rss, OID_AUTO, hashalgo, CTLFLAG_RDTUN, &rss_hashalgo, 0, | ||||
▲ Show 20 Lines • Show All 70 Lines • ▼ Show 20 Lines | |||||
* Drivers may supplement this table with a seperate CPU<->queue table when | * Drivers may supplement this table with a seperate CPU<->queue table when | ||||
* programming devices. | * programming devices. | ||||
*/ | */ | ||||
struct rss_table_entry { | struct rss_table_entry { | ||||
uint8_t rte_cpu; /* CPU affinity of bucket. */ | uint8_t rte_cpu; /* CPU affinity of bucket. */ | ||||
}; | }; | ||||
static struct rss_table_entry rss_table[RSS_TABLE_MAXLEN]; | static struct rss_table_entry rss_table[RSS_TABLE_MAXLEN]; | ||||
static inline u_int rss_gethashconfig_local(void); | |||||
static void | static void | ||||
rss_init(__unused void *arg) | rss_init(__unused void *arg) | ||||
{ | { | ||||
u_int i; | u_int i; | ||||
u_int cpuid; | u_int cpuid; | ||||
/* | /* | ||||
* Validate tunables, coerce to sensible values. | * Validate tunables, coerce to sensible values. | ||||
▲ Show 20 Lines • Show All 89 Lines • ▼ Show 20 Lines | rss_naive_hash(u_int keylen, const uint8_t *key, u_int datalen, | ||||
v = 0; | v = 0; | ||||
for (i = 0; i < keylen; i++) | for (i = 0; i < keylen; i++) | ||||
v += key[i]; | v += key[i]; | ||||
for (i = 0; i < datalen; i++) | for (i = 0; i < datalen; i++) | ||||
v += data[i]; | v += data[i]; | ||||
return (v); | return (v); | ||||
} | } | ||||
static uint32_t | uint32_t | ||||
rss_hash(u_int datalen, const uint8_t *data) | rss_hash(u_int datalen, const uint8_t *data) | ||||
{ | { | ||||
switch (rss_hashalgo) { | switch (rss_hashalgo) { | ||||
case RSS_HASH_TOEPLITZ: | case RSS_HASH_TOEPLITZ: | ||||
return (toeplitz_hash(sizeof(rss_key), rss_key, datalen, | return (toeplitz_hash(sizeof(rss_key), rss_key, datalen, | ||||
data)); | data)); | ||||
case RSS_HASH_NAIVE: | case RSS_HASH_NAIVE: | ||||
return (rss_naive_hash(sizeof(rss_key), rss_key, datalen, | return (rss_naive_hash(sizeof(rss_key), rss_key, datalen, | ||||
data)); | data)); | ||||
default: | default: | ||||
panic("%s: unsupported/unknown hashalgo %d", __func__, | panic("%s: unsupported/unknown hashalgo %d", __func__, | ||||
rss_hashalgo); | rss_hashalgo); | ||||
} | } | ||||
} | } | ||||
/* | /* | ||||
* Hash an IPv4 2-tuple. | |||||
*/ | |||||
uint32_t | |||||
rss_hash_ip4_2tuple(struct in_addr src, struct in_addr dst) | |||||
{ | |||||
uint8_t data[sizeof(src) + sizeof(dst)]; | |||||
u_int datalen; | |||||
datalen = 0; | |||||
bcopy(&src, &data[datalen], sizeof(src)); | |||||
datalen += sizeof(src); | |||||
bcopy(&dst, &data[datalen], sizeof(dst)); | |||||
datalen += sizeof(dst); | |||||
return (rss_hash(datalen, data)); | |||||
} | |||||
/* | |||||
* Hash an IPv4 4-tuple. | |||||
*/ | |||||
uint32_t | |||||
rss_hash_ip4_4tuple(struct in_addr src, u_short srcport, struct in_addr dst, | |||||
u_short dstport) | |||||
{ | |||||
uint8_t data[sizeof(src) + sizeof(dst) + sizeof(srcport) + | |||||
sizeof(dstport)]; | |||||
u_int datalen; | |||||
datalen = 0; | |||||
bcopy(&src, &data[datalen], sizeof(src)); | |||||
datalen += sizeof(src); | |||||
bcopy(&dst, &data[datalen], sizeof(dst)); | |||||
datalen += sizeof(dst); | |||||
bcopy(&srcport, &data[datalen], sizeof(srcport)); | |||||
datalen += sizeof(srcport); | |||||
bcopy(&dstport, &data[datalen], sizeof(dstport)); | |||||
datalen += sizeof(dstport); | |||||
return (rss_hash(datalen, data)); | |||||
} | |||||
#ifdef INET6 | |||||
/* | |||||
* Hash an IPv6 2-tuple. | |||||
*/ | |||||
uint32_t | |||||
rss_hash_ip6_2tuple(const struct in6_addr *src, const struct in6_addr *dst) | |||||
{ | |||||
uint8_t data[sizeof(*src) + sizeof(*dst)]; | |||||
u_int datalen; | |||||
datalen = 0; | |||||
bcopy(src, &data[datalen], sizeof(*src)); | |||||
datalen += sizeof(*src); | |||||
bcopy(dst, &data[datalen], sizeof(*dst)); | |||||
datalen += sizeof(*dst); | |||||
return (rss_hash(datalen, data)); | |||||
} | |||||
/* | |||||
* Hash an IPv6 4-tuple. | |||||
*/ | |||||
uint32_t | |||||
rss_hash_ip6_4tuple(const struct in6_addr *src, u_short srcport, | |||||
const struct in6_addr *dst, u_short dstport) | |||||
{ | |||||
uint8_t data[sizeof(*src) + sizeof(*dst) + sizeof(srcport) + | |||||
sizeof(dstport)]; | |||||
u_int datalen; | |||||
datalen = 0; | |||||
bcopy(src, &data[datalen], sizeof(*src)); | |||||
datalen += sizeof(*src); | |||||
bcopy(dst, &data[datalen], sizeof(*dst)); | |||||
datalen += sizeof(*dst); | |||||
bcopy(&srcport, &data[datalen], sizeof(srcport)); | |||||
datalen += sizeof(srcport); | |||||
bcopy(&dstport, &data[datalen], sizeof(dstport)); | |||||
datalen += sizeof(dstport); | |||||
return (rss_hash(datalen, data)); | |||||
} | |||||
#endif /* INET6 */ | |||||
/* | |||||
* Query the number of RSS bits in use. | * Query the number of RSS bits in use. | ||||
*/ | */ | ||||
u_int | u_int | ||||
rss_getbits(void) | rss_getbits(void) | ||||
{ | { | ||||
return (rss_bits); | return (rss_bits); | ||||
} | } | ||||
▲ Show 20 Lines • Show All 98 Lines • ▼ Show 20 Lines | rss_m2bucket(struct mbuf *m, uint32_t *bucket_id) | ||||
M_ASSERTPKTHDR(m); | M_ASSERTPKTHDR(m); | ||||
return(rss_hash2bucket(m->m_pkthdr.flowid, M_HASHTYPE_GET(m), | return(rss_hash2bucket(m->m_pkthdr.flowid, M_HASHTYPE_GET(m), | ||||
bucket_id)); | bucket_id)); | ||||
} | } | ||||
/* | /* | ||||
* Calculate an appropriate ipv4 2-tuple or 4-tuple given the given | |||||
* IPv4 source/destination address, UDP or TCP source/destination ports | |||||
* and the protocol type. | |||||
* | |||||
* The protocol code may wish to do a software hash of the given | |||||
* tuple. This depends upon the currently configured RSS hash types. | |||||
* | |||||
* This assumes that the packet in question isn't a fragment. | |||||
* | |||||
* It also assumes the packet source/destination address | |||||
* are in "incoming" packet order (ie, source is "far" address.) | |||||
*/ | |||||
int | |||||
rss_proto_software_hash_v4(struct in_addr s, struct in_addr d, | |||||
u_short sp, u_short dp, int proto, | |||||
uint32_t *hashval, uint32_t *hashtype) | |||||
{ | |||||
uint32_t hash; | |||||
/* | |||||
* Next, choose the hash type depending upon the protocol | |||||
* identifier. | |||||
*/ | |||||
if ((proto == IPPROTO_TCP) && | |||||
(rss_gethashconfig_local() & RSS_HASHTYPE_RSS_TCP_IPV4)) { | |||||
hash = rss_hash_ip4_4tuple(s, sp, d, dp); | |||||
*hashval = hash; | |||||
*hashtype = M_HASHTYPE_RSS_TCP_IPV4; | |||||
return (0); | |||||
} else if ((proto == IPPROTO_UDP) && | |||||
(rss_gethashconfig_local() & RSS_HASHTYPE_RSS_UDP_IPV4)) { | |||||
hash = rss_hash_ip4_4tuple(s, sp, d, dp); | |||||
*hashval = hash; | |||||
*hashtype = M_HASHTYPE_RSS_UDP_IPV4; | |||||
return (0); | |||||
} else if (rss_gethashconfig_local() & RSS_HASHTYPE_RSS_IPV4) { | |||||
/* RSS doesn't hash on other protocols like SCTP; so 2-tuple */ | |||||
hash = rss_hash_ip4_2tuple(s, d); | |||||
*hashval = hash; | |||||
*hashtype = M_HASHTYPE_RSS_IPV4; | |||||
return (0); | |||||
} | |||||
/* No configured available hashtypes! */ | |||||
printf("%s: no available hashtypes!\n", __func__); | |||||
return (-1); | |||||
} | |||||
/* | |||||
* Do a software calculation of the RSS for the given mbuf. | |||||
* | |||||
* This is typically used by the input path to recalculate the RSS after | |||||
* some form of packet processing (eg de-capsulation, IP fragment reassembly.) | |||||
* | |||||
* dir is the packet direction - RSS_HASH_PKT_INGRESS for incoming and | |||||
* RSS_HASH_PKT_EGRESS for outgoing. | |||||
* | |||||
* Returns 0 if a hash was done, -1 if no hash was done, +1 if | |||||
* the mbuf already had a valid RSS flowid. | |||||
* | |||||
* This function doesn't modify the mbuf. It's up to the caller to | |||||
* assign flowid/flowtype as appropriate. | |||||
*/ | |||||
int | |||||
rss_mbuf_software_hash_v4(const struct mbuf *m, int dir, uint32_t *hashval, | |||||
uint32_t *hashtype) | |||||
{ | |||||
const struct ip *ip; | |||||
const struct tcphdr *th; | |||||
const struct udphdr *uh; | |||||
uint32_t flowid; | |||||
uint32_t flowtype; | |||||
uint8_t proto; | |||||
int iphlen; | |||||
int is_frag = 0; | |||||
/* | |||||
* XXX For now this only handles hashing on incoming mbufs. | |||||
*/ | |||||
if (dir != RSS_HASH_PKT_INGRESS) { | |||||
printf("%s: called on EGRESS packet!\n", __func__); | |||||
return (-1); | |||||
} | |||||
/* | |||||
* First, validate that the mbuf we have is long enough | |||||
* to have an IPv4 header in it. | |||||
*/ | |||||
if (m->m_pkthdr.len < (sizeof(struct ip))) { | |||||
printf("%s: short mbuf pkthdr\n", __func__); | |||||
return (-1); | |||||
} | |||||
if (m->m_len < (sizeof(struct ip))) { | |||||
printf("%s: short mbuf len\n", __func__); | |||||
return (-1); | |||||
} | |||||
/* Ok, let's dereference that */ | |||||
ip = mtod(m, struct ip *); | |||||
proto = ip->ip_p; | |||||
iphlen = ip->ip_hl << 2; | |||||
/* | |||||
* If this is a fragment then it shouldn't be four-tuple | |||||
* hashed just yet. Once it's reassembled into a full | |||||
* frame it should be re-hashed. | |||||
*/ | |||||
if (ip->ip_off & htons(IP_MF | IP_OFFMASK)) | |||||
is_frag = 1; | |||||
/* | |||||
* If the mbuf flowid/flowtype matches the packet type, | |||||
* and we don't support the 4-tuple version of the given protocol, | |||||
* then signal to the owner that it can trust the flowid/flowtype | |||||
* details. | |||||
* | |||||
* This is a little picky - eg, if TCPv4 / UDPv4 hashing | |||||
* is supported but we got a TCP/UDP frame only 2-tuple hashed, | |||||
* then we shouldn't just "trust" the 2-tuple hash. We need | |||||
* a 4-tuple hash. | |||||
*/ | |||||
flowid = m->m_pkthdr.flowid; | |||||
flowtype = M_HASHTYPE_GET(m); | |||||
if (flowtype != M_HASHTYPE_NONE) { | |||||
switch (proto) { | |||||
case IPPROTO_UDP: | |||||
if ((rss_gethashconfig_local() & RSS_HASHTYPE_RSS_UDP_IPV4) && | |||||
(flowtype == M_HASHTYPE_RSS_UDP_IPV4) && | |||||
(is_frag == 0)) { | |||||
return (1); | |||||
} | |||||
/* | |||||
* Only allow 2-tuple for UDP frames if we don't also | |||||
* support 4-tuple for UDP. | |||||
*/ | |||||
if ((rss_gethashconfig_local() & RSS_HASHTYPE_RSS_IPV4) && | |||||
((rss_gethashconfig_local() & RSS_HASHTYPE_RSS_UDP_IPV4) == 0) && | |||||
flowtype == M_HASHTYPE_RSS_IPV4) { | |||||
return (1); | |||||
} | |||||
break; | |||||
case IPPROTO_TCP: | |||||
if ((rss_gethashconfig_local() & RSS_HASHTYPE_RSS_TCP_IPV4) && | |||||
(flowtype == M_HASHTYPE_RSS_TCP_IPV4) && | |||||
(is_frag == 0)) { | |||||
return (1); | |||||
} | |||||
/* | |||||
* Only allow 2-tuple for TCP frames if we don't also | |||||
* support 2-tuple for TCP. | |||||
*/ | |||||
if ((rss_gethashconfig_local() & RSS_HASHTYPE_RSS_IPV4) && | |||||
((rss_gethashconfig_local() & RSS_HASHTYPE_RSS_TCP_IPV4) == 0) && | |||||
flowtype == M_HASHTYPE_RSS_IPV4) { | |||||
return (1); | |||||
} | |||||
break; | |||||
default: | |||||
if ((rss_gethashconfig_local() & RSS_HASHTYPE_RSS_IPV4) && | |||||
flowtype == M_HASHTYPE_RSS_IPV4) { | |||||
return (1); | |||||
} | |||||
break; | |||||
} | |||||
} | |||||
/* | |||||
* Decode enough information to make a hash decision. | |||||
* | |||||
* XXX TODO: does the hardware hash on 4-tuple if IP | |||||
* options are present? | |||||
*/ | |||||
if ((rss_gethashconfig_local() & RSS_HASHTYPE_RSS_TCP_IPV4) && | |||||
(proto == IPPROTO_TCP) && | |||||
(is_frag == 0)) { | |||||
if (m->m_len < iphlen + sizeof(struct tcphdr)) { | |||||
printf("%s: short TCP frame?\n", __func__); | |||||
return (-1); | |||||
} | |||||
th = (struct tcphdr *)((caddr_t)ip + iphlen); | |||||
return rss_proto_software_hash_v4(ip->ip_src, ip->ip_dst, | |||||
th->th_sport, | |||||
th->th_dport, | |||||
proto, | |||||
hashval, | |||||
hashtype); | |||||
} else if ((rss_gethashconfig_local() & RSS_HASHTYPE_RSS_UDP_IPV4) && | |||||
(proto == IPPROTO_UDP) && | |||||
(is_frag == 0)) { | |||||
uh = (struct udphdr *)((caddr_t)ip + iphlen); | |||||
if (m->m_len < iphlen + sizeof(struct udphdr)) { | |||||
printf("%s: short UDP frame?\n", __func__); | |||||
return (-1); | |||||
} | |||||
return rss_proto_software_hash_v4(ip->ip_src, ip->ip_dst, | |||||
uh->uh_sport, | |||||
uh->uh_dport, | |||||
proto, | |||||
hashval, | |||||
hashtype); | |||||
} else if (rss_gethashconfig_local() & RSS_HASHTYPE_RSS_IPV4) { | |||||
/* Default to 2-tuple hash */ | |||||
return rss_proto_software_hash_v4(ip->ip_src, ip->ip_dst, | |||||
0, /* source port */ | |||||
0, /* destination port */ | |||||
0, /* IPPROTO_IP */ | |||||
hashval, | |||||
hashtype); | |||||
} else { | |||||
printf("%s: no available hashtypes!\n", __func__); | |||||
return (-1); | |||||
} | |||||
} | |||||
/* | |||||
* Similar to rss_m2cpuid, but designed to be used by the IP NETISR | |||||
* on incoming frames. | |||||
* | |||||
* If an existing RSS hash exists and it matches what the configured | |||||
* hashing is, then use it. | |||||
* | |||||
* If there's an existing RSS hash but the desired hash is different, | |||||
* or if there's no useful RSS hash, then calculate it via | |||||
* the software path. | |||||
* | |||||
* XXX TODO: definitely want statistics here! | |||||
*/ | |||||
struct mbuf * | |||||
rss_soft_m2cpuid(struct mbuf *m, uintptr_t source, u_int *cpuid) | |||||
{ | |||||
uint32_t hash_val, hash_type; | |||||
int ret; | |||||
M_ASSERTPKTHDR(m); | |||||
ret = rss_mbuf_software_hash_v4(m, RSS_HASH_PKT_INGRESS, | |||||
&hash_val, &hash_type); | |||||
if (ret > 0) { | |||||
/* mbuf has a valid hash already; don't need to modify it */ | |||||
*cpuid = rss_hash2cpuid(m->m_pkthdr.flowid, M_HASHTYPE_GET(m)); | |||||
} else if (ret == 0) { | |||||
/* hash was done; update */ | |||||
m->m_pkthdr.flowid = hash_val; | |||||
M_HASHTYPE_SET(m, hash_type); | |||||
*cpuid = rss_hash2cpuid(m->m_pkthdr.flowid, M_HASHTYPE_GET(m)); | |||||
} else { /* ret < 0 */ | |||||
/* no hash was done */ | |||||
*cpuid = NETISR_CPUID_NONE; | |||||
} | |||||
return (m); | |||||
} | |||||
/* | |||||
* Query the RSS hash algorithm. | * Query the RSS hash algorithm. | ||||
*/ | */ | ||||
u_int | u_int | ||||
rss_gethashalgo(void) | rss_gethashalgo(void) | ||||
{ | { | ||||
return (rss_hashalgo); | return (rss_hashalgo); | ||||
} | } | ||||
Show All 31 Lines | |||||
*/ | */ | ||||
u_int | u_int | ||||
rss_getnumcpus(void) | rss_getnumcpus(void) | ||||
{ | { | ||||
return (rss_ncpus); | return (rss_ncpus); | ||||
} | } | ||||
static inline u_int | /* | ||||
rss_gethashconfig_local(void) | * Return the supported RSS hash configuration. | ||||
* | |||||
* NICs should query this to determine what to configure in their redirection | |||||
* matching table. | |||||
*/ | |||||
inline u_int | |||||
rss_gethashconfig(void) | |||||
{ | { | ||||
/* Return 4-tuple for TCP; 2-tuple for others */ | /* Return 4-tuple for TCP; 2-tuple for others */ | ||||
/* | /* | ||||
* UDP may fragment more often than TCP and thus we'll end up with | * UDP may fragment more often than TCP and thus we'll end up with | ||||
* NICs returning 2-tuple fragments. | * NICs returning 2-tuple fragments. | ||||
* udp_init() and udplite_init() both currently initialise things | * udp_init() and udplite_init() both currently initialise things | ||||
* as 2-tuple. | * as 2-tuple. | ||||
Show All 9 Lines | rss_gethashconfig(void) | ||||
| RSS_HASHTYPE_RSS_TCP_IPV6_EX | | RSS_HASHTYPE_RSS_TCP_IPV6_EX | ||||
#if 0 | #if 0 | ||||
| RSS_HASHTYPE_RSS_UDP_IPV4 | | RSS_HASHTYPE_RSS_UDP_IPV4 | ||||
| RSS_HASHTYPE_RSS_UDP_IPV4_EX | | RSS_HASHTYPE_RSS_UDP_IPV4_EX | ||||
| RSS_HASHTYPE_RSS_UDP_IPV6 | | RSS_HASHTYPE_RSS_UDP_IPV6 | ||||
| RSS_HASHTYPE_RSS_UDP_IPV6_EX | | RSS_HASHTYPE_RSS_UDP_IPV6_EX | ||||
#endif | #endif | ||||
); | ); | ||||
} | |||||
/* | |||||
* Return the supported RSS hash configuration. | |||||
* | |||||
* NICs should query this to determine what to configure in their redirection | |||||
* matching table. | |||||
*/ | |||||
u_int | |||||
rss_gethashconfig(void) | |||||
{ | |||||
return (rss_gethashconfig_local()); | |||||
} | } | ||||
/* | /* | ||||
* XXXRW: Confirm that sysctl -a won't dump this keying material, don't want | * XXXRW: Confirm that sysctl -a won't dump this keying material, don't want | ||||
* it appearing in debugging output unnecessarily. | * it appearing in debugging output unnecessarily. | ||||
*/ | */ | ||||
static int | static int | ||||
sysctl_rss_key(SYSCTL_HANDLER_ARGS) | sysctl_rss_key(SYSCTL_HANDLER_ARGS) | ||||
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines |
This probably just wants to become $FreeBSD$