Merge tag 'v3.8-rc3' into v4l_for_linus

Linux 3.8-rc3

* tag 'v3.8-rc3': (11110 commits)
  Linux 3.8-rc3
  mm: reinstante dropped pmd_trans_splitting() check
  cred: Remove tgcred pointer from struct cred
  drm/ttm: fix fence locking in ttm_buffer_object_transfer
  ARM: clps711x: Fix bad merge of clockevents setup
  ARM: highbank: save and restore L2 cache and GIC on suspend
  ARM: highbank: add a power request clear
  ARM: highbank: fix secondary boot and hotplug
  ARM: highbank: fix typos with hignbank in power request functions
  ARM: dts: fix highbank cpu mpidr values
  ARM: dts: add device_type prop to cpu nodes on Calxeda platforms
  drm/prime: drop reference on imported dma-buf come from gem
  xen/netfront: improve truesize tracking
  ARM: mx5: Fix MX53 flexcan2 clock
  ARM: OMAP2+: am33xx-hwmod: Fix wrongly terminated am33xx_usbss_mpu_irqs array
  sctp: fix Kconfig bug in default cookie hmac selection
  EDAC: Cleanup device deregistering path
  EDAC: Fix EDAC Kconfig menu
  EDAC: Fix kernel panic on module unloading
  ALSA: hda - add mute LED for HP Pavilion 17 (Realtek codec)
  ...

1 files changed, 34 insertions, 29 deletions

diff --git a/mm/hugetlb.c b/mm/hugetlb.c
index 59a0059b39e2..4f3ea0b1e57c 100644
--- a/mm/hugetlb.c
+++ b/mm/hugetlb.c
@@ -1,6 +1,6 @@
 /*
  * Generic hugetlb support.
- * (C) William Irwin, April 2004
+ * (C) Nadia Yvette Chambers, April 2004
  */
 #include <linux/list.h>
 #include <linux/init.h>
@@ -1057,7 +1057,7 @@ static void return_unused_surplus_pages(struct hstate *h,
          * on-line nodes with memory and will handle the hstate accounting.
          */
         while (nr_pages--) {
-                if (!free_pool_huge_page(h, &node_states[N_HIGH_MEMORY], 1))
+                if (!free_pool_huge_page(h, &node_states[N_MEMORY], 1))
                         break;
         }
 }
@@ -1180,14 +1180,14 @@ static struct page *alloc_huge_page(struct vm_area_struct *vma,
 int __weak alloc_bootmem_huge_page(struct hstate *h)
 {
         struct huge_bootmem_page *m;
-        int nr_nodes = nodes_weight(node_states[N_HIGH_MEMORY]);
+        int nr_nodes = nodes_weight(node_states[N_MEMORY]);
 
         while (nr_nodes) {
                 void *addr;
 
                 addr = __alloc_bootmem_node_nopanic(
                                 NODE_DATA(hstate_next_node_to_alloc(h,
-                                                &node_states[N_HIGH_MEMORY])),
+                                                &node_states[N_MEMORY])),
                                 huge_page_size(h), huge_page_size(h), 0);
 
                 if (addr) {
@@ -1259,7 +1259,7 @@ static void __init hugetlb_hstate_alloc_pages(struct hstate *h)
                         if (!alloc_bootmem_huge_page(h))
                                 break;
                 } else if (!alloc_fresh_huge_page(h,
-                                         &node_states[N_HIGH_MEMORY]))
+                                         &node_states[N_MEMORY]))
                         break;
         }
         h->max_huge_pages = i;
@@ -1527,7 +1527,7 @@ static ssize_t nr_hugepages_store_common(bool obey_mempolicy,
                 if (!(obey_mempolicy &&
                                 init_nodemask_of_mempolicy(nodes_allowed))) {
                         NODEMASK_FREE(nodes_allowed);
-                        nodes_allowed = &node_states[N_HIGH_MEMORY];
+                        nodes_allowed = &node_states[N_MEMORY];
                 }
         } else if (nodes_allowed) {
                 /*
@@ -1537,11 +1537,11 @@ static ssize_t nr_hugepages_store_common(bool obey_mempolicy,
                 count += h->nr_huge_pages - h->nr_huge_pages_node[nid];
                 init_nodemask_of_node(nodes_allowed, nid);
         } else
-                nodes_allowed = &node_states[N_HIGH_MEMORY];
+                nodes_allowed = &node_states[N_MEMORY];
 
         h->max_huge_pages = set_max_huge_pages(h, count, nodes_allowed);
 
-        if (nodes_allowed != &node_states[N_HIGH_MEMORY])
+        if (nodes_allowed != &node_states[N_MEMORY])
                 NODEMASK_FREE(nodes_allowed);
 
         return len;
@@ -1800,7 +1800,7 @@ static void hugetlb_unregister_all_nodes(void)
          * remove hstate attributes from any nodes that have them.
          */
         for (nid = 0; nid < nr_node_ids; nid++)
-                hugetlb_unregister_node(&node_devices[nid]);
+                hugetlb_unregister_node(node_devices[nid]);
 }
 
 /*
@@ -1844,8 +1844,8 @@ static void hugetlb_register_all_nodes(void)
 {
         int nid;
 
-        for_each_node_state(nid, N_HIGH_MEMORY) {
-                struct node *node = &node_devices[nid];
+        for_each_node_state(nid, N_MEMORY) {
+                struct node *node = node_devices[nid];
                 if (node->dev.id == nid)
                         hugetlb_register_node(node);
         }
@@ -1906,14 +1906,12 @@ static int __init hugetlb_init(void)
                 default_hstate.max_huge_pages = default_hstate_max_huge_pages;
 
         hugetlb_init_hstates();
-
         gather_bootmem_prealloc();
-
         report_hugepages();
 
         hugetlb_sysfs_init();
-
         hugetlb_register_all_nodes();
+        hugetlb_cgroup_file_init();
 
         return 0;
 }
@@ -1939,17 +1937,10 @@ void __init hugetlb_add_hstate(unsigned order)
         for (i = 0; i < MAX_NUMNODES; ++i)
                 INIT_LIST_HEAD(&h->hugepage_freelists[i]);
         INIT_LIST_HEAD(&h->hugepage_activelist);
-        h->next_nid_to_alloc = first_node(node_states[N_HIGH_MEMORY]);
-        h->next_nid_to_free = first_node(node_states[N_HIGH_MEMORY]);
+        h->next_nid_to_alloc = first_node(node_states[N_MEMORY]);
+        h->next_nid_to_free = first_node(node_states[N_MEMORY]);
         snprintf(h->name, HSTATE_NAME_LEN, "hugepages-%lukB",
                                         huge_page_size(h)/1024);
-        /*
-         * Add cgroup control files only if the huge page consists
-         * of more than two normal pages. This is because we use
-         * page[2].lru.next for storing cgoup details.
-         */
-        if (order >= HUGETLB_CGROUP_MIN_ORDER)
-                hugetlb_cgroup_file_init(hugetlb_max_hstate - 1);
 
         parsed_hstate = h;
 }
