* This gives a bit extra plus room for the sparse addr if any.
* Note, we adjust the read size to be smaller so that the
* same output buffer can be used without growing it.
+ *
+ * The zlib compression workset is initialized here to minimise
+ * the "per file" load. The jcr member is only set, if the init was successful.
*/
jcr->compress_buf_size = jcr->buf_size + ((jcr->buf_size+999) / 1000) + 30;
jcr->compress_buf = get_memory(jcr->compress_buf_size);
+#ifdef HAVE_LIBZ
+ z_stream *pZlibStream = (z_stream*)malloc(sizeof(z_stream));
+ if (pZlibStream) {
+ pZlibStream->zalloc = Z_NULL;
+ pZlibStream->zfree = Z_NULL;
+ pZlibStream->opaque = Z_NULL;
+ pZlibStream->state = Z_NULL;
+
+ if (deflateInit(pZlibStream, Z_DEFAULT_COMPRESSION) == Z_OK)
+ jcr->pZLIB_compress_workset = pZlibStream;
+ else
+ free (pZlibStream);
+ }
+#endif
+
/* Create encryption session data and a cached, DER-encoded session data
* structure. We use a single session key for each backup, so we'll encode
* the session data only once. */
if (jcr->pki_encrypt) {
- size_t size = 0;
+ uint32_t size = 0;
/* Create per-job session encryption context */
jcr->pki_session = crypto_session_new(cipher, jcr->pki_recipients);
/* Get the session data size */
- if (crypto_session_encode(jcr->pki_session, NULL, &size) == false) {
+ if (crypto_session_encode(jcr->pki_session, (uint8_t *)0, &size) == false) {
Jmsg(jcr, M_FATAL, 0, _("An error occured while encrypting the stream.\n"));
return 0;
}
/* Allocate buffer */
- jcr->pki_session_encoded = malloc(size);
+ jcr->pki_session_encoded = (uint8_t *)malloc(size);
if (!jcr->pki_session_encoded) {
return 0;
}
free_pool_memory(jcr->compress_buf);
jcr->compress_buf = NULL;
}
+ if (jcr->pZLIB_compress_workset) {
+ /* Free the zlib stream */
+#ifdef HAVE_LIBZ
+ deflateEnd((z_stream *)jcr->pZLIB_compress_workset);
+#endif
+ free (jcr->pZLIB_compress_workset);
+ jcr->pZLIB_compress_workset = NULL;
+ }
if (jcr->crypto_buf) {
free_pool_memory(jcr->crypto_buf);
jcr->crypto_buf = NULL;
}
-
if (jcr->pki_session) {
crypto_session_free(jcr->pki_session);
}
jcr->num_files_examined--; /* correct file count */
return 1; /* not used */
case FT_NORECURSE:
- Jmsg(jcr, M_INFO, 1, _(" Recursion turned off. Will not descend into %s\n"),
- ff_pkt->fname);
+ Jmsg(jcr, M_INFO, 1, _(" Recursion turned off. Will not descend from %s into %s\n"),
+ ff_pkt->top_fname, ff_pkt->fname);
ff_pkt->type = FT_DIREND; /* Backup only the directory entry */
break;
case FT_NOFSCHG:
/* Suppress message for /dev filesystems */
if (strncmp(ff_pkt->fname, "/dev/", 5) != 0) {
- Jmsg(jcr, M_INFO, 1, _(" Filesystem change prohibited. Will not descend into %s\n"),
- ff_pkt->fname);
+ Jmsg(jcr, M_INFO, 1, _(" %s is a different filesystem. Will not descend from %s into %s\n"),
+ ff_pkt->fname, ff_pkt->top_fname, ff_pkt->fname);
}
ff_pkt->type = FT_DIREND; /* Backup only the directory entry */
break;
case FT_INVALIDFS:
- Jmsg(jcr, M_INFO, 1, _(" Disallowed filesystem. Will not descend into %s\n"),
- ff_pkt->fname);
+ Jmsg(jcr, M_INFO, 1, _(" Disallowed filesystem. Will not descend from %s into %s\n"),
+ ff_pkt->top_fname, ff_pkt->fname);
ff_pkt->type = FT_DIREND; /* Backup only the directory entry */
break;
+ case FT_INVALIDDT:
+ Jmsg(jcr, M_INFO, 1, _(" Disallowed drive type. Will not descend into %s\n"),
+ ff_pkt->fname);
+ break;
case FT_DIREND:
Dmsg1(130, "FT_DIREND: %s\n", ff_pkt->link);
break;
} else {
tid = NULL;
}
- if (bopen(&ff_pkt->bfd, ff_pkt->fname, O_RDONLY | O_BINARY, 0) < 0) {
+ int noatime = ff_pkt->flags & FO_NOATIME ? O_NOATIME : 0;
+ if (bopen(&ff_pkt->bfd, ff_pkt->fname, O_RDONLY | O_BINARY | noatime, 0) < 0) {
ff_pkt->ff_errno = errno;
berrno be;
Jmsg(jcr, M_NOTSAVED, 0, _(" Cannot open %s: ERR=%s.\n"), ff_pkt->fname,
bnet_fsend(sd, "%ld %d 0", jcr->JobFiles, STREAM_ENCRYPTED_SESSION_DATA);
/* Grow the bsock buffer to fit our message if necessary */
- if ((size_t) sizeof_pool_memory(sd->msg) < jcr->pki_session_encoded_size) {
+ if (sizeof_pool_memory(sd->msg) < jcr->pki_session_encoded_size) {
sd->msg = realloc_pool_memory(sd->msg, jcr->pki_session_encoded_size);
}
memcpy(sd->msg, ff_pkt->hfsinfo.fndrinfo, 32);
sd->msglen = 32;
if (digest) {
- crypto_digest_update(digest, sd->msg, sd->msglen);
+ crypto_digest_update(digest, (uint8_t *)sd->msg, sd->msglen);
}
if (signing_digest) {
- crypto_digest_update(signing_digest, sd->msg, sd->msglen);
+ crypto_digest_update(signing_digest, (uint8_t *)sd->msg, sd->msglen);
}
bnet_send(sd);
bnet_sig(sd, BNET_EOD);
/* Terminate the signing digest and send it to the Storage daemon */
if (signing_digest) {
SIGNATURE *sig;
- size_t size = 0;
- void *buf;
+ uint32_t size = 0;
+ uint8_t *buf;
if ((sig = crypto_sign_new()) == NULL) {
Jmsg(jcr, M_FATAL, 0, _("Failed to allocate memory for stream signature.\n"));
}
/* Allocate signature data buffer */
- buf = malloc(size);
+ buf = (uint8_t *)malloc(size);
if (!buf) {
crypto_sign_free(sig);
return 0;
Dmsg1(300, "bfiled>stored:header %s\n", sd->msg);
/* Grow the bsock buffer to fit our message if necessary */
- if ((size_t) sizeof_pool_memory(sd->msg) < size) {
+ if (sizeof_pool_memory(sd->msg) < (int32_t)size) {
sd->msg = realloc_pool_memory(sd->msg, size);
}
/* Terminate any digest and send it to Storage daemon and the Director */
if (digest) {
- char md[CRYPTO_DIGEST_MAX_SIZE];
- size_t size;
+ uint8_t md[CRYPTO_DIGEST_MAX_SIZE];
+ uint32_t size;
size = sizeof(md);
- if (crypto_digest_finalize(digest, &md, &size)) {
+ if (crypto_digest_finalize(digest, md, &size)) {
bnet_fsend(sd, "%ld %d 0", jcr->JobFiles, digest_stream);
Dmsg1(300, "bfiled>stored:header %s\n", sd->msg);
memcpy(sd->msg, md, size);
BSOCK *sd = jcr->store_bsock;
uint64_t fileAddr = 0; /* file address */
char *rbuf, *wbuf;
- int rsize = jcr->buf_size; /* read buffer size */
+ int32_t rsize = jcr->buf_size; /* read buffer size */
POOLMEM *msgsave;
CIPHER_CONTEXT *cipher_ctx = NULL; /* Quell bogus uninitialized warnings */
- const void *cipher_input;
- size_t cipher_input_len;
- size_t cipher_block_size;
- size_t encrypted_len;
+ const uint8_t *cipher_input;
+ uint32_t cipher_input_len;
+ uint32_t cipher_block_size;
+ uint32_t encrypted_len;
#ifdef FD_NO_SEND_TEST
return 1;
#endif
msgsave = sd->msg;
rbuf = sd->msg; /* read buffer */
wbuf = sd->msg; /* write buffer */
- cipher_input = rbuf; /* encrypt uncompressed data */
+ cipher_input = (uint8_t *)rbuf; /* encrypt uncompressed data */
Dmsg1(300, "Saving data, type=%d\n", ff_pkt->type);
#ifdef HAVE_LIBZ
uLong compress_len, max_compress_len = 0;
const Bytef *cbuf = NULL;
+ int zstat;
if (ff_pkt->flags & FO_GZIP) {
if (ff_pkt->flags & FO_SPARSE) {
max_compress_len = jcr->compress_buf_size; /* set max length */
}
wbuf = jcr->compress_buf; /* compressed output here */
- cipher_input = jcr->compress_buf; /* encrypt compressed data */
+ cipher_input = (uint8_t *)jcr->compress_buf; /* encrypt compressed data */
+
+ /*
+ * Only change zlib parameters if there is no pending operation.
+ * This should never happen as deflaterset is called after each
+ * deflate.
+ */
+
+ if (((z_stream*)jcr->pZLIB_compress_workset)->total_in == 0) {
+ /* set gzip compression level - must be done per file */
+ if ((zstat=deflateParams((z_stream*)jcr->pZLIB_compress_workset, ff_pkt->GZIP_level, Z_DEFAULT_STRATEGY)) != Z_OK) {
+ Jmsg(jcr, M_FATAL, 0, _("Compression deflateParams error: %d\n"), zstat);
+ set_jcr_job_status(jcr, JS_ErrorTerminated);
+ goto err;
+ }
+ }
}
#else
const uint32_t max_compress_len = 0;
* could be returned for the given read buffer size.
* (Using the larger of either rsize or max_compress_len)
*/
- jcr->crypto_buf = check_pool_memory_size(jcr->crypto_buf, (MAX((size_t) rsize, max_compress_len) + cipher_block_size - 1) / cipher_block_size * cipher_block_size);
+ jcr->crypto_buf = check_pool_memory_size(jcr->crypto_buf, (MAX(rsize, (int32_t)max_compress_len) + cipher_block_size - 1) / cipher_block_size * cipher_block_size);
wbuf = jcr->crypto_buf; /* Encrypted, possibly compressed output here. */
}
rsize = (rsize/512) * 512;
#endif
-#ifdef HAVE_LIBZ
- /*
- * instead of using compress2 for every block (with 256KB alloc + free per block)
- * we init the zlib once per file which leads to less pagefaults on large files (>64K)
- */
-
- z_stream zstream;
- zstream.zalloc = Z_NULL;
- zstream.zfree = Z_NULL;
- zstream.opaque = Z_NULL;
- zstream.state = Z_NULL;
-
- BOOL blibzInited = deflateInit(&zstream, ff_pkt->GZIP_level) == Z_OK;
-#endif
-
/*
* Read the file data
*/
/* Update checksum if requested */
if (digest) {
- crypto_digest_update(digest, rbuf, sd->msglen);
+ crypto_digest_update(digest, (uint8_t *)rbuf, sd->msglen);
}
/* Update signing digest if requested */
if (signing_digest) {
- crypto_digest_update(signing_digest, rbuf, sd->msglen);
+ crypto_digest_update(signing_digest, (uint8_t *)rbuf, sd->msglen);
}
#ifdef HAVE_LIBZ
/* Do compression if turned on */
- if (!sparseBlock && (ff_pkt->flags & FO_GZIP) && blibzInited) {
- int zstat;
+ if (!sparseBlock && (ff_pkt->flags & FO_GZIP) && jcr->pZLIB_compress_workset) {
compress_len = max_compress_len;
Dmsg4(400, "cbuf=0x%x len=%u rbuf=0x%x len=%u\n", cbuf, compress_len,
rbuf, sd->msglen);
- zstream.next_in = (Bytef *)rbuf;
- zstream.avail_in = sd->msglen;
- zstream.next_out = (Bytef *)cbuf;
- zstream.avail_out = compress_len;
+ ((z_stream*)jcr->pZLIB_compress_workset)->next_in = (Bytef *)rbuf;
+ ((z_stream*)jcr->pZLIB_compress_workset)->avail_in = sd->msglen;
+ ((z_stream*)jcr->pZLIB_compress_workset)->next_out = (Bytef *)cbuf;
+ ((z_stream*)jcr->pZLIB_compress_workset)->avail_out = compress_len;
- if ((zstat=deflate(&zstream, Z_FINISH)) != Z_STREAM_END) {
- Jmsg(jcr, M_FATAL, 0, _("Compression error: %d\n"), zstat);
+ if ((zstat=deflate((z_stream*)jcr->pZLIB_compress_workset, Z_FINISH)) != Z_STREAM_END) {
+ Jmsg(jcr, M_FATAL, 0, _("Compression deflate error: %d\n"), zstat);
+ set_jcr_job_status(jcr, JS_ErrorTerminated);
+ goto err;
+ }
+ compress_len = ((z_stream*)jcr->pZLIB_compress_workset)->total_out;
+ /* reset zlib stream to be able to begin from scratch again */
+ if ((zstat=deflateReset((z_stream*)jcr->pZLIB_compress_workset)) != Z_OK) {
+ Jmsg(jcr, M_FATAL, 0, _("Compression deflateReset error: %d\n"), zstat);
set_jcr_job_status(jcr, JS_ErrorTerminated);
goto err;
}
- compress_len = zstream.total_out;
- blibzInited = deflateReset(&zstream) == Z_OK;
Dmsg2(400, "compressed len=%d uncompressed len=%d\n",
compress_len, sd->msglen);
if (ff_pkt->flags & FO_ENCRYPT) {
/* Encrypt the input block */
- if (crypto_cipher_update(cipher_ctx, cipher_input, cipher_input_len, jcr->crypto_buf, &encrypted_len)) {
+ if (crypto_cipher_update(cipher_ctx, cipher_input, cipher_input_len, (uint8_t *)jcr->crypto_buf, &encrypted_len)) {
if (encrypted_len == 0) {
/* No full block of data available, read more data */
continue;
/* Send any remaining encrypted data + padding */
if (ff_pkt->flags & FO_ENCRYPT) {
- if (!crypto_cipher_finalize(cipher_ctx, jcr->crypto_buf, &encrypted_len)) {
+ if (!crypto_cipher_finalize(cipher_ctx, (uint8_t *)jcr->crypto_buf, &encrypted_len)) {
/* Padding failed. Shouldn't happen. */
Jmsg(jcr, M_FATAL, 0, _("Encryption padding error\n"));
goto err;
if (cipher_ctx) {
crypto_cipher_free(cipher_ctx);
}
-#ifdef HAVE_LIBZ
- /* Free the zlib stream */
- deflateEnd(&zstream);
-#endif
-
return 1;
err:
if (cipher_ctx) {
crypto_cipher_free(cipher_ctx);
}
-#ifdef HAVE_LIBZ
- /* Free the zlib stream */
- deflateEnd(&zstream);
-#endif
sd->msg = msgsave; /* restore bnet buffer */
sd->msglen = 0;
projects / bacula / bacula / blobdiff