linux下读取ntfs数据,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.html

根据这名注释，能够推测index bitmap是用来标注多个index allocation的使用状况的。node

那么这些index allocation都存在哪里呢，由于一般一个File Record中只有一个index allocation属性。app

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);dom

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

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

/* If there is no index allocation attribute we are finished. */

if (!NInoIndexAllocPresent(ndir))

goto EOD;

post

若是没有Index Allocation属性，咱们就已经遍历完了全部的目录项，结束。ui

读取到Bitmap的内容this

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是否有效。spa

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