Page MenuHomeFreeBSD
Differential D29077

Implement basic support for allocating memory from a specific numa node in the LinuxKPI.
ClosedPublic
Actions

Authored by • hselasky on Mar 5 2021, 11:50 AM.
Tags
None
Referenced Files
Unknown Object (File)
Tue, Mar 18, 11:26 AM
Unknown Object (File)
Sat, Mar 15, 11:01 AM
Unknown Object (File)
Thu, Mar 13, 3:21 AM
Unknown Object (File)
Wed, Mar 12, 10:09 AM
Unknown Object (File)
Sun, Mar 9, 12:38 PM
Unknown Object (File)
Thu, Mar 6, 7:45 AM
Unknown Object (File)
Feb 4 2025, 7:28 AM
Unknown Object (File)
Feb 3 2025, 9:15 PM
View All Files
Subscribers
emaste
linuxkpi

Details

Reviewers
kib
manu
bz
markj
Commits
rG1a12a42a9ac5: MFC ebe5cf355dca:
rG773811507d44: MFC ebe5cf355dca:
rGebe5cf355dca: Implement basic support for allocating memory from a specific numa node
Summary

Implement basic support for allocating memory from a specific numa node in the LinuxKPI.

MFC after: 1 week
Sponsored by: Mellanox Technologies // NVIDIA Networking

Diff Detail

Repository
rG FreeBSD src repository
Lint
Lint Skipped
Unit
Tests Skipped

Event Timeline

• hselasky created this revision.Mar 5 2021, 11:50 AM
Herald added subscribers: linuxkpi, emaste. · View Herald TranscriptMar 5 2021, 11:50 AM
• hselasky requested review of this revision.Mar 5 2021, 11:50 AM
• hselasky updated this revision to Diff 85195.Mar 5 2021, 1:01 PM
kib added inline comments.Mar 6 2021, 5:45 AM
sys/compat/linuxkpi/common/src/linux_domain.c
47

Are you sure that FIXED policy is right there? What is the Linux' semantic?

From my experience, it almost never is. You typically want a graceful fallback to to other domains if requested domain is full. AFAIR in our terminology this means _PREF().

