Changeset 47128d9

Timestamp:

May 23, 2011, 8:57:46 PM (14 years ago)

Author:

David Benjamin <davidben@mit.edu>

Branches:

master, release-1.10, release-1.8, release-1.9

Children:

6bd485e

Parents:

1491439

git-author:

David Benjamin <davidben@mit.edu> (02/26/11 14:38:04)

git-committer:

David Benjamin <davidben@mit.edu> (05/23/11 20:57:46)

Message:

Allow interrupts to be taken at any point

This way we can catch SIGINT in the middle of a search if we care.
(Though ideally we wouldn't block the event loop when searching like
this.)

Files:

• functions.c (modified) (3 diffs)
• global.c (modified) (2 diffs)
• owl.c (modified) (2 diffs)
• owl.h (modified) (1 diff)

functions.c

@@ -2995 +2995 @@
       i--;
     }
-#if 0
-    /* FIXME!!! */
-    owl_function_mask_sigint(NULL);
-    if(owl_global_is_interrupted(&g)) {
-      owl_global_unset_interrupted(&g);
-      owl_function_unmask_sigint(NULL);
+    if (owl_global_take_interrupt(&g)) {
       owl_function_makemsg("Search interrupted!");
       owl_mainwin_redisplay(owl_global_get_mainwin(&g));
       return;
     }
-    owl_function_unmask_sigint(NULL);
-#endif
   }
   owl_mainwin_redisplay(owl_global_get_mainwin(&g));
@@ -3089 +3082 @@
           ret=ZLocateUser(zstr(user), &numlocs, ZAUTH);
 
-#if 0
-          /* FIXME!! */
-          owl_function_mask_sigint(NULL);
-          if(owl_global_is_interrupted(&g)) {
+          if (owl_global_take_interrupt(&g)) {
             interrupted = 1;
-            owl_global_unset_interrupted(&g);
-            owl_function_unmask_sigint(NULL);
             owl_function_makemsg("Interrupted!");
             break;
           }
-
-          owl_function_unmask_sigint(NULL);
-#endif
 
           if (ret!=ZERR_NONE) {
@@ -3506 +3491 @@
 }
 
-void owl_function_mask_sigint(sigset_t *oldmask) {
-  sigset_t intr;
-
-  sigemptyset(&intr);
-  sigaddset(&intr, SIGINT);
-  sigprocmask(SIG_BLOCK, &intr, oldmask);
-}
-
-void owl_function_unmask_sigint(sigset_t *oldmask) {
-  sigset_t intr;
-
-  sigemptyset(&intr);
-  sigaddset(&intr, SIGINT);
-  sigprocmask(SIG_UNBLOCK, &intr, oldmask);
-}
-
 void _owl_function_mark_message(const owl_message *m)
 {

global.c

@@ -112 +112 @@
   g->timerlist = NULL;
   g->kill_buffer = NULL;
+
+  g->interrupt_count = 0;
+  g->interrupt_lock = g_mutex_new();
 }
 
@@ -924 +927 @@
   g->kill_buffer = g_strndup(kill, len);
 }
+
+void owl_global_add_interrupt(owl_global *g) {
+  /* TODO: This can almost certainly be done with atomic
+   * operations. Whatever. */
+  g_mutex_lock(g->interrupt_lock);
+  g->interrupt_count++;
+  g_mutex_unlock(g->interrupt_lock);
+}
+
+bool owl_global_take_interrupt(owl_global *g) {
+  bool ans = false;
+  g_mutex_lock(g->interrupt_lock);
+  if (g->interrupt_count > 0) {
+    ans = true;
+    g->interrupt_count--;
+  }
+  g_mutex_unlock(g->interrupt_lock);
+  return ans;
+}

owl.c

@@ -362 +362 @@
   } else if (sig == SIGTERM || sig == SIGHUP) {
     owl_function_quit();
-  } else if (sig == SIGINT) {
+  } else if (sig == SIGINT && owl_global_take_interrupt(&g)) {
     owl_input in;
     in.ch = in.uch = owl_global_get_startup_tio(&g)->c_cc[VINTR];
@@ -374 +374 @@
   GSource *source;
 
-  /* TODO: Special-case SIGINT so that it can interrupt outside the
-   * event loop. */
-
+  /* If it was an interrupt, set a flag so we can handle it earlier if
+   * needbe. sig_handler_main_thread will check the flag to make sure
+   * no one else took it. */
+  if (sig == SIGINT) {
+    owl_global_add_interrupt(&g);
+  }
   /* Send a message to the main thread. */
   source = g_idle_source_new();

owl.h

@@ -630 +630 @@
   FILE *debug_file;
   char *kill_buffer;
+  int interrupt_count;
+  GMutex *interrupt_lock;
 } owl_global;