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