sys/kern/kern_malloc.c
808 ↗(On Diff #85195)

This line looks too long.

kern_malloc.c/malloc.h bits should be committed separately.

• hselasky added a comment.Mar 6 2021, 10:30 AM

Strip the malloc.h bits from this commit and push them separately.

• hselasky marked an inline comment as done.Mar 6 2021, 10:31 AM
• hselasky updated this revision to Diff 85263.Mar 6 2021, 10:42 AM

Update patch as per suggestions from kib@

• hselasky marked an inline comment as done.Mar 6 2021, 10:42 AM
kib accepted this revision.Mar 6 2021, 8:34 PM

Looks fine to me. I did not looked at the Linux KPI to see if this is a proper implementation.

I suggest to wait some time for Mark' comments.

This revision is now accepted and ready to land.Mar 6 2021, 8:34 PM
• hselasky added a reviewer: markj.Mar 9 2021, 2:56 PM
markj accepted this revision.Mar 9 2021, 5:13 PM

Looks ok to me.

sys/compat/linuxkpi/common/include/linux/device.h
557

Why is it variadic?

• hselasky added inline comments.Mar 9 2021, 5:56 PM
sys/compat/linuxkpi/common/include/linux/device.h
557

Just to get a better compile error, if the argument passed is bad.
Do you think I should change it?

markj added inline comments.Mar 9 2021, 7:28 PM
sys/compat/linuxkpi/common/include/linux/device.h
557

I think there should at least be a comment explaining it, otherwise it looks strange. And, why is it especially likely to get compile errors with this function?

• hselasky marked an inline comment as done.Mar 9 2021, 7:37 PM
• hselasky added inline comments.
sys/compat/linuxkpi/common/include/linux/device.h
557

OK, I'll fix.

• hselasky updated this revision to Diff 85414.Mar 9 2021, 7:42 PM
• hselasky marked an inline comment as done.

Fix comment by @markj .

This revision now requires review to proceed.Mar 9 2021, 7:42 PM
• hselasky marked an inline comment as done.Mar 9 2021, 7:43 PM
markj accepted this revision.Mar 9 2021, 7:50 PM
This revision is now accepted and ready to land.Mar 9 2021, 7:50 PM
• hselasky updated this revision to Diff 85420.Mar 9 2021, 7:58 PM

Added build-fix for DRM KMOD.

This revision now requires review to proceed.Mar 9 2021, 7:58 PM
This revision was not accepted when it landed; it landed in state Needs Review.Mar 9 2021, 8:09 PM
Closed by commit rGebe5cf355dca: Implement basic support for allocating memory from a specific numa node (authored by • hselasky). · Explain Why
This revision was automatically updated to reflect the committed changes.
• hselasky added a commit: rGebe5cf355dca: Implement basic support for allocating memory from a specific numa node.
• hselasky added a commit: rG773811507d44: MFC ebe5cf355dca:.Mar 23 2021, 10:58 AM
• hselasky added a commit: rG1a12a42a9ac5: MFC ebe5cf355dca:.Mar 23 2021, 11:48 AM

Revision Contents
Changeset List

PathSize
sys/
compat/
linuxkpi/
common/
include/
linux/
2 lines
7 lines
37 lines
src/
59 lines
conf/
2 lines
modules/
linuxkpi/
1 line

Diff 85263

View Options

sys/compat/linuxkpi/common/include/linux/compat.h

Show First 20 Lines • Show All 75 Lines • ▼ Show 20 Lines
* net.inet.tcp.fastopen.ccache_bucket_limit * net.inet.tcp.fastopen.ccache_bucket_limit
* (RWTUN, default TCP_FASTOPEN_CCACHE_BUCKET_LIMIT_DEFAULT) * (RWTUN, default TCP_FASTOPEN_CCACHE_BUCKET_LIMIT_DEFAULT)
* The maximum number of entries in a client cookie cache bucket. * The maximum number of entries in a client cookie cache bucket.
* *
* net.inet.tcp.fastopen.ccache_buckets * net.inet.tcp.fastopen.ccache_buckets
* (RDTUN, default TCP_FASTOPEN_CCACHE_BUCKETS_DEFAULT) * (RDTUN, default TCP_FASTOPEN_CCACHE_BUCKETS_DEFAULT)
* The number of client cookie cache buckets. * The number of client cookie cache buckets.
* *
* net.inet.tcp.fastopen.ccache_list (RO)
* Print the client cookie cache.
*
* net.inet.tcp.fastopen.client_enable (RW, default 0) * net.inet.tcp.fastopen.client_enable (RW, default 0)
* When zero, no new active (i.e., client) TFO connections can be * When zero, no new active (i.e., client) TFO connections can be
* created. On the transition from enabled to disabled, the client * created. On the transition from enabled to disabled, the client
* cookie cache is cleared and disabled. The transition from enabled to * cookie cache is cleared and disabled. The transition from enabled to
* disabled does not affect any active TFO connections in progress; it * disabled does not affect any active TFO connections in progress; it
* only prevents new ones from being made. * only prevents new ones from being made.
* *
* net.inet.tcp.fastopen.keylen (RD) * net.inet.tcp.fastopen.keylen (RD)
▲ Show 20 Lines • Show All 69 Lines • ▼ Show 20 Lines
*/ */
#include <sys/cdefs.h> #include <sys/cdefs.h>
__FBSDID("$FreeBSD$"); __FBSDID("$FreeBSD$");
#include "opt_inet.h" #include "opt_inet.h"
#include <sys/param.h> #include <sys/param.h>
#include <sys/jail.h>
#include <sys/kernel.h> #include <sys/kernel.h>
#include <sys/hash.h> #include <sys/hash.h>
#include <sys/limits.h> #include <sys/limits.h>
#include <sys/lock.h> #include <sys/lock.h>
#include <sys/proc.h>
#include <sys/rmlock.h> #include <sys/rmlock.h>
#include <sys/sbuf.h>
#include <sys/socket.h> #include <sys/socket.h>
#include <sys/socketvar.h> #include <sys/socketvar.h>
#include <sys/sysctl.h> #include <sys/sysctl.h>
#include <sys/systm.h> #include <sys/systm.h>
#include <crypto/siphash/siphash.h> #include <crypto/siphash/siphash.h>
#include <net/vnet.h> #include <net/vnet.h>
▲ Show 20 Lines • Show All 156 Lines • ▼ Show 20 LinesSYSCTL_PROC(_net_inet_tcp_fastopen, OID_AUTO, setkey,
"Install a new key"); "Install a new key");
static int sysctl_net_inet_tcp_fastopen_setpsk(SYSCTL_HANDLER_ARGS); static int sysctl_net_inet_tcp_fastopen_setpsk(SYSCTL_HANDLER_ARGS);
SYSCTL_PROC(_net_inet_tcp_fastopen, OID_AUTO, setpsk, SYSCTL_PROC(_net_inet_tcp_fastopen, OID_AUTO, setpsk,
CTLFLAG_VNET | CTLTYPE_OPAQUE | CTLFLAG_WR, NULL, 0, CTLFLAG_VNET | CTLTYPE_OPAQUE | CTLFLAG_WR, NULL, 0,
&sysctl_net_inet_tcp_fastopen_setpsk, "", &sysctl_net_inet_tcp_fastopen_setpsk, "",
"Install a new pre-shared key"); "Install a new pre-shared key");
static int sysctl_net_inet_tcp_fastopen_ccache_list(SYSCTL_HANDLER_ARGS);
SYSCTL_PROC(_net_inet_tcp_fastopen, OID_AUTO, ccache_list,
CTLFLAG_VNET | CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_SKIP, NULL, 0,
sysctl_net_inet_tcp_fastopen_ccache_list, "A",
"List of all client cookie cache entries");
static VNET_DEFINE(struct rmlock, tcp_fastopen_keylock); static VNET_DEFINE(struct rmlock, tcp_fastopen_keylock);
#define V_tcp_fastopen_keylock VNET(tcp_fastopen_keylock) #define V_tcp_fastopen_keylock VNET(tcp_fastopen_keylock)
#define TCP_FASTOPEN_KEYS_RLOCK(t) rm_rlock(&V_tcp_fastopen_keylock, (t)) #define TCP_FASTOPEN_KEYS_RLOCK(t) rm_rlock(&V_tcp_fastopen_keylock, (t))
#define TCP_FASTOPEN_KEYS_RUNLOCK(t) rm_runlock(&V_tcp_fastopen_keylock, (t)) #define TCP_FASTOPEN_KEYS_RUNLOCK(t) rm_runlock(&V_tcp_fastopen_keylock, (t))
#define TCP_FASTOPEN_KEYS_WLOCK() rm_wlock(&V_tcp_fastopen_keylock) #define TCP_FASTOPEN_KEYS_WLOCK() rm_wlock(&V_tcp_fastopen_keylock)
#define TCP_FASTOPEN_KEYS_WUNLOCK() rm_wunlock(&V_tcp_fastopen_keylock) #define TCP_FASTOPEN_KEYS_WUNLOCK() rm_wunlock(&V_tcp_fastopen_keylock)
▲ Show 20 Lines • Show All 774 Lines • ▼ Show 20 Linestcp_fastopen_ccache_entry_drop(struct tcp_fastopen_ccache_entry *cce,
struct tcp_fastopen_ccache_bucket *ccb) struct tcp_fastopen_ccache_bucket *ccb)
{ {
CCB_LOCK_ASSERT(ccb); CCB_LOCK_ASSERT(ccb);
TAILQ_REMOVE(&ccb->ccb_entries, cce, cce_link); TAILQ_REMOVE(&ccb->ccb_entries, cce, cce_link);
ccb->ccb_num_entries--; ccb->ccb_num_entries--;
uma_zfree(V_tcp_fastopen_ccache.zone, cce); uma_zfree(V_tcp_fastopen_ccache.zone, cce);
}
static int
sysctl_net_inet_tcp_fastopen_ccache_list(SYSCTL_HANDLER_ARGS)
{
struct sbuf sb;
struct tcp_fastopen_ccache_bucket *ccb;
struct tcp_fastopen_ccache_entry *cce;
sbintime_t now, duration, limit;
const int linesize = 128;
int i, error, num_entries;
unsigned int j;
#ifdef INET6
char clt_buf[INET6_ADDRSTRLEN], srv_buf[INET6_ADDRSTRLEN];
#else
char clt_buf[INET_ADDRSTRLEN], srv_buf[INET_ADDRSTRLEN];
#endif
if (jailed_without_vnet(curthread->td_ucred) != 0)
return (EPERM);
/* Only allow root to read the client cookie cache */
if (curthread->td_ucred->cr_uid != 0)
return (EPERM);
num_entries = 0;
for (i = 0; i < V_tcp_fastopen_ccache.buckets; i++) {
ccb = &V_tcp_fastopen_ccache.base[i];
CCB_LOCK(ccb);
if (ccb->ccb_num_entries > 0)
num_entries += ccb->ccb_num_entries;
CCB_UNLOCK(ccb);
}
sbuf_new(&sb, NULL, linesize * (num_entries + 1), SBUF_INCLUDENUL);
sbuf_printf(&sb,
"\nLocal IP address Remote IP address Port MSS"
" Disabled Cookie\n");
now = getsbinuptime();
limit = (sbintime_t)V_tcp_fastopen_path_disable_time << 32;
for (i = 0; i < V_tcp_fastopen_ccache.buckets; i++) {
ccb = &V_tcp_fastopen_ccache.base[i];
CCB_LOCK(ccb);
TAILQ_FOREACH(cce, &ccb->ccb_entries, cce_link) {
if (cce->disable_time != 0) {
duration = now - cce->disable_time;
if (limit >= duration)
duration = limit - duration;
else
duration = 0;
} else
duration = 0;
sbuf_printf(&sb,
"%-20s %-20s %5u %5u ",
inet_ntop(cce->af, &cce->cce_client_ip,
clt_buf, sizeof(clt_buf)),
inet_ntop(cce->af, &cce->cce_server_ip,
srv_buf, sizeof(srv_buf)),
ntohs(cce->server_port),
cce->server_mss);
if (duration > 0)
sbuf_printf(&sb, "%7ds ", sbintime_getsec(duration));
else
sbuf_printf(&sb, "%8s ", "No");
for (j = 0; j < cce->cookie_len; j++)
sbuf_printf(&sb, "%02x", cce->cookie[j]);
sbuf_putc(&sb, '\n');
}
CCB_UNLOCK(ccb);
}
error = sbuf_finish(&sb);
if (error == 0)
error = SYSCTL_OUT(req, sbuf_data(&sb), sbuf_len(&sb));
sbuf_delete(&sb);
return (error);
} }
View Options

