Merge branch 'akpm' (patches from Andrew)

Merge misc fixes from Andrew Morton:
 "6 fixes"

* emailed patches from Andrew Morton <akpm@linux-foundation.org>:
  sh: add copy_user_page() alias for __copy_user()
  lib/Kconfig: ZLIB_DEFLATE must select BITREVERSE
  mm, dax: fix DAX deadlocks
  memcg: convert threshold to bytes
  builddeb: remove debian/files before build
  mm, fs: obey gfp_mapping for add_to_page_cache()

12 files changed, 58 insertions, 61 deletions

diff --git a/arch/sh/include/asm/page.h b/arch/sh/include/asm/page.h
index fe20d14ae051..ceb5201a30ed 100644
--- a/arch/sh/include/asm/page.h
+++ b/arch/sh/include/asm/page.h
@@ -59,6 +59,7 @@ pages_do_alias(unsigned long addr1, unsigned long addr2)
 
 #define clear_page(page)        memset((void *)(page), 0, PAGE_SIZE)
 extern void copy_page(void *to, void *from);
+#define copy_user_page(to, from, vaddr, pg)  __copy_user(to, from, PAGE_SIZE)
 
 struct page;
 struct vm_area_struct;
diff --git a/drivers/staging/lustre/lustre/llite/dir.c b/drivers/staging/lustre/lustre/llite/dir.c
index 769b61193d87..a9bc6e23fc25 100644
--- a/drivers/staging/lustre/lustre/llite/dir.c
+++ b/drivers/staging/lustre/lustre/llite/dir.c
@@ -224,7 +224,7 @@ static int ll_dir_filler(void *_hash, struct page *page0)
 
                 prefetchw(&page->flags);
                 ret = add_to_page_cache_lru(page, inode->i_mapping, offset,
-                                            GFP_KERNEL);
+                                            GFP_NOFS);
                 if (ret == 0) {
                         unlock_page(page);
                 } else {
diff --git a/fs/cifs/file.c b/fs/cifs/file.c
index e2a6af1508af..62203c387db4 100644
--- a/fs/cifs/file.c
+++ b/fs/cifs/file.c
@@ -3380,6 +3380,7 @@ readpages_get_pages(struct address_space *mapping, struct list_head *page_list,
         struct page *page, *tpage;
         unsigned int expected_index;
         int rc;
+        gfp_t gfp = GFP_KERNEL & mapping_gfp_mask(mapping);
 
         INIT_LIST_HEAD(tmplist);
 
@@ -3392,7 +3393,7 @@ readpages_get_pages(struct address_space *mapping, struct list_head *page_list,
          */
         __set_page_locked(page);
         rc = add_to_page_cache_locked(page, mapping,
-                                      page->index, GFP_KERNEL);
+                                      page->index, gfp);
 
         /* give up if we can't stick it in the cache */
         if (rc) {
@@ -3418,8 +3419,7 @@ readpages_get_pages(struct address_space *mapping, struct list_head *page_list,
                         break;
 
                 __set_page_locked(page);
-                if (add_to_page_cache_locked(page, mapping, page->index,
-                                                                GFP_KERNEL)) {
+                if (add_to_page_cache_locked(page, mapping, page->index, gfp)) {
                         __clear_page_locked(page);
                         break;
                 }
diff --git a/fs/dax.c b/fs/dax.c
index bcfb14bfc1e4..a86d3cc2b389 100644
--- a/fs/dax.c
+++ b/fs/dax.c
@@ -285,6 +285,7 @@ static int copy_user_bh(struct page *to, struct buffer_head *bh,
 static int dax_insert_mapping(struct inode *inode, struct buffer_head *bh,
                         struct vm_area_struct *vma, struct vm_fault *vmf)
 {
+        struct address_space *mapping = inode->i_mapping;
         sector_t sector = bh->b_blocknr << (inode->i_blkbits - 9);
         unsigned long vaddr = (unsigned long)vmf->virtual_address;
         void __pmem *addr;
@@ -292,6 +293,8 @@ static int dax_insert_mapping(struct inode *inode, struct buffer_head *bh,
         pgoff_t size;
         int error;
 
+        i_mmap_lock_read(mapping);
+
         /*
          * Check truncate didn't happen while we were allocating a block.
          * If it did, this block may or may not be still allocated to the
@@ -321,6 +324,8 @@ static int dax_insert_mapping(struct inode *inode, struct buffer_head *bh,
         error = vm_insert_mixed(vma, vaddr, pfn);
 
  out:
+        i_mmap_unlock_read(mapping);
+
         return error;
 }
 
@@ -382,17 +387,15 @@ int __dax_fault(struct vm_area_struct *vma, struct vm_fault *vmf,
                          * from a read fault and we've raced with a truncate
                          */
                         error = -EIO;
-                        goto unlock;
+                        goto unlock_page;
                 }
-        } else {
-                i_mmap_lock_write(mapping);
         }
 
         error = get_block(inode, block, &bh, 0);
         if (!error && (bh.b_size < PAGE_SIZE))
                 error = -EIO;           /* fs corruption? */
         if (error)
-                goto unlock;
+                goto unlock_page;
 
         if (!buffer_mapped(&bh) && !buffer_unwritten(&bh) && !vmf->cow_page) {
                 if (vmf->flags & FAULT_FLAG_WRITE) {
@@ -403,9 +406,8 @@ int __dax_fault(struct vm_area_struct *vma, struct vm_fault *vmf,
                         if (!error && (bh.b_size < PAGE_SIZE))
                                 error = -EIO;
                         if (error)
-                                goto unlock;
+                                goto unlock_page;
                 } else {
-                        i_mmap_unlock_write(mapping);
                         return dax_load_hole(mapping, page, vmf);
                 }
         }
@@ -417,15 +419,17 @@ int __dax_fault(struct vm_area_struct *vma, struct vm_fault *vmf,
                 else
                         clear_user_highpage(new_page, vaddr);
                 if (error)
-                        goto unlock;
+                        goto unlock_page;
                 vmf->page = page;
                 if (!page) {
+                        i_mmap_lock_read(mapping);
                         /* Check we didn't race with truncate */
                         size = (i_size_read(inode) + PAGE_SIZE - 1) >>
                                                                 PAGE_SHIFT;
                         if (vmf->pgoff >= size) {
+                                i_mmap_unlock_read(mapping);
                                 error = -EIO;
-                                goto unlock;
+                                goto out;
                         }
                 }
                 return VM_FAULT_LOCKED;
@@ -461,8 +465,6 @@ int __dax_fault(struct vm_area_struct *vma, struct vm_fault *vmf,
                         WARN_ON_ONCE(!(vmf->flags & FAULT_FLAG_WRITE));
         }
 
-        if (!page)
-                i_mmap_unlock_write(mapping);
  out:
         if (error == -ENOMEM)
                 return VM_FAULT_OOM | major;
@@ -471,14 +473,11 @@ int __dax_fault(struct vm_area_struct *vma, struct vm_fault *vmf,
                 return VM_FAULT_SIGBUS | major;
         return VM_FAULT_NOPAGE | major;
 
- unlock:
+ unlock_page:
         if (page) {
                 unlock_page(page);
                 page_cache_release(page);
-        } else {
-                i_mmap_unlock_write(mapping);
         }
-
         goto out;
 }
 EXPORT_SYMBOL(__dax_fault);
@@ -556,10 +555,10 @@ int __dax_pmd_fault(struct vm_area_struct *vma, unsigned long address,
         block = (sector_t)pgoff << (PAGE_SHIFT - blkbits);
 
         bh.b_size = PMD_SIZE;
-        i_mmap_lock_write(mapping);
         length = get_block(inode, block, &bh, write);
         if (length)
                 return VM_FAULT_SIGBUS;
+        i_mmap_lock_read(mapping);
 
         /*
          * If the filesystem isn't willing to tell us the length of a hole,
@@ -569,36 +568,14 @@ int __dax_pmd_fault(struct vm_area_struct *vma, unsigned long address,
         if (!buffer_size_valid(&bh) || bh.b_size < PMD_SIZE)
                 goto fallback;
 
-        sector = bh.b_blocknr << (blkbits - 9);
-
-        if (buffer_unwritten(&bh) || buffer_new(&bh)) {
-                int i;
-
-                length = bdev_direct_access(bh.b_bdev, sector, &kaddr, &pfn,
-                                                bh.b_size);
-                if (length < 0) {
-                        result = VM_FAULT_SIGBUS;
-                        goto out;
-                }
-                if ((length < PMD_SIZE) || (pfn & PG_PMD_COLOUR))
-                        goto fallback;
-
-                for (i = 0; i < PTRS_PER_PMD; i++)
-                        clear_pmem(kaddr + i * PAGE_SIZE, PAGE_SIZE);
-                wmb_pmem();
-                count_vm_event(PGMAJFAULT);
-                mem_cgroup_count_vm_event(vma->vm_mm, PGMAJFAULT);
-                result |= VM_FAULT_MAJOR;
-        }
-
         /*
          * If we allocated new storage, make sure no process has any
          * zero pages covering this hole
          */
         if (buffer_new(&bh)) {
-                i_mmap_unlock_write(mapping);
+                i_mmap_unlock_read(mapping);
                 unmap_mapping_range(mapping, pgoff << PAGE_SHIFT, PMD_SIZE, 0);
-                i_mmap_lock_write(mapping);
+                i_mmap_lock_read(mapping);
         }
 
         /*
@@ -635,6 +612,7 @@ int __dax_pmd_fault(struct vm_area_struct *vma, unsigned long address,
                 result = VM_FAULT_NOPAGE;
                 spin_unlock(ptl);
         } else {
+                sector = bh.b_blocknr << (blkbits - 9);
                 length = bdev_direct_access(bh.b_bdev, sector, &kaddr, &pfn,
                                                 bh.b_size);
                 if (length < 0) {
@@ -644,15 +622,25 @@ int __dax_pmd_fault(struct vm_area_struct *vma, unsigned long address,
                 if ((length < PMD_SIZE) || (pfn & PG_PMD_COLOUR))
                         goto fallback;
 
+                if (buffer_unwritten(&bh) || buffer_new(&bh)) {
+                        int i;
+                        for (i = 0; i < PTRS_PER_PMD; i++)
+                                clear_pmem(kaddr + i * PAGE_SIZE, PAGE_SIZE);
+                        wmb_pmem();
+                        count_vm_event(PGMAJFAULT);
+                        mem_cgroup_count_vm_event(vma->vm_mm, PGMAJFAULT);
+                        result |= VM_FAULT_MAJOR;
+                }
+
                 result |= vmf_insert_pfn_pmd(vma, address, pmd, pfn, write);
         }
 
  out:
+        i_mmap_unlock_read(mapping);
+
         if (buffer_unwritten(&bh))
                 complete_unwritten(&bh, !(result & VM_FAULT_ERROR));
 
-        i_mmap_unlock_write(mapping);
-
         return result;
 
  fallback:
diff --git a/fs/ext4/readpage.c b/fs/ext4/readpage.c
index e26803fb210d..560af0437704 100644
--- a/fs/ext4/readpage.c
+++ b/fs/ext4/readpage.c
@@ -165,8 +165,8 @@ int ext4_mpage_readpages(struct address_space *mapping,
                 if (pages) {
                         page = list_entry(pages->prev, struct page, lru);
                         list_del(&page->lru);
-                        if (add_to_page_cache_lru(page, mapping,
-                                                  page->index, GFP_KERNEL))
+                        if (add_to_page_cache_lru(page, mapping, page->index,
+                                        GFP_KERNEL & mapping_gfp_mask(mapping)))
                                 goto next_page;
                 }
 
diff --git a/fs/mpage.c b/fs/mpage.c
index 778a4ddef77a..a7c34274f207 100644
--- a/fs/mpage.c
+++ b/fs/mpage.c
@@ -139,7 +139,8 @@ map_buffer_to_page(struct page *page, struct buffer_head *bh, int page_block)
 static struct bio *
 do_mpage_readpage(struct bio *bio, struct page *page, unsigned nr_pages,
                 sector_t *last_block_in_bio, struct buffer_head *map_bh,
-                unsigned long *first_logical_block, get_block_t get_block)
+                unsigned long *first_logical_block, get_block_t get_block,
+                gfp_t gfp)
 {
         struct inode *inode = page->mapping->host;
         const unsigned blkbits = inode->i_blkbits;
@@ -277,8 +278,7 @@ alloc_new:
                                 goto out;
                 }
                 bio = mpage_alloc(bdev, blocks[0] << (blkbits - 9),
-                                min_t(int, nr_pages, BIO_MAX_PAGES),
-                                GFP_KERNEL);
+                                min_t(int, nr_pages, BIO_MAX_PAGES), gfp);
                 if (bio == NULL)
                         goto confused;
         }
@@ -361,6 +361,7 @@ mpage_readpages(struct address_space *mapping, struct list_head *pages,
         sector_t last_block_in_bio = 0;
         struct buffer_head map_bh;
         unsigned long first_logical_block = 0;
+        gfp_t gfp = GFP_KERNEL & mapping_gfp_mask(mapping);
 
         map_bh.b_state = 0;
         map_bh.b_size = 0;
@@ -370,12 +371,13 @@ mpage_readpages(struct address_space *mapping, struct list_head *pages,
                 prefetchw(&page->flags);
                 list_del(&page->lru);
                 if (!add_to_page_cache_lru(page, mapping,
-                                        page->index, GFP_KERNEL)) {
+                                        page->index,
+                                        gfp)) {
                         bio = do_mpage_readpage(bio, page,
                                         nr_pages - page_idx,
                                         &last_block_in_bio, &map_bh,
                                         &first_logical_block,
-                                        get_block);
+                                        get_block, gfp);
                 }
                 page_cache_release(page);
         }
@@ -395,11 +397,12 @@ int mpage_readpage(struct page *page, get_block_t get_block)
         sector_t last_block_in_bio = 0;
         struct buffer_head map_bh;
         unsigned long first_logical_block = 0;
+        gfp_t gfp = GFP_KERNEL & mapping_gfp_mask(page->mapping);
 
         map_bh.b_state = 0;
         map_bh.b_size = 0;
         bio = do_mpage_readpage(bio, page, 1, &last_block_in_bio,
-                        &map_bh, &first_logical_block, get_block);
+                        &map_bh, &first_logical_block, get_block, gfp);
         if (bio)
                 mpage_bio_submit(READ, bio);
         return 0;
diff --git a/fs/ramfs/file-nommu.c b/fs/ramfs/file-nommu.c
index ba1323a94924..a586467f6ff6 100644
--- a/fs/ramfs/file-nommu.c
+++ b/fs/ramfs/file-nommu.c
@@ -70,6 +70,7 @@ int ramfs_nommu_expand_for_mapping(struct inode *inode, size_t newsize)
         unsigned order;
         void *data;
         int ret;
+        gfp_t gfp = mapping_gfp_mask(inode->i_mapping);
 
         /* make various checks */
         order = get_order(newsize);
@@ -84,7 +85,7 @@ int ramfs_nommu_expand_for_mapping(struct inode *inode, size_t newsize)
 
         /* allocate enough contiguous pages to be able to satisfy the
          * request */
-        pages = alloc_pages(mapping_gfp_mask(inode->i_mapping), order);
+        pages = alloc_pages(gfp, order);
         if (!pages)
                 return -ENOMEM;
 
@@ -108,7 +109,7 @@ int ramfs_nommu_expand_for_mapping(struct inode *inode, size_t newsize)
                 struct page *page = pages + loop;
 
                 ret = add_to_page_cache_lru(page, inode->i_mapping, loop,
-                                        GFP_KERNEL);
+                                        gfp);
                 if (ret < 0)
                         goto add_error;
 
diff --git a/lib/Kconfig b/lib/Kconfig
index 2e491ac15622..f0df318104e7 100644
--- a/lib/Kconfig
+++ b/lib/Kconfig
@@ -220,6 +220,7 @@ config ZLIB_INFLATE
 
 config ZLIB_DEFLATE
         tristate
+        select BITREVERSE
 
 config LZO_COMPRESS
         tristate
diff --git a/mm/memcontrol.c b/mm/memcontrol.c
index 1fedbde68f59..d9b5c817dce8 100644
--- a/mm/memcontrol.c
+++ b/mm/memcontrol.c
@@ -3387,6 +3387,7 @@ static int __mem_cgroup_usage_register_event(struct mem_cgroup *memcg,
         ret = page_counter_memparse(args, "-1", &threshold);
         if (ret)
                 return ret;
+        threshold <<= PAGE_SHIFT;
 
         mutex_lock(&memcg->thresholds_lock);
 
diff --git a/mm/memory.c b/mm/memory.c
index 9cb27470fee9..deb679c31f2a 100644
--- a/mm/memory.c
+++ b/mm/memory.c
@@ -2426,6 +2426,8 @@ void unmap_mapping_range(struct address_space *mapping,
         if (details.last_index < details.first_index)
                 details.last_index = ULONG_MAX;
 
+
+        /* DAX uses i_mmap_lock to serialise file truncate vs page fault */
         i_mmap_lock_write(mapping);
         if (unlikely(!RB_EMPTY_ROOT(&mapping->i_mmap)))
                 unmap_mapping_range_tree(&mapping->i_mmap, &details);
diff --git a/mm/readahead.c b/mm/readahead.c
index 60cd846a9a44..24682f6f4cfd 100644
--- a/mm/readahead.c
+++ b/mm/readahead.c
@@ -89,8 +89,8 @@ int read_cache_pages(struct address_space *mapping, struct list_head *pages,
         while (!list_empty(pages)) {
                 page = list_to_page(pages);
                 list_del(&page->lru);
-                if (add_to_page_cache_lru(page, mapping,
-                                        page->index, GFP_KERNEL)) {
+                if (add_to_page_cache_lru(page, mapping, page->index,
+                                GFP_KERNEL & mapping_gfp_mask(mapping))) {
                         read_cache_pages_invalidate_page(mapping, page);
                         continue;
                 }
@@ -127,8 +127,8 @@ static int read_pages(struct address_space *mapping, struct file *filp,
         for (page_idx = 0; page_idx < nr_pages; page_idx++) {
                 struct page *page = list_to_page(pages);
                 list_del(&page->lru);
-                if (!add_to_page_cache_lru(page, mapping,
-                                        page->index, GFP_KERNEL)) {
+                if (!add_to_page_cache_lru(page, mapping, page->index,
+                                GFP_KERNEL & mapping_gfp_mask(mapping))) {
                         mapping->a_ops->readpage(filp, page);
                 }
                 page_cache_release(page);
diff --git a/scripts/package/builddeb b/scripts/package/builddeb
index 0cd46e129920..b967e4f9fed2 100755
--- a/scripts/package/builddeb
+++ b/scripts/package/builddeb
@@ -115,7 +115,7 @@ esac
 BUILD_DEBUG="$(grep -s '^CONFIG_DEBUG_INFO=y' $KCONFIG_CONFIG || true)"
 
 # Setup the directory structure
-rm -rf "$tmpdir" "$fwdir" "$kernel_headers_dir" "$libc_headers_dir" "$dbg_dir"
+rm -rf "$tmpdir" "$fwdir" "$kernel_headers_dir" "$libc_headers_dir" "$dbg_dir" $objtree/debian/files
 mkdir -m 755 -p "$tmpdir/DEBIAN"
 mkdir -p "$tmpdir/lib" "$tmpdir/boot"
 mkdir -p "$fwdir/lib/firmware/$version/"
@@ -408,7 +408,7 @@ binary-arch:
         \$(MAKE) KDEB_SOURCENAME=${sourcename} KDEB_PKGVERSION=${packageversion} bindeb-pkg
 
 clean:
-        rm -rf debian/*tmp
+        rm -rf debian/*tmp debian/files
         mv debian/ debian.backup # debian/ might be cleaned away
         \$(MAKE) clean
         mv debian.backup debian