X-Git-Url: https://wimlib.net/git/?p=wimlib;a=blobdiff_plain;f=src%2Fmount_image.c;h=a2e09b435e43a60a72db289e0839c747315ceeaa;hp=2f09ce7c0102d73ef0cd20c167aa440fe7f584e5;hb=394c5bd3292c0f3168416c0a5f25989e557b3cfc;hpb=14baa6ae892debbaa18dba8119931580efd0e517 diff --git a/src/mount_image.c b/src/mount_image.c index 2f09ce7c..a2e09b43 100644 --- a/src/mount_image.c +++ b/src/mount_image.c @@ -30,6 +30,10 @@ #ifdef WITH_FUSE +#ifdef __WIN32__ +# error "FUSE mount not supported on Win32! Please configure --without-fuse" +#endif + #include "buffer_io.h" #include "lookup_table.h" #include "sha1.h" @@ -78,7 +82,7 @@ struct wimfs_context { * file in the WIM is modified, it is extracted to the staging directory. If * changes are commited when the WIM is unmounted, the file resources are merged * in from the staging directory when writing the new WIM. */ - mbchar *staging_dir_name; + char *staging_dir_name; size_t staging_dir_name_len; /* Flags passed to wimlib_mount(). */ @@ -94,11 +98,8 @@ struct wimfs_context { * filesystem anyway. */ u64 next_ino; - /* List of lookup table entries for files in the staging directory */ - struct list_head staging_list; - /* List of inodes in the mounted image */ - struct hlist_head *image_inode_list; + struct list_head *image_inode_list; /* Name and message queue descriptors for message queues between the * filesystem daemon process and the unmount process. These are used @@ -106,8 +107,8 @@ struct wimfs_context { * wimlib_unmount_image() (i.e. the `imagex unmount' command) needs to * communicate with the filesystem daemon running fuse_main() (i.e. the * daemon created by the `imagex mount' or `imagex mountrw' commands */ - mbchar *unmount_to_daemon_mq_name; - mbchar *daemon_to_unmount_mq_name; + char *unmount_to_daemon_mq_name; + char *daemon_to_unmount_mq_name; mqd_t unmount_to_daemon_mq; mqd_t daemon_to_unmount_mq; @@ -124,7 +125,6 @@ init_wimfs_context(struct wimfs_context *ctx) memset(ctx, 0, sizeof(*ctx)); ctx->unmount_to_daemon_mq = (mqd_t)-1; ctx->daemon_to_unmount_mq = (mqd_t)-1; - INIT_LIST_HEAD(&ctx->staging_list); } #define WIMFS_CTX(fuse_ctx) ((struct wimfs_context*)(fuse_ctx)->private_data) @@ -292,7 +292,7 @@ close_wimfs_fd(struct wimfs_fd *fd) fd->f_inode->i_ino, fd->f_inode->i_num_opened_fds, fd->f_inode->i_num_allocated_fds); ret = lte_put_fd(fd->f_lte, fd); - if (ret != 0) + if (ret) return ret; inode_put_fd(fd->f_inode, fd); @@ -305,13 +305,14 @@ close_wimfs_fd(struct wimfs_fd *fd) * Returns 0 on success, or negative error number on failure. */ static int -create_dentry(struct fuse_context *fuse_ctx, const mbchar *path, +create_dentry(struct fuse_context *fuse_ctx, const char *path, mode_t mode, int attributes, struct wim_dentry **dentry_ret) { struct wim_dentry *parent; struct wim_dentry *new; - const mbchar *basename; + const char *basename; struct wimfs_context *wimfs_ctx = WIMFS_CTX(fuse_ctx); + int ret; parent = get_parent_dentry(wimfs_ctx->wim, path); if (!parent) @@ -324,9 +325,9 @@ create_dentry(struct fuse_context *fuse_ctx, const mbchar *path, if (get_dentry_child_with_name(parent, basename)) return -EEXIST; - new = new_dentry_with_inode(basename); - if (!new) - return -errno; + ret = new_dentry_with_inode(basename, &new); + if (ret) + return -ENOMEM; new->d_inode->i_resolved = 1; new->d_inode->i_ino = wimfs_ctx->next_ino++; @@ -345,7 +346,7 @@ create_dentry(struct fuse_context *fuse_ctx, const mbchar *path, } } dentry_add_child(parent, new); - hlist_add_head(&new->d_inode->i_hlist, wimfs_ctx->image_inode_list); + list_add_tail(&new->d_inode->i_list, wimfs_ctx->image_inode_list); if (dentry_ret) *dentry_ret = new; return 0; @@ -377,7 +378,7 @@ remove_dentry(struct wim_dentry *dentry, lte_decrement_refcnt(lte, lookup_table); } unlink_dentry(dentry); - put_dentry(dentry); + free_dentry(dentry); } static mode_t @@ -417,22 +418,10 @@ inode_to_stbuf(const struct wim_inode *inode, } stbuf->st_ino = (ino_t)inode->i_ino; stbuf->st_nlink = inode->i_nlink; - if (lte) { - if (lte->resource_location == RESOURCE_IN_STAGING_FILE) { - struct stat native_stat; - 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 = wim_resource_size(lte); - } - } else { + if (lte) + stbuf->st_size = wim_resource_size(lte); + else stbuf->st_size = 0; - } - #ifdef HAVE_STAT_NANOSECOND_PRECISION stbuf->st_atim = wim_timestamp_to_timespec(inode->i_last_access_time); stbuf->st_mtim = wim_timestamp_to_timespec(inode->i_last_write_time); @@ -467,10 +456,10 @@ touch_inode(struct wim_inode *inode) * writing. On failure, returns -1 and sets errno. */ static int -create_staging_file(mbchar **name_ret, struct wimfs_context *ctx) +create_staging_file(char **name_ret, struct wimfs_context *ctx) { size_t name_len; - mbchar *name; + char *name; struct stat stbuf; int fd; int errno_save; @@ -656,18 +645,10 @@ extract_resource_to_staging_dir(struct wim_inode *inode, new_lte->refcnt = inode->i_nlink; new_lte->resource_location = RESOURCE_IN_STAGING_FILE; new_lte->staging_file_name = staging_file_name; - new_lte->lte_inode = inode; - random_hash(new_lte->hash); + new_lte->resource_entry.original_size = size; - if (stream_id == 0) - inode->i_lte = new_lte; - else - for (u16 i = 0; i < inode->i_num_ads; i++) - if (inode->i_ads_entries[i].stream_id == stream_id) - inode->i_ads_entries[i].lte = new_lte; - - lookup_table_insert(ctx->wim->lookup_table, new_lte); - list_add(&new_lte->staging_list, &ctx->staging_list); + lookup_table_insert_unhashed(ctx->wim->lookup_table, new_lte, + inode, stream_id); *lte = new_lte; return 0; out_revert_fd_changes: @@ -694,17 +675,17 @@ out_delete_staging_file: * filesystem context structure. */ static int -make_staging_dir(struct wimfs_context *ctx, const mbchar *user_prefix) +make_staging_dir(struct wimfs_context *ctx, const char *user_prefix) { static const size_t random_suffix_len = 10; - static const mbchar *common_suffix = ".staging"; + static const char *common_suffix = ".staging"; static const size_t common_suffix_len = 8; - mbchar *staging_dir_name = NULL; + char *staging_dir_name = NULL; size_t staging_dir_name_len; size_t prefix_len; - const mbchar *wim_basename; - mbchar *real_user_prefix = NULL; + const char *wim_basename; + char *real_user_prefix = NULL; int ret; if (user_prefix) { @@ -760,7 +741,7 @@ out: } static int -remove_file_or_directory(const mbchar *fpath, const struct stat *sb, +remove_file_or_directory(const char *fpath, const struct stat *sb, int typeflag, struct FTW *ftwbuf) { if (remove(fpath) == 0) @@ -785,64 +766,6 @@ delete_staging_dir(struct wimfs_context *ctx) return ret; } -static void -inode_update_lte_ptr(struct wim_inode *inode, - struct wim_lookup_table_entry *old_lte, - struct wim_lookup_table_entry *new_lte) -{ - if (inode->i_lte == old_lte) { - inode->i_lte = new_lte; - } else { - for (unsigned i = 0; i < inode->i_num_ads; i++) { - if (inode->i_ads_entries[i].lte == old_lte) { - inode->i_ads_entries[i].lte = new_lte; - break; - } - } - } -} - -static int -update_lte_of_staging_file(struct wim_lookup_table_entry *lte, - struct wim_lookup_table *table) -{ - struct wim_lookup_table_entry *duplicate_lte; - int ret; - u8 hash[SHA1_HASH_SIZE]; - struct stat stbuf; - - ret = sha1sum(lte->staging_file_name, hash); - if (ret != 0) - return ret; - lookup_table_unlink(table, lte); - duplicate_lte = __lookup_resource(table, hash); - if (duplicate_lte) { - /* Merge duplicate lookup table entries */ - duplicate_lte->refcnt += lte->refcnt; - inode_update_lte_ptr(lte->lte_inode, lte, duplicate_lte); - 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; - } - if (stbuf.st_size == 0) { - /* Zero-length stream. No lookup table entry needed. */ - inode_update_lte_ptr(lte->lte_inode, lte, NULL); - free_lookup_table_entry(lte); - } else { - BUILD_BUG_ON(<e->file_on_disk != <e->staging_file_name); - lte->resource_entry.original_size = stbuf.st_size; - lte->resource_entry.size = stbuf.st_size; - lte->resource_location = RESOURCE_IN_FILE_ON_DISK; - lte->file_on_disk_fp = NULL; - copy_hash(lte->hash, hash); - lookup_table_insert(table, lte); - } - } - return 0; -} - static int inode_close_fds(struct wim_inode *inode) { @@ -868,24 +791,31 @@ rebuild_wim(struct wimfs_context *ctx, int write_flags, int ret; struct wim_lookup_table_entry *lte, *tmp; WIMStruct *w = ctx->wim; + struct wim_image_metadata *imd = wim_get_current_image_metadata(ctx->wim); DEBUG("Closing all staging file descriptors."); - list_for_each_entry_safe(lte, tmp, &ctx->staging_list, staging_list) { - ret = inode_close_fds(lte->lte_inode); - if (ret != 0) + image_for_each_unhashed_stream_safe(lte, tmp, imd) { + ret = inode_close_fds(lte->back_inode); + if (ret) return ret; } - DEBUG("Calculating SHA1 checksums for all new staging files."); - list_for_each_entry_safe(lte, tmp, &ctx->staging_list, staging_list) { - ret = update_lte_of_staging_file(lte, w->lookup_table); - if (ret != 0) - return ret; + DEBUG("Freeing entries for zero-length streams"); + image_for_each_unhashed_stream_safe(lte, tmp, imd) { + wimlib_assert(lte->unhashed); + if (wim_resource_size(lte) == 0) { + print_lookup_table_entry(lte, stderr); + struct wim_lookup_table_entry **back_ptr; + back_ptr = retrieve_lte_pointer(lte); + *back_ptr = NULL; + list_del(<e->unhashed_list); + free_lookup_table_entry(lte); + } } xml_update_image_info(w, w->current_image); ret = wimlib_overwrite(w, write_flags, 0, progress_func); - if (ret != 0) + if (ret) ERROR("Failed to commit changes to mounted WIM image"); return ret; } @@ -905,12 +835,12 @@ strcat_dup(const char *s1, const char *s2, size_t max_len) } static int -set_message_queue_names(struct wimfs_context *ctx, const mbchar *mount_dir) +set_message_queue_names(struct wimfs_context *ctx, const char *mount_dir) { - static const mbchar *u2d_prefix = "/wimlib-unmount-to-daemon-mq"; - static const mbchar *d2u_prefix = "/wimlib-daemon-to-unmount-mq"; - mbchar *dir_path; - mbchar *p; + static const char *u2d_prefix = "/wimlib-unmount-to-daemon-mq"; + static const char *d2u_prefix = "/wimlib-daemon-to-unmount-mq"; + char *dir_path; + char *p; int ret; dir_path = realpath(mount_dir, NULL); @@ -1050,7 +980,7 @@ get_mailbox(mqd_t mq, long needed_msgsize, long *msgsize_ret, void **mailbox_ret) { long msgsize; - char *mailbox; + void *mailbox; msgsize = mq_get_msgsize(mq); @@ -1493,7 +1423,7 @@ message_loop(mqd_t mq, * daemon to finish writing the WIM file. */ static int -execute_fusermount(const mbchar *dir) +execute_fusermount(const char *dir) { pid_t pid; int ret; @@ -1571,7 +1501,7 @@ static int wimfs_access(const char *path, int mask) #endif static int -wimfs_chmod(const mbchar *path, mode_t mask) +wimfs_chmod(const char *path, mode_t mask) { struct wim_dentry *dentry; struct wimfs_context *ctx = wimfs_get_context(); @@ -1592,7 +1522,7 @@ wimfs_chmod(const mbchar *path, mode_t mask) } static int -wimfs_chown(const mbchar *path, uid_t uid, gid_t gid) +wimfs_chown(const char *path, uid_t uid, gid_t gid) { struct wim_dentry *dentry; struct wimfs_context *ctx = wimfs_get_context(); @@ -1643,7 +1573,7 @@ static int wimfs_fallocate(const char *path, int mode, #endif static int -wimfs_fgetattr(const mbchar *path, struct stat *stbuf, +wimfs_fgetattr(const char *path, struct stat *stbuf, struct fuse_file_info *fi) { struct wimfs_fd *fd = (struct wimfs_fd*)(uintptr_t)fi->fh; @@ -1651,14 +1581,14 @@ wimfs_fgetattr(const mbchar *path, struct stat *stbuf, } static int -wimfs_ftruncate(const mbchar *path, off_t size, struct fuse_file_info *fi) +wimfs_ftruncate(const char *path, off_t size, struct fuse_file_info *fi) { struct wimfs_fd *fd = (struct wimfs_fd*)(uintptr_t)fi->fh; int ret = ftruncate(fd->staging_fd, size); - if (ret != 0) + if (ret) return -errno; - if (fd->f_lte && size < fd->f_lte->resource_entry.original_size) - fd->f_lte->resource_entry.original_size = size; + touch_inode(fd->f_inode); + fd->f_lte->resource_entry.original_size = size; return 0; } @@ -1666,7 +1596,7 @@ wimfs_ftruncate(const mbchar *path, off_t size, struct fuse_file_info *fi) * Fills in a `struct stat' that corresponds to a file or directory in the WIM. */ static int -wimfs_getattr(const mbchar *path, struct stat *stbuf) +wimfs_getattr(const char *path, struct stat *stbuf) { struct wim_dentry *dentry; struct wim_lookup_table_entry *lte; @@ -1684,7 +1614,7 @@ wimfs_getattr(const mbchar *path, struct stat *stbuf) #ifdef ENABLE_XATTR /* Read an alternate data stream through the XATTR interface, or get its size */ static int -wimfs_getxattr(const mbchar *path, const mbchar *name, char *value, +wimfs_getxattr(const char *path, const char *name, char *value, size_t size) { int ret; @@ -1718,8 +1648,7 @@ wimfs_getxattr(const mbchar *path, const mbchar *name, char *value, if (res_size > size) return -ERANGE; - ret = read_full_wim_resource(lte, (u8*)value, - WIMLIB_RESOURCE_FLAG_MULTITHREADED); + ret = read_full_resource_into_buf(lte, value, true); if (ret != 0) return -EIO; @@ -1729,14 +1658,13 @@ wimfs_getxattr(const mbchar *path, const mbchar *name, char *value, /* Create a hard link */ static int -wimfs_link(const mbchar *to, const mbchar *from) +wimfs_link(const char *to, const char *from) { struct wim_dentry *from_dentry, *from_dentry_parent; - const mbchar *link_name; + const char *link_name; struct wim_inode *inode; - struct wim_lookup_table_entry *lte; WIMStruct *w = wimfs_get_WIMStruct(); - u16 i; + int ret; inode = wim_pathname_to_inode(w, to); if (!inode) @@ -1755,32 +1683,28 @@ wimfs_link(const mbchar *to, const mbchar *from) link_name = path_basename(from); if (get_dentry_child_with_name(from_dentry_parent, link_name)) return -EEXIST; - from_dentry = new_dentry(link_name); - if (!from_dentry) - return -errno; - inode_add_dentry(from_dentry, inode); - from_dentry->d_inode = inode; - inode->i_nlink++; + ret = new_dentry(link_name, &from_dentry); + if (ret) + return -ENOMEM; - for (i = 0; i <= inode->i_num_ads; i++) { - lte = inode_stream_lte_resolved(inode, i); - if (lte) - lte->refcnt++; - } + inode->i_nlink++; + inode_ref_streams(inode); + from_dentry->d_inode = inode; + inode_add_dentry(from_dentry, inode); dentry_add_child(from_dentry_parent, from_dentry); return 0; } #ifdef ENABLE_XATTR static int -wimfs_listxattr(const mbchar *path, mbchar *list, size_t size) +wimfs_listxattr(const char *path, char *list, size_t size) { size_t needed_size; struct wim_inode *inode; struct wimfs_context *ctx = wimfs_get_context(); u16 i; - mbchar *p; + char *p; bool size_only = (size == 0); if (!(ctx->mount_flags & WIMLIB_MOUNT_FLAG_STREAM_INTERFACE_XATTR)) @@ -1794,20 +1718,16 @@ wimfs_listxattr(const mbchar *path, mbchar *list, size_t size) p = list; for (i = 0; i < inode->i_num_ads; i++) { - mbchar *stream_name_mbs; + char *stream_name_mbs; size_t stream_name_mbs_nbytes; int ret; - ret = utf16le_to_mbs(inode->i_ads_entries[i].stream_name, - inode->i_ads_entries[i].stream_name_nbytes, - &stream_name_mbs, - &stream_name_mbs_nbytes); - if (ret) { - if (ret == WIMLIB_ERR_NOMEM) - return -ENOMEM; - else - return -EIO; - } + ret = utf16le_to_tstr(inode->i_ads_entries[i].stream_name, + inode->i_ads_entries[i].stream_name_nbytes, + &stream_name_mbs, + &stream_name_mbs_nbytes); + if (ret) + return -errno; needed_size = stream_name_mbs_nbytes + 6; if (!size_only) { @@ -1828,7 +1748,7 @@ wimfs_listxattr(const mbchar *path, mbchar *list, size_t size) /* Create a directory in the WIM image. */ static int -wimfs_mkdir(const mbchar *path, mode_t mode) +wimfs_mkdir(const char *path, mode_t mode) { return create_dentry(fuse_get_context(), path, mode | S_IFDIR, FILE_ATTRIBUTE_DIRECTORY, NULL); @@ -1836,9 +1756,9 @@ wimfs_mkdir(const mbchar *path, mode_t mode) /* Create a regular file or alternate data stream in the WIM image. */ static int -wimfs_mknod(const mbchar *path, mode_t mode, dev_t rdev) +wimfs_mknod(const char *path, mode_t mode, dev_t rdev) { - const mbchar *stream_name; + const char *stream_name; struct fuse_context *fuse_ctx = fuse_get_context(); struct wimfs_context *wimfs_ctx = WIMFS_CTX(fuse_ctx); @@ -1851,15 +1771,14 @@ wimfs_mknod(const mbchar *path, mode_t mode, dev_t rdev) struct wim_ads_entry *new_entry; struct wim_inode *inode; - mbchar *p = (mbchar*)stream_name - 1; + char *p = (char*)stream_name - 1; wimlib_assert(*p == ':'); *p = '\0'; inode = wim_pathname_to_inode(wimfs_ctx->wim, path); if (!inode) return -errno; - if (inode->i_attributes & - (FILE_ATTRIBUTE_REPARSE_POINT | FILE_ATTRIBUTE_DIRECTORY)) + if (inode->i_attributes & FILE_ATTRIBUTE_REPARSE_POINT) return -ENOENT; if (inode_get_ads_entry(inode, stream_name, NULL)) return -EEXIST; @@ -1876,7 +1795,7 @@ wimfs_mknod(const mbchar *path, mode_t mode, dev_t rdev) /* Open a file. */ static int -wimfs_open(const mbchar *path, struct fuse_file_info *fi) +wimfs_open(const char *path, struct fuse_file_info *fi) { struct wim_dentry *dentry; struct wim_lookup_table_entry *lte; @@ -1886,6 +1805,7 @@ wimfs_open(const mbchar *path, struct fuse_file_info *fi) u16 stream_idx; u32 stream_id; struct wimfs_context *ctx = wimfs_get_context(); + struct wim_lookup_table_entry **back_ptr; ret = lookup_resource(ctx->wim, path, get_lookup_flags(ctx), &dentry, <e, &stream_idx); @@ -1894,10 +1814,13 @@ wimfs_open(const mbchar *path, struct fuse_file_info *fi) inode = dentry->d_inode; - if (stream_idx == 0) + if (stream_idx == 0) { stream_id = 0; - else + back_ptr = &inode->i_lte; + } else { stream_id = inode->i_ads_entries[stream_idx - 1].stream_id; + back_ptr = &inode->i_ads_entries[stream_idx - 1].lte; + } /* 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 @@ -1913,7 +1836,9 @@ wimfs_open(const mbchar *path, struct fuse_file_info *fi) <e, size, ctx); if (ret != 0) return ret; + *back_ptr = lte; } + print_lookup_table_entry(lte, stderr); ret = alloc_wimfs_fd(inode, stream_id, lte, &fd, wimfs_ctx_readonly(ctx)); @@ -1934,7 +1859,7 @@ wimfs_open(const mbchar *path, struct fuse_file_info *fi) /* Opens a directory. */ static int -wimfs_opendir(const mbchar *path, struct fuse_file_info *fi) +wimfs_opendir(const char *path, struct fuse_file_info *fi) { struct wim_inode *inode; int ret; @@ -1957,11 +1882,12 @@ wimfs_opendir(const mbchar *path, struct fuse_file_info *fi) * Read data from a file in the WIM or in the staging directory. */ static int -wimfs_read(const mbchar *path, char *buf, size_t size, +wimfs_read(const char *path, char *buf, size_t size, off_t offset, struct fuse_file_info *fi) { struct wimfs_fd *fd = (struct wimfs_fd*)(uintptr_t)fi->fh; ssize_t ret; + u64 res_size; if (!fd) return -EBADF; @@ -1969,32 +1895,34 @@ wimfs_read(const mbchar *path, char *buf, size_t size, if (!fd->f_lte) /* Empty stream with no lookup table entry */ return 0; - if (fd->f_lte->resource_location == RESOURCE_IN_STAGING_FILE) { - /* Read from staging file */ - - wimlib_assert(fd->f_lte->staging_file_name); - wimlib_assert(fd->staging_fd != -1); + res_size = wim_resource_size(fd->f_lte); + if (offset > res_size) + return -EOVERFLOW; + size = min(size, INT_MAX); + size = min(size, res_size - offset); - DEBUG("Seek to offset %"PRIu64, offset); - - if (lseek(fd->staging_fd, offset, SEEK_SET) == -1) - return -errno; - ret = read(fd->staging_fd, buf, size); - if (ret == -1) - return -errno; - return ret; - } else { - /* Read from WIM */ - u64 res_size = wim_resource_size(fd->f_lte); - if (offset > res_size) - return -EOVERFLOW; - size = min(size, res_size - offset); - if (read_wim_resource(fd->f_lte, buf, - size, offset, - WIMLIB_RESOURCE_FLAG_MULTITHREADED) != 0) - return -EIO; - return size; + switch (fd->f_lte->resource_location) { + case RESOURCE_IN_STAGING_FILE: + ret = pread(fd->staging_fd, buf, size, offset); + if (ret < 0) + ret = -errno; + break; + case RESOURCE_IN_WIM: + if (read_partial_wim_resource_into_buf(fd->f_lte, size, + offset, buf, true)) + ret = -errno; + ret = size; + break; + case RESOURCE_IN_ATTACHED_BUFFER: + memcpy(buf, fd->f_lte->attached_buffer + offset, size); + ret = size; + break; + default: + ERROR("Invalid resource location"); + ret = -EIO; + break; } + return ret; } struct fill_params { @@ -2007,20 +1935,17 @@ dentry_fuse_fill(struct wim_dentry *dentry, void *arg) { struct fill_params *fill_params = arg; - mbchar *file_name_mbs; + char *file_name_mbs; size_t file_name_mbs_nbytes; int ret; - ret = utf16le_to_mbs(dentry->file_name, - dentry->file_name_nbytes, - &file_name_mbs, - &file_name_mbs_nbytes); - if (ret) { - if (ret == WIMLIB_ERR_NOMEM) - return -ENOMEM; - else - return -EILSEQ; - } + 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; @@ -2029,7 +1954,7 @@ dentry_fuse_fill(struct wim_dentry *dentry, void *arg) /* Fills in the entries of the directory specified by @path using the * FUSE-provided function @filler. */ static int -wimfs_readdir(const mbchar *path, void *buf, fuse_fill_dir_t filler, +wimfs_readdir(const char *path, void *buf, fuse_fill_dir_t filler, off_t offset, struct fuse_file_info *fi) { struct wimfs_fd *fd = (struct wimfs_fd*)(uintptr_t)fi->fh; @@ -2054,7 +1979,7 @@ wimfs_readdir(const mbchar *path, void *buf, fuse_fill_dir_t filler, static int -wimfs_readlink(const mbchar *path, char *buf, size_t buf_len) +wimfs_readlink(const char *path, char *buf, size_t buf_len) { struct wimfs_context *ctx = wimfs_get_context(); struct wim_inode *inode = wim_pathname_to_inode(ctx->wim, path); @@ -2064,8 +1989,7 @@ wimfs_readlink(const mbchar *path, char *buf, size_t buf_len) if (!inode_is_symlink(inode)) return -EINVAL; - ret = inode_readlink(inode, buf, buf_len, ctx->wim, - WIMLIB_RESOURCE_FLAG_MULTITHREADED); + ret = inode_readlink(inode, buf, buf_len, ctx->wim, true); if (ret > 0) ret = 0; return ret; @@ -2073,7 +1997,7 @@ wimfs_readlink(const mbchar *path, char *buf, size_t buf_len) /* Close a file. */ static int -wimfs_release(const mbchar *path, struct fuse_file_info *fi) +wimfs_release(const char *path, struct fuse_file_info *fi) { struct wimfs_fd *fd = (struct wimfs_fd*)(uintptr_t)fi->fh; return close_wimfs_fd(fd); @@ -2081,7 +2005,7 @@ wimfs_release(const mbchar *path, struct fuse_file_info *fi) /* Close a directory */ static int -wimfs_releasedir(const mbchar *path, struct fuse_file_info *fi) +wimfs_releasedir(const char *path, struct fuse_file_info *fi) { struct wimfs_fd *fd = (struct wimfs_fd*)(uintptr_t)fi->fh; return close_wimfs_fd(fd); @@ -2090,7 +2014,7 @@ wimfs_releasedir(const mbchar *path, struct fuse_file_info *fi) #ifdef ENABLE_XATTR /* Remove an alternate data stream through the XATTR interface */ static int -wimfs_removexattr(const char *path, const mbchar *name) +wimfs_removexattr(const char *path, const char *name) { struct wim_inode *inode; struct wim_ads_entry *ads_entry; @@ -2118,7 +2042,7 @@ wimfs_removexattr(const char *path, const mbchar *name) /* Renames a file or directory. See rename (3) */ static int -wimfs_rename(const mbchar *from, const mbchar *to) +wimfs_rename(const char *from, const char *to) { struct wim_dentry *src; struct wim_dentry *dst; @@ -2176,7 +2100,7 @@ wimfs_rename(const mbchar *from, const mbchar *to) /* Remove a directory */ static int -wimfs_rmdir(const mbchar *path) +wimfs_rmdir(const char *path) { struct wim_dentry *dentry; WIMStruct *w = wimfs_get_WIMStruct(); @@ -2198,7 +2122,7 @@ wimfs_rmdir(const mbchar *path) #ifdef ENABLE_XATTR /* Write an alternate data stream through the XATTR interface */ static int -wimfs_setxattr(const mbchar *path, const mbchar *name, +wimfs_setxattr(const char *path, const char *name, const char *value, size_t size, int flags) { struct wim_ads_entry *existing_ads_entry; @@ -2240,7 +2164,7 @@ wimfs_setxattr(const mbchar *path, const mbchar *name, #endif static int -wimfs_symlink(const mbchar *to, const mbchar *from) +wimfs_symlink(const char *to, const char *from) { struct fuse_context *fuse_ctx = fuse_get_context(); struct wimfs_context *wimfs_ctx = WIMFS_CTX(fuse_ctx); @@ -2264,7 +2188,7 @@ wimfs_symlink(const mbchar *to, const mbchar *from) /* Reduce the size of a file */ static int -wimfs_truncate(const mbchar *path, off_t size) +wimfs_truncate(const char *path, off_t size) { struct wim_dentry *dentry; struct wim_lookup_table_entry *lte; @@ -2283,19 +2207,20 @@ wimfs_truncate(const mbchar *path, off_t size) if (lte == NULL && size == 0) return 0; - inode = dentry->d_inode; - if (stream_idx == 0) - stream_id = 0; - else - stream_id = inode->i_ads_entries[stream_idx - 1].stream_id; - if (lte->resource_location == RESOURCE_IN_STAGING_FILE) { ret = truncate(lte->staging_file_name, size); - if (ret != 0) + if (ret) ret = -errno; + else + lte->resource_entry.original_size = size; } else { /* File in WIM. Extract it to the staging directory, but only * the first @size bytes of it. */ + inode = dentry->d_inode; + if (stream_idx == 0) + stream_id = 0; + else + stream_id = inode->i_ads_entries[stream_idx - 1].stream_id; ret = extract_resource_to_staging_dir(inode, stream_id, <e, size, ctx); } @@ -2304,7 +2229,7 @@ wimfs_truncate(const mbchar *path, off_t size) /* Unlink a non-directory or alternate data stream */ static int -wimfs_unlink(const mbchar *path) +wimfs_unlink(const char *path) { struct wim_dentry *dentry; struct wim_lookup_table_entry *lte; @@ -2333,7 +2258,7 @@ wimfs_unlink(const mbchar *path) * Note that alternate data streams do not have their own timestamps. */ static int -wimfs_utimens(const mbchar *path, const struct timespec tv[2]) +wimfs_utimens(const char *path, const struct timespec tv[2]) { struct wim_dentry *dentry; struct wim_inode *inode; @@ -2360,7 +2285,7 @@ wimfs_utimens(const mbchar *path, const struct timespec tv[2]) } #else /* HAVE_UTIMENSAT */ static int -wimfs_utime(const mbchar *path, struct utimbuf *times) +wimfs_utime(const char *path, struct utimbuf *times) { struct wim_dentry *dentry; struct wim_inode *inode; @@ -2381,30 +2306,33 @@ wimfs_utime(const mbchar *path, struct utimbuf *times) * It may be an alternate data stream, but here we don't even notice because we * just get a lookup table entry. */ static int -wimfs_write(const mbchar *path, const char *buf, size_t size, +wimfs_write(const char *path, const char *buf, size_t size, off_t offset, struct fuse_file_info *fi) { struct wimfs_fd *fd = (struct wimfs_fd*)(uintptr_t)fi->fh; int ret; - u64 now; if (!fd) return -EBADF; - wimlib_assert(fd->f_lte); - wimlib_assert(fd->f_lte->staging_file_name); + wimlib_assert(fd->f_lte != NULL); + wimlib_assert(fd->f_lte->staging_file_name != NULL); wimlib_assert(fd->staging_fd != -1); - wimlib_assert(fd->f_inode); - - /* Seek to the requested position */ - if (lseek(fd->staging_fd, offset, SEEK_SET) == -1) - return -errno; + wimlib_assert(fd->f_inode != NULL); /* Write the data. */ - ret = write(fd->staging_fd, buf, size); + ret = pwrite(fd->staging_fd, buf, size, offset); if (ret == -1) return -errno; + /* Update file size */ + if (offset + size > fd->f_lte->resource_entry.original_size) { + DEBUG("Update file size %"PRIu64 " => %"PRIu64"", + fd->f_lte->resource_entry.original_size, + offset + size); + fd->f_lte->resource_entry.original_size = offset + size; + } + /* Update timestamps */ touch_inode(fd->f_inode); return ret; @@ -2472,19 +2400,18 @@ static struct fuse_operations wimfs_operations = { /* Mounts an image from a WIM file. */ WIMLIBAPI int -wimlib_mount_image(WIMStruct *wim, int image, const mbchar *dir, +wimlib_mount_image(WIMStruct *wim, int image, const char *dir, int mount_flags, WIMStruct **additional_swms, unsigned num_additional_swms, - const mbchar *staging_dir) + const char *staging_dir) { int argc; char *argv[16]; int ret; - mbchar *dir_copy; + char *dir_copy; struct wim_lookup_table *joined_tab, *wim_tab_save; struct wim_image_metadata *imd; struct wimfs_context ctx; - struct hlist_node *cur_node; struct wim_inode *inode; DEBUG("Mount: wim = %p, image = %d, dir = %s, flags = %d, ", @@ -2494,7 +2421,7 @@ wimlib_mount_image(WIMStruct *wim, int image, const mbchar *dir, return WIMLIB_ERR_INVALID_PARAM; ret = verify_swm_set(wim, additional_swms, num_additional_swms); - if (ret != 0) + if (ret) return ret; if ((mount_flags & WIMLIB_MOUNT_FLAG_READWRITE) && (wim->hdr.total_parts != 1)) { @@ -2506,7 +2433,7 @@ wimlib_mount_image(WIMStruct *wim, int image, const mbchar *dir, ret = new_joined_lookup_table(wim, additional_swms, num_additional_swms, &joined_tab); - if (ret != 0) + if (ret) return ret; wim_tab_save = wim->lookup_table; wim->lookup_table = joined_tab; @@ -2514,28 +2441,29 @@ wimlib_mount_image(WIMStruct *wim, int image, const mbchar *dir, if (mount_flags & WIMLIB_MOUNT_FLAG_READWRITE) { ret = wim_run_full_verifications(wim); - if (ret != 0) + if (ret) goto out; } + ret = wim_checksum_unhashed_streams(wim); + if (ret) + goto out; + ret = select_wim_image(wim, image); - if (ret != 0) + if (ret) goto out; DEBUG("Selected image %d", image); imd = wim_get_current_image_metadata(wim); - if (imd->root_dentry->refcnt != 1) { + if (imd->refcnt != 1) { ERROR("Cannot mount image that was just exported with " "wimlib_export_image()"); ret = WIMLIB_ERR_INVALID_PARAM; goto out; } - if (imd->inode_list.first) /* May be unneeded? */ - imd->inode_list.first->pprev = &imd->inode_list.first; - if (imd->modified) { ERROR("Cannot mount image that was added " "with wimlib_add_image()"); @@ -2545,7 +2473,7 @@ wimlib_mount_image(WIMStruct *wim, int image, const mbchar *dir, if (mount_flags & WIMLIB_MOUNT_FLAG_READWRITE) { ret = lock_wim(wim, wim->fp); - if (ret != 0) + if (ret) goto out; } @@ -2555,7 +2483,6 @@ wimlib_mount_image(WIMStruct *wim, int image, const mbchar *dir, WIMLIB_MOUNT_FLAG_STREAM_INTERFACE_WINDOWS))) mount_flags |= WIMLIB_MOUNT_FLAG_STREAM_INTERFACE_XATTR; - DEBUG("Initializing struct wimfs_context"); init_wimfs_context(&ctx); ctx.wim = wim; @@ -2563,12 +2490,14 @@ wimlib_mount_image(WIMStruct *wim, int image, const mbchar *dir, ctx.image_inode_list = &imd->inode_list; ctx.default_uid = getuid(); ctx.default_gid = getgid(); + wimlib_assert(list_empty(&imd->unhashed_streams)); + ctx.wim->lookup_table->unhashed_streams = &imd->unhashed_streams; if (mount_flags & WIMLIB_MOUNT_FLAG_STREAM_INTERFACE_WINDOWS) ctx.default_lookup_flags = LOOKUP_FLAG_ADS_OK; DEBUG("Unlinking message queues in case they already exist"); ret = set_message_queue_names(&ctx, dir); - if (ret != 0) + if (ret) goto out_unlock; unlink_message_queues(&ctx); @@ -2606,7 +2535,7 @@ wimlib_mount_image(WIMStruct *wim, int image, const mbchar *dir, if ((mount_flags & WIMLIB_MOUNT_FLAG_READWRITE)) { /* Read-write mount. Make the staging directory */ ret = make_staging_dir(&ctx, staging_dir); - if (ret != 0) + if (ret) goto out_free_dir_copy; } else { /* Read-only mount */ @@ -2639,7 +2568,7 @@ wimlib_mount_image(WIMStruct *wim, int image, const mbchar *dir, * assign inode numbers */ DEBUG("Resolving lookup table entries and assigning inode numbers"); ctx.next_ino = 1; - hlist_for_each_entry(inode, cur_node, &imd->inode_list, i_hlist) { + image_for_each_inode(inode, imd) { inode_resolve_ltes(inode, wim->lookup_table); inode->i_ino = ctx.next_ino++; } @@ -2687,7 +2616,7 @@ out: * wimlib_mount_image(). */ WIMLIBAPI int -wimlib_unmount_image(const mbchar *dir, int unmount_flags, +wimlib_unmount_image(const char *dir, int unmount_flags, wimlib_progress_func_t progress_func) { int ret; @@ -2750,17 +2679,17 @@ mount_unsupported_error() } WIMLIBAPI int -wimlib_unmount_image(const mbchar *dir, int unmount_flags, +wimlib_unmount_image(const tchar *dir, int unmount_flags, wimlib_progress_func_t progress_func) { return mount_unsupported_error(); } WIMLIBAPI int -wimlib_mount_image(WIMStruct *wim, int image, const mbchar *dir, +wimlib_mount_image(WIMStruct *wim, int image, const tchar *dir, int mount_flags, WIMStruct **additional_swms, unsigned num_additional_swms, - const mbchar *staging_dir) + const tchar *staging_dir) { return mount_unsupported_error(); }