1 /* 2 * probe-file.c : operate ftrace k/uprobe events files 3 * 4 * Written by Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com> 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License as published by 8 * the Free Software Foundation; either version 2 of the License, or 9 * (at your option) any later version. 10 * 11 * This program is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * GNU General Public License for more details. 15 * 16 */ 17 #include "util.h" 18 #include "event.h" 19 #include "strlist.h" 20 #include "debug.h" 21 #include "cache.h" 22 #include "color.h" 23 #include "symbol.h" 24 #include "thread.h" 25 #include <api/fs/debugfs.h> 26 #include <api/fs/tracefs.h> 27 #include "probe-event.h" 28 #include "probe-file.h" 29 #include "session.h" 30 31 #define MAX_CMDLEN 256 32 33 static void print_open_warning(int err, bool uprobe) 34 { 35 char sbuf[STRERR_BUFSIZE]; 36 37 if (err == -ENOENT) { 38 const char *config; 39 40 if (uprobe) 41 config = "CONFIG_UPROBE_EVENTS"; 42 else 43 config = "CONFIG_KPROBE_EVENTS"; 44 45 pr_warning("%cprobe_events file does not exist" 46 " - please rebuild kernel with %s.\n", 47 uprobe ? 'u' : 'k', config); 48 } else if (err == -ENOTSUP) 49 pr_warning("Tracefs or debugfs is not mounted.\n"); 50 else 51 pr_warning("Failed to open %cprobe_events: %s\n", 52 uprobe ? 'u' : 'k', 53 strerror_r(-err, sbuf, sizeof(sbuf))); 54 } 55 56 static void print_both_open_warning(int kerr, int uerr) 57 { 58 /* Both kprobes and uprobes are disabled, warn it. */ 59 if (kerr == -ENOTSUP && uerr == -ENOTSUP) 60 pr_warning("Tracefs or debugfs is not mounted.\n"); 61 else if (kerr == -ENOENT && uerr == -ENOENT) 62 pr_warning("Please rebuild kernel with CONFIG_KPROBE_EVENTS " 63 "or/and CONFIG_UPROBE_EVENTS.\n"); 64 else { 65 char sbuf[STRERR_BUFSIZE]; 66 pr_warning("Failed to open kprobe events: %s.\n", 67 strerror_r(-kerr, sbuf, sizeof(sbuf))); 68 pr_warning("Failed to open uprobe events: %s.\n", 69 strerror_r(-uerr, sbuf, sizeof(sbuf))); 70 } 71 } 72 73 static int open_probe_events(const char *trace_file, bool readwrite) 74 { 75 char buf[PATH_MAX]; 76 const char *__debugfs; 77 const char *tracing_dir = ""; 78 int ret; 79 80 __debugfs = tracefs_find_mountpoint(); 81 if (__debugfs == NULL) { 82 tracing_dir = "tracing/"; 83 84 __debugfs = debugfs_find_mountpoint(); 85 if (__debugfs == NULL) 86 return -ENOTSUP; 87 } 88 89 ret = e_snprintf(buf, PATH_MAX, "%s/%s%s", 90 __debugfs, tracing_dir, trace_file); 91 if (ret >= 0) { 92 pr_debug("Opening %s write=%d\n", buf, readwrite); 93 if (readwrite && !probe_event_dry_run) 94 ret = open(buf, O_RDWR | O_APPEND, 0); 95 else 96 ret = open(buf, O_RDONLY, 0); 97 98 if (ret < 0) 99 ret = -errno; 100 } 101 return ret; 102 } 103 104 static int open_kprobe_events(bool readwrite) 105 { 106 return open_probe_events("kprobe_events", readwrite); 107 } 108 109 static int open_uprobe_events(bool readwrite) 110 { 111 return open_probe_events("uprobe_events", readwrite); 112 } 113 114 int probe_file__open(int flag) 115 { 116 int fd; 117 118 if (flag & PF_FL_UPROBE) 119 fd = open_uprobe_events(flag & PF_FL_RW); 120 else 121 fd = open_kprobe_events(flag & PF_FL_RW); 122 if (fd < 0) 123 print_open_warning(fd, flag & PF_FL_UPROBE); 124 125 return fd; 126 } 127 128 int probe_file__open_both(int *kfd, int *ufd, int flag) 129 { 130 if (!kfd || !ufd) 131 return -EINVAL; 132 133 *kfd = open_kprobe_events(flag & PF_FL_RW); 134 *ufd = open_uprobe_events(flag & PF_FL_RW); 135 if (*kfd < 0 && *ufd < 0) { 136 print_both_open_warning(*kfd, *ufd); 137 return *kfd; 138 } 139 140 return 0; 141 } 142 143 /* Get raw string list of current kprobe_events or uprobe_events */ 144 struct strlist *probe_file__get_rawlist(int fd) 145 { 146 int ret, idx; 147 FILE *fp; 148 char buf[MAX_CMDLEN]; 149 char *p; 150 struct strlist *sl; 151 152 sl = strlist__new(NULL, NULL); 153 154 fp = fdopen(dup(fd), "r"); 155 while (!feof(fp)) { 156 p = fgets(buf, MAX_CMDLEN, fp); 157 if (!p) 158 break; 159 160 idx = strlen(p) - 1; 161 if (p[idx] == '\n') 162 p[idx] = '\0'; 163 ret = strlist__add(sl, buf); 164 if (ret < 0) { 165 pr_debug("strlist__add failed (%d)\n", ret); 166 strlist__delete(sl); 167 return NULL; 168 } 169 } 170 fclose(fp); 171 172 return sl; 173 } 174 175 static struct strlist *__probe_file__get_namelist(int fd, bool include_group) 176 { 177 char buf[128]; 178 struct strlist *sl, *rawlist; 179 struct str_node *ent; 180 struct probe_trace_event tev; 181 int ret = 0; 182 183 memset(&tev, 0, sizeof(tev)); 184 rawlist = probe_file__get_rawlist(fd); 185 if (!rawlist) 186 return NULL; 187 sl = strlist__new(NULL, NULL); 188 strlist__for_each(ent, rawlist) { 189 ret = parse_probe_trace_command(ent->s, &tev); 190 if (ret < 0) 191 break; 192 if (include_group) { 193 ret = e_snprintf(buf, 128, "%s:%s", tev.group, 194 tev.event); 195 if (ret >= 0) 196 ret = strlist__add(sl, buf); 197 } else 198 ret = strlist__add(sl, tev.event); 199 clear_probe_trace_event(&tev); 200 if (ret < 0) 201 break; 202 } 203 strlist__delete(rawlist); 204 205 if (ret < 0) { 206 strlist__delete(sl); 207 return NULL; 208 } 209 return sl; 210 } 211 212 /* Get current perf-probe event names */ 213 struct strlist *probe_file__get_namelist(int fd) 214 { 215 return __probe_file__get_namelist(fd, false); 216 } 217 218 int probe_file__add_event(int fd, struct probe_trace_event *tev) 219 { 220 int ret = 0; 221 char *buf = synthesize_probe_trace_command(tev); 222 char sbuf[STRERR_BUFSIZE]; 223 224 if (!buf) { 225 pr_debug("Failed to synthesize probe trace event.\n"); 226 return -EINVAL; 227 } 228 229 pr_debug("Writing event: %s\n", buf); 230 if (!probe_event_dry_run) { 231 ret = write(fd, buf, strlen(buf)); 232 if (ret <= 0) { 233 ret = -errno; 234 pr_warning("Failed to write event: %s\n", 235 strerror_r(errno, sbuf, sizeof(sbuf))); 236 } 237 } 238 free(buf); 239 240 return ret; 241 } 242 243 static int __del_trace_probe_event(int fd, struct str_node *ent) 244 { 245 char *p; 246 char buf[128]; 247 int ret; 248 249 /* Convert from perf-probe event to trace-probe event */ 250 ret = e_snprintf(buf, 128, "-:%s", ent->s); 251 if (ret < 0) 252 goto error; 253 254 p = strchr(buf + 2, ':'); 255 if (!p) { 256 pr_debug("Internal error: %s should have ':' but not.\n", 257 ent->s); 258 ret = -ENOTSUP; 259 goto error; 260 } 261 *p = '/'; 262 263 pr_debug("Writing event: %s\n", buf); 264 ret = write(fd, buf, strlen(buf)); 265 if (ret < 0) { 266 ret = -errno; 267 goto error; 268 } 269 270 pr_info("Removed event: %s\n", ent->s); 271 return 0; 272 error: 273 pr_warning("Failed to delete event: %s\n", 274 strerror_r(-ret, buf, sizeof(buf))); 275 return ret; 276 } 277 278 int probe_file__del_events(int fd, struct strfilter *filter) 279 { 280 struct strlist *namelist; 281 struct str_node *ent; 282 const char *p; 283 int ret = -ENOENT; 284 285 namelist = __probe_file__get_namelist(fd, true); 286 if (!namelist) 287 return -ENOENT; 288 289 strlist__for_each(ent, namelist) { 290 p = strchr(ent->s, ':'); 291 if ((p && strfilter__compare(filter, p + 1)) || 292 strfilter__compare(filter, ent->s)) { 293 ret = __del_trace_probe_event(fd, ent); 294 if (ret < 0) 295 break; 296 } 297 } 298 strlist__delete(namelist); 299 300 return ret; 301 } 302