On Mon 14-12-15 16:31:43, Ross Zwisler wrote: > To properly handle fsync/msync in an efficient way DAX needs to track dirty > pages so it is able to flush them durably to media on demand. > > The tracking of dirty pages is done via the radix tree in struct > address_space. This radix tree is already used by the page writeback > infrastructure for tracking dirty pages associated with an open file, and > it already has support for exceptional (non struct page*) entries. We > build upon these features to add exceptional entries to the radix tree for > DAX dirty PMD or PTE pages at fault time. In principle this looks good to me but I can finally judge only once we resolve the possible issue with conflicting exceptional entries I have pointed out in patch 2/7. Honza > > Signed-off-by: Ross Zwisler <ross.zwisler@xxxxxxxxxxxxxxx> > --- > > For v4 I'm just sending out this one changed patch in an effort to not spam > everyone. > > Changes since v3: > > - Rebased on top of ext4/master which provides the patches from Jan which I'm > building upon. The rebased tree can be found here: > > https://git.kernel.org/cgit/linux/kernel/git/zwisler/linux.git/log/?h=fsync_v4 > > - Removed a WARN_ONCE() and added a comment for the case where we can get a > dax_pfn_mkwrite() call that has lost a race with a hole punch operation. > > --- > fs/dax.c | 159 ++++++++++++++++++++++++++++++++++++++++++++++++++-- > include/linux/dax.h | 2 + > mm/filemap.c | 3 + > 3 files changed, 158 insertions(+), 6 deletions(-) > > diff --git a/fs/dax.c b/fs/dax.c > index 43671b6..19347cf 100644 > --- a/fs/dax.c > +++ b/fs/dax.c > @@ -24,6 +24,7 @@ > #include <linux/memcontrol.h> > #include <linux/mm.h> > #include <linux/mutex.h> > +#include <linux/pagevec.h> > #include <linux/pmem.h> > #include <linux/sched.h> > #include <linux/uio.h> > @@ -289,6 +290,143 @@ static int copy_user_bh(struct page *to, struct buffer_head *bh, > return 0; > } > > +static int dax_radix_entry(struct address_space *mapping, pgoff_t index, > + void __pmem *addr, bool pmd_entry, bool dirty) > +{ > + struct radix_tree_root *page_tree = &mapping->page_tree; > + int error = 0; > + void *entry; > + > + __mark_inode_dirty(mapping->host, I_DIRTY_PAGES); > + > + spin_lock_irq(&mapping->tree_lock); > + entry = radix_tree_lookup(page_tree, index); > + > + if (entry) { > + if (!pmd_entry || RADIX_DAX_TYPE(entry) == RADIX_DAX_PMD) > + goto dirty; > + radix_tree_delete(&mapping->page_tree, index); > + mapping->nrdax--; > + } > + > + if (!addr) { > + /* > + * This can happen during correct operation if our pfn_mkwrite > + * fault raced against a hole punch operation. If this > + * happens the pte that was hole punched will have been > + * unmapped and the radix tree entry will have been removed by > + * the time we are called, but the call will still happen. We > + * will return all the way up to wp_pfn_shared(), where the > + * pte_same() check will fail, eventually causing page fault > + * to be retried by the CPU. > + */ > + goto unlock; > + } else if (RADIX_DAX_TYPE(addr)) { > + WARN_ONCE(1, "%s: invalid address %p\n", __func__, addr); > + goto unlock; > + } > + > + error = radix_tree_insert(page_tree, index, > + RADIX_DAX_ENTRY(addr, pmd_entry)); > + if (error) > + goto unlock; > + > + mapping->nrdax++; > + dirty: > + if (dirty) > + radix_tree_tag_set(page_tree, index, PAGECACHE_TAG_DIRTY); > + unlock: > + spin_unlock_irq(&mapping->tree_lock); > + return error; > +} > + > +static void dax_writeback_one(struct address_space *mapping, pgoff_t index, > + void *entry) > +{ > + struct radix_tree_root *page_tree = &mapping->page_tree; > + int type = RADIX_DAX_TYPE(entry); > + struct radix_tree_node *node; > + void **slot; > + > + if (type != RADIX_DAX_PTE && type != RADIX_DAX_PMD) { > + WARN_ON_ONCE(1); > + return; > + } > + > + spin_lock_irq(&mapping->tree_lock); > + /* > + * Regular page slots are stabilized by the page lock even > + * without the tree itself locked. These unlocked entries > + * need verification under the tree lock. > + */ > + if (!__radix_tree_lookup(page_tree, index, &node, &slot)) > + goto unlock; > + if (*slot != entry) > + goto unlock; > + > + /* another fsync thread may have already written back this entry */ > + if (!radix_tree_tag_get(page_tree, index, PAGECACHE_TAG_TOWRITE)) > + goto unlock; > + > + radix_tree_tag_clear(page_tree, index, PAGECACHE_TAG_TOWRITE); > + > + if (type == RADIX_DAX_PMD) > + wb_cache_pmem(RADIX_DAX_ADDR(entry), PMD_SIZE); > + else > + wb_cache_pmem(RADIX_DAX_ADDR(entry), PAGE_SIZE); > + unlock: > + spin_unlock_irq(&mapping->tree_lock); > +} > + > +/* > + * Flush the mapping to the persistent domain within the byte range of [start, > + * end]. This is required by data integrity operations to ensure file data is > + * on persistent storage prior to completion of the operation. > + */ > +void dax_writeback_mapping_range(struct address_space *mapping, loff_t start, > + loff_t end) > +{ > + struct inode *inode = mapping->host; > + pgoff_t indices[PAGEVEC_SIZE]; > + pgoff_t start_page, end_page; > + struct pagevec pvec; > + void *entry; > + int i; > + > + if (inode->i_blkbits != PAGE_SHIFT) { > + WARN_ON_ONCE(1); > + return; > + } > + > + rcu_read_lock(); > + entry = radix_tree_lookup(&mapping->page_tree, start & PMD_MASK); > + rcu_read_unlock(); > + > + /* see if the start of our range is covered by a PMD entry */ > + if (entry && RADIX_DAX_TYPE(entry) == RADIX_DAX_PMD) > + start &= PMD_MASK; > + > + start_page = start >> PAGE_CACHE_SHIFT; > + end_page = end >> PAGE_CACHE_SHIFT; > + > + tag_pages_for_writeback(mapping, start_page, end_page); > + > + pagevec_init(&pvec, 0); > + while (1) { > + pvec.nr = find_get_entries_tag(mapping, start_page, > + PAGECACHE_TAG_TOWRITE, PAGEVEC_SIZE, > + pvec.pages, indices); > + > + if (pvec.nr == 0) > + break; > + > + for (i = 0; i < pvec.nr; i++) > + dax_writeback_one(mapping, indices[i], pvec.pages[i]); > + } > + wmb_pmem(); > +} > +EXPORT_SYMBOL_GPL(dax_writeback_mapping_range); > + > static int dax_insert_mapping(struct inode *inode, struct buffer_head *bh, > struct vm_area_struct *vma, struct vm_fault *vmf) > { > @@ -329,7 +467,11 @@ static int dax_insert_mapping(struct inode *inode, struct buffer_head *bh, > } > > error = vm_insert_mixed(vma, vaddr, pfn); > + if (error) > + goto out; > > + error = dax_radix_entry(mapping, vmf->pgoff, addr, false, > + vmf->flags & FAULT_FLAG_WRITE); > out: > i_mmap_unlock_read(mapping); > > @@ -452,6 +594,7 @@ int __dax_fault(struct vm_area_struct *vma, struct vm_fault *vmf, > delete_from_page_cache(page); > unlock_page(page); > page_cache_release(page); > + page = NULL; > } > > /* > @@ -539,7 +682,7 @@ int __dax_pmd_fault(struct vm_area_struct *vma, unsigned long address, > pgoff_t size, pgoff; > sector_t block, sector; > unsigned long pfn; > - int result = 0; > + int error, result = 0; > > /* dax pmd mappings are broken wrt gup and fork */ > if (!IS_ENABLED(CONFIG_FS_DAX_PMD)) > @@ -651,6 +794,13 @@ int __dax_pmd_fault(struct vm_area_struct *vma, unsigned long address, > } > > result |= vmf_insert_pfn_pmd(vma, address, pmd, pfn, write); > + > + if (write) { > + error = dax_radix_entry(mapping, pgoff, kaddr, true, > + true); > + if (error) > + goto fallback; > + } > } > > out: > @@ -702,15 +852,12 @@ EXPORT_SYMBOL_GPL(dax_pmd_fault); > * dax_pfn_mkwrite - handle first write to DAX page > * @vma: The virtual memory area where the fault occurred > * @vmf: The description of the fault > - * > */ > int dax_pfn_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf) > { > - struct super_block *sb = file_inode(vma->vm_file)->i_sb; > + struct file *file = vma->vm_file; > > - sb_start_pagefault(sb); > - file_update_time(vma->vm_file); > - sb_end_pagefault(sb); > + dax_radix_entry(file->f_mapping, vmf->pgoff, NULL, false, true); > return VM_FAULT_NOPAGE; > } > EXPORT_SYMBOL_GPL(dax_pfn_mkwrite); > diff --git a/include/linux/dax.h b/include/linux/dax.h > index e9d57f68..11eb183 100644 > --- a/include/linux/dax.h > +++ b/include/linux/dax.h > @@ -41,4 +41,6 @@ static inline bool dax_mapping(struct address_space *mapping) > { > return mapping->host && IS_DAX(mapping->host); > } > +void dax_writeback_mapping_range(struct address_space *mapping, loff_t start, > + loff_t end); > #endif > diff --git a/mm/filemap.c b/mm/filemap.c > index 99dfbc9..9577783 100644 > --- a/mm/filemap.c > +++ b/mm/filemap.c > @@ -482,6 +482,9 @@ int filemap_write_and_wait_range(struct address_space *mapping, > { > int err = 0; > > + if (dax_mapping(mapping) && mapping->nrdax) > + dax_writeback_mapping_range(mapping, lstart, lend); > + > if (mapping->nrpages) { > err = __filemap_fdatawrite_range(mapping, lstart, lend, > WB_SYNC_ALL); > -- > 2.5.0 > > -- Jan Kara <jack@xxxxxxxx> SUSE Labs, CR _______________________________________________ xfs mailing list xfs@xxxxxxxxxxx http://oss.sgi.com/mailman/listinfo/xfs
