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 Dmsg1(100, "mount cmd blocked=%d\n", dev->blocked());
654 switch (dev->blocked()) { /* device blocked? */
655 case BST_WAITING_FOR_SYSOP:
656 /* Someone is waiting, wake him */
657 Dmsg0(100, "Waiting for mount. Attempting to wake thread\n");
658 dev->set_blocked(BST_MOUNT);
659 dir->fsend("3001 OK mount. Device=%s\n",
661 pthread_cond_broadcast(&dev->wait_next_vol);
662 Dmsg1(100, "JobId=%u broadcast wait_device_release\n", (uint32_t)dcr->jcr->JobId);
663 pthread_cond_broadcast(&wait_device_release);
666 /* In both of these two cases, we (the user) unmounted the Volume */
667 case BST_UNMOUNTED_WAITING_FOR_SYSOP:
669 if (dev->is_autochanger() && slot > 0) {
670 try_autoload_device(jcr, dcr, slot, "");
672 /* We freed the device, so reopen it and wake any waiting threads */
673 if (dev->open(dcr, OPEN_READ_ONLY) < 0) {
674 dir->fsend(_("3901 Unable to open device %s: ERR=%s\n"),
675 dev->print_name(), dev->bstrerror());
676 if (dev->blocked() == BST_UNMOUNTED) {
677 /* We blocked the device, so unblock it */
678 Dmsg0(100, "Unmounted. Unblocking device\n");
683 read_dev_volume_label(dcr);
684 if (dev->blocked() == BST_UNMOUNTED) {
685 /* We blocked the device, so unblock it */
686 Dmsg0(100, "Unmounted. Unblocking device\n");
687 read_label(dcr); /* this should not be necessary */
690 Dmsg0(100, "Unmounted waiting for mount. Attempting to wake thread\n");
691 dev->set_blocked(BST_MOUNT);
693 if (dev->is_labeled()) {
694 dir->fsend(_("3001 Device %s is mounted with Volume \"%s\"\n"),
695 dev->print_name(), dev->VolHdr.VolumeName);
697 dir->fsend(_("3905 Device %s open but no Bacula volume is mounted.\n"
698 "If this is not a blank tape, try unmounting and remounting the Volume.\n"),
701 pthread_cond_broadcast(&dev->wait_next_vol);
702 Dmsg1(100, "JobId=%u broadcast wait_device_release\n", (uint32_t)dcr->jcr->JobId);
703 pthread_cond_broadcast(&wait_device_release);
706 case BST_DOING_ACQUIRE:
707 dir->fsend(_("3001 Device %s is doing acquire.\n"),
711 case BST_WRITING_LABEL:
712 dir->fsend(_("3903 Device %s is being labeled.\n"),
716 case BST_NOT_BLOCKED:
717 if (dev->is_autochanger() && slot > 0) {
718 try_autoload_device(jcr, dcr, slot, "");
720 if (dev->is_open()) {
721 if (dev->is_labeled()) {
722 dir->fsend(_("3001 Device %s is mounted with Volume \"%s\"\n"),
723 dev->print_name(), dev->VolHdr.VolumeName);
725 dir->fsend(_("3905 Device %s open but no Bacula volume is mounted.\n"
726 "If this is not a blank tape, try unmounting and remounting the Volume.\n"),
729 } else if (dev->is_tape()) {
730 if (dev->open(dcr, OPEN_READ_ONLY) < 0) {
731 dir->fsend(_("3901 Unable to open device %s: ERR=%s\n"),
732 dev->print_name(), dev->bstrerror());
736 if (dev->is_labeled()) {
737 dir->fsend(_("3001 Device %s is already mounted with Volume \"%s\"\n"),
738 dev->print_name(), dev->VolHdr.VolumeName);
740 dir->fsend(_("3905 Device %s open but no Bacula volume is mounted.\n"
741 "If this is not a blank tape, try unmounting and remounting the Volume.\n"),
744 } else if (dev->is_unmountable()) {
746 dir->fsend(_("3002 Device %s is mounted.\n"),
749 dir->fsend(_("3907 %s"), dev->bstrerror());
751 } else { /* must be file */
752 dir->fsend(_("3906 File device %s is always mounted.\n"),
758 dir->fsend(_("3905 Bizarre wait state %d\n"), dev->blocked());
764 dir->fsend(_("3999 Device \"%s\" not found or could not be opened.\n"), devname.c_str());
767 pm_strcpy(jcr->errmsg, dir->msg);
768 dir->fsend(_("3909 Error scanning mount command: %s\n"), jcr->errmsg);
770 dir->signal(BNET_EOD);
775 * unmount command from Director
777 static bool unmount_cmd(JCR *jcr)
780 BSOCK *dir = jcr->dir_bsock;
785 if (sscanf(dir->msg, "unmount %127s drive=%d", devname.c_str(), &drive) == 2) {
786 dcr = find_device(jcr, devname, drive);
789 dev->dlock(); /* Use P to avoid indefinite block */
790 if (!dev->is_open()) {
791 if (!dev->is_busy()) {
792 unload_autochanger(dcr, -1);
794 if (dev->is_unmountable()) {
795 if (dev->unmount(0)) {
796 dir->fsend(_("3002 Device %s unmounted.\n"),
799 dir->fsend(_("3907 %s"), dev->bstrerror());
802 Dmsg0(90, "Device already unmounted\n");
803 dir->fsend(_("3901 Device %s is already unmounted.\n"),
806 } else if (dev->blocked() == BST_WAITING_FOR_SYSOP) {
807 Dmsg2(90, "%d waiter dev_block=%d. doing unmount\n", dev->num_waiting,
809 if (!unload_autochanger(dcr, -1)) {
810 /* ***FIXME**** what is this ???? */
813 if (dev->is_unmountable() && !dev->unmount(0)) {
814 dir->fsend(_("3907 %s"), dev->bstrerror());
816 dev->set_blocked(BST_UNMOUNTED_WAITING_FOR_SYSOP);
817 dir->fsend(_("3001 Device %s unmounted.\n"),
821 } else if (dev->blocked() == BST_DOING_ACQUIRE) {
822 dir->fsend(_("3902 Device %s is busy in acquire.\n"),
825 } else if (dev->blocked() == BST_WRITING_LABEL) {
826 dir->fsend(_("3903 Device %s is being labeled.\n"),
829 } else if (dev->is_busy()) {
830 send_dir_busy_message(dir, dev);
831 } else { /* device not being used */
832 Dmsg0(90, "Device not in use, unmounting\n");
833 /* On FreeBSD, I am having ASSERT() failures in block_device()
834 * and I can only imagine that the thread id that we are
835 * leaving in no_wait_id is being re-used. So here,
836 * we simply do it by hand. Gross, but a solution.
838 /* block_device(dev, BST_UNMOUNTED); replace with 2 lines below */
839 dev->set_blocked(BST_UNMOUNTED);
841 if (!unload_autochanger(dcr, -1)) {
844 if (dev->is_unmountable() && !dev->unmount(0)) {
845 dir->fsend(_("3907 %s"), dev->bstrerror());
847 dir->fsend(_("3002 Device %s unmounted.\n"),
854 dir->fsend(_("3999 Device \"%s\" not found or could not be opened.\n"), devname.c_str());
857 /* NB dir->msg gets clobbered in bnet_fsend, so save command */
858 pm_strcpy(jcr->errmsg, dir->msg);
859 dir->fsend(_("3907 Error scanning unmount command: %s\n"), jcr->errmsg);
861 dir->signal(BNET_EOD);
866 * Release command from Director. This rewinds the device and if
867 * configured does a offline and ensures that Bacula will
868 * re-read the label of the tape before continuing. This gives
869 * the operator the chance to change the tape anytime before the
872 static bool release_cmd(JCR *jcr)
875 BSOCK *dir = jcr->dir_bsock;
880 if (sscanf(dir->msg, "release %127s drive=%d", devname.c_str(), &drive) == 2) {
881 dcr = find_device(jcr, devname, drive);
884 dev->dlock(); /* Use P to avoid indefinite block */
885 if (!dev->is_open()) {
886 if (!dev->is_busy()) {
887 unload_autochanger(dcr, -1);
889 Dmsg0(90, "Device already released\n");
890 dir->fsend(_("3921 Device %s already released.\n"),
893 } else if (dev->blocked() == BST_WAITING_FOR_SYSOP) {
894 Dmsg2(90, "%d waiter dev_block=%d.\n", dev->num_waiting,
896 unload_autochanger(dcr, -1);
897 dir->fsend(_("3922 Device %s waiting for sysop.\n"),
900 } else if (dev->blocked() == BST_UNMOUNTED_WAITING_FOR_SYSOP) {
901 Dmsg2(90, "%d waiter dev_block=%d. doing unmount\n", dev->num_waiting,
903 dir->fsend(_("3922 Device %s waiting for mount.\n"),
906 } else if (dev->blocked() == BST_DOING_ACQUIRE) {
907 dir->fsend(_("3923 Device %s is busy in acquire.\n"),
910 } else if (dev->blocked() == BST_WRITING_LABEL) {
911 dir->fsend(_("3914 Device %s is being labeled.\n"),
914 } else if (dev->is_busy()) {
915 send_dir_busy_message(dir, dev);
916 } else { /* device not being used */
917 Dmsg0(90, "Device not in use, releasing\n");
918 dcr->release_volume();
919 dir->fsend(_("3022 Device %s released.\n"),
925 dir->fsend(_("3999 Device \"%s\" not found or could not be opened.\n"), devname.c_str());
928 /* NB dir->msg gets clobbered in bnet_fsend, so save command */
929 pm_strcpy(jcr->errmsg, dir->msg);
930 dir->fsend(_("3927 Error scanning release command: %s\n"), jcr->errmsg);
932 dir->signal(BNET_EOD);
937 static bool bootstrap_cmd(JCR *jcr)
939 return get_bootstrap_file(jcr, jcr->dir_bsock);
943 * Autochanger command from Director
945 static bool changer_cmd(JCR *jcr)
948 BSOCK *dir = jcr->dir_bsock;
951 const char *cmd = NULL;
954 * A safe_cmd may call autochanger script but does not load/unload
955 * slots so it can be done at the same time that the drive is open.
957 bool safe_cmd = false;
959 if (sscanf(dir->msg, "autochanger list %127s", devname.c_str()) == 1) {
961 safe_cmd = ok = true;
962 } else if (sscanf(dir->msg, "autochanger slots %127s", devname.c_str()) == 1) {
964 safe_cmd = ok = true;
965 } else if (sscanf(dir->msg, "autochanger drives %127s", devname.c_str()) == 1) {
967 safe_cmd = ok = true;
970 dcr = find_device(jcr, devname, -1);
973 dev->dlock(); /* Use P to avoid indefinite block */
974 if (!dev->device->changer_res) {
975 dir->fsend(_("3995 Device %s is not an autochanger.\n"),
977 /* Under certain "safe" conditions, we can steal the lock */
978 } else if (safe_cmd || !dev->is_open() || dev->can_steal_lock()) {
979 autochanger_cmd(dcr, dir, cmd);
980 } else if (dev->is_busy() || dev->is_blocked()) {
981 send_dir_busy_message(dir, dev);
982 } else { /* device not being used */
983 autochanger_cmd(dcr, dir, cmd);
988 dir->fsend(_("3999 Device \"%s\" not found or could not be opened.\n"), devname.c_str());
990 } else { /* error on scanf */
991 pm_strcpy(jcr->errmsg, dir->msg);
992 dir->fsend(_("3908 Error scanning autocharger drives/list/slots command: %s\n"),
995 dir->signal(BNET_EOD);
1000 * Read and return the Volume label
1002 static bool readlabel_cmd(JCR *jcr)
1005 BSOCK *dir = jcr->dir_bsock;
1011 if (sscanf(dir->msg, "readlabel %127s Slot=%d drive=%d", devname.c_str(),
1012 &Slot, &drive) == 3) {
1013 dcr = find_device(jcr, devname, drive);
1016 dev->dlock(); /* Use P to avoid indefinite block */
1017 if (!dev->is_open()) {
1018 read_volume_label(jcr, dcr, dev, Slot);
1020 /* Under certain "safe" conditions, we can steal the lock */
1021 } else if (dev->can_steal_lock()) {
1022 read_volume_label(jcr, dcr, dev, Slot);
1023 } else if (dev->is_busy() || dev->is_blocked()) {
1024 send_dir_busy_message(dir, dev);
1025 } else { /* device not being used */
1026 read_volume_label(jcr, dcr, dev, Slot);
1031 dir->fsend(_("3999 Device \"%s\" not found or could not be opened.\n"), devname.c_str());
1034 pm_strcpy(jcr->errmsg, dir->msg);
1035 dir->fsend(_("3909 Error scanning readlabel command: %s\n"), jcr->errmsg);
1037 dir->signal(BNET_EOD);
1043 * Read the tape label
1045 * Enter with the mutex set
1047 static void read_volume_label(JCR *jcr, DCR *dcr, DEVICE *dev, int Slot)
1049 BSOCK *dir = jcr->dir_bsock;
1053 steal_device_lock(dev, &hold, BST_WRITING_LABEL);
1055 if (!try_autoload_device(jcr, dcr, Slot, "")) {
1056 goto bail_out; /* error */
1059 dev->clear_labeled(); /* force read of label */
1060 switch (read_dev_volume_label(dcr)) {
1062 /* DO NOT add quotes around the Volume name. It is scanned in the DIR */
1063 dir->fsend(_("3001 Volume=%s Slot=%d\n"), dev->VolHdr.VolumeName, Slot);
1064 Dmsg1(100, "Volume: %s\n", dev->VolHdr.VolumeName);
1067 dir->fsend(_("3902 Cannot mount Volume on Storage Device %s because:\n%s"),
1068 dev->print_name(), jcr->errmsg);
1073 give_back_device_lock(dev, &hold);
1077 static bool try_autoload_device(JCR *jcr, DCR *dcr, int slot, const char *VolName)
1079 BSOCK *dir = jcr->dir_bsock;
1081 bstrncpy(dcr->VolumeName, VolName, sizeof(dcr->VolumeName));
1082 dcr->VolCatInfo.Slot = slot;
1083 dcr->VolCatInfo.InChanger = slot > 0;
1084 if (autoload_device(dcr, 0, dir) < 0) { /* autoload if possible */
1090 static void send_dir_busy_message(BSOCK *dir, DEVICE *dev)
1092 if (dev->is_blocked()) {
1093 switch (dev->blocked()) {
1095 dir->fsend(_("3931 Device %s is BLOCKED. user unmounted.\n"),
1098 case BST_UNMOUNTED_WAITING_FOR_SYSOP:
1099 dir->fsend(_("3932 Device %s is BLOCKED. user unmounted during wait for media/mount.\n"),
1102 case BST_WAITING_FOR_SYSOP:
1103 dir->fsend(_("3933 Device %s is BLOCKED waiting for media.\n"),
1106 case BST_DOING_ACQUIRE:
1107 dir->fsend(_("3934 Device %s is being initialized.\n"),
1110 case BST_WRITING_LABEL:
1111 dir->fsend(_("3935 Device %s is blocked labeling a Volume.\n"),
1115 dir->fsend(_("3935 Device %s is blocked for unknown reason.\n"),
1119 } else if (dev->can_read()) {
1120 dir->fsend(_("3936 Device %s is busy reading.\n"),
1121 dev->print_name());;
1123 dir->fsend(_("3937 Device %s is busy with %d writer(s).\n"),
1124 dev->print_name(), dev->num_writers);