LWKT - Rename lwkt_yield_quick() to a more appropriate splz_check().

diff --git a/sys/kern/lwkt_thread.c b/sys/kern/lwkt_thread.c
index 8d4198d..8694163 100644 (file)
--- a/sys/kern/lwkt_thread.c
+++ b/sys/kern/lwkt_thread.c
@@ -76,7 +76,6 @@ static MALLOC_DEFINE(M_THREAD, "thread", "lwkt threads");
 #ifdef SMP
 static int mplock_countx = 0;
 #endif
-static int untimely_switch = 0;
 #ifdef INVARIANTS
 static int panic_on_cscount = 0;
 #endif
@@ -128,7 +127,6 @@ jg_tos_ok(struct thread *td)
  */
 TUNABLE_INT("lwkt.use_spin_port", &lwkt_use_spin_port);
 
-SYSCTL_INT(_lwkt, OID_AUTO, untimely_switch, CTLFLAG_RW, &untimely_switch, 0, "");
 #ifdef INVARIANTS
 SYSCTL_INT(_lwkt, OID_AUTO, panic_on_cscount, CTLFLAG_RW, &panic_on_cscount, 0, "");
 #endif
@@ -932,72 +930,30 @@ lwkt_preempt(thread_t ntd, int critpri)
 }
 
 /*
- * Yield our thread while higher priority threads are pending.  This is
- * typically called when we leave a critical section but it can be safely
- * called while we are in a critical section.
+ * Conditionally call splz() if gd_reqflags indicates work is pending.
  *
- * This function will not generally yield to equal priority threads but it
- * can occur as a side effect.  Note that lwkt_switch() is called from
- * inside the critical section to prevent its own crit_exit() from reentering
- * lwkt_yield_quick().
- *
- * gd_reqflags indicates that *something* changed, e.g. an interrupt or softint
- * came along but was blocked and made pending.
+ * td_nest_count prevents deep nesting via splz() or doreti() which
+ * might otherwise blow out the kernel stack.  Note that except for
+ * this special case, we MUST call splz() here to handle any
+ * pending ints, particularly after we switch, or we might accidently
+ * halt the cpu with interrupts pending.
  *
  * (self contained on a per cpu basis)
  */
 void
-lwkt_yield_quick(void)
+splz_check(void)
 {
     globaldata_t gd = mycpu;
     thread_t td = gd->gd_curthread;
 
-    /*
-     * gd_reqflags is cleared in splz if the cpl is 0.  If we were to clear
-     * it with a non-zero cpl then we might not wind up calling splz after
-     * a task switch when the critical section is exited even though the
-     * new task could accept the interrupt.
-     *
-     * XXX from crit_exit() only called after last crit section is released.
-     * If called directly will run splz() even if in a critical section.
-     *
-     * td_nest_count prevent deep nesting via splz() or doreti().  Note that
-     * except for this special case, we MUST call splz() here to handle any
-     * pending ints, particularly after we switch, or we might accidently
-     * halt the cpu with interrupts pending.
-     */
     if (gd->gd_reqflags && td->td_nest_count < 2)
        splz();
-
-    /*
-     * YYY enabling will cause wakeup() to task-switch, which really
-     * confused the old 4.x code.  This is a good way to simulate
-     * preemption and MP without actually doing preemption or MP, because a
-     * lot of code assumes that wakeup() does not block.
-     */
-    if (untimely_switch && td->td_nest_count == 0 &&
-       gd->gd_intr_nesting_level == 0
-    ) {
-       crit_enter_quick(td);
-       /*
-        * YYY temporary hacks until we disassociate the userland scheduler
-        * from the LWKT scheduler.
-        */
-       if (td->td_flags & TDF_RUNQ) {
-           lwkt_switch();              /* will not reenter yield function */
-       } else {
-           lwkt_schedule_self(td);     /* make sure we are scheduled */
-           lwkt_switch();              /* will not reenter yield function */
-           lwkt_deschedule_self(td);   /* make sure we are descheduled */
-       }
-       crit_exit_noyield(td);
-    }
 }
 
 /*
- * This implements a normal yield which, unlike _quick, will yield to equal
- * priority threads as well.  Note that gd_reqflags tests will be handled by
- * the crit_exit() call in lwkt_switch().
+ * This implements a normal yield which will yield to equal priority
+ * threads as well as higher priority threads.  Note that gd_reqflags
+ * tests will be handled by the crit_exit() call in lwkt_switch().
  *
  * (self contained on a per cpu basis)
  */

