No longer using the SIGRTMIN signal; instead, the logs will be reopened upon receiving SIGWINCH. SIGRTMIN is a feature unique to Linux.

Author: matyhtf

ext-src/swoole_process_pool.cc

@@ -310,7 +310,10 @@ static void process_pool_signal_handler(int sig) {
         current_pool->reload();
         break;
     case SIGIO:
-        current_pool->read_message = true;
+        current_pool->rigger_read_message_event();
+        break;
+    case SIGWINCH:
+        current_pool->reopen_logger();
         break;
     default:
         break;

include/swoole_process_pool.h

@@ -400,6 +400,12 @@ struct ProcessPool {
     int start();
     bool shutdown();
     bool reload();
+    void reopen_logger();
+
+    void rigger_read_message_event() {
+        read_message = true;
+    }
+
     pid_t spawn(Worker *worker);
     void stop(Worker *worker);
     void kill_all_workers(int signo = SIGKILL);

src/os/process_pool.cc

@@ -442,6 +442,14 @@ void ProcessPool::stop(Worker *worker) {
     }
 }
 
+void ProcessPool::reopen_logger() {
+    sw_logger()->reopen();
+
+    if (is_master()) {
+        kill_all_workers(SIGWINCH);
+    }
+}
+
 void ProcessPool::kill_all_workers(int signo) {
     SW_LOOP_N(worker_num) {
         swoole_kill(workers[i].pid, signo);

src/server/manager.cc

@@ -27,6 +27,11 @@
 #endif
 
 namespace swoole {
+/**
+ * The functionality of the Manager class is similar to that of the ProcessPool,
+ * but due to the more complex management requirements for processes in the Server module, the ProcessPool falls short.
+ * Therefore, we ad an new class, and the Manager class should reuse the ProcessPool code as much as possible.
+ */
 struct Manager {
     bool reload_all_worker;
     bool reload_task_worker;
@@ -37,6 +42,7 @@ struct Manager {
 
     void wait(Server *_server);
     void terminate_all_worker();
+    void reopen_logger() const;
 
     static void signal_handler(int sig);
     static void timer_callback(Timer *timer, TimerNode *tnode);
@@ -122,14 +128,14 @@ void Manager::wait(Server *_server) {
 
     swoole_event_free();
 
-    // for reload
     swoole_signal_set(SIGHUP, nullptr);
-    swoole_signal_set(SIGCHLD, signal_handler);
-    swoole_signal_set(SIGTERM, signal_handler);
-    swoole_signal_set(SIGUSR1, signal_handler);
-    swoole_signal_set(SIGUSR2, signal_handler);
-    swoole_signal_set(SIGIO, signal_handler);
-    swoole_signal_set(SIGALRM, signal_handler);
+    swoole_signal_set(SIGCHLD, signal_handler);   // child process exit
+    swoole_signal_set(SIGTERM, signal_handler);   // shutdown
+    swoole_signal_set(SIGUSR1, signal_handler);   // reload all workers
+    swoole_signal_set(SIGUSR2, signal_handler);   // reload task workers
+    swoole_signal_set(SIGIO, signal_handler);     // read message
+    swoole_signal_set(SIGALRM, signal_handler);   // timer
+    swoole_signal_set(SIGWINCH, signal_handler);  // reopen log file
 #ifdef SIGRTMIN
     swoole_signal_set(SIGRTMIN, signal_handler);
 #endif
@@ -331,6 +337,15 @@ void Manager::terminate_all_worker() {
     }
 }
 
+void Manager::reopen_logger() const {
+    sw_logger()->reopen();
+
+    SW_LOOP_N(server_->get_all_worker_num()) {
+        const auto worker = server_->get_worker(i);
+        swoole_kill(worker->pid, SIGWINCH);
+    }
+}
+
 void Manager::signal_handler(int signo) {
     Server *_server = sw_server();
     if (!_server || !_server->manager) {
@@ -346,7 +361,6 @@ void Manager::signal_handler(int signo) {
     case SIGUSR1:
     case SIGUSR2:
         _server->reload(signo == SIGUSR1);
-        sw_logger()->reopen();
         break;
     case SIGIO:
         pool->read_message = true;
@@ -356,10 +370,13 @@ void Manager::signal_handler(int signo) {
             manager->terminate_all_worker();
         }
         break;
+    case SIGWINCH:
+        manager->reopen_logger();
+        break;
     default:
 #ifdef SIGRTMIN
         if (signo == SIGRTMIN) {
-            sw_logger()->reopen();
+            manager->reopen_logger();
         }
 #endif
         break;

src/server/master.cc

@@ -931,20 +931,16 @@ bool Server::signal_handler_read_message() {
     return true;
 }
 
-#ifdef SIGRTMIN
 bool Server::signal_handler_reopen_logger() {
     swoole_trace_log(SW_TRACE_SERVER, "reopen log file ['%s']", sw_logger()->get_file());
-    for (uint32_t i = 0; i < worker_num + task_worker_num + get_user_worker_num(); i++) {
-        Worker *worker = get_worker(i);
-        swoole_kill(worker->pid, SIGRTMIN);
-    }
+    sw_logger()->reopen();
+
     if (is_process_mode()) {
-        swoole_kill(gs->manager_pid, SIGRTMIN);
+        swoole_kill(gs->manager_pid, SIGWINCH);
     }
-    sw_logger()->reopen();
+
     return true;
 }
-#endif
 
 void Server::stop_master_thread() {
     Reactor *reactor = SwooleTG.reactor;
@@ -1644,11 +1640,10 @@ void Server::init_signal_handler() {
     swoole_signal_set(SIGUSR1, master_signal_handler);
     swoole_signal_set(SIGUSR2, master_signal_handler);
     swoole_signal_set(SIGTERM, master_signal_handler);
+    swoole_signal_set(SIGWINCH, master_signal_handler);
 #ifdef SIGRTMIN
     swoole_signal_set(SIGRTMIN, master_signal_handler);
 #endif
-    // for test
-    swoole_signal_set(SIGVTALRM, master_signal_handler);
 
     if (SwooleG.signal_fd > 0) {
         set_minfd(SwooleG.signal_fd);
@@ -1864,16 +1859,16 @@ void Server::master_signal_handler(int signo) {
     case SIGCHLD:
         serv->signal_handler_child_exit();
         break;
-    case SIGVTALRM:
-        swoole_warning("SIGVTALRM coming");
-        break;
     case SIGUSR1:
     case SIGUSR2:
         serv->signal_handler_reload(signo == SIGUSR1);
         break;
     case SIGIO:
         serv->signal_handler_read_message();
         break;
+    case SIGWINCH:
+        serv->signal_handler_reopen_logger();
+        break;
     default:
 #ifdef SIGRTMIN
         if (signo == SIGRTMIN) {

src/server/task_worker.cc

@@ -233,9 +233,10 @@ static void TaskWorker_signal_init(ProcessPool *pool) {
     }
     swoole_signal_set(SIGHUP, nullptr);
     swoole_signal_set(SIGPIPE, nullptr);
-    swoole_signal_set(SIGUSR1, Server::worker_signal_handler);
+    swoole_signal_set(SIGUSR1, nullptr);
     swoole_signal_set(SIGUSR2, nullptr);
     swoole_signal_set(SIGTERM, Server::worker_signal_handler);
+    swoole_signal_set(SIGWINCH, Server::worker_signal_handler);
 #ifdef SIGRTMIN
     swoole_signal_set(SIGRTMIN, Server::worker_signal_handler);
 #endif

src/server/worker.cc

@@ -29,6 +29,12 @@ using namespace network;
 static int Worker_onPipeReceive(Reactor *reactor, Event *event);
 static void Worker_reactor_try_to_exit(Reactor *reactor);
 
+static void Worker_reopen_logger() {
+    if (sw_logger()) {
+        sw_logger()->reopen();
+    }
+}
+
 void Server::worker_signal_init() {
     if (is_thread_mode()) {
         return;
@@ -37,12 +43,10 @@ void Server::worker_signal_init() {
     swoole_signal_set(SIGPIPE, SIG_IGN);
     swoole_signal_set(SIGUSR1, nullptr);
     swoole_signal_set(SIGUSR2, nullptr);
-    // swSignal_set(SIGINT, Server::worker_signal_handler);
-    swoole_signal_set(SIGTERM, Server::worker_signal_handler);
-    // for test
-    swoole_signal_set(SIGVTALRM, Server::worker_signal_handler);
+    swoole_signal_set(SIGTERM, worker_signal_handler);
+    swoole_signal_set(SIGWINCH, worker_signal_handler);
 #ifdef SIGRTMIN
-    swoole_signal_set(SIGRTMIN, Server::worker_signal_handler);
+    swoole_signal_set(SIGRTMIN, worker_signal_handler);
 #endif
 }
 
@@ -60,20 +64,13 @@ void Server::worker_signal_handler(int signo) {
             sw_worker()->shutdown();
         }
         break;
-    // for test
-    case SIGVTALRM:
-        swoole_warning("SIGVTALRM coming");
-        break;
-    case SIGUSR1:
-    case SIGUSR2:
-        if (sw_logger()) {
-            sw_logger()->reopen();
-        }
+    case SIGWINCH:
+        Worker_reopen_logger();
         break;
     default:
 #ifdef SIGRTMIN
-        if (signo == SIGRTMIN && sw_logger()) {
-            sw_logger()->reopen();
+        if (signo == SIGRTMIN ) {
+            Worker_reopen_logger();
         }
 #endif
         break;