X-Git-Url: https://wimlib.net/git/?a=blobdiff_plain;f=src%2Fmount.c;h=5a2b6b73441d091e1062a6ca03c93a62dbb949d6;hb=86a1be4251c561e6f9ef752bd38e158bfab590cd;hp=f4f30d11cf35f6543b32933ce19d1c4348166526;hpb=d977c5b4f348208e47fd2922f202f3eb60d5d5cb;p=wimlib

diff --git a/src/mount.c b/src/mount.c
index f4f30d11..5a2b6b73 100644
--- a/src/mount.c
+++ b/src/mount.c
@@ -45,6 +45,14 @@
 #include <ftw.h>
 #include <mqueue.h>
 
+struct wimlib_fd {
+	u16 idx;
+	int staging_fd;
+	u64 hard_link_group;
+	struct lookup_table_entry *lte;
+	struct dentry *dentry;
+};
+
 /* The WIMStruct for the mounted WIM. */
 static WIMStruct *w;
 
@@ -65,6 +73,10 @@ static int mount_flags;
 /* Name of the directory on which the WIM file is mounted. */
 static const char *mount_dir;
 
+/* Next hard link group ID to be assigned.  These are also used as the inode
+ * numbers. */
+static u64 next_link_group_id;
+
 
 static inline int get_lookup_flags()
 {
@@ -74,6 +86,299 @@ static inline int get_lookup_flags()
 		return 0;
 }
 
