首页 > 系统相关> 文章详细

ARM PSCI在ATF和Linux kernel中的实现【转】

2022-02-25 23:02:44 阅读：447 来源： 互联网

标签：ATF kernel ops PSCI unsigned CPU psci cpu

转自：https://www.cnblogs.com/arnoldlu/p/14211367.html

Linux内核中cpu_ops的实现因架构而已，对于ARM64架构一般通过执行smc指令进入EL3异常，由ATF执行PSCI功能。然后将结果返回给Linux。

这中间涉及到【Linux kernel的cpu_ops、psci_ops】、【SMC/HVC】、【PSCI】、【ATF的PSCI】相关等等。

1. PSCI规格

目前PSCI最新规格为v1.1，这里以v1.0为参考：《POWER STATE COORDINATION INTERFACE (PSCI) System Software on ARM® Systems》。

1.1 PSCI_VERSION

返回当前psci固件版本号。

1.2 CPU_SUSPEND

执行核的suspend操作，一般用于等待被唤醒后继续执行的子系统。

1.3 CPU_OFF

用于hotplug中关闭调用此功能的核。被CPU_OFF关闭的仅能被CPU_ON打开。

1.4 CPU_ON

上电一个核，用于以下两种情况：

还未被启动的核
已经被CPU_OFF关闭的核。

1.5 AFFINITY_INFO

1.6 MIGRATE

可选。要求单核TOS将指向上下文迁移到一个指定核。

1.7 MIGRATE_INFO_TYPE

允许调用者查询当前TOS对多核支持情况。

1.8 MIGRATE_INFO_UP_CPU

可选。对单核TOS系统，此功能返回TOS当前驻存在哪个核上。

1.9 SYSTEM_OFF

1.10 SYSTEM_RESET

进行系统复位，没有入参也没有返回值。

1.11 PSCI_FEATURES

查询psci固件是否支持指定功能id及其特性。

1.12 CPU_FREEZE

1.13 CPU_DEFAULT_SUSPEND

1.14 NODE_HW_STATE

1.15 SYSTEM_SUSPEND

让系统进入深度低功耗模式。

1.16 SUSPEND_MODE

1.17 PSCI_STAT_RESIDENCY

1.18 PSCI_STAT_COUNT

2. ATF PSCI实现

参考：《《ARM Trusted Firmware》阅读笔记 PSCI》

3. Linux PSCI实现

PSCI主要负责CPU低功耗、热插拔功能，对接cpu_ops实现一系列函数。

在dt中配置psci属性，以及在

3.1 psci dts配置

psci相关配置在dts中定义：

    psci {
        compatible = "arm,psci-0.2";
        method = "smc";
    };

说明使用的驱动是psci v0.2标准的接口。

3.2 psci驱动初始化

对psci初始化在setup_arch()中调用，psci_dt_init()从dt中解析出psci版本以及实现psci调用的方式(smc)。

void __init setup_arch(char **cmdline_p)
{
...
    if (acpi_disabled)
        psci_dt_init();
    else
        psci_acpi_init();
...
}


int __init psci_dt_init(void)
{
    struct device_node *np;
    const struct of_device_id *matched_np;
    psci_initcall_t init_fn;

    np = of_find_matching_node_and_match(NULL, psci_of_match, &matched_np);----进行dts设备匹配，这里对应psci-0.2。

    if (!np)
        return -ENODEV;

    init_fn = (psci_initcall_t)matched_np->data;-------------------------------对应的函数为psci_0_2_init()。
    return init_fn(np);
}

static const struct of_device_id psci_of_match[] __initconst = {
    { .compatible = "arm,psci",    .data = psci_0_1_init},
    { .compatible = "arm,psci-0.2",    .data = psci_0_2_init},
    { .compatible = "arm,psci-1.0",    .data = psci_0_2_init},
    {},
};

static int __init psci_0_2_init(struct device_node *np)
{
    int err;

    err = get_set_conduit_method(np);--------------------------------------从dt中解析出psci的method，这里为smc，表示psci功能通过smc(Secure Monitor Call：->EL3调用)实现。其他方式还有svc(Supervisor call：->EL1调用)和hvc(Hypervisor call：->EL2调用)。

    if (err)
        goto out_put_node;
    /*
     * Starting with v0.2, the PSCI specification introduced a call
     * (PSCI_VERSION) that allows probing the firmware version, so
     * that PSCI function IDs and version specific initialization
     * can be carried out according to the specific version reported
     * by firmware
     */
    err = psci_probe();

out_put_node:
    of_node_put(np);
    return err;
}

