link_group_set_stream_hash(), staging_list

diff --git a/src/header.c b/src/header.c
index c68514322bbbebebc6f69fa7429c8f8985468b39..7a9d5fd0810420c12aed71b85137873cd39da9ac 100644 (file)
--- a/src/header.c
+++ b/src/header.c
@@ -184,6 +184,7 @@ int write_header(const struct wim_header *hdr, FILE *out_fp)
                ERROR_WITH_ERRNO("Failed to write WIM header");
                return WIMLIB_ERR_WRITE;
        }
                ERROR_WITH_ERRNO("Failed to write WIM header");
                return WIMLIB_ERR_WRITE;
        }

+       DEBUG("Done writing WIM header");

        return 0;
 }
 
        return 0;
 }
 

diff --git a/src/lookup_table.c b/src/lookup_table.c
index bb6e2b52e27d9866e462b9368d424f1b1f1effaf..d3ed585445a225f53b91e82e7d437d127f9560ee 100644 (file)
--- a/src/lookup_table.c
+++ b/src/lookup_table.c
@@ -70,6 +70,15 @@ struct lookup_table_entry *new_lookup_table_entry()
 }
 
 
 }
 
 

+void free_lookup_table_entry(struct lookup_table_entry *lte)
+{
+       if (lte) {
+               if (lte->staging_list.next)
+                       list_del(&lte->staging_list);
+               FREE(lte->file_on_disk);
+               FREE(lte);
+       }
+}

 
 /*
  * Inserts an entry into the lookup table.
 
 /*
  * Inserts an entry into the lookup table.


@@ -362,11 +371,12 @@ int lookup_resource(WIMStruct *w, const char *path,
                    int lookup_flags,
                    struct dentry **dentry_ret,
                    struct lookup_table_entry **lte_ret,
                    int lookup_flags,
                    struct dentry **dentry_ret,
                    struct lookup_table_entry **lte_ret,

-                   u8 **hash_ret)
+                   unsigned *stream_idx_ret)

 {
        struct dentry *dentry = get_dentry(w, path);
        struct lookup_table_entry *lte;
 {
        struct dentry *dentry = get_dentry(w, path);
        struct lookup_table_entry *lte;

-       u8 *hash;
+       unsigned stream_idx = 0;
+       const u8 *hash = dentry->hash;

        if (!dentry)
                return -ENOENT;
        if (!(lookup_flags & LOOKUP_FLAG_DIRECTORY_OK)
        if (!dentry)
                return -ENOENT;
        if (!(lookup_flags & LOOKUP_FLAG_DIRECTORY_OK)


@@ -381,6 +391,7 @@ int lookup_resource(WIMStruct *w, const char *path,
                                                       stream_name,
                                                       stream_name_len))
                                {
                                                       stream_name,
                                                       stream_name_len))
                                {

+                                       stream_idx = i + 1;

                                        hash = dentry->ads_entries[i].hash;
                                        goto do_lookup;
                                }
                                        hash = dentry->ads_entries[i].hash;
                                        goto do_lookup;
                                }


@@ -388,14 +399,13 @@ int lookup_resource(WIMStruct *w, const char *path,
                        return -ENOENT;
                }
        }
                        return -ENOENT;
                }
        }

-       hash = dentry->hash;

 do_lookup:
        lte = __lookup_resource(w->lookup_table, hash);
        if (dentry_ret)
                *dentry_ret = dentry;
        if (lte_ret)
                *lte_ret = lte;
 do_lookup:
        lte = __lookup_resource(w->lookup_table, hash);
        if (dentry_ret)
                *dentry_ret = dentry;
        if (lte_ret)
                *lte_ret = lte;

-       if (hash_ret)
-               *hash_ret = hash;
+       if (stream_idx_ret)
+               *stream_idx_ret = stream_idx;

        return 0;
 }
        return 0;
 }

diff --git a/src/lookup_table.h b/src/lookup_table.h
index 434b9d89a48bb5d39e388480c379a820bd6df1c2..df780a09e8ede3540fb5cf7a892d55a3f5165147 100644 (file)
--- a/src/lookup_table.h
+++ b/src/lookup_table.h
@@ -38,14 +38,14 @@ struct lookup_table_entry {
        /* Currently ignored; set to 1 in new lookup table entries. */
        u16 part_number;
 
        /* Currently ignored; set to 1 in new lookup table entries. */
        u16 part_number;
 

-       /* Number of times this lookup table entry is referenced by dentries. */
-       u32 refcnt;
-

        /* If %true, this lookup table entry corresponds to a symbolic link
         * reparse buffer.  @symlink_reparse_data_buf will give the target of
         * the symbolic link. */
        bool is_symlink;
 
        /* If %true, this lookup table entry corresponds to a symbolic link
         * reparse buffer.  @symlink_reparse_data_buf will give the target of
         * the symbolic link. */
        bool is_symlink;
 

