3 files changed, 18 insertions, 15 deletions

diff --git a/arch/arm/kernel/entry-common.S b/arch/arm/kernel/entry-common.S
index f8ccc21fa032..4e7f40c577e6 100644
--- a/arch/arm/kernel/entry-common.S
+++ b/arch/arm/kernel/entry-common.S
@@ -33,7 +33,9 @@ ret_fast_syscall:
  UNWIND(.fnstart        )
  UNWIND(.cantunwind     )
         disable_irq                             @ disable interrupts
-        ldr     r1, [tsk, #TI_FLAGS]
+        ldr     r1, [tsk, #TI_FLAGS]            @ re-check for syscall tracing
+        tst     r1, #_TIF_SYSCALL_WORK
+        bne     __sys_trace_return
         tst     r1, #_TIF_WORK_MASK
         bne     fast_work_pending
         asm_trace_hardirqs_on
diff --git a/arch/arm/kernel/perf_event_cpu.c b/arch/arm/kernel/perf_event_cpu.c
index 213919ba326f..3b8c2833c537 100644
--- a/arch/arm/kernel/perf_event_cpu.c
+++ b/arch/arm/kernel/perf_event_cpu.c
@@ -304,16 +304,17 @@ static int probe_current_pmu(struct arm_pmu *pmu)
 static int of_pmu_irq_cfg(struct platform_device *pdev)
 {
         int i, irq;
-        int *irqs = kcalloc(pdev->num_resources, sizeof(*irqs), GFP_KERNEL);
-
-        if (!irqs)
-                return -ENOMEM;
+        int *irqs;
 
         /* Don't bother with PPIs; they're already affine */
         irq = platform_get_irq(pdev, 0);
         if (irq >= 0 && irq_is_percpu(irq))
                 return 0;
 
+        irqs = kcalloc(pdev->num_resources, sizeof(*irqs), GFP_KERNEL);
+        if (!irqs)
+                return -ENOMEM;
+
         for (i = 0; i < pdev->num_resources; ++i) {
                 struct device_node *dn;
                 int cpu;
diff --git a/arch/arm/mm/mmu.c b/arch/arm/mm/mmu.c
index 4e6ef896c619..7186382672b5 100644
--- a/arch/arm/mm/mmu.c
+++ b/arch/arm/mm/mmu.c
@@ -1112,22 +1112,22 @@ void __init sanity_check_meminfo(void)
                         }
 
                         /*
-                         * Find the first non-section-aligned page, and point
+                         * Find the first non-pmd-aligned page, and point
                          * memblock_limit at it. This relies on rounding the
-                         * limit down to be section-aligned, which happens at
-                         * the end of this function.
+                         * limit down to be pmd-aligned, which happens at the
+                         * end of this function.
                          *
                          * With this algorithm, the start or end of almost any
-                         * bank can be non-section-aligned. The only exception
-                         * is that the start of the bank 0 must be section-
+                         * bank can be non-pmd-aligned. The only exception is
+                         * that the start of the bank 0 must be section-
                          * aligned, since otherwise memory would need to be
                          * allocated when mapping the start of bank 0, which
                          * occurs before any free memory is mapped.
                          */
                         if (!memblock_limit) {
-                                if (!IS_ALIGNED(block_start, SECTION_SIZE))
+                                if (!IS_ALIGNED(block_start, PMD_SIZE))
                                         memblock_limit = block_start;
-                                else if (!IS_ALIGNED(block_end, SECTION_SIZE))
+                                else if (!IS_ALIGNED(block_end, PMD_SIZE))
                                         memblock_limit = arm_lowmem_limit;
                         }
 
@@ -1137,12 +1137,12 @@ void __init sanity_check_meminfo(void)
         high_memory = __va(arm_lowmem_limit - 1) + 1;
 
         /*
-         * Round the memblock limit down to a section size.  This
+         * Round the memblock limit down to a pmd size.  This
          * helps to ensure that we will allocate memory from the
-         * last full section, which should be mapped.
+         * last full pmd, which should be mapped.
          */
         if (memblock_limit)
-                memblock_limit = round_down(memblock_limit, SECTION_SIZE);
+                memblock_limit = round_down(memblock_limit, PMD_SIZE);
         if (!memblock_limit)
                 memblock_limit = arm_lowmem_limit;