1 // SPDX-License-Identifier: GPL-2.0
4 * Copyright (C) 2019-2021 Paragon Software GmbH, All rights reserved.
8 #include <linux/buffer_head.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>
21 * ntfs_read_mft - Read record and parses MFT.
23 static struct inode
*ntfs_read_mft(struct inode
*inode
,
24 const struct cpu_str
*name
,
25 const struct MFT_REF
*ref
)
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
;
32 struct ATTR_STD_INFO5
*std5
= NULL
;
33 struct ATTR_LIST_ENTRY
*le
;
35 bool is_match
= false;
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
; // 0x18 bytes
46 struct runs_tree
*run
;
49 /* Setup 'uid' and 'gid' */
50 inode
->i_uid
= sbi
->options
->fs_uid
;
51 inode
->i_gid
= sbi
->options
->fs_gid
;
53 err
= mi_init(&ni
->mi
, sbi
, ino
);
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
);
61 init_rwsem(&ni
->file
.run_lock
);
63 if (!run_add_entry(&ni
->file
.run
, 0, t64
, t32
, true)) {
69 err
= mi_read(&ni
->mi
, ino
== MFT_REC_MFT
);
76 if (sbi
->flags
& NTFS_FLAGS_LOG_REPLAYING
) {
78 } else if (ref
->seq
!= rec
->seq
) {
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
));
83 } else if (!is_rec_inuse(rec
)) {
85 ntfs_err(sb
, "Inode r=%x is not in use!", (u32
)ino
);
89 if (le32_to_cpu(rec
->total
) != sbi
->record_size
) {
95 if (!is_rec_base(rec
))
98 /* Record should contain $I30 root. */
99 is_dir
= rec
->flags
& RECORD_FLAG_DIR
;
101 inode
->i_generation
= le16_to_cpu(rec
->seq
);
103 /* Enumerate all struct Attributes MFT. */
108 * To reduce tab pressure use goto instead of
109 * while( (attr = ni_enum_attr_ex(ni, attr, &le, NULL) ))
114 attr
= ni_enum_attr_ex(ni
, attr
, &le
, NULL
);
119 /* This is non primary attribute segment. Ignore if not MFT. */
120 if (ino
!= MFT_REC_MFT
|| attr
->type
!= ATTR_DATA
)
124 asize
= le32_to_cpu(attr
->size
);
125 goto attr_unpack_run
;
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
);
132 switch (attr
->type
) {
135 asize
< sizeof(struct ATTR_STD_INFO
) + roff
||
136 rsize
< sizeof(struct ATTR_STD_INFO
))
142 std5
= Add2Ptr(attr
, roff
);
145 nt2kernel(std5
->cr_time
, &ni
->i_crtime
);
147 nt2kernel(std5
->a_time
, &inode
->i_atime
);
148 nt2kernel(std5
->c_time
, &inode
->i_ctime
);
149 nt2kernel(std5
->m_time
, &inode
->i_mtime
);
151 ni
->std_fa
= std5
->fa
;
153 if (asize
>= sizeof(struct ATTR_STD_INFO5
) + roff
&&
154 rsize
>= sizeof(struct ATTR_STD_INFO5
))
155 ni
->std_security_id
= std5
->security_id
;
159 if (attr
->name_len
|| le
|| ino
== MFT_REC_LOG
)
162 err
= ntfs_load_attr_list(ni
, attr
);
171 if (attr
->non_res
|| asize
< SIZEOF_ATTRIBUTE_FILENAME
+ roff
||
172 rsize
< SIZEOF_ATTRIBUTE_FILENAME
)
175 fname
= Add2Ptr(attr
, roff
);
176 if (fname
->type
== FILE_NAME_DOS
)
180 if (name
&& name
->len
== fname
->name_len
&&
181 !ntfs_cmp_names_cpu(name
, (struct le_str
*)&fname
->name_len
,
189 /* Ignore data attribute in dir record. */
193 if (ino
== MFT_REC_BADCLUST
&& !attr
->non_res
)
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 /* File contains stream attribute. Ignore it. */
207 if (is_attr_sparsed(attr
))
208 ni
->std_fa
|= FILE_ATTRIBUTE_SPARSE_FILE
;
210 ni
->std_fa
&= ~FILE_ATTRIBUTE_SPARSE_FILE
;
212 if (is_attr_compressed(attr
))
213 ni
->std_fa
|= FILE_ATTRIBUTE_COMPRESSED
;
215 ni
->std_fa
&= ~FILE_ATTRIBUTE_COMPRESSED
;
217 if (is_attr_encrypted(attr
))
218 ni
->std_fa
|= FILE_ATTRIBUTE_ENCRYPTED
;
220 ni
->std_fa
&= ~FILE_ATTRIBUTE_ENCRYPTED
;
222 if (!attr
->non_res
) {
223 ni
->i_valid
= inode
->i_size
= rsize
;
224 inode_set_bytes(inode
, rsize
);
227 mode
= S_IFREG
| (0777 & sbi
->options
->fs_fmask_inv
);
229 if (!attr
->non_res
) {
230 ni
->ni_flags
|= NI_FLAG_RESIDENT
;
234 inode_set_bytes(inode
, attr_ondisk_size(attr
));
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
)
241 run
= ino
== MFT_REC_BITMAP
? &sbi
->used
.bitmap
.run
249 root
= Add2Ptr(attr
, roff
);
252 if (attr
->name_len
!= ARRAY_SIZE(I30_NAME
) ||
253 memcmp(attr_name(attr
), I30_NAME
, sizeof(I30_NAME
)))
256 if (root
->type
!= ATTR_NAME
||
257 root
->rule
!= NTFS_COLLATION_TYPE_FILENAME
)
263 ni
->ni_flags
|= NI_FLAG_DIR
;
265 err
= indx_init(&ni
->dir
, sbi
, attr
, INDEX_MUTEX_I30
);
270 ? (S_IFDIR
| (0777 & sbi
->options
->fs_dmask_inv
))
275 if (!is_root
|| attr
->name_len
!= ARRAY_SIZE(I30_NAME
) ||
276 memcmp(attr_name(attr
), I30_NAME
, sizeof(I30_NAME
)))
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
));
283 run
= &ni
->dir
.alloc_run
;
287 if (ino
== MFT_REC_MFT
) {
290 #ifndef CONFIG_NTFS3_64BIT_CLUSTER
291 /* 0x20000000 = 2^32 / 8 */
292 if (le64_to_cpu(attr
->nres
.alloc_size
) >= 0x20000000)
295 run
= &sbi
->mft
.bitmap
.run
;
297 } else if (is_dir
&& attr
->name_len
== ARRAY_SIZE(I30_NAME
) &&
298 !memcmp(attr_name(attr
), I30_NAME
,
301 run
= &ni
->dir
.bitmap_run
;
310 rp_fa
= ni_parse_reparse(ni
, attr
, &rp
);
315 * Assume one unicode symbol == one utf8.
317 inode
->i_size
= le16_to_cpu(rp
.SymbolicLinkReparseBuffer
321 ni
->i_valid
= inode
->i_size
;
323 /* Clear directory bit. */
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
;
329 run_close(&ni
->file
.run
);
331 mode
= S_IFLNK
| 0777;
335 goto attr_unpack_run
; // Double break.
339 case REPARSE_COMPRESSED
:
342 case REPARSE_DEDUPLICATED
:
348 if (!attr
->name_len
&&
349 resident_data_ex(attr
, sizeof(struct EA_INFO
))) {
350 ni
->ni_flags
|= NI_FLAG_EA
;
352 * ntfs_get_wsl_perm updates inode->i_uid, inode->i_gid, inode->i_mode
354 inode
->i_mode
= mode
;
355 ntfs_get_wsl_perm(inode
);
356 mode
= inode
->i_mode
;
365 roff
= le16_to_cpu(attr
->nres
.run_off
);
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
);
380 if (!is_match
&& name
) {
381 /* Reuse rec as buffer for ascii name. */
386 if (std5
->fa
& FILE_ATTRIBUTE_READONLY
)
394 if (names
!= le16_to_cpu(rec
->hard_links
)) {
395 /* Correct minor error on the fly. Do not mark inode as dirty. */
396 rec
->hard_links
= cpu_to_le16(names
);
400 set_nlink(inode
, names
);
403 ni
->std_fa
|= FILE_ATTRIBUTE_DIRECTORY
;
406 * Dot and dot-dot should be included in count but was not
407 * included in enumeration.
408 * Usually a hard links to directories are disabled.
410 inode
->i_op
= &ntfs_dir_inode_operations
;
411 inode
->i_fop
= &ntfs_dir_operations
;
413 } else if (S_ISLNK(mode
)) {
414 ni
->std_fa
&= ~FILE_ATTRIBUTE_DIRECTORY
;
415 inode
->i_op
= &ntfs_link_inode_operations
;
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
) ||
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 /* Records in $Extend are not a files or general directories. */
433 inode
->i_op
= &ntfs_file_inode_operations
;
439 if ((sbi
->options
->sys_immutable
&&
440 (std5
->fa
& FILE_ATTRIBUTE_SYSTEM
)) &&
441 !S_ISFIFO(mode
) && !S_ISSOCK(mode
) && !S_ISLNK(mode
)) {
442 inode
->i_flags
|= S_IMMUTABLE
;
444 inode
->i_flags
&= ~S_IMMUTABLE
;
447 inode
->i_mode
= mode
;
448 if (!(ni
->ni_flags
& NI_FLAG_EA
)) {
449 /* If no xattr then no security (stored in xattr). */
450 inode
->i_flags
|= S_NOSEC
;
454 if (ino
== MFT_REC_MFT
&& !sb
->s_root
)
457 unlock_new_inode(inode
);
462 if (ino
== MFT_REC_MFT
&& !sb
->s_root
)
472 * Return: 1 if match.
474 static int ntfs_test_inode(struct inode
*inode
, void *data
)
476 struct MFT_REF
*ref
= data
;
478 return ino_get(ref
) == inode
->i_ino
;
481 static int ntfs_set_inode(struct inode
*inode
, void *data
)
483 const struct MFT_REF
*ref
= data
;
485 inode
->i_ino
= ino_get(ref
);
489 struct inode
*ntfs_iget5(struct super_block
*sb
, const struct MFT_REF
*ref
,
490 const struct cpu_str
*name
)
494 inode
= iget5_locked(sb
, ino_get(ref
), ntfs_test_inode
, ntfs_set_inode
,
496 if (unlikely(!inode
))
497 return ERR_PTR(-ENOMEM
);
499 /* If this is a freshly allocated inode, need to read it now. */
500 if (inode
->i_state
& I_NEW
)
501 inode
= ntfs_read_mft(inode
, name
, ref
);
502 else if (ref
->seq
!= ntfs_i(inode
)->mi
.mrec
->seq
) {
503 /* Inode overlaps? */
504 _ntfs_bad_inode(inode
);
511 GET_BLOCK_GENERAL
= 0,
512 GET_BLOCK_WRITE_BEGIN
= 1,
513 GET_BLOCK_DIRECT_IO_R
= 2,
514 GET_BLOCK_DIRECT_IO_W
= 3,
518 static noinline
int ntfs_get_block_vbo(struct inode
*inode
, u64 vbo
,
519 struct buffer_head
*bh
, int create
,
520 enum get_block_ctx ctx
)
522 struct super_block
*sb
= inode
->i_sb
;
523 struct ntfs_sb_info
*sbi
= sb
->s_fs_info
;
524 struct ntfs_inode
*ni
= ntfs_i(inode
);
525 struct page
*page
= bh
->b_page
;
526 u8 cluster_bits
= sbi
->cluster_bits
;
527 u32 block_size
= sb
->s_blocksize
;
528 u64 bytes
, lbo
, valid
;
534 /* Clear previous state. */
535 clear_buffer_new(bh
);
536 clear_buffer_uptodate(bh
);
538 /* Direct write uses 'create=0'. */
539 if (!create
&& vbo
>= ni
->i_valid
) {
544 if (vbo
>= inode
->i_size
) {
549 if (is_resident(ni
)) {
551 err
= attr_data_read_resident(ni
, page
);
555 set_buffer_uptodate(bh
);
556 bh
->b_size
= block_size
;
560 vcn
= vbo
>> cluster_bits
;
561 off
= vbo
& sbi
->cluster_mask
;
564 err
= attr_data_get_block(ni
, vcn
, 1, &lcn
, &len
, create
? &new : NULL
);
571 bytes
= ((u64
)len
<< cluster_bits
) - off
;
573 if (lcn
== SPARSE_LCN
) {
575 if (bh
->b_size
> bytes
)
584 if ((len
<< cluster_bits
) > block_size
)
585 ntfs_sparse_cluster(inode
, page
, vcn
, len
);
588 lbo
= ((u64
)lcn
<< cluster_bits
) + off
;
590 set_buffer_mapped(bh
);
591 bh
->b_bdev
= sb
->s_bdev
;
592 bh
->b_blocknr
= lbo
>> sb
->s_blocksize_bits
;
596 if (ctx
== GET_BLOCK_DIRECT_IO_W
) {
597 /* ntfs_direct_IO will update ni->i_valid. */
602 if (bytes
> bh
->b_size
)
608 if (vbo
+ bytes
> valid
) {
609 ni
->i_valid
= vbo
+ bytes
;
610 mark_inode_dirty(inode
);
612 } else if (vbo
>= valid
) {
613 /* Read out of valid data. */
614 /* Should never be here 'cause already checked. */
615 clear_buffer_mapped(bh
);
616 } else if (vbo
+ bytes
<= valid
) {
618 } else if (vbo
+ block_size
<= valid
) {
619 /* Normal short read. */
623 * Read across valid size: vbo < valid && valid < vbo + block_size
628 u32 voff
= valid
- vbo
;
630 bh
->b_size
= block_size
;
631 off
= vbo
& (PAGE_SIZE
- 1);
632 set_bh_page(bh
, page
, off
);
633 err
= bh_read(bh
, 0);
636 zero_user_segment(page
, off
+ voff
, off
+ block_size
);
640 if (bh
->b_size
> bytes
)
644 if (ctx
== GET_BLOCK_DIRECT_IO_W
|| ctx
== GET_BLOCK_DIRECT_IO_R
) {
645 static_assert(sizeof(size_t) < sizeof(loff_t
));
646 if (bytes
> 0x40000000u
)
647 bh
->b_size
= 0x40000000u
;
657 int ntfs_get_block(struct inode
*inode
, sector_t vbn
,
658 struct buffer_head
*bh_result
, int create
)
660 return ntfs_get_block_vbo(inode
, (u64
)vbn
<< inode
->i_blkbits
,
661 bh_result
, create
, GET_BLOCK_GENERAL
);
664 static int ntfs_get_block_bmap(struct inode
*inode
, sector_t vsn
,
665 struct buffer_head
*bh_result
, int create
)
667 return ntfs_get_block_vbo(inode
,
668 (u64
)vsn
<< inode
->i_sb
->s_blocksize_bits
,
669 bh_result
, create
, GET_BLOCK_BMAP
);
672 static sector_t
ntfs_bmap(struct address_space
*mapping
, sector_t block
)
674 return generic_block_bmap(mapping
, block
, ntfs_get_block_bmap
);
677 static int ntfs_read_folio(struct file
*file
, struct folio
*folio
)
679 struct page
*page
= &folio
->page
;
681 struct address_space
*mapping
= page
->mapping
;
682 struct inode
*inode
= mapping
->host
;
683 struct ntfs_inode
*ni
= ntfs_i(inode
);
685 if (is_resident(ni
)) {
687 err
= attr_data_read_resident(ni
, page
);
689 if (err
!= E_NTFS_NONRESIDENT
) {
695 if (is_compressed(ni
)) {
697 err
= ni_readpage_cmpr(ni
, page
);
702 /* Normal + sparse files. */
703 return mpage_read_folio(folio
, ntfs_get_block
);
706 static void ntfs_readahead(struct readahead_control
*rac
)
708 struct address_space
*mapping
= rac
->mapping
;
709 struct inode
*inode
= mapping
->host
;
710 struct ntfs_inode
*ni
= ntfs_i(inode
);
714 if (is_resident(ni
)) {
715 /* No readahead for resident. */
719 if (is_compressed(ni
)) {
720 /* No readahead for compressed. */
725 pos
= readahead_pos(rac
);
727 if (valid
< i_size_read(inode
) && pos
<= valid
&&
728 valid
< pos
+ readahead_length(rac
)) {
729 /* Range cross 'valid'. Read it page by page. */
733 mpage_readahead(rac
, ntfs_get_block
);
736 static int ntfs_get_block_direct_IO_R(struct inode
*inode
, sector_t iblock
,
737 struct buffer_head
*bh_result
, int create
)
739 return ntfs_get_block_vbo(inode
, (u64
)iblock
<< inode
->i_blkbits
,
740 bh_result
, create
, GET_BLOCK_DIRECT_IO_R
);
743 static int ntfs_get_block_direct_IO_W(struct inode
*inode
, sector_t iblock
,
744 struct buffer_head
*bh_result
, int create
)
746 return ntfs_get_block_vbo(inode
, (u64
)iblock
<< inode
->i_blkbits
,
747 bh_result
, create
, GET_BLOCK_DIRECT_IO_W
);
750 static ssize_t
ntfs_direct_IO(struct kiocb
*iocb
, struct iov_iter
*iter
)
752 struct file
*file
= iocb
->ki_filp
;
753 struct address_space
*mapping
= file
->f_mapping
;
754 struct inode
*inode
= mapping
->host
;
755 struct ntfs_inode
*ni
= ntfs_i(inode
);
756 loff_t vbo
= iocb
->ki_pos
;
758 int wr
= iov_iter_rw(iter
) & WRITE
;
759 size_t iter_count
= iov_iter_count(iter
);
763 if (is_resident(ni
)) {
764 /* Switch to buffered write. */
769 ret
= blockdev_direct_IO(iocb
, inode
, iter
,
770 wr
? ntfs_get_block_direct_IO_W
771 : ntfs_get_block_direct_IO_R
);
775 else if (wr
&& ret
== -EIOCBQUEUED
)
776 end
= vbo
+ iter_count
;
782 if (end
> valid
&& !S_ISBLK(inode
->i_mode
)) {
784 mark_inode_dirty(inode
);
786 } else if (vbo
< valid
&& valid
< end
) {
788 iov_iter_revert(iter
, end
- valid
);
789 iov_iter_zero(end
- valid
, iter
);
796 int ntfs_set_size(struct inode
*inode
, u64 new_size
)
798 struct super_block
*sb
= inode
->i_sb
;
799 struct ntfs_sb_info
*sbi
= sb
->s_fs_info
;
800 struct ntfs_inode
*ni
= ntfs_i(inode
);
803 /* Check for maximum file size. */
804 if (is_sparsed(ni
) || is_compressed(ni
)) {
805 if (new_size
> sbi
->maxbytes_sparse
) {
809 } else if (new_size
> sbi
->maxbytes
) {
815 down_write(&ni
->file
.run_lock
);
817 err
= attr_set_size(ni
, ATTR_DATA
, NULL
, 0, &ni
->file
.run
, new_size
,
818 &ni
->i_valid
, true, NULL
);
820 up_write(&ni
->file
.run_lock
);
823 mark_inode_dirty(inode
);
829 static int ntfs_writepage(struct page
*page
, struct writeback_control
*wbc
)
831 struct address_space
*mapping
= page
->mapping
;
832 struct inode
*inode
= mapping
->host
;
833 struct ntfs_inode
*ni
= ntfs_i(inode
);
836 if (is_resident(ni
)) {
838 err
= attr_data_write_resident(ni
, page
);
840 if (err
!= E_NTFS_NONRESIDENT
) {
846 return block_write_full_page(page
, ntfs_get_block
, wbc
);
849 static int ntfs_writepages(struct address_space
*mapping
,
850 struct writeback_control
*wbc
)
852 /* Redirect call to 'ntfs_writepage' for resident files. */
853 if (is_resident(ntfs_i(mapping
->host
)))
854 return generic_writepages(mapping
, wbc
);
855 return mpage_writepages(mapping
, wbc
, ntfs_get_block
);
858 static int ntfs_get_block_write_begin(struct inode
*inode
, sector_t vbn
,
859 struct buffer_head
*bh_result
, int create
)
861 return ntfs_get_block_vbo(inode
, (u64
)vbn
<< inode
->i_blkbits
,
862 bh_result
, create
, GET_BLOCK_WRITE_BEGIN
);
865 int ntfs_write_begin(struct file
*file
, struct address_space
*mapping
,
866 loff_t pos
, u32 len
, struct page
**pagep
, void **fsdata
)
869 struct inode
*inode
= mapping
->host
;
870 struct ntfs_inode
*ni
= ntfs_i(inode
);
873 if (is_resident(ni
)) {
874 struct page
*page
= grab_cache_page_write_begin(
875 mapping
, pos
>> PAGE_SHIFT
);
883 err
= attr_data_read_resident(ni
, page
);
893 if (err
!= E_NTFS_NONRESIDENT
)
897 err
= block_write_begin(mapping
, pos
, len
, pagep
,
898 ntfs_get_block_write_begin
);
905 * ntfs_write_end - Address_space_operations::write_end.
907 int ntfs_write_end(struct file
*file
, struct address_space
*mapping
,
908 loff_t pos
, u32 len
, u32 copied
, struct page
*page
,
911 struct inode
*inode
= mapping
->host
;
912 struct ntfs_inode
*ni
= ntfs_i(inode
);
913 u64 valid
= ni
->i_valid
;
917 if (is_resident(ni
)) {
919 err
= attr_data_write_resident(ni
, page
);
923 /* Clear any buffers in page. */
924 if (page_has_buffers(page
)) {
925 struct buffer_head
*head
, *bh
;
927 bh
= head
= page_buffers(page
);
929 clear_buffer_dirty(bh
);
930 clear_buffer_mapped(bh
);
931 set_buffer_uptodate(bh
);
932 } while (head
!= (bh
= bh
->b_this_page
));
934 SetPageUptodate(page
);
940 err
= generic_write_end(file
, mapping
, pos
, len
, copied
, page
,
945 if (!(ni
->std_fa
& FILE_ATTRIBUTE_ARCHIVE
)) {
946 inode
->i_ctime
= inode
->i_mtime
= current_time(inode
);
947 ni
->std_fa
|= FILE_ATTRIBUTE_ARCHIVE
;
951 if (valid
!= ni
->i_valid
) {
952 /* ni->i_valid is changed in ntfs_get_block_vbo. */
957 mark_inode_dirty(inode
);
963 int reset_log_file(struct inode
*inode
)
967 u32 log_size
= inode
->i_size
;
968 struct address_space
*mapping
= inode
->i_mapping
;
975 len
= pos
+ PAGE_SIZE
> log_size
? (log_size
- pos
) : PAGE_SIZE
;
977 err
= block_write_begin(mapping
, pos
, len
, &page
,
978 ntfs_get_block_write_begin
);
982 kaddr
= kmap_atomic(page
);
983 memset(kaddr
, -1, len
);
984 kunmap_atomic(kaddr
);
985 flush_dcache_page(page
);
987 err
= block_write_end(NULL
, mapping
, pos
, len
, len
, page
, NULL
);
994 balance_dirty_pages_ratelimited(mapping
);
997 mark_inode_dirty_sync(inode
);
1002 int ntfs3_write_inode(struct inode
*inode
, struct writeback_control
*wbc
)
1004 return _ni_write_inode(inode
, wbc
->sync_mode
== WB_SYNC_ALL
);
1007 int ntfs_sync_inode(struct inode
*inode
)
1009 return _ni_write_inode(inode
, 1);
1013 * writeback_inode - Helper function for ntfs_flush_inodes().
1015 * This writes both the inode and the file data blocks, waiting
1016 * for in flight data blocks before the start of the call. It
1017 * does not wait for any io started during the call.
1019 static int writeback_inode(struct inode
*inode
)
1021 int ret
= sync_inode_metadata(inode
, 0);
1024 ret
= filemap_fdatawrite(inode
->i_mapping
);
1031 * Write data and metadata corresponding to i1 and i2. The io is
1032 * started but we do not wait for any of it to finish.
1034 * filemap_flush() is used for the block device, so if there is a dirty
1035 * page for a block already in flight, we will not wait and start the
1038 int ntfs_flush_inodes(struct super_block
*sb
, struct inode
*i1
,
1044 ret
= writeback_inode(i1
);
1046 ret
= writeback_inode(i2
);
1048 ret
= sync_blockdev_nowait(sb
->s_bdev
);
1052 int inode_write_data(struct inode
*inode
, const void *data
, size_t bytes
)
1056 /* Write non resident data. */
1057 for (idx
= 0; bytes
; idx
++) {
1058 size_t op
= bytes
> PAGE_SIZE
? PAGE_SIZE
: bytes
;
1059 struct page
*page
= ntfs_map_page(inode
->i_mapping
, idx
);
1062 return PTR_ERR(page
);
1065 WARN_ON(!PageUptodate(page
));
1066 ClearPageUptodate(page
);
1068 memcpy(page_address(page
), data
, op
);
1070 flush_dcache_page(page
);
1071 SetPageUptodate(page
);
1074 ntfs_unmap_page(page
);
1077 data
= Add2Ptr(data
, PAGE_SIZE
);
1083 * ntfs_reparse_bytes
1085 * Number of bytes for REPARSE_DATA_BUFFER(IO_REPARSE_TAG_SYMLINK)
1086 * for unicode string of @uni_len length.
1088 static inline u32
ntfs_reparse_bytes(u32 uni_len
)
1090 /* Header + unicode string + decorated unicode string. */
1091 return sizeof(short) * (2 * uni_len
+ 4) +
1092 offsetof(struct REPARSE_DATA_BUFFER
,
1093 SymbolicLinkReparseBuffer
.PathBuffer
);
1096 static struct REPARSE_DATA_BUFFER
*
1097 ntfs_create_reparse_buffer(struct ntfs_sb_info
*sbi
, const char *symname
,
1098 u32 size
, u16
*nsize
)
1101 struct REPARSE_DATA_BUFFER
*rp
;
1103 typeof(rp
->SymbolicLinkReparseBuffer
) *rs
;
1105 rp
= kzalloc(ntfs_reparse_bytes(2 * size
+ 2), GFP_NOFS
);
1107 return ERR_PTR(-ENOMEM
);
1109 rs
= &rp
->SymbolicLinkReparseBuffer
;
1110 rp_name
= rs
->PathBuffer
;
1112 /* Convert link name to UTF-16. */
1113 err
= ntfs_nls_to_utf16(sbi
, symname
, size
,
1114 (struct cpu_str
*)(rp_name
- 1), 2 * size
,
1115 UTF16_LITTLE_ENDIAN
);
1119 /* err = the length of unicode name of symlink. */
1120 *nsize
= ntfs_reparse_bytes(err
);
1122 if (*nsize
> sbi
->reparse
.max_size
) {
1127 /* Translate Linux '/' into Windows '\'. */
1128 for (i
= 0; i
< err
; i
++) {
1129 if (rp_name
[i
] == cpu_to_le16('/'))
1130 rp_name
[i
] = cpu_to_le16('\\');
1133 rp
->ReparseTag
= IO_REPARSE_TAG_SYMLINK
;
1134 rp
->ReparseDataLength
=
1135 cpu_to_le16(*nsize
- offsetof(struct REPARSE_DATA_BUFFER
,
1136 SymbolicLinkReparseBuffer
));
1138 /* PrintName + SubstituteName. */
1139 rs
->SubstituteNameOffset
= cpu_to_le16(sizeof(short) * err
);
1140 rs
->SubstituteNameLength
= cpu_to_le16(sizeof(short) * err
+ 8);
1141 rs
->PrintNameLength
= rs
->SubstituteNameOffset
;
1144 * TODO: Use relative path if possible to allow Windows to
1146 * 0-absolute path 1- relative path (SYMLINK_FLAG_RELATIVE).
1150 memmove(rp_name
+ err
+ 4, rp_name
, sizeof(short) * err
);
1152 /* Decorate SubstituteName. */
1154 rp_name
[0] = cpu_to_le16('\\');
1155 rp_name
[1] = cpu_to_le16('?');
1156 rp_name
[2] = cpu_to_le16('?');
1157 rp_name
[3] = cpu_to_le16('\\');
1162 return ERR_PTR(err
);
1165 struct inode
*ntfs_create_inode(struct user_namespace
*mnt_userns
,
1166 struct inode
*dir
, struct dentry
*dentry
,
1167 const struct cpu_str
*uni
, umode_t mode
,
1168 dev_t dev
, const char *symname
, u32 size
,
1169 struct ntfs_fnd
*fnd
)
1172 struct super_block
*sb
= dir
->i_sb
;
1173 struct ntfs_sb_info
*sbi
= sb
->s_fs_info
;
1174 const struct qstr
*name
= &dentry
->d_name
;
1176 struct ntfs_inode
*dir_ni
= ntfs_i(dir
);
1177 struct ntfs_inode
*ni
= NULL
;
1178 struct inode
*inode
= NULL
;
1179 struct ATTRIB
*attr
;
1180 struct ATTR_STD_INFO5
*std5
;
1181 struct ATTR_FILE_NAME
*fname
;
1182 struct MFT_REC
*rec
;
1183 u32 asize
, dsize
, sd_size
;
1184 enum FILE_ATTRIBUTE fa
;
1185 __le32 security_id
= SECURITY_ID_INVALID
;
1188 u16 t16
, nsize
= 0, aid
= 0;
1189 struct INDEX_ROOT
*root
, *dir_root
;
1190 struct NTFS_DE
*e
, *new_de
= NULL
;
1191 struct REPARSE_DATA_BUFFER
*rp
= NULL
;
1192 bool rp_inserted
= false;
1194 ni_lock_dir(dir_ni
);
1196 dir_root
= indx_get_root(&dir_ni
->dir
, dir_ni
, NULL
, NULL
);
1202 if (S_ISDIR(mode
)) {
1203 /* Use parent's directory attributes. */
1204 fa
= dir_ni
->std_fa
| FILE_ATTRIBUTE_DIRECTORY
|
1205 FILE_ATTRIBUTE_ARCHIVE
;
1207 * By default child directory inherits parent attributes.
1208 * Root directory is hidden + system.
1209 * Make an exception for children in root.
1211 if (dir
->i_ino
== MFT_REC_ROOT
)
1212 fa
&= ~(FILE_ATTRIBUTE_HIDDEN
| FILE_ATTRIBUTE_SYSTEM
);
1213 } else if (S_ISLNK(mode
)) {
1214 /* It is good idea that link should be the same type (file/dir) as target */
1215 fa
= FILE_ATTRIBUTE_REPARSE_POINT
;
1218 * Linux: there are dir/file/symlink and so on.
1219 * NTFS: symlinks are "dir + reparse" or "file + reparse"
1220 * It is good idea to create:
1221 * dir + reparse if 'symname' points to directory
1223 * file + reparse if 'symname' points to file
1224 * Unfortunately kern_path hangs if symname contains 'dir'.
1230 * if (!kern_path(symname, LOOKUP_FOLLOW, &path)){
1231 * struct inode *target = d_inode(path.dentry);
1233 * if (S_ISDIR(target->i_mode))
1234 * fa |= FILE_ATTRIBUTE_DIRECTORY;
1235 * // if ( target->i_sb == sb ){
1236 * // use relative path?
1241 } else if (S_ISREG(mode
)) {
1242 if (sbi
->options
->sparse
) {
1243 /* Sparsed regular file, cause option 'sparse'. */
1244 fa
= FILE_ATTRIBUTE_SPARSE_FILE
|
1245 FILE_ATTRIBUTE_ARCHIVE
;
1246 } else if (dir_ni
->std_fa
& FILE_ATTRIBUTE_COMPRESSED
) {
1247 /* Compressed regular file, if parent is compressed. */
1248 fa
= FILE_ATTRIBUTE_COMPRESSED
| FILE_ATTRIBUTE_ARCHIVE
;
1250 /* Regular file, default attributes. */
1251 fa
= FILE_ATTRIBUTE_ARCHIVE
;
1254 fa
= FILE_ATTRIBUTE_ARCHIVE
;
1258 fa
|= FILE_ATTRIBUTE_READONLY
;
1260 /* Allocate PATH_MAX bytes. */
1261 new_de
= __getname();
1267 /* Mark rw ntfs as dirty. it will be cleared at umount. */
1268 ntfs_set_state(sbi
, NTFS_DIRTY_DIRTY
);
1270 /* Step 1: allocate and fill new mft record. */
1271 err
= ntfs_look_free_mft(sbi
, &ino
, false, NULL
, NULL
);
1275 ni
= ntfs_new_inode(sbi
, ino
, fa
& FILE_ATTRIBUTE_DIRECTORY
);
1281 inode
= &ni
->vfs_inode
;
1282 inode_init_owner(mnt_userns
, inode
, dir
, mode
);
1283 mode
= inode
->i_mode
;
1285 inode
->i_atime
= inode
->i_mtime
= inode
->i_ctime
= ni
->i_crtime
=
1286 current_time(inode
);
1289 rec
->hard_links
= cpu_to_le16(1);
1290 attr
= Add2Ptr(rec
, le16_to_cpu(rec
->attr_off
));
1292 /* Get default security id. */
1293 sd
= s_default_security
;
1294 sd_size
= sizeof(s_default_security
);
1296 if (is_ntfs3(sbi
)) {
1297 security_id
= dir_ni
->std_security_id
;
1298 if (le32_to_cpu(security_id
) < SECURITY_ID_FIRST
) {
1299 security_id
= sbi
->security
.def_security_id
;
1301 if (security_id
== SECURITY_ID_INVALID
&&
1302 !ntfs_insert_security(sbi
, sd
, sd_size
,
1303 &security_id
, NULL
))
1304 sbi
->security
.def_security_id
= security_id
;
1308 /* Insert standard info. */
1309 std5
= Add2Ptr(attr
, SIZEOF_RESIDENT
);
1311 if (security_id
== SECURITY_ID_INVALID
) {
1312 dsize
= sizeof(struct ATTR_STD_INFO
);
1314 dsize
= sizeof(struct ATTR_STD_INFO5
);
1315 std5
->security_id
= security_id
;
1316 ni
->std_security_id
= security_id
;
1318 asize
= SIZEOF_RESIDENT
+ dsize
;
1320 attr
->type
= ATTR_STD
;
1321 attr
->size
= cpu_to_le32(asize
);
1322 attr
->id
= cpu_to_le16(aid
++);
1323 attr
->res
.data_off
= SIZEOF_RESIDENT_LE
;
1324 attr
->res
.data_size
= cpu_to_le32(dsize
);
1326 std5
->cr_time
= std5
->m_time
= std5
->c_time
= std5
->a_time
=
1327 kernel2nt(&inode
->i_atime
);
1332 attr
= Add2Ptr(attr
, asize
);
1334 /* Insert file name. */
1335 err
= fill_name_de(sbi
, new_de
, name
, uni
);
1339 mi_get_ref(&ni
->mi
, &new_de
->ref
);
1341 fname
= (struct ATTR_FILE_NAME
*)(new_de
+ 1);
1342 mi_get_ref(&dir_ni
->mi
, &fname
->home
);
1343 fname
->dup
.cr_time
= fname
->dup
.m_time
= fname
->dup
.c_time
=
1344 fname
->dup
.a_time
= std5
->cr_time
;
1345 fname
->dup
.alloc_size
= fname
->dup
.data_size
= 0;
1346 fname
->dup
.fa
= std5
->fa
;
1347 fname
->dup
.ea_size
= fname
->dup
.reparse
= 0;
1349 dsize
= le16_to_cpu(new_de
->key_size
);
1350 asize
= ALIGN(SIZEOF_RESIDENT
+ dsize
, 8);
1352 attr
->type
= ATTR_NAME
;
1353 attr
->size
= cpu_to_le32(asize
);
1354 attr
->res
.data_off
= SIZEOF_RESIDENT_LE
;
1355 attr
->res
.flags
= RESIDENT_FLAG_INDEXED
;
1356 attr
->id
= cpu_to_le16(aid
++);
1357 attr
->res
.data_size
= cpu_to_le32(dsize
);
1358 memcpy(Add2Ptr(attr
, SIZEOF_RESIDENT
), fname
, dsize
);
1360 attr
= Add2Ptr(attr
, asize
);
1362 if (security_id
== SECURITY_ID_INVALID
) {
1363 /* Insert security attribute. */
1364 asize
= SIZEOF_RESIDENT
+ ALIGN(sd_size
, 8);
1366 attr
->type
= ATTR_SECURE
;
1367 attr
->size
= cpu_to_le32(asize
);
1368 attr
->id
= cpu_to_le16(aid
++);
1369 attr
->res
.data_off
= SIZEOF_RESIDENT_LE
;
1370 attr
->res
.data_size
= cpu_to_le32(sd_size
);
1371 memcpy(Add2Ptr(attr
, SIZEOF_RESIDENT
), sd
, sd_size
);
1373 attr
= Add2Ptr(attr
, asize
);
1376 attr
->id
= cpu_to_le16(aid
++);
1377 if (fa
& FILE_ATTRIBUTE_DIRECTORY
) {
1379 * Regular directory or symlink to directory.
1380 * Create root attribute.
1382 dsize
= sizeof(struct INDEX_ROOT
) + sizeof(struct NTFS_DE
);
1383 asize
= sizeof(I30_NAME
) + SIZEOF_RESIDENT
+ dsize
;
1385 attr
->type
= ATTR_ROOT
;
1386 attr
->size
= cpu_to_le32(asize
);
1388 attr
->name_len
= ARRAY_SIZE(I30_NAME
);
1389 attr
->name_off
= SIZEOF_RESIDENT_LE
;
1390 attr
->res
.data_off
=
1391 cpu_to_le16(sizeof(I30_NAME
) + SIZEOF_RESIDENT
);
1392 attr
->res
.data_size
= cpu_to_le32(dsize
);
1393 memcpy(Add2Ptr(attr
, SIZEOF_RESIDENT
), I30_NAME
,
1396 root
= Add2Ptr(attr
, sizeof(I30_NAME
) + SIZEOF_RESIDENT
);
1397 memcpy(root
, dir_root
, offsetof(struct INDEX_ROOT
, ihdr
));
1399 cpu_to_le32(sizeof(struct INDEX_HDR
)); // 0x10
1400 root
->ihdr
.used
= cpu_to_le32(sizeof(struct INDEX_HDR
) +
1401 sizeof(struct NTFS_DE
));
1402 root
->ihdr
.total
= root
->ihdr
.used
;
1404 e
= Add2Ptr(root
, sizeof(struct INDEX_ROOT
));
1405 e
->size
= cpu_to_le16(sizeof(struct NTFS_DE
));
1406 e
->flags
= NTFS_IE_LAST
;
1407 } else if (S_ISLNK(mode
)) {
1410 * Create empty resident data attribute.
1412 asize
= SIZEOF_RESIDENT
;
1414 /* Insert empty ATTR_DATA */
1415 attr
->type
= ATTR_DATA
;
1416 attr
->size
= cpu_to_le32(SIZEOF_RESIDENT
);
1417 attr
->name_off
= SIZEOF_RESIDENT_LE
;
1418 attr
->res
.data_off
= SIZEOF_RESIDENT_LE
;
1419 } else if (S_ISREG(mode
)) {
1421 * Regular file. Create empty non resident data attribute.
1423 attr
->type
= ATTR_DATA
;
1425 attr
->nres
.evcn
= cpu_to_le64(-1ll);
1426 if (fa
& FILE_ATTRIBUTE_SPARSE_FILE
) {
1427 attr
->size
= cpu_to_le32(SIZEOF_NONRESIDENT_EX
+ 8);
1428 attr
->name_off
= SIZEOF_NONRESIDENT_EX_LE
;
1429 attr
->flags
= ATTR_FLAG_SPARSED
;
1430 asize
= SIZEOF_NONRESIDENT_EX
+ 8;
1431 } else if (fa
& FILE_ATTRIBUTE_COMPRESSED
) {
1432 attr
->size
= cpu_to_le32(SIZEOF_NONRESIDENT_EX
+ 8);
1433 attr
->name_off
= SIZEOF_NONRESIDENT_EX_LE
;
1434 attr
->flags
= ATTR_FLAG_COMPRESSED
;
1435 attr
->nres
.c_unit
= COMPRESSION_UNIT
;
1436 asize
= SIZEOF_NONRESIDENT_EX
+ 8;
1438 attr
->size
= cpu_to_le32(SIZEOF_NONRESIDENT
+ 8);
1439 attr
->name_off
= SIZEOF_NONRESIDENT_LE
;
1440 asize
= SIZEOF_NONRESIDENT
+ 8;
1442 attr
->nres
.run_off
= attr
->name_off
;
1445 * Node. Create empty resident data attribute.
1447 attr
->type
= ATTR_DATA
;
1448 attr
->size
= cpu_to_le32(SIZEOF_RESIDENT
);
1449 attr
->name_off
= SIZEOF_RESIDENT_LE
;
1450 if (fa
& FILE_ATTRIBUTE_SPARSE_FILE
)
1451 attr
->flags
= ATTR_FLAG_SPARSED
;
1452 else if (fa
& FILE_ATTRIBUTE_COMPRESSED
)
1453 attr
->flags
= ATTR_FLAG_COMPRESSED
;
1454 attr
->res
.data_off
= SIZEOF_RESIDENT_LE
;
1455 asize
= SIZEOF_RESIDENT
;
1456 ni
->ni_flags
|= NI_FLAG_RESIDENT
;
1459 if (S_ISDIR(mode
)) {
1460 ni
->ni_flags
|= NI_FLAG_DIR
;
1461 err
= indx_init(&ni
->dir
, sbi
, attr
, INDEX_MUTEX_I30
);
1464 } else if (S_ISLNK(mode
)) {
1465 rp
= ntfs_create_reparse_buffer(sbi
, symname
, size
, &nsize
);
1474 * Insert ATTR_REPARSE.
1476 attr
= Add2Ptr(attr
, asize
);
1477 attr
->type
= ATTR_REPARSE
;
1478 attr
->id
= cpu_to_le16(aid
++);
1480 /* Resident or non resident? */
1481 asize
= ALIGN(SIZEOF_RESIDENT
+ nsize
, 8);
1482 t16
= PtrOffset(rec
, attr
);
1485 * Below function 'ntfs_save_wsl_perm' requires 0x78 bytes.
1486 * It is good idea to keep extened attributes resident.
1488 if (asize
+ t16
+ 0x78 + 8 > sbi
->record_size
) {
1490 CLST clst
= bytes_to_cluster(sbi
, nsize
);
1492 /* Bytes per runs. */
1493 t16
= sbi
->record_size
- t16
- SIZEOF_NONRESIDENT
;
1496 attr
->nres
.evcn
= cpu_to_le64(clst
- 1);
1497 attr
->name_off
= SIZEOF_NONRESIDENT_LE
;
1498 attr
->nres
.run_off
= attr
->name_off
;
1499 attr
->nres
.data_size
= cpu_to_le64(nsize
);
1500 attr
->nres
.valid_size
= attr
->nres
.data_size
;
1501 attr
->nres
.alloc_size
=
1502 cpu_to_le64(ntfs_up_cluster(sbi
, nsize
));
1504 err
= attr_allocate_clusters(sbi
, &ni
->file
.run
, 0, 0,
1505 clst
, NULL
, 0, &alen
, 0,
1510 err
= run_pack(&ni
->file
.run
, 0, clst
,
1511 Add2Ptr(attr
, SIZEOF_NONRESIDENT
), t16
,
1521 asize
= SIZEOF_NONRESIDENT
+ ALIGN(err
, 8);
1523 attr
->res
.data_off
= SIZEOF_RESIDENT_LE
;
1524 attr
->res
.data_size
= cpu_to_le32(nsize
);
1525 memcpy(Add2Ptr(attr
, SIZEOF_RESIDENT
), rp
, nsize
);
1528 /* Size of symlink equals the length of input string. */
1529 inode
->i_size
= size
;
1531 attr
->size
= cpu_to_le32(asize
);
1533 err
= ntfs_insert_reparse(sbi
, IO_REPARSE_TAG_SYMLINK
,
1541 attr
= Add2Ptr(attr
, asize
);
1542 attr
->type
= ATTR_END
;
1544 rec
->used
= cpu_to_le32(PtrOffset(rec
, attr
) + 8);
1545 rec
->next_attr_id
= cpu_to_le16(aid
);
1547 /* Step 2: Add new name in index. */
1548 err
= indx_insert_entry(&dir_ni
->dir
, dir_ni
, new_de
, sbi
, fnd
, 0);
1552 /* Unlock parent directory before ntfs_init_acl. */
1555 inode
->i_generation
= le16_to_cpu(rec
->seq
);
1557 dir
->i_mtime
= dir
->i_ctime
= inode
->i_atime
;
1559 if (S_ISDIR(mode
)) {
1560 inode
->i_op
= &ntfs_dir_inode_operations
;
1561 inode
->i_fop
= &ntfs_dir_operations
;
1562 } else if (S_ISLNK(mode
)) {
1563 inode
->i_op
= &ntfs_link_inode_operations
;
1564 inode
->i_fop
= NULL
;
1565 inode
->i_mapping
->a_ops
= &ntfs_aops
;
1566 inode
->i_size
= size
;
1567 inode_nohighmem(inode
);
1568 } else if (S_ISREG(mode
)) {
1569 inode
->i_op
= &ntfs_file_inode_operations
;
1570 inode
->i_fop
= &ntfs_file_operations
;
1571 inode
->i_mapping
->a_ops
=
1572 is_compressed(ni
) ? &ntfs_aops_cmpr
: &ntfs_aops
;
1573 init_rwsem(&ni
->file
.run_lock
);
1575 inode
->i_op
= &ntfs_special_inode_operations
;
1576 init_special_inode(inode
, mode
, dev
);
1579 #ifdef CONFIG_NTFS3_FS_POSIX_ACL
1580 if (!S_ISLNK(mode
) && (sb
->s_flags
& SB_POSIXACL
)) {
1581 err
= ntfs_init_acl(mnt_userns
, inode
, dir
);
1587 inode
->i_flags
|= S_NOSEC
;
1590 /* Write non resident data. */
1592 err
= ntfs_sb_write_run(sbi
, &ni
->file
.run
, 0, rp
, nsize
, 0);
1598 * Call 'd_instantiate' after inode->i_op is set
1599 * but before finish_open.
1601 d_instantiate(dentry
, inode
);
1603 ntfs_save_wsl_perm(inode
);
1604 mark_inode_dirty(dir
);
1605 mark_inode_dirty(inode
);
1612 /* Undo 'indx_insert_entry'. */
1613 ni_lock_dir(dir_ni
);
1614 indx_delete_entry(&dir_ni
->dir
, dir_ni
, new_de
+ 1,
1615 le16_to_cpu(new_de
->key_size
), sbi
);
1616 /* ni_unlock(dir_ni); will be called later. */
1619 ntfs_remove_reparse(sbi
, IO_REPARSE_TAG_SYMLINK
, &new_de
->ref
);
1622 if (S_ISDIR(mode
) || run_is_empty(&ni
->file
.run
))
1625 run_deallocate(sbi
, &ni
->file
.run
, false);
1628 clear_rec_inuse(rec
);
1630 ni
->mi
.dirty
= false;
1631 discard_new_inode(inode
);
1633 ntfs_mark_rec_free(sbi
, ino
, false);
1642 return ERR_PTR(err
);
1645 unlock_new_inode(inode
);
1650 int ntfs_link_inode(struct inode
*inode
, struct dentry
*dentry
)
1653 struct ntfs_inode
*ni
= ntfs_i(inode
);
1654 struct ntfs_sb_info
*sbi
= inode
->i_sb
->s_fs_info
;
1657 /* Allocate PATH_MAX bytes. */
1662 /* Mark rw ntfs as dirty. It will be cleared at umount. */
1663 ntfs_set_state(sbi
, NTFS_DIRTY_DIRTY
);
1665 /* Construct 'de'. */
1666 err
= fill_name_de(sbi
, de
, &dentry
->d_name
, NULL
);
1670 err
= ni_add_name(ntfs_i(d_inode(dentry
->d_parent
)), ni
, de
);
1679 * inode_operations::unlink
1680 * inode_operations::rmdir
1682 int ntfs_unlink_inode(struct inode
*dir
, const struct dentry
*dentry
)
1685 struct ntfs_sb_info
*sbi
= dir
->i_sb
->s_fs_info
;
1686 struct inode
*inode
= d_inode(dentry
);
1687 struct ntfs_inode
*ni
= ntfs_i(inode
);
1688 struct ntfs_inode
*dir_ni
= ntfs_i(dir
);
1689 struct NTFS_DE
*de
, *de2
= NULL
;
1692 if (ntfs_is_meta_file(sbi
, ni
->mi
.rno
))
1695 /* Allocate PATH_MAX bytes. */
1702 if (S_ISDIR(inode
->i_mode
) && !dir_is_empty(inode
)) {
1707 err
= fill_name_de(sbi
, de
, &dentry
->d_name
, NULL
);
1712 err
= ni_remove_name(dir_ni
, ni
, de
, &de2
, &undo_remove
);
1716 dir
->i_mtime
= dir
->i_ctime
= current_time(dir
);
1717 mark_inode_dirty(dir
);
1718 inode
->i_ctime
= dir
->i_ctime
;
1720 mark_inode_dirty(inode
);
1721 } else if (!ni_remove_name_undo(dir_ni
, ni
, de
, de2
, undo_remove
)) {
1722 _ntfs_bad_inode(inode
);
1724 if (ni_is_dirty(dir
))
1725 mark_inode_dirty(dir
);
1726 if (ni_is_dirty(inode
))
1727 mark_inode_dirty(inode
);
1736 void ntfs_evict_inode(struct inode
*inode
)
1738 truncate_inode_pages_final(&inode
->i_data
);
1741 _ni_write_inode(inode
, inode_needs_sync(inode
));
1743 invalidate_inode_buffers(inode
);
1746 ni_clear(ntfs_i(inode
));
1749 static noinline
int ntfs_readlink_hlp(struct inode
*inode
, char *buffer
,
1752 int i
, err
= -EINVAL
;
1753 struct ntfs_inode
*ni
= ntfs_i(inode
);
1754 struct super_block
*sb
= inode
->i_sb
;
1755 struct ntfs_sb_info
*sbi
= sb
->s_fs_info
;
1758 void *to_free
= NULL
;
1759 struct REPARSE_DATA_BUFFER
*rp
;
1760 const __le16
*uname
;
1761 struct ATTRIB
*attr
;
1763 /* Reparse data present. Try to parse it. */
1764 static_assert(!offsetof(struct REPARSE_DATA_BUFFER
, ReparseTag
));
1765 static_assert(sizeof(u32
) == sizeof(rp
->ReparseTag
));
1769 attr
= ni_find_attr(ni
, NULL
, NULL
, ATTR_REPARSE
, NULL
, 0, NULL
, NULL
);
1773 if (!attr
->non_res
) {
1774 rp
= resident_data_ex(attr
, sizeof(struct REPARSE_DATA_BUFFER
));
1777 size
= le32_to_cpu(attr
->res
.data_size
);
1779 size
= le64_to_cpu(attr
->nres
.data_size
);
1783 if (size
> sbi
->reparse
.max_size
|| size
<= sizeof(u32
))
1787 rp
= kmalloc(size
, GFP_NOFS
);
1793 /* Read into temporal buffer. */
1794 err
= ntfs_read_run_nb(sbi
, &ni
->file
.run
, 0, rp
, size
, NULL
);
1799 /* Microsoft Tag. */
1800 switch (rp
->ReparseTag
) {
1801 case IO_REPARSE_TAG_MOUNT_POINT
:
1802 /* Mount points and junctions. */
1803 /* Can we use 'Rp->MountPointReparseBuffer.PrintNameLength'? */
1804 if (size
<= offsetof(struct REPARSE_DATA_BUFFER
,
1805 MountPointReparseBuffer
.PathBuffer
))
1808 offsetof(struct REPARSE_DATA_BUFFER
,
1809 MountPointReparseBuffer
.PathBuffer
) +
1810 le16_to_cpu(rp
->MountPointReparseBuffer
1812 ulen
= le16_to_cpu(rp
->MountPointReparseBuffer
.PrintNameLength
);
1815 case IO_REPARSE_TAG_SYMLINK
:
1816 /* FolderSymbolicLink */
1817 /* Can we use 'Rp->SymbolicLinkReparseBuffer.PrintNameLength'? */
1818 if (size
<= offsetof(struct REPARSE_DATA_BUFFER
,
1819 SymbolicLinkReparseBuffer
.PathBuffer
))
1822 rp
, offsetof(struct REPARSE_DATA_BUFFER
,
1823 SymbolicLinkReparseBuffer
.PathBuffer
) +
1824 le16_to_cpu(rp
->SymbolicLinkReparseBuffer
1827 rp
->SymbolicLinkReparseBuffer
.PrintNameLength
);
1830 case IO_REPARSE_TAG_CLOUD
:
1831 case IO_REPARSE_TAG_CLOUD_1
:
1832 case IO_REPARSE_TAG_CLOUD_2
:
1833 case IO_REPARSE_TAG_CLOUD_3
:
1834 case IO_REPARSE_TAG_CLOUD_4
:
1835 case IO_REPARSE_TAG_CLOUD_5
:
1836 case IO_REPARSE_TAG_CLOUD_6
:
1837 case IO_REPARSE_TAG_CLOUD_7
:
1838 case IO_REPARSE_TAG_CLOUD_8
:
1839 case IO_REPARSE_TAG_CLOUD_9
:
1840 case IO_REPARSE_TAG_CLOUD_A
:
1841 case IO_REPARSE_TAG_CLOUD_B
:
1842 case IO_REPARSE_TAG_CLOUD_C
:
1843 case IO_REPARSE_TAG_CLOUD_D
:
1844 case IO_REPARSE_TAG_CLOUD_E
:
1845 case IO_REPARSE_TAG_CLOUD_F
:
1846 err
= sizeof("OneDrive") - 1;
1849 memcpy(buffer
, "OneDrive", err
);
1853 if (IsReparseTagMicrosoft(rp
->ReparseTag
)) {
1854 /* Unknown Microsoft Tag. */
1857 if (!IsReparseTagNameSurrogate(rp
->ReparseTag
) ||
1858 size
<= sizeof(struct REPARSE_POINT
)) {
1863 uname
= Add2Ptr(rp
, sizeof(struct REPARSE_POINT
));
1864 ulen
= le16_to_cpu(rp
->ReparseDataLength
) -
1865 sizeof(struct REPARSE_POINT
);
1868 /* Convert nlen from bytes to UNICODE chars. */
1871 /* Check that name is available. */
1872 if (!ulen
|| uname
+ ulen
> (__le16
*)Add2Ptr(rp
, size
))
1875 /* If name is already zero terminated then truncate it now. */
1876 if (!uname
[ulen
- 1])
1879 err
= ntfs_utf16_to_nls(sbi
, uname
, ulen
, buffer
, buflen
);
1884 /* Translate Windows '\' into Linux '/'. */
1885 for (i
= 0; i
< err
; i
++) {
1886 if (buffer
[i
] == '\\')
1890 /* Always set last zero. */
1897 static const char *ntfs_get_link(struct dentry
*de
, struct inode
*inode
,
1898 struct delayed_call
*done
)
1904 return ERR_PTR(-ECHILD
);
1906 ret
= kmalloc(PAGE_SIZE
, GFP_NOFS
);
1908 return ERR_PTR(-ENOMEM
);
1910 err
= ntfs_readlink_hlp(inode
, ret
, PAGE_SIZE
);
1913 return ERR_PTR(err
);
1916 set_delayed_call(done
, kfree_link
, ret
);
1922 const struct inode_operations ntfs_link_inode_operations
= {
1923 .get_link
= ntfs_get_link
,
1924 .setattr
= ntfs3_setattr
,
1925 .listxattr
= ntfs_listxattr
,
1926 .permission
= ntfs_permission
,
1929 const struct address_space_operations ntfs_aops
= {
1930 .read_folio
= ntfs_read_folio
,
1931 .readahead
= ntfs_readahead
,
1932 .writepage
= ntfs_writepage
,
1933 .writepages
= ntfs_writepages
,
1934 .write_begin
= ntfs_write_begin
,
1935 .write_end
= ntfs_write_end
,
1936 .direct_IO
= ntfs_direct_IO
,
1938 .dirty_folio
= block_dirty_folio
,
1939 .invalidate_folio
= block_invalidate_folio
,
1942 const struct address_space_operations ntfs_aops_cmpr
= {
1943 .read_folio
= ntfs_read_folio
,
1944 .readahead
= ntfs_readahead
,