d/freebsd-dev
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Initialize native priority to PRI_MAX. It was usually 0 which made a

Browse Source 
process's priority go through the roof when it released a (contested)
mutex.  Only set the native priority in mtx_lock if hasn't already
been set.

Reviewed by:	jhb
This commit is contained in:
jake 2001-02-26 23:27:35 +00:00
parent 1e08bdb027
commit 6accca97f7
5 changed files with 8 additions and 33 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
sys/kern/init_main.c
View File

@ -306,6 +306,7 @@ proc0_init(void *dummy __unused)
p->p_nice = NZERO;
p->p_pri.pri_class = PRI_TIMESHARE;
p->p_pri.pri_level = PVM;
p->p_pri.pri_native = PRI_MAX;
p->p_pri.pri_user = PUSER;
p->p_peers = 0;

1
sys/kern/kern_fork.c
View File

@ -357,6 +357,7 @@ fork1(p1, flags, procp)
p2 = newproc;
p2->p_intr_nesting_level = 0;
p2->p_pri.pri_native = PRI_MAX;
p2->p_stat = SIDL; /* protect against others */
p2->p_pid = trypid;
LIST_INSERT_HEAD(&allproc, p2, p_list);

13
sys/kern/kern_mutex.c
View File

@ -339,17 +339,6 @@ _mtx_lock_sleep(struct mtx *m, int opts, const char *file, int line)
"_mtx_lock_sleep: %s contested (lock=%p) at %s:%d",
m->mtx_description, (void *)m->mtx_lock, file, line);
/*
* Save our priority. Even though p_nativepri is protected by
* sched_lock, we don't obtain it here as it can be expensive.
* Since this is the only place p_nativepri is set, and since two
* CPUs will not be executing the same process concurrently, we know
* that no other CPU is going to be messing with this. Also,
* p_nativepri is only read when we are blocked on a mutex, so that
* can't be happening right now either.
*/
p->p_pri.pri_native = p->p_pri.pri_level;
while (!_obtain_lock(m, p)) {
uintptr_t v;
struct proc *p1;
@ -437,6 +426,8 @@ _mtx_lock_sleep(struct mtx *m, int opts, const char *file, int line)
p->p_blocked = m;
p->p_mtxname = m->mtx_description;
p->p_stat = SMTX;
if (p->p_pri.pri_native == PRI_MAX)
p->p_pri.pri_native = p->p_pri.pri_level;
propagate_priority(p);
if ((opts & MTX_QUIET) == 0)

13
sys/kern/subr_turnstile.c
View File

@ -339,17 +339,6 @@ _mtx_lock_sleep(struct mtx *m, int opts, const char *file, int line)
"_mtx_lock_sleep: %s contested (lock=%p) at %s:%d",
m->mtx_description, (void *)m->mtx_lock, file, line);
/*
* Save our priority. Even though p_nativepri is protected by
* sched_lock, we don't obtain it here as it can be expensive.
* Since this is the only place p_nativepri is set, and since two
* CPUs will not be executing the same process concurrently, we know
* that no other CPU is going to be messing with this. Also,
* p_nativepri is only read when we are blocked on a mutex, so that
* can't be happening right now either.
*/
p->p_pri.pri_native = p->p_pri.pri_level;
while (!_obtain_lock(m, p)) {
uintptr_t v;
struct proc *p1;
@ -437,6 +426,8 @@ _mtx_lock_sleep(struct mtx *m, int opts, const char *file, int line)
p->p_blocked = m;
p->p_mtxname = m->mtx_description;
p->p_stat = SMTX;
if (p->p_pri.pri_native == PRI_MAX)
p->p_pri.pri_native = p->p_pri.pri_level;
propagate_priority(p);
if ((opts & MTX_QUIET) == 0)

13
sys/kern/subr_witness.c
View File

@ -339,17 +339,6 @@ _mtx_lock_sleep(struct mtx *m, int opts, const char *file, int line)
"_mtx_lock_sleep: %s contested (lock=%p) at %s:%d",
m->mtx_description, (void *)m->mtx_lock, file, line);
/*
* Save our priority. Even though p_nativepri is protected by
* sched_lock, we don't obtain it here as it can be expensive.
* Since this is the only place p_nativepri is set, and since two
* CPUs will not be executing the same process concurrently, we know
* that no other CPU is going to be messing with this. Also,
* p_nativepri is only read when we are blocked on a mutex, so that
* can't be happening right now either.
*/
p->p_pri.pri_native = p->p_pri.pri_level;
while (!_obtain_lock(m, p)) {
uintptr_t v;
struct proc *p1;
@ -437,6 +426,8 @@ _mtx_lock_sleep(struct mtx *m, int opts, const char *file, int line)
p->p_blocked = m;
p->p_mtxname = m->mtx_description;
p->p_stat = SMTX;
if (p->p_pri.pri_native == PRI_MAX)
p->p_pri.pri_native = p->p_pri.pri_level;
propagate_priority(p);
if ((opts & MTX_QUIET) == 0)