1 /* $NetBSD: filemon_ktrace.c,v 1.15 2021/07/31 09:30:17 rillig Exp $ */ 2 3 /* 4 * Copyright (c) 2019 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Taylor R. Campbell. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 29 * POSSIBILITY OF SUCH DAMAGE. 30 */ 31 32 #define _KERNTYPES /* register_t */ 33 34 #include "filemon.h" 35 36 #include <sys/param.h> 37 #include <sys/types.h> 38 #include <sys/rbtree.h> 39 #include <sys/syscall.h> 40 #include <sys/time.h> 41 #include <sys/uio.h> 42 #include <sys/wait.h> 43 44 #include <sys/ktrace.h> 45 46 #include <assert.h> 47 #include <err.h> 48 #include <errno.h> 49 #include <fcntl.h> 50 #include <stdbool.h> 51 #include <stddef.h> 52 #include <stdio.h> 53 #include <stdlib.h> 54 #include <string.h> 55 #include <unistd.h> 56 57 #ifndef AT_CWD 58 #define AT_CWD -1 59 #endif 60 61 struct filemon; 62 struct filemon_key; 63 struct filemon_state; 64 65 typedef struct filemon_state *filemon_syscall_t(struct filemon *, 66 const struct filemon_key *, const struct ktr_syscall *); 67 68 static filemon_syscall_t filemon_sys_chdir; 69 static filemon_syscall_t filemon_sys_execve; 70 static filemon_syscall_t filemon_sys_exit; 71 static filemon_syscall_t filemon_sys_fork; 72 static filemon_syscall_t filemon_sys_link; 73 static filemon_syscall_t filemon_sys_open; 74 static filemon_syscall_t filemon_sys_openat; 75 static filemon_syscall_t filemon_sys_symlink; 76 static filemon_syscall_t filemon_sys_unlink; 77 static filemon_syscall_t filemon_sys_rename; 78 79 static filemon_syscall_t *const filemon_syscalls[] = { 80 [SYS_chdir] = &filemon_sys_chdir, 81 [SYS_execve] = &filemon_sys_execve, 82 [SYS_exit] = &filemon_sys_exit, 83 [SYS_fork] = &filemon_sys_fork, 84 [SYS_link] = &filemon_sys_link, 85 [SYS_open] = &filemon_sys_open, 86 [SYS_openat] = &filemon_sys_openat, 87 [SYS_symlink] = &filemon_sys_symlink, 88 [SYS_unlink] = &filemon_sys_unlink, 89 [SYS_rename] = &filemon_sys_rename, 90 }; 91 92 struct filemon { 93 int ktrfd; /* kernel writes ktrace events here */ 94 FILE *in; /* we read ktrace events from here */ 95 FILE *out; /* we write filemon events to here */ 96 rb_tree_t active; 97 pid_t child; 98 99 /* I/O state machine. */ 100 enum { 101 FILEMON_START = 0, 102 FILEMON_HEADER, 103 FILEMON_PAYLOAD, 104 FILEMON_ERROR, 105 } state; 106 unsigned char *p; 107 size_t resid; 108 109 /* I/O buffer. */ 110 struct ktr_header hdr; 111 union { 112 struct ktr_syscall syscall; 113 struct ktr_sysret sysret; 114 char namei[PATH_MAX]; 115 unsigned char buf[4096]; 116 } payload; 117 }; 118 119 struct filemon_state { 120 struct filemon_key { 121 pid_t pid; 122 lwpid_t lid; 123 } key; 124 struct rb_node node; 125 int syscode; 126 void (*show)(struct filemon *, const struct filemon_state *, 127 const struct ktr_sysret *); 128 unsigned i; 129 unsigned npath; 130 char *path[/*npath*/]; 131 }; 132 133 /*ARGSUSED*/ 134 static int 135 compare_filemon_states(void *cookie, const void *na, const void *nb) 136 { 137 const struct filemon_state *Sa = na; 138 const struct filemon_state *Sb = nb; 139 140 if (Sa->key.pid < Sb->key.pid) 141 return -1; 142 if (Sa->key.pid > Sb->key.pid) 143 return +1; 144 if (Sa->key.lid < Sb->key.lid) 145 return -1; 146 if (Sa->key.lid > Sb->key.lid) 147 return +1; 148 return 0; 149 } 150 151 /*ARGSUSED*/ 152 static int 153 compare_filemon_key(void *cookie, const void *n, const void *k) 154 { 155 const struct filemon_state *S = n; 156 const struct filemon_key *key = k; 157 158 if (S->key.pid < key->pid) 159 return -1; 160 if (S->key.pid > key->pid) 161 return +1; 162 if (S->key.lid < key->lid) 163 return -1; 164 if (S->key.lid > key->lid) 165 return +1; 166 return 0; 167 } 168 169 static const rb_tree_ops_t filemon_rb_ops = { 170 .rbto_compare_nodes = &compare_filemon_states, 171 .rbto_compare_key = &compare_filemon_key, 172 .rbto_node_offset = offsetof(struct filemon_state, node), 173 .rbto_context = NULL, 174 }; 175 176 /* 177 * filemon_path() 178 * 179 * Return a pointer to a constant string denoting the `path' of 180 * the filemon. 181 */ 182 const char * 183 filemon_path(void) 184 { 185 186 return "ktrace"; 187 } 188 189 /* 190 * filemon_open() 191 * 192 * Allocate a filemon descriptor. Returns NULL and sets errno on 193 * failure. 194 */ 195 struct filemon * 196 filemon_open(void) 197 { 198 struct filemon *F; 199 int ktrpipe[2]; 200 int error; 201 202 /* Allocate and zero a struct filemon object. */ 203 F = calloc(1, sizeof *F); 204 if (F == NULL) 205 return NULL; 206 207 /* Create a pipe for ktrace events. */ 208 if (pipe2(ktrpipe, O_CLOEXEC|O_NONBLOCK) == -1) { 209 error = errno; 210 goto fail0; 211 } 212 213 /* Create a file stream for reading the ktrace events. */ 214 if ((F->in = fdopen(ktrpipe[0], "r")) == NULL) { 215 error = errno; 216 goto fail1; 217 } 218 ktrpipe[0] = -1; /* claimed by fdopen */ 219 220 /* 221 * Set the fd for writing ktrace events and initialize the 222 * rbtree. The rest can be safely initialized to zero. 223 */ 224 F->ktrfd = ktrpipe[1]; 225 rb_tree_init(&F->active, &filemon_rb_ops); 226 227 /* Success! */ 228 return F; 229 230 fail1: (void)close(ktrpipe[0]); 231 (void)close(ktrpipe[1]); 232 fail0: free(F); 233 errno = error; 234 return NULL; 235 } 236 237 /* 238 * filemon_closefd(F) 239 * 240 * Internal subroutine to try to flush and close the output file. 241 * If F is not open for output, do nothing. Never leaves F open 242 * for output even on failure. Returns 0 on success; sets errno 243 * and return -1 on failure. 244 */ 245 static int 246 filemon_closefd(struct filemon *F) 247 { 248 int error = 0; 249 250 /* If we're not open, nothing to do. */ 251 if (F->out == NULL) 252 return 0; 253 254 /* 255 * Flush it, close it, and null it unconditionally, but be 256 * careful to return the earliest error in errno. 257 */ 258 if (fflush(F->out) == EOF && error == 0) 259 error = errno; 260 if (fclose(F->out) == EOF && error == 0) 261 error = errno; 262 F->out = NULL; 263 264 /* Set errno and return -1 if anything went wrong. */ 265 if (error != 0) { 266 errno = error; 267 return -1; 268 } 269 270 /* Success! */ 271 return 0; 272 } 273 274 /* 275 * filemon_setfd(F, fd) 276 * 277 * Cause filemon activity on F to be sent to fd. Claims ownership 278 * of fd; caller should not use fd afterward, and any duplicates 279 * of fd may see their file positions changed. 280 */ 281 int 282 filemon_setfd(struct filemon *F, int fd) 283 { 284 285 /* 286 * Close an existing output file if done. Fail now if there's 287 * an error closing. 288 */ 289 if ((filemon_closefd(F)) == -1) 290 return -1; 291 assert(F->out == NULL); 292 293 /* Open a file stream and claim ownership of the fd. */ 294 if ((F->out = fdopen(fd, "a")) == NULL) 295 return -1; 296 297 /* 298 * Print the opening output. Any failure will be deferred 299 * until closing. For hysterical raisins, we show the parent 300 * pid, not the child pid. 301 */ 302 fprintf(F->out, "# filemon version 4\n"); 303 fprintf(F->out, "# Target pid %jd\n", (intmax_t)getpid()); 304 fprintf(F->out, "V 4\n"); 305 306 /* Success! */ 307 return 0; 308 } 309 310 /* 311 * filemon_setpid_parent(F, pid) 312 * 313 * Set the traced pid, from the parent. Never fails. 314 */ 315 void 316 filemon_setpid_parent(struct filemon *F, pid_t pid) 317 { 318 319 F->child = pid; 320 } 321 322 /* 323 * filemon_setpid_child(F, pid) 324 * 325 * Set the traced pid, from the child. Returns 0 on success; sets 326 * errno and returns -1 on failure. 327 */ 328 int 329 filemon_setpid_child(const struct filemon *F, pid_t pid) 330 { 331 int ops, trpoints; 332 333 ops = KTROP_SET|KTRFLAG_DESCEND; 334 trpoints = KTRFACv2; 335 trpoints |= KTRFAC_SYSCALL|KTRFAC_NAMEI|KTRFAC_SYSRET; 336 trpoints |= KTRFAC_INHERIT; 337 if (fktrace(F->ktrfd, ops, trpoints, pid) == -1) 338 return -1; 339 340 return 0; 341 } 342 343 /* 344 * filemon_close(F) 345 * 346 * Close F for output if necessary, and free a filemon descriptor. 347 * Returns 0 on success; sets errno and returns -1 on failure, but 348 * frees the filemon descriptor either way; 349 */ 350 int 351 filemon_close(struct filemon *F) 352 { 353 struct filemon_state *S; 354 int error = 0; 355 356 /* Close for output. */ 357 if (filemon_closefd(F) == -1 && error == 0) 358 error = errno; 359 360 /* Close the ktrace pipe. */ 361 if (fclose(F->in) == EOF && error == 0) 362 error = errno; 363 if (close(F->ktrfd) == -1 && error == 0) 364 error = errno; 365 366 /* Free any active records. */ 367 while ((S = RB_TREE_MIN(&F->active)) != NULL) { 368 rb_tree_remove_node(&F->active, S); 369 free(S); 370 } 371 372 /* Free the filemon descriptor. */ 373 free(F); 374 375 /* Set errno and return -1 if anything went wrong. */ 376 if (error != 0) { 377 errno = error; 378 return -1; 379 } 380 381 /* Success! */ 382 return 0; 383 } 384 385 /* 386 * filemon_readfd(F) 387 * 388 * Returns a file descriptor which will select/poll ready for read 389 * when there are filemon events to be processed by 390 * filemon_process, or -1 if anything has gone wrong. 391 */ 392 int 393 filemon_readfd(const struct filemon *F) 394 { 395 396 if (F->state == FILEMON_ERROR) 397 return -1; 398 return fileno(F->in); 399 } 400 401 /* 402 * filemon_dispatch(F) 403 * 404 * Internal subroutine to dispatch a filemon ktrace event. 405 * Silently ignore events that we don't recognize. 406 */ 407 static void 408 filemon_dispatch(struct filemon *F) 409 { 410 const struct filemon_key key = { 411 .pid = F->hdr.ktr_pid, 412 .lid = F->hdr.ktr_lid, 413 }; 414 struct filemon_state *S; 415 416 switch (F->hdr.ktr_type) { 417 case KTR_SYSCALL: { 418 struct ktr_syscall *call = &F->payload.syscall; 419 struct filemon_state *S1; 420 421 /* Validate the syscall code. */ 422 if (call->ktr_code < 0 || 423 (size_t)call->ktr_code >= __arraycount(filemon_syscalls) || 424 filemon_syscalls[call->ktr_code] == NULL) 425 break; 426 427 /* 428 * Invoke the syscall-specific logic to create a new 429 * active state. 430 */ 431 S = (*filemon_syscalls[call->ktr_code])(F, &key, call); 432 if (S == NULL) 433 break; 434 435 /* 436 * Insert the active state, or ignore it if there 437 * already is one. 438 * 439 * Collisions shouldn't happen because the states are 440 * keyed by <pid,lid>, in which syscalls should happen 441 * sequentially in CALL/RET pairs, but let's be 442 * defensive. 443 */ 444 S1 = rb_tree_insert_node(&F->active, S); 445 if (S1 != S) { 446 /* XXX Which one to drop? */ 447 free(S); 448 break; 449 } 450 break; 451 } 452 case KTR_NAMEI: 453 /* Find an active syscall state, or drop it. */ 454 S = rb_tree_find_node(&F->active, &key); 455 if (S == NULL) 456 break; 457 /* Find the position of the next path, or drop it. */ 458 if (S->i >= S->npath) 459 break; 460 /* Record the path. */ 461 S->path[S->i++] = strndup(F->payload.namei, 462 sizeof F->payload.namei); 463 break; 464 case KTR_SYSRET: { 465 struct ktr_sysret *ret = &F->payload.sysret; 466 unsigned i; 467 468 /* Find and remove an active syscall state, or drop it. */ 469 S = rb_tree_find_node(&F->active, &key); 470 if (S == NULL) 471 break; 472 rb_tree_remove_node(&F->active, S); 473 474 /* 475 * If the active syscall state matches this return, 476 * invoke the syscall-specific logic to show a filemon 477 * event. 478 */ 479 /* XXX What to do if syscall code doesn't match? */ 480 if (S->i == S->npath && S->syscode == ret->ktr_code) 481 S->show(F, S, ret); 482 483 /* Free the state now that it is no longer active. */ 484 for (i = 0; i < S->i; i++) 485 free(S->path[i]); 486 free(S); 487 break; 488 } 489 default: 490 /* Ignore all other ktrace events. */ 491 break; 492 } 493 } 494 495 /* 496 * filemon_process(F) 497 * 498 * Process all pending events after filemon_readfd(F) has 499 * selected/polled ready for read. 500 * 501 * Returns -1 on failure, 0 on end of events, and anything else if 502 * there may be more events. 503 * 504 * XXX What about fairness to other activities in the event loop? 505 * If we stop while there's events buffered in F->in, then select 506 * or poll may not return ready even though there's work queued up 507 * in the buffer of F->in, but if we don't stop then ktrace events 508 * may overwhelm all other activity in the event loop. 509 */ 510 int 511 filemon_process(struct filemon *F) 512 { 513 size_t nread; 514 515 top: /* If the child has exited, nothing to do. */ 516 /* XXX What if one thread calls exit while another is running? */ 517 if (F->child == 0) 518 return 0; 519 520 /* If we're waiting for input, read some. */ 521 if (F->resid > 0) { 522 nread = fread(F->p, 1, F->resid, F->in); 523 if (nread == 0) { 524 if (feof(F->in) != 0) 525 return 0; 526 assert(ferror(F->in) != 0); 527 /* 528 * If interrupted or would block, there may be 529 * more events. Otherwise fail. 530 */ 531 if (errno == EAGAIN || errno == EINTR) 532 return 1; 533 F->state = FILEMON_ERROR; 534 F->p = NULL; 535 F->resid = 0; 536 return -1; 537 } 538 assert(nread <= F->resid); 539 F->p += nread; 540 F->resid -= nread; 541 if (F->resid > 0) /* may be more events */ 542 return 1; 543 } 544 545 /* Process a state transition now that we've read a buffer. */ 546 switch (F->state) { 547 case FILEMON_START: /* just started filemon; read header next */ 548 F->state = FILEMON_HEADER; 549 F->p = (void *)&F->hdr; 550 F->resid = sizeof F->hdr; 551 goto top; 552 case FILEMON_HEADER: /* read header */ 553 /* Sanity-check ktrace header; then read payload. */ 554 if (F->hdr.ktr_len < 0 || 555 (size_t)F->hdr.ktr_len > sizeof F->payload) { 556 F->state = FILEMON_ERROR; 557 F->p = NULL; 558 F->resid = 0; 559 errno = EIO; 560 return -1; 561 } 562 F->state = FILEMON_PAYLOAD; 563 F->p = (void *)&F->payload; 564 F->resid = (size_t)F->hdr.ktr_len; 565 goto top; 566 case FILEMON_PAYLOAD: /* read header and payload */ 567 /* Dispatch ktrace event; then read next header. */ 568 filemon_dispatch(F); 569 F->state = FILEMON_HEADER; 570 F->p = (void *)&F->hdr; 571 F->resid = sizeof F->hdr; 572 goto top; 573 default: /* paranoia */ 574 F->state = FILEMON_ERROR; 575 /*FALLTHROUGH*/ 576 case FILEMON_ERROR: /* persistent error indicator */ 577 F->p = NULL; 578 F->resid = 0; 579 errno = EIO; 580 return -1; 581 } 582 } 583 584 static struct filemon_state * 585 syscall_enter( 586 const struct filemon_key *key, const struct ktr_syscall *call, 587 unsigned npath, 588 void (*show)(struct filemon *, const struct filemon_state *, 589 const struct ktr_sysret *)) 590 { 591 struct filemon_state *S; 592 unsigned i; 593 594 S = calloc(1, offsetof(struct filemon_state, path[npath])); 595 if (S == NULL) 596 return NULL; 597 S->key = *key; 598 S->show = show; 599 S->syscode = call->ktr_code; 600 S->i = 0; 601 S->npath = npath; 602 for (i = 0; i < npath; i++) 603 S->path[i] = NULL; /* paranoia */ 604 605 return S; 606 } 607 608 static void 609 show_paths(struct filemon *F, const struct filemon_state *S, 610 const struct ktr_sysret *ret, const char *prefix) 611 { 612 unsigned i; 613 614 /* Caller must ensure all paths have been specified. */ 615 assert(S->i == S->npath); 616 617 /* 618 * Ignore it if it failed or yielded EJUSTRETURN (-2), or if 619 * we're not producing output. 620 */ 621 if (ret->ktr_error != 0 && ret->ktr_error != -2) 622 return; 623 if (F->out == NULL) 624 return; 625 626 /* 627 * Print the prefix, pid, and paths -- with the paths quoted if 628 * there's more than one. 629 */ 630 fprintf(F->out, "%s %jd", prefix, (intmax_t)S->key.pid); 631 for (i = 0; i < S->npath; i++) { 632 const char *q = S->npath > 1 ? "'" : ""; 633 fprintf(F->out, " %s%s%s", q, S->path[i], q); 634 } 635 fprintf(F->out, "\n"); 636 } 637 638 static void 639 show_retval(struct filemon *F, const struct filemon_state *S, 640 const struct ktr_sysret *ret, const char *prefix) 641 { 642 643 /* 644 * Ignore it if it failed or yielded EJUSTRETURN (-2), or if 645 * we're not producing output. 646 */ 647 if (ret->ktr_error != 0 && ret->ktr_error != -2) 648 return; 649 if (F->out == NULL) 650 return; 651 652 fprintf(F->out, "%s %jd %jd\n", prefix, (intmax_t)S->key.pid, 653 (intmax_t)ret->ktr_retval); 654 } 655 656 static void 657 show_chdir(struct filemon *F, const struct filemon_state *S, 658 const struct ktr_sysret *ret) 659 { 660 show_paths(F, S, ret, "C"); 661 } 662 663 static void 664 show_execve(struct filemon *F, const struct filemon_state *S, 665 const struct ktr_sysret *ret) 666 { 667 show_paths(F, S, ret, "E"); 668 } 669 670 static void 671 show_fork(struct filemon *F, const struct filemon_state *S, 672 const struct ktr_sysret *ret) 673 { 674 show_retval(F, S, ret, "F"); 675 } 676 677 static void 678 show_link(struct filemon *F, const struct filemon_state *S, 679 const struct ktr_sysret *ret) 680 { 681 show_paths(F, S, ret, "L"); /* XXX same as symlink */ 682 } 683 684 static void 685 show_open_read(struct filemon *F, const struct filemon_state *S, 686 const struct ktr_sysret *ret) 687 { 688 show_paths(F, S, ret, "R"); 689 } 690 691 static void 692 show_open_write(struct filemon *F, const struct filemon_state *S, 693 const struct ktr_sysret *ret) 694 { 695 show_paths(F, S, ret, "W"); 696 } 697 698 static void 699 show_open_readwrite(struct filemon *F, const struct filemon_state *S, 700 const struct ktr_sysret *ret) 701 { 702 show_paths(F, S, ret, "R"); 703 show_paths(F, S, ret, "W"); 704 } 705 706 static void 707 show_openat_read(struct filemon *F, const struct filemon_state *S, 708 const struct ktr_sysret *ret) 709 { 710 if (S->path[0][0] != '/') 711 show_paths(F, S, ret, "A"); 712 show_paths(F, S, ret, "R"); 713 } 714 715 static void 716 show_openat_write(struct filemon *F, const struct filemon_state *S, 717 const struct ktr_sysret *ret) 718 { 719 if (S->path[0][0] != '/') 720 show_paths(F, S, ret, "A"); 721 show_paths(F, S, ret, "W"); 722 } 723 724 static void 725 show_openat_readwrite(struct filemon *F, const struct filemon_state *S, 726 const struct ktr_sysret *ret) 727 { 728 if (S->path[0][0] != '/') 729 show_paths(F, S, ret, "A"); 730 show_paths(F, S, ret, "R"); 731 show_paths(F, S, ret, "W"); 732 } 733 734 static void 735 show_symlink(struct filemon *F, const struct filemon_state *S, 736 const struct ktr_sysret *ret) 737 { 738 show_paths(F, S, ret, "L"); /* XXX same as link */ 739 } 740 741 static void 742 show_unlink(struct filemon *F, const struct filemon_state *S, 743 const struct ktr_sysret *ret) 744 { 745 show_paths(F, S, ret, "D"); 746 } 747 748 static void 749 show_rename(struct filemon *F, const struct filemon_state *S, 750 const struct ktr_sysret *ret) 751 { 752 show_paths(F, S, ret, "M"); 753 } 754 755 /*ARGSUSED*/ 756 static struct filemon_state * 757 filemon_sys_chdir(struct filemon *F, const struct filemon_key *key, 758 const struct ktr_syscall *call) 759 { 760 return syscall_enter(key, call, 1, &show_chdir); 761 } 762 763 /* TODO: monitor fchdir as well */ 764 765 /*ARGSUSED*/ 766 static struct filemon_state * 767 filemon_sys_execve(struct filemon *F, const struct filemon_key *key, 768 const struct ktr_syscall *call) 769 { 770 return syscall_enter(key, call, 1, &show_execve); 771 } 772 773 static struct filemon_state * 774 filemon_sys_exit(struct filemon *F, const struct filemon_key *key, 775 const struct ktr_syscall *call) 776 { 777 const register_t *args = (const void *)&call[1]; 778 int status = (int)args[0]; 779 780 if (F->out != NULL) { 781 fprintf(F->out, "X %jd %d\n", (intmax_t)key->pid, status); 782 if (key->pid == F->child) { 783 fprintf(F->out, "# Bye bye\n"); 784 F->child = 0; 785 } 786 } 787 return NULL; 788 } 789 790 /*ARGSUSED*/ 791 static struct filemon_state * 792 filemon_sys_fork(struct filemon *F, const struct filemon_key *key, 793 const struct ktr_syscall *call) 794 { 795 return syscall_enter(key, call, 0, &show_fork); 796 } 797 798 /*ARGSUSED*/ 799 static struct filemon_state * 800 filemon_sys_link(struct filemon *F, const struct filemon_key *key, 801 const struct ktr_syscall *call) 802 { 803 return syscall_enter(key, call, 2, &show_link); 804 } 805 806 /*ARGSUSED*/ 807 static struct filemon_state * 808 filemon_sys_open(struct filemon *F, const struct filemon_key *key, 809 const struct ktr_syscall *call) 810 { 811 const register_t *args = (const void *)&call[1]; 812 int flags; 813 814 if (call->ktr_argsize < 2) 815 return NULL; 816 flags = (int)args[1]; 817 818 if ((flags & O_RDWR) == O_RDWR) 819 return syscall_enter(key, call, 1, &show_open_readwrite); 820 else if ((flags & O_WRONLY) == O_WRONLY) 821 return syscall_enter(key, call, 1, &show_open_write); 822 else if ((flags & O_RDONLY) == O_RDONLY) 823 return syscall_enter(key, call, 1, &show_open_read); 824 else 825 return NULL; /* XXX Do we care if no read or write? */ 826 } 827 828 /*ARGSUSED*/ 829 static struct filemon_state * 830 filemon_sys_openat(struct filemon *F, const struct filemon_key *key, 831 const struct ktr_syscall *call) 832 { 833 const register_t *args = (const void *)&call[1]; 834 int flags, fd; 835 836 /* 837 * XXX: In the .meta log, the base directory is missing, which makes 838 * all references to relative pathnames useless. 839 */ 840 841 if (call->ktr_argsize < 3) 842 return NULL; 843 fd = (int)args[0]; 844 flags = (int)args[2]; 845 846 if (fd == AT_CWD) { 847 if ((flags & O_RDWR) == O_RDWR) 848 return syscall_enter(key, call, 1, 849 &show_open_readwrite); 850 else if ((flags & O_WRONLY) == O_WRONLY) 851 return syscall_enter(key, call, 1, &show_open_write); 852 else if ((flags & O_RDONLY) == O_RDONLY) 853 return syscall_enter(key, call, 1, &show_open_read); 854 else 855 return NULL; 856 } else { 857 if ((flags & O_RDWR) == O_RDWR) 858 return syscall_enter(key, call, 1, 859 &show_openat_readwrite); 860 else if ((flags & O_WRONLY) == O_WRONLY) 861 return syscall_enter(key, call, 1, &show_openat_write); 862 else if ((flags & O_RDONLY) == O_RDONLY) 863 return syscall_enter(key, call, 1, &show_openat_read); 864 else 865 return NULL; 866 } 867 } 868 869 /* TODO: monitor the other *at syscalls as well, not only openat. */ 870 871 /*ARGSUSED*/ 872 static struct filemon_state * 873 filemon_sys_symlink(struct filemon *F, const struct filemon_key *key, 874 const struct ktr_syscall *call) 875 { 876 return syscall_enter(key, call, 2, &show_symlink); 877 } 878 879 /*ARGSUSED*/ 880 static struct filemon_state * 881 filemon_sys_unlink(struct filemon *F, const struct filemon_key *key, 882 const struct ktr_syscall *call) 883 { 884 return syscall_enter(key, call, 1, &show_unlink); 885 } 886 887 /*ARGSUSED*/ 888 static struct filemon_state * 889 filemon_sys_rename(struct filemon *F, const struct filemon_key *key, 890 const struct ktr_syscall *call) 891 { 892 return syscall_enter(key, call, 2, &show_rename); 893 } 894
Indexes created Sat Sep 20 22:09:52 GMT 2025