sys/compat/linuxkpi/common/include/linux/device.h

Show First 20 Lines • Show All 75 Lines • ▼ Show 20 Lines
* net.inet.tcp.fastopen.ccache_bucket_limit * net.inet.tcp.fastopen.ccache_bucket_limit
* (RWTUN, default TCP_FASTOPEN_CCACHE_BUCKET_LIMIT_DEFAULT) * (RWTUN, default TCP_FASTOPEN_CCACHE_BUCKET_LIMIT_DEFAULT)
* The maximum number of entries in a client cookie cache bucket. * The maximum number of entries in a client cookie cache bucket.
* *
* net.inet.tcp.fastopen.ccache_buckets * net.inet.tcp.fastopen.ccache_buckets
* (RDTUN, default TCP_FASTOPEN_CCACHE_BUCKETS_DEFAULT) * (RDTUN, default TCP_FASTOPEN_CCACHE_BUCKETS_DEFAULT)
* The number of client cookie cache buckets. * The number of client cookie cache buckets.
* *
* net.inet.tcp.fastopen.ccache_list (RO)
* Print the client cookie cache.
*
* net.inet.tcp.fastopen.client_enable (RW, default 0) * net.inet.tcp.fastopen.client_enable (RW, default 0)
* When zero, no new active (i.e., client) TFO connections can be * When zero, no new active (i.e., client) TFO connections can be
* created. On the transition from enabled to disabled, the client * created. On the transition from enabled to disabled, the client
* cookie cache is cleared and disabled. The transition from enabled to * cookie cache is cleared and disabled. The transition from enabled to
* disabled does not affect any active TFO connections in progress; it * disabled does not affect any active TFO connections in progress; it
* only prevents new ones from being made. * only prevents new ones from being made.
* *
* net.inet.tcp.fastopen.keylen (RD) * net.inet.tcp.fastopen.keylen (RD)
▲ Show 20 Lines • Show All 69 Lines • ▼ Show 20 Lines
*/ */
#include <sys/cdefs.h> #include <sys/cdefs.h>
__FBSDID("$FreeBSD$"); __FBSDID("$FreeBSD$");
#include "opt_inet.h" #include "opt_inet.h"
#include <sys/param.h> #include <sys/param.h>
#include <sys/jail.h>
#include <sys/kernel.h> #include <sys/kernel.h>
#include <sys/hash.h> #include <sys/hash.h>
#include <sys/limits.h> #include <sys/limits.h>
#include <sys/lock.h> #include <sys/lock.h>
#include <sys/proc.h>
#include <sys/rmlock.h> #include <sys/rmlock.h>
#include <sys/sbuf.h>
#include <sys/socket.h> #include <sys/socket.h>
#include <sys/socketvar.h> #include <sys/socketvar.h>
#include <sys/sysctl.h> #include <sys/sysctl.h>
#include <sys/systm.h> #include <sys/systm.h>
#include <crypto/siphash/siphash.h> #include <crypto/siphash/siphash.h>
#include <net/vnet.h> #include <net/vnet.h>
▲ Show 20 Lines • Show All 156 Lines • ▼ Show 20 LinesSYSCTL_PROC(_net_inet_tcp_fastopen, OID_AUTO, setkey,
"Install a new key"); "Install a new key");
static int sysctl_net_inet_tcp_fastopen_setpsk(SYSCTL_HANDLER_ARGS); static int sysctl_net_inet_tcp_fastopen_setpsk(SYSCTL_HANDLER_ARGS);
SYSCTL_PROC(_net_inet_tcp_fastopen, OID_AUTO, setpsk, SYSCTL_PROC(_net_inet_tcp_fastopen, OID_AUTO, setpsk,
CTLFLAG_VNET | CTLTYPE_OPAQUE | CTLFLAG_WR, NULL, 0, CTLFLAG_VNET | CTLTYPE_OPAQUE | CTLFLAG_WR, NULL, 0,
&sysctl_net_inet_tcp_fastopen_setpsk, "", &sysctl_net_inet_tcp_fastopen_setpsk, "",
"Install a new pre-shared key"); "Install a new pre-shared key");
static int sysctl_net_inet_tcp_fastopen_ccache_list(SYSCTL_HANDLER_ARGS);
SYSCTL_PROC(_net_inet_tcp_fastopen, OID_AUTO, ccache_list,
CTLFLAG_VNET | CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_SKIP, NULL, 0,
sysctl_net_inet_tcp_fastopen_ccache_list, "A",
"List of all client cookie cache entries");
static VNET_DEFINE(struct rmlock, tcp_fastopen_keylock); static VNET_DEFINE(struct rmlock, tcp_fastopen_keylock);
#define V_tcp_fastopen_keylock VNET(tcp_fastopen_keylock) #define V_tcp_fastopen_keylock VNET(tcp_fastopen_keylock)
#define TCP_FASTOPEN_KEYS_RLOCK(t) rm_rlock(&V_tcp_fastopen_keylock, (t)) #define TCP_FASTOPEN_KEYS_RLOCK(t) rm_rlock(&V_tcp_fastopen_keylock, (t))
#define TCP_FASTOPEN_KEYS_RUNLOCK(t) rm_runlock(&V_tcp_fastopen_keylock, (t)) #define TCP_FASTOPEN_KEYS_RUNLOCK(t) rm_runlock(&V_tcp_fastopen_keylock, (t))
#define TCP_FASTOPEN_KEYS_WLOCK() rm_wlock(&V_tcp_fastopen_keylock) #define TCP_FASTOPEN_KEYS_WLOCK() rm_wlock(&V_tcp_fastopen_keylock)
#define TCP_FASTOPEN_KEYS_WUNLOCK() rm_wunlock(&V_tcp_fastopen_keylock) #define TCP_FASTOPEN_KEYS_WUNLOCK() rm_wunlock(&V_tcp_fastopen_keylock)
▲ Show 20 Lines • Show All 774 Lines • ▼ Show 20 Linestcp_fastopen_ccache_entry_drop(struct tcp_fastopen_ccache_entry *cce,
struct tcp_fastopen_ccache_bucket *ccb) struct tcp_fastopen_ccache_bucket *ccb)
{ {
CCB_LOCK_ASSERT(ccb); CCB_LOCK_ASSERT(ccb);
TAILQ_REMOVE(&ccb->ccb_entries, cce, cce_link); TAILQ_REMOVE(&ccb->ccb_entries, cce, cce_link);
ccb->ccb_num_entries--; ccb->ccb_num_entries--;
uma_zfree(V_tcp_fastopen_ccache.zone, cce); uma_zfree(V_tcp_fastopen_ccache.zone, cce);
}
static int
sysctl_net_inet_tcp_fastopen_ccache_list(SYSCTL_HANDLER_ARGS)
{
struct sbuf sb;
struct tcp_fastopen_ccache_bucket *ccb;
struct tcp_fastopen_ccache_entry *cce;
sbintime_t now, duration, limit;
const int linesize = 128;
int i, error, num_entries;
unsigned int j;
#ifdef INET6
char clt_buf[INET6_ADDRSTRLEN], srv_buf[INET6_ADDRSTRLEN];
#else
char clt_buf[INET_ADDRSTRLEN], srv_buf[INET_ADDRSTRLEN];
#endif
if (jailed_without_vnet(curthread->td_ucred) != 0)
return (EPERM);
/* Only allow root to read the client cookie cache */
if (curthread->td_ucred->cr_uid != 0)
return (EPERM);
num_entries = 0;
for (i = 0; i < V_tcp_fastopen_ccache.buckets; i++) {
ccb = &V_tcp_fastopen_ccache.base[i];
CCB_LOCK(ccb);
if (ccb->ccb_num_entries > 0)
num_entries += ccb->ccb_num_entries;
CCB_UNLOCK(ccb);
}
sbuf_new(&sb, NULL, linesize * (num_entries + 1), SBUF_INCLUDENUL);
sbuf_printf(&sb,
"\nLocal IP address Remote IP address Port MSS"
" Disabled Cookie\n");
now = getsbinuptime();
limit = (sbintime_t)V_tcp_fastopen_path_disable_time << 32;
for (i = 0; i < V_tcp_fastopen_ccache.buckets; i++) {
ccb = &V_tcp_fastopen_ccache.base[i];
CCB_LOCK(ccb);
TAILQ_FOREACH(cce, &ccb->ccb_entries, cce_link) {
if (cce->disable_time != 0) {
duration = now - cce->disable_time;
if (limit >= duration)
duration = limit - duration;
else
duration = 0;
} else
duration = 0;
sbuf_printf(&sb,
"%-20s %-20s %5u %5u ",
inet_ntop(cce->af, &cce->cce_client_ip,
clt_buf, sizeof(clt_buf)),
inet_ntop(cce->af, &cce->cce_server_ip,
srv_buf, sizeof(srv_buf)),
ntohs(cce->server_port),
cce->server_mss);
if (duration > 0)
sbuf_printf(&sb, "%7ds ", sbintime_getsec(duration));
else
sbuf_printf(&sb, "%8s ", "No");
for (j = 0; j < cce->cookie_len; j++)
sbuf_printf(&sb, "%02x", cce->cookie[j]);
sbuf_putc(&sb, '\n');
}
CCB_UNLOCK(ccb);
}
error = sbuf_finish(&sb);
if (error == 0)
error = SYSCTL_OUT(req, sbuf_data(&sb), sbuf_len(&sb));
sbuf_delete(&sb);
return (error);
} }
View Options

