#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. */
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 {
reserve_size = expected_num_chunk_entries *
get_chunk_entry_size(res_expected_size,
0 != (ctx->write_resource_flags &
- WIM_RESHDR_FLAG_PACKED_STREAMS));
+ WRITE_RESOURCE_FLAG_PACK_STREAMS));
if (ctx->write_resource_flags & WRITE_RESOURCE_FLAG_PACK_STREAMS)
reserve_size += sizeof(struct alt_chunk_table_header_disk);
memset(ctx->chunk_csizes, 0, reserve_size);
chunk_entry_size = get_chunk_entry_size(res_actual_size,
0 != (ctx->write_resource_flags &
- WIM_RESHDR_FLAG_PACKED_STREAMS));
+ WRITE_RESOURCE_FLAG_PACK_STREAMS));
typedef le64 __attribute__((may_alias)) aliased_le64_t;
typedef le32 __attribute__((may_alias)) aliased_le32_t;
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)
*
* @out_ctype
* Compression format to use to write the output streams, specified as one
- * of the WIMLIB_COMPRESSION_TYPE_* constants, excepting
- * WIMLIB_COMPRESSION_TYPE_INVALID but including
- * WIMLIB_COMPRESSION_TYPE_NONE.
+ * of the WIMLIB_COMPRESSION_TYPE_* constants.
+ * WIMLIB_COMPRESSION_TYPE_NONE is allowed.
*
* @out_chunk_size
* Chunk size to use to write the streams. It must be a valid chunk size
* 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.
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, "
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);
}
* @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 {
}
#if defined(HAVE_SYS_FILE_H) && defined(HAVE_FLOCK)
+
+/* Set advisory lock on WIM file (if not already done so) */
int
-lock_wim(WIMStruct *wim, int fd)
+lock_wim_for_append(WIMStruct *wim)
{
- int ret = 0;
- if (fd != -1 && !wim->wim_locked) {
- ret = flock(fd, LOCK_EX | LOCK_NB);
- if (ret != 0) {
- if (errno == EWOULDBLOCK) {
- ERROR("`%"TS"' is already being modified or has been "
- "mounted read-write\n"
- " by another process!", wim->filename);
- ret = WIMLIB_ERR_ALREADY_LOCKED;
- } else {
- WARNING_WITH_ERRNO("Failed to lock `%"TS"'",
- wim->filename);
- ret = 0;
- }
- } else {
- wim->wim_locked = 1;
- }
+ if (wim->locked_for_append)
+ return 0;
+ if (!flock(wim->in_fd.fd, LOCK_EX | LOCK_NB)) {
+ wim->locked_for_append = 1;
+ return 0;
+ }
+ if (errno != EWOULDBLOCK)
+ return 0;
+ return WIMLIB_ERR_ALREADY_LOCKED;
+}
+
+/* Remove advisory lock on WIM file (if present) */
+void
+unlock_wim_for_append(WIMStruct *wim)
+{
+ if (wim->locked_for_append) {
+ flock(wim->in_fd.fd, LOCK_UN);
+ wim->locked_for_append = 0;
}
- return ret;
}
#endif
*/
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;
if (ret)
goto out_restore_memory_hdr;
- ret = lock_wim(wim, wim->out_fd.fd);
+ ret = lock_wim_for_append(wim);
if (ret)
goto out_close_wim;
&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;
- wim->wim_locked = 0;
+ unlock_wim_for_append(wim);
return 0;
out_truncate:
out_restore_physical_hdr:
(void)write_wim_header_flags(hdr_save.flags, &wim->out_fd);
out_unlock_wim:
- wim->wim_locked = 0;
+ unlock_wim_for_append(wim);
out_close_wim:
(void)close_wim_writable(wim, write_flags);
out_restore_memory_hdr:
}
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);
}