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