sys/sys/thread2.h

   1 /*
   2  * SYS/THREAD2.H
   3  *
   4  * Implements inline procedure support for the LWKT subsystem.
   5  *
   6  * Generally speaking these routines only operate on threads associated
   7  * with the current cpu.  For example, a higher priority thread pending
   8  * on a different cpu will not be immediately scheduled by a yield() on
   9  * this cpu.
  10  *
  11  * $DragonFly: src/sys/sys/thread2.h,v 1.28 2006/12/23 00:27:03 swildner Exp $
  12  */
  13
  14 #ifndef _SYS_THREAD2_H_
  15 #define _SYS_THREAD2_H_
  16
  17 #ifndef _KERNEL
  18
  19 #error "This file should not be included by userland programs."
  20
  21 #else
  22
  23 /*
  24  * Userland will have its own globaldata which it includes prior to this.
  25  */
  26 #ifndef _SYS_SYSTM_H_
  27 #include <sys/systm.h>
  28 #endif
  29 #ifndef _SYS_GLOBALDATA_H_
  30 #include <sys/globaldata.h>
  31 #endif
  32 #ifndef _MACHINE_CPUFUNC_H_
  33 #include <machine/cpufunc.h>
  34 #endif
  35
  36 /*
  37  * Critical section debugging
  38  */
  39 #ifdef DEBUG_CRIT_SECTIONS
  40 #define __DEBUG_CRIT_ARG__              const char *id
  41 #define __DEBUG_CRIT_ADD_ARG__          , const char *id
  42 #define __DEBUG_CRIT_PASS_ARG__         , id
  43 #define __DEBUG_CRIT_ENTER(td)          _debug_crit_enter((td), id)
  44 #define __DEBUG_CRIT_EXIT(td)           _debug_crit_exit((td), id)
  45 #define crit_enter()                    _crit_enter(__FUNCTION__)
  46 #define crit_enter_id(id)               _crit_enter(id)
  47 #define crit_enter_quick(curtd)         _crit_enter_quick((curtd), __FUNCTION__)
  48 #define crit_enter_gd(curgd)            _crit_enter_gd(curgd, __FUNCTION__)
  49 #define crit_exit()                     _crit_exit(__FUNCTION__)
  50 #define crit_exit_id(id)                _crit_exit(id)
  51 #define crit_exit_quick(curtd)          _crit_exit_quick((curtd), __FUNCTION__)
  52 #define crit_exit_noyield(curtd)        _crit_exit_noyield((curtd),__FUNCTION__)
  53 #define crit_exit_gd(curgd)             _crit_exit_gd((curgd), __FUNCTION__)
  54 #else
  55 #define __DEBUG_CRIT_ARG__              void
  56 #define __DEBUG_CRIT_ADD_ARG__
  57 #define __DEBUG_CRIT_PASS_ARG__
  58 #define __DEBUG_CRIT_ENTER(td)
  59 #define __DEBUG_CRIT_EXIT(td)
  60 #define crit_enter()                    _crit_enter()
  61 #define crit_enter_id(id)               _crit_enter()
  62 #define crit_enter_quick(curtd)         _crit_enter_quick(curtd)
  63 #define crit_enter_gd(curgd)            _crit_enter_gd(curgd)
  64 #define crit_exit()                     _crit_exit()
  65 #define crit_exit_id(id)                _crit_exit()
  66 #define crit_exit_quick(curtd)          _crit_exit_quick(curtd)
  67 #define crit_exit_noyield(curtd)        _crit_exit_noyield(curtd)
  68 #define crit_exit_gd(curgd)             _crit_exit_gd(curgd)
  69 #endif
  70
  71 /*
  72  * Track crit_enter()/crit_exit() pairs and warn on mismatches.
  73  */
  74 #ifdef DEBUG_CRIT_SECTIONS
  75
  76 static __inline void
  77 _debug_crit_enter(thread_t td, const char *id)
  78 {
  79     int wi = td->td_crit_debug_index;
  80
  81     td->td_crit_debug_array[wi & CRIT_DEBUG_ARRAY_MASK] = id;
  82     ++td->td_crit_debug_index;
  83 }
  84
  85 static __inline void
  86 _debug_crit_exit(thread_t td, const char *id)
  87 {
  88     const char *gid;
  89     int wi;
  90
  91     wi = td->td_crit_debug_index - 1;
  92     if ((gid = td->td_crit_debug_array[wi & CRIT_DEBUG_ARRAY_MASK]) != id) {
  93         if (td->td_in_crit_report == 0) {
  94             td->td_in_crit_report = 1;
  95             kprintf("crit_exit(%s) expected id %s\n", id, gid);
  96             td->td_in_crit_report = 0;
  97         }
  98     }
  99     --td->td_crit_debug_index;
 100 }
 101
 102 #endif
 103
 104 /*
 105  * Critical sections prevent preemption by raising a thread's priority
 106  * above the highest possible interrupting priority.  Additionally, the
 107  * current cpu will not be able to schedule a new thread but will instead
 108  * place it on a pending list (with interrupts physically disabled) and
 109  * set mycpu->gd_reqflags to indicate that work needs to be done, which
 110  * splz_check() takes care of.
 111  *
 112  * Some of these routines take a struct thread pointer as an argument.  This
 113  * pointer MUST be curthread and is only passed as an optimization.
 114  *
 115  * Synchronous switching and blocking is allowed while in a critical section.
 116  */
 117
 118 static __inline void
 119 _crit_enter(__DEBUG_CRIT_ARG__)
 120 {
 121     struct thread *td = curthread;
 122
 123 #ifdef INVARIANTS
 124     if (td->td_pri < 0)
 125         crit_panic();
 126 #endif
 127     td->td_pri += TDPRI_CRIT;
 128     __DEBUG_CRIT_ENTER(td);
 129     cpu_ccfence();
 130 }
 131
 132 static __inline void
 133 _crit_enter_quick(struct thread *curtd __DEBUG_CRIT_ADD_ARG__)
 134 {
 135     curtd->td_pri += TDPRI_CRIT;
 136     __DEBUG_CRIT_ENTER(curtd);
 137     cpu_ccfence();
 138 }
 139
 140 static __inline void
 141 _crit_enter_gd(globaldata_t mygd __DEBUG_CRIT_ADD_ARG__)
 142 {
 143     _crit_enter_quick(mygd->gd_curthread __DEBUG_CRIT_PASS_ARG__);
 144 }
 145
 146 static __inline void
 147 _crit_exit_noyield(struct thread *curtd __DEBUG_CRIT_ADD_ARG__)
 148 {
 149     __DEBUG_CRIT_EXIT(curtd);
 150     curtd->td_pri -= TDPRI_CRIT;
 151 #ifdef INVARIANTS
 152     if (curtd->td_pri < 0)
 153         crit_panic();
 154 #endif
 155     cpu_ccfence();      /* prevent compiler reordering */
 156 }
 157
 158 static __inline void
 159 _crit_exit(__DEBUG_CRIT_ARG__)
 160 {
 161     thread_t td = curthread;
 162
 163     __DEBUG_CRIT_EXIT(td);
 164     td->td_pri -= TDPRI_CRIT;
 165 #ifdef INVARIANTS
 166     if (td->td_pri < 0)
 167         crit_panic();
 168 #endif
 169     cpu_ccfence();      /* prevent compiler reordering */
 170     if (td->td_gd->gd_reqflags && td->td_pri < TDPRI_CRIT)
 171         splz_check();
 172 }
 173
 174 static __inline void
 175 _crit_exit_quick(struct thread *curtd __DEBUG_CRIT_ADD_ARG__)
 176 {
 177     globaldata_t gd = curtd->td_gd;
 178
 179     __DEBUG_CRIT_EXIT(curtd);
 180     curtd->td_pri -= TDPRI_CRIT;
 181     cpu_ccfence();      /* prevent compiler reordering */
 182     if (gd->gd_reqflags && curtd->td_pri < TDPRI_CRIT)
 183         splz_check();
 184 }
 185
 186 static __inline void
 187 _crit_exit_gd(globaldata_t mygd __DEBUG_CRIT_ADD_ARG__)
 188 {
 189     _crit_exit_quick(mygd->gd_curthread __DEBUG_CRIT_PASS_ARG__);
 190 }
 191
 192 static __inline int
 193 crit_test(thread_t td)
 194 {
 195     return(td->td_pri >= TDPRI_CRIT);
 196 }
 197
 198 /*
 199  * Return whether any threads are runnable, whether they meet mp_lock
 200  * requirements or not.
 201  */
 202 static __inline int
 203 lwkt_runnable(void)
 204 {
 205     return (mycpu->gd_runqmask != 0);
 206 }
 207
 208 static __inline int
 209 lwkt_getpri(thread_t td)
 210 {
 211     return(td->td_pri & TDPRI_MASK);
 212 }
 213
 214 static __inline int
 215 lwkt_getpri_self(void)
 216 {
 217     return(lwkt_getpri(curthread));
 218 }
 219
 220 /*
 221  * Reduce our priority in preparation for a return to userland.  If
 222  * our passive release function was still in place, our priority was
 223  * never raised and does not need to be reduced.
 224  *
 225  * See also lwkt_passive_release() and platform/blah/trap.c
 226  */
 227 static __inline void
 228 lwkt_passive_recover(thread_t td)
 229 {
 230     if (td->td_release == NULL)
 231         lwkt_setpri_self(TDPRI_USER_NORM);
 232     td->td_release = NULL;
 233 }
 234
 235 #ifdef SMP
 236
 237 /*
 238  * IPIQ messaging wrappers.  IPIQ remote functions are passed three arguments:
 239  * a void * pointer, an integer, and a pointer to the trap frame (or NULL if
 240  * the trap frame is not known).  However, we wish to provide opaque
 241  * interfaces for simpler callbacks... the basic IPI messaging function as
 242  * used by the kernel takes a single argument.
 243  */
 244 static __inline int
 245 lwkt_send_ipiq(globaldata_t target, ipifunc1_t func, void *arg)
 246 {
 247     return(lwkt_send_ipiq3(target, (ipifunc3_t)func, arg, 0));
 248 }
 249
 250 static __inline int
 251 lwkt_send_ipiq2(globaldata_t target, ipifunc2_t func, void *arg1, int arg2)
 252 {
 253     return(lwkt_send_ipiq3(target, (ipifunc3_t)func, arg1, arg2));
 254 }
 255
 256 static __inline int
 257 lwkt_send_ipiq_mask(u_int32_t mask, ipifunc1_t func, void *arg)
 258 {
 259     return(lwkt_send_ipiq3_mask(mask, (ipifunc3_t)func, arg, 0));
 260 }
 261
 262 static __inline int
 263 lwkt_send_ipiq2_mask(u_int32_t mask, ipifunc2_t func, void *arg1, int arg2)
 264 {
 265     return(lwkt_send_ipiq3_mask(mask, (ipifunc3_t)func, arg1, arg2));
 266 }
 267
 268 static __inline int
 269 lwkt_send_ipiq_nowait(globaldata_t target, ipifunc1_t func, void *arg)
 270 {
 271     return(lwkt_send_ipiq3_nowait(target, (ipifunc3_t)func, arg, 0));
 272 }
 273
 274 static __inline int
 275 lwkt_send_ipiq2_nowait(globaldata_t target, ipifunc2_t func,
 276                        void *arg1, int arg2)
 277 {
 278     return(lwkt_send_ipiq3_nowait(target, (ipifunc3_t)func, arg1, arg2));
 279 }
 280
 281 static __inline int
 282 lwkt_send_ipiq_passive(globaldata_t target, ipifunc1_t func, void *arg)
 283 {
 284     return(lwkt_send_ipiq3_passive(target, (ipifunc3_t)func, arg, 0));
 285 }
 286
 287 static __inline int
 288 lwkt_send_ipiq2_passive(globaldata_t target, ipifunc2_t func,
 289                        void *arg1, int arg2)
 290 {
 291     return(lwkt_send_ipiq3_passive(target, (ipifunc3_t)func, arg1, arg2));
 292 }
 293
 294 static __inline int
 295 lwkt_send_ipiq_bycpu(int dcpu, ipifunc1_t func, void *arg)
 296 {
 297     return(lwkt_send_ipiq3_bycpu(dcpu, (ipifunc3_t)func, arg, 0));
 298 }
 299
 300 static __inline int
 301 lwkt_send_ipiq2_bycpu(int dcpu, ipifunc2_t func, void *arg1, int arg2)
 302 {
 303     return(lwkt_send_ipiq3_bycpu(dcpu, (ipifunc3_t)func, arg1, arg2));
 304 }
 305
 306 #endif  /* SMP */
 307 #endif  /* _KERNEL */
 308 #endif  /* _SYS_THREAD2_H_ */
 309