Loading...
Note: File does not exist in v6.13.7.
1// SPDX-License-Identifier: GPL-2.0-or-later
2/**
3 * dir.c - NTFS kernel directory operations. Part of the Linux-NTFS project.
4 *
5 * Copyright (c) 2001-2007 Anton Altaparmakov
6 * Copyright (c) 2002 Richard Russon
7 */
8
9#include <linux/buffer_head.h>
10#include <linux/slab.h>
11#include <linux/blkdev.h>
12
13#include "dir.h"
14#include "aops.h"
15#include "attrib.h"
16#include "mft.h"
17#include "debug.h"
18#include "ntfs.h"
19
20/**
21 * The little endian Unicode string $I30 as a global constant.
22 */
23ntfschar I30[5] = { cpu_to_le16('$'), cpu_to_le16('I'),
24 cpu_to_le16('3'), cpu_to_le16('0'), 0 };
25
26/**
27 * ntfs_lookup_inode_by_name - find an inode in a directory given its name
28 * @dir_ni: ntfs inode of the directory in which to search for the name
29 * @uname: Unicode name for which to search in the directory
30 * @uname_len: length of the name @uname in Unicode characters
31 * @res: return the found file name if necessary (see below)
32 *
33 * Look for an inode with name @uname in the directory with inode @dir_ni.
34 * ntfs_lookup_inode_by_name() walks the contents of the directory looking for
35 * the Unicode name. If the name is found in the directory, the corresponding
36 * inode number (>= 0) is returned as a mft reference in cpu format, i.e. it
37 * is a 64-bit number containing the sequence number.
38 *
39 * On error, a negative value is returned corresponding to the error code. In
40 * particular if the inode is not found -ENOENT is returned. Note that you
41 * can't just check the return value for being negative, you have to check the
42 * inode number for being negative which you can extract using MREC(return
43 * value).
44 *
45 * Note, @uname_len does not include the (optional) terminating NULL character.
46 *
47 * Note, we look for a case sensitive match first but we also look for a case
48 * insensitive match at the same time. If we find a case insensitive match, we
49 * save that for the case that we don't find an exact match, where we return
50 * the case insensitive match and setup @res (which we allocate!) with the mft
51 * reference, the file name type, length and with a copy of the little endian
52 * Unicode file name itself. If we match a file name which is in the DOS name
53 * space, we only return the mft reference and file name type in @res.
54 * ntfs_lookup() then uses this to find the long file name in the inode itself.
55 * This is to avoid polluting the dcache with short file names. We want them to
56 * work but we don't care for how quickly one can access them. This also fixes
57 * the dcache aliasing issues.
58 *
59 * Locking: - Caller must hold i_mutex on the directory.
60 * - Each page cache page in the index allocation mapping must be
61 * locked whilst being accessed otherwise we may find a corrupt
62 * page due to it being under ->writepage at the moment which
63 * applies the mst protection fixups before writing out and then
64 * removes them again after the write is complete after which it
65 * unlocks the page.
66 */
67MFT_REF ntfs_lookup_inode_by_name(ntfs_inode *dir_ni, const ntfschar *uname,
68 const int uname_len, ntfs_name **res)
69{
70 ntfs_volume *vol = dir_ni->vol;
71 struct super_block *sb = vol->sb;
72 MFT_RECORD *m;
73 INDEX_ROOT *ir;
74 INDEX_ENTRY *ie;
75 INDEX_ALLOCATION *ia;
76 u8 *index_end;
77 u64 mref;
78 ntfs_attr_search_ctx *ctx;
79 int err, rc;
80 VCN vcn, old_vcn;
81 struct address_space *ia_mapping;
82 struct page *page;
83 u8 *kaddr;
84 ntfs_name *name = NULL;
85
86 BUG_ON(!S_ISDIR(VFS_I(dir_ni)->i_mode));
87 BUG_ON(NInoAttr(dir_ni));
88 /* Get hold of the mft record for the directory. */
89 m = map_mft_record(dir_ni);
90 if (IS_ERR(m)) {
91 ntfs_error(sb, "map_mft_record() failed with error code %ld.",
92 -PTR_ERR(m));
93 return ERR_MREF(PTR_ERR(m));
94 }
95 ctx = ntfs_attr_get_search_ctx(dir_ni, m);
96 if (unlikely(!ctx)) {
97 err = -ENOMEM;
98 goto err_out;
99 }
100 /* Find the index root attribute in the mft record. */
101 err = ntfs_attr_lookup(AT_INDEX_ROOT, I30, 4, CASE_SENSITIVE, 0, NULL,
102 0, ctx);
103 if (unlikely(err)) {
104 if (err == -ENOENT) {
105 ntfs_error(sb, "Index root attribute missing in "
106 "directory inode 0x%lx.",
107 dir_ni->mft_no);
108 err = -EIO;
109 }
110 goto err_out;
111 }
112 /* Get to the index root value (it's been verified in read_inode). */
113 ir = (INDEX_ROOT*)((u8*)ctx->attr +
114 le16_to_cpu(ctx->attr->data.resident.value_offset));
115 index_end = (u8*)&ir->index + le32_to_cpu(ir->index.index_length);
116 /* The first index entry. */
117 ie = (INDEX_ENTRY*)((u8*)&ir->index +
118 le32_to_cpu(ir->index.entries_offset));
119 /*
120 * Loop until we exceed valid memory (corruption case) or until we
121 * reach the last entry.
122 */
123 for (;; ie = (INDEX_ENTRY*)((u8*)ie + le16_to_cpu(ie->length))) {
124 /* Bounds checks. */
125 if ((u8*)ie < (u8*)ctx->mrec || (u8*)ie +
126 sizeof(INDEX_ENTRY_HEADER) > index_end ||
127 (u8*)ie + le16_to_cpu(ie->key_length) >
128 index_end)
129 goto dir_err_out;
130 /*
131 * The last entry cannot contain a name. It can however contain
132 * a pointer to a child node in the B+tree so we just break out.
133 */
134 if (ie->flags & INDEX_ENTRY_END)
135 break;
136 /*
137 * We perform a case sensitive comparison and if that matches
138 * we are done and return the mft reference of the inode (i.e.
139 * the inode number together with the sequence number for
140 * consistency checking). We convert it to cpu format before
141 * returning.
142 */
143 if (ntfs_are_names_equal(uname, uname_len,
144 (ntfschar*)&ie->key.file_name.file_name,
145 ie->key.file_name.file_name_length,
146 CASE_SENSITIVE, vol->upcase, vol->upcase_len)) {
147found_it:
148 /*
149 * We have a perfect match, so we don't need to care
150 * about having matched imperfectly before, so we can
151 * free name and set *res to NULL.
152 * However, if the perfect match is a short file name,
153 * we need to signal this through *res, so that
154 * ntfs_lookup() can fix dcache aliasing issues.
155 * As an optimization we just reuse an existing
156 * allocation of *res.
157 */
158 if (ie->key.file_name.file_name_type == FILE_NAME_DOS) {
159 if (!name) {
160 name = kmalloc(sizeof(ntfs_name),
161 GFP_NOFS);
162 if (!name) {
163 err = -ENOMEM;
164 goto err_out;
165 }
166 }
167 name->mref = le64_to_cpu(
168 ie->data.dir.indexed_file);
169 name->type = FILE_NAME_DOS;
170 name->len = 0;
171 *res = name;
172 } else {
173 kfree(name);
174 *res = NULL;
175 }
176 mref = le64_to_cpu(ie->data.dir.indexed_file);
177 ntfs_attr_put_search_ctx(ctx);
178 unmap_mft_record(dir_ni);
179 return mref;
180 }
181 /*
182 * For a case insensitive mount, we also perform a case
183 * insensitive comparison (provided the file name is not in the
184 * POSIX namespace). If the comparison matches, and the name is
185 * in the WIN32 namespace, we cache the filename in *res so
186 * that the caller, ntfs_lookup(), can work on it. If the
187 * comparison matches, and the name is in the DOS namespace, we
188 * only cache the mft reference and the file name type (we set
189 * the name length to zero for simplicity).
190 */
191 if (!NVolCaseSensitive(vol) &&
192 ie->key.file_name.file_name_type &&
193 ntfs_are_names_equal(uname, uname_len,
194 (ntfschar*)&ie->key.file_name.file_name,
195 ie->key.file_name.file_name_length,
196 IGNORE_CASE, vol->upcase, vol->upcase_len)) {
197 int name_size = sizeof(ntfs_name);
198 u8 type = ie->key.file_name.file_name_type;
199 u8 len = ie->key.file_name.file_name_length;
200
201 /* Only one case insensitive matching name allowed. */
202 if (name) {
203 ntfs_error(sb, "Found already allocated name "
204 "in phase 1. Please run chkdsk "
205 "and if that doesn't find any "
206 "errors please report you saw "
207 "this message to "
208 "linux-ntfs-dev@lists."
209 "sourceforge.net.");
210 goto dir_err_out;
211 }
212
213 if (type != FILE_NAME_DOS)
214 name_size += len * sizeof(ntfschar);
215 name = kmalloc(name_size, GFP_NOFS);
216 if (!name) {
217 err = -ENOMEM;
218 goto err_out;
219 }
220 name->mref = le64_to_cpu(ie->data.dir.indexed_file);
221 name->type = type;
222 if (type != FILE_NAME_DOS) {
223 name->len = len;
224 memcpy(name->name, ie->key.file_name.file_name,
225 len * sizeof(ntfschar));
226 } else
227 name->len = 0;
228 *res = name;
229 }
230 /*
231 * Not a perfect match, need to do full blown collation so we
232 * know which way in the B+tree we have to go.
233 */
234 rc = ntfs_collate_names(uname, uname_len,
235 (ntfschar*)&ie->key.file_name.file_name,
236 ie->key.file_name.file_name_length, 1,
237 IGNORE_CASE, vol->upcase, vol->upcase_len);
238 /*
239 * If uname collates before the name of the current entry, there
240 * is definitely no such name in this index but we might need to
241 * descend into the B+tree so we just break out of the loop.
242 */
243 if (rc == -1)
244 break;
245 /* The names are not equal, continue the search. */
246 if (rc)
247 continue;
248 /*
249 * Names match with case insensitive comparison, now try the
250 * case sensitive comparison, which is required for proper
251 * collation.
252 */
253 rc = ntfs_collate_names(uname, uname_len,
254 (ntfschar*)&ie->key.file_name.file_name,
255 ie->key.file_name.file_name_length, 1,
256 CASE_SENSITIVE, vol->upcase, vol->upcase_len);
257 if (rc == -1)
258 break;
259 if (rc)
260 continue;
261 /*
262 * Perfect match, this will never happen as the
263 * ntfs_are_names_equal() call will have gotten a match but we
264 * still treat it correctly.
265 */
266 goto found_it;
267 }
268 /*
269 * We have finished with this index without success. Check for the
270 * presence of a child node and if not present return -ENOENT, unless
271 * we have got a matching name cached in name in which case return the
272 * mft reference associated with it.
273 */
274 if (!(ie->flags & INDEX_ENTRY_NODE)) {
275 if (name) {
276 ntfs_attr_put_search_ctx(ctx);
277 unmap_mft_record(dir_ni);
278 return name->mref;
279 }
280 ntfs_debug("Entry not found.");
281 err = -ENOENT;
282 goto err_out;
283 } /* Child node present, descend into it. */
284 /* Consistency check: Verify that an index allocation exists. */
285 if (!NInoIndexAllocPresent(dir_ni)) {
286 ntfs_error(sb, "No index allocation attribute but index entry "
287 "requires one. Directory inode 0x%lx is "
288 "corrupt or driver bug.", dir_ni->mft_no);
289 goto err_out;
290 }
291 /* Get the starting vcn of the index_block holding the child node. */
292 vcn = sle64_to_cpup((sle64*)((u8*)ie + le16_to_cpu(ie->length) - 8));
293 ia_mapping = VFS_I(dir_ni)->i_mapping;
294 /*
295 * We are done with the index root and the mft record. Release them,
296 * otherwise we deadlock with ntfs_map_page().
297 */
298 ntfs_attr_put_search_ctx(ctx);
299 unmap_mft_record(dir_ni);
300 m = NULL;
301 ctx = NULL;
302descend_into_child_node:
303 /*
304 * Convert vcn to index into the index allocation attribute in units
305 * of PAGE_SIZE and map the page cache page, reading it from
306 * disk if necessary.
307 */
308 page = ntfs_map_page(ia_mapping, vcn <<
309 dir_ni->itype.index.vcn_size_bits >> PAGE_SHIFT);
310 if (IS_ERR(page)) {
311 ntfs_error(sb, "Failed to map directory index page, error %ld.",
312 -PTR_ERR(page));
313 err = PTR_ERR(page);
314 goto err_out;
315 }
316 lock_page(page);
317 kaddr = (u8*)page_address(page);
318fast_descend_into_child_node:
319 /* Get to the index allocation block. */
320 ia = (INDEX_ALLOCATION*)(kaddr + ((vcn <<
321 dir_ni->itype.index.vcn_size_bits) & ~PAGE_MASK));
322 /* Bounds checks. */
323 if ((u8*)ia < kaddr || (u8*)ia > kaddr + PAGE_SIZE) {
324 ntfs_error(sb, "Out of bounds check failed. Corrupt directory "
325 "inode 0x%lx or driver bug.", dir_ni->mft_no);
326 goto unm_err_out;
327 }
328 /* Catch multi sector transfer fixup errors. */
329 if (unlikely(!ntfs_is_indx_record(ia->magic))) {
330 ntfs_error(sb, "Directory index record with vcn 0x%llx is "
331 "corrupt. Corrupt inode 0x%lx. Run chkdsk.",
332 (unsigned long long)vcn, dir_ni->mft_no);
333 goto unm_err_out;
334 }
335 if (sle64_to_cpu(ia->index_block_vcn) != vcn) {
336 ntfs_error(sb, "Actual VCN (0x%llx) of index buffer is "
337 "different from expected VCN (0x%llx). "
338 "Directory inode 0x%lx is corrupt or driver "
339 "bug.", (unsigned long long)
340 sle64_to_cpu(ia->index_block_vcn),
341 (unsigned long long)vcn, dir_ni->mft_no);
342 goto unm_err_out;
343 }
344 if (le32_to_cpu(ia->index.allocated_size) + 0x18 !=
345 dir_ni->itype.index.block_size) {
346 ntfs_error(sb, "Index buffer (VCN 0x%llx) of directory inode "
347 "0x%lx has a size (%u) differing from the "
348 "directory specified size (%u). Directory "
349 "inode is corrupt or driver bug.",
350 (unsigned long long)vcn, dir_ni->mft_no,
351 le32_to_cpu(ia->index.allocated_size) + 0x18,
352 dir_ni->itype.index.block_size);
353 goto unm_err_out;
354 }
355 index_end = (u8*)ia + dir_ni->itype.index.block_size;
356 if (index_end > kaddr + PAGE_SIZE) {
357 ntfs_error(sb, "Index buffer (VCN 0x%llx) of directory inode "
358 "0x%lx crosses page boundary. Impossible! "
359 "Cannot access! This is probably a bug in the "
360 "driver.", (unsigned long long)vcn,
361 dir_ni->mft_no);
362 goto unm_err_out;
363 }
364 index_end = (u8*)&ia->index + le32_to_cpu(ia->index.index_length);
365 if (index_end > (u8*)ia + dir_ni->itype.index.block_size) {
366 ntfs_error(sb, "Size of index buffer (VCN 0x%llx) of directory "
367 "inode 0x%lx exceeds maximum size.",
368 (unsigned long long)vcn, dir_ni->mft_no);
369 goto unm_err_out;
370 }
371 /* The first index entry. */
372 ie = (INDEX_ENTRY*)((u8*)&ia->index +
373 le32_to_cpu(ia->index.entries_offset));
374 /*
375 * Iterate similar to above big loop but applied to index buffer, thus
376 * loop until we exceed valid memory (corruption case) or until we
377 * reach the last entry.
378 */
379 for (;; ie = (INDEX_ENTRY*)((u8*)ie + le16_to_cpu(ie->length))) {
380 /* Bounds check. */
381 if ((u8*)ie < (u8*)ia || (u8*)ie +
382 sizeof(INDEX_ENTRY_HEADER) > index_end ||
383 (u8*)ie + le16_to_cpu(ie->key_length) >
384 index_end) {
385 ntfs_error(sb, "Index entry out of bounds in "
386 "directory inode 0x%lx.",
387 dir_ni->mft_no);
388 goto unm_err_out;
389 }
390 /*
391 * The last entry cannot contain a name. It can however contain
392 * a pointer to a child node in the B+tree so we just break out.
393 */
394 if (ie->flags & INDEX_ENTRY_END)
395 break;
396 /*
397 * We perform a case sensitive comparison and if that matches
398 * we are done and return the mft reference of the inode (i.e.
399 * the inode number together with the sequence number for
400 * consistency checking). We convert it to cpu format before
401 * returning.
402 */
403 if (ntfs_are_names_equal(uname, uname_len,
404 (ntfschar*)&ie->key.file_name.file_name,
405 ie->key.file_name.file_name_length,
406 CASE_SENSITIVE, vol->upcase, vol->upcase_len)) {
407found_it2:
408 /*
409 * We have a perfect match, so we don't need to care
410 * about having matched imperfectly before, so we can
411 * free name and set *res to NULL.
412 * However, if the perfect match is a short file name,
413 * we need to signal this through *res, so that
414 * ntfs_lookup() can fix dcache aliasing issues.
415 * As an optimization we just reuse an existing
416 * allocation of *res.
417 */
418 if (ie->key.file_name.file_name_type == FILE_NAME_DOS) {
419 if (!name) {
420 name = kmalloc(sizeof(ntfs_name),
421 GFP_NOFS);
422 if (!name) {
423 err = -ENOMEM;
424 goto unm_err_out;
425 }
426 }
427 name->mref = le64_to_cpu(
428 ie->data.dir.indexed_file);
429 name->type = FILE_NAME_DOS;
430 name->len = 0;
431 *res = name;
432 } else {
433 kfree(name);
434 *res = NULL;
435 }
436 mref = le64_to_cpu(ie->data.dir.indexed_file);
437 unlock_page(page);
438 ntfs_unmap_page(page);
439 return mref;
440 }
441 /*
442 * For a case insensitive mount, we also perform a case
443 * insensitive comparison (provided the file name is not in the
444 * POSIX namespace). If the comparison matches, and the name is
445 * in the WIN32 namespace, we cache the filename in *res so
446 * that the caller, ntfs_lookup(), can work on it. If the
447 * comparison matches, and the name is in the DOS namespace, we
448 * only cache the mft reference and the file name type (we set
449 * the name length to zero for simplicity).
450 */
451 if (!NVolCaseSensitive(vol) &&
452 ie->key.file_name.file_name_type &&
453 ntfs_are_names_equal(uname, uname_len,
454 (ntfschar*)&ie->key.file_name.file_name,
455 ie->key.file_name.file_name_length,
456 IGNORE_CASE, vol->upcase, vol->upcase_len)) {
457 int name_size = sizeof(ntfs_name);
458 u8 type = ie->key.file_name.file_name_type;
459 u8 len = ie->key.file_name.file_name_length;
460
461 /* Only one case insensitive matching name allowed. */
462 if (name) {
463 ntfs_error(sb, "Found already allocated name "
464 "in phase 2. Please run chkdsk "
465 "and if that doesn't find any "
466 "errors please report you saw "
467 "this message to "
468 "linux-ntfs-dev@lists."
469 "sourceforge.net.");
470 unlock_page(page);
471 ntfs_unmap_page(page);
472 goto dir_err_out;
473 }
474
475 if (type != FILE_NAME_DOS)
476 name_size += len * sizeof(ntfschar);
477 name = kmalloc(name_size, GFP_NOFS);
478 if (!name) {
479 err = -ENOMEM;
480 goto unm_err_out;
481 }
482 name->mref = le64_to_cpu(ie->data.dir.indexed_file);
483 name->type = type;
484 if (type != FILE_NAME_DOS) {
485 name->len = len;
486 memcpy(name->name, ie->key.file_name.file_name,
487 len * sizeof(ntfschar));
488 } else
489 name->len = 0;
490 *res = name;
491 }
492 /*
493 * Not a perfect match, need to do full blown collation so we
494 * know which way in the B+tree we have to go.
495 */
496 rc = ntfs_collate_names(uname, uname_len,
497 (ntfschar*)&ie->key.file_name.file_name,
498 ie->key.file_name.file_name_length, 1,
499 IGNORE_CASE, vol->upcase, vol->upcase_len);
500 /*
501 * If uname collates before the name of the current entry, there
502 * is definitely no such name in this index but we might need to
503 * descend into the B+tree so we just break out of the loop.
504 */
505 if (rc == -1)
506 break;
507 /* The names are not equal, continue the search. */
508 if (rc)
509 continue;
510 /*
511 * Names match with case insensitive comparison, now try the
512 * case sensitive comparison, which is required for proper
513 * collation.
514 */
515 rc = ntfs_collate_names(uname, uname_len,
516 (ntfschar*)&ie->key.file_name.file_name,
517 ie->key.file_name.file_name_length, 1,
518 CASE_SENSITIVE, vol->upcase, vol->upcase_len);
519 if (rc == -1)
520 break;
521 if (rc)
522 continue;
523 /*
524 * Perfect match, this will never happen as the
525 * ntfs_are_names_equal() call will have gotten a match but we
526 * still treat it correctly.
527 */
528 goto found_it2;
529 }
530 /*
531 * We have finished with this index buffer without success. Check for
532 * the presence of a child node.
533 */
534 if (ie->flags & INDEX_ENTRY_NODE) {
535 if ((ia->index.flags & NODE_MASK) == LEAF_NODE) {
536 ntfs_error(sb, "Index entry with child node found in "
537 "a leaf node in directory inode 0x%lx.",
538 dir_ni->mft_no);
539 goto unm_err_out;
540 }
541 /* Child node present, descend into it. */
542 old_vcn = vcn;
543 vcn = sle64_to_cpup((sle64*)((u8*)ie +
544 le16_to_cpu(ie->length) - 8));
545 if (vcn >= 0) {
546 /* If vcn is in the same page cache page as old_vcn we
547 * recycle the mapped page. */
548 if (old_vcn << vol->cluster_size_bits >>
549 PAGE_SHIFT == vcn <<
550 vol->cluster_size_bits >>
551 PAGE_SHIFT)
552 goto fast_descend_into_child_node;
553 unlock_page(page);
554 ntfs_unmap_page(page);
555 goto descend_into_child_node;
556 }
557 ntfs_error(sb, "Negative child node vcn in directory inode "
558 "0x%lx.", dir_ni->mft_no);
559 goto unm_err_out;
560 }
561 /*
562 * No child node present, return -ENOENT, unless we have got a matching
563 * name cached in name in which case return the mft reference
564 * associated with it.
565 */
566 if (name) {
567 unlock_page(page);
568 ntfs_unmap_page(page);
569 return name->mref;
570 }
571 ntfs_debug("Entry not found.");
572 err = -ENOENT;
573unm_err_out:
574 unlock_page(page);
575 ntfs_unmap_page(page);
576err_out:
577 if (!err)
578 err = -EIO;
579 if (ctx)
580 ntfs_attr_put_search_ctx(ctx);
581 if (m)
582 unmap_mft_record(dir_ni);
583 if (name) {
584 kfree(name);
585 *res = NULL;
586 }
587 return ERR_MREF(err);
588dir_err_out:
589 ntfs_error(sb, "Corrupt directory. Aborting lookup.");
590 goto err_out;
591}
592
593#if 0
594
595// TODO: (AIA)
596// The algorithm embedded in this code will be required for the time when we
597// want to support adding of entries to directories, where we require correct
598// collation of file names in order not to cause corruption of the filesystem.
599
600/**
601 * ntfs_lookup_inode_by_name - find an inode in a directory given its name
602 * @dir_ni: ntfs inode of the directory in which to search for the name
603 * @uname: Unicode name for which to search in the directory
604 * @uname_len: length of the name @uname in Unicode characters
605 *
606 * Look for an inode with name @uname in the directory with inode @dir_ni.
607 * ntfs_lookup_inode_by_name() walks the contents of the directory looking for
608 * the Unicode name. If the name is found in the directory, the corresponding
609 * inode number (>= 0) is returned as a mft reference in cpu format, i.e. it
610 * is a 64-bit number containing the sequence number.
611 *
612 * On error, a negative value is returned corresponding to the error code. In
613 * particular if the inode is not found -ENOENT is returned. Note that you
614 * can't just check the return value for being negative, you have to check the
615 * inode number for being negative which you can extract using MREC(return
616 * value).
617 *
618 * Note, @uname_len does not include the (optional) terminating NULL character.
619 */
620u64 ntfs_lookup_inode_by_name(ntfs_inode *dir_ni, const ntfschar *uname,
621 const int uname_len)
622{
623 ntfs_volume *vol = dir_ni->vol;
624 struct super_block *sb = vol->sb;
625 MFT_RECORD *m;
626 INDEX_ROOT *ir;
627 INDEX_ENTRY *ie;
628 INDEX_ALLOCATION *ia;
629 u8 *index_end;
630 u64 mref;
631 ntfs_attr_search_ctx *ctx;
632 int err, rc;
633 IGNORE_CASE_BOOL ic;
634 VCN vcn, old_vcn;
635 struct address_space *ia_mapping;
636 struct page *page;
637 u8 *kaddr;
638
639 /* Get hold of the mft record for the directory. */
640 m = map_mft_record(dir_ni);
641 if (IS_ERR(m)) {
642 ntfs_error(sb, "map_mft_record() failed with error code %ld.",
643 -PTR_ERR(m));
644 return ERR_MREF(PTR_ERR(m));
645 }
646 ctx = ntfs_attr_get_search_ctx(dir_ni, m);
647 if (!ctx) {
648 err = -ENOMEM;
649 goto err_out;
650 }
651 /* Find the index root attribute in the mft record. */
652 err = ntfs_attr_lookup(AT_INDEX_ROOT, I30, 4, CASE_SENSITIVE, 0, NULL,
653 0, ctx);
654 if (unlikely(err)) {
655 if (err == -ENOENT) {
656 ntfs_error(sb, "Index root attribute missing in "
657 "directory inode 0x%lx.",
658 dir_ni->mft_no);
659 err = -EIO;
660 }
661 goto err_out;
662 }
663 /* Get to the index root value (it's been verified in read_inode). */
664 ir = (INDEX_ROOT*)((u8*)ctx->attr +
665 le16_to_cpu(ctx->attr->data.resident.value_offset));
666 index_end = (u8*)&ir->index + le32_to_cpu(ir->index.index_length);
667 /* The first index entry. */
668 ie = (INDEX_ENTRY*)((u8*)&ir->index +
669 le32_to_cpu(ir->index.entries_offset));
670 /*
671 * Loop until we exceed valid memory (corruption case) or until we
672 * reach the last entry.
673 */
674 for (;; ie = (INDEX_ENTRY*)((u8*)ie + le16_to_cpu(ie->length))) {
675 /* Bounds checks. */
676 if ((u8*)ie < (u8*)ctx->mrec || (u8*)ie +
677 sizeof(INDEX_ENTRY_HEADER) > index_end ||
678 (u8*)ie + le16_to_cpu(ie->key_length) >
679 index_end)
680 goto dir_err_out;
681 /*
682 * The last entry cannot contain a name. It can however contain
683 * a pointer to a child node in the B+tree so we just break out.
684 */
685 if (ie->flags & INDEX_ENTRY_END)
686 break;
687 /*
688 * If the current entry has a name type of POSIX, the name is
689 * case sensitive and not otherwise. This has the effect of us
690 * not being able to access any POSIX file names which collate
691 * after the non-POSIX one when they only differ in case, but
692 * anyone doing screwy stuff like that deserves to burn in
693 * hell... Doing that kind of stuff on NT4 actually causes
694 * corruption on the partition even when using SP6a and Linux
695 * is not involved at all.
696 */
697 ic = ie->key.file_name.file_name_type ? IGNORE_CASE :
698 CASE_SENSITIVE;
699 /*
700 * If the names match perfectly, we are done and return the
701 * mft reference of the inode (i.e. the inode number together
702 * with the sequence number for consistency checking. We
703 * convert it to cpu format before returning.
704 */
705 if (ntfs_are_names_equal(uname, uname_len,
706 (ntfschar*)&ie->key.file_name.file_name,
707 ie->key.file_name.file_name_length, ic,
708 vol->upcase, vol->upcase_len)) {
709found_it:
710 mref = le64_to_cpu(ie->data.dir.indexed_file);
711 ntfs_attr_put_search_ctx(ctx);
712 unmap_mft_record(dir_ni);
713 return mref;
714 }
715 /*
716 * Not a perfect match, need to do full blown collation so we
717 * know which way in the B+tree we have to go.
718 */
719 rc = ntfs_collate_names(uname, uname_len,
720 (ntfschar*)&ie->key.file_name.file_name,
721 ie->key.file_name.file_name_length, 1,
722 IGNORE_CASE, vol->upcase, vol->upcase_len);
723 /*
724 * If uname collates before the name of the current entry, there
725 * is definitely no such name in this index but we might need to
726 * descend into the B+tree so we just break out of the loop.
727 */
728 if (rc == -1)
729 break;
730 /* The names are not equal, continue the search. */
731 if (rc)
732 continue;
733 /*
734 * Names match with case insensitive comparison, now try the
735 * case sensitive comparison, which is required for proper
736 * collation.
737 */
738 rc = ntfs_collate_names(uname, uname_len,
739 (ntfschar*)&ie->key.file_name.file_name,
740 ie->key.file_name.file_name_length, 1,
741 CASE_SENSITIVE, vol->upcase, vol->upcase_len);
742 if (rc == -1)
743 break;
744 if (rc)
745 continue;
746 /*
747 * Perfect match, this will never happen as the
748 * ntfs_are_names_equal() call will have gotten a match but we
749 * still treat it correctly.
750 */
751 goto found_it;
752 }
753 /*
754 * We have finished with this index without success. Check for the
755 * presence of a child node.
756 */
757 if (!(ie->flags & INDEX_ENTRY_NODE)) {
758 /* No child node, return -ENOENT. */
759 err = -ENOENT;
760 goto err_out;
761 } /* Child node present, descend into it. */
762 /* Consistency check: Verify that an index allocation exists. */
763 if (!NInoIndexAllocPresent(dir_ni)) {
764 ntfs_error(sb, "No index allocation attribute but index entry "
765 "requires one. Directory inode 0x%lx is "
766 "corrupt or driver bug.", dir_ni->mft_no);
767 goto err_out;
768 }
769 /* Get the starting vcn of the index_block holding the child node. */
770 vcn = sle64_to_cpup((u8*)ie + le16_to_cpu(ie->length) - 8);
771 ia_mapping = VFS_I(dir_ni)->i_mapping;
772 /*
773 * We are done with the index root and the mft record. Release them,
774 * otherwise we deadlock with ntfs_map_page().
775 */
776 ntfs_attr_put_search_ctx(ctx);
777 unmap_mft_record(dir_ni);
778 m = NULL;
779 ctx = NULL;
780descend_into_child_node:
781 /*
782 * Convert vcn to index into the index allocation attribute in units
783 * of PAGE_SIZE and map the page cache page, reading it from
784 * disk if necessary.
785 */
786 page = ntfs_map_page(ia_mapping, vcn <<
787 dir_ni->itype.index.vcn_size_bits >> PAGE_SHIFT);
788 if (IS_ERR(page)) {
789 ntfs_error(sb, "Failed to map directory index page, error %ld.",
790 -PTR_ERR(page));
791 err = PTR_ERR(page);
792 goto err_out;
793 }
794 lock_page(page);
795 kaddr = (u8*)page_address(page);
796fast_descend_into_child_node:
797 /* Get to the index allocation block. */
798 ia = (INDEX_ALLOCATION*)(kaddr + ((vcn <<
799 dir_ni->itype.index.vcn_size_bits) & ~PAGE_MASK));
800 /* Bounds checks. */
801 if ((u8*)ia < kaddr || (u8*)ia > kaddr + PAGE_SIZE) {
802 ntfs_error(sb, "Out of bounds check failed. Corrupt directory "
803 "inode 0x%lx or driver bug.", dir_ni->mft_no);
804 goto unm_err_out;
805 }
806 /* Catch multi sector transfer fixup errors. */
807 if (unlikely(!ntfs_is_indx_record(ia->magic))) {
808 ntfs_error(sb, "Directory index record with vcn 0x%llx is "
809 "corrupt. Corrupt inode 0x%lx. Run chkdsk.",
810 (unsigned long long)vcn, dir_ni->mft_no);
811 goto unm_err_out;
812 }
813 if (sle64_to_cpu(ia->index_block_vcn) != vcn) {
814 ntfs_error(sb, "Actual VCN (0x%llx) of index buffer is "
815 "different from expected VCN (0x%llx). "
816 "Directory inode 0x%lx is corrupt or driver "
817 "bug.", (unsigned long long)
818 sle64_to_cpu(ia->index_block_vcn),
819 (unsigned long long)vcn, dir_ni->mft_no);
820 goto unm_err_out;
821 }
822 if (le32_to_cpu(ia->index.allocated_size) + 0x18 !=
823 dir_ni->itype.index.block_size) {
824 ntfs_error(sb, "Index buffer (VCN 0x%llx) of directory inode "
825 "0x%lx has a size (%u) differing from the "
826 "directory specified size (%u). Directory "
827 "inode is corrupt or driver bug.",
828 (unsigned long long)vcn, dir_ni->mft_no,
829 le32_to_cpu(ia->index.allocated_size) + 0x18,
830 dir_ni->itype.index.block_size);
831 goto unm_err_out;
832 }
833 index_end = (u8*)ia + dir_ni->itype.index.block_size;
834 if (index_end > kaddr + PAGE_SIZE) {
835 ntfs_error(sb, "Index buffer (VCN 0x%llx) of directory inode "
836 "0x%lx crosses page boundary. Impossible! "
837 "Cannot access! This is probably a bug in the "
838 "driver.", (unsigned long long)vcn,
839 dir_ni->mft_no);
840 goto unm_err_out;
841 }
842 index_end = (u8*)&ia->index + le32_to_cpu(ia->index.index_length);
843 if (index_end > (u8*)ia + dir_ni->itype.index.block_size) {
844 ntfs_error(sb, "Size of index buffer (VCN 0x%llx) of directory "
845 "inode 0x%lx exceeds maximum size.",
846 (unsigned long long)vcn, dir_ni->mft_no);
847 goto unm_err_out;
848 }
849 /* The first index entry. */
850 ie = (INDEX_ENTRY*)((u8*)&ia->index +
851 le32_to_cpu(ia->index.entries_offset));
852 /*
853 * Iterate similar to above big loop but applied to index buffer, thus
854 * loop until we exceed valid memory (corruption case) or until we
855 * reach the last entry.
856 */
857 for (;; ie = (INDEX_ENTRY*)((u8*)ie + le16_to_cpu(ie->length))) {
858 /* Bounds check. */
859 if ((u8*)ie < (u8*)ia || (u8*)ie +
860 sizeof(INDEX_ENTRY_HEADER) > index_end ||
861 (u8*)ie + le16_to_cpu(ie->key_length) >
862 index_end) {
863 ntfs_error(sb, "Index entry out of bounds in "
864 "directory inode 0x%lx.",
865 dir_ni->mft_no);
866 goto unm_err_out;
867 }
868 /*
869 * The last entry cannot contain a name. It can however contain
870 * a pointer to a child node in the B+tree so we just break out.
871 */
872 if (ie->flags & INDEX_ENTRY_END)
873 break;
874 /*
875 * If the current entry has a name type of POSIX, the name is
876 * case sensitive and not otherwise. This has the effect of us
877 * not being able to access any POSIX file names which collate
878 * after the non-POSIX one when they only differ in case, but
879 * anyone doing screwy stuff like that deserves to burn in
880 * hell... Doing that kind of stuff on NT4 actually causes
881 * corruption on the partition even when using SP6a and Linux
882 * is not involved at all.
883 */
884 ic = ie->key.file_name.file_name_type ? IGNORE_CASE :
885 CASE_SENSITIVE;
886 /*
887 * If the names match perfectly, we are done and return the
888 * mft reference of the inode (i.e. the inode number together
889 * with the sequence number for consistency checking. We
890 * convert it to cpu format before returning.
891 */
892 if (ntfs_are_names_equal(uname, uname_len,
893 (ntfschar*)&ie->key.file_name.file_name,
894 ie->key.file_name.file_name_length, ic,
895 vol->upcase, vol->upcase_len)) {
896found_it2:
897 mref = le64_to_cpu(ie->data.dir.indexed_file);
898 unlock_page(page);
899 ntfs_unmap_page(page);
900 return mref;
901 }
902 /*
903 * Not a perfect match, need to do full blown collation so we
904 * know which way in the B+tree we have to go.
905 */
906 rc = ntfs_collate_names(uname, uname_len,
907 (ntfschar*)&ie->key.file_name.file_name,
908 ie->key.file_name.file_name_length, 1,
909 IGNORE_CASE, vol->upcase, vol->upcase_len);
910 /*
911 * If uname collates before the name of the current entry, there
912 * is definitely no such name in this index but we might need to
913 * descend into the B+tree so we just break out of the loop.
914 */
915 if (rc == -1)
916 break;
917 /* The names are not equal, continue the search. */
918 if (rc)
919 continue;
920 /*
921 * Names match with case insensitive comparison, now try the
922 * case sensitive comparison, which is required for proper
923 * collation.
924 */
925 rc = ntfs_collate_names(uname, uname_len,
926 (ntfschar*)&ie->key.file_name.file_name,
927 ie->key.file_name.file_name_length, 1,
928 CASE_SENSITIVE, vol->upcase, vol->upcase_len);
929 if (rc == -1)
930 break;
931 if (rc)
932 continue;
933 /*
934 * Perfect match, this will never happen as the
935 * ntfs_are_names_equal() call will have gotten a match but we
936 * still treat it correctly.
937 */
938 goto found_it2;
939 }
940 /*
941 * We have finished with this index buffer without success. Check for
942 * the presence of a child node.
943 */
944 if (ie->flags & INDEX_ENTRY_NODE) {
945 if ((ia->index.flags & NODE_MASK) == LEAF_NODE) {
946 ntfs_error(sb, "Index entry with child node found in "
947 "a leaf node in directory inode 0x%lx.",
948 dir_ni->mft_no);
949 goto unm_err_out;
950 }
951 /* Child node present, descend into it. */
952 old_vcn = vcn;
953 vcn = sle64_to_cpup((u8*)ie + le16_to_cpu(ie->length) - 8);
954 if (vcn >= 0) {
955 /* If vcn is in the same page cache page as old_vcn we
956 * recycle the mapped page. */
957 if (old_vcn << vol->cluster_size_bits >>
958 PAGE_SHIFT == vcn <<
959 vol->cluster_size_bits >>
960 PAGE_SHIFT)
961 goto fast_descend_into_child_node;
962 unlock_page(page);
963 ntfs_unmap_page(page);
964 goto descend_into_child_node;
965 }
966 ntfs_error(sb, "Negative child node vcn in directory inode "
967 "0x%lx.", dir_ni->mft_no);
968 goto unm_err_out;
969 }
970 /* No child node, return -ENOENT. */
971 ntfs_debug("Entry not found.");
972 err = -ENOENT;
973unm_err_out:
974 unlock_page(page);
975 ntfs_unmap_page(page);
976err_out:
977 if (!err)
978 err = -EIO;
979 if (ctx)
980 ntfs_attr_put_search_ctx(ctx);
981 if (m)
982 unmap_mft_record(dir_ni);
983 return ERR_MREF(err);
984dir_err_out:
985 ntfs_error(sb, "Corrupt directory. Aborting lookup.");
986 goto err_out;
987}
988
989#endif
990
991/**
992 * ntfs_filldir - ntfs specific filldir method
993 * @vol: current ntfs volume
994 * @ndir: ntfs inode of current directory
995 * @ia_page: page in which the index allocation buffer @ie is in resides
996 * @ie: current index entry
997 * @name: buffer to use for the converted name
998 * @actor: what to feed the entries to
999 *
1000 * Convert the Unicode @name to the loaded NLS and pass it to the @filldir
1001 * callback.
1002 *
1003 * If @ia_page is not NULL it is the locked page containing the index
1004 * allocation block containing the index entry @ie.
1005 *
1006 * Note, we drop (and then reacquire) the page lock on @ia_page across the
1007 * @filldir() call otherwise we would deadlock with NFSd when it calls ->lookup
1008 * since ntfs_lookup() will lock the same page. As an optimization, we do not
1009 * retake the lock if we are returning a non-zero value as ntfs_readdir()
1010 * would need to drop the lock immediately anyway.
1011 */
1012static inline int ntfs_filldir(ntfs_volume *vol,
1013 ntfs_inode *ndir, struct page *ia_page, INDEX_ENTRY *ie,
1014 u8 *name, struct dir_context *actor)
1015{
1016 unsigned long mref;
1017 int name_len;
1018 unsigned dt_type;
1019 FILE_NAME_TYPE_FLAGS name_type;
1020
1021 name_type = ie->key.file_name.file_name_type;
1022 if (name_type == FILE_NAME_DOS) {
1023 ntfs_debug("Skipping DOS name space entry.");
1024 return 0;
1025 }
1026 if (MREF_LE(ie->data.dir.indexed_file) == FILE_root) {
1027 ntfs_debug("Skipping root directory self reference entry.");
1028 return 0;
1029 }
1030 if (MREF_LE(ie->data.dir.indexed_file) < FILE_first_user &&
1031 !NVolShowSystemFiles(vol)) {
1032 ntfs_debug("Skipping system file.");
1033 return 0;
1034 }
1035 name_len = ntfs_ucstonls(vol, (ntfschar*)&ie->key.file_name.file_name,
1036 ie->key.file_name.file_name_length, &name,
1037 NTFS_MAX_NAME_LEN * NLS_MAX_CHARSET_SIZE + 1);
1038 if (name_len <= 0) {
1039 ntfs_warning(vol->sb, "Skipping unrepresentable inode 0x%llx.",
1040 (long long)MREF_LE(ie->data.dir.indexed_file));
1041 return 0;
1042 }
1043 if (ie->key.file_name.file_attributes &
1044 FILE_ATTR_DUP_FILE_NAME_INDEX_PRESENT)
1045 dt_type = DT_DIR;
1046 else
1047 dt_type = DT_REG;
1048 mref = MREF_LE(ie->data.dir.indexed_file);
1049 /*
1050 * Drop the page lock otherwise we deadlock with NFS when it calls
1051 * ->lookup since ntfs_lookup() will lock the same page.
1052 */
1053 if (ia_page)
1054 unlock_page(ia_page);
1055 ntfs_debug("Calling filldir for %s with len %i, fpos 0x%llx, inode "
1056 "0x%lx, DT_%s.", name, name_len, actor->pos, mref,
1057 dt_type == DT_DIR ? "DIR" : "REG");
1058 if (!dir_emit(actor, name, name_len, mref, dt_type))
1059 return 1;
1060 /* Relock the page but not if we are aborting ->readdir. */
1061 if (ia_page)
1062 lock_page(ia_page);
1063 return 0;
1064}
1065
1066/*
1067 * We use the same basic approach as the old NTFS driver, i.e. we parse the
1068 * index root entries and then the index allocation entries that are marked
1069 * as in use in the index bitmap.
1070 *
1071 * While this will return the names in random order this doesn't matter for
1072 * ->readdir but OTOH results in a faster ->readdir.
1073 *
1074 * VFS calls ->readdir without BKL but with i_mutex held. This protects the VFS
1075 * parts (e.g. ->f_pos and ->i_size, and it also protects against directory
1076 * modifications).
1077 *
1078 * Locking: - Caller must hold i_mutex on the directory.
1079 * - Each page cache page in the index allocation mapping must be
1080 * locked whilst being accessed otherwise we may find a corrupt
1081 * page due to it being under ->writepage at the moment which
1082 * applies the mst protection fixups before writing out and then
1083 * removes them again after the write is complete after which it
1084 * unlocks the page.
1085 */
1086static int ntfs_readdir(struct file *file, struct dir_context *actor)
1087{
1088 s64 ia_pos, ia_start, prev_ia_pos, bmp_pos;
1089 loff_t i_size;
1090 struct inode *bmp_vi, *vdir = file_inode(file);
1091 struct super_block *sb = vdir->i_sb;
1092 ntfs_inode *ndir = NTFS_I(vdir);
1093 ntfs_volume *vol = NTFS_SB(sb);
1094 MFT_RECORD *m;
1095 INDEX_ROOT *ir = NULL;
1096 INDEX_ENTRY *ie;
1097 INDEX_ALLOCATION *ia;
1098 u8 *name = NULL;
1099 int rc, err, ir_pos, cur_bmp_pos;
1100 struct address_space *ia_mapping, *bmp_mapping;
1101 struct page *bmp_page = NULL, *ia_page = NULL;
1102 u8 *kaddr, *bmp, *index_end;
1103 ntfs_attr_search_ctx *ctx;
1104
1105 ntfs_debug("Entering for inode 0x%lx, fpos 0x%llx.",
1106 vdir->i_ino, actor->pos);
1107 rc = err = 0;
1108 /* Are we at end of dir yet? */
1109 i_size = i_size_read(vdir);
1110 if (actor->pos >= i_size + vol->mft_record_size)
1111 return 0;
1112 /* Emulate . and .. for all directories. */
1113 if (!dir_emit_dots(file, actor))
1114 return 0;
1115 m = NULL;
1116 ctx = NULL;
1117 /*
1118 * Allocate a buffer to store the current name being processed
1119 * converted to format determined by current NLS.
1120 */
1121 name = kmalloc(NTFS_MAX_NAME_LEN * NLS_MAX_CHARSET_SIZE + 1, GFP_NOFS);
1122 if (unlikely(!name)) {
1123 err = -ENOMEM;
1124 goto err_out;
1125 }
1126 /* Are we jumping straight into the index allocation attribute? */
1127 if (actor->pos >= vol->mft_record_size)
1128 goto skip_index_root;
1129 /* Get hold of the mft record for the directory. */
1130 m = map_mft_record(ndir);
1131 if (IS_ERR(m)) {
1132 err = PTR_ERR(m);
1133 m = NULL;
1134 goto err_out;
1135 }
1136 ctx = ntfs_attr_get_search_ctx(ndir, m);
1137 if (unlikely(!ctx)) {
1138 err = -ENOMEM;
1139 goto err_out;
1140 }
1141 /* Get the offset into the index root attribute. */
1142 ir_pos = (s64)actor->pos;
1143 /* Find the index root attribute in the mft record. */
1144 err = ntfs_attr_lookup(AT_INDEX_ROOT, I30, 4, CASE_SENSITIVE, 0, NULL,
1145 0, ctx);
1146 if (unlikely(err)) {
1147 ntfs_error(sb, "Index root attribute missing in directory "
1148 "inode 0x%lx.", vdir->i_ino);
1149 goto err_out;
1150 }
1151 /*
1152 * Copy the index root attribute value to a buffer so that we can put
1153 * the search context and unmap the mft record before calling the
1154 * filldir() callback. We need to do this because of NFSd which calls
1155 * ->lookup() from its filldir callback() and this causes NTFS to
1156 * deadlock as ntfs_lookup() maps the mft record of the directory and
1157 * we have got it mapped here already. The only solution is for us to
1158 * unmap the mft record here so that a call to ntfs_lookup() is able to
1159 * map the mft record without deadlocking.
1160 */
1161 rc = le32_to_cpu(ctx->attr->data.resident.value_length);
1162 ir = kmalloc(rc, GFP_NOFS);
1163 if (unlikely(!ir)) {
1164 err = -ENOMEM;
1165 goto err_out;
1166 }
1167 /* Copy the index root value (it has been verified in read_inode). */
1168 memcpy(ir, (u8*)ctx->attr +
1169 le16_to_cpu(ctx->attr->data.resident.value_offset), rc);
1170 ntfs_attr_put_search_ctx(ctx);
1171 unmap_mft_record(ndir);
1172 ctx = NULL;
1173 m = NULL;
1174 index_end = (u8*)&ir->index + le32_to_cpu(ir->index.index_length);
1175 /* The first index entry. */
1176 ie = (INDEX_ENTRY*)((u8*)&ir->index +
1177 le32_to_cpu(ir->index.entries_offset));
1178 /*
1179 * Loop until we exceed valid memory (corruption case) or until we
1180 * reach the last entry or until filldir tells us it has had enough
1181 * or signals an error (both covered by the rc test).
1182 */
1183 for (;; ie = (INDEX_ENTRY*)((u8*)ie + le16_to_cpu(ie->length))) {
1184 ntfs_debug("In index root, offset 0x%zx.", (u8*)ie - (u8*)ir);
1185 /* Bounds checks. */
1186 if (unlikely((u8*)ie < (u8*)ir || (u8*)ie +
1187 sizeof(INDEX_ENTRY_HEADER) > index_end ||
1188 (u8*)ie + le16_to_cpu(ie->key_length) >
1189 index_end))
1190 goto err_out;
1191 /* The last entry cannot contain a name. */
1192 if (ie->flags & INDEX_ENTRY_END)
1193 break;
1194 /* Skip index root entry if continuing previous readdir. */
1195 if (ir_pos > (u8*)ie - (u8*)ir)
1196 continue;
1197 /* Advance the position even if going to skip the entry. */
1198 actor->pos = (u8*)ie - (u8*)ir;
1199 /* Submit the name to the filldir callback. */
1200 rc = ntfs_filldir(vol, ndir, NULL, ie, name, actor);
1201 if (rc) {
1202 kfree(ir);
1203 goto abort;
1204 }
1205 }
1206 /* We are done with the index root and can free the buffer. */
1207 kfree(ir);
1208 ir = NULL;
1209 /* If there is no index allocation attribute we are finished. */
1210 if (!NInoIndexAllocPresent(ndir))
1211 goto EOD;
1212 /* Advance fpos to the beginning of the index allocation. */
1213 actor->pos = vol->mft_record_size;
1214skip_index_root:
1215 kaddr = NULL;
1216 prev_ia_pos = -1LL;
1217 /* Get the offset into the index allocation attribute. */
1218 ia_pos = (s64)actor->pos - vol->mft_record_size;
1219 ia_mapping = vdir->i_mapping;
1220 ntfs_debug("Inode 0x%lx, getting index bitmap.", vdir->i_ino);
1221 bmp_vi = ntfs_attr_iget(vdir, AT_BITMAP, I30, 4);
1222 if (IS_ERR(bmp_vi)) {
1223 ntfs_error(sb, "Failed to get bitmap attribute.");
1224 err = PTR_ERR(bmp_vi);
1225 goto err_out;
1226 }
1227 bmp_mapping = bmp_vi->i_mapping;
1228 /* Get the starting bitmap bit position and sanity check it. */
1229 bmp_pos = ia_pos >> ndir->itype.index.block_size_bits;
1230 if (unlikely(bmp_pos >> 3 >= i_size_read(bmp_vi))) {
1231 ntfs_error(sb, "Current index allocation position exceeds "
1232 "index bitmap size.");
1233 goto iput_err_out;
1234 }
1235 /* Get the starting bit position in the current bitmap page. */
1236 cur_bmp_pos = bmp_pos & ((PAGE_SIZE * 8) - 1);
1237 bmp_pos &= ~(u64)((PAGE_SIZE * 8) - 1);
1238get_next_bmp_page:
1239 ntfs_debug("Reading bitmap with page index 0x%llx, bit ofs 0x%llx",
1240 (unsigned long long)bmp_pos >> (3 + PAGE_SHIFT),
1241 (unsigned long long)bmp_pos &
1242 (unsigned long long)((PAGE_SIZE * 8) - 1));
1243 bmp_page = ntfs_map_page(bmp_mapping,
1244 bmp_pos >> (3 + PAGE_SHIFT));
1245 if (IS_ERR(bmp_page)) {
1246 ntfs_error(sb, "Reading index bitmap failed.");
1247 err = PTR_ERR(bmp_page);
1248 bmp_page = NULL;
1249 goto iput_err_out;
1250 }
1251 bmp = (u8*)page_address(bmp_page);
1252 /* Find next index block in use. */
1253 while (!(bmp[cur_bmp_pos >> 3] & (1 << (cur_bmp_pos & 7)))) {
1254find_next_index_buffer:
1255 cur_bmp_pos++;
1256 /*
1257 * If we have reached the end of the bitmap page, get the next
1258 * page, and put away the old one.
1259 */
1260 if (unlikely((cur_bmp_pos >> 3) >= PAGE_SIZE)) {
1261 ntfs_unmap_page(bmp_page);
1262 bmp_pos += PAGE_SIZE * 8;
1263 cur_bmp_pos = 0;
1264 goto get_next_bmp_page;
1265 }
1266 /* If we have reached the end of the bitmap, we are done. */
1267 if (unlikely(((bmp_pos + cur_bmp_pos) >> 3) >= i_size))
1268 goto unm_EOD;
1269 ia_pos = (bmp_pos + cur_bmp_pos) <<
1270 ndir->itype.index.block_size_bits;
1271 }
1272 ntfs_debug("Handling index buffer 0x%llx.",
1273 (unsigned long long)bmp_pos + cur_bmp_pos);
1274 /* If the current index buffer is in the same page we reuse the page. */
1275 if ((prev_ia_pos & (s64)PAGE_MASK) !=
1276 (ia_pos & (s64)PAGE_MASK)) {
1277 prev_ia_pos = ia_pos;
1278 if (likely(ia_page != NULL)) {
1279 unlock_page(ia_page);
1280 ntfs_unmap_page(ia_page);
1281 }
1282 /*
1283 * Map the page cache page containing the current ia_pos,
1284 * reading it from disk if necessary.
1285 */
1286 ia_page = ntfs_map_page(ia_mapping, ia_pos >> PAGE_SHIFT);
1287 if (IS_ERR(ia_page)) {
1288 ntfs_error(sb, "Reading index allocation data failed.");
1289 err = PTR_ERR(ia_page);
1290 ia_page = NULL;
1291 goto err_out;
1292 }
1293 lock_page(ia_page);
1294 kaddr = (u8*)page_address(ia_page);
1295 }
1296 /* Get the current index buffer. */
1297 ia = (INDEX_ALLOCATION*)(kaddr + (ia_pos & ~PAGE_MASK &
1298 ~(s64)(ndir->itype.index.block_size - 1)));
1299 /* Bounds checks. */
1300 if (unlikely((u8*)ia < kaddr || (u8*)ia > kaddr + PAGE_SIZE)) {
1301 ntfs_error(sb, "Out of bounds check failed. Corrupt directory "
1302 "inode 0x%lx or driver bug.", vdir->i_ino);
1303 goto err_out;
1304 }
1305 /* Catch multi sector transfer fixup errors. */
1306 if (unlikely(!ntfs_is_indx_record(ia->magic))) {
1307 ntfs_error(sb, "Directory index record with vcn 0x%llx is "
1308 "corrupt. Corrupt inode 0x%lx. Run chkdsk.",
1309 (unsigned long long)ia_pos >>
1310 ndir->itype.index.vcn_size_bits, vdir->i_ino);
1311 goto err_out;
1312 }
1313 if (unlikely(sle64_to_cpu(ia->index_block_vcn) != (ia_pos &
1314 ~(s64)(ndir->itype.index.block_size - 1)) >>
1315 ndir->itype.index.vcn_size_bits)) {
1316 ntfs_error(sb, "Actual VCN (0x%llx) of index buffer is "
1317 "different from expected VCN (0x%llx). "
1318 "Directory inode 0x%lx is corrupt or driver "
1319 "bug. ", (unsigned long long)
1320 sle64_to_cpu(ia->index_block_vcn),
1321 (unsigned long long)ia_pos >>
1322 ndir->itype.index.vcn_size_bits, vdir->i_ino);
1323 goto err_out;
1324 }
1325 if (unlikely(le32_to_cpu(ia->index.allocated_size) + 0x18 !=
1326 ndir->itype.index.block_size)) {
1327 ntfs_error(sb, "Index buffer (VCN 0x%llx) of directory inode "
1328 "0x%lx has a size (%u) differing from the "
1329 "directory specified size (%u). Directory "
1330 "inode is corrupt or driver bug.",
1331 (unsigned long long)ia_pos >>
1332 ndir->itype.index.vcn_size_bits, vdir->i_ino,
1333 le32_to_cpu(ia->index.allocated_size) + 0x18,
1334 ndir->itype.index.block_size);
1335 goto err_out;
1336 }
1337 index_end = (u8*)ia + ndir->itype.index.block_size;
1338 if (unlikely(index_end > kaddr + PAGE_SIZE)) {
1339 ntfs_error(sb, "Index buffer (VCN 0x%llx) of directory inode "
1340 "0x%lx crosses page boundary. Impossible! "
1341 "Cannot access! This is probably a bug in the "
1342 "driver.", (unsigned long long)ia_pos >>
1343 ndir->itype.index.vcn_size_bits, vdir->i_ino);
1344 goto err_out;
1345 }
1346 ia_start = ia_pos & ~(s64)(ndir->itype.index.block_size - 1);
1347 index_end = (u8*)&ia->index + le32_to_cpu(ia->index.index_length);
1348 if (unlikely(index_end > (u8*)ia + ndir->itype.index.block_size)) {
1349 ntfs_error(sb, "Size of index buffer (VCN 0x%llx) of directory "
1350 "inode 0x%lx exceeds maximum size.",
1351 (unsigned long long)ia_pos >>
1352 ndir->itype.index.vcn_size_bits, vdir->i_ino);
1353 goto err_out;
1354 }
1355 /* The first index entry in this index buffer. */
1356 ie = (INDEX_ENTRY*)((u8*)&ia->index +
1357 le32_to_cpu(ia->index.entries_offset));
1358 /*
1359 * Loop until we exceed valid memory (corruption case) or until we
1360 * reach the last entry or until filldir tells us it has had enough
1361 * or signals an error (both covered by the rc test).
1362 */
1363 for (;; ie = (INDEX_ENTRY*)((u8*)ie + le16_to_cpu(ie->length))) {
1364 ntfs_debug("In index allocation, offset 0x%llx.",
1365 (unsigned long long)ia_start +
1366 (unsigned long long)((u8*)ie - (u8*)ia));
1367 /* Bounds checks. */
1368 if (unlikely((u8*)ie < (u8*)ia || (u8*)ie +
1369 sizeof(INDEX_ENTRY_HEADER) > index_end ||
1370 (u8*)ie + le16_to_cpu(ie->key_length) >
1371 index_end))
1372 goto err_out;
1373 /* The last entry cannot contain a name. */
1374 if (ie->flags & INDEX_ENTRY_END)
1375 break;
1376 /* Skip index block entry if continuing previous readdir. */
1377 if (ia_pos - ia_start > (u8*)ie - (u8*)ia)
1378 continue;
1379 /* Advance the position even if going to skip the entry. */
1380 actor->pos = (u8*)ie - (u8*)ia +
1381 (sle64_to_cpu(ia->index_block_vcn) <<
1382 ndir->itype.index.vcn_size_bits) +
1383 vol->mft_record_size;
1384 /*
1385 * Submit the name to the @filldir callback. Note,
1386 * ntfs_filldir() drops the lock on @ia_page but it retakes it
1387 * before returning, unless a non-zero value is returned in
1388 * which case the page is left unlocked.
1389 */
1390 rc = ntfs_filldir(vol, ndir, ia_page, ie, name, actor);
1391 if (rc) {
1392 /* @ia_page is already unlocked in this case. */
1393 ntfs_unmap_page(ia_page);
1394 ntfs_unmap_page(bmp_page);
1395 iput(bmp_vi);
1396 goto abort;
1397 }
1398 }
1399 goto find_next_index_buffer;
1400unm_EOD:
1401 if (ia_page) {
1402 unlock_page(ia_page);
1403 ntfs_unmap_page(ia_page);
1404 }
1405 ntfs_unmap_page(bmp_page);
1406 iput(bmp_vi);
1407EOD:
1408 /* We are finished, set fpos to EOD. */
1409 actor->pos = i_size + vol->mft_record_size;
1410abort:
1411 kfree(name);
1412 return 0;
1413err_out:
1414 if (bmp_page) {
1415 ntfs_unmap_page(bmp_page);
1416iput_err_out:
1417 iput(bmp_vi);
1418 }
1419 if (ia_page) {
1420 unlock_page(ia_page);
1421 ntfs_unmap_page(ia_page);
1422 }
1423 kfree(ir);
1424 kfree(name);
1425 if (ctx)
1426 ntfs_attr_put_search_ctx(ctx);
1427 if (m)
1428 unmap_mft_record(ndir);
1429 if (!err)
1430 err = -EIO;
1431 ntfs_debug("Failed. Returning error code %i.", -err);
1432 return err;
1433}
1434
1435/**
1436 * ntfs_dir_open - called when an inode is about to be opened
1437 * @vi: inode to be opened
1438 * @filp: file structure describing the inode
1439 *
1440 * Limit directory size to the page cache limit on architectures where unsigned
1441 * long is 32-bits. This is the most we can do for now without overflowing the
1442 * page cache page index. Doing it this way means we don't run into problems
1443 * because of existing too large directories. It would be better to allow the
1444 * user to read the accessible part of the directory but I doubt very much
1445 * anyone is going to hit this check on a 32-bit architecture, so there is no
1446 * point in adding the extra complexity required to support this.
1447 *
1448 * On 64-bit architectures, the check is hopefully optimized away by the
1449 * compiler.
1450 */
1451static int ntfs_dir_open(struct inode *vi, struct file *filp)
1452{
1453 if (sizeof(unsigned long) < 8) {
1454 if (i_size_read(vi) > MAX_LFS_FILESIZE)
1455 return -EFBIG;
1456 }
1457 return 0;
1458}
1459
1460#ifdef NTFS_RW
1461
1462/**
1463 * ntfs_dir_fsync - sync a directory to disk
1464 * @filp: directory to be synced
1465 * @dentry: dentry describing the directory to sync
1466 * @datasync: if non-zero only flush user data and not metadata
1467 *
1468 * Data integrity sync of a directory to disk. Used for fsync, fdatasync, and
1469 * msync system calls. This function is based on file.c::ntfs_file_fsync().
1470 *
1471 * Write the mft record and all associated extent mft records as well as the
1472 * $INDEX_ALLOCATION and $BITMAP attributes and then sync the block device.
1473 *
1474 * If @datasync is true, we do not wait on the inode(s) to be written out
1475 * but we always wait on the page cache pages to be written out.
1476 *
1477 * Note: In the past @filp could be NULL so we ignore it as we don't need it
1478 * anyway.
1479 *
1480 * Locking: Caller must hold i_mutex on the inode.
1481 *
1482 * TODO: We should probably also write all attribute/index inodes associated
1483 * with this inode but since we have no simple way of getting to them we ignore
1484 * this problem for now. We do write the $BITMAP attribute if it is present
1485 * which is the important one for a directory so things are not too bad.
1486 */
1487static int ntfs_dir_fsync(struct file *filp, loff_t start, loff_t end,
1488 int datasync)
1489{
1490 struct inode *bmp_vi, *vi = filp->f_mapping->host;
1491 int err, ret;
1492 ntfs_attr na;
1493
1494 ntfs_debug("Entering for inode 0x%lx.", vi->i_ino);
1495
1496 err = file_write_and_wait_range(filp, start, end);
1497 if (err)
1498 return err;
1499 inode_lock(vi);
1500
1501 BUG_ON(!S_ISDIR(vi->i_mode));
1502 /* If the bitmap attribute inode is in memory sync it, too. */
1503 na.mft_no = vi->i_ino;
1504 na.type = AT_BITMAP;
1505 na.name = I30;
1506 na.name_len = 4;
1507 bmp_vi = ilookup5(vi->i_sb, vi->i_ino, ntfs_test_inode, &na);
1508 if (bmp_vi) {
1509 write_inode_now(bmp_vi, !datasync);
1510 iput(bmp_vi);
1511 }
1512 ret = __ntfs_write_inode(vi, 1);
1513 write_inode_now(vi, !datasync);
1514 err = sync_blockdev(vi->i_sb->s_bdev);
1515 if (unlikely(err && !ret))
1516 ret = err;
1517 if (likely(!ret))
1518 ntfs_debug("Done.");
1519 else
1520 ntfs_warning(vi->i_sb, "Failed to f%ssync inode 0x%lx. Error "
1521 "%u.", datasync ? "data" : "", vi->i_ino, -ret);
1522 inode_unlock(vi);
1523 return ret;
1524}
1525
1526#endif /* NTFS_RW */
1527
1528const struct file_operations ntfs_dir_ops = {
1529 .llseek = generic_file_llseek, /* Seek inside directory. */
1530 .read = generic_read_dir, /* Return -EISDIR. */
1531 .iterate = ntfs_readdir, /* Read directory contents. */
1532#ifdef NTFS_RW
1533 .fsync = ntfs_dir_fsync, /* Sync a directory to disk. */
1534#endif /* NTFS_RW */
1535 /*.ioctl = ,*/ /* Perform function on the
1536 mounted filesystem. */
1537 .open = ntfs_dir_open, /* Open directory. */
1538};