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

   1 /*
   2  * Manipulation routines for Job Control Records and
   3  *  handling of last_jobs_list.
   4  *
   5  *  Kern E. Sibbald, December 2000
   6  *
   7  *  Version $Id$
   8  *
   9  *  These routines are thread safe.
  10  *
  11  *  The job list routines were re-written in May 2005 to
  12  *  eliminate the global lock while traversing the list, and
  13  *  to use the dlist subroutines.  The locking is now done
  14  *  on the list each time the list is modified or traversed.
  15  *  That is it is "micro-locked" rather than globally locked.
  16  *  The result is that there is one lock/unlock for each entry
  17  *  in the list while traversing it rather than a single lock
  18  *  at the beginning of a traversal and one at the end.  This
  19  *  incurs slightly more overhead, but effectively eliminates
  20  *  the possibilty of race conditions.  In addition, with the
  21  *  exception of the global locking of the list during the
  22  *  re-reading of the config file, no recursion is needed.
  23  *
  24  */
  25 /*
  26    Copyright (C) 2000-2006 Kern Sibbald
  27
  28    This program is free software; you can redistribute it and/or
  29    modify it under the terms of the GNU General Public License
  30    version 2 as amended with additional clauses defined in the
  31    file LICENSE in the main source directory.
  32
  33    This program is distributed in the hope that it will be useful,
  34    but WITHOUT ANY WARRANTY; without even the implied warranty of
  35    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  36    the file LICENSE for additional details.
  37
  38  */
  39
  40 #include "bacula.h"
  41 #include "jcr.h"
  42
  43 /* External variables we reference */
  44 extern time_t watchdog_time;
  45
  46 /* Forward referenced functions */
  47 extern "C" void timeout_handler(int sig);
  48 static void jcr_timeout_check(watchdog_t *self);
  49 #ifdef TRACE_JCR_CHAIN
  50 static void b_lock_jcr_chain(const char *filen, int line);
  51 static void b_unlock_jcr_chain(const char *filen, int line);
  52 #define lock_jcr_chain() b_lock_jcr_chain(__FILE__, __LINE__);
  53 #define unlock_jcr_chain() b_unlock_jcr_chain(__FILE__, __LINE__);
  54 #else
  55 static void lock_jcr_chain();
  56 static void unlock_jcr_chain();
  57 #endif
  58
  59
  60 int num_jobs_run;
  61 dlist *last_jobs = NULL;
  62 const int max_last_jobs = 10;
  63
  64 static dlist *jcrs = NULL;            /* JCR chain */
  65 static pthread_mutex_t jcr_lock = PTHREAD_MUTEX_INITIALIZER;
  66
  67 static pthread_mutex_t job_start_mutex = PTHREAD_MUTEX_INITIALIZER;
  68
  69 static pthread_mutex_t last_jobs_mutex = PTHREAD_MUTEX_INITIALIZER;
  70
  71
  72 void lock_jobs()
  73 {
  74    P(job_start_mutex);
  75 }
  76
  77 void unlock_jobs()
  78 {
  79    V(job_start_mutex);
  80 }
  81
  82 void init_last_jobs_list()
  83 {
  84    JCR *jcr = NULL;
  85    struct s_last_job *job_entry = NULL;
  86    if (!last_jobs) {
  87       last_jobs = New(dlist(job_entry, &job_entry->link));
  88    }
  89    if (!jcrs) {
  90       jcrs = New(dlist(jcr, &jcr->link));
  91    }
  92 }
  93
  94 void term_last_jobs_list()
  95 {
  96    if (last_jobs) {
  97       while (!last_jobs->empty()) {
  98          void *je = last_jobs->first();
  99          last_jobs->remove(je);
 100          free(je);
 101       }
 102       delete last_jobs;
 103       last_jobs = NULL;
 104    }
 105    if (jcrs) {
 106       delete jcrs;
 107       jcrs = NULL;
 108    }
 109 }
 110
 111 bool read_last_jobs_list(int fd, uint64_t addr)
 112 {
 113    struct s_last_job *je, job;
 114    uint32_t num;
 115
 116    Dmsg1(100, "read_last_jobs seek to %d\n", (int)addr);
 117    if (addr == 0 || lseek(fd, (off_t)addr, SEEK_SET) < 0) {
 118       return false;
 119    }
 120    if (read(fd, &num, sizeof(num)) != sizeof(num)) {
 121       return false;
 122    }
 123    Dmsg1(100, "Read num_items=%d\n", num);
 124    if (num > 4 * max_last_jobs) {  /* sanity check */
 125       return false;
 126    }
 127    for ( ; num; num--) {
 128       if (read(fd, &job, sizeof(job)) != sizeof(job)) {
 129          Dmsg1(000, "Read job entry. ERR=%s\n", strerror(errno));
 130          return false;
 131       }
 132       if (job.JobId > 0) {
 133          je = (struct s_last_job *)malloc(sizeof(struct s_last_job));
 134          memcpy((char *)je, (char *)&job, sizeof(job));
 135          if (!last_jobs) {
 136             init_last_jobs_list();
 137          }
 138          last_jobs->append(je);
 139          if (last_jobs->size() > max_last_jobs) {
 140             je = (struct s_last_job *)last_jobs->first();
 141             last_jobs->remove(je);
 142             free(je);
 143          }
 144       }
 145    }
 146    return true;
 147 }
 148
 149 uint64_t write_last_jobs_list(int fd, uint64_t addr)
 150 {
 151    struct s_last_job *je;
 152    uint32_t num;
 153
 154    Dmsg1(100, "write_last_jobs seek to %d\n", (int)addr);
 155    if (lseek(fd, (off_t)addr, SEEK_SET) < 0) {
 156       return 0;
 157    }
 158    if (last_jobs) {
 159       /* First record is number of entires */
 160       num = last_jobs->size();
 161       if (write(fd, &num, sizeof(num)) != sizeof(num)) {
 162          Dmsg1(000, "Error writing num_items: ERR=%s\n", strerror(errno));
 163          return 0;
 164       }
 165       foreach_dlist(je, last_jobs) {
 166          if (write(fd, je, sizeof(struct s_last_job)) != sizeof(struct s_last_job)) {
 167             Dmsg1(000, "Error writing job: ERR=%s\n", strerror(errno));
 168             return 0;
 169          }
 170       }
 171    }
 172    /* Return current address */
 173    ssize_t stat = lseek(fd, 0, SEEK_CUR);
 174    if (stat < 0) {
 175       stat = 0;
 176    }
 177    return stat;
 178
 179 }
 180
 181 void lock_last_jobs_list()
 182 {
 183    P(last_jobs_mutex);
 184 }
 185
 186 void unlock_last_jobs_list()
 187 {
 188    V(last_jobs_mutex);
 189 }
 190
 191 /*
 192  * Push a subroutine address into the job end callback stack
 193  */
 194 void job_end_push(JCR *jcr, void job_end_cb(JCR *jcr,void *), void *ctx)
 195 {
 196    jcr->job_end_push.append((void *)job_end_cb);
 197    jcr->job_end_push.append(ctx);
 198 }
 199
 200 /* Pop each job_end subroutine and call it */
 201 static void job_end_pop(JCR *jcr)
 202 {
 203    void (*job_end_cb)(JCR *jcr, void *ctx);
 204    void *ctx;
 205    for (int i=jcr->job_end_push.size()-1; i > 0; ) {
 206       ctx = jcr->job_end_push.get(i--);
 207       job_end_cb = (void (*)(JCR *,void *))jcr->job_end_push.get(i--);
 208       job_end_cb(jcr, ctx);
 209    }
 210 }
 211
 212 /*
 213  * Create a Job Control Record and link it into JCR chain
 214  * Returns newly allocated JCR
 215  * Note, since each daemon has a different JCR, he passes
 216  *  us the size.
 217  */
 218 JCR *new_jcr(int size, JCR_free_HANDLER *daemon_free_jcr)
 219 {
 220    JCR *jcr;
 221    MQUEUE_ITEM *item = NULL;
 222    struct sigaction sigtimer;
 223
 224    Dmsg0(3400, "Enter new_jcr\n");
 225    jcr = (JCR *)malloc(size);
 226    memset(jcr, 0, size);
 227    jcr->my_thread_id = pthread_self();
 228    jcr->msg_queue = New(dlist(item, &item->link));
 229    jcr->job_end_push.init(1, false);
 230    jcr->sched_time = time(NULL);
 231    jcr->daemon_free_jcr = daemon_free_jcr;    /* plug daemon free routine */
 232    jcr->init_mutex();
 233    jcr->inc_use_count();
 234    jcr->VolumeName = get_pool_memory(PM_FNAME);
 235    jcr->VolumeName[0] = 0;
 236    jcr->errmsg = get_pool_memory(PM_MESSAGE);
 237    jcr->errmsg[0] = 0;
 238    /* Setup some dummy values */
 239    bstrncpy(jcr->Job, "*System*", sizeof(jcr->Job));
 240    jcr->JobId = 0;
 241    jcr->JobType = JT_SYSTEM;          /* internal job until defined */
 242    jcr->JobLevel = L_NONE;
 243    set_jcr_job_status(jcr, JS_Created);       /* ready to run */
 244
 245    sigtimer.sa_flags = 0;
 246    sigtimer.sa_handler = timeout_handler;
 247    sigfillset(&sigtimer.sa_mask);
 248    sigaction(TIMEOUT_SIGNAL, &sigtimer, NULL);
 249
 250    /*
 251     * Locking jobs is a global lock that is needed
 252     * so that the Director can stop new jobs from being
 253     * added to the jcr chain while it processes a new
 254     * conf file and does the job_end_push().
 255     */
 256    lock_jobs();
 257    lock_jcr_chain();
 258    if (!jcrs) {
 259       jcrs = New(dlist(jcr, &jcr->link));
 260    }
 261    jcrs->append(jcr);
 262    unlock_jcr_chain();
 263    unlock_jobs();
 264
 265    return jcr;
 266 }
 267
 268
 269 /*
 270  * Remove a JCR from the chain
 271  * NOTE! The chain must be locked prior to calling
 272  *       this routine.
 273  */
 274 static void remove_jcr(JCR *jcr)
 275 {
 276    Dmsg0(3400, "Enter remove_jcr\n");
 277    if (!jcr) {
 278       Emsg0(M_ABORT, 0, _("NULL jcr.\n"));
 279    }
 280    jcrs->remove(jcr);
 281    Dmsg0(3400, "Leave remove_jcr\n");
 282 }
 283
 284 /*
 285  * Free stuff common to all JCRs.  N.B. Be careful to include only
 286  *  generic stuff in the common part of the jcr.
 287  */
 288 static void free_common_jcr(JCR *jcr)
 289 {
 290    struct s_last_job *je, last_job;
 291
 292    /* Keep some statistics */
 293    switch (jcr->JobType) {
 294    case JT_BACKUP:
 295    case JT_VERIFY:
 296    case JT_RESTORE:
 297    case JT_MIGRATE:
 298    case JT_COPY:
 299    case JT_ADMIN:
 300       num_jobs_run++;
 301       last_job.Errors = jcr->Errors;
 302       last_job.JobType = jcr->JobType;
 303       last_job.JobId = jcr->JobId;
 304       last_job.VolSessionId = jcr->VolSessionId;
 305       last_job.VolSessionTime = jcr->VolSessionTime;
 306       bstrncpy(last_job.Job, jcr->Job, sizeof(last_job.Job));
 307       last_job.JobFiles = jcr->JobFiles;
 308       last_job.JobBytes = jcr->JobBytes;
 309       last_job.JobStatus = jcr->JobStatus;
 310       last_job.JobLevel = jcr->JobLevel;
 311       last_job.start_time = jcr->start_time;
 312       last_job.end_time = time(NULL);
 313       /* Keep list of last jobs, but not Console where JobId==0 */
 314       if (last_job.JobId > 0) {
 315          je = (struct s_last_job *)malloc(sizeof(struct s_last_job));
 316          memcpy((char *)je, (char *)&last_job, sizeof(last_job));
 317          if (!last_jobs) {
 318             init_last_jobs_list();
 319          }
 320          last_jobs->append(je);
 321          if (last_jobs->size() > max_last_jobs) {
 322             je = (struct s_last_job *)last_jobs->first();
 323             last_jobs->remove(je);
 324             free(je);
 325          }
 326       }
 327       break;
 328    default:
 329       break;
 330    }
 331    jcr->destroy_mutex();
 332
 333    delete jcr->msg_queue;
 334    close_msg(jcr);                    /* close messages for this job */
 335
 336    /* do this after closing messages */
 337    if (jcr->client_name) {
 338       free_pool_memory(jcr->client_name);
 339       jcr->client_name = NULL;
 340    }
 341
 342    if (jcr->attr) {
 343       free_pool_memory(jcr->attr);
 344       jcr->attr = NULL;
 345    }
 346
 347    if (jcr->sd_auth_key) {
 348       free(jcr->sd_auth_key);
 349       jcr->sd_auth_key = NULL;
 350    }
 351    if (jcr->VolumeName) {
 352       free_pool_memory(jcr->VolumeName);
 353       jcr->VolumeName = NULL;
 354    }
 355
 356    if (jcr->dir_bsock) {
 357       bnet_close(jcr->dir_bsock);
 358       jcr->dir_bsock = NULL;
 359    }
 360    if (jcr->errmsg) {
 361       free_pool_memory(jcr->errmsg);
 362       jcr->errmsg = NULL;
 363    }
 364    if (jcr->where) {
 365       free(jcr->where);
 366       jcr->where = NULL;
 367    }
 368    if (jcr->cached_path) {
 369       free_pool_memory(jcr->cached_path);
 370       jcr->cached_path = NULL;
 371       jcr->cached_pnl = 0;
 372    }
 373    free_getuser_cache();
 374    free_getgroup_cache();
 375    free(jcr);
 376 }
 377
 378 /*
 379  * Global routine to free a jcr
 380  */
 381 #ifdef DEBUG
 382 void b_free_jcr(const char *file, int line, JCR *jcr)
 383 {
 384    Dmsg3(3400, "Enter free_jcr 0x%x from %s:%d\n", jcr, file, line);
 385
 386 #else
 387
 388 void free_jcr(JCR *jcr)
 389 {
 390
 391    Dmsg2(3400, "Enter free_jcr 0x%x job=%d\n", jcr, jcr->JobId);
 392
 393 #endif
 394
 395    dequeue_messages(jcr);
 396    lock_jcr_chain();
 397    jcr->dec_use_count();              /* decrement use count */
 398    if (jcr->use_count() < 0) {
 399       Emsg2(M_ERROR, 0, _("JCR use_count=%d JobId=%d\n"),
 400          jcr->use_count(), jcr->JobId);
 401    }
 402    Dmsg3(3400, "Dec free_jcr 0x%x use_count=%d jobid=%d\n", jcr, jcr->use_count(), jcr->JobId);
 403    if (jcr->use_count() > 0) {          /* if in use */
 404       unlock_jcr_chain();
 405       Dmsg3(3400, "free_jcr 0x%x job=%d use_count=%d\n", jcr, jcr->JobId, jcr->use_count());
 406       return;
 407    }
 408
 409    remove_jcr(jcr);                   /* remove Jcr from chain */
 410    unlock_jcr_chain();
 411
 412    job_end_pop(jcr);                  /* pop and call hooked routines */
 413
 414    Dmsg1(3400, "End job=%d\n", jcr->JobId);
 415    if (jcr->daemon_free_jcr) {
 416       jcr->daemon_free_jcr(jcr);      /* call daemon free routine */
 417    }
 418    free_common_jcr(jcr);
 419    close_msg(NULL);                   /* flush any daemon messages */
 420    garbage_collect_memory_pool();
 421    Dmsg0(3400, "Exit free_jcr\n");
 422 }
 423
 424
 425 /*
 426  * Given a JobId, find the JCR
 427  *   Returns: jcr on success
 428  *            NULL on failure
 429  */
 430 JCR *get_jcr_by_id(uint32_t JobId)
 431 {
 432    JCR *jcr;
 433
 434    foreach_jcr(jcr) {
 435       if (jcr->JobId == JobId) {
 436          jcr->inc_use_count();
 437          Dmsg2(3400, "Inc get_jcr 0x%x use_count=%d\n", jcr, jcr->use_count());
 438          break;
 439       }
 440    }
 441    endeach_jcr(jcr);
 442    return jcr;
 443 }
 444
 445 /*
 446  * Given a SessionId and SessionTime, find the JCR
 447  *   Returns: jcr on success
 448  *            NULL on failure
 449  */
 450 JCR *get_jcr_by_session(uint32_t SessionId, uint32_t SessionTime)
 451 {
 452    JCR *jcr;
 453
 454    foreach_jcr(jcr) {
 455       if (jcr->VolSessionId == SessionId &&
 456           jcr->VolSessionTime == SessionTime) {
 457          jcr->inc_use_count();
 458          Dmsg2(3400, "Inc get_jcr 0x%x use_count=%d\n", jcr, jcr->use_count());
 459          break;
 460       }
 461    }
 462    endeach_jcr(jcr);
 463    return jcr;
 464 }
 465
 466
 467 /*
 468  * Given a Job, find the JCR
 469  *  compares on the number of characters in Job
 470  *  thus allowing partial matches.
 471  *   Returns: jcr on success
 472  *            NULL on failure
 473  */
 474 JCR *get_jcr_by_partial_name(char *Job)
 475 {
 476    JCR *jcr;
 477    int len;
 478
 479    if (!Job) {
 480       return NULL;
 481    }
 482    len = strlen(Job);
 483    foreach_jcr(jcr) {
 484       if (strncmp(Job, jcr->Job, len) == 0) {
 485          jcr->inc_use_count();
 486          Dmsg2(3400, "Inc get_jcr 0x%x use_count=%d\n", jcr, jcr->use_count());
 487          break;
 488       }
 489    }
 490    endeach_jcr(jcr);
 491    return jcr;
 492 }
 493
 494
 495 /*
 496  * Given a Job, find the JCR
 497  *  requires an exact match of names.
 498  *   Returns: jcr on success
 499  *            NULL on failure
 500  */
 501 JCR *get_jcr_by_full_name(char *Job)
 502 {
 503    JCR *jcr;
 504
 505    if (!Job) {
 506       return NULL;
 507    }
 508    foreach_jcr(jcr) {
 509       if (strcmp(jcr->Job, Job) == 0) {
 510          jcr->inc_use_count();
 511          Dmsg2(3400, "Inc get_jcr 0x%x use_count=%d\n", jcr, jcr->use_count());
 512          break;
 513       }
 514    }
 515    endeach_jcr(jcr);
 516    return jcr;
 517 }
 518
 519 void set_jcr_job_status(JCR *jcr, int JobStatus)
 520 {
 521    /*
 522     * For a set of errors, ... keep the current status
 523     *   so it isn't lost. For all others, set it.
 524     */
 525    switch (jcr->JobStatus) {
 526    case JS_ErrorTerminated:
 527    case JS_Error:
 528    case JS_FatalError:
 529    case JS_Differences:
 530    case JS_Canceled:
 531       break;
 532    default:
 533       jcr->JobStatus = JobStatus;
 534    }
 535 }
 536
 537 #ifdef TRACE_JCR_CHAIN
 538 static int lock_count = 0;
 539 #endif
 540
 541 /*
 542  * Lock the chain
 543  */
 544 #ifdef TRACE_JCR_CHAIN
 545 static void b_lock_jcr_chain(const char *fname, int line)
 546 #else
 547 static void lock_jcr_chain()
 548 #endif
 549 {
 550 #ifdef TRACE_JCR_CHAIN
 551    Dmsg3(3400, "Lock jcr chain %d from %s:%d\n", ++lock_count,
 552       fname, line);
 553 #endif
 554    P(jcr_lock);
 555 }
 556
 557 /*
 558  * Unlock the chain
 559  */
 560 #ifdef TRACE_JCR_CHAIN
 561 static void b_unlock_jcr_chain(const char *fname, int line)
 562 #else
 563 static void unlock_jcr_chain()
 564 #endif
 565 {
 566 #ifdef TRACE_JCR_CHAIN
 567    Dmsg3(3400, "Unlock jcr chain %d from %s:%d\n", lock_count--,
 568       fname, line);
 569 #endif
 570    V(jcr_lock);
 571 }
 572
 573
 574 /*
 575  * Start walk of jcr chain
 576  * The proper way to walk the jcr chain is:
 577  *    JCR *jcr;
 578  *    foreach_jcr(jcr) {
 579  *      ...
 580  *    }
 581  *    endeach_jcr(jcr);
 582  *
 583  *  It is possible to leave out the endeach_jcr(jcr), but
 584  *   in that case, the last jcr referenced must be explicitly
 585  *   released with:
 586  *
 587  *    free_jcr(jcr);
 588  *
 589  */
 590 JCR *jcr_walk_start()
 591 {
 592    JCR *jcr;
 593    lock_jcr_chain();
 594    jcr = (JCR *)jcrs->first();
 595    if (jcr) {
 596       jcr->inc_use_count();
 597       Dmsg3(3400, "Inc jcr_walk_start 0x%x job=%d use_count=%d\n", jcr,
 598             jcr->JobId, jcr->use_count());
 599    }
 600    unlock_jcr_chain();
 601    return jcr;
 602 }
 603
 604 /*
 605  * Get next jcr from chain, and release current one
 606  */
 607 JCR *jcr_walk_next(JCR *prev_jcr)
 608 {
 609    JCR *jcr;
 610
 611    lock_jcr_chain();
 612    jcr = (JCR *)jcrs->next(prev_jcr);
 613    if (jcr) {
 614       jcr->inc_use_count();
 615       Dmsg3(3400, "Inc jcr_walk_next 0x%x job=%d use_count=%d\n", jcr,
 616          jcr->JobId, jcr->use_count());
 617    }
 618    unlock_jcr_chain();
 619    if (prev_jcr) {
 620       free_jcr(prev_jcr);
 621    }
 622    return jcr;
 623 }
 624
 625 /*
 626  * Release last jcr referenced
 627  */
 628 void jcr_walk_end(JCR *jcr)
 629 {
 630    if (jcr) {
 631       free_jcr(jcr);
 632    }
 633 }
 634
 635
 636 /*
 637  * Setup to call the timeout check routine every 30 seconds
 638  *  This routine will check any timers that have been enabled.
 639  */
 640 bool init_jcr_subsystem(void)
 641 {
 642    watchdog_t *wd = new_watchdog();
 643
 644    wd->one_shot = false;
 645    wd->interval = 30;   /* FIXME: should be configurable somewhere, even
 646                          if only with a #define */
 647    wd->callback = jcr_timeout_check;
 648
 649    register_watchdog(wd);
 650
 651    return true;
 652 }
 653
 654 static void jcr_timeout_check(watchdog_t *self)
 655 {
 656    JCR *jcr;
 657    BSOCK *fd;
 658    time_t timer_start;
 659
 660    Dmsg0(3400, "Start JCR timeout checks\n");
 661
 662    /* Walk through all JCRs checking if any one is
 663     * blocked for more than specified max time.
 664     */
 665    foreach_jcr(jcr) {
 666       Dmsg2(3400, "jcr_timeout_check JobId=%u jcr=0x%x\n", jcr->JobId, jcr);
 667       if (jcr->JobId == 0) {
 668          continue;
 669       }
 670       fd = jcr->store_bsock;
 671       if (fd) {
 672          timer_start = fd->timer_start;
 673          if (timer_start && (watchdog_time - timer_start) > fd->timeout) {
 674             fd->timer_start = 0;      /* turn off timer */
 675             fd->timed_out = true;
 676             Jmsg(jcr, M_ERROR, 0, _(
 677 "Watchdog sending kill after %d secs to thread stalled reading Storage daemon.\n"),
 678                  watchdog_time - timer_start);
 679             pthread_kill(jcr->my_thread_id, TIMEOUT_SIGNAL);
 680          }
 681       }
 682       fd = jcr->file_bsock;
 683       if (fd) {
 684          timer_start = fd->timer_start;
 685          if (timer_start && (watchdog_time - timer_start) > fd->timeout) {
 686             fd->timer_start = 0;      /* turn off timer */
 687             fd->timed_out = true;
 688             Jmsg(jcr, M_ERROR, 0, _(
 689 "Watchdog sending kill after %d secs to thread stalled reading File daemon.\n"),
 690                  watchdog_time - timer_start);
 691             pthread_kill(jcr->my_thread_id, TIMEOUT_SIGNAL);
 692          }
 693       }
 694       fd = jcr->dir_bsock;
 695       if (fd) {
 696          timer_start = fd->timer_start;
 697          if (timer_start && (watchdog_time - timer_start) > fd->timeout) {
 698             fd->timer_start = 0;      /* turn off timer */
 699             fd->timed_out = true;
 700             Jmsg(jcr, M_ERROR, 0, _(
 701 "Watchdog sending kill after %d secs to thread stalled reading Director.\n"),
 702                  watchdog_time - timer_start);
 703             pthread_kill(jcr->my_thread_id, TIMEOUT_SIGNAL);
 704          }
 705       }
 706    }
 707    endeach_jcr(jcr);
 708
 709    Dmsg0(3400, "Finished JCR timeout checks\n");
 710 }
 711
 712 /*
 713  * Timeout signal comes here
 714  */
 715 extern "C" void timeout_handler(int sig)
 716 {
 717    return;                            /* thus interrupting the function */
 718 }