#include <unistd.h> /* for unlink() */
#include "wimlib/assert.h"
+#include "wimlib/bitops.h"
#include "wimlib/blob_table.h"
#include "wimlib/encoding.h"
#include "wimlib/endianness.h"
#include "wimlib/resource.h"
#include "wimlib/unaligned.h"
#include "wimlib/util.h"
+#include "wimlib/win32.h"
#include "wimlib/write.h"
/* A hash table mapping SHA-1 message digests to blob descriptors */
struct blob_table {
struct hlist_head *array;
size_t num_blobs;
- size_t capacity;
+ size_t mask; /* capacity - 1; capacity is a power of 2 */
};
+static size_t
+next_power_of_2(size_t n)
+{
+ if (n <= 1)
+ return 1;
+ return (size_t)1 << (1 + flsw(n - 1));
+}
+
struct blob_table *
new_blob_table(size_t capacity)
{
struct blob_table *table;
struct hlist_head *array;
+ capacity = next_power_of_2(capacity);
+
table = MALLOC(sizeof(struct blob_table));
if (table == NULL)
goto oom;
}
table->num_blobs = 0;
- table->capacity = capacity;
+ table->mask = capacity - 1;
table->array = array;
return table;
struct blob_descriptor *
new_blob_descriptor(void)
{
- BUILD_BUG_ON(BLOB_NONEXISTENT != 0);
+ STATIC_ASSERT(BLOB_NONEXISTENT == 0);
return CALLOC(1, sizeof(struct blob_descriptor));
}
break;
case BLOB_IN_FILE_ON_DISK:
-#ifdef __WIN32__
- case BLOB_IN_WINNT_FILE_ON_DISK:
- case BLOB_WIN32_ENCRYPTED:
-#endif
#ifdef WITH_FUSE
case BLOB_IN_STAGING_FILE:
- BUILD_BUG_ON((void*)&old->file_on_disk !=
- (void*)&old->staging_file_name);
+ STATIC_ASSERT((void*)&old->file_on_disk ==
+ (void*)&old->staging_file_name);
#endif
new->file_on_disk = TSTRDUP(old->file_on_disk);
if (new->file_on_disk == NULL)
goto out_free;
break;
+#ifdef __WIN32__
+ case BLOB_IN_WINDOWS_FILE:
+ new->windows_file = clone_windows_file(old->windows_file);
+ break;
+#endif
case BLOB_IN_ATTACHED_BUFFER:
new->attached_buffer = memdup(old->attached_buffer, old->size);
if (new->attached_buffer == NULL)
return NULL;
}
-static void
+/* Release a blob descriptor from its location, if any, and set its new location
+ * to BLOB_NONEXISTENT. */
+void
blob_release_location(struct blob_descriptor *blob)
{
switch (blob->blob_location) {
- case BLOB_IN_WIM:
+ case BLOB_IN_WIM: {
+ struct wim_resource_descriptor *rdesc = blob->rdesc;
+
list_del(&blob->rdesc_node);
- if (list_empty(&blob->rdesc->blob_list))
- FREE(blob->rdesc);
+ if (list_empty(&rdesc->blob_list)) {
+ wim_decrement_refcnt(rdesc->wim);
+ FREE(rdesc);
+ }
break;
+ }
case BLOB_IN_FILE_ON_DISK:
-#ifdef __WIN32__
- case BLOB_IN_WINNT_FILE_ON_DISK:
- case BLOB_WIN32_ENCRYPTED:
-#endif
#ifdef WITH_FUSE
case BLOB_IN_STAGING_FILE:
- BUILD_BUG_ON((void*)&blob->file_on_disk !=
- (void*)&blob->staging_file_name);
+ STATIC_ASSERT((void*)&blob->file_on_disk ==
+ (void*)&blob->staging_file_name);
#endif
case BLOB_IN_ATTACHED_BUFFER:
- BUILD_BUG_ON((void*)&blob->file_on_disk !=
- (void*)&blob->attached_buffer);
+ STATIC_ASSERT((void*)&blob->file_on_disk ==
+ (void*)&blob->attached_buffer);
FREE(blob->file_on_disk);
break;
+#ifdef __WIN32__
+ case BLOB_IN_WINDOWS_FILE:
+ free_windows_file(blob->windows_file);
+ break;
+#endif
#ifdef WITH_NTFS_3G
case BLOB_IN_NTFS_VOLUME:
- if (blob->ntfs_loc)
- free_ntfs_location(blob->ntfs_loc);
+ free_ntfs_location(blob->ntfs_loc);
break;
#endif
}
+ blob->blob_location = BLOB_NONEXISTENT;
}
void
static void
blob_table_insert_raw(struct blob_table *table, struct blob_descriptor *blob)
{
- size_t i = blob->hash_short % table->capacity;
+ size_t i = blob->hash_short & table->mask;
hlist_add_head(&blob->hash_list, &table->array[i]);
}
struct hlist_node *tmp;
size_t i;
- old_capacity = table->capacity;
+ old_capacity = table->mask + 1;
new_capacity = old_capacity * 2;
new_array = CALLOC(new_capacity, sizeof(struct hlist_head));
if (new_array == NULL)
return;
old_array = table->array;
table->array = new_array;
- table->capacity = new_capacity;
+ table->mask = new_capacity - 1;
for (i = 0; i < old_capacity; i++)
hlist_for_each_entry_safe(blob, tmp, &old_array[i], hash_list)
blob_table_insert(struct blob_table *table, struct blob_descriptor *blob)
{
blob_table_insert_raw(table, blob);
- if (++table->num_blobs > table->capacity)
+ if (table->num_blobs++ > table->mask)
enlarge_blob_table(table);
}
size_t i;
struct blob_descriptor *blob;
- i = load_size_t_unaligned(hash) % table->capacity;
+ i = load_size_t_unaligned(hash) & table->mask;
hlist_for_each_entry(blob, &table->array[i], hash_list)
if (hashes_equal(hash, blob->hash))
return blob;
struct hlist_node *tmp;
int ret;
- for (size_t i = 0; i < table->capacity; i++) {
+ for (size_t i = 0; i <= table->mask; i++) {
hlist_for_each_entry_safe(blob, tmp, &table->array[i],
hash_list)
{
v = (int)blob1->blob_location - (int)blob2->blob_location;
- /* Different locations? */
+ /* Different locations? Note: "unsafe compaction mode" requires that
+ * blobs in WIMs sort before all others. For the logic here to ensure
+ * this, BLOB_IN_WIM must have the lowest value among all defined
+ * blob_locations. Statically verify that the enum values haven't
+ * changed. */
+ STATIC_ASSERT(BLOB_NONEXISTENT == 0 && BLOB_IN_WIM == 1);
if (v)
return v;
wim1 = blob1->rdesc->wim;
wim2 = blob2->rdesc->wim;
- /* Different (possibly split) WIMs? */
+ /* Different WIM files? */
if (wim1 != wim2) {
+
+ /* Resources from the WIM file currently being compacted
+ * (if any) must always sort first. */
+ v = (int)wim2->being_compacted - (int)wim1->being_compacted;
+ if (v)
+ return v;
+
+ /* Different split WIMs? */
v = cmp_guids(wim1->hdr.guid, wim2->hdr.guid);
if (v)
return v;
+
+ /* Different part numbers in the same split WIM? */
+ v = (int)wim1->hdr.part_number - (int)wim2->hdr.part_number;
+ if (v)
+ return v;
+
+ /* Probably two WIMStructs for the same on-disk file.
+ * Just sort by pointer. */
+ return wim1 < wim2 ? -1 : 1;
}
- /* Different part numbers in the same WIM? */
- v = (int)wim1->hdr.part_number - (int)wim2->hdr.part_number;
- if (v)
- return v;
+ /* Same WIM file */
+ /* Sort by increasing resource offset */
if (blob1->rdesc->offset_in_wim != blob2->rdesc->offset_in_wim)
return cmp_u64(blob1->rdesc->offset_in_wim,
blob2->rdesc->offset_in_wim);
+ /* The blobs are in the same solid resource. Sort by increasing
+ * offset in the resource. */
return cmp_u64(blob1->offset_in_res, blob2->offset_in_res);
case BLOB_IN_FILE_ON_DISK:
#ifdef WITH_FUSE
case BLOB_IN_STAGING_FILE:
-#endif
-#ifdef __WIN32__
- case BLOB_IN_WINNT_FILE_ON_DISK:
- case BLOB_WIN32_ENCRYPTED:
- /* Windows: compare by starting LCN (logical cluster number) */
- v = cmp_u64(blob1->sort_key, blob2->sort_key);
- if (v)
- return v;
#endif
/* Compare files by path: just a heuristic that will place files
* in the same directory next to each other. */
return tstrcmp(blob1->file_on_disk, blob2->file_on_disk);
+#ifdef __WIN32__
+ case BLOB_IN_WINDOWS_FILE:
+ return cmp_windows_files(blob1->windows_file, blob2->windows_file);
+#endif
#ifdef WITH_NTFS_3G
case BLOB_IN_NTFS_VOLUME:
return cmp_ntfs_locations(blob1->ntfs_loc, blob2->ntfs_loc);
/* Compression format numbers must be the same as in
* WIMGAPI to be compatible here. */
- BUILD_BUG_ON(WIMLIB_COMPRESSION_TYPE_NONE != 0);
- BUILD_BUG_ON(WIMLIB_COMPRESSION_TYPE_XPRESS != 1);
- BUILD_BUG_ON(WIMLIB_COMPRESSION_TYPE_LZX != 2);
- BUILD_BUG_ON(WIMLIB_COMPRESSION_TYPE_LZMS != 3);
+ STATIC_ASSERT(WIMLIB_COMPRESSION_TYPE_NONE == 0);
+ STATIC_ASSERT(WIMLIB_COMPRESSION_TYPE_XPRESS == 1);
+ STATIC_ASSERT(WIMLIB_COMPRESSION_TYPE_LZX == 2);
+ STATIC_ASSERT(WIMLIB_COMPRESSION_TYPE_LZMS == 3);
rdesc->compression_type = le32_to_cpu(hdr.compression_format);
rdesc->chunk_size = le32_to_cpu(hdr.chunk_size);
}
if (ret)
goto out_free_rdescs;
+ wim->refcnt += num_rdescs;
+
*rdescs_ret = rdescs;
*num_rdescs_ret = num_rdescs;
return 0;
free_solid_rdescs(struct wim_resource_descriptor **rdescs, size_t num_rdescs)
{
if (rdescs) {
- for (size_t i = 0; i < num_rdescs; i++)
- if (list_empty(&rdescs[i]->blob_list))
+ for (size_t i = 0; i < num_rdescs; i++) {
+ if (list_empty(&rdescs[i]->blob_list)) {
+ rdescs[i]->wim->refcnt--;
FREE(rdescs[i]);
+ }
+ }
FREE(rdescs);
}
}
/* Allocate a hash table to map SHA-1 message digests into blob
* descriptors. This is the in-memory "blob table". */
- table = new_blob_table(num_entries * 2 + 1);
+ table = new_blob_table(num_entries);
if (!table)
goto oom;
goto oom;
wim_reshdr_to_desc_and_blob(&reshdr, wim, rdesc, cur_blob);
+ wim->refcnt++;
}
/* cur_blob is now a blob bound to a resource. */
git://wimlib.net / wimlib / blobdiff