diff options
author | charan makkina <charan795m@gmail.com> | 2019-04-30 17:40:53 +0530 |
---|---|---|
committer | charan makkina <charan795m@gmail.com> | 2019-05-20 18:14:40 +0530 |
commit | a826fe833d3f2a8fe2673fa05811fe1a22baf045 (patch) | |
tree | da11a17c46ca9b8a002a52a290628574fa3f5eda /src/framework/res/nstack_share_res.c | |
parent | 3e6bf7b64eea418c59959c18750261b815b2892c (diff) |
Feature: 19.04 part 1
Change-Id: Ibba924b8deca1f246b9dcb12d89d085b6fd33046
Signed-off-by: charan makkina <charan795m@gmail.com>
Diffstat (limited to 'src/framework/res/nstack_share_res.c')
-rw-r--r-- | src/framework/res/nstack_share_res.c | 270 |
1 files changed, 270 insertions, 0 deletions
diff --git a/src/framework/res/nstack_share_res.c b/src/framework/res/nstack_share_res.c new file mode 100644 index 0000000..d6024cf --- /dev/null +++ b/src/framework/res/nstack_share_res.c @@ -0,0 +1,270 @@ +/* +* +* Copyright (c) 2018 Huawei Technologies Co.,Ltd. +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at: +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#include "nstack_share_res.h" +#include "nsfw_mem_api.h" +#include "types.h" +#include "nstack_securec.h" +#include "nstack_log.h" +#include "nsfw_maintain_api.h" + +#include "nsfw_ps_api.h" + +#define NSTACK_SHARE_RES "nstack_share_res" + +#define MAX_DELAY_RECYCLE_SEC 15 + +typedef struct +{ + volatile u16 forking; + u8 delay_recycle; + u8 delay_tick; + volatile u16 child_hbt; + u16 old_child_hbt; +} nstack_fork_recycle; + +typedef struct +{ + nstack_fork_recycle fork_recycle[NSFW_MAX_PID]; +} nstack_share_res; + +NSTACK_STATIC nstack_share_res *g_nstack_share_res; +NSTACK_STATIC volatile int g_enable_child_hbt = 0; + +/* Add dfx timer tick */ +/** global timer tick */ +u64 g_nstack_timer_init_value = 0; +nstack_tick_info_t g_nstack_timer_tick = {.tick_ptr = + &g_nstack_timer_init_value, +}; + +int nstack_init_share_res() +{ + mzone_handle zone; + nsfw_mem_zone param; + int ret; + + param.isocket_id = -1; + param.lenth = sizeof(nstack_share_res); + param.stname.entype = NSFW_SHMEM; + + ret = strcpy_s(param.stname.aname, NSFW_MEM_NAME_LENTH, NSTACK_SHARE_RES); + if (EOK != ret) + { + NSSOC_LOGERR("strcpy_s failed]name=%s,ret=%d", NSTACK_SHARE_RES, ret); + return -1; + } + + zone = nsfw_mem_zone_create(¶m); + if (!zone) + { + NSSOC_LOGERR("nsfw_mem_zone_create failed]name=%s", NSTACK_SHARE_RES); + return -1; + } + + g_nstack_share_res = (nstack_share_res *) zone; + if (EOK != + memset_s(g_nstack_share_res, sizeof(nstack_share_res), 0, + sizeof(nstack_share_res))) + { + NSSOC_LOGERR("memset failed"); + return -1; + } + + NSSOC_LOGDBG("ok"); + return 0; +} + +NSTACK_STATIC int nstack_lookup_share_res() +{ + mzone_handle zone; + nsfw_mem_name param; + + param.entype = NSFW_SHMEM; + param.enowner = NSFW_PROC_MAIN; + if (strcpy_s(param.aname, NSFW_MEM_NAME_LENTH, NSTACK_SHARE_RES) != 0) + { + NSSOC_LOGERR("strcpy_s failed]name=%s", NSTACK_SHARE_RES); + return -1; + } + + zone = nsfw_mem_zone_lookup(¶m); + if (!zone) + { + NSSOC_LOGERR("nsfw_mem_zone_lookup failed]name=%s", NSTACK_SHARE_RES); + return -1; + } + + g_nstack_share_res = (nstack_share_res *) zone; + NSSOC_LOGDBG("ok"); + return 0; +} + +/* Add dfx timer tick */ +NSTACK_STATIC int nstack_lookup_share_global_tick() +{ + int ret; + nsfw_mem_name name = {.entype = NSFW_SHMEM,.enowner = NSFW_PROC_MAIN }; + + ret = strcpy_s(name.aname, NSFW_MEM_NAME_LENTH, NSTACK_GLOBAL_TICK_SHM); + if (EOK != ret) + { + NSSOC_LOGERR("strcpy_s failed]name=%s,ret=%d", + NSTACK_GLOBAL_TICK_SHM, ret); + return -1; + } + + g_nstack_timer_tick.tick_ptr = (u64 *) nsfw_mem_zone_lookup(&name); + if (NULL == g_nstack_timer_tick.tick_ptr) + { + NSSOC_LOGERR("Failed to lookup global timer tick memory"); + return -1; + } + + NSSOC_LOGDBG("ok"); + return 0; +} + +int nstack_attach_share_res() +{ + if (nstack_lookup_share_res() != 0) + { + return -1; + } + + /* Add dfx timer tick */ + if (nstack_lookup_share_global_tick() != 0) + { + return -1; + } + + return 0; +} + +void fork_parent_start(i32 ppid) +{ + g_nstack_share_res->fork_recycle[ppid].forking = 1; +} + +/* + * if child die, child_hbt will stop changing, parent wait FORK_WAIT_SEC seconds. + * otherwise, parent wait until child fork done. + */ +void fork_wait_child_done(u32 ppid) +{ +#define FORK_WAIT_SEC 5 +#define FORK_SLEEP_MS 10 +#define FORK_WAIT_CNT (FORK_WAIT_SEC * 1000 / FORK_SLEEP_MS) + u32 wait_cnt = FORK_WAIT_CNT; + nstack_fork_recycle *recycle = &g_nstack_share_res->fork_recycle[ppid]; + while (recycle->forking && wait_cnt) + { + --wait_cnt; + sys_sleep_ns(0, 1000000 * FORK_SLEEP_MS); + + if (recycle->old_child_hbt != recycle->child_hbt) + { + recycle->old_child_hbt = recycle->child_hbt; + wait_cnt = FORK_WAIT_CNT; + } + } + + if ((0 == wait_cnt) && recycle->forking) + { + NSSOC_LOGWAR("timeout] waited time=%u,ppid=%u", FORK_WAIT_SEC, ppid); + recycle->forking = 0; + } +} + +void fork_parent_failed(u32 ppid) +{ + g_nstack_share_res->fork_recycle[ppid].forking = 0; +} + +NSTACK_STATIC void *fork_start_child_hbt(void *arg) +{ + u32 ppid = (u32) (u64) arg; + nstack_fork_recycle *recycle = &g_nstack_share_res->fork_recycle[ppid]; + + while (g_enable_child_hbt) + { + ++recycle->child_hbt; + sys_sleep_ns(0, 10); + } + + return NULL; +} + +void fork_child_start(u32 ppid) +{ + g_enable_child_hbt = 1; + pthread_t t; + if (pthread_create(&t, NULL, fork_start_child_hbt, (void *) (u64) ppid)) + { + NSPOL_LOGERR("pthread_create failed]ppid=%u", ppid); + } +} + +void fork_child_done(u32 ppid) +{ + g_enable_child_hbt = 0; + g_nstack_share_res->fork_recycle[ppid].forking = 0; +} + +int fork_recycle_check(u32 pid) +{ + if (g_nstack_share_res->fork_recycle[pid].forking) + { + g_nstack_share_res->fork_recycle[pid].delay_recycle = 1; + return -1; + } + + return 0; +} + +/* + * if child die, child_hbt will stop changing, daemon-stack delay MAX_DELAY_RECYCLE_SEC seconds to recycle. + * otherwise, daemon-stack delay recycle until child fork done. + */ +void fork_delay_recycle(u8 sec, nsfw_recycle_fun fun) +{ + u32 i; + + for (i = 0; i < NSFW_MAX_PID; ++i) + { + nstack_fork_recycle *recycle = &g_nstack_share_res->fork_recycle[i]; + if (recycle->delay_recycle) + { + if (recycle->old_child_hbt != recycle->child_hbt) + { + recycle->old_child_hbt = recycle->child_hbt; + recycle->delay_tick = 0; + } + else + { + recycle->delay_tick += sec; + if (!recycle->forking + || (recycle->delay_tick > MAX_DELAY_RECYCLE_SEC)) + { + recycle->delay_recycle = 0; + recycle->delay_tick = 0; + recycle->forking = 0; + (void) fun(i, NULL, 0); + } + } + } + } +} |