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

Pull s390 updates from Martin Schwidefsky:

 - The remaining patches for the z13 machine support: kernel build
   option for z13, the cache synonym avoidance, SMT support,
   compare-and-delay for spinloops and the CES5S crypto adapater.

 - The ftrace support for function tracing with the gcc hotpatch option.
   This touches common code Makefiles, Steven is ok with the changes.

 - The hypfs file system gets an extension to access diagnose 0x0c data
   in user space for performance analysis for Linux running under z/VM.

 - The iucv hvc console gets wildcard spport for the user id filtering.

 - The cacheinfo code is converted to use the generic infrastructure.

 - Cleanup and bug fixes.

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/s390/linux: (42 commits)
  s390/process: free vx save area when releasing tasks
  s390/hypfs: Eliminate hypfs interval
  s390/hypfs: Add diagnose 0c support
  s390/cacheinfo: don't use smp_processor_id() in preemptible context
  s390/zcrypt: fixed domain scanning problem (again)
  s390/smp: increase maximum value of NR_CPUS to 512
  s390/jump label: use different nop instruction
  s390/jump label: add sanity checks
  s390/mm: correct missing space when reporting user process faults
  s390/dasd: cleanup profiling
  s390/dasd: add locking for global_profile access
  s390/ftrace: hotpatch support for function tracing
  ftrace: let notrace function attribute disable hotpatching if necessary
  ftrace: allow architectures to specify ftrace compile options
  s390: reintroduce diag 44 calls for cpu_relax()
  s390/zcrypt: Add support for new crypto express (CEX5S) adapter.
  s390/zcrypt: Number of supported ap domains is not retrievable.
  s390/spinlock: add compare-and-delay to lock wait loops
  s390/tape: remove redundant if statement
  s390/hvc_iucv: add simple wildcard matches to the iucv allow filter
  ...

1 files changed, 62 insertions, 46 deletions

diff --git a/arch/s390/kernel/ftrace.c b/arch/s390/kernel/ftrace.c
index b86bb8823f15..82c19899574f 100644
--- a/arch/s390/kernel/ftrace.c
+++ b/arch/s390/kernel/ftrace.c
@@ -46,6 +46,13 @@
  *      lg      %r14,8(%r15)            # offset 18
  * The jg instruction branches to offset 24 to skip as many instructions
  * as possible.
+ * In case we use gcc's hotpatch feature the original and also the disabled
+ * function prologue contains only a single six byte instruction and looks
+ * like this:
+ * >    brcl    0,0                     # offset 0
+ * To enable ftrace the code gets patched like above and afterwards looks
+ * like this:
+ * >    brasl   %r0,ftrace_caller       # offset 0
  */
 
 unsigned long ftrace_plt;
