mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-09-12 13:55:32 +00:00
6bbdd563ee
virtiofs device has a range of memory which is mapped into file inodes using dax. This memory is mapped in qemu on host and maps different sections of real file on host. Size of this memory is limited (determined by administrator) and depending on filesystem size, we will soon reach a situation where all the memory is in use and we need to reclaim some. As part of reclaim process, we will need to make sure that there are no active references to pages (taken by get_user_pages()) on the memory range we are trying to reclaim. I am planning to use dax_layout_busy_page() for this. But in current form this is per inode and scans through all the pages of the inode. We want to reclaim only a portion of memory (say 2MB page). So we want to make sure that only that 2MB range of pages do not have any references (and don't want to unmap all the pages of inode). Hence, create a range version of this function named dax_layout_busy_page_range() which can be used to pass a range which needs to be unmapped. Cc: Dan Williams <dan.j.williams@intel.com> Cc: linux-nvdimm@lists.01.org Cc: Jan Kara <jack@suse.cz> Cc: Vishal L Verma <vishal.l.verma@intel.com> Cc: "Weiny, Ira" <ira.weiny@intel.com> Signed-off-by: Vivek Goyal <vgoyal@redhat.com> Reviewed-by: Jan Kara <jack@suse.cz> Signed-off-by: Miklos Szeredi <mszeredi@redhat.com>
230 lines
6.9 KiB
C
230 lines
6.9 KiB
C
/* SPDX-License-Identifier: GPL-2.0 */
|
|
#ifndef _LINUX_DAX_H
|
|
#define _LINUX_DAX_H
|
|
|
|
#include <linux/fs.h>
|
|
#include <linux/mm.h>
|
|
#include <linux/radix-tree.h>
|
|
|
|
/* Flag for synchronous flush */
|
|
#define DAXDEV_F_SYNC (1UL << 0)
|
|
|
|
typedef unsigned long dax_entry_t;
|
|
|
|
struct iomap_ops;
|
|
struct iomap;
|
|
struct dax_device;
|
|
struct dax_operations {
|
|
/*
|
|
* direct_access: translate a device-relative
|
|
* logical-page-offset into an absolute physical pfn. Return the
|
|
* number of pages available for DAX at that pfn.
|
|
*/
|
|
long (*direct_access)(struct dax_device *, pgoff_t, long,
|
|
void **, pfn_t *);
|
|
/*
|
|
* Validate whether this device is usable as an fsdax backing
|
|
* device.
|
|
*/
|
|
bool (*dax_supported)(struct dax_device *, struct block_device *, int,
|
|
sector_t, sector_t);
|
|
/* copy_from_iter: required operation for fs-dax direct-i/o */
|
|
size_t (*copy_from_iter)(struct dax_device *, pgoff_t, void *, size_t,
|
|
struct iov_iter *);
|
|
/* copy_to_iter: required operation for fs-dax direct-i/o */
|
|
size_t (*copy_to_iter)(struct dax_device *, pgoff_t, void *, size_t,
|
|
struct iov_iter *);
|
|
/* zero_page_range: required operation. Zero page range */
|
|
int (*zero_page_range)(struct dax_device *, pgoff_t, size_t);
|
|
};
|
|
|
|
extern struct attribute_group dax_attribute_group;
|
|
|
|
#if IS_ENABLED(CONFIG_DAX)
|
|
struct dax_device *dax_get_by_host(const char *host);
|
|
struct dax_device *alloc_dax(void *private, const char *host,
|
|
const struct dax_operations *ops, unsigned long flags);
|
|
void put_dax(struct dax_device *dax_dev);
|
|
void kill_dax(struct dax_device *dax_dev);
|
|
void dax_write_cache(struct dax_device *dax_dev, bool wc);
|
|
bool dax_write_cache_enabled(struct dax_device *dax_dev);
|
|
bool __dax_synchronous(struct dax_device *dax_dev);
|
|
static inline bool dax_synchronous(struct dax_device *dax_dev)
|
|
{
|
|
return __dax_synchronous(dax_dev);
|
|
}
|
|
void __set_dax_synchronous(struct dax_device *dax_dev);
|
|
static inline void set_dax_synchronous(struct dax_device *dax_dev)
|
|
{
|
|
__set_dax_synchronous(dax_dev);
|
|
}
|
|
/*
|
|
* Check if given mapping is supported by the file / underlying device.
|
|
*/
|
|
static inline bool daxdev_mapping_supported(struct vm_area_struct *vma,
|
|
struct dax_device *dax_dev)
|
|
{
|
|
if (!(vma->vm_flags & VM_SYNC))
|
|
return true;
|
|
if (!IS_DAX(file_inode(vma->vm_file)))
|
|
return false;
|
|
return dax_synchronous(dax_dev);
|
|
}
|
|
#else
|
|
static inline struct dax_device *dax_get_by_host(const char *host)
|
|
{
|
|
return NULL;
|
|
}
|
|
static inline struct dax_device *alloc_dax(void *private, const char *host,
|
|
const struct dax_operations *ops, unsigned long flags)
|
|
{
|
|
/*
|
|
* Callers should check IS_ENABLED(CONFIG_DAX) to know if this
|
|
* NULL is an error or expected.
|
|
*/
|
|
return NULL;
|
|
}
|
|
static inline void put_dax(struct dax_device *dax_dev)
|
|
{
|
|
}
|
|
static inline void kill_dax(struct dax_device *dax_dev)
|
|
{
|
|
}
|
|
static inline void dax_write_cache(struct dax_device *dax_dev, bool wc)
|
|
{
|
|
}
|
|
static inline bool dax_write_cache_enabled(struct dax_device *dax_dev)
|
|
{
|
|
return false;
|
|
}
|
|
static inline bool dax_synchronous(struct dax_device *dax_dev)
|
|
{
|
|
return true;
|
|
}
|
|
static inline void set_dax_synchronous(struct dax_device *dax_dev)
|
|
{
|
|
}
|
|
static inline bool daxdev_mapping_supported(struct vm_area_struct *vma,
|
|
struct dax_device *dax_dev)
|
|
{
|
|
return !(vma->vm_flags & VM_SYNC);
|
|
}
|
|
#endif
|
|
|
|
struct writeback_control;
|
|
int bdev_dax_pgoff(struct block_device *, sector_t, size_t, pgoff_t *pgoff);
|
|
#if IS_ENABLED(CONFIG_FS_DAX)
|
|
bool __bdev_dax_supported(struct block_device *bdev, int blocksize);
|
|
static inline bool bdev_dax_supported(struct block_device *bdev, int blocksize)
|
|
{
|
|
return __bdev_dax_supported(bdev, blocksize);
|
|
}
|
|
|
|
bool __generic_fsdax_supported(struct dax_device *dax_dev,
|
|
struct block_device *bdev, int blocksize, sector_t start,
|
|
sector_t sectors);
|
|
static inline bool generic_fsdax_supported(struct dax_device *dax_dev,
|
|
struct block_device *bdev, int blocksize, sector_t start,
|
|
sector_t sectors)
|
|
{
|
|
return __generic_fsdax_supported(dax_dev, bdev, blocksize, start,
|
|
sectors);
|
|
}
|
|
|
|
static inline void fs_put_dax(struct dax_device *dax_dev)
|
|
{
|
|
put_dax(dax_dev);
|
|
}
|
|
|
|
struct dax_device *fs_dax_get_by_bdev(struct block_device *bdev);
|
|
int dax_writeback_mapping_range(struct address_space *mapping,
|
|
struct dax_device *dax_dev, struct writeback_control *wbc);
|
|
|
|
struct page *dax_layout_busy_page(struct address_space *mapping);
|
|
struct page *dax_layout_busy_page_range(struct address_space *mapping, loff_t start, loff_t end);
|
|
dax_entry_t dax_lock_page(struct page *page);
|
|
void dax_unlock_page(struct page *page, dax_entry_t cookie);
|
|
#else
|
|
static inline bool bdev_dax_supported(struct block_device *bdev,
|
|
int blocksize)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
static inline bool generic_fsdax_supported(struct dax_device *dax_dev,
|
|
struct block_device *bdev, int blocksize, sector_t start,
|
|
sector_t sectors)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
static inline void fs_put_dax(struct dax_device *dax_dev)
|
|
{
|
|
}
|
|
|
|
static inline struct dax_device *fs_dax_get_by_bdev(struct block_device *bdev)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
static inline struct page *dax_layout_busy_page(struct address_space *mapping)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
static inline struct page *dax_layout_busy_page_range(struct address_space *mapping, pgoff_t start, pgoff_t nr_pages)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
static inline int dax_writeback_mapping_range(struct address_space *mapping,
|
|
struct dax_device *dax_dev, struct writeback_control *wbc)
|
|
{
|
|
return -EOPNOTSUPP;
|
|
}
|
|
|
|
static inline dax_entry_t dax_lock_page(struct page *page)
|
|
{
|
|
if (IS_DAX(page->mapping->host))
|
|
return ~0UL;
|
|
return 0;
|
|
}
|
|
|
|
static inline void dax_unlock_page(struct page *page, dax_entry_t cookie)
|
|
{
|
|
}
|
|
#endif
|
|
|
|
int dax_read_lock(void);
|
|
void dax_read_unlock(int id);
|
|
bool dax_alive(struct dax_device *dax_dev);
|
|
void *dax_get_private(struct dax_device *dax_dev);
|
|
long dax_direct_access(struct dax_device *dax_dev, pgoff_t pgoff, long nr_pages,
|
|
void **kaddr, pfn_t *pfn);
|
|
bool dax_supported(struct dax_device *dax_dev, struct block_device *bdev,
|
|
int blocksize, sector_t start, sector_t len);
|
|
size_t dax_copy_from_iter(struct dax_device *dax_dev, pgoff_t pgoff, void *addr,
|
|
size_t bytes, struct iov_iter *i);
|
|
size_t dax_copy_to_iter(struct dax_device *dax_dev, pgoff_t pgoff, void *addr,
|
|
size_t bytes, struct iov_iter *i);
|
|
int dax_zero_page_range(struct dax_device *dax_dev, pgoff_t pgoff,
|
|
size_t nr_pages);
|
|
void dax_flush(struct dax_device *dax_dev, void *addr, size_t size);
|
|
|
|
ssize_t dax_iomap_rw(struct kiocb *iocb, struct iov_iter *iter,
|
|
const struct iomap_ops *ops);
|
|
vm_fault_t dax_iomap_fault(struct vm_fault *vmf, enum page_entry_size pe_size,
|
|
pfn_t *pfnp, int *errp, const struct iomap_ops *ops);
|
|
vm_fault_t dax_finish_sync_fault(struct vm_fault *vmf,
|
|
enum page_entry_size pe_size, pfn_t pfn);
|
|
int dax_delete_mapping_entry(struct address_space *mapping, pgoff_t index);
|
|
int dax_invalidate_mapping_entry_sync(struct address_space *mapping,
|
|
pgoff_t index);
|
|
int dax_iomap_zero(loff_t pos, unsigned offset, unsigned size,
|
|
struct iomap *iomap);
|
|
static inline bool dax_mapping(struct address_space *mapping)
|
|
{
|
|
return mapping->host && IS_DAX(mapping->host);
|
|
}
|
|
|
|
#endif
|