2 * @copyright Copyright (c) 2016-2020 TOYOTA MOTOR CORPORATION.
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
17 #ifndef _cl_process_h_ // NOLINT(build/header_guard)
18 #define _cl_process_h_ // NOLINT(build/header_guard)
20 #include <sys/types.h>
22 #define CL_PROCESSS_ATTR_HOLD_FDS_NUM 8
24 #define CL_INTFY_FILENAME_FORMAT "/tmp/intfy_%05d"
26 /////////////////////////////////////////////////////////////////////////////////////
27 /// \ingroup CL_ProcessAttr_t
28 /// \~english @par Brief
29 /// Process attribute structure
30 /////////////////////////////////////////////////////////////////////////////////////
32 char body[148]; ///< process attribute
35 /////////////////////////////////////////////////////////////////////////////////////
36 /// \ingroup CL_ProcessCleanupInfo_t
37 /// \~english @par Brief
38 /// Child-process attribute structure
39 /////////////////////////////////////////////////////////////////////////////////////
41 pid_t pid; ///< child-process ID
42 int code; ///< signal code
43 int status; ///< end status or signal
44 } CL_ProcessCleanupInfo_t;
46 /////////////////////////////////////////////////////////////////////////////////////
47 /// \ingroup CL_ProcessSchedPolicy_t
48 /// \~english @par Brief
50 /////////////////////////////////////////////////////////////////////////////////////
52 CL_PROCESS_SCHED_POLICY_OTHER = 0, ///< TSS
53 CL_PROCESS_SCHED_POLICY_RR, ///< Round robin
54 CL_PROCESS_SCHED_POLICY_FIFO, ///< FIFO
55 } CL_ProcessSchedPolicy_t;
61 /////////////////////////////////////////////////////////////////////////////////////
62 /// \ingroup CL_ProcessCreateCgroupAttr_t
63 /// Cgroup attribute structure
64 /////////////////////////////////////////////////////////////////////////////////////
66 char body[24]; ///< Cgroup attribute
67 } CL_ProcessCreateCgroupAttr_t;
74 * @brief \~english This file contains the base api,enum and struct of cl_process.
77 /** @addtogroup BaseSystem
80 /** @addtogroup native_service
84 /** @addtogroup common_library
85 * @ingroup native_service
89 /////////////////////////////////////////////////////////////////////////////////////
90 /// \ingroup CL_ProcessInit
91 /// \~english @par Brief
92 /// Initialize the process
93 /// \~english @retval int file descriptor
94 /// \~english @retval -1 Error
95 /// \~english @par Prerequisite
96 /// - Prerequisites are nothing.
97 /// \~english @par Change of internal state
98 /// - Change of internal state according to the API does not occur.
99 /// \~english @par Conditions of processing failure
100 /// - Failed to set up process prctl, -1 is returned.
101 /// - Failed to set the signal set to the empty set sigemptyset, -1 is returned.
102 /// - Failed to add a signal to the signal mask sigaddset, -1 is returned.
103 /// - Failed to set sigprocmask, -1 is returned.
104 /// - Failed to create a scripter in the file for signal acceptance signalfd, -1 is returned.
105 /// \~english @par Detail
106 /// This API must be called before createing a thread.
107 /// Therefore, it is recommended that this API be called from within the main() function immediately after the API started.\n
108 /// Initialize the process.\n
109 /// The retuen value fd is assumed to be poll/select and used for waiting for event.\n
110 /// An ready occurs when the child process terminates.\n
111 /// Call process name setting(\ref CL_ProcessCreateAttrSetName) uniformly
112 /// because it is applied only to the number of architecture after exec.\n
113 /// \~english @par Classification
115 /// \~english @par Type
119 ////////////////////////////////////////////////////////////////////////////////////
120 int CL_ProcessInit(void); // NOLINT(readability/nolint)
122 /////////////////////////////////////////////////////////////////////////////////////
123 /// \ingroup CL_ProcessCreate
124 /// \~english @par Brief
125 /// Create the process
126 /// \~english @param [in] file
128 /// \~english @param [in] argv[]
130 /// \~english @param [in] envp[]
132 /// \~english @param [in] attr
133 /// const CL_ProcessAttr_t* - Process attribute pointer
135 /// CL_ProcessAttr_t struct
139 /// } CL_ProcessAttr_t;
141 /// \~english @retval int Success(PID)
142 /// \~english @retval -1 Error
143 /// \~english @par Prerequisite
144 /// - Need to be running CL_ProcessInit.
145 /// - Initialize attr with CL_ProcessCreateAttrInit.
146 /// \~english @par Change of internal state
147 /// - Change of internal state according to the API does not occur.
148 /// \~english @par Conditions of processing failure
149 /// - When the executable name (file) in the argument is NULL, set errno to EINVAL, -1 is returned.
150 /// - When the ARG parameter (argv[]) in the argument is NULL, set errno to EINVAL, -1 is returned.
151 /// - When the pointer of the process attribute specified (attr) in the argument is NULL,
152 /// set errno to EINVAL, -1 is returned.
153 /// - When memory (malloc) of the data storagee area of the environment variable parameter (envp[]) specified
154 /// by the arguments fails, set errno to EINVAL, -1 is returned.
155 /// - When memory (malloc) of the data control area of the environment variable parameter (envp[]) specified
156 /// by the arguments fails, set errno to EINVAL, -1 is returned.
157 /// - Process creation (fork) fail, -1 is returned.
158 /// - Process CPU affinity masking (sched_setaffinity) fail, -1 is returned.
159 /// - When the character string output processing (snprintf) for process creation fail, -1 is returned.
160 /// - When the character string output processing (snprintf) for PID setting of cgroup fail, -1 is returned.
161 /// - Failure to allocate the area fo sstoring the path name of cgroup (malloc), -1 is returned.
162 /// - Failure to open file descriptor (open) of cgroup, -1 is returned.
163 /// - Failure to write file descriptor (write) of cgroup, -1 is returned.
164 /// \~english @par Detail
165 /// - This API must be called before createing a thread.
167 /// Create the process.\n
168 /// The ARG parameter (argv[]) specified in the argment must satisfy the following conditions:\n
169 /// - Can not be omitted.\n
170 /// - The first argument must specify a pointer o the filename to be executed.\n
171 /// - An array of pointer to NULL terminated strings.\n
172 /// - Arrays must be terminated by NULL pointer.\n
174 /// Enviroment-variable parameters (envp[]) specified in arguments mus satisfy the following condiions:\n
175 /// - When NULL is specified, the parent process inherits the parent process's environment variables.\n
176 /// - An array of pointer to NULL terminated strings.\n
177 /// - Arrays must be terminated by NULL pointer.\n
179 /// Be aware of the following.\n
180 /// - Processing continues without interrupting event if setrlimit() fail.\n
181 /// - System call access() checks whether or not there is access privilege,
182 /// but returns PID regardless of the access privilege status.
183 /// (If the process does not have access privilege, 100 retries are executed at 100 microseconds.)
185 /// Since the process attribute of a process cannot be changed during processing,
186 /// if it is necessary to change the process attribute,
187 /// it is necessary to call the following API and change the process attribute before calling this API.\n
188 /// - CL_ProcessCreateAttrInit Initialize process attribute
189 /// - CL_ProcessCreateAttrSetCgroup Setting process attribute (Cgroup)
190 /// - CL_ProcessCreateAttrSetDisableCloseFds Setting process attribute (stop compulsion FD close)
191 /// - CL_ProcessCreateAttrSetGid Setting process attribute (group ID)
192 /// - CL_ProcessCreateAttrSetGroup Setting process attribute (process group)
193 /// - CL_ProcessCreateAttrSetHoldFds Setting process attribute (maintain FD)
194 /// - CL_ProcessCreateAttrSetName Setting process attribute (process name)
195 /// - CL_ProcessCreateAttrSetSchedule Setting process attribute (schedule policy and priority)
196 /// - CL_ProcessCreateAttrSetStackSize Setting process attribute (Stack Size)
197 /// - CL_ProcessCreateAttrSetUid Setting process attribute (user ID)
198 /// \~english @par Classification
200 /// \~english @par Type
203 /// CL_ProcessTerminate, CL_ProcessTerminateGroup
204 /// CL_ProcessCreateAttrInit, CL_ProcessCreateAttrSetCgroup,
205 /// CL_ProcessCreateAttrSetDisableCloseFds, CL_ProcessCreateAttrSetGid,
206 /// CL_ProcessCreateAttrSetGroup, CL_ProcessCreateAttrSetHoldFds,
207 /// CL_ProcessCreateAttrSetName, CL_ProcessCreateAttrSetSchedule,
208 /// CL_ProcessCreateAttrSetStackSize, CL_ProcessCreateAttrSetUid
209 ////////////////////////////////////////////////////////////////////////////////////
210 int CL_ProcessCreate(const char *file, char * const argv[], char * const envp[], // NOLINT(readability/nolint)
211 const CL_ProcessAttr_t *attr);
213 ////////////////////////////////////////////////////////////////////////////////////
214 /// \ingroup CL_ProcessCreateAttrInit
215 /// \~english @par Brief
216 /// Initialize process attribute
217 /// \~english @param [out] attr
218 /// const CL_ProcessAttr_t* - Process attribute pointer
220 /// CL_ProcessAttr_t struct
224 /// } CL_ProcessAttr_t;
226 /// \~english @retval 0 Success
227 /// \~english @retval -1 Error
228 /// \~english @par Prerequisite
229 /// - Prerequisites are nothing.
230 /// \~english @par Change of internal state
231 /// - Change of internal state according to the API does not occur.
232 /// \~english @par Conditions of processing failure
233 /// - When the pointer of the process attribute specified (attr) in the argument is NULL,
234 /// set errno to EINVAL, -1 is returned.
235 /// \~english @par Detail
236 /// Initilize the CL_ProcessAttr_t structure that stores process attribute.\n
237 /// \~english @par Classification
239 /// \~english @par Type
240 /// Method(Async) / Fire and Forget / Broadcast / Sync / Set Get / Open Close / Request Notify / No match
243 ////////////////////////////////////////////////////////////////////////////////////
244 int CL_ProcessCreateAttrInit(CL_ProcessAttr_t *attr); // NOLINT(readability/nolint)
246 ////////////////////////////////////////////////////////////////////////////////////
247 /// \ingroup CL_ProcessCreateAttrSetName
248 /// \~english @par Brief
249 /// Set process name in process attribute
250 /// \~english @param [in,out] attr
251 /// const CL_ProcessAttr_t* - Process attribute pointer
252 /// \~english @param [in] name
253 /// const char* - process name (max length 16byte)
255 /// CL_ProcessAttr_t struct
259 /// } CL_ProcessAttr_t;
261 /// \~english @retval 0 Success
262 /// \~english @retval -1 Error
263 /// \~english @par Prerequisite
264 /// - Initialize attr with CL_ProcessCreateAttrInit.
265 /// \~english @par Change of internal state
266 /// - Change of internal state according to the API does not occur.
267 /// \~english @par Conditions of processing failure
268 /// - When the pointer of the process attribute specified (attr) in the argument is NULL,
269 /// set errno to EINVAL, -1 is returned.
270 /// - When the pointer (name) to the character string hat stores the process name specified
271 /// by the argument is NULL, set errno to EINVAL, -1 is returned.
272 /// \~english @par Detail
273 /// Set process name to process attribute.\n
274 /// The charactr string that stores the process name specified by the argument must satisfy the following conditions:\n
275 /// - Terminated by a NULL.\n
276 /// - The maximum lengthof character string is 16 byte including the termination character.\n
277 /// \~english @par Classification
279 /// \~english @par Type
283 ////////////////////////////////////////////////////////////////////////////////////
284 int CL_ProcessCreateAttrSetName(CL_ProcessAttr_t *attr, const char *name); // NOLINT(readability/nolint)
286 ////////////////////////////////////////////////////////////////////////////////////
287 /// \ingroup CL_ProcessCreateAttrSetUid
288 /// \~english @par Brief
289 /// Set process attribute to user ID
290 /// \~english @param [in,out] attr
291 /// const CL_ProcessAttr_t* - Process attribute pointer
292 /// \~english @param [in] uid
295 /// CL_ProcessAttr_t struct
299 /// } CL_ProcessAttr_t;
301 /// \~english @retval 0 Success
302 /// \~english @retval -1 Error
303 /// \~english @par Prerequisite
304 /// - Initialize attr with CL_ProcessCreateAttrInit.
305 /// \~english @par Change of internal state
306 /// - Change of internal state according to the API does not occur.
307 /// \~english @par Conditions of processing failure
308 /// - When the pointer of the process attribute specified (attr) in the argument is NULL,
309 /// set errno to EINVAL, -1 is returned.
310 /// \~english @par Detail
311 /// Set process attribute to user ID.\n
312 /// When UINT_MAX is set for the user ID,
313 /// the user ID is set to 0 in the process attribute in the processing of CL_ProcessCreate().\n
314 /// When 0 is set for the user ID,
315 /// it is not reflected in the process attribute becose if is played by the process of CL_ProcessCreate().\n
316 /// \~english @par Classification
318 /// \~english @par Type
322 ////////////////////////////////////////////////////////////////////////////////////
323 int CL_ProcessCreateAttrSetUid(CL_ProcessAttr_t *attr, uid_t uid); // NOLINT(readability/nolint)
325 ////////////////////////////////////////////////////////////////////////////////////
326 /// \ingroup CL_ProcessCreateAttrSetGid
327 /// \~english @par Brief
328 /// Set process attribute to group ID
329 /// \~english @param [in,out] attr
330 /// const CL_ProcessAttr_t* - Process attribute pointer
331 /// \~english @param [in] gid
334 /// CL_ProcessAttr_t struct
338 /// } CL_ProcessAttr_t;
340 /// \~english @retval 0 Success
341 /// \~english @retval -1 Error
342 /// \~english @par Prerequisite
343 /// - Initialize attr with CL_ProcessCreateAttrInit.
344 /// \~english @par Change of internal state
345 /// - Change of internal state according to the API does not occur.
346 /// \~english @par Conditions of processing failure
347 /// - When the pointer of the process attribute specified (attr) in the argument is NULL,
348 /// set errno to EINVAL, -1 is returned.
349 /// \~english @par Detail
350 /// Set process attribute to group ID.\n
351 /// When 0 is set for the group ID,
352 /// it is not reflected in the process attribute becose if is played by the process of CL_ProcessCreate().\n
353 /// \~english @par Classification
355 /// \~english @par Type
359 ////////////////////////////////////////////////////////////////////////////////////
360 int CL_ProcessCreateAttrSetGid(CL_ProcessAttr_t *attr, gid_t gid); // NOLINT(readability/nolint)
362 ////////////////////////////////////////////////////////////////////////////////////
363 /// \ingroup CL_ProcessCreateAttrSetSchedule
364 /// \~english @par Brief
365 /// Set process attribute to schedule policy and priority
366 /// \~english @param [in,out] attr
367 /// const CL_ProcessAttr_t* - Process attribute pointer
368 /// \~english @param [in] policy
369 /// CL_ProcessSchedPolicy_t - schedule policy
370 /// \~english @param [in] priority
373 /// CL_ProcessAttr_t struct
377 /// } CL_ProcessAttr_t;
380 /// enum CL_ProcessSchedPolicy_t Variable
383 /// CL_PROCESS_SCHED_POLICY_OTHER = 0, // TSS
384 /// CL_PROCESS_SCHED_POLICY_RR, // Round-robin
385 /// CL_PROCESS_SCHED_POLICY_FIFO, // FIFO
386 /// } CL_ProcessSchedPolicy_t;
389 /// target to priority
390 /// - -20~19 : CL_PROCESS_SCHED_POLICY_OTHER
391 /// - 1~99 : CL_PROCESS_SCHED_POLICY_RR or CL_PROCESS_SCHED_POLICY_FIFO
392 /// \~english @retval 0 Success
393 /// \~english @retval -1 Error
394 /// \~english @par Prerequisite
395 /// - Initialize attr with CL_ProcessCreateAttrInit.
396 /// \~english @par Change of internal state
397 /// - Change of internal state according to the API does not occur.
398 /// \~english @par Conditions of processing failure
399 /// - When the pointer of the process attribute specified (attr) in the argument is NULL,
400 /// set errno to EINVAL, -1 is returned.
401 /// - When the schedule policy (policy) specified in the parameter is CL_PROCESS_SCHED_POLICY_RR
402 /// and the priority (priority) is other than 1 to 99, set errno to EINVAL, -1 is returned.
403 /// - When the schedule policy (policy) specified in the parameter is CL_PROCESS_SCHED_POLICY_FIFO
404 /// and the priority (priority) is other than 1 to 99, set errno to EINVAL, -1 is returned.
405 /// - Incorrect parameters are specified for the schedule policy (policy) specified in the arguments,
406 /// set errno to EINVAL, -1 is returned.
407 /// \~english @par Detail
408 /// Set process attribute to schedule policy and priority.\n
409 /// Error occur if the real-time schedule policy is set and
410 /// the priority is passed value outside the range of 1-99.\n
411 /// In the case of TSS, an error does not occur even if it is outside the range of -20 to 19,
412 /// but ti is rounded to the nearest integer by a system call when a process is created.\n
413 /// If not set by this funtion, the schedule policy set the TSS and priority sets 0.\n
414 /// \~english @par Classification
416 /// \~english @par Type
420 ////////////////////////////////////////////////////////////////////////////////////
421 int CL_ProcessCreateAttrSetSchedule(CL_ProcessAttr_t *attr, // NOLINT(readability/nolint)
422 CL_ProcessSchedPolicy_t policy,
425 ////////////////////////////////////////////////////////////////////////////////////
426 /// \ingroup CL_ProcessCreateAttrSetGroup
427 /// \~english @par Brief
428 /// Set process attribute to process group
429 /// \~english @param [in,out] attr
430 /// const CL_ProcessAttr_t* - Process attribute pointer
431 /// \~english @param [in] create
435 /// - 0 not make(default)
437 /// CL_ProcessAttr_t struct
441 /// } CL_ProcessAttr_t;
443 /// \~english @retval 0 Success
444 /// \~english @retval -1 Error
445 /// \~english @par Prerequisite
446 /// - Initialize attr with CL_ProcessCreateAttrInit.
447 /// \~english @par Change of internal state
448 /// - Change of internal state according to the API does not occur.
449 /// \~english @par Conditions of processing failure
450 /// - When the pointer of the process attribute specified (attr) in the argument is NULL,
451 /// set errno to EINVAL, -1 is returned.
452 /// - When a value oher than 0 or 1 is secified for the process group cration flag (create)
453 /// specified in the parameter, set errno to EINVAL, -1 is returned.
454 /// \~english @par Detail
455 /// Set process attribute to process group.\n
456 /// When a process group is created, all descendant process fork from child process also belong
457 /// to the same process group, and the entire process group can be forcibly terminated.\n
458 /// \~english @par Classification
460 /// \~english @par Type
464 ////////////////////////////////////////////////////////////////////////////////////
465 int CL_ProcessCreateAttrSetGroup(CL_ProcessAttr_t *attr, int create); // NOLINT(readability/nolint)
467 int CL_ProcessCreateAttrSetCpuAssign(CL_ProcessAttr_t *attr, int cpu_assign); // NOLINT(readability/nolint)
469 ////////////////////////////////////////////////////////////////////////////////////
470 /// \ingroup CL_ProcessCreateAttrSetStackSize
471 /// \~english @par Brief
472 /// Set process attribute to stack size
473 /// \~english @param [in,out] attr
474 /// const CL_ProcessAttr_t* - Process attribute pointer
475 /// \~english @param [in] stack_size
476 /// int - stack size(byte)
478 /// CL_ProcessAttr_t struct
482 /// } CL_ProcessAttr_t;
484 /// \~english @retval 0 Success
485 /// \~english @retval -1 Error
486 /// \~english @par Prerequisite
487 /// - Initialize attr with CL_ProcessCreateAttrInit.
488 /// \~english @par Change of internal state
489 /// - Change of internal state according to the API does not occur.
490 /// \~english @par Conditions of processing failure
491 /// - When the pointer of the process attribute specified (attr) in the argument is NULL,
492 /// set errno to EINVAL, -1 is returned.
493 /// \~english @par Detail
494 /// Set process attribute to stack size.\n
495 /// The muximum configurable stack size is 1MB.\n
496 /// \~english @par Classification
498 /// \~english @par Type
502 ////////////////////////////////////////////////////////////////////////////////////
503 int CL_ProcessCreateAttrSetStackSize(CL_ProcessAttr_t *attr, int stack_size); // NOLINT(readability/nolint)
505 ////////////////////////////////////////////////////////////////////////////////////
506 /// \ingroup CL_ProcessCreateAttrSetHoldFds
507 /// \~english @par Brief
508 /// Set process attribute to FD to maintain
509 /// \~english @param [in,out] attr
510 /// const CL_ProcessAttr_t* - Process attribute pointer
511 /// \~english @param [in] hold_fds[]
514 /// CL_ProcessAttr_t struct
518 /// } CL_ProcessAttr_t;
520 /// \~english @retval 0 Success
521 /// \~english @retval -1 Error
522 /// \~english @par Prerequisite
523 /// - Initialize attr with CL_ProcessCreateAttrInit.
524 /// \~english @par Change of internal state
525 /// - Change of internal state according to the API does not occur.
526 /// \~english @par Conditions of processing failure
527 /// - When the pointer of the process attribute specified (attr) in the argument is NULL,
528 /// set errno to EINVAL, -1 is returned.
529 /// - When the array (hode_openfd[]) storing the list of the FD to be maintained specified
530 /// by the arguments is NULL, set errno to EINVAL, -1 is returned.
531 /// \~english @par Detail
532 /// Set process attribute to FD to maintain.\n
533 /// When nothing is set, FD other than 0, 1, and 2 are automatically close.\n
534 /// For hold_openfds is stored in a CL_PROCESSS_ATTR_HOLD_FDS_NUM array,
535 /// it is recommended that int hold_openfds[CL_PROCESSS_ATTR_HOLD_FDS_NUM] be used.\n
536 /// \~english @par Classification
538 /// \~english @par Type
542 ////////////////////////////////////////////////////////////////////////////////////
543 int CL_ProcessCreateAttrSetHoldFds(CL_ProcessAttr_t *attr, int hold_fds[]); // NOLINT(readability/nolint)
545 ////////////////////////////////////////////////////////////////////////////////////
546 /// \ingroup CL_ProcessCreateAttrSetDisableCloseFds
547 /// \~english @par Brief
548 /// Set process attribute to suspend forced FD close
549 /// \~english @param [in,out] attr
550 /// const CL_ProcessAttr_t* - Process attribute pointer
552 /// CL_ProcessAttr_t struct
556 /// } CL_ProcessAttr_t;
558 /// \~english @retval 0 Success
559 /// \~english @retval -1 Error
560 /// \~english @par Prerequisite
561 /// - Initialize attr with CL_ProcessCreateAttrInit.
562 /// \~english @par Change of internal state
563 /// - Change of internal state according to the API does not occur.
564 /// \~english @par Conditions of processing failure
565 /// - When the pointer of the process attribute specified (attr) in the argument is NULL,
566 /// set errno to EINVAL, -1 is returned.
567 /// \~english @par Detail
568 /// Set process attribute to suspend forced FD close.\n
569 /// \~english @par Classification
571 /// \~english @par Type
575 ////////////////////////////////////////////////////////////////////////////////////
576 int CL_ProcessCreateAttrSetDisableCloseFds(CL_ProcessAttr_t *attr); // NOLINT(readability/nolint)
578 ////////////////////////////////////////////////////////////////////////////////////
579 /// \ingroup CL_ProcessCreateAttrSetCgroup
580 /// \~english @par Brief
581 /// Set process attribute to Cgroup
582 /// \~english @param [in,out] attr
583 /// const CL_ProcessAttr_t* - Process attribute pointer
584 /// \~english @param [in] cgroup_name
585 /// const char* - Cgroup name
587 /// CL_ProcessAttr_t struct
591 /// } CL_ProcessAttr_t;
593 /// \~english @retval 0 Success
594 /// \~english @retval -1 Error
595 /// \~english @par Prerequisite
596 /// - Initialize attr with CL_ProcessCreateAttrInit.
597 /// - cgroup specified by CL_ProcessCreateCgroupCreate() has been created.
598 /// \~english @par Change of internal state
599 /// - Change of internal state according to the API does not occur.
600 /// \~english @par Conditions of processing failure
601 /// - When the pointer of the process attribute specified (attr) in the argument is NULL,
602 /// set errno to EINVAL, -1 is returned.
603 /// - When the pointer (name) to the character string hat stores the process name specified
604 /// by the argument is NULL, set errno to EINVAL, -1 is returned.
605 /// - When the character string length of the character string (cgroup_name) storing the process name specified
606 /// by the argument is 64 byte or more, set errno to EINVAL, -1 is returned.
607 /// \~english @par Detail
608 /// Set process attribute to Cgroup.\n
609 /// Creat new Cgroup with CL_ProcessCreateCgroupCreate().\n
610 /// An error occurs if an Cgroup name that does not exist is specified.\n
611 /// \~english @par Classification
613 /// \~english @par Type
617 ////////////////////////////////////////////////////////////////////////////////////
618 int CL_ProcessCreateAttrSetCgroup(CL_ProcessAttr_t *attr, // NOLINT(readability/nolint)
619 const char *cgroup_name);
621 /////////////////////////////////////////////////////////////////////////////////////
622 /// \ingroup CL_ProcessTerminate
623 /// \~english @par Brief
625 /// \~english @param [in] pid
627 /// \~english @retval int file descriptor
628 /// \~english @retval -1 Error
629 /// \~english @par Prerequisite
630 /// - CL_ProcessInit and CL_ProcessCreate must be running.
631 /// (Process ID to be forcibly terminated exists)
632 /// \~english @par Change of internal state
633 /// - Change of internal state according to the API does not occur.
634 /// \~english @par Conditions of processing failure
635 /// - When the process ID to be forcibly terminated does not exist, -1 is returned.
636 /// \~english @par Detail
637 /// The PID of the process is he return value (PID) of CL_ProcessCreate().
638 /// \~english @par Classification
640 /// \~english @par Type
644 /////////////////////////////////////////////////////////////////////////////////////
645 int CL_ProcessTerminate(pid_t pid); // NOLINT(readability/nolint)
647 /////////////////////////////////////////////////////////////////////////////////////
648 /// \ingroup CL_ProcessTerminateGroup
649 /// \~english @par Brief
650 /// Kill process group
651 /// \~english @param [in] pid
652 /// pid_t - process group ID
653 /// \~english @retval int file descriptor
654 /// \~english @retval -1 Error
655 /// \~english @par Prerequisite
656 /// - CL_ProcessInit and CL_ProcessCreate must be running.
657 /// (Process ID to be forcibly terminated exists)
658 /// \~english @par Change of internal state
659 /// - Change of internal state according to the API does not occur.
660 /// \~english @par Conditions of processing failure
661 /// - When the process ID to be forcibly terminated does not exist, -1 is returned.
662 /// \~english @par Detail
663 /// The process group ID is he return value (PID) of CL_ProcessCreate().
664 /// \~english @par Classification
666 /// \~english @par Type
670 /////////////////////////////////////////////////////////////////////////////////////
671 int CL_ProcessTerminateGroup(pid_t pid); // NOLINT(readability/nolint)
673 int CL_ProcessAbort(pid_t pid); // NOLINT(readability/nolint)
675 int CL_ProcessAbortGroup(pid_t pid); // NOLINT(readability/nolint)
677 int CL_ProcessEuthanizeGroup(pid_t pid); // NOLINT(readability/nolint)
679 /////////////////////////////////////////////////////////////////////////////////////
680 /// \ingroup CL_ProcessCleanup
681 /// \~english @par Brief
682 /// Collect child process
683 /// \~english @param [in] sigchld_fd
684 /// int - CL_ProcessInit() function return to fd
685 /// \~english @param [out] cleanup_info
686 /// CL_ProcessCleanupInfo_t* - Pointer to chiled process info
688 /// CL_ProcessCleanupInfo_t struct
691 /// pid_t pid; /* The process ID of the child. */
692 /// int code; /* signal code */
693 /// int status; /* the exit status of the child or the signal */
694 /// } CL_ProcessCleanupInfo_t;
696 /// \~english @retval 0 Success
697 /// \~english @retval 1 Success
698 /// (If WNOHANG was specified and no child(ren) specified by id has yet changed state)
699 /// \~english @retval -1 Error (setting to errno)
700 /// \~english @par Prerequisite
701 /// - Must be runnning CL_ProcessInit.
702 /// \~english @par Change of internal state
703 /// - Change of internal state according to the API does not occur.
704 /// \~english @par Conditions of processing failure
705 /// - When the pointer (cleanup_info) to the child process information structure is NULL,
706 /// set errno to EINVAL, -1 is returned.
707 /// - When a systemu call (waitid) fails, -1 is returned.
708 /// - When there are no child process in state waitable, set errno to EINVAL, -1 is returned.
709 /// \~english @par Detail
710 /// This API must be called before createing a thread.\n
712 /// It must be called many times while the return valu is 1.
713 /// After the return value reaches 0, calling it again results in an error (ECHILD).\n
714 /// The code of CL_ProcessCleanupInfo_t cotains the following value:\n
715 /// - CLD_EXITED : Finished child process (exited)
716 /// - CLD_KILLED : Killed child process
717 /// - CLD_DUMPED : Ended abnormally child process
718 /// - CLD_TRAPPED : Trapped traced child process
719 /// - CLD_STOPPED : Stopped child process (stop)
720 /// - CLD_CONTINUED restarted the sopped child process (after Linux 2.6.9)
721 /// - The exit status is stored in status only when code is CLD_EXITED. Otherwise, signals are stored.
722 /// - Need to include signal.h to use CLD_*.
723 /// \~english @par Classification
725 /// \~english @par Type
729 ////////////////////////////////////////////////////////////////////////////////////
730 int CL_ProcessCleanup(int sigchld_fd, CL_ProcessCleanupInfo_t *cleanup_info); // NOLINT(readability/nolint)
732 ////////////////////////////////////////////////////////////////////////////////////
733 /// \ingroup CL_ThreadCreate
734 /// \~english @par Brief
736 /// \~english @param [out] thread
737 /// pthread_t* - thread hadle
738 /// \~english @param [in] attr
739 /// pthread_attr_t* - Thread attibute pointer for pthread
740 /// \~english @param [in] cl_attr
741 /// CL_ThreadAttr_t* - Tred attribute pointer for expansion
742 /// \~english @param [in] start_routine
743 /// void*(*)(void*) - Pointer to the entry function of the thread
744 /// \~english @param [in] arg
745 /// void* - Argument to the entry function of the thread
747 /// CL_ThreadAttr_t structure
751 /// } CL_ThreadAttr_t;
753 /// \~english @retval 0 Success
754 /// \~english @retval -1 Error (set errno)
755 /// \~english @retval EAGAIN failure to create thread
756 /// \~english @par Prerequisite
757 /// - Prerequisites are nothing.
758 /// \~english @par Change of internal state
759 /// - Change of internal state according to the API does not occur.
760 /// \~english @par Conditions of processing failure
761 /// - When the thread handler (thread) specified in the argument is NULL, set errno to EINVAL, -1 is returned.
762 /// - When the pointer of the thread attribute specified in the argument is NULL,
763 /// set errno to EINVAL, -1 is returned.
764 /// - When the pointer (start_routine) of the entry function of the thread specified by the argument is NULL,
765 /// set errno to EINVAL, -1 is returned.
766 /// - Failure to initialize semaphore, set errno to sem_init, -1 is returned.
767 /// - Failure to create thread (pthread_create), EAGAIN is returned.
768 /// - Failure to rock semaphore (sem_wait), set errno to sem_init, -1 is returned.
769 /// \~english @par Detail
771 /// The extension thread attribute (cl_attr) is used o assign the thread name set
772 /// by CL_ThreadCreateAttrSetName(CL_ThreadAttr_t*, const char*).\n
773 /// \~english @par Classification
777 ////////////////////////////////////////////////////////////////////////////////////
778 int CL_ThreadCreate(pthread_t *thread, pthread_attr_t *attr, // NOLINT(readability/nolint)
779 CL_ThreadAttr_t *cl_attr, void *(*start_routine)(void *),
782 ////////////////////////////////////////////////////////////////////////////////////
783 /// \ingroup CL_ThreadCreateAttrInit
784 /// \~english @par Brief
785 /// Initialize thread attribute
786 /// \~english @param [out] attr
787 /// CL_ThreadAttr_t* - thread attribute pointer
789 /// CL_ThreadAttr_t structure
793 /// } CL_ThreadAttr_t;
795 /// \~english @retval 0 Success
796 /// \~english @retval -1 Error (set errno)
797 /// \~english @par Prerequisite
798 /// - Prerequisites are nothing.
799 /// \~english @par Change of internal state
800 /// - Change of internal state according to the API does not occur.
801 /// \~english @par Conditions of processing failure
802 /// - When the pointer (attr) of the thread attributespecified by the argument is NULL, set errno to EINVAL, -1 is returned.
803 /// \~english @par Detail
804 /// Initialize structure CL_ThreadAttr_t that stores threade attribute.\n
805 /// \~english @par Classification
809 ////////////////////////////////////////////////////////////////////////////////////
810 int CL_ThreadCreateAttrInit(CL_ThreadAttr_t *attr); // NOLINT(readability/nolint)
812 ////////////////////////////////////////////////////////////////////////////////////
813 /// \ingroup CL_ThreadCreateAttrSetName
814 /// \~english @par Brief
815 /// Set thread attribute to thread name
816 /// \~english @param [out] attr
817 /// CL_ThreadAttr_t* - thread attribute pointer
818 /// \~english @param [in] name
819 /// const char* - Pointer to the string storing the thread name (max length 16byte)
821 /// CL_ThreadAttr_t structure
825 /// } CL_ThreadAttr_t;
827 /// \~english @retval 0 Success
828 /// \~english @retval -1 Error (set errno)
829 /// \~english @par Prerequisite
830 /// - Prerequisites are nothing.
831 /// \~english @par Change of internal state
832 /// - Change of internal state according to the API does not occur.
833 /// \~english @par Conditions of processing failure
834 /// - When the pointer (attr) of thread attribute specified by the argument is NULL, set errno to EINVAL, -1 is returned.
835 /// - When the pointer (name) to the character string that stores the thread name specified
836 /// by the argument is NULL, set errno to EINVAL, -1 is returned.
837 /// \~english @par Detail
838 /// Set thread attribute to thread name\n
839 /// The characer string that stores the thread name specified by the argument must satisfy the following conditions:\n
840 /// - Terminated by a NULL.\n
841 /// - The maximum lengthof character string is 16 byte including the termination character.\n
842 /// \~english @par Classification
846 ////////////////////////////////////////////////////////////////////////////////////
847 int CL_ThreadCreateAttrSetName(CL_ThreadAttr_t *attr, const char *name); // NOLINT(readability/nolint)
849 ////////////////////////////////////////////////////////////////////////////////////
850 /// \ingroup CL_ProcessCreateCgroupCreate
851 /// \~english @par Brief
853 /// \~english @param [in] cgroup_name
854 /// const char* - cgroup name
855 /// \~english @param [in] attr
856 /// const CL_ProcessCreateCgroupAttr_t* - Cgroup attribut
858 /// CL_ProcessCreateCgroupAttr_t struct
862 /// } CL_ProcessCreateCgroupAttr_t;
864 /// \~english @retval 0 Success
865 /// \~english @retval -1 Error
866 /// \~english @par Prerequisite
867 /// - Initialize attr by CL_ProcessCreateCgroupAttrInit
868 /// \~english @par Change of internal state
869 /// - Change of internal state according to the API does not occur.
870 /// \~english @par Conditions of processing failure
871 /// - When the Cgroup name (cgroup_name) specified by the argument is NULL, set errno to EINVAL, -1 is returned.
872 /// - When the pointer (attr) of the Cgroup attribute specified by the argumet is NULL,
873 /// set errno to EINVAL, -1 is returned.
874 /// - When the area for directory path name of the CPU subsystem of Cgroup could not be allocated,
875 /// set errno to EINVAL, -1 is returned.
876 /// - When the area for directory of the CPU subsystem of Cgroup could not be create, -1 is returned.
877 /// - When the area for file path name of the CPU subsystem of Cgroup could not be allocated,
878 /// set errno to EINVAL, -1 is returned.
879 /// - When file descriptor of the CPU subsystem of Cgroup could not be acquired, -1 is returned.
880 /// - When setting value to CPU subsystem of Cgroup could not be written, -1 is returned.
881 /// - When the area for directory path name of the memory subsystem of Cgroup could not be allocated,
882 /// set errno to EINVAL, -1 is returned.
883 /// - When the area for directory of the memory subsystem of Cgroup could not be create, -1 is returned.
884 /// - When the area for file path name of the memory subsystem of Cgroup could not be allocated,
885 /// set errno to EINVAL, -1 is returned.
886 /// - When file descriptor of the memory subsystem of Cgroup could not be acquired, -1 is returned.
887 /// - When setting value to memory subsystem of Cgroup could not be written, -1 is returned.
888 /// \~english @par Detail
889 /// Create Cgroup to which the process to be created belongs.
890 /// If it belongs to Cgroup that has already been created, it is not necessary to create it.\n
892 /// Since the Cgroup attribute cannot be changed during Cgroup, if it is necessary o chage the Cgroup attribute,
893 /// it is necessary to call the following API and change the Cgroup attribute calling this API.\n
894 /// - CL_ProcessCreateCgroupAttrInit :Initialize Cgroup attribute
895 /// - CL_ProcessCreateCgroupAttrSetCfsBandwidthControl :TSS process CPU time control by Bandwidth Control
896 /// - CL_ProcessCreateCgroupAttrSetCpuShares :TSS process CPU time control
897 /// - CL_ProcessCreateCgroupAttrSetMemoryLimit :Contol memory usage
898 /// - CL_ProcessCreateCgroupAttrSetMemoryUsageNotification :Memory usage notification setting
899 /// - CL_ProcessCreateCgroupAttrSetRtThrottling :FIFO/RR process CPU time control
900 /// \~english @par Classification
902 /// \~english @par Type
905 /// CL_ProcessCreateCgroupDelete,
906 /// CL_ProcessCreateCgroupAttrInit, CL_ProcessCreateCgroupAttrSetCfsBandwidthControl,
907 /// CL_ProcessCreateCgroupAttrSetCpuShares, CL_ProcessCreateCgroupAttrSetMemoryLimit,
908 /// CL_ProcessCreateCgroupAttrSetMemoryUsageNotification, CL_ProcessCreateCgroupAttrSetRtThrottling,
909 ////////////////////////////////////////////////////////////////////////////////////
910 int CL_ProcessCreateCgroupCreate(const char *cgroup_name, // NOLINT(readability/nolint)
911 CL_ProcessCreateCgroupAttr_t *attr);
913 ////////////////////////////////////////////////////////////////////////////////////
914 /// \ingroup CL_ProcessCreateCgroupAttrInit
915 /// \~english @par Brief
916 /// Initialize Cgroup attribute
917 /// \~english @param [out] attr
918 /// const CL_ProcessCreateCgroupAttr_t* - Cgroup attribute pointer
920 /// CL_ProcessCreateCgroupAttr_t struct
924 /// } CL_ProcessCreateCgroupAttr_t;
926 /// \~english @retval 0 Success
927 /// \~english @retval -1 Error
928 /// \~english @par Prerequisite
929 /// - Prerequisites are nothing.
930 /// \~english @par Change of internal state
931 /// - Change of internal state according to the API does not occur.
932 /// \~english @par Conditions of processing failure
933 /// - When the pointer of Cgroup attribute (attr) specified in the arguments is NULL, set errno to EINVAL, -1 is returned.
934 /// \~english @par Detail
935 /// Initialize Cgroup attibute with 0.\n
936 /// \~english @par Classification
938 /// \~english @par Type
942 ////////////////////////////////////////////////////////////////////////////////////
943 int CL_ProcessCreateCgroupAttrInit(CL_ProcessCreateCgroupAttr_t *attr); // NOLINT(readability/nolint)
945 ////////////////////////////////////////////////////////////////////////////////////
946 /// \ingroup CL_ProcessCreateCgroupAttrSetRtThrottling
947 /// \~english @par Brief
948 /// Set FIFO/RR process CPU time control
949 /// \~english @param [in,out] attr
950 /// const CL_ProcessCreateCgroupAttr_t* - Cgroup attribute
951 /// \~english @param [in] runtime_us
952 /// int - CPU allocation time(us)
954 /// CL_ProcessCreateCgroupAttr_t struct
958 /// } CL_ProcessCreateCgroupAttr_t;
960 /// \~english @retval 0 Success
961 /// \~english @retval -1 Error
962 /// \~english @par Prerequisite
963 /// - Initialize attr with CL_ProcessCreateCgroupAttrInit.
964 /// \~english @par Change of internal state
965 /// - Change of internal state according to the API does not occur.
966 /// \~english @par Conditions of processing failure
967 /// - When the pointer of Cgroup attribute (attr) specified in the arguments is NULL,
968 /// set errno to EINVAL, -1 is returned.
969 /// \~english @par Detail
970 /// Limiting the CPU time allocated to a process to
971 /// which a real-time class schedule policy (SCHED_FIFO/SCHED_RR) is applied.\n
972 /// Set the value of argument runtime_us to the cpu.rt_runtime_us (CPU allocation time) of created Cgroup.\n
973 /// cpu.rt_period_us(unit time:1000000us) is not changed.\n
974 /// If not set, Cgroup created will remain at default (CPU allocation time:950000us).\n
975 /// The configurable range of runtime_us depends on the use of Cgroup and the kernel version.
976 /// The user sets an appropriate value.\n
977 /// \~english @par Classification
979 /// \~english @par Type
983 ////////////////////////////////////////////////////////////////////////////////////
984 int CL_ProcessCreateCgroupAttrSetRtThrottling( // NOLINT(readability/nolint)
985 CL_ProcessCreateCgroupAttr_t *attr, int runtime_us);
987 ////////////////////////////////////////////////////////////////////////////////////
988 /// \ingroup CL_ProcessCreateCgroupAttrSetCpuShares
989 /// \~english @par Brief
990 /// Set TSS process CPU time control
991 /// \~english @param [in,out] attr
992 /// const CL_ProcessCreateCgroupAttr_t* - Cgroup attribute pointer
993 /// \~english @param [in] cpu_shares
994 /// int - An integer value that sepcified the relative distribution of CPU time
996 /// CL_ProcessCreateCgroupAttr_t struct
1000 /// } CL_ProcessCreateCgroupAttr_t;
1002 /// \~english @retval 0 Success
1003 /// \~english @retval -1 Error
1004 /// \~english @par Prerequisite
1005 /// - Initialize attr with CL_ProcessCreateCgroupAttrInit
1006 /// \~english @par Change of internal state
1007 /// - Change of internal state according to the API does not occur.
1008 /// \~english @par Conditions of processing failure
1009 /// - When the pointer (attr) of the Cgroup attribute specified by the argument is NULL,
1010 /// set errno to EINVAL, -1 is returned.
1011 /// \~english @par Detail
1012 /// Cotrols the CPU time allocated to a process to which
1013 /// a class TSS schedule policy (SCHED_OTHER, etc.) is applied.\n
1014 /// If cpu_shares is set with this function, a single Cgroup is created and cpu.shares is set with that value.\n
1015 /// If not set, remain at default.\n
1016 /// cpu_shares is set to the standard value 1024, and CPU time is allocated according
1017 /// to the allocaion value specified between Cgroup.\n
1018 /// Task Cgroup with cpu.shares set to 1024 has twice as much CPU time as
1019 /// task Cgroup with cpu.shares set to 512.\n
1020 /// Processes belonging to the same Cgroup are equally allocated CPU time allocated to Cgroup.\n
1021 /// Note that the time distribution is distributed across al CPU cores on a multi-core system.\n
1022 /// In a multicore system, if Cgroup limit is set to 100% of the CPU,
1023 /// 100% of each CPU core wil be available.\n\n
1024 /// Examle) If Cgroup A is set to use 25% of the CPU and Cgroup B is set to use 75% of the CPU,\n
1025 /// and a process that uses CPU intensively is started on a 4-core system (1 process in A and 3 processes in B),\n
1026 /// the CPU allocaion is distributed as follows.\n\n
1028 /// | PID | cgroup | CPU | CPU allotment |
1029 /// |:---:|:------:|:---:|:-------:|
1030 /// | 100 | A | 0 | CPU0 100% |
1031 /// | 101 | B | 1 | CPU1 100% |
1032 /// | 102 | B | 2 | CPU2 100% |
1033 /// | 103 | B | 3 | CPU3 100% |
1035 /// \~english @par Classification
1037 /// \~english @par Type
1041 ////////////////////////////////////////////////////////////////////////////////////
1042 int CL_ProcessCreateCgroupAttrSetCpuShares(CL_ProcessCreateCgroupAttr_t *attr, // NOLINT(readability/nolint)
1045 ///////////////////////////////////////////////////////////////////////////////////
1046 /// \ingroup CL_ProcessCreateCgroupAttrSetCfsBandwidthControl
1047 /// \~english @par Brief
1048 /// Set TS process CU time control by Bandwidth Control
1049 /// \~english @param [in,out] attr
1050 /// const CL_ProcessCreateCgroupAttr_t* - Cgroup attribute pointer
1051 /// \~english @param [in] cfs_quota_us
1052 /// int - CPU allocation time
1054 /// CL_ProcessCreateCgroupAttr_t struct
1056 /// typedef struct {
1058 /// } CL_ProcessCreateCgroupAttr_t;
1060 /// \~english @retval 0 Success
1061 /// \~english @retval -1 Error
1062 /// \~english @par Prerequisite
1063 /// - Initialize attr with CL_ProcessCreateCgroupAttrInit
1064 /// \~english @par Change of internal state
1065 /// - Change of internal state according to the API does not occur.
1066 /// \~english @par Conditions of processing failure
1067 /// - When the pointer of the process attribute specified (attr) in the argument is NULL,
1068 /// set errno to EINVAL, -1 is returned.
1069 /// \~english @par Detail
1070 /// Controls the amount of time allocated to processes o whitch TSS class schedule plicy (SCHED_OTHER, etc.) are
1071 /// applied using bandwidth control of CFS(Completely Fair Scheduler) implemented from kernel 3.2.\n
1072 /// Set the value of argument cfs_quota_us to the cpu.cfs_quota_us of created Cgroup.\n
1073 /// cpu.cfs_period_us(unit time:1000000us) is not changed.\n
1074 /// If not set, the created Cgroup will not have CPU allocatio control. (set cpu.cfs_guota_us to -1).\n
1075 /// The time (%) allocated to Cgroup can be set correctly,
1076 /// and it can be allocated correctly if the CPU is free.\n
1077 /// It is scheduled to be allocated as much as possible even if it conflicts with other Cgroup's.\n
1078 /// \~english @par Classification
1080 /// \~english @par Type
1084 ////////////////////////////////////////////////////////////////////////////////////
1085 int CL_ProcessCreateCgroupAttrSetCfsBandwidthControl( // NOLINT(readability/nolint)
1086 CL_ProcessCreateCgroupAttr_t *attr, int cfs_quota_us);
1088 /////////////////////////////////////////////////////////////////
1089 /// \ingroup CL_ProcessCreateCgroupAttrSetMemoryLimit
1090 /// \~english @par Brief
1091 /// Control memory usage
1092 /// \~english @param [in,out] attr
1093 /// const CL_ProcessCreateCgroupAttr_t* - Cgroup attribute pointer
1094 /// \~english @param [in] memory_limit
1095 /// int - memory limit (byte)
1097 /// CL_ProcessCreateCgroupAttr_t struct
1099 /// typedef struct {
1101 /// } CL_ProcessCreateCgroupAttr_t;
1103 /// \~english @retval 0 Success
1104 /// \~english @retval -1 Error
1105 /// \~english @par Prerequisite
1106 /// - Initialize attr with CL_ProcessCreateCgroupAttrInit
1107 /// \~english @par Change of internal state
1108 /// - Change of internal state according to the API does not occur.
1109 /// \~english @par Conditions of processing failure
1110 /// - When the pointer of the process attribute specified (attr) in the argument is NULL,
1111 /// set errno to EINVAL, -1 is returned.
1112 /// \~english @par Detail
1113 /// Control the CPU time allocated to a process.\n
1114 /// Set the value of argument memory_limit to the memory.limit_in_bytes of created Cgroup.\n
1115 /// If not set, there is no memory limit.When a request exceeding the memory limit is issued,
1116 /// a SIGKILL is sent from the kernel and the process is discarded.
1117 /// Note: When the memory limit is exceeded, control moves to 00M,
1118 /// but its operation ca be changed (Documentation/cgroup/memory.txt).\n
1119 /// Write memory.oom_control to 1 to stop the OOM-Killer.
1120 /// When OOM-Killer is stopped, the task below Cgroup becomes hang/sleep.\n
1121 /// The task moves when the limit of the memory Cgroup increaes or when usage decreases. When usage decreases,\n
1122 /// - Task was killed\n
1123 /// - Task was moved other group\n
1124 /// - File has been deleted\n
1126 /// You can also receive a eventf notification from OOM.\n
1127 /// Memory usage is counted as follows\n
1128 /// - RSS(All mapped anon pages)\n
1130 /// - First acess Shared Pages in Cgroup\n
1131 /// \~english @par Classification
1133 /// \~english @par Type
1137 ////////////////////////////////////////////////////////////////////////////////////
1138 int CL_ProcessCreateCgroupAttrSetMemoryLimit(CL_ProcessCreateCgroupAttr_t *attr, // NOLINT(readability/nolint)
1141 ////////////////////////////////////////////////////////////////////////////////////
1142 /// \ingroup CL_ProcessCreateCgroupAttrSetMemoryUsageNotification
1143 /// \~english @par Brief
1144 /// Set notificatio when memory usage exceeds the specified amount
1145 /// \~english @param [in,out] attr
1146 /// const CL_ProcessCreateCgroupAttr_t* - Cgroup attribute pointer
1147 /// \~english @param [in] usage_in_bytes
1148 /// int - usage in bytes(byte)
1149 /// \~english @param [in] event_fd
1150 /// int - File dexcriptor created by system call eventfd()
1152 /// CL_ProcessCreateCgroupAttr_t struct
1154 /// typedef struct {
1156 /// } CL_ProcessCreateCgroupAttr_t;
1158 /// \~english @retval 0 Success
1159 /// \~english @retval -1 Error
1160 /// \~english @par Prerequisite
1161 /// - Initialize attr with CL_ProcessCreateCgroupAttrInit
1162 /// \~english @par Change of internal state
1163 /// - Change of internal state according to the API does not occur.
1164 /// \~english @par Conditions of processing failure
1165 /// - When the pointer of the process attribute specified (attr) in the argument is NULL,
1166 /// set errno to EINVAL, -1 is returned.
1167 /// - When event_fd is negative for a file descriptor created by system call eventfd(),
1168 /// set errno to EINVAL, -1 is returned.
1169 /// \~english @par Detail
1170 /// event_fd is notifued when memory usage exceeds argument usage_in_bytes.\n
1171 /// See eventfd for details of event_fd.\n
1172 /// \~english @par Classification
1174 /// \~english @par Type
1178 ////////////////////////////////////////////////////////////////////////////////////
1179 int CL_ProcessCreateCgroupAttrSetMemoryUsageNotification( // NOLINT(readability/nolint)
1180 CL_ProcessCreateCgroupAttr_t *attr, int usage_in_bytes, int event_fd);
1182 ////////////////////////////////////////////////////////////////////////////////////
1183 /// \ingroup CL_ProcessCreateCgroupDelete
1184 /// \~english @par Brief
1186 /// \~english @param [in] cgroup_name
1187 /// const char* - cgroup name
1188 /// \~english @retval 0 Success
1189 /// \~english @retval -1 Error
1190 /// \~english @par Prerequisite
1191 /// - Need to be runnning CL_ProcessCreateCgroupCreate.
1192 /// \~english @par Change of internal state
1193 /// - Change of internal state according to the API does not occur.
1194 /// \~english @par Conditions of processing failure
1195 /// - When the Cgroup (cgroup_name) name specified inthe argument is NULL, set errno to EINVAL, -1 is returned.
1196 /// - When the area for directory path name of the CPU subsystem of Cgroup and
1197 /// memory subsystem of Cgroup could not be allocated, set errno to EINVAL, -1 is returned.
1198 /// - When the area for the directory path name of the memory subsystem of Cgroup cannot be allocated and
1199 /// the directory for the CPU subsystem of Cgroup does not exist, set errno to EINVAL, -1 is returned.
1200 /// - When the directory for the CPU subsystem of Cgroup does not exist and
1201 /// the area for the directory path name of the memory subsystem of Cgroup cannot be allocated,
1202 /// set errno to EINVAL, -1 is returned.
1203 /// - When the directory for the memory subsystem of Cgroup and
1204 /// the directory for the CPU subsystem of Cgroup does not exist, set errno to EINVAL, -1 is returned.
1205 /// - When the directory for the memory subsystem of Cgroup could not be deleted, -1 is returned.
1206 /// - When the directory for the CPU subsystem of Cgroup could not be deleted, -1 is returned.
1207 /// \~english @par Detail
1208 /// Delete Cgroup. If there is a proess belonging to Cgroup, error code (EBUSY) is returned.\n
1210 /// Success is also notified in the following cases:\n
1211 /// - When the area for directory path name of memory subsyste Cgroup could not be allocated
1212 /// but CPU subsystem of Cgroup was deleted successfully.
1213 /// - When the directory for the memory subsystem of Cgroup does not exist,
1214 /// but CPU subsystem of Cgroup was deleted successfully.
1215 /// - When the area for directory path name of CPU subsyste Cgroup could not be allocated
1216 /// but memory subsystem of Cgroup was deleted successfully.
1217 /// - When the directory for the CPU subsystem of Cgroup does not exist,
1218 /// but memory subsystem of Cgroup was deleted successfully.
1219 /// \~english @par Classification
1221 /// \~english @par Type
1224 /// CL_ProcessCreateCgroupCreate
1225 ////////////////////////////////////////////////////////////////////////////////////
1226 int CL_ProcessCreateCgroupDelete(const char *cgroup_name); // NOLINT(readability/nolint)
1228 ////////////////////////////////////////////////////////////////////////////////////
1229 /// \ingroup CL_ProcessCreateCgroupClassify
1230 /// \~english @par Brief
1231 /// Move process to the Cgroup
1232 /// \~english @param [in,out] cgroup_name
1233 /// const char* - Destination A name
1234 /// \~english @param [in] pid
1235 /// pid_t - process ID
1236 /// \~english @retval 0 Success
1237 /// \~english @retval -1 Error
1238 /// \~english @par Prerequisite
1239 /// - Need to be running CL_ProcessCreateCgroupCreate.
1240 /// \~english @par Change of internal state
1241 /// - Change of internal state according to the API does not occur.
1242 /// \~english @par Conditions of processing failure
1243 /// - When the Cgroup (cgroup_name) specified in the argument is NULL, set errno to EINVAL, -1 is returned.
1244 /// - When the area for directory path name of memory subsystem of Cgroup and
1245 /// CPU subsystem of Cgroup could not be allocated, set errno to EINVAL, -1 is returned.
1246 /// - When the area for directory path name of memory subsystem of Cgroup could not be allocated,
1247 /// and the directory for CPU subsystem of Cgroup does not exist, set errno to EINVAL, -1 is returned.
1248 /// - When the directory for memory subsystem of Cgroup does not exist and
1249 /// the directory for CU subsystem of Cgroup could not allocated , set errno to EINVAL, -1 is returned.
1250 /// - When the directory for the memory subsystem of Cgroup and
1251 /// the directory for the CPU subsystem of Cgroup does not exist, set errno to EINVAL, -1 is returned.
1252 /// - When the area for directory path name of the memory subsystem of Cgroup could not allocated,
1253 /// set errno to EINVAL, -1 is returned.
1254 /// - When the file descripter for the memory subsystem of Cgroup could not be obtained, -1 is returned.
1255 /// - When pid could not be written to the file for memory subsystem of Cgroup, -1 is returned.
1256 /// - When the area for directory path name of the CPU subsystem of Cgroup could not be allocated,
1257 /// set errno to EINVAL, -1 is returned.
1258 /// - When the file decsripter for the CPU subsystem of Cgroup could not be allocated, -1 is returned.
1259 /// - When pid could not be written to the file for CPU subsystem of Cgroup, -1 is returned.
1260 /// \~english @par Detail
1261 /// Move process to the Cgroup.\n
1263 /// Success is also notified in the following cases:\n
1264 /// - When the area for directory path name of memory subsyste Cgroup could not be allocated
1265 /// but CPU subsystem of Cgroup was deleted successfully.
1266 /// - When the directory for the memory subsystem of Cgroup does not exist,
1267 /// but CPU subsystem of Cgroup was deleted successfully.
1268 /// - When the area for directory path name of CPU subsyste Cgroup could not be allocated
1269 /// but memory subsystem of Cgroup was deleted successfully.
1270 /// - When the directory for the CPU subsystem of Cgroup does not exist,
1271 /// but memory subsystem of Cgroup was deleted successfully.
1272 /// \~english @par Classification
1274 /// \~english @par Type
1278 ////////////////////////////////////////////////////////////////////////////////////
1279 int CL_ProcessCreateCgroupClassify(const char *cgroup_name, pid_t pid); // NOLINT(readability/nolint)
1281 /** @}*/ // end of common_library
1282 /** @}*/ // end of NativeService
1283 /** @}*/ // end of BaseSystem
1288 #endif // #ifndef _cl_process_h_ // NOLINT(build/header_guard)