tables-uniarch.c

   1 /*
   2  * Functions for handling the system call tables.
   3  * These functions are only used by architectures that have either 32 or 64 bit syscalls, but not both.
   4  */
   5
   6 #include <string.h>
   7 #include <stdio.h>
   8 #include <unistd.h>
   9 #include <stdlib.h>
  10
  11 #include "trinity.h"    // ARRAY_SIZE, alloc_shared
  12 #include "arch.h"
  13 #include "syscall.h"
  14 #include "params.h"
  15 #include "log.h"
  16 #include "shm.h"
  17 #include "tables.h"
  18
  19 const struct syscalltable *syscalls;
  20
  21 unsigned int max_nr_syscalls;
  22
  23 void activate_syscall(unsigned int calln)
  24 {
  25         activate_syscall_in_table(calln, &shm->nr_active_syscalls, syscalls, shm->active_syscalls);
  26 }
  27
  28 void deactivate_syscall(unsigned int calln)
  29 {
  30         deactivate_syscall_in_table(calln, &shm->nr_active_syscalls, syscalls, shm->active_syscalls);
  31 }
  32
  33 void toggle_syscall_n(int calln, bool state, const char *arg, const char *arg_name)
  34 {
  35         if (calln == -1) {
  36                 outputerr("No idea what syscall (%s) is.\n", arg);
  37                 exit(EXIT_FAILURE);
  38         }
  39
  40         validate_specific_syscall(syscalls, calln);
  41
  42         if (state == TRUE) {
  43                 syscalls[calln].entry->flags |= ACTIVE;
  44                 activate_syscall(calln);
  45         } else {
  46                 syscalls[calln].entry->flags |= TO_BE_DEACTIVATED;
  47         }
  48
  49         output(0, "Marking syscall %s (%d) as to be %sabled.\n",
  50                 arg_name, calln,
  51                 state ? "en" : "dis");
  52 }
  53
  54
  55 void enable_random_syscalls_uniarch(void)
  56 {
  57         unsigned int call;
  58
  59 retry:
  60         call = rand() % max_nr_syscalls;
  61
  62         if (validate_specific_syscall_silent(syscalls, call) == FALSE)
  63                 goto retry;
  64
  65         if (no_files == TRUE)
  66                 if (is_syscall_net_related(syscalls, call) == FALSE)
  67                         goto retry;
  68
  69         /* if we've set this to be disabled, don't enable it! */
  70         if (syscalls[call].entry->flags & TO_BE_DEACTIVATED)
  71                 goto retry;
  72
  73         toggle_syscall_n(call, TRUE, syscalls[call].entry->name, syscalls[call].entry->name);
  74 }
  75
  76 void disable_non_net_syscalls_uniarch(void)
  77 {
  78         unsigned int i;
  79
  80         for_each_syscall(i) {
  81                 if (validate_specific_syscall_silent(syscalls, i) == FALSE)
  82                         continue;
  83
  84                 if (syscalls[i].entry->flags & ACTIVE) {
  85                         if (is_syscall_net_related(syscalls, i) == FALSE) {
  86                                 toggle_syscall_n(i, FALSE, syscalls[i].entry->name, syscalls[i].entry->name);
  87                         }
  88                 }
  89         }
  90 }
  91
  92 int setup_syscall_group_uniarch(unsigned int group)
  93 {
  94         unsigned int i;
  95
  96         for_each_syscall(i) {
  97                 if (syscalls[i].entry->group == group)
  98                         activate_syscall(i);
  99         }
 100
 101         if (shm->nr_active_syscalls == 0) {
 102                 outputstd("No syscalls found in group\n");
 103                 return FALSE;
 104         } else {
 105                 outputstd("Found %d syscalls in group\n", shm->nr_active_syscalls);
 106         }
 107
 108         return TRUE;
 109 }
 110
 111 void mark_all_syscalls_active_uniarch(void)
 112 {
 113         unsigned int i;
 114
 115         for_each_syscall(i) {
 116                 syscalls[i].entry->flags |= ACTIVE;
 117                 activate_syscall(i);
 118         }
 119 }
 120
 121 void init_syscalls_uniarch(void)
 122 {
 123         unsigned int i;
 124
 125         for_each_syscall(i) {
 126                 if (syscalls[i].entry->flags & ACTIVE)
 127                         if (syscalls[i].entry->init)
 128                                 syscalls[i].entry->init();
 129         }
 130 }
 131
 132 void deactivate_disabled_syscalls_uniarch(void)
 133 {
 134         unsigned int i;
 135
 136         for_each_syscall(i) {
 137                 if (syscalls[i].entry->flags & TO_BE_DEACTIVATED) {
 138                         syscalls[i].entry->flags &= ~(ACTIVE|TO_BE_DEACTIVATED);
 139                         deactivate_syscall(i);
 140                         output(0, "Marked syscall %s (%d) as deactivated.\n",
 141                         syscalls[i].entry->name, syscalls[i].entry->number);
 142                 }
 143         }
 144 }
 145
 146 void dump_syscall_tables_uniarch(void)
 147 {
 148         unsigned int i;
 149
 150         outputstd("syscalls: %d\n", max_nr_syscalls);
 151
 152         for_each_syscall(i) {
 153                 outputstd("entrypoint %d %s : ",
 154                         syscalls[i].entry->number,
 155                         syscalls[i].entry->name);
 156                 show_state(syscalls[i].entry->flags & ACTIVE);
 157                 if (syscalls[i].entry->flags & AVOID_SYSCALL)
 158                         outputstd(" AVOID");
 159                 outputstd("\n");
 160         }
 161 }
 162
 163 void display_enabled_syscalls_uniarch(void)
 164 {
 165         unsigned int i;
 166
 167         for_each_syscall(i) {
 168                 if (syscalls[i].entry->flags & ACTIVE)
 169                         output(0, "syscall %d:%s enabled.\n", i, syscalls[i].entry->name);
 170         }
 171 }