1
2
3
4
5
6
7
8#include <linux/buffer_head.h>
9#include <linux/fs.h>
10#include <linux/mpage.h>
11#include <linux/namei.h>
12#include <linux/nls.h>
13#include <linux/uio.h>
14#include <linux/writeback.h>
15
16#include "debug.h"
17#include "ntfs.h"
18#include "ntfs_fs.h"
19
20
21
22
23static struct inode *ntfs_read_mft(struct inode *inode,
24 const struct cpu_str *name,
25 const struct MFT_REF *ref)
26{
27 int err = 0;
28 struct ntfs_inode *ni = ntfs_i(inode);
29 struct super_block *sb = inode->i_sb;
30 struct ntfs_sb_info *sbi = sb->s_fs_info;
31 mode_t mode = 0;
32 struct ATTR_STD_INFO5 *std5 = NULL;
33 struct ATTR_LIST_ENTRY *le;
34 struct ATTRIB *attr;
35 bool is_match = false;
36 bool is_root = false;
37 bool is_dir;
38 unsigned long ino = inode->i_ino;
39 u32 rp_fa = 0, asize, t32;
40 u16 roff, rsize, names = 0;
41 const struct ATTR_FILE_NAME *fname = NULL;
42 const struct INDEX_ROOT *root;
43 struct REPARSE_DATA_BUFFER rp;
44 u64 t64;
45 struct MFT_REC *rec;
46 struct runs_tree *run;
47
48 inode->i_op = NULL;
49
50 inode->i_uid = sbi->options->fs_uid;
51 inode->i_gid = sbi->options->fs_gid;
52
53 err = mi_init(&ni->mi, sbi, ino);
54 if (err)
55 goto out;
56
57 if (!sbi->mft.ni && ino == MFT_REC_MFT && !sb->s_root) {
58 t64 = sbi->mft.lbo >> sbi->cluster_bits;
59 t32 = bytes_to_cluster(sbi, MFT_REC_VOL * sbi->record_size);
60 sbi->mft.ni = ni;
61 init_rwsem(&ni->file.run_lock);
62
63 if (!run_add_entry(&ni->file.run, 0, t64, t32, true)) {
64 err = -ENOMEM;
65 goto out;
66 }
67 }
68
69 err = mi_read(&ni->mi, ino == MFT_REC_MFT);
70
71 if (err)
72 goto out;
73
74 rec = ni->mi.mrec;
75
76 if (sbi->flags & NTFS_FLAGS_LOG_REPLAYING) {
77 ;
78 } else if (ref->seq != rec->seq) {
79 err = -EINVAL;
80 ntfs_err(sb, "MFT: r=%lx, expect seq=%x instead of %x!", ino,
81 le16_to_cpu(ref->seq), le16_to_cpu(rec->seq));
82 goto out;
83 } else if (!is_rec_inuse(rec)) {
84 err = -EINVAL;
85 ntfs_err(sb, "Inode r=%x is not in use!", (u32)ino);
86 goto out;
87 }
88
89 if (le32_to_cpu(rec->total) != sbi->record_size) {
90
91 err = -EINVAL;
92 goto out;
93 }
94
95 if (!is_rec_base(rec))
96 goto Ok;
97
98
99 is_dir = rec->flags & RECORD_FLAG_DIR;
100
101 inode->i_generation = le16_to_cpu(rec->seq);
102
103
104 le = NULL;
105 attr = NULL;
106
107
108
109
110
111next_attr:
112 run = NULL;
113 err = -EINVAL;
114 attr = ni_enum_attr_ex(ni, attr, &le, NULL);
115 if (!attr)
116 goto end_enum;
117
118 if (le && le->vcn) {
119
120 if (ino != MFT_REC_MFT || attr->type != ATTR_DATA)
121 goto next_attr;
122
123 run = &ni->file.run;
124 asize = le32_to_cpu(attr->size);
125 goto attr_unpack_run;
126 }
127
128 roff = attr->non_res ? 0 : le16_to_cpu(attr->res.data_off);
129 rsize = attr->non_res ? 0 : le32_to_cpu(attr->res.data_size);
130 asize = le32_to_cpu(attr->size);
131
132 switch (attr->type) {
133 case ATTR_STD:
134 if (attr->non_res ||
135 asize < sizeof(struct ATTR_STD_INFO) + roff ||
136 rsize < sizeof(struct ATTR_STD_INFO))
137 goto out;
138
139 if (std5)
140 goto next_attr;
141
142 std5 = Add2Ptr(attr, roff);
143
144#ifdef STATX_BTIME
145 nt2kernel(std5->cr_time, &ni->i_crtime);
146#endif
147 nt2kernel(std5->a_time, &inode->i_atime);
148 nt2kernel(std5->c_time, &inode->i_ctime);
149 nt2kernel(std5->m_time, &inode->i_mtime);
150
151 ni->std_fa = std5->fa;
152
153 if (asize >= sizeof(struct ATTR_STD_INFO5) + roff &&
154 rsize >= sizeof(struct ATTR_STD_INFO5))
155 ni->std_security_id = std5->security_id;
156 goto next_attr;
157
158 case ATTR_LIST:
159 if (attr->name_len || le || ino == MFT_REC_LOG)
160 goto out;
161
162 err = ntfs_load_attr_list(ni, attr);
163 if (err)
164 goto out;
165
166 le = NULL;
167 attr = NULL;
168 goto next_attr;
169
170 case ATTR_NAME:
171 if (attr->non_res || asize < SIZEOF_ATTRIBUTE_FILENAME + roff ||
172 rsize < SIZEOF_ATTRIBUTE_FILENAME)
173 goto out;
174
175 fname = Add2Ptr(attr, roff);
176 if (fname->type == FILE_NAME_DOS)
177 goto next_attr;
178
179 names += 1;
180 if (name && name->len == fname->name_len &&
181 !ntfs_cmp_names_cpu(name, (struct le_str *)&fname->name_len,
182 NULL, false))
183 is_match = true;
184
185 goto next_attr;
186
187 case ATTR_DATA:
188 if (is_dir) {
189
190 goto next_attr;
191 }
192
193 if (ino == MFT_REC_BADCLUST && !attr->non_res)
194 goto next_attr;
195
196 if (attr->name_len &&
197 ((ino != MFT_REC_BADCLUST || !attr->non_res ||
198 attr->name_len != ARRAY_SIZE(BAD_NAME) ||
199 memcmp(attr_name(attr), BAD_NAME, sizeof(BAD_NAME))) &&
200 (ino != MFT_REC_SECURE || !attr->non_res ||
201 attr->name_len != ARRAY_SIZE(SDS_NAME) ||
202 memcmp(attr_name(attr), SDS_NAME, sizeof(SDS_NAME))))) {
203
204 goto next_attr;
205 }
206
207 if (is_attr_sparsed(attr))
208 ni->std_fa |= FILE_ATTRIBUTE_SPARSE_FILE;
209 else
210 ni->std_fa &= ~FILE_ATTRIBUTE_SPARSE_FILE;
211
212 if (is_attr_compressed(attr))
213 ni->std_fa |= FILE_ATTRIBUTE_COMPRESSED;
214 else
215 ni->std_fa &= ~FILE_ATTRIBUTE_COMPRESSED;
216
217 if (is_attr_encrypted(attr))
218 ni->std_fa |= FILE_ATTRIBUTE_ENCRYPTED;
219 else
220 ni->std_fa &= ~FILE_ATTRIBUTE_ENCRYPTED;
221
222 if (!attr->non_res) {
223 ni->i_valid = inode->i_size = rsize;
224 inode_set_bytes(inode, rsize);
225 }
226
227 mode = S_IFREG | (0777 & sbi->options->fs_fmask_inv);
228
229 if (!attr->non_res) {
230 ni->ni_flags |= NI_FLAG_RESIDENT;
231 goto next_attr;
232 }
233
234 inode_set_bytes(inode, attr_ondisk_size(attr));
235
236 ni->i_valid = le64_to_cpu(attr->nres.valid_size);
237 inode->i_size = le64_to_cpu(attr->nres.data_size);
238 if (!attr->nres.alloc_size)
239 goto next_attr;
240
241 run = ino == MFT_REC_BITMAP ? &sbi->used.bitmap.run
242 : &ni->file.run;
243 break;
244
245 case ATTR_ROOT:
246 if (attr->non_res)
247 goto out;
248
249 root = Add2Ptr(attr, roff);
250 is_root = true;
251
252 if (attr->name_len != ARRAY_SIZE(I30_NAME) ||
253 memcmp(attr_name(attr), I30_NAME, sizeof(I30_NAME)))
254 goto next_attr;
255
256 if (root->type != ATTR_NAME ||
257 root->rule != NTFS_COLLATION_TYPE_FILENAME)
258 goto out;
259
260 if (!is_dir)
261 goto next_attr;
262
263 ni->ni_flags |= NI_FLAG_DIR;
264
265 err = indx_init(&ni->dir, sbi, attr, INDEX_MUTEX_I30);
266 if (err)
267 goto out;
268
269 mode = sb->s_root
270 ? (S_IFDIR | (0777 & sbi->options->fs_dmask_inv))
271 : (S_IFDIR | 0777);
272 goto next_attr;
273
274 case ATTR_ALLOC:
275 if (!is_root || attr->name_len != ARRAY_SIZE(I30_NAME) ||
276 memcmp(attr_name(attr), I30_NAME, sizeof(I30_NAME)))
277 goto next_attr;
278
279 inode->i_size = le64_to_cpu(attr->nres.data_size);
280 ni->i_valid = le64_to_cpu(attr->nres.valid_size);
281 inode_set_bytes(inode, le64_to_cpu(attr->nres.alloc_size));
282
283 run = &ni->dir.alloc_run;
284 break;
285
286 case ATTR_BITMAP:
287 if (ino == MFT_REC_MFT) {
288 if (!attr->non_res)
289 goto out;
290#ifndef CONFIG_NTFS3_64BIT_CLUSTER
291
292 if (le64_to_cpu(attr->nres.alloc_size) >= 0x20000000)
293 goto out;
294#endif
295 run = &sbi->mft.bitmap.run;
296 break;
297 } else if (is_dir && attr->name_len == ARRAY_SIZE(I30_NAME) &&
298 !memcmp(attr_name(attr), I30_NAME,
299 sizeof(I30_NAME)) &&
300 attr->non_res) {
301 run = &ni->dir.bitmap_run;
302 break;
303 }
304 goto next_attr;
305
306 case ATTR_REPARSE:
307 if (attr->name_len)
308 goto next_attr;
309
310 rp_fa = ni_parse_reparse(ni, attr, &rp);
311 switch (rp_fa) {
312 case REPARSE_LINK:
313
314
315
316
317 inode->i_size = le16_to_cpu(rp.SymbolicLinkReparseBuffer
318 .PrintNameLength) /
319 sizeof(u16);
320
321 ni->i_valid = inode->i_size;
322
323
324 if (ni->ni_flags & NI_FLAG_DIR) {
325 indx_clear(&ni->dir);
326 memset(&ni->dir, 0, sizeof(ni->dir));
327 ni->ni_flags &= ~NI_FLAG_DIR;
328 } else {
329 run_close(&ni->file.run);
330 }
331 mode = S_IFLNK | 0777;
332 is_dir = false;
333 if (attr->non_res) {
334 run = &ni->file.run;
335 goto attr_unpack_run;
336 }
337 break;
338
339 case REPARSE_COMPRESSED:
340 break;
341
342 case REPARSE_DEDUPLICATED:
343 break;
344 }
345 goto next_attr;
346
347 case ATTR_EA_INFO:
348 if (!attr->name_len &&
349 resident_data_ex(attr, sizeof(struct EA_INFO))) {
350 ni->ni_flags |= NI_FLAG_EA;
351
352
353
354 inode->i_mode = mode;
355 ntfs_get_wsl_perm(inode);
356 mode = inode->i_mode;
357 }
358 goto next_attr;
359
360 default:
361 goto next_attr;
362 }
363
364attr_unpack_run:
365 roff = le16_to_cpu(attr->nres.run_off);
366
367 t64 = le64_to_cpu(attr->nres.svcn);
368 err = run_unpack_ex(run, sbi, ino, t64, le64_to_cpu(attr->nres.evcn),
369 t64, Add2Ptr(attr, roff), asize - roff);
370 if (err < 0)
371 goto out;
372 err = 0;
373 goto next_attr;
374
375end_enum:
376
377 if (!std5)
378 goto out;
379
380 if (!is_match && name) {
381
382 err = -ENOENT;
383 goto out;
384 }
385
386 if (std5->fa & FILE_ATTRIBUTE_READONLY)
387 mode &= ~0222;
388
389 if (!names) {
390 err = -EINVAL;
391 goto out;
392 }
393
394 if (names != le16_to_cpu(rec->hard_links)) {
395
396 rec->hard_links = cpu_to_le16(names);
397 ni->mi.dirty = true;
398 }
399
400 set_nlink(inode, names);
401
402 if (S_ISDIR(mode)) {
403 ni->std_fa |= FILE_ATTRIBUTE_DIRECTORY;
404
405
406
407
408
409
410 inode->i_op = &ntfs_dir_inode_operations;
411 inode->i_fop = &ntfs_dir_operations;
412 ni->i_valid = 0;
413 } else if (S_ISLNK(mode)) {
414 ni->std_fa &= ~FILE_ATTRIBUTE_DIRECTORY;
415 inode->i_op = &ntfs_link_inode_operations;
416 inode->i_fop = NULL;
417 inode_nohighmem(inode);
418 } else if (S_ISREG(mode)) {
419 ni->std_fa &= ~FILE_ATTRIBUTE_DIRECTORY;
420 inode->i_op = &ntfs_file_inode_operations;
421 inode->i_fop = &ntfs_file_operations;
422 inode->i_mapping->a_ops =
423 is_compressed(ni) ? &ntfs_aops_cmpr : &ntfs_aops;
424 if (ino != MFT_REC_MFT)
425 init_rwsem(&ni->file.run_lock);
426 } else if (S_ISCHR(mode) || S_ISBLK(mode) || S_ISFIFO(mode) ||
427 S_ISSOCK(mode)) {
428 inode->i_op = &ntfs_special_inode_operations;
429 init_special_inode(inode, mode, inode->i_rdev);
430 } else if (fname && fname->home.low == cpu_to_le32(MFT_REC_EXTEND) &&
431 fname->home.seq == cpu_to_le16(MFT_REC_EXTEND)) {
432
433 } else {
434 err = -EINVAL;
435 goto out;
436 }
437
438 if ((sbi->options->sys_immutable &&
439 (std5->fa & FILE_ATTRIBUTE_SYSTEM)) &&
440 !S_ISFIFO(mode) && !S_ISSOCK(mode) && !S_ISLNK(mode)) {
441 inode->i_flags |= S_IMMUTABLE;
442 } else {
443 inode->i_flags &= ~S_IMMUTABLE;
444 }
445
446 inode->i_mode = mode;
447 if (!(ni->ni_flags & NI_FLAG_EA)) {
448
449 inode->i_flags |= S_NOSEC;
450 }
451
452Ok:
453 if (ino == MFT_REC_MFT && !sb->s_root)
454 sbi->mft.ni = NULL;
455
456 unlock_new_inode(inode);
457
458 return inode;
459
460out:
461 if (ino == MFT_REC_MFT && !sb->s_root)
462 sbi->mft.ni = NULL;
463
464 iget_failed(inode);
465 return ERR_PTR(err);
466}
467
468
469
470
471
472
473static int ntfs_test_inode(struct inode *inode, void *data)
474{
475 struct MFT_REF *ref = data;
476
477 return ino_get(ref) == inode->i_ino;
478}
479
480static int ntfs_set_inode(struct inode *inode, void *data)
481{
482 const struct MFT_REF *ref = data;
483
484 inode->i_ino = ino_get(ref);
485 return 0;
486}
487
488struct inode *ntfs_iget5(struct super_block *sb, const struct MFT_REF *ref,
489 const struct cpu_str *name)
490{
491 struct inode *inode;
492
493 inode = iget5_locked(sb, ino_get(ref), ntfs_test_inode, ntfs_set_inode,
494 (void *)ref);
495 if (unlikely(!inode))
496 return ERR_PTR(-ENOMEM);
497
498
499 if (inode->i_state & I_NEW)
500 inode = ntfs_read_mft(inode, name, ref);
501 else if (ref->seq != ntfs_i(inode)->mi.mrec->seq) {
502
503 make_bad_inode(inode);
504 }
505
506 return inode;
507}
508
509enum get_block_ctx {
510 GET_BLOCK_GENERAL = 0,
511 GET_BLOCK_WRITE_BEGIN = 1,
512 GET_BLOCK_DIRECT_IO_R = 2,
513 GET_BLOCK_DIRECT_IO_W = 3,
514 GET_BLOCK_BMAP = 4,
515};
516
517static noinline int ntfs_get_block_vbo(struct inode *inode, u64 vbo,
518 struct buffer_head *bh, int create,
519 enum get_block_ctx ctx)
520{
521 struct super_block *sb = inode->i_sb;
522 struct ntfs_sb_info *sbi = sb->s_fs_info;
523 struct ntfs_inode *ni = ntfs_i(inode);
524 struct page *page = bh->b_page;
525 u8 cluster_bits = sbi->cluster_bits;
526 u32 block_size = sb->s_blocksize;
527 u64 bytes, lbo, valid;
528 u32 off;
529 int err;
530 CLST vcn, lcn, len;
531 bool new;
532
533
534 clear_buffer_new(bh);
535 clear_buffer_uptodate(bh);
536
537
538 if (!create && vbo >= ni->i_valid) {
539
540 return 0;
541 }
542
543 if (vbo >= inode->i_size) {
544
545 return 0;
546 }
547
548 if (is_resident(ni)) {
549 ni_lock(ni);
550 err = attr_data_read_resident(ni, page);
551 ni_unlock(ni);
552
553 if (!err)
554 set_buffer_uptodate(bh);
555 bh->b_size = block_size;
556 return err;
557 }
558
559 vcn = vbo >> cluster_bits;
560 off = vbo & sbi->cluster_mask;
561 new = false;
562
563 err = attr_data_get_block(ni, vcn, 1, &lcn, &len, create ? &new : NULL);
564 if (err)
565 goto out;
566
567 if (!len)
568 return 0;
569
570 bytes = ((u64)len << cluster_bits) - off;
571
572 if (lcn == SPARSE_LCN) {
573 if (!create) {
574 if (bh->b_size > bytes)
575 bh->b_size = bytes;
576 return 0;
577 }
578 WARN_ON(1);
579 }
580
581 if (new) {
582 set_buffer_new(bh);
583 if ((len << cluster_bits) > block_size)
584 ntfs_sparse_cluster(inode, page, vcn, len);
585 }
586
587 lbo = ((u64)lcn << cluster_bits) + off;
588
589 set_buffer_mapped(bh);
590 bh->b_bdev = sb->s_bdev;
591 bh->b_blocknr = lbo >> sb->s_blocksize_bits;
592
593 valid = ni->i_valid;
594
595 if (ctx == GET_BLOCK_DIRECT_IO_W) {
596
597 if (vbo >= valid)
598 set_buffer_new(bh);
599 } else if (create) {
600
601 if (bytes > bh->b_size)
602 bytes = bh->b_size;
603
604 if (vbo >= valid)
605 set_buffer_new(bh);
606
607 if (vbo + bytes > valid) {
608 ni->i_valid = vbo + bytes;
609 mark_inode_dirty(inode);
610 }
611 } else if (vbo >= valid) {
612
613
614 clear_buffer_mapped(bh);
615 } else if (vbo + bytes <= valid) {
616
617 } else if (vbo + block_size <= valid) {
618
619 bytes = block_size;
620 } else {
621
622
623
624 bytes = block_size;
625
626 if (page) {
627 u32 voff = valid - vbo;
628
629 bh->b_size = block_size;
630 off = vbo & (PAGE_SIZE - 1);
631 set_bh_page(bh, page, off);
632 ll_rw_block(REQ_OP_READ, 0, 1, &bh);
633 wait_on_buffer(bh);
634 if (!buffer_uptodate(bh)) {
635 err = -EIO;
636 goto out;
637 }
638 zero_user_segment(page, off + voff, off + block_size);
639 }
640 }
641
642 if (bh->b_size > bytes)
643 bh->b_size = bytes;
644
645#ifndef __LP64__
646 if (ctx == GET_BLOCK_DIRECT_IO_W || ctx == GET_BLOCK_DIRECT_IO_R) {
647 static_assert(sizeof(size_t) < sizeof(loff_t));
648 if (bytes > 0x40000000u)
649 bh->b_size = 0x40000000u;
650 }
651#endif
652
653 return 0;
654
655out:
656 return err;
657}
658
659int ntfs_get_block(struct inode *inode, sector_t vbn,
660 struct buffer_head *bh_result, int create)
661{
662 return ntfs_get_block_vbo(inode, (u64)vbn << inode->i_blkbits,
663 bh_result, create, GET_BLOCK_GENERAL);
664}
665
666static int ntfs_get_block_bmap(struct inode *inode, sector_t vsn,
667 struct buffer_head *bh_result, int create)
668{
669 return ntfs_get_block_vbo(inode,
670 (u64)vsn << inode->i_sb->s_blocksize_bits,
671 bh_result, create, GET_BLOCK_BMAP);
672}
673
674static sector_t ntfs_bmap(struct address_space *mapping, sector_t block)
675{
676 return generic_block_bmap(mapping, block, ntfs_get_block_bmap);
677}
678
679static int ntfs_readpage(struct file *file, struct page *page)
680{
681 int err;
682 struct address_space *mapping = page->mapping;
683 struct inode *inode = mapping->host;
684 struct ntfs_inode *ni = ntfs_i(inode);
685
686 if (is_resident(ni)) {
687 ni_lock(ni);
688 err = attr_data_read_resident(ni, page);
689 ni_unlock(ni);
690 if (err != E_NTFS_NONRESIDENT) {
691 unlock_page(page);
692 return err;
693 }
694 }
695
696 if (is_compressed(ni)) {
697 ni_lock(ni);
698 err = ni_readpage_cmpr(ni, page);
699 ni_unlock(ni);
700 return err;
701 }
702
703
704 return mpage_readpage(page, ntfs_get_block);
705}
706
707static void ntfs_readahead(struct readahead_control *rac)
708{
709 struct address_space *mapping = rac->mapping;
710 struct inode *inode = mapping->host;
711 struct ntfs_inode *ni = ntfs_i(inode);
712 u64 valid;
713 loff_t pos;
714
715 if (is_resident(ni)) {
716
717 return;
718 }
719
720 if (is_compressed(ni)) {
721
722 return;
723 }
724
725 valid = ni->i_valid;
726 pos = readahead_pos(rac);
727
728 if (valid < i_size_read(inode) && pos <= valid &&
729 valid < pos + readahead_length(rac)) {
730
731 return;
732 }
733
734 mpage_readahead(rac, ntfs_get_block);
735}
736
737static int ntfs_get_block_direct_IO_R(struct inode *inode, sector_t iblock,
738 struct buffer_head *bh_result, int create)
739{
740 return ntfs_get_block_vbo(inode, (u64)iblock << inode->i_blkbits,
741 bh_result, create, GET_BLOCK_DIRECT_IO_R);
742}
743
744static int ntfs_get_block_direct_IO_W(struct inode *inode, sector_t iblock,
745 struct buffer_head *bh_result, int create)
746{
747 return ntfs_get_block_vbo(inode, (u64)iblock << inode->i_blkbits,
748 bh_result, create, GET_BLOCK_DIRECT_IO_W);
749}
750
751static ssize_t ntfs_direct_IO(struct kiocb *iocb, struct iov_iter *iter)
752{
753 struct file *file = iocb->ki_filp;
754 struct address_space *mapping = file->f_mapping;
755 struct inode *inode = mapping->host;
756 struct ntfs_inode *ni = ntfs_i(inode);
757 loff_t vbo = iocb->ki_pos;
758 loff_t end;
759 int wr = iov_iter_rw(iter) & WRITE;
760 loff_t valid;
761 ssize_t ret;
762
763 if (is_resident(ni)) {
764
765 ret = 0;
766 goto out;
767 }
768
769 ret = blockdev_direct_IO(iocb, inode, iter,
770 wr ? ntfs_get_block_direct_IO_W
771 : ntfs_get_block_direct_IO_R);
772
773 if (ret <= 0)
774 goto out;
775
776 end = vbo + ret;
777 valid = ni->i_valid;
778 if (wr) {
779 if (end > valid && !S_ISBLK(inode->i_mode)) {
780 ni->i_valid = end;
781 mark_inode_dirty(inode);
782 }
783 } else if (vbo < valid && valid < end) {
784
785 iov_iter_revert(iter, end - valid);
786 iov_iter_zero(end - valid, iter);
787 }
788
789out:
790 return ret;
791}
792
793int ntfs_set_size(struct inode *inode, u64 new_size)
794{
795 struct super_block *sb = inode->i_sb;
796 struct ntfs_sb_info *sbi = sb->s_fs_info;
797 struct ntfs_inode *ni = ntfs_i(inode);
798 int err;
799
800
801 if (is_sparsed(ni) || is_compressed(ni)) {
802 if (new_size > sbi->maxbytes_sparse) {
803 err = -EFBIG;
804 goto out;
805 }
806 } else if (new_size > sbi->maxbytes) {
807 err = -EFBIG;
808 goto out;
809 }
810
811 ni_lock(ni);
812 down_write(&ni->file.run_lock);
813
814 err = attr_set_size(ni, ATTR_DATA, NULL, 0, &ni->file.run, new_size,
815 &ni->i_valid, true, NULL);
816
817 up_write(&ni->file.run_lock);
818 ni_unlock(ni);
819
820 mark_inode_dirty(inode);
821
822out:
823 return err;
824}
825
826static int ntfs_writepage(struct page *page, struct writeback_control *wbc)
827{
828 struct address_space *mapping = page->mapping;
829 struct inode *inode = mapping->host;
830 struct ntfs_inode *ni = ntfs_i(inode);
831 int err;
832
833 if (is_resident(ni)) {
834 ni_lock(ni);
835 err = attr_data_write_resident(ni, page);
836 ni_unlock(ni);
837 if (err != E_NTFS_NONRESIDENT) {
838 unlock_page(page);
839 return err;
840 }
841 }
842
843 return block_write_full_page(page, ntfs_get_block, wbc);
844}
845
846static int ntfs_writepages(struct address_space *mapping,
847 struct writeback_control *wbc)
848{
849 struct inode *inode = mapping->host;
850 struct ntfs_inode *ni = ntfs_i(inode);
851
852 get_block_t *get_block = is_resident(ni) ? NULL : &ntfs_get_block;
853
854 return mpage_writepages(mapping, wbc, get_block);
855}
856
857static int ntfs_get_block_write_begin(struct inode *inode, sector_t vbn,
858 struct buffer_head *bh_result, int create)
859{
860 return ntfs_get_block_vbo(inode, (u64)vbn << inode->i_blkbits,
861 bh_result, create, GET_BLOCK_WRITE_BEGIN);
862}
863
864static int ntfs_write_begin(struct file *file, struct address_space *mapping,
865 loff_t pos, u32 len, u32 flags, struct page **pagep,
866 void **fsdata)
867{
868 int err;
869 struct inode *inode = mapping->host;
870 struct ntfs_inode *ni = ntfs_i(inode);
871
872 *pagep = NULL;
873 if (is_resident(ni)) {
874 struct page *page = grab_cache_page_write_begin(
875 mapping, pos >> PAGE_SHIFT, flags);
876
877 if (!page) {
878 err = -ENOMEM;
879 goto out;
880 }
881
882 ni_lock(ni);
883 err = attr_data_read_resident(ni, page);
884 ni_unlock(ni);
885
886 if (!err) {
887 *pagep = page;
888 goto out;
889 }
890 unlock_page(page);
891 put_page(page);
892
893 if (err != E_NTFS_NONRESIDENT)
894 goto out;
895 }
896
897 err = block_write_begin(mapping, pos, len, flags, pagep,
898 ntfs_get_block_write_begin);
899
900out:
901 return err;
902}
903
904
905
906
907static int ntfs_write_end(struct file *file, struct address_space *mapping,
908 loff_t pos, u32 len, u32 copied, struct page *page,
909 void *fsdata)
910
911{
912 struct inode *inode = mapping->host;
913 struct ntfs_inode *ni = ntfs_i(inode);
914 u64 valid = ni->i_valid;
915 bool dirty = false;
916 int err;
917
918 if (is_resident(ni)) {
919 ni_lock(ni);
920 err = attr_data_write_resident(ni, page);
921 ni_unlock(ni);
922 if (!err) {
923 dirty = true;
924
925 if (page_has_buffers(page)) {
926 struct buffer_head *head, *bh;
927
928 bh = head = page_buffers(page);
929 do {
930 clear_buffer_dirty(bh);
931 clear_buffer_mapped(bh);
932 set_buffer_uptodate(bh);
933 } while (head != (bh = bh->b_this_page));
934 }
935 SetPageUptodate(page);
936 err = copied;
937 }
938 unlock_page(page);
939 put_page(page);
940 } else {
941 err = generic_write_end(file, mapping, pos, len, copied, page,
942 fsdata);
943 }
944
945 if (err >= 0) {
946 if (!(ni->std_fa & FILE_ATTRIBUTE_ARCHIVE)) {
947 inode->i_ctime = inode->i_mtime = current_time(inode);
948 ni->std_fa |= FILE_ATTRIBUTE_ARCHIVE;
949 dirty = true;
950 }
951
952 if (valid != ni->i_valid) {
953
954 dirty = true;
955 }
956
957 if (dirty)
958 mark_inode_dirty(inode);
959 }
960
961 return err;
962}
963
964int reset_log_file(struct inode *inode)
965{
966 int err;
967 loff_t pos = 0;
968 u32 log_size = inode->i_size;
969 struct address_space *mapping = inode->i_mapping;
970
971 for (;;) {
972 u32 len;
973 void *kaddr;
974 struct page *page;
975
976 len = pos + PAGE_SIZE > log_size ? (log_size - pos) : PAGE_SIZE;
977
978 err = block_write_begin(mapping, pos, len, 0, &page,
979 ntfs_get_block_write_begin);
980 if (err)
981 goto out;
982
983 kaddr = kmap_atomic(page);
984 memset(kaddr, -1, len);
985 kunmap_atomic(kaddr);
986 flush_dcache_page(page);
987
988 err = block_write_end(NULL, mapping, pos, len, len, page, NULL);
989 if (err < 0)
990 goto out;
991 pos += len;
992
993 if (pos >= log_size)
994 break;
995 balance_dirty_pages_ratelimited(mapping);
996 }
997out:
998 mark_inode_dirty_sync(inode);
999
1000 return err;
1001}
1002
1003int ntfs3_write_inode(struct inode *inode, struct writeback_control *wbc)
1004{
1005 return _ni_write_inode(inode, wbc->sync_mode == WB_SYNC_ALL);
1006}
1007
1008int ntfs_sync_inode(struct inode *inode)
1009{
1010 return _ni_write_inode(inode, 1);
1011}
1012
1013
1014
1015
1016
1017
1018
1019
1020static int writeback_inode(struct inode *inode)
1021{
1022 int ret = sync_inode_metadata(inode, 0);
1023
1024 if (!ret)
1025 ret = filemap_fdatawrite(inode->i_mapping);
1026 return ret;
1027}
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039int ntfs_flush_inodes(struct super_block *sb, struct inode *i1,
1040 struct inode *i2)
1041{
1042 int ret = 0;
1043
1044 if (i1)
1045 ret = writeback_inode(i1);
1046 if (!ret && i2)
1047 ret = writeback_inode(i2);
1048 if (!ret)
1049 ret = filemap_flush(sb->s_bdev->bd_inode->i_mapping);
1050 return ret;
1051}
1052
1053int inode_write_data(struct inode *inode, const void *data, size_t bytes)
1054{
1055 pgoff_t idx;
1056
1057
1058 for (idx = 0; bytes; idx++) {
1059 size_t op = bytes > PAGE_SIZE ? PAGE_SIZE : bytes;
1060 struct page *page = ntfs_map_page(inode->i_mapping, idx);
1061
1062 if (IS_ERR(page))
1063 return PTR_ERR(page);
1064
1065 lock_page(page);
1066 WARN_ON(!PageUptodate(page));
1067 ClearPageUptodate(page);
1068
1069 memcpy(page_address(page), data, op);
1070
1071 flush_dcache_page(page);
1072 SetPageUptodate(page);
1073 unlock_page(page);
1074
1075 ntfs_unmap_page(page);
1076
1077 bytes -= op;
1078 data = Add2Ptr(data, PAGE_SIZE);
1079 }
1080 return 0;
1081}
1082
1083
1084
1085
1086
1087
1088
1089static inline u32 ntfs_reparse_bytes(u32 uni_len)
1090{
1091
1092 return sizeof(short) * (2 * uni_len + 4) +
1093 offsetof(struct REPARSE_DATA_BUFFER,
1094 SymbolicLinkReparseBuffer.PathBuffer);
1095}
1096
1097static struct REPARSE_DATA_BUFFER *
1098ntfs_create_reparse_buffer(struct ntfs_sb_info *sbi, const char *symname,
1099 u32 size, u16 *nsize)
1100{
1101 int i, err;
1102 struct REPARSE_DATA_BUFFER *rp;
1103 __le16 *rp_name;
1104 typeof(rp->SymbolicLinkReparseBuffer) *rs;
1105
1106 rp = kzalloc(ntfs_reparse_bytes(2 * size + 2), GFP_NOFS);
1107 if (!rp)
1108 return ERR_PTR(-ENOMEM);
1109
1110 rs = &rp->SymbolicLinkReparseBuffer;
1111 rp_name = rs->PathBuffer;
1112
1113
1114 err = ntfs_nls_to_utf16(sbi, symname, size,
1115 (struct cpu_str *)(rp_name - 1), 2 * size,
1116 UTF16_LITTLE_ENDIAN);
1117 if (err < 0)
1118 goto out;
1119
1120
1121 *nsize = ntfs_reparse_bytes(err);
1122
1123 if (*nsize > sbi->reparse.max_size) {
1124 err = -EFBIG;
1125 goto out;
1126 }
1127
1128
1129 for (i = 0; i < err; i++) {
1130 if (rp_name[i] == cpu_to_le16('/'))
1131 rp_name[i] = cpu_to_le16('\\');
1132 }
1133
1134 rp->ReparseTag = IO_REPARSE_TAG_SYMLINK;
1135 rp->ReparseDataLength =
1136 cpu_to_le16(*nsize - offsetof(struct REPARSE_DATA_BUFFER,
1137 SymbolicLinkReparseBuffer));
1138
1139
1140 rs->SubstituteNameOffset = cpu_to_le16(sizeof(short) * err);
1141 rs->SubstituteNameLength = cpu_to_le16(sizeof(short) * err + 8);
1142 rs->PrintNameLength = rs->SubstituteNameOffset;
1143
1144
1145
1146
1147
1148
1149 rs->Flags = 0;
1150
1151 memmove(rp_name + err + 4, rp_name, sizeof(short) * err);
1152
1153
1154 rp_name += err;
1155 rp_name[0] = cpu_to_le16('\\');
1156 rp_name[1] = cpu_to_le16('?');
1157 rp_name[2] = cpu_to_le16('?');
1158 rp_name[3] = cpu_to_le16('\\');
1159
1160 return rp;
1161out:
1162 kfree(rp);
1163 return ERR_PTR(err);
1164}
1165
1166struct inode *ntfs_create_inode(struct user_namespace *mnt_userns,
1167 struct inode *dir, struct dentry *dentry,
1168 const struct cpu_str *uni, umode_t mode,
1169 dev_t dev, const char *symname, u32 size,
1170 struct ntfs_fnd *fnd)
1171{
1172 int err;
1173 struct super_block *sb = dir->i_sb;
1174 struct ntfs_sb_info *sbi = sb->s_fs_info;
1175 const struct qstr *name = &dentry->d_name;
1176 CLST ino = 0;
1177 struct ntfs_inode *dir_ni = ntfs_i(dir);
1178 struct ntfs_inode *ni = NULL;
1179 struct inode *inode = NULL;
1180 struct ATTRIB *attr;
1181 struct ATTR_STD_INFO5 *std5;
1182 struct ATTR_FILE_NAME *fname;
1183 struct MFT_REC *rec;
1184 u32 asize, dsize, sd_size;
1185 enum FILE_ATTRIBUTE fa;
1186 __le32 security_id = SECURITY_ID_INVALID;
1187 CLST vcn;
1188 const void *sd;
1189 u16 t16, nsize = 0, aid = 0;
1190 struct INDEX_ROOT *root, *dir_root;
1191 struct NTFS_DE *e, *new_de = NULL;
1192 struct REPARSE_DATA_BUFFER *rp = NULL;
1193 bool rp_inserted = false;
1194
1195 ni_lock_dir(dir_ni);
1196
1197 dir_root = indx_get_root(&dir_ni->dir, dir_ni, NULL, NULL);
1198 if (!dir_root) {
1199 err = -EINVAL;
1200 goto out1;
1201 }
1202
1203 if (S_ISDIR(mode)) {
1204
1205 fa = dir_ni->std_fa | FILE_ATTRIBUTE_DIRECTORY |
1206 FILE_ATTRIBUTE_ARCHIVE;
1207
1208
1209
1210
1211
1212 if (dir->i_ino == MFT_REC_ROOT)
1213 fa &= ~(FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_SYSTEM);
1214 } else if (S_ISLNK(mode)) {
1215
1216 fa = FILE_ATTRIBUTE_REPARSE_POINT;
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242 } else if (S_ISREG(mode)) {
1243 if (sbi->options->sparse) {
1244
1245 fa = FILE_ATTRIBUTE_SPARSE_FILE |
1246 FILE_ATTRIBUTE_ARCHIVE;
1247 } else if (dir_ni->std_fa & FILE_ATTRIBUTE_COMPRESSED) {
1248
1249 fa = FILE_ATTRIBUTE_COMPRESSED | FILE_ATTRIBUTE_ARCHIVE;
1250 } else {
1251
1252 fa = FILE_ATTRIBUTE_ARCHIVE;
1253 }
1254 } else {
1255 fa = FILE_ATTRIBUTE_ARCHIVE;
1256 }
1257
1258 if (!(mode & 0222))
1259 fa |= FILE_ATTRIBUTE_READONLY;
1260
1261
1262 new_de = __getname();
1263 if (!new_de) {
1264 err = -ENOMEM;
1265 goto out1;
1266 }
1267
1268
1269 ntfs_set_state(sbi, NTFS_DIRTY_DIRTY);
1270
1271
1272 err = ntfs_look_free_mft(sbi, &ino, false, NULL, NULL);
1273 if (err)
1274 goto out2;
1275
1276 ni = ntfs_new_inode(sbi, ino, fa & FILE_ATTRIBUTE_DIRECTORY);
1277 if (IS_ERR(ni)) {
1278 err = PTR_ERR(ni);
1279 ni = NULL;
1280 goto out3;
1281 }
1282 inode = &ni->vfs_inode;
1283 inode_init_owner(mnt_userns, inode, dir, mode);
1284 mode = inode->i_mode;
1285
1286 inode->i_atime = inode->i_mtime = inode->i_ctime = ni->i_crtime =
1287 current_time(inode);
1288
1289 rec = ni->mi.mrec;
1290 rec->hard_links = cpu_to_le16(1);
1291 attr = Add2Ptr(rec, le16_to_cpu(rec->attr_off));
1292
1293
1294 sd = s_default_security;
1295 sd_size = sizeof(s_default_security);
1296
1297 if (is_ntfs3(sbi)) {
1298 security_id = dir_ni->std_security_id;
1299 if (le32_to_cpu(security_id) < SECURITY_ID_FIRST) {
1300 security_id = sbi->security.def_security_id;
1301
1302 if (security_id == SECURITY_ID_INVALID &&
1303 !ntfs_insert_security(sbi, sd, sd_size,
1304 &security_id, NULL))
1305 sbi->security.def_security_id = security_id;
1306 }
1307 }
1308
1309
1310 std5 = Add2Ptr(attr, SIZEOF_RESIDENT);
1311
1312 if (security_id == SECURITY_ID_INVALID) {
1313 dsize = sizeof(struct ATTR_STD_INFO);
1314 } else {
1315 dsize = sizeof(struct ATTR_STD_INFO5);
1316 std5->security_id = security_id;
1317 ni->std_security_id = security_id;
1318 }
1319 asize = SIZEOF_RESIDENT + dsize;
1320
1321 attr->type = ATTR_STD;
1322 attr->size = cpu_to_le32(asize);
1323 attr->id = cpu_to_le16(aid++);
1324 attr->res.data_off = SIZEOF_RESIDENT_LE;
1325 attr->res.data_size = cpu_to_le32(dsize);
1326
1327 std5->cr_time = std5->m_time = std5->c_time = std5->a_time =
1328 kernel2nt(&inode->i_atime);
1329
1330 ni->std_fa = fa;
1331 std5->fa = fa;
1332
1333 attr = Add2Ptr(attr, asize);
1334
1335
1336 err = fill_name_de(sbi, new_de, name, uni);
1337 if (err)
1338 goto out4;
1339
1340 mi_get_ref(&ni->mi, &new_de->ref);
1341
1342 fname = (struct ATTR_FILE_NAME *)(new_de + 1);
1343 mi_get_ref(&dir_ni->mi, &fname->home);
1344 fname->dup.cr_time = fname->dup.m_time = fname->dup.c_time =
1345 fname->dup.a_time = std5->cr_time;
1346 fname->dup.alloc_size = fname->dup.data_size = 0;
1347 fname->dup.fa = std5->fa;
1348 fname->dup.ea_size = fname->dup.reparse = 0;
1349
1350 dsize = le16_to_cpu(new_de->key_size);
1351 asize = ALIGN(SIZEOF_RESIDENT + dsize, 8);
1352
1353 attr->type = ATTR_NAME;
1354 attr->size = cpu_to_le32(asize);
1355 attr->res.data_off = SIZEOF_RESIDENT_LE;
1356 attr->res.flags = RESIDENT_FLAG_INDEXED;
1357 attr->id = cpu_to_le16(aid++);
1358 attr->res.data_size = cpu_to_le32(dsize);
1359 memcpy(Add2Ptr(attr, SIZEOF_RESIDENT), fname, dsize);
1360
1361 attr = Add2Ptr(attr, asize);
1362
1363 if (security_id == SECURITY_ID_INVALID) {
1364
1365 asize = SIZEOF_RESIDENT + ALIGN(sd_size, 8);
1366
1367 attr->type = ATTR_SECURE;
1368 attr->size = cpu_to_le32(asize);
1369 attr->id = cpu_to_le16(aid++);
1370 attr->res.data_off = SIZEOF_RESIDENT_LE;
1371 attr->res.data_size = cpu_to_le32(sd_size);
1372 memcpy(Add2Ptr(attr, SIZEOF_RESIDENT), sd, sd_size);
1373
1374 attr = Add2Ptr(attr, asize);
1375 }
1376
1377 attr->id = cpu_to_le16(aid++);
1378 if (fa & FILE_ATTRIBUTE_DIRECTORY) {
1379
1380
1381
1382
1383 dsize = sizeof(struct INDEX_ROOT) + sizeof(struct NTFS_DE);
1384 asize = sizeof(I30_NAME) + SIZEOF_RESIDENT + dsize;
1385
1386 attr->type = ATTR_ROOT;
1387 attr->size = cpu_to_le32(asize);
1388
1389 attr->name_len = ARRAY_SIZE(I30_NAME);
1390 attr->name_off = SIZEOF_RESIDENT_LE;
1391 attr->res.data_off =
1392 cpu_to_le16(sizeof(I30_NAME) + SIZEOF_RESIDENT);
1393 attr->res.data_size = cpu_to_le32(dsize);
1394 memcpy(Add2Ptr(attr, SIZEOF_RESIDENT), I30_NAME,
1395 sizeof(I30_NAME));
1396
1397 root = Add2Ptr(attr, sizeof(I30_NAME) + SIZEOF_RESIDENT);
1398 memcpy(root, dir_root, offsetof(struct INDEX_ROOT, ihdr));
1399 root->ihdr.de_off =
1400 cpu_to_le32(sizeof(struct INDEX_HDR));
1401 root->ihdr.used = cpu_to_le32(sizeof(struct INDEX_HDR) +
1402 sizeof(struct NTFS_DE));
1403 root->ihdr.total = root->ihdr.used;
1404
1405 e = Add2Ptr(root, sizeof(struct INDEX_ROOT));
1406 e->size = cpu_to_le16(sizeof(struct NTFS_DE));
1407 e->flags = NTFS_IE_LAST;
1408 } else if (S_ISLNK(mode)) {
1409
1410
1411
1412
1413 asize = SIZEOF_RESIDENT;
1414
1415
1416 attr->type = ATTR_DATA;
1417 attr->size = cpu_to_le32(SIZEOF_RESIDENT);
1418 attr->name_off = SIZEOF_RESIDENT_LE;
1419 attr->res.data_off = SIZEOF_RESIDENT_LE;
1420 } else if (S_ISREG(mode)) {
1421
1422
1423
1424 attr->type = ATTR_DATA;
1425 attr->non_res = 1;
1426 attr->nres.evcn = cpu_to_le64(-1ll);
1427 if (fa & FILE_ATTRIBUTE_SPARSE_FILE) {
1428 attr->size = cpu_to_le32(SIZEOF_NONRESIDENT_EX + 8);
1429 attr->name_off = SIZEOF_NONRESIDENT_EX_LE;
1430 attr->flags = ATTR_FLAG_SPARSED;
1431 asize = SIZEOF_NONRESIDENT_EX + 8;
1432 } else if (fa & FILE_ATTRIBUTE_COMPRESSED) {
1433 attr->size = cpu_to_le32(SIZEOF_NONRESIDENT_EX + 8);
1434 attr->name_off = SIZEOF_NONRESIDENT_EX_LE;
1435 attr->flags = ATTR_FLAG_COMPRESSED;
1436 attr->nres.c_unit = COMPRESSION_UNIT;
1437 asize = SIZEOF_NONRESIDENT_EX + 8;
1438 } else {
1439 attr->size = cpu_to_le32(SIZEOF_NONRESIDENT + 8);
1440 attr->name_off = SIZEOF_NONRESIDENT_LE;
1441 asize = SIZEOF_NONRESIDENT + 8;
1442 }
1443 attr->nres.run_off = attr->name_off;
1444 } else {
1445
1446
1447
1448 attr->type = ATTR_DATA;
1449 attr->size = cpu_to_le32(SIZEOF_RESIDENT);
1450 attr->name_off = SIZEOF_RESIDENT_LE;
1451 if (fa & FILE_ATTRIBUTE_SPARSE_FILE)
1452 attr->flags = ATTR_FLAG_SPARSED;
1453 else if (fa & FILE_ATTRIBUTE_COMPRESSED)
1454 attr->flags = ATTR_FLAG_COMPRESSED;
1455 attr->res.data_off = SIZEOF_RESIDENT_LE;
1456 asize = SIZEOF_RESIDENT;
1457 ni->ni_flags |= NI_FLAG_RESIDENT;
1458 }
1459
1460 if (S_ISDIR(mode)) {
1461 ni->ni_flags |= NI_FLAG_DIR;
1462 err = indx_init(&ni->dir, sbi, attr, INDEX_MUTEX_I30);
1463 if (err)
1464 goto out4;
1465 } else if (S_ISLNK(mode)) {
1466 rp = ntfs_create_reparse_buffer(sbi, symname, size, &nsize);
1467
1468 if (IS_ERR(rp)) {
1469 err = PTR_ERR(rp);
1470 rp = NULL;
1471 goto out4;
1472 }
1473
1474
1475
1476
1477 attr = Add2Ptr(attr, asize);
1478 attr->type = ATTR_REPARSE;
1479 attr->id = cpu_to_le16(aid++);
1480
1481
1482 asize = ALIGN(SIZEOF_RESIDENT + nsize, 8);
1483 t16 = PtrOffset(rec, attr);
1484
1485
1486
1487
1488
1489 if (asize + t16 + 0x78 + 8 > sbi->record_size) {
1490 CLST alen;
1491 CLST clst = bytes_to_cluster(sbi, nsize);
1492
1493
1494 t16 = sbi->record_size - t16 - SIZEOF_NONRESIDENT;
1495
1496 attr->non_res = 1;
1497 attr->nres.evcn = cpu_to_le64(clst - 1);
1498 attr->name_off = SIZEOF_NONRESIDENT_LE;
1499 attr->nres.run_off = attr->name_off;
1500 attr->nres.data_size = cpu_to_le64(nsize);
1501 attr->nres.valid_size = attr->nres.data_size;
1502 attr->nres.alloc_size =
1503 cpu_to_le64(ntfs_up_cluster(sbi, nsize));
1504
1505 err = attr_allocate_clusters(sbi, &ni->file.run, 0, 0,
1506 clst, NULL, 0, &alen, 0,
1507 NULL);
1508 if (err)
1509 goto out5;
1510
1511 err = run_pack(&ni->file.run, 0, clst,
1512 Add2Ptr(attr, SIZEOF_NONRESIDENT), t16,
1513 &vcn);
1514 if (err < 0)
1515 goto out5;
1516
1517 if (vcn != clst) {
1518 err = -EINVAL;
1519 goto out5;
1520 }
1521
1522 asize = SIZEOF_NONRESIDENT + ALIGN(err, 8);
1523 } else {
1524 attr->res.data_off = SIZEOF_RESIDENT_LE;
1525 attr->res.data_size = cpu_to_le32(nsize);
1526 memcpy(Add2Ptr(attr, SIZEOF_RESIDENT), rp, nsize);
1527 nsize = 0;
1528 }
1529
1530 inode->i_size = size;
1531
1532 attr->size = cpu_to_le32(asize);
1533
1534 err = ntfs_insert_reparse(sbi, IO_REPARSE_TAG_SYMLINK,
1535 &new_de->ref);
1536 if (err)
1537 goto out5;
1538
1539 rp_inserted = true;
1540 }
1541
1542 attr = Add2Ptr(attr, asize);
1543 attr->type = ATTR_END;
1544
1545 rec->used = cpu_to_le32(PtrOffset(rec, attr) + 8);
1546 rec->next_attr_id = cpu_to_le16(aid);
1547
1548
1549 err = indx_insert_entry(&dir_ni->dir, dir_ni, new_de, sbi, fnd, 0);
1550 if (err)
1551 goto out6;
1552
1553
1554 ni_unlock(dir_ni);
1555
1556 inode->i_generation = le16_to_cpu(rec->seq);
1557
1558 dir->i_mtime = dir->i_ctime = inode->i_atime;
1559
1560 if (S_ISDIR(mode)) {
1561 inode->i_op = &ntfs_dir_inode_operations;
1562 inode->i_fop = &ntfs_dir_operations;
1563 } else if (S_ISLNK(mode)) {
1564 inode->i_op = &ntfs_link_inode_operations;
1565 inode->i_fop = NULL;
1566 inode->i_mapping->a_ops = &ntfs_aops;
1567 inode->i_size = size;
1568 inode_nohighmem(inode);
1569 } else if (S_ISREG(mode)) {
1570 inode->i_op = &ntfs_file_inode_operations;
1571 inode->i_fop = &ntfs_file_operations;
1572 inode->i_mapping->a_ops =
1573 is_compressed(ni) ? &ntfs_aops_cmpr : &ntfs_aops;
1574 init_rwsem(&ni->file.run_lock);
1575 } else {
1576 inode->i_op = &ntfs_special_inode_operations;
1577 init_special_inode(inode, mode, dev);
1578 }
1579
1580#ifdef CONFIG_NTFS3_FS_POSIX_ACL
1581 if (!S_ISLNK(mode) && (sb->s_flags & SB_POSIXACL)) {
1582 err = ntfs_init_acl(mnt_userns, inode, dir);
1583 if (err)
1584 goto out7;
1585 } else
1586#endif
1587 {
1588 inode->i_flags |= S_NOSEC;
1589 }
1590
1591
1592 if (nsize) {
1593 err = ntfs_sb_write_run(sbi, &ni->file.run, 0, rp, nsize, 0);
1594 if (err)
1595 goto out7;
1596 }
1597
1598
1599
1600
1601
1602 d_instantiate(dentry, inode);
1603
1604 ntfs_save_wsl_perm(inode);
1605 mark_inode_dirty(dir);
1606 mark_inode_dirty(inode);
1607
1608
1609 goto out2;
1610
1611out7:
1612
1613
1614 ni_lock_dir(dir_ni);
1615 indx_delete_entry(&dir_ni->dir, dir_ni, new_de + 1,
1616 le16_to_cpu(new_de->key_size), sbi);
1617
1618out6:
1619 if (rp_inserted)
1620 ntfs_remove_reparse(sbi, IO_REPARSE_TAG_SYMLINK, &new_de->ref);
1621
1622out5:
1623 if (S_ISDIR(mode) || run_is_empty(&ni->file.run))
1624 goto out4;
1625
1626 run_deallocate(sbi, &ni->file.run, false);
1627
1628out4:
1629 clear_rec_inuse(rec);
1630 clear_nlink(inode);
1631 ni->mi.dirty = false;
1632 discard_new_inode(inode);
1633out3:
1634 ntfs_mark_rec_free(sbi, ino);
1635
1636out2:
1637 __putname(new_de);
1638 kfree(rp);
1639
1640out1:
1641 if (err) {
1642 ni_unlock(dir_ni);
1643 return ERR_PTR(err);
1644 }
1645
1646 unlock_new_inode(inode);
1647
1648 return inode;
1649}
1650
1651int ntfs_link_inode(struct inode *inode, struct dentry *dentry)
1652{
1653 int err;
1654 struct ntfs_inode *ni = ntfs_i(inode);
1655 struct ntfs_sb_info *sbi = inode->i_sb->s_fs_info;
1656 struct NTFS_DE *de;
1657 struct ATTR_FILE_NAME *de_name;
1658
1659
1660 de = __getname();
1661 if (!de)
1662 return -ENOMEM;
1663
1664
1665 ntfs_set_state(sbi, NTFS_DIRTY_DIRTY);
1666
1667
1668 err = fill_name_de(sbi, de, &dentry->d_name, NULL);
1669 if (err)
1670 goto out;
1671
1672 de_name = (struct ATTR_FILE_NAME *)(de + 1);
1673
1674 de_name->dup.cr_time = de_name->dup.m_time = de_name->dup.c_time =
1675 de_name->dup.a_time = kernel2nt(&inode->i_ctime);
1676 de_name->dup.alloc_size = de_name->dup.data_size =
1677 cpu_to_le64(inode->i_size);
1678 de_name->dup.fa = ni->std_fa;
1679 de_name->dup.ea_size = de_name->dup.reparse = 0;
1680
1681 err = ni_add_name(ntfs_i(d_inode(dentry->d_parent)), ni, de);
1682out:
1683 __putname(de);
1684 return err;
1685}
1686
1687
1688
1689
1690
1691
1692
1693int ntfs_unlink_inode(struct inode *dir, const struct dentry *dentry)
1694{
1695 int err;
1696 struct ntfs_sb_info *sbi = dir->i_sb->s_fs_info;
1697 struct inode *inode = d_inode(dentry);
1698 struct ntfs_inode *ni = ntfs_i(inode);
1699 struct ntfs_inode *dir_ni = ntfs_i(dir);
1700 struct NTFS_DE *de, *de2 = NULL;
1701 int undo_remove;
1702
1703 if (ntfs_is_meta_file(sbi, ni->mi.rno))
1704 return -EINVAL;
1705
1706
1707 de = __getname();
1708 if (!de)
1709 return -ENOMEM;
1710
1711 ni_lock(ni);
1712
1713 if (S_ISDIR(inode->i_mode) && !dir_is_empty(inode)) {
1714 err = -ENOTEMPTY;
1715 goto out;
1716 }
1717
1718 err = fill_name_de(sbi, de, &dentry->d_name, NULL);
1719 if (err < 0)
1720 goto out;
1721
1722 undo_remove = 0;
1723 err = ni_remove_name(dir_ni, ni, de, &de2, &undo_remove);
1724
1725 if (!err) {
1726 drop_nlink(inode);
1727 dir->i_mtime = dir->i_ctime = current_time(dir);
1728 mark_inode_dirty(dir);
1729 inode->i_ctime = dir->i_ctime;
1730 if (inode->i_nlink)
1731 mark_inode_dirty(inode);
1732 } else if (!ni_remove_name_undo(dir_ni, ni, de, de2, undo_remove)) {
1733 make_bad_inode(inode);
1734 ntfs_inode_err(inode, "failed to undo unlink");
1735 ntfs_set_state(sbi, NTFS_DIRTY_ERROR);
1736 } else {
1737 if (ni_is_dirty(dir))
1738 mark_inode_dirty(dir);
1739 if (ni_is_dirty(inode))
1740 mark_inode_dirty(inode);
1741 }
1742
1743out:
1744 ni_unlock(ni);
1745 __putname(de);
1746 return err;
1747}
1748
1749void ntfs_evict_inode(struct inode *inode)
1750{
1751 truncate_inode_pages_final(&inode->i_data);
1752
1753 if (inode->i_nlink)
1754 _ni_write_inode(inode, inode_needs_sync(inode));
1755
1756 invalidate_inode_buffers(inode);
1757 clear_inode(inode);
1758
1759 ni_clear(ntfs_i(inode));
1760}
1761
1762static noinline int ntfs_readlink_hlp(struct inode *inode, char *buffer,
1763 int buflen)
1764{
1765 int i, err = -EINVAL;
1766 struct ntfs_inode *ni = ntfs_i(inode);
1767 struct super_block *sb = inode->i_sb;
1768 struct ntfs_sb_info *sbi = sb->s_fs_info;
1769 u64 size;
1770 u16 ulen = 0;
1771 void *to_free = NULL;
1772 struct REPARSE_DATA_BUFFER *rp;
1773 const __le16 *uname;
1774 struct ATTRIB *attr;
1775
1776
1777 static_assert(!offsetof(struct REPARSE_DATA_BUFFER, ReparseTag));
1778 static_assert(sizeof(u32) == sizeof(rp->ReparseTag));
1779
1780 *buffer = 0;
1781
1782 attr = ni_find_attr(ni, NULL, NULL, ATTR_REPARSE, NULL, 0, NULL, NULL);
1783 if (!attr)
1784 goto out;
1785
1786 if (!attr->non_res) {
1787 rp = resident_data_ex(attr, sizeof(struct REPARSE_DATA_BUFFER));
1788 if (!rp)
1789 goto out;
1790 size = le32_to_cpu(attr->res.data_size);
1791 } else {
1792 size = le64_to_cpu(attr->nres.data_size);
1793 rp = NULL;
1794 }
1795
1796 if (size > sbi->reparse.max_size || size <= sizeof(u32))
1797 goto out;
1798
1799 if (!rp) {
1800 rp = kmalloc(size, GFP_NOFS);
1801 if (!rp) {
1802 err = -ENOMEM;
1803 goto out;
1804 }
1805 to_free = rp;
1806
1807 err = ntfs_read_run_nb(sbi, &ni->file.run, 0, rp, size, NULL);
1808 if (err)
1809 goto out;
1810 }
1811
1812
1813 switch (rp->ReparseTag) {
1814 case IO_REPARSE_TAG_MOUNT_POINT:
1815
1816
1817 if (size <= offsetof(struct REPARSE_DATA_BUFFER,
1818 MountPointReparseBuffer.PathBuffer))
1819 goto out;
1820 uname = Add2Ptr(rp,
1821 offsetof(struct REPARSE_DATA_BUFFER,
1822 MountPointReparseBuffer.PathBuffer) +
1823 le16_to_cpu(rp->MountPointReparseBuffer
1824 .PrintNameOffset));
1825 ulen = le16_to_cpu(rp->MountPointReparseBuffer.PrintNameLength);
1826 break;
1827
1828 case IO_REPARSE_TAG_SYMLINK:
1829
1830
1831 if (size <= offsetof(struct REPARSE_DATA_BUFFER,
1832 SymbolicLinkReparseBuffer.PathBuffer))
1833 goto out;
1834 uname = Add2Ptr(
1835 rp, offsetof(struct REPARSE_DATA_BUFFER,
1836 SymbolicLinkReparseBuffer.PathBuffer) +
1837 le16_to_cpu(rp->SymbolicLinkReparseBuffer
1838 .PrintNameOffset));
1839 ulen = le16_to_cpu(
1840 rp->SymbolicLinkReparseBuffer.PrintNameLength);
1841 break;
1842
1843 case IO_REPARSE_TAG_CLOUD:
1844 case IO_REPARSE_TAG_CLOUD_1:
1845 case IO_REPARSE_TAG_CLOUD_2:
1846 case IO_REPARSE_TAG_CLOUD_3:
1847 case IO_REPARSE_TAG_CLOUD_4:
1848 case IO_REPARSE_TAG_CLOUD_5:
1849 case IO_REPARSE_TAG_CLOUD_6:
1850 case IO_REPARSE_TAG_CLOUD_7:
1851 case IO_REPARSE_TAG_CLOUD_8:
1852 case IO_REPARSE_TAG_CLOUD_9:
1853 case IO_REPARSE_TAG_CLOUD_A:
1854 case IO_REPARSE_TAG_CLOUD_B:
1855 case IO_REPARSE_TAG_CLOUD_C:
1856 case IO_REPARSE_TAG_CLOUD_D:
1857 case IO_REPARSE_TAG_CLOUD_E:
1858 case IO_REPARSE_TAG_CLOUD_F:
1859 err = sizeof("OneDrive") - 1;
1860 if (err > buflen)
1861 err = buflen;
1862 memcpy(buffer, "OneDrive", err);
1863 goto out;
1864
1865 default:
1866 if (IsReparseTagMicrosoft(rp->ReparseTag)) {
1867
1868 goto out;
1869 }
1870 if (!IsReparseTagNameSurrogate(rp->ReparseTag) ||
1871 size <= sizeof(struct REPARSE_POINT)) {
1872 goto out;
1873 }
1874
1875
1876 uname = Add2Ptr(rp, sizeof(struct REPARSE_POINT));
1877 ulen = le16_to_cpu(rp->ReparseDataLength) -
1878 sizeof(struct REPARSE_POINT);
1879 }
1880
1881
1882 ulen >>= 1;
1883
1884
1885 if (!ulen || uname + ulen > (__le16 *)Add2Ptr(rp, size))
1886 goto out;
1887
1888
1889 if (!uname[ulen - 1])
1890 ulen -= 1;
1891
1892 err = ntfs_utf16_to_nls(sbi, uname, ulen, buffer, buflen);
1893
1894 if (err < 0)
1895 goto out;
1896
1897
1898 for (i = 0; i < err; i++) {
1899 if (buffer[i] == '\\')
1900 buffer[i] = '/';
1901 }
1902
1903
1904 buffer[err] = 0;
1905out:
1906 kfree(to_free);
1907 return err;
1908}
1909
1910static const char *ntfs_get_link(struct dentry *de, struct inode *inode,
1911 struct delayed_call *done)
1912{
1913 int err;
1914 char *ret;
1915
1916 if (!de)
1917 return ERR_PTR(-ECHILD);
1918
1919 ret = kmalloc(PAGE_SIZE, GFP_NOFS);
1920 if (!ret)
1921 return ERR_PTR(-ENOMEM);
1922
1923 err = ntfs_readlink_hlp(inode, ret, PAGE_SIZE);
1924 if (err < 0) {
1925 kfree(ret);
1926 return ERR_PTR(err);
1927 }
1928
1929 set_delayed_call(done, kfree_link, ret);
1930
1931 return ret;
1932}
1933
1934
1935const struct inode_operations ntfs_link_inode_operations = {
1936 .get_link = ntfs_get_link,
1937 .setattr = ntfs3_setattr,
1938 .listxattr = ntfs_listxattr,
1939 .permission = ntfs_permission,
1940 .get_acl = ntfs_get_acl,
1941 .set_acl = ntfs_set_acl,
1942};
1943
1944const struct address_space_operations ntfs_aops = {
1945 .readpage = ntfs_readpage,
1946 .readahead = ntfs_readahead,
1947 .writepage = ntfs_writepage,
1948 .writepages = ntfs_writepages,
1949 .write_begin = ntfs_write_begin,
1950 .write_end = ntfs_write_end,
1951 .direct_IO = ntfs_direct_IO,
1952 .bmap = ntfs_bmap,
1953 .set_page_dirty = __set_page_dirty_buffers,
1954};
1955
1956const struct address_space_operations ntfs_aops_cmpr = {
1957 .readpage = ntfs_readpage,
1958 .readahead = ntfs_readahead,
1959};
1960
1961