sys/compat/linuxkpi/common/include/linux/slab.h

Show First 20 Lines • Show All 75 Lines • ▼ Show 20 Lines
* net.inet.tcp.fastopen.ccache_bucket_limit * net.inet.tcp.fastopen.ccache_bucket_limit
* (RWTUN, default TCP_FASTOPEN_CCACHE_BUCKET_LIMIT_DEFAULT) * (RWTUN, default TCP_FASTOPEN_CCACHE_BUCKET_LIMIT_DEFAULT)
* The maximum number of entries in a client cookie cache bucket. * The maximum number of entries in a client cookie cache bucket.
* *
* net.inet.tcp.fastopen.ccache_buckets * net.inet.tcp.fastopen.ccache_buckets
* (RDTUN, default TCP_FASTOPEN_CCACHE_BUCKETS_DEFAULT) * (RDTUN, default TCP_FASTOPEN_CCACHE_BUCKETS_DEFAULT)
* The number of client cookie cache buckets. * The number of client cookie cache buckets.
* *
* net.inet.tcp.fastopen.ccache_list (RO)
* Print the client cookie cache.
*
* net.inet.tcp.fastopen.client_enable (RW, default 0) * net.inet.tcp.fastopen.client_enable (RW, default 0)
* When zero, no new active (i.e., client) TFO connections can be * When zero, no new active (i.e., client) TFO connections can be
* created. On the transition from enabled to disabled, the client * created. On the transition from enabled to disabled, the client
* cookie cache is cleared and disabled. The transition from enabled to * cookie cache is cleared and disabled. The transition from enabled to
* disabled does not affect any active TFO connections in progress; it * disabled does not affect any active TFO connections in progress; it
* only prevents new ones from being made. * only prevents new ones from being made.
* *
* net.inet.tcp.fastopen.keylen (RD) * net.inet.tcp.fastopen.keylen (RD)
▲ Show 20 Lines • Show All 69 Lines • ▼ Show 20 Lines
*/ */
#include <sys/cdefs.h> #include <sys/cdefs.h>
__FBSDID("$FreeBSD$"); __FBSDID("$FreeBSD$");
#include "opt_inet.h" #include "opt_inet.h"
#include <sys/param.h> #include <sys/param.h>
#include <sys/jail.h>
#include <sys/kernel.h> #include <sys/kernel.h>
#include <sys/hash.h> #include <sys/hash.h>
#include <sys/limits.h> #include <sys/limits.h>
#include <sys/lock.h> #include <sys/lock.h>
#include <sys/proc.h>
#include <sys/rmlock.h> #include <sys/rmlock.h>
#include <sys/sbuf.h>
#include <sys/socket.h> #include <sys/socket.h>
#include <sys/socketvar.h> #include <sys/socketvar.h>
#include <sys/sysctl.h> #include <sys/sysctl.h>
#include <sys/systm.h> #include <sys/systm.h>
#include <crypto/siphash/siphash.h> #include <crypto/siphash/siphash.h>
#include <net/vnet.h> #include <net/vnet.h>
▲ Show 20 Lines • Show All 156 Lines • ▼ Show 20 LinesSYSCTL_PROC(_net_inet_tcp_fastopen, OID_AUTO, setkey,
"Install a new key"); "Install a new key");
static int sysctl_net_inet_tcp_fastopen_setpsk(SYSCTL_HANDLER_ARGS); static int sysctl_net_inet_tcp_fastopen_setpsk(SYSCTL_HANDLER_ARGS);
SYSCTL_PROC(_net_inet_tcp_fastopen, OID_AUTO, setpsk, SYSCTL_PROC(_net_inet_tcp_fastopen, OID_AUTO, setpsk,
CTLFLAG_VNET | CTLTYPE_OPAQUE | CTLFLAG_WR, NULL, 0, CTLFLAG_VNET | CTLTYPE_OPAQUE | CTLFLAG_WR, NULL, 0,
&sysctl_net_inet_tcp_fastopen_setpsk, "", &sysctl_net_inet_tcp_fastopen_setpsk, "",
"Install a new pre-shared key"); "Install a new pre-shared key");
static int sysctl_net_inet_tcp_fastopen_ccache_list(SYSCTL_HANDLER_ARGS);
SYSCTL_PROC(_net_inet_tcp_fastopen, OID_AUTO, ccache_list,
CTLFLAG_VNET | CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_SKIP, NULL, 0,
sysctl_net_inet_tcp_fastopen_ccache_list, "A",
"List of all client cookie cache entries");
static VNET_DEFINE(struct rmlock, tcp_fastopen_keylock); static VNET_DEFINE(struct rmlock, tcp_fastopen_keylock);
#define V_tcp_fastopen_keylock VNET(tcp_fastopen_keylock) #define V_tcp_fastopen_keylock VNET(tcp_fastopen_keylock)
#define TCP_FASTOPEN_KEYS_RLOCK(t) rm_rlock(&V_tcp_fastopen_keylock, (t)) #define TCP_FASTOPEN_KEYS_RLOCK(t) rm_rlock(&V_tcp_fastopen_keylock, (t))
#define TCP_FASTOPEN_KEYS_RUNLOCK(t) rm_runlock(&V_tcp_fastopen_keylock, (t)) #define TCP_FASTOPEN_KEYS_RUNLOCK(t) rm_runlock(&V_tcp_fastopen_keylock, (t))
#define TCP_FASTOPEN_KEYS_WLOCK() rm_wlock(&V_tcp_fastopen_keylock) #define TCP_FASTOPEN_KEYS_WLOCK() rm_wlock(&V_tcp_fastopen_keylock)
#define TCP_FASTOPEN_KEYS_WUNLOCK() rm_wunlock(&V_tcp_fastopen_keylock) #define TCP_FASTOPEN_KEYS_WUNLOCK() rm_wunlock(&V_tcp_fastopen_keylock)
▲ Show 20 Lines • Show All 774 Lines • ▼ Show 20 Linestcp_fastopen_ccache_entry_drop(struct tcp_fastopen_ccache_entry *cce,
struct tcp_fastopen_ccache_bucket *ccb) struct tcp_fastopen_ccache_bucket *ccb)
{ {
CCB_LOCK_ASSERT(ccb); CCB_LOCK_ASSERT(ccb);
TAILQ_REMOVE(&ccb->ccb_entries, cce, cce_link); TAILQ_REMOVE(&ccb->ccb_entries, cce, cce_link);
ccb->ccb_num_entries--; ccb->ccb_num_entries--;
uma_zfree(V_tcp_fastopen_ccache.zone, cce); uma_zfree(V_tcp_fastopen_ccache.zone, cce);
}
static int
sysctl_net_inet_tcp_fastopen_ccache_list(SYSCTL_HANDLER_ARGS)
{
struct sbuf sb;
struct tcp_fastopen_ccache_bucket *ccb;
struct tcp_fastopen_ccache_entry *cce;
sbintime_t now, duration, limit;
const int linesize = 128;
int i, error, num_entries;
unsigned int j;
#ifdef INET6
char clt_buf[INET6_ADDRSTRLEN], srv_buf[INET6_ADDRSTRLEN];
#else
char clt_buf[INET_ADDRSTRLEN], srv_buf[INET_ADDRSTRLEN];
#endif
if (jailed_without_vnet(curthread->td_ucred) != 0)
return (EPERM);
/* Only allow root to read the client cookie cache */
if (curthread->td_ucred->cr_uid != 0)
return (EPERM);
num_entries = 0;
for (i = 0; i < V_tcp_fastopen_ccache.buckets; i++) {
ccb = &V_tcp_fastopen_ccache.base[i];
CCB_LOCK(ccb);
if (ccb->ccb_num_entries > 0)
num_entries += ccb->ccb_num_entries;
CCB_UNLOCK(ccb);
}
sbuf_new(&sb, NULL, linesize * (num_entries + 1), SBUF_INCLUDENUL);
sbuf_printf(&sb,
"\nLocal IP address Remote IP address Port MSS"
" Disabled Cookie\n");
now = getsbinuptime();
limit = (sbintime_t)V_tcp_fastopen_path_disable_time << 32;
for (i = 0; i < V_tcp_fastopen_ccache.buckets; i++) {
ccb = &V_tcp_fastopen_ccache.base[i];
CCB_LOCK(ccb);
TAILQ_FOREACH(cce, &ccb->ccb_entries, cce_link) {
if (cce->disable_time != 0) {
duration = now - cce->disable_time;
if (limit >= duration)
duration = limit - duration;
else
duration = 0;
} else
duration = 0;
sbuf_printf(&sb,
"%-20s %-20s %5u %5u ",
inet_ntop(cce->af, &cce->cce_client_ip,
clt_buf, sizeof(clt_buf)),
inet_ntop(cce->af, &cce->cce_server_ip,
srv_buf, sizeof(srv_buf)),
ntohs(cce->server_port),
cce->server_mss);
if (duration > 0)
sbuf_printf(&sb, "%7ds ", sbintime_getsec(duration));
else
sbuf_printf(&sb, "%8s ", "No");
for (j = 0; j < cce->cookie_len; j++)
sbuf_printf(&sb, "%02x", cce->cookie[j]);
sbuf_putc(&sb, '\n');
}
CCB_UNLOCK(ccb);
}
error = sbuf_finish(&sb);
if (error == 0)
error = SYSCTL_OUT(req, sbuf_data(&sb), sbuf_len(&sb));
sbuf_delete(&sb);
return (error);
} }
View Options

