diff --git a/en/device-dev/subsystems/subsys-boot-init.md b/en/device-dev/subsystems/subsys-boot-init.md
index f6fecd700f123748cb8e81fc8a9d353c36dcef53..1d8cd45ad6bc70c1078b9f0a0be51cf3d3955029 100644
--- a/en/device-dev/subsystems/subsys-boot-init.md
+++ b/en/device-dev/subsystems/subsys-boot-init.md
@@ -1,85 +1,171 @@
# init Module
-
## Introduction
The init module starts key service processes during system startup. If you would like to add a system service that automatically starts upon system startup, you can add a configuration file named in the **xxx.cfg** format. The system automatically analyzes the **.cfg** file and starts the corresponding service.
- Configuration file of the init module
+
The configuration file of the init module, that is, **init.cfg**, contains service names, executable file paths, permissions, and other information of all key system services that need to be started by the init process. The file can be found in **/etc/** after burning is complete. The file is in JSON format, and its size cannot exceed 100 KB.
After the init process starts, it reads the **/etc/init.cfg** file, parses the content in JSON format, and loads system services in sequence based on the parsing result.
- If you need to add a key service to a module, you can also add the **.cfg** file of the module. During compilation, copy the file to the **/system/etc/init** directory. The init process will parse the **.cfg** file and starts the corresponding service.
+ If you need to add a key service to a module, you can also add the **.cfg** file of the module. The file will be copied to the **/system/etc/init** directory during compilation.
+
+ The init process scans the **.cfg** files in the **/etc/init** directory and parses them one by one. The following describes the file scanning rules and format.
+
+ - File scanning rules
+
+ For the mini and standard systems, the same API is used for scanning **.cfg** files. The code is as follows:
+ ```
+ void ReadConfig(void)
+ {
+ // parse cfg
+ if (InChargerMode() == 1) {
+ ParseInitCfg(INIT_CONFIGURATION_FILE, NULL);
+ ReadFileInDir(OTHER_CHARGE_PATH, ".cfg", ParseInitCfg, NULL);
+ } else if (InUpdaterMode() == 0) {
+ ParseInitCfg(INIT_CONFIGURATION_FILE, NULL);
+ ReadFileInDir(OTHER_CFG_PATH, ".cfg", ParseInitCfg, NULL);
+ ReadFileInDir("/vendor/etc/init", ".cfg", ParseInitCfg, NULL);
+ } else {
+ ReadFileInDir("/etc", ".cfg", ParseInitCfg, NULL);
+ }
+ }
+ ```
+ The macro definition in the code is as follows:
+
+ ```
+ #define INIT_CONFIGURATION_FILE "/etc/init.cfg"
+
+ #define OTHER_CHARGE_PATH "/system/etc/charge"
+
+ #define OTHER_CFG_PATH "/system/etc/init"
+ ```
+ The following describes how the init process scans **.cfg** files in normal system startup. File scanning in charging mode and update mode is beyond the scope of this document.
+ 1. Call the file parsing API to parse the **/etc/init.cfg** file, because this file is one that needs to be preferentially parsed.
+ 2. Traverse the **.cfg** files in the **/etc/init** directory, and call the parsing API to parse the file when a **.cfg** file is matched. (**/etc** is a symbolic link pointing to **/system/etc** and can be regarded as an equivalent.)
+ 3. Traverse the **.cfg** files in the **/vendor/etc/init** directory, and call the parsing API to parse the file when a **.cfg** file is matched. The **.cfg** files in this directory are usually related to the hardware platform.
+
+ - File format
+
+ The **.cfg** file format is as follows:
+ ```
+ {
+ "import" : [
+ "/etc/init.xxx.cfg",
+ "/vendor/etc/init.${ohos.boot.hardware}.cfg"
+ ],
+ "jobs" : [{
+ "name" : "example-stage",
+ "cmds" : [
+ "write /example/file 0",
+ "start example"
+ ]
+ }
+ ],
+ "services" : [{
+ "name" : "example",
+ "path" : ["/system/bin/example"],
+ }
+ ]
+ }
+ ```
+ As mentioned earlier, a **.cfg** file is a text file in JSON format. For the startup module, the init process is required to parse the following types of JSON objects in the **.cfg** file: **import**, **jobs**, and **services**. The three types of JSON objects are described as follows:
+
+ 1. "import": other **.cfg** files into the current **.cfg** file. These files will be parsed in sequence after the current **.cfg** file is parsed.
+ 2. "jobs": command set with a name. Execution of a job is the process of executing commands in **cmds** one by one in sequence. Details about how to trigger a job will be provided in the following sections.
+ 3. "services": a collection of services. The simplest service can be one that has only a name and an executable file path. The basic logic of a service is to fork a subprocess in the init process and then run the executable file of the service in the subprocess. Services form the core of the startup module. The service configuration in the **.cfg** file also includes various attributes and service control modes. More details will be provided in the following sections.
+
+- init service startup control (for standard system or higher)
-- init service startup control (for standard system or higher)
The init process classifies services into three types based on service configurations and starts the services in different phases.
- - **boot**: services that need to be preferentially started in the system. This type of services are started after the init phase is complete.
- - **normal**: common services in the system. These services are started after the init command is executed successfully. This is the default service type.
- - **condition**: services with special requirements. You can run the **start xxx** command to start such a service. Generally, this type of services are started in a condition job or in a certain phase of the init process.
+ - **boot**: services that need to be preferentially started in the system. This type of services are started in the init phase.
+ - **normal**: common services in the system. This type of services are started in the post-init phase. This is the default service type.
+ - condition: services that are started based on the specified conditions. You can run the **start xxx** command to start such a service. Generally, this type of services are started in a condition job or in a certain phase of the init process.
If dependencies exist between services or between services and commands, you need to use **condition** to describe services. For example:
-
-
- ```
- "services" : [{
- "name" : "service1",
- "path" : ["/bin/process1", "param1", "param2"],
- "uid" : 1,
- "gid" : 1,
- "once" : 0,
- "importance" : 1,
- "caps" : [0, 1, 2, 5],
+ ```
+ "services" : [{
+ "name" : "serviceName",
"start-mode" : "condition",
- "cpucore" : [0],
- "critical" : [0, 5, 10],
- "apl" : "normal",
- "d-caps" : ["OHOS_DMS"]
- "jobs" : {
- "on-boot" : "boot",
- "on-start" : "services:service1_start",
- "on-stop" : "services:service1_stop",
- "on-restart" : "services:service1_restart"
- }
},
- ```
+ ```
+- init parallel service control (for standard system or higher)
-- init parallel service control (for standard system or higher)
The init module provides the parallel service processing function, which allows services to execute jobs in different phases.
- **on-start**: a job executed after the service process is forked. The on-start jobs of different services can be executed in parallel. (The on-start job is executed in the subprocess of the service and affects only the subprocess.)
- **on-stop**: a job executed when the service is stopped.
- **on-restart**: a job executed when the service is restarted.
-- init on-demand startup (for standard system or higher)
+ The following is the example configuration:
+ ```
+ "services" : [{
+ "name" : "serviceName",
+ "jobs" : {
+ "on-boot" : "boot",
+ "on-start" : "services:serviceName_start",
+ "on-stop" : "services:serviceName_stop",
+ "on-restart" : "services:serviceName_restart"
+ }
+ },
+ ```
+
+- init on-demand startup (for standard system or higher)
+
Services managed by the init process can be started on demand. Such services are not automatically started during system startup. Instead, they are started by the init process only when a certain event occurs. Typical events that trigger service startup are as follows: Messages are sent over the socket listened by the init process. The samgr process receives a request from the client and needs to start the SA service.
The **ondemand** attribute indicates whether a service is started on demand. If this attribute is set to **true** for a service, the service does not need to be started by running the **start** command. Instead, it is started only when the corresponding event occurs.
+ The following is the example configuration:
+ ```
+ "services" : [{
+ "name" : "serviceName",
+ "ondemand" : true,
+ }]
+ ```
+
- SA process on-demand startup
1. When an application requests an SA handle, the samgr process checks whether the process to which the SA belongs can be dynamically started.
2. If the SA process needs to be started, the samgr process blocks the request. After the init process starts and registers the SA process, the samgr process returns the SA handle.
- Socket process on-demand startup
- 1. The init process creates a socket for socket processes in the pre-fork phase, and listens to network events on this socket.
+ 1. The init process creates a socket for socket processes in the pre-fork phase and listens to network events on this socket.
2. When messages are detected on the socket, the init process starts the socket process for message processing. The init process then stops listening to network data over the socket and waits until the socket process completes message processing.
3. If no more messages need to be processed, the socket process can automatically exit. After that, the init process reclaims the subprocess and listens to network data over the socket again.
- The hot swap service process is started as required. Hot swap events can be started as required based on system parameter changes.
- Enhanced init process startup and recycling
+
The CPU core binding, priority, MAC address, and AccessToken information of the service process can be configured in the configuration file during process startup.
- - Support of CPU core binding for service processes (through modification of the **.cfg** file)
- - Support of priority setting for service processes (through modification of the **.cfg** file)
- - Support of AccessToken setting for service processes and distributed capability setting for system service processes (through modification of the **.cfg** file)
- - Support of the suppression mechanism for service processes (through modification of the **.cfg** file)
+ - Support of CPU core binding for service processes (through modification of the **\*.cfg** file)
+ - Support of priority setting for service processes (through modification of the **\*.cfg** file)
+ - Support of MAC address setting (that is, SELinux tag setting) for service processes (through modification of the **\*.cfg** file)
+ - Support of AccessToken setting for service processes and distributed capability setting for system service processes (through modification of the **\*.cfg** file)
+ - Support of the suppression mechanism for service processes (through modification of the **\*.cfg** file)
+ The following is the example configuration for enhanced init process startup and recycling:
+ ```
+ "services" : [{
+ "name" : "serviceName",
+ "importance" : 1, // Priority setting for service processes
+ "cpucore" : [0], // CPU binding for service processes
+ "critical" : [1, 5, 10], // Suppression for service processes
+ "apl" : "normal", // Ability privilege level setting for service processes
+ "d-caps" : ["OHOS_DMS"], // Distributed capability setting for service processes
+ "secon" : "u:r:distributedsche:s0" // SELinux tag setting for service processes. In this example, u:r:distributedsche:s0 is the SELinux tag.
+ },
+ ```
- init fd proxy (for standard system or higher)
+
fd proxy is an extended mechanism for on-demand startup. It can ensure that the fd state handle is not lost before the service process exits. Specifically, a service process sends the fd to the init process before it exits, and then reclaims the fd from the init process when it is started again.
- This mechanism is implemented using the API provided by the init process. Before a service process exits, it can call the related API to send the fd to the init process over the socket that supports IPC communication. After the service process is restarted, the init process returns the corresponding fd handle to it in the same way.
+ This mechanism is implemented using the API provided by the init process. Before a service process exits, it can call the related API to send the fd to the init process over the socket that supports IPC communication. After the service process is restarted, the init process returns the corresponding fd handle to it in the same way. For details about the APIs, see [fd Proxy APIs](#table14737791479).
- init job
+
A job provided by the init process. It is actually a set of commands. A job can be configured in the **init.cfg** file or the custom **.cfg** file of the module. The parser of the init process aggregates commands of the jobs with the same name into one job. For jobs with the same name, the init process only ensures that the commands in the **init.cfg** file are executed in preference. It does not guarantee the execution sequence of commands in other **.cfg** files.
- Common job: A job executed in a fixed phase during init process startup, for example, pre-init, init, or post-init.
@@ -87,6 +173,37 @@ The init module starts key service processes during system startup. If you would
- job: A user-defined job, which can be executed using the **trigger** command.
- Control job (for standard system or higher): A job triggered based on specified conditions. You can set trigger conditions in such a job. When the corresponding attribute values meet the trigger conditions, the job will be triggered. && and || operations are supported for trigger conditions, and these operations can be used in flexible combinations as needed.
+ - bootchart plug-in
+
+ The bootchart plug-in is an open source tool used to evaluate system performance during Linux startup. It automatically collects information such as the CPU usage, disk throughput, and process status, and displays the evaluation result in graphics to facilitate system startup optimization. For details about the commands provided by begetctl, see [begetctl Command Description](#table14737791480).
+
+ The following describes how to use begetctl in detail.
+
+ Prerequisites
+ 1. Prepare the test environment by installing Python and PyCairo in Linux.
+ pip install pycairo
+ 2. Decompress bootchart-master.tar.
+ tar -zxvf bootchart-master.tar
+
+ The operation procedure is as follows:
+ 1. Start the system.
+ 2. Run the **begetctl bootchart enable** command.
+ 3. Restart the system.
+ 4. Run the **begetctl bootchart stop** command.
+ 5. Run the **begetctl bootchart disable** command.
+ 6. Export the following files from the **/data/bootchart** directory:
+ header
+ proc_diskstats.log
+ proc_ps.log
+ proc_stat.log
+ Save the files to the **bootchart** folder.
+ 7. Run the tar -zcvf bootchart.tgz * command to compress the bootchart.tgz file (only the Linux version is supported) and copy the compressed file to the linux:bootchart-master directory.
+ 8. Go to the
+ **bootchart-master** directory
+ and run the **python3 pybootchartgui.py -f pdf bootchart.tgz** command.
+
+ Expected result:
+ A **bootchart.pdf** file is generated in the **bootchart-master** directory.
## Development Guidelines
@@ -97,8 +214,7 @@ The init module starts key service processes during system startup. If you would
- **init**: operations required for starting system services.
- **post-init**: operations required after system services are started.
-
- ```
+ ```
"jobs" : [{
"name" : "pre-init",
"cmds" : [
@@ -117,91 +233,128 @@ The init module starts key service processes during system startup. If you would
"cmds" : []
}
]
- ```
+ ```
- **Table 1** Job description
-
+ **Table 1** Job description
| Job | Description |
- | -------- | -------- |
+ | :-------- | :-------- |
| pre-init | Job that is executed first. Operations (for example, creating a folder) required before the process startup are executed in the pre-init job. |
| init | Job that is executed in between. Operations (for example, service startup) are executed in this job. |
| post-init | Job that is finally executed. Operations (for example, mounting the device after the driver initialization) required after the process startup are executed in this job. A single job can hold a maximum of 30 commands (Only start, mkdir, chmod, chown, mount, and loadcfg are supported currently). The command name and parameters (128 bytes or less) must be separated by only one space. |
**Table 2** Commands supported by a job
-
- | Command | Format and Example | Description |
- | -------- | -------- | -------- |
- | mkdir | mkdir target folder
Example: mkdir /storage/myDirectory | Creates a folder. mkdir and the target folder must be separated by only one space. |
- | chmod | chmod permission target
Example:
chmod 0600 /storage/myFile.txt
chmod 0750 /storage/myDir | Modifies the permission, which must be in the 0xxx format. chmod, permission, and target must be separated by only one space. |
- | chown | chown uid gid target
Example:
chown 900 800 /storage/myDir
chown 100 100 /storage/myFile.txt | Modifies the owner group. chown, uid, gid, and target must be separated by only one space. |
- | mount | mount fileSystemType src dst flags data
Example:
mount vfat /dev/mmcblk0 /sdc rw,umask=000
mount jffs2 /dev/mtdblock3 /storage nosuid | Mounts devices. Every two parameters must be separated by only one space. Currently, supported flags include nodev, noexec, nosuid, rdonly, and optionally data. |
- | start | start serviceName
Example:
start foundation
start shell | Starts services. serviceName must be contained in the services array. |
- | loadcfg | loadcfg filePath
Example: loadcfg /patch/fstab.cfg | Loads other .cfg files. The maximum size of the target file (Only /patch/fstab.cfg supported currently) is 50 KB. Each line in the /patch/fstab.cfg file is a command. The command types and formats must comply with their respective requirements mentioned in this table. A maximum of 20 commands are allowed. |
-
-2. Configure the services array, which holds all system services (a maximum of 100) that need to be started by the init process.
-
- ```
- "services" : [{
- "name" : "service1",
- "path" : ["/bin/process1", "param1", "param2"],
- "uid" : 1,
- "gid" : 1,
- "once" : 0,
- "importance" : 1,
- "caps" : [0, 1, 2, 5],
- "start-mode" : "condition",
- "cpucore" : [0],
- "critical" : [0, 5, 10],
- "apl" : "normal",
- "d-caps" : ["OHOS_DMS"]
- "jobs" : {
- "on-boot" : "boot",
- "on-start" : "services:service1_start",
- "on-stop" : "services:service1_stop",
- "on-restart" : "services:service1_restart"
- }
- }, {
- "name" : "service2",
- "path" : "/bin/process2",
- "uid" : 2,
- "gid" : 2,
- "once" : 1,
- "importance" : 0,
- "caps" : [ ],
- "cpucore" : 0,
- "critical" : [ ],
- "apl" : "normal",
- "d-caps" : [ ]
- }]
- ```
+ | Command | Format and Example | Description | System Type |
+ | -------- | -------- | -------- | -------- |
+ | mkdir | mkdir target folder
Example: mkdir /storage/myDirectory | Creates a folder. mkdir and the target folder must be separated by only one space. | small&standard |
+ | chmod | chmod permission target
Example:
chmod 0600 /storage/myFile.txt
chmod 0750 /storage/myDir | Modifies the permission, which must be in the 0xxx format. chmod, permission, and target must be separated by only one space. | small&standard |
+ | chown | chown uid gid target
Example:
chown 900 800 /storage/myDir
chown 100 100 /storage/myFile.txt | Modifies the owner group. chown, uid, gid, and target must be separated by only one space. | small&standard |
+ | mount | mount fileSystemType src dst flags data
Example:
mount vfat /dev/mmcblk0 /sdc rw,umask=000
mount jffs2 /dev/mtdblock3 /storage nosuid | Mounts devices. Every two parameters must be separated by only one space. Currently, supported flags include nodev, noexec, nosuid, rdonly, and optionally data. | small&standard |
+ | start | start serviceName
Example:
start foundation
start shell | Starts services. start must be followed by serviceName, and serviceName must be contained in the services array. | small&standard |
+ | export | export key value
Example:
export TEST /data/test | Exports environment variables. key and value respectively indicate the environment variable and its value.| small&standard |
+ | rm | rm filename
Example:
rm /data/testfile | Removes a file. filename indicates the absolute file path. | small&standard |
+ | rmdir | rmdir dirname
Example:
rmdir /data/testdir | Removes a directory. dirname indicates the absolute path of the directory. | small&standard | write | write filename value
Example:
write /data/testfile 0 | Writes a file. filename and value respectively indicate the absolute file path and the string to write. | small&standard |
+ | stop | stop servicename
Example:
stop console | Stops a service. servicename indicates the name of the service to stop. | small&standard |
+ | copy | copy oldfile newfile
Example:
copy /data/old /data/new | Copies a file. oldfile and newfile respectively indicate the old and new absolute file paths. | small&standard |
+ | reset | reset servicename
Example:
reset console | Resets a service. servicename indicates the name of the service to reset. If the service has not been started, this command will start the service. If the service is running, the command will stop the service and then restart it.| small&standard |
+ | reboot | reboot *subsystem*
Example:
reboot updater | Restarts the system. subsystem is optional. If it is not specified, the device enters the current system upon restarting. If it is specified, the device enters the correspoding subsystem upon restarting. For example, if you run **reboot updater**, the device enters the updater subsystem upon restarting. | small&standard |
+ | sleep | sleep time
Example:
sleep 5 | Enters the sleep state. time indicates the sleep time. | small&standard |
+ | domainname | domainname name
Example:
domainname localdomain | Sets a domain name. | small & standard |
+ | hostname | hostname name
Example:
hostname localhost | Sets a host name. | small&standard |
+ | wait | wait PID
Example:
wait pid | Waits for a command.| small&standard |
+ | setrlimit | setrlimit resource curValue maxValue | Sets limitations on resource usage. | small&standard |
+ | write | write path content
Example:
write /proc/sys/kernel/sysrq 0 | Writes a file. | small&standard |
+ | exec | exec *Path of the executable file* *Parameters passed by the executable file*
Example:
exec /system/bin/udevadm trigger | Runs an executable file. | small&standard |
+ | mknode | mknod name { b \| c } Major Minor
Example:
mknod path b 0644 1 9 | Creates an index node corresponding to a directory entry and a special file. For details, see the **mknod** command. | standard |
+ | makedev | makedev major minor
Example:
makedev -v update | Creates a static device node, which is usually in the **/dev** directory.| standard |
+ | symlink | symlink path1 path2
Example:
symlink /proc/self/fd/0 /dev/stdin | Creates a symbolic link. | standard |
+ | trigger | trigger jobName
Example:
trigger early-fs | Triggers a job. | standard |
+ | insmod | insmod *ko file*
Example:
insmod *xxx*.ko| Loads a kernel module file. | standard |
+ | setparam | setparam *paramname* *paramvalue*
Example:
setparam sys.usb.config hdc | Sets a system parameter.| standard |
+ | load_persist_params | load persist params
Example:
load_persist_params | Loads **persist** parameters. There must be one and only one space after the **load_persist_params** command. | standard |
+ | load_param | load params
Example:
load_param /data/test.normal.para | Loads the parameters from a file to the memory.| standard |
+ | load_access_token_id | Example:
load_access_token_id | Writes the access token to the **data/service/el0/access_token/nativetoken.json** file. There is one and only one space after **load_access_token_id**.| standard |
+ | ifup | ifup *NIC*
Example:
ifup eth0 | Activates the specified NIC.| standard |
+ | mount_fstab | mount_fstab fstab.test
Example:
mount_fstab /vendor/etc/fstab.test | Mounts partitions based on the **fstab** file. | standard |
+ | umount_fstab | umount_fstab fstab.test
Example:
umount_fstab /vendor/etc/fstab.test | Unmounts partitions based on the **fstab** file. | standard |
+ | restorecon | restorecon file or dir
Example:
restorecon /file | Reloads the SELinux context. | standard |
+ | stopAllServices | stopAllServices [bool]
Example:
stopAllServices false
stopAllServices | Stops all services. | standard |
+ | umount |umount path
Example:
umount /vendor | Unmounts a mounted device. | standard |
+ | sync | Example:
sync | Writes data to the disk synchronously. There is only one and only one space after **sync**.| standard |
+ | timer_start | timer_start serviceName
Example:
timer_start console | Starts the service timer. | standard |
+ | timer_stop | timer_stop serviceName
Example:
timer_stop console | Stops the service timer. | standard |
+ | init_global_key | init_global_key path
Example:
init_global_key /data | Initializes the encryption key of the data partition file.| standard |
+ | init_main_user | Example:
init_main_user| Encrypts the main user directory.| standard |
+ | mkswap | mkswap file
Example:
mkswap /swapfile1 | Creates a swap partition on a file or device. | standard |
+ | swapon | swapon file
Example:
swapon /swapfile1 | Activates the swap space. | standard |
+ | loadcfg | loadcfg *filePath*
Example:
loadcfg /patch/fstab.cfg | Loads other .cfg files. The maximum size of the target file (Only /patch/fstab.cfg supported currently) is 50 KB. Each line in the /patch/fstab.cfg file is a command. The command types and formats must comply with their respective requirements mentioned in this table. A maximum of 20 commands are allowed. | small |
+
+2. Configure the services array, which holds all system services that need to be started by the init process.
+
+ ```
+ "services" : [{
+ "name" : "service1",
+ "path" : ["/bin/process1", "param1", "param2"],
+ "uid" : 1,
+ "gid" : 1,
+ "once" : 0,
+ "importance" : 1,
+ "caps" : [0, 1, 2, 5],
+ "start-mode" : "condition",
+ "cpucore" : [0],
+ "critical" : [0, 5, 10],
+ "apl" : "normal",
+ "d-caps" : ["OHOS_DMS"],
+ "jobs" : {
+ "on-boot" : "boot",
+ "on-start" : "services:service1_start",
+ "on-stop" : "services:service1_stop",
+ "on-restart" : "services:service1_restart"
+ }
+ }, {
+ "name" : "service2",
+ "path" : "/bin/process2",
+ "uid" : 2,
+ "gid" : 2,
+ "once" : 1,
+ "importance" : 0,
+ "caps" : [ ],
+ "cpucore" : 0,
+ "critical" : [ ],
+ "apl" : "normal",
+ "d-caps" : [ ]
+ }]
+ ```
+
+ **Table 3** Service field description
+
+ | Field | Description | Value | System Type |
+ | ---------- |-------- | --------| --------|
+ | name | Name of the current service. | Type: string. The value cannot be empty and can contain a maximum of 32 bytes.| small&standard |
+ | path | Full path (including parameters) of the current service's executable file, in array. | The first element is the path of the executable file, and the maximum number of elements is 20.
Each element is a string that contains a maximum of 64 bytes.| small&standard |
+ | uid | User ID (UID) of the current service process. | Type: int | small&standard |
+ | gid | Group ID (GID) of the current service process. | Type: int | small&standard |
+ | once | Whether the current service process is a one-off process. | **1**: The current service process is a one-off process. If the process exits, the init process does not restart it.
**0**: The current service process is not a one-off process. If the process exits, the init process restarts it upon receiving the SIGCHLD signal. | small&standard |
+ | importance | Current service priority. | Standard system:
The service priority ranges from **-20** to **19**. A value beyond the range is invalid.
Small-scale system:
**0**: unimportant process
non-0: important process | small&standard |
+ | caps | Capabilities required by the current service. They are evaluated based on the capabilities supported by the security subsystem and configured in accordance with the principle of least permission. | Type: number or string array. If you set the value to a number, use the standard Linux capability. If you set the value to a string array, use the standard macro name. | small&standard |
+ | critical | Suppression mechanism for services. If the number of times a service is restarted exceeds the value N within the specified period T, the system will be restarted. | Standard system:
Type: int array, for example, **"critical": [M, N, T]**.
- **M**: enable flag (**0**: disable; **1**: enable)
- N: number of times the service is started
- **T**: period of time, in seconds
Both **M** and **N** must be greater than **0**.
Small and standard systems:
Type: int, for example, **"critical": M**.
**M**: enable flag (**0**: disable; **1**: enable)
By default, **N** is **4** and **T** is **20**. | small&standard |
+ | cpucore | Number of CPU cores to be bound to the service. | Type: int array, for example, **"cpucore": [N1, N2, ...]**. **N1** and **N2** indicate the indices of the CPU cores to be bound.
For a single-core device, **cpucore** is **0**. | small&standard |
+ | d-caps | Service distribution capability. (Available only for the standard system or higher) | Type: string array, for example, **"d-caps": ["OHOS_DMS"]**. | standard |
+ | apl | Ability privilege level. (Available only for the standard system or higher) | Type: string, for example, **"apl": "system_core"**.
The value can be **system_core** (default), **normal**, or **system_basic**. | standard |
+ | start-mode | Service startup mode. (Available only for the standard system or higher) | Type: string, for example, **"start-mode": "condition"**.
The value can be **boot**, **normal**, or **condition**. For details, see [init service startup control](#section56901555918). | standard |
+ | jobs | Jobs that can be executed by the current service in different phases. For details, see [init parallel control](#section56901555919). | small&standard |
+ | ondemand | Whether to enable on-demand service startup. |Type: bool, for example, **"ondemand": true**. For small systems, this feature is available only on the Linux kernel. For details, see [init on-demand startup](#section56901555920). | small&standard |
+ | disable | Reserved. | | small&standard |
+3. Add socket and on-demand startup configurations for a service.
+
+ You can configure the **socket** attribute for a service in the JSON format. If a service is configured with the **socket** attribute, the init process will create a socket for the service upon startup. The socket creation time depends on whether on-demand startup is enabled for the service.
+ - If on-demand startup is enabled, the init process creates the socket based on the socket configuration obtained from parsing the service.
+ - If on-demand startup is disabled, the init process creates a socket before executing the executable file to start the service.
+
+ No matter whether on-demand startup is enabled, a service needs to obtain the handle of the socket created by the init process upon startup, so that it can take over the socket from the init process.
+ If on-demand startup is enabled, the init process can also take future processing. Specifically, after creating a socket based on the parsed socket configuration, the init process checks whether the **ondemand** attribute of the service is **true**. If yes, the init process listens to messages sent over the socket in polling mode. When a message is received, the init process stops listening and starts the service to take over the socket and process message.
- **Table 3** Service field description
-
- | Field | Description |
- | -------- | -------- |
- | name | Name of the current service. The value must not be empty and can contain a maximum of 32 bytes. |
- | path | Full path (including parameters) of the executable file for the current service. This is an array. Ensure that the first element is the path of the executable file, the maximum number of elements is 20, and each element is a string that contains a maximum of 64 bytes. |
- | uid | User ID (UID) of the current service process. |
- | gid | Group ID (GID) of the current service process. |
- | once | Whether the current service process is a one-off process.
1: The current service process is a one-off process. If the process exits, the init process does not restart it.
0: The current service process is not a one-off process. If the process exits, the init process restarts it upon receiving the SIGCHLD signal.
Note: If a non-one-off process exits for five consecutive times within four minutes, the init process will no longer restart it at the fifth exit. |
- |importance | Standard system:
Priority of a service process. The value ranges from -20 to 19.
Small system:
0: non-critical process
1: critical process