IB/hfi1: Fix NULL pointer dereference when invalid num_vls is used

[linux.git] / mm / page-writeback.c

diff --git a/mm/page-writeback.c b/mm/page-writeback.c
index 586f31261c8328e30106254e09e52fa6e93f410e..5c1a3279e63f865664bafcaf4d3c7f98af697cce 100644 (file)
--- a/mm/page-writeback.c
+++ b/mm/page-writeback.c
@@ -2099,7 +2099,8 @@ void __init page_writeback_init(void)
  * so that it can tag pages faster than a dirtying process can create them).
  */
 /*
- * We tag pages in batches of WRITEBACK_TAG_BATCH to reduce tree_lock latency.
+ * We tag pages in batches of WRITEBACK_TAG_BATCH to reduce the i_pages lock
+ * latency.
  */
 void tag_pages_for_writeback(struct address_space *mapping,
                             pgoff_t start, pgoff_t end)
@@ -2109,22 +2110,22 @@ void tag_pages_for_writeback(struct address_space *mapping,
        struct radix_tree_iter iter;
        void **slot;
 
-       spin_lock_irq(&mapping->tree_lock);
-       radix_tree_for_each_tagged(slot, &mapping->page_tree, &iter, start,
+       xa_lock_irq(&mapping->i_pages);
+       radix_tree_for_each_tagged(slot, &mapping->i_pages, &iter, start,
                                                        PAGECACHE_TAG_DIRTY) {
                if (iter.index > end)
                        break;
-               radix_tree_iter_tag_set(&mapping->page_tree, &iter,
+               radix_tree_iter_tag_set(&mapping->i_pages, &iter,
                                                        PAGECACHE_TAG_TOWRITE);
                tagged++;
                if ((tagged % WRITEBACK_TAG_BATCH) != 0)
                        continue;
                slot = radix_tree_iter_resume(slot, &iter);
-               spin_unlock_irq(&mapping->tree_lock);
+               xa_unlock_irq(&mapping->i_pages);
                cond_resched();
-               spin_lock_irq(&mapping->tree_lock);
+               xa_lock_irq(&mapping->i_pages);
        }
-       spin_unlock_irq(&mapping->tree_lock);
+       xa_unlock_irq(&mapping->i_pages);
 }
 EXPORT_SYMBOL(tag_pages_for_writeback);
 
@@ -2467,13 +2468,13 @@ int __set_page_dirty_nobuffers(struct page *page)
                        return 1;
                }
 
-               spin_lock_irqsave(&mapping->tree_lock, flags);
+               xa_lock_irqsave(&mapping->i_pages, flags);
                BUG_ON(page_mapping(page) != mapping);
                WARN_ON_ONCE(!PagePrivate(page) && !PageUptodate(page));
                account_page_dirtied(page, mapping);
-               radix_tree_tag_set(&mapping->page_tree, page_index(page),
+               radix_tree_tag_set(&mapping->i_pages, page_index(page),
                                   PAGECACHE_TAG_DIRTY);
-               spin_unlock_irqrestore(&mapping->tree_lock, flags);
+               xa_unlock_irqrestore(&mapping->i_pages, flags);
                unlock_page_memcg(page);
 
                if (mapping->host) {
@@ -2718,11 +2719,10 @@ int test_clear_page_writeback(struct page *page)
                struct backing_dev_info *bdi = inode_to_bdi(inode);
                unsigned long flags;
 
-               spin_lock_irqsave(&mapping->tree_lock, flags);
+               xa_lock_irqsave(&mapping->i_pages, flags);
                ret = TestClearPageWriteback(page);
                if (ret) {
-                       radix_tree_tag_clear(&mapping->page_tree,
-                                               page_index(page),
+                       radix_tree_tag_clear(&mapping->i_pages, page_index(page),
                                                PAGECACHE_TAG_WRITEBACK);
                        if (bdi_cap_account_writeback(bdi)) {
                                struct bdi_writeback *wb = inode_to_wb(inode);
@@ -2736,7 +2736,7 @@ int test_clear_page_writeback(struct page *page)
                                                     PAGECACHE_TAG_WRITEBACK))
                        sb_clear_inode_writeback(mapping->host);
 
-               spin_unlock_irqrestore(&mapping->tree_lock, flags);
+               xa_unlock_irqrestore(&mapping->i_pages, flags);
        } else {
                ret = TestClearPageWriteback(page);
        }
@@ -2766,7 +2766,7 @@ int __test_set_page_writeback(struct page *page, bool keep_write)
                struct backing_dev_info *bdi = inode_to_bdi(inode);
                unsigned long flags;
 
-               spin_lock_irqsave(&mapping->tree_lock, flags);
+               xa_lock_irqsave(&mapping->i_pages, flags);
                ret = TestSetPageWriteback(page);
                if (!ret) {
                        bool on_wblist;
@@ -2774,8 +2774,7 @@ int __test_set_page_writeback(struct page *page, bool keep_write)
                        on_wblist = mapping_tagged(mapping,
                                                   PAGECACHE_TAG_WRITEBACK);
 
-                       radix_tree_tag_set(&mapping->page_tree,
-                                               page_index(page),
+                       radix_tree_tag_set(&mapping->i_pages, page_index(page),
                                                PAGECACHE_TAG_WRITEBACK);
                        if (bdi_cap_account_writeback(bdi))
                                inc_wb_stat(inode_to_wb(inode), WB_WRITEBACK);
@@ -2789,14 +2788,12 @@ int __test_set_page_writeback(struct page *page, bool keep_write)
                                sb_mark_inode_writeback(mapping->host);
                }
                if (!PageDirty(page))
-                       radix_tree_tag_clear(&mapping->page_tree,
-                                               page_index(page),
+                       radix_tree_tag_clear(&mapping->i_pages, page_index(page),
                                                PAGECACHE_TAG_DIRTY);
                if (!keep_write)
-                       radix_tree_tag_clear(&mapping->page_tree,
-                                               page_index(page),
+                       radix_tree_tag_clear(&mapping->i_pages, page_index(page),
                                                PAGECACHE_TAG_TOWRITE);
-               spin_unlock_irqrestore(&mapping->tree_lock, flags);
+               xa_unlock_irqrestore(&mapping->i_pages, flags);
        } else {
                ret = TestSetPageWriteback(page);
        }
@@ -2816,7 +2813,7 @@ EXPORT_SYMBOL(__test_set_page_writeback);
  */
 int mapping_tagged(struct address_space *mapping, int tag)
 {
-       return radix_tree_tagged(&mapping->page_tree, tag);
+       return radix_tree_tagged(&mapping->i_pages, tag);
 }
 EXPORT_SYMBOL(mapping_tagged);