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: {  

   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:     }  

   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:     }