Parameter Management

Overview

Function

The parameter management subsystem, namely, sysparam, provides easy-to-use key-value pair access interfaces for system services to customize functions based on their own system parameters.

Basic Concepts

Operation Primitives

Figure 1 shows the primitives used to operate system parameters. For details about how they work, see Table 1.

Figure 1 Overview of system parameter operation primitives

Table 1 Description of system parameter operation primitives

Parameter Definition

• Naming format

  A system parameter name consists of multiple segments in dotted notation. Each segment can be a string that consists of letters, digits, and underscores (_). The total length cannot exceed 96 bytes.

  Two naming formats are supported for system parameters, as described in Table 2.

  Table 2 Description of system parameter naming formats

• Type

  System parameters are categorized into three types, as described in Table 3.

  Table 3 Description of system parameter types

Given below is the general naming format for system parameters:

[ const | persist ].$sub_system.$desc

wherein,

• $sub_system is the subsystem or module name.

• $desc is the parameter description, which can contain multiple segments in dotted notation.

Parameter Definition Rule

System parameters are defined per module on each subsystem. The parameter definition includes the system parameter name, default value, and access permission information.

• Value definition file

  • A value definition file of system parameters ends with the .para extension. The following is an example format of file content:

    # This is comment
    const.product.name=OHOS-PRODUCT
    const.os.version.api=26
    const.telephony.enable=false|true
    
    const.test.withblank=My Value
    const.test.withcomment=MyValue # This should be omitted
    const.test.multiline="This is a multiline parameter.
    Line2 value.
    Last line."
    

  • A complete system parameter command is required to assign a value for a system parameter. See Table 4 for the value assignment modes.

    Table 4 Description of value assignment modes

• DAC definition file

  Access permissions of system parameters are managed in discretionary access control (DAC) mode. A DAC definition file ends with the .para.dac extension. The following is an example format of DAC information:

  const.product.="root:root:660"
  

  As shown in this example, a parameter directory can be used to define the same access permission for system parameters with the same prefix. A piece of DAC information is divided into three segments, user, group, and Ugo rule, which are separated using a semicolon (:).

  NOTE

  Ugo is the abbreviation for user access, group access, ad other system user's access, respectively. These permissions are set to allow or deny access to members of their own group, or any other groups.

  Figure 2 shows the Ugo rule structure.

  Figure 2 Overview of the Ugo rule structure

  

• SELinux policy

  An SELinux policy defines the access permissions for all users, programs, processes, and files.

  • Adding an SELinux tag

    To add an SELinux tag to system parameters, you first need to define the tag in the /base/security/selinux/sepolicy/base/public/parameter.te file. For example:

    type servicectrl_param, parameter_attr
    

    After the tag is defined, add the system parameter prefix associated with the tag to /base/security/selinux/sepolicy/base/public/parameter_contexts. The following uses the prefix ohos.servicectrl as an example:

    ohos.servicectrl.           u:object_r:servicectrl_param:s0
    

  • Granting access permissions for a process

    For example, to grant access permissions such as map for the init process, add the following code to the /base/security/selinux/sepolicy/ohos_policy/startup/init/public/init.te file:

    allow servicectrl_param tmpfs:filesystem associate;
    allow init servicectrl_param:file { map open read relabelto relabelfrom };
    

  • Granting the write permission

    For example, to grant the write permission for services such as init, samgr, and hdf_devmgr, use the following code:

    allow { init samgr hdf_devmgr } servicectrl_param:parameter_service { set };
    

  • Granting the read permission

    If you want to grant the read permission only for certain services, replace xxx with these services in the following code:

    allow { xxx } servicectrl_param:file { map open read };
    

  • Granting access permissions for all services

    If you want to grant access permissions for all services, use the following code:

    allow { domain -limit_domain } servicectrl_param:file { map open read };
    

• System parameter tag

  You are advised to keep only two system parameter tags for each subsystem:

  • A private tag to control system parameter settings.

  • A public tag to grant access permissions from all services.

• Loading sequence

  System parameters are loaded by priority in the specified sequence, as described in Table 5.

  Table 5 Description of the system parameter loading sequence

Tag File Size

If one tag is associated with more than five system parameters, you need to set the size of the system parameter tag file in /base/startup/init/services/etc/param/ohos.para.size. The default value is 512.

The configuration rule is as follows:

System parameter tag = Size

For example:

startup_init_param=40960

Constraints

The parameter management subsystem is available only for the mini system and standard system.

How to Develop

Application Scenario

You can set specific system parameters as needed to meet your service demand.

Implementation Method

The parameter management subsystem allows you to manage system parameters by running shell commands or calling syspara APIs.

• Shell command mode

  You can operate system parameters directly by running shell commands. This operation mode is available only for the standard system. Table 6 is a list of the shell commands.

  Table 6 Description of shell commands

• syspara API mode

  Besides shell commands, you can use syspara APIs to manage system parameters. The return result is a constant string and the free operation is not supported. Table 7 is a list of the syspara APIs.

  Table 7 Description of syspara APIs

Development Procedure

Parameter Definition

You can define default system parameters and implement permission control on them by configuring the .para and .para.dac files of the respective subsystem or product.

• On a standard system, use the ohos_prebuilt_para template to install the configuration file to the /etc/param/ directory. The following is an example of the GN script:

  import("//base/startup/init/services/etc/param/param_fixer.gni")
  
  ohos_prebuilt_para("ohos.para") {
      source = "//base/startup/init/services/etc/ohos.para"
      part_name = "init"
      module_install_dir = "etc/param"
  }
  
  ohos_prebuilt_para("ohos.para.dac") {
      source = "//base/startup/init/services/etc/ohos.para.dac"
      part_name = "init"
      module_install_dir = "etc/param"
  }
  

• On a small system, run the copy command to copy the corresponding system parameter definition file to the system/etc/param directory.

  copy("ohos.para") {
    sources = [ "//base/startup/init/services/etc/param/ohos.para" ]
    outputs = [ "$root_out_dir/system/etc/param/ohos.para" ]
  }
  copy("ohos.para.dac") {
    sources = [ "//base/startup/init/services/etc/param/ohos.para.dac" ]
    outputs = [ "$root_out_dir/system/etc/param/ohos.para.dac" ]
  }
  

• On a mini system, convert all defined default system parameters into header files through action and compile them into the system.

  action("lite_const_param_to") {
    script = "//base/startup/init/scripts/param_cfg_to_code.py"
    args = [
      "--source",
      rebase_path(
          "//base/startup/init/services/etc_lite/param/ohos_const/ohospara"),
      "--dest_dir",
      rebase_path("$root_out_dir/gen/init/"),
      "--priority",
      "0",
    ]
    outputs = [ "$target_gen_dir/${target_name}_param_cfg_to_code.log" ]
  }
  

Development Example

```
// set && get
char key1[] = "rw.sys.version";
char value1[] = "10.1.0";
int ret = SetParameter(key1, value1);
char valueGet1[128] = {0};
ret = GetParameter(key1, "version=10.1.0", valueGet1, 128);

// get sysparm
char* value1 = GetDeviceType();
printf("Product type =%s\n", value1);

char* value2 = GetManufacture();
printf("Manufacture =%s\n", value2);

char* value3 = GetBrand();
printf("GetBrand =%s\n", value3);

char* value4 = GetMarketName();
printf("MarketName =%s\n", value4);

char* value5 = GetProductSeries();
printf("ProductSeries =%s\n", value5);

char* value6 = GetProductModel();
printf("ProductModel =%s\n", value6);

char* value7 = GetSoftwareModel();
printf("SoftwareModel =%s\n", value7);

char* value8 = GetHardwareModel();
printf("HardwareModel =%s\n", value8);

char* value9 = GetHardwareProfile();
printf("Software profile =%s\n", value9);

char* value10 = GetSerial();
printf("Serial =%s\n", value10);

char* value11 = GetOSFullName();
printf("OS name =%s\n", value11);

char* value12 = GetDisplayVersion();
printf("Display version =%s\n", value12);

char* value13 = GetBootloaderVersion();
printf("bootloader version =%s\n", value13);

char* value14 = GetSecurityPatchTag();
printf("secure patch level =%s\n", value14);

char* value15 = GetAbiList();
printf("abi list =%s\n", value15);

int value16 = GetFirstApiVersion();
printf("first api level =%d\n", value16);

char* value17 = GetIncrementalVersion();
printf("Incremental version = %s\n", value17);

char* value18 = GetVersionId();
printf("formal id =%s\n", value18);

char* value19 = GetBuildType();
printf("build type =%s\n", value19);

char* value20 = GetBuildUser();
printf("build user =%s\n", value20);

char* value21 = GetBuildHost();
printf("Build host = %s\n", value21);

char* value22 = GetBuildTime();
printf("build time =%s\n", value22);

char* value23 = GetBuildRootHash();
printf("build root later..., %s\n", value23);

char* value24 = GetOsReleaseType();
printf("OS release type =%s\n", value24);

char* value25 = GetOsReleaseType();
printf("OS release type =%s\n", value25);

char value26[65] = {0};
GetDevUdid(value26, 65);
printf("device udid =%s\n", value26);
```