2 * This file handles accepting Director Commands
4 * Most Director commands are handled here, with the
5 * exception of the Job command command and subsequent
6 * subcommands that are handled
9 * N.B. in this file, in general we must use P(dev->mutex) rather
10 * than lock_device(dev) so that we can examine the blocked
11 * state rather than blocking ourselves because a Job
12 * thread has the device blocked. In some "safe" cases,
13 * we can do things to a blocked device. CAREFUL!!!!
15 * File daemon commands are handled in fdcmd.c
17 * Kern Sibbald, May MMI
23 Bacula® - The Network Backup Solution
25 Copyright (C) 2001-2006 Free Software Foundation Europe e.V.
27 The main author of Bacula is Kern Sibbald, with contributions from
28 many others, a complete list can be found in the file AUTHORS.
29 This program is Free Software; you can redistribute it and/or
30 modify it under the terms of version two of the GNU General Public
31 License as published by the Free Software Foundation plus additions
32 that are listed in the file LICENSE.
34 This program is distributed in the hope that it will be useful, but
35 WITHOUT ANY WARRANTY; without even the implied warranty of
36 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
37 General Public License for more details.
39 You should have received a copy of the GNU General Public License
40 along with this program; if not, write to the Free Software
41 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
44 Bacula® is a registered trademark of John Walker.
45 The licensor of Bacula is the Free Software Foundation Europe
46 (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich,
47 Switzerland, email:ftf@fsfeurope.org.
53 /* Exported variables */
55 /* Imported variables */
56 extern BSOCK *filed_chan;
57 extern int r_first, r_last;
58 extern struct s_res resources[];
59 extern struct s_last_job last_job;
60 extern bool init_done;
62 /* Static variables */
63 static char derrmsg[] = "3900 Invalid command\n";
64 static char OKsetdebug[] = "3000 OK setdebug=%d\n";
65 static char invalid_cmd[] = "3997 Invalid command for a Director with Monitor directive enabled.\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 relabel_cmd(JCR *jcr);
79 static bool readlabel_cmd(JCR *jcr);
80 static bool release_cmd(JCR *jcr);
81 static bool setdebug_cmd(JCR *jcr);
82 static bool cancel_cmd(JCR *cjcr);
83 static bool mount_cmd(JCR *jcr);
84 static bool unmount_cmd(JCR *jcr);
85 static bool bootstrap_cmd(JCR *jcr);
86 static bool changer_cmd(JCR *sjcr);
87 static bool do_label(JCR *jcr, int relabel);
88 static DCR *find_device(JCR *jcr, POOL_MEM &dev_name, int drive);
89 static void read_volume_label(JCR *jcr, DEVICE *dev, int Slot);
90 static void label_volume_if_ok(DCR *dcr, char *oldname,
91 char *newname, char *poolname,
92 int Slot, int relabel);
93 static bool try_autoload_device(JCR *jcr, int slot, const char *VolName);
94 static void send_dir_busy_message(BSOCK *dir, DEVICE *dev);
98 bool (*func)(JCR *jcr);
99 int monitoraccess; /* specify if monitors have access to this function */
103 * The following are the recognized commands from the Director.
105 static struct s_cmds cmds[] = {
106 {"JobId=", job_cmd, 0}, /* start Job */
107 {"autochanger", changer_cmd, 0},
108 {"bootstrap", bootstrap_cmd, 0},
109 {"cancel", cancel_cmd, 0},
110 {"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;
149 char name[MAX_NAME_LENGTH];
151 if (bnet_recv(bs) <= 0) {
152 Emsg0(M_ERROR, 0, _("Connection request failed.\n"));
158 * Do a sanity check on the message received
160 if (bs->msglen < 25 || bs->msglen > (int)sizeof(name)-25) {
161 Emsg1(M_ERROR, 0, _("Invalid connection. Len=%d\n"), bs->msglen);
166 * See if this is a File daemon connection. If so
169 Dmsg1(110, "Conn: %s", bs->msg);
170 if (sscanf(bs->msg, "Hello Start Job %127s", name) == 1) {
171 handle_filed_connection(bs, name);
176 * This is a connection from the Director, so setup a JCR
178 Dmsg0(110, "Start Dir Job\n");
179 jcr = new_jcr(sizeof(JCR), stored_free_jcr); /* create Job Control Record */
180 jcr->dir_bsock = bs; /* save Director bsock */
181 jcr->dir_bsock->set_jcr(jcr);
182 jcr->dcrs = New(alist(10, not_owned_by_alist));
183 /* Initialize FD start condition variable */
184 int errstat = pthread_cond_init(&jcr->job_start_wait, NULL);
186 Jmsg1(jcr, M_FATAL, 0, _("Unable to init job cond variable: ERR=%s\n"), strerror(errstat));
190 Dmsg0(1000, "stored in start_job\n");
193 * Authenticate the Director
195 if (!authenticate_director(jcr)) {
196 Jmsg(jcr, M_FATAL, 0, _("Unable to authenticate Director\n"));
199 Dmsg0(90, "Message channel init completed.\n");
201 for (quit=false; !quit;) {
203 if ((bnet_stat = bnet_recv(bs)) <= 0) {
204 break; /* connection terminated */
206 Dmsg1(199, "<dird: %s\n", bs->msg);
207 /* Ensure that device initialization is complete */
212 for (i=0; cmds[i].cmd; i++) {
213 if (strncmp(cmds[i].cmd, bs->msg, strlen(cmds[i].cmd)) == 0) {
214 if ((!cmds[i].monitoraccess) && (jcr->director->monitor)) {
215 Dmsg1(100, "Command \"%s\" is invalid.\n", cmds[i].cmd);
216 bnet_fsend(bs, invalid_cmd);
217 bnet_sig(bs, BNET_EOD);
220 Dmsg1(200, "Do command: %s\n", cmds[i].cmd);
221 if (!cmds[i].func(jcr)) { /* do command */
222 quit = true; /* error, get out */
223 Dmsg1(190, "Command %s reqeusts quit\n", cmds[i].cmd);
225 found = true; /* indicate command found */
229 if (!found) { /* command not found */
230 bnet_fsend(bs, derrmsg);
235 generate_daemon_event(jcr, "JobEnd");
236 dequeue_messages(jcr); /* send any queued messages */
237 bnet_sig(bs, BNET_TERMINATE);
243 * Set debug level as requested by the Director
246 static bool setdebug_cmd(JCR *jcr)
248 BSOCK *dir = jcr->dir_bsock;
249 int level, trace_flag;
251 Dmsg1(10, "setdebug_cmd: %s", dir->msg);
252 if (sscanf(dir->msg, "setdebug=%d trace=%d", &level, &trace_flag) != 2 || level < 0) {
253 bnet_fsend(dir, _("3991 Bad setdebug command: %s\n"), dir->msg);
257 set_trace(trace_flag);
258 return bnet_fsend(dir, OKsetdebug, level);
265 static bool cancel_cmd(JCR *cjcr)
267 BSOCK *dir = cjcr->dir_bsock;
269 char Job[MAX_NAME_LENGTH];
272 if (sscanf(dir->msg, "cancel Job=%127s", Job) == 1) {
273 if (!(jcr=get_jcr_by_full_name(Job))) {
274 bnet_fsend(dir, _("3904 Job %s not found.\n"), Job);
277 oldStatus = jcr->JobStatus;
278 set_jcr_job_status(jcr, JS_Canceled);
279 if (!jcr->authenticated && oldStatus == JS_WaitFD) {
280 pthread_cond_signal(&jcr->job_start_wait); /* wake waiting thread */
283 if (jcr->file_bsock) {
284 bnet_sig(jcr->file_bsock, BNET_TERMINATE);
286 /* If thread waiting on mount, wake him */
287 if (jcr->dcr && jcr->dcr->dev && jcr->dcr->dev->waiting_for_mount()) {
288 pthread_cond_broadcast(&jcr->dcr->dev->wait_next_vol);
289 pthread_cond_broadcast(&wait_device_release);
291 if (jcr->read_dcr && jcr->read_dcr->dev && jcr->read_dcr->dev->waiting_for_mount()) {
292 pthread_cond_broadcast(&jcr->read_dcr->dev->wait_next_vol);
293 pthread_cond_broadcast(&wait_device_release);
295 Jmsg(jcr, M_INFO, 0, _("Job marked to be canceled.\n"));
296 bnet_fsend(dir, _("3000 Job %s marked to be canceled.\n"), jcr->Job);
300 bnet_fsend(dir, _("3903 Error scanning cancel command.\n"));
302 bnet_sig(dir, BNET_EOD);
310 static bool label_cmd(JCR *jcr)
312 return do_label(jcr, 0);
315 static bool relabel_cmd(JCR *jcr)
317 return do_label(jcr, 1);
320 static bool do_label(JCR *jcr, int relabel)
322 POOLMEM *newname, *oldname, *poolname, *mtype;
324 BSOCK *dir = jcr->dir_bsock;
331 newname = get_memory(dir->msglen+1);
332 oldname = get_memory(dir->msglen+1);
333 poolname = get_memory(dir->msglen+1);
334 mtype = get_memory(dir->msglen+1);
336 if (sscanf(dir->msg, "relabel %127s OldName=%127s NewName=%127s PoolName=%127s "
337 "MediaType=%127s Slot=%d drive=%d",
338 dev_name.c_str(), oldname, newname, poolname, mtype,
339 &slot, &drive) == 7) {
344 if (sscanf(dir->msg, "label %127s VolumeName=%127s PoolName=%127s "
345 "MediaType=%127s Slot=%d drive=%d",
346 dev_name.c_str(), newname, poolname, mtype, &slot, &drive) == 6) {
351 unbash_spaces(newname);
352 unbash_spaces(oldname);
353 unbash_spaces(poolname);
354 unbash_spaces(mtype);
355 dcr = find_device(jcr, dev_name, drive);
358 P(dev->mutex); /* Use P to avoid indefinite block */
359 if (!dev->is_open()) {
360 Dmsg1(400, "Can %slabel. Device is not open\n", relabel?"re":"");
361 label_volume_if_ok(dcr, oldname, newname, poolname, slot, relabel);
363 /* Under certain "safe" conditions, we can steal the lock */
364 } else if (dev->can_steal_lock()) {
365 Dmsg0(400, "Can relabel. can_steal_lock\n");
366 label_volume_if_ok(dcr, oldname, newname, poolname, slot, relabel);
367 } else if (dev->is_busy() || dev->is_blocked()) {
368 send_dir_busy_message(dir, dev);
369 } else { /* device not being used */
370 Dmsg0(400, "Can relabel. device not used\n");
371 label_volume_if_ok(dcr, oldname, newname, poolname, slot, relabel);
377 bnet_fsend(dir, _("3999 Device \"%s\" not found or could not be opened.\n"), dev_name.c_str());
380 /* NB dir->msg gets clobbered in bnet_fsend, so save command */
381 pm_strcpy(jcr->errmsg, dir->msg);
382 bnet_fsend(dir, _("3903 Error scanning label command: %s\n"), jcr->errmsg);
384 free_memory(oldname);
385 free_memory(newname);
386 free_memory(poolname);
388 bnet_sig(dir, BNET_EOD);
393 * Read the tape label and determine if we can safely
394 * label the tape (not a Bacula volume), then label it.
396 * Enter with the mutex set
398 static void label_volume_if_ok(DCR *dcr, char *oldname,
399 char *newname, char *poolname,
400 int slot, int relabel)
402 BSOCK *dir = dcr->jcr->dir_bsock;
404 DEVICE *dev = dcr->dev;
407 const char *volname = (relabel == 1) ? oldname : newname;
410 steal_device_lock(dev, &hold, BST_WRITING_LABEL);
411 Dmsg1(100, "Stole device %s lock, writing label.\n", dev->print_name());
414 Dmsg0(90, "try_autoload_device - looking for volume_info\n");
415 if (!try_autoload_device(dcr->jcr, slot, volname)) {
416 goto bail_out; /* error */
419 /* Ensure that the device is open -- autoload_device() closes it */
420 if (dev->is_tape()) {
421 mode = OPEN_READ_WRITE;
423 mode = CREATE_READ_WRITE;
427 dev->truncating = true; /* let open() know we will truncate it */
429 /* Set old volume name for open if relabeling */
430 bstrncpy(dcr->VolCatInfo.VolCatName, volname, sizeof(dcr->VolCatInfo.VolCatName));
431 if (dev->open(dcr, mode) < 0) {
432 bnet_fsend(dir, _("3910 Unable to open device %s: ERR=%s\n"),
433 dev->print_name(), dev->strerror());
437 /* See what we have for a Volume */
438 label_status = read_dev_volume_label(dcr);
440 /* Set new volume name */
441 bstrncpy(dcr->VolCatInfo.VolCatName, newname, sizeof(dcr->VolCatInfo.VolCatName));
442 switch(label_status) {
444 case VOL_VERSION_ERROR:
445 case VOL_LABEL_ERROR:
449 "3920 Cannot label Volume because it is already labeled: \"%s\"\n"),
450 dev->VolHdr.VolumeName);
454 /* Relabel request. If oldname matches, continue */
455 if (strcmp(oldname, dev->VolHdr.VolumeName) != 0) {
456 bnet_fsend(dir, _("3921 Wrong volume mounted.\n"));
459 if (dev->label_type != B_BACULA_LABEL) {
460 bnet_fsend(dir, _("3922 Cannot relabel an ANSI/IBM labeled Volume.\n"));
463 /* Fall through wanted! */
466 if (!write_new_volume_label_to_dev(dcr, newname, poolname,
467 relabel, true /* write dvd now */)) {
468 bnet_fsend(dir, _("3912 Failed to label Volume: ERR=%s\n"), dev->bstrerror());
471 bstrncpy(dcr->VolumeName, newname, sizeof(dcr->VolumeName));
472 /* The following 3000 OK label. string is scanned in ua_label.c */
473 bnet_fsend(dir, "3000 OK label. VolBytes=%s DVD=%d Volume=\"%s\" Device=%s\n",
474 edit_uint64(dev->VolCatInfo.VolCatBytes, ed1),
475 dev->is_dvd()?1:0, newname, dev->print_name());
478 bnet_fsend(dir, _("3912 Failed to label Volume: ERR=%s\n"), dev->bstrerror());
481 bnet_fsend(dir, _("3913 Cannot label Volume. "
482 "Unknown status %d from read_volume_label()\n"), label_status);
487 if (!dev->is_open()) {
490 give_back_device_lock(dev, &hold);
496 * Read the tape label
498 * Enter with the mutex set
500 static bool read_label(DCR *dcr)
504 BSOCK *dir = jcr->dir_bsock;
506 DEVICE *dev = dcr->dev;
508 steal_device_lock(dev, &hold, BST_DOING_ACQUIRE);
510 dcr->VolumeName[0] = 0;
511 dev->clear_labeled(); /* force read of label */
512 switch (read_dev_volume_label(dcr)) {
514 bnet_fsend(dir, _("3001 Mounted Volume: %s\n"), dev->VolHdr.VolumeName);
518 bnet_fsend(dir, _("3902 Cannot mount Volume on Storage Device %s because:\n%s"),
519 dev->print_name(), jcr->errmsg);
523 give_back_device_lock(dev, &hold);
528 * Searches for device by name, and if found, creates a dcr and
531 static DCR *find_device(JCR *jcr, POOL_MEM &devname, int drive)
534 AUTOCHANGER *changer;
538 unbash_spaces(devname);
539 foreach_res(device, R_DEVICE) {
540 /* Find resource, and make sure we were able to open it */
541 if (fnmatch(device->hdr.name, devname.c_str(), 0) == 0) {
543 device->dev = init_dev(jcr, device);
546 Jmsg(jcr, M_WARNING, 0, _("\n"
547 " Device \"%s\" requested by DIR could not be opened or does not exist.\n"),
551 Dmsg1(20, "Found device %s\n", device->hdr.name);
557 foreach_res(changer, R_AUTOCHANGER) {
558 /* Find resource, and make sure we were able to open it */
559 if (fnmatch(devname.c_str(), changer->hdr.name, 0) == 0) {
560 /* Try each device in this AutoChanger */
561 foreach_alist(device, changer->device) {
562 Dmsg1(100, "Try changer device %s\n", device->hdr.name);
564 device->dev = init_dev(jcr, device);
567 Dmsg1(100, "Device %s could not be opened. Skipped\n", devname.c_str());
568 Jmsg(jcr, M_WARNING, 0, _("\n"
569 " Device \"%s\" in changer \"%s\" requested by DIR could not be opened or does not exist.\n"),
570 device->hdr.name, devname.c_str());
573 if (!device->dev->autoselect) {
574 Dmsg1(100, "Device %s not autoselect skipped.\n", devname.c_str());
575 continue; /* device is not available */
577 if (drive < 0 || drive == (int)device->dev->drive_index) {
578 Dmsg1(20, "Found changer device %s\n", device->hdr.name);
582 Dmsg3(100, "Device %s drive wrong: want=%d got=%d skipping\n",
583 devname.c_str(), drive, (int)device->dev->drive_index);
585 break; /* we found it but could not open a device */
591 Dmsg1(100, "Found device %s\n", device->hdr.name);
592 dcr = new_dcr(jcr, device->dev);
593 dcr->device = device;
601 * Mount command from Director
603 static bool mount_cmd(JCR *jcr)
606 BSOCK *dir = jcr->dir_bsock;
613 ok = sscanf(dir->msg, "mount %127s drive=%d slot=%d", devname.c_str(),
616 ok = sscanf(dir->msg, "mount %127s drive=%d", devname.c_str(), &drive) == 2;
619 dcr = find_device(jcr, devname, drive);
622 P(dev->mutex); /* Use P to avoid indefinite block */
623 Dmsg1(100, "mount cmd blocked=%d\n", dev->dev_blocked);
624 switch (dev->dev_blocked) { /* device blocked? */
625 case BST_WAITING_FOR_SYSOP:
626 /* Someone is waiting, wake him */
627 Dmsg0(100, "Waiting for mount. Attempting to wake thread\n");
628 dev->dev_blocked = BST_MOUNT;
629 bnet_fsend(dir, "3001 OK mount. Device=%s\n",
631 pthread_cond_broadcast(&dev->wait_next_vol);
632 pthread_cond_broadcast(&wait_device_release);
635 /* In both of these two cases, we (the user) unmounted the Volume */
636 case BST_UNMOUNTED_WAITING_FOR_SYSOP:
638 if (dev->is_autochanger() && slot > 0) {
639 try_autoload_device(jcr, slot, "");
641 /* We freed the device, so reopen it and wake any waiting threads */
642 if (dev->open(dcr, OPEN_READ_ONLY) < 0) {
643 bnet_fsend(dir, _("3901 open device failed: ERR=%s\n"),
645 if (dev->dev_blocked == BST_UNMOUNTED) {
646 /* We blocked the device, so unblock it */
647 Dmsg0(100, "Unmounted. Unblocking device\n");
652 read_dev_volume_label(dcr);
653 if (dev->dev_blocked == BST_UNMOUNTED) {
654 /* We blocked the device, so unblock it */
655 Dmsg0(100, "Unmounted. Unblocking device\n");
656 read_label(dcr); /* this should not be necessary */
659 Dmsg0(100, "Unmounted waiting for mount. Attempting to wake thread\n");
660 dev->dev_blocked = BST_MOUNT;
662 if (dev->is_labeled()) {
663 bnet_fsend(dir, _("3001 Device %s is mounted with Volume \"%s\"\n"),
664 dev->print_name(), dev->VolHdr.VolumeName);
666 bnet_fsend(dir, _("3905 Device %s open but no Bacula volume is mounted.\n"
667 "If this is not a blank tape, try unmounting and remounting the Volume.\n"),
670 pthread_cond_broadcast(&dev->wait_next_vol);
671 pthread_cond_broadcast(&wait_device_release);
674 case BST_DOING_ACQUIRE:
675 bnet_fsend(dir, _("3001 Device %s is doing acquire.\n"),
679 case BST_WRITING_LABEL:
680 bnet_fsend(dir, _("3903 Device %s is being labeled.\n"),
684 case BST_NOT_BLOCKED:
685 if (dev->is_autochanger() && slot > 0) {
686 try_autoload_device(jcr, slot, "");
688 if (dev->is_open()) {
689 if (dev->is_labeled()) {
690 bnet_fsend(dir, _("3001 Device %s is mounted with Volume \"%s\"\n"),
691 dev->print_name(), dev->VolHdr.VolumeName);
693 bnet_fsend(dir, _("3905 Device %s open but no Bacula volume is mounted.\n"
694 "If this is not a blank tape, try unmounting and remounting the Volume.\n"),
697 } else if (dev->is_tape()) {
698 if (dev->open(dcr, OPEN_READ_ONLY) < 0) {
699 bnet_fsend(dir, _("3901 open device failed: ERR=%s\n"),
704 if (dev->is_labeled()) {
705 bnet_fsend(dir, _("3001 Device %s is already mounted with Volume \"%s\"\n"),
706 dev->print_name(), dev->VolHdr.VolumeName);
708 bnet_fsend(dir, _("3905 Device %s open but no Bacula volume is mounted.\n"
709 "If this is not a blank tape, try unmounting and remounting the Volume.\n"),
712 } else if (dev->is_dvd()) {
714 bnet_fsend(dir, _("3002 Device %s is mounted.\n"),
717 bnet_fsend(dir, _("3907 %s"), dev->bstrerror());
719 } else { /* must be file */
720 bnet_fsend(dir, _("3906 File device %s is always mounted.\n"),
726 bnet_fsend(dir, _("3905 Bizarre wait state %d\n"), dev->dev_blocked);
733 bnet_fsend(dir, _("3999 Device \"%s\" not found or could not be opened.\n"), devname.c_str());
736 pm_strcpy(jcr->errmsg, dir->msg);
737 bnet_fsend(dir, _("3909 Error scanning mount command: %s\n"), jcr->errmsg);
739 bnet_sig(dir, BNET_EOD);
744 * unmount command from Director
746 static bool unmount_cmd(JCR *jcr)
749 BSOCK *dir = jcr->dir_bsock;
754 if (sscanf(dir->msg, "unmount %127s drive=%d", devname.c_str(), &drive) == 2) {
755 dcr = find_device(jcr, devname, drive);
758 P(dev->mutex); /* Use P to avoid indefinite block */
759 if (!dev->is_open()) {
760 if (!dev->is_busy()) {
761 unload_autochanger(dcr, -1);
764 if (dev->unmount(0)) {
765 bnet_fsend(dir, _("3002 Device %s unmounted.\n"),
768 bnet_fsend(dir, _("3907 %s"), dev->bstrerror());
771 Dmsg0(90, "Device already unmounted\n");
772 bnet_fsend(dir, _("3901 Device %s is already unmounted.\n"),
775 } else if (dev->dev_blocked == BST_WAITING_FOR_SYSOP) {
776 Dmsg2(90, "%d waiter dev_block=%d. doing unmount\n", dev->num_waiting,
778 if (!unload_autochanger(dcr, -1)) {
779 /* ***FIXME**** what is this ???? */
782 if (dev->is_dvd() && !dev->unmount(0)) {
783 bnet_fsend(dir, _("3907 %s"), dev->bstrerror());
785 dev->dev_blocked = BST_UNMOUNTED_WAITING_FOR_SYSOP;
786 bnet_fsend(dir, _("3001 Device %s unmounted.\n"),
790 } else if (dev->dev_blocked == BST_DOING_ACQUIRE) {
791 bnet_fsend(dir, _("3902 Device %s is busy in acquire.\n"),
794 } else if (dev->dev_blocked == BST_WRITING_LABEL) {
795 bnet_fsend(dir, _("3903 Device %s is being labeled.\n"),
798 } else if (dev->is_busy()) {
799 send_dir_busy_message(dir, dev);
800 } else { /* device not being used */
801 Dmsg0(90, "Device not in use, unmounting\n");
802 /* On FreeBSD, I am having ASSERT() failures in block_device()
803 * and I can only imagine that the thread id that we are
804 * leaving in no_wait_id is being re-used. So here,
805 * we simply do it by hand. Gross, but a solution.
807 /* block_device(dev, BST_UNMOUNTED); replace with 2 lines below */
808 dev->dev_blocked = BST_UNMOUNTED;
810 if (!unload_autochanger(dcr, -1)) {
813 if (dev->is_dvd() && !dev->unmount(0)) {
814 bnet_fsend(dir, _("3907 %s"), dev->bstrerror());
816 bnet_fsend(dir, _("3002 Device %s unmounted.\n"),
824 bnet_fsend(dir, _("3999 Device \"%s\" not found or could not be opened.\n"), devname.c_str());
827 /* NB dir->msg gets clobbered in bnet_fsend, so save command */
828 pm_strcpy(jcr->errmsg, dir->msg);
829 bnet_fsend(dir, _("3907 Error scanning unmount command: %s\n"), jcr->errmsg);
831 bnet_sig(dir, BNET_EOD);
836 * Release command from Director. This rewinds the device and if
837 * configured does a offline and ensures that Bacula will
838 * re-read the label of the tape before continuing. This gives
839 * the operator the chance to change the tape anytime before the
842 static bool release_cmd(JCR *jcr)
845 BSOCK *dir = jcr->dir_bsock;
850 if (sscanf(dir->msg, "release %127s drive=%d", devname.c_str(), &drive) == 2) {
851 dcr = find_device(jcr, devname, drive);
854 P(dev->mutex); /* Use P to avoid indefinite block */
855 if (!dev->is_open()) {
856 if (!dev->is_busy()) {
857 unload_autochanger(dcr, -1);
859 Dmsg0(90, "Device already released\n");
860 bnet_fsend(dir, _("3921 Device %s already released.\n"),
863 } else if (dev->dev_blocked == BST_WAITING_FOR_SYSOP) {
864 Dmsg2(90, "%d waiter dev_block=%d.\n", dev->num_waiting,
866 unload_autochanger(dcr, -1);
867 bnet_fsend(dir, _("3922 Device %s waiting for sysop.\n"),
870 } else if (dev->dev_blocked == BST_UNMOUNTED_WAITING_FOR_SYSOP) {
871 Dmsg2(90, "%d waiter dev_block=%d. doing unmount\n", dev->num_waiting,
873 bnet_fsend(dir, _("3922 Device %s waiting for mount.\n"),
876 } else if (dev->dev_blocked == BST_DOING_ACQUIRE) {
877 bnet_fsend(dir, _("3923 Device %s is busy in acquire.\n"),
880 } else if (dev->dev_blocked == BST_WRITING_LABEL) {
881 bnet_fsend(dir, _("3914 Device %s is being labeled.\n"),
884 } else if (dev->is_busy()) {
885 send_dir_busy_message(dir, dev);
886 } else { /* device not being used */
887 Dmsg0(90, "Device not in use, releaseing\n");
888 unload_autochanger(dcr, -1);
890 bnet_fsend(dir, _("3022 Device %s released.\n"),
897 bnet_fsend(dir, _("3999 Device \"%s\" not found or could not be opened.\n"), devname.c_str());
900 /* NB dir->msg gets clobbered in bnet_fsend, so save command */
901 pm_strcpy(jcr->errmsg, dir->msg);
902 bnet_fsend(dir, _("3927 Error scanning release command: %s\n"), jcr->errmsg);
904 bnet_sig(dir, BNET_EOD);
909 static bool bootstrap_cmd(JCR *jcr)
911 return get_bootstrap_file(jcr, jcr->dir_bsock);
915 * Autochanger command from Director
917 static bool changer_cmd(JCR *jcr)
920 BSOCK *dir = jcr->dir_bsock;
923 const char *cmd = NULL;
926 * A safe_cmd may call autochanger script but does not load/unload
927 * slots so it can be done at the same time that the drive is open.
929 bool safe_cmd = false;
931 if (sscanf(dir->msg, "autochanger list %127s", devname.c_str()) == 1) {
933 safe_cmd = ok = true;
934 } else if (sscanf(dir->msg, "autochanger slots %127s", devname.c_str()) == 1) {
936 safe_cmd = ok = true;
937 } else if (sscanf(dir->msg, "autochanger drives %127s", devname.c_str()) == 1) {
939 safe_cmd = ok = true;
942 dcr = find_device(jcr, devname, -1);
945 P(dev->mutex); /* Use P to avoid indefinite block */
946 if (!dev->device->changer_res) {
947 bnet_fsend(dir, _("3995 Device %s is not an autochanger.\n"),
949 /* Under certain "safe" conditions, we can steal the lock */
950 } else if (safe_cmd || !dev->is_open() || dev->can_steal_lock()) {
951 autochanger_cmd(dcr, dir, cmd);
952 } else if (dev->is_busy() || dev->is_blocked()) {
953 send_dir_busy_message(dir, dev);
954 } else { /* device not being used */
955 autochanger_cmd(dcr, dir, cmd);
961 bnet_fsend(dir, _("3999 Device \"%s\" not found or could not be opened.\n"), devname.c_str());
963 } else { /* error on scanf */
964 pm_strcpy(jcr->errmsg, dir->msg);
965 bnet_fsend(dir, _("3908 Error scanning autocharger drives/list/slots command: %s\n"),
968 bnet_sig(dir, BNET_EOD);
973 * Read and return the Volume label
975 static bool readlabel_cmd(JCR *jcr)
978 BSOCK *dir = jcr->dir_bsock;
984 if (sscanf(dir->msg, "readlabel %127s Slot=%d drive=%d", devname.c_str(),
985 &Slot, &drive) == 3) {
986 dcr = find_device(jcr, devname, drive);
989 P(dev->mutex); /* Use P to avoid indefinite block */
990 if (!dev->is_open()) {
991 read_volume_label(jcr, dev, Slot);
993 /* Under certain "safe" conditions, we can steal the lock */
994 } else if (dev->can_steal_lock()) {
995 read_volume_label(jcr, dev, Slot);
996 } else if (dev->is_busy() || dev->is_blocked()) {
997 send_dir_busy_message(dir, dev);
998 } else { /* device not being used */
999 read_volume_label(jcr, dev, Slot);
1005 bnet_fsend(dir, _("3999 Device \"%s\" not found or could not be opened.\n"), devname.c_str());
1008 pm_strcpy(jcr->errmsg, dir->msg);
1009 bnet_fsend(dir, _("3909 Error scanning readlabel command: %s\n"), jcr->errmsg);
1011 bnet_sig(dir, BNET_EOD);
1017 * Read the tape label
1019 * Enter with the mutex set
1021 static void read_volume_label(JCR *jcr, DEVICE *dev, int Slot)
1023 BSOCK *dir = jcr->dir_bsock;
1025 DCR *dcr = jcr->dcr;
1028 steal_device_lock(dev, &hold, BST_WRITING_LABEL);
1030 if (!try_autoload_device(jcr, Slot, "")) {
1031 goto bail_out; /* error */
1034 dev->clear_labeled(); /* force read of label */
1035 switch (read_dev_volume_label(dcr)) {
1037 /* DO NOT add quotes around the Volume name. It is scanned in the DIR */
1038 bnet_fsend(dir, _("3001 Volume=%s Slot=%d\n"), dev->VolHdr.VolumeName, Slot);
1039 Dmsg1(100, "Volume: %s\n", dev->VolHdr.VolumeName);
1042 bnet_fsend(dir, _("3902 Cannot mount Volume on Storage Device %s because:\n%s"),
1043 dev->print_name(), jcr->errmsg);
1048 give_back_device_lock(dev, &hold);
1052 static bool try_autoload_device(JCR *jcr, int slot, const char *VolName)
1054 DCR *dcr = jcr->dcr;
1055 BSOCK *dir = jcr->dir_bsock;
1057 bstrncpy(dcr->VolumeName, VolName, sizeof(dcr->VolumeName));
1058 dcr->VolCatInfo.Slot = slot;
1059 dcr->VolCatInfo.InChanger = slot > 0;
1060 if (autoload_device(dcr, 0, dir) < 0) { /* autoload if possible */
1066 static void send_dir_busy_message(BSOCK *dir, DEVICE *dev)
1068 if (dev->is_blocked()) {
1069 switch (dev->dev_blocked) {
1071 bnet_fsend(dir, _("3931 Device %s is BLOCKED. user unmounted.\n"),
1074 case BST_UNMOUNTED_WAITING_FOR_SYSOP:
1075 bnet_fsend(dir, _("3932 Device %s is BLOCKED. user unmounted during wait for media/mount.\n"),
1078 case BST_WAITING_FOR_SYSOP:
1079 bnet_fsend(dir, _("3933 Device %s is BLOCKED waiting for media.\n"),
1082 case BST_DOING_ACQUIRE:
1083 bnet_fsend(dir, _("3934 Device %s is being initialized.\n"),
1086 case BST_WRITING_LABEL:
1087 bnet_fsend(dir, _("3935 Device %s is blocked labeling a Volume.\n"),
1091 bnet_fsend(dir, _("3935 Device %s is blocked for unknown reason.\n"),
1095 } else if (dev->can_read()) {
1096 bnet_fsend(dir, _("3936 Device %s is busy reading.\n"),
1097 dev->print_name());;
1099 bnet_fsend(dir, _("3937 Device %s is busy with %d writer(s).\n"),
1100 dev->print_name(), dev->num_writers);