]> wimlib.net Git - wimlib/blobdiff - src/write.c
header cleanups
[wimlib] / src / write.c
index ae1754803628f8f2f433568d05453fba28444ed6..f3c12ffe4cbc8ffacced2e635ff3a352c773a21f 100644 (file)
@@ -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
 #  include <sys/file.h>
 #endif
 
+#include <errno.h>
+#include <fcntl.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#include "wimlib/alloca.h"
+#include "wimlib/assert.h"
 #include "wimlib/chunk_compressor.h"
 #include "wimlib/endianness.h"
 #include "wimlib/error.h"
@@ -43,6 +48,8 @@
 #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() */
 #include "wimlib/write.h"
 #include "wimlib/xml.h"
 
-#include <errno.h>
-#include <fcntl.h>
-#include <stdlib.h>
-#include <unistd.h>
-
-#ifdef HAVE_ALLOCA_H
-#  include <alloca.h>
-#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)
@@ -75,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;
 }
 
@@ -97,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)
@@ -270,19 +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;
 };
 
-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;
+       int ret;
 
        if (discarded) {
                progress->write_streams.total_bytes -= complete_size;
@@ -297,20 +303,43 @@ do_write_streams_progress(struct write_streams_progress_data *progress_data,
                progress->write_streams.completed_streams += complete_count;
        }
 
-       if (progress_data->progress_func
-           && (progress->write_streams.completed_bytes >= progress_data->next_progress))
+       if (progress->write_streams.completed_bytes >= progress_data->next_progress)
        {
-               progress_data->progress_func(WIMLIB_PROGRESS_MSG_WRITE_STREAMS,
-                                            progress);
+               ret = call_progress(progress_data->progfunc,
+                                   WIMLIB_PROGRESS_MSG_WRITE_STREAMS,
+                                   progress,
+                                   progress_data->progctx);
+               if (ret)
+                       return ret;
+
                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 {
@@ -358,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;
 
@@ -443,7 +466,7 @@ begin_chunk_table(struct write_streams_ctx *ctx, u64 res_expected_size)
                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);
@@ -491,10 +514,10 @@ end_chunk_table(struct write_streams_ctx *ctx, u64 res_actual_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;
+       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;
@@ -533,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 {
@@ -557,7 +580,7 @@ end_chunk_table(struct write_streams_ctx *ctx, u64 res_actual_size,
                        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;
@@ -566,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;
@@ -574,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;
 }
@@ -610,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 = &lte->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,
-                       u32 flags, void *_ctx)
+write_stream_begin_read(struct wim_lookup_table_entry *lte, void *_ctx)
 {
        struct write_streams_ctx *ctx = _ctx;
        int ret;
@@ -634,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(!(flags & BEGIN_STREAM_FLAG_PARTIAL_RESOURCE));
-
                struct wim_lookup_table_entry *lte_new;
 
                ret = hash_unhashed_stream(lte, ctx->lookup_table, &lte_new);
@@ -658,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(&lte->write_streams_list);
                                list_del(&lte->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,
@@ -682,9 +792,10 @@ write_stream_begin_read(struct wim_lookup_table_entry *lte,
                                             &lte_new->write_streams_list);
                                list_replace(&lte->lookup_table_list,
                                             &lte_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;
                        }
                }
@@ -741,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
@@ -794,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;
 
@@ -810,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(&lte->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(&lte->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(&lte->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(&lte->write_streams_list);
-
                        wimlib_assert(ctx->cur_write_stream_offset ==
                                      ctx->cur_write_res_size);
 
@@ -851,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(&lte->write_streams_list);
+                       completed_stream_count++;
                }
        }
 
-       do_write_streams_progress(&ctx->progress_data, lte,
-                                 completed_size, completed_stream_count,
-                                 false);
-
-       return 0;
+       return do_write_streams_progress(&ctx->progress_data,
+                                        completed_size, completed_stream_count,
+                                        false);
 
-error:
+write_error:
        ERROR_WITH_ERRNO("Write error");
        return ret;
 }
@@ -998,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(&lte->unhashed_list);
                lookup_table_insert(ctx->lookup_table, lte);
                lte->unhashed = 0;
@@ -1169,8 +1348,10 @@ write_raw_copy_resources(struct list_head *raw_copy_streams,
                                return ret;
                        lte->rspec->raw_copy_ok = 0;
                }
-               do_write_streams_progress(progress_data, lte, lte->size,
-                                         1, false);
+               ret = do_write_streams_progress(progress_data, lte->size,
+                                               1, false);
+               if (ret)
+                       return ret;
        }
        return 0;
 }
@@ -1219,6 +1400,25 @@ 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.
  *
@@ -1251,9 +1451,8 @@ remove_zero_length_streams(struct list_head *stream_list)
  *
  * @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
@@ -1278,12 +1477,6 @@ 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.
@@ -1341,7 +1534,8 @@ 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;
@@ -1360,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().
@@ -1393,7 +1592,8 @@ 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_streams(stream_list,
                                                          write_resource_flags,
@@ -1428,9 +1628,10 @@ write_stream_list(struct list_head *stream_list,
                                                            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
@@ -1454,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);
@@ -1553,8 +1756,7 @@ 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;
@@ -1562,7 +1764,7 @@ wim_write_stream_list(WIMStruct *wim,
 
        write_resource_flags = write_flags_to_resource_flags(write_flags);
 
-       /* wimlib v1.6.3: pack streams by default if the WIM version has been
+       /* 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).  */
@@ -1588,7 +1790,8 @@ wim_write_stream_list(WIMStruct *wim,
                                 num_threads,
                                 wim->lookup_table,
                                 filter_ctx,
-                                progress_func);
+                                wim->progfunc,
+                                wim->progctx);
 }
 
 static int
@@ -1609,6 +1812,7 @@ write_wim_resource(struct wim_lookup_table_entry *lte,
                                 1,
                                 NULL,
                                 NULL,
+                                NULL,
                                 NULL);
 }
 
@@ -2006,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)
 {
@@ -2047,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;
@@ -2072,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;
@@ -2112,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
@@ -2255,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
@@ -2275,18 +2476,21 @@ write_wim_lookup_table(WIMStruct *wim, int image, int write_flags,
  *             Use the existing <TOTALBYTES> 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);
 
@@ -2305,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.  */
@@ -2323,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) {
@@ -2335,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 {
@@ -2392,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
 
@@ -2497,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)
 {
@@ -2532,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().  */
@@ -2555,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,
@@ -2631,7 +2857,7 @@ 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", (write_flags &
                                        WIMLIB_WRITE_FLAG_RETAIN_GUID) ? "retain"
@@ -2799,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;
@@ -2820,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);
@@ -2832,18 +3056,16 @@ 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 (write_flags & ~WIMLIB_WRITE_MASK_PUBLIC)
                return WIMLIB_ERR_INVALID_PARAM;
@@ -2851,15 +3073,13 @@ wimlib_write(WIMStruct *wim, const tchar *path,
        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;
@@ -2869,8 +3089,7 @@ wimlib_write_to_fd(WIMStruct *wim, int fd,
 
        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
@@ -2974,9 +3193,7 @@ check_resource_offsets(WIMStruct *wim, off_t end_offset)
  * 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;
@@ -3030,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
@@ -3066,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;
 
@@ -3088,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:
@@ -3118,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:
@@ -3127,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;
@@ -3148,7 +3360,7 @@ overwrite_wim_via_tmpfile(WIMStruct *wim, int write_flags,
                           write_flags |
                                WIMLIB_WRITE_FLAG_FSYNC |
                                WIMLIB_WRITE_FLAG_RETAIN_GUID,
-                          num_threads, progress_func);
+                          num_threads);
        if (ret) {
                tunlink(tmpfile);
                return ret;
@@ -3176,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
@@ -3194,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
@@ -3216,9 +3427,7 @@ 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;
@@ -3238,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);
 }