+       /* Number of times this lookup table entry is referenced by dentries. */
+       u32 refcnt;
+

        union {
                /* SHA1 hash of the file resource pointed to by this lookup
                 * table entry */
        union {
                /* SHA1 hash of the file resource pointed to by this lookup
                 * table entry */


@@ -99,11 +99,11 @@ struct lookup_table_entry {
         *
         * output_resource_entry is the struct resource_entry for the position of the
         * file resource when written to the output file. */
         *
         * output_resource_entry is the struct resource_entry for the position of the
         * file resource when written to the output file. */

+       u32 out_refcnt;

        union {
        union {

-               u32 out_refcnt;
-               bool refcnt_is_incremented;
+               struct resource_entry output_resource_entry;
+               struct list_head staging_list;

        };
        };

-       struct resource_entry output_resource_entry;

        struct dentry *hard_link_sets;
 };
 
        struct dentry *hard_link_sets;
 };
 


@@ -131,7 +131,7 @@ __lookup_resource(const struct lookup_table *lookup_table, const u8 hash[]);
 extern int lookup_resource(WIMStruct *w, const char *path,
                           int lookup_flags, struct dentry **dentry_ret,
                           struct lookup_table_entry **lte_ret,
 extern int lookup_resource(WIMStruct *w, const char *path,
                           int lookup_flags, struct dentry **dentry_ret,
                           struct lookup_table_entry **lte_ret,

-                          u8 **hash_ret);
+                          unsigned *stream_idx_ret);

 
 extern int zero_out_refcnts(struct lookup_table_entry *entry, void *ignore);
 
 
 extern int zero_out_refcnts(struct lookup_table_entry *entry, void *ignore);
 


@@ -144,13 +144,7 @@ extern void free_lookup_table(struct lookup_table *table);
 
 extern int write_lookup_table_entry(struct lookup_table_entry *lte, void *__out);
 
 
 extern int write_lookup_table_entry(struct lookup_table_entry *lte, void *__out);
 

-static inline void free_lookup_table_entry(struct lookup_table_entry *lte)
-{
-       if (lte) {
-               FREE(lte->file_on_disk);
-               FREE(lte);
-       }
-}
+extern void free_lookup_table_entry(struct lookup_table_entry *lte);

 
 /* Writes the lookup table to the output file. */
 static inline int write_lookup_table(struct lookup_table *table, FILE *out)
 
 /* Writes the lookup table to the output file. */
 static inline int write_lookup_table(struct lookup_table *table, FILE *out)

diff --git a/src/mount.c b/src/mount.c
index 5a2b6b73441d091e1062a6ca03c93a62dbb949d6..fd386a8e8c5277a9c725c796d26f9dab49155a07 100644 (file)
--- a/src/mount.c
+++ b/src/mount.c
@@ -77,6 +77,8 @@ static const char *mount_dir;
  * numbers. */
 static u64 next_link_group_id;
 
  * numbers. */
 static u64 next_link_group_id;
 

+/* List of lookup table entries in the staging directory */
+static LIST_HEAD(staging_list);

 
 static inline int get_lookup_flags()
 {
 
 static inline int get_lookup_flags()
 {


@@ -192,6 +194,32 @@ static void dentry_increment_lookup_table_refcnts(struct dentry *dentry,
        }
 }
 
        }
 }
 

