2 * Copyright (C) 2003-2007 Red Hat, Inc.
4 * This file is part of util-linux.
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.
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.
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)
23 * based on ideas from the ppc32 util by Guy Streeter (2002-01), based on the
24 * sparc32 util by Jakub Jelinek (1998, 1999)
27 #include <sys/personality.h>
34 #include <sys/utsname.h>
37 #include "closestream.h"
41 #ifndef HAVE_PERSONALITY
43 # define personality(pers) ((long)syscall(SYS_personality, pers))
46 #define turn_on(_flag, _opts) \
50 printf(_("Switching on %s.\n"), #_flag); \
54 # define UNAME26 0x0020000
56 #ifndef ADDR_NO_RANDOMIZE
57 # define ADDR_NO_RANDOMIZE 0x0040000
59 #ifndef FDPIC_FUNCPTRS
60 # define FDPIC_FUNCPTRS 0x0080000
62 #ifndef MMAP_PAGE_ZERO
63 # define MMAP_PAGE_ZERO 0x0100000
65 #ifndef ADDR_COMPAT_LAYOUT
66 # define ADDR_COMPAT_LAYOUT 0x0200000
68 #ifndef READ_IMPLIES_EXEC
69 # define READ_IMPLIES_EXEC 0x0400000
71 #ifndef ADDR_LIMIT_32BIT
72 # define ADDR_LIMIT_32BIT 0x0800000
75 # define SHORT_INODE 0x1000000
78 # define WHOLE_SECONDS 0x2000000
80 #ifndef STICKY_TIMEOUTS
81 # define STICKY_TIMEOUTS 0x4000000
83 #ifndef ADDR_LIMIT_3GB
84 # define ADDR_LIMIT_3GB 0x8000000
87 /* fallback for old glibc-headers 2.17 */
88 #ifndef PER_LINUX_FDPIC
89 # define PER_LINUX_FDPIC (PER_LINUX | FDPIC_FUNCPTRS)
92 #define ALL_PERSONALITIES \
117 #define ALL_OPTIONS \
119 X(ADDR_NO_RANDOMIZE) \
122 X(ADDR_COMPAT_LAYOUT) \
123 X(READ_IMPLIES_EXEC) \
124 X(ADDR_LIMIT_32BIT) \
132 int perval
; /* PER_* */
133 const char *target_arch
;
134 const char *result_arch
;
138 static void __attribute__((__noreturn__
)) usage(int archwrapper
)
140 fputs(USAGE_HEADER
, stdout
);
142 fprintf(stdout
, _(" %s [<arch>] [options] [<program> [<argument>...]]\n"), program_invocation_short_name
);
144 fprintf(stdout
, _(" %s [options] [<program> [<argument>...]]\n"), program_invocation_short_name
);
146 fputs(USAGE_SEPARATOR
, stdout
);
147 fputs(_("Change the reported architecture and set personality flags.\n"), stdout
);
149 fputs(USAGE_OPTIONS
, stdout
);
150 fputs(_(" -B, --32bit turns on ADDR_LIMIT_32BIT\n"), stdout
);
151 fputs(_(" -F, --fdpic-funcptrs makes function pointers point to descriptors\n"), stdout
);
152 fputs(_(" -I, --short-inode turns on SHORT_INODE\n"), stdout
);
153 fputs(_(" -L, --addr-compat-layout changes the way virtual memory is allocated\n"), stdout
);
154 fputs(_(" -R, --addr-no-randomize disables randomization of the virtual address space\n"), stdout
);
155 fputs(_(" -S, --whole-seconds turns on WHOLE_SECONDS\n"), stdout
);
156 fputs(_(" -T, --sticky-timeouts turns on STICKY_TIMEOUTS\n"), stdout
);
157 fputs(_(" -X, --read-implies-exec turns on READ_IMPLIES_EXEC\n"), stdout
);
158 fputs(_(" -Z, --mmap-page-zero turns on MMAP_PAGE_ZERO\n"), stdout
);
159 fputs(_(" -3, --3gb limits the used address space to a maximum of 3 GB\n"), stdout
);
160 fputs(_(" --4gb ignored (for backward compatibility only)\n"), stdout
);
161 fputs(_(" --uname-2.6 turns on UNAME26\n"), stdout
);
162 fputs(_(" -v, --verbose say what options are being switched on\n"), stdout
);
165 fputs(_(" --list list settable architectures, and exit\n"), stdout
);
166 fputs(_(" --show[=personality] show current or specific personality and exit\n"), stdout
);
169 fputs(USAGE_SEPARATOR
, stdout
);
170 fprintf(stdout
, USAGE_HELP_OPTIONS(26));
171 fprintf(stdout
, USAGE_MAN_TAIL("setarch(8)"));
177 * Returns inilialized list of all available execution domains.
179 static struct arch_domain
*init_arch_domains(void)
181 static struct utsname un
;
184 static struct arch_domain transitions
[] =
186 {UNAME26
, "uname26", NULL
},
187 {PER_LINUX32
, "linux32", NULL
},
188 {PER_LINUX
, "linux64", NULL
},
189 #if defined(__powerpc__) || defined(__powerpc64__)
190 # ifdef __BIG_ENDIAN__
191 {PER_LINUX32
, "ppc32", "ppc"},
192 {PER_LINUX32
, "ppc", "ppc"},
193 {PER_LINUX
, "ppc64", "ppc64"},
194 {PER_LINUX
, "ppc64pseries", "ppc64"},
195 {PER_LINUX
, "ppc64iseries", "ppc64"},
197 {PER_LINUX32
, "ppc32", "ppcle"},
198 {PER_LINUX32
, "ppc", "ppcle"},
199 {PER_LINUX32
, "ppc32le", "ppcle"},
200 {PER_LINUX32
, "ppcle", "ppcle"},
201 {PER_LINUX
, "ppc64le", "ppc64le"},
204 #if defined(__x86_64__) || defined(__i386__) || defined(__ia64__)
205 {PER_LINUX32
, "i386", "i386"},
206 {PER_LINUX32
, "i486", "i386"},
207 {PER_LINUX32
, "i586", "i386"},
208 {PER_LINUX32
, "i686", "i386"},
209 {PER_LINUX32
, "athlon", "i386"},
211 #if defined(__x86_64__) || defined(__i386__)
212 {PER_LINUX
, "x86_64", "x86_64"},
214 #if defined(__ia64__) || defined(__i386__)
215 {PER_LINUX
, "ia64", "ia64"},
217 #if defined(__hppa__)
218 {PER_LINUX32
, "parisc32", "parisc"},
219 {PER_LINUX32
, "parisc", "parisc"},
220 {PER_LINUX
, "parisc64", "parisc64"},
222 #if defined(__s390x__) || defined(__s390__)
223 {PER_LINUX32
, "s390", "s390"},
224 {PER_LINUX
, "s390x", "s390x"},
226 #if defined(__sparc64__) || defined(__sparc__)
227 {PER_LINUX32
, "sparc", "sparc"},
228 {PER_LINUX32
, "sparc32bash", "sparc"},
229 {PER_LINUX32
, "sparc32", "sparc"},
230 {PER_LINUX
, "sparc64", "sparc64"},
232 #if defined(__mips64__) || defined(__mips__)
233 {PER_LINUX32
, "mips32", "mips"},
234 {PER_LINUX32
, "mips", "mips"},
235 {PER_LINUX
, "mips64", "mips64"},
237 #if defined(__alpha__)
238 {PER_LINUX
, "alpha", "alpha"},
239 {PER_LINUX
, "alphaev5", "alpha"},
240 {PER_LINUX
, "alphaev56", "alpha"},
241 {PER_LINUX
, "alphaev6", "alpha"},
242 {PER_LINUX
, "alphaev67", "alpha"},
244 #if defined(__loongarch__)
245 {PER_LINUX
, "loongarch", "loongarch64"},
246 {PER_LINUX
, "loongarch64", "loongarch64"},
249 {PER_LINUX
, "e2k", "e2k"},
250 {PER_LINUX
, "e2kv4", "e2k"},
251 {PER_LINUX
, "e2kv5", "e2k"},
252 {PER_LINUX
, "e2kv6", "e2k"},
253 {PER_LINUX
, "e2k4c", "e2k"},
254 {PER_LINUX
, "e2k8c", "e2k"},
255 {PER_LINUX
, "e2k1cp", "e2k"},
256 {PER_LINUX
, "e2k8c2", "e2k"},
257 {PER_LINUX
, "e2k12c", "e2k"},
258 {PER_LINUX
, "e2k16c", "e2k"},
259 {PER_LINUX
, "e2k2c3", "e2k"},
261 #if defined(__arm__) || defined(__aarch64__)
262 # ifdef __BIG_ENDIAN__
263 {PER_LINUX32
, "armv7b", "arm"},
264 {PER_LINUX32
, "armv8b", "arm"},
266 {PER_LINUX32
, "armv7l", "arm"},
267 {PER_LINUX32
, "armv8l", "arm"},
269 {PER_LINUX32
, "armh", "arm"},
270 {PER_LINUX32
, "arm", "arm"},
271 {PER_LINUX
, "arm64", "aarch64"},
272 {PER_LINUX
, "aarch64", "aarch64"},
275 {PER_LINUX32
, "riscv32", "riscv32"},
276 {PER_LINUX32
, "rv32", "riscv32"},
277 {PER_LINUX
, "riscv64", "riscv64"},
278 {PER_LINUX
, "rv64", "riscv64"},
280 /* place holder, will be filled up at runtime */
285 /* Add the trivial transition {PER_LINUX, machine, machine} if no
286 * such target_arch is hardcoded yet. */
288 for (i
= 0; transitions
[i
].perval
>= 0; i
++)
289 if (!strcmp(un
.machine
, transitions
[i
].target_arch
))
291 if (transitions
[i
].perval
< 0) {
292 int wrdsz
= sysfs_get_address_bits(NULL
);
294 wrdsz
= CHAR_BIT
* sizeof(void *);
295 if (wrdsz
== 32 || wrdsz
== 64) {
296 /* fill up the place holder */
297 transitions
[i
].perval
= wrdsz
== 32 ? PER_LINUX32
: PER_LINUX
;
298 transitions
[i
].target_arch
= un
.machine
;
299 transitions
[i
].result_arch
= un
.machine
;
307 * List all execution domains from transitions
309 static void list_arch_domains(struct arch_domain
*doms
)
311 struct arch_domain
*d
;
313 for (d
= doms
; d
->target_arch
!= NULL
; d
++)
314 printf("%s\n", d
->target_arch
);
317 static struct arch_domain
*get_arch_domain(struct arch_domain
*doms
, const char *pers
)
319 struct arch_domain
*d
;
321 for (d
= doms
; d
&& d
->perval
>= 0; d
++) {
322 if (!strcmp(pers
, d
->target_arch
))
326 return !d
|| d
->perval
< 0 ? NULL
: d
;
329 static void verify_arch_domain(struct arch_domain
*doms
, struct arch_domain
*target
, const char *wanted
)
333 if (!doms
|| !target
|| !target
->result_arch
)
338 if (!strcmp(un
.machine
, target
->result_arch
))
341 if (!strcmp(target
->result_arch
, "i386") ||
342 !strcmp(target
->result_arch
, "arm")) {
343 struct arch_domain
*dom
;
344 for (dom
= doms
; dom
->target_arch
!= NULL
; dom
++) {
345 if (!dom
->result_arch
|| strcmp(dom
->result_arch
, target
->result_arch
))
347 if (!strcmp(dom
->target_arch
, un
.machine
))
352 errx(EXIT_FAILURE
, _("Kernel cannot set architecture to %s"), wanted
);
355 static const struct { int value
; const char * const name
; } all_personalities
[] = {
356 #define X(opt) { .value = opt, .name = #opt },
361 static const struct { int value
; const char * const name
; } all_options
[] = {
362 #define X(opt) { .value = opt, .name = #opt },
367 static void show_personality(int pers
)
372 /* Test for exact matches including options */
373 for (i
= 0; i
< ARRAY_SIZE(all_personalities
); i
++) {
374 if (pers
== all_personalities
[i
].value
) {
375 printf("%s\n", all_personalities
[i
].name
);
380 options
= pers
& ~PER_MASK
;
383 /* Second test for type-only matches */
384 for (i
= 0; i
< ARRAY_SIZE(all_personalities
); i
++) {
385 if (pers
== all_personalities
[i
].value
) {
386 printf("%s", all_personalities
[i
].name
);
391 if (i
== ARRAY_SIZE(all_personalities
))
392 printf("0x%02x", pers
);
397 for (i
= 0; i
< ARRAY_SIZE(all_options
); i
++) {
398 if (options
& all_options
[i
].value
) {
399 printf("%s", all_options
[i
].name
);
401 options
&= ~all_options
[i
].value
;
407 printf("0x%08x", options
);
413 static void show_current_personality(void)
415 int pers
= personality(0xffffffff);
417 err(EXIT_FAILURE
, _("Can not get current kernel personality"));
419 show_personality(pers
);
422 int main(int argc
, char *argv
[])
424 const char *arch
= NULL
;
425 unsigned long options
= 0;
429 struct arch_domain
*doms
= NULL
, *target
= NULL
;
430 unsigned long pers_value
= 0;
431 char *shell
= NULL
, *shell_arg
= NULL
;
433 /* Options without equivalent short options */
435 OPT_4GB
= CHAR_MAX
+ 1,
441 /* Options --3gb and --4gb are for compatibility with an old
442 * Debian setarch implementation. */
443 static const struct option longopts
[] = {
444 {"help", no_argument
, NULL
, 'h'},
445 {"version", no_argument
, NULL
, 'V'},
446 {"verbose", no_argument
, NULL
, 'v'},
447 {"addr-no-randomize", no_argument
, NULL
, 'R'},
448 {"fdpic-funcptrs", no_argument
, NULL
, 'F'},
449 {"mmap-page-zero", no_argument
, NULL
, 'Z'},
450 {"addr-compat-layout", no_argument
, NULL
, 'L'},
451 {"read-implies-exec", no_argument
, NULL
, 'X'},
452 {"32bit", no_argument
, NULL
, 'B'},
453 {"short-inode", no_argument
, NULL
, 'I'},
454 {"whole-seconds", no_argument
, NULL
, 'S'},
455 {"sticky-timeouts", no_argument
, NULL
, 'T'},
456 {"3gb", no_argument
, NULL
, '3'},
457 {"4gb", no_argument
, NULL
, OPT_4GB
},
458 {"uname-2.6", no_argument
, NULL
, OPT_UNAME26
},
459 {"list", no_argument
, NULL
, OPT_LIST
},
460 {"show", optional_argument
, NULL
, OPT_SHOW
},
464 setlocale(LC_ALL
, "");
465 bindtextdomain(PACKAGE
, LOCALEDIR
);
467 close_stdout_atexit();
470 warnx(_("Not enough arguments"));
471 errtryhelp(EXIT_FAILURE
);
473 archwrapper
= strcmp(program_invocation_short_name
, "setarch") != 0;
475 arch
= program_invocation_short_name
; /* symlinks to setarch */
477 /* Don't use ifdef sparc here, we get "Unrecognized architecture"
478 * error message later if necessary */
479 if (strcmp(arch
, "sparc32bash") == 0) {
485 if (1 < argc
&& *argv
[1] != '-') {
487 argv
[1] = argv
[0]; /* for getopt_long() to get the program name */
493 while ((c
= getopt_long(argc
, argv
, "+hVv3BFILRSTXZ", longopts
, NULL
)) != -1) {
499 turn_on(ADDR_NO_RANDOMIZE
, options
);
502 turn_on(FDPIC_FUNCPTRS
, options
);
505 turn_on(MMAP_PAGE_ZERO
, options
);
508 turn_on(ADDR_COMPAT_LAYOUT
, options
);
511 turn_on(READ_IMPLIES_EXEC
, options
);
514 turn_on(ADDR_LIMIT_32BIT
, options
);
517 turn_on(SHORT_INODE
, options
);
520 turn_on(WHOLE_SECONDS
, options
);
523 turn_on(STICKY_TIMEOUTS
, options
);
526 turn_on(ADDR_LIMIT_3GB
, options
);
528 case OPT_4GB
: /* just ignore this one */
531 turn_on(UNAME26
, options
);
535 list_arch_domains(init_arch_domains());
538 warnx(_("unrecognized option '--list'"));
542 if (!optarg
|| strcmp(optarg
, "current") == 0)
543 show_current_personality();
545 show_personality(str2num_or_err(
547 _("could not parse personality"),
551 warnx(_("unrecognized option '--show'"));
556 errtryhelp(EXIT_FAILURE
);
560 print_version(EXIT_SUCCESS
);
564 if (!arch
&& !options
)
565 errx(EXIT_FAILURE
, _("no architecture argument or personality flags specified"));
571 /* get execution domain (architecture) */
573 doms
= init_arch_domains();
574 target
= get_arch_domain(doms
, arch
);
577 errx(EXIT_FAILURE
, _("%s: Unrecognized architecture"), arch
);
578 pers_value
= target
->perval
;
581 /* add personality flags */
582 pers_value
|= options
;
585 if (personality(pers_value
) < 0) {
587 * Depending on architecture and kernel version, personality
588 * syscall is either capable or incapable of returning an error.
589 * If the return value is not an error, then it's the previous
590 * personality value, which can be an arbitrary value
591 * undistinguishable from an error value.
592 * To make things clear, a second call is needed.
594 if (personality(pers_value
) < 0)
595 err(EXIT_FAILURE
, _("failed to set personality to %s"), arch
);
598 /* make sure architecture is set as expected */
600 verify_arch_domain(doms
, target
, arch
);
607 printf(_("Execute command `%s'.\n"), shell
? shell
: argv
[0]);
608 /* flush all output streams before exec */
614 execl(shell
, shell_arg
, (char *)NULL
);
618 /* Execute on command line specified command */
619 execvp(argv
[0], argv
);