X-Git-Url: https://wimlib.net/git/?p=wimlib;a=blobdiff_plain;f=src%2Fmount.c;h=ad001ce24037deb5786465f30bd970e9ea2287d5;hp=68909618596997c14b5c10cb0277b48e25c7d809;hb=db046c7191d39535dfb49e9b9bdfc0751a8c17b4;hpb=038eaccece575d04de8d647bb93773b7f3e38ce4

diff --git a/src/mount.c b/src/mount.c
index 68909618..ad001ce2 100644
--- a/src/mount.c
+++ b/src/mount.c
@@ -143,14 +143,17 @@ static int close_wimlib_fd(struct wimlib_fd *fd)
 	wimlib_assert(lte);
 	wimlib_assert(lte->num_opened_fds);
 
-	if (lte->staging_file_name) {
+	if (lte->resource_location == RESOURCE_IN_STAGING_FILE) {
+		wimlib_assert(lte->staging_file_name);
 		wimlib_assert(fd->staging_fd != -1);
 		if (close(fd->staging_fd) != 0)
 			return -errno;
 	}
 	if (--lte->num_opened_fds == 0 && lte->refcnt == 0) {
-		if (lte->staging_file_name)
+		if (lte->resource_location == RESOURCE_IN_STAGING_FILE) {
+			wimlib_assert(lte->staging_file_name);
 			unlink(lte->staging_file_name);
+		}
 		free_lookup_table_entry(lte);
 	}
 	wimlib_assert(lte->fds[fd->idx] == fd);
@@ -203,11 +206,16 @@ 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))) {
-		if (lte->staging_file_name) {
+	lte = dentry_first_lte_resolved(dentry);
+	if (lte) {
+		if (lte->resource_location == RESOURCE_IN_STAGING_FILE) {
+			wimlib_assert(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 +224,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 +247,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 +259,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';
 
 
@@ -420,8 +428,7 @@ static int extract_resource_to_staging_dir(struct dentry *dentry,
 		return -errno;
 
 	if (old_lte)
-		ret = extract_resource_to_fd(w, &old_lte->resource_entry, fd,
-					     size);
+		ret = extract_wim_resource_to_fd(old_lte, fd, size);
 	else
 		ret = 0;
 	if (ret != 0 || close(fd) != 0) {
@@ -482,8 +489,9 @@ 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;
+	new_lte->resource_location = RESOURCE_IN_STAGING_FILE;
 
 	lookup_table_insert(w->lookup_table, new_lte);
 	list_add(&new_lte->staging_list, &staging_list);
@@ -733,6 +741,8 @@ static int close_lte_fds(struct lookup_table_entry *lte)
 {
 	for (u16 i = 0, j = 0; j < lte->num_opened_fds; i++) {
 		if (lte->fds[i] && lte->fds[i]->staging_fd != -1) {
+			wimlib_assert(lte->resource_location == RESOURCE_IN_STAGING_FILE);
+			wimlib_assert(lte->staging_file_name);
 			if (close(lte->fds[i]->staging_fd) != 0) {
 				ERROR_WITH_ERRNO("Failed close file `%s'",
 						 lte->staging_file_name);
@@ -768,19 +778,22 @@ static void lte_list_change_lte_ptr(struct lookup_table_entry *lte,
 }
 
 
-static int calculate_sha1sum_of_staging_file(struct lookup_table_entry *lte,
-					     struct lookup_table *table)
+static int update_lte_of_staging_file(struct lookup_table_entry *lte,
+				      struct lookup_table *table)
 {
 	struct lookup_table_entry *duplicate_lte;
 	int ret;
-	u8 hash[WIM_HASH_SIZE];
+	u8 hash[SHA1_HASH_SIZE];
+	struct stat stbuf;
+
+	wimlib_assert(lte->resource_location == RESOURCE_IN_STAGING_FILE);
+	wimlib_assert(lte->staging_file_name);
 
 	ret = sha1sum(lte->staging_file_name, hash);
 	if (ret != 0)
 		return ret;
 
 	lookup_table_unlink(table, lte);
-	memcpy(lte->hash, hash, WIM_HASH_SIZE);
 
 	duplicate_lte = __lookup_resource(table, hash);
 
@@ -789,11 +802,20 @@ static int calculate_sha1sum_of_staging_file(struct lookup_table_entry *lte,
 
 		lte_list_change_lte_ptr(lte, duplicate_lte);
 		duplicate_lte->refcnt += lte->refcnt;
-		list_splice(&duplicate_lte->lte_group_list,
-			    &lte->lte_group_list);
+		list_splice(&lte->lte_group_list,
+			    &duplicate_lte->lte_group_list);
 
 		free_lookup_table_entry(lte);
 	} else {
+		if (stat(lte->staging_file_name, &stbuf) != 0) {
+			ERROR_WITH_ERRNO("Failed to stat `%s'", lte->staging_file_name);
+			return WIMLIB_ERR_STAT;
+		}
+		wimlib_assert(&lte->file_on_disk == &lte->staging_file_name);
+		lte->resource_location = RESOURCE_IN_FILE_ON_DISK;
+		copy_hash(lte->hash, hash);
+		lte->resource_entry.original_size = stbuf.st_size;
+		lte->resource_entry.size = stbuf.st_size;
 		lookup_table_insert(table, lte);
 	}
 
@@ -818,7 +840,7 @@ static int rebuild_wim(WIMStruct *w, bool check_integrity)
 	 * lookup table entries. */
 	DEBUG("Calculating SHA1 checksums for all new staging files.");
 	list_for_each_entry_safe(lte, tmp, &staging_list, staging_list) {
-		ret = calculate_sha1sum_of_staging_file(lte, w->lookup_table);
+		ret = update_lte_of_staging_file(lte, w->lookup_table);
 		if (ret != 0)
 			return ret;
 	}
@@ -1039,6 +1061,7 @@ static int wimfs_mkdir(const char *path, mode_t mode)
 	newdir = new_dentry(basename);
 	newdir->attributes |= FILE_ATTRIBUTE_DIRECTORY;
 	newdir->resolved = true;
+	newdir->hard_link = next_link_group_id++;
 	link_dentry(newdir, parent);
 	return 0;
 }
@@ -1144,7 +1167,7 @@ static int wimfs_open(const char *path, struct fuse_file_info *fi)
 		if (ret != 0)
 			return ret;
 	}
-	if (lte->staging_file_name) {
+	if (lte->resource_location == RESOURCE_IN_STAGING_FILE) {
 		fd->staging_fd = open(lte->staging_file_name, fi->flags);
 		if (fd->staging_fd == -1) {
 			close_wimlib_fd(fd);
@@ -1188,9 +1211,10 @@ static int wimfs_read(const char *path, char *buf, size_t size,
 
 	wimlib_assert(fd->lte);
 
-	if (fd->lte->staging_file_name) {
+	if (fd->lte->resource_location == RESOURCE_IN_STAGING_FILE) {
 		/* Read from staging file */
 
+		wimlib_assert(fd->lte->staging_file_name);
 		wimlib_assert(fd->staging_fd != -1);
 
 		ssize_t ret;
@@ -1205,22 +1229,16 @@ static int wimfs_read(const char *path, char *buf, size_t size,
 	} else {
 		/* Read from WIM */
 
-		struct resource_entry *res_entry;
-		int ctype;
+		const struct resource_entry *res_entry;
 		
 		res_entry = &fd->lte->resource_entry;
 
-		ctype = wim_resource_compression_type(w, res_entry);
-
 		if (offset > res_entry->original_size)
 			return -EOVERFLOW;
 
 		size = min(size, res_entry->original_size - offset);
 
-		if (read_resource(w->fp, res_entry->size, 
-				  res_entry->original_size,
-				  res_entry->offset, ctype, size, 
-				  offset, buf) != 0)
+		if (read_wim_resource(fd->lte, buf, size, offset) != 0)
 			return -EIO;
 		return size;
 	}
@@ -1281,7 +1299,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;
 	}
@@ -1421,15 +1439,17 @@ 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;
 
+	wimlib_assert(lte);
+
 	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;
@@ -1506,20 +1526,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;
 }
 
@@ -1580,6 +1608,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)
@@ -1608,6 +1654,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;
 
@@ -1627,7 +1677,7 @@ WIMLIBAPI int wimlib_mount(WIMStruct *wim, int image, const char *dir,
 	if (!p)
 		return WIMLIB_ERR_NOMEM;
 
-	argv[argc++] = "mount";
+	argv[argc++] = "imagex";
 	argv[argc++] = p;
 	argv[argc++] = "-s"; /* disable multi-threaded operation */
 
@@ -1762,7 +1812,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;