Page MenuHomeFreeBSD
Differential D14491

Don't define struct mymsg.
ClosedPublic
Actions

Authored by brooks on Feb 23 2018, 9:34 PM.
Tags
None
Referenced Files
Unknown Object (File)
Tue, Mar 11, 1:40 AM
Unknown Object (File)
Wed, Mar 5, 10:28 AM
Unknown Object (File)
Feb 8 2025, 1:05 AM
Unknown Object (File)
Jan 20 2025, 6:47 PM
Unknown Object (File)
Jan 16 2025, 12:55 PM
Unknown Object (File)
Jan 5 2025, 4:35 PM
Unknown Object (File)
Jan 3 2025, 7:04 PM
Unknown Object (File)
Dec 26 2024, 7:59 PM
View All 54 Files
Subscribers
imp

Details

Reviewers
jhb
emaste
kib
Commits
rS330298: Don't define struct mymsg.
Summary

This structure is an example in the POSIX manpage and it not part of the
standard as such.

In an exp-run a single port (qemu-user-static) was found to use them
which it did becuase it emulates system calls. This has been fixed in
the ports tree.

PR: 224299, 224443

Diff Detail

Lint
Lint Passed
Unit
No Test Coverage
Build Status
Buildable 15235
Build 15299: arc lint + arc unit

Revision Contents
Changeset List

PathSize
sys/
sys/
17 lines

Diff 39665

View Options

sys/sys/msg.h

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();
} }