1 /*
2 +----------------------------------------------------------------------+
3 | PHP Version 7 |
4 +----------------------------------------------------------------------+
5 | Copyright (c) 1997-2018 The PHP Group |
6 +----------------------------------------------------------------------+
7 | This source file is subject to version 3.01 of the PHP license, |
8 | that is bundled with this package in the file LICENSE, and is |
9 | available at through the world-wide-web at the following url: |
10 | http://www.php.net/license/3_01.txt. |
11 | If you did not receive a copy of the PHP license and are unable to |
12 | obtain it through the world-wide-web, please send a note to |
13 | license@php.net so we can mail you a copy immediately. |
14 +----------------------------------------------------------------------+
15 | Author: George Wang <gwang@litespeedtech.com> |
16 +----------------------------------------------------------------------+
17 */
18 /*
19 Copyright (c) 2002-2018, Lite Speed Technologies Inc.
20 All rights reserved.
21
22 Redistribution and use in source and binary forms, with or without
23 modification, are permitted provided that the following conditions are
24 met:
25
26 * Redistributions of source code must retain the above copyright
27 notice, this list of conditions and the following disclaimer.
28 * Redistributions in binary form must reproduce the above
29 copyright notice, this list of conditions and the following
30 disclaimer in the documentation and/or other materials provided
31 with the distribution.
32 * Neither the name of the Lite Speed Technologies Inc nor the
33 names of its contributors may be used to endorse or promote
34 products derived from this software without specific prior
35 written permission.
36
37 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
38 "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
39 LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
40 A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
41 OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
42 SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
43 LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
44 DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
45 THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
46 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
47 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
48 */
49
50 #define HAVE_MSGHDR_MSG_CONTROL
51 #include "lsapilib.h"
52
53 #include <stdio.h>
54
55 #if HAVE_STDLIB_H
56 #include <stdlib.h>
57 #endif
58
59 #if HAVE_UNISTD_H
60 #include <unistd.h>
61 #endif
62
63 #include <sys/wait.h>
64
65
66 #include <sys/stat.h>
67
68 #if HAVE_SYS_TYPES_H
69
70 #include <sys/types.h>
71
72 #endif
73
74 #include <sys/types.h>
75 #include <sys/socket.h>
76 #include <sys/un.h>
77 #include <arpa/inet.h>
78 #include <netinet/in.h>
79 #include <semaphore.h>
80 #include <sys/mman.h>
81 #include <fcntl.h>
82 #include <dlfcn.h>
83 #include <stdlib.h>
84 #include <errno.h>
85 #include <string.h>
86 #include <stdarg.h>
87
88 #include <signal.h>
89 #include <time.h>
90 #include <sys/timeb.h>
91 #include <unistd.h>
92 #include "lscriu.h"
93
94 #define LSCRIU_PATH 256
95
96 // Begin CRIU inclusion
97 //CRIU inclusion
98 static int s_initial_start_reqs = 0;
99 static int s_requests_count = 0;
100 static int s_restored = 0;
101 static int (*s_lscapi_dump_me)() = NULL;
102 static int (*s_lscapi_prepare_me)() = NULL;
103 static int s_native = 0;
104 static int s_tried_checkpoint = 0;
105 static int s_criu_debug = 0;
106 static int s_fd_native = -1;
107 static char *s_criu_image_path = NULL;
108 static int s_pid = 0;
109
110 typedef enum
111 {
112 CRIU_GCOUNTER_SHM,
113 CRIU_GCOUNTER_SIG,
114 CRIU_GCOUNTER_PIPE
115 } GlobalCounterType_t;
116 static GlobalCounterType_t s_global_counter_type = CRIU_GCOUNTER_SHM;
117
118 #ifndef sighandler_t
119 typedef void (*sighandler_t)(int);
120 #endif
121
122 void lsapi_perror( const char * pMessage, int err_no );
123 void LSAPI_reset_server_state( void );
124 int LSAPI_Get_ppid();
125
126 #ifdef LSAPILIB_DEBUG_CRIU
127 #define lscriu_dbg(...) \
128 do { if (s_criu_debug) fprintf(stderr, __VA_ARGS__); } while(0)
129 #else
130 #define lscriu_dbg(...)
131 #endif
132
133 #define lscriu_err(...) fprintf(stderr, __VA_ARGS__)
134
135
136 #define SUN_PATH_MAX (sizeof(((struct sockaddr_un *)NULL)->sun_path))
137
138 typedef struct
139 {
140 pid_t m_iPidToDump;
141 char m_chImageDirectory[1024];
142 char m_chSocketDir[SUN_PATH_MAX];
143 char m_chServiceAddress[SUN_PATH_MAX];
144 } criu_native_dump_t;
145
146 typedef struct
147 {
148 int m_iDumpResult;
149 char m_chDumpResponseMessage[1024];
150 } criu_native_dump_response_t;
151
152 typedef sem_t * (*psem_open_t) (const char *__name, int __oflag, ...);
153 typedef int (*psem_post_t) (sem_t *__sem);
154 typedef int (*psem_close_t) (sem_t *__sem);
155
156 psem_open_t psem_open = NULL;
157 psem_post_t psem_post = NULL;
158 psem_close_t psem_close = NULL;
159
lsapi_criu_signal(int signo,sighandler_t handler)160 static void lsapi_criu_signal(int signo, sighandler_t handler)
161 {
162 struct sigaction sa;
163
164 sigaction(signo, NULL, &sa);
165
166 if (sa.sa_handler == SIG_DFL) {
167 sigemptyset(&sa.sa_mask);
168 sa.sa_flags = 0;
169 sa.sa_handler = handler;
170 sigaction(signo, &sa, NULL);
171 }
172 }
173
174
lsapi_siguser2(int sig)175 static void lsapi_siguser2(int sig)
176 {
177 // child requests counter for master process
178 ++s_requests_count;
179 }
180
181
LSCRIU_Set_Initial_Start_Reqs(int reqs)182 static void LSCRIU_Set_Initial_Start_Reqs(int reqs)
183 {
184 s_initial_start_reqs = reqs;
185 }
186
187
LSCRIU_Set_Global_Counter_Type(GlobalCounterType_t tp)188 static void LSCRIU_Set_Global_Counter_Type(GlobalCounterType_t tp)
189 {
190 if ((tp == CRIU_GCOUNTER_SHM) || (tp == CRIU_GCOUNTER_SIG)
191 || (tp == CRIU_GCOUNTER_PIPE)) {
192 s_global_counter_type = tp;
193 } else {
194 s_global_counter_type = CRIU_GCOUNTER_SHM;
195 }
196
197 }
198
199
LSCRIU_Get_Global_Counter_Type(void)200 static int LSCRIU_Get_Global_Counter_Type(void)
201 {
202 return s_global_counter_type;
203 }
204
205
LSCRIU_Init_Global_Counter(int value)206 static int LSCRIU_Init_Global_Counter(int value)
207 {
208 if (LSCRIU_Get_Global_Counter_Type() != CRIU_GCOUNTER_SHM
209 || !s_initial_start_reqs) {
210 return 0;
211 }
212
213 return 0;
214 }
215
216
LSCRIU_Increase_Global_Counter(void)217 static void LSCRIU_Increase_Global_Counter(void)
218 {
219 if (LSCRIU_Get_Global_Counter_Type() != CRIU_GCOUNTER_SHM
220 || !s_initial_start_reqs) {
221 return;
222 }
223
224 s_requests_count = LSAPI_Inc_Req_Processed(1);
225 }
226
227
LSCRIU_Get_Global_Counter(void)228 static void LSCRIU_Get_Global_Counter(void)
229 {
230 if (!s_initial_start_reqs) {
231 return;
232 }
233 s_requests_count = LSAPI_Inc_Req_Processed(0);
234
235 }
236
237
LSCRIU_need_checkpoint(void)238 static int LSCRIU_need_checkpoint(void)
239 {
240 if (!s_initial_start_reqs) {
241 return 0;
242 }
243
244 if (LSCRIU_Get_Global_Counter_Type() == CRIU_GCOUNTER_SHM
245 && s_requests_count <= s_initial_start_reqs) {
246 LSCRIU_Get_Global_Counter();
247 }
248 if (s_initial_start_reqs > 0
249 && s_requests_count >= s_initial_start_reqs) {
250 return 1;
251 }
252
253 return 0;
254 }
255
256
LSCRIU_load_liblscapi(void)257 static int LSCRIU_load_liblscapi(void)
258 {
259 void *lib_handle = NULL;
260 void *pthread_lib_handle = NULL;
261 char ch;
262
263 if (s_native)
264 return 0;
265 // Numerical signals indicates Apache
266 int error = 1;
267 char *last;
268
269 if (!(lib_handle = dlopen(last = "liblscapi.so", RTLD_LAZY)) /*||
270 !(pthread_lib_handle = dlopen(last = "libpthread.so", RTLD_LAZY))*/)
271 fprintf(stderr, "LSCRIU (%d): failed to dlopen %s: %s - ignore CRIU\n",
272 s_pid, last, dlerror());
273 else if (!(s_lscapi_dump_me = dlsym(lib_handle, last = "lscapi_dump_me")) ||
274 !(s_lscapi_prepare_me = dlsym(lib_handle, last = "lscapi_prepare_me")) ||
275 !(psem_open = dlsym(pthread_lib_handle, last = "sem_open")) ||
276 !(psem_post = dlsym(pthread_lib_handle, last = "sem_post")) ||
277 !(psem_close = dlsym(pthread_lib_handle, last = "sem_close")))
278 fprintf(stderr, "LSCRIU (%d): failed to dlsym %s: %s - ignore CRIU\n",
279 s_pid, last, dlerror());
280 else
281 error = 0;
282 if (error) {
283 // close the dll handles so we release the resources
284 if (lib_handle)
285 dlclose(lib_handle);
286 if (pthread_lib_handle)
287 dlclose(pthread_lib_handle);
288 return -1;
289 }
290 return 0;
291 }
292
293
LSCRIU_Wink_Server_is_Ready(void)294 static void LSCRIU_Wink_Server_is_Ready(void)
295 {
296 char sem_name[60];
297
298 if (s_native) {
299 // Not used for native
300 return;
301 }
302 if (getenv("LSAPI_UNIQE"))
303 snprintf(sem_name, sizeof sem_name - 1, "lsphp[hash=%s].is_ready",
304 getenv("LSAPI_UNIQE"));
305 else
306 snprintf(sem_name, sizeof sem_name - 1, "lsphp[euid=0x%x].is_ready",
307 geteuid());
308
309 sem_t *is_ready_sem = psem_open(sem_name, O_RDWR);
310 if (is_ready_sem) {
311 if (psem_post(is_ready_sem) < 0)
312 lsapi_perror(sem_name, errno);
313
314 if (psem_close(is_ready_sem) < 0)
315 lsapi_perror(sem_name, errno);
316 }
317 else if (errno != ENOENT)
318 lsapi_perror(sem_name, errno);
319 }
320
321
LSCRIU_Error_File_Name(char * pchFile,int max_len)322 static char *LSCRIU_Error_File_Name(char *pchFile, int max_len)
323 {
324 const char *pchDefaultSocketPath = "/tmp/";
325 const char *pchDefaultLogFileName = "lsws_error.log";
326 snprintf(pchFile, max_len, "%s%s", pchDefaultSocketPath,
327 pchDefaultLogFileName);
328 return pchFile;
329 }
330
331
332 #ifdef LSAPILIB_DEBUG_CRIU
LSCRIU_Debugging(void)333 static void LSCRIU_Debugging(void) {
334 char *pchCRIUDebug;
335 pchCRIUDebug = getenv("LSAPI_CRIU_DEBUG");
336 if (!pchCRIUDebug)
337 pchCRIUDebug = getenv("LSCAPI_CRIU_DEBUG");
338 //fprintf(stderr,"(%d) LSCRIU: CRIU debug environment variable: %s\n",
339 // s_pid, pchCRIUDebug);
340 // I've made it easy to turn on debugging. CloudLinux Apache sets
341 // LSCAPI_CRIU_DEBUG to nothing to indicate it's on. Sigh.
342 if ((!pchCRIUDebug) ||
343 ((!*pchCRIUDebug) ||
344 (*pchCRIUDebug == '0') ||
345 (*pchCRIUDebug == 'f') ||
346 (*pchCRIUDebug == 'F') ||
347 (((*pchCRIUDebug == 'O') ||
348 (*pchCRIUDebug == 'o')) &&
349 ((*(pchCRIUDebug + 1)) &&
350 ((*(pchCRIUDebug + 1) == 'F') || (*(pchCRIUDebug + 1) == 'f'))))))
351 {
352 lscriu_dbg("LSCRIU (%d): CRIU Debugging disabled by environment\n", s_pid);
353 s_criu_debug = 0;
354 }
355 else {
356 s_criu_debug = 1;
357 lscriu_dbg("LSCRIU (%d): CRIU Debugging enabled by environment\n", s_pid);
358 fprintf(stderr,"LSCRIU (%d): CRIU debug environment variable: %s\n",
359 s_pid, pchCRIUDebug);
360 }
361 }
362
363
LSCRIU_Restored_Error(int iFatal,char * format,...)364 static void LSCRIU_Restored_Error(int iFatal, char *format, ...) {
365 // This routine deals with the awful situation of trying to get info while the stderr handle is closed on purpose.
366 int iOldUMask;
367 int iFd = -1;
368 char chFile[1024];
369
370 if (!iFatal) {
371 // LSCRIU_Debugging();
372 if (!s_criu_debug) {
373 // Debugging message and debugging is off
374 return;
375 }
376 }
377 if (!LSCRIU_Error_File_Name(chFile, sizeof(chFile))) {
378 // We're done here...nowhere to write
379 return;
380 }
381 iOldUMask = umask(0);
382 iFd = open( chFile, O_WRONLY | O_APPEND | O_CREAT,
383 S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH);
384 umask(iOldUMask);
385 if (iFd >= 0) {
386 char chFullMessage[0x1000];
387 struct timeb sTimeb;
388 struct tm sTm;
389 ftime(&sTimeb);
390 localtime_r(&sTimeb.time,&sTm);
391 va_list ap;
392 va_start(ap, format);
393 char buf[0x1000];
394 vsnprintf(buf, sizeof(buf), format, ap);
395 va_end(ap);
396
397 int n = snprintf(chFullMessage, sizeof(chFullMessage),
398 "%04d-%02d-%02d %02d:%02d:%02d.%03d: LSCRIU (%d): %s %s\n",
399 sTm.tm_year + 1900,
400 sTm.tm_mon + 1,
401 sTm.tm_mday,
402 sTm.tm_hour,
403 sTm.tm_min,
404 sTm.tm_sec,
405 sTimeb.millitm,
406 s_pid,
407 iFatal ? "FATAL! " : "(debug) ",
408 buf);
409 if (n > (int)sizeof(chFullMessage))
410 n = sizeof(chFullMessage);
411 write(iFd, chFullMessage, n);
412 close(iFd);
413 }
414 }
415 #else // no debugging
LSCRIU_Debugging(void)416 static void inline LSCRIU_Debugging(void) {}
LSCRIU_Restored_Error(int iFatal,char * format,...)417 static void inline LSCRIU_Restored_Error(int iFatal, char *format, ...) {}
418 #endif
419
420
LSCRIU_Native_Dump(pid_t iPid,char * pchImagePath,int iFdNative)421 static int LSCRIU_Native_Dump(pid_t iPid,
422 char *pchImagePath,
423 int iFdNative) {
424 criu_native_dump_t criu_native_dump;
425 char *pchLastSlash;
426 criu_native_dump_response_t criu_native_dump_response;
427
428 memset(&criu_native_dump, 0, sizeof(criu_native_dump));
429 criu_native_dump.m_iPidToDump = iPid;
430 strncpy(criu_native_dump.m_chImageDirectory, pchImagePath,
431 sizeof(criu_native_dump.m_chImageDirectory));
432 pchLastSlash = strrchr(criu_native_dump.m_chSocketDir,'/');
433 if (pchLastSlash) {
434 pchLastSlash++;
435 (*pchLastSlash) = 0;
436 }
437 lscriu_dbg("LSCRIU (%d): Sent the dump request to the listener\n", s_pid);
438 if (write(iFdNative,
439 &criu_native_dump,
440 sizeof(criu_native_dump)) == -1) {
441 lscriu_err("LSCRIU (%d): Error sending dump request to the listener: %s\n",
442 s_pid, strerror(errno));
443 return(-1);
444 }
445 return 0;
446 /* do not wait response.
447 //while (sleep(7200));
448 if (read(iFdNative,
449 &criu_native_dump_response,
450 sizeof(criu_native_dump_response)) == -1) {
451 // The test will actually fail it!
452 //LSCRIU_Restored_Error(1, "Error reading dump socket #%d from parent: %s",
453 // iFdNative, strerror(errno));
454 //return(-1);
455 }
456 return(-1);
457 */
458 }
459
460
LSCRIU_CloudLinux_Checkpoint(void)461 static void LSCRIU_CloudLinux_Checkpoint(void)
462 {
463 int iRet;
464
465 if ((!s_native) && (!s_lscapi_dump_me)) {
466 lscriu_dbg("LSCRIU (%d): Not native and unable to dump - abandon one-time "
467 "dump\n", s_pid);
468 return;
469 }
470
471 iRet = s_lscapi_dump_me();
472 if (iRet < 0) {
473 char *pchError;
474 lscriu_err("LSCRIU: CloudLinux dump of PID: %d, error: %s\n",
475 s_pid, strerror(errno));
476 }
477 if (iRet == 0) {
478 // Dumped. To continue the child must send us the handles back
479 lscriu_err("LSCRIU: Successful CloudLinux dump of PID: %d\n", s_pid);
480 }
481 else {
482 s_restored = 1;
483 LSAPI_reset_server_state();
484 /*
485 Here we have restored the php process, so we should to tell (via
486 semaphore) mod_lsapi that we are started and ready to receive data.
487 */
488 LSCRIU_Wink_Server_is_Ready();
489 lscriu_err("LSCRIU: Successful CloudLinux restore of PID: %d, parent: %d.\n",
490 getpid(), getppid());
491 }
492 LSCRIU_Set_Initial_Start_Reqs(0);
493 }
494
495
LSCRIU_Wait_Dump_Finsh_Or_Restored(int pid_parent)496 static void LSCRIU_Wait_Dump_Finsh_Or_Restored(int pid_parent)
497 {
498 // Now get restored. We know if we're restored if the ppid changes!
499 // If we're dumped, we're killed (no use worrying about that!).
500 time_t iTimeStart = 0;
501 time_t iTimeNow;
502 int iRestored = 0;
503 do {
504 usleep(1000);
505 time(&iTimeNow);
506 if (!iTimeStart) {
507 iTimeStart = iTimeNow;
508 }
509 else if ((pid_parent != getppid()) ||
510 (iTimeNow - iTimeStart > 10)) {
511 iRestored = 1;
512 }
513 else if (iTimeNow - iTimeStart > 5) {
514 LSCRIU_Restored_Error(1, "Timed out waiting to be dumped");
515 exit(1);
516 }
517 } while (!iRestored);
518 }
519
520
LSCRIU_try_checkpoint(int * forked_pid)521 static void LSCRIU_try_checkpoint(int *forked_pid)
522 {
523 int iRet;
524 pid_t iPid;
525 pid_t iPidDump = getpid();
526
527 if (s_tried_checkpoint) {
528 lscriu_dbg("LSCRIU (%d): Already tried checkpoint - one time per customer\n",
529 getpid());
530 return;
531 }
532 lscriu_dbg("LSCRIU (%d): Trying checkpoint\n", getpid());
533 s_tried_checkpoint = 1;
534 if (!s_native) {
535 LSCRIU_CloudLinux_Checkpoint();
536 return;
537 }
538
539 lscriu_dbg("LSCRIU (%d): fork!\n", getpid());
540 iPid = fork();
541 if (iPid < 0) {
542 lscriu_err("LSCRIU (%d): Can't checkpoint due to a fork error: %s\n",
543 getpid(), strerror(errno));
544 return;
545 }
546 if (iPid == 0) {
547 int iResult;
548 pid_t iPidSender;
549 pid_t iPidParent = getppid();
550
551 s_pid = getpid();
552 setsid();
553 iRet = LSCRIU_Native_Dump(s_pid,
554 s_criu_image_path,
555 s_fd_native);
556 close(s_fd_native);
557
558 LSCRIU_Wait_Dump_Finsh_Or_Restored(iPidParent);
559 LSCRIU_Restored_Error(0, "Restored!");
560 LSAPI_reset_server_state();
561 s_restored = 1;
562 }
563 else {
564 if (forked_pid)
565 *forked_pid = iPid;
566 }
567 LSCRIU_Set_Initial_Start_Reqs(0);
568 }
569
570
init_native_env()571 static int init_native_env()
572 {
573 char *pchFd;
574 pchFd = getenv("LSAPI_CRIU_SYNC_FD");
575 if (!pchFd)
576 pchFd = getenv("LSCAPI_CRIU_SYNC_FD");
577
578 const char *image_path;
579 image_path = getenv("LSAPI_CRIU_IMAGE_PATH");
580 if (!pchFd) {
581 lscriu_err("LSCRIU (%d): LSAPI_CRIU_SYNC_FD internal environment "
582 "variable not set - contact Litespeed tech support\n", getpid());
583 return -1;
584 }
585 if (!image_path) {
586 lscriu_err("LSCRIU (%d): LSAPI_CRIU_IMAGE_PATH internal environment "
587 "variable not set - contact Litespeed tech support\n", getpid());
588 return -1;
589 }
590 lscriu_dbg("LSCRIU (%d): Checkpoint dump. ImagePath: %s\n",
591 getpid(), image_path);
592
593 s_fd_native = atoi(pchFd);
594 lscriu_dbg("LSCRIU (%d): Native checkpoint. Use filepointer %d (%s) to send "
595 "pid %d\n", getpid(), s_fd_native, pchFd, iPidDump);
596 s_criu_image_path = strdup(image_path);
597 return 0;
598 }
599
LSCRIU_Init_Env_Parameters(void)600 static int LSCRIU_Init_Env_Parameters(void)
601 {
602 const char *p;
603 int n;
604
605 p = getenv("LSAPI_INITIAL_START");
606 if (!p)
607 p = getenv("LSAPI_BACKEND_INITIAL_START");
608 if (p) {
609 n = atoi(p);
610
611 if (n > 0) {
612 lscriu_dbg("LSCRIU (%d): Set start requests based on environment (%d)\n",
613 getpid(), n);
614 LSCRIU_Set_Initial_Start_Reqs(n);
615 } else {
616 lscriu_dbg("LSCRIU (%d): LSAPI_INITIAL_START set to 0 disabled\n",
617 getpid());
618 return 0;
619 }
620 } else {
621 lscriu_dbg("LSCRIU (%d): LSAPI_INITIAL_START NOT set - disabled\n",
622 getpid());
623 return 0;
624 }
625 if (LSAPI_Is_Listen()) {
626 lscriu_dbg("LSCRIU (%d): Listening...\n", getpid());
627 GlobalCounterType_t gc_type = CRIU_GCOUNTER_SHM;
628 char *env;
629 if ((env = getenv("LSAPI_CRIU_USE_SHM"))) {
630 // CloudLinux doc: Off (shared memory) or Signals.
631 // Litespeed doc: On (shared memory) or Signals
632 // So just check the first character for an 'S' and if not, then
633 // use shared memory. Pipe support is lost (sigh).
634 if ((*env == 'S') || (*env == 's'))
635 gc_type = CRIU_GCOUNTER_SIG; // Just assume the rest is signals
636 // else use the default of shared memory
637 }
638 else if ((env = getenv("LSAPI_SIGNALS"))) {
639 if ((*env == '1') ||
640 (*env == 'Y') ||
641 (*env == 'y') ||
642 (*env == 'T') ||
643 (*env == 't') ||
644 (((*env == 'O') || (*env == 'o')) &&
645 ((*(env + 1) == 'N') || (*(env + 1) == 'n'))))
646 gc_type = CRIU_GCOUNTER_SIG;
647 else if (*env == 2)
648 gc_type = CRIU_GCOUNTER_PIPE; // The only case for pipe
649 //else use the default of shared memory
650 }
651 if (gc_type != CRIU_GCOUNTER_SHM) {
652 lscriu_dbg("LSCRIU (%d): Use %s\n", getpid(),
653 gc_type == CRIU_GCOUNTER_SIG ? "signals" : "pipe");
654 lsapi_criu_signal(SIGUSR2, lsapi_siguser2);
655 }
656 else
657 lscriu_dbg("LSCRIU (%d): Use shared memory\n", getpid());
658 LSCRIU_Set_Global_Counter_Type(gc_type);
659 }
660 else
661 lscriu_dbg("LSCRIU (%d): NOT Listening\n", getpid());
662
663 char *criu_mode = NULL;
664 char ch;
665 criu_mode = getenv("LSAPI_CRIU");
666 // 0 disabled
667 // 1 cloudlinux
668 // 2 native
669 if (criu_mode) {
670 if (*criu_mode == '0') {
671 lscriu_dbg("LSCRIU (%d): Disabled by environment.\n", getpid());
672 LSCRIU_Set_Initial_Start_Reqs(0);
673 }
674 else if (*criu_mode == '2') {
675 lscriu_dbg("LSCRIU (%d): Disabled by environment.\n", getpid());
676 s_native = 1;
677 }
678 }
679
680 if (s_native && init_native_env() == -1)
681 LSCRIU_Set_Initial_Start_Reqs(0);
682
683 //unset_lsapi_envs();
684 return 0;
685 }
686
687
LSCRIU_inc_req_procssed()688 void LSCRIU_inc_req_procssed()
689 {
690 if (!LSCRIU_Get_Global_Counter_Type()) {
691 ++s_requests_count;
692 }
693
694 lscriu_dbg("LSCRIU (%d): s_requests_count %d counter %d\n", getpid(),
695 s_requests_count, s_initial_start_reqs);
696
697 if (s_initial_start_reqs > 0 && s_requests_count <= s_initial_start_reqs) {
698 if (LSCRIU_Get_Global_Counter_Type() == CRIU_GCOUNTER_SHM) {
699 LSCRIU_Increase_Global_Counter();
700 if (s_requests_count >= s_initial_start_reqs) {
701 //Maybe this time we can stop to send signal and wait for
702 //1 second of select timeout
703 //kill( LSCRIU_Get_ppid(), SIGUSR2 );
704 lscriu_dbg("LSCRIU (%d): Time to dump main process with semaphore\n",
705 getpid());
706 }
707 } else {
708 kill(LSAPI_Get_ppid(), SIGUSR2);
709 lscriu_dbg("LSCRIU (%d): Send kill to main process with signals\n",
710 getpid());
711 }
712 }
713 }
714
715
LSCRIU_on_timer(int * forked_pid)716 static void LSCRIU_on_timer(int *forked_pid)
717 {
718 lscriu_dbg("LSCRIU (%d): LSCRIU_on_timer\n", getpid());
719 if (LSCRIU_need_checkpoint()) {
720 LSCRIU_try_checkpoint(forked_pid);
721 }
722 }
723
724
LSCRIU_Init(void)725 int LSCRIU_Init(void)
726 {
727 s_pid = getpid();
728 LSCRIU_Debugging();
729 LSCRIU_Init_Env_Parameters();
730 if (s_initial_start_reqs && !s_native) {
731 if (LSCRIU_load_liblscapi() == -1)
732 s_initial_start_reqs = 0;
733 }
734 if (s_initial_start_reqs) {
735 LSCRIU_Wink_Server_is_Ready();
736 lscriu_dbg("LSCRIU (%d): LSAPI_Register_Pgrp_Timer_Callback\n", s_pid);
737 LSAPI_Register_Pgrp_Timer_Callback(LSCRIU_on_timer);
738 LSCRIU_Init_Global_Counter(0);
739 }
740 return s_initial_start_reqs > 0;
741 }
742
