1 /* SPDX-License-Identifier: GPL-2.0-or-later */ 2 /* 3 * Defines for NTFS Linux kernel driver. 4 * 5 * Copyright (c) 2001-2014 Anton Altaparmakov and Tuxera Inc. 6 * Copyright (C) 2002 Richard Russon 7 * Copyright (c) 2025 LG Electronics Co., Ltd. 8 */ 9 10 #ifndef _LINUX_NTFS_H 11 #define _LINUX_NTFS_H 12 13 #include <linux/stddef.h> 14 #include <linux/kernel.h> 15 #include <linux/hex.h> 16 #include <linux/module.h> 17 #include <linux/compiler.h> 18 #include <linux/fs.h> 19 #include <linux/nls.h> 20 #include <linux/smp.h> 21 #include <linux/pagemap.h> 22 #include <linux/blk_types.h> 23 #include <linux/uidgid.h> 24 25 #include "volume.h" 26 #include "layout.h" 27 #include "inode.h" 28 29 #ifdef pr_fmt 30 #undef pr_fmt 31 #endif 32 33 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 34 35 /* 36 * Default pre-allocation size is optimize runlist merge overhead 37 * with small chunk size. 38 */ 39 #define NTFS_DEF_PREALLOC_SIZE 65536 40 41 /* 42 * The log2 of the standard number of clusters per compression block. 43 * A value of 4 corresponds to 16 clusters (1 << 4), which is the 44 * default chunk size used by NTFS LZNT1 compression. 45 */ 46 #define STANDARD_COMPRESSION_UNIT 4 47 48 /* 49 * The maximum cluster size (4KB) allowed for compression to be enabled. 50 * By design, NTFS does not support compression on volumes where the 51 * cluster size exceeds 4096 bytes. 52 */ 53 #define MAX_COMPRESSION_CLUSTER_SIZE 4096 54 55 #define NTFS_B_TO_CLU(vol, b) ((b) >> (vol)->cluster_size_bits) 56 #define NTFS_CLU_TO_B(vol, clu) ((u64)(clu) << (vol)->cluster_size_bits) 57 #define NTFS_B_TO_CLU_OFS(vol, clu) ((u64)(clu) & (vol)->cluster_size_mask) 58 59 #define NTFS_MFT_NR_TO_CLU(vol, mft_no) (((u64)mft_no << (vol)->mft_record_size_bits) >> \ 60 (vol)->cluster_size_bits) 61 #define NTFS_MFT_NR_TO_PIDX(vol, mft_no) (mft_no >> (PAGE_SHIFT - \ 62 (vol)->mft_record_size_bits)) 63 #define NTFS_MFT_NR_TO_POFS(vol, mft_no) (((u64)mft_no << (vol)->mft_record_size_bits) & \ 64 ~PAGE_MASK) 65 66 #define NTFS_PIDX_TO_BLK(vol, idx) (((u64)idx << PAGE_SHIFT) >> \ 67 ((vol)->sb)->s_blocksize_bits) 68 #define NTFS_PIDX_TO_CLU(vol, idx) (((u64)idx << PAGE_SHIFT) >> \ 69 (vol)->cluster_size_bits) 70 #define NTFS_CLU_TO_PIDX(vol, clu) (((u64)(clu) << (vol)->cluster_size_bits) >> \ 71 PAGE_SHIFT) 72 #define NTFS_CLU_TO_POFS(vol, clu) (((u64)(clu) << (vol)->cluster_size_bits) & \ 73 ~PAGE_MASK) 74 75 enum { 76 NTFS_BLOCK_SIZE = 512, 77 NTFS_BLOCK_SIZE_BITS = 9, 78 NTFS_SB_MAGIC = 0x5346544e, /* 'NTFS' */ 79 NTFS_MAX_NAME_LEN = 255, 80 NTFS_MAX_LABEL_LEN = 128, 81 }; 82 83 enum { 84 CASE_SENSITIVE = 0, 85 IGNORE_CASE = 1, 86 }; 87 88 /* 89 * Conversion helpers for NTFS units. 90 */ 91 92 /* Convert bytes to cluster count */ 93 static inline u64 ntfs_bytes_to_cluster(const struct ntfs_volume *vol, 94 s64 bytes) 95 { 96 return bytes >> vol->cluster_size_bits; 97 } 98 99 /* Convert cluster count to bytes */ 100 static inline u64 ntfs_cluster_to_bytes(const struct ntfs_volume *vol, 101 u64 clusters) 102 { 103 return clusters << vol->cluster_size_bits; 104 } 105 106 /* Get the byte offset within a cluster from a linear byte address */ 107 static inline u64 ntfs_bytes_to_cluster_off(const struct ntfs_volume *vol, 108 u64 bytes) 109 { 110 return bytes & vol->cluster_size_mask; 111 } 112 113 /* Calculate the physical cluster number containing a specific MFT record. */ 114 static inline u64 ntfs_mft_no_to_cluster(const struct ntfs_volume *vol, 115 unsigned long mft_no) 116 { 117 return ((u64)mft_no << vol->mft_record_size_bits) >> 118 vol->cluster_size_bits; 119 } 120 121 /* Calculate the folio index where the MFT record resides. */ 122 static inline pgoff_t ntfs_mft_no_to_pidx(const struct ntfs_volume *vol, 123 unsigned long mft_no) 124 { 125 return mft_no >> (PAGE_SHIFT - vol->mft_record_size_bits); 126 } 127 128 /* Calculate the byte offset within a folio for an MFT record. */ 129 static inline u64 ntfs_mft_no_to_poff(const struct ntfs_volume *vol, 130 unsigned long mft_no) 131 { 132 return ((u64)mft_no << vol->mft_record_size_bits) & ~PAGE_MASK; 133 } 134 135 /* Convert folio index to cluster number. */ 136 static inline u64 ntfs_pidx_to_cluster(const struct ntfs_volume *vol, 137 pgoff_t idx) 138 { 139 return ((u64)idx << PAGE_SHIFT) >> vol->cluster_size_bits; 140 } 141 142 /* Convert cluster number to folio index. */ 143 static inline pgoff_t ntfs_cluster_to_pidx(const struct ntfs_volume *vol, 144 u64 clu) 145 { 146 return (clu << vol->cluster_size_bits) >> PAGE_SHIFT; 147 } 148 149 /* Get the byte offset within a folio from a cluster number */ 150 static inline u64 ntfs_cluster_to_poff(const struct ntfs_volume *vol, 151 u64 clu) 152 { 153 return (clu << vol->cluster_size_bits) & ~PAGE_MASK; 154 } 155 156 /* Convert a byte offset on the volume to a bio sector number. */ 157 static inline sector_t ntfs_bytes_to_bio_sector(u64 bytes) 158 { 159 return bytes >> SECTOR_SHIFT; 160 } 161 162 /* Global variables. */ 163 164 /* Slab caches (from super.c). */ 165 extern struct kmem_cache *ntfs_name_cache; 166 extern struct kmem_cache *ntfs_inode_cache; 167 extern struct kmem_cache *ntfs_big_inode_cache; 168 extern struct kmem_cache *ntfs_attr_ctx_cache; 169 extern struct kmem_cache *ntfs_index_ctx_cache; 170 171 /* The various operations structs defined throughout the driver files. */ 172 extern const struct address_space_operations ntfs_aops; 173 extern const struct address_space_operations ntfs_mft_aops; 174 175 extern const struct file_operations ntfs_file_ops; 176 extern const struct inode_operations ntfs_file_inode_ops; 177 extern const struct inode_operations ntfs_symlink_inode_operations; 178 extern const struct inode_operations ntfs_special_inode_operations; 179 180 extern const struct file_operations ntfs_dir_ops; 181 extern const struct inode_operations ntfs_dir_inode_ops; 182 183 extern const struct file_operations ntfs_empty_file_ops; 184 extern const struct inode_operations ntfs_empty_inode_ops; 185 186 extern const struct export_operations ntfs_export_ops; 187 188 /* 189 * NTFS_SB - return the ntfs volume given a vfs super block 190 * @sb: VFS super block 191 * 192 * NTFS_SB() returns the ntfs volume associated with the VFS super block @sb. 193 */ 194 static inline struct ntfs_volume *NTFS_SB(struct super_block *sb) 195 { 196 return sb->s_fs_info; 197 } 198 199 /* Declarations of functions and global variables. */ 200 201 /* From fs/ntfs/compress.c */ 202 int ntfs_read_compressed_block(struct folio *folio); 203 #ifdef CONFIG_NTFS_FS_WOF_COMPRESSION 204 int ntfs_read_wof_compressed_block(struct folio *folio); 205 void ntfs_wof_free_workspaces(void); 206 #endif 207 int allocate_compression_buffers(void); 208 void free_compression_buffers(void); 209 int ntfs_compress_write(struct ntfs_inode *ni, loff_t pos, size_t count, 210 struct iov_iter *from); 211 212 /* From fs/ntfs/super.c */ 213 #define default_upcase_len 0x10000 214 extern struct mutex ntfs_lock; 215 216 struct option_t { 217 int val; 218 char *str; 219 }; 220 extern const struct option_t on_errors_arr[]; 221 int ntfs_set_volume_flags(struct ntfs_volume *vol, __le16 flags); 222 int ntfs_clear_volume_flags(struct ntfs_volume *vol, __le16 flags); 223 int ntfs_write_volume_label(struct ntfs_volume *vol, char *label); 224 225 /* From fs/ntfs/mst.c */ 226 int post_read_mst_fixup(struct ntfs_record *b, const u32 size); 227 int pre_write_mst_fixup(struct ntfs_record *b, const u32 size); 228 void post_write_mst_fixup(struct ntfs_record *b); 229 230 /* From fs/ntfs/unistr.c */ 231 bool ntfs_are_names_equal(const __le16 *s1, size_t s1_len, 232 const __le16 *s2, size_t s2_len, 233 const u32 ic, 234 const __le16 *upcase, const u32 upcase_size); 235 int ntfs_collate_names(const __le16 *name1, const u32 name1_len, 236 const __le16 *name2, const u32 name2_len, 237 const int err_val, const u32 ic, 238 const __le16 *upcase, const u32 upcase_len); 239 int ntfs_ucsncmp(const __le16 *s1, const __le16 *s2, size_t n); 240 int ntfs_ucsncasecmp(const __le16 *s1, const __le16 *s2, size_t n, 241 const __le16 *upcase, const u32 upcase_size); 242 int ntfs_file_compare_values(const struct file_name_attr *file_name_attr1, 243 const struct file_name_attr *file_name_attr2, 244 const int err_val, const u32 ic, 245 const __le16 *upcase, const u32 upcase_len); 246 int ntfs_nlstoucs(const struct ntfs_volume *vol, const char *ins, 247 const int ins_len, __le16 **outs, int max_name_len); 248 int ntfs_ucstonls(const struct ntfs_volume *vol, const __le16 *ins, 249 const int ins_len, unsigned char **outs, int outs_len); 250 __le16 *ntfs_ucsndup(const __le16 *s, u32 maxlen); 251 bool ntfs_names_are_equal(const __le16 *s1, size_t s1_len, 252 const __le16 *s2, size_t s2_len, 253 const u32 ic, 254 const __le16 *upcase, const u32 upcase_size); 255 int ntfs_force_shutdown(struct super_block *sb, u32 flags); 256 long ntfs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg); 257 #ifdef CONFIG_COMPAT 258 long ntfs_compat_ioctl(struct file *filp, unsigned int cmd, 259 unsigned long arg); 260 #endif 261 262 /* From fs/ntfs/upcase.c */ 263 __le16 *generate_default_upcase(void); 264 265 static inline int ntfs_ffs(int x) 266 { 267 int r = 1; 268 269 if (!x) 270 return 0; 271 if (!(x & 0xffff)) { 272 x >>= 16; 273 r += 16; 274 } 275 if (!(x & 0xff)) { 276 x >>= 8; 277 r += 8; 278 } 279 if (!(x & 0xf)) { 280 x >>= 4; 281 r += 4; 282 } 283 if (!(x & 3)) { 284 x >>= 2; 285 r += 2; 286 } 287 if (!(x & 1)) 288 r += 1; 289 return r; 290 } 291 292 /* From fs/ntfs/bdev-io.c */ 293 int ntfs_bdev_read(struct block_device *bdev, char *data, loff_t start, size_t size); 294 int ntfs_bdev_write(struct super_block *sb, void *buf, loff_t start, size_t size); 295 296 #endif /* _LINUX_NTFS_H */ 297