NativeLauncher/installer-plugin/ni_common.cc

   1 /*
   2  * Copyright (c) 2016 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the License);
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an AS IS BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <pkgmgr-info.h>
  18 #include <pkgmgr_installer_info.h>
  19 #include <aul.h>
  20
  21 #include "log.h"
  22 #include "utils.h"
  23 #include "pkgmgr_parser_plugin_interface.h"
  24
  25 #include <wait.h>
  26 #include <dirent.h>
  27 #include <sys/stat.h>
  28
  29 #include <algorithm>
  30 #include <string>
  31
  32 #include <pwd.h>
  33 #include <grp.h>
  34 #include <sys/stat.h>
  35 #include <unistd.h>
  36 #include <string.h>
  37
  38 #include <fstream>
  39 #include <sys/smack.h>
  40
  41 #include "ni_common.h"
  42 #include "path_manager.h"
  43 #include "plugin_manager.h"
  44
  45 #ifdef  LOG_TAG
  46 #undef  LOG_TAG
  47 #endif
  48 #define LOG_TAG "NETCORE_INSTALLER_PLUGIN"
  49
  50 #ifndef CROSSGEN_PATH
  51 #error "CROSSGEN_PATH is missed"
  52 #endif
  53
  54 #define __XSTR(x) #x
  55 #define __STR(x) __XSTR(x)
  56 static const char* __CROSSGEN_PATH = __STR(CROSSGEN_PATH);
  57 #undef __STR
  58 #undef __XSTR
  59
  60 static int __interval = 0;
  61
  62 static void waitInterval()
  63 {
  64         // by the recommand, ignore small value for performance.
  65         if (__interval > 10000) {
  66                 fprintf(stderr, "sleep %d usec\n", __interval);
  67                 usleep(__interval);
  68         }
  69 }
  70
  71 static bool niExist(const std::string& path, std::string& ni)
  72 {
  73         static std::string possibleExts[] = {
  74                 ".ni.dll", ".NI.dll", ".NI.DLL", ".ni.DLL",
  75                 ".ni.exe", ".NI.exe", ".NI.EXE", ".ni.EXE"
  76         };
  77         std::string fName = path.substr(0, path.size() - 4);
  78
  79         struct stat sb;
  80
  81         for (std::string ext : possibleExts) {
  82                 std::string f = fName + ext;
  83                 if (stat(f.c_str(), &sb) == 0) {
  84                         ni = f;
  85                         return true;
  86                 }
  87         }
  88
  89         // native image of System.Private.CoreLib.dll should have to overwrite
  90         // original file to support new coreclr
  91         if (path.find("System.Private.CoreLib.dll") != std::string::npos) {
  92                 std::string coreLibBackup = path + ".Backup";
  93                 if (isFileExist(coreLibBackup)) {
  94                         ni = path;
  95                         return true;
  96                 }
  97         }
  98
  99         return false;
 100 }
 101
 102 static void updateNiFileInfo(const std::string& path)
 103 {
 104         char* label = NULL;
 105         std::string niPath;
 106
 107         if (niExist(path, niPath)) {
 108                 // change smack label
 109                 if (smack_getlabel(path.c_str(), &label, SMACK_LABEL_ACCESS) == 0) {
 110                         if (smack_setlabel(niPath.c_str(), label, SMACK_LABEL_ACCESS) < 0) {
 111                                 fprintf(stderr, "Fail to set smack label\n");
 112                         }
 113                         free(label);
 114                 }
 115
 116                 // change owner and groups for generated ni file.
 117                 struct stat info;
 118                 if (!stat(path.c_str(), &info)) {
 119                         if (chown(niPath.c_str(), info.st_uid, info.st_gid) == -1)
 120                                 fprintf(stderr, "Failed to change owner and group name\n");
 121                 }
 122         }
 123 }
 124
 125 static void crossgen(const std::string& dllPath, const std::string& appPath, bool enableR2R)
 126 {
 127         std::string absDllPath = absolutePath(dllPath);
 128
 129         pid_t pid = fork();
 130         if (pid == -1)
 131                 return;
 132
 133         if (pid > 0) {
 134                 int status;
 135                 waitpid(pid, &status, 0);
 136                 if (WIFEXITED(status)) {
 137                         updateNiFileInfo(absDllPath);
 138                         return;
 139                 }
 140         } else {
 141                 std::string tpa = getTPA();
 142                 std::string jitPath = getRuntimeDir() + "/libclrjit.so";
 143                 std::vector<const char*> argv = {
 144                         __CROSSGEN_PATH,
 145                         "/nologo",
 146                         "/Trusted_Platform_Assemblies", tpa.c_str(),
 147                         "/JITPath", jitPath.c_str()
 148                 };
 149
 150                 if (!enableR2R) {
 151                         argv.push_back("/FragileNonVersionable");
 152                 }
 153
 154                 argv.push_back("/App_Paths");
 155                 std::string absAppPath;
 156                 if (!appPath.empty()) {
 157                         absAppPath = appPath;
 158                 } else {
 159                         absAppPath = baseName(absDllPath);
 160                 }
 161                 argv.push_back(absAppPath.c_str());
 162
 163                 argv.push_back(absDllPath.c_str());
 164                 argv.push_back(nullptr);
 165
 166                 fprintf(stderr, "+ %s (%s)\n", absDllPath.c_str(), enableR2R ? "R2R" : "FNV");
 167
 168                 execv(__CROSSGEN_PATH, const_cast<char* const*>(argv.data()));
 169                 exit(0);
 170         }
 171 }
 172
 173 static int getRootPath(std::string pkgId, std::string& rootPath)
 174 {
 175         int ret = 0;
 176         char *path = 0;
 177
 178         uid_t uid = 0;
 179
 180         if (pkgmgr_installer_info_get_target_uid(&uid) < 0) {
 181                 _ERR("Failed to get UID");
 182                 return -1;
 183         }
 184
 185         pkgmgrinfo_pkginfo_h handle;
 186         if (uid == 0) {
 187                 ret = pkgmgrinfo_pkginfo_get_pkginfo(pkgId.c_str(), &handle);
 188                 if (ret != PMINFO_R_OK)
 189                         return -1;
 190         } else {
 191                 ret = pkgmgrinfo_pkginfo_get_usr_pkginfo(pkgId.c_str(), uid, &handle);
 192                 if (ret != PMINFO_R_OK)
 193                         return -1;
 194         }
 195
 196         ret = pkgmgrinfo_pkginfo_get_root_path(handle, &path);
 197         if (ret != PMINFO_R_OK) {
 198                 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
 199                 return -1;
 200         }
 201         rootPath = path;
 202         pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
 203
 204         return 0;
 205 }
 206
 207
 208 static int appAotCb(pkgmgrinfo_appinfo_h handle, void *userData)
 209 {
 210         char *pkgId = NULL;
 211         int ret = 0;
 212
 213         ret = pkgmgrinfo_appinfo_get_pkgid(handle, &pkgId);
 214         if (ret != PMINFO_R_OK) {
 215                 fprintf(stderr, "Failed to get pkgid\n");
 216                 return -1;
 217         }
 218
 219         if (removeNiUnderPkgRoot(pkgId) != 0) {
 220                 fprintf(stderr, "Failed to remove previous dlls from [%s]\n", pkgId);
 221                 return -1;
 222         }
 223
 224         // Regenerate ni files with R2R mode forcibiliy. (there is no way to now which option is used)
 225         if (createNiUnderPkgRoot(pkgId, true) != 0) {
 226                 fprintf(stderr, "Failed to get root path from [%s]\n", pkgId);
 227                 return -1;
 228         } else {
 229                 fprintf(stderr, "Complete make application to native image\n");
 230         }
 231
 232         return 0;
 233 }
 234
 235 static void createCoreLibNI(bool enableR2R)
 236 {
 237         std::string coreLib = concatPath(getRuntimeDir(), "System.Private.CoreLib.dll");
 238         std::string niCoreLib = concatPath(getRuntimeDir(), "System.Private.CoreLib.ni.dll");
 239         std::string coreLibBackup = concatPath(getRuntimeDir(), "System.Private.CoreLib.dll.Backup");
 240
 241         if (!niExist(coreLib, niCoreLib)) {
 242                 crossgen(coreLib, std::string(), enableR2R);
 243                 if (isFileExist(niCoreLib)) {
 244                         if (rename(coreLib.c_str(), coreLibBackup.c_str())) {
 245                                 fprintf(stderr, "Failed to rename System.Private.CoreLib.dll\n");
 246                         }
 247                         if (rename(niCoreLib.c_str(), coreLib.c_str())) {
 248                                 fprintf(stderr, "Failed to rename System.Private.CoreLib.ni.dll\n");
 249                         }
 250                 } else {
 251                         fprintf(stderr, "Failed to create native image for %s\n", coreLib.c_str());
 252                 }
 253         }
 254 }
 255
 256 int initNICommon(NiCommonOption* option)
 257 {
 258         // get interval value
 259         const char* intervalFile = "/usr/share/dotnet.tizen/lib/crossgen_interval.txt";
 260         std::ifstream inFile(intervalFile);
 261         if (inFile) {
 262                 fprintf(stderr, "crossgen_interval.txt is found\n");
 263                 inFile >> __interval;
 264         }
 265
 266         if (initializePluginManager("normal")) {
 267                 fprintf(stderr, "Fail to initialize plugin manager\n");
 268                 return -1;
 269         }
 270         if (initializePathManager(option->runtimeDir, option->tizenFXDir, option->extraDirs)) {
 271                 fprintf(stderr, "Fail to initialize path manager\n");
 272                 return -1;
 273         }
 274
 275         return 0;
 276 }
 277
 278 void finalizeNICommon()
 279 {
 280         __interval = 0;
 281
 282         finalizePluginManager();
 283         finalizePathManager();
 284 }
 285
 286
 287 void createNiPlatform(bool enableR2R)
 288 {
 289         const std::string platformDirs[] = {getRuntimeDir(), getTizenFXDir()};
 290
 291         createNiUnderDirs(platformDirs, 2, enableR2R);
 292 }
 293
 294 void createNiDll(const std::string& dllPath, bool enableR2R)
 295 {
 296         createCoreLibNI(enableR2R);
 297
 298         if (!isFileExist(dllPath)) {
 299                 fprintf(stderr, "Failed to find dll : %s\n", dllPath.c_str());
 300                 return;
 301         }
 302
 303         std::string niPath;
 304         if (niExist(dllPath, niPath)) {
 305                 fprintf(stderr, "Already [%s] file is exist\n", niPath.c_str());
 306                 return;
 307         }
 308
 309         crossgen(dllPath, std::string(), enableR2R);
 310         if (!niExist(dllPath, niPath)) {
 311                 fprintf(stderr, "Failed to create native image for %s\n", dllPath.c_str());
 312         }
 313 }
 314
 315 void createNiUnderDirs(const std::string rootPaths[], int count, const std::string ignores[], int igcount, afterCreate cb, bool enableR2R)
 316 {
 317         createCoreLibNI(enableR2R);
 318
 319         std::string appPaths;
 320         for (int i = 0; i < count; i++) {
 321                 appPaths += rootPaths[i];
 322                 appPaths += ':';
 323         }
 324
 325         if (appPaths.back() == ':')
 326                 appPaths.pop_back();
 327
 328         auto convert = [&appPaths, ignores, igcount, &cb, enableR2R](const std::string& path, const char* name) {
 329                 for (int i = 0; i < igcount; i++) {
 330                         if (path == ignores[i])
 331                                 return;
 332                 }
 333                 std::string niPath;
 334                 if (isManagedAssembly(path)) {
 335                         if (niExist(path, niPath)) {
 336                                 fprintf(stderr, "Already [%s] file is exist\n", niPath.c_str());
 337                                 return;
 338                         }
 339                         fprintf(stderr, "path [%s], appPath[%s]\n", path.c_str(), appPaths.c_str());
 340                         crossgen(path, appPaths.c_str(), enableR2R);
 341                         if (niExist(path, niPath)) {
 342                                 if (cb != nullptr)
 343                                         cb(niPath.c_str());
 344                         } else {
 345                                 fprintf(stderr, "Failed to create native image for %s\n", path.c_str());
 346                         }
 347                         waitInterval();
 348                 }
 349         };
 350
 351         for (int i = 0; i < count; i++)
 352                 scanFilesInDir(rootPaths[i], convert, 1);
 353 }
 354 void createNiUnderDirs(const std::string rootPaths[], int count, afterCreate cb, bool enableR2R)
 355 {
 356         createNiUnderDirs(rootPaths, count, nullptr, 0, cb, enableR2R);
 357 }
 358 void createNiUnderDirs(const std::string rootPaths[], int count, bool enableR2R)
 359 {
 360         createNiUnderDirs(rootPaths, count, nullptr, enableR2R);
 361 }
 362
 363 int createNiUnderPkgRoot(const std::string& pkgName, bool enableR2R)
 364 {
 365         std::string pkgRoot;
 366         if (getRootPath(pkgName, pkgRoot) < 0)
 367                 return -1;
 368
 369         std::string binDir = concatPath(pkgRoot, "bin");
 370         std::string libDir = concatPath(pkgRoot, "lib");
 371         std::string paths[] = {binDir, libDir};
 372
 373         createNiUnderDirs(paths, 2, enableR2R);
 374
 375         return 0;
 376 }
 377
 378 int createNiDllUnderPkgRoot(const std::string& pkgName, const std::string& dllPath, bool enableR2R)
 379 {
 380         std::string pkgRoot;
 381         if (getRootPath(pkgName, pkgRoot) < 0)
 382                 return -1;
 383
 384         std::string binDir = concatPath(pkgRoot, "bin");
 385         std::string libDir = concatPath(pkgRoot, "lib");
 386         std::string appPaths = binDir + ":" + libDir;
 387
 388         if (!isFileExist(dllPath)) {
 389                 fprintf(stderr, "Failed to find dll : %s\n", dllPath.c_str());
 390                 return -1;
 391         }
 392
 393         std::string niPath;
 394         if (niExist(dllPath, niPath)) {
 395                 fprintf(stderr, "Already [%s] file is exist\n", niPath.c_str());
 396                 return -1;
 397         }
 398
 399         crossgen(dllPath, appPaths, enableR2R);
 400         if (!niExist(dllPath, niPath)) {
 401                 fprintf(stderr, "Failed to create native image for %s\n", dllPath.c_str());
 402                 return -1;
 403         }
 404
 405         return 0;
 406 }
 407
 408 void removeNiPlatform()
 409 {
 410         std::string coreLib = concatPath(getRuntimeDir(), "System.Private.CoreLib.dll");
 411         std::string coreLibBackup = concatPath(getRuntimeDir(), "System.Private.CoreLib.dll.Backup");
 412
 413         if (!isFileExist(coreLibBackup)) {
 414                 return;
 415         }
 416
 417         if (remove(coreLib.c_str())) {
 418                 fprintf(stderr, "Failed to remove System.Private.CoreLib native image file\n");
 419         }
 420
 421         if (rename(coreLibBackup.c_str(), coreLib.c_str())) {
 422                 fprintf(stderr, "Failed to rename System.Private.CoreLib.Backup to origin\n");
 423         }
 424
 425         const std::string platformDirs[] = {getRuntimeDir(), getTizenFXDir()};
 426
 427         removeNiUnderDirs(platformDirs, 2);
 428 }
 429
 430 void removeNiUnderDirs(const std::string rootPaths[], int count)
 431 {
 432         auto convert = [](const std::string& path, std::string name) {
 433                 std::string ni;
 434                 if (isNativeImage(path)) {
 435                         if (remove(path.c_str())) {
 436                                 fprintf(stderr, "Failed to remove %s\n", path.c_str());
 437                         }
 438                 }
 439         };
 440
 441         for (int i = 0; i < count; i++)
 442                 scanFilesInDir(rootPaths[i], convert, -1);
 443 }
 444
 445 int removeNiUnderPkgRoot(const std::string& pkgName)
 446 {
 447         std::string pkgRoot;
 448         if (getRootPath(pkgName, pkgRoot) < 0)
 449                 return -1;
 450
 451         std::string binDir = concatPath(pkgRoot, "bin");
 452         std::string libDir = concatPath(pkgRoot, "lib");
 453         std::string paths[] = {binDir, libDir};
 454
 455         removeNiUnderDirs(paths, 2);
 456
 457         return 0;
 458 }
 459
 460 int regenerateAppNI()
 461 {
 462         int ret = 0;
 463         pkgmgrinfo_appinfo_metadata_filter_h handle;
 464
 465         ret = pkgmgrinfo_appinfo_metadata_filter_create(&handle);
 466         if (ret != PMINFO_R_OK)
 467                 return -1;
 468
 469         ret = pkgmgrinfo_appinfo_metadata_filter_add(handle, "http://tizen.org/metadata/prefer_dotnet_aot", "true");
 470         if (ret != PMINFO_R_OK) {
 471                 pkgmgrinfo_appinfo_metadata_filter_destroy(handle);
 472                 return -1;
 473         }
 474
 475         ret = pkgmgrinfo_appinfo_metadata_filter_foreach(handle, appAotCb, NULL);
 476         if (ret != PMINFO_R_OK) {
 477                 fprintf(stderr, "Failed pkgmgrinfo_appinfo_metadata_filter_foreach\n");
 478                 pkgmgrinfo_appinfo_metadata_filter_destroy(handle);
 479                 return -1;
 480         }
 481
 482         fprintf(stderr, "Success pkgmgrinfo_appinfo_metadata_filter_foreach\n");
 483
 484         pkgmgrinfo_appinfo_metadata_filter_destroy(handle);
 485         return 0;
 486 }
 487