toolchain-wrapper.c 15 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532
  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. { NULL, 0 },
  126. };
  127. /* Unsafe options are options that specify a potentialy unsafe path,
  128. * that will be checked by check_unsafe_path(), below.
  129. */
  130. static const struct str_len_s unsafe_opts[] = {
  131. STR_LEN(-I),
  132. STR_LEN(-idirafter),
  133. STR_LEN(-iquote),
  134. STR_LEN(-isystem),
  135. STR_LEN(-L),
  136. { NULL, 0 },
  137. };
  138. /* Check if path is unsafe for cross-compilation. Unsafe paths are those
  139. * pointing to the standard native include or library paths.
  140. *
  141. * We print the arguments leading to the failure. For some options, gcc
  142. * accepts the path to be concatenated to the argument (e.g. -I/foo/bar)
  143. * or separated (e.g. -I /foo/bar). In the first case, we need only print
  144. * the argument as it already contains the path (arg_has_path), while in
  145. * the second case we need to print both (!arg_has_path).
  146. *
  147. * If paranoid, exit in error instead of just printing a warning.
  148. */
  149. static void check_unsafe_path(const char *arg,
  150. const char *path,
  151. int paranoid,
  152. int arg_has_path)
  153. {
  154. const struct str_len_s *p;
  155. for (p=unsafe_paths; p->str; p++) {
  156. if (strncmp(path, p->str, p->len))
  157. continue;
  158. fprintf(stderr,
  159. "%s: %s: unsafe header/library path used in cross-compilation: '%s%s%s'\n",
  160. program_invocation_short_name,
  161. paranoid ? "ERROR" : "WARNING",
  162. arg,
  163. arg_has_path ? "" : "' '", /* close single-quote, space, open single-quote */
  164. arg_has_path ? "" : path); /* so that arg and path are properly quoted. */
  165. if (paranoid)
  166. exit(1);
  167. }
  168. }
  169. /* Returns false if SOURCE_DATE_EPOCH was not defined in the environment.
  170. *
  171. * Returns true if SOURCE_DATE_EPOCH is in the environment and represent
  172. * a valid timestamp, in which case the timestamp is formatted into the
  173. * global variables _date_ and _time_.
  174. *
  175. * Aborts if SOURCE_DATE_EPOCH was set in the environment but did not
  176. * contain a valid timestamp.
  177. *
  178. * Valid values are defined in the spec:
  179. * https://reproducible-builds.org/specs/source-date-epoch/
  180. * but we further restrict them to be positive or null.
  181. */
  182. bool parse_source_date_epoch_from_env(void)
  183. {
  184. char *epoch_env, *endptr;
  185. time_t epoch;
  186. struct tm epoch_tm;
  187. if ((epoch_env = getenv("SOURCE_DATE_EPOCH")) == NULL)
  188. return false;
  189. errno = 0;
  190. epoch = (time_t) strtoll(epoch_env, &endptr, 10);
  191. /* We just need to test if it is incorrect, but we do not
  192. * care why it is incorrect.
  193. */
  194. if ((errno != 0) || !*epoch_env || *endptr || (epoch < 0)) {
  195. fprintf(stderr, "%s: invalid SOURCE_DATE_EPOCH='%s'\n",
  196. program_invocation_short_name,
  197. epoch_env);
  198. exit(1);
  199. }
  200. tzset(); /* For localtime_r(), below. */
  201. if (localtime_r(&epoch, &epoch_tm) == NULL) {
  202. fprintf(stderr, "%s: cannot parse SOURCE_DATE_EPOCH=%s\n",
  203. program_invocation_short_name,
  204. getenv("SOURCE_DATE_EPOCH"));
  205. exit(1);
  206. }
  207. if (!strftime(_time_, sizeof(_time_), "-D__TIME__=\"%T\"", &epoch_tm)) {
  208. fprintf(stderr, "%s: cannot set time from SOURCE_DATE_EPOCH=%s\n",
  209. program_invocation_short_name,
  210. getenv("SOURCE_DATE_EPOCH"));
  211. exit(1);
  212. }
  213. if (!strftime(_date_, sizeof(_date_), "-D__DATE__=\"%b %e %Y\"", &epoch_tm)) {
  214. fprintf(stderr, "%s: cannot set date from SOURCE_DATE_EPOCH=%s\n",
  215. program_invocation_short_name,
  216. getenv("SOURCE_DATE_EPOCH"));
  217. exit(1);
  218. }
  219. return true;
  220. }
  221. int main(int argc, char **argv)
  222. {
  223. char **args, **cur, **exec_args;
  224. char *relbasedir, *absbasedir;
  225. char *progpath = argv[0];
  226. char *basename;
  227. char *env_debug;
  228. char *paranoid_wrapper;
  229. int paranoid;
  230. int ret, i, count = 0, debug, found_shared = 0;
  231. /* Calculate the relative paths */
  232. basename = strrchr(progpath, '/');
  233. if (basename) {
  234. *basename = '\0';
  235. basename++;
  236. relbasedir = malloc(strlen(progpath) + 7);
  237. if (relbasedir == NULL) {
  238. perror(__FILE__ ": malloc");
  239. return 2;
  240. }
  241. sprintf(relbasedir, "%s/..", argv[0]);
  242. absbasedir = realpath(relbasedir, NULL);
  243. } else {
  244. basename = progpath;
  245. absbasedir = malloc(PATH_MAX + 1);
  246. ret = readlink("/proc/self/exe", absbasedir, PATH_MAX);
  247. if (ret < 0) {
  248. perror(__FILE__ ": readlink");
  249. return 2;
  250. }
  251. absbasedir[ret] = '\0';
  252. for (i = ret; i > 0; i--) {
  253. if (absbasedir[i] == '/') {
  254. absbasedir[i] = '\0';
  255. if (++count == 2)
  256. break;
  257. }
  258. }
  259. }
  260. if (absbasedir == NULL) {
  261. perror(__FILE__ ": realpath");
  262. return 2;
  263. }
  264. /* Fill in the relative paths */
  265. #ifdef BR_CROSS_PATH_REL
  266. ret = snprintf(path, sizeof(path), "%s/" BR_CROSS_PATH_REL "/%s" BR_CROSS_PATH_SUFFIX, absbasedir, basename);
  267. #elif defined(BR_CROSS_PATH_ABS)
  268. ret = snprintf(path, sizeof(path), BR_CROSS_PATH_ABS "/%s" BR_CROSS_PATH_SUFFIX, basename);
  269. #else
  270. ret = snprintf(path, sizeof(path), "%s/bin/%s" BR_CROSS_PATH_SUFFIX, absbasedir, basename);
  271. #endif
  272. if (ret >= sizeof(path)) {
  273. perror(__FILE__ ": overflow");
  274. return 3;
  275. }
  276. #ifdef BR_CCACHE
  277. ret = snprintf(ccache_path, sizeof(ccache_path), "%s/bin/ccache", absbasedir);
  278. if (ret >= sizeof(ccache_path)) {
  279. perror(__FILE__ ": overflow");
  280. return 3;
  281. }
  282. #endif
  283. ret = snprintf(sysroot, sizeof(sysroot), "%s/" BR_SYSROOT, absbasedir);
  284. if (ret >= sizeof(sysroot)) {
  285. perror(__FILE__ ": overflow");
  286. return 3;
  287. }
  288. cur = args = malloc(sizeof(predef_args) +
  289. (sizeof(char *) * (argc + EXCLUSIVE_ARGS)));
  290. if (args == NULL) {
  291. perror(__FILE__ ": malloc");
  292. return 2;
  293. }
  294. /* start with predefined args */
  295. memcpy(cur, predef_args, sizeof(predef_args));
  296. cur += sizeof(predef_args) / sizeof(predef_args[0]);
  297. #ifdef BR_FLOAT_ABI
  298. /* add float abi if not overridden in args */
  299. for (i = 1; i < argc; i++) {
  300. if (!strncmp(argv[i], "-mfloat-abi=", strlen("-mfloat-abi=")) ||
  301. !strcmp(argv[i], "-msoft-float") ||
  302. !strcmp(argv[i], "-mhard-float"))
  303. break;
  304. }
  305. if (i == argc)
  306. *cur++ = "-mfloat-abi=" BR_FLOAT_ABI;
  307. #endif
  308. #ifdef BR_FP32_MODE
  309. /* add fp32 mode if soft-float is not args or hard-float overrides soft-float */
  310. int add_fp32_mode = 1;
  311. for (i = 1; i < argc; i++) {
  312. if (!strcmp(argv[i], "-msoft-float"))
  313. add_fp32_mode = 0;
  314. else if (!strcmp(argv[i], "-mhard-float"))
  315. add_fp32_mode = 1;
  316. }
  317. if (add_fp32_mode == 1)
  318. *cur++ = "-mfp" BR_FP32_MODE;
  319. #endif
  320. #if defined(BR_ARCH) || \
  321. defined(BR_CPU)
  322. /* Add our -march/cpu flags, but only if none of
  323. * -march/mtune/mcpu are already specified on the commandline
  324. */
  325. for (i = 1; i < argc; i++) {
  326. if (!strncmp(argv[i], "-march=", strlen("-march=")) ||
  327. !strncmp(argv[i], "-mtune=", strlen("-mtune=")) ||
  328. !strncmp(argv[i], "-mcpu=", strlen("-mcpu=" )))
  329. break;
  330. }
  331. if (i == argc) {
  332. #ifdef BR_ARCH
  333. *cur++ = "-march=" BR_ARCH;
  334. #endif
  335. #ifdef BR_CPU
  336. *cur++ = "-mcpu=" BR_CPU;
  337. #endif
  338. }
  339. #endif /* ARCH || CPU */
  340. if (parse_source_date_epoch_from_env()) {
  341. *cur++ = _time_;
  342. *cur++ = _date_;
  343. /* This has existed since gcc-4.4.0. */
  344. *cur++ = "-Wno-builtin-macro-redefined";
  345. }
  346. #ifdef BR2_RELRO_FULL
  347. /* Patterned after Fedora/Gentoo hardening approaches.
  348. * https://fedoraproject.org/wiki/Changes/Harden_All_Packages
  349. * https://wiki.gentoo.org/wiki/Hardened/Toolchain#Position_Independent_Executables_.28PIEs.29
  350. *
  351. * A few checks are added to allow disabling of PIE
  352. * 1) -fno-pie and -no-pie are used by other distros to disable PIE in
  353. * cases where the compiler enables it by default. The logic below
  354. * maintains that behavior.
  355. * Ref: https://wiki.ubuntu.com/SecurityTeam/PIE
  356. * 2) A check for -fno-PIE has been used in older Linux Kernel builds
  357. * in a similar way to -fno-pie or -no-pie.
  358. * 3) A check is added for Kernel and U-boot defines
  359. * (-D__KERNEL__ and -D__UBOOT__).
  360. */
  361. for (i = 1; i < argc; i++) {
  362. /* Apply all incompatible link flag and disable checks first */
  363. if (!strcmp(argv[i], "-r") ||
  364. !strcmp(argv[i], "-Wl,-r") ||
  365. !strcmp(argv[i], "-static") ||
  366. !strcmp(argv[i], "-D__KERNEL__") ||
  367. !strcmp(argv[i], "-D__UBOOT__") ||
  368. !strcmp(argv[i], "-fno-pie") ||
  369. !strcmp(argv[i], "-fno-PIE") ||
  370. !strcmp(argv[i], "-no-pie"))
  371. break;
  372. /* Record that shared was present which disables -pie but don't
  373. * break out of loop as a check needs to occur that possibly
  374. * still allows -fPIE to be set
  375. */
  376. if (!strcmp(argv[i], "-shared"))
  377. found_shared = 1;
  378. }
  379. if (i == argc) {
  380. /* Compile and link condition checking have been kept split
  381. * between these two loops, as there maybe already are valid
  382. * compile flags set for position independence. In that case
  383. * the wrapper just adds the -pie for link.
  384. */
  385. for (i = 1; i < argc; i++) {
  386. if (!strcmp(argv[i], "-fpie") ||
  387. !strcmp(argv[i], "-fPIE") ||
  388. !strcmp(argv[i], "-fpic") ||
  389. !strcmp(argv[i], "-fPIC"))
  390. break;
  391. }
  392. /* Both args below can be set at compile/link time
  393. * and are ignored correctly when not used
  394. */
  395. if(i == argc)
  396. *cur++ = "-fPIE";
  397. if (!found_shared)
  398. *cur++ = "-pie";
  399. }
  400. #endif
  401. /* Are we building the Linux Kernel or U-Boot? */
  402. for (i = 1; i < argc; i++) {
  403. if (!strcmp(argv[i], "-D__KERNEL__") ||
  404. !strcmp(argv[i], "-D__UBOOT__"))
  405. break;
  406. }
  407. if (i == argc) {
  408. /* https://wiki.gentoo.org/wiki/Hardened/Toolchain#Mark_Read-Only_Appropriate_Sections */
  409. #ifdef BR2_RELRO_PARTIAL
  410. *cur++ = "-Wl,-z,relro";
  411. #endif
  412. #ifdef BR2_RELRO_FULL
  413. *cur++ = "-Wl,-z,now";
  414. *cur++ = "-Wl,-z,relro";
  415. #endif
  416. }
  417. paranoid_wrapper = getenv("BR_COMPILER_PARANOID_UNSAFE_PATH");
  418. if (paranoid_wrapper && strlen(paranoid_wrapper) > 0)
  419. paranoid = 1;
  420. else
  421. paranoid = 0;
  422. /* Check for unsafe library and header paths */
  423. for (i = 1; i < argc; i++) {
  424. const struct str_len_s *opt;
  425. for (opt=unsafe_opts; opt->str; opt++ ) {
  426. /* Skip any non-unsafe option. */
  427. if (strncmp(argv[i], opt->str, opt->len))
  428. continue;
  429. /* Handle both cases:
  430. * - path is a separate argument,
  431. * - path is concatenated with option.
  432. */
  433. if (argv[i][opt->len] == '\0') {
  434. i++;
  435. if (i == argc)
  436. break;
  437. check_unsafe_path(argv[i-1], argv[i], paranoid, 0);
  438. } else
  439. check_unsafe_path(argv[i], argv[i] + opt->len, paranoid, 1);
  440. }
  441. }
  442. /* append forward args */
  443. memcpy(cur, &argv[1], sizeof(char *) * (argc - 1));
  444. cur += argc - 1;
  445. /* finish with NULL termination */
  446. *cur = NULL;
  447. exec_args = args;
  448. #ifdef BR_CCACHE
  449. if (getenv("BR_NO_CCACHE"))
  450. /* Skip the ccache call */
  451. exec_args++;
  452. #endif
  453. /* Debug the wrapper to see actual arguments passed to
  454. * the compiler:
  455. * unset, empty, or 0: do not trace
  456. * set to 1 : trace all arguments on a single line
  457. * set to 2 : trace one argument per line
  458. */
  459. if ((env_debug = getenv("BR2_DEBUG_WRAPPER"))) {
  460. debug = atoi(env_debug);
  461. if (debug > 0) {
  462. fprintf(stderr, "Toolchain wrapper executing:");
  463. #ifdef BR_CCACHE_HASH
  464. fprintf(stderr, "%sCCACHE_COMPILERCHECK='string:" BR_CCACHE_HASH "'",
  465. (debug == 2) ? "\n " : " ");
  466. #endif
  467. #ifdef BR_CCACHE_BASEDIR
  468. fprintf(stderr, "%sCCACHE_BASEDIR='" BR_CCACHE_BASEDIR "'",
  469. (debug == 2) ? "\n " : " ");
  470. #endif
  471. for (i = 0; exec_args[i]; i++)
  472. fprintf(stderr, "%s'%s'",
  473. (debug == 2) ? "\n " : " ", exec_args[i]);
  474. fprintf(stderr, "\n");
  475. }
  476. }
  477. #ifdef BR_CCACHE_HASH
  478. /* Allow compilercheck to be overridden through the environment */
  479. if (setenv("CCACHE_COMPILERCHECK", "string:" BR_CCACHE_HASH, 0)) {
  480. perror(__FILE__ ": Failed to set CCACHE_COMPILERCHECK");
  481. return 3;
  482. }
  483. #endif
  484. #ifdef BR_CCACHE_BASEDIR
  485. /* Allow compilercheck to be overridden through the environment */
  486. if (setenv("CCACHE_BASEDIR", BR_CCACHE_BASEDIR, 0)) {
  487. perror(__FILE__ ": Failed to set CCACHE_BASEDIR");
  488. return 3;
  489. }
  490. #endif
  491. if (execv(exec_args[0], exec_args))
  492. perror(path);
  493. free(args);
  494. return 2;
  495. }