X-Git-Url: https://wimlib.net/git/?p=wimlib;a=blobdiff_plain;f=src%2Fwrite.c;h=90dcaed4201d0d92ce6cf74dfc9691dd4bf11025;hp=5218fee0251e8d45ff355d2c4b499487edd1cce1;hb=77b2c74599190197074c82937787f24f83ece0af;hpb=81d682b3995ba8736f819acd043a695f161dd8a2 diff --git a/src/write.c b/src/write.c index 5218fee0..90dcaed4 100644 --- a/src/write.c +++ b/src/write.c @@ -24,25 +24,31 @@ * along with wimlib; if not, see http://www.gnu.org/licenses/. */ -#include "config.h" +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif #if defined(HAVE_SYS_FILE_H) && defined(HAVE_FLOCK) -/* On BSD, this should be included before "list.h" so that "list.h" can +/* On BSD, this should be included before "wimlib/list.h" so that "wimlib/list.h" can * overwrite the LIST_HEAD macro. */ # include #endif +#include "wimlib/endianness.h" +#include "wimlib/error.h" +#include "wimlib/file_io.h" +#include "wimlib/header.h" +#include "wimlib/integrity.h" +#include "wimlib/lookup_table.h" +#include "wimlib/metadata.h" +#include "wimlib/resource.h" +#include "wimlib/write.h" +#include "wimlib/xml.h" + #ifdef __WIN32__ -# include "win32.h" +# include "wimlib/win32.h" /* win32_get_number_of_processors() */ #endif -#include "list.h" -#include "wimlib_internal.h" -#include "buffer_io.h" -#include "dentry.h" -#include "lookup_table.h" -#include "xml.h" - #ifdef ENABLE_MULTITHREADED_COMPRESSION # include #endif @@ -75,13 +81,19 @@ * array of offsets.) */ struct chunk_table { off_t file_offset; - u64 num_chunks; u64 original_resource_size; - u64 bytes_per_chunk_entry; + u64 num_chunks; u64 table_disk_size; - u64 cur_offset; - u64 *cur_offset_p; - u64 offsets[0]; + unsigned bytes_per_chunk_entry; + void *cur_offset_p; + union { + u32 cur_offset_u32; + u64 cur_offset_u64; + }; + /* Beginning of chunk offsets, in either 32-bit or 64-bit little endian + * integers, including the first offset of 0, which will not be written. + * */ + u8 offsets[] _aligned_attribute(8); }; /* @@ -95,11 +107,12 @@ begin_wim_resource_chunk_tab(const struct wim_lookup_table_entry *lte, struct chunk_table **chunk_tab_ret) { u64 size = wim_resource_size(lte); - u64 num_chunks = (size + WIM_CHUNK_SIZE - 1) / WIM_CHUNK_SIZE; + u64 num_chunks = wim_resource_chunks(lte); + unsigned bytes_per_chunk_entry = (size > (1ULL << 32)) ? 8 : 4; size_t alloc_size = sizeof(struct chunk_table) + num_chunks * sizeof(u64); struct chunk_table *chunk_tab = CALLOC(1, alloc_size); - DEBUG("Begin chunk table for stream with size %"PRIu64, size); + DEBUG("Beginning chunk table for stream with size %"PRIu64, size); if (!chunk_tab) { ERROR("Failed to allocate chunk table for %"PRIu64" byte " @@ -109,13 +122,15 @@ begin_wim_resource_chunk_tab(const struct wim_lookup_table_entry *lte, chunk_tab->file_offset = file_offset; chunk_tab->num_chunks = num_chunks; chunk_tab->original_resource_size = size; - chunk_tab->bytes_per_chunk_entry = (size >= (1ULL << 32)) ? 8 : 4; + chunk_tab->bytes_per_chunk_entry = bytes_per_chunk_entry; chunk_tab->table_disk_size = chunk_tab->bytes_per_chunk_entry * (num_chunks - 1); - chunk_tab->cur_offset = 0; chunk_tab->cur_offset_p = chunk_tab->offsets; - if (full_write(out_fd, chunk_tab, + /* We don't know the correct offsets yet; this just writes zeroes to + * reserve space for the table, so we can go back to it later after + * we've written the compressed chunks following it. */ + if (full_write(out_fd, chunk_tab->offsets, chunk_tab->table_disk_size) != chunk_tab->table_disk_size) { ERROR_WITH_ERRNO("Failed to write chunk table in compressed " @@ -127,6 +142,22 @@ begin_wim_resource_chunk_tab(const struct wim_lookup_table_entry *lte, return 0; } +/* Add the offset for the next chunk to the chunk table being constructed for a + * compressed stream. */ +static void +chunk_tab_record_chunk(struct chunk_table *chunk_tab, unsigned out_chunk_size) +{ + if (chunk_tab->bytes_per_chunk_entry == 4) { + *(le32*)chunk_tab->cur_offset_p = cpu_to_le32(chunk_tab->cur_offset_u32); + chunk_tab->cur_offset_p = (le32*)chunk_tab->cur_offset_p + 1; + chunk_tab->cur_offset_u32 += out_chunk_size; + } else { + *(le64*)chunk_tab->cur_offset_p = cpu_to_le64(chunk_tab->cur_offset_u64); + chunk_tab->cur_offset_p = (le64*)chunk_tab->cur_offset_p + 1; + chunk_tab->cur_offset_u64 += out_chunk_size; + } +} + /* * compress_func_t- Pointer to a function to compresses a chunk * of a WIM resource. This may be either @@ -196,8 +227,7 @@ write_wim_resource_chunk(const void * restrict chunk, out_chunk = chunk; out_chunk_size = chunk_size; } - *chunk_tab->cur_offset_p++ = chunk_tab->cur_offset; - chunk_tab->cur_offset += out_chunk_size; + chunk_tab_record_chunk(chunk_tab, out_chunk_size); } else { /* Write uncompressed */ out_chunk = chunk; @@ -223,15 +253,8 @@ finish_wim_resource_chunk_tab(struct chunk_table *chunk_tab, { size_t bytes_written; - if (chunk_tab->bytes_per_chunk_entry == 8) { - array_cpu_to_le64(chunk_tab->offsets, chunk_tab->num_chunks); - } else { - for (u64 i = 0; i < chunk_tab->num_chunks; i++) - ((u32*)chunk_tab->offsets)[i] = - cpu_to_le32(chunk_tab->offsets[i]); - } bytes_written = full_pwrite(out_fd, - (u8*)chunk_tab->offsets + chunk_tab->bytes_per_chunk_entry, + chunk_tab->offsets + chunk_tab->bytes_per_chunk_entry, chunk_tab->table_disk_size, chunk_tab->file_offset); if (bytes_written != chunk_tab->table_disk_size) { @@ -239,7 +262,10 @@ finish_wim_resource_chunk_tab(struct chunk_table *chunk_tab, "file resource"); return WIMLIB_ERR_WRITE; } - *compressed_size_p = chunk_tab->cur_offset + chunk_tab->table_disk_size; + if (chunk_tab->bytes_per_chunk_entry == 4) + *compressed_size_p = chunk_tab->cur_offset_u32 + chunk_tab->table_disk_size; + else + *compressed_size_p = chunk_tab->cur_offset_u64 + chunk_tab->table_disk_size; return 0; } @@ -785,10 +811,8 @@ static int write_wim_chunks(struct message *msg, int out_fd, struct chunk_table *chunk_tab) { - for (unsigned i = 0; i < msg->num_chunks; i++) { - *chunk_tab->cur_offset_p++ = chunk_tab->cur_offset; - chunk_tab->cur_offset += msg->out_chunks[i].iov_len; - } + for (unsigned i = 0; i < msg->num_chunks; i++) + chunk_tab_record_chunk(chunk_tab, msg->out_chunks[i].iov_len); if (full_writev(out_fd, msg->out_chunks, msg->num_chunks) != msg->total_out_bytes) { @@ -1200,7 +1224,7 @@ main_thread_process_next_stream(struct wim_lookup_table_entry *lte, void *_ctx) } static long -get_default_num_threads() +get_default_num_threads(void) { #ifdef __WIN32__ return win32_get_number_of_processors(); @@ -1415,7 +1439,7 @@ write_stream_list(struct list_head *stream_list, progress.write_streams._private = 0; #ifdef ENABLE_MULTITHREADED_COMPRESSION - if (total_compression_bytes >= 1000000 && num_threads != 1) + if (total_compression_bytes >= 2000000 && num_threads != 1) ret = write_stream_list_parallel(stream_list, lookup_table, out_fd, @@ -1704,9 +1728,6 @@ write_wim_streams(WIMStruct *wim, int image, int write_flags, * (public) WIMLIB_WRITE_FLAG_CHECK_INTEGRITY: * Include an integrity table. * - * (public) WIMLIB_WRITE_FLAG_SHOW_PROGRESS: - * Show progress information when (if) writing the integrity table. - * * (private) WIMLIB_WRITE_FLAG_NO_LOOKUP_TABLE: * Don't write the lookup table. *