X-Git-Url: https://wimlib.net/git/?p=wimlib;a=blobdiff_plain;f=include%2Fwimlib%2Flookup_table.h;h=f0cfb768f1e92410f022180c1c3393f9d1d04e62;hp=aad400deb2d556584cd3a2704729e13c2e00cb41;hb=7cfb9777313e1a2f60a49d6b9ef87910f27f1a51;hpb=26ba6eaef7f310b682513696930013225f658044 diff --git a/include/wimlib/lookup_table.h b/include/wimlib/lookup_table.h index aad400de..f0cfb768 100644 --- a/include/wimlib/lookup_table.h +++ b/include/wimlib/lookup_table.h @@ -49,51 +49,50 @@ struct ntfs_location { * * If we open a WIM and read its lookup table, the location is set to * RESOURCE_IN_WIM since all the streams will initially be located in the WIM. - * However, to deal with problems such as image capture and image mount, we - * allow the actual location of the stream to be somewhere else, such as an - * external file. + * However, to handle situations such as image capture and image mount, we allow + * the actual location of the stream to be somewhere else, such as an external + * file. */ enum resource_location { - /* The lookup table entry does not correspond to a stream (this state - * should exist only temporarily) */ + /* The lookup table entry does not yet correspond to a stream; this is a + * temporary state only. */ RESOURCE_NONEXISTENT = 0, - /* The stream resource is located in a WIM file. The WIMStruct for the - * WIM file will be pointed to by the @wim member. */ + /* The stream is located in a resource in a WIM file identified by the + * `struct wim_resource_spec' pointed to by @rspec. @offset_in_res + * identifies the offset at which this particular stream begins in the + * uncompressed data of the resource; this is normally 0, but in general + * a WIM resource may contain multiple streams. */ RESOURCE_IN_WIM, -#ifndef __WIN32__ - /* The stream resource is located in an external file. The name of the - * file will be provided by @file_on_disk member. */ + /* The stream is located in the external file named by @file_on_disk. + * On Windows, @file_on_disk may actually specify a named data stream. + */ RESOURCE_IN_FILE_ON_DISK, -#endif - /* The stream resource is directly attached in an in-memory buffer - * pointed to by @attached_buffer. */ + /* The stream is directly attached in the in-memory buffer pointed to by + * @attached_buffer. */ RESOURCE_IN_ATTACHED_BUFFER, #ifdef WITH_FUSE - /* The stream resource is located in an external file in the staging - * directory for a read-write mount. */ + /* The stream is located in the external file named by + * @staging_file_name, located in the staging directory for a read-write + * mount. */ RESOURCE_IN_STAGING_FILE, #endif #ifdef WITH_NTFS_3G - /* The stream resource is located in an NTFS volume. It is identified - * by volume, filename, data stream name, and by whether it is a reparse - * point or not. @ntfs_loc points to a structure containing this - * information. */ + /* The stream is located in an NTFS volume. It is identified by volume, + * filename, data stream name, and by whether it is a reparse point or + * not. @ntfs_loc points to a structure containing this information. + * */ RESOURCE_IN_NTFS_VOLUME, #endif #ifdef __WIN32__ - /* Resource must be accessed using Win32 API (may be a named data - * stream) */ - RESOURCE_WIN32, - - /* Windows only: the file is on disk in the file named @file_on_disk, - * but the file is encrypted and must be read using special functions. - * */ + /* Windows only: the stream is located in the external file named by + * @file_on_disk, but the file is encrypted and must be read using the + * appropriate Windows API. */ RESOURCE_WIN32_ENCRYPTED, #endif @@ -115,56 +114,54 @@ struct wim_lookup_table_entry { /* List of lookup table entries in this hash bucket */ struct hlist_node hash_list; - /* Location and size of the stream in the WIM, whether it is compressed - * or not, and whether it's a metadata resource or not. This is an - * on-disk field. */ - struct resource_entry resource_entry; - - /* Specifies which part of the split WIM the resource is located in. - * This is on on-disk field. - * - * In stand-alone WIMs, this must be 1. - * - * In split WIMs, every split WIM part has its own lookup table, and in - * read_lookup_table() it's currently expected that the part number of - * each lookup table entry in a split WIM part's lookup table is the - * same as the part number of that split WIM part. So this makes this - * field redundant since we store a pointer to the corresponding - * WIMStruct in the lookup table entry anyway. - */ - u16 part_number; + /* Uncompressed size of the stream. */ + u64 size; + + /* Stream flags (WIM_RESHDR_FLAG_*). */ + u16 flags : 8; /* One of the `enum resource_location' values documented above. */ u16 resource_location : 5; /* 1 if this stream is a unique size (only set while writing streams). */ - u8 unique_size : 1; + u16 unique_size : 1; /* 1 if this stream has not had a SHA1 message digest calculated for it * yet */ - u8 unhashed : 1; + u16 unhashed : 1; + + u16 deferred : 1; + + u16 no_progress : 1; - u8 deferred : 1; + /* Set to 1 when a metadata entry has its checksum changed; in such + * cases the hash is no longer valid to verify the data if the metadata + * resource is read again. */ + u16 dont_check_metadata_hash : 1; - u8 no_progress : 1; + /* Only used during WIM write. Normal value is 0 (resource not + * filtered). */ + u16 filtered : 2; +#define FILTERED_SAME_WIM 0x1 /* Resource already in same WIM */ +#define FILTERED_EXTERNAL_WIM 0x2 /* Resource already in external WIM */ /* (On-disk field) * Number of times this lookup table entry is referenced by dentries. * Unfortunately, this field is not always set correctly in Microsoft's * WIMs, so we have no choice but to fix it if more references to the - * lookup table entry are found than stated here. */ + * lookup table entry are found than stated here. */ u32 refcnt; union { /* (On-disk field) SHA1 message digest of the stream referenced - * by this lookup table entry */ + * by this lookup table entry. */ u8 hash[SHA1_HASH_SIZE]; /* First 4 or 8 bytes of the SHA1 message digest, used for * inserting the entry into the hash table. Since the SHA1 * message digest can be considered random, we don't really need * the full 20 byte hash just to insert the entry in a hash - * table. */ + * table. */ size_t hash_short; /* Unhashed entries only (unhashed == 1): these variables make @@ -188,7 +185,10 @@ struct wim_lookup_table_entry { /* Pointers to somewhere where the stream is actually located. See the * comments for the @resource_location field above. */ union { - WIMStruct *wim; + struct { + struct wim_resource_spec *rspec; + u64 offset_in_res; + }; tchar *file_on_disk; void *attached_buffer; #ifdef WITH_FUSE @@ -217,69 +217,69 @@ struct wim_lookup_table_entry { tchar *extracted_file; }; + /* Temporary fields */ union { - /* When a WIM file is written, @output_resource_entry is filled - * in with the resource entry for the output WIM. This will not - * necessarily be the same as the @resource_entry since: - * - The stream may have a different offset in the new WIM - * - The stream may have a different compressed size in the new - * WIM if the compression type changed - */ - struct resource_entry output_resource_entry; + /* Used temporarily during WIM file writing */ + struct { + struct hlist_node hash_list_2; + + /* Links streams being written to the WIM. */ + struct list_head write_streams_list; + }; + /* Used temporarily during WIM file writing (after above) */ struct { struct list_head msg_list; struct list_head being_compressed_list; }; - struct list_head lte_dentry_list; - - struct { - struct hlist_node hash_list_2; - struct list_head write_streams_list; + /* When a WIM file is written, @output_reshdr is filled in with + * the resource header for the output WIM. */ + struct wim_reshdr out_reshdr; + + /* Used temporarily during extraction */ + union { + /* out_refcnt tracks number of slots filled */ + struct wim_dentry *inline_lte_dentries[4]; + struct { + struct wim_dentry **lte_dentries; + unsigned long alloc_lte_dentries; + }; }; }; /* Temporary list fields */ union { - struct list_head unhashed_list; - struct list_head swm_stream_list; + /* Links streams when writing lookup table. */ struct list_head lookup_table_list; + + /* Links streams being extracted. */ struct list_head extraction_list; + + /* Links streams being exported. */ struct list_head export_stream_list; }; -}; -static inline u64 -wim_resource_size(const struct wim_lookup_table_entry *lte) -{ - return lte->resource_entry.original_size; -} + /* Links streams that are still unhashed after being been added + * to a WIM. */ + struct list_head unhashed_list; -static inline u64 -wim_resource_chunks(const struct wim_lookup_table_entry *lte) -{ - return DIV_ROUND_UP(wim_resource_size(lte), WIM_CHUNK_SIZE); -} + struct list_head wim_resource_list; +}; -static inline u64 -wim_resource_compressed_size(const struct wim_lookup_table_entry *lte) +static inline bool +lte_is_partial(const struct wim_lookup_table_entry * lte) { - return lte->resource_entry.size; + return lte->resource_location == RESOURCE_IN_WIM && + lte->size != lte->rspec->uncompressed_size; } -extern int -wim_resource_compression_type(const struct wim_lookup_table_entry *lte); - static inline bool lte_filename_valid(const struct wim_lookup_table_entry *lte) { - return 0 + return lte->resource_location == RESOURCE_IN_FILE_ON_DISK #ifdef __WIN32__ - || lte->resource_location == RESOURCE_WIN32 || lte->resource_location == RESOURCE_WIN32_ENCRYPTED - #else - || lte->resource_location == RESOURCE_IN_FILE_ON_DISK #endif #ifdef WITH_FUSE || lte->resource_location == RESOURCE_IN_STAGING_FILE @@ -291,15 +291,12 @@ extern struct wim_lookup_table * new_lookup_table(size_t capacity) _malloc_attribute; extern int -read_lookup_table(WIMStruct *w); - -extern int -write_lookup_table(WIMStruct *w, int image, struct resource_entry *out_res_entry); +read_wim_lookup_table(WIMStruct *wim); extern int -write_lookup_table_from_stream_list(struct list_head *stream_list, - int out_fd, - struct resource_entry *out_res_entry); +write_wim_lookup_table(WIMStruct *wim, int image, int write_flags, + struct wim_reshdr *out_reshdr, + struct list_head *stream_list_override); extern void free_lookup_table(struct wim_lookup_table *table); @@ -325,19 +322,23 @@ clone_lookup_table_entry(const struct wim_lookup_table_entry *lte) _malloc_attribute; extern void -print_lookup_table_entry(const struct wim_lookup_table_entry *entry, - FILE *out); +print_lookup_table_entry(const struct wim_lookup_table_entry *lte, FILE *out); extern void free_lookup_table_entry(struct wim_lookup_table_entry *lte); +extern void +lte_to_wimlib_resource_entry(const struct wim_lookup_table_entry *lte, + struct wimlib_resource_entry *wentry); + extern int for_lookup_table_entry(struct wim_lookup_table *table, int (*visitor)(struct wim_lookup_table_entry *, void *), void *arg); extern int -cmp_streams_by_wim_position(const void *p1, const void *p2); +sort_stream_list_by_sequential_order(struct list_head *stream_list, + size_t list_head_offset); extern int for_lookup_table_entry_pos_sorted(struct wim_lookup_table *table, @@ -346,12 +347,14 @@ for_lookup_table_entry_pos_sorted(struct wim_lookup_table *table, void *arg); extern struct wim_lookup_table_entry * -__lookup_resource(const struct wim_lookup_table *table, const u8 hash[]); +lookup_resource(const struct wim_lookup_table *table, const u8 hash[]); extern int -lookup_resource(WIMStruct *w, const tchar *path, - int lookup_flags, struct wim_dentry **dentry_ret, - struct wim_lookup_table_entry **lte_ret, u16 *stream_idx_ret); +wim_pathname_to_stream(WIMStruct *wim, const tchar *path, + int lookup_flags, + struct wim_dentry **dentry_ret, + struct wim_lookup_table_entry **lte_ret, + u16 *stream_idx_ret); extern void lte_decrement_refcnt(struct wim_lookup_table_entry *lte, @@ -362,16 +365,37 @@ lte_decrement_num_opened_fds(struct wim_lookup_table_entry *lte); #endif extern int -lte_zero_out_refcnt(struct wim_lookup_table_entry *entry, void *ignore); +lte_zero_out_refcnt(struct wim_lookup_table_entry *lte, void *ignore); extern int -lte_zero_real_refcnt(struct wim_lookup_table_entry *entry, void *ignore); +lte_zero_real_refcnt(struct wim_lookup_table_entry *lte, void *ignore); extern int lte_free_extracted_file(struct wim_lookup_table_entry *lte, void *ignore); +static inline void +lte_bind_wim_resource_spec(struct wim_lookup_table_entry *lte, + struct wim_resource_spec *rspec) +{ + lte->resource_location = RESOURCE_IN_WIM; + lte->rspec = rspec; + list_add_tail(<e->wim_resource_list, &rspec->stream_list); +} + +static inline void +lte_unbind_wim_resource_spec(struct wim_lookup_table_entry *lte) +{ + list_del(<e->wim_resource_list); + lte->rspec = NULL; + lte->resource_location = RESOURCE_NONEXISTENT; +} + +extern int +inode_resolve_ltes(struct wim_inode *inode, struct wim_lookup_table *table, + bool force); + extern int -inode_resolve_ltes(struct wim_inode *inode, struct wim_lookup_table *table); +resource_not_found_error(const struct wim_inode *inode, const u8 *hash); extern void inode_unresolve_ltes(struct wim_inode *inode); @@ -396,9 +420,9 @@ inode_stream_lte_unresolved(const struct wim_inode *inode, unsigned stream_idx, if (!table) return NULL; if (stream_idx == 0) - return __lookup_resource(table, inode->i_hash); + return lookup_resource(table, inode->i_hash); else - return __lookup_resource(table, + return lookup_resource(table, inode->i_ads_entries[ stream_idx - 1].hash); } @@ -456,6 +480,9 @@ inode_stream_name_nbytes(const struct wim_inode *inode, unsigned stream_idx) return inode->i_ads_entries[stream_idx - 1].stream_name_nbytes; } +extern struct wim_lookup_table_entry * +inode_unnamed_stream_resolved(const struct wim_inode *inode, u16 *stream_idx_ret); + extern struct wim_lookup_table_entry * inode_unnamed_lte_resolved(const struct wim_inode *inode); @@ -466,9 +493,8 @@ inode_unnamed_lte_unresolved(const struct wim_inode *inode, extern struct wim_lookup_table_entry * inode_unnamed_lte(const struct wim_inode *inode, const struct wim_lookup_table *table); -extern u64 -lookup_table_total_stream_size(struct wim_lookup_table *table); - +extern const u8 * +inode_unnamed_stream_hash(const struct wim_inode *inode); static inline void lookup_table_insert_unhashed(struct wim_lookup_table *table,