static int __init psci_probe(void)
{
    u32 ver = psci_get_version();--------------------------------------------------通过SMC的PSCI_0_2_FN_PSCI_VERSION功能id获取PSCI固件版本号。

    pr_info("PSCIv%d.%d detected in firmware.\n",
            PSCI_VERSION_MAJOR(ver),
            PSCI_VERSION_MINOR(ver));

    if (PSCI_VERSION_MAJOR(ver) == 0 && PSCI_VERSION_MINOR(ver) < 2) {-------------驱动只支持psci 0.2及以上的psci固件。
        pr_err("Conflicting PSCI version detected.\n");
        return -EINVAL;
    }

    psci_0_2_set_functions();------------------------------------------------------将linux中使用的psci_ops、arm_pm_off、pm_power_off对齐到具体PSCI的SMC功能id。

    psci_init_migrate();

    if (PSCI_VERSION_MAJOR(ver) >= 1) {--------------------------------------------对于>=v1.0版本psci，特殊处理suspend。
        psci_init_smccc();
        psci_init_cpu_suspend();
        psci_init_system_suspend();
    }

    return 0;
}

3.2.1 PSCI功能实现中转通道：SMC或HVC

kernel实现SMC调用的两种方式：SMC和HVC。get_set_conduit_method()的核心是根据dt中的method字段，选择合适的invoke_psci_fn函数。

enum psci_conduit {
    PSCI_CONDUIT_NONE,
    PSCI_CONDUIT_SMC,
    PSCI_CONDUIT_HVC,
};

static int get_set_conduit_method(struct device_node *np)
{
    const char *method;

    pr_info("probing for conduit method from DT.\n");

    if (of_property_read_string(np, "method", &method)) {
        pr_warn("missing \"method\" property\n");
        return -ENXIO;
    }

    if (!strcmp("hvc", method)) {
        set_conduit(PSCI_CONDUIT_HVC);
    } else if (!strcmp("smc", method)) {------------------------------根据dt中的method字段，设置invoke_psci_fn函数。
        set_conduit(PSCI_CONDUIT_SMC);
    } else {
        pr_warn("invalid \"method\" property: %s\n", method);
        return -EINVAL;
    }
    return 0;
}

static void set_conduit(enum psci_conduit conduit)-----------------------HVC和SMC两种访问psci固件的方式，HVC表示当前OS为guest os；SMC表示从EL1直接访问EL3 psci固件。
{
    switch (conduit) {
    case PSCI_CONDUIT_HVC:
        invoke_psci_fn = __invoke_psci_fn_hvc;
        break;
    case PSCI_CONDUIT_SMC:
        invoke_psci_fn = __invoke_psci_fn_smc;
        break;
    default:
        WARN(1, "Unexpected PSCI conduit %d\n", conduit);
    }

    psci_ops.conduit = conduit;
}

static unsigned long __invoke_psci_fn_hvc(unsigned long function_id,
            unsigned long arg0, unsigned long arg1,
            unsigned long arg2)
{
    struct arm_smccc_res res;

    arm_smccc_hvc(function_id, arg0, arg1, arg2, 0, 0, 0, 0, &res);
    return res.a0;
}

