ext4: indicate that fast_commit is available via /sys/fs/ext4/feature/...

[linux-2.6-microblaze.git] / fs / dax.c

diff --git a/fs/dax.c b/fs/dax.c
index 994ab66..5b47834 100644 (file)
--- a/fs/dax.c
+++ b/fs/dax.c
@@ -559,8 +559,11 @@ fallback:
 }
 
 /**
- * dax_layout_busy_page - find first pinned page in @mapping
+ * dax_layout_busy_page_range - find first pinned page in @mapping
  * @mapping: address space to scan for a page with ref count > 1
+ * @start: Starting offset. Page containing 'start' is included.
+ * @end: End offset. Page containing 'end' is included. If 'end' is LLONG_MAX,
+ *       pages from 'start' till the end of file are included.
  *
  * DAX requires ZONE_DEVICE mapped pages. These pages are never
  * 'onlined' to the page allocator so they are considered idle when
@@ -573,12 +576,15 @@ fallback:
  * to be able to run unmap_mapping_range() and subsequently not race
  * mapping_mapped() becoming true.
  */
-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)
 {
-       XA_STATE(xas, &mapping->i_pages, 0);
        void *entry;
        unsigned int scanned = 0;
        struct page *page = NULL;
+       pgoff_t start_idx = start >> PAGE_SHIFT;
+       pgoff_t end_idx;
+       XA_STATE(xas, &mapping->i_pages, start_idx);
 
        /*
         * In the 'limited' case get_user_pages() for dax is disabled.
@@ -589,6 +595,11 @@ struct page *dax_layout_busy_page(struct address_space *mapping)
        if (!dax_mapping(mapping) || !mapping_mapped(mapping))
                return NULL;
 
+       /* If end == LLONG_MAX, all pages from start to till end of file */
+       if (end == LLONG_MAX)
+               end_idx = ULONG_MAX;
+       else
+               end_idx = end >> PAGE_SHIFT;
        /*
         * If we race get_user_pages_fast() here either we'll see the
         * elevated page count in the iteration and wait, or
@@ -596,15 +607,15 @@ struct page *dax_layout_busy_page(struct address_space *mapping)
         * against is no longer mapped in the page tables and bail to the
         * get_user_pages() slow path.  The slow path is protected by
         * pte_lock() and pmd_lock(). New references are not taken without
-        * holding those locks, and unmap_mapping_range() will not zero the
+        * holding those locks, and unmap_mapping_pages() will not zero the
         * pte or pmd without holding the respective lock, so we are
         * guaranteed to either see new references or prevent new
         * references from being established.
         */
-       unmap_mapping_range(mapping, 0, 0, 0);
+       unmap_mapping_pages(mapping, start_idx, end_idx - start_idx + 1, 0);
 
        xas_lock_irq(&xas);
-       xas_for_each(&xas, entry, ULONG_MAX) {
+       xas_for_each(&xas, entry, end_idx) {
                if (WARN_ON_ONCE(!xa_is_value(entry)))
                        continue;
                if (unlikely(dax_is_locked(entry)))
@@ -625,6 +636,12 @@ struct page *dax_layout_busy_page(struct address_space *mapping)
        xas_unlock_irq(&xas);
        return page;
 }
+EXPORT_SYMBOL_GPL(dax_layout_busy_page_range);
+
+struct page *dax_layout_busy_page(struct address_space *mapping)
+{
+       return dax_layout_busy_page_range(mapping, 0, LLONG_MAX);
+}
 EXPORT_SYMBOL_GPL(dax_layout_busy_page);
 
 static int __dax_invalidate_entry(struct address_space *mapping,
@@ -1037,18 +1054,18 @@ static vm_fault_t dax_load_hole(struct xa_state *xas,
        return ret;
 }
 
-int dax_iomap_zero(loff_t pos, unsigned offset, unsigned size,
-                  struct iomap *iomap)
+s64 dax_iomap_zero(loff_t pos, u64 length, struct iomap *iomap)
 {
        sector_t sector = iomap_sector(iomap, pos & PAGE_MASK);
        pgoff_t pgoff;
        long rc, id;
        void *kaddr;
        bool page_aligned = false;
-
+       unsigned offset = offset_in_page(pos);
+       unsigned size = min_t(u64, PAGE_SIZE - offset, length);
 
        if (IS_ALIGNED(sector << SECTOR_SHIFT, PAGE_SIZE) &&
-           IS_ALIGNED(size, PAGE_SIZE))
+           (size == PAGE_SIZE))
                page_aligned = true;
 
        rc = bdev_dax_pgoff(iomap->bdev, sector, PAGE_SIZE, &pgoff);
@@ -1058,8 +1075,7 @@ int dax_iomap_zero(loff_t pos, unsigned offset, unsigned size,
        id = dax_read_lock();
 
        if (page_aligned)
-               rc = dax_zero_page_range(iomap->dax_dev, pgoff,
-                                        size >> PAGE_SHIFT);
+               rc = dax_zero_page_range(iomap->dax_dev, pgoff, 1);
        else
                rc = dax_direct_access(iomap->dax_dev, pgoff, 1, &kaddr, NULL);
        if (rc < 0) {
@@ -1072,7 +1088,7 @@ int dax_iomap_zero(loff_t pos, unsigned offset, unsigned size,
                dax_flush(iomap->dax_dev, kaddr + offset, size);
        }
        dax_read_unlock(id);
-       return 0;
+       return size;
 }
 
 static loff_t