1 /* SPDX-License-Identifier: GPL-2.0 */ 2 /* 3 * Copyright (C) 2007 Oracle. All rights reserved. 4 */ 5 6 #ifndef BTRFS_INODE_H 7 #define BTRFS_INODE_H 8 9 #include <linux/hash.h> 10 #include <linux/refcount.h> 11 #include "extent_map.h" 12 #include "extent_io.h" 13 #include "ordered-data.h" 14 #include "delayed-inode.h" 15 16 /* 17 * Since we search a directory based on f_pos (struct dir_context::pos) we have 18 * to start at 2 since '.' and '..' have f_pos of 0 and 1 respectively, so 19 * everybody else has to start at 2 (see btrfs_real_readdir() and dir_emit_dots()). 20 */ 21 #define BTRFS_DIR_START_INDEX 2 22 23 /* 24 * ordered_data_close is set by truncate when a file that used 25 * to have good data has been truncated to zero. When it is set 26 * the btrfs file release call will add this inode to the 27 * ordered operations list so that we make sure to flush out any 28 * new data the application may have written before commit. 29 */ 30 enum { 31 BTRFS_INODE_FLUSH_ON_CLOSE, 32 BTRFS_INODE_DUMMY, 33 BTRFS_INODE_IN_DEFRAG, 34 BTRFS_INODE_HAS_ASYNC_EXTENT, 35 /* 36 * Always set under the VFS' inode lock, otherwise it can cause races 37 * during fsync (we start as a fast fsync and then end up in a full 38 * fsync racing with ordered extent completion). 39 */ 40 BTRFS_INODE_NEEDS_FULL_SYNC, 41 BTRFS_INODE_COPY_EVERYTHING, 42 BTRFS_INODE_IN_DELALLOC_LIST, 43 BTRFS_INODE_HAS_PROPS, 44 BTRFS_INODE_SNAPSHOT_FLUSH, 45 /* 46 * Set and used when logging an inode and it serves to signal that an 47 * inode does not have xattrs, so subsequent fsyncs can avoid searching 48 * for xattrs to log. This bit must be cleared whenever a xattr is added 49 * to an inode. 50 */ 51 BTRFS_INODE_NO_XATTRS, 52 /* 53 * Set when we are in a context where we need to start a transaction and 54 * have dirty pages with the respective file range locked. This is to 55 * ensure that when reserving space for the transaction, if we are low 56 * on available space and need to flush delalloc, we will not flush 57 * delalloc for this inode, because that could result in a deadlock (on 58 * the file range, inode's io_tree). 59 */ 60 BTRFS_INODE_NO_DELALLOC_FLUSH, 61 /* 62 * Set when we are working on enabling verity for a file. Computing and 63 * writing the whole Merkle tree can take a while so we want to prevent 64 * races where two separate tasks attempt to simultaneously start verity 65 * on the same file. 66 */ 67 BTRFS_INODE_VERITY_IN_PROGRESS, 68 }; 69 70 /* in memory btrfs inode */ 71 struct btrfs_inode { 72 /* which subvolume this inode belongs to */ 73 struct btrfs_root *root; 74 75 /* key used to find this inode on disk. This is used by the code 76 * to read in roots of subvolumes 77 */ 78 struct btrfs_key location; 79 80 /* 81 * Lock for counters and all fields used to determine if the inode is in 82 * the log or not (last_trans, last_sub_trans, last_log_commit, 83 * logged_trans), to access/update new_delalloc_bytes and to update the 84 * VFS' inode number of bytes used. 85 */ 86 spinlock_t lock; 87 88 /* the extent_tree has caches of all the extent mappings to disk */ 89 struct extent_map_tree extent_tree; 90 91 /* the io_tree does range state (DIRTY, LOCKED etc) */ 92 struct extent_io_tree io_tree; 93 94 /* special utility tree used to record which mirrors have already been 95 * tried when checksums fail for a given block 96 */ 97 struct extent_io_tree io_failure_tree; 98 99 /* 100 * Keep track of where the inode has extent items mapped in order to 101 * make sure the i_size adjustments are accurate 102 */ 103 struct extent_io_tree file_extent_tree; 104 105 /* held while logging the inode in tree-log.c */ 106 struct mutex log_mutex; 107 108 /* used to order data wrt metadata */ 109 struct btrfs_ordered_inode_tree ordered_tree; 110 111 /* list of all the delalloc inodes in the FS. There are times we need 112 * to write all the delalloc pages to disk, and this list is used 113 * to walk them all. 114 */ 115 struct list_head delalloc_inodes; 116 117 /* node for the red-black tree that links inodes in subvolume root */ 118 struct rb_node rb_node; 119 120 unsigned long runtime_flags; 121 122 /* Keep track of who's O_SYNC/fsyncing currently */ 123 atomic_t sync_writers; 124 125 /* full 64 bit generation number, struct vfs_inode doesn't have a big 126 * enough field for this. 127 */ 128 u64 generation; 129 130 /* 131 * transid of the trans_handle that last modified this inode 132 */ 133 u64 last_trans; 134 135 /* 136 * transid that last logged this inode 137 */ 138 u64 logged_trans; 139 140 /* 141 * log transid when this inode was last modified 142 */ 143 int last_sub_trans; 144 145 /* a local copy of root's last_log_commit */ 146 int last_log_commit; 147 148 /* total number of bytes pending delalloc, used by stat to calc the 149 * real block usage of the file 150 */ 151 u64 delalloc_bytes; 152 153 /* 154 * Total number of bytes pending delalloc that fall within a file 155 * range that is either a hole or beyond EOF (and no prealloc extent 156 * exists in the range). This is always <= delalloc_bytes. 157 */ 158 u64 new_delalloc_bytes; 159 160 /* 161 * total number of bytes pending defrag, used by stat to check whether 162 * it needs COW. 163 */ 164 u64 defrag_bytes; 165 166 /* 167 * the size of the file stored in the metadata on disk. data=ordered 168 * means the in-memory i_size might be larger than the size on disk 169 * because not all the blocks are written yet. 170 */ 171 u64 disk_i_size; 172 173 /* 174 * If this is a directory then index_cnt is the counter for the index 175 * number for new files that are created. For an empty directory, this 176 * must be initialized to BTRFS_DIR_START_INDEX. 177 */ 178 u64 index_cnt; 179 180 /* Cache the directory index number to speed the dir/file remove */ 181 u64 dir_index; 182 183 /* the fsync log has some corner cases that mean we have to check 184 * directories to see if any unlinks have been done before 185 * the directory was logged. See tree-log.c for all the 186 * details 187 */ 188 u64 last_unlink_trans; 189 190 /* 191 * The id/generation of the last transaction where this inode was 192 * either the source or the destination of a clone/dedupe operation. 193 * Used when logging an inode to know if there are shared extents that 194 * need special care when logging checksum items, to avoid duplicate 195 * checksum items in a log (which can lead to a corruption where we end 196 * up with missing checksum ranges after log replay). 197 * Protected by the vfs inode lock. 198 */ 199 u64 last_reflink_trans; 200 201 /* 202 * Number of bytes outstanding that are going to need csums. This is 203 * used in ENOSPC accounting. 204 */ 205 u64 csum_bytes; 206 207 /* Backwards incompatible flags, lower half of inode_item::flags */ 208 u32 flags; 209 /* Read-only compatibility flags, upper half of inode_item::flags */ 210 u32 ro_flags; 211 212 /* 213 * Counters to keep track of the number of extent item's we may use due 214 * to delalloc and such. outstanding_extents is the number of extent 215 * items we think we'll end up using, and reserved_extents is the number 216 * of extent items we've reserved metadata for. 217 */ 218 unsigned outstanding_extents; 219 220 struct btrfs_block_rsv block_rsv; 221 222 /* 223 * Cached values of inode properties 224 */ 225 unsigned prop_compress; /* per-file compression algorithm */ 226 /* 227 * Force compression on the file using the defrag ioctl, could be 228 * different from prop_compress and takes precedence if set 229 */ 230 unsigned defrag_compress; 231 232 struct btrfs_delayed_node *delayed_node; 233 234 /* File creation time. */ 235 struct timespec64 i_otime; 236 237 /* Hook into fs_info->delayed_iputs */ 238 struct list_head delayed_iput; 239 240 struct rw_semaphore i_mmap_lock; 241 struct inode vfs_inode; 242 }; 243 244 static inline u32 btrfs_inode_sectorsize(const struct btrfs_inode *inode) 245 { 246 return inode->root->fs_info->sectorsize; 247 } 248 249 static inline struct btrfs_inode *BTRFS_I(const struct inode *inode) 250 { 251 return container_of(inode, struct btrfs_inode, vfs_inode); 252 } 253 254 static inline unsigned long btrfs_inode_hash(u64 objectid, 255 const struct btrfs_root *root) 256 { 257 u64 h = objectid ^ (root->root_key.objectid * GOLDEN_RATIO_PRIME); 258 259 #if BITS_PER_LONG == 32 260 h = (h >> 32) ^ (h & 0xffffffff); 261 #endif 262 263 return (unsigned long)h; 264 } 265 266 static inline void btrfs_insert_inode_hash(struct inode *inode) 267 { 268 unsigned long h = btrfs_inode_hash(inode->i_ino, BTRFS_I(inode)->root); 269 270 __insert_inode_hash(inode, h); 271 } 272 273 static inline u64 btrfs_ino(const struct btrfs_inode *inode) 274 { 275 u64 ino = inode->location.objectid; 276 277 /* 278 * !ino: btree_inode 279 * type == BTRFS_ROOT_ITEM_KEY: subvol dir 280 */ 281 if (!ino || inode->location.type == BTRFS_ROOT_ITEM_KEY) 282 ino = inode->vfs_inode.i_ino; 283 return ino; 284 } 285 286 static inline void btrfs_i_size_write(struct btrfs_inode *inode, u64 size) 287 { 288 i_size_write(&inode->vfs_inode, size); 289 inode->disk_i_size = size; 290 } 291 292 static inline bool btrfs_is_free_space_inode(struct btrfs_inode *inode) 293 { 294 struct btrfs_root *root = inode->root; 295 296 if (root == root->fs_info->tree_root && 297 btrfs_ino(inode) != BTRFS_BTREE_INODE_OBJECTID) 298 return true; 299 if (inode->location.objectid == BTRFS_FREE_INO_OBJECTID) 300 return true; 301 return false; 302 } 303 304 static inline bool is_data_inode(struct inode *inode) 305 { 306 return btrfs_ino(BTRFS_I(inode)) != BTRFS_BTREE_INODE_OBJECTID; 307 } 308 309 static inline void btrfs_mod_outstanding_extents(struct btrfs_inode *inode, 310 int mod) 311 { 312 lockdep_assert_held(&inode->lock); 313 inode->outstanding_extents += mod; 314 if (btrfs_is_free_space_inode(inode)) 315 return; 316 trace_btrfs_inode_mod_outstanding_extents(inode->root, btrfs_ino(inode), 317 mod); 318 } 319 320 /* 321 * Called every time after doing a buffered, direct IO or memory mapped write. 322 * 323 * This is to ensure that if we write to a file that was previously fsynced in 324 * the current transaction, then try to fsync it again in the same transaction, 325 * we will know that there were changes in the file and that it needs to be 326 * logged. 327 */ 328 static inline void btrfs_set_inode_last_sub_trans(struct btrfs_inode *inode) 329 { 330 spin_lock(&inode->lock); 331 inode->last_sub_trans = inode->root->log_transid; 332 spin_unlock(&inode->lock); 333 } 334 335 static inline bool btrfs_inode_in_log(struct btrfs_inode *inode, u64 generation) 336 { 337 bool ret = false; 338 339 spin_lock(&inode->lock); 340 if (inode->logged_trans == generation && 341 inode->last_sub_trans <= inode->last_log_commit && 342 inode->last_sub_trans <= inode->root->last_log_commit) 343 ret = true; 344 spin_unlock(&inode->lock); 345 return ret; 346 } 347 348 struct btrfs_dio_private { 349 struct inode *inode; 350 u64 logical_offset; 351 u64 disk_bytenr; 352 /* Used for bio::bi_size */ 353 u32 bytes; 354 355 /* 356 * References to this structure. There is one reference per in-flight 357 * bio plus one while we're still setting up. 358 */ 359 refcount_t refs; 360 361 /* dio_bio came from fs/direct-io.c */ 362 struct bio *dio_bio; 363 364 /* Array of checksums */ 365 u8 csums[]; 366 }; 367 368 /* 369 * btrfs_inode_item stores flags in a u64, btrfs_inode stores them in two 370 * separate u32s. These two functions convert between the two representations. 371 */ 372 static inline u64 btrfs_inode_combine_flags(u32 flags, u32 ro_flags) 373 { 374 return (flags | ((u64)ro_flags << 32)); 375 } 376 377 static inline void btrfs_inode_split_flags(u64 inode_item_flags, 378 u32 *flags, u32 *ro_flags) 379 { 380 *flags = (u32)inode_item_flags; 381 *ro_flags = (u32)(inode_item_flags >> 32); 382 } 383 384 /* Array of bytes with variable length, hexadecimal format 0x1234 */ 385 #define CSUM_FMT "0x%*phN" 386 #define CSUM_FMT_VALUE(size, bytes) size, bytes 387 388 static inline void btrfs_print_data_csum_error(struct btrfs_inode *inode, 389 u64 logical_start, u8 *csum, u8 *csum_expected, int mirror_num) 390 { 391 struct btrfs_root *root = inode->root; 392 const u32 csum_size = root->fs_info->csum_size; 393 394 /* Output minus objectid, which is more meaningful */ 395 if (root->root_key.objectid >= BTRFS_LAST_FREE_OBJECTID) 396 btrfs_warn_rl(root->fs_info, 397 "csum failed root %lld ino %lld off %llu csum " CSUM_FMT " expected csum " CSUM_FMT " mirror %d", 398 root->root_key.objectid, btrfs_ino(inode), 399 logical_start, 400 CSUM_FMT_VALUE(csum_size, csum), 401 CSUM_FMT_VALUE(csum_size, csum_expected), 402 mirror_num); 403 else 404 btrfs_warn_rl(root->fs_info, 405 "csum failed root %llu ino %llu off %llu csum " CSUM_FMT " expected csum " CSUM_FMT " mirror %d", 406 root->root_key.objectid, btrfs_ino(inode), 407 logical_start, 408 CSUM_FMT_VALUE(csum_size, csum), 409 CSUM_FMT_VALUE(csum_size, csum_expected), 410 mirror_num); 411 } 412 413 #endif 414