1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22#include <linux/buffer_head.h>
23#include <linux/fs.h>
24#include <linux/mm.h>
25#include <linux/mount.h>
26#include <linux/mutex.h>
27#include <linux/pagemap.h>
28#include <linux/quotaops.h>
29#include <linux/slab.h>
30#include <linux/log2.h>
31
32#include "aops.h"
33#include "attrib.h"
34#include "bitmap.h"
35#include "dir.h"
36#include "debug.h"
37#include "inode.h"
38#include "lcnalloc.h"
39#include "malloc.h"
40#include "mft.h"
41#include "time.h"
42#include "ntfs.h"
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60int ntfs_test_inode(struct inode *vi, ntfs_attr *na)
61{
62 ntfs_inode *ni;
63
64 if (vi->i_ino != na->mft_no)
65 return 0;
66 ni = NTFS_I(vi);
67
68 if (likely(!NInoAttr(ni))) {
69
70 if (unlikely(na->type != AT_UNUSED))
71 return 0;
72 } else {
73
74 if (ni->type != na->type)
75 return 0;
76 if (ni->name_len != na->name_len)
77 return 0;
78 if (na->name_len && memcmp(ni->name, na->name,
79 na->name_len * sizeof(ntfschar)))
80 return 0;
81 }
82
83 return 1;
84}
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104static int ntfs_init_locked_inode(struct inode *vi, ntfs_attr *na)
105{
106 ntfs_inode *ni = NTFS_I(vi);
107
108 vi->i_ino = na->mft_no;
109
110 ni->type = na->type;
111 if (na->type == AT_INDEX_ALLOCATION)
112 NInoSetMstProtected(ni);
113
114 ni->name = na->name;
115 ni->name_len = na->name_len;
116
117
118 if (likely(na->type == AT_UNUSED)) {
119 BUG_ON(na->name);
120 BUG_ON(na->name_len);
121 return 0;
122 }
123
124
125 NInoSetAttr(ni);
126
127
128
129
130
131
132
133
134 if (na->name_len && na->name != I30) {
135 unsigned int i;
136
137 BUG_ON(!na->name);
138 i = na->name_len * sizeof(ntfschar);
139 ni->name = kmalloc(i + sizeof(ntfschar), GFP_ATOMIC);
140 if (!ni->name)
141 return -ENOMEM;
142 memcpy(ni->name, na->name, i);
143 ni->name[na->name_len] = 0;
144 }
145 return 0;
146}
147
148typedef int (*set_t)(struct inode *, void *);
149static int ntfs_read_locked_inode(struct inode *vi);
150static int ntfs_read_locked_attr_inode(struct inode *base_vi, struct inode *vi);
151static int ntfs_read_locked_index_inode(struct inode *base_vi,
152 struct inode *vi);
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170struct inode *ntfs_iget(struct super_block *sb, unsigned long mft_no)
171{
172 struct inode *vi;
173 int err;
174 ntfs_attr na;
175
176 na.mft_no = mft_no;
177 na.type = AT_UNUSED;
178 na.name = NULL;
179 na.name_len = 0;
180
181 vi = iget5_locked(sb, mft_no, (test_t)ntfs_test_inode,
182 (set_t)ntfs_init_locked_inode, &na);
183 if (unlikely(!vi))
184 return ERR_PTR(-ENOMEM);
185
186 err = 0;
187
188
189 if (vi->i_state & I_NEW) {
190 err = ntfs_read_locked_inode(vi);
191 unlock_new_inode(vi);
192 }
193
194
195
196
197 if (unlikely(err == -ENOMEM)) {
198 iput(vi);
199 vi = ERR_PTR(err);
200 }
201 return vi;
202}
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227struct inode *ntfs_attr_iget(struct inode *base_vi, ATTR_TYPE type,
228 ntfschar *name, u32 name_len)
229{
230 struct inode *vi;
231 int err;
232 ntfs_attr na;
233
234
235 BUG_ON(type == AT_INDEX_ALLOCATION);
236
237 na.mft_no = base_vi->i_ino;
238 na.type = type;
239 na.name = name;
240 na.name_len = name_len;
241
242 vi = iget5_locked(base_vi->i_sb, na.mft_no, (test_t)ntfs_test_inode,
243 (set_t)ntfs_init_locked_inode, &na);
244 if (unlikely(!vi))
245 return ERR_PTR(-ENOMEM);
246
247 err = 0;
248
249
250 if (vi->i_state & I_NEW) {
251 err = ntfs_read_locked_attr_inode(base_vi, vi);
252 unlock_new_inode(vi);
253 }
254
255
256
257
258
259 if (unlikely(err)) {
260 iput(vi);
261 vi = ERR_PTR(err);
262 }
263 return vi;
264}
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285struct inode *ntfs_index_iget(struct inode *base_vi, ntfschar *name,
286 u32 name_len)
287{
288 struct inode *vi;
289 int err;
290 ntfs_attr na;
291
292 na.mft_no = base_vi->i_ino;
293 na.type = AT_INDEX_ALLOCATION;
294 na.name = name;
295 na.name_len = name_len;
296
297 vi = iget5_locked(base_vi->i_sb, na.mft_no, (test_t)ntfs_test_inode,
298 (set_t)ntfs_init_locked_inode, &na);
299 if (unlikely(!vi))
300 return ERR_PTR(-ENOMEM);
301
302 err = 0;
303
304
305 if (vi->i_state & I_NEW) {
306 err = ntfs_read_locked_index_inode(base_vi, vi);
307 unlock_new_inode(vi);
308 }
309
310
311
312
313
314 if (unlikely(err)) {
315 iput(vi);
316 vi = ERR_PTR(err);
317 }
318 return vi;
319}
320
321struct inode *ntfs_alloc_big_inode(struct super_block *sb)
322{
323 ntfs_inode *ni;
324
325 ntfs_debug("Entering.");
326 ni = kmem_cache_alloc(ntfs_big_inode_cache, GFP_NOFS);
327 if (likely(ni != NULL)) {
328 ni->state = 0;
329 return VFS_I(ni);
330 }
331 ntfs_error(sb, "Allocation of NTFS big inode structure failed.");
332 return NULL;
333}
334
335static void ntfs_i_callback(struct rcu_head *head)
336{
337 struct inode *inode = container_of(head, struct inode, i_rcu);
338 INIT_LIST_HEAD(&inode->i_dentry);
339 kmem_cache_free(ntfs_big_inode_cache, NTFS_I(inode));
340}
341
342void ntfs_destroy_big_inode(struct inode *inode)
343{
344 ntfs_inode *ni = NTFS_I(inode);
345
346 ntfs_debug("Entering.");
347 BUG_ON(ni->page);
348 if (!atomic_dec_and_test(&ni->count))
349 BUG();
350 call_rcu(&inode->i_rcu, ntfs_i_callback);
351}
352
353static inline ntfs_inode *ntfs_alloc_extent_inode(void)
354{
355 ntfs_inode *ni;
356
357 ntfs_debug("Entering.");
358 ni = kmem_cache_alloc(ntfs_inode_cache, GFP_NOFS);
359 if (likely(ni != NULL)) {
360 ni->state = 0;
361 return ni;
362 }
363 ntfs_error(NULL, "Allocation of NTFS inode structure failed.");
364 return NULL;
365}
366
367static void ntfs_destroy_extent_inode(ntfs_inode *ni)
368{
369 ntfs_debug("Entering.");
370 BUG_ON(ni->page);
371 if (!atomic_dec_and_test(&ni->count))
372 BUG();
373 kmem_cache_free(ntfs_inode_cache, ni);
374}
375
376
377
378
379
380static struct lock_class_key attr_list_rl_lock_class;
381
382
383
384
385
386
387
388
389
390
391
392
393
394void __ntfs_init_inode(struct super_block *sb, ntfs_inode *ni)
395{
396 ntfs_debug("Entering.");
397 rwlock_init(&ni->size_lock);
398 ni->initialized_size = ni->allocated_size = 0;
399 ni->seq_no = 0;
400 atomic_set(&ni->count, 1);
401 ni->vol = NTFS_SB(sb);
402 ntfs_init_runlist(&ni->runlist);
403 mutex_init(&ni->mrec_lock);
404 ni->page = NULL;
405 ni->page_ofs = 0;
406 ni->attr_list_size = 0;
407 ni->attr_list = NULL;
408 ntfs_init_runlist(&ni->attr_list_rl);
409 lockdep_set_class(&ni->attr_list_rl.lock,
410 &attr_list_rl_lock_class);
411 ni->itype.index.block_size = 0;
412 ni->itype.index.vcn_size = 0;
413 ni->itype.index.collation_rule = 0;
414 ni->itype.index.block_size_bits = 0;
415 ni->itype.index.vcn_size_bits = 0;
416 mutex_init(&ni->extent_lock);
417 ni->nr_extents = 0;
418 ni->ext.base_ntfs_ino = NULL;
419}
420
421
422
423
424
425
426static struct lock_class_key extent_inode_mrec_lock_key;
427
428inline ntfs_inode *ntfs_new_extent_inode(struct super_block *sb,
429 unsigned long mft_no)
430{
431 ntfs_inode *ni = ntfs_alloc_extent_inode();
432
433 ntfs_debug("Entering.");
434 if (likely(ni != NULL)) {
435 __ntfs_init_inode(sb, ni);
436 lockdep_set_class(&ni->mrec_lock, &extent_inode_mrec_lock_key);
437 ni->mft_no = mft_no;
438 ni->type = AT_UNUSED;
439 ni->name = NULL;
440 ni->name_len = 0;
441 }
442 return ni;
443}
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458static int ntfs_is_extended_system_file(ntfs_attr_search_ctx *ctx)
459{
460 int nr_links, err;
461
462
463 ntfs_attr_reinit_search_ctx(ctx);
464
465
466 nr_links = le16_to_cpu(ctx->mrec->link_count);
467
468
469 while (!(err = ntfs_attr_lookup(AT_FILE_NAME, NULL, 0, 0, 0, NULL, 0,
470 ctx))) {
471 FILE_NAME_ATTR *file_name_attr;
472 ATTR_RECORD *attr = ctx->attr;
473 u8 *p, *p2;
474
475 nr_links--;
476
477
478
479
480 p = (u8*)attr + le32_to_cpu(attr->length);
481 if (p < (u8*)ctx->mrec || (u8*)p > (u8*)ctx->mrec +
482 le32_to_cpu(ctx->mrec->bytes_in_use)) {
483err_corrupt_attr:
484 ntfs_error(ctx->ntfs_ino->vol->sb, "Corrupt file name "
485 "attribute. You should run chkdsk.");
486 return -EIO;
487 }
488 if (attr->non_resident) {
489 ntfs_error(ctx->ntfs_ino->vol->sb, "Non-resident file "
490 "name. You should run chkdsk.");
491 return -EIO;
492 }
493 if (attr->flags) {
494 ntfs_error(ctx->ntfs_ino->vol->sb, "File name with "
495 "invalid flags. You should run "
496 "chkdsk.");
497 return -EIO;
498 }
499 if (!(attr->data.resident.flags & RESIDENT_ATTR_IS_INDEXED)) {
500 ntfs_error(ctx->ntfs_ino->vol->sb, "Unindexed file "
501 "name. You should run chkdsk.");
502 return -EIO;
503 }
504 file_name_attr = (FILE_NAME_ATTR*)((u8*)attr +
505 le16_to_cpu(attr->data.resident.value_offset));
506 p2 = (u8*)attr + le32_to_cpu(attr->data.resident.value_length);
507 if (p2 < (u8*)attr || p2 > p)
508 goto err_corrupt_attr;
509
510 if (MREF_LE(file_name_attr->parent_directory) == FILE_Extend)
511 return 1;
512 }
513 if (unlikely(err != -ENOENT))
514 return err;
515 if (unlikely(nr_links)) {
516 ntfs_error(ctx->ntfs_ino->vol->sb, "Inode hard link count "
517 "doesn't match number of name attributes. You "
518 "should run chkdsk.");
519 return -EIO;
520 }
521 return 0;
522}
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550static int ntfs_read_locked_inode(struct inode *vi)
551{
552 ntfs_volume *vol = NTFS_SB(vi->i_sb);
553 ntfs_inode *ni;
554 struct inode *bvi;
555 MFT_RECORD *m;
556 ATTR_RECORD *a;
557 STANDARD_INFORMATION *si;
558 ntfs_attr_search_ctx *ctx;
559 int err = 0;
560
561 ntfs_debug("Entering for i_ino 0x%lx.", vi->i_ino);
562
563
564
565
566
567
568
569 vi->i_version = 1;
570
571 vi->i_uid = vol->uid;
572 vi->i_gid = vol->gid;
573 vi->i_mode = 0;
574
575
576
577
578
579 if (vi->i_ino != FILE_MFT)
580 ntfs_init_big_inode(vi);
581 ni = NTFS_I(vi);
582
583 m = map_mft_record(ni);
584 if (IS_ERR(m)) {
585 err = PTR_ERR(m);
586 goto err_out;
587 }
588 ctx = ntfs_attr_get_search_ctx(ni, m);
589 if (!ctx) {
590 err = -ENOMEM;
591 goto unm_err_out;
592 }
593
594 if (!(m->flags & MFT_RECORD_IN_USE)) {
595 ntfs_error(vi->i_sb, "Inode is not in use!");
596 goto unm_err_out;
597 }
598 if (m->base_mft_record) {
599 ntfs_error(vi->i_sb, "Inode is an extent inode!");
600 goto unm_err_out;
601 }
602
603
604 vi->i_generation = ni->seq_no = le16_to_cpu(m->sequence_number);
605
606
607
608
609
610
611
612
613
614
615 vi->i_nlink = le16_to_cpu(m->link_count);
616
617
618
619
620
621
622
623
624 vi->i_mode |= S_IRWXUGO;
625
626 if (IS_RDONLY(vi))
627 vi->i_mode &= ~S_IWUGO;
628 if (m->flags & MFT_RECORD_IS_DIRECTORY) {
629 vi->i_mode |= S_IFDIR;
630
631
632
633
634 vi->i_mode &= ~vol->dmask;
635
636 if (vi->i_nlink > 1)
637 vi->i_nlink = 1;
638 } else {
639 vi->i_mode |= S_IFREG;
640
641 vi->i_mode &= ~vol->fmask;
642 }
643
644
645
646
647
648
649 err = ntfs_attr_lookup(AT_STANDARD_INFORMATION, NULL, 0, 0, 0, NULL, 0,
650 ctx);
651 if (unlikely(err)) {
652 if (err == -ENOENT) {
653
654
655
656
657
658 ntfs_error(vi->i_sb, "$STANDARD_INFORMATION attribute "
659 "is missing.");
660 }
661 goto unm_err_out;
662 }
663 a = ctx->attr;
664
665 si = (STANDARD_INFORMATION*)((u8*)a +
666 le16_to_cpu(a->data.resident.value_offset));
667
668
669
670
671
672
673
674
675
676
677
678 vi->i_mtime = ntfs2utc(si->last_data_change_time);
679
680
681
682
683
684 vi->i_ctime = ntfs2utc(si->last_mft_change_time);
685
686
687
688
689 vi->i_atime = ntfs2utc(si->last_access_time);
690
691
692 ntfs_attr_reinit_search_ctx(ctx);
693 err = ntfs_attr_lookup(AT_ATTRIBUTE_LIST, NULL, 0, 0, 0, NULL, 0, ctx);
694 if (err) {
695 if (unlikely(err != -ENOENT)) {
696 ntfs_error(vi->i_sb, "Failed to lookup attribute list "
697 "attribute.");
698 goto unm_err_out;
699 }
700 } else {
701 if (vi->i_ino == FILE_MFT)
702 goto skip_attr_list_load;
703 ntfs_debug("Attribute list found in inode 0x%lx.", vi->i_ino);
704 NInoSetAttrList(ni);
705 a = ctx->attr;
706 if (a->flags & ATTR_COMPRESSION_MASK) {
707 ntfs_error(vi->i_sb, "Attribute list attribute is "
708 "compressed.");
709 goto unm_err_out;
710 }
711 if (a->flags & ATTR_IS_ENCRYPTED ||
712 a->flags & ATTR_IS_SPARSE) {
713 if (a->non_resident) {
714 ntfs_error(vi->i_sb, "Non-resident attribute "
715 "list attribute is encrypted/"
716 "sparse.");
717 goto unm_err_out;
718 }
719 ntfs_warning(vi->i_sb, "Resident attribute list "
720 "attribute in inode 0x%lx is marked "
721 "encrypted/sparse which is not true. "
722 "However, Windows allows this and "
723 "chkdsk does not detect or correct it "
724 "so we will just ignore the invalid "
725 "flags and pretend they are not set.",
726 vi->i_ino);
727 }
728
729 ni->attr_list_size = (u32)ntfs_attr_size(a);
730 ni->attr_list = ntfs_malloc_nofs(ni->attr_list_size);
731 if (!ni->attr_list) {
732 ntfs_error(vi->i_sb, "Not enough memory to allocate "
733 "buffer for attribute list.");
734 err = -ENOMEM;
735 goto unm_err_out;
736 }
737 if (a->non_resident) {
738 NInoSetAttrListNonResident(ni);
739 if (a->data.non_resident.lowest_vcn) {
740 ntfs_error(vi->i_sb, "Attribute list has non "
741 "zero lowest_vcn.");
742 goto unm_err_out;
743 }
744
745
746
747
748 ni->attr_list_rl.rl = ntfs_mapping_pairs_decompress(vol,
749 a, NULL);
750 if (IS_ERR(ni->attr_list_rl.rl)) {
751 err = PTR_ERR(ni->attr_list_rl.rl);
752 ni->attr_list_rl.rl = NULL;
753 ntfs_error(vi->i_sb, "Mapping pairs "
754 "decompression failed.");
755 goto unm_err_out;
756 }
757
758 if ((err = load_attribute_list(vol, &ni->attr_list_rl,
759 ni->attr_list, ni->attr_list_size,
760 sle64_to_cpu(a->data.non_resident.
761 initialized_size)))) {
762 ntfs_error(vi->i_sb, "Failed to load "
763 "attribute list attribute.");
764 goto unm_err_out;
765 }
766 } else {
767 if ((u8*)a + le16_to_cpu(a->data.resident.value_offset)
768 + le32_to_cpu(
769 a->data.resident.value_length) >
770 (u8*)ctx->mrec + vol->mft_record_size) {
771 ntfs_error(vi->i_sb, "Corrupt attribute list "
772 "in inode.");
773 goto unm_err_out;
774 }
775
776 memcpy(ni->attr_list, (u8*)a + le16_to_cpu(
777 a->data.resident.value_offset),
778 le32_to_cpu(
779 a->data.resident.value_length));
780 }
781 }
782skip_attr_list_load:
783
784
785
786
787 if (S_ISDIR(vi->i_mode)) {
788 loff_t bvi_size;
789 ntfs_inode *bni;
790 INDEX_ROOT *ir;
791 u8 *ir_end, *index_end;
792
793
794 ntfs_attr_reinit_search_ctx(ctx);
795 err = ntfs_attr_lookup(AT_INDEX_ROOT, I30, 4, CASE_SENSITIVE,
796 0, NULL, 0, ctx);
797 if (unlikely(err)) {
798 if (err == -ENOENT) {
799
800
801
802 ntfs_error(vi->i_sb, "$INDEX_ROOT attribute "
803 "is missing.");
804 }
805 goto unm_err_out;
806 }
807 a = ctx->attr;
808
809 if (unlikely(a->non_resident)) {
810 ntfs_error(vol->sb, "$INDEX_ROOT attribute is not "
811 "resident.");
812 goto unm_err_out;
813 }
814
815 if (unlikely(a->name_length && (le16_to_cpu(a->name_offset) >=
816 le16_to_cpu(a->data.resident.value_offset)))) {
817 ntfs_error(vol->sb, "$INDEX_ROOT attribute name is "
818 "placed after the attribute value.");
819 goto unm_err_out;
820 }
821
822
823
824
825
826
827 if (a->flags & ATTR_COMPRESSION_MASK)
828 NInoSetCompressed(ni);
829 if (a->flags & ATTR_IS_ENCRYPTED) {
830 if (a->flags & ATTR_COMPRESSION_MASK) {
831 ntfs_error(vi->i_sb, "Found encrypted and "
832 "compressed attribute.");
833 goto unm_err_out;
834 }
835 NInoSetEncrypted(ni);
836 }
837 if (a->flags & ATTR_IS_SPARSE)
838 NInoSetSparse(ni);
839 ir = (INDEX_ROOT*)((u8*)a +
840 le16_to_cpu(a->data.resident.value_offset));
841 ir_end = (u8*)ir + le32_to_cpu(a->data.resident.value_length);
842 if (ir_end > (u8*)ctx->mrec + vol->mft_record_size) {
843 ntfs_error(vi->i_sb, "$INDEX_ROOT attribute is "
844 "corrupt.");
845 goto unm_err_out;
846 }
847 index_end = (u8*)&ir->index +
848 le32_to_cpu(ir->index.index_length);
849 if (index_end > ir_end) {
850 ntfs_error(vi->i_sb, "Directory index is corrupt.");
851 goto unm_err_out;
852 }
853 if (ir->type != AT_FILE_NAME) {
854 ntfs_error(vi->i_sb, "Indexed attribute is not "
855 "$FILE_NAME.");
856 goto unm_err_out;
857 }
858 if (ir->collation_rule != COLLATION_FILE_NAME) {
859 ntfs_error(vi->i_sb, "Index collation rule is not "
860 "COLLATION_FILE_NAME.");
861 goto unm_err_out;
862 }
863 ni->itype.index.collation_rule = ir->collation_rule;
864 ni->itype.index.block_size = le32_to_cpu(ir->index_block_size);
865 if (ni->itype.index.block_size &
866 (ni->itype.index.block_size - 1)) {
867 ntfs_error(vi->i_sb, "Index block size (%u) is not a "
868 "power of two.",
869 ni->itype.index.block_size);
870 goto unm_err_out;
871 }
872 if (ni->itype.index.block_size > PAGE_CACHE_SIZE) {
873 ntfs_error(vi->i_sb, "Index block size (%u) > "
874 "PAGE_CACHE_SIZE (%ld) is not "
875 "supported. Sorry.",
876 ni->itype.index.block_size,
877 PAGE_CACHE_SIZE);
878 err = -EOPNOTSUPP;
879 goto unm_err_out;
880 }
881 if (ni->itype.index.block_size < NTFS_BLOCK_SIZE) {
882 ntfs_error(vi->i_sb, "Index block size (%u) < "
883 "NTFS_BLOCK_SIZE (%i) is not "
884 "supported. Sorry.",
885 ni->itype.index.block_size,
886 NTFS_BLOCK_SIZE);
887 err = -EOPNOTSUPP;
888 goto unm_err_out;
889 }
890 ni->itype.index.block_size_bits =
891 ffs(ni->itype.index.block_size) - 1;
892
893 if (vol->cluster_size <= ni->itype.index.block_size) {
894 ni->itype.index.vcn_size = vol->cluster_size;
895 ni->itype.index.vcn_size_bits = vol->cluster_size_bits;
896 } else {
897 ni->itype.index.vcn_size = vol->sector_size;
898 ni->itype.index.vcn_size_bits = vol->sector_size_bits;
899 }
900
901
902 NInoSetMstProtected(ni);
903 ni->type = AT_INDEX_ALLOCATION;
904 ni->name = I30;
905 ni->name_len = 4;
906
907 if (!(ir->index.flags & LARGE_INDEX)) {
908
909 vi->i_size = ni->initialized_size =
910 ni->allocated_size = 0;
911
912 ntfs_attr_put_search_ctx(ctx);
913 unmap_mft_record(ni);
914 m = NULL;
915 ctx = NULL;
916 goto skip_large_dir_stuff;
917 }
918 NInoSetIndexAllocPresent(ni);
919
920 ntfs_attr_reinit_search_ctx(ctx);
921 err = ntfs_attr_lookup(AT_INDEX_ALLOCATION, I30, 4,
922 CASE_SENSITIVE, 0, NULL, 0, ctx);
923 if (unlikely(err)) {
924 if (err == -ENOENT)
925 ntfs_error(vi->i_sb, "$INDEX_ALLOCATION "
926 "attribute is not present but "
927 "$INDEX_ROOT indicated it is.");
928 else
929 ntfs_error(vi->i_sb, "Failed to lookup "
930 "$INDEX_ALLOCATION "
931 "attribute.");
932 goto unm_err_out;
933 }
934 a = ctx->attr;
935 if (!a->non_resident) {
936 ntfs_error(vi->i_sb, "$INDEX_ALLOCATION attribute "
937 "is resident.");
938 goto unm_err_out;
939 }
940
941
942
943
944 if (unlikely(a->name_length && (le16_to_cpu(a->name_offset) >=
945 le16_to_cpu(
946 a->data.non_resident.mapping_pairs_offset)))) {
947 ntfs_error(vol->sb, "$INDEX_ALLOCATION attribute name "
948 "is placed after the mapping pairs "
949 "array.");
950 goto unm_err_out;
951 }
952 if (a->flags & ATTR_IS_ENCRYPTED) {
953 ntfs_error(vi->i_sb, "$INDEX_ALLOCATION attribute "
954 "is encrypted.");
955 goto unm_err_out;
956 }
957 if (a->flags & ATTR_IS_SPARSE) {
958 ntfs_error(vi->i_sb, "$INDEX_ALLOCATION attribute "
959 "is sparse.");
960 goto unm_err_out;
961 }
962 if (a->flags & ATTR_COMPRESSION_MASK) {
963 ntfs_error(vi->i_sb, "$INDEX_ALLOCATION attribute "
964 "is compressed.");
965 goto unm_err_out;
966 }
967 if (a->data.non_resident.lowest_vcn) {
968 ntfs_error(vi->i_sb, "First extent of "
969 "$INDEX_ALLOCATION attribute has non "
970 "zero lowest_vcn.");
971 goto unm_err_out;
972 }
973 vi->i_size = sle64_to_cpu(a->data.non_resident.data_size);
974 ni->initialized_size = sle64_to_cpu(
975 a->data.non_resident.initialized_size);
976 ni->allocated_size = sle64_to_cpu(
977 a->data.non_resident.allocated_size);
978
979
980
981
982 ntfs_attr_put_search_ctx(ctx);
983 unmap_mft_record(ni);
984 m = NULL;
985 ctx = NULL;
986
987 bvi = ntfs_attr_iget(vi, AT_BITMAP, I30, 4);
988 if (IS_ERR(bvi)) {
989 ntfs_error(vi->i_sb, "Failed to get bitmap attribute.");
990 err = PTR_ERR(bvi);
991 goto unm_err_out;
992 }
993 bni = NTFS_I(bvi);
994 if (NInoCompressed(bni) || NInoEncrypted(bni) ||
995 NInoSparse(bni)) {
996 ntfs_error(vi->i_sb, "$BITMAP attribute is compressed "
997 "and/or encrypted and/or sparse.");
998 goto iput_unm_err_out;
999 }
1000
1001 bvi_size = i_size_read(bvi);
1002 if ((bvi_size << 3) < (vi->i_size >>
1003 ni->itype.index.block_size_bits)) {
1004 ntfs_error(vi->i_sb, "Index bitmap too small (0x%llx) "
1005 "for index allocation (0x%llx).",
1006 bvi_size << 3, vi->i_size);
1007 goto iput_unm_err_out;
1008 }
1009
1010 iput(bvi);
1011skip_large_dir_stuff:
1012
1013 vi->i_op = &ntfs_dir_inode_ops;
1014 vi->i_fop = &ntfs_dir_ops;
1015 } else {
1016
1017 ntfs_attr_reinit_search_ctx(ctx);
1018
1019
1020 ni->type = AT_DATA;
1021 ni->name = NULL;
1022 ni->name_len = 0;
1023
1024
1025 err = ntfs_attr_lookup(AT_DATA, NULL, 0, 0, 0, NULL, 0, ctx);
1026 if (unlikely(err)) {
1027 vi->i_size = ni->initialized_size =
1028 ni->allocated_size = 0;
1029 if (err != -ENOENT) {
1030 ntfs_error(vi->i_sb, "Failed to lookup $DATA "
1031 "attribute.");
1032 goto unm_err_out;
1033 }
1034
1035
1036
1037
1038 if (vi->i_ino == FILE_Secure)
1039 goto no_data_attr_special_case;
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049 if (ntfs_is_extended_system_file(ctx) > 0)
1050 goto no_data_attr_special_case;
1051
1052
1053 ntfs_error(vi->i_sb, "$DATA attribute is missing.");
1054 goto unm_err_out;
1055 }
1056 a = ctx->attr;
1057
1058 if (a->flags & (ATTR_COMPRESSION_MASK | ATTR_IS_SPARSE)) {
1059 if (a->flags & ATTR_COMPRESSION_MASK) {
1060 NInoSetCompressed(ni);
1061 if (vol->cluster_size > 4096) {
1062 ntfs_error(vi->i_sb, "Found "
1063 "compressed data but "
1064 "compression is "
1065 "disabled due to "
1066 "cluster size (%i) > "
1067 "4kiB.",
1068 vol->cluster_size);
1069 goto unm_err_out;
1070 }
1071 if ((a->flags & ATTR_COMPRESSION_MASK)
1072 != ATTR_IS_COMPRESSED) {
1073 ntfs_error(vi->i_sb, "Found unknown "
1074 "compression method "
1075 "or corrupt file.");
1076 goto unm_err_out;
1077 }
1078 }
1079 if (a->flags & ATTR_IS_SPARSE)
1080 NInoSetSparse(ni);
1081 }
1082 if (a->flags & ATTR_IS_ENCRYPTED) {
1083 if (NInoCompressed(ni)) {
1084 ntfs_error(vi->i_sb, "Found encrypted and "
1085 "compressed data.");
1086 goto unm_err_out;
1087 }
1088 NInoSetEncrypted(ni);
1089 }
1090 if (a->non_resident) {
1091 NInoSetNonResident(ni);
1092 if (NInoCompressed(ni) || NInoSparse(ni)) {
1093 if (NInoCompressed(ni) && a->data.non_resident.
1094 compression_unit != 4) {
1095 ntfs_error(vi->i_sb, "Found "
1096 "non-standard "
1097 "compression unit (%u "
1098 "instead of 4). "
1099 "Cannot handle this.",
1100 a->data.non_resident.
1101 compression_unit);
1102 err = -EOPNOTSUPP;
1103 goto unm_err_out;
1104 }
1105 if (a->data.non_resident.compression_unit) {
1106 ni->itype.compressed.block_size = 1U <<
1107 (a->data.non_resident.
1108 compression_unit +
1109 vol->cluster_size_bits);
1110 ni->itype.compressed.block_size_bits =
1111 ffs(ni->itype.
1112 compressed.
1113 block_size) - 1;
1114 ni->itype.compressed.block_clusters =
1115 1U << a->data.
1116 non_resident.
1117 compression_unit;
1118 } else {
1119 ni->itype.compressed.block_size = 0;
1120 ni->itype.compressed.block_size_bits =
1121 0;
1122 ni->itype.compressed.block_clusters =
1123 0;
1124 }
1125 ni->itype.compressed.size = sle64_to_cpu(
1126 a->data.non_resident.
1127 compressed_size);
1128 }
1129 if (a->data.non_resident.lowest_vcn) {
1130 ntfs_error(vi->i_sb, "First extent of $DATA "
1131 "attribute has non zero "
1132 "lowest_vcn.");
1133 goto unm_err_out;
1134 }
1135 vi->i_size = sle64_to_cpu(
1136 a->data.non_resident.data_size);
1137 ni->initialized_size = sle64_to_cpu(
1138 a->data.non_resident.initialized_size);
1139 ni->allocated_size = sle64_to_cpu(
1140 a->data.non_resident.allocated_size);
1141 } else {
1142 vi->i_size = ni->initialized_size = le32_to_cpu(
1143 a->data.resident.value_length);
1144 ni->allocated_size = le32_to_cpu(a->length) -
1145 le16_to_cpu(
1146 a->data.resident.value_offset);
1147 if (vi->i_size > ni->allocated_size) {
1148 ntfs_error(vi->i_sb, "Resident data attribute "
1149 "is corrupt (size exceeds "
1150 "allocation).");
1151 goto unm_err_out;
1152 }
1153 }
1154no_data_attr_special_case:
1155
1156 ntfs_attr_put_search_ctx(ctx);
1157 unmap_mft_record(ni);
1158 m = NULL;
1159 ctx = NULL;
1160
1161 vi->i_op = &ntfs_file_inode_ops;
1162 vi->i_fop = &ntfs_file_ops;
1163 }
1164 if (NInoMstProtected(ni))
1165 vi->i_mapping->a_ops = &ntfs_mst_aops;
1166 else
1167 vi->i_mapping->a_ops = &ntfs_aops;
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179 if (S_ISREG(vi->i_mode) && (NInoCompressed(ni) || NInoSparse(ni)))
1180 vi->i_blocks = ni->itype.compressed.size >> 9;
1181 else
1182 vi->i_blocks = ni->allocated_size >> 9;
1183 ntfs_debug("Done.");
1184 return 0;
1185iput_unm_err_out:
1186 iput(bvi);
1187unm_err_out:
1188 if (!err)
1189 err = -EIO;
1190 if (ctx)
1191 ntfs_attr_put_search_ctx(ctx);
1192 if (m)
1193 unmap_mft_record(ni);
1194err_out:
1195 ntfs_error(vol->sb, "Failed with error code %i. Marking corrupt "
1196 "inode 0x%lx as bad. Run chkdsk.", err, vi->i_ino);
1197 make_bad_inode(vi);
1198 if (err != -EOPNOTSUPP && err != -ENOMEM)
1199 NVolSetErrors(vol);
1200 return err;
1201}
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225static int ntfs_read_locked_attr_inode(struct inode *base_vi, struct inode *vi)
1226{
1227 ntfs_volume *vol = NTFS_SB(vi->i_sb);
1228 ntfs_inode *ni, *base_ni;
1229 MFT_RECORD *m;
1230 ATTR_RECORD *a;
1231 ntfs_attr_search_ctx *ctx;
1232 int err = 0;
1233
1234 ntfs_debug("Entering for i_ino 0x%lx.", vi->i_ino);
1235
1236 ntfs_init_big_inode(vi);
1237
1238 ni = NTFS_I(vi);
1239 base_ni = NTFS_I(base_vi);
1240
1241
1242 vi->i_version = base_vi->i_version;
1243 vi->i_uid = base_vi->i_uid;
1244 vi->i_gid = base_vi->i_gid;
1245 vi->i_nlink = base_vi->i_nlink;
1246 vi->i_mtime = base_vi->i_mtime;
1247 vi->i_ctime = base_vi->i_ctime;
1248 vi->i_atime = base_vi->i_atime;
1249 vi->i_generation = ni->seq_no = base_ni->seq_no;
1250
1251
1252 vi->i_mode = base_vi->i_mode & ~S_IFMT;
1253
1254 m = map_mft_record(base_ni);
1255 if (IS_ERR(m)) {
1256 err = PTR_ERR(m);
1257 goto err_out;
1258 }
1259 ctx = ntfs_attr_get_search_ctx(base_ni, m);
1260 if (!ctx) {
1261 err = -ENOMEM;
1262 goto unm_err_out;
1263 }
1264
1265 err = ntfs_attr_lookup(ni->type, ni->name, ni->name_len,
1266 CASE_SENSITIVE, 0, NULL, 0, ctx);
1267 if (unlikely(err))
1268 goto unm_err_out;
1269 a = ctx->attr;
1270 if (a->flags & (ATTR_COMPRESSION_MASK | ATTR_IS_SPARSE)) {
1271 if (a->flags & ATTR_COMPRESSION_MASK) {
1272 NInoSetCompressed(ni);
1273 if ((ni->type != AT_DATA) || (ni->type == AT_DATA &&
1274 ni->name_len)) {
1275 ntfs_error(vi->i_sb, "Found compressed "
1276 "non-data or named data "
1277 "attribute. Please report "
1278 "you saw this message to "
1279 "linux-ntfs-dev@lists."
1280 "sourceforge.net");
1281 goto unm_err_out;
1282 }
1283 if (vol->cluster_size > 4096) {
1284 ntfs_error(vi->i_sb, "Found compressed "
1285 "attribute but compression is "
1286 "disabled due to cluster size "
1287 "(%i) > 4kiB.",
1288 vol->cluster_size);
1289 goto unm_err_out;
1290 }
1291 if ((a->flags & ATTR_COMPRESSION_MASK) !=
1292 ATTR_IS_COMPRESSED) {
1293 ntfs_error(vi->i_sb, "Found unknown "
1294 "compression method.");
1295 goto unm_err_out;
1296 }
1297 }
1298
1299
1300
1301
1302 if (NInoMstProtected(ni) && ni->type != AT_INDEX_ROOT) {
1303 ntfs_error(vi->i_sb, "Found mst protected attribute "
1304 "but the attribute is %s. Please "
1305 "report you saw this message to "
1306 "linux-ntfs-dev@lists.sourceforge.net",
1307 NInoCompressed(ni) ? "compressed" :
1308 "sparse");
1309 goto unm_err_out;
1310 }
1311 if (a->flags & ATTR_IS_SPARSE)
1312 NInoSetSparse(ni);
1313 }
1314 if (a->flags & ATTR_IS_ENCRYPTED) {
1315 if (NInoCompressed(ni)) {
1316 ntfs_error(vi->i_sb, "Found encrypted and compressed "
1317 "data.");
1318 goto unm_err_out;
1319 }
1320
1321
1322
1323
1324 if (NInoMstProtected(ni) && ni->type != AT_INDEX_ROOT) {
1325 ntfs_error(vi->i_sb, "Found mst protected attribute "
1326 "but the attribute is encrypted. "
1327 "Please report you saw this message "
1328 "to linux-ntfs-dev@lists.sourceforge."
1329 "net");
1330 goto unm_err_out;
1331 }
1332 if (ni->type != AT_DATA) {
1333 ntfs_error(vi->i_sb, "Found encrypted non-data "
1334 "attribute.");
1335 goto unm_err_out;
1336 }
1337 NInoSetEncrypted(ni);
1338 }
1339 if (!a->non_resident) {
1340
1341 if (unlikely(a->name_length && (le16_to_cpu(a->name_offset) >=
1342 le16_to_cpu(a->data.resident.value_offset)))) {
1343 ntfs_error(vol->sb, "Attribute name is placed after "
1344 "the attribute value.");
1345 goto unm_err_out;
1346 }
1347 if (NInoMstProtected(ni)) {
1348 ntfs_error(vi->i_sb, "Found mst protected attribute "
1349 "but the attribute is resident. "
1350 "Please report you saw this message to "
1351 "linux-ntfs-dev@lists.sourceforge.net");
1352 goto unm_err_out;
1353 }
1354 vi->i_size = ni->initialized_size = le32_to_cpu(
1355 a->data.resident.value_length);
1356 ni->allocated_size = le32_to_cpu(a->length) -
1357 le16_to_cpu(a->data.resident.value_offset);
1358 if (vi->i_size > ni->allocated_size) {
1359 ntfs_error(vi->i_sb, "Resident attribute is corrupt "
1360 "(size exceeds allocation).");
1361 goto unm_err_out;
1362 }
1363 } else {
1364 NInoSetNonResident(ni);
1365
1366
1367
1368
1369 if (unlikely(a->name_length && (le16_to_cpu(a->name_offset) >=
1370 le16_to_cpu(
1371 a->data.non_resident.mapping_pairs_offset)))) {
1372 ntfs_error(vol->sb, "Attribute name is placed after "
1373 "the mapping pairs array.");
1374 goto unm_err_out;
1375 }
1376 if (NInoCompressed(ni) || NInoSparse(ni)) {
1377 if (NInoCompressed(ni) && a->data.non_resident.
1378 compression_unit != 4) {
1379 ntfs_error(vi->i_sb, "Found non-standard "
1380 "compression unit (%u instead "
1381 "of 4). Cannot handle this.",
1382 a->data.non_resident.
1383 compression_unit);
1384 err = -EOPNOTSUPP;
1385 goto unm_err_out;
1386 }
1387 if (a->data.non_resident.compression_unit) {
1388 ni->itype.compressed.block_size = 1U <<
1389 (a->data.non_resident.
1390 compression_unit +
1391 vol->cluster_size_bits);
1392 ni->itype.compressed.block_size_bits =
1393 ffs(ni->itype.compressed.
1394 block_size) - 1;
1395 ni->itype.compressed.block_clusters = 1U <<
1396 a->data.non_resident.
1397 compression_unit;
1398 } else {
1399 ni->itype.compressed.block_size = 0;
1400 ni->itype.compressed.block_size_bits = 0;
1401 ni->itype.compressed.block_clusters = 0;
1402 }
1403 ni->itype.compressed.size = sle64_to_cpu(
1404 a->data.non_resident.compressed_size);
1405 }
1406 if (a->data.non_resident.lowest_vcn) {
1407 ntfs_error(vi->i_sb, "First extent of attribute has "
1408 "non-zero lowest_vcn.");
1409 goto unm_err_out;
1410 }
1411 vi->i_size = sle64_to_cpu(a->data.non_resident.data_size);
1412 ni->initialized_size = sle64_to_cpu(
1413 a->data.non_resident.initialized_size);
1414 ni->allocated_size = sle64_to_cpu(
1415 a->data.non_resident.allocated_size);
1416 }
1417 if (NInoMstProtected(ni))
1418 vi->i_mapping->a_ops = &ntfs_mst_aops;
1419 else
1420 vi->i_mapping->a_ops = &ntfs_aops;
1421 if ((NInoCompressed(ni) || NInoSparse(ni)) && ni->type != AT_INDEX_ROOT)
1422 vi->i_blocks = ni->itype.compressed.size >> 9;
1423 else
1424 vi->i_blocks = ni->allocated_size >> 9;
1425
1426
1427
1428
1429 igrab(base_vi);
1430 ni->ext.base_ntfs_ino = base_ni;
1431 ni->nr_extents = -1;
1432
1433 ntfs_attr_put_search_ctx(ctx);
1434 unmap_mft_record(base_ni);
1435
1436 ntfs_debug("Done.");
1437 return 0;
1438
1439unm_err_out:
1440 if (!err)
1441 err = -EIO;
1442 if (ctx)
1443 ntfs_attr_put_search_ctx(ctx);
1444 unmap_mft_record(base_ni);
1445err_out:
1446 ntfs_error(vol->sb, "Failed with error code %i while reading attribute "
1447 "inode (mft_no 0x%lx, type 0x%x, name_len %i). "
1448 "Marking corrupt inode and base inode 0x%lx as bad. "
1449 "Run chkdsk.", err, vi->i_ino, ni->type, ni->name_len,
1450 base_vi->i_ino);
1451 make_bad_inode(vi);
1452 if (err != -ENOMEM)
1453 NVolSetErrors(vol);
1454 return err;
1455}
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490static int ntfs_read_locked_index_inode(struct inode *base_vi, struct inode *vi)
1491{
1492 loff_t bvi_size;
1493 ntfs_volume *vol = NTFS_SB(vi->i_sb);
1494 ntfs_inode *ni, *base_ni, *bni;
1495 struct inode *bvi;
1496 MFT_RECORD *m;
1497 ATTR_RECORD *a;
1498 ntfs_attr_search_ctx *ctx;
1499 INDEX_ROOT *ir;
1500 u8 *ir_end, *index_end;
1501 int err = 0;
1502
1503 ntfs_debug("Entering for i_ino 0x%lx.", vi->i_ino);
1504 ntfs_init_big_inode(vi);
1505 ni = NTFS_I(vi);
1506 base_ni = NTFS_I(base_vi);
1507
1508 vi->i_version = base_vi->i_version;
1509 vi->i_uid = base_vi->i_uid;
1510 vi->i_gid = base_vi->i_gid;
1511 vi->i_nlink = base_vi->i_nlink;
1512 vi->i_mtime = base_vi->i_mtime;
1513 vi->i_ctime = base_vi->i_ctime;
1514 vi->i_atime = base_vi->i_atime;
1515 vi->i_generation = ni->seq_no = base_ni->seq_no;
1516
1517 vi->i_mode = base_vi->i_mode & ~S_IFMT;
1518
1519 m = map_mft_record(base_ni);
1520 if (IS_ERR(m)) {
1521 err = PTR_ERR(m);
1522 goto err_out;
1523 }
1524 ctx = ntfs_attr_get_search_ctx(base_ni, m);
1525 if (!ctx) {
1526 err = -ENOMEM;
1527 goto unm_err_out;
1528 }
1529
1530 err = ntfs_attr_lookup(AT_INDEX_ROOT, ni->name, ni->name_len,
1531 CASE_SENSITIVE, 0, NULL, 0, ctx);
1532 if (unlikely(err)) {
1533 if (err == -ENOENT)
1534 ntfs_error(vi->i_sb, "$INDEX_ROOT attribute is "
1535 "missing.");
1536 goto unm_err_out;
1537 }
1538 a = ctx->attr;
1539
1540 if (unlikely(a->non_resident)) {
1541 ntfs_error(vol->sb, "$INDEX_ROOT attribute is not resident.");
1542 goto unm_err_out;
1543 }
1544
1545 if (unlikely(a->name_length && (le16_to_cpu(a->name_offset) >=
1546 le16_to_cpu(a->data.resident.value_offset)))) {
1547 ntfs_error(vol->sb, "$INDEX_ROOT attribute name is placed "
1548 "after the attribute value.");
1549 goto unm_err_out;
1550 }
1551
1552
1553
1554
1555 if (a->flags & (ATTR_COMPRESSION_MASK | ATTR_IS_ENCRYPTED |
1556 ATTR_IS_SPARSE)) {
1557 ntfs_error(vi->i_sb, "Found compressed/encrypted/sparse index "
1558 "root attribute.");
1559 goto unm_err_out;
1560 }
1561 ir = (INDEX_ROOT*)((u8*)a + le16_to_cpu(a->data.resident.value_offset));
1562 ir_end = (u8*)ir + le32_to_cpu(a->data.resident.value_length);
1563 if (ir_end > (u8*)ctx->mrec + vol->mft_record_size) {
1564 ntfs_error(vi->i_sb, "$INDEX_ROOT attribute is corrupt.");
1565 goto unm_err_out;
1566 }
1567 index_end = (u8*)&ir->index + le32_to_cpu(ir->index.index_length);
1568 if (index_end > ir_end) {
1569 ntfs_error(vi->i_sb, "Index is corrupt.");
1570 goto unm_err_out;
1571 }
1572 if (ir->type) {
1573 ntfs_error(vi->i_sb, "Index type is not 0 (type is 0x%x).",
1574 le32_to_cpu(ir->type));
1575 goto unm_err_out;
1576 }
1577 ni->itype.index.collation_rule = ir->collation_rule;
1578 ntfs_debug("Index collation rule is 0x%x.",
1579 le32_to_cpu(ir->collation_rule));
1580 ni->itype.index.block_size = le32_to_cpu(ir->index_block_size);
1581 if (!is_power_of_2(ni->itype.index.block_size)) {
1582 ntfs_error(vi->i_sb, "Index block size (%u) is not a power of "
1583 "two.", ni->itype.index.block_size);
1584 goto unm_err_out;
1585 }
1586 if (ni->itype.index.block_size > PAGE_CACHE_SIZE) {
1587 ntfs_error(vi->i_sb, "Index block size (%u) > PAGE_CACHE_SIZE "
1588 "(%ld) is not supported. Sorry.",
1589 ni->itype.index.block_size, PAGE_CACHE_SIZE);
1590 err = -EOPNOTSUPP;
1591 goto unm_err_out;
1592 }
1593 if (ni->itype.index.block_size < NTFS_BLOCK_SIZE) {
1594 ntfs_error(vi->i_sb, "Index block size (%u) < NTFS_BLOCK_SIZE "
1595 "(%i) is not supported. Sorry.",
1596 ni->itype.index.block_size, NTFS_BLOCK_SIZE);
1597 err = -EOPNOTSUPP;
1598 goto unm_err_out;
1599 }
1600 ni->itype.index.block_size_bits = ffs(ni->itype.index.block_size) - 1;
1601
1602 if (vol->cluster_size <= ni->itype.index.block_size) {
1603 ni->itype.index.vcn_size = vol->cluster_size;
1604 ni->itype.index.vcn_size_bits = vol->cluster_size_bits;
1605 } else {
1606 ni->itype.index.vcn_size = vol->sector_size;
1607 ni->itype.index.vcn_size_bits = vol->sector_size_bits;
1608 }
1609
1610 if (!(ir->index.flags & LARGE_INDEX)) {
1611
1612 vi->i_size = ni->initialized_size = ni->allocated_size = 0;
1613
1614 ntfs_attr_put_search_ctx(ctx);
1615 unmap_mft_record(base_ni);
1616 m = NULL;
1617 ctx = NULL;
1618 goto skip_large_index_stuff;
1619 }
1620 NInoSetIndexAllocPresent(ni);
1621
1622 ntfs_attr_reinit_search_ctx(ctx);
1623 err = ntfs_attr_lookup(AT_INDEX_ALLOCATION, ni->name, ni->name_len,
1624 CASE_SENSITIVE, 0, NULL, 0, ctx);
1625 if (unlikely(err)) {
1626 if (err == -ENOENT)
1627 ntfs_error(vi->i_sb, "$INDEX_ALLOCATION attribute is "
1628 "not present but $INDEX_ROOT "
1629 "indicated it is.");
1630 else
1631 ntfs_error(vi->i_sb, "Failed to lookup "
1632 "$INDEX_ALLOCATION attribute.");
1633 goto unm_err_out;
1634 }
1635 a = ctx->attr;
1636 if (!a->non_resident) {
1637 ntfs_error(vi->i_sb, "$INDEX_ALLOCATION attribute is "
1638 "resident.");
1639 goto unm_err_out;
1640 }
1641
1642
1643
1644 if (unlikely(a->name_length && (le16_to_cpu(a->name_offset) >=
1645 le16_to_cpu(
1646 a->data.non_resident.mapping_pairs_offset)))) {
1647 ntfs_error(vol->sb, "$INDEX_ALLOCATION attribute name is "
1648 "placed after the mapping pairs array.");
1649 goto unm_err_out;
1650 }
1651 if (a->flags & ATTR_IS_ENCRYPTED) {
1652 ntfs_error(vi->i_sb, "$INDEX_ALLOCATION attribute is "
1653 "encrypted.");
1654 goto unm_err_out;
1655 }
1656 if (a->flags & ATTR_IS_SPARSE) {
1657 ntfs_error(vi->i_sb, "$INDEX_ALLOCATION attribute is sparse.");
1658 goto unm_err_out;
1659 }
1660 if (a->flags & ATTR_COMPRESSION_MASK) {
1661 ntfs_error(vi->i_sb, "$INDEX_ALLOCATION attribute is "
1662 "compressed.");
1663 goto unm_err_out;
1664 }
1665 if (a->data.non_resident.lowest_vcn) {
1666 ntfs_error(vi->i_sb, "First extent of $INDEX_ALLOCATION "
1667 "attribute has non zero lowest_vcn.");
1668 goto unm_err_out;
1669 }
1670 vi->i_size = sle64_to_cpu(a->data.non_resident.data_size);
1671 ni->initialized_size = sle64_to_cpu(
1672 a->data.non_resident.initialized_size);
1673 ni->allocated_size = sle64_to_cpu(a->data.non_resident.allocated_size);
1674
1675
1676
1677
1678 ntfs_attr_put_search_ctx(ctx);
1679 unmap_mft_record(base_ni);
1680 m = NULL;
1681 ctx = NULL;
1682
1683 bvi = ntfs_attr_iget(base_vi, AT_BITMAP, ni->name, ni->name_len);
1684 if (IS_ERR(bvi)) {
1685 ntfs_error(vi->i_sb, "Failed to get bitmap attribute.");
1686 err = PTR_ERR(bvi);
1687 goto unm_err_out;
1688 }
1689 bni = NTFS_I(bvi);
1690 if (NInoCompressed(bni) || NInoEncrypted(bni) ||
1691 NInoSparse(bni)) {
1692 ntfs_error(vi->i_sb, "$BITMAP attribute is compressed and/or "
1693 "encrypted and/or sparse.");
1694 goto iput_unm_err_out;
1695 }
1696
1697 bvi_size = i_size_read(bvi);
1698 if ((bvi_size << 3) < (vi->i_size >> ni->itype.index.block_size_bits)) {
1699 ntfs_error(vi->i_sb, "Index bitmap too small (0x%llx) for "
1700 "index allocation (0x%llx).", bvi_size << 3,
1701 vi->i_size);
1702 goto iput_unm_err_out;
1703 }
1704 iput(bvi);
1705skip_large_index_stuff:
1706
1707 vi->i_op = NULL;
1708 vi->i_fop = NULL;
1709 vi->i_mapping->a_ops = &ntfs_mst_aops;
1710 vi->i_blocks = ni->allocated_size >> 9;
1711
1712
1713
1714
1715 igrab(base_vi);
1716 ni->ext.base_ntfs_ino = base_ni;
1717 ni->nr_extents = -1;
1718
1719 ntfs_debug("Done.");
1720 return 0;
1721iput_unm_err_out:
1722 iput(bvi);
1723unm_err_out:
1724 if (!err)
1725 err = -EIO;
1726 if (ctx)
1727 ntfs_attr_put_search_ctx(ctx);
1728 if (m)
1729 unmap_mft_record(base_ni);
1730err_out:
1731 ntfs_error(vi->i_sb, "Failed with error code %i while reading index "
1732 "inode (mft_no 0x%lx, name_len %i.", err, vi->i_ino,
1733 ni->name_len);
1734 make_bad_inode(vi);
1735 if (err != -EOPNOTSUPP && err != -ENOMEM)
1736 NVolSetErrors(vol);
1737 return err;
1738}
1739
1740
1741
1742
1743
1744
1745
1746
1747static struct lock_class_key mft_ni_runlist_lock_key, mft_ni_mrec_lock_key;
1748
1749
1750
1751
1752
1753
1754
1755
1756
1757
1758
1759
1760
1761
1762
1763
1764
1765
1766
1767
1768
1769
1770
1771
1772
1773
1774
1775int ntfs_read_inode_mount(struct inode *vi)
1776{
1777 VCN next_vcn, last_vcn, highest_vcn;
1778 s64 block;
1779 struct super_block *sb = vi->i_sb;
1780 ntfs_volume *vol = NTFS_SB(sb);
1781 struct buffer_head *bh;
1782 ntfs_inode *ni;
1783 MFT_RECORD *m = NULL;
1784 ATTR_RECORD *a;
1785 ntfs_attr_search_ctx *ctx;
1786 unsigned int i, nr_blocks;
1787 int err;
1788
1789 ntfs_debug("Entering.");
1790
1791
1792 ntfs_init_big_inode(vi);
1793
1794 ni = NTFS_I(vi);
1795
1796
1797 NInoSetNonResident(ni);
1798 NInoSetMstProtected(ni);
1799 NInoSetSparseDisabled(ni);
1800 ni->type = AT_DATA;
1801 ni->name = NULL;
1802 ni->name_len = 0;
1803
1804
1805
1806
1807 ni->itype.index.block_size = vol->mft_record_size;
1808 ni->itype.index.block_size_bits = vol->mft_record_size_bits;
1809
1810
1811 vol->mft_ino = vi;
1812
1813
1814 if (vol->mft_record_size > 64 * 1024) {
1815 ntfs_error(sb, "Unsupported mft record size %i (max 64kiB).",
1816 vol->mft_record_size);
1817 goto err_out;
1818 }
1819 i = vol->mft_record_size;
1820 if (i < sb->s_blocksize)
1821 i = sb->s_blocksize;
1822 m = (MFT_RECORD*)ntfs_malloc_nofs(i);
1823 if (!m) {
1824 ntfs_error(sb, "Failed to allocate buffer for $MFT record 0.");
1825 goto err_out;
1826 }
1827
1828
1829 block = vol->mft_lcn << vol->cluster_size_bits >>
1830 sb->s_blocksize_bits;
1831 nr_blocks = vol->mft_record_size >> sb->s_blocksize_bits;
1832 if (!nr_blocks)
1833 nr_blocks = 1;
1834
1835
1836 for (i = 0; i < nr_blocks; i++) {
1837 bh = sb_bread(sb, block++);
1838 if (!bh) {
1839 ntfs_error(sb, "Device read failed.");
1840 goto err_out;
1841 }
1842 memcpy((char*)m + (i << sb->s_blocksize_bits), bh->b_data,
1843 sb->s_blocksize);
1844 brelse(bh);
1845 }
1846
1847
1848 if (post_read_mst_fixup((NTFS_RECORD*)m, vol->mft_record_size)) {
1849
1850 ntfs_error(sb, "MST fixup failed. $MFT is corrupt.");
1851 goto err_out;
1852 }
1853
1854
1855 vi->i_generation = ni->seq_no = le16_to_cpu(m->sequence_number);
1856
1857
1858 vi->i_mapping->a_ops = &ntfs_mst_aops;
1859
1860 ctx = ntfs_attr_get_search_ctx(ni, m);
1861 if (!ctx) {
1862 err = -ENOMEM;
1863 goto err_out;
1864 }
1865
1866
1867 err = ntfs_attr_lookup(AT_ATTRIBUTE_LIST, NULL, 0, 0, 0, NULL, 0, ctx);
1868 if (err) {
1869 if (unlikely(err != -ENOENT)) {
1870 ntfs_error(sb, "Failed to lookup attribute list "
1871 "attribute. You should run chkdsk.");
1872 goto put_err_out;
1873 }
1874 } else {
1875 ATTR_LIST_ENTRY *al_entry, *next_al_entry;
1876 u8 *al_end;
1877 static const char *es = " Not allowed. $MFT is corrupt. "
1878 "You should run chkdsk.";
1879
1880 ntfs_debug("Attribute list attribute found in $MFT.");
1881 NInoSetAttrList(ni);
1882 a = ctx->attr;
1883 if (a->flags & ATTR_COMPRESSION_MASK) {
1884 ntfs_error(sb, "Attribute list attribute is "
1885 "compressed.%s", es);
1886 goto put_err_out;
1887 }
1888 if (a->flags & ATTR_IS_ENCRYPTED ||
1889 a->flags & ATTR_IS_SPARSE) {
1890 if (a->non_resident) {
1891 ntfs_error(sb, "Non-resident attribute list "
1892 "attribute is encrypted/"
1893 "sparse.%s", es);
1894 goto put_err_out;
1895 }
1896 ntfs_warning(sb, "Resident attribute list attribute "
1897 "in $MFT system file is marked "
1898 "encrypted/sparse which is not true. "
1899 "However, Windows allows this and "
1900 "chkdsk does not detect or correct it "
1901 "so we will just ignore the invalid "
1902 "flags and pretend they are not set.");
1903 }
1904
1905 ni->attr_list_size = (u32)ntfs_attr_size(a);
1906 ni->attr_list = ntfs_malloc_nofs(ni->attr_list_size);
1907 if (!ni->attr_list) {
1908 ntfs_error(sb, "Not enough memory to allocate buffer "
1909 "for attribute list.");
1910 goto put_err_out;
1911 }
1912 if (a->non_resident) {
1913 NInoSetAttrListNonResident(ni);
1914 if (a->data.non_resident.lowest_vcn) {
1915 ntfs_error(sb, "Attribute list has non zero "
1916 "lowest_vcn. $MFT is corrupt. "
1917 "You should run chkdsk.");
1918 goto put_err_out;
1919 }
1920
1921 ni->attr_list_rl.rl = ntfs_mapping_pairs_decompress(vol,
1922 a, NULL);
1923 if (IS_ERR(ni->attr_list_rl.rl)) {
1924 err = PTR_ERR(ni->attr_list_rl.rl);
1925 ni->attr_list_rl.rl = NULL;
1926 ntfs_error(sb, "Mapping pairs decompression "
1927 "failed with error code %i.",
1928 -err);
1929 goto put_err_out;
1930 }
1931
1932 if ((err = load_attribute_list(vol, &ni->attr_list_rl,
1933 ni->attr_list, ni->attr_list_size,
1934 sle64_to_cpu(a->data.
1935 non_resident.initialized_size)))) {
1936 ntfs_error(sb, "Failed to load attribute list "
1937 "attribute with error code %i.",
1938 -err);
1939 goto put_err_out;
1940 }
1941 } else {
1942 if ((u8*)a + le16_to_cpu(
1943 a->data.resident.value_offset) +
1944 le32_to_cpu(
1945 a->data.resident.value_length) >
1946 (u8*)ctx->mrec + vol->mft_record_size) {
1947 ntfs_error(sb, "Corrupt attribute list "
1948 "attribute.");
1949 goto put_err_out;
1950 }
1951
1952 memcpy(ni->attr_list, (u8*)a + le16_to_cpu(
1953 a->data.resident.value_offset),
1954 le32_to_cpu(
1955 a->data.resident.value_length));
1956 }
1957
1958
1959
1960
1961
1962
1963
1964
1965
1966
1967
1968
1969 al_entry = (ATTR_LIST_ENTRY*)ni->attr_list;
1970 al_end = (u8*)al_entry + ni->attr_list_size;
1971 for (;; al_entry = next_al_entry) {
1972
1973 if ((u8*)al_entry < ni->attr_list ||
1974 (u8*)al_entry > al_end)
1975 goto em_put_err_out;
1976
1977 if ((u8*)al_entry == al_end)
1978 goto em_put_err_out;
1979 if (!al_entry->length)
1980 goto em_put_err_out;
1981 if ((u8*)al_entry + 6 > al_end || (u8*)al_entry +
1982 le16_to_cpu(al_entry->length) > al_end)
1983 goto em_put_err_out;
1984 next_al_entry = (ATTR_LIST_ENTRY*)((u8*)al_entry +
1985 le16_to_cpu(al_entry->length));
1986 if (le32_to_cpu(al_entry->type) > le32_to_cpu(AT_DATA))
1987 goto em_put_err_out;
1988 if (AT_DATA != al_entry->type)
1989 continue;
1990
1991 if (al_entry->name_length)
1992 goto em_put_err_out;
1993
1994 if (al_entry->lowest_vcn)
1995 goto em_put_err_out;
1996
1997 if (MREF_LE(al_entry->mft_reference) != vi->i_ino) {
1998
1999 ntfs_error(sb, "BUG: The first $DATA extent "
2000 "of $MFT is not in the base "
2001 "mft record. Please report "
2002 "you saw this message to "
2003 "linux-ntfs-dev@lists."
2004 "sourceforge.net");
2005 goto put_err_out;
2006 } else {
2007
2008 if (MSEQNO_LE(al_entry->mft_reference) !=
2009 ni->seq_no)
2010 goto em_put_err_out;
2011
2012 break;
2013 }
2014 }
2015 }
2016
2017 ntfs_attr_reinit_search_ctx(ctx);
2018
2019
2020 a = NULL;
2021 next_vcn = last_vcn = highest_vcn = 0;
2022 while (!(err = ntfs_attr_lookup(AT_DATA, NULL, 0, 0, next_vcn, NULL, 0,
2023 ctx))) {
2024 runlist_element *nrl;
2025
2026
2027 a = ctx->attr;
2028
2029 if (!a->non_resident) {
2030 ntfs_error(sb, "$MFT must be non-resident but a "
2031 "resident extent was found. $MFT is "
2032 "corrupt. Run chkdsk.");
2033 goto put_err_out;
2034 }
2035
2036 if (a->flags & ATTR_COMPRESSION_MASK ||
2037 a->flags & ATTR_IS_ENCRYPTED ||
2038 a->flags & ATTR_IS_SPARSE) {
2039 ntfs_error(sb, "$MFT must be uncompressed, "
2040 "non-sparse, and unencrypted but a "
2041 "compressed/sparse/encrypted extent "
2042 "was found. $MFT is corrupt. Run "
2043 "chkdsk.");
2044 goto put_err_out;
2045 }
2046
2047
2048
2049
2050
2051
2052 nrl = ntfs_mapping_pairs_decompress(vol, a, ni->runlist.rl);
2053 if (IS_ERR(nrl)) {
2054 ntfs_error(sb, "ntfs_mapping_pairs_decompress() "
2055 "failed with error code %ld. $MFT is "
2056 "corrupt.", PTR_ERR(nrl));
2057 goto put_err_out;
2058 }
2059 ni->runlist.rl = nrl;
2060
2061
2062 if (!next_vcn) {
2063 if (a->data.non_resident.lowest_vcn) {
2064 ntfs_error(sb, "First extent of $DATA "
2065 "attribute has non zero "
2066 "lowest_vcn. $MFT is corrupt. "
2067 "You should run chkdsk.");
2068 goto put_err_out;
2069 }
2070
2071 last_vcn = sle64_to_cpu(
2072 a->data.non_resident.allocated_size)
2073 >> vol->cluster_size_bits;
2074
2075 vi->i_size = sle64_to_cpu(
2076 a->data.non_resident.data_size);
2077 ni->initialized_size = sle64_to_cpu(
2078 a->data.non_resident.initialized_size);
2079 ni->allocated_size = sle64_to_cpu(
2080 a->data.non_resident.allocated_size);
2081
2082
2083
2084
2085 if ((vi->i_size >> vol->mft_record_size_bits) >=
2086 (1ULL << 32)) {
2087 ntfs_error(sb, "$MFT is too big! Aborting.");
2088 goto put_err_out;
2089 }
2090
2091
2092
2093
2094
2095
2096
2097
2098
2099
2100
2101
2102
2103
2104
2105
2106
2107
2108
2109 ntfs_read_locked_inode(vi);
2110 if (is_bad_inode(vi)) {
2111 ntfs_error(sb, "ntfs_read_inode() of $MFT "
2112 "failed. BUG or corrupt $MFT. "
2113 "Run chkdsk and if no errors "
2114 "are found, please report you "
2115 "saw this message to "
2116 "linux-ntfs-dev@lists."
2117 "sourceforge.net");
2118 ntfs_attr_put_search_ctx(ctx);
2119
2120 ntfs_free(m);
2121 return -1;
2122 }
2123
2124
2125
2126
2127
2128 vi->i_uid = vi->i_gid = 0;
2129
2130 vi->i_mode = S_IFREG;
2131
2132 vi->i_op = &ntfs_empty_inode_ops;
2133 vi->i_fop = &ntfs_empty_file_ops;
2134 }
2135
2136
2137 highest_vcn = sle64_to_cpu(a->data.non_resident.highest_vcn);
2138 next_vcn = highest_vcn + 1;
2139
2140
2141 if (next_vcn <= 0)
2142 break;
2143
2144
2145 if (next_vcn < sle64_to_cpu(
2146 a->data.non_resident.lowest_vcn)) {
2147 ntfs_error(sb, "$MFT has corrupt attribute list "
2148 "attribute. Run chkdsk.");
2149 goto put_err_out;
2150 }
2151 }
2152 if (err != -ENOENT) {
2153 ntfs_error(sb, "Failed to lookup $MFT/$DATA attribute extent. "
2154 "$MFT is corrupt. Run chkdsk.");
2155 goto put_err_out;
2156 }
2157 if (!a) {
2158 ntfs_error(sb, "$MFT/$DATA attribute not found. $MFT is "
2159 "corrupt. Run chkdsk.");
2160 goto put_err_out;
2161 }
2162 if (highest_vcn && highest_vcn != last_vcn - 1) {
2163 ntfs_error(sb, "Failed to load the complete runlist for "
2164 "$MFT/$DATA. Driver bug or corrupt $MFT. "
2165 "Run chkdsk.");
2166 ntfs_debug("highest_vcn = 0x%llx, last_vcn - 1 = 0x%llx",
2167 (unsigned long long)highest_vcn,
2168 (unsigned long long)last_vcn - 1);
2169 goto put_err_out;
2170 }
2171 ntfs_attr_put_search_ctx(ctx);
2172 ntfs_debug("Done.");
2173 ntfs_free(m);
2174
2175
2176
2177
2178
2179 lockdep_set_class(&ni->runlist.lock, &mft_ni_runlist_lock_key);
2180 lockdep_set_class(&ni->mrec_lock, &mft_ni_mrec_lock_key);
2181
2182 return 0;
2183
2184em_put_err_out:
2185 ntfs_error(sb, "Couldn't find first extent of $DATA attribute in "
2186 "attribute list. $MFT is corrupt. Run chkdsk.");
2187put_err_out:
2188 ntfs_attr_put_search_ctx(ctx);
2189err_out:
2190 ntfs_error(sb, "Failed. Marking inode as bad.");
2191 make_bad_inode(vi);
2192 ntfs_free(m);
2193 return -1;
2194}
2195
2196static void __ntfs_clear_inode(ntfs_inode *ni)
2197{
2198
2199 down_write(&ni->runlist.lock);
2200 if (ni->runlist.rl) {
2201 ntfs_free(ni->runlist.rl);
2202 ni->runlist.rl = NULL;
2203 }
2204 up_write(&ni->runlist.lock);
2205
2206 if (ni->attr_list) {
2207 ntfs_free(ni->attr_list);
2208 ni->attr_list = NULL;
2209 }
2210
2211 down_write(&ni->attr_list_rl.lock);
2212 if (ni->attr_list_rl.rl) {
2213 ntfs_free(ni->attr_list_rl.rl);
2214 ni->attr_list_rl.rl = NULL;
2215 }
2216 up_write(&ni->attr_list_rl.lock);
2217
2218 if (ni->name_len && ni->name != I30) {
2219
2220 BUG_ON(!ni->name);
2221 kfree(ni->name);
2222 }
2223}
2224
2225void ntfs_clear_extent_inode(ntfs_inode *ni)
2226{
2227 ntfs_debug("Entering for inode 0x%lx.", ni->mft_no);
2228
2229 BUG_ON(NInoAttr(ni));
2230 BUG_ON(ni->nr_extents != -1);
2231
2232#ifdef NTFS_RW
2233 if (NInoDirty(ni)) {
2234 if (!is_bad_inode(VFS_I(ni->ext.base_ntfs_ino)))
2235 ntfs_error(ni->vol->sb, "Clearing dirty extent inode! "
2236 "Losing data! This is a BUG!!!");
2237
2238 }
2239#endif
2240
2241 __ntfs_clear_inode(ni);
2242
2243
2244 ntfs_destroy_extent_inode(ni);
2245}
2246
2247
2248
2249
2250
2251
2252
2253
2254
2255
2256
2257void ntfs_evict_big_inode(struct inode *vi)
2258{
2259 ntfs_inode *ni = NTFS_I(vi);
2260
2261 truncate_inode_pages(&vi->i_data, 0);
2262 end_writeback(vi);
2263
2264#ifdef NTFS_RW
2265 if (NInoDirty(ni)) {
2266 bool was_bad = (is_bad_inode(vi));
2267
2268
2269 ntfs_commit_inode(vi);
2270
2271 if (!was_bad && (is_bad_inode(vi) || NInoDirty(ni))) {
2272 ntfs_error(vi->i_sb, "Failed to commit dirty inode "
2273 "0x%lx. Losing data!", vi->i_ino);
2274
2275 }
2276 }
2277#endif
2278
2279
2280 if (ni->nr_extents > 0) {
2281 int i;
2282
2283 for (i = 0; i < ni->nr_extents; i++)
2284 ntfs_clear_extent_inode(ni->ext.extent_ntfs_inos[i]);
2285 kfree(ni->ext.extent_ntfs_inos);
2286 }
2287
2288 __ntfs_clear_inode(ni);
2289
2290 if (NInoAttr(ni)) {
2291
2292 if (ni->nr_extents == -1) {
2293 iput(VFS_I(ni->ext.base_ntfs_ino));
2294 ni->nr_extents = 0;
2295 ni->ext.base_ntfs_ino = NULL;
2296 }
2297 }
2298 return;
2299}
2300
2301
2302
2303
2304
2305
2306
2307
2308
2309
2310
2311int ntfs_show_options(struct seq_file *sf, struct vfsmount *mnt)
2312{
2313 ntfs_volume *vol = NTFS_SB(mnt->mnt_sb);
2314 int i;
2315
2316 seq_printf(sf, ",uid=%i", vol->uid);
2317 seq_printf(sf, ",gid=%i", vol->gid);
2318 if (vol->fmask == vol->dmask)
2319 seq_printf(sf, ",umask=0%o", vol->fmask);
2320 else {
2321 seq_printf(sf, ",fmask=0%o", vol->fmask);
2322 seq_printf(sf, ",dmask=0%o", vol->dmask);
2323 }
2324 seq_printf(sf, ",nls=%s", vol->nls_map->charset);
2325 if (NVolCaseSensitive(vol))
2326 seq_printf(sf, ",case_sensitive");
2327 if (NVolShowSystemFiles(vol))
2328 seq_printf(sf, ",show_sys_files");
2329 if (!NVolSparseEnabled(vol))
2330 seq_printf(sf, ",disable_sparse");
2331 for (i = 0; on_errors_arr[i].val; i++) {
2332 if (on_errors_arr[i].val & vol->on_errors)
2333 seq_printf(sf, ",errors=%s", on_errors_arr[i].str);
2334 }
2335 seq_printf(sf, ",mft_zone_multiplier=%i", vol->mft_zone_multiplier);
2336 return 0;
2337}
2338
2339#ifdef NTFS_RW
2340
2341static const char *es = " Leaving inconsistent metadata. Unmount and run "
2342 "chkdsk.";
2343
2344
2345
2346
2347
2348
2349
2350
2351
2352
2353
2354
2355
2356
2357
2358
2359
2360
2361
2362
2363
2364
2365
2366
2367int ntfs_truncate(struct inode *vi)
2368{
2369 s64 new_size, old_size, nr_freed, new_alloc_size, old_alloc_size;
2370 VCN highest_vcn;
2371 unsigned long flags;
2372 ntfs_inode *base_ni, *ni = NTFS_I(vi);
2373 ntfs_volume *vol = ni->vol;
2374 ntfs_attr_search_ctx *ctx;
2375 MFT_RECORD *m;
2376 ATTR_RECORD *a;
2377 const char *te = " Leaving file length out of sync with i_size.";
2378 int err, mp_size, size_change, alloc_change;
2379 u32 attr_len;
2380
2381 ntfs_debug("Entering for inode 0x%lx.", vi->i_ino);
2382 BUG_ON(NInoAttr(ni));
2383 BUG_ON(S_ISDIR(vi->i_mode));
2384 BUG_ON(NInoMstProtected(ni));
2385 BUG_ON(ni->nr_extents < 0);
2386retry_truncate:
2387
2388
2389
2390
2391 down_write(&ni->runlist.lock);
2392 if (!NInoAttr(ni))
2393 base_ni = ni;
2394 else
2395 base_ni = ni->ext.base_ntfs_ino;
2396 m = map_mft_record(base_ni);
2397 if (IS_ERR(m)) {
2398 err = PTR_ERR(m);
2399 ntfs_error(vi->i_sb, "Failed to map mft record for inode 0x%lx "
2400 "(error code %d).%s", vi->i_ino, err, te);
2401 ctx = NULL;
2402 m = NULL;
2403 goto old_bad_out;
2404 }
2405 ctx = ntfs_attr_get_search_ctx(base_ni, m);
2406 if (unlikely(!ctx)) {
2407 ntfs_error(vi->i_sb, "Failed to allocate a search context for "
2408 "inode 0x%lx (not enough memory).%s",
2409 vi->i_ino, te);
2410 err = -ENOMEM;
2411 goto old_bad_out;
2412 }
2413 err = ntfs_attr_lookup(ni->type, ni->name, ni->name_len,
2414 CASE_SENSITIVE, 0, NULL, 0, ctx);
2415 if (unlikely(err)) {
2416 if (err == -ENOENT) {
2417 ntfs_error(vi->i_sb, "Open attribute is missing from "
2418 "mft record. Inode 0x%lx is corrupt. "
2419 "Run chkdsk.%s", vi->i_ino, te);
2420 err = -EIO;
2421 } else
2422 ntfs_error(vi->i_sb, "Failed to lookup attribute in "
2423 "inode 0x%lx (error code %d).%s",
2424 vi->i_ino, err, te);
2425 goto old_bad_out;
2426 }
2427 m = ctx->mrec;
2428 a = ctx->attr;
2429
2430
2431
2432 new_size = i_size_read(vi);
2433
2434 old_size = ntfs_attr_size(a);
2435
2436 if (NInoNonResident(ni))
2437 new_alloc_size = (new_size + vol->cluster_size - 1) &
2438 ~(s64)vol->cluster_size_mask;
2439 else
2440 new_alloc_size = (new_size + 7) & ~7;
2441
2442 read_lock_irqsave(&ni->size_lock, flags);
2443 old_alloc_size = ni->allocated_size;
2444 read_unlock_irqrestore(&ni->size_lock, flags);
2445
2446
2447
2448
2449 size_change = -1;
2450 if (new_size - old_size >= 0) {
2451 size_change = 1;
2452 if (new_size == old_size)
2453 size_change = 0;
2454 }
2455
2456 alloc_change = -1;
2457 if (new_alloc_size - old_alloc_size >= 0) {
2458 alloc_change = 1;
2459 if (new_alloc_size == old_alloc_size)
2460 alloc_change = 0;
2461 }
2462
2463
2464
2465
2466 if (!size_change && !alloc_change)
2467 goto unm_done;
2468
2469 if (size_change) {
2470 err = ntfs_attr_size_bounds_check(vol, ni->type, new_size);
2471 if (unlikely(err)) {
2472 if (err == -ERANGE) {
2473 ntfs_error(vol->sb, "Truncate would cause the "
2474 "inode 0x%lx to %simum size "
2475 "for its attribute type "
2476 "(0x%x). Aborting truncate.",
2477 vi->i_ino,
2478 new_size > old_size ? "exceed "
2479 "the max" : "go under the min",
2480 le32_to_cpu(ni->type));
2481 err = -EFBIG;
2482 } else {
2483 ntfs_error(vol->sb, "Inode 0x%lx has unknown "
2484 "attribute type 0x%x. "
2485 "Aborting truncate.",
2486 vi->i_ino,
2487 le32_to_cpu(ni->type));
2488 err = -EIO;
2489 }
2490
2491 i_size_write(vi, old_size);
2492 goto err_out;
2493 }
2494 }
2495 if (NInoCompressed(ni) || NInoEncrypted(ni)) {
2496 ntfs_warning(vi->i_sb, "Changes in inode size are not "
2497 "supported yet for %s files, ignoring.",
2498 NInoCompressed(ni) ? "compressed" :
2499 "encrypted");
2500 err = -EOPNOTSUPP;
2501 goto bad_out;
2502 }
2503 if (a->non_resident)
2504 goto do_non_resident_truncate;
2505 BUG_ON(NInoNonResident(ni));
2506
2507 if (new_size < vol->mft_record_size &&
2508 !ntfs_resident_attr_value_resize(m, a, new_size)) {
2509
2510 flush_dcache_mft_record_page(ctx->ntfs_ino);
2511 mark_mft_record_dirty(ctx->ntfs_ino);
2512 write_lock_irqsave(&ni->size_lock, flags);
2513
2514 ni->allocated_size = le32_to_cpu(a->length) -
2515 le16_to_cpu(a->data.resident.value_offset);
2516
2517
2518
2519
2520
2521
2522
2523
2524
2525
2526
2527
2528
2529
2530
2531
2532
2533
2534
2535
2536
2537
2538
2539
2540
2541
2542
2543
2544 ni->initialized_size = new_size;
2545 write_unlock_irqrestore(&ni->size_lock, flags);
2546 goto unm_done;
2547 }
2548
2549 BUG_ON(size_change < 0);
2550
2551
2552
2553
2554
2555
2556
2557
2558
2559 ntfs_attr_put_search_ctx(ctx);
2560 unmap_mft_record(base_ni);
2561 up_write(&ni->runlist.lock);
2562
2563
2564
2565
2566 err = ntfs_attr_make_non_resident(ni, old_size);
2567 if (likely(!err))
2568 goto retry_truncate;
2569
2570
2571
2572
2573
2574 if (unlikely(err != -EPERM && err != -ENOSPC)) {
2575 ntfs_error(vol->sb, "Cannot truncate inode 0x%lx, attribute "
2576 "type 0x%x, because the conversion from "
2577 "resident to non-resident attribute failed "
2578 "with error code %i.", vi->i_ino,
2579 (unsigned)le32_to_cpu(ni->type), err);
2580 if (err != -ENOMEM)
2581 err = -EIO;
2582 goto conv_err_out;
2583 }
2584
2585 if (err == -ENOSPC)
2586 ntfs_error(vol->sb, "Not enough space in the mft record/on "
2587 "disk for the non-resident attribute value. "
2588 "This case is not implemented yet.");
2589 else
2590 ntfs_error(vol->sb, "This attribute type may not be "
2591 "non-resident. This case is not implemented "
2592 "yet.");
2593 err = -EOPNOTSUPP;
2594 goto conv_err_out;
2595#if 0
2596
2597 if (!err)
2598 goto do_resident_extend;
2599
2600
2601
2602
2603
2604
2605 if (ni->type == AT_ATTRIBUTE_LIST ||
2606 ni->type == AT_STANDARD_INFORMATION) {
2607
2608
2609 err = -EOPNOTSUPP;
2610 if (!err)
2611 goto do_resident_extend;
2612 goto err_out;
2613 }
2614
2615
2616
2617 err = -EOPNOTSUPP;
2618 if (!err)
2619 goto do_resident_extend;
2620
2621 goto err_out;
2622#endif
2623do_non_resident_truncate:
2624 BUG_ON(!NInoNonResident(ni));
2625 if (alloc_change < 0) {
2626 highest_vcn = sle64_to_cpu(a->data.non_resident.highest_vcn);
2627 if (highest_vcn > 0 &&
2628 old_alloc_size >> vol->cluster_size_bits >
2629 highest_vcn + 1) {
2630
2631
2632
2633
2634 ntfs_error(vol->sb, "Cannot truncate inode 0x%lx, "
2635 "attribute type 0x%x, because the "
2636 "attribute is highly fragmented (it "
2637 "consists of multiple extents) and "
2638 "this case is not implemented yet.",
2639 vi->i_ino,
2640 (unsigned)le32_to_cpu(ni->type));
2641 err = -EOPNOTSUPP;
2642 goto bad_out;
2643 }
2644 }
2645
2646
2647
2648
2649 if (size_change < 0) {
2650
2651
2652
2653 write_lock_irqsave(&ni->size_lock, flags);
2654 if (new_size < ni->initialized_size) {
2655 ni->initialized_size = new_size;
2656 a->data.non_resident.initialized_size =
2657 cpu_to_sle64(new_size);
2658 }
2659 a->data.non_resident.data_size = cpu_to_sle64(new_size);
2660 write_unlock_irqrestore(&ni->size_lock, flags);
2661 flush_dcache_mft_record_page(ctx->ntfs_ino);
2662 mark_mft_record_dirty(ctx->ntfs_ino);
2663
2664 if (!alloc_change)
2665 goto unm_done;
2666
2667
2668
2669
2670 BUG_ON(alloc_change > 0);
2671 } else {
2672
2673
2674
2675
2676 if (alloc_change > 0) {
2677
2678
2679
2680
2681
2682
2683
2684
2685
2686
2687
2688
2689
2690
2691
2692 ntfs_attr_put_search_ctx(ctx);
2693 unmap_mft_record(base_ni);
2694 up_write(&ni->runlist.lock);
2695 err = ntfs_attr_extend_allocation(ni, new_size,
2696 size_change > 0 ? new_size : -1, -1);
2697
2698
2699
2700
2701 goto done;
2702 }
2703 if (!alloc_change)
2704 goto alloc_done;
2705 }
2706
2707
2708 nr_freed = ntfs_cluster_free(ni, new_alloc_size >>
2709 vol->cluster_size_bits, -1, ctx);
2710 m = ctx->mrec;
2711 a = ctx->attr;
2712 if (unlikely(nr_freed < 0)) {
2713 ntfs_error(vol->sb, "Failed to release cluster(s) (error code "
2714 "%lli). Unmount and run chkdsk to recover "
2715 "the lost cluster(s).", (long long)nr_freed);
2716 NVolSetErrors(vol);
2717 nr_freed = 0;
2718 }
2719
2720 err = ntfs_rl_truncate_nolock(vol, &ni->runlist,
2721 new_alloc_size >> vol->cluster_size_bits);
2722
2723
2724
2725
2726
2727
2728 if (unlikely(err || IS_ERR(m))) {
2729 ntfs_error(vol->sb, "Failed to %s (error code %li).%s",
2730 IS_ERR(m) ?
2731 "restore attribute search context" :
2732 "truncate attribute runlist",
2733 IS_ERR(m) ? PTR_ERR(m) : err, es);
2734 err = -EIO;
2735 goto bad_out;
2736 }
2737
2738 mp_size = ntfs_get_size_for_mapping_pairs(vol, ni->runlist.rl, 0, -1);
2739 if (unlikely(mp_size <= 0)) {
2740 ntfs_error(vol->sb, "Cannot shrink allocation of inode 0x%lx, "
2741 "attribute type 0x%x, because determining the "
2742 "size for the mapping pairs failed with error "
2743 "code %i.%s", vi->i_ino,
2744 (unsigned)le32_to_cpu(ni->type), mp_size, es);
2745 err = -EIO;
2746 goto bad_out;
2747 }
2748
2749
2750
2751
2752
2753 attr_len = le32_to_cpu(a->length);
2754 err = ntfs_attr_record_resize(m, a, mp_size +
2755 le16_to_cpu(a->data.non_resident.mapping_pairs_offset));
2756 BUG_ON(err);
2757
2758
2759
2760 err = ntfs_mapping_pairs_build(vol, (u8*)a +
2761 le16_to_cpu(a->data.non_resident.mapping_pairs_offset),
2762 mp_size, ni->runlist.rl, 0, -1, NULL);
2763 if (unlikely(err)) {
2764 ntfs_error(vol->sb, "Cannot shrink allocation of inode 0x%lx, "
2765 "attribute type 0x%x, because building the "
2766 "mapping pairs failed with error code %i.%s",
2767 vi->i_ino, (unsigned)le32_to_cpu(ni->type),
2768 err, es);
2769 err = -EIO;
2770 goto bad_out;
2771 }
2772
2773 a->data.non_resident.highest_vcn = cpu_to_sle64((new_alloc_size >>
2774 vol->cluster_size_bits) - 1);
2775 write_lock_irqsave(&ni->size_lock, flags);
2776 ni->allocated_size = new_alloc_size;
2777 a->data.non_resident.allocated_size = cpu_to_sle64(new_alloc_size);
2778 if (NInoSparse(ni) || NInoCompressed(ni)) {
2779 if (nr_freed) {
2780 ni->itype.compressed.size -= nr_freed <<
2781 vol->cluster_size_bits;
2782 BUG_ON(ni->itype.compressed.size < 0);
2783 a->data.non_resident.compressed_size = cpu_to_sle64(
2784 ni->itype.compressed.size);
2785 vi->i_blocks = ni->itype.compressed.size >> 9;
2786 }
2787 } else
2788 vi->i_blocks = new_alloc_size >> 9;
2789 write_unlock_irqrestore(&ni->size_lock, flags);
2790
2791
2792
2793
2794
2795
2796
2797
2798alloc_done:
2799
2800
2801
2802
2803 if (size_change > 0)
2804 a->data.non_resident.data_size = cpu_to_sle64(new_size);
2805
2806 flush_dcache_mft_record_page(ctx->ntfs_ino);
2807 mark_mft_record_dirty(ctx->ntfs_ino);
2808unm_done:
2809 ntfs_attr_put_search_ctx(ctx);
2810 unmap_mft_record(base_ni);
2811 up_write(&ni->runlist.lock);
2812done:
2813
2814
2815
2816
2817
2818
2819 if (!IS_NOCMTIME(VFS_I(base_ni)) && !IS_RDONLY(VFS_I(base_ni))) {
2820 struct timespec now = current_fs_time(VFS_I(base_ni)->i_sb);
2821 int sync_it = 0;
2822
2823 if (!timespec_equal(&VFS_I(base_ni)->i_mtime, &now) ||
2824 !timespec_equal(&VFS_I(base_ni)->i_ctime, &now))
2825 sync_it = 1;
2826 VFS_I(base_ni)->i_mtime = now;
2827 VFS_I(base_ni)->i_ctime = now;
2828
2829 if (sync_it)
2830 mark_inode_dirty_sync(VFS_I(base_ni));
2831 }
2832
2833 if (likely(!err)) {
2834 NInoClearTruncateFailed(ni);
2835 ntfs_debug("Done.");
2836 }
2837 return err;
2838old_bad_out:
2839 old_size = -1;
2840bad_out:
2841 if (err != -ENOMEM && err != -EOPNOTSUPP)
2842 NVolSetErrors(vol);
2843 if (err != -EOPNOTSUPP)
2844 NInoSetTruncateFailed(ni);
2845 else if (old_size >= 0)
2846 i_size_write(vi, old_size);
2847err_out:
2848 if (ctx)
2849 ntfs_attr_put_search_ctx(ctx);
2850 if (m)
2851 unmap_mft_record(base_ni);
2852 up_write(&ni->runlist.lock);
2853out:
2854 ntfs_debug("Failed. Returning error code %i.", err);
2855 return err;
2856conv_err_out:
2857 if (err != -ENOMEM && err != -EOPNOTSUPP)
2858 NVolSetErrors(vol);
2859 if (err != -EOPNOTSUPP)
2860 NInoSetTruncateFailed(ni);
2861 else
2862 i_size_write(vi, old_size);
2863 goto out;
2864}
2865
2866
2867
2868
2869
2870
2871
2872
2873
2874void ntfs_truncate_vfs(struct inode *vi) {
2875 ntfs_truncate(vi);
2876}
2877
2878
2879
2880
2881
2882
2883
2884
2885
2886
2887
2888
2889
2890
2891
2892
2893int ntfs_setattr(struct dentry *dentry, struct iattr *attr)
2894{
2895 struct inode *vi = dentry->d_inode;
2896 int err;
2897 unsigned int ia_valid = attr->ia_valid;
2898
2899 err = inode_change_ok(vi, attr);
2900 if (err)
2901 goto out;
2902
2903 if (ia_valid & (ATTR_UID | ATTR_GID | ATTR_MODE)) {
2904 ntfs_warning(vi->i_sb, "Changes in user/group/mode are not "
2905 "supported yet, ignoring.");
2906 err = -EOPNOTSUPP;
2907 goto out;
2908 }
2909 if (ia_valid & ATTR_SIZE) {
2910 if (attr->ia_size != i_size_read(vi)) {
2911 ntfs_inode *ni = NTFS_I(vi);
2912
2913
2914
2915
2916 if (NInoCompressed(ni) || NInoEncrypted(ni)) {
2917 ntfs_warning(vi->i_sb, "Changes in inode size "
2918 "are not supported yet for "
2919 "%s files, ignoring.",
2920 NInoCompressed(ni) ?
2921 "compressed" : "encrypted");
2922 err = -EOPNOTSUPP;
2923 } else
2924 err = vmtruncate(vi, attr->ia_size);
2925 if (err || ia_valid == ATTR_SIZE)
2926 goto out;
2927 } else {
2928
2929
2930
2931
2932 ia_valid |= ATTR_MTIME | ATTR_CTIME;
2933 }
2934 }
2935 if (ia_valid & ATTR_ATIME)
2936 vi->i_atime = timespec_trunc(attr->ia_atime,
2937 vi->i_sb->s_time_gran);
2938 if (ia_valid & ATTR_MTIME)
2939 vi->i_mtime = timespec_trunc(attr->ia_mtime,
2940 vi->i_sb->s_time_gran);
2941 if (ia_valid & ATTR_CTIME)
2942 vi->i_ctime = timespec_trunc(attr->ia_ctime,
2943 vi->i_sb->s_time_gran);
2944 mark_inode_dirty(vi);
2945out:
2946 return err;
2947}
2948
2949
2950
2951
2952
2953
2954
2955
2956
2957
2958
2959
2960
2961
2962
2963
2964
2965
2966
2967int __ntfs_write_inode(struct inode *vi, int sync)
2968{
2969 sle64 nt;
2970 ntfs_inode *ni = NTFS_I(vi);
2971 ntfs_attr_search_ctx *ctx;
2972 MFT_RECORD *m;
2973 STANDARD_INFORMATION *si;
2974 int err = 0;
2975 bool modified = false;
2976
2977 ntfs_debug("Entering for %sinode 0x%lx.", NInoAttr(ni) ? "attr " : "",
2978 vi->i_ino);
2979
2980
2981
2982
2983
2984 if (NInoAttr(ni)) {
2985 NInoClearDirty(ni);
2986 ntfs_debug("Done.");
2987 return 0;
2988 }
2989
2990 m = map_mft_record(ni);
2991 if (IS_ERR(m)) {
2992 err = PTR_ERR(m);
2993 goto err_out;
2994 }
2995
2996 ctx = ntfs_attr_get_search_ctx(ni, m);
2997 if (unlikely(!ctx)) {
2998 err = -ENOMEM;
2999 goto unm_err_out;
3000 }
3001 err = ntfs_attr_lookup(AT_STANDARD_INFORMATION, NULL, 0,
3002 CASE_SENSITIVE, 0, NULL, 0, ctx);
3003 if (unlikely(err)) {
3004 ntfs_attr_put_search_ctx(ctx);
3005 goto unm_err_out;
3006 }
3007 si = (STANDARD_INFORMATION*)((u8*)ctx->attr +
3008 le16_to_cpu(ctx->attr->data.resident.value_offset));
3009
3010 nt = utc2ntfs(vi->i_mtime);
3011 if (si->last_data_change_time != nt) {
3012 ntfs_debug("Updating mtime for inode 0x%lx: old = 0x%llx, "
3013 "new = 0x%llx", vi->i_ino, (long long)
3014 sle64_to_cpu(si->last_data_change_time),
3015 (long long)sle64_to_cpu(nt));
3016 si->last_data_change_time = nt;
3017 modified = true;
3018 }
3019 nt = utc2ntfs(vi->i_ctime);
3020 if (si->last_mft_change_time != nt) {
3021 ntfs_debug("Updating ctime for inode 0x%lx: old = 0x%llx, "
3022 "new = 0x%llx", vi->i_ino, (long long)
3023 sle64_to_cpu(si->last_mft_change_time),
3024 (long long)sle64_to_cpu(nt));
3025 si->last_mft_change_time = nt;
3026 modified = true;
3027 }
3028 nt = utc2ntfs(vi->i_atime);
3029 if (si->last_access_time != nt) {
3030 ntfs_debug("Updating atime for inode 0x%lx: old = 0x%llx, "
3031 "new = 0x%llx", vi->i_ino,
3032 (long long)sle64_to_cpu(si->last_access_time),
3033 (long long)sle64_to_cpu(nt));
3034 si->last_access_time = nt;
3035 modified = true;
3036 }
3037
3038
3039
3040
3041
3042
3043
3044
3045
3046
3047
3048
3049
3050
3051
3052
3053 if (modified) {
3054 flush_dcache_mft_record_page(ctx->ntfs_ino);
3055 if (!NInoTestSetDirty(ctx->ntfs_ino))
3056 mark_ntfs_record_dirty(ctx->ntfs_ino->page,
3057 ctx->ntfs_ino->page_ofs);
3058 }
3059 ntfs_attr_put_search_ctx(ctx);
3060
3061 if (NInoDirty(ni))
3062 err = write_mft_record(ni, m, sync);
3063
3064 mutex_lock(&ni->extent_lock);
3065 if (ni->nr_extents > 0) {
3066 ntfs_inode **extent_nis = ni->ext.extent_ntfs_inos;
3067 int i;
3068
3069 ntfs_debug("Writing %i extent inodes.", ni->nr_extents);
3070 for (i = 0; i < ni->nr_extents; i++) {
3071 ntfs_inode *tni = extent_nis[i];
3072
3073 if (NInoDirty(tni)) {
3074 MFT_RECORD *tm = map_mft_record(tni);
3075 int ret;
3076
3077 if (IS_ERR(tm)) {
3078 if (!err || err == -ENOMEM)
3079 err = PTR_ERR(tm);
3080 continue;
3081 }
3082 ret = write_mft_record(tni, tm, sync);
3083 unmap_mft_record(tni);
3084 if (unlikely(ret)) {
3085 if (!err || err == -ENOMEM)
3086 err = ret;
3087 }
3088 }
3089 }
3090 }
3091 mutex_unlock(&ni->extent_lock);
3092 unmap_mft_record(ni);
3093 if (unlikely(err))
3094 goto err_out;
3095 ntfs_debug("Done.");
3096 return 0;
3097unm_err_out:
3098 unmap_mft_record(ni);
3099err_out:
3100 if (err == -ENOMEM) {
3101 ntfs_warning(vi->i_sb, "Not enough memory to write inode. "
3102 "Marking the inode dirty again, so the VFS "
3103 "retries later.");
3104 mark_inode_dirty(vi);
3105 } else {
3106 ntfs_error(vi->i_sb, "Failed (error %i): Run chkdsk.", -err);
3107 NVolSetErrors(ni->vol);
3108 }
3109 return err;
3110}
3111
3112#endif
3113