修复了不能同时写入多个log文件的问题

- 全局变量只会被初始化一次,所以下次使用的时候log文件处于打开状态
- 去掉全部的全局变量,使用传入文件指针的方式打开文件
- flock函数可以防止多线程和多进程对文件的并发修改

demo/demo.py

@@ -13,8 +13,8 @@ def _compile():
                       max_memory=judger.MEMORY_UNLIMITED,
                       args=[os.path.join(base_path, "demo.c"), "-o", os.path.join(base_path, "demo")],
                       env=["PATH=" + os.environ["PATH"]],
+                      log_path="compile.log",
                       use_sandbox=False,
-                      log_path="test.log",
                       use_nobody=False)
 
 
@@ -28,9 +28,10 @@ def run(use_sandbox, use_nobody):
                       max_cpu_time=2000,
                       # Byte
                       max_memory=200000000,
-                      # args and env are optional
+                      # args env and log_path are optional
                       args=["1", "2", "####"],
                       env=["aaa=123"],
+                      log_path="run.log",
                       # default is True
                       use_sandbox=use_sandbox,
                       use_nobody=use_nobody)

logger.h

@@ -1,33 +1,3 @@
-/*
- *
- * LOGGER v0.0.3
- * A simple logger for c/c++ under linux, multiprocess-safe
- *
- * ---- CopyLeft by Felix021 @ http://www.felix021.com ----
- *
- * LOG Format:
- * --LEVEL_NOTE--\x7 [Y-m-d H:m:s]\x7 [FILE:LINE]\x7 [EXTRA_INFO]\x7 log_info
- *   // LEVEL_NOTE stands for one of DEBUG/TRACE/NOTICE...
- *   // \x7 is a special character to separate logged fields.
- *
- * Usage:
- *   //Open log file first. Supply a log file name.
- *   log_open("log.txt");
- *
- *   //use it just as printf
- *   LOG_INFO("some info %d", 123);
- *
- *   //6 level: DEBUG, TRACE, NOTICE, MONITOR, WARNING, FATAL
- *   LOG_DEBUG("hi there");
- *
- *   //Need EXTRA_INFO to be logged automatically?
- *   log_add_info("pid:123");
- *
- *   //You don't need to call log_close manually, it'll be called at exit
- *   log_close();
- *
- */
-
 #ifndef __LOGGER__
 #define __LOGGER__
 
@@ -40,10 +10,9 @@
 #include <error.h>
 #include <sys/file.h>
 
-int log_open(const char *filename);
-void log_close(void);
-static void log_write(int, const char *, const int, const char *, ...);
-void log_add_info(const char *info);
+FILE* log_open(const char *);
+void log_close(FILE*);
+static void log_write(int level, const char* source_filename, const int line_number, const FILE* log_fp, const char*, ...);
 
 const int LOG_FATAL         = 0;
 const int LOG_WARNING       = 1;
@@ -51,65 +20,40 @@ const int LOG_INFO         = 2;
 const int LOG_DEBUG         = 3;
 static char LOG_LEVEL_NOTE[][10] =
         { "FATAL", "WARNING", "INFO", "DEBUG" };
-#define LOG_DEBUG(x...)   log_write(LOG_DEBUG, __FILE__, __LINE__, ##x)
-#define LOG_INFO(x...)  log_write(LOG_INFO, __FILE__ __LINE__, ##x)
-#define LOG_WARNING(x...) log_write(LOG_WARNING, __FILE__, __LINE__, ##x)
-#define LOG_FATAL(x...)   log_write(LOG_FATAL, __FILE__, __LINE__, ##x)
-
-
-static FILE *log_fp                 = NULL;
-static char *log_filename           = NULL;
-static int  log_opened              = 0;
+#define LOG_DEBUG(log_fp, x...)   log_write(LOG_DEBUG, __FILE__, __LINE__, log_fp, ##x)
+#define LOG_INFO(log_fp, x...)  log_write(LOG_INFO, __FILE__ __LINE__, log_fp, ##x)
+#define LOG_WARNING(log_fp, x...) log_write(LOG_WARNING, __FILE__, __LINE__, log_fp, ##x)
+#define LOG_FATAL(log_fp, x...)   log_write(LOG_FATAL, __FILE__, __LINE__, log_fp, ##x)
 
 #define log_buffer_size 8192
-static char log_buffer[log_buffer_size];
-static char log_extra_info[log_buffer_size];
 
