Grant Edwards | 8a08277 | 2011-04-07 20:25:40 +0000 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (c) 2011, Comtrol Corp. |
| 3 | * All rights reserved. |
| 4 | * |
| 5 | * Redistribution and use in source and binary forms, with or without |
| 6 | * modification, are permitted provided that the following conditions |
| 7 | * are met: |
| 8 | * 1. Redistributions of source code must retain the above copyright |
| 9 | * notice, this list of conditions and the following disclaimer. |
| 10 | * 2. Redistributions in binary form must reproduce the above copyright |
| 11 | * notice, this list of conditions and the following disclaimer in the |
| 12 | * documentation and/or other materials provided with the distribution. |
| 13 | * 3. The name of the author may not be used to endorse or promote products |
| 14 | * derived from this software without specific prior written permission. |
| 15 | * |
| 16 | * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| 17 | * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| 18 | * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| 19 | * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| 20 | * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| 21 | * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| 22 | * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| 23 | * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| 24 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| 25 | * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| 26 | * |
| 27 | */ |
| 28 | |
| 29 | #include "defs.h" |
| 30 | |
| 31 | #include <ctype.h> |
Dmitry V. Levin | b038a43 | 2011-08-30 16:05:26 +0000 | [diff] [blame] | 32 | #include <sys/param.h> |
Grant Edwards | 8a08277 | 2011-04-07 20:25:40 +0000 | [diff] [blame] | 33 | |
| 34 | #ifdef HAVE_POLL_H |
| 35 | #include <poll.h> |
| 36 | #endif |
| 37 | #ifdef HAVE_SYS_POLL_H |
| 38 | #include <sys/poll.h> |
| 39 | #endif |
| 40 | |
| 41 | #include "syscall.h" |
| 42 | |
Grant Edwards | 8a08277 | 2011-04-07 20:25:40 +0000 | [diff] [blame] | 43 | #define MAXSELECTED 256 /* max number of "selected" paths */ |
| 44 | static const char *selected[MAXSELECTED]; /* paths selected for tracing */ |
| 45 | |
| 46 | /* |
| 47 | * Return true if specified path matches one that we're tracing. |
| 48 | */ |
| 49 | static int |
| 50 | pathmatch(const char *path) |
| 51 | { |
Dmitry V. Levin | fcda7a5 | 2011-06-13 21:58:43 +0000 | [diff] [blame] | 52 | unsigned int i; |
Grant Edwards | 8a08277 | 2011-04-07 20:25:40 +0000 | [diff] [blame] | 53 | |
Denys Vlasenko | 7b609d5 | 2011-06-22 14:32:43 +0200 | [diff] [blame] | 54 | for (i = 0; i < ARRAY_SIZE(selected); ++i) { |
Grant Edwards | 8a08277 | 2011-04-07 20:25:40 +0000 | [diff] [blame] | 55 | if (selected[i] == NULL) |
| 56 | return 0; |
| 57 | if (!strcmp(path, selected[i])) |
| 58 | return 1; |
| 59 | } |
| 60 | return 0; |
| 61 | } |
| 62 | |
| 63 | /* |
| 64 | * Return true if specified path (in user-space) matches. |
| 65 | */ |
| 66 | static int |
| 67 | upathmatch(struct tcb *tcp, unsigned long upath) |
| 68 | { |
Denys Vlasenko | 7b609d5 | 2011-06-22 14:32:43 +0200 | [diff] [blame] | 69 | char path[PATH_MAX + 1]; |
Grant Edwards | 8a08277 | 2011-04-07 20:25:40 +0000 | [diff] [blame] | 70 | |
Denys Vlasenko | 6cecba5 | 2012-01-20 11:56:00 +0100 | [diff] [blame] | 71 | return umovestr(tcp, upath, sizeof path, path) >= 0 && |
Grant Edwards | 8a08277 | 2011-04-07 20:25:40 +0000 | [diff] [blame] | 72 | pathmatch(path); |
| 73 | } |
| 74 | |
| 75 | /* |
| 76 | * Return true if specified fd maps to a path we're tracing. |
| 77 | */ |
| 78 | static int |
| 79 | fdmatch(struct tcb *tcp, int fd) |
| 80 | { |
| 81 | const char *path = getfdpath(tcp, fd); |
| 82 | |
| 83 | return path && pathmatch(path); |
| 84 | } |
| 85 | |
| 86 | /* |
| 87 | * Add a path to the set we're tracing. |
| 88 | * Secifying NULL will delete all paths. |
| 89 | */ |
| 90 | static int |
| 91 | storepath(const char *path) |
| 92 | { |
Dmitry V. Levin | fcda7a5 | 2011-06-13 21:58:43 +0000 | [diff] [blame] | 93 | unsigned int i; |
Grant Edwards | 8a08277 | 2011-04-07 20:25:40 +0000 | [diff] [blame] | 94 | |
Denys Vlasenko | 7b609d5 | 2011-06-22 14:32:43 +0200 | [diff] [blame] | 95 | if (path == NULL) { |
Dmitry V. Levin | fcda7a5 | 2011-06-13 21:58:43 +0000 | [diff] [blame] | 96 | for (i = 0; i < ARRAY_SIZE(selected); ++i) |
Denys Vlasenko | 7b609d5 | 2011-06-22 14:32:43 +0200 | [diff] [blame] | 97 | if (selected[i]) { |
Grant Edwards | 8a08277 | 2011-04-07 20:25:40 +0000 | [diff] [blame] | 98 | free((char *) selected[i]); |
| 99 | selected[i] = NULL; |
| 100 | } |
| 101 | return 0; |
| 102 | } |
| 103 | |
Dmitry V. Levin | fcda7a5 | 2011-06-13 21:58:43 +0000 | [diff] [blame] | 104 | for (i = 0; i < ARRAY_SIZE(selected); ++i) |
Denys Vlasenko | 7b609d5 | 2011-06-22 14:32:43 +0200 | [diff] [blame] | 105 | if (!selected[i]) { |
Grant Edwards | 8a08277 | 2011-04-07 20:25:40 +0000 | [diff] [blame] | 106 | selected[i] = path; |
| 107 | return 0; |
| 108 | } |
| 109 | |
Dmitry V. Levin | fcda7a5 | 2011-06-13 21:58:43 +0000 | [diff] [blame] | 110 | fprintf(stderr, "Max trace paths exceeded, only using first %u\n", |
| 111 | (unsigned int) ARRAY_SIZE(selected)); |
Grant Edwards | 8a08277 | 2011-04-07 20:25:40 +0000 | [diff] [blame] | 112 | return -1; |
| 113 | } |
| 114 | |
| 115 | /* |
| 116 | * Get path associated with fd. |
| 117 | */ |
| 118 | const char *getfdpath(struct tcb *tcp, int fd) |
| 119 | { |
Grant Edwards | 8a08277 | 2011-04-07 20:25:40 +0000 | [diff] [blame] | 120 | static char path[PATH_MAX+1]; |
| 121 | char linkpath[64]; |
| 122 | ssize_t n; |
| 123 | |
| 124 | if (fd < 0) |
| 125 | return NULL; |
| 126 | |
| 127 | snprintf(linkpath, sizeof linkpath, "/proc/%d/fd/%d", tcp->pid, fd); |
| 128 | n = readlink(linkpath, path, (sizeof path) - 1); |
| 129 | if (n <= 0) |
| 130 | return NULL; |
| 131 | path[n] = '\0'; |
| 132 | return path; |
Grant Edwards | 8a08277 | 2011-04-07 20:25:40 +0000 | [diff] [blame] | 133 | } |
| 134 | |
| 135 | /* |
| 136 | * Add a path to the set we're tracing. Also add the canonicalized |
| 137 | * version of the path. Secifying NULL will delete all paths. |
| 138 | */ |
| 139 | int |
| 140 | pathtrace_select(const char *path) |
| 141 | { |
| 142 | char *rpath; |
| 143 | |
| 144 | if (path == NULL) |
| 145 | return storepath(path); |
| 146 | |
| 147 | if (storepath(path)) |
| 148 | return -1; |
| 149 | |
| 150 | rpath = realpath(path, NULL); |
| 151 | |
| 152 | if (rpath == NULL) |
| 153 | return 0; |
| 154 | |
| 155 | /* if realpath and specified path are same, we're done */ |
Denys Vlasenko | 7b609d5 | 2011-06-22 14:32:43 +0200 | [diff] [blame] | 156 | if (!strcmp(path, rpath)) { |
Grant Edwards | 8a08277 | 2011-04-07 20:25:40 +0000 | [diff] [blame] | 157 | free(rpath); |
| 158 | return 0; |
| 159 | } |
| 160 | |
| 161 | fprintf(stderr, "Requested path '%s' resolved into '%s'\n", |
| 162 | path, rpath); |
| 163 | return storepath(rpath); |
| 164 | } |
| 165 | |
| 166 | /* |
| 167 | * Return true if syscall accesses a selected path |
| 168 | * (or if no paths have been specified for tracing). |
| 169 | */ |
| 170 | int |
| 171 | pathtrace_match(struct tcb *tcp) |
| 172 | { |
| 173 | const struct sysent *s; |
| 174 | |
| 175 | if (selected[0] == NULL) |
| 176 | return 1; |
| 177 | |
Dmitry V. Levin | bdec9cb | 2012-02-06 17:13:59 +0000 | [diff] [blame] | 178 | if (!SCNO_IN_RANGE(tcp->scno)) |
| 179 | return 0; |
| 180 | |
Grant Edwards | 8a08277 | 2011-04-07 20:25:40 +0000 | [diff] [blame] | 181 | s = &sysent[tcp->scno]; |
| 182 | |
| 183 | if (!(s->sys_flags & (TRACE_FILE | TRACE_DESC))) |
| 184 | return 0; |
| 185 | |
| 186 | /* |
| 187 | * Check for special cases where we need to do something |
| 188 | * other than test arg[0]. |
| 189 | */ |
| 190 | |
Grant Edwards | 8a08277 | 2011-04-07 20:25:40 +0000 | [diff] [blame] | 191 | if (s->sys_func == sys_dup2 || |
| 192 | s->sys_func == sys_dup3 || |
| 193 | s->sys_func == sys_sendfile || |
| 194 | s->sys_func == sys_sendfile64 || |
Dmitry V. Levin | ad178c0 | 2011-11-28 22:48:53 +0000 | [diff] [blame] | 195 | s->sys_func == sys_tee) |
Grant Edwards | 8a08277 | 2011-04-07 20:25:40 +0000 | [diff] [blame] | 196 | { |
| 197 | /* fd, fd */ |
| 198 | return fdmatch(tcp, tcp->u_arg[0]) || |
| 199 | fdmatch(tcp, tcp->u_arg[1]); |
| 200 | } |
| 201 | |
| 202 | if (s->sys_func == sys_inotify_add_watch || |
| 203 | s->sys_func == sys_faccessat || |
| 204 | s->sys_func == sys_fchmodat || |
| 205 | s->sys_func == sys_futimesat || |
| 206 | s->sys_func == sys_mkdirat || |
| 207 | s->sys_func == sys_unlinkat || |
| 208 | s->sys_func == sys_newfstatat || |
| 209 | s->sys_func == sys_mknodat || |
| 210 | s->sys_func == sys_openat || |
| 211 | s->sys_func == sys_readlinkat || |
| 212 | s->sys_func == sys_utimensat || |
| 213 | s->sys_func == sys_fchownat || |
Denys Vlasenko | b63256e | 2011-06-07 12:13:24 +0200 | [diff] [blame] | 214 | s->sys_func == sys_pipe2) |
Grant Edwards | 8a08277 | 2011-04-07 20:25:40 +0000 | [diff] [blame] | 215 | { |
| 216 | /* fd, path */ |
| 217 | return fdmatch(tcp, tcp->u_arg[0]) || |
| 218 | upathmatch(tcp, tcp->u_arg[1]); |
| 219 | } |
| 220 | |
| 221 | if (s->sys_func == sys_link || |
Denys Vlasenko | b63256e | 2011-06-07 12:13:24 +0200 | [diff] [blame] | 222 | s->sys_func == sys_mount) |
Grant Edwards | 8a08277 | 2011-04-07 20:25:40 +0000 | [diff] [blame] | 223 | { |
| 224 | /* path, path */ |
| 225 | return upathmatch(tcp, tcp->u_arg[0]) || |
| 226 | upathmatch(tcp, tcp->u_arg[1]); |
| 227 | } |
| 228 | |
| 229 | if (s->sys_func == sys_renameat || |
Denys Vlasenko | b63256e | 2011-06-07 12:13:24 +0200 | [diff] [blame] | 230 | s->sys_func == sys_linkat) |
Grant Edwards | 8a08277 | 2011-04-07 20:25:40 +0000 | [diff] [blame] | 231 | { |
| 232 | /* fd, path, fd, path */ |
| 233 | return fdmatch(tcp, tcp->u_arg[0]) || |
| 234 | fdmatch(tcp, tcp->u_arg[2]) || |
| 235 | upathmatch(tcp, tcp->u_arg[1]) || |
| 236 | upathmatch(tcp, tcp->u_arg[3]); |
| 237 | } |
| 238 | |
Denys Vlasenko | 7b609d5 | 2011-06-22 14:32:43 +0200 | [diff] [blame] | 239 | if (s->sys_func == sys_old_mmap || s->sys_func == sys_mmap) { |
Grant Edwards | 8a08277 | 2011-04-07 20:25:40 +0000 | [diff] [blame] | 240 | /* x, x, x, x, fd */ |
| 241 | return fdmatch(tcp, tcp->u_arg[4]); |
| 242 | } |
| 243 | |
Denys Vlasenko | 7b609d5 | 2011-06-22 14:32:43 +0200 | [diff] [blame] | 244 | if (s->sys_func == sys_symlinkat) { |
Grant Edwards | 8a08277 | 2011-04-07 20:25:40 +0000 | [diff] [blame] | 245 | /* path, fd, path */ |
| 246 | return fdmatch(tcp, tcp->u_arg[1]) || |
| 247 | upathmatch(tcp, tcp->u_arg[0]) || |
Denys Vlasenko | b63256e | 2011-06-07 12:13:24 +0200 | [diff] [blame] | 248 | upathmatch(tcp, tcp->u_arg[2]); |
Grant Edwards | 8a08277 | 2011-04-07 20:25:40 +0000 | [diff] [blame] | 249 | } |
| 250 | |
Dmitry V. Levin | ad178c0 | 2011-11-28 22:48:53 +0000 | [diff] [blame] | 251 | if (s->sys_func == sys_splice) { |
Grant Edwards | 8a08277 | 2011-04-07 20:25:40 +0000 | [diff] [blame] | 252 | /* fd, x, fd, x, x */ |
| 253 | return fdmatch(tcp, tcp->u_arg[0]) || |
| 254 | fdmatch(tcp, tcp->u_arg[2]); |
| 255 | } |
| 256 | |
Denys Vlasenko | 7b609d5 | 2011-06-22 14:32:43 +0200 | [diff] [blame] | 257 | if (s->sys_func == sys_epoll_ctl) { |
Grant Edwards | 8a08277 | 2011-04-07 20:25:40 +0000 | [diff] [blame] | 258 | /* x, x, fd, x */ |
| 259 | return fdmatch(tcp, tcp->u_arg[2]); |
| 260 | } |
| 261 | |
| 262 | if (s->sys_func == sys_select || |
| 263 | s->sys_func == sys_oldselect || |
Denys Vlasenko | b63256e | 2011-06-07 12:13:24 +0200 | [diff] [blame] | 264 | s->sys_func == sys_pselect6) |
Grant Edwards | 8a08277 | 2011-04-07 20:25:40 +0000 | [diff] [blame] | 265 | { |
Denys Vlasenko | 79a79ea | 2011-09-01 16:35:44 +0200 | [diff] [blame] | 266 | int i, j; |
| 267 | unsigned nfds; |
Grant Edwards | 8a08277 | 2011-04-07 20:25:40 +0000 | [diff] [blame] | 268 | long *args, oldargs[5]; |
| 269 | unsigned fdsize; |
| 270 | fd_set *fds; |
| 271 | |
Denys Vlasenko | 7b609d5 | 2011-06-22 14:32:43 +0200 | [diff] [blame] | 272 | if (s->sys_func == sys_oldselect) { |
Grant Edwards | 8a08277 | 2011-04-07 20:25:40 +0000 | [diff] [blame] | 273 | if (umoven(tcp, tcp->u_arg[0], sizeof oldargs, |
| 274 | (char*) oldargs) < 0) |
| 275 | { |
| 276 | fprintf(stderr, "umoven() failed\n"); |
| 277 | return 0; |
| 278 | } |
| 279 | args = oldargs; |
| 280 | } else |
| 281 | args = tcp->u_arg; |
| 282 | |
| 283 | nfds = args[0]; |
Denys Vlasenko | 79a79ea | 2011-09-01 16:35:44 +0200 | [diff] [blame] | 284 | /* Beware of select(2^31-1, NULL, NULL, NULL) and similar... */ |
| 285 | if (args[0] > 1024*1024) |
| 286 | nfds = 1024*1024; |
| 287 | if (args[0] < 0) |
| 288 | nfds = 0; |
Grant Edwards | 8a08277 | 2011-04-07 20:25:40 +0000 | [diff] [blame] | 289 | fdsize = ((((nfds + 7) / 8) + sizeof(long) - 1) |
| 290 | & -sizeof(long)); |
| 291 | fds = malloc(fdsize); |
Denys Vlasenko | 1d46ba5 | 2011-08-31 14:00:02 +0200 | [diff] [blame] | 292 | if (!fds) |
| 293 | die_out_of_memory(); |
Grant Edwards | 8a08277 | 2011-04-07 20:25:40 +0000 | [diff] [blame] | 294 | |
Denys Vlasenko | 7b609d5 | 2011-06-22 14:32:43 +0200 | [diff] [blame] | 295 | for (i = 1; i <= 3; ++i) { |
Grant Edwards | 8a08277 | 2011-04-07 20:25:40 +0000 | [diff] [blame] | 296 | if (args[i] == 0) |
| 297 | continue; |
| 298 | |
Denys Vlasenko | 7b609d5 | 2011-06-22 14:32:43 +0200 | [diff] [blame] | 299 | if (umoven(tcp, args[i], fdsize, (char *) fds) < 0) { |
Grant Edwards | 8a08277 | 2011-04-07 20:25:40 +0000 | [diff] [blame] | 300 | fprintf(stderr, "umoven() failed\n"); |
| 301 | continue; |
| 302 | } |
| 303 | |
| 304 | for (j = 0; j < nfds; ++j) |
Denys Vlasenko | 7b609d5 | 2011-06-22 14:32:43 +0200 | [diff] [blame] | 305 | if (FD_ISSET(j, fds) && fdmatch(tcp, j)) { |
Grant Edwards | 8a08277 | 2011-04-07 20:25:40 +0000 | [diff] [blame] | 306 | free(fds); |
| 307 | return 1; |
| 308 | } |
| 309 | } |
| 310 | free(fds); |
| 311 | return 0; |
| 312 | } |
| 313 | |
| 314 | if (s->sys_func == sys_poll || |
Denys Vlasenko | b63256e | 2011-06-07 12:13:24 +0200 | [diff] [blame] | 315 | s->sys_func == sys_ppoll) |
Grant Edwards | 8a08277 | 2011-04-07 20:25:40 +0000 | [diff] [blame] | 316 | { |
| 317 | struct pollfd fds; |
| 318 | unsigned nfds; |
| 319 | unsigned long start, cur, end; |
| 320 | |
| 321 | start = tcp->u_arg[0]; |
| 322 | nfds = tcp->u_arg[1]; |
| 323 | |
| 324 | end = start + sizeof(fds) * nfds; |
| 325 | |
| 326 | if (nfds == 0 || end < start) |
| 327 | return 0; |
| 328 | |
| 329 | for (cur = start; cur < end; cur += sizeof(fds)) |
| 330 | if ((umoven(tcp, cur, sizeof fds, (char *) &fds) == 0) |
| 331 | && fdmatch(tcp, fds.fd)) |
| 332 | return 1; |
| 333 | |
| 334 | return 0; |
| 335 | } |
| 336 | |
| 337 | if (s->sys_func == printargs || |
| 338 | s->sys_func == sys_pipe || |
| 339 | s->sys_func == sys_pipe2 || |
| 340 | s->sys_func == sys_eventfd2 || |
| 341 | s->sys_func == sys_eventfd || |
| 342 | s->sys_func == sys_inotify_init1 || |
| 343 | s->sys_func == sys_timerfd_create || |
| 344 | s->sys_func == sys_timerfd_settime || |
| 345 | s->sys_func == sys_timerfd_gettime || |
| 346 | s->sys_func == sys_epoll_create || |
| 347 | !strcmp(s->sys_name, "fanotify_init")) |
| 348 | { |
| 349 | /* |
| 350 | * These have TRACE_FILE or TRACE_DESCRIPTOR set, but they |
| 351 | * don't have any file descriptor or path args to test. |
| 352 | */ |
| 353 | return 0; |
| 354 | } |
Grant Edwards | 8a08277 | 2011-04-07 20:25:40 +0000 | [diff] [blame] | 355 | |
| 356 | /* |
| 357 | * Our fallback position for calls that haven't already |
| 358 | * been handled is to just check arg[0]. |
| 359 | */ |
| 360 | |
| 361 | if (s->sys_flags & TRACE_FILE) |
| 362 | return upathmatch(tcp, tcp->u_arg[0]); |
| 363 | |
| 364 | if (s->sys_flags & TRACE_DESC) |
| 365 | return fdmatch(tcp, tcp->u_arg[0]); |
| 366 | |
| 367 | return 0; |
| 368 | } |