toolchain-wrapper.c 15 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553
  1. /**
  2. * Buildroot wrapper for toolchains. This simply executes the real toolchain
  3. * with a number of arguments (sysroot/arch/..) hardcoded, to ensure the
  4. * toolchain uses the correct configuration.
  5. * The hardcoded path arguments are defined relative to the actual location
  6. * of the binary.
  7. *
  8. * (C) 2011 Peter Korsgaard <jacmet@sunsite.dk>
  9. * (C) 2011 Daniel Nyström <daniel.nystrom@timeterminal.se>
  10. * (C) 2012 Arnout Vandecappelle (Essensium/Mind) <arnout@mind.be>
  11. * (C) 2013 Spenser Gilliland <spenser@gillilanding.com>
  12. *
  13. * This file is licensed under the terms of the GNU General Public License
  14. * version 2. This program is licensed "as is" without any warranty of any
  15. * kind, whether express or implied.
  16. */
  17. #define _GNU_SOURCE
  18. #include <stdio.h>
  19. #include <string.h>
  20. #include <limits.h>
  21. #include <unistd.h>
  22. #include <stdlib.h>
  23. #include <errno.h>
  24. #include <time.h>
  25. #include <stdbool.h>
  26. #ifdef BR_CCACHE
  27. static char ccache_path[PATH_MAX];
  28. #endif
  29. static char path[PATH_MAX];
  30. static char sysroot[PATH_MAX];
  31. /* As would be defined by gcc:
  32. * https://gcc.gnu.org/onlinedocs/cpp/Standard-Predefined-Macros.html
  33. * sizeof() on string literals includes the terminating \0. */
  34. static char _time_[sizeof("-D__TIME__=\"HH:MM:SS\"")];
  35. static char _date_[sizeof("-D__DATE__=\"MMM DD YYYY\"")];
  36. /**
  37. * GCC errors out with certain combinations of arguments (examples are
  38. * -mfloat-abi={hard|soft} and -m{little|big}-endian), so we have to ensure
  39. * that we only pass the predefined one to the real compiler if the inverse
  40. * option isn't in the argument list.
  41. * This specifies the worst case number of extra arguments we might pass
  42. * Currently, we may have:
  43. * -mfloat-abi=
  44. * -march=
  45. * -mcpu=
  46. * -D__TIME__=
  47. * -D__DATE__=
  48. * -Wno-builtin-macro-redefined
  49. * -Wl,-z,now
  50. * -Wl,-z,relro
  51. * -fPIE
  52. * -pie
  53. */
  54. #define EXCLUSIVE_ARGS 10
  55. static char *predef_args[] = {
  56. #ifdef BR_CCACHE
  57. ccache_path,
  58. #endif
  59. path,
  60. "--sysroot", sysroot,
  61. #ifdef BR_ABI
  62. "-mabi=" BR_ABI,
  63. #endif
  64. #ifdef BR_NAN
  65. "-mnan=" BR_NAN,
  66. #endif
  67. #ifdef BR_FPU
  68. "-mfpu=" BR_FPU,
  69. #endif
  70. #ifdef BR_SOFTFLOAT
  71. "-msoft-float",
  72. #endif /* BR_SOFTFLOAT */
  73. #ifdef BR_MODE
  74. "-m" BR_MODE,
  75. #endif
  76. #ifdef BR_64
  77. "-m64",
  78. #endif
  79. #ifdef BR_OMIT_LOCK_PREFIX
  80. "-Wa,-momit-lock-prefix=yes",
  81. #endif
  82. #ifdef BR_NO_FUSED_MADD
  83. "-mno-fused-madd",
  84. #endif
  85. #ifdef BR_FP_CONTRACT_OFF
  86. "-ffp-contract=off",
  87. #endif
  88. #ifdef BR_BINFMT_FLAT
  89. "-Wl,-elf2flt",
  90. #endif
  91. #ifdef BR_MIPS_TARGET_LITTLE_ENDIAN
  92. "-EL",
  93. #endif
  94. #if defined(BR_MIPS_TARGET_BIG_ENDIAN) || defined(BR_ARC_TARGET_BIG_ENDIAN)
  95. "-EB",
  96. #endif
  97. #ifdef BR_ADDITIONAL_CFLAGS
  98. BR_ADDITIONAL_CFLAGS
  99. #endif
  100. };
  101. /* A {string,length} tuple, to avoid computing strlen() on constants.
  102. * - str must be a \0-terminated string
  103. * - len does not account for the terminating '\0'
  104. */
  105. struct str_len_s {
  106. const char *str;
  107. size_t len;
  108. };
  109. /* Define a {string,length} tuple. Takes an unquoted constant string as
  110. * parameter. sizeof() on a string literal includes the terminating \0,
  111. * but we don't want to count it.
  112. */
  113. #define STR_LEN(s) { #s, sizeof(#s)-1 }
  114. /* List of paths considered unsafe for cross-compilation.
  115. *
  116. * An unsafe path is one that points to a directory with libraries or
  117. * headers for the build machine, which are not suitable for the target.
  118. */
  119. static const struct str_len_s unsafe_paths[] = {
  120. STR_LEN(/lib),
  121. STR_LEN(/usr/include),
  122. STR_LEN(/usr/lib),
  123. STR_LEN(/usr/local/include),
  124. STR_LEN(/usr/local/lib),
  125. STR_LEN(/usr/X11R6/include),
  126. STR_LEN(/usr/X11R6/lib),
  127. { NULL, 0 },
  128. };
  129. /* Unsafe options are options that specify a potentialy unsafe path,
  130. * that will be checked by check_unsafe_path(), below.
  131. */
  132. static const struct str_len_s unsafe_opts[] = {
  133. STR_LEN(-I),
  134. STR_LEN(-idirafter),
  135. STR_LEN(-iquote),
  136. STR_LEN(-isystem),
  137. STR_LEN(-L),
  138. { NULL, 0 },
  139. };
  140. /* Check if path is unsafe for cross-compilation. Unsafe paths are those
  141. * pointing to the standard native include or library paths.
  142. *
  143. * We print the arguments leading to the failure. For some options, gcc
  144. * accepts the path to be concatenated to the argument (e.g. -I/foo/bar)
  145. * or separated (e.g. -I /foo/bar). In the first case, we need only print
  146. * the argument as it already contains the path (arg_has_path), while in
  147. * the second case we need to print both (!arg_has_path).
  148. *
  149. * If paranoid, exit in error instead of just printing a warning.
  150. */
  151. static void check_unsafe_path(const char *arg,
  152. const char *path,
  153. int paranoid,
  154. int arg_has_path)
  155. {
  156. const struct str_len_s *p;
  157. for (p=unsafe_paths; p->str; p++) {
  158. if (strncmp(path, p->str, p->len))
  159. continue;
  160. fprintf(stderr,
  161. "%s: %s: unsafe header/library path used in cross-compilation: '%s%s%s'\n",
  162. program_invocation_short_name,
  163. paranoid ? "ERROR" : "WARNING",
  164. arg,
  165. arg_has_path ? "" : "' '", /* close single-quote, space, open single-quote */
  166. arg_has_path ? "" : path); /* so that arg and path are properly quoted. */
  167. if (paranoid)
  168. exit(1);
  169. }
  170. }
  171. #ifdef BR_NEED_SOURCE_DATE_EPOCH
  172. /* Returns false if SOURCE_DATE_EPOCH was not defined in the environment.
  173. *
  174. * Returns true if SOURCE_DATE_EPOCH is in the environment and represent
  175. * a valid timestamp, in which case the timestamp is formatted into the
  176. * global variables _date_ and _time_.
  177. *
  178. * Aborts if SOURCE_DATE_EPOCH was set in the environment but did not
  179. * contain a valid timestamp.
  180. *
  181. * Valid values are defined in the spec:
  182. * https://reproducible-builds.org/specs/source-date-epoch/
  183. * but we further restrict them to be positive or null.
  184. */
  185. bool parse_source_date_epoch_from_env(void)
  186. {
  187. char *epoch_env, *endptr;
  188. time_t epoch;
  189. struct tm epoch_tm;
  190. if ((epoch_env = getenv("SOURCE_DATE_EPOCH")) == NULL)
  191. return false;
  192. errno = 0;
  193. epoch = (time_t) strtoll(epoch_env, &endptr, 10);
  194. /* We just need to test if it is incorrect, but we do not
  195. * care why it is incorrect.
  196. */
  197. if ((errno != 0) || !*epoch_env || *endptr || (epoch < 0)) {
  198. fprintf(stderr, "%s: invalid SOURCE_DATE_EPOCH='%s'\n",
  199. program_invocation_short_name,
  200. epoch_env);
  201. exit(1);
  202. }
  203. tzset(); /* For localtime_r(), below. */
  204. if (localtime_r(&epoch, &epoch_tm) == NULL) {
  205. fprintf(stderr, "%s: cannot parse SOURCE_DATE_EPOCH=%s\n",
  206. program_invocation_short_name,
  207. getenv("SOURCE_DATE_EPOCH"));
  208. exit(1);
  209. }
  210. if (!strftime(_time_, sizeof(_time_), "-D__TIME__=\"%T\"", &epoch_tm)) {
  211. fprintf(stderr, "%s: cannot set time from SOURCE_DATE_EPOCH=%s\n",
  212. program_invocation_short_name,
  213. getenv("SOURCE_DATE_EPOCH"));
  214. exit(1);
  215. }
  216. if (!strftime(_date_, sizeof(_date_), "-D__DATE__=\"%b %e %Y\"", &epoch_tm)) {
  217. fprintf(stderr, "%s: cannot set date from SOURCE_DATE_EPOCH=%s\n",
  218. program_invocation_short_name,
  219. getenv("SOURCE_DATE_EPOCH"));
  220. exit(1);
  221. }
  222. return true;
  223. }
  224. #else
  225. bool parse_source_date_epoch_from_env(void)
  226. {
  227. /* The compiler is recent enough to handle SOURCE_DATE_EPOCH itself
  228. * so we do not need to do anything here.
  229. */
  230. return false;
  231. }
  232. #endif
  233. int main(int argc, char **argv)
  234. {
  235. char **args, **cur, **exec_args;
  236. char *relbasedir, *absbasedir;
  237. char *progpath = argv[0];
  238. char *basename;
  239. char *env_debug;
  240. char *paranoid_wrapper;
  241. int paranoid;
  242. int ret, i, count = 0, debug = 0, found_shared = 0;
  243. /* Debug the wrapper to see arguments it was called with.
  244. * If environment variable BR2_DEBUG_WRAPPER is:
  245. * unset, empty, or 0: do not trace
  246. * set to 1 : trace all arguments on a single line
  247. * set to 2 : trace one argument per line
  248. */
  249. if ((env_debug = getenv("BR2_DEBUG_WRAPPER"))) {
  250. debug = atoi(env_debug);
  251. }
  252. if (debug > 0) {
  253. fprintf(stderr, "Toolchain wrapper was called with:");
  254. for (i = 0; i < argc; i++)
  255. fprintf(stderr, "%s'%s'",
  256. (debug == 2) ? "\n " : " ", argv[i]);
  257. fprintf(stderr, "\n");
  258. }
  259. /* Calculate the relative paths */
  260. basename = strrchr(progpath, '/');
  261. if (basename) {
  262. *basename = '\0';
  263. basename++;
  264. relbasedir = malloc(strlen(progpath) + 7);
  265. if (relbasedir == NULL) {
  266. perror(__FILE__ ": malloc");
  267. return 2;
  268. }
  269. sprintf(relbasedir, "%s/..", argv[0]);
  270. absbasedir = realpath(relbasedir, NULL);
  271. } else {
  272. basename = progpath;
  273. absbasedir = malloc(PATH_MAX + 1);
  274. ret = readlink("/proc/self/exe", absbasedir, PATH_MAX);
  275. if (ret < 0) {
  276. perror(__FILE__ ": readlink");
  277. return 2;
  278. }
  279. absbasedir[ret] = '\0';
  280. for (i = ret; i > 0; i--) {
  281. if (absbasedir[i] == '/') {
  282. absbasedir[i] = '\0';
  283. if (++count == 2)
  284. break;
  285. }
  286. }
  287. }
  288. if (absbasedir == NULL) {
  289. perror(__FILE__ ": realpath");
  290. return 2;
  291. }
  292. /* Fill in the relative paths */
  293. #ifdef BR_CROSS_PATH_REL
  294. ret = snprintf(path, sizeof(path), "%s/" BR_CROSS_PATH_REL "/%s" BR_CROSS_PATH_SUFFIX, absbasedir, basename);
  295. #elif defined(BR_CROSS_PATH_ABS)
  296. ret = snprintf(path, sizeof(path), BR_CROSS_PATH_ABS "/%s" BR_CROSS_PATH_SUFFIX, basename);
  297. #else
  298. ret = snprintf(path, sizeof(path), "%s/bin/%s" BR_CROSS_PATH_SUFFIX, absbasedir, basename);
  299. #endif
  300. if (ret >= sizeof(path)) {
  301. perror(__FILE__ ": overflow");
  302. return 3;
  303. }
  304. #ifdef BR_CCACHE
  305. ret = snprintf(ccache_path, sizeof(ccache_path), "%s/bin/ccache", absbasedir);
  306. if (ret >= sizeof(ccache_path)) {
  307. perror(__FILE__ ": overflow");
  308. return 3;
  309. }
  310. #endif
  311. ret = snprintf(sysroot, sizeof(sysroot), "%s/" BR_SYSROOT, absbasedir);
  312. if (ret >= sizeof(sysroot)) {
  313. perror(__FILE__ ": overflow");
  314. return 3;
  315. }
  316. cur = args = malloc(sizeof(predef_args) +
  317. (sizeof(char *) * (argc + EXCLUSIVE_ARGS)));
  318. if (args == NULL) {
  319. perror(__FILE__ ": malloc");
  320. return 2;
  321. }
  322. /* start with predefined args */
  323. memcpy(cur, predef_args, sizeof(predef_args));
  324. cur += sizeof(predef_args) / sizeof(predef_args[0]);
  325. #ifdef BR_FLOAT_ABI
  326. /* add float abi if not overridden in args */
  327. for (i = 1; i < argc; i++) {
  328. if (!strncmp(argv[i], "-mfloat-abi=", strlen("-mfloat-abi=")) ||
  329. !strcmp(argv[i], "-msoft-float") ||
  330. !strcmp(argv[i], "-mhard-float"))
  331. break;
  332. }
  333. if (i == argc)
  334. *cur++ = "-mfloat-abi=" BR_FLOAT_ABI;
  335. #endif
  336. #ifdef BR_FP32_MODE
  337. /* add fp32 mode if soft-float is not args or hard-float overrides soft-float */
  338. int add_fp32_mode = 1;
  339. for (i = 1; i < argc; i++) {
  340. if (!strcmp(argv[i], "-msoft-float"))
  341. add_fp32_mode = 0;
  342. else if (!strcmp(argv[i], "-mhard-float"))
  343. add_fp32_mode = 1;
  344. }
  345. if (add_fp32_mode == 1)
  346. *cur++ = "-mfp" BR_FP32_MODE;
  347. #endif
  348. #if defined(BR_ARCH) || \
  349. defined(BR_CPU)
  350. /* Add our -march/cpu flags, but only if none of
  351. * -march/mtune/mcpu are already specified on the commandline
  352. */
  353. for (i = 1; i < argc; i++) {
  354. if (!strncmp(argv[i], "-march=", strlen("-march=")) ||
  355. !strncmp(argv[i], "-mtune=", strlen("-mtune=")) ||
  356. !strncmp(argv[i], "-mcpu=", strlen("-mcpu=" )))
  357. break;
  358. }
  359. if (i == argc) {
  360. #ifdef BR_ARCH
  361. *cur++ = "-march=" BR_ARCH;
  362. #endif
  363. #ifdef BR_CPU
  364. *cur++ = "-mcpu=" BR_CPU;
  365. #endif
  366. }
  367. #endif /* ARCH || CPU */
  368. if (parse_source_date_epoch_from_env()) {
  369. *cur++ = _time_;
  370. *cur++ = _date_;
  371. /* This has existed since gcc-4.4.0. */
  372. *cur++ = "-Wno-builtin-macro-redefined";
  373. }
  374. #ifdef BR2_PIC_PIE
  375. /* Patterned after Fedora/Gentoo hardening approaches.
  376. * https://fedoraproject.org/wiki/Changes/Harden_All_Packages
  377. * https://wiki.gentoo.org/wiki/Hardened/Toolchain#Position_Independent_Executables_.28PIEs.29
  378. *
  379. * A few checks are added to allow disabling of PIE
  380. * 1) -fno-pie and -no-pie are used by other distros to disable PIE in
  381. * cases where the compiler enables it by default. The logic below
  382. * maintains that behavior.
  383. * Ref: https://wiki.ubuntu.com/SecurityTeam/PIE
  384. * 2) A check for -fno-PIE has been used in older Linux Kernel builds
  385. * in a similar way to -fno-pie or -no-pie.
  386. * 3) A check is added for Kernel and U-boot defines
  387. * (-D__KERNEL__ and -D__UBOOT__).
  388. */
  389. for (i = 1; i < argc; i++) {
  390. /* Apply all incompatible link flag and disable checks first */
  391. if (!strcmp(argv[i], "-r") ||
  392. !strcmp(argv[i], "-Wl,-r") ||
  393. !strcmp(argv[i], "-static") ||
  394. !strcmp(argv[i], "-D__KERNEL__") ||
  395. !strcmp(argv[i], "-D__UBOOT__") ||
  396. !strcmp(argv[i], "-fno-pie") ||
  397. !strcmp(argv[i], "-fno-PIE") ||
  398. !strcmp(argv[i], "-no-pie"))
  399. break;
  400. /* Record that shared was present which disables -pie but don't
  401. * break out of loop as a check needs to occur that possibly
  402. * still allows -fPIE to be set
  403. */
  404. if (!strcmp(argv[i], "-shared"))
  405. found_shared = 1;
  406. }
  407. if (i == argc) {
  408. /* Compile and link condition checking have been kept split
  409. * between these two loops, as there maybe already are valid
  410. * compile flags set for position independence. In that case
  411. * the wrapper just adds the -pie for link.
  412. */
  413. for (i = 1; i < argc; i++) {
  414. if (!strcmp(argv[i], "-fpie") ||
  415. !strcmp(argv[i], "-fPIE") ||
  416. !strcmp(argv[i], "-fpic") ||
  417. !strcmp(argv[i], "-fPIC"))
  418. break;
  419. }
  420. /* Both args below can be set at compile/link time
  421. * and are ignored correctly when not used
  422. */
  423. if (i == argc)
  424. *cur++ = "-fPIE";
  425. if (!found_shared)
  426. *cur++ = "-pie";
  427. }
  428. #endif
  429. /* Are we building the Linux Kernel or U-Boot? */
  430. for (i = 1; i < argc; i++) {
  431. if (!strcmp(argv[i], "-D__KERNEL__") ||
  432. !strcmp(argv[i], "-D__UBOOT__"))
  433. break;
  434. }
  435. if (i == argc) {
  436. /* https://wiki.gentoo.org/wiki/Hardened/Toolchain#Mark_Read-Only_Appropriate_Sections */
  437. #ifdef BR2_RELRO_PARTIAL
  438. *cur++ = "-Wl,-z,relro";
  439. #endif
  440. #ifdef BR2_RELRO_FULL
  441. *cur++ = "-Wl,-z,now";
  442. *cur++ = "-Wl,-z,relro";
  443. #endif
  444. }
  445. paranoid_wrapper = getenv("BR_COMPILER_PARANOID_UNSAFE_PATH");
  446. if (paranoid_wrapper && strlen(paranoid_wrapper) > 0)
  447. paranoid = 1;
  448. else
  449. paranoid = 0;
  450. /* Check for unsafe library and header paths */
  451. for (i = 1; i < argc; i++) {
  452. const struct str_len_s *opt;
  453. for (opt=unsafe_opts; opt->str; opt++ ) {
  454. /* Skip any non-unsafe option. */
  455. if (strncmp(argv[i], opt->str, opt->len))
  456. continue;
  457. /* Handle both cases:
  458. * - path is a separate argument,
  459. * - path is concatenated with option.
  460. */
  461. if (argv[i][opt->len] == '\0') {
  462. i++;
  463. if (i == argc)
  464. break;
  465. check_unsafe_path(argv[i-1], argv[i], paranoid, 0);
  466. } else
  467. check_unsafe_path(argv[i], argv[i] + opt->len, paranoid, 1);
  468. }
  469. }
  470. /* append forward args */
  471. memcpy(cur, &argv[1], sizeof(char *) * (argc - 1));
  472. cur += argc - 1;
  473. /* finish with NULL termination */
  474. *cur = NULL;
  475. exec_args = args;
  476. #ifdef BR_CCACHE
  477. if (getenv("BR_NO_CCACHE"))
  478. /* Skip the ccache call */
  479. exec_args++;
  480. #endif
  481. /* Debug the wrapper to see final arguments passed to the real compiler. */
  482. if (debug > 0) {
  483. fprintf(stderr, "Toolchain wrapper executing:");
  484. #ifdef BR_CCACHE_HASH
  485. fprintf(stderr, "%sCCACHE_COMPILERCHECK='string:" BR_CCACHE_HASH "'",
  486. (debug == 2) ? "\n " : " ");
  487. #endif
  488. #ifdef BR_CCACHE_BASEDIR
  489. fprintf(stderr, "%sCCACHE_BASEDIR='" BR_CCACHE_BASEDIR "'",
  490. (debug == 2) ? "\n " : " ");
  491. #endif
  492. for (i = 0; exec_args[i]; i++)
  493. fprintf(stderr, "%s'%s'",
  494. (debug == 2) ? "\n " : " ", exec_args[i]);
  495. fprintf(stderr, "\n");
  496. }
  497. #ifdef BR_CCACHE_HASH
  498. /* Allow compilercheck to be overridden through the environment */
  499. if (setenv("CCACHE_COMPILERCHECK", "string:" BR_CCACHE_HASH, 0)) {
  500. perror(__FILE__ ": Failed to set CCACHE_COMPILERCHECK");
  501. return 3;
  502. }
  503. #endif
  504. #ifdef BR_CCACHE_BASEDIR
  505. /* Allow compilercheck to be overridden through the environment */
  506. if (setenv("CCACHE_BASEDIR", BR_CCACHE_BASEDIR, 0)) {
  507. perror(__FILE__ ": Failed to set CCACHE_BASEDIR");
  508. return 3;
  509. }
  510. #endif
  511. if (execv(exec_args[0], exec_args))
  512. perror(path);
  513. free(args);
  514. return 2;
  515. }