Page MenuHomeFreeBSD
Differential D46530

openzfs: Reduce local diffs
ClosedPublic
Actions

Authored by jhb on Sep 4 2024, 2:09 PM.
Tags
None
Referenced Files
Unknown Object (File)
Mon, Mar 17, 4:17 PM
Unknown Object (File)
Tue, Mar 11, 2:19 AM
Unknown Object (File)
Sun, Mar 9, 6:22 PM
Unknown Object (File)
Feb 13 2025, 5:50 PM
Unknown Object (File)
Feb 12 2025, 10:58 AM
Unknown Object (File)
Feb 10 2025, 12:23 PM
Unknown Object (File)
Feb 10 2025, 12:22 PM
Unknown Object (File)
Feb 10 2025, 12:22 PM
View All 36 Files
Subscribers
delphij
emaste
imp
jhibbits
ZFS

Details

Reviewers
mm
mav
emaste
Commits
rG59f5f100b774: openzfs: Reduce local diffs
Summary

These are all local diffs that have no functional change.

Sponsored by: AFRL, DARPA

Diff Detail

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

Event Timeline

jhb created this revision.Sep 4 2024, 2:09 PM
Herald added subscribers: delphij, imp. · View Herald TranscriptSep 4 2024, 2:09 PM
jhb requested review of this revision.Sep 4 2024, 2:09 PM
Harbormaster completed remote builds in B59298: Diff 142856.Sep 4 2024, 2:09 PM
jhb added inline comments.Sep 4 2024, 2:09 PM
sys/contrib/openzfs/module/os/freebsd/zfs/zfs_ctldir.c
689

Possibly this should be fixed upstream instead, but having it as a local diff is needless.

jhb added a comment.Sep 4 2024, 2:13 PM

FYI, we track a modified version of OpenZFS for CHERI and keep track of local changes in FreeBSD in a 'freebsd' branch forked from 'master' that we periodically rebase as we merge in upstream FreeBSD commits. It's a few months behind currently, but you can see the local changes we have here: https://github.com/openzfs/zfs/compare/master...CTSRD-CHERI:zfs:freebsd Some of these fixes should possibly go upstream. The lz4 allocator changes stand out as an odd local patch to me as they came in without a real log message during a merge.

jhb added a reviewer: mav.Sep 14 2024, 9:38 AM
jhb added a subscriber: ZFS.Oct 2 2024, 7:22 PM

Ping

mav accepted this revision.Oct 2 2024, 7:26 PM
This revision is now accepted and ready to land.Oct 2 2024, 7:26 PM
emaste added a subscriber: emaste.Oct 2 2024, 7:28 PM
emaste added inline comments.
sys/contrib/openzfs/include/os/freebsd/spl/sys/simd_powerpc.h
52

This feels like a comment that would be useful upstream, but agreed there's little value in carrying this as a local diff.

sys/contrib/openzfs/module/os/freebsd/zfs/zfs_ctldir.c
689

