db_main.c 16 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508
  1. /* -*- mode:c; c-file-style:"k&r"; c-basic-offset: 4; tab-width:4; indent-tabs-mode:nil; mode:auto-fill; fill-column:78; -*- */
  2. /* vim: set ts=4 sw=4 et tw=78 fo=cqt wm=0: */
  3. /* Copyright (C) 2014 Stony Brook University
  4. This file is part of Graphene Library OS.
  5. Graphene Library OS is free software: you can redistribute it and/or
  6. modify it under the terms of the GNU Lesser General Public License
  7. as published by the Free Software Foundation, either version 3 of the
  8. License, or (at your option) any later version.
  9. Graphene Library OS is distributed in the hope that it will be useful,
  10. but WITHOUT ANY WARRANTY; without even the implied warranty of
  11. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  12. GNU Lesser General Public License for more details.
  13. You should have received a copy of the GNU Lesser General Public License
  14. along with this program. If not, see <http://www.gnu.org/licenses/>. */
  15. /*
  16. * db_main.c
  17. *
  18. * This file contains the main function of the PAL loader, which loads and
  19. * processes environment, arguments and manifest.
  20. */
  21. #include "pal_defs.h"
  22. #include "pal.h"
  23. #include "pal_internal.h"
  24. #include "pal_debug.h"
  25. #include "pal_error.h"
  26. #include "api.h"
  27. #include <sysdeps/generic/ldsodefs.h>
  28. #include <elf/elf.h>
  29. PAL_CONTROL __pal_control;
  30. PAL_CONTROL * pal_control_addr (void)
  31. {
  32. return &__pal_control;
  33. }
  34. struct pal_internal_state pal_state;
  35. static void load_libraries (void)
  36. {
  37. /* we will not make any assumption for where the libraries are loaded */
  38. char cfgbuf[CONFIG_MAX];
  39. ssize_t len, ret = 0;
  40. /* loader.preload:
  41. any other libraries to preload. The can be multiple URIs,
  42. seperated by commas */
  43. len = get_config(pal_state.root_config, "loader.preload", cfgbuf,
  44. CONFIG_MAX);
  45. if (len <= 0)
  46. return;
  47. char * c = cfgbuf, * library_name = c;
  48. for (;; c++)
  49. if (*c == ',' || !(*c)) {
  50. if (c > library_name) {
  51. #if PROFILING == 1
  52. unsigned long before_load_library = _DkSystemTimeQuery();
  53. #endif
  54. *c = 0;
  55. if ((ret = load_elf_object(library_name, OBJECT_PRELOAD)) < 0)
  56. init_fail(-ret, "Unable to load preload library");
  57. #if PROFILING == 1
  58. pal_state.linking_time +=
  59. _DkSystemTimeQuery() - before_load_library;
  60. #endif
  61. }
  62. if (c == cfgbuf + len)
  63. break;
  64. library_name = c + 1;
  65. }
  66. }
  67. static void read_environments (const char *** envpp)
  68. {
  69. struct config_store * store = pal_state.root_config;
  70. const char ** envp = *envpp;
  71. char * cfgbuf;
  72. /* loader.env.*: rewriting host environment variables */
  73. struct setenv {
  74. const char * str;
  75. int len, idx;
  76. } * setenvs = NULL;
  77. int nsetenvs = 0;
  78. if (!pal_state.root_config)
  79. return;
  80. ssize_t cfgsize = get_config_entries_size(store, "loader.env");
  81. if (cfgsize < 0)
  82. return;
  83. cfgbuf = malloc(cfgsize);
  84. assert(cfgbuf);
  85. nsetenvs = get_config_entries(store, "loader.env", cfgbuf, cfgsize);
  86. if (nsetenvs <= 0) {
  87. free(cfgbuf);
  88. return;
  89. }
  90. setenvs = __alloca(sizeof(struct setenv) * nsetenvs);
  91. char * cfg = cfgbuf;
  92. for (int i = 0 ; i < nsetenvs ; i++) {
  93. size_t len = strlen(cfg);
  94. char * str = __alloca(len + 1);
  95. setenvs[i].str = str;
  96. setenvs[i].len = len;
  97. setenvs[i].idx = -1;
  98. memcpy(str, cfg, len + 1);
  99. cfg += len + 1;
  100. }
  101. int nenvs = 0, noverwrite = 0;
  102. for (const char ** e = envp ; *e ; e++, nenvs++)
  103. for (int i = 0 ; i < nsetenvs ; i++)
  104. if (!memcmp(setenvs[i].str, *e, setenvs[i].len) &&
  105. (*e)[setenvs[i].len] == '=') {
  106. setenvs[i].idx = nenvs;
  107. noverwrite++;
  108. break;
  109. }
  110. /* TODO: This code appears to rely on the memory buffer being zero-
  111. * initialized, so we use calloc here to get zeroed memory. We should
  112. * audit this code to verify that it's correct. */
  113. const char ** new_envp =
  114. calloc((nenvs + nsetenvs - noverwrite + 1), sizeof(const char *));
  115. memcpy(new_envp, envp, sizeof(const char *) * nenvs);
  116. envp = new_envp;
  117. char key[CONFIG_MAX] = "loader.env.";
  118. int prefix_len = static_strlen("loader.env.");
  119. const char ** ptr;
  120. free(cfgbuf);
  121. cfgbuf = __alloca(sizeof(char) * CONFIG_MAX);
  122. for (int i = 0 ; i < nsetenvs ; i++) {
  123. const char * str = setenvs[i].str;
  124. int len = setenvs[i].len;
  125. int idx = setenvs[i].idx;
  126. ssize_t bytes;
  127. ptr = &envp[(idx == -1) ? nenvs++ : idx];
  128. memcpy(key + prefix_len, str, len + 1);
  129. if ((bytes = get_config(store, key, cfgbuf, CONFIG_MAX)) > 0) {
  130. char * e = malloc(len + bytes + 2);
  131. memcpy(e, str, len);
  132. e[len] = '=';
  133. memcpy(e + len + 1, cfgbuf, bytes + 1);
  134. *ptr = e;
  135. } else {
  136. char * e = malloc(len + 2);
  137. memcpy(e, str, len);
  138. e[len] = '=';
  139. e[len + 1] = 0;
  140. *ptr = e;
  141. }
  142. }
  143. *envpp = envp;
  144. }
  145. static void set_debug_type (void)
  146. {
  147. char cfgbuf[CONFIG_MAX];
  148. ssize_t ret = 0;
  149. if (!pal_state.root_config)
  150. return;
  151. ret = get_config(pal_state.root_config, "loader.debug_type",
  152. cfgbuf, CONFIG_MAX);
  153. if (ret <= 0)
  154. return;
  155. PAL_HANDLE handle = NULL;
  156. if (strcmp_static(cfgbuf, "inline")) {
  157. ret = _DkStreamOpen(&handle, "dev:tty", PAL_ACCESS_RDWR, 0, 0, 0);
  158. goto out;
  159. }
  160. if (strcmp_static(cfgbuf, "file")) {
  161. ret = get_config(pal_state.root_config, "loader.debug_file",
  162. cfgbuf, CONFIG_MAX);
  163. if (ret <= 0)
  164. init_fail(PAL_ERROR_INVAL, "debug file not specified");
  165. ret = _DkStreamOpen(&handle, cfgbuf,
  166. PAL_ACCESS_RDWR,
  167. PAL_SHARE_OWNER_R|PAL_SHARE_OWNER_W,
  168. PAL_CREAT_TRY, 0);
  169. goto out;
  170. }
  171. if (strcmp_static(cfgbuf, "none"))
  172. goto out;
  173. init_fail(PAL_ERROR_INVAL, "unknown debug type");
  174. out:
  175. if (ret < 0)
  176. init_fail(-ret, "cannot open debug stream");
  177. __pal_control.debug_stream = handle;
  178. }
  179. static int loader_filter (const char * key, int len)
  180. {
  181. /* try to do this as fast as possible */
  182. return (key[0] == 'l' && key[1] == 'o' && key[2] == 'a' && key[3] == 'd' &&
  183. key[4] == 'e' && key[5] == 'r' && key[6] == '.') ? 0 : 1;
  184. }
  185. void start_execution (const char * first_argument, const char ** arguments,
  186. const char ** environments);
  187. /* 'pal_main' must be called by the host-specific bootloader */
  188. void pal_main (
  189. PAL_NUM instance_id, /* current instance id */
  190. PAL_HANDLE manifest_handle, /* manifest handle if opened */
  191. PAL_HANDLE exec_handle, /* executable handle if opened */
  192. PAL_PTR exec_loaded_addr, /* executable addr if loaded */
  193. PAL_HANDLE parent_process, /* parent process if it's a child */
  194. PAL_HANDLE first_thread, /* first thread handle */
  195. PAL_STR * arguments, /* application arguments */
  196. PAL_STR * environments /* environment variables */
  197. )
  198. {
  199. bool is_parent = (parent_process == NULL);
  200. #if PROFILING == 1
  201. __pal_control.host_specific_startup_time =
  202. _DkSystemTimeQuery() - pal_state.start_time;
  203. #endif
  204. pal_state.instance_id = instance_id;
  205. pal_state.pagesize = _DkGetPagesize();
  206. pal_state.alloc_align = _DkGetAllocationAlignment();
  207. pal_state.alloc_shift = pal_state.alloc_align - 1;
  208. pal_state.alloc_mask = ~pal_state.alloc_shift;
  209. init_slab_mgr(pal_state.alloc_align);
  210. pal_state.parent_process = parent_process;
  211. char uri_buf[URI_MAX];
  212. char * manifest_uri = NULL, * exec_uri = NULL;
  213. ssize_t ret;
  214. if (exec_handle) {
  215. ret = _DkStreamGetName(exec_handle, uri_buf, URI_MAX);
  216. if (ret < 0)
  217. init_fail(-ret, "cannot get executable name");
  218. exec_uri = remalloc(uri_buf, ret + 1);
  219. }
  220. if (manifest_handle) {
  221. ret = _DkStreamGetName(manifest_handle, uri_buf, URI_MAX);
  222. if (ret < 0)
  223. init_fail(-ret, "cannot get manifest name");
  224. manifest_uri = remalloc(uri_buf, ret + 1);
  225. goto has_manifest;
  226. }
  227. if (!exec_handle)
  228. init_fail(PAL_ERROR_INVAL, "Must have manifest or executable");
  229. #if PROFILING == 1
  230. unsigned long before_find_manifest = _DkSystemTimeQuery();
  231. #endif
  232. /* The rule is to only find the manifest in the current directory */
  233. /* try open "<execname>.manifest" */
  234. ret = get_base_name(exec_uri, uri_buf, URI_MAX);
  235. strcpy_static(uri_buf + ret, ".manifest", URI_MAX - ret);
  236. ret = _DkStreamOpen(&manifest_handle, uri_buf, PAL_ACCESS_RDONLY, 0, 0, 0);
  237. if (!ret)
  238. goto has_manifest;
  239. /* try open "file:manifest" */
  240. manifest_uri = "file:manifest";
  241. ret = _DkStreamOpen(&manifest_handle, manifest_uri, PAL_ACCESS_RDONLY,
  242. 0, 0, 0);
  243. if (!ret)
  244. goto has_manifest;
  245. #if PROFILING == 1
  246. pal_state.manifest_loading_time +=
  247. _DkSystemTimeQuery() - before_find_manifest;
  248. #endif
  249. /* well, there is no manifest file, leave it alone */
  250. printf("Can't fine any manifest, will run without one.\n");
  251. has_manifest:
  252. /* load manifest if there is one */
  253. if (!pal_state.root_config && manifest_handle) {
  254. #if PROFILING == 1
  255. unsigned long before_load_manifest = _DkSystemTimeQuery();
  256. #endif
  257. PAL_STREAM_ATTR attr;
  258. ret = _DkStreamAttributesQuerybyHandle(manifest_handle, &attr);
  259. if (ret < 0)
  260. init_fail(-ret, "cannot open manifest file");
  261. void * cfg_addr = NULL;
  262. int cfg_size = attr.pending_size;
  263. ret = _DkStreamMap(manifest_handle, &cfg_addr,
  264. PAL_PROT_READ, 0,
  265. ALLOC_ALIGNUP(cfg_size));
  266. if (ret < 0)
  267. init_fail(-ret, "cannot open manifest file");
  268. struct config_store * root_config = malloc(sizeof(struct config_store));
  269. root_config->raw_data = cfg_addr;
  270. root_config->raw_size = cfg_size;
  271. root_config->malloc = malloc;
  272. root_config->free = free;
  273. const char * errstring = NULL;
  274. if ((ret = read_config(root_config, loader_filter, &errstring)) < 0)
  275. init_fail(-ret, errstring);
  276. pal_state.root_config = root_config;
  277. #if PROFILING == 1
  278. pal_state.manifest_loading_time +=
  279. _DkSystemTimeQuery() - before_load_manifest;
  280. #endif
  281. }
  282. /* if there is no executable, try to find one in the manifest */
  283. if (!exec_handle && pal_state.root_config) {
  284. ret = get_config(pal_state.root_config, "loader.exec",
  285. uri_buf, URI_MAX);
  286. if (ret > 0) {
  287. exec_uri = remalloc(uri_buf, ret + 1);
  288. ret = _DkStreamOpen(&exec_handle, exec_uri, PAL_ACCESS_RDONLY,
  289. 0, 0, 0);
  290. if (ret < 0)
  291. init_fail(-ret, "cannot open executable");
  292. }
  293. }
  294. /* If we still don't have an exec in the manifest, but we have a manifest
  295. * try implicitly from the manifest name */
  296. if ((!exec_handle) && manifest_uri) {
  297. size_t manifest_strlen = strlen(manifest_uri);
  298. size_t exec_strlen = manifest_strlen - 9;
  299. int success = 0;
  300. // Try .manifest
  301. if (strcmp_static(&manifest_uri[exec_strlen], ".manifest")) {
  302. success = 1;
  303. } else {
  304. exec_strlen -= 4;
  305. if (strcmp_static(&manifest_uri[exec_strlen], ".manifest.sgx")) {
  306. success = 1;
  307. }
  308. }
  309. if (success) {
  310. exec_uri = malloc(exec_strlen + 1);
  311. if (!exec_uri)
  312. init_fail(-PAL_ERROR_NOMEM, "Cannot allocate URI buf");
  313. memcpy (exec_uri, manifest_uri, exec_strlen);
  314. exec_uri[exec_strlen] = '\0';
  315. ret = _DkStreamOpen(&exec_handle, exec_uri, PAL_ACCESS_RDONLY,
  316. 0, 0, 0);
  317. // DEP 3/20/17: There are cases where we want to let
  318. // the PAL start up without a main executable. Don't
  319. // die here, just free the exec_uri buffer.
  320. if (ret < 0) {
  321. free(exec_uri);
  322. exec_uri = NULL;
  323. }
  324. }
  325. }
  326. /* must be a ELF */
  327. if (exec_handle && check_elf_object(exec_handle) < 0)
  328. init_fail(PAL_ERROR_INVAL, "executable is not a ELF binary");
  329. pal_state.manifest = manifest_uri;
  330. pal_state.manifest_handle = manifest_handle;
  331. pal_state.exec = exec_uri;
  332. pal_state.exec_handle = exec_handle;
  333. const char * first_argument =
  334. (is_parent && exec_uri) ? exec_uri : *arguments;
  335. arguments++;
  336. if (pal_state.root_config) {
  337. char cfgbuf[CONFIG_MAX];
  338. ret = get_config(pal_state.root_config, "loader.execname", cfgbuf,
  339. CONFIG_MAX);
  340. if (ret > 0)
  341. first_argument = remalloc(cfgbuf, ret + 1);
  342. }
  343. read_environments(&environments);
  344. if (pal_state.root_config)
  345. load_libraries();
  346. if (exec_handle) {
  347. #if PROFILING == 1
  348. unsigned long before_load_exec = _DkSystemTimeQuery();
  349. #endif
  350. if (exec_loaded_addr) {
  351. ret = add_elf_object(exec_loaded_addr, exec_handle, OBJECT_EXEC);
  352. } else {
  353. ret = load_elf_object_by_handle(exec_handle, OBJECT_EXEC);
  354. }
  355. if (ret < 0)
  356. init_fail(ret, PAL_STRERROR(ret));
  357. #if PROFILING == 1
  358. pal_state.linking_time += _DkSystemTimeQuery() - before_load_exec;
  359. #endif
  360. }
  361. #if PROFILING == 1
  362. unsigned long before_tail = _DkSystemTimeQuery();
  363. #endif
  364. set_debug_type();
  365. __pal_control.host_type = XSTRINGIFY(HOST_TYPE);
  366. __pal_control.process_id = _DkGetProcessId();
  367. __pal_control.host_id = _DkGetHostId();
  368. __pal_control.manifest_handle = manifest_handle;
  369. __pal_control.executable = exec_uri;
  370. __pal_control.parent_process = parent_process;
  371. __pal_control.first_thread = first_thread;
  372. _DkGetAvailableUserAddressRange(&__pal_control.user_address.start,
  373. &__pal_control.user_address.end);
  374. __pal_control.pagesize = pal_state.pagesize;
  375. __pal_control.alloc_align = pal_state.alloc_align;
  376. __pal_control.broadcast_stream = _DkBroadcastStreamOpen();
  377. _DkGetCPUInfo(&__pal_control.cpu_info);
  378. __pal_control.mem_info.mem_total = _DkMemoryQuota();
  379. #if PROFILING == 1
  380. pal_state.tail_startup_time += _DkSystemTimeQuery() - before_tail;
  381. __pal_control.relocation_time = pal_state.relocation_time;
  382. __pal_control.linking_time = pal_state.linking_time;
  383. __pal_control.manifest_loading_time
  384. = pal_state.manifest_loading_time;
  385. __pal_control.allocation_time = pal_state.slab_time;
  386. __pal_control.child_creation_time = is_parent ? 0 : pal_state.start_time -
  387. pal_state.process_create_time;
  388. #endif
  389. /* Now we will start the execution */
  390. start_execution(first_argument, arguments, environments);
  391. /* We wish we will never reached here */
  392. init_fail(PAL_ERROR_DENIED, "unexpected termination");
  393. }
  394. void write_log (int nstrs, ...)
  395. {
  396. const char ** strs = __alloca(sizeof(const char *) * nstrs);
  397. int len = 0;
  398. va_list ap;
  399. va_start(ap, nstrs);
  400. for (int i = 0 ; i < nstrs ; i++) {
  401. strs[i] = va_arg(ap, char *);
  402. len += strlen(strs[i]);
  403. }
  404. va_end(ap);
  405. char * buf = __alloca(len);
  406. int cnt = 0;
  407. for (int i = 0 ; i < nstrs ; i++) {
  408. int l = strlen(strs[i]);
  409. memcpy(buf + cnt, strs[i], l);
  410. cnt += l;
  411. }
  412. _DkStreamWrite(pal_state.log_stream, 0, cnt, buf, NULL, 0);
  413. }