Parameter Management

Overview

Function

The parameter management module, namely, sysparam, provides an easy-to-use key-value pair access interface for system services to configure service functions based on their own system parameters.

Basic Concepts

Figure 1 System parameter operation primitives

Table 1 Description of system parameter operation primitives

System 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. System parameter names are categorized into the following two types.

  Table 2 System parameter names

• Type

  System parameters are categorized into three types.

  Table 3 System parameter types

The general naming format is as follows:

[ const | persist ].$sub_system.$desc

$sub_system is the name of the subsystem or module.

$desc indicates the description of a system parameter. The description can contain multiple segments in dotted notation.

Definition Rules

Each subsystem defines the system parameters of its own modules, including the system parameter name, default value, and access permission information.

• System parameter value definition file

  • The system parameter value definition file ends with the .para extension. An example of the file format is as follows:

    # 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 ommitted
    const.test.multiline="This is a multiline parameter.
    Line2 value.
    Last line."
    

  • You must use a complete system parameter command when assigning a value for a system parameter. The following table describes the value assignment modes.

    Table 4 Value assignment modes

• DAC definition file

  Currently, access permissions of system parameters are managed in Discretionary Access Control (DAC) mode. The access permission definition file ends with the .para.dac extension. The following is an example:

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

  As shown above, we can use parameter directory to define the same access permission for system parameters with the same prefix. The DAC information is divided into three segments, user, group, and UGO rule, which are separated using a semicolon (:).

  The following figure shows the structure of the UGO rule.

  Figure 2 UGO rule structure

  

• SELinux policy for system parameter configuration

  • Add SELinux tags.

    To add a 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
    

  • Grant operation permissions. For example, to grant operation permissions such as map for the init process, add the following content 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 };
    

  • Set the write permission. For example, grant the system parameter write permission for services such as init, samgr, and hdf_devmgr.

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

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

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

  • If you want to grant the permission for all services, use the following code:

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

• Suggestions

  Keep only two system parameter tags for each subsystem:

  • A private tag to control system parameter settings.

  • A public tag to grant access from all services.

• Loading sequence

  The following table provides the sequence of loading system parameters.

  Table 5 System parameter loading sequence

System Parameter Tag File Size

If one tag corresponds to 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 size value is 512 by default.

Configuring rule:

System parameter tag = Size

Example:

startup_init_param=40960

Constraints

The service management module is available only for the mini system and standard system.

How to Develop

Use Cases

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

Available APIs

• Shell commands

  You can operate system parameters directly by using shell commands. This operation mode is available only for the standard system. The following table lists the shell commands.

  Table 6 Description of shell commands

• syspara APIs

  The following table lists the APIs used to obtain system parameter values. The return result is a const string and the free operation is not supported.

  Table 7 Description of syspara APIs

How to Develop

1. System parameter definition

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

   ​ 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" ]
   }
   

2. 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);