/*
* Release resources allocated during backup.
*/
void admin_cleanup(JCR *jcr, int TermCode)
{
char sdt[50], edt[50], schedt[50];
char term_code[100];
const char *term_msg;
int msg_type;
MEDIA_DBR mr;
Dmsg0(100, "Enter backup_cleanup()\n");
update_job_end(jcr, TermCode);
if (!db_get_job_record(jcr, jcr->db, &jcr->jr)) {
Jmsg(jcr, M_WARNING, 0, _("Error getting Job record for Job report: ERR=%s"),
db_strerror(jcr->db));
jcr->setJobStatus(JS_ErrorTerminated);
}
msg_type = M_INFO; /* by default INFO message */
switch (jcr->JobStatus) {
case JS_Terminated:
term_msg = _("Admin OK");
break;
case JS_FatalError:
case JS_ErrorTerminated:
term_msg = _("*** Admin Error ***");
msg_type = M_ERROR; /* Generate error message */
break;
case JS_Canceled:
term_msg = _("Admin Canceled");
break;
default:
term_msg = term_code;
sprintf(term_code, _("Inappropriate term code: %c\n"), jcr->JobStatus);
break;
}
bstrftimes(schedt, sizeof(schedt), jcr->jr.SchedTime);
bstrftimes(sdt, sizeof(sdt), jcr->jr.StartTime);
bstrftimes(edt, sizeof(edt), jcr->jr.EndTime);
Jmsg(jcr, msg_type, 0, _("Bacula " VERSION " (" LSMDATE "): %s\n"
" JobId: %d\n"
" Job: %s\n"
" Scheduled time: %s\n"
" Start time: %s\n"
" End time: %s\n"
" Termination: %s\n\n"),
edt,
jcr->jr.JobId,
jcr->jr.Job,
schedt,
sdt,
edt,
term_msg);
Dmsg0(100, "Leave admin_cleanup()\n");
}
/*
* Generic function which generates a restore summary message.
* Used by:
* - native_restore_cleanup e.g. normal restores
* - ndmp_restore_cleanup e.g. NDMP restores
*/
void generate_restore_summary(JCR *jcr, int msg_type, const char *term_msg)
{
char sdt[MAX_TIME_LENGTH], edt[MAX_TIME_LENGTH];
char ec1[30], ec2[30], ec3[30];
char fd_term_msg[100], sd_term_msg[100];
double kbps;
bstrftimes(sdt, sizeof(sdt), jcr->jr.StartTime);
bstrftimes(edt, sizeof(edt), jcr->jr.EndTime);
if (jcr->jr.EndTime - jcr->jr.StartTime > 0) {
kbps = (double)jcr->jr.JobBytes / (1000 * (jcr->jr.EndTime - jcr->jr.StartTime));
} else {
kbps = 0;
}
if (kbps < 0.05) {
kbps = 0;
}
jobstatus_to_ascii(jcr->FDJobStatus, fd_term_msg, sizeof(fd_term_msg));
jobstatus_to_ascii(jcr->SDJobStatus, sd_term_msg, sizeof(sd_term_msg));
Jmsg(jcr, msg_type, 0, _("%s %s %s (%s):\n"
" Build OS: %s %s %s\n"
" JobId: %d\n"
" Job: %s\n"
" Restore Client: %s\n"
" Start time: %s\n"
" End time: %s\n"
" Files Expected: %s\n"
" Files Restored: %s\n"
" Bytes Restored: %s\n"
" Rate: %.1f KB/s\n"
" FD Errors: %d\n"
" FD termination status: %s\n"
" SD termination status: %s\n"
" Termination: %s\n\n"),
BAREOS, my_name, VERSION, LSMDATE,
HOST_OS, DISTNAME, DISTVER,
jcr->jr.JobId,
jcr->jr.Job,
jcr->res.client->name(),
sdt,
edt,
edit_uint64_with_commas((uint64_t)jcr->ExpectedFiles, ec1),
edit_uint64_with_commas((uint64_t)jcr->jr.JobFiles, ec2),
edit_uint64_with_commas(jcr->jr.JobBytes, ec3),
(float)kbps,
jcr->JobErrors,
fd_term_msg,
sd_term_msg,
term_msg);
}
static bool close_attr_spool_file(JCR *jcr, BSOCK *bs)
{
POOLMEM *name;
char tbuf[MAX_TIME_LENGTH];
Dmsg1(100, "Close attr spool file at %s\n", bstrftimes(tbuf, sizeof(tbuf), (utime_t)time(NULL)));
if (bs->m_spool_fd == -1) {
return true;
}
name = get_pool_memory(PM_MESSAGE);
P(mutex);
spool_stats.attr_jobs--;
spool_stats.total_attr_jobs++;
V(mutex);
make_unique_spool_filename(jcr, &name, bs->m_fd);
close(bs->m_spool_fd);
unlink(name);
free_pool_memory(name);
bs->m_spool_fd = -1;
bs->clear_spooling();
return true;
}
/*
* Connection request. We accept connections either from the
* Director, Storage Daemon or a Client (File daemon).
*
* Note, we are running as a seperate thread of the Storage daemon.
*
* Basic tasks done here:
* - If it was a connection from the FD, call handle_filed_connection()
* - If it was a connection from another SD, call handle_stored_connection()
* - Otherwise it was a connection from the DIR, call handle_director_connection()
*/
static void *handle_connection_request(void *arg)
{
BSOCK *bs = (BSOCK *)arg;
char name[MAX_NAME_LENGTH];
char tbuf[MAX_TIME_LENGTH];
if (bs->recv() <= 0) {
Emsg1(M_ERROR, 0, _("Connection request from %s failed.\n"), bs->who());
bmicrosleep(5, 0); /* make user wait 5 seconds */
bs->close();
return NULL;
}
/*
* Do a sanity check on the message received
*/
if (bs->msglen < MIN_MSG_LEN || bs->msglen > MAX_MSG_LEN) {
Dmsg1(000, "<filed: %s", bs->msg);
Emsg2(M_ERROR, 0, _("Invalid connection from %s. Len=%d\n"), bs->who(), bs->msglen);
bmicrosleep(5, 0); /* make user wait 5 seconds */
bs->close();
return NULL;
}
Dmsg1(110, "Conn: %s", bs->msg);
/*
* See if this is a File daemon connection. If so call FD handler.
*/
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)));
return handle_filed_connection(bs, name);
}
/*
* See if this is a Storage daemon connection. If so call SD handler.
*/
if (sscanf(bs->msg, "Hello Start Storage Job %127s", name) == 1) {
Dmsg1(110, "Got a SD connection at %s\n", bstrftimes(tbuf, sizeof(tbuf), (utime_t)time(NULL)));
return handle_stored_connection(bs, name);
}
Dmsg1(110, "Got a DIR connection at %s\n", bstrftimes(tbuf, sizeof(tbuf), (utime_t)time(NULL)));
return handle_director_connection(bs);
}
bool commit_attribute_spool(JCR *jcr)
{
boffset_t size;
char ec1[30];
char tbuf[100];
Dmsg1(100, "Commit attributes at %s\n", bstrftimes(tbuf, sizeof(tbuf),
(utime_t)time(NULL)));
if (are_attributes_spooled(jcr)) {
if (fseeko(jcr->dir_bsock->m_spool_fd, 0, SEEK_END) != 0) {
berrno be;
Jmsg(jcr, M_FATAL, 0, _("Fseek on attributes file failed: ERR=%s\n"),
be.bstrerror());
goto bail_out;
}
size = ftello(jcr->dir_bsock->m_spool_fd);
if (size < 0) {
berrno be;
Jmsg(jcr, M_FATAL, 0, _("Fseek on attributes file failed: ERR=%s\n"),
be.bstrerror());
goto bail_out;
}
P(mutex);
if (spool_stats.attr_size + size > spool_stats.max_attr_size) {
spool_stats.max_attr_size = spool_stats.attr_size + size;
}
spool_stats.attr_size += size;
V(mutex);
set_jcr_job_status(jcr, JS_AttrDespooling);
dir_send_job_status(jcr);
Jmsg(jcr, M_INFO, 0, _("Sending spooled attrs to the Director. Despooling %s bytes ...\n"),
edit_uint64_with_commas(size, ec1));
if (!blast_attr_spool_file(jcr, size)) {
/* Can't read spool file from director side,
* send content over network.
*/
jcr->dir_bsock->despool(update_attr_spool_size, size);
}
return close_attr_spool_file(jcr, jcr->dir_bsock);
}
return true;
bail_out:
close_attr_spool_file(jcr, jcr->dir_bsock);
return false;
}
/*
* This job is done, so release the device. From a Unix standpoint,
* the device remains open.
*
* Note, if we were spooling, we may enter with the device blocked.
* We unblock at the end, only if it was us who blocked the
* device.
*
*/
bool release_device(DCR *dcr)
{
utime_t now;
JCR *jcr = dcr->jcr;
DEVICE *dev = dcr->dev;
bool ok = true;
char tbuf[100];
int was_blocked = BST_NOT_BLOCKED;
/*
* Capture job statistics now that we are done using this device.
*/
now = (utime_t)time(NULL);
update_job_statistics(jcr, now);
dev->Lock();
if (!dev->is_blocked()) {
block_device(dev, BST_RELEASING);
} else {
was_blocked = dev->blocked();
dev->set_blocked(BST_RELEASING);
}
lock_volumes();
Dmsg2(100, "release_device device %s is %s\n", dev->print_name(), dev->is_tape() ? "tape" : "disk");
/*
* If device is reserved, job never started, so release the reserve here
*/
dcr->clear_reserved();
if (dev->can_read()) {
VOLUME_CAT_INFO *vol = &dev->VolCatInfo;
dev->clear_read(); /* clear read bit */
Dmsg2(150, "dir_update_vol_info. label=%d Vol=%s\n",
dev->is_labeled(), vol->VolCatName);
if (dev->is_labeled() && vol->VolCatName[0] != 0) {
dcr->dir_update_volume_info(false, false); /* send Volume info to Director */
remove_read_volume(jcr, dcr->VolumeName);
volume_unused(dcr);
}
} else if (dev->num_writers > 0) {
/*
* Note if WEOT is set, we are at the end of the tape and may not be positioned correctly,
* so the job_media_record and update_vol_info have already been done,
* which means we skip them here.
*/
dev->num_writers--;
Dmsg1(100, "There are %d writers in release_device\n", dev->num_writers);
if (dev->is_labeled()) {
Dmsg2(200, "dir_create_jobmedia. Release vol=%s dev=%s\n",
dev->getVolCatName(), dev->print_name());
if (!dev->at_weot() && !dcr->dir_create_jobmedia_record(false)) {
Jmsg2(jcr, M_FATAL, 0, _("Could not create JobMedia record for Volume=\"%s\" Job=%s\n"),
dcr->getVolCatName(), jcr->Job);
}
/*
* If no more writers, and no errors, and wrote something, write an EOF
*/
if (!dev->num_writers && dev->can_write() && dev->block_num > 0) {
dev->weof(1);
write_ansi_ibm_labels(dcr, ANSI_EOF_LABEL, dev->VolHdr.VolumeName);
}
if (!dev->at_weot()) {
dev->VolCatInfo.VolCatFiles = dev->file; /* set number of files */
/*
* Note! do volume update before close, which zaps VolCatInfo
*/
dcr->dir_update_volume_info(false, false); /* send Volume info to Director */
Dmsg2(200, "dir_update_vol_info. Release vol=%s dev=%s\n",
dev->getVolCatName(), dev->print_name());
}
if (dev->num_writers == 0) { /* if not being used */
volume_unused(dcr); /* we obviously are not using the volume */
}
}
} else {
/*
* If we reach here, it is most likely because the job has failed,
* since the device is not in read mode and there are no writers.
* It was probably reserved.
*/
volume_unused(dcr);
}
Dmsg3(100, "%d writers, %d reserve, dev=%s\n", dev->num_writers, dev->num_reserved(), dev->print_name());
/*
* If no writers, close if file or !CAP_ALWAYS_OPEN
*/
if (dev->num_writers == 0 && (!dev->is_tape() || !dev->has_cap(CAP_ALWAYSOPEN))) {
dev->close(dcr);
free_volume(dev);
}
unlock_volumes();
/*
* Fire off Alert command and include any output
*/
if (!job_canceled(jcr)) {
if (!dcr->device->drive_tapealert_enabled && dcr->device->alert_command) {
int status = 1;
POOLMEM *alert, *line;
BPIPE *bpipe;
alert = get_pool_memory(PM_FNAME);
line = get_pool_memory(PM_FNAME);
alert = edit_device_codes(dcr, alert, dcr->device->alert_command, "");
/*
* Wait maximum 5 minutes
*/
bpipe = open_bpipe(alert, 60 * 5, "r");
if (bpipe) {
while (bfgets(line, bpipe->rfd)) {
Jmsg(jcr, M_ALERT, 0, _("Alert: %s"), line);
}
status = close_bpipe(bpipe);
} else {
status = errno;
}
if (status != 0) {
berrno be;
Jmsg(jcr, M_ALERT, 0, _("3997 Bad alert command: %s: ERR=%s.\n"), alert, be.bstrerror(status));
}
Dmsg1(400, "alert status=%d\n", status);
free_pool_memory(alert);
free_pool_memory(line);
} else {
/*
* If all reservations are cleared for this device raise an event that SD plugins can register to.
*/
if (dev->num_reserved() == 0) {
generate_plugin_event(jcr, bsdEventDeviceReleased, dcr);
}
}
}
pthread_cond_broadcast(&dev->wait_next_vol);
Dmsg2(100, "JobId=%u broadcast wait_device_release at %s\n",
(uint32_t)jcr->JobId, bstrftimes(tbuf, sizeof(tbuf), (utime_t)time(NULL)));
release_device_cond();
/*
* If we are the thread that blocked the device, then unblock it
*/
if (pthread_equal(dev->no_wait_id, pthread_self())) {
dev->dunblock(true);
} else {
/*
* Otherwise, reset the prior block status and unlock
*/
dev->set_blocked(was_blocked);
dev->Unlock();
}
if (dcr->keep_dcr) {
detach_dcr_from_dev(dcr);
} else {
free_dcr(dcr);
}
Dmsg2(100, "Device %s released by JobId=%u\n", dev->print_name(), (uint32_t)jcr->JobId);
return ok;
}
bool commit_attribute_spool(JCR *jcr)
{
boffset_t size, data_end;
char ec1[30];
char tbuf[MAX_TIME_LENGTH];
BSOCK *dir;
Dmsg1(100, "Commit attributes at %s\n", bstrftimes(tbuf, sizeof(tbuf), (utime_t)time(NULL)));
if (are_attributes_spooled(jcr)) {
dir = jcr->dir_bsock;
if ((size = lseek(dir->m_spool_fd, 0, SEEK_END)) == -1) {
berrno be;
Jmsg(jcr, M_FATAL, 0, _("lseek on attributes file failed: ERR=%s\n"), be.bstrerror());
jcr->forceJobStatus(JS_FatalError); /* override any Incomplete */
goto bail_out;
}
if (jcr->is_JobStatus(JS_Incomplete)) {
data_end = dir->get_data_end();
/*
* Check and truncate to last valid data_end if necssary
*/
if (size > data_end) {
if (ftruncate(dir->m_spool_fd, data_end) != 0) {
berrno be;
Jmsg(jcr, M_FATAL, 0, _("Truncate on attributes file failed: ERR=%s\n"), be.bstrerror());
jcr->forceJobStatus(JS_FatalError); /* override any Incomplete */
goto bail_out;
}
Dmsg2(100, "=== Attrib spool truncated from %lld to %lld\n", size, data_end);
size = data_end;
}
}
if (size < 0) {
berrno be;
Jmsg(jcr, M_FATAL, 0, _("Fseek on attributes file failed: ERR=%s\n"),
be.bstrerror());
jcr->forceJobStatus(JS_FatalError); /* override any Incomplete */
goto bail_out;
}
P(mutex);
if (spool_stats.attr_size + size > spool_stats.max_attr_size) {
spool_stats.max_attr_size = spool_stats.attr_size + size;
}
spool_stats.attr_size += size;
V(mutex);
jcr->sendJobStatus(JS_AttrDespooling);
Jmsg(jcr, M_INFO, 0, _("Sending spooled attrs to the Director. Despooling %s bytes ...\n"),
edit_uint64_with_commas(size, ec1));
if (!blast_attr_spool_file(jcr, size)) {
/* Can't read spool file from director side,
* send content over network.
*/
dir->despool(update_attr_spool_size, size);
}
return close_attr_spool_file(jcr, dir);
}
return true;
bail_out:
close_attr_spool_file(jcr, dir);
return false;
}
/*
* Release resources allocated during backup.
*
*/
void verify_cleanup(JCR *jcr, int TermCode)
{
char sdt[50], edt[50];
char ec1[30], ec2[30];
char term_code[100], fd_term_msg[100], sd_term_msg[100];
const char *term_msg;
int msg_type;
const char *Name;
// Dmsg1(100, "Enter verify_cleanup() TermCod=%d\n", TermCode);
Dmsg3(900, "JobLevel=%c Expected=%u JobFiles=%u\n", jcr->getJobLevel(),
jcr->ExpectedFiles, jcr->JobFiles);
if ((jcr->getJobLevel() == L_VERIFY_VOLUME_TO_CATALOG || jcr->getJobLevel() == L_VERIFY_DATA) &&
jcr->ExpectedFiles != jcr->JobFiles) {
TermCode = JS_ErrorTerminated;
}
update_job_end(jcr, TermCode);
if (job_canceled(jcr)) {
cancel_storage_daemon_job(jcr);
}
if (jcr->unlink_bsr && jcr->RestoreBootstrap) {
unlink(jcr->RestoreBootstrap);
jcr->unlink_bsr = false;
}
msg_type = M_INFO; /* by default INFO message */
switch (TermCode) {
case JS_Terminated:
if (jcr->JobErrors || jcr->SDErrors) {
term_msg = _("Verify OK -- with warnings");
} else {
term_msg = _("Verify OK");
}
break;
case JS_FatalError:
case JS_ErrorTerminated:
term_msg = _("*** Verify Error ***");
msg_type = M_ERROR; /* Generate error message */
break;
case JS_Error:
term_msg = _("Verify warnings");
break;
case JS_Canceled:
term_msg = _("Verify Canceled");
break;
case JS_Differences:
term_msg = _("Verify Differences");
break;
default:
term_msg = term_code;
bsnprintf(term_code, sizeof(term_code),
_("Inappropriate term code: %d %c\n"), TermCode, TermCode);
break;
}
bstrftimes(sdt, sizeof(sdt), jcr->jr.StartTime);
bstrftimes(edt, sizeof(edt), jcr->jr.EndTime);
if (jcr->verify_job) {
Name = jcr->verify_job->hdr.name;
} else {
Name = "";
}
jobstatus_to_ascii(jcr->FDJobStatus, fd_term_msg, sizeof(fd_term_msg));
if (jcr->getJobLevel() == L_VERIFY_VOLUME_TO_CATALOG || jcr->getJobLevel() == L_VERIFY_DATA) {
jobstatus_to_ascii(jcr->SDJobStatus, sd_term_msg, sizeof(sd_term_msg));
Jmsg(jcr, msg_type, 0, _("%s %s %s (%s):\n"
" Build OS: %s %s %s\n"
" JobId: %d\n"
" Job: %s\n"
" FileSet: %s\n"
" Verify Level: %s\n"
" Client: %s\n"
" Verify JobId: %d\n"
" Verify Job: %s\n"
" Start time: %s\n"
" End time: %s\n"
" Files Expected: %s\n"
" Files Examined: %s\n"
" Non-fatal FD errors: %d\n"
" SD Errors: %d\n"
" FD termination status: %s\n"
" SD termination status: %s\n"
" Termination: %s\n\n"),
BACULA, my_name, VERSION, LSMDATE,
HOST_OS, DISTNAME, DISTVER,
jcr->jr.JobId,
jcr->jr.Job,
jcr->fileset->hdr.name,
level_to_str(jcr->getJobLevel()),
jcr->client->hdr.name,
jcr->previous_jr.JobId,
Name,
sdt,
edt,
edit_uint64_with_commas(jcr->ExpectedFiles, ec1),
edit_uint64_with_commas(jcr->JobFiles, ec2),
jcr->JobErrors,
jcr->SDErrors,
fd_term_msg,
sd_term_msg,
term_msg);
} else {
Jmsg(jcr, msg_type, 0, _("%s %s %s (%s):\n"
" Build: %s %s %s\n"
" JobId: %d\n"
" Job: %s\n"
" FileSet: %s\n"
" Verify Level: %s\n"
" Client: %s\n"
" Verify JobId: %d\n"
" Verify Job: %s\n"
" Start time: %s\n"
" End time: %s\n"
" Files Examined: %s\n"
" Non-fatal FD errors: %d\n"
" FD termination status: %s\n"
" Termination: %s\n\n"),
BACULA, my_name, VERSION, LSMDATE,
HOST_OS, DISTNAME, DISTVER,
jcr->jr.JobId,
jcr->jr.Job,
jcr->fileset->hdr.name,
level_to_str(jcr->getJobLevel()),
jcr->client->name(),
jcr->previous_jr.JobId,
Name,
sdt,
edt,
edit_uint64_with_commas(jcr->JobFiles, ec1),
jcr->JobErrors,
fd_term_msg,
term_msg);
}
Dmsg0(100, "Leave verify_cleanup()\n");
}
/*
* Handle signals here
*/
extern "C" void signal_handler(int sig)
{
static int already_dead = 0;
int chld_status=-1;
utime_t now;
/* If we come back more than once, get out fast! */
if (already_dead) {
exit(1);
}
Dmsg2(900, "sig=%d %s\n", sig, sig_names[sig]);
/* Ignore certain signals -- SIGUSR2 used to interrupt threads */
if (sig == SIGCHLD || sig == SIGUSR2) {
return;
}
/* FreeBSD seems to generate a signal of 0, which is of course undefined */
if (sig == 0) {
return;
}
already_dead++;
/* Don't use Emsg here as it may lock and thus block us */
if (sig == SIGTERM || sig == SIGINT) {
syslog(LOG_DAEMON|LOG_ERR, "Shutting down Bacula service: %s ...\n", my_name);
} else {
fprintf(stderr, _("Bacula interrupted by signal %d: %s\n"), sig, get_signal_name(sig));
syslog(LOG_DAEMON|LOG_ERR,
_("Bacula interrupted by signal %d: %s\n"), sig, get_signal_name(sig));
/* Edit current time for showing in the dump */
now = time(NULL);
bstrftimes(fail_time, 30, now);
}
#ifdef TRACEBACK
if (sig != SIGTERM && sig != SIGINT) {
struct sigaction sigdefault;
static char *argv[5];
static char pid_buf[20];
static char btpath[400];
char buf[400];
pid_t pid;
int exelen = strlen(exepath);
fprintf(stderr, _("Kaboom! %s, %s got signal %d - %s at %s. Attempting traceback.\n"),
exename, my_name, sig, get_signal_name(sig), fail_time);
fprintf(stderr, _("Kaboom! exepath=%s\n"), exepath);
if (exelen + 12 > (int)sizeof(btpath)) {
bstrncpy(btpath, "btraceback", sizeof(btpath));
} else {
bstrncpy(btpath, exepath, sizeof(btpath));
if (IsPathSeparator(btpath[exelen-1])) {
btpath[exelen-1] = 0;
}
bstrncat(btpath, "/btraceback", sizeof(btpath));
}
if (!IsPathSeparator(exepath[exelen - 1])) {
strcat(exepath, "/");
}
strcat(exepath, exename);
if (!working_directory) {
working_directory = buf;
*buf = 0;
}
if (*working_directory == 0) {
strcpy((char *)working_directory, "/tmp/");
}
if (chdir(working_directory) != 0) { /* dump in working directory */
berrno be;
Pmsg2(000, "chdir to %s failed. ERR=%s\n", working_directory, be.bstrerror());
strcpy((char *)working_directory, "/tmp/");
}
unlink("./core"); /* get rid of any old core file */
#ifdef DEVELOPER /* When DEVELOPER not set, this is done below */
/* print information about the current state into working/<file>.lockdump */
dbg_print_bacula();
#endif
sprintf(pid_buf, "%d", (int)main_pid);
Dmsg1(300, "Working=%s\n", working_directory);
Dmsg1(300, "btpath=%s\n", btpath);
Dmsg1(300, "exepath=%s\n", exepath);
switch (pid = fork()) {
case -1: /* error */
fprintf(stderr, _("Fork error: ERR=%s\n"), strerror(errno));
break;
case 0: /* child */
argv[0] = btpath; /* path to btraceback */
argv[1] = exepath; /* path to exe */
argv[2] = pid_buf;
argv[3] = (char *)working_directory;
argv[4] = (char *)NULL;
fprintf(stderr, _("Calling: %s %s %s %s\n"), btpath, exepath, pid_buf,
working_directory);
if (execv(btpath, argv) != 0) {
berrno be;
printf(_("execv: %s failed: ERR=%s\n"), btpath, be.bstrerror());
}
exit(-1);
default: /* parent */
break;
}
/* Parent continue here, waiting for child */
sigdefault.sa_flags = 0;
sigdefault.sa_handler = SIG_DFL;
sigfillset(&sigdefault.sa_mask);
sigaction(sig, &sigdefault, NULL);
if (pid > 0) {
Dmsg0(500, "Doing waitpid\n");
waitpid(pid, &chld_status, 0); /* wait for child to produce dump */
Dmsg0(500, "Done waitpid\n");
} else {
Dmsg0(500, "Doing sleep\n");
bmicrosleep(30, 0);
}
if (WEXITSTATUS(chld_status) == 0) {
fprintf(stderr, _("It looks like the traceback worked...\n"));
} else {
fprintf(stderr, _("The btraceback call returned %d\n"),
WEXITSTATUS(chld_status));
}
/* If we want it printed, do so */
#ifdef direct_print
if (prt_kaboom) {
FILE *fd;
snprintf(buf, sizeof(buf), "%s/%s.%s.traceback", working_directory, my_name, pid_buf);
fd = fopen(buf, "r");
if (fd != NULL) {
printf("\n\n ==== Traceback output ====\n\n");
while (fgets(buf, (int)sizeof(buf), fd) != NULL) {
printf("%s", buf);
}
fclose(fd);
printf(" ==== End traceback output ====\n\n");
}
}
#else
if (prt_kaboom) {
snprintf(buf, sizeof(buf), "/bin/cat %s/%s.%s.traceback", working_directory, my_name, pid_buf);
fprintf(stderr, "\n\n ==== Traceback output ====\n\n");
system(buf);
fprintf(stderr, " ==== End traceback output ====\n\n");
}
#endif
#ifndef DEVELOPER /* When DEVELOPER set, this is done above */
/* print information about the current state into working/<file>.lockdump */
dbg_print_bacula();
#endif
}
#endif
exit_handler(sig);
Dmsg0(500, "Done exit_handler\n");
}
void dump_label_record(DEVICE *dev, DEV_RECORD *rec, bool verbose)
{
const char *type;
int dbl;
if (rec->FileIndex == 0 && rec->VolSessionId == 0 && rec->VolSessionTime == 0) {
return;
}
dbl = debug_level;
debug_level = 1;
switch (rec->FileIndex) {
case PRE_LABEL:
type = _("Fresh Volume");
break;
case VOL_LABEL:
type = _("Volume");
break;
case SOS_LABEL:
type = _("Begin Job Session");
break;
case EOS_LABEL:
type = _("End Job Session");
break;
case EOM_LABEL:
type = _("End of Media");
break;
case EOT_LABEL:
type = _("End of Tape");
break;
default:
type = _("Unknown");
break;
}
if (verbose) {
switch (rec->FileIndex) {
case PRE_LABEL:
case VOL_LABEL:
unser_volume_label(dev, rec);
dump_volume_label(dev);
break;
case SOS_LABEL:
dump_session_label(rec, type);
break;
case EOS_LABEL:
dump_session_label(rec, type);
break;
case EOM_LABEL:
Pmsg7(-1, _("%s Record: File:blk=%u:%u SessId=%d SessTime=%d JobId=%d DataLen=%d\n"),
type, dev->file, dev->block_num, rec->VolSessionId,
rec->VolSessionTime, rec->Stream, rec->data_len);
break;
case EOT_LABEL:
Pmsg0(-1, _("End of physical tape.\n"));
break;
default:
Pmsg7(-1, _("%s Record: File:blk=%u:%u SessId=%d SessTime=%d JobId=%d DataLen=%d\n"),
type, dev->file, dev->block_num, rec->VolSessionId,
rec->VolSessionTime, rec->Stream, rec->data_len);
break;
}
} else {
SESSION_LABEL label;
char dt[50];
switch (rec->FileIndex) {
case SOS_LABEL:
unser_session_label(&label, rec);
bstrftimes(dt, sizeof(dt), btime_to_utime(label.write_btime));
Pmsg6(-1, _("%s Record: File:blk=%u:%u SessId=%d SessTime=%d JobId=%d\n"),
type, dev->file, dev->block_num, rec->VolSessionId, rec->VolSessionTime, label.JobId);
Pmsg4(-1, _(" Job=%s Date=%s Level=%c Type=%c\n"),
label.Job, dt, label.JobLevel, label.JobType);
break;
case EOS_LABEL:
char ed1[30], ed2[30];
unser_session_label(&label, rec);
bstrftimes(dt, sizeof(dt), btime_to_utime(label.write_btime));
Pmsg6(-1, _("%s Record: File:blk=%u:%u SessId=%d SessTime=%d JobId=%d\n"),
type, dev->file, dev->block_num, rec->VolSessionId, rec->VolSessionTime, label.JobId);
Pmsg7(-1, _(" Date=%s Level=%c Type=%c Files=%s Bytes=%s Errors=%d Status=%c\n"),
dt, label.JobLevel, label.JobType,
edit_uint64_with_commas(label.JobFiles, ed1),
edit_uint64_with_commas(label.JobBytes, ed2),
label.JobErrors, (char)label.JobStatus);
break;
case EOM_LABEL:
case PRE_LABEL:
case VOL_LABEL:
default:
Pmsg7(-1, _("%s Record: File:blk=%u:%u SessId=%d SessTime=%d JobId=%d DataLen=%d\n"),
type, dev->file, dev->block_num, rec->VolSessionId, rec->VolSessionTime,
rec->Stream, rec->data_len);
break;
case EOT_LABEL:
break;
}
}
debug_level = dbl;
}
void update_bootstrap_file(JCR *jcr)
{
/* Now update the bootstrap file if any */
if (jcr->JobStatus == JS_Terminated && jcr->jr.JobBytes &&
jcr->job->WriteBootstrap) {
FILE *fd;
BPIPE *bpipe = NULL;
int got_pipe = 0;
POOLMEM *fname = get_pool_memory(PM_FNAME);
fname = edit_job_codes(jcr, fname, jcr->job->WriteBootstrap, "");
VOL_PARAMS *VolParams = NULL;
int VolCount;
char edt[50], ed1[50], ed2[50];
if (*fname == '|') {
got_pipe = 1;
bpipe = open_bpipe(fname+1, 0, "w"); /* skip first char "|" */
fd = bpipe ? bpipe->wfd : NULL;
} else {
/* ***FIXME*** handle BASE */
fd = fopen(fname, jcr->get_JobLevel()==L_FULL?"w+b":"a+b");
}
if (fd) {
VolCount = db_get_job_volume_parameters(jcr, jcr->db, jcr->JobId,
&VolParams);
if (VolCount == 0) {
Jmsg(jcr, M_ERROR, 0, _("Could not get Job Volume Parameters to "
"update Bootstrap file. ERR=%s\n"), db_strerror(jcr->db));
if (jcr->SDJobFiles != 0) {
set_jcr_job_status(jcr, JS_ErrorTerminated);
}
}
/* Start output with when and who wrote it */
bstrftimes(edt, sizeof(edt), time(NULL));
fprintf(fd, "# %s - %s - %s%s\n", edt, jcr->jr.Job,
level_to_str(jcr->get_JobLevel()), jcr->since);
for (int i=0; i < VolCount; i++) {
/* Write the record */
fprintf(fd, "Volume=\"%s\"\n", VolParams[i].VolumeName);
fprintf(fd, "MediaType=\"%s\"\n", VolParams[i].MediaType);
if (VolParams[i].Slot > 0) {
fprintf(fd, "Slot=%d\n", VolParams[i].Slot);
}
fprintf(fd, "VolSessionId=%u\n", jcr->VolSessionId);
fprintf(fd, "VolSessionTime=%u\n", jcr->VolSessionTime);
fprintf(fd, "VolAddr=%s-%s\n",
edit_uint64(VolParams[i].StartAddr, ed1),
edit_uint64(VolParams[i].EndAddr, ed2));
fprintf(fd, "FileIndex=%d-%d\n", VolParams[i].FirstIndex,
VolParams[i].LastIndex);
}
if (VolParams) {
free(VolParams);
}
if (got_pipe) {
close_bpipe(bpipe);
} else {
fclose(fd);
}
} else {
berrno be;
Jmsg(jcr, M_ERROR, 0, _("Could not open WriteBootstrap file:\n"
"%s: ERR=%s\n"), fname, be.bstrerror());
set_jcr_job_status(jcr, JS_ErrorTerminated);
}
free_pool_memory(fname);
}
}
/*
* Release resources allocated during backup.
*/
void backup_cleanup(JCR *jcr, int TermCode)
{
char sdt[50], edt[50], schedt[50];
char ec1[30], ec2[30], ec3[30], ec4[30], ec5[30], compress[50];
char ec6[30], ec7[30], ec8[30], elapsed[50];
char term_code[100], fd_term_msg[100], sd_term_msg[100];
const char *term_msg;
int msg_type = M_INFO;
MEDIA_DBR mr;
CLIENT_DBR cr;
double kbps, compression;
utime_t RunTime;
if (jcr->get_JobLevel() == L_VIRTUAL_FULL) {
vbackup_cleanup(jcr, TermCode);
return;
}
Dmsg2(100, "Enter backup_cleanup %d %c\n", TermCode, TermCode);
memset(&mr, 0, sizeof(mr));
memset(&cr, 0, sizeof(cr));
update_job_end(jcr, TermCode);
if (!db_get_job_record(jcr, jcr->db, &jcr->jr)) {
Jmsg(jcr, M_WARNING, 0, _("Error getting Job record for Job report: ERR=%s"),
db_strerror(jcr->db));
set_jcr_job_status(jcr, JS_ErrorTerminated);
}
bstrncpy(cr.Name, jcr->client->name(), sizeof(cr.Name));
if (!db_get_client_record(jcr, jcr->db, &cr)) {
Jmsg(jcr, M_WARNING, 0, _("Error getting Client record for Job report: ERR=%s"),
db_strerror(jcr->db));
}
bstrncpy(mr.VolumeName, jcr->VolumeName, sizeof(mr.VolumeName));
if (!db_get_media_record(jcr, jcr->db, &mr)) {
Jmsg(jcr, M_WARNING, 0, _("Error getting Media record for Volume \"%s\": ERR=%s"),
mr.VolumeName, db_strerror(jcr->db));
set_jcr_job_status(jcr, JS_ErrorTerminated);
}
update_bootstrap_file(jcr);
switch (jcr->JobStatus) {
case JS_Terminated:
if (jcr->JobErrors || jcr->SDErrors) {
term_msg = _("Backup OK -- with warnings");
} else {
term_msg = _("Backup OK");
}
break;
case JS_Warnings:
term_msg = _("Backup OK -- with warnings");
break;
case JS_FatalError:
case JS_ErrorTerminated:
term_msg = _("*** Backup Error ***");
msg_type = M_ERROR; /* Generate error message */
if (jcr->store_bsock) {
jcr->store_bsock->signal(BNET_TERMINATE);
if (jcr->SD_msg_chan) {
pthread_cancel(jcr->SD_msg_chan);
}
}
break;
case JS_Canceled:
term_msg = _("Backup Canceled");
if (jcr->store_bsock) {
jcr->store_bsock->signal(BNET_TERMINATE);
if (jcr->SD_msg_chan) {
pthread_cancel(jcr->SD_msg_chan);
}
}
break;
default:
term_msg = term_code;
sprintf(term_code, _("Inappropriate term code: %c\n"), jcr->JobStatus);
break;
}
bstrftimes(schedt, sizeof(schedt), jcr->jr.SchedTime);
bstrftimes(sdt, sizeof(sdt), jcr->jr.StartTime);
bstrftimes(edt, sizeof(edt), jcr->jr.EndTime);
RunTime = jcr->jr.EndTime - jcr->jr.StartTime;
if (RunTime <= 0) {
kbps = 0;
} else {
kbps = ((double)jcr->jr.JobBytes) / (1000.0 * (double)RunTime);
}
if (!db_get_job_volume_names(jcr, jcr->db, jcr->jr.JobId, &jcr->VolumeName)) {
/*
* Note, if the job has erred, most likely it did not write any
* tape, so suppress this "error" message since in that case
* it is normal. Or look at it the other way, only for a
* normal exit should we complain about this error.
*/
if (jcr->JobStatus == JS_Terminated && jcr->jr.JobBytes) {
Jmsg(jcr, M_ERROR, 0, "%s", db_strerror(jcr->db));
}
jcr->VolumeName[0] = 0; /* none */
}
if (jcr->ReadBytes == 0) {
bstrncpy(compress, "None", sizeof(compress));
} else {
compression = (double)100 - 100.0 * ((double)jcr->JobBytes / (double)jcr->ReadBytes);
if (compression < 0.5) {
bstrncpy(compress, "None", sizeof(compress));
} else {
bsnprintf(compress, sizeof(compress), "%.1f %%", compression);
}
}
jobstatus_to_ascii(jcr->FDJobStatus, fd_term_msg, sizeof(fd_term_msg));
jobstatus_to_ascii(jcr->SDJobStatus, sd_term_msg, sizeof(sd_term_msg));
// bmicrosleep(15, 0); /* for debugging SIGHUP */
Jmsg(jcr, msg_type, 0, _("%s %s %s (%s): %s\n"
" Build OS: %s %s %s\n"
" JobId: %d\n"
" Job: %s\n"
" Backup Level: %s%s\n"
" Client: \"%s\" %s\n"
" FileSet: \"%s\" %s\n"
" Pool: \"%s\" (From %s)\n"
" Catalog: \"%s\" (From %s)\n"
" Storage: \"%s\" (From %s)\n"
" Scheduled time: %s\n"
" Start time: %s\n"
" End time: %s\n"
" Elapsed time: %s\n"
" Priority: %d\n"
" FD Files Written: %s\n"
" SD Files Written: %s\n"
" FD Bytes Written: %s (%sB)\n"
" SD Bytes Written: %s (%sB)\n"
" Rate: %.1f KB/s\n"
" Software Compression: %s\n"
" VSS: %s\n"
" Encryption: %s\n"
" Accurate: %s\n"
" Volume name(s): %s\n"
" Volume Session Id: %d\n"
" Volume Session Time: %d\n"
" Last Volume Bytes: %s (%sB)\n"
" Non-fatal FD errors: %d\n"
" SD Errors: %d\n"
" FD termination status: %s\n"
" SD termination status: %s\n"
" Termination: %s\n\n"),
BACULA, my_name, VERSION, LSMDATE, edt,
HOST_OS, DISTNAME, DISTVER,
jcr->jr.JobId,
jcr->jr.Job,
level_to_str(jcr->get_JobLevel()), jcr->since,
jcr->client->name(), cr.Uname,
jcr->fileset->name(), jcr->FSCreateTime,
jcr->pool->name(), jcr->pool_source,
jcr->catalog->name(), jcr->catalog_source,
jcr->wstore->name(), jcr->wstore_source,
schedt,
sdt,
edt,
edit_utime(RunTime, elapsed, sizeof(elapsed)),
jcr->JobPriority,
edit_uint64_with_commas(jcr->jr.JobFiles, ec1),
edit_uint64_with_commas(jcr->SDJobFiles, ec2),
edit_uint64_with_commas(jcr->jr.JobBytes, ec3),
edit_uint64_with_suffix(jcr->jr.JobBytes, ec4),
edit_uint64_with_commas(jcr->SDJobBytes, ec5),
edit_uint64_with_suffix(jcr->SDJobBytes, ec6),
kbps,
compress,
jcr->VSS?_("yes"):_("no"),
jcr->Encrypt?_("yes"):_("no"),
jcr->accurate?_("yes"):_("no"),
jcr->VolumeName,
jcr->VolSessionId,
jcr->VolSessionTime,
edit_uint64_with_commas(mr.VolBytes, ec7),
edit_uint64_with_suffix(mr.VolBytes, ec8),
jcr->JobErrors,
jcr->SDErrors,
fd_term_msg,
sd_term_msg,
term_msg);
Dmsg0(100, "Leave backup_cleanup()\n");
}
