Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mpe/linux

Pull more powerpc updates from Michael Ellerman:
 "Here's some more updates for powerpc for 3.18.

  They are a bit late I know, though must are actually bug fixes.  In my
  defence I nearly cut the top of my finger off last weekend in a
  gruesome bike maintenance accident, so I spent a good part of the week
  waiting around for doctors.  True story, I can send photos if you like :)

  Probably the most interesting fix is the sys_call_table one, which
  enables syscall tracing for powerpc.  There's a fix for HMI handling
  for old firmware, more endian fixes for firmware interfaces, more EEH
  fixes, Anton fixed our routine that gets the current stack pointer,
  and a few other misc bits"

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mpe/linux: (22 commits)
  powerpc: Only do dynamic DMA zone limits on platforms that need it
  powerpc: sync pseries_le_defconfig with pseries_defconfig
  powerpc: Add printk levels to setup_system output
  powerpc/vphn: NUMA node code expects big-endian
  powerpc/msi: Use WARN_ON() in msi bitmap selftests
  powerpc/msi: Fix the msi bitmap alignment tests
  powerpc/eeh: Block CFG upon frozen Shiner adapter
  powerpc/eeh: Don't collect logs on PE with blocked config space
  powerpc/eeh: Block PCI config access upon frozen PE
  powerpc/pseries: Drop config requests in EEH accessors
  powerpc/powernv: Drop config requests in EEH accessors
  powerpc/eeh: Rename flag EEH_PE_RESET to EEH_PE_CFG_BLOCKED
  powerpc/eeh: Fix condition for isolated state
  powerpc/pseries: Make CPU hotplug path endian safe
  powerpc/pseries: Use dump_stack instead of show_stack
  powerpc: Rename __get_SP() to current_stack_pointer()
  powerpc: Reimplement __get_SP() as a function not a define
  powerpc/numa: Add ability to disable and debug topology updates
  powerpc/numa: check error return from proc_create
  powerpc/powernv: Fallback to old HMI handling behavior for old firmware
  ...

1 files changed, 35 insertions, 31 deletions

diff --git a/arch/powerpc/sysdev/msi_bitmap.c b/arch/powerpc/sysdev/msi_bitmap.c
index 0c75214b6f92..73b64c73505b 100644
--- a/arch/powerpc/sysdev/msi_bitmap.c
+++ b/arch/powerpc/sysdev/msi_bitmap.c
@@ -145,59 +145,64 @@ void msi_bitmap_free(struct msi_bitmap *bmp)
 
 #ifdef CONFIG_MSI_BITMAP_SELFTEST
 
