ntfs_fs.h revision e8b8e97f
1/* SPDX-License-Identifier: GPL-2.0 */
2/*
3 *
4 * Copyright (C) 2019-2021 Paragon Software GmbH, All rights reserved.
5 *
6 */
7
8// clang-format off
9#ifndef _LINUX_NTFS3_NTFS_FS_H
10#define _LINUX_NTFS3_NTFS_FS_H
11
12#define MINUS_ONE_T			((size_t)(-1))
13/* Biggest MFT / smallest cluster */
14#define MAXIMUM_BYTES_PER_MFT		4096
15#define NTFS_BLOCKS_PER_MFT_RECORD	(MAXIMUM_BYTES_PER_MFT / 512)
16
17#define MAXIMUM_BYTES_PER_INDEX		4096
18#define NTFS_BLOCKS_PER_INODE		(MAXIMUM_BYTES_PER_INDEX / 512)
19
20/* NTFS specific error code when fixup failed. */
21#define E_NTFS_FIXUP			555
22/* NTFS specific error code about resident->nonresident. */
23#define E_NTFS_NONRESIDENT		556
24/* NTFS specific error code about punch hole. */
25#define E_NTFS_NOTALIGNED		557
26
27
28/* sbi->flags */
29#define NTFS_FLAGS_NODISCARD		0x00000001
30/* Set when LogFile is replaying. */
31#define NTFS_FLAGS_LOG_REPLAYING	0x00000008
32/* Set when we changed first MFT's which copy must be updated in $MftMirr. */
33#define NTFS_FLAGS_MFTMIRR		0x00001000
34#define NTFS_FLAGS_NEED_REPLAY		0x04000000
35
36
37/* ni->ni_flags */
38/*
39 * Data attribute is external compressed (LZX/Xpress)
40 * 1 - WOF_COMPRESSION_XPRESS4K
41 * 2 - WOF_COMPRESSION_XPRESS8K
42 * 3 - WOF_COMPRESSION_XPRESS16K
43 * 4 - WOF_COMPRESSION_LZX32K
44 */
45#define NI_FLAG_COMPRESSED_MASK		0x0000000f
46/* Data attribute is deduplicated. */
47#define NI_FLAG_DEDUPLICATED		0x00000010
48#define NI_FLAG_EA			0x00000020
49#define NI_FLAG_DIR			0x00000040
50#define NI_FLAG_RESIDENT		0x00000080
51#define NI_FLAG_UPDATE_PARENT		0x00000100
52// clang-format on
53
54struct ntfs_mount_options {
55	struct nls_table *nls;
56
57	kuid_t fs_uid;
58	kgid_t fs_gid;
59	u16 fs_fmask_inv;
60	u16 fs_dmask_inv;
61
62	unsigned uid : 1,	/* uid was set. */
63		gid : 1,	/* gid was set. */
64		fmask : 1,	/* fmask was set. */
65		dmask : 1,	/* dmask was set. */
66		sys_immutable : 1,/* Immutable system files. */
67		discard : 1,	/* Issue discard requests on deletions. */
68		sparse : 1,	/* Create sparse files. */
69		showmeta : 1,	/* Show meta files. */
70		nohidden : 1, 	/* Do not show hidden files. */
71		force : 1, 	/* Rw mount dirty volume. */
72		no_acs_rules : 1,/*Exclude acs rules. */
73		prealloc : 1	/* Preallocate space when file is growing. */
74		;
75};
76
77/* Special value to unpack and deallocate. */
78#define RUN_DEALLOCATE ((struct runs_tree *)(size_t)1)
79
80/* TODO: Use rb tree instead of array. */
81struct runs_tree {
82	struct ntfs_run *runs;
83	size_t count; /* Currently used size a ntfs_run storage. */
84	size_t allocated; /* Currently allocated ntfs_run storage size. */
85};
86
87struct ntfs_buffers {
88	/* Biggest MFT / smallest cluster = 4096 / 512 = 8 */
89	/* Biggest index / smallest cluster = 4096 / 512 = 8 */
90	struct buffer_head *bh[PAGE_SIZE >> SECTOR_SHIFT];
91	u32 bytes;
92	u32 nbufs;
93	u32 off;
94};
95
96enum ALLOCATE_OPT {
97	ALLOCATE_DEF = 0, // Allocate all clusters.
98	ALLOCATE_MFT = 1, // Allocate for MFT.
99};
100
101enum bitmap_mutex_classes {
102	BITMAP_MUTEX_CLUSTERS = 0,
103	BITMAP_MUTEX_MFT = 1,
104};
105
106struct wnd_bitmap {
107	struct super_block *sb;
108	struct rw_semaphore rw_lock;
109
110	struct runs_tree run;
111	size_t nbits;
112
113	size_t total_zeroes; // Total number of free bits.
114	u16 *free_bits; // Free bits in each window.
115	size_t nwnd;
116	u32 bits_last; // Bits in last window.
117
118	struct rb_root start_tree; // Extents, sorted by 'start'.
119	struct rb_root count_tree; // Extents, sorted by 'count + start'.
120	size_t count; // Extents count.
121
122	/*
123	 * -1 Tree is activated but not updated (too many fragments).
124	 * 0 - Tree is not activated.
125	 * 1 - Tree is activated and updated.
126	 */
127	int uptodated;
128	size_t extent_min; // Minimal extent used while building.
129	size_t extent_max; // Upper estimate of biggest free block.
130
131	/* Zone [bit, end) */
132	size_t zone_bit;
133	size_t zone_end;
134
135	bool set_tail; // Not necessary in driver.
136	bool inited;
137};
138
139typedef int (*NTFS_CMP_FUNC)(const void *key1, size_t len1, const void *key2,
140			     size_t len2, const void *param);
141
142enum index_mutex_classed {
143	INDEX_MUTEX_I30 = 0,
144	INDEX_MUTEX_SII = 1,
145	INDEX_MUTEX_SDH = 2,
146	INDEX_MUTEX_SO = 3,
147	INDEX_MUTEX_SQ = 4,
148	INDEX_MUTEX_SR = 5,
149	INDEX_MUTEX_TOTAL
150};
151
152/* ntfs_index - Allocation unit inside directory. */
153struct ntfs_index {
154	struct runs_tree bitmap_run;
155	struct runs_tree alloc_run;
156	/* read/write access to 'bitmap_run'/'alloc_run' while ntfs_readdir */
157	struct rw_semaphore run_lock;
158
159	/*TODO: Remove 'cmp'. */
160	NTFS_CMP_FUNC cmp;
161
162	u8 index_bits; // log2(root->index_block_size)
163	u8 idx2vbn_bits; // log2(root->index_block_clst)
164	u8 vbn2vbo_bits; // index_block_size < cluster? 9 : cluster_bits
165	u8 type; // index_mutex_classed
166};
167
168/* Minimum MFT zone. */
169#define NTFS_MIN_MFT_ZONE 100
170
171/* Ntfs file system in-core superblock data. */
172struct ntfs_sb_info {
173	struct super_block *sb;
174
175	u32 discard_granularity;
176	u64 discard_granularity_mask_inv; // ~(discard_granularity_mask_inv-1)
177
178	u32 cluster_size; // bytes per cluster
179	u32 cluster_mask; // == cluster_size - 1
180	u64 cluster_mask_inv; // ~(cluster_size - 1)
181	u32 block_mask; // sb->s_blocksize - 1
182	u32 blocks_per_cluster; // cluster_size / sb->s_blocksize
183
184	u32 record_size;
185	u32 sector_size;
186	u32 index_size;
187
188	u8 sector_bits;
189	u8 cluster_bits;
190	u8 record_bits;
191
192	u64 maxbytes; // Maximum size for normal files.
193	u64 maxbytes_sparse; // Maximum size for sparse file.
194
195	u32 flags; // See NTFS_FLAGS_XXX.
196
197	CLST bad_clusters; // The count of marked bad clusters.
198
199	u16 max_bytes_per_attr; // Maximum attribute size in record.
200	u16 attr_size_tr; // Attribute size threshold (320 bytes).
201
202	/* Records in $Extend. */
203	CLST objid_no;
204	CLST quota_no;
205	CLST reparse_no;
206	CLST usn_jrnl_no;
207
208	struct ATTR_DEF_ENTRY *def_table; // Attribute definition table.
209	u32 def_entries;
210	u32 ea_max_size;
211
212	struct MFT_REC *new_rec;
213
214	u16 *upcase;
215
216	struct {
217		u64 lbo, lbo2;
218		struct ntfs_inode *ni;
219		struct wnd_bitmap bitmap; // $MFT::Bitmap
220		/*
221		 * MFT records [11-24) used to expand MFT itself.
222		 * They always marked as used in $MFT::Bitmap
223		 * 'reserved_bitmap' contains real bitmap of these records.
224		 */
225		ulong reserved_bitmap; // Bitmap of used records [11 - 24)
226		size_t next_free; // The next record to allocate from
227		size_t used; // MFT valid size in records.
228		u32 recs_mirr; // Number of records in MFTMirr
229		u8 next_reserved;
230		u8 reserved_bitmap_inited;
231	} mft;
232
233	struct {
234		struct wnd_bitmap bitmap; // $Bitmap::Data
235		CLST next_free_lcn;
236	} used;
237
238	struct {
239		u64 size; // In bytes.
240		u64 blocks; // In blocks.
241		u64 ser_num;
242		struct ntfs_inode *ni;
243		__le16 flags; // Cached current VOLUME_INFO::flags, VOLUME_FLAG_DIRTY.
244		u8 major_ver;
245		u8 minor_ver;
246		char label[65];
247		bool real_dirty; // Real fs state.
248	} volume;
249
250	struct {
251		struct ntfs_index index_sii;
252		struct ntfs_index index_sdh;
253		struct ntfs_inode *ni;
254		u32 next_id;
255		u64 next_off;
256
257		__le32 def_security_id;
258	} security;
259
260	struct {
261		struct ntfs_index index_r;
262		struct ntfs_inode *ni;
263		u64 max_size; // 16K
264	} reparse;
265
266	struct {
267		struct ntfs_index index_o;
268		struct ntfs_inode *ni;
269	} objid;
270
271	struct {
272		struct mutex mtx_lznt;
273		struct lznt *lznt;
274#ifdef CONFIG_NTFS3_LZX_XPRESS
275		struct mutex mtx_xpress;
276		struct xpress_decompressor *xpress;
277		struct mutex mtx_lzx;
278		struct lzx_decompressor *lzx;
279#endif
280	} compress;
281
282	struct ntfs_mount_options options;
283	struct ratelimit_state msg_ratelimit;
284};
285
286/* One MFT record(usually 1024 bytes), consists of attributes. */
287struct mft_inode {
288	struct rb_node node;
289	struct ntfs_sb_info *sbi;
290
291	struct MFT_REC *mrec;
292	struct ntfs_buffers nb;
293
294	CLST rno;
295	bool dirty;
296};
297
298/* Nested class for ntfs_inode::ni_lock. */
299enum ntfs_inode_mutex_lock_class {
300	NTFS_INODE_MUTEX_DIRTY,
301	NTFS_INODE_MUTEX_SECURITY,
302	NTFS_INODE_MUTEX_OBJID,
303	NTFS_INODE_MUTEX_REPARSE,
304	NTFS_INODE_MUTEX_NORMAL,
305	NTFS_INODE_MUTEX_PARENT,
306};
307
308/*
309 * sturct ntfs_inode
310 *
311 * Ntfs inode - extends linux inode. consists of one or more MFT inodes.
312 */
313struct ntfs_inode {
314	struct mft_inode mi; // base record
315
316	/*
317	 * Valid size: [0 - i_valid) - these range in file contains valid data.
318	 * Range [i_valid - inode->i_size) - contains 0.
319	 * Usually i_valid <= inode->i_size.
320	 */
321	u64 i_valid;
322	struct timespec64 i_crtime;
323
324	struct mutex ni_lock;
325
326	/* File attributes from std. */
327	enum FILE_ATTRIBUTE std_fa;
328	__le32 std_security_id;
329
330	/*
331	 * Tree of mft_inode.
332	 * Not empty when primary MFT record (usually 1024 bytes) can't save all attributes
333	 * e.g. file becomes too fragmented or contains a lot of names.
334	 */
335	struct rb_root mi_tree;
336
337	/*
338	 * This member is used in ntfs_readdir to ensure that all subrecords are loaded
339	 */
340	u8 mi_loaded;
341
342	union {
343		struct ntfs_index dir;
344		struct {
345			struct rw_semaphore run_lock;
346			struct runs_tree run;
347#ifdef CONFIG_NTFS3_LZX_XPRESS
348			struct page *offs_page;
349#endif
350		} file;
351	};
352
353	struct {
354		struct runs_tree run;
355		struct ATTR_LIST_ENTRY *le; // 1K aligned memory.
356		size_t size;
357		bool dirty;
358	} attr_list;
359
360	size_t ni_flags; // NI_FLAG_XXX
361
362	struct inode vfs_inode;
363};
364
365struct indx_node {
366	struct ntfs_buffers nb;
367	struct INDEX_BUFFER *index;
368};
369
370struct ntfs_fnd {
371	int level;
372	struct indx_node *nodes[20];
373	struct NTFS_DE *de[20];
374	struct NTFS_DE *root_de;
375};
376
377enum REPARSE_SIGN {
378	REPARSE_NONE = 0,
379	REPARSE_COMPRESSED = 1,
380	REPARSE_DEDUPLICATED = 2,
381	REPARSE_LINK = 3
382};
383
384/* Functions from attrib.c */
385int attr_load_runs(struct ATTRIB *attr, struct ntfs_inode *ni,
386		   struct runs_tree *run, const CLST *vcn);
387int attr_allocate_clusters(struct ntfs_sb_info *sbi, struct runs_tree *run,
388			   CLST vcn, CLST lcn, CLST len, CLST *pre_alloc,
389			   enum ALLOCATE_OPT opt, CLST *alen, const size_t fr,
390			   CLST *new_lcn);
391int attr_make_nonresident(struct ntfs_inode *ni, struct ATTRIB *attr,
392			  struct ATTR_LIST_ENTRY *le, struct mft_inode *mi,
393			  u64 new_size, struct runs_tree *run,
394			  struct ATTRIB **ins_attr, struct page *page);
395int attr_set_size(struct ntfs_inode *ni, enum ATTR_TYPE type,
396		  const __le16 *name, u8 name_len, struct runs_tree *run,
397		  u64 new_size, const u64 *new_valid, bool keep_prealloc,
398		  struct ATTRIB **ret);
399int attr_data_get_block(struct ntfs_inode *ni, CLST vcn, CLST clen, CLST *lcn,
400			CLST *len, bool *new);
401int attr_data_read_resident(struct ntfs_inode *ni, struct page *page);
402int attr_data_write_resident(struct ntfs_inode *ni, struct page *page);
403int attr_load_runs_vcn(struct ntfs_inode *ni, enum ATTR_TYPE type,
404		       const __le16 *name, u8 name_len, struct runs_tree *run,
405		       CLST vcn);
406int attr_load_runs_range(struct ntfs_inode *ni, enum ATTR_TYPE type,
407			 const __le16 *name, u8 name_len, struct runs_tree *run,
408			 u64 from, u64 to);
409int attr_wof_frame_info(struct ntfs_inode *ni, struct ATTRIB *attr,
410			struct runs_tree *run, u64 frame, u64 frames,
411			u8 frame_bits, u32 *ondisk_size, u64 *vbo_data);
412int attr_is_frame_compressed(struct ntfs_inode *ni, struct ATTRIB *attr,
413			     CLST frame, CLST *clst_data);
414int attr_allocate_frame(struct ntfs_inode *ni, CLST frame, size_t compr_size,
415			u64 new_valid);
416int attr_collapse_range(struct ntfs_inode *ni, u64 vbo, u64 bytes);
417int attr_punch_hole(struct ntfs_inode *ni, u64 vbo, u64 bytes, u32 *frame_size);
418
419/* Functions from attrlist.c */
420void al_destroy(struct ntfs_inode *ni);
421bool al_verify(struct ntfs_inode *ni);
422int ntfs_load_attr_list(struct ntfs_inode *ni, struct ATTRIB *attr);
423struct ATTR_LIST_ENTRY *al_enumerate(struct ntfs_inode *ni,
424				     struct ATTR_LIST_ENTRY *le);
425struct ATTR_LIST_ENTRY *al_find_le(struct ntfs_inode *ni,
426				   struct ATTR_LIST_ENTRY *le,
427				   const struct ATTRIB *attr);
428struct ATTR_LIST_ENTRY *al_find_ex(struct ntfs_inode *ni,
429				   struct ATTR_LIST_ENTRY *le,
430				   enum ATTR_TYPE type, const __le16 *name,
431				   u8 name_len, const CLST *vcn);
432int al_add_le(struct ntfs_inode *ni, enum ATTR_TYPE type, const __le16 *name,
433	      u8 name_len, CLST svcn, __le16 id, const struct MFT_REF *ref,
434	      struct ATTR_LIST_ENTRY **new_le);
435bool al_remove_le(struct ntfs_inode *ni, struct ATTR_LIST_ENTRY *le);
436bool al_delete_le(struct ntfs_inode *ni, enum ATTR_TYPE type, CLST vcn,
437		  const __le16 *name, size_t name_len,
438		  const struct MFT_REF *ref);
439int al_update(struct ntfs_inode *ni);
440static inline size_t al_aligned(size_t size)
441{
442	return (size + 1023) & ~(size_t)1023;
443}
444
445/* Globals from bitfunc.c */
446bool are_bits_clear(const ulong *map, size_t bit, size_t nbits);
447bool are_bits_set(const ulong *map, size_t bit, size_t nbits);
448size_t get_set_bits_ex(const ulong *map, size_t bit, size_t nbits);
449
450/* Globals from dir.c */
451int ntfs_utf16_to_nls(struct ntfs_sb_info *sbi, const struct le_str *uni,
452		      u8 *buf, int buf_len);
453int ntfs_nls_to_utf16(struct ntfs_sb_info *sbi, const u8 *name, u32 name_len,
454		      struct cpu_str *uni, u32 max_ulen,
455		      enum utf16_endian endian);
456struct inode *dir_search_u(struct inode *dir, const struct cpu_str *uni,
457			   struct ntfs_fnd *fnd);
458bool dir_is_empty(struct inode *dir);
459extern const struct file_operations ntfs_dir_operations;
460
461/* Globals from file.c */
462int ntfs_getattr(struct user_namespace *mnt_userns, const struct path *path,
463		 struct kstat *stat, u32 request_mask, u32 flags);
464void ntfs_sparse_cluster(struct inode *inode, struct page *page0, CLST vcn,
465			 CLST len);
466int ntfs3_setattr(struct user_namespace *mnt_userns, struct dentry *dentry,
467		  struct iattr *attr);
468int ntfs_file_open(struct inode *inode, struct file *file);
469int ntfs_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
470		__u64 start, __u64 len);
471extern const struct inode_operations ntfs_special_inode_operations;
472extern const struct inode_operations ntfs_file_inode_operations;
473extern const struct file_operations ntfs_file_operations;
474
475/* Globals from frecord.c */
476void ni_remove_mi(struct ntfs_inode *ni, struct mft_inode *mi);
477struct ATTR_STD_INFO *ni_std(struct ntfs_inode *ni);
478struct ATTR_STD_INFO5 *ni_std5(struct ntfs_inode *ni);
479void ni_clear(struct ntfs_inode *ni);
480int ni_load_mi_ex(struct ntfs_inode *ni, CLST rno, struct mft_inode **mi);
481int ni_load_mi(struct ntfs_inode *ni, struct ATTR_LIST_ENTRY *le,
482	       struct mft_inode **mi);
483struct ATTRIB *ni_find_attr(struct ntfs_inode *ni, struct ATTRIB *attr,
484			    struct ATTR_LIST_ENTRY **entry_o,
485			    enum ATTR_TYPE type, const __le16 *name,
486			    u8 name_len, const CLST *vcn,
487			    struct mft_inode **mi);
488struct ATTRIB *ni_enum_attr_ex(struct ntfs_inode *ni, struct ATTRIB *attr,
489			       struct ATTR_LIST_ENTRY **le,
490			       struct mft_inode **mi);
491struct ATTRIB *ni_load_attr(struct ntfs_inode *ni, enum ATTR_TYPE type,
492			    const __le16 *name, u8 name_len, CLST vcn,
493			    struct mft_inode **pmi);
494int ni_load_all_mi(struct ntfs_inode *ni);
495bool ni_add_subrecord(struct ntfs_inode *ni, CLST rno, struct mft_inode **mi);
496int ni_remove_attr(struct ntfs_inode *ni, enum ATTR_TYPE type,
497		   const __le16 *name, size_t name_len, bool base_only,
498		   const __le16 *id);
499int ni_create_attr_list(struct ntfs_inode *ni);
500int ni_expand_list(struct ntfs_inode *ni);
501int ni_insert_nonresident(struct ntfs_inode *ni, enum ATTR_TYPE type,
502			  const __le16 *name, u8 name_len,
503			  const struct runs_tree *run, CLST svcn, CLST len,
504			  __le16 flags, struct ATTRIB **new_attr,
505			  struct mft_inode **mi);
506int ni_insert_resident(struct ntfs_inode *ni, u32 data_size,
507		       enum ATTR_TYPE type, const __le16 *name, u8 name_len,
508		       struct ATTRIB **new_attr, struct mft_inode **mi);
509int ni_remove_attr_le(struct ntfs_inode *ni, struct ATTRIB *attr,
510		      struct ATTR_LIST_ENTRY *le);
511int ni_delete_all(struct ntfs_inode *ni);
512struct ATTR_FILE_NAME *ni_fname_name(struct ntfs_inode *ni,
513				     const struct cpu_str *uni,
514				     const struct MFT_REF *home,
515				     struct ATTR_LIST_ENTRY **entry);
516struct ATTR_FILE_NAME *ni_fname_type(struct ntfs_inode *ni, u8 name_type,
517				     struct ATTR_LIST_ENTRY **entry);
518int ni_new_attr_flags(struct ntfs_inode *ni, enum FILE_ATTRIBUTE new_fa);
519enum REPARSE_SIGN ni_parse_reparse(struct ntfs_inode *ni, struct ATTRIB *attr,
520				   void *buffer);
521int ni_write_inode(struct inode *inode, int sync, const char *hint);
522#define _ni_write_inode(i, w) ni_write_inode(i, w, __func__)
523int ni_fiemap(struct ntfs_inode *ni, struct fiemap_extent_info *fieinfo,
524	      __u64 vbo, __u64 len);
525int ni_readpage_cmpr(struct ntfs_inode *ni, struct page *page);
526int ni_decompress_file(struct ntfs_inode *ni);
527int ni_read_frame(struct ntfs_inode *ni, u64 frame_vbo, struct page **pages,
528		  u32 pages_per_frame);
529int ni_write_frame(struct ntfs_inode *ni, struct page **pages,
530		   u32 pages_per_frame);
531
532/* Globals from fslog.c */
533int log_replay(struct ntfs_inode *ni, bool *initialized);
534
535/* Globals from fsntfs.c */
536bool ntfs_fix_pre_write(struct NTFS_RECORD_HEADER *rhdr, size_t bytes);
537int ntfs_fix_post_read(struct NTFS_RECORD_HEADER *rhdr, size_t bytes,
538		       bool simple);
539int ntfs_extend_init(struct ntfs_sb_info *sbi);
540int ntfs_loadlog_and_replay(struct ntfs_inode *ni, struct ntfs_sb_info *sbi);
541const struct ATTR_DEF_ENTRY *ntfs_query_def(struct ntfs_sb_info *sbi,
542					    enum ATTR_TYPE Type);
543int ntfs_look_for_free_space(struct ntfs_sb_info *sbi, CLST lcn, CLST len,
544			     CLST *new_lcn, CLST *new_len,
545			     enum ALLOCATE_OPT opt);
546int ntfs_look_free_mft(struct ntfs_sb_info *sbi, CLST *rno, bool mft,
547		       struct ntfs_inode *ni, struct mft_inode **mi);
548void ntfs_mark_rec_free(struct ntfs_sb_info *sbi, CLST rno);
549int ntfs_clear_mft_tail(struct ntfs_sb_info *sbi, size_t from, size_t to);
550int ntfs_refresh_zone(struct ntfs_sb_info *sbi);
551int ntfs_update_mftmirr(struct ntfs_sb_info *sbi, int wait);
552enum NTFS_DIRTY_FLAGS {
553	NTFS_DIRTY_CLEAR = 0,
554	NTFS_DIRTY_DIRTY = 1,
555	NTFS_DIRTY_ERROR = 2,
556};
557int ntfs_set_state(struct ntfs_sb_info *sbi, enum NTFS_DIRTY_FLAGS dirty);
558int ntfs_sb_read(struct super_block *sb, u64 lbo, size_t bytes, void *buffer);
559int ntfs_sb_write(struct super_block *sb, u64 lbo, size_t bytes,
560		  const void *buffer, int wait);
561int ntfs_sb_write_run(struct ntfs_sb_info *sbi, const struct runs_tree *run,
562		      u64 vbo, const void *buf, size_t bytes);
563struct buffer_head *ntfs_bread_run(struct ntfs_sb_info *sbi,
564				   const struct runs_tree *run, u64 vbo);
565int ntfs_read_run_nb(struct ntfs_sb_info *sbi, const struct runs_tree *run,
566		     u64 vbo, void *buf, u32 bytes, struct ntfs_buffers *nb);
567int ntfs_read_bh(struct ntfs_sb_info *sbi, const struct runs_tree *run, u64 vbo,
568		 struct NTFS_RECORD_HEADER *rhdr, u32 bytes,
569		 struct ntfs_buffers *nb);
570int ntfs_get_bh(struct ntfs_sb_info *sbi, const struct runs_tree *run, u64 vbo,
571		u32 bytes, struct ntfs_buffers *nb);
572int ntfs_write_bh(struct ntfs_sb_info *sbi, struct NTFS_RECORD_HEADER *rhdr,
573		  struct ntfs_buffers *nb, int sync);
574int ntfs_bio_pages(struct ntfs_sb_info *sbi, const struct runs_tree *run,
575		   struct page **pages, u32 nr_pages, u64 vbo, u32 bytes,
576		   u32 op);
577int ntfs_bio_fill_1(struct ntfs_sb_info *sbi, const struct runs_tree *run);
578int ntfs_vbo_to_lbo(struct ntfs_sb_info *sbi, const struct runs_tree *run,
579		    u64 vbo, u64 *lbo, u64 *bytes);
580struct ntfs_inode *ntfs_new_inode(struct ntfs_sb_info *sbi, CLST nRec,
581				  bool dir);
582extern const u8 s_default_security[0x50];
583bool is_sd_valid(const struct SECURITY_DESCRIPTOR_RELATIVE *sd, u32 len);
584int ntfs_security_init(struct ntfs_sb_info *sbi);
585int ntfs_get_security_by_id(struct ntfs_sb_info *sbi, __le32 security_id,
586			    struct SECURITY_DESCRIPTOR_RELATIVE **sd,
587			    size_t *size);
588int ntfs_insert_security(struct ntfs_sb_info *sbi,
589			 const struct SECURITY_DESCRIPTOR_RELATIVE *sd,
590			 u32 size, __le32 *security_id, bool *inserted);
591int ntfs_reparse_init(struct ntfs_sb_info *sbi);
592int ntfs_objid_init(struct ntfs_sb_info *sbi);
593int ntfs_objid_remove(struct ntfs_sb_info *sbi, struct GUID *guid);
594int ntfs_insert_reparse(struct ntfs_sb_info *sbi, __le32 rtag,
595			const struct MFT_REF *ref);
596int ntfs_remove_reparse(struct ntfs_sb_info *sbi, __le32 rtag,
597			const struct MFT_REF *ref);
598void mark_as_free_ex(struct ntfs_sb_info *sbi, CLST lcn, CLST len, bool trim);
599int run_deallocate(struct ntfs_sb_info *sbi, struct runs_tree *run, bool trim);
600
601/* Globals from index.c */
602int indx_used_bit(struct ntfs_index *indx, struct ntfs_inode *ni, size_t *bit);
603void fnd_clear(struct ntfs_fnd *fnd);
604static inline struct ntfs_fnd *fnd_get(void)
605{
606	return kzalloc(sizeof(struct ntfs_fnd), GFP_NOFS);
607}
608static inline void fnd_put(struct ntfs_fnd *fnd)
609{
610	if (fnd) {
611		fnd_clear(fnd);
612		kfree(fnd);
613	}
614}
615void indx_clear(struct ntfs_index *idx);
616int indx_init(struct ntfs_index *indx, struct ntfs_sb_info *sbi,
617	      const struct ATTRIB *attr, enum index_mutex_classed type);
618struct INDEX_ROOT *indx_get_root(struct ntfs_index *indx, struct ntfs_inode *ni,
619				 struct ATTRIB **attr, struct mft_inode **mi);
620int indx_read(struct ntfs_index *idx, struct ntfs_inode *ni, CLST vbn,
621	      struct indx_node **node);
622int indx_find(struct ntfs_index *indx, struct ntfs_inode *dir,
623	      const struct INDEX_ROOT *root, const void *Key, size_t KeyLen,
624	      const void *param, int *diff, struct NTFS_DE **entry,
625	      struct ntfs_fnd *fnd);
626int indx_find_sort(struct ntfs_index *indx, struct ntfs_inode *ni,
627		   const struct INDEX_ROOT *root, struct NTFS_DE **entry,
628		   struct ntfs_fnd *fnd);
629int indx_find_raw(struct ntfs_index *indx, struct ntfs_inode *ni,
630		  const struct INDEX_ROOT *root, struct NTFS_DE **entry,
631		  size_t *off, struct ntfs_fnd *fnd);
632int indx_insert_entry(struct ntfs_index *indx, struct ntfs_inode *ni,
633		      const struct NTFS_DE *new_de, const void *param,
634		      struct ntfs_fnd *fnd);
635int indx_delete_entry(struct ntfs_index *indx, struct ntfs_inode *ni,
636		      const void *key, u32 key_len, const void *param);
637int indx_update_dup(struct ntfs_inode *ni, struct ntfs_sb_info *sbi,
638		    const struct ATTR_FILE_NAME *fname,
639		    const struct NTFS_DUP_INFO *dup, int sync);
640
641/* Globals from inode.c */
642struct inode *ntfs_iget5(struct super_block *sb, const struct MFT_REF *ref,
643			 const struct cpu_str *name);
644int ntfs_set_size(struct inode *inode, u64 new_size);
645int reset_log_file(struct inode *inode);
646int ntfs_get_block(struct inode *inode, sector_t vbn,
647		   struct buffer_head *bh_result, int create);
648int ntfs3_write_inode(struct inode *inode, struct writeback_control *wbc);
649int ntfs_sync_inode(struct inode *inode);
650int ntfs_flush_inodes(struct super_block *sb, struct inode *i1,
651		      struct inode *i2);
652int inode_write_data(struct inode *inode, const void *data, size_t bytes);
653struct inode *ntfs_create_inode(struct user_namespace *mnt_userns,
654				struct inode *dir, struct dentry *dentry,
655				const struct cpu_str *uni, umode_t mode,
656				dev_t dev, const char *symname, u32 size,
657				struct ntfs_fnd *fnd);
658int ntfs_link_inode(struct inode *inode, struct dentry *dentry);
659int ntfs_unlink_inode(struct inode *dir, const struct dentry *dentry);
660void ntfs_evict_inode(struct inode *inode);
661extern const struct inode_operations ntfs_link_inode_operations;
662extern const struct address_space_operations ntfs_aops;
663extern const struct address_space_operations ntfs_aops_cmpr;
664
665/* Globals from name_i.c */
666int fill_name_de(struct ntfs_sb_info *sbi, void *buf, const struct qstr *name,
667		 const struct cpu_str *uni);
668struct dentry *ntfs3_get_parent(struct dentry *child);
669
670extern const struct inode_operations ntfs_dir_inode_operations;
671extern const struct inode_operations ntfs_special_inode_operations;
672
673/* Globals from record.c */
674int mi_get(struct ntfs_sb_info *sbi, CLST rno, struct mft_inode **mi);
675void mi_put(struct mft_inode *mi);
676int mi_init(struct mft_inode *mi, struct ntfs_sb_info *sbi, CLST rno);
677int mi_read(struct mft_inode *mi, bool is_mft);
678struct ATTRIB *mi_enum_attr(struct mft_inode *mi, struct ATTRIB *attr);
679// TODO: id?
680struct ATTRIB *mi_find_attr(struct mft_inode *mi, struct ATTRIB *attr,
681			    enum ATTR_TYPE type, const __le16 *name,
682			    size_t name_len, const __le16 *id);
683static inline struct ATTRIB *rec_find_attr_le(struct mft_inode *rec,
684					      struct ATTR_LIST_ENTRY *le)
685{
686	return mi_find_attr(rec, NULL, le->type, le_name(le), le->name_len,
687			    &le->id);
688}
689int mi_write(struct mft_inode *mi, int wait);
690int mi_format_new(struct mft_inode *mi, struct ntfs_sb_info *sbi, CLST rno,
691		  __le16 flags, bool is_mft);
692void mi_mark_free(struct mft_inode *mi);
693struct ATTRIB *mi_insert_attr(struct mft_inode *mi, enum ATTR_TYPE type,
694			      const __le16 *name, u8 name_len, u32 asize,
695			      u16 name_off);
696
697bool mi_remove_attr(struct mft_inode *mi, struct ATTRIB *attr);
698bool mi_resize_attr(struct mft_inode *mi, struct ATTRIB *attr, int bytes);
699int mi_pack_runs(struct mft_inode *mi, struct ATTRIB *attr,
700		 struct runs_tree *run, CLST len);
701static inline bool mi_is_ref(const struct mft_inode *mi,
702			     const struct MFT_REF *ref)
703{
704	if (le32_to_cpu(ref->low) != mi->rno)
705		return false;
706	if (ref->seq != mi->mrec->seq)
707		return false;
708
709#ifdef CONFIG_NTFS3_64BIT_CLUSTER
710	return le16_to_cpu(ref->high) == (mi->rno >> 32);
711#else
712	return !ref->high;
713#endif
714}
715
716static inline void mi_get_ref(const struct mft_inode *mi, struct MFT_REF *ref)
717{
718	ref->low = cpu_to_le32(mi->rno);
719#ifdef CONFIG_NTFS3_64BIT_CLUSTER
720	ref->high = cpu_to_le16(mi->rno >> 32);
721#else
722	ref->high = 0;
723#endif
724	ref->seq = mi->mrec->seq;
725}
726
727/* Globals from run.c */
728bool run_lookup_entry(const struct runs_tree *run, CLST vcn, CLST *lcn,
729		      CLST *len, size_t *index);
730void run_truncate(struct runs_tree *run, CLST vcn);
731void run_truncate_head(struct runs_tree *run, CLST vcn);
732void run_truncate_around(struct runs_tree *run, CLST vcn);
733bool run_lookup(const struct runs_tree *run, CLST vcn, size_t *Index);
734bool run_add_entry(struct runs_tree *run, CLST vcn, CLST lcn, CLST len,
735		   bool is_mft);
736bool run_collapse_range(struct runs_tree *run, CLST vcn, CLST len);
737bool run_get_entry(const struct runs_tree *run, size_t index, CLST *vcn,
738		   CLST *lcn, CLST *len);
739bool run_is_mapped_full(const struct runs_tree *run, CLST svcn, CLST evcn);
740
741int run_pack(const struct runs_tree *run, CLST svcn, CLST len, u8 *run_buf,
742	     u32 run_buf_size, CLST *packed_vcns);
743int run_unpack(struct runs_tree *run, struct ntfs_sb_info *sbi, CLST ino,
744	       CLST svcn, CLST evcn, CLST vcn, const u8 *run_buf,
745	       u32 run_buf_size);
746
747#ifdef NTFS3_CHECK_FREE_CLST
748int run_unpack_ex(struct runs_tree *run, struct ntfs_sb_info *sbi, CLST ino,
749		  CLST svcn, CLST evcn, CLST vcn, const u8 *run_buf,
750		  u32 run_buf_size);
751#else
752#define run_unpack_ex run_unpack
753#endif
754int run_get_highest_vcn(CLST vcn, const u8 *run_buf, u64 *highest_vcn);
755
756/* Globals from super.c */
757void *ntfs_set_shared(void *ptr, u32 bytes);
758void *ntfs_put_shared(void *ptr);
759void ntfs_unmap_meta(struct super_block *sb, CLST lcn, CLST len);
760int ntfs_discard(struct ntfs_sb_info *sbi, CLST Lcn, CLST Len);
761
762/* Globals from bitmap.c*/
763int __init ntfs3_init_bitmap(void);
764void ntfs3_exit_bitmap(void);
765void wnd_close(struct wnd_bitmap *wnd);
766static inline size_t wnd_zeroes(const struct wnd_bitmap *wnd)
767{
768	return wnd->total_zeroes;
769}
770int wnd_init(struct wnd_bitmap *wnd, struct super_block *sb, size_t nbits);
771int wnd_set_free(struct wnd_bitmap *wnd, size_t bit, size_t bits);
772int wnd_set_used(struct wnd_bitmap *wnd, size_t bit, size_t bits);
773bool wnd_is_free(struct wnd_bitmap *wnd, size_t bit, size_t bits);
774bool wnd_is_used(struct wnd_bitmap *wnd, size_t bit, size_t bits);
775
776/* Possible values for 'flags' 'wnd_find'. */
777#define BITMAP_FIND_MARK_AS_USED 0x01
778#define BITMAP_FIND_FULL 0x02
779size_t wnd_find(struct wnd_bitmap *wnd, size_t to_alloc, size_t hint,
780		size_t flags, size_t *allocated);
781int wnd_extend(struct wnd_bitmap *wnd, size_t new_bits);
782void wnd_zone_set(struct wnd_bitmap *wnd, size_t Lcn, size_t Len);
783int ntfs_trim_fs(struct ntfs_sb_info *sbi, struct fstrim_range *range);
784
785/* Globals from upcase.c */
786int ntfs_cmp_names(const __le16 *s1, size_t l1, const __le16 *s2, size_t l2,
787		   const u16 *upcase, bool bothcase);
788int ntfs_cmp_names_cpu(const struct cpu_str *uni1, const struct le_str *uni2,
789		       const u16 *upcase, bool bothcase);
790
791/* globals from xattr.c */
792#ifdef CONFIG_NTFS3_FS_POSIX_ACL
793struct posix_acl *ntfs_get_acl(struct inode *inode, int type);
794int ntfs_set_acl(struct user_namespace *mnt_userns, struct inode *inode,
795		 struct posix_acl *acl, int type);
796int ntfs_init_acl(struct user_namespace *mnt_userns, struct inode *inode,
797		  struct inode *dir);
798#else
799#define ntfs_get_acl NULL
800#define ntfs_set_acl NULL
801#endif
802
803int ntfs_acl_chmod(struct user_namespace *mnt_userns, struct inode *inode);
804int ntfs_permission(struct user_namespace *mnt_userns, struct inode *inode,
805		    int mask);
806ssize_t ntfs_listxattr(struct dentry *dentry, char *buffer, size_t size);
807extern const struct xattr_handler *ntfs_xattr_handlers[];
808
809int ntfs_save_wsl_perm(struct inode *inode);
810void ntfs_get_wsl_perm(struct inode *inode);
811
812/* globals from lznt.c */
813struct lznt *get_lznt_ctx(int level);
814size_t compress_lznt(const void *uncompressed, size_t uncompressed_size,
815		     void *compressed, size_t compressed_size,
816		     struct lznt *ctx);
817ssize_t decompress_lznt(const void *compressed, size_t compressed_size,
818			void *uncompressed, size_t uncompressed_size);
819
820static inline bool is_ntfs3(struct ntfs_sb_info *sbi)
821{
822	return sbi->volume.major_ver >= 3;
823}
824
825/* (sb->s_flags & SB_ACTIVE) */
826static inline bool is_mounted(struct ntfs_sb_info *sbi)
827{
828	return !!sbi->sb->s_root;
829}
830
831static inline bool ntfs_is_meta_file(struct ntfs_sb_info *sbi, CLST rno)
832{
833	return rno < MFT_REC_FREE || rno == sbi->objid_no ||
834	       rno == sbi->quota_no || rno == sbi->reparse_no ||
835	       rno == sbi->usn_jrnl_no;
836}
837
838static inline void ntfs_unmap_page(struct page *page)
839{
840	kunmap(page);
841	put_page(page);
842}
843
844static inline struct page *ntfs_map_page(struct address_space *mapping,
845					 unsigned long index)
846{
847	struct page *page = read_mapping_page(mapping, index, NULL);
848
849	if (!IS_ERR(page)) {
850		kmap(page);
851		if (!PageError(page))
852			return page;
853		ntfs_unmap_page(page);
854		return ERR_PTR(-EIO);
855	}
856	return page;
857}
858
859static inline size_t wnd_zone_bit(const struct wnd_bitmap *wnd)
860{
861	return wnd->zone_bit;
862}
863
864static inline size_t wnd_zone_len(const struct wnd_bitmap *wnd)
865{
866	return wnd->zone_end - wnd->zone_bit;
867}
868
869static inline void run_init(struct runs_tree *run)
870{
871	run->runs = NULL;
872	run->count = 0;
873	run->allocated = 0;
874}
875
876static inline struct runs_tree *run_alloc(void)
877{
878	return kzalloc(sizeof(struct runs_tree), GFP_NOFS);
879}
880
881static inline void run_close(struct runs_tree *run)
882{
883	kvfree(run->runs);
884	memset(run, 0, sizeof(*run));
885}
886
887static inline void run_free(struct runs_tree *run)
888{
889	if (run) {
890		kvfree(run->runs);
891		kfree(run);
892	}
893}
894
895static inline bool run_is_empty(struct runs_tree *run)
896{
897	return !run->count;
898}
899
900/* NTFS uses quad aligned bitmaps. */
901static inline size_t bitmap_size(size_t bits)
902{
903	return ALIGN((bits + 7) >> 3, 8);
904}
905
906#define _100ns2seconds 10000000
907#define SecondsToStartOf1970 0x00000002B6109100
908
909#define NTFS_TIME_GRAN 100
910
911/*
912 * kernel2nt - Converts in-memory kernel timestamp into nt time.
913 */
914static inline __le64 kernel2nt(const struct timespec64 *ts)
915{
916	// 10^7 units of 100 nanoseconds one second
917	return cpu_to_le64(_100ns2seconds *
918				   (ts->tv_sec + SecondsToStartOf1970) +
919			   ts->tv_nsec / NTFS_TIME_GRAN);
920}
921
922/*
923 * nt2kernel - Converts on-disk nt time into kernel timestamp.
924 */
925static inline void nt2kernel(const __le64 tm, struct timespec64 *ts)
926{
927	u64 t = le64_to_cpu(tm) - _100ns2seconds * SecondsToStartOf1970;
928
929	// WARNING: do_div changes its first argument(!)
930	ts->tv_nsec = do_div(t, _100ns2seconds) * 100;
931	ts->tv_sec = t;
932}
933
934static inline struct ntfs_sb_info *ntfs_sb(struct super_block *sb)
935{
936	return sb->s_fs_info;
937}
938
939/*
940 * ntfs_up_cluster - Align up on cluster boundary.
941 */
942static inline u64 ntfs_up_cluster(const struct ntfs_sb_info *sbi, u64 size)
943{
944	return (size + sbi->cluster_mask) & sbi->cluster_mask_inv;
945}
946
947/*
948 * ntfs_up_block - Align up on cluster boundary.
949 */
950static inline u64 ntfs_up_block(const struct super_block *sb, u64 size)
951{
952	return (size + sb->s_blocksize - 1) & ~(u64)(sb->s_blocksize - 1);
953}
954
955static inline CLST bytes_to_cluster(const struct ntfs_sb_info *sbi, u64 size)
956{
957	return (size + sbi->cluster_mask) >> sbi->cluster_bits;
958}
959
960static inline u64 bytes_to_block(const struct super_block *sb, u64 size)
961{
962	return (size + sb->s_blocksize - 1) >> sb->s_blocksize_bits;
963}
964
965static inline struct buffer_head *ntfs_bread(struct super_block *sb,
966					     sector_t block)
967{
968	struct buffer_head *bh = sb_bread(sb, block);
969
970	if (bh)
971		return bh;
972
973	ntfs_err(sb, "failed to read volume at offset 0x%llx",
974		 (u64)block << sb->s_blocksize_bits);
975	return NULL;
976}
977
978static inline struct ntfs_inode *ntfs_i(struct inode *inode)
979{
980	return container_of(inode, struct ntfs_inode, vfs_inode);
981}
982
983static inline bool is_compressed(const struct ntfs_inode *ni)
984{
985	return (ni->std_fa & FILE_ATTRIBUTE_COMPRESSED) ||
986	       (ni->ni_flags & NI_FLAG_COMPRESSED_MASK);
987}
988
989static inline int ni_ext_compress_bits(const struct ntfs_inode *ni)
990{
991	return 0xb + (ni->ni_flags & NI_FLAG_COMPRESSED_MASK);
992}
993
994/* Bits - 0xc, 0xd, 0xe, 0xf, 0x10 */
995static inline void ni_set_ext_compress_bits(struct ntfs_inode *ni, u8 bits)
996{
997	ni->ni_flags |= (bits - 0xb) & NI_FLAG_COMPRESSED_MASK;
998}
999
1000static inline bool is_dedup(const struct ntfs_inode *ni)
1001{
1002	return ni->ni_flags & NI_FLAG_DEDUPLICATED;
1003}
1004
1005static inline bool is_encrypted(const struct ntfs_inode *ni)
1006{
1007	return ni->std_fa & FILE_ATTRIBUTE_ENCRYPTED;
1008}
1009
1010static inline bool is_sparsed(const struct ntfs_inode *ni)
1011{
1012	return ni->std_fa & FILE_ATTRIBUTE_SPARSE_FILE;
1013}
1014
1015static inline int is_resident(struct ntfs_inode *ni)
1016{
1017	return ni->ni_flags & NI_FLAG_RESIDENT;
1018}
1019
1020static inline void le16_sub_cpu(__le16 *var, u16 val)
1021{
1022	*var = cpu_to_le16(le16_to_cpu(*var) - val);
1023}
1024
1025static inline void le32_sub_cpu(__le32 *var, u32 val)
1026{
1027	*var = cpu_to_le32(le32_to_cpu(*var) - val);
1028}
1029
1030static inline void nb_put(struct ntfs_buffers *nb)
1031{
1032	u32 i, nbufs = nb->nbufs;
1033
1034	if (!nbufs)
1035		return;
1036
1037	for (i = 0; i < nbufs; i++)
1038		put_bh(nb->bh[i]);
1039	nb->nbufs = 0;
1040}
1041
1042static inline void put_indx_node(struct indx_node *in)
1043{
1044	if (!in)
1045		return;
1046
1047	kfree(in->index);
1048	nb_put(&in->nb);
1049	kfree(in);
1050}
1051
1052static inline void mi_clear(struct mft_inode *mi)
1053{
1054	nb_put(&mi->nb);
1055	kfree(mi->mrec);
1056	mi->mrec = NULL;
1057}
1058
1059static inline void ni_lock(struct ntfs_inode *ni)
1060{
1061	mutex_lock_nested(&ni->ni_lock, NTFS_INODE_MUTEX_NORMAL);
1062}
1063
1064static inline void ni_lock_dir(struct ntfs_inode *ni)
1065{
1066	mutex_lock_nested(&ni->ni_lock, NTFS_INODE_MUTEX_PARENT);
1067}
1068
1069static inline void ni_unlock(struct ntfs_inode *ni)
1070{
1071	mutex_unlock(&ni->ni_lock);
1072}
1073
1074static inline int ni_trylock(struct ntfs_inode *ni)
1075{
1076	return mutex_trylock(&ni->ni_lock);
1077}
1078
1079static inline int attr_load_runs_attr(struct ntfs_inode *ni,
1080				      struct ATTRIB *attr,
1081				      struct runs_tree *run, CLST vcn)
1082{
1083	return attr_load_runs_vcn(ni, attr->type, attr_name(attr),
1084				  attr->name_len, run, vcn);
1085}
1086
1087static inline void le64_sub_cpu(__le64 *var, u64 val)
1088{
1089	*var = cpu_to_le64(le64_to_cpu(*var) - val);
1090}
1091
1092#endif /* _LINUX_NTFS3_NTFS_FS_H */
1093