My Project  debian-1:4.1.2-p1+ds-2
Macros | Typedefs | Functions | Variables
cntrlc.cc File Reference
#include "kernel/mod2.h"
#include "reporter/si_signals.h"
#include "Singular/fevoices.h"
#include "misc/options.h"
#include "Singular/tok.h"
#include "Singular/ipshell.h"
#include "Singular/cntrlc.h"
#include "Singular/feOpt.h"
#include "Singular/misc_ip.h"
#include "Singular/links/silink.h"
#include "Singular/links/ssiLink.h"
#include <NTL/version.h>
#include <NTL/tools.h>
#include <time.h>
#include <sys/time.h>

Go to the source code of this file.

Macros

#define CALL_GDB
 
#define INTERACTIVE   0
 
#define STACK_TRACE   1
 

Typedefs

typedef void(* si_hdl_typ) (int)
 

Functions

static void debug (int)
 
static void debug_stop (char *const *args)
 
static void stack_trace (char *const *args)
 
void sig_pipe_hdl (int)
 
void sig_term_hdl (int)
 
void sigint_handler (int)
 
si_hdl_typ si_set_signal (int sig, si_hdl_typ signal_handler)
 meta function for binding a signal to an handler More...
 
void sigsegv_handler (int sig)
 
void init_signals ()
 init signal handlers and error handling for libraries: NTL, factory More...
 

Variables

VAR si_link pipeLastLink =NULL
 
VAR BOOLEAN singular_in_batchmode =FALSE
 
VAR volatile BOOLEAN do_shutdown = FALSE
 
VAR volatile int defer_shutdown = 0
 
VAR jmp_buf si_start_jmpbuf
 
VAR int siRandomStart
 
VAR short si_restart =0
 
VAR int sigint_handler_cnt =0
 
VAR volatile int si_stop_stack_trace_x
 

Macro Definition Documentation

◆ CALL_GDB

#define CALL_GDB

Definition at line 31 of file cntrlc.cc.

◆ INTERACTIVE

#define INTERACTIVE   0

Definition at line 53 of file cntrlc.cc.

◆ STACK_TRACE

#define STACK_TRACE   1

Definition at line 54 of file cntrlc.cc.

Typedef Documentation

◆ si_hdl_typ

typedef void(* si_hdl_typ) (int)

Definition at line 99 of file cntrlc.cc.

Function Documentation

◆ debug()

static void debug ( int  method)
static

Definition at line 406 of file cntrlc.cc.

407 {
408  if (feOptValue(FE_OPT_NO_TTY))
409  {
410  dReportError("Caught Signal 11");
411  return;
412  }
413  int pid;
414  char buf[16];
415  char * args[4] = { (char*)"gdb", (char*)"Singular", NULL, NULL };
416 
417  #ifdef HAVE_FEREAD
419  #endif /* HAVE_FEREAD */
420 
421  sprintf (buf, "%d", getpid ());
422 
423  args[2] = buf;
424 
425  pid = fork ();
426  if (pid == 0)
427  {
428  switch (method)
429  {
430  case INTERACTIVE:
431  fputs ("\n\nquit with \"p si_stop_stack_trace_x=0\"\n\n\n",stderr);
432  debug_stop (args);
433  break;
434  case STACK_TRACE:
435  fputs ("stack_trace\n",stderr);
436  stack_trace (args);
437  break;
438  default:
439  // should not be reached:
440  exit(1);
441  }
442  }
443  else if (pid == -1)
444  {
445  perror ("could not fork");
446  return;
447  }
448 
450  while (si_stop_stack_trace_x) ;
451 }
static void stack_trace(char *const *args)
Definition: cntrlc.cc:461
VAR volatile int si_stop_stack_trace_x
Definition: cntrlc.cc:404
#define INTERACTIVE
Definition: cntrlc.cc:53
#define STACK_TRACE
Definition: cntrlc.cc:54
static void debug_stop(char *const *args)
Definition: cntrlc.cc:453
static void * feOptValue(feOptIndex opt)
Definition: feOpt.h:40
VAR BOOLEAN fe_is_raw_tty
Definition: fereadl.c:71
void fe_temp_reset(void)
Definition: fereadl.c:109
int dReportError(const char *fmt,...)
Definition: dError.cc:43
#define NULL
Definition: omList.c:12
int status int void * buf
Definition: si_signals.h:59

