litmus-rt-ext-res.git - LITMUS^RT with extended reservations for Forbidden Zones paper @ RTAS'20

diff options

author	Miroslav Benes <mbenes@suse.cz>	2017-05-26 08:45:21 -0400
committer	Jiri Kosina <jkosina@suse.cz>	2017-05-26 18:27:37 -0400
commit	5720acf4bfc142ba568d5b6782fceaf62ed15e0b (patch)
tree	1710c0e1717f88eb51d7c6536e357de89f6b076c /tools/perf/scripts/python/sched-migration.py
parent	76f1948a79b26d5f57a5ee9941876b745c6baaea (diff)

livepatch: Make livepatch dependent on !TRIM_UNUSED_KSYMS

If TRIM_UNUSED_KSYMS is enabled, all unneeded exported symbols are made unexported. Two-pass build of the kernel is done to find out which symbols are needed based on a configuration. This effectively complicates things for out-of-tree modules. Livepatch exports functions to (un)register and enable/disable a live patch. The only in-tree module which uses these functions is a sample in samples/livepatch/. If the sample is disabled, the functions are trimmed and out-of-tree live patches cannot be built. Note that live patches are intended to be built out-of-tree. Suggested-by: Michal Marek <mmarek@suse.com> Acked-by: Josh Poimboeuf <jpoimboe@redhat.com> Acked-by: Jessica Yu <jeyu@redhat.com> Signed-off-by: Miroslav Benes <mbenes@suse.cz> Signed-off-by: Jiri Kosina <jkosina@suse.cz>

Diffstat (limited to 'tools/perf/scripts/python/sched-migration.py')

0 files changed, 0 insertions, 0 deletions

