+/*
+ Bacula® - The Network Backup Solution
+
+ Copyright (C) 2004-2007 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 two of the GNU 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 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.
+*/
/*
* Spooling code
*
*
* Version $Id$
*/
-/*
- Copyright (C) 2004-2005 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"
#include "stored.h"
RB_OK
};
-void list_spool_stats(BSOCK *bs)
+void list_spool_stats(void sendit(const char *msg, int len, void *sarg), void *arg)
{
char ed1[30], ed2[30];
+ POOL_MEM msg(PM_MESSAGE);
+ int len;
+
+ len = Mmsg(msg, _("Spooling statistics:\n"));
+
if (spool_stats.data_jobs || spool_stats.max_data_size) {
- bnet_fsend(bs, _("Data spooling: %u active jobs, %s bytes; %u total jobs, %s max bytes/job.\n"),
+ len = Mmsg(msg, _("Data spooling: %u active jobs, %s bytes; %u total jobs, %s max bytes/job.\n"),
spool_stats.data_jobs, edit_uint64_with_commas(spool_stats.data_size, ed1),
spool_stats.total_data_jobs,
edit_uint64_with_commas(spool_stats.max_data_size, ed2));
+
+ sendit(msg.c_str(), len, arg);
}
if (spool_stats.attr_jobs || spool_stats.max_attr_size) {
- bnet_fsend(bs, _("Attr spooling: %u active jobs, %s bytes; %u total jobs, %s max bytes.\n"),
+ len = Mmsg(msg, _("Attr spooling: %u active jobs, %s bytes; %u total jobs, %s max bytes.\n"),
spool_stats.attr_jobs, edit_uint64_with_commas(spool_stats.attr_size, ed1),
spool_stats.total_attr_jobs,
edit_uint64_with_commas(spool_stats.max_attr_size, ed2));
+
+ sendit(msg.c_str(), len, arg);
}
+ len = Mmsg(msg, "====\n");
+ sendit(msg.c_str(), len, arg);
}
bool begin_data_spool(DCR *dcr)
{
bool stat = true;
- if (dcr->jcr->spool_data) {
+ if (!dcr->dev->is_dvd() && dcr->jcr->spool_data) {
Dmsg0(100, "Turning on data spooling\n");
dcr->spool_data = true;
stat = open_data_spool_file(dcr);
} else {
dir = working_directory;
}
- Mmsg(name, "%s/%s.data.%s.%s.spool", dir, my_name, dcr->jcr->Job,
- dcr->device->hdr.name);
+ Mmsg(name, "%s/%s.data.%u.%s.%s.spool", dir, my_name, dcr->jcr->JobId,
+ dcr->jcr->Job, dcr->device->hdr.name);
}
} else {
berrno be;
Jmsg(dcr->jcr, M_FATAL, 0, _("Open data spool file %s failed: ERR=%s\n"), name,
- be.strerror());
+ be.bstrerror());
free_pool_memory(name);
return false;
}
static const char *spool_name = "*spool*";
+/*
+ * NB! This routine locks the device, but if committing will
+ * not unlock it. If not committing, it will be unlocked.
+ */
static bool despool_data(DCR *dcr, bool commit)
{
DEVICE *rdev;
char ec1[50];
Dmsg0(100, "Despooling data\n");
+ /*
+ * Commit means that the job is done, so we commit, otherwise, we
+ * are despooling because of user spool size max or some error
+ * (e.g. filesystem full).
+ */
if (commit) {
Jmsg(jcr, M_INFO, 0, _("Committing spooled data to Volume \"%s\". Despooling %s bytes ...\n"),
jcr->dcr->VolumeName,
edit_uint64_with_commas(jcr->dcr->job_spool_size, ec1));
- }
- else {
+ } else {
Jmsg(jcr, M_INFO, 0, _("Writing spooled data to Volume. Despooling %s bytes ...\n"),
edit_uint64_with_commas(jcr->dcr->job_spool_size, ec1));
}
+ dcr->despool_wait = true;
dcr->spooling = false;
- lock_device(dcr->dev);
- dcr->dev_locked = true;
+ /*
+ * We work with device blocked, but not locked so that
+ * other threads -- e.g. reservations can lock the device
+ * structure.
+ */
+ dcr->dblock(BST_DESPOOLING);
+ dcr->despool_wait = false;
+ dcr->despooling = true;
/*
* This is really quite kludgy and should be fixed some time.
rdev->max_block_size = dcr->dev->max_block_size;
rdev->min_block_size = dcr->dev->min_block_size;
rdev->device = dcr->dev->device;
- rdcr = new_dcr(NULL, rdev);
+ rdcr = new_dcr(jcr, NULL, rdev);
rdcr->spool_fd = dcr->spool_fd;
- rdcr->jcr = jcr; /* set a valid jcr */
block = dcr->block; /* save block */
dcr->block = rdcr->block; /* make read and write block the same */
Dmsg1(800, "read/write block size = %d\n", block->buf_len);
lseek(rdcr->spool_fd, 0, SEEK_SET); /* rewind */
+#if defined(HAVE_POSIX_FADVISE) && defined(POSIX_FADV_WILLNEED)
+ posix_fadvise(rdcr->spool_fd, 0, 0, POSIX_FADV_WILLNEED);
+#endif
+
+ /* Add run time, to get current wait time */
+ time_t despool_start = time(NULL) - jcr->run_time;
+
for ( ; ok; ) {
if (job_canceled(jcr)) {
ok = false;
}
Dmsg3(800, "Write block ok=%d FI=%d LI=%d\n", ok, block->FirstIndex, block->LastIndex);
}
+
+ /* Subtracting run_time give us elapsed time - wait_time since we started despooling */
+ time_t despool_elapsed = time(NULL) - despool_start - jcr->run_time;
+
+ if (despool_elapsed <= 0) {
+ despool_elapsed = 1;
+ }
+
+ Jmsg(dcr->jcr, M_INFO, 0, _("Despooling elapsed time = %02d:%02d:%02d, Transfer rate = %s bytes/second\n"),
+ despool_elapsed / 3600, despool_elapsed % 3600 / 60, despool_elapsed % 60,
+ edit_uint64_with_suffix(jcr->dcr->job_spool_size / despool_elapsed, ec1));
+
dcr->block = block; /* reset block */
lseek(rdcr->spool_fd, 0, SEEK_SET); /* rewind */
if (ftruncate(rdcr->spool_fd, 0) != 0) {
berrno be;
Jmsg(dcr->jcr, M_ERROR, 0, _("Ftruncate spool file failed: ERR=%s\n"),
- be.strerror());
- Pmsg1(000, _("Bad return from ftruncate. ERR=%s\n"), be.strerror());
- ok = false;
+ be.bstrerror());
+ /* Note, try continuing despite ftruncate problem */
}
P(mutex);
free_pool_memory(rdev->errmsg);
/* Be careful to NULL the jcr and free rdev after free_dcr() */
rdcr->jcr = NULL;
+ rdcr->dev = NULL;
free_dcr(rdcr);
free(rdev);
- unlock_device(dcr->dev);
- dcr->dev_locked = false;
dcr->spooling = true; /* turn on spooling again */
+ dcr->despooling = false;
+ /*
+ * We are done, so unblock the device, but if we have done a
+ * commit, leave it locked so that the job cleanup does not
+ * need to wait to release the device (no re-acquire of the lock).
+ */
+ dcr->dlock();
+ unblock_device(dcr->dev);
+ /* If doing a commit, leave the device locked -- unlocked in release_device() */
+ if (!commit) {
+ dcr->dunlock();
+ }
return ok;
}
if (stat == -1) {
berrno be;
Jmsg(dcr->jcr, M_FATAL, 0, _("Spool header read error. ERR=%s\n"),
- be.strerror());
+ be.bstrerror());
} else {
Pmsg2(000, _("Spool read error. Wanted %u bytes, got %d\n"), rlen, stat);
Jmsg2(dcr->jcr, M_FATAL, 0, _("Spool header read error. Wanted %u bytes, got %d\n"), rlen, stat);
if (stat == -1) {
berrno be;
Jmsg(dcr->jcr, M_FATAL, 0, _("Error writing header to spool file. ERR=%s\n"),
- be.strerror());
+ be.bstrerror());
}
if (stat != (ssize_t)sizeof(hdr)) {
/* If we wrote something, truncate it, then despool */
if (stat != -1) {
- if (ftruncate(dcr->spool_fd, lseek(dcr->spool_fd, (off_t)0, SEEK_CUR) - stat) != 0) {
+#if defined(HAVE_WIN32)
+ boffset_t pos = _lseeki64(dcr->spool_fd, (__int64)0, SEEK_CUR);
+#else
+ boffset_t pos = lseek(dcr->spool_fd, (off_t)0, SEEK_CUR);
+#endif
+ if (ftruncate(dcr->spool_fd, pos - stat) != 0) {
berrno be;
- Jmsg(dcr->jcr, M_FATAL, 0, _("Ftruncate spool file failed: ERR=%s\n"),
- be.strerror());
- return false;
+ Jmsg(dcr->jcr, M_ERROR, 0, _("Ftruncate spool file failed: ERR=%s\n"),
+ be.bstrerror());
+ /* Note, try continuing despite ftruncate problem */
}
}
if (!despool_data(dcr, false)) {
if (stat == -1) {
berrno be;
Jmsg(dcr->jcr, M_FATAL, 0, _("Error writing data to spool file. ERR=%s\n"),
- be.strerror());
+ be.bstrerror());
}
if (stat != (ssize_t)block->binbuf) {
/*
* If we wrote something, truncate it and the header, then despool
*/
if (stat != -1) {
- if (ftruncate(dcr->spool_fd, lseek(dcr->spool_fd, (off_t)0, SEEK_CUR)
- - stat - sizeof(spool_hdr)) != 0) {
+#if defined(HAVE_WIN32)
+ boffset_t pos = _lseeki64(dcr->spool_fd, (__int64)0, SEEK_CUR);
+#else
+ boffset_t pos = lseek(dcr->spool_fd, (off_t)0, SEEK_CUR);
+#endif
+ if (ftruncate(dcr->spool_fd, pos - stat - sizeof(spool_hdr)) != 0) {
berrno be;
- Jmsg(dcr->jcr, M_FATAL, 0, _("Ftruncate spool file failed: ERR=%s\n"),
- be.strerror());
- return false;
+ Jmsg(dcr->jcr, M_ERROR, 0, _("Ftruncate spool file failed: ERR=%s\n"),
+ be.bstrerror());
+ /* Note, try continuing despite ftruncate problem */
}
}
if (!despool_data(dcr, false)) {
bool are_attributes_spooled(JCR *jcr)
{
- return jcr->spool_attributes && jcr->dir_bsock->spool_fd;
+ return jcr->spool_attributes && jcr->dir_bsock->m_spool_fd;
}
/*
char ec1[30];
if (are_attributes_spooled(jcr)) {
- if (fseeko(jcr->dir_bsock->spool_fd, 0, SEEK_END) != 0) {
+ 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.strerror());
+ be.bstrerror());
goto bail_out;
}
- size = ftello(jcr->dir_bsock->spool_fd);
+ 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.strerror());
+ be.bstrerror());
goto bail_out;
}
P(mutex);
}
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));
- bnet_despool_to_bsock(jcr->dir_bsock, update_attr_spool_size, size);
+ jcr->dir_bsock->despool(update_attr_spool_size, size);
return close_attr_spool_file(jcr, jcr->dir_bsock);
}
return true;
{
POOLMEM *name = get_pool_memory(PM_MESSAGE);
- make_unique_spool_filename(jcr, &name, bs->fd);
- bs->spool_fd = fopen(name, "w+");
- if (!bs->spool_fd) {
+ make_unique_spool_filename(jcr, &name, bs->m_fd);
+ bs->m_spool_fd = fopen(name, "w+b");
+ if (!bs->m_spool_fd) {
berrno be;
Jmsg(jcr, M_FATAL, 0, _("fopen attr spool file %s failed: ERR=%s\n"), name,
- be.strerror());
+ be.bstrerror());
free_pool_memory(name);
return false;
}
{
POOLMEM *name;
- if (!bs->spool_fd) {
+ if (!bs->m_spool_fd) {
return true;
}
name = get_pool_memory(PM_MESSAGE);
spool_stats.attr_jobs--;
spool_stats.total_attr_jobs++;
V(mutex);
- make_unique_spool_filename(jcr, &name, bs->fd);
- fclose(bs->spool_fd);
+ make_unique_spool_filename(jcr, &name, bs->m_fd);
+ fclose(bs->m_spool_fd);
unlink(name);
free_pool_memory(name);
- bs->spool_fd = NULL;
- bs->spool = false;
+ bs->m_spool_fd = NULL;
+ bs->clear_spooling();
return true;
}
projects / bacula / bacula / blobdiff