}
/*
+ * finish_write():
+ *
* Finish writing a WIM file: write the lookup table, xml data, and integrity
- * table, then overwrite the WIM header. Always closes the WIM file descriptor
- * (wim->out_fd).
+ * table, then overwrite the WIM header. By default, closes the WIM file
+ * descriptor (@wim->out_fd) if successful.
*
* write_flags is a bitwise OR of the following:
*
* (public) WIMLIB_WRITE_FLAG_FSYNC:
* fsync() the output file before closing it.
*
- * (public) WIMLIB_WRITE_FLAG_PIPABLE:
+ * (public) WIMLIB_WRITE_FLAG_PIPABLE:
* Writing a pipable WIM, possibly to a pipe; include pipable WIM
* stream headers before the lookup table and XML data, and also
* write the WIM header at the end instead of seeking to the
* Instead of overwriting the WIM header at the beginning of the
* file, simply append it to the end of the file. (Used when
* writing to pipe.)
+ * (private) WIMLIB_WRITE_FLAG_FILE_DESCRIPTOR:
+ * Do not close the file descriptor @wim->out_fd on either success
+ * on failure.
* (private) WIMLIB_WRITE_FLAG_USE_EXISTING_TOTALBYTES:
* Use the existing <TOTALBYTES> stored in the in-memory XML
* information, rather than setting it to the offset of the XML
&wim->hdr.lookup_table_res_entry,
stream_list_override);
if (ret)
- goto out_close_wim;
+ return ret;
}
/* Write XML data. */
&wim->hdr.xml_res_entry,
write_resource_flags);
if (ret)
- goto out_close_wim;
+ return ret;
+ /* Write integrity table (optional). */
if (write_flags & WIMLIB_WRITE_FLAG_CHECK_INTEGRITY) {
if (write_flags & WIMLIB_WRITE_FLAG_CHECKPOINT_AFTER_XML) {
struct wim_header checkpoint_hdr;
ret = write_wim_header_at_offset(&checkpoint_hdr,
&wim->out_fd, 0);
if (ret)
- goto out_close_wim;
+ return ret;
}
if (!(write_flags & WIMLIB_WRITE_FLAG_REUSE_INTEGRITY_TABLE))
old_lookup_table_end,
progress_func);
if (ret)
- goto out_close_wim;
+ return ret;
} else {
+ /* No integrity table. */
zero_resource_entry(&wim->hdr.integrity);
}
+ /* Now that all information in the WIM header has been determined, the
+ * preliminary header written earlier can be overwritten, the header of
+ * the existing WIM file can be overwritten, or the final header can be
+ * written to the end of the pipable WIM. */
wim->hdr.flags &= ~WIM_HDR_FLAG_WRITE_IN_PROGRESS;
hdr_offset = 0;
if (write_flags & WIMLIB_WRITE_FLAG_HEADER_AT_END)
hdr_offset = wim->out_fd.offset;
ret = write_wim_header_at_offset(&wim->hdr, &wim->out_fd, hdr_offset);
if (ret)
- goto out_close_wim;
+ return ret;
+ /* Possibly sync file data to disk before closing. On POSIX systems, it
+ * is necessary to do this before using rename() to overwrite an
+ * existing file with a new file. Otherwise, data loss would occur if
+ * the system is abruptly terminated when the metadata for the rename
+ * operation has been written to disk, but the new file data has not.
+ */
if (write_flags & WIMLIB_WRITE_FLAG_FSYNC) {
if (fsync(wim->out_fd.fd)) {
ERROR_WITH_ERRNO("Error syncing data to WIM file");
- ret = WIMLIB_ERR_WRITE;
- goto out_close_wim;
+ return WIMLIB_ERR_WRITE;
}
}
- ret = 0;
-out_close_wim:
if (close_wim_writable(wim, write_flags)) {
- if (ret == 0) {
- ERROR_WITH_ERRNO("Failed to close the output WIM file");
- ret = WIMLIB_ERR_WRITE;
- }
+ ERROR_WITH_ERRNO("Failed to close the output WIM file");
+ return WIMLIB_ERR_WRITE;
}
- return ret;
+
+ return 0;
}
#if defined(HAVE_SYS_FILE_H) && defined(HAVE_FLOCK)
stream_list_override);
out_restore_hdr:
memcpy(&wim->hdr, &hdr_save, sizeof(struct wim_header));
- close_wim_writable(wim, write_flags);
+ (void)close_wim_writable(wim, write_flags);
return ret;
}
struct list_head stream_list;
off_t old_wim_end;
u64 old_lookup_table_end, old_xml_begin, old_xml_end;
-
+ struct wim_header hdr_save;
DEBUG("Overwriting `%"TS"' in-place", wim->filename);
return ret;
ret = lock_wim(wim, wim->out_fd.fd);
- if (ret) {
- close_wim_writable(wim, write_flags);
- return ret;
- }
+ if (ret)
+ goto out_close_wim;
+
+ /* Save original header so it can be restored in case of error */
+ memcpy(&hdr_save, &wim->hdr, sizeof(struct wim_header));
/* Set WIM_HDR_FLAG_WRITE_IN_PROGRESS flag in header. */
- ret = write_wim_header_flags(wim->hdr.flags | WIM_HDR_FLAG_WRITE_IN_PROGRESS,
- &wim->out_fd);
+ wim->hdr.flags |= WIM_HDR_FLAG_WRITE_IN_PROGRESS;
+ ret = write_wim_header_flags(wim->hdr.flags, &wim->out_fd);
if (ret) {
ERROR_WITH_ERRNO("Error updating WIM header flags");
- close_wim_writable(wim, write_flags);
- goto out_unlock_wim;
+ goto out_restore_memory_hdr;
}
if (filedes_seek(&wim->out_fd, old_wim_end) == -1) {
ERROR_WITH_ERRNO("Can't seek to end of WIM");
- close_wim_writable(wim, write_flags);
ret = WIMLIB_ERR_WRITE;
- goto out_unlock_wim;
+ goto out_restore_physical_hdr;
}
ret = write_stream_list(&stream_list,
write_flags |= WIMLIB_WRITE_FLAG_REUSE_INTEGRITY_TABLE;
ret = finish_write(wim, WIMLIB_ALL_IMAGES, write_flags,
progress_func, NULL);
+ if (ret)
+ goto out_truncate;
+
+ goto out_unlock_wim;
+
out_truncate:
- close_wim_writable(wim, write_flags);
- if (ret && !(write_flags & WIMLIB_WRITE_FLAG_NO_LOOKUP_TABLE)) {
+ if (!(write_flags & WIMLIB_WRITE_FLAG_NO_LOOKUP_TABLE)) {
WARNING("Truncating `%"TS"' to its original size (%"PRIu64" bytes)",
wim->filename, old_wim_end);
- /* Return value of truncate() is ignored because this is already
- * an error path. */
- (void)ttruncate(wim->filename, old_wim_end);
+ /* Return value of ftruncate() is ignored because this is
+ * already an error path. */
+ (void)ftruncate(wim->out_fd.fd, old_wim_end);
}
+out_restore_physical_hdr:
+ (void)write_wim_header_flags(hdr_save.flags, &wim->out_fd);
+out_restore_memory_hdr:
+ memcpy(&wim->hdr, &hdr_save, sizeof(struct wim_header));
+out_close_wim:
+ (void)close_wim_writable(wim, write_flags);
out_unlock_wim:
wim->wim_locked = 0;
return ret;
git://wimlib.net / wimlib / blobdiff