Debian Codegraph @

runtime/linux/stap-hw-breakpoint.h

raw
1 /* -*- linux-c -*-
2 * Utility functions for handling haredware breakpoints (watchpoints).
3 *
4 * Copyright (C) 2023 by OpenResty Inc.
5 * This file is part of systemtap, and is free software. You can
6 * redistribute it and/or modify it under the terms of the GNU General
7 * Public License (GPL); either version 2, or (at your option) any
8 * later version.
9 */
10
11 #ifndef _STP_HW_BREAKPOINT_H_INCLUDED_
12 #define _STP_HW_BREAKPOINT_H_INCLUDED_
13
14 #ifndef IS_ERR_PCPU
15 /* Need to define our own IS_ERR_PCPU for Linux 6.11 and older */
16 #define IS_ERR_PCPU(ptr) (IS_ERR((const void *)(__force const unsigned long)(ptr)))
17 #endif
18
19 struct stap_hwbkpt_probe {
20 bool kernel_p;
21
22 bool registered_p;
23 // registered_p = false signifies a probe that is unregistered (or failed)
24 // registered_p = true signifies a probe that got registered successfully
25
26 uint8_t atype;
27 unsigned int len;
28
29 // Symbol Names are mostly small and uniform enough
30 // to justify putting const char*.
31 const char * const symbol;
32
33 const unsigned long address;
34 const struct stap_probe * const probe;
35 };
36
37
38 static inline void
39 stap_hwbkpt_exit(struct stap_hwbkpt_probe *probes, int probe_count,
40 struct perf_event ** u_ret_array, struct perf_event * __percpu ** k_ret_array)
41 {
42 int i;
43 //Unregister hwbkpt probes.
44 for (i=0; i<probe_count; i++) {
45 struct stap_hwbkpt_probe *skp = & probes[i];
46 if (unlikely(!skp->registered_p)) continue;
47 if (skp->kernel_p) {
48 unregister_wide_hw_breakpoint(k_ret_array[i]);
49 } else {
50 unregister_hw_breakpoint(u_ret_array[i]); // dual to register_user_hw_breakpoint
51 }
52 skp->registered_p = false;
53 }
54 }
55
56
57
58 static inline int
59 stap_hwbkpt_init(perf_overflow_handler_t triggered, struct stap_hwbkpt_probe *probes, int probe_count,
60 struct perf_event_attr *probe_array,
61 struct perf_event ** u_ret_array, struct perf_event * __percpu ** k_ret_array,
62 const char **probe_point_ptr)
63 {
64 int rc = 0;
65 int i;
66
67 if (unlikely(probe_count == 0)) /* do nothing */
68 return 0;
69
70 for (i=0; i<probe_count; i++) {
71 struct stap_hwbkpt_probe *skp = & probes[i];
72 struct perf_event_attr *hp = & probe_array[i];
73 void *addr = (void *) skp->address;
74 const char *hwbkpt_symbol_name = addr ? NULL : skp->symbol;
75 hw_breakpoint_init(hp);
76 if (addr)
77 hp->bp_addr = (unsigned long) addr;
78 else {
79 hp->bp_addr = kallsyms_lookup_name(hwbkpt_symbol_name);
80 if (!hp->bp_addr) {
81 _stp_error("Probe %s registration failed: invalid symbol '%s' ",
82 skp->probe->pp, hwbkpt_symbol_name);
83 rc = -EINVAL;
84 skp->registered_p = false;
85 break;
86 }
87 }
88 hp->bp_type = skp->atype;
89
90 // Convert actual len to bp len.
91 switch(skp->len) {
92 case 1:
93 hp->bp_len = HW_BREAKPOINT_LEN_1;
94 break;
95 case 2:
96 hp->bp_len = HW_BREAKPOINT_LEN_2;
97 break;
98 case 3:
99 case 4:
100 hp->bp_len = HW_BREAKPOINT_LEN_4;
101 break;
102 case 5:
103 case 6:
104 case 7:
105 case 8:
106 default: // XXX: could instead reject
107 hp->bp_len = HW_BREAKPOINT_LEN_8;
108 break;
109 }
110
111 *probe_point_ptr = skp->probe->pp; // for error messages
112
113 #ifdef STAPCONF_HW_BREAKPOINT_CONTEXT
114 if (skp->kernel_p) {
115 #ifdef DEBUG_PROBES
116 pr_warn("%s:%d: registering kernel-mode hw breakpoint at %#lx\n",
117 __func__, __LINE__, (unsigned long) hp->bp_addr);
118 #endif
119 k_ret_array[i] = register_wide_hw_breakpoint(hp, triggered, NULL);
120 if (IS_ERR_PCPU(k_ret_array[i]))
121 {
122 _stp_error("Hwbkpt probe %s: registration error [man warning::pass5] %d, addr %#lx, name %s",
123 skp->probe->pp, rc, (unsigned long) addr, hwbkpt_symbol_name);
124 }
125 else
126 skp->registered_p = true;
127 } else {
128 if (likely(_stp_target > 0)) {
129 struct task_struct *tsk;
130 rcu_read_lock();
131 tsk = get_pid_task(find_vpid(_stp_orig_target), PIDTYPE_PID);
132 rcu_read_unlock();
133 if (unlikely(tsk == NULL)) {
134 u_ret_array[i] = ERR_PTR(-ESRCH);
135 } else {
136 #ifdef DEBUG_PROBES
137 pr_warn("%s:%d: registering user hw breakpoint for pid %d (%s) at addr %#lx\n",
138 __func__, __LINE__, _stp_target, tsk->comm,
139 (unsigned long) hp->bp_addr);
140 #endif
141 u_ret_array[i] = register_user_hw_breakpoint(hp, triggered, NULL, tsk);
142 if (IS_ERR(u_ret_array[i]))
143 {
144 _stp_error("Hwbkpt probe %s: registration error [man warning::pass5] %d, addr %#lx, name %s",
145 skp->probe->pp, rc, (unsigned long) addr, hwbkpt_symbol_name);
146 }
147 else
148 skp->registered_p = true;
149 put_task_struct(tsk);
150 } /* tsk != NULL */
151 } else { /* _stp_target <= 0 */
152 u_ret_array[i] = ERR_PTR(-ESRCH);
153 }
154 } /* !skp->kernel_p */
155 #else /* !defined(STAPCONF_HW_BREAKPOINT_CONTEXT) */
156 if (unlikely(!skp->kernel_p))
157 u_ret_array[i] = ERR_PTR(-ENOTSUP);
158 else {
159 k_ret_array[i] = register_wide_hw_breakpoint(hp, triggered);
160 if (IS_ERR_PCPU(k_ret_array[i]))
161 {
162 _stp_error("Hwbkpt probe %s: registration error [man warning::pass5] %d, addr %#lx, name %s",
163 skp->probe->pp, rc, (unsigned long) addr, hwbkpt_symbol_name);
164 }
165 else
166 skp->registered_p = true;
167 }
168 #endif
169 } // for loop
170
171 if (unlikely(rc)) {
172 stap_hwbkpt_exit(probes, probe_count, u_ret_array, k_ret_array);
173 }
174
175 return rc;
176 }
177
178
179 #endif /* _STP_HW_BREAKPOINT_H_INCLUDED_ */