Match-id-737d601f866e7f67e6759de16b6f5541d2d1ded4

cli/src/basic.h

@@ -19,6 +19,12 @@
 #define MAX_DEVICE_NR         1024
 #define MAX_MOUNT_NR          512
 
+#define LEVEL_INFO     0
+#define LEVEL_WARN     1
+#define LEVEL_ERROR     2
+#define LEVEL_DEBUG     3
+
+
 #define LOG_ERROR(fmt, ...)                                           \
     do {                                                              \
         char _content[BUF_SIZE] = {0};                                \

cli/src/cgrp.c

@@ -3,7 +3,7 @@
  * Description: ascend-docker-cli工具容器CGroup配置模块
 */
 #include "cgrp.h"
-
+#include "basic.h"
 #include <stdio.h>
 #include <limits.h>
 #include <stdlib.h>
@@ -74,13 +74,17 @@ int ParseFileByLine(char* buffer, int bufferSize, const ParseFileLine fn, const
     char resolvedPath[PATH_MAX] = {0x0};
 
     if (realpath(filepath, resolvedPath) == NULL && errno != ENOENT) {
-        Logger(FormatMessage("cannot canonicalize path %s.", filepath), 2);
+        int iLength = 0;
+        char* str = FormatLogMessage("cannot canonicalize path %s.", &iLength, filepath);
+        Logger(str, LEVEL_ERROR, iLength);
+        free(str);
         return -1;
     }
 
     fp = fopen(resolvedPath, "r");
     if (fp == NULL) {
-        Logger("cannot open file.", 2);
+        char msg[] = "cannot open file.";
+        Logger(msg, LEVEL_ERROR, sizeof(msg)/sizeof(char));
         return -1;
     }
 
@@ -158,20 +162,27 @@ int SetupDeviceCgroup(FILE *cgroupAllow, const char *devName)
 
     ret = sprintf_s(devPath, BUF_SIZE, "/dev/%s", devName);
     if (ret < 0) {
-        Logger(FormatMessage("failed to assemble dev path for %s.", devName), 2);
+        int iLength = 0;
+        char* str = FormatLogMessage("failed to assemble dev path for %s.", &iLength, devName);
+        Logger(str, LEVEL_ERROR, iLength);
+        free(str);
         return -1;
     }
 
     ret = stat((const char *)devPath, &devStat);
     if (ret < 0) {
-        Logger(FormatMessage("failed to get stat of %s.", devPath), 2);
+        int iLength = 0;
+        char* str = FormatLogMessage("failed to get stat of %s.", &iLength, devPath);
+        Logger(str, LEVEL_ERROR, iLength);
+        free(str);
         return -1;
     }
 
     bool isFailed = fprintf(cgroupAllow, "c %u:%u rw", major(devStat.st_rdev), minor(devStat.st_rdev)) < 0 ||
                     fflush(cgroupAllow) == EOF || ferror(cgroupAllow) < 0;
     if (isFailed) {
-        Logger("write devices failed.", 2);
+        char msg[] = "write devices failed.";
+        Logger(msg, LEVEL_ERROR, sizeof(msg)/sizeof(char));
         return -1;
     }
 
@@ -184,19 +195,28 @@ int SetupDriverCgroup(FILE *cgroupAllow)
 
     ret = SetupDeviceCgroup(cgroupAllow, DAVINCI_MANAGER);
     if (ret < 0) {
-        Logger(FormatMessage("failed to setup cgroup for %s.", DAVINCI_MANAGER), 2);
+        int iLength = 0;
+        char* str = FormatLogMessage("failed to setup cgroup for %s.", &iLength, DAVINCI_MANAGER);
+        Logger(str, LEVEL_ERROR, iLength);
+        free(str);
         return -1;
     }
 
     ret = SetupDeviceCgroup(cgroupAllow, DEVMM_SVM);
     if (ret < 0) {
-        Logger(FormatMessage("failed to setup cgroup for %s.", DEVMM_SVM), 2);
+        int iLength = 0;
+        char* str = FormatLogMessage("failed to setup cgroup for %s.", &iLength, DEVMM_SVM);
+        Logger(str, LEVEL_ERROR, iLength);
+        free(str);
         return -1;
     }
 
     ret = SetupDeviceCgroup(cgroupAllow, HISI_HDC);
     if (ret < 0) {
-        Logger(FormatMessage("failed to setup cgroup for %s.", HISI_HDC), 2);
+        int iLength = 0;
+        char* str = FormatLogMessage("failed to setup cgroup for %s.", &iLength, HISI_HDC);
+        Logger(str, LEVEL_ERROR, iLength);
+        free(str);
         return -1;
     }
 
@@ -211,13 +231,17 @@ int GetCgroupPath(int pid, char *effPath, size_t maxSize)
 
     ret = sprintf_s(mountPath, BUF_SIZE, "/proc/%d/mountinfo", (int)getppid());
     if (ret < 0) {
-        Logger(FormatMessage("assemble mount info path failed: ppid(%d).", getppid()), 2);
+        int iLength = 0;
+        char* str = FormatLogMessage("assemble mount info path failed: ppid(%d).", &iLength, getppid());
+        Logger(str, LEVEL_ERROR, iLength);
+        free(str);
         return -1;
     }
 
     ret = ParseFileByLine(mount, BUF_SIZE, GetCgroupMount, mountPath);
     if (ret < 0) {
-        Logger("cat file content failed.", 2);
+        char msg[] = "cat file content failed.";
+        Logger(msg, LEVEL_ERROR, sizeof(msg)/sizeof(char));
         return -1;
     }
 
@@ -225,13 +249,17 @@ int GetCgroupPath(int pid, char *effPath, size_t maxSize)
     char cgroupPath[BUF_SIZE] = {0x0};
     ret = sprintf_s(cgroupPath, BUF_SIZE, "/proc/%d/cgroup", pid);
     if (ret < 0) {
-        Logger(FormatMessage("assemble cgroup path failed: pid(%d).", pid), 2);
+        int iLength = 0;
+        char* str = FormatLogMessage("assemble cgroup path failed: pid(%d).", &iLength, pid);
+        Logger(str, LEVEL_ERROR, iLength);
+        free(str);
         return -1;
     }
 
     ret = ParseFileByLine(cgroup, BUF_SIZE, GetCgroupRoot, cgroupPath);
     if (ret < 0) {
-        Logger("cat file content failed.", 2);
+        char msg[] = "cat file content failed.";
+        Logger(msg, LEVEL_ERROR, sizeof(msg)/sizeof(char));
         return -1;
     }
 
@@ -240,7 +268,8 @@ int GetCgroupPath(int pid, char *effPath, size_t maxSize)
 
     ret = sprintf_s(effPath, maxSize, "%s%s%s", mount, cgroup, ALLOW_PATH);
     if (ret < 0) {
-        Logger("assemble cgroup device path failed.", 2);
+        char msg[] = "assemble cgroup device path failed.";
+        Logger(msg, LEVEL_ERROR, sizeof(msg)/sizeof(char));
         return -1;
     }
 
@@ -255,20 +284,27 @@ int SetupCgroup(const struct ParsedConfig *config)
     FILE *cgroupAllow = NULL;
 
     if (realpath(config->cgroupPath, resolvedCgroupPath) == NULL && errno != ENOENT) {
-        Logger(FormatMessage("cannot canonicalize cgroup path: %s.", config->cgroupPath), 2);
+        int iLength = 0;
+        char* str = FormatLogMessage("cannot canonicalize cgroup path: %s.", &iLength, config->cgroupPath);
+        Logger(str, LEVEL_ERROR, iLength);
+        free(str);
         return -1;
     }
 
     cgroupAllow = fopen((const char *)resolvedCgroupPath, "a");
     if (cgroupAllow == NULL) {
-        Logger(FormatMessage("failed to open cgroup file: %s.", resolvedCgroupPath), 2);
+        int iLength = 0;
+        char* str = FormatLogMessage("failed to open cgroup file: %s.", &iLength, resolvedCgroupPath);
+        Logger(str, LEVEL_ERROR, iLength);
+        free(str);
         return -1;
     }
 
     ret = SetupDriverCgroup(cgroupAllow);
     if (ret < 0) {
         fclose(cgroupAllow);
-        Logger("failed to setup driver cgroup.", 2);
+        char msg[] = "failed to setup driver cgroup.";
+        Logger(msg, LEVEL_ERROR, sizeof(msg)/sizeof(char));
         return -1;
     }
 
@@ -278,14 +314,20 @@ int SetupCgroup(const struct ParsedConfig *config)
             config->devices[idx]);
         if (ret < 0) {
             fclose(cgroupAllow);
-            Logger(FormatMessage("failed to assemble device path for no.%u.", config->devices[idx]), 2);
+            int iLength = 0;
+            char* str = FormatLogMessage("failed to assemble device path for no.%u.", &iLength, config->devices[idx]);
+            Logger(str, LEVEL_ERROR, iLength);
+            free(str);
             return -1;
         }
 
         ret = SetupDeviceCgroup(cgroupAllow, (const char *)deviceName);
         if (ret < 0) {
             fclose(cgroupAllow);
-            Logger(FormatMessage("failed to setup cgroup for %s.", deviceName), 2);
+            int iLength = 0;
+            char* str = FormatLogMessage("failed to setup cgroup for %s.", &iLength, deviceName);
+            Logger(str, LEVEL_ERROR, iLength);
+            free(str);
             return -1;
         }
     }

