src/thread.h

   1 /* Thread definitions
   2 Copyright (C) 2012-2018 Free Software Foundation, Inc.
   3
   4 This file is part of GNU Emacs.
   5
   6 GNU Emacs is free software: you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation, either version 3 of the License, or
   9 (at your option) any later version.
  10
  11 GNU Emacs is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.  */
  18
  19 #ifndef THREAD_H
  20 #define THREAD_H
  21
  22 #include "regex.h"
  23
  24 #ifdef WINDOWSNT
  25 #include <sys/socket.h>
  26 #endif
  27
  28 #ifdef MSDOS
  29 #include <signal.h>             /* sigset_t */
  30 #endif
  31
  32 #include "sysselect.h"          /* FIXME */
  33 #include "systime.h"            /* FIXME */
  34 #include "systhread.h"
  35
  36 struct thread_state
  37 {
  38   union vectorlike_header header;
  39
  40   /* The buffer in which the last search was performed, or
  41      Qt if the last search was done in a string;
  42      Qnil if no searching has been done yet.  */
  43   Lisp_Object m_last_thing_searched;
  44 #define last_thing_searched (current_thread->m_last_thing_searched)
  45
  46   Lisp_Object m_saved_last_thing_searched;
  47 #define saved_last_thing_searched (current_thread->m_saved_last_thing_searched)
  48
  49   /* The thread's name.  */
  50   Lisp_Object name;
  51
  52   /* The thread's function.  */
  53   Lisp_Object function;
  54
  55   /* If non-nil, this thread has been signaled.  */
  56   Lisp_Object error_symbol;
  57   Lisp_Object error_data;
  58
  59   /* If we are waiting for some event, this holds the object we are
  60      waiting on.  */
  61   Lisp_Object event_object;
  62
  63   /* m_stack_bottom must be the first non-Lisp field.  */
  64   /* An address near the bottom of the stack.
  65      Tells GC how to save a copy of the stack.  */
  66   char *m_stack_bottom;
  67 #define stack_bottom (current_thread->m_stack_bottom)
  68
  69   /* The address of an object near the C stack top, used to determine
  70      which words need to be scanned by the garbage collector.  This is
  71      also used to detect heuristically whether segmentation violation
  72      address indicates stack overflow, as opposed to some internal
  73      error in Emacs.  If the C function F calls G which calls H which
  74      calls ... F, then at least one of the functions in the chain
  75      should set this to the address of a local variable.  */
  76   void *stack_top;
  77
  78   struct catchtag *m_catchlist;
  79 #define catchlist (current_thread->m_catchlist)
  80
  81   /* Chain of condition handlers currently in effect.
  82      The elements of this chain are contained in the stack frames
  83      of Fcondition_case and internal_condition_case.
  84      When an error is signaled (by calling Fsignal),
  85      this chain is searched for an element that applies.  */
  86   struct handler *m_handlerlist;
  87 #define handlerlist (current_thread->m_handlerlist)
  88
  89   struct handler *m_handlerlist_sentinel;
  90 #define handlerlist_sentinel (current_thread->m_handlerlist_sentinel)
  91
  92   /* Current number of specbindings allocated in specpdl.  */
  93   ptrdiff_t m_specpdl_size;
  94 #define specpdl_size (current_thread->m_specpdl_size)
  95
  96   /* Pointer to beginning of specpdl.  */
  97   union specbinding *m_specpdl;
  98 #define specpdl (current_thread->m_specpdl)
  99
 100   /* Pointer to first unused element in specpdl.  */
 101   union specbinding *m_specpdl_ptr;
 102 #define specpdl_ptr (current_thread->m_specpdl_ptr)
 103
 104   /* Depth in Lisp evaluations and function calls.  */
 105   EMACS_INT m_lisp_eval_depth;
 106 #define lisp_eval_depth (current_thread->m_lisp_eval_depth)
 107
 108   /* This points to the current buffer.  */
 109   struct buffer *m_current_buffer;
 110 #define current_buffer (current_thread->m_current_buffer)
 111
 112   /* Every call to re_match, etc., must pass &search_regs as the regs
 113      argument unless you can show it is unnecessary (i.e., if re_match
 114      is certainly going to be called again before region-around-match
 115      can be called).
 116
 117      Since the registers are now dynamically allocated, we need to make
 118      sure not to refer to the Nth register before checking that it has
 119      been allocated by checking search_regs.num_regs.
 120
 121      The regex code keeps track of whether it has allocated the search
 122      buffer using bits in the re_pattern_buffer.  This means that whenever
 123      you compile a new pattern, it completely forgets whether it has
 124      allocated any registers, and will allocate new registers the next
 125      time you call a searching or matching function.  Therefore, we need
 126      to call re_set_registers after compiling a new pattern or after
 127      setting the match registers, so that the regex functions will be
 128      able to free or re-allocate it properly.  */
 129   struct re_registers m_search_regs;
 130 #define search_regs (current_thread->m_search_regs)
 131
 132   /* If non-zero the match data have been saved in saved_search_regs
 133      during the execution of a sentinel or filter. */
 134   bool m_search_regs_saved;
 135 #define search_regs_saved (current_thread->m_search_regs_saved)
 136
 137   struct re_registers m_saved_search_regs;
 138 #define saved_search_regs (current_thread->m_saved_search_regs)
 139
 140   /* This member is different from waiting_for_input.
 141      It is used to communicate to a lisp process-filter/sentinel (via the
 142      function Fwaiting_for_user_input_p) whether Emacs was waiting
 143      for user-input when that process-filter was called.
 144      waiting_for_input cannot be used as that is by definition 0 when
 145      lisp code is being evalled.
 146      This is also used in record_asynch_buffer_change.
 147      For that purpose, this must be 0
 148      when not inside wait_reading_process_output.  */
 149   int m_waiting_for_user_input_p;
 150 #define waiting_for_user_input_p (current_thread->m_waiting_for_user_input_p)
 151
 152   /* True while doing kbd input.  */
 153   bool m_waiting_for_input;
 154 #define waiting_for_input (current_thread->m_waiting_for_input)
 155
 156   /* For longjmp to where kbd input is being done.  This is per-thread
 157      so that if more than one thread calls read_char, they don't
 158      clobber each other's getcjmp, which will cause
 159      quit_throw_to_read_char crash due to using a wrong stack.  */
 160   sys_jmp_buf m_getcjmp;
 161 #define getcjmp (current_thread->m_getcjmp)
 162
 163   /* The OS identifier for this thread.  */
 164   sys_thread_t thread_id;
 165
 166   /* The condition variable for this thread.  This is associated with
 167      the global lock.  This thread broadcasts to it when it exits.  */
 168   sys_cond_t thread_condvar;
 169
 170   /* This thread might be waiting for some condition.  If so, this
 171      points to the condition.  If the thread is interrupted, the
 172      interrupter should broadcast to this condition.  */
 173   sys_cond_t *wait_condvar;
 174
 175   /* This thread might have released the global lock.  If so, this is
 176      non-zero.  When a thread runs outside thread_select with this
 177      flag non-zero, it means it has been interrupted by SIGINT while
 178      in thread_select, and didn't have a chance of acquiring the lock.
 179      It must do so ASAP.  */
 180   int not_holding_lock;
 181
 182   /* Threads are kept on a linked list.  */
 183   struct thread_state *next_thread;
 184 };
 185
 186 INLINE bool
 187 THREADP (Lisp_Object a)
 188 {
 189   return PSEUDOVECTORP (a, PVEC_THREAD);
 190 }
 191
 192 INLINE void
 193 CHECK_THREAD (Lisp_Object x)
 194 {
 195   CHECK_TYPE (THREADP (x), Qthreadp, x);
 196 }
 197
 198 INLINE struct thread_state *
 199 XTHREAD (Lisp_Object a)
 200 {
 201   eassert (THREADP (a));
 202   return XUNTAG (a, Lisp_Vectorlike, struct thread_state);
 203 }
 204
 205 /* A mutex in lisp is represented by a system condition variable.
 206    The system mutex associated with this condition variable is the
 207    global lock.
 208
 209    Using a condition variable lets us implement interruptibility for
 210    lisp mutexes.  */
 211 typedef struct
 212 {
 213   /* The owning thread, or NULL if unlocked.  */
 214   struct thread_state *owner;
 215   /* The lock count.  */
 216   unsigned int count;
 217   /* The underlying system condition variable.  */
 218   sys_cond_t condition;
 219 } lisp_mutex_t;
 220
 221 /* A mutex as a lisp object.  */
 222 struct Lisp_Mutex
 223 {
 224   union vectorlike_header header;
 225
 226   /* The name of the mutex, or nil.  */
 227   Lisp_Object name;
 228
 229   /* The lower-level mutex object.  */
 230   lisp_mutex_t mutex;
 231 };
 232
 233 INLINE bool
 234 MUTEXP (Lisp_Object a)
 235 {
 236   return PSEUDOVECTORP (a, PVEC_MUTEX);
 237 }
 238
 239 INLINE void
 240 CHECK_MUTEX (Lisp_Object x)
 241 {
 242   CHECK_TYPE (MUTEXP (x), Qmutexp, x);
 243 }
 244
 245 INLINE struct Lisp_Mutex *
 246 XMUTEX (Lisp_Object a)
 247 {
 248   eassert (MUTEXP (a));
 249   return XUNTAG (a, Lisp_Vectorlike, struct Lisp_Mutex);
 250 }
 251
 252 /* A condition variable as a lisp object.  */
 253 struct Lisp_CondVar
 254 {
 255   union vectorlike_header header;
 256
 257   /* The associated mutex.  */
 258   Lisp_Object mutex;
 259
 260   /* The name of the condition variable, or nil.  */
 261   Lisp_Object name;
 262
 263   /* The lower-level condition variable object.  */
 264   sys_cond_t cond;
 265 };
 266
 267 INLINE bool
 268 CONDVARP (Lisp_Object a)
 269 {
 270   return PSEUDOVECTORP (a, PVEC_CONDVAR);
 271 }
 272
 273 INLINE void
 274 CHECK_CONDVAR (Lisp_Object x)
 275 {
 276   CHECK_TYPE (CONDVARP (x), Qcondition_variable_p, x);
 277 }
 278
 279 INLINE struct Lisp_CondVar *
 280 XCONDVAR (Lisp_Object a)
 281 {
 282   eassert (CONDVARP (a));
 283   return XUNTAG (a, Lisp_Vectorlike, struct Lisp_CondVar);
 284 }
 285
 286 extern struct thread_state *current_thread;
 287
 288 extern void finalize_one_thread (struct thread_state *state);
 289 extern void finalize_one_mutex (struct Lisp_Mutex *);
 290 extern void finalize_one_condvar (struct Lisp_CondVar *);
 291 extern void maybe_reacquire_global_lock (void);
 292
 293 extern void init_threads_once (void);
 294 extern void init_threads (void);
 295 extern void syms_of_threads (void);
 296 extern bool main_thread_p (void *);
 297 extern bool in_current_thread (void);
 298
 299 typedef int select_func (int, fd_set *, fd_set *, fd_set *,
 300                          const struct timespec *, const sigset_t *);
 301
 302 int thread_select  (select_func *func, int max_fds, fd_set *rfds,
 303                     fd_set *wfds, fd_set *efds, struct timespec *timeout,
 304                     sigset_t *sigmask);
 305
 306 bool thread_check_current_buffer (struct buffer *);
 307
 308 #endif /* THREAD_H */