]> wimlib.net Git - wimlib/blobdiff - src/write.c
win32_capture.c: Don't add duplicate backslashes
[wimlib] / src / write.c
index 2b8347da973a1f20bd05dc15eed472f0dff374c3..56eb5dd46e5dc8db1ee2a9148c57da427dae0c8a 100644 (file)
@@ -6,7 +6,7 @@
  */
 
 /*
- * 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.
  *
@@ -312,10 +312,28 @@ do_write_streams_progress(struct write_streams_progress_data *progress_data,
                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;
@@ -451,7 +469,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);
@@ -499,7 +517,7 @@ 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;
@@ -1261,9 +1279,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
@@ -1569,7 +1586,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).  */
@@ -2265,10 +2282,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
@@ -2285,6 +2298,9 @@ 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,
@@ -2293,9 +2309,10 @@ finish_write(WIMStruct *wim, int image, int write_flags,
        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);
 
@@ -2314,15 +2331,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.  */
@@ -2332,8 +2370,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) {
@@ -2344,19 +2384,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);
+                                           old_lookup_table_end,
+                                           old_integrity_table);
+               free_integrity_table(old_integrity_table);
                if (ret)
                        return ret;
        } else {
@@ -2400,28 +2441,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
 
@@ -3062,7 +3105,7 @@ overwrite_wim_inplace(WIMStruct *wim, int write_flags, unsigned num_threads)
        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;
 
@@ -3092,13 +3135,12 @@ overwrite_wim_inplace(WIMStruct *wim, int write_flags, unsigned num_threads)
        if (ret)
                goto out_truncate;
 
-       write_flags |= WIMLIB_WRITE_FLAG_REUSE_INTEGRITY_TABLE;
        ret = finish_write(wim, WIMLIB_ALL_IMAGES, write_flags,
                           &lookup_table_list);
        if (ret)
                goto out_truncate;
 
-       wim->wim_locked = 0;
+       unlock_wim_for_append(wim);
        return 0;
 
 out_truncate:
@@ -3112,7 +3154,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: