MESSAGE("CMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}")
INCLUDE(FindPkgConfig)
-PKG_CHECK_MODULES(${PROJECT_NAME} REQUIRED aul pkgmgr-info pkgmgr-installer dlog ecore bundle dlog liblaunchpad glib-2.0 libsmack capi-appfw-app-common storage jsoncpp openssl sqlite3)
+PKG_CHECK_MODULES(${PROJECT_NAME} REQUIRED aul pkgmgr-info pkgmgr-installer ecore bundle dlog liblaunchpad glib-2.0 libsmack capi-appfw-app-common storage jsoncpp openssl sqlite3)
FOREACH(flag ${${PROJECT_NAME}_CFLAGS})
SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} ${flag}")
ENDFOREACH(flag)
+SET(target_hydra dotnet_hydra_launcher)
+
+PKG_CHECK_MODULES(${target_hydra} REQUIRED liblaunchpad-hydra)
+
+FOREACH(flag ${${target_hydra}_CFLAGS})
+ SET(EXTRA_CFLAGS_HYDRA "${EXTRA_CFLAGS_HYDRA} ${flag}")
+ENDFOREACH(flag)
+
+
IF(DEFINED LAUNCHER_CONFIG_PATH)
- SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} -DLAUNCHER_CONFIG_PATH=${LAUNCHER_CONFIG_PATH}")
+ SET(EXTRA_CFLAGS_COMMON "${EXTRA_CFLAGS_COMMON} -DLAUNCHER_CONFIG_PATH=${LAUNCHER_CONFIG_PATH}")
ENDIF(DEFINED LAUNCHER_CONFIG_PATH)
IF(DEFINED DEVICE_API_DIR)
- SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} -DDEVICE_API_DIR=${DEVICE_API_DIR}")
+ SET(EXTRA_CFLAGS_COMMON "${EXTRA_CFLAGS_COMMON} -DDEVICE_API_DIR=${DEVICE_API_DIR}")
ENDIF(DEFINED DEVICE_API_DIR)
IF(DEFINED RUNTIME_DIR)
- SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} -DRUNTIME_DIR=${RUNTIME_DIR}")
+ SET(EXTRA_CFLAGS_COMMON "${EXTRA_CFLAGS_COMMON} -DRUNTIME_DIR=${RUNTIME_DIR}")
ENDIF(DEFINED RUNTIME_DIR)
IF(DEFINED CROSSGEN_PATH)
- SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} -DCROSSGEN_PATH=${CROSSGEN_PATH}")
+ SET(EXTRA_CFLAGS_COMMON "${EXTRA_CFLAGS_COMMON} -DCROSSGEN_PATH=${CROSSGEN_PATH}")
ENDIF(DEFINED CROSSGEN_PATH)
IF(DEFINED VERSION)
- SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} -DVERSION=${VERSION}")
+ SET(EXTRA_CFLAGS_COMMON "${EXTRA_CFLAGS_COMMON} -DVERSION=${VERSION}")
ENDIF(DEFINED VERSION)
IF(DEFINED NATIVE_LIB_DIR)
- SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} -DNATIVE_LIB_DIR=${NATIVE_LIB_DIR}")
+ SET(EXTRA_CFLAGS_COMMON "${EXTRA_CFLAGS_COMMON} -DNATIVE_LIB_DIR=${NATIVE_LIB_DIR}")
ENDIF(DEFINED NATIVE_LIB_DIR)
IF(DEFINED TAC_DIR)
- SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} -DTAC_DIR=${TAC_DIR}")
+ SET(EXTRA_CFLAGS_COMMON "${EXTRA_CFLAGS_COMMON} -DTAC_DIR=${TAC_DIR}")
ENDIF(DEFINED TAC_DIR)
IF(DEFINED USE_DEFAULT_BASE_ADDR)
- SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} -DUSE_DEFAULT_BASE_ADDR")
+ SET(EXTRA_CFLAGS_COMMON "${EXTRA_CFLAGS_COMMON} -DUSE_DEFAULT_BASE_ADDR")
ENDIF(DEFINED USE_DEFAULT_BASE_ADDR)
IF(DEFINED UNIQUE_DEFAULT_BASE_ADDR_SUPPORT)
- SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} -DUNIQUE_DEFAULT_BASE_ADDR_SUPPORT")
+ SET(EXTRA_CFLAGS_COMMON "${EXTRA_CFLAGS_COMMON} -DUNIQUE_DEFAULT_BASE_ADDR_SUPPORT")
ENDIF(DEFINED UNIQUE_DEFAULT_BASE_ADDR_SUPPORT)
IF(DEFINED SYSTEM_BASE_FILE)
- SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} -DSYSTEM_BASE_FILE=${SYSTEM_BASE_FILE}")
+ SET(EXTRA_CFLAGS_COMMON "${EXTRA_CFLAGS_COMMON} -DSYSTEM_BASE_FILE=${SYSTEM_BASE_FILE}")
ENDIF(DEFINED SYSTEM_BASE_FILE)
IF(DEFINED DEFAULT_BASE_ADDR_START)
- SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} -DDEFAULT_BASE_ADDR_START=${DEFAULT_BASE_ADDR_START}")
+ SET(EXTRA_CFLAGS_COMMON "${EXTRA_CFLAGS_COMMON} -DDEFAULT_BASE_ADDR_START=${DEFAULT_BASE_ADDR_START}")
ENDIF(DEFINED DEFAULT_BASE_ADDR_START)
ADD_DEFINITIONS(-DLOADERDIR="${LOADERDIR}")
ADD_DEFINITIONS("-DNOT_USE_FUNCTION")
ENDIF(NOT_USE_FUNCTION)
-
-SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} -pthread -std=c++11 -ggdb")
-#SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} -fvisibility=hidden")
-#SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} -fPIE")
-SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} -fdata-sections -ffunction-sections")
-SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} -D_FILE_OFFSET_BITS=64")
-#SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} -DLAUNCHING_TIME_MEASURE")
+SET(EXTRA_CFLAGS_COMMON "${EXTRA_CFLAGS_COMMON} -pthread -std=c++11 -ggdb")
+#SET(EXTRA_CFLAGS_COMMON "${EXTRA_CFLAGS_COMMON} -fvisibility=hidden")
+#SET(EXTRA_CFLAGS_COMMON "${EXTRA_CFLAGS_COMMON} -fPIE")
+SET(EXTRA_CFLAGS_COMMON "${EXTRA_CFLAGS_COMMON} -fdata-sections -ffunction-sections")
+SET(EXTRA_CFLAGS_COMMON "${EXTRA_CFLAGS_COMMON} -D_FILE_OFFSET_BITS=64")
+#SET(EXTRA_CFLAGS_COMMON "${EXTRA_CFLAGS_COMMON} -DLAUNCHING_TIME_MEASURE")
IF(ASAN_ENABLED)
- SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} -fno-omit-frame-pointer -fsanitize=address")
+ SET(EXTRA_CFLAGS_COMMON "${EXTRA_CFLAGS_COMMON} -fno-omit-frame-pointer -fsanitize=address")
ELSE(ASAN_ENABLED)
- SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} -Wl,-zdefs")
- SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} -Wl,--no-as-needed")
- SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} -Wl,--gc-sections")
+ SET(EXTRA_CFLAGS_COMMON "${EXTRA_CFLAGS_COMMON} -Wl,-zdefs")
+ SET(EXTRA_CFLAGS_COMMON "${EXTRA_CFLAGS_COMMON} -Wl,--no-as-needed")
+ SET(EXTRA_CFLAGS_COMMON "${EXTRA_CFLAGS_COMMON} -Wl,--gc-sections")
ENDIF(ASAN_ENABLED)
-SET(CMAKE_CXX_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_CFLAGS}")
-SET(CMAKE_CXX_FLAGS_DEBUG "-O2 -g")
-SET(CMAKE_CXX_FLAGS_RELEASE "-O2")
-SET(CMAKE_EXE_LINKER_FLAGS "-Wl,--as-needed")
+SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} ${EXTRA_CFLAGS_COMMON}")
+SET(EXTRA_CFLAGS_EXE "${EXTRA_CFLAGS} -fPIE")
+SET(EXTRA_CFLAGS_LIB "${EXTRA_CFLAGS} -fPIC")
-#SET(${PROJECT_NAME}_LDFLAGS ${${PROJECT_NAME}_LDFLAGS} "-pie")
+SET(EXTRA_CFLAGS_HYDRA "${EXTRA_CFLAGS_HYDRA} ${EXTRA_CFLAGS_COMMON}")
+SET(EXTRA_CFLAGS_HYDRA "${EXTRA_CFLAGS_HYDRA} -fPIE")
+
+SET(CMAKE_CXX_FLAGS "${CMAKE_C_FLAGS}")
+#SET(CMAKE_CXX_FLAGS_DEBUG "-O2 -g")
+#SET(CMAKE_CXX_FLAGS_RELEASE "-O2")
+SET(CMAKE_EXE_LINKER_FLAGS "-Wl,--as-needed")
INCLUDE_DIRECTORIES(inc launcher util)
util/log_manager.cc
)
ADD_LIBRARY(${DOTNET_LAUNCHER_UTIL} SHARED ${${DOTNET_LAUNCHER_UTIL}_SOURCE_FILES})
-SET_TARGET_PROPERTIES(${DOTNET_LAUNCHER_UTIL} PROPERTIES COMPILE_FLAGS "-fPIC")
+SET_TARGET_PROPERTIES(${DOTNET_LAUNCHER_UTIL} PROPERTIES COMPILE_FLAGS ${EXTRA_CFLAGS_LIB})
TARGET_LINK_LIBRARIES(${DOTNET_LAUNCHER_UTIL} ${${PROJECT_NAME}_LDFLAGS} "-ldl" boost_filesystem boost_system)
SET(DOTNET_LAUNCHER "dotnet-launcher")
launcher/dotnet/dotnet_launcher.cc
)
ADD_EXECUTABLE(${DOTNET_LAUNCHER} ${${DOTNET_LAUNCHER}_SOURCE_FILES})
-SET_TARGET_PROPERTIES(${DOTNET_LAUNCHER} PROPERTIES COMPILE_FLAGS "-fPIE")
+SET_TARGET_PROPERTIES(${DOTNET_LAUNCHER} PROPERTIES COMPILE_FLAGS ${EXTRA_CFLAGS_EXE})
TARGET_LINK_LIBRARIES(${DOTNET_LAUNCHER} ${${PROJECT_NAME}_LDFLAGS} "-pie -ldl -lpthread" aul ${DOTNET_LAUNCHER_UTIL})
SET_TARGET_PROPERTIES(${DOTNET_LAUNCHER}
PROPERTIES SKIP_BUILD_RPATH TRUE
) # remove rpath option that is automatically generated by cmake.
+SET(DOTNET_HYDRA_LAUNCHER "dotnet-hydra-launcher")
+SET(${DOTNET_HYDRA_LAUNCHER}_SOURCE_FILES
+ hydra/hydra_main.cc
+)
+ADD_EXECUTABLE(${DOTNET_HYDRA_LAUNCHER} ${${DOTNET_HYDRA_LAUNCHER}_SOURCE_FILES})
+TARGET_LINK_LIBRARIES(${DOTNET_HYDRA_LAUNCHER} ${${target_hydra}_LDFLAGS} "-pie -ldl")
+SET_TARGET_PROPERTIES(${DOTNET_HYDRA_LAUNCHER} PROPERTIES COMPILE_FLAGS ${EXTRA_CFLAGS_HYDRA})
+SET_TARGET_PROPERTIES(${DOTNET_HYDRA_LAUNCHER}
+ PROPERTIES SKIP_BUILD_RPATH TRUE
+) # remove rpath option that is automatically generated by cmake.
+
SET(TAC_COMMON "tac_common")
SET(${TAC_COMMON}_SOURCE_FILES
tool/tac_common.cc
util/db_manager.cc
)
ADD_LIBRARY(${TAC_COMMON} SHARED ${${TAC_COMMON}_SOURCE_FILES})
-SET_TARGET_PROPERTIES(${TAC_COMMON} PROPERTIES COMPILE_FLAGS "-fPIC")
+SET_TARGET_PROPERTIES(${TAC_COMMON} PROPERTIES COMPILE_FLAGS ${EXTRA_CFLAGS_LIB})
TARGET_LINK_LIBRARIES(${TAC_COMMON} ${${PROJECT_NAME}_LDFLAGS} ${DOTNET_LAUNCHER_UTIL})
SET(NI_COMMON "ni_common")
tool/ni_common.cc
)
ADD_LIBRARY(${NI_COMMON} SHARED ${${NI_COMMON}_SOURCE_FILES})
-SET_TARGET_PROPERTIES(${NI_COMMON} PROPERTIES COMPILE_FLAGS "-fPIC")
+SET_TARGET_PROPERTIES(${NI_COMMON} PROPERTIES COMPILE_FLAGS ${EXTRA_CFLAGS_LIB})
TARGET_LINK_LIBRARIES(${NI_COMMON} ${${PROJECT_NAME}_LDFLAGS} ${DOTNET_LAUNCHER_UTIL} ${TAC_COMMON})
SET(NITOOL "nitool")
tool/nitool.cc
)
ADD_EXECUTABLE(${NITOOL} ${${NITOOL}_SOURCE_FILES})
-SET_TARGET_PROPERTIES(${NITOOL} PROPERTIES COMPILE_FLAGS "-fPIE")
+SET_TARGET_PROPERTIES(${NITOOL} PROPERTIES COMPILE_FLAGS ${EXTRA_CFLAGS_EXE})
TARGET_LINK_LIBRARIES(${NITOOL} ${${PROJECT_NAME}_LDFLAGS} "-pie" ${DOTNET_LAUNCHER_UTIL} ${NI_COMMON})
SET(TPATOOL "tpatool")
tool/tpatool.cc
)
ADD_EXECUTABLE(${TPATOOL} ${${TPATOOL}_SOURCE_FILES})
-SET_TARGET_PROPERTIES(${TPATOOL} PROPERTIES COMPILE_FLAGS "-fPIE")
+SET_TARGET_PROPERTIES(${TPATOOL} PROPERTIES COMPILE_FLAGS ${EXTRA_CFLAGS_EXE})
TARGET_LINK_LIBRARIES(${TPATOOL} ${${PROJECT_NAME}_LDFLAGS} "-pie" ${DOTNET_LAUNCHER_UTIL})
SET(DOTNETTOOL "dotnettool")
tool/dotnettool.cc
)
ADD_EXECUTABLE(${DOTNETTOOL} ${${DOTNETTOOL}_SOURCE_FILES})
-SET_TARGET_PROPERTIES(${DOTNETTOOL} PROPERTIES COMPILE_FLAGS "-fPIE")
+SET_TARGET_PROPERTIES(${DOTNETTOOL} PROPERTIES COMPILE_FLAGS ${EXTRA_CFLAGS_EXE})
TARGET_LINK_LIBRARIES(${DOTNETTOOL} ${${PROJECT_NAME}_LDFLAGS} "-pie" ${DOTNET_LAUNCHER_UTIL} ${NI_COMMON})
SET(PREFER_DOTNET_AOT_PLUGIN "prefer_dotnet_aot_plugin")
installer-plugin/prefer_dotnet_aot_plugin.cc
)
ADD_LIBRARY(${PREFER_DOTNET_AOT_PLUGIN} SHARED ${${PREFER_DOTNET_AOT_PLUGIN}_SOURCE_FILES})
-SET_TARGET_PROPERTIES(${PREFER_DOTNET_AOT_PLUGIN} PROPERTIES COMPILE_FLAGS "-fPIC")
+SET_TARGET_PROPERTIES(${PREFER_DOTNET_AOT_PLUGIN} PROPERTIES COMPILE_FLAGS ${EXTRA_CFLAGS_LIB})
TARGET_LINK_LIBRARIES(${PREFER_DOTNET_AOT_PLUGIN} ${${PROJECT_NAME}_LDFLAGS} ${DOTNET_LAUNCHER_UTIL} ${NI_COMMON})
SET(PREFER_NUGET_CACHE_PLUGIN "prefer_nuget_cache_plugin")
installer-plugin/prefer_nuget_cache_plugin.cc
)
ADD_LIBRARY(${PREFER_NUGET_CACHE_PLUGIN} SHARED ${${PREFER_NUGET_CACHE_PLUGIN}_SOURCE_FILES})
-SET_TARGET_PROPERTIES(${PREFER_NUGET_CACHE_PLUGIN} PROPERTIES COMPILE_FLAGS "-fPIC")
+SET_TARGET_PROPERTIES(${PREFER_NUGET_CACHE_PLUGIN} PROPERTIES COMPILE_FLAGS ${EXTRA_CFLAGS_LIB})
TARGET_LINK_LIBRARIES(${PREFER_NUGET_CACHE_PLUGIN} ${${PROJECT_NAME}_LDFLAGS} ${DOTNET_LAUNCHER_UTIL} ${TAC_COMMON})
CONFIGURE_FILE(dotnet-launcher.pc.in dotnet-launcher.pc @ONLY)
INSTALL(TARGETS ${DOTNET_LAUNCHER_UTIL} DESTINATION ${LIBDIR})
INSTALL(TARGETS ${DOTNET_LAUNCHER} DESTINATION ${BINDIR})
+INSTALL(TARGETS ${DOTNET_HYDRA_LAUNCHER} DESTINATION ${BINDIR})
INSTALL(TARGETS ${TAC_COMMON} DESTINATION ${LIBDIR})
INSTALL(TARGETS ${NI_COMMON} DESTINATION ${LIBDIR})
INSTALL(TARGETS ${NITOOL} DESTINATION ${BINDIR})
[LOADER]
NAME dotnet-launcher
+# for candidate mode
EXE /usr/bin/dotnet-launcher
+# for hydra mode
+#EXE /usr/bin/dotnet-hydra-launcher
APP_TYPE dotnet
DETECTION_METHOD TIMEOUT|DEMAND
TIMEOUT 5000
ON_BOOT OFF
-EXTRA_ARRAY preload
-EXTRA_ARRAY_VAL /usr/lib/libappcore-efl.so.1
-EXTRA_ARRAY_VAL /usr/lib/libappcore-common.so.1
-EXTRA_ARRAY_VAL /usr/lib/libcapi-appfw-application.so.0
-EXTRA_ARRAY_VAL /usr/lib/ecore_imf/modules/wayland/v-1.16/libwltextinputmodule.so
-EXTRA_ARRAY_VAL /usr/lib/libdali-toolkit.so
-EXTRA_ARRAY_VAL /usr/lib/libcairo.so.2
-EXTRA_ARRAY_VAL /usr/lib/libefl-assist.so.0
-HYDRA ON
+HYDRA OFF
--- /dev/null
+/*
+ * Copyright (c) 2019 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <launchpad_hydra.h>
+
+#include <stdio.h>
+#include <dlfcn.h>
+#include <cstring>
+#include <fstream>
+#include <limits.h>
+#include <stdlib.h>
+
+#include "log.h"
+#include "launcher_env.h"
+
+const char* __coreclr_lib = "/usr/share/dotnet.tizen/netcoreapp/libcoreclr.so";
+const char* __dotnet_launcher = "/usr/bin/dotnet-launcher";
+
+typedef int (*coreclr_preload_assembly_ptr)(const char* assemblyPath);
+typedef int (*launcher_real_main_ptr)(int argc, char *argv[], const char* mode);
+
+static std::string absolutePath(const std::string& path)
+{
+ std::string absPath;
+ char realPath[PATH_MAX];
+ if (realpath(path.c_str(), realPath) != nullptr && realPath[0] != '\0')
+ absPath.assign(realPath);
+
+ return absPath;
+}
+
+static void preloadAssemblies()
+{
+#ifdef USE_DEFAULT_BASE_ADDR
+ putenv(const_cast<char *>("COMPlus_UseDefaultBaseAddr=1"));
+#endif // USE_DEFAULT_BASE_ADDR
+
+ void* coreclrLib = dlopen(__coreclr_lib, RTLD_NOW | RTLD_GLOBAL);
+ if (coreclrLib == nullptr) {
+ _DBG("dlopen failed to open libcoreclr.so");
+ return;
+ }
+
+ coreclr_preload_assembly_ptr preloadAssembly;
+ preloadAssembly = (coreclr_preload_assembly_ptr)dlsym(coreclrLib, "coreclr_preload_assembly");
+ if (preloadAssembly == nullptr) {
+ _DBG("coreclr_preload_assembly is not found in the libcoreclr.so");
+ return;
+ }
+
+ std::ifstream preloadList(AOT_PRELOAD_PATH);
+ if (preloadList) {
+ std::string path;
+ while (getline(preloadList, path)) {
+ int st = preloadAssembly(absolutePath(path).c_str());
+ if (st != 0) {
+ _DBG("preload of %s failed! (0x%08x)", path.c_str(), st);
+ } else {
+ _DBG("preload of %s succeded", path.c_str());
+ }
+ }
+ }
+}
+
+int main(int argc, char** argv)
+{
+ hydra_lifecycle_callback_s hydra_callback;
+
+ hydra_callback.precreate = [](void* user_data) {
+ _INFO("hydra : precreate");
+ preloadAssemblies();
+ };
+
+ hydra_callback.create = [](void* user_data) {
+ _INFO("hydra : create");
+ };
+
+ hydra_callback.fork = [](int argc, char **argv, void* user_data) -> int {
+ _INFO("hydra : fork");
+ void* launcher_h = dlopen(__dotnet_launcher, RTLD_NOW | RTLD_GLOBAL);
+ if (launcher_h == nullptr) {
+ _DBG("dlopen failed to open dotnet-launcher");
+ return -1;
+ }
+
+ launcher_real_main_ptr realMain = (launcher_real_main_ptr)dlsym(launcher_h, "realMain");
+ if (realMain == nullptr) {
+ _DBG("realMain is not found in the dotnet-launcher");
+ return -1;
+ }
+
+ return realMain(argc, argv, "default");
+ };
+
+ hydra_callback.terminate = [](void* user_data)-> int {
+ _INFO("hydra : terminate");
+ return 0;
+ };
+
+ return launchpad_hydra_main(argc, argv, &hydra_callback, nullptr);
+}
+
shutdown(nullptr),
createDelegate(nullptr),
setEnvironmentVariable(nullptr),
- preloadAssembly(nullptr),
__coreclrLib(nullptr),
__hostHandle(nullptr),
__domainId(-1),
dispose();
}
-int CoreRuntime::preinitialize(bool standalone)
+int CoreRuntime::initialize(bool standalone)
{
// checkInjection checks dotnet-launcher run mode
// At the moment, this mechanism is used only when the Memory Profiler is started.
return -1;
}
+ if (__enableLogManager) {
+ if (initializeLogManager() < 0) {
+ _ERR("Failed to initnialize LogManager");
+ return -1;
+ }
+
+ if (redirectFD() < 0) {
+ _ERR("Failed to redirect FD");
+ return -1;
+ }
+
+ if (runLoggingThread() < 0) {
+ _ERR("Failed to create and run logging thread to redicrect log");
+ return -1;
+ }
+ }
+
std::string libCoreclr(concatPath(getRuntimeDir(), "libcoreclr.so"));
__coreclrLib = dlopen(libCoreclr.c_str(), RTLD_NOW | RTLD_LOCAL);
CORELIB_RETURN_IF_NOSYM(coreclr_execute_assembly_ptr, executeAssembly, "coreclr_execute_assembly");
CORELIB_RETURN_IF_NOSYM(coreclr_shutdown_ptr, shutdown, "coreclr_shutdown");
CORELIB_RETURN_IF_NOSYM(coreclr_create_delegate_ptr, createDelegate, "coreclr_create_delegate");
- CORELIB_RETURN_IF_NOSYM(coreclr_preload_assembly_ptr, preloadAssembly, "coreclr_preload_assembly");
#undef CORELIB_RETURN_IF_NOSYM
_INFO("libcoreclr dlopen and dlsym success");
-#define PRELOAD_IMAGE(path) \
- do { \
- int st = preloadAssembly(path); \
- if (st != 0) { \
- _ERR("preload of %s failed! (0x%08x)", path, st); \
- } else { \
- _DBG("preload of %s succeded", path); \
- } \
- } while (0)
-
- if(!standalone) {
- std::ifstream preloadList(AOT_PRELOAD_PATH);
- if (preloadList) {
- std::string path;
- while (getline(preloadList, path)) {
- PRELOAD_IMAGE(absolutePath(path).c_str());
- }
- }
- }
-
-#undef PRELOAD_IMAGE
-
- return 0;
-}
-
-int CoreRuntime::initialize(bool standalone)
-{
-#define __XSTR(x) #x
-#define __STR(x) __XSTR(x)
-
-#ifdef NATIVE_LIB_DIR
- __nativeLibDirectory = __STR(NATIVE_LIB_DIR);
-#endif
-
-#undef __STR
-#undef __XSTR
-
- if (__enableLogManager) {
- if (initializeLogManager() < 0) {
- _ERR("Failed to initnialize LogManager");
- return -1;
- }
-
- if (redirectFD() < 0) {
- _ERR("Failed to redirect FD");
- return -1;
- }
-
- if (runLoggingThread() < 0) {
- _ERR("Failed to create and run logging thread to redicrect log");
- return -1;
- }
- }
-
if (!standalone)
pluginPreload();
public:
CoreRuntime(const char* mode);
~CoreRuntime();
- int preinitialize(bool standalone);
int initialize(bool standalone);
void dispose();
int launch(const char* appId, const char* root, const char* path, int argc, char* argv[]);
coreclr_shutdown_ptr shutdown;
coreclr_create_delegate_ptr createDelegate;
set_environment_variable_ptr setEnvironmentVariable;
- coreclr_preload_assembly_ptr preloadAssembly;
std::string __nativeLibDirectory;
void* __coreclrLib;
void* __hostHandle;
public:
LaunchpadAdapterImpl() :
callbacks(),
- hydraCallbacks(),
adapter(),
__isLaunched(false)
{ }
private:
AppInfo appInfo;
loader_lifecycle_callback_s callbacks;
- hydra_lifecycle_callback_s hydraCallbacks;
loader_adapter_s adapter;
bool __isLaunched;
std::string __launchPath;
}
}
- return ECORE_CALLBACK_RENEW;
+ return ECORE_CALLBACK_CANCEL;
}
static void fdAdd(void *data, int fd, loader_receiver_cb receiver)
return 0;
};
- // Called before initial fork
- hydraCallbacks.precreate = [](void* userData) {
- WITH_SELF(userData) {
- if (self->onPreCreate != nullptr)
- self->onPreCreate();
- }
- };
-
- hydraCallbacks.create = [](void* userData) {
- ecore_init();
- };
-
- // Called after fork in candidate
- hydraCallbacks.fork = [](void *userData) {
- ecore_fork_reset();
- };
-
- hydraCallbacks.terminate = [](void* userData) {
- ecore_shutdown();
- return 0;
- };
-
adapter.loop_begin = [](void *data) {
ecore_init();
ecore_main_loop_begin();
adapter.add_fd = fdAdd;
adapter.remove_fd = fdRemove;
- _INFO("launchpad_hydra_main is start");
- int r = launchpad_hydra_main(argc, argv, &(this->hydraCallbacks),
- &(this->callbacks), &(this->adapter), this);
- _INFO("launchpad_hydra_main is finished with [%d]", r);
+ _INFO("launchpad_loader_main is start");
+ int r = launchpad_loader_main(argc, argv, &(this->callbacks), &(this->adapter), this);
+ _INFO("launchpad_loader_main is finished with [%d]", r);
return r;
}
{
public:
virtual int loaderMain(int argc, char* argv[]) = 0;
- std::function<void()> onPreCreate = nullptr;
std::function<void()> onCreate = nullptr;
std::function<void(const AppInfo&, int, char**)> onLaunch = nullptr;
std::function<void(const AppInfo&, int, char**)> onTerminate = nullptr;
snprintf(appId, 16, "%s", "dotnet-launcher");
appRoot = baseName(argv[1]);
- if (runtime->preinitialize(true) != 0) {
- _ERR("Failed to preinitialized");
- return 1;
- }
-
if (runtime->initialize(true) != 0) {
_ERR("Failed to initialize");
return 1;
}
_INFO("AUL_APPID : %s", appId);
- if (runtime->preinitialize(true) != 0) {
- _ERR("Failed to preinitialized");
- return 1;
- }
-
if (runtime->initialize(true) != 0) {
_ERR("Failed to initialize");
return 1;
return 1;
}
} else {
- Launchpad.onPreCreate = [&runtime]() {
- if (runtime->preinitialize(false) != 0)
- _ERR("Failed to preinitialized");
- else
- _INFO("Success to preinitialized");
- };
-
Launchpad.onCreate = [&runtime]() {
if (runtime->initialize(false) != 0)
_ERR("Failed to initialized");
BuildRequires: pkgconfig(dlog)
BuildRequires: pkgconfig(ecore)
BuildRequires: pkgconfig(liblaunchpad)
+BuildRequires: pkgconfig(liblaunchpad-hydra)
BuildRequires: pkgconfig(pkgmgr-info)
BuildRequires: pkgconfig(pkgmgr-installer)
BuildRequires: pkgconfig(glib-2.0)
%{_install_mdplugin_dir}/libprefer_nuget_cache_plugin.so
%{_install_mdplugin_dir}/libprefer_dotnet_aot_plugin.so
%{_bindir}/dotnet-launcher
+%{_bindir}/dotnet-hydra-launcher
%{_libdir}/libdotnet_launcher_util.so
%{_libdir}/libni_common.so
%{_libdir}/libtac_common.so
%{_libdir}/libni_common.so
%{_libdir}/libtac_common.so
%{_libdir}/pkgconfig/dotnet-launcher.pc
+
projects / platform / core / dotnet / launcher.git / commitdiff