Move signals into lwps, take p_lwp out of proc.
Originally-Submitted-by: David Xu <davidxu@freebsd.org>
Reviewed-by: Thomas E. Spanjaard <tgen@netphreax.net>
*
* @(#)keyword.c 8.5 (Berkeley) 4/2/94
* $FreeBSD: src/bin/ps/keyword.c,v 1.24.2.3 2002/10/10 20:05:32 jmallett Exp $
- * $DragonFly: src/bin/ps/keyword.c,v 1.25 2007/02/01 10:33:25 corecode Exp $
+ * $DragonFly: src/bin/ps/keyword.c,v 1.26 2007/02/03 17:05:57 corecode Exp $
*/
#include <sys/param.h>
{"ppid", "PPID", NULL, 0, pvar, NULL, PIDLEN, POFF(ppid), UINT, PIDFMT,
NULL},
{"pri", "PRI", NULL, 0, pri, NULL, 3, 0, 0, NULL, NULL},
- {"re", "RE", NULL, 0, lpvar, NULL, 3, LPOFF(swtime), UINT, "d", NULL},
+ {"re", "RE", NULL, 0, lpvar, NULL, 3, POFF(swtime), UINT, "d", NULL},
{"rgid", "RGID", NULL, 0, pvar, NULL, UIDLEN, POFF(rgid),
UINT, UIDFMT, NULL},
#if 0
*
* @(#)print.c 8.6 (Berkeley) 4/16/94
* $FreeBSD: src/bin/ps/print.c,v 1.36.2.4 2002/11/30 13:00:14 tjr Exp $
- * $DragonFly: src/bin/ps/print.c,v 1.26 2007/02/01 10:33:25 corecode Exp $
+ * $DragonFly: src/bin/ps/print.c,v 1.27 2007/02/03 17:05:57 corecode Exp $
*/
#include <sys/param.h>
#define fxtofl(fixpt) ((double)(fixpt) / fscale)
/* XXX - I don't like this */
- if (KI_LWP(k, swtime) == 0 || (KI_PROC(k, flags) & P_SWAPPEDOUT))
+ if (KI_PROC(k, swtime) == 0 || (KI_PROC(k, flags) & P_SWAPPEDOUT))
return (0.0);
if (rawcpu)
return (100.0 * fxtofl(KI_LWP(k, pctcpu)));
return (100.0 * fxtofl(KI_LWP(k, pctcpu)) /
- (1.0 - exp(KI_LWP(k, swtime) * log(fxtofl(ccpu)))));
+ (1.0 - exp(KI_PROC(k, swtime) * log(fxtofl(ccpu)))));
}
void
*
* from: @(#)cpu.h 5.4 (Berkeley) 5/9/91
* $FreeBSD: src/sys/i386/include/cpu.h,v 1.43.2.2 2001/06/15 09:37:57 scottl Exp $
- * $DragonFly: src/sys/cpu/i386/include/cpu.h,v 1.23 2007/01/22 19:37:04 corecode Exp $
+ * $DragonFly: src/sys/cpu/i386/include/cpu.h,v 1.24 2007/02/03 17:05:57 corecode Exp $
*/
#ifndef _CPU_CPU_H_
#define cpu_exec(p) /* nothing */
#define cpu_swapin(p) /* nothing */
-#define cpu_setstack(p, ap) ((p)->p_md.md_regs[SP] = (ap))
+#define cpu_setstack(lp, ap) ((lp)->lwp_md.md_regs[SP] = (ap))
#define CLKF_INTR(framep) (mycpu->gd_intr_nesting_level > 1 || (curthread->td_flags & TDF_INTTHREAD))
#define CLKF_PC(framep) ((framep)->if_eip)
* SUCH DAMAGE.
*
* $FreeBSD: src/sys/ddb/db_ps.c,v 1.20 1999/08/28 00:41:09 peter Exp $
- * $DragonFly: src/sys/ddb/db_ps.c,v 1.20 2006/12/23 00:27:02 swildner Exp $
+ * $DragonFly: src/sys/ddb/db_ps.c,v 1.21 2007/02/03 17:05:57 corecode Exp $
*/
#include <sys/param.h>
#include <sys/systm.h>
int cpuidx;
int nl = 0;
volatile struct proc *p, *pp;
+ struct lwp *lp;
np = nprocs;
if (pp == NULL)
pp = p;
- db_printf("%5d %8p %4d %5d %5d %06x %d",
+ /* XXX lwp */
+ lp = FIRST_LWP_IN_PROC(p);
+ db_printf("%5d %8p %8p %4d %5d %5d %06x %d",
p->p_pid, (volatile void *)p,
+ (void *)lp->lwp_thread->td_pcb,
p->p_ucred ? p->p_ucred->cr_ruid : 0, pp->p_pid,
p->p_pgrp ? p->p_pgrp->pg_id : 0, p->p_flag, p->p_stat);
- if (p->p_wchan) {
- db_printf(" %6s %8p", p->p_wmesg, (void *)p->p_wchan);
+ if (lp->lwp_wchan) {
+ db_printf(" %6s %8p", lp->lwp_wmesg,
+ (void *)lp->lwp_wchan);
} else {
db_printf(" ");
}
db_printf(" %s\n", p->p_comm ? p->p_comm : "");
+ db_dump_td_tokens(lp->lwp_thread);
p = p->p_list.le_next;
if (p == NULL && np > 0)
* Version 1.7, December 1995.
*
* $FreeBSD: src/sys/i386/isa/spigot.c,v 1.44 2000/01/29 16:17:36 peter Exp $
- * $DragonFly: src/sys/dev/misc/spigot/spigot.c,v 1.14 2006/09/10 01:26:35 dillon Exp $
+ * $DragonFly: src/sys/dev/misc/spigot/spigot.c,v 1.15 2007/02/03 17:05:57 corecode Exp $
*
*/
if (securelevel > 0)
return EPERM;
#endif
- curproc->p_md.md_regs->tf_eflags |= PSL_IOPL;
+ curthread->td_lwp->lwp_md.md_regs->tf_eflags |= PSL_IOPL;
break;
case SPIGOT_IOPL_OFF: /* deny access to the IO PAGE */
- curproc->p_md.md_regs->tf_eflags &= ~PSL_IOPL;
+ curthread->td_lwp->lwp_md.md_regs->tf_eflags &= ~PSL_IOPL;
break;
case SPIGOT_GET_INFO:
info = (struct spigot_info *)data;
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* $FreeBSD: /usr/local/www/cvsroot/FreeBSD/src/sys/dev/syscons/syscons.c,v 1.336.2.17 2004/03/25 08:41:09 ru Exp $
- * $DragonFly: src/sys/dev/misc/syscons/syscons.c,v 1.29 2006/12/22 23:26:18 swildner Exp $
+ * $DragonFly: src/sys/dev/misc/syscons/syscons.c,v 1.30 2007/02/03 17:05:57 corecode Exp $
*/
#include "use_splash.h"
return error;
if (securelevel > 0)
return EPERM;
- curproc->p_md.md_regs->tf_eflags |= PSL_IOPL;
+ curthread->td_lwp->lwp_md.md_regs->tf_eflags |= PSL_IOPL;
return 0;
case KDDISABIO: /* disallow io operations (default) */
- curproc->p_md.md_regs->tf_eflags &= ~PSL_IOPL;
+ curthread->td_lwp->lwp_md.md_regs->tf_eflags &= ~PSL_IOPL;
return 0;
case KDSKBSTATE: /* set keyboard state (locks) */
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
- * $DragonFly: src/sys/emulation/43bsd/43bsd_signal.c,v 1.3 2006/06/05 07:26:07 dillon Exp $
+ * $DragonFly: src/sys/emulation/43bsd/43bsd_signal.c,v 1.4 2007/02/03 17:05:57 corecode Exp $
* from: DragonFly kern/kern_sig.c,v 1.22
*
* These syscalls used to live in kern/kern_sig.c. They are modified
int
sys_osigblock(struct osigblock_args *uap)
{
- struct proc *p = curproc;
+ struct lwp *lp = curthread->td_lwp;
sigset_t set;
OSIG2SIG(uap->mask, set);
SIG_CANTMASK(set);
crit_enter();
- SIG2OSIG(p->p_sigmask, uap->sysmsg_result);
- SIGSETOR(p->p_sigmask, set);
+ SIG2OSIG(lp->lwp_sigmask, uap->sysmsg_result);
+ SIGSETOR(lp->lwp_sigmask, set);
crit_exit();
return (0);
}
int
sys_osigsetmask(struct osigsetmask_args *uap)
{
- struct proc *p = curproc;
+ struct lwp *lp = curthread->td_lwp;
sigset_t set;
OSIG2SIG(uap->mask, set);
SIG_CANTMASK(set);
crit_enter();
- SIG2OSIG(p->p_sigmask, uap->sysmsg_result);
- SIGSETLO(p->p_sigmask, set);
+ SIG2OSIG(lp->lwp_sigmask, uap->sysmsg_result);
+ SIGSETLO(lp->lwp_sigmask, set);
crit_exit();
return (0);
}
int
sys_osigstack(struct osigstack_args *uap)
{
- struct proc *p = curproc;
+ struct lwp *lp = curthread->td_lwp;
struct sigstack ss;
int error = 0;
- ss.ss_sp = p->p_sigstk.ss_sp;
- ss.ss_onstack = p->p_sigstk.ss_flags & SS_ONSTACK;
+ ss.ss_sp = lp->lwp_sigstk.ss_sp;
+ ss.ss_onstack = lp->lwp_sigstk.ss_flags & SS_ONSTACK;
if (uap->oss && (error = copyout(&ss, uap->oss,
sizeof(struct sigstack))))
return (error);
if (uap->nss && (error = copyin(uap->nss, &ss, sizeof(ss))) == 0) {
- p->p_sigstk.ss_sp = ss.ss_sp;
- p->p_sigstk.ss_size = 0;
- p->p_sigstk.ss_flags |= ss.ss_onstack & SS_ONSTACK;
- p->p_flag |= P_ALTSTACK;
+ lp->lwp_sigstk.ss_sp = ss.ss_sp;
+ lp->lwp_sigstk.ss_size = 0;
+ lp->lwp_sigstk.ss_flags |= ss.ss_onstack & SS_ONSTACK;
+ lp->lwp_flag |= LWP_ALTSTACK;
}
return (error);
}
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* $FreeBSD: src/sys/i386/linux/linux_machdep.c,v 1.6.2.4 2001/11/05 19:08:23 marcel Exp $
- * $DragonFly: src/sys/emulation/linux/i386/linux_machdep.c,v 1.19 2006/12/23 00:27:02 swildner Exp $
+ * $DragonFly: src/sys/emulation/linux/i386/linux_machdep.c,v 1.20 2007/02/03 17:05:57 corecode Exp $
*/
#include <sys/param.h>
return (ESRCH);
p2->p_sigparent = exit_signal;
- p2->p_md.md_regs->tf_esp = (unsigned int)args->stack;
+ ONLY_LWP_IN_PROC(p2)->lwp_md.md_regs->tf_esp =
+ (unsigned int)args->stack;
#ifdef DEBUG
if (ldebug(clone))
sys_linux_iopl(struct linux_iopl_args *args)
{
struct thread *td = curthread;
- struct proc *p = td->td_proc;
+ struct lwp *lp = td->td_lwp;
int error;
- KKASSERT(p);
+ KKASSERT(lp);
if (args->level < 0 || args->level > 3)
return (EINVAL);
return (error);
if (securelevel > 0)
return (EPERM);
- p->p_md.md_regs->tf_eflags = (p->p_md.md_regs->tf_eflags & ~PSL_IOPL) |
+ lp->lwp_md.md_regs->tf_eflags =
+ (lp->lwp_md.md_regs->tf_eflags & ~PSL_IOPL) |
(args->level * (PSL_IOPL / 3));
return (0);
}
sys_linux_pause(struct linux_pause_args *args)
{
struct thread *td = curthread;
- struct proc *p = td->td_proc;
+ struct lwp *lp = td->td_lwp;
sigset_t mask;
int error;
kprintf(ARGS(pause, ""));
#endif
- mask = p->p_sigmask;
+ mask = lp->lwp_sigmask;
error = kern_sigsuspend(&mask);
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* $FreeBSD: src/sys/i386/linux/linux_ptrace.c,v 1.7.4.3 2003/01/03 17:13:23 kan Exp $
- * $DragonFly: src/sys/emulation/linux/i386/linux_ptrace.c,v 1.13 2006/12/23 00:27:02 swildner Exp $
+ * $DragonFly: src/sys/emulation/linux/i386/linux_ptrace.c,v 1.14 2007/02/03 17:05:57 corecode Exp $
*/
#include "opt_cpu.h"
#ifndef CPU_DISABLE_SSE
static int
-linux_proc_read_fpxregs(struct thread *td, struct linux_pt_fpxreg *fpxregs)
+linux_proc_read_fpxregs(struct proc *p, struct linux_pt_fpxreg *fpxregs)
{
+ /* XXX lwp */
+ struct lwp *lp = FIRST_LWP_IN_PROC(p);
int error;
error = 0;
if (cpu_fxsr == 0)
error = EIO;
else
- bcopy(&td->td_pcb->pcb_save.sv_xmm,
+ bcopy(&lp->lwp_thread->td_pcb->pcb_save.sv_xmm,
fpxregs, sizeof(*fpxregs));
return (error);
}
static int
-linux_proc_write_fpxregs(struct thread *td, struct linux_pt_fpxreg *fpxregs)
+linux_proc_write_fpxregs(struct proc *p, struct linux_pt_fpxreg *fpxregs)
{
+ /* XXX lwp */
+ struct lwp *lp = FIRST_LWP_IN_PROC(p);
int error;
error = 0;
if (cpu_fxsr == 0)
error = EIO;
else
- bcopy(fpxregs, &td->td_pcb->pcb_save.sv_xmm,
+ bcopy(fpxregs, &lp->lwp_thread->td_pcb->pcb_save.sv_xmm,
sizeof(*fpxregs));
return (error);
}
if (req == PTRACE_GETFPXREGS) {
PHOLD(p);
- error = linux_proc_read_fpxregs(td, &r.fpxreg);
+ error = linux_proc_read_fpxregs(p, &r.fpxreg);
PRELE(p);
if (error == 0)
error = copyout(&r.fpxreg, (caddr_t)uap->data,
/* clear dangerous bits exactly as Linux does*/
r.fpxreg.mxcsr &= 0xffbf;
PHOLD(p);
- error = linux_proc_write_fpxregs(td, &r.fpxreg);
+ error = linux_proc_write_fpxregs(p, &r.fpxreg);
PRELE(p);
}
break;
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* $FreeBSD: src/sys/i386/linux/linux_sysvec.c,v 1.55.2.9 2002/01/12 11:03:30 bde Exp $
- * $DragonFly: src/sys/emulation/linux/i386/linux_sysvec.c,v 1.26 2007/02/03 09:56:04 y0netan1 Exp $
+ * $DragonFly: src/sys/emulation/linux/i386/linux_sysvec.c,v 1.27 2007/02/03 17:05:57 corecode Exp $
*/
/* XXX we use functions that might not exist. */
linux_rt_sendsig(sig_t catcher, int sig, sigset_t *mask, u_long code)
{
struct proc *p = curproc;
+ struct lwp *lp = curthread->td_lwp;
struct trapframe *regs;
struct l_rt_sigframe *fp, frame;
int oonstack;
- regs = p->p_md.md_regs;
- oonstack = p->p_sigstk.ss_flags & SS_ONSTACK;
+ regs = lp->lwp_md.md_regs;
+ oonstack = lp->lwp_sigstk.ss_flags & SS_ONSTACK;
#ifdef DEBUG
if (ldebug(rt_sendsig))
/*
* Allocate space for the signal handler context.
*/
- if ((p->p_flag & P_ALTSTACK) && !oonstack &&
+ if ((lp->lwp_flag & LWP_ALTSTACK) && !oonstack &&
SIGISMEMBER(p->p_sigacts->ps_sigonstack, sig)) {
- fp = (struct l_rt_sigframe *)(p->p_sigstk.ss_sp +
- p->p_sigstk.ss_size - sizeof(struct l_rt_sigframe));
- p->p_sigstk.ss_flags |= SS_ONSTACK;
+ fp = (struct l_rt_sigframe *)(lp->lwp_sigstk.ss_sp +
+ lp->lwp_sigstk.ss_size - sizeof(struct l_rt_sigframe));
+ lp->lwp_sigstk.ss_flags |= SS_ONSTACK;
} else
fp = (struct l_rt_sigframe *)regs->tf_esp - 1;
SIGACTION(p, SIGILL) = SIG_DFL;
SIGDELSET(p->p_sigignore, SIGILL);
SIGDELSET(p->p_sigcatch, SIGILL);
- SIGDELSET(p->p_sigmask, SIGILL);
+ SIGDELSET(lp->lwp_sigmask, SIGILL);
#ifdef DEBUG
if (ldebug(rt_sendsig))
kprintf(LMSG("rt_sendsig: bad stack %p, oonstack=%x"),
frame.sf_sc.uc_flags = 0; /* XXX ??? */
frame.sf_sc.uc_link = NULL; /* XXX ??? */
- frame.sf_sc.uc_stack.ss_sp = p->p_sigstk.ss_sp;
- frame.sf_sc.uc_stack.ss_size = p->p_sigstk.ss_size;
- frame.sf_sc.uc_stack.ss_flags = (p->p_flag & P_ALTSTACK)
+ frame.sf_sc.uc_stack.ss_sp = lp->lwp_sigstk.ss_sp;
+ frame.sf_sc.uc_stack.ss_size = lp->lwp_sigstk.ss_size;
+ frame.sf_sc.uc_stack.ss_flags = (lp->lwp_flag & LWP_ALTSTACK)
? ((oonstack) ? LINUX_SS_ONSTACK : 0) : LINUX_SS_DISABLE;
bsd_to_linux_sigset(mask, &frame.sf_sc.uc_sigmask);
if (ldebug(rt_sendsig))
kprintf(LMSG("rt_sendsig flags: 0x%x, sp: %p, ss: 0x%x, mask: 0x%x"),
frame.sf_sc.uc_stack.ss_flags, p->p_sigstk.ss_sp,
- p->p_sigstk.ss_size, frame.sf_sc.uc_mcontext.sc_mask);
+ lp->lwp_sigstk.ss_size, frame.sf_sc.uc_mcontext.sc_mask);
#endif
if (copyout(&frame, fp, sizeof(frame)) != 0) {
linux_sendsig(sig_t catcher, int sig, sigset_t *mask, u_long code)
{
struct proc *p = curproc;
+ struct lwp *lp = curthread->td_lwp;
struct trapframe *regs;
struct l_sigframe *fp, frame;
l_sigset_t lmask;
return;
}
- regs = p->p_md.md_regs;
- oonstack = p->p_sigstk.ss_flags & SS_ONSTACK;
+ regs = lp->lwp_md.md_regs;
+ oonstack = lp->lwp_sigstk.ss_flags & SS_ONSTACK;
#ifdef DEBUG
if (ldebug(sendsig))
/*
* Allocate space for the signal handler context.
*/
- if ((p->p_flag & P_ALTSTACK) && !oonstack &&
+ if ((lp->lwp_flag & LWP_ALTSTACK) && !oonstack &&
SIGISMEMBER(p->p_sigacts->ps_sigonstack, sig)) {
- fp = (struct l_sigframe *)(p->p_sigstk.ss_sp +
- p->p_sigstk.ss_size - sizeof(struct l_sigframe));
- p->p_sigstk.ss_flags |= SS_ONSTACK;
+ fp = (struct l_sigframe *)(lp->lwp_sigstk.ss_sp +
+ lp->lwp_sigstk.ss_size - sizeof(struct l_sigframe));
+ lp->lwp_sigstk.ss_flags |= SS_ONSTACK;
} else
fp = (struct l_sigframe *)regs->tf_esp - 1;
SIGACTION(p, SIGILL) = SIG_DFL;
SIGDELSET(p->p_sigignore, SIGILL);
SIGDELSET(p->p_sigcatch, SIGILL);
- SIGDELSET(p->p_sigmask, SIGILL);
+ SIGDELSET(lp->lwp_sigmask, SIGILL);
ksignal(p, SIGILL);
return;
}
int
sys_linux_sigreturn(struct linux_sigreturn_args *args)
{
- struct proc *p = curproc;
+ struct lwp *lp = curthread->td_lwp;
struct l_sigframe frame;
struct trapframe *regs;
l_sigset_t lmask;
int eflags, i;
- regs = p->p_md.md_regs;
+ regs = lp->lwp_md.md_regs;
#ifdef DEBUG
if (ldebug(sigreturn))
*/
#define CS_SECURE(cs) (ISPL(cs) == SEL_UPL)
if (!CS_SECURE(frame.sf_sc.sc_cs)) {
- trapsignal(p, SIGBUS, T_PROTFLT);
+ trapsignal(lp, SIGBUS, T_PROTFLT);
return(EINVAL);
}
- p->p_sigstk.ss_flags &= ~SS_ONSTACK;
+ lp->lwp_sigstk.ss_flags &= ~SS_ONSTACK;
lmask.__bits[0] = frame.sf_sc.sc_mask;
for (i = 0; i < (LINUX_NSIG_WORDS-1); i++)
lmask.__bits[i+1] = frame.sf_extramask[i];
- linux_to_bsd_sigset(&lmask, &p->p_sigmask);
- SIG_CANTMASK(p->p_sigmask);
+ linux_to_bsd_sigset(&lmask, &lp->lwp_sigmask);
+ SIG_CANTMASK(lp->lwp_sigmask);
/*
* Restore signal context.
int
sys_linux_rt_sigreturn(struct linux_rt_sigreturn_args *args)
{
- struct proc *p = curproc;
+ struct lwp *lp = curthread->td_lwp;
struct l_ucontext uc;
struct l_sigcontext *context;
l_stack_t *lss;
struct trapframe *regs;
int eflags;
- regs = p->p_md.md_regs;
+ regs = lp->lwp_md.md_regs;
#ifdef DEBUG
if (ldebug(rt_sigreturn))
*/
#define CS_SECURE(cs) (ISPL(cs) == SEL_UPL)
if (!CS_SECURE(context->sc_cs)) {
- trapsignal(p, SIGBUS, T_PROTFLT);
+ trapsignal(lp, SIGBUS, T_PROTFLT);
return(EINVAL);
}
- p->p_sigstk.ss_flags &= ~SS_ONSTACK;
- linux_to_bsd_sigset(&uc.uc_sigmask, &p->p_sigmask);
- SIG_CANTMASK(p->p_sigmask);
+ lp->lwp_sigstk.ss_flags &= ~SS_ONSTACK;
+ linux_to_bsd_sigset(&uc.uc_sigmask, &lp->lwp_sigmask);
+ SIG_CANTMASK(lp->lwp_sigmask);
/*
* Restore signal context
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* $FreeBSD: src/sys/compat/linux/linux_signal.c,v 1.23.2.3 2001/11/05 19:08:23 marcel Exp $
- * $DragonFly: src/sys/emulation/linux/linux_signal.c,v 1.12 2006/12/23 00:27:02 swildner Exp $
+ * $DragonFly: src/sys/emulation/linux/linux_signal.c,v 1.13 2007/02/03 17:05:57 corecode Exp $
*/
#include <sys/param.h>
int
sys_linux_sgetmask(struct linux_sgetmask_args *args)
{
- struct proc *p = curproc;
+ struct lwp *lp = curthread->td_lwp;
l_sigset_t mask;
#ifdef DEBUG
kprintf(ARGS(sgetmask, ""));
#endif
- bsd_to_linux_sigset(&p->p_sigmask, &mask);
+ bsd_to_linux_sigset(&lp->lwp_sigmask, &mask);
args->sysmsg_result = mask.__bits[0];
return (0);
}
int
sys_linux_ssetmask(struct linux_ssetmask_args *args)
{
- struct proc *p = curproc;
+ struct lwp *lp = curthread->td_lwp;
l_sigset_t lset;
sigset_t bset;
kprintf(ARGS(ssetmask, "%08lx"), (unsigned long)args->mask);
#endif
- bsd_to_linux_sigset(&p->p_sigmask, &lset);
+ bsd_to_linux_sigset(&lp->lwp_sigmask, &lset);
args->sysmsg_result = lset.__bits[0];
LINUX_SIGEMPTYSET(lset);
lset.__bits[0] = args->mask;
linux_to_bsd_sigset(&lset, &bset);
- p->p_sigmask = bset;
- SIG_CANTMASK(p->p_sigmask);
+ lp->lwp_sigmask = bset;
+ SIG_CANTMASK(lp->lwp_sigmask);
return (0);
}
sys_linux_sigpending(struct linux_sigpending_args *args)
{
struct thread *td = curthread;
- struct proc *p = td->td_proc;
+ struct lwp *lp = td->td_lwp;
sigset_t set;
l_sigset_t linux_set;
l_osigset_t mask;
error = kern_sigpending(&set);
if (error == 0) {
- SIGSETAND(set, p->p_sigmask);
+ SIGSETAND(set, lp->lwp_sigmask);
bsd_to_linux_sigset(&set, &linux_set);
mask = linux_set.__bits[0];
error = copyout(&mask, args->mask, sizeof(mask));
* SUCH DAMAGE.
*
* $FreeBSD: src/sys/posix4/ksched.c,v 1.7.2.1 2000/05/16 06:58:13 dillon Exp $
- * $DragonFly: src/sys/emulation/posix4/Attic/ksched.c,v 1.7 2006/11/07 18:50:06 dillon Exp $
+ * $DragonFly: src/sys/emulation/posix4/Attic/ksched.c,v 1.8 2007/02/03 17:05:57 corecode Exp $
*/
/* ksched: Soft real time scheduling based on "rtprio".
#define P1B_PRIO_MAX rtpprio_to_p4prio(RTP_PRIO_MIN)
static __inline int
-getscheduler(register_t *ret, struct ksched *ksched, struct proc *p)
+getscheduler(register_t *ret, struct ksched *ksched, struct lwp *lp)
{
int e = 0;
- switch (p->p_lwp.lwp_rtprio.type)
+ switch (lp->lwp_rtprio.type)
{
case RTP_PRIO_FIFO:
*ret = SCHED_FIFO;
}
int ksched_setparam(register_t *ret, struct ksched *ksched,
- struct proc *p, const struct sched_param *param)
+ struct lwp *lp, const struct sched_param *param)
{
register_t policy;
int e;
- e = getscheduler(&policy, ksched, p);
+ e = getscheduler(&policy, ksched, lp);
if (e == 0)
{
if (policy == SCHED_OTHER)
e = EINVAL;
else
- e = ksched_setscheduler(ret, ksched, p, policy, param);
+ e = ksched_setscheduler(ret, ksched, lp, policy, param);
}
return e;
}
int ksched_getparam(register_t *ret, struct ksched *ksched,
- struct proc *p, struct sched_param *param)
+ struct lwp *lp, struct sched_param *param)
{
- if (RTP_PRIO_IS_REALTIME(p->p_lwp.lwp_rtprio.type))
- param->sched_priority = rtpprio_to_p4prio(p->p_rtprio.prio);
+ if (RTP_PRIO_IS_REALTIME(lp->lwp_rtprio.type))
+ param->sched_priority = rtpprio_to_p4prio(lp->lwp_rtprio.prio);
return 0;
}
*
*/
int ksched_setscheduler(register_t *ret, struct ksched *ksched,
- struct proc *p, int policy, const struct sched_param *param)
+ struct lwp *lp, int policy, const struct sched_param *param)
{
int e = 0;
struct rtprio rtp;
rtp.type = (policy == SCHED_FIFO)
? RTP_PRIO_FIFO : RTP_PRIO_REALTIME;
- p->p_lwp.lwp_rtprio = rtp;
+ lp->lwp_rtprio = rtp;
need_user_resched();
}
else
{
rtp.type = RTP_PRIO_NORMAL;
rtp.prio = p4prio_to_rtpprio(param->sched_priority);
- p->p_lwp.lwp_rtprio = rtp;
+ lp->lwp_rtprio = rtp;
/* XXX Simply revert to whatever we had for last
* normal scheduler priorities.
return e;
}
-int ksched_getscheduler(register_t *ret, struct ksched *ksched, struct proc *p)
+int ksched_getscheduler(register_t *ret, struct ksched *ksched, struct lwp *lp)
{
- return getscheduler(ret, ksched, p);
+ return getscheduler(ret, ksched, lp);
}
/* ksched_yield: Yield the CPU.
}
int ksched_rr_get_interval(register_t *ret, struct ksched *ksched,
- struct proc *p, struct timespec *timespec)
+ struct lwp *lp, struct timespec *timespec)
{
*timespec = ksched->rr_interval;
* SUCH DAMAGE.
*
* $FreeBSD: src/sys/posix4/p1003_1b.c,v 1.5.2.2 2003/03/25 06:13:35 rwatson Exp $
- * $DragonFly: src/sys/emulation/posix4/Attic/p1003_1b.c,v 1.8 2006/06/05 07:26:10 dillon Exp $
+ * $DragonFly: src/sys/emulation/posix4/Attic/p1003_1b.c,v 1.9 2007/02/03 17:05:57 corecode Exp $
*/
/* p1003_1b: Real Time common code.
sys_sched_setparam(struct sched_setparam_args *uap)
{
struct proc *p = curproc;
+ struct lwp *lp;
int e;
struct sched_param sched_param;
copyin(uap->param, &sched_param, sizeof(sched_param));
if ((e = p31b_proc(p, uap->pid, &p)) == 0) {
- e = ksched_setparam(&uap->sysmsg_result, ksched, p,
+ lp = FIRST_LWP_IN_PROC(p); /* XXX lwp */
+ e = ksched_setparam(&uap->sysmsg_result, ksched, lp,
(const struct sched_param *)&sched_param);
}
return e;
{
struct proc *p = curproc;
struct proc *targetp;
+ struct lwp *lp;
struct sched_param sched_param;
int e;
targetp = p;
}
- e = ksched_getparam(&uap->sysmsg_result, ksched, targetp, &sched_param);
+ lp = FIRST_LWP_IN_PROC(targetp); /* XXX lwp */
+ e = ksched_getparam(&uap->sysmsg_result, ksched, lp, &sched_param);
if (!e)
copyout(&sched_param, uap->param, sizeof(sched_param));
sys_sched_setscheduler(struct sched_setscheduler_args *uap)
{
struct proc *p = curproc;
+ struct lwp *lp;
int e;
struct sched_param sched_param;
copyin(uap->param, &sched_param, sizeof(sched_param));
if ((e = p31b_proc(p, uap->pid, &p)) == 0) {
- e = ksched_setscheduler(&uap->sysmsg_result, ksched, p,
+ lp = FIRST_LWP_IN_PROC(p); /* XXX lwp */
+ e = ksched_setscheduler(&uap->sysmsg_result, ksched, lp,
uap->policy, (const struct sched_param *)&sched_param);
}
return e;
{
struct proc *p = curproc;
struct proc *targetp;
+ struct lwp *lp;
int e;
if (uap->pid != 0 && uap->pid != p->p_pid) {
targetp = p;
}
- e = ksched_getscheduler(&uap->sysmsg_result, ksched, targetp);
+ lp = FIRST_LWP_IN_PROC(targetp); /* XXX lwp */
+ e = ksched_getscheduler(&uap->sysmsg_result, ksched, lp);
return e;
}
{
int e;
struct proc *p = curproc;
+ struct lwp *lp = curthread->td_lwp;
if ((e = p31b_proc(p, uap->pid, &p)) == 0) {
e = ksched_rr_get_interval(&uap->sysmsg_result, ksched,
- p, uap->interval);
+ lp, uap->interval);
}
return e;
}
* SUCH DAMAGE.
*
* $FreeBSD: src/sys/posix4/posix4.h,v 1.6 1999/12/27 10:22:09 bde Exp $
- * $DragonFly: src/sys/emulation/posix4/Attic/posix4.h,v 1.6 2006/09/05 03:48:11 dillon Exp $
+ * $DragonFly: src/sys/emulation/posix4/Attic/posix4.h,v 1.7 2007/02/03 17:05:57 corecode Exp $
*/
#include "opt_posix.h"
#define p31b_free(P) kfree((P), M_P31B)
struct proc;
+struct lwp;
int p31b_proc (struct proc *, pid_t, struct proc **);
int ksched_detach(struct ksched *);
int ksched_setparam(register_t *, struct ksched *,
- struct proc *, const struct sched_param *);
+ struct lwp *, const struct sched_param *);
int ksched_getparam(register_t *, struct ksched *,
- struct proc *, struct sched_param *);
+ struct lwp *, struct sched_param *);
int ksched_setscheduler(register_t *, struct ksched *,
- struct proc *, int, const struct sched_param *);
-int ksched_getscheduler(register_t *, struct ksched *, struct proc *);
+ struct lwp *, int, const struct sched_param *);
+int ksched_getscheduler(register_t *, struct ksched *, struct lwp *);
int ksched_yield(register_t *, struct ksched *);
int ksched_get_priority_min(register_t *, struct ksched *, int);
int ksched_rr_get_interval(register_t *, struct ksched *,
- struct proc *, struct timespec *);
+ struct lwp *, struct timespec *);
#endif /* _KPOSIX_PRIORITY_SCHEDULING */
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* $FreeBSD: src/sys/kern/imgact_elf.c,v 1.73.2.13 2002/12/28 19:49:41 dillon Exp $
- * $DragonFly: src/sys/kern/imgact_elf.c,v 1.47 2007/01/12 06:06:57 dillon Exp $
+ * $DragonFly: src/sys/kern/imgact_elf.c,v 1.48 2007/02/03 17:05:57 corecode Exp $
*/
#include <sys/param.h>
status->pr_osreldate = osreldate;
status->pr_cursig = p->p_sig;
status->pr_pid = p->p_pid;
- fill_regs(&p->p_lwp, &status->pr_reg);
+ /* XXX lwp */
+ fill_regs(FIRST_LWP_IN_PROC(p), &status->pr_reg);
- fill_fpregs(&p->p_lwp, fpregset);
+ fill_fpregs(FIRST_LWP_IN_PROC(p), fpregset);
psinfo->pr_version = PRPSINFO_VERSION;
psinfo->pr_psinfosz = sizeof(prpsinfo_t);
bcopy(p->p_procsig, &csi->csi_procsig, sizeof(struct procsig));
bcopy(p->p_procsig->ps_sigacts, &csi->csi_sigacts, sizeof(struct sigacts));
bcopy(&p->p_realtimer, &csi->csi_itimerval, sizeof(struct itimerval));
- bcopy(&p->p_sigmask, &csi->csi_sigmask, sizeof(sigset_t));
+ /* XXX lwp */
+ bcopy(&FIRST_LWP_IN_PROC(p)->lwp_sigmask, &csi->csi_sigmask,
+ sizeof(sigset_t));
csi->csi_sigparent = p->p_sigparent;
}
return(error);
*
* @(#)init_main.c 8.9 (Berkeley) 1/21/94
* $FreeBSD: src/sys/kern/init_main.c,v 1.134.2.8 2003/06/06 20:21:32 tegge Exp $
- * $DragonFly: src/sys/kern/init_main.c,v 1.71 2007/01/01 22:51:17 corecode Exp $
+ * $DragonFly: src/sys/kern/init_main.c,v 1.72 2007/02/03 17:05:57 corecode Exp $
*/
#include "opt_init_path.h"
static struct vmspace vmspace0;
struct proc *initproc;
struct proc proc0;
+struct lwp lwp0;
struct thread thread0;
int cmask = CMASK;
lwkt_set_comm(&thread0, "thread0");
proc0.p_addr = (void *)thread0.td_kstack;
LIST_INIT(&proc0.p_lwps);
- LIST_INSERT_HEAD(&proc0.p_lwps, &proc0.p_lwp, lwp_list);
- proc0.p_lwp.lwp_thread = &thread0;
- proc0.p_lwp.lwp_proc = &proc0;
+ LIST_INSERT_HEAD(&proc0.p_lwps, &lwp0, lwp_list);
+ lwp0.lwp_thread = &thread0;
+ lwp0.lwp_proc = &proc0;
proc0.p_usched = usched_init();
- proc0.p_lwp.lwp_cpumask = 0xFFFFFFFF;
+ lwp0.lwp_cpumask = 0xFFFFFFFF;
varsymset_init(&proc0.p_varsymset, NULL);
thread0.td_flags |= TDF_RUNNING;
thread0.td_proc = &proc0;
- thread0.td_lwp = &proc0.p_lwp;
+ thread0.td_lwp = &lwp0;
thread0.td_switch = cpu_heavy_switch; /* YYY eventually LWKT */
}
struct lwp *lp;
p = &proc0;
- lp = &proc0.p_lwp; /* XXX lwp to be: lwp0 */
+ lp = &lwp0;
/*
* Initialize process and pgrp structures.
p->p_nice = NZERO;
p->p_rtprio.type = RTP_PRIO_NORMAL;
p->p_rtprio.prio = 0;
- p->p_lwp.lwp_rtprio = p->p_rtprio;
+ lp->lwp_rtprio = p->p_rtprio;
p->p_peers = 0;
p->p_leader = p;
p = curproc;
- KKASSERT(p->p_nthreads == 1);
-
- lp = LIST_FIRST(&p->p_lwps);
+ lp = ONLY_LWP_IN_PROC(p);
/* Get the vnode for '/'. Set p->p_fd->fd_cdir to reference it. */
mp = mountlist_boot_getfirst();
struct lwp *lp;
crit_enter();
- error = fork1(&proc0.p_lwp, RFFDG | RFPROC, &initproc);
+ error = fork1(&lwp0, RFFDG | RFPROC, &initproc);
if (error)
panic("cannot fork init: %d", error);
initproc->p_flag |= P_SYSTEM;
- lp = LIST_FIRST(&initproc->p_lwps);
+ lp = ONLY_LWP_IN_PROC(initproc);
cpu_set_fork_handler(lp, start_init, NULL);
crit_exit();
}
static void
kick_init(const void *udata __unused)
{
- start_forked_proc(&proc0.p_lwp, initproc);
+ start_forked_proc(&lwp0, initproc);
}
SYSINIT(kickinit,SI_SUB_KTHREAD_INIT, SI_ORDER_FIRST, kick_init, NULL)
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
- * $DragonFly: src/sys/kern/kern_checkpoint.c,v 1.15 2007/01/12 06:06:57 dillon Exp $
+ * $DragonFly: src/sys/kern/kern_checkpoint.c,v 1.16 2007/02/03 17:05:57 corecode Exp $
*/
#include <sys/types.h>
elf_loadnotes(struct proc *p, prpsinfo_t *psinfo, prstatus_t *status,
prfpregset_t *fpregset)
{
+ struct lwp *lp;
int error;
/* validate status and psinfo */
error = EINVAL;
goto done;
}
- if ((error = set_regs(&p->p_lwp, &status->pr_reg)) != 0)
+ /* XXX lwp */
+ lp = FIRST_LWP_IN_PROC(p);
+ if ((error = set_regs(lp, &status->pr_reg)) != 0)
goto done;
- error = set_fpregs(&p->p_lwp, fpregset);
+ error = set_fpregs(lp, fpregset);
strlcpy(p->p_comm, psinfo->pr_fname, sizeof(p->p_comm));
/* XXX psinfo->pr_psargs not yet implemented */
done:
int error;
struct ckpt_siginfo *csi;
struct sigacts *tmpsigacts;
+ struct lwp *lp;
TRACE_ENTER;
csi = kmalloc(sizeof(struct ckpt_siginfo), M_TEMP, M_ZERO | M_WAITOK);
bcopy(&csi->csi_sigacts, p->p_procsig->ps_sigacts, sizeof(struct sigacts));
bcopy(&csi->csi_itimerval, &p->p_realtimer, sizeof(struct itimerval));
SIG_CANTMASK(csi->csi_sigmask);
- bcopy(&csi->csi_sigmask, &p->p_sigmask, sizeof(sigset_t));
+ /* XXX lwp */
+ lp = FIRST_LWP_IN_PROC(p);
+ bcopy(&csi->csi_sigmask, &lp->lwp_sigmask, sizeof(sigset_t));
p->p_sigparent = csi->csi_sigparent;
done:
if (csi)
*
* @(#)kern_descrip.c 8.6 (Berkeley) 4/19/94
* $FreeBSD: src/sys/kern/kern_descrip.c,v 1.81.2.19 2004/02/28 00:43:31 tegge Exp $
- * $DragonFly: src/sys/kern/kern_descrip.c,v 1.76 2006/12/23 00:35:03 swildner Exp $
+ * $DragonFly: src/sys/kern/kern_descrip.c,v 1.77 2007/02/03 17:05:57 corecode Exp $
*/
#include "opt_compat.h"
fdfree(struct proc *p)
{
/* Take any thread of p */
- struct thread *td = LIST_FIRST(&p->p_lwps)->lwp_thread;
+ struct thread *td = FIRST_LWP_IN_PROC(p)->lwp_thread;
struct filedesc *fdp = p->p_fd;
struct fdnode *fdnode;
int i;
setugidsafety(struct proc *p)
{
/* Take any thread of p */
- struct thread *td = LIST_FIRST(&p->p_lwps)->lwp_thread;
+ struct thread *td = FIRST_LWP_IN_PROC(p)->lwp_thread;
struct filedesc *fdp = p->p_fd;
int i;
fdcloseexec(struct proc *p)
{
/* Take any thread of p */
- struct thread *td = LIST_FIRST(&p->p_lwps)->lwp_thread;
+ struct thread *td = FIRST_LWP_IN_PROC(p)->lwp_thread;
struct filedesc *fdp = p->p_fd;
int i;
* SUCH DAMAGE.
*
* $FreeBSD: src/sys/kern/kern_event.c,v 1.2.2.10 2004/04/04 07:03:14 cperciva Exp $
- * $DragonFly: src/sys/kern/kern_event.c,v 1.32 2007/01/15 01:26:55 dillon Exp $
+ * $DragonFly: src/sys/kern/kern_event.c,v 1.33 2007/02/03 17:05:57 corecode Exp $
*/
#include <sys/param.h>
struct filedesc *fdp = p->p_fd;
struct klist *list = &fdp->fd_knlist[fd];
/* Take any thread of p */
- struct thread *td = LIST_FIRST(&p->p_lwps)->lwp_thread;
+ struct thread *td = FIRST_LWP_IN_PROC(p)->lwp_thread;
knote_remove(td, list);
}
* SUCH DAMAGE.
*
* $FreeBSD: src/sys/kern/kern_exec.c,v 1.107.2.15 2002/07/30 15:40:46 nectar Exp $
- * $DragonFly: src/sys/kern/kern_exec.c,v 1.52 2006/12/28 21:24:01 dillon Exp $
+ * $DragonFly: src/sys/kern/kern_exec.c,v 1.53 2007/02/03 17:05:57 corecode Exp $
*/
#include <sys/param.h>
kern_execve(struct nlookupdata *nd, struct image_args *args)
{
struct thread *td = curthread;
+ struct lwp *lp = td->td_lwp;
struct proc *p = td->td_proc;
register_t *stack_base;
int error, len, i;
len = min(nd->nl_nch.ncp->nc_nlen, MAXCOMLEN);
bcopy(nd->nl_nch.ncp->nc_name, p->p_comm, len);
p->p_comm[len] = 0;
- bcopy(p->p_comm, p->p_lwp.lwp_thread->td_comm, MAXCOMLEN+1);
+ bcopy(p->p_comm, lp->lwp_thread->td_comm, MAXCOMLEN+1);
/*
* mark as execed, wakeup the process that vforked (if any) and tell
p->p_acflag &= ~AFORK;
/* Set values passed into the program in registers. */
- setregs(td->td_lwp, imgp->entry_addr, (u_long)(uintptr_t)stack_base,
+ exec_setregs(imgp->entry_addr, (u_long)(uintptr_t)stack_base,
imgp->ps_strings);
/* Free any previous argument cache */
imgp->vmspace_destroyed = 1;
/*
+ * XXX lwp here would be a good place to kill sibling lwps
+ */
+
+ /*
* Prevent a pending AIO from modifying the new address space.
*/
aio_proc_rundown(imgp->proc);
} else if (vmspace->vm_refcnt == 1 && vmspace->vm_exitingcnt == 0) {
shmexit(vmspace);
if (vmspace->vm_upcalls)
- upc_release(vmspace, &imgp->proc->p_lwp);
+ upc_release(vmspace, ONLY_LWP_IN_PROC(imgp->proc));
pmap_remove_pages(vmspace_pmap(vmspace),
0, VM_MAX_USER_ADDRESS);
vm_map_remove(map, 0, VM_MAX_USER_ADDRESS);
*
* @(#)kern_exit.c 8.7 (Berkeley) 2/12/94
* $FreeBSD: src/sys/kern/kern_exit.c,v 1.92.2.11 2003/01/13 22:51:16 dillon Exp $
- * $DragonFly: src/sys/kern/kern_exit.c,v 1.68 2007/02/01 10:33:25 corecode Exp $
+ * $DragonFly: src/sys/kern/kern_exit.c,v 1.69 2007/02/03 17:05:57 corecode Exp $
*/
#include "opt_compat.h"
* Release upcalls associated with this process
*/
if (vm->vm_upcalls)
- upc_release(vm, &p->p_lwp);
+ upc_release(vm, lp);
/* clean up data related to virtual kernel operation */
if (p->p_vkernel)
kern_wait(pid_t pid, int *status, int options, struct rusage *rusage, int *res)
{
struct thread *td = curthread;
- struct thread *deadtd;
+ struct lwp *deadlp;
struct proc *q = td->td_proc;
struct proc *p, *t;
int nfound, error;
nfound++;
if (p->p_flag & P_ZOMBIE) {
- KKASSERT((p->p_nthreads == 1));
- deadtd = LIST_FIRST(&p->p_lwps)->lwp_thread;
+ deadlp = ONLY_LWP_IN_PROC(p);
/*
* Other kernel threads may be in the middle of
while (p->p_lock)
tsleep(p, 0, "reap3", hz);
}
- lwkt_wait_free(deadtd);
+ lwkt_wait_free(deadlp->lwp_thread);
/*
* The process's thread may still be in the middle
*
* YYY no wakeup occurs so we depend on the timeout.
*/
- if ((deadtd->td_flags & (TDF_RUNNING|TDF_PREEMPT_LOCK|TDF_EXITING)) != TDF_EXITING) {
- tsleep(deadtd, 0, "reap2", 1);
+ if ((deadlp->lwp_thread->td_flags & (TDF_RUNNING|TDF_PREEMPT_LOCK|TDF_EXITING)) != TDF_EXITING) {
+ tsleep(deadlp->lwp_thread, 0, "reap2", 1);
goto loop;
}
/* scheduling hook for heuristic */
- p->p_usched->heuristic_exiting(td->td_lwp, deadtd->td_lwp);
+ p->p_usched->heuristic_exiting(td->td_lwp, deadlp);
/* Take care of our return values. */
*res = p->p_pid;
}
vm_waitproc(p);
+ zfree(lwp_zone, deadlp);
zfree(proc_zone, p);
nprocs--;
return (0);
*
* @(#)kern_fork.c 8.6 (Berkeley) 4/8/94
* $FreeBSD: src/sys/kern/kern_fork.c,v 1.72.2.14 2003/06/26 04:15:10 silby Exp $
- * $DragonFly: src/sys/kern/kern_fork.c,v 1.60 2006/12/23 00:35:04 swildner Exp $
+ * $DragonFly: src/sys/kern/kern_fork.c,v 1.61 2007/02/03 17:05:57 corecode Exp $
*/
#include "opt_ktrace.h"
pgrp = NULL;
if ((flags & RFPGLOCK) && (pgrp = p1->p_pgrp) != NULL) {
lockmgr(&pgrp->pg_lock, LK_SHARED);
- if (CURSIGNB(p1)) {
+ if (CURSIGNB(lp1)) {
error = ERESTART;
goto done;
}
/* Allocate new proc. */
p2 = zalloc(proc_zone);
+ lp2 = zalloc(lwp_zone);
/*
* Setup linkage for kernel based threading XXX lwp
LIST_INIT(&p2->p_lwps);
/* XXX lwp */
- lp2 = &p2->p_lwp;
lp2->lwp_proc = p2;
lp2->lwp_tid = 0;
LIST_INSERT_HEAD(&p2->p_lwps, lp2, lwp_list);
(caddr_t)&lp2->lwp_startzero));
bcopy(&p1->p_startcopy, &p2->p_startcopy,
(unsigned) ((caddr_t)&p2->p_endcopy - (caddr_t)&p2->p_startcopy));
- bcopy(&p1->p_lwp.lwp_startcopy, &lp2->lwp_startcopy,
+ bcopy(&lp1->lwp_startcopy, &lp2->lwp_startcopy,
(unsigned) ((caddr_t)&lp2->lwp_endcopy -
(caddr_t)&lp2->lwp_startcopy));
* Preserve some more flags in subprocess. P_PROFIL has already
* been preserved.
*/
- p2->p_flag |= p1->p_flag & (P_SUGID | P_ALTSTACK);
+ p2->p_flag |= p1->p_flag & P_SUGID;
+ lp2->lwp_flag |= lp1->lwp_flag & LWP_ALTSTACK;
if (p1->p_session->s_ttyvp != NULL && p1->p_flag & P_CONTROLT)
p2->p_flag |= P_CONTROLT;
if (flags & RFPPWAIT)
p2->p_usched = p1->p_usched;
lp2->lwp_cpbase = mycpu->gd_schedclock.time -
mycpu->gd_schedclock.periodic;
- p2->p_usched->heuristic_forking(&p1->p_lwp, lp2);
+ p2->p_usched->heuristic_forking(lp1, lp2);
crit_exit();
/*
* execution path later. (ie: directly into user mode)
*/
vm_fork(lp1, p2, flags);
- caps_fork(p1, p2, flags);
+ caps_fork(lp1->lwp_thread, lp2->lwp_thread, flags);
if (flags == (RFFDG | RFPROC)) {
mycpu->gd_cnt.v_forks++;
void
start_forked_proc(struct lwp *lp1, struct proc *p2)
{
- struct lwp *lp2;
-
- KKASSERT(p2 != NULL && p2->p_nthreads == 1);
-
- lp2 = LIST_FIRST(&p2->p_lwps);
+ struct lwp *lp2 = ONLY_LWP_IN_PROC(p2);
/*
* Move from SIDL to RUN queue, and activate the process's thread.
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
- * $DragonFly: src/sys/kern/kern_kinfo.c,v 1.4 2007/02/02 19:57:31 corecode Exp $
+ * $DragonFly: src/sys/kern/kern_kinfo.c,v 1.5 2007/02/03 17:05:57 corecode Exp $
*/
/*
kp->kp_exitstat = p->p_xstat;
kp->kp_nthreads = p->p_nthreads;
kp->kp_nice = p->p_nice;
+ kp->kp_swtime = p->p_swtime;
kp->kp_vm_map_size = p->p_vmspace->vm_map.size;
kp->kp_vm_rssize = p->p_vmspace->vm_rssize;
kl->kl_pid = lwp->lwp_proc->p_pid;
kl->kl_tid = lwp->lwp_tid;
-#ifdef notyet
kl->kl_flags = lwp->lwp_flag;
+#ifdef notyet
kl->kl_stat = lwp->lwp_stat;
#endif
kl->kl_tdflags = lwp->lwp_thread->td_flags;
kl->kl_iticks = lwp->lwp_thread->td_iticks;
kl->kl_cpticks = lwp->lwp_cpticks;
kl->kl_pctcpu = lwp->lwp_pctcpu;
- kl->kl_swtime = lwp->lwp_swtime;
kl->kl_slptime = lwp->lwp_slptime;
kl->kl_origcpu = lwp->lwp_usdata.bsd4.origcpu; /* XXX TGEN same */
kl->kl_estcpu = lwp->lwp_usdata.bsd4.estcpu;
* from: Utah $Hdr: mem.c 1.13 89/10/08$
* from: @(#)mem.c 7.2 (Berkeley) 5/9/91
* $FreeBSD: src/sys/i386/i386/mem.c,v 1.79.2.9 2003/01/04 22:58:01 njl Exp $
- * $DragonFly: src/sys/kern/kern_memio.c,v 1.28 2007/01/15 20:51:14 dillon Exp $
+ * $DragonFly: src/sys/kern/kern_memio.c,v 1.29 2007/02/03 17:05:57 corecode Exp $
*/
/*
error = EPERM;
break;
}
- if (CURSIG(curproc) != 0) {
+ if (CURSIG(curthread->td_lwp) != 0) {
/*
* Use tsleep() to get the error code right.
* It should return immediately.
* SUCH DAMAGE.
*
* $FreeBSD: src/sys/posix4/p1003_1b.c,v 1.5.2.2 2003/03/25 06:13:35 rwatson Exp $
- * $DragonFly: src/sys/kern/kern_p1003_1b.c,v 1.8 2006/06/05 07:26:10 dillon Exp $
+ * $DragonFly: src/sys/kern/kern_p1003_1b.c,v 1.9 2007/02/03 17:05:57 corecode Exp $
*/
/* p1003_1b: Real Time common code.
sys_sched_setparam(struct sched_setparam_args *uap)
{
struct proc *p = curproc;
+ struct lwp *lp;
int e;
struct sched_param sched_param;
copyin(uap->param, &sched_param, sizeof(sched_param));
if ((e = p31b_proc(p, uap->pid, &p)) == 0) {
- e = ksched_setparam(&uap->sysmsg_result, ksched, p,
+ lp = FIRST_LWP_IN_PROC(p); /* XXX lwp */
+ e = ksched_setparam(&uap->sysmsg_result, ksched, lp,
(const struct sched_param *)&sched_param);
}
return e;
{
struct proc *p = curproc;
struct proc *targetp;
+ struct lwp *lp;
struct sched_param sched_param;
int e;
targetp = p;
}
- e = ksched_getparam(&uap->sysmsg_result, ksched, targetp, &sched_param);
+ lp = FIRST_LWP_IN_PROC(targetp); /* XXX lwp */
+ e = ksched_getparam(&uap->sysmsg_result, ksched, lp, &sched_param);
if (!e)
copyout(&sched_param, uap->param, sizeof(sched_param));
sys_sched_setscheduler(struct sched_setscheduler_args *uap)
{
struct proc *p = curproc;
+ struct lwp *lp;
int e;
struct sched_param sched_param;
copyin(uap->param, &sched_param, sizeof(sched_param));
if ((e = p31b_proc(p, uap->pid, &p)) == 0) {
- e = ksched_setscheduler(&uap->sysmsg_result, ksched, p,
+ lp = FIRST_LWP_IN_PROC(p); /* XXX lwp */
+ e = ksched_setscheduler(&uap->sysmsg_result, ksched, lp,
uap->policy, (const struct sched_param *)&sched_param);
}
return e;
{
struct proc *p = curproc;
struct proc *targetp;
+ struct lwp *lp;
int e;
if (uap->pid != 0 && uap->pid != p->p_pid) {
targetp = p;
}
- e = ksched_getscheduler(&uap->sysmsg_result, ksched, targetp);
+ lp = FIRST_LWP_IN_PROC(targetp); /* XXX lwp */
+ e = ksched_getscheduler(&uap->sysmsg_result, ksched, lp);
return e;
}
{
int e;
struct proc *p = curproc;
+ struct lwp *lp = curthread->td_lwp;
if ((e = p31b_proc(p, uap->pid, &p)) == 0) {
e = ksched_rr_get_interval(&uap->sysmsg_result, ksched,
- p, uap->interval);
+ lp, uap->interval);
}
return e;
}
*
* @(#)kern_proc.c 8.7 (Berkeley) 2/14/95
* $FreeBSD: src/sys/kern/kern_proc.c,v 1.63.2.9 2003/05/08 07:47:16 kbyanc Exp $
- * $DragonFly: src/sys/kern/kern_proc.c,v 1.34 2007/02/03 10:02:01 corecode Exp $
+ * $DragonFly: src/sys/kern/kern_proc.c,v 1.35 2007/02/03 17:05:58 corecode Exp $
*/
#include <sys/param.h>
struct proclist zombproc;
struct spinlock allproc_spin;
vm_zone_t proc_zone;
+vm_zone_t lwp_zone;
vm_zone_t thread_zone;
/*
pidhashtbl = hashinit(maxproc / 4, M_PROC, &pidhash);
pgrphashtbl = hashinit(maxproc / 4, M_PROC, &pgrphash);
proc_zone = zinit("PROC", sizeof (struct proc), 0, 0, 5);
+ lwp_zone = zinit("LWP", sizeof (struct lwp), 0, 0, 5);
thread_zone = zinit("THREAD", sizeof (struct thread), 0, 0, 5);
uihashinit();
}
*
* @(#)kern_resource.c 8.5 (Berkeley) 1/21/94
* $FreeBSD: src/sys/kern/kern_resource.c,v 1.55.2.5 2001/11/03 01:41:08 ps Exp $
- * $DragonFly: src/sys/kern/kern_resource.c,v 1.30 2007/01/01 22:51:17 corecode Exp $
+ * $DragonFly: src/sys/kern/kern_resource.c,v 1.31 2007/02/03 17:05:58 corecode Exp $
*/
#include "opt_compat.h"
{
struct proc *curp = curproc;
struct ucred *cr = curp->p_ucred;
+ struct lwp *lp;
if (cr->cr_uid && cr->cr_ruid &&
cr->cr_uid != chgp->p_ucred->cr_uid &&
if (n < chgp->p_nice && suser_cred(cr, 0))
return (EACCES);
chgp->p_nice = n;
- chgp->p_usched->resetpriority(&chgp->p_lwp);
+ FOREACH_LWP_IN_PROC(lp, chgp)
+ chgp->p_usched->resetpriority(lp);
return (0);
}
{
struct proc *curp = curproc;
struct proc *p;
+ struct lwp *lp;
struct ucred *cr = curp->p_ucred;
struct rtprio rtp;
int error;
if (p == 0)
return (ESRCH);
+ /* XXX lwp */
+ lp = FIRST_LWP_IN_PROC(p);
switch (uap->function) {
case RTP_LOOKUP:
- return (copyout(&p->p_lwp.lwp_rtprio, uap->rtp, sizeof(struct rtprio)));
+ return (copyout(&lp->lwp_rtprio, uap->rtp, sizeof(struct rtprio)));
case RTP_SET:
if (cr->cr_uid && cr->cr_ruid &&
cr->cr_uid != p->p_ucred->cr_uid &&
case RTP_PRIO_IDLE:
if (rtp.prio > RTP_PRIO_MAX)
return (EINVAL);
- p->p_lwp.lwp_rtprio = rtp;
+ lp->lwp_rtprio = rtp;
return (0);
default:
return (EINVAL);
* SUCH DAMAGE.
*
* $FreeBSD: src/sys/posix4/ksched.c,v 1.7.2.1 2000/05/16 06:58:13 dillon Exp $
- * $DragonFly: src/sys/kern/kern_sched.c,v 1.7 2006/11/07 18:50:06 dillon Exp $
+ * $DragonFly: src/sys/kern/kern_sched.c,v 1.8 2007/02/03 17:05:57 corecode Exp $
*/
/* ksched: Soft real time scheduling based on "rtprio".
#define P1B_PRIO_MAX rtpprio_to_p4prio(RTP_PRIO_MIN)
static __inline int
-getscheduler(register_t *ret, struct ksched *ksched, struct proc *p)
+getscheduler(register_t *ret, struct ksched *ksched, struct lwp *lp)
{
int e = 0;
- switch (p->p_lwp.lwp_rtprio.type)
+ switch (lp->lwp_rtprio.type)
{
case RTP_PRIO_FIFO:
*ret = SCHED_FIFO;
}
int ksched_setparam(register_t *ret, struct ksched *ksched,
- struct proc *p, const struct sched_param *param)
+ struct lwp *lp, const struct sched_param *param)
{
register_t policy;
int e;
- e = getscheduler(&policy, ksched, p);
+ e = getscheduler(&policy, ksched, lp);
if (e == 0)
{
if (policy == SCHED_OTHER)
e = EINVAL;
else
- e = ksched_setscheduler(ret, ksched, p, policy, param);
+ e = ksched_setscheduler(ret, ksched, lp, policy, param);
}
return e;
}
int ksched_getparam(register_t *ret, struct ksched *ksched,
- struct proc *p, struct sched_param *param)
+ struct lwp *lp, struct sched_param *param)
{
- if (RTP_PRIO_IS_REALTIME(p->p_lwp.lwp_rtprio.type))
- param->sched_priority = rtpprio_to_p4prio(p->p_rtprio.prio);
+ if (RTP_PRIO_IS_REALTIME(lp->lwp_rtprio.type))
+ param->sched_priority = rtpprio_to_p4prio(lp->lwp_rtprio.prio);
return 0;
}
*
*/
int ksched_setscheduler(register_t *ret, struct ksched *ksched,
- struct proc *p, int policy, const struct sched_param *param)
+ struct lwp *lp, int policy, const struct sched_param *param)
{
int e = 0;
struct rtprio rtp;
rtp.type = (policy == SCHED_FIFO)
? RTP_PRIO_FIFO : RTP_PRIO_REALTIME;
- p->p_lwp.lwp_rtprio = rtp;
+ lp->lwp_rtprio = rtp;
need_user_resched();
}
else
{
rtp.type = RTP_PRIO_NORMAL;
rtp.prio = p4prio_to_rtpprio(param->sched_priority);
- p->p_lwp.lwp_rtprio = rtp;
+ lp->lwp_rtprio = rtp;
/* XXX Simply revert to whatever we had for last
* normal scheduler priorities.
return e;
}
-int ksched_getscheduler(register_t *ret, struct ksched *ksched, struct proc *p)
+int ksched_getscheduler(register_t *ret, struct ksched *ksched, struct lwp *lp)
{
- return getscheduler(ret, ksched, p);
+ return getscheduler(ret, ksched, lp);
}
/* ksched_yield: Yield the CPU.
}
int ksched_rr_get_interval(register_t *ret, struct ksched *ksched,
- struct proc *p, struct timespec *timespec)
+ struct lwp *lp, struct timespec *timespec)
{
*timespec = ksched->rr_interval;
*
* @(#)kern_sig.c 8.7 (Berkeley) 4/18/94
* $FreeBSD: src/sys/kern/kern_sig.c,v 1.72.2.17 2003/05/16 16:34:34 obrien Exp $
- * $DragonFly: src/sys/kern/kern_sig.c,v 1.61 2007/01/14 07:59:03 dillon Exp $
+ * $DragonFly: src/sys/kern/kern_sig.c,v 1.62 2007/02/03 17:05:58 corecode Exp $
*/
#include "opt_ktrace.h"
execsigs(struct proc *p)
{
struct sigacts *ps = p->p_sigacts;
+ struct lwp *lp;
int sig;
/*
* Reset stack state to the user stack.
* Clear set of signals caught on the signal stack.
*/
- p->p_sigstk.ss_flags = SS_DISABLE;
- p->p_sigstk.ss_size = 0;
- p->p_sigstk.ss_sp = 0;
- p->p_flag &= ~P_ALTSTACK;
+ lp = ONLY_LWP_IN_PROC(p);
+ lp->lwp_sigstk.ss_flags = SS_DISABLE;
+ lp->lwp_sigstk.ss_size = 0;
+ lp->lwp_sigstk.ss_sp = 0;
+ lp->lwp_flag &= ~LWP_ALTSTACK;
/*
* Reset no zombies if child dies flag as Solaris does.
*/
kern_sigprocmask(int how, sigset_t *set, sigset_t *oset)
{
struct thread *td = curthread;
- struct proc *p = td->td_proc;
+ struct lwp *lp = td->td_lwp;
int error;
if (oset != NULL)
- *oset = p->p_sigmask;
+ *oset = lp->lwp_sigmask;
error = 0;
if (set != NULL) {
switch (how) {
case SIG_BLOCK:
SIG_CANTMASK(*set);
- SIGSETOR(p->p_sigmask, *set);
+ SIGSETOR(lp->lwp_sigmask, *set);
break;
case SIG_UNBLOCK:
- SIGSETNAND(p->p_sigmask, *set);
+ SIGSETNAND(lp->lwp_sigmask, *set);
break;
case SIG_SETMASK:
SIG_CANTMASK(*set);
- p->p_sigmask = *set;
+ lp->lwp_sigmask = *set;
break;
default:
error = EINVAL;
kern_sigsuspend(struct __sigset *set)
{
struct thread *td = curthread;
+ struct lwp *lp = td->td_lwp;
struct proc *p = td->td_proc;
struct sigacts *ps = p->p_sigacts;
* save it here and mark the sigacts structure
* to indicate this.
*/
- p->p_oldsigmask = p->p_sigmask;
- p->p_flag |= P_OLDMASK;
+ lp->lwp_oldsigmask = lp->lwp_sigmask;
+ lp->lwp_flag |= LWP_OLDMASK;
SIG_CANTMASK(*set);
- p->p_sigmask = *set;
+ lp->lwp_sigmask = *set;
while (tsleep(ps, PCATCH, "pause", 0) == 0)
/* void */;
/* always return EINTR rather than ERESTART... */
kern_sigaltstack(struct sigaltstack *ss, struct sigaltstack *oss)
{
struct thread *td = curthread;
+ struct lwp *lp = td->td_lwp;
struct proc *p = td->td_proc;
- if ((p->p_flag & P_ALTSTACK) == 0)
- p->p_sigstk.ss_flags |= SS_DISABLE;
+ if ((lp->lwp_flag & LWP_ALTSTACK) == 0)
+ lp->lwp_sigstk.ss_flags |= SS_DISABLE;
if (oss)
- *oss = p->p_sigstk;
+ *oss = lp->lwp_sigstk;
if (ss) {
if (ss->ss_flags & SS_DISABLE) {
- if (p->p_sigstk.ss_flags & SS_ONSTACK)
+ if (lp->lwp_sigstk.ss_flags & SS_ONSTACK)
return (EINVAL);
- p->p_flag &= ~P_ALTSTACK;
- p->p_sigstk.ss_flags = ss->ss_flags;
+ lp->lwp_flag &= ~LWP_ALTSTACK;
+ lp->lwp_sigstk.ss_flags = ss->ss_flags;
} else {
if (ss->ss_size < p->p_sysent->sv_minsigstksz)
return (ENOMEM);
- p->p_flag |= P_ALTSTACK;
- p->p_sigstk = *ss;
+ lp->lwp_flag |= LWP_ALTSTACK;
+ lp->lwp_sigstk = *ss;
}
}
* Otherwise, post it normally.
*/
void
-trapsignal(struct proc *p, int sig, u_long code)
+trapsignal(struct lwp *lp, int sig, u_long code)
{
+ struct proc *p = lp->lwp_proc;
struct sigacts *ps = p->p_sigacts;
/*
if ((p->p_flag & P_TRACED) == 0 && SIGISMEMBER(p->p_sigcatch, sig) &&
- !SIGISMEMBER(p->p_sigmask, sig)) {
- p->p_lwp.lwp_ru.ru_nsignals++;
+ !SIGISMEMBER(lp->lwp_sigmask, sig)) {
+ lp->lwp_ru.ru_nsignals++;
#ifdef KTRACE
- if (KTRPOINT(p->p_thread, KTR_PSIG))
+ if (KTRPOINT(lp->lwp_thread, KTR_PSIG))
ktrpsig(p, sig, ps->ps_sigact[_SIG_IDX(sig)],
- &p->p_sigmask, code);
+ &lp->lwp_sigmask, code);
#endif
(*p->p_sysent->sv_sendsig)(ps->ps_sigact[_SIG_IDX(sig)], sig,
- &p->p_sigmask, code);
- SIGSETOR(p->p_sigmask, ps->ps_catchmask[_SIG_IDX(sig)]);
+ &lp->lwp_sigmask, code);
+ SIGSETOR(lp->lwp_sigmask, ps->ps_catchmask[_SIG_IDX(sig)]);
if (!SIGISMEMBER(ps->ps_signodefer, sig))
- SIGADDSET(p->p_sigmask, sig);
+ SIGADDSET(lp->lwp_sigmask, sig);
if (SIGISMEMBER(ps->ps_sigreset, sig)) {
/*
* See kern_sigaction() for origin of this code.
void
ksignal(struct proc *p, int sig)
{
- struct lwp *lp = &p->p_lwp;
+ /* XXX lwp more intelligent lwp choice needed */
+ struct lwp *lp = FIRST_LWP_IN_PROC(p);
int prop;
sig_t action;
*/
if (SIGISMEMBER(p->p_sigignore, sig) || (p->p_flag & P_WEXIT))
return;
- if (SIGISMEMBER(p->p_sigmask, sig))
+ if (SIGISMEMBER(lp->lwp_sigmask, sig))
action = SIG_HOLD;
else if (SIGISMEMBER(p->p_sigcatch, sig))
action = SIG_CATCH;
if (lp == lwkt_preempted_proc()) {
signotify();
} else if (p->p_stat == SRUN) {
- struct thread *td = p->p_thread;
+ struct thread *td = lp->lwp_thread;
KASSERT(td != NULL,
("pid %d NULL p_thread stat %d flags %08x",
{
sigset_t savedmask, set;
struct proc *p = curproc;
+ struct lwp *lp = curthread->td_lwp;
int error, sig, hz, timevalid = 0;
struct timespec rts, ets, ts;
struct timeval tv;
error = 0;
sig = 0;
SIG_CANTMASK(waitset);
- savedmask = p->p_sigmask;
+ savedmask = lp->lwp_sigmask;
if (timeout) {
if (timeout->tv_sec >= 0 && timeout->tv_nsec >= 0 &&
set = p->p_siglist;
SIGSETAND(set, waitset);
if ((sig = sig_ffs(&set)) != 0) {
- SIGFILLSET(p->p_sigmask);
- SIGDELSET(p->p_sigmask, sig);
- SIG_CANTMASK(p->p_sigmask);
- sig = issignal(p);
+ SIGFILLSET(lp->lwp_sigmask);
+ SIGDELSET(lp->lwp_sigmask, sig);
+ SIG_CANTMASK(lp->lwp_sigmask);
+ sig = issignal(lp);
/*
* It may be a STOP signal, in the case, issignal
* returns 0, because we may stop there, and new
} else
hz = 0;
- p->p_sigmask = savedmask;
- SIGSETNAND(p->p_sigmask, waitset);
+ lp->lwp_sigmask = savedmask;
+ SIGSETNAND(lp->lwp_sigmask, waitset);
error = tsleep(&p->p_sigacts, PCATCH, "sigwt", hz);
if (timeout) {
if (error == ERESTART) {
/* Retry ... */
}
- p->p_sigmask = savedmask;
+ lp->lwp_sigmask = savedmask;
if (sig) {
error = 0;
bzero(info, sizeof(*info));
* system call, return EINTR or ERESTART as appropriate.
*/
int
-iscaught(struct proc *p)
+iscaught(struct lwp *lp)
{
+ struct proc *p = lp->lwp_proc;
int sig;
if (p) {
- if ((sig = CURSIG(p)) != 0) {
+ if ((sig = CURSIG(lp)) != 0) {
if (SIGISMEMBER(p->p_sigacts->ps_sigintr, sig))
return (EINTR);
return (ERESTART);
* postsig(sig);
*/
int
-issignal(struct proc *p)
+issignal(struct lwp *lp)
{
+ struct proc *p = lp->lwp_proc;
sigset_t mask;
int sig, prop;
int traced = (p->p_flag & P_TRACED) || (p->p_stops & S_SIG);
mask = p->p_siglist;
- SIGSETNAND(mask, p->p_sigmask);
+ SIGSETNAND(mask, lp->lwp_sigmask);
if (p->p_flag & P_PPWAIT)
SIG_STOPSIGMASK(mask);
if (!SIGNOTEMPTY(mask)) { /* no signal to send */
* signal is being masked, look for other signals.
*/
SIGADDSET(p->p_siglist, sig);
- if (SIGISMEMBER(p->p_sigmask, sig))
+ if (SIGISMEMBER(lp->lwp_sigmask, sig))
continue;
/*
void
postsig(int sig)
{
- struct thread *td = curthread;
- struct proc *p = td->td_proc;
+ struct lwp *lp = curthread->td_lwp;
+ struct proc *p = lp->lwp_proc;
struct sigacts *ps = p->p_sigacts;
sig_t action;
sigset_t returnmask;
SIGDELSET(p->p_siglist, sig);
action = ps->ps_sigact[_SIG_IDX(sig)];
#ifdef KTRACE
- if (KTRPOINT(td, KTR_PSIG))
- ktrpsig(p, sig, action, p->p_flag & P_OLDMASK ?
- &p->p_oldsigmask : &p->p_sigmask, 0);
+ if (KTRPOINT(lp->lwp_thread, KTR_PSIG))
+ ktrpsig(p, sig, action, lp->lwp_flag & LWP_OLDMASK ?
+ &lp->lwp_oldsigmask : &lp->lwp_sigmask, 0);
#endif
STOPEVENT(p, S_SIG, sig);
/*
* If we get here, the signal must be caught.
*/
- KASSERT(action != SIG_IGN && !SIGISMEMBER(p->p_sigmask, sig),
+ KASSERT(action != SIG_IGN && !SIGISMEMBER(lp->lwp_sigmask, sig),
("postsig action"));
crit_enter();
* mask from before the sigsuspend is what we want
* restored after the signal processing is completed.
*/
- if (p->p_flag & P_OLDMASK) {
- returnmask = p->p_oldsigmask;
- p->p_flag &= ~P_OLDMASK;
+ if (lp->lwp_flag & LWP_OLDMASK) {
+ returnmask = lp->lwp_oldsigmask;
+ lp->lwp_flag &= ~LWP_OLDMASK;
} else {
- returnmask = p->p_sigmask;
+ returnmask = lp->lwp_sigmask;
}
- SIGSETOR(p->p_sigmask, ps->ps_catchmask[_SIG_IDX(sig)]);
+
+ SIGSETOR(lp->lwp_sigmask, ps->ps_catchmask[_SIG_IDX(sig)]);
if (!SIGISMEMBER(ps->ps_signodefer, sig))
- SIGADDSET(p->p_sigmask, sig);
+ SIGADDSET(lp->lwp_sigmask, sig);
crit_exit();
- p->p_lwp.lwp_ru.ru_nsignals++;
+ lp->lwp_ru.ru_nsignals++;
if (p->p_sig != sig) {
code = 0;
} else {
*
* @(#)kern_synch.c 8.9 (Berkeley) 5/19/95
* $FreeBSD: src/sys/kern/kern_synch.c,v 1.87.2.6 2002/10/13 07:29:53 kbyanc Exp $
- * $DragonFly: src/sys/kern/kern_synch.c,v 1.71 2007/01/14 07:59:03 dillon Exp $
+ * $DragonFly: src/sys/kern/kern_synch.c,v 1.72 2007/02/03 17:05:58 corecode Exp $
*/
#include "opt_ktrace.h"
* can set CCPU_SHIFT to (FSHIFT + 1) which will use a slower/less-accurate
* (more general) method of calculating the %age of CPU used by a process.
*
- * decay 95% of `p_pctcpu' in 60 seconds; see CCPU_SHIFT before changing
+ * decay 95% of `lwp_pctcpu' in 60 seconds; see CCPU_SHIFT before changing
*/
#define CCPU_SHIFT 11
static int
schedcpu_stats(struct proc *p, void *data __unused)
{
+ struct lwp *lp;
+
+ /* XXX lwp */
+ lp = FIRST_LWP_IN_PROC(p);
crit_enter();
p->p_swtime++;
if (p->p_stat == SSLEEP)
- p->p_slptime++;
+ lp->lwp_slptime++;
/*
* Only recalculate processes that are active or have slept
* less then 2 seconds. The schedulers understand this.
*/
- if (p->p_slptime <= 1) {
- p->p_usched->recalculate(&p->p_lwp);
+ if (lp->lwp_slptime <= 1) {
+ p->p_usched->recalculate(lp);
} else {
- p->p_pctcpu = (p->p_pctcpu * ccpu) >> FSHIFT;
+ lp->lwp_pctcpu = (lp->lwp_pctcpu * ccpu) >> FSHIFT;
}
crit_exit();
return(0);
schedcpu_resource(struct proc *p, void *data __unused)
{
u_int64_t ttime;
+ struct lwp *lp;
+ /* XXX lwp */
+ lp = FIRST_LWP_IN_PROC(p);
crit_enter();
if (p->p_stat == SIDL ||
(p->p_flag & P_ZOMBIE) ||
p->p_limit == NULL ||
- p->p_thread == NULL
+ lp->lwp_thread == NULL
) {
crit_exit();
return(0);
}
- ttime = p->p_thread->td_sticks + p->p_thread->td_uticks;
+ ttime = lp->lwp_thread->td_sticks + lp->lwp_thread->td_uticks;
switch(plimit_testcpulimit(p->p_limit, ttime)) {
case PLIMIT_TESTCPU_KILL:
tsleep(void *ident, int flags, const char *wmesg, int timo)
{
struct thread *td = curthread;
+ struct lwp *lp = td->td_lwp;
struct proc *p = td->td_proc; /* may be NULL */
globaldata_t gd;
int sig;
/*
* Setup for the current process (if this is a process).
*/
- if (p) {
+ if (lp) {
if (catch) {
/*
* Early termination if PCATCH was set and a
* Early termination only occurs when tsleep() is
* entered while in a normal SRUN state.
*/
- if ((sig = CURSIG(p)) != 0)
+ if ((sig = CURSIG(lp)) != 0)
goto resume;
/*
*/
if (flags & PNORESCHED)
td->td_flags |= TDF_NORESCHED;
- p->p_usched->release_curproc(&p->p_lwp);
- p->p_slptime = 0;
+ p->p_usched->release_curproc(lp);
+ lp->lwp_slptime = 0;
}
/*
/*
* Beddy bye bye.
*/
- if (p) {
+ if (lp) {
/*
* Ok, we are sleeping. Place us in the SSLEEP state.
*/
KKASSERT((p->p_flag & P_ONRUNQ) == 0);
p->p_stat = SSLEEP;
- p->p_lwp.lwp_ru.ru_nvcsw++;
+ lp->lwp_ru.ru_nvcsw++;
lwkt_switch();
/*
* slept for over a second, recalculate our estcpu.
*/
p->p_stat = SRUN;
- if (p->p_slptime)
- p->p_usched->recalculate(&p->p_lwp);
- p->p_slptime = 0;
+ if (lp->lwp_slptime)
+ p->p_usched->recalculate(lp);
+ lp->lwp_slptime = 0;
} else {
lwkt_switch();
}
if (catch && error == 0) {
if ((p->p_flag & P_MAILBOX) && sig == 0) {
error = EINTR;
- } else if ((sig != 0 || (sig = CURSIG(p)))) {
+ } else if (sig != 0 || (sig = CURSIG(lp))) {
if (SIGISMEMBER(p->p_sigacts->ps_sigintr, sig))
error = EINTR;
else
void
setrunnable(struct proc *p)
{
+ /* XXX lwp */
+ struct lwp *lp = FIRST_LWP_IN_PROC(p);
crit_enter();
ASSERT_MP_LOCK_HELD(curthread);
p->p_flag &= ~P_STOPPED;
if (p->p_stat == SSLEEP && (p->p_flag & P_BREAKTSLEEP)) {
- unsleep_and_wakeup_thread(p->p_thread);
+ unsleep_and_wakeup_thread(lp->lwp_thread);
}
crit_exit();
}
static int
loadav_count_runnable(struct proc *p, void *data)
{
+ struct lwp *lp;
int *nrunp = data;
thread_t td;
+ /* XXX lwp */
+ lp = FIRST_LWP_IN_PROC(p);
switch (p->p_stat) {
case SRUN:
- if ((td = p->p_thread) == NULL)
+ if ((td = lp->lwp_thread) == NULL)
break;
if (td->td_flags & TDF_BLOCKED)
break;
* and I certainly make no claims as to its fitness for *any* purpose.
*
* $FreeBSD: src/sys/kern/kern_threads.c,v 1.15 1999/08/28 00:46:15 peter Exp $
- * $DragonFly: src/sys/kern/kern_threads.c,v 1.9 2006/06/05 07:26:10 dillon Exp $
+ * $DragonFly: src/sys/kern/kern_threads.c,v 1.10 2007/02/03 17:05:58 corecode Exp $
*/
#include <sys/param.h>
#include <sys/sysproto.h>
#include <sys/uio.h> /* uio_yield() fixme */
+
+/*
+ * XXX lwp
+ *
+ * I am unhappy code, please remove me
+ */
+
+
/*
* Low level support for sleep/wakeup paradigm
* If a timeout is specified:
}
pSlave->p_wakeup++;
- if((pSlave->p_stat == SSLEEP) && (pSlave->p_wchan == pSlave)) {
+ if((pSlave->p_stat == SSLEEP) &&
+ (FIRST_LWP_IN_PROC(pSlave)->lwp_wchan == pSlave)) {
wakeup(pSlave);
return(0);
}
*
* @(#)kern_time.c 8.1 (Berkeley) 6/10/93
* $FreeBSD: src/sys/kern/kern_time.c,v 1.68.2.1 2002/10/01 08:00:41 bde Exp $
- * $DragonFly: src/sys/kern/kern_time.c,v 1.38 2006/12/23 23:47:54 swildner Exp $
+ * $DragonFly: src/sys/kern/kern_time.c,v 1.39 2007/02/03 17:05:58 corecode Exp $
*/
#include <sys/param.h>
lwkt_switch();
systimer_del(&info); /* make sure it's gone */
}
- error = iscaught(td->td_proc);
+ error = iscaught(td->td_lwp);
} else if (tv.tv_sec == 0) {
error = tsleep(&nanowait, PCATCH, "nanslp", ticks);
} else {
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
- * $DragonFly: src/sys/kern/kern_usched.c,v 1.7 2006/12/23 00:35:04 swildner Exp $
+ * $DragonFly: src/sys/kern/kern_usched.c,v 1.8 2007/02/03 17:05:58 corecode Exp $
*/
#include <sys/errno.h>
* disassociation' and another ABI call to do a 'full
* reassociation'
*/
+ /* XXX lwp have to deal with multiple lwps here */
+ if (p->p_nthreads != 1)
+ return (EINVAL);
if (item && item != p->p_usched) {
- p->p_usched->release_curproc(&p->p_lwp);
+ /* XXX lwp */
+ p->p_usched->release_curproc(ONLY_LWP_IN_PROC(p));
p->p_usched = item;
} else if (item == NULL) {
error = EINVAL;
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
- * $DragonFly: src/sys/kern/lwkt_caps.c,v 1.11 2006/12/23 00:35:04 swildner Exp $
+ * $DragonFly: src/sys/kern/lwkt_caps.c,v 1.12 2007/02/03 17:05:58 corecode Exp $
*/
/*
* forked condition and reforge the connection.
*/
void
-caps_fork(struct proc *p1, struct proc *p2, int flags)
+caps_fork(struct thread *td1, struct thread *td2, int flags)
{
caps_kinfo_t caps1;
caps_kinfo_t caps2;
- thread_t td1;
- thread_t td2;
-
- td1 = p1->p_thread;
- td2 = p2->p_thread;
/*
* Create dummy entries with the same id's as the originals. Note
* NOTE! This file may be compiled for userland libraries as well as for
* the kernel.
*
- * $DragonFly: src/sys/kern/lwkt_msgport.c,v 1.35 2006/11/07 18:50:06 dillon Exp $
+ * $DragonFly: src/sys/kern/lwkt_msgport.c,v 1.36 2007/02/03 17:05:58 corecode Exp $
*/
#ifdef _KERNEL
* completion after sending an abort request.
*/
if (msg->ms_flags & MSGF_PCATCH) {
- if (sentabort == 0 && CURSIG(port->mp_td->td_proc)) {
+ if (sentabort == 0 && CURSIG(port->mp_td->td_lwp)) {
sentabort = 1;
lwkt_abortmsg(msg);
continue;
*
* @(#)sys_generic.c 8.5 (Berkeley) 1/21/94
* $FreeBSD: src/sys/kern/sys_generic.c,v 1.55.2.10 2001/03/17 10:39:32 peter Exp $
- * $DragonFly: src/sys/kern/sys_generic.c,v 1.39 2007/01/08 21:41:56 dillon Exp $
+ * $DragonFly: src/sys/kern/sys_generic.c,v 1.40 2007/02/03 17:05:58 corecode Exp $
*/
#include "opt_ktrace.h"
selrecord(struct thread *selector, struct selinfo *sip)
{
struct proc *p;
+ struct lwp *lp;
pid_t mypid;
if ((p = selector->td_proc) == NULL)
mypid = p->p_pid;
if (sip->si_pid == mypid)
return;
+ /* XXX lwp
+ * pfind ? this is seriously broken code for LWP
+ */
if (sip->si_pid && (p = pfind(sip->si_pid)) &&
- p->p_wchan == (caddr_t)&selwait) {
+ (lp = FIRST_LWP_IN_PROC(p)) &&
+ lp->lwp_wchan == (caddr_t)&selwait) {
sip->si_flags |= SI_COLL;
} else {
sip->si_pid = mypid;
p = pfind(sip->si_pid);
sip->si_pid = 0;
if (p != NULL) {
+ /* XXX lwp */
+ struct lwp *lp = FIRST_LWP_IN_PROC(p);
crit_enter();
- if (p->p_wchan == (caddr_t)&selwait) {
+ if (lp->lwp_wchan == (caddr_t)&selwait) {
/*
* Flag the process to break the tsleep when
* setrunnable is called, but only call setrunnable
* SUCH DAMAGE.
*
* $FreeBSD: src/sys/kern/sys_process.c,v 1.51.2.6 2003/01/08 03:06:45 kan Exp $
- * $DragonFly: src/sys/kern/sys_process.c,v 1.26 2006/12/28 21:24:01 dillon Exp $
+ * $DragonFly: src/sys/kern/sys_process.c,v 1.27 2007/02/03 17:05:58 corecode Exp $
*/
#include <sys/param.h>
kern_ptrace(struct proc *curp, int req, pid_t pid, void *addr, int data, int *res)
{
struct proc *p, *pp;
+ struct lwp *lp;
struct iovec iov;
struct uio uio;
struct ptrace_io_desc *piod;
return EINVAL;
}
+ /* XXX lwp */
+ lp = FIRST_LWP_IN_PROC(p);
#ifdef FIX_SSTEP
/*
* Single step fixup ala procfs
PHOLD(p);
if (req == PT_STEP) {
- if ((error = ptrace_single_step (&p->p_lwp))) {
+ if ((error = ptrace_single_step (lp))) {
PRELE(p);
return error;
}
}
if (addr != (void *)1) {
- if ((error = ptrace_set_pc (p,
+ if ((error = ptrace_set_pc (lp,
(u_long)(uintfptr_t)addr))) {
PRELE(p);
return error;
uio.uio_resid = sizeof(int);
uio.uio_segflg = UIO_SYSSPACE;
uio.uio_rw = write ? UIO_WRITE : UIO_READ;
- uio.uio_td = curp->p_thread;
+ uio.uio_td = curthread;
error = procfs_domem(curp, p, NULL, &uio);
if (uio.uio_resid != 0) {
/*
uio.uio_offset = (off_t)(uintptr_t)piod->piod_offs;
uio.uio_resid = piod->piod_len;
uio.uio_segflg = UIO_USERSPACE;
- uio.uio_td = curp->p_thread;
+ uio.uio_td = curthread;
switch (piod->piod_op) {
case PIOD_READ_D:
case PIOD_READ_I:
uio.uio_resid = sizeof(struct reg);
uio.uio_segflg = UIO_SYSSPACE;
uio.uio_rw = write ? UIO_WRITE : UIO_READ;
- uio.uio_td = curp->p_thread;
+ uio.uio_td = curthread;
return (procfs_doregs(curp, p, NULL, &uio));
}
#endif /* defined(PT_SETREGS) || defined(PT_GETREGS) */
uio.uio_resid = sizeof(struct fpreg);
uio.uio_segflg = UIO_SYSSPACE;
uio.uio_rw = write ? UIO_WRITE : UIO_READ;
- uio.uio_td = curp->p_thread;
+ uio.uio_td = curthread;
return (procfs_dofpregs(curp, p, NULL, &uio));
}
#endif /* defined(PT_SETFPREGS) || defined(PT_GETFPREGS) */
uio.uio_resid = sizeof(struct dbreg);
uio.uio_segflg = UIO_SYSSPACE;
uio.uio_rw = write ? UIO_WRITE : UIO_READ;
- uio.uio_td = curp->p_thread;
+ uio.uio_td = curthread;
return (procfs_dodbregs(curp, p, NULL, &uio));
}
#endif /* defined(PT_SETDBREGS) || defined(PT_GETDBREGS) */
*
* @(#)tty.c 8.8 (Berkeley) 1/21/94
* $FreeBSD: src/sys/kern/tty.c,v 1.129.2.5 2002/03/11 01:32:31 dd Exp $
- * $DragonFly: src/sys/kern/tty.c,v 1.35 2007/01/01 22:51:17 corecode Exp $
+ * $DragonFly: src/sys/kern/tty.c,v 1.36 2007/02/03 17:05:58 corecode Exp $
*/
/*-
ttioctl(struct tty *tp, u_long cmd, void *data, int flag)
{
struct thread *td = curthread;
+ struct lwp *lp = td->td_lwp;
struct proc *p = td->td_proc;
int error;
#endif
while (isbackground(p, tp) && !(p->p_flag & P_PPWAIT) &&
!SIGISMEMBER(p->p_sigignore, SIGTTOU) &&
- !SIGISMEMBER(p->p_sigmask, SIGTTOU)) {
+ !SIGISMEMBER(lp->lwp_sigmask, SIGTTOU)) {
if (p->p_pgrp->pg_jobc == 0)
return (EIO);
pgsignal(p->p_pgrp, SIGTTOU, 1);
tcflag_t lflag;
cc_t *cc = tp->t_cc;
struct proc *pp;
+ struct lwp *lp;
int first, error = 0;
int has_stime = 0, last_cc = 0;
long slp = 0; /* XXX this should be renamed `timo'. */
struct timeval stime;
+ lp = curthread->td_lwp;
+
loop:
crit_enter();
lflag = tp->t_lflag;
if ((pp = curproc) && isbackground(pp, tp)) {
crit_exit();
if (SIGISMEMBER(pp->p_sigignore, SIGTTIN) ||
- SIGISMEMBER(pp->p_sigmask, SIGTTIN) ||
+ SIGISMEMBER(lp->lwp_sigmask, SIGTTIN) ||
(pp->p_flag & P_PPWAIT) || pp->p_pgrp->pg_jobc == 0)
return (EIO);
pgsignal(pp->p_pgrp, SIGTTIN, 1);
char *cp = NULL;
int cc, ce;
struct proc *pp;
+ struct lwp *lp;
int i, hiwat, cnt, error;
char obuf[OBUFSIZ];
+ lp = curthread->td_lwp;
hiwat = tp->t_ohiwat;
cnt = uio->uio_resid;
error = 0;
if ((pp = curproc) && isbackground(pp, tp) &&
ISSET(tp->t_lflag, TOSTOP) && !(pp->p_flag & P_PPWAIT) &&
!SIGISMEMBER(pp->p_sigignore, SIGTTOU) &&
- !SIGISMEMBER(pp->p_sigmask, SIGTTOU)) {
+ !SIGISMEMBER(lp->lwp_sigmask, SIGTTOU)) {
if (pp->p_pgrp->pg_jobc == 0) {
error = EIO;
goto out;
ttyinfo(struct tty *tp)
{
struct proc *p, *pick;
+ struct lwp *lp;
struct rusage ru;
int tmp;
* in particular the wmesg, require a critical section for
* safe access (YYY and we are still not MP safe).
*
- * NOTE: p_wmesg is p_thread->td_wmesg, and p_comm is
- * p_thread->td_comm.
+ * NOTE: lwp_wmesg is lwp_thread->td_wmesg.
*/
char buf[64];
const char *str;
pick = p;
}
+ /* XXX lwp */
+ lp = FIRST_LWP_IN_PROC(pick);
+ if (lp == NULL) {
+ ttyprintf(tp, "foreground process without lwp\n");
+ tp->t_rocount = 0;
+ return;
+ }
+
/*
* Figure out what wait/process-state message, and command
* buffer to present
*/
+ /*
+ * XXX lwp This is a horrible mixture. We need to rework this
+ * as soon as lwps have their own runnable status.
+ */
if (pick->p_flag & P_WEXIT)
str = "exiting";
else if (pick->p_stat == SRUN)
str = "running";
else if (pick->p_stat == SIDL)
str = "spawning";
- else if (pick->p_wmesg) /* p_thread must not be NULL */
- str = pick->p_wmesg;
+ else if (lp->lwp_wmesg) /* lwp_thread must not be NULL */
+ str = lp->lwp_wmesg;
else
str = "iowait";
* 'pick' becomes invalid the moment we exit the critical
* section.
*/
- if (pick->p_thread && (pick->p_flag & P_SWAPPEDOUT) == 0) {
+ if (lp->lwp_thread && (pick->p_flag & P_SWAPPEDOUT) == 0) {
calcru_proc(pick, &ru);
isinmem = 1;
} else {
isinmem = 0;
}
- pctcpu = (pick->p_pctcpu * 10000 + FSCALE / 2) >> FSHIFT;
+ pctcpu = (lp->lwp_pctcpu * 10000 + FSCALE / 2) >> FSHIFT;
if (pick->p_stat == SIDL || (pick->p_flag & P_ZOMBIE))
vmsz = 0;
static int
proc_compare(struct proc *p1, struct proc *p2)
{
-
+ struct lwp *lp1, *lp2;
if (p1 == NULL)
return (1);
+
+ /* XXX lwp */
+ lp1 = FIRST_LWP_IN_PROC(p1);
+ lp2 = FIRST_LWP_IN_PROC(p2);
+
/*
* see if at least one of them is runnable
*/
/*
* tie - favor one with highest recent cpu utilization
*/
- if (p2->p_cpticks > p1->p_cpticks)
+ if (lp2->lwp_cpticks > lp1->lwp_cpticks)
return (1);
- if (p1->p_cpticks > p2->p_cpticks)
+ if (lp1->lwp_cpticks > lp2->lwp_cpticks)
return (0);
return (p2->p_pid > p1->p_pid); /* tie - return highest pid */
}
/*
* pick the one with the smallest sleep time
*/
- if (p2->p_slptime > p1->p_slptime)
+ if (lp2->lwp_slptime > lp1->lwp_slptime)
return (0);
- if (p1->p_slptime > p2->p_slptime)
+ if (lp1->lwp_slptime > lp2->lwp_slptime)
return (1);
/*
* favor one sleeping in a non-interruptible sleep
*
* @(#)tty_pty.c 8.4 (Berkeley) 2/20/95
* $FreeBSD: src/sys/kern/tty_pty.c,v 1.74.2.4 2002/02/20 19:58:13 dillon Exp $
- * $DragonFly: src/sys/kern/tty_pty.c,v 1.18 2006/12/23 23:47:54 swildner Exp $
+ * $DragonFly: src/sys/kern/tty_pty.c,v 1.19 2007/02/03 17:05:58 corecode Exp $
*/
/*
struct proc *p = curproc;
struct tty *tp = dev->si_tty;
struct pt_ioctl *pti = dev->si_drv1;
+ struct lwp *lp;
+
int error = 0;
+ lp = curthread->td_lwp;
+
again:
if (pti->pt_flags & PF_REMOTE) {
while (isbackground(p, tp)) {
if (SIGISMEMBER(p->p_sigignore, SIGTTIN) ||
- SIGISMEMBER(p->p_sigmask, SIGTTIN) ||
+ SIGISMEMBER(lp->lwp_sigmask, SIGTTIN) ||
p->p_pgrp->pg_jobc == 0 || p->p_flag & P_PPWAIT)
return (EIO);
pgsignal(p->p_pgrp, SIGTTIN, 1);
* of the author. This software is distributed AS-IS.
*
* $FreeBSD: src/sys/kern/vfs_aio.c,v 1.70.2.28 2003/05/29 06:15:35 alc Exp $
- * $DragonFly: src/sys/kern/vfs_aio.c,v 1.34 2007/01/01 22:51:17 corecode Exp $
+ * $DragonFly: src/sys/kern/vfs_aio.c,v 1.35 2007/02/03 17:05:58 corecode Exp $
*/
/*
}
/* aiocbe is going away, we need to destroy any knotes */
- knote_remove(p->p_thread, &aiocbe->klist);
+ /* XXX lwp knote wants a thread, but only cares about the process */
+ knote_remove(FIRST_LWP_IN_PROC(p)->lwp_thread, &aiocbe->klist);
if ((ki->kaio_flags & KAIO_WAKEUP) || ((ki->kaio_flags & KAIO_RUNDOWN)
&& ((ki->kaio_buffer_count == 0) && (ki->kaio_queue_count == 0)))) {
struct lwp *lp, *nlp;
struct proc *np;
- lp = &proc0.p_lwp;
+ lp = &lwp0;
error = fork1(lp, RFPROC|RFMEM|RFNOWAIT, &np);
if (error)
return error;
- nlp = LIST_FIRST(&np->p_lwps);
+ nlp = ONLY_LWP_IN_PROC(np);
cpu_set_fork_handler(nlp, aio_daemon, curproc);
start_forked_proc(lp, np);
kev.filter = EVFILT_AIO;
kev.flags = EV_ADD | EV_ENABLE | EV_FLAG1;
kev.data = (intptr_t)aiocbe;
- error = kqueue_register(kq, &kev, p->p_thread);
+ /* XXX lwp kqueue_register takes a thread, but only uses its proc */
+ error = kqueue_register(kq, &kev, FIRST_LWP_IN_PROC(p)->lwp_thread);
aqueue_fail:
if (error) {
fdrop(fp);
* SUCH DAMAGE.
*
* $FreeBSD: src/sys/netncp/ncp_ncp.c,v 1.3 1999/10/29 10:21:07 bp Exp $
- * $DragonFly: src/sys/netproto/ncp/ncp_ncp.c,v 1.10 2006/12/22 23:57:54 swildner Exp $
+ * $DragonFly: src/sys/netproto/ncp/ncp_ncp.c,v 1.11 2007/02/03 17:05:58 corecode Exp $
*
* Core of NCP protocol
*/
ncp_chkintr(struct ncp_conn *conn, struct thread *td)
{
sigset_t tmpset;
+ struct lwp *lp = td->td_lwp;
struct proc *p = td->td_proc;
if (p == NULL)
return 0;
tmpset = p->p_siglist;
- SIGSETNAND(tmpset, p->p_sigmask);
+ SIGSETOR(tmpset, lp->lwp_siglist);
+ SIGSETNAND(tmpset, lp->lwp_sigmask);
SIGSETNAND(tmpset, p->p_sigignore);
- if (SIGNOTEMPTY(p->p_siglist) && NCP_SIGMASK(tmpset))
+ if (SIGNOTEMPTY(tmpset) && NCP_SIGMASK(tmpset))
return EINTR;
return 0;
}
* SUCH DAMAGE.
*
* $FreeBSD: src/sys/netsmb/smb_iod.c,v 1.1.2.2 2002/04/23 03:45:01 bp Exp $
- * $DragonFly: src/sys/netproto/smb/smb_iod.c,v 1.14 2006/09/05 00:55:49 dillon Exp $
+ * $DragonFly: src/sys/netproto/smb/smb_iod.c,v 1.15 2007/02/03 17:05:58 corecode Exp $
*/
#include <sys/param.h>
kfree(iod, M_SMBIOD);
return error;
}
- iod->iod_td = newp->p_thread;
+ /* XXX lwp */
+ iod->iod_td = ONLY_LWP_IN_PROC(newp)->lwp_thread;
return 0;
}
* SUCH DAMAGE.
*
* $FreeBSD: src/sys/netsmb/smb_subr.c,v 1.1.2.2 2001/09/03 08:55:11 bp Exp $
- * $DragonFly: src/sys/netproto/smb/smb_subr.c,v 1.25 2007/01/01 22:51:18 corecode Exp $
+ * $DragonFly: src/sys/netproto/smb/smb_subr.c,v 1.26 2007/02/03 17:05:58 corecode Exp $
*/
#include <sys/param.h>
#include <sys/systm.h>
{
sigset_t tmpset;
struct proc *p;
+ struct lwp *lp;
if (td == NULL || (p = td->td_proc) == NULL)
return 0;
+ lp = td->td_lwp;
tmpset = p->p_siglist;
- SIGSETNAND(tmpset, p->p_sigmask);
+ SIGSETOR(tmpset, lp->lwp_siglist);
+ SIGSETNAND(tmpset, lp->lwp_sigmask);
SIGSETNAND(tmpset, p->p_sigignore);
- if (SIGNOTEMPTY(p->p_siglist) && SMB_SIGMASK(tmpset))
+ if (SIGNOTEMPTY(tmpset) && SMB_SIGMASK(tmpset))
return EINTR;
return 0;
}
struct proc *p2;
struct lwp *lp2;
- error = fork1(&proc0.p_lwp, RFMEM | RFFDG | RFPROC | flags, &p2);
+ error = fork1(&lwp0, RFMEM | RFFDG | RFPROC | flags, &p2);
if (error)
return error;
p2->p_flag |= P_SYSTEM;
p2->p_procsig->ps_flag |= PS_NOCLDWAIT;
- lp2 = LIST_FIRST(&p2->p_lwps);
+ lp2 = ONLY_LWP_IN_PROC(p2);
/* set up arg0 for 'ps', et al */
__va_start(ap, fmt);
/* call the processes' main()... */
cpu_set_fork_handler(lp2, func, arg);
- start_forked_proc(&proc0.p_lwp, p2);
+ start_forked_proc(&lwp0, p2);
return 0;
}
*
* from: @(#)machdep.c 7.4 (Berkeley) 6/3/91
* $FreeBSD: src/sys/i386/i386/machdep.c,v 1.385.2.30 2003/05/31 08:48:05 alc Exp $
- * $DragonFly: src/sys/platform/pc32/i386/machdep.c,v 1.117 2007/01/16 07:16:20 dillon Exp $
+ * $DragonFly: src/sys/platform/pc32/i386/machdep.c,v 1.118 2007/02/03 17:05:58 corecode Exp $
*/
#include "use_apm.h"
sf.sf_uc.uc_mcontext.mc_xflags |= PGEX_MAILBOX;
/* Allocate and validate space for the signal handler context. */
- /* XXX lwp flags */
- if ((p->p_flag & P_ALTSTACK) != 0 && !oonstack &&
+ if ((lp->lwp_flag & LWP_ALTSTACK) != 0 && !oonstack &&
SIGISMEMBER(psp->ps_sigonstack, sig)) {
sfp = (struct sigframe *)(lp->lwp_sigstk.ss_sp +
lp->lwp_sigstk.ss_size - sizeof(struct sigframe));
/* go back to user mode if both flags are set */
if ((eflags & PSL_VIP) && (eflags & PSL_VIF))
- trapsignal(lp->lwp_proc, SIGBUS, 0);
+ trapsignal(lp, SIGBUS, 0);
if (vm86->vm86_has_vme) {
eflags = (tf->tf_eflags & ~VME_USERCHANGE) |
cs = ucp->uc_mcontext.mc_cs;
if (!CS_SECURE(cs)) {
kprintf("sigreturn: cs = 0x%x\n", cs);
- trapsignal(lp->lwp_proc, SIGBUS, T_PROTFLT);
+ trapsignal(lp, SIGBUS, T_PROTFLT);
return(EINVAL);
}
bcopy(&ucp->uc_mcontext.mc_gs, regs, sizeof(struct trapframe));
* Clear registers on exec
*/
void
-setregs(struct lwp *lp, u_long entry, u_long stack, u_long ps_strings)
+exec_setregs(u_long entry, u_long stack, u_long ps_strings)
{
+ struct thread *td = curthread;
+ struct lwp *lp = td->td_lwp;
+ struct pcb *pcb = td->td_pcb;
struct trapframe *regs = lp->lwp_md.md_regs;
- struct pcb *pcb = lp->lwp_thread->td_pcb;
/* was i386_user_cleanup() in NetBSD */
user_ldt_free(pcb);
pcb->pcb_dr3 = 0;
pcb->pcb_dr6 = 0;
pcb->pcb_dr7 = 0;
- if (pcb == curthread->td_pcb) {
+ if (pcb == td->td_pcb) {
/*
* Clear the debug registers on the running
* CPU, otherwise they will end up affecting
* traps to the emulator (if it is done at all) mainly because
* emulators don't provide an entry point for initialization.
*/
- lp->lwp_thread->td_pcb->pcb_flags &= ~FP_SOFTFP;
+ pcb->pcb_flags &= ~FP_SOFTFP;
/*
* note: do not set CR0_TS here. npxinit() must do it after clearing
thread0.td_pcb->pcb_flags = 0;
thread0.td_pcb->pcb_cr3 = (int)IdlePTD; /* should already be setup */
thread0.td_pcb->pcb_ext = 0;
- proc0.p_lwp.lwp_md.md_regs = &proc0_tf;
+ lwp0.lwp_md.md_regs = &proc0_tf;
}
/*
#endif /* defined(I586_CPU) && !NO_F00F_HACK */
int
-ptrace_set_pc(struct proc *p, unsigned long addr)
+ptrace_set_pc(struct lwp *lp, unsigned long addr)
{
- p->p_md.md_regs->tf_eip = addr;
+ lp->lwp_md.md_regs->tf_eip = addr;
return (0);
}
*
* from: 386BSD 0.1
* $FreeBSD: src/sys/i386/i386/math_emulate.c,v 1.35 1999/08/28 00:43:47 peter Exp $
- * $DragonFly: src/sys/platform/pc32/i386/math_emulate.c,v 1.8 2006/12/23 00:27:03 swildner Exp $
+ * $DragonFly: src/sys/platform/pc32/i386/math_emulate.c,v 1.9 2007/02/03 17:05:58 corecode Exp $
*/
/*
tEAX, tECX, tEDX, tEBX, tESP, tEBP, tESI, tEDI
};
-#define REG(x) (((int *)curproc->p_md.md_regs)[__regoffset[(x)]])
+#define REG(x) (((int *)curthread->td_lwp->lwp_md.md_regs)[__regoffset[(x)]])
static char *
sib(struct trapframe *info, int mod)
*
* from: @(#)pmap.c 7.7 (Berkeley) 5/12/91
* $FreeBSD: src/sys/i386/i386/pmap.c,v 1.250.2.18 2002/03/06 22:48:53 silby Exp $
- * $DragonFly: src/sys/platform/pc32/i386/pmap.c,v 1.72 2007/01/15 09:28:36 dillon Exp $
+ * $DragonFly: src/sys/platform/pc32/i386/pmap.c,v 1.73 2007/02/03 17:05:58 corecode Exp $
*/
/*
void
pmap_init_proc(struct proc *p, struct thread *td)
{
+ struct lwp *lp = ONLY_LWP_IN_PROC(p);
+
p->p_addr = (void *)td->td_kstack;
- p->p_thread = td;
+ lp->lwp_thread = td;
td->td_proc = p;
- td->td_lwp = &p->p_lwp;
+ td->td_lwp = lp;
td->td_switch = cpu_heavy_switch;
#ifdef SMP
KKASSERT(td->td_mpcount == 1);
struct thread *
pmap_dispose_proc(struct proc *p)
{
- struct thread *td;
+ struct thread *td = NULL;
+ struct lwp *lp;
KASSERT(p->p_lock == 0, ("attempt to dispose referenced proc! %p", p));
- if ((td = p->p_thread) != NULL) {
- p->p_thread = NULL;
+ lp = ONLY_LWP_IN_PROC(p);
+ if (lp != NULL && (td = lp->lwp_thread) != NULL) {
td->td_proc = NULL;
+ td->td_lwp = NULL;
+ lp->lwp_thread = NULL;
}
p->p_addr = NULL;
return(td);
{
pmap_t pmap;
+ KKASSERT((p == curproc));
+
pmap = vmspace_pmap(p->p_vmspace);
#if defined(SMP)
atomic_set_int(&pmap->pm_active, 1 << mycpu->gd_cpuid);
#if defined(SWTCH_OPTIM_STATS)
tlb_flush_count++;
#endif
- p->p_thread->td_pcb->pcb_cr3 = vtophys(pmap->pm_pdir);
- load_cr3(p->p_thread->td_pcb->pcb_cr3);
+ curthread->td_pcb->pcb_cr3 = vtophys(pmap->pm_pdir);
+ load_cr3(curthread->td_pcb->pcb_cr3);
}
void
*
* From:
* $FreeBSD: src/sys/i386/i386/procfs_machdep.c,v 1.14 1999/10/11 14:50:03 peter Exp $
- * $DragonFly: src/sys/platform/pc32/i386/procfs_machdep.c,v 1.7 2006/11/07 20:48:15 dillon Exp $
+ * $DragonFly: src/sys/platform/pc32/i386/procfs_machdep.c,v 1.8 2007/02/03 17:05:58 corecode Exp $
*/
/*
int
procfs_read_regs(struct proc *p, struct reg *regs)
{
+ struct lwp *lp;
+
if (p->p_flag & P_SWAPPEDOUT)
return (EIO);
- return (fill_regs(&p->p_lwp, regs));
+ /* XXX lwp */
+ lp = FIRST_LWP_IN_PROC(p);
+ return (fill_regs(lp, regs));
}
int
procfs_write_regs(struct proc *p, struct reg *regs)
{
+ struct lwp *lp;
+
if (p->p_flag & P_SWAPPEDOUT)
return (EIO);
- return (set_regs(&p->p_lwp, regs));
+
+ /* XXX lwp */
+ lp = FIRST_LWP_IN_PROC(p);
+ return (set_regs(lp, regs));
}
int
procfs_read_dbregs(struct proc *p, struct dbreg *dbregs)
{
+ struct lwp *lp;
+
if (p->p_flag & P_SWAPPEDOUT)
return (EIO);
- return (fill_dbregs(&p->p_lwp, dbregs));
+
+ /* XXX lwp */
+ lp = FIRST_LWP_IN_PROC(p);
+ return (fill_dbregs(lp, dbregs));
}
int
procfs_write_dbregs(struct proc *p, struct dbreg *dbregs)
{
+ struct lwp *lp;
+
if (p->p_flag & P_SWAPPEDOUT)
return (EIO);
- return (set_dbregs(&p->p_lwp, dbregs));
+
+ /* XXX lwp */
+ lp = FIRST_LWP_IN_PROC(p);
+ return (set_dbregs(lp, dbregs));
}
/*
int
procfs_read_fpregs(struct proc *p, struct fpreg *fpregs)
{
+ struct lwp *lp;
+
if (p->p_flag & P_SWAPPEDOUT)
return (EIO);
- return (fill_fpregs(&p->p_lwp, fpregs));
+
+ /* XXX lwp */
+ lp = FIRST_LWP_IN_PROC(p);
+ return (fill_fpregs(lp, fpregs));
}
int
procfs_write_fpregs(struct proc *p, struct fpreg *fpregs)
{
+ struct lwp *lp;
+
if (p->p_flag & P_SWAPPEDOUT)
return (EIO);
- return (set_fpregs(&p->p_lwp, fpregs));
+
+ /* XXX lwp */
+ lp = FIRST_LWP_IN_PROC(p);
+ return (set_fpregs(lp, fpregs));
}
int
procfs_sstep(struct proc *p)
{
+ struct lwp *lp;
+
if (p->p_flag & P_SWAPPEDOUT)
return (EIO);
- return (ptrace_single_step(&p->p_lwp));
+
+ /* XXX lwp */
+ lp = FIRST_LWP_IN_PROC(p);
+ return (ptrace_single_step(lp));
}
*
* from: @(#)sys_machdep.c 5.5 (Berkeley) 1/19/91
* $FreeBSD: src/sys/i386/i386/sys_machdep.c,v 1.47.2.3 2002/10/07 17:20:00 jhb Exp $
- * $DragonFly: src/sys/platform/pc32/i386/sys_machdep.c,v 1.30 2007/01/08 03:33:42 dillon Exp $
+ * $DragonFly: src/sys/platform/pc32/i386/sys_machdep.c,v 1.31 2007/02/03 17:05:58 corecode Exp $
*
*/
int
cpu_set_iopl(void)
{
- curproc->p_md.md_regs->tf_eflags |= PSL_IOPL;
+ curthread->td_lwp->lwp_md.md_regs->tf_eflags |= PSL_IOPL;
return(0);
}
int
cpu_clr_iopl(void)
{
- curproc->p_md.md_regs->tf_eflags &= ~PSL_IOPL;
+ curthread->td_lwp->lwp_md.md_regs->tf_eflags &= ~PSL_IOPL;
return(0);
}
*
* from: @(#)trap.c 7.4 (Berkeley) 5/13/91
* $FreeBSD: src/sys/i386/i386/trap.c,v 1.147.2.11 2003/02/27 19:09:59 luoqi Exp $
- * $DragonFly: src/sys/platform/pc32/i386/trap.c,v 1.96 2007/01/22 19:37:04 corecode Exp $
+ * $DragonFly: src/sys/platform/pc32/i386/trap.c,v 1.97 2007/02/03 17:05:58 corecode Exp $
*/
/*
* Post any pending signals. If running a virtual kernel be sure
* to restore the virtual kernel's vmspace before posting the signal.
*/
- if ((sig = CURSIG(p)) != 0) {
+ if ((sig = CURSIG(lp)) != 0) {
get_mplock();
postsig(sig);
rel_mplock();
i = (*p->p_sysent->sv_transtrap)(i, type);
MAKEMPSAFE(have_mplock);
- trapsignal(p, i, ucode);
+ trapsignal(lp, i, ucode);
#ifdef DEBUG
if (type <= MAX_TRAP_MSG) {
if ((orig_tf_eflags & PSL_T) && !(orig_tf_eflags & PSL_VM)) {
MAKEMPSAFE(have_mplock);
frame->tf_eflags &= ~PSL_T;
- trapsignal(p, SIGTRAP, 0);
+ trapsignal(lp, SIGTRAP, 0);
}
/*
* from: @(#)vm_machdep.c 7.3 (Berkeley) 5/13/91
* Utah $Hdr: vm_machdep.c 1.16.1.1 89/06/23$
* $FreeBSD: src/sys/i386/i386/vm_machdep.c,v 1.132.2.9 2003/01/25 19:02:23 dillon Exp $
- * $DragonFly: src/sys/platform/pc32/i386/vm_machdep.c,v 1.55 2007/02/03 10:30:12 corecode Exp $
+ * $DragonFly: src/sys/platform/pc32/i386/vm_machdep.c,v 1.56 2007/02/03 17:05:58 corecode Exp $
*/
#include "use_npx.h"
bcopy(&lp1->lwp_thread->td_tls, &lp2->lwp_thread->td_tls,
sizeof(lp2->lwp_thread->td_tls));
/*
- * Now, cpu_switch() can schedule the new process.
+ * Now, cpu_switch() can schedule the new lwp.
* pcb_esp is loaded pointing to the cpu_switch() stack frame
* containing the return address when exiting cpu_switch.
* This will normally be to fork_trampoline(), which will have
- * %ebx loaded with the new proc's pointer. fork_trampoline()
- * will set up a stack to call fork_return(p, frame); to complete
+ * %ebx loaded with the new lwp's pointer. fork_trampoline()
+ * will set up a stack to call fork_return(lp, frame); to complete
* the return to user-mode.
*/
}
*
* from: @(#)npx.c 7.2 (Berkeley) 5/12/91
* $FreeBSD: src/sys/i386/isa/npx.c,v 1.80.2.3 2001/10/20 19:04:38 tegge Exp $
- * $DragonFly: src/sys/platform/pc32/isa/npx.c,v 1.40 2007/01/09 23:34:04 dillon Exp $
+ * $DragonFly: src/sys/platform/pc32/isa/npx.c,v 1.41 2007/02/03 17:05:58 corecode Exp $
*/
#include "opt_cpu.h"
* in doreti, and the frame for that could easily be set up
* just before it is used).
*/
- curproc->p_md.md_regs = INTR_TO_TRAPFRAME(frame);
+ curthread->td_lwp->lwp_md.md_regs = INTR_TO_TRAPFRAME(frame);
/*
* Encode the appropriate code for detailed information on
* this exception.
*/
code =
fpetable[(*exstat & ~control & 0x3f) | (*exstat & 0x40)];
- trapsignal(curproc, SIGFPE, code);
+ trapsignal(curthread->td_lwp, SIGFPE, code);
} else {
/*
* Nested interrupt. These losers occur when:
*
* from: @(#)machdep.c 7.4 (Berkeley) 6/3/91
* $FreeBSD: src/sys/i386/i386/machdep.c,v 1.385.2.30 2003/05/31 08:48:05 alc Exp $
- * $DragonFly: src/sys/platform/vkernel/i386/cpu_regs.c,v 1.12 2007/02/03 09:25:10 corecode Exp $
+ * $DragonFly: src/sys/platform/vkernel/i386/cpu_regs.c,v 1.13 2007/02/03 17:05:58 corecode Exp $
*/
#include "use_ether.h"
/* Allocate and validate space for the signal handler context. */
/* XXX lwp flags */
- if ((p->p_flag & P_ALTSTACK) != 0 && !oonstack &&
+ if ((lp->lwp_flag & LWP_ALTSTACK) != 0 && !oonstack &&
SIGISMEMBER(psp->ps_sigonstack, sig)) {
sfp = (struct sigframe *)(lp->lwp_sigstk.ss_sp +
lp->lwp_sigstk.ss_size - sizeof(struct sigframe));
cs = ucp.uc_mcontext.mc_cs;
if (!CS_SECURE(cs)) {
kprintf("sigreturn: cs = 0x%x\n", cs);
- trapsignal(lp->lwp_proc, SIGBUS, T_PROTFLT);
+ trapsignal(lp, SIGBUS, T_PROTFLT);
return(EINVAL);
}
bcopy(&ucp.uc_mcontext.mc_gs, regs, sizeof(struct trapframe));
* Clear registers on exec
*/
void
-setregs(struct lwp *lp, u_long entry, u_long stack, u_long ps_strings)
+exec_setregs(u_long entry, u_long stack, u_long ps_strings)
{
+ struct thread *td = curthread;
+ struct lwp *lp = td->td_lwp;
struct trapframe *regs = lp->lwp_md.md_regs;
struct pcb *pcb = lp->lwp_thread->td_pcb;
pcb->pcb_dr3 = 0;
pcb->pcb_dr6 = 0;
pcb->pcb_dr7 = 0;
- if (pcb == curthread->td_pcb) {
+ if (pcb == td->td_pcb) {
/*
* Clear the debug registers on the running
* CPU, otherwise they will end up affecting
* traps to the emulator (if it is done at all) mainly because
* emulators don't provide an entry point for initialization.
*/
- lp->lwp_thread->td_pcb->pcb_flags &= ~FP_SOFTFP;
+ pcb->pcb_flags &= ~FP_SOFTFP;
/*
* note: do not set CR0_TS here. npxinit() must do it after clearing
#endif
int
-ptrace_set_pc(struct proc *p, unsigned long addr)
+ptrace_set_pc(struct lwp *lp, unsigned long addr)
{
- p->p_md.md_regs->tf_eip = addr;
+ lp->lwp_md.md_regs->tf_eip = addr;
return (0);
}
*
* from: @(#)npx.c 7.2 (Berkeley) 5/12/91
* $FreeBSD: src/sys/i386/isa/npx.c,v 1.80.2.3 2001/10/20 19:04:38 tegge Exp $
- * $DragonFly: src/sys/platform/vkernel/i386/npx.c,v 1.4 2007/01/09 23:34:05 dillon Exp $
+ * $DragonFly: src/sys/platform/vkernel/i386/npx.c,v 1.5 2007/02/03 17:05:58 corecode Exp $
*/
#include "opt_debug_npx.h"
* in doreti, and the frame for that could easily be set up
* just before it is used).
*/
- curproc->p_md.md_regs = INTR_TO_TRAPFRAME(frame);
+ curthread->td_lwp->lwp_md.md_regs = INTR_TO_TRAPFRAME(frame);
/*
* Encode the appropriate code for detailed information on
* this exception.
*
* From:
* $FreeBSD: src/sys/i386/i386/procfs_machdep.c,v 1.14 1999/10/11 14:50:03 peter Exp $
- * $DragonFly: src/sys/platform/vkernel/i386/procfs_machdep.c,v 1.1 2007/01/06 08:34:53 dillon Exp $
+ * $DragonFly: src/sys/platform/vkernel/i386/procfs_machdep.c,v 1.2 2007/02/03 17:05:58 corecode Exp $
*/
/*
int
procfs_read_regs(struct proc *p, struct reg *regs)
{
+ struct lwp *lp;
+
if (p->p_flag & P_SWAPPEDOUT)
return (EIO);
- return (fill_regs(&p->p_lwp, regs));
+ /* XXX lwp */
+ lp = FIRST_LWP_IN_PROC(p);
+ return (fill_regs(lp, regs));
}
int
procfs_write_regs(struct proc *p, struct reg *regs)
{
+ struct lwp *lp;
+
if (p->p_flag & P_SWAPPEDOUT)
return (EIO);
- return (set_regs(&p->p_lwp, regs));
+ /* XXX lwp */
+ lp = FIRST_LWP_IN_PROC(p);
+ return (set_regs(lp, regs));
}
int
procfs_read_dbregs(struct proc *p, struct dbreg *dbregs)
{
+ struct lwp *lp;
+
if (p->p_flag & P_SWAPPEDOUT)
return (EIO);
- return (fill_dbregs(&p->p_lwp, dbregs));
+ /* XXX lwp */
+ lp = FIRST_LWP_IN_PROC(p);
+ return (fill_dbregs(lp, dbregs));
}
int
procfs_write_dbregs(struct proc *p, struct dbreg *dbregs)
{
+ struct lwp *lp;
+
if (p->p_flag & P_SWAPPEDOUT)
return (EIO);
- return (set_dbregs(&p->p_lwp, dbregs));
+ /* XXX lwp */
+ lp = FIRST_LWP_IN_PROC(p);
+ return (set_dbregs(lp, dbregs));
}
/*
int
procfs_read_fpregs(struct proc *p, struct fpreg *fpregs)
{
+ struct lwp *lp;
+
if (p->p_flag & P_SWAPPEDOUT)
return (EIO);
- return (fill_fpregs(&p->p_lwp, fpregs));
+ /* XXX lwp */
+ lp = FIRST_LWP_IN_PROC(p);
+ return (fill_fpregs(lp, fpregs));
}
int
procfs_write_fpregs(struct proc *p, struct fpreg *fpregs)
{
+ struct lwp *lp;
+
if (p->p_flag & P_SWAPPEDOUT)
return (EIO);
- return (set_fpregs(&p->p_lwp, fpregs));
+ /* XXX lwp */
+ lp = FIRST_LWP_IN_PROC(p);
+ return (set_fpregs(lp, fpregs));
}
int
procfs_sstep(struct proc *p)
{
+ struct lwp *lp;
+
if (p->p_flag & P_SWAPPEDOUT)
return (EIO);
- return (ptrace_single_step(&p->p_lwp));
+ /* XXX lwp */
+ lp = FIRST_LWP_IN_PROC(p);
+ return (ptrace_single_step(lp));
}
*
* from: @(#)trap.c 7.4 (Berkeley) 5/13/91
* $FreeBSD: src/sys/i386/i386/trap.c,v 1.147.2.11 2003/02/27 19:09:59 luoqi Exp $
- * $DragonFly: src/sys/platform/vkernel/i386/trap.c,v 1.15 2007/02/02 20:00:22 tgen Exp $
+ * $DragonFly: src/sys/platform/vkernel/i386/trap.c,v 1.16 2007/02/03 17:05:58 corecode Exp $
*/
/*
/*
* Post any pending signals
*/
- if ((sig = CURSIG(p)) != 0) {
+ if ((sig = CURSIG(lp)) != 0) {
get_mplock();
postsig(sig);
rel_mplock();
i = (*p->p_sysent->sv_transtrap)(i, type);
MAKEMPSAFE(have_mplock);
- trapsignal(p, i, ucode);
+ trapsignal(lp, i, ucode);
#ifdef DEBUG
if (type <= MAX_TRAP_MSG) {
{
struct globaldata *gd = mycpu;
struct thread *td = gd->gd_curthread;
+ struct lwp *lp;
struct proc *p;
int i = 0, ucode = 0, type, code;
#ifdef SMP
#endif
vm_offset_t eva;
+ lp = td->td_lwp;
p = td->td_proc;
if (frame->tf_trapno == T_PAGEFLT)
i = (*p->p_sysent->sv_transtrap)(i, type);
MAKEMPSAFE(have_mplock);
- trapsignal(p, i, ucode);
+ trapsignal(lp, i, ucode);
#ifdef DEBUG
if (type <= MAX_TRAP_MSG) {
if ((orig_tf_eflags & PSL_T) /*&& !(orig_tf_eflags & PSL_VM)*/) {
MAKEMPSAFE(have_mplock);
frame->tf_eflags &= ~PSL_T;
- trapsignal(p, SIGTRAP, 0);
+ trapsignal(lp, SIGTRAP, 0);
}
/*
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
- * $DragonFly: src/sys/platform/vkernel/platform/init.c,v 1.28 2007/01/15 20:51:15 dillon Exp $
+ * $DragonFly: src/sys/platform/vkernel/platform/init.c,v 1.29 2007/02/03 17:05:59 corecode Exp $
*/
#include <sys/types.h>
mi_gdinit(&gd->mi, 0);
cpu_gdinit(gd, 0);
mi_proc0init(&gd->mi, proc0paddr);
- proc0.p_lwp.lwp_md.md_regs = &proc0_tf;
+ lwp0.lwp_md.md_regs = &proc0_tf;
/*init_locks();*/
cninit();
#endif
#if 0
thread0.td_pcb_cr3 ... MMU
- proc0.p_lwp.lwp_md.md_regs = &proc0_tf;
+ lwp0.lwp_md.md_regs = &proc0_tf;
#endif
}
*
* from: @(#)pmap.c 7.7 (Berkeley) 5/12/91
* $FreeBSD: src/sys/i386/i386/pmap.c,v 1.250.2.18 2002/03/06 22:48:53 silby Exp $
- * $DragonFly: src/sys/platform/vkernel/platform/pmap.c,v 1.15 2007/01/15 09:28:40 dillon Exp $
+ * $DragonFly: src/sys/platform/vkernel/platform/pmap.c,v 1.16 2007/02/03 17:05:59 corecode Exp $
*/
/*
* NOTE: PMAP_INVAL_ADD: In pc32 this function is called prior to adjusting
void
pmap_init_proc(struct proc *p, struct thread *td)
{
+ struct lwp *lp = ONLY_LWP_IN_PROC(p);
+
p->p_addr = (void *)td->td_kstack;
- p->p_thread = td;
+ lp->lwp_thread = td;
td->td_proc = p;
- td->td_lwp = &p->p_lwp;
+ td->td_lwp = lp;
td->td_switch = cpu_heavy_switch;
#ifdef SMP
KKASSERT(td->td_mpcount == 1);
struct thread *
pmap_dispose_proc(struct proc *p)
{
- struct thread *td;
+ struct thread *td = NULL;
+ struct lwp *lp;
KASSERT(p->p_lock == 0, ("attempt to dispose referenced proc! %p", p));
- if ((td = p->p_thread) != NULL) {
- p->p_thread = NULL;
+ lp = ONLY_LWP_IN_PROC(p);
+ if (lp != NULL && (td = lp->lwp_thread) != NULL) {
+ lp->lwp_thread = NULL;
+ td->td_lwp = NULL;
td->td_proc = NULL;
}
p->p_addr = NULL;
tlb_flush_count++;
#endif
#if 0
- p->p_thread->td_pcb->pcb_cr3 = vtophys(pmap->pm_pdir);
- load_cr3(p->p_thread->td_pcb->pcb_cr3);
+ KKASSERT((p == curproc));
+
+ curthread->td_pcb->pcb_cr3 = vtophys(pmap->pm_pdir);
+ load_cr3(curthread->td_pcb->pcb_cr3);
#endif
}
*
* Implements an architecture independant Capability Service API
*
- * $DragonFly: src/sys/sys/caps.h,v 1.9 2006/05/20 02:42:13 dillon Exp $
+ * $DragonFly: src/sys/sys/caps.h,v 1.10 2007/02/03 17:05:59 corecode Exp $
*/
#ifndef _SYS_CAPS_H_
* kernel support
*/
void caps_exit(struct thread *td);
-void caps_fork(struct proc *p1, struct proc *p2, int flags);
+void caps_fork(struct thread *td1, struct thread *td2, int flags);
#else
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
- * $DragonFly: src/sys/sys/kinfo.h,v 1.10 2007/02/01 20:27:05 tgen Exp $
+ * $DragonFly: src/sys/sys/kinfo.h,v 1.11 2007/02/03 17:05:59 corecode Exp $
*/
#ifndef _SYS_KINFO_H_
uint64_t kl_iticks;
uint64_t kl_cpticks; /* sched quantums used */
u_int kl_pctcpu; /* percentage cputime */
- u_int kl_swtime; /* time swapped in or out */
u_int kl_slptime; /* time since last blocked */
int kl_origcpu; /* originally scheduled on cpu */
int kl_estcpu;
u_short kp_exitstat; /* exit status information */
int kp_nthreads;
int kp_nice;
+ unsigned int kp_swtime;
vm_size_t kp_vm_map_size; /* vmmap virtual size */
segsz_t kp_vm_rssize; /* resident set size */
* SUCH DAMAGE.
*
* $FreeBSD: src/sys/posix4/posix4.h,v 1.6 1999/12/27 10:22:09 bde Exp $
- * $DragonFly: src/sys/sys/posix4.h,v 1.6 2006/09/05 03:48:11 dillon Exp $
+ * $DragonFly: src/sys/sys/posix4.h,v 1.7 2007/02/03 17:05:57 corecode Exp $
*/
#include "opt_posix.h"
#define p31b_free(P) kfree((P), M_P31B)
struct proc;
+struct lwp;
int p31b_proc (struct proc *, pid_t, struct proc **);
int ksched_detach(struct ksched *);
int ksched_setparam(register_t *, struct ksched *,
- struct proc *, const struct sched_param *);
+ struct lwp *, const struct sched_param *);
int ksched_getparam(register_t *, struct ksched *,
- struct proc *, struct sched_param *);
+ struct lwp *, struct sched_param *);
int ksched_setscheduler(register_t *, struct ksched *,
- struct proc *, int, const struct sched_param *);
-int ksched_getscheduler(register_t *, struct ksched *, struct proc *);
+ struct lwp *, int, const struct sched_param *);
+int ksched_getscheduler(register_t *, struct ksched *, struct lwp *);
int ksched_yield(register_t *, struct ksched *);
int ksched_get_priority_min(register_t *, struct ksched *, int);
int ksched_rr_get_interval(register_t *, struct ksched *,
- struct proc *, struct timespec *);
+ struct lwp *, struct timespec *);
#endif /* _KPOSIX_PRIORITY_SCHEDULING */
*
* @(#)proc.h 8.15 (Berkeley) 5/19/95
* $FreeBSD: src/sys/sys/proc.h,v 1.99.2.9 2003/06/06 20:21:32 tegge Exp $
- * $DragonFly: src/sys/sys/proc.h,v 1.91 2007/02/01 10:33:26 corecode Exp $
+ * $DragonFly: src/sys/sys/proc.h,v 1.92 2007/02/03 17:05:59 corecode Exp $
*/
#ifndef _SYS_PROC_H_
lwpid_t lwp_tid; /* Our thread id . */
-#ifdef notyet
int lwp_flag; /* P_* flags. */
+#ifdef notyet
char lwp_stat; /* S* process status. */
#endif
sysclock_t lwp_cpticks; /* cpu used in sched clock ticks */
sysclock_t lwp_cpbase; /* Measurement base */
fixpt_t lwp_pctcpu; /* %cpu for this process */
- u_int lwp_swtime; /* Time swapped in or out. */
u_int lwp_slptime; /* Time since last blocked. */
int lwp_traceflag; /* Kernel trace points. */
struct filedesc *p_fd; /* Ptr to open files structure. */
struct filedesc_to_leader *p_fdtol; /* Ptr to tracking node XXX lwp */
struct plimit *p_limit; /* Process limits. */
+ struct pstats *p_stats;
void *p_pad0;
struct procsig *p_procsig;
#define p_sigacts p_procsig->ps_sigacts
struct vmspace *p_vmspace; /* Current address space. */
-#define p_cpticks p_lwp.lwp_cpticks
-#define p_cpbase p_lwp.lwp_cpbase
-#define p_pctcpu p_lwp.lwp_pctcpu
-#define p_swtime p_lwp.lwp_swtime
-#define p_slptime p_lwp.lwp_slptime
+ unsigned int p_swtime; /* Time swapped in or out */
struct itimerval p_realtimer; /* Alarm timer. */
struct itimerval p_timer[3]; /* Virtual-time timers. */
struct vnode *p_textvp; /* Vnode of executable. */
-#define p_usdata p_lwp.lwp_usdata
-
unsigned int p_stops; /* procfs event bitmask */
unsigned int p_stype; /* procfs stop event type */
char p_step; /* procfs stop *once* flag */
char p_pad2[2]; /* padding for alignment */
struct sigiolst p_sigiolst; /* list of sigio sources */
int p_sigparent; /* signal to parent on exit */
-#define p_oldsigmask p_lwp.lwp_oldsigmask
int p_sig; /* for core dump/debugger XXX */
u_long p_code; /* for core dump/debugger XXX */
struct klist p_klist; /* knotes attached to this process */
/* The following fields are all copied upon creation in fork. */
#define p_startcopy p_comm
-#define p_sigmask p_lwp.lwp_sigmask
-#define p_sigstk p_lwp.lwp_sigstk
-
char p_comm[MAXCOMLEN+1]; /* typ 16+1 bytes */
char p_lock; /* Process lock (prevent swap) count. */
char p_nice; /* Process "nice" value. */
/* End area that is copied on creation. */
#define p_endcopy p_addr
struct user *p_addr; /* Kernel virtual addr of u-area (PROC ONLY) XXX lwp */
-#define p_md p_lwp.lwp_md
u_short p_xstat; /* Exit status or last stop signal */
u_short p_acflag; /* Accounting flags. */
struct proc *p_peers; /* XXX lwp */
struct proc *p_leader; /* XXX lwp */
void *p_emuldata; /* process-specific emulator state */
-#define p_thread p_lwp.lwp_thread
struct usched *p_usched; /* Userland scheduling control */
struct vkernel *p_vkernel; /* Virtual kernel extension */
int p_numposixlocks; /* number of POSIX locks */
- struct lwp p_lwp; /* Embedded lwp XXX */
struct spinlock p_spin; /* Spinlock for LWP access to proc */
};
-#define p_wchan p_thread->td_wchan
-#define p_wmesg p_thread->td_wmesg
+#define lwp_wchan lwp_thread->td_wchan
+#define lwp_wmesg lwp_thread->td_wmesg
#define p_session p_pgrp->pg_session
#define p_pgid p_pgrp->pg_id
#define P_DEADLKTREAT 0x800000 /* lock aquisition - deadlock treatment */
#define P_JAILED 0x1000000 /* Process is in jail */
-#define P_OLDMASK 0x2000000 /* need to restore mask before pause */
-#define P_ALTSTACK 0x4000000 /* have alternate signal stack */
+#define P_UNUSED0 0x2000000 /* need to restore mask before pause */
+#define P_UNUSED1 0x4000000 /* have alternate signal stack */
#define P_INEXEC 0x8000000 /* Process is in execve(). */
#define P_PASSIVE_ACQ 0x10000000 /* Passive acquire cpu (see kern_switch) */
#define P_UPCALLWAIT 0x20000000 /* Wait for upcall or signal */
#define P_XCPU 0x40000000 /* SIGXCPU */
+#define LWP_ALTSTACK 0x0000001 /* have alternate signal stack */
+#define LWP_OLDMASK 0x0000002 /* need to restore mask before pause */
+
#define FIRST_LWP_IN_PROC(p) LIST_FIRST(&(p)->p_lwps)
#define FOREACH_LWP_IN_PROC(lp, p) \
LIST_FOREACH((lp), &(p)->p_lwps, lwp_list)
#endif
extern struct proc proc0; /* Process slot for swapper. */
+extern struct lwp lwp0; /* LWP slot for swapper. */
extern struct thread thread0; /* Thread slot for swapper. */
extern int hogticks; /* Limit on kernel cpu hogs. */
extern int nprocs, maxproc; /* Current and max number of procs. */
struct vm_zone;
struct globaldata;
extern struct vm_zone *proc_zone;
+extern struct vm_zone *lwp_zone;
int enterpgrp (struct proc *p, pid_t pgid, int mksess);
void proc_add_allproc(struct proc *p);
*
* @(#)ptrace.h 8.2 (Berkeley) 1/4/94
* $FreeBSD: src/sys/sys/ptrace.h,v 1.10.2.2 2003/01/02 20:39:13 kan Exp $
- * $DragonFly: src/sys/sys/ptrace.h,v 1.8 2006/09/19 11:47:36 corecode Exp $
+ * $DragonFly: src/sys/sys/ptrace.h,v 1.9 2007/02/03 17:05:59 corecode Exp $
*/
#ifndef _SYS_PTRACE_H_
struct lwp;
void proc_reparent (struct proc *child, struct proc *newparent);
-int ptrace_set_pc (struct proc *p, unsigned long addr);
+int ptrace_set_pc (struct lwp *p, unsigned long addr);
int ptrace_single_step (struct lwp *lp);
int kern_ptrace (struct proc *p, int req, pid_t pid, void *addr,
int data, int *res);
*
* from: @(#)reg.h 5.5 (Berkeley) 1/18/91
* $FreeBSD: src/sys/i386/include/reg.h,v 1.22.2.2 2002/11/07 22:47:55 alfred Exp $
- * $DragonFly: src/sys/sys/reg.h,v 1.2 2006/11/07 20:48:15 dillon Exp $
+ * $DragonFly: src/sys/sys/reg.h,v 1.3 2007/02/03 17:05:59 corecode Exp $
*/
/*
* Machine independant interface to abstract cpu registers that a process
int fill_dbregs (struct lwp *lp, struct dbreg *dbregs);
int set_fpregs (struct lwp *, struct fpreg *);
int set_regs (struct lwp *lp, struct reg *regs);
-void setregs (struct lwp *, u_long, u_long, u_long);
+void exec_setregs (u_long, u_long, u_long);
int set_dbregs (struct lwp *lp, struct dbreg *dbregs);
#endif
*
* @(#)signalvar.h 8.6 (Berkeley) 2/19/95
* $FreeBSD: src/sys/sys/signalvar.h,v 1.34.2.1 2000/05/16 06:58:05 dillon Exp $
- * $DragonFly: src/sys/sys/signalvar.h,v 1.16 2007/01/14 07:59:08 dillon Exp $
+ * $DragonFly: src/sys/sys/signalvar.h,v 1.17 2007/02/03 17:05:59 corecode Exp $
*/
#ifndef _SYS_SIGNALVAR_H_ /* tmp for user.h */
void check_sigacts (void);
void execsigs (struct proc *p);
void gsignal (int pgid, int sig);
-int issignal (struct proc *p);
-int iscaught (struct proc *p);
+int issignal (struct lwp *lp);
+int iscaught (struct lwp *p);
void killproc (struct proc *p, char *why);
void pgsigio (struct sigio *, int signum, int checkctty);
void pgsignal (struct pgrp *pgrp, int sig, int checkctty);
void postsig (int sig);
void ksignal (struct proc *p, int sig);
void siginit (struct proc *p);
-void trapsignal (struct proc *p, int sig, u_long code);
-static int __cursig (struct proc *p);
+void trapsignal (struct lwp *p, int sig, u_long code);
+static int __cursig (struct lwp *p);
/*
* Machine-dependent functions:
/*
* Inline functions:
*/
-#define CURSIG(p) __cursig(p)
-#define CURSIGNB(p) __cursignb(p)
+#define CURSIG(lp) __cursig(lp)
+#define CURSIGNB(lp) __cursignb(lp)
/*
* Determine signal that should be delivered to process p, the current
*/
static __inline
int
-__cursig(struct proc *p)
+__cursig(struct lwp *lp)
{
+ struct proc *p;
sigset_t tmpset;
int r;
+ p = lp->lwp_proc;
tmpset = p->p_siglist;
- SIGSETNAND(tmpset, p->p_sigmask);
- if (SIGISEMPTY(p->p_siglist) ||
- (!(p->p_flag & P_TRACED) && SIGISEMPTY(tmpset))) {
+ SIGSETOR(tmpset, lp->lwp_siglist);
+ SIGSETNAND(tmpset, lp->lwp_sigmask);
+ if (!(p->p_flag & P_TRACED) && SIGISEMPTY(tmpset))
return(0);
- }
- r = issignal(p);
+ r = issignal(lp);
return(r);
}
static __inline
int
-__cursignb(struct proc *p)
+__cursignb(struct lwp *lp)
{
+ struct proc *p;
sigset_t tmpset;
+ p = lp->lwp_proc;
tmpset = p->p_siglist;
- SIGSETNAND(tmpset, p->p_sigmask);
- if (SIGISEMPTY(p->p_siglist) ||
- (!(p->p_flag & P_TRACED) && SIGISEMPTY(tmpset))) {
+ SIGSETOR(tmpset, lp->lwp_siglist);
+ SIGSETNAND(tmpset, lp->lwp_sigmask);
+ if ((!(p->p_flag & P_TRACED) && SIGISEMPTY(tmpset))) {
return(FALSE);
}
return (TRUE);
*
* @(#)mfs_vfsops.c 8.11 (Berkeley) 6/19/95
* $FreeBSD: src/sys/ufs/mfs/mfs_vfsops.c,v 1.81.2.3 2001/07/04 17:35:21 tegge Exp $
- * $DragonFly: src/sys/vfs/mfs/mfs_vfsops.c,v 1.35 2006/09/10 01:26:41 dillon Exp $
+ * $DragonFly: src/sys/vfs/mfs/mfs_vfsops.c,v 1.36 2007/02/03 17:05:59 corecode Exp $
*/
gotsig = 0;
if (dounmount(mp, 0) != 0) {
KKASSERT(td->td_proc);
- sig = CURSIG(td->td_proc);
+ sig = CURSIG(td->td_lwp);
if (sig)
SIGDELSET(td->td_proc->p_siglist, sig);
}
*
* @(#)nfs_socket.c 8.5 (Berkeley) 3/30/95
* $FreeBSD: src/sys/nfs/nfs_socket.c,v 1.60.2.6 2003/03/26 01:44:46 alfred Exp $
- * $DragonFly: src/sys/vfs/nfs/nfs_socket.c,v 1.39 2006/12/23 00:41:29 swildner Exp $
+ * $DragonFly: src/sys/vfs/nfs/nfs_socket.c,v 1.40 2007/02/03 17:05:59 corecode Exp $
*/
/*
{
sigset_t tmpset;
struct proc *p;
+ struct lwp *lp;
if (rep && (rep->r_flags & R_SOFTTERM))
return (EINTR);
if (td == NULL || (p = td->td_proc) == NULL)
return (0);
- tmpset = p->p_siglist;
- SIGSETNAND(tmpset, p->p_sigmask);
+ lp = td->td_lwp;
+ tmpset = lp->lwp_siglist;
+ SIGSETOR(tmpset, p->p_siglist);
+ SIGSETNAND(tmpset, lp->lwp_sigmask);
SIGSETNAND(tmpset, p->p_sigignore);
- if (SIGNOTEMPTY(p->p_siglist) && NFSINT_SIGMASK(tmpset))
+ if (SIGNOTEMPTY(tmpset) && NFSINT_SIGMASK(tmpset))
return (EINTR);
return (0);
*
* From:
* $FreeBSD: src/sys/miscfs/procfs/procfs_status.c,v 1.20.2.4 2002/01/22 17:22:59 nectar Exp $
- * $DragonFly: src/sys/vfs/procfs/procfs_status.c,v 1.13 2007/01/01 22:51:18 corecode Exp $
+ * $DragonFly: src/sys/vfs/procfs/procfs_status.c,v 1.14 2007/02/03 17:05:59 corecode Exp $
*/
#include <sys/param.h>
procfs_dostatus(struct proc *curp, struct proc *p, struct pfsnode *pfs,
struct uio *uio)
{
+ struct lwp *lp;
struct session *sess;
struct tty *tp;
struct ucred *cr;
KASSERT(sizeof(psbuf) > MAXCOMLEN,
("Too short buffer for new MAXCOMLEN"));
+ /* XXX lwp */
+ lp = FIRST_LWP_IN_PROC(p);
ps = psbuf;
bcopy(p->p_comm, ps, MAXCOMLEN);
ps[MAXCOMLEN] = '\0';
DOCHECK();
ps += ksnprintf(ps, psbuf + sizeof(psbuf) - ps, " %s",
- (p->p_wchan && p->p_wmesg) ? p->p_wmesg : "nochan");
+ (lp->lwp_wchan && lp->lwp_wmesg) ? lp->lwp_wmesg : "nochan");
DOCHECK();
cr = p->p_ucred;
* rights to redistribute these changes.
*
* $FreeBSD: src/sys/vm/vm_glue.c,v 1.94.2.4 2003/01/13 22:51:17 dillon Exp $
- * $DragonFly: src/sys/vm/vm_glue.c,v 1.48 2007/01/01 22:51:18 corecode Exp $
+ * $DragonFly: src/sys/vm/vm_glue.c,v 1.49 2007/02/03 17:05:59 corecode Exp $
*/
#include "opt_vm.h"
scheduler_callback(struct proc *p, void *data)
{
struct scheduler_info *info = data;
+ struct lwp *lp;
segsz_t pgs;
int pri;
if (p->p_flag & P_SWAPWAIT) {
- pri = p->p_swtime + p->p_slptime - p->p_nice * 8;
+ /* XXX lwp */
+ lp = FIRST_LWP_IN_PROC(p);
+ pri = p->p_swtime + lp->lwp_slptime - p->p_nice * 8;
/*
* The more pages paged out while we were swapped,
swapout_procs_callback(struct proc *p, void *data)
{
struct vmspace *vm;
+ struct lwp *lp;
int action = *(int *)data;
if (!swappable(p))
/*
* do not swap out a realtime process
*/
- if (RTP_PRIO_IS_REALTIME(p->p_lwp.lwp_rtprio.type))
+ /* XXX lwp */
+ lp = FIRST_LWP_IN_PROC(p);
+ if (RTP_PRIO_IS_REALTIME(lp->lwp_rtprio.type))
return(0);
/*
* Guarentee swap_idle_threshold time in memory
*/
- if (p->p_slptime < swap_idle_threshold1)
+ if (lp->lwp_slptime < swap_idle_threshold1)
return(0);
/*
*/
if (((action & VM_SWAP_NORMAL) == 0) &&
(((action & VM_SWAP_IDLE) == 0) ||
- (p->p_slptime < swap_idle_threshold2))) {
+ (lp->lwp_slptime < swap_idle_threshold2))) {
return(0);
}
*/
if ((action & VM_SWAP_NORMAL) ||
((action & VM_SWAP_IDLE) &&
- (p->p_slptime > swap_idle_threshold2))) {
+ (lp->lwp_slptime > swap_idle_threshold2))) {
swapout(p);
}
*
* @(#)vm_meter.c 8.4 (Berkeley) 1/4/94
* $FreeBSD: src/sys/vm/vm_meter.c,v 1.34.2.7 2002/10/10 19:28:22 dillon Exp $
- * $DragonFly: src/sys/vm/vm_meter.c,v 1.10 2006/09/11 20:25:31 dillon Exp $
+ * $DragonFly: src/sys/vm/vm_meter.c,v 1.11 2007/02/03 17:05:59 corecode Exp $
*/
#include <sys/param.h>
do_vmtotal_callback(struct proc *p, void *data)
{
struct vmtotal *totalp = data;
+ struct lwp *lp;
vm_map_entry_t entry;
vm_map_t map;
int paging;
if (p->p_flag & P_SYSTEM)
return(0);
+ /* XXX lwp */
+ lp = FIRST_LWP_IN_PROC(p);
+
switch (p->p_stat) {
case 0:
return(0);
if ((p->p_flag & P_SWAPPEDOUT) == 0) {
if ((p->p_flag & P_SINTR) == 0)
totalp->t_dw++;
- else if (p->p_slptime < maxslp)
+ else if (lp->lwp_slptime < maxslp)
totalp->t_sl++;
- } else if (p->p_slptime < maxslp) {
+ } else if (lp->lwp_slptime < maxslp) {
totalp->t_sw++;
}
- if (p->p_slptime >= maxslp)
+ if (lp->lwp_slptime >= maxslp)
return(0);
break;
* rights to redistribute these changes.
*
* $FreeBSD: src/sys/vm/vm_pageout.c,v 1.151.2.15 2002/12/29 18:21:04 dillon Exp $
- * $DragonFly: src/sys/vm/vm_pageout.c,v 1.29 2006/12/28 18:29:08 dillon Exp $
+ * $DragonFly: src/sys/vm/vm_pageout.c,v 1.30 2007/02/03 17:05:59 corecode Exp $
*/
/*
if (info.bigproc != NULL) {
killproc(info.bigproc, "out of swap space");
info.bigproc->p_nice = PRIO_MIN;
- info.bigproc->p_usched->resetpriority(&info.bigproc->p_lwp);
+ info.bigproc->p_usched->resetpriority(
+ FIRST_LWP_IN_PROC(info.bigproc));
wakeup(&vmstats.v_free_count);
PRELE(info.bigproc);
}
*
* @(#)pigs.c 8.2 (Berkeley) 9/23/93
*
- * $DragonFly: src/usr.bin/systat/pigs.c,v 1.12 2007/02/01 10:33:26 corecode Exp $
+ * $DragonFly: src/usr.bin/systat/pigs.c,v 1.13 2007/02/03 17:05:59 corecode Exp $
*/
/*
pt[i].pt_kp = &kpp[i];
pp = &kpp[i];
pctp = &pt[i].pt_pctcpu;
- time = pp->kp_lwp.kl_swtime;
+ time = pp->kp_swtime;
if (time == 0 || (pp->kp_flags & P_SWAPPEDOUT))
*pctp = 0;
else
* Hiten Pandya <hmp@backplane.com>
*
* $FreeBSD: src/usr.bin/top/machine.c,v 1.29.2.2 2001/07/31 20:27:05 tmm Exp $
- * $DragonFly: src/usr.bin/top/machine.c,v 1.20 2007/02/01 10:33:26 corecode Exp $
+ * $DragonFly: src/usr.bin/top/machine.c,v 1.21 2007/02/03 17:05:59 corecode Exp $
*/
#define VP(pp, field) ((pp)->kp_vm_ ## field)
/* define what weighted cpu is. */
-#define weighted_cpu(pct, pp) (LP((pp), swtime) == 0 ? 0.0 : \
- ((pct) / (1.0 - exp(LP((pp), swtime) * logcpu))))
+#define weighted_cpu(pct, pp) (PP((pp), swtime) == 0 ? 0.0 : \
+ ((pct) / (1.0 - exp(PP((pp), swtime) * logcpu))))
/* what we consider to be process size: */
#define PROCSIZE(pp) (VP((pp), map_size) / 1024)
projects / dragonfly.git / commitdiff