return wimfs_get_context()->wim;
}
+static inline bool wimfs_ctx_readonly(const struct wimfs_context *ctx)
+{
+ return (ctx->mount_flags & WIMLIB_MOUNT_FLAG_READWRITE) == 0;
+}
+
static inline int get_lookup_flags(const struct wimfs_context *ctx)
{
if (ctx->mount_flags & WIMLIB_MOUNT_FLAG_STREAM_INTERFACE_WINDOWS)
* @stream_id: ID of the stream we're opening
* @lte: Lookup table entry for the stream (may be NULL)
* @fd_ret: Return the allocated file descriptor if successful.
+ * @readonly: True if this is a read-only mount.
*
* Return 0 iff successful or error code if unsuccessful.
*/
static int alloc_wimlib_fd(struct inode *inode,
u32 stream_id,
struct lookup_table_entry *lte,
- struct wimlib_fd **fd_ret)
+ struct wimlib_fd **fd_ret,
+ bool readonly)
{
static const u16 fds_per_alloc = 8;
static const u16 max_fds = 0xffff;
+ int ret;
+
+ pthread_mutex_lock(&inode->i_mutex);
DEBUG("Allocating fd for stream ID %u from inode %lx (open = %u, allocated = %u)",
stream_id, inode->ino, inode->num_opened_fds,
struct wimlib_fd **fds;
u16 num_new_fds;
- if (inode->num_allocated_fds == max_fds)
- return -EMFILE;
+ if (inode->num_allocated_fds == max_fds) {
+ ret = -EMFILE;
+ goto out;
+ }
num_new_fds = min(fds_per_alloc,
max_fds - inode->num_allocated_fds);
fds = REALLOC(inode->fds,
(inode->num_allocated_fds + num_new_fds) *
sizeof(inode->fds[0]));
- if (!fds)
- return -ENOMEM;
+ if (!fds) {
+ ret = -ENOMEM;
+ goto out;
+ }
memset(&fds[inode->num_allocated_fds], 0,
num_new_fds * sizeof(fds[0]));
inode->fds = fds;
for (u16 i = 0; ; i++) {
if (!inode->fds[i]) {
struct wimlib_fd *fd = CALLOC(1, sizeof(*fd));
- if (!fd)
- return -ENOMEM;
+ if (!fd) {
+ ret = -ENOMEM;
+ break;
+ }
fd->f_inode = inode;
fd->f_lte = lte;
fd->staging_fd = -1;
*fd_ret = fd;
inode->fds[i] = fd;
inode->num_opened_fds++;
- if (lte)
+ if (lte && !readonly)
lte->num_opened_fds++;
DEBUG("Allocated fd (idx = %u)", fd->idx);
- return 0;
+ ret = 0;
+ break;
}
}
+out:
+ pthread_mutex_unlock(&inode->i_mutex);
+ return ret;
}
static void inode_put_fd(struct inode *inode, struct wimlib_fd *fd)
{
wimlib_assert(fd != NULL);
wimlib_assert(inode != NULL);
+
+ pthread_mutex_lock(&inode->i_mutex);
+
wimlib_assert(fd->f_inode == inode);
wimlib_assert(inode->num_opened_fds != 0);
wimlib_assert(fd->idx < inode->num_allocated_fds);
inode->fds[fd->idx] = NULL;
FREE(fd);
- if (--inode->num_opened_fds == 0 && inode->link_count == 0)
+ if (--inode->num_opened_fds == 0 && inode->link_count == 0) {
+ pthread_mutex_unlock(&inode->i_mutex);
free_inode(inode);
+ } else {
+ pthread_mutex_unlock(&inode->i_mutex);
+ }
}
static int lte_put_fd(struct lookup_table_entry *lte, struct wimlib_fd *fd)
{
- wimlib_assert(fd);
+ wimlib_assert(fd != NULL);
wimlib_assert(fd->f_lte == lte);
if (!lte) /* Empty stream with no lookup table entry */
static int close_wimlib_fd(struct wimlib_fd *fd)
{
int ret;
- wimlib_assert(fd);
+ wimlib_assert(fd != NULL);
DEBUG("Closing fd (inode = %lu, opened = %u, allocated = %u)",
fd->f_inode->ino, fd->f_inode->num_opened_fds,
fd->f_inode->num_allocated_fds);
}
/*
- * Creates a randomly named staging directory and returns its name into the
- * static variable staging_dir_name.
- *
- * If the staging directory cannot be created, staging_dir_name is set to NULL.
- * */
+ * Creates a randomly named staging directory and saves its name in the
+ * filesystem context structure.
+ */
static int make_staging_dir(struct wimfs_context *ctx)
{
/* XXX Give the user an option of where to stage files */
return 0;
}
+static int wimfs_chmod(const char *path, mode_t mask)
+{
+ struct dentry *dentry;
+ struct wimfs_context *ctx = wimfs_get_context();
+ struct inode *inode;
+ struct stat stbuf;
+ int ret;
+
+ ret = lookup_resource(ctx->wim, path,
+ get_lookup_flags(ctx) | LOOKUP_FLAG_DIRECTORY_OK,
+ &dentry, NULL, NULL);
+ if (ret != 0)
+ return ret;
+ inode = dentry->d_inode;
+ inode_to_stbuf(inode, NULL, &stbuf);
+ if (mask == stbuf.st_mode)
+ return 0;
+ else
+ return -EPERM;
+
+}
+
static void inode_update_lte_ptr(struct inode *inode,
struct lookup_table_entry *old_lte,
struct lookup_table_entry *new_lte)
DEBUG("Closing all staging file descriptors.");
- list_for_each_entry(lte, &ctx->staging_list, staging_list) {
+ list_for_each_entry_safe(lte, tmp, &ctx->staging_list, staging_list) {
ret = inode_close_fds(lte->lte_inode);
if (ret != 0)
return ret;
xml_update_image_info(w, w->current_image);
- ret = wimlib_overwrite(w, check_integrity);
+ ret = wimlib_overwrite(w, check_integrity, 0);
if (ret != 0) {
ERROR("Failed to commit changes");
return ret;
if (res_size > size)
return -ERANGE;
- ret = read_full_wim_resource(lte, (u8*)value);
+ ret = read_full_wim_resource(lte, (u8*)value,
+ WIMLIB_RESOURCE_FLAG_MULTITHREADED);
if (ret != 0)
return -EIO;
lte->refcnt++;
}
- link_dentry(from_dentry, from_dentry_parent);
+ dentry_add_child(from_dentry_parent, from_dentry);
return 0;
}
newdir->d_inode->attributes |= FILE_ATTRIBUTE_DIRECTORY;
newdir->d_inode->resolved = true;
newdir->d_inode->ino = ctx->next_ino++;
- link_dentry(newdir, parent);
+ dentry_add_child(parent, newdir);
return 0;
}
return -ENOMEM;
dentry->d_inode->resolved = true;
dentry->d_inode->ino = ctx->next_ino++;
- link_dentry(dentry, parent);
+ dentry_add_child(parent, dentry);
}
return 0;
}
return ret;
}
- ret = alloc_wimlib_fd(inode, stream_id, lte, &fd);
+ ret = alloc_wimlib_fd(inode, stream_id, lte, &fd,
+ wimfs_ctx_readonly(ctx));
if (ret != 0)
return ret;
struct inode *inode;
int ret;
struct wimlib_fd *fd = NULL;
- WIMStruct *w = wimfs_get_WIMStruct();
+ struct wimfs_context *ctx = wimfs_get_context();
+ WIMStruct *w = ctx->wim;
inode = wim_pathname_to_inode(w, path);
if (!inode)
return -ENOENT;
if (!inode_is_directory(inode))
return -ENOTDIR;
- ret = alloc_wimlib_fd(inode, 0, NULL, &fd);
+ ret = alloc_wimlib_fd(inode, 0, NULL, &fd, wimfs_ctx_readonly(ctx));
fi->fh = (uintptr_t)fd;
return ret;
}
} else {
/* Read from WIM */
+ wimlib_assert(fd->f_lte->resource_location == RESOURCE_IN_WIM);
+
u64 res_size = wim_resource_size(fd->f_lte);
if (offset > res_size)
size = min(size, res_size - offset);
if (read_wim_resource(fd->f_lte, (u8*)buf,
- size, offset, false) != 0)
+ size, offset,
+ WIMLIB_RESOURCE_FLAG_MULTITHREADED) != 0)
return -EIO;
return size;
}
if (!inode_is_symlink(inode))
return -EINVAL;
- ret = inode_readlink(inode, buf, buf_len, ctx->wim);
+ ret = inode_readlink(inode, buf, buf_len, ctx->wim,
+ WIMLIB_RESOURCE_FLAG_MULTITHREADED);
if (ret > 0)
ret = 0;
return ret;
src->file_name_utf8_len = file_name_utf8_len;
unlink_dentry(src);
- link_dentry(src, parent_of_dst);
+ dentry_add_child(parent_of_dst, src);
return 0;
}
if (inode_set_symlink(inode, to, ctx->wim->lookup_table, NULL) != 0)
goto out_free_dentry;
- link_dentry(dentry, dentry_parent);
+ dentry_add_child(dentry_parent, dentry);
return 0;
out_free_dentry:
free_dentry(dentry);
static struct fuse_operations wimfs_operations = {
.access = wimfs_access,
+ .chmod = wimfs_chmod,
.destroy = wimfs_destroy,
#if 0
.fallocate = wimfs_fallocate,
.utime = wimfs_utime,
#endif
.write = wimfs_write,
+
+#if FUSE_MAJOR_VERSION > 2 || (FUSE_MAJOR_VERSION == 2 && FUSE_MINOR_VERSION >= 8)
+ .flag_nullpath_ok = 1,
+#endif
+#if FUSE_MAJOR_VERSION > 2 || (FUSE_MAJOR_VERSION == 2 && FUSE_MINOR_VERSION >= 9)
+ .flag_nopath = 1,
+ .flag_utime_omit_ok = 1,
+#endif
};
if (ret != 0)
return ret;
+ if ((flags & WIMLIB_MOUNT_FLAG_READWRITE) && (wim->hdr.total_parts != 1)) {
+ ERROR("Cannot mount a split WIM read-write");
+ return WIMLIB_ERR_SPLIT_UNSUPPORTED;
+ }
+
if (num_additional_swms) {
ret = new_joined_lookup_table(wim, additional_swms,
num_additional_swms,
if (imd->root_dentry->refcnt != 1) {
ERROR("Cannot mount image that was just exported with "
- "wimlib_export()");
+ "wimlib_export_image()");
+ ret = WIMLIB_ERR_INVALID_PARAM;
+ goto out;
+ }
+
+ if (imd->modified) {
+ ERROR("Cannot mount image that was added "
+ "with wimlib_add_image()");
ret = WIMLIB_ERR_INVALID_PARAM;
goto out;
}
argv[argc++] = "imagex";
argv[argc++] = dir_copy;
- argv[argc++] = "-s"; /* disable multi-threaded operation */
+
+ /* disable multi-threaded operation for read-write mounts */
+ if (flags & WIMLIB_MOUNT_FLAG_READWRITE)
+ argv[argc++] = "-s";
if (flags & WIMLIB_MOUNT_FLAG_DEBUG)
argv[argc++] = "-d";
#endif
/* Mark dentry tree as modified if read-write mount. */
- if (flags & WIMLIB_MOUNT_FLAG_READWRITE)
+ if (flags & WIMLIB_MOUNT_FLAG_READWRITE) {
imd->modified = true;
+ imd->has_been_mounted_rw = true;
+ }
/* Resolve all the lookup table entries of the dentry tree */
DEBUG("Resolving lookup table entries");