Change the process flags P_KSES to be P_THREADED.
This is just a cosmetic change but I've been meaning to do it for about a year.
This commit is contained in:
parent
7d33ae9677
commit
ac2e415327
Notes:
svn2git
2020-12-20 02:59:44 +00:00
svn path=/head/; revision=111585
@ -126,7 +126,7 @@ kvm_proclist(kd, what, arg, p, bp, maxcnt)
|
||||
TAILQ_FIRST(&proc.p_threads));
|
||||
return (-1);
|
||||
}
|
||||
if (proc.p_flag & P_KSES == 0) {
|
||||
if (proc.p_flag & P_THREADED == 0) {
|
||||
if (KREAD(kd,
|
||||
(u_long)TAILQ_FIRST(&proc.p_ksegrps),
|
||||
&mkg)) {
|
||||
@ -364,7 +364,7 @@ kvm_proclist(kd, what, arg, p, bp, maxcnt)
|
||||
kp->ki_lastcpu = mtd.td_lastcpu;
|
||||
kp->ki_wchan = mtd.td_wchan;
|
||||
|
||||
if (!(proc.p_flag & P_KSES)) {
|
||||
if (!(proc.p_flag & P_THREADED)) {
|
||||
/* stuff from the ksegrp */
|
||||
kp->ki_slptime = mkg.kg_slptime;
|
||||
kp->ki_pri.pri_class = mkg.kg_pri_class;
|
||||
|
@ -663,7 +663,7 @@ syscall(code, framep)
|
||||
sticks = td->td_sticks;
|
||||
if (td->td_ucred != p->p_ucred)
|
||||
cred_update_thread(td);
|
||||
if (p->p_flag & P_KSES)
|
||||
if (p->p_flag & P_THREADED)
|
||||
thread_user_enter(p, td);
|
||||
#ifdef DIAGNOSTIC
|
||||
alpha_fpstate_check(td);
|
||||
|
@ -3381,7 +3381,7 @@ pmap_activate(struct thread *td)
|
||||
/* XXXKSE this is wrong.
|
||||
* pmap_activate is for the current thread on the current cpu
|
||||
*/
|
||||
if (p->p_flag & P_KSES) {
|
||||
if (p->p_flag & P_THREADED) {
|
||||
/* Make sure all other cr3 entries are updated. */
|
||||
/* what if they are running? XXXKSE (maybe abort them) */
|
||||
FOREACH_THREAD_IN_PROC(p, td) {
|
||||
|
@ -129,7 +129,7 @@ i386_extend_pcb(struct thread *td)
|
||||
0 /* granularity */
|
||||
};
|
||||
|
||||
if (td->td_proc->p_flag & P_KSES)
|
||||
if (td->td_proc->p_flag & P_THREADED)
|
||||
return (EINVAL); /* XXXKSE */
|
||||
/* XXXKSE All the code below only works in 1:1 needs changing */
|
||||
ext = (struct pcb_ext *)kmem_alloc(kernel_map, ctob(IOPAGES+1));
|
||||
|
@ -958,7 +958,7 @@ syscall(frame)
|
||||
td->td_frame = &frame;
|
||||
if (td->td_ucred != p->p_ucred)
|
||||
cred_update_thread(td);
|
||||
if (p->p_flag & P_KSES)
|
||||
if (p->p_flag & P_THREADED)
|
||||
thread_user_enter(p, td);
|
||||
params = (caddr_t)frame.tf_esp + sizeof(int);
|
||||
code = frame.tf_eax;
|
||||
|
@ -125,7 +125,7 @@ db_ps(dummy1, dummy2, dummy3, dummy4)
|
||||
p->p_ucred != NULL ? p->p_ucred->cr_ruid : 0, pp->p_pid,
|
||||
p->p_pgrp != NULL ? p->p_pgrp->pg_id : 0, p->p_flag,
|
||||
state);
|
||||
if (p->p_flag & P_KSES)
|
||||
if (p->p_flag & P_THREADED)
|
||||
db_printf("(threaded) %s\n", p->p_comm);
|
||||
FOREACH_THREAD_IN_PROC(p, td) {
|
||||
dumpthread(p, td);
|
||||
@ -141,7 +141,7 @@ db_ps(dummy1, dummy2, dummy3, dummy4)
|
||||
static void
|
||||
dumpthread(volatile struct proc *p, volatile struct thread *td)
|
||||
{
|
||||
if (p->p_flag & P_KSES)
|
||||
if (p->p_flag & P_THREADED)
|
||||
db_printf( " thread %p ksegrp %p ", td, td->td_ksegrp);
|
||||
if (TD_ON_SLEEPQ(td)) {
|
||||
if (td->td_flags & TDF_CVWAITQ)
|
||||
@ -183,7 +183,7 @@ dumpthread(volatile struct proc *p, volatile struct thread *td)
|
||||
default:
|
||||
panic("unknown thread state");
|
||||
}
|
||||
if (p->p_flag & P_KSES) {
|
||||
if (p->p_flag & P_THREADED) {
|
||||
if (td->td_kse)
|
||||
db_printf("[kse %p]", td->td_kse);
|
||||
db_printf("\n");
|
||||
|
@ -130,7 +130,7 @@ procfs_doprocstatus(PFS_FILL_ARGS)
|
||||
sbuf_printf(sb, " -1,-1 -1,-1 -1,-1");
|
||||
}
|
||||
|
||||
if (p->p_flag & P_KSES)
|
||||
if (p->p_flag & P_THREADED)
|
||||
sbuf_printf(sb, " %s", "-kse- ");
|
||||
else {
|
||||
tdfirst = FIRST_THREAD_IN_PROC(p); /* XXX diff from td? */
|
||||
|
@ -3381,7 +3381,7 @@ pmap_activate(struct thread *td)
|
||||
/* XXXKSE this is wrong.
|
||||
* pmap_activate is for the current thread on the current cpu
|
||||
*/
|
||||
if (p->p_flag & P_KSES) {
|
||||
if (p->p_flag & P_THREADED) {
|
||||
/* Make sure all other cr3 entries are updated. */
|
||||
/* what if they are running? XXXKSE (maybe abort them) */
|
||||
FOREACH_THREAD_IN_PROC(p, td) {
|
||||
|
@ -129,7 +129,7 @@ i386_extend_pcb(struct thread *td)
|
||||
0 /* granularity */
|
||||
};
|
||||
|
||||
if (td->td_proc->p_flag & P_KSES)
|
||||
if (td->td_proc->p_flag & P_THREADED)
|
||||
return (EINVAL); /* XXXKSE */
|
||||
/* XXXKSE All the code below only works in 1:1 needs changing */
|
||||
ext = (struct pcb_ext *)kmem_alloc(kernel_map, ctob(IOPAGES+1));
|
||||
|
@ -958,7 +958,7 @@ syscall(frame)
|
||||
td->td_frame = &frame;
|
||||
if (td->td_ucred != p->p_ucred)
|
||||
cred_update_thread(td);
|
||||
if (p->p_flag & P_KSES)
|
||||
if (p->p_flag & P_THREADED)
|
||||
thread_user_enter(p, td);
|
||||
params = (caddr_t)frame.tf_esp + sizeof(int);
|
||||
code = frame.tf_eax;
|
||||
|
@ -808,7 +808,7 @@ syscall(int code, u_int64_t *args, struct trapframe *framep)
|
||||
framep->tf_cr_iip += 16;
|
||||
}
|
||||
|
||||
if (p->p_flag & P_KSES)
|
||||
if (p->p_flag & P_THREADED)
|
||||
thread_user_enter(p, td);
|
||||
#ifdef DIAGNOSTIC
|
||||
ia64_fpstate_check(td);
|
||||
|
@ -166,7 +166,7 @@ hardclock_process(frame)
|
||||
* Run current process's virtual and profile time, as needed.
|
||||
*/
|
||||
mtx_lock_spin_flags(&sched_lock, MTX_QUIET);
|
||||
if (p->p_flag & P_KSES) {
|
||||
if (p->p_flag & P_THREADED) {
|
||||
/* XXXKSE What to do? */
|
||||
} else {
|
||||
pstats = p->p_stats;
|
||||
@ -374,7 +374,7 @@ statclock(frame)
|
||||
/*
|
||||
* Charge the time as appropriate.
|
||||
*/
|
||||
if (p->p_flag & P_KSES)
|
||||
if (p->p_flag & P_THREADED)
|
||||
thread_statclock(1);
|
||||
p->p_uticks++;
|
||||
if (ke->ke_ksegrp->kg_nice > NZERO)
|
||||
@ -398,7 +398,7 @@ statclock(frame)
|
||||
p->p_iticks++;
|
||||
cp_time[CP_INTR]++;
|
||||
} else {
|
||||
if (p->p_flag & P_KSES)
|
||||
if (p->p_flag & P_THREADED)
|
||||
thread_statclock(0);
|
||||
td->td_sticks++;
|
||||
p->p_sticks++;
|
||||
|
@ -200,7 +200,7 @@ kern_execve(td, fname, argv, envv, mac_p)
|
||||
PROC_LOCK(p);
|
||||
KASSERT((p->p_flag & P_INEXEC) == 0,
|
||||
("%s(): process already has P_INEXEC flag", __func__));
|
||||
if (p->p_flag & P_KSES) {
|
||||
if (p->p_flag & P_THREADED) {
|
||||
if (thread_single(SINGLE_EXIT)) {
|
||||
PROC_UNLOCK(p);
|
||||
return (ERESTART); /* Try again later. */
|
||||
@ -209,7 +209,7 @@ kern_execve(td, fname, argv, envv, mac_p)
|
||||
* If we get here all other threads are dead,
|
||||
* so unset the associated flags and lose KSE mode.
|
||||
*/
|
||||
p->p_flag &= ~P_KSES;
|
||||
p->p_flag &= ~P_THREADED;
|
||||
td->td_mailbox = NULL;
|
||||
thread_single_end();
|
||||
}
|
||||
|
@ -150,7 +150,7 @@ exit1(td, rv)
|
||||
* XXXKSE: MUST abort all other threads before proceeding past here.
|
||||
*/
|
||||
PROC_LOCK(p);
|
||||
if (p->p_flag & P_KSES) {
|
||||
if (p->p_flag & P_THREADED) {
|
||||
/*
|
||||
* First check if some other thread got here before us..
|
||||
* if so, act apropriatly, (exit or suspend);
|
||||
@ -180,7 +180,7 @@ exit1(td, rv)
|
||||
* ...
|
||||
* Turn off threading support.
|
||||
*/
|
||||
p->p_flag &= ~P_KSES;
|
||||
p->p_flag &= ~P_THREADED;
|
||||
thread_single_end(); /* Don't need this any more. */
|
||||
}
|
||||
/*
|
||||
|
@ -289,7 +289,7 @@ fork1(td, flags, pages, procp)
|
||||
return (0);
|
||||
}
|
||||
|
||||
if (p1->p_flag & P_KSES) {
|
||||
if (p1->p_flag & P_THREADED) {
|
||||
/*
|
||||
* Idle the other threads for a second.
|
||||
* Since the user space is copied, it must remain stable.
|
||||
@ -744,7 +744,7 @@ fork1(td, flags, pages, procp)
|
||||
/*
|
||||
* If other threads are waiting, let them continue now
|
||||
*/
|
||||
if (p1->p_flag & P_KSES) {
|
||||
if (p1->p_flag & P_THREADED) {
|
||||
PROC_LOCK(p1);
|
||||
thread_single_end();
|
||||
PROC_UNLOCK(p1);
|
||||
@ -758,7 +758,7 @@ fork1(td, flags, pages, procp)
|
||||
fail:
|
||||
sx_xunlock(&allproc_lock);
|
||||
uma_zfree(proc_zone, newproc);
|
||||
if (p1->p_flag & P_KSES) {
|
||||
if (p1->p_flag & P_THREADED) {
|
||||
PROC_LOCK(p1);
|
||||
thread_single_end();
|
||||
PROC_UNLOCK(p1);
|
||||
|
@ -390,7 +390,7 @@ kse_thr_interrupt(struct thread *td, struct kse_thr_interrupt_args *uap)
|
||||
struct thread *td2;
|
||||
|
||||
p = td->td_proc;
|
||||
if (!(p->p_flag & P_KSES) || (uap->tmbx == NULL))
|
||||
if (!(p->p_flag & P_THREADED) || (uap->tmbx == NULL))
|
||||
return (EINVAL);
|
||||
mtx_lock_spin(&sched_lock);
|
||||
FOREACH_THREAD_IN_PROC(p, td2) {
|
||||
@ -444,7 +444,7 @@ kse_exit(struct thread *td, struct kse_exit_args *uap)
|
||||
upcall_remove(td);
|
||||
if (p->p_numthreads == 1) {
|
||||
kse_purge(p, td);
|
||||
p->p_flag &= ~P_KSES;
|
||||
p->p_flag &= ~P_THREADED;
|
||||
mtx_unlock_spin(&sched_lock);
|
||||
PROC_UNLOCK(p);
|
||||
} else {
|
||||
@ -535,7 +535,7 @@ kse_wakeup(struct thread *td, struct kse_wakeup_args *uap)
|
||||
td2 = NULL;
|
||||
ku = NULL;
|
||||
/* KSE-enabled processes only, please. */
|
||||
if (!(p->p_flag & P_KSES))
|
||||
if (!(p->p_flag & P_THREADED))
|
||||
return (EINVAL);
|
||||
PROC_LOCK(p);
|
||||
mtx_lock_spin(&sched_lock);
|
||||
@ -609,7 +609,7 @@ kse_create(struct thread *td, struct kse_create_args *uap)
|
||||
ncpus = virtual_cpu;
|
||||
|
||||
/* Easier to just set it than to test and set */
|
||||
p->p_flag |= P_KSES;
|
||||
p->p_flag |= P_THREADED;
|
||||
kg = td->td_ksegrp;
|
||||
if (uap->newgroup) {
|
||||
/* Have race condition but it is cheap */
|
||||
@ -1778,7 +1778,7 @@ thread_single(int force_exit)
|
||||
PROC_LOCK_ASSERT(p, MA_OWNED);
|
||||
KASSERT((td != NULL), ("curthread is NULL"));
|
||||
|
||||
if ((p->p_flag & P_KSES) == 0)
|
||||
if ((p->p_flag & P_THREADED) == 0)
|
||||
return (0);
|
||||
|
||||
/* Is someone already single threading? */
|
||||
|
@ -681,7 +681,7 @@ fill_kinfo_proc(p, kp)
|
||||
mtx_unlock_spin(&sched_lock);
|
||||
return;
|
||||
}
|
||||
if (!(p->p_flag & P_KSES)) {
|
||||
if (!(p->p_flag & P_THREADED)) {
|
||||
if (td->td_wmesg != NULL) {
|
||||
strlcpy(kp->ki_wmesg, td->td_wmesg,
|
||||
sizeof(kp->ki_wmesg));
|
||||
@ -715,7 +715,7 @@ fill_kinfo_proc(p, kp)
|
||||
kp->ki_swtime = p->p_swtime;
|
||||
kp->ki_pid = p->p_pid;
|
||||
/* vvv XXXKSE */
|
||||
if (!(p->p_flag & P_KSES)) {
|
||||
if (!(p->p_flag & P_THREADED)) {
|
||||
kg = td->td_ksegrp;
|
||||
ke = td->td_kse;
|
||||
KASSERT((ke != NULL), ("fill_kinfo_proc: Null KSE"));
|
||||
|
@ -1902,7 +1902,7 @@ postsig(sig)
|
||||
p->p_code = 0;
|
||||
p->p_sig = 0;
|
||||
}
|
||||
if (p->p_flag & P_KSES)
|
||||
if (p->p_flag & P_THREADED)
|
||||
thread_signal_add(curthread, sig);
|
||||
else
|
||||
(*p->p_sysent->sv_sendsig)(action, sig,
|
||||
|
@ -127,7 +127,7 @@ choosethread(void)
|
||||
td = ke->ke_thread;
|
||||
KASSERT((td->td_kse == ke), ("kse/thread mismatch"));
|
||||
kg = ke->ke_ksegrp;
|
||||
if (td->td_proc->p_flag & P_KSES) {
|
||||
if (td->td_proc->p_flag & P_THREADED) {
|
||||
TAILQ_REMOVE(&kg->kg_runq, td, td_runq);
|
||||
if (kg->kg_last_assigned == td) {
|
||||
kg->kg_last_assigned = TAILQ_PREV(td,
|
||||
@ -255,7 +255,7 @@ remrunqueue(struct thread *td)
|
||||
/*
|
||||
* If it is not a threaded process, take the shortcut.
|
||||
*/
|
||||
if ((td->td_proc->p_flag & P_KSES) == 0) {
|
||||
if ((td->td_proc->p_flag & P_THREADED) == 0) {
|
||||
/* Bring its kse with it, leave the thread attached */
|
||||
sched_rem(ke);
|
||||
ke->ke_state = KES_THREAD;
|
||||
@ -298,7 +298,7 @@ adjustrunqueue( struct thread *td, int newpri)
|
||||
/*
|
||||
* If it is not a threaded process, take the shortcut.
|
||||
*/
|
||||
if ((td->td_proc->p_flag & P_KSES) == 0) {
|
||||
if ((td->td_proc->p_flag & P_THREADED) == 0) {
|
||||
/* We only care about the kse in the run queue. */
|
||||
td->td_priority = newpri;
|
||||
if (ke->ke_rqindex != (newpri / RQ_PPQ)) {
|
||||
@ -339,7 +339,7 @@ setrunqueue(struct thread *td)
|
||||
TD_SET_RUNQ(td);
|
||||
kg = td->td_ksegrp;
|
||||
kg->kg_runnable++;
|
||||
if ((td->td_proc->p_flag & P_KSES) == 0) {
|
||||
if ((td->td_proc->p_flag & P_THREADED) == 0) {
|
||||
/*
|
||||
* Common path optimisation: Only one of everything
|
||||
* and the KSE is always already attached.
|
||||
@ -659,7 +659,7 @@ thread_sanity_check(struct thread *td, char *string)
|
||||
}
|
||||
}
|
||||
|
||||
if ((p->p_flag & P_KSES) == 0) {
|
||||
if ((p->p_flag & P_THREADED) == 0) {
|
||||
if (ke == NULL) {
|
||||
panc(string, "non KSE thread lost kse");
|
||||
}
|
||||
|
@ -160,7 +160,7 @@ msleep(ident, mtx, priority, wmesg, timo)
|
||||
* the thread (recursion here might be bad).
|
||||
* Hence the TDF_INMSLEEP flag.
|
||||
*/
|
||||
if (p->p_flag & P_KSES) {
|
||||
if (p->p_flag & P_THREADED) {
|
||||
/*
|
||||
* Just don't bother if we are exiting
|
||||
* and not the exiting thread or thread was marked as
|
||||
|
@ -390,7 +390,7 @@ kse_thr_interrupt(struct thread *td, struct kse_thr_interrupt_args *uap)
|
||||
struct thread *td2;
|
||||
|
||||
p = td->td_proc;
|
||||
if (!(p->p_flag & P_KSES) || (uap->tmbx == NULL))
|
||||
if (!(p->p_flag & P_THREADED) || (uap->tmbx == NULL))
|
||||
return (EINVAL);
|
||||
mtx_lock_spin(&sched_lock);
|
||||
FOREACH_THREAD_IN_PROC(p, td2) {
|
||||
@ -444,7 +444,7 @@ kse_exit(struct thread *td, struct kse_exit_args *uap)
|
||||
upcall_remove(td);
|
||||
if (p->p_numthreads == 1) {
|
||||
kse_purge(p, td);
|
||||
p->p_flag &= ~P_KSES;
|
||||
p->p_flag &= ~P_THREADED;
|
||||
mtx_unlock_spin(&sched_lock);
|
||||
PROC_UNLOCK(p);
|
||||
} else {
|
||||
@ -535,7 +535,7 @@ kse_wakeup(struct thread *td, struct kse_wakeup_args *uap)
|
||||
td2 = NULL;
|
||||
ku = NULL;
|
||||
/* KSE-enabled processes only, please. */
|
||||
if (!(p->p_flag & P_KSES))
|
||||
if (!(p->p_flag & P_THREADED))
|
||||
return (EINVAL);
|
||||
PROC_LOCK(p);
|
||||
mtx_lock_spin(&sched_lock);
|
||||
@ -609,7 +609,7 @@ kse_create(struct thread *td, struct kse_create_args *uap)
|
||||
ncpus = virtual_cpu;
|
||||
|
||||
/* Easier to just set it than to test and set */
|
||||
p->p_flag |= P_KSES;
|
||||
p->p_flag |= P_THREADED;
|
||||
kg = td->td_ksegrp;
|
||||
if (uap->newgroup) {
|
||||
/* Have race condition but it is cheap */
|
||||
@ -1778,7 +1778,7 @@ thread_single(int force_exit)
|
||||
PROC_LOCK_ASSERT(p, MA_OWNED);
|
||||
KASSERT((td != NULL), ("curthread is NULL"));
|
||||
|
||||
if ((p->p_flag & P_KSES) == 0)
|
||||
if ((p->p_flag & P_THREADED) == 0)
|
||||
return (0);
|
||||
|
||||
/* Is someone already single threading? */
|
||||
|
@ -544,7 +544,7 @@ sched_switchout(struct thread *td)
|
||||
if (TD_IS_RUNNING(td)) {
|
||||
/* Put us back on the run queue (kse and all). */
|
||||
setrunqueue(td);
|
||||
} else if (p->p_flag & P_KSES) {
|
||||
} else if (p->p_flag & P_THREADED) {
|
||||
/*
|
||||
* We will not be on the run queue. So we must be
|
||||
* sleeping or similar. As it's available,
|
||||
|
@ -504,7 +504,7 @@ sched_switchout(struct thread *td)
|
||||
* We will not be on the run queue. So we must be
|
||||
* sleeping or similar.
|
||||
*/
|
||||
if (td->td_proc->p_flag & P_KSES)
|
||||
if (td->td_proc->p_flag & P_THREADED)
|
||||
kse_reassign(ke);
|
||||
}
|
||||
|
||||
|
@ -109,7 +109,7 @@ userret(td, frame, oticks)
|
||||
/*
|
||||
* Do special thread processing, e.g. upcall tweaking and such.
|
||||
*/
|
||||
if (p->p_flag & P_KSES) {
|
||||
if (p->p_flag & P_THREADED) {
|
||||
thread_userret(td, frame);
|
||||
}
|
||||
|
||||
@ -256,7 +256,7 @@ ast(struct trapframe *framep)
|
||||
sigs++;
|
||||
}
|
||||
PROC_UNLOCK(p);
|
||||
if (p->p_flag & P_KSES && sigs)
|
||||
if (p->p_flag & P_THREADED && sigs)
|
||||
thread_signal_upcall(td);
|
||||
}
|
||||
|
||||
|
@ -2407,7 +2407,7 @@ ttyinfo(struct tty *tp)
|
||||
PGRP_UNLOCK(tp->t_pgrp);
|
||||
|
||||
td = FIRST_THREAD_IN_PROC(pick);
|
||||
if (pick->p_flag & P_KSES) {
|
||||
if (pick->p_flag & P_THREADED) {
|
||||
stmp = "KSE" ; /* XXXKSE */
|
||||
} else {
|
||||
if (td) {
|
||||
|
@ -496,7 +496,7 @@ syscall(struct trapframe *tf)
|
||||
td->td_frame = tf;
|
||||
if (td->td_ucred != p->p_ucred)
|
||||
cred_update_thread(td);
|
||||
if (p->p_flag & P_KSES)
|
||||
if (p->p_flag & P_THREADED)
|
||||
thread_user_enter(p, td);
|
||||
code = tf->tf_global[1];
|
||||
|
||||
|
@ -624,7 +624,7 @@ struct proc {
|
||||
#define P_WAITED 0x01000 /* Someone is waiting for us */
|
||||
#define P_WEXIT 0x02000 /* Working on exiting. */
|
||||
#define P_EXEC 0x04000 /* Process called exec. */
|
||||
#define P_KSES 0x08000 /* Process is using KSEs. */
|
||||
#define P_THREADED 0x08000 /* Process is using threads. */
|
||||
#define P_CONTINUED 0x10000 /* Proc has continued from a stopped state. */
|
||||
|
||||
/* flags that control how threads may be suspended for some reason */
|
||||
|
Loading…
Reference in New Issue
Block a user