X-Git-Url: https://wimlib.net/git/?p=wimlib;a=blobdiff_plain;f=src%2Fwrite.c;h=c346e61c65c57e51b629e5d306799724255d18f4;hp=e7f6966760c465f8b832765af70836f1c47b1291;hb=ebd6c0ec0ff47ac18af4ef918fd78fb8d9f19540;hpb=9a23ab0c8f362ca68a45e8b4a9a973b418972cb6

diff --git a/src/write.c b/src/write.c
index e7f69667..c346e61c 100644
--- a/src/write.c
+++ b/src/write.c
@@ -6,7 +6,7 @@
  */
 
 /*
- * Copyright (C) 2012 Eric Biggers
+ * Copyright (C) 2012, 2013 Eric Biggers
  *
  * This file is part of wimlib, a library for working with WIM files.
  *
@@ -98,7 +98,7 @@ struct chunk_table {
  * output file.
  */
 static int
-begin_wim_resource_chunk_tab(const struct lookup_table_entry *lte,
+begin_wim_resource_chunk_tab(const struct wim_lookup_table_entry *lte,
 			     FILE *out_fp,
 			     off_t file_offset,
 			     struct chunk_table **chunk_tab_ret)
@@ -250,63 +250,76 @@ finish_wim_resource_chunk_tab(struct chunk_table *chunk_tab,
 
 /* Prepare for multiple reads to a resource by caching a FILE * or NTFS
  * attribute pointer in the lookup table entry. */
-static int prepare_resource_for_read(struct lookup_table_entry *lte
+static int prepare_resource_for_read(struct wim_lookup_table_entry *lte
 
 					#ifdef WITH_NTFS_3G
 					, ntfs_inode **ni_ret
 					#endif
 		)
 {
-	if (lte->resource_location == RESOURCE_IN_FILE_ON_DISK
-	     && !lte->file_on_disk_fp)
-	{
-		wimlib_assert(lte->file_on_disk);
-		lte->file_on_disk_fp = fopen(lte->file_on_disk, "rb");
+	switch (lte->resource_location) {
+	case RESOURCE_IN_FILE_ON_DISK:
 		if (!lte->file_on_disk_fp) {
-			ERROR_WITH_ERRNO("Failed to open the file `%s' for "
-					 "reading", lte->file_on_disk);
-			return WIMLIB_ERR_OPEN;
+			lte->file_on_disk_fp = fopen(lte->file_on_disk, "rb");
+			if (!lte->file_on_disk_fp) {
+				ERROR_WITH_ERRNO("Failed to open the file "
+						 "`%s'", lte->file_on_disk);
+				return WIMLIB_ERR_OPEN;
+			}
 		}
-	}
+		break;
 #ifdef WITH_NTFS_3G
-	else if (lte->resource_location == RESOURCE_IN_NTFS_VOLUME
-		  && !lte->attr)
-	{
-		struct ntfs_location *loc = lte->ntfs_loc;
-		ntfs_inode *ni;
-		wimlib_assert(loc);
-		ni = ntfs_pathname_to_inode(*loc->ntfs_vol_p, NULL, loc->path_utf8);
-		if (!ni) {
-			ERROR_WITH_ERRNO("Failed to open inode `%s' in NTFS "
-					 "volume", loc->path_utf8);
-			return WIMLIB_ERR_NTFS_3G;
-		}
-		lte->attr = ntfs_attr_open(ni,
-					   loc->is_reparse_point ? AT_REPARSE_POINT : AT_DATA,
-					   (ntfschar*)loc->stream_name_utf16,
-					   loc->stream_name_utf16_num_chars);
+	case RESOURCE_IN_NTFS_VOLUME:
 		if (!lte->attr) {
-			ERROR_WITH_ERRNO("Failed to open attribute of `%s' in "
-					 "NTFS volume", loc->path_utf8);
-			ntfs_inode_close(ni);
-			return WIMLIB_ERR_NTFS_3G;
+			struct ntfs_location *loc = lte->ntfs_loc;
+			ntfs_inode *ni;
+			wimlib_assert(loc);
+			ni = ntfs_pathname_to_inode(*loc->ntfs_vol_p, NULL, loc->path_utf8);
+			if (!ni) {
+				ERROR_WITH_ERRNO("Failed to open inode `%s' in NTFS "
+						 "volume", loc->path_utf8);
+				return WIMLIB_ERR_NTFS_3G;
+			}
+			lte->attr = ntfs_attr_open(ni,
+						   loc->is_reparse_point ? AT_REPARSE_POINT : AT_DATA,
+						   (ntfschar*)loc->stream_name_utf16,
+						   loc->stream_name_utf16_num_chars);
+			if (!lte->attr) {
+				ERROR_WITH_ERRNO("Failed to open attribute of `%s' in "
+						 "NTFS volume", loc->path_utf8);
+				ntfs_inode_close(ni);
+				return WIMLIB_ERR_NTFS_3G;
+			}
+			*ni_ret = ni;
 		}
-		*ni_ret = ni;
-	}
+		break;
+#endif
+#if defined(__CYGWIN__) || defined(__WIN32__)
+	case RESOURCE_WIN32:
+		if (!lte->file_on_disk_fp) {
+			lte->file_on_disk_fp = win32_open_handle(lte->file_on_disk);
+			if (!lte->file_on_disk_fp)
+				return WIMLIB_ERR_OPEN;
+		}
+		break;
 #endif
+	default:
+		break;
+	}
 	return 0;
 }
 
 /* Undo prepare_resource_for_read() by closing the cached FILE * or NTFS
  * attribute. */
-static void end_wim_resource_read(struct lookup_table_entry *lte
+static void end_wim_resource_read(struct wim_lookup_table_entry *lte
 				#ifdef WITH_NTFS_3G
 					, ntfs_inode *ni
 				#endif
 					)
 {
 	if (lte->resource_location == RESOURCE_IN_FILE_ON_DISK
-	    && lte->file_on_disk_fp) {
+	    && lte->file_on_disk_fp)
+	{
 		fclose(lte->file_on_disk_fp);
 		lte->file_on_disk_fp = NULL;
 	}
@@ -320,10 +333,18 @@ static void end_wim_resource_read(struct lookup_table_entry *lte
 			ntfs_inode_close(ni);
 	}
 #endif
+#if defined(__CYGWIN__) || defined(__WIN32__)
+	else if (lte->resource_location == RESOURCE_WIN32
+		 && lte->file_on_disk_fp)
+	{
+		win32_close_handle(lte->file_on_disk_fp);
+		lte->file_on_disk_fp = NULL;
+	}
+#endif
 }
 
 static int
-write_uncompressed_resource_and_truncate(struct lookup_table_entry *lte,
+write_uncompressed_resource_and_truncate(struct wim_lookup_table_entry *lte,
 					 FILE *out_fp,
 					 off_t file_offset,
 					 struct resource_entry *out_res_entry)
@@ -364,7 +385,7 @@ write_uncompressed_resource_and_truncate(struct lookup_table_entry *lte,
  *
  * Returns 0 on success; nonzero on failure.
  */
-int write_wim_resource(struct lookup_table_entry *lte,
+int write_wim_resource(struct wim_lookup_table_entry *lte,
 		       FILE *out_fp, int out_ctype,
 		       struct resource_entry *out_res_entry,
 		       int flags)
@@ -626,7 +647,7 @@ struct compressor_thread_params {
 #define MAX_CHUNKS_PER_MSG 2
 
 struct message {
-	struct lookup_table_entry *lte;
+	struct wim_lookup_table_entry *lte;
 	u8 *uncompressed_chunks[MAX_CHUNKS_PER_MSG];
 	u8 *out_compressed_chunks[MAX_CHUNKS_PER_MSG];
 	u8 *compressed_chunks[MAX_CHUNKS_PER_MSG];
@@ -686,7 +707,7 @@ static int do_write_stream_list(struct list_head *my_resources,
 				int write_resource_flags)
 {
 	int ret;
-	struct lookup_table_entry *lte, *tmp;
+	struct wim_lookup_table_entry *lte, *tmp;
 
 	list_for_each_entry_safe(lte, tmp, my_resources, staging_list) {
 		ret = write_wim_resource(lte,
@@ -777,7 +798,7 @@ static int main_writer_thread_proc(struct list_head *stream_list,
 	int ret;
 	struct chunk_table *cur_chunk_tab = NULL;
 	struct message *msgs = CALLOC(num_messages, sizeof(struct message));
-	struct lookup_table_entry *next_lte = NULL;
+	struct wim_lookup_table_entry *next_lte = NULL;
 
 	// Initially, all the messages are available to use.
 	LIST_HEAD(available_msgs);
@@ -818,7 +839,7 @@ static int main_writer_thread_proc(struct list_head *stream_list,
 	// list and written directly by the main thread.
 	LIST_HEAD(my_resources);
 
-	struct lookup_table_entry *cur_lte = NULL;
+	struct wim_lookup_table_entry *cur_lte = NULL;
 	struct message *msg;
 
 #ifdef WITH_NTFS_3G
@@ -835,10 +856,11 @@ static int main_writer_thread_proc(struct list_head *stream_list,
 		for (size_t j = 0; j < MAX_CHUNKS_PER_MSG; j++) {
 			msgs[i].compressed_chunks[j] = MALLOC(WIM_CHUNK_SIZE);
 
-			// The extra 8 bytes is because longest_match() in lz.c
-			// may read a little bit off the end of the uncompressed
-			// data.  It doesn't need to be initialized--- we really
-			// just need to avoid accessing an unmapped page.
+			// The extra 8 bytes is because longest_match() in
+			// lz77.c may read a little bit off the end of the
+			// uncompressed data.  It doesn't need to be
+			// initialized--- we really just need to avoid accessing
+			// an unmapped page.
 			msgs[i].uncompressed_chunks[j] = MALLOC(WIM_CHUNK_SIZE + 8);
 			if (msgs[i].compressed_chunks[j] == NULL ||
 			    msgs[i].uncompressed_chunks[j] == NULL)
@@ -908,7 +930,7 @@ static int main_writer_thread_proc(struct list_head *stream_list,
 						break;
 					}
 					next_lte = container_of(next_resource,
-								struct lookup_table_entry,
+								struct wim_lookup_table_entry,
 								staging_list);
 					next_resource = next_resource->next;
 					if ((!(write_flags & WIMLIB_WRITE_FLAG_RECOMPRESS)
@@ -1113,7 +1135,7 @@ static int main_writer_thread_proc(struct list_head *stream_list,
 					cur_lte = NULL;
 				else
 					cur_lte = container_of(cur_lte->staging_list.next,
-							       struct lookup_table_entry,
+							       struct wim_lookup_table_entry,
 							       staging_list);
 
 				// Since we just finished writing a stream,
@@ -1265,8 +1287,8 @@ out_join:
 
 	for (unsigned i = 0; i < num_threads; i++) {
 		if (pthread_join(compressor_threads[i], NULL)) {
-			WARNING("Failed to join compressor thread %u: %s",
-				i, strerror(errno));
+			WARNING_WITH_ERRNO("Failed to join compressor "
+					   "thread %u", i);
 		}
 	}
 	FREE(compressor_threads);
@@ -1297,7 +1319,7 @@ static int write_stream_list(struct list_head *stream_list, FILE *out_fp,
 			     unsigned num_threads,
 			     wimlib_progress_func_t progress_func)
 {
-	struct lookup_table_entry *lte;
+	struct wim_lookup_table_entry *lte;
 	size_t num_streams = 0;
 	u64 total_bytes = 0;
 	u64 total_compression_bytes = 0;
@@ -1341,19 +1363,22 @@ static int write_stream_list(struct list_head *stream_list, FILE *out_fp,
 
 struct lte_overwrite_prepare_args {
 	WIMStruct *wim;
-	struct list_head *stream_list;
 	off_t end_offset;
+	struct list_head *stream_list;
 };
 
-static int lte_overwrite_prepare(struct lookup_table_entry *lte, void *arg)
+static int lte_overwrite_prepare(struct wim_lookup_table_entry *lte, void *arg)
 {
 	struct lte_overwrite_prepare_args *args = arg;
 
-	if (lte->resource_entry.offset +
-	    lte->resource_entry.size > args->end_offset)
+	if (lte->resource_location == RESOURCE_IN_WIM &&
+	    lte->wim == args->wim &&
+	    lte->resource_entry.offset + lte->resource_entry.size > args->end_offset)
 	{
+	#ifdef ENABLE_ERROR_MESSAGES
 		ERROR("The following resource is after the XML data:");
-		print_lookup_table_entry(lte);
+		print_lookup_table_entry(lte, stderr);
+	#endif
 		return WIMLIB_ERR_RESOURCE_ORDER;
 	}
 
@@ -1372,33 +1397,43 @@ static int wim_find_new_streams(WIMStruct *wim, off_t end_offset,
 				struct list_head *stream_list)
 {
 	struct lte_overwrite_prepare_args args = {
-		.wim = wim,
+		.wim         = wim,
+		.end_offset  = end_offset,
 		.stream_list = stream_list,
-		.end_offset = end_offset,
 	};
 
 	return for_lookup_table_entry(wim->lookup_table,
 				      lte_overwrite_prepare, &args);
 }
 
-static int dentry_find_streams_to_write(struct dentry *dentry,
-					void *wim)
+static int inode_find_streams_to_write(struct wim_inode *inode,
+				       struct wim_lookup_table *table,
+				       struct list_head *stream_list)
 {
-	WIMStruct *w = wim;
-	struct list_head *stream_list = w->private;
-	struct lookup_table_entry *lte;
-	for (unsigned i = 0; i <= dentry->d_inode->num_ads; i++) {
-		lte = inode_stream_lte(dentry->d_inode, i, w->lookup_table);
-		if (lte && ++lte->out_refcnt == 1)
-			list_add_tail(&lte->staging_list, stream_list);
+	struct wim_lookup_table_entry *lte;
+	for (unsigned i = 0; i <= inode->i_num_ads; i++) {
+		lte = inode_stream_lte(inode, i, table);
+		if (lte) {
+			if (lte->out_refcnt == 0)
+				list_add_tail(&lte->staging_list, stream_list);
+			lte->out_refcnt += inode->i_nlink;
+		}
 	}
 	return 0;
 }
 
 static int image_find_streams_to_write(WIMStruct *w)
 {
-	return for_dentry_in_tree(wim_root_dentry(w),
-				  dentry_find_streams_to_write, w);
+	struct wim_inode *inode;
+	struct hlist_node *cur;
+	struct hlist_head *inode_list;
+
+	inode_list = &wim_get_current_image_metadata(w)->inode_list;
+	hlist_for_each_entry(inode, cur, inode_list, i_hlist) {
+		inode_find_streams_to_write(inode, w->lookup_table,
+					    (struct list_head*)w->private);
+	}
+	return 0;
 }
 
 static int write_wim_streams(WIMStruct *w, int image, int write_flags,
@@ -1590,8 +1625,8 @@ int lock_wim(WIMStruct *w, FILE *fp)
 				      "        by another process!", w->filename);
 				ret = WIMLIB_ERR_ALREADY_LOCKED;
 			} else {
-				WARNING("Failed to lock `%s': %s",
-					w->filename, strerror(errno));
+				WARNING_WITH_ERRNO("Failed to lock `%s'",
+						   w->filename);
 				ret = 0;
 			}
 		} else {
@@ -1629,8 +1664,7 @@ void close_wim_writable(WIMStruct *w)
 {
 	if (w->out_fp) {
 		if (fclose(w->out_fp) != 0) {
-			WARNING("Failed to close output WIM: %s",
-				strerror(errno));
+			WARNING_WITH_ERRNO("Failed to close output WIM");
 		}
 		w->out_fp = NULL;
 	}
@@ -1691,6 +1725,7 @@ WIMLIBAPI int wimlib_write(WIMStruct *w, const char *path,
 	ret = finish_write(w, image, write_flags, progress_func);
 out:
 	close_wim_writable(w);
+	DEBUG("wimlib_write(path=%s) = %d", path, ret);
 	return ret;
 }
 
@@ -1856,7 +1891,9 @@ out_ftruncate:
 	if (ret != 0 && !(write_flags & WIMLIB_WRITE_FLAG_NO_LOOKUP_TABLE)) {
 		WARNING("Truncating `%s' to its original size (%"PRIu64" bytes)",
 			w->filename, old_wim_end);
-		truncate(w->filename, old_wim_end);
+		/* Return value of truncate() is ignored because this is already
+		 * an error path. */
+		(void)truncate(w->filename, old_wim_end);
 	}
 	w->wim_locked = 0;
 	return ret;
@@ -1914,8 +1951,8 @@ static int overwrite_wim_via_tmpfile(WIMStruct *w, int write_flags,
 	w->fp = fopen(w->filename, "rb");
 	if (w->fp == NULL) {
 		ret = WIMLIB_ERR_REOPEN;
-		WARNING("Failed to re-open `%s' read-only: %s",
-			w->filename, strerror(errno));
+		WARNING_WITH_ERRNO("Failed to re-open `%s' read-only",
+				   w->filename);
 		FREE(w->filename);
 		w->filename = NULL;
 	}
@@ -1923,7 +1960,7 @@ static int overwrite_wim_via_tmpfile(WIMStruct *w, int write_flags,
 err:
 	/* Remove temporary file. */
 	if (unlink(tmpfile) != 0)
-		WARNING("Failed to remove `%s': %s", tmpfile, strerror(errno));
+		WARNING_WITH_ERRNO("Failed to remove `%s'", tmpfile);
 	return ret;
 }