X-Git-Url: https://wimlib.net/git/?p=wimlib;a=blobdiff_plain;f=src%2Fhardlink.c;h=3f316f1d993d1f84fa9852fde53e9ec900ad3f09;hp=53d03ecde00f4f41fef58dece3460526bf580d9d;hb=48fbbd68e82d879e2cb6f384c1440e81373338c7;hpb=bb40342796df9c677f6903b596abf4e9e5769845 diff --git a/src/hardlink.c b/src/hardlink.c index 53d03ecd..3f316f1d 100644 --- a/src/hardlink.c +++ b/src/hardlink.c @@ -23,10 +23,14 @@ * 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 * ^ ^ @@ -88,10 +92,6 @@ inode_table_insert(struct wim_dentry *dentry, void *_table) * 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); - - wimlib_assert(d_inode->i_dentry.next == &dentry->d_alias); - wimlib_assert(d_inode->i_dentry.prev == &dentry->d_alias); - wimlib_assert(d_inode->i_nlink == 1); } else { size_t pos; struct wim_inode *inode; @@ -101,8 +101,16 @@ inode_table_insert(struct wim_dentry *dentry, void *_table) 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->i_nlink++; return 0; } } @@ -111,10 +119,6 @@ inode_table_insert(struct wim_dentry *dentry, void *_table) * it to the table. */ hlist_add_head(&d_inode->i_hlist, &table->array[pos]); - wimlib_assert(d_inode->i_dentry.next == &dentry->d_alias); - wimlib_assert(d_inode->i_dentry.prev == &dentry->d_alias); - wimlib_assert(d_inode->i_nlink == 1); - /* XXX Make the table grow when too many entries have been * inserted. */ table->num_entries++; @@ -176,11 +180,16 @@ inode_table_new_dentry(struct wim_inode_table *table, const tchar *name, 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; @@ -189,6 +198,8 @@ inode_table_new_dentry(struct wim_inode_table *table, const tchar *name, 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; @@ -198,25 +209,23 @@ inode_table_new_dentry(struct wim_inode_table *table, const tchar *name, return 0; } -#if defined(ENABLE_ERROR_MESSAGES) || defined(ENABLE_DEBUG) -static void +static inline void print_inode_dentries(const struct wim_inode *inode) { struct wim_dentry *dentry; inode_for_each_dentry(dentry, inode) tfprintf(stderr, T("%"TS"\n"), dentry_full_path(dentry)); } -#endif static void inconsistent_inode(const struct wim_inode *inode) { -#ifdef ENABLE_ERROR_MESSAGES - 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); -#endif + 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 @@ -292,7 +301,7 @@ fix_true_inode(struct wim_inode *inode, struct list_head *inode_list) } ref_inode = ref_dentry->d_inode; - ref_inode->i_nlink = 1; + wimlib_assert(ref_inode->i_nlink == 1); list_add_tail(&ref_inode->i_list, inode_list); list_del(&inode->i_dentry); @@ -302,9 +311,10 @@ fix_true_inode(struct wim_inode *inode, struct list_head *inode_list) 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 wim_inode'. */ + wimlib_assert(dentry->d_inode->i_nlink == 1); free_inode(dentry->d_inode); dentry->d_inode = ref_inode; ref_inode->i_nlink++; @@ -340,8 +350,6 @@ fix_nominal_inode(struct wim_inode *inode, struct list_head *inode_list, int ret; size_t num_true_inodes; - wimlib_assert(inode->i_nlink == inode_link_count(inode)); - LIST_HEAD(dentries_with_data_streams); LIST_HEAD(dentries_with_no_data_streams); HLIST_HEAD(true_inodes); @@ -369,9 +377,10 @@ fix_nominal_inode(struct wim_inode *inode, struct list_head *inode_list, * inode to be a true inode */ if (list_empty(&dentries_with_data_streams)) { #ifdef ENABLE_DEBUG - if (inode->i_nlink > 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->i_nlink); + "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 " @@ -411,13 +420,14 @@ 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->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 wim_inode, i_hlist); /* Assign the streamless dentries to the one and only true @@ -446,11 +456,18 @@ next_dentry_2: } 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) - return ret; + goto out_cleanup_true_inode_list; } - return 0; + 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 @@ -463,7 +480,7 @@ fix_inodes(struct wim_inode_table *table, struct list_head *inode_list, 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) { - INIT_LIST_HEAD(&inode->i_list); + hlist_del_init(&inode->i_hlist); ret = fix_nominal_inode(inode, inode_list, ino_changes_needed); if (ret) return ret; @@ -497,9 +514,13 @@ fix_inodes(struct wim_inode_table *table, struct list_head *inode_list, * WIM) is examined for consistency and may be split into multiple "true" inodes * that are maximally sized consistent sets of dentries. * - * Return 0 on success; WIMLIB_ERR_NOMEM or WIMLIB_ERR_INVALID_DENTRY on - * failure. On success, the list of "true" inodes, linked by the i_hlist field, + * 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 dentry_tree_fix_inodes(struct wim_dentry *root, struct list_head *inode_list) @@ -507,22 +528,25 @@ dentry_tree_fix_inodes(struct wim_dentry *root, struct list_head *inode_list) struct wim_inode_table inode_tab; int ret; bool ino_changes_needed; + struct wim_inode *inode; DEBUG("Inserting dentries into inode table"); ret = init_inode_table(&inode_tab, 9001); if (ret) - return ret; + goto out; - for_dentry_in_tree(root, inode_table_insert, &inode_tab); + 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); - destroy_inode_table(&inode_tab); + if (ret) + goto out_destroy_inode_table; - if (ret == 0 && ino_changes_needed) { + if (ino_changes_needed) { u64 cur_ino = 1; - struct wim_inode *inode; WARNING("Re-assigning inode numbers due to inode inconsistencies"); list_for_each_entry(inode, inode_list, i_list) { @@ -532,38 +556,60 @@ dentry_tree_fix_inodes(struct wim_dentry *root, struct list_head *inode_list) inode->i_ino = 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 the inodes in the inode table, and move - * the inodes to a single list @head. */ +/* 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; + struct wim_inode *inode, *tmp_inode; struct hlist_node *cur, *tmp; u64 cur_ino = 1; - list_for_each_entry(inode, head, i_list) { - if (inode->i_nlink > 1) - inode->i_ino = cur_ino++; - else - inode->i_ino = 0; - list_add_tail(&inode->i_list, head); - } + /* 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) { - if (inode->i_nlink > 1) - inode->i_ino = cur_ino++; - else - inode->i_ino = 0; + inode->i_ino = cur_ino++; + inode->i_devno = 0; list_add_tail(&inode->i_list, head); } INIT_HLIST_HEAD(&table->array[i]); } - list_splice_tail(&table->extra_inodes, head); + 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; }