diff --git a/sys/platform/pc32/i386/bcopy.s b/sys/platform/pc32/i386/bcopy.s
index a27b101..131ab0d 100644 (file)
--- a/sys/platform/pc32/i386/bcopy.s
+++ b/sys/platform/pc32/i386/bcopy.s
@@ -320,7 +320,7 @@ ENTRY(asm_generic_bcopy)
        je      101f ;                                                  \
        cmpl    $TDPRI_CRIT,TD_PRI(%edx) ;                              \
        jge     101f ;                                                  \
-       call    lwkt_yield_quick ;                                      \
+       call    splz_check ;                                            \
        /* note: eax,ecx,edx destroyed */                               \
 101: ;                                                                 \
        movl    (%esp),%ecx ;                                           \

diff --git a/sys/sys/systm.h b/sys/sys/systm.h
index bf70dca..7a2fb37 100644 (file)
--- a/sys/sys/systm.h
+++ b/sys/sys/systm.h
@@ -295,6 +295,7 @@ void                setsoftvm (void);
 void           setsofttq (void);
 void           schedsofttty (void);
 void           splz (void);
+void           splz_check (void);
 #endif /* __i386__ */
 
 /*

diff --git a/sys/sys/thread.h b/sys/sys/thread.h
index 1be8cd8..bce1908 100644 (file)
--- a/sys/sys/thread.h
+++ b/sys/sys/thread.h
@@ -359,7 +359,6 @@ extern void lwkt_schedule_self(thread_t);
 extern void lwkt_deschedule(thread_t);
 extern void lwkt_deschedule_self(thread_t);
 extern void lwkt_yield(void);
-extern void lwkt_yield_quick(void);
 extern void lwkt_user_yield(void);
 extern void lwkt_token_wait(void);
 extern void lwkt_hold(thread_t);

diff --git a/sys/sys/thread2.h b/sys/sys/thread2.h
index 1957d40..adae288 100644 (file)
--- a/sys/sys/thread2.h
+++ b/sys/sys/thread2.h
@@ -107,7 +107,7 @@ _debug_crit_exit(thread_t td, const char *id)
  * current cpu will not be able to schedule a new thread but will instead
  * place it on a pending list (with interrupts physically disabled) and
  * set mycpu->gd_reqflags to indicate that work needs to be done, which
- * lwkt_yield_quick() takes care of.
+ * splz_check() takes care of.
  *
  * Some of these routines take a struct thread pointer as an argument.  This
  * pointer MUST be curthread and is only passed as an optimization.
@@ -168,7 +168,7 @@ _crit_exit(__DEBUG_CRIT_ARG__)
 #endif
     cpu_ccfence();     /* prevent compiler reordering */
     if (td->td_gd->gd_reqflags && td->td_pri < TDPRI_CRIT)
-       lwkt_yield_quick();
+       splz_check();
 }
 
 static __inline void
@@ -180,7 +180,7 @@ _crit_exit_quick(struct thread *curtd __DEBUG_CRIT_ADD_ARG__)
     curtd->td_pri -= TDPRI_CRIT;
     cpu_ccfence();     /* prevent compiler reordering */
     if (gd->gd_reqflags && curtd->td_pri < TDPRI_CRIT)
-       lwkt_yield_quick();
+       splz_check();
 }
 
 static __inline void