1 /* 2 exfat.h (29.08.09) 3 Definitions of structures and constants used in exFAT file system 4 implementation. 5 6 Free exFAT implementation. 7 Copyright (C) 2010-2023 Andrew Nayenko 8 9 This program is free software; you can redistribute it and/or modify 10 it under the terms of the GNU General Public License as published by 11 the Free Software Foundation, either version 2 of the License, or 12 (at your option) any later version. 13 14 This program is distributed in the hope that it will be useful, 15 but WITHOUT ANY WARRANTY; without even the implied warranty of 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 GNU General Public License for more details. 18 19 You should have received a copy of the GNU General Public License along 20 with this program; if not, write to the Free Software Foundation, Inc., 21 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. 22 */ 23 24 #ifndef EXFAT_H_INCLUDED 25 #define EXFAT_H_INCLUDED 26 27 #ifndef ANDROID 28 /* Android.bp is used instead of autotools when targeting Android */ 29 #include "config.h" 30 #endif 31 #include "compiler.h" 32 #include "exfatfs.h" 33 #include <stdio.h> 34 #include <stdlib.h> 35 #include <time.h> 36 #include <stdbool.h> 37 #ifndef __UBOOT__ 38 #include <sys/stat.h> 39 #include <sys/types.h> 40 #endif 41 42 #define EXFAT_NAME_MAX 255 43 /* UTF-16 encodes code points up to U+FFFF as single 16-bit code units. 44 UTF-8 uses up to 3 bytes (i.e. 8-bit code units) to encode code points 45 up to U+FFFF. One additional character is for null terminator. */ 46 #define EXFAT_UTF8_NAME_BUFFER_MAX (EXFAT_NAME_MAX * 3 + 1) 47 #define EXFAT_UTF8_ENAME_BUFFER_MAX (EXFAT_ENAME_MAX * 3 + 1) 48 49 #define SECTOR_SIZE(sb) (1 << (sb).sector_bits) 50 #define CLUSTER_SIZE(sb) (SECTOR_SIZE(sb) << (sb).spc_bits) 51 #define CLUSTER_INVALID(sb, c) ((c) < EXFAT_FIRST_DATA_CLUSTER || \ 52 (c) - EXFAT_FIRST_DATA_CLUSTER >= le32_to_cpu((sb).cluster_count)) 53 54 #define MIN(a, b) ((a) < (b) ? (a) : (b)) 55 #define MAX(a, b) ((a) > (b) ? (a) : (b)) 56 #ifndef __UBOOT__ 57 #define DIV_ROUND_UP(x, d) (((x) + (d) - 1) / (d)) 58 #endif 59 #define ROUND_UP(x, d) (DIV_ROUND_UP(x, d) * (d)) 60 61 #define BMAP_SIZE(count) (ROUND_UP(count, sizeof(bitmap_t) * 8) / 8) 62 #define BMAP_BLOCK(index) ((index) / sizeof(bitmap_t) / 8) 63 #define BMAP_MASK(index) ((bitmap_t) 1 << ((index) % (sizeof(bitmap_t) * 8))) 64 #define BMAP_GET(bitmap, index) \ 65 ((bitmap)[BMAP_BLOCK(index)] & BMAP_MASK(index)) 66 #define BMAP_SET(bitmap, index) \ 67 ((bitmap)[BMAP_BLOCK(index)] |= BMAP_MASK(index)) 68 #define BMAP_CLR(bitmap, index) \ 69 ((bitmap)[BMAP_BLOCK(index)] &= ~BMAP_MASK(index)) 70 71 #define EXFAT_REPAIR(hook, ef, ...) \ 72 (exfat_ask_to_fix(ef) && exfat_fix_ ## hook(ef, __VA_ARGS__)) 73 74 /* The size of off_t type must be 64 bits. File systems larger than 2 GB will 75 be corrupted with 32-bit off_t. */ 76 STATIC_ASSERT(sizeof(off_t) == 8); 77 78 struct exfat_node 79 { 80 struct exfat_node* parent; 81 struct exfat_node* child; 82 struct exfat_node* next; 83 struct exfat_node* prev; 84 85 int references; 86 uint32_t fptr_index; 87 cluster_t fptr_cluster; 88 off_t entry_offset; 89 cluster_t start_cluster; 90 uint16_t attrib; 91 uint8_t continuations; 92 bool is_contiguous : 1; 93 bool is_cached : 1; 94 bool is_dirty : 1; 95 bool is_unlinked : 1; 96 uint64_t valid_size; 97 uint64_t size; 98 time_t mtime, atime; 99 le16_t name[EXFAT_NAME_MAX + 1]; 100 }; 101 102 enum exfat_mode 103 { 104 EXFAT_MODE_RO, 105 EXFAT_MODE_RW, 106 EXFAT_MODE_ANY, 107 }; 108 109 struct exfat_dev; 110 111 struct exfat 112 { 113 struct exfat_dev* dev; 114 struct exfat_super_block* sb; 115 uint16_t* upcase; 116 struct exfat_node* root; 117 struct 118 { 119 cluster_t start_cluster; 120 uint32_t size; /* in bits */ 121 bitmap_t* chunk; 122 uint32_t chunk_size; /* in bits */ 123 bool dirty; 124 } 125 cmap; 126 char label[EXFAT_UTF8_ENAME_BUFFER_MAX]; 127 void* zero_cluster; 128 int dmask, fmask; 129 uid_t uid; 130 gid_t gid; 131 int ro; 132 bool noatime; 133 enum { EXFAT_REPAIR_NO, EXFAT_REPAIR_ASK, EXFAT_REPAIR_YES } repair; 134 }; 135 136 /* in-core nodes iterator */ 137 struct exfat_iterator 138 { 139 struct exfat_node* parent; 140 struct exfat_node* current; 141 }; 142 143 struct exfat_human_bytes 144 { 145 uint64_t value; 146 const char* unit; 147 }; 148 149 extern int exfat_errors; 150 extern int exfat_errors_fixed; 151 152 #ifdef __UBOOT__ 153 #define exfat_bug(fmt, args...) log_crit(fmt, ##args) 154 #define exfat_error(fmt, args...) log_err(fmt, ##args) 155 #define exfat_warn(fmt, args...) log_warning(fmt, ##args) 156 #define exfat_debug(fmt, args...) log_debug(fmt, ##args) 157 #else 158 void exfat_bug(const char* format, ...) PRINTF NORETURN; 159 void exfat_error(const char* format, ...) PRINTF; 160 void exfat_warn(const char* format, ...) PRINTF; 161 void exfat_debug(const char* format, ...) PRINTF; 162 #endif 163 164 struct exfat_dev* exfat_open(const char* spec, enum exfat_mode mode); 165 int exfat_close(struct exfat_dev* dev); 166 int exfat_fsync(struct exfat_dev* dev); 167 enum exfat_mode exfat_get_mode(const struct exfat_dev* dev); 168 off_t exfat_get_size(const struct exfat_dev* dev); 169 off_t exfat_seek(struct exfat_dev* dev, off_t offset, int whence); 170 ssize_t exfat_read(struct exfat_dev* dev, void* buffer, size_t size); 171 ssize_t exfat_write(struct exfat_dev* dev, const void* buffer, size_t size); 172 ssize_t exfat_pread(struct exfat_dev* dev, void* buffer, size_t size, 173 off_t offset); 174 ssize_t exfat_pwrite(struct exfat_dev* dev, const void* buffer, size_t size, 175 off_t offset); 176 ssize_t exfat_generic_pread(const struct exfat* ef, struct exfat_node* node, 177 void* buffer, size_t size, off_t offset); 178 ssize_t exfat_generic_pwrite(struct exfat* ef, struct exfat_node* node, 179 const void* buffer, size_t size, off_t offset); 180 181 int exfat_opendir(struct exfat* ef, struct exfat_node* dir, 182 struct exfat_iterator* it); 183 void exfat_closedir(struct exfat* ef, struct exfat_iterator* it); 184 struct exfat_node* exfat_readdir(struct exfat_iterator* it); 185 int exfat_lookup(struct exfat* ef, struct exfat_node** node, 186 const char* path); 187 int exfat_split(struct exfat* ef, struct exfat_node** parent, 188 struct exfat_node** node, le16_t* name, const char* path); 189 190 off_t exfat_c2o(const struct exfat* ef, cluster_t cluster); 191 cluster_t exfat_next_cluster(const struct exfat* ef, 192 const struct exfat_node* node, cluster_t cluster); 193 cluster_t exfat_advance_cluster(const struct exfat* ef, 194 struct exfat_node* node, uint32_t count); 195 int exfat_flush_nodes(struct exfat* ef); 196 int exfat_flush(struct exfat* ef); 197 int exfat_truncate(struct exfat* ef, struct exfat_node* node, uint64_t size, 198 bool erase); 199 uint32_t exfat_count_free_clusters(const struct exfat* ef); 200 int exfat_find_used_sectors(const struct exfat* ef, off_t* a, off_t* b); 201 202 void exfat_stat(const struct exfat* ef, const struct exfat_node* node, 203 struct stat* stbuf); 204 void exfat_get_name(const struct exfat_node* node, 205 char buffer[EXFAT_UTF8_NAME_BUFFER_MAX]); 206 uint16_t exfat_start_checksum(const struct exfat_entry_meta1* entry); 207 uint16_t exfat_add_checksum(const void* entry, uint16_t sum); 208 le16_t exfat_calc_checksum(const struct exfat_entry* entries, int n); 209 uint32_t exfat_vbr_start_checksum(const void* sector, size_t size); 210 uint32_t exfat_vbr_add_checksum(const void* sector, size_t size, uint32_t sum); 211 le16_t exfat_calc_name_hash(const struct exfat* ef, const le16_t* name, 212 size_t length); 213 #ifndef __UBOOT__ 214 void exfat_humanize_bytes(uint64_t value, struct exfat_human_bytes* hb); 215 void exfat_print_info(const struct exfat_super_block* sb, 216 uint32_t free_clusters); 217 #endif 218 bool exfat_match_option(const char* options, const char* option_name); 219 220 int exfat_utf16_to_utf8(char* output, const le16_t* input, size_t outsize, 221 size_t insize); 222 int exfat_utf8_to_utf16(le16_t* output, const char* input, size_t outsize, 223 size_t insize); 224 size_t exfat_utf16_length(const le16_t* str); 225 226 struct exfat_node* exfat_get_node(struct exfat_node* node); 227 void exfat_put_node(struct exfat* ef, struct exfat_node* node); 228 int exfat_cleanup_node(struct exfat* ef, struct exfat_node* node); 229 int exfat_cache_directory(struct exfat* ef, struct exfat_node* dir); 230 void exfat_reset_cache(struct exfat* ef); 231 int exfat_flush_node(struct exfat* ef, struct exfat_node* node); 232 int exfat_unlink(struct exfat* ef, struct exfat_node* node); 233 int exfat_rmdir(struct exfat* ef, struct exfat_node* node); 234 int exfat_mknod(struct exfat* ef, const char* path); 235 int exfat_mkdir(struct exfat* ef, const char* path); 236 int exfat_rename(struct exfat* ef, const char* old_path, const char* new_path); 237 void exfat_utimes(struct exfat_node* node, const struct timespec tv[2]); 238 void exfat_update_atime(struct exfat_node* node); 239 void exfat_update_mtime(struct exfat_node* node); 240 #ifndef __UBOOT__ 241 const char* exfat_get_label(struct exfat* ef); 242 int exfat_set_label(struct exfat* ef, const char* label); 243 #endif /* __UBOOT__ */ 244 245 int exfat_soil_super_block(const struct exfat* ef); 246 int exfat_mount(struct exfat* ef, const char* spec, const char* options); 247 void exfat_unmount(struct exfat* ef); 248 249 time_t exfat_exfat2unix(le16_t date, le16_t time, uint8_t centisec, 250 uint8_t tzoffset); 251 void exfat_unix2exfat(time_t unix_time, le16_t* date, le16_t* time, 252 uint8_t* centisec, uint8_t* tzoffset); 253 void exfat_tzset(void); 254 255 bool exfat_ask_to_fix(const struct exfat* ef); 256 bool exfat_fix_invalid_vbr_checksum(const struct exfat* ef, void* sector, 257 uint32_t vbr_checksum); 258 bool exfat_fix_invalid_node_checksum(const struct exfat* ef, 259 struct exfat_node* node); 260 bool exfat_fix_unknown_entry(struct exfat* ef, struct exfat_node* dir, 261 const struct exfat_entry* entry, off_t offset); 262 263 #endif /* ifndef EXFAT_H_INCLUDED */ 264