+/* Change the hash value of the main or alternate file stream in a hard link
+ * group.  This needs to be done if the hash of the corresponding lookup table
+ * entry was changed. */
+static void link_group_set_stream_hash(struct dentry *dentry,
+                                      unsigned stream_idx,
+                                      const u8 new_hash[])
+{
+       struct list_head *head, *cur;
+
+       if (stream_idx == 0) {
+               head = &dentry->link_group_list;
+               cur = head;
+               do {
+                       dentry = container_of(cur, struct dentry, link_group_list);
+                       memcpy(dentry->hash, new_hash, WIM_HASH_SIZE);
+                       cur = cur->next;
+               } while (cur != head);
+       } else {
+               /* Dentries in the link group share their alternate stream
+                * entries. */
+               wimlib_assert(stream_idx <= dentry->num_ads);
+               memcpy(dentry->ads_entries[stream_idx - 1].hash, new_hash,
+                      WIM_HASH_SIZE);
+       }
+}
+

 /* Creates a new staging file and returns its file descriptor opened for
  * writing.
  *
 /* Creates a new staging file and returns its file descriptor opened for
  * writing.
  *


@@ -359,6 +387,8 @@ static int extract_resource_to_staging_dir(struct dentry *dentry,
                        new_lte->num_allocated_fds = num_transferred_fds;
                } 
        } else {
                        new_lte->num_allocated_fds = num_transferred_fds;
                } 
        } else {

+               /* No old_lte was supplied, so the resource had no lookup table
+                * entry before (it must be an empty resource) */

                new_lte = new_lookup_table_entry();
                if (!new_lte) {
                        ret = -ENOMEM;
                new_lte = new_lookup_table_entry();
                if (!new_lte) {
                        ret = -ENOMEM;


@@ -371,6 +401,7 @@ static int extract_resource_to_staging_dir(struct dentry *dentry,
        new_lte->staging_file_name = staging_file_name;
 
        lookup_table_insert(w->lookup_table, new_lte);
        new_lte->staging_file_name = staging_file_name;
 
        lookup_table_insert(w->lookup_table, new_lte);

+       list_add(&new_lte->staging_list, &staging_list);

        *lte = new_lte;
        return 0;
 out_delete_staging_file:
        *lte = new_lte;
        return 0;
 out_delete_staging_file:


@@ -613,15 +644,16 @@ static int wimfs_access(const char *path, int mask)
 
 /* Closes the staging file descriptor associated with the lookup table entry, if
  * it is opened. */
 
 /* Closes the staging file descriptor associated with the lookup table entry, if
  * it is opened. */

-static int close_lte_fds(struct lookup_table_entry *lte, void *ignore)
+static int close_lte_fds(struct lookup_table_entry *lte)

 {
 {

-       for (u16 i = 0; i < lte->num_opened_fds; i++) {
+       for (u16 i = 0, j = 0; j < lte->num_opened_fds; i++) {

                if (lte->fds[i] && lte->fds[i]->staging_fd != -1) {
                        if (close(lte->fds[i]->staging_fd) != 0) {
                                ERROR_WITH_ERRNO("Failed close file `%s'",
                                                 lte->staging_file_name);
                                return WIMLIB_ERR_WRITE;
                        }
                if (lte->fds[i] && lte->fds[i]->staging_fd != -1) {
                        if (close(lte->fds[i]->staging_fd) != 0) {
                                ERROR_WITH_ERRNO("Failed close file `%s'",
                                                 lte->staging_file_name);
                                return WIMLIB_ERR_WRITE;
                        }

+                       j++;

                }
        }
        return 0;
                }
        }
        return 0;


@@ -632,10 +664,10 @@ static int close_lte_fds(struct lookup_table_entry *lte, void *ignore)
  * file.  Updates the SHA1 sum in the dentry and the lookup table entry.  If
  * there is already a lookup table entry with the same checksum, increment its
  * reference count and destroy the lookup entry with the updated checksum. */
  * file.  Updates the SHA1 sum in the dentry and the lookup table entry.  If
  * there is already a lookup table entry with the same checksum, increment its
  * reference count and destroy the lookup entry with the updated checksum. */

-static int calculate_sha1sum_for_staging_file(struct dentry *dentry,
-                                             void *_lookup_table)
+static int calculate_sha1sum_of_staging_file(struct dentry *dentry,
+                                            void *__lookup_table)

 {
 {

-       struct lookup_table *lookup_table =  _lookup_table;
+       struct lookup_table *lookup_table =  __lookup_table;

        u8 *hash = dentry->hash;
        u16 i = 0;
        while (1) {
        u8 *hash = dentry->hash;
        u16 i = 0;
        while (1) {


@@ -674,27 +706,23 @@ static int calculate_sha1sum_for_staging_file(struct dentry *dentry,
 static int rebuild_wim(WIMStruct *w, bool check_integrity)
 {
        int ret;
 static int rebuild_wim(WIMStruct *w, bool check_integrity)
 {
        int ret;

-       struct dentry *root;
-
-       root = wim_root_dentry(w);
+       struct lookup_table_entry *lte;

 
 

-       DEBUG("Closing all staging file descriptors.");

        /* Close all the staging file descriptors. */
        /* Close all the staging file descriptors. */

-       ret = for_lookup_table_entry(w->lookup_table, close_lte_fds, NULL);
-       if (ret != 0) {
-               ERROR("Failed to close all staging files");
-               return ret;
+       DEBUG("Closing all staging file descriptors.");
+       list_for_each_entry(lte, &staging_list, staging_list) {
+               ret = close_lte_fds(lte);
+               if (ret != 0)
+                       return ret;

        }
 
        }
 

-       DEBUG("Calculating SHA1 checksums for all new staging files.");

        /* Calculate SHA1 checksums for all staging files, and merge unnecessary
         * lookup table entries. */
        /* Calculate SHA1 checksums for all staging files, and merge unnecessary
         * lookup table entries. */

-       ret = for_dentry_in_tree(root, calculate_sha1sum_for_staging_file,
-                                w->lookup_table);
-       if (ret != 0) {
-               ERROR("Failed to calculate new SHA1 checksums");
+       DEBUG("Calculating SHA1 checksums for all new staging files.");
+       ret = for_dentry_in_tree(wim_root_dentry(w),
+                                calculate_sha1sum_of_staging_file, w->lookup_table);
+       if (ret != 0)

                return ret;
                return ret;

-       }

 
        xml_update_image_info(w, w->current_image);
 
 
        xml_update_image_info(w, w->current_image);
 


@@ -945,9 +973,10 @@ static int wimfs_open(const char *path, struct fuse_file_info *fi)
        u8 *dentry_hash;
        int ret;
        struct wimlib_fd *fd;
        u8 *dentry_hash;
        int ret;
        struct wimlib_fd *fd;

+       unsigned stream_idx;

 
        ret = lookup_resource(w, path, get_lookup_flags(), &dentry, &lte,
 
        ret = lookup_resource(w, path, get_lookup_flags(), &dentry, &lte,

-                             &dentry_hash);
+                             &stream_idx);

        if (ret != 0)
                return ret;
 
        if (ret != 0)
                return ret;
 


@@ -965,7 +994,7 @@ static int wimfs_open(const char *path, struct fuse_file_info *fi)
                ret = extract_resource_to_staging_dir(dentry, &lte, 0);
                if (ret != 0)
                        return ret;
                ret = extract_resource_to_staging_dir(dentry, &lte, 0);
                if (ret != 0)
                        return ret;

-               memcpy(dentry_hash, lte->hash, WIM_HASH_SIZE);
+               link_group_set_stream_hash(dentry, stream_idx, lte->hash);

        }
 
        ret = alloc_wimlib_fd(lte, &fd);
        }
 
        ret = alloc_wimlib_fd(lte, &fd);


@@ -986,7 +1015,7 @@ static int wimfs_open(const char *path, struct fuse_file_info *fi)
                                                      lte->resource_entry.original_size);
                if (ret != 0)
                        return ret;
                                                      lte->resource_entry.original_size);
                if (ret != 0)
                        return ret;

-               memcpy(dentry_hash, lte->hash, WIM_HASH_SIZE);
+               link_group_set_stream_hash(dentry, stream_idx, lte->hash);

        }
        if (lte->staging_file_name) {
                fd->staging_fd = open(lte->staging_file_name, fi->flags);
        }
        if (lte->staging_file_name) {
                fd->staging_fd = open(lte->staging_file_name, fi->flags);


@@ -1273,10 +1302,9 @@ static int wimfs_truncate(const char *path, off_t size)
        struct dentry *dentry;
        struct lookup_table_entry *lte;
        int ret;
        struct dentry *dentry;
        struct lookup_table_entry *lte;
        int ret;

-       u8 *dentry_hash;

        
        ret = lookup_resource(w, path, get_lookup_flags(), &dentry,
        
        ret = lookup_resource(w, path, get_lookup_flags(), &dentry,

-                             &lte, &dentry_hash);
+                             &lte, NULL);

 
        if (ret != 0)
                return ret;
 
        if (ret != 0)
                return ret;


@@ -1305,25 +1333,27 @@ static int wimfs_unlink(const char *path)
        struct lookup_table_entry *lte;
        int ret;
        u8 *dentry_hash;
        struct lookup_table_entry *lte;
        int ret;
        u8 *dentry_hash;

+       unsigned stream_idx;

        
        ret = lookup_resource(w, path, get_lookup_flags(), &dentry,
        
        ret = lookup_resource(w, path, get_lookup_flags(), &dentry,

-                             &lte, &dentry_hash);
+                             &lte, &stream_idx);

 
        if (ret != 0)
                return ret;
 
 
        if (ret != 0)
                return ret;
 

-       if (dentry_hash == dentry->hash) {
+       if (stream_idx == 0) {

                /* We are removing the full dentry including all alternate data
                 * streams. */
                remove_dentry(dentry, w->lookup_table);
        } else {
                /* We are removing an alternate data stream. */
                /* We are removing the full dentry including all alternate data
                 * streams. */
                remove_dentry(dentry, w->lookup_table);
        } else {
                /* We are removing an alternate data stream. */

-               struct ads_entry *cur_entry = dentry->ads_entries;
-               while (cur_entry->hash != dentry_hash)
-                       cur_entry++;
-               lookup_table_decrement_refcnt(w->lookup_table, cur_entry->hash);
+               struct ads_entry *ads_entry;
+               
+               ads_entry = &dentry->ads_entries[stream_idx - 1];
+
+               lookup_table_decrement_refcnt(w->lookup_table, ads_entry->hash);

                
                

-               dentry_remove_ads(dentry, cur_entry);
+               dentry_remove_ads(dentry, ads_entry);

        }
        /* Beware: The lookup table entry(s) may still be referenced by users
         * that have opened the corresponding streams.  They are freed later in
        }
        /* Beware: The lookup table entry(s) may still be referenced by users
         * that have opened the corresponding streams.  They are freed later in