return (dentry_correct_length_unaligned(dentry) + 7) & ~7;
}
-/* Return %true iff @dentry has the UTF-8 file name @name that has length
- * @name_len bytes. */
-static bool dentry_has_name(const struct dentry *dentry, const char *name,
- size_t name_len)
-{
- if (dentry->file_name_utf8_len != name_len)
- return false;
- return memcmp(dentry->file_name_utf8, name, name_len) == 0;
-}
-
/* Return %true iff the alternate data stream entry @entry has the UTF-8 stream
* name @name that has length @name_len bytes. */
static inline bool ads_entry_has_name(const struct ads_entry *entry,
return __dentry_total_length(dentry, dentry->length);
}
-/* Transfers file attributes from a `stat' buffer to a WIM "inode". */
-void stbuf_to_inode(const struct stat *stbuf, struct inode *inode)
-{
- if (S_ISLNK(stbuf->st_mode)) {
- inode->attributes = FILE_ATTRIBUTE_REPARSE_POINT;
- inode->reparse_tag = WIM_IO_REPARSE_TAG_SYMLINK;
- } else if (S_ISDIR(stbuf->st_mode)) {
- inode->attributes = FILE_ATTRIBUTE_DIRECTORY;
- } else {
- inode->attributes = FILE_ATTRIBUTE_NORMAL;
- }
- if (sizeof(ino_t) >= 8)
- inode->ino = (u64)stbuf->st_ino;
- else
- inode->ino = (u64)stbuf->st_ino |
- ((u64)stbuf->st_dev << ((sizeof(ino_t) * 8) & 63));
- /* Set timestamps */
- inode->creation_time = timespec_to_wim_timestamp(&stbuf->st_mtim);
- inode->last_write_time = timespec_to_wim_timestamp(&stbuf->st_mtim);
- inode->last_access_time = timespec_to_wim_timestamp(&stbuf->st_atim);
-}
-
#ifdef WITH_FUSE
/* Transfers file attributes from a struct inode to a `stat' buffer.
*
else if (inode_is_directory(inode))
stbuf->st_mode = S_IFDIR | 0755;
else
- stbuf->st_mode = S_IFREG | 0644;
+ stbuf->st_mode = S_IFREG | 0755;
stbuf->st_ino = (ino_t)inode->ino;
stbuf->st_nlink = inode->link_count;
}
#endif
-int for_dentry_in_rbtree(struct rb_node *node,
+int for_dentry_in_rbtree(struct rb_node *root,
int (*visitor)(struct dentry *, void *),
void *arg)
{
int ret;
- if (node) {
- ret = for_dentry_in_rbtree(node->rb_left, visitor, arg);
- if (ret != 0)
- return ret;
- ret = visitor(rbnode_dentry(node), arg);
- if (ret != 0)
- return ret;
- ret = for_dentry_in_rbtree(node->rb_right, visitor, arg);
- if (ret != 0)
- return ret;
+ struct rb_node *node = root;
+ LIST_HEAD(stack);
+ while (true) {
+ if (node) {
+ list_add(&rbnode_dentry(node)->tmp_list, &stack);
+ node = node->rb_left;
+ } else {
+ struct list_head *next;
+ struct dentry *dentry;
+
+ next = stack.next;
+ if (next == &stack)
+ return 0;
+ dentry = container_of(next, struct dentry, tmp_list);
+ list_del(next);
+ ret = visitor(dentry, arg);
+ if (ret != 0)
+ return ret;
+ node = dentry->rb_node.rb_right;
+ }
}
- return 0;
}
-int for_dentry_tree_in_rbtree(struct rb_node *node,
- int (*visitor)(struct dentry*, void*),
- void *arg)
+static int for_dentry_tree_in_rbtree_depth(struct rb_node *node,
+ int (*visitor)(struct dentry*, void*),
+ void *arg)
{
int ret;
if (node) {
- ret = for_dentry_tree_in_rbtree(node->rb_left, visitor, arg);
+ ret = for_dentry_tree_in_rbtree_depth(node->rb_left,
+ visitor, arg);
if (ret != 0)
return ret;
- ret = for_dentry_in_tree(rbnode_dentry(node), visitor, arg);
+ ret = for_dentry_tree_in_rbtree_depth(node->rb_right,
+ visitor, arg);
if (ret != 0)
return ret;
- ret = for_dentry_tree_in_rbtree(node->rb_right, visitor, arg);
+ ret = for_dentry_in_tree_depth(rbnode_dentry(node), visitor, arg);
if (ret != 0)
return ret;
}
return 0;
}
-static int for_dentry_tree_in_rbtree_depth(struct rb_node *node,
- int (*visitor)(struct dentry*, void*),
- void *arg)
+/*#define RECURSIVE_FOR_DENTRY_IN_TREE*/
+
+#ifdef RECURSIVE_FOR_DENTRY_IN_TREE
+static int for_dentry_tree_in_rbtree(struct rb_node *node,
+ int (*visitor)(struct dentry*, void*),
+ void *arg)
{
int ret;
if (node) {
- ret = for_dentry_tree_in_rbtree_depth(node->rb_left,
- visitor, arg);
+ ret = for_dentry_tree_in_rbtree(node->rb_left, visitor, arg);
if (ret != 0)
return ret;
- ret = for_dentry_tree_in_rbtree_depth(node->rb_right,
- visitor, arg);
+ ret = for_dentry_in_tree(rbnode_dentry(node), visitor, arg);
if (ret != 0)
return ret;
- ret = for_dentry_in_tree_depth(rbnode_dentry(node), visitor, arg);
+ ret = for_dentry_tree_in_rbtree(node->rb_right, visitor, arg);
if (ret != 0)
return ret;
}
return 0;
}
+#endif
/*
- * Calls a function on all directory entries in a directory tree. It is called
- * on a parent before its children.
+ * Calls a function on all directory entries in a WIM dentry tree. Logically,
+ * this is a pre-order traversal (the function is called on a parent dentry
+ * before its children), but sibling dentries will be visited in order as well.
+ *
+ * In reality, the data structures are more complicated than the above might
+ * suggest because there is a separate red-black tree for each dentry that
+ * contains its direct children.
*/
int for_dentry_in_tree(struct dentry *root,
int (*visitor)(struct dentry*, void*), void *arg)
{
+#ifdef RECURSIVE_FOR_DENTRY_IN_TREE
int ret = visitor(root, arg);
if (ret != 0)
return ret;
+ return for_dentry_tree_in_rbtree(root->d_inode->children.rb_node, visitor, arg);
+#else
+ int ret;
+ struct list_head main_stack;
+ struct list_head sibling_stack;
+ struct list_head *sibling_stack_bottom;
+ struct dentry *main_dentry;
+ struct rb_node *node;
+ struct list_head *next_sibling;
+ struct dentry *dentry;
+
+ ret = visitor(root, arg);
+ if (ret != 0)
+ return ret;
+
+ main_dentry = root;
+ sibling_stack_bottom = &sibling_stack;
+ INIT_LIST_HEAD(&main_stack);
+ INIT_LIST_HEAD(&sibling_stack);
+
+ list_add(&root->tmp_list, &main_stack);
+ node = root->d_inode->children.rb_node;
- return for_dentry_tree_in_rbtree(root->d_inode->children.rb_node,
- visitor, arg);
+ while (1) {
+ // Prepare for non-recursive in-order traversal of the red-black
+ // tree of this dentry's children
+
+ while (node) {
+ // Push this node to the sibling stack and examine the
+ // left neighbor, if any
+ list_add(&rbnode_dentry(node)->tmp_list, &sibling_stack);
+ node = node->rb_left;
+ }
+
+ next_sibling = sibling_stack.next;
+ if (next_sibling == sibling_stack_bottom) {
+ // Done with all siblings. Pop the main dentry to move
+ // back up one level.
+ main_dentry = container_of(main_stack.next,
+ struct dentry,
+ tmp_list);
+ list_del(&main_dentry->tmp_list);
+
+ if (main_dentry == root)
+ goto out;
+
+ // Restore sibling stack bottom from the previous level
+ sibling_stack_bottom = (void*)main_dentry->parent;
+
+ // Restore the just-popped main dentry's parent
+ main_dentry->parent = container_of(main_stack.next,
+ struct dentry,
+ tmp_list);
+
+ // The next sibling to traverse in the previous level,
+ // in the in-order traversal of the red-black tree, is
+ // the one to the right.
+ node = main_dentry->rb_node.rb_right;
+ } else {
+ // The sibling stack is not empty, so there are more to
+ // go!
+
+ // Pop a sibling from the stack.
+ list_del(next_sibling);
+ dentry = container_of(next_sibling, struct dentry, tmp_list);
+
+ // Visit the sibling.
+ ret = visitor(dentry, arg);
+ if (ret != 0) {
+ // Failed. Restore parent pointers for the
+ // dentries in the main stack
+ list_for_each_entry(dentry, &main_stack, tmp_list) {
+ dentry->parent = container_of(dentry->tmp_list.next,
+ struct dentry,
+ tmp_list);
+ }
+ goto out;
+ }
+
+ // We'd like to recursively visit the dentry tree rooted
+ // at this sibling. To do this, add it to the main
+ // stack, save the bottom of this level's sibling stack
+ // in the dentry->parent field, re-set the bottom of the
+ // sibling stack to be its current height, and set
+ // main_dentry to the sibling so it becomes the parent
+ // dentry in the next iteration through the outer loop.
+ if (inode_has_children(dentry->d_inode)) {
+ list_add(&dentry->tmp_list, &main_stack);
+ dentry->parent = (void*)sibling_stack_bottom;
+ sibling_stack_bottom = sibling_stack.next;
+
+ main_dentry = dentry;
+ node = main_dentry->d_inode->children.rb_node;
+ } else {
+ node = dentry->rb_node.rb_right;
+ }
+ }
+ }
+out:
+ root->parent = root;
+ return ret;
+#endif
}
/*
int for_dentry_in_tree_depth(struct dentry *root,
int (*visitor)(struct dentry*, void*), void *arg)
{
-
- int ret = for_dentry_tree_in_rbtree_depth(root->d_inode->children.rb_node,
- visitor, arg);
+#if 1
+ int ret;
+ ret = for_dentry_tree_in_rbtree_depth(root->d_inode->children.rb_node,
+ visitor, arg);
if (ret != 0)
return ret;
return visitor(root, arg);
+
+#else
+ int ret;
+ struct list_head main_stack;
+ struct list_head sibling_stack;
+ struct list_head *sibling_stack_bottom;
+ struct dentry *main_dentry;
+ struct rb_node *node;
+ struct list_head *next_sibling;
+ struct dentry *dentry;
+
+ main_dentry = root;
+ sibling_stack_bottom = &sibling_stack;
+ INIT_LIST_HEAD(&main_stack);
+ INIT_LIST_HEAD(&sibling_stack);
+
+ list_add(&main_dentry->tmp_list, &main_stack);
+
+ while (1) {
+ node = main_dentry->d_inode->children.rb_node;
+
+ while (1) {
+ if (node->rb_left) {
+ list_add(&rbnode_dentry(node)->tmp_list, &sibling_stack);
+ node = node->rb_left;
+ continue;
+ }
+ if (node->rb_right) {
+ list_add(&rbnode_dentry(node)->tmp_list, &sibling_stack);
+ node = node->rb_right;
+ continue;
+ }
+ list_add(&rbnode_dentry(node)->tmp_list, &sibling_stack);
+ }
+
+ pop_sibling:
+ next_sibling = sibling_stack.next;
+ if (next_sibling == sibling_stack_bottom) {
+ main_dentry = container_of(main_stack.next,
+ struct dentry,
+ tmp_list);
+ list_del(&main_dentry->tmp_list);
+
+
+ sibling_stack_bottom = (void*)main_dentry->parent;
+
+ if (main_dentry == root) {
+ main_dentry->parent = main_dentry;
+ ret = visitor(dentry, arg);
+ return ret;
+ } else {
+ main_dentry->parent = container_of(main_stack.next,
+ struct dentry,
+ tmp_list);
+ }
+
+ ret = visitor(main_dentry, arg);
+
+ if (ret != 0) {
+ list_del(&root->tmp_list);
+ list_for_each_entry(dentry, &main_stack, tmp_list) {
+ dentry->parent = container_of(dentry->tmp_list.next,
+ struct dentry,
+ tmp_list);
+ }
+ root->parent = root;
+ return ret;
+ }
+ goto pop_sibling;
+ } else {
+
+ list_del(next_sibling);
+ dentry = container_of(next_sibling, struct dentry, tmp_list);
+
+
+ list_add(&dentry->tmp_list, &main_stack);
+ dentry->parent = (void*)sibling_stack_bottom;
+ sibling_stack_bottom = sibling_stack.next;
+
+ main_dentry = dentry;
+ }
+ }
+#endif
}
/*
}
}
-static int compare_names(const char *name_1, size_t len_1,
- const char *name_2, size_t len_2)
+static int compare_names(const char *name_1, u16 len_1,
+ const char *name_2, u16 len_2)
{
- if (len_1 < len_2)
- return -1;
- else if (len_1 > len_2)
- return 1;
- else
- return memcmp(name_1, name_2, len_1);
+ int result = strncasecmp(name_1, name_2, min(len_1, len_2));
+ if (result) {
+ return result;
+ } else {
+ return (int)len_1 - (int)len_2;
+ }
}
static int dentry_compare_names(const struct dentry *d1, const struct dentry *d2)
const u8 *hash;
struct lookup_table_entry *lte;
const struct inode *inode = dentry->d_inode;
- time_t time;
- char *p;
+ char buf[50];
printf("[DENTRY]\n");
printf("Length = %"PRIu64"\n", dentry->length);
printf("Attributes = 0x%x\n", inode->attributes);
- for (unsigned i = 0; i < ARRAY_LEN(file_attr_flags); i++)
+ for (size_t i = 0; i < ARRAY_LEN(file_attr_flags); i++)
if (file_attr_flags[i].flag & inode->attributes)
printf(" FILE_ATTRIBUTE_%s is set\n",
file_attr_flags[i].name);
printf("Security ID = %d\n", inode->security_id);
printf("Subdir offset = %"PRIu64"\n", dentry->subdir_offset);
- /* Translate the timestamps into something readable */
- time = wim_timestamp_to_unix(inode->creation_time);
- p = asctime(gmtime(&time));
- *(strrchr(p, '\n')) = '\0';
- printf("Creation Time = %s UTC\n", p);
+ wim_timestamp_to_str(inode->creation_time, buf, sizeof(buf));
+ printf("Creation Time = %s\n", buf);
- time = wim_timestamp_to_unix(inode->last_access_time);
- p = asctime(gmtime(&time));
- *(strrchr(p, '\n')) = '\0';
- printf("Last Access Time = %s UTC\n", p);
+ wim_timestamp_to_str(inode->last_access_time, buf, sizeof(buf));
+ printf("Last Access Time = %s\n", buf);
- time = wim_timestamp_to_unix(inode->last_write_time);
- p = asctime(gmtime(&time));
- *(strrchr(p, '\n')) = '\0';
- printf("Last Write Time = %s UTC\n", p);
+ wim_timestamp_to_str(inode->last_write_time, buf, sizeof(buf));
+ printf("Last Write Time = %s\n", buf);
printf("Reparse Tag = 0x%"PRIx32"\n", inode->reparse_tag);
printf("Hard Link Group = 0x%"PRIx64"\n", inode->ino);
printf("Hard Link Group Size = %"PRIu32"\n", inode->link_count);
printf("Number of Alternate Data Streams = %hu\n", inode->num_ads);
- printf("Filename = \"");
- print_string(dentry->file_name, dentry->file_name_len);
- puts("\"");
- printf("Filename Length = %hu\n", dentry->file_name_len);
printf("Filename (UTF-8) = \"%s\"\n", dentry->file_name_utf8);
- printf("Filename (UTF-8) Length = %hu\n", dentry->file_name_utf8_len);
- printf("Short Name = \"");
+ /*printf("Filename (UTF-8) Length = %hu\n", dentry->file_name_utf8_len);*/
+ printf("Short Name (UTF-16LE) = \"");
print_string(dentry->short_name, dentry->short_name_len);
puts("\"");
- printf("Short Name Length = %hu\n", dentry->short_name_len);
+ /*printf("Short Name Length = %hu\n", dentry->short_name_len);*/
printf("Full Path (UTF-8) = \"%s\"\n", dentry->full_path_utf8);
lte = inode_stream_lte(dentry->d_inode, 0, lookup_table);
if (lte) {
inode->link_count = 1;
#ifdef WITH_FUSE
inode->next_stream_id = 1;
+ if (pthread_mutex_init(&inode->i_mutex, NULL) != 0) {
+ ERROR_WITH_ERRNO("Error initializing mutex");
+ FREE(inode);
+ return NULL;
+ }
#endif
INIT_LIST_HEAD(&inode->dentry_list);
}
#ifdef WITH_FUSE
wimlib_assert(inode->num_opened_fds == 0);
FREE(inode->fds);
+ pthread_mutex_destroy(&inode->i_mutex);
#endif
FREE(inode->extracted_file);
FREE(inode);
* */
static void put_inode(struct inode *inode)
{
- wimlib_assert(inode);
- wimlib_assert(inode->link_count);
+ wimlib_assert(inode->link_count != 0);
if (--inode->link_count == 0) {
#ifdef WITH_FUSE
if (inode->num_opened_fds == 0)
*/
void free_dentry(struct dentry *dentry)
{
- wimlib_assert(dentry != NULL);
FREE(dentry->file_name);
FREE(dentry->file_name_utf8);
FREE(dentry->short_name);
void put_dentry(struct dentry *dentry)
{
- wimlib_assert(dentry != NULL);
wimlib_assert(dentry->refcnt != 0);
-
if (--dentry->refcnt == 0)
free_dentry(dentry);
}
if (lookup_table) {
struct lookup_table_entry *lte;
struct inode *inode = dentry->d_inode;
- wimlib_assert(inode->link_count);
+ wimlib_assert(inode->link_count != 0);
for (i = 0; i <= inode->num_ads; i++) {
lte = inode_stream_lte(inode, i, lookup_table);
if (lte)
*/
void free_dentry_tree(struct dentry *root, struct lookup_table *lookup_table)
{
- if (!root || !root->parent)
- return;
- for_dentry_in_tree_depth(root, do_free_dentry, lookup_table);
+ if (root)
+ for_dentry_in_tree_depth(root, do_free_dentry, lookup_table);
}
int increment_dentry_refcnt(struct dentry *dentry, void *ignore)
"%u of dentry `%s'", i, first_dentry->full_path_utf8);
goto out;
}
- if (lte && (lte->real_refcnt += inode->link_count) > lte->refcnt)
+ if (lte)
+ lte->real_refcnt += inode->link_count;
+
+ /* The following is now done when required by
+ * wim_run_full_verifications(). */
+
+ #if 0
+ if (lte && !w->full_verification_in_progress &&
+ lte->real_refcnt > lte->refcnt)
{
#ifdef ENABLE_ERROR_MESSAGES
WARNING("The following lookup table entry "
print_lookup_table_entry(lte);
#endif
/* Guess what! install.wim for Windows 8
- * contains a stream with 2 dentries referencing
- * it, but the lookup table entry has reference
- * count of 1. So we will need to handle this
+ * contains many streams referenced by more
+ * dentries than the refcnt stated in the lookup
+ * table entry. So we will need to handle this
* case and not just make it be an error... I'm
* just setting the reference count to the
* number of references we found.
goto out;
#endif
}
+ #endif
}
}
* @offset: Offset of this directory entry in the metadata resource.
* @dentry: A `struct dentry' that will be filled in by this function.
*
- * Return 0 on success or nonzero on failure. On failure, @dentry have been
- * modified, bu it will be left with no pointers to any allocated buffers.
- * On success, the dentry->length field must be examined. If zero, this was a
- * special "end of directory" dentry and not a real dentry. If nonzero, this
- * was a real dentry.
+ * Return 0 on success or nonzero on failure. On failure, @dentry will have
+ * been modified, but it will not be left with pointers to any allocated
+ * buffers. On success, the dentry->length field must be examined. If zero,
+ * this was a special "end of directory" dentry and not a real dentry. If
+ * nonzero, this was a real dentry.
*/
int read_dentry(const u8 metadata_resource[], u64 metadata_resource_len,
u64 offset, struct dentry *dentry)
struct dentry *dentry)
{
u64 cur_offset = dentry->subdir_offset;
- struct dentry *prev_child = NULL;
- struct dentry *first_child = NULL;
struct dentry *child;
struct dentry cur_child;
int ret;
break;
}
memcpy(child, &cur_child, sizeof(struct dentry));
-
dentry_add_child(dentry, child);
-
inode_add_dentry(child, child->d_inode);
/* If there are children of this child, call this procedure
git://wimlib.net / wimlib / blobdiff