trinity.c

   1 #include <stdlib.h>
   2 #include <malloc.h>
   3 #include <string.h>
   4 #include <sys/prctl.h>
   5 #include <sys/types.h>
   6 #include <sys/wait.h>
   7
   8 #include "arch.h"
   9 #include "trinity.h"
  10 #include "files.h"
  11 #include "log.h"
  12 #include "maps.h"
  13 #include "pids.h"
  14 #include "params.h"
  15 #include "random.h"
  16 #include "signals.h"
  17 #include "shm.h"
  18 #include "tables.h"
  19 #include "ioctls.h"
  20 #include "protocols.h"
  21 #include "uid.h"
  22 #include "config.h"     // for VERSION
  23 #include "taint.h"
  24
  25 char *progname = NULL;
  26
  27 unsigned int page_size;
  28 unsigned int num_online_cpus;
  29 unsigned int max_children;
  30
  31 /*
  32  * just in case we're not using the test.sh harness, we
  33  * change to the tmp dir if it exists.
  34  */
  35 static void change_tmp_dir(void)
  36 {
  37         struct stat sb;
  38         const char tmpdir[]="tmp/";
  39         int ret;
  40
  41         /* Check if it exists, bail early if it doesn't */
  42         ret = (lstat(tmpdir, &sb));
  43         if (ret == -1)
  44                 return;
  45
  46         /* Just in case a previous run screwed the perms. */
  47         ret = chmod(tmpdir, 0777);
  48         if (ret == -1)
  49                 output(0, "Couldn't chmod %s to 0777.\n", tmpdir);
  50
  51         ret = chdir(tmpdir);
  52         if (ret == -1)
  53                 output(0, "Couldn't change to %s\n", tmpdir);
  54 }
  55
  56 int main(int argc, char* argv[])
  57 {
  58         int ret = EXIT_SUCCESS;
  59         int childstatus;
  60         pid_t pid;
  61         const char taskname[13]="trinity-main";
  62
  63         outputstd("Trinity v" __stringify(VERSION) "  Dave Jones <davej@redhat.com>\n");
  64
  65         progname = argv[0];
  66
  67         initpid = getpid();
  68
  69         page_size = getpagesize();
  70         num_online_cpus = sysconf(_SC_NPROCESSORS_ONLN);
  71         max_children = num_online_cpus; /* possibly overridden in params. */
  72
  73         select_syscall_tables();
  74
  75         create_shm();
  76
  77         parse_args(argc, argv);
  78
  79         create_shm_arrays();
  80
  81         init_uids();
  82
  83         if (logging == TRUE)
  84                 open_logfiles();
  85
  86         init_shm();
  87
  88         kernel_taint_initial = check_tainted();
  89         if (kernel_taint_initial != 0)
  90                 output(0, "Kernel was tainted on startup. Will ignore flags that are already set.\n");
  91
  92         if (munge_tables() == FALSE) {
  93                 ret = EXIT_FAILURE;
  94                 goto out;
  95         }
  96
  97         if (show_syscall_list == TRUE) {
  98                 dump_syscall_tables();
  99                 goto out;
 100         }
 101
 102         init_syscalls();
 103
 104         if (show_ioctl_list == TRUE) {
 105                 dump_ioctls();
 106                 goto out;
 107         }
 108
 109         do_uid0_check();
 110
 111         if (do_specific_proto == TRUE)
 112                 find_specific_proto(specific_proto_optarg);
 113
 114         init_shared_pages();
 115
 116         parse_devices();
 117
 118         pids_init();
 119
 120         setup_main_signals();
 121
 122         change_tmp_dir();
 123
 124         /* check if we ctrl'c or something went wrong during init. */
 125         if (shm->exit_reason != STILL_RUNNING)
 126                 goto cleanup_fds;
 127
 128         init_watchdog();
 129
 130         /* do an extra fork so that the watchdog and the children don't share a common parent */
 131         fflush(stdout);
 132         pid = fork();
 133         if (pid == 0) {
 134                 shm->mainpid = getpid();
 135
 136                 setup_main_signals();
 137
 138                 output(0, "Main thread is alive.\n");
 139                 prctl(PR_SET_NAME, (unsigned long) &taskname);
 140                 set_seed(0);
 141
 142                 if (setup_fds() == FALSE) {
 143                         shm->exit_reason = EXIT_FD_INIT_FAILURE;        // FIXME: Later, push this down to multiple EXIT's.
 144                         _exit(EXIT_FAILURE);
 145                 }
 146
 147                 if (no_files == FALSE) {
 148                         if (files_in_index == 0) {
 149                                 shm->exit_reason = EXIT_NO_FILES;
 150                                 _exit(EXIT_FAILURE);
 151                         }
 152                 }
 153
 154                 if (dropprivs == TRUE)  //FIXME: Push down into child processes later.
 155                         drop_privs();
 156
 157                 main_loop();
 158
 159                 _exit(EXIT_SUCCESS);
 160         }
 161
 162         /* wait for main loop process to exit. */
 163         (void)waitpid(pid, &childstatus, 0);
 164
 165         /* wait for watchdog to exit. */
 166         waitpid(watchdog_pid, &childstatus, 0);
 167
 168         output(0, "\nRan %ld syscalls. Successes: %ld  Failures: %ld\n",
 169                 shm->total_syscalls_done - 1, shm->successes, shm->failures);
 170
 171 cleanup_fds:
 172
 173         close_sockets();
 174
 175         destroy_shared_mappings();
 176
 177         if (logging == TRUE)
 178                 close_logfiles();
 179
 180 out:
 181
 182         exit(ret);
 183 }