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

"post_handler," if any, that is associated with the kprobe.

Execution then continues with the instruction following the probepoint.

Changing Execution Path

-----------------------

Since kprobes can probe into a running kernel code, it can change the

register set, including instruction pointer. This operation requires

maximum care, such as keeping the stack frame, recovering the execution

path etc. Since it operates on a running kernel and needs deep knowledge

of computer architecture and concurrent computing, you can easily shoot

your foot.

If you change the instruction pointer (and set up other related

registers) in pre_handler, you must return !0 so that kprobes stops

single stepping and just returns to the given address.

This also means post_handler should not be called anymore.

Note that this operation may be harder on some architectures which use

TOC (Table of Contents) for function call, since you have to setup a new

TOC for your function in your module, and recover the old one after

returning from it.

Return Probes

-------------

tweak the kernel's execution path, you need to suppress optimization,

using one of the following techniques:

- Specify an empty function for the kprobe's post_handler or break_handler.

- Specify an empty function for the kprobe's post_handler.

or

the bad probe, are safely unregistered before the register_*probes

function returns.

- kps/rps/jps: an array of pointers to ``*probe`` data structures

- kps/rps: an array of pointers to ``*probe`` data structures

- num: the number of the array entries.

.. note::

Kprobes does not use mutexes or allocate memory except during

registration and unregistration.

Probe handlers are run with preemption disabled.  Depending on the

architecture and optimization state, handlers may also run with

interrupts disabled (e.g., kretprobe handlers and optimized kprobe

handlers run without interrupt disabled on x86/x86-64).  In any case,

your handler should not yield the CPU (e.g., by attempting to acquire

a semaphore).

Probe handlers are run with preemption disabled or interrupt disabled,

which depends on the architecture and optimization state.  (e.g.,

kretprobe handlers and optimized kprobe handlers run without interrupt

disabled on x86/x86-64).  In any case, your handler should not yield

the CPU (e.g., by attempting to acquire a semaphore, or waiting I/O).

Since a return probe is implemented by replacing the return

address with the trampoline's address, stack backtraces and calls

struct kprobe_ctlblk {

	unsigned int kprobe_status;

	struct pt_regs jprobe_saved_regs;

	char jprobes_stack[MAX_STACK_SIZE];

	struct prev_kprobe prev_kprobe;

};

		/* If we have no pre-handler or it returned 0, we continue with

		 * normal processing. If we have a pre-handler and it returned

		 * non-zero - which is expected from setjmp_pre_handler for

		 * jprobe, we return without single stepping and leave that to

		 * the break-handler which is invoked by a kprobe from

		 * jprobe_return

		 * non-zero - which means user handler setup registers to exit

		 * to another instruction, we must skip the single stepping.

		 */

		if (!p->pre_handler || !p->pre_handler(p, regs)) {

			setup_singlestep(p, regs);

			kcb->kprobe_status = KPROBE_HIT_SS;

		} else {

			reset_current_kprobe();

			preempt_enable_no_resched();

		}

		return 1;

	} else if (kprobe_running()) {

		p = __this_cpu_read(current_kprobe);

		if (p->break_handler && p->break_handler(p, regs)) {

			setup_singlestep(p, regs);

			kcb->kprobe_status = KPROBE_HIT_SS;

			return 1;

		}

	}

	/* no_kprobe: */

	return ret;

}

int __kprobes setjmp_pre_handler(struct kprobe *p, struct pt_regs *regs)

{

	struct jprobe *jp = container_of(p, struct jprobe, kp);

	struct kprobe_ctlblk *kcb = get_kprobe_ctlblk();

	unsigned long sp_addr = regs->sp;

	kcb->jprobe_saved_regs = *regs;

	memcpy(kcb->jprobes_stack, (void *)sp_addr, MIN_STACK_SIZE(sp_addr));

	regs->ret = (unsigned long)(jp->entry);

	return 1;

}

void __kprobes jprobe_return(void)

{

	__asm__ __volatile__("unimp_s");

	return;

}

int __kprobes longjmp_break_handler(struct kprobe *p, struct pt_regs *regs)

{

	struct kprobe_ctlblk *kcb = get_kprobe_ctlblk();

	unsigned long sp_addr;

	*regs = kcb->jprobe_saved_regs;

	sp_addr = regs->sp;

	memcpy((void *)sp_addr, kcb->jprobes_stack, MIN_STACK_SIZE(sp_addr));

	preempt_enable_no_resched();

	return 1;

}

static void __used kretprobe_trampoline_holder(void)

{

	__asm__ __volatile__(".global kretprobe_trampoline\n"

	kretprobe_assert(ri, orig_ret_address, trampoline_address);

	regs->ret = orig_ret_address;

	reset_current_kprobe();

	kretprobe_hash_unlock(current, &flags);

	preempt_enable_no_resched();

	hlist_for_each_entry_safe(ri, tmp, &empty_rp, hlist) {

		hlist_del(&ri->hlist);

	asm volatile("mcr p14, 0, %0, " #N "," #M ", " #OP2 : : "r" (VAL));\

} while (0)

struct perf_event_attr;

struct notifier_block;

struct perf_event;

struct pmu;

extern int arch_bp_generic_fields(struct arch_hw_breakpoint_ctrl ctrl,

				  int *gen_len, int *gen_type);

extern int arch_check_bp_in_kernelspace(struct perf_event *bp);

extern int arch_validate_hwbkpt_settings(struct perf_event *bp);

extern int arch_check_bp_in_kernelspace(struct arch_hw_breakpoint *hw);

extern int hw_breakpoint_arch_parse(struct perf_event *bp,

				    const struct perf_event_attr *attr,

				    struct arch_hw_breakpoint *hw);

extern int hw_breakpoint_exceptions_notify(struct notifier_block *unused,

					   unsigned long val, void *data);

struct kprobe_ctlblk {

	unsigned int kprobe_status;

	struct prev_kprobe prev_kprobe;

	struct pt_regs jprobe_saved_regs;

	char jprobes_stack[MAX_STACK_SIZE];

};

void arch_remove_kprobe(struct kprobe *);