cli/src/logger.c

@@ -10,20 +10,16 @@
 
 #define FILE_MAX_SIZE (1024*1024*10)
 #define LOG_PATH_DIR "/var/log/"
+#define TEMP_BUFFER 30
 
-void GetCurrentLocalTime(char* buffer)
+void GetCurrentLocalTime(char* buffer, int length)
 {
     time_t rawtime;
-    struct tm* timeinfo;
+    struct tm* timeinfo = NULL;
     time(&rawtime);
     timeinfo = localtime(&rawtime);
-    sprintf(buffer, "[%04d-%02d-%02d %02d:%02d:%02d]",
+    sprintf_s(buffer, TEMP_BUFFER, "[%04d-%02d-%02d %02d:%02d:%02d]", (timeinfo->tm_year+1900), (timeinfo->tm_mon+1),
-    (timeinfo->tm_year+1900), 
+    (timeinfo->tm_mday), (timeinfo->tm_hour), (timeinfo->tm_min), (timeinfo->tm_sec));
-    (timeinfo->tm_mon+1), 
-    (timeinfo->tm_mday),
-    (timeinfo->tm_hour), 
-    (timeinfo->tm_min), 
-    (timeinfo->tm_sec));
 }
 
 long GetLogSize(char* filename)
@@ -69,9 +65,8 @@ void WriteLogFile(char* filename, long maxSize, char* buffer, unsigned bufferSiz
         fp = fopen(filename, "a+");
         if (fp != NULL)
         {
-            char now[21];
+            char now[TEMP_BUFFER] = {0};
-            memset(now, 0, sizeof(now));
+            GetCurrentLocalTime(now, sizeof(now)/sizeof(now[0]));
-            GetCurrentLocalTime(now);
             fwrite(now, strlen(now), 1, fp);
             fwrite(buffer, bufferSize, 1, fp);
             fclose(fp);
@@ -80,13 +75,12 @@ void WriteLogFile(char* filename, long maxSize, char* buffer, unsigned bufferSiz
     }
 }
 
-void Logger(const char *msg, int level) {
+void Logger(const char *msg, int level, int length) {
     enum LEVEL { Info=0,  Warn, Error, Debug};
     enum LEVEL _level;
     char *logPath = LOG_PATH_DIR"docker-runtime-log.log";
     _level = level;
-    char buffer[strlen(msg)+20];
+    char* buffer = malloc(length+20);
-    memset(buffer, 0, sizeof(buffer));
     switch (_level) 
     {
         case Debug:sprintf(buffer, "[Debug]%s\n", msg);
@@ -98,4 +92,5 @@ void Logger(const char *msg, int level) {
         default:sprintf(buffer, "[Info]%s\n", msg);
     }
     WriteLogFile(logPath, FILE_MAX_SIZE, buffer, strlen(buffer));
+    free(buffer);
 }

cli/src/logger.h

@@ -6,6 +6,6 @@
 #ifndef _LOGGER_H
 #define _LOGGER_H
 
-void Logger(const char *msg, int level);
+void Logger(const char *msg, int level, int length);
 
 #endif

cli/src/main.c

@@ -49,7 +49,8 @@ static bool DevicesCmdArgParser(struct CmdArgs *args, const char *arg)
 {
     errno_t err = strcpy_s(args->devices, BUF_SIZE, arg);
     if (err != EOK) {
-        Logger("failed to get devices from cmd args.", 2);
+        char msg[] = "failed to get devices from cmd args.";
+        Logger(msg, LEVEL_ERROR, sizeof(msg)/sizeof(char));
         return false;
     }
 
@@ -61,12 +62,18 @@ static bool PidCmdArgParser(struct CmdArgs *args, const char *arg)
     errno = 0;
     args->pid = strtol(optarg, NULL, DECIMAL);
     if (errno != 0) {
-        Logger(FormatMessage("failed to convert pid string from cmd args, pid string: %s.", arg), 2);
+        int iLength = 0;
+        char* str = FormatLogMessage("failed to convert pid string from cmd args, pid string: %s.", &iLength, arg);
+        Logger(str, LEVEL_ERROR, iLength);
+        free(str);
         return false;
     }
 
     if (args->pid <= 0) {
-        Logger(FormatMessage("invalid pid %d.", args->pid), 2);
+        int iLength = 0;
+        char* str = FormatLogMessage("invalid pid %d.", &iLength, args->pid);
+        Logger(str, LEVEL_ERROR, iLength);
+        free(str);
         return false;
     }
 
@@ -77,7 +84,8 @@ static bool RootfsCmdArgParser(struct CmdArgs *args, const char *arg)
 {
     errno_t err = strcpy_s(args->rootfs, BUF_SIZE, arg);
     if (err != EOK) {
-        Logger("failed to get rootfs path from cmd args", 2);
+        char msg[] = "failed to get rootfs path from cmd args";
+        Logger(msg, LEVEL_ERROR, sizeof(msg)/sizeof(char));
         return false;
     }
 
@@ -88,7 +96,8 @@ static bool OptionsCmdArgParser(struct CmdArgs *args, const char *arg)
 {
     errno_t err = strcpy_s(args->options, BUF_SIZE, arg);
     if (err != EOK) {
-        Logger("failed to get options string from cmd args", 2);
+        char msg[] = "failed to get options string from cmd args";
+        Logger(msg, LEVEL_ERROR, sizeof(msg)/sizeof(char));
         return false;
     }
 
@@ -98,14 +107,20 @@ static bool OptionsCmdArgParser(struct CmdArgs *args, const char *arg)
 static bool MountFileCmdArgParser(struct CmdArgs *args, const char *arg)
 {
     if (args->files.count == MAX_MOUNT_NR) {
-        Logger(FormatMessage("too many files to mount, max number is %u", MAX_MOUNT_NR), 2);
+        int iLength = 0;
+        char* str = FormatLogMessage("too many files to mount, max number is %u", &iLength, MAX_MOUNT_NR);
+        Logger(str, LEVEL_ERROR, iLength);
+        free(str);
         return -1;
     }
 
     char *dst = &args->files.list[args->files.count++][0];
     errno_t err = strcpy_s(dst, PATH_MAX, arg);
     if (err != EOK) {
-        Logger(FormatMessage("failed to copy mount file path: %s", arg), 2);
+        int iLength = 0;
+        char* str = FormatLogMessage("failed to copy mount file path: %s", &iLength, arg);
+        Logger(str, LEVEL_ERROR, iLength);
+        free(str);
         return false;
     }
 
@@ -115,14 +130,20 @@ static bool MountFileCmdArgParser(struct CmdArgs *args, const char *arg)
 static bool MountDirCmdArgParser(struct CmdArgs *args, const char *arg)
 {
     if (args->dirs.count == MAX_MOUNT_NR) {
-        Logger(FormatMessage("too many directories to mount, max number is %u", MAX_MOUNT_NR), 2);
+        int iLength = 0;
+        char* str = FormatLogMessage("too many directories to mount, max number is %u", &iLength, MAX_MOUNT_NR);
+        Logger(str, LEVEL_ERROR, iLength);
+        free(str);
         return -1;
     }
 
     char *dst = &args->dirs.list[args->dirs.count++][0];
     errno_t  err = strcpy_s(dst, PATH_MAX, arg);
     if (err != EOK) {
-        Logger(FormatMessage("error: failed to copy mount directory path: %s", arg), 2);
+        int iLength = 0;
+        char* str = FormatLogMessage("error: failed to copy mount directory path: %s", &iLength, arg);
+        Logger(str, LEVEL_ERROR, iLength);
+        free(str);
         return false;
     }
 
@@ -153,12 +174,18 @@ static int ParseOneCmdArg(struct CmdArgs *args, char indicator, const char *valu
     }
 
     if (i == NUM_OF_CMD_ARGS) {
-        Logger(FormatMessage("unrecognized cmd arg: indicate char: %c, value: %s.", indicator, value), 2);
+        int iLength = 0;
+        char* str = FormatLogMessage("unrecognized cmd arg: indicate char: %c, value: %s.", &iLength, indicator, value);
+        Logger(str, LEVEL_ERROR, iLength);
+        free(str);
         return -1;
     }
     bool isOK = g_cmdArgParsers[i].parser(args, value);
     if (!isOK) {
-        Logger(FormatMessage("failed while parsing cmd arg, indicate char: %c, value: %s.", indicator, value), 2);
+        int iLength = 0;
+        char* str = FormatLogMessage("failed while parsing cmd arg, indicate char: %c, value: %s.", &iLength, indicator, value);
+        Logger(str, LEVEL_ERROR, iLength);
+        free(str);
         return -1;
     }
     return 0;
@@ -179,14 +206,20 @@ static int ParseDeviceIDs(unsigned int *idList, size_t *idListSize, char *device
     token = strtok_s(devices, sep, &context);
     while (token != NULL) {
         if (idx >= *idListSize) {
-            Logger(FormatMessage("too many devices(%u), support %u devices maximally", idx, *idListSize), 2);
+            int iLength = 0;
+            char* str = FormatLogMessage("too many devices(%u), support %u devices maximally", &iLength, idx, *idListSize);
+            Logger(str, LEVEL_ERROR, iLength);
+            free(str);
             return -1;
         }
 
         errno = 0;
         idList[idx] = strtoul((const char *)token, NULL, DECIMAL);
         if (errno != 0) {
-            Logger(FormatMessage("failed to convert device id (%s) from cmd args", token), 2);
+            int iLength = 0;
+            char* str = FormatLogMessage("failed to convert device id (%s) from cmd args", &iLength, token);
+            Logger(str, LEVEL_ERROR, iLength);
+            free(str);
             return -1;
         }
 
@@ -205,38 +238,48 @@ int DoPrepare(const struct CmdArgs *args, struct ParsedConfig *config)
 
     err = strcpy_s(config->rootfs, BUF_SIZE, args->rootfs);
     if (err != EOK) {
-        Logger("failed to copy rootfs path to parsed config.", 2);
+        char msg[] = "failed to copy rootfs path to parsed config.";
+        Logger(msg, LEVEL_ERROR, sizeof(msg)/sizeof(char));
         return -1;
     }
 
     ret = ParseDeviceIDs(config->devices, &config->devicesNr, (char *)args->devices);
     if (ret < 0) {
-        Logger("failed to parse device ids from cmdline argument", 2);
+        char msg[] = "failed to parse device ids from cmdline argument";
+        Logger(msg, LEVEL_ERROR, sizeof(msg)/sizeof(char));
         return -1;
     }
 
     ret = GetNsPath(args->pid, "mnt", config->containerNsPath, BUF_SIZE);
     if (ret < 0) {
-        Logger(FormatMessage("failed to get container mnt ns path: pid(%d).", args->pid), 2);
+        int iLength = 0;
+        char* str = FormatLogMessage("failed to get container mnt ns path: pid(%d).", &iLength, args->pid);
+        Logger(str, LEVEL_ERROR, iLength);
+        free(str);
         return -1;
     }
 
     ret = GetCgroupPath(args->pid, config->cgroupPath, BUF_SIZE);
     if (ret < 0) {
-        Logger("failed to get cgroup path.", 2);
+        char msg[] = "failed to get cgroup path.";
+        Logger(msg, LEVEL_ERROR, sizeof(msg)/sizeof(char));
         return -1;
     }
 
     char originNsPath[BUF_SIZE] = {0};
     ret = GetSelfNsPath("mnt", originNsPath, BUF_SIZE);
     if (ret < 0) {
-        Logger("failed to get self ns path.", 2);
+        char msg[] = "failed to get self ns path.";
+        Logger(msg, LEVEL_ERROR, sizeof(msg)/sizeof(char));
         return -1;
     }
 
     config->originNsFd = open((const char *)originNsPath, O_RDONLY); // proc接口，非外部输入
     if (config->originNsFd < 0) {
-        Logger(FormatMessage("failed to get self ns fd: %s.", originNsPath), 2);
+        int iLength = 0;
+        char* str = FormatLogMessage("failed to get self ns fd: %s.", &iLength, originNsPath);
+        Logger(str, LEVEL_ERROR, iLength);
+        free(str);
         return -1;
     }
 
@@ -255,28 +298,34 @@ int SetupContainer(struct CmdArgs *args)
 
     ret = DoPrepare(args, &config);
     if (ret < 0) {
-        Logger("failed to prepare nesessary config.", 2);
+        char msg[] = "failed to prepare nesessary config.";
+        Logger(msg, LEVEL_ERROR, sizeof(msg)/sizeof(char));
         return -1;
     }
 
     // enter container's mount namespace
     ret = EnterNsByPath((const char *)config.containerNsPath, CLONE_NEWNS);
     if (ret < 0) {
-        Logger(FormatMessage("failed to set to container ns: %s.", config.containerNsPath), 2);
+        int iLength = 0;
+        char* str = FormatLogMessage("failed to set to container ns: %s.", &iLength, config.containerNsPath);
+        Logger(str, LEVEL_ERROR, iLength);
+        free(str);
         close(config.originNsFd);
         return -1;
     }
 
     ret = DoMounting(&config);
     if (ret < 0) {
-        Logger("failed to do mounting.", 2);
+        char msg[] = "failed to do mounting.";
+        Logger(msg, LEVEL_ERROR, sizeof(msg)/sizeof(char));
         close(config.originNsFd);
         return -1;
     }
 
     ret = SetupCgroup(&config);
     if (ret < 0) {
-        Logger("failed to set up cgroup.", 2);
+        char msg[] = "failed to set up cgroup.";
+        Logger(msg, LEVEL_ERROR, sizeof(msg)/sizeof(char));
         close(config.originNsFd);
         return -1;
     }
@@ -284,7 +333,8 @@ int SetupContainer(struct CmdArgs *args)
     // back to original namespace
     ret = EnterNsByFd(config.originNsFd, CLONE_NEWNS);
     if (ret < 0) {
-        Logger("failed to set ns back.", 2);
+        char msg[] = "failed to set ns back.";
+        Logger(msg, LEVEL_ERROR, sizeof(msg)/sizeof(char));
         close(config.originNsFd);
         return -1;
     }
@@ -300,28 +350,35 @@ int Process(int argc, char **argv)
     int optionIndex;
     struct CmdArgs args = {0};
 
-    Logger("runc start prestart-hook ...", 0);
+    char startMsg[] = "runc start prestart-hook ...";
+    Logger(startMsg, LEVEL_INFO, sizeof(startMsg)/sizeof(char));
     while ((c = getopt_long(argc, argv, "d:p:r:o:f:i", g_cmdOpts, &optionIndex)) != -1) {
         ret = ParseOneCmdArg(&args, (char)c, optarg);
         if (ret < 0) {
-            Logger("failed to parse cmd args.", 2);
+            char msg[] = "failed to parse cmd args.";
+            Logger(msg, LEVEL_ERROR, sizeof(msg)/sizeof(char));
             return -1;
         }
     }
-    Logger("verify parameters valid and parse runtime options", 0);
+    char parametersMsg[] = "verify parameters valid and parse runtime options";
+    Logger(parametersMsg, LEVEL_INFO, sizeof(parametersMsg)/sizeof(char));
     if (!IsCmdArgsValid(&args)) {
-        Logger("information not completed or valid.", 2);
+        char msg[] = "information not completed or valid.";
+        Logger(msg, LEVEL_ERROR, sizeof(msg)/sizeof(char));
         return -1;
     }
 
     ParseRuntimeOptions(args.options);
-    Logger("setup container config", 0);
+    char containerMsg[] = "setup container config";
+    Logger(containerMsg, LEVEL_INFO, sizeof(containerMsg)/sizeof(char));
     ret = SetupContainer(&args);
     if (ret < 0) {
-        Logger("failed to setup container.", 2);
+        char msg[] = "failed to setup container.";
+        Logger(msg, LEVEL_ERROR, sizeof(msg)/sizeof(char));
         return ret;
     }
-    Logger("prestart-hook setup container successful.", 0);
+    char successMsg[] = "prestart-hook setup container successful.";
+    Logger(successMsg, LEVEL_INFO, sizeof(successMsg)/sizeof(char));
     return 0;
 }
 

cli/src/ns.c

@@ -29,7 +29,10 @@ int EnterNsByFd(int fd, int nsType)
 {
     int ret = setns(fd, nsType);
     if (ret < 0) {
-        Logger(FormatMessage("failed to set ns: fd(%d).", fd), 2);
+        int iLength = 0;
+        char* str = FormatLogMessage("failed to set ns: fd(%d).", &iLength, fd);
+        Logger(str, LEVEL_ERROR, iLength);
+        free(str);
         return -1;
     }
 
@@ -43,13 +46,19 @@ int EnterNsByPath(const char *path, int nsType)
 
     fd = open(path, O_RDONLY); // proc文件接口，非外部输入
     if (fd < 0) {
-        Logger(FormatMessage("failed to open ns path: %s.", path), 2);
+        int iLength = 0;
+        char* str = FormatLogMessage("failed to open ns path: %s.", &iLength, path);
+        Logger(str, LEVEL_ERROR, iLength);
+        free(str);
         return -1;
     }
 
     ret = EnterNsByFd(fd, nsType);
     if (ret < 0) {
-        Logger(FormatMessage("failed to set ns: %s.", path), 2);
+        int iLength = 0;
+        char* str = FormatLogMessage("failed to set ns: %s.", &iLength, path);
+        Logger(str, LEVEL_ERROR, iLength);
+        free(str);
         close(fd);
         return -1;
     }

cli/src/u_mount.c

@@ -24,13 +24,15 @@ int Mount(const char *src, const char *dst)
 
     ret = mount(src, dst, NULL, mountFlags, NULL);
     if (ret < 0) {
-        Logger("failed to mount.", 2);
+        char msg[] = "failed to mount.";
+        Logger(msg, LEVEL_ERROR, sizeof(msg)/sizeof(char));
         return -1;
     }
 
     ret = mount(NULL, dst, NULL, remountFlags, NULL);
     if (ret < 0) {
-        Logger("failed to re-mount.", 2);
+        char msg[] = "failed to re-mount.";
+        Logger(msg, LEVEL_ERROR, sizeof(msg)/sizeof(char));
         return -1;
     }
 
@@ -66,7 +68,10 @@ static int GetDeviceMntSrcDst(const char *rootfs, const char *srcDeviceName,
     }
 
     if (realpath(unresolvedDst, resolvedDst) == NULL && errno != ENOENT) {
-        Logger(FormatMessage("cannot canonicalize device dst: %s.", dst), 2);
+        int iLength = 0;
+        char* str = FormatLogMessage("cannot canonicalize device dst: %s.", &iLength, dst);
+        Logger(str, LEVEL_ERROR, iLength);
+        free(str);
         return -1;
     }
 
@@ -78,7 +83,10 @@ static int GetDeviceMntSrcDst(const char *rootfs, const char *srcDeviceName,
     } else {
         err = strcpy_s(dst, dstBufSize, resolvedDst);
         if (err != EOK) {
-            Logger(FormatMessage("failed to copy resolved device mnt path to dst: %s.", resolvedDst), 2);
+            int iLength = 0;
+            char* str = FormatLogMessage("failed to copy resolved device mnt path to dst: %s.", &iLength, resolvedDst);
+            Logger(str, LEVEL_ERROR, iLength);
+            free(str);
             return -1;
         }
     }
@@ -95,14 +103,20 @@ int MountDevice(const char *rootfs, const char *srcDeviceName, const char *dstDe
 
     ret = GetDeviceMntSrcDst(rootfs, srcDeviceName, dstDeviceName, &pathInfo);
     if (ret < 0) {
-        Logger(FormatMessage("failed to get device mount src and(or) dst path, device name: %s.", srcDeviceName), 2);
+        int iLength = 0;
+        char* str = FormatLogMessage("failed to get device mount src and(or) dst path, device name: %s.", &iLength, srcDeviceName);
+        Logger(str, LEVEL_ERROR, iLength);
+        free(str);
         return -1;
     }
 
     struct stat srcStat;
     ret = stat((const char *)src, &srcStat);
     if (ret < 0) {
-        Logger(FormatMessage("failed to stat src: %s.", src), 2);
+        int iLength = 0;
+        char* str = FormatLogMessage("failed to stat src: %s.", &iLength, src);
+        Logger(str, LEVEL_ERROR, iLength);
+        free(str);
         return -1;
     }
 
@@ -112,21 +126,31 @@ int MountDevice(const char *rootfs, const char *srcDeviceName, const char *dstDe
     if (ret == 0 && S_ISCHR(dstStat.st_mode)) {
         return 0; // 特权容器自动挂载HOST所有设备，故此处跳过
     } else if (ret == 0) {
-        Logger(FormatMessage("%s already exists but not a char device as expected.", dst), 2);
+        int iLength = 0;
+        char* str = FormatLogMessage("%s already exists but not a char device as expected.", &iLength, dst);
+        Logger(str, LEVEL_ERROR, iLength);
+        free(str);
         return -1;
     } else if (ret < 0 && errno != ENOENT) {
-        Logger(FormatMessage("failed to check dst %s stat", dst), 2);
+        int iLength = 0;
+        char* str = FormatLogMessage("failed to check dst %s stat", &iLength, dst);
+        Logger(str, LEVEL_ERROR, iLength);
+        free(str);
         return -1;
     }
     ret = MakeMountPoints(dst, srcStat.st_mode);
     if (ret < 0) {
-        Logger(FormatMessage("failed to create mount dst file: %s.", dst), 2);
+        int iLength = 0;
+        char* str = FormatLogMessage("failed to create mount dst file: %s.", &iLength, dst);
+        Logger(str, LEVEL_ERROR, iLength);
+        free(str);
         return -1;
     }
 
     ret = Mount(src, dst);
     if (ret < 0) {
-        Logger("failed to mount dev.", 2);
+        char msg[] = "failed to mount dev.";
+        Logger(msg, LEVEL_ERROR, sizeof(msg)/sizeof(char));
         return -1;
     }
 
@@ -142,12 +166,18 @@ int DoDeviceMounting(const char *rootfs, const char *device_name, const unsigned
         int srcRet = sprintf_s(srcDeviceName, BUF_SIZE, "%s%u", device_name, ids[idx]);
         int dstRet = sprintf_s(dstDeviceName, BUF_SIZE, "%s%u", DEVICE_NAME, ids[idx]);
         if (srcRet < 0 || dstRet < 0) {
-            Logger(FormatMessage("assemble device name failed, id: %u.", ids[idx]), 2);
+            int iLength = 0;
+            char* str = FormatLogMessage("assemble device name failed, id: %u.", &iLength, ids[idx]);
+            Logger(str, LEVEL_ERROR, iLength);
+            free(str);
             return -1;
         }
         int ret = MountDevice(rootfs, srcDeviceName, dstDeviceName);
         if (ret < 0) {
-            Logger(FormatMessage("failed to mount device %s.", srcDeviceName), 2);
+            int iLength = 0;
+            char* str = FormatLogMessage("failed to mount device %s.", &iLength, srcDeviceName);
+            Logger(str, LEVEL_ERROR, iLength);
+            free(str);
             return -1;
         }
     }
@@ -162,7 +192,10 @@ int MountFile(const char *rootfs, const char *filepath)
 
     ret = sprintf_s(dst, BUF_SIZE, "%s%s", rootfs, filepath);
     if (ret < 0) {
-        Logger(FormatMessage("failed to assemble file mounting path, file: %s.", filepath), 2);
+        int iLength = 0;
+        char* str = FormatLogMessage("failed to assemble file mounting path, file: %s.", &iLength, filepath);
+        Logger(str, LEVEL_ERROR, iLength);
+        free(str);
         return -1;
     }
 
@@ -174,13 +207,17 @@ int MountFile(const char *rootfs, const char *filepath)
 
     ret = MakeMountPoints(dst, srcStat.st_mode);
     if (ret < 0) {
-        Logger(FormatMessage("failed to create mount dst file: %s.", dst), 2);
+        int iLength = 0;
+        char* str = FormatLogMessage("failed to create mount dst file: %s.", &iLength, dst);
+        Logger(str, LEVEL_ERROR, iLength);
+        free(str);
         return -1;
     }
 
     ret = Mount(filepath, dst);
     if (ret < 0) {
-        Logger("failed to mount dev.", 2);
+        char msg[] = "failed to mount dev.";
+        Logger(msg, LEVEL_ERROR, sizeof(msg)/sizeof(char));
         return -1;
     }
 
@@ -205,13 +242,19 @@ int MountDir(const char *rootfs, const char *src)
 
     ret = MakeDirWithParent(dst, DEFAULT_DIR_MODE);
     if (ret < 0) {
-        Logger(FormatMessage("failed to make dir: %s.", dst), 2);
+        int iLength = 0;
+        char* str = FormatLogMessage("failed to make dir: %s.", &iLength, dst);
+        Logger(str, LEVEL_ERROR, iLength);
+        free(str);
         return -1;
     }
 
     ret = Mount(src, dst);
     if (ret < 0) {
-        Logger(FormatMessage("error: failed to mount dir: %s to %s.", src, dst), 2);
+        int iLength = 0;
+        char* str = FormatLogMessage("failed to mount dir: %s to %s.", &iLength, src, dst);
+        Logger(str, LEVEL_ERROR, iLength);
+        free(str);
         return -1;
     }
 
@@ -223,19 +266,28 @@ int DoCtrlDeviceMounting(const char *rootfs)
     /* device */
     int ret = MountDevice(rootfs, DAVINCI_MANAGER, NULL);
     if (ret < 0) {
-        Logger(FormatMessage("failed to mount device %s.", DAVINCI_MANAGER), 2);
+        int iLength = 0;
+        char* str = FormatLogMessage("failed to mount device %s.", &iLength, DAVINCI_MANAGER);
+        Logger(str, LEVEL_ERROR, iLength);
+        free(str);
         return -1;
     }
 
     ret = MountDevice(rootfs, DEVMM_SVM, NULL);
     if (ret < 0) {
-        Logger(FormatMessage("failed to mount device %s.", DEVMM_SVM), 2);
+        int iLength = 0;
+        char* str = FormatLogMessage("failed to mount device %s.", &iLength, DEVMM_SVM);
+        Logger(str, LEVEL_ERROR, iLength);
+        free(str);
         return -1;
     }
 
     ret = MountDevice(rootfs, HISI_HDC, NULL);
     if (ret < 0) {
-        Logger(FormatMessage("failed to mount device %s.", HISI_HDC), 2);
+        int iLength = 0;
+        char* str = FormatLogMessage("failed to mount device %s.", &iLength, HISI_HDC);
+        Logger(str, LEVEL_ERROR, iLength);
+        free(str);
         return -1;
     }
 
@@ -249,7 +301,10 @@ int DoDirectoryMounting(const char *rootfs, const struct MountList *list)
     for (unsigned int i = 0; i < list->count; i++) {
         ret = MountDir(rootfs, (const char *)&list->list[i][0]);
         if (ret < 0) {
-            Logger(FormatMessage("failed to do directory mounting for %s.", (const char *)&list->list[i][0]), 2);
+            int iLength = 0;
+            char* str = FormatLogMessage("failed to do directory mounting for %s.", &iLength, (const char *)&list->list[i][0]);
+            Logger(str, LEVEL_ERROR, iLength);
+            free(str);
             return -1;
         }
     }
@@ -264,7 +319,10 @@ int DoFileMounting(const char *rootfs, const struct MountList *list)
     for (unsigned int i = 0; i < list->count; i++) {
         ret = MountFile(rootfs, (const char *)&list->list[i][0]);
         if (ret < 0) {
-            Logger(FormatMessage("failed to do file mounting for %s.", (const char *)&list->list[i][0]), 2);
+            int iLength = 0;
+            char* str = FormatLogMessage("failed to do file mounting for %s.", &iLength, (const char *)&list->list[i][0]);
+            Logger(str, LEVEL_ERROR, iLength);
+            free(str);
             return -1;
         }
     }
@@ -279,13 +337,15 @@ int DoMounting(const struct ParsedConfig *config)
                            (IsVirtual() ? VDEVICE_NAME : DEVICE_NAME),
                            config->devices, config->devicesNr);
     if (ret < 0) {
-        Logger("failed to mount devices.", 2);
+        char msg[] = "failed to mount devices.";
+        Logger(msg, LEVEL_ERROR, sizeof(msg)/sizeof(char));
         return -1;
     }
 
     ret = DoCtrlDeviceMounting(config->rootfs);
     if (ret < 0) {
-        Logger("failed to mount ctrl devices.", 2);
+        char msg[] = "failed to mount ctrl devices.";
+        Logger(msg, LEVEL_ERROR, sizeof(msg)/sizeof(char));
         return -1;
     }
 
@@ -295,13 +355,15 @@ int DoMounting(const struct ParsedConfig *config)
 
     ret = DoFileMounting(config->rootfs, config->files);
     if (ret < 0) {
-        Logger("failed to mount files.", 2);
+        char msg[] = "failed to mount files.";
+        Logger(msg, LEVEL_ERROR, sizeof(msg)/sizeof(char));
         return -1;
     }
 
     ret = DoDirectoryMounting(config->rootfs, config->dirs);
     if (ret < 0) {
-        Logger("failed to do mount directories.", 2);
+        char msg[] = "failed to do mount directories.";
+        Logger(msg, LEVEL_ERROR, sizeof(msg)/sizeof(char));
         return -1;
     }
 

cli/src/utils.c

@@ -14,11 +14,13 @@
 #include <sys/stat.h>
 #include "securec.h"
 #include "logger.h"
-char *FormatMessage(char *format, ...){
+
+char *FormatLogMessage(char *format, int* iLength, ...){
     va_list list;
     // 获取格式化后字符串的长度
     va_start(list, format);
-    int size = vsnprintf(NULL, 0, format, list);
+    char buff[1024] = {0};
+    int size = vsnprintf_s(buff, sizeof(buff), sizeof(buff), format, list);
     va_end(list);
     if(size <= 0){
         return NULL;
@@ -27,7 +29,8 @@ char *FormatMessage(char *format, ...){
     // 复位va_list, 将格式化字符串写入到buf
     va_start(list, format);
     char *buf = (char *)malloc(size);
-    vsnprintf(buf, size, format, list);
+    *iLength = size;
+    vsnprintf_s(buf, size, size, format, list);
     va_end(list);
     return buf;
 }
@@ -117,19 +120,28 @@ int MakeMountPoints(const char *path, mode_t mode)
 
     int ret = MakeDirWithParent(parentDir, DEFAULT_DIR_MODE);
     if (ret < 0) {
-        Logger(FormatMessage("failed to make parent dir for file: %s", path), 2);
+        int iLength = 0;
+        char* str = FormatLogMessage("failed to make parent dir for file: %s", &iLength, path);
+        Logger(str, LEVEL_ERROR, iLength);
+        free(str);
         return -1;
     }
 
     char resolvedPath[PATH_MAX] = {0};
     if (realpath(path, resolvedPath) == NULL && errno != ENOENT) {
-        Logger(FormatMessage("failed to resolve path %s.", path), 2);
+        int iLength = 0;
+        char* str = FormatLogMessage("failed to resolve path %s.", &iLength, path);
+        Logger(str, LEVEL_ERROR, iLength);
+        free(str);
         return -1;
     }
 
     int fd = open(resolvedPath, O_NOFOLLOW | O_CREAT, mode);
     if (fd < 0) {
-        Logger(FormatMessage("cannot create file: %s.", resolvedPath), 2);
+        int iLength = 0;
+        char* str = FormatLogMessage("cannot create file: %s.", &iLength, resolvedPath);
+        Logger(str, LEVEL_ERROR, iLength);
+        free(str);
         return -1;
     }
     close(fd);

cli/src/utils.h

@@ -9,7 +9,7 @@
 #include <sys/types.h>
 #include "basic.h"
 
-char *FormatMessage(char *format, ...);
+char *FormatLogMessage(char *format, int* iLength, ...);
 int IsStrEqual(const char *s1, const char *s2);
 int StrHasPrefix(const char *str, const char *prefix);
 int MkDir(const char *dir, int mode);