+static inline int flags_writable(int open_flags)
+{
+	return open_flags & (O_RDWR | O_WRONLY);
+}
+
+static int alloc_wimlib_fd(struct lookup_table_entry *lte,
+			   struct wimlib_fd **fd_ret)
+{
+	static const u16 fds_per_alloc = 8;
+	static const u16 max_fds = 0xffff;
+
+	if (lte->num_opened_fds == lte->num_allocated_fds) {
+		struct wimlib_fd **fds;
+		u16 num_new_fds;
+
+		if (lte->num_allocated_fds == max_fds)
+			return -EMFILE;
+		num_new_fds = min(fds_per_alloc, max_fds - lte->num_allocated_fds);
+		
+		fds = CALLOC(lte->num_allocated_fds + num_new_fds,
+			     sizeof(lte->fds[0]));
+		if (!fds)
+			return -ENOMEM;
+		memcpy(fds, lte->fds,
+		       lte->num_allocated_fds * sizeof(lte->fds[0]));
+		FREE(lte->fds);
+		lte->fds = fds;
+		lte->num_allocated_fds += num_new_fds;
+	}
+	for (u16 i = 0; ; i++) {
+		if (!lte->fds[i]) {
+			struct wimlib_fd *fd = CALLOC(1, sizeof(*fd));
+			if (!fd)
+				return -ENOMEM;
+			fd->staging_fd = -1;
+			fd->idx        = i;
+			fd->lte        = lte;
+			lte->fds[i]    = fd;
+			lte->num_opened_fds++;
+			*fd_ret        = fd;
+			return 0;
+		}
+	}
+}
+
+static int close_wimlib_fd(struct wimlib_fd *fd)
+{
+	struct lookup_table_entry *lte = fd->lte;
+
+	wimlib_assert(lte);
+	wimlib_assert(lte->num_opened_fds);
+
+	if (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)
+			unlink(lte->staging_file_name);
+		free_lookup_table_entry(lte);
+	}
+	lte->fds[fd->idx] = NULL;
+	FREE(fd);
+	return 0;
+}
+
+static void remove_dentry(struct dentry *dentry,
+			  struct lookup_table *lookup_table)
+{
+	const u8 *hash = dentry->hash;
+	u16 i = 0;
+	struct lookup_table_entry *lte;
+	while (1) {
+		lte = lookup_table_decrement_refcnt(lookup_table, hash);
+		if (lte && lte->num_opened_fds)
+			for (u16 i = 0; i < lte->num_allocated_fds; i++)
+				if (lte->fds[i] && lte->fds[i]->dentry == dentry)
+					lte->fds[i]->dentry = NULL;
+		if (i == dentry->num_ads)
+			break;
+		hash = dentry->ads_entries[i].hash;
+		i++;
+	}
+
+	unlink_dentry(dentry);
+	put_dentry(dentry);
+}
+
+static void dentry_increment_lookup_table_refcnts(struct dentry *dentry,
+						  struct lookup_table *lookup_table)
+{
+	u16 i = 0;
+	const u8 *hash = dentry->hash;
+	struct lookup_table_entry *lte;
+	while (1) {
+		lte = __lookup_resource(lookup_table, hash);
+		if (lte)
+			lte->refcnt++;
+		if (i == dentry->num_ads)
+			break;
+		hash = dentry->ads_entries[i].hash;
+		i++;
+	}
+}
+
+/* Creates a new staging file and returns its file descriptor opened for
+ * writing.
+ *
+ * @name_ret: A location into which the a pointer to the newly allocated name of
+ * 			the staging file is stored.
+ * @return:  The file descriptor for the new file.  Returns -1 and sets errno on
+ * 		error, for any reason possible from the creat() function.
+ */
+static int create_staging_file(char **name_ret, int open_flags)
+{
+	size_t name_len;
+	char *name;
+	struct stat stbuf;
+	int fd;
+	int errno_save;
+
+	name_len = staging_dir_name_len + 1 + WIM_HASH_SIZE;
+ 	name = MALLOC(name_len + 1);
+	if (!name) {
+		errno = ENOMEM;
+		return -1;
+	}
+
+	do {
+
+		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);
+		name[name_len] = '\0';
+
+
+	/* Just in case, verify that the randomly generated name doesn't name an
+	 * existing file, and try again if so  */
+	} while (stat(name, &stbuf) == 0);
+
+	if (errno != ENOENT)
+		/* other error! */
+		return -1;
+
+	/* doesn't exist--- ok */
+
+	DEBUG("Creating staging file `%s'", name);
+
+	fd = open(name, open_flags | O_CREAT | O_TRUNC, 0600); 
+	if (fd == -1) {
+		errno_save = errno;
+		FREE(name);
+		errno = errno_save;
+	} else {
+		*name_ret = name;
+	}
+	return fd;
+}
+
+/* 
+ * Extract a WIM resource to the staging directory.
+ *
+ * We need to:
+ * - Create a staging file for the WIM resource
+ * - Extract the resource to it
+ * - Create a new lte for the file resource
+ * - Transfer fds from the old lte to the new lte, but
+ *   only if they share the same hard link group as this
+ *   dentry
+ */
+static int extract_resource_to_staging_dir(struct dentry *dentry,
+					   struct lookup_table_entry **lte,
+					   off_t size)
+{
+	char *staging_file_name;
+	int ret;
+	int fd;
+	struct lookup_table_entry *old_lte, *new_lte;
+	size_t link_group_size;
+
+	DEBUG("Extracting resource `%s' to staging directory", dentry->full_path_utf8);
+
+	old_lte = *lte;
+	fd = create_staging_file(&staging_file_name, O_WRONLY);
+	if (fd == -1)
+		return -errno;
+
+	if (old_lte)
+		ret = extract_resource_to_fd(w, &old_lte->resource_entry, fd,
+					     size);
+	else
+		ret = 0;
+	if (ret != 0 || close(fd) != 0) {
+		if (errno != 0)
+			ret = -errno;
+		else
+			ret = -EIO;
+		close(fd);
+		goto out_delete_staging_file;
+	}
+
+	link_group_size = dentry_link_group_size(dentry);
+
+	if (old_lte) {
+		if (link_group_size == old_lte->refcnt) {
+			/* This hard link group is the only user of the lookup
+			 * table entry, so we can re-use it. */
+			DEBUG("Re-using lookup table entry");
+			lookup_table_remove(w->lookup_table, old_lte);
+			new_lte = old_lte;
+		} else {
+			DEBUG("Splitting lookup table entry "
+			      "(link_group_size = %u, lte refcnt = %u)",
+			      link_group_size, old_lte->refcnt);
+			/* Split a hard link group away from the "lookup table
+			 * entry" hard link group (i.e. we had two hard link
+			 * groups that were identical, but now we are changing
+			 * one of them) */
+
+			/* XXX The ADS really complicate things here and not
+			 * everything is going to work correctly yet.  For
+			 * example it could be the same that a file contains two
+			 * file streams that are identical and therefore share
+			 * the same lookup table entry despite the fact that the
+			 * streams themselves are not hardlinked. */
+			wimlib_assert(old_lte->refcnt > link_group_size);
+
+			new_lte = new_lookup_table_entry();
+			if (!new_lte) {
+				ret = -ENOMEM;
+				goto out_delete_staging_file;
+			}
+
+			u16 num_transferred_fds = 0;
+			for (u16 i = 0; i < old_lte->num_allocated_fds; i++) {
+				if (old_lte->fds[i] &&
+				    old_lte->fds[i]->dentry->hard_link ==
+				      dentry->hard_link)
+				{
+					num_transferred_fds++;
+				}
+			}
+			DEBUG("Transferring %u file descriptors",
+			      num_transferred_fds);
+			new_lte->fds = MALLOC(num_transferred_fds *
+					      sizeof(new_lte->fds[0]));
+			if (!new_lte->fds) {
+				FREE(new_lte);
+				ret = -ENOMEM;
+				goto out_delete_staging_file;
+			}
+			for (u16 i = 0, j = 0; ; i++) {
+				if (old_lte->fds[i] &&
+				    old_lte->fds[i]->dentry->hard_link ==
+				      dentry->hard_link)
+				{
+					struct wimlib_fd *fd = old_lte->fds[i];
+					old_lte->fds[i] = NULL;
+					fd->lte = new_lte;
+					fd->idx = j;
+					new_lte->fds[j] = fd;
+					if (++j == num_transferred_fds)
+						break;
+				}
+			}
+			old_lte->refcnt -= link_group_size;
+			old_lte->num_opened_fds -= num_transferred_fds;
+			new_lte->num_opened_fds = num_transferred_fds;
+			new_lte->num_allocated_fds = num_transferred_fds;
+		} 
+	} else {
+		new_lte = new_lookup_table_entry();
+		if (!new_lte) {
+			ret = -ENOMEM;
+			goto out_delete_staging_file;
+		}
+	}
+	new_lte->resource_entry.original_size = size;
+	new_lte->refcnt = link_group_size;
+	randomize_byte_array(new_lte->hash, WIM_HASH_SIZE);
+	new_lte->staging_file_name = staging_file_name;
+
+	lookup_table_insert(w->lookup_table, new_lte);
+	*lte = new_lte;
+	return 0;
+out_delete_staging_file:
+	unlink(staging_file_name);
+	FREE(staging_file_name);
+	return ret;
+}
+
 /* 
  * Creates a randomly named staging directory and returns its name into the
  * static variable staging_dir_name.
@@ -308,13 +613,15 @@ static int wimfs_access(const char *path, int mask)
 
 /* Closes the staging file descriptor associated with the lookup table entry, if
  * it is opened. */