@@ -59,62 +66,71 @@ int ftrace_modify_call(struct dyn_ftrace *rec, unsigned long old_addr,
 int ftrace_make_nop(struct module *mod, struct dyn_ftrace *rec,
                     unsigned long addr)
 {
-        struct ftrace_insn insn;
-        unsigned short op;
-        void *from, *to;
-        size_t size;
-
-        ftrace_generate_nop_insn(&insn);
-        size = sizeof(insn);
-        from = &insn;
-        to = (void *) rec->ip;
-        if (probe_kernel_read(&op, (void *) rec->ip, sizeof(op)))
+        struct ftrace_insn orig, new, old;
+
+        if (probe_kernel_read(&old, (void *) rec->ip, sizeof(old)))
                 return -EFAULT;
-        /*
-         * If we find a breakpoint instruction, a kprobe has been placed
-         * at the beginning of the function. We write the constant
-         * KPROBE_ON_FTRACE_NOP into the remaining four bytes of the original
-         * instruction so that the kprobes handler can execute a nop, if it
-         * reaches this breakpoint.
-         */
-        if (op == BREAKPOINT_INSTRUCTION) {
-                size -= 2;
-                from += 2;
-                to += 2;
-                insn.disp = KPROBE_ON_FTRACE_NOP;
+        if (addr == MCOUNT_ADDR) {
+                /* Initial code replacement */
+#ifdef CC_USING_HOTPATCH
+                /* We expect to see brcl 0,0 */
+                ftrace_generate_nop_insn(&orig);
+#else
+                /* We expect to see stg r14,8(r15) */
+                orig.opc = 0xe3e0;
+                orig.disp = 0xf0080024;
+#endif
+                ftrace_generate_nop_insn(&new);
+        } else if (old.opc == BREAKPOINT_INSTRUCTION) {
+                /*
+                 * If we find a breakpoint instruction, a kprobe has been
+                 * placed at the beginning of the function. We write the
+                 * constant KPROBE_ON_FTRACE_NOP into the remaining four
+                 * bytes of the original instruction so that the kprobes
+                 * handler can execute a nop, if it reaches this breakpoint.
+                 */
+                new.opc = orig.opc = BREAKPOINT_INSTRUCTION;
+                orig.disp = KPROBE_ON_FTRACE_CALL;
+                new.disp = KPROBE_ON_FTRACE_NOP;
+        } else {
+                /* Replace ftrace call with a nop. */
+                ftrace_generate_call_insn(&orig, rec->ip);
+                ftrace_generate_nop_insn(&new);
         }
-        if (probe_kernel_write(to, from, size))
+        /* Verify that the to be replaced code matches what we expect. */
+        if (memcmp(&orig, &old, sizeof(old)))
+                return -EINVAL;
+        if (probe_kernel_write((void *) rec->ip, &new, sizeof(new)))
                 return -EPERM;
         return 0;
 }
 
 int ftrace_make_call(struct dyn_ftrace *rec, unsigned long addr)
 {
-        struct ftrace_insn insn;
-        unsigned short op;
-        void *from, *to;
-        size_t size;
-
-        ftrace_generate_call_insn(&insn, rec->ip);
-        size = sizeof(insn);
-        from = &insn;
-        to = (void *) rec->ip;
-        if (probe_kernel_read(&op, (void *) rec->ip, sizeof(op)))
+        struct ftrace_insn orig, new, old;
+
+        if (probe_kernel_read(&old, (void *) rec->ip, sizeof(old)))
                 return -EFAULT;
-        /*
-         * If we find a breakpoint instruction, a kprobe has been placed
-         * at the beginning of the function. We write the constant
-         * KPROBE_ON_FTRACE_CALL into the remaining four bytes of the original
-         * instruction so that the kprobes handler can execute a brasl if it
-         * reaches this breakpoint.
-         */
-        if (op == BREAKPOINT_INSTRUCTION) {
-                size -= 2;
-                from += 2;
-                to += 2;
-                insn.disp = KPROBE_ON_FTRACE_CALL;
+        if (old.opc == BREAKPOINT_INSTRUCTION) {
+                /*
+                 * If we find a breakpoint instruction, a kprobe has been
+                 * placed at the beginning of the function. We write the
+                 * constant KPROBE_ON_FTRACE_CALL into the remaining four
+                 * bytes of the original instruction so that the kprobes
+                 * handler can execute a brasl if it reaches this breakpoint.
+                 */
+                new.opc = orig.opc = BREAKPOINT_INSTRUCTION;
+                orig.disp = KPROBE_ON_FTRACE_NOP;
+                new.disp = KPROBE_ON_FTRACE_CALL;
+        } else {
+                /* Replace nop with an ftrace call. */
+                ftrace_generate_nop_insn(&orig);
+                ftrace_generate_call_insn(&new, rec->ip);
         }
-        if (probe_kernel_write(to, from, size))
+        /* Verify that the to be replaced code matches what we expect. */
+        if (memcmp(&orig, &old, sizeof(old)))
+                return -EINVAL;
+        if (probe_kernel_write((void *) rec->ip, &new, sizeof(new)))
                 return -EPERM;
         return 0;
 }