fs/btrfs/btrfs_inode.h

   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         /* Set when this inode is a free space inode. */
  69         BTRFS_INODE_FREE_SPACE_INODE,
  70 };
  71
  72 /* in memory btrfs inode */
  73 struct btrfs_inode {
  74         /* which subvolume this inode belongs to */
  75         struct btrfs_root *root;
  76
  77         /* key used to find this inode on disk.  This is used by the code
  78          * to read in roots of subvolumes
  79          */
  80         struct btrfs_key location;
  81
  82         /*
  83          * Lock for counters and all fields used to determine if the inode is in
  84          * the log or not (last_trans, last_sub_trans, last_log_commit,
  85          * logged_trans), to access/update new_delalloc_bytes and to update the
  86          * VFS' inode number of bytes used.
  87          */
  88         spinlock_t lock;
  89
  90         /* the extent_tree has caches of all the extent mappings to disk */
  91         struct extent_map_tree extent_tree;
  92
  93         /* the io_tree does range state (DIRTY, LOCKED etc) */
  94         struct extent_io_tree io_tree;
  95
  96         /*
  97          * Keep track of where the inode has extent items mapped in order to
  98          * make sure the i_size adjustments are accurate
  99          */
 100         struct extent_io_tree file_extent_tree;
 101
 102         /* held while logging the inode in tree-log.c */
 103         struct mutex log_mutex;
 104
 105         /* used to order data wrt metadata */
 106         struct btrfs_ordered_inode_tree ordered_tree;
 107
 108         /* list of all the delalloc inodes in the FS.  There are times we need
 109          * to write all the delalloc pages to disk, and this list is used
 110          * to walk them all.
 111          */
 112         struct list_head delalloc_inodes;
 113
 114         /* node for the red-black tree that links inodes in subvolume root */
 115         struct rb_node rb_node;
 116
 117         unsigned long runtime_flags;
 118
 119         /* full 64 bit generation number, struct vfs_inode doesn't have a big
 120          * enough field for this.
 121          */
 122         u64 generation;
 123
 124         /*
 125          * transid of the trans_handle that last modified this inode
 126          */
 127         u64 last_trans;
 128
 129         /*
 130          * transid that last logged this inode
 131          */
 132         u64 logged_trans;
 133
 134         /*
 135          * log transid when this inode was last modified
 136          */
 137         int last_sub_trans;
 138
 139         /* a local copy of root's last_log_commit */
 140         int last_log_commit;
 141
 142         union {
 143                 /*
 144                  * Total number of bytes pending delalloc, used by stat to
 145                  * calculate the real block usage of the file. This is used
 146                  * only for files.
 147                  */
 148                 u64 delalloc_bytes;
 149                 /*
 150                  * The lowest possible index of the next dir index key which
 151                  * points to an inode that needs to be logged.
 152                  * This is used only for directories.
 153                  * Use the helpers btrfs_get_first_dir_index_to_log() and
 154                  * btrfs_set_first_dir_index_to_log() to access this field.
 155                  */
 156                 u64 first_dir_index_to_log;
 157         };
 158
 159         union {
 160                 /*
 161                  * Total number of bytes pending delalloc that fall within a file
 162                  * range that is either a hole or beyond EOF (and no prealloc extent
 163                  * exists in the range). This is always <= delalloc_bytes and this
 164                  * is used only for files.
 165                  */
 166                 u64 new_delalloc_bytes;
 167                 /*
 168                  * The offset of the last dir index key that was logged.
 169                  * This is used only for directories.
 170                  */
 171                 u64 last_dir_index_offset;
 172         };
 173
 174         /*
 175          * total number of bytes pending defrag, used by stat to check whether
 176          * it needs COW.
 177          */
 178         u64 defrag_bytes;
 179
 180         /*
 181          * the size of the file stored in the metadata on disk.  data=ordered
 182          * means the in-memory i_size might be larger than the size on disk
 183          * because not all the blocks are written yet.
 184          */
 185         u64 disk_i_size;
 186
 187         /*
 188          * If this is a directory then index_cnt is the counter for the index
 189          * number for new files that are created. For an empty directory, this
 190          * must be initialized to BTRFS_DIR_START_INDEX.
 191          */
 192         u64 index_cnt;
 193
 194         /* Cache the directory index number to speed the dir/file remove */
 195         u64 dir_index;
 196
 197         /* the fsync log has some corner cases that mean we have to check
 198          * directories to see if any unlinks have been done before
 199          * the directory was logged.  See tree-log.c for all the
 200          * details
 201          */
 202         u64 last_unlink_trans;
 203
 204         /*
 205          * The id/generation of the last transaction where this inode was
 206          * either the source or the destination of a clone/dedupe operation.
 207          * Used when logging an inode to know if there are shared extents that
 208          * need special care when logging checksum items, to avoid duplicate
 209          * checksum items in a log (which can lead to a corruption where we end
 210          * up with missing checksum ranges after log replay).
 211          * Protected by the vfs inode lock.
 212          */
 213         u64 last_reflink_trans;
 214
 215         /*
 216          * Number of bytes outstanding that are going to need csums.  This is
 217          * used in ENOSPC accounting.
 218          */
 219         u64 csum_bytes;
 220
 221         /* Backwards incompatible flags, lower half of inode_item::flags  */
 222         u32 flags;
 223         /* Read-only compatibility flags, upper half of inode_item::flags */
 224         u32 ro_flags;
 225
 226         /*
 227          * Counters to keep track of the number of extent item's we may use due
 228          * to delalloc and such.  outstanding_extents is the number of extent
 229          * items we think we'll end up using, and reserved_extents is the number
 230          * of extent items we've reserved metadata for.
 231          */
 232         unsigned outstanding_extents;
 233
 234         struct btrfs_block_rsv block_rsv;
 235
 236         /*
 237          * Cached values of inode properties
 238          */
 239         unsigned prop_compress;         /* per-file compression algorithm */
 240         /*
 241          * Force compression on the file using the defrag ioctl, could be
 242          * different from prop_compress and takes precedence if set
 243          */
 244         unsigned defrag_compress;
 245
 246         struct btrfs_delayed_node *delayed_node;
 247
 248         /* File creation time. */
 249         struct timespec64 i_otime;
 250
 251         /* Hook into fs_info->delayed_iputs */
 252         struct list_head delayed_iput;
 253
 254         struct rw_semaphore i_mmap_lock;
 255         struct inode vfs_inode;
 256 };
 257
 258 static inline u64 btrfs_get_first_dir_index_to_log(const struct btrfs_inode *inode)
 259 {
 260         return READ_ONCE(inode->first_dir_index_to_log);
 261 }
 262
 263 static inline void btrfs_set_first_dir_index_to_log(struct btrfs_inode *inode,
 264                                                     u64 index)
 265 {
 266         WRITE_ONCE(inode->first_dir_index_to_log, index);
 267 }
 268
 269 static inline struct btrfs_inode *BTRFS_I(const struct inode *inode)
 270 {
 271         return container_of(inode, struct btrfs_inode, vfs_inode);
 272 }
 273
 274 static inline unsigned long btrfs_inode_hash(u64 objectid,
 275                                              const struct btrfs_root *root)
 276 {
 277         u64 h = objectid ^ (root->root_key.objectid * GOLDEN_RATIO_PRIME);
 278
 279 #if BITS_PER_LONG == 32
 280         h = (h >> 32) ^ (h & 0xffffffff);
 281 #endif
 282
 283         return (unsigned long)h;
 284 }
 285
 286 #if BITS_PER_LONG == 32
 287
 288 /*
 289  * On 32 bit systems the i_ino of struct inode is 32 bits (unsigned long), so
 290  * we use the inode's location objectid which is a u64 to avoid truncation.
 291  */
 292 static inline u64 btrfs_ino(const struct btrfs_inode *inode)
 293 {
 294         u64 ino = inode->location.objectid;
 295
 296         /* type == BTRFS_ROOT_ITEM_KEY: subvol dir */
 297         if (inode->location.type == BTRFS_ROOT_ITEM_KEY)
 298                 ino = inode->vfs_inode.i_ino;
 299         return ino;
 300 }
 301
 302 #else
 303
 304 static inline u64 btrfs_ino(const struct btrfs_inode *inode)
 305 {
 306         return inode->vfs_inode.i_ino;
 307 }
 308
 309 #endif
 310
 311 static inline void btrfs_i_size_write(struct btrfs_inode *inode, u64 size)
 312 {
 313         i_size_write(&inode->vfs_inode, size);
 314         inode->disk_i_size = size;
 315 }
 316
 317 static inline bool btrfs_is_free_space_inode(struct btrfs_inode *inode)
 318 {
 319         return test_bit(BTRFS_INODE_FREE_SPACE_INODE, &inode->runtime_flags);
 320 }
 321
 322 static inline bool is_data_inode(struct inode *inode)
 323 {
 324         return btrfs_ino(BTRFS_I(inode)) != BTRFS_BTREE_INODE_OBJECTID;
 325 }
 326
 327 static inline void btrfs_mod_outstanding_extents(struct btrfs_inode *inode,
 328                                                  int mod)
 329 {
 330         lockdep_assert_held(&inode->lock);
 331         inode->outstanding_extents += mod;
 332         if (btrfs_is_free_space_inode(inode))
 333                 return;
 334         trace_btrfs_inode_mod_outstanding_extents(inode->root, btrfs_ino(inode),
 335                                                   mod, inode->outstanding_extents);
 336 }
 337
 338 /*
 339  * Called every time after doing a buffered, direct IO or memory mapped write.
 340  *
 341  * This is to ensure that if we write to a file that was previously fsynced in
 342  * the current transaction, then try to fsync it again in the same transaction,
 343  * we will know that there were changes in the file and that it needs to be
 344  * logged.
 345  */
 346 static inline void btrfs_set_inode_last_sub_trans(struct btrfs_inode *inode)
 347 {
 348         spin_lock(&inode->lock);
 349         inode->last_sub_trans = inode->root->log_transid;
 350         spin_unlock(&inode->lock);
 351 }
 352
 353 /*
 354  * Should be called while holding the inode's VFS lock in exclusive mode or in a
 355  * context where no one else can access the inode concurrently (during inode
 356  * creation or when loading an inode from disk).
 357  */
 358 static inline void btrfs_set_inode_full_sync(struct btrfs_inode *inode)
 359 {
 360         set_bit(BTRFS_INODE_NEEDS_FULL_SYNC, &inode->runtime_flags);
 361         /*
 362          * The inode may have been part of a reflink operation in the last
 363          * transaction that modified it, and then a fsync has reset the
 364          * last_reflink_trans to avoid subsequent fsyncs in the same
 365          * transaction to do unnecessary work. So update last_reflink_trans
 366          * to the last_trans value (we have to be pessimistic and assume a
 367          * reflink happened).
 368          *
 369          * The ->last_trans is protected by the inode's spinlock and we can
 370          * have a concurrent ordered extent completion update it. Also set
 371          * last_reflink_trans to ->last_trans only if the former is less than
 372          * the later, because we can be called in a context where
 373          * last_reflink_trans was set to the current transaction generation
 374          * while ->last_trans was not yet updated in the current transaction,
 375          * and therefore has a lower value.
 376          */
 377         spin_lock(&inode->lock);
 378         if (inode->last_reflink_trans < inode->last_trans)
 379                 inode->last_reflink_trans = inode->last_trans;
 380         spin_unlock(&inode->lock);
 381 }
 382
 383 static inline bool btrfs_inode_in_log(struct btrfs_inode *inode, u64 generation)
 384 {
 385         bool ret = false;
 386
 387         spin_lock(&inode->lock);
 388         if (inode->logged_trans == generation &&
 389             inode->last_sub_trans <= inode->last_log_commit &&
 390             inode->last_sub_trans <= inode->root->last_log_commit)
 391                 ret = true;
 392         spin_unlock(&inode->lock);
 393         return ret;
 394 }
 395
 396 /*
 397  * Check if the inode has flags compatible with compression
 398  */
 399 static inline bool btrfs_inode_can_compress(const struct btrfs_inode *inode)
 400 {
 401         if (inode->flags & BTRFS_INODE_NODATACOW ||
 402             inode->flags & BTRFS_INODE_NODATASUM)
 403                 return false;
 404         return true;
 405 }
 406
 407 /* Array of bytes with variable length, hexadecimal format 0x1234 */
 408 #define CSUM_FMT                                "0x%*phN"
 409 #define CSUM_FMT_VALUE(size, bytes)             size, bytes
 410
 411 int btrfs_check_sector_csum(struct btrfs_fs_info *fs_info, struct page *page,
 412                             u32 pgoff, u8 *csum, const u8 * const csum_expected);
 413 bool btrfs_data_csum_ok(struct btrfs_bio *bbio, struct btrfs_device *dev,
 414                         u32 bio_offset, struct bio_vec *bv);
 415 noinline int can_nocow_extent(struct inode *inode, u64 offset, u64 *len,
 416                               u64 *orig_start, u64 *orig_block_len,
 417                               u64 *ram_bytes, bool nowait, bool strict);
 418
 419 void __btrfs_del_delalloc_inode(struct btrfs_root *root, struct btrfs_inode *inode);
 420 struct inode *btrfs_lookup_dentry(struct inode *dir, struct dentry *dentry);
 421 int btrfs_set_inode_index(struct btrfs_inode *dir, u64 *index);
 422 int btrfs_unlink_inode(struct btrfs_trans_handle *trans,
 423                        struct btrfs_inode *dir, struct btrfs_inode *inode,
 424                        const struct fscrypt_str *name);
 425 int btrfs_add_link(struct btrfs_trans_handle *trans,
 426                    struct btrfs_inode *parent_inode, struct btrfs_inode *inode,
 427                    const struct fscrypt_str *name, int add_backref, u64 index);
 428 int btrfs_delete_subvolume(struct btrfs_inode *dir, struct dentry *dentry);
 429 int btrfs_truncate_block(struct btrfs_inode *inode, loff_t from, loff_t len,
 430                          int front);
 431
 432 int btrfs_start_delalloc_snapshot(struct btrfs_root *root, bool in_reclaim_context);
 433 int btrfs_start_delalloc_roots(struct btrfs_fs_info *fs_info, long nr,
 434                                bool in_reclaim_context);
 435 int btrfs_set_extent_delalloc(struct btrfs_inode *inode, u64 start, u64 end,
 436                               unsigned int extra_bits,
 437                               struct extent_state **cached_state);
 438
 439 struct btrfs_new_inode_args {
 440         /* Input */
 441         struct inode *dir;
 442         struct dentry *dentry;
 443         struct inode *inode;
 444         bool orphan;
 445         bool subvol;
 446
 447         /* Output from btrfs_new_inode_prepare(), input to btrfs_create_new_inode(). */
 448         struct posix_acl *default_acl;
 449         struct posix_acl *acl;
 450         struct fscrypt_name fname;
 451 };
 452
 453 int btrfs_new_inode_prepare(struct btrfs_new_inode_args *args,
 454                             unsigned int *trans_num_items);
 455 int btrfs_create_new_inode(struct btrfs_trans_handle *trans,
 456                            struct btrfs_new_inode_args *args);
 457 void btrfs_new_inode_args_destroy(struct btrfs_new_inode_args *args);
 458 struct inode *btrfs_new_subvol_inode(struct mnt_idmap *idmap,
 459                                      struct inode *dir);
 460  void btrfs_set_delalloc_extent(struct btrfs_inode *inode, struct extent_state *state,
 461                                 u32 bits);
 462 void btrfs_clear_delalloc_extent(struct btrfs_inode *inode,
 463                                  struct extent_state *state, u32 bits);
 464 void btrfs_merge_delalloc_extent(struct btrfs_inode *inode, struct extent_state *new,
 465                                  struct extent_state *other);
 466 void btrfs_split_delalloc_extent(struct btrfs_inode *inode,
 467                                  struct extent_state *orig, u64 split);
 468 void btrfs_set_range_writeback(struct btrfs_inode *inode, u64 start, u64 end);
 469 vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf);
 470 void btrfs_evict_inode(struct inode *inode);
 471 struct inode *btrfs_alloc_inode(struct super_block *sb);
 472 void btrfs_destroy_inode(struct inode *inode);
 473 void btrfs_free_inode(struct inode *inode);
 474 int btrfs_drop_inode(struct inode *inode);
 475 int __init btrfs_init_cachep(void);
 476 void __cold btrfs_destroy_cachep(void);
 477 struct inode *btrfs_iget_path(struct super_block *s, u64 ino,
 478                               struct btrfs_root *root, struct btrfs_path *path);
 479 struct inode *btrfs_iget(struct super_block *s, u64 ino, struct btrfs_root *root);
 480 struct extent_map *btrfs_get_extent(struct btrfs_inode *inode,
 481                                     struct page *page, size_t pg_offset,
 482                                     u64 start, u64 end);
 483 int btrfs_update_inode(struct btrfs_trans_handle *trans,
 484                        struct btrfs_root *root, struct btrfs_inode *inode);
 485 int btrfs_update_inode_fallback(struct btrfs_trans_handle *trans,
 486                                 struct btrfs_root *root, struct btrfs_inode *inode);
 487 int btrfs_orphan_add(struct btrfs_trans_handle *trans, struct btrfs_inode *inode);
 488 int btrfs_orphan_cleanup(struct btrfs_root *root);
 489 int btrfs_cont_expand(struct btrfs_inode *inode, loff_t oldsize, loff_t size);
 490 void btrfs_add_delayed_iput(struct btrfs_inode *inode);
 491 void btrfs_run_delayed_iputs(struct btrfs_fs_info *fs_info);
 492 int btrfs_wait_on_delayed_iputs(struct btrfs_fs_info *fs_info);
 493 int btrfs_prealloc_file_range(struct inode *inode, int mode,
 494                               u64 start, u64 num_bytes, u64 min_size,
 495                               loff_t actual_len, u64 *alloc_hint);
 496 int btrfs_prealloc_file_range_trans(struct inode *inode,
 497                                     struct btrfs_trans_handle *trans, int mode,
 498                                     u64 start, u64 num_bytes, u64 min_size,
 499                                     loff_t actual_len, u64 *alloc_hint);
 500 int btrfs_run_delalloc_range(struct btrfs_inode *inode, struct page *locked_page,
 501                              u64 start, u64 end, int *page_started,
 502                              unsigned long *nr_written, struct writeback_control *wbc);
 503 int btrfs_writepage_cow_fixup(struct page *page);
 504 void btrfs_writepage_endio_finish_ordered(struct btrfs_inode *inode,
 505                                           struct page *page, u64 start,
 506                                           u64 end, bool uptodate);
 507 int btrfs_encoded_io_compression_from_extent(struct btrfs_fs_info *fs_info,
 508                                              int compress_type);
 509 int btrfs_encoded_read_regular_fill_pages(struct btrfs_inode *inode,
 510                                           u64 file_offset, u64 disk_bytenr,
 511                                           u64 disk_io_size,
 512                                           struct page **pages);
 513 ssize_t btrfs_encoded_read(struct kiocb *iocb, struct iov_iter *iter,
 514                            struct btrfs_ioctl_encoded_io_args *encoded);
 515 ssize_t btrfs_do_encoded_write(struct kiocb *iocb, struct iov_iter *from,
 516                                const struct btrfs_ioctl_encoded_io_args *encoded);
 517
 518 ssize_t btrfs_dio_read(struct kiocb *iocb, struct iov_iter *iter,
 519                        size_t done_before);
 520 struct iomap_dio *btrfs_dio_write(struct kiocb *iocb, struct iov_iter *iter,
 521                                   size_t done_before);
 522
 523 extern const struct dentry_operations btrfs_dentry_operations;
 524
 525 /* Inode locking type flags, by default the exclusive lock is taken. */
 526 enum btrfs_ilock_type {
 527         ENUM_BIT(BTRFS_ILOCK_SHARED),
 528         ENUM_BIT(BTRFS_ILOCK_TRY),
 529         ENUM_BIT(BTRFS_ILOCK_MMAP),
 530 };
 531
 532 int btrfs_inode_lock(struct btrfs_inode *inode, unsigned int ilock_flags);
 533 void btrfs_inode_unlock(struct btrfs_inode *inode, unsigned int ilock_flags);
 534 void btrfs_update_inode_bytes(struct btrfs_inode *inode, const u64 add_bytes,
 535                               const u64 del_bytes);
 536 void btrfs_assert_inode_range_clean(struct btrfs_inode *inode, u64 start, u64 end);
 537
 538 #endif