◆ debug_stop()

static void debug_stop ( char *const args)
static

Definition at line 453 of file cntrlc.cc.

454 {
455  execvp (args[0], args);
456  perror ("exec failed");
457  _exit (0);
458 }

◆ init_signals()

void init_signals ( )

init signal handlers and error handling for libraries: NTL, factory

Definition at line 559 of file cntrlc.cc.

560 {
561 // NTL error handling (>= 9.3.0) ----------------------------------------
562 #ifdef HAVE_NTL
563 #if (((NTL_MAJOR_VERSION==9)&&(NTL_MINOR_VERSION>=3))||(NTL_MAJOR_VERSION>=10))
564  ErrorMsgCallback=WerrorS;
565  ErrorCallback=HALT;
566 #endif
567 #endif
568 // factory error handling: -----------------------------------------------
570 
571 // signal handler -------------------------------------------------------
572  #ifdef SIGSEGV
574  #endif
575  #ifdef SIGBUS
577  #endif
578  #ifdef SIGFPE
580  #endif
581  #ifdef SIGILL
583  #endif
584  #ifdef SIGIOT
586  #endif
591 }
VAR void(* factoryError)(const char *s)
Definition: cf_util.cc:76
void sig_pipe_hdl(int)
Definition: cntrlc.cc:67
si_hdl_typ si_set_signal(int sig, si_hdl_typ signal_handler)
meta function for binding a signal to an handler
Definition: cntrlc.cc:121
void sig_term_hdl(int)
Definition: cntrlc.cc:80
void sigint_handler(int)
Definition: cntrlc.cc:309
void(* si_hdl_typ)(int)
Definition: cntrlc.cc:99
void sigsegv_handler(int sig)
Definition: cntrlc.cc:277
void WerrorS(const char *s)
Definition: feFopen.cc:24
static void HALT()
Definition: mod2.h:127

◆ si_set_signal()

si_hdl_typ si_set_signal ( int  sig,
si_hdl_typ  signal_handler 
)

meta function for binding a signal to an handler

Parameters
[in]sigSignal number
[in]signal_handlerPointer to signal handler
Returns
value of signal()

Definition at line 121 of file cntrlc.cc.

122 {
123 #if 0
124  si_hdl_typ retval=signal (sig, (si_hdl_typ)signal_handler);
125  if (retval == SIG_ERR)
126  {
127  fprintf(stderr, "Unable to init signal %d ... exiting...\n", sig);
128  }
129  si_siginterrupt(sig, 0);
130  /*system calls will be restarted if interrupted by the specified
131  * signal sig. This is the default behavior in Linux.
132  */
133 #else
134  struct sigaction new_action,old_action;
135  memset(&new_action, 0, sizeof(struct sigaction));
136 
137  /* Set up the structure to specify the new action. */
138  new_action.sa_handler = signal_handler;
139  if (sig==SIGINT)
140  sigemptyset (&new_action.sa_mask);
141  else
142  new_action.sa_flags = SA_RESTART;
143 
144  int r=si_sigaction (sig, &new_action, &old_action);
145  si_hdl_typ retval=(si_hdl_typ)old_action.sa_handler;
146  if (r == -1)
147  {
148  fprintf(stderr, "Unable to init signal %d ... exiting...\n", sig);
149  retval=SIG_ERR;
150  }
151 #endif
152  return retval;
153 } /* si_set_signal */
if(yy_init)
Definition: libparse.cc:1420
#define si_siginterrupt(arg1, arg2)

◆ sig_pipe_hdl()

void sig_pipe_hdl ( int  )

Definition at line 67 of file cntrlc.cc.

68 {
69  if (pipeLastLink!=NULL)
70  {
73  WerrorS("pipe failed");
74  }
75 }
VAR si_link pipeLastLink
Definition: cntrlc.cc:64

◆ sig_term_hdl()

void sig_term_hdl ( int  )

Definition at line 80 of file cntrlc.cc.

81 {
82  do_shutdown = TRUE;
83  if (!defer_shutdown)
84  {
85  m2_end(1);
86  }
87 }
#define TRUE
Definition: auxiliary.h:100
VAR volatile BOOLEAN do_shutdown
Definition: cntrlc.cc:77
VAR volatile int defer_shutdown
Definition: cntrlc.cc:78
void m2_end(int i)
Definition: misc_ip.cc:1096

◆ sigint_handler()

