filemon_wrapper.c

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
    1 /*-
    2  * Copyright (c) 2011, David E. O'Brien.
    3  * Copyright (c) 2009-2011, Juniper Networks, Inc.
    4  * All rights reserved.
    5  *
    6  * Redistribution and use in source and binary forms, with or without
    7  * modification, are permitted provided that the following conditions
    8  * are met:
    9  * 1. Redistributions of source code must retain the above copyright
   10  *    notice, this list of conditions and the following disclaimer.
   11  * 2. Redistributions in binary form must reproduce the above copyright
   12  *    notice, this list of conditions and the following disclaimer in the
   13  *    documentation and/or other materials provided with the distribution.
   14  *
   15  * THIS SOFTWARE IS PROVIDED BY JUNIPER NETWORKS AND CONTRIBUTORS ``AS IS'' AND
   16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   18  * ARE DISCLAIMED. IN NO EVENT SHALL JUNIPER NETWORKS OR CONTRIBUTORS BE LIABLE
   19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   25  * SUCH DAMAGE.
   26  */
   27 
   28 #include <sys/cdefs.h>
   29 __FBSDID("$FreeBSD$");
   30 
   31 #include "opt_compat.h"
   32 
   33 #if __FreeBSD_version > 800032
   34 #define FILEMON_HAS_LINKAT
   35 #endif
   36 
   37 #if __FreeBSD_version < 900044  /* r225617 (2011-09-16) failed to bump
   38                                    __FreeBSD_version.  This really should
   39                                    be based on "900045".  "900044" is r225469
   40                                    (2011-09-10) so this code is broken for
   41                                    9-CURRENT September 10th-16th. */
   42 #define sys_chdir       chdir
   43 #define sys_execve      execve
   44 #define sys_fork        fork
   45 #define sys_link        link
   46 #define sys_open        open
   47 #define sys_rename      rename
   48 #define sys_stat        stat
   49 #define sys_symlink     symlink
   50 #define sys_unlink      unlink
   51 #define sys_vfork       vfork
   52 #define sys_sys_exit    sys_exit
   53 #ifdef FILEMON_HAS_LINKAT
   54 #define sys_linkat      linkat
   55 #endif
   56 #endif  /* __FreeBSD_version */
   57 
   58 static void
   59 filemon_output(struct filemon *filemon, char *msg, size_t len)
   60 {
   61         struct uio auio;
   62         struct iovec aiov;
   63 
   64         if (filemon->fp == NULL)
   65                 return;
   66 
   67         aiov.iov_base = msg;
   68         aiov.iov_len = len;
   69         auio.uio_iov = &aiov;
   70         auio.uio_iovcnt = 1;
   71         auio.uio_resid = len;
   72         auio.uio_segflg = UIO_SYSSPACE;
   73         auio.uio_rw = UIO_WRITE;
   74         auio.uio_td = curthread;
   75         auio.uio_offset = (off_t) -1;
   76 
   77         bwillwrite();
   78 
   79         fo_write(filemon->fp, &auio, curthread->td_ucred, 0, curthread);
   80 }
   81 
   82 static struct filemon *
   83 filemon_pid_check(struct proc *p)
   84 {
   85         struct filemon *filemon;
   86 
   87         while (p->p_pptr) {
   88                 TAILQ_FOREACH(filemon, &filemons_inuse, link) {
   89                         if (p->p_pid == filemon->pid)
   90                                 return (filemon);
   91                 }
   92                 p = p->p_pptr;
   93         }
   94         return (NULL);
   95 }
   96 
   97 static void
   98 filemon_comment(struct filemon *filemon)
   99 {
  100         int len;
  101         struct timeval now;
  102 
  103         /* Load timestamp before locking.  Less accurate but less contention. */
  104         getmicrotime(&now);
  105 
  106         /* Grab a read lock on the filemon inuse list. */
  107         filemon_lock_read();
  108 
  109         /* Lock the found filemon structure. */
  110         filemon_filemon_lock(filemon);
  111 
  112         len = snprintf(filemon->msgbufr, sizeof(filemon->msgbufr),
  113             "# filemon version %d\n# Target pid %d\n# Start %ju.%06ju\nV %d\n",
  114             FILEMON_VERSION, curproc->p_pid, (uintmax_t)now.tv_sec,
  115             (uintmax_t)now.tv_usec, FILEMON_VERSION);
  116 
  117         filemon_output(filemon, filemon->msgbufr, len);
  118 
  119         /* Unlock the found filemon structure. */
  120         filemon_filemon_unlock(filemon);
  121 
  122         /* Release the read lock. */
  123         filemon_unlock_read();
  124 }
  125 
  126 static int
  127 filemon_wrapper_chdir(struct thread *td, struct chdir_args *uap)
  128 {
  129         int ret;
  130         size_t done;
  131         size_t len;
  132         struct filemon *filemon;
  133 
  134         if ((ret = sys_chdir(td, uap)) == 0) {
  135                 /* Grab a read lock on the filemon inuse list. */
  136                 filemon_lock_read();
  137 
  138                 if ((filemon = filemon_pid_check(curproc)) != NULL) {
  139                         /* Lock the found filemon structure. */
  140                         filemon_filemon_lock(filemon);
  141 
  142                         copyinstr(uap->path, filemon->fname1,
  143                             sizeof(filemon->fname1), &done);
  144 
  145                         len = snprintf(filemon->msgbufr,
  146                             sizeof(filemon->msgbufr), "C %d %s\n",
  147                             curproc->p_pid, filemon->fname1);
  148 
  149                         filemon_output(filemon, filemon->msgbufr, len);
  150 
  151                         /* Unlock the found filemon structure. */
  152                         filemon_filemon_unlock(filemon);
  153                 }
  154 
  155                 /* Release the read lock. */
  156                 filemon_unlock_read();
  157         }
  158 
  159         return (ret);
  160 }
  161 
  162 static int
  163 filemon_wrapper_execve(struct thread *td, struct execve_args *uap)
  164 {
  165         char fname[MAXPATHLEN];
  166         int ret;
  167         size_t done;
  168         size_t len;
  169         struct filemon *filemon;
  170 
  171         copyinstr(uap->fname, fname, sizeof(fname), &done);
  172 
  173         if ((ret = sys_execve(td, uap)) == 0) {
  174                 /* Grab a read lock on the filemon inuse list. */
  175                 filemon_lock_read();
  176 
  177                 if ((filemon = filemon_pid_check(curproc)) != NULL) {
  178                         /* Lock the found filemon structure. */
  179                         filemon_filemon_lock(filemon);
  180 
  181                         len = snprintf(filemon->msgbufr,
  182                             sizeof(filemon->msgbufr), "E %d %s\n",
  183                             curproc->p_pid, fname);
  184 
  185                         filemon_output(filemon, filemon->msgbufr, len);
  186 
  187                         /* Unlock the found filemon structure. */
  188                         filemon_filemon_unlock(filemon);
  189                 }
  190 
  191                 /* Release the read lock. */
  192                 filemon_unlock_read();
  193         }
  194 
  195         return (ret);
  196 }
  197 
  198 #if defined(COMPAT_IA32) || defined(COMPAT_FREEBSD32) || defined(COMPAT_ARCH32)
  199 static int
  200 filemon_wrapper_freebsd32_execve(struct thread *td,
  201     struct freebsd32_execve_args *uap)
  202 {
  203         char fname[MAXPATHLEN];
  204         int ret;
  205         size_t done;
  206         size_t len;
  207         struct filemon *filemon;
  208 
  209         copyinstr(uap->fname, fname, sizeof(fname), &done);
  210 
  211         if ((ret = freebsd32_execve(td, uap)) == 0) {
  212                 /* Grab a read lock on the filemon inuse list. */
  213                 filemon_lock_read();
  214 
  215                 if ((filemon = filemon_pid_check(curproc)) != NULL) {
  216                         /* Lock the found filemon structure. */
  217                         filemon_filemon_lock(filemon);
  218 
  219                         len = snprintf(filemon->msgbufr,
  220                             sizeof(filemon->msgbufr), "E %d %s\n",
  221                             curproc->p_pid, fname);
  222 
  223                         filemon_output(filemon, filemon->msgbufr, len);
  224 
  225                         /* Unlock the found filemon structure. */
  226                         filemon_filemon_unlock(filemon);
  227                 }
  228 
  229                 /* Release the read lock. */
  230                 filemon_unlock_read();
  231         }
  232 
  233         return (ret);
  234 }
  235 #endif
  236 
  237 static int
  238 filemon_wrapper_fork(struct thread *td, struct fork_args *uap)
  239 {
  240         int ret;
  241         size_t len;
  242         struct filemon *filemon;
  243 
  244         if ((ret = sys_fork(td, uap)) == 0) {
  245                 /* Grab a read lock on the filemon inuse list. */
  246                 filemon_lock_read();
  247 
  248                 if ((filemon = filemon_pid_check(curproc)) != NULL) {
  249                         /* Lock the found filemon structure. */
  250                         filemon_filemon_lock(filemon);
  251 
  252                         len = snprintf(filemon->msgbufr,
  253                             sizeof(filemon->msgbufr), "F %d %ld\n",
  254                             curproc->p_pid, (long)curthread->td_retval[0]);
  255 
  256                         filemon_output(filemon, filemon->msgbufr, len);
  257 
  258                         /* Unlock the found filemon structure. */
  259                         filemon_filemon_unlock(filemon);
  260                 }
  261 
  262                 /* Release the read lock. */
  263                 filemon_unlock_read();
  264         }
  265 
  266         return (ret);
  267 }
  268 
  269 static int
  270 filemon_wrapper_open(struct thread *td, struct open_args *uap)
  271 {
  272         int ret;
  273         size_t done;
  274         size_t len;
  275         struct filemon *filemon;
  276 
  277         if ((ret = sys_open(td, uap)) == 0) {
  278                 /* Grab a read lock on the filemon inuse list. */
  279                 filemon_lock_read();
  280 
  281                 if ((filemon = filemon_pid_check(curproc)) != NULL) {
  282                         /* Lock the found filemon structure. */
  283                         filemon_filemon_lock(filemon);
  284 
  285                         copyinstr(uap->path, filemon->fname1,
  286                             sizeof(filemon->fname1), &done);
  287 
  288                         if (uap->flags & O_RDWR) {
  289                                 /*
  290                                  * We'll get the W record below, but need
  291                                  * to also output an R to distingish from
  292                                  * O_WRONLY.
  293                                  */
  294                                 len = snprintf(filemon->msgbufr,
  295                                     sizeof(filemon->msgbufr), "R %d %s\n",
  296                                     curproc->p_pid, filemon->fname1);
  297                                 filemon_output(filemon, filemon->msgbufr, len);
  298                         }
  299 
  300 
  301                         len = snprintf(filemon->msgbufr,
  302                             sizeof(filemon->msgbufr), "%c %d %s\n",
  303                             (uap->flags & O_ACCMODE) ? 'W':'R',
  304                             curproc->p_pid, filemon->fname1);
  305                         filemon_output(filemon, filemon->msgbufr, len);
  306 
  307                         /* Unlock the found filemon structure. */
  308                         filemon_filemon_unlock(filemon);
  309                 }
  310 
  311                 /* Release the read lock. */
  312                 filemon_unlock_read();
  313         }
  314 
  315         return (ret);
  316 }
  317 
  318 static int
  319 filemon_wrapper_rename(struct thread *td, struct rename_args *uap)
  320 {
  321         int ret;
  322         size_t done;
  323         size_t len;
  324         struct filemon *filemon;
  325 
  326         if ((ret = sys_rename(td, uap)) == 0) {
  327                 /* Grab a read lock on the filemon inuse list. */
  328                 filemon_lock_read();
  329 
  330                 if ((filemon = filemon_pid_check(curproc)) != NULL) {
  331                         /* Lock the found filemon structure. */
  332                         filemon_filemon_lock(filemon);
  333 
  334                         copyinstr(uap->from, filemon->fname1,
  335                             sizeof(filemon->fname1), &done);
  336                         copyinstr(uap->to, filemon->fname2,
  337                             sizeof(filemon->fname2), &done);
  338 
  339                         len = snprintf(filemon->msgbufr,
  340                             sizeof(filemon->msgbufr), "M %d '%s' '%s'\n",
  341                             curproc->p_pid, filemon->fname1, filemon->fname2);
  342 
  343                         filemon_output(filemon, filemon->msgbufr, len);
  344 
  345                         /* Unlock the found filemon structure. */
  346                         filemon_filemon_unlock(filemon);
  347                 }
  348 
  349                 /* Release the read lock. */
  350                 filemon_unlock_read();
  351         }
  352 
  353         return (ret);
  354 }
  355 
  356 static int
  357 filemon_wrapper_link(struct thread *td, struct link_args *uap)
  358 {
  359         int ret;
  360         size_t done;
  361         size_t len;
  362         struct filemon *filemon;
  363 
  364         if ((ret = sys_link(td, uap)) == 0) {
  365                 /* Grab a read lock on the filemon inuse list. */
  366                 filemon_lock_read();
  367 
  368                 if ((filemon = filemon_pid_check(curproc)) != NULL) {
  369                         /* Lock the found filemon structure. */
  370                         filemon_filemon_lock(filemon);
  371 
  372                         copyinstr(uap->path, filemon->fname1,
  373                             sizeof(filemon->fname1), &done);
  374                         copyinstr(uap->link, filemon->fname2,
  375                             sizeof(filemon->fname2), &done);
  376 
  377                         len = snprintf(filemon->msgbufr,
  378                             sizeof(filemon->msgbufr), "L %d '%s' '%s'\n",
  379                             curproc->p_pid, filemon->fname1, filemon->fname2);
  380 
  381                         filemon_output(filemon, filemon->msgbufr, len);
  382 
  383                         /* Unlock the found filemon structure. */
  384                         filemon_filemon_unlock(filemon);
  385                 }
  386 
  387                 /* Release the read lock. */
  388                 filemon_unlock_read();
  389         }
  390 
  391         return (ret);
  392 }
  393 
  394 static int
  395 filemon_wrapper_symlink(struct thread *td, struct symlink_args *uap)
  396 {
  397         int ret;
  398         size_t done;
  399         size_t len;
  400         struct filemon *filemon;
  401 
  402         if ((ret = sys_symlink(td, uap)) == 0) {
  403                 /* Grab a read lock on the filemon inuse list. */
  404                 filemon_lock_read();
  405 
  406                 if ((filemon = filemon_pid_check(curproc)) != NULL) {
  407                         /* Lock the found filemon structure. */
  408                         filemon_filemon_lock(filemon);
  409 
  410                         copyinstr(uap->path, filemon->fname1,
  411                             sizeof(filemon->fname1), &done);
  412                         copyinstr(uap->link, filemon->fname2,
  413                             sizeof(filemon->fname2), &done);
  414 
  415                         len = snprintf(filemon->msgbufr,
  416                             sizeof(filemon->msgbufr), "L %d '%s' '%s'\n",
  417                             curproc->p_pid, filemon->fname1, filemon->fname2);
  418 
  419                         filemon_output(filemon, filemon->msgbufr, len);
  420 
  421                         /* Unlock the found filemon structure. */
  422                         filemon_filemon_unlock(filemon);
  423                 }
  424 
  425                 /* Release the read lock. */
  426                 filemon_unlock_read();
  427         }
  428 
  429         return (ret);
  430 }
  431 
  432 #ifdef FILEMON_HAS_LINKAT
  433 static int
  434 filemon_wrapper_linkat(struct thread *td, struct linkat_args *uap)
  435 {
  436         int ret;
  437         size_t done;
  438         size_t len;
  439         struct filemon *filemon;
  440 
  441         if ((ret = sys_linkat(td, uap)) == 0) {
  442                 /* Grab a read lock on the filemon inuse list. */
  443                 filemon_lock_read();
  444 
  445                 if ((filemon = filemon_pid_check(curproc)) != NULL) {
  446                         /* Lock the found filemon structure. */
  447                         filemon_filemon_lock(filemon);
  448 
  449                         copyinstr(uap->path1, filemon->fname1,
  450                             sizeof(filemon->fname1), &done);
  451                         copyinstr(uap->path2, filemon->fname2,
  452                             sizeof(filemon->fname2), &done);
  453 
  454                         len = snprintf(filemon->msgbufr,
  455                             sizeof(filemon->msgbufr), "L %d '%s' '%s'\n",
  456                             curproc->p_pid, filemon->fname1, filemon->fname2);
  457 
  458                         filemon_output(filemon, filemon->msgbufr, len);
  459 
  460                         /* Unlock the found filemon structure. */
  461                         filemon_filemon_unlock(filemon);
  462                 }
  463 
  464                 /* Release the read lock. */
  465                 filemon_unlock_read();
  466         }
  467 
  468         return (ret);
  469 }
  470 #endif
  471 
  472 static int
  473 filemon_wrapper_stat(struct thread *td, struct stat_args *uap)
  474 {
  475         int ret;
  476         size_t done;
  477         size_t len;
  478         struct filemon *filemon;
  479 
  480         if ((ret = sys_stat(td, uap)) == 0) {
  481                 /* Grab a read lock on the filemon inuse list. */
  482                 filemon_lock_read();
  483 
  484                 if ((filemon = filemon_pid_check(curproc)) != NULL) {
  485                         /* Lock the found filemon structure. */
  486                         filemon_filemon_lock(filemon);
  487 
  488                         copyinstr(uap->path, filemon->fname1,
  489                             sizeof(filemon->fname1), &done);
  490 
  491                         len = snprintf(filemon->msgbufr,
  492                             sizeof(filemon->msgbufr), "S %d %s\n",
  493                             curproc->p_pid, filemon->fname1);
  494 
  495                         filemon_output(filemon, filemon->msgbufr, len);
  496 
  497                         /* Unlock the found filemon structure. */
  498                         filemon_filemon_unlock(filemon);
  499                 }
  500 
  501                 /* Release the read lock. */
  502                 filemon_unlock_read();
  503         }
  504 
  505         return (ret);
  506 }
  507 
  508 #if defined(COMPAT_IA32) || defined(COMPAT_FREEBSD32) || defined(COMPAT_ARCH32)
  509 static int
  510 filemon_wrapper_freebsd32_stat(struct thread *td,
  511     struct freebsd32_stat_args *uap)
  512 {
  513         int ret;
  514         size_t done;
  515         size_t len;
  516         struct filemon *filemon;
  517 
  518         if ((ret = freebsd32_stat(td, uap)) == 0) {
  519                 /* Grab a read lock on the filemon inuse list. */
  520                 filemon_lock_read();
  521 
  522                 if ((filemon = filemon_pid_check(curproc)) != NULL) {
  523                         /* Lock the found filemon structure. */
  524                         filemon_filemon_lock(filemon);
  525 
  526                         copyinstr(uap->path, filemon->fname1,
  527                             sizeof(filemon->fname1), &done);
  528 
  529                         len = snprintf(filemon->msgbufr,
  530                             sizeof(filemon->msgbufr), "S %d %s\n",
  531                             curproc->p_pid, filemon->fname1);
  532 
  533                         filemon_output(filemon, filemon->msgbufr, len);
  534 
  535                         /* Unlock the found filemon structure. */
  536                         filemon_filemon_unlock(filemon);
  537                 }
  538 
  539                 /* Release the read lock. */
  540                 filemon_unlock_read();
  541         }
  542 
  543         return (ret);
  544 }
  545 #endif
  546 
  547 static void
  548 filemon_wrapper_sys_exit(struct thread *td, struct sys_exit_args *uap)
  549 {
  550         size_t len;
  551         struct filemon *filemon;
  552         struct timeval now;
  553 
  554         /* Get timestamp before locking. */
  555         getmicrotime(&now);
  556 
  557         /* Grab a read lock on the filemon inuse list. */
  558         filemon_lock_read();
  559 
  560         if ((filemon = filemon_pid_check(curproc)) != NULL) {
  561                 /* Lock the found filemon structure. */
  562                 filemon_filemon_lock(filemon);
  563 
  564                 len = snprintf(filemon->msgbufr, sizeof(filemon->msgbufr),
  565                     "X %d %d\n", curproc->p_pid, uap->rval);
  566 
  567                 filemon_output(filemon, filemon->msgbufr, len);
  568 
  569                 /* Check if the monitored process is about to exit. */
  570                 if (filemon->pid == curproc->p_pid) {
  571                         len = snprintf(filemon->msgbufr,
  572                             sizeof(filemon->msgbufr),
  573                             "# Stop %ju.%06ju\n# Bye bye\n",
  574                             (uintmax_t)now.tv_sec, (uintmax_t)now.tv_usec);
  575 
  576                         filemon_output(filemon, filemon->msgbufr, len);
  577                         filemon->pid = -1;
  578                 }
  579 
  580                 /* Unlock the found filemon structure. */
  581                 filemon_filemon_unlock(filemon);
  582         }
  583 
  584         /* Release the read lock. */
  585         filemon_unlock_read();
  586 
  587         sys_sys_exit(td, uap);
  588 }
  589 
  590 static int
  591 filemon_wrapper_unlink(struct thread *td, struct unlink_args *uap)
  592 {
  593         int ret;
  594         size_t done;
  595         size_t len;
  596         struct filemon *filemon;
  597 
  598         if ((ret = sys_unlink(td, uap)) == 0) {
  599                 /* Grab a read lock on the filemon inuse list. */
  600                 filemon_lock_read();
  601 
  602                 if ((filemon = filemon_pid_check(curproc)) != NULL) {
  603                         /* Lock the found filemon structure. */
  604                         filemon_filemon_lock(filemon);
  605 
  606                         copyinstr(uap->path, filemon->fname1,
  607                             sizeof(filemon->fname1), &done);
  608 
  609                         len = snprintf(filemon->msgbufr,
  610                             sizeof(filemon->msgbufr), "D %d %s\n",
  611                             curproc->p_pid, filemon->fname1);
  612 
  613                         filemon_output(filemon, filemon->msgbufr, len);
  614 
  615                         /* Unlock the found filemon structure. */
  616                         filemon_filemon_unlock(filemon);
  617                 }
  618 
  619                 /* Release the read lock. */
  620                 filemon_unlock_read();
  621         }
  622 
  623         return (ret);
  624 }
  625 
  626 static int
  627 filemon_wrapper_vfork(struct thread *td, struct vfork_args *uap)
  628 {
  629         int ret;
  630         size_t len;
  631         struct filemon *filemon;
  632 
  633         if ((ret = sys_vfork(td, uap)) == 0) {
  634                 /* Grab a read lock on the filemon inuse list. */
  635                 filemon_lock_read();
  636 
  637                 if ((filemon = filemon_pid_check(curproc)) != NULL) {
  638                         /* Lock the found filemon structure. */
  639                         filemon_filemon_lock(filemon);
  640 
  641                         len = snprintf(filemon->msgbufr,
  642                             sizeof(filemon->msgbufr), "F %d %ld\n",
  643                             curproc->p_pid, (long)curthread->td_retval[0]);
  644 
  645                         filemon_output(filemon, filemon->msgbufr, len);
  646 
  647                         /* Unlock the found filemon structure. */
  648                         filemon_filemon_unlock(filemon);
  649                 }
  650 
  651                 /* Release the read lock. */
  652                 filemon_unlock_read();
  653         }
  654 
  655         return (ret);
  656 }
  657 
  658 static void
  659 filemon_wrapper_install(void)
  660 {
  661 #if defined(__i386__)
  662         struct sysent *sv_table = elf32_freebsd_sysvec.sv_table;
  663 #elif defined(__amd64__)
  664         struct sysent *sv_table = elf64_freebsd_sysvec.sv_table;
  665 #else
  666 #error Machine type not supported
  667 #endif
  668 
  669         sv_table[SYS_chdir].sy_call = (sy_call_t *) filemon_wrapper_chdir;
  670         sv_table[SYS_exit].sy_call = (sy_call_t *) filemon_wrapper_sys_exit;
  671         sv_table[SYS_execve].sy_call = (sy_call_t *) filemon_wrapper_execve;
  672         sv_table[SYS_fork].sy_call = (sy_call_t *) filemon_wrapper_fork;
  673         sv_table[SYS_open].sy_call = (sy_call_t *) filemon_wrapper_open;
  674         sv_table[SYS_rename].sy_call = (sy_call_t *) filemon_wrapper_rename;
  675         sv_table[SYS_stat].sy_call = (sy_call_t *) filemon_wrapper_stat;
  676         sv_table[SYS_unlink].sy_call = (sy_call_t *) filemon_wrapper_unlink;
  677         sv_table[SYS_vfork].sy_call = (sy_call_t *) filemon_wrapper_vfork;
  678         sv_table[SYS_link].sy_call = (sy_call_t *) filemon_wrapper_link;
  679         sv_table[SYS_symlink].sy_call = (sy_call_t *) filemon_wrapper_symlink;
  680 #ifdef FILEMON_HAS_LINKAT
  681         sv_table[SYS_linkat].sy_call = (sy_call_t *) filemon_wrapper_linkat;
  682 #endif
  683 
  684 #if defined(COMPAT_IA32) || defined(COMPAT_FREEBSD32) || defined(COMPAT_ARCH32)
  685         sv_table = ia32_freebsd_sysvec.sv_table;
  686 
  687         sv_table[FREEBSD32_SYS_chdir].sy_call = (sy_call_t *) filemon_wrapper_chdir;
  688         sv_table[FREEBSD32_SYS_exit].sy_call = (sy_call_t *) filemon_wrapper_sys_exit;
  689         sv_table[FREEBSD32_SYS_freebsd32_execve].sy_call = (sy_call_t *) filemon_wrapper_freebsd32_execve;
  690         sv_table[FREEBSD32_SYS_fork].sy_call = (sy_call_t *) filemon_wrapper_fork;
  691         sv_table[FREEBSD32_SYS_open].sy_call = (sy_call_t *) filemon_wrapper_open;
  692         sv_table[FREEBSD32_SYS_rename].sy_call = (sy_call_t *) filemon_wrapper_rename;
  693         sv_table[FREEBSD32_SYS_freebsd32_stat].sy_call = (sy_call_t *) filemon_wrapper_freebsd32_stat;
  694         sv_table[FREEBSD32_SYS_unlink].sy_call = (sy_call_t *) filemon_wrapper_unlink;
  695         sv_table[FREEBSD32_SYS_vfork].sy_call = (sy_call_t *) filemon_wrapper_vfork;
  696         sv_table[FREEBSD32_SYS_link].sy_call = (sy_call_t *) filemon_wrapper_link;
  697         sv_table[FREEBSD32_SYS_symlink].sy_call = (sy_call_t *) filemon_wrapper_symlink;
  698 #ifdef FILEMON_HAS_LINKAT
  699         sv_table[FREEBSD32_SYS_linkat].sy_call = (sy_call_t *) filemon_wrapper_linkat;
  700 #endif
  701 #endif  /* COMPAT_ARCH32 */
  702 }
  703 
  704 static void
  705 filemon_wrapper_deinstall(void)
  706 {
  707 #if defined(__i386__)
  708         struct sysent *sv_table = elf32_freebsd_sysvec.sv_table;
  709 #elif defined(__amd64__)
  710         struct sysent *sv_table = elf64_freebsd_sysvec.sv_table;
  711 #else
  712 #error Machine type not supported
  713 #endif
  714 
  715         sv_table[SYS_chdir].sy_call = (sy_call_t *)sys_chdir;
  716         sv_table[SYS_exit].sy_call = (sy_call_t *)sys_sys_exit;
  717         sv_table[SYS_execve].sy_call = (sy_call_t *)sys_execve;
  718         sv_table[SYS_fork].sy_call = (sy_call_t *)sys_fork;
  719         sv_table[SYS_open].sy_call = (sy_call_t *)sys_open;
  720         sv_table[SYS_rename].sy_call = (sy_call_t *)sys_rename;
  721         sv_table[SYS_stat].sy_call = (sy_call_t *)sys_stat;
  722         sv_table[SYS_unlink].sy_call = (sy_call_t *)sys_unlink;
  723         sv_table[SYS_vfork].sy_call = (sy_call_t *)sys_vfork;
  724         sv_table[SYS_link].sy_call = (sy_call_t *)sys_link;
  725         sv_table[SYS_symlink].sy_call = (sy_call_t *)sys_symlink;
  726 #ifdef FILEMON_HAS_LINKAT
  727         sv_table[SYS_linkat].sy_call = (sy_call_t *)sys_linkat;
  728 #endif
  729 
  730 #if defined(COMPAT_IA32) || defined(COMPAT_FREEBSD32) || defined(COMPAT_ARCH32)
  731         sv_table = ia32_freebsd_sysvec.sv_table;
  732 
  733         sv_table[FREEBSD32_SYS_chdir].sy_call = (sy_call_t *)sys_chdir;
  734         sv_table[FREEBSD32_SYS_exit].sy_call = (sy_call_t *)sys_sys_exit;
  735         sv_table[FREEBSD32_SYS_freebsd32_execve].sy_call = (sy_call_t *)freebsd32_execve;
  736         sv_table[FREEBSD32_SYS_fork].sy_call = (sy_call_t *)sys_fork;
  737         sv_table[FREEBSD32_SYS_open].sy_call = (sy_call_t *)sys_open;
  738         sv_table[FREEBSD32_SYS_rename].sy_call = (sy_call_t *)sys_rename;
  739         sv_table[FREEBSD32_SYS_freebsd32_stat].sy_call = (sy_call_t *)freebsd32_stat;
  740         sv_table[FREEBSD32_SYS_unlink].sy_call = (sy_call_t *)sys_unlink;
  741         sv_table[FREEBSD32_SYS_vfork].sy_call = (sy_call_t *)sys_vfork;
  742         sv_table[FREEBSD32_SYS_link].sy_call = (sy_call_t *)sys_link;
  743         sv_table[FREEBSD32_SYS_symlink].sy_call = (sy_call_t *)sys_symlink;
  744 #ifdef FILEMON_HAS_LINKAT
  745         sv_table[FREEBSD32_SYS_linkat].sy_call = (sy_call_t *)sys_linkat;
  746 #endif
  747 #endif  /* COMPAT_ARCH32 */
  748 }
Cache object: 107acddcebdcf7c9d650b0adc297f007
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.
FreeBSD/Linux Kernel Cross Reference sys/dev/filemon/filemon_wrapper.c

FreeBSD/Linux Kernel Cross Reference
sys/dev/filemon/filemon_wrapper.c
