1 #ifndef _LINUX_DAX_H 2 #define _LINUX_DAX_H 3 4 #include <linux/fs.h> 5 #include <linux/mm.h> 6 #include <linux/radix-tree.h> 7 #include <asm/pgtable.h> 8 9 struct iomap_ops; 10 struct dax_device; 11 struct dax_operations { 12 /* 13 * direct_access: translate a device-relative 14 * logical-page-offset into an absolute physical pfn. Return the 15 * number of pages available for DAX at that pfn. 16 */ 17 long (*direct_access)(struct dax_device *, pgoff_t, long, 18 void **, pfn_t *); 19 /* copy_from_iter: required operation for fs-dax direct-i/o */ 20 size_t (*copy_from_iter)(struct dax_device *, pgoff_t, void *, size_t, 21 struct iov_iter *); 22 /* flush: optional driver-specific cache management after writes */ 23 void (*flush)(struct dax_device *, pgoff_t, void *, size_t); 24 }; 25 26 extern struct attribute_group dax_attribute_group; 27 28 #if IS_ENABLED(CONFIG_DAX) 29 struct dax_device *dax_get_by_host(const char *host); 30 void put_dax(struct dax_device *dax_dev); 31 #else 32 static inline struct dax_device *dax_get_by_host(const char *host) 33 { 34 return NULL; 35 } 36 37 static inline void put_dax(struct dax_device *dax_dev) 38 { 39 } 40 #endif 41 42 int bdev_dax_pgoff(struct block_device *, sector_t, size_t, pgoff_t *pgoff); 43 #if IS_ENABLED(CONFIG_FS_DAX) 44 int __bdev_dax_supported(struct super_block *sb, int blocksize); 45 static inline int bdev_dax_supported(struct super_block *sb, int blocksize) 46 { 47 return __bdev_dax_supported(sb, blocksize); 48 } 49 50 static inline struct dax_device *fs_dax_get_by_host(const char *host) 51 { 52 return dax_get_by_host(host); 53 } 54 55 static inline void fs_put_dax(struct dax_device *dax_dev) 56 { 57 put_dax(dax_dev); 58 } 59 60 #else 61 static inline int bdev_dax_supported(struct super_block *sb, int blocksize) 62 { 63 return -EOPNOTSUPP; 64 } 65 66 static inline struct dax_device *fs_dax_get_by_host(const char *host) 67 { 68 return NULL; 69 } 70 71 static inline void fs_put_dax(struct dax_device *dax_dev) 72 { 73 } 74 #endif 75 76 int dax_read_lock(void); 77 void dax_read_unlock(int id); 78 struct dax_device *alloc_dax(void *private, const char *host, 79 const struct dax_operations *ops); 80 bool dax_alive(struct dax_device *dax_dev); 81 void kill_dax(struct dax_device *dax_dev); 82 void *dax_get_private(struct dax_device *dax_dev); 83 long dax_direct_access(struct dax_device *dax_dev, pgoff_t pgoff, long nr_pages, 84 void **kaddr, pfn_t *pfn); 85 size_t dax_copy_from_iter(struct dax_device *dax_dev, pgoff_t pgoff, void *addr, 86 size_t bytes, struct iov_iter *i); 87 void dax_flush(struct dax_device *dax_dev, pgoff_t pgoff, void *addr, 88 size_t size); 89 void dax_write_cache(struct dax_device *dax_dev, bool wc); 90 91 /* 92 * We use lowest available bit in exceptional entry for locking, one bit for 93 * the entry size (PMD) and two more to tell us if the entry is a huge zero 94 * page (HZP) or an empty entry that is just used for locking. In total four 95 * special bits. 96 * 97 * If the PMD bit isn't set the entry has size PAGE_SIZE, and if the HZP and 98 * EMPTY bits aren't set the entry is a normal DAX entry with a filesystem 99 * block allocation. 100 */ 101 #define RADIX_DAX_SHIFT (RADIX_TREE_EXCEPTIONAL_SHIFT + 4) 102 #define RADIX_DAX_ENTRY_LOCK (1 << RADIX_TREE_EXCEPTIONAL_SHIFT) 103 #define RADIX_DAX_PMD (1 << (RADIX_TREE_EXCEPTIONAL_SHIFT + 1)) 104 #define RADIX_DAX_HZP (1 << (RADIX_TREE_EXCEPTIONAL_SHIFT + 2)) 105 #define RADIX_DAX_EMPTY (1 << (RADIX_TREE_EXCEPTIONAL_SHIFT + 3)) 106 107 static inline unsigned long dax_radix_sector(void *entry) 108 { 109 return (unsigned long)entry >> RADIX_DAX_SHIFT; 110 } 111 112 static inline void *dax_radix_locked_entry(sector_t sector, unsigned long flags) 113 { 114 return (void *)(RADIX_TREE_EXCEPTIONAL_ENTRY | flags | 115 ((unsigned long)sector << RADIX_DAX_SHIFT) | 116 RADIX_DAX_ENTRY_LOCK); 117 } 118 119 ssize_t dax_iomap_rw(struct kiocb *iocb, struct iov_iter *iter, 120 const struct iomap_ops *ops); 121 int dax_iomap_fault(struct vm_fault *vmf, enum page_entry_size pe_size, 122 const struct iomap_ops *ops); 123 int dax_delete_mapping_entry(struct address_space *mapping, pgoff_t index); 124 int dax_invalidate_mapping_entry_sync(struct address_space *mapping, 125 pgoff_t index); 126 void dax_wake_mapping_entry_waiter(struct address_space *mapping, 127 pgoff_t index, void *entry, bool wake_all); 128 129 #ifdef CONFIG_FS_DAX 130 int __dax_zero_page_range(struct block_device *bdev, 131 struct dax_device *dax_dev, sector_t sector, 132 unsigned int offset, unsigned int length); 133 #else 134 static inline int __dax_zero_page_range(struct block_device *bdev, 135 struct dax_device *dax_dev, sector_t sector, 136 unsigned int offset, unsigned int length) 137 { 138 return -ENXIO; 139 } 140 #endif 141 142 #ifdef CONFIG_FS_DAX_PMD 143 static inline unsigned int dax_radix_order(void *entry) 144 { 145 if ((unsigned long)entry & RADIX_DAX_PMD) 146 return PMD_SHIFT - PAGE_SHIFT; 147 return 0; 148 } 149 #else 150 static inline unsigned int dax_radix_order(void *entry) 151 { 152 return 0; 153 } 154 #endif 155 int dax_pfn_mkwrite(struct vm_fault *vmf); 156 157 static inline bool dax_mapping(struct address_space *mapping) 158 { 159 return mapping->host && IS_DAX(mapping->host); 160 } 161 162 struct writeback_control; 163 int dax_writeback_mapping_range(struct address_space *mapping, 164 struct block_device *bdev, struct writeback_control *wbc); 165 #endif 166