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 54 struct 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 */ 81 struct 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 87 struct 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 96 enum ALLOCATE_OPT { 97 ALLOCATE_DEF = 0, // Allocate all clusters 98 ALLOCATE_MFT = 1, // Allocate for MFT 99 }; 100 101 enum bitmap_mutex_classes { 102 BITMAP_MUTEX_CLUSTERS = 0, 103 BITMAP_MUTEX_MFT = 1, 104 }; 105 106 struct 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 139 typedef int (*NTFS_CMP_FUNC)(const void *key1, size_t len1, const void *key2, 140 size_t len2, const void *param); 141 142 enum 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 */ 153 struct 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 */ 172 struct 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 /* 287 * one MFT record(usually 1024 bytes), consists of attributes 288 */ 289 struct mft_inode { 290 struct rb_node node; 291 struct ntfs_sb_info *sbi; 292 293 struct MFT_REC *mrec; 294 struct ntfs_buffers nb; 295 296 CLST rno; 297 bool dirty; 298 }; 299 300 /* nested class for ntfs_inode::ni_lock */ 301 enum ntfs_inode_mutex_lock_class { 302 NTFS_INODE_MUTEX_DIRTY, 303 NTFS_INODE_MUTEX_SECURITY, 304 NTFS_INODE_MUTEX_OBJID, 305 NTFS_INODE_MUTEX_REPARSE, 306 NTFS_INODE_MUTEX_NORMAL, 307 NTFS_INODE_MUTEX_PARENT, 308 }; 309 310 /* 311 * ntfs inode - extends linux inode. consists of one or more mft inodes 312 */ 313 struct 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 365 struct indx_node { 366 struct ntfs_buffers nb; 367 struct INDEX_BUFFER *index; 368 }; 369 370 struct 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 377 enum 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*/ 385 int attr_load_runs(struct ATTRIB *attr, struct ntfs_inode *ni, 386 struct runs_tree *run, const CLST *vcn); 387 int 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); 391 int 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); 395 int 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); 399 int attr_data_get_block(struct ntfs_inode *ni, CLST vcn, CLST clen, CLST *lcn, 400 CLST *len, bool *new); 401 int attr_data_read_resident(struct ntfs_inode *ni, struct page *page); 402 int attr_data_write_resident(struct ntfs_inode *ni, struct page *page); 403 int 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); 406 int 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); 409 int 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); 412 int attr_is_frame_compressed(struct ntfs_inode *ni, struct ATTRIB *attr, 413 CLST frame, CLST *clst_data); 414 int attr_allocate_frame(struct ntfs_inode *ni, CLST frame, size_t compr_size, 415 u64 new_valid); 416 int attr_collapse_range(struct ntfs_inode *ni, u64 vbo, u64 bytes); 417 int attr_punch_hole(struct ntfs_inode *ni, u64 vbo, u64 bytes, u32 *frame_size); 418 419 /* functions from attrlist.c*/ 420 void al_destroy(struct ntfs_inode *ni); 421 bool al_verify(struct ntfs_inode *ni); 422 int ntfs_load_attr_list(struct ntfs_inode *ni, struct ATTRIB *attr); 423 struct ATTR_LIST_ENTRY *al_enumerate(struct ntfs_inode *ni, 424 struct ATTR_LIST_ENTRY *le); 425 struct ATTR_LIST_ENTRY *al_find_le(struct ntfs_inode *ni, 426 struct ATTR_LIST_ENTRY *le, 427 const struct ATTRIB *attr); 428 struct 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); 432 int 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); 435 bool al_remove_le(struct ntfs_inode *ni, struct ATTR_LIST_ENTRY *le); 436 bool 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); 439 int al_update(struct ntfs_inode *ni); 440 static inline size_t al_aligned(size_t size) 441 { 442 return (size + 1023) & ~(size_t)1023; 443 } 444 445 /* globals from bitfunc.c */ 446 bool are_bits_clear(const ulong *map, size_t bit, size_t nbits); 447 bool are_bits_set(const ulong *map, size_t bit, size_t nbits); 448 size_t get_set_bits_ex(const ulong *map, size_t bit, size_t nbits); 449 450 /* globals from dir.c */ 451 int ntfs_utf16_to_nls(struct ntfs_sb_info *sbi, const struct le_str *uni, 452 u8 *buf, int buf_len); 453 int 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); 456 struct inode *dir_search_u(struct inode *dir, const struct cpu_str *uni, 457 struct ntfs_fnd *fnd); 458 bool dir_is_empty(struct inode *dir); 459 extern const struct file_operations ntfs_dir_operations; 460 461 /* globals from file.c*/ 462 int ntfs_getattr(struct user_namespace *mnt_userns, const struct path *path, 463 struct kstat *stat, u32 request_mask, u32 flags); 464 void ntfs_sparse_cluster(struct inode *inode, struct page *page0, CLST vcn, 465 CLST len); 466 int ntfs3_setattr(struct user_namespace *mnt_userns, struct dentry *dentry, 467 struct iattr *attr); 468 int ntfs_file_open(struct inode *inode, struct file *file); 469 int ntfs_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo, 470 __u64 start, __u64 len); 471 extern const struct inode_operations ntfs_special_inode_operations; 472 extern const struct inode_operations ntfs_file_inode_operations; 473 extern const struct file_operations ntfs_file_operations; 474 475 /* globals from frecord.c */ 476 void ni_remove_mi(struct ntfs_inode *ni, struct mft_inode *mi); 477 struct ATTR_STD_INFO *ni_std(struct ntfs_inode *ni); 478 struct ATTR_STD_INFO5 *ni_std5(struct ntfs_inode *ni); 479 void ni_clear(struct ntfs_inode *ni); 480 int ni_load_mi_ex(struct ntfs_inode *ni, CLST rno, struct mft_inode **mi); 481 int ni_load_mi(struct ntfs_inode *ni, struct ATTR_LIST_ENTRY *le, 482 struct mft_inode **mi); 483 struct 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); 488 struct ATTRIB *ni_enum_attr_ex(struct ntfs_inode *ni, struct ATTRIB *attr, 489 struct ATTR_LIST_ENTRY **le, 490 struct mft_inode **mi); 491 struct 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); 494 int ni_load_all_mi(struct ntfs_inode *ni); 495 bool ni_add_subrecord(struct ntfs_inode *ni, CLST rno, struct mft_inode **mi); 496 int 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); 499 int ni_create_attr_list(struct ntfs_inode *ni); 500 int ni_expand_list(struct ntfs_inode *ni); 501 int 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); 506 int 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); 509 int ni_remove_attr_le(struct ntfs_inode *ni, struct ATTRIB *attr, 510 struct ATTR_LIST_ENTRY *le); 511 int ni_delete_all(struct ntfs_inode *ni); 512 struct 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); 516 struct ATTR_FILE_NAME *ni_fname_type(struct ntfs_inode *ni, u8 name_type, 517 struct ATTR_LIST_ENTRY **entry); 518 int ni_new_attr_flags(struct ntfs_inode *ni, enum FILE_ATTRIBUTE new_fa); 519 enum REPARSE_SIGN ni_parse_reparse(struct ntfs_inode *ni, struct ATTRIB *attr, 520 void *buffer); 521 int ni_write_inode(struct inode *inode, int sync, const char *hint); 522 #define _ni_write_inode(i, w) ni_write_inode(i, w, __func__) 523 int ni_fiemap(struct ntfs_inode *ni, struct fiemap_extent_info *fieinfo, 524 __u64 vbo, __u64 len); 525 int ni_readpage_cmpr(struct ntfs_inode *ni, struct page *page); 526 int ni_decompress_file(struct ntfs_inode *ni); 527 int ni_read_frame(struct ntfs_inode *ni, u64 frame_vbo, struct page **pages, 528 u32 pages_per_frame); 529 int ni_write_frame(struct ntfs_inode *ni, struct page **pages, 530 u32 pages_per_frame); 531 532 /* globals from fslog.c */ 533 int log_replay(struct ntfs_inode *ni, bool *initialized); 534 535 /* globals from fsntfs.c */ 536 bool ntfs_fix_pre_write(struct NTFS_RECORD_HEADER *rhdr, size_t bytes); 537 int ntfs_fix_post_read(struct NTFS_RECORD_HEADER *rhdr, size_t bytes, 538 bool simple); 539 int ntfs_extend_init(struct ntfs_sb_info *sbi); 540 int ntfs_loadlog_and_replay(struct ntfs_inode *ni, struct ntfs_sb_info *sbi); 541 const struct ATTR_DEF_ENTRY *ntfs_query_def(struct ntfs_sb_info *sbi, 542 enum ATTR_TYPE Type); 543 int 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); 546 int ntfs_look_free_mft(struct ntfs_sb_info *sbi, CLST *rno, bool mft, 547 struct ntfs_inode *ni, struct mft_inode **mi); 548 void ntfs_mark_rec_free(struct ntfs_sb_info *sbi, CLST rno); 549 int ntfs_clear_mft_tail(struct ntfs_sb_info *sbi, size_t from, size_t to); 550 int ntfs_refresh_zone(struct ntfs_sb_info *sbi); 551 int ntfs_update_mftmirr(struct ntfs_sb_info *sbi, int wait); 552 enum NTFS_DIRTY_FLAGS { 553 NTFS_DIRTY_CLEAR = 0, 554 NTFS_DIRTY_DIRTY = 1, 555 NTFS_DIRTY_ERROR = 2, 556 }; 557 int ntfs_set_state(struct ntfs_sb_info *sbi, enum NTFS_DIRTY_FLAGS dirty); 558 int ntfs_sb_read(struct super_block *sb, u64 lbo, size_t bytes, void *buffer); 559 int ntfs_sb_write(struct super_block *sb, u64 lbo, size_t bytes, 560 const void *buffer, int wait); 561 int ntfs_sb_write_run(struct ntfs_sb_info *sbi, const struct runs_tree *run, 562 u64 vbo, const void *buf, size_t bytes); 563 struct buffer_head *ntfs_bread_run(struct ntfs_sb_info *sbi, 564 const struct runs_tree *run, u64 vbo); 565 int 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); 567 int 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); 570 int ntfs_get_bh(struct ntfs_sb_info *sbi, const struct runs_tree *run, u64 vbo, 571 u32 bytes, struct ntfs_buffers *nb); 572 int ntfs_write_bh(struct ntfs_sb_info *sbi, struct NTFS_RECORD_HEADER *rhdr, 573 struct ntfs_buffers *nb, int sync); 574 int 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); 577 int ntfs_bio_fill_1(struct ntfs_sb_info *sbi, const struct runs_tree *run); 578 int ntfs_vbo_to_lbo(struct ntfs_sb_info *sbi, const struct runs_tree *run, 579 u64 vbo, u64 *lbo, u64 *bytes); 580 struct ntfs_inode *ntfs_new_inode(struct ntfs_sb_info *sbi, CLST nRec, 581 bool dir); 582 extern const u8 s_default_security[0x50]; 583 bool is_sd_valid(const struct SECURITY_DESCRIPTOR_RELATIVE *sd, u32 len); 584 int ntfs_security_init(struct ntfs_sb_info *sbi); 585 int ntfs_get_security_by_id(struct ntfs_sb_info *sbi, __le32 security_id, 586 struct SECURITY_DESCRIPTOR_RELATIVE **sd, 587 size_t *size); 588 int ntfs_insert_security(struct ntfs_sb_info *sbi, 589 const struct SECURITY_DESCRIPTOR_RELATIVE *sd, 590 u32 size, __le32 *security_id, bool *inserted); 591 int ntfs_reparse_init(struct ntfs_sb_info *sbi); 592 int ntfs_objid_init(struct ntfs_sb_info *sbi); 593 int ntfs_objid_remove(struct ntfs_sb_info *sbi, struct GUID *guid); 594 int ntfs_insert_reparse(struct ntfs_sb_info *sbi, __le32 rtag, 595 const struct MFT_REF *ref); 596 int ntfs_remove_reparse(struct ntfs_sb_info *sbi, __le32 rtag, 597 const struct MFT_REF *ref); 598 void mark_as_free_ex(struct ntfs_sb_info *sbi, CLST lcn, CLST len, bool trim); 599 int run_deallocate(struct ntfs_sb_info *sbi, struct runs_tree *run, bool trim); 600 601 /* globals from index.c */ 602 int indx_used_bit(struct ntfs_index *indx, struct ntfs_inode *ni, size_t *bit); 603 void fnd_clear(struct ntfs_fnd *fnd); 604 static inline struct ntfs_fnd *fnd_get(void) 605 { 606 return kzalloc(sizeof(struct ntfs_fnd), GFP_NOFS); 607 } 608 static inline void fnd_put(struct ntfs_fnd *fnd) 609 { 610 if (fnd) { 611 fnd_clear(fnd); 612 kfree(fnd); 613 } 614 } 615 void indx_clear(struct ntfs_index *idx); 616 int indx_init(struct ntfs_index *indx, struct ntfs_sb_info *sbi, 617 const struct ATTRIB *attr, enum index_mutex_classed type); 618 struct INDEX_ROOT *indx_get_root(struct ntfs_index *indx, struct ntfs_inode *ni, 619 struct ATTRIB **attr, struct mft_inode **mi); 620 int indx_read(struct ntfs_index *idx, struct ntfs_inode *ni, CLST vbn, 621 struct indx_node **node); 622 int 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); 626 int 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); 629 int 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); 632 int 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); 635 int indx_delete_entry(struct ntfs_index *indx, struct ntfs_inode *ni, 636 const void *key, u32 key_len, const void *param); 637 int 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 */ 642 struct inode *ntfs_iget5(struct super_block *sb, const struct MFT_REF *ref, 643 const struct cpu_str *name); 644 int ntfs_set_size(struct inode *inode, u64 new_size); 645 int reset_log_file(struct inode *inode); 646 int ntfs_get_block(struct inode *inode, sector_t vbn, 647 struct buffer_head *bh_result, int create); 648 int ntfs3_write_inode(struct inode *inode, struct writeback_control *wbc); 649 int ntfs_sync_inode(struct inode *inode); 650 int ntfs_flush_inodes(struct super_block *sb, struct inode *i1, 651 struct inode *i2); 652 int inode_write_data(struct inode *inode, const void *data, size_t bytes); 653 struct 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); 658 int ntfs_link_inode(struct inode *inode, struct dentry *dentry); 659 int ntfs_unlink_inode(struct inode *dir, const struct dentry *dentry); 660 void ntfs_evict_inode(struct inode *inode); 661 extern const struct inode_operations ntfs_link_inode_operations; 662 extern const struct address_space_operations ntfs_aops; 663 extern const struct address_space_operations ntfs_aops_cmpr; 664 665 /* globals from name_i.c*/ 666 int fill_name_de(struct ntfs_sb_info *sbi, void *buf, const struct qstr *name, 667 const struct cpu_str *uni); 668 struct dentry *ntfs3_get_parent(struct dentry *child); 669 670 extern const struct inode_operations ntfs_dir_inode_operations; 671 extern const struct inode_operations ntfs_special_inode_operations; 672 673 /* globals from record.c */ 674 int mi_get(struct ntfs_sb_info *sbi, CLST rno, struct mft_inode **mi); 675 void mi_put(struct mft_inode *mi); 676 int mi_init(struct mft_inode *mi, struct ntfs_sb_info *sbi, CLST rno); 677 int mi_read(struct mft_inode *mi, bool is_mft); 678 struct ATTRIB *mi_enum_attr(struct mft_inode *mi, struct ATTRIB *attr); 679 // TODO: id? 680 struct 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); 683 static 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 } 689 int mi_write(struct mft_inode *mi, int wait); 690 int mi_format_new(struct mft_inode *mi, struct ntfs_sb_info *sbi, CLST rno, 691 __le16 flags, bool is_mft); 692 void mi_mark_free(struct mft_inode *mi); 693 struct 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 697 bool mi_remove_attr(struct mft_inode *mi, struct ATTRIB *attr); 698 bool mi_resize_attr(struct mft_inode *mi, struct ATTRIB *attr, int bytes); 699 int mi_pack_runs(struct mft_inode *mi, struct ATTRIB *attr, 700 struct runs_tree *run, CLST len); 701 static 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 716 static 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 */ 728 bool run_lookup_entry(const struct runs_tree *run, CLST vcn, CLST *lcn, 729 CLST *len, size_t *index); 730 void run_truncate(struct runs_tree *run, CLST vcn); 731 void run_truncate_head(struct runs_tree *run, CLST vcn); 732 void run_truncate_around(struct runs_tree *run, CLST vcn); 733 bool run_lookup(const struct runs_tree *run, CLST vcn, size_t *Index); 734 bool run_add_entry(struct runs_tree *run, CLST vcn, CLST lcn, CLST len, 735 bool is_mft); 736 bool run_collapse_range(struct runs_tree *run, CLST vcn, CLST len); 737 bool run_get_entry(const struct runs_tree *run, size_t index, CLST *vcn, 738 CLST *lcn, CLST *len); 739 bool run_is_mapped_full(const struct runs_tree *run, CLST svcn, CLST evcn); 740 741 int run_pack(const struct runs_tree *run, CLST svcn, CLST len, u8 *run_buf, 742 u32 run_buf_size, CLST *packed_vcns); 743 int 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 748 int 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 754 int run_get_highest_vcn(CLST vcn, const u8 *run_buf, u64 *highest_vcn); 755 756 /* globals from super.c */ 757 void *ntfs_set_shared(void *ptr, u32 bytes); 758 void *ntfs_put_shared(void *ptr); 759 void ntfs_unmap_meta(struct super_block *sb, CLST lcn, CLST len); 760 int ntfs_discard(struct ntfs_sb_info *sbi, CLST Lcn, CLST Len); 761 762 /* globals from bitmap.c*/ 763 int __init ntfs3_init_bitmap(void); 764 void ntfs3_exit_bitmap(void); 765 void wnd_close(struct wnd_bitmap *wnd); 766 static inline size_t wnd_zeroes(const struct wnd_bitmap *wnd) 767 { 768 return wnd->total_zeroes; 769 } 770 int wnd_init(struct wnd_bitmap *wnd, struct super_block *sb, size_t nbits); 771 int wnd_set_free(struct wnd_bitmap *wnd, size_t bit, size_t bits); 772 int wnd_set_used(struct wnd_bitmap *wnd, size_t bit, size_t bits); 773 bool wnd_is_free(struct wnd_bitmap *wnd, size_t bit, size_t bits); 774 bool 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 779 size_t wnd_find(struct wnd_bitmap *wnd, size_t to_alloc, size_t hint, 780 size_t flags, size_t *allocated); 781 int wnd_extend(struct wnd_bitmap *wnd, size_t new_bits); 782 void wnd_zone_set(struct wnd_bitmap *wnd, size_t Lcn, size_t Len); 783 int ntfs_trim_fs(struct ntfs_sb_info *sbi, struct fstrim_range *range); 784 785 /* globals from upcase.c */ 786 int ntfs_cmp_names(const __le16 *s1, size_t l1, const __le16 *s2, size_t l2, 787 const u16 *upcase, bool bothcase); 788 int 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 793 struct posix_acl *ntfs_get_acl(struct inode *inode, int type); 794 int ntfs_set_acl(struct user_namespace *mnt_userns, struct inode *inode, 795 struct posix_acl *acl, int type); 796 int 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 803 int ntfs_acl_chmod(struct user_namespace *mnt_userns, struct inode *inode); 804 int ntfs_permission(struct user_namespace *mnt_userns, struct inode *inode, 805 int mask); 806 ssize_t ntfs_listxattr(struct dentry *dentry, char *buffer, size_t size); 807 extern const struct xattr_handler *ntfs_xattr_handlers[]; 808 809 int ntfs_save_wsl_perm(struct inode *inode); 810 void ntfs_get_wsl_perm(struct inode *inode); 811 812 /* globals from lznt.c */ 813 struct lznt *get_lznt_ctx(int level); 814 size_t compress_lznt(const void *uncompressed, size_t uncompressed_size, 815 void *compressed, size_t compressed_size, 816 struct lznt *ctx); 817 ssize_t decompress_lznt(const void *compressed, size_t compressed_size, 818 void *uncompressed, size_t uncompressed_size); 819 820 static 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)*/ 826 static inline bool is_mounted(struct ntfs_sb_info *sbi) 827 { 828 return !!sbi->sb->s_root; 829 } 830 831 static 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 838 static inline void ntfs_unmap_page(struct page *page) 839 { 840 kunmap(page); 841 put_page(page); 842 } 843 844 static 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 859 static inline size_t wnd_zone_bit(const struct wnd_bitmap *wnd) 860 { 861 return wnd->zone_bit; 862 } 863 864 static inline size_t wnd_zone_len(const struct wnd_bitmap *wnd) 865 { 866 return wnd->zone_end - wnd->zone_bit; 867 } 868 869 static inline void run_init(struct runs_tree *run) 870 { 871 run->runs = NULL; 872 run->count = 0; 873 run->allocated = 0; 874 } 875 876 static inline struct runs_tree *run_alloc(void) 877 { 878 return kzalloc(sizeof(struct runs_tree), GFP_NOFS); 879 } 880 881 static inline void run_close(struct runs_tree *run) 882 { 883 kvfree(run->runs); 884 memset(run, 0, sizeof(*run)); 885 } 886 887 static inline void run_free(struct runs_tree *run) 888 { 889 if (run) { 890 kvfree(run->runs); 891 kfree(run); 892 } 893 } 894 895 static inline bool run_is_empty(struct runs_tree *run) 896 { 897 return !run->count; 898 } 899 900 /* NTFS uses quad aligned bitmaps */ 901 static 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 913 * 914 * converts in-memory kernel timestamp into nt time 915 */ 916 static inline __le64 kernel2nt(const struct timespec64 *ts) 917 { 918 // 10^7 units of 100 nanoseconds one second 919 return cpu_to_le64(_100ns2seconds * 920 (ts->tv_sec + SecondsToStartOf1970) + 921 ts->tv_nsec / NTFS_TIME_GRAN); 922 } 923 924 /* 925 * nt2kernel 926 * 927 * converts on-disk nt time into kernel timestamp 928 */ 929 static inline void nt2kernel(const __le64 tm, struct timespec64 *ts) 930 { 931 u64 t = le64_to_cpu(tm) - _100ns2seconds * SecondsToStartOf1970; 932 933 // WARNING: do_div changes its first argument(!) 934 ts->tv_nsec = do_div(t, _100ns2seconds) * 100; 935 ts->tv_sec = t; 936 } 937 938 static inline struct ntfs_sb_info *ntfs_sb(struct super_block *sb) 939 { 940 return sb->s_fs_info; 941 } 942 943 /* Align up on cluster boundary */ 944 static inline u64 ntfs_up_cluster(const struct ntfs_sb_info *sbi, u64 size) 945 { 946 return (size + sbi->cluster_mask) & sbi->cluster_mask_inv; 947 } 948 949 /* Align up on cluster boundary */ 950 static 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 955 static 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 960 static 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 965 static 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 978 static inline struct ntfs_inode *ntfs_i(struct inode *inode) 979 { 980 return container_of(inode, struct ntfs_inode, vfs_inode); 981 } 982 983 static 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 989 static 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 */ 995 static 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 1000 static inline bool is_dedup(const struct ntfs_inode *ni) 1001 { 1002 return ni->ni_flags & NI_FLAG_DEDUPLICATED; 1003 } 1004 1005 static inline bool is_encrypted(const struct ntfs_inode *ni) 1006 { 1007 return ni->std_fa & FILE_ATTRIBUTE_ENCRYPTED; 1008 } 1009 1010 static inline bool is_sparsed(const struct ntfs_inode *ni) 1011 { 1012 return ni->std_fa & FILE_ATTRIBUTE_SPARSE_FILE; 1013 } 1014 1015 static inline int is_resident(struct ntfs_inode *ni) 1016 { 1017 return ni->ni_flags & NI_FLAG_RESIDENT; 1018 } 1019 1020 static inline void le16_sub_cpu(__le16 *var, u16 val) 1021 { 1022 *var = cpu_to_le16(le16_to_cpu(*var) - val); 1023 } 1024 1025 static inline void le32_sub_cpu(__le32 *var, u32 val) 1026 { 1027 *var = cpu_to_le32(le32_to_cpu(*var) - val); 1028 } 1029 1030 static 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 1042 static 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 1052 static inline void mi_clear(struct mft_inode *mi) 1053 { 1054 nb_put(&mi->nb); 1055 kfree(mi->mrec); 1056 mi->mrec = NULL; 1057 } 1058 1059 static inline void ni_lock(struct ntfs_inode *ni) 1060 { 1061 mutex_lock_nested(&ni->ni_lock, NTFS_INODE_MUTEX_NORMAL); 1062 } 1063 1064 static inline void ni_lock_dir(struct ntfs_inode *ni) 1065 { 1066 mutex_lock_nested(&ni->ni_lock, NTFS_INODE_MUTEX_PARENT); 1067 } 1068 1069 static inline void ni_unlock(struct ntfs_inode *ni) 1070 { 1071 mutex_unlock(&ni->ni_lock); 1072 } 1073 1074 static inline int ni_trylock(struct ntfs_inode *ni) 1075 { 1076 return mutex_trylock(&ni->ni_lock); 1077 } 1078 1079 static 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 1087 static 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