2 Bacula® - The Network Backup Solution
4 Copyright (C) 2001-2009 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 two of the GNU 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 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
53 /* Exported variables */
55 /* Imported variables */
56 extern BSOCK *filed_chan;
57 extern struct s_last_job last_job;
58 extern bool init_done;
60 /* Static variables */
61 static char derrmsg[] = "3900 Invalid command\n";
62 static char OKsetdebug[] = "3000 OK setdebug=%d\n";
63 static char invalid_cmd[] = "3997 Invalid command for a Director with Monitor directive enabled.\n";
64 static char OK_bootstrap[] = "3000 OK bootstrap\n";
65 static char ERROR_bootstrap[] = "3904 Error bootstrap\n";
67 /* Imported functions */
68 extern void terminate_child();
69 extern bool job_cmd(JCR *jcr);
70 extern bool use_cmd(JCR *jcr);
71 extern bool run_cmd(JCR *jcr);
72 extern bool status_cmd(JCR *sjcr);
73 extern bool qstatus_cmd(JCR *jcr);
74 //extern bool query_cmd(JCR *jcr);
76 /* Forward referenced functions */
77 static bool label_cmd(JCR *jcr);
78 static bool die_cmd(JCR *jcr);
79 static bool relabel_cmd(JCR *jcr);
80 static bool readlabel_cmd(JCR *jcr);
81 static bool release_cmd(JCR *jcr);
82 static bool setdebug_cmd(JCR *jcr);
83 static bool cancel_cmd(JCR *cjcr);
84 static bool mount_cmd(JCR *jcr);
85 static bool unmount_cmd(JCR *jcr);
86 static bool action_on_purge_cmd(JCR *jcr);
87 static bool bootstrap_cmd(JCR *jcr);
88 static bool changer_cmd(JCR *sjcr);
89 static bool do_label(JCR *jcr, int relabel);
90 static DCR *find_device(JCR *jcr, POOL_MEM &dev_name, int drive);
91 static void read_volume_label(JCR *jcr, DCR *dcr, DEVICE *dev, int Slot);
92 static void label_volume_if_ok(DCR *dcr, char *oldname,
93 char *newname, char *poolname,
94 int Slot, int relabel);
95 static bool try_autoload_device(JCR *jcr, DCR *dcr, int slot, const char *VolName);
96 static void send_dir_busy_message(BSOCK *dir, DEVICE *dev);
100 bool (*func)(JCR *jcr);
101 bool monitoraccess; /* set if monitors can access this cmd */
105 * The following are the recognized commands from the Director.
107 static struct s_cmds cmds[] = {
108 {"JobId=", job_cmd, 0}, /* start Job */
109 {"autochanger", changer_cmd, 0},
110 {"bootstrap", bootstrap_cmd, 0},
111 {"cancel", cancel_cmd, 0},
112 {".die", die_cmd, 0},
113 {"label", label_cmd, 0}, /* label a tape */
114 {"mount", mount_cmd, 0},
115 {"readlabel", readlabel_cmd, 0},
116 {"release", release_cmd, 0},
117 {"relabel", relabel_cmd, 0}, /* relabel a tape */
118 {"setdebug=", setdebug_cmd, 0}, /* set debug level */
119 {"status", status_cmd, 1},
120 {".status", qstatus_cmd, 1},
121 {"unmount", unmount_cmd, 0},
122 {"action_on_purge", action_on_purge_cmd, 0},
123 {"use storage=", use_cmd, 0},
125 // {"query", query_cmd, 0},
126 {NULL, NULL} /* list terminator */
131 * Connection request. We accept connections either from the
132 * Director or a Client (File daemon).
134 * Note, we are running as a seperate thread of the Storage daemon.
135 * and it is because a Director has made a connection with
136 * us on the "Message" channel.
138 * Basic tasks done here:
139 * - Create a JCR record
140 * - If it was from the FD, call handle_filed_connection()
141 * - Authenticate the Director
142 * - We wait for a command
143 * - We execute the command
144 * - We continue or exit depending on the return status
146 void *handle_connection_request(void *arg)
148 BSOCK *bs = (BSOCK *)arg;
156 if (bs->recv() <= 0) {
157 Emsg1(M_ERROR, 0, _("Connection request from %s failed.\n"), bs->who());
163 * Do a sanity check on the message received
165 if (bs->msglen < 25 || bs->msglen > (int)sizeof(name)) {
166 Dmsg1(000, "<filed: %s", bs->msg);
167 Emsg2(M_ERROR, 0, _("Invalid connection from %s. Len=%d\n"), bs->who(), bs->msglen);
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 reqeusts quit\n", cmds[i].cmd);
239 found = true; /* indicate command found */
243 if (!found) { /* command not found */
249 generate_daemon_event(jcr, "JobEnd");
250 dequeue_messages(jcr); /* send any queued messages */
251 bs->signal(BNET_TERMINATE);
253 /* ***FIXME*** remove for production */
254 sm_check(__FILE__, __LINE__, true);
260 * Force SD to die, and hopefully dump itself. Turned on only
261 * in development version.
263 static bool die_cmd(JCR *jcr)
268 Pmsg0(000, "I have been requested to die ...");
269 a = djcr->JobId; /* ref NULL pointer */
277 * Set debug level as requested by the Director
280 static bool setdebug_cmd(JCR *jcr)
282 BSOCK *dir = jcr->dir_bsock;
283 int level, trace_flag;
285 Dmsg1(10, "setdebug_cmd: %s", dir->msg);
286 if (sscanf(dir->msg, "setdebug=%d trace=%d", &level, &trace_flag) != 2 || level < 0) {
287 dir->fsend(_("3991 Bad setdebug command: %s\n"), dir->msg);
291 set_trace(trace_flag);
292 return dir->fsend(OKsetdebug, level);
299 static bool cancel_cmd(JCR *cjcr)
301 BSOCK *dir = cjcr->dir_bsock;
303 char Job[MAX_NAME_LENGTH];
306 if (sscanf(dir->msg, "cancel Job=%127s", Job) == 1) {
307 if (!(jcr=get_jcr_by_full_name(Job))) {
308 dir->fsend(_("3904 Job %s not found.\n"), Job);
310 oldStatus = jcr->JobStatus;
311 set_jcr_job_status(jcr, JS_Canceled);
312 if (!jcr->authenticated && oldStatus == JS_WaitFD) {
313 pthread_cond_signal(&jcr->job_start_wait); /* wake waiting thread */
315 if (jcr->file_bsock) {
316 bnet_sig(jcr->file_bsock, BNET_TERMINATE);
318 /* Still waiting for FD to connect, release it */
319 pthread_cond_signal(&jcr->job_start_wait); /* wake waiting job */
321 /* If thread waiting on mount, wake him */
322 if (jcr->dcr && jcr->dcr->dev && jcr->dcr->dev->waiting_for_mount()) {
323 pthread_cond_broadcast(&jcr->dcr->dev->wait_next_vol);
324 Dmsg1(100, "JobId=%u broadcast wait_device_release\n", (uint32_t)jcr->JobId);
325 pthread_cond_broadcast(&wait_device_release);
327 if (jcr->read_dcr && jcr->read_dcr->dev && jcr->read_dcr->dev->waiting_for_mount()) {
328 pthread_cond_broadcast(&jcr->read_dcr->dev->wait_next_vol);
329 Dmsg1(100, "JobId=%u broadcast wait_device_release\n", (uint32_t)jcr->JobId);
330 pthread_cond_broadcast(&wait_device_release);
332 Jmsg(jcr, M_INFO, 0, _("JobId=%d Job=\"%s\" marked to be canceled.\n"),
333 (int)jcr->JobId, jcr->Job);
334 dir->fsend(_("3000 Job %s marked to be canceled.\n"), jcr->Job);
338 dir->fsend(_("3903 Error scanning cancel command.\n"));
340 dir->signal(BNET_EOD);
348 static bool label_cmd(JCR *jcr)
350 return do_label(jcr, 0);
353 static bool relabel_cmd(JCR *jcr)
355 return do_label(jcr, 1);
358 static bool do_label(JCR *jcr, int relabel)
360 POOLMEM *newname, *oldname, *poolname, *mtype;
362 BSOCK *dir = jcr->dir_bsock;
369 newname = get_memory(dir->msglen+1);
370 oldname = get_memory(dir->msglen+1);
371 poolname = get_memory(dir->msglen+1);
372 mtype = get_memory(dir->msglen+1);
374 if (sscanf(dir->msg, "relabel %127s OldName=%127s NewName=%127s PoolName=%127s "
375 "MediaType=%127s Slot=%d drive=%d",
376 dev_name.c_str(), oldname, newname, poolname, mtype,
377 &slot, &drive) == 7) {
382 if (sscanf(dir->msg, "label %127s VolumeName=%127s PoolName=%127s "
383 "MediaType=%127s Slot=%d drive=%d",
384 dev_name.c_str(), newname, poolname, mtype, &slot, &drive) == 6) {
389 unbash_spaces(newname);
390 unbash_spaces(oldname);
391 unbash_spaces(poolname);
392 unbash_spaces(mtype);
393 dcr = find_device(jcr, dev_name, drive);
396 dev->dlock(); /* Use P to avoid indefinite block */
397 if (!dev->is_open() && !dev->is_busy()) {
398 Dmsg1(400, "Can %slabel. Device is not open\n", relabel?"re":"");
399 label_volume_if_ok(dcr, oldname, newname, poolname, slot, relabel);
401 /* Under certain "safe" conditions, we can steal the lock */
402 } else if (dev->can_steal_lock()) {
403 Dmsg0(400, "Can relabel. can_steal_lock\n");
404 label_volume_if_ok(dcr, oldname, newname, poolname, slot, relabel);
405 } else if (dev->is_busy() || dev->is_blocked()) {
406 send_dir_busy_message(dir, dev);
407 } else { /* device not being used */
408 Dmsg0(400, "Can relabel. device not used\n");
409 label_volume_if_ok(dcr, oldname, newname, poolname, slot, relabel);
414 dir->fsend(_("3999 Device \"%s\" not found or could not be opened.\n"), dev_name.c_str());
417 /* NB dir->msg gets clobbered in bnet_fsend, so save command */
418 pm_strcpy(jcr->errmsg, dir->msg);
419 dir->fsend(_("3903 Error scanning label command: %s\n"), jcr->errmsg);
421 free_memory(oldname);
422 free_memory(newname);
423 free_memory(poolname);
425 dir->signal(BNET_EOD);
430 * Read the tape label and determine if we can safely
431 * label the tape (not a Bacula volume), then label it.
433 * Enter with the mutex set
435 static void label_volume_if_ok(DCR *dcr, char *oldname,
436 char *newname, char *poolname,
437 int slot, int relabel)
439 BSOCK *dir = dcr->jcr->dir_bsock;
441 DEVICE *dev = dcr->dev;
444 const char *volname = (relabel == 1) ? oldname : newname;
447 steal_device_lock(dev, &hold, BST_WRITING_LABEL);
448 Dmsg1(100, "Stole device %s lock, writing label.\n", dev->print_name());
451 Dmsg0(90, "try_autoload_device - looking for volume_info\n");
452 if (!try_autoload_device(dcr->jcr, dcr, slot, volname)) {
453 goto bail_out; /* error */
456 /* Ensure that the device is open -- autoload_device() closes it */
457 if (dev->is_tape()) {
458 mode = OPEN_READ_WRITE;
460 mode = CREATE_READ_WRITE;
464 dev->truncating = true; /* let open() know we will truncate it */
466 /* Set old volume name for open if relabeling */
467 bstrncpy(dcr->VolCatInfo.VolCatName, volname, sizeof(dcr->VolCatInfo.VolCatName));
468 if (dev->open(dcr, mode) < 0) {
469 dir->fsend(_("3910 Unable to open device %s: ERR=%s\n"),
470 dev->print_name(), dev->bstrerror());
474 /* See what we have for a Volume */
475 label_status = read_dev_volume_label(dcr);
477 /* Set new volume name */
478 bstrncpy(dcr->VolCatInfo.VolCatName, newname, sizeof(dcr->VolCatInfo.VolCatName));
479 switch(label_status) {
481 case VOL_VERSION_ERROR:
482 case VOL_LABEL_ERROR:
486 "3920 Cannot label Volume because it is already labeled: \"%s\"\n"),
487 dev->VolHdr.VolumeName);
491 /* Relabel request. If oldname matches, continue */
492 if (strcmp(oldname, dev->VolHdr.VolumeName) != 0) {
493 dir->fsend(_("3921 Wrong volume mounted.\n"));
496 if (dev->label_type != B_BACULA_LABEL) {
497 dir->fsend(_("3922 Cannot relabel an ANSI/IBM labeled Volume.\n"));
500 /* Fall through wanted! */
503 if (!write_new_volume_label_to_dev(dcr, newname, poolname,
504 relabel, true /* write dvd now */)) {
505 dir->fsend(_("3912 Failed to label Volume: ERR=%s\n"), dev->bstrerror());
508 bstrncpy(dcr->VolumeName, newname, sizeof(dcr->VolumeName));
509 /* The following 3000 OK label. string is scanned in ua_label.c */
510 dir->fsend("3000 OK label. VolBytes=%s DVD=%d Volume=\"%s\" Device=%s\n",
511 edit_uint64(dev->VolCatInfo.VolCatBytes, ed1),
512 dev->is_dvd()?1:0, newname, dev->print_name());
515 dir->fsend(_("3914 Failed to label Volume (no media): ERR=%s\n"), dev->bstrerror());
518 dir->fsend(_("3913 Cannot label Volume. "
519 "Unknown status %d from read_volume_label()\n"), label_status);
524 if (!dev->is_open()) {
527 volume_unused(dcr); /* no longer using volume */
528 give_back_device_lock(dev, &hold);
534 * Read the tape label
536 * Enter with the mutex set
538 static bool read_label(DCR *dcr)
542 BSOCK *dir = jcr->dir_bsock;
544 DEVICE *dev = dcr->dev;
546 steal_device_lock(dev, &hold, BST_DOING_ACQUIRE);
548 dcr->VolumeName[0] = 0;
549 dev->clear_labeled(); /* force read of label */
550 switch (read_dev_volume_label(dcr)) {
552 dir->fsend(_("3001 Mounted Volume: %s\n"), dev->VolHdr.VolumeName);
556 dir->fsend(_("3902 Cannot mount Volume on Storage Device %s because:\n%s"),
557 dev->print_name(), jcr->errmsg);
562 give_back_device_lock(dev, &hold);
567 * Searches for device by name, and if found, creates a dcr and
570 static DCR *find_device(JCR *jcr, POOL_MEM &devname, int drive)
573 AUTOCHANGER *changer;
577 unbash_spaces(devname);
578 foreach_res(device, R_DEVICE) {
579 /* Find resource, and make sure we were able to open it */
580 if (strcmp(device->hdr.name, devname.c_str()) == 0) {
582 device->dev = init_dev(jcr, device);
585 Jmsg(jcr, M_WARNING, 0, _("\n"
586 " Device \"%s\" requested by DIR could not be opened or does not exist.\n"),
590 Dmsg1(20, "Found device %s\n", device->hdr.name);
596 foreach_res(changer, R_AUTOCHANGER) {
597 /* Find resource, and make sure we were able to open it */
598 if (strcmp(devname.c_str(), changer->hdr.name) == 0) {
599 /* Try each device in this AutoChanger */
600 foreach_alist(device, changer->device) {
601 Dmsg1(100, "Try changer device %s\n", device->hdr.name);
603 device->dev = init_dev(jcr, device);
606 Dmsg1(100, "Device %s could not be opened. Skipped\n", devname.c_str());
607 Jmsg(jcr, M_WARNING, 0, _("\n"
608 " Device \"%s\" in changer \"%s\" requested by DIR could not be opened or does not exist.\n"),
609 device->hdr.name, devname.c_str());
612 if (!device->dev->autoselect) {
613 Dmsg1(100, "Device %s not autoselect skipped.\n", devname.c_str());
614 continue; /* device is not available */
616 if (drive < 0 || drive == (int)device->dev->drive_index) {
617 Dmsg1(20, "Found changer device %s\n", device->hdr.name);
621 Dmsg3(100, "Device %s drive wrong: want=%d got=%d skipping\n",
622 devname.c_str(), drive, (int)device->dev->drive_index);
624 break; /* we found it but could not open a device */
630 Dmsg1(100, "Found device %s\n", device->hdr.name);
631 dcr = new_dcr(jcr, NULL, device->dev);
632 dcr->device = device;
639 * Mount command from Director
641 static bool mount_cmd(JCR *jcr)
644 BSOCK *dir = jcr->dir_bsock;
651 ok = sscanf(dir->msg, "mount %127s drive=%d slot=%d", devname.c_str(),
654 ok = sscanf(dir->msg, "mount %127s drive=%d", devname.c_str(), &drive) == 2;
657 dcr = find_device(jcr, devname, drive);
660 dev->dlock(); /* Use P to avoid indefinite block */
661 Dmsg2(100, "mount cmd blocked=%d must_unload=%d\n", dev->blocked(),
663 switch (dev->blocked()) { /* device blocked? */
664 case BST_WAITING_FOR_SYSOP:
665 /* Someone is waiting, wake him */
666 Dmsg0(100, "Waiting for mount. Attempting to wake thread\n");
667 dev->set_blocked(BST_MOUNT);
668 dir->fsend("3001 OK mount requested. %sDevice=%s\n",
669 slot>0?_("Specified slot ignored. "):"",
671 pthread_cond_broadcast(&dev->wait_next_vol);
672 Dmsg1(100, "JobId=%u broadcast wait_device_release\n", (uint32_t)dcr->jcr->JobId);
673 pthread_cond_broadcast(&wait_device_release);
676 /* In both of these two cases, we (the user) unmounted the Volume */
677 case BST_UNMOUNTED_WAITING_FOR_SYSOP:
679 if (dev->is_autochanger() && slot > 0) {
680 try_autoload_device(jcr, dcr, slot, "");
682 /* We freed the device, so reopen it and wake any waiting threads */
683 if (dev->open(dcr, OPEN_READ_ONLY) < 0) {
684 dir->fsend(_("3901 Unable to open device %s: ERR=%s\n"),
685 dev->print_name(), dev->bstrerror());
686 if (dev->blocked() == BST_UNMOUNTED) {
687 /* We blocked the device, so unblock it */
688 Dmsg0(100, "Unmounted. Unblocking device\n");
693 read_dev_volume_label(dcr);
694 if (dev->blocked() == BST_UNMOUNTED) {
695 /* We blocked the device, so unblock it */
696 Dmsg0(100, "Unmounted. Unblocking device\n");
697 read_label(dcr); /* this should not be necessary */
700 Dmsg0(100, "Unmounted waiting for mount. Attempting to wake thread\n");
701 dev->set_blocked(BST_MOUNT);
703 if (dev->is_labeled()) {
704 dir->fsend(_("3001 Device %s is mounted with Volume \"%s\"\n"),
705 dev->print_name(), dev->VolHdr.VolumeName);
707 dir->fsend(_("3905 Device %s open but no Bacula volume is mounted.\n"
708 "If this is not a blank tape, try unmounting and remounting the Volume.\n"),
711 pthread_cond_broadcast(&dev->wait_next_vol);
712 Dmsg1(100, "JobId=%u broadcast wait_device_release\n", (uint32_t)dcr->jcr->JobId);
713 pthread_cond_broadcast(&wait_device_release);
716 case BST_DOING_ACQUIRE:
717 dir->fsend(_("3001 Device %s is doing acquire.\n"),
721 case BST_WRITING_LABEL:
722 dir->fsend(_("3903 Device %s is being labeled.\n"),
726 case BST_NOT_BLOCKED:
727 if (dev->is_autochanger() && slot > 0) {
728 try_autoload_device(jcr, dcr, slot, "");
730 if (dev->is_open()) {
731 if (dev->is_labeled()) {
732 dir->fsend(_("3001 Device %s is mounted with Volume \"%s\"\n"),
733 dev->print_name(), dev->VolHdr.VolumeName);
735 dir->fsend(_("3905 Device %s open but no Bacula volume is mounted.\n"
736 "If this is not a blank tape, try unmounting and remounting the Volume.\n"),
739 } else if (dev->is_tape()) {
740 if (dev->open(dcr, OPEN_READ_ONLY) < 0) {
741 dir->fsend(_("3901 Unable to open device %s: ERR=%s\n"),
742 dev->print_name(), dev->bstrerror());
746 if (dev->is_labeled()) {
747 dir->fsend(_("3001 Device %s is already 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_unmountable()) {
756 dir->fsend(_("3002 Device %s is mounted.\n"),
759 dir->fsend(_("3907 %s"), dev->bstrerror());
761 } else { /* must be file */
762 dir->fsend(_("3906 File device %s is always mounted.\n"),
764 pthread_cond_broadcast(&dev->wait_next_vol);
765 Dmsg1(100, "JobId=%u broadcast wait_device_release\n", (uint32_t)dcr->jcr->JobId);
766 pthread_cond_broadcast(&wait_device_release);
771 dir->fsend(_("3905 Bizarre wait state %d\n"), dev->blocked());
777 dir->fsend(_("3999 Device \"%s\" not found or could not be opened.\n"), devname.c_str());
780 pm_strcpy(jcr->errmsg, dir->msg);
781 dir->fsend(_("3909 Error scanning mount command: %s\n"), jcr->errmsg);
783 dir->signal(BNET_EOD);
788 * unmount command from Director
790 static bool unmount_cmd(JCR *jcr)
793 BSOCK *dir = jcr->dir_bsock;
798 if (sscanf(dir->msg, "unmount %127s drive=%d", devname.c_str(), &drive) == 2) {
799 dcr = find_device(jcr, devname, drive);
802 dev->dlock(); /* Use P to avoid indefinite block */
803 if (!dev->is_open()) {
804 if (!dev->is_busy()) {
805 unload_autochanger(dcr, -1);
807 if (dev->is_unmountable()) {
808 if (dev->unmount(0)) {
809 dir->fsend(_("3002 Device %s unmounted.\n"),
812 dir->fsend(_("3907 %s"), dev->bstrerror());
815 Dmsg0(90, "Device already unmounted\n");
816 dir->fsend(_("3901 Device %s is already unmounted.\n"),
819 } else if (dev->blocked() == BST_WAITING_FOR_SYSOP) {
820 Dmsg2(90, "%d waiter dev_block=%d. doing unmount\n", dev->num_waiting,
822 if (!unload_autochanger(dcr, -1)) {
823 /* ***FIXME**** what is this ???? */
827 if (dev->is_unmountable() && !dev->unmount(0)) {
828 dir->fsend(_("3907 %s"), dev->bstrerror());
830 dev->set_blocked(BST_UNMOUNTED_WAITING_FOR_SYSOP);
831 dir->fsend(_("3001 Device %s unmounted.\n"),
835 } else if (dev->blocked() == BST_DOING_ACQUIRE) {
836 dir->fsend(_("3902 Device %s is busy in acquire.\n"),
839 } else if (dev->blocked() == BST_WRITING_LABEL) {
840 dir->fsend(_("3903 Device %s is being labeled.\n"),
843 } else if (dev->is_busy()) {
844 send_dir_busy_message(dir, dev);
845 } else { /* device not being used */
846 Dmsg0(90, "Device not in use, unmounting\n");
847 /* On FreeBSD, I am having ASSERT() failures in block_device()
848 * and I can only imagine that the thread id that we are
849 * leaving in no_wait_id is being re-used. So here,
850 * we simply do it by hand. Gross, but a solution.
852 /* block_device(dev, BST_UNMOUNTED); replace with 2 lines below */
853 dev->set_blocked(BST_UNMOUNTED);
854 clear_thread_id(dev->no_wait_id);
855 if (!unload_autochanger(dcr, -1)) {
859 if (dev->is_unmountable() && !dev->unmount(0)) {
860 dir->fsend(_("3907 %s"), dev->bstrerror());
862 dir->fsend(_("3002 Device %s unmounted.\n"),
869 dir->fsend(_("3999 Device \"%s\" not found or could not be opened.\n"), devname.c_str());
872 /* NB dir->msg gets clobbered in bnet_fsend, so save command */
873 pm_strcpy(jcr->errmsg, dir->msg);
874 dir->fsend(_("3907 Error scanning unmount command: %s\n"), jcr->errmsg);
876 dir->signal(BNET_EOD);
881 * The truncate command will recycle a volume. The director can call this
882 * after purging a volume so that disk space will not be wasted. Only useful
883 * for File Storage, of course.
886 static bool action_on_purge_cmd(JCR *jcr)
890 BSOCK *dir = jcr->dir_bsock;
895 if (sscanf(dir->msg, "action_on_purge %127s vol=%s action=%d",
896 devname.c_str(), volumename.c_str(), &action) != 3) {
897 dir->fsend(_("3916 Error scanning action_on_purge command\n"));
900 unbash_spaces(volumename.c_str());
902 /* FIXME: autochanger, drive = 0? how can we avoid that? we only work on
905 if ((dcr = find_device(jcr, devname, 0)) == NULL) {
906 dir->fsend(_("3999 Device \"%s\" not found or could not be opened.\n"), devname.c_str());
912 /* Store the VolumeName for opening and re-labeling the volume */
913 bstrncpy(dcr->VolumeName, volumename.c_str(), sizeof(dcr->VolumeName));
914 bstrncpy(dev->VolHdr.VolumeName, volumename.c_str(), sizeof(dev->VolHdr.VolumeName));
916 /* Re-write the label with the recycle flag */
917 if (rewrite_volume_label(dcr, true)) {
918 dir->fsend(_("3917 Volume recycled\n"));
920 dir->fsend(_("3918 Recycle failed\n"));
924 dir->signal(BNET_EOD);
929 * Release command from Director. This rewinds the device and if
930 * configured does a offline and ensures that Bacula will
931 * re-read the label of the tape before continuing. This gives
932 * the operator the chance to change the tape anytime before the
935 static bool release_cmd(JCR *jcr)
938 BSOCK *dir = jcr->dir_bsock;
943 if (sscanf(dir->msg, "release %127s drive=%d", devname.c_str(), &drive) == 2) {
944 dcr = find_device(jcr, devname, drive);
947 dev->dlock(); /* Use P to avoid indefinite block */
948 if (!dev->is_open()) {
949 if (!dev->is_busy()) {
950 unload_autochanger(dcr, -1);
952 Dmsg0(90, "Device already released\n");
953 dir->fsend(_("3921 Device %s already released.\n"),
956 } else if (dev->blocked() == BST_WAITING_FOR_SYSOP) {
957 Dmsg2(90, "%d waiter dev_block=%d.\n", dev->num_waiting,
959 unload_autochanger(dcr, -1);
960 dir->fsend(_("3922 Device %s waiting for sysop.\n"),
963 } else if (dev->blocked() == BST_UNMOUNTED_WAITING_FOR_SYSOP) {
964 Dmsg2(90, "%d waiter dev_block=%d. doing unmount\n", dev->num_waiting,
966 dir->fsend(_("3922 Device %s waiting for mount.\n"),
969 } else if (dev->blocked() == BST_DOING_ACQUIRE) {
970 dir->fsend(_("3923 Device %s is busy in acquire.\n"),
973 } else if (dev->blocked() == BST_WRITING_LABEL) {
974 dir->fsend(_("3914 Device %s is being labeled.\n"),
977 } else if (dev->is_busy()) {
978 send_dir_busy_message(dir, dev);
979 } else { /* device not being used */
980 Dmsg0(90, "Device not in use, releasing\n");
981 dcr->release_volume();
982 dir->fsend(_("3022 Device %s released.\n"),
988 dir->fsend(_("3999 Device \"%s\" not found or could not be opened.\n"), devname.c_str());
991 /* NB dir->msg gets clobbered in bnet_fsend, so save command */
992 pm_strcpy(jcr->errmsg, dir->msg);
993 dir->fsend(_("3927 Error scanning release command: %s\n"), jcr->errmsg);
995 dir->signal(BNET_EOD);
999 static pthread_mutex_t bsr_mutex = PTHREAD_MUTEX_INITIALIZER;
1000 static uint32_t bsr_uniq = 0;
1002 static bool get_bootstrap_file(JCR *jcr, BSOCK *sock)
1004 POOLMEM *fname = get_pool_memory(PM_FNAME);
1008 if (jcr->RestoreBootstrap) {
1009 unlink(jcr->RestoreBootstrap);
1010 free_pool_memory(jcr->RestoreBootstrap);
1014 Mmsg(fname, "%s/%s.%s.%d.bootstrap", me->working_directory, me->hdr.name,
1015 jcr->Job, bsr_uniq);
1017 Dmsg1(400, "bootstrap=%s\n", fname);
1018 jcr->RestoreBootstrap = fname;
1019 bs = fopen(fname, "a+b"); /* create file */
1022 Jmsg(jcr, M_FATAL, 0, _("Could not create bootstrap file %s: ERR=%s\n"),
1023 jcr->RestoreBootstrap, be.bstrerror());
1026 Dmsg0(10, "=== Bootstrap file ===\n");
1027 while (sock->recv() >= 0) {
1028 Dmsg1(10, "%s", sock->msg);
1029 fputs(sock->msg, bs);
1032 Dmsg0(10, "=== end bootstrap file ===\n");
1033 jcr->bsr = parse_bsr(jcr, jcr->RestoreBootstrap);
1035 Jmsg(jcr, M_FATAL, 0, _("Error parsing bootstrap file.\n"));
1038 if (debug_level >= 10) {
1039 dump_bsr(jcr->bsr, true);
1041 /* If we got a bootstrap, we are reading, so create read volume list */
1042 create_restore_volume_list(jcr);
1046 unlink(jcr->RestoreBootstrap);
1047 free_pool_memory(jcr->RestoreBootstrap);
1048 jcr->RestoreBootstrap = NULL;
1050 sock->fsend(ERROR_bootstrap);
1053 return sock->fsend(OK_bootstrap);
1056 static bool bootstrap_cmd(JCR *jcr)
1058 return get_bootstrap_file(jcr, jcr->dir_bsock);
1062 * Autochanger command from Director
1064 static bool changer_cmd(JCR *jcr)
1067 BSOCK *dir = jcr->dir_bsock;
1070 const char *cmd = NULL;
1073 * A safe_cmd may call autochanger script but does not load/unload
1074 * slots so it can be done at the same time that the drive is open.
1076 bool safe_cmd = false;
1078 if (sscanf(dir->msg, "autochanger listall %127s", devname.c_str()) == 1) {
1080 safe_cmd = ok = true;
1081 } else if (sscanf(dir->msg, "autochanger list %127s", devname.c_str()) == 1) {
1083 safe_cmd = ok = true;
1084 } else if (sscanf(dir->msg, "autochanger slots %127s", devname.c_str()) == 1) {
1086 safe_cmd = ok = true;
1087 } else if (sscanf(dir->msg, "autochanger drives %127s", devname.c_str()) == 1) {
1089 safe_cmd = ok = true;
1092 dcr = find_device(jcr, devname, -1);
1095 dev->dlock(); /* Use P to avoid indefinite block */
1096 if (!dev->device->changer_res) {
1097 dir->fsend(_("3995 Device %s is not an autochanger.\n"),
1099 /* Under certain "safe" conditions, we can steal the lock */
1100 } else if (safe_cmd || !dev->is_open() || dev->can_steal_lock()) {
1101 autochanger_cmd(dcr, dir, cmd);
1102 } else if (dev->is_busy() || dev->is_blocked()) {
1103 send_dir_busy_message(dir, dev);
1104 } else { /* device not being used */
1105 autochanger_cmd(dcr, dir, cmd);
1110 dir->fsend(_("3999 Device \"%s\" not found or could not be opened.\n"), devname.c_str());
1112 } else { /* error on scanf */
1113 pm_strcpy(jcr->errmsg, dir->msg);
1114 dir->fsend(_("3908 Error scanning autocharger drives/list/slots command: %s\n"),
1117 dir->signal(BNET_EOD);
1122 * Read and return the Volume label
1124 static bool readlabel_cmd(JCR *jcr)
1127 BSOCK *dir = jcr->dir_bsock;
1133 if (sscanf(dir->msg, "readlabel %127s Slot=%d drive=%d", devname.c_str(),
1134 &Slot, &drive) == 3) {
1135 dcr = find_device(jcr, devname, drive);
1138 dev->dlock(); /* Use P to avoid indefinite block */
1139 if (!dev->is_open()) {
1140 read_volume_label(jcr, dcr, dev, Slot);
1142 /* Under certain "safe" conditions, we can steal the lock */
1143 } else if (dev->can_steal_lock()) {
1144 read_volume_label(jcr, dcr, dev, Slot);
1145 } else if (dev->is_busy() || dev->is_blocked()) {
1146 send_dir_busy_message(dir, dev);
1147 } else { /* device not being used */
1148 read_volume_label(jcr, dcr, dev, Slot);
1153 dir->fsend(_("3999 Device \"%s\" not found or could not be opened.\n"), devname.c_str());
1156 pm_strcpy(jcr->errmsg, dir->msg);
1157 dir->fsend(_("3909 Error scanning readlabel command: %s\n"), jcr->errmsg);
1159 dir->signal(BNET_EOD);
1165 * Read the tape label
1167 * Enter with the mutex set
1169 static void read_volume_label(JCR *jcr, DCR *dcr, DEVICE *dev, int Slot)
1171 BSOCK *dir = jcr->dir_bsock;
1175 steal_device_lock(dev, &hold, BST_WRITING_LABEL);
1177 if (!try_autoload_device(jcr, dcr, Slot, "")) {
1178 goto bail_out; /* error */
1181 dev->clear_labeled(); /* force read of label */
1182 switch (read_dev_volume_label(dcr)) {
1184 /* DO NOT add quotes around the Volume name. It is scanned in the DIR */
1185 dir->fsend(_("3001 Volume=%s Slot=%d\n"), dev->VolHdr.VolumeName, Slot);
1186 Dmsg1(100, "Volume: %s\n", dev->VolHdr.VolumeName);
1189 dir->fsend(_("3902 Cannot mount Volume on Storage Device %s because:\n%s"),
1190 dev->print_name(), jcr->errmsg);
1195 give_back_device_lock(dev, &hold);
1199 static bool try_autoload_device(JCR *jcr, DCR *dcr, int slot, const char *VolName)
1201 BSOCK *dir = jcr->dir_bsock;
1203 bstrncpy(dcr->VolumeName, VolName, sizeof(dcr->VolumeName));
1204 dcr->VolCatInfo.Slot = slot;
1205 dcr->VolCatInfo.InChanger = slot > 0;
1206 if (autoload_device(dcr, 0, dir) < 0) { /* autoload if possible */
1212 static void send_dir_busy_message(BSOCK *dir, DEVICE *dev)
1214 if (dev->is_blocked()) {
1215 switch (dev->blocked()) {
1217 dir->fsend(_("3931 Device %s is BLOCKED. user unmounted.\n"),
1220 case BST_UNMOUNTED_WAITING_FOR_SYSOP:
1221 dir->fsend(_("3932 Device %s is BLOCKED. user unmounted during wait for media/mount.\n"),
1224 case BST_WAITING_FOR_SYSOP:
1225 dir->fsend(_("3933 Device %s is BLOCKED waiting for media.\n"),
1228 case BST_DOING_ACQUIRE:
1229 dir->fsend(_("3934 Device %s is being initialized.\n"),
1232 case BST_WRITING_LABEL:
1233 dir->fsend(_("3935 Device %s is blocked labeling a Volume.\n"),
1237 dir->fsend(_("3935 Device %s is blocked for unknown reason.\n"),
1241 } else if (dev->can_read()) {
1242 dir->fsend(_("3936 Device %s is busy reading.\n"),
1243 dev->print_name());;
1245 dir->fsend(_("3937 Device %s is busy with %d writer(s).\n"),
1246 dev->print_name(), dev->num_writers);