usr.bin/truss/i386-fbsd.c

   1 /*
   2  * Copryight 1997 Sean Eric Fagan
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  * 3. All advertising materials mentioning features or use of this software
  13  *    must display the following acknowledgement:
  14  *      This product includes software developed by Sean Eric Fagan
  15  * 4. Neither the name of the author may be used to endorse or promote
  16  *    products derived from this software without specific prior written
  17  *    permission.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  22  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  29  * SUCH DAMAGE.
  30  */
  31
  32 #ifndef lint
  33 static const char rcsid[] =
  34   "$FreeBSD$";
  35 #endif /* not lint */
  36
  37 /*
  38  * FreeBSD/386-specific system call handling.  This is probably the most
  39  * complex part of the entire truss program, although I've got lots of
  40  * it handled relatively cleanly now.  The system call names are generated
  41  * automatically, thanks to /usr/src/sys/kern/syscalls.master.  The
  42  * names used for the various structures are confusing, I sadly admit.
  43  */
  44
  45 #include <errno.h>
  46 #include <fcntl.h>
  47 #include <signal.h>
  48 #include <stdio.h>
  49 #include <stdlib.h>
  50 #include <string.h>
  51 #include <unistd.h>
  52 #include <sys/ioctl.h>
  53 #include <sys/pioctl.h>
  54 #include <machine/reg.h>
  55 #include <machine/psl.h>
  56 #include <sys/syscall.h>
  57
  58 #include "syscall.h"
  59
  60 static int fd = -1;
  61 static int cpid = -1;
  62 extern int Procfd;
  63
  64 extern FILE *outfile;
  65 #include "syscalls.h"
  66
  67 static int nsyscalls = sizeof(syscallnames) / sizeof(syscallnames[0]);
  68
  69 /*
  70  * This is what this particular file uses to keep track of a system call.
  71  * It is probably not quite sufficient -- I can probably use the same
  72  * structure for the various syscall personalities, and I also probably
  73  * need to nest system calls (for signal handlers).
  74  *
  75  * 'struct syscall' describes the system call; it may be NULL, however,
  76  * if we don't know about this particular system call yet.
  77  */
  78 static struct freebsd_syscall {
  79         struct syscall *sc;
  80         char *name;
  81         int number;
  82         unsigned long *args;
  83         int nargs;      /* number of arguments -- *not* number of words! */
  84         char **s_args;  /* the printable arguments */
  85 } fsc;
  86
  87 /* Clear up and free parts of the fsc structure. */
  88 static inline void
  89 clear_fsc() {
  90   if (fsc.args) {
  91     free(fsc.args);
  92   }
  93   if (fsc.s_args) {
  94     int i;
  95     for (i = 0; i < fsc.nargs; i++)
  96       if (fsc.s_args[i])
  97         free(fsc.s_args[i]);
  98     free(fsc.s_args);
  99   }
 100   memset(&fsc, 0, sizeof(fsc));
 101 }
 102
 103 /*
 104  * Called when a process has entered a system call.  nargs is the
 105  * number of words, not number of arguments (a necessary distinction
 106  * in some cases).  Note that if the STOPEVENT() code in i386/i386/trap.c
 107  * is ever changed these functions need to keep up.
 108  */
 109
 110 void
 111 i386_syscall_entry(int pid, int nargs) {
 112   char buf[32];
 113   struct reg regs = { 0 };
 114   int syscall;
 115   int i;
 116   unsigned int parm_offset;
 117   struct syscall *sc;
 118
 119   if (fd == -1 || pid != cpid) {
 120     sprintf(buf, "/proc/%d/regs", pid);
 121     fd = open(buf, O_RDWR);
 122     if (fd == -1) {
 123       fprintf(outfile, "-- CANNOT READ REGISTERS --\n");
 124       return;
 125     }
 126     cpid = pid;
 127   }
 128
 129   clear_fsc();
 130   lseek(fd, 0L, 0);
 131   i = read(fd, &regs, sizeof(regs));
 132   parm_offset = regs.r_esp + sizeof(int);
 133
 134   /*
 135    * FreeBSD has two special kinds of system call redirctions --
 136    * SYS_syscall, and SYS___syscall.  The former is the old syscall()
 137    * routine, basicly; the latter is for quad-aligned arguments.
 138    */
 139   syscall = regs.r_eax;
 140   switch (syscall) {
 141   case SYS_syscall:
 142     lseek(Procfd, parm_offset, SEEK_SET);
 143     read(Procfd, &syscall, sizeof(int));
 144     parm_offset += sizeof(int);
 145     break;
 146   case SYS___syscall:
 147     lseek(Procfd, parm_offset, SEEK_SET);
 148     read(Procfd, &syscall, sizeof(int));
 149     parm_offset += sizeof(quad_t);
 150     break;
 151   }
 152
 153   fsc.number = syscall;
 154   fsc.name =
 155     (syscall < 0 || syscall > nsyscalls) ? NULL : syscallnames[syscall];
 156   if (!fsc.name) {
 157     fprintf(outfile, "-- UNKNOWN SYSCALL %d --\n", syscall);
 158   }
 159
 160   if (nargs == 0)
 161     return;
 162
 163   fsc.args = malloc((1+nargs) * sizeof(unsigned long));
 164   lseek(Procfd, parm_offset, SEEK_SET);
 165   if (read(Procfd, fsc.args, nargs * sizeof(unsigned long)) == -1)
 166     return;
 167
 168   sc = get_syscall(fsc.name);
 169   if (sc) {
 170     fsc.nargs = sc->nargs;
 171   } else {
 172 #if DEBUG
 173     fprintf(outfile, "unknown syscall %s -- setting args to %d\n",
 174            fsc.name, nargs);
 175 #endif
 176     fsc.nargs = nargs;
 177   }
 178
 179   fsc.s_args = malloc((1+fsc.nargs) * sizeof(char*));
 180   memset(fsc.s_args, 0, fsc.nargs * sizeof(char*));
 181   fsc.sc = sc;
 182
 183   /*
 184    * At this point, we set up the system call arguments.
 185    * We ignore any OUT ones, however -- those are arguments that
 186    * are set by the system call, and so are probably meaningless
 187    * now.  This doesn't currently support arguments that are
 188    * passed in *and* out, however.
 189    */
 190
 191   if (fsc.name) {
 192
 193 #if DEBUG
 194     fprintf(stderr, "syscall %s(", fsc.name);
 195 #endif
 196     for (i = 0; i < fsc.nargs; i++) {
 197 #if DEBUG
 198       fprintf(stderr, "0x%x%s",
 199              sc
 200              ? fsc.args[sc->args[i].offset]
 201              : fsc.args[i],
 202              i < (fsc.nargs -1) ? "," : "");
 203 #endif
 204       if (sc && !(sc->args[i].type & OUT)) {
 205         fsc.s_args[i] = print_arg(Procfd, &sc->args[i], fsc.args);
 206       }
 207     }
 208 #if DEBUG
 209     fprintf(stderr, ")\n");
 210 #endif
 211   }
 212
 213 #if DEBUG
 214   fprintf(outfile, "\n");
 215 #endif
 216
 217   /*
 218    * Some system calls should be printed out before they are done --
 219    * execve() and exit(), for example, never return.  Possibly change
 220    * this to work for any system call that doesn't have an OUT
 221    * parameter?
 222    */
 223
 224   if (!strcmp(fsc.name, "execve") || !strcmp(fsc.name, "exit")) {
 225     print_syscall(outfile, fsc.name, fsc.nargs, fsc.s_args);
 226   }
 227
 228   return;
 229 }
 230
 231 /*
 232  * And when the system call is done, we handle it here.
 233  * Currently, no attempt is made to ensure that the system calls
 234  * match -- this needs to be fixed (and is, in fact, why S_SCX includes
 235  * the sytem call number instead of, say, an error status).
 236  */
 237
 238 void
 239 i386_syscall_exit(int pid, int syscall) {
 240   char buf[32];
 241   struct reg regs;
 242   int retval;
 243   int i;
 244   int errorp;
 245   struct syscall *sc;
 246
 247   if (fd == -1 || pid != cpid) {
 248     sprintf(buf, "/proc/%d/regs", pid);
 249     fd = open(buf, O_RDONLY);
 250     if (fd == -1) {
 251       fprintf(outfile, "-- CANNOT READ REGISTERS --\n");
 252       return;
 253     }
 254     cpid = pid;
 255   }
 256
 257   lseek(fd, 0L, 0);
 258   if (read(fd, &regs, sizeof(regs)) != sizeof(regs))
 259     return;
 260   retval = regs.r_eax;
 261   errorp = !!(regs.r_eflags & PSL_C);
 262
 263   /*
 264    * This code, while simpler than the initial versions I used, could
 265    * stand some significant cleaning.
 266    */
 267
 268   sc = fsc.sc;
 269   if (!sc) {
 270     for (i = 0; i < fsc.nargs; i++) {
 271       fsc.s_args[i] = malloc(12);
 272       sprintf(fsc.s_args[i], "0x%lx", fsc.args[i]);
 273     }
 274   } else {
 275     /*
 276      * Here, we only look for arguments that have OUT masked in --
 277      * otherwise, they were handled in the syscall_entry function.
 278      */
 279     for (i = 0; i < sc->nargs; i++) {
 280       char *temp;
 281       if (sc->args[i].type & OUT) {
 282         /*
 283          * If an error occurred, than don't bothe getting the data;
 284          * it may not be valid.
 285          */
 286         if (errorp) {
 287           temp = malloc(12);
 288           sprintf(temp, "0x%lx", fsc.args[sc->args[i].offset]);
 289         } else {
 290           temp = print_arg(Procfd, &sc->args[i], fsc.args);
 291         }
 292         fsc.s_args[i] = temp;
 293       }
 294     }
 295   }
 296
 297   /*
 298    * It would probably be a good idea to merge the error handling,
 299    * but that complicates things considerably.
 300    */
 301
 302   print_syscall(outfile, fsc.name, fsc.nargs, fsc.s_args);
 303   if (errorp) {
 304     fprintf(outfile, "errno %d '%s'\n", retval, strerror(retval));
 305   } else {
 306     fprintf(outfile, "returns %d (0x%x)\n", retval, retval);
 307   }
 308   clear_fsc();
 309
 310   return;
 311 }