2 Bacula® - The Network Backup Solution
4 Copyright (C) 2001-2012 Free Software Foundation Europe e.V.
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 three of the GNU Affero General Public
10 License as published by the Free Software Foundation and included
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.
18 You should have received a copy of the GNU Affero 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
23 Bacula® is a registered trademark of Kern Sibbald.
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.
29 * This file handles accepting Director Commands
31 * Most Director commands are handled here, with the
32 * exception of the Job command command and subsequent
33 * subcommands that are handled
36 * N.B. in this file, in general we must use P(dev->mutex) rather
37 * than dev->r_lock() so that we can examine the blocked
38 * state rather than blocking ourselves because a Job
39 * thread has the device blocked. In some "safe" cases,
40 * we can do things to a blocked device. CAREFUL!!!!
42 * File daemon commands are handled in fdcmd.c
44 * Kern Sibbald, May MMI
51 /* Exported variables */
53 /* Imported variables */
54 extern BSOCK *filed_chan;
55 extern struct s_last_job last_job;
56 extern bool init_done;
58 /* Static variables */
59 static char derrmsg[] = "3900 Invalid command:";
60 static char OKsetdebug[] = "3000 OK setdebug=%d\n";
61 static char invalid_cmd[] = "3997 Invalid command for a Director with Monitor directive enabled.\n";
62 static char OK_bootstrap[] = "3000 OK bootstrap\n";
63 static char ERROR_bootstrap[] = "3904 Error bootstrap\n";
65 /* Imported functions */
66 extern void terminate_child();
67 extern bool job_cmd(JCR *jcr);
68 extern bool use_cmd(JCR *jcr);
69 extern bool run_cmd(JCR *jcr);
70 extern bool status_cmd(JCR *sjcr);
71 extern bool qstatus_cmd(JCR *jcr);
72 //extern bool query_cmd(JCR *jcr);
74 /* Forward referenced functions */
75 static bool label_cmd(JCR *jcr);
76 static bool die_cmd(JCR *jcr);
77 static bool relabel_cmd(JCR *jcr);
78 static bool readlabel_cmd(JCR *jcr);
79 static bool release_cmd(JCR *jcr);
80 static bool setdebug_cmd(JCR *jcr);
81 static bool cancel_cmd(JCR *cjcr);
82 static bool mount_cmd(JCR *jcr);
83 static bool unmount_cmd(JCR *jcr);
84 //static bool action_on_purge_cmd(JCR *jcr);
85 static bool bootstrap_cmd(JCR *jcr);
86 static bool changer_cmd(JCR *sjcr);
87 static bool do_label(JCR *jcr, int relabel);
88 static DCR *find_device(JCR *jcr, POOL_MEM &dev_name, int drive);
89 static void read_volume_label(JCR *jcr, DCR *dcr, DEVICE *dev, int Slot);
90 static void label_volume_if_ok(DCR *dcr, char *oldname,
91 char *newname, char *poolname,
92 int Slot, int relabel);
93 static bool try_autoload_device(JCR *jcr, DCR *dcr, int slot, const char *VolName);
94 static void send_dir_busy_message(BSOCK *dir, DEVICE *dev);
98 bool (*func)(JCR *jcr);
99 bool monitoraccess; /* set if monitors can access this cmd */
103 * The following are the recognized commands from the Director.
105 static struct s_cmds cmds[] = {
106 {"JobId=", job_cmd, 0}, /* start Job */
107 {"autochanger", changer_cmd, 0},
108 {"bootstrap", bootstrap_cmd, 0},
109 {"cancel", cancel_cmd, 0},
110 {".die", die_cmd, 0},
111 {"label", label_cmd, 0}, /* label a tape */
112 {"mount", mount_cmd, 0},
113 {"readlabel", readlabel_cmd, 0},
114 {"release", release_cmd, 0},
115 {"relabel", relabel_cmd, 0}, /* relabel a tape */
116 {"setdebug=", setdebug_cmd, 0}, /* set debug level */
117 {"status", status_cmd, 1},
118 {".status", qstatus_cmd, 1},
119 {"unmount", unmount_cmd, 0},
120 // {"action_on_purge", action_on_purge_cmd, 0},
121 {"use storage=", use_cmd, 0},
123 // {"query", query_cmd, 0},
124 {NULL, NULL} /* list terminator */
129 * Connection request. We accept connections either from the
130 * Director or a Client (File daemon).
132 * Note, we are running as a seperate thread of the Storage daemon.
133 * and it is because a Director has made a connection with
134 * us on the "Message" channel.
136 * Basic tasks done here:
137 * - Create a JCR record
138 * - If it was from the FD, call handle_filed_connection()
139 * - Authenticate the Director
140 * - We wait for a command
141 * - We execute the command
142 * - We continue or exit depending on the return status
144 void *handle_connection_request(void *arg)
146 BSOCK *bs = (BSOCK *)arg;
154 if (bs->recv() <= 0) {
155 Emsg1(M_ERROR, 0, _("Connection request from %s failed.\n"), bs->who());
156 bmicrosleep(5, 0); /* make user wait 5 seconds */
162 * Do a sanity check on the message received
164 if (bs->msglen < 25 || bs->msglen > (int)sizeof(name)) {
165 Dmsg1(000, "<filed: %s", bs->msg);
166 Emsg2(M_ERROR, 0, _("Invalid connection from %s. Len=%d\n"), bs->who(), bs->msglen);
167 bmicrosleep(5, 0); /* make user wait 5 seconds */
172 * See if this is a File daemon connection. If so
175 Dmsg1(110, "Conn: %s", bs->msg);
176 if (debug_level == 3) {
177 Dmsg1(000, "<filed: %s", bs->msg);
179 if (sscanf(bs->msg, "Hello Start Job %127s", name) == 1) {
180 Dmsg1(110, "Got a FD connection at %s\n", bstrftimes(tbuf, sizeof(tbuf),
181 (utime_t)time(NULL)));
182 Dmsg1(50, "%s", bs->msg);
183 handle_filed_connection(bs, name);
188 * This is a connection from the Director, so setup a JCR
190 Dmsg1(110, "Got a DIR connection at %s\n", bstrftimes(tbuf, sizeof(tbuf),
191 (utime_t)time(NULL)));
192 jcr = new_jcr(sizeof(JCR), stored_free_jcr); /* create Job Control Record */
193 jcr->dir_bsock = bs; /* save Director bsock */
194 jcr->dir_bsock->set_jcr(jcr);
195 jcr->dcrs = New(alist(10, not_owned_by_alist));
196 /* Initialize FD start condition variable */
197 int errstat = pthread_cond_init(&jcr->job_start_wait, NULL);
200 Jmsg1(jcr, M_FATAL, 0, _("Unable to init job cond variable: ERR=%s\n"), be.bstrerror(errstat));
204 Dmsg0(1000, "stored in start_job\n");
207 * Authenticate the Director
209 if (!authenticate_director(jcr)) {
210 Jmsg(jcr, M_FATAL, 0, _("Unable to authenticate Director\n"));
213 Dmsg0(90, "Message channel init completed.\n");
215 for (quit=false; !quit;) {
217 if ((bnet_stat = bs->recv()) <= 0) {
218 break; /* connection terminated */
220 Dmsg1(199, "<dird: %s\n", bs->msg);
221 /* Ensure that device initialization is complete */
226 for (i=0; cmds[i].cmd; i++) {
227 if (strncmp(cmds[i].cmd, bs->msg, strlen(cmds[i].cmd)) == 0) {
228 if ((!cmds[i].monitoraccess) && (jcr->director->monitor)) {
229 Dmsg1(100, "Command \"%s\" is invalid.\n", cmds[i].cmd);
230 bs->fsend(invalid_cmd);
231 bs->signal(BNET_EOD);
234 Dmsg1(200, "Do command: %s\n", cmds[i].cmd);
235 if (!cmds[i].func(jcr)) { /* do command */
236 quit = true; /* error, get out */
237 Dmsg1(190, "Command %s requests quit\n", cmds[i].cmd);
239 found = true; /* indicate command found */
243 if (!found) { /* command not found */
245 Mmsg(err_msg, "%s %s\n", derrmsg, bs->msg);
246 bs->fsend(err_msg.c_str());
251 generate_daemon_event(jcr, "JobEnd");
252 dequeue_messages(jcr); /* send any queued messages */
253 bs->signal(BNET_TERMINATE);
260 * Force SD to die, and hopefully dump itself. Turned on only
261 * in development version.
263 static bool die_cmd(JCR *jcr)
268 BSOCK *dir = jcr->dir_bsock;
269 pthread_mutex_t m=PTHREAD_MUTEX_INITIALIZER;
271 if (strstr(dir->msg, "deadlock")) {
272 Pmsg0(000, "I have been requested to deadlock ...\n");
277 Pmsg1(000, "I have been requested to die ... (%s)\n", dir->msg);
278 a = djcr->JobId; /* ref NULL pointer */
286 * Set debug level as requested by the Director
289 static bool setdebug_cmd(JCR *jcr)
291 BSOCK *dir = jcr->dir_bsock;
292 int32_t level, trace_flag;
294 Dmsg1(10, "setdebug_cmd: %s", dir->msg);
295 if (sscanf(dir->msg, "setdebug=%d trace=%d", &level, &trace_flag) != 2 || level < 0) {
296 dir->fsend(_("3991 Bad setdebug command: %s\n"), dir->msg);
300 set_trace(trace_flag);
301 return dir->fsend(OKsetdebug, level);
307 * Be careful, we switch to using the job's JCR! So, using
308 * BSOCKs on that jcr can have two threads in the same code.
310 static bool cancel_cmd(JCR *cjcr)
312 BSOCK *dir = cjcr->dir_bsock;
314 char Job[MAX_NAME_LENGTH];
317 if (sscanf(dir->msg, "cancel Job=%127s", Job) == 1) {
318 if (!(jcr=get_jcr_by_full_name(Job))) {
319 dir->fsend(_("3904 Job %s not found.\n"), Job);
321 oldStatus = jcr->JobStatus;
322 jcr->setJobStatus(JS_Canceled);
323 Dmsg2(800, "Cancel JobId=%d %p\n", jcr->JobId, jcr);
324 if (!jcr->authenticated && oldStatus == JS_WaitFD) {
325 pthread_cond_signal(&jcr->job_start_wait); /* wake waiting thread */
327 if (jcr->file_bsock) {
328 jcr->file_bsock->set_terminated();
329 jcr->file_bsock->set_timed_out();
330 Dmsg2(800, "Term bsock jid=%d %p\n", jcr->JobId, jcr);
332 /* Still waiting for FD to connect, release it */
333 pthread_cond_signal(&jcr->job_start_wait); /* wake waiting job */
334 Dmsg2(800, "Signal FD connect jid=%d %p\n", jcr->JobId, jcr);
336 /* If thread waiting on mount, wake him */
337 if (jcr->dcr && jcr->dcr->dev && jcr->dcr->dev->waiting_for_mount()) {
338 pthread_cond_broadcast(&jcr->dcr->dev->wait_next_vol);
339 Dmsg1(100, "JobId=%u broadcast wait_device_release\n", (uint32_t)jcr->JobId);
340 pthread_cond_broadcast(&wait_device_release);
342 if (jcr->read_dcr && jcr->read_dcr->dev && jcr->read_dcr->dev->waiting_for_mount()) {
343 pthread_cond_broadcast(&jcr->read_dcr->dev->wait_next_vol);
344 Dmsg1(100, "JobId=%u broadcast wait_device_release\n", (uint32_t)jcr->JobId);
345 pthread_cond_broadcast(&wait_device_release);
347 dir->fsend(_("3000 JobId=%ld Job=\"%s\" marked to be canceled.\n"), jcr->JobId, jcr->Job);
351 dir->fsend(_("3903 Error scanning cancel command.\n"));
353 dir->signal(BNET_EOD);
361 static bool label_cmd(JCR *jcr)
363 return do_label(jcr, 0);
366 static bool relabel_cmd(JCR *jcr)
368 return do_label(jcr, 1);
371 static bool do_label(JCR *jcr, int relabel)
373 POOLMEM *newname, *oldname, *poolname, *mtype;
375 BSOCK *dir = jcr->dir_bsock;
381 newname = get_memory(dir->msglen+1);
382 oldname = get_memory(dir->msglen+1);
383 poolname = get_memory(dir->msglen+1);
384 mtype = get_memory(dir->msglen+1);
386 if (sscanf(dir->msg, "relabel %127s OldName=%127s NewName=%127s PoolName=%127s "
387 "MediaType=%127s Slot=%d drive=%d",
388 dev_name.c_str(), oldname, newname, poolname, mtype,
389 &slot, &drive) == 7) {
394 if (sscanf(dir->msg, "label %127s VolumeName=%127s PoolName=%127s "
395 "MediaType=%127s Slot=%d drive=%d",
396 dev_name.c_str(), newname, poolname, mtype, &slot, &drive) == 6) {
401 unbash_spaces(newname);
402 unbash_spaces(oldname);
403 unbash_spaces(poolname);
404 unbash_spaces(mtype);
405 dcr = find_device(jcr, dev_name, drive);
408 dev->dlock(); /* Use P to avoid indefinite block */
409 if (!dev->is_open() && !dev->is_busy()) {
410 Dmsg1(400, "Can %slabel. Device is not open\n", relabel?"re":"");
411 label_volume_if_ok(dcr, oldname, newname, poolname, slot, relabel);
413 /* Under certain "safe" conditions, we can steal the lock */
414 } else if (dev->can_steal_lock()) {
415 Dmsg0(400, "Can relabel. can_steal_lock\n");
416 label_volume_if_ok(dcr, oldname, newname, poolname, slot, relabel);
417 } else if (dev->is_busy() || dev->is_blocked()) {
418 send_dir_busy_message(dir, dev);
419 } else { /* device not being used */
420 Dmsg0(400, "Can relabel. device not used\n");
421 label_volume_if_ok(dcr, oldname, newname, poolname, slot, relabel);
426 dir->fsend(_("3999 Device \"%s\" not found or could not be opened.\n"), dev_name.c_str());
429 /* NB dir->msg gets clobbered in bnet_fsend, so save command */
430 pm_strcpy(jcr->errmsg, dir->msg);
431 dir->fsend(_("3903 Error scanning label command: %s\n"), jcr->errmsg);
433 free_memory(oldname);
434 free_memory(newname);
435 free_memory(poolname);
437 dir->signal(BNET_EOD);
442 * Read the tape label and determine if we can safely
443 * label the tape (not a Bacula volume), then label it.
445 * Enter with the mutex set
447 static void label_volume_if_ok(DCR *dcr, char *oldname,
448 char *newname, char *poolname,
449 int slot, int relabel)
451 BSOCK *dir = dcr->jcr->dir_bsock;
453 DEVICE *dev = dcr->dev;
456 const char *volname = (relabel == 1) ? oldname : newname;
459 steal_device_lock(dev, &hold, BST_WRITING_LABEL);
460 Dmsg1(100, "Stole device %s lock, writing label.\n", dev->print_name());
463 Dmsg0(90, "try_autoload_device - looking for volume_info\n");
464 if (!try_autoload_device(dcr->jcr, dcr, slot, volname)) {
465 goto bail_out; /* error */
468 /* Ensure that the device is open -- autoload_device() closes it */
469 if (dev->is_tape()) {
470 mode = OPEN_READ_WRITE;
472 mode = CREATE_READ_WRITE;
476 dev->truncating = true; /* let open() know we will truncate it */
478 /* Set old volume name for open if relabeling */
479 dcr->setVolCatName(volname);
480 if (dev->open(dcr, mode) < 0) {
481 dir->fsend(_("3910 Unable to open device \"%s\": ERR=%s\n"),
482 dev->print_name(), dev->bstrerror());
486 /* See what we have for a Volume */
487 label_status = read_dev_volume_label(dcr);
489 /* Set new volume name */
490 dcr->setVolCatName(newname);
491 switch(label_status) {
493 case VOL_VERSION_ERROR:
494 case VOL_LABEL_ERROR:
498 "3920 Cannot label Volume because it is already labeled: \"%s\"\n"),
499 dev->VolHdr.VolumeName);
503 /* Relabel request. If oldname matches, continue */
504 if (strcmp(oldname, dev->VolHdr.VolumeName) != 0) {
505 dir->fsend(_("3921 Wrong volume mounted.\n"));
508 if (dev->label_type != B_BACULA_LABEL) {
509 dir->fsend(_("3922 Cannot relabel an ANSI/IBM labeled Volume.\n"));
512 /* Fall through wanted! */
515 if (!write_new_volume_label_to_dev(dcr, newname, poolname,
516 relabel, true /* write dvd now */)) {
517 dir->fsend(_("3912 Failed to label Volume: ERR=%s\n"), dev->bstrerror());
520 bstrncpy(dcr->VolumeName, newname, sizeof(dcr->VolumeName));
521 /* The following 3000 OK label. string is scanned in ua_label.c */
522 dir->fsend("3000 OK label. VolBytes=%s DVD=%d Volume=\"%s\" Device=%s\n",
523 edit_uint64(dev->VolCatInfo.VolCatBytes, ed1),
524 dev->is_dvd()?1:0, newname, dev->print_name());
527 dir->fsend(_("3914 Failed to label Volume (no media): ERR=%s\n"), dev->bstrerror());
530 dir->fsend(_("3913 Cannot label Volume. "
531 "Unknown status %d from read_volume_label()\n"), label_status);
536 if (!dev->is_open()) {
539 volume_unused(dcr); /* no longer using volume */
540 give_back_device_lock(dev, &hold);
546 * Read the tape label
548 * Enter with the mutex set
550 static bool read_label(DCR *dcr)
554 BSOCK *dir = jcr->dir_bsock;
556 DEVICE *dev = dcr->dev;
558 steal_device_lock(dev, &hold, BST_DOING_ACQUIRE);
560 dcr->VolumeName[0] = 0;
561 dev->clear_labeled(); /* force read of label */
562 switch (read_dev_volume_label(dcr)) {
564 dir->fsend(_("3001 Mounted Volume: %s\n"), dev->VolHdr.VolumeName);
568 dir->fsend(_("3902 Cannot mount Volume on Storage Device \"%s\" because:\n%s"),
569 dev->print_name(), jcr->errmsg);
574 give_back_device_lock(dev, &hold);
579 * Searches for device by name, and if found, creates a dcr and
582 static DCR *find_device(JCR *jcr, POOL_MEM &devname, int drive)
585 AUTOCHANGER *changer;
589 unbash_spaces(devname);
590 foreach_res(device, R_DEVICE) {
591 /* Find resource, and make sure we were able to open it */
592 if (strcmp(device->hdr.name, devname.c_str()) == 0) {
594 device->dev = init_dev(jcr, device);
597 Jmsg(jcr, M_WARNING, 0, _("\n"
598 " Device \"%s\" requested by DIR could not be opened or does not exist.\n"),
602 Dmsg1(20, "Found device %s\n", device->hdr.name);
608 foreach_res(changer, R_AUTOCHANGER) {
609 /* Find resource, and make sure we were able to open it */
610 if (strcmp(devname.c_str(), changer->hdr.name) == 0) {
611 /* Try each device in this AutoChanger */
612 foreach_alist(device, changer->device) {
613 Dmsg1(100, "Try changer device %s\n", device->hdr.name);
615 device->dev = init_dev(jcr, device);
618 Dmsg1(100, "Device %s could not be opened. Skipped\n", devname.c_str());
619 Jmsg(jcr, M_WARNING, 0, _("\n"
620 " Device \"%s\" in changer \"%s\" requested by DIR could not be opened or does not exist.\n"),
621 device->hdr.name, devname.c_str());
624 if (!device->dev->autoselect) {
625 Dmsg1(100, "Device %s not autoselect skipped.\n", devname.c_str());
626 continue; /* device is not available */
628 if (drive < 0 || drive == (int)device->dev->drive_index) {
629 Dmsg1(20, "Found changer device %s\n", device->hdr.name);
633 Dmsg3(100, "Device %s drive wrong: want=%d got=%d skipping\n",
634 devname.c_str(), drive, (int)device->dev->drive_index);
636 break; /* we found it but could not open a device */
642 Dmsg1(100, "Found device %s\n", device->hdr.name);
643 dcr = new_dcr(jcr, NULL, device->dev);
644 dcr->device = device;
651 * Mount command from Director
653 static bool mount_cmd(JCR *jcr)
656 BSOCK *dir = jcr->dir_bsock;
663 ok = sscanf(dir->msg, "mount %127s drive=%d slot=%d", devname.c_str(),
666 ok = sscanf(dir->msg, "mount %127s drive=%d", devname.c_str(), &drive) == 2;
668 Dmsg3(100, "ok=%d drive=%d slot=%d\n", ok, drive, slot);
670 dcr = find_device(jcr, devname, drive);
673 dev->dlock(); /* Use P to avoid indefinite block */
674 Dmsg2(100, "mount cmd blocked=%d must_unload=%d\n", dev->blocked(),
676 switch (dev->blocked()) { /* device blocked? */
677 case BST_WAITING_FOR_SYSOP:
678 /* Someone is waiting, wake him */
679 Dmsg0(100, "Waiting for mount. Attempting to wake thread\n");
680 dev->set_blocked(BST_MOUNT);
681 dir->fsend("3001 OK mount requested. %sDevice=%s\n",
682 slot>0?_("Specified slot ignored. "):"",
684 pthread_cond_broadcast(&dev->wait_next_vol);
685 Dmsg1(100, "JobId=%u broadcast wait_device_release\n", (uint32_t)dcr->jcr->JobId);
686 pthread_cond_broadcast(&wait_device_release);
689 /* In both of these two cases, we (the user) unmounted the Volume */
690 case BST_UNMOUNTED_WAITING_FOR_SYSOP:
692 Dmsg2(100, "Unmounted changer=%d slot=%d\n", dev->is_autochanger(), slot);
693 if (dev->is_autochanger() && slot > 0) {
694 try_autoload_device(jcr, dcr, slot, "");
696 /* We freed the device, so reopen it and wake any waiting threads */
697 if (dev->open(dcr, OPEN_READ_ONLY) < 0) {
698 dir->fsend(_("3901 Unable to open device \"%s\": ERR=%s\n"),
699 dev->print_name(), dev->bstrerror());
700 if (dev->blocked() == BST_UNMOUNTED) {
701 /* We blocked the device, so unblock it */
702 Dmsg0(100, "Unmounted. Unblocking device\n");
707 read_dev_volume_label(dcr);
708 if (dev->blocked() == BST_UNMOUNTED) {
709 /* We blocked the device, so unblock it */
710 Dmsg0(100, "Unmounted. Unblocking device\n");
711 read_label(dcr); /* this should not be necessary */
714 Dmsg0(100, "Unmounted waiting for mount. Attempting to wake thread\n");
715 dev->set_blocked(BST_MOUNT);
717 if (dev->is_labeled()) {
718 dir->fsend(_("3001 Device \"%s\" is mounted with Volume \"%s\"\n"),
719 dev->print_name(), dev->VolHdr.VolumeName);
721 dir->fsend(_("3905 Device \"%s\" open but no Bacula volume is mounted.\n"
722 "If this is not a blank tape, try unmounting and remounting the Volume.\n"),
725 pthread_cond_broadcast(&dev->wait_next_vol);
726 Dmsg1(100, "JobId=%u broadcast wait_device_release\n", (uint32_t)dcr->jcr->JobId);
727 pthread_cond_broadcast(&wait_device_release);
730 case BST_DOING_ACQUIRE:
731 dir->fsend(_("3001 Device \"%s\" is doing acquire.\n"),
735 case BST_WRITING_LABEL:
736 dir->fsend(_("3903 Device \"%s\" is being labeled.\n"),
740 case BST_NOT_BLOCKED:
741 Dmsg2(100, "Not blocked changer=%d slot=%d\n", dev->is_autochanger(), slot);
742 if (dev->is_autochanger() && slot > 0) {
743 try_autoload_device(jcr, dcr, slot, "");
745 if (dev->is_open()) {
746 if (dev->is_labeled()) {
747 dir->fsend(_("3001 Device \"%s\" is mounted with Volume \"%s\"\n"),
748 dev->print_name(), dev->VolHdr.VolumeName);
750 dir->fsend(_("3905 Device \"%s\" open but no Bacula volume is mounted.\n"
751 "If this is not a blank tape, try unmounting and remounting the Volume.\n"),
754 } else if (dev->is_tape()) {
755 if (dev->open(dcr, OPEN_READ_ONLY) < 0) {
756 dir->fsend(_("3901 Unable to open device \"%s\": ERR=%s\n"),
757 dev->print_name(), dev->bstrerror());
761 if (dev->is_labeled()) {
762 dir->fsend(_("3001 Device \"%s\" is already mounted with Volume \"%s\"\n"),
763 dev->print_name(), dev->VolHdr.VolumeName);
765 dir->fsend(_("3905 Device \"%s\" open but no Bacula volume is mounted.\n"
766 "If this is not a blank tape, try unmounting and remounting the Volume.\n"),
769 } else if (dev->is_unmountable()) {
771 dir->fsend(_("3002 Device \"%s\" is mounted.\n"), dev->print_name());
773 dir->fsend(_("3907 %s"), dev->bstrerror());
775 } else { /* must be file */
776 dir->fsend(_("3906 File device \"%s\" is always mounted.\n"),
778 pthread_cond_broadcast(&dev->wait_next_vol);
779 Dmsg1(100, "JobId=%u broadcast wait_device_release\n", (uint32_t)dcr->jcr->JobId);
780 pthread_cond_broadcast(&wait_device_release);
785 dir->fsend(_("3930 Device \"%s\" is being released.\n"), dev->print_name());
789 dir->fsend(_("3905 Unknown wait state %d\n"), dev->blocked());
795 dir->fsend(_("3999 Device \"%s\" not found or could not be opened.\n"), devname.c_str());
798 pm_strcpy(jcr->errmsg, dir->msg);
799 dir->fsend(_("3909 Error scanning mount command: %s\n"), jcr->errmsg);
801 dir->signal(BNET_EOD);
806 * unmount command from Director
808 static bool unmount_cmd(JCR *jcr)
811 BSOCK *dir = jcr->dir_bsock;
816 if (sscanf(dir->msg, "unmount %127s drive=%d", devname.c_str(), &drive) == 2) {
817 dcr = find_device(jcr, devname, drive);
820 dev->dlock(); /* Use P to avoid indefinite block */
821 if (!dev->is_open()) {
822 if (!dev->is_busy()) {
823 unload_autochanger(dcr, -1);
825 if (dev->is_unmountable()) {
826 if (dev->unmount(0)) {
827 dir->fsend(_("3002 Device \"%s\" unmounted.\n"),
830 dir->fsend(_("3907 %s"), dev->bstrerror());
833 Dmsg0(90, "Device already unmounted\n");
834 dir->fsend(_("3901 Device \"%s\" is already unmounted.\n"),
837 } else if (dev->blocked() == BST_WAITING_FOR_SYSOP) {
838 Dmsg2(90, "%d waiter dev_block=%d. doing unmount\n", dev->num_waiting,
840 if (!unload_autochanger(dcr, -1)) {
841 /* ***FIXME**** what is this ???? */
845 if (dev->is_unmountable() && !dev->unmount(0)) {
846 dir->fsend(_("3907 %s"), dev->bstrerror());
848 dev->set_blocked(BST_UNMOUNTED_WAITING_FOR_SYSOP);
849 dir->fsend(_("3001 Device \"%s\" unmounted.\n"),
853 } else if (dev->blocked() == BST_DOING_ACQUIRE) {
854 dir->fsend(_("3902 Device \"%s\" is busy in acquire.\n"),
857 } else if (dev->blocked() == BST_WRITING_LABEL) {
858 dir->fsend(_("3903 Device \"%s\" is being labeled.\n"),
861 } else if (dev->is_busy()) {
862 send_dir_busy_message(dir, dev);
863 } else { /* device not being used */
864 Dmsg0(90, "Device not in use, unmounting\n");
865 /* On FreeBSD, I am having ASSERT() failures in block_device()
866 * and I can only imagine that the thread id that we are
867 * leaving in no_wait_id is being re-used. So here,
868 * we simply do it by hand. Gross, but a solution.
870 /* block_device(dev, BST_UNMOUNTED); replace with 2 lines below */
871 dev->set_blocked(BST_UNMOUNTED);
872 clear_thread_id(dev->no_wait_id);
873 if (!unload_autochanger(dcr, -1)) {
877 if (dev->is_unmountable() && !dev->unmount(0)) {
878 dir->fsend(_("3907 %s"), dev->bstrerror());
880 dir->fsend(_("3002 Device \"%s\" unmounted.\n"),
887 dir->fsend(_("3999 Device \"%s\" not found or could not be opened.\n"), devname.c_str());
890 /* NB dir->msg gets clobbered in bnet_fsend, so save command */
891 pm_strcpy(jcr->errmsg, dir->msg);
892 dir->fsend(_("3907 Error scanning unmount command: %s\n"), jcr->errmsg);
894 dir->signal(BNET_EOD);
900 * The truncate command will recycle a volume. The director can call this
901 * after purging a volume so that disk space will not be wasted. Only useful
902 * for File Storage, of course.
905 * It is currently disabled
907 static bool action_on_purge_cmd(JCR *jcr)
909 BSOCK *dir = jcr->dir_bsock;
911 char devname[MAX_NAME_LENGTH];
912 char volumename[MAX_NAME_LENGTH];
915 /* TODO: Need to find a free device and ask for slot to the director */
917 "action_on_purge %127s vol=%127s action=%d",
918 devname, volumename, &action)!= 5)
920 dir->fsend(_("3916 Error scanning action_on_purge command\n"));
923 unbash_spaces(volumename);
924 unbash_spaces(devname);
926 /* Check if action is correct */
927 if (action & AOP_TRUNCTATE) {
933 dir->signal(BNET_EOD);
939 * Release command from Director. This rewinds the device and if
940 * configured does a offline and ensures that Bacula will
941 * re-read the label of the tape before continuing. This gives
942 * the operator the chance to change the tape anytime before the
945 static bool release_cmd(JCR *jcr)
948 BSOCK *dir = jcr->dir_bsock;
953 if (sscanf(dir->msg, "release %127s drive=%d", devname.c_str(), &drive) == 2) {
954 dcr = find_device(jcr, devname, drive);
957 dev->dlock(); /* Use P to avoid indefinite block */
958 if (!dev->is_open()) {
959 if (!dev->is_busy()) {
960 unload_autochanger(dcr, -1);
962 Dmsg0(90, "Device already released\n");
963 dir->fsend(_("3921 Device \"%s\" already released.\n"),
966 } else if (dev->blocked() == BST_WAITING_FOR_SYSOP) {
967 Dmsg2(90, "%d waiter dev_block=%d.\n", dev->num_waiting,
969 unload_autochanger(dcr, -1);
970 dir->fsend(_("3922 Device \"%s\" waiting for sysop.\n"),
973 } else if (dev->blocked() == BST_UNMOUNTED_WAITING_FOR_SYSOP) {
974 Dmsg2(90, "%d waiter dev_block=%d. doing unmount\n", dev->num_waiting,
976 dir->fsend(_("3922 Device \"%s\" waiting for mount.\n"),
979 } else if (dev->blocked() == BST_DOING_ACQUIRE) {
980 dir->fsend(_("3923 Device \"%s\" is busy in acquire.\n"),
983 } else if (dev->blocked() == BST_WRITING_LABEL) {
984 dir->fsend(_("3914 Device \"%s\" is being labeled.\n"),
987 } else if (dev->is_busy()) {
988 send_dir_busy_message(dir, dev);
989 } else { /* device not being used */
990 Dmsg0(90, "Device not in use, releasing\n");
991 dcr->release_volume();
992 dir->fsend(_("3022 Device \"%s\" released.\n"),
998 dir->fsend(_("3999 Device \"%s\" not found or could not be opened.\n"), devname.c_str());
1001 /* NB dir->msg gets clobbered in bnet_fsend, so save command */
1002 pm_strcpy(jcr->errmsg, dir->msg);
1003 dir->fsend(_("3927 Error scanning release command: %s\n"), jcr->errmsg);
1005 dir->signal(BNET_EOD);
1009 static pthread_mutex_t bsr_mutex = PTHREAD_MUTEX_INITIALIZER;
1010 static uint32_t bsr_uniq = 0;
1012 static bool get_bootstrap_file(JCR *jcr, BSOCK *sock)
1014 POOLMEM *fname = get_pool_memory(PM_FNAME);
1018 if (jcr->RestoreBootstrap) {
1019 unlink(jcr->RestoreBootstrap);
1020 free_pool_memory(jcr->RestoreBootstrap);
1024 Mmsg(fname, "%s/%s.%s.%d.bootstrap", me->working_directory, me->hdr.name,
1025 jcr->Job, bsr_uniq);
1027 Dmsg1(400, "bootstrap=%s\n", fname);
1028 jcr->RestoreBootstrap = fname;
1029 bs = fopen(fname, "a+b"); /* create file */
1032 Jmsg(jcr, M_FATAL, 0, _("Could not create bootstrap file %s: ERR=%s\n"),
1033 jcr->RestoreBootstrap, be.bstrerror());
1036 Dmsg0(10, "=== Bootstrap file ===\n");
1037 while (sock->recv() >= 0) {
1038 Dmsg1(10, "%s", sock->msg);
1039 fputs(sock->msg, bs);
1042 Dmsg0(10, "=== end bootstrap file ===\n");
1043 jcr->bsr = parse_bsr(jcr, jcr->RestoreBootstrap);
1045 Jmsg(jcr, M_FATAL, 0, _("Error parsing bootstrap file.\n"));
1048 if (debug_level >= 10) {
1049 dump_bsr(jcr->bsr, true);
1051 /* If we got a bootstrap, we are reading, so create read volume list */
1052 create_restore_volume_list(jcr);
1056 unlink(jcr->RestoreBootstrap);
1057 free_pool_memory(jcr->RestoreBootstrap);
1058 jcr->RestoreBootstrap = NULL;
1060 sock->fsend(ERROR_bootstrap);
1063 return sock->fsend(OK_bootstrap);
1066 static bool bootstrap_cmd(JCR *jcr)
1068 return get_bootstrap_file(jcr, jcr->dir_bsock);
1072 * Autochanger command from Director
1074 static bool changer_cmd(JCR *jcr)
1077 BSOCK *dir = jcr->dir_bsock;
1080 const char *cmd = NULL;
1083 * A safe_cmd may call autochanger script but does not load/unload
1084 * slots so it can be done at the same time that the drive is open.
1086 bool safe_cmd = false;
1088 if (sscanf(dir->msg, "autochanger listall %127s", devname.c_str()) == 1) {
1090 safe_cmd = ok = true;
1091 } else if (sscanf(dir->msg, "autochanger list %127s", devname.c_str()) == 1) {
1093 safe_cmd = ok = true;
1094 } else if (sscanf(dir->msg, "autochanger slots %127s", devname.c_str()) == 1) {
1096 safe_cmd = ok = true;
1097 } else if (sscanf(dir->msg, "autochanger drives %127s", devname.c_str()) == 1) {
1099 safe_cmd = ok = true;
1102 dcr = find_device(jcr, devname, -1);
1105 dev->dlock(); /* Use P to avoid indefinite block */
1106 if (!dev->device->changer_res) {
1107 dir->fsend(_("3995 Device \"%s\" is not an autochanger.\n"),
1109 /* Under certain "safe" conditions, we can steal the lock */
1110 } else if (safe_cmd || !dev->is_open() || dev->can_steal_lock()) {
1111 autochanger_cmd(dcr, dir, cmd);
1112 } else if (dev->is_busy() || dev->is_blocked()) {
1113 send_dir_busy_message(dir, dev);
1114 } else { /* device not being used */
1115 autochanger_cmd(dcr, dir, cmd);
1120 dir->fsend(_("3999 Device \"%s\" not found or could not be opened.\n"), devname.c_str());
1122 } else { /* error on scanf */
1123 pm_strcpy(jcr->errmsg, dir->msg);
1124 dir->fsend(_("3908 Error scanning autochanger drives/list/slots command: %s\n"),
1127 dir->signal(BNET_EOD);
1132 * Read and return the Volume label
1134 static bool readlabel_cmd(JCR *jcr)
1137 BSOCK *dir = jcr->dir_bsock;
1140 int32_t Slot, drive;
1142 if (sscanf(dir->msg, "readlabel %127s Slot=%d drive=%d", devname.c_str(),
1143 &Slot, &drive) == 3) {
1144 dcr = find_device(jcr, devname, drive);
1147 dev->dlock(); /* Use P to avoid indefinite block */
1148 if (!dev->is_open()) {
1149 read_volume_label(jcr, dcr, dev, Slot);
1151 /* Under certain "safe" conditions, we can steal the lock */
1152 } else if (dev->can_steal_lock()) {
1153 read_volume_label(jcr, dcr, dev, Slot);
1154 } else if (dev->is_busy() || dev->is_blocked()) {
1155 send_dir_busy_message(dir, dev);
1156 } else { /* device not being used */
1157 read_volume_label(jcr, dcr, dev, Slot);
1162 dir->fsend(_("3999 Device \"%s\" not found or could not be opened.\n"), devname.c_str());
1165 pm_strcpy(jcr->errmsg, dir->msg);
1166 dir->fsend(_("3909 Error scanning readlabel command: %s\n"), jcr->errmsg);
1168 dir->signal(BNET_EOD);
1174 * Read the tape label
1176 * Enter with the mutex set
1178 static void read_volume_label(JCR *jcr, DCR *dcr, DEVICE *dev, int Slot)
1180 BSOCK *dir = jcr->dir_bsock;
1184 steal_device_lock(dev, &hold, BST_WRITING_LABEL);
1186 if (!try_autoload_device(jcr, dcr, Slot, "")) {
1187 goto bail_out; /* error */
1190 dev->clear_labeled(); /* force read of label */
1191 switch (read_dev_volume_label(dcr)) {
1193 /* DO NOT add quotes around the Volume name. It is scanned in the DIR */
1194 dir->fsend(_("3001 Volume=%s Slot=%d\n"), dev->VolHdr.VolumeName, Slot);
1195 Dmsg1(100, "Volume: %s\n", dev->VolHdr.VolumeName);
1198 dir->fsend(_("3902 Cannot mount Volume on Storage Device \"%s\" because:\n%s"),
1199 dev->print_name(), jcr->errmsg);
1204 give_back_device_lock(dev, &hold);
1208 static bool try_autoload_device(JCR *jcr, DCR *dcr, int slot, const char *VolName)
1210 BSOCK *dir = jcr->dir_bsock;
1212 bstrncpy(dcr->VolumeName, VolName, sizeof(dcr->VolumeName));
1213 dcr->VolCatInfo.Slot = slot;
1214 dcr->VolCatInfo.InChanger = slot > 0;
1215 if (autoload_device(dcr, 0, dir) < 0) { /* autoload if possible */
1221 static void send_dir_busy_message(BSOCK *dir, DEVICE *dev)
1223 if (dev->is_blocked()) {
1224 switch (dev->blocked()) {
1226 dir->fsend(_("3931 Device \"%s\" is BLOCKED. user unmounted.\n"),
1229 case BST_UNMOUNTED_WAITING_FOR_SYSOP:
1230 dir->fsend(_("3932 Device \"%s\" is BLOCKED. user unmounted during wait for media/mount.\n"),
1233 case BST_WAITING_FOR_SYSOP:
1234 dir->fsend(_("3933 Device \"%s\" is BLOCKED waiting for media.\n"),
1237 case BST_DOING_ACQUIRE:
1238 dir->fsend(_("3934 Device \"%s\" is being initialized.\n"),
1241 case BST_WRITING_LABEL:
1242 dir->fsend(_("3935 Device \"%s\" is blocked labeling a Volume.\n"),
1246 dir->fsend(_("3935 Device \"%s\" is blocked for unknown reason.\n"),
1250 } else if (dev->can_read()) {
1251 dir->fsend(_("3936 Device \"%s\" is busy reading.\n"),
1252 dev->print_name());;
1254 dir->fsend(_("3937 Device \"%s\" is busy with writers=%d reserved=%d.\n"),
1255 dev->print_name(), dev->num_writers, dev->num_reserved());