Changeset d2240176af6ac239216b160611ed74d481095a4b for core

Timestamp:

09/20/11 02:45:19 (8 months ago)

Author:

Paulo Alcantara <pcacjr@…>

Children:

120523b681d08245d68d9db08998fad4018713db

Parents:

7e6065d5d1d8346683abf2f894d59c703fa60d87

git-committer:

Paulo Alcantara <pcacjr@gmail.com> / 2011-09-20T02:45:19Z+0000

Message:

ntfs: keep a state structure for ntfs_readdir() callers

Latetly, we kept a state information within the inode structure, that
was actually a mistake. Now, a ntfs_readdir_state structure is allocated
to keep a state that'll help on listing directory entries from sucessive
ntfs_readdir() calls.

Signed-off-by: Paulo Alcantara <pcacjr@…>

Location:

core/fs/ntfs

Files:

• ntfs.c (modified) (9 diffs)
• ntfs.h (modified) (2 diffs)

core/fs/ntfs/ntfs.c

@@ -35 +35 @@
 #include "ntfs.h"
 #include "runlist.h"
+
+static struct ntfs_readdir_state *readdir_state;
 
 /*** Function declarations */
@@ -475 +477 @@
         }
 
-        NTFS_PVT(inode)->in_idx_root = true;
+        /* check if we have a previous allocated state structure */
+        if (readdir_state) {
+            free(readdir_state);
+            readdir_state = NULL;
+        }
+
+        /* allocate our state structure */
+        readdir_state = malloc(sizeof *readdir_state);
+        if (!readdir_state)
+            malloc_error("ntfs_readdir_state structure");
+
+        readdir_state->mft_no = mft_no;
+        /* obviously, the ntfs_readdir() caller will start from INDEX root */
+        readdir_state->in_idx_root = true;
     } else if (d_type == DT_REG) {        /* file stuff */
         dprintf("Got a file.\n");
@@ -887 +902 @@
         goto index_err;
 
-    if (!file->offset && NTFS_PVT(inode)->in_idx_root) {
+    if (!file->offset && readdir_state->in_idx_root) {
         file->offset = (uint32_t)((uint8_t *)&ir->index +
                                         ir->index.entries_offset);
@@ -893 +908 @@
 
 idx_root_next_entry:
-    if (NTFS_PVT(inode)->in_idx_root) {
+    if (readdir_state->in_idx_root) {
         ie = (struct ntfs_idx_entry *)(uint8_t *)file->offset;
         if (ie->flags & INDEX_ENTRY_END) {
             file->offset = 0;
-            NTFS_PVT(inode)->in_idx_root = false;
-            NTFS_PVT(inode)->idx_blks_count = 1;
-            NTFS_PVT(inode)->entries_count = 0;
-            NTFS_PVT(inode)->last_vcn = 0;
+            readdir_state->in_idx_root = false;
+            readdir_state->idx_blks_count = 1;
+            readdir_state->entries_count = 0;
+            readdir_state->last_vcn = 0;
             goto descend_into_child_node;
         }
@@ -929 +944 @@
 next_run:
     stream = mapping_chunk_init(attr, &chunk, &offset);
-    count = NTFS_PVT(inode)->idx_blks_count;
+    count = readdir_state->idx_blks_count;
     while (count--) {
         err = parse_data_run(stream, &offset, attr_len, &chunk);
@@ -944 +959 @@
 
     if (chunk.flags & MAP_UNALLOCATED) {
-       NTFS_PVT(inode)->idx_blks_count++;
+       readdir_state->idx_blks_count++;
        goto next_run;
     }
 
 next_vcn:
-    vcn = NTFS_PVT(inode)->last_vcn;
+    vcn = readdir_state->last_vcn;
     if (vcn >= chunk.len) {
-        NTFS_PVT(inode)->last_vcn = 0;
-        NTFS_PVT(inode)->idx_blks_count++;
+        readdir_state->last_vcn = 0;
+        readdir_state->idx_blks_count++;
         goto next_run;
     }
@@ -979 +994 @@
     ie = (struct ntfs_idx_entry *)((uint8_t *)&iblk->index +
                         iblk->index.entries_offset);
-    count = NTFS_PVT(inode)->entries_count;
+    count = readdir_state->entries_count;
     for ( ; count--; ie = (struct ntfs_idx_entry *)((uint8_t *)ie + ie->len)) {
         /* bounds checks */
@@ -992 +1007 @@
         if (ie->flags & INDEX_ENTRY_END) {
             /* go to the next VCN */
-            NTFS_PVT(inode)->last_vcn += (blk_size / (1 <<
+            readdir_state->last_vcn += (blk_size / (1 <<
                                 NTFS_SB(fs)->clust_byte_shift));
-            NTFS_PVT(inode)->entries_count = 0;
+            readdir_state->entries_count = 0;
             goto next_vcn;
         }
     }
 
-    NTFS_PVT(inode)->entries_count++;
+    readdir_state->entries_count++;
     len = ntfs_cvt_filename(filename, ie);
     if (!is_filename_printable(filename))
@@ -1007 +1022 @@
 
 out:
-    NTFS_PVT(inode)->in_idx_root = true;
+    readdir_state->in_idx_root = true;
 
     free(mrec);

core/fs/ntfs/ntfs.h

@@ -84 +84 @@
     uint32_t type;              /* Attribute type of this inode */
     uint8_t non_resident;
-    bool in_idx_root;
-    uint32_t idx_blks_count;
-    uint32_t entries_count;
-    int64_t last_vcn;
     union {                 /* Non-resident $DATA attribute */
         struct {            /* Used only if non_resident flags isn't set */
@@ -100 +96 @@
     sector_t offset;        /* Current sector offset */
     sector_t here;          /* Sector corresponding to offset */
+};
+
+/* This is structure is used to keep a state for ntfs_readdir() callers.
+ * As NTFS stores directory entries in a complex way, this is structure
+ * ends up saving a state required to find out where we must start from
+ * for the next ntfs_readdir() call.
+ */
+struct ntfs_readdir_state {
+    unsigned long mft_no;       /* MFT record number */
+    bool in_idx_root;           /* It's true if we're still in the INDEX root */
+    uint32_t idx_blks_count;    /* Number of read INDX blocks */
+    uint32_t entries_count;     /* Number of read INDEX entries */
+    int64_t last_vcn;           /* Last VCN of the INDX block */
 };