diff --git a/score/launch_manager/src/daemon/src/process_group_manager/details/BUILD b/score/launch_manager/src/daemon/src/process_group_manager/details/BUILD index f5188d441..1ecd13cb2 100644 --- a/score/launch_manager/src/daemon/src/process_group_manager/details/BUILD +++ b/score/launch_manager/src/daemon/src/process_group_manager/details/BUILD @@ -12,6 +12,23 @@ # ******************************************************************************* load("@rules_cc//cc:defs.bzl", "cc_library") +cc_library( + name = "configure_process", + srcs = ["configure_process.cpp"], + hdrs = ["configure_process.hpp"], + include_prefix = "score/mw/launch_manager/process_group_manager/details", + strip_include_prefix = "/score/launch_manager/src/daemon/src/process_group_manager/details", + visibility = ["//score/launch_manager/src/daemon/src/process_group_manager:__pkg__"], + deps = [ + "//score/launch_manager/src/daemon/src/osal:return_types", + "//score/launch_manager/src/daemon/src/osal:security_policy", + "//score/launch_manager/src/daemon/src/osal:set_affinity", + "//score/launch_manager/src/daemon/src/osal:set_groups", + "//score/launch_manager/src/daemon/src/osal:sys_exit", + "//score/launch_manager/src/daemon/src/process_group_manager:iprocess", + ], +) + cc_library( name = "process_info_node", hdrs = ["process_info_node.hpp"], @@ -98,13 +115,10 @@ cc_library( srcs = ["process_launcher.cpp"], visibility = ["//score/launch_manager/src/daemon/src/process_group_manager:__pkg__"], deps = [ + ":configure_process", "//score/launch_manager/src/daemon/src/common:log", "//score/launch_manager/src/daemon/src/control:control_client_channel", "//score/launch_manager/src/daemon/src/osal:ipc_comms", - "//score/launch_manager/src/daemon/src/osal:security_policy", - "//score/launch_manager/src/daemon/src/osal:set_affinity", - "//score/launch_manager/src/daemon/src/osal:set_groups", - "//score/launch_manager/src/daemon/src/osal:sys_exit", "//score/launch_manager/src/daemon/src/process_group_manager:iprocess", ], ) @@ -121,6 +135,7 @@ cc_library( ], visibility = ["//score/launch_manager/src/daemon/src/process_group_manager:__pkg__"], deps = [ + ":configure_process", ":graph", ":os_handler", ":process_info_node", diff --git a/score/launch_manager/src/daemon/src/process_group_manager/details/configure_process.cpp b/score/launch_manager/src/daemon/src/process_group_manager/details/configure_process.cpp new file mode 100644 index 000000000..b5cd35d1d --- /dev/null +++ b/score/launch_manager/src/daemon/src/process_group_manager/details/configure_process.cpp @@ -0,0 +1,149 @@ +/******************************************************************************** + * Copyright (c) 2026 Contributors to the Eclipse Foundation + * + * See the NOTICE file(s) distributed with this work for additional + * information regarding copyright ownership. + * + * This program and the accompanying materials are made available under the + * terms of the Apache License Version 2.0 which is available at + * https://www.apache.org/licenses/LICENSE-2.0 + * + * SPDX-License-Identifier: Apache-2.0 + ********************************************************************************/ + +#include + +#include +#include +#include +#include +#include +#include + +#include "score/launch_manager/src/daemon/src/osal/return_types.hpp" +#include "score/mw/launch_manager/osal/security_policy.hpp" +#include "score/mw/launch_manager/osal/set_affinity.hpp" +#include "score/mw/launch_manager/osal/set_groups.hpp" +#include "score/mw/launch_manager/process_group_manager/iprocess.hpp" + +namespace score +{ + +namespace lcm +{ + +namespace internal +{ + +void setLimit(const int resource, const std::size_t amount, const std::string_view rlimit_name) noexcept +{ + if (amount == 0U) + { + return; + } + + const struct rlimit limit{ + .rlim_cur = amount, + .rlim_max = amount, + }; + + const auto result = ::setrlimit(resource, &limit); + SCORE_LANGUAGE_FUTURECPP_ASSERT_MESSAGE( + result != -1, ("Failed to set rlimit " + std::string(rlimit_name) + ": " + std::strerror(errno)).c_str()); +} + +void setSchedulingAndSecurity(const osal::OsalConfig& config) +{ + int result; // Used for return value from system calls + + // Set process group id to be equal to the pid + // setpgid will fail if called by a session leader (which LCMd is), so skip + if (config.comms_type_ != osal::CommsType::kLaunchManager) + { + result = setpgid(0, getpid()); + SCORE_LANGUAGE_FUTURECPP_ASSERT_MESSAGE(result == 0, std::strerror(errno)); + } + + // Set scheduling policy with sched_setscheduler + /* RULECHECKER_comment(1, 1, check_union_object, "Union type defined in external library is used.", true) */ + sched_param sch_param{}; + + sch_param.sched_priority = config.scheduling_priority_; + + // TODO: Clamping should be done when the config is loaded + if (sch_param.sched_priority < sched_get_priority_min(config.scheduling_policy_)) + { + sch_param.sched_priority = sched_get_priority_min(config.scheduling_policy_); + } + else if (sch_param.sched_priority > sched_get_priority_max(config.scheduling_policy_)) + { + sch_param.sched_priority = sched_get_priority_max(config.scheduling_policy_); + } + + result = sched_setscheduler(0, config.scheduling_policy_, &sch_param); + SCORE_LANGUAGE_FUTURECPP_ASSERT_MESSAGE(result != -1, std::strerror(errno)); + + result = osal::setaffinity(config.cpu_mask_); + SCORE_LANGUAGE_FUTURECPP_ASSERT_MESSAGE(result != -1, std::strerror(errno)); + + result = setgid(config.gid_); + SCORE_LANGUAGE_FUTURECPP_ASSERT_MESSAGE(result != -1, std::strerror(errno)); + + // Note: the type of the first parameter of setgroups() differs in Linux and QNX, so we use osal + const auto gids_size = config.supplementary_gids_.size(); + if (gids_size > 0) + { + const auto gids_data = config.supplementary_gids_.data(); + result = osal::setgroups(gids_size, gids_data); + SCORE_LANGUAGE_FUTURECPP_ASSERT_MESSAGE(result != -1, std::strerror(errno)); + } + + result = setuid(config.uid_); + SCORE_LANGUAGE_FUTURECPP_ASSERT_MESSAGE(result != -1, std::strerror(errno)); +} + +void changeCurrentWorkingDirectory(const osal::OsalConfig& config) +{ + // Change current working directory to the same as the executable + constexpr size_t string_size = static_cast(PATH_MAX); + // Notice that this next static variable is duplicated by the fork() and so does not need + // any protection by a mutex although at first sight you may think it could need one. + static char path_copy[string_size + 1U] = {0}; + + // TODO: This should be validated when the config is loaded + SCORE_LANGUAGE_FUTURECPP_ASSERT_MESSAGE(config.executable_path_.size() < string_size, + "Executable path is too long"); + + const auto result = chdir(dirname(strncpy(path_copy, config.executable_path_.c_str(), string_size))); + SCORE_LANGUAGE_FUTURECPP_ASSERT_MESSAGE(result != -1, std::strerror(errno)); +} + +void implementMemoryResourceLimits(const osal::OsalConfig& config) +{ + setLimit(RLIMIT_DATA, config.resource_limits_.data_, "RLIMIT_DATA"); + setLimit(RLIMIT_AS, config.resource_limits_.as_, "RLIMIT_AS"); + setLimit(RLIMIT_STACK, config.resource_limits_.stack_, "RLIMIT_STACK"); + + // Note about cpu limit: + // Using setrlimit, this imposes a maximum time that a process will run for, which might not be + // what you intend? Probably you'll want a maximum time in a time-slice, but you don't get that + // with limits set by setrlimit... + setLimit(RLIMIT_CPU, config.resource_limits_.cpu_, "RLIMIT_CPU"); +} + +void changeSecurityPolicy(const osal::OsalConfig& config) +{ + if (config.security_policy_ != "") + { + const auto result = osal::setSecurityPolicy(config.security_policy_.c_str()); + SCORE_LANGUAGE_FUTURECPP_ASSERT_MESSAGE( + result == 0, + ("Changing security policy to " + config.security_policy_ + ": " + std::strerror(errno)).c_str()); + } +} + +} // namespace internal + +} // namespace lcm + +} // namespace score diff --git a/score/launch_manager/src/daemon/src/process_group_manager/details/configure_process.hpp b/score/launch_manager/src/daemon/src/process_group_manager/details/configure_process.hpp new file mode 100644 index 000000000..c56646241 --- /dev/null +++ b/score/launch_manager/src/daemon/src/process_group_manager/details/configure_process.hpp @@ -0,0 +1,48 @@ +/******************************************************************************** + * Copyright (c) 2026 Contributors to the Eclipse Foundation + * + * See the NOTICE file(s) distributed with this work for additional + * information regarding copyright ownership. + * + * This program and the accompanying materials are made available under the + * terms of the Apache License Version 2.0 which is available at + * https://www.apache.org/licenses/LICENSE-2.0 + * + * SPDX-License-Identifier: Apache-2.0 + ********************************************************************************/ + +#include + +#include "score/mw/launch_manager/osal/security_policy.hpp" +#include "score/mw/launch_manager/process_group_manager/iprocess.hpp" + +namespace score +{ + +namespace lcm +{ + +namespace internal +{ + +/// @brief Sets the limit if given a non-zero value, otherwise skips. +/// @warning This will abort if not successful. +void setLimit(const int resource, const std::size_t amount, const std::string_view rlimit_name); + +/// @warning This will abort if not successful. +void setSchedulingAndSecurity(const osal::OsalConfig& config); + +/// @warning This will abort if not successful. +void changeCurrentWorkingDirectory(const osal::OsalConfig& config); + +/// @warning This will abort if not successful. +void implementMemoryResourceLimits(const osal::OsalConfig& config); + +/// @warning This will abort if not successful. +void changeSecurityPolicy(const osal::OsalConfig& config); + +} // namespace internal + +} // namespace lcm + +} // namespace score diff --git a/score/launch_manager/src/daemon/src/process_group_manager/details/process_group_manager.cpp b/score/launch_manager/src/daemon/src/process_group_manager/details/process_group_manager.cpp index 4f45c09f7..753ff4752 100644 --- a/score/launch_manager/src/daemon/src/process_group_manager/details/process_group_manager.cpp +++ b/score/launch_manager/src/daemon/src/process_group_manager/details/process_group_manager.cpp @@ -16,6 +16,7 @@ #include #include +#include "score/launch_manager/src/daemon/src/process_group_manager/details/configure_process.hpp" #include "score/mw/launch_manager/common/log.hpp" #include "score/mw/launch_manager/process_group_manager/ialive_monitor_thread.hpp" #include "score/mw/launch_manager/process_group_manager/process_group_manager.hpp" @@ -104,10 +105,9 @@ bool ProcessGroupManager::initialize() return false; } - if (launch_manager_config_ && - OsalReturnType::kFail == IProcess::setSchedulingAndSecurity(launch_manager_config_->startup_config_)) + if (launch_manager_config_) { - return false; + setSchedulingAndSecurity(launch_manager_config_->startup_config_); } return true; diff --git a/score/launch_manager/src/daemon/src/process_group_manager/details/process_launcher.cpp b/score/launch_manager/src/daemon/src/process_group_manager/details/process_launcher.cpp index 1b7369578..0704b5c1c 100644 --- a/score/launch_manager/src/daemon/src/process_group_manager/details/process_launcher.cpp +++ b/score/launch_manager/src/daemon/src/process_group_manager/details/process_launcher.cpp @@ -11,8 +11,6 @@ * SPDX-License-Identifier: Apache-2.0 ********************************************************************************/ -#include - #include #include #include @@ -22,14 +20,12 @@ #include #include -#include "score/mw/launch_manager/process_group_manager/iprocess.hpp" -#include "score/mw/launch_manager/control/control_client_channel.hpp" +#include "score/launch_manager/src/daemon/src/process_group_manager/details/configure_process.hpp" #include "score/mw/launch_manager/common/log.hpp" +#include "score/mw/launch_manager/control/control_client_channel.hpp" #include "score/mw/launch_manager/osal/ipc_comms.hpp" #include "score/mw/launch_manager/osal/security_policy.hpp" -#include "score/mw/launch_manager/osal/set_affinity.hpp" -#include "score/mw/launch_manager/osal/set_groups.hpp" -#include "score/mw/launch_manager/osal/sys_exit.hpp" +#include "score/mw/launch_manager/process_group_manager/iprocess.hpp" #include #include #include @@ -44,37 +40,9 @@ namespace using score::lcm::internal::osal::CommsType; using score::lcm::internal::osal::IpcCommsSync; -using score::lcm::internal::osal::sysexit; - -/// @brief Applies the given limit. -/// @warning This will sysexit if the set is not succesful. -void applyLimitOrDie(const int resource, const rlimit& limit, const std::string_view rlimit_name) noexcept(false) -{ - if (::setrlimit(resource, &limit) == -1) - { - LM_LOG_FATAL() << "[New process] Failed to set rlimit " << rlimit_name << " " - << score::lcm::internal::errno_message(errno); - sysexit(EXIT_FAILURE); - } -} - -/// @brief Sets the limit if given a non-zero value, otherwise skips. -/// @warning This will sysexit if the set is not succesful. -void setLimit(const int resource, const std::size_t amount, const std::string_view rlimit_name) noexcept -{ - if (amount == 0U) - { - return; - } - - const struct rlimit limit{ - .rlim_cur = amount, - .rlim_max = amount, - }; - - applyLimitOrDie(resource, limit, rlimit_name); -} +using score::lcm::internal::osal::OsalConfig; +/// @warning This will abort if not successful. void handleComms(score::lcm::internal::osal::ChildProcessConfig& param) { // kNoComms !fd3 & !fd4 @@ -90,6 +58,8 @@ void handleComms(score::lcm::internal::osal::ChildProcessConfig& param) param.fd = dup2(param.fd, param.shared_block->sync_fd); // always make sure we are using fd=3 param.shared_block->pid_ = getpid(); // Store pid for check at client end + int result; // Used for return value from system calls + // It must be ensured that sync_fd (f3) and control_client_handler_nudge_fd (fd4) remain open depending on // the communication type. Flag FD_CLOEXEC is cleared conditionally to ensure that the // respective file descriptor remains open after the execve call. @@ -99,85 +69,51 @@ void handleComms(score::lcm::internal::osal::ChildProcessConfig& param) // in the current implementation this case means param.shared_block == nullptr and is handled above break; case CommsType::kReporting: - if (-1 == fcntl(IpcCommsSync::sync_fd, F_SETFD, 0)) - { - LM_LOG_ERROR() << "[New process] fcntl() at line" << __LINE__ - << "failed:" << score::lcm::internal::errno_message(errno); - sysexit(EXIT_FAILURE); - } + result = fcntl(IpcCommsSync::sync_fd, F_SETFD, 0); + SCORE_LANGUAGE_FUTURECPP_ASSERT_MESSAGE(result != -1, std::strerror(errno)); + close(IpcCommsSync::control_client_handler_nudge_fd); + break; case CommsType::kControlClient: - if (-1 == fcntl(IpcCommsSync::sync_fd, F_SETFD, 0)) - { - LM_LOG_ERROR() << "[New process] fcntl() at line" << __LINE__ - << "failed:" << score::lcm::internal::errno_message(errno); - sysexit(EXIT_FAILURE); - } - if (-1 == fcntl(IpcCommsSync::control_client_handler_nudge_fd, F_SETFD, 0)) - { - LM_LOG_ERROR() << "[New process] fcntl() at line" << __LINE__ - << "failed:" << score::lcm::internal::errno_message(errno); - } + result = fcntl(IpcCommsSync::sync_fd, F_SETFD, 0); + SCORE_LANGUAGE_FUTURECPP_ASSERT_MESSAGE(result != -1, std::strerror(errno)); + + result = fcntl(IpcCommsSync::control_client_handler_nudge_fd, F_SETFD, 0); + SCORE_LANGUAGE_FUTURECPP_ASSERT_MESSAGE(result != -1, std::strerror(errno)); + break; case CommsType::kLaunchManager: // nothing to do here break; default: - LM_LOG_ERROR() << "[New process] at line" << __LINE__ << "unknown CommsType" - << static_cast(param.shared_block->comms_type_); - sysexit(EXIT_FAILURE); + SCORE_LANGUAGE_FUTURECPP_UNREACHABLE_MESSAGE( + ("unknown CommsType " + std::to_string(static_cast(param.shared_block->comms_type_))) + .c_str()); break; } } -void changeCurrentWorkingDirectory(const score::lcm::internal::osal::OsalConfig& config) +bool validateConfig(const OsalConfig* config) { - // Change current working directory to the same as the executable - constexpr size_t string_size = static_cast(PATH_MAX); - // Notice that this next static variable is duplicated by the fork() and so does not need - // any protection by a mutex although at first sight you may think it could need one. - static char path_copy[string_size + 1U] = {0}; - - if (config.executable_path_.size() >= string_size) + if (access(config->executable_path_.c_str(), X_OK) != 0) { - LM_LOG_ERROR() << "[New process] executable path longer than" << string_size - << "chars:" << config.executable_path_; - sysexit(EXIT_FAILURE); + LM_LOG_ERROR() << "File does not exist or is not executable:" << config->executable_path_; + return false; } - if (-1 == chdir(dirname(strncpy(path_copy, config.executable_path_.c_str(), string_size)))) + if (config->scheduling_priority_ < sched_get_priority_min(config->scheduling_policy_)) { - LM_LOG_ERROR() << "[New process] chdir(" << config.executable_path_ - << ") failed:" << score::lcm::internal::errno_message(errno); - sysexit(EXIT_FAILURE); + LM_LOG_WARN() << "Scheduling priority" << config->scheduling_priority_ << "is below minimum for policy" + << config->scheduling_policy_; } -} - -void implementMemoryResourceLimits(const score::lcm::internal::osal::OsalConfig& config) -{ - setLimit(RLIMIT_DATA, config.resource_limits_.data_, "RLIMIT_DATA"); - setLimit(RLIMIT_AS, config.resource_limits_.as_, "RLIMIT_AS"); - setLimit(RLIMIT_STACK, config.resource_limits_.stack_, "RLIMIT_STACK"); - - // Note about cpu limit: - // Using setrlimit, this imposes a maximum time that a process will run for, which might not be - // what you intend? Probably you'll want a maximum time in a time-slice, but you don't get that - // with limits set by setrlimit... - setLimit(RLIMIT_CPU, config.resource_limits_.cpu_, "RLIMIT_CPU"); -} - -void changeSecurityPolicy(const score::lcm::internal::osal::OsalConfig& config) -{ - if (config.security_policy_ != "") + else if (config->scheduling_priority_ > sched_get_priority_max(config->scheduling_policy_)) { - if (score::lcm::internal::osal::setSecurityPolicy(config.security_policy_.c_str()) != 0) - { - LM_LOG_ERROR() << "[New process] changeSecurityPolicy(" << config.security_policy_ - << ") failed:" << score::lcm::internal::errno_message(errno); - sysexit(EXIT_FAILURE); - } + LM_LOG_WARN() << "Scheduling priority" << config->scheduling_priority_ << "is above maximum for policy" + << config->scheduling_policy_; } + + return true; } } // namespace @@ -200,11 +136,8 @@ OsalReturnType IProcess::startProcess(ProcessID* pid, IpcCommsP* block, const Os if ((pid && block && config && config->executable_path_ != "" && config->argv_[0U])) { - if (access(config->executable_path_.c_str(), X_OK) != 0) - { - LM_LOG_ERROR() << "File does not exist or is not executable:" << config->executable_path_; + if (!validateConfig(config)) return result; - } int fd = -1; *pid = -1; @@ -225,6 +158,16 @@ OsalReturnType IProcess::startProcess(ProcessID* pid, IpcCommsP* block, const Os if (*pid == kPosixSuccess) { + /* + Fork only copies the current thread, so from this point on we + could deadlock if we access anything that was locked by another + thread at the time of the fork. + + As such we should play it safe and use only basic functions. + This means assertions rather than logs for fatal errors, and + no logging at all on the happy path. + */ + ChildProcessConfig param = {config, fd, *block}; handleChildProcess(param); result = OsalReturnType::kSuccess; @@ -353,100 +296,20 @@ inline bool IProcess::initializeSemaphores(IpcCommsP shared_block) return result; } -OsalReturnType IProcess::setSchedulingAndSecurity(const OsalConfig& config) -{ - OsalReturnType retval = OsalReturnType::kSuccess; - - // Set process group id to be equal to the pid - // setpgid will fail if called by a session lader (which LCMd is), so skip - if (config.comms_type_ != osal::CommsType::kLaunchManager && 0 != setpgid(0, getpid())) - { - LM_LOG_ERROR() << "setpgid() failed:" << score::lcm::internal::errno_message(errno); - retval = OsalReturnType::kFail; - } - // Set scheduling policy with sched_setscheduler - /* RULECHECKER_comment(1, 1, check_union_object, "Union type defined in external library is used.", true) */ - sched_param sch_param{}; - - sch_param.sched_priority = config.scheduling_priority_; - - if (sch_param.sched_priority < sched_get_priority_min(config.scheduling_policy_)) - { - LM_LOG_WARN() << "Scheduling priority" << sch_param.sched_priority << "is below minimum for policy" - << config.scheduling_policy_ << ", setting to minimum"; - sch_param.sched_priority = sched_get_priority_min(config.scheduling_policy_); - } - else if (sch_param.sched_priority > sched_get_priority_max(config.scheduling_policy_)) - { - LM_LOG_WARN() << "Scheduling priority" << sch_param.sched_priority << "is above maximum for policy" - << config.scheduling_policy_ << ", setting to maximum"; - sch_param.sched_priority = sched_get_priority_max(config.scheduling_policy_); - } - - if (-1 == sched_setscheduler(0, config.scheduling_policy_, &sch_param)) - { - LM_LOG_ERROR() << "sched_setscheduler() failed:" << score::lcm::internal::errno_message(errno); - retval = OsalReturnType::kFail; - } - - // Set core affinity using OS specific functionality in osal - if (-1 == osal::setaffinity(config.cpu_mask_)) - { - LM_LOG_ERROR() << "setaffinity(" << config.cpu_mask_ - << ") failed:" << score::lcm::internal::errno_message(errno); - retval = OsalReturnType::kFail; - } - - // Set group ID - if (-1 == setgid(config.gid_)) - { - LM_LOG_ERROR() << "setgid(" << config.gid_ << ") failed:" << score::lcm::internal::errno_message(errno); - retval = OsalReturnType::kFail; - } - // Set supplementary group ids - size_t supplementary_gids_number = config.supplementary_gids_.size(); - - // Note: the type of the first parameter of setgroups() differs in Linux and QNX, so we use osal - if (supplementary_gids_number > 0 && - -1 == osal::setgroups(supplementary_gids_number, config.supplementary_gids_.data())) - { - LM_LOG_ERROR() << "setgroups() failed:" << score::lcm::internal::errno_message(errno); - retval = OsalReturnType::kFail; - } - - // Set user ID - if (-1 == setuid(config.uid_)) - { - LM_LOG_ERROR() << "setuid(" << config.uid_ << ") failed:" << score::lcm::internal::errno_message(errno); - retval = OsalReturnType::kFail; - } - - return retval; -} - +/// @warning This will abort if not successful. inline void IProcess::handleChildProcess(ChildProcessConfig& param) { handleComms(param); - if (OsalReturnType::kSuccess != setSchedulingAndSecurity(*param.config)) - { - sysexit(EXIT_FAILURE); - } - + setSchedulingAndSecurity(*param.config); changeCurrentWorkingDirectory(*param.config); implementMemoryResourceLimits(*param.config); changeSecurityPolicy(*param.config); // Finally, execute the process, passing all the arguments and environment variables - - // RULECHECKER_comment(1, 1, check_pointer_qualifier_cast_const, "Remove const for standard library with char type - // arguments.", true); - if (-1 == execve(param.config->argv_[0], const_cast(param.config->argv_.data()), param.config->envp_)) - { - LM_LOG_ERROR() << "[New process] execve failed: Unable to execute the" << param.config->executable_path_ - << "app. Error:" << score::lcm::internal::errno_message(errno); - sysexit(EXIT_FAILURE); - } + const auto result = + execve(param.config->argv_[0], const_cast(param.config->argv_.data()), param.config->envp_); + SCORE_LANGUAGE_FUTURECPP_ASSERT_MESSAGE(result != -1, std::strerror(errno)); } OsalReturnType IProcess::requestTermination(ProcessID pid) diff --git a/score/launch_manager/src/daemon/src/process_group_manager/iprocess.hpp b/score/launch_manager/src/daemon/src/process_group_manager/iprocess.hpp index 50ce8d2ab..c44826a37 100644 --- a/score/launch_manager/src/daemon/src/process_group_manager/iprocess.hpp +++ b/score/launch_manager/src/daemon/src/process_group_manager/iprocess.hpp @@ -130,11 +130,6 @@ class IProcess { OsalReturnType waitForkRunning(IpcCommsP sync, std::chrono::milliseconds timeout); - /// @brief This method will set up all the scheduling and security parameters described in the config, for the current process - /// @param config the configuration to use - /// @return kFail if any operation fails, kSuccess otherwise - static OsalReturnType setSchedulingAndSecurity(const osal::OsalConfig& config); - private: /// @brief Creates shared memory for communication between processes. /// @param[in,out] sync Pointer to a location to store a pointer to a structure containing