Remove unused directories and files in video_in_hal

The directory video_in_hal contained a lot of unnecessary
directories and files which supposed to have been accidentally
copied from staging/toyota.git druing migration.

Signed-off-by: Tadao Tanikawa <tanikawa.tadao@jp.panasonic.com>
Change-Id: I12f2d72562bc008080ae866831d966c0b751914c

1 files changed, 0 insertions, 1288 deletions

diff --git a/video_in_hal/nsframework/common_library/client/include/native_service/cl_process.h b/video_in_hal/nsframework/common_library/client/include/native_service/cl_process.h
deleted file mode 100755
index 6a9adbf..0000000
--- a/video_in_hal/nsframework/common_library/client/include/native_service/cl_process.h
+++ /dev/null
@@ -1,1288 +0,0 @@
-/*
- * @copyright Copyright (c) 2016-2020 TOYOTA MOTOR CORPORATION.
- *
- * 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.
- */
-
-#ifndef _cl_process_h_  // NOLINT(build/header_guard)
-#define _cl_process_h_  // NOLINT(build/header_guard)
-
-#include <sys/types.h>
-
-#define CL_PROCESSS_ATTR_HOLD_FDS_NUM 8
-
-#define CL_INTFY_FILENAME_FORMAT "/tmp/intfy_%05d"
-
-/////////////////////////////////////////////////////////////////////////////////////
-/// \ingroup CL_ProcessAttr_t
-/// \~english @par Brief
-///        Process attribute structure
-/////////////////////////////////////////////////////////////////////////////////////
-typedef struct {
-  char body[148];  ///< process attribute
-} CL_ProcessAttr_t;
-
-/////////////////////////////////////////////////////////////////////////////////////
-/// \ingroup CL_ProcessCleanupInfo_t
-/// \~english @par Brief
-///        Child-process attribute structure
-/////////////////////////////////////////////////////////////////////////////////////
-typedef struct {
-  pid_t pid;       ///< child-process ID
-  int code;        ///< signal code
-  int status;      ///< end status or signal
-} CL_ProcessCleanupInfo_t;
-
-/////////////////////////////////////////////////////////////////////////////////////
-/// \ingroup CL_ProcessSchedPolicy_t
-/// \~english @par Brief
-///        Schedule policy
-/////////////////////////////////////////////////////////////////////////////////////
-typedef enum {
-  CL_PROCESS_SCHED_POLICY_OTHER = 0,  ///< TSS
-  CL_PROCESS_SCHED_POLICY_RR,         ///< Round robin
-  CL_PROCESS_SCHED_POLICY_FIFO,       ///< FIFO
-} CL_ProcessSchedPolicy_t;
-
-typedef struct {
-  char body[20];
-} CL_ThreadAttr_t;
-
-/////////////////////////////////////////////////////////////////////////////////////
-/// \ingroup CL_ProcessCreateCgroupAttr_t
-/// Cgroup attribute structure
-/////////////////////////////////////////////////////////////////////////////////////
-typedef struct {
-  char body[24];  ///< Cgroup attribute
-} CL_ProcessCreateCgroupAttr_t;
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-/**
- * @file cl_process.h
- * @brief \~english This file contains the base api,enum and struct of cl_process.
- */
-
-/** @addtogroup BaseSystem
- *  @{
- */
-/** @addtogroup native_service
- *  @ingroup BaseSystem
- *  @{
- */
-/** @addtogroup common_library
- *  @ingroup native_service
- *  @{
- */
-
-/////////////////////////////////////////////////////////////////////////////////////
-/// \ingroup CL_ProcessInit
-/// \~english @par Brief
-///        Initialize the process
-/// \~english @retval int file  descriptor
-/// \~english @retval -1 Error
-/// \~english @par Prerequisite
-///        - Prerequisites are nothing.
-/// \~english @par Change of internal state
-///        - Change of internal state according to the API does not occur.
-/// \~english @par Conditions of processing failure
-///        - Failed to set up process prctl, -1 is returned.
-///        - Failed to set the signal set to the empty set sigemptyset, -1 is returned.
-///        - Failed to add a signal to the signal mask sigaddset, -1 is returned.
-///        - Failed to set sigprocmask, -1 is returned.
-///        - Failed to create a scripter in the file for signal acceptance signalfd, -1 is returned.
-/// \~english @par Detail
-///        This API must be called before createing a thread.
-///        Therefore, it is recommended that this API be called from within the main() function immediately after the API started.\n
-///        Initialize the process.\n
-///        The retuen value fd is assumed to be poll/select and used for waiting for event.\n
-///        An ready occurs when the child process terminates.\n
-///        Call process name setting(\ref CL_ProcessCreateAttrSetName) uniformly
-///        because it is applied only to the number of architecture after exec.\n
-/// \~english @par Classification
-///        Public
-/// \~english @par Type
-///        No match
-/// \~english @see
-///        none
-////////////////////////////////////////////////////////////////////////////////////
-int CL_ProcessInit(void);  // NOLINT(readability/nolint)
-
-/////////////////////////////////////////////////////////////////////////////////////
-/// \ingroup CL_ProcessCreate
-/// \~english @par Brief
-///        Create the process
-/// \~english @param [in] file
-///        const char*   -
-/// \~english @param [in] argv[]
-///        char* const  -
-/// \~english @param [in] envp[]
-///        char* const
-/// \~english @param [in] attr
-///        const CL_ProcessAttr_t* - Process attribute pointer
-/// \~english @par
-///        CL_ProcessAttr_t struct
-/// \~english @code
-///                 typedef struct {
-///                   char body[148];
-///                 } CL_ProcessAttr_t;
-///            @endcode
-/// \~english @retval int Success(PID)
-/// \~english @retval -1 Error
-/// \~english @par Prerequisite
-///        - Need to be running CL_ProcessInit.
-///        - Initialize attr with CL_ProcessCreateAttrInit.
-/// \~english @par Change of internal state
-///        - Change of internal state according to the API does not occur.
-/// \~english @par Conditions of processing failure
-///        - When the executable name (file) in the argument is NULL, set errno to EINVAL, -1 is returned.
-///        - When the ARG parameter (argv[]) in the argument is NULL, set errno to EINVAL, -1 is returned.
-///        - When the pointer of the process attribute specified (attr) in the argument is NULL,
-///          set errno to EINVAL, -1 is returned.
-///        - When memory (malloc) of the data storagee area of the environment variable parameter (envp[]) specified
-///          by the arguments fails, set errno to EINVAL, -1 is returned.
-///        - When memory (malloc) of the data control area of the environment variable parameter (envp[]) specified
-///          by the arguments fails, set errno to EINVAL, -1 is returned.
-///        - Process creation (fork) fail, -1 is returned.
-///        - Process CPU affinity masking (sched_setaffinity) fail, -1 is returned.
-///        - When the character string output processing (snprintf) for process creation fail, -1 is returned.
-///        - When the character string output processing (snprintf) for PID setting of cgroup fail, -1 is returned.
-///        - Failure to allocate the area fo sstoring the path name of cgroup (malloc), -1 is returned.
-///        - Failure to open file descriptor (open) of cgroup, -1 is returned.
-///        - Failure to write file descriptor (write) of cgroup, -1 is returned.
-/// \~english @par Detail
-///        - This API must be called before createing a thread.
-/// \~english @par
-///        Create the process.\n
-///        The ARG parameter (argv[]) specified in the argment must satisfy the following conditions:\n
-///        - Can not be omitted.\n
-///        - The first argument must specify a pointer o the filename to be executed.\n
-///        - An array of pointer to NULL terminated strings.\n
-///        - Arrays must be terminated by NULL pointer.\n
-/// \~english @par
-///        Enviroment-variable parameters (envp[]) specified in arguments mus satisfy the following condiions:\n
-///        - When NULL is specified, the parent process inherits the parent process's environment variables.\n
-///        - An array of pointer to NULL terminated strings.\n
-///        - Arrays must be terminated by NULL pointer.\n
-/// \~english @par
-///        Be aware of the following.\n
-///        - Processing continues without interrupting event if setrlimit() fail.\n
-///        - System call access() checks whether or not there is access privilege,
-///          but returns PID regardless of the access privilege status.
-///          (If the process does not have access privilege, 100 retries are executed at 100 microseconds.)
-/// \~english @par
-///        Since the process attribute of a process cannot be changed during processing,
-///        if it is necessary to change the process attribute,
-///        it is necessary to call the following API and change the process attribute before calling this API.\n
-///          - CL_ProcessCreateAttrInit Initialize process attribute
-///          - CL_ProcessCreateAttrSetCgroup Setting process attribute (Cgroup)
-///          - CL_ProcessCreateAttrSetDisableCloseFds Setting process attribute (stop compulsion FD close)
-///          - CL_ProcessCreateAttrSetGid Setting process attribute (group ID)
-///          - CL_ProcessCreateAttrSetGroup Setting process attribute (process group)
-///          - CL_ProcessCreateAttrSetHoldFds Setting process attribute (maintain FD)
-///          - CL_ProcessCreateAttrSetName Setting process attribute (process name)
-///          - CL_ProcessCreateAttrSetSchedule Setting process attribute (schedule policy and priority)
-///          - CL_ProcessCreateAttrSetStackSize Setting process attribute (Stack Size)
-///          - CL_ProcessCreateAttrSetUid Setting process attribute (user ID)
-/// \~english @par Classification
-///        Public
-/// \~english @par Type
-///        Open Close
-/// \~english @see
-///        CL_ProcessTerminate, CL_ProcessTerminateGroup
-///        CL_ProcessCreateAttrInit, CL_ProcessCreateAttrSetCgroup,
-///        CL_ProcessCreateAttrSetDisableCloseFds, CL_ProcessCreateAttrSetGid,
-///        CL_ProcessCreateAttrSetGroup, CL_ProcessCreateAttrSetHoldFds,
-///        CL_ProcessCreateAttrSetName, CL_ProcessCreateAttrSetSchedule,
-///        CL_ProcessCreateAttrSetStackSize, CL_ProcessCreateAttrSetUid
-////////////////////////////////////////////////////////////////////////////////////
-int CL_ProcessCreate(const char *file, char * const argv[], char * const envp[],  // NOLINT(readability/nolint)
-                     const CL_ProcessAttr_t *attr);
-
-////////////////////////////////////////////////////////////////////////////////////
-/// \ingroup CL_ProcessCreateAttrInit
-/// \~english @par Brief
-///        Initialize process attribute
-/// \~english @param [out] attr
-///        const CL_ProcessAttr_t* - Process attribute pointer
-/// \~english @par
-///        CL_ProcessAttr_t struct
-/// \~english @code
-///                 typedef struct {
-///                   char body[148];
-///                 } CL_ProcessAttr_t;
-///            @endcode
-/// \~english @retval 0 Success
-/// \~english @retval -1 Error
-/// \~english @par Prerequisite
-///        - Prerequisites are nothing.
-/// \~english @par Change of internal state
-///        - Change of internal state according to the API does not occur.
-/// \~english @par Conditions of processing failure
-///        - When the pointer of the process attribute specified (attr) in the argument is NULL,
-///          set errno to EINVAL, -1 is returned.
-/// \~english @par Detail
-///        Initilize the CL_ProcessAttr_t structure that stores process attribute.\n
-/// \~english @par Classification
-///        Public
-/// \~english @par Type
-///        Method(Async) / Fire and Forget / Broadcast / Sync / Set Get / Open Close / Request Notify / No match
-/// \~english @see
-///        none
-////////////////////////////////////////////////////////////////////////////////////
-int CL_ProcessCreateAttrInit(CL_ProcessAttr_t *attr);  // NOLINT(readability/nolint)
-
-////////////////////////////////////////////////////////////////////////////////////
-/// \ingroup CL_ProcessCreateAttrSetName
-/// \~english @par Brief
-///        Set process name in process attribute
-/// \~english @param [in,out] attr
-///        const CL_ProcessAttr_t* - Process attribute pointer
-/// \~english @param [in] name
-///        const char*   - process name (max length 16byte)
-/// \~english @par
-///        CL_ProcessAttr_t struct
-/// \~english @code
-///                 typedef struct {
-///                   char body[148];
-///                 } CL_ProcessAttr_t;
-///            @endcode
-/// \~english @retval 0 Success
-/// \~english @retval -1 Error
-/// \~english @par Prerequisite
-///        - Initialize attr with CL_ProcessCreateAttrInit.
-/// \~english @par Change of internal state
-///        - Change of internal state according to the API does not occur.
-/// \~english @par Conditions of processing failure
-///        - When the pointer of the process attribute specified (attr) in the argument is NULL,
-///          set errno to EINVAL, -1 is returned.
-///        - When the pointer (name) to the character string hat stores the process name specified
-///          by the argument is NULL, set errno to EINVAL, -1 is returned.
-/// \~english @par Detail
-///        Set process name to process attribute.\n
-///        The charactr string that stores the process name specified by the argument must satisfy the following conditions:\n
-///        - Terminated by a NULL.\n
-///        - The maximum lengthof character string is 16 byte including the termination character.\n
-/// \~english @par Classification
-///        Public
-/// \~english @par Type
-///        No match
-/// \~english @see
-///        none
-////////////////////////////////////////////////////////////////////////////////////
-int CL_ProcessCreateAttrSetName(CL_ProcessAttr_t *attr, const char *name);  // NOLINT(readability/nolint)
-
-////////////////////////////////////////////////////////////////////////////////////
-/// \ingroup CL_ProcessCreateAttrSetUid
-/// \~english @par Brief
-///        Set process attribute to user ID
-/// \~english @param [in,out] attr
-///        const CL_ProcessAttr_t* - Process attribute pointer
-/// \~english @param [in] uid
-///        uid_t   - user ID
-/// \~english @par
-///        CL_ProcessAttr_t struct
-/// \~english @code
-///                 typedef struct {
-///                   char body[148];
-///                 } CL_ProcessAttr_t;
-///            @endcode
-/// \~english @retval 0 Success
-/// \~english @retval -1 Error
-/// \~english @par Prerequisite
-///        - Initialize attr with CL_ProcessCreateAttrInit.
-/// \~english @par Change of internal state
-///        - Change of internal state according to the API does not occur.
-/// \~english @par Conditions of processing failure
-///        - When the pointer of the process attribute specified (attr) in the argument is NULL,
-///          set errno to EINVAL, -1 is returned.
-/// \~english @par Detail
-///        Set process attribute to user ID.\n
-///        When UINT_MAX is set for the user ID,
-///        the user ID is set to 0 in the process attribute in the processing of CL_ProcessCreate().\n
-///        When 0 is set for the user ID,
-///        it is not reflected in the process attribute becose if is played by the process of CL_ProcessCreate().\n
-/// \~english @par Classification
-///        Public
-/// \~english @par Type
-///        No match
-/// \~english @see
-///        none
-////////////////////////////////////////////////////////////////////////////////////
-int CL_ProcessCreateAttrSetUid(CL_ProcessAttr_t *attr, uid_t uid);  // NOLINT(readability/nolint)
-
-////////////////////////////////////////////////////////////////////////////////////
-/// \ingroup CL_ProcessCreateAttrSetGid
-/// \~english @par Brief
-///        Set process attribute to group ID
-/// \~english @param [in,out] attr
-///        const CL_ProcessAttr_t* - Process attribute pointer
-/// \~english @param [in] gid
-///        gid_t   - Group ID
-/// \~english @par
-///        CL_ProcessAttr_t struct
-/// \~english @code
-///                 typedef struct {
-///                   char body[148];
-///                 } CL_ProcessAttr_t;
-///            @endcode
-/// \~english @retval 0 Success
-/// \~english @retval -1 Error
-/// \~english @par Prerequisite
-///        - Initialize attr with CL_ProcessCreateAttrInit.
-/// \~english @par Change of internal state
-///        - Change of internal state according to the API does not occur.
-/// \~english @par Conditions of processing failure
-///        - When the pointer of the process attribute specified (attr) in the argument is NULL,
-///          set errno to EINVAL, -1 is returned.
-/// \~english @par Detail
-///        Set process attribute to group ID.\n
-///        When 0 is set for the group ID,
-///        it is not reflected in the process attribute becose if is played by the process of CL_ProcessCreate().\n
-/// \~english @par Classification
-///        Public
-/// \~english @par Type
-///        No match
-/// \~english @see
-///        none
-////////////////////////////////////////////////////////////////////////////////////
-int CL_ProcessCreateAttrSetGid(CL_ProcessAttr_t *attr, gid_t gid);  // NOLINT(readability/nolint)
-
-////////////////////////////////////////////////////////////////////////////////////
-/// \ingroup CL_ProcessCreateAttrSetSchedule
-/// \~english @par Brief
-///        Set process attribute to schedule policy and priority
-/// \~english @param [in,out] attr
-///        const CL_ProcessAttr_t* - Process attribute pointer
-/// \~english @param [in] policy
-///        CL_ProcessSchedPolicy_t   - schedule policy
-/// \~english @param [in] priority
-///        int   - priority
-/// \~english @par
-///        CL_ProcessAttr_t struct
-/// \~english @code
-///                 typedef struct {
-///                   char body[148];
-///                 } CL_ProcessAttr_t;
-///            @endcode
-/// \~english @par
-///        enum CL_ProcessSchedPolicy_t Variable
-/// \~english @code
-///                 typedef enum {
-///                   CL_PROCESS_SCHED_POLICY_OTHER = 0,  // TSS
-///                   CL_PROCESS_SCHED_POLICY_RR,         // Round-robin
-///                   CL_PROCESS_SCHED_POLICY_FIFO,       // FIFO
-///                 } CL_ProcessSchedPolicy_t;
-///            @endcode
-/// \~english @par
-///        target to priority
-///        - -20~19 : CL_PROCESS_SCHED_POLICY_OTHER
-///        -   1~99 : CL_PROCESS_SCHED_POLICY_RR or CL_PROCESS_SCHED_POLICY_FIFO
-/// \~english @retval 0 Success
-/// \~english @retval -1 Error
-/// \~english @par Prerequisite
-///        - Initialize attr with CL_ProcessCreateAttrInit.
-/// \~english @par Change of internal state
-///        - Change of internal state according to the API does not occur.
-/// \~english @par Conditions of processing failure
-///        - When the pointer of the process attribute specified (attr) in the argument is NULL,
-///          set errno to EINVAL, -1 is returned.
-///        - When the schedule policy (policy) specified in the parameter is CL_PROCESS_SCHED_POLICY_RR
-///          and the priority (priority) is other than 1 to 99, set errno to EINVAL, -1 is returned.
-///        - When the schedule policy (policy) specified in the parameter is CL_PROCESS_SCHED_POLICY_FIFO
-///          and the priority (priority) is other than 1 to 99, set errno to EINVAL, -1 is returned.
-///        - Incorrect parameters are specified for the schedule policy (policy) specified in the arguments,
-///          set errno to EINVAL, -1 is returned.
-/// \~english @par Detail
-///        Set process attribute to schedule policy and priority.\n
-///        Error occur if the real-time schedule policy is set and
-///        the priority is passed value outside the range of 1-99.\n
-///        In the case of TSS, an error does not occur even if it is outside the range of -20 to 19,
-///        but ti is rounded to the nearest integer by a system call when a process is created.\n
-///        If not set by this funtion, the schedule policy set the TSS and priority sets 0.\n
-/// \~english @par Classification
-///        Public
-/// \~english @par Type
-///        No match
-/// \~english @see
-///        none
-////////////////////////////////////////////////////////////////////////////////////
-int CL_ProcessCreateAttrSetSchedule(CL_ProcessAttr_t *attr,  // NOLINT(readability/nolint)
-                                    CL_ProcessSchedPolicy_t policy,
-                                    int priority);
-
-////////////////////////////////////////////////////////////////////////////////////
-/// \ingroup CL_ProcessCreateAttrSetGroup
-/// \~english @par Brief
-///        Set process attribute to process group
-/// \~english @param [in,out] attr
-///        const CL_ProcessAttr_t* - Process attribute pointer
-/// \~english @param [in] create
-///        int   - (0 or 1)
-/// \~english @par
-///        - 1  make
-///        - 0  not make(default)
-/// \~english @par
-///        CL_ProcessAttr_t struct
-/// \~english @code
-///                 typedef struct {
-///                   char body[148];
-///                 } CL_ProcessAttr_t;
-///            @endcode
-/// \~english @retval 0 Success
-/// \~english @retval -1 Error
-/// \~english @par Prerequisite
-///        - Initialize attr with CL_ProcessCreateAttrInit.
-/// \~english @par Change of internal state
-///        - Change of internal state according to the API does not occur.
-/// \~english @par Conditions of processing failure
-///        - When the pointer of the process attribute specified (attr) in the argument is NULL,
-///          set errno to EINVAL, -1 is returned.
-///        - When a value oher than 0 or 1 is secified for the process group cration flag (create)
-///          specified in the parameter, set errno to EINVAL, -1 is returned.
-/// \~english @par Detail
-///        Set process attribute to process group.\n
-///        When a process group is created, all descendant process fork from child process also belong
-///        to the same process group, and the entire process group can be forcibly terminated.\n
-/// \~english @par Classification
-///        Public
-/// \~english @par Type
-///        No match
-/// \~english @see
-///        none
-////////////////////////////////////////////////////////////////////////////////////
-int CL_ProcessCreateAttrSetGroup(CL_ProcessAttr_t *attr, int create);  // NOLINT(readability/nolint)
-
-int CL_ProcessCreateAttrSetCpuAssign(CL_ProcessAttr_t *attr, int cpu_assign);  // NOLINT(readability/nolint)
-
-////////////////////////////////////////////////////////////////////////////////////
-/// \ingroup CL_ProcessCreateAttrSetStackSize
-/// \~english @par Brief
-///        Set process attribute to stack size
-/// \~english @param [in,out] attr
-///        const CL_ProcessAttr_t* - Process attribute pointer
-/// \~english @param [in] stack_size
-///        int   - stack size(byte)
-/// \~english @par
-///        CL_ProcessAttr_t struct
-/// \~english @code
-///                 typedef struct {
-///                   char body[148];
-///                 } CL_ProcessAttr_t;
-///            @endcode
-/// \~english @retval 0 Success
-/// \~english @retval -1 Error
-/// \~english @par Prerequisite
-///        - Initialize attr with CL_ProcessCreateAttrInit.
-/// \~english @par Change of internal state
-///        - Change of internal state according to the API does not occur.
-/// \~english @par Conditions of processing failure
-///        - When the pointer of the process attribute specified (attr) in the argument is NULL,
-///          set errno to EINVAL, -1 is returned.
-/// \~english @par Detail
-///        Set process attribute to stack size.\n
-///        The muximum configurable stack size is 1MB.\n
-/// \~english @par Classification
-///        Public
-/// \~english @par Type
-///        No match
-/// \~english @see
-///        none
-////////////////////////////////////////////////////////////////////////////////////
-int CL_ProcessCreateAttrSetStackSize(CL_ProcessAttr_t *attr, int stack_size);  // NOLINT(readability/nolint)
-
-////////////////////////////////////////////////////////////////////////////////////
-/// \ingroup CL_ProcessCreateAttrSetHoldFds
-/// \~english @par Brief
-///        Set process attribute to FD to maintain
-/// \~english @param [in,out] attr
-///        const CL_ProcessAttr_t* - Process attribute pointer
-/// \~english @param [in] hold_fds[]
-///        int   -
-/// \~english @par
-///        CL_ProcessAttr_t struct
-/// \~english @code
-///                 typedef struct {
-///                   char body[148];
-///                 } CL_ProcessAttr_t;
-///            @endcode
-/// \~english @retval 0 Success
-/// \~english @retval -1 Error
-/// \~english @par Prerequisite
-///        - Initialize attr with CL_ProcessCreateAttrInit.
-/// \~english @par Change of internal state
-///        - Change of internal state according to the API does not occur.
-/// \~english @par Conditions of processing failure
-///        - When the pointer of the process attribute specified (attr) in the argument is NULL,
-///          set errno to EINVAL, -1 is returned.
-///        - When the array (hode_openfd[]) storing the list of the FD to be maintained specified
-///          by the arguments is NULL, set errno to EINVAL, -1 is returned.
-/// \~english @par Detail
-///        Set process attribute to FD to maintain.\n
-///        When nothing is set, FD other than 0, 1, and 2 are automatically close.\n
-///        For hold_openfds is stored in a CL_PROCESSS_ATTR_HOLD_FDS_NUM array,
-///        it is recommended that int hold_openfds[CL_PROCESSS_ATTR_HOLD_FDS_NUM] be used.\n
-/// \~english @par Classification
-///        Public
-/// \~english @par Type
-///        No match
-/// \~english @see
-///        none
-////////////////////////////////////////////////////////////////////////////////////
-int CL_ProcessCreateAttrSetHoldFds(CL_ProcessAttr_t *attr, int hold_fds[]);  // NOLINT(readability/nolint)
-
-////////////////////////////////////////////////////////////////////////////////////
-/// \ingroup CL_ProcessCreateAttrSetDisableCloseFds
-/// \~english @par Brief
-///        Set process attribute to suspend forced FD close
-/// \~english @param [in,out] attr
-///        const CL_ProcessAttr_t* - Process attribute pointer
-/// \~english @par
-///        CL_ProcessAttr_t struct
-/// \~english @code
-///                 typedef struct {
-///                   char body[148];
-///                 } CL_ProcessAttr_t;
-///            @endcode
-/// \~english @retval 0 Success
-/// \~english @retval -1 Error
-/// \~english @par Prerequisite
-///        - Initialize attr with CL_ProcessCreateAttrInit.
-/// \~english @par Change of internal state
-///        - Change of internal state according to the API does not occur.
-/// \~english @par Conditions of processing failure
-///        - When the pointer of the process attribute specified (attr) in the argument is NULL,
-///          set errno to EINVAL, -1 is returned.
-/// \~english @par Detail
-///        Set process attribute to suspend forced FD close.\n
-/// \~english @par Classification
-///        Public
-/// \~english @par Type
-///        No match
-/// \~english @see
-///        none
-////////////////////////////////////////////////////////////////////////////////////
-int CL_ProcessCreateAttrSetDisableCloseFds(CL_ProcessAttr_t *attr);  // NOLINT(readability/nolint)
-
-////////////////////////////////////////////////////////////////////////////////////
-/// \ingroup CL_ProcessCreateAttrSetCgroup
-/// \~english @par Brief
-///        Set process attribute to Cgroup
-/// \~english @param [in,out] attr
-///        const CL_ProcessAttr_t* - Process attribute pointer
-/// \~english @param [in] cgroup_name
-///        const char*   - Cgroup name
-/// \~english @par
-///        CL_ProcessAttr_t struct
-/// \~english @code
-///                 typedef struct {
-///                   char body[148];
-///                 } CL_ProcessAttr_t;
-///            @endcode
-/// \~english @retval 0 Success
-/// \~english @retval -1 Error
-/// \~english @par Prerequisite
-///        - Initialize attr with CL_ProcessCreateAttrInit.
-///        - cgroup specified by CL_ProcessCreateCgroupCreate() has been created.
-/// \~english @par Change of internal state
-///        - Change of internal state according to the API does not occur.
-/// \~english @par Conditions of processing failure
-///        - When the pointer of the process attribute specified (attr) in the argument is NULL,
-///          set errno to EINVAL, -1 is returned.
-///        - When the pointer (name) to the character string hat stores the process name specified
-///          by the argument is NULL, set errno to EINVAL, -1 is returned.
-///        - When the character string length of the character string (cgroup_name) storing the process name specified
-///          by the argument is 64 byte or more, set errno to EINVAL, -1 is returned.
-/// \~english @par Detail
-///        Set process attribute to Cgroup.\n
-///        Creat new Cgroup with CL_ProcessCreateCgroupCreate().\n
-///        An error occurs if an Cgroup name that does not exist is specified.\n
-/// \~english @par Classification
-///        Public
-/// \~english @par Type
-///        No match
-/// \~english @see
-///        none
-////////////////////////////////////////////////////////////////////////////////////
-int CL_ProcessCreateAttrSetCgroup(CL_ProcessAttr_t *attr,  // NOLINT(readability/nolint)
-                                  const char *cgroup_name);
-
-/////////////////////////////////////////////////////////////////////////////////////
-/// \ingroup CL_ProcessTerminate
-/// \~english @par Brief
-///        Kill the process
-/// \~english @param [in] pid
-///        pid_t - PID
-/// \~english @retval int file  descriptor
-/// \~english @retval -1 Error
-/// \~english @par Prerequisite
-///        - CL_ProcessInit and CL_ProcessCreate must be running.
-///          (Process ID to be forcibly terminated exists)
-/// \~english @par Change of internal state
-///        - Change of internal state according to the API does not occur.
-/// \~english @par Conditions of processing failure
-///        - When the process ID to be forcibly terminated does not exist, -1 is returned.
-/// \~english @par Detail
-///        The PID of the process is he return value (PID) of CL_ProcessCreate().
-/// \~english @par Classification
-///        Public
-/// \~english @par Type
-///        Open Close
-/// \~english @see
-///        CL_ProcessCreate
-/////////////////////////////////////////////////////////////////////////////////////
-int CL_ProcessTerminate(pid_t pid);  // NOLINT(readability/nolint)
-
-/////////////////////////////////////////////////////////////////////////////////////
-/// \ingroup CL_ProcessTerminateGroup
-/// \~english @par Brief
-///        Kill process group
-/// \~english @param [in] pid
-///        pid_t - process group ID
-/// \~english @retval int file descriptor
-/// \~english @retval -1 Error
-/// \~english @par Prerequisite
-///        - CL_ProcessInit and CL_ProcessCreate must be running.
-///          (Process ID to be forcibly terminated exists)
-/// \~english @par Change of internal state
-///        - Change of internal state according to the API does not occur.
-/// \~english @par Conditions of processing failure
-///        - When the process ID to be forcibly terminated does not exist, -1 is returned.
-/// \~english @par Detail
-///        The process group ID is he return value (PID) of CL_ProcessCreate().
-/// \~english @par Classification
-///        Public
-/// \~english @par Type
-///        Open Close
-/// \~english @see
-///        CL_ProcessCreate
-/////////////////////////////////////////////////////////////////////////////////////
-int CL_ProcessTerminateGroup(pid_t pid);  // NOLINT(readability/nolint)
-
-int CL_ProcessAbort(pid_t pid);  // NOLINT(readability/nolint)
-
-int CL_ProcessAbortGroup(pid_t pid);  // NOLINT(readability/nolint)
-
-int CL_ProcessEuthanizeGroup(pid_t pid);  // NOLINT(readability/nolint)
-
-/////////////////////////////////////////////////////////////////////////////////////
-/// \ingroup CL_ProcessCleanup
-/// \~english @par Brief
-///        Collect child process
-/// \~english @param [in] sigchld_fd
-///        int - CL_ProcessInit() function return to fd
-/// \~english @param [out] cleanup_info
-///        CL_ProcessCleanupInfo_t* - Pointer to chiled process info
-/// \~english @par
-///        CL_ProcessCleanupInfo_t struct
-/// \~english @code
-///                 typedef struct {
-///                   pid_t pid;                /* The process ID of the child. */
-///                   int code;                 /* signal code */
-///                   int status;               /* the exit status of the child or the signal */
-///                 } CL_ProcessCleanupInfo_t;
-///            @endcode
-/// \~english @retval 0  Success
-/// \~english @retval 1  Success
-///        (If WNOHANG was specified and no child(ren) specified by id has yet changed state)
-/// \~english @retval -1 Error (setting to errno)
-/// \~english @par Prerequisite
-///        - Must be runnning CL_ProcessInit.
-/// \~english @par Change of internal state
-///        - Change of internal state according to the API does not occur.
-/// \~english @par Conditions of processing failure
-///        - When the pointer (cleanup_info) to the child process information structure is NULL,
-///          set errno to EINVAL, -1 is returned.
-///        - When a systemu call (waitid) fails, -1 is returned.
-///        - When there are no child process in state waitable, set errno to EINVAL, -1 is returned.
-/// \~english @par Detail
-///        This API must be called before createing a thread.\n
-/// \~english @par
-///        It must be called many times while the return valu is 1.
-///        After the return value reaches 0, calling it again results in an error (ECHILD).\n
-///        The code of CL_ProcessCleanupInfo_t cotains the following value:\n
-///          - CLD_EXITED : Finished child process (exited)
-///          - CLD_KILLED : Killed child process
-///          - CLD_DUMPED : Ended abnormally child process
-///          - CLD_TRAPPED : Trapped traced child process
-///          - CLD_STOPPED : Stopped child process (stop)
-///          - CLD_CONTINUED restarted the sopped child process (after Linux 2.6.9)
-///          - The exit status is stored in status only when code is CLD_EXITED. Otherwise, signals are stored.
-///          - Need to include signal.h to use CLD_*.
-/// \~english @par Classification
-///        Public
-/// \~english @par Type
-///        No match
-/// \~english @see
-///        none
-////////////////////////////////////////////////////////////////////////////////////
-int CL_ProcessCleanup(int sigchld_fd, CL_ProcessCleanupInfo_t *cleanup_info);  // NOLINT(readability/nolint)
-
-////////////////////////////////////////////////////////////////////////////////////
-/// \ingroup CL_ThreadCreate
-/// \~english @par Brief
-///        Create thread
-/// \~english @param [out] thread
-///        pthread_t*   - thread hadle
-/// \~english @param [in] attr
-///        pthread_attr_t*   - Thread attibute pointer for pthread
-/// \~english @param [in] cl_attr
-///        CL_ThreadAttr_t*   - Tred attribute pointer for expansion
-/// \~english @param [in] start_routine
-///        void*(*)(void*)   - Pointer to the entry function of the thread
-/// \~english @param [in] arg
-///        void*   - Argument to the entry function of the thread
-/// \~english @par
-///        CL_ThreadAttr_t structure
-/// \~english @code
-///                 typedef struct {
-///                   char body[20];
-///                 } CL_ThreadAttr_t;
-///            @endcode
-/// \~english @retval 0 Success
-/// \~english @retval -1 Error (set errno)
-/// \~english @retval EAGAIN failure to create thread
-/// \~english @par Prerequisite
-///        - Prerequisites are nothing.
-/// \~english @par Change of internal state
-///        - Change of internal state according to the API does not occur.
-/// \~english @par Conditions of processing failure
-///       - When the thread handler (thread) specified in the argument is NULL, set errno to EINVAL, -1 is returned.
-///       - When the pointer of the thread attribute specified in the argument is NULL,
-///         set errno to EINVAL, -1 is returned.
-///       - When the pointer (start_routine) of the entry function of the thread specified by the argument is NULL,
-///         set errno to EINVAL, -1 is returned.
-///       - Failure to initialize semaphore, set errno to sem_init, -1 is returned.
-///       - Failure to create thread (pthread_create), EAGAIN is returned.
-///       - Failure to rock semaphore (sem_wait), set errno to sem_init, -1 is returned.
-/// \~english @par Detail
-///        Create thread.\n
-///        The extension thread attribute (cl_attr) is used o assign the thread name set
-///        by CL_ThreadCreateAttrSetName(CL_ThreadAttr_t*, const char*).\n
-/// \~english @par Classification
-///        Public
-/// \~english @see
-///        none
-////////////////////////////////////////////////////////////////////////////////////
-int CL_ThreadCreate(pthread_t *thread, pthread_attr_t *attr,  // NOLINT(readability/nolint)
-                    CL_ThreadAttr_t *cl_attr, void *(*start_routine)(void *),
-                    void *arg);
-
-////////////////////////////////////////////////////////////////////////////////////
-/// \ingroup CL_ThreadCreateAttrInit
-/// \~english @par Brief
-///        Initialize thread attribute
-/// \~english @param [out] attr
-///        CL_ThreadAttr_t*   - thread attribute pointer
-/// \~english @par
-///        CL_ThreadAttr_t structure
-/// \~english @code
-///                 typedef struct {
-///                   char body[20];
-///                 } CL_ThreadAttr_t;
-///            @endcode
-/// \~english @retval 0 Success
-/// \~english @retval -1 Error (set errno)
-/// \~english @par Prerequisite
-///        - Prerequisites are nothing.
-/// \~english @par Change of internal state
-///        - Change of internal state according to the API does not occur.
-/// \~english @par Conditions of processing failure
-///       - When the pointer (attr) of the thread attributespecified by the argument is NULL, set errno to EINVAL, -1 is returned.
-/// \~english @par Detail
-///       Initialize structure CL_ThreadAttr_t that stores threade attribute.\n
-/// \~english @par Classification
-///        Public
-/// \~english @see
-///        none
-////////////////////////////////////////////////////////////////////////////////////
-int CL_ThreadCreateAttrInit(CL_ThreadAttr_t *attr);  // NOLINT(readability/nolint)
-
-////////////////////////////////////////////////////////////////////////////////////
-/// \ingroup CL_ThreadCreateAttrSetName
-/// \~english @par Brief
-///        Set thread attribute to thread name
-/// \~english @param [out] attr
-///        CL_ThreadAttr_t*   - thread attribute pointer
-/// \~english @param [in] name
-///        const char*   - Pointer to the string storing the thread name (max length 16byte)
-/// \~english @par
-///        CL_ThreadAttr_t structure
-/// \~english @code
-///                 typedef struct {
-///                   char body[20];
-///                 } CL_ThreadAttr_t;
-///            @endcode
-/// \~english @retval 0 Success
-/// \~english @retval -1 Error (set errno)
-/// \~english @par Prerequisite
-///        - Prerequisites are nothing.
-/// \~english @par Change of internal state
-///        - Change of internal state according to the API does not occur.
-/// \~english @par Conditions of processing failure
-///       - When the pointer (attr) of thread attribute specified by the argument is NULL, set errno to EINVAL, -1 is returned.
-///       - When the pointer (name) to the character string that stores the thread name specified
-///         by the argument is NULL, set errno to EINVAL, -1 is returned.
-/// \~english @par Detail
-///       Set thread attribute to thread name\n
-///       The characer string that stores the thread name specified by the argument must satisfy the following conditions:\n
-///       - Terminated by a NULL.\n
-///       - The maximum lengthof character string is 16 byte including the termination character.\n
-/// \~english @par Classification
-///        Public
-/// \~english @see
-///        none
-////////////////////////////////////////////////////////////////////////////////////
-int CL_ThreadCreateAttrSetName(CL_ThreadAttr_t *attr, const char *name);  // NOLINT(readability/nolint)
-
-////////////////////////////////////////////////////////////////////////////////////
-/// \ingroup CL_ProcessCreateCgroupCreate
-/// \~english @par Brief
-///        Create Cgroup
-/// \~english @param [in] cgroup_name
-///        const char* - cgroup name
-/// \~english @param [in] attr
-///        const CL_ProcessCreateCgroupAttr_t* - Cgroup attribut
-/// \~english @par
-///        CL_ProcessCreateCgroupAttr_t struct
-/// \~english @code
-///                 typedef struct {
-///                   char body[24];
-///                 } CL_ProcessCreateCgroupAttr_t;
-///            @endcode
-/// \~english @retval 0 Success
-/// \~english @retval -1 Error
-/// \~english @par Prerequisite
-///        - Initialize attr by CL_ProcessCreateCgroupAttrInit
-/// \~english @par Change of internal state
-///        - Change of internal state according to the API does not occur.
-/// \~english @par Conditions of processing failure
-///       - When the Cgroup name (cgroup_name) specified by the argument is NULL, set errno to EINVAL, -1 is returned.
-///       - When the pointer (attr) of the Cgroup attribute specified by the argumet is NULL,
-///         set errno to EINVAL, -1 is returned.
-///       - When the area for directory path name of the CPU subsystem of Cgroup could not be allocated,
-///         set errno to EINVAL, -1 is returned.
-///       - When the area for directory of the CPU subsystem of Cgroup could not be create, -1 is returned.
-///       - When the area for file path name of the CPU subsystem of Cgroup could not be allocated,
-///         set errno to EINVAL, -1 is returned.
-///       - When file descriptor of the CPU subsystem of Cgroup could not be acquired, -1 is returned.
-///       - When setting value to CPU subsystem of Cgroup could not be written, -1 is returned.
-///       - When the area for directory path name of the memory subsystem of Cgroup could not be allocated,
-///         set errno to EINVAL, -1 is returned.
-///       - When the area for directory of the memory subsystem of Cgroup could not be create, -1 is returned.
-///       - When the area for file path name of the memory subsystem of Cgroup could not be allocated,
-///         set errno to EINVAL, -1 is returned.
-///       - When file descriptor of the memory subsystem of Cgroup could not be acquired, -1 is returned.
-///       - When setting value to memory subsystem of Cgroup could not be written, -1 is returned.
-/// \~english @par Detail
-///        Create Cgroup to which the process to be created belongs.
-///        If it belongs to Cgroup that has already been created, it is not necessary to create it.\n
-/// \~english @par
-///        Since the Cgroup attribute cannot be changed during Cgroup, if it is necessary o chage the Cgroup attribute,
-///        it is necessary to call the following API and change the Cgroup attribute calling this API.\n
-///          - CL_ProcessCreateCgroupAttrInit :Initialize Cgroup attribute
-///          - CL_ProcessCreateCgroupAttrSetCfsBandwidthControl :TSS process CPU time control by Bandwidth Control
-///          - CL_ProcessCreateCgroupAttrSetCpuShares :TSS process CPU time control
-///          - CL_ProcessCreateCgroupAttrSetMemoryLimit :Contol memory usage
-///          - CL_ProcessCreateCgroupAttrSetMemoryUsageNotification :Memory usage notification setting
-///          - CL_ProcessCreateCgroupAttrSetRtThrottling :FIFO/RR process CPU time control
-/// \~english @par Classification
-///        Public
-/// \~english @par Type
-///        Open Close
-/// \~english @see
-///        CL_ProcessCreateCgroupDelete,
-///        CL_ProcessCreateCgroupAttrInit, CL_ProcessCreateCgroupAttrSetCfsBandwidthControl,
-///        CL_ProcessCreateCgroupAttrSetCpuShares, CL_ProcessCreateCgroupAttrSetMemoryLimit,
-///        CL_ProcessCreateCgroupAttrSetMemoryUsageNotification, CL_ProcessCreateCgroupAttrSetRtThrottling,
-////////////////////////////////////////////////////////////////////////////////////
-int CL_ProcessCreateCgroupCreate(const char *cgroup_name,  // NOLINT(readability/nolint)
-                                 CL_ProcessCreateCgroupAttr_t *attr);
-
-////////////////////////////////////////////////////////////////////////////////////
-/// \ingroup CL_ProcessCreateCgroupAttrInit
-/// \~english @par Brief
-///        Initialize Cgroup attribute
-/// \~english @param [out] attr
-///        const CL_ProcessCreateCgroupAttr_t* - Cgroup attribute pointer
-/// \~english @par
-///        CL_ProcessCreateCgroupAttr_t struct
-/// \~english @code
-///                 typedef struct {
-///                   char body[24];
-///                 } CL_ProcessCreateCgroupAttr_t;
-///            @endcode
-/// \~english @retval 0 Success
-/// \~english @retval -1 Error
-/// \~english @par Prerequisite
-///        - Prerequisites are nothing.
-/// \~english @par Change of internal state
-///        - Change of internal state according to the API does not occur.
-/// \~english @par Conditions of processing failure
-///       - When the pointer of Cgroup attribute (attr) specified in the arguments is NULL, set errno to EINVAL, -1 is returned.
-/// \~english @par Detail
-///       Initialize Cgroup attibute with 0.\n
-/// \~english @par Classification
-///        Public
-/// \~english @par Type
-///        No match
-/// \~english @see
-///        none
-////////////////////////////////////////////////////////////////////////////////////
-int CL_ProcessCreateCgroupAttrInit(CL_ProcessCreateCgroupAttr_t *attr);  // NOLINT(readability/nolint)
-
-////////////////////////////////////////////////////////////////////////////////////
-/// \ingroup CL_ProcessCreateCgroupAttrSetRtThrottling
-/// \~english @par Brief
-///        Set FIFO/RR process CPU time control
-/// \~english @param [in,out] attr
-///        const CL_ProcessCreateCgroupAttr_t* - Cgroup attribute
-/// \~english @param [in] runtime_us
-///        int - CPU allocation time(us)
-/// \~english @par
-///        CL_ProcessCreateCgroupAttr_t struct
-/// \~english @code
-///                 typedef struct {
-///                   char body[24];
-///                 } CL_ProcessCreateCgroupAttr_t;
-///            @endcode
-/// \~english @retval 0 Success
-/// \~english @retval -1 Error
-/// \~english @par Prerequisite
-///        - Initialize attr with CL_ProcessCreateCgroupAttrInit.
-/// \~english @par Change of internal state
-///        - Change of internal state according to the API does not occur.
-/// \~english @par Conditions of processing failure
-///        - When the pointer of Cgroup attribute (attr) specified in the arguments is NULL,
-///          set errno to EINVAL, -1 is returned.
-/// \~english @par Detail
-///        Limiting the CPU time allocated to a process to
-///        which a real-time class schedule policy (SCHED_FIFO/SCHED_RR) is applied.\n
-///        Set the value of argument runtime_us to the cpu.rt_runtime_us (CPU allocation time) of created Cgroup.\n
-///        cpu.rt_period_us(unit time:1000000us) is not changed.\n
-///        If not set, Cgroup created will remain at default (CPU allocation time:950000us).\n
-///        The configurable range of runtime_us depends on the use of Cgroup and the kernel version.
-///        The user sets an appropriate value.\n
-/// \~english @par Classification
-///        Public
-/// \~english @par Type
-///        No match
-/// \~english @see
-///        none
-////////////////////////////////////////////////////////////////////////////////////
-int CL_ProcessCreateCgroupAttrSetRtThrottling(  // NOLINT(readability/nolint)
-    CL_ProcessCreateCgroupAttr_t *attr, int runtime_us);
-
-////////////////////////////////////////////////////////////////////////////////////
-/// \ingroup CL_ProcessCreateCgroupAttrSetCpuShares
-/// \~english @par Brief
-///        Set TSS process CPU time control
-/// \~english @param [in,out] attr
-///        const CL_ProcessCreateCgroupAttr_t* - Cgroup attribute pointer
-/// \~english @param [in] cpu_shares
-///        int - An integer value that sepcified the relative distribution of CPU time
-/// \~english @par
-///        CL_ProcessCreateCgroupAttr_t struct
-/// \~english @code
-///                 typedef struct {
-///                   char body[24];
-///                 } CL_ProcessCreateCgroupAttr_t;
-///            @endcode
-/// \~english @retval 0 Success
-/// \~english @retval -1 Error
-/// \~english @par Prerequisite
-///        - Initialize attr with CL_ProcessCreateCgroupAttrInit
-/// \~english @par Change of internal state
-///        - Change of internal state according to the API does not occur.
-/// \~english @par Conditions of processing failure
-///        - When the pointer (attr) of the Cgroup attribute specified by the argument is NULL,
-///          set errno to EINVAL, -1 is returned.
-/// \~english @par Detail
-///        Cotrols the CPU time allocated to a process to which
-///        a class TSS schedule policy (SCHED_OTHER, etc.) is applied.\n
-///        If cpu_shares is set with this function, a single Cgroup is created and cpu.shares is set with that value.\n
-///        If not set, remain at default.\n
-///        cpu_shares is set to the standard value 1024, and CPU time is allocated according
-///        to the allocaion value specified between Cgroup.\n
-///        Task Cgroup with cpu.shares set to 1024 has twice as much CPU time as
-///        task Cgroup with cpu.shares set to 512.\n
-///        Processes belonging to the same Cgroup are equally allocated CPU time allocated to Cgroup.\n
-///        Note that the time distribution is distributed across al CPU cores on a multi-core system.\n
-///        In a multicore system, if Cgroup limit is set to 100% of the CPU,
-///        100% of each CPU core wil be available.\n\n
-///        Examle) If Cgroup A is set to use 25% of the CPU and Cgroup B is set to use 75% of the CPU,\n
-///        and a process that uses CPU intensively is started on a 4-core system (1 process in A and 3 processes in B),\n
-///        the CPU allocaion is distributed as follows.\n\n
-/// \~english @par
-///        | PID | cgroup | CPU | CPU allotment |
-///        |:---:|:------:|:---:|:-------:|
-///        | 100 | A | 0 | CPU0 100% |
-///        | 101 | B | 1 | CPU1 100% |
-///        | 102 | B | 2 | CPU2 100% |
-///        | 103 | B | 3 | CPU3 100% |
-/// \~english @par
-/// \~english @par Classification
-///        Public
-/// \~english @par Type
-///        No match
-/// \~english @see
-///        none
-////////////////////////////////////////////////////////////////////////////////////
-int CL_ProcessCreateCgroupAttrSetCpuShares(CL_ProcessCreateCgroupAttr_t *attr,  // NOLINT(readability/nolint)
-                                           int cpu_shares);
-
-///////////////////////////////////////////////////////////////////////////////////
-/// \ingroup CL_ProcessCreateCgroupAttrSetCfsBandwidthControl
-/// \~english @par Brief
-///        Set TS process CU time control by Bandwidth Control
-/// \~english @param [in,out] attr
-///        const CL_ProcessCreateCgroupAttr_t* - Cgroup attribute pointer
-/// \~english @param [in] cfs_quota_us
-///        int - CPU allocation time
-/// \~english @par
-///        CL_ProcessCreateCgroupAttr_t struct
-/// \~english @code
-///                 typedef struct {
-///                   char body[24];
-///                 } CL_ProcessCreateCgroupAttr_t;
-///            @endcode
-/// \~english @retval 0 Success
-/// \~english @retval -1 Error
-/// \~english @par Prerequisite
-///        - Initialize attr with CL_ProcessCreateCgroupAttrInit
-/// \~english @par Change of internal state
-///        - Change of internal state according to the API does not occur.
-/// \~english @par Conditions of processing failure
-///        - When the pointer of the process attribute specified (attr) in the argument is NULL,
-///          set errno to EINVAL, -1 is returned.
-/// \~english @par Detail
-///        Controls the amount of time allocated to processes o whitch TSS class schedule plicy (SCHED_OTHER, etc.) are
-///        applied using bandwidth control of CFS(Completely Fair Scheduler) implemented from kernel 3.2.\n
-///        Set the value of argument cfs_quota_us to the cpu.cfs_quota_us of created Cgroup.\n
-///        cpu.cfs_period_us(unit time:1000000us) is not changed.\n
-///        If not set, the created Cgroup will not have CPU allocatio control. (set cpu.cfs_guota_us to -1).\n
-///        The time (%) allocated to Cgroup can be set correctly,
-///        and it can be allocated correctly if the CPU is free.\n
-///        It is scheduled to be allocated as much as possible even if it conflicts with other Cgroup's.\n
-/// \~english @par Classification
-///        Public
-/// \~english @par Type
-///        No match
-/// \~english @see
-///        none
-////////////////////////////////////////////////////////////////////////////////////
-int CL_ProcessCreateCgroupAttrSetCfsBandwidthControl(  // NOLINT(readability/nolint)
-    CL_ProcessCreateCgroupAttr_t *attr, int cfs_quota_us);
-
-/////////////////////////////////////////////////////////////////
-/// \ingroup CL_ProcessCreateCgroupAttrSetMemoryLimit
-/// \~english @par Brief
-///        Control memory usage
-/// \~english @param [in,out] attr
-///        const CL_ProcessCreateCgroupAttr_t* - Cgroup attribute pointer
-/// \~english @param [in] memory_limit
-///        int - memory limit (byte)
-/// \~english @par
-///        CL_ProcessCreateCgroupAttr_t struct
-/// \~english @code
-///                 typedef struct {
-///                   char body[24];
-///                 } CL_ProcessCreateCgroupAttr_t;
-///            @endcode
-/// \~english @retval 0 Success
-/// \~english @retval -1 Error
-/// \~english @par Prerequisite
-///        - Initialize attr with CL_ProcessCreateCgroupAttrInit
-/// \~english @par Change of internal state
-///        - Change of internal state according to the API does not occur.
-/// \~english @par Conditions of processing failure
-///        - When the pointer of the process attribute specified (attr) in the argument is NULL,
-///          set errno to EINVAL, -1 is returned.
-/// \~english @par Detail
-///        Control the CPU time allocated to a process.\n
-///        Set the value of argument memory_limit to the memory.limit_in_bytes of created Cgroup.\n
-///        If not set, there is no memory limit.When a request exceeding the memory limit is issued,
-///        a SIGKILL is sent from the kernel and the process is discarded.
-///        Note: When the memory limit is exceeded, control moves to 00M,
-///        but its operation ca be changed (Documentation/cgroup/memory.txt).\n
-///        Write memory.oom_control to 1 to stop the OOM-Killer.
-///        When OOM-Killer is stopped, the task below Cgroup becomes hang/sleep.\n
-///        The task moves when the limit of the memory Cgroup increaes or when usage decreases. When usage decreases,\n
-///        - Task was killed\n
-///        - Task was moved other group\n
-///        - File has been deleted\n
-/// \~english @par
-///       You can also receive a eventf notification from OOM.\n
-///       Memory usage is counted as follows\n
-///        - RSS(All mapped anon pages)\n
-///        - Page Cache\n
-///        - First acess Shared Pages in Cgroup\n
-/// \~english @par Classification
-///        Public
-/// \~english @par Type
-///        No match
-/// \~english @see
-///        none
-////////////////////////////////////////////////////////////////////////////////////
-int CL_ProcessCreateCgroupAttrSetMemoryLimit(CL_ProcessCreateCgroupAttr_t *attr,  // NOLINT(readability/nolint)
-                                             int memory_limit);
-
-////////////////////////////////////////////////////////////////////////////////////
-/// \ingroup CL_ProcessCreateCgroupAttrSetMemoryUsageNotification
-/// \~english @par Brief
-///        Set notificatio when memory usage exceeds the specified amount
-/// \~english @param [in,out] attr
-///        const CL_ProcessCreateCgroupAttr_t* - Cgroup attribute pointer
-/// \~english @param [in] usage_in_bytes
-///        int - usage in bytes(byte)
-/// \~english @param [in] event_fd
-///        int - File dexcriptor created by system call eventfd()
-/// \~english @par
-///        CL_ProcessCreateCgroupAttr_t struct
-/// \~english @code
-///                 typedef struct {
-///                   char body[24];
-///                 } CL_ProcessCreateCgroupAttr_t;
-///            @endcode
-/// \~english @retval 0 Success
-/// \~english @retval -1 Error
-/// \~english @par Prerequisite
-///        - Initialize attr with CL_ProcessCreateCgroupAttrInit
-/// \~english @par Change of internal state
-///        - Change of internal state according to the API does not occur.
-/// \~english @par Conditions of processing failure
-///        - When the pointer of the process attribute specified (attr) in the argument is NULL,
-///          set errno to EINVAL, -1 is returned.
-///        - When event_fd is negative for a file descriptor created by system call eventfd(),
-///          set errno to EINVAL, -1 is returned.
-/// \~english @par Detail
-///        event_fd is notifued when memory usage exceeds argument usage_in_bytes.\n
-///        See eventfd for details of event_fd.\n
-/// \~english @par Classification
-///        Public
-/// \~english @par Type
-///        No match
-/// \~english @see
-///        none
-////////////////////////////////////////////////////////////////////////////////////
-int CL_ProcessCreateCgroupAttrSetMemoryUsageNotification(  // NOLINT(readability/nolint)
-    CL_ProcessCreateCgroupAttr_t *attr, int usage_in_bytes, int event_fd);
-
-////////////////////////////////////////////////////////////////////////////////////
-/// \ingroup CL_ProcessCreateCgroupDelete
-/// \~english @par Brief
-///        Delete Cgroup
-/// \~english @param [in] cgroup_name
-///        const char* - cgroup name
-/// \~english @retval 0 Success
-/// \~english @retval -1 Error
-/// \~english @par Prerequisite
-///        - Need to be runnning CL_ProcessCreateCgroupCreate.
-/// \~english @par Change of internal state
-///        - Change of internal state according to the API does not occur.
-/// \~english @par Conditions of processing failure
-///        - When the Cgroup (cgroup_name) name specified inthe argument is NULL, set errno to EINVAL, -1 is returned.
-///        - When the area for directory path name of the CPU subsystem of Cgroup and
-///          memory subsystem of Cgroup could not be allocated,  set errno to EINVAL, -1 is returned.
-///        - When the area for the directory path name of the memory subsystem of Cgroup cannot be allocated and
-///          the directory for the CPU subsystem of Cgroup does not exist, set errno to EINVAL, -1 is returned.
-///        - When the directory for the CPU subsystem of Cgroup does not exist and
-///          the area for the directory path name of the memory subsystem of Cgroup cannot be allocated,
-///          set errno to EINVAL, -1 is returned.
-///        - When the directory for the memory subsystem of Cgroup and
-///          the directory for the CPU subsystem of Cgroup does not exist, set errno to EINVAL, -1 is returned.
-///        - When the directory for the memory subsystem of Cgroup could not be deleted, -1 is returned.
-///        - When the directory for the CPU subsystem of Cgroup could not be deleted, -1 is returned.
-/// \~english @par Detail
-///        Delete Cgroup. If there is a proess belonging to Cgroup, error code (EBUSY) is returned.\n
-/// \~english @par
-///        Success is also notified in the following cases:\n
-///        - When the area for directory path name of memory subsyste Cgroup could not be allocated
-///          but CPU subsystem of Cgroup was deleted successfully.
-///        - When the directory for the memory subsystem of Cgroup does not exist,
-///          but CPU subsystem of Cgroup was deleted successfully.
-///        - When the area for directory path name of CPU subsyste Cgroup could not be allocated
-///          but memory subsystem of Cgroup was deleted successfully.
-///        - When the directory for the CPU subsystem of Cgroup does not exist,
-///          but memory subsystem of Cgroup was deleted successfully.
-/// \~english @par Classification
-///        Public
-/// \~english @par Type
-///        Open Close
-/// \~english @see
-///        CL_ProcessCreateCgroupCreate
-////////////////////////////////////////////////////////////////////////////////////
-int CL_ProcessCreateCgroupDelete(const char *cgroup_name);  // NOLINT(readability/nolint)
-
-////////////////////////////////////////////////////////////////////////////////////
-/// \ingroup CL_ProcessCreateCgroupClassify
-/// \~english @par Brief
-///        Move process to the Cgroup
-/// \~english @param [in,out] cgroup_name
-///        const char* - Destination A name
-/// \~english @param [in] pid
-///        pid_t - process ID
-/// \~english @retval 0 Success
-/// \~english @retval -1 Error
-/// \~english @par Prerequisite
-///        - Need to be running CL_ProcessCreateCgroupCreate.
-/// \~english @par Change of internal state
-///        - Change of internal state according to the API does not occur.
-/// \~english @par Conditions of processing failure
-///        - When the Cgroup (cgroup_name) specified in the argument is NULL, set errno to EINVAL, -1 is returned.
-///        - When the area for directory path name of memory subsystem of Cgroup and
-///          CPU subsystem of Cgroup could not be allocated, set errno to EINVAL, -1 is returned.
-///        - When the area for directory path name of memory subsystem of Cgroup could not be allocated,
-///          and the directory for CPU subsystem of Cgroup does not exist, set errno to EINVAL, -1 is returned.
-///        - When the directory for memory subsystem of Cgroup does not exist and
-///          the directory for CU subsystem of Cgroup could not allocated , set errno to EINVAL, -1 is returned.
-///        - When the directory for the memory subsystem of Cgroup and
-///          the directory for the CPU subsystem of Cgroup does not exist, set errno to EINVAL, -1 is returned.
-///        - When the area for directory path name of the memory subsystem of Cgroup could not allocated,
-///          set errno to EINVAL, -1 is returned.
-///        - When the file descripter for the memory subsystem of Cgroup could not be obtained, -1 is returned.
-///        - When pid could not be written to the file for memory subsystem of Cgroup, -1 is returned.
-///        - When the area for directory path name of the CPU subsystem of Cgroup could not be allocated,
-///          set errno to EINVAL, -1 is returned.
-///        - When the file decsripter for the CPU subsystem of Cgroup could not be allocated, -1 is returned.
-///        - When pid could not be written to the file for CPU subsystem of Cgroup, -1 is returned.
-/// \~english @par Detail
-///        Move process to the Cgroup.\n
-/// \~english @par
-///        Success is also notified in the following cases:\n
-///        - When the area for directory path name of memory subsyste Cgroup could not be allocated
-///          but CPU subsystem of Cgroup was deleted successfully.
-///        - When the directory for the memory subsystem of Cgroup does not exist,
-///          but CPU subsystem of Cgroup was deleted successfully.
-///        - When the area for directory path name of CPU subsyste Cgroup could not be allocated
-///          but memory subsystem of Cgroup was deleted successfully.
-///        - When the directory for the CPU subsystem of Cgroup does not exist,
-///          but memory subsystem of Cgroup was deleted successfully.
-/// \~english @par Classification
-///        Public
-/// \~english @par Type
-///        No match
-/// \~english @see
-///        none
-////////////////////////////////////////////////////////////////////////////////////
-int CL_ProcessCreateCgroupClassify(const char *cgroup_name, pid_t pid);  // NOLINT(readability/nolint)
-
-/** @}*/  // end of common_library
-/** @}*/  // end of NativeService
-/** @}*/  // end of BaseSystem
-#ifdef __cplusplus
-}
-#endif
-
-#endif  // #ifndef _cl_process_h_  // NOLINT(build/header_guard)