static unsigned long __invoke_psci_fn_smc(unsigned long function_id,
            unsigned long arg0, unsigned long arg1,
            unsigned long arg2)
{
    struct arm_smccc_res res;

    arm_smccc_smc(function_id, arg0, arg1, arg2, 0, 0, 0, 0, &res);
    return res.a0;
}


    .macro SMCCC instr
    .cfi_startproc
    \instr    #0
    ldr    x4, [sp]
    stp    x0, x1, [x4, #ARM_SMCCC_RES_X0_OFFS]
    stp    x2, x3, [x4, #ARM_SMCCC_RES_X2_OFFS]
    ldr    x4, [sp, #8]
    cbz    x4, 1f /* no quirk structure */
    ldr    x9, [x4, #ARM_SMCCC_QUIRK_ID_OFFS]
    cmp    x9, #ARM_SMCCC_QUIRK_QCOM_A6
    b.ne    1f
    str    x6, [x4, ARM_SMCCC_QUIRK_STATE_OFFS]
1:    ret
    .cfi_endproc
    .endm

/*
 * void arm_smccc_smc(unsigned long a0, unsigned long a1, unsigned long a2,
 *          unsigned long a3, unsigned long a4, unsigned long a5,
 *          unsigned long a6, unsigned long a7, struct arm_smccc_res *res,
 *          struct arm_smccc_quirk *quirk)
 */
ENTRY(__arm_smccc_smc)
    SMCCC    smc
ENDPROC(__arm_smccc_smc)

/*
 * void arm_smccc_hvc(unsigned long a0, unsigned long a1, unsigned long a2,
 *          unsigned long a3, unsigned long a4, unsigned long a5,
 *          unsigned long a6, unsigned long a7, struct arm_smccc_res *res,
 *          struct arm_smccc_quirk *quirk)
 */
ENTRY(__arm_smccc_hvc)
    SMCCC    hvc
ENDPROC(__arm_smccc_hvc)

3.2.2 psci_ops函数集

struct psci_operations psci_ops是Linux下对应psci功能函数集，另外psci_function_id[]下标为LInux psci功能id，值为具体psci规格功能id，psci_function_id[]进行两者的转换。

struct psci_operations {
    u32 (*get_version)(void);------------------------------------------获取psci固件版本号。
    int (*cpu_suspend)(u32 state, unsigned long entry_point);----------
    int (*cpu_off)(u32 state);
    int (*cpu_on)(unsigned long cpuid, unsigned long entry_point);
    int (*migrate)(unsigned long cpuid);
    int (*affinity_info)(unsigned long target_affinity,
            unsigned long lowest_affinity_level);
    int (*migrate_info_type)(void);
    enum psci_conduit conduit;
    enum smccc_version smccc_version;
};

struct psci_operations psci_ops = {
    .conduit = PSCI_CONDUIT_NONE,
    .smccc_version = SMCCC_VERSION_1_0,
};

enum psci_function {
    PSCI_FN_CPU_SUSPEND,
    PSCI_FN_CPU_ON,
    PSCI_FN_CPU_OFF,
    PSCI_FN_MIGRATE,
    PSCI_FN_MAX,
};

static u32 psci_function_id[PSCI_FN_MAX];

psci_0_2_setfunction()主要设置了psci_ops函数集，以及arm_pm_restart和pm_power_off。

static void __init psci_0_2_set_functions(void)
{
    pr_info("Using standard PSCI v0.2 function IDs\n");
    psci_ops.get_version = psci_get_version;

    psci_function_id[PSCI_FN_CPU_SUSPEND] =
                    PSCI_FN_NATIVE(0_2, CPU_SUSPEND);
    psci_ops.cpu_suspend = psci_cpu_suspend;

    psci_function_id[PSCI_FN_CPU_OFF] = PSCI_0_2_FN_CPU_OFF;
    psci_ops.cpu_off = psci_cpu_off;

    psci_function_id[PSCI_FN_CPU_ON] = PSCI_FN_NATIVE(0_2, CPU_ON);
    psci_ops.cpu_on = psci_cpu_on;

    psci_function_id[PSCI_FN_MIGRATE] = PSCI_FN_NATIVE(0_2, MIGRATE);
    psci_ops.migrate = psci_migrate;

    psci_ops.affinity_info = psci_affinity_info;

    psci_ops.migrate_info_type = psci_migrate_info_type;

    arm_pm_restart = psci_sys_reset;

    pm_power_off = psci_sys_poweroff;
}

对应psci的PSCI_VERSION功能，返回psci固件版本号。

通过PSCI_VERSION_MAJOR()和PSCI_VERSION_MINOR()解析。

static u32 psci_get_version(void)
{
    return invoke_psci_fn(PSCI_0_2_FN_PSCI_VERSION, 0, 0, 0);
}

对应psci的CPU_SUSPEND功能，state是将要进入的低功耗状态，entry_point是从低功耗状态返回后执行入口地址。

entry_point必须是物理地址或者虚拟机的IPA。

第三个参数是Powerdown功耗状态才会使用。

static int psci_cpu_suspend(u32 state, unsigned long entry_point)
{
    int err;
    u32 fn;

    fn = psci_function_id[PSCI_FN_CPU_SUSPEND];
    err = invoke_psci_fn(fn, state, entry_point, 0);
    return psci_to_linux_errno(err);
}

对应psci的CPU_OFF功能，让关闭调用此功能的核。

static int psci_cpu_off(u32 state)
{
    int err;
    u32 fn;

    fn = psci_function_id[PSCI_FN_CPU_OFF];
    err = invoke_psci_fn(fn, state, 0, 0);
    return psci_to_linux_errno(err);
}

对应psci的CPU_ON功能，给一个核上电。

cpuid为需要上电cpu的id；entry_point是CPU上电后运行入口物理地址或IPA，比如这里为secondary_entry()。如果第一次启动，可以传入context_id参数。

static int psci_cpu_on(unsigned long cpuid, unsigned long entry_point)
{
    int err;
    u32 fn;

    fn = psci_function_id[PSCI_FN_CPU_ON];
    err = invoke_psci_fn(fn, cpuid, entry_point, 0);
    return psci_to_linux_errno(err);
}


static int cpu_psci_cpu_boot(unsigned int cpu)
{
    int err = psci_ops.cpu_on(cpu_logical_map(cpu), __pa(secondary_entry));
    if (err)
        pr_err("failed to boot CPU%d (%d)\n", cpu, err);

    return err;
}
    /*
     * Secondary entry point that jumps straight into the kernel. Only to
     * be used where CPUs are brought online dynamically by the kernel.
     */
ENTRY(secondary_entry)
    bl    el2_setup            // Drop to EL1
    bl    set_cpu_boot_mode_flag
    b    secondary_startup
ENDPROC(secondary_entry)

对应psci的MIGRATE功能，将TOS迁移到指定cpuid上执行。

cpuid将要迁移到cpu的id。

static int psci_migrate(unsigned long cpuid)
{
    int err;
    u32 fn;

    fn = psci_function_id[PSCI_FN_MIGRATE];
    err = invoke_psci_fn(fn, cpuid, 0, 0);
    return psci_to_linux_errno(err);
}

对应psci的AFFINITY_INFO功能，

static int psci_affinity_info(unsigned long target_affinity,
        unsigned long lowest_affinity_level)
{
    return invoke_psci_fn(PSCI_FN_NATIVE(0_2, AFFINITY_INFO),
                  target_affinity, lowest_affinity_level, 0);
}

对应psci的MIGRATE_INFO_TYPE功能，获取TOS在多核环境下迁移能力。

0 - TOS运行在一个核上，但是可以迁移到任何违背CPU_OFF的核。

1 - TOS仅运行在一个核上，不支持MIGRATE功能。

2 - TOS不存在或者不需要MIGRATE功能。

NOT_SUPPORTED - 不需要MIGRATE。

static int psci_migrate_info_type(void)
{
    return invoke_psci_fn(PSCI_0_2_FN_MIGRATE_INFO_TYPE, 0, 0, 0);
}

/* PSCI v0.2 multicore support in Trusted OS returned by MIGRATE_INFO_TYPE */
#define PSCI_0_2_TOS_UP_MIGRATE            0
#define PSCI_0_2_TOS_UP_NO_MIGRATE        1
#define PSCI_0_2_TOS_MP                2

对应psci的SYSTEM_RESET功能，执行系统复位功能。

static void psci_sys_reset(enum reboot_mode reboot_mode, const char *cmd)
{
    invoke_psci_fn(PSCI_0_2_FN_SYSTEM_RESET, 0, 0, 0);
}


/*
 * Restart requires that the secondary CPUs stop performing any activity
 * while the primary CPU resets the system. Systems with multiple CPUs must
 * provide a HW restart implementation, to ensure that all CPUs reset at once.
 * This is required so that any code running after reset on the primary CPU
 * doesn't have to co-ordinate with other CPUs to ensure they aren't still
 * executing pre-reset code, and using RAM that the primary CPU's code wishes
 * to use. Implementing such co-ordination would be essentially impossible.
 */
void machine_restart(char *cmd)
{
...
    /* Now call the architecture specific reboot code. */
    if (arm_pm_restart)
        arm_pm_restart(reboot_mode, cmd);------------------调用psci_sys_reset()函数。
    else
        do_kernel_restart(cmd);

    /*
     * Whoops - the architecture was unable to reboot.
     */
    printk("Reboot failed -- System halted\n");
    while (1);
}

对应psci的SYSTEM_OFF功能，关闭系统。无入参和返回值。

static void psci_sys_poweroff(void)
{
    invoke_psci_fn(PSCI_0_2_FN_SYSTEM_OFF, 0, 0, 0);
}

/*
 * Power-off simply requires that the secondary CPUs stop performing any
 * activity (executing tasks, handling interrupts). smp_send_stop()
 * achieves this. When the system power is turned off, it will take all CPUs
 * with it.
 */
void machine_power_off(void)
{
    local_irq_disable();
    smp_send_stop();
    if (pm_power_off)
        pm_power_off();---------------------------调用psci_sys_poweroff()。
}

3.3 TOS驻存CPU不允许hotplug

psci_init_migrate()获取当前TOS驻存的CPU id，并赋值给resident_cpu。

/*
 * Detect the presence of a resident Trusted OS which may cause CPU_OFF to
 * return DENIED (which would be fatal).
 */
static void __init psci_init_migrate(void)
{
    unsigned long cpuid;
    int type, cpu = -1;

    type = psci_ops.migrate_info_type();-----------------------------------------获取psci支持的TOS服务迁移类型。

    if (type == PSCI_0_2_TOS_MP) {
        pr_info("Trusted OS migration not required\n");
        return;
    }

    if (type == PSCI_RET_NOT_SUPPORTED) {
        pr_info("MIGRATE_INFO_TYPE not supported.\n");
        return;
    }

    if (type != PSCI_0_2_TOS_UP_MIGRATE &&
        type != PSCI_0_2_TOS_UP_NO_MIGRATE) {
        pr_err("MIGRATE_INFO_TYPE returned unknown type (%d)\n", type);
        return;
    }

    cpuid = psci_migrate_info_up_cpu();------------------------------------------MIGRATE_INFO_UP_CPU获取TOS驻存CPU的mpidr值。
    if (cpuid & ~MPIDR_HWID_BITMASK) {
        pr_warn("MIGRATE_INFO_UP_CPU reported invalid physical ID (0x%lx)\n",
            cpuid);
        return;
    }

    cpu = get_logical_index(cpuid);----------------------------------------------将mpidr值转换成cpu逻辑id，并赋值给resident_cpu。
    resident_cpu = cpu >= 0 ? cpu : -1;

    pr_info("Trusted OS resident on physical CPU 0x%lx\n", cpuid);
}

当需要CPU进行hotplug之前，调用cpu_disable来检查CPU是否支持hotplug。如果需要进行hotplug的cpu是resident_cpu，则返回EPERM错误。

bool psci_tos_resident_on(int cpu)
{
    return cpu == resident_cpu;
}
static int cpu_psci_cpu_disable(unsigned int cpu)
{
    /* Fail early if we don't have CPU_OFF support */
    if (!psci_ops.cpu_off)
        return -EOPNOTSUPP;

    /* Trusted OS will deny CPU_OFF */
    if (psci_tos_resident_on(cpu))
        return -EPERM;

    return 0;
}

const struct cpu_operations cpu_psci_ops = {
    .name        = "psci",
...
#ifdef CONFIG_HOTPLUG_CPU
    .cpu_disable    = cpu_psci_cpu_disable,
    .cpu_die    = cpu_psci_cpu_die,
    .cpu_kill    = cpu_psci_cpu_kill,
#endif
};

3.4 v1.0及以上suspend处理

static void __init psci_init_cpu_suspend(void)
{
    int feature = psci_features(psci_function_id[PSCI_FN_CPU_SUSPEND]);

    if (feature != PSCI_RET_NOT_SUPPORTED)
        psci_cpu_suspend_feature = feature;
}

static void __init psci_init_system_suspend(void)
{
    int ret;

    if (!IS_ENABLED(CONFIG_SUSPEND))
        return;

    ret = psci_features(PSCI_FN_NATIVE(1_0, SYSTEM_SUSPEND));

    if (ret != PSCI_RET_NOT_SUPPORTED)
        suspend_set_ops(&psci_suspend_ops);
}

static const struct platform_suspend_ops psci_suspend_ops = {
    .valid          = suspend_valid_only_mem,
    .enter          = psci_system_suspend_enter,
};

static int psci_system_suspend_enter(suspend_state_t state)
{
    return cpu_suspend(0, psci_system_suspend);
}

对应psci的SYSTEM_SUSPEND功能，实现suspend到ram功能，类似于进入最深度低功耗的CPU_SUSPEND。

成功则没有返回值，失败则返回NOT_SUPPORTED、INVALID_ADDRESS、ALREADY_ON之一。

static int psci_system_suspend(unsigned long unused)
{
    return invoke_psci_fn(PSCI_FN_NATIVE(1_0, SYSTEM_SUSPEND),
                  virt_to_phys(cpu_resume), 0, 0);
}

4. cpu_ops到psci固件通路

大致调用路径：cpu_ops->cpu_psci_ops->psci_ops->invoke_psci_fn()->SMCC。

dt中低功耗配置：

    cpus {
        #address-cells = <0x2>;
        #size-cells = <0x0>;

        cpu@0 {
            compatible = "arm,cortex-a53";
            device_type = "cpu";
            reg = <0x0 0x0>;
            enable-method = "psci";
            clock-latency = <0x186a0>;
            cpu-idle-states = <0xc 0xd>;
        };

        cpu@1 {
...
        };
...
    };

setup_arch()中调用cpu_read_bootcpu_ops()，经过一系列判断cpu_ops[0]指向cpu_psci_ops。cpu_psci_ops中大部分实现通过调用psci_ops，在函数psci_0_2_set_functions()中指定了psci_ops函数集，基本通过invoke_psci_fn()发送SMC调用由psci固件在EL3执行。

void __init setup_arch(char **cmdline_p)
{
...
    if (acpi_disabled)
        psci_dt_init();
    else
        psci_acpi_init();

    cpu_read_bootcpu_ops();
...
}

static inline void __init cpu_read_bootcpu_ops(void)
{
    cpu_read_ops(0);
}

int __init cpu_read_ops(int cpu)
{
    const char *enable_method = cpu_read_enable_method(cpu);------------------------读取当前cpu在dt中的enable-method配置，这里以psci为例。

    if (!enable_method)
        return -ENODEV;

    cpu_ops[cpu] = cpu_get_ops(enable_method);
    if (!cpu_ops[cpu]) {
        pr_warn("Unsupported enable-method: %s\n", enable_method);
        return -EOPNOTSUPP;
    }

    return 0;
}

static const struct cpu_operations * __init cpu_get_ops(const char *name)
{
    const struct cpu_operations **ops;

    ops = acpi_disabled ? dt_supported_cpu_ops : acpi_supported_cpu_ops;

    while (*ops) {
        if (!strcmp(name, (*ops)->name))-----------------------------------------------在关闭acpi情况下，根据从dt中读取的字符串匹配到cpu_psci_ops函数集。
            return *ops;

        ops++;
    }

    return NULL;
}

static const struct cpu_operations *dt_supported_cpu_ops[] __initconst = {
    &smp_spin_table_ops,
    &cpu_psci_ops,
    NULL,
};

const struct cpu_operations cpu_psci_ops = {
    .name        = "psci",
#ifdef CONFIG_CPU_IDLE
    .cpu_init_idle    = psci_cpu_init_idle,
    .cpu_suspend    = psci_cpu_suspend_enter,
#endif
    .cpu_init    = cpu_psci_cpu_init,
    .cpu_prepare    = cpu_psci_cpu_prepare,
    .cpu_boot    = cpu_psci_cpu_boot,
#ifdef CONFIG_HOTPLUG_CPU
    .cpu_disable    = cpu_psci_cpu_disable,
    .cpu_die    = cpu_psci_cpu_die,
    .cpu_kill    = cpu_psci_cpu_kill,
#endif
};

联系方式:arnoldlu@qq.com

标签：ATF,kernel,ops,PSCI,unsigned,CPU,psci,cpu
来源： https://www.cnblogs.com/sky-heaven/p/15938086.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9