-int log_open(const char* filename)
+FILE* log_open(const char* filename)
 {
-    if (log_opened == 1)
-    {
-        fprintf(stderr, "logger: log already opened\n");
-        return 0;
-    }
-    int len = strlen(filename);
-    log_filename = (char *)malloc(sizeof(char) * len + 1);
-    strcpy(log_filename, filename);
-    log_fp = fopen(log_filename, "a");
+    FILE* log_fp = fopen(filename, "a");
     if (log_fp == NULL)
     {
-        fprintf(stderr, "log_file: %s", log_filename);
-        perror("can't not open log file");
-        exit(1);
+        fprintf(stderr, "can not open log file %s", filename);
     }
-
-    atexit(log_close);
-    log_opened = 1;
-    log_extra_info[0] = 0;
-    return 1;
+    return log_fp;
 }
 
-void log_close(void)
+void log_close(FILE* log_fp)
 {
-    if (log_opened)
+    if (log_fp != NULL)
     {
         fclose(log_fp);
-        free(log_filename);
-        log_fp       = NULL;
-        log_filename = NULL;
-        log_opened   = 0;
     }
 }
 
-static void log_write(int level, const char *file,
-                      const int line, const char *fmt, ...)
+static void log_write(int level, const char* source_filename, const int line, const FILE* log_fp, const char *fmt, ...)
 {
-    if (log_opened == 0)
+    if (log_fp == NULL)
     {
-        fprintf(stderr, "log_open not called yet\n");
-        exit(1);
+        fprintf(stderr, "can not open log file");
+        return;
     }
     static char buffer[log_buffer_size];
+    static char log_buffer[log_buffer_size];
     static char datetime[100];
     static char line_str[20];
     static time_t now;
@@ -123,30 +67,24 @@ static void log_write(int level, const char *file,
     va_end(ap);
 
     size_t count = snprintf(buffer, log_buffer_size,
-                            "%s [%s] [%s:%d]%s %s\n",
-                            LOG_LEVEL_NOTE[level], datetime, file, line, log_extra_info, log_buffer);
+                            "%s [%s] [%s:%d]%s\n",
+                            LOG_LEVEL_NOTE[level], datetime, source_filename, line, log_buffer);
     fprintf(stdout, "%s", buffer);
     int log_fd = log_fp->_fileno;
     if (flock(log_fd, LOCK_EX) == 0)
     {
         if (write(log_fd, buffer, count) < 0)
         {
-            perror("write error");
-            exit(1);
+            fprintf(stderr, "write error");
+            return;
         }
         flock(log_fd, LOCK_UN);
     }
     else
     {
-        perror("flock error");
-        exit(1);
+        fprintf(stderr, "flock error");
+        return;
     }
 }
 
-void log_add_info(const char *info)
-{
-    int len = strlen(log_extra_info);
-    snprintf(log_extra_info + len, log_buffer_size - len, "\n [%s]", info);
-}
-
 #endif

runner.c

