More accurate timestamps

[wimlib] / src / mount.c

diff --git a/src/mount.c b/src/mount.c
index edd9cd1dfe4af1b0ca39c99459651cdfd2c4daf0..de8fe001d8009a053668a537ef06362a22b74d28 100644 (file)
--- a/src/mount.c
+++ b/src/mount.c
@@ -203,11 +203,15 @@ int dentry_to_stbuf(const struct dentry *dentry, struct stat *stbuf)
        stbuf->st_gid   = getgid();
 
        /* Use the size of the unnamed (default) file stream. */
-       if ((lte = dentry_lte(dentry))) {
+       lte = dentry_first_lte_resolved(dentry);
+       if (lte) {
                if (lte->staging_file_name) {
                        struct stat native_stat;
-                       if (stat(lte->staging_file_name, &native_stat) != 0)
+                       if (stat(lte->staging_file_name, &native_stat) != 0) {
+                               DEBUG("Failed to stat `%s': %m",
+                                     lte->staging_file_name);
                                return -errno;
+                       }
                        stbuf->st_size = native_stat.st_size;
                } else {
                        stbuf->st_size = lte->resource_entry.original_size;
@@ -216,9 +220,9 @@ int dentry_to_stbuf(const struct dentry *dentry, struct stat *stbuf)
                stbuf->st_size = 0;
        }
 
-       stbuf->st_atime   = ms_timestamp_to_unix(dentry->last_access_time);
-       stbuf->st_mtime   = ms_timestamp_to_unix(dentry->last_write_time);
-       stbuf->st_ctime   = ms_timestamp_to_unix(dentry->creation_time);
+       stbuf->st_atime   = wim_timestamp_to_unix(dentry->last_access_time);
+       stbuf->st_mtime   = wim_timestamp_to_unix(dentry->last_write_time);
+       stbuf->st_ctime   = wim_timestamp_to_unix(dentry->creation_time);
        stbuf->st_blocks  = (stbuf->st_size + 511) / 512;
        return 0;
 }
@@ -239,7 +243,7 @@ static int create_staging_file(char **name_ret, int open_flags)
        int fd;
        int errno_save;
 
-       name_len = staging_dir_name_len + 1 + WIM_HASH_SIZE;
+       name_len = staging_dir_name_len + 1 + SHA1_HASH_SIZE;
        name = MALLOC(name_len + 1);
        if (!name) {
                errno = ENOMEM;
@@ -251,7 +255,7 @@ static int create_staging_file(char **name_ret, int open_flags)
                memcpy(name, staging_dir_name, staging_dir_name_len);
                name[staging_dir_name_len] = '/';
                randomize_char_array_with_alnum(name + staging_dir_name_len + 1,
-                                               WIM_HASH_SIZE);
+                                               SHA1_HASH_SIZE);
                name[name_len] = '\0';
 
 
@@ -482,7 +486,7 @@ static int extract_resource_to_staging_dir(struct dentry *dentry,
        }
        new_lte->resource_entry.original_size = size;
        new_lte->refcnt = link_group_size;
-       randomize_byte_array(new_lte->hash, WIM_HASH_SIZE);
+       random_hash(new_lte->hash);
        new_lte->staging_file_name = staging_file_name;
 
        lookup_table_insert(w->lookup_table, new_lte);
@@ -773,14 +777,14 @@ static int calculate_sha1sum_of_staging_file(struct lookup_table_entry *lte,
 {
        struct lookup_table_entry *duplicate_lte;
        int ret;
-       u8 hash[WIM_HASH_SIZE];
+       u8 hash[SHA1_HASH_SIZE];
 
        ret = sha1sum(lte->staging_file_name, hash);
        if (ret != 0)
                return ret;
 
        lookup_table_unlink(table, lte);
-       memcpy(lte->hash, hash, WIM_HASH_SIZE);
+       copy_hash(lte->hash, hash);
 
        duplicate_lte = __lookup_resource(table, hash);
 
@@ -1282,7 +1286,7 @@ static int wimfs_release(const char *path, struct fuse_file_info *fi)
        }
 
        if (flags_writable(fi->flags) && fd->dentry) {
-               u64 now = get_timestamp();
+               u64 now = get_wim_timestamp();
                fd->dentry->last_access_time = now;
                fd->dentry->last_write_time = now;
        }
@@ -1422,6 +1426,7 @@ static int wimfs_symlink(const char *to, const char *from)
 
        dentry->attributes = FILE_ATTRIBUTE_REPARSE_POINT;
        dentry->reparse_tag = WIM_IO_REPARSE_TAG_SYMLINK;
+       dentry->hard_link = next_link_group_id++;
 
        if (dentry_set_symlink(dentry, to, w->lookup_table, &lte) != 0)
                goto out_free_dentry;
@@ -1431,8 +1436,7 @@ static int wimfs_symlink(const char *to, const char *from)
        dentry->ads_entries[1].lte_group_list.type = STREAM_TYPE_ADS;
        list_add(&dentry->ads_entries[1].lte_group_list.list,
                 &lte->lte_group_list);
-       dentry->ads_entries[1].lte = lte;
-       dentry->resolved = true;
+       wimlib_assert(dentry->resolved);
 
        link_dentry(dentry, dentry_parent);
        return 0;
@@ -1509,20 +1513,28 @@ static int wimfs_unlink(const char *path)
        return 0;
 }
 
-/* Change the timestamp on a file dentry. 
+/* 
+ * Change the timestamp on a file dentry. 
  *
- * There is no distinction between a file and its alternate data streams here.  */
+ * Note that alternate data streams do not have their own timestamps.
+ */
 static int wimfs_utimens(const char *path, const struct timespec tv[2])
 {
        struct dentry *dentry = get_dentry(w, path);
        if (!dentry)
                return -ENOENT;
-       time_t last_access_t = (tv[0].tv_nsec == UTIME_NOW) ? 
-                               time(NULL) : tv[0].tv_sec;
-       dentry->last_access_time = unix_timestamp_to_ms(last_access_t);
-       time_t last_mod_t = (tv[1].tv_nsec == UTIME_NOW) ?  
-                               time(NULL) : tv[1].tv_sec;
-       dentry->last_write_time = unix_timestamp_to_ms(last_mod_t);
+       if (tv[0].tv_nsec != UTIME_OMIT) {
+               if (tv[0].tv_nsec == UTIME_NOW)
+                       dentry->last_access_time = get_wim_timestamp();
+               else
+                       dentry->last_access_time = timespec_to_wim_timestamp(&tv[0]);
+       }
+       if (tv[1].tv_nsec != UTIME_OMIT) {
+               if (tv[1].tv_nsec == UTIME_NOW)
+                       dentry->last_write_time = get_wim_timestamp();
+               else
+                       dentry->last_write_time = timespec_to_wim_timestamp(&tv[1]);
+       }
        return 0;
 }
 
@@ -1583,6 +1595,24 @@ static struct fuse_operations wimfs_operations = {
 };
 
 
+static int check_lte_refcnt(struct lookup_table_entry *lte, void *ignore)
+{
+       size_t lte_group_size = 0;
+       struct list_head *cur;
+       list_for_each(cur, &lte->lte_group_list)
+               lte_group_size++;
+       if (lte_group_size > lte->refcnt) {
+#ifdef ENABLE_ERROR_MESSAGES
+               ERROR("The following lookup table entry has a reference count "
+                     "of %u, but", lte->refcnt);
+               ERROR("We found %u references to it", lte_group_size);
+               print_lookup_table_entry(lte);
+#endif
+               return WIMLIB_ERR_INVALID_DENTRY;
+       }
+       return 0;
+}
+
 /* Mounts a WIM file. */
 WIMLIBAPI int wimlib_mount(WIMStruct *wim, int image, const char *dir, 
                           int flags)
@@ -1611,6 +1641,10 @@ WIMLIBAPI int wimlib_mount(WIMStruct *wim, int image, const char *dir,
        for_dentry_in_tree(wim_root_dentry(wim), dentry_resolve_ltes,
                           wim->lookup_table);
 
+       ret = for_lookup_table_entry(wim->lookup_table, check_lte_refcnt, NULL);
+       if (ret != 0)
+               return ret;
+
        if (flags & WIMLIB_MOUNT_FLAG_READWRITE)
                wim_get_current_image_metadata(wim)->modified = true;
 
@@ -1765,7 +1799,10 @@ WIMLIBAPI int wimlib_unmount(const char *dir, int flags)
         * filesystem daemon has crashed or failed for some reason.
         *
         * XXX come up with some method to determine if the filesystem
-        * daemon has really crashed or not. */
+        * daemon has really crashed or not. 
+        *
+        * XXX Idea: have mount daemon write its PID into the WIM file header?
+        * */
 
        gettimeofday(&now, NULL);
        timeout.tv_sec = now.tv_sec + 600;