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 John Walker.
24 The licensor of Bacula is the Free Software Foundation Europe
25 (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich,
26 Switzerland, email:ftf@fsfeurope.org.
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";
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 bootstrap_cmd(JCR *jcr);
85 static bool changer_cmd(JCR *sjcr);
86 static bool do_label(JCR *jcr, int relabel);
87 static DCR *find_device(JCR *jcr, POOL_MEM &dev_name, int drive);
88 static void read_volume_label(JCR *jcr, DCR *dcr, DEVICE *dev, int Slot);
89 static void label_volume_if_ok(DCR *dcr, char *oldname,
90 char *newname, char *poolname,
91 int Slot, int relabel);
92 static bool try_autoload_device(JCR *jcr, DCR *dcr, int slot, const char *VolName);
93 static void send_dir_busy_message(BSOCK *dir, DEVICE *dev);
97 bool (*func)(JCR *jcr);
98 bool monitoraccess; /* set if monitors can access this cmd */
102 * The following are the recognized commands from the Director.
104 static struct s_cmds cmds[] = {
105 {"JobId=", job_cmd, 0}, /* start Job */
106 {"autochanger", changer_cmd, 0},
107 {"bootstrap", bootstrap_cmd, 0},
108 {"cancel", cancel_cmd, 0},
109 {".die", die_cmd, 0},
110 {"label", label_cmd, 0}, /* label a tape */
111 {"mount", mount_cmd, 0},
112 {"readlabel", readlabel_cmd, 0},
113 {"release", release_cmd, 0},
114 {"relabel", relabel_cmd, 0}, /* relabel a tape */
115 {"setdebug=", setdebug_cmd, 0}, /* set debug level */
116 {"status", status_cmd, 1},
117 {".status", qstatus_cmd, 1},
118 {"unmount", unmount_cmd, 0},
119 {"use storage=", use_cmd, 0},
121 // {"query", query_cmd, 0},
122 {NULL, NULL} /* list terminator */
127 * Connection request. We accept connections either from the
128 * Director or a Client (File daemon).
130 * Note, we are running as a seperate thread of the Storage daemon.
131 * and it is because a Director has made a connection with
132 * us on the "Message" channel.
134 * Basic tasks done here:
135 * - Create a JCR record
136 * - If it was from the FD, call handle_filed_connection()
137 * - Authenticate the Director
138 * - We wait for a command
139 * - We execute the command
140 * - We continue or exit depending on the return status
142 void *handle_connection_request(void *arg)
144 BSOCK *bs = (BSOCK *)arg;
152 if (bs->recv() <= 0) {
153 Emsg0(M_ERROR, 0, _("Connection request failed.\n"));
159 * Do a sanity check on the message received
161 if (bs->msglen < 25 || bs->msglen > (int)sizeof(name)) {
162 Dmsg1(000, "<filed: %s", bs->msg);
163 Emsg1(M_ERROR, 0, _("Invalid connection. Len=%d\n"), bs->msglen);
168 * See if this is a File daemon connection. If so
171 Dmsg1(110, "Conn: %s", bs->msg);
172 if (debug_level == 3) {
173 Dmsg1(000, "<filed: %s", bs->msg);
175 if (sscanf(bs->msg, "Hello Start Job %127s", name) == 1) {
176 Dmsg1(110, "Got a FD connection at %s\n", bstrftimes(tbuf, sizeof(tbuf),
177 (utime_t)time(NULL)));
178 handle_filed_connection(bs, name);
183 * This is a connection from the Director, so setup a JCR
185 Dmsg1(110, "Got a DIR connection at %s\n", bstrftimes(tbuf, sizeof(tbuf),
186 (utime_t)time(NULL)));
187 jcr = new_jcr(sizeof(JCR), stored_free_jcr); /* create Job Control Record */
188 jcr->dir_bsock = bs; /* save Director bsock */
189 jcr->dir_bsock->set_jcr(jcr);
190 jcr->dcrs = New(alist(10, not_owned_by_alist));
191 /* Initialize FD start condition variable */
192 int errstat = pthread_cond_init(&jcr->job_start_wait, NULL);
195 Jmsg1(jcr, M_FATAL, 0, _("Unable to init job cond variable: ERR=%s\n"), be.bstrerror(errstat));
199 Dmsg0(1000, "stored in start_job\n");
202 * Authenticate the Director
204 if (!authenticate_director(jcr)) {
205 Jmsg(jcr, M_FATAL, 0, _("Unable to authenticate Director\n"));
208 Dmsg0(90, "Message channel init completed.\n");
210 for (quit=false; !quit;) {
212 if ((bnet_stat = bs->recv()) <= 0) {
213 break; /* connection terminated */
215 Dmsg1(199, "<dird: %s\n", bs->msg);
216 /* Ensure that device initialization is complete */
221 for (i=0; cmds[i].cmd; i++) {
222 if (strncmp(cmds[i].cmd, bs->msg, strlen(cmds[i].cmd)) == 0) {
223 if ((!cmds[i].monitoraccess) && (jcr->director->monitor)) {
224 Dmsg1(100, "Command \"%s\" is invalid.\n", cmds[i].cmd);
225 bs->fsend(invalid_cmd);
226 bs->signal(BNET_EOD);
229 Dmsg1(200, "Do command: %s\n", cmds[i].cmd);
230 if (!cmds[i].func(jcr)) { /* do command */
231 quit = true; /* error, get out */
232 Dmsg1(190, "Command %s reqeusts quit\n", cmds[i].cmd);
234 found = true; /* indicate command found */
238 if (!found) { /* command not found */
244 generate_daemon_event(jcr, "JobEnd");
245 dequeue_messages(jcr); /* send any queued messages */
246 bs->signal(BNET_TERMINATE);
253 * Force SD to die, and hopefully dump itself. Turned on only
254 * in development version.
256 static bool die_cmd(JCR *jcr)
261 Pmsg0(000, "I have been requested to die ...");
262 a = djcr->JobId; /* ref NULL pointer */
270 * Set debug level as requested by the Director
273 static bool setdebug_cmd(JCR *jcr)
275 BSOCK *dir = jcr->dir_bsock;
276 int level, trace_flag;
278 Dmsg1(10, "setdebug_cmd: %s", dir->msg);
279 if (sscanf(dir->msg, "setdebug=%d trace=%d", &level, &trace_flag) != 2 || level < 0) {
280 dir->fsend(_("3991 Bad setdebug command: %s\n"), dir->msg);
284 set_trace(trace_flag);
285 return dir->fsend(OKsetdebug, level);
292 static bool cancel_cmd(JCR *cjcr)
294 BSOCK *dir = cjcr->dir_bsock;
296 char Job[MAX_NAME_LENGTH];
299 if (sscanf(dir->msg, "cancel Job=%127s", Job) == 1) {
300 if (!(jcr=get_jcr_by_full_name(Job))) {
301 dir->fsend(_("3904 Job %s not found.\n"), Job);
303 oldStatus = jcr->JobStatus;
304 set_jcr_job_status(jcr, JS_Canceled);
305 if (!jcr->authenticated && oldStatus == JS_WaitFD) {
306 pthread_cond_signal(&jcr->job_start_wait); /* wake waiting thread */
308 if (jcr->file_bsock) {
309 bnet_sig(jcr->file_bsock, BNET_TERMINATE);
311 /* Still waiting for FD to connect, release it */
312 pthread_cond_signal(&jcr->job_start_wait); /* wake waiting job */
314 /* If thread waiting on mount, wake him */
315 if (jcr->dcr && jcr->dcr->dev && jcr->dcr->dev->waiting_for_mount()) {
316 pthread_cond_broadcast(&jcr->dcr->dev->wait_next_vol);
317 Dmsg1(100, "JobId=%u broadcast wait_device_release\n", (uint32_t)jcr->JobId);
318 pthread_cond_broadcast(&wait_device_release);
320 if (jcr->read_dcr && jcr->read_dcr->dev && jcr->read_dcr->dev->waiting_for_mount()) {
321 pthread_cond_broadcast(&jcr->read_dcr->dev->wait_next_vol);
322 Dmsg1(100, "JobId=%u broadcast wait_device_release\n", (uint32_t)jcr->JobId);
323 pthread_cond_broadcast(&wait_device_release);
325 Jmsg(jcr, M_INFO, 0, _("Job %s marked to be canceled.\n"), jcr->Job);
326 dir->fsend(_("3000 Job %s marked to be canceled.\n"), jcr->Job);
330 dir->fsend(_("3903 Error scanning cancel command.\n"));
332 dir->signal(BNET_EOD);
340 static bool label_cmd(JCR *jcr)
342 return do_label(jcr, 0);
345 static bool relabel_cmd(JCR *jcr)
347 return do_label(jcr, 1);
350 static bool do_label(JCR *jcr, int relabel)
352 POOLMEM *newname, *oldname, *poolname, *mtype;
354 BSOCK *dir = jcr->dir_bsock;
361 newname = get_memory(dir->msglen+1);
362 oldname = get_memory(dir->msglen+1);
363 poolname = get_memory(dir->msglen+1);
364 mtype = get_memory(dir->msglen+1);
366 if (sscanf(dir->msg, "relabel %127s OldName=%127s NewName=%127s PoolName=%127s "
367 "MediaType=%127s Slot=%d drive=%d",
368 dev_name.c_str(), oldname, newname, poolname, mtype,
369 &slot, &drive) == 7) {
374 if (sscanf(dir->msg, "label %127s VolumeName=%127s PoolName=%127s "
375 "MediaType=%127s Slot=%d drive=%d",
376 dev_name.c_str(), newname, poolname, mtype, &slot, &drive) == 6) {
381 unbash_spaces(newname);
382 unbash_spaces(oldname);
383 unbash_spaces(poolname);
384 unbash_spaces(mtype);
385 dcr = find_device(jcr, dev_name, drive);
388 dev->dlock(); /* Use P to avoid indefinite block */
389 if (!dev->is_open() && !dev->is_busy()) {
390 Dmsg1(400, "Can %slabel. Device is not open\n", relabel?"re":"");
391 label_volume_if_ok(dcr, oldname, newname, poolname, slot, relabel);
393 /* Under certain "safe" conditions, we can steal the lock */
394 } else if (dev->can_steal_lock()) {
395 Dmsg0(400, "Can relabel. can_steal_lock\n");
396 label_volume_if_ok(dcr, oldname, newname, poolname, slot, relabel);
397 } else if (dev->is_busy() || dev->is_blocked()) {
398 send_dir_busy_message(dir, dev);
399 } else { /* device not being used */
400 Dmsg0(400, "Can relabel. device not used\n");
401 label_volume_if_ok(dcr, oldname, newname, poolname, slot, relabel);
406 dir->fsend(_("3999 Device \"%s\" not found or could not be opened.\n"), dev_name.c_str());
409 /* NB dir->msg gets clobbered in bnet_fsend, so save command */
410 pm_strcpy(jcr->errmsg, dir->msg);
411 dir->fsend(_("3903 Error scanning label command: %s\n"), jcr->errmsg);
413 free_memory(oldname);
414 free_memory(newname);
415 free_memory(poolname);
417 dir->signal(BNET_EOD);
422 * Read the tape label and determine if we can safely
423 * label the tape (not a Bacula volume), then label it.
425 * Enter with the mutex set
427 static void label_volume_if_ok(DCR *dcr, char *oldname,
428 char *newname, char *poolname,
429 int slot, int relabel)
431 BSOCK *dir = dcr->jcr->dir_bsock;
433 DEVICE *dev = dcr->dev;
436 const char *volname = (relabel == 1) ? oldname : newname;
439 steal_device_lock(dev, &hold, BST_WRITING_LABEL);
440 Dmsg1(100, "Stole device %s lock, writing label.\n", dev->print_name());
443 Dmsg0(90, "try_autoload_device - looking for volume_info\n");
444 if (!try_autoload_device(dcr->jcr, dcr, slot, volname)) {
445 goto bail_out; /* error */
448 /* Ensure that the device is open -- autoload_device() closes it */
449 if (dev->is_tape()) {
450 mode = OPEN_READ_WRITE;
452 mode = CREATE_READ_WRITE;
456 dev->truncating = true; /* let open() know we will truncate it */
458 /* Set old volume name for open if relabeling */
459 bstrncpy(dcr->VolCatInfo.VolCatName, volname, sizeof(dcr->VolCatInfo.VolCatName));
460 if (dev->open(dcr, mode) < 0) {
461 dir->fsend(_("3910 Unable to open device %s: ERR=%s\n"),
462 dev->print_name(), dev->bstrerror());
466 /* See what we have for a Volume */
467 label_status = read_dev_volume_label(dcr);
469 /* Set new volume name */
470 bstrncpy(dcr->VolCatInfo.VolCatName, newname, sizeof(dcr->VolCatInfo.VolCatName));
471 switch(label_status) {
473 case VOL_VERSION_ERROR:
474 case VOL_LABEL_ERROR:
478 "3920 Cannot label Volume because it is already labeled: \"%s\"\n"),
479 dev->VolHdr.VolumeName);
483 /* Relabel request. If oldname matches, continue */
484 if (strcmp(oldname, dev->VolHdr.VolumeName) != 0) {
485 dir->fsend(_("3921 Wrong volume mounted.\n"));
488 if (dev->label_type != B_BACULA_LABEL) {
489 dir->fsend(_("3922 Cannot relabel an ANSI/IBM labeled Volume.\n"));
492 /* Fall through wanted! */
495 if (!write_new_volume_label_to_dev(dcr, newname, poolname,
496 relabel, true /* write dvd now */)) {
497 dir->fsend(_("3912 Failed to label Volume: ERR=%s\n"), dev->bstrerror());
500 bstrncpy(dcr->VolumeName, newname, sizeof(dcr->VolumeName));
501 /* The following 3000 OK label. string is scanned in ua_label.c */
502 dir->fsend("3000 OK label. VolBytes=%s DVD=%d Volume=\"%s\" Device=%s\n",
503 edit_uint64(dev->VolCatInfo.VolCatBytes, ed1),
504 dev->is_dvd()?1:0, newname, dev->print_name());
507 dir->fsend(_("3914 Failed to label Volume (no media): ERR=%s\n"), dev->bstrerror());
510 dir->fsend(_("3913 Cannot label Volume. "
511 "Unknown status %d from read_volume_label()\n"), label_status);
516 if (!dev->is_open()) {
519 volume_unused(dcr); /* no longer using volume */
520 give_back_device_lock(dev, &hold);
526 * Read the tape label
528 * Enter with the mutex set
530 static bool read_label(DCR *dcr)
534 BSOCK *dir = jcr->dir_bsock;
536 DEVICE *dev = dcr->dev;
538 steal_device_lock(dev, &hold, BST_DOING_ACQUIRE);
540 dcr->VolumeName[0] = 0;
541 dev->clear_labeled(); /* force read of label */
542 switch (read_dev_volume_label(dcr)) {
544 dir->fsend(_("3001 Mounted Volume: %s\n"), dev->VolHdr.VolumeName);
548 dir->fsend(_("3902 Cannot mount Volume on Storage Device %s because:\n%s"),
549 dev->print_name(), jcr->errmsg);
554 give_back_device_lock(dev, &hold);
559 * Searches for device by name, and if found, creates a dcr and
562 static DCR *find_device(JCR *jcr, POOL_MEM &devname, int drive)
565 AUTOCHANGER *changer;
569 unbash_spaces(devname);
570 foreach_res(device, R_DEVICE) {
571 /* Find resource, and make sure we were able to open it */
572 if (strcmp(device->hdr.name, devname.c_str()) == 0) {
574 device->dev = init_dev(jcr, device);
577 Jmsg(jcr, M_WARNING, 0, _("\n"
578 " Device \"%s\" requested by DIR could not be opened or does not exist.\n"),
582 Dmsg1(20, "Found device %s\n", device->hdr.name);
588 foreach_res(changer, R_AUTOCHANGER) {
589 /* Find resource, and make sure we were able to open it */
590 if (strcmp(devname.c_str(), changer->hdr.name) == 0) {
591 /* Try each device in this AutoChanger */
592 foreach_alist(device, changer->device) {
593 Dmsg1(100, "Try changer device %s\n", device->hdr.name);
595 device->dev = init_dev(jcr, device);
598 Dmsg1(100, "Device %s could not be opened. Skipped\n", devname.c_str());
599 Jmsg(jcr, M_WARNING, 0, _("\n"
600 " Device \"%s\" in changer \"%s\" requested by DIR could not be opened or does not exist.\n"),
601 device->hdr.name, devname.c_str());
604 if (!device->dev->autoselect) {
605 Dmsg1(100, "Device %s not autoselect skipped.\n", devname.c_str());
606 continue; /* device is not available */
608 if (drive < 0 || drive == (int)device->dev->drive_index) {
609 Dmsg1(20, "Found changer device %s\n", device->hdr.name);
613 Dmsg3(100, "Device %s drive wrong: want=%d got=%d skipping\n",
614 devname.c_str(), drive, (int)device->dev->drive_index);
616 break; /* we found it but could not open a device */
622 Dmsg1(100, "Found device %s\n", device->hdr.name);
623 dcr = new_dcr(jcr, NULL, device->dev);
624 dcr->device = device;
631 * Mount command from Director
633 static bool mount_cmd(JCR *jcr)
636 BSOCK *dir = jcr->dir_bsock;
643 ok = sscanf(dir->msg, "mount %127s drive=%d slot=%d", devname.c_str(),
646 ok = sscanf(dir->msg, "mount %127s drive=%d", devname.c_str(), &drive) == 2;
649 dcr = find_device(jcr, devname, drive);
652 dev->dlock(); /* Use P to avoid indefinite block */
653 Dmsg2(100, "mount cmd blocked=%d must_unload=%d\n", dev->blocked(),
655 switch (dev->blocked()) { /* device blocked? */
656 case BST_WAITING_FOR_SYSOP:
657 /* Someone is waiting, wake him */
658 Dmsg0(100, "Waiting for mount. Attempting to wake thread\n");
659 dev->set_blocked(BST_MOUNT);
660 dir->fsend("3001 OK mount. Device=%s\n",
662 pthread_cond_broadcast(&dev->wait_next_vol);
663 Dmsg1(100, "JobId=%u broadcast wait_device_release\n", (uint32_t)dcr->jcr->JobId);
664 pthread_cond_broadcast(&wait_device_release);
667 /* In both of these two cases, we (the user) unmounted the Volume */
668 case BST_UNMOUNTED_WAITING_FOR_SYSOP:
670 if (dev->is_autochanger() && slot > 0) {
671 try_autoload_device(jcr, dcr, slot, "");
673 /* We freed the device, so reopen it and wake any waiting threads */
674 if (dev->open(dcr, OPEN_READ_ONLY) < 0) {
675 dir->fsend(_("3901 Unable to open device %s: ERR=%s\n"),
676 dev->print_name(), dev->bstrerror());
677 if (dev->blocked() == BST_UNMOUNTED) {
678 /* We blocked the device, so unblock it */
679 Dmsg0(100, "Unmounted. Unblocking device\n");
684 read_dev_volume_label(dcr);
685 if (dev->blocked() == BST_UNMOUNTED) {
686 /* We blocked the device, so unblock it */
687 Dmsg0(100, "Unmounted. Unblocking device\n");
688 read_label(dcr); /* this should not be necessary */
691 Dmsg0(100, "Unmounted waiting for mount. Attempting to wake thread\n");
692 dev->set_blocked(BST_MOUNT);
694 if (dev->is_labeled()) {
695 dir->fsend(_("3001 Device %s is mounted with Volume \"%s\"\n"),
696 dev->print_name(), dev->VolHdr.VolumeName);
698 dir->fsend(_("3905 Device %s open but no Bacula volume is mounted.\n"
699 "If this is not a blank tape, try unmounting and remounting the Volume.\n"),
702 pthread_cond_broadcast(&dev->wait_next_vol);
703 Dmsg1(100, "JobId=%u broadcast wait_device_release\n", (uint32_t)dcr->jcr->JobId);
704 pthread_cond_broadcast(&wait_device_release);
707 case BST_DOING_ACQUIRE:
708 dir->fsend(_("3001 Device %s is doing acquire.\n"),
712 case BST_WRITING_LABEL:
713 dir->fsend(_("3903 Device %s is being labeled.\n"),
717 case BST_NOT_BLOCKED:
718 if (dev->is_autochanger() && slot > 0) {
719 try_autoload_device(jcr, dcr, slot, "");
721 if (dev->is_open()) {
722 if (dev->is_labeled()) {
723 dir->fsend(_("3001 Device %s is mounted with Volume \"%s\"\n"),
724 dev->print_name(), dev->VolHdr.VolumeName);
726 dir->fsend(_("3905 Device %s open but no Bacula volume is mounted.\n"
727 "If this is not a blank tape, try unmounting and remounting the Volume.\n"),
730 } else if (dev->is_tape()) {
731 if (dev->open(dcr, OPEN_READ_ONLY) < 0) {
732 dir->fsend(_("3901 Unable to open device %s: ERR=%s\n"),
733 dev->print_name(), dev->bstrerror());
737 if (dev->is_labeled()) {
738 dir->fsend(_("3001 Device %s is already mounted with Volume \"%s\"\n"),
739 dev->print_name(), dev->VolHdr.VolumeName);
741 dir->fsend(_("3905 Device %s open but no Bacula volume is mounted.\n"
742 "If this is not a blank tape, try unmounting and remounting the Volume.\n"),
745 } else if (dev->is_unmountable()) {
747 dir->fsend(_("3002 Device %s is mounted.\n"),
750 dir->fsend(_("3907 %s"), dev->bstrerror());
752 } else { /* must be file */
753 dir->fsend(_("3906 File device %s is always mounted.\n"),
759 dir->fsend(_("3905 Bizarre wait state %d\n"), dev->blocked());
765 dir->fsend(_("3999 Device \"%s\" not found or could not be opened.\n"), devname.c_str());
768 pm_strcpy(jcr->errmsg, dir->msg);
769 dir->fsend(_("3909 Error scanning mount command: %s\n"), jcr->errmsg);
771 dir->signal(BNET_EOD);
776 * unmount command from Director
778 static bool unmount_cmd(JCR *jcr)
781 BSOCK *dir = jcr->dir_bsock;
786 if (sscanf(dir->msg, "unmount %127s drive=%d", devname.c_str(), &drive) == 2) {
787 dcr = find_device(jcr, devname, drive);
790 dev->dlock(); /* Use P to avoid indefinite block */
791 if (!dev->is_open()) {
792 if (!dev->is_busy()) {
793 unload_autochanger(dcr, -1);
795 if (dev->is_unmountable()) {
796 if (dev->unmount(0)) {
797 dir->fsend(_("3002 Device %s unmounted.\n"),
800 dir->fsend(_("3907 %s"), dev->bstrerror());
803 Dmsg0(90, "Device already unmounted\n");
804 dir->fsend(_("3901 Device %s is already unmounted.\n"),
807 } else if (dev->blocked() == BST_WAITING_FOR_SYSOP) {
808 Dmsg2(90, "%d waiter dev_block=%d. doing unmount\n", dev->num_waiting,
810 if (!unload_autochanger(dcr, -1)) {
811 /* ***FIXME**** what is this ???? */
814 if (dev->is_unmountable() && !dev->unmount(0)) {
815 dir->fsend(_("3907 %s"), dev->bstrerror());
817 dev->set_blocked(BST_UNMOUNTED_WAITING_FOR_SYSOP);
818 dir->fsend(_("3001 Device %s unmounted.\n"),
822 } else if (dev->blocked() == BST_DOING_ACQUIRE) {
823 dir->fsend(_("3902 Device %s is busy in acquire.\n"),
826 } else if (dev->blocked() == BST_WRITING_LABEL) {
827 dir->fsend(_("3903 Device %s is being labeled.\n"),
830 } else if (dev->is_busy()) {
831 send_dir_busy_message(dir, dev);
832 } else { /* device not being used */
833 Dmsg0(90, "Device not in use, unmounting\n");
834 /* On FreeBSD, I am having ASSERT() failures in block_device()
835 * and I can only imagine that the thread id that we are
836 * leaving in no_wait_id is being re-used. So here,
837 * we simply do it by hand. Gross, but a solution.
839 /* block_device(dev, BST_UNMOUNTED); replace with 2 lines below */
840 dev->set_blocked(BST_UNMOUNTED);
842 if (!unload_autochanger(dcr, -1)) {
845 if (dev->is_unmountable() && !dev->unmount(0)) {
846 dir->fsend(_("3907 %s"), dev->bstrerror());
848 dir->fsend(_("3002 Device %s unmounted.\n"),
855 dir->fsend(_("3999 Device \"%s\" not found or could not be opened.\n"), devname.c_str());
858 /* NB dir->msg gets clobbered in bnet_fsend, so save command */
859 pm_strcpy(jcr->errmsg, dir->msg);
860 dir->fsend(_("3907 Error scanning unmount command: %s\n"), jcr->errmsg);
862 dir->signal(BNET_EOD);
867 * Release command from Director. This rewinds the device and if
868 * configured does a offline and ensures that Bacula will
869 * re-read the label of the tape before continuing. This gives
870 * the operator the chance to change the tape anytime before the
873 static bool release_cmd(JCR *jcr)
876 BSOCK *dir = jcr->dir_bsock;
881 if (sscanf(dir->msg, "release %127s drive=%d", devname.c_str(), &drive) == 2) {
882 dcr = find_device(jcr, devname, drive);
885 dev->dlock(); /* Use P to avoid indefinite block */
886 if (!dev->is_open()) {
887 if (!dev->is_busy()) {
888 unload_autochanger(dcr, -1);
890 Dmsg0(90, "Device already released\n");
891 dir->fsend(_("3921 Device %s already released.\n"),
894 } else if (dev->blocked() == BST_WAITING_FOR_SYSOP) {
895 Dmsg2(90, "%d waiter dev_block=%d.\n", dev->num_waiting,
897 unload_autochanger(dcr, -1);
898 dir->fsend(_("3922 Device %s waiting for sysop.\n"),
901 } else if (dev->blocked() == BST_UNMOUNTED_WAITING_FOR_SYSOP) {
902 Dmsg2(90, "%d waiter dev_block=%d. doing unmount\n", dev->num_waiting,
904 dir->fsend(_("3922 Device %s waiting for mount.\n"),
907 } else if (dev->blocked() == BST_DOING_ACQUIRE) {
908 dir->fsend(_("3923 Device %s is busy in acquire.\n"),
911 } else if (dev->blocked() == BST_WRITING_LABEL) {
912 dir->fsend(_("3914 Device %s is being labeled.\n"),
915 } else if (dev->is_busy()) {
916 send_dir_busy_message(dir, dev);
917 } else { /* device not being used */
918 Dmsg0(90, "Device not in use, releasing\n");
919 dcr->release_volume();
920 dir->fsend(_("3022 Device %s released.\n"),
926 dir->fsend(_("3999 Device \"%s\" not found or could not be opened.\n"), devname.c_str());
929 /* NB dir->msg gets clobbered in bnet_fsend, so save command */
930 pm_strcpy(jcr->errmsg, dir->msg);
931 dir->fsend(_("3927 Error scanning release command: %s\n"), jcr->errmsg);
933 dir->signal(BNET_EOD);
938 static bool bootstrap_cmd(JCR *jcr)
940 return get_bootstrap_file(jcr, jcr->dir_bsock);
944 * Autochanger command from Director
946 static bool changer_cmd(JCR *jcr)
949 BSOCK *dir = jcr->dir_bsock;
952 const char *cmd = NULL;
955 * A safe_cmd may call autochanger script but does not load/unload
956 * slots so it can be done at the same time that the drive is open.
958 bool safe_cmd = false;
960 if (sscanf(dir->msg, "autochanger list %127s", devname.c_str()) == 1) {
962 safe_cmd = ok = true;
963 } else if (sscanf(dir->msg, "autochanger slots %127s", devname.c_str()) == 1) {
965 safe_cmd = ok = true;
966 } else if (sscanf(dir->msg, "autochanger drives %127s", devname.c_str()) == 1) {
968 safe_cmd = ok = true;
971 dcr = find_device(jcr, devname, -1);
974 dev->dlock(); /* Use P to avoid indefinite block */
975 if (!dev->device->changer_res) {
976 dir->fsend(_("3995 Device %s is not an autochanger.\n"),
978 /* Under certain "safe" conditions, we can steal the lock */
979 } else if (safe_cmd || !dev->is_open() || dev->can_steal_lock()) {
980 autochanger_cmd(dcr, dir, cmd);
981 } else if (dev->is_busy() || dev->is_blocked()) {
982 send_dir_busy_message(dir, dev);
983 } else { /* device not being used */
984 autochanger_cmd(dcr, dir, cmd);
989 dir->fsend(_("3999 Device \"%s\" not found or could not be opened.\n"), devname.c_str());
991 } else { /* error on scanf */
992 pm_strcpy(jcr->errmsg, dir->msg);
993 dir->fsend(_("3908 Error scanning autocharger drives/list/slots command: %s\n"),
996 dir->signal(BNET_EOD);
1001 * Read and return the Volume label
1003 static bool readlabel_cmd(JCR *jcr)
1006 BSOCK *dir = jcr->dir_bsock;
1012 if (sscanf(dir->msg, "readlabel %127s Slot=%d drive=%d", devname.c_str(),
1013 &Slot, &drive) == 3) {
1014 dcr = find_device(jcr, devname, drive);
1017 dev->dlock(); /* Use P to avoid indefinite block */
1018 if (!dev->is_open()) {
1019 read_volume_label(jcr, dcr, dev, Slot);
1021 /* Under certain "safe" conditions, we can steal the lock */
1022 } else if (dev->can_steal_lock()) {
1023 read_volume_label(jcr, dcr, dev, Slot);
1024 } else if (dev->is_busy() || dev->is_blocked()) {
1025 send_dir_busy_message(dir, dev);
1026 } else { /* device not being used */
1027 read_volume_label(jcr, dcr, dev, Slot);
1032 dir->fsend(_("3999 Device \"%s\" not found or could not be opened.\n"), devname.c_str());
1035 pm_strcpy(jcr->errmsg, dir->msg);
1036 dir->fsend(_("3909 Error scanning readlabel command: %s\n"), jcr->errmsg);
1038 dir->signal(BNET_EOD);
1044 * Read the tape label
1046 * Enter with the mutex set
1048 static void read_volume_label(JCR *jcr, DCR *dcr, DEVICE *dev, int Slot)
1050 BSOCK *dir = jcr->dir_bsock;
1054 steal_device_lock(dev, &hold, BST_WRITING_LABEL);
1056 if (!try_autoload_device(jcr, dcr, Slot, "")) {
1057 goto bail_out; /* error */
1060 dev->clear_labeled(); /* force read of label */
1061 switch (read_dev_volume_label(dcr)) {
1063 /* DO NOT add quotes around the Volume name. It is scanned in the DIR */
1064 dir->fsend(_("3001 Volume=%s Slot=%d\n"), dev->VolHdr.VolumeName, Slot);
1065 Dmsg1(100, "Volume: %s\n", dev->VolHdr.VolumeName);
1068 dir->fsend(_("3902 Cannot mount Volume on Storage Device %s because:\n%s"),
1069 dev->print_name(), jcr->errmsg);
1074 give_back_device_lock(dev, &hold);
1078 static bool try_autoload_device(JCR *jcr, DCR *dcr, int slot, const char *VolName)
1080 BSOCK *dir = jcr->dir_bsock;
1082 bstrncpy(dcr->VolumeName, VolName, sizeof(dcr->VolumeName));
1083 dcr->VolCatInfo.Slot = slot;
1084 dcr->VolCatInfo.InChanger = slot > 0;
1085 if (autoload_device(dcr, 0, dir) < 0) { /* autoload if possible */
1091 static void send_dir_busy_message(BSOCK *dir, DEVICE *dev)
1093 if (dev->is_blocked()) {
1094 switch (dev->blocked()) {
1096 dir->fsend(_("3931 Device %s is BLOCKED. user unmounted.\n"),
1099 case BST_UNMOUNTED_WAITING_FOR_SYSOP:
1100 dir->fsend(_("3932 Device %s is BLOCKED. user unmounted during wait for media/mount.\n"),
1103 case BST_WAITING_FOR_SYSOP:
1104 dir->fsend(_("3933 Device %s is BLOCKED waiting for media.\n"),
1107 case BST_DOING_ACQUIRE:
1108 dir->fsend(_("3934 Device %s is being initialized.\n"),
1111 case BST_WRITING_LABEL:
1112 dir->fsend(_("3935 Device %s is blocked labeling a Volume.\n"),
1116 dir->fsend(_("3935 Device %s is blocked for unknown reason.\n"),
1120 } else if (dev->can_read()) {
1121 dir->fsend(_("3936 Device %s is busy reading.\n"),
1122 dev->print_name());;
1124 dir->fsend(_("3937 Device %s is busy with %d writer(s).\n"),
1125 dev->print_name(), dev->num_writers);