diff options
69 files changed, 79 insertions, 2343 deletions
diff --git a/sys/amd64/amd64/machdep.c b/sys/amd64/amd64/machdep.c index 24e9ec8..df831a1 100644 --- a/sys/amd64/amd64/machdep.c +++ b/sys/amd64/amd64/machdep.c @@ -1325,7 +1325,7 @@ hammer_time(u_int64_t modulep, u_int64_t physfree) _ucode32sel = GSEL(GUCODE32_SEL, SEL_UPL); /* setup proc 0's pcb */ - thread0.td_pcb->pcb_flags = 0; /* XXXKSE */ + thread0.td_pcb->pcb_flags = 0; thread0.td_pcb->pcb_cr3 = KPML4phys; thread0.td_frame = &proc0_tf; diff --git a/sys/amd64/amd64/trap.c b/sys/amd64/amd64/trap.c index 38da3f6..df325eb 100644 --- a/sys/amd64/amd64/trap.c +++ b/sys/amd64/amd64/trap.c @@ -301,10 +301,6 @@ trap(struct trapframe *frame) case T_PAGEFLT: /* page fault */ addr = frame->tf_addr; -#ifdef KSE - if (td->td_pflags & TDP_SA) - thread_user_enter(td); -#endif i = trap_pfault(frame, TRUE); if (i == -1) goto userout; @@ -782,10 +778,6 @@ syscall(struct trapframe *frame) td->td_frame = frame; if (td->td_ucred != p->p_ucred) cred_update_thread(td); -#ifdef KSE - if (p->p_flag & P_SA) - thread_user_enter(td); -#endif params = (caddr_t)frame->tf_rsp + sizeof(register_t); code = frame->tf_rax; orig_tf_rflags = frame->tf_rflags; diff --git a/sys/amd64/amd64/vm_machdep.c b/sys/amd64/amd64/vm_machdep.c index aba0fad..c181d42 100644 --- a/sys/amd64/amd64/vm_machdep.c +++ b/sys/amd64/amd64/vm_machdep.c @@ -51,7 +51,6 @@ __FBSDID("$FreeBSD$"); #include <sys/systm.h> #include <sys/bio.h> #include <sys/buf.h> -#include <sys/kse.h> #include <sys/kernel.h> #include <sys/ktr.h> #include <sys/lock.h> @@ -272,22 +271,12 @@ cpu_set_upcall(struct thread *td, struct thread *td0) * Copy the upcall pcb. This loads kernel regs. * Those not loaded individually below get their default * values here. - * - * XXXKSE It might be a good idea to simply skip this as - * the values of the other registers may be unimportant. - * This would remove any requirement for knowing the KSE - * at this time (see the matching comment below for - * more analysis) (need a good safe default). */ bcopy(td0->td_pcb, pcb2, sizeof(*pcb2)); pcb2->pcb_flags &= ~PCB_FPUINITDONE; /* * Create a new fresh stack for the new thread. - * Don't forget to set this stack value into whatever supplies - * the address for the fault handlers. - * The contexts are filled in at the time we actually DO the - * upcall as only then do we know which KSE we got. */ bcopy(td0->td_frame, td->td_frame, sizeof(struct trapframe)); diff --git a/sys/amd64/conf/DEFAULTS b/sys/amd64/conf/DEFAULTS index e98b169..3477caf 100644 --- a/sys/amd64/conf/DEFAULTS +++ b/sys/amd64/conf/DEFAULTS @@ -18,6 +18,3 @@ device uart_ns8250 # Default partitioning schemes options GEOM_BSD options GEOM_MBR - -# KSE support went from being default to a kernel option -options KSE diff --git a/sys/amd64/linux32/linux32_sysvec.c b/sys/amd64/linux32/linux32_sysvec.c index 2f9fd9f..3906852 100644 --- a/sys/amd64/linux32/linux32_sysvec.c +++ b/sys/amd64/linux32/linux32_sysvec.c @@ -247,8 +247,7 @@ elf_linux_fixup(register_t **stack_base, struct image_params *imgp) Elf32_Addr *base; Elf32_Addr *pos; - KASSERT(curthread->td_proc == imgp->proc && - (curthread->td_proc->p_flag & P_SA) == 0, + KASSERT(curthread->td_proc == imgp->proc, ("unsafe elf_linux_fixup(), should be curproc")); base = (Elf32_Addr *)*stack_base; args = (Elf32_Auxargs *)imgp->auxargs; diff --git a/sys/arm/arm/trap.c b/sys/arm/arm/trap.c index 8424a17..fc03b52 100644 --- a/sys/arm/arm/trap.c +++ b/sys/arm/arm/trap.c @@ -262,10 +262,6 @@ data_abort_handler(trapframe_t *tf) td->td_frame = tf; if (td->td_ucred != td->td_proc->p_ucred) cred_update_thread(td); -#ifdef KSE - if (td->td_pflags & TDP_SA) - thread_user_enter(td); -#endif } /* Grab the current pcb */ @@ -731,10 +727,6 @@ prefetch_abort_handler(trapframe_t *tf) td->td_frame = tf; if (td->td_ucred != td->td_proc->p_ucred) cred_update_thread(td); -#ifdef KSE - if (td->td_proc->p_flag & P_SA) - thread_user_enter(td); -#endif } fault_pc = tf->tf_pc; if (td->td_md.md_spinlock_count == 0) { @@ -1008,10 +1000,6 @@ swi_handler(trapframe_t *frame) td->td_frame = frame; td->td_pticks = 0; -#ifdef KSE - if (td->td_proc->p_flag & P_SA) - thread_user_enter(td); -#endif /* * Make sure the program counter is correctly aligned so we * don't take an alignment fault trying to read the opcode. diff --git a/sys/arm/conf/AVILA b/sys/arm/conf/AVILA index 1fbe148..2308152 100644 --- a/sys/arm/conf/AVILA +++ b/sys/arm/conf/AVILA @@ -49,7 +49,6 @@ options DDB #Enable the kernel debugger #options DIAGNOSTIC options SCHED_4BSD #4BSD scheduler -options KSE options INET #InterNETworking options INET6 #IPv6 communications protocols options FFS #Berkeley Fast Filesystem diff --git a/sys/arm/xscale/i8134x/crb_machdep.c b/sys/arm/xscale/i8134x/crb_machdep.c index 0c6475a..18570e4 100644 --- a/sys/arm/xscale/i8134x/crb_machdep.c +++ b/sys/arm/xscale/i8134x/crb_machdep.c @@ -406,11 +406,7 @@ initarm(void *arg, void *arg2) undefined_handler_address = (u_int)undefinedinstruction_bounce; undefined_init(); -#ifdef KSE - proc_linkup(&proc0, &ksegrp0, &thread0); -#else proc_linkup0(&proc0, &thread0); -#endif thread0.td_kstack = kernelstack.pv_va; thread0.td_pcb = (struct pcb *) (thread0.td_kstack + KSTACK_PAGES * PAGE_SIZE) - 1; diff --git a/sys/compat/freebsd32/freebsd32_syscall.h b/sys/compat/freebsd32/freebsd32_syscall.h index cb98700..a5d0fd6 100644 --- a/sys/compat/freebsd32/freebsd32_syscall.h +++ b/sys/compat/freebsd32/freebsd32_syscall.h @@ -284,11 +284,6 @@ #define FREEBSD32_SYS___setugid 374 #define FREEBSD32_SYS_eaccess 376 #define FREEBSD32_SYS_nmount 378 -#define FREEBSD32_SYS_kse_exit 379 -#define FREEBSD32_SYS_kse_wakeup 380 -#define FREEBSD32_SYS_kse_create 381 -#define FREEBSD32_SYS_kse_thr_interrupt 382 -#define FREEBSD32_SYS_kse_release 383 #define FREEBSD32_SYS_kenv 390 #define FREEBSD32_SYS_lchflags 391 #define FREEBSD32_SYS_uuidgen 392 diff --git a/sys/compat/freebsd32/freebsd32_syscalls.c b/sys/compat/freebsd32/freebsd32_syscalls.c index 82e3c05..4713dc3 100644 --- a/sys/compat/freebsd32/freebsd32_syscalls.c +++ b/sys/compat/freebsd32/freebsd32_syscalls.c @@ -386,11 +386,11 @@ const char *freebsd32_syscallnames[] = { "eaccess", /* 376 = eaccess */ "#377", /* 377 = afs_syscall */ "nmount", /* 378 = nmount */ - "kse_exit", /* 379 = kse_exit */ - "kse_wakeup", /* 380 = kse_wakeup */ - "kse_create", /* 381 = kse_create */ - "kse_thr_interrupt", /* 382 = kse_thr_interrupt */ - "kse_release", /* 383 = kse_release */ + "#379", /* 379 = kse_exit */ + "#380", /* 380 = kse_wakeup */ + "#381", /* 381 = kse_create */ + "#382", /* 382 = kse_thr_interrupt */ + "#383", /* 383 = kse_release */ "#384", /* 384 = __mac_get_proc */ "#385", /* 385 = __mac_set_proc */ "#386", /* 386 = __mac_get_fd */ diff --git a/sys/compat/freebsd32/freebsd32_sysent.c b/sys/compat/freebsd32/freebsd32_sysent.c index ab7ee2a..d45b3ce 100644 --- a/sys/compat/freebsd32/freebsd32_sysent.c +++ b/sys/compat/freebsd32/freebsd32_sysent.c @@ -418,11 +418,11 @@ struct sysent freebsd32_sysent[] = { { AS(eaccess_args), (sy_call_t *)eaccess, AUE_EACCESS, NULL, 0, 0 }, /* 376 = eaccess */ { 0, (sy_call_t *)nosys, AUE_NULL, NULL, 0, 0 }, /* 377 = afs_syscall */ { AS(nmount_args), (sy_call_t *)nmount, AUE_NMOUNT, NULL, 0, 0 }, /* 378 = nmount */ - { 0, (sy_call_t *)kse_exit, AUE_NULL, NULL, 0, 0 }, /* 379 = kse_exit */ - { AS(kse_wakeup_args), (sy_call_t *)kse_wakeup, AUE_NULL, NULL, 0, 0 }, /* 380 = kse_wakeup */ - { AS(kse_create_args), (sy_call_t *)kse_create, AUE_NULL, NULL, 0, 0 }, /* 381 = kse_create */ - { AS(kse_thr_interrupt_args), (sy_call_t *)kse_thr_interrupt, AUE_NULL, NULL, 0, 0 }, /* 382 = kse_thr_interrupt */ - { 0, (sy_call_t *)kse_release, AUE_NULL, NULL, 0, 0 }, /* 383 = kse_release */ + { 0, (sy_call_t *)nosys, AUE_NULL, NULL, 0, 0 }, /* 379 = kse_exit */ + { 0, (sy_call_t *)nosys, AUE_NULL, NULL, 0, 0 }, /* 380 = kse_wakeup */ + { 0, (sy_call_t *)nosys, AUE_NULL, NULL, 0, 0 }, /* 381 = kse_create */ + { 0, (sy_call_t *)nosys, AUE_NULL, NULL, 0, 0 }, /* 382 = kse_thr_interrupt */ + { 0, (sy_call_t *)nosys, AUE_NULL, NULL, 0, 0 }, /* 383 = kse_release */ { 0, (sy_call_t *)nosys, AUE_NULL, NULL, 0, 0 }, /* 384 = __mac_get_proc */ { 0, (sy_call_t *)nosys, AUE_NULL, NULL, 0, 0 }, /* 385 = __mac_set_proc */ { 0, (sy_call_t *)nosys, AUE_NULL, NULL, 0, 0 }, /* 386 = __mac_get_fd */ diff --git a/sys/compat/freebsd32/syscalls.master b/sys/compat/freebsd32/syscalls.master index 1394a92..c56eec4 100644 --- a/sys/compat/freebsd32/syscalls.master +++ b/sys/compat/freebsd32/syscalls.master @@ -645,13 +645,11 @@ 377 AUE_NULL UNIMPL afs_syscall 378 AUE_NMOUNT NOPROTO { int nmount(struct iovec *iovp, \ unsigned int iovcnt, int flags); } -379 AUE_NULL NOPROTO { int kse_exit(void); } -380 AUE_NULL NOPROTO { int kse_wakeup(struct kse_mailbox *mbx); } -381 AUE_NULL NOPROTO { int kse_create(struct kse_mailbox *mbx, \ - int newgroup); } -382 AUE_NULL NOPROTO { int kse_thr_interrupt( \ - struct kse_thr_mailbox *tmbx); } -383 AUE_NULL NOPROTO { int kse_release(void); } +379 AUE_NULL UNIMPL kse_exit +380 AUE_NULL UNIMPL kse_wakeup +381 AUE_NULL UNIMPL kse_create +382 AUE_NULL UNIMPL kse_thr_interrupt +383 AUE_NULL UNIMPL kse_release 384 AUE_NULL UNIMPL __mac_get_proc 385 AUE_NULL UNIMPL __mac_set_proc 386 AUE_NULL UNIMPL __mac_get_fd diff --git a/sys/conf/files b/sys/conf/files index 41af3db..2e47b33 100644 --- a/sys/conf/files +++ b/sys/conf/files @@ -1459,7 +1459,6 @@ kern/kern_fork.c standard kern/kern_idle.c standard kern/kern_intr.c standard kern/kern_jail.c standard -kern/kern_kse.c standard kern/kern_kthread.c standard kern/kern_ktr.c optional ktr kern/kern_ktrace.c standard diff --git a/sys/conf/options b/sys/conf/options index 2525f29..97fb06c 100644 --- a/sys/conf/options +++ b/sys/conf/options @@ -104,7 +104,6 @@ GEOM_UZIP opt_geom.h GEOM_VIRSTOR opt_geom.h GEOM_VOL opt_geom.h GEOM_ZERO opt_geom.h -KSE opt_global.h KSTACK_MAX_PAGES KSTACK_PAGES KTRACE diff --git a/sys/fs/fifofs/fifo_vnops.c b/sys/fs/fifofs/fifo_vnops.c index 10266b7..051b59b 100644 --- a/sys/fs/fifofs/fifo_vnops.c +++ b/sys/fs/fifofs/fifo_vnops.c @@ -43,7 +43,7 @@ #include <sys/mutex.h> #include <sys/malloc.h> #include <sys/poll.h> -#include <sys/proc.h> /* XXXKSE */ +#include <sys/proc.h> #include <sys/signalvar.h> #include <sys/socket.h> #include <sys/socketvar.h> diff --git a/sys/fs/procfs/procfs_ctl.c b/sys/fs/procfs/procfs_ctl.c index 89aa304..ca227e8 100644 --- a/sys/fs/procfs/procfs_ctl.c +++ b/sys/fs/procfs/procfs_ctl.c @@ -189,7 +189,7 @@ out: /* * do single-step fixup if needed */ - FIX_SSTEP(FIRST_THREAD_IN_PROC(p)); /* XXXKSE */ + FIX_SSTEP(FIRST_THREAD_IN_PROC(p)); #endif /* @@ -245,7 +245,7 @@ out: * What does it mean to single step a threaded program? */ case PROCFS_CTL_STEP: - error = proc_sstep(FIRST_THREAD_IN_PROC(p)); /* XXXKSE */ + error = proc_sstep(FIRST_THREAD_IN_PROC(p)); PROC_UNLOCK(p); if (error) return (error); @@ -335,14 +335,11 @@ procfs_doprocctl(PFS_FILL_ARGS) printf("procfs: got a sig%s\n", sbuf_data(sb)); PROC_LOCK(p); - /* This is very broken XXXKSE: */ if (TRACE_WAIT_P(td->td_proc, p)) { p->p_xstat = nm->nm_val; #ifdef FIX_SSTEP - /* XXXKSE: */ FIX_SSTEP(FIRST_THREAD_IN_PROC(p)); #endif - /* XXXKSE: */ p->p_flag &= ~P_STOPPED_SIG; PROC_SLOCK(p); thread_unsuspend(p); diff --git a/sys/fs/procfs/procfs_dbregs.c b/sys/fs/procfs/procfs_dbregs.c index d985245..722e4cf 100644 --- a/sys/fs/procfs/procfs_dbregs.c +++ b/sys/fs/procfs/procfs_dbregs.c @@ -105,7 +105,6 @@ procfs_doprocdbregs(PFS_FILL_ARGS) return (EPERM); } - /* XXXKSE: */ td2 = FIRST_THREAD_IN_PROC(p); #ifdef COMPAT_IA32 if (td->td_proc->p_sysent == &ia32_freebsd_sysvec) { diff --git a/sys/fs/procfs/procfs_status.c b/sys/fs/procfs/procfs_status.c index 871d7fc..a1eefb4 100644 --- a/sys/fs/procfs/procfs_status.c +++ b/sys/fs/procfs/procfs_status.c @@ -112,20 +112,13 @@ procfs_doprocstatus(PFS_FILL_ARGS) sbuf_printf(sb, "noflags"); } -#ifdef KSE - if (p->p_flag & P_SA) - wmesg = "-kse- "; - else -#endif - { - tdfirst = FIRST_THREAD_IN_PROC(p); - if (tdfirst->td_wchan != NULL) { - KASSERT(tdfirst->td_wmesg != NULL, - ("wchan %p has no wmesg", tdfirst->td_wchan)); - wmesg = tdfirst->td_wmesg; - } else - wmesg = "nochan"; - } + tdfirst = FIRST_THREAD_IN_PROC(p); + if (tdfirst->td_wchan != NULL) { + KASSERT(tdfirst->td_wmesg != NULL, + ("wchan %p has no wmesg", tdfirst->td_wchan)); + wmesg = tdfirst->td_wmesg; + } else + wmesg = "nochan"; if (p->p_flag & P_INMEM) { struct timeval start, ut, st; diff --git a/sys/i386/conf/DEFAULTS b/sys/i386/conf/DEFAULTS index a5f69a1..b19af35 100644 --- a/sys/i386/conf/DEFAULTS +++ b/sys/i386/conf/DEFAULTS @@ -22,6 +22,3 @@ device uart_ns8250 # Default partitioning schemes options GEOM_BSD options GEOM_MBR - -# KSE support went from being default to a kernel option -options KSE diff --git a/sys/i386/i386/sys_machdep.c b/sys/i386/i386/sys_machdep.c index 98e845a..97ebe34 100644 --- a/sys/i386/i386/sys_machdep.c +++ b/sys/i386/i386/sys_machdep.c @@ -233,9 +233,6 @@ i386_extend_pcb(struct thread *td) 0 /* granularity */ }; - if (td->td_proc->p_flag & P_SA) - return (EINVAL); /* XXXKSE */ -/* XXXKSE All the code below only works in 1:1 needs changing */ ext = (struct pcb_ext *)kmem_alloc(kernel_map, ctob(IOPAGES+1)); if (ext == 0) return (ENOMEM); diff --git a/sys/i386/i386/trap.c b/sys/i386/i386/trap.c index d6aa973..88750d4 100644 --- a/sys/i386/i386/trap.c +++ b/sys/i386/i386/trap.c @@ -348,10 +348,6 @@ trap(struct trapframe *frame) break; case T_PAGEFLT: /* page fault */ -#ifdef KSE - if (td->td_pflags & TDP_SA) - thread_user_enter(td); -#endif i = trap_pfault(frame, TRUE, eva); #if defined(I586_CPU) && !defined(NO_F00F_HACK) @@ -959,10 +955,6 @@ syscall(struct trapframe *frame) td->td_frame = frame; if (td->td_ucred != p->p_ucred) cred_update_thread(td); -#ifdef KSE - if (p->p_flag & P_SA) - thread_user_enter(td); -#endif params = (caddr_t)frame->tf_esp + sizeof(int); code = frame->tf_eax; orig_tf_eflags = frame->tf_eflags; diff --git a/sys/i386/i386/vm_machdep.c b/sys/i386/i386/vm_machdep.c index 346d423..f041b54 100644 --- a/sys/i386/i386/vm_machdep.c +++ b/sys/i386/i386/vm_machdep.c @@ -53,7 +53,6 @@ __FBSDID("$FreeBSD$"); #include <sys/systm.h> #include <sys/bio.h> #include <sys/buf.h> -#include <sys/kse.h> #include <sys/kernel.h> #include <sys/ktr.h> #include <sys/lock.h> @@ -338,7 +337,6 @@ cpu_thread_clean(struct thread *td) pcb = td->td_pcb; if (pcb->pcb_ext != NULL) { - /* XXXKSE XXXSMP not SMP SAFE.. what locks do we have? */ /* if (pcb->pcb_ext->ext_refcount-- == 1) ?? */ /* * XXX do we need to move the TSS off the allocated pages @@ -396,23 +394,12 @@ cpu_set_upcall(struct thread *td, struct thread *td0) * Copy the upcall pcb. This loads kernel regs. * Those not loaded individually below get their default * values here. - * - * XXXKSE It might be a good idea to simply skip this as - * the values of the other registers may be unimportant. - * This would remove any requirement for knowing the KSE - * at this time (see the matching comment below for - * more analysis) (need a good safe default). */ bcopy(td0->td_pcb, pcb2, sizeof(*pcb2)); pcb2->pcb_flags &= ~(PCB_NPXTRAP|PCB_NPXINITDONE); /* * Create a new fresh stack for the new thread. - * The -16 is so we can expand the trapframe if we go to vm86. - * Don't forget to set this stack value into whatever supplies - * the address for the fault handlers. - * The contexts are filled in at the time we actually DO the - * upcall as only then do we know which KSE we got. */ bcopy(td0->td_frame, td->td_frame, sizeof(struct trapframe)); @@ -439,7 +426,7 @@ cpu_set_upcall(struct thread *td, struct thread *td0) * pcb2->pcb_savefpu: cloned above. * pcb2->pcb_flags: cloned above. * pcb2->pcb_onfault: cloned above (always NULL here?). - * pcb2->pcb_gs: cloned above. XXXKSE ??? + * pcb2->pcb_gs: cloned above. * pcb2->pcb_ext: cleared below. */ pcb2->pcb_ext = NULL; diff --git a/sys/i386/ibcs2/imgact_coff.c b/sys/i386/ibcs2/imgact_coff.c index 348820c..5c08e0d 100644 --- a/sys/i386/ibcs2/imgact_coff.c +++ b/sys/i386/ibcs2/imgact_coff.c @@ -405,7 +405,7 @@ exec_coff_imgact(imgp) DPRINTF(("%s(%d): shared library %s\n", __FILE__, __LINE__, libname)); strlcpy(&libbuf[emul_path_len], libname, MAXPATHLEN); -/* XXXKSE only 1:1 in coff */ error = coff_load_file( + error = coff_load_file( FIRST_THREAD_IN_PROC(imgp->proc), libbuf); if (error) error = coff_load_file( diff --git a/sys/i386/linux/linux_sysvec.c b/sys/i386/linux/linux_sysvec.c index 177691c..b2c42ea 100644 --- a/sys/i386/linux/linux_sysvec.c +++ b/sys/i386/linux/linux_sysvec.c @@ -239,8 +239,7 @@ elf_linux_fixup(register_t **stack_base, struct image_params *imgp) Elf32_Auxargs *args; register_t *pos; - KASSERT(curthread->td_proc == imgp->proc && - (curthread->td_proc->p_flag & P_SA) == 0, + KASSERT(curthread->td_proc == imgp->proc, ("unsafe elf_linux_fixup(), should be curproc")); args = (Elf32_Auxargs *)imgp->auxargs; pos = *stack_base + (imgp->args->argc + imgp->args->envc + 2); diff --git a/sys/ia64/conf/DEFAULTS b/sys/ia64/conf/DEFAULTS index 7afec5c..1a96cd6 100644 --- a/sys/ia64/conf/DEFAULTS +++ b/sys/ia64/conf/DEFAULTS @@ -17,6 +17,3 @@ device uart_ns8250 options GEOM_PART_BSD options GEOM_PART_GPT options GEOM_PART_MBR - -# KSE support went from being default to a kernel option -options KSE diff --git a/sys/ia64/ia64/machdep.c b/sys/ia64/ia64/machdep.c index 6e98bd0..fe50d45 100644 --- a/sys/ia64/ia64/machdep.c +++ b/sys/ia64/ia64/machdep.c @@ -1231,9 +1231,6 @@ set_mcontext(struct thread *td, const mcontext_t *mc) restore_callee_saved(&mc->mc_preserved); restore_callee_saved_fp(&mc->mc_preserved_fp); - if (mc->mc_flags & _MC_FLAGS_KSE_SET_MBOX) - suword((caddr_t)mc->mc_special.ifa, mc->mc_special.isr); - return (0); } diff --git a/sys/ia64/ia64/trap.c b/sys/ia64/ia64/trap.c index a970353..aa31e6c 100644 --- a/sys/ia64/ia64/trap.c +++ b/sys/ia64/ia64/trap.c @@ -987,10 +987,6 @@ syscall(struct trapframe *tf) td->td_pticks = 0; if (td->td_ucred != p->p_ucred) cred_update_thread(td); -#ifdef KSE - if (p->p_flag & P_SA) - thread_user_enter(td); -#endif if (p->p_sysent->sv_prepsyscall) { /* (*p->p_sysent->sv_prepsyscall)(tf, args, &code, ¶ms); */ diff --git a/sys/ia64/include/ucontext.h b/sys/ia64/include/ucontext.h index 5619d59..f4af26c 100644 --- a/sys/ia64/include/ucontext.h +++ b/sys/ia64/include/ucontext.h @@ -79,7 +79,6 @@ typedef struct __mcontext { unsigned long mc_flags; #define _MC_FLAGS_ASYNC_CONTEXT 0x0001 #define _MC_FLAGS_HIGHFP_VALID 0x0002 -#define _MC_FLAGS_KSE_SET_MBOX 0x0004 /* Undocumented. Has to go. */ #define _MC_FLAGS_SYSCALL_CONTEXT 0x0008 unsigned long _reserved_; struct _special mc_special; diff --git a/sys/kern/imgact_elf.c b/sys/kern/imgact_elf.c index ff1bcda..42f82c8 100644 --- a/sys/kern/imgact_elf.c +++ b/sys/kern/imgact_elf.c @@ -480,9 +480,6 @@ __elfN(load_file)(struct proc *p, const char *file, u_long *addr, u_long base_addr = 0; int vfslocked, error, i, numsegs; - if (curthread->td_proc != p) - panic("elf_load_file - thread"); /* XXXKSE DIAGNOSTIC */ - tempdata = malloc(sizeof(*tempdata), M_TEMP, M_WAITOK); nd = &tempdata->nd; attr = &tempdata->attr; @@ -498,7 +495,6 @@ __elfN(load_file)(struct proc *p, const char *file, u_long *addr, imgp->object = NULL; imgp->execlabel = NULL; - /* XXXKSE */ NDINIT(nd, LOOKUP, MPSAFE|LOCKLEAF|FOLLOW, UIO_SYSSPACE, file, curthread); vfslocked = 0; @@ -999,7 +995,7 @@ __elfN(coredump)(td, vp, limit) (caddr_t)(uintptr_t)php->p_vaddr, php->p_filesz, offset, UIO_USERSPACE, IO_UNIT | IO_DIRECT, cred, NOCRED, NULL, - curthread); /* XXXKSE */ + curthread); if (error != 0) break; offset += php->p_filesz; @@ -1147,7 +1143,7 @@ __elfN(corehdr)(td, vp, cred, numsegs, hdr, hdrsize) /* Write it to the core file. */ return (vn_rdwr_inchunks(UIO_WRITE, vp, hdr, hdrsize, (off_t)0, UIO_SYSSPACE, IO_UNIT | IO_DIRECT, cred, NOCRED, NULL, - td)); /* XXXKSE */ + td)); } #if defined(COMPAT_IA32) && __ELF_WORD_SIZE == 32 diff --git a/sys/kern/init_sysent.c b/sys/kern/init_sysent.c index 37dd36b..5c34f2e 100644 --- a/sys/kern/init_sysent.c +++ b/sys/kern/init_sysent.c @@ -408,11 +408,11 @@ struct sysent sysent[] = { { AS(eaccess_args), (sy_call_t *)eaccess, AUE_EACCESS, NULL, 0, 0 }, /* 376 = eaccess */ { 0, (sy_call_t *)nosys, AUE_NULL, NULL, 0, 0 }, /* 377 = afs_syscall */ { AS(nmount_args), (sy_call_t *)nmount, AUE_NMOUNT, NULL, 0, 0 }, /* 378 = nmount */ - { 0, (sy_call_t *)kse_exit, AUE_NULL, NULL, 0, 0 }, /* 379 = kse_exit */ - { AS(kse_wakeup_args), (sy_call_t *)kse_wakeup, AUE_NULL, NULL, 0, 0 }, /* 380 = kse_wakeup */ - { AS(kse_create_args), (sy_call_t *)kse_create, AUE_NULL, NULL, 0, 0 }, /* 381 = kse_create */ - { AS(kse_thr_interrupt_args), (sy_call_t *)kse_thr_interrupt, AUE_NULL, NULL, 0, 0 }, /* 382 = kse_thr_interrupt */ - { AS(kse_release_args), (sy_call_t *)kse_release, AUE_NULL, NULL, 0, 0 }, /* 383 = kse_release */ + { 0, (sy_call_t *)nosys, AUE_NULL, NULL, 0, 0 }, /* 379 = kse_exit */ + { 0, (sy_call_t *)nosys, AUE_NULL, NULL, 0, 0 }, /* 380 = kse_wakeup */ + { 0, (sy_call_t *)nosys, AUE_NULL, NULL, 0, 0 }, /* 381 = kse_create */ + { 0, (sy_call_t *)nosys, AUE_NULL, NULL, 0, 0 }, /* 382 = kse_thr_interrupt */ + { 0, (sy_call_t *)nosys, AUE_NULL, NULL, 0, 0 }, /* 383 = kse_release */ { AS(__mac_get_proc_args), (sy_call_t *)__mac_get_proc, AUE_NULL, NULL, 0, 0 }, /* 384 = __mac_get_proc */ { AS(__mac_set_proc_args), (sy_call_t *)__mac_set_proc, AUE_NULL, NULL, 0, 0 }, /* 385 = __mac_set_proc */ { AS(__mac_get_fd_args), (sy_call_t *)__mac_get_fd, AUE_NULL, NULL, 0, 0 }, /* 386 = __mac_get_fd */ @@ -469,7 +469,7 @@ struct sysent sysent[] = { { AS(extattr_list_fd_args), (sy_call_t *)extattr_list_fd, AUE_EXTATTR_LIST_FD, NULL, 0, 0 }, /* 437 = extattr_list_fd */ { AS(extattr_list_file_args), (sy_call_t *)extattr_list_file, AUE_EXTATTR_LIST_FILE, NULL, 0, 0 }, /* 438 = extattr_list_file */ { AS(extattr_list_link_args), (sy_call_t *)extattr_list_link, AUE_EXTATTR_LIST_LINK, NULL, 0, 0 }, /* 439 = extattr_list_link */ - { AS(kse_switchin_args), (sy_call_t *)kse_switchin, AUE_NULL, NULL, 0, 0 }, /* 440 = kse_switchin */ + { 0, (sy_call_t *)nosys, AUE_NULL, NULL, 0, 0 }, /* 440 = kse_switchin */ { AS(ksem_timedwait_args), (sy_call_t *)lkmressys, AUE_NULL, NULL, 0, 0 }, /* 441 = ksem_timedwait */ { AS(thr_suspend_args), (sy_call_t *)thr_suspend, AUE_NULL, NULL, 0, 0 }, /* 442 = thr_suspend */ { AS(thr_wake_args), (sy_call_t *)thr_wake, AUE_NULL, NULL, 0, 0 }, /* 443 = thr_wake */ diff --git a/sys/kern/kern_clock.c b/sys/kern/kern_clock.c index fb0ca7e..c92d7de 100644 --- a/sys/kern/kern_clock.c +++ b/sys/kern/kern_clock.c @@ -477,10 +477,6 @@ statclock(int usermode) /* * Charge the time as appropriate. */ -#ifdef KSE - if (p->p_flag & P_SA) - thread_statclock(1); -#endif td->td_uticks++; if (p->p_nice > NZERO) cp_time[CP_NICE]++; @@ -504,10 +500,6 @@ statclock(int usermode) td->td_iticks++; cp_time[CP_INTR]++; } else { -#ifdef KSE - if (p->p_flag & P_SA) - thread_statclock(0); -#endif td->td_pticks++; td->td_sticks++; if (!TD_IS_IDLETHREAD(td)) diff --git a/sys/kern/kern_exec.c b/sys/kern/kern_exec.c index 2f81fcd..a972cb9 100644 --- a/sys/kern/kern_exec.c +++ b/sys/kern/kern_exec.c @@ -1194,7 +1194,7 @@ exec_check_permissions(imgp) struct thread *td; int error; - td = curthread; /* XXXKSE */ + td = curthread; /* Get file attributes */ error = VOP_GETATTR(vp, attr, td->td_ucred, td); diff --git a/sys/kern/kern_fork.c b/sys/kern/kern_fork.c index e6f891d..e59a1f4 100644 --- a/sys/kern/kern_fork.c +++ b/sys/kern/kern_fork.c @@ -764,7 +764,7 @@ fork_exit(callout, arg, frame) p = td->td_proc; KASSERT(p->p_state == PRS_NORMAL, ("executing process is still new")); - CTR4(KTR_PROC, "fork_exit: new thread %p (kse %p, pid %d, %s)", + CTR4(KTR_PROC, "fork_exit: new thread %p (td_sched %p, pid %d, %s)", td, td->td_sched, p->p_pid, td->td_name); sched_fork_exit(td); diff --git a/sys/kern/kern_intr.c b/sys/kern/kern_intr.c index 17af1ee..d9b983a 100644 --- a/sys/kern/kern_intr.c +++ b/sys/kern/kern_intr.c @@ -905,7 +905,6 @@ swi_add(struct intr_event **eventp, const char *name, driver_intr_t handler, } return (intr_event_add_handler(ie, name, NULL, handler, arg, (pri * RQ_PPQ) + PI_SOFT, flags, cookiep)); - /* XXKSE.. think of a better way to get separate queues */ } /* diff --git a/sys/kern/kern_kse.c b/sys/kern/kern_kse.c deleted file mode 100644 index 787aa49..0000000 --- a/sys/kern/kern_kse.c +++ /dev/null @@ -1,1445 +0,0 @@ -/*- - * Copyright (C) 2001 Julian Elischer <julian@freebsd.org>. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * 1. Redistributions of source code must retain the above copyright - * notice(s), this list of conditions and the following disclaimer as - * the first lines of this file unmodified other than the possible - * addition of one or more copyright notices. - * 2. Redistributions in binary form must reproduce the above copyright - * notice(s), this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) ``AS IS'' AND ANY - * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED - * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) BE LIABLE FOR ANY - * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES - * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR - * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER - * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT - * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY - * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH - * DAMAGE. - */ - -#include <sys/cdefs.h> -__FBSDID("$FreeBSD$"); - -#include <sys/param.h> -#include <sys/systm.h> -#include <sys/kernel.h> -#include <sys/imgact.h> -#include <sys/lock.h> -#include <sys/mutex.h> -#include <sys/proc.h> -#include <sys/ptrace.h> -#include <sys/smp.h> -#include <sys/syscallsubr.h> -#include <sys/sysproto.h> -#include <sys/sched.h> -#include <sys/signalvar.h> -#include <sys/sleepqueue.h> -#include <sys/syslog.h> -#include <sys/kse.h> -#include <sys/ktr.h> -#include <vm/uma.h> - -#ifdef KSE -static uma_zone_t upcall_zone; - -/* DEBUG ONLY */ -extern int virtual_cpu; -extern int thread_debug; - -extern int max_threads_per_proc; -extern int max_groups_per_proc; -extern int max_threads_hits; -extern struct mtx kse_lock; - - -TAILQ_HEAD(, kse_upcall) zombie_upcalls = - TAILQ_HEAD_INITIALIZER(zombie_upcalls); - -static int thread_update_usr_ticks(struct thread *td); -static int thread_alloc_spare(struct thread *td); -static struct thread *thread_schedule_upcall(struct thread *td, struct kse_upcall *ku); -static struct kse_upcall *upcall_alloc(void); - - -struct mtx kse_lock; -MTX_SYSINIT(kse_lock, &kse_lock, "kse lock", MTX_SPIN); - -struct kse_upcall * -upcall_alloc(void) -{ - struct kse_upcall *ku; - - ku = uma_zalloc(upcall_zone, M_WAITOK | M_ZERO); - return (ku); -} - -void -upcall_reap(void) -{ - TAILQ_HEAD(, kse_upcall) zupcalls; - struct kse_upcall *ku_item, *ku_tmp; - - TAILQ_INIT(&zupcalls); - mtx_lock_spin(&kse_lock); - if (!TAILQ_EMPTY(&zombie_upcalls)) { - TAILQ_CONCAT(&zupcalls, &zombie_upcalls, ku_link); - TAILQ_INIT(&zombie_upcalls); - } - mtx_unlock_spin(&kse_lock); - TAILQ_FOREACH_SAFE(ku_item, &zupcalls, ku_link, ku_tmp) - uma_zfree(upcall_zone, ku_item); -} - -void -upcall_remove(struct thread *td) -{ - - PROC_SLOCK_ASSERT(td->td_proc, MA_OWNED); - THREAD_LOCK_ASSERT(td, MA_OWNED); - if (td->td_upcall != NULL) { - /* - * If we are not a bound thread then decrement the count of - * possible upcall sources - */ - if (td->td_pflags & TDP_SA) - td->td_proc->p_numupcalls--; - mtx_lock_spin(&kse_lock); - td->td_upcall->ku_owner = NULL; - TAILQ_REMOVE(&td->td_upcall->ku_proc->p_upcalls, td->td_upcall, - ku_link); - TAILQ_INSERT_HEAD(&zombie_upcalls, td->td_upcall, ku_link); - mtx_unlock_spin(&kse_lock); - td->td_upcall = NULL; - } -} -#endif - -#ifndef _SYS_SYSPROTO_H_ -struct kse_switchin_args { - struct kse_thr_mailbox *tmbx; - int flags; -}; -#endif - -#ifdef KSE -void -kse_unlink(struct thread *td) -{ - mtx_lock_spin(&kse_lock); - thread_unlink(td); - mtx_unlock_spin(&kse_lock); - upcall_remove(td); -} -#endif - -int -kse_switchin(struct thread *td, struct kse_switchin_args *uap) -{ -#ifdef KSE - struct kse_thr_mailbox tmbx; - struct kse_upcall *ku; - int error; - - thread_lock(td); - if ((ku = td->td_upcall) == NULL || TD_CAN_UNBIND(td)) { - thread_unlock(td); - return (EINVAL); - } - thread_unlock(td); - error = (uap->tmbx == NULL) ? EINVAL : 0; - if (!error) - error = copyin(uap->tmbx, &tmbx, sizeof(tmbx)); - if (!error && (uap->flags & KSE_SWITCHIN_SETTMBX)) - error = (suword(&ku->ku_mailbox->km_curthread, - (long)uap->tmbx) != 0 ? EINVAL : 0); - if (!error) - error = set_mcontext(td, &tmbx.tm_context.uc_mcontext); - if (!error) { - suword32(&uap->tmbx->tm_lwp, td->td_tid); - if (uap->flags & KSE_SWITCHIN_SETTMBX) { - td->td_mailbox = uap->tmbx; - td->td_pflags |= TDP_CAN_UNBIND; - } - PROC_LOCK(td->td_proc); - if (td->td_proc->p_flag & P_TRACED) { - _PHOLD(td->td_proc); - if (tmbx.tm_dflags & TMDF_SSTEP) - ptrace_single_step(td); - else - ptrace_clear_single_step(td); - if (tmbx.tm_dflags & TMDF_SUSPEND) { - thread_lock(td); - /* fuword can block, check again */ - if (td->td_upcall) - ku->ku_flags |= KUF_DOUPCALL; - thread_unlock(td); - } - _PRELE(td->td_proc); - } - PROC_UNLOCK(td->td_proc); - } - return ((error == 0) ? EJUSTRETURN : error); -#else /* !KSE */ - return (EOPNOTSUPP); -#endif -} - -/* -struct kse_thr_interrupt_args { - struct kse_thr_mailbox * tmbx; - int cmd; - long data; -}; -*/ -int -kse_thr_interrupt(struct thread *td, struct kse_thr_interrupt_args *uap) -{ -#ifdef KSE - struct kse_execve_args args; - struct image_args iargs; - struct proc *p; - struct thread *td2; - struct kse_upcall *ku; - struct kse_thr_mailbox *tmbx; - uint32_t flags; - int error; - - p = td->td_proc; - - PROC_LOCK(p); - if (!(p->p_flag & P_SA)) { - PROC_UNLOCK(p); - return (EINVAL); - } - PROC_UNLOCK(p); - - switch (uap->cmd) { - case KSE_INTR_SENDSIG: - if (uap->data < 0 || uap->data > _SIG_MAXSIG) - return (EINVAL); - case KSE_INTR_INTERRUPT: - case KSE_INTR_RESTART: - PROC_LOCK(p); - PROC_SLOCK(p); - FOREACH_THREAD_IN_PROC(p, td2) { - if (td2->td_mailbox == uap->tmbx) - break; - } - if (td2 == NULL) { - PROC_SUNLOCK(p); - PROC_UNLOCK(p); - return (ESRCH); - } - thread_lock(td2); - PROC_SUNLOCK(p); - if (uap->cmd == KSE_INTR_SENDSIG) { - if (uap->data > 0) { - td2->td_flags &= ~TDF_INTERRUPT; - thread_unlock(td2); - tdsignal(p, td2, (int)uap->data, NULL); - } else { - thread_unlock(td2); - } - } else { - td2->td_flags |= TDF_INTERRUPT | TDF_ASTPENDING; - if (TD_CAN_UNBIND(td2)) - td2->td_upcall->ku_flags |= KUF_DOUPCALL; - if (uap->cmd == KSE_INTR_INTERRUPT) - td2->td_intrval = EINTR; - else - td2->td_intrval = ERESTART; - if (TD_ON_SLEEPQ(td2) && (td2->td_flags & TDF_SINTR)) - sleepq_abort(td2, td2->td_intrval); - thread_unlock(td2); - } - PROC_UNLOCK(p); - break; - case KSE_INTR_SIGEXIT: - if (uap->data < 1 || uap->data > _SIG_MAXSIG) - return (EINVAL); - PROC_LOCK(p); - sigexit(td, (int)uap->data); - break; - - case KSE_INTR_DBSUSPEND: - /* this sub-function is only for bound thread */ - if (td->td_pflags & TDP_SA) - return (EINVAL); - thread_lock(td); - ku = td->td_upcall; - thread_unlock(td); - tmbx = (void *)fuword((void *)&ku->ku_mailbox->km_curthread); - if (tmbx == NULL || tmbx == (void *)-1) - return (EINVAL); - flags = 0; - PROC_LOCK(p); - while ((p->p_flag & P_TRACED) && !(p->p_flag & P_SINGLE_EXIT)) { - flags = fuword32(&tmbx->tm_dflags); - if (!(flags & TMDF_SUSPEND)) - break; - PROC_SLOCK(p); - thread_stopped(p); - PROC_UNLOCK(p); - thread_lock(td); - thread_suspend_one(td); - PROC_SUNLOCK(p); - mi_switch(SW_VOL, NULL); - thread_unlock(td); - PROC_LOCK(p); - } - PROC_UNLOCK(p); - return (0); - - case KSE_INTR_EXECVE: - error = copyin((void *)uap->data, &args, sizeof(args)); - if (error) - return (error); - error = exec_copyin_args(&iargs, args.path, UIO_USERSPACE, - args.argv, args.envp); - if (error == 0) - error = kern_execve(td, &iargs, NULL); - if (error == 0) { - PROC_LOCK(p); - SIGSETOR(td->td_siglist, args.sigpend); - PROC_UNLOCK(p); - kern_sigprocmask(td, SIG_SETMASK, &args.sigmask, NULL, - 0); - } - return (error); - - default: - return (EINVAL); - } - return (0); -#else /* !KSE */ - return (EOPNOTSUPP); -#endif -} - -/* -struct kse_exit_args { - register_t dummy; -}; -*/ -int -kse_exit(struct thread *td, struct kse_exit_args *uap) -{ -#ifdef KSE - struct proc *p; - struct kse_upcall *ku, *ku2; - int error, count; - - p = td->td_proc; - /* - * Ensure that this is only called from the UTS - */ - thread_lock(td); - if ((ku = td->td_upcall) == NULL || TD_CAN_UNBIND(td)) { - thread_unlock(td); - return (EINVAL); - } - thread_unlock(td); - - /* - * Calculate the existing non-exiting upcalls in this process. - * If we are the last upcall but there are still other threads, - * then do not exit. We need the other threads to be able to - * complete whatever they are doing. - * XXX This relies on the userland knowing what to do if we return. - * It may be a better choice to convert ourselves into a kse_release - * ( or similar) and wait in the kernel to be needed. - * XXX Where are those other threads? I suppose they are waiting in - * the kernel. We should wait for them all at the user boundary after - * turning into an exit. - */ - count = 0; - PROC_LOCK(p); - PROC_SLOCK(p); - FOREACH_UPCALL_IN_PROC(p, ku2) { - if ((ku2->ku_flags & KUF_EXITING) == 0) - count++; - } - if (count == 1 && (p->p_numthreads > 1)) { - PROC_SUNLOCK(p); - PROC_UNLOCK(p); - return (EDEADLK); - } - ku->ku_flags |= KUF_EXITING; - PROC_SUNLOCK(p); - PROC_UNLOCK(p); - - /* - * Mark the UTS mailbox as having been finished with. - * If that fails then just go for a segfault. - * XXX need to check it that can be deliverred without a mailbox. - */ - error = suword32(&ku->ku_mailbox->km_flags, ku->ku_mflags|KMF_DONE); - if (!(td->td_pflags & TDP_SA)) - if (suword32(&td->td_mailbox->tm_lwp, 0)) - error = EFAULT; - PROC_LOCK(p); - if (error) - psignal(p, SIGSEGV); - sigqueue_flush(&td->td_sigqueue); - PROC_SLOCK(p); - thread_lock(td); - upcall_remove(td); - thread_unlock(td); - if (p->p_numthreads != 1) { - thread_stopped(p); - thread_exit(); - /* NOTREACHED */ - } - /* - * This is the last thread. Just return to the user. - * Effectively we have left threading mode.. - * The only real thing left to do is ensure that the - * scheduler sets out concurrency back to 1 as that may be a - * resource leak otherwise. - * This is an A[PB]I issue.. what SHOULD we do? - * One possibility is to return to the user. It may not cope well. - * The other possibility would be to let the process exit. - */ - thread_unthread(td); - PROC_SUNLOCK(p); - PROC_UNLOCK(p); -#if 0 - return (0); -#else - printf("kse_exit: called on last thread. Calling exit1()"); - exit1(td, 0); -#endif -#else /* !KSE */ - return (EOPNOTSUPP); -#endif -} - -/* - * Either becomes an upcall or waits for an awakening event and - * then becomes an upcall. Only error cases return. - */ -/* -struct kse_release_args { - struct timespec *timeout; -}; -*/ -int -kse_release(struct thread *td, struct kse_release_args *uap) -{ -#ifdef KSE - struct proc *p; - struct kse_upcall *ku; - struct timespec timeout; - struct timeval tv; - sigset_t sigset; - int error; - - p = td->td_proc; - thread_lock(td); - if ((ku = td->td_upcall) == NULL || TD_CAN_UNBIND(td)) { - thread_unlock(td); - printf("kse_release: called outside of threading. exiting"); - exit1(td, 0); - } - thread_unlock(td); - if (uap->timeout != NULL) { - if ((error = copyin(uap->timeout, &timeout, sizeof(timeout)))) - return (error); - TIMESPEC_TO_TIMEVAL(&tv, &timeout); - } - if (td->td_pflags & TDP_SA) - td->td_pflags |= TDP_UPCALLING; - else { - ku->ku_mflags = fuword32(&ku->ku_mailbox->km_flags); - if (ku->ku_mflags == -1) { - PROC_LOCK(p); - sigexit(td, SIGSEGV); - } - } - PROC_LOCK(p); - if (ku->ku_mflags & KMF_WAITSIGEVENT) { - /* UTS wants to wait for signal event */ - if (!(p->p_flag & P_SIGEVENT) && - !(ku->ku_flags & KUF_DOUPCALL)) { - td->td_kflags |= TDK_KSERELSIG; - error = msleep(&p->p_siglist, &p->p_mtx, PPAUSE|PCATCH, - "ksesigwait", (uap->timeout ? tvtohz(&tv) : 0)); - td->td_kflags &= ~(TDK_KSERELSIG | TDK_WAKEUP); - } - p->p_flag &= ~P_SIGEVENT; - sigset = p->p_siglist; - PROC_UNLOCK(p); - error = copyout(&sigset, &ku->ku_mailbox->km_sigscaught, - sizeof(sigset)); - } else { - if ((ku->ku_flags & KUF_DOUPCALL) == 0 && - ((ku->ku_mflags & KMF_NOCOMPLETED) || - (p->p_completed == NULL))) { - p->p_upsleeps++; - td->td_kflags |= TDK_KSEREL; - error = msleep(&p->p_completed, &p->p_mtx, - PPAUSE|PCATCH, "kserel", - (uap->timeout ? tvtohz(&tv) : 0)); - td->td_kflags &= ~(TDK_KSEREL | TDK_WAKEUP); - p->p_upsleeps--; - } - PROC_UNLOCK(p); - } - if (ku->ku_flags & KUF_DOUPCALL) { - PROC_SLOCK(p); - ku->ku_flags &= ~KUF_DOUPCALL; - PROC_SUNLOCK(p); - } - return (0); -#else /* !KSE */ - return (EOPNOTSUPP); -#endif -} - -/* struct kse_wakeup_args { - struct kse_mailbox *mbx; -}; */ -int -kse_wakeup(struct thread *td, struct kse_wakeup_args *uap) -{ -#ifdef KSE - struct proc *p; - struct kse_upcall *ku; - struct thread *td2; - - p = td->td_proc; - td2 = NULL; - ku = NULL; - /* KSE-enabled processes only, please. */ - PROC_LOCK(p); - if (!(p->p_flag & P_SA)) { - PROC_UNLOCK(p); - return (EINVAL); - } - PROC_SLOCK(p); - if (uap->mbx) { - FOREACH_UPCALL_IN_PROC(p, ku) { - if (ku->ku_mailbox == uap->mbx) - break; - } - } else { - if (p->p_upsleeps) { - PROC_SUNLOCK(p); - wakeup(&p->p_completed); - PROC_UNLOCK(p); - return (0); - } - ku = TAILQ_FIRST(&p->p_upcalls); - } - if (ku == NULL) { - PROC_SUNLOCK(p); - PROC_UNLOCK(p); - return (ESRCH); - } - mtx_lock_spin(&kse_lock); - if ((td2 = ku->ku_owner) == NULL) { - mtx_unlock_spin(&kse_lock); - PROC_SUNLOCK(p); - PROC_UNLOCK(p); - panic("%s: no owner", __func__); - } else if (td2->td_kflags & (TDK_KSEREL | TDK_KSERELSIG)) { - mtx_unlock_spin(&kse_lock); - if (!(td2->td_kflags & TDK_WAKEUP)) { - td2->td_kflags |= TDK_WAKEUP; - if (td2->td_kflags & TDK_KSEREL) - sleepq_remove(td2, &p->p_completed); - else - sleepq_remove(td2, &p->p_siglist); - } - } else { - ku->ku_flags |= KUF_DOUPCALL; - mtx_unlock_spin(&kse_lock); - } - PROC_SUNLOCK(p); - PROC_UNLOCK(p); - return (0); -#else /* !KSE */ - return (EOPNOTSUPP); -#endif -} - -/* - * newgroup == 0: first call: use current KSE, don't schedule an upcall - * All other situations, do allocate max new KSEs and schedule an upcall. - * - * XXX should be changed so that 'first' behaviour lasts for as long - * as you have not made a thread in this proc. i.e. as long as we do not have - * a mailbox.. - */ -/* struct kse_create_args { - struct kse_mailbox *mbx; - int newgroup; -}; */ -int -kse_create(struct thread *td, struct kse_create_args *uap) -{ -#ifdef KSE - struct proc *p; - struct kse_mailbox mbx; - struct kse_upcall *newku; - int err, ncpus, sa = 0, first = 0; - struct thread *newtd; - - p = td->td_proc; - - /* - * Processes using the other threading model can't - * suddenly start calling this one - * XXX maybe... - */ - PROC_LOCK(p); - if ((p->p_flag & (P_SA|P_HADTHREADS)) == P_HADTHREADS) { - PROC_UNLOCK(p); - return (EINVAL); - } - if (!(p->p_flag & P_SA)) { - first = 1; - p->p_flag |= P_SA|P_HADTHREADS; - } - PROC_UNLOCK(p); - - if ((err = copyin(uap->mbx, &mbx, sizeof(mbx)))) - return (err); - - ncpus = mp_ncpus; - if (virtual_cpu != 0) - ncpus = virtual_cpu; - /* - * If the new UTS mailbox says that this - * will be a BOUND lwp, then it had better - * have its thread mailbox already there. - */ - if ((mbx.km_flags & KMF_BOUND) || uap->newgroup) { - /* It's a bound thread (1:1) */ - if (mbx.km_curthread == NULL) - return (EINVAL); - ncpus = 1; - if (!(uap->newgroup || first)) - return (EINVAL); - } else { - /* It's an upcall capable thread */ - sa = TDP_SA; - PROC_LOCK(p); - /* - * Limit it to NCPU upcall contexts per proc in any case. - * numupcalls will soon be numkse or something - * as it will represent the number of - * non-bound upcalls available. (i.e. ones that can - * actually call up). - */ - if (p->p_numupcalls >= ncpus) { - PROC_UNLOCK(p); - return (EPROCLIM); - } - p->p_numupcalls++; - PROC_UNLOCK(p); - } - - /* - * For the first call this may not have been set. - * Of course nor may it actually be needed. - * thread_schedule_upcall() will look for it. - */ - if (td->td_standin == NULL) { - if (!thread_alloc_spare(td)) - return (ENOMEM); - } - - /* - * Even bound LWPs get a mailbox and an upcall to hold it. - * XXX This should change. - */ - newku = upcall_alloc(); - newku->ku_mailbox = uap->mbx; - newku->ku_func = mbx.km_func; - bcopy(&mbx.km_stack, &newku->ku_stack, sizeof(stack_t)); - - PROC_LOCK(p); - PROC_SLOCK(p); - /* - * If we are the first time, and a normal thread, - * then transfer all the signals back to the 'process'. - * SA threading will make a special thread to handle them. - */ - if (first) { - sigqueue_move_set(&td->td_sigqueue, &p->p_sigqueue, - &td->td_sigqueue.sq_signals); - SIGFILLSET(td->td_sigmask); - SIG_CANTMASK(td->td_sigmask); - } - - /* - * Make the new upcall available to the process. - * It may or may not use it, but it's available. - */ - TAILQ_INSERT_TAIL(&p->p_upcalls, newku, ku_link); - newku->ku_proc = p; - PROC_UNLOCK(p); - if (mbx.km_quantum) -/* XXX should this be in the thread? */ - p->p_upquantum = max(1, mbx.km_quantum / tick); - - /* - * Each upcall structure has an owner thread, find which - * one owns it. - */ - thread_lock(td); - mtx_lock_spin(&kse_lock); - if (uap->newgroup) { - /* - * The newgroup parameter now means - * "bound, non SA, system scope" - * It is only used for the interrupt thread at the - * moment I think.. (or system scope threads dopey). - * We'll rename it later. - */ - newtd = thread_schedule_upcall(td, newku); - } else { - /* - * If the current thread hasn't an upcall structure, - * just assign the upcall to it. - * It'll just return. - */ - if (td->td_upcall == NULL) { - newku->ku_owner = td; - td->td_upcall = newku; - newtd = td; - } else { - /* - * Create a new upcall thread to own it. - */ - newtd = thread_schedule_upcall(td, newku); - } - } - mtx_unlock_spin(&kse_lock); - thread_unlock(td); - PROC_SUNLOCK(p); - - /* - * Let the UTS instance know its LWPID. - * It doesn't really care. But the debugger will. - * XXX warning.. remember that this moves. - */ - suword32(&newku->ku_mailbox->km_lwp, newtd->td_tid); - - /* - * In the same manner, if the UTS has a current user thread, - * then it is also running on this LWP so set it as well. - * The library could do that of course.. but why not.. - * XXX I'm not sure this can ever happen but ... - * XXX does the UTS ever set this in the mailbox before calling this? - */ - if (mbx.km_curthread) - suword32(&mbx.km_curthread->tm_lwp, newtd->td_tid); - - if (sa) { - newtd->td_pflags |= TDP_SA; - /* - * If we are starting a new thread, kick it off. - */ - if (newtd != td) { - thread_lock(newtd); - sched_add(newtd, SRQ_BORING); - thread_unlock(newtd); - } - } else { - newtd->td_pflags &= ~TDP_SA; - - /* - * Since a library will use the mailbox pointer to - * identify even a bound thread, and the mailbox pointer - * will never be allowed to change after this syscall - * for a bound thread, set it here so the library can - * find the thread after the syscall returns. - */ - newtd->td_mailbox = mbx.km_curthread; - - if (newtd != td) { - /* - * If we did create a new thread then - * make sure it goes to the right place - * when it starts up, and make sure that it runs - * at full speed when it gets there. - * thread_schedule_upcall() copies all cpu state - * to the new thread, so we should clear single step - * flag here. - */ - cpu_set_upcall_kse(newtd, newku->ku_func, - newku->ku_mailbox, &newku->ku_stack); - PROC_LOCK(p); - if (p->p_flag & P_TRACED) { - _PHOLD(p); - ptrace_clear_single_step(newtd); - _PRELE(p); - } - PROC_UNLOCK(p); - thread_lock(newtd); - sched_add(newtd, SRQ_BORING); - thread_unlock(newtd); - } - } - return (0); -#else /* !KSE */ - return (EOPNOTSUPP); -#endif -} - -#ifdef KSE -/* - * Initialize global thread allocation resources. - */ -void -kseinit(void) -{ - - upcall_zone = uma_zcreate("UPCALL", sizeof(struct kse_upcall), - NULL, NULL, NULL, NULL, UMA_ALIGN_CACHE, 0); -} - -/* - * Store the thread context in the UTS's mailbox. - * then add the mailbox at the head of a list we are building in user space. - * The list is anchored in the proc structure. - */ -int -thread_export_context(struct thread *td, int willexit) -{ - struct proc *p; - uintptr_t mbx; - void *addr; - int error = 0, sig; - mcontext_t mc; - - p = td->td_proc; - - /* - * Post sync signal, or process SIGKILL and SIGSTOP. - * For sync signal, it is only possible when the signal is not - * caught by userland or process is being debugged. - */ - PROC_LOCK(p); - if (td->td_flags & TDF_NEEDSIGCHK) { - thread_lock(td); - td->td_flags &= ~TDF_NEEDSIGCHK; - thread_unlock(td); - mtx_lock(&p->p_sigacts->ps_mtx); - while ((sig = cursig(td)) != 0) - postsig(sig); - mtx_unlock(&p->p_sigacts->ps_mtx); - } - if (willexit) - SIGFILLSET(td->td_sigmask); - PROC_UNLOCK(p); - - /* Export the user/machine context. */ - get_mcontext(td, &mc, 0); - addr = (void *)(&td->td_mailbox->tm_context.uc_mcontext); - error = copyout(&mc, addr, sizeof(mcontext_t)); - if (error) - goto bad; - - addr = (caddr_t)(&td->td_mailbox->tm_lwp); - if (suword32(addr, 0)) { - error = EFAULT; - goto bad; - } - - /* Get address in latest mbox of list pointer */ - addr = (void *)(&td->td_mailbox->tm_next); - /* - * Put the saved address of the previous first - * entry into this one - */ - for (;;) { - mbx = (uintptr_t)p->p_completed; - if (suword(addr, mbx)) { - error = EFAULT; - goto bad; - } - PROC_LOCK(p); - if (mbx == (uintptr_t)p->p_completed) { - thread_lock(td); - p->p_completed = td->td_mailbox; - /* - * The thread context may be taken away by - * other upcall threads when we unlock - * process lock. it's no longer valid to - * use it again in any other places. - */ - td->td_mailbox = NULL; - thread_unlock(td); - PROC_UNLOCK(p); - break; - } - PROC_UNLOCK(p); - } - td->td_usticks = 0; - return (0); - -bad: - PROC_LOCK(p); - sigexit(td, SIGILL); - return (error); -} - -/* - * Take the list of completed mailboxes for this Process and put them on this - * upcall's mailbox as it's the next one going up. - */ -static int -thread_link_mboxes(struct proc *p, struct kse_upcall *ku) -{ - void *addr; - uintptr_t mbx; - - addr = (void *)(&ku->ku_mailbox->km_completed); - for (;;) { - mbx = (uintptr_t)p->p_completed; - if (suword(addr, mbx)) { - PROC_LOCK(p); - psignal(p, SIGSEGV); - PROC_UNLOCK(p); - return (EFAULT); - } - PROC_LOCK(p); - if (mbx == (uintptr_t)p->p_completed) { - p->p_completed = NULL; - PROC_UNLOCK(p); - break; - } - PROC_UNLOCK(p); - } - return (0); -} - -/* - * This function should be called at statclock interrupt time - */ -int -thread_statclock(int user) -{ - struct thread *td = curthread; - - if (!(td->td_pflags & TDP_SA)) - return (0); - if (user) { - /* Current always do via ast() */ - thread_lock(td); - td->td_flags |= TDF_ASTPENDING; - thread_unlock(td); - td->td_uuticks++; - } else if (td->td_mailbox != NULL) - td->td_usticks++; - return (0); -} - -/* - * Export state clock ticks for userland - */ -static int -thread_update_usr_ticks(struct thread *td) -{ - struct proc *p = td->td_proc; - caddr_t addr; - u_int uticks; - - thread_lock(td); - if (td->td_mailbox == NULL) { - thread_unlock(td); - return (-1); - } - thread_unlock(td); - - if ((uticks = td->td_uuticks) != 0) { - td->td_uuticks = 0; - addr = (caddr_t)&td->td_mailbox->tm_uticks; - if (suword32(addr, uticks+fuword32(addr))) - goto error; - } - if ((uticks = td->td_usticks) != 0) { - td->td_usticks = 0; - addr = (caddr_t)&td->td_mailbox->tm_sticks; - if (suword32(addr, uticks+fuword32(addr))) - goto error; - } - return (0); - -error: - PROC_LOCK(p); - psignal(p, SIGSEGV); - PROC_UNLOCK(p); - return (-2); -} - -/* - * This function is intended to be used to initialize a spare thread - * for upcall. Initialize thread's large data area outside the thread lock - * for thread_schedule_upcall(). The crhold is also here to get it out - * from the schedlock as it has a mutex op itself. - * XXX BUG.. we need to get the cr ref after the thread has - * checked and chenged its own, not 6 months before... - */ -int -thread_alloc_spare(struct thread *td) -{ - struct thread *spare; - - if (td->td_standin) - return (1); - spare = thread_alloc(); - if (spare == NULL) - return (0); - td->td_standin = spare; - bzero(&spare->td_startzero, - __rangeof(struct thread, td_startzero, td_endzero)); - spare->td_proc = td->td_proc; - spare->td_ucred = crhold(td->td_ucred); - spare->td_flags = TDF_INMEM; - return (1); -} - -/* - * Create a thread and schedule it for upcall on the KSE given. - * Use our thread's standin so that we don't have to allocate one. - */ -struct thread * -thread_schedule_upcall(struct thread *td, struct kse_upcall *ku) -{ - struct thread *td2; - - THREAD_LOCK_ASSERT(td, MA_OWNED); - mtx_assert(&kse_lock, MA_OWNED); - /* - * Schedule an upcall thread on specified kse_upcall, - * the kse_upcall must be free. - * td must have a spare thread. - */ - KASSERT(ku->ku_owner == NULL, ("%s: upcall has owner", __func__)); - if ((td2 = td->td_standin) != NULL) { - td->td_standin = NULL; - } else { - panic("no reserve thread when scheduling an upcall"); - return (NULL); - } - CTR3(KTR_PROC, "thread_schedule_upcall: thread %p (pid %d, %s)", - td2, td->td_proc->p_pid, td->td_name); - /* - * Bzero already done in thread_alloc_spare() because we can't - * do the crhold here because we are in schedlock already. - */ - bcopy(&td->td_startcopy, &td2->td_startcopy, - __rangeof(struct thread, td_startcopy, td_endcopy)); - sched_fork_thread(td, td2); - thread_link(td2, ku->ku_proc); - bcopy(ku->ku_proc->p_comm, td2->td_name, sizeof(td2->td_name)); - /* inherit parts of blocked thread's context as a good template */ - cpu_set_upcall(td2, td); - /* Let the new thread become owner of the upcall */ - ku->ku_owner = td2; - td2->td_upcall = ku; - td2->td_pflags = TDP_SA|TDP_UPCALLING; - td2->td_state = TDS_CAN_RUN; - td2->td_inhibitors = 0; - SIGFILLSET(td2->td_sigmask); - SIG_CANTMASK(td2->td_sigmask); - return (td2); /* bogus.. should be a void function */ -} - -/* - * It is only used when thread generated a trap and process is being - * debugged. - */ -void -thread_signal_add(struct thread *td, ksiginfo_t *ksi) -{ - struct proc *p; - struct sigacts *ps; - int error; - - p = td->td_proc; - PROC_LOCK_ASSERT(p, MA_OWNED); - ps = p->p_sigacts; - mtx_assert(&ps->ps_mtx, MA_OWNED); - - mtx_unlock(&ps->ps_mtx); - SIGADDSET(td->td_sigmask, ksi->ksi_signo); - PROC_UNLOCK(p); - error = copyout(&ksi->ksi_info, &td->td_mailbox->tm_syncsig, - sizeof(siginfo_t)); - if (error) { - PROC_LOCK(p); - sigexit(td, SIGSEGV); - } - PROC_LOCK(p); - mtx_lock(&ps->ps_mtx); -} -#include "opt_sched.h" -struct thread * -thread_switchout(struct thread *td, int flags, struct thread *nextthread) -{ - struct kse_upcall *ku; - struct thread *td2; - - THREAD_LOCK_ASSERT(td, MA_OWNED); - - /* - * If the outgoing thread is in threaded group and has never - * scheduled an upcall, decide whether this is a short - * or long term event and thus whether or not to schedule - * an upcall. - * If it is a short term event, just suspend it in - * a way that takes its KSE with it. - * Select the events for which we want to schedule upcalls. - * For now it's just sleep or if thread is suspended but - * process wide suspending flag is not set (debugger - * suspends thread). - * XXXKSE eventually almost any inhibition could do. - */ - if (TD_CAN_UNBIND(td) && (td->td_standin) && - (TD_ON_SLEEPQ(td) || (TD_IS_SUSPENDED(td) && - !P_SHOULDSTOP(td->td_proc)))) { - /* - * Release ownership of upcall, and schedule an upcall - * thread, this new upcall thread becomes the owner of - * the upcall structure. It will be ahead of us in the - * run queue, so as we are stopping, it should either - * start up immediatly, or at least before us if - * we release our slot. - */ - mtx_lock_spin(&kse_lock); - ku = td->td_upcall; - ku->ku_owner = NULL; - td->td_upcall = NULL; - td->td_pflags &= ~TDP_CAN_UNBIND; - td2 = thread_schedule_upcall(td, ku); - mtx_unlock_spin(&kse_lock); - if (flags & SW_INVOL || nextthread) { - thread_lock(td2); - sched_add(td2, SRQ_YIELDING); - thread_unlock(td2); - } else { - /* Keep up with reality.. we have one extra thread - * in the picture.. and it's 'running'. - */ - return td2; - } - } - return (nextthread); -} - -/* - * Setup done on the thread when it enters the kernel. - */ -void -thread_user_enter(struct thread *td) -{ - struct proc *p = td->td_proc; - struct kse_upcall *ku; - struct kse_thr_mailbox *tmbx; - uint32_t flags; - - /* - * First check that we shouldn't just abort. we - * can suspend it here or just exit. - */ - if (__predict_false(P_SHOULDSTOP(p))) { - PROC_LOCK(p); - thread_suspend_check(0); - PROC_UNLOCK(p); - } - - if (!(td->td_pflags & TDP_SA)) - return; - - /* - * If we are doing a syscall in a KSE environment, - * note where our mailbox is. - */ - - thread_lock(td); - ku = td->td_upcall; - thread_unlock(td); - - KASSERT(ku != NULL, ("no upcall owned")); - KASSERT(ku->ku_owner == td, ("wrong owner")); - KASSERT(!TD_CAN_UNBIND(td), ("can unbind")); - - if (td->td_standin == NULL) { - if (!thread_alloc_spare(td)) { - PROC_LOCK(p); - if (kern_logsigexit) - log(LOG_INFO, - "pid %d (%s), uid %d: thread_alloc_spare failed\n", - p->p_pid, p->p_comm, - td->td_ucred ? td->td_ucred->cr_uid : -1); - sigexit(td, SIGSEGV); /* XXX ? */ - /* panic("thread_user_enter: thread_alloc_spare failed"); */ - } - } - ku->ku_mflags = fuword32((void *)&ku->ku_mailbox->km_flags); - tmbx = (void *)fuword((void *)&ku->ku_mailbox->km_curthread); - if ((tmbx == NULL) || (tmbx == (void *)-1L) || - (ku->ku_mflags & KMF_NOUPCALL)) { - td->td_mailbox = NULL; - } else { - flags = fuword32(&tmbx->tm_flags); - /* - * On some architectures, TP register points to thread - * mailbox but not points to kse mailbox, and userland - * can not atomically clear km_curthread, but can - * use TP register, and set TMF_NOUPCALL in thread - * flag to indicate a critical region. - */ - if (flags & TMF_NOUPCALL) { - td->td_mailbox = NULL; - } else { - td->td_mailbox = tmbx; - td->td_pflags |= TDP_CAN_UNBIND; - PROC_LOCK(p); - if (__predict_false(p->p_flag & P_TRACED)) { - flags = fuword32(&tmbx->tm_dflags); - if (flags & TMDF_SUSPEND) { - thread_lock(td); - /* fuword can block, check again */ - if (td->td_upcall) - ku->ku_flags |= KUF_DOUPCALL; - thread_unlock(td); - } - } - PROC_UNLOCK(p); - } - } -} - -/* - * The extra work we go through if we are a threaded process when we - * return to userland. - * - * If we are a KSE process and returning to user mode, check for - * extra work to do before we return (e.g. for more syscalls - * to complete first). If we were in a critical section, we should - * just return to let it finish. Same if we were in the UTS (in - * which case the mailbox's context's busy indicator will be set). - * The only traps we suport will have set the mailbox. - * We will clear it here. - */ -int -thread_userret(struct thread *td, struct trapframe *frame) -{ - struct kse_upcall *ku; - struct proc *p; - struct timespec ts; - int error = 0, uts_crit; - - /* Nothing to do with bound thread */ - if (!(td->td_pflags & TDP_SA)) - return (0); - - /* - * Update stat clock count for userland - */ - if (td->td_mailbox != NULL) { - thread_update_usr_ticks(td); - uts_crit = 0; - } else { - uts_crit = 1; - } - - p = td->td_proc; - thread_lock(td); - ku = td->td_upcall; - - /* - * Optimisation: - * This thread has not started any upcall. - * If there is no work to report other than ourself, - * then it can return direct to userland. - */ - if (TD_CAN_UNBIND(td)) { - thread_unlock(td); - td->td_pflags &= ~TDP_CAN_UNBIND; - if ((td->td_flags & TDF_NEEDSIGCHK) == 0 && - (p->p_completed == NULL) && - (ku->ku_flags & KUF_DOUPCALL) == 0 && - (p->p_upquantum && ticks < p->p_nextupcall)) { - nanotime(&ts); - error = copyout(&ts, - (caddr_t)&ku->ku_mailbox->km_timeofday, - sizeof(ts)); - td->td_mailbox = 0; - ku->ku_mflags = 0; - if (error) - goto out; - return (0); - } - thread_export_context(td, 0); - /* - * There is something to report, and we own an upcall - * structure, we can go to userland. - * Turn ourself into an upcall thread. - */ - td->td_pflags |= TDP_UPCALLING; - } else if (td->td_mailbox && (ku == NULL)) { - thread_unlock(td); - thread_export_context(td, 1); - PROC_LOCK(p); - if (p->p_upsleeps) - wakeup(&p->p_completed); - WITNESS_WARN(WARN_PANIC, &p->p_mtx.lock_object, - "thread exiting in userret"); - sigqueue_flush(&td->td_sigqueue); - PROC_SLOCK(p); - thread_stopped(p); - thread_exit(); - /* NOTREACHED */ - } else - thread_unlock(td); - - KASSERT(ku != NULL, ("upcall is NULL")); - KASSERT(TD_CAN_UNBIND(td) == 0, ("can unbind")); - - PROC_LOCK(p); - PROC_SLOCK(p); - if (p->p_numthreads > max_threads_per_proc) { - max_threads_hits++; - while (p->p_numthreads > max_threads_per_proc) { - if (p->p_numupcalls >= max_threads_per_proc) - break; - PROC_SUNLOCK(p); - if (msleep(&p->p_numthreads, &p->p_mtx, PPAUSE|PCATCH, - "maxthreads", hz/10) != EWOULDBLOCK) { - PROC_SLOCK(p); - break; - } else - PROC_SLOCK(p); - } - } - PROC_SUNLOCK(p); - PROC_UNLOCK(p); - - if (td->td_pflags & TDP_UPCALLING) { - uts_crit = 0; - p->p_nextupcall = ticks + p->p_upquantum; - /* - * There is no more work to do and we are going to ride - * this thread up to userland as an upcall. - * Do the last parts of the setup needed for the upcall. - */ - CTR3(KTR_PROC, "userret: upcall thread %p (pid %d, %s)", - td, td->td_proc->p_pid, td->td_name); - - td->td_pflags &= ~TDP_UPCALLING; - if (ku->ku_flags & KUF_DOUPCALL) { - PROC_SLOCK(p); - ku->ku_flags &= ~KUF_DOUPCALL; - PROC_SUNLOCK(p); - } - /* - * Set user context to the UTS - */ - if (!(ku->ku_mflags & KMF_NOUPCALL)) { - cpu_set_upcall_kse(td, ku->ku_func, ku->ku_mailbox, - &ku->ku_stack); - PROC_LOCK(p); - if (p->p_flag & P_TRACED) { - _PHOLD(p); - ptrace_clear_single_step(td); - _PRELE(p); - } - PROC_UNLOCK(p); - error = suword32(&ku->ku_mailbox->km_lwp, - td->td_tid); - if (error) - goto out; - error = suword(&ku->ku_mailbox->km_curthread, 0); - if (error) - goto out; - } - - /* - * Unhook the list of completed threads. - * anything that completes after this gets to - * come in next time. - * Put the list of completed thread mailboxes on - * this KSE's mailbox. - */ - if (!(ku->ku_mflags & KMF_NOCOMPLETED) && - (error = thread_link_mboxes(p, ku)) != 0) - goto out; - } - if (!uts_crit) { - nanotime(&ts); - error = copyout(&ts, &ku->ku_mailbox->km_timeofday, sizeof(ts)); - } - -out: - if (error) { - /* - * Things are going to be so screwed we should just kill - * the process. - * how do we do that? - */ - PROC_LOCK(p); - psignal(p, SIGSEGV); - PROC_UNLOCK(p); - } else { - /* - * Optimisation: - * Ensure that we have a spare thread available, - * for when we re-enter the kernel. - */ - if (td->td_standin == NULL) - thread_alloc_spare(td); /* XXX care of failure ? */ - } - - ku->ku_mflags = 0; - td->td_mailbox = NULL; - td->td_usticks = 0; - return (error); /* go sync */ -} - -/* - * called after ptrace resumed a process, force all - * virtual CPUs to schedule upcall for SA process, - * because debugger may have changed something in userland, - * we should notice UTS as soon as possible. - */ -void -thread_continued(struct proc *p) -{ - struct kse_upcall *ku; - struct thread *td; - - PROC_LOCK_ASSERT(p, MA_OWNED); - KASSERT(P_SHOULDSTOP(p), ("process not stopped")); - - if (!(p->p_flag & P_SA)) - return; - - if (p->p_flag & P_TRACED) { - td = TAILQ_FIRST(&p->p_threads); - if (td && (td->td_pflags & TDP_SA)) { - FOREACH_UPCALL_IN_PROC(p, ku) { - PROC_SLOCK(p); - ku->ku_flags |= KUF_DOUPCALL; - PROC_SUNLOCK(p); - wakeup(&p->p_completed); - } - } - } -} -#endif diff --git a/sys/kern/kern_proc.c b/sys/kern/kern_proc.c index c398a8d..5ca1e60 100644 --- a/sys/kern/kern_proc.c +++ b/sys/kern/kern_proc.c @@ -645,7 +645,7 @@ fill_kinfo_proc_only(struct proc *p, struct kinfo_proc *kp) kp->ki_structsize = sizeof(*kp); kp->ki_paddr = p; PROC_LOCK_ASSERT(p, MA_OWNED); - kp->ki_addr =/* p->p_addr; */0; /* XXXKSE */ + kp->ki_addr =/* p->p_addr; */0; /* XXX */ kp->ki_args = p->p_args; kp->ki_textvp = p->p_textvp; #ifdef KTRACE @@ -794,7 +794,7 @@ fill_kinfo_thread(struct thread *td, struct kinfo_proc *kp, int preferthread) bzero(kp->ki_lockname, sizeof(kp->ki_lockname)); } - if (p->p_state == PRS_NORMAL) { /* XXXKSE very approximate */ + if (p->p_state == PRS_NORMAL) { /* approximate. */ if (TD_ON_RUNQ(td) || TD_CAN_RUN(td) || TD_IS_RUNNING(td)) { diff --git a/sys/kern/kern_resource.c b/sys/kern/kern_resource.c index 5f8ea8f..b2b1daf 100644 --- a/sys/kern/kern_resource.c +++ b/sys/kern/kern_resource.c @@ -407,8 +407,6 @@ rtprio(td, uap) * or if one is, report the highest priority * in the process. There isn't much more you can do as * there is only room to return a single priority. - * XXXKSE: maybe need a new interface to report - * priorities of multiple system scope threads. * Note: specifying our own pid is not the same * as leaving it zero. */ diff --git a/sys/kern/kern_sig.c b/sys/kern/kern_sig.c index 5be17ea..0e1c493 100644 --- a/sys/kern/kern_sig.c +++ b/sys/kern/kern_sig.c @@ -49,7 +49,6 @@ __FBSDID("$FreeBSD$"); #include <sys/event.h> #include <sys/fcntl.h> #include <sys/kernel.h> -#include <sys/kse.h> #include <sys/ktr.h> #include <sys/ktrace.h> #include <sys/lock.h> @@ -94,9 +93,6 @@ static int filt_sigattach(struct knote *kn); static void filt_sigdetach(struct knote *kn); static int filt_signal(struct knote *kn, long hint); static struct thread *sigtd(struct proc *p, int sig, int prop); -#ifdef KSE -static int do_tdsignal(struct proc *, struct thread *, int, ksiginfo_t *); -#endif static void sigqueue_start(void); static uma_zone_t ksiginfo_zone = NULL; @@ -566,11 +562,7 @@ void signotify(struct thread *td) { struct proc *p; -#ifdef KSE - sigset_t set, saved; -#else sigset_t set; -#endif p = td->td_proc; @@ -581,10 +573,6 @@ signotify(struct thread *td) * previously masked by all threads to our sigqueue. */ set = p->p_sigqueue.sq_signals; -#ifdef KSE - if (p->p_flag & P_SA) - saved = p->p_sigqueue.sq_signals; -#endif SIGSETNAND(set, td->td_sigmask); if (! SIGISEMPTY(set)) sigqueue_move_set(&p->p_sigqueue, &td->td_sigqueue, &set); @@ -593,15 +581,6 @@ signotify(struct thread *td) td->td_flags |= TDF_NEEDSIGCHK | TDF_ASTPENDING; thread_unlock(td); } -#ifdef KSE - if ((p->p_flag & P_SA) && !(p->p_flag & P_SIGEVENT)) { - if (!SIGSETEQ(saved, p->p_sigqueue.sq_signals)) { - /* pending set changed */ - p->p_flag |= P_SIGEVENT; - wakeup(&p->p_siglist); - } - } -#endif } int @@ -754,13 +733,6 @@ kern_sigaction(td, sig, act, oact, flags) if (ps->ps_sigact[_SIG_IDX(sig)] == SIG_IGN || (sigprop(sig) & SA_IGNORE && ps->ps_sigact[_SIG_IDX(sig)] == SIG_DFL)) { -#ifdef KSE - if ((p->p_flag & P_SA) && - SIGISMEMBER(p->p_sigqueue.sq_signals, sig)) { - p->p_flag |= P_SIGEVENT; - wakeup(&p->p_siglist); - } -#endif /* never to be seen again */ PROC_SLOCK(p); sigqueue_delete_proc(p, sig); @@ -1200,12 +1172,6 @@ restart: continue; if (!SIGISMEMBER(td->td_sigqueue.sq_signals, i)) { if (SIGISMEMBER(p->p_sigqueue.sq_signals, i)) { -#ifdef KSE - if (p->p_flag & P_SA) { - p->p_flag |= P_SIGEVENT; - wakeup(&p->p_siglist); - } -#endif sigqueue_move(&p->p_sigqueue, &td->td_sigqueue, i); } else @@ -1842,9 +1808,6 @@ trapsignal(struct thread *td, ksiginfo_t *ksi) { struct sigacts *ps; struct proc *p; -#ifdef KSE - int error; -#endif int sig; int code; @@ -1853,27 +1816,7 @@ trapsignal(struct thread *td, ksiginfo_t *ksi) code = ksi->ksi_code; KASSERT(_SIG_VALID(sig), ("invalid signal")); -#ifdef KSE - if (td->td_pflags & TDP_SA) { - if (td->td_mailbox == NULL) - thread_user_enter(td); - PROC_LOCK(p); - SIGDELSET(td->td_sigmask, sig); - thread_lock(td); - /* - * Force scheduling an upcall, so UTS has chance to - * process the signal before thread runs again in - * userland. - */ - if (td->td_upcall) - td->td_upcall->ku_flags |= KUF_DOUPCALL; - thread_unlock(td); - } else { - PROC_LOCK(p); - } -#else PROC_LOCK(p); -#endif ps = p->p_sigacts; mtx_lock(&ps->ps_mtx); if ((p->p_flag & P_TRACED) == 0 && SIGISMEMBER(ps->ps_sigcatch, sig) && @@ -1884,34 +1827,8 @@ trapsignal(struct thread *td, ksiginfo_t *ksi) ktrpsig(sig, ps->ps_sigact[_SIG_IDX(sig)], &td->td_sigmask, code); #endif -#ifdef KSE - if (!(td->td_pflags & TDP_SA)) - (*p->p_sysent->sv_sendsig)(ps->ps_sigact[_SIG_IDX(sig)], - ksi, &td->td_sigmask); -#else (*p->p_sysent->sv_sendsig)(ps->ps_sigact[_SIG_IDX(sig)], ksi, &td->td_sigmask); -#endif -#ifdef KSE - else if (td->td_mailbox == NULL) { - mtx_unlock(&ps->ps_mtx); - /* UTS caused a sync signal */ - p->p_code = code; /* XXX for core dump/debugger */ - p->p_sig = sig; /* XXX to verify code */ - sigexit(td, sig); - } else { - mtx_unlock(&ps->ps_mtx); - SIGADDSET(td->td_sigmask, sig); - PROC_UNLOCK(p); - error = copyout(&ksi->ksi_info, &td->td_mailbox->tm_syncsig, - sizeof(siginfo_t)); - PROC_LOCK(p); - /* UTS memory corrupted */ - if (error) - sigexit(td, SIGSEGV); - mtx_lock(&ps->ps_mtx); - } -#endif SIGSETOR(td->td_sigmask, ps->ps_catchmask[_SIG_IDX(sig)]); if (!SIGISMEMBER(ps->ps_signodefer, sig)) SIGADDSET(td->td_sigmask, sig); @@ -2024,27 +1941,6 @@ psignal_event(struct proc *p, struct sigevent *sigev, ksiginfo_t *ksi) int tdsignal(struct proc *p, struct thread *td, int sig, ksiginfo_t *ksi) { -#ifdef KSE - sigset_t saved; - int ret; - - if (p->p_flag & P_SA) - saved = p->p_sigqueue.sq_signals; - ret = do_tdsignal(p, td, sig, ksi); - if ((p->p_flag & P_SA) && !(p->p_flag & P_SIGEVENT)) { - if (!SIGSETEQ(saved, p->p_sigqueue.sq_signals)) { - /* pending set changed */ - p->p_flag |= P_SIGEVENT; - wakeup(&p->p_siglist); - } - } - return (ret); -} - -static int -do_tdsignal(struct proc *p, struct thread *td, int sig, ksiginfo_t *ksi) -{ -#endif sig_t action; sigqueue_t *sigqueue; int prop; @@ -2055,17 +1951,9 @@ do_tdsignal(struct proc *p, struct thread *td, int sig, ksiginfo_t *ksi) PROC_LOCK_ASSERT(p, MA_OWNED); if (!_SIG_VALID(sig)) -#ifdef KSE - panic("do_tdsignal(): invalid signal %d", sig); -#else panic("tdsignal(): invalid signal %d", sig); -#endif -#ifdef KSE - KASSERT(ksi == NULL || !KSI_ONQ(ksi), ("do_tdsignal: ksi on queue")); -#else KASSERT(ksi == NULL || !KSI_ONQ(ksi), ("tdsignal: ksi on queue")); -#endif /* * IEEE Std 1003.1-2001: return success when killing a zombie. @@ -2232,18 +2120,6 @@ do_tdsignal(struct proc *p, struct thread *td, int sig, ksiginfo_t *ksi) goto out; } if (action == SIG_CATCH) { -#ifdef KSE - /* - * The process wants to catch it so it needs - * to run at least one thread, but which one? - * It would seem that the answer would be to - * run an upcall in the next KSE to run, and - * deliver the signal that way. In a NON KSE - * process, we need to make sure that the - * single thread is runnable asap. - * XXXKSE for now however, make them all run. - */ -#endif /* * The process wants to catch it so it needs * to run at least one thread, but which one? @@ -2540,10 +2416,6 @@ issignal(td) */ if (SIGISMEMBER(ps->ps_sigignore, sig) && (traced == 0)) { sigqueue_delete(&td->td_sigqueue, sig); -#ifdef KSE - if (td->td_pflags & TDP_SA) - SIGADDSET(td->td_sigmask, sig); -#endif continue; } if (p->p_flag & P_TRACED && (p->p_flag & P_PPWAIT) == 0) { @@ -2554,11 +2426,6 @@ issignal(td) newsig = ptracestop(td, sig); mtx_lock(&ps->ps_mtx); -#ifdef KSE - if (td->td_pflags & TDP_SA) - SIGADDSET(td->td_sigmask, sig); - -#endif if (sig != newsig) { ksiginfo_t ksi; /* @@ -2582,10 +2449,6 @@ issignal(td) * signal is being masked, look for other signals. */ SIGADDSET(td->td_sigqueue.sq_signals, sig); -#ifdef KSE - if (td->td_pflags & TDP_SA) - SIGDELSET(td->td_sigmask, sig); -#endif if (SIGISMEMBER(td->td_sigmask, sig)) continue; signotify(td); @@ -2739,11 +2602,7 @@ postsig(sig) mtx_lock(&ps->ps_mtx); } -#ifdef KSE - if (!(td->td_pflags & TDP_SA) && action == SIG_DFL) { -#else if (action == SIG_DFL) { -#endif /* * Default action, where the default is to kill * the process. (Other cases were ignored above.) @@ -2752,15 +2611,6 @@ postsig(sig) sigexit(td, sig); /* NOTREACHED */ } else { -#ifdef KSE - if (td->td_pflags & TDP_SA) { - if (sig == SIGKILL) { - mtx_unlock(&ps->ps_mtx); - sigexit(td, sig); - } - } - -#endif /* * If we get here, the signal must be caught. */ @@ -2803,14 +2653,7 @@ postsig(sig) p->p_code = 0; p->p_sig = 0; } -#ifdef KSE - if (td->td_pflags & TDP_SA) - thread_signal_add(curthread, &ksi); - else - (*p->p_sysent->sv_sendsig)(action, &ksi, &returnmask); -#else (*p->p_sysent->sv_sendsig)(action, &ksi, &returnmask); -#endif } } diff --git a/sys/kern/kern_switch.c b/sys/kern/kern_switch.c index cdc5b8a..360a993 100644 --- a/sys/kern/kern_switch.c +++ b/sys/kern/kern_switch.c @@ -521,7 +521,7 @@ runq_choose_from(struct runq *rq, u_char idx) ts = TAILQ_FIRST(rqh); KASSERT(ts != NULL, ("runq_choose: no proc on busy queue")); CTR4(KTR_RUNQ, - "runq_choose_from: pri=%d kse=%p idx=%d rqh=%p", + "runq_choose_from: pri=%d td_sched=%p idx=%d rqh=%p", pri, ts, ts->ts_rqindex, rqh); return (ts); } diff --git a/sys/kern/kern_synch.c b/sys/kern/kern_synch.c index f876147..71764e5 100644 --- a/sys/kern/kern_synch.c +++ b/sys/kern/kern_synch.c @@ -412,7 +412,7 @@ mi_switch(int flags, struct thread *newtd) td->td_generation++; /* bump preempt-detect counter */ PCPU_INC(cnt.v_swtch); PCPU_SET(switchticks, ticks); - CTR4(KTR_PROC, "mi_switch: old thread %ld (kse %p, pid %ld, %s)", + CTR4(KTR_PROC, "mi_switch: old thread %ld (td_sched %p, pid %ld, %s)", td->td_tid, td->td_sched, p->p_pid, td->td_name); #if (KTR_COMPILE & KTR_SCHED) != 0 if (TD_IS_IDLETHREAD(td)) @@ -429,19 +429,11 @@ mi_switch(int flags, struct thread *newtd) td, td->td_name, td->td_priority, td->td_inhibitors, td->td_wmesg, td->td_lockname); #endif - /* - * We call thread_switchout after the KTR_SCHED prints above so kse - * selecting a new thread to run does not show up as a preemption. - */ -#ifdef KSE - if ((flags & SW_VOL) && (td->td_proc->p_flag & P_SA)) - newtd = thread_switchout(td, flags, newtd); -#endif sched_switch(td, newtd, flags); CTR3(KTR_SCHED, "mi_switch: running %p(%s) prio %d", td, td->td_name, td->td_priority); - CTR4(KTR_PROC, "mi_switch: new thread %ld (kse %p, pid %ld, %s)", + CTR4(KTR_PROC, "mi_switch: new thread %ld (td_sched %p, pid %ld, %s)", td->td_tid, td->td_sched, p->p_pid, td->td_name); /* @@ -500,8 +492,6 @@ setrunnable(struct thread *td) /* * Compute a tenex style load average of a quantity on * 1, 5 and 15 minute intervals. - * XXXKSE Needs complete rewrite when correct info is available. - * Completely Bogus.. only works with 1:1 (but compiles ok now :-) */ static void loadav(void *arg) diff --git a/sys/kern/kern_thread.c b/sys/kern/kern_thread.c index db6d71a..ec63f89 100644 --- a/sys/kern/kern_thread.c +++ b/sys/kern/kern_thread.c @@ -68,43 +68,12 @@ int max_threads_hits; SYSCTL_INT(_kern_threads, OID_AUTO, max_threads_hits, CTLFLAG_RD, &max_threads_hits, 0, ""); -#ifdef KSE -int virtual_cpu; - -#endif TAILQ_HEAD(, thread) zombie_threads = TAILQ_HEAD_INITIALIZER(zombie_threads); static struct mtx zombie_lock; MTX_SYSINIT(zombie_lock, &zombie_lock, "zombie lock", MTX_SPIN); static void thread_zombie(struct thread *); -#ifdef KSE -static int -sysctl_kse_virtual_cpu(SYSCTL_HANDLER_ARGS) -{ - int error, new_val; - int def_val; - - def_val = mp_ncpus; - if (virtual_cpu == 0) - new_val = def_val; - else - new_val = virtual_cpu; - error = sysctl_handle_int(oidp, &new_val, 0, req); - if (error != 0 || req->newptr == NULL) - return (error); - if (new_val < 0) - return (EINVAL); - virtual_cpu = new_val; - return (0); -} - -/* DEBUG ONLY */ -SYSCTL_PROC(_kern_threads, OID_AUTO, virtual_cpu, CTLTYPE_INT|CTLFLAG_RW, - 0, sizeof(virtual_cpu), sysctl_kse_virtual_cpu, "I", - "debug virtual cpus"); -#endif - struct mtx tid_lock; static struct unrhdr *tid_unrhdr; @@ -230,9 +199,6 @@ void proc_linkup(struct proc *p, struct thread *td) { -#ifdef KSE - TAILQ_INIT(&p->p_upcalls); /* upcall list */ -#endif sigqueue_init(&p->p_sigqueue, p); p->p_ksi = ksiginfo_alloc(1); if (p->p_ksi != NULL) { @@ -258,9 +224,6 @@ threadinit(void) thread_zone = uma_zcreate("THREAD", sched_sizeof_thread(), thread_ctor, thread_dtor, thread_init, thread_fini, 16 - 1, 0); -#ifdef KSE - kseinit(); /* set up kse specific stuff e.g. upcall zone*/ -#endif } /* @@ -286,7 +249,7 @@ thread_stash(struct thread *td) } /* - * Reap zombie kse resource. + * Reap zombie resources. */ void thread_reap(void) @@ -311,9 +274,6 @@ thread_reap(void) td_first = td_next; } } -#ifdef KSE - upcall_reap(); -#endif } /* @@ -343,12 +303,7 @@ thread_alloc(void) void thread_free(struct thread *td) { -#ifdef KSE - if (td->td_cpuset != NULL) - cpuset_rel(td->td_cpuset); -#else cpuset_rel(td->td_cpuset); -#endif td->td_cpuset = NULL; cpu_thread_free(td); if (td->td_altkstack != 0) @@ -365,29 +320,7 @@ thread_free(struct thread *td) * Because we can't free a thread while we're operating under its context, * push the current thread into our CPU's deadthread holder. This means * we needn't worry about someone else grabbing our context before we - * do a cpu_throw(). This may not be needed now as we are under schedlock. - * Maybe we can just do a thread_stash() as thr_exit1 does. - */ -/* XXX - * libthr expects its thread exit to return for the last - * thread, meaning that the program is back to non-threaded - * mode I guess. Because we do this (cpu_throw) unconditionally - * here, they have their own version of it. (thr_exit1()) - * that doesn't do it all if this was the last thread. - * It is also called from thread_suspend_check(). - * Of course in the end, they end up coming here through exit1 - * anyhow.. After fixing 'thr' to play by the rules we should be able - * to merge these two functions together. - * - * called from: - * exit1() - * kse_exit() - * thr_exit() - * ifdef KSE - * thread_user_enter() - * thread_userret() - * endif - * thread_suspend_check() + * do a cpu_throw(). */ void thread_exit(void) @@ -413,17 +346,6 @@ thread_exit(void) AUDIT_SYSCALL_EXIT(0, td); #endif -#ifdef KSE - if (td->td_standin != NULL) { - /* - * Note that we don't need to free the cred here as it - * is done in thread_reap(). - */ - thread_zombie(td->td_standin); - td->td_standin = NULL; - } -#endif - umtx_thread_exit(td); /* @@ -453,11 +375,7 @@ thread_exit(void) if (p->p_flag & P_HADTHREADS) { if (p->p_numthreads > 1) { thread_lock(td); -#ifdef KSE - kse_unlink(td); -#else thread_unlink(td); -#endif thread_unlock(td); td2 = FIRST_THREAD_IN_PROC(p); sched_exit_thread(td2, td); @@ -480,16 +398,6 @@ thread_exit(void) } else { /* * The last thread is exiting.. but not through exit() - * what should we do? - * Theoretically this can't happen - * exit1() - clears threading flags before coming here - * kse_exit() - treats last thread specially - * thr_exit() - treats last thread specially - * ifdef KSE - * thread_user_enter() - only if more exist - * thread_userret() - only if more exist - * endif - * thread_suspend_check() - only if more exist */ panic ("thread_exit: Last thread exiting on its own"); } @@ -518,16 +426,6 @@ thread_wait(struct proc *p) mtx_assert(&Giant, MA_NOTOWNED); KASSERT((p->p_numthreads == 1), ("Multiple threads in wait1()")); td = FIRST_THREAD_IN_PROC(p); -#ifdef KSE - if (td->td_standin != NULL) { - if (td->td_standin->td_ucred != NULL) { - crfree(td->td_standin->td_ucred); - td->td_standin->td_ucred = NULL; - } - thread_free(td->td_standin); - td->td_standin = NULL; - } -#endif /* Lock the last thread so we spin until it exits cpu_throw(). */ thread_lock(td); thread_unlock(td); @@ -545,13 +443,6 @@ thread_wait(struct proc *p) * Link a thread to a process. * set up anything that needs to be initialized for it to * be used by the process. - * - * Note that we do not link to the proc's ucred here. - * The thread is linked as if running but no KSE assigned. - * Called from: - * proc_linkup() - * thread_schedule_upcall() - * thr_create() */ void thread_link(struct thread *td, struct proc *p) @@ -577,9 +468,6 @@ thread_link(struct thread *td, struct proc *p) /* * Convert a process with one thread to an unthreaded process. - * Called from: - * thread_single(exit) (called from execve and exit) - * kse_exit() XXX may need cleaning up wrt KSE stuff */ void thread_unthread(struct thread *td) @@ -587,20 +475,7 @@ thread_unthread(struct thread *td) struct proc *p = td->td_proc; KASSERT((p->p_numthreads == 1), ("Unthreading with >1 threads")); -#ifdef KSE - thread_lock(td); - upcall_remove(td); - thread_unlock(td); - p->p_flag &= ~(P_SA|P_HADTHREADS); - td->td_mailbox = NULL; - td->td_pflags &= ~(TDP_SA | TDP_CAN_UNBIND); - if (td->td_standin != NULL) { - thread_zombie(td->td_standin); - td->td_standin = NULL; - } -#else p->p_flag &= ~P_HADTHREADS; -#endif } /* diff --git a/sys/kern/p1003_1b.c b/sys/kern/p1003_1b.c index 5fae20d..6d05972 100644 --- a/sys/kern/p1003_1b.c +++ b/sys/kern/p1003_1b.c @@ -156,7 +156,7 @@ sched_getparam(struct thread *td, struct sched_getparam_args *uap) if (targetp == NULL) { return (ESRCH); } - targettd = FIRST_THREAD_IN_PROC(targetp); /* XXXKSE */ + targettd = FIRST_THREAD_IN_PROC(targetp); } e = p_cansee(td, targetp); @@ -223,7 +223,7 @@ sched_getscheduler(struct thread *td, struct sched_getscheduler_args *uap) e = ESRCH; goto done2; } - targettd = FIRST_THREAD_IN_PROC(targetp); /* XXXKSE */ + targettd = FIRST_THREAD_IN_PROC(targetp); } e = p_cansee(td, targetp); diff --git a/sys/kern/sched_4bsd.c b/sys/kern/sched_4bsd.c index 0232e09..17ae0be 100644 --- a/sys/kern/sched_4bsd.c +++ b/sys/kern/sched_4bsd.c @@ -383,8 +383,6 @@ schedcpu(void) /* * ts_pctcpu is only for ps and ttyinfo(). - * Do it per td_sched, and add them up at the end? - * XXXKSE */ ts->ts_pctcpu = (ts->ts_pctcpu * ccpu) >> FSHIFT; /* diff --git a/sys/kern/sched_ule.c b/sys/kern/sched_ule.c index ebdc5e0..563d0aa 100644 --- a/sys/kern/sched_ule.c +++ b/sys/kern/sched_ule.c @@ -2013,15 +2013,6 @@ sched_exit_thread(struct thread *td, struct thread *child) CTR3(KTR_SCHED, "sched_exit_thread: %p(%s) prio %d", child, child->td_name, child->td_priority); -#ifdef KSE - /* - * KSE forks and exits so often that this penalty causes short-lived - * threads to always be non-interactive. This causes mozilla to - * crawl under load. - */ - if ((td->td_pflags & TDP_SA) && td->td_proc == child->td_proc) - return; -#endif /* * Give the child's runtime to the parent without returning the * sleep time as a penalty to the parent. This causes shells that diff --git a/sys/kern/subr_sleepqueue.c b/sys/kern/subr_sleepqueue.c index dca91ff..175cc60 100644 --- a/sys/kern/subr_sleepqueue.c +++ b/sys/kern/subr_sleepqueue.c @@ -410,13 +410,8 @@ sleepq_catch_signals(void *wchan, int pri) PROC_UNLOCK(p); thread_lock(td); if (ret == 0) { - if (!(td->td_flags & TDF_INTERRUPT)) { - sleepq_switch(wchan, pri); - return (0); - } - /* KSE threads tried unblocking us. */ - ret = td->td_intrval; - MPASS(ret == EINTR || ret == ERESTART || ret == EWOULDBLOCK); + sleepq_switch(wchan, pri); + return (0); } /* * There were pending signals and this thread is still @@ -540,9 +535,6 @@ sleepq_check_signals(void) return (td->td_intrval); } - if (td->td_flags & TDF_INTERRUPT) - return (td->td_intrval); - return (0); } diff --git a/sys/kern/subr_trap.c b/sys/kern/subr_trap.c index d8168af..1701fba 100644 --- a/sys/kern/subr_trap.c +++ b/sys/kern/subr_trap.c @@ -119,15 +119,6 @@ userret(struct thread *td, struct trapframe *frame) thread_suspend_check(0); /* Can suspend or kill */ PROC_UNLOCK(p); } - -#ifdef KSE - /* - * Do special thread processing, e.g. upcall tweaking and such. - */ - if (p->p_flag & P_SA) - thread_userret(td, frame); -#endif - /* * Charge system time if profiling. */ @@ -135,7 +126,6 @@ userret(struct thread *td, struct trapframe *frame) addupc_task(td, TRAPF_PC(frame), td->td_pticks * psratio); } - /* * Let the scheduler adjust our priority etc. */ @@ -173,11 +163,6 @@ ast(struct trapframe *framep) td->td_frame = framep; td->td_pticks = 0; -#ifdef KSE - if ((p->p_flag & P_SA) && (td->td_mailbox == NULL)) - thread_user_enter(td); -#endif - /* * This updates the td_flag's for the checks below in one * "atomic" operation with turning off the astpending flag. @@ -188,18 +173,11 @@ ast(struct trapframe *framep) thread_lock(td); flags = td->td_flags; td->td_flags &= ~(TDF_ASTPENDING | TDF_NEEDSIGCHK | - TDF_NEEDRESCHED | TDF_INTERRUPT | TDF_ALRMPEND | TDF_PROFPEND | + TDF_NEEDRESCHED | TDF_ALRMPEND | TDF_PROFPEND | TDF_MACPEND); thread_unlock(td); PCPU_INC(cnt.v_trap); - /* - * XXXKSE While the fact that we owe a user profiling - * tick is stored per thread in this code, the statistics - * themselves are still stored per process. - * This should probably change, by which I mean that - * possibly the location of both might change. - */ if (td->td_ucred != p->p_ucred) cred_update_thread(td); if (td->td_pflags & TDP_OWEUPC && p->p_flag & P_PROFIL) { diff --git a/sys/kern/subr_witness.c b/sys/kern/subr_witness.c index 9e2ac7d..b213766 100644 --- a/sys/kern/subr_witness.c +++ b/sys/kern/subr_witness.c @@ -450,7 +450,6 @@ static struct witness_order_list_entry order_lists[] = { #endif { "clk", &lock_class_mtx_spin }, { "mprof lock", &lock_class_mtx_spin }, - { "kse lock", &lock_class_mtx_spin }, { "zombie lock", &lock_class_mtx_spin }, { "ALD Queue", &lock_class_mtx_spin }, #ifdef __ia64__ diff --git a/sys/kern/sys_process.c b/sys/kern/sys_process.c index 432138c..77ddee5 100644 --- a/sys/kern/sys_process.c +++ b/sys/kern/sys_process.c @@ -803,11 +803,6 @@ kern_ptrace(struct thread *td, int req, pid_t pid, void *addr, int data) * you should use PT_SUSPEND to suspend it before * continuing process. */ -#ifdef KSE - PROC_SUNLOCK(p); - thread_continued(p); - PROC_SLOCK(p); -#endif p->p_flag &= ~(P_STOPPED_TRACE|P_STOPPED_SIG|P_WAITED); thread_unsuspend(p); PROC_SUNLOCK(p); @@ -943,17 +938,7 @@ kern_ptrace(struct thread *td, int req, pid_t pid, void *addr, int data) pl->pl_event = PL_EVENT_SIGNAL; else pl->pl_event = 0; -#ifdef KSE - if (td2->td_pflags & TDP_SA) { - pl->pl_flags = PL_FLAG_SA; - if (td2->td_upcall && !TD_CAN_UNBIND(td2)) - pl->pl_flags |= PL_FLAG_BOUND; - } else { - pl->pl_flags = 0; - } -#else pl->pl_flags = 0; -#endif pl->pl_sigmask = td2->td_sigmask; pl->pl_siglist = td2->td_siglist; break; diff --git a/sys/kern/syscalls.c b/sys/kern/syscalls.c index ac584a3..4503be4 100644 --- a/sys/kern/syscalls.c +++ b/sys/kern/syscalls.c @@ -386,11 +386,11 @@ const char *syscallnames[] = { "eaccess", /* 376 = eaccess */ "#377", /* 377 = afs_syscall */ "nmount", /* 378 = nmount */ - "kse_exit", /* 379 = kse_exit */ - "kse_wakeup", /* 380 = kse_wakeup */ - "kse_create", /* 381 = kse_create */ - "kse_thr_interrupt", /* 382 = kse_thr_interrupt */ - "kse_release", /* 383 = kse_release */ + "#379", /* 379 = kse_exit */ + "#380", /* 380 = kse_wakeup */ + "#381", /* 381 = kse_create */ + "#382", /* 382 = kse_thr_interrupt */ + "#383", /* 383 = kse_release */ "__mac_get_proc", /* 384 = __mac_get_proc */ "__mac_set_proc", /* 385 = __mac_set_proc */ "__mac_get_fd", /* 386 = __mac_get_fd */ @@ -447,7 +447,7 @@ const char *syscallnames[] = { "extattr_list_fd", /* 437 = extattr_list_fd */ "extattr_list_file", /* 438 = extattr_list_file */ "extattr_list_link", /* 439 = extattr_list_link */ - "kse_switchin", /* 440 = kse_switchin */ + "#440", /* 440 = kse_switchin */ "ksem_timedwait", /* 441 = ksem_timedwait */ "thr_suspend", /* 442 = thr_suspend */ "thr_wake", /* 443 = thr_wake */ diff --git a/sys/kern/syscalls.master b/sys/kern/syscalls.master index c31df8d..59ef46e 100644 --- a/sys/kern/syscalls.master +++ b/sys/kern/syscalls.master @@ -664,14 +664,11 @@ 377 AUE_NULL UNIMPL afs_syscall 378 AUE_NMOUNT STD { int nmount(struct iovec *iovp, \ unsigned int iovcnt, int flags); } -379 AUE_NULL STD { int kse_exit(void); } -380 AUE_NULL STD { int kse_wakeup(struct kse_mailbox *mbx); } -381 AUE_NULL STD { int kse_create(struct kse_mailbox *mbx, \ - int newgroup); } -382 AUE_NULL STD { int kse_thr_interrupt( \ - struct kse_thr_mailbox *tmbx, int cmd, \ - long data); } -383 AUE_NULL STD { int kse_release(struct timespec *timeout); } +379 AUE_NULL UNIMPL kse_exit +380 AUE_NULL UNIMPL kse_wakeup +381 AUE_NULL UNIMPL kse_create +382 AUE_NULL UNIMPL kse_thr_interrupt +383 AUE_NULL UNIMPL kse_release 384 AUE_NULL STD { int __mac_get_proc(struct mac *mac_p); } 385 AUE_NULL STD { int __mac_set_proc(struct mac *mac_p); } 386 AUE_NULL STD { int __mac_get_fd(int fd, \ @@ -772,9 +769,7 @@ 439 AUE_EXTATTR_LIST_LINK STD { ssize_t extattr_list_link( \ const char *path, int attrnamespace, \ void *data, size_t nbytes); } -440 AUE_NULL STD { int kse_switchin( \ - struct kse_thr_mailbox *tmbx, \ - int flags); } +440 AUE_NULL UNIMPL kse_switchin 441 AUE_NULL NOSTD { int ksem_timedwait(semid_t id, \ const struct timespec *abstime); } 442 AUE_NULL STD { int thr_suspend( \ diff --git a/sys/kern/systrace_args.c b/sys/kern/systrace_args.c index 9b5b706..8ae6875 100644 --- a/sys/kern/systrace_args.c +++ b/sys/kern/systrace_args.c @@ -2067,42 +2067,6 @@ systrace_args(int sysnum, void *params, u_int64_t *uarg, int *n_args) *n_args = 3; break; } - /* kse_exit */ - case 379: { - *n_args = 0; - break; - } - /* kse_wakeup */ - case 380: { - struct kse_wakeup_args *p = params; - uarg[0] = (intptr_t) p->mbx; /* struct kse_mailbox * */ - *n_args = 1; - break; - } - /* kse_create */ - case 381: { - struct kse_create_args *p = params; - uarg[0] = (intptr_t) p->mbx; /* struct kse_mailbox * */ - iarg[1] = p->newgroup; /* int */ - *n_args = 2; - break; - } - /* kse_thr_interrupt */ - case 382: { - struct kse_thr_interrupt_args *p = params; - uarg[0] = (intptr_t) p->tmbx; /* struct kse_thr_mailbox * */ - iarg[1] = p->cmd; /* int */ - iarg[2] = p->data; /* long */ - *n_args = 3; - break; - } - /* kse_release */ - case 383: { - struct kse_release_args *p = params; - uarg[0] = (intptr_t) p->timeout; /* struct timespec * */ - *n_args = 1; - break; - } /* __mac_get_proc */ case 384: { struct __mac_get_proc_args *p = params; @@ -2534,14 +2498,6 @@ systrace_args(int sysnum, void *params, u_int64_t *uarg, int *n_args) *n_args = 4; break; } - /* kse_switchin */ - case 440: { - struct kse_switchin_args *p = params; - uarg[0] = (intptr_t) p->tmbx; /* struct kse_thr_mailbox * */ - iarg[1] = p->flags; /* int */ - *n_args = 2; - break; - } /* ksem_timedwait */ case 441: { struct ksem_timedwait_args *p = params; diff --git a/sys/pc98/conf/DEFAULTS b/sys/pc98/conf/DEFAULTS index d42d4d3..962c099 100644 --- a/sys/pc98/conf/DEFAULTS +++ b/sys/pc98/conf/DEFAULTS @@ -24,6 +24,3 @@ device uart_ns8250 # Default partitioning schemes options GEOM_BSD options GEOM_PC98 - -# KSE support went from being default to a kernel option -options KSE diff --git a/sys/pc98/pc98/machdep.c b/sys/pc98/pc98/machdep.c index 81f77fd..c158e4f 100644 --- a/sys/pc98/pc98/machdep.c +++ b/sys/pc98/pc98/machdep.c @@ -2148,7 +2148,7 @@ init386(first) _udatasel = GSEL(GUDATA_SEL, SEL_UPL); /* setup proc 0's pcb */ - thread0.td_pcb->pcb_flags = 0; /* XXXKSE */ + thread0.td_pcb->pcb_flags = 0; thread0.td_pcb->pcb_cr3 = (int)IdlePTD; thread0.td_pcb->pcb_ext = 0; thread0.td_frame = &proc0_tf; diff --git a/sys/powerpc/aim/trap.c b/sys/powerpc/aim/trap.c index a5f91fd..9df017d 100644 --- a/sys/powerpc/aim/trap.c +++ b/sys/powerpc/aim/trap.c @@ -349,11 +349,6 @@ syscall(struct trapframe *frame) PCPU_INC(cnt.v_syscall); -#ifdef KSE - if (p->p_flag & P_SA) - thread_user_enter(td); -#endif - code = frame->fixreg[0]; params = (caddr_t)(frame->fixreg + FIRSTARG); n = NARGREG; diff --git a/sys/powerpc/aim/vm_machdep.c b/sys/powerpc/aim/vm_machdep.c index 282e2e6..5bd1e2b 100644 --- a/sys/powerpc/aim/vm_machdep.c +++ b/sys/powerpc/aim/vm_machdep.c @@ -264,7 +264,7 @@ is_physical_memory(addr) } /* - * KSE functions + * Threading functions */ void cpu_thread_exit(struct thread *td) diff --git a/sys/powerpc/booke/trap.c b/sys/powerpc/booke/trap.c index edd49f5..d50b754 100644 --- a/sys/powerpc/booke/trap.c +++ b/sys/powerpc/booke/trap.c @@ -343,11 +343,6 @@ syscall(struct trapframe *frame) PCPU_INC(cnt.v_syscall); -#if KSE - if (p->p_flag & P_SA) - thread_user_enter(td); -#endif - code = frame->fixreg[0]; params = (caddr_t)(frame->fixreg + FIRSTARG); n = NARGREG; diff --git a/sys/powerpc/booke/vm_machdep.c b/sys/powerpc/booke/vm_machdep.c index fb7f2db..eb85a6e 100644 --- a/sys/powerpc/booke/vm_machdep.c +++ b/sys/powerpc/booke/vm_machdep.c @@ -408,7 +408,7 @@ is_physical_memory(vm_offset_t addr) } /* - * KSE functions + * Thread functions */ void cpu_thread_exit(struct thread *td) diff --git a/sys/powerpc/conf/DEFAULTS b/sys/powerpc/conf/DEFAULTS index 7204e8b..7c981d1 100644 --- a/sys/powerpc/conf/DEFAULTS +++ b/sys/powerpc/conf/DEFAULTS @@ -14,6 +14,3 @@ device uart_z8530 options GEOM_PART_APM options GEOM_PART_MBR - -# KSE support went from being default to a kernel option -options KSE diff --git a/sys/sparc64/conf/DEFAULTS b/sys/sparc64/conf/DEFAULTS index 0bcec69..910e61e 100644 --- a/sys/sparc64/conf/DEFAULTS +++ b/sys/sparc64/conf/DEFAULTS @@ -13,9 +13,6 @@ device uart_ns8250 device uart_sab82532 device uart_z8530 -# KSE support went from being default to a kernel option -options KSE - # Default partitioning schemes options GEOM_BSD options GEOM_SUNLABEL diff --git a/sys/sparc64/sparc64/trap.c b/sys/sparc64/sparc64/trap.c index e9e3c40..53fce76 100644 --- a/sys/sparc64/sparc64/trap.c +++ b/sys/sparc64/sparc64/trap.c @@ -529,10 +529,6 @@ syscall(struct trapframe *tf) td->td_frame = tf; if (td->td_ucred != p->p_ucred) cred_update_thread(td); -#ifdef KSE - if (p->p_flag & P_SA) - thread_user_enter(td); -#endif code = tf->tf_global[1]; /* diff --git a/sys/sys/kse.h b/sys/sys/kse.h deleted file mode 100644 index 9eb5449..0000000 --- a/sys/sys/kse.h +++ /dev/null @@ -1,135 +0,0 @@ -/*- - * Copyright (C) 2001 Julian Elischer <julian@freebsd.org> - * for the FreeBSD Foundation. - * - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * 1. Redistributions of source code must retain the above copyright - * notice(s), this list of conditions and the following disclaimer as - * the first lines of this file unmodified other than the possible - * addition of one or more copyright notices. - * 2. Redistributions in binary form must reproduce the above copyright - * notice(s), this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) ``AS IS'' AND ANY - * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED - * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) BE LIABLE FOR ANY - * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES - * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR - * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER - * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT - * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY - * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH - * DAMAGE. - * - * $FreeBSD$ - */ - -#ifndef _SYS_KSE_H_ -#define _SYS_KSE_H_ - -#include <sys/ucontext.h> -#include <sys/time.h> -#include <sys/signal.h> - -/* - * This file defines the structures needed for communication between - * the userland and the kernel when running a KSE-based threading system. - * The only programs that should see this file are the user thread - * scheduler (UTS) and the kernel. - */ -struct kse_mailbox; - -typedef void kse_func_t(struct kse_mailbox *); - -/* - * Thread mailbox. - * - * This describes a user thread to the kernel scheduler. - */ -struct kse_thr_mailbox { - ucontext_t tm_context; /* User and machine context */ - uint32_t tm_flags; /* Thread flags */ - struct kse_thr_mailbox *tm_next; /* Next thread in list */ - void *tm_udata; /* For use by the UTS */ - uint32_t tm_uticks; /* Time in userland */ - uint32_t tm_sticks; /* Time in kernel */ - siginfo_t tm_syncsig; - uint32_t tm_dflags; /* Debug flags */ - lwpid_t tm_lwp; /* kernel thread UTS runs on */ - uint32_t __spare__[6]; -}; - -/* - * KSE mailbox. - * - * Communication path between the UTS and the kernel scheduler specific to - * a single KSE. - */ -struct kse_mailbox { - uint32_t km_version; /* Mailbox version */ - struct kse_thr_mailbox *km_curthread; /* Currently running thread */ - struct kse_thr_mailbox *km_completed; /* Threads back from kernel */ - sigset_t km_sigscaught; /* Caught signals */ - uint32_t km_flags; /* Mailbox flags */ - kse_func_t *km_func; /* UTS function */ - stack_t km_stack; /* UTS stack */ - void *km_udata; /* For use by the UTS */ - struct timespec km_timeofday; /* Time of day */ - uint32_t km_quantum; /* Upcall quantum in msecs */ - lwpid_t km_lwp; /* kernel thread UTS runs on */ - uint32_t __spare2__[7]; -}; - -#define KSE_VER_0 0 -#define KSE_VERSION KSE_VER_0 - -/* These flags are kept in km_flags */ -#define KMF_NOUPCALL 0x01 -#define KMF_NOCOMPLETED 0x02 -#define KMF_DONE 0x04 -#define KMF_BOUND 0x08 -#define KMF_WAITSIGEVENT 0x10 - -/* These flags are kept in tm_flags */ -#define TMF_NOUPCALL 0x01 - -/* These flags are kept in tm_dlfags */ -#define TMDF_SSTEP 0x01 -#define TMDF_SUSPEND 0x02 - -/* Flags for kse_switchin */ -#define KSE_SWITCHIN_SETTMBX 0x01 - -/* Commands for kse_thr_interrupt */ -#define KSE_INTR_INTERRUPT 1 -#define KSE_INTR_RESTART 2 -#define KSE_INTR_SENDSIG 3 -#define KSE_INTR_SIGEXIT 4 -#define KSE_INTR_DBSUSPEND 5 -#define KSE_INTR_EXECVE 6 - -struct kse_execve_args { - sigset_t sigmask; - sigset_t sigpend; - char *path; - char **argv; - char **envp; - void *reserved; -}; - -#ifndef _KERNEL -int kse_create(struct kse_mailbox *, int); -int kse_exit(void); -int kse_release(struct timespec *); -int kse_thr_interrupt(struct kse_thr_mailbox *, int, long); -int kse_wakeup(struct kse_mailbox *); -int kse_switchin(struct kse_thr_mailbox *, int flags); -#endif /* !_KERNEL */ - -#endif /* !_SYS_KSE_H_ */ diff --git a/sys/sys/proc.h b/sys/sys/proc.h index 76d7645..90b152b 100644 --- a/sys/sys/proc.h +++ b/sys/sys/proc.h @@ -166,37 +166,6 @@ struct mqueue_notifier; struct cpuset; /* - * Here we define the two structures used for process information. - * - * The first is the thread. It might be thought of as a "Kernel - * Schedulable Entity Context". - * This structure contains all the information as to where a thread of - * execution is now, or was when it was suspended, why it was suspended, - * and anything else that will be needed to restart it when it is - * rescheduled. It includes a scheduler specific substructure that is different - * for each scheduler. - * - * M:N notes. - * It is important to remember that when using M:N threading, - * a particular thread structure may only exist as long as - * the system call or kernel entrance (e.g. by pagefault) - * which it is currently executing. It should therefore NEVER be referenced - * by pointers in long lived structures that live longer than a single - * request. If several threads complete their work at the same time, - * they will all rewind their stacks to the user boundary, report their - * completion state, and all but one will be freed. That last one will - * be kept to provide a kernel stack and pcb for the NEXT syscall or kernel - * entrance (basically to save freeing and then re-allocating it). The existing - * thread keeps a cached spare thread available to allow it to quickly - * get one when it needs a new one. There is also a system - * cache of free threads. Threads have priority and partake in priority - * inheritance schemes. - * - * The second is the proc (process) which owns all the resources of a process - * other than CPU cycles, which are parceled out to the threads. - */ - -/* * Kernel runnable context (thread). * This is what is put to sleep and reactivated. * Thread context. Processes may have multiple threads. @@ -218,7 +187,7 @@ struct thread { sigqueue_t td_sigqueue; /* (c) Sigs arrived, not delivered. */ #define td_siglist td_sigqueue.sq_signals -/* Cleared during fork1() or thread_schedule_upcall(). */ +/* Cleared during fork1() */ #define td_startzero td_flags int td_flags; /* (t) TDF_* flags. */ int td_inhibitors; /* (t) Why can not run. */ @@ -239,10 +208,7 @@ struct thread { struct lock_list_entry *td_sleeplocks; /* (k) Held sleep locks. */ int td_intr_nesting_level; /* (k) Interrupt recursion. */ int td_pinned; /* (k) Temporary cpu pin count. */ - struct kse_thr_mailbox *td_mailbox; /* (*) Userland mailbox address. */ struct ucred *td_ucred; /* (k) Reference to credentials. */ - struct thread *td_standin; /* (k + a) Use this for an upcall. */ - struct kse_upcall *td_upcall; /* (k + t) Upcall structure. */ u_int td_estcpu; /* (t) estimated cpu utilization */ u_int td_slptick; /* (t) Time at sleep. */ struct rusage td_ru; /* (t) rusage information */ @@ -254,12 +220,11 @@ struct thread { u_int td_uticks; /* (t) Statclock hits in user mode. */ u_int td_uuticks; /* (k) Statclock hits (usr), for UTS. */ u_int td_usticks; /* (k) Statclock hits (sys), for UTS. */ - int td_intrval; /* (t) Return value of TDF_INTERRUPT. */ + int td_intrval; /* (t) Return value for sleepq. */ sigset_t td_oldsigmask; /* (k) Saved mask from pre sigpause. */ sigset_t td_sigmask; /* (c) Current signal mask. */ volatile u_int td_generation; /* (k) For detection of preemption */ stack_t td_sigstk; /* (k) Stack ptr and on-stack flag. */ - int td_kflags; /* (c) Flags for KSE threading. */ int td_xsig; /* (c) Signal for ptrace */ u_long td_profil_addr; /* (k) Temporary addr until AST. */ u_int td_profil_ticks; /* (k) Temporary ticks until AST. */ @@ -342,7 +307,7 @@ do { \ #define TDF_BOUNDARY 0x00000400 /* Thread suspended at user boundary */ #define TDF_ASTPENDING 0x00000800 /* Thread has some asynchronous events. */ #define TDF_TIMOFAIL 0x00001000 /* Timeout from sleep after we were awake. */ -#define TDF_INTERRUPT 0x00002000 /* Thread is marked as interrupted. */ +#define TDF_UNUSED2000 0x00002000 /* --available-- */ #define TDF_UPIBLOCKED 0x00004000 /* Thread blocked on user PI mutex. */ #define TDF_UNUSED15 0x00008000 /* --available-- */ #define TDF_NEEDRESCHED 0x00010000 /* Thread needs to yield. */ @@ -368,15 +333,15 @@ do { \ #define TDP_OLDMASK 0x00000001 /* Need to restore mask after suspend. */ #define TDP_INKTR 0x00000002 /* Thread is currently in KTR code. */ #define TDP_INKTRACE 0x00000004 /* Thread is currently in KTRACE code. */ -#define TDP_UPCALLING 0x00000008 /* This thread is doing an upcall. */ +#define TDP_UNUSED8 0x00000008 /* available */ #define TDP_COWINPROGRESS 0x00000010 /* Snapshot copy-on-write in progress. */ #define TDP_ALTSTACK 0x00000020 /* Have alternate signal stack. */ #define TDP_DEADLKTREAT 0x00000040 /* Lock aquisition - deadlock treatment. */ -#define TDP_SA 0x00000080 /* A scheduler activation based thread. */ +#define TDP_UNUSED80 0x00000080 /* available. */ #define TDP_NOSLEEPING 0x00000100 /* Thread is not allowed to sleep on a sq. */ #define TDP_OWEUPC 0x00000200 /* Call addupc() at next AST. */ #define TDP_ITHREAD 0x00000400 /* Thread is an interrupt thread. */ -#define TDP_CAN_UNBIND 0x00000800 /* Only temporarily bound. */ +#define TDP_UNUSED800 0x00000800 /* available. */ #define TDP_SCHED1 0x00001000 /* Reserved for scheduler private use */ #define TDP_SCHED2 0x00002000 /* Reserved for scheduler private use */ #define TDP_SCHED3 0x00004000 /* Reserved for scheduler private use */ @@ -399,17 +364,6 @@ do { \ #define TDI_LOCK 0x0008 /* Stopped on a lock. */ #define TDI_IWAIT 0x0010 /* Awaiting interrupt. */ -/* - * flags (in kflags) related to M:N threading. - */ -#define TDK_KSEREL 0x0001 /* Blocked in msleep on p->p_completed. */ -#define TDK_KSERELSIG 0x0002 /* Blocked in msleep on p->p_siglist. */ -#define TDK_WAKEUP 0x0004 /* Thread has been woken by kse_wakeup. */ - -#define TD_CAN_UNBIND(td) \ - (((td)->td_pflags & TDP_CAN_UNBIND) && \ - ((td)->td_upcall != NULL)) - #define TD_IS_SLEEPING(td) ((td)->td_inhibitors & TDI_SLEEPING) #define TD_ON_SLEEPQ(td) ((td)->td_wchan != NULL) #define TD_IS_SUSPENDED(td) ((td)->td_inhibitors & TDI_SUSPENDED) @@ -421,11 +375,7 @@ do { \ #define TD_CAN_RUN(td) ((td)->td_state == TDS_CAN_RUN) #define TD_IS_INHIBITED(td) ((td)->td_state == TDS_INHIBITED) #define TD_ON_UPILOCK(td) ((td)->td_flags & TDF_UPIBLOCKED) -#if 0 -#define TD_IS_IDLETHREAD(td) ((td) == pcpu(idlethread)) -#else #define TD_IS_IDLETHREAD(td) ((td)->td_flags & TDF_IDLETD) -#endif #define TD_SET_INHIB(td, inhib) do { \ @@ -457,24 +407,6 @@ do { \ #define TD_SET_CAN_RUN(td) (td)->td_state = TDS_CAN_RUN /* - * An upcall is used when returning to userland. If a thread does not have - * an upcall on return to userland the thread exports its context and exits. - */ -struct kse_upcall { - TAILQ_ENTRY(kse_upcall) ku_link; /* List of upcalls in proc. */ - struct proc *ku_proc; /* Associated proc. */ - struct thread *ku_owner; /* Owning thread. */ - int ku_flags; /* KUF_* flags. */ - struct kse_mailbox *ku_mailbox; /* Userland mailbox address. */ - stack_t ku_stack; /* Userland upcall stack. */ - void *ku_func; /* Userland upcall function. */ - unsigned int ku_mflags; /* Cached upcall mbox flags. */ -}; - -#define KUF_DOUPCALL 0x00001 /* Do upcall now; don't wait. */ -#define KUF_EXITING 0x00002 /* Upcall structure is exiting. */ - -/* * XXX: Does this belong in resource.h or resourcevar.h instead? * Resource usage extension. The times in rusage structs in the kernel are * never up to date. The actual times are kept as runtimes and tick counts @@ -495,18 +427,15 @@ struct rusage_ext { }; /* - * The old fashionned process. May have multiple threads. - * Starts off with a single embedded THREAD. + * Process structure. */ struct proc { LIST_ENTRY(proc) p_list; /* (d) List of all processes. */ TAILQ_HEAD(, thread) p_threads; /* (j) all threads. */ - TAILQ_HEAD(, kse_upcall) p_upcalls; /* (j) All upcalls in the proc. */ struct mtx p_slock; /* process spin lock */ struct ucred *p_ucred; /* (c) Process owner's identity. */ struct filedesc *p_fd; /* (b) Open files. */ struct filedesc_to_leader *p_fdtol; /* (b) Tracking node */ - /* Accumulated stats for all threads? */ struct pstats *p_stats; /* (b) Accounting/statistics (CPU). */ struct plimit *p_limit; /* (c) Process limits. */ struct callout p_limco; /* (c) Limit callout handle */ @@ -565,11 +494,6 @@ struct proc { int p_boundary_count;/* (c) Num threads at user boundary */ int p_pendingcnt; /* how many signals are pending */ struct itimers *p_itimers; /* (c) POSIX interval timers. */ - int p_numupcalls; /* (j) Num upcalls. */ - int p_upsleeps; /* (c) Num threads in kse_release(). */ - struct kse_thr_mailbox *p_completed; /* (c) Completed thread mboxes. */ - int p_nextupcall; /* (n) Next upcall time. */ - int p_upquantum; /* (n) Quantum to schedule an upcall. */ /* End area that is zeroed on creation. */ #define p_endzero p_magic @@ -627,7 +551,7 @@ struct proc { #define P_WAITED 0x01000 /* Someone is waiting for us. */ #define P_WEXIT 0x02000 /* Working on exiting. */ #define P_EXEC 0x04000 /* Process called exec. */ -#define P_SA 0x08000 /* Using scheduler activations. */ +#define P_UNUSED8000 0x08000 /* available. */ #define P_CONTINUED 0x10000 /* Proc has continued from a stopped state. */ #define P_STOPPED_SIG 0x20000 /* Stopped due to SIGSTOP/SIGTSTP. */ #define P_STOPPED_TRACE 0x40000 /* Stopped because of tracing. */ @@ -673,8 +597,6 @@ struct proc { #define SINGLE_EXIT 1 #define SINGLE_BOUNDARY 2 -/* XXXKSE: Missing values for thread_suspend_check(). */ - #ifdef MALLOC_DECLARE MALLOC_DECLARE(M_PARGS); MALLOC_DECLARE(M_PGRP); @@ -687,10 +609,7 @@ MALLOC_DECLARE(M_ZOMBIE); LIST_FOREACH((p), &allproc, p_list) #define FOREACH_THREAD_IN_PROC(p, td) \ TAILQ_FOREACH((td), &(p)->p_threads, td_plist) -#define FOREACH_UPCALL_IN_PROC(p, ku) \ - TAILQ_FOREACH((ku), &(p)->p_upcalls, ku_link) -/* XXXKSE the following lines should probably only be used in 1:1 code: */ #define FIRST_THREAD_IN_PROC(p) TAILQ_FIRST(&(p)->p_threads) /* @@ -884,15 +803,9 @@ void exit1(struct thread *, int) __dead2; void cpu_fork(struct thread *, struct proc *, struct thread *, int); void cpu_set_fork_handler(struct thread *, void (*)(void *), void *); -/* New in KSE. */ -#ifdef KSE -void kse_unlink(struct thread *); -void kseinit(void); -void upcall_reap(void); -void upcall_remove(struct thread *td); -#endif void cpu_set_upcall(struct thread *td, struct thread *td0); -void cpu_set_upcall_kse(struct thread *, void (*)(void *), void *, stack_t *); +void cpu_set_upcall_kse(struct thread *, void (*)(void *), void *, + stack_t *); int cpu_set_user_tls(struct thread *, void *tls_base); void cpu_thread_alloc(struct thread *); void cpu_thread_clean(struct thread *); @@ -901,17 +814,13 @@ void cpu_thread_free(struct thread *); void cpu_thread_swapin(struct thread *); void cpu_thread_swapout(struct thread *); struct thread *thread_alloc(void); -void thread_continued(struct proc *p); void thread_exit(void) __dead2; -int thread_export_context(struct thread *td, int willexit); void thread_free(struct thread *td); void thread_link(struct thread *td, struct proc *p); void thread_reap(void); -void thread_signal_add(struct thread *td, ksiginfo_t *); int thread_single(int how); void thread_single_end(void); void thread_stash(struct thread *td); -int thread_statclock(int user); void thread_stopped(struct proc *p); void childproc_stopped(struct proc *child, int reason); void childproc_continued(struct proc *child); @@ -919,14 +828,10 @@ void childproc_exited(struct proc *child); int thread_suspend_check(int how); void thread_suspend_switch(struct thread *); void thread_suspend_one(struct thread *td); -struct thread *thread_switchout(struct thread *td, int flags, - struct thread *newtd); void thread_unlink(struct thread *td); void thread_unsuspend(struct proc *p); void thread_unsuspend_one(struct thread *td); void thread_unthread(struct thread *td); -int thread_userret(struct thread *td, struct trapframe *frame); -void thread_user_enter(struct thread *td); void thread_wait(struct proc *p); struct thread *thread_find(struct proc *p, lwpid_t tid); void thr_exit1(void); diff --git a/sys/sys/sched.h b/sys/sys/sched.h index ca7bfc9..431a929 100644 --- a/sys/sys/sched.h +++ b/sys/sys/sched.h @@ -82,11 +82,6 @@ int sched_runnable(void); void sched_exit(struct proc *p, struct thread *childtd); void sched_fork(struct thread *td, struct thread *childtd); void sched_fork_exit(struct thread *td); - -/* - * KSE Groups contain scheduling priority information. They record the - * behavior of groups of KSEs and threads. - */ void sched_class(struct thread *td, int class); void sched_nice(struct proc *p, int nice); diff --git a/sys/sys/syscall.h b/sys/sys/syscall.h index a0124aa..cc3c701 100644 --- a/sys/sys/syscall.h +++ b/sys/sys/syscall.h @@ -306,11 +306,6 @@ #define SYS_nfsclnt 375 #define SYS_eaccess 376 #define SYS_nmount 378 -#define SYS_kse_exit 379 -#define SYS_kse_wakeup 380 -#define SYS_kse_create 381 -#define SYS_kse_thr_interrupt 382 -#define SYS_kse_release 383 #define SYS___mac_get_proc 384 #define SYS___mac_set_proc 385 #define SYS___mac_get_fd 386 @@ -363,7 +358,6 @@ #define SYS_extattr_list_fd 437 #define SYS_extattr_list_file 438 #define SYS_extattr_list_link 439 -#define SYS_kse_switchin 440 #define SYS_ksem_timedwait 441 #define SYS_thr_suspend 442 #define SYS_thr_wake 443 diff --git a/sys/sys/syscall.mk b/sys/sys/syscall.mk index 3744a1b..fe6b21c 100644 --- a/sys/sys/syscall.mk +++ b/sys/sys/syscall.mk @@ -255,11 +255,6 @@ MIASM = \ nfsclnt.o \ eaccess.o \ nmount.o \ - kse_exit.o \ - kse_wakeup.o \ - kse_create.o \ - kse_thr_interrupt.o \ - kse_release.o \ __mac_get_proc.o \ __mac_set_proc.o \ __mac_get_fd.o \ @@ -312,7 +307,6 @@ MIASM = \ extattr_list_fd.o \ extattr_list_file.o \ extattr_list_link.o \ - kse_switchin.o \ ksem_timedwait.o \ thr_suspend.o \ thr_wake.o \ diff --git a/sys/sys/sysproto.h b/sys/sys/sysproto.h index 530b31d..2319e13 100644 --- a/sys/sys/sysproto.h +++ b/sys/sys/sysproto.h @@ -1094,24 +1094,6 @@ struct nmount_args { char iovcnt_l_[PADL_(unsigned int)]; unsigned int iovcnt; char iovcnt_r_[PADR_(unsigned int)]; char flags_l_[PADL_(int)]; int flags; char flags_r_[PADR_(int)]; }; -struct kse_exit_args { - register_t dummy; -}; -struct kse_wakeup_args { - char mbx_l_[PADL_(struct kse_mailbox *)]; struct kse_mailbox * mbx; char mbx_r_[PADR_(struct kse_mailbox *)]; -}; -struct kse_create_args { - char mbx_l_[PADL_(struct kse_mailbox *)]; struct kse_mailbox * mbx; char mbx_r_[PADR_(struct kse_mailbox *)]; - char newgroup_l_[PADL_(int)]; int newgroup; char newgroup_r_[PADR_(int)]; -}; -struct kse_thr_interrupt_args { - char tmbx_l_[PADL_(struct kse_thr_mailbox *)]; struct kse_thr_mailbox * tmbx; char tmbx_r_[PADR_(struct kse_thr_mailbox *)]; - char cmd_l_[PADL_(int)]; int cmd; char cmd_r_[PADR_(int)]; - char data_l_[PADL_(long)]; long data; char data_r_[PADR_(long)]; -}; -struct kse_release_args { - char timeout_l_[PADL_(struct timespec *)]; struct timespec * timeout; char timeout_r_[PADR_(struct timespec *)]; -}; struct __mac_get_proc_args { char mac_p_l_[PADL_(struct mac *)]; struct mac * mac_p; char mac_p_r_[PADR_(struct mac *)]; }; @@ -1335,10 +1317,6 @@ struct extattr_list_link_args { char data_l_[PADL_(void *)]; void * data; char data_r_[PADR_(void *)]; char nbytes_l_[PADL_(size_t)]; size_t nbytes; char nbytes_r_[PADR_(size_t)]; }; -struct kse_switchin_args { - char tmbx_l_[PADL_(struct kse_thr_mailbox *)]; struct kse_thr_mailbox * tmbx; char tmbx_r_[PADR_(struct kse_thr_mailbox *)]; - char flags_l_[PADL_(int)]; int flags; char flags_r_[PADR_(int)]; -}; struct ksem_timedwait_args { char id_l_[PADL_(semid_t)]; semid_t id; char id_r_[PADR_(semid_t)]; char abstime_l_[PADL_(const struct timespec *)]; const struct timespec * abstime; char abstime_r_[PADR_(const struct timespec *)]; @@ -1800,11 +1778,6 @@ int __setugid(struct thread *, struct __setugid_args *); int nfsclnt(struct thread *, struct nfsclnt_args *); int eaccess(struct thread *, struct eaccess_args *); int nmount(struct thread *, struct nmount_args *); -int kse_exit(struct thread *, struct kse_exit_args *); -int kse_wakeup(struct thread *, struct kse_wakeup_args *); -int kse_create(struct thread *, struct kse_create_args *); -int kse_thr_interrupt(struct thread *, struct kse_thr_interrupt_args *); -int kse_release(struct thread *, struct kse_release_args *); int __mac_get_proc(struct thread *, struct __mac_get_proc_args *); int __mac_set_proc(struct thread *, struct __mac_set_proc_args *); int __mac_get_fd(struct thread *, struct __mac_get_fd_args *); @@ -1857,7 +1830,6 @@ int jail_attach(struct thread *, struct jail_attach_args *); int extattr_list_fd(struct thread *, struct extattr_list_fd_args *); int extattr_list_file(struct thread *, struct extattr_list_file_args *); int extattr_list_link(struct thread *, struct extattr_list_link_args *); -int kse_switchin(struct thread *, struct kse_switchin_args *); int ksem_timedwait(struct thread *, struct ksem_timedwait_args *); int thr_suspend(struct thread *, struct thr_suspend_args *); int thr_wake(struct thread *, struct thr_wake_args *); @@ -2371,11 +2343,6 @@ int freebsd4_sigreturn(struct thread *, struct freebsd4_sigreturn_args *); #define SYS_AUE_nfsclnt AUE_NULL #define SYS_AUE_eaccess AUE_EACCESS #define SYS_AUE_nmount AUE_NMOUNT -#define SYS_AUE_kse_exit AUE_NULL -#define SYS_AUE_kse_wakeup AUE_NULL -#define SYS_AUE_kse_create AUE_NULL -#define SYS_AUE_kse_thr_interrupt AUE_NULL -#define SYS_AUE_kse_release AUE_NULL #define SYS_AUE___mac_get_proc AUE_NULL #define SYS_AUE___mac_set_proc AUE_NULL #define SYS_AUE___mac_get_fd AUE_NULL @@ -2428,7 +2395,6 @@ int freebsd4_sigreturn(struct thread *, struct freebsd4_sigreturn_args *); #define SYS_AUE_extattr_list_fd AUE_EXTATTR_LIST_FD #define SYS_AUE_extattr_list_file AUE_EXTATTR_LIST_FILE #define SYS_AUE_extattr_list_link AUE_EXTATTR_LIST_LINK -#define SYS_AUE_kse_switchin AUE_NULL #define SYS_AUE_ksem_timedwait AUE_NULL #define SYS_AUE_thr_suspend AUE_NULL #define SYS_AUE_thr_wake AUE_NULL diff --git a/sys/sys/systm.h b/sys/sys/systm.h index 91189e3..0e5f820 100644 --- a/sys/sys/systm.h +++ b/sys/sys/systm.h @@ -116,7 +116,6 @@ struct lock_object; struct malloc_type; struct mtx; struct proc; -struct kse; struct socket; struct thread; struct tty; diff --git a/sys/vm/vm_glue.c b/sys/vm/vm_glue.c index 2a0b516..71b3b79 100644 --- a/sys/vm/vm_glue.c +++ b/sys/vm/vm_glue.c @@ -663,8 +663,6 @@ faultin(p) * is enough space for them. Of course, if a process waits for a long * time, it will be swapped in anyway. * - * XXXKSE - process with the thread with highest priority counts.. - * * Giant is held on entry. */ /* ARGSUSED*/ diff --git a/sys/vm/vm_map.c b/sys/vm/vm_map.c index f3ee930..dfbba59 100644 --- a/sys/vm/vm_map.c +++ b/sys/vm/vm_map.c @@ -3036,7 +3036,7 @@ vmspace_exec(struct proc *p, vm_offset_t minuser, vm_offset_t maxuser) PROC_VMSPACE_LOCK(p); p->p_vmspace = newvmspace; PROC_VMSPACE_UNLOCK(p); - if (p == curthread->td_proc) /* XXXKSE ? */ + if (p == curthread->td_proc) pmap_activate(curthread); vmspace_free(oldvmspace); return (0); @@ -3060,7 +3060,7 @@ vmspace_unshare(struct proc *p) PROC_VMSPACE_LOCK(p); p->p_vmspace = newvmspace; PROC_VMSPACE_UNLOCK(p); - if (p == curthread->td_proc) /* XXXKSE ? */ + if (p == curthread->td_proc) pmap_activate(curthread); vmspace_free(oldvmspace); return (0); |