void sigint_handler ( int  )

Definition at line 309 of file cntrlc.cc.

310 {
311  mflush();
312  #ifdef HAVE_FEREAD
314  #endif /* HAVE_FEREAD */
315  char default_opt=' ';
316  if ((feOptSpec[FE_OPT_CNTRLC].value!=NULL)
317  && ((char*)(feOptSpec[FE_OPT_CNTRLC].value))[0])
318  { default_opt=((char*)(feOptSpec[FE_OPT_CNTRLC].value))[0]; }
319  loop
320  {
321  int cnt=0;
322  int c;
323 
325  {
326  c = 'q';
327  }
328  else if (default_opt!=' ')
329  {
330  c = default_opt;
331  }
332  else
333  {
334  fprintf(stderr,"// ** Interrupt at cmd:`%s` in line:'%s'\n",
336  if (feOptValue(FE_OPT_EMACS) == NULL)
337  {
338  fputs("abort after this command(a), abort immediately(r), print backtrace(b), continue(c) or quit Singular(q) ?",stderr);
339  fflush(stderr);fflush(stdin);
340  c = fgetc(stdin);
341  }
342  else
343  {
344  c = 'a';
345  }
346  }
347 
348  switch(c)
349  {
350  case 'q': case EOF:
351  m2_end(2);
352  case 'r':
353  if (sigint_handler_cnt<3)
354  {
356  fputs("** Warning: Singular should be restarted as soon as possible **\n",stderr);
357  fflush(stderr);
358  extern void my_yy_flush();
359  my_yy_flush();
361  longjmp(si_start_jmpbuf,1);
362  }
363  else
364  {
365  fputs("** tried too often, try another possibility **\n",stderr);
366  fflush(stderr);
367  }
368  break;
369  case 'b':
370  VoiceBackTrack();
371  break;
372  case 'a':
373  siCntrlc++;
374  case 'c':
375  if ((feOptValue(FE_OPT_EMACS) == NULL) && (default_opt!=' '))
376  {
377  /* Read until a newline or EOF */
378  while (c != EOF && c != '\n') c = fgetc(stdin);
379  }
381  return;
382  //siCntrlc ++;
383  //if (siCntrlc>2) si_set_signal(SIGINT,(si_hdl_typ) sigsegv_handler);
384  //else si_set_signal(SIGINT,(si_hdl_typ) sigint_handler);
385  }
386  cnt++;
387  if(cnt>5) m2_end(2);
388  }
389 }
VAR jmp_buf si_start_jmpbuf
Definition: cntrlc.cc:95
VAR BOOLEAN singular_in_batchmode
Definition: cntrlc.cc:65
VAR int sigint_handler_cnt
Definition: cntrlc.cc:308
EXTERN_VAR struct fe_option feOptSpec[]
Definition: feOpt.h:17
VAR char my_yylinebuf[80]
Definition: febase.cc:43
VAR Voice * currentVoice
Definition: fevoices.cc:47
void VoiceBackTrack()
Definition: fevoices.cc:67
Voice * feInitStdin(Voice *pp)
Definition: fevoices.cc:655
const char * Tok2Cmdname(int tok)
Definition: gentable.cc:140
VAR int iiOp
Definition: iparith.cc:216
VAR BOOLEAN siCntrlc
Definition: options.c:14
#define mflush()
Definition: reporter.h:57
void my_yy_flush()
Definition: scanner.cc:2338
#define loop
Definition: structs.h:80

◆ sigsegv_handler()

void sigsegv_handler ( int  sig)

Definition at line 277 of file cntrlc.cc.

278 {
279  fprintf(stderr,"Singular : signal %d (v: %d):\n",
280  sig,SINGULAR_VERSION);
281  if (sig!=SIGINT)
282  {
283  fprintf(stderr,"current line:>>%s<<\n",my_yylinebuf);
284  fprintf(stderr,"Segment fault/Bus error occurred (r:%d)\n"
285  "please inform the authors\n",
286  siRandomStart);
287  }
288  #ifdef __OPTIMIZE__
289  if(si_restart<3)
290  {
291  si_restart++;
292  fputs("trying to restart...\n",stderr);
293  init_signals();
294  longjmp(si_start_jmpbuf,1);
295  }
296  #endif /* __OPTIMIZE__ */
297  #ifdef CALL_GDB
298  if (sig!=SIGINT) debug(STACK_TRACE);
299  #endif /* CALL_GDB */
300  exit(0);
301 }
static void debug(int)
Definition: cntrlc.cc:406
VAR short si_restart
Definition: cntrlc.cc:97
VAR int siRandomStart
Definition: cntrlc.cc:96
void init_signals()
init signal handlers and error handling for libraries: NTL, factory
Definition: cntrlc.cc:559
#define SINGULAR_VERSION
Definition: mod2.h:88

◆ stack_trace()

static void stack_trace ( char *const args)
static

Definition at line 461 of file cntrlc.cc.

462 {
463  int pid;
464  int in_fd[2];
465  int out_fd[2];
466  fd_set fdset;
467  fd_set readset;
468  struct timeval tv;
469  int sel, index, state;
470  char buffer[256];
471  char c;
472 
473  if ((pipe (in_fd) == -1) || (pipe (out_fd) == -1))
474  {
475  perror ("could open pipe");
476  m2_end(999);
477  }
478 
479  pid = fork ();
480  if (pid == 0)
481  {
482  si_close (0); si_dup2 (in_fd[0],0); /* set the stdin to the in pipe */
483  si_close (1); si_dup2 (out_fd[1],1); /* set the stdout to the out pipe */
484  si_close (2); si_dup2 (out_fd[1],2); /* set the stderr to the out pipe */
485 
486  execvp (args[0], args); /* exec gdb */
487  perror ("exec failed");
488  m2_end(999);
489  }
490  else if (pid == -1)
491  {
492  perror ("could not fork");
493  m2_end(999);
494  }
495 
496  FD_ZERO (&fdset);
497  FD_SET (out_fd[0], &fdset);
498 
499  si_write (in_fd[1], "backtrace\n", 10);
500  si_write (in_fd[1], "p si_stop_stack_trace_x = 0\n", 28);
501  si_write (in_fd[1], "quit\n", 5);
502 
503  index = 0;
504  state = 0;
505 
506  loop
507  {
508  readset = fdset;
509  tv.tv_sec = 1;
510  tv.tv_usec = 0;
511 
512  sel = si_select (FD_SETSIZE, &readset, NULL, NULL, &tv);
513  if (sel == -1)
514  break;
515 
516  if ((sel > 0) && (FD_ISSET (out_fd[0], &readset)))
517  {
518  if (si_read (out_fd[0], &c, 1))
519  {
520  switch (state)
521  {
522  case 0:
523  if (c == '#')
524  {
525  state = 1;
526  index = 0;
527  buffer[index++] = c;
528  }
529  break;
530  case 1:
531  buffer[index++] = c;
532  if ((c == '\n') || (c == '\r'))
533  {
534  buffer[index] = 0;
535  fputs (buffer,stderr);
536  state = 0;
537  index = 0;
538  }
539  break;
540  default:
541  break;
542  }
543  }
544  }
545  else if (si_stop_stack_trace_x==0)
546  break;
547  }
548 
549  si_close (in_fd[0]);
550  si_close (in_fd[1]);
551  si_close (out_fd[0]);
552  si_close (out_fd[1]);
553  m2_end(0);
554 }
static int index(p_Length length, p_Ord ord)
Definition: p_Procs_Impl.h:592

Variable Documentation

◆ defer_shutdown

VAR volatile int defer_shutdown = 0

Definition at line 78 of file cntrlc.cc.

◆ do_shutdown

VAR volatile BOOLEAN do_shutdown = FALSE

Definition at line 77 of file cntrlc.cc.

◆ pipeLastLink

VAR si_link pipeLastLink =NULL

Definition at line 64 of file cntrlc.cc.

◆ si_restart

VAR short si_restart =0

Definition at line 97 of file cntrlc.cc.

◆ si_start_jmpbuf

VAR jmp_buf si_start_jmpbuf

Definition at line 95 of file cntrlc.cc.

◆ si_stop_stack_trace_x

VAR volatile int si_stop_stack_trace_x

Definition at line 404 of file cntrlc.cc.

◆ sigint_handler_cnt

VAR int sigint_handler_cnt =0

Definition at line 308 of file cntrlc.cc.

◆ singular_in_batchmode

VAR BOOLEAN singular_in_batchmode =FALSE

Definition at line 65 of file cntrlc.cc.

◆ siRandomStart

VAR int siRandomStart

Definition at line 96 of file cntrlc.cc.