-static int close_staging_file(struct lookup_table_entry *lte, void *ignore)
+static int close_lte_fds(struct lookup_table_entry *lte, void *ignore)
 {
-	if (lte->staging_file_name && lte->staging_num_times_opened) {
-		if (close(lte->staging_fd) != 0) {
-			ERROR_WITH_ERRNO("Failed close file `%s'",
-					 lte->staging_file_name);
-			return WIMLIB_ERR_WRITE;
+	for (u16 i = 0; i < 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;
+			}
 		}
 	}
 	return 0;
@@ -373,7 +680,7 @@ static int rebuild_wim(WIMStruct *w, bool check_integrity)
 
 	DEBUG("Closing all staging file descriptors.");
 	/* Close all the staging file descriptors. */
-	ret = for_lookup_table_entry(w->lookup_table, close_staging_file, NULL);
+	ret = for_lookup_table_entry(w->lookup_table, close_lte_fds, NULL);
 	if (ret != 0) {
 		ERROR("Failed to close all staging files");
 		return ret;
@@ -402,7 +709,6 @@ static int rebuild_wim(WIMStruct *w, bool check_integrity)
 /* Called when the filesystem is unmounted. */
 static void wimfs_destroy(void *p)
 {
-
 	/* For read-write mounts, the `imagex unmount' command, which is
 	 * running in a separate process and is executing the
 	 * wimlib_unmount() function, will send this process a byte
@@ -475,6 +781,32 @@ done:
 	close_message_queues();
 }
 
+static int wimfs_fallocate(const char *path, int mode,
+			   off_t offset, off_t len, struct fuse_file_info *fi)
+{
+	struct wimlib_fd *fd = (struct wimlib_fd*)fi->fh;
+	wimlib_assert(fd->staging_fd != -1);
+	return fallocate(fd->staging_fd, mode, offset, len);
+}
+
+static int wimfs_fgetattr(const char *path, struct stat *stbuf,
+			  struct fuse_file_info *fi)
+{
+	struct wimlib_fd *fd = (struct wimlib_fd*)fi->fh;
+	return dentry_to_stbuf(fd->dentry, stbuf, w->lookup_table);
+}
+
+static int wimfs_ftruncate(const char *path, off_t size,
+			   struct fuse_file_info *fi)
+{
+	struct wimlib_fd *fd = (struct wimlib_fd*)fi->fh;
+	int ret = ftruncate(fd->staging_fd, size);
+	if (ret != 0)
+		return ret;
+	fd->lte->resource_entry.original_size = size;
+	return 0;
+}
+
 /*
  * Fills in a `struct stat' that corresponds to a file or directory in the WIM.
  */
@@ -483,10 +815,57 @@ static int wimfs_getattr(const char *path, struct stat *stbuf)
 	struct dentry *dentry = get_dentry(w, path);
 	if (!dentry)
 		return -ENOENT;
-	dentry_to_stbuf(dentry, stbuf, w->lookup_table);
+	return dentry_to_stbuf(dentry, stbuf, w->lookup_table);
+}
+
+static int wimfs_getxattr(const char *path, const char *name, char *value,
+			  size_t size)
+{
+	/* XXX */
+	return -ENOTSUP;
+}
+
+/* Create a hard link */
+static int wimfs_link(const char *to, const char *from)
+{
+	struct dentry *to_dentry, *from_dentry, *from_dentry_parent;
+	const char *link_name;
+
+	to_dentry = get_dentry(w, to);
+	if (!to_dentry)
+		return -ENOENT;
+	if (!dentry_is_regular_file(to_dentry))
+		return -EPERM;
+
+	from_dentry_parent = get_parent_dentry(w, from);
+	if (!from_dentry_parent)
+		return -ENOENT;
+	if (!dentry_is_directory(from_dentry_parent))
+		return -ENOTDIR;
+
+	link_name = path_basename(from);
+	if (get_dentry_child_with_name(from_dentry_parent, link_name))
+		return -EEXIST;
+	from_dentry = clone_dentry(to_dentry);
+	if (!from_dentry)
+		return -ENOMEM;
+	if (change_dentry_name(from_dentry, link_name) != 0) {
+		FREE(from_dentry);
+		return -ENOMEM;
+	}
+	list_add(&from_dentry->link_group_list, &to_dentry->link_group_list);
+	link_dentry(from_dentry, from_dentry_parent);
+	dentry_increment_lookup_table_refcnts(from_dentry, w->lookup_table);
+	from_dentry->link_group_master_status = GROUP_SLAVE;
 	return 0;
 }
 
+static int wimfs_listxattr(const char *path, char *list, size_t size)
+{
+	/* XXX */
+	return -ENOTSUP;
+}
+
 /* 
  * Create a directory in the WIM.  
  * @mode is currently ignored.
@@ -514,60 +893,6 @@ static int wimfs_mkdir(const char *path, mode_t mode)
 	return 0;
 }
 
-/* Creates a new staging file and returns its file descriptor opened for
- * writing.
- *
- * @name_ret: A location into which the a pointer to the newly allocated name of
- * 			the staging file is stored.
- * @return:  The file descriptor for the new file.  Returns -1 and sets errno on
- * 		error, for any reason possible from the creat() function.
- */
-static int create_staging_file(char **name_ret, int open_flags)
-{
-	size_t name_len;
-	char *name;
-	struct stat stbuf;
-	int fd;
-	int errno_save;
-
-	name_len = staging_dir_name_len + 1 + WIM_HASH_SIZE;
- 	name = MALLOC(name_len + 1);
-	if (!name) {
-		errno = ENOMEM;
-		return -1;
-	}
-
-	do {
-
-		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);
-		name[name_len] = '\0';
-
-
-	/* Just in case, verify that the randomly generated name doesn't name an
-	 * existing file, and try again if so  */
-	} while (stat(name, &stbuf) == 0);
-
-	if (errno != ENOENT)
-		/* other error! */
-		return -1;
-
-	/* doesn't exist--- ok */
-
-	DEBUG("Creating staging file `%s'", name);
-
-	fd = open(name, mode | O_CREAT | O_TRUNC, 0600); 
-	if (fd == -1) {
-		errno_save = errno;
-		FREE(name);
-		errno = errno_save;
-	} else {
-		*name_ret = name;
-	}
-	return fd;
-}
 
 /* Creates a regular file. */
 static int wimfs_mknod(const char *path, mode_t mode, dev_t rdev)
@@ -597,11 +922,15 @@ static int wimfs_mknod(const char *path, mode_t mode, dev_t rdev)
 			return -ENOENT;
 		if (!dentry_is_directory(parent))
 			return -ENOTDIR;
+
 		basename = path_basename(path);
 		if (get_dentry_child_with_name(parent, path))
 			return -EEXIST;
 
 		dentry = new_dentry(basename);
+		if (!dentry)
+			return -ENOMEM;
+		dentry->hard_link = next_link_group_id++;
 		link_dentry(dentry, parent);
 	}
 	return 0;
