fs/bcachefs/fs-io-pagecache.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 #ifndef _BCACHEFS_FS_IO_PAGECACHE_H
   3 #define _BCACHEFS_FS_IO_PAGECACHE_H
   4
   5 #include <linux/pagemap.h>
   6
   7 typedef DARRAY(struct folio *) folios;
   8
   9 int bch2_filemap_get_contig_folios_d(struct address_space *, loff_t,
  10                                      u64, fgf_t, gfp_t, folios *);
  11 int bch2_write_invalidate_inode_pages_range(struct address_space *, loff_t, loff_t);
  12
  13 /*
  14  * Use u64 for the end pos and sector helpers because if the folio covers the
  15  * max supported range of the mapping, the start offset of the next folio
  16  * overflows loff_t. This breaks much of the range based processing in the
  17  * buffered write path.
  18  */
  19 static inline u64 folio_end_pos(struct folio *folio)
  20 {
  21         return folio_pos(folio) + folio_size(folio);
  22 }
  23
  24 static inline size_t folio_sectors(struct folio *folio)
  25 {
  26         return PAGE_SECTORS << folio_order(folio);
  27 }
  28
  29 static inline loff_t folio_sector(struct folio *folio)
  30 {
  31         return folio_pos(folio) >> 9;
  32 }
  33
  34 static inline u64 folio_end_sector(struct folio *folio)
  35 {
  36         return folio_end_pos(folio) >> 9;
  37 }
  38
  39 #define BCH_FOLIO_SECTOR_STATE()        \
  40         x(unallocated)                  \
  41         x(reserved)                     \
  42         x(dirty)                        \
  43         x(dirty_reserved)               \
  44         x(allocated)
  45
  46 enum bch_folio_sector_state {
  47 #define x(n)    SECTOR_##n,
  48         BCH_FOLIO_SECTOR_STATE()
  49 #undef x
  50 };
  51
  52 struct bch_folio_sector {
  53         /* Uncompressed, fully allocated replicas (or on disk reservation): */
  54         u8                      nr_replicas:4,
  55         /* Owns PAGE_SECTORS * replicas_reserved sized in memory reservation: */
  56                                 replicas_reserved:4;
  57         u8                      state;
  58 };
  59
  60 struct bch_folio {
  61         spinlock_t              lock;
  62         atomic_t                write_count;
  63         /*
  64          * Is the sector state up to date with the btree?
  65          * (Not the data itself)
  66          */
  67         bool                    uptodate;
  68         struct bch_folio_sector s[];
  69 };
  70
  71 /* Helper for when we need to add debug instrumentation: */
  72 static inline void bch2_folio_sector_set(struct folio *folio,
  73                              struct bch_folio *s,
  74                              unsigned i, unsigned n)
  75 {
  76         s->s[i].state = n;
  77 }
  78
  79 /* file offset (to folio offset) to bch_folio_sector index */
  80 static inline int folio_pos_to_s(struct folio *folio, loff_t pos)
  81 {
  82         u64 f_offset = pos - folio_pos(folio);
  83
  84         BUG_ON(pos < folio_pos(folio) || pos >= folio_end_pos(folio));
  85         return f_offset >> SECTOR_SHIFT;
  86 }
  87
  88 /* for newly allocated folios: */
  89 static inline void __bch2_folio_release(struct folio *folio)
  90 {
  91         kfree(folio_detach_private(folio));
  92 }
  93
  94 static inline void bch2_folio_release(struct folio *folio)
  95 {
  96         EBUG_ON(!folio_test_locked(folio));
  97         __bch2_folio_release(folio);
  98 }
  99
 100 static inline struct bch_folio *__bch2_folio(struct folio *folio)
 101 {
 102         return folio_get_private(folio);
 103 }
 104
 105 static inline struct bch_folio *bch2_folio(struct folio *folio)
 106 {
 107         EBUG_ON(!folio_test_locked(folio));
 108
 109         return __bch2_folio(folio);
 110 }
 111
 112 struct bch_folio *__bch2_folio_create(struct folio *, gfp_t);
 113 struct bch_folio *bch2_folio_create(struct folio *, gfp_t);
 114
 115 struct bch2_folio_reservation {
 116         struct disk_reservation disk;
 117         struct quota_res        quota;
 118 };
 119
 120 static inline unsigned inode_nr_replicas(struct bch_fs *c, struct bch_inode_info *inode)
 121 {
 122         /* XXX: this should not be open coded */
 123         return inode->ei_inode.bi_data_replicas
 124                 ? inode->ei_inode.bi_data_replicas - 1
 125                 : c->opts.data_replicas;
 126 }
 127
 128 static inline void bch2_folio_reservation_init(struct bch_fs *c,
 129                         struct bch_inode_info *inode,
 130                         struct bch2_folio_reservation *res)
 131 {
 132         memset(res, 0, sizeof(*res));
 133
 134         res->disk.nr_replicas = inode_nr_replicas(c, inode);
 135 }
 136
 137 int bch2_folio_set(struct bch_fs *, subvol_inum, struct folio **, unsigned);
 138 void bch2_bio_page_state_set(struct bio *, struct bkey_s_c);
 139
 140 void bch2_mark_pagecache_unallocated(struct bch_inode_info *, u64, u64);
 141 int bch2_mark_pagecache_reserved(struct bch_inode_info *, u64 *, u64, bool);
 142
 143 int bch2_get_folio_disk_reservation(struct bch_fs *,
 144                                 struct bch_inode_info *,
 145                                 struct folio *, bool);
 146
 147 void bch2_folio_reservation_put(struct bch_fs *,
 148                         struct bch_inode_info *,
 149                         struct bch2_folio_reservation *);
 150 int bch2_folio_reservation_get(struct bch_fs *,
 151                         struct bch_inode_info *,
 152                         struct folio *,
 153                         struct bch2_folio_reservation *,
 154                         size_t, size_t);
 155 ssize_t bch2_folio_reservation_get_partial(struct bch_fs *,
 156                         struct bch_inode_info *,
 157                         struct folio *,
 158                         struct bch2_folio_reservation *,
 159                         size_t, size_t);
 160
 161 void bch2_set_folio_dirty(struct bch_fs *,
 162                           struct bch_inode_info *,
 163                           struct folio *,
 164                           struct bch2_folio_reservation *,
 165                           unsigned, unsigned);
 166
 167 vm_fault_t bch2_page_fault(struct vm_fault *);
 168 vm_fault_t bch2_page_mkwrite(struct vm_fault *);
 169 void bch2_invalidate_folio(struct folio *, size_t, size_t);
 170 bool bch2_release_folio(struct folio *, gfp_t);
 171
 172 loff_t bch2_seek_pagecache_data(struct inode *, loff_t, loff_t, unsigned, bool);
 173 loff_t bch2_seek_pagecache_hole(struct inode *, loff_t, loff_t, unsigned, bool);
 174 int bch2_clamp_data_hole(struct inode *, u64 *, u64 *, unsigned, bool);
 175
 176 #endif /* _BCACHEFS_FS_IO_PAGECACHE_H */