Linux操作系统中对于NTFS读取目录功能的实现

   1: /*

   2:  * We use the same basic approach as the old NTFS driver, i.e. we parse the

   3:  * index root entries and then the index allocation entries that are marked

   4:  * as in use in the index bitmap.

   5:  *

   6:  * While this will return the names in random order this doesn't matter for

   7:  * ->readdir but OTOH results in a faster ->readdir.

   8:  *

   9:  * VFS calls ->readdir without BKL but with i_mutex held. This protects the VFS

  10:  * parts (e.g. ->f_pos and ->i_size, and it also protects against directory

  11:  * modifications).

  12:  *

  13:  * Locking:  - Caller must hold i_mutex on the directory.

  14:  *         - Each page cache page in the index allocation mapping must be

  15:  *           locked whilst being accessed otherwise we may find a corrupt

  16:  *           page due to it being under ->writepage at the moment which

  17:  *           applies the mst protection fixups before writing out and then

  18:  *           removes them again after the write is complete after which it 

  19:  *           unlocks the page.

  20:  */

  21: static int ntfs_readdir(struct file *filp, void *dirent, filldir_t filldir)

  22: {

We use the same basic approach as the old NTFS driver, i.e. we parse the
index root entries and then the index allocation entries that are marked
as in use in the index bitmap.

根据这名注释，可以推测index bitmap是用来标注多个index allocation的使用情况的。

那么这些index allocation都存在哪里呢，因为通常一个File Record中只有一个index allocation属性。

   1: /*

   2:      * Copy the index root attribute value to a buffer so that we can put

   3:      * the search context and unmap the mft record before calling the

   4:      * filldir() callback.  We need to do this because of NFSd which calls

   5:      * ->lookup() from its filldir callback() and this causes NTFS to

   6:      * deadlock as ntfs_lookup() maps the mft record of the directory and

   7:      * we have got it mapped here already.  The only solution is for us to

   8:      * unmap the mft record here so that a call to ntfs_lookup() is able to

   9:      * map the mft record without deadlocking.

  10:      */

  11:     rc = le32_to_cpu(ctx->attr->data.resident.value_length);

  12:     ir = kmalloc(rc, GFP_NOFS);

  13:     if (unlikely(!ir)) {

  14:         err = -ENOMEM;

  15:         goto err_out;

  16:     }

  17:     /* Copy the index root value (it has been verified in read_inode). */

  18:     memcpy(ir, (u8*)ctx->attr +

  19:             le16_to_cpu(ctx->attr->data.resident.value_offset), rc);

  20:     ntfs_attr_put_search_ctx(ctx);

  21:     unmap_mft_record(ndir);

  22:     ctx = NULL;

  23:     m = NULL;

  24:     index_end = (u8*)&ir->index + le32_to_cpu(ir->index.index_length);

  25:     /* The first index entry. */

  26:     ie = (INDEX_ENTRY*)((u8*)&ir->index +

  27:             le32_to_cpu(ir->index.entries_offset));

  28:     /*

  29:      * Loop until we exceed valid memory (corruption case) or until we

  30:      * reach the last entry or until filldir tells us it has had enough

  31:      * or signals an error (both covered by the rc test).

  32:      */

  33:     for (;; ie = (INDEX_ENTRY*)((u8*)ie + le16_to_cpu(ie->length))) {

  34:         ntfs_debug("In index root, offset 0x%zx.", (u8*)ie - (u8*)ir);

  35:         /* Bounds checks. */

  36:         if (unlikely((u8*)ie < (u8*)ir || (u8*)ie +

  37:                 sizeof(INDEX_ENTRY_HEADER) > index_end ||

  38:                 (u8*)ie + le16_to_cpu(ie->key_length) >

  39:                 index_end))

  40:             goto err_out;

  41:         /* The last entry cannot contain a name. */

  42:         if (ie->flags & INDEX_ENTRY_END)

  43:             break;

  44:         /* Skip index root entry if continuing previous readdir. */

  45:         if (ir_pos > (u8*)ie - (u8*)ir)

  46:             continue;

  47:         /* Advance the position even if going to skip the entry. */

  48:         fpos = (u8*)ie - (u8*)ir;

  49:         /* Submit the name to the filldir callback. */

  50:         rc = ntfs_filldir(vol, fpos, ndir, NULL, ie, name, dirent,

  51:                 filldir);

  52:         if (rc) {

  53:             kfree(ir);

  54:             goto abort;

  55:         }

  56:     }

/* Copy the index root value (it has been verified in read_inode). */
    memcpy(ir, (u8*)ctx->attr +
            le16_to_cpu(ctx->attr->data.resident.value_offset), rc);

这段代码是从index root属性中提取文件名信息，如果遇到index entry的flags被设置了INDEX_ENTRY_END标志，就跳出循环。

index root是存放于resident，即File Record本地的index entry集合。

/* If there is no index allocation attribute we are finished. */
if (!NInoIndexAllocPresent(ndir))
    goto EOD;

如果没有Index Allocation属性，我们就已经遍历完了所有的目录项，结束。

读取到Bitmap的内容

   1: bmp = (u8*)page_address(bmp_page);

   2:     /* Find next index block in use. */

   3:     while (!(bmp[cur_bmp_pos >> 3] & (1 << (cur_bmp_pos & 7)))) {

   4: find_next_index_buffer:

   5:         cur_bmp_pos++;

   6:         /*

   7:          * If we have reached the end of the bitmap page, get the next

   8:          * page, and put away the old one.

   9:          */

  10:         if (unlikely((cur_bmp_pos >> 3) >= PAGE_CACHE_SIZE)) {

  11:             ntfs_unmap_page(bmp_page);

  12:             bmp_pos += PAGE_CACHE_SIZE * 8;

  13:             cur_bmp_pos = 0;

  14:             goto get_next_bmp_page;

  15:         }

  16:         /* If we have reached the end of the bitmap, we are done. */

  17:         if (unlikely(((bmp_pos + cur_bmp_pos) >> 3) >= i_size))

  18:             goto unm_EOD;

  19:         ia_pos = (bmp_pos + cur_bmp_pos) <<

  20:                 ndir->itype.index.block_size_bits;

  21:     }

Bitmap里面的每一位，代表着index allocation中的一个cluster是否有效。

如果Bitmap中某一比特位为0，则其对应的index allocation中的数据就要越过相应的cluster去读下一个cluster的内容。