Merge branch 'fixes-2.6.39' into for-2.6.40

8 files changed, 21 insertions, 18 deletions

diff --git a/mm/backing-dev.c b/mm/backing-dev.c
index 8fe9d3407921..0d9a036ada66 100644
--- a/mm/backing-dev.c
+++ b/mm/backing-dev.c
@@ -67,14 +67,14 @@ static int bdi_debug_stats_show(struct seq_file *m, void *v)
         struct inode *inode;
 
         nr_wb = nr_dirty = nr_io = nr_more_io = 0;
-        spin_lock(&inode_lock);
+        spin_lock(&inode_wb_list_lock);
         list_for_each_entry(inode, &wb->b_dirty, i_wb_list)
                 nr_dirty++;
         list_for_each_entry(inode, &wb->b_io, i_wb_list)
                 nr_io++;
         list_for_each_entry(inode, &wb->b_more_io, i_wb_list)
                 nr_more_io++;
-        spin_unlock(&inode_lock);
+        spin_unlock(&inode_wb_list_lock);
 
         global_dirty_limits(&background_thresh, &dirty_thresh);
         bdi_thresh = bdi_dirty_limit(bdi, dirty_thresh);
@@ -676,11 +676,11 @@ void bdi_destroy(struct backing_dev_info *bdi)
         if (bdi_has_dirty_io(bdi)) {
                 struct bdi_writeback *dst = &default_backing_dev_info.wb;
 
-                spin_lock(&inode_lock);
+                spin_lock(&inode_wb_list_lock);
                 list_splice(&bdi->wb.b_dirty, &dst->b_dirty);
                 list_splice(&bdi->wb.b_io, &dst->b_io);
                 list_splice(&bdi->wb.b_more_io, &dst->b_more_io);
-                spin_unlock(&inode_lock);
+                spin_unlock(&inode_wb_list_lock);
         }
 
         bdi_unregister(bdi);
diff --git a/mm/filemap.c b/mm/filemap.c
index 04d1992fd86b..c641edf553a9 100644
--- a/mm/filemap.c
+++ b/mm/filemap.c
@@ -80,8 +80,8 @@
  *  ->i_mutex
  *    ->i_alloc_sem             (various)
  *
- *  ->inode_lock
- *    ->sb_lock                 (fs/fs-writeback.c)
+ *  inode_wb_list_lock
+ *    sb_lock                   (fs/fs-writeback.c)
  *    ->mapping->tree_lock      (__sync_single_inode)
  *
  *  ->i_mmap_lock
@@ -98,8 +98,10 @@
  *    ->zone.lru_lock           (check_pte_range->isolate_lru_page)
  *    ->private_lock            (page_remove_rmap->set_page_dirty)
  *    ->tree_lock               (page_remove_rmap->set_page_dirty)
