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    bool tls_needed;
 291
 292
 293    me = (STORES *)GetNextRes(R_STORAGE, NULL);
 294    if (!me) {
 295       Jmsg1(NULL, M_ERROR, 0, _("No Storage resource defined in %s. Cannot continue.\n"),
 296          configfile);
 297       OK = false;
 298    }
 299
 300    if (GetNextRes(R_STORAGE, (RES *)me) != NULL) {
 301       Jmsg1(NULL, M_ERROR, 0, _("Only one Storage resource permitted in %s\n"),
 302          configfile);
 303       OK = false;
 304    }
 305    if (GetNextRes(R_DIRECTOR, NULL) == NULL) {
 306       Jmsg1(NULL, M_ERROR, 0, _("No Director resource defined in %s. Cannot continue.\n"),
 307          configfile);
 308       OK = false;
 309    }
 310    if (GetNextRes(R_DEVICE, NULL) == NULL){
 311       Jmsg1(NULL, M_ERROR, 0, _("No Device resource defined in %s. Cannot continue.\n"),
 312            configfile);
 313       OK = false;
 314    }
 315
 316    if (!me->messages) {
 317       me->messages = (MSGS *)GetNextRes(R_MSGS, NULL);
 318       if (!me->messages) {
 319          Jmsg1(NULL, M_ERROR, 0, _("No Messages resource defined in %s. Cannot continue.\n"),
 320             configfile);
 321          OK = false;
 322       }
 323    }
 324
 325    if (!me->working_directory) {
 326       Jmsg1(NULL, M_ERROR, 0, _("No Working Directory defined in %s. Cannot continue.\n"),
 327          configfile);
 328       OK = false;
 329    }
 330
 331    DIRRES *director;
 332    STORES *store;
 333    foreach_res(store, R_STORAGE) {
 334       /* tls_require implies tls_enable */
 335       if (store->tls_require) {
 336          if (have_tls) {
 337             store->tls_enable = true;
 338          } else {
 339             Jmsg(NULL, M_FATAL, 0, _("TLS required but not configured in Bacula.\n"));
 340             OK = false;
 341             continue;
 342          }
 343       }
 344
 345       tls_needed = store->tls_enable || store->tls_authenticate;
 346
 347       if (!store->tls_certfile && tls_needed) {
 348          Jmsg(NULL, M_FATAL, 0, _("\"TLS Certificate\" file not defined for Storage \"%s\" in %s.\n"),
 349               store->hdr.name, configfile);
 350          OK = false;
 351       }
 352
 353       if (!store->tls_keyfile && tls_needed) {
 354          Jmsg(NULL, M_FATAL, 0, _("\"TLS Key\" file not defined for Storage \"%s\" in %s.\n"),
 355               store->hdr.name, configfile);
 356          OK = false;
 357       }
 358
 359       if ((!store->tls_ca_certfile && !store->tls_ca_certdir) && tls_needed && store->tls_verify_peer) {
 360          Jmsg(NULL, M_FATAL, 0, _("Neither \"TLS CA Certificate\""
 361               " or \"TLS CA Certificate Dir\" are defined for Storage \"%s\" in %s."
 362               " At least one CA certificate store is required"
 363               " when using \"TLS Verify Peer\".\n"),
 364               store->hdr.name, configfile);
 365          OK = false;
 366       }
 367
 368       /* If everything is well, attempt to initialize our per-resource TLS context */
 369       if (OK && (tls_needed || store->tls_require)) {
 370          /* Initialize TLS context:
 371           * Args: CA certfile, CA certdir, Certfile, Keyfile,
 372           * Keyfile PEM Callback, Keyfile CB Userdata, DHfile, Verify Peer */
 373          store->tls_ctx = new_tls_context(store->tls_ca_certfile,
 374             store->tls_ca_certdir, store->tls_certfile,
 375             store->tls_keyfile, NULL, NULL, store->tls_dhfile,
 376             store->tls_verify_peer);
 377
 378          if (!store->tls_ctx) {
 379             Jmsg(NULL, M_FATAL, 0, _("Failed to initialize TLS context for Storage \"%s\" in %s.\n"),
 380                  store->hdr.name, configfile);
 381             OK = false;
 382          }
 383       }
 384    }
 385
 386    foreach_res(director, R_DIRECTOR) {
 387       /* tls_require implies tls_enable */
 388       if (director->tls_require) {
 389          director->tls_enable = true;
 390       }
 391
 392       tls_needed = director->tls_enable || director->tls_authenticate;
 393
 394       if (!director->tls_certfile && tls_needed) {
 395          Jmsg(NULL, M_FATAL, 0, _("\"TLS Certificate\" file not defined for Director \"%s\" in %s.\n"),
 396               director->hdr.name, configfile);
 397          OK = false;
 398       }
 399
 400       if (!director->tls_keyfile && tls_needed) {
 401          Jmsg(NULL, M_FATAL, 0, _("\"TLS Key\" file not defined for Director \"%s\" in %s.\n"),
 402               director->hdr.name, configfile);
 403          OK = false;
 404       }
 405
 406       if ((!director->tls_ca_certfile && !director->tls_ca_certdir) && tls_needed && director->tls_verify_peer) {
 407          Jmsg(NULL, M_FATAL, 0, _("Neither \"TLS CA Certificate\""
 408               " or \"TLS CA Certificate Dir\" are defined for Director \"%s\" in %s."
 409               " At least one CA certificate store is required"
 410               " when using \"TLS Verify Peer\".\n"),
 411               director->hdr.name, configfile);
 412          OK = false;
 413       }
 414
 415       /* If everything is well, attempt to initialize our per-resource TLS context */
 416       if (OK && (tls_needed || director->tls_require)) {
 417          /* Initialize TLS context:
 418           * Args: CA certfile, CA certdir, Certfile, Keyfile,
 419           * Keyfile PEM Callback, Keyfile CB Userdata, DHfile, Verify Peer */
 420          director->tls_ctx = new_tls_context(director->tls_ca_certfile,
 421             director->tls_ca_certdir, director->tls_certfile,
 422             director->tls_keyfile, NULL, NULL, director->tls_dhfile,
 423             director->tls_verify_peer);
 424
 425          if (!director->tls_ctx) {
 426             Jmsg(NULL, M_FATAL, 0, _("Failed to initialize TLS context for Director \"%s\" in %s.\n"),
 427                  director->hdr.name, configfile);
 428             OK = false;
 429          }
 430       }
 431    }
 432
 433    OK = init_autochangers();
 434
 435
 436    if (OK) {
 437       close_msg(NULL);                   /* close temp message handler */
 438       init_msg(NULL, me->messages);      /* open daemon message handler */
 439       set_working_directory(me->working_directory);
 440    }
 441
 442    return OK;
 443 }
 444
 445 static void cleanup_old_files()
 446 {
 447    POOLMEM *cleanup = get_pool_memory(PM_MESSAGE);
 448    int len = strlen(me->working_directory);
 449 #if defined(HAVE_WIN32)
 450    pm_strcpy(cleanup, "del /q ");
 451 #else
 452    pm_strcpy(cleanup, "/bin/rm -f ");
 453 #endif
 454    pm_strcat(cleanup, me->working_directory);
 455    if (len > 0 && !IsPathSeparator(me->working_directory[len-1])) {
 456       pm_strcat(cleanup, "/");
 457    }
 458    pm_strcat(cleanup, my_name);
 459    pm_strcat(cleanup, "*.spool");
 460    run_program(cleanup, 0, NULL);
 461    free_pool_memory(cleanup);
 462 }
 463
 464
 465 /*
 466  * Here we attempt to init and open each device. This is done
 467  *  once at startup in a separate thread.
 468  */
 469 extern "C"
 470 void *device_initialization(void *arg)
 471 {
 472    DEVRES *device;
 473    DCR *dcr;
 474    JCR *jcr;
 475    DEVICE *dev;
 476
 477    LockRes();
 478
 479    pthread_detach(pthread_self());
 480    jcr = new_jcr(sizeof(JCR), stored_free_jcr);
 481    jcr->JobType = JT_SYSTEM;
 482    /* Initialize FD start condition variable */
 483    int errstat = pthread_cond_init(&jcr->job_start_wait, NULL);
 484    if (errstat != 0) {
 485       berrno be;
 486       Jmsg1(jcr, M_ABORT, 0, _("Unable to init job cond variable: ERR=%s\n"), be.bstrerror(errstat));
 487    }
 488
 489    foreach_res(device, R_DEVICE) {
 490       Dmsg1(90, "calling init_dev %s\n", device->device_name);
 491       dev = init_dev(NULL, device);
 492       Dmsg1(10, "SD init done %s\n", device->device_name);
 493       if (!dev) {
 494          Jmsg1(NULL, M_ERROR, 0, _("Could not initialize %s\n"), device->device_name);
 495          continue;
 496       }
 497
 498       jcr->dcr = dcr = new_dcr(jcr, NULL, dev);
 499       if (dev->is_autochanger()) {
 500          /* If autochanger set slot in dev sturcture */
 501          get_autochanger_loaded_slot(dcr);
 502       }
 503
 504       if (device->cap_bits & CAP_ALWAYSOPEN) {
 505          Dmsg1(20, "calling first_open_device %s\n", dev->print_name());
 506          if (!first_open_device(dcr)) {
 507             Jmsg1(NULL, M_ERROR, 0, _("Could not open device %s\n"), dev->print_name());
 508             Dmsg1(20, "Could not open device %s\n", dev->print_name());
 509             free_dcr(dcr);
 510             jcr->dcr = NULL;
 511             continue;
 512          }
 513       }
 514       if (device->cap_bits & CAP_AUTOMOUNT && dev->is_open()) {
 515          switch (read_dev_volume_label(dcr)) {
 516          case VOL_OK:
 517             memcpy(&dev->VolCatInfo, &dcr->VolCatInfo, sizeof(dev->VolCatInfo));
 518             volume_unused(dcr);             /* mark volume "released" */
 519             break;
 520          default:
 521             Jmsg1(NULL, M_WARNING, 0, _("Could not mount device %s\n"), dev->print_name());
 522             break;
 523          }
 524       }
 525       free_dcr(dcr);
 526       jcr->dcr = NULL;
 527    }
 528 #ifdef xxx
 529    if (jcr->dcr) {
 530       Dmsg1(000, "free_dcr=%p\n", jcr->dcr);
 531       free_dcr(jcr->dcr);
 532       jcr->dcr = NULL;
 533    }
 534 #endif
 535    free_jcr(jcr);
 536    init_done = true;
 537    UnlockRes();
 538    return NULL;
 539 }
 540
 541
 542 /* Clean up and then exit */
 543 void terminate_stored(int sig)
 544 {
 545    static bool in_here = false;
 546    DEVRES *device;
 547    JCR *jcr;
 548
 549    if (in_here) {                     /* prevent loops */
 550       bmicrosleep(2, 0);              /* yield */
 551       exit(1);
 552    }
 553    in_here = true;
 554    stop_watchdog();
 555
 556    if (sig == SIGTERM) {              /* normal shutdown request? */
 557       /*
 558        * This is a normal shutdown request. We wiffle through
 559        *   all open jobs canceling them and trying to wake
 560        *   them up so that they will report back the correct
 561        *   volume status.
 562        */
 563       foreach_jcr(jcr) {
 564          BSOCK *fd;
 565          if (jcr->JobId == 0) {
 566             free_jcr(jcr);
 567             continue;                 /* ignore console */
 568          }
 569          set_jcr_job_status(jcr, JS_Canceled);
 570          fd = jcr->file_bsock;
 571          if (fd) {
 572             fd->set_timed_out();
 573             Dmsg1(100, "term_stored killing JobId=%d\n", jcr->JobId);
 574             pthread_kill(jcr->my_thread_id, TIMEOUT_SIGNAL);
 575             /* ***FIXME*** wiffle through all dcrs */
 576             if (jcr->dcr && jcr->dcr->dev && jcr->dcr->dev->blocked()) {
 577                pthread_cond_broadcast(&jcr->dcr->dev->wait_next_vol);
 578                Dmsg1(100, "JobId=%u broadcast wait_device_release\n", (uint32_t)jcr->JobId);
 579                pthread_cond_broadcast(&wait_device_release);
 580             }
 581             if (jcr->read_dcr && jcr->read_dcr->dev && jcr->read_dcr->dev->blocked()) {
 582                pthread_cond_broadcast(&jcr->read_dcr->dev->wait_next_vol);
 583                pthread_cond_broadcast(&wait_device_release);
 584             }
 585             bmicrosleep(0, 50000);
 586          }
 587          free_jcr(jcr);
 588       }
 589       bmicrosleep(0, 500000);         /* give them 1/2 sec to clean up */
 590    }
 591
 592    write_state_file(me->working_directory, "bacula-sd", get_first_port_host_order(me->sdaddrs));
 593    delete_pid_file(me->pid_directory, "bacula-sd", get_first_port_host_order(me->sdaddrs));
 594
 595    Dmsg1(200, "In terminate_stored() sig=%d\n", sig);
 596
 597    foreach_res(device, R_DEVICE) {
 598       Dmsg1(10, "Term device %s\n", device->device_name);
 599       if (device->dev) {
 600          device->dev->clear_volhdr();
 601          device->dev->term();
 602          device->dev = NULL;
 603       } else {
 604          Dmsg1(10, "No dev structure %s\n", device->device_name);
 605       }
 606    }
 607
 608    if (configfile) {
 609       free(configfile);
 610       configfile = NULL;
 611    }
 612    free_config_resources();
 613
 614    if (debug_level > 10) {
 615       print_memory_pool_stats();
 616    }
 617    term_msg();
 618    cleanup_crypto();
 619    free_volume_list();
 620    term_reservations_lock();
 621    close_memory_pool();
 622
 623    sm_dump(false);                    /* dump orphaned buffers */
 624    exit(sig);
 625 }