/* * Ftrace header. For implementation details beyond the random comments * scattered below, see: Documentation/trace/ftrace-design.txt */ #ifndef _LINUX_FTRACE_H #define _LINUX_FTRACE_H #include <linux/trace_clock.h> #include <linux/kallsyms.h> #include <linux/linkage.h> #include <linux/bitops.h> #include <linux/ptrace.h> #include <linux/ktime.h> #include <linux/sched.h> #include <linux/types.h> #include <linux/init.h> #include <linux/fs.h> #include <asm/ftrace.h> /* * If the arch supports passing the variable contents of * function_trace_op as the third parameter back from the * mcount call, then the arch should define this as 1. */ #ifndef ARCH_SUPPORTS_FTRACE_OPS #define ARCH_SUPPORTS_FTRACE_OPS 0 #endif /* * If the arch's mcount caller does not support all of ftrace's * features, then it must call an indirect function that * does. Or at least does enough to prevent any unwelcomed side effects. */ #if !defined(CONFIG_HAVE_FUNCTION_TRACE_MCOUNT_TEST) || \ !ARCH_SUPPORTS_FTRACE_OPS # define FTRACE_FORCE_LIST_FUNC 1 #else # define FTRACE_FORCE_LIST_FUNC 0 #endif struct module; struct ftrace_hash; #ifdef CONFIG_FUNCTION_TRACER extern int ftrace_enabled; extern int ftrace_enable_sysctl(struct ctl_table *table, int write, void __user *buffer, size_t *lenp, loff_t *ppos); struct ftrace_ops; typedef void (*ftrace_func_t)(unsigned long ip, unsigned long parent_ip, struct ftrace_ops *op, struct pt_regs *regs); /* * FTRACE_OPS_FL_* bits denote the state of ftrace_ops struct and are * set in the flags member. * * ENABLED - set/unset when ftrace_ops is registered/unregistered * GLOBAL - set manualy by ftrace_ops user to denote the ftrace_ops * is part of the global tracers sharing the same filter * via set_ftrace_* debugfs files. * DYNAMIC - set when ftrace_ops is registered to denote dynamically * allocated ftrace_ops which need special care * CONTROL - set manualy by ftrace_ops user to denote the ftrace_ops * could be controled by following calls: * ftrace_function_local_enable * ftrace_function_local_disable * SAVE_REGS - The ftrace_ops wants regs saved at each function called * and passed to the callback. If this flag is set, but the * architecture does not support passing regs * (ARCH_SUPPORTS_FTRACE_SAVE_REGS is not defined), then the * ftrace_ops will fail to register, unless the next flag * is set. * SAVE_REGS_IF_SUPPORTED - This is the same as SAVE_REGS, but if the * handler can handle an arch that does not save regs * (the handler tests if regs == NULL), then it can set * this flag instead. It will not fail registering the ftrace_ops * but, the regs field will be NULL if the arch does not support * passing regs to the handler. * Note, if this flag is set, the SAVE_REGS flag will automatically * get set upon registering the ftrace_ops, if the arch supports it. * RECURSION_SAFE - The ftrace_ops can set this to tell the ftrace infrastructure * that the call back has its own recursion protection. If it does * not set this, then the ftrace infrastructure will add recursion * protection for the caller. */ enum { FTRACE_OPS_FL_ENABLED = 1 << 0, FTRACE_OPS_FL_GLOBAL = 1 << 1, FTRACE_OPS_FL_DYNAMIC = 1 << 2, FTRACE_OPS_FL_CONTROL = 1 << 3, FTRACE_OPS_FL_SAVE_REGS = 1 << 4, FTRACE_OPS_FL_SAVE_REGS_IF_SUPPORTED = 1 << 5, FTRACE_OPS_FL_RECURSION_SAFE = 1 << 6, }; struct ftrace_ops { ftrace_func_t func; struct ftrace_ops *next; unsigned long flags; int __percpu *disabled; #ifdef CONFIG_DYNAMIC_FTRACE struct ftrace_hash *notrace_hash; struct ftrace_hash *filter_hash; #endif }; extern int function_trace_stop; /* * Type of the current tracing. */ enum ftrace_tracing_type_t { FTRACE_TYPE_ENTER = 0, /* Hook the call of the function */ FTRACE_TYPE_RETURN, /* Hook the return of the function */ }; /* Current tracing type, default is FTRACE_TYPE_ENTER */ extern enum ftrace_tracing_type_t ftrace_tracing_type; /** * ftrace_stop - stop function tracer. * * A quick way to stop the function tracer. Note this an on off switch, * it is not something that is recursive like preempt_disable. * This does not disable the calling of mcount, it only stops the * calling of functions from mcount. */ static inline void ftrace_stop(void) { function_trace_stop = 1; } /** * ftrace_start - start the function tracer. * * This function is the inverse of ftrace_stop. This does not enable * the function tracing if the function tracer is disabled. This only * sets the function tracer flag to continue calling the functions * from mcount. */ static inline void ftrace_start(void) { function_trace_stop = 0; } /* * The ftrace_ops must be a static and should also * be read_mostly. These functions do modify read_mostly variables * so use them sparely. Never free an ftrace_op or modify the * next pointer after it has been registered. Even after unregistering * it, the next pointer may still be used internally. */ int register_ftrace_function(struct ftrace_ops *ops); int unregister_ftrace_function(struct ftrace_ops *ops); void clear_ftrace_function(void); /** * ftrace_function_local_enable - enable controlled ftrace_ops on current cpu * * This function enables tracing on current cpu by decreasing * the per cpu control variable. * It must be called with preemption disabled and only on ftrace_ops * registered with FTRACE_OPS_FL_CONTROL. If called without preemption * disabled, this_cpu_ptr will complain when CONFIG_DEBUG_PREEMPT is enabled. */ static inline void ftrace_function_local_enable(struct ftrace_ops *ops) { if (WARN_ON_ONCE(!(ops->flags & FTRACE_OPS_FL_CONTROL))) return; (*this_cpu_ptr(ops->disabled))--; } /** * ftrace_function_local_disable - enable controlled ftrace_ops on current cpu * * This function enables tracing on current cpu by decreasing * the per cpu control variable. * It must be called with preemption disabled and only on ftrace_ops * registered with FTRACE_OPS_FL_CONTROL. If called without preemption * disabled, this_cpu_ptr will complain when CONFIG_DEBUG_PREEMPT is enabled. */ static inline void ftrace_function_local_disable(struct ftrace_ops *ops) { if (WARN_ON_ONCE(!(ops->flags & FTRACE_OPS_FL_CONTROL))) return; (*this_cpu_ptr(ops->disabled))++; } /** * ftrace_function_local_disabled - returns ftrace_ops disabled value * on current cpu * * This function returns value of ftrace_ops::disabled on current cpu. * It must be called with preemption disabled and only on ftrace_ops * registered with FTRACE_OPS_FL_CONTROL. If called without preemption * disabled, this_cpu_ptr will complain when CONFIG_DEBUG_PREEMPT is enabled. */ static inline int ftrace_function_local_disabled(struct ftrace_ops *ops) { WARN_ON_ONCE(!(ops->flags & FTRACE_OPS_FL_CONTROL)); return *this_cpu_ptr(ops->disabled); } extern void ftrace_stub(unsigned long a0, unsigned long a1, struct ftrace_ops *op, struct pt_regs *regs); #else /* !CONFIG_FUNCTION_TRACER */ /* * (un)register_ftrace_function must be a macro since the ops parameter * must not be evaluated. */ #define register_ftrace_function(ops) ({ 0; }) #define unregister_ftrace_function(ops) ({ 0; }) static inline int ftrace_nr_registered_ops(void) { return 0; } static inline void clear_ftrace_function(void) { } static inline void ftrace_kill(void) { } static inline void ftrace_stop(void) { } static inline void ftrace_start(void) { } #endif /* CONFIG_FUNCTION_TRACER */ #ifdef CONFIG_STACK_TRACER extern int stack_tracer_enabled; int stack_trace_sysctl(struct ctl_table *table, int write, void __user *buffer, size_t *lenp, loff_t *ppos); #endif struct ftrace_func_command { struct list_head list; char *name; int (*func)(struct ftrace_hash *hash, char *func, char *cmd, char *params, int enable); }; #ifdef CONFIG_DYNAMIC_FTRACE int ftrace_arch_code_modify_prepare(void); int ftrace_arch_code_modify_post_process(void); void ftrace_bug(int err, unsigned long ip); struct seq_file; struct ftrace_probe_ops { void (*func)(unsigned long ip, unsigned long parent_ip, void **data); int (*callback)(unsigned long ip, void **data); void (*free)(void **data); int (*print)(struct seq_file *m, unsigned long ip, struct ftrace_probe_ops *ops, void *data); }; extern int register_ftrace_function_probe(char *glob, struct ftrace_probe_ops *ops, void *data); extern void unregister_ftrace_function_probe(char *glob, struct ftrace_probe_ops *ops, void *data); extern void unregister_ftrace_function_probe_func(char *glob, struct ftrace_probe_ops *ops); extern void unregister_ftrace_function_probe_all(char *glob); extern int ftrace_text_reserved(void *start, void *end); extern int ftrace_nr_registered_ops(void); /* * The dyn_ftrace record's flags field is split into two parts. * the first part which is '0-FTRACE_REF_MAX' is a counter of


context:
space:
mode: