static void event_handler(switch_event_t *event)
{
switch_mutex_lock(MUTEX);
do_unload();
do_load();
switch_mutex_unlock(MUTEX);
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Number Translations Reloaded\n");
}
/*
* If release is set, we rewind the current volume,
* which we no longer want, and ask the user (console)
* to mount the next volume.
*
* Continue trying until we get it, and then ensure
* that we can write on it.
*
* This routine returns a 0 only if it is REALLY
* impossible to get the requested Volume.
*
*/
bool DCR::mount_next_write_volume()
{
int retry = 0;
bool ask = false, recycle, autochanger;
bool do_find = true;
int mode;
DCR *dcr = this;
Dmsg2(150, "Enter mount_next_volume(release=%d) dev=%s\n", dev->must_unload(),
dev->print_name());
init_device_wait_timers(dcr);
lock_volumes();
/*
* Attempt to mount the next volume. If something non-fatal goes
* wrong, we come back here to re-try (new op messages, re-read
* Volume, ...)
*/
mount_next_vol:
Dmsg1(150, "mount_next_vol retry=%d\n", retry);
/* Ignore retry if this is poll request */
if (!dev->poll && retry++ > 4) {
/* Last ditch effort before giving up, force operator to respond */
VolCatInfo.Slot = 0;
unlock_volumes();
if (!dir_ask_sysop_to_mount_volume(dcr, ST_APPEND)) {
Jmsg(jcr, M_FATAL, 0, _("Too many errors trying to mount device %s.\n"),
dev->print_name());
goto no_lock_bail_out;
}
lock_volumes();
Dmsg1(150, "Continue after dir_ask_sysop_to_mount. must_load=%d\n", dev->must_load());
}
if (job_canceled(jcr)) {
Jmsg(jcr, M_FATAL, 0, _("Job %d canceled.\n"), jcr->JobId);
goto bail_out;
}
recycle = false;
if (retry >= 2) {
do_find = false;
}
if (dev->must_unload()) {
ask = true; /* ask operator to mount tape */
do_find = true; /* re-find a volume after unload */
}
do_unload();
do_swapping(true /*is_writing*/);
do_load(true /*is_writing*/);
if (do_find && !find_a_volume()) {
goto no_lock_bail_out;
}
if (job_canceled(jcr)) {
goto bail_out;
}
Dmsg3(150, "After find_next_append. Vol=%s Slot=%d Parts=%d\n",
VolCatInfo.VolCatName, VolCatInfo.Slot, VolCatInfo.VolCatParts);
/*
* Get next volume and ready it for append
* This code ensures that the device is ready for
* writing. We start from the assumption that there
* may not be a tape mounted.
*
* If the device is a file, we create the output
* file. If it is a tape, we check the volume name
* and move the tape to the end of data.
*
*/
if (autoload_device(dcr, true/*writing*/, NULL) > 0) {
autochanger = true;
ask = false;
} else {
autochanger = false;
VolCatInfo.Slot = 0;
ask = retry >= 2;
}
Dmsg1(150, "autoload_dev returns %d\n", autochanger);
/*
* If we autochanged to correct Volume or (we have not just
* released the Volume AND we can automount) we go ahead
* and read the label. If there is no tape in the drive,
* we will fail, recurse and ask the operator the next time.
*/
if (!dev->must_unload() && dev->is_tape() && dev->has_cap(CAP_AUTOMOUNT)) {
Dmsg0(250, "(1)Ask=0\n");
ask = false; /* don't ask SYSOP this time */
}
/* Don't ask if not removable */
if (!dev->is_removable()) {
Dmsg0(250, "(2)Ask=0\n");
ask = false;
}
Dmsg2(250, "Ask=%d autochanger=%d\n", ask, autochanger);
if (ask) {
unlock_volumes();
if (!dir_ask_sysop_to_mount_volume(dcr, ST_APPEND)) {
Dmsg0(150, "Error return ask_sysop ...\n");
goto no_lock_bail_out;
}
lock_volumes();
}
if (job_canceled(jcr)) {
goto bail_out;
}
Dmsg3(150, "want vol=%s devvol=%s dev=%s\n", VolumeName,
dev->VolHdr.VolumeName, dev->print_name());
if (dev->poll && dev->has_cap(CAP_CLOSEONPOLL)) {
dev->close();
}
/* Ensure the device is open */
if (dev->has_cap(CAP_STREAM)) {
mode = OPEN_WRITE_ONLY;
} else {
mode = OPEN_READ_WRITE;
}
/* Try autolabel if enabled */
if (dev->open(dcr, mode) < 0) {
try_autolabel(false); /* try to create a new volume label */
}
while (dev->open(dcr, mode) < 0) {
Dmsg1(150, "open_device failed: ERR=%s\n", dev->bstrerror());
if ((dev->is_file() && dev->is_removable()) || dev->is_dvd()) {
bool ok = true;
Dmsg0(150, "call scan_dir_for_vol\n");
if (dev->is_dvd()) {
if (!dev->mount(0)) {
ok = false;
}
}
if (ok && dev->scan_dir_for_volume(dcr)) {
if (dev->open(dcr, mode) >= 0) {
break; /* got a valid volume */
}
}
if (ok && dev->is_dvd()) {
dev->unmount(0);
}
}
if (try_autolabel(false) == try_read_vol) {
break; /* created a new volume label */
}
Dmsg0(50, "set_unload\n");
dev->set_unload(); /* force ask sysop */
ask = true;
Dmsg0(150, "goto mount_next_vol\n");
goto mount_next_vol;
}
/*
* Now check the volume label to make sure we have the right tape mounted
*/
read_volume:
switch (check_volume_label(ask, autochanger)) {
case check_next_vol:
Dmsg0(50, "set_unload\n");
dev->set_unload(); /* want a different Volume */
Dmsg0(150, "goto mount_next_vol\n");
goto mount_next_vol;
case check_read_vol:
goto read_volume;
case check_error:
goto bail_out;
case check_ok:
break;
}
/*
* See if we have a fresh tape or a tape with data.
*
* Note, if the LabelType is PRE_LABEL, it was labeled
* but never written. If so, rewrite the label but set as
* VOL_LABEL. We rewind and return the label (reconstructed)
* in the block so that in the case of a new tape, data can
* be appended just after the block label. If we are writing
* a second volume, the calling routine will write the label
* before writing the overflow block.
*
* If the tape is marked as Recycle, we rewrite the label.
*/
recycle = strcmp(dev->VolCatInfo.VolCatStatus, "Recycle") == 0;
if (dev->VolHdr.LabelType == PRE_LABEL || recycle) {
if (!rewrite_volume_label(dcr, recycle)) {
mark_volume_in_error();
goto mount_next_vol;
}
} else {
/*
* OK, at this point, we have a valid Bacula label, but
* we need to position to the end of the volume, since we are
* just now putting it into append mode.
*/
Dmsg0(200, "Device previously written, moving to end of data\n");
Jmsg(jcr, M_INFO, 0, _("Volume \"%s\" previously written, moving to end of data.\n"),
VolumeName);
if (!dev->eod(dcr)) {
Jmsg(jcr, M_ERROR, 0, _("Unable to position to end of data on device %s: ERR=%s\n"),
dev->print_name(), dev->bstrerror());
mark_volume_in_error();
goto mount_next_vol;
}
if (!is_eod_valid()) {
Dmsg0(150, "goto mount_next_vol\n");
goto mount_next_vol;
}
dev->VolCatInfo.VolCatMounts++; /* Update mounts */
Dmsg1(150, "update volinfo mounts=%d\n", dev->VolCatInfo.VolCatMounts);
if (!dir_update_volume_info(dcr, false, false)) {
goto bail_out;
}
/* Return an empty block */
empty_block(block); /* we used it for reading so set for write */
}
dev->set_append();
Dmsg1(150, "set APPEND, normal return from mount_next_write_volume. dev=%s\n",
dev->print_name());
unlock_volumes();
return true;
bail_out:
unlock_volumes();
no_lock_bail_out:
return false;
}
int
main(int argc, char *argv[])
{
char *subcmd;
int cmdnum;
int cmd_index = 0;
int rc = SUCCESS;
(void) setlocale(LC_ALL, "");
#if !defined(TEXT_DOMAIN) /* Should be defined by cc -D */
#define TEXT_DOMAIN "SYS_TEST" /* Use this only if it weren't */
#endif
(void) textdomain(TEXT_DOMAIN);
cryptodebug_init(basename(argv[0]));
if (argc < REQ_ARG_CNT) {
usage();
return (ERROR_USAGE);
}
/* get the subcommand index */
cmd_index = 0;
subcmd = argv[1];
cmdnum = sizeof (cmd_table)/sizeof (cmd_table[0]);
while ((cmd_index < cmdnum) &&
(strcmp(subcmd, cmd_table[cmd_index]) != 0)) {
cmd_index++;
}
if (cmd_index >= cmdnum) {
usage();
return (ERROR_USAGE);
}
/* do the subcommand */
switch (cmd_index) {
case CRYPTO_LIST:
rc = do_list(argc, argv);
break;
case CRYPTO_DISABLE:
rc = do_disable(argc, argv);
break;
case CRYPTO_ENABLE:
rc = do_enable(argc, argv);
break;
case CRYPTO_INSTALL:
rc = do_install(argc, argv);
break;
case CRYPTO_UNINSTALL:
rc = do_uninstall(argc, argv);
break;
case CRYPTO_UNLOAD:
rc = do_unload(argc, argv);
break;
case CRYPTO_REFRESH:
rc = do_refresh(argc);
break;
case CRYPTO_START:
rc = do_start(argc);
break;
case CRYPTO_STOP:
rc = do_stop(argc);
break;
case CRYPTO_HELP:
usage();
rc = SUCCESS;
break;
default: /* should not come here */
usage();
rc = ERROR_USAGE;
break;
}
return (rc);
}