@@ -21,7 +21,6 @@ int set_timer(int sec, int ms, int is_cpu_time) {
     time_val.it_value.tv_sec = sec;
     time_val.it_value.tv_usec = ms * 1000;
     if (setitimer(is_cpu_time ? ITIMER_VIRTUAL : ITIMER_REAL, &time_val, NULL)) {
-        LOG_FATAL("setitimer failed, errno %d", errno);
         return SETITIMER_FAILED;
     }
     return SUCCESS;
@@ -35,6 +34,7 @@ void run(struct config *config, struct result *result) {
     struct rlimit memory_limit;
     int signal;
     int i;
+    FILE* log_fp;
     struct passwd *passwd = getpwnam("nobody");
     FILE *in_file, *out_file;
     int syscalls_whitelist[] = {SCMP_SYS(read), SCMP_SYS(fstat),
@@ -47,7 +47,11 @@ void run(struct config *config, struct result *result) {
     int syscalls_whitelist_length = sizeof(syscalls_whitelist) / sizeof(int);
     scmp_filter_ctx ctx = NULL;
     
-    log_open(config->log_path);
+    log_fp = log_open(config->log_path);
+    if(log_fp == NULL){
+        result->flag = SYSTEM_ERROR;
+        return;
+    }
 
 #ifdef __APPLE__
     #warning "setrlimit with RLIMIT_AS to limit memory usage will not work on OSX"
@@ -56,21 +60,24 @@ void run(struct config *config, struct result *result) {
     gettimeofday(&start, NULL);
 
     if(config->max_memory < 1 && config->max_memory != MEMORY_UNLIMITED) {
-        LOG_FATAL("max_memory must > 1 or unlimited");
+        LOG_FATAL(log_fp, "max_memory must > 1 or unlimited");
         result->flag = SYSTEM_ERROR;
+        log_close(log_fp);
         return;
     }
     if(config->max_cpu_time < 1 && config->max_cpu_time != CPU_TIME_UNLIMITED) {
-        LOG_FATAL("max_cpu_time must > 1 or unlimited");
+        LOG_FATAL(log_fp, "max_cpu_time must > 1 or unlimited");
         result->flag = SYSTEM_ERROR;
+        log_close(log_fp);
         return;
     }
 
     in_file = fopen(config->in_file, "r");
     out_file = fopen(config->out_file, "w");
     if(in_file == NULL || out_file == NULL) {
-        LOG_FATAL("failed to open in/out redirect file");
+        LOG_FATAL(log_fp, "failed to open in/out redirect file");
         result->flag = SYSTEM_ERROR;
+        log_close(log_fp);
         return;
     }
 
@@ -78,8 +85,9 @@ void run(struct config *config, struct result *result) {
     pid_t pid = fork();
 
     if (pid < 0) {
-        LOG_FATAL("fork failed");
+        LOG_FATAL(log_fp, "fork failed");
         result->flag = SYSTEM_ERROR;
+        log_close(log_fp);
         return;
     }
 
@@ -89,11 +97,12 @@ void run(struct config *config, struct result *result) {
         // on success, returns the process ID of the child whose state has changed;
         // On error, -1 is returned.
         if (wait4(pid, &status, 0, &resource_usage) == -1) {
-            LOG_FATAL("wait4 failed");
+            LOG_FATAL(log_fp, "wait4 failed");
             result->flag = SYSTEM_ERROR;
+            log_close(log_fp);
             return;
         }
-        LOG_DEBUG("exit status: %d", WEXITSTATUS(status));
+        LOG_DEBUG(log_fp, "exit status: %d", WEXITSTATUS(status));
         result->exit_status = WEXITSTATUS(status);
         result->cpu_time = (int) (resource_usage.ru_utime.tv_sec * 1000 +
                                   resource_usage.ru_utime.tv_usec / 1000 +
@@ -115,7 +124,7 @@ void run(struct config *config, struct result *result) {
 
         if (WIFSIGNALED(status) != 0) {
             signal = WTERMSIG(status);
-            LOG_DEBUG("signal: %d", signal);
+            LOG_DEBUG(log_fp, "signal: %d", signal);
             result->signal = signal;
             if (signal == SIGALRM) {
                 result->flag = REAL_TIME_LIMIT_EXCEEDED;
@@ -157,20 +166,20 @@ void run(struct config *config, struct result *result) {
         if (config->max_memory != MEMORY_UNLIMITED) {
             memory_limit.rlim_cur = memory_limit.rlim_max = (rlim_t) (config->max_memory) * 2;
             if (setrlimit(RLIMIT_AS, &memory_limit) == -1) {
-                LOG_FATAL("setrlimit failed, errno: %d", errno);
-                ERROR(SETRLIMIT_FAILED);
+                LOG_FATAL(log_fp, "setrlimit failed, errno: %d", errno);
+                ERROR(log_fp, SETRLIMIT_FAILED);
             }
         }
         if (config->max_cpu_time != CPU_TIME_UNLIMITED) {
             // cpu time
             if (set_timer(config->max_cpu_time / 1000, config->max_cpu_time % 1000, 1) != SUCCESS) {
-                LOG_FATAL("set cpu time timer failed");
-                ERROR(SETITIMER_FAILED);
+                LOG_FATAL(log_fp, "set cpu time timer failed");
+                ERROR(log_fp, SETITIMER_FAILED);
             }
             // real time * 3
             if (set_timer(config->max_cpu_time / 1000 * 3, (config->max_cpu_time % 1000) * 3 % 1000, 0) != SUCCESS) {
-                LOG_FATAL("set real time timer failed");
-                ERROR(SETITIMER_FAILED);
+                LOG_FATAL(log_fp, "set real time timer failed");
+                ERROR(log_fp, SETITIMER_FAILED);
             }
         }
 
@@ -178,32 +187,32 @@ void run(struct config *config, struct result *result) {
         // On success, these system calls return the new descriptor. 
         // On error, -1 is returned, and errno is set appropriately.
         if (dup2(fileno(in_file), 0) == -1) {
-            LOG_FATAL("dup2 stdin failed, errno: %d", errno);
-            ERROR(DUP2_FAILED);
+            LOG_FATAL(log_fp, "dup2 stdin failed, errno: %d", errno);
+            ERROR(log_fp, DUP2_FAILED);
         }
         // write stdout to out file
         if (dup2(fileno(out_file), 1) == -1) {
-            LOG_FATAL("dup2 stdout failed, errno: %d", errno);
-            ERROR(DUP2_FAILED);
+            LOG_FATAL(log_fp, "dup2 stdout failed, errno: %d", errno);
+            ERROR(log_fp, DUP2_FAILED);
         }
         // redirect stderr to stdout
         if (dup2(fileno(stdout), fileno(stderr)) == -1) {
-            LOG_FATAL("dup2 stderr failed, errno: %d", errno);
-            ERROR(DUP2_FAILED);
+            LOG_FATAL(log_fp, "dup2 stderr failed, errno: %d", errno);
+            ERROR(log_fp, DUP2_FAILED);
         }
 
         if (config->use_nobody != 0) {
             if(passwd == NULL) {
-                LOG_FATAL("get nobody user info failed, errno: %d", errno);
-                ERROR(SET_UID_FAILED);
+                LOG_FATAL(log_fp, "get nobody user info failed, errno: %d", errno);
+                ERROR(log_fp, SET_UID_FAILED);
             }
             if (setgid(passwd->pw_gid) == -1) {
-                LOG_FATAL("setgid failed, errno: %d", errno);
-                ERROR(SET_GID_FAILED);
+                LOG_FATAL(log_fp, "setgid failed, errno: %d", errno);
+                ERROR(log_fp, SET_GID_FAILED);
             }
             if (setuid(passwd->pw_uid) == -1) {
-                LOG_FATAL("setuid failed, errno: %d", errno);
-                ERROR(SET_UID_FAILED);
+                LOG_FATAL(log_fp, "setuid failed, errno: %d", errno);
+                ERROR(log_fp, SET_UID_FAILED);
             }
         }
 
@@ -211,33 +220,34 @@ void run(struct config *config, struct result *result) {
             // load seccomp rules
             ctx = seccomp_init(SCMP_ACT_KILL);
             if (!ctx) {
-                LOG_FATAL("init seccomp failed");
-                ERROR(LOAD_SECCOMP_FAILED);
+                LOG_FATAL(log_fp, "init seccomp failed");
+                ERROR(log_fp, LOAD_SECCOMP_FAILED);
             }
             for (i = 0; i < syscalls_whitelist_length; i++) {
                 if (seccomp_rule_add(ctx, SCMP_ACT_ALLOW, syscalls_whitelist[i], 0) != 0) {
-                    LOG_FATAL("load syscall white list failed");
-                    ERROR(LOAD_SECCOMP_FAILED);
+                    LOG_FATAL(log_fp, "load syscall white list failed");
+                    ERROR(log_fp, LOAD_SECCOMP_FAILED);
                 }
             }
             // add extra rule for execve
             if (seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(execve), 1, SCMP_A0(SCMP_CMP_EQ, config->path)) != 0) {
-                LOG_FATAL("load execve rule failed");
-                ERROR(LOAD_SECCOMP_FAILED);
+                LOG_FATAL(log_fp, "load execve rule failed");
+                ERROR(log_fp, LOAD_SECCOMP_FAILED);
             }
             // only fd 0 1 2 are allowed
             if (seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(write), 1, SCMP_A0(SCMP_CMP_LE, 2)) != 0) {
-                LOG_FATAL("load dup2 rule failed");
-                ERROR(LOAD_SECCOMP_FAILED);
+                LOG_FATAL(log_fp, "load dup2 rule failed");
+                ERROR(log_fp, LOAD_SECCOMP_FAILED);
             }
             if (seccomp_load(ctx) != 0) {
-                LOG_FATAL("seccomp load failed");
-                ERROR(LOAD_SECCOMP_FAILED);
+                LOG_FATAL(log_fp, "seccomp load failed");
+                ERROR(log_fp, LOAD_SECCOMP_FAILED);
             }
             seccomp_release(ctx);
         }
         execve(config->path, config->args, config->env);
-        LOG_FATAL("execve failed, errno: %d", errno);
-        ERROR(EXCEVE_FAILED);
+        LOG_FATAL(log_fp, "execve failed, errno: %d", errno);
+        ERROR(log_fp, EXCEVE_FAILED);
     }
+    log_close(log_fp);
 }

runner.h

@@ -26,7 +26,7 @@
 #define SYSTEM_ERROR 5
 
 
-#define ERROR(code) LOG_FATAL("judger return error code: %d", code);raise(SIGUSR1)
+#define ERROR(log_fp, code) LOG_FATAL(log_fp, "judger return error code: %d", code);raise(SIGUSR1)
 
 
 struct result {