2 Bacula® - The Network Backup Solution
4 Copyright (C) 2001-2008 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 bootstrap_cmd(JCR *jcr);
87 static bool changer_cmd(JCR *sjcr);
88 static bool do_label(JCR *jcr, int relabel);
89 static DCR *find_device(JCR *jcr, POOL_MEM &dev_name, int drive);
90 static void read_volume_label(JCR *jcr, DCR *dcr, DEVICE *dev, int Slot);
91 static void label_volume_if_ok(DCR *dcr, char *oldname,
92 char *newname, char *poolname,
93 int Slot, int relabel);
94 static bool try_autoload_device(JCR *jcr, DCR *dcr, int slot, const char *VolName);
95 static void send_dir_busy_message(BSOCK *dir, DEVICE *dev);
99 bool (*func)(JCR *jcr);
100 bool monitoraccess; /* set if monitors can access this cmd */
104 * The following are the recognized commands from the Director.
106 static struct s_cmds cmds[] = {
107 {"JobId=", job_cmd, 0}, /* start Job */
108 {"autochanger", changer_cmd, 0},
109 {"bootstrap", bootstrap_cmd, 0},
110 {"cancel", cancel_cmd, 0},
111 {".die", die_cmd, 0},
112 {"label", label_cmd, 0}, /* label a tape */
113 {"mount", mount_cmd, 0},
114 {"readlabel", readlabel_cmd, 0},
115 {"release", release_cmd, 0},
116 {"relabel", relabel_cmd, 0}, /* relabel a tape */
117 {"setdebug=", setdebug_cmd, 0}, /* set debug level */
118 {"status", status_cmd, 1},
119 {".status", qstatus_cmd, 1},
120 {"unmount", unmount_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());
161 * Do a sanity check on the message received
163 if (bs->msglen < 25 || bs->msglen > (int)sizeof(name)) {
164 Dmsg1(000, "<filed: %s", bs->msg);
165 Emsg2(M_ERROR, 0, _("Invalid connection from %s. Len=%d\n"), bs->who(), bs->msglen);
170 * See if this is a File daemon connection. If so
173 Dmsg1(110, "Conn: %s", bs->msg);
174 if (debug_level == 3) {
175 Dmsg1(000, "<filed: %s", bs->msg);
177 if (sscanf(bs->msg, "Hello Start Job %127s", name) == 1) {
178 Dmsg1(110, "Got a FD connection at %s\n", bstrftimes(tbuf, sizeof(tbuf),
179 (utime_t)time(NULL)));
180 Dmsg1(50, "%s", bs->msg);
181 handle_filed_connection(bs, name);
186 * This is a connection from the Director, so setup a JCR
188 Dmsg1(110, "Got a DIR connection at %s\n", bstrftimes(tbuf, sizeof(tbuf),
189 (utime_t)time(NULL)));
190 jcr = new_jcr(sizeof(JCR), stored_free_jcr); /* create Job Control Record */
191 jcr->dir_bsock = bs; /* save Director bsock */
192 jcr->dir_bsock->set_jcr(jcr);
193 jcr->dcrs = New(alist(10, not_owned_by_alist));
194 /* Initialize FD start condition variable */
195 int errstat = pthread_cond_init(&jcr->job_start_wait, NULL);
198 Jmsg1(jcr, M_FATAL, 0, _("Unable to init job cond variable: ERR=%s\n"), be.bstrerror(errstat));
202 Dmsg0(1000, "stored in start_job\n");
205 * Authenticate the Director
207 if (!authenticate_director(jcr)) {
208 Jmsg(jcr, M_FATAL, 0, _("Unable to authenticate Director\n"));
211 Dmsg0(90, "Message channel init completed.\n");
213 for (quit=false; !quit;) {
215 if ((bnet_stat = bs->recv()) <= 0) {
216 break; /* connection terminated */
218 Dmsg1(199, "<dird: %s\n", bs->msg);
219 /* Ensure that device initialization is complete */
224 for (i=0; cmds[i].cmd; i++) {
225 if (strncmp(cmds[i].cmd, bs->msg, strlen(cmds[i].cmd)) == 0) {
226 if ((!cmds[i].monitoraccess) && (jcr->director->monitor)) {
227 Dmsg1(100, "Command \"%s\" is invalid.\n", cmds[i].cmd);
228 bs->fsend(invalid_cmd);
229 bs->signal(BNET_EOD);
232 Dmsg1(200, "Do command: %s\n", cmds[i].cmd);
233 if (!cmds[i].func(jcr)) { /* do command */
234 quit = true; /* error, get out */
235 Dmsg1(190, "Command %s reqeusts quit\n", cmds[i].cmd);
237 found = true; /* indicate command found */
241 if (!found) { /* command not found */
247 generate_daemon_event(jcr, "JobEnd");
248 dequeue_messages(jcr); /* send any queued messages */
249 bs->signal(BNET_TERMINATE);
256 * Force SD to die, and hopefully dump itself. Turned on only
257 * in development version.
259 static bool die_cmd(JCR *jcr)
264 Pmsg0(000, "I have been requested to die ...");
265 a = djcr->JobId; /* ref NULL pointer */
273 * Set debug level as requested by the Director
276 static bool setdebug_cmd(JCR *jcr)
278 BSOCK *dir = jcr->dir_bsock;
279 int level, trace_flag;
281 Dmsg1(10, "setdebug_cmd: %s", dir->msg);
282 if (sscanf(dir->msg, "setdebug=%d trace=%d", &level, &trace_flag) != 2 || level < 0) {
283 dir->fsend(_("3991 Bad setdebug command: %s\n"), dir->msg);
287 set_trace(trace_flag);
288 return dir->fsend(OKsetdebug, level);
295 static bool cancel_cmd(JCR *cjcr)
297 BSOCK *dir = cjcr->dir_bsock;
299 char Job[MAX_NAME_LENGTH];
302 if (sscanf(dir->msg, "cancel Job=%127s", Job) == 1) {
303 if (!(jcr=get_jcr_by_full_name(Job))) {
304 dir->fsend(_("3904 Job %s not found.\n"), Job);
306 oldStatus = jcr->JobStatus;
307 set_jcr_job_status(jcr, JS_Canceled);
308 if (!jcr->authenticated && oldStatus == JS_WaitFD) {
309 pthread_cond_signal(&jcr->job_start_wait); /* wake waiting thread */
311 if (jcr->file_bsock) {
312 bnet_sig(jcr->file_bsock, BNET_TERMINATE);
314 /* Still waiting for FD to connect, release it */
315 pthread_cond_signal(&jcr->job_start_wait); /* wake waiting job */
317 /* If thread waiting on mount, wake him */
318 if (jcr->dcr && jcr->dcr->dev && jcr->dcr->dev->waiting_for_mount()) {
319 pthread_cond_broadcast(&jcr->dcr->dev->wait_next_vol);
320 Dmsg1(100, "JobId=%u broadcast wait_device_release\n", (uint32_t)jcr->JobId);
321 pthread_cond_broadcast(&wait_device_release);
323 if (jcr->read_dcr && jcr->read_dcr->dev && jcr->read_dcr->dev->waiting_for_mount()) {
324 pthread_cond_broadcast(&jcr->read_dcr->dev->wait_next_vol);
325 Dmsg1(100, "JobId=%u broadcast wait_device_release\n", (uint32_t)jcr->JobId);
326 pthread_cond_broadcast(&wait_device_release);
328 Jmsg(jcr, M_INFO, 0, _("Job %s marked to be canceled.\n"), jcr->Job);
329 dir->fsend(_("3000 Job %s marked to be canceled.\n"), jcr->Job);
333 dir->fsend(_("3903 Error scanning cancel command.\n"));
335 dir->signal(BNET_EOD);
343 static bool label_cmd(JCR *jcr)
345 return do_label(jcr, 0);
348 static bool relabel_cmd(JCR *jcr)
350 return do_label(jcr, 1);
353 static bool do_label(JCR *jcr, int relabel)
355 POOLMEM *newname, *oldname, *poolname, *mtype;
357 BSOCK *dir = jcr->dir_bsock;
364 newname = get_memory(dir->msglen+1);
365 oldname = get_memory(dir->msglen+1);
366 poolname = get_memory(dir->msglen+1);
367 mtype = get_memory(dir->msglen+1);
369 if (sscanf(dir->msg, "relabel %127s OldName=%127s NewName=%127s PoolName=%127s "
370 "MediaType=%127s Slot=%d drive=%d",
371 dev_name.c_str(), oldname, newname, poolname, mtype,
372 &slot, &drive) == 7) {
377 if (sscanf(dir->msg, "label %127s VolumeName=%127s PoolName=%127s "
378 "MediaType=%127s Slot=%d drive=%d",
379 dev_name.c_str(), newname, poolname, mtype, &slot, &drive) == 6) {
384 unbash_spaces(newname);
385 unbash_spaces(oldname);
386 unbash_spaces(poolname);
387 unbash_spaces(mtype);
388 dcr = find_device(jcr, dev_name, drive);
391 dev->dlock(); /* Use P to avoid indefinite block */
392 if (!dev->is_open() && !dev->is_busy()) {
393 Dmsg1(400, "Can %slabel. Device is not open\n", relabel?"re":"");
394 label_volume_if_ok(dcr, oldname, newname, poolname, slot, relabel);
396 /* Under certain "safe" conditions, we can steal the lock */
397 } else if (dev->can_steal_lock()) {
398 Dmsg0(400, "Can relabel. can_steal_lock\n");
399 label_volume_if_ok(dcr, oldname, newname, poolname, slot, relabel);
400 } else if (dev->is_busy() || dev->is_blocked()) {
401 send_dir_busy_message(dir, dev);
402 } else { /* device not being used */
403 Dmsg0(400, "Can relabel. device not used\n");
404 label_volume_if_ok(dcr, oldname, newname, poolname, slot, relabel);
409 dir->fsend(_("3999 Device \"%s\" not found or could not be opened.\n"), dev_name.c_str());
412 /* NB dir->msg gets clobbered in bnet_fsend, so save command */
413 pm_strcpy(jcr->errmsg, dir->msg);
414 dir->fsend(_("3903 Error scanning label command: %s\n"), jcr->errmsg);
416 free_memory(oldname);
417 free_memory(newname);
418 free_memory(poolname);
420 dir->signal(BNET_EOD);
425 * Read the tape label and determine if we can safely
426 * label the tape (not a Bacula volume), then label it.
428 * Enter with the mutex set
430 static void label_volume_if_ok(DCR *dcr, char *oldname,
431 char *newname, char *poolname,
432 int slot, int relabel)
434 BSOCK *dir = dcr->jcr->dir_bsock;
436 DEVICE *dev = dcr->dev;
439 const char *volname = (relabel == 1) ? oldname : newname;
442 steal_device_lock(dev, &hold, BST_WRITING_LABEL);
443 Dmsg1(100, "Stole device %s lock, writing label.\n", dev->print_name());
446 Dmsg0(90, "try_autoload_device - looking for volume_info\n");
447 if (!try_autoload_device(dcr->jcr, dcr, slot, volname)) {
448 goto bail_out; /* error */
451 /* Ensure that the device is open -- autoload_device() closes it */
452 if (dev->is_tape()) {
453 mode = OPEN_READ_WRITE;
455 mode = CREATE_READ_WRITE;
459 dev->truncating = true; /* let open() know we will truncate it */
461 /* Set old volume name for open if relabeling */
462 bstrncpy(dcr->VolCatInfo.VolCatName, volname, sizeof(dcr->VolCatInfo.VolCatName));
463 if (dev->open(dcr, mode) < 0) {
464 dir->fsend(_("3910 Unable to open device %s: ERR=%s\n"),
465 dev->print_name(), dev->bstrerror());
469 /* See what we have for a Volume */
470 label_status = read_dev_volume_label(dcr);
472 /* Set new volume name */
473 bstrncpy(dcr->VolCatInfo.VolCatName, newname, sizeof(dcr->VolCatInfo.VolCatName));
474 switch(label_status) {
476 case VOL_VERSION_ERROR:
477 case VOL_LABEL_ERROR:
481 "3920 Cannot label Volume because it is already labeled: \"%s\"\n"),
482 dev->VolHdr.VolumeName);
486 /* Relabel request. If oldname matches, continue */
487 if (strcmp(oldname, dev->VolHdr.VolumeName) != 0) {
488 dir->fsend(_("3921 Wrong volume mounted.\n"));
491 if (dev->label_type != B_BACULA_LABEL) {
492 dir->fsend(_("3922 Cannot relabel an ANSI/IBM labeled Volume.\n"));
495 /* Fall through wanted! */
498 if (!write_new_volume_label_to_dev(dcr, newname, poolname,
499 relabel, true /* write dvd now */)) {
500 dir->fsend(_("3912 Failed to label Volume: ERR=%s\n"), dev->bstrerror());
503 bstrncpy(dcr->VolumeName, newname, sizeof(dcr->VolumeName));
504 /* The following 3000 OK label. string is scanned in ua_label.c */
505 dir->fsend("3000 OK label. VolBytes=%s DVD=%d Volume=\"%s\" Device=%s\n",
506 edit_uint64(dev->VolCatInfo.VolCatBytes, ed1),
507 dev->is_dvd()?1:0, newname, dev->print_name());
510 dir->fsend(_("3914 Failed to label Volume (no media): ERR=%s\n"), dev->bstrerror());
513 dir->fsend(_("3913 Cannot label Volume. "
514 "Unknown status %d from read_volume_label()\n"), label_status);
519 if (!dev->is_open()) {
522 volume_unused(dcr); /* no longer using volume */
523 give_back_device_lock(dev, &hold);
529 * Read the tape label
531 * Enter with the mutex set
533 static bool read_label(DCR *dcr)
537 BSOCK *dir = jcr->dir_bsock;
539 DEVICE *dev = dcr->dev;
541 steal_device_lock(dev, &hold, BST_DOING_ACQUIRE);
543 dcr->VolumeName[0] = 0;
544 dev->clear_labeled(); /* force read of label */
545 switch (read_dev_volume_label(dcr)) {
547 dir->fsend(_("3001 Mounted Volume: %s\n"), dev->VolHdr.VolumeName);
551 dir->fsend(_("3902 Cannot mount Volume on Storage Device %s because:\n%s"),
552 dev->print_name(), jcr->errmsg);
557 give_back_device_lock(dev, &hold);
562 * Searches for device by name, and if found, creates a dcr and
565 static DCR *find_device(JCR *jcr, POOL_MEM &devname, int drive)
568 AUTOCHANGER *changer;
572 unbash_spaces(devname);
573 foreach_res(device, R_DEVICE) {
574 /* Find resource, and make sure we were able to open it */
575 if (strcmp(device->hdr.name, devname.c_str()) == 0) {
577 device->dev = init_dev(jcr, device);
580 Jmsg(jcr, M_WARNING, 0, _("\n"
581 " Device \"%s\" requested by DIR could not be opened or does not exist.\n"),
585 Dmsg1(20, "Found device %s\n", device->hdr.name);
591 foreach_res(changer, R_AUTOCHANGER) {
592 /* Find resource, and make sure we were able to open it */
593 if (strcmp(devname.c_str(), changer->hdr.name) == 0) {
594 /* Try each device in this AutoChanger */
595 foreach_alist(device, changer->device) {
596 Dmsg1(100, "Try changer device %s\n", device->hdr.name);
598 device->dev = init_dev(jcr, device);
601 Dmsg1(100, "Device %s could not be opened. Skipped\n", devname.c_str());
602 Jmsg(jcr, M_WARNING, 0, _("\n"
603 " Device \"%s\" in changer \"%s\" requested by DIR could not be opened or does not exist.\n"),
604 device->hdr.name, devname.c_str());
607 if (!device->dev->autoselect) {
608 Dmsg1(100, "Device %s not autoselect skipped.\n", devname.c_str());
609 continue; /* device is not available */
611 if (drive < 0 || drive == (int)device->dev->drive_index) {
612 Dmsg1(20, "Found changer device %s\n", device->hdr.name);
616 Dmsg3(100, "Device %s drive wrong: want=%d got=%d skipping\n",
617 devname.c_str(), drive, (int)device->dev->drive_index);
619 break; /* we found it but could not open a device */
625 Dmsg1(100, "Found device %s\n", device->hdr.name);
626 dcr = new_dcr(jcr, NULL, device->dev);
627 dcr->device = device;
634 * Mount command from Director
636 static bool mount_cmd(JCR *jcr)
639 BSOCK *dir = jcr->dir_bsock;
646 ok = sscanf(dir->msg, "mount %127s drive=%d slot=%d", devname.c_str(),
649 ok = sscanf(dir->msg, "mount %127s drive=%d", devname.c_str(), &drive) == 2;
652 dcr = find_device(jcr, devname, drive);
655 dev->dlock(); /* Use P to avoid indefinite block */
656 Dmsg2(100, "mount cmd blocked=%d must_unload=%d\n", dev->blocked(),
658 switch (dev->blocked()) { /* device blocked? */
659 case BST_WAITING_FOR_SYSOP:
660 /* Someone is waiting, wake him */
661 Dmsg0(100, "Waiting for mount. Attempting to wake thread\n");
662 dev->set_blocked(BST_MOUNT);
663 dir->fsend("3001 OK mount requested. %sDevice=%s\n",
664 slot>0?_("Specified slot ignored. "):"",
666 pthread_cond_broadcast(&dev->wait_next_vol);
667 Dmsg1(100, "JobId=%u broadcast wait_device_release\n", (uint32_t)dcr->jcr->JobId);
668 pthread_cond_broadcast(&wait_device_release);
671 /* In both of these two cases, we (the user) unmounted the Volume */
672 case BST_UNMOUNTED_WAITING_FOR_SYSOP:
674 if (dev->is_autochanger() && slot > 0) {
675 try_autoload_device(jcr, dcr, slot, "");
677 /* We freed the device, so reopen it and wake any waiting threads */
678 if (dev->open(dcr, OPEN_READ_ONLY) < 0) {
679 dir->fsend(_("3901 Unable to open device %s: ERR=%s\n"),
680 dev->print_name(), dev->bstrerror());
681 if (dev->blocked() == BST_UNMOUNTED) {
682 /* We blocked the device, so unblock it */
683 Dmsg0(100, "Unmounted. Unblocking device\n");
688 read_dev_volume_label(dcr);
689 if (dev->blocked() == BST_UNMOUNTED) {
690 /* We blocked the device, so unblock it */
691 Dmsg0(100, "Unmounted. Unblocking device\n");
692 read_label(dcr); /* this should not be necessary */
695 Dmsg0(100, "Unmounted waiting for mount. Attempting to wake thread\n");
696 dev->set_blocked(BST_MOUNT);
698 if (dev->is_labeled()) {
699 dir->fsend(_("3001 Device %s is mounted with Volume \"%s\"\n"),
700 dev->print_name(), dev->VolHdr.VolumeName);
702 dir->fsend(_("3905 Device %s open but no Bacula volume is mounted.\n"
703 "If this is not a blank tape, try unmounting and remounting the Volume.\n"),
706 pthread_cond_broadcast(&dev->wait_next_vol);
707 Dmsg1(100, "JobId=%u broadcast wait_device_release\n", (uint32_t)dcr->jcr->JobId);
708 pthread_cond_broadcast(&wait_device_release);
711 case BST_DOING_ACQUIRE:
712 dir->fsend(_("3001 Device %s is doing acquire.\n"),
716 case BST_WRITING_LABEL:
717 dir->fsend(_("3903 Device %s is being labeled.\n"),
721 case BST_NOT_BLOCKED:
722 if (dev->is_autochanger() && slot > 0) {
723 try_autoload_device(jcr, dcr, slot, "");
725 if (dev->is_open()) {
726 if (dev->is_labeled()) {
727 dir->fsend(_("3001 Device %s is mounted with Volume \"%s\"\n"),
728 dev->print_name(), dev->VolHdr.VolumeName);
730 dir->fsend(_("3905 Device %s open but no Bacula volume is mounted.\n"
731 "If this is not a blank tape, try unmounting and remounting the Volume.\n"),
734 } else if (dev->is_tape()) {
735 if (dev->open(dcr, OPEN_READ_ONLY) < 0) {
736 dir->fsend(_("3901 Unable to open device %s: ERR=%s\n"),
737 dev->print_name(), dev->bstrerror());
741 if (dev->is_labeled()) {
742 dir->fsend(_("3001 Device %s is already mounted with Volume \"%s\"\n"),
743 dev->print_name(), dev->VolHdr.VolumeName);
745 dir->fsend(_("3905 Device %s open but no Bacula volume is mounted.\n"
746 "If this is not a blank tape, try unmounting and remounting the Volume.\n"),
749 } else if (dev->is_unmountable()) {
751 dir->fsend(_("3002 Device %s is mounted.\n"),
754 dir->fsend(_("3907 %s"), dev->bstrerror());
756 } else { /* must be file */
757 dir->fsend(_("3906 File device %s is always mounted.\n"),
763 dir->fsend(_("3905 Bizarre wait state %d\n"), dev->blocked());
769 dir->fsend(_("3999 Device \"%s\" not found or could not be opened.\n"), devname.c_str());
772 pm_strcpy(jcr->errmsg, dir->msg);
773 dir->fsend(_("3909 Error scanning mount command: %s\n"), jcr->errmsg);
775 dir->signal(BNET_EOD);
780 * unmount command from Director
782 static bool unmount_cmd(JCR *jcr)
785 BSOCK *dir = jcr->dir_bsock;
790 if (sscanf(dir->msg, "unmount %127s drive=%d", devname.c_str(), &drive) == 2) {
791 dcr = find_device(jcr, devname, drive);
794 dev->dlock(); /* Use P to avoid indefinite block */
795 if (!dev->is_open()) {
796 if (!dev->is_busy()) {
797 unload_autochanger(dcr, -1);
799 if (dev->is_unmountable()) {
800 if (dev->unmount(0)) {
801 dir->fsend(_("3002 Device %s unmounted.\n"),
804 dir->fsend(_("3907 %s"), dev->bstrerror());
807 Dmsg0(90, "Device already unmounted\n");
808 dir->fsend(_("3901 Device %s is already unmounted.\n"),
811 } else if (dev->blocked() == BST_WAITING_FOR_SYSOP) {
812 Dmsg2(90, "%d waiter dev_block=%d. doing unmount\n", dev->num_waiting,
814 if (!unload_autochanger(dcr, -1)) {
815 /* ***FIXME**** what is this ???? */
819 if (dev->is_unmountable() && !dev->unmount(0)) {
820 dir->fsend(_("3907 %s"), dev->bstrerror());
822 dev->set_blocked(BST_UNMOUNTED_WAITING_FOR_SYSOP);
823 dir->fsend(_("3001 Device %s unmounted.\n"),
827 } else if (dev->blocked() == BST_DOING_ACQUIRE) {
828 dir->fsend(_("3902 Device %s is busy in acquire.\n"),
831 } else if (dev->blocked() == BST_WRITING_LABEL) {
832 dir->fsend(_("3903 Device %s is being labeled.\n"),
835 } else if (dev->is_busy()) {
836 send_dir_busy_message(dir, dev);
837 } else { /* device not being used */
838 Dmsg0(90, "Device not in use, unmounting\n");
839 /* On FreeBSD, I am having ASSERT() failures in block_device()
840 * and I can only imagine that the thread id that we are
841 * leaving in no_wait_id is being re-used. So here,
842 * we simply do it by hand. Gross, but a solution.
844 /* block_device(dev, BST_UNMOUNTED); replace with 2 lines below */
845 dev->set_blocked(BST_UNMOUNTED);
846 clear_thread_id(dev->no_wait_id);
847 if (!unload_autochanger(dcr, -1)) {
851 if (dev->is_unmountable() && !dev->unmount(0)) {
852 dir->fsend(_("3907 %s"), dev->bstrerror());
854 dir->fsend(_("3002 Device %s unmounted.\n"),
861 dir->fsend(_("3999 Device \"%s\" not found or could not be opened.\n"), devname.c_str());
864 /* NB dir->msg gets clobbered in bnet_fsend, so save command */
865 pm_strcpy(jcr->errmsg, dir->msg);
866 dir->fsend(_("3907 Error scanning unmount command: %s\n"), jcr->errmsg);
868 dir->signal(BNET_EOD);
873 * Release command from Director. This rewinds the device and if
874 * configured does a offline and ensures that Bacula will
875 * re-read the label of the tape before continuing. This gives
876 * the operator the chance to change the tape anytime before the
879 static bool release_cmd(JCR *jcr)
882 BSOCK *dir = jcr->dir_bsock;
887 if (sscanf(dir->msg, "release %127s drive=%d", devname.c_str(), &drive) == 2) {
888 dcr = find_device(jcr, devname, drive);
891 dev->dlock(); /* Use P to avoid indefinite block */
892 if (!dev->is_open()) {
893 if (!dev->is_busy()) {
894 unload_autochanger(dcr, -1);
896 Dmsg0(90, "Device already released\n");
897 dir->fsend(_("3921 Device %s already released.\n"),
900 } else if (dev->blocked() == BST_WAITING_FOR_SYSOP) {
901 Dmsg2(90, "%d waiter dev_block=%d.\n", dev->num_waiting,
903 unload_autochanger(dcr, -1);
904 dir->fsend(_("3922 Device %s waiting for sysop.\n"),
907 } else if (dev->blocked() == BST_UNMOUNTED_WAITING_FOR_SYSOP) {
908 Dmsg2(90, "%d waiter dev_block=%d. doing unmount\n", dev->num_waiting,
910 dir->fsend(_("3922 Device %s waiting for mount.\n"),
913 } else if (dev->blocked() == BST_DOING_ACQUIRE) {
914 dir->fsend(_("3923 Device %s is busy in acquire.\n"),
917 } else if (dev->blocked() == BST_WRITING_LABEL) {
918 dir->fsend(_("3914 Device %s is being labeled.\n"),
921 } else if (dev->is_busy()) {
922 send_dir_busy_message(dir, dev);
923 } else { /* device not being used */
924 Dmsg0(90, "Device not in use, releasing\n");
925 dcr->release_volume();
926 dir->fsend(_("3022 Device %s released.\n"),
932 dir->fsend(_("3999 Device \"%s\" not found or could not be opened.\n"), devname.c_str());
935 /* NB dir->msg gets clobbered in bnet_fsend, so save command */
936 pm_strcpy(jcr->errmsg, dir->msg);
937 dir->fsend(_("3927 Error scanning release command: %s\n"), jcr->errmsg);
939 dir->signal(BNET_EOD);
943 static pthread_mutex_t bsr_mutex = PTHREAD_MUTEX_INITIALIZER;
944 static uint32_t bsr_uniq = 0;
946 static bool get_bootstrap_file(JCR *jcr, BSOCK *sock)
948 POOLMEM *fname = get_pool_memory(PM_FNAME);
952 if (jcr->RestoreBootstrap) {
953 unlink(jcr->RestoreBootstrap);
954 free_pool_memory(jcr->RestoreBootstrap);
958 Mmsg(fname, "%s/%s.%s.%d.bootstrap", me->working_directory, me->hdr.name,
961 Dmsg1(400, "bootstrap=%s\n", fname);
962 jcr->RestoreBootstrap = fname;
963 bs = fopen(fname, "a+b"); /* create file */
966 Jmsg(jcr, M_FATAL, 0, _("Could not create bootstrap file %s: ERR=%s\n"),
967 jcr->RestoreBootstrap, be.bstrerror());
970 Dmsg0(10, "=== Bootstrap file ===\n");
971 while (sock->recv() >= 0) {
972 Dmsg1(10, "%s", sock->msg);
973 fputs(sock->msg, bs);
976 Dmsg0(10, "=== end bootstrap file ===\n");
977 jcr->bsr = parse_bsr(jcr, jcr->RestoreBootstrap);
979 Jmsg(jcr, M_FATAL, 0, _("Error parsing bootstrap file.\n"));
982 if (debug_level >= 10) {
983 dump_bsr(jcr->bsr, true);
985 /* If we got a bootstrap, we are reading, so create read volume list */
986 create_restore_volume_list(jcr);
990 unlink(jcr->RestoreBootstrap);
991 free_pool_memory(jcr->RestoreBootstrap);
992 jcr->RestoreBootstrap = NULL;
994 sock->fsend(ERROR_bootstrap);
997 return sock->fsend(OK_bootstrap);
1000 static bool bootstrap_cmd(JCR *jcr)
1002 return get_bootstrap_file(jcr, jcr->dir_bsock);
1006 * Autochanger command from Director
1008 static bool changer_cmd(JCR *jcr)
1011 BSOCK *dir = jcr->dir_bsock;
1014 const char *cmd = NULL;
1017 * A safe_cmd may call autochanger script but does not load/unload
1018 * slots so it can be done at the same time that the drive is open.
1020 bool safe_cmd = false;
1022 if (sscanf(dir->msg, "autochanger list %127s", devname.c_str()) == 1) {
1024 safe_cmd = ok = true;
1025 } else if (sscanf(dir->msg, "autochanger slots %127s", devname.c_str()) == 1) {
1027 safe_cmd = ok = true;
1028 } else if (sscanf(dir->msg, "autochanger drives %127s", devname.c_str()) == 1) {
1030 safe_cmd = ok = true;
1033 dcr = find_device(jcr, devname, -1);
1036 dev->dlock(); /* Use P to avoid indefinite block */
1037 if (!dev->device->changer_res) {
1038 dir->fsend(_("3995 Device %s is not an autochanger.\n"),
1040 /* Under certain "safe" conditions, we can steal the lock */
1041 } else if (safe_cmd || !dev->is_open() || dev->can_steal_lock()) {
1042 autochanger_cmd(dcr, dir, cmd);
1043 } else if (dev->is_busy() || dev->is_blocked()) {
1044 send_dir_busy_message(dir, dev);
1045 } else { /* device not being used */
1046 autochanger_cmd(dcr, dir, cmd);
1051 dir->fsend(_("3999 Device \"%s\" not found or could not be opened.\n"), devname.c_str());
1053 } else { /* error on scanf */
1054 pm_strcpy(jcr->errmsg, dir->msg);
1055 dir->fsend(_("3908 Error scanning autocharger drives/list/slots command: %s\n"),
1058 dir->signal(BNET_EOD);
1063 * Read and return the Volume label
1065 static bool readlabel_cmd(JCR *jcr)
1068 BSOCK *dir = jcr->dir_bsock;
1074 if (sscanf(dir->msg, "readlabel %127s Slot=%d drive=%d", devname.c_str(),
1075 &Slot, &drive) == 3) {
1076 dcr = find_device(jcr, devname, drive);
1079 dev->dlock(); /* Use P to avoid indefinite block */
1080 if (!dev->is_open()) {
1081 read_volume_label(jcr, dcr, dev, Slot);
1083 /* Under certain "safe" conditions, we can steal the lock */
1084 } else if (dev->can_steal_lock()) {
1085 read_volume_label(jcr, dcr, dev, Slot);
1086 } else if (dev->is_busy() || dev->is_blocked()) {
1087 send_dir_busy_message(dir, dev);
1088 } else { /* device not being used */
1089 read_volume_label(jcr, dcr, dev, Slot);
1094 dir->fsend(_("3999 Device \"%s\" not found or could not be opened.\n"), devname.c_str());
1097 pm_strcpy(jcr->errmsg, dir->msg);
1098 dir->fsend(_("3909 Error scanning readlabel command: %s\n"), jcr->errmsg);
1100 dir->signal(BNET_EOD);
1106 * Read the tape label
1108 * Enter with the mutex set
1110 static void read_volume_label(JCR *jcr, DCR *dcr, DEVICE *dev, int Slot)
1112 BSOCK *dir = jcr->dir_bsock;
1116 steal_device_lock(dev, &hold, BST_WRITING_LABEL);
1118 if (!try_autoload_device(jcr, dcr, Slot, "")) {
1119 goto bail_out; /* error */
1122 dev->clear_labeled(); /* force read of label */
1123 switch (read_dev_volume_label(dcr)) {
1125 /* DO NOT add quotes around the Volume name. It is scanned in the DIR */
1126 dir->fsend(_("3001 Volume=%s Slot=%d\n"), dev->VolHdr.VolumeName, Slot);
1127 Dmsg1(100, "Volume: %s\n", dev->VolHdr.VolumeName);
1130 dir->fsend(_("3902 Cannot mount Volume on Storage Device %s because:\n%s"),
1131 dev->print_name(), jcr->errmsg);
1136 give_back_device_lock(dev, &hold);
1140 static bool try_autoload_device(JCR *jcr, DCR *dcr, int slot, const char *VolName)
1142 BSOCK *dir = jcr->dir_bsock;
1144 bstrncpy(dcr->VolumeName, VolName, sizeof(dcr->VolumeName));
1145 dcr->VolCatInfo.Slot = slot;
1146 dcr->VolCatInfo.InChanger = slot > 0;
1147 if (autoload_device(dcr, 0, dir) < 0) { /* autoload if possible */
1153 static void send_dir_busy_message(BSOCK *dir, DEVICE *dev)
1155 if (dev->is_blocked()) {
1156 switch (dev->blocked()) {
1158 dir->fsend(_("3931 Device %s is BLOCKED. user unmounted.\n"),
1161 case BST_UNMOUNTED_WAITING_FOR_SYSOP:
1162 dir->fsend(_("3932 Device %s is BLOCKED. user unmounted during wait for media/mount.\n"),
1165 case BST_WAITING_FOR_SYSOP:
1166 dir->fsend(_("3933 Device %s is BLOCKED waiting for media.\n"),
1169 case BST_DOING_ACQUIRE:
1170 dir->fsend(_("3934 Device %s is being initialized.\n"),
1173 case BST_WRITING_LABEL:
1174 dir->fsend(_("3935 Device %s is blocked labeling a Volume.\n"),
1178 dir->fsend(_("3935 Device %s is blocked for unknown reason.\n"),
1182 } else if (dev->can_read()) {
1183 dir->fsend(_("3936 Device %s is busy reading.\n"),
1184 dev->print_name());;
1186 dir->fsend(_("3937 Device %s is busy with %d writer(s).\n"),
1187 dev->print_name(), dev->num_writers);