git.sur5r.net Git - bacula/bacula/blob - bacula/src/stored/stored.c

   1 /*
   2    Bacula® - The Network Backup Solution
   3
   4    Copyright (C) 2000-2007 Free Software Foundation Europe e.V.
   5
   6    The main author of Bacula is Kern Sibbald, with contributions from
   7    many others, a complete list can be found in the file AUTHORS.
   8    This program is Free Software; you can redistribute it and/or
   9    modify it under the terms of version two of the GNU General Public
  10    License as published by the Free Software Foundation and included
  11    in the file LICENSE.
  12
  13    This program is distributed in the hope that it will be useful, but
  14    WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16    General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  21    02110-1301, USA.
  22
  23    Bacula® is a registered trademark of John Walker.
  24    The licensor of Bacula is the Free Software Foundation Europe
  25    (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich,
  26    Switzerland, email:ftf@fsfeurope.org.
  27 */
  28 /*
  29  * Second generation Storage daemon.
  30  *
  31  *  Kern Sibbald, MM
  32  *
  33  * It accepts a number of simple commands from the File daemon
  34  * and acts on them. When a request to append data is made,
  35  * it opens a data channel and accepts data from the
  36  * File daemon.
  37  *
  38  *   Version $Id$
  39  *
  40  */
  41
  42 #include "bacula.h"
  43 #include "stored.h"
  44
  45 /* Imported functions */
  46
  47
  48 /* Forward referenced functions */
  49 void terminate_stored(int sig);
  50 static int check_resources();
  51 static void cleanup_old_files();
  52
  53 extern "C" void *device_initialization(void *arg);
  54
  55 #define CONFIG_FILE "bacula-sd.conf"  /* Default config file */
  56
  57 /* Global variables exported */
  58 char OK_msg[]   = "3000 OK\n";
  59 char TERM_msg[] = "3999 Terminate\n";
  60 STORES *me = NULL;                    /* our Global resource */
  61 bool forge_on = false;                /* proceed inspite of I/O errors */
  62 pthread_mutex_t device_release_mutex = PTHREAD_MUTEX_INITIALIZER;
  63 pthread_cond_t wait_device_release = PTHREAD_COND_INITIALIZER;
  64 void *start_heap;
  65
  66
  67 static uint32_t VolSessionId = 0;
  68 uint32_t VolSessionTime;
  69 char *configfile = NULL;
  70 bool init_done = false;
  71
  72 /* Global static variables */
  73 static bool foreground = 0;
  74 static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
  75 static workq_t dird_workq;            /* queue for processing connections */
  76
  77
  78 static void usage()
  79 {
  80    fprintf(stderr, _(
  81 PROG_COPYRIGHT
  82 "\nVersion: %s (%s)\n\n"
  83 "Usage: stored [options] [-c config_file] [config_file]\n"
  84 "        -c <file>   use <file> as configuration file\n"
  85 "        -d <nn>     set debug level to <nn>\n"
  86 "        -dt         print timestamp in debug output\n"
  87 "        -f          run in foreground (for debugging)\n"
  88 "        -g <group>  set groupid to group\n"
  89 "        -p          proceed despite I/O errors\n"
  90 "        -s          no signals (for debugging)\n"
  91 "        -t          test - read config and exit\n"
  92 "        -u <user>   userid to <user>\n"
  93 "        -v          verbose user messages\n"
  94 "        -?          print this message.\n"
  95 "\n"), 2000, VERSION, BDATE);
  96    exit(1);
  97 }
  98
  99 /*********************************************************************
 100  *
 101  *  Main Bacula Unix Storage Daemon
 102  *
 103  */
 104 #if defined(HAVE_WIN32)
 105 #define main BaculaMain
 106 #endif
 107
 108 int main (int argc, char *argv[])
 109 {
 110    int ch;
 111    bool no_signals = false;
 112    bool test_config = false;
 113    pthread_t thid;
 114    char *uid = NULL;
 115    char *gid = NULL;
 116
 117    start_heap = sbrk(0);
 118    setlocale(LC_ALL, "");
 119    bindtextdomain("bacula", LOCALEDIR);
 120    textdomain("bacula");
 121
 122    init_stack_dump();
 123    my_name_is(argc, argv, "bacula-sd");
 124    init_msg(NULL, NULL);
 125    daemon_start_time = time(NULL);
 126
 127    /* Sanity checks */
 128    if (TAPE_BSIZE % B_DEV_BSIZE != 0 || TAPE_BSIZE / B_DEV_BSIZE == 0) {
 129       Emsg2(M_ABORT, 0, _("Tape block size (%d) not multiple of system size (%d)\n"),
 130          TAPE_BSIZE, B_DEV_BSIZE);
 131    }
 132    if (TAPE_BSIZE != (1 << (ffs(TAPE_BSIZE)-1))) {
 133       Emsg1(M_ABORT, 0, _("Tape block size (%d) is not a power of 2\n"), TAPE_BSIZE);
 134    }
 135
 136    while ((ch = getopt(argc, argv, "c:d:fg:pstu:v?")) != -1) {
 137       switch (ch) {
 138       case 'c':                    /* configuration file */
 139          if (configfile != NULL) {
 140             free(configfile);
 141          }
 142          configfile = bstrdup(optarg);
 143          break;
 144
 145       case 'd':                    /* debug level */
 146          if (*optarg == 't') {
 147             dbg_timestamp = true;
 148          } else {
 149             debug_level = atoi(optarg);
 150             if (debug_level <= 0) {
 151                debug_level = 1;
 152             }
 153          }
 154          break;
 155
 156       case 'f':                    /* run in foreground */
 157          foreground = true;
 158          break;
 159
 160       case 'g':                    /* set group id */
 161          gid = optarg;
 162          break;
 163
 164       case 'p':                    /* proceed in spite of I/O errors */
 165          forge_on = true;
 166          break;
 167
 168       case 's':                    /* no signals */
 169          no_signals = true;
 170          break;
 171
 172       case 't':
 173          test_config = true;
 174          break;
 175
 176       case 'u':                    /* set uid */
 177          uid = optarg;
 178          break;
 179
 180       case 'v':                    /* verbose */
 181          verbose++;
 182          break;
 183
 184       case '?':
 185       default:
 186          usage();
 187          break;
 188       }
 189    }
 190    argc -= optind;
 191    argv += optind;
 192
 193    if (argc) {
 194       if (configfile != NULL) {
 195          free(configfile);
 196       }
 197       configfile = bstrdup(*argv);
 198       argc--;
 199       argv++;
 200    }
 201    if (argc)
 202       usage();
 203
 204    if (!no_signals) {
 205       init_signals(terminate_stored);
 206    }
 207
 208    if (configfile == NULL) {
 209       configfile = bstrdup(CONFIG_FILE);
 210    }
 211
 212    parse_config(configfile);
 213
 214    if (init_crypto() != 0) {
 215       Jmsg((JCR *)NULL, M_ERROR_TERM, 0, _("Cryptography library initialization failed.\n"));
 216    }
 217
 218    if (!check_resources()) {
 219       Jmsg((JCR *)NULL, M_ERROR_TERM, 0, _("Please correct configuration file: %s\n"), configfile);
 220    }
 221
 222    init_reservations_lock();
 223
 224    if (test_config) {
 225       terminate_stored(0);
 226    }
 227
 228    my_name_is(0, (char **)NULL, me->hdr.name);     /* Set our real name */
 229
 230    if (!foreground) {
 231       daemon_start();                 /* become daemon */
 232       init_stack_dump();              /* pick up new pid */
 233    }
 234
 235    create_pid_file(me->pid_directory, "bacula-sd", get_first_port_host_order(me->sdaddrs));
 236    read_state_file(me->working_directory, "bacula-sd", get_first_port_host_order(me->sdaddrs));
 237
 238    drop(uid, gid);
 239
 240    cleanup_old_files();
 241
 242
 243    /* Ensure that Volume Session Time and Id are both
 244     * set and are both non-zero.
 245     */
 246    VolSessionTime = (uint32_t)daemon_start_time;
 247    if (VolSessionTime == 0) { /* paranoid */
 248       Jmsg0(NULL, M_ABORT, 0, _("Volume Session Time is ZERO!\n"));
 249    }
 250
 251    init_python_interpreter(me->hdr.name, me->scripts_directory, "SDStartUp");
 252
 253    /* Make sure on Solaris we can run concurrent, watch dog + servers + misc */
 254    set_thread_concurrency(me->max_concurrent_jobs * 2 + 4);
 255
 256     /*
 257      * Start the device allocation thread
 258      */
 259    create_volume_list();              /* do before device_init */
 260    if (pthread_create(&thid, NULL, device_initialization, NULL) != 0) {
 261       berrno be;
 262       Emsg1(M_ABORT, 0, _("Unable to create thread. ERR=%s\n"), be.bstrerror());
 263    }
 264
 265    start_watchdog();                  /* start watchdog thread */
 266    init_jcr_subsystem();              /* start JCR watchdogs etc. */
 267
 268    /* Single server used for Director and File daemon */
 269    bnet_thread_server(me->sdaddrs, me->max_concurrent_jobs * 2 + 1,
 270                       &dird_workq, handle_connection_request);
 271    exit(1);                           /* to keep compiler quiet */
 272 }
 273
 274 /* Return a new Session Id */
 275 uint32_t newVolSessionId()
 276 {
 277    uint32_t Id;
 278
 279    P(mutex);
 280    VolSessionId++;
 281    Id = VolSessionId;
 282    V(mutex);
 283    return Id;
 284 }
 285
 286 /* Check Configuration file for necessary info */
 287 static int check_resources()
 288 {
 289    bool OK = true;
 290
 291
 292    me = (STORES *)GetNextRes(R_STORAGE, NULL);
 293    if (!me) {
 294       Jmsg1(NULL, M_ERROR, 0, _("No Storage resource defined in %s. Cannot continue.\n"),
 295          configfile);
 296       OK = false;
 297    }
 298
 299    if (GetNextRes(R_STORAGE, (RES *)me) != NULL) {
 300       Jmsg1(NULL, M_ERROR, 0, _("Only one Storage resource permitted in %s\n"),
 301          configfile);
 302       OK = false;
 303    }
 304    if (GetNextRes(R_DIRECTOR, NULL) == NULL) {
 305       Jmsg1(NULL, M_ERROR, 0, _("No Director resource defined in %s. Cannot continue.\n"),
 306          configfile);
 307       OK = false;
 308    }
 309    if (GetNextRes(R_DEVICE, NULL) == NULL){
 310       Jmsg1(NULL, M_ERROR, 0, _("No Device resource defined in %s. Cannot continue.\n"),
 311            configfile);
 312       OK = false;
 313    }
 314
 315    if (!me->messages) {
 316       me->messages = (MSGS *)GetNextRes(R_MSGS, NULL);
 317       if (!me->messages) {
 318          Jmsg1(NULL, M_ERROR, 0, _("No Messages resource defined in %s. Cannot continue.\n"),
 319             configfile);
 320          OK = false;
 321       }
 322    }
 323
 324    if (!me->working_directory) {
 325       Jmsg1(NULL, M_ERROR, 0, _("No Working Directory defined in %s. Cannot continue.\n"),
 326          configfile);
 327       OK = false;
 328    }
 329
 330    DIRRES *director;
 331    STORES *store;
 332    foreach_res(store, R_STORAGE) {
 333       /* tls_require implies tls_enable */
 334       if (store->tls_require) {
 335          if (have_tls) {
 336             store->tls_enable = true;
 337          } else {
 338             Jmsg(NULL, M_FATAL, 0, _("TLS required but not configured in Bacula.\n"));
 339             OK = false;
 340             continue;
 341          }
 342       }
 343
 344       if (!store->tls_certfile && store->tls_enable) {
 345          Jmsg(NULL, M_FATAL, 0, _("\"TLS Certificate\" file not defined for Storage \"%s\" in %s.\n"),
 346               store->hdr.name, configfile);
 347          OK = false;
 348       }
 349
 350       if (!store->tls_keyfile && store->tls_enable) {
 351          Jmsg(NULL, M_FATAL, 0, _("\"TLS Key\" file not defined for Storage \"%s\" in %s.\n"),
 352               store->hdr.name, configfile);
 353          OK = false;
 354       }
 355
 356       if ((!store->tls_ca_certfile && !store->tls_ca_certdir) && store->tls_enable && store->tls_verify_peer) {
 357          Jmsg(NULL, M_FATAL, 0, _("Neither \"TLS CA Certificate\""
 358               " or \"TLS CA Certificate Dir\" are defined for Storage \"%s\" in %s."
 359               " At least one CA certificate store is required"
 360               " when using \"TLS Verify Peer\".\n"),
 361               store->hdr.name, configfile);
 362          OK = false;
 363       }
 364
 365       /* If everything is well, attempt to initialize our per-resource TLS context */
 366       if (OK && (store->tls_enable || store->tls_require)) {
 367          /* Initialize TLS context:
 368           * Args: CA certfile, CA certdir, Certfile, Keyfile,
 369           * Keyfile PEM Callback, Keyfile CB Userdata, DHfile, Verify Peer */
 370          store->tls_ctx = new_tls_context(store->tls_ca_certfile,
 371             store->tls_ca_certdir, store->tls_certfile,
 372             store->tls_keyfile, NULL, NULL, store->tls_dhfile,
 373             store->tls_verify_peer);
 374
 375          if (!store->tls_ctx) {
 376             Jmsg(NULL, M_FATAL, 0, _("Failed to initialize TLS context for Storage \"%s\" in %s.\n"),
 377                  store->hdr.name, configfile);
 378             OK = false;
 379          }
 380       }
 381    }
 382
 383    foreach_res(director, R_DIRECTOR) {
 384       /* tls_require implies tls_enable */
 385       if (director->tls_require) {
 386          director->tls_enable = true;
 387       }
 388
 389       if (!director->tls_certfile && director->tls_enable) {
 390          Jmsg(NULL, M_FATAL, 0, _("\"TLS Certificate\" file not defined for Director \"%s\" in %s.\n"),
 391               director->hdr.name, configfile);
 392          OK = false;
 393       }
 394
 395       if (!director->tls_keyfile && director->tls_enable) {
 396          Jmsg(NULL, M_FATAL, 0, _("\"TLS Key\" file not defined for Director \"%s\" in %s.\n"),
 397               director->hdr.name, configfile);
 398          OK = false;
 399       }
 400
 401       if ((!director->tls_ca_certfile && !director->tls_ca_certdir) && director->tls_enable && director->tls_verify_peer) {
 402          Jmsg(NULL, M_FATAL, 0, _("Neither \"TLS CA Certificate\""
 403               " or \"TLS CA Certificate Dir\" are defined for Director \"%s\" in %s."
 404               " At least one CA certificate store is required"
 405               " when using \"TLS Verify Peer\".\n"),
 406               director->hdr.name, configfile);
 407          OK = false;
 408       }
 409
 410       /* If everything is well, attempt to initialize our per-resource TLS context */
 411       if (OK && (director->tls_enable || director->tls_require)) {
 412          /* Initialize TLS context:
 413           * Args: CA certfile, CA certdir, Certfile, Keyfile,
 414           * Keyfile PEM Callback, Keyfile CB Userdata, DHfile, Verify Peer */
 415          director->tls_ctx = new_tls_context(director->tls_ca_certfile,
 416             director->tls_ca_certdir, director->tls_certfile,
 417             director->tls_keyfile, NULL, NULL, director->tls_dhfile,
 418             director->tls_verify_peer);
 419
 420          if (!director->tls_ctx) {
 421             Jmsg(NULL, M_FATAL, 0, _("Failed to initialize TLS context for Director \"%s\" in %s.\n"),
 422                  director->hdr.name, configfile);
 423             OK = false;
 424          }
 425       }
 426    }
 427
 428    OK = init_autochangers();
 429
 430
 431    if (OK) {
 432       close_msg(NULL);                   /* close temp message handler */
 433       init_msg(NULL, me->messages);      /* open daemon message handler */
 434       set_working_directory(me->working_directory);
 435    }
 436
 437    return OK;
 438 }
 439
 440 static void cleanup_old_files()
 441 {
 442    POOLMEM *cleanup = get_pool_memory(PM_MESSAGE);
 443    int len = strlen(me->working_directory);
 444 #if defined(HAVE_WIN32)
 445    pm_strcpy(cleanup, "del /q ");
 446 #else
 447    pm_strcpy(cleanup, "/bin/rm -f ");
 448 #endif
 449    pm_strcat(cleanup, me->working_directory);
 450    if (len > 0 && !IsPathSeparator(me->working_directory[len-1])) {
 451       pm_strcat(cleanup, "/");
 452    }
 453    pm_strcat(cleanup, my_name);
 454    pm_strcat(cleanup, "*.spool");
 455    run_program(cleanup, 0, NULL);
 456    free_pool_memory(cleanup);
 457 }
 458
 459
 460 /*
 461  * Here we attempt to init and open each device. This is done
 462  *  once at startup in a separate thread.
 463  */
 464 extern "C"
 465 void *device_initialization(void *arg)
 466 {
 467    DEVRES *device;
 468    DCR *dcr;
 469    JCR *jcr;
 470    DEVICE *dev;
 471
 472    LockRes();
 473
 474    pthread_detach(pthread_self());
 475    jcr = new_jcr(sizeof(JCR), stored_free_jcr);
 476    jcr->JobType = JT_SYSTEM;
 477    /* Initialize FD start condition variable */
 478    int errstat = pthread_cond_init(&jcr->job_start_wait, NULL);
 479    if (errstat != 0) {
 480       berrno be;
 481       Jmsg1(jcr, M_ABORT, 0, _("Unable to init job cond variable: ERR=%s\n"), be.bstrerror(errstat));
 482    }
 483
 484    foreach_res(device, R_DEVICE) {
 485       Dmsg1(90, "calling init_dev %s\n", device->device_name);
 486       dev = init_dev(NULL, device);
 487       Dmsg1(10, "SD init done %s\n", device->device_name);
 488       if (!dev) {
 489          Jmsg1(NULL, M_ERROR, 0, _("Could not initialize %s\n"), device->device_name);
 490          continue;
 491       }
 492
 493       jcr->dcr = dcr = new_dcr(jcr, NULL, dev);
 494       if (dev->is_autochanger()) {
 495          /* If autochanger set slot in dev sturcture */
 496          get_autochanger_loaded_slot(dcr);
 497       }
 498
 499       if (device->cap_bits & CAP_ALWAYSOPEN) {
 500          Dmsg1(20, "calling first_open_device %s\n", dev->print_name());
 501          if (!first_open_device(dcr)) {
 502             Jmsg1(NULL, M_ERROR, 0, _("Could not open device %s\n"), dev->print_name());
 503             Dmsg1(20, "Could not open device %s\n", dev->print_name());
 504             free_dcr(dcr);
 505             jcr->dcr = NULL;
 506             continue;
 507          }
 508       }
 509       if (device->cap_bits & CAP_AUTOMOUNT && dev->is_open()) {
 510          switch (read_dev_volume_label(dcr)) {
 511          case VOL_OK:
 512             memcpy(&dev->VolCatInfo, &dcr->VolCatInfo, sizeof(dev->VolCatInfo));
 513             break;
 514          default:
 515             Jmsg1(NULL, M_WARNING, 0, _("Could not mount device %s\n"), dev->print_name());
 516             break;
 517          }
 518       }
 519       free_dcr(dcr);
 520       jcr->dcr = NULL;
 521    }
 522 #ifdef xxx
 523    if (jcr->dcr) {
 524       Dmsg1(000, "free_dcr=%p\n", jcr->dcr);
 525       free_dcr(jcr->dcr);
 526       jcr->dcr = NULL;
 527    }
 528 #endif
 529    free_jcr(jcr);
 530    init_done = true;
 531    UnlockRes();
 532    return NULL;
 533 }
 534
 535
 536 /* Clean up and then exit */
 537 void terminate_stored(int sig)
 538 {
 539    static bool in_here = false;
 540    DEVRES *device;
 541    JCR *jcr;
 542
 543    if (in_here) {                     /* prevent loops */
 544       bmicrosleep(2, 0);              /* yield */
 545       exit(1);
 546    }
 547    in_here = true;
 548    stop_watchdog();
 549
 550    if (sig == SIGTERM) {              /* normal shutdown request? */
 551       /*
 552        * This is a normal shutdown request. We wiffle through
 553        *   all open jobs canceling them and trying to wake
 554        *   them up so that they will report back the correct
 555        *   volume status.
 556        */
 557       foreach_jcr(jcr) {
 558          BSOCK *fd;
 559          if (jcr->JobId == 0) {
 560             free_jcr(jcr);
 561             continue;                 /* ignore console */
 562          }
 563          set_jcr_job_status(jcr, JS_Canceled);
 564          fd = jcr->file_bsock;
 565          if (fd) {
 566             fd->set_timed_out();
 567             Dmsg1(100, "term_stored killing JobId=%d\n", jcr->JobId);
 568             pthread_kill(jcr->my_thread_id, TIMEOUT_SIGNAL);
 569             /* ***FIXME*** wiffle through all dcrs */
 570             if (jcr->dcr && jcr->dcr->dev && jcr->dcr->dev->blocked()) {
 571                pthread_cond_broadcast(&jcr->dcr->dev->wait_next_vol);
 572                Dmsg1(100, "JobId=%u broadcast wait_device_release\n", (uint32_t)jcr->JobId);
 573                pthread_cond_broadcast(&wait_device_release);
 574             }
 575             if (jcr->read_dcr && jcr->read_dcr->dev && jcr->read_dcr->dev->blocked()) {
 576                pthread_cond_broadcast(&jcr->read_dcr->dev->wait_next_vol);
 577                pthread_cond_broadcast(&wait_device_release);
 578             }
 579             bmicrosleep(0, 50000);
 580          }
 581          free_jcr(jcr);
 582       }
 583       bmicrosleep(0, 500000);         /* give them 1/2 sec to clean up */
 584    }
 585
 586    write_state_file(me->working_directory, "bacula-sd", get_first_port_host_order(me->sdaddrs));
 587    delete_pid_file(me->pid_directory, "bacula-sd", get_first_port_host_order(me->sdaddrs));
 588
 589    Dmsg1(200, "In terminate_stored() sig=%d\n", sig);
 590
 591    foreach_res(device, R_DEVICE) {
 592       Dmsg1(10, "Term device %s\n", device->device_name);
 593       if (device->dev) {
 594          device->dev->clear_volhdr();
 595          device->dev->term();
 596          device->dev = NULL;
 597       } else {
 598          Dmsg1(10, "No dev structure %s\n", device->device_name);
 599       }
 600    }
 601
 602    if (configfile) {
 603       free(configfile);
 604       configfile = NULL;
 605    }
 606    free_config_resources();
 607
 608    if (debug_level > 10) {
 609       print_memory_pool_stats();
 610    }
 611    term_msg();
 612    cleanup_crypto();
 613    free_volume_list();
 614    term_reservations_lock();
 615    close_memory_pool();
 616
 617    sm_dump(false);                    /* dump orphaned buffers */
 618    exit(sig);
 619 }