-#define check(x)        \
-        if (!(x)) printk("msi_bitmap: test failed at line %d\n", __LINE__);
-
 static void __init test_basics(void)
 {
         struct msi_bitmap bmp;
-        int i, size = 512;
+        int rc, i, size = 512;
 
         /* Can't allocate a bitmap of 0 irqs */
-        check(msi_bitmap_alloc(&bmp, 0, NULL) != 0);
+        WARN_ON(msi_bitmap_alloc(&bmp, 0, NULL) == 0);
 
         /* of_node may be NULL */
-        check(0 == msi_bitmap_alloc(&bmp, size, NULL));
+        WARN_ON(msi_bitmap_alloc(&bmp, size, NULL));
 
         /* Should all be free by default */
-        check(0 == bitmap_find_free_region(bmp.bitmap, size,
-                                           get_count_order(size)));
+        WARN_ON(bitmap_find_free_region(bmp.bitmap, size, get_count_order(size)));
         bitmap_release_region(bmp.bitmap, 0, get_count_order(size));
 
         /* With no node, there's no msi-available-ranges, so expect > 0 */
-        check(msi_bitmap_reserve_dt_hwirqs(&bmp) > 0);
+        WARN_ON(msi_bitmap_reserve_dt_hwirqs(&bmp) <= 0);
 
         /* Should all still be free */
-        check(0 == bitmap_find_free_region(bmp.bitmap, size,
-                                           get_count_order(size)));
+        WARN_ON(bitmap_find_free_region(bmp.bitmap, size, get_count_order(size)));
         bitmap_release_region(bmp.bitmap, 0, get_count_order(size));
 
         /* Check we can fill it up and then no more */
         for (i = 0; i < size; i++)
-                check(msi_bitmap_alloc_hwirqs(&bmp, 1) >= 0);
+                WARN_ON(msi_bitmap_alloc_hwirqs(&bmp, 1) < 0);
 
-        check(msi_bitmap_alloc_hwirqs(&bmp, 1) < 0);
+        WARN_ON(msi_bitmap_alloc_hwirqs(&bmp, 1) >= 0);
 
         /* Should all be allocated */
-        check(bitmap_find_free_region(bmp.bitmap, size, 0) < 0);
+        WARN_ON(bitmap_find_free_region(bmp.bitmap, size, 0) >= 0);
 
         /* And if we free one we can then allocate another */
         msi_bitmap_free_hwirqs(&bmp, size / 2, 1);
-        check(msi_bitmap_alloc_hwirqs(&bmp, 1) == size / 2);
+        WARN_ON(msi_bitmap_alloc_hwirqs(&bmp, 1) != size / 2);
+
+        /* Free most of them for the alignment tests */
+        msi_bitmap_free_hwirqs(&bmp, 3, size - 3);
 
         /* Check we get a naturally aligned offset */
-        check(msi_bitmap_alloc_hwirqs(&bmp, 2) % 2 == 0);
-        check(msi_bitmap_alloc_hwirqs(&bmp, 4) % 4 == 0);
-        check(msi_bitmap_alloc_hwirqs(&bmp, 8) % 8 == 0);
-        check(msi_bitmap_alloc_hwirqs(&bmp, 9) % 16 == 0);
-        check(msi_bitmap_alloc_hwirqs(&bmp, 3) % 4 == 0);
-        check(msi_bitmap_alloc_hwirqs(&bmp, 7) % 8 == 0);
-        check(msi_bitmap_alloc_hwirqs(&bmp, 121) % 128 == 0);
+        rc = msi_bitmap_alloc_hwirqs(&bmp, 2);
+        WARN_ON(rc < 0 && rc % 2 != 0);
+        rc = msi_bitmap_alloc_hwirqs(&bmp, 4);
+        WARN_ON(rc < 0 && rc % 4 != 0);
+        rc = msi_bitmap_alloc_hwirqs(&bmp, 8);
+        WARN_ON(rc < 0 && rc % 8 != 0);
+        rc = msi_bitmap_alloc_hwirqs(&bmp, 9);
+        WARN_ON(rc < 0 && rc % 16 != 0);
+        rc = msi_bitmap_alloc_hwirqs(&bmp, 3);
+        WARN_ON(rc < 0 && rc % 4 != 0);
+        rc = msi_bitmap_alloc_hwirqs(&bmp, 7);
+        WARN_ON(rc < 0 && rc % 8 != 0);
+        rc = msi_bitmap_alloc_hwirqs(&bmp, 121);
+        WARN_ON(rc < 0 && rc % 128 != 0);
 
         msi_bitmap_free(&bmp);
 
-        /* Clients may check bitmap == NULL for "not-allocated" */
-        check(bmp.bitmap == NULL);
+        /* Clients may WARN_ON bitmap == NULL for "not-allocated" */
+        WARN_ON(bmp.bitmap != NULL);
 
         kfree(bmp.bitmap);
 }
@@ -219,14 +224,13 @@ static void __init test_of_node(void)
         of_node_init(&of_node);
         of_node.full_name = node_name;
 
-        check(0 == msi_bitmap_alloc(&bmp, size, &of_node));
+        WARN_ON(msi_bitmap_alloc(&bmp, size, &of_node));
 
         /* No msi-available-ranges, so expect > 0 */
-        check(msi_bitmap_reserve_dt_hwirqs(&bmp) > 0);
+        WARN_ON(msi_bitmap_reserve_dt_hwirqs(&bmp) <= 0);
 
         /* Should all still be free */
-        check(0 == bitmap_find_free_region(bmp.bitmap, size,
-                                           get_count_order(size)));
+        WARN_ON(bitmap_find_free_region(bmp.bitmap, size, get_count_order(size)));
         bitmap_release_region(bmp.bitmap, 0, get_count_order(size));
 
         /* Now create a fake msi-available-ranges property */
@@ -240,11 +244,11 @@ static void __init test_of_node(void)
         of_node.properties = &prop;
 
         /* msi-available-ranges, so expect == 0 */
-        check(msi_bitmap_reserve_dt_hwirqs(&bmp) == 0);
+        WARN_ON(msi_bitmap_reserve_dt_hwirqs(&bmp));
 
         /* Check we got the expected result */
-        check(0 == bitmap_parselist(expected_str, expected, size));
-        check(bitmap_equal(expected, bmp.bitmap, size));
+        WARN_ON(bitmap_parselist(expected_str, expected, size));
+        WARN_ON(!bitmap_equal(expected, bmp.bitmap, size));
 
         msi_bitmap_free(&bmp);
         kfree(bmp.bitmap);