#include "wimlib/error.h"
#include "wimlib/file_io.h"
#include "wimlib/header.h"
+#include "wimlib/inode.h"
#include "wimlib/integrity.h"
#include "wimlib/lookup_table.h"
#include "wimlib/metadata.h"
+#include "wimlib/progress.h"
#include "wimlib/resource.h"
#ifdef __WIN32__
# include "wimlib/win32.h" /* win32_rename_replacement() */
if (rspec->is_pipable != !!(write_resource_flags & WRITE_RESOURCE_FLAG_PIPABLE))
return false;
-
if (rspec->flags & WIM_RESHDR_FLAG_COMPRESSED) {
/* Normal compressed resource: Must use same compression type
* and chunk size. */
- return (rspec->wim->compression_type == out_ctype &&
- rspec->wim->chunk_size == out_chunk_size);
+ return (rspec->compression_type == out_ctype &&
+ rspec->chunk_size == out_chunk_size);
}
- /* XXX: For compatibility, we can't allow multiple packed resources per
- * WIM. */
-#if 0
if ((rspec->flags & WIM_RESHDR_FLAG_PACKED_STREAMS) &&
(write_resource_flags & WRITE_RESOURCE_FLAG_PACK_STREAMS))
{
/* Packed resource: Such resources may contain multiple streams,
* and in general only a subset of them need to be written. As
- * a heuristic, re-use the raw data if at least half the
+ * a heuristic, re-use the raw data if more than two-thirds the
* uncompressed size is being written. */
/* Note: packed resources contain a header that specifies the
if (res_stream->will_be_in_output_wim)
write_size += res_stream->size;
- return (write_size > rspec->uncompressed_size / 2);
+ return (write_size > rspec->uncompressed_size * 2 / 3);
}
-#endif
return false;
}
lte->out_res_offset_in_wim = rspec->offset_in_wim;
lte->out_res_size_in_wim = rspec->size_in_wim;
- /*lte->out_res_uncompressed_size = rspec->uncompressed_size;*/
+ lte->out_res_uncompressed_size = rspec->uncompressed_size;
} else {
wimlib_assert(!(lte->flags & WIM_RESHDR_FLAG_PACKED_STREAMS));
}
struct write_streams_progress_data {
- wimlib_progress_func_t progress_func;
+ wimlib_progress_func_t progfunc;
+ void *progctx;
union wimlib_progress_info progress;
uint64_t next_progress;
- WIMStruct *prev_wim_part;
};
-static void
+static int
do_write_streams_progress(struct write_streams_progress_data *progress_data,
struct wim_lookup_table_entry *cur_stream,
u64 complete_size,
bool discarded)
{
union wimlib_progress_info *progress = &progress_data->progress;
- bool new_wim_part;
+ int ret;
if (discarded) {
progress->write_streams.total_bytes -= complete_size;
progress->write_streams.completed_streams += complete_count;
}
- new_wim_part = false;
- if (cur_stream->resource_location == RESOURCE_IN_WIM &&
- cur_stream->rspec->wim != progress_data->prev_wim_part)
+ if (progress->write_streams.completed_bytes >= progress_data->next_progress)
{
- if (progress_data->prev_wim_part) {
- new_wim_part = true;
- progress->write_streams.completed_parts++;
- }
- progress_data->prev_wim_part = cur_stream->rspec->wim;
- }
+ ret = call_progress(progress_data->progfunc,
+ WIMLIB_PROGRESS_MSG_WRITE_STREAMS,
+ progress,
+ progress_data->progctx);
+ if (ret)
+ return ret;
- if (progress_data->progress_func
- && (progress->write_streams.completed_bytes >= progress_data->next_progress
- || new_wim_part))
- {
- progress_data->progress_func(WIMLIB_PROGRESS_MSG_WRITE_STREAMS,
- progress);
if (progress_data->next_progress == progress->write_streams.total_bytes) {
progress_data->next_progress = ~(uint64_t)0;
} else {
progress->write_streams.total_bytes / 100);
}
}
+ return 0;
}
struct write_streams_ctx {
hdr.chunk_size = cpu_to_le32(ctx->out_chunk_size);
hdr.compression_format = cpu_to_le32(ctx->out_ctype);
- BUILD_BUG_ON(WIMLIB_COMPRESSION_TYPE_LZX != 1);
- BUILD_BUG_ON(WIMLIB_COMPRESSION_TYPE_XPRESS != 2);
+ BUILD_BUG_ON(WIMLIB_COMPRESSION_TYPE_XPRESS != 1);
+ BUILD_BUG_ON(WIMLIB_COMPRESSION_TYPE_LZX != 2);
BUILD_BUG_ON(WIMLIB_COMPRESSION_TYPE_LZMS != 3);
ret = full_pwrite(ctx->out_fd, &hdr, sizeof(hdr),
/* Begin processing a stream for writing. */
static int
write_stream_begin_read(struct wim_lookup_table_entry *lte,
- bool is_partial_res, void *_ctx)
+ u32 flags, void *_ctx)
{
struct write_streams_ctx *ctx = _ctx;
int ret;
ctx->stream_was_duplicate = false;
if (ctx->lookup_table != NULL && lte->unhashed && !lte->unique_size) {
- wimlib_assert(!is_partial_res);
+ wimlib_assert(!(flags & BEGIN_STREAM_FLAG_PARTIAL_RESOURCE));
struct wim_lookup_table_entry *lte_new;
* duplicate stream in the former case. */
DEBUG("Discarding duplicate stream of "
"length %"PRIu64, lte->size);
- do_write_streams_progress(&ctx->progress_data,
- lte, lte->size,
- 1, true);
+ ret = do_write_streams_progress(&ctx->progress_data,
+ lte, lte->size,
+ 1, true);
list_del(<e->write_streams_list);
list_del(<e->lookup_table_list);
if (lte_new->will_be_in_output_wim)
if (ctx->write_resource_flags & WRITE_RESOURCE_FLAG_PACK_STREAMS)
ctx->cur_write_res_size -= lte->size;
free_lookup_table_entry(lte);
+ if (ret)
+ return ret;
return BEGIN_STREAM_STATUS_SKIP_STREAM;
} else {
/* The duplicate stream can validly be written,
}
}
- do_write_streams_progress(&ctx->progress_data, lte,
- completed_size, completed_stream_count,
- false);
-
- return 0;
+ return do_write_streams_progress(&ctx->progress_data, lte,
+ completed_size, completed_stream_count,
+ false);
error:
ERROR_WITH_ERRNO("Write error");
* compressed chunk. */
while (!ctx->compressor->submit_chunk(ctx->compressor, chunk, size)) {
const void *cchunk;
- unsigned csize;
- unsigned usize;
+ u32 csize;
+ u32 usize;
bool bret;
int ret;
ctx->progress_data.progress.write_streams.total_parts = total_parts;
ctx->progress_data.progress.write_streams.completed_parts = 0;
ctx->progress_data.next_progress = 0;
- ctx->progress_data.prev_wim_part = NULL;
}
/* Find streams in @stream_list that can be copied to the output WIM in raw form
- * rather than compressed. Delete these streams from @stream_list, and move one
- * per resource to @raw_copy_resources. Return the total uncompressed size of
- * the streams that need to be compressed. */
+ * rather than compressed. Delete these streams from @stream_list and move them
+ * to @raw_copy_streams. Return the total uncompressed size of the streams that
+ * need to be compressed. */
static u64
-find_raw_copy_resources(struct list_head *stream_list,
- int write_resource_flags,
- int out_ctype,
- u32 out_chunk_size,
- struct list_head *raw_copy_resources)
+find_raw_copy_streams(struct list_head *stream_list,
+ int write_resource_flags,
+ int out_ctype,
+ u32 out_chunk_size,
+ struct list_head *raw_copy_streams)
{
struct wim_lookup_table_entry *lte, *tmp;
u64 num_bytes_to_compress = 0;
- INIT_LIST_HEAD(raw_copy_resources);
+ INIT_LIST_HEAD(raw_copy_streams);
/* Initialize temporary raw_copy_ok flag. */
list_for_each_entry(lte, stream_list, write_streams_list)
if (lte->resource_location == RESOURCE_IN_WIM &&
lte->rspec->raw_copy_ok)
{
- list_del(<e->write_streams_list);
+ list_move_tail(<e->write_streams_list,
+ raw_copy_streams);
} else if (can_raw_copy(lte, write_resource_flags,
out_ctype, out_chunk_size))
{
lte->rspec->raw_copy_ok = 1;
list_move_tail(<e->write_streams_list,
- raw_copy_resources);
+ raw_copy_streams);
} else {
num_bytes_to_compress += lte->size;
}
return 0;
}
-/* Copy a list of raw compressed resources located other WIM file(s) to the WIM
- * file being written. */
+/* Copy a list of raw compressed resources located in other WIM file(s) to the
+ * WIM file being written. */
static int
-write_raw_copy_resources(struct list_head *raw_copy_resources,
+write_raw_copy_resources(struct list_head *raw_copy_streams,
struct filedes *out_fd,
struct write_streams_progress_data *progress_data)
{
struct wim_lookup_table_entry *lte;
int ret;
- list_for_each_entry(lte, raw_copy_resources, write_streams_list) {
- ret = write_raw_copy_resource(lte->rspec, out_fd);
+ list_for_each_entry(lte, raw_copy_streams, write_streams_list)
+ lte->rspec->raw_copy_ok = 1;
+
+ list_for_each_entry(lte, raw_copy_streams, write_streams_list) {
+ if (lte->rspec->raw_copy_ok) {
+ /* Write each packed resource only one time, no matter
+ * how many streams reference it. */
+ ret = write_raw_copy_resource(lte->rspec, out_fd);
+ if (ret)
+ return ret;
+ lte->rspec->raw_copy_ok = 0;
+ }
+ ret = do_write_streams_progress(progress_data, lte, lte->size,
+ 1, false);
if (ret)
return ret;
- do_write_streams_progress(progress_data, lte, lte->size,
- 1, false);
}
return 0;
}
finish_remaining_chunks(struct write_streams_ctx *ctx)
{
const void *cdata;
- unsigned csize;
- unsigned usize;
+ u32 csize;
+ u32 usize;
int ret;
if (ctx->compressor == NULL)
* Write a list of streams to the output WIM file.
*
* @stream_list
- * The list of streams to write, specifies a list of `struct
+ * The list of streams to write, specified by a list of `struct
* wim_lookup_table_entry's linked by the 'write_streams_list' member.
*
* @out_fd
*
* WRITE_RESOURCE_FLAG_RECOMPRESS:
* Force compression of all resources, even if they could otherwise
- * be re-used by caping the raw data, due to being located in a WIM
+ * be re-used by copying the raw data, due to being located in a WIM
* file with compatible compression parameters.
*
* WRITE_RESOURCE_FLAG_PIPABLE:
* Write the resources in the wimlib-specific pipable format, and
* furthermore do so in such a way that no seeking backwards in
- * @out_fd will be performed (so it may be a pipe, contrary to the
- * default behavior).
+ * @out_fd will be performed (so it may be a pipe).
*
* WRITE_RESOURCE_FLAG_PACK_STREAMS:
* Pack all the streams into a single resource rather than writing
- * them in separate resources. This format is only valid if the
- * WIM version number is WIM_VERSION_PACKED_STREAMS. This flag
- * currently may not be combined with WRITE_RESOURCE_FLAG_PIPABLE.
+ * them in separate resources. This flag is only valid if the WIM
+ * version number has been, or will be, set to
+ * WIM_VERSION_PACKED_STREAMS. This flag may not be combined with
+ * WRITE_RESOURCE_FLAG_PIPABLE.
*
* @out_ctype
* Compression format to use to write the output streams, specified as one
* no streams are hard-filtered or no streams are unhashed, this parameter
* can be NULL.
*
- * @progress_func
- * If non-NULL, a progress function that will be called periodically with
- * WIMLIB_PROGRESS_MSG_WRITE_STREAMS messages. Note that on-the-fly
- * deduplication of unhashed streams may result in the total bytes provided
- * in the progress data to decrease from one message to the next.
- *
* This function will write the streams in @stream_list to resources in
* consecutive positions in the output WIM file, or to a single packed resource
* if WRITE_RESOURCE_FLAG_PACK_STREAMS was specified in @write_resource_flags.
* In both cases, the @out_reshdr of the `struct wim_lookup_table_entry' for
* each stream written will be updated to specify its location, size, and flags
* in the output WIM. In the packed resource case,
- * WIM_RESHDR_FLAG_PACKED_STREAMS shall be set in the @flags field of the
- * @out_reshdr, and @out_res_offset_in_wim and @out_res_size_in_wim will also
- * be set to the offset and size, respectively, in the output WIM of the full
- * packed resource containing the corresponding stream.
+ * WIM_RESHDR_FLAG_PACKED_STREAMS will be set in the @flags field of each
+ * @out_reshdr, and furthermore @out_res_offset_in_wim and @out_res_size_in_wim
+ * of each @out_reshdr will be set to the offset and size, respectively, in the
+ * output WIM of the packed resource containing the corresponding stream.
*
* Each of the streams to write may be in any location supported by the
* resource-handling code (specifically, read_stream_list()), such as the
* contents of external file that has been logically added to the output WIM, or
- * a stream in another WIM file that has been imported, or even stream in the
+ * a stream in another WIM file that has been imported, or even a stream in the
* "same" WIM file of which a modified copy is being written. In the case that
* a stream is already in a WIM file and uses compatible compression parameters,
* by default this function will re-use the raw data instead of decompressing
* specified in @write_resource_flags, this is not done.
*
* As a further requirement, this function requires that the
- * @will_be_in_output_wim member be set on all streams in @stream_list as well
- * as any other streams not in @stream_list that will be in the output WIM file,
- * but not on any other streams in the output WIM's lookup table or sharing a
- * packed resource with a stream in @stream_list. Still furthermore, if
- * on-the-fly deduplication of streams is possible, then all streams in
+ * @will_be_in_output_wim member be set to 1 on all streams in @stream_list as
+ * well as any other streams not in @stream_list that will be in the output WIM
+ * file, but set to 0 on any other streams in the output WIM's lookup table or
+ * sharing a packed resource with a stream in @stream_list. Still furthermore,
+ * if on-the-fly deduplication of streams is possible, then all streams in
* @stream_list must also be linked by @lookup_table_list along with any other
* streams that have @will_be_in_output_wim set.
*
* This function handles on-the-fly deduplication of streams for which SHA1
- * message digests have not yet been calculated and it is therefore known
- * whether such streams are already in @stream_list or in the WIM's lookup table
- * at all. If @lookup_table is non-NULL, then each stream in @stream_list that
- * has @unhashed set but not @unique_size set is checksummed immediately before
- * it would otherwise be read for writing in order to determine if it is
- * identical to another stream already being written or one that would be
- * filtered out of the output WIM using stream_filtered() with the context
- * @filter_ctx. Each such duplicate stream will be removed from @stream_list, its
- * reference count transfered to the pre-existing duplicate stream, its memory
- * freed, and will not be written. Alternatively, if a stream in @stream_list
- * is a duplicate with any stream in @lookup_table that has not been marked for
- * writing or would not be hard-filtered, it is freed and the pre-existing
- * duplicate is written instead, taking ownership of the reference count and
- * slot in the @lookup_table_list.
- *
- * Returns 0 if all streams were written successfully (or did not need to be
- * written); otherwise a non-zero error code.
+ * message digests have not yet been calculated. Such streams may or may not
+ * need to be written. If @lookup_table is non-NULL, then each stream in
+ * @stream_list that has @unhashed set but not @unique_size set is checksummed
+ * immediately before it would otherwise be read for writing in order to
+ * determine if it is identical to another stream already being written or one
+ * that would be filtered out of the output WIM using stream_filtered() with the
+ * context @filter_ctx. Each such duplicate stream will be removed from
+ * @stream_list, its reference count transfered to the pre-existing duplicate
+ * stream, its memory freed, and will not be written. Alternatively, if a
+ * stream in @stream_list is a duplicate with any stream in @lookup_table that
+ * has not been marked for writing or would not be hard-filtered, it is freed
+ * and the pre-existing duplicate is written instead, taking ownership of the
+ * reference count and slot in the @lookup_table_list.
+ *
+ * Returns 0 if every stream was either written successfully or did not need to
+ * be written; otherwise returns a non-zero error code.
*/
static int
write_stream_list(struct list_head *stream_list,
unsigned num_threads,
struct wim_lookup_table *lookup_table,
struct filter_context *filter_ctx,
- wimlib_progress_func_t progress_func)
+ wimlib_progress_func_t progfunc,
+ void *progctx)
{
int ret;
struct write_streams_ctx ctx;
- struct list_head raw_copy_resources;
+ struct list_head raw_copy_streams;
wimlib_assert((write_resource_flags &
(WRITE_RESOURCE_FLAG_PACK_STREAMS |
compute_stream_list_stats(stream_list, &ctx);
- ctx.progress_data.progress_func = progress_func;
+ ctx.progress_data.progfunc = progfunc;
+ ctx.progress_data.progctx = progctx;
- ctx.num_bytes_to_compress = find_raw_copy_resources(stream_list,
- write_resource_flags,
- out_ctype,
- out_chunk_size,
- &raw_copy_resources);
+ ctx.num_bytes_to_compress = find_raw_copy_streams(stream_list,
+ write_resource_flags,
+ out_ctype,
+ out_chunk_size,
+ &raw_copy_streams);
DEBUG("Writing stream list "
"(offset = %"PRIu64", write_resource_flags=0x%08x, "
* to do compression. There are serial and parallel implementations of
* the chunk_compressor interface. We default to parallel using the
* specified number of threads, unless the upper bound on the number
- * bytes needing to be compressed is less 2000000 (heuristic value). */
+ * bytes needing to be compressed is less than a heuristic value. */
if (out_ctype != WIMLIB_COMPRESSION_TYPE_NONE) {
#ifdef ENABLE_MULTITHREADED_COMPRESSION
- if (ctx.num_bytes_to_compress >= 2000000) {
+ if (ctx.num_bytes_to_compress > max(2000000, out_chunk_size)) {
ret = new_parallel_chunk_compressor(out_ctype,
out_chunk_size,
num_threads, 0,
INIT_LIST_HEAD(&ctx.pending_streams);
INIT_LIST_HEAD(&ctx.pack_streams);
- if (ctx.progress_data.progress_func) {
- (*ctx.progress_data.progress_func)(WIMLIB_PROGRESS_MSG_WRITE_STREAMS,
- &ctx.progress_data.progress);
- }
+ ret = call_progress(ctx.progress_data.progfunc,
+ WIMLIB_PROGRESS_MSG_WRITE_STREAMS,
+ &ctx.progress_data.progress,
+ ctx.progress_data.progctx);
+ if (ret)
+ goto out_destroy_context;
if (write_resource_flags & WRITE_RESOURCE_FLAG_PACK_STREAMS) {
ret = begin_write_resource(&ctx, ctx.num_bytes_to_compress);
lte->out_reshdr.offset_in_wim = offset_in_res;
lte->out_res_offset_in_wim = reshdr.offset_in_wim;
lte->out_res_size_in_wim = reshdr.size_in_wim;
- /*lte->out_res_uncompressed_size = reshdr.uncompressed_size;*/
+ lte->out_res_uncompressed_size = reshdr.uncompressed_size;
offset_in_res += lte->size;
}
wimlib_assert(offset_in_res == reshdr.uncompressed_size);
out_write_raw_copy_resources:
/* Copy any compressed resources for which the raw data can be reused
* without decompression. */
- ret = write_raw_copy_resources(&raw_copy_resources, ctx.out_fd,
+ ret = write_raw_copy_resources(&raw_copy_streams, ctx.out_fd,
&ctx.progress_data);
out_destroy_context:
return ret;
}
+static int
+is_stream_packed(struct wim_lookup_table_entry *lte, void *_ignore)
+{
+ return lte_is_partial(lte);
+}
+
+static bool
+wim_has_packed_streams(WIMStruct *wim)
+{
+ return for_lookup_table_entry(wim->lookup_table, is_stream_packed, NULL);
+}
+
static int
wim_write_stream_list(WIMStruct *wim,
struct list_head *stream_list,
int write_flags,
unsigned num_threads,
- struct filter_context *filter_ctx,
- wimlib_progress_func_t progress_func)
+ struct filter_context *filter_ctx)
{
int out_ctype;
u32 out_chunk_size;
write_resource_flags = write_flags_to_resource_flags(write_flags);
+ /* wimlib v1.7.0: pack streams by default if the WIM version has been
+ * set to WIM_VERSION_PACKED_STREAMS and at least one stream in the
+ * WIM's lookup table is located in a packed resource (may be the same
+ * WIM, or a different one in the case of export). */
+ if (wim->hdr.wim_version == WIM_VERSION_PACKED_STREAMS &&
+ wim_has_packed_streams(wim))
+ {
+ write_resource_flags |= WRITE_RESOURCE_FLAG_PACK_STREAMS;
+ }
+
if (write_resource_flags & WRITE_RESOURCE_FLAG_PACK_STREAMS) {
out_chunk_size = wim->out_pack_chunk_size;
out_ctype = wim->out_pack_compression_type;
num_threads,
wim->lookup_table,
filter_ctx,
- progress_func);
+ wim->progfunc,
+ wim->progctx);
}
static int
1,
NULL,
NULL,
+ NULL,
NULL);
}
struct stream_size_table tab;
struct wim_lookup_table_entry *lte;
- ret = init_stream_size_table(&tab, lt->capacity);
+ ret = init_stream_size_table(&tab, 9001);
if (ret)
return ret;
* @stream_list_ret.
*
* SKIP_EXTERNAL_WIMS: Streams already present in a WIM file, but not
- * @wim, shall be be returned in neither @stream_list_ret nor
+ * @wim, shall be returned in neither @stream_list_ret nor
* @lookup_table_list_ret.
*
* @stream_list_ret
static int
write_wim_streams(WIMStruct *wim, int image, int write_flags,
unsigned num_threads,
- wimlib_progress_func_t progress_func,
struct list_head *stream_list_override,
struct list_head *lookup_table_list_ret)
{
stream_list,
write_flags,
num_threads,
- filter_ctx,
- progress_func);
+ filter_ctx);
}
static int
-write_wim_metadata_resources(WIMStruct *wim, int image, int write_flags,
- wimlib_progress_func_t progress_func)
+write_wim_metadata_resources(WIMStruct *wim, int image, int write_flags)
{
int ret;
int start_image;
DEBUG("Writing metadata resources (offset=%"PRIu64")",
wim->out_fd.offset);
- if (progress_func)
- progress_func(WIMLIB_PROGRESS_MSG_WRITE_METADATA_BEGIN, NULL);
+ ret = call_progress(wim->progfunc,
+ WIMLIB_PROGRESS_MSG_WRITE_METADATA_BEGIN,
+ NULL, wim->progctx);
+ if (ret)
+ return ret;
if (image == WIMLIB_ALL_IMAGES) {
start_image = 1;
if (ret)
return ret;
}
- if (progress_func)
- progress_func(WIMLIB_PROGRESS_MSG_WRITE_METADATA_END, NULL);
- return 0;
+
+ return call_progress(wim->progfunc,
+ WIMLIB_PROGRESS_MSG_WRITE_METADATA_END,
+ NULL, wim->progctx);
}
static int
*/
static int
finish_write(WIMStruct *wim, int image, int write_flags,
- wimlib_progress_func_t progress_func,
struct list_head *lookup_table_list)
{
int ret;
ret = write_integrity_table(wim,
new_lookup_table_end,
- old_lookup_table_end,
- progress_func);
+ old_lookup_table_end);
if (ret)
return ret;
} else {
*/
static int
write_pipable_wim(WIMStruct *wim, int image, int write_flags,
- unsigned num_threads, wimlib_progress_func_t progress_func,
+ unsigned num_threads,
struct list_head *stream_list_override,
struct list_head *lookup_table_list_ret)
{
/* Write metadata resources for the image(s) being included in the
* output WIM. */
- ret = write_wim_metadata_resources(wim, image, write_flags,
- progress_func);
+ ret = write_wim_metadata_resources(wim, image, write_flags);
if (ret)
return ret;
/* Write streams needed for the image(s) being included in the output
* WIM, or streams needed for the split WIM part. */
return write_wim_streams(wim, image, write_flags, num_threads,
- progress_func, stream_list_override,
- lookup_table_list_ret);
+ stream_list_override, lookup_table_list_ret);
/* The lookup table, XML data, and header at end are handled by
* finish_write(). */
int image,
int write_flags,
unsigned num_threads,
- wimlib_progress_func_t progress_func,
unsigned part_number,
unsigned total_parts,
struct list_head *stream_list_override,
if (write_flags & WIMLIB_WRITE_FLAG_CHECK_INTEGRITY)
DEBUG("\tCHECK_INTEGRITY");
- if (write_flags & WIMLIB_WRITE_FLAG_REBUILD)
- DEBUG("\tREBUILD");
+ if (write_flags & WIMLIB_WRITE_FLAG_NO_CHECK_INTEGRITY)
+ DEBUG("\tNO_CHECK_INTEGRITY");
+
+ if (write_flags & WIMLIB_WRITE_FLAG_PIPABLE)
+ DEBUG("\tPIPABLE");
+
+ if (write_flags & WIMLIB_WRITE_FLAG_NOT_PIPABLE)
+ DEBUG("\tNOT_PIPABLE");
if (write_flags & WIMLIB_WRITE_FLAG_RECOMPRESS)
DEBUG("\tRECOMPRESS");
if (write_flags & WIMLIB_WRITE_FLAG_FSYNC)
DEBUG("\tFSYNC");
+ if (write_flags & WIMLIB_WRITE_FLAG_REBUILD)
+ DEBUG("\tREBUILD");
+
if (write_flags & WIMLIB_WRITE_FLAG_SOFT_DELETE)
- DEBUG("\tFSYNC");
+ DEBUG("\tSOFT_DELETE");
if (write_flags & WIMLIB_WRITE_FLAG_IGNORE_READONLY_FLAG)
DEBUG("\tIGNORE_READONLY_FLAG");
- if (write_flags & WIMLIB_WRITE_FLAG_PIPABLE)
- DEBUG("\tPIPABLE");
+ if (write_flags & WIMLIB_WRITE_FLAG_SKIP_EXTERNAL_WIMS)
+ DEBUG("\tSKIP_EXTERNAL_WIMS");
- if (write_flags & WIMLIB_WRITE_FLAG_NOT_PIPABLE)
- DEBUG("\tNOT_PIPABLE");
+ if (write_flags & WIMLIB_WRITE_FLAG_STREAMS_OK)
+ DEBUG("\tSTREAMS_OK");
+
+ if (write_flags & WIMLIB_WRITE_FLAG_RETAIN_GUID)
+ DEBUG("\tRETAIN_GUID");
if (write_flags & WIMLIB_WRITE_FLAG_PACK_STREAMS)
DEBUG("\tPACK_STREAMS");
DEBUG("Number of threads: autodetect");
else
DEBUG("Number of threads: %u", num_threads);
- DEBUG("Progress function: %s", (progress_func ? "yes" : "no"));
+ DEBUG("Progress function: %s", (wim->progfunc ? "yes" : "no"));
DEBUG("Stream list: %s", (stream_list_override ? "specified" : "autodetect"));
- DEBUG("GUID: %s", ((guid || wim->guid_set_explicitly) ?
- "specified" : "generate new"));
+ DEBUG("GUID: %s", (write_flags &
+ WIMLIB_WRITE_FLAG_RETAIN_GUID) ? "retain"
+ : guid ? "explicit" : "generate new");
/* Internally, this is always called with a valid part number and total
* parts. */
/* Set chunk size if different. */
wim->hdr.chunk_size = wim->out_chunk_size;
- /* Use GUID if specified; otherwise generate a new one. */
- if (guid)
- memcpy(wim->hdr.guid, guid, WIMLIB_GUID_LEN);
- else if (!wim->guid_set_explicitly)
- randomize_byte_array(wim->hdr.guid, WIMLIB_GUID_LEN);
+ /* Set GUID. */
+ if (!(write_flags & WIMLIB_WRITE_FLAG_RETAIN_GUID)) {
+ if (guid)
+ memcpy(wim->hdr.guid, guid, WIMLIB_GUID_LEN);
+ else
+ randomize_byte_array(wim->hdr.guid, WIMLIB_GUID_LEN);
+ }
/* Clear references to resources that have not been written yet. */
zero_reshdr(&wim->hdr.lookup_table_reshdr);
if (!(write_flags & WIMLIB_WRITE_FLAG_PIPABLE)) {
/* Default case: create a normal (non-pipable) WIM. */
ret = write_wim_streams(wim, image, write_flags, num_threads,
- progress_func, stream_list_override,
+ stream_list_override,
&lookup_table_list);
if (ret)
goto out_restore_hdr;
- ret = write_wim_metadata_resources(wim, image, write_flags,
- progress_func);
+ ret = write_wim_metadata_resources(wim, image, write_flags);
if (ret)
goto out_restore_hdr;
} else {
/* Non-default case: create pipable WIM. */
ret = write_pipable_wim(wim, image, write_flags, num_threads,
- progress_func, stream_list_override,
+ stream_list_override,
&lookup_table_list);
if (ret)
goto out_restore_hdr;
/* Write lookup table, XML data, and (optional) integrity table. */
- ret = finish_write(wim, image, write_flags, progress_func,
- &lookup_table_list);
+ ret = finish_write(wim, image, write_flags, &lookup_table_list);
out_restore_hdr:
memcpy(&wim->hdr, &hdr_save, sizeof(struct wim_header));
(void)close_wim_writable(wim, write_flags);
/* Write a standalone WIM to a file or file descriptor. */
static int
write_standalone_wim(WIMStruct *wim, const void *path_or_fd,
- int image, int write_flags, unsigned num_threads,
- wimlib_progress_func_t progress_func)
+ int image, int write_flags, unsigned num_threads)
{
return write_wim_part(wim, path_or_fd, image, write_flags,
- num_threads, progress_func, 1, 1, NULL, NULL);
+ num_threads, 1, 1, NULL, NULL);
}
/* API function documented in wimlib.h */
WIMLIBAPI int
wimlib_write(WIMStruct *wim, const tchar *path,
- int image, int write_flags, unsigned num_threads,
- wimlib_progress_func_t progress_func)
+ int image, int write_flags, unsigned num_threads)
{
- if (!path)
+ if (write_flags & ~WIMLIB_WRITE_MASK_PUBLIC)
return WIMLIB_ERR_INVALID_PARAM;
- write_flags &= WIMLIB_WRITE_MASK_PUBLIC;
+ if (path == NULL || path[0] == T('\0'))
+ return WIMLIB_ERR_INVALID_PARAM;
- return write_standalone_wim(wim, path, image, write_flags,
- num_threads, progress_func);
+ return write_standalone_wim(wim, path, image, write_flags, num_threads);
}
/* API function documented in wimlib.h */
WIMLIBAPI int
wimlib_write_to_fd(WIMStruct *wim, int fd,
- int image, int write_flags, unsigned num_threads,
- wimlib_progress_func_t progress_func)
+ int image, int write_flags, unsigned num_threads)
{
+ if (write_flags & ~WIMLIB_WRITE_MASK_PUBLIC)
+ return WIMLIB_ERR_INVALID_PARAM;
+
if (fd < 0)
return WIMLIB_ERR_INVALID_PARAM;
- write_flags &= WIMLIB_WRITE_MASK_PUBLIC;
write_flags |= WIMLIB_WRITE_FLAG_FILE_DESCRIPTOR;
- return write_standalone_wim(wim, &fd, image, write_flags,
- num_threads, progress_func);
+ return write_standalone_wim(wim, &fd, image, write_flags, num_threads);
}
static bool
* Integrity table (optional) (variable size)
*
* This method allows an image to be appended to a large WIM very quickly, and
- * is is crash-safe except in the case of write re-ordering, but the
+ * is crash-safe except in the case of write re-ordering, but the
* disadvantage is that a small hole is left in the WIM where the old lookup
* table, xml data, and integrity table were. (These usually only take up a
* small amount of space compared to the streams, however.)
*/
static int
-overwrite_wim_inplace(WIMStruct *wim, int write_flags,
- unsigned num_threads,
- wimlib_progress_func_t progress_func)
+overwrite_wim_inplace(WIMStruct *wim, int write_flags, unsigned num_threads)
{
int ret;
off_t old_wim_end;
&stream_list,
write_flags,
num_threads,
- &filter_ctx,
- progress_func);
+ &filter_ctx);
if (ret)
goto out_truncate;
- ret = write_wim_metadata_resources(wim, WIMLIB_ALL_IMAGES,
- write_flags, progress_func);
+ ret = write_wim_metadata_resources(wim, WIMLIB_ALL_IMAGES, write_flags);
if (ret)
goto out_truncate;
write_flags |= WIMLIB_WRITE_FLAG_REUSE_INTEGRITY_TABLE;
ret = finish_write(wim, WIMLIB_ALL_IMAGES, write_flags,
- progress_func, &lookup_table_list);
+ &lookup_table_list);
if (ret)
goto out_truncate;
}
static int
-overwrite_wim_via_tmpfile(WIMStruct *wim, int write_flags,
- unsigned num_threads,
- wimlib_progress_func_t progress_func)
+overwrite_wim_via_tmpfile(WIMStruct *wim, int write_flags, unsigned num_threads)
{
size_t wim_name_len;
int ret;
tmpfile[wim_name_len + 9] = T('\0');
ret = wimlib_write(wim, tmpfile, WIMLIB_ALL_IMAGES,
- write_flags | WIMLIB_WRITE_FLAG_FSYNC,
- num_threads, progress_func);
+ write_flags |
+ WIMLIB_WRITE_FLAG_FSYNC |
+ WIMLIB_WRITE_FLAG_RETAIN_GUID,
+ num_threads);
if (ret) {
tunlink(tmpfile);
return ret;
}
- close_wim(wim);
+ if (filedes_valid(&wim->in_fd)) {
+ filedes_close(&wim->in_fd);
+ filedes_invalidate(&wim->in_fd);
+ }
/* Rename the new WIM file to the original WIM file. Note: on Windows
* this actually calls win32_rename_replacement(), not _wrename(), so
return WIMLIB_ERR_RENAME;
}
- if (progress_func) {
- union wimlib_progress_info progress;
- progress.rename.from = tmpfile;
- progress.rename.to = wim->filename;
- progress_func(WIMLIB_PROGRESS_MSG_RENAME, &progress);
- }
- return 0;
+ union wimlib_progress_info progress;
+ progress.rename.from = tmpfile;
+ progress.rename.to = wim->filename;
+ return call_progress(wim->progfunc, WIMLIB_PROGRESS_MSG_RENAME,
+ &progress, wim->progctx);
}
/* Determine if the specified WIM file may be updated by appending in-place
if (wim_is_pipable(wim) || (write_flags & WIMLIB_WRITE_FLAG_PIPABLE))
return false;
- /* wimlib allows multiple packs in a single WIM, but they don't seem to
- * be compatible with WIMGAPI, so force all streams to be repacked if
- * the WIM already may have contained a pack and PACK_STREAMS was
- * requested. */
- if (write_flags & WIMLIB_WRITE_FLAG_PACK_STREAMS &&
- wim->hdr.wim_version == WIM_VERSION_PACKED_STREAMS)
- return false;
-
/* The default compression type and compression chunk size selected for
* the output WIM must be the same as those currently used for the WIM.
*/
/* API function documented in wimlib.h */
WIMLIBAPI int
-wimlib_overwrite(WIMStruct *wim, int write_flags,
- unsigned num_threads,
- wimlib_progress_func_t progress_func)
+wimlib_overwrite(WIMStruct *wim, int write_flags, unsigned num_threads)
{
int ret;
u32 orig_hdr_flags;
- write_flags &= WIMLIB_WRITE_MASK_PUBLIC;
-
- if (write_flags & WIMLIB_WRITE_FLAG_FILE_DESCRIPTOR)
+ if (write_flags & ~WIMLIB_WRITE_MASK_PUBLIC)
return WIMLIB_ERR_INVALID_PARAM;
if (!wim->filename)
return ret;
if (can_overwrite_wim_inplace(wim, write_flags)) {
- ret = overwrite_wim_inplace(wim, write_flags, num_threads,
- progress_func);
+ ret = overwrite_wim_inplace(wim, write_flags, num_threads);
if (ret != WIMLIB_ERR_RESOURCE_ORDER)
return ret;
WARNING("Falling back to re-building entire WIM");
}
- return overwrite_wim_via_tmpfile(wim, write_flags, num_threads,
- progress_func);
+ return overwrite_wim_via_tmpfile(wim, write_flags, num_threads);
}
git://wimlib.net / wimlib / blobdiff