@@ -615,60 +944,58 @@ static int wimfs_open(const char *path, struct fuse_file_info *fi)
 	struct lookup_table_entry *lte;
 	u8 *dentry_hash;
 	int ret;
+	struct wimlib_fd *fd;
 
 	ret = lookup_resource(w, path, get_lookup_flags(), &dentry, &lte,
 			      &dentry_hash);
 	if (ret != 0)
 		return ret;
 
-	if (lte) {
-		/* If this file is in the staging directory and the file is not
-		 * currently open, open it. */
-		if (lte->staging_file_name) {
- 			if (lte->staging_num_times_opened == 0) {
-				lte->staging_fd = open(lte->staging_file_name, O_RDWR);
-				if (lte->staging_fd == -1)
-					return -errno;
-				lte->staging_offset = 0;
-			}
-		} else {
-			/* File in the WIM.  We must extract it to the staging directory
-			 * before it can be written to.  */
-			ret = extract_resource_to_staging_dir(dentry_hash, lte,
-							      lte->resource_entry.original_size);
-			if (ret != 0)
-				return ret;
-		}
-	} else {
+	if (!lte) {
 		/* Empty file with no lookup-table entry.  This is fine if it's
-		 * a read-only filesystem.  Otherwise we need to move the file
-		 * to the staging directory with a new lookup table entry, even
-		 * if we aren't opening it for writing at the moment, so that we
-		 * will have a lookup table entry for the file in case it's
-		 * changed. */
+		 * a read-only filesystem.  Otherwise we need to create a lookup
+		 * table entry so that we can keep track of the file descriptors
+		 * (this is important in case someone opens the file for
+		 * writing) */
 		if (!(mount_flags & WIMLIB_MOUNT_FLAG_READWRITE)) {
-			fi->fd = 0;
+			fi->fh = 0;
 			return 0;
 		}
-		char *tmpfile_name;
-		int fd;
 
-		fd = create_staging_file(&tmpfile_name, O_RDWR);
-		if (fd == -1)
-			return -errno;
+		ret = extract_resource_to_staging_dir(dentry, &lte, 0);
+		if (ret != 0)
+			return ret;
+		memcpy(dentry_hash, lte->hash, WIM_HASH_SIZE);
+	}
 
-		lte = new_lookup_table_entry();
-		if (!lte)
-			return -ENOMEM;
+	ret = alloc_wimlib_fd(lte, &fd);
+	if (ret != 0)
+		return ret;
 
-		randomize_byte_array(lte->hash, WIM_HASH_SIZE);
+	fd->dentry = dentry;
+
+	/* The file resource may be in the staging directory (read-write
+	 * mounts only) or in the WIM.  If it's in the staging
+	 * directory, we need to open a native file descriptor for the
+	 * corresponding file.  Otherwise, we can read the file resource
+	 * directly from the WIM file if we are opening it read-only,
+	 * but we need to extract the resource to the staging directory
+	 * if we are opening it writable. */
+	if (flags_writable(fi->flags) && !lte->staging_file_name) {
+		ret = extract_resource_to_staging_dir(dentry, &lte,
+						      lte->resource_entry.original_size);
+		if (ret != 0)
+			return ret;
 		memcpy(dentry_hash, lte->hash, WIM_HASH_SIZE);
-		lte->staging_file_name = tmpfile_name;
-		lte->staging_fd = fd;
-		lookup_table_insert(w->lookup_table, lte);
 	}
-	lte->staging_num_times_opened++;
-	fi->fd = (uint64_t)lte;
+	if (lte->staging_file_name) {
+		fd->staging_fd = open(lte->staging_file_name, fi->flags);
+		if (fd->staging_fd == -1) {
+			close_wimlib_fd(fd);
+			return -errno;
+		}
+	}
+	fi->fh = (uint64_t)fd;
 	return 0;
 }
 
