X-Git-Url: https://wimlib.net/git/?p=wimlib;a=blobdiff_plain;f=src%2Fhardlink.c;h=3f316f1d993d1f84fa9852fde53e9ec900ad3f09;hp=2fd3857018c19be0e21044ef37af1c7e8fcf2a99;hb=48fbbd68e82d879e2cb6f384c1440e81373338c7;hpb=7231431086332de22b2556477bcc5fc2c3e4bdcf diff --git a/src/hardlink.c b/src/hardlink.c index 2fd38570..3f316f1d 100644 --- a/src/hardlink.c +++ b/src/hardlink.c @@ -1,13 +1,11 @@ /* * hardlink.c * - * Code to deal with hard links in WIMs. Essentially, the WIM dentries are put - * into a hash table indexed by the inode ID field, then for each hard - * inode, a linked list is made to connect the dentries. + * Code to deal with hard links in WIMs. */ /* - * Copyright (C) 2012 Eric Biggers + * Copyright (C) 2012, 2013 Eric Biggers * * This file is part of wimlib, a library for working with WIM files. * @@ -25,34 +23,39 @@ * along with wimlib; if not, see http://www.gnu.org/licenses/. */ -#include "wimlib_internal.h" -#include "dentry.h" -#include "list.h" -#include "lookup_table.h" +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include "wimlib/capture.h" +#include "wimlib/dentry.h" +#include "wimlib/error.h" +#include "wimlib/lookup_table.h" /* NULL NULL * ^ ^ * dentry | | * / \ ----------- ----------- * | dentry<---| struct | | struct |---> dentry - * \ / | inode | | inode | + * \ / | wim_inode| | wim_inode| * dentry ------------ ------------ * ^ ^ * | | * | | dentry * ----------- ----------- / \ * dentry<---| struct | | struct |---> dentry dentry - * / | inode | | inode | \ / + * / | wim_inode| | wim_inode| \ / * dentry ------------ ------------ dentry * ^ ^ * | | * ----------------- - * inode_table->array | idx 0 | idx 1 | + * wim_inode_table->array | idx 0 | idx 1 | * ----------------- */ -int init_inode_table(struct inode_table *table, size_t capacity) +int +init_inode_table(struct wim_inode_table *table, size_t capacity) { table->array = CALLOC(capacity, sizeof(table->array[0])); if (!table->array) { @@ -61,74 +64,60 @@ int init_inode_table(struct inode_table *table, size_t capacity) } table->num_entries = 0; table->capacity = capacity; - INIT_HLIST_HEAD(&table->extra_inodes); + INIT_LIST_HEAD(&table->extra_inodes); return 0; } - -static size_t inode_link_count(const struct inode *inode) +static inline size_t +inode_link_count(const struct wim_inode *inode) { const struct list_head *cur; size_t size = 0; - list_for_each(cur, &inode->dentry_list) + list_for_each(cur, &inode->i_dentry) size++; return size; } -/* - * Insert a dentry into the inode table based on its inode - * ID. - * - * If there is already a dentry in the table having the same inode ID, - * and the inode ID is not 0, the dentry is added to the circular - * linked list for that inode. - * - * If the inode ID is 0, this indicates a dentry that's in a hard link - * inode by itself (has a link count of 1). We can't insert it into the hash - * table itself because we don't know what inode numbers are available to - * give it (this could be kept track of but would be more difficult). Instead - * we keep a linked list of the single dentries, and assign them inode - * numbers later. - */ -int inode_table_insert(struct dentry *dentry, void *__table) +/* Insert a dentry into the inode table based on the inode number of the + * attached inode (which came from the hard link group ID field of the on-disk + * WIM dentry) */ +static int +inode_table_insert(struct wim_dentry *dentry, void *_table) { - struct inode_table *table = __table; - struct inode *d_inode = dentry->d_inode; - - if (d_inode->ino == 0) { - /* Single inode--- Add to the list of extra inodes (we can't put - * it in the table itself because all the singles have a link - * inode ID of 0) */ - hlist_add_head(&d_inode->hlist, &table->extra_inodes); - - wimlib_assert(d_inode->dentry_list.next == &dentry->inode_dentry_list); - wimlib_assert(d_inode->dentry_list.prev == &dentry->inode_dentry_list); - wimlib_assert(d_inode->link_count == 1); + struct wim_inode_table *table = _table; + struct wim_inode *d_inode = dentry->d_inode; + + if (d_inode->i_ino == 0) { + /* A dentry with a hard link group ID of 0 indicates that it's + * in a hard link group by itself. Add it to the list of extra + * inodes rather than inserting it into the hash lists. */ + list_add_tail(&d_inode->i_list, &table->extra_inodes); } else { - /* Inode that may have multiple corresponding dentries (the code - * will work even if the inode actually contains only 1 dentry - * though) */ - size_t pos; - struct inode *inode; + struct wim_inode *inode; struct hlist_node *cur; - /* Try adding to existing inode */ - pos = d_inode->ino % table->capacity; - hlist_for_each_entry(inode, cur, &table->array[pos], hlist) { - if (inode->ino == d_inode->ino) { + /* Try adding this dentry to an existing inode */ + pos = d_inode->i_ino % table->capacity; + hlist_for_each_entry(inode, cur, &table->array[pos], i_hlist) { + if (inode->i_ino == d_inode->i_ino) { + if (unlikely((inode->i_attributes & FILE_ATTRIBUTE_DIRECTORY) || + (d_inode->i_attributes & FILE_ATTRIBUTE_DIRECTORY))) + { + ERROR("Unsupported directory hard link " + "\"%"TS"\" <=> \"%"TS"\"", + dentry_full_path(dentry), + dentry_full_path(inode_first_dentry(inode))); + return WIMLIB_ERR_INVALID_METADATA_RESOURCE; + } inode_add_dentry(dentry, inode); - inode->link_count++; return 0; } } - /* Add new inode to the table */ - hlist_add_head(&d_inode->hlist, &table->array[pos]); - - wimlib_assert(d_inode->dentry_list.next == &dentry->inode_dentry_list); - wimlib_assert(d_inode->dentry_list.prev == &dentry->inode_dentry_list); - wimlib_assert(d_inode->link_count == 1); + /* No inode in the table has the same number as this one, so add + * it to the table. */ + hlist_add_head(&d_inode->i_hlist, &table->array[pos]); /* XXX Make the table grow when too many entries have been * inserted. */ @@ -137,156 +126,230 @@ int inode_table_insert(struct dentry *dentry, void *__table) return 0; } -/* Assign the inode numbers to dentries in a inode table, and return the - * next available inode ID. */ -u64 assign_inode_numbers(struct hlist_head *inode_list) +static struct wim_inode * +inode_table_get_inode(struct wim_inode_table *table, u64 ino, u64 devno) { - DEBUG("Assigning inode numbers"); - struct inode *inode; + u64 hash = hash_u64(hash_u64(ino) + hash_u64(devno)); + size_t pos = hash % table->capacity; + struct wim_inode *inode; struct hlist_node *cur; - u64 cur_ino = 1; - hlist_for_each_entry(inode, cur, inode_list, hlist) { - inode->ino = cur_ino; - cur_ino++; + + hlist_for_each_entry(inode, cur, &table->array[pos], i_hlist) { + if (inode->i_ino == ino && inode->i_devno == devno) { + DEBUG("Using existing inode {devno=%"PRIu64", ino=%"PRIu64"}", + devno, ino); + inode->i_nlink++; + return inode; + } + } + inode = new_timeless_inode(); + if (inode) { + inode->i_ino = ino; + inode->i_devno = devno; + hlist_add_head(&inode->i_hlist, &table->array[pos]); + table->num_entries++; } - return cur_ino; + return inode; } +void +inode_ref_streams(struct wim_inode *inode) +{ + for (unsigned i = 0; i <= inode->i_num_ads; i++) { + struct wim_lookup_table_entry *lte; + lte = inode_stream_lte_resolved(inode, i); + if (lte) + lte->refcnt++; + } +} -static void print_inode_dentries(const struct inode *inode) +/* Given a directory entry with the name @name for the file with the inode + * number @ino and device number @devno, create a new WIM dentry with an + * associated inode, where the inode is shared if an inode with the same @ino + * and @devno has already been created. On success, the new WIM dentry is + * written to *dentry_ret, and its inode has i_nlink > 1 if a previously + * existing inode was used. + */ +int +inode_table_new_dentry(struct wim_inode_table *table, const tchar *name, + u64 ino, u64 devno, bool noshare, + struct wim_dentry **dentry_ret) +{ + struct wim_dentry *dentry; + struct wim_inode *inode; + int ret; + + if (noshare) { + /* File that cannot be hardlinked--- Return a new inode with its + * inode and device numbers left at 0. */ + ret = new_dentry_with_timeless_inode(name, &dentry); + if (ret) + return ret; + list_add_tail(&dentry->d_inode->i_list, &table->extra_inodes); + } else { + /* File that can be hardlinked--- search the table for an + * existing inode matching the inode number and device; + * otherwise create a new inode. */ + ret = new_dentry(name, &dentry); + if (ret) + return ret; + inode = inode_table_get_inode(table, ino, devno); + if (!inode) { + free_dentry(dentry); + return WIMLIB_ERR_NOMEM; + } + /* If using an existing inode, we need to gain a reference to + * each of its streams. */ + if (inode->i_nlink > 1) + inode_ref_streams(inode); + dentry->d_inode = inode; + inode_add_dentry(dentry, inode); + } + *dentry_ret = dentry; + return 0; +} + +static inline void +print_inode_dentries(const struct wim_inode *inode) { - struct dentry *dentry; + struct wim_dentry *dentry; inode_for_each_dentry(dentry, inode) - printf("`%s'\n", dentry->full_path_utf8); + tfprintf(stderr, T("%"TS"\n"), dentry_full_path(dentry)); } -static void inconsistent_inode(const struct inode *inode) +static void +inconsistent_inode(const struct wim_inode *inode) { - ERROR("An inconsistent hard link group that we cannot correct has been " - "detected"); - ERROR("The dentries are located at the following paths:"); - print_inode_dentries(inode); + if (wimlib_print_errors) { + ERROR("An inconsistent hard link group that cannot be corrected has " + "been detected"); + ERROR("The dentries are located at the following paths:"); + print_inode_dentries(inode); + } } -static bool ref_inodes_consistent(const struct inode * restrict ref_inode_1, - const struct inode * restrict ref_inode_2) +static bool +ref_inodes_consistent(const struct wim_inode * restrict ref_inode_1, + const struct wim_inode * restrict ref_inode_2) { wimlib_assert(ref_inode_1 != ref_inode_2); - if (ref_inode_1->num_ads != ref_inode_2->num_ads) + if (ref_inode_1->i_num_ads != ref_inode_2->i_num_ads) return false; - if (ref_inode_1->security_id != ref_inode_2->security_id - || ref_inode_1->attributes != ref_inode_2->attributes) + if (ref_inode_1->i_security_id != ref_inode_2->i_security_id + || ref_inode_1->i_attributes != ref_inode_2->i_attributes) return false; - for (unsigned i = 0; i <= ref_inode_1->num_ads; i++) { + for (unsigned i = 0; i <= ref_inode_1->i_num_ads; i++) { const u8 *ref_1_hash, *ref_2_hash; ref_1_hash = inode_stream_hash(ref_inode_1, i); ref_2_hash = inode_stream_hash(ref_inode_2, i); if (!hashes_equal(ref_1_hash, ref_2_hash)) return false; - if (i && !ads_entries_have_same_name(&ref_inode_1->ads_entries[i - 1], - &ref_inode_2->ads_entries[i - 1])) + if (i && !ads_entries_have_same_name(&ref_inode_1->i_ads_entries[i - 1], + &ref_inode_2->i_ads_entries[i - 1])) return false; } return true; } -static bool inodes_consistent(const struct inode * restrict ref_inode, - const struct inode * restrict inode) +static bool +inodes_consistent(const struct wim_inode * restrict ref_inode, + const struct wim_inode * restrict inode) { wimlib_assert(ref_inode != inode); - if (ref_inode->num_ads != inode->num_ads && - inode->num_ads != 0) + if (ref_inode->i_num_ads != inode->i_num_ads && + inode->i_num_ads != 0) return false; - if (ref_inode->security_id != inode->security_id - || ref_inode->attributes != inode->attributes) + if (ref_inode->i_security_id != inode->i_security_id + || ref_inode->i_attributes != inode->i_attributes) return false; - for (unsigned i = 0; i <= min(ref_inode->num_ads, inode->num_ads); i++) { + for (unsigned i = 0; i <= min(ref_inode->i_num_ads, inode->i_num_ads); i++) { const u8 *ref_hash, *hash; ref_hash = inode_stream_hash(ref_inode, i); hash = inode_stream_hash(inode, i); if (!hashes_equal(ref_hash, hash) && !is_zero_hash(hash)) return false; - if (i && !ads_entries_have_same_name(&ref_inode->ads_entries[i - 1], - &inode->ads_entries[i - 1])) + if (i && !ads_entries_have_same_name(&ref_inode->i_ads_entries[i - 1], + &inode->i_ads_entries[i - 1])) return false; } return true; } /* Fix up a "true" inode and check for inconsistencies */ -static int fix_true_inode(struct inode *inode, struct hlist_head *inode_list) +static int +fix_true_inode(struct wim_inode *inode, struct list_head *inode_list) { - struct dentry *dentry; - struct dentry *ref_dentry = NULL; - struct inode *ref_inode; + struct wim_dentry *dentry; + struct wim_dentry *ref_dentry = NULL; + struct wim_inode *ref_inode; u64 last_ctime = 0; u64 last_mtime = 0; u64 last_atime = 0; inode_for_each_dentry(dentry, inode) { - if (!ref_dentry || dentry->d_inode->num_ads > ref_dentry->d_inode->num_ads) + if (!ref_dentry || dentry->d_inode->i_num_ads > ref_dentry->d_inode->i_num_ads) ref_dentry = dentry; - if (dentry->d_inode->creation_time > last_ctime) - last_ctime = dentry->d_inode->creation_time; - if (dentry->d_inode->last_write_time > last_mtime) - last_mtime = dentry->d_inode->last_write_time; - if (dentry->d_inode->last_access_time > last_atime) - last_atime = dentry->d_inode->last_access_time; + if (dentry->d_inode->i_creation_time > last_ctime) + last_ctime = dentry->d_inode->i_creation_time; + if (dentry->d_inode->i_last_write_time > last_mtime) + last_mtime = dentry->d_inode->i_last_write_time; + if (dentry->d_inode->i_last_access_time > last_atime) + last_atime = dentry->d_inode->i_last_access_time; } ref_inode = ref_dentry->d_inode; - ref_inode->link_count = 1; - hlist_add_head(&ref_inode->hlist, inode_list); + wimlib_assert(ref_inode->i_nlink == 1); + list_add_tail(&ref_inode->i_list, inode_list); - list_del(&inode->dentry_list); - list_add(&ref_inode->dentry_list, &ref_dentry->inode_dentry_list); + list_del(&inode->i_dentry); + list_add(&ref_inode->i_dentry, &ref_dentry->d_alias); inode_for_each_dentry(dentry, ref_inode) { if (dentry != ref_dentry) { if (!inodes_consistent(ref_inode, dentry->d_inode)) { inconsistent_inode(ref_inode); - return WIMLIB_ERR_INVALID_DENTRY; + return WIMLIB_ERR_INVALID_METADATA_RESOURCE; } - /* Free the unneeded `struct inode'. */ + /* Free the unneeded `struct wim_inode'. */ + wimlib_assert(dentry->d_inode->i_nlink == 1); free_inode(dentry->d_inode); dentry->d_inode = ref_inode; - ref_inode->link_count++; + ref_inode->i_nlink++; } } - ref_inode->creation_time = last_ctime; - ref_inode->last_write_time = last_mtime; - ref_inode->last_access_time = last_atime; - wimlib_assert(inode_link_count(ref_inode) == ref_inode->link_count); + ref_inode->i_creation_time = last_ctime; + ref_inode->i_last_write_time = last_mtime; + ref_inode->i_last_access_time = last_atime; + wimlib_assert(inode_link_count(ref_inode) == ref_inode->i_nlink); return 0; } /* * Fixes up a nominal inode. * - * By a nominal inode we mean a group of two or more dentries that share - * the same hard link group ID. + * By a nominal inode we mean a group of two or more dentries that share the + * same hard link group ID. * * If dentries in the inode are found to be inconsistent, we may split the inode * into several "true" inodes. * * After splitting up each nominal inode into the "true" inodes we will * canonicalize the link group by getting rid of all the unnecessary `struct - * inodes'. There will be just one `struct inode' for each hard link group - * remaining. + * wim_inode's. There will be just one `struct wim_inode' for each hard link + * group remaining. */ static int -fix_nominal_inode(struct inode *inode, struct hlist_head *inode_list) +fix_nominal_inode(struct wim_inode *inode, struct list_head *inode_list, + bool *ino_changes_needed) { - struct dentry *dentry; + struct wim_dentry *dentry; struct hlist_node *cur, *tmp; int ret; size_t num_true_inodes; - wimlib_assert(inode->link_count == inode_link_count(inode)); - LIST_HEAD(dentries_with_data_streams); LIST_HEAD(dentries_with_no_data_streams); HLIST_HEAD(true_inodes); @@ -295,7 +358,7 @@ fix_nominal_inode(struct inode *inode, struct hlist_head *inode_list) * least one data stream with a non-zero hash, and another list that * contains the dentries that have a zero hash for all data streams. */ inode_for_each_dentry(dentry, inode) { - for (unsigned i = 0; i <= dentry->d_inode->num_ads; i++) { + for (unsigned i = 0; i <= dentry->d_inode->i_num_ads; i++) { const u8 *hash; hash = inode_stream_hash(dentry->d_inode, i); if (!is_zero_hash(hash)) { @@ -314,9 +377,10 @@ fix_nominal_inode(struct inode *inode, struct hlist_head *inode_list) * inode to be a true inode */ if (list_empty(&dentries_with_data_streams)) { #ifdef ENABLE_DEBUG - if (inode->link_count > 1) { + unsigned nominal_group_size = inode_link_count(inode); + if (nominal_group_size > 1) { DEBUG("Found link group of size %u without " - "any data streams:", inode->link_count); + "any data streams:", nominal_group_size); print_inode_dentries(inode); DEBUG("We are going to interpret it as true " "link group, provided that the dentries " @@ -335,16 +399,16 @@ fix_nominal_inode(struct inode *inode, struct hlist_head *inode_list) * add this dentry to it. Or, if none of the true inodes are * consistent with this dentry, add a new one (if that happens, * we have split the hard link group). */ - hlist_for_each_entry(inode, cur, &true_inodes, hlist) { + hlist_for_each_entry(inode, cur, &true_inodes, i_hlist) { if (ref_inodes_consistent(inode, dentry->d_inode)) { inode_add_dentry(dentry, inode); goto next_dentry_2; } } num_true_inodes++; - INIT_LIST_HEAD(&dentry->d_inode->dentry_list); + INIT_LIST_HEAD(&dentry->d_inode->i_dentry); inode_add_dentry(dentry, dentry->d_inode); - hlist_add_head(&dentry->d_inode->hlist, &true_inodes); + hlist_add_head(&dentry->d_inode->i_hlist, &true_inodes); next_dentry_2: ; } @@ -356,75 +420,196 @@ next_dentry_2: * streamless dentries to. */ if (!list_empty(&dentries_with_no_data_streams)) { if (num_true_inodes != 1) { - ERROR("Hard inode ambiguity detected!"); + ERROR("Hard link ambiguity detected!"); ERROR("We split up inode 0x%"PRIx64" due to " - "inconsistencies,", inode->ino); + "inconsistencies,", inode->i_ino); ERROR("but dentries with no stream information remained. " "We don't know which inode"); ERROR("to assign them to."); - return WIMLIB_ERR_INVALID_DENTRY; + ret = WIMLIB_ERR_INVALID_METADATA_RESOURCE; + goto out_cleanup_true_inode_list; } - inode = container_of(true_inodes.first, struct inode, hlist); + inode = container_of(true_inodes.first, struct wim_inode, i_hlist); /* Assign the streamless dentries to the one and only true * inode. */ list_for_each_entry(dentry, &dentries_with_no_data_streams, tmp_list) inode_add_dentry(dentry, inode); } - #ifdef ENABLE_DEBUG if (num_true_inodes != 1) { - inode = container_of(true_inodes.first, struct inode, hlist); + #ifdef ENABLE_DEBUG + inode = container_of(true_inodes.first, struct wim_inode, i_hlist); - printf("Split nominal inode 0x%"PRIx64" into %zu " - "inodes:\n", - inode->ino, num_true_inodes); - puts("------------------------------------------------------------------------------"); + tprintf(T("Split nominal inode 0x%"PRIx64" into %zu " + "inodes:\n"), inode->i_ino, num_true_inodes); + tputs(T("----------------------------------------------------" + "--------------------------")); size_t i = 1; - hlist_for_each_entry(inode, cur, &true_inodes, hlist) { - printf("[Split inode %zu]\n", i++); + hlist_for_each_entry(inode, cur, &true_inodes, i_hlist) { + tprintf(T("[Split inode %zu]\n"), i++); print_inode_dentries(inode); - putchar('\n'); + tputchar(T('\n')); } - puts("------------------------------------------------------------------------------"); - } + tputs(T("----------------------------------------------------" + "--------------------------")); #endif + *ino_changes_needed = true; + } - hlist_for_each_entry_safe(inode, cur, tmp, &true_inodes, hlist) { + hlist_for_each_entry_safe(inode, cur, tmp, &true_inodes, i_hlist) { + hlist_del_init(&inode->i_hlist); ret = fix_true_inode(inode, inode_list); - if (ret != 0) - return ret; + if (ret) + goto out_cleanup_true_inode_list; + } + ret = 0; + goto out; +out_cleanup_true_inode_list: + hlist_for_each_entry_safe(inode, cur, tmp, &true_inodes, i_hlist) + hlist_del_init(&inode->i_hlist); +out: + return ret; +} + +static int +fix_inodes(struct wim_inode_table *table, struct list_head *inode_list, + bool *ino_changes_needed) +{ + struct wim_inode *inode; + struct hlist_node *cur, *tmp; + int ret; + INIT_LIST_HEAD(inode_list); + for (u64 i = 0; i < table->capacity; i++) { + hlist_for_each_entry_safe(inode, cur, tmp, &table->array[i], i_hlist) { + hlist_del_init(&inode->i_hlist); + ret = fix_nominal_inode(inode, inode_list, ino_changes_needed); + if (ret) + return ret; + } } + list_splice_tail(&table->extra_inodes, inode_list); return 0; } /* - * Goes through each hard link group (dentries sharing the same hard link group - * ID field) that's been inserted into the inode table and shares the `struct - * inode's among members of each hard link group. + * dentry_tree_fix_inodes(): + * + * This function takes as input a tree of WIM dentries that initially has a + * different inode associated with each dentry. Sets of dentries that should + * share the same inode (a.k.a. hard link groups) are built using the i_ino + * field of each inode, then the link count and alias list for one inode in each + * set is set correctly and the unnecessary struct wim_inode's freed. The + * effect is to correctly associate exactly one struct wim_inode with each + * original inode, regardless of how many dentries are aliases for that inode. + * + * The special inode number of 0 indicates that the dentry is in a hard link + * group by itself, and therefore has a 'struct wim_inode' with i_nlink=1 to + * itself. * - * In the process, the dentries belonging to each inode are checked for - * consistency. If they contain data features that indicate they cannot really - * correspond to the same inode, this should be an error, but in reality this - * case needs to be handled, so we split the dentries into different inodes. + * This function also checks the dentries in each hard link group for + * consistency. In some WIMs, such as install.wim for some versions of Windows + * 7, dentries can share the same hard link group ID but not actually be hard + * linked to each other (based on conflicting information, such as file + * contents). This should be an error, but this case needs be handled. So, + * each "nominal" inode (the inode based on the inode numbers provided in the + * WIM) is examined for consistency and may be split into multiple "true" inodes + * that are maximally sized consistent sets of dentries. * - * After this function returns, the inodes are no longer in the inode table, and - * the inode table should be destroyed. A list of the inodes, including all - * split inodes as well as the inodes that were good before, is returned in the - * list @inode_list. + * On success, the list of "true" inodes, linked by the i_hlist field, + * is returned in the hlist @inode_list. + * + * Return values: + * WIMLIB_ERR_SUCCESS (0) + * WIMLIB_ERR_INVALID_METADATA_RESOURCE + * WIMLIB_ERR_NOMEM */ -int fix_inodes(struct inode_table *table, struct hlist_head *inode_list) +int +dentry_tree_fix_inodes(struct wim_dentry *root, struct list_head *inode_list) { - struct inode *inode; - struct hlist_node *cur, *tmp; + struct wim_inode_table inode_tab; int ret; - INIT_HLIST_HEAD(inode_list); - for (u64 i = 0; i < table->capacity; i++) { - hlist_for_each_entry_safe(inode, cur, tmp, &table->array[i], hlist) { - ret = fix_nominal_inode(inode, inode_list); - if (ret != 0) - return ret; + bool ino_changes_needed; + struct wim_inode *inode; + + DEBUG("Inserting dentries into inode table"); + ret = init_inode_table(&inode_tab, 9001); + if (ret) + goto out; + + ret = for_dentry_in_tree(root, inode_table_insert, &inode_tab); + if (ret) + goto out_destroy_inode_table; + + DEBUG("Cleaning up the hard link groups"); + ino_changes_needed = false; + ret = fix_inodes(&inode_tab, inode_list, &ino_changes_needed); + if (ret) + goto out_destroy_inode_table; + + if (ino_changes_needed) { + u64 cur_ino = 1; + + WARNING("Re-assigning inode numbers due to inode inconsistencies"); + list_for_each_entry(inode, inode_list, i_list) { + if (inode->i_nlink > 1) + inode->i_ino = cur_ino++; + else + inode->i_ino = 0; } } - hlist_for_each_safe(cur, tmp, &table->extra_inodes) - hlist_add_head(cur, inode_list); - return 0; + /* On success, all the inodes have been moved to the image inode list, + * so there's no need to delete from from the hash lists in the inode + * table before freeing the hash buckets array directly. */ + ret = 0; + goto out_destroy_inode_table_raw; +out_destroy_inode_table: + for (size_t i = 0; i < inode_tab.capacity; i++) { + struct hlist_node *cur, *tmp; + hlist_for_each_entry_safe(inode, cur, tmp, &inode_tab.array[i], i_hlist) + hlist_del_init(&inode->i_hlist); + } + { + struct wim_inode *tmp; + list_for_each_entry_safe(inode, tmp, &inode_tab.extra_inodes, i_list) + list_del_init(&inode->i_list); + } +out_destroy_inode_table_raw: + destroy_inode_table(&inode_tab); +out: + return ret; +} + +/* Assign consecutive inode numbers to a new set of inodes from the inode table, + * and append the inodes to a single list @head that contains the inodes already + * existing in the WIM image. */ +void +inode_table_prepare_inode_list(struct wim_inode_table *table, + struct list_head *head) +{ + struct wim_inode *inode, *tmp_inode; + struct hlist_node *cur, *tmp; + u64 cur_ino = 1; + + /* Re-assign inode numbers in the existing list to avoid duplicates. */ + list_for_each_entry(inode, head, i_list) + inode->i_ino = cur_ino++; + + /* Assign inode numbers to the new inodes and move them to the image's + * inode list. */ + for (size_t i = 0; i < table->capacity; i++) { + hlist_for_each_entry_safe(inode, cur, tmp, &table->array[i], i_hlist) + { + inode->i_ino = cur_ino++; + inode->i_devno = 0; + list_add_tail(&inode->i_list, head); + } + INIT_HLIST_HEAD(&table->array[i]); + } + list_for_each_entry_safe(inode, tmp_inode, &table->extra_inodes, i_list) + { + inode->i_ino = cur_ino++; + inode->i_devno = 0; + list_add_tail(&inode->i_list, head); + } + INIT_LIST_HEAD(&table->extra_inodes); + table->num_entries = 0; }