I see 57 files with sizeof( and 385 with sizeof ( upstream (some files might have both styles and be double-counted) so it looks like our local diff is contrary to upstream's preferred style.

emaste accepted this revision.Oct 2 2024, 7:28 PM
emaste added a subscriber: jhibbits.Oct 2 2024, 7:32 PM
emaste added inline comments.
sys/contrib/openzfs/include/os/freebsd/spl/sys/simd_powerpc.h
52

For context: https://github.com/openzfs/zfs/pull/14779/commits/810fb097682a077a618283835c0e93ad2acc2659 and 344986ff4cb6f.

@jhibbits do you think it's worth an upstream change to add a comment like this?

jhibbits added inline comments.Oct 2 2024, 7:52 PM
sys/contrib/openzfs/include/os/freebsd/spl/sys/simd_powerpc.h
52

I think it can be dropped. In fact, I *think* kernel FPU support was added recently as part of the openssl work, so this might be able to be changed to 1 instead, but needs tested first.

Closed by commit rG59f5f100b774: openzfs: Reduce local diffs (authored by jhb). · Explain WhyOct 3 2024, 4:08 PM
This revision was automatically updated to reflect the committed changes.
jhb added a commit: rG59f5f100b774: openzfs: Reduce local diffs.

Revision Contents
Changeset List

PathSize
sys/
contrib/
openzfs/
include/
os/
freebsd/
spl/
sys/
2 lines
1 line
module/
os/
freebsd/
zfs/
2 lines

Diff 144169

View Options

sys/contrib/openzfs/include/os/freebsd/spl/sys/simd_powerpc.h

Show First 20 Lines • Show All 179 Lines • ▼ Show 20 Linesstatic const char *blessed[] = {
"so_rcv_sx", "so_rcv_sx",
NULL NULL
}; };
static int slptime_threshold = 1800; static int slptime_threshold = 1800;
static int blktime_threshold = 900; static int blktime_threshold = 900;
static int sleepfreq = 3; static int sleepfreq = 3;
static void static void
deadlkres(void) deadlres_td_on_lock(struct proc *p, struct thread *td, int blkticks)
{ {
struct proc *p; int tticks;
struct thread *td;
void *wchan;
int blkticks, i, slpticks, slptype, tryl, tticks;
tryl = 0; sx_assert(&allproc_lock, SX_LOCKED);
for (;;) { PROC_LOCK_ASSERT(p, MA_OWNED);
blkticks = blktime_threshold * hz; THREAD_LOCK_ASSERT(td, MA_OWNED);
slpticks = slptime_threshold * hz;
/* /*
* Avoid to sleep on the sx_lock in order to avoid a possible * The thread should be blocked on a turnstile, simply check
* priority inversion problem leading to starvation. * if the turnstile channel is in good state.
* If the lock can't be held after 100 tries, panic.
*/ */
if (!sx_try_slock(&allproc_lock)) {
if (tryl > 100)
panic("%s: possible deadlock detected on allproc_lock\n",
__func__);
tryl++;
pause("allproc", sleepfreq * hz);
continue;
}
tryl = 0;
FOREACH_PROC_IN_SYSTEM(p) {
PROC_LOCK(p);
if (p->p_state == PRS_NEW) {
PROC_UNLOCK(p);
continue;
}
FOREACH_THREAD_IN_PROC(p, td) {
thread_lock(td);
if (TD_ON_LOCK(td)) {
/*
* The thread should be blocked on a
* turnstile, simply check if the
* turnstile channel is in good state.
*/
MPASS(td->td_blocked != NULL); MPASS(td->td_blocked != NULL);
tticks = ticks - td->td_blktick; tticks = ticks - td->td_blktick;
thread_unlock(td); if (tticks > blkticks)
if (tticks > blkticks) {
/* /*
* Accordingly with provided * Accordingly with provided thresholds, this thread is stuck
* thresholds, this thread is * for too long on a turnstile.
* stuck for too long on a
* turnstile.
*/ */
PROC_UNLOCK(p); panic("%s: possible deadlock detected for %p, "
sx_sunlock(&allproc_lock); "blocked for %d ticks\n", __func__, td, tticks);
panic("%s: possible deadlock detected for %p, blocked for %d ticks\n",
__func__, td, tticks);
} }
} else if (TD_IS_SLEEPING(td) &&
TD_ON_SLEEPQ(td)) {
static void
deadlres_td_sleep_q(struct proc *p, struct thread *td, int slpticks)
{
void *wchan;
int i, slptype, tticks;
sx_assert(&allproc_lock, SX_LOCKED);
PROC_LOCK_ASSERT(p, MA_OWNED);
THREAD_LOCK_ASSERT(td, MA_OWNED);
/* /*
* Check if the thread is sleeping on a * Check if the thread is sleeping on a lock, otherwise skip the check.
* lock, otherwise skip the check. * Drop the thread lock in order to avoid a LOR with the sleepqueue
* Drop the thread lock in order to
* avoid a LOR with the sleepqueue
* spinlock. * spinlock.
*/ */
wchan = td->td_wchan; wchan = td->td_wchan;
tticks = ticks - td->td_slptick; tticks = ticks - td->td_slptick;
thread_unlock(td);
slptype = sleepq_type(wchan); slptype = sleepq_type(wchan);
if ((slptype == SLEEPQ_SX || if ((slptype == SLEEPQ_SX || slptype == SLEEPQ_LK) &&
slptype == SLEEPQ_LK) &&
tticks > slpticks) { tticks > slpticks) {
/* /*
* Accordingly with provided * Accordingly with provided thresholds, this thread is stuck
* thresholds, this thread is * for too long on a sleepqueue.
* stuck for too long on a * However, being on a sleepqueue, we might still check for the
* sleepqueue. * blessed list.
* However, being on a
* sleepqueue, we might still
* check for the blessed
* list.
*/ */
tryl = 0; for (i = 0; blessed[i] != NULL; i++)
for (i = 0; blessed[i] != NULL; if (!strcmp(blessed[i], td->td_wmesg))
i++) { return;
if (!strcmp(blessed[i],
td->td_wmesg)) { panic("%s: possible deadlock detected for %p, "
tryl = 1; "blocked for %d ticks\n", __func__, td, tticks);
break;
} }
} }
if (tryl != 0) {
static void
deadlkres(void)
{
struct proc *p;
struct thread *td;
int blkticks, slpticks, tryl;
tryl = 0; tryl = 0;
for (;;) {
blkticks = blktime_threshold * hz;
slpticks = slptime_threshold * hz;
/*
* Avoid to sleep on the sx_lock in order to avoid a
* possible priority inversion problem leading to
* starvation.
* If the lock can't be held after 100 tries, panic.
*/
if (!sx_try_slock(&allproc_lock)) {
if (tryl > 100)
panic("%s: possible deadlock detected "
"on allproc_lock\n", __func__);
tryl++;
pause("allproc", sleepfreq * hz);
continue; continue;
} }
tryl = 0;
FOREACH_PROC_IN_SYSTEM(p) {
PROC_LOCK(p);
if (p->p_state == PRS_NEW) {
PROC_UNLOCK(p); PROC_UNLOCK(p);
sx_sunlock(&allproc_lock); continue;
panic("%s: possible deadlock detected for %p, blocked for %d ticks\n",
__func__, td, tticks);
} }
} else FOREACH_THREAD_IN_PROC(p, td) {
thread_lock(td);
if (TD_ON_LOCK(td))
deadlres_td_on_lock(p, td,
blkticks);
else if (TD_IS_SLEEPING(td) &&
TD_ON_SLEEPQ(td))
deadlres_td_sleep_q(p, td,
slpticks);
thread_unlock(td); thread_unlock(td);
} }
PROC_UNLOCK(p); PROC_UNLOCK(p);
} }
sx_sunlock(&allproc_lock); sx_sunlock(&allproc_lock);
/* Sleep for sleepfreq seconds. */ /* Sleep for sleepfreq seconds. */
pause("-", sleepfreq * hz); pause("-", sleepfreq * hz);
} }
▲ Show 20 Lines • Show All 599 Lines • Show Last 20 Lines
View Options

sys/contrib/openzfs/include/os/freebsd/spl/sys/simd_x86.h

Show First 20 Lines • Show All 179 Lines • ▼ Show 20 Linesstatic const char *blessed[] = {
"so_rcv_sx", "so_rcv_sx",
NULL NULL
}; };
static int slptime_threshold = 1800; static int slptime_threshold = 1800;
static int blktime_threshold = 900; static int blktime_threshold = 900;
static int sleepfreq = 3; static int sleepfreq = 3;
static void static void
deadlkres(void) deadlres_td_on_lock(struct proc *p, struct thread *td, int blkticks)
{ {
struct proc *p; int tticks;
struct thread *td;
void *wchan;
int blkticks, i, slpticks, slptype, tryl, tticks;
tryl = 0; sx_assert(&allproc_lock, SX_LOCKED);
for (;;) { PROC_LOCK_ASSERT(p, MA_OWNED);
blkticks = blktime_threshold * hz; THREAD_LOCK_ASSERT(td, MA_OWNED);
slpticks = slptime_threshold * hz;
/* /*
* Avoid to sleep on the sx_lock in order to avoid a possible * The thread should be blocked on a turnstile, simply check
* priority inversion problem leading to starvation. * if the turnstile channel is in good state.
* If the lock can't be held after 100 tries, panic.
*/ */
if (!sx_try_slock(&allproc_lock)) {
if (tryl > 100)
panic("%s: possible deadlock detected on allproc_lock\n",
__func__);
tryl++;
pause("allproc", sleepfreq * hz);
continue;
}
tryl = 0;
FOREACH_PROC_IN_SYSTEM(p) {
PROC_LOCK(p);
if (p->p_state == PRS_NEW) {
PROC_UNLOCK(p);
continue;
}
FOREACH_THREAD_IN_PROC(p, td) {
thread_lock(td);
if (TD_ON_LOCK(td)) {
/*
* The thread should be blocked on a
* turnstile, simply check if the
* turnstile channel is in good state.
*/
MPASS(td->td_blocked != NULL); MPASS(td->td_blocked != NULL);
tticks = ticks - td->td_blktick; tticks = ticks - td->td_blktick;
thread_unlock(td); if (tticks > blkticks)
if (tticks > blkticks) {
/* /*
* Accordingly with provided * Accordingly with provided thresholds, this thread is stuck
* thresholds, this thread is * for too long on a turnstile.
* stuck for too long on a
* turnstile.
*/ */
PROC_UNLOCK(p); panic("%s: possible deadlock detected for %p, "
sx_sunlock(&allproc_lock); "blocked for %d ticks\n", __func__, td, tticks);
panic("%s: possible deadlock detected for %p, blocked for %d ticks\n",
__func__, td, tticks);
} }
} else if (TD_IS_SLEEPING(td) &&
TD_ON_SLEEPQ(td)) {
static void
deadlres_td_sleep_q(struct proc *p, struct thread *td, int slpticks)
{
void *wchan;
int i, slptype, tticks;
sx_assert(&allproc_lock, SX_LOCKED);
PROC_LOCK_ASSERT(p, MA_OWNED);
THREAD_LOCK_ASSERT(td, MA_OWNED);
/* /*
* Check if the thread is sleeping on a * Check if the thread is sleeping on a lock, otherwise skip the check.
* lock, otherwise skip the check. * Drop the thread lock in order to avoid a LOR with the sleepqueue
* Drop the thread lock in order to
* avoid a LOR with the sleepqueue
* spinlock. * spinlock.
*/ */
wchan = td->td_wchan; wchan = td->td_wchan;
tticks = ticks - td->td_slptick; tticks = ticks - td->td_slptick;
thread_unlock(td);
slptype = sleepq_type(wchan); slptype = sleepq_type(wchan);
if ((slptype == SLEEPQ_SX || if ((slptype == SLEEPQ_SX || slptype == SLEEPQ_LK) &&
slptype == SLEEPQ_LK) &&
tticks > slpticks) { tticks > slpticks) {
/* /*
* Accordingly with provided * Accordingly with provided thresholds, this thread is stuck
* thresholds, this thread is * for too long on a sleepqueue.
* stuck for too long on a * However, being on a sleepqueue, we might still check for the
* sleepqueue. * blessed list.
* However, being on a
* sleepqueue, we might still
* check for the blessed
* list.
*/ */
tryl = 0; for (i = 0; blessed[i] != NULL; i++)
for (i = 0; blessed[i] != NULL; if (!strcmp(blessed[i], td->td_wmesg))
i++) { return;
if (!strcmp(blessed[i],
td->td_wmesg)) { panic("%s: possible deadlock detected for %p, "
tryl = 1; "blocked for %d ticks\n", __func__, td, tticks);
break;
} }
} }
if (tryl != 0) {
static void
deadlkres(void)
{
struct proc *p;
struct thread *td;
int blkticks, slpticks, tryl;
tryl = 0; tryl = 0;
for (;;) {
blkticks = blktime_threshold * hz;
slpticks = slptime_threshold * hz;
/*
* Avoid to sleep on the sx_lock in order to avoid a
* possible priority inversion problem leading to
* starvation.
* If the lock can't be held after 100 tries, panic.
*/
if (!sx_try_slock(&allproc_lock)) {
if (tryl > 100)
panic("%s: possible deadlock detected "
"on allproc_lock\n", __func__);
tryl++;
pause("allproc", sleepfreq * hz);
continue; continue;
} }
tryl = 0;
FOREACH_PROC_IN_SYSTEM(p) {
PROC_LOCK(p);
if (p->p_state == PRS_NEW) {
PROC_UNLOCK(p); PROC_UNLOCK(p);
sx_sunlock(&allproc_lock); continue;
panic("%s: possible deadlock detected for %p, blocked for %d ticks\n",
__func__, td, tticks);
} }
} else FOREACH_THREAD_IN_PROC(p, td) {
thread_lock(td);
if (TD_ON_LOCK(td))
deadlres_td_on_lock(p, td,
blkticks);
else if (TD_IS_SLEEPING(td) &&
TD_ON_SLEEPQ(td))
deadlres_td_sleep_q(p, td,
slpticks);
thread_unlock(td); thread_unlock(td);
} }
PROC_UNLOCK(p); PROC_UNLOCK(p);
} }
sx_sunlock(&allproc_lock); sx_sunlock(&allproc_lock);
/* Sleep for sleepfreq seconds. */ /* Sleep for sleepfreq seconds. */
pause("-", sleepfreq * hz); pause("-", sleepfreq * hz);
} }
▲ Show 20 Lines • Show All 599 Lines • Show Last 20 Lines
View Options

sys/contrib/openzfs/module/os/freebsd/zfs/zfs_ctldir.c

Show First 20 Lines • Show All 179 Lines • ▼ Show 20 Linesstatic const char *blessed[] = {
"so_rcv_sx", "so_rcv_sx",
NULL NULL
}; };
static int slptime_threshold = 1800; static int slptime_threshold = 1800;
static int blktime_threshold = 900; static int blktime_threshold = 900;
static int sleepfreq = 3; static int sleepfreq = 3;
static void static void
deadlkres(void) deadlres_td_on_lock(struct proc *p, struct thread *td, int blkticks)
{ {
struct proc *p; int tticks;
struct thread *td;
void *wchan;
int blkticks, i, slpticks, slptype, tryl, tticks;
tryl = 0; sx_assert(&allproc_lock, SX_LOCKED);
for (;;) { PROC_LOCK_ASSERT(p, MA_OWNED);
blkticks = blktime_threshold * hz; THREAD_LOCK_ASSERT(td, MA_OWNED);
slpticks = slptime_threshold * hz;
/* /*
* Avoid to sleep on the sx_lock in order to avoid a possible * The thread should be blocked on a turnstile, simply check
* priority inversion problem leading to starvation. * if the turnstile channel is in good state.
* If the lock can't be held after 100 tries, panic.
*/ */
if (!sx_try_slock(&allproc_lock)) {
if (tryl > 100)
panic("%s: possible deadlock detected on allproc_lock\n",
__func__);
tryl++;
pause("allproc", sleepfreq * hz);
continue;
}
tryl = 0;
FOREACH_PROC_IN_SYSTEM(p) {
PROC_LOCK(p);
if (p->p_state == PRS_NEW) {
PROC_UNLOCK(p);
continue;
}
FOREACH_THREAD_IN_PROC(p, td) {
thread_lock(td);
if (TD_ON_LOCK(td)) {
/*
* The thread should be blocked on a
* turnstile, simply check if the
* turnstile channel is in good state.
*/
MPASS(td->td_blocked != NULL); MPASS(td->td_blocked != NULL);
tticks = ticks - td->td_blktick; tticks = ticks - td->td_blktick;
thread_unlock(td); if (tticks > blkticks)
if (tticks > blkticks) {
/* /*
* Accordingly with provided * Accordingly with provided thresholds, this thread is stuck
* thresholds, this thread is * for too long on a turnstile.
* stuck for too long on a
* turnstile.
*/ */
PROC_UNLOCK(p); panic("%s: possible deadlock detected for %p, "
sx_sunlock(&allproc_lock); "blocked for %d ticks\n", __func__, td, tticks);
panic("%s: possible deadlock detected for %p, blocked for %d ticks\n",
__func__, td, tticks);
} }
} else if (TD_IS_SLEEPING(td) &&
TD_ON_SLEEPQ(td)) {
static void
deadlres_td_sleep_q(struct proc *p, struct thread *td, int slpticks)
{
void *wchan;
int i, slptype, tticks;
sx_assert(&allproc_lock, SX_LOCKED);
PROC_LOCK_ASSERT(p, MA_OWNED);
THREAD_LOCK_ASSERT(td, MA_OWNED);
/* /*
* Check if the thread is sleeping on a * Check if the thread is sleeping on a lock, otherwise skip the check.
* lock, otherwise skip the check. * Drop the thread lock in order to avoid a LOR with the sleepqueue
* Drop the thread lock in order to
* avoid a LOR with the sleepqueue
* spinlock. * spinlock.
*/ */
wchan = td->td_wchan; wchan = td->td_wchan;
tticks = ticks - td->td_slptick; tticks = ticks - td->td_slptick;
thread_unlock(td);
slptype = sleepq_type(wchan); slptype = sleepq_type(wchan);
if ((slptype == SLEEPQ_SX || if ((slptype == SLEEPQ_SX || slptype == SLEEPQ_LK) &&
slptype == SLEEPQ_LK) &&
tticks > slpticks) { tticks > slpticks) {
/* /*
* Accordingly with provided * Accordingly with provided thresholds, this thread is stuck
* thresholds, this thread is * for too long on a sleepqueue.
* stuck for too long on a * However, being on a sleepqueue, we might still check for the
* sleepqueue. * blessed list.
* However, being on a
* sleepqueue, we might still
* check for the blessed
* list.
*/ */
tryl = 0; for (i = 0; blessed[i] != NULL; i++)
for (i = 0; blessed[i] != NULL; if (!strcmp(blessed[i], td->td_wmesg))
i++) { return;
if (!strcmp(blessed[i],
td->td_wmesg)) { panic("%s: possible deadlock detected for %p, "
tryl = 1; "blocked for %d ticks\n", __func__, td, tticks);
break;
} }
} }
if (tryl != 0) {
static void
deadlkres(void)
{
struct proc *p;
struct thread *td;
int blkticks, slpticks, tryl;
tryl = 0; tryl = 0;
for (;;) {
blkticks = blktime_threshold * hz;
slpticks = slptime_threshold * hz;
/*
* Avoid to sleep on the sx_lock in order to avoid a
* possible priority inversion problem leading to
* starvation.
* If the lock can't be held after 100 tries, panic.
*/
if (!sx_try_slock(&allproc_lock)) {
if (tryl > 100)
panic("%s: possible deadlock detected "
"on allproc_lock\n", __func__);
tryl++;
pause("allproc", sleepfreq * hz);
continue; continue;
} }
tryl = 0;
FOREACH_PROC_IN_SYSTEM(p) {
PROC_LOCK(p);
if (p->p_state == PRS_NEW) {
PROC_UNLOCK(p); PROC_UNLOCK(p);
sx_sunlock(&allproc_lock); continue;
panic("%s: possible deadlock detected for %p, blocked for %d ticks\n",
__func__, td, tticks);
} }
} else FOREACH_THREAD_IN_PROC(p, td) {
thread_lock(td);
if (TD_ON_LOCK(td))
deadlres_td_on_lock(p, td,
blkticks);
else if (TD_IS_SLEEPING(td) &&
TD_ON_SLEEPQ(td))
deadlres_td_sleep_q(p, td,
slpticks);
thread_unlock(td); thread_unlock(td);
} }
PROC_UNLOCK(p); PROC_UNLOCK(p);
} }
sx_sunlock(&allproc_lock); sx_sunlock(&allproc_lock);
/* Sleep for sleepfreq seconds. */ /* Sleep for sleepfreq seconds. */
pause("-", sleepfreq * hz); pause("-", sleepfreq * hz);
} }
▲ Show 20 Lines • Show All 599 Lines • Show Last 20 Lines