C++ Loader::load方法代码示例

int main() {
	
	{
	Loader<Plugin> l;
    std::shared_ptr<Plugin> h = l.load("./testplugin.o");
    std::cout << h->next() << std::endl;
    std::shared_ptr<Plugin> i = l.load("./testplugin.o");
     std::cout << i->next() << std::endl;
	}
	
    // unload the triangle library
    
}

void process_lines(vector<string> & lines)
{

    const int nlines = lines.size();  // number of lines
    const int n = nlines - 1; // number of input data
    if (nlines < 2) {
        cout << "number of lines is wrong" << endl;
        exit(EXIT_FAILURE);
    }


    Loader loader; // frontend
    Docker docker; // backend

    for (int i = 0; i < n; ++i) {
        string input = lines[i + 1];
        //cout << input << endl;

        loader.load(input);
        loader.check();

#if 1
        vector<string> tokens = loader.get_tokens();
        for (unsigned int i = 0; i < tokens.size() - 1; ++i)
            cout << tokens[i] << ",";
        cout << tokens[tokens.size() - 1];
#endif
        cout << endl;


        loader.build_complex(docker.complex);
        docker.run();
    }
}

  /**
   * Entry point of loader.
   * At first of loop read load instruction json by stdin stream, and launch loader instance.
   * At last of loop, write result json for stdout stream.
   * @param argc
   * @param argv
   * @return Exit code of loader.
   */
  int entry(int argc, char* argv[]) {
    // Read stdin and separate by '\0'.
    std::string line;
    picojson::object result;

    // Create logger.
    Logger::Syslog logger;
    logger.initialize("loader");
    Logger::set_logger_delegate(&logger);

    // Load messages.
    Message::load("loader_message.json");
    Logger::info(LoaderMid::L2001, std::string(LLVM_VERSION_STRING).c_str());

    while (std::getline(std::cin, line, '\0')) {
      // Convert json string to picojson instance.
      picojson::value v;
      std::string err = picojson::parse(v, line);
      if (!err.empty()) {
        Logger::err(LoaderMid::L2003, err.c_str());
      }
      result = v.get<picojson::object>();
      Logger::info(LoaderMid::L2002, line.c_str());

      try {
        // Make loader.
        Loader loader;
        // Read information from json.
        loader.in_pid  = Convert::json2vpid(result.at("pid"));
        loader.in_name = result.at("name").get<std::string>();
        loader.in_dst_nid = Convert::json2nid(result.at("dst_nid"));
        loader.in_src_nid = Convert::json2nid(result.at("src_nid"));
        loader.in_src_account = result.at("src_account").get<std::string>();
        loader.in_type        = result.at("type").get<std::string>();

        // Convert arguments.
        std::vector<std::string> args;
        for (auto& it : result.at("args").get<picojson::array>()) {
          args.push_back(it.get<std::string>());
        }
        // Load.
        loader.load(args);

        // Show result.
        result.insert(std::make_pair("result", picojson::value(0.0)));
        result.insert(std::make_pair("root_tid", Convert::vtid2json(loader.out_root_tid)));

        std::cout << picojson::value(result).serialize() << '\0';
        Logger::info(LoaderMid::L2004, 0, loader.out_root_tid);
      } catch(const Error& ex) {
        // Show error information.
        result.insert(std::make_pair("result", picojson::value(-1.0)));
        result.insert(std::make_pair("reason", picojson::value(std::to_string(ex.reason))));
        result.insert(std::make_pair("message", picojson::value(ex.mesg)));
        result.insert(std::make_pair("llvm_version",
                                     picojson::value(std::string(LLVM_VERSION_STRING))));
        std::cout << picojson::value(result).serialize() << '\0';
        Logger::warn(LoaderMid::L2005, -1, ex.reason, ex.mesg.c_str());
      } catch(const std::exception& ex) {
        // Show error information.
        result.insert(std::make_pair("result", picojson::value(-1.0)));
        result.insert(std::make_pair("reason", picojson::value(std::to_string(-1))));
        result.insert(std::make_pair("message", picojson::value(std::string(ex.what()))));
        result.insert(std::make_pair("llvm_version",
                                     picojson::value(std::string(LLVM_VERSION_STRING))));
        std::cout << picojson::value(result).serialize() << '\0';
        Logger::warn(LoaderMid::L2005, -1, -1, ex.what());
      } catch (...) {
        int errsv = errno;
        // Show error information.
        result.insert(std::make_pair("result", picojson::value(-1.0)));
        result.insert(std::make_pair("reason", picojson::value(std::to_string(-2))));
        result.insert(std::make_pair("message",
                                     picojson::value(std::string(std::strerror(errsv)))));
        result.insert(std::make_pair("llvm_version",
                                     picojson::value(std::string(LLVM_VERSION_STRING))));
        std::cout << picojson::value(result).serialize() << '\0';
        Logger::warn(LoaderMid::L2005, -1, -2, std::strerror(errsv));
      }
    }

    return 0;
  }

void process_lines(vector<string> & lines)
{

    const int nlines = lines.size();  // number of lines
    const int n = nlines - 1; // number of input data
    if (nlines < 2) {
        cout << "number of lines is wrong" << endl;
        exit(EXIT_FAILURE);
    }



    // prints modified CSV title
    vector<string> tokens;
    tokens = tokenlize(lines[0]);

    tokens[18] = "steps_total";
    tokens[20] = "sz.n_prt";
    tokens[21] = "sz.n_lig";
    tokens[22] = "sz.n_tmp";
    tokens[23] = "sz.n_rep";
    tokens[24] = "sz.prt_npoint";
    tokens[25] = "sz.lig_natom";
    tokens[26] = "sz.kde_npoint";
    tokens[27] = "sz.mcs_nrow";

    for (unsigned int i = 0; i < tokens.size() - 1; ++i)
        cout << tokens[i] << ",";
    cout << tokens[tokens.size() - 1];
    cout << endl;



    // CSV contents
    Loader loader;
    for (int i = 0; i < n; ++i) {
        string input = lines[i + 1];
        //cout << input << endl;

        loader.load(input);
        loader.check();

#if 1
        tokens = loader.get_tokens();
	McPara mcpara = loader.get_mcpara();
        ComplexSize sz = loader.get_sz();

        tokens[18] = num2string(mcpara.steps_total);
        tokens[20] = num2string(sz.n_prt);
        tokens[21] = num2string(sz.n_lig);
        tokens[22] = num2string(sz.n_tmp);
        tokens[23] = num2string(sz.n_rep);
        tokens[24] = num2string(sz.prt_npoint);
        tokens[25] = num2string(sz.lig_natom);
        tokens[26] = num2string(sz.kde_npoint);
        tokens[27] = num2string(sz.mcs_nrow);
        for (unsigned int i = 0; i < tokens.size() - 1; ++i)
            cout << tokens[i] << ",";
        cout << tokens[tokens.size() - 1];
#endif
        cout << endl;

    }
}

SpawnStatus spawn(const char *path, const char *args, const char *workdir, SecurityLevel secLvl, Pid requesterPid, Pid *outPid, File_t *outStdin, File_t *outStdout, File_t *outStderr, File_t inStdin, File_t inStdout, File_t inStderr)
{
	// file of executable
	File_t file;

	// open input file
	if (!findFile(path, &file))
	{
		klog("unable to open the file: %s, it doesn't exist on PATH directory", path);
		return SPAWN_STATUS_IO_ERROR;
	}

	// detect format
	BinaryFormat format = detectFormat(file);
	if (format == BF_UNKNOWN)
	{
		klog("binary has an unknown format: %s", path);
		return SPAWN_STATUS_FORMAT_ERROR;
	}

	// create empty target process
	auto targetProc = CreateEmptyProcess(secLvl);
	Pid targetPid = GetCreatedProcessID(targetProc);

	// apply configuration
	ProcessConfiguration configuration;
	configuration.sourcePath = (char*) path;
	ConfigureProcess(targetProc, configuration);

	// create a loader
	Loader *loader;
	if (format == BF_ELF32) loader = new Elf32Loader(targetProc, file);
	//else if (format == BF_ELF64) loader = new Elf64Loader(targetProc, file);
	else
	{
		klog("no loader implementation for binary format %i", format);
		return SPAWN_STATUS_FORMAT_ERROR;
	}

	// setup standard I/O
	if (!setupStdio(targetPid, requesterPid, outStdin, outStdout, outStderr, inStdin, inStdout, inStderr)) klog("unable to setup stdio for process %i", targetPid);

	// perform loading
	uintptr_t entryAddress;
	LoaderStatus ldrStat = loader->load(&entryAddress);
	SpawnStatus spawnStat = SPAWN_STATUS_UNKNOWN;

	if (ldrStat == LS_SUCCESSFUL)
	{
		// push command line arguments
		writeCliArgs(targetProc, args);

		// set working directory
		SetWorkingDirectoryP(workdir, targetProc);

		// attached loaded process
		AttachCreatedProcess(targetProc, entryAddress);

		// out-set process id
		*outPid = targetPid;
		spawnStat = SPAWN_STATUS_SUCCESSFUL;

	}

	else
	{
		// cancel creation & let kernel clean up
		CancelProcessCreation(targetProc);

		if (ldrStat == LS_IO_ERROR) spawnStat = SPAWN_STATUS_IO_ERROR;
		else if (ldrStat == LS_FORMAT_ERROR) spawnStat = SPAWN_STATUS_FORMAT_ERROR;
		else if (ldrStat == LS_MEMORY_ERROR) spawnStat = SPAWN_STATUS_MEMORY_ERROR;
		else
		{
			klog("loader return unknown status on failure %i",  ldrStat);
			spawnStat = SPAWN_STATUS_UNKNOWN;
		}
	}

	// Close binary file
	Close(file);

	return spawnStat;
}