git.sur5r.net Git - bacula/bacula/blob - bacula/src/lib/watchdog.c

   1 /*
   2  * Bacula thread watchdog routine. General routine that monitors
   3  *  the daemon and signals a thread if it is blocked on a BSOCK
   4  *  too long. This prevents catastropic long waits -- generally
   5  *  due to Windows "hanging" the app.
   6  *
   7  *  Kern Sibbald, January MMII
   8  *
   9  */
  10 /*
  11    Copyright (C) 2000-2003 Kern Sibbald and John Walker
  12
  13    This program is free software; you can redistribute it and/or
  14    modify it under the terms of the GNU General Public License as
  15    published by the Free Software Foundation; either version 2 of
  16    the License, or (at your option) any later version.
  17
  18    This program is distributed in the hope that it will be useful,
  19    but WITHOUT ANY WARRANTY; without even the implied warranty of
  20    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  21    General Public License for more details.
  22
  23    You should have received a copy of the GNU General Public
  24    License along with this program; if not, write to the Free
  25    Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  26    MA 02111-1307, USA.
  27
  28  */
  29
  30 #include "bacula.h"
  31 #include "jcr.h"
  32
  33 /* Exported globals */
  34 time_t watchdog_time;                 /* this has granularity of SLEEP_TIME */
  35
  36 #define SLEEP_TIME 1                  /* examine things every second */
  37
  38 /* Forward referenced functions */
  39 static void *watchdog_thread(void *arg);
  40
  41 /* Static globals */
  42 static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
  43 static pthread_cond_t  timer = PTHREAD_COND_INITIALIZER;
  44 static bool quit;
  45 static bool wd_is_init = false;
  46
  47 /* Forward referenced callback functions */
  48 static pthread_t wd_tid;
  49
  50 /* Static globals */
  51 static dlist *wd_queue;
  52 static dlist *wd_inactive;
  53
  54 /*
  55  * Start watchdog thread
  56  *
  57  *  Returns: 0 on success
  58  *           errno on failure
  59  */
  60 int start_watchdog(void)
  61 {
  62    int stat;
  63    watchdog_t *dummy = NULL;
  64
  65    if (wd_is_init) {
  66       return 0;
  67    }
  68    Dmsg0(200, "Initialising NicB-hacked watchdog thread\n");
  69    watchdog_time = time(NULL);
  70    quit = false;
  71
  72    wd_queue = new dlist(wd_queue, &dummy->link);
  73    wd_inactive = new dlist(wd_inactive, &dummy->link);
  74
  75    if ((stat = pthread_create(&wd_tid, NULL, watchdog_thread, NULL)) != 0) {
  76       return stat;
  77    }
  78    wd_is_init = true;
  79    return 0;
  80 }
  81
  82 /*
  83  * Terminate the watchdog thread
  84  *
  85  * Returns: 0 on success
  86  *          errno on failure
  87  */
  88 int stop_watchdog(void)
  89 {
  90    int stat;
  91    watchdog_t *p;
  92
  93    if (!wd_is_init) {
  94       return 0;
  95    }
  96
  97    Dmsg0(200, "Sending stop signal to NicB-hacked watchdog thread\n");
  98    P(mutex);
  99    quit = true;
 100    stat = pthread_cond_signal(&timer);
 101    V(mutex);
 102
 103    wd_is_init = false;
 104
 105    stat = pthread_join(wd_tid, NULL);
 106
 107    foreach_dlist(p, wd_queue) {
 108       if (p->destructor != NULL) {
 109          p->destructor(p);
 110       }
 111       free(p);
 112    }
 113    delete wd_queue;
 114    wd_queue = NULL;
 115
 116    foreach_dlist(p, wd_inactive) {
 117       if (p->destructor != NULL) {
 118          p->destructor(p);
 119       }
 120       free(p);
 121    }
 122    delete wd_inactive;
 123    wd_inactive = NULL;
 124
 125    return stat;
 126 }
 127
 128 watchdog_t *watchdog_new(void)
 129 {
 130    watchdog_t *wd = (watchdog_t *) malloc(sizeof(watchdog_t));
 131
 132    if (!wd_is_init) {
 133       Emsg0(M_ABORT, 0, "BUG! watchdog_new called before start_watchdog\n");
 134    }
 135
 136    if (wd == NULL) {
 137       return NULL;
 138    }
 139    wd->one_shot = true;
 140    wd->interval = 0;
 141    wd->callback = NULL;
 142    wd->destructor = NULL;
 143    wd->data = NULL;
 144
 145    return wd;
 146 }
 147
 148 bool register_watchdog(watchdog_t *wd)
 149 {
 150    if (!wd_is_init) {
 151       Emsg0(M_ABORT, 0, "BUG! register_watchdog called before start_watchdog\n");
 152    }
 153    if (wd->callback == NULL) {
 154       Emsg1(M_ABORT, 0, "BUG! Watchdog %p has NULL callback\n", wd);
 155    }
 156    if (wd->interval == 0) {
 157       Emsg1(M_ABORT, 0, "BUG! Watchdog %p has zero interval\n", wd);
 158    }
 159
 160    P(mutex);
 161    wd->next_fire = watchdog_time + wd->interval;
 162    wd_queue->append(wd);
 163    Dmsg3(200, "Registered watchdog %p, interval %d%s\n",
 164          wd, wd->interval, wd->one_shot ? " one shot" : "");
 165    V(mutex);
 166
 167    return false;
 168 }
 169
 170 bool unregister_watchdog_unlocked(watchdog_t *wd)
 171 {
 172    watchdog_t *p;
 173
 174    if (!wd_is_init) {
 175       Emsg0(M_ABORT, 0, "BUG! unregister_watchdog_unlocked called before start_watchdog\n");
 176    }
 177
 178    foreach_dlist(p, wd_queue) {
 179       if (wd == p) {
 180          wd_queue->remove(wd);
 181          Dmsg1(200, "Unregistered watchdog %p\n", wd);
 182          return true;
 183       }
 184    }
 185
 186    foreach_dlist(p, wd_inactive) {
 187       if (wd == p) {
 188          wd_inactive->remove(wd);
 189          Dmsg1(200, "Unregistered inactive watchdog %p\n", wd);
 190          return true;
 191       }
 192    }
 193
 194    Dmsg1(200, "Failed to unregister watchdog %p\n", wd);
 195    return false;
 196 }
 197
 198 bool unregister_watchdog(watchdog_t *wd)
 199 {
 200    bool ret;
 201
 202    if (!wd_is_init) {
 203       Emsg0(M_ABORT, 0, "BUG! unregister_watchdog called before start_watchdog\n");
 204    }
 205
 206    P(mutex);
 207    ret = unregister_watchdog_unlocked(wd);
 208    V(mutex);
 209
 210    return ret;
 211 }
 212
 213 static void *watchdog_thread(void *arg)
 214 {
 215    Dmsg0(200, "NicB-reworked watchdog thread entered\n");
 216
 217    while (true) {
 218       watchdog_t *p;
 219
 220       P(mutex);
 221       if (quit) {
 222          V(mutex);
 223          break;
 224       }
 225
 226       watchdog_time = time(NULL);
 227
 228       foreach_dlist(p, wd_queue) {
 229          if (p->next_fire < watchdog_time) {
 230             /* Run the callback */
 231             p->callback(p);
 232
 233             /* Reschedule (or move to inactive list if it's a one-shot timer) */
 234             if (p->one_shot) {
 235                wd_queue->remove(p);
 236                wd_inactive->append(p);
 237             } else {
 238                p->next_fire = watchdog_time + p->interval;
 239             }
 240          }
 241       }
 242       V(mutex);
 243       bmicrosleep(SLEEP_TIME, 0);
 244    }
 245
 246    Dmsg0(200, "NicB-reworked watchdog thread exited\n");
 247    return NULL;
 248 }