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

   1 /*
   2    Bacula® - The Network Backup Solution
   3
   4    Copyright (C) 2000-2008 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    POOLMEM *results = get_pool_memory(PM_MESSAGE);
 449    int len = strlen(me->working_directory);
 450 #if defined(HAVE_WIN32)
 451    pm_strcpy(cleanup, "del /q ");
 452 #else
 453    pm_strcpy(cleanup, "/bin/rm -f ");
 454 #endif
 455    pm_strcat(cleanup, me->working_directory);
 456    if (len > 0 && !IsPathSeparator(me->working_directory[len-1])) {
 457       pm_strcat(cleanup, "/");
 458    }
 459    pm_strcat(cleanup, my_name);
 460    pm_strcat(cleanup, "*.spool");
 461    run_program(cleanup, 0, results);
 462    free_pool_memory(cleanup);
 463    free_pool_memory(results);
 464 }
 465
 466
 467 /*
 468  * Here we attempt to init and open each device. This is done
 469  *  once at startup in a separate thread.
 470  */
 471 extern "C"
 472 void *device_initialization(void *arg)
 473 {
 474    DEVRES *device;
 475    DCR *dcr;
 476    JCR *jcr;
 477    DEVICE *dev;
 478
 479    LockRes();
 480
 481    pthread_detach(pthread_self());
 482    jcr = new_jcr(sizeof(JCR), stored_free_jcr);
 483    jcr->JobType = JT_SYSTEM;
 484    /* Initialize FD start condition variable */
 485    int errstat = pthread_cond_init(&jcr->job_start_wait, NULL);
 486    if (errstat != 0) {
 487       berrno be;
 488       Jmsg1(jcr, M_ABORT, 0, _("Unable to init job cond variable: ERR=%s\n"), be.bstrerror(errstat));
 489    }
 490
 491    foreach_res(device, R_DEVICE) {
 492       Dmsg1(90, "calling init_dev %s\n", device->device_name);
 493       dev = init_dev(NULL, device);
 494       Dmsg1(10, "SD init done %s\n", device->device_name);
 495       if (!dev) {
 496          Jmsg1(NULL, M_ERROR, 0, _("Could not initialize %s\n"), device->device_name);
 497          continue;
 498       }
 499
 500       jcr->dcr = dcr = new_dcr(jcr, NULL, dev);
 501       if (dev->is_autochanger()) {
 502          /* If autochanger set slot in dev sturcture */
 503          get_autochanger_loaded_slot(dcr);
 504       }
 505
 506       if (device->cap_bits & CAP_ALWAYSOPEN) {
 507          Dmsg1(20, "calling first_open_device %s\n", dev->print_name());
 508          if (!first_open_device(dcr)) {
 509             Jmsg1(NULL, M_ERROR, 0, _("Could not open device %s\n"), dev->print_name());
 510             Dmsg1(20, "Could not open device %s\n", dev->print_name());
 511             free_dcr(dcr);
 512             jcr->dcr = NULL;
 513             continue;
 514          }
 515       }
 516       if (device->cap_bits & CAP_AUTOMOUNT && dev->is_open()) {
 517          switch (read_dev_volume_label(dcr)) {
 518          case VOL_OK:
 519             memcpy(&dev->VolCatInfo, &dcr->VolCatInfo, sizeof(dev->VolCatInfo));
 520             volume_unused(dcr);             /* mark volume "released" */
 521             break;
 522          default:
 523             Jmsg1(NULL, M_WARNING, 0, _("Could not mount device %s\n"), dev->print_name());
 524             break;
 525          }
 526       }
 527       free_dcr(dcr);
 528       jcr->dcr = NULL;
 529    }
 530 #ifdef xxx
 531    if (jcr->dcr) {
 532       Dmsg1(000, "free_dcr=%p\n", jcr->dcr);
 533       free_dcr(jcr->dcr);
 534       jcr->dcr = NULL;
 535    }
 536 #endif
 537    free_jcr(jcr);
 538    init_done = true;
 539    UnlockRes();
 540    return NULL;
 541 }
 542
 543
 544 /* Clean up and then exit */
 545 void terminate_stored(int sig)
 546 {
 547    static bool in_here = false;
 548    DEVRES *device;
 549    JCR *jcr;
 550
 551    if (in_here) {                     /* prevent loops */
 552       bmicrosleep(2, 0);              /* yield */
 553       exit(1);
 554    }
 555    in_here = true;
 556    debug_level = 0;                   /* turn off any debug */
 557    stop_watchdog();
 558
 559    if (sig == SIGTERM) {              /* normal shutdown request? */
 560       /*
 561        * This is a normal shutdown request. We wiffle through
 562        *   all open jobs canceling them and trying to wake
 563        *   them up so that they will report back the correct
 564        *   volume status.
 565        */
 566       foreach_jcr(jcr) {
 567          BSOCK *fd;
 568          if (jcr->JobId == 0) {
 569             free_jcr(jcr);
 570             continue;                 /* ignore console */
 571          }
 572          set_jcr_job_status(jcr, JS_Canceled);
 573          fd = jcr->file_bsock;
 574          if (fd) {
 575             fd->set_timed_out();
 576             Dmsg1(100, "term_stored killing JobId=%d\n", jcr->JobId);
 577             pthread_kill(jcr->my_thread_id, TIMEOUT_SIGNAL);
 578             /* ***FIXME*** wiffle through all dcrs */
 579             if (jcr->dcr && jcr->dcr->dev && jcr->dcr->dev->blocked()) {
 580                pthread_cond_broadcast(&jcr->dcr->dev->wait_next_vol);
 581                Dmsg1(100, "JobId=%u broadcast wait_device_release\n", (uint32_t)jcr->JobId);
 582                pthread_cond_broadcast(&wait_device_release);
 583             }
 584             if (jcr->read_dcr && jcr->read_dcr->dev && jcr->read_dcr->dev->blocked()) {
 585                pthread_cond_broadcast(&jcr->read_dcr->dev->wait_next_vol);
 586                pthread_cond_broadcast(&wait_device_release);
 587             }
 588             bmicrosleep(0, 50000);
 589          }
 590          free_jcr(jcr);
 591       }
 592       bmicrosleep(0, 500000);         /* give them 1/2 sec to clean up */
 593    }
 594
 595    write_state_file(me->working_directory, "bacula-sd", get_first_port_host_order(me->sdaddrs));
 596    delete_pid_file(me->pid_directory, "bacula-sd", get_first_port_host_order(me->sdaddrs));
 597
 598    Dmsg1(200, "In terminate_stored() sig=%d\n", sig);
 599
 600    free_volume_list();
 601
 602    foreach_res(device, R_DEVICE) {
 603       Dmsg1(10, "Term device %s\n", device->device_name);
 604       if (device->dev) {
 605          device->dev->clear_volhdr();
 606          device->dev->term();
 607          device->dev = NULL;
 608       } else {
 609          Dmsg1(10, "No dev structure %s\n", device->device_name);
 610       }
 611    }
 612
 613    if (configfile) {
 614       free(configfile);
 615       configfile = NULL;
 616    }
 617    free_config_resources();
 618
 619    if (debug_level > 10) {
 620       print_memory_pool_stats();
 621    }
 622    term_msg();
 623    cleanup_crypto();
 624    term_reservations_lock();
 625    close_memory_pool();
 626
 627    sm_dump(false);                    /* dump orphaned buffers */
 628    exit(sig);
 629 }