- *    ->inode_lock              (page_remove_rmap->set_page_dirty)
- *    ->inode_lock              (zap_pte_range->set_page_dirty)
+ *    inode_wb_list_lock        (page_remove_rmap->set_page_dirty)
+ *    ->inode->i_lock           (page_remove_rmap->set_page_dirty)
+ *    inode_wb_list_lock        (zap_pte_range->set_page_dirty)
+ *    ->inode->i_lock           (zap_pte_range->set_page_dirty)
  *    ->private_lock            (zap_pte_range->__set_page_dirty_buffers)
  *
  *  (code doesn't rely on that order, so you could switch it around)
diff --git a/mm/memory.c b/mm/memory.c
index 51a5c23704af..9da8cab1b1b0 100644
--- a/mm/memory.c
+++ b/mm/memory.c
@@ -3715,7 +3715,7 @@ static int __access_remote_vm(struct task_struct *tsk, struct mm_struct *mm,
 }
 
 /**
- * @access_remote_vm - access another process' address space
+ * access_remote_vm - access another process' address space
  * @mm:         the mm_struct of the target address space
  * @addr:       start address to access
  * @buf:        source or destination buffer
diff --git a/mm/oom_kill.c b/mm/oom_kill.c
index 62a5cec08a17..6a819d1b2c7d 100644
--- a/mm/oom_kill.c
+++ b/mm/oom_kill.c
@@ -406,7 +406,7 @@ static void dump_header(struct task_struct *p, gfp_t gfp_mask, int order,
         task_unlock(current);
         dump_stack();
         mem_cgroup_print_oom_info(mem, p);
-        __show_mem(SHOW_MEM_FILTER_NODES);
+        show_mem(SHOW_MEM_FILTER_NODES);
         if (sysctl_oom_dump_tasks)
                 dump_tasks(mem, nodemask);
 }
diff --git a/mm/page_alloc.c b/mm/page_alloc.c
index 8e5726ab0d85..d6e7ba7373be 100644
--- a/mm/page_alloc.c
+++ b/mm/page_alloc.c
@@ -2195,7 +2195,7 @@ nopage:
                         current->comm, order, gfp_mask);
                 dump_stack();
                 if (!should_suppress_show_mem())
-                        __show_mem(filter);
+                        show_mem(filter);
         }
         return page;
 got_pg:
diff --git a/mm/percpu.c b/mm/percpu.c
index c5feb79f5995..8eb536645f68 100644
--- a/mm/percpu.c
+++ b/mm/percpu.c
@@ -1648,8 +1648,8 @@ int __init pcpu_embed_first_chunk(size_t reserved_size, size_t dyn_size,
         /* warn if maximum distance is further than 75% of vmalloc space */
         if (max_distance > (VMALLOC_END - VMALLOC_START) * 3 / 4) {
                 pr_warning("PERCPU: max_distance=0x%zx too large for vmalloc "
-                           "space 0x%lx\n",
-                           max_distance, VMALLOC_END - VMALLOC_START);
+                           "space 0x%lx\n", max_distance,
+                           (unsigned long)(VMALLOC_END - VMALLOC_START));
 #ifdef CONFIG_NEED_PER_CPU_PAGE_FIRST_CHUNK
                 /* and fail if we have fallback */
                 rc = -EINVAL;
diff --git a/mm/rmap.c b/mm/rmap.c
index 4a8e99a0fb97..8da044a1db0f 100644
--- a/mm/rmap.c
+++ b/mm/rmap.c
@@ -31,11 +31,12 @@
  *             swap_lock (in swap_duplicate, swap_info_get)
  *               mmlist_lock (in mmput, drain_mmlist and others)
  *               mapping->private_lock (in __set_page_dirty_buffers)
- *               inode_lock (in set_page_dirty's __mark_inode_dirty)
+ *               inode->i_lock (in set_page_dirty's __mark_inode_dirty)
+ *               inode_wb_list_lock (in set_page_dirty's __mark_inode_dirty)
  *                 sb_lock (within inode_lock in fs/fs-writeback.c)
  *                 mapping->tree_lock (widely used, in set_page_dirty,
  *                           in arch-dependent flush_dcache_mmap_lock,
- *                           within inode_lock in __sync_single_inode)
+ *                           within inode_wb_list_lock in __sync_single_inode)
  *
  * (code doesn't rely on that order so it could be switched around)
  * ->tasklist_lock
diff --git a/mm/slub.c b/mm/slub.c
index 93de30db95f5..f881874843a5 100644
--- a/mm/slub.c
+++ b/mm/slub.c
@@ -849,11 +849,11 @@ static inline void slab_free_hook(struct kmem_cache *s, void *x)
                 local_irq_save(flags);
                 kmemcheck_slab_free(s, x, s->objsize);
                 debug_check_no_locks_freed(x, s->objsize);
-                if (!(s->flags & SLAB_DEBUG_OBJECTS))
-                        debug_check_no_obj_freed(x, s->objsize);
                 local_irq_restore(flags);
         }
 #endif
+        if (!(s->flags & SLAB_DEBUG_OBJECTS))
+                debug_check_no_obj_freed(x, s->objsize);
 }
 
 /*
@@ -1604,7 +1604,7 @@ static inline void note_cmpxchg_failure(const char *n,
 
 void init_kmem_cache_cpus(struct kmem_cache *s)
 {
-#if defined(CONFIG_CMPXCHG_LOCAL) && defined(CONFIG_PREEMPT)
+#ifdef CONFIG_CMPXCHG_LOCAL
         int cpu;
 
         for_each_possible_cpu(cpu)