X-Git-Url: https://wimlib.net/git/?p=wimlib;a=blobdiff_plain;f=src%2Fextract_image.c;h=c2021563d11289edcc04ba8eb5ddaf54757e9b4c;hp=470469a0be0a8c511b2f8f97c6b3d8d747cab9f9;hb=80224de6c2ff870ea36ff98b491223c674e4d57a;hpb=fea0ee9f10fbcb85ff56ca06510e96186a7611ae;ds=sidebyside diff --git a/src/extract_image.c b/src/extract_image.c index 470469a0..c2021563 100644 --- a/src/extract_image.c +++ b/src/extract_image.c @@ -54,10 +54,10 @@ #include #endif -static int extract_regular_file_linked(struct dentry *dentry, +static int extract_regular_file_linked(struct wim_dentry *dentry, const char *output_path, struct apply_args *args, - struct lookup_table_entry *lte) + struct wim_lookup_table_entry *lte) { /* This mode overrides the normal hard-link extraction and * instead either symlinks or hardlinks *all* identical files in @@ -114,44 +114,44 @@ static int extract_regular_file_linked(struct dentry *dentry, return 0; } -static int extract_regular_file_unlinked(struct dentry *dentry, +static int extract_regular_file_unlinked(struct wim_dentry *dentry, struct apply_args *args, const char *output_path, - struct lookup_table_entry *lte) + struct wim_lookup_table_entry *lte) { /* Normal mode of extraction. Regular files and hard links are * extracted in the way that they appear in the WIM. */ int out_fd; int ret; - struct inode *inode = dentry->d_inode; + struct wim_inode *inode = dentry->d_inode; if (!((args->extract_flags & WIMLIB_EXTRACT_FLAG_MULTI_IMAGE) && (args->extract_flags & (WIMLIB_EXTRACT_FLAG_SYMLINK | WIMLIB_EXTRACT_FLAG_HARDLINK)))) { - /* If the dentry is one of a hard link set of at least 2 + /* If the dentry is part of a hard link set of at least 2 * dentries and one of the other dentries has already been * extracted, make a hard link to the file corresponding to this - * already-extracted directory. Otherwise, extract the file, - * and set the inode->extracted_file field so that other - * dentries in the hard link group can link to it. */ - if (inode->link_count > 1) { - if (inode->extracted_file) { + * already-extracted directory. Otherwise, extract the file and + * set the inode->i_extracted_file field so that other dentries + * in the hard link group can link to it. */ + if (inode->i_nlink > 1) { + if (inode->i_extracted_file) { DEBUG("Extracting hard link `%s' => `%s'", - output_path, inode->extracted_file); - if (link(inode->extracted_file, output_path) != 0) { + output_path, inode->i_extracted_file); + if (link(inode->i_extracted_file, output_path) != 0) { ERROR_WITH_ERRNO("Failed to hard link " "`%s' to `%s'", output_path, - inode->extracted_file); + inode->i_extracted_file); return WIMLIB_ERR_LINK; } return 0; } - FREE(inode->extracted_file); - inode->extracted_file = STRDUP(output_path); - if (!inode->extracted_file) { + FREE(inode->i_extracted_file); + inode->i_extracted_file = STRDUP(output_path); + if (!inode->i_extracted_file) { ERROR("Failed to allocate memory for filename"); return WIMLIB_ERR_NOMEM; } @@ -174,7 +174,7 @@ static int extract_regular_file_unlinked(struct dentry *dentry, goto out; } - ret = extract_full_wim_resource_to_fd(lte, out_fd); + ret = extract_wim_resource_to_fd(lte, out_fd, wim_resource_size(lte)); if (ret != 0) { ERROR("Failed to extract resource to `%s'", output_path); goto out; @@ -188,15 +188,12 @@ out: return ret; } -/* - * Extracts a regular file from the WIM archive. - */ -static int extract_regular_file(struct dentry *dentry, +static int extract_regular_file(struct wim_dentry *dentry, struct apply_args *args, const char *output_path) { - struct lookup_table_entry *lte; - const struct inode *inode = dentry->d_inode; + struct wim_lookup_table_entry *lte; + const struct wim_inode *inode = dentry->d_inode; lte = inode_unnamed_lte_resolved(inode); @@ -214,14 +211,14 @@ static int extract_regular_file(struct dentry *dentry, return extract_regular_file_unlinked(dentry, args, output_path, lte); } -static int extract_symlink(struct dentry *dentry, +static int extract_symlink(struct wim_dentry *dentry, struct apply_args *args, const char *output_path) { char target[4096]; ssize_t ret = inode_readlink(dentry->d_inode, target, sizeof(target), args->w, 0); - struct lookup_table_entry *lte; + struct wim_lookup_table_entry *lte; if (ret <= 0) { ERROR("Could not read the symbolic link from dentry `%s'", @@ -239,13 +236,6 @@ static int extract_symlink(struct dentry *dentry, return 0; } -/* - * Extracts a directory from the WIM archive. - * - * @dentry: The directory entry for the directory. - * @output_path: The path to which the directory is to be extracted to. - * @return: True on success, false on failure. - */ static int extract_directory(const char *output_path, bool is_root) { int ret; @@ -266,7 +256,6 @@ static int extract_directory(const char *output_path, bool is_root) return WIMLIB_ERR_STAT; } } - /* Compute the output path directory to the directory. */ if (mkdir(output_path, S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH) != 0) { ERROR_WITH_ERRNO("Cannot create directory `%s'", @@ -276,32 +265,12 @@ static int extract_directory(const char *output_path, bool is_root) return 0; } -/* - * Extracts a file, directory, or symbolic link from the WIM archive. For use - * in for_dentry_in_tree(). - */ -static int apply_dentry_normal(struct dentry *dentry, void *arg) +/* Extracts a file, directory, or symbolic link from the WIM archive. */ +static int apply_dentry_normal(struct wim_dentry *dentry, void *arg) { struct apply_args *args = arg; - int extract_flags = args->extract_flags; - struct inode *inode = dentry->d_inode; + struct wim_inode *inode = dentry->d_inode; size_t len; - int ret; - - if (dentry->is_extracted) - return 0; - - if (extract_flags & WIMLIB_EXTRACT_FLAG_NO_STREAMS) - if (inode_unnamed_lte_resolved(inode)) - return 0; - - if ((extract_flags & WIMLIB_EXTRACT_FLAG_VERBOSE) && - args->progress_func) - { - args->progress.extract.cur_path = dentry->full_path_utf8; - args->progress_func(WIMLIB_PROGRESS_MSG_EXTRACT_DENTRY, - &args->progress); - } len = strlen(args->target); char output_path[len + dentry->full_path_utf8_len + 1]; @@ -310,32 +279,31 @@ static int apply_dentry_normal(struct dentry *dentry, void *arg) output_path[len + dentry->full_path_utf8_len] = '\0'; if (inode_is_symlink(inode)) - ret = extract_symlink(dentry, args, output_path); + return extract_symlink(dentry, args, output_path); else if (inode_is_directory(inode)) - ret = extract_directory(output_path, false); + return extract_directory(output_path, false); else - ret = extract_regular_file(dentry, args, output_path); - if (ret == 0) - dentry->is_extracted = 1; - return ret; + return extract_regular_file(dentry, args, output_path); } -/* Apply timestamp to extracted file */ -static int apply_dentry_timestamps_normal(struct dentry *dentry, void *arg) +/* Apply timestamps to an extracted file or directory */ +static int apply_dentry_timestamps_normal(struct wim_dentry *dentry, void *arg) { struct apply_args *args = arg; size_t len = strlen(args->target); char output_path[len + dentry->full_path_utf8_len + 1]; - const struct inode *inode = dentry->d_inode; + const struct wim_inode *inode = dentry->d_inode; int ret; memcpy(output_path, args->target, len); memcpy(output_path + len, dentry->full_path_utf8, dentry->full_path_utf8_len); output_path[len + dentry->full_path_utf8_len] = '\0'; + /* Convert the WIM timestamps, which are accurate to 100 nanoseconds, + * into struct timeval's. */ struct timeval tv[2]; - wim_timestamp_to_timeval(inode->last_access_time, &tv[0]); - wim_timestamp_to_timeval(inode->last_write_time, &tv[1]); + wim_timestamp_to_timeval(inode->i_last_access_time, &tv[0]); + wim_timestamp_to_timeval(inode->i_last_write_time, &tv[1]); #ifdef HAVE_LUTIMES ret = lutimes(output_path, tv); #else @@ -346,26 +314,52 @@ static int apply_dentry_timestamps_normal(struct dentry *dentry, void *arg) #ifdef HAVE_UTIME if (errno == ENOSYS) { struct utimbuf buf; - buf.actime = wim_timestamp_to_unix(inode->last_access_time); - buf.modtime = wim_timestamp_to_unix(inode->last_write_time); + buf.actime = wim_timestamp_to_unix(inode->i_last_access_time); + buf.modtime = wim_timestamp_to_unix(inode->i_last_write_time); if (utime(output_path, &buf) == 0) return 0; } #endif if (errno != ENOSYS || args->num_lutimes_warnings < 10) { - /*WARNING("Failed to set timestamp on file `%s': %s",*/ - /*output_path, strerror(errno));*/ + /*WARNING_WITH_ERRNO("Failed to set timestamp on file `%s',*/ + /*output_path");*/ args->num_lutimes_warnings++; } } return 0; } +/* Extract a dentry if it hasn't already been extracted, and either the dentry + * has no streams or WIMLIB_EXTRACT_FLAG_NO_STREAMS is not specified. */ +static int maybe_apply_dentry(struct wim_dentry *dentry, void *arg) +{ + struct apply_args *args = arg; + int ret; + + if (dentry->is_extracted) + return 0; + + if (args->extract_flags & WIMLIB_EXTRACT_FLAG_NO_STREAMS) + if (inode_unnamed_lte_resolved(dentry->d_inode)) + return 0; + + if ((args->extract_flags & WIMLIB_EXTRACT_FLAG_VERBOSE) && + args->progress_func) { + args->progress.extract.cur_path = dentry->full_path_utf8; + args->progress_func(WIMLIB_PROGRESS_MSG_EXTRACT_DENTRY, + &args->progress); + } + ret = args->apply_dentry(dentry, args); + if (ret == 0) + dentry->is_extracted = 1; + return ret; +} + static int cmp_streams_by_wim_position(const void *p1, const void *p2) { - const struct lookup_table_entry *lte1, *lte2; - lte1 = *(const struct lookup_table_entry**)p1; - lte2 = *(const struct lookup_table_entry**)p2; + const struct wim_lookup_table_entry *lte1, *lte2; + lte1 = *(const struct wim_lookup_table_entry**)p1; + lte2 = *(const struct wim_lookup_table_entry**)p2; if (lte1->resource_entry.offset < lte2->resource_entry.offset) return -1; else if (lte1->resource_entry.offset > lte2->resource_entry.offset) @@ -378,7 +372,7 @@ static int sort_stream_list_by_wim_position(struct list_head *stream_list) { struct list_head *cur; size_t num_streams; - struct lookup_table_entry **array; + struct wim_lookup_table_entry **array; size_t i; size_t array_size; @@ -394,7 +388,7 @@ static int sort_stream_list_by_wim_position(struct list_head *stream_list) } cur = stream_list->next; for (i = 0; i < num_streams; i++) { - array[i] = container_of(cur, struct lookup_table_entry, staging_list); + array[i] = container_of(cur, struct wim_lookup_table_entry, staging_list); cur = cur->next; } @@ -411,7 +405,7 @@ static void calculate_bytes_to_extract(struct list_head *stream_list, int extract_flags, union wimlib_progress_info *progress) { - struct lookup_table_entry *lte; + struct wim_lookup_table_entry *lte; u64 total_bytes = 0; u64 num_streams = 0; @@ -438,7 +432,7 @@ static void calculate_bytes_to_extract(struct list_head *stream_list, progress->extract.completed_bytes = 0; } -static void maybe_add_stream_for_extraction(struct lookup_table_entry *lte, +static void maybe_add_stream_for_extraction(struct wim_lookup_table_entry *lte, struct list_head *stream_list) { if (++lte->out_refcnt == 1) { @@ -447,30 +441,29 @@ static void maybe_add_stream_for_extraction(struct lookup_table_entry *lte, } } -static void inode_find_streams_for_extraction(struct inode *inode, +static void inode_find_streams_for_extraction(struct wim_inode *inode, struct list_head *stream_list, int extract_flags) { - struct lookup_table_entry *lte; + struct wim_lookup_table_entry *lte; bool inode_added = false; lte = inode_unnamed_lte_resolved(inode); - if (lte) { maybe_add_stream_for_extraction(lte, stream_list); - list_add_tail(&inode->lte_inode_list, <e->inode_list); + list_add_tail(&inode->i_lte_inode_list, <e->inode_list); inode_added = true; } #ifdef WITH_NTFS_3G if (extract_flags & WIMLIB_EXTRACT_FLAG_NTFS) { - for (unsigned i = 0; i < inode->num_ads; i++) { - if (inode->ads_entries[i].stream_name_len != 0) { - lte = inode->ads_entries[i].lte; + for (unsigned i = 0; i < inode->i_num_ads; i++) { + if (inode->i_ads_entries[i].stream_name_len != 0) { + lte = inode->i_ads_entries[i].lte; if (lte) { maybe_add_stream_for_extraction(lte, stream_list); if (!inode_added) { - list_add_tail(&inode->lte_inode_list, + list_add_tail(&inode->i_lte_inode_list, <e->inode_list); inode_added = true; } @@ -483,17 +476,17 @@ static void inode_find_streams_for_extraction(struct inode *inode, static void find_streams_for_extraction(struct hlist_head *inode_list, struct list_head *stream_list, - struct lookup_table *lookup_table, + struct wim_lookup_table *lookup_table, int extract_flags) { - struct inode *inode; + struct wim_inode *inode; struct hlist_node *cur; - struct dentry *dentry; + struct wim_dentry *dentry; for_lookup_table_entry(lookup_table, lte_zero_out_refcnt, NULL); INIT_LIST_HEAD(stream_list); - hlist_for_each_entry(inode, cur, inode_list, hlist) { - if (!inode->resolved) + hlist_for_each_entry(inode, cur, inode_list, i_hlist) { + if (!inode->i_resolved) inode_resolve_ltes(inode, lookup_table); inode_for_each_dentry(dentry, inode) dentry->is_extracted = 0; @@ -503,8 +496,8 @@ static void find_streams_for_extraction(struct hlist_head *inode_list, } struct apply_operations { - int (*apply_dentry)(struct dentry *dentry, void *arg); - int (*apply_dentry_timestamps)(struct dentry *dentry, void *arg); + int (*apply_dentry)(struct wim_dentry *dentry, void *arg); + int (*apply_dentry_timestamps)(struct wim_dentry *dentry, void *arg); }; static const struct apply_operations normal_apply_operations = { @@ -526,40 +519,54 @@ static int apply_stream_list(struct list_head *stream_list, { uint64_t bytes_per_progress = args->progress.extract.total_bytes / 100; uint64_t next_progress = bytes_per_progress; - struct lookup_table_entry *lte; - struct inode *inode; - struct dentry *dentry; - int ret = 0; + struct wim_lookup_table_entry *lte; + struct wim_inode *inode; + struct wim_dentry *dentry; + int ret; - /* This complicated loop is actually just looping through the dentries - * (as for_dentry_in_tree() does), but the outer loop is actually over - * the distinct streams to be extracted so that sequential reading of - * the WIM can be implemented. */ + /* This complicated loop is essentially looping through the dentries, + * although dentries may be visited more than once (if a dentry contains + * two different nonempty streams) or not at all (if a dentry contains + * no non-empty streams). + * + * The outer loop is over the distinct streams to be extracted so that + * sequential reading of the WIM can be implemented. */ /* For each distinct stream to be extracted */ list_for_each_entry(lte, stream_list, staging_list) { /* For each inode that contains the stream */ - list_for_each_entry(inode, <e->inode_list, lte_inode_list) { + list_for_each_entry(inode, <e->inode_list, i_lte_inode_list) { /* For each dentry that points to the inode */ inode_for_each_dentry(dentry, inode) { - ret = ops->apply_dentry(dentry, args); + /* Extract the dentry if it was not already + * extracted */ + ret = maybe_apply_dentry(dentry, args); if (ret != 0) - goto out; + return ret; if (progress_func && - args->progress.extract.completed_bytes >= next_progress && - args->progress.extract.total_bytes != 0) + args->progress.extract.completed_bytes >= next_progress) { progress_func(WIMLIB_PROGRESS_MSG_EXTRACT_STREAMS, &args->progress); - next_progress += bytes_per_progress; + if (args->progress.extract.completed_bytes >= + args->progress.extract.total_bytes) + { + next_progress = ~0ULL; + } else { + next_progress = + min (args->progress.extract.completed_bytes + + bytes_per_progress, + args->progress.extract.total_bytes); + } } } } } -out: - return ret; + return 0; } +/* Extracts the image @image from the WIM @w to the directory or NTFS volume + * @target. */ static int extract_single_image(WIMStruct *w, int image, const char *target, int extract_flags, wimlib_progress_func_t progress_func) @@ -575,7 +582,6 @@ static int extract_single_image(WIMStruct *w, int image, args.target = target; args.extract_flags = extract_flags; args.num_lutimes_warnings = 0; - args.target = target; args.stream_list = &stream_list; args.progress_func = progress_func; @@ -606,9 +612,11 @@ static int extract_single_image(WIMStruct *w, int image, inode_list = &w->image_metadata[image - 1].inode_list; + /* Build a list of the streams that need to be extracted */ find_streams_for_extraction(inode_list, &stream_list, w->lookup_table, extract_flags); + /* Calculate the number of bytes of data that will be extracted */ calculate_bytes_to_extract(&stream_list, extract_flags, &args.progress); @@ -617,6 +625,9 @@ static int extract_single_image(WIMStruct *w, int image, &args.progress); } + /* If a sequential extraction was specified, sort the streams to be + * extracted by their position in the WIM file, so that the WIM file can + * be read sequentially. */ if (extract_flags & WIMLIB_EXTRACT_FLAG_SEQUENTIAL) { ret = sort_stream_list_by_wim_position(&stream_list); if (ret != 0) { @@ -630,8 +641,10 @@ static int extract_single_image(WIMStruct *w, int image, &args.progress); } + /* Make the directory structure and extract empty files */ args.extract_flags |= WIMLIB_EXTRACT_FLAG_NO_STREAMS; - ret = for_dentry_in_tree(wim_root_dentry(w), ops->apply_dentry, &args); + args.apply_dentry = ops->apply_dentry; + ret = for_dentry_in_tree(wim_root_dentry(w), maybe_apply_dentry, &args); args.extract_flags &= ~WIMLIB_EXTRACT_FLAG_NO_STREAMS; if (ret != 0) goto out; @@ -641,13 +654,17 @@ static int extract_single_image(WIMStruct *w, int image, &args.progress); } + /* Extract non-empty files */ ret = apply_stream_list(&stream_list, &args, ops, progress_func); if (ret != 0) goto out; - if (progress_func) - progress_func(WIMLIB_PROGRESS_MSG_APPLY_TIMESTAMPS, NULL); + if (progress_func) { + progress_func(WIMLIB_PROGRESS_MSG_APPLY_TIMESTAMPS, + &args.progress); + } + /* Apply timestamps */ ret = for_dentry_in_tree_depth(wim_root_dentry(w), ops->apply_dentry_timestamps, &args); if (ret != 0) @@ -659,6 +676,7 @@ static int extract_single_image(WIMStruct *w, int image, } out: #ifdef WITH_NTFS_3G + /* Unmount the NTFS volume */ if (extract_flags & WIMLIB_EXTRACT_FLAG_NTFS) { if (ntfs_umount(args.vol, FALSE) != 0) { ERROR_WITH_ERRNO("Failed to unmount NTFS volume `%s'", args.target); @@ -671,8 +689,8 @@ out: } -/* Extracts all images from the WIM to @output_dir, with the images placed in - * subdirectories named by their image names. */ +/* Extracts all images from the WIM to the directory @target, with the images + * placed in subdirectories named by their image names. */ static int extract_all_images(WIMStruct *w, const char *target, int extract_flags, wimlib_progress_func_t progress_func) @@ -706,15 +724,17 @@ static int extract_all_images(WIMStruct *w, const char *target, return 0; } -/* Extracts a single image or all images from a WIM file. */ -WIMLIBAPI int wimlib_extract_image(WIMStruct *w, int image, +/* Extracts a single image or all images from a WIM file to a directory or NTFS + * volume. */ +WIMLIBAPI int wimlib_extract_image(WIMStruct *w, + int image, const char *target, int extract_flags, WIMStruct **additional_swms, unsigned num_additional_swms, wimlib_progress_func_t progress_func) { - struct lookup_table *joined_tab, *w_tab_save; + struct wim_lookup_table *joined_tab, *w_tab_save; int ret; if (!target)