@@ -678,9 +1005,12 @@ static int wimfs_opendir(const char *path, struct fuse_file_info *fi)
 	struct dentry *dentry;
 	
 	dentry = get_dentry(w, path);
-	if (!dentry || !dentry_is_directory(dentry))
+	if (!dentry)
+		return -ENOENT;
+	if (!dentry_is_directory(dentry))
 		return -ENOTDIR;
-	fi->fd = (uint64_t)dentry;
+	dentry->num_times_opened++;
+	fi->fh = (uint64_t)dentry;
 	return 0;
 }
 
@@ -689,36 +1019,30 @@ static int wimfs_opendir(const char *path, struct fuse_file_info *fi)
  * Read data from a file in the WIM or in the staging directory. 
  */
 static int wimfs_read(const char *path, char *buf, size_t size, 
-		off_t offset, struct fuse_file_info *fi)
+		      off_t offset, struct fuse_file_info *fi)
 {
-	struct lookup_table_entry *lte;
+	struct wimlib_fd *fd = (struct wimlib_fd*)fi->fh;
 
-	lte = (struct lookup_table_entry*)fi->fh;
-	if (!lte)
+	if (!fd) {
+		/* Empty file with no lookup table entry on read-only mounted
+		 * WIM */
+		wimlib_assert(!(mount_flags & WIMLIB_MOUNT_FLAG_READWRITE));
 		return 0;
+	}
 
-	if (lte->staging_file_name) {
-
-		/* Read from staging */
-		int fd;
-		off_t cur_offset;
-		ssize_t ret;
+	if (fd->lte->staging_file_name) {
+		/* Read from staging file */
 
-		if (lte->staging_num_times_opened == 0)
-			return -EBADF;
+		wimlib_assert(fd->staging_fd != -1);
 
-		fd = lte->staging_fd;
-		cur_offset = lte->staging_offset;
-		if (cur_offset != offset)
-			if (lseek(fd, offset, SEEK_SET) == -1)
-				return -errno;
-		lte->staging_offset = offset;
+		ssize_t ret;
+		DEBUG("Seek to offset %zu", offset);
 
-		ret = read(fd, buf, size);
+		if (lseek(fd->staging_fd, offset, SEEK_SET) == -1)
+			return -errno;
+		ret = read(fd->staging_fd, buf, size);
 		if (ret == -1)
 			return -errno;
-		lte->staging_offset = offset + ret;
-
 		return ret;
 	} else {
 
@@ -727,7 +1051,7 @@ static int wimfs_read(const char *path, char *buf, size_t size,
 		struct resource_entry *res_entry;
 		int ctype;
 		
-		res_entry = &lte->resource_entry;
+		res_entry = &fd->lte->resource_entry;
 
 		ctype = wim_resource_compression_type(w, res_entry);
 
@@ -750,12 +1074,14 @@ static int wimfs_read(const char *path, char *buf, size_t size,
 static int wimfs_readdir(const char *path, void *buf, fuse_fill_dir_t filler, 
 				off_t offset, struct fuse_file_info *fi)
 {
-	struct dentry *parent = (struct dentry*) fi->fh;
+	struct dentry *parent, *child;
+	
+	parent = (struct dentry*)fi->fh;
+	child = parent->children;
+
 	filler(buf, ".", NULL, 0);
 	filler(buf, "..", NULL, 0);
 
-	child = parent->children;
-
 	if (!child)
 		return 0;
 
@@ -786,30 +1112,53 @@ static int wimfs_readlink(const char *path, char *buf, size_t buf_len)
 /* Close a file. */
 static int wimfs_release(const char *path, struct fuse_file_info *fi)
 {
-	struct lookup_table_entry *lte;
 	int ret;
+	struct wimlib_fd *fd = (struct wimlib_fd*)fi->fh;
 
-	lte = (struct lookup_table_entry*)fi->fh;
-	
-	if (!lte || lte->staging_num_times_opened == 0)
-		return -EBADF;
+	if (!fd) {
+		/* Empty file with no lookup table entry on read-only mounted
+		 * WIM */
+		wimlib_assert(!(mount_flags & WIMLIB_MOUNT_FLAG_READWRITE));
+		return 0;
+	}
 
-	if (--lte->staging_num_times_opened == 0 && lte->staging_file_name) {
-		ret = close(lte->staging_fd);
-		if (lte->refcnt == 0)
-			free_lookup_table_entry(lte);
-		if (ret != 0)
-			return -errno;
+	if (flags_writable(fi->flags) && fd->dentry) {
+		u64 now = get_timestamp();
+		fd->dentry->last_access_time = now;
+		fd->dentry->last_write_time = now;
 	}
+
+	return close_wimlib_fd(fd);
+}
+
+static int wimfs_releasedir(const char *path, struct fuse_file_info *fi)
+{
+	struct dentry *dentry = (struct dentry *)fi->fh;
+
+	wimlib_assert(dentry->num_times_opened);
+	if (--dentry->num_times_opened == 0)
+		free_dentry(dentry);
 	return 0;
 }
 
+static int wimfs_removexattr(const char *path, const char *name)
+{
+	/* XXX */
+	return -ENOTSUP;
+}
+
 /* Renames a file or directory.  See rename (3) */
 static int wimfs_rename(const char *from, const char *to)
 {
 	struct dentry *src;
 	struct dentry *dst;
 	struct dentry *parent_of_dst;
+	char *file_name_utf16 = NULL, *file_name_utf8 = NULL;
+	u16 file_name_utf16_len, file_name_utf8_len;
+	int ret;
+
+	/* This rename() implementation currently only supports actual files
+	 * (not alternate data streams) */
 	
 	src = get_dentry(w, from);
 	if (!src)
@@ -817,7 +1166,17 @@ static int wimfs_rename(const char *from, const char *to)
 
 	dst = get_dentry(w, to);
 
+
+	ret = get_names(&file_name_utf16, &file_name_utf8,
+			&file_name_utf16_len, &file_name_utf8_len,
+			path_basename(to));
+	if (ret != 0)
+		return -ENOMEM;
+
 	if (dst) {
+		if (src == dst) /* Same file */
+			return 0;
+
 		if (!dentry_is_directory(src)) {
 			/* Cannot rename non-directory to directory. */
 			if (dentry_is_directory(dst))
@@ -831,19 +1190,22 @@ static int wimfs_rename(const char *from, const char *to)
 				return -ENOTEMPTY;
 		}
 		parent_of_dst = dst->parent;
-		unlink_dentry(dst);
-		lookup_table_decrement_refcnt(w->lookup_table, dst->hash);
-		free_dentry(dst);
+		remove_dentry(dst, w->lookup_table);
 	} else {
 		parent_of_dst = get_parent_dentry(w, to);
 		if (!parent_of_dst)
 			return -ENOENT;
 	}
 
+	FREE(src->file_name);
+	FREE(src->file_name_utf8);
+	src->file_name          = file_name_utf16;
+	src->file_name_utf8     = file_name_utf8;
+	src->file_name_len      = file_name_utf16_len;
+	src->file_name_utf8_len = file_name_utf8_len;
+
 	unlink_dentry(src);
-	change_dentry_name(src, path_basename(to));
 	link_dentry(src, parent_of_dst);
-	/*calculate_dentry_full_path(src);*/
 	return 0;
 }
 
@@ -860,74 +1222,51 @@ static int wimfs_rmdir(const char *path)
 		return -ENOTEMPTY;
 
 	unlink_dentry(dentry);
-	free_dentry(dentry);
+	if (dentry->num_times_opened == 0)
+		free_dentry(dentry);
 	return 0;
 }
 
-/* Extracts the resource corresponding to @dentry and its lookup table entry
- * @lte to a file in the staging directory.  The lookup table entry for @dentry
- * is updated to point to the new file.  If @lte has multiple dentries
- * referencing it, a new lookup table entry is created and the hash of @dentry
- * is changed to point to the new lookup table entry.
- *
- * Only @size bytes are extracted, to support truncating the file. 
- *
- * Returns the negative error code on failure.
- */
-static int extract_resource_to_staging_dir(u8 *dentry_hash,
-					   struct lookup_table_entry *lte, 
-					   u64 size)
+static int wimfs_setxattr(const char *path, const char *name,
+			  const char *value, size_t size, int flags)
 {
-	int fd;
-	bool ret;
-	char *staging_file_name;
-	struct lookup_table_entry *new_lte;
-
-	/* File in WIM.  Copy it to the staging directory. */
-	fd = create_staging_file(&staging_file_name);
-	if (fd == -1)
-		return -errno;
-
-	ret = extract_resource_to_fd(w, &lte->resource_entry, fd, size);
-	if (ret != 0) {
-		if (errno != 0)
-			ret = -errno;
-		else
-			ret = -EIO;
-		unlink(staging_file_name);
-		FREE(staging_file_name);
-		return ret;
-	}
+	/* XXX */
+	return -ENOTSUP;
+}
 
-	if (lte->refcnt != 1) {
-		/* Need to make a new lookup table entry if we are
-		 * changing only one copy of a hardlinked entry */
-		lte->refcnt--;
+static int wimfs_symlink(const char *to, const char *from)
+{
+	struct dentry *dentry_parent, *dentry;
+	const char *link_name;
+	
+	dentry_parent = get_parent_dentry(w, from);
+	if (!dentry_parent)
+		return -ENOENT;
+	if (!dentry_is_directory(dentry_parent))
+		return -ENOTDIR;
 
-		new_lte = new_lookup_table_entry();
-		if (!new_lte)
-			return -ENOMEM;
-		randomize_byte_array(dentry_hash, WIM_HASH_SIZE);
-		memcpy(new_lte->hash, dentry_hash, WIM_HASH_SIZE);
+	link_name = path_basename(from);
 
-		new_lte->resource_entry.flags = 0;
-		new_lte->staging_num_times_opened = lte->staging_num_times_opened;
+	if (get_dentry_child_with_name(dentry_parent, link_name))
+		return -EEXIST;
+	dentry = new_dentry(link_name);
+	if (!dentry)
+		return -ENOMEM;
 
-		lookup_table_insert(w->lookup_table, new_lte);
+	dentry->attributes = FILE_ATTRIBUTE_REPARSE_POINT;
+	dentry->reparse_tag = WIM_IO_REPARSE_TAG_SYMLINK;
 
-		lte = new_lte;
-	} 
+	if (dentry_set_symlink(dentry, to, w->lookup_table) != 0)
+		goto out_free_dentry;
 
-	lte->resource_entry.original_size = size;
-	lte->staging_file_name = staging_file_name;
-	
-	if (lte->staging_num_times_opened == 0)
-		close(fd);
-	else
-		lte->staging_fd = fd;
+	link_dentry(dentry, dentry_parent);
 	return 0;
+out_free_dentry:
+	free_dentry(dentry);
+	return -ENOMEM;
 }
 
+
 /* Reduce the size of a file */
 static int wimfs_truncate(const char *path, off_t size)
 {
@@ -946,20 +1285,16 @@ static int wimfs_truncate(const char *path, off_t size)
 		return 0;
 
 	if (lte->staging_file_name) {
-		/* File on disk.  Call POSIX API */
-		if (lte->staging_num_times_opened != 0)
-			ret = ftruncate(lte->staging_fd, size);
-		else
-			ret = truncate(lte->staging_file_name, size);
+		ret = truncate(lte->staging_file_name, size);
 		if (ret != 0)
 			return -errno;
-		dentry_update_all_timestamps(dentry);
 		lte->resource_entry.original_size = size;
 	} else {
 		/* File in WIM.  Extract it to the staging directory, but only
 		 * the first @size bytes of it. */
-		ret = extract_resource_to_staging_dir(dentry_hash, lte, size);
+		ret = extract_resource_to_staging_dir(dentry, &lte, size);
 	}
+	dentry_update_all_timestamps(dentry);
 	return ret;
 }
 
@@ -977,25 +1312,10 @@ static int wimfs_unlink(const char *path)
 	if (ret != 0)
 		return ret;
 
-	if (lte && lte->staging_file_name)
-		if (unlink(lte->staging_file_name) != 0)
-			return -errno;
-
 	if (dentry_hash == dentry->hash) {
 		/* We are removing the full dentry including all alternate data
 		 * streams. */
-		const u8 *hash = dentry->hash;
-		u16 i = 0;
-		while (1) {
-			lookup_table_decrement_refcnt(w->lookup_table, hash);
-			if (i == dentry->num_ads)
-				break;
-			hash = dentry->ads_entries[i].hash;
-			i++;
-		}
-
-		unlink_dentry(dentry);
-		free_dentry(dentry);
+		remove_dentry(dentry, w->lookup_table);
 	} else {
 		/* We are removing an alternate data stream. */
 		struct ads_entry *cur_entry = dentry->ads_entries;
@@ -1034,59 +1354,54 @@ static int wimfs_utimens(const char *path, const struct timespec tv[2])
 static int wimfs_write(const char *path, const char *buf, size_t size, 
 		       off_t offset, struct fuse_file_info *fi)
 {
-	/* Grab our lookup table entry from the FUSE file info structure. */
-	struct lookup_table_entry *lte;
-	lte = (struct lookup_table_entry*)fi->fh;
+	struct wimlib_fd *fd = (struct wimlib_fd*)fi->fh;
 	int ret;
 
-	if (!lte || !lte->staging_file_name)
-		return -EBADF;
+	wimlib_assert(fd->lte);
+	wimlib_assert(fd->lte->staging_file_name);
+	wimlib_assert(fd->staging_fd != -1);
 
-	/* Seek to correct position in file if needed. */
-	if (lte->staging_offset != offset) {
-		if (lseek(lte->staging_fd, offset, SEEK_SET) == -1)
-			return -errno;
-		lte->staging_offset = offset;
-	}
+	/* Seek to the requested position */
+	if (lseek(fd->staging_fd, offset, SEEK_SET) == -1)
+		return -errno;
 
 	/* Write the data. */
-	ret = write(lte->staging_fd, buf, size);
+	ret = write(fd->staging_fd, buf, size);
 	if (ret == -1)
 		return -errno;
 
-	/* Adjust the stored offset of staging_fd. */
-	lte->staging_offset = offset + ret;
-
-	/* Increase file size if needed. */
-	if (lte->resource_entry.original_size < lte->staging_offset)
-		lte->resource_entry.original_size = lte->staging_offset;
-
-	/* The file has been modified, so all its timestamps must be
-	 * updated. */
-	dentry_update_all_timestamps(dentry);
-
 	return ret;
 }
 
 
-static struct fuse_operations wimfs_oper = {
-	.access   = wimfs_access,
-	.destroy  = wimfs_destroy,
-	.getattr  = wimfs_getattr,
-	.mkdir    = wimfs_mkdir,
-	.mknod    = wimfs_mknod,
-	.open     = wimfs_open,
-	.opendir  = wimfs_opendir,
-	.read     = wimfs_read,
-	.readdir  = wimfs_readdir,
-	.readlink = wimfs_readlink,
-	.release  = wimfs_release,
-	.rename   = wimfs_rename,
-	.rmdir    = wimfs_rmdir,
-	.truncate = wimfs_truncate,
-	.unlink   = wimfs_unlink,
-	.utimens  = wimfs_utimens,
-	.write    = wimfs_write,
+static struct fuse_operations wimfs_operations = {
+	.access      = wimfs_access,
+	.destroy     = wimfs_destroy,
+	.fallocate   = wimfs_fallocate,
+	.fgetattr    = wimfs_fgetattr,
+	.ftruncate   = wimfs_ftruncate,
+	.getattr     = wimfs_getattr,
+	.getxattr    = wimfs_getxattr,
+	.link        = wimfs_link,
+	.listxattr   = wimfs_listxattr,
+	.mkdir       = wimfs_mkdir,
+	.mknod       = wimfs_mknod,
+	.open        = wimfs_open,
+	.opendir     = wimfs_opendir,
+	.read        = wimfs_read,
+	.readdir     = wimfs_readdir,
+	.readlink    = wimfs_readlink,
+	.release     = wimfs_release,
+	.releasedir  = wimfs_releasedir,
+	.removexattr = wimfs_removexattr,
+	.rename      = wimfs_rename,
+	.rmdir       = wimfs_rmdir,
+	.setxattr    = wimfs_setxattr,
+	.symlink     = wimfs_symlink,
+	.truncate    = wimfs_truncate,
+	.unlink      = wimfs_unlink,
+	.utimens     = wimfs_utimens,
+	.write       = wimfs_write,
 };
 
 
@@ -1095,7 +1410,7 @@ WIMLIBAPI int wimlib_mount(WIMStruct *wim, int image, const char *dir,
 			   int flags)
 {
 	int argc = 0;
-	char *argv[6];
+	char *argv[16];
 	int ret;
 	char *p;
 
@@ -1110,6 +1425,10 @@ WIMLIBAPI int wimlib_mount(WIMStruct *wim, int image, const char *dir,
 	if (ret != 0)
 		return ret;
 
+	DEBUG("Selected image %d", image);
+
+	next_link_group_id = assign_link_groups(wim->image_metadata[image - 1].lgt);
+
 	if (flags & WIMLIB_MOUNT_FLAG_READWRITE)
 		wim_get_current_image_metadata(wim)->modified = true;
 
@@ -1136,16 +1455,19 @@ WIMLIBAPI int wimlib_mount(WIMStruct *wim, int image, const char *dir,
 	if (flags & WIMLIB_MOUNT_FLAG_DEBUG) {
 		argv[argc++] = "-d";
 	}
-	if (!(flags & WIMLIB_MOUNT_FLAG_READWRITE)) {
-		argv[argc++] = "-o";
-		argv[argc++] = "ro";
-	} else {
+	char optstring[256] = "use_ino";
+	argv[argc++] = "-o";
+	argv[argc++] = optstring;
+	if ((flags & WIMLIB_MOUNT_FLAG_READWRITE)) {
 		make_staging_dir();
 		if (!staging_dir_name) {
 			FREE(p);
 			return WIMLIB_ERR_MKDIR;
 		}
+	} else {
+		strcat(optstring, ",ro");
 	}
+	argv[argc] = NULL;
 
 #ifdef ENABLE_DEBUG
 	{
@@ -1164,7 +1486,7 @@ WIMLIBAPI int wimlib_mount(WIMStruct *wim, int image, const char *dir,
 	w = wim;
 	mount_flags = flags;
 
-	ret = fuse_main(argc, argv, &wimfs_oper, NULL);
+	ret = fuse_main(argc, argv, &wimfs_operations, NULL);
 
 	return (ret == 0) ? 0 : WIMLIB_ERR_FUSE;
 }