sys-utils/setarch.c

   1 /*
   2  * Copyright (C) 2003-2007 Red Hat, Inc.
   3  *
   4  * This file is part of util-linux.
   5  *
   6  * This file is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This file is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  *
  17  * Written by Elliot Lee <sopwith@redhat.com>
  18  * New personality options & code added by Jindrich Novy <jnovy@redhat.com>
  19  * ADD_NO_RANDOMIZE flag added by Arjan van de Ven <arjanv@redhat.com>
  20  * Help and MIPS support from Mike Frysinger (vapier@gentoo.org)
  21  * Better error handling from Dmitry V. Levin (ldv@altlinux.org)
  22  *
  23  * based on ideas from the ppc32 util by Guy Streeter (2002-01), based on the
  24  * sparc32 util by Jakub Jelinek (1998, 1999)
  25  */
  26
  27 #include <sys/personality.h>
  28 #include <unistd.h>
  29 #include <stdio.h>
  30 #include <string.h>
  31 #include <stdlib.h>
  32 #include <getopt.h>
  33 #include <limits.h>
  34 #include <sys/utsname.h>
  35 #include "nls.h"
  36 #include "c.h"
  37 #include "closestream.h"
  38 #include "sysfs.h"
  39 #include "strutils.h"
  40 #include "procfs.h"
  41
  42 #ifndef HAVE_PERSONALITY
  43 # include <syscall.h>
  44 # define personality(pers) ((long)syscall(SYS_personality, pers))
  45 #endif
  46
  47 #define turn_on(_flag, _opts) \
  48         do { \
  49                 (_opts) |= _flag; \
  50                 if (verbose) \
  51                         printf(_("Switching on %s.\n"), #_flag); \
  52         } while(0)
  53
  54 #ifndef UNAME26
  55 # define UNAME26                 0x0020000
  56 #endif
  57 #ifndef ADDR_NO_RANDOMIZE
  58 # define ADDR_NO_RANDOMIZE       0x0040000
  59 #endif
  60 #ifndef FDPIC_FUNCPTRS
  61 # define FDPIC_FUNCPTRS          0x0080000
  62 #endif
  63 #ifndef MMAP_PAGE_ZERO
  64 # define MMAP_PAGE_ZERO          0x0100000
  65 #endif
  66 #ifndef ADDR_COMPAT_LAYOUT
  67 # define ADDR_COMPAT_LAYOUT      0x0200000
  68 #endif
  69 #ifndef READ_IMPLIES_EXEC
  70 # define READ_IMPLIES_EXEC       0x0400000
  71 #endif
  72 #ifndef ADDR_LIMIT_32BIT
  73 # define ADDR_LIMIT_32BIT        0x0800000
  74 #endif
  75 #ifndef SHORT_INODE
  76 # define SHORT_INODE             0x1000000
  77 #endif
  78 #ifndef WHOLE_SECONDS
  79 # define WHOLE_SECONDS           0x2000000
  80 #endif
  81 #ifndef STICKY_TIMEOUTS
  82 # define STICKY_TIMEOUTS         0x4000000
  83 #endif
  84 #ifndef ADDR_LIMIT_3GB
  85 # define ADDR_LIMIT_3GB          0x8000000
  86 #endif
  87
  88 /* fallback for old glibc-headers 2.17 */
  89 #ifndef PER_LINUX_FDPIC
  90 # define PER_LINUX_FDPIC        (PER_LINUX | FDPIC_FUNCPTRS)
  91 #endif
  92
  93 /* fallback for old uclibc-headers < 1.0.39 */
  94 #ifndef PER_LINUX32_3GB
  95 # define PER_LINUX32_3GB        (PER_LINUX32 | ADDR_LIMIT_3GB)
  96 #endif
  97
  98 #define ALL_PERSONALITIES \
  99     X(PER_LINUX) \
 100     X(PER_LINUX_32BIT) \
 101     X(PER_LINUX_FDPIC) \
 102     X(PER_SVR4) \
 103     X(PER_SVR3) \
 104     X(PER_SCOSVR3) \
 105     X(PER_OSR5) \
 106     X(PER_WYSEV386) \
 107     X(PER_ISCR4) \
 108     X(PER_BSD) \
 109     X(PER_SUNOS) \
 110     X(PER_XENIX) \
 111     X(PER_LINUX32) \
 112     X(PER_LINUX32_3GB) \
 113     X(PER_IRIX32) \
 114     X(PER_IRIXN32) \
 115     X(PER_IRIX64) \
 116     X(PER_RISCOS) \
 117     X(PER_SOLARIS) \
 118     X(PER_UW7) \
 119     X(PER_OSF4) \
 120     X(PER_HPUX) \
 121
 122
 123 #define ALL_OPTIONS \
 124     X(UNAME26) \
 125     X(ADDR_NO_RANDOMIZE) \
 126     X(FDPIC_FUNCPTRS) \
 127     X(MMAP_PAGE_ZERO) \
 128     X(ADDR_COMPAT_LAYOUT) \
 129     X(READ_IMPLIES_EXEC) \
 130     X(ADDR_LIMIT_32BIT) \
 131     X(SHORT_INODE) \
 132     X(WHOLE_SECONDS) \
 133     X(STICKY_TIMEOUTS) \
 134     X(ADDR_LIMIT_3GB) \
 135
 136
 137 struct arch_domain {
 138         int             perval;         /* PER_* */
 139         const char      *target_arch;
 140         const char      *result_arch;
 141 };
 142
 143
 144 static void __attribute__((__noreturn__)) usage(int archwrapper)
 145 {
 146         fputs(USAGE_HEADER, stdout);
 147         if (!archwrapper)
 148                 fprintf(stdout, _(" %s [<arch>] [options] [<program> [<argument>...]]\n"), program_invocation_short_name);
 149         else
 150                 fprintf(stdout, _(" %s [options] [<program> [<argument>...]]\n"), program_invocation_short_name);
 151
 152         fputs(USAGE_SEPARATOR, stdout);
 153         fputs(_("Change the reported architecture and set personality flags.\n"), stdout);
 154
 155         fputs(USAGE_OPTIONS, stdout);
 156         fputs(_(" -B, --32bit              turns on ADDR_LIMIT_32BIT\n"), stdout);
 157         fputs(_(" -F, --fdpic-funcptrs     makes function pointers point to descriptors\n"), stdout);
 158         fputs(_(" -I, --short-inode        turns on SHORT_INODE\n"), stdout);
 159         fputs(_(" -L, --addr-compat-layout changes the way virtual memory is allocated\n"), stdout);
 160         fputs(_(" -R, --addr-no-randomize  disables randomization of the virtual address space\n"), stdout);
 161         fputs(_(" -S, --whole-seconds      turns on WHOLE_SECONDS\n"), stdout);
 162         fputs(_(" -T, --sticky-timeouts    turns on STICKY_TIMEOUTS\n"), stdout);
 163         fputs(_(" -X, --read-implies-exec  turns on READ_IMPLIES_EXEC\n"), stdout);
 164         fputs(_(" -Z, --mmap-page-zero     turns on MMAP_PAGE_ZERO\n"), stdout);
 165         fputs(_(" -3, --3gb                limits the used address space to a maximum of 3 GB\n"), stdout);
 166         fputs(_("     --4gb                ignored (for backward compatibility only)\n"), stdout);
 167         fputs(_("     --uname-2.6          turns on UNAME26\n"), stdout);
 168         fputs(_(" -v, --verbose            say what options are being switched on\n"), stdout);
 169
 170         if (!archwrapper) {
 171                 fputs(_("     --list               list settable architectures, and exit\n"), stdout);
 172                 fputs(_("     --show[=personality] show current or specific personality and exit\n"), stdout);
 173                 fputs(_(" -p, --pid=PID            show the personality of the process using with --show\n"), stdout);
 174         }
 175
 176         fputs(USAGE_SEPARATOR, stdout);
 177         fprintf(stdout, USAGE_HELP_OPTIONS(26));
 178         fprintf(stdout, USAGE_MAN_TAIL("setarch(8)"));
 179
 180         exit(EXIT_SUCCESS);
 181 }
 182
 183 /*
 184  * Returns inilialized list of all available execution domains.
 185  */
 186 static struct arch_domain *init_arch_domains(void)
 187 {
 188         static struct utsname un;
 189         size_t i;
 190
 191         static struct arch_domain transitions[] =
 192         {
 193                 {UNAME26,       "uname26",      NULL},
 194                 {PER_LINUX32,   "linux32",      NULL},
 195                 {PER_LINUX,     "linux64",      NULL},
 196 #if defined(__powerpc__) || defined(__powerpc64__)
 197 # ifdef __BIG_ENDIAN__
 198                 {PER_LINUX32,   "ppc32",        "ppc"},
 199                 {PER_LINUX32,   "ppc",          "ppc"},
 200                 {PER_LINUX,     "ppc64",        "ppc64"},
 201                 {PER_LINUX,     "ppc64pseries", "ppc64"},
 202                 {PER_LINUX,     "ppc64iseries", "ppc64"},
 203 # else
 204                 {PER_LINUX32,   "ppc32",        "ppcle"},
 205                 {PER_LINUX32,   "ppc",          "ppcle"},
 206                 {PER_LINUX32,   "ppc32le",      "ppcle"},
 207                 {PER_LINUX32,   "ppcle",        "ppcle"},
 208                 {PER_LINUX,     "ppc64le",      "ppc64le"},
 209 # endif
 210 #endif
 211 #if defined(__x86_64__) || defined(__i386__) || defined(__ia64__)
 212                 {PER_LINUX32,   "i386",         "i386"},
 213                 {PER_LINUX32,   "i486",         "i386"},
 214                 {PER_LINUX32,   "i586",         "i386"},
 215                 {PER_LINUX32,   "i686",         "i386"},
 216                 {PER_LINUX32,   "athlon",       "i386"},
 217 #endif
 218 #if defined(__x86_64__) || defined(__i386__)
 219                 {PER_LINUX,     "x86_64",       "x86_64"},
 220 #endif
 221 #if defined(__ia64__) || defined(__i386__)
 222                 {PER_LINUX,     "ia64",         "ia64"},
 223 #endif
 224 #if defined(__hppa__)
 225                 {PER_LINUX32,   "parisc32",     "parisc"},
 226                 {PER_LINUX32,   "parisc",       "parisc"},
 227                 {PER_LINUX,     "parisc64",     "parisc64"},
 228 #endif
 229 #if defined(__s390x__) || defined(__s390__)
 230                 {PER_LINUX32,   "s390",         "s390"},
 231                 {PER_LINUX,     "s390x",        "s390x"},
 232 #endif
 233 #if defined(__sparc64__) || defined(__sparc__)
 234                 {PER_LINUX32,   "sparc",        "sparc"},
 235                 {PER_LINUX32,   "sparc32bash",  "sparc"},
 236                 {PER_LINUX32,   "sparc32",      "sparc"},
 237                 {PER_LINUX,     "sparc64",      "sparc64"},
 238 #endif
 239 #if defined(__mips64__) || defined(__mips__)
 240                 {PER_LINUX32,   "mips32",       "mips"},
 241                 {PER_LINUX32,   "mips",         "mips"},
 242                 {PER_LINUX,     "mips64",       "mips64"},
 243 #endif
 244 #if defined(__alpha__)
 245                 {PER_LINUX,     "alpha",        "alpha"},
 246                 {PER_LINUX,     "alphaev5",     "alpha"},
 247                 {PER_LINUX,     "alphaev56",    "alpha"},
 248                 {PER_LINUX,     "alphaev6",     "alpha"},
 249                 {PER_LINUX,     "alphaev67",    "alpha"},
 250 #endif
 251 #if defined(__loongarch__)
 252                 {PER_LINUX,     "loongarch",    "loongarch64"},
 253                 {PER_LINUX,     "loongarch64",  "loongarch64"},
 254 #endif
 255 #if defined(__e2k__)
 256                 {PER_LINUX,     "e2k",      "e2k"},
 257                 {PER_LINUX,     "e2kv4",        "e2k"},
 258                 {PER_LINUX,     "e2kv5",        "e2k"},
 259                 {PER_LINUX,     "e2kv6",        "e2k"},
 260                 {PER_LINUX,     "e2k4c",        "e2k"},
 261                 {PER_LINUX,     "e2k8c",        "e2k"},
 262                 {PER_LINUX,     "e2k1cp",       "e2k"},
 263                 {PER_LINUX,     "e2k8c2",       "e2k"},
 264                 {PER_LINUX,     "e2k12c",       "e2k"},
 265                 {PER_LINUX,     "e2k16c",       "e2k"},
 266                 {PER_LINUX,     "e2k2c3",       "e2k"},
 267 #endif
 268 #if defined(__arm__) || defined(__aarch64__)
 269 # ifdef __BIG_ENDIAN__
 270                 {PER_LINUX32,   "armv7b",       "arm"},
 271                 {PER_LINUX32,   "armv8b",       "arm"},
 272 # else
 273                 {PER_LINUX32,   "armv7l",       "arm"},
 274                 {PER_LINUX32,   "armv8l",       "arm"},
 275 # endif
 276                 {PER_LINUX32,   "armh",         "arm"},
 277                 {PER_LINUX32,   "arm",          "arm"},
 278                 {PER_LINUX,     "arm64",        "aarch64"},
 279                 {PER_LINUX,     "aarch64",      "aarch64"},
 280 #endif
 281 #if defined(__riscv)
 282                 {PER_LINUX32,   "riscv32",      "riscv32"},
 283                 {PER_LINUX32,   "rv32", "riscv32"},
 284                 {PER_LINUX,     "riscv64",      "riscv64"},
 285                 {PER_LINUX,     "rv64", "riscv64"},
 286 #endif
 287                 /* place holder, will be filled up at runtime */
 288                 {-1,            NULL,           NULL},
 289                 {-1,            NULL,           NULL}
 290         };
 291
 292         /* Add the trivial transition {PER_LINUX, machine, machine} if no
 293          * such target_arch is hardcoded yet.  */
 294         uname(&un);
 295         for (i = 0; transitions[i].perval >= 0; i++)
 296                 if (!strcmp(un.machine, transitions[i].target_arch))
 297                         break;
 298         if (transitions[i].perval < 0) {
 299                 int wrdsz = sysfs_get_address_bits(NULL);
 300                 if (wrdsz < 0)
 301                         wrdsz = CHAR_BIT * sizeof(void *);
 302                 if (wrdsz == 32 || wrdsz == 64) {
 303                         /* fill up the place holder */
 304                         transitions[i].perval = wrdsz == 32 ? PER_LINUX32 : PER_LINUX;
 305                         transitions[i].target_arch = un.machine;
 306                         transitions[i].result_arch = un.machine;
 307                 }
 308         }
 309
 310         return transitions;
 311 }
 312
 313 /*
 314  * List all execution domains from transitions
 315  */
 316 static void list_arch_domains(struct arch_domain *doms)
 317 {
 318         struct arch_domain *d;
 319
 320         for (d = doms; d->target_arch != NULL; d++)
 321                 printf("%s\n", d->target_arch);
 322 }
 323
 324 static struct arch_domain *get_arch_domain(struct arch_domain *doms, const char *pers)
 325 {
 326         struct arch_domain *d;
 327
 328         for (d = doms; d && d->perval >= 0; d++) {
 329                 if (!strcmp(pers, d->target_arch))
 330                         break;
 331         }
 332
 333         return !d || d->perval < 0 ? NULL : d;
 334 }
 335
 336 static void verify_arch_domain(struct arch_domain *doms, struct arch_domain *target, const char *wanted)
 337 {
 338         struct utsname un;
 339
 340         if (!doms || !target || !target->result_arch)
 341                 return;
 342
 343         uname(&un);
 344
 345         if (!strcmp(un.machine, target->result_arch))
 346                 return;
 347
 348         if (!strcmp(target->result_arch, "i386") ||
 349             !strcmp(target->result_arch, "arm")) {
 350                 struct arch_domain *dom;
 351                 for (dom = doms; dom->target_arch != NULL; dom++) {
 352                         if (!dom->result_arch || strcmp(dom->result_arch, target->result_arch))
 353                                 continue;
 354                         if (!strcmp(dom->target_arch, un.machine))
 355                                 return;
 356                 }
 357         }
 358
 359         errx(EXIT_FAILURE, _("Kernel cannot set architecture to %s"), wanted);
 360 }
 361
 362 static const struct { int value; const char * const name; } all_personalities[] = {
 363 #define X(opt) { .value = opt, .name = #opt },
 364         ALL_PERSONALITIES
 365 #undef X
 366 };
 367
 368 static const struct { int value; const char * const name; } all_options[] = {
 369 #define X(opt) { .value = opt, .name = #opt },
 370         ALL_OPTIONS
 371 #undef X
 372 };
 373
 374 static void show_personality(int pers)
 375 {
 376         int options;
 377         size_t i;
 378
 379         /* Test for exact matches including options */
 380         for (i = 0; i < ARRAY_SIZE(all_personalities); i++) {
 381                 if (pers == all_personalities[i].value) {
 382                         printf("%s\n", all_personalities[i].name);
 383                         return;
 384                 }
 385         }
 386
 387         options = pers & ~PER_MASK;
 388         pers &= PER_MASK;
 389
 390         /* Second test for type-only matches */
 391         for (i = 0; i < ARRAY_SIZE(all_personalities); i++) {
 392                 if (pers == all_personalities[i].value) {
 393                         printf("%s", all_personalities[i].name);
 394                         break;
 395                 }
 396         }
 397
 398         if (i == ARRAY_SIZE(all_personalities))
 399                 printf("0x%02x", pers);
 400
 401         if (options) {
 402                 printf(" (");
 403
 404                 for (i = 0; i < ARRAY_SIZE(all_options); i++) {
 405                         if (options & all_options[i].value) {
 406                                 printf("%s", all_options[i].name);
 407
 408                                 options &= ~all_options[i].value;
 409                                 if (options)
 410                                         printf(" ");
 411                         }
 412                 }
 413                 if (options)
 414                         printf("0x%08x", options);
 415                 printf(")");
 416         }
 417         printf("\n");
 418 }
 419
 420 static void show_current_personality(void)
 421 {
 422         int pers = personality(0xffffffff);
 423         if (pers == -1)
 424                 err(EXIT_FAILURE, _("Can not get current kernel personality"));
 425
 426         show_personality(pers);
 427 }
 428
 429 static void show_process_personality(pid_t pid)
 430 {
 431         int pers;
 432         char *pers_str;
 433
 434         pers_str = pid_get_personality(pid);
 435         if (pers_str == NULL)
 436                 err(EXIT_FAILURE,
 437                     _("Can not get the personality for process(%d)"),
 438                     pid);
 439         pers = str2num_or_err(pers_str, 16,
 440                               _("could not parse personality"),
 441                               0, INT_MAX);
 442         free(pers_str);
 443
 444         show_personality(pers);
 445 }
 446
 447 int main(int argc, char *argv[])
 448 {
 449         const char *arch = NULL;
 450         unsigned long options = 0;
 451         int verbose = 0;
 452         int archwrapper;
 453         int c;
 454         struct arch_domain *doms = NULL, *target = NULL;
 455         unsigned long pers_value = 0;
 456         char *shell = NULL, *shell_arg = NULL;
 457         int do_show = 0;
 458         pid_t target_pid = 0;
 459
 460         /* Options without equivalent short options */
 461         enum {
 462                 OPT_4GB = CHAR_MAX + 1,
 463                 OPT_UNAME26,
 464                 OPT_LIST,
 465                 OPT_SHOW,
 466         };
 467
 468         /* Options --3gb and --4gb are for compatibility with an old
 469          * Debian setarch implementation.  */
 470         static const struct option longopts[] = {
 471                 {"help",                no_argument,            NULL,   'h'},
 472                 {"version",             no_argument,            NULL,   'V'},
 473                 {"verbose",             no_argument,            NULL,   'v'},
 474                 {"addr-no-randomize",   no_argument,            NULL,   'R'},
 475                 {"fdpic-funcptrs",      no_argument,            NULL,   'F'},
 476                 {"mmap-page-zero",      no_argument,            NULL,   'Z'},
 477                 {"addr-compat-layout",  no_argument,            NULL,   'L'},
 478                 {"read-implies-exec",   no_argument,            NULL,   'X'},
 479                 {"32bit",               no_argument,            NULL,   'B'},
 480                 {"short-inode",         no_argument,            NULL,   'I'},
 481                 {"whole-seconds",       no_argument,            NULL,   'S'},
 482                 {"sticky-timeouts",     no_argument,            NULL,   'T'},
 483                 {"3gb",                 no_argument,            NULL,   '3'},
 484                 {"4gb",                 no_argument,            NULL,   OPT_4GB},
 485                 {"uname-2.6",           no_argument,            NULL,   OPT_UNAME26},
 486                 {"list",                no_argument,            NULL,   OPT_LIST},
 487                 {"show",                optional_argument,      NULL,   OPT_SHOW},
 488                 {"pid",                 required_argument,      NULL,   'p'},
 489                 {NULL,                  0,                      NULL,   0}
 490         };
 491
 492         setlocale(LC_ALL, "");
 493         bindtextdomain(PACKAGE, LOCALEDIR);
 494         textdomain(PACKAGE);
 495         close_stdout_atexit();
 496
 497         if (argc < 1) {
 498                 warnx(_("Not enough arguments"));
 499                 errtryhelp(EXIT_FAILURE);
 500         }
 501         archwrapper = strcmp(program_invocation_short_name, "setarch") != 0;
 502         if (archwrapper) {
 503                 arch = program_invocation_short_name;   /* symlinks to setarch */
 504
 505                 /* Don't use ifdef sparc here, we get "Unrecognized architecture"
 506                  * error message later if necessary */
 507                 if (strcmp(arch, "sparc32bash") == 0) {
 508                         shell = "/bin/bash";
 509                         shell_arg = "";
 510                         goto set_arch;
 511                 }
 512         } else {
 513                 if (1 < argc && *argv[1] != '-') {
 514                         arch = argv[1];
 515                         argv[1] = argv[0];      /* for getopt_long() to get the program name */
 516                         argv++;
 517                         argc--;
 518                 }
 519         }
 520
 521         while ((c = getopt_long(argc, argv, "+hVv3BFILRSTXZp:", longopts, NULL)) != -1) {
 522                 switch (c) {
 523                 case 'v':
 524                         verbose = 1;
 525                         break;
 526                 case 'R':
 527                         turn_on(ADDR_NO_RANDOMIZE, options);
 528                         break;
 529                 case 'F':
 530                         turn_on(FDPIC_FUNCPTRS, options);
 531                         break;
 532                 case 'Z':
 533                         turn_on(MMAP_PAGE_ZERO, options);
 534                         break;
 535                 case 'L':
 536                         turn_on(ADDR_COMPAT_LAYOUT, options);
 537                         break;
 538                 case 'X':
 539                         turn_on(READ_IMPLIES_EXEC, options);
 540                         break;
 541                 case 'B':
 542                         turn_on(ADDR_LIMIT_32BIT, options);
 543                         break;
 544                 case 'I':
 545                         turn_on(SHORT_INODE, options);
 546                         break;
 547                 case 'S':
 548                         turn_on(WHOLE_SECONDS, options);
 549                         break;
 550                 case 'T':
 551                         turn_on(STICKY_TIMEOUTS, options);
 552                         break;
 553                 case '3':
 554                         turn_on(ADDR_LIMIT_3GB, options);
 555                         break;
 556                 case OPT_4GB:   /* just ignore this one */
 557                         break;
 558                 case OPT_UNAME26:
 559                         turn_on(UNAME26, options);
 560                         break;
 561                 case OPT_LIST:
 562                         if (!archwrapper) {
 563                                 list_arch_domains(init_arch_domains());
 564                                 return EXIT_SUCCESS;
 565                         } else
 566                                 warnx(_("unrecognized option '--list'"));
 567                         goto error_getopts;
 568                 case 'p':
 569                         if (!archwrapper) {
 570                                 target_pid = strtopid_or_err(optarg, _("invalid PID argument"));
 571                                 if (target_pid <= 0)
 572                                         errx(EXIT_FAILURE, _("out of range value for pid specification: %d"),
 573                                              target_pid);
 574                                 break;
 575                         } else
 576                                 warnx(_("unrecognized option '%s'"), argv[optind - 1]);
 577                         goto error_getopts;
 578                 case OPT_SHOW:
 579                         if (!archwrapper) {
 580                                 if (!optarg) {
 581                                         do_show = 1;
 582                                         break;
 583                                 } else if (strcmp(optarg, "current") == 0)
 584                                         show_current_personality();
 585                                 else
 586                                         show_personality(str2num_or_err(
 587                                                 optarg, 16,
 588                                                 _("could not parse personality"),
 589                                                 0, INT_MAX));
 590                                 return EXIT_SUCCESS;
 591                         } else
 592                                 warnx(_("unrecognized option '--show'"));
 593                         goto error_getopts;
 594
 595 error_getopts:
 596                 default:
 597                         errtryhelp(EXIT_FAILURE);
 598                 case 'h':
 599                         usage(archwrapper);
 600                 case 'V':
 601                         print_version(EXIT_SUCCESS);
 602                 }
 603         }
 604
 605         /* We could not find --pid option though we saw --show option. */
 606         if (do_show) {
 607                 if (target_pid)
 608                         show_process_personality(target_pid);
 609                 else
 610                         show_current_personality();
 611                 return EXIT_SUCCESS;
 612         }
 613         if (target_pid)
 614                 errx(EXIT_FAILURE, _("use -p/--pid option with --show option"));
 615
 616         if (!arch && !options)
 617                 errx(EXIT_FAILURE, _("no architecture argument or personality flags specified"));
 618
 619         argc -= optind;
 620         argv += optind;
 621
 622 set_arch:
 623         /* get execution domain (architecture) */
 624         if (arch) {
 625                 doms = init_arch_domains();
 626                 target = get_arch_domain(doms, arch);
 627
 628                 if (!target)
 629                         errx(EXIT_FAILURE, _("%s: Unrecognized architecture"), arch);
 630                 pers_value = target->perval;
 631         }
 632
 633         /* add personality flags */
 634         pers_value |= options;
 635
 636         /* call kernel */
 637         if (personality(pers_value) < 0) {
 638                 /*
 639                  * Depending on architecture and kernel version, personality
 640                  * syscall is either capable or incapable of returning an error.
 641                  * If the return value is not an error, then it's the previous
 642                  * personality value, which can be an arbitrary value
 643                  * undistinguishable from an error value.
 644                  * To make things clear, a second call is needed.
 645                  */
 646                 if (personality(pers_value) < 0)
 647                         err(EXIT_FAILURE, _("failed to set personality to %s"), arch);
 648         }
 649
 650         /* make sure architecture is set as expected */
 651         if (arch)
 652                 verify_arch_domain(doms, target, arch);
 653
 654         if (!argc) {
 655                 shell = "/bin/sh";
 656                 shell_arg = "-sh";
 657         }
 658         if (verbose) {
 659                 printf(_("Execute command `%s'.\n"), shell ? shell : argv[0]);
 660                 /* flush all output streams before exec */
 661                 fflush(NULL);
 662         }
 663
 664         /* Execute shell */
 665         if (shell) {
 666                 execl(shell, shell_arg, (char *)NULL);
 667                 errexec(shell);
 668         }
 669
 670         /* Execute on command line specified command */
 671         execvp(argv[0], argv);
 672         errexec(argv[0]);
 673 }