src/thread.h

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