@@ -2035,11 +2026,11 @@ static int hugetlb_sysctl_handler_common(bool obey_mempolicy,
                 if (!(obey_mempolicy &&
                                init_nodemask_of_mempolicy(nodes_allowed))) {
                         NODEMASK_FREE(nodes_allowed);
-                        nodes_allowed = &node_states[N_HIGH_MEMORY];
+                        nodes_allowed = &node_states[N_MEMORY];
                 }
                 h->max_huge_pages = set_max_huge_pages(h, tmp, nodes_allowed);
 
-                if (nodes_allowed != &node_states[N_HIGH_MEMORY])
+                if (nodes_allowed != &node_states[N_MEMORY])
                         NODEMASK_FREE(nodes_allowed);
         }
 out:
@@ -2386,8 +2377,10 @@ again:
                 /*
                  * HWPoisoned hugepage is already unmapped and dropped reference
                  */
-                if (unlikely(is_hugetlb_entry_hwpoisoned(pte)))
+                if (unlikely(is_hugetlb_entry_hwpoisoned(pte))) {
+                        pte_clear(mm, address, ptep);
                         continue;
+                }
 
                 page = pte_page(pte);
                 /*
@@ -3014,7 +3007,7 @@ same_page:
         return i ? i : -EFAULT;
 }
 
-void hugetlb_change_protection(struct vm_area_struct *vma,
+unsigned long hugetlb_change_protection(struct vm_area_struct *vma,
                 unsigned long address, unsigned long end, pgprot_t newprot)
 {
         struct mm_struct *mm = vma->vm_mm;
@@ -3022,6 +3015,7 @@ void hugetlb_change_protection(struct vm_area_struct *vma,
         pte_t *ptep;
         pte_t pte;
         struct hstate *h = hstate_vma(vma);
+        unsigned long pages = 0;
 
         BUG_ON(address >= end);
         flush_cache_range(vma, address, end);
@@ -3032,12 +3026,15 @@ void hugetlb_change_protection(struct vm_area_struct *vma,
                 ptep = huge_pte_offset(mm, address);
                 if (!ptep)
                         continue;
-                if (huge_pmd_unshare(mm, &address, ptep))
+                if (huge_pmd_unshare(mm, &address, ptep)) {
+                        pages++;
                         continue;
+                }
                 if (!huge_pte_none(huge_ptep_get(ptep))) {
                         pte = huge_ptep_get_and_clear(mm, address, ptep);
                         pte = pte_mkhuge(pte_modify(pte, newprot));
                         set_huge_pte_at(mm, address, ptep, pte);
+                        pages++;
                 }
         }
         spin_unlock(&mm->page_table_lock);
@@ -3049,6 +3046,8 @@ void hugetlb_change_protection(struct vm_area_struct *vma,
          */
         flush_tlb_range(vma, start, end);
         mutex_unlock(&vma->vm_file->f_mapping->i_mmap_mutex);
+
+        return pages << h->order;
 }
 
 int hugetlb_reserve_pages(struct inode *inode,
@@ -3170,7 +3169,13 @@ int dequeue_hwpoisoned_huge_page(struct page *hpage)
 
         spin_lock(&hugetlb_lock);
         if (is_hugepage_on_freelist(hpage)) {
-                list_del(&hpage->lru);
+                /*
+                 * Hwpoisoned hugepage isn't linked to activelist or freelist,
+                 * but dangling hpage->lru can trigger list-debug warnings
+                 * (this happens when we call unpoison_memory() on it),
+                 * so let it point to itself with list_del_init().
+                 */
+                list_del_init(&hpage->lru);
                 set_page_refcounted(hpage);
                 h->free_huge_pages--;
                 h->free_huge_pages_node[nid]--;