X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=bacula%2Fsrc%2Fstored%2Fautochanger.c;h=ea79fcc778b07a236c2a51fcfb89eb8232c3299f;hb=ecf33f65329d2ac71403eb26962800c9c2f4664e;hp=b9ef352b31f24478f40e34a1320cdcd981b61a3e;hpb=1c31d780ff8befc9ef13c681d991bf235cb5f735;p=bacula%2Fbacula diff --git a/bacula/src/stored/autochanger.c b/bacula/src/stored/autochanger.c index b9ef352b31..ea79fcc778 100644 --- a/bacula/src/stored/autochanger.c +++ b/bacula/src/stored/autochanger.c @@ -1,37 +1,97 @@ /* - * - * Routines for handling the autochanger. - * - * Kern Sibbald, August MMII - * - * Version $Id$ - */ -/* - Copyright (C) 2000-2004 Kern Sibbald and John Walker + Bacula® - The Network Backup Solution + + Copyright (C) 2002-2007 Free Software Foundation Europe e.V. - This program is free software; you can redistribute it and/or - modify it under the terms of the GNU General Public License as - published by the Free Software Foundation; either version 2 of - the License, or (at your option) any later version. + 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 two of the GNU General Public + License as published by the Free Software Foundation plus additions + that are listed 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 + 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 General Public - License along with this program; if not, write to the Free - Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, - MA 02111-1307, USA. + You should have received a copy of the GNU 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 John Walker. + The licensor of Bacula is the Free Software Foundation Europe + (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich, + Switzerland, email:ftf@fsfeurope.org. +*/ +/* + * + * Routines for handling the autochanger. + * + * Kern Sibbald, August MMII + * + * Version $Id$ */ #include "bacula.h" /* pull in global headers */ #include "stored.h" /* pull in Storage Deamon headers */ /* Forward referenced functions */ -char *edit_device_codes(JCR *jcr, char *omsg, const char *imsg, const char *cmd); -static int get_autochanger_loaded_slot(JCR *jcr); +static void lock_changer(DCR *dcr); +static void unlock_changer(DCR *dcr); +static bool unload_other_drive(DCR *dcr, int slot); + +/* Init all the autochanger resources found */ +bool init_autochangers() +{ + bool OK = true; + AUTOCHANGER *changer; + /* Ensure that the media_type for each device is the same */ + foreach_res(changer, R_AUTOCHANGER) { + DEVRES *device; + foreach_alist(device, changer->device) { + /* + * If the device does not have a changer name or changer command + * defined, used the one from the Autochanger resource + */ + if (!device->changer_name && changer->changer_name) { + device->changer_name = bstrdup(changer->changer_name); + } + if (!device->changer_command && changer->changer_command) { + device->changer_command = bstrdup(changer->changer_command); + } + if (!device->changer_name) { + Jmsg(NULL, M_ERROR, 0, + _("No Changer Name given for device %s. Cannot continue.\n"), + device->hdr.name); + OK = false; + } + if (!device->changer_command) { + Jmsg(NULL, M_ERROR, 0, + _("No Changer Command given for device %s. Cannot continue.\n"), + device->hdr.name); + OK = false; + } + +#ifdef xxx_needed + if (media_type == NULL) { + media_type = device->media_type; /* get Media Type of first device */ + continue; + } + /* Ensure that other devices Media Types are the same */ + if (strcmp(media_type, device->media_type) != 0) { + Jmsg(NULL, M_ERROR, 0, + _("Media Type not the same for all devices in changer %s. Cannot continue.\n"), + changer->hdr.name); + OK = false; + continue; + } +#endif + } + } + return OK; +} /* @@ -40,225 +100,453 @@ static int get_autochanger_loaded_slot(JCR *jcr); * On success this routine loads the indicated tape, but the * label is not read, so it must be verified. * - * Note if dir is not NULL, it is the console requesting the + * Note if dir is not NULL, it is the console requesting the * autoload for labeling, so we respond directly to the * dir bsock. * * Returns: 1 on success - * 0 on failure (no changer available) - * -1 on error on autochanger + * 0 on failure (no changer available) + * -1 on error on autochanger */ int autoload_device(DCR *dcr, int writing, BSOCK *dir) { JCR *jcr = dcr->jcr; DEVICE *dev = dcr->dev; - int slot = dcr->VolCatInfo.Slot; - int drive = jcr->device->drive_index; - int rtn_stat = -1; /* error status */ - + int slot; + int drive = dev->drive_index; + int rtn_stat = -1; /* error status */ + POOLMEM *changer; + + if (!dev->is_autochanger()) { + Dmsg1(200, "Device %s is not an autochanger\n", dev->print_name()); + return 0; + } + + /* An empty ChangerCommand => virtual disk autochanger */ + if (dcr->device->changer_command && dcr->device->changer_command[0] == 0) { + return 1; /* nothing to load */ + } + + slot = dcr->VolCatInfo.InChanger ? dcr->VolCatInfo.Slot : 0; /* - * Handle autoloaders here. If we cannot autoload it, we - * will return FALSE to ask the sysop. + * Handle autoloaders here. If we cannot autoload it, we + * will return 0 so that the sysop will be asked to load it. */ - if (writing && dev_cap(dev, CAP_AUTOCHANGER) && slot <= 0) { + if (writing && slot <= 0) { if (dir) { - return 0; /* For user, bail out right now */ + return 0; /* For user, bail out right now */ } if (dir_find_next_appendable_volume(dcr)) { - slot = dcr->VolCatInfo.Slot; + slot = dcr->VolCatInfo.InChanger ? dcr->VolCatInfo.Slot : 0; } else { - slot = 0; + slot = 0; } } Dmsg1(400, "Want changer slot=%d\n", slot); - if (slot > 0 && jcr->device->changer_name && jcr->device->changer_command) { - uint32_t timeout = jcr->device->max_changer_wait; - POOLMEM *changer; - int loaded, status; - - changer = get_pool_memory(PM_FNAME); - - loaded = get_autochanger_loaded_slot(jcr); - - /* If tape we want is not loaded, load it. */ - if (loaded != slot) { - offline_or_rewind_dev(dev); - /* We are going to load a new tape, so close the device */ - force_close_dev(dev); - if (loaded != 0 && loaded != -1) { /* must unload drive */ - Dmsg0(400, "Doing changer unload.\n"); - Jmsg(jcr, M_INFO, 0, - _("3303 Issuing autochanger \"unload slot %d, drive %d\" command.\n"), - loaded, drive); - dcr->VolCatInfo.Slot = loaded; /* slot to be unloaded */ - changer = edit_device_codes(jcr, changer, - jcr->device->changer_command, "unload"); - status = run_program(changer, timeout, NULL); - if (status != 0) { - berrno be; - be.set_errno(status); - Jmsg(jcr, M_INFO, 0, _("3992 Bad autochanger \"unload slot %d, drive %d\": ERR=%s.\n"), - slot, drive, be.strerror()); - } - - Dmsg1(400, "unload status=%d\n", status); - } - /* - * Load the desired cassette - */ - Dmsg1(400, "Doing changer load slot %d\n", slot); - Jmsg(jcr, M_INFO, 0, - _("3304 Issuing autochanger \"load slot %d, drive %d\" command.\n"), - slot, drive); - dcr->VolCatInfo.Slot = slot; /* slot to be loaded */ - changer = edit_device_codes(jcr, changer, - jcr->device->changer_command, "load"); - status = run_program(changer, timeout, NULL); - if (status == 0) { + changer = get_pool_memory(PM_FNAME); + if (slot <= 0) { + Jmsg(jcr, M_INFO, 0, _("Invalid slot=%d defined in catalog. Manual load my be required.\n"), slot); + rtn_stat = 0; + } else if (!dcr->device->changer_name) { + Jmsg(jcr, M_INFO, 0, _("No \"Changer Device\" manual load of Volume may be required.\n")); + rtn_stat = 0; + } else if (!dcr->device->changer_command) { + Jmsg(jcr, M_INFO, 0, _("No \"Changer Command\" manual load of Volume may be requird.\n")); + rtn_stat = 0; + } else { + /* Attempt to load the Volume */ + + uint32_t timeout = dcr->device->max_changer_wait; + int loaded, status; + + loaded = get_autochanger_loaded_slot(dcr); + + if (loaded != slot) { + POOL_MEM results(PM_MESSAGE); + + /* Unload anything in our drive */ + if (!unload_autochanger(dcr, loaded)) { + goto bail_out; + } + + /* Make sure desired slot is unloaded */ + if (!unload_other_drive(dcr, slot)) { + goto bail_out; + } + + /* + * Load the desired cassette + */ + lock_changer(dcr); + Dmsg1(100, "Doing changer load slot %d\n", slot); + Jmsg(jcr, M_INFO, 0, + _("3304 Issuing autochanger \"load slot %d, drive %d\" command.\n"), + slot, drive); + dcr->VolCatInfo.Slot = slot; /* slot to be loaded */ + changer = edit_device_codes(dcr, changer, dcr->device->changer_command, "load"); + dev->close(); + Dmsg1(200, "Run program=%s\n", changer); + status = run_program_full_output(changer, timeout, results.c_str()); + if (status == 0) { Jmsg(jcr, M_INFO, 0, _("3305 Autochanger \"load slot %d, drive %d\", status is OK.\n"), - slot, drive); - } else { - berrno be; - be.set_errno(status); - Jmsg(jcr, M_INFO, 0, _("3992 Bad autochanger \"load slot %d, drive %d\": ERR=%s.\n"), - slot, drive, be.strerror()); - } - Dmsg2(400, "load slot %d status=%d\n", slot, status); - } else { - status = 0; /* we got what we want */ + slot, drive); + Dmsg2(100, "load slot %d, drive %d, status is OK.\n", slot, drive); + dev->Slot = slot; /* set currently loaded slot */ + } else { + berrno be; + be.set_errno(status); + Dmsg3(100, "load slot %d, drive %d, bad stats=%s.\n", slot, drive, + be.bstrerror()); + Jmsg(jcr, M_FATAL, 0, _("3992 Bad autochanger \"load slot %d, drive %d\": " + "ERR=%s.\nResults=%s\n"), + slot, drive, be.bstrerror(), results.c_str()); + rtn_stat = -1; /* hard error */ + dev->Slot = -1; /* mark unknown */ + } + Dmsg2(100, "load slot %d status=%d\n", slot, status); + unlock_changer(dcr); + } else { + status = 0; /* we got what we want */ + dev->Slot = slot; /* set currently loaded slot */ } - free_pool_memory(changer); - Dmsg1(400, "After changer, status=%d\n", status); - if (status == 0) { /* did we succeed? */ - rtn_stat = 1; /* tape loaded by changer */ + Dmsg1(100, "After changer, status=%d\n", status); + if (status == 0) { /* did we succeed? */ + rtn_stat = 1; /* tape loaded by changer */ } - } else { - rtn_stat = 0; /* no changer found */ } + free_pool_memory(changer); return rtn_stat; + +bail_out: + free_pool_memory(changer); + return -1; + } -static int get_autochanger_loaded_slot(JCR *jcr) +/* + * Returns: -1 if error from changer command + * slot otherwise + * Note, this is safe to do without releasing the drive + * since it does not attempt load/unload a slot. + */ +int get_autochanger_loaded_slot(DCR *dcr) { - POOLMEM *changer, *results; + JCR *jcr = dcr->jcr; + DEVICE *dev = dcr->dev; int status, loaded; - uint32_t timeout = jcr->device->max_changer_wait; - int drive = jcr->device->drive_index; + uint32_t timeout = dcr->device->max_changer_wait; + int drive = dcr->dev->drive_index; + POOL_MEM results(PM_MESSAGE); + POOLMEM *changer; - results = get_pool_memory(PM_MESSAGE); - changer = get_pool_memory(PM_FNAME); + if (!dev->is_autochanger()) { + return -1; + } + if (!dcr->device->changer_command) { + Jmsg(jcr, M_FATAL, 0, _("3992 Missing Changer command.\n")); + return -1; + } + if (dev->Slot > 0) { + return dev->Slot; + } + /* Virtual disk autochanger */ + if (dcr->device->changer_command[0] ==0) { + return 1; + } /* Find out what is loaded, zero means device is unloaded */ - Jmsg(jcr, M_INFO, 0, _("3301 Issuing autochanger \"loaded drive %d\" command.\n"), - drive); - changer = edit_device_codes(jcr, changer, jcr->device->changer_command, - "loaded"); - status = run_program(changer, timeout, results); - Dmsg3(100, "run_prog: %s stat=%d result=%s\n", changer, status, results); + changer = get_pool_memory(PM_FNAME); + lock_changer(dcr); + Jmsg(jcr, M_INFO, 0, _("3301 Issuing autochanger \"loaded? drive %d\" command.\n"), + drive); + changer = edit_device_codes(dcr, changer, dcr->device->changer_command, "loaded"); + *results.c_str() = 0; + Dmsg1(100, "Run program=%s\n", changer); + status = run_program_full_output(changer, timeout, results.c_str()); + Dmsg3(100, "run_prog: %s stat=%d result=%s", changer, status, results.c_str()); if (status == 0) { - loaded = atoi(results); + loaded = str_to_int32(results.c_str()); if (loaded > 0) { - Jmsg(jcr, M_INFO, 0, _("3302 Autochanger \"loaded drive %d\", result is Slot %d.\n"), - drive, loaded); + Jmsg(jcr, M_INFO, 0, _("3302 Autochanger \"loaded? drive %d\", result is Slot %d.\n"), + drive, loaded); + dev->Slot = loaded; } else { - Jmsg(jcr, M_INFO, 0, _("3302 Autochanger \"loaded drive %d\", result: nothing loaded.\n"), - drive); + Jmsg(jcr, M_INFO, 0, _("3302 Autochanger \"loaded? drive %d\", result: nothing loaded.\n"), + drive); + dev->Slot = -1; /* unknown */ } } else { berrno be; be.set_errno(status); - Jmsg(jcr, M_INFO, 0, _("3991 Bad autochanger \"loaded drive %d\" command: ERR=%s.\n"), - drive, be.strerror()); - loaded = -1; /* force unload */ + Jmsg(jcr, M_INFO, 0, _("3991 Bad autochanger \"loaded? drive %d\" command: " + "ERR=%s.\nResults=%s\n"), drive, be.bstrerror(), results.c_str()); + loaded = -1; /* force unload */ } + unlock_changer(dcr); free_pool_memory(changer); - free_pool_memory(results); return loaded; } +static void lock_changer(DCR *dcr) +{ + AUTOCHANGER *changer_res = dcr->device->changer_res; + if (changer_res) { + Dmsg1(200, "Locking changer %s\n", changer_res->hdr.name); + P(changer_res->changer_mutex); /* Lock changer script */ + } +} + +static void unlock_changer(DCR *dcr) +{ + AUTOCHANGER *changer_res = dcr->device->changer_res; + if (changer_res) { + Dmsg1(200, "Unlocking changer %s\n", changer_res->hdr.name); + V(changer_res->changer_mutex); /* Unlock changer script */ + } +} + /* - * The Volume is not in the correct slot, so mark this - * Volume as not being in the Changer. + * Unload the volume, if any, in this drive + * On entry: loaded == 0 -- nothing to do + * loaded < 0 -- check if anything to do + * loaded > 0 -- load slot == loaded */ -void invalid_slot_in_catalog(DCR *dcr) +bool unload_autochanger(DCR *dcr, int loaded) { - JCR *jcr = dcr->jcr; DEVICE *dev = dcr->dev; - Jmsg(jcr, M_ERROR, 0, _("Autochanger Volume \"%s\" not found in slot %d.\n" -" Setting slot to zero in catalog.\n"), - dcr->VolCatInfo.VolCatName, dcr->VolCatInfo.Slot); - dcr->VolCatInfo.InChanger = false; - dev->VolCatInfo.InChanger = false; - Dmsg0(100, "update vol info in mount\n"); - dir_update_volume_info(dcr, true); /* set new status */ + JCR *jcr = dcr->jcr; + int slot; + uint32_t timeout = dcr->device->max_changer_wait; + bool ok = true; + + if (loaded == 0) { + return true; + } + + if (!dev->is_autochanger() || !dcr->device->changer_name || + !dcr->device->changer_command) { + return false; + } + + if (loaded < 0) { + loaded = get_autochanger_loaded_slot(dcr); + } + + if (loaded > 0) { + POOL_MEM results(PM_MESSAGE); + POOLMEM *changer = get_pool_memory(PM_FNAME); + lock_changer(dcr); + Jmsg(jcr, M_INFO, 0, + _("3307 Issuing autochanger \"unload slot %d, drive %d\" command.\n"), + loaded, dev->drive_index); + slot = dcr->VolCatInfo.Slot; + dcr->VolCatInfo.Slot = loaded; + changer = edit_device_codes(dcr, changer, + dcr->device->changer_command, "unload"); + dev->close(); + Dmsg1(100, "Run program=%s\n", changer); + *results.c_str() = 0; + int stat = run_program_full_output(changer, timeout, results.c_str()); + dcr->VolCatInfo.Slot = slot; + if (stat != 0) { + berrno be; + be.set_errno(stat); + Jmsg(jcr, M_INFO, 0, _("3995 Bad autochanger \"unload slot %d, drive %d\": " + "ERR=%s\nResults=%s\n"), + loaded, dev->drive_index, be.bstrerror(), results.c_str()); + ok = false; + dev->Slot = -1; /* unknown */ + } else { + dev->Slot = 0; /* nothing loaded */ + } + free_pool_memory(changer); + unlock_changer(dcr); + } + return ok; } +/* + * Unload the slot if mounted in a different drive + */ +static bool unload_other_drive(DCR *dcr, int slot) +{ + DEVICE *dev = NULL; + DEVICE *save_dev; + JCR *jcr = dcr->jcr; + int save_slot; + uint32_t timeout = dcr->device->max_changer_wait; + bool ok = true; + AUTOCHANGER *changer = dcr->dev->device->changer_res; + DEVRES *device; + bool found = false; + int retries = 0; /* wait for device retries */ + + if (!changer) { + return false; + } + if (changer->device->size() == 1) { + return true; + } + + foreach_alist(device, changer->device) { + if (device->dev && device->dev->Slot == slot) { + found = true; + dev = device->dev; + break; + } + } + if (!found) { + return true; + } + + /* The Volume we want is on another device. */ + if (dev->is_busy()) { + Dmsg4(100, "Vol %s for dev=%s in use dev=%s slot=%d\n", + dcr->VolumeName, dcr->dev->print_name(), + dev->print_name(), slot); + } + for (int i=0; i < 3; i++) { + if (dev->is_busy()) { + wait_for_device(dcr->jcr, retries); + continue; + } + break; + } + dev->dlock(); + if (dev->is_busy()) { + Jmsg(jcr, M_WARNING, 0, _("Volume \"%s\" is in use by device %s\n"), + dcr->VolumeName, dev->print_name()); + Dmsg4(100, "Vol %s for dev=%s is busy dev=%s slot=%d\n", + dcr->VolumeName, dcr->dev->print_name(), dev->print_name(), slot); + Dmsg2(100, "num_writ=%d reserv=%d\n", dev->num_writers, dev->reserved_device); + dev->dunlock(); + return false; + } + + POOLMEM *changer_cmd = get_pool_memory(PM_FNAME); + POOL_MEM results(PM_MESSAGE); + lock_changer(dcr); + Jmsg(jcr, M_INFO, 0, + _("3307 Issuing autochanger \"unload slot %d, drive %d\" command.\n"), + slot, dev->drive_index); + + Dmsg2(100, "Issuing autochanger \"unload slot %d, drive %d\" command.\n", + slot, dev->drive_index); + + save_dev = dcr->dev; + dcr->dev = dev; + save_slot = dcr->VolCatInfo.Slot; + dcr->VolCatInfo.Slot = slot; + changer_cmd = edit_device_codes(dcr, changer_cmd, + dcr->device->changer_command, "unload"); + dev->close(); + Dmsg2(200, "close dev=%s reserve=%d\n", dev->print_name(), + dev->reserved_device); + Dmsg1(100, "Run program=%s\n", changer_cmd); + int stat = run_program_full_output(changer_cmd, timeout, results.c_str()); + dcr->VolCatInfo.Slot = save_slot; + dcr->dev = save_dev; + if (stat != 0) { + berrno be; + be.set_errno(stat); + Jmsg(jcr, M_INFO, 0, _("3995 Bad autochanger \"unload slot %d, drive %d\": ERR=%s.\n"), + slot, dev->drive_index, be.bstrerror()); + + Dmsg3(100, "Bad autochanger \"unload slot %d, drive %d\": ERR=%s.\n", + slot, dev->drive_index, be.bstrerror()); + ok = false; + dev->Slot = -1; /* unknown */ + } else { + dev->Slot = 0; /* nothing loaded */ + Dmsg0(100, "Slot unloaded\n"); + } + unlock_changer(dcr); + dev->dunlock(); + free_pool_memory(changer_cmd); + return ok; +} + + + /* * List the Volumes that are in the autoloader possibly * with their barcodes. * We assume that it is always the Console that is calling us. */ -bool autochanger_list(DCR *dcr, BSOCK *dir) +bool autochanger_cmd(DCR *dcr, BSOCK *dir, const char *cmd) { DEVICE *dev = dcr->dev; - JCR *jcr = dcr->jcr; - uint32_t timeout = jcr->device->max_changer_wait; + uint32_t timeout = dcr->device->max_changer_wait; POOLMEM *changer; BPIPE *bpipe; - int slot, loaded; int len = sizeof_pool_memory(dir->msg) - 1; + bool ok = false; + int stat; - if (!dev_cap(dev, CAP_AUTOCHANGER) || !jcr->device->changer_name || - !jcr->device->changer_command) { - bnet_fsend(dir, _("3993 Not a autochanger device.\n")); + if (!dev->is_autochanger() || !dcr->device->changer_name || + !dcr->device->changer_command) { + if (strcmp(cmd, "drives") == 0) { + bnet_fsend(dir, "drives=1\n"); + } + bnet_fsend(dir, _("3993 Device %s not an autochanger device.\n"), + dev->print_name()); return false; } - changer = get_pool_memory(PM_FNAME); - offline_or_rewind_dev(dev); - /* We are going to load a new tape, so close the device */ - force_close_dev(dev); - - /* First unload any tape */ - loaded = get_autochanger_loaded_slot(jcr); - if (loaded > 0) { - bnet_fsend(dir, _("3305 Issuing autochanger \"unload slot %d\" command.\n"), loaded); - slot = dcr->VolCatInfo.Slot; - dcr->VolCatInfo.Slot = loaded; - changer = edit_device_codes(jcr, changer, jcr->device->changer_command, "unload"); - int stat = run_program(changer, timeout, NULL); - if (stat != 0) { - berrno be; - be.set_errno(stat); - Jmsg(jcr, M_INFO, 0, _("3995 Bad autochanger \"unload slot %d\" command: ERR=%s.\n"), - loaded, be.strerror()); + if (strcmp(cmd, "drives") == 0) { + AUTOCHANGER *changer_res = dcr->device->changer_res; + int drives = 1; + if (changer_res) { + drives = changer_res->device->size(); } - dcr->VolCatInfo.Slot = slot; + bnet_fsend(dir, "drives=%d\n", drives); + Dmsg1(100, "drives=%d\n", drives); + return true; } - /* Now list slots occupied */ - changer = edit_device_codes(jcr, changer, jcr->device->changer_command, "list"); - bnet_fsend(dir, _("3306 Issuing autochanger \"list\" command.\n")); + changer = get_pool_memory(PM_FNAME); + lock_changer(dcr); + /* Now issue the command */ + changer = edit_device_codes(dcr, changer, + dcr->device->changer_command, cmd); + bnet_fsend(dir, _("3306 Issuing autochanger \"%s\" command.\n"), cmd); bpipe = open_bpipe(changer, timeout, "r"); if (!bpipe) { - bnet_fsend(dir, _("3993 Open bpipe failed.\n")); - free_pool_memory(changer); - return false; - } - /* Get output from changer */ - while (fgets(dir->msg, len, bpipe->rfd)) { - dir->msglen = strlen(dir->msg); - bnet_send(dir); + bnet_fsend(dir, _("3996 Open bpipe failed.\n")); + goto bail_out; } - int stat = close_bpipe(bpipe); + if (strcmp(cmd, "list") == 0) { + /* Get output from changer */ + while (fgets(dir->msg, len, bpipe->rfd)) { + dir->msglen = strlen(dir->msg); + Dmsg1(100, "msg); + bnet_send(dir); + } + } else if (strcmp(cmd, "slots") == 0 ) { + char buf[100], *p; + /* For slots command, read a single line */ + buf[0] = 0; + fgets(buf, sizeof(buf)-1, bpipe->rfd); + buf[sizeof(buf)-1] = 0; + /* Strip any leading space in front of # of slots */ + for (p=buf; B_ISSPACE(*p); p++) + { } + bnet_fsend(dir, "slots=%s", p); + Dmsg1(100, "msg); + } + + stat = close_bpipe(bpipe); if (stat != 0) { berrno be; be.set_errno(stat); - bnet_fsend(dir, "Autochanger error: ERR=%s\n", be.strerror()); + bnet_fsend(dir, _("Autochanger error: ERR=%s\n"), be.bstrerror()); } bnet_sig(dir, BNET_EOD); + ok = true; +bail_out: + unlock_changer(dcr); free_pool_memory(changer); return true; } @@ -269,7 +557,7 @@ bool autochanger_list(DCR *dcr, BSOCK *dir) * %% = % * %a = archive device name * %c = changer device name - * %d = changer drive index + * %d = changer drive index * %f = Client's name * %j = Job name * %o = command @@ -280,69 +568,70 @@ bool autochanger_list(DCR *dcr, BSOCK *dir) * * omsg = edited output message * imsg = input string containing edit codes (%x) - * cmd = command string (load, unload, ...) + * cmd = command string (load, unload, ...) * */ -char *edit_device_codes(JCR *jcr, char *omsg, const char *imsg, const char *cmd) +char *edit_device_codes(DCR *dcr, char *omsg, const char *imsg, const char *cmd) { const char *p; const char *str; char add[20]; *omsg = 0; - Dmsg1(400, "edit_device_codes: %s\n", imsg); + Dmsg1(1800, "edit_device_codes: %s\n", imsg); for (p=imsg; *p; p++) { if (*p == '%') { - switch (*++p) { + switch (*++p) { case '%': str = "%"; - break; + break; case 'a': - str = dev_name(jcr->device->dev); - break; + str = dcr->dev->archive_name(); + break; case 'c': - str = NPRT(jcr->device->changer_name); - break; + str = NPRT(dcr->device->changer_name); + break; case 'd': - sprintf(add, "%d", jcr->device->dev->drive_index); - str = add; - break; + sprintf(add, "%d", dcr->dev->drive_index); + str = add; + break; case 'o': - str = NPRT(cmd); - break; + str = NPRT(cmd); + break; case 's': - sprintf(add, "%d", jcr->dcr->VolCatInfo.Slot - 1); - str = add; - break; + sprintf(add, "%d", dcr->VolCatInfo.Slot - 1); + str = add; + break; case 'S': - sprintf(add, "%d", jcr->dcr->VolCatInfo.Slot); - str = add; - break; + sprintf(add, "%d", dcr->VolCatInfo.Slot); + str = add; + break; case 'j': /* Job name */ - str = jcr->Job; - break; + str = dcr->jcr->Job; + break; case 'v': - str = NPRT(jcr->dcr->VolumeName); - break; + str = NPRT(dcr->VolumeName); + break; case 'f': - str = NPRT(jcr->client_name); - break; + str = NPRT(dcr->jcr->client_name); + break; - default: + default: add[0] = '%'; - add[1] = *p; - add[2] = 0; - str = add; - break; - } + add[1] = *p; + add[2] = 0; + str = add; + break; + } } else { - add[0] = *p; - add[1] = 0; - str = add; + add[0] = *p; + add[1] = 0; + str = add; } - Dmsg1(400, "add_str %s\n", str); + Dmsg1(1900, "add_str %s\n", str); pm_strcat(&omsg, (char *)str); - Dmsg1(400, "omsg=%s\n", omsg); + Dmsg1(1800, "omsg=%s\n", omsg); } + Dmsg1(800, "omsg=%s\n", omsg); return omsg; }