sys/compat/linuxkpi/common/src/linux_domain.c

Show First 20 Lines • Show All 75 Lines • ▼ Show 20 Lines
* net.inet.tcp.fastopen.ccache_bucket_limit * net.inet.tcp.fastopen.ccache_bucket_limit
* (RWTUN, default TCP_FASTOPEN_CCACHE_BUCKET_LIMIT_DEFAULT) * (RWTUN, default TCP_FASTOPEN_CCACHE_BUCKET_LIMIT_DEFAULT)
* The maximum number of entries in a client cookie cache bucket. * The maximum number of entries in a client cookie cache bucket.
* *
* net.inet.tcp.fastopen.ccache_buckets * net.inet.tcp.fastopen.ccache_buckets
* (RDTUN, default TCP_FASTOPEN_CCACHE_BUCKETS_DEFAULT) * (RDTUN, default TCP_FASTOPEN_CCACHE_BUCKETS_DEFAULT)
* The number of client cookie cache buckets. * The number of client cookie cache buckets.
* *
* net.inet.tcp.fastopen.ccache_list (RO)
* Print the client cookie cache.
*
* net.inet.tcp.fastopen.client_enable (RW, default 0) * net.inet.tcp.fastopen.client_enable (RW, default 0)
* When zero, no new active (i.e., client) TFO connections can be * When zero, no new active (i.e., client) TFO connections can be
* created. On the transition from enabled to disabled, the client * created. On the transition from enabled to disabled, the client
* cookie cache is cleared and disabled. The transition from enabled to * cookie cache is cleared and disabled. The transition from enabled to
* disabled does not affect any active TFO connections in progress; it * disabled does not affect any active TFO connections in progress; it
* only prevents new ones from being made. * only prevents new ones from being made.
* *
* net.inet.tcp.fastopen.keylen (RD) * net.inet.tcp.fastopen.keylen (RD)
▲ Show 20 Lines • Show All 69 Lines • ▼ Show 20 Lines
*/ */
#include <sys/cdefs.h> #include <sys/cdefs.h>
__FBSDID("$FreeBSD$"); __FBSDID("$FreeBSD$");
#include "opt_inet.h" #include "opt_inet.h"
#include <sys/param.h> #include <sys/param.h>
#include <sys/jail.h>
#include <sys/kernel.h> #include <sys/kernel.h>
#include <sys/hash.h> #include <sys/hash.h>
#include <sys/limits.h> #include <sys/limits.h>
#include <sys/lock.h> #include <sys/lock.h>
#include <sys/proc.h>
#include <sys/rmlock.h> #include <sys/rmlock.h>
#include <sys/sbuf.h>
#include <sys/socket.h> #include <sys/socket.h>
#include <sys/socketvar.h> #include <sys/socketvar.h>
#include <sys/sysctl.h> #include <sys/sysctl.h>
#include <sys/systm.h> #include <sys/systm.h>
#include <crypto/siphash/siphash.h> #include <crypto/siphash/siphash.h>
#include <net/vnet.h> #include <net/vnet.h>
▲ Show 20 Lines • Show All 156 Lines • ▼ Show 20 LinesSYSCTL_PROC(_net_inet_tcp_fastopen, OID_AUTO, setkey,
"Install a new key"); "Install a new key");
static int sysctl_net_inet_tcp_fastopen_setpsk(SYSCTL_HANDLER_ARGS); static int sysctl_net_inet_tcp_fastopen_setpsk(SYSCTL_HANDLER_ARGS);
SYSCTL_PROC(_net_inet_tcp_fastopen, OID_AUTO, setpsk, SYSCTL_PROC(_net_inet_tcp_fastopen, OID_AUTO, setpsk,
CTLFLAG_VNET | CTLTYPE_OPAQUE | CTLFLAG_WR, NULL, 0, CTLFLAG_VNET | CTLTYPE_OPAQUE | CTLFLAG_WR, NULL, 0,
&sysctl_net_inet_tcp_fastopen_setpsk, "", &sysctl_net_inet_tcp_fastopen_setpsk, "",
"Install a new pre-shared key"); "Install a new pre-shared key");
static int sysctl_net_inet_tcp_fastopen_ccache_list(SYSCTL_HANDLER_ARGS);
SYSCTL_PROC(_net_inet_tcp_fastopen, OID_AUTO, ccache_list,
CTLFLAG_VNET | CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_SKIP, NULL, 0,
sysctl_net_inet_tcp_fastopen_ccache_list, "A",
"List of all client cookie cache entries");
static VNET_DEFINE(struct rmlock, tcp_fastopen_keylock); static VNET_DEFINE(struct rmlock, tcp_fastopen_keylock);
#define V_tcp_fastopen_keylock VNET(tcp_fastopen_keylock) #define V_tcp_fastopen_keylock VNET(tcp_fastopen_keylock)
#define TCP_FASTOPEN_KEYS_RLOCK(t) rm_rlock(&V_tcp_fastopen_keylock, (t)) #define TCP_FASTOPEN_KEYS_RLOCK(t) rm_rlock(&V_tcp_fastopen_keylock, (t))
#define TCP_FASTOPEN_KEYS_RUNLOCK(t) rm_runlock(&V_tcp_fastopen_keylock, (t)) #define TCP_FASTOPEN_KEYS_RUNLOCK(t) rm_runlock(&V_tcp_fastopen_keylock, (t))
#define TCP_FASTOPEN_KEYS_WLOCK() rm_wlock(&V_tcp_fastopen_keylock) #define TCP_FASTOPEN_KEYS_WLOCK() rm_wlock(&V_tcp_fastopen_keylock)
#define TCP_FASTOPEN_KEYS_WUNLOCK() rm_wunlock(&V_tcp_fastopen_keylock) #define TCP_FASTOPEN_KEYS_WUNLOCK() rm_wunlock(&V_tcp_fastopen_keylock)
▲ Show 20 Lines • Show All 774 Lines • ▼ Show 20 Linestcp_fastopen_ccache_entry_drop(struct tcp_fastopen_ccache_entry *cce,
struct tcp_fastopen_ccache_bucket *ccb) struct tcp_fastopen_ccache_bucket *ccb)
{ {
CCB_LOCK_ASSERT(ccb); CCB_LOCK_ASSERT(ccb);
TAILQ_REMOVE(&ccb->ccb_entries, cce, cce_link); TAILQ_REMOVE(&ccb->ccb_entries, cce, cce_link);
ccb->ccb_num_entries--; ccb->ccb_num_entries--;
uma_zfree(V_tcp_fastopen_ccache.zone, cce); uma_zfree(V_tcp_fastopen_ccache.zone, cce);
}
static int
sysctl_net_inet_tcp_fastopen_ccache_list(SYSCTL_HANDLER_ARGS)
{
struct sbuf sb;
struct tcp_fastopen_ccache_bucket *ccb;
struct tcp_fastopen_ccache_entry *cce;
sbintime_t now, duration, limit;
const int linesize = 128;
int i, error, num_entries;
unsigned int j;
#ifdef INET6
char clt_buf[INET6_ADDRSTRLEN], srv_buf[INET6_ADDRSTRLEN];
#else
char clt_buf[INET_ADDRSTRLEN], srv_buf[INET_ADDRSTRLEN];
#endif
if (jailed_without_vnet(curthread->td_ucred) != 0)
return (EPERM);
/* Only allow root to read the client cookie cache */
if (curthread->td_ucred->cr_uid != 0)
return (EPERM);
num_entries = 0;
for (i = 0; i < V_tcp_fastopen_ccache.buckets; i++) {
ccb = &V_tcp_fastopen_ccache.base[i];
CCB_LOCK(ccb);
if (ccb->ccb_num_entries > 0)
num_entries += ccb->ccb_num_entries;
CCB_UNLOCK(ccb);
}
sbuf_new(&sb, NULL, linesize * (num_entries + 1), SBUF_INCLUDENUL);
sbuf_printf(&sb,
"\nLocal IP address Remote IP address Port MSS"
" Disabled Cookie\n");
now = getsbinuptime();
limit = (sbintime_t)V_tcp_fastopen_path_disable_time << 32;
for (i = 0; i < V_tcp_fastopen_ccache.buckets; i++) {
ccb = &V_tcp_fastopen_ccache.base[i];
CCB_LOCK(ccb);
TAILQ_FOREACH(cce, &ccb->ccb_entries, cce_link) {
if (cce->disable_time != 0) {
duration = now - cce->disable_time;
if (limit >= duration)
duration = limit - duration;
else
duration = 0;
} else
duration = 0;
sbuf_printf(&sb,
"%-20s %-20s %5u %5u ",
inet_ntop(cce->af, &cce->cce_client_ip,
clt_buf, sizeof(clt_buf)),
inet_ntop(cce->af, &cce->cce_server_ip,
srv_buf, sizeof(srv_buf)),
ntohs(cce->server_port),
cce->server_mss);
if (duration > 0)
sbuf_printf(&sb, "%7ds ", sbintime_getsec(duration));
else
sbuf_printf(&sb, "%8s ", "No");
for (j = 0; j < cce->cookie_len; j++)
sbuf_printf(&sb, "%02x", cce->cookie[j]);
sbuf_putc(&sb, '\n');
}
CCB_UNLOCK(ccb);
}
error = sbuf_finish(&sb);
if (error == 0)
error = SYSCTL_OUT(req, sbuf_data(&sb), sbuf_len(&sb));
sbuf_delete(&sb);
return (error);
} }
View Options

sys/conf/files

Loading...
View Options

sys/modules/linuxkpi/Makefile

Loading...