diff options
Diffstat (limited to 'kernel/trace')
-rw-r--r-- | kernel/trace/ftrace.c | 370 | ||||
-rw-r--r-- | kernel/trace/trace.c | 4 | ||||
-rw-r--r-- | kernel/trace/trace.h | 44 | ||||
-rw-r--r-- | kernel/trace/trace_events.c | 23 | ||||
-rw-r--r-- | kernel/trace/trace_events_filter.c | 155 | ||||
-rw-r--r-- | kernel/trace/trace_syscalls.c | 86 |
6 files changed, 499 insertions, 183 deletions
diff --git a/kernel/trace/ftrace.c b/kernel/trace/ftrace.c index 9c451a1930b6..1ed514fe3a30 100644 --- a/kernel/trace/ftrace.c +++ b/kernel/trace/ftrace.c | |||
@@ -60,6 +60,13 @@ static int last_ftrace_enabled; | |||
60 | /* Quick disabling of function tracer. */ | 60 | /* Quick disabling of function tracer. */ |
61 | int function_trace_stop; | 61 | int function_trace_stop; |
62 | 62 | ||
63 | /* List for set_ftrace_pid's pids. */ | ||
64 | LIST_HEAD(ftrace_pids); | ||
65 | struct ftrace_pid { | ||
66 | struct list_head list; | ||
67 | struct pid *pid; | ||
68 | }; | ||
69 | |||
63 | /* | 70 | /* |
64 | * ftrace_disabled is set when an anomaly is discovered. | 71 | * ftrace_disabled is set when an anomaly is discovered. |
65 | * ftrace_disabled is much stronger than ftrace_enabled. | 72 | * ftrace_disabled is much stronger than ftrace_enabled. |
@@ -78,6 +85,10 @@ ftrace_func_t ftrace_trace_function __read_mostly = ftrace_stub; | |||
78 | ftrace_func_t __ftrace_trace_function __read_mostly = ftrace_stub; | 85 | ftrace_func_t __ftrace_trace_function __read_mostly = ftrace_stub; |
79 | ftrace_func_t ftrace_pid_function __read_mostly = ftrace_stub; | 86 | ftrace_func_t ftrace_pid_function __read_mostly = ftrace_stub; |
80 | 87 | ||
88 | #ifdef CONFIG_FUNCTION_GRAPH_TRACER | ||
89 | static int ftrace_set_func(unsigned long *array, int *idx, char *buffer); | ||
90 | #endif | ||
91 | |||
81 | static void ftrace_list_func(unsigned long ip, unsigned long parent_ip) | 92 | static void ftrace_list_func(unsigned long ip, unsigned long parent_ip) |
82 | { | 93 | { |
83 | struct ftrace_ops *op = ftrace_list; | 94 | struct ftrace_ops *op = ftrace_list; |
@@ -155,7 +166,7 @@ static int __register_ftrace_function(struct ftrace_ops *ops) | |||
155 | else | 166 | else |
156 | func = ftrace_list_func; | 167 | func = ftrace_list_func; |
157 | 168 | ||
158 | if (ftrace_pid_trace) { | 169 | if (!list_empty(&ftrace_pids)) { |
159 | set_ftrace_pid_function(func); | 170 | set_ftrace_pid_function(func); |
160 | func = ftrace_pid_func; | 171 | func = ftrace_pid_func; |
161 | } | 172 | } |
@@ -203,7 +214,7 @@ static int __unregister_ftrace_function(struct ftrace_ops *ops) | |||
203 | if (ftrace_list->next == &ftrace_list_end) { | 214 | if (ftrace_list->next == &ftrace_list_end) { |
204 | ftrace_func_t func = ftrace_list->func; | 215 | ftrace_func_t func = ftrace_list->func; |
205 | 216 | ||
206 | if (ftrace_pid_trace) { | 217 | if (!list_empty(&ftrace_pids)) { |
207 | set_ftrace_pid_function(func); | 218 | set_ftrace_pid_function(func); |
208 | func = ftrace_pid_func; | 219 | func = ftrace_pid_func; |
209 | } | 220 | } |
@@ -231,7 +242,7 @@ static void ftrace_update_pid_func(void) | |||
231 | func = __ftrace_trace_function; | 242 | func = __ftrace_trace_function; |
232 | #endif | 243 | #endif |
233 | 244 | ||
234 | if (ftrace_pid_trace) { | 245 | if (!list_empty(&ftrace_pids)) { |
235 | set_ftrace_pid_function(func); | 246 | set_ftrace_pid_function(func); |
236 | func = ftrace_pid_func; | 247 | func = ftrace_pid_func; |
237 | } else { | 248 | } else { |
@@ -821,8 +832,6 @@ static __init void ftrace_profile_debugfs(struct dentry *d_tracer) | |||
821 | } | 832 | } |
822 | #endif /* CONFIG_FUNCTION_PROFILER */ | 833 | #endif /* CONFIG_FUNCTION_PROFILER */ |
823 | 834 | ||
824 | /* set when tracing only a pid */ | ||
825 | struct pid *ftrace_pid_trace; | ||
826 | static struct pid * const ftrace_swapper_pid = &init_struct_pid; | 835 | static struct pid * const ftrace_swapper_pid = &init_struct_pid; |
827 | 836 | ||
828 | #ifdef CONFIG_DYNAMIC_FTRACE | 837 | #ifdef CONFIG_DYNAMIC_FTRACE |
@@ -1261,12 +1270,34 @@ static int ftrace_update_code(struct module *mod) | |||
1261 | ftrace_new_addrs = p->newlist; | 1270 | ftrace_new_addrs = p->newlist; |
1262 | p->flags = 0L; | 1271 | p->flags = 0L; |
1263 | 1272 | ||
1264 | /* convert record (i.e, patch mcount-call with NOP) */ | 1273 | /* |
1265 | if (ftrace_code_disable(mod, p)) { | 1274 | * Do the initial record convertion from mcount jump |
1266 | p->flags |= FTRACE_FL_CONVERTED; | 1275 | * to the NOP instructions. |
1267 | ftrace_update_cnt++; | 1276 | */ |
1268 | } else | 1277 | if (!ftrace_code_disable(mod, p)) { |
1269 | ftrace_free_rec(p); | 1278 | ftrace_free_rec(p); |
1279 | continue; | ||
1280 | } | ||
1281 | |||
1282 | p->flags |= FTRACE_FL_CONVERTED; | ||
1283 | ftrace_update_cnt++; | ||
1284 | |||
1285 | /* | ||
1286 | * If the tracing is enabled, go ahead and enable the record. | ||
1287 | * | ||
1288 | * The reason not to enable the record immediatelly is the | ||
1289 | * inherent check of ftrace_make_nop/ftrace_make_call for | ||
1290 | * correct previous instructions. Making first the NOP | ||
1291 | * conversion puts the module to the correct state, thus | ||
1292 | * passing the ftrace_make_call check. | ||
1293 | */ | ||
1294 | if (ftrace_start_up) { | ||
1295 | int failed = __ftrace_replace_code(p, 1); | ||
1296 | if (failed) { | ||
1297 | ftrace_bug(failed, p->ip); | ||
1298 | ftrace_free_rec(p); | ||
1299 | } | ||
1300 | } | ||
1270 | } | 1301 | } |
1271 | 1302 | ||
1272 | stop = ftrace_now(raw_smp_processor_id()); | 1303 | stop = ftrace_now(raw_smp_processor_id()); |
@@ -1656,60 +1687,6 @@ ftrace_regex_lseek(struct file *file, loff_t offset, int origin) | |||
1656 | return ret; | 1687 | return ret; |
1657 | } | 1688 | } |
1658 | 1689 | ||
1659 | enum { | ||
1660 | MATCH_FULL, | ||
1661 | MATCH_FRONT_ONLY, | ||
1662 | MATCH_MIDDLE_ONLY, | ||
1663 | MATCH_END_ONLY, | ||
1664 | }; | ||
1665 | |||
1666 | /* | ||
1667 | * (static function - no need for kernel doc) | ||
1668 | * | ||
1669 | * Pass in a buffer containing a glob and this function will | ||
1670 | * set search to point to the search part of the buffer and | ||
1671 | * return the type of search it is (see enum above). | ||
1672 | * This does modify buff. | ||
1673 | * | ||
1674 | * Returns enum type. | ||
1675 | * search returns the pointer to use for comparison. | ||
1676 | * not returns 1 if buff started with a '!' | ||
1677 | * 0 otherwise. | ||
1678 | */ | ||
1679 | static int | ||
1680 | ftrace_setup_glob(char *buff, int len, char **search, int *not) | ||
1681 | { | ||
1682 | int type = MATCH_FULL; | ||
1683 | int i; | ||
1684 | |||
1685 | if (buff[0] == '!') { | ||
1686 | *not = 1; | ||
1687 | buff++; | ||
1688 | len--; | ||
1689 | } else | ||
1690 | *not = 0; | ||
1691 | |||
1692 | *search = buff; | ||
1693 | |||
1694 | for (i = 0; i < len; i++) { | ||
1695 | if (buff[i] == '*') { | ||
1696 | if (!i) { | ||
1697 | *search = buff + 1; | ||
1698 | type = MATCH_END_ONLY; | ||
1699 | } else { | ||
1700 | if (type == MATCH_END_ONLY) | ||
1701 | type = MATCH_MIDDLE_ONLY; | ||
1702 | else | ||
1703 | type = MATCH_FRONT_ONLY; | ||
1704 | buff[i] = 0; | ||
1705 | break; | ||
1706 | } | ||
1707 | } | ||
1708 | } | ||
1709 | |||
1710 | return type; | ||
1711 | } | ||
1712 | |||
1713 | static int ftrace_match(char *str, char *regex, int len, int type) | 1690 | static int ftrace_match(char *str, char *regex, int len, int type) |
1714 | { | 1691 | { |
1715 | int matched = 0; | 1692 | int matched = 0; |
@@ -1758,7 +1735,7 @@ static void ftrace_match_records(char *buff, int len, int enable) | |||
1758 | int not; | 1735 | int not; |
1759 | 1736 | ||
1760 | flag = enable ? FTRACE_FL_FILTER : FTRACE_FL_NOTRACE; | 1737 | flag = enable ? FTRACE_FL_FILTER : FTRACE_FL_NOTRACE; |
1761 | type = ftrace_setup_glob(buff, len, &search, ¬); | 1738 | type = filter_parse_regex(buff, len, &search, ¬); |
1762 | 1739 | ||
1763 | search_len = strlen(search); | 1740 | search_len = strlen(search); |
1764 | 1741 | ||
@@ -1826,7 +1803,7 @@ static void ftrace_match_module_records(char *buff, char *mod, int enable) | |||
1826 | } | 1803 | } |
1827 | 1804 | ||
1828 | if (strlen(buff)) { | 1805 | if (strlen(buff)) { |
1829 | type = ftrace_setup_glob(buff, strlen(buff), &search, ¬); | 1806 | type = filter_parse_regex(buff, strlen(buff), &search, ¬); |
1830 | search_len = strlen(search); | 1807 | search_len = strlen(search); |
1831 | } | 1808 | } |
1832 | 1809 | ||
@@ -1991,7 +1968,7 @@ register_ftrace_function_probe(char *glob, struct ftrace_probe_ops *ops, | |||
1991 | int count = 0; | 1968 | int count = 0; |
1992 | char *search; | 1969 | char *search; |
1993 | 1970 | ||
1994 | type = ftrace_setup_glob(glob, strlen(glob), &search, ¬); | 1971 | type = filter_parse_regex(glob, strlen(glob), &search, ¬); |
1995 | len = strlen(search); | 1972 | len = strlen(search); |
1996 | 1973 | ||
1997 | /* we do not support '!' for function probes */ | 1974 | /* we do not support '!' for function probes */ |
@@ -2068,7 +2045,7 @@ __unregister_ftrace_function_probe(char *glob, struct ftrace_probe_ops *ops, | |||
2068 | else if (glob) { | 2045 | else if (glob) { |
2069 | int not; | 2046 | int not; |
2070 | 2047 | ||
2071 | type = ftrace_setup_glob(glob, strlen(glob), &search, ¬); | 2048 | type = filter_parse_regex(glob, strlen(glob), &search, ¬); |
2072 | len = strlen(search); | 2049 | len = strlen(search); |
2073 | 2050 | ||
2074 | /* we do not support '!' for function probes */ | 2051 | /* we do not support '!' for function probes */ |
@@ -2297,6 +2274,7 @@ void ftrace_set_notrace(unsigned char *buf, int len, int reset) | |||
2297 | #define FTRACE_FILTER_SIZE COMMAND_LINE_SIZE | 2274 | #define FTRACE_FILTER_SIZE COMMAND_LINE_SIZE |
2298 | static char ftrace_notrace_buf[FTRACE_FILTER_SIZE] __initdata; | 2275 | static char ftrace_notrace_buf[FTRACE_FILTER_SIZE] __initdata; |
2299 | static char ftrace_filter_buf[FTRACE_FILTER_SIZE] __initdata; | 2276 | static char ftrace_filter_buf[FTRACE_FILTER_SIZE] __initdata; |
2277 | static char ftrace_graph_buf[FTRACE_FILTER_SIZE] __initdata; | ||
2300 | 2278 | ||
2301 | static int __init set_ftrace_notrace(char *str) | 2279 | static int __init set_ftrace_notrace(char *str) |
2302 | { | 2280 | { |
@@ -2312,6 +2290,31 @@ static int __init set_ftrace_filter(char *str) | |||
2312 | } | 2290 | } |
2313 | __setup("ftrace_filter=", set_ftrace_filter); | 2291 | __setup("ftrace_filter=", set_ftrace_filter); |
2314 | 2292 | ||
2293 | #ifdef CONFIG_FUNCTION_GRAPH_TRACER | ||
2294 | static int __init set_graph_function(char *str) | ||
2295 | { | ||
2296 | strlcpy(ftrace_graph_buf, str, FTRACE_FILTER_SIZE); | ||
2297 | return 1; | ||
2298 | } | ||
2299 | __setup("ftrace_graph_filter=", set_graph_function); | ||
2300 | |||
2301 | static void __init set_ftrace_early_graph(char *buf) | ||
2302 | { | ||
2303 | int ret; | ||
2304 | char *func; | ||
2305 | |||
2306 | while (buf) { | ||
2307 | func = strsep(&buf, ","); | ||
2308 | /* we allow only one expression at a time */ | ||
2309 | ret = ftrace_set_func(ftrace_graph_funcs, &ftrace_graph_count, | ||
2310 | func); | ||
2311 | if (ret) | ||
2312 | printk(KERN_DEBUG "ftrace: function %s not " | ||
2313 | "traceable\n", func); | ||
2314 | } | ||
2315 | } | ||
2316 | #endif /* CONFIG_FUNCTION_GRAPH_TRACER */ | ||
2317 | |||
2315 | static void __init set_ftrace_early_filter(char *buf, int enable) | 2318 | static void __init set_ftrace_early_filter(char *buf, int enable) |
2316 | { | 2319 | { |
2317 | char *func; | 2320 | char *func; |
@@ -2328,6 +2331,10 @@ static void __init set_ftrace_early_filters(void) | |||
2328 | set_ftrace_early_filter(ftrace_filter_buf, 1); | 2331 | set_ftrace_early_filter(ftrace_filter_buf, 1); |
2329 | if (ftrace_notrace_buf[0]) | 2332 | if (ftrace_notrace_buf[0]) |
2330 | set_ftrace_early_filter(ftrace_notrace_buf, 0); | 2333 | set_ftrace_early_filter(ftrace_notrace_buf, 0); |
2334 | #ifdef CONFIG_FUNCTION_GRAPH_TRACER | ||
2335 | if (ftrace_graph_buf[0]) | ||
2336 | set_ftrace_early_graph(ftrace_graph_buf); | ||
2337 | #endif /* CONFIG_FUNCTION_GRAPH_TRACER */ | ||
2331 | } | 2338 | } |
2332 | 2339 | ||
2333 | static int | 2340 | static int |
@@ -2513,7 +2520,7 @@ ftrace_set_func(unsigned long *array, int *idx, char *buffer) | |||
2513 | return -ENODEV; | 2520 | return -ENODEV; |
2514 | 2521 | ||
2515 | /* decode regex */ | 2522 | /* decode regex */ |
2516 | type = ftrace_setup_glob(buffer, strlen(buffer), &search, ¬); | 2523 | type = filter_parse_regex(buffer, strlen(buffer), &search, ¬); |
2517 | if (not) | 2524 | if (not) |
2518 | return -EINVAL; | 2525 | return -EINVAL; |
2519 | 2526 | ||
@@ -2624,7 +2631,7 @@ static __init int ftrace_init_dyn_debugfs(struct dentry *d_tracer) | |||
2624 | return 0; | 2631 | return 0; |
2625 | } | 2632 | } |
2626 | 2633 | ||
2627 | static int ftrace_convert_nops(struct module *mod, | 2634 | static int ftrace_process_locs(struct module *mod, |
2628 | unsigned long *start, | 2635 | unsigned long *start, |
2629 | unsigned long *end) | 2636 | unsigned long *end) |
2630 | { | 2637 | { |
@@ -2684,7 +2691,7 @@ static void ftrace_init_module(struct module *mod, | |||
2684 | { | 2691 | { |
2685 | if (ftrace_disabled || start == end) | 2692 | if (ftrace_disabled || start == end) |
2686 | return; | 2693 | return; |
2687 | ftrace_convert_nops(mod, start, end); | 2694 | ftrace_process_locs(mod, start, end); |
2688 | } | 2695 | } |
2689 | 2696 | ||
2690 | static int ftrace_module_notify(struct notifier_block *self, | 2697 | static int ftrace_module_notify(struct notifier_block *self, |
@@ -2745,7 +2752,7 @@ void __init ftrace_init(void) | |||
2745 | 2752 | ||
2746 | last_ftrace_enabled = ftrace_enabled = 1; | 2753 | last_ftrace_enabled = ftrace_enabled = 1; |
2747 | 2754 | ||
2748 | ret = ftrace_convert_nops(NULL, | 2755 | ret = ftrace_process_locs(NULL, |
2749 | __start_mcount_loc, | 2756 | __start_mcount_loc, |
2750 | __stop_mcount_loc); | 2757 | __stop_mcount_loc); |
2751 | 2758 | ||
@@ -2778,23 +2785,6 @@ static inline void ftrace_startup_enable(int command) { } | |||
2778 | # define ftrace_shutdown_sysctl() do { } while (0) | 2785 | # define ftrace_shutdown_sysctl() do { } while (0) |
2779 | #endif /* CONFIG_DYNAMIC_FTRACE */ | 2786 | #endif /* CONFIG_DYNAMIC_FTRACE */ |
2780 | 2787 | ||
2781 | static ssize_t | ||
2782 | ftrace_pid_read(struct file *file, char __user *ubuf, | ||
2783 | size_t cnt, loff_t *ppos) | ||
2784 | { | ||
2785 | char buf[64]; | ||
2786 | int r; | ||
2787 | |||
2788 | if (ftrace_pid_trace == ftrace_swapper_pid) | ||
2789 | r = sprintf(buf, "swapper tasks\n"); | ||
2790 | else if (ftrace_pid_trace) | ||
2791 | r = sprintf(buf, "%u\n", pid_vnr(ftrace_pid_trace)); | ||
2792 | else | ||
2793 | r = sprintf(buf, "no pid\n"); | ||
2794 | |||
2795 | return simple_read_from_buffer(ubuf, cnt, ppos, buf, r); | ||
2796 | } | ||
2797 | |||
2798 | static void clear_ftrace_swapper(void) | 2788 | static void clear_ftrace_swapper(void) |
2799 | { | 2789 | { |
2800 | struct task_struct *p; | 2790 | struct task_struct *p; |
@@ -2845,14 +2835,12 @@ static void set_ftrace_pid(struct pid *pid) | |||
2845 | rcu_read_unlock(); | 2835 | rcu_read_unlock(); |
2846 | } | 2836 | } |
2847 | 2837 | ||
2848 | static void clear_ftrace_pid_task(struct pid **pid) | 2838 | static void clear_ftrace_pid_task(struct pid *pid) |
2849 | { | 2839 | { |
2850 | if (*pid == ftrace_swapper_pid) | 2840 | if (pid == ftrace_swapper_pid) |
2851 | clear_ftrace_swapper(); | 2841 | clear_ftrace_swapper(); |
2852 | else | 2842 | else |
2853 | clear_ftrace_pid(*pid); | 2843 | clear_ftrace_pid(pid); |
2854 | |||
2855 | *pid = NULL; | ||
2856 | } | 2844 | } |
2857 | 2845 | ||
2858 | static void set_ftrace_pid_task(struct pid *pid) | 2846 | static void set_ftrace_pid_task(struct pid *pid) |
@@ -2863,11 +2851,140 @@ static void set_ftrace_pid_task(struct pid *pid) | |||
2863 | set_ftrace_pid(pid); | 2851 | set_ftrace_pid(pid); |
2864 | } | 2852 | } |
2865 | 2853 | ||
2854 | static int ftrace_pid_add(int p) | ||
2855 | { | ||
2856 | struct pid *pid; | ||
2857 | struct ftrace_pid *fpid; | ||
2858 | int ret = -EINVAL; | ||
2859 | |||
2860 | mutex_lock(&ftrace_lock); | ||
2861 | |||
2862 | if (!p) | ||
2863 | pid = ftrace_swapper_pid; | ||
2864 | else | ||
2865 | pid = find_get_pid(p); | ||
2866 | |||
2867 | if (!pid) | ||
2868 | goto out; | ||
2869 | |||
2870 | ret = 0; | ||
2871 | |||
2872 | list_for_each_entry(fpid, &ftrace_pids, list) | ||
2873 | if (fpid->pid == pid) | ||
2874 | goto out_put; | ||
2875 | |||
2876 | ret = -ENOMEM; | ||
2877 | |||
2878 | fpid = kmalloc(sizeof(*fpid), GFP_KERNEL); | ||
2879 | if (!fpid) | ||
2880 | goto out_put; | ||
2881 | |||
2882 | list_add(&fpid->list, &ftrace_pids); | ||
2883 | fpid->pid = pid; | ||
2884 | |||
2885 | set_ftrace_pid_task(pid); | ||
2886 | |||
2887 | ftrace_update_pid_func(); | ||
2888 | ftrace_startup_enable(0); | ||
2889 | |||
2890 | mutex_unlock(&ftrace_lock); | ||
2891 | return 0; | ||
2892 | |||
2893 | out_put: | ||
2894 | if (pid != ftrace_swapper_pid) | ||
2895 | put_pid(pid); | ||
2896 | |||
2897 | out: | ||
2898 | mutex_unlock(&ftrace_lock); | ||
2899 | return ret; | ||
2900 | } | ||
2901 | |||
2902 | static void ftrace_pid_reset(void) | ||
2903 | { | ||
2904 | struct ftrace_pid *fpid, *safe; | ||
2905 | |||
2906 | mutex_lock(&ftrace_lock); | ||
2907 | list_for_each_entry_safe(fpid, safe, &ftrace_pids, list) { | ||
2908 | struct pid *pid = fpid->pid; | ||
2909 | |||
2910 | clear_ftrace_pid_task(pid); | ||
2911 | |||
2912 | list_del(&fpid->list); | ||
2913 | kfree(fpid); | ||
2914 | } | ||
2915 | |||
2916 | ftrace_update_pid_func(); | ||
2917 | ftrace_startup_enable(0); | ||
2918 | |||
2919 | mutex_unlock(&ftrace_lock); | ||
2920 | } | ||
2921 | |||
2922 | static void *fpid_start(struct seq_file *m, loff_t *pos) | ||
2923 | { | ||
2924 | mutex_lock(&ftrace_lock); | ||
2925 | |||
2926 | if (list_empty(&ftrace_pids) && (!*pos)) | ||
2927 | return (void *) 1; | ||
2928 | |||
2929 | return seq_list_start(&ftrace_pids, *pos); | ||
2930 | } | ||
2931 | |||
2932 | static void *fpid_next(struct seq_file *m, void *v, loff_t *pos) | ||
2933 | { | ||
2934 | if (v == (void *)1) | ||
2935 | return NULL; | ||
2936 | |||
2937 | return seq_list_next(v, &ftrace_pids, pos); | ||
2938 | } | ||
2939 | |||
2940 | static void fpid_stop(struct seq_file *m, void *p) | ||
2941 | { | ||
2942 | mutex_unlock(&ftrace_lock); | ||
2943 | } | ||
2944 | |||
2945 | static int fpid_show(struct seq_file *m, void *v) | ||
2946 | { | ||
2947 | const struct ftrace_pid *fpid = list_entry(v, struct ftrace_pid, list); | ||
2948 | |||
2949 | if (v == (void *)1) { | ||
2950 | seq_printf(m, "no pid\n"); | ||
2951 | return 0; | ||
2952 | } | ||
2953 | |||
2954 | if (fpid->pid == ftrace_swapper_pid) | ||
2955 | seq_printf(m, "swapper tasks\n"); | ||
2956 | else | ||
2957 | seq_printf(m, "%u\n", pid_vnr(fpid->pid)); | ||
2958 | |||
2959 | return 0; | ||
2960 | } | ||
2961 | |||
2962 | static const struct seq_operations ftrace_pid_sops = { | ||
2963 | .start = fpid_start, | ||
2964 | .next = fpid_next, | ||
2965 | .stop = fpid_stop, | ||
2966 | .show = fpid_show, | ||
2967 | }; | ||
2968 | |||
2969 | static int | ||
2970 | ftrace_pid_open(struct inode *inode, struct file *file) | ||
2971 | { | ||
2972 | int ret = 0; | ||
2973 | |||
2974 | if ((file->f_mode & FMODE_WRITE) && | ||
2975 | (file->f_flags & O_TRUNC)) | ||
2976 | ftrace_pid_reset(); | ||
2977 | |||
2978 | if (file->f_mode & FMODE_READ) | ||
2979 | ret = seq_open(file, &ftrace_pid_sops); | ||
2980 | |||
2981 | return ret; | ||
2982 | } | ||
2983 | |||
2866 | static ssize_t | 2984 | static ssize_t |
2867 | ftrace_pid_write(struct file *filp, const char __user *ubuf, | 2985 | ftrace_pid_write(struct file *filp, const char __user *ubuf, |
2868 | size_t cnt, loff_t *ppos) | 2986 | size_t cnt, loff_t *ppos) |
2869 | { | 2987 | { |
2870 | struct pid *pid; | ||
2871 | char buf[64]; | 2988 | char buf[64]; |
2872 | long val; | 2989 | long val; |
2873 | int ret; | 2990 | int ret; |
@@ -2880,57 +2997,38 @@ ftrace_pid_write(struct file *filp, const char __user *ubuf, | |||
2880 | 2997 | ||
2881 | buf[cnt] = 0; | 2998 | buf[cnt] = 0; |
2882 | 2999 | ||
3000 | /* | ||
3001 | * Allow "echo > set_ftrace_pid" or "echo -n '' > set_ftrace_pid" | ||
3002 | * to clean the filter quietly. | ||
3003 | */ | ||
3004 | strstrip(buf); | ||
3005 | if (strlen(buf) == 0) | ||
3006 | return 1; | ||
3007 | |||
2883 | ret = strict_strtol(buf, 10, &val); | 3008 | ret = strict_strtol(buf, 10, &val); |
2884 | if (ret < 0) | 3009 | if (ret < 0) |
2885 | return ret; | 3010 | return ret; |
2886 | 3011 | ||
2887 | mutex_lock(&ftrace_lock); | 3012 | ret = ftrace_pid_add(val); |
2888 | if (val < 0) { | ||
2889 | /* disable pid tracing */ | ||
2890 | if (!ftrace_pid_trace) | ||
2891 | goto out; | ||
2892 | |||
2893 | clear_ftrace_pid_task(&ftrace_pid_trace); | ||
2894 | |||
2895 | } else { | ||
2896 | /* swapper task is special */ | ||
2897 | if (!val) { | ||
2898 | pid = ftrace_swapper_pid; | ||
2899 | if (pid == ftrace_pid_trace) | ||
2900 | goto out; | ||
2901 | } else { | ||
2902 | pid = find_get_pid(val); | ||
2903 | 3013 | ||
2904 | if (pid == ftrace_pid_trace) { | 3014 | return ret ? ret : cnt; |
2905 | put_pid(pid); | 3015 | } |
2906 | goto out; | ||
2907 | } | ||
2908 | } | ||
2909 | |||
2910 | if (ftrace_pid_trace) | ||
2911 | clear_ftrace_pid_task(&ftrace_pid_trace); | ||
2912 | |||
2913 | if (!pid) | ||
2914 | goto out; | ||
2915 | |||
2916 | ftrace_pid_trace = pid; | ||
2917 | |||
2918 | set_ftrace_pid_task(ftrace_pid_trace); | ||
2919 | } | ||
2920 | |||
2921 | /* update the function call */ | ||
2922 | ftrace_update_pid_func(); | ||
2923 | ftrace_startup_enable(0); | ||
2924 | 3016 | ||
2925 | out: | 3017 | static int |
2926 | mutex_unlock(&ftrace_lock); | 3018 | ftrace_pid_release(struct inode *inode, struct file *file) |
3019 | { | ||
3020 | if (file->f_mode & FMODE_READ) | ||
3021 | seq_release(inode, file); | ||
2927 | 3022 | ||
2928 | return cnt; | 3023 | return 0; |
2929 | } | 3024 | } |
2930 | 3025 | ||
2931 | static const struct file_operations ftrace_pid_fops = { | 3026 | static const struct file_operations ftrace_pid_fops = { |
2932 | .read = ftrace_pid_read, | 3027 | .open = ftrace_pid_open, |
2933 | .write = ftrace_pid_write, | 3028 | .write = ftrace_pid_write, |
3029 | .read = seq_read, | ||
3030 | .llseek = seq_lseek, | ||
3031 | .release = ftrace_pid_release, | ||
2934 | }; | 3032 | }; |
2935 | 3033 | ||
2936 | static __init int ftrace_init_debugfs(void) | 3034 | static __init int ftrace_init_debugfs(void) |
diff --git a/kernel/trace/trace.c b/kernel/trace/trace.c index b20d3ec75de9..9d3067a62d43 100644 --- a/kernel/trace/trace.c +++ b/kernel/trace/trace.c | |||
@@ -129,7 +129,7 @@ static int tracing_set_tracer(const char *buf); | |||
129 | static char bootup_tracer_buf[MAX_TRACER_SIZE] __initdata; | 129 | static char bootup_tracer_buf[MAX_TRACER_SIZE] __initdata; |
130 | static char *default_bootup_tracer; | 130 | static char *default_bootup_tracer; |
131 | 131 | ||
132 | static int __init set_ftrace(char *str) | 132 | static int __init set_cmdline_ftrace(char *str) |
133 | { | 133 | { |
134 | strncpy(bootup_tracer_buf, str, MAX_TRACER_SIZE); | 134 | strncpy(bootup_tracer_buf, str, MAX_TRACER_SIZE); |
135 | default_bootup_tracer = bootup_tracer_buf; | 135 | default_bootup_tracer = bootup_tracer_buf; |
@@ -137,7 +137,7 @@ static int __init set_ftrace(char *str) | |||
137 | ring_buffer_expanded = 1; | 137 | ring_buffer_expanded = 1; |
138 | return 1; | 138 | return 1; |
139 | } | 139 | } |
140 | __setup("ftrace=", set_ftrace); | 140 | __setup("ftrace=", set_cmdline_ftrace); |
141 | 141 | ||
142 | static int __init set_ftrace_dump_on_oops(char *str) | 142 | static int __init set_ftrace_dump_on_oops(char *str) |
143 | { | 143 | { |
diff --git a/kernel/trace/trace.h b/kernel/trace/trace.h index 405cb850b75d..acef8b4636f0 100644 --- a/kernel/trace/trace.h +++ b/kernel/trace/trace.h | |||
@@ -483,10 +483,6 @@ static inline int ftrace_graph_addr(unsigned long addr) | |||
483 | return 0; | 483 | return 0; |
484 | } | 484 | } |
485 | #else | 485 | #else |
486 | static inline int ftrace_trace_addr(unsigned long addr) | ||
487 | { | ||
488 | return 1; | ||
489 | } | ||
490 | static inline int ftrace_graph_addr(unsigned long addr) | 486 | static inline int ftrace_graph_addr(unsigned long addr) |
491 | { | 487 | { |
492 | return 1; | 488 | return 1; |
@@ -500,12 +496,12 @@ print_graph_function(struct trace_iterator *iter) | |||
500 | } | 496 | } |
501 | #endif /* CONFIG_FUNCTION_GRAPH_TRACER */ | 497 | #endif /* CONFIG_FUNCTION_GRAPH_TRACER */ |
502 | 498 | ||
503 | extern struct pid *ftrace_pid_trace; | 499 | extern struct list_head ftrace_pids; |
504 | 500 | ||
505 | #ifdef CONFIG_FUNCTION_TRACER | 501 | #ifdef CONFIG_FUNCTION_TRACER |
506 | static inline int ftrace_trace_task(struct task_struct *task) | 502 | static inline int ftrace_trace_task(struct task_struct *task) |
507 | { | 503 | { |
508 | if (!ftrace_pid_trace) | 504 | if (list_empty(&ftrace_pids)) |
509 | return 1; | 505 | return 1; |
510 | 506 | ||
511 | return test_tsk_trace_trace(task); | 507 | return test_tsk_trace_trace(task); |
@@ -699,22 +695,40 @@ struct event_subsystem { | |||
699 | }; | 695 | }; |
700 | 696 | ||
701 | struct filter_pred; | 697 | struct filter_pred; |
698 | struct regex; | ||
702 | 699 | ||
703 | typedef int (*filter_pred_fn_t) (struct filter_pred *pred, void *event, | 700 | typedef int (*filter_pred_fn_t) (struct filter_pred *pred, void *event, |
704 | int val1, int val2); | 701 | int val1, int val2); |
705 | 702 | ||
703 | typedef int (*regex_match_func)(char *str, struct regex *r, int len); | ||
704 | |||
705 | enum regex_type { | ||
706 | MATCH_FULL, | ||
707 | MATCH_FRONT_ONLY, | ||
708 | MATCH_MIDDLE_ONLY, | ||
709 | MATCH_END_ONLY, | ||
710 | }; | ||
711 | |||
712 | struct regex { | ||
713 | char pattern[MAX_FILTER_STR_VAL]; | ||
714 | int len; | ||
715 | int field_len; | ||
716 | regex_match_func match; | ||
717 | }; | ||
718 | |||
706 | struct filter_pred { | 719 | struct filter_pred { |
707 | filter_pred_fn_t fn; | 720 | filter_pred_fn_t fn; |
708 | u64 val; | 721 | u64 val; |
709 | char str_val[MAX_FILTER_STR_VAL]; | 722 | struct regex regex; |
710 | int str_len; | 723 | char *field_name; |
711 | char *field_name; | 724 | int offset; |
712 | int offset; | 725 | int not; |
713 | int not; | 726 | int op; |
714 | int op; | 727 | int pop_n; |
715 | int pop_n; | ||
716 | }; | 728 | }; |
717 | 729 | ||
730 | extern enum regex_type | ||
731 | filter_parse_regex(char *buff, int len, char **search, int *not); | ||
718 | extern void print_event_filter(struct ftrace_event_call *call, | 732 | extern void print_event_filter(struct ftrace_event_call *call, |
719 | struct trace_seq *s); | 733 | struct trace_seq *s); |
720 | extern int apply_event_filter(struct ftrace_event_call *call, | 734 | extern int apply_event_filter(struct ftrace_event_call *call, |
diff --git a/kernel/trace/trace_events.c b/kernel/trace/trace_events.c index d128f65778e6..5e9ffc33f6db 100644 --- a/kernel/trace/trace_events.c +++ b/kernel/trace/trace_events.c | |||
@@ -878,9 +878,9 @@ event_subsystem_dir(const char *name, struct dentry *d_events) | |||
878 | "'%s/filter' entry\n", name); | 878 | "'%s/filter' entry\n", name); |
879 | } | 879 | } |
880 | 880 | ||
881 | entry = trace_create_file("enable", 0644, system->entry, | 881 | trace_create_file("enable", 0644, system->entry, |
882 | (void *)system->name, | 882 | (void *)system->name, |
883 | &ftrace_system_enable_fops); | 883 | &ftrace_system_enable_fops); |
884 | 884 | ||
885 | return system->entry; | 885 | return system->entry; |
886 | } | 886 | } |
@@ -892,7 +892,6 @@ event_create_dir(struct ftrace_event_call *call, struct dentry *d_events, | |||
892 | const struct file_operations *filter, | 892 | const struct file_operations *filter, |
893 | const struct file_operations *format) | 893 | const struct file_operations *format) |
894 | { | 894 | { |
895 | struct dentry *entry; | ||
896 | int ret; | 895 | int ret; |
897 | 896 | ||
898 | /* | 897 | /* |
@@ -910,12 +909,12 @@ event_create_dir(struct ftrace_event_call *call, struct dentry *d_events, | |||
910 | } | 909 | } |
911 | 910 | ||
912 | if (call->regfunc) | 911 | if (call->regfunc) |
913 | entry = trace_create_file("enable", 0644, call->dir, call, | 912 | trace_create_file("enable", 0644, call->dir, call, |
914 | enable); | 913 | enable); |
915 | 914 | ||
916 | if (call->id && call->profile_enable) | 915 | if (call->id && call->profile_enable) |
917 | entry = trace_create_file("id", 0444, call->dir, call, | 916 | trace_create_file("id", 0444, call->dir, call, |
918 | id); | 917 | id); |
919 | 918 | ||
920 | if (call->define_fields) { | 919 | if (call->define_fields) { |
921 | ret = call->define_fields(call); | 920 | ret = call->define_fields(call); |
@@ -924,16 +923,16 @@ event_create_dir(struct ftrace_event_call *call, struct dentry *d_events, | |||
924 | " events/%s\n", call->name); | 923 | " events/%s\n", call->name); |
925 | return ret; | 924 | return ret; |
926 | } | 925 | } |
927 | entry = trace_create_file("filter", 0644, call->dir, call, | 926 | trace_create_file("filter", 0644, call->dir, call, |
928 | filter); | 927 | filter); |
929 | } | 928 | } |
930 | 929 | ||
931 | /* A trace may not want to export its format */ | 930 | /* A trace may not want to export its format */ |
932 | if (!call->show_format) | 931 | if (!call->show_format) |
933 | return 0; | 932 | return 0; |
934 | 933 | ||
935 | entry = trace_create_file("format", 0444, call->dir, call, | 934 | trace_create_file("format", 0444, call->dir, call, |
936 | format); | 935 | format); |
937 | 936 | ||
938 | return 0; | 937 | return 0; |
939 | } | 938 | } |
diff --git a/kernel/trace/trace_events_filter.c b/kernel/trace/trace_events_filter.c index 98a6cc5c64ed..92672016da28 100644 --- a/kernel/trace/trace_events_filter.c +++ b/kernel/trace/trace_events_filter.c | |||
@@ -18,8 +18,6 @@ | |||
18 | * Copyright (C) 2009 Tom Zanussi <tzanussi@gmail.com> | 18 | * Copyright (C) 2009 Tom Zanussi <tzanussi@gmail.com> |
19 | */ | 19 | */ |
20 | 20 | ||
21 | #include <linux/debugfs.h> | ||
22 | #include <linux/uaccess.h> | ||
23 | #include <linux/module.h> | 21 | #include <linux/module.h> |
24 | #include <linux/ctype.h> | 22 | #include <linux/ctype.h> |
25 | #include <linux/mutex.h> | 23 | #include <linux/mutex.h> |
@@ -197,9 +195,9 @@ static int filter_pred_string(struct filter_pred *pred, void *event, | |||
197 | char *addr = (char *)(event + pred->offset); | 195 | char *addr = (char *)(event + pred->offset); |
198 | int cmp, match; | 196 | int cmp, match; |
199 | 197 | ||
200 | cmp = strncmp(addr, pred->str_val, pred->str_len); | 198 | cmp = pred->regex.match(addr, &pred->regex, pred->regex.field_len); |
201 | 199 | ||
202 | match = (!cmp) ^ pred->not; | 200 | match = cmp ^ pred->not; |
203 | 201 | ||
204 | return match; | 202 | return match; |
205 | } | 203 | } |
@@ -211,9 +209,9 @@ static int filter_pred_pchar(struct filter_pred *pred, void *event, | |||
211 | char **addr = (char **)(event + pred->offset); | 209 | char **addr = (char **)(event + pred->offset); |
212 | int cmp, match; | 210 | int cmp, match; |
213 | 211 | ||
214 | cmp = strncmp(*addr, pred->str_val, pred->str_len); | 212 | cmp = pred->regex.match(*addr, &pred->regex, pred->regex.field_len); |
215 | 213 | ||
216 | match = (!cmp) ^ pred->not; | 214 | match = cmp ^ pred->not; |
217 | 215 | ||
218 | return match; | 216 | return match; |
219 | } | 217 | } |
@@ -237,9 +235,9 @@ static int filter_pred_strloc(struct filter_pred *pred, void *event, | |||
237 | char *addr = (char *)(event + str_loc); | 235 | char *addr = (char *)(event + str_loc); |
238 | int cmp, match; | 236 | int cmp, match; |
239 | 237 | ||
240 | cmp = strncmp(addr, pred->str_val, str_len); | 238 | cmp = pred->regex.match(addr, &pred->regex, str_len); |
241 | 239 | ||
242 | match = (!cmp) ^ pred->not; | 240 | match = cmp ^ pred->not; |
243 | 241 | ||
244 | return match; | 242 | return match; |
245 | } | 243 | } |
@@ -250,6 +248,124 @@ static int filter_pred_none(struct filter_pred *pred, void *event, | |||
250 | return 0; | 248 | return 0; |
251 | } | 249 | } |
252 | 250 | ||
251 | /* Basic regex callbacks */ | ||
252 | static int regex_match_full(char *str, struct regex *r, int len) | ||
253 | { | ||
254 | if (strncmp(str, r->pattern, len) == 0) | ||
255 | return 1; | ||
256 | return 0; | ||
257 | } | ||
258 | |||
259 | static int regex_match_front(char *str, struct regex *r, int len) | ||
260 | { | ||
261 | if (strncmp(str, r->pattern, len) == 0) | ||
262 | return 1; | ||
263 | return 0; | ||
264 | } | ||
265 | |||
266 | static int regex_match_middle(char *str, struct regex *r, int len) | ||
267 | { | ||
268 | if (strstr(str, r->pattern)) | ||
269 | return 1; | ||
270 | return 0; | ||
271 | } | ||
272 | |||
273 | static int regex_match_end(char *str, struct regex *r, int len) | ||
274 | { | ||
275 | char *ptr = strstr(str, r->pattern); | ||
276 | |||
277 | if (ptr && (ptr[r->len] == 0)) | ||
278 | return 1; | ||
279 | return 0; | ||
280 | } | ||
281 | |||
282 | /** | ||
283 | * filter_parse_regex - parse a basic regex | ||
284 | * @buff: the raw regex | ||
285 | * @len: length of the regex | ||
286 | * @search: will point to the beginning of the string to compare | ||
287 | * @not: tell whether the match will have to be inverted | ||
288 | * | ||
289 | * This passes in a buffer containing a regex and this function will | ||
290 | * set search to point to the search part of the buffer and | ||
291 | * return the type of search it is (see enum above). | ||
292 | * This does modify buff. | ||
293 | * | ||
294 | * Returns enum type. | ||
295 | * search returns the pointer to use for comparison. | ||
296 | * not returns 1 if buff started with a '!' | ||
297 | * 0 otherwise. | ||
298 | */ | ||
299 | enum regex_type filter_parse_regex(char *buff, int len, char **search, int *not) | ||
300 | { | ||
301 | int type = MATCH_FULL; | ||
302 | int i; | ||
303 | |||
304 | if (buff[0] == '!') { | ||
305 | *not = 1; | ||
306 | buff++; | ||
307 | len--; | ||
308 | } else | ||
309 | *not = 0; | ||
310 | |||
311 | *search = buff; | ||
312 | |||
313 | for (i = 0; i < len; i++) { | ||
314 | if (buff[i] == '*') { | ||
315 | if (!i) { | ||
316 | *search = buff + 1; | ||
317 | type = MATCH_END_ONLY; | ||
318 | } else { | ||
319 | if (type == MATCH_END_ONLY) | ||
320 | type = MATCH_MIDDLE_ONLY; | ||
321 | else | ||
322 | type = MATCH_FRONT_ONLY; | ||
323 | buff[i] = 0; | ||
324 | break; | ||
325 | } | ||
326 | } | ||
327 | } | ||
328 | |||
329 | return type; | ||
330 | } | ||
331 | |||
332 | static int filter_build_regex(struct filter_pred *pred) | ||
333 | { | ||
334 | struct regex *r = &pred->regex; | ||
335 | char *search, *dup; | ||
336 | enum regex_type type; | ||
337 | int not; | ||
338 | |||
339 | type = filter_parse_regex(r->pattern, r->len, &search, ¬); | ||
340 | dup = kstrdup(search, GFP_KERNEL); | ||
341 | if (!dup) | ||
342 | return -ENOMEM; | ||
343 | |||
344 | strcpy(r->pattern, dup); | ||
345 | kfree(dup); | ||
346 | |||
347 | r->len = strlen(r->pattern); | ||
348 | |||
349 | switch (type) { | ||
350 | case MATCH_FULL: | ||
351 | r->match = regex_match_full; | ||
352 | break; | ||
353 | case MATCH_FRONT_ONLY: | ||
354 | r->match = regex_match_front; | ||
355 | break; | ||
356 | case MATCH_MIDDLE_ONLY: | ||
357 | r->match = regex_match_middle; | ||
358 | break; | ||
359 | case MATCH_END_ONLY: | ||
360 | r->match = regex_match_end; | ||
361 | break; | ||
362 | } | ||
363 | |||
364 | pred->not ^= not; | ||
365 | |||
366 | return 0; | ||
367 | } | ||
368 | |||
253 | /* return 1 if event matches, 0 otherwise (discard) */ | 369 | /* return 1 if event matches, 0 otherwise (discard) */ |
254 | int filter_match_preds(struct ftrace_event_call *call, void *rec) | 370 | int filter_match_preds(struct ftrace_event_call *call, void *rec) |
255 | { | 371 | { |
@@ -396,7 +512,7 @@ static void filter_clear_pred(struct filter_pred *pred) | |||
396 | { | 512 | { |
397 | kfree(pred->field_name); | 513 | kfree(pred->field_name); |
398 | pred->field_name = NULL; | 514 | pred->field_name = NULL; |
399 | pred->str_len = 0; | 515 | pred->regex.len = 0; |
400 | } | 516 | } |
401 | 517 | ||
402 | static int filter_set_pred(struct filter_pred *dest, | 518 | static int filter_set_pred(struct filter_pred *dest, |
@@ -660,21 +776,24 @@ static int filter_add_pred(struct filter_parse_state *ps, | |||
660 | } | 776 | } |
661 | 777 | ||
662 | if (is_string_field(field)) { | 778 | if (is_string_field(field)) { |
663 | pred->str_len = field->size; | 779 | ret = filter_build_regex(pred); |
780 | if (ret) | ||
781 | return ret; | ||
664 | 782 | ||
665 | if (field->filter_type == FILTER_STATIC_STRING) | 783 | if (field->filter_type == FILTER_STATIC_STRING) { |
666 | fn = filter_pred_string; | 784 | fn = filter_pred_string; |
667 | else if (field->filter_type == FILTER_DYN_STRING) | 785 | pred->regex.field_len = field->size; |
668 | fn = filter_pred_strloc; | 786 | } else if (field->filter_type == FILTER_DYN_STRING) |
787 | fn = filter_pred_strloc; | ||
669 | else { | 788 | else { |
670 | fn = filter_pred_pchar; | 789 | fn = filter_pred_pchar; |
671 | pred->str_len = strlen(pred->str_val); | 790 | pred->regex.field_len = strlen(pred->regex.pattern); |
672 | } | 791 | } |
673 | } else { | 792 | } else { |
674 | if (field->is_signed) | 793 | if (field->is_signed) |
675 | ret = strict_strtoll(pred->str_val, 0, &val); | 794 | ret = strict_strtoll(pred->regex.pattern, 0, &val); |
676 | else | 795 | else |
677 | ret = strict_strtoull(pred->str_val, 0, &val); | 796 | ret = strict_strtoull(pred->regex.pattern, 0, &val); |
678 | if (ret) { | 797 | if (ret) { |
679 | parse_error(ps, FILT_ERR_ILLEGAL_INTVAL, 0); | 798 | parse_error(ps, FILT_ERR_ILLEGAL_INTVAL, 0); |
680 | return -EINVAL; | 799 | return -EINVAL; |
@@ -1045,8 +1164,8 @@ static struct filter_pred *create_pred(int op, char *operand1, char *operand2) | |||
1045 | return NULL; | 1164 | return NULL; |
1046 | } | 1165 | } |
1047 | 1166 | ||
1048 | strcpy(pred->str_val, operand2); | 1167 | strcpy(pred->regex.pattern, operand2); |
1049 | pred->str_len = strlen(operand2); | 1168 | pred->regex.len = strlen(pred->regex.pattern); |
1050 | 1169 | ||
1051 | pred->op = op; | 1170 | pred->op = op; |
1052 | 1171 | ||
diff --git a/kernel/trace/trace_syscalls.c b/kernel/trace/trace_syscalls.c index 527e17eae575..ddee9c593732 100644 --- a/kernel/trace/trace_syscalls.c +++ b/kernel/trace/trace_syscalls.c | |||
@@ -14,6 +14,69 @@ static int sys_refcount_exit; | |||
14 | static DECLARE_BITMAP(enabled_enter_syscalls, NR_syscalls); | 14 | static DECLARE_BITMAP(enabled_enter_syscalls, NR_syscalls); |
15 | static DECLARE_BITMAP(enabled_exit_syscalls, NR_syscalls); | 15 | static DECLARE_BITMAP(enabled_exit_syscalls, NR_syscalls); |
16 | 16 | ||
17 | extern unsigned long __start_syscalls_metadata[]; | ||
18 | extern unsigned long __stop_syscalls_metadata[]; | ||
19 | |||
20 | static struct syscall_metadata **syscalls_metadata; | ||
21 | |||
22 | static struct syscall_metadata *find_syscall_meta(unsigned long syscall) | ||
23 | { | ||
24 | struct syscall_metadata *start; | ||
25 | struct syscall_metadata *stop; | ||
26 | char str[KSYM_SYMBOL_LEN]; | ||
27 | |||
28 | |||
29 | start = (struct syscall_metadata *)__start_syscalls_metadata; | ||
30 | stop = (struct syscall_metadata *)__stop_syscalls_metadata; | ||
31 | kallsyms_lookup(syscall, NULL, NULL, NULL, str); | ||
32 | |||
33 | for ( ; start < stop; start++) { | ||
34 | /* | ||
35 | * Only compare after the "sys" prefix. Archs that use | ||
36 | * syscall wrappers may have syscalls symbols aliases prefixed | ||
37 | * with "SyS" instead of "sys", leading to an unwanted | ||
38 | * mismatch. | ||
39 | */ | ||
40 | if (start->name && !strcmp(start->name + 3, str + 3)) | ||
41 | return start; | ||
42 | } | ||
43 | return NULL; | ||
44 | } | ||
45 | |||
46 | static struct syscall_metadata *syscall_nr_to_meta(int nr) | ||
47 | { | ||
48 | if (!syscalls_metadata || nr >= NR_syscalls || nr < 0) | ||
49 | return NULL; | ||
50 | |||
51 | return syscalls_metadata[nr]; | ||
52 | } | ||
53 | |||
54 | int syscall_name_to_nr(char *name) | ||
55 | { | ||
56 | int i; | ||
57 | |||
58 | if (!syscalls_metadata) | ||
59 | return -1; | ||
60 | |||
61 | for (i = 0; i < NR_syscalls; i++) { | ||
62 | if (syscalls_metadata[i]) { | ||
63 | if (!strcmp(syscalls_metadata[i]->name, name)) | ||
64 | return i; | ||
65 | } | ||
66 | } | ||
67 | return -1; | ||
68 | } | ||
69 | |||
70 | void set_syscall_enter_id(int num, int id) | ||
71 | { | ||
72 | syscalls_metadata[num]->enter_id = id; | ||
73 | } | ||
74 | |||
75 | void set_syscall_exit_id(int num, int id) | ||
76 | { | ||
77 | syscalls_metadata[num]->exit_id = id; | ||
78 | } | ||
79 | |||
17 | enum print_line_t | 80 | enum print_line_t |
18 | print_syscall_enter(struct trace_iterator *iter, int flags) | 81 | print_syscall_enter(struct trace_iterator *iter, int flags) |
19 | { | 82 | { |
@@ -375,6 +438,29 @@ struct trace_event event_syscall_exit = { | |||
375 | .trace = print_syscall_exit, | 438 | .trace = print_syscall_exit, |
376 | }; | 439 | }; |
377 | 440 | ||
441 | int __init init_ftrace_syscalls(void) | ||
442 | { | ||
443 | struct syscall_metadata *meta; | ||
444 | unsigned long addr; | ||
445 | int i; | ||
446 | |||
447 | syscalls_metadata = kzalloc(sizeof(*syscalls_metadata) * | ||
448 | NR_syscalls, GFP_KERNEL); | ||
449 | if (!syscalls_metadata) { | ||
450 | WARN_ON(1); | ||
451 | return -ENOMEM; | ||
452 | } | ||
453 | |||
454 | for (i = 0; i < NR_syscalls; i++) { | ||
455 | addr = arch_syscall_addr(i); | ||
456 | meta = find_syscall_meta(addr); | ||
457 | syscalls_metadata[i] = meta; | ||
458 | } | ||
459 | |||
460 | return 0; | ||
461 | } | ||
462 | core_initcall(init_ftrace_syscalls); | ||
463 | |||
378 | #ifdef CONFIG_EVENT_PROFILE | 464 | #ifdef CONFIG_EVENT_PROFILE |
379 | 465 | ||
380 | static DECLARE_BITMAP(enabled_prof_enter_syscalls, NR_syscalls); | 466 | static DECLARE_BITMAP(enabled_prof_enter_syscalls, NR_syscalls); |