X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=bacula%2Fsrc%2Fstored%2Fdircmd.c;h=e339602cf176613ffed70f5e62eea8e889363b32;hb=1a5f3848bea19e7965f9794d1330914ebfed790a;hp=5c6817972a85e8c85ce5b7c9a10d0ebd09d5be9a;hpb=fc92af306f2cd876b24b4858a15d05b18f525b6e;p=bacula%2Fbacula diff --git a/bacula/src/stored/dircmd.c b/bacula/src/stored/dircmd.c index 5c6817972a..e339602cf1 100644 --- a/bacula/src/stored/dircmd.c +++ b/bacula/src/stored/dircmd.c @@ -1,3 +1,30 @@ +/* + Bacula® - The Network Backup Solution + + Copyright (C) 2001-2010 Free Software Foundation Europe e.V. + + The main author of Bacula is Kern Sibbald, with contributions from + many others, a complete list can be found in the file AUTHORS. + This program is Free Software; you can redistribute it and/or + modify it under the terms of version three of the GNU Affero General Public + License as published by the Free Software Foundation and included + in the file LICENSE. + + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + 02110-1301, USA. + + Bacula® is a registered trademark of Kern Sibbald. + The licensor of Bacula is the Free Software Foundation Europe + (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich, + Switzerland, email:ftf@fsfeurope.org. +*/ /* * This file handles accepting Director Commands * @@ -7,7 +34,7 @@ * in job.c. * * N.B. in this file, in general we must use P(dev->mutex) rather - * than lock_device(dev) so that we can examine the blocked + * than dev->r_lock() so that we can examine the blocked * state rather than blocking ourselves because a Job * thread has the device blocked. In some "safe" cases, * we can do things to a blocked device. CAREFUL!!!! @@ -16,22 +43,6 @@ * * Kern Sibbald, May MMI * - * Version $Id$ - * - */ -/* - Copyright (C) 2001-2006 Kern Sibbald - - This program is free software; you can redistribute it and/or - modify it under the terms of the GNU General Public License - version 2 as amended with additional clauses defined in the - file LICENSE in the main source directory. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - the file LICENSE for additional details. - */ #include "bacula.h" @@ -41,17 +52,15 @@ /* Imported variables */ extern BSOCK *filed_chan; -extern int r_first, r_last; -extern struct s_res resources[]; -extern char my_name[]; -extern time_t daemon_start_time; extern struct s_last_job last_job; extern bool init_done; /* Static variables */ -static char derrmsg[] = "3900 Invalid command\n"; +static char derrmsg[] = "3900 Invalid command:"; static char OKsetdebug[] = "3000 OK setdebug=%d\n"; -static char illegal_cmd[] = "3997 Illegal command for a Director with Monitor directive enabled\n"; +static char invalid_cmd[] = "3997 Invalid command for a Director with Monitor directive enabled.\n"; +static char OK_bootstrap[] = "3000 OK bootstrap\n"; +static char ERROR_bootstrap[] = "3904 Error bootstrap\n"; /* Imported functions */ extern void terminate_child(); @@ -64,6 +73,7 @@ extern bool qstatus_cmd(JCR *jcr); /* Forward referenced functions */ static bool label_cmd(JCR *jcr); +static bool die_cmd(JCR *jcr); static bool relabel_cmd(JCR *jcr); static bool readlabel_cmd(JCR *jcr); static bool release_cmd(JCR *jcr); @@ -71,21 +81,22 @@ static bool setdebug_cmd(JCR *jcr); static bool cancel_cmd(JCR *cjcr); static bool mount_cmd(JCR *jcr); static bool unmount_cmd(JCR *jcr); +//static bool action_on_purge_cmd(JCR *jcr); static bool bootstrap_cmd(JCR *jcr); static bool changer_cmd(JCR *sjcr); static bool do_label(JCR *jcr, int relabel); static DCR *find_device(JCR *jcr, POOL_MEM &dev_name, int drive); -static void read_volume_label(JCR *jcr, DEVICE *dev, int Slot); +static void read_volume_label(JCR *jcr, DCR *dcr, DEVICE *dev, int Slot); static void label_volume_if_ok(DCR *dcr, char *oldname, char *newname, char *poolname, int Slot, int relabel); -static bool try_autoload_device(JCR *jcr, int slot, const char *VolName); +static bool try_autoload_device(JCR *jcr, DCR *dcr, int slot, const char *VolName); static void send_dir_busy_message(BSOCK *dir, DEVICE *dev); struct s_cmds { const char *cmd; bool (*func)(JCR *jcr); - int monitoraccess; /* specify if monitors have access to this function */ + bool monitoraccess; /* set if monitors can access this cmd */ }; /* @@ -96,6 +107,7 @@ static struct s_cmds cmds[] = { {"autochanger", changer_cmd, 0}, {"bootstrap", bootstrap_cmd, 0}, {"cancel", cancel_cmd, 0}, + {".die", die_cmd, 0}, {"label", label_cmd, 0}, /* label a tape */ {"mount", mount_cmd, 0}, {"readlabel", readlabel_cmd, 0}, @@ -105,6 +117,7 @@ static struct s_cmds cmds[] = { {"status", status_cmd, 1}, {".status", qstatus_cmd, 1}, {"unmount", unmount_cmd, 0}, +// {"action_on_purge", action_on_purge_cmd, 0}, {"use storage=", use_cmd, 0}, {"run", run_cmd, 0}, // {"query", query_cmd, 0}, @@ -135,20 +148,22 @@ void *handle_connection_request(void *arg) int i; bool found, quit; int bnet_stat = 0; - char name[MAX_NAME_LENGTH]; + char name[500]; + char tbuf[100]; - if (bnet_recv(bs) <= 0) { - Emsg0(M_ERROR, 0, _("Connection request failed.\n")); - bnet_close(bs); + if (bs->recv() <= 0) { + Emsg1(M_ERROR, 0, _("Connection request from %s failed.\n"), bs->who()); + bs->close(); return NULL; } /* * Do a sanity check on the message received */ - if (bs->msglen < 25 || bs->msglen > (int)sizeof(name)-25) { - Emsg1(M_ERROR, 0, _("Invalid connection. Len=%d\n"), bs->msglen); - bnet_close(bs); + if (bs->msglen < 25 || bs->msglen > (int)sizeof(name)) { + Dmsg1(000, "msg); + Emsg2(M_ERROR, 0, _("Invalid connection from %s. Len=%d\n"), bs->who(), bs->msglen); + bs->close(); return NULL; } /* @@ -156,7 +171,13 @@ void *handle_connection_request(void *arg) * call FD handler. */ Dmsg1(110, "Conn: %s", bs->msg); + if (debug_level == 3) { + Dmsg1(000, "msg); + } if (sscanf(bs->msg, "Hello Start Job %127s", name) == 1) { + Dmsg1(110, "Got a FD connection at %s\n", bstrftimes(tbuf, sizeof(tbuf), + (utime_t)time(NULL))); + Dmsg1(50, "%s", bs->msg); handle_filed_connection(bs, name); return NULL; } @@ -164,15 +185,17 @@ void *handle_connection_request(void *arg) /* * This is a connection from the Director, so setup a JCR */ - Dmsg0(110, "Start Dir Job\n"); + Dmsg1(110, "Got a DIR connection at %s\n", bstrftimes(tbuf, sizeof(tbuf), + (utime_t)time(NULL))); jcr = new_jcr(sizeof(JCR), stored_free_jcr); /* create Job Control Record */ jcr->dir_bsock = bs; /* save Director bsock */ - jcr->dir_bsock->jcr = jcr; + jcr->dir_bsock->set_jcr(jcr); jcr->dcrs = New(alist(10, not_owned_by_alist)); /* Initialize FD start condition variable */ int errstat = pthread_cond_init(&jcr->job_start_wait, NULL); if (errstat != 0) { - Jmsg1(jcr, M_FATAL, 0, _("Unable to init job cond variable: ERR=%s\n"), strerror(errstat)); + berrno be; + Jmsg1(jcr, M_FATAL, 0, _("Unable to init job cond variable: ERR=%s\n"), be.bstrerror(errstat)); goto bail_out; } @@ -189,7 +212,7 @@ void *handle_connection_request(void *arg) for (quit=false; !quit;) { /* Read command */ - if ((bnet_stat = bnet_recv(bs)) <= 0) { + if ((bnet_stat = bs->recv()) <= 0) { break; /* connection terminated */ } Dmsg1(199, "msg); @@ -201,33 +224,53 @@ void *handle_connection_request(void *arg) for (i=0; cmds[i].cmd; i++) { if (strncmp(cmds[i].cmd, bs->msg, strlen(cmds[i].cmd)) == 0) { if ((!cmds[i].monitoraccess) && (jcr->director->monitor)) { - Dmsg1(100, "Command %s illegal.\n", cmds[i].cmd); - bnet_fsend(bs, illegal_cmd); - bnet_sig(bs, BNET_EOD); + Dmsg1(100, "Command \"%s\" is invalid.\n", cmds[i].cmd); + bs->fsend(invalid_cmd); + bs->signal(BNET_EOD); break; } Dmsg1(200, "Do command: %s\n", cmds[i].cmd); if (!cmds[i].func(jcr)) { /* do command */ quit = true; /* error, get out */ - Dmsg1(190, "Command %s requsts quit\n", cmds[i].cmd); + Dmsg1(190, "Command %s requests quit\n", cmds[i].cmd); } found = true; /* indicate command found */ break; } } if (!found) { /* command not found */ - bnet_fsend(bs, derrmsg); + POOL_MEM err_msg; + Mmsg(err_msg, "%s %s\n", derrmsg, bs->msg); + bs->fsend(err_msg.c_str()); break; } } bail_out: generate_daemon_event(jcr, "JobEnd"); dequeue_messages(jcr); /* send any queued messages */ - bnet_sig(bs, BNET_TERMINATE); + bs->signal(BNET_TERMINATE); free_jcr(jcr); return NULL; } + +/* + * Force SD to die, and hopefully dump itself. Turned on only + * in development version. + */ +static bool die_cmd(JCR *jcr) +{ +#ifdef DEVELOPER + JCR *djcr = NULL; + int a; + Pmsg0(000, "I have been requested to die ..."); + a = djcr->JobId; /* ref NULL pointer */ +#endif + return 0; +} + + + /* * Set debug level as requested by the Director * @@ -239,12 +282,12 @@ static bool setdebug_cmd(JCR *jcr) Dmsg1(10, "setdebug_cmd: %s", dir->msg); if (sscanf(dir->msg, "setdebug=%d trace=%d", &level, &trace_flag) != 2 || level < 0) { - bnet_fsend(dir, _("3991 Bad setdebug command: %s\n"), dir->msg); + dir->fsend(_("3991 Bad setdebug command: %s\n"), dir->msg); return 0; } debug_level = level; set_trace(trace_flag); - return bnet_fsend(dir, OKsetdebug, level); + return dir->fsend(OKsetdebug, level); } @@ -260,34 +303,43 @@ static bool cancel_cmd(JCR *cjcr) if (sscanf(dir->msg, "cancel Job=%127s", Job) == 1) { if (!(jcr=get_jcr_by_full_name(Job))) { - bnet_fsend(dir, _("3904 Job %s not found.\n"), Job); + dir->fsend(_("3904 Job %s not found.\n"), Job); } else { - P(jcr->mutex); oldStatus = jcr->JobStatus; set_jcr_job_status(jcr, JS_Canceled); + Dmsg2(800, "Cancel JobId=%d %p\n", jcr->JobId, jcr); if (!jcr->authenticated && oldStatus == JS_WaitFD) { pthread_cond_signal(&jcr->job_start_wait); /* wake waiting thread */ } - V(jcr->mutex); if (jcr->file_bsock) { - bnet_sig(jcr->file_bsock, BNET_TERMINATE); + jcr->file_bsock->signal(BNET_TERMINATE); + jcr->file_bsock->set_terminated(); + Dmsg2(800, "Term bsock jid=%d %p\n", jcr->JobId, jcr); + } else { + /* Still waiting for FD to connect, release it */ + pthread_cond_signal(&jcr->job_start_wait); /* wake waiting job */ + Dmsg2(800, "Signal FD connect jid=%d %p\n", jcr->JobId, jcr); } /* If thread waiting on mount, wake him */ if (jcr->dcr && jcr->dcr->dev && jcr->dcr->dev->waiting_for_mount()) { pthread_cond_broadcast(&jcr->dcr->dev->wait_next_vol); + Dmsg1(100, "JobId=%u broadcast wait_device_release\n", (uint32_t)jcr->JobId); pthread_cond_broadcast(&wait_device_release); } if (jcr->read_dcr && jcr->read_dcr->dev && jcr->read_dcr->dev->waiting_for_mount()) { pthread_cond_broadcast(&jcr->read_dcr->dev->wait_next_vol); + Dmsg1(100, "JobId=%u broadcast wait_device_release\n", (uint32_t)jcr->JobId); pthread_cond_broadcast(&wait_device_release); } - bnet_fsend(dir, _("3000 Job %s marked to be canceled.\n"), jcr->Job); + Jmsg(jcr, M_INFO, 0, _("JobId=%d Job=\"%s\" marked to be canceled.\n"), + (int)jcr->JobId, jcr->Job); + dir->fsend(_("3000 Job %s marked to be canceled.\n"), jcr->Job); free_jcr(jcr); } } else { - bnet_fsend(dir, _("3903 Error scanning cancel command.\n")); + dir->fsend(_("3903 Error scanning cancel command.\n")); } - bnet_sig(dir, BNET_EOD); + dir->signal(BNET_EOD); return 1; } @@ -343,8 +395,8 @@ static bool do_label(JCR *jcr, int relabel) dcr = find_device(jcr, dev_name, drive); if (dcr) { dev = dcr->dev; - P(dev->mutex); /* Use P to avoid indefinite block */ - if (!dev->is_open()) { + dev->dlock(); /* Use P to avoid indefinite block */ + if (!dev->is_open() && !dev->is_busy()) { Dmsg1(400, "Can %slabel. Device is not open\n", relabel?"re":""); label_volume_if_ok(dcr, oldname, newname, poolname, slot, relabel); dev->close(); @@ -358,22 +410,21 @@ static bool do_label(JCR *jcr, int relabel) Dmsg0(400, "Can relabel. device not used\n"); label_volume_if_ok(dcr, oldname, newname, poolname, slot, relabel); } - V(dev->mutex); + dev->dunlock(); free_dcr(dcr); - jcr->dcr = NULL; } else { - bnet_fsend(dir, _("3999 Device \"%s\" not found or could not be opened.\n"), dev_name.c_str()); + dir->fsend(_("3999 Device \"%s\" not found or could not be opened.\n"), dev_name.c_str()); } } else { /* NB dir->msg gets clobbered in bnet_fsend, so save command */ pm_strcpy(jcr->errmsg, dir->msg); - bnet_fsend(dir, _("3903 Error scanning label command: %s\n"), jcr->errmsg); + dir->fsend(_("3903 Error scanning label command: %s\n"), jcr->errmsg); } free_memory(oldname); free_memory(newname); free_memory(poolname); free_memory(mtype); - bnet_sig(dir, BNET_EOD); + dir->signal(BNET_EOD); return true; } @@ -392,11 +443,15 @@ static void label_volume_if_ok(DCR *dcr, char *oldname, DEVICE *dev = dcr->dev; int label_status; int mode; + const char *volname = (relabel == 1) ? oldname : newname; + char ed1[50]; steal_device_lock(dev, &hold, BST_WRITING_LABEL); Dmsg1(100, "Stole device %s lock, writing label.\n", dev->print_name()); - if (!try_autoload_device(dcr->jcr, slot, newname)) { + + Dmsg0(90, "try_autoload_device - looking for volume_info\n"); + if (!try_autoload_device(dcr->jcr, dcr, slot, volname)) { goto bail_out; /* error */ } @@ -406,22 +461,30 @@ static void label_volume_if_ok(DCR *dcr, char *oldname, } else { mode = CREATE_READ_WRITE; } + + if (relabel) { + dev->truncating = true; /* let open() know we will truncate it */ + } + /* Set old volume name for open if relabeling */ + dcr->setVolCatName(volname); if (dev->open(dcr, mode) < 0) { - bnet_fsend(dir, _("3910 Unable to open device %s: ERR=%s\n"), - dev->print_name(), dev->strerror()); - return; + dir->fsend(_("3910 Unable to open device \"%s\": ERR=%s\n"), + dev->print_name(), dev->bstrerror()); + goto bail_out; } /* See what we have for a Volume */ label_status = read_dev_volume_label(dcr); + /* Set new volume name */ + dcr->setVolCatName(newname); switch(label_status) { case VOL_NAME_ERROR: case VOL_VERSION_ERROR: case VOL_LABEL_ERROR: case VOL_OK: if (!relabel) { - bnet_fsend(dir, _( + dir->fsend(_( "3920 Cannot label Volume because it is already labeled: \"%s\"\n"), dev->VolHdr.VolumeName); break; @@ -429,39 +492,41 @@ static void label_volume_if_ok(DCR *dcr, char *oldname, /* Relabel request. If oldname matches, continue */ if (strcmp(oldname, dev->VolHdr.VolumeName) != 0) { - bnet_fsend(dir, _("3921 Wrong volume mounted.\n")); + dir->fsend(_("3921 Wrong volume mounted.\n")); break; } if (dev->label_type != B_BACULA_LABEL) { - bnet_fsend(dir, _("3922 Cannot relabel an ANSI/IBM labeled Volume.\n")); + dir->fsend(_("3922 Cannot relabel an ANSI/IBM labeled Volume.\n")); break; } - free_volume(dev); /* release old volume name */ /* Fall through wanted! */ case VOL_IO_ERROR: case VOL_NO_LABEL: - if (!write_new_volume_label_to_dev(dcr, newname, poolname)) { - bnet_fsend(dir, _("3912 Failed to label Volume: ERR=%s\n"), strerror_dev(dev)); + if (!write_new_volume_label_to_dev(dcr, newname, poolname, + relabel, true /* write dvd now */)) { + dir->fsend(_("3912 Failed to label Volume: ERR=%s\n"), dev->bstrerror()); break; } bstrncpy(dcr->VolumeName, newname, sizeof(dcr->VolumeName)); /* The following 3000 OK label. string is scanned in ua_label.c */ - bnet_fsend(dir, "3000 OK label. Volume=%s Device=%s\n", - newname, dev->print_name()); + dir->fsend("3000 OK label. VolBytes=%s DVD=%d Volume=\"%s\" Device=%s\n", + edit_uint64(dev->VolCatInfo.VolCatBytes, ed1), + dev->is_dvd()?1:0, newname, dev->print_name()); break; case VOL_NO_MEDIA: - bnet_fsend(dir, _("3912 Failed to label Volume: ERR=%s\n"), strerror_dev(dev)); + dir->fsend(_("3914 Failed to label Volume (no media): ERR=%s\n"), dev->bstrerror()); break; default: - bnet_fsend(dir, _("3913 Cannot label Volume. " + dir->fsend(_("3913 Cannot label Volume. " "Unknown status %d from read_volume_label()\n"), label_status); break; } bail_out: if (!dev->is_open()) { - free_volume(dev); + dev->clear_volhdr(); } + volume_unused(dcr); /* no longer using volume */ give_back_device_lock(dev, &hold); return; } @@ -486,15 +551,16 @@ static bool read_label(DCR *dcr) dev->clear_labeled(); /* force read of label */ switch (read_dev_volume_label(dcr)) { case VOL_OK: - bnet_fsend(dir, _("3001 Mounted Volume: %s\n"), dev->VolHdr.VolumeName); + dir->fsend(_("3001 Mounted Volume: %s\n"), dev->VolHdr.VolumeName); ok = true; break; default: - bnet_fsend(dir, _("3902 Cannot mount Volume on Storage Device %s because:\n%s"), + dir->fsend(_("3902 Cannot mount Volume on Storage Device \"%s\" because:\n%s"), dev->print_name(), jcr->errmsg); ok = false; break; } + volume_unused(dcr); give_back_device_lock(dev, &hold); return ok; } @@ -513,7 +579,7 @@ static DCR *find_device(JCR *jcr, POOL_MEM &devname, int drive) unbash_spaces(devname); foreach_res(device, R_DEVICE) { /* Find resource, and make sure we were able to open it */ - if (fnmatch(device->hdr.name, devname.c_str(), 0) == 0) { + if (strcmp(device->hdr.name, devname.c_str()) == 0) { if (!device->dev) { device->dev = init_dev(jcr, device); } @@ -531,7 +597,7 @@ static DCR *find_device(JCR *jcr, POOL_MEM &devname, int drive) if (!found) { foreach_res(changer, R_AUTOCHANGER) { /* Find resource, and make sure we were able to open it */ - if (fnmatch(devname.c_str(), changer->hdr.name, 0) == 0) { + if (strcmp(devname.c_str(), changer->hdr.name) == 0) { /* Try each device in this AutoChanger */ foreach_alist(device, changer->device) { Dmsg1(100, "Try changer device %s\n", device->hdr.name); @@ -564,9 +630,8 @@ static DCR *find_device(JCR *jcr, POOL_MEM &devname, int drive) if (found) { Dmsg1(100, "Found device %s\n", device->hdr.name); - dcr = new_dcr(jcr, device->dev); + dcr = new_dcr(jcr, NULL, device->dev); dcr->device = device; - jcr->dcr = dcr; } return dcr; } @@ -582,32 +647,45 @@ static bool mount_cmd(JCR *jcr) DEVICE *dev; DCR *dcr; int drive; + int slot = 0; + bool ok; - if (sscanf(dir->msg, "mount %127s drive=%d", devname.c_str(), &drive) == 2) { + ok = sscanf(dir->msg, "mount %127s drive=%d slot=%d", devname.c_str(), + &drive, &slot) == 3; + if (!ok) { + ok = sscanf(dir->msg, "mount %127s drive=%d", devname.c_str(), &drive) == 2; + } + if (ok) { dcr = find_device(jcr, devname, drive); if (dcr) { dev = dcr->dev; - P(dev->mutex); /* Use P to avoid indefinite block */ - Dmsg1(100, "mount cmd blocked=%d\n", dev->dev_blocked); - switch (dev->dev_blocked) { /* device blocked? */ + dev->dlock(); /* Use P to avoid indefinite block */ + Dmsg2(100, "mount cmd blocked=%d must_unload=%d\n", dev->blocked(), + dev->must_unload()); + switch (dev->blocked()) { /* device blocked? */ case BST_WAITING_FOR_SYSOP: /* Someone is waiting, wake him */ Dmsg0(100, "Waiting for mount. Attempting to wake thread\n"); - dev->dev_blocked = BST_MOUNT; - bnet_fsend(dir, "3001 OK mount. Device=%s\n", - dev->print_name()); + dev->set_blocked(BST_MOUNT); + dir->fsend("3001 OK mount requested. %sDevice=%s\n", + slot>0?_("Specified slot ignored. "):"", + dev->print_name()); pthread_cond_broadcast(&dev->wait_next_vol); + Dmsg1(100, "JobId=%u broadcast wait_device_release\n", (uint32_t)dcr->jcr->JobId); pthread_cond_broadcast(&wait_device_release); break; /* In both of these two cases, we (the user) unmounted the Volume */ case BST_UNMOUNTED_WAITING_FOR_SYSOP: case BST_UNMOUNTED: + if (dev->is_autochanger() && slot > 0) { + try_autoload_device(jcr, dcr, slot, ""); + } /* We freed the device, so reopen it and wake any waiting threads */ if (dev->open(dcr, OPEN_READ_ONLY) < 0) { - bnet_fsend(dir, _("3901 open device failed: ERR=%s\n"), - strerror_dev(dev)); - if (dev->dev_blocked == BST_UNMOUNTED) { + dir->fsend(_("3901 Unable to open device \"%s\": ERR=%s\n"), + dev->print_name(), dev->bstrerror()); + if (dev->blocked() == BST_UNMOUNTED) { /* We blocked the device, so unblock it */ Dmsg0(100, "Unmounted. Unblocking device\n"); unblock_device(dev); @@ -615,90 +693,99 @@ static bool mount_cmd(JCR *jcr) break; } read_dev_volume_label(dcr); - if (dev->dev_blocked == BST_UNMOUNTED) { + if (dev->blocked() == BST_UNMOUNTED) { /* We blocked the device, so unblock it */ Dmsg0(100, "Unmounted. Unblocking device\n"); read_label(dcr); /* this should not be necessary */ unblock_device(dev); } else { Dmsg0(100, "Unmounted waiting for mount. Attempting to wake thread\n"); - dev->dev_blocked = BST_MOUNT; + dev->set_blocked(BST_MOUNT); } if (dev->is_labeled()) { - bnet_fsend(dir, _("3001 Device %s is mounted with Volume \"%s\"\n"), + dir->fsend(_("3001 Device \"%s\" is mounted with Volume \"%s\"\n"), dev->print_name(), dev->VolHdr.VolumeName); } else { - bnet_fsend(dir, _("3905 Device %s open but no Bacula volume is mounted.\n" + dir->fsend(_("3905 Device \"%s\" open but no Bacula volume is mounted.\n" "If this is not a blank tape, try unmounting and remounting the Volume.\n"), dev->print_name()); } pthread_cond_broadcast(&dev->wait_next_vol); + Dmsg1(100, "JobId=%u broadcast wait_device_release\n", (uint32_t)dcr->jcr->JobId); pthread_cond_broadcast(&wait_device_release); break; case BST_DOING_ACQUIRE: - bnet_fsend(dir, _("3001 Device %s is doing acquire.\n"), + dir->fsend(_("3001 Device \"%s\" is doing acquire.\n"), dev->print_name()); break; case BST_WRITING_LABEL: - bnet_fsend(dir, _("3903 Device %s is being labeled.\n"), + dir->fsend(_("3903 Device \"%s\" is being labeled.\n"), dev->print_name()); break; case BST_NOT_BLOCKED: + if (dev->is_autochanger() && slot > 0) { + try_autoload_device(jcr, dcr, slot, ""); + } if (dev->is_open()) { if (dev->is_labeled()) { - bnet_fsend(dir, _("3001 Device %s is mounted with Volume \"%s\"\n"), + dir->fsend(_("3001 Device \"%s\" is mounted with Volume \"%s\"\n"), dev->print_name(), dev->VolHdr.VolumeName); } else { - bnet_fsend(dir, _("3905 Device %s open but no Bacula volume is mounted.\n" + dir->fsend(_("3905 Device \"%s\" open but no Bacula volume is mounted.\n" "If this is not a blank tape, try unmounting and remounting the Volume.\n"), dev->print_name()); } } else if (dev->is_tape()) { if (dev->open(dcr, OPEN_READ_ONLY) < 0) { - bnet_fsend(dir, _("3901 open device failed: ERR=%s\n"), - strerror_dev(dev)); + dir->fsend(_("3901 Unable to open device \"%s\": ERR=%s\n"), + dev->print_name(), dev->bstrerror()); break; } read_label(dcr); if (dev->is_labeled()) { - bnet_fsend(dir, _("3001 Device %s is already mounted with Volume \"%s\"\n"), + dir->fsend(_("3001 Device \"%s\" is already mounted with Volume \"%s\"\n"), dev->print_name(), dev->VolHdr.VolumeName); } else { - bnet_fsend(dir, _("3905 Device %s open but no Bacula volume is mounted.\n" + dir->fsend(_("3905 Device \"%s\" open but no Bacula volume is mounted.\n" "If this is not a blank tape, try unmounting and remounting the Volume.\n"), dev->print_name()); } - } else if (dev->is_dvd()) { - if (mount_dvd(dev, 1)) { - bnet_fsend(dir, _("3002 Device %s is mounted.\n"), - dev->print_name()); + } else if (dev->is_unmountable()) { + if (dev->mount(1)) { + dir->fsend(_("3002 Device \"%s\" is mounted.\n"), dev->print_name()); } else { - bnet_fsend(dir, _("3907 %s"), strerror_dev(dev)); + dir->fsend(_("3907 %s"), dev->bstrerror()); } } else { /* must be file */ - bnet_fsend(dir, _("3906 File device %s is always mounted.\n"), + dir->fsend(_("3906 File device \"%s\" is always mounted.\n"), dev->print_name()); + pthread_cond_broadcast(&dev->wait_next_vol); + Dmsg1(100, "JobId=%u broadcast wait_device_release\n", (uint32_t)dcr->jcr->JobId); + pthread_cond_broadcast(&wait_device_release); } break; + case BST_RELEASING: + dir->fsend(_("3930 Device \"%s\" is being released.\n"), dev->print_name()); + break; + default: - bnet_fsend(dir, _("3905 Bizarre wait state %d\n"), dev->dev_blocked); + dir->fsend(_("3905 Unknown wait state %d\n"), dev->blocked()); break; } - V(dev->mutex); + dev->dunlock(); free_dcr(dcr); - jcr->dcr = NULL; } else { - bnet_fsend(dir, _("3999 Device \"%s\" not found or could not be opened.\n"), devname.c_str()); + dir->fsend(_("3999 Device \"%s\" not found or could not be opened.\n"), devname.c_str()); } } else { pm_strcpy(jcr->errmsg, dir->msg); - bnet_fsend(dir, _("3909 Error scanning mount command: %s\n"), jcr->errmsg); + dir->fsend(_("3909 Error scanning mount command: %s\n"), jcr->errmsg); } - bnet_sig(dir, BNET_EOD); + dir->signal(BNET_EOD); return true; } @@ -717,31 +804,45 @@ static bool unmount_cmd(JCR *jcr) dcr = find_device(jcr, devname, drive); if (dcr) { dev = dcr->dev; - P(dev->mutex); /* Use P to avoid indefinite block */ + dev->dlock(); /* Use P to avoid indefinite block */ if (!dev->is_open()) { if (!dev->is_busy()) { - unload_autochanger(jcr->dcr, -1); + unload_autochanger(dcr, -1); } - Dmsg0(90, "Device already unmounted\n"); - bnet_fsend(dir, _("3901 Device %s is already unmounted.\n"), - dev->print_name()); - - } else if (dev->dev_blocked == BST_WAITING_FOR_SYSOP) { + if (dev->is_unmountable()) { + if (dev->unmount(0)) { + dir->fsend(_("3002 Device \"%s\" unmounted.\n"), + dev->print_name()); + } else { + dir->fsend(_("3907 %s"), dev->bstrerror()); + } + } else { + Dmsg0(90, "Device already unmounted\n"); + dir->fsend(_("3901 Device \"%s\" is already unmounted.\n"), + dev->print_name()); + } + } else if (dev->blocked() == BST_WAITING_FOR_SYSOP) { Dmsg2(90, "%d waiter dev_block=%d. doing unmount\n", dev->num_waiting, - dev->dev_blocked); - if (!unload_autochanger(jcr->dcr, -1)) { + dev->blocked()); + if (!unload_autochanger(dcr, -1)) { + /* ***FIXME**** what is this ???? */ dev->close(); + free_volume(dev); + } + if (dev->is_unmountable() && !dev->unmount(0)) { + dir->fsend(_("3907 %s"), dev->bstrerror()); + } else { + dev->set_blocked(BST_UNMOUNTED_WAITING_FOR_SYSOP); + dir->fsend(_("3001 Device \"%s\" unmounted.\n"), + dev->print_name()); } - dev->dev_blocked = BST_UNMOUNTED_WAITING_FOR_SYSOP; - bnet_fsend(dir, _("3001 Device %s unmounted.\n"), - dev->print_name()); - } else if (dev->dev_blocked == BST_DOING_ACQUIRE) { - bnet_fsend(dir, _("3902 Device %s is busy in acquire.\n"), + } else if (dev->blocked() == BST_DOING_ACQUIRE) { + dir->fsend(_("3902 Device \"%s\" is busy in acquire.\n"), dev->print_name()); - } else if (dev->dev_blocked == BST_WRITING_LABEL) { - bnet_fsend(dir, _("3903 Device %s is being labeled.\n"), + } else if (dev->blocked() == BST_WRITING_LABEL) { + dir->fsend(_("3903 Device \"%s\" is being labeled.\n"), dev->print_name()); } else if (dev->is_busy()) { @@ -754,28 +855,72 @@ static bool unmount_cmd(JCR *jcr) * we simply do it by hand. Gross, but a solution. */ /* block_device(dev, BST_UNMOUNTED); replace with 2 lines below */ - dev->dev_blocked = BST_UNMOUNTED; - dev->no_wait_id = 0; - if (!unload_autochanger(jcr->dcr, -1)) { + dev->set_blocked(BST_UNMOUNTED); + clear_thread_id(dev->no_wait_id); + if (!unload_autochanger(dcr, -1)) { dev->close(); + free_volume(dev); + } + if (dev->is_unmountable() && !dev->unmount(0)) { + dir->fsend(_("3907 %s"), dev->bstrerror()); + } else { + dir->fsend(_("3002 Device \"%s\" unmounted.\n"), + dev->print_name()); } - bnet_fsend(dir, _("3002 Device %s unmounted.\n"), - dev->print_name()); } - V(dev->mutex); + dev->dunlock(); free_dcr(dcr); - jcr->dcr = NULL; } else { - bnet_fsend(dir, _("3999 Device \"%s\" not found or could not be opened.\n"), devname.c_str()); + dir->fsend(_("3999 Device \"%s\" not found or could not be opened.\n"), devname.c_str()); } } else { /* NB dir->msg gets clobbered in bnet_fsend, so save command */ pm_strcpy(jcr->errmsg, dir->msg); - bnet_fsend(dir, _("3907 Error scanning unmount command: %s\n"), jcr->errmsg); + dir->fsend(_("3907 Error scanning unmount command: %s\n"), jcr->errmsg); + } + dir->signal(BNET_EOD); + return true; +} + +#if 0 +/* + * The truncate command will recycle a volume. The director can call this + * after purging a volume so that disk space will not be wasted. Only useful + * for File Storage, of course. + * + * + * It is currently disabled + */ +static bool action_on_purge_cmd(JCR *jcr) +{ + BSOCK *dir = jcr->dir_bsock; + + char devname[MAX_NAME_LENGTH]; + char volumename[MAX_NAME_LENGTH]; + int action; + + /* TODO: Need to find a free device and ask for slot to the director */ + if (sscanf(dir->msg, + "action_on_purge %127s vol=%127s action=%d", + devname, volumename, &action)!= 5) + { + dir->fsend(_("3916 Error scanning action_on_purge command\n")); + goto done; } - bnet_sig(dir, BNET_EOD); + unbash_spaces(volumename); + unbash_spaces(devname); + + /* Check if action is correct */ + if (action & AOP_TRUNCTATE) { + + } + /* ... */ + +done: + dir->signal(BNET_EOD); return true; } +#endif /* * Release command from Director. This rewinds the device and if @@ -796,50 +941,114 @@ static bool release_cmd(JCR *jcr) dcr = find_device(jcr, devname, drive); if (dcr) { dev = dcr->dev; - P(dev->mutex); /* Use P to avoid indefinite block */ + dev->dlock(); /* Use P to avoid indefinite block */ if (!dev->is_open()) { + if (!dev->is_busy()) { + unload_autochanger(dcr, -1); + } Dmsg0(90, "Device already released\n"); - bnet_fsend(dir, _("3921 Device %s already released.\n"), + dir->fsend(_("3921 Device \"%s\" already released.\n"), dev->print_name()); - } else if (dev->dev_blocked == BST_WAITING_FOR_SYSOP || - dev->dev_blocked == BST_UNMOUNTED_WAITING_FOR_SYSOP) { + } else if (dev->blocked() == BST_WAITING_FOR_SYSOP) { + Dmsg2(90, "%d waiter dev_block=%d.\n", dev->num_waiting, + dev->blocked()); + unload_autochanger(dcr, -1); + dir->fsend(_("3922 Device \"%s\" waiting for sysop.\n"), + dev->print_name()); + + } else if (dev->blocked() == BST_UNMOUNTED_WAITING_FOR_SYSOP) { Dmsg2(90, "%d waiter dev_block=%d. doing unmount\n", dev->num_waiting, - dev->dev_blocked); - bnet_fsend(dir, _("3922 Device %s waiting for mount.\n"), + dev->blocked()); + dir->fsend(_("3922 Device \"%s\" waiting for mount.\n"), dev->print_name()); - } else if (dev->dev_blocked == BST_DOING_ACQUIRE) { - bnet_fsend(dir, _("3923 Device %s is busy in acquire.\n"), + } else if (dev->blocked() == BST_DOING_ACQUIRE) { + dir->fsend(_("3923 Device \"%s\" is busy in acquire.\n"), dev->print_name()); - } else if (dev->dev_blocked == BST_WRITING_LABEL) { - bnet_fsend(dir, _("3914 Device %s is being labeled.\n"), + } else if (dev->blocked() == BST_WRITING_LABEL) { + dir->fsend(_("3914 Device \"%s\" is being labeled.\n"), dev->print_name()); } else if (dev->is_busy()) { send_dir_busy_message(dir, dev); } else { /* device not being used */ - Dmsg0(90, "Device not in use, unmounting\n"); - release_volume(jcr->dcr); - bnet_fsend(dir, _("3022 Device %s released.\n"), + Dmsg0(90, "Device not in use, releasing\n"); + dcr->release_volume(); + dir->fsend(_("3022 Device \"%s\" released.\n"), dev->print_name()); } - V(dev->mutex); + dev->dunlock(); free_dcr(dcr); - jcr->dcr = NULL; } else { - bnet_fsend(dir, _("3999 Device \"%s\" not found or could not be opened.\n"), devname.c_str()); + dir->fsend(_("3999 Device \"%s\" not found or could not be opened.\n"), devname.c_str()); } } else { /* NB dir->msg gets clobbered in bnet_fsend, so save command */ pm_strcpy(jcr->errmsg, dir->msg); - bnet_fsend(dir, _("3927 Error scanning release command: %s\n"), jcr->errmsg); + dir->fsend(_("3927 Error scanning release command: %s\n"), jcr->errmsg); } - bnet_sig(dir, BNET_EOD); + dir->signal(BNET_EOD); return true; } +static pthread_mutex_t bsr_mutex = PTHREAD_MUTEX_INITIALIZER; +static uint32_t bsr_uniq = 0; + +static bool get_bootstrap_file(JCR *jcr, BSOCK *sock) +{ + POOLMEM *fname = get_pool_memory(PM_FNAME); + FILE *bs; + bool ok = false; + + if (jcr->RestoreBootstrap) { + unlink(jcr->RestoreBootstrap); + free_pool_memory(jcr->RestoreBootstrap); + } + P(bsr_mutex); + bsr_uniq++; + Mmsg(fname, "%s/%s.%s.%d.bootstrap", me->working_directory, me->hdr.name, + jcr->Job, bsr_uniq); + V(bsr_mutex); + Dmsg1(400, "bootstrap=%s\n", fname); + jcr->RestoreBootstrap = fname; + bs = fopen(fname, "a+b"); /* create file */ + if (!bs) { + berrno be; + Jmsg(jcr, M_FATAL, 0, _("Could not create bootstrap file %s: ERR=%s\n"), + jcr->RestoreBootstrap, be.bstrerror()); + goto bail_out; + } + Dmsg0(10, "=== Bootstrap file ===\n"); + while (sock->recv() >= 0) { + Dmsg1(10, "%s", sock->msg); + fputs(sock->msg, bs); + } + fclose(bs); + Dmsg0(10, "=== end bootstrap file ===\n"); + jcr->bsr = parse_bsr(jcr, jcr->RestoreBootstrap); + if (!jcr->bsr) { + Jmsg(jcr, M_FATAL, 0, _("Error parsing bootstrap file.\n")); + goto bail_out; + } + if (debug_level >= 10) { + dump_bsr(jcr->bsr, true); + } + /* If we got a bootstrap, we are reading, so create read volume list */ + create_restore_volume_list(jcr); + ok = true; + +bail_out: + unlink(jcr->RestoreBootstrap); + free_pool_memory(jcr->RestoreBootstrap); + jcr->RestoreBootstrap = NULL; + if (!ok) { + sock->fsend(ERROR_bootstrap); + return false; + } + return sock->fsend(OK_bootstrap); +} static bool bootstrap_cmd(JCR *jcr) { @@ -857,45 +1066,52 @@ static bool changer_cmd(JCR *jcr) DCR *dcr; const char *cmd = NULL; bool ok = false; + /* + * A safe_cmd may call autochanger script but does not load/unload + * slots so it can be done at the same time that the drive is open. + */ + bool safe_cmd = false; - if (sscanf(dir->msg, "autochanger list %127s", devname.c_str()) == 1) { + if (sscanf(dir->msg, "autochanger listall %127s", devname.c_str()) == 1) { + cmd = "listall"; + safe_cmd = ok = true; + } else if (sscanf(dir->msg, "autochanger list %127s", devname.c_str()) == 1) { cmd = "list"; - ok = true; + safe_cmd = ok = true; } else if (sscanf(dir->msg, "autochanger slots %127s", devname.c_str()) == 1) { cmd = "slots"; - ok = true; + safe_cmd = ok = true; } else if (sscanf(dir->msg, "autochanger drives %127s", devname.c_str()) == 1) { cmd = "drives"; - ok = true; + safe_cmd = ok = true; } if (ok) { dcr = find_device(jcr, devname, -1); if (dcr) { dev = dcr->dev; - P(dev->mutex); /* Use P to avoid indefinite block */ - if (!dev->device->changer_res) { - bnet_fsend(dir, _("3995 Device %s is not an autochanger.\n"), + dev->dlock(); /* Use P to avoid indefinite block */ + if (!dev->device->changer_res) { + dir->fsend(_("3995 Device \"%s\" is not an autochanger.\n"), dev->print_name()); /* Under certain "safe" conditions, we can steal the lock */ - } else if (!dev->is_open() || dev->can_steal_lock()) { + } else if (safe_cmd || !dev->is_open() || dev->can_steal_lock()) { autochanger_cmd(dcr, dir, cmd); } else if (dev->is_busy() || dev->is_blocked()) { send_dir_busy_message(dir, dev); } else { /* device not being used */ autochanger_cmd(dcr, dir, cmd); } - V(dev->mutex); + dev->dunlock(); free_dcr(dcr); - jcr->dcr = NULL; } else { - bnet_fsend(dir, _("3999 Device \"%s\" not found or could not be opened.\n"), devname.c_str()); + dir->fsend(_("3999 Device \"%s\" not found or could not be opened.\n"), devname.c_str()); } } else { /* error on scanf */ pm_strcpy(jcr->errmsg, dir->msg); - bnet_fsend(dir, _("3908 Error scanning autocharger drives/list/slots command: %s\n"), + dir->fsend(_("3908 Error scanning autocharger drives/list/slots command: %s\n"), jcr->errmsg); } - bnet_sig(dir, BNET_EOD); + dir->signal(BNET_EOD); return true; } @@ -916,29 +1132,28 @@ static bool readlabel_cmd(JCR *jcr) dcr = find_device(jcr, devname, drive); if (dcr) { dev = dcr->dev; - P(dev->mutex); /* Use P to avoid indefinite block */ + dev->dlock(); /* Use P to avoid indefinite block */ if (!dev->is_open()) { - read_volume_label(jcr, dev, Slot); + read_volume_label(jcr, dcr, dev, Slot); dev->close(); /* Under certain "safe" conditions, we can steal the lock */ } else if (dev->can_steal_lock()) { - read_volume_label(jcr, dev, Slot); + read_volume_label(jcr, dcr, dev, Slot); } else if (dev->is_busy() || dev->is_blocked()) { send_dir_busy_message(dir, dev); } else { /* device not being used */ - read_volume_label(jcr, dev, Slot); + read_volume_label(jcr, dcr, dev, Slot); } - V(dev->mutex); + dev->dunlock(); free_dcr(dcr); - jcr->dcr = NULL; } else { - bnet_fsend(dir, _("3999 Device \"%s\" not found or could not be opened.\n"), devname.c_str()); + dir->fsend(_("3999 Device \"%s\" not found or could not be opened.\n"), devname.c_str()); } } else { pm_strcpy(jcr->errmsg, dir->msg); - bnet_fsend(dir, _("3909 Error scanning readlabel command: %s\n"), jcr->errmsg); + dir->fsend(_("3909 Error scanning readlabel command: %s\n"), jcr->errmsg); } - bnet_sig(dir, BNET_EOD); + dir->signal(BNET_EOD); return true; } @@ -948,16 +1163,15 @@ static bool readlabel_cmd(JCR *jcr) * * Enter with the mutex set */ -static void read_volume_label(JCR *jcr, DEVICE *dev, int Slot) +static void read_volume_label(JCR *jcr, DCR *dcr, DEVICE *dev, int Slot) { BSOCK *dir = jcr->dir_bsock; bsteal_lock_t hold; - DCR *dcr = jcr->dcr; dcr->dev = dev; steal_device_lock(dev, &hold, BST_WRITING_LABEL); - if (!try_autoload_device(jcr, Slot, "")) { + if (!try_autoload_device(jcr, dcr, Slot, "")) { goto bail_out; /* error */ } @@ -965,11 +1179,11 @@ static void read_volume_label(JCR *jcr, DEVICE *dev, int Slot) switch (read_dev_volume_label(dcr)) { case VOL_OK: /* DO NOT add quotes around the Volume name. It is scanned in the DIR */ - bnet_fsend(dir, _("3001 Volume=%s Slot=%d\n"), dev->VolHdr.VolumeName, Slot); + dir->fsend(_("3001 Volume=%s Slot=%d\n"), dev->VolHdr.VolumeName, Slot); Dmsg1(100, "Volume: %s\n", dev->VolHdr.VolumeName); break; default: - bnet_fsend(dir, _("3902 Cannot mount Volume on Storage Device %s because:\n%s"), + dir->fsend(_("3902 Cannot mount Volume on Storage Device \"%s\" because:\n%s"), dev->print_name(), jcr->errmsg); break; } @@ -979,9 +1193,8 @@ bail_out: return; } -static bool try_autoload_device(JCR *jcr, int slot, const char *VolName) +static bool try_autoload_device(JCR *jcr, DCR *dcr, int slot, const char *VolName) { - DCR *dcr = jcr->dcr; BSOCK *dir = jcr->dir_bsock; bstrncpy(dcr->VolumeName, VolName, sizeof(dcr->VolumeName)); @@ -996,37 +1209,37 @@ static bool try_autoload_device(JCR *jcr, int slot, const char *VolName) static void send_dir_busy_message(BSOCK *dir, DEVICE *dev) { if (dev->is_blocked()) { - switch (dev->dev_blocked) { + switch (dev->blocked()) { case BST_UNMOUNTED: - bnet_fsend(dir, _("3931 Device %s is BLOCKED. user unmounted.\n"), + dir->fsend(_("3931 Device \"%s\" is BLOCKED. user unmounted.\n"), dev->print_name()); break; case BST_UNMOUNTED_WAITING_FOR_SYSOP: - bnet_fsend(dir, _("3932 Device %s is BLOCKED. user unmounted during wait for media/mount.\n"), + dir->fsend(_("3932 Device \"%s\" is BLOCKED. user unmounted during wait for media/mount.\n"), dev->print_name()); break; case BST_WAITING_FOR_SYSOP: - bnet_fsend(dir, _("3933 Device %s is BLOCKED waiting for media.\n"), + dir->fsend(_("3933 Device \"%s\" is BLOCKED waiting for media.\n"), dev->print_name()); break; case BST_DOING_ACQUIRE: - bnet_fsend(dir, _("3934 Device %s is being initialized.\n"), + dir->fsend(_("3934 Device \"%s\" is being initialized.\n"), dev->print_name()); break; case BST_WRITING_LABEL: - bnet_fsend(dir, _("3935 Device %s is blocked labeling a Volume.\n"), + dir->fsend(_("3935 Device \"%s\" is blocked labeling a Volume.\n"), dev->print_name()); break; default: - bnet_fsend(dir, _("3935 Device %s is blocked for unknown reason.\n"), + dir->fsend(_("3935 Device \"%s\" is blocked for unknown reason.\n"), dev->print_name()); break; } } else if (dev->can_read()) { - bnet_fsend(dir, _("3936 Device %s is busy reading.\n"), + dir->fsend(_("3936 Device \"%s\" is busy reading.\n"), dev->print_name());; } else { - bnet_fsend(dir, _("3937 Device %s is busy with %d writer(s).\n"), + dir->fsend(_("3937 Device \"%s\" is busy with %d writer(s).\n"), dev->print_name(), dev->num_writers); } }