X-Git-Url: https://wimlib.net/git/?a=blobdiff_plain;f=src%2Funix_apply.c;h=ff11977c646779e19eb28e76c47a2a64f1687c23;hb=3519f882f1b44ef45d9f9c5762b53d0c8f8da55a;hp=4eeee2ca4153511ad8359366a88ce68d8aa5e99d;hpb=a3c63defc94455a84fa681024a461691c1ad5661;p=wimlib diff --git a/src/unix_apply.c b/src/unix_apply.c index 4eeee2ca..ff11977c 100644 --- a/src/unix_apply.c +++ b/src/unix_apply.c @@ -26,6 +26,7 @@ #endif #include "wimlib/apply.h" +#include "wimlib/assert.h" #include "wimlib/dentry.h" #include "wimlib/error.h" #include "wimlib/file_io.h" @@ -64,8 +65,6 @@ unix_get_supported_features(const char *target, } #define NUM_PATHBUFS 2 /* We need 2 when creating hard links */ -#define MAX_OPEN_FDS 1000 /* TODO: Add special case for when the number of - identical streams exceeds this number. */ struct unix_apply_ctx { /* Extract flags, the pointer to the WIMStruct, etc. */ @@ -78,7 +77,7 @@ struct unix_apply_ctx { unsigned which_pathbuf; /* Currently open file descriptors for extraction */ - struct filedes open_fds[MAX_OPEN_FDS]; + struct filedes open_fds[MAX_OPEN_STREAMS]; /* Number of currently open file descriptors in open_fds, starting from * the beginning of the array. */ @@ -373,7 +372,8 @@ unix_create_if_directory(const struct wim_dentry *dentry, ERROR_WITH_ERRNO("Can't create directory \"%s\"", path); return WIMLIB_ERR_MKDIR; } - return 0; + + return report_file_created(&ctx->common); } /* If @dentry represents an empty regular file or a special file, create it, set @@ -445,7 +445,11 @@ unix_extract_if_empty_file(const struct wim_dentry *dentry, if (ret) return ret; - return unix_create_hardlinks(inode, dentry, path, ctx); + ret = unix_create_hardlinks(inode, dentry, path, ctx); + if (ret) + return ret; + + return report_file_created(&ctx->common); } static int @@ -468,6 +472,29 @@ unix_create_dirs_and_empty_files(const struct list_head *dentry_list, return 0; } +static void +unix_count_dentries(const struct list_head *dentry_list, + uint64_t *dir_count_ret, uint64_t *empty_file_count_ret) +{ + const struct wim_dentry *dentry; + uint64_t dir_count = 0; + uint64_t empty_file_count = 0; + + list_for_each_entry(dentry, dentry_list, d_extraction_list_node) { + + const struct wim_inode *inode = dentry->d_inode; + + if (inode_is_directory(inode)) + dir_count++; + else if ((dentry == inode_first_extraction_dentry(inode)) && + !inode_unnamed_lte_resolved(inode)) + empty_file_count++; + } + + *dir_count_ret = dir_count; + *empty_file_count_ret = empty_file_count; +} + static int unix_create_symlink(const struct wim_inode *inode, const char *path, const u8 *rpdata, u16 rpdatalen, bool rpfix, @@ -543,10 +570,8 @@ unix_begin_extract_stream_instance(const struct wim_lookup_table_entry *stream, return 0; } - if (ctx->num_open_fds == MAX_OPEN_FDS) { - ERROR("Can't extract data: too many open files!"); - return WIMLIB_ERR_UNSUPPORTED; - } + /* This should be ensured by extract_stream_list() */ + wimlib_assert(ctx->num_open_fds < MAX_OPEN_STREAMS); first_dentry = inode_first_extraction_dentry(inode); first_path = unix_build_extraction_path(first_dentry, ctx); @@ -564,8 +589,7 @@ retry_create: /* Called when starting to read a single-instance stream for extraction */ static int -unix_begin_extract_stream(struct wim_lookup_table_entry *stream, - u32 flags, void *_ctx) +unix_begin_extract_stream(struct wim_lookup_table_entry *stream, void *_ctx) { struct unix_apply_ctx *ctx = _ctx; const struct stream_owner *owners = stream_owners(stream); @@ -630,13 +654,17 @@ unix_end_extract_stream(struct wim_lookup_table_entry *stream, int status, /* We finally have the symlink data, so we can create * the symlink. */ const char *path; + bool rpfix; + + rpfix = (ctx->common.extract_flags & + WIMLIB_EXTRACT_FLAG_RPFIX) && + !inode->i_not_rpfixed; path = unix_build_inode_extraction_path(inode, ctx); ret = unix_create_symlink(inode, path, ctx->reparse_data, stream->size, - (ctx->common.extract_flags & - WIMLIB_EXTRACT_FLAG_RPFIX), + rpfix, ctx->target_abspath, ctx->target_abspath_nchars); if (ret) { @@ -680,6 +708,9 @@ unix_set_dir_metadata(struct list_head *dentry_list, struct unix_apply_ctx *ctx) ret = unix_set_metadata(-1, dentry->d_inode, NULL, ctx); if (ret) return ret; + ret = report_file_metadata_applied(&ctx->common); + if (ret) + return ret; } } return 0; @@ -691,6 +722,8 @@ unix_extract(struct list_head *dentry_list, struct apply_ctx *_ctx) int ret; struct unix_apply_ctx *ctx = (struct unix_apply_ctx *)_ctx; size_t path_max; + uint64_t dir_count; + uint64_t empty_file_count; /* Compute the maximum path length that will be needed, then allocate * some path buffers. */ @@ -712,10 +745,21 @@ unix_extract(struct list_head *dentry_list, struct apply_ctx *_ctx) * because we can't extract any other files until their directories * exist. Empty files are needed because they don't have * representatives in the stream list. */ + + unix_count_dentries(dentry_list, &dir_count, &empty_file_count); + + ret = start_file_structure_phase(&ctx->common, dir_count + empty_file_count); + if (ret) + goto out; + ret = unix_create_dirs_and_empty_files(dentry_list, ctx); if (ret) goto out; + ret = end_file_structure_phase(&ctx->common); + if (ret) + goto out; + /* Get full path to target if needed for absolute symlink fixups. */ if ((ctx->common.extract_flags & WIMLIB_EXTRACT_FLAG_RPFIX) && ctx->common.required_features.symlink_reparse_points) @@ -742,11 +786,21 @@ unix_extract(struct list_head *dentry_list, struct apply_ctx *_ctx) if (ret) goto out; + /* Set directory metadata. We do this last so that we get the right * directory timestamps. */ + ret = start_file_metadata_phase(&ctx->common, dir_count); + if (ret) + goto out; + ret = unix_set_dir_metadata(dentry_list, ctx); if (ret) goto out; + + ret = end_file_metadata_phase(&ctx->common); + if (ret) + goto out; + if (ctx->num_special_files_ignored) { WARNING("%lu special files were not extracted due to EPERM!", ctx->num_special_files_ignored);