mirror of
https://gitee.com/openharmony/startup_init
synced 2024-10-07 06:03:32 +00:00
fix log
Signed-off-by: cheng_jinsong <chengjinsong2@huawei.com>
This commit is contained in:
parent
394dd86c8b
commit
a91a982af4
@ -328,7 +328,7 @@ int GetBlockDeviceByMountPoint(const char *mountPoint, const Fstab *fstab, char
|
||||
}
|
||||
FstabItem *item = FindFstabItemForMountPoint(*fstab, mountPoint);
|
||||
if (item == NULL) {
|
||||
BEGET_LOGE("Failed to get fstab item from point \" %s \"", mountPoint);
|
||||
BEGET_LOGE("Failed to get fstab item from mount point \" %s \"", mountPoint);
|
||||
return -1;
|
||||
}
|
||||
if (strncpy_s(deviceName, nameLen, item->deviceName, strlen(item->deviceName)) != 0) {
|
||||
@ -398,7 +398,6 @@ static unsigned long ParseDefaultMountFlag(const char *str)
|
||||
|
||||
static bool IsFscryptOption(const char *option)
|
||||
{
|
||||
BEGET_LOGI("IsFscryptOption start");
|
||||
if (!option) {
|
||||
return false;
|
||||
}
|
||||
@ -510,7 +509,7 @@ int GetBlockDevicePath(const char *partName, char *path, size_t size)
|
||||
BEGET_CHECK_RETURN_VALUE(fstab != NULL, -1);
|
||||
int ret = GetBlockDeviceByMountPoint(partName, fstab, path, size);
|
||||
BEGET_INFO_CHECK(ret == 0, ret = GetBlockDeviceByName(partName, fstab, path, size),
|
||||
"mount point not found, try to get it by device name");
|
||||
"Mount point not found, try to get path by device name.");
|
||||
ReleaseFstab(fstab);
|
||||
return ret;
|
||||
}
|
||||
|
@ -138,15 +138,15 @@ static int AddMountInfoToSandbox(sandbox_t *sandbox, cJSON *item, const char *ty
|
||||
{
|
||||
BEGET_CHECK(!(sandbox == NULL || item == NULL || type == NULL), return -1);
|
||||
char *srcPath = cJSON_GetStringValue(cJSON_GetObjectItem(item, SANDBOX_SOURCE));
|
||||
BEGET_ERROR_CHECK(srcPath != NULL, return 0, "Get src-path is null");
|
||||
BEGET_INFO_CHECK(srcPath != NULL, return 0, "Get src-path is null");
|
||||
char *dstPath = cJSON_GetStringValue(cJSON_GetObjectItem(item, SANDBOX_TARGET));
|
||||
BEGET_ERROR_CHECK(dstPath != NULL, return 0, "Get sandbox-path is null");
|
||||
BEGET_INFO_CHECK(dstPath != NULL, return 0, "Get sandbox-path is null");
|
||||
cJSON *obj = cJSON_GetObjectItem(item, SANDBOX_FLAGS);
|
||||
BEGET_ERROR_CHECK(obj != NULL, return 0, "Get sandbox-flags is null");
|
||||
BEGET_INFO_CHECK(obj != NULL, return 0, "Get sandbox-flags is null");
|
||||
int ret = cJSON_IsArray(obj);
|
||||
BEGET_ERROR_CHECK(ret, return 0, "Sandbox-flags is not array");
|
||||
BEGET_INFO_CHECK(ret, return 0, "Sandbox-flags is not array");
|
||||
int count = cJSON_GetArraySize(obj);
|
||||
BEGET_ERROR_CHECK(count > 0, return 0, "Get sandbox-flags array size is zero");
|
||||
BEGET_INFO_CHECK(count > 0, return 0, "Get sandbox-flags array size is zero");
|
||||
mountlist_t *tmpMount = (mountlist_t *)calloc(1, sizeof(mountlist_t));
|
||||
BEGET_ERROR_CHECK(tmpMount != NULL, return -1, "Failed calloc err=%d", errno);
|
||||
tmpMount->info = (mount_t *)calloc(1, sizeof(mount_t));
|
||||
@ -214,7 +214,7 @@ static int GetSandboxInfo(sandbox_t *sandbox, cJSON *root, const char *itemName)
|
||||
BEGET_ERROR_CHECK(cJSON_IsArray(obj), return 0, "%s with invalid type, should be array", itemName);
|
||||
|
||||
int counts = cJSON_GetArraySize(obj);
|
||||
BEGET_ERROR_CHECK(!(counts <= 0), return 0, "Item %s array size is zero.", itemName);
|
||||
BEGET_ERROR_CHECK(counts > 0, return 0, "Item %s array size is zero.", itemName);
|
||||
AddInfoToSandboxCallback func = NULL;
|
||||
if (strcmp(itemName, SANDBOX_MOUNT_PATH_TAG) == 0) {
|
||||
func = AddMountInfoToSandbox;
|
||||
@ -339,12 +339,9 @@ static int BindMount(const char *source, const char *target, unsigned long flags
|
||||
}
|
||||
|
||||
BEGET_WARNING_CHECK((tmpflags & MS_BIND) != 0, tmpflags |= MS_BIND,
|
||||
"Not configure bind, must configure bind flag.");
|
||||
|
||||
if ((tmpflags & MS_REC) == 0) {
|
||||
BEGET_LOGW("Not configure rec, must configure rec flag.");
|
||||
tmpflags |= MS_REC;
|
||||
}
|
||||
"Not configure mount bind, must configure mount bind flag.");
|
||||
BEGET_WARNING_CHECK((tmpflags & MS_REC) != 0, tmpflags |= MS_REC,
|
||||
"Not configure mount rec, must configure mount rec flag.");
|
||||
|
||||
// do mount
|
||||
if (mount(source, target, NULL, tmpflags, NULL) != 0) {
|
||||
|
@ -28,14 +28,12 @@
|
||||
static int GetControlFromEnv(const char *path, int length)
|
||||
{
|
||||
BEGET_CHECK_RETURN_VALUE(path != NULL && length > 0, -1);
|
||||
BEGET_LOGI("GetControlFromEnv path is %s ", path);
|
||||
const char *val = getenv(path);
|
||||
BEGET_ERROR_CHECK(val != NULL, return -1, "GetControlFromEnv val is null %d", errno);
|
||||
BEGET_ERROR_CHECK(val != NULL, return -1, "Get environment from %s failed", path);
|
||||
errno = 0;
|
||||
int fd = strtol(val, NULL, N_DEC);
|
||||
BEGET_CHECK_RETURN_VALUE(errno == 0, -1);
|
||||
BEGET_LOGI("GetControlFromEnv fd is %d ", fd);
|
||||
BEGET_ERROR_CHECK(fcntl(fd, F_GETFD) >= 0, return -1, "GetControlFromEnv errno %d ", errno);
|
||||
BEGET_ERROR_CHECK(errno == 0, return -1, "Failed strtol err=%d", errno);
|
||||
BEGET_ERROR_CHECK(fcntl(fd, F_GETFD) >= 0, return -1, "Failed fcntl err=%d ", errno);
|
||||
return fd;
|
||||
}
|
||||
|
||||
@ -45,26 +43,23 @@ int GetControlSocket(const char *name)
|
||||
char path[MAX_SOCKET_ENV_PREFIX_LEN] = {0};
|
||||
BEGET_CHECK_RETURN_VALUE(snprintf_s(path, sizeof(path), sizeof(path) - 1, OHOS_SOCKET_ENV_PREFIX"%s",
|
||||
name) != -1, -1);
|
||||
BEGET_LOGI("GetControlSocket path is %s ", path);
|
||||
int fd = GetControlFromEnv(path, MAX_SOCKET_ENV_PREFIX_LEN);
|
||||
BEGET_ERROR_CHECK(fd >= 0, return -1, "GetControlFromEnv fail ");
|
||||
BEGET_ERROR_CHECK(fd >= 0, return -1, "Get control fd from environment failed");
|
||||
int addrFamily = 0;
|
||||
socklen_t afLen = sizeof(addrFamily);
|
||||
int ret = getsockopt(fd, SOL_SOCKET, SO_DOMAIN, &addrFamily, &afLen);
|
||||
BEGET_ERROR_CHECK(ret == 0, return -1, "get socket option fail, errno %d ", errno);
|
||||
BEGET_LOGI("socket %s fd %d address family %d", name, fd, addrFamily);
|
||||
BEGET_ERROR_CHECK(ret == 0, return -1, "Get socket option fail, err=%d ", errno);
|
||||
if (addrFamily != AF_UNIX) {
|
||||
return fd;
|
||||
}
|
||||
struct sockaddr_un addr;
|
||||
socklen_t addrlen = sizeof(addr);
|
||||
ret = getsockname(fd, (struct sockaddr*)&addr, &addrlen);
|
||||
BEGET_ERROR_CHECK(ret >= 0, return -1, "GetControlSocket errno %d ", errno);
|
||||
BEGET_ERROR_CHECK(ret >= 0, return -1, "Failed getsockname err=%d ", errno);
|
||||
char sockDir[MAX_SOCKET_DIR_LEN] = {0};
|
||||
BEGET_CHECK_RETURN_VALUE(snprintf_s(sockDir, sizeof(sockDir), sizeof(sockDir) - 1, OHOS_SOCKET_DIR"/%s",
|
||||
name) != -1, -1);
|
||||
BEGET_LOGI("sockDir %s ", sockDir);
|
||||
BEGET_LOGI("addr.sun_path %s ", addr.sun_path);
|
||||
BEGET_LOGV("Compary sockDir %s and addr.sun_path %s", sockDir, addr.sun_path);
|
||||
if (strncmp(sockDir, addr.sun_path, strlen(sockDir)) == 0) {
|
||||
return fd;
|
||||
}
|
||||
|
@ -17,7 +17,10 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <sys/stat.h>
|
||||
#include <sys/time.h>
|
||||
#include <sys/types.h>
|
||||
#include <time.h>
|
||||
|
||||
#include "cJSON.h"
|
||||
#ifdef __cplusplus
|
||||
#if __cplusplus
|
||||
@ -68,6 +71,11 @@ struct CmdTable {
|
||||
void (*DoFuncion)(const struct CmdArgs *ctx);
|
||||
};
|
||||
|
||||
typedef struct INIT_TIMING_STAT {
|
||||
struct timespec startTime;
|
||||
struct timespec endTime;
|
||||
} INIT_TIMING_STAT;
|
||||
|
||||
int GetParamValue(const char *symValue, unsigned int symLen, char *paramValue, unsigned int paramLen);
|
||||
const struct CmdArgs *GetCmdArg(const char *cmdContent, const char *delim, int argsCount);
|
||||
void FreeCmdArg(struct CmdArgs *cmd);
|
||||
@ -84,6 +92,7 @@ void ExecCmd(const struct CmdTable *cmd, const char *cmdContent);
|
||||
int SetFileCryptPolicy(const char *dir);
|
||||
|
||||
void OpenHidebug(const char *name);
|
||||
long long InitDiffTime(INIT_TIMING_STAT *stat);
|
||||
#ifdef __cplusplus
|
||||
#if __cplusplus
|
||||
}
|
||||
|
@ -316,7 +316,7 @@ static void DoMkDir(const struct CmdArgs *ctx)
|
||||
}
|
||||
mode_t mode = DEFAULT_DIR_MODE;
|
||||
if (mkdir(ctx->argv[0], mode) != 0 && errno != EEXIST) {
|
||||
INIT_LOGE("DoMkDir, failed for '%s', err %d.", ctx->argv[0], errno);
|
||||
INIT_LOGE("Create directory '%s' failed, err=%d.", ctx->argv[0], errno);
|
||||
return;
|
||||
}
|
||||
|
||||
@ -338,7 +338,7 @@ static void DoMkDir(const struct CmdArgs *ctx)
|
||||
}
|
||||
ret = SetFileCryptPolicy(ctx->argv[0]);
|
||||
if (ret != 0) {
|
||||
INIT_LOGW("failed to set file fscrypt");
|
||||
INIT_LOGW("Failed to set file fscrypt");
|
||||
}
|
||||
|
||||
return;
|
||||
@ -354,7 +354,7 @@ static void DoChmod(const struct CmdArgs *ctx)
|
||||
}
|
||||
|
||||
if (chmod(ctx->argv[1], mode) != 0) {
|
||||
INIT_LOGE("Failed to change mode \" %s \" mode to %04o, err = %d", ctx->argv[1], mode, errno);
|
||||
INIT_LOGE("Failed to change mode \" %s \" to %04o, err=%d", ctx->argv[1], mode, errno);
|
||||
}
|
||||
}
|
||||
|
||||
@ -525,21 +525,21 @@ static void DoSetrlimit(const struct CmdArgs *ctx)
|
||||
INIT_LOGE("DoSetrlimit failed, resources :%s not support.", ctx->argv[0]);
|
||||
return;
|
||||
}
|
||||
INIT_CHECK_ONLY_ELOG(setrlimit(rcs, &limit) == 0, "DoSetrlimit failed : %d", errno);
|
||||
INIT_CHECK_ONLY_ELOG(setrlimit(rcs, &limit) == 0, "Failed setrlimit err=%d", errno);
|
||||
return;
|
||||
}
|
||||
|
||||
static void DoRm(const struct CmdArgs *ctx)
|
||||
{
|
||||
// format: rm /xxx/xxx/xxx
|
||||
INIT_CHECK_ONLY_ELOG(unlink(ctx->argv[0]) != -1, "DoRm: unlink %s failed: %d.", ctx->argv[0], errno);
|
||||
INIT_CHECK_ONLY_ELOG(unlink(ctx->argv[0]) != -1, "Failed unlink %s err=%d.", ctx->argv[0], errno);
|
||||
return;
|
||||
}
|
||||
|
||||
static void DoExport(const struct CmdArgs *ctx)
|
||||
{
|
||||
// format: export xxx /xxx/xxx/xxx
|
||||
INIT_CHECK_ONLY_ELOG(setenv(ctx->argv[0], ctx->argv[1], 1) == 0, "DoExport: set %s with %s failed: %d",
|
||||
INIT_CHECK_ONLY_ELOG(setenv(ctx->argv[0], ctx->argv[1], 1) == 0, "Failed setenv %s with %s err=%d.",
|
||||
ctx->argv[0], ctx->argv[1], errno);
|
||||
return;
|
||||
}
|
||||
@ -693,17 +693,33 @@ int GetCmdLinesFromJson(const cJSON *root, CmdLines **cmdLines)
|
||||
return 0;
|
||||
}
|
||||
|
||||
long long InitDiffTime(INIT_TIMING_STAT *stat)
|
||||
{
|
||||
long long diff = (long long)((stat->endTime.tv_sec - stat->startTime.tv_sec) * 1000000); // 1000000 1000ms
|
||||
if (stat->endTime.tv_nsec > stat->startTime.tv_nsec) {
|
||||
diff += (stat->endTime.tv_nsec - stat->startTime.tv_nsec) / 1000; // 1000 ms
|
||||
} else {
|
||||
diff -= (stat->startTime.tv_nsec - stat->endTime.tv_nsec) / 1000; // 1000 ms
|
||||
}
|
||||
return diff;
|
||||
}
|
||||
|
||||
void DoCmdByName(const char *name, const char *cmdContent)
|
||||
{
|
||||
if (name == NULL || cmdContent == NULL) {
|
||||
return;
|
||||
}
|
||||
INIT_TIMING_STAT cmdTimer;
|
||||
(void)clock_gettime(CLOCK_MONOTONIC, &cmdTimer.startTime);
|
||||
const struct CmdTable *cmd = GetCmdByName(name);
|
||||
if (cmd != NULL) {
|
||||
ExecCmd(cmd, cmdContent);
|
||||
return;
|
||||
} else {
|
||||
PluginExecCmdByName(name, cmdContent);
|
||||
}
|
||||
PluginExecCmdByName(name, cmdContent);
|
||||
(void)clock_gettime(CLOCK_MONOTONIC, &cmdTimer.endTime);
|
||||
long long diff = InitDiffTime(&cmdTimer);
|
||||
INIT_LOGV("Command %s execute time %lld", name, diff);
|
||||
}
|
||||
|
||||
void DoCmdByIndex(int index, const char *cmdContent)
|
||||
@ -712,16 +728,23 @@ void DoCmdByIndex(int index, const char *cmdContent)
|
||||
return;
|
||||
}
|
||||
int cmdCnt = 0;
|
||||
INIT_TIMING_STAT cmdTimer;
|
||||
(void)clock_gettime(CLOCK_MONOTONIC, &cmdTimer.startTime);
|
||||
const struct CmdTable *commCmds = GetCommCmdTable(&cmdCnt);
|
||||
if (index < cmdCnt) {
|
||||
ExecCmd(&commCmds[index], cmdContent);
|
||||
return;
|
||||
INIT_LOGV("Command: %s content: %s", commCmds[index].name, cmdContent);
|
||||
} else {
|
||||
int number = 0;
|
||||
const struct CmdTable *cmds = GetCmdTable(&number);
|
||||
if (index < (cmdCnt + number)) {
|
||||
ExecCmd(&cmds[index - cmdCnt], cmdContent);
|
||||
INIT_LOGV("Command: %s content: %s", cmds[index - cmdCnt].name, cmdContent);
|
||||
} else {
|
||||
PluginExecCmdByCmdIndex(index, cmdContent);
|
||||
}
|
||||
}
|
||||
int number = 0;
|
||||
const struct CmdTable *cmds = GetCmdTable(&number);
|
||||
if (index < (cmdCnt + number)) {
|
||||
ExecCmd(&cmds[index - cmdCnt], cmdContent);
|
||||
return;
|
||||
}
|
||||
PluginExecCmdByCmdIndex(index, cmdContent);
|
||||
(void)clock_gettime(CLOCK_MONOTONIC, &cmdTimer.endTime);
|
||||
long long diff = InitDiffTime(&cmdTimer);
|
||||
INIT_LOGV("Command execute time %lld", diff);
|
||||
}
|
||||
|
@ -295,13 +295,13 @@ static int InitServiceProperties(Service *service)
|
||||
{
|
||||
INIT_ERROR_CHECK(service != NULL, return -1, "Invalid parameter.");
|
||||
SetServiceEnterSandbox(service->pathArgs.argv[0], service->attribute);
|
||||
INIT_CHECK_ONLY_ELOG(SetAccessToken(service) == SERVICE_SUCCESS, "access token failed %s", service->name);
|
||||
INIT_CHECK_ONLY_ELOG(SetAccessToken(service) == SERVICE_SUCCESS,
|
||||
"Set service %s access token failed", service->name);
|
||||
// deal start job
|
||||
if (service->serviceJobs.jobsName[JOB_ON_START] != NULL) {
|
||||
DoJobNow(service->serviceJobs.jobsName[JOB_ON_START]);
|
||||
}
|
||||
ClearEnvironment(service);
|
||||
|
||||
if (!IsOnDemandService(service)) {
|
||||
INIT_ERROR_CHECK(CreateServiceSocket(service) >= 0, return -1,
|
||||
"service %s exit! create socket failed!", service->name);
|
||||
@ -321,7 +321,7 @@ static int InitServiceProperties(Service *service)
|
||||
// permissions
|
||||
INIT_ERROR_CHECK(SetPerms(service) == SERVICE_SUCCESS, return -1,
|
||||
"service %s exit! set perms failed! err %d.", service->name, errno);
|
||||
|
||||
|
||||
// write pid
|
||||
INIT_ERROR_CHECK(WritePid(service) == SERVICE_SUCCESS, return -1,
|
||||
"service %s exit! write pid failed!", service->name);
|
||||
@ -350,7 +350,7 @@ void EnterServiceSandbox(Service *service)
|
||||
int ServiceStart(Service *service)
|
||||
{
|
||||
INIT_ERROR_CHECK(service != NULL, return SERVICE_FAILURE, "start service failed! null ptr.");
|
||||
INIT_ERROR_CHECK(service->pid <= 0, return SERVICE_SUCCESS, "service : %s had started already.", service->name);
|
||||
INIT_ERROR_CHECK(service->pid <= 0, return SERVICE_SUCCESS, "Service %s already started", service->name);
|
||||
INIT_ERROR_CHECK(service->pathArgs.count > 0,
|
||||
return SERVICE_FAILURE, "start service %s pathArgs is NULL.", service->name);
|
||||
|
||||
@ -382,7 +382,7 @@ int ServiceStart(Service *service)
|
||||
INIT_LOGE("start service %s fork failed!", service->name);
|
||||
return SERVICE_FAILURE;
|
||||
}
|
||||
INIT_LOGI("service %s starting pid %d", service->name, pid);
|
||||
INIT_LOGI("Service %s(pid %d) started", service->name, pid);
|
||||
service->pid = pid;
|
||||
NotifyServiceChange(service, SERVICE_STARTED);
|
||||
return SERVICE_SUCCESS;
|
||||
@ -414,8 +414,6 @@ int ServiceStop(Service *service)
|
||||
"stop service %s pid %d failed! err %d.", service->name, service->pid, errno);
|
||||
NotifyServiceChange(service, SERVICE_STOPPING);
|
||||
INIT_LOGI("stop service %s, pid %d.", service->name, service->pid);
|
||||
service->pid = -1;
|
||||
NotifyServiceChange(service, SERVICE_STOPPED);
|
||||
return SERVICE_SUCCESS;
|
||||
}
|
||||
|
||||
|
@ -34,7 +34,7 @@ static void ParseInitCfgContents(const char *cfgName, const cJSON *root)
|
||||
int ParseInitCfg(const char *configFile, void *context)
|
||||
{
|
||||
UNUSED(context);
|
||||
INIT_LOGI("ParseInitCfg %s", configFile);
|
||||
INIT_LOGV("Parse init configs from %s", configFile);
|
||||
static const char *excludeCfg[] = {
|
||||
"/system/etc/init/weston.cfg"
|
||||
};
|
||||
|
@ -49,7 +49,6 @@ static int ParseGroupCfgItem(cJSON *root, int type, const char *itemName)
|
||||
{
|
||||
int itemNumber = 0;
|
||||
cJSON *json = GetArrayItem(root, &itemNumber, itemName);
|
||||
INIT_LOGI("ParseGroupCfgItem %s itemNumber %d", itemName, itemNumber);
|
||||
if (json == NULL) {
|
||||
return 0;
|
||||
}
|
||||
@ -189,7 +188,7 @@ void InitServiceSpace(void)
|
||||
int ret = GetProcCmdlineValue(BOOT_GROUP_NAME, data,
|
||||
g_initWorkspace.groupModeStr, sizeof(g_initWorkspace.groupModeStr));
|
||||
if (ret != 0) {
|
||||
INIT_LOGE("%s", "Failed to get boot group");
|
||||
INIT_LOGV("Failed to get boot group");
|
||||
if (GetBootModeFromMisc() == GROUP_CHARGE) {
|
||||
strcpy_s(g_initWorkspace.groupModeStr, sizeof(g_initWorkspace.groupModeStr), "device.charge.group");
|
||||
}
|
||||
|
@ -39,7 +39,7 @@ static int CreateFile(ServiceFile *file)
|
||||
INIT_ERROR_CHECK(strncpy_s(path, strlen(file->fileName) + 1, file->fileName, strlen(file->fileName)) >= 0,
|
||||
return -1, "Failed strncpy_s err=%d", errno);
|
||||
}
|
||||
INIT_LOGI("File path =%s . file flags =%d, file perm =%u ", path, file->flags, file->perm);
|
||||
INIT_LOGV("File path =%s . file flags =%d, file perm =%u ", path, file->flags, file->perm);
|
||||
if (file->fd >= 0) {
|
||||
close(file->fd);
|
||||
file->fd = -1;
|
||||
@ -64,7 +64,6 @@ static int SetFileEnv(int fd, const char *pathName)
|
||||
char val[MAX_FILE_FD_LEN] = { 0 };
|
||||
INIT_ERROR_CHECK(snprintf_s(val, sizeof(val), sizeof(val) - 1, "%d", fd) >= 0, return -1,
|
||||
"Failed snprintf_s err=%d", errno);
|
||||
INIT_LOGE("Set file env pubName =%s, val =%s.", pubName, val);
|
||||
int ret = setenv(pubName, val, 1);
|
||||
INIT_ERROR_CHECK(ret >= 0, return -1, "Failed setenv err=%d ", errno);
|
||||
fcntl(fd, F_SETFD, 0);
|
||||
|
@ -213,7 +213,7 @@ static int GetServiceArgs(const cJSON *argJson, const char *name, int maxCount,
|
||||
INIT_ERROR_CHECK(curParam != NULL, return SERVICE_FAILURE, "Invalid arg %d", i);
|
||||
INIT_ERROR_CHECK(strlen(curParam) <= MAX_ONE_ARG_LEN, return SERVICE_FAILURE, "Arg %s is tool long", curParam);
|
||||
args->argv[i] = strdup(curParam);
|
||||
INIT_ERROR_CHECK(args->argv[i] != NULL, return SERVICE_FAILURE, "Failed to dupstring %s", curParam);
|
||||
INIT_ERROR_CHECK(args->argv[i] != NULL, return SERVICE_FAILURE, "Failed to duplicate argument %s", curParam);
|
||||
}
|
||||
return SERVICE_SUCCESS;
|
||||
}
|
||||
@ -265,13 +265,13 @@ static int GetServiceGids(const cJSON *curArrItem, Service *curServ)
|
||||
free(curServ->servPerm.gIDArray);
|
||||
}
|
||||
curServ->servPerm.gIDArray = (gid_t *)malloc(sizeof(gid_t) * gidCount);
|
||||
INIT_ERROR_CHECK(curServ->servPerm.gIDArray != NULL, return SERVICE_FAILURE, "Failed to malloc");
|
||||
INIT_ERROR_CHECK(curServ->servPerm.gIDArray != NULL, return SERVICE_FAILURE, "Failed to malloc err=%d", errno);
|
||||
curServ->servPerm.gIDCnt = gidCount;
|
||||
|
||||
gid_t gid;
|
||||
if (!cJSON_IsArray(arrItem)) {
|
||||
int ret = GetGid(arrItem, &gid, curServ);
|
||||
INIT_ERROR_CHECK(ret == 0, return SERVICE_FAILURE, "Failed to gid");
|
||||
INIT_ERROR_CHECK(ret == 0, return SERVICE_FAILURE, "Parse service %s gid failed.", curServ->name);
|
||||
curServ->servPerm.gIDArray[0] = gid;
|
||||
return SERVICE_SUCCESS;
|
||||
}
|
||||
@ -280,7 +280,7 @@ static int GetServiceGids(const cJSON *curArrItem, Service *curServ)
|
||||
cJSON *item = cJSON_GetArrayItem(arrItem, i);
|
||||
int ret = GetGid(item, &gid, curServ);
|
||||
if (ret != 0) {
|
||||
INIT_LOGE("parse service %s %d gid failed skip this", curServ->name, i);
|
||||
INIT_LOGW("Parse service %s gid failed from item %s.", curServ->name, cJSON_Print(item));
|
||||
continue;
|
||||
}
|
||||
curServ->servPerm.gIDArray[gidArrayIndex++] = gid;
|
||||
@ -1071,7 +1071,7 @@ static Service *GetServiceByExtServName(const char *fullServName)
|
||||
|
||||
void StartServiceByName(const char *servName)
|
||||
{
|
||||
INIT_LOGI("StartServiceByName Service %s", servName);
|
||||
INIT_LOGI("Start service %s", servName);
|
||||
Service *service = GetServiceByName(servName);
|
||||
if (service == NULL) {
|
||||
service = GetServiceByExtServName(servName);
|
||||
@ -1094,7 +1094,7 @@ void StopServiceByName(const char *servName)
|
||||
INIT_ERROR_CHECK(service != NULL, return, "Cannot find service %s.", servName);
|
||||
|
||||
if (ServiceStop(service) != SERVICE_SUCCESS) {
|
||||
INIT_LOGE("Service %s start failed!", servName);
|
||||
INIT_LOGE("Service %s stop failed!", servName);
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
@ -123,8 +123,8 @@ static int SetSocketOptionAndBind(ServiceSocket *sockopt)
|
||||
|
||||
static int CreateSocket(ServiceSocket *sockopt)
|
||||
{
|
||||
INIT_ERROR_CHECK(sockopt != NULL, return SERVICE_FAILURE, "Invalid socket opt");
|
||||
INIT_LOGI("name: %s, family: %d, type: %u, protocol: %d, perm: %u, uid: %u, gid: %u, option: %u",
|
||||
INIT_ERROR_CHECK(sockopt != NULL, return SERVICE_FAILURE, "Invalid socket options");
|
||||
INIT_LOGV("Socket name: %s, family: %d, type: %u, protocol: %d, perm: %u, uid: %u, gid: %u, option: %u",
|
||||
sockopt->name, sockopt->family, sockopt->type, sockopt->protocol,
|
||||
sockopt->perm, sockopt->uid, sockopt->gid, sockopt->option);
|
||||
if (sockopt->sockFd >= 0) {
|
||||
@ -192,7 +192,7 @@ int SocketAddWatcher(ServiceWatcher *watcherHandle, Service *service, int fd)
|
||||
info.events = Event_Read;
|
||||
info.processEvent = ProcessWatchEvent_;
|
||||
int ret = LE_StartWatcher(LE_GetDefaultLoop(), &handle, &info, service);
|
||||
INIT_LOGI("Start to monitor socket, fd:%d service name:%s", fd, service->name);
|
||||
INIT_LOGI("Watcher socket fd %d for service %s", fd, service->name);
|
||||
*watcherHandle = (ServiceWatcher)handle;
|
||||
return ret;
|
||||
}
|
||||
|
@ -66,21 +66,8 @@ int ServiceExec(const Service *service)
|
||||
{
|
||||
INIT_ERROR_CHECK(service != NULL && service->pathArgs.count > 0,
|
||||
return SERVICE_FAILURE, "Exec service failed! null ptr.");
|
||||
INIT_LOGI("service->name is %s ", service->name);
|
||||
char sockEnvName[MAX_ENV_NAME] = {0};
|
||||
char sockEnvValue[MAX_ENV_NAME] = {0};
|
||||
if (service->socketCfg != NULL) {
|
||||
INIT_ERROR_CHECK(snprintf_s(sockEnvName, MAX_ENV_NAME, MAX_ENV_NAME - 1, "OHOS_SOCKET_%s",
|
||||
service->socketCfg->name) != -1,
|
||||
return SERVICE_FAILURE, "format socket env name failed!");
|
||||
INIT_ERROR_CHECK(snprintf_s(sockEnvValue, MAX_ENV_NAME, MAX_ENV_NAME - 1, "%d",
|
||||
service->socketCfg->sockFd) != -1,
|
||||
return SERVICE_FAILURE, "format socket env value failed!");
|
||||
}
|
||||
INIT_CHECK_ONLY_ELOG(setenv(sockEnvName, sockEnvValue, 1) == 0, "DoExport: set %s with %s failed: %d",
|
||||
sockEnvName, sockEnvValue, errno);
|
||||
if (execv(service->pathArgs.argv[0], service->pathArgs.argv) != 0) {
|
||||
INIT_LOGE("service %s execv failed! err %d.", service->name, errno);
|
||||
INIT_LOGE("Service %s execv failed! err=%d.", service->name, errno);
|
||||
return errno;
|
||||
}
|
||||
return SERVICE_SUCCESS;
|
||||
|
@ -46,11 +46,6 @@
|
||||
#include "fd_holder_internal.h"
|
||||
#include "bootstage.h"
|
||||
|
||||
typedef struct HOOK_TIMING_STAT {
|
||||
struct timespec startTime;
|
||||
struct timespec endTime;
|
||||
} HOOK_TIMING_STAT;
|
||||
|
||||
static int FdHolderSockInit(void)
|
||||
{
|
||||
int sock = -1;
|
||||
@ -206,6 +201,7 @@ static void StartInitSecondStage(void)
|
||||
KeyCtrlGetKeyringId(KEY_SPEC_SESSION_KEYRING, 1);
|
||||
|
||||
#ifndef DISABLE_INIT_TWO_STAGES
|
||||
INIT_LOGI("Start init second stage.");
|
||||
SwitchRoot("/usr");
|
||||
// Execute init second stage
|
||||
char * const args[] = {
|
||||
@ -222,6 +218,7 @@ static void StartInitSecondStage(void)
|
||||
|
||||
void SystemPrepare(void)
|
||||
{
|
||||
INIT_LOGI("Start init first stage.");
|
||||
MountBasicFs();
|
||||
CreateDeviceNode();
|
||||
LogInit();
|
||||
@ -252,17 +249,7 @@ HOOK_MGR *GetBootStageHookMgr()
|
||||
return bootStageHookMgr;
|
||||
}
|
||||
|
||||
HOOK_TIMING_STAT g_bootJob = {0};
|
||||
static long long InitDiffTime(HOOK_TIMING_STAT *stat)
|
||||
{
|
||||
long long diff = (long long)((stat->endTime.tv_sec - stat->startTime.tv_sec) * 1000000); // 1000000 1000ms
|
||||
if (stat->endTime.tv_nsec > stat->startTime.tv_nsec) {
|
||||
diff += (stat->endTime.tv_nsec - stat->startTime.tv_nsec) / 1000; // 1000 ms
|
||||
} else {
|
||||
diff -= (stat->startTime.tv_nsec - stat->endTime.tv_nsec) / 1000; // 1000 ms
|
||||
}
|
||||
return diff;
|
||||
}
|
||||
INIT_TIMING_STAT g_bootJob = {0};
|
||||
|
||||
static void BootStateChange(int start, const char *content)
|
||||
{
|
||||
@ -297,13 +284,13 @@ static void InitLoadParamFiles(void)
|
||||
|
||||
static void InitPreHook(const HOOK_INFO *hookInfo, void *executionContext)
|
||||
{
|
||||
HOOK_TIMING_STAT *stat = (HOOK_TIMING_STAT *)executionContext;
|
||||
INIT_TIMING_STAT *stat = (INIT_TIMING_STAT *)executionContext;
|
||||
clock_gettime(CLOCK_MONOTONIC, &(stat->startTime));
|
||||
}
|
||||
|
||||
static void InitPostHook(const HOOK_INFO *hookInfo, void *executionContext, int executionRetVal)
|
||||
{
|
||||
HOOK_TIMING_STAT *stat = (HOOK_TIMING_STAT *)executionContext;
|
||||
INIT_TIMING_STAT *stat = (INIT_TIMING_STAT *)executionContext;
|
||||
clock_gettime(CLOCK_MONOTONIC, &(stat->endTime));
|
||||
long long diff = InitDiffTime(stat);
|
||||
INIT_LOGI("Executing hook [%d:%d:%p] cost [%lld]us, return %d.",
|
||||
@ -352,7 +339,7 @@ static void TriggerServices(int startMode)
|
||||
|
||||
void SystemConfig(void)
|
||||
{
|
||||
HOOK_TIMING_STAT timingStat;
|
||||
INIT_TIMING_STAT timingStat;
|
||||
HOOK_EXEC_OPTIONS options;
|
||||
|
||||
options.flags = 0;
|
||||
|
@ -29,7 +29,7 @@ static int g_cmdId = 0;
|
||||
int AddCmdExecutor(const char *cmdName, CmdExecutor execCmd)
|
||||
{
|
||||
INIT_ERROR_CHECK(cmdName != NULL, return -1, "Invalid input param");
|
||||
INIT_LOGI("AddCmdExecutor '%s'", cmdName);
|
||||
INIT_LOGV("Add command '%s' executor.", cmdName);
|
||||
PluginCmd *cmd = NULL;
|
||||
InitGroupNode *groupNode = GetGroupNode(NODE_TYPE_CMDS, cmdName);
|
||||
if (groupNode == NULL) {
|
||||
@ -158,6 +158,7 @@ void PluginExecCmdByCmdIndex(int index, const char *cmdContent)
|
||||
return;
|
||||
}
|
||||
PluginCmd *cmd = groupNode->data.cmd;
|
||||
INIT_LOGV("Command: %s cmdContent: %s", cmd->name, cmdContent);
|
||||
PluginExecCmd_(cmd, cmdContent);
|
||||
}
|
||||
|
||||
@ -186,6 +187,5 @@ const char *PluginGetCmdIndex(const char *cmdStr, int *index)
|
||||
hashCode = (hashCode < 0) ? -hashCode : hashCode;
|
||||
hashCode = hashCode % GROUP_HASHMAP_BUCKET;
|
||||
*index = ((hashCode + 1) << 16) | cmd->cmdId; // 16 left shift
|
||||
INIT_LOGI("PluginGetCmdIndex content: %s index %d", cmd->name, *index);
|
||||
return cmd->name;
|
||||
}
|
||||
|
@ -92,7 +92,7 @@ int GetParamValue(const char *symValue, unsigned int symLen, char *paramValue, u
|
||||
static void SyncExecCommand(int argc, char * const *argv)
|
||||
{
|
||||
INIT_CHECK(!(argc == 0 || argv == NULL || argv[0] == NULL), return);
|
||||
INIT_LOGI("sync exec: %s", argv[0]);
|
||||
INIT_LOGI("Sync exec: %s", argv[0]);
|
||||
pid_t pid = fork();
|
||||
INIT_ERROR_CHECK(!(pid < 0), return, "Fork new process to format failed: %d", errno);
|
||||
if (pid == 0) {
|
||||
@ -105,7 +105,7 @@ static void SyncExecCommand(int argc, char * const *argv)
|
||||
INIT_LOGE("Failed to wait pid %d, errno %d", pid, errno);
|
||||
return;
|
||||
}
|
||||
INIT_LOGI("sync exec: %s result %d %d", argv[0], WEXITSTATUS(status), WIFEXITED(status));
|
||||
INIT_LOGI("Sync exec: %s result %d %d", argv[0], WEXITSTATUS(status), WIFEXITED(status));
|
||||
return;
|
||||
}
|
||||
|
||||
@ -424,17 +424,18 @@ static bool InitFscryptPolicy(void)
|
||||
|
||||
static void DoInitGlobalKey(const struct CmdArgs *ctx)
|
||||
{
|
||||
INIT_LOGV("Do init global key start");
|
||||
if (ctx == NULL || ctx->argc != 1) {
|
||||
INIT_LOGE("DoInitGlobalKey: para invalid");
|
||||
INIT_LOGE("Parameter is invalid");
|
||||
return;
|
||||
}
|
||||
const char *dataDir = "/data";
|
||||
if (strncmp(ctx->argv[0], dataDir, strlen(dataDir)) != 0) {
|
||||
INIT_LOGE("DoInitGlobalKey: not data partitation");
|
||||
INIT_LOGE("Not data partitation");
|
||||
return;
|
||||
}
|
||||
if (!InitFscryptPolicy()) {
|
||||
INIT_LOGI("DoInitGlobalKey:init fscrypt failed,not enable fscrypt");
|
||||
INIT_LOGW("Init fscrypt failed, not enable fscrypt");
|
||||
return;
|
||||
}
|
||||
|
||||
@ -451,7 +452,7 @@ static void DoInitGlobalKey(const struct CmdArgs *ctx)
|
||||
static void DoInitMainUser(const struct CmdArgs *ctx)
|
||||
{
|
||||
if (ctx == NULL) {
|
||||
INIT_LOGE("DoInitMainUser: para invalid");
|
||||
INIT_LOGE("Do init main user: para invalid");
|
||||
return;
|
||||
}
|
||||
|
||||
@ -468,7 +469,7 @@ static void DoInitMainUser(const struct CmdArgs *ctx)
|
||||
static void DoMkswap(const struct CmdArgs *ctx)
|
||||
{
|
||||
if (ctx == NULL) {
|
||||
INIT_LOGE("DoMkswap: para invalid");
|
||||
INIT_LOGE("Parameter is invalid");
|
||||
return;
|
||||
}
|
||||
char *const argv[] = {
|
||||
@ -483,7 +484,7 @@ static void DoMkswap(const struct CmdArgs *ctx)
|
||||
static void DoSwapon(const struct CmdArgs *ctx)
|
||||
{
|
||||
if (ctx == NULL) {
|
||||
INIT_LOGE("DoSwapon: para invalid");
|
||||
INIT_LOGE("Parameter is invalid");
|
||||
return;
|
||||
}
|
||||
char *const argv[] = {
|
||||
@ -497,7 +498,7 @@ static void DoSwapon(const struct CmdArgs *ctx)
|
||||
|
||||
static void DoMkSandbox(const struct CmdArgs *ctx)
|
||||
{
|
||||
INIT_LOGI("DoMkSandbox: start");
|
||||
INIT_LOGV("Do make sandbox start");
|
||||
if ((ctx == NULL) || (ctx->argc != 1)) {
|
||||
INIT_LOGE("Call DoMkSandbox with invalid arguments");
|
||||
return;
|
||||
|
@ -40,7 +40,7 @@ static bool g_enableSandbox = false;
|
||||
|
||||
void NotifyServiceChange(Service *service, int status)
|
||||
{
|
||||
INIT_LOGI("NotifyServiceChange %s %d to %d", service->name, service->status, status);
|
||||
INIT_LOGV("Notify service %s change from %d to %d", service->name, service->status, status);
|
||||
service->status = status;
|
||||
INIT_CHECK(status != SERVICE_IDLE, return);
|
||||
char paramName[PARAM_NAME_LEN_MAX] = { 0 };
|
||||
@ -98,8 +98,11 @@ int SetAccessToken(const Service *service)
|
||||
{
|
||||
INIT_ERROR_CHECK(service != NULL, return SERVICE_FAILURE, "service is null");
|
||||
int ret = SetSelfTokenID(service->tokenId);
|
||||
INIT_LOGI("%s: token id %lld, set token id result %d", service->name, service->tokenId, ret);
|
||||
return ret == 0 ? SERVICE_SUCCESS : SERVICE_FAILURE;
|
||||
if (ret != 0) {
|
||||
INIT_LOGV("Set service %s token id %lld failed.", service->name, service->tokenId);
|
||||
return SERVICE_FAILURE;
|
||||
}
|
||||
return SERVICE_SUCCESS;
|
||||
}
|
||||
|
||||
void GetAccessToken(void)
|
||||
@ -125,7 +128,6 @@ void GetAccessToken(void)
|
||||
service->name,
|
||||
apl,
|
||||
};
|
||||
|
||||
uint64_t tokenId = GetAccessTokenId(&nativeTokenInfoParams);
|
||||
INIT_CHECK_ONLY_ELOG(tokenId != 0,
|
||||
"Get totken id %lld of service \' %s \' failed", tokenId, service->name);
|
||||
|
@ -35,18 +35,16 @@ static void ProcessSignal(const struct signalfd_siginfo *siginfo)
|
||||
if (sigPID <= 0) {
|
||||
break;
|
||||
}
|
||||
Service* service = GetServiceByPid(sigPID);
|
||||
// check child process exit status
|
||||
if (WIFSIGNALED(procStat)) {
|
||||
INIT_LOGE("Child process %d exit with signal: %d", sigPID, WTERMSIG(procStat));
|
||||
}
|
||||
if (WIFEXITED(procStat)) {
|
||||
INIT_LOGE("Child process %d exit with code : %d", sigPID, WEXITSTATUS(procStat));
|
||||
INIT_LOGE("Child process %s(pid %d) exit with code : %d",
|
||||
service == NULL ? "Unknown" : service->name, sigPID, WEXITSTATUS(procStat));
|
||||
}
|
||||
CmdServiceProcessDelClient(sigPID);
|
||||
Service* service = GetServiceByPid(sigPID);
|
||||
INIT_LOGI("SigHandler, SIGCHLD received, Service:%s pid:%d uid:%d status:%d.",
|
||||
service == NULL ? "Unknown" : service->name,
|
||||
sigPID, siginfo->ssi_uid, procStat);
|
||||
CheckWaitPid(sigPID);
|
||||
ServiceReap(service);
|
||||
}
|
||||
|
@ -128,12 +128,12 @@ static void RebootAdpExit(void)
|
||||
|
||||
MODULE_CONSTRUCTOR(void)
|
||||
{
|
||||
PLUGIN_LOGI("RebootAdp init now ...");
|
||||
PLUGIN_LOGI("Reboot adapter plug-in init now ...");
|
||||
RebootAdpInit();
|
||||
}
|
||||
|
||||
MODULE_DESTRUCTOR(void)
|
||||
{
|
||||
PLUGIN_LOGI("RebootAdp exit now ...");
|
||||
PLUGIN_LOGI("Reboot adapter plug-in exit now ...");
|
||||
RebootAdpExit();
|
||||
}
|
||||
|
@ -52,7 +52,7 @@ static int SetServiceContent(int id, const char *name, int argc, const char **ar
|
||||
PLUGIN_LOGE("failed to set service %s's secon (%s).", argv[0], (char *)data->data);
|
||||
_exit(PROCESS_EXIT_CODE);
|
||||
} else {
|
||||
PLUGIN_LOGI("Set content %s to %s.", (char *)data->data, argv[0]);
|
||||
PLUGIN_LOGV("Set content %s to %s.", (char *)data->data, argv[0]);
|
||||
}
|
||||
} else {
|
||||
PLUGIN_CHECK(!(setexeccon("u:r:limit_domain:s0") < 0), _exit(PROCESS_EXIT_CODE),
|
||||
@ -95,12 +95,12 @@ static void SelinuxAdpExit(void)
|
||||
|
||||
MODULE_CONSTRUCTOR(void)
|
||||
{
|
||||
PLUGIN_LOGI("SelinuxAdp init now ...");
|
||||
PLUGIN_LOGI("Selinux adapter plug-in init now ...");
|
||||
SelinuxAdpInit();
|
||||
}
|
||||
|
||||
MODULE_DESTRUCTOR(void)
|
||||
{
|
||||
PLUGIN_LOGI("SelinuxAdp exit now ...");
|
||||
PLUGIN_LOGI("Selinux adapter plug-in exit now ...");
|
||||
SelinuxAdpExit();
|
||||
}
|
@ -195,7 +195,7 @@ static int DacGetParamSecurityLabel(const char *path)
|
||||
ProcessParamFile(fileName, NULL);
|
||||
}
|
||||
}
|
||||
PARAM_LOGI("DacGetParamSecurityLabel path %s %d", path, count);
|
||||
PARAM_LOGV("Get parameter security label dac number is %d, from %s.", count, path);
|
||||
free(fileName);
|
||||
closedir(pDir);
|
||||
return 0;
|
||||
|
@ -42,7 +42,7 @@ static int LoadPersistParam()
|
||||
if (fp == NULL) {
|
||||
tmpPath = (updaterMode == 0) ? PARAM_PERSIST_SAVE_PATH : "/param/persist_parameters";
|
||||
fp = fopen(tmpPath, "r");
|
||||
PARAM_LOGI("LoadPersistParam open file %s", PARAM_PERSIST_SAVE_PATH);
|
||||
PARAM_LOGI("Load persist param, from file %s", tmpPath);
|
||||
}
|
||||
PARAM_CHECK(fp != NULL, return -1, "No valid persist parameter file %s", PARAM_PERSIST_SAVE_PATH);
|
||||
|
||||
|
@ -202,7 +202,7 @@ static int SelinuxGetAllLabel(int readOnly)
|
||||
if (readOnly == 0) {
|
||||
SetSelinuxFileCon(WORKSPACE_NAME_DEF_SELINUX, WORKSPACE_NAME_DEF_SELINUX);
|
||||
}
|
||||
PARAM_LOGI("SelinuxGetAllLabel count %d", count);
|
||||
PARAM_LOGV("Selinux get all label counts %d.", count);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
@ -75,7 +75,7 @@ static int InitParamSecurity(ParamWorkSpace *workSpace,
|
||||
}
|
||||
ret = paramSecurityOps->securityCheckFilePermission(&workSpace->securityLabel, PARAM_STORAGE_PATH, op);
|
||||
PARAM_CHECK(ret == 0, return PARAM_CODE_INVALID_NAME, "No permission to read file %s", PARAM_STORAGE_PATH);
|
||||
PARAM_LOGI("InitParamSecurity %s success", paramSecurityOps->name);
|
||||
PARAM_LOGI("Init parameter %s success", paramSecurityOps->name);
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -107,7 +107,6 @@ static int CheckNeedInit(int onlyRead, const PARAM_WORKSPACE_OPS *ops)
|
||||
g_paramWorkSpace.ops.setfilecon = ops->setfilecon;
|
||||
#endif
|
||||
}
|
||||
PARAM_LOGI("InitParamWorkSpace %x", g_paramWorkSpace.flags);
|
||||
if (PARAM_TEST_FLAG(g_paramWorkSpace.flags, WORKSPACE_FLAGS_INIT)) {
|
||||
return 0;
|
||||
}
|
||||
@ -225,7 +224,7 @@ INIT_INNER_API ParamWorkSpace *GetParamWorkSpace(void)
|
||||
|
||||
int SystemReadParam(const char *name, char *value, uint32_t *len)
|
||||
{
|
||||
PARAM_WORKSPACE_CHECK(&g_paramWorkSpace, return -1, "Invalid space");
|
||||
PARAM_WORKSPACE_CHECK(&g_paramWorkSpace, return -1, "Param workspace has not init.");
|
||||
PARAM_CHECK(name != NULL && len != NULL && strlen(name) > 0, return -1, "The name or value is null");
|
||||
ParamHandle handle = 0;
|
||||
int ret = ReadParamWithCheck(name, DAC_READ, &handle);
|
||||
|
@ -134,7 +134,10 @@ static int StartRequest(int clientFd, ParamMessage *request, int timeout)
|
||||
{
|
||||
int ret = 0;
|
||||
ssize_t sendLen = send(clientFd, (char *)request, request->msgSize, 0);
|
||||
PARAM_CHECK(sendLen >= 0, return PARAM_CODE_FAIL_CONNECT, "Failed to send message");
|
||||
if (errno == EINVAL || errno == EACCES) {
|
||||
return PARAM_CODE_INVALID_SOCKET;
|
||||
}
|
||||
PARAM_CHECK(sendLen >= 0, return PARAM_CODE_FAIL_CONNECT, "Failed to send message err: %d", errno);
|
||||
PARAM_LOGV("sendMessage sendLen fd %d %zd", clientFd, sendLen);
|
||||
ret = ReadMessage(clientFd, (char *)request, timeout);
|
||||
if (ret == 0) {
|
||||
|
@ -95,7 +95,7 @@ static int SendResponseMsg(ParamTaskPtr worker, const ParamMessage *msg, int res
|
||||
response->result = result;
|
||||
response->msg.msgSize = sizeof(ParamResponseMessage);
|
||||
ParamTaskSendMsg(worker, (ParamMessage *)response);
|
||||
PARAM_LOGI("SendResponseMsg msgId %d result %d", msg->id.msgId, result);
|
||||
PARAM_LOGI("Send response msg msgId %d result %d", msg->id.msgId, result);
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -172,7 +172,7 @@ static int HandleParamSet(const ParamTaskPtr worker, const ParamMessage *msg)
|
||||
srcLabel.cred.uid = cr.uid;
|
||||
srcLabel.cred.pid = cr.pid;
|
||||
srcLabel.cred.gid = cr.gid;
|
||||
PARAM_LOGI("HandleParamSet msgId %d pid %d key: %s", msg->id.msgId, cr.pid, msg->key);
|
||||
PARAM_LOGI("Handle set param msgId %d pid %d key: %s", msg->id.msgId, cr.pid, msg->key);
|
||||
int ret = SystemSetParam(msg->key, valueContent->content, &srcLabel);
|
||||
return SendResponseMsg(worker, msg, ret);
|
||||
}
|
||||
@ -364,7 +364,6 @@ static void LoadSelinuxLabel(void)
|
||||
// load security label
|
||||
#ifdef PARAM_SUPPORT_SELINUX
|
||||
ParamSecurityOps *ops = GetParamSecurityOps(PARAM_SECURITY_SELINUX);
|
||||
PARAM_LOGI("load selinux label %p", ops->securityGetLabel);
|
||||
if (ops != NULL && ops->securityGetLabel != NULL) {
|
||||
ops->securityGetLabel(NULL);
|
||||
}
|
||||
|
@ -348,7 +348,7 @@ INIT_LOCAL_API int CheckParameterSet(const char *name,
|
||||
}
|
||||
#if !(defined __LITEOS_A__ || defined __LITEOS_M__)
|
||||
// do hook cmd
|
||||
PARAM_LOGV("CheckParameterSet realKey %s cmd: '%s' value: %s",
|
||||
PARAM_LOGV("Check parameter settings realKey %s cmd: '%s' value: %s",
|
||||
serviceInfo->realKey, serviceInfo->cmdName, (char *)serviceInfo->realKey + serviceInfo->valueOffset);
|
||||
DoCmdByName(serviceInfo->cmdName, (char *)serviceInfo->realKey + serviceInfo->valueOffset);
|
||||
#endif
|
||||
|
@ -185,7 +185,6 @@ INIT_LOCAL_API int WritePersistParam(const char *name, const char *value)
|
||||
// for linux, start timer after set persist parameter
|
||||
// for liteos-a, start timer in init to check and save parameter
|
||||
#ifdef PARAM_SUPPORT_REAL_CHECK
|
||||
PARAM_LOGI("WritePersistParam start check ");
|
||||
if (!PARAM_TEST_FLAG(g_persistWorkSpace.flags, WORKSPACE_FLAGS_LOADED)) {
|
||||
PARAM_LOGE("Can not save persist param before load %s ", name);
|
||||
return 0;
|
||||
|
@ -46,14 +46,14 @@ static int CommonDealFun(const char *name, const char *value, int res)
|
||||
{
|
||||
int ret = 0;
|
||||
if (res == 0) {
|
||||
PARAM_LOGI("Add param from cmdline %s %s", name, value);
|
||||
PARAM_LOGV("Add param from cmdline %s %s", name, value);
|
||||
ret = CheckParamName(name, 0);
|
||||
PARAM_CHECK(ret == 0, return ret, "Invalid name %s", name);
|
||||
PARAM_LOGV("**** name %s, value %s", name, value);
|
||||
PARAM_CHECK(ret == 0, return ret, "Invalid param name %s", name);
|
||||
PARAM_LOGV("Param name %s, value %s", name, value);
|
||||
ret = WriteParam(name, value, NULL, 0);
|
||||
PARAM_CHECK(ret == 0, return ret, "Failed to write param %s %s", name, value);
|
||||
} else {
|
||||
PARAM_LOGE("Can not find arrt %s", name);
|
||||
PARAM_LOGE("Get %s parameter value is null.", name);
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
@ -182,7 +182,7 @@ static int LoadDefaultParam_(const char *fileName, uint32_t mode,
|
||||
}
|
||||
(void)fclose(fp);
|
||||
free(buffer);
|
||||
PARAM_LOGI("Load parameters success %s total %u", fileName, paramNum);
|
||||
PARAM_LOGV("Load %u default parameters success from %s.", paramNum, fileName);
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -201,7 +201,7 @@ int LoadParamsFile(const char *fileName, bool onlyAdd)
|
||||
int LoadDefaultParams(const char *fileName, uint32_t mode)
|
||||
{
|
||||
PARAM_CHECK(fileName != NULL, return -1, "Invalid filename for load");
|
||||
PARAM_LOGI("load default parameters %s.", fileName);
|
||||
PARAM_LOGI("Load default parameters from %s.", fileName);
|
||||
struct stat st;
|
||||
if ((stat(fileName, &st) == 0) && !S_ISDIR(st.st_mode)) {
|
||||
(void)ProcessParamFile(fileName, &mode);
|
||||
|
@ -32,7 +32,7 @@ static TriggerWorkSpace g_triggerWorkSpace = {};
|
||||
static int DoTriggerExecute_(const TriggerNode *trigger, const char *content, uint32_t size)
|
||||
{
|
||||
PARAM_CHECK(trigger != NULL, return -1, "Invalid trigger");
|
||||
PARAM_LOGI("DoTriggerExecute_ trigger %s type: %d", GetTriggerName(trigger), trigger->type);
|
||||
PARAM_LOGV("Do execute trigger %s type: %d", GetTriggerName(trigger), trigger->type);
|
||||
PARAM_CHECK(trigger->type <= TRIGGER_UNKNOW, return -1, "Invalid trigger type %d", trigger->type);
|
||||
CommandNode *cmd = GetNextCmdNode((JobNode *)trigger, NULL);
|
||||
while (cmd != NULL) {
|
||||
@ -53,7 +53,7 @@ static int DoTriggerCheckResult(TriggerNode *trigger, const char *content, uint3
|
||||
return 0;
|
||||
}
|
||||
TRIGGER_SET_FLAG(trigger, TRIGGER_FLAGS_QUEUE);
|
||||
PARAM_LOGI("Add trigger %s to execute queue", GetTriggerName(trigger));
|
||||
PARAM_LOGV("Add trigger %s to execute queue", GetTriggerName(trigger));
|
||||
ExecuteQueuePush(&g_triggerWorkSpace, trigger);
|
||||
return 0;
|
||||
}
|
||||
@ -368,11 +368,11 @@ void DoTriggerExec(const char *triggerName)
|
||||
PARAM_CHECK(triggerName != NULL, return, "Invalid param");
|
||||
JobNode *trigger = GetTriggerByName(&g_triggerWorkSpace, triggerName);
|
||||
if (trigger != NULL && !TRIGGER_IN_QUEUE((TriggerNode *)trigger)) {
|
||||
PARAM_LOGI("DoTriggerExec trigger %s", trigger->name);
|
||||
PARAM_LOGV("Trigger job %s", trigger->name);
|
||||
TRIGGER_SET_FLAG((TriggerNode *)trigger, TRIGGER_FLAGS_QUEUE);
|
||||
ExecuteQueuePush(&g_triggerWorkSpace, (TriggerNode *)trigger);
|
||||
} else {
|
||||
PARAM_LOGE("Can not find trigger %s", triggerName);
|
||||
PARAM_LOGW("Can not find trigger %s", triggerName);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -511,8 +511,8 @@ int InUpdaterMode(void)
|
||||
#ifdef OHOS_LITE
|
||||
return 0;
|
||||
#else
|
||||
const char * const updaterExecutabeFile = "/bin/updater";
|
||||
if (access(updaterExecutabeFile, X_OK) == 0) {
|
||||
const char * const updaterExecutableFile = "/bin/updater";
|
||||
if (access(updaterExecutableFile, X_OK) == 0) {
|
||||
return 1;
|
||||
} else {
|
||||
return 0;
|
||||
|
@ -243,7 +243,7 @@ void ParseUeventMessage(const char *buffer, ssize_t length, struct Uevent *ueven
|
||||
return;
|
||||
}
|
||||
|
||||
// reset parititon number, major and minor.
|
||||
// reset partititon number, major and minor.
|
||||
uevent->partitionNum = -1;
|
||||
uevent->major = -1;
|
||||
uevent->minor = -1;
|
||||
|
@ -74,9 +74,7 @@ static void CreateSymbolLinks(const char *deviceNode, char **symLinks)
|
||||
errno = 0;
|
||||
int rc = symlink(deviceNode, linkName);
|
||||
if (rc != 0) {
|
||||
if (errno == EEXIST) {
|
||||
INIT_LOGW("Link \" %s \" already linked to other target", linkName);
|
||||
} else {
|
||||
if (errno != EEXIST) {
|
||||
INIT_LOGE("Failed to link \" %s \" to \" %s \", err = %d", deviceNode, linkName, errno);
|
||||
}
|
||||
}
|
||||
|
@ -68,7 +68,7 @@ int main(int argc, char **argv)
|
||||
return -1;
|
||||
}
|
||||
if (access(UEVENTD_FLAG, F_OK)) {
|
||||
INIT_LOGI("ueventd first start to trigger");
|
||||
INIT_LOGI("Ueventd started, trigger uevent");
|
||||
RetriggerUevent(ueventSockFd, NULL, 0); // Not require boot devices
|
||||
int fd = open(UEVENTD_FLAG, O_RDWR | O_CREAT, S_IRUSR | S_IWUSR);
|
||||
if (fd < 0) {
|
||||
|
@ -311,7 +311,7 @@ bool IsMatch(const char *target, const char *pattern)
|
||||
}
|
||||
|
||||
if (*p == '\0') {
|
||||
return !reMatch ? false : true;
|
||||
return reMatch;
|
||||
}
|
||||
|
||||
if (*p == '*') {
|
||||
@ -335,7 +335,7 @@ bool IsMatch(const char *target, const char *pattern)
|
||||
while (*p == '*') {
|
||||
p++;
|
||||
}
|
||||
return (*p == '\0') ? true : false;
|
||||
return (*p == '\0');
|
||||
}
|
||||
|
||||
struct DeviceUdevConf *GetDeviceUdevConfByDevNode(const char *devNode)
|
||||
|
@ -76,7 +76,7 @@ int main(int argc, const char *argv[])
|
||||
}
|
||||
gap = (gap > 0) ? gap : DEFAULT_GAP;
|
||||
|
||||
INIT_LOGI("watchdoge started (interval %d, margin %d), fd = %d\n", interval, gap, fd);
|
||||
INIT_LOGI("Watchdog started (interval %d, margin %d), fd = %d\n", interval, gap, fd);
|
||||
#ifdef OHOS_LITE_WATCHDOG
|
||||
#ifndef LINUX_WATCHDOG
|
||||
if (setpriority(PRIO_PROCESS, 0, 14) != 0) { // 14 is process priority
|
||||
|
Loading…
Reference in New Issue
Block a user