* 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)
/* 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
/* 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
}
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)
*
* 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)
#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];
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,
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);
// 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
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)
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,
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);
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;
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;
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;
}
lte_overwrite_prepare, &args);
}
-static int inode_find_streams_to_write(struct inode *inode,
- struct lookup_table *table,
+static int inode_find_streams_to_write(struct wim_inode *inode,
+ struct wim_lookup_table *table,
struct list_head *stream_list)
{
- struct lookup_table_entry *lte;
- for (unsigned i = 0; i <= inode->num_ads; i++) {
+ 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(<e->staging_list, stream_list);
- lte->out_refcnt += inode->link_count;
+ lte->out_refcnt += inode->i_nlink;
}
}
return 0;
static int image_find_streams_to_write(WIMStruct *w)
{
- struct inode *inode;
+ 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, hlist) {
+ hlist_for_each_entry(inode, cur, inode_list, i_hlist) {
inode_find_streams_to_write(inode, w->lookup_table,
(struct list_head*)w->private);
}
" 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 {
{
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;
}
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;
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;
}
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;
}