*/
/*
- * Copyright (C) 2012, 2013 Eric Biggers
+ * Copyright (C) 2012, 2013, 2014 Eric Biggers
*
* This file is part of wimlib, a library for working with WIM files.
*
#include "wimlib/lookup_table.h"
#include "wimlib/metadata.h"
#include "wimlib/paths.h"
+#include "wimlib/progress.h"
#include "wimlib/reparse.h"
#include "wimlib/resource.h"
#include "wimlib/timestamp.h"
new->d_inode->i_attributes = attributes;
if (wimfs_ctx->mount_flags & WIMLIB_MOUNT_FLAG_UNIX_DATA) {
- if (inode_set_unix_data(new->d_inode,
- fuse_ctx->uid,
- fuse_ctx->gid,
- fuse_mask_mode(mode, fuse_ctx),
- wimfs_ctx->wim->lookup_table,
- UNIX_DATA_ALL | UNIX_DATA_CREATE))
- {
- free_dentry(new);
- return -ENOMEM;
- }
+ new->d_inode->i_unix_data.uid = fuse_ctx->uid;
+ new->d_inode->i_unix_data.gid = fuse_ctx->gid;
+ new->d_inode->i_unix_data.mode = fuse_mask_mode(mode, fuse_ctx);
}
dentry_add_child(parent, new);
list_add_tail(&new->d_inode->i_list, wimfs_ctx->image_inode_list);
return NULL;
}
-/* Remove a dentry from a mounted WIM image; i.e. remove an alias for the
- * corresponding inode.
- *
- * If there are no remaining references to the inode either through dentries or
- * open file descriptors, the inode is freed. Otherwise, the inode is not
- * removed, but the dentry is unlinked and freed.
- *
- * Either way, all lookup table entries referenced by the inode have their
- * reference count decremented. If a lookup table entry has no open file
- * descriptors and no references remaining, it is freed, and the corresponding
- * staging file is unlinked.
+/*
+ * Remove a dentry from a mounted WIM image; i.e. remove an alias for an inode.
*/
static void
remove_dentry(struct wim_dentry *dentry,
struct wim_lookup_table *lookup_table)
{
- struct wim_inode *inode = dentry->d_inode;
- struct wim_lookup_table_entry *lte;
- unsigned i;
+ /* Put a reference to each stream the inode contains. */
+ inode_unref_streams(dentry->d_inode, lookup_table);
- for (i = 0; i <= inode->i_num_ads; i++) {
- lte = inode_stream_lte(inode, i, lookup_table);
- if (lte)
- lte_decrement_refcnt(lte, lookup_table);
- }
+ /* Unlink the dentry from the image's dentry tree. */
unlink_dentry(dentry);
+
+ /* Delete the dentry. This will also decrement the link count of the
+ * corresponding inode. */
free_dentry(dentry);
}
static mode_t
-inode_default_unix_mode(const struct wim_inode *inode)
+inode_unix_file_type(const struct wim_inode *inode)
{
if (inode_is_symlink(inode))
- return S_IFLNK | 0777;
+ return S_IFLNK;
else if (inode_is_directory(inode))
- return S_IFDIR | 0777;
+ return S_IFDIR;
else
- return S_IFREG | 0777;
+ return S_IFREG;
+}
+
+static mode_t
+inode_default_unix_mode(const struct wim_inode *inode)
+{
+ return inode_unix_file_type(inode) | 0777;
}
/* Transfers file attributes from a struct wim_inode to a `stat' buffer.
const struct wimfs_context *ctx = wimfs_get_context();
memset(stbuf, 0, sizeof(struct stat));
- stbuf->st_mode = inode_default_unix_mode(inode);
- stbuf->st_uid = ctx->default_uid;
- stbuf->st_gid = ctx->default_gid;
- if (ctx->mount_flags & WIMLIB_MOUNT_FLAG_UNIX_DATA) {
- struct wimlib_unix_data unix_data;
- if (inode_get_unix_data(inode, &unix_data, NULL) == 0) {
- stbuf->st_uid = unix_data.uid;
- stbuf->st_gid = unix_data.gid;
- stbuf->st_mode = unix_data.mode;
- }
+ if ((ctx->mount_flags & WIMLIB_MOUNT_FLAG_UNIX_DATA) &&
+ inode_has_unix_data(inode))
+ {
+ stbuf->st_uid = inode->i_unix_data.uid;
+ stbuf->st_gid = inode->i_unix_data.gid;
+ stbuf->st_mode = inode->i_unix_data.mode;
+ } else {
+ stbuf->st_uid = ctx->default_uid;
+ stbuf->st_gid = ctx->default_gid;
+ stbuf->st_mode = inode_default_unix_mode(inode);
}
stbuf->st_ino = (ino_t)inode->i_ino;
stbuf->st_nlink = inode->i_nlink;
/* Overwrites the WIM file, with changes saved. */
static int
-rebuild_wim(struct wimfs_context *ctx, int write_flags,
- wimlib_progress_func_t progress_func)
+rebuild_wim(struct wimfs_context *ctx, int write_flags)
{
int ret;
struct wim_lookup_table_entry *lte, *tmp;
}
xml_update_image_info(wim, wim->current_image);
- ret = wimlib_overwrite(wim, write_flags, 0, progress_func);
+ ret = wimlib_overwrite(wim, write_flags, 0);
if (ret)
ERROR("Failed to commit changes to mounted WIM image");
return ret;
pid_t daemon_pid;
int mount_flags;
int status;
- wimlib_progress_func_t progress_func;
+ wimlib_progress_func_t progfunc;
+ void *progctx;
};
struct daemon_msg_handler_context {
ERROR_WITH_ERRNO("Failed to send status to unmount process");
}
-static int
+static enum wimlib_progress_status
unmount_progress_func(enum wimlib_progress_msg msg,
- const union wimlib_progress_info *info)
+ union wimlib_progress_info *info, void *_ignored_context)
{
if (msg == WIMLIB_PROGRESS_MSG_WRITE_STREAMS) {
struct msg_write_streams_progress msg = {
"to unmount process");
}
}
- return 0;
+ return WIMLIB_PROGRESS_STATUS_CONTINUE;
}
static void
struct wim_lookup_table *lookup_table = ctx->wim->lookup_table;
struct wim_lookup_table_entry *lte, *tmp;
- list_for_each_entry_safe(lte, tmp, list, orig_stream_list)
- while (lte->out_refcnt--)
+ list_for_each_entry_safe(lte, tmp, list, orig_stream_list) {
+ u32 n = lte->out_refcnt;
+ while (n--)
lte_decrement_refcnt(lte, lookup_table);
+ }
}
/* Moves the currently selected image, which may have been modified, to a new
int status = 0;
int ret;
int unmount_flags;
- wimlib_progress_func_t progress_func;
DEBUG("Handling unmount request msg");
}
unmount_flags = msg->unmount_flags;
- if (msg->want_progress_messages)
- progress_func = unmount_progress_func;
- else
- progress_func = NULL;
+
+ wimlib_register_progress_function(wimfs_ctx->wim,
+ (msg->want_progress_messages ?
+ unmount_progress_func : NULL),
+ NULL);
ret = send_daemon_info_msg(wimfs_ctx->daemon_to_unmount_mq, getpid(),
wimfs_ctx->mount_flags);
write_flags |= WIMLIB_WRITE_FLAG_REBUILD;
if (unmount_flags & WIMLIB_UNMOUNT_FLAG_RECOMPRESS)
write_flags |= WIMLIB_WRITE_FLAG_RECOMPRESS;
- status = rebuild_wim(wimfs_ctx, write_flags,
- progress_func);
+ status = rebuild_wim(wimfs_ctx, write_flags);
}
} else {
DEBUG("Read-only mount");
if (msg->hdr.msg_size < sizeof(*msg))
return WIMLIB_ERR_INVALID_UNMOUNT_MESSAGE;
- if (handler_ctx->progress_func) {
- handler_ctx->progress_func(WIMLIB_PROGRESS_MSG_WRITE_STREAMS,
- &msg->info);
- }
- return 0;
+ return call_progress(handler_ctx->progfunc,
+ WIMLIB_PROGRESS_MSG_WRITE_STREAMS,
+ (union wimlib_progress_info *)&msg->info,
+ handler_ctx->progctx);
}
static int
wimfs_chmod(const char *path, mode_t mask)
{
struct wim_dentry *dentry;
+ struct wim_inode *inode;
struct wimfs_context *ctx = wimfs_get_context();
int ret;
if (ret)
return ret;
- ret = inode_set_unix_data(dentry->d_inode, ctx->default_uid,
- ctx->default_gid, mask,
- ctx->wim->lookup_table, UNIX_DATA_MODE);
- return ret ? -ENOMEM : 0;
+ inode = dentry->d_inode;
+
+ if (!inode_has_unix_data(inode)) {
+ inode->i_unix_data.uid = ctx->default_uid;
+ inode->i_unix_data.gid = ctx->default_gid;
+ }
+ inode->i_unix_data.mode = mask;
+ return 0;
}
static int
wimfs_chown(const char *path, uid_t uid, gid_t gid)
{
struct wim_dentry *dentry;
+ struct wim_inode *inode;
struct wimfs_context *ctx = wimfs_get_context();
int ret;
if (ret)
return ret;
- ret = inode_set_unix_data(dentry->d_inode, uid, gid,
- inode_default_unix_mode(dentry->d_inode),
- ctx->wim->lookup_table,
- UNIX_DATA_UID | UNIX_DATA_GID);
- return ret ? -ENOMEM : 0;
+ inode = dentry->d_inode;
+
+ if (!inode_has_unix_data(inode))
+ inode->i_unix_data.mode = inode_default_unix_mode(inode);
+ inode->i_unix_data.uid = uid;
+ inode->i_unix_data.gid = gid;
+ return 0;
}
/* Called when the filesystem is unmounted. */
return ret;
}
-struct fill_params {
- void *buf;
- fuse_fill_dir_t filler;
-};
-
-static int
-dentry_fuse_fill(struct wim_dentry *dentry, void *arg)
-{
- struct fill_params *fill_params = arg;
-
- char *file_name_mbs;
- size_t file_name_mbs_nbytes;
- int ret;
-
- ret = utf16le_to_tstr(dentry->file_name,
- dentry->file_name_nbytes,
- &file_name_mbs,
- &file_name_mbs_nbytes);
- if (ret)
- return -errno;
-
- ret = fill_params->filler(fill_params->buf, file_name_mbs, NULL, 0);
- FREE(file_name_mbs);
- return ret;
-}
-
/* Fills in the entries of the directory specified by @path using the
* FUSE-provided function @filler. */
static int
{
struct wimfs_fd *fd = (struct wimfs_fd*)(uintptr_t)fi->fh;
struct wim_inode *inode;
+ struct wim_dentry *child;
+ int ret;
if (!fd)
return -EBADF;
inode = fd->f_inode;
- struct fill_params fill_params = {
- .buf = buf,
- .filler = filler,
- };
+ ret = filler(buf, ".", NULL, 0);
+ if (ret)
+ return ret;
+ ret = filler(buf, "..", NULL, 0);
+ if (ret)
+ return ret;
- filler(buf, ".", NULL, 0);
- filler(buf, "..", NULL, 0);
+ for_inode_child(child, inode) {
+ char *file_name_mbs;
+ size_t file_name_mbs_nbytes;
- return for_dentry_in_rbtree(inode->i_children.rb_node,
- dentry_fuse_fill, &fill_params);
+ ret = utf16le_to_tstr(child->file_name,
+ child->file_name_nbytes,
+ &file_name_mbs,
+ &file_name_mbs_nbytes);
+ if (ret)
+ return -errno;
+
+ ret = filler(buf, file_name_mbs, NULL, 0);
+ FREE(file_name_mbs);
+ if (ret)
+ return ret;
+ }
+ return 0;
}
wimfs_rename(const char *from, const char *to)
{
return rename_wim_path(wimfs_get_WIMStruct(), from, to,
- WIMLIB_CASE_SENSITIVE);
+ WIMLIB_CASE_SENSITIVE, NULL);
}
/* Remove a directory */
static int
wimfs_utimens(const char *path, const struct timespec tv[2])
{
- struct wim_dentry *dentry;
struct wim_inode *inode;
WIMStruct *wim = wimfs_get_WIMStruct();
- dentry = get_dentry(wim, path, WIMLIB_CASE_SENSITIVE);
- if (!dentry)
+ inode = wim_pathname_to_inode(wim, path);
+ if (!inode)
return -errno;
- inode = dentry->d_inode;
if (tv[0].tv_nsec != UTIME_OMIT) {
if (tv[0].tv_nsec == UTIME_NOW)
static int
wimfs_utime(const char *path, struct utimbuf *times)
{
- struct wim_dentry *dentry;
struct wim_inode *inode;
WIMStruct *wim = wimfs_get_WIMStruct();
- dentry = get_dentry(wim, path, WIMLIB_CASE_SENSITIVE);
- if (!dentry)
+ inode = wim_pathname_to_inode(wim, path);
+ if (!inode)
return -errno;
- inode = dentry->d_inode;
inode->i_last_write_time = unix_timestamp_to_wim(times->modtime);
inode->i_last_access_time = unix_timestamp_to_wim(times->actime);
/* API function documented in wimlib.h */
WIMLIBAPI int
-wimlib_unmount_image(const char *dir, int unmount_flags,
- wimlib_progress_func_t progress_func)
+wimlib_unmount_image_with_progress(const tchar *dir, int unmount_flags,
+ wimlib_progress_func_t progfunc, void *progctx)
{
int ret;
struct wimfs_context wimfs_ctx;
ret = send_unmount_request_msg(wimfs_ctx.unmount_to_daemon_mq,
unmount_flags,
- progress_func != NULL);
+ progfunc != NULL);
if (ret != 0)
goto out_close_message_queues;
.timeout_seconds = 5,
},
.daemon_pid = 0,
- .progress_func = progress_func,
+ .progfunc = progfunc,
+ .progctx = progctx,
};
ret = message_loop(wimfs_ctx.daemon_to_unmount_mq,
}
WIMLIBAPI int
-wimlib_unmount_image(const tchar *dir, int unmount_flags,
- wimlib_progress_func_t progress_func)
+wimlib_unmount_image_with_progress(const tchar *dir, int unmount_flags,
+ wimlib_progress_func_t progfunc, void *progctx)
{
return mount_unsupported_error();
}
}
#endif /* !WITH_FUSE */
+
+
+WIMLIBAPI int
+wimlib_unmount_image(const tchar *dir, int unmount_flags)
+{
+ return wimlib_unmount_image_with_progress(dir, unmount_flags, NULL, NULL);
+}
git://wimlib.net / wimlib / blobdiff