tables-biarch.c

   1 /*
   2  * Functions for handling the system call tables.
   3  * These functions are only used on architectures that have both 32 and 64 bit syscalls.
   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 #define NOTFOUND (unsigned int)-1
  20
  21 const struct syscalltable *syscalls_32bit;
  22 const struct syscalltable *syscalls_64bit;
  23
  24 unsigned int max_nr_32bit_syscalls;
  25 unsigned int max_nr_64bit_syscalls;
  26
  27 bool use_32bit = FALSE;
  28 bool use_64bit = FALSE;
  29
  30 void activate_syscall32(unsigned int calln)
  31 {
  32         activate_syscall_in_table(calln, &shm->nr_active_32bit_syscalls, syscalls_32bit, shm->active_syscalls32);
  33 }
  34
  35 void activate_syscall64(unsigned int calln)
  36 {
  37         activate_syscall_in_table(calln, &shm->nr_active_64bit_syscalls, syscalls_64bit, shm->active_syscalls64);
  38 }
  39
  40 void deactivate_syscall32(unsigned int calln)
  41 {
  42         deactivate_syscall_in_table(calln, &shm->nr_active_32bit_syscalls, syscalls_32bit, shm->active_syscalls32);
  43 }
  44
  45 void deactivate_syscall64(unsigned int calln)
  46 {
  47         deactivate_syscall_in_table(calln, &shm->nr_active_64bit_syscalls, syscalls_64bit, shm->active_syscalls64);
  48 }
  49
  50
  51 int validate_syscall_table_64(void)
  52 {
  53         if (shm->nr_active_64bit_syscalls == 0)
  54                 use_64bit = FALSE;
  55         else
  56                 use_64bit = TRUE;
  57
  58         return use_64bit;
  59 }
  60
  61 int validate_syscall_table_32(void)
  62 {
  63         if (shm->nr_active_32bit_syscalls == 0)
  64                 use_32bit = FALSE;
  65         else
  66                 use_32bit = TRUE;
  67
  68         return use_32bit;
  69 }
  70
  71 void toggle_syscall_biarch_n(int calln, const struct syscalltable *table, bool onlyflag, bool doflag, bool state, void (*activate)(unsigned int), int arch_bits, const char *arg_name)
  72 {
  73         if (calln != -1) {
  74                 struct syscallentry *entry = table[calln].entry;
  75
  76                 validate_specific_syscall(table, calln);
  77
  78                 if ((state == TRUE) && onlyflag && doflag) {
  79                         entry->flags |= ACTIVE;
  80                         (*activate)(calln);
  81                 } else {
  82                         entry->flags |= TO_BE_DEACTIVATED;
  83                 }
  84         }
  85
  86         if ((arch_bits != 0) && (calln != -1))
  87                 output(0, "Marking %d-bit syscall %s (%d) as to be %sabled.\n",
  88                         arch_bits, arg_name, calln,
  89                         state ? "en" : "dis");
  90 }
  91
  92 void toggle_syscall_biarch(const char *arg, bool state)
  93 {
  94         int specific_syscall32 = 0;
  95         int specific_syscall64 = 0;
  96         char *arg_name = NULL;
  97         bool only_32bit = TRUE;
  98         bool only_64bit = TRUE;
  99
 100         check_user_specified_arch(arg, &arg_name, &only_64bit, &only_32bit);
 101
 102         /* If we found a 64bit syscall, validate it. */
 103         specific_syscall64 = search_syscall_table(syscalls_64bit, max_nr_64bit_syscalls, arg_name);
 104         toggle_syscall_biarch_n(specific_syscall64, syscalls_64bit, only_64bit, do_64_arch, state, &activate_syscall64, 0, arg_name);
 105
 106         /* Search for and validate 32bit */
 107         specific_syscall32 = search_syscall_table(syscalls_32bit, max_nr_32bit_syscalls, arg_name);
 108         toggle_syscall_biarch_n(specific_syscall32, syscalls_32bit, only_32bit, do_32_arch, state, &activate_syscall32, 0, arg_name);
 109
 110
 111         if ((!only_32bit) && (!only_64bit)) {
 112                 outputerr("No idea what architecture for syscall (%s) is.\n", arg);
 113                 exit(EXIT_FAILURE);
 114         }
 115
 116         if ((specific_syscall64 == -1) && (specific_syscall32 == -1)) {
 117                 outputerr("No idea what syscall (%s) is.\n", arg);
 118                 exit(EXIT_FAILURE);
 119         }
 120
 121         if ((specific_syscall64 != -1) && (specific_syscall32 != -1)) {
 122                 output(0, "Marking syscall %s (64bit:%d 32bit:%d) as to be %sabled.\n",
 123                         arg_name, specific_syscall64, specific_syscall32,
 124                         state ? "en" : "dis");
 125                 goto out;
 126         }
 127
 128         if (specific_syscall64 != -1) {
 129                 output(0, "Marking 64-bit syscall %s (%d) as to be %sabled.\n",
 130                         arg, specific_syscall64,
 131                         state ? "en" : "dis");
 132                 goto out;
 133         }
 134
 135         if  (specific_syscall32 != -1) {
 136                 output(0, "Marking 32-bit syscall %s (%d) as to be %sabled.\n",
 137                         arg, specific_syscall32,
 138                         state ? "en" : "dis");
 139         }
 140 out:
 141         clear_check_user_specified_arch(arg, &arg_name);
 142         return;
 143
 144 }
 145
 146 void enable_random_syscalls_biarch(void)
 147 {
 148         unsigned int call32 = NOTFOUND, call64 = NOTFOUND;
 149
 150 retry:
 151
 152         //Search for 64 bit version
 153         if (do_64_arch) {
 154                 struct syscallentry *entry = NULL;
 155
 156                 call64 = rand() % max_nr_64bit_syscalls;
 157
 158                 if (validate_specific_syscall_silent(syscalls_64bit, call64) == FALSE)
 159                         goto retry;
 160
 161                 if (no_files == TRUE)
 162                         if (is_syscall_net_related(syscalls_64bit, call64) == FALSE)
 163                                 goto retry;
 164
 165                 entry = syscalls_64bit[call64].entry;
 166
 167                 if (entry->flags & TO_BE_DEACTIVATED) {
 168                         call64 = NOTFOUND;
 169                         goto try32bit;
 170                 }
 171
 172                 if (entry->active_number != 0) {
 173                         call64 = NOTFOUND;
 174                         goto try32bit;
 175                 }
 176
 177                 // If we got so far, then activate it.
 178                 toggle_syscall_biarch_n(call64, syscalls_64bit, TRUE, do_64_arch, TRUE,
 179                                         &activate_syscall64, 64, entry->name);
 180         }
 181
 182 try32bit:
 183         //Search for 32 bit version
 184         if (do_32_arch) {
 185                 struct syscallentry *entry = NULL;
 186
 187                 /* If we enabled a 64bit syscall above, enable its 32-bit counter-part too */
 188                 if (do_64_arch) {
 189                         if (call64 == NOTFOUND) {
 190                                 goto just32;
 191                         } else {
 192                                 call32 = search_syscall_table(syscalls_32bit, max_nr_32bit_syscalls, syscalls_64bit[call64].entry->name);
 193                                 if (call32 == NOTFOUND)
 194                                         return; // syscall is 64-bit only.
 195                         }
 196                 } else {
 197 just32:
 198                         call32 = rand() % max_nr_32bit_syscalls;
 199                 }
 200
 201                 if (validate_specific_syscall_silent(syscalls_32bit, call32) == FALSE)
 202                         return;
 203
 204                 if (no_files == TRUE) {
 205                         if (is_syscall_net_related(syscalls_32bit, call32) == FALSE)
 206                                 return;
 207                 }
 208
 209                 entry = syscalls_32bit[call32].entry;
 210
 211                 if ((entry->flags & TO_BE_DEACTIVATED) || (entry->active_number != 0))
 212                         return;
 213
 214                 //If we got so far, then active it.
 215                 toggle_syscall_biarch_n(call32, syscalls_32bit, TRUE, do_32_arch, TRUE,
 216                                         &activate_syscall32, 32, entry->name);
 217         }
 218 }
 219
 220 void disable_non_net_syscalls_biarch(void)
 221 {
 222         struct syscallentry *entry;
 223         unsigned int i;
 224
 225         for_each_64bit_syscall(i) {
 226                 entry = syscalls_64bit[i].entry;
 227
 228                 if (validate_specific_syscall_silent(syscalls_64bit, i) == FALSE)
 229                         continue;
 230
 231                 if (entry->flags & ACTIVE) {
 232                         if (is_syscall_net_related(syscalls_64bit, i) == FALSE) {
 233                                 toggle_syscall_biarch_n(i, syscalls_64bit, FALSE, do_64_arch, FALSE,
 234                                         &activate_syscall64, 64, entry->name);
 235                         }
 236                 }
 237         }
 238
 239         for_each_32bit_syscall(i) {
 240                 entry = syscalls_32bit[i].entry;
 241
 242                 if (validate_specific_syscall_silent(syscalls_32bit, i) == FALSE)
 243                         continue;
 244
 245                 if (entry->flags & ACTIVE) {
 246                         if (is_syscall_net_related(syscalls_32bit, i) == FALSE) {
 247                                 toggle_syscall_biarch_n(i, syscalls_32bit, FALSE, do_32_arch, FALSE,
 248                                         &activate_syscall32, 32, entry->name);
 249                         }
 250                 }
 251         }
 252 }
 253
 254 int setup_syscall_group_biarch(unsigned int group)
 255 {
 256         unsigned int i;
 257
 258         for_each_32bit_syscall(i) {
 259                 if (syscalls_32bit[i].entry->group == group)
 260                         activate_syscall32(i);
 261         }
 262
 263         if (shm->nr_active_32bit_syscalls == 0)
 264                 outputstd("No 32-bit syscalls in group\n");
 265         else
 266                 outputstd("Found %d 32-bit syscalls in group\n", shm->nr_active_32bit_syscalls);
 267
 268         /* now the 64 bit table*/
 269         for_each_64bit_syscall(i) {
 270                 if (syscalls_64bit[i].entry->group == group)
 271                         activate_syscall64(i);
 272         }
 273
 274         if (shm->nr_active_64bit_syscalls == 0) {
 275                 outputstd("No 64-bit syscalls in group\n");
 276                 return FALSE;
 277         } else {
 278                 outputstd("Found %d 64-bit syscalls in group\n", shm->nr_active_64bit_syscalls);
 279         }
 280
 281         return TRUE;
 282 }
 283
 284 void mark_all_syscalls_active_biarch(void)
 285 {
 286         unsigned int i;
 287
 288         if (do_32_arch) {
 289                 for_each_32bit_syscall(i) {
 290                         syscalls_32bit[i].entry->flags |= ACTIVE;
 291                         activate_syscall32(i);
 292                 }
 293         }
 294
 295         if (do_64_arch) {
 296                 for_each_64bit_syscall(i) {
 297                         syscalls_64bit[i].entry->flags |= ACTIVE;
 298                         activate_syscall64(i);
 299                 }
 300         }
 301 }
 302
 303 void init_syscalls_biarch(void)
 304 {
 305         struct syscallentry *entry;
 306         unsigned int i;
 307
 308         for_each_64bit_syscall(i) {
 309                 entry = syscalls_64bit[i].entry;
 310                 if (entry->flags & ACTIVE)
 311                         if (entry->init)
 312                                 entry->init();
 313         }
 314
 315         for_each_32bit_syscall(i) {
 316                 entry = syscalls_32bit[i].entry;
 317                 if (entry->flags & ACTIVE)
 318                         if (entry->init)
 319                                 entry->init();
 320         }
 321 }
 322
 323 void deactivate_disabled_syscalls_biarch(void)
 324 {
 325         struct syscallentry *entry;
 326         unsigned int i;
 327
 328         for_each_64bit_syscall(i) {
 329                 entry = syscalls_64bit[i].entry;
 330                 if (entry->flags & TO_BE_DEACTIVATED) {
 331                         entry->flags &= ~(ACTIVE|TO_BE_DEACTIVATED);
 332                         deactivate_syscall64(i);
 333                         output(0, "Marked 64-bit syscall %s (%d) as deactivated.\n",
 334                                 entry->name, entry->number);
 335                 }
 336         }
 337
 338         for_each_32bit_syscall(i) {
 339                 entry = syscalls_32bit[i].entry;
 340                 if (entry->flags & TO_BE_DEACTIVATED) {
 341                         entry->flags &= ~(ACTIVE|TO_BE_DEACTIVATED);
 342                         deactivate_syscall32(i);
 343                         output(0, "Marked 32-bit syscall %s (%d) as deactivated.\n",
 344                                 entry->name, entry->number);
 345                 }
 346         }
 347 }
 348
 349 void dump_syscall_tables_biarch(void)
 350 {
 351         struct syscallentry *entry;
 352         unsigned int i;
 353
 354         outputstd("syscalls: %d [32-bit]\n", max_nr_32bit_syscalls);
 355         outputstd("syscalls: %d [64-bit]\n", max_nr_64bit_syscalls);
 356
 357         for_each_32bit_syscall(i) {
 358                 entry = syscalls_32bit[i].entry;
 359                 outputstd("entrypoint %d %s : [32-bit] ",
 360                         entry->number, entry->name);
 361                 show_state(entry->flags & ACTIVE);
 362
 363                 if (entry->flags & AVOID_SYSCALL)
 364                         outputstd(" AVOID");
 365
 366                 outputstd("\n");
 367         }
 368
 369         for_each_64bit_syscall(i) {
 370                 entry = syscalls_64bit[i].entry;
 371
 372                 outputstd("entrypoint %d %s : [64-bit] ",
 373                         entry->number, entry->name);
 374                 show_state(entry->flags & ACTIVE);
 375
 376                 if (entry->flags & AVOID_SYSCALL)
 377                         outputstd(" AVOID");
 378
 379                 outputstd("\n");
 380         }
 381 }
 382
 383 void display_enabled_syscalls_biarch(void)
 384 {
 385         struct syscallentry *entry;
 386         unsigned int i;
 387
 388         for_each_64bit_syscall(i) {
 389                 entry = syscalls_64bit[i].entry;
 390                 if (entry->flags & ACTIVE)
 391                         output(0, "64-bit syscall %d:%s enabled.\n", i, entry->name);
 392         }
 393
 394         for_each_32bit_syscall(i) {
 395                 entry = syscalls_32bit[i].entry;
 396                 if (entry->flags & ACTIVE)
 397                         output(0, "32-bit syscall %d:%s enabled.\n", i, entry->name);
 398         }
 399 }