X-Git-Url: https://wimlib.net/git/?p=wimlib;a=blobdiff_plain;f=src%2Fwrite.c;h=f3c12ffe4cbc8ffacced2e635ff3a352c773a21f;hp=7e597e18bf2410526a3225bb47946834fecd1f35;hb=f18b7fc3361c4daac0ddd104af65a8eff8466fec;hpb=0ecf748e0db6bb4d9a02388b4ea925d8742848b1 diff --git a/src/write.c b/src/write.c index 7e597e18..f3c12ffe 100644 --- a/src/write.c +++ b/src/write.c @@ -6,22 +6,20 @@ */ /* - * Copyright (C) 2012, 2013 Eric Biggers + * Copyright (C) 2012, 2013, 2014 Eric Biggers * - * This file is part of wimlib, a library for working with WIM files. + * This file is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the Free + * Software Foundation; either version 3 of the License, or (at your option) any + * later version. * - * wimlib is free software; you can redistribute it and/or modify it under the - * terms of the GNU General Public License as published by the Free - * Software Foundation; either version 3 of the License, or (at your option) - * any later version. - * - * wimlib 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 + * This file 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 Lesser General Public License for more * details. * - * You should have received a copy of the GNU General Public License - * along with wimlib; if not, see http://www.gnu.org/licenses/. + * You should have received a copy of the GNU Lesser General Public License + * along with this file; if not, see http://www.gnu.org/licenses/. */ #ifdef HAVE_CONFIG_H @@ -34,14 +32,24 @@ # include #endif +#include +#include +#include +#include + +#include "wimlib/alloca.h" +#include "wimlib/assert.h" #include "wimlib/chunk_compressor.h" #include "wimlib/endianness.h" #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/paths.h" +#include "wimlib/progress.h" #include "wimlib/resource.h" #ifdef __WIN32__ # include "wimlib/win32.h" /* win32_rename_replacement() */ @@ -49,19 +57,12 @@ #include "wimlib/write.h" #include "wimlib/xml.h" -#include -#include -#include -#include - -#ifdef HAVE_ALLOCA_H -# include -#endif /* wimlib internal flags used when writing resources. */ #define WRITE_RESOURCE_FLAG_RECOMPRESS 0x00000001 #define WRITE_RESOURCE_FLAG_PIPABLE 0x00000002 #define WRITE_RESOURCE_FLAG_PACK_STREAMS 0x00000004 +#define WRITE_RESOURCE_FLAG_SEND_DONE_WITH_FILE 0x00000008 static inline int write_flags_to_resource_flags(int write_flags) @@ -74,6 +75,8 @@ write_flags_to_resource_flags(int write_flags) write_resource_flags |= WRITE_RESOURCE_FLAG_PIPABLE; if (write_flags & WIMLIB_WRITE_FLAG_PACK_STREAMS) write_resource_flags |= WRITE_RESOURCE_FLAG_PACK_STREAMS; + if (write_flags & WIMLIB_WRITE_FLAG_SEND_DONE_WITH_FILE_MESSAGES) + write_resource_flags |= WRITE_RESOURCE_FLAG_SEND_DONE_WITH_FILE; return write_resource_flags; } @@ -96,12 +99,15 @@ static int stream_filtered(const struct wim_lookup_table_entry *lte, const struct filter_context *ctx) { - int write_flags = ctx->write_flags; - WIMStruct *wim = ctx->wim; + int write_flags; + WIMStruct *wim; if (ctx == NULL) return 0; + write_flags = ctx->write_flags; + wim = ctx->wim; + if (write_flags & WIMLIB_WRITE_FLAG_OVERWRITE && lte->resource_location == RESOURCE_IN_WIM && lte->rspec->wim == wim) @@ -168,23 +174,19 @@ can_raw_copy(const struct wim_lookup_table_entry *lte, 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 @@ -199,9 +201,8 @@ can_raw_copy(const struct wim_lookup_table_entry *lte, 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; } @@ -233,7 +234,7 @@ stream_set_out_reshdr_for_reuse(struct wim_lookup_table_entry *lte) 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)); @@ -274,21 +275,20 @@ write_pwm_stream_header(const struct wim_lookup_table_entry *lte, } 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, u32 complete_count, 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; @@ -303,32 +303,43 @@ do_write_streams_progress(struct write_streams_progress_data *progress_data, 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 { + /* Handle rate-limiting of messages */ + + /* Send new message as soon as another 1/128 of the + * total has been written. (Arbitrary number.) */ progress_data->next_progress = - min(progress->write_streams.total_bytes, - progress->write_streams.completed_bytes + - progress->write_streams.total_bytes / 100); + progress->write_streams.completed_bytes + + progress->write_streams.total_bytes / 128; + + /* ... Unless that would be more than 5000000 bytes, in + * which case send the next after the next 5000000 + * bytes. (Another arbitrary number.) */ + if (progress->write_streams.completed_bytes + 5000000 < + progress_data->next_progress) + progress_data->next_progress = + progress->write_streams.completed_bytes + 5000000; + + /* ... But always send a message as soon as we're + * completely done. */ + if (progress->write_streams.total_bytes < + progress_data->next_progress) + progress_data->next_progress = + progress->write_streams.total_bytes; } } + return 0; } struct write_streams_ctx { @@ -376,12 +387,6 @@ struct write_streams_ctx { * @pending_streams only when writing a packed resource. */ struct list_head pack_streams; - /* Set to true if the stream currently being read was a duplicate, and - * therefore the corresponding stream entry needs to be freed once the - * read finishes. (In this case we add the duplicate entry to - * pending_streams rather than the entry being read.) */ - bool stream_was_duplicate; - /* Current uncompressed offset in the stream being read. */ u64 cur_read_stream_offset; @@ -409,16 +414,6 @@ struct write_streams_ctx { u64 chunks_start_offset; }; -static u64 -get_chunk_entry_size(u64 res_size, int write_resource_flags) -{ - if (res_size <= UINT32_MAX || - (write_resource_flags & WIM_RESHDR_FLAG_PACKED_STREAMS)) - return 4; - else - return 8; -} - /* Reserve space for the chunk table and prepare to accumulate the chunk table * in memory. */ static int @@ -470,7 +465,8 @@ begin_chunk_table(struct write_streams_ctx *ctx, u64 res_expected_size) * are unknown. */ reserve_size = expected_num_chunk_entries * get_chunk_entry_size(res_expected_size, - ctx->write_resource_flags); + 0 != (ctx->write_resource_flags & + 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); @@ -517,10 +513,11 @@ end_chunk_table(struct write_streams_ctx *ctx, u64 res_actual_size, actual_num_chunk_entries--; chunk_entry_size = get_chunk_entry_size(res_actual_size, - ctx->write_resource_flags); + 0 != (ctx->write_resource_flags & + WRITE_RESOURCE_FLAG_PACK_STREAMS)); - typedef le64 __attribute__((may_alias)) aliased_le64_t; - typedef le32 __attribute__((may_alias)) aliased_le32_t; + typedef le64 _may_alias_attribute aliased_le64_t; + typedef le32 _may_alias_attribute aliased_le32_t; if (chunk_entry_size == 4) { aliased_le32_t *entries = (aliased_le32_t*)ctx->chunk_csizes; @@ -559,7 +556,7 @@ end_chunk_table(struct write_streams_ctx *ctx, u64 res_actual_size, if (ctx->write_resource_flags & WRITE_RESOURCE_FLAG_PIPABLE) { ret = full_write(ctx->out_fd, ctx->chunk_csizes, chunk_table_size); if (ret) - goto error; + goto write_error; res_end_offset = ctx->out_fd->offset; res_start_offset = ctx->chunks_start_offset; } else { @@ -576,14 +573,14 @@ end_chunk_table(struct write_streams_ctx *ctx, u64 res_actual_size, 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), chunk_table_offset - sizeof(hdr)); if (ret) - goto error; + goto write_error; res_start_offset = chunk_table_offset - sizeof(hdr); } else { res_start_offset = chunk_table_offset; @@ -592,7 +589,7 @@ end_chunk_table(struct write_streams_ctx *ctx, u64 res_actual_size, ret = full_pwrite(ctx->out_fd, ctx->chunk_csizes, chunk_table_size, chunk_table_offset); if (ret) - goto error; + goto write_error; } *res_start_offset_ret = res_start_offset; @@ -600,7 +597,7 @@ end_chunk_table(struct write_streams_ctx *ctx, u64 res_actual_size, return 0; -error: +write_error: ERROR_WITH_ERRNO("Write error"); return ret; } @@ -636,10 +633,96 @@ end_write_resource(struct write_streams_ctx *ctx, struct wim_reshdr *out_reshdr) return 0; } +/* No more data streams of the file at @path are needed. */ +static int +done_with_file(const tchar *path, wimlib_progress_func_t progfunc, void *progctx) +{ + union wimlib_progress_info info; + + info.done_with_file.path_to_file = path; + + return call_progress(progfunc, WIMLIB_PROGRESS_MSG_DONE_WITH_FILE, + &info, progctx); +} + +static inline bool +is_file_stream(const struct wim_lookup_table_entry *lte) +{ + return lte->resource_location == RESOURCE_IN_FILE_ON_DISK +#ifdef __WIN32__ + || lte->resource_location == RESOURCE_IN_WINNT_FILE_ON_DISK + || lte->resource_location == RESOURCE_WIN32_ENCRYPTED +#endif + ; +} + +static int +do_done_with_stream(struct wim_lookup_table_entry *lte, + wimlib_progress_func_t progfunc, void *progctx) +{ + int ret; + struct wim_inode *inode; + + if (!lte->may_send_done_with_file) + return 0; + + inode = lte->file_inode; + + wimlib_assert(inode != NULL); + wimlib_assert(inode->num_remaining_streams > 0); + if (--inode->num_remaining_streams > 0) + return 0; + +#ifdef __WIN32__ + /* XXX: This logic really should be somewhere else. */ + + /* We want the path to the file, but lte->file_on_disk might actually + * refer to a named data stream. Temporarily strip the named data + * stream from the path. */ + wchar_t *p_colon = NULL; + wchar_t *p_question_mark = NULL; + const wchar_t *p_stream_name; + + p_stream_name = path_stream_name(lte->file_on_disk); + if (unlikely(p_stream_name)) { + p_colon = (wchar_t *)(p_stream_name - 1); + wimlib_assert(*p_colon == L':'); + *p_colon = L'\0'; + } + + /* We also should use a fake Win32 path instead of a NT path */ + if (!wcsncmp(lte->file_on_disk, L"\\??\\", 4)) { + p_question_mark = <e->file_on_disk[1]; + *p_question_mark = L'\\'; + } +#endif + + ret = done_with_file(lte->file_on_disk, progfunc, progctx); + +#ifdef __WIN32__ + if (p_colon) + *p_colon = L':'; + if (p_question_mark) + *p_question_mark = L'?'; +#endif + return ret; +} + +/* Handle WIMLIB_WRITE_FLAG_SEND_DONE_WITH_FILE_MESSAGES mode. */ +static inline int +done_with_stream(struct wim_lookup_table_entry *lte, + struct write_streams_ctx *ctx) +{ + if (likely(!(ctx->write_resource_flags & + WRITE_RESOURCE_FLAG_SEND_DONE_WITH_FILE))) + return 0; + return do_done_with_stream(lte, ctx->progress_data.progfunc, + ctx->progress_data.progctx); +} + /* Begin processing a stream for writing. */ static int -write_stream_begin_read(struct wim_lookup_table_entry *lte, - bool is_partial_res, void *_ctx) +write_stream_begin_read(struct wim_lookup_table_entry *lte, void *_ctx) { struct write_streams_ctx *ctx = _ctx; int ret; @@ -660,11 +743,8 @@ write_stream_begin_read(struct wim_lookup_table_entry *lte, * still provide the data again to write_stream_process_chunk(). This * is okay because an unhashed stream cannot be in a WIM resource, which * might be costly to decompress. */ - ctx->stream_was_duplicate = false; if (ctx->lookup_table != NULL && lte->unhashed && !lte->unique_size) { - wimlib_assert(!is_partial_res); - struct wim_lookup_table_entry *lte_new; ret = hash_unhashed_stream(lte, ctx->lookup_table, <e_new); @@ -684,16 +764,20 @@ write_stream_begin_read(struct wim_lookup_table_entry *lte, * 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->size, + 1, true); list_del(<e->write_streams_list); list_del(<e->lookup_table_list); if (lte_new->will_be_in_output_wim) lte_new->out_refcnt += lte->out_refcnt; if (ctx->write_resource_flags & WRITE_RESOURCE_FLAG_PACK_STREAMS) ctx->cur_write_res_size -= lte->size; + if (!ret) + ret = done_with_stream(lte, ctx); free_lookup_table_entry(lte); + if (ret) + return ret; return BEGIN_STREAM_STATUS_SKIP_STREAM; } else { /* The duplicate stream can validly be written, @@ -708,9 +792,10 @@ write_stream_begin_read(struct wim_lookup_table_entry *lte, <e_new->write_streams_list); list_replace(<e->lookup_table_list, <e_new->lookup_table_list); + lte->will_be_in_output_wim = 0; lte_new->out_refcnt = lte->out_refcnt; lte_new->will_be_in_output_wim = 1; - ctx->stream_was_duplicate = true; + lte_new->may_send_done_with_file = 0; lte = lte_new; } } @@ -767,6 +852,73 @@ write_stream_uncompressed(struct wim_lookup_table_entry *lte, return 0; } +/* Returns true if the specified stream should be truncated from the WIM file + * and re-written as uncompressed. lte->out_reshdr must be filled in from the + * initial write of the stream. */ +static bool +should_rewrite_stream_uncompressed(const struct write_streams_ctx *ctx, + const struct wim_lookup_table_entry *lte) +{ + /* If the compressed data is smaller than the uncompressed data, prefer + * the compressed data. */ + if (lte->out_reshdr.size_in_wim < lte->out_reshdr.uncompressed_size) + return false; + + /* If we're not actually writing compressed data, then there's no need + * for re-writing. */ + if (!ctx->compressor) + return false; + + /* If writing a pipable WIM, everything we write to the output is final + * (it might actually be a pipe!). */ + if (ctx->write_resource_flags & WRITE_RESOURCE_FLAG_PIPABLE) + return false; + + /* If the stream that would need to be re-read is located in a solid + * block in another WIM file, then re-reading it would be costly. So + * don't do it. + * + * Exception: if the compressed size happens to be *exactly* the same as + * the uncompressed size, then the stream *must* be written uncompressed + * in order to remain compatible with the Windows Overlay Filesystem + * Filter Driver (WOF). + * + * TODO: we are currently assuming that the optimization for + * single-chunk resources in maybe_rewrite_stream_uncompressed() + * prevents this case from being triggered too often. To fully prevent + * excessive decompressions in degenerate cases, we really should + * obtain the uncompressed data by decompressing the compressed data we + * wrote to the output file. + */ + if ((lte->flags & WIM_RESHDR_FLAG_PACKED_STREAMS) && + (lte->out_reshdr.size_in_wim != lte->out_reshdr.uncompressed_size)) + return false; + + return true; +} + +static int +maybe_rewrite_stream_uncompressed(struct write_streams_ctx *ctx, + struct wim_lookup_table_entry *lte) +{ + if (!should_rewrite_stream_uncompressed(ctx, lte)) + return 0; + + /* Regular (non-solid) WIM resources with exactly one chunk and + * compressed size equal to uncompressed size are exactly the same as + * the corresponding compressed data --- since there must be 0 entries + * in the chunk table and the only chunk must be stored uncompressed. + * In this case, there's no need to rewrite anything. */ + if (ctx->chunk_index == 1 && + lte->out_reshdr.size_in_wim == lte->out_reshdr.uncompressed_size) + { + lte->out_reshdr.flags &= ~WIM_RESHDR_FLAG_COMPRESSED; + return 0; + } + + return write_stream_uncompressed(lte, ctx->out_fd); +} + /* Write the next chunk of (typically compressed) data to the output WIM, * handling the writing of the chunk table. */ static int @@ -820,14 +972,14 @@ write_chunk(struct write_streams_ctx *ctx, const void *cchunk, ret = full_write(ctx->out_fd, &chunk_hdr, sizeof(chunk_hdr)); if (ret) - goto error; + goto write_error; } } /* Write the chunk data. */ ret = full_write(ctx->out_fd, cchunk, csize); if (ret) - goto error; + goto write_error; ctx->cur_write_stream_offset += usize; @@ -836,36 +988,32 @@ write_chunk(struct write_streams_ctx *ctx, const void *cchunk, if (ctx->write_resource_flags & WRITE_RESOURCE_FLAG_PACK_STREAMS) { /* Wrote chunk in packed mode. It may have finished multiple * streams. */ - while (ctx->cur_write_stream_offset > lte->size) { - struct wim_lookup_table_entry *next; + struct wim_lookup_table_entry *next_lte; + + while (lte && ctx->cur_write_stream_offset >= lte->size) { ctx->cur_write_stream_offset -= lte->size; - wimlib_assert(!list_is_singular(&ctx->pending_streams) && - !list_empty(&ctx->pending_streams)); - next = list_entry(lte->write_streams_list.next, - struct wim_lookup_table_entry, - write_streams_list); - list_move_tail(<e->write_streams_list, - &ctx->pack_streams); - lte = next; - completed_stream_count++; - } - if (ctx->cur_write_stream_offset == lte->size) { - ctx->cur_write_stream_offset = 0; - list_move_tail(<e->write_streams_list, - &ctx->pack_streams); + if (ctx->cur_write_stream_offset) + next_lte = list_entry(lte->write_streams_list.next, + struct wim_lookup_table_entry, + write_streams_list); + else + next_lte = NULL; + + ret = done_with_stream(lte, ctx); + if (ret) + return ret; + list_move_tail(<e->write_streams_list, &ctx->pack_streams); completed_stream_count++; + + lte = next_lte; } } else { /* Wrote chunk in non-packed mode. It may have finished a * stream. */ if (ctx->cur_write_stream_offset == lte->size) { - completed_stream_count++; - - list_del(<e->write_streams_list); - wimlib_assert(ctx->cur_write_stream_offset == ctx->cur_write_res_size); @@ -877,38 +1025,27 @@ write_chunk(struct write_streams_ctx *ctx, const void *cchunk, if (ctx->compressor != NULL) lte->out_reshdr.flags |= WIM_RESHDR_FLAG_COMPRESSED; - if (ctx->compressor != NULL && - lte->out_reshdr.size_in_wim >= lte->out_reshdr.uncompressed_size && - !(ctx->write_resource_flags & WRITE_RESOURCE_FLAG_PIPABLE) && - !(lte->flags & WIM_RESHDR_FLAG_PACKED_STREAMS)) - { - /* Stream did not compress to less than its original - * size. If we're not writing a pipable WIM (which - * could mean the output file descriptor is - * non-seekable), and the stream isn't located in a - * resource pack (which would make reading it again - * costly), truncate the file to the start of the stream - * and write it uncompressed instead. */ - DEBUG("Stream of size %"PRIu64" did not compress to " - "less than original size; writing uncompressed.", - lte->size); - ret = write_stream_uncompressed(lte, ctx->out_fd); - if (ret) - return ret; - } + ret = maybe_rewrite_stream_uncompressed(ctx, lte); + if (ret) + return ret; + wimlib_assert(lte->out_reshdr.uncompressed_size == lte->size); ctx->cur_write_stream_offset = 0; + + ret = done_with_stream(lte, ctx); + if (ret) + return ret; + list_del(<e->write_streams_list); + completed_stream_count++; } } - do_write_streams_progress(&ctx->progress_data, lte, - completed_size, completed_stream_count, - false); + return do_write_streams_progress(&ctx->progress_data, + completed_size, completed_stream_count, + false); - return 0; - -error: +write_error: ERROR_WITH_ERRNO("Write error"); return ret; } @@ -922,8 +1059,8 @@ submit_chunk_for_compression(struct write_streams_ctx *ctx, * 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; @@ -1024,11 +1161,27 @@ static int write_stream_end_read(struct wim_lookup_table_entry *lte, int status, void *_ctx) { struct write_streams_ctx *ctx = _ctx; - if (status == 0) - wimlib_assert(ctx->cur_read_stream_offset == ctx->cur_read_stream_size); - if (ctx->stream_was_duplicate) { + + wimlib_assert(ctx->cur_read_stream_offset == ctx->cur_read_stream_size || status); + + if (!lte->will_be_in_output_wim) { + /* The 'lte' stream was a duplicate. Now that its data has + * finished being read, it is being discarded in favor of the + * duplicate entry. It therefore is no longer needed, and we + * can fire the DONE_WITH_FILE callback because the file will + * not be read again. + * + * Note: we can't yet fire DONE_WITH_FILE for non-duplicate + * streams, since it needs to be possible to re-read the file if + * it does not compress to less than its original size. */ + if (!status) + status = done_with_stream(lte, ctx); free_lookup_table_entry(lte); - } else if (lte->unhashed && ctx->lookup_table != NULL) { + } else if (!status && lte->unhashed && ctx->lookup_table != NULL) { + /* The 'lte' stream was not a duplicate and was previously + * unhashed. Since we passed COMPUTE_MISSING_STREAM_HASHES to + * read_stream_list(), lte->hash is now computed and valid. So + * turn this stream into a "hashed" stream. */ list_del(<e->unhashed_list); lookup_table_insert(ctx->lookup_table, lte); lte->unhashed = 0; @@ -1068,24 +1221,23 @@ compute_stream_list_stats(struct list_head *stream_list, 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) @@ -1096,13 +1248,14 @@ find_raw_copy_resources(struct list_head *stream_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; } @@ -1173,22 +1326,32 @@ write_raw_copy_resource(struct wim_resource_spec *in_rspec, 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->size, + 1, false); if (ret) return ret; - do_write_streams_progress(progress_data, lte, lte->size, - 1, false); } return 0; } @@ -1198,8 +1361,8 @@ static int 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) @@ -1237,11 +1400,30 @@ remove_zero_length_streams(struct list_head *stream_list) } } +static void +init_done_with_file_info(struct list_head *stream_list) +{ + struct wim_lookup_table_entry *lte; + + list_for_each_entry(lte, stream_list, write_streams_list) { + if (is_file_stream(lte)) { + lte->file_inode->num_remaining_streams = 0; + lte->may_send_done_with_file = 1; + } else { + lte->may_send_done_with_file = 0; + } + } + + list_for_each_entry(lte, stream_list, write_streams_list) + if (lte->may_send_done_with_file) + lte->file_inode->num_remaining_streams++; +} + /* * 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 @@ -1252,26 +1434,25 @@ remove_zero_length_streams(struct list_head *stream_list) * * 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 - * 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 @@ -1296,27 +1477,21 @@ remove_zero_length_streams(struct list_head *stream_list) * 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 @@ -1324,32 +1499,31 @@ remove_zero_length_streams(struct list_head *stream_list) * 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, @@ -1360,11 +1534,12 @@ 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 | @@ -1379,6 +1554,11 @@ write_stream_list(struct list_head *stream_list, return 0; } + /* If needed, set auxiliary information so that we can detect when the + * library has finished using each external file. */ + if (unlikely(write_resource_flags & WRITE_RESOURCE_FLAG_SEND_DONE_WITH_FILE)) + init_done_with_file_info(stream_list); + memset(&ctx, 0, sizeof(ctx)); /* Pre-sorting the streams is required for compute_stream_list_stats(). @@ -1412,13 +1592,14 @@ write_stream_list(struct list_head *stream_list, 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, " @@ -1438,18 +1619,19 @@ write_stream_list(struct list_head *stream_list, * 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, &ctx.compressor); - if (ret) { - DEBUG("Couldn't create parallel chunk compressor " - "(status %d)", ret); + if (ret > 0) { + WARNING("Couldn't create parallel chunk compressor: %"TS".\n" + " Falling back to single-threaded compression.", + wimlib_get_error_string(ret)); } } #endif @@ -1473,10 +1655,12 @@ write_stream_list(struct list_head *stream_list, 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); @@ -1533,7 +1717,7 @@ write_stream_list(struct list_head *stream_list, 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); @@ -1542,7 +1726,7 @@ write_stream_list(struct list_head *stream_list, 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: @@ -1555,13 +1739,24 @@ 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; @@ -1569,6 +1764,16 @@ wim_write_stream_list(WIMStruct *wim, 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; @@ -1585,7 +1790,8 @@ wim_write_stream_list(WIMStruct *wim, num_threads, wim->lookup_table, filter_ctx, - progress_func); + wim->progfunc, + wim->progctx); } static int @@ -1606,6 +1812,7 @@ write_wim_resource(struct wim_lookup_table_entry *lte, 1, NULL, NULL, + NULL, NULL); } @@ -1851,7 +2058,7 @@ determine_stream_size_uniquity(struct list_head *stream_list, 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; @@ -1922,7 +2129,7 @@ filter_stream_list_for_write(struct list_head *stream_list, * @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 @@ -2003,7 +2210,6 @@ prepare_stream_list_for_write(WIMStruct *wim, int image, 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) { @@ -2044,13 +2250,11 @@ write_wim_streams(WIMStruct *wim, int image, int write_flags, 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; @@ -2069,8 +2273,11 @@ write_wim_metadata_resources(WIMStruct *wim, int image, int write_flags, 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; @@ -2109,9 +2316,10 @@ write_wim_metadata_resources(WIMStruct *wim, int image, int write_flags, 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 @@ -2252,10 +2460,6 @@ write_wim_lookup_table(WIMStruct *wim, int image, int write_flags, * (private) WIMLIB_WRITE_FLAG_NO_LOOKUP_TABLE: * Don't write the lookup table. * - * (private) WIMLIB_WRITE_FLAG_REUSE_INTEGRITY_TABLE: - * When (if) writing the integrity table, re-use entries from the - * existing integrity table, if possible. - * * (private) WIMLIB_WRITE_FLAG_CHECKPOINT_AFTER_XML: * After writing the XML data but before writing the integrity * table, write a temporary WIM header and flush the stream so that @@ -2272,18 +2476,21 @@ write_wim_lookup_table(WIMStruct *wim, int image, int write_flags, * Use the existing stored in the in-memory XML * information, rather than setting it to the offset of the XML * data being written. + * (private) WIMLIB_WRITE_FLAG_OVERWRITE + * The existing WIM file is being updated in-place. The entries + * from its integrity table may be re-used. */ 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; off_t hdr_offset; int write_resource_flags; - off_t old_lookup_table_end; + off_t old_lookup_table_end = 0; off_t new_lookup_table_end; u64 xml_totalbytes; + struct integrity_table *old_integrity_table = NULL; DEBUG("image=%d, write_flags=%08x", image, write_flags); @@ -2302,15 +2509,36 @@ finish_write(WIMStruct *wim, int image, int write_flags, wim->hdr.boot_idx - 1]->metadata_lte->out_reshdr); } - /* Write lookup table. (Save old position first.) */ - old_lookup_table_end = wim->hdr.lookup_table_reshdr.offset_in_wim + - wim->hdr.lookup_table_reshdr.size_in_wim; + /* If overwriting the WIM file containing an integrity table in-place, + * we'd like to re-use the information in the old integrity table + * instead of recalculating it. But we might overwrite the old + * integrity table when we expand the XML data. Read it into memory + * just in case. */ + if ((write_flags & (WIMLIB_WRITE_FLAG_OVERWRITE | + WIMLIB_WRITE_FLAG_CHECK_INTEGRITY)) == + (WIMLIB_WRITE_FLAG_OVERWRITE | + WIMLIB_WRITE_FLAG_CHECK_INTEGRITY) + && wim_has_integrity_table(wim)) + { + old_lookup_table_end = wim->hdr.lookup_table_reshdr.offset_in_wim + + wim->hdr.lookup_table_reshdr.size_in_wim; + (void)read_integrity_table(wim, + old_lookup_table_end - WIM_HEADER_DISK_SIZE, + &old_integrity_table); + /* If we couldn't read the old integrity table, we can still + * re-calculate the full integrity table ourselves. Hence the + * ignoring of the return value. */ + } + + /* Write lookup table. */ if (!(write_flags & WIMLIB_WRITE_FLAG_NO_LOOKUP_TABLE)) { ret = write_wim_lookup_table(wim, image, write_flags, &wim->hdr.lookup_table_reshdr, lookup_table_list); - if (ret) + if (ret) { + free_integrity_table(old_integrity_table); return ret; + } } /* Write XML data. */ @@ -2320,8 +2548,10 @@ finish_write(WIMStruct *wim, int image, int write_flags, ret = write_wim_xml_data(wim, image, xml_totalbytes, &wim->hdr.xml_data_reshdr, write_resource_flags); - if (ret) + if (ret) { + free_integrity_table(old_integrity_table); return ret; + } /* Write integrity table (optional). */ if (write_flags & WIMLIB_WRITE_FLAG_CHECK_INTEGRITY) { @@ -2332,20 +2562,20 @@ finish_write(WIMStruct *wim, int image, int write_flags, checkpoint_hdr.flags |= WIM_HDR_FLAG_WRITE_IN_PROGRESS; ret = write_wim_header_at_offset(&checkpoint_hdr, &wim->out_fd, 0); - if (ret) + if (ret) { + free_integrity_table(old_integrity_table); return ret; + } } - if (!(write_flags & WIMLIB_WRITE_FLAG_REUSE_INTEGRITY_TABLE)) - old_lookup_table_end = 0; - new_lookup_table_end = wim->hdr.lookup_table_reshdr.offset_in_wim + wim->hdr.lookup_table_reshdr.size_in_wim; ret = write_integrity_table(wim, new_lookup_table_end, old_lookup_table_end, - progress_func); + old_integrity_table); + free_integrity_table(old_integrity_table); if (ret) return ret; } else { @@ -2389,28 +2619,30 @@ finish_write(WIMStruct *wim, int image, int write_flags, } #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 @@ -2494,7 +2726,7 @@ lock_wim(WIMStruct *wim, int fd) */ 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) { @@ -2529,16 +2761,14 @@ write_pipable_wim(WIMStruct *wim, int image, int write_flags, /* 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(). */ @@ -2552,7 +2782,6 @@ write_wim_part(WIMStruct *wim, 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, @@ -2579,8 +2808,14 @@ write_wim_part(WIMStruct *wim, 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"); @@ -2588,17 +2823,23 @@ write_wim_part(WIMStruct *wim, 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"); @@ -2616,10 +2857,11 @@ write_wim_part(WIMStruct *wim, 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. */ @@ -2715,11 +2957,13 @@ write_wim_part(WIMStruct *wim, /* 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); @@ -2781,19 +3025,18 @@ write_wim_part(WIMStruct *wim, 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; @@ -2802,8 +3045,7 @@ write_wim_part(WIMStruct *wim, /* 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); @@ -2814,42 +3056,40 @@ out_restore_hdr: /* 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 @@ -2947,15 +3187,13 @@ check_resource_offsets(WIMStruct *wim, off_t end_offset) * 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; @@ -3009,7 +3247,7 @@ overwrite_wim_inplace(WIMStruct *wim, int write_flags, * allow any file and metadata resources to appear without returning * WIMLIB_ERR_RESOURCE_ORDER (due to the fact that we would otherwise * overwrite these resources). */ - if (!wim->deletion_occurred && !any_images_modified(wim)) { + if (!wim->image_deletion_occurred && !any_images_modified(wim)) { /* If no images have been modified and no images have been * deleted, a new lookup table does not need to be written. We * shall write the new XML data and optional integrity table @@ -3045,7 +3283,7 @@ overwrite_wim_inplace(WIMStruct *wim, int write_flags, 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; @@ -3067,23 +3305,20 @@ overwrite_wim_inplace(WIMStruct *wim, int write_flags, &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: @@ -3097,7 +3332,7 @@ 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: @@ -3106,9 +3341,7 @@ 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; @@ -3124,14 +3357,19 @@ overwrite_wim_via_tmpfile(WIMStruct *wim, int write_flags, 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 @@ -3150,13 +3388,11 @@ overwrite_wim_via_tmpfile(WIMStruct *wim, int write_flags, 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 @@ -3168,8 +3404,9 @@ can_overwrite_wim_inplace(const WIMStruct *wim, int write_flags) if (write_flags & WIMLIB_WRITE_FLAG_REBUILD) return false; - /* Deletions cause full rebuild by default. */ - if (wim->deletion_occurred && !(write_flags & WIMLIB_WRITE_FLAG_SOFT_DELETE)) + /* Image deletions cause full rebuild by default. */ + if (wim->image_deletion_occurred && + !(write_flags & WIMLIB_WRITE_FLAG_SOFT_DELETE)) return false; /* Pipable WIMs cannot be updated in place, nor can a non-pipable WIM be @@ -3177,14 +3414,6 @@ can_overwrite_wim_inplace(const WIMStruct *wim, int write_flags) 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. */ @@ -3198,16 +3427,12 @@ can_overwrite_wim_inplace(const WIMStruct *wim, int write_flags) /* 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) @@ -3222,12 +3447,10 @@ wimlib_overwrite(WIMStruct *wim, int write_flags, 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); }