Page MenuHomeFreeBSD
Differential D21079

elfcopy: Stop using optind.
ClosedPublic
Actions

Authored by markj on Jul 26 2019, 7:11 PM.
Tags
None
Referenced Files
Unknown Object (File)
Sat, Mar 8, 3:40 AM
Unknown Object (File)
Fri, Feb 21, 3:03 PM
Unknown Object (File)
Jan 29 2025, 5:37 PM
Unknown Object (File)
Jan 17 2025, 10:05 AM
Unknown Object (File)
Jan 10 2025, 6:33 PM
Unknown Object (File)
Jan 10 2025, 6:32 PM
Unknown Object (File)
Jan 10 2025, 6:32 PM
Unknown Object (File)
Jan 10 2025, 4:02 PM
View All 73 Files
Subscribers
imp
jkoshy_users.sourceforge.net

Details

Reviewers
emaste
Commits
rS350679: Merge r3780 from elftoolchain.
Summary

This marginally simplifies the code. Writing argc--; argv++; after the
option parsing loop is a common idiom anyway.

Diff Detail

Repository
rS FreeBSD src repository - subversion
Lint
Lint Not Applicable
Unit
Tests Not Applicable

Revision Contents
Changeset List

PathSize
head/
contrib/
elftoolchain/
elfcopy/
27 lines

Diff 60547

View Options

head/contrib/elftoolchain/elfcopy/main.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