Page MenuHomeFreeBSD
Differential D46412

tests: Add some test cases for SO_SPLICE
ClosedPublic
Actions

Authored by markj on Aug 22 2024, 2:22 PM.
Tags
None
Referenced Files
Unknown Object (File)
Feb 21 2025, 11:47 AM
Unknown Object (File)
Feb 8 2025, 6:36 AM
Unknown Object (File)
Feb 5 2025, 12:36 AM
Unknown Object (File)
Feb 4 2025, 9:54 PM
Unknown Object (File)
Feb 1 2025, 10:03 PM
Unknown Object (File)
Jan 29 2025, 1:15 AM
Unknown Object (File)
Jan 16 2025, 3:03 AM
Unknown Object (File)
Jan 16 2025, 2:51 AM
View All 39 Files
Subscribers
imp
jonathan

Details

Reviewers
gallatin
glebius
Group Reviewers
network
Commits
rG794fd74ab8bd: tests: Add some test cases for SO_SPLICE
rG877cf210c08b: tests: Add some test cases for SO_SPLICE
Summary

Sponsored by: Klara, Inc.
Sponsored by: Stormshield

Diff Detail

Repository
rG FreeBSD src repository
Lint
Lint Not Applicable
Unit
Tests Not Applicable

Event Timeline

markj created this revision.Aug 22 2024, 2:22 PM
Herald added subscribers: jonathan, imp. · View Herald TranscriptAug 22 2024, 2:22 PM
markj requested review of this revision.Aug 22 2024, 2:22 PM
Harbormaster completed remote builds in B59146: Diff 142349.Aug 22 2024, 2:22 PM
markj added a parent revision: D46411: socket: Implement SO_SPLICE.Aug 22 2024, 2:22 PM
markj added a child revision: D46413: sockstat: Show the address of the spliced socket when -I is specified.
markj updated this revision to Diff 143139.Sep 9 2024, 1:51 PM

Add a test case which creates a loop and verifies that killing
the splicing process also kills the loop.

Harbormaster completed remote builds in B59403: Diff 143139.Sep 9 2024, 1:51 PM
gallatin accepted this revision.Sep 9 2024, 4:08 PM
This revision is now accepted and ready to land.Sep 9 2024, 4:08 PM
Closed by commit rG877cf210c08b: tests: Add some test cases for SO_SPLICE (authored by markj). · Explain WhySep 10 2024, 4:55 PM
This revision was automatically updated to reflect the committed changes.
markj added a commit: rG877cf210c08b: tests: Add some test cases for SO_SPLICE.
markj added a commit: rG794fd74ab8bd: tests: Add some test cases for SO_SPLICE.Oct 17 2024, 4:17 PM

Revision Contents
Changeset List

PathSize
tests/
sys/
kern/
2 lines
979 lines

Diff 143201

View Options

tests/sys/kern/Makefile

Show First 20 Lines • Show All 45 Lines • ▼ Show 20 Lines
#include <sys/proc.h> #include <sys/proc.h>
#include <sys/kernel.h> #include <sys/kernel.h>
#include <sys/sched.h> #include <sys/sched.h>
#include <machine/clock.h> #include <machine/clock.h>
#include <machine/cpu.h> #include <machine/cpu.h>
#include <x86/init.h> #include <x86/init.h>
static u_int static void
get_tsc(__unused struct timecounter *tc) delay_tsc(int n)
{ {
uint64_t end, now;
return (rdtsc32()); /*
* Pin the current thread ensure correct behavior if the TSCs
* on different CPUs are not in sync.
*/
sched_pin();
now = rdtsc();
end = now + tsc_freq * n / 1000000;
do {
cpu_spinwait();
now = rdtsc();
} while (now < end);
sched_unpin();
} }
static int static int
delay_tc(int n) delay_tc(int n)
{ {
struct timecounter *tc; struct timecounter *tc;
timecounter_get_t *func; timecounter_get_t *func;
uint64_t end, freq, now; uint64_t end, freq, now;
u_int last, mask, u; u_int last, mask, u;
/*
* Only use the TSC if it is P-state invariant. If the TSC is
* not P-state invariant and the CPU is not running at the
* "full" P-state, then the TSC will increment at some rate
* less than tsc_freq and delay_tsc() will wait too long.
*/
if (tsc_is_invariant && tsc_freq != 0) {
delay_tsc(n);
return (1);
}
tc = timecounter; tc = timecounter;
freq = atomic_load_acq_64(&tsc_freq);
if (tsc_is_invariant && freq != 0) {
func = get_tsc;
mask = ~0u;
} else {
if (tc->tc_quality <= 0) if (tc->tc_quality <= 0)
return (0); return (0);
func = tc->tc_get_timecount; func = tc->tc_get_timecount;
mask = tc->tc_counter_mask; mask = tc->tc_counter_mask;
freq = tc->tc_frequency; freq = tc->tc_frequency;
}
now = 0; now = 0;
end = freq * n / 1000000; end = freq * n / 1000000;
if (func == get_tsc)
sched_pin();
last = func(tc) & mask; last = func(tc) & mask;
do { do {
cpu_spinwait(); cpu_spinwait();
u = func(tc) & mask; u = func(tc) & mask;
if (u < last) if (u < last)
now += mask - last + u + 1; now += mask - last + u + 1;
else else
now += u - last; now += u - last;
last = u; last = u;
} while (now < end); } while (now < end);
if (func == get_tsc)
sched_unpin();
return (1); return (1);
} }
void void
DELAY(int n) DELAY(int n)
{ {
TSENTER(); TSENTER();
if (delay_tc(n)) { if (delay_tc(n)) {
TSEXIT(); TSEXIT();
return; return;
} }
init_ops.early_delay(n); init_ops.early_delay(n);
TSEXIT(); TSEXIT();
} }
View Options

tests/sys/kern/socket_splice.c

Show First 20 Lines • Show All 45 Lines • ▼ Show 20 Lines
#include <sys/proc.h> #include <sys/proc.h>
#include <sys/kernel.h> #include <sys/kernel.h>
#include <sys/sched.h> #include <sys/sched.h>
#include <machine/clock.h> #include <machine/clock.h>
#include <machine/cpu.h> #include <machine/cpu.h>
#include <x86/init.h> #include <x86/init.h>
static u_int static void
get_tsc(__unused struct timecounter *tc) delay_tsc(int n)
{ {
uint64_t end, now;
return (rdtsc32()); /*
* Pin the current thread ensure correct behavior if the TSCs
* on different CPUs are not in sync.
*/
sched_pin();
now = rdtsc();
end = now + tsc_freq * n / 1000000;
do {
cpu_spinwait();
now = rdtsc();
} while (now < end);
sched_unpin();
} }
static int static int
delay_tc(int n) delay_tc(int n)
{ {
struct timecounter *tc; struct timecounter *tc;
timecounter_get_t *func; timecounter_get_t *func;
uint64_t end, freq, now; uint64_t end, freq, now;
u_int last, mask, u; u_int last, mask, u;
/*
* Only use the TSC if it is P-state invariant. If the TSC is
* not P-state invariant and the CPU is not running at the
* "full" P-state, then the TSC will increment at some rate
* less than tsc_freq and delay_tsc() will wait too long.
*/
if (tsc_is_invariant && tsc_freq != 0) {
delay_tsc(n);
return (1);
}
tc = timecounter; tc = timecounter;
freq = atomic_load_acq_64(&tsc_freq);
if (tsc_is_invariant && freq != 0) {
func = get_tsc;
mask = ~0u;
} else {
if (tc->tc_quality <= 0) if (tc->tc_quality <= 0)
return (0); return (0);
func = tc->tc_get_timecount; func = tc->tc_get_timecount;
mask = tc->tc_counter_mask; mask = tc->tc_counter_mask;
freq = tc->tc_frequency; freq = tc->tc_frequency;
}
now = 0; now = 0;
end = freq * n / 1000000; end = freq * n / 1000000;
if (func == get_tsc)
sched_pin();
last = func(tc) & mask; last = func(tc) & mask;
do { do {
cpu_spinwait(); cpu_spinwait();
u = func(tc) & mask; u = func(tc) & mask;
if (u < last) if (u < last)
now += mask - last + u + 1; now += mask - last + u + 1;
else else
now += u - last; now += u - last;
last = u; last = u;
} while (now < end); } while (now < end);
if (func == get_tsc)
sched_unpin();
return (1); return (1);
} }
void void
DELAY(int n) DELAY(int n)
{ {
TSENTER(); TSENTER();
if (delay_tc(n)) { if (delay_tc(n)) {
TSEXIT(); TSEXIT();
return; return;
} }
init_ops.early_delay(n); init_ops.early_delay(n);
TSEXIT(); TSEXIT();
} }