/* +----------------------------------------------------------------------+ | PHP Version 7 | +----------------------------------------------------------------------+ | Copyright (c) 1997-2018 The PHP Group | +----------------------------------------------------------------------+ | This source file is subject to version 3.01 of the PHP license, | | that is bundled with this package in the file LICENSE, and is | | available at through the world-wide-web at the following url: | | http://www.php.net/license/3_01.txt. | | If you did not receive a copy of the PHP license and are unable to | | obtain it through the world-wide-web, please send a note to | | license@php.net so we can mail you a copy immediately. | +----------------------------------------------------------------------+ | Author: George Wang | +----------------------------------------------------------------------+ */ /* Copyright (c) 2002-2018, Lite Speed Technologies Inc. All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the name of the Lite Speed Technologies Inc nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #define HAVE_MSGHDR_MSG_CONTROL #include "lsapilib.h" #include #if HAVE_STDLIB_H #include #endif #if HAVE_UNISTD_H #include #endif #include #include #if HAVE_SYS_TYPES_H #include #endif #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "lscriu.h" #define LSCRIU_PATH 256 // Begin CRIU inclusion //CRIU inclusion static int s_initial_start_reqs = 0; static int s_requests_count = 0; static int s_restored = 0; static int (*s_lscapi_dump_me)() = NULL; static int (*s_lscapi_prepare_me)() = NULL; static int s_native = 0; static int s_tried_checkpoint = 0; static int s_criu_debug = 0; typedef enum { CRIU_GCOUNTER_SHM, CRIU_GCOUNTER_SIG, CRIU_GCOUNTER_PIPE } GlobalCounterType_t; static GlobalCounterType_t s_global_counter_type = CRIU_GCOUNTER_SHM; #ifndef sighandler_t typedef void (*sighandler_t)(int); #endif void lsapi_error( const char * pMessage, int err_no ); void LSAPI_reset_server_state( void ); int LSAPI_Get_ppid(); #ifdef LSAPILIB_DEBUG_CRIU #define lscriu_dbg(...) \ do { if (s_criu_debug) fprintf(stderr, __VA_ARGS__); } while(0) #else #define lscriu_dbg(...) #endif #define lscriu_err(...) fprintf(stderr, __VA_ARGS__) #define SUN_PATH_MAX (sizeof(((struct sockaddr_un *)NULL)->sun_path)) typedef struct { pid_t m_iPidToDump; char m_chImageDirectory[1024]; char m_chSocketDir[SUN_PATH_MAX]; char m_chServiceAddress[SUN_PATH_MAX]; } criu_native_dump_t; typedef struct { int m_iDumpResult; char m_chDumpResponseMessage[1024]; } criu_native_dump_response_t; typedef sem_t * (*psem_open_t) (const char *__name, int __oflag, ...); typedef int (*psem_post_t) (sem_t *__sem); typedef int (*psem_close_t) (sem_t *__sem); psem_open_t psem_open = NULL; psem_post_t psem_post = NULL; psem_close_t psem_close = NULL; static void lsapi_criu_signal(int signo, sighandler_t handler) { struct sigaction sa; sigaction(signo, NULL, &sa); if (sa.sa_handler == SIG_DFL) { sigemptyset(&sa.sa_mask); sa.sa_flags = 0; sa.sa_handler = handler; sigaction(signo, &sa, NULL); } } static void lsapi_siguser2(int sig) { // child requests counter for master process ++s_requests_count; } static void LSCRIU_Set_Initial_Start_Reqs(int reqs) { s_initial_start_reqs = reqs; } static void LSCRIU_Set_Global_Counter_Type(GlobalCounterType_t tp) { if ((tp == CRIU_GCOUNTER_SHM) || (tp == CRIU_GCOUNTER_SIG) || (tp == CRIU_GCOUNTER_PIPE)) { s_global_counter_type = tp; } else { s_global_counter_type = CRIU_GCOUNTER_SHM; } } static int LSCRIU_Get_Global_Counter_Type(void) { return s_global_counter_type; } #if 0 static int *s_shm_global_counter = NULL; static int LSCRIU_Init_Global_Counter(int value) { if (LSCRIU_Get_Global_Counter_Type() != CRIU_GCOUNTER_SHM || !s_initial_start_reqs) { return 0; } s_shm_global_counter = mmap(NULL, sizeof * s_shm_global_counter, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, -1, 0); if (!s_shm_global_counter) { fprintf(stderr, "LSCRIU (%d): memory for global counter allocation error\n", getpid()); return -1; } __sync_lock_test_and_set(s_shm_global_counter, value); lscriu_dbg("LSCRIU (%d): semaphore and shared memory created\n", getpid()); return 0; } //static void LSCRIU_Destroy_Global_Counter(int only_unmap) //{ // if (LSCRIU_Get_Global_Counter_Type() != CRIU_GCOUNTER_SHM) { // return; // } // // if (s_shm_global_counter) { // munmap(s_shm_global_counter, sizeof * s_shm_global_counter); // } //} static void LSCRIU_Increase_Global_Counter(void) { if (LSCRIU_Get_Global_Counter_Type() != CRIU_GCOUNTER_SHM || !s_initial_start_reqs) { return; } if (s_shm_global_counter) { s_requests_count = __sync_add_and_fetch(s_shm_global_counter, 1); //lscriu_dbg("LSCRIU (%d): increase counter %d\n", getpid(), // s_requests_count); } else { s_requests_count = 0; LSCRIU_Set_Initial_Start_Reqs(0); } } static void LSCRIU_Get_Global_Counter(void) { if (!s_initial_start_reqs) { return; } if (s_shm_global_counter) { s_requests_count = __sync_fetch_and_or(s_shm_global_counter, 0); //lscriu_dbg("LSCRIU (%d): get counter value %d\n", getpid(), // s_requests_count); } else { lscriu_dbg("LSCRIU (%d): Reset requests in get\n", getpid()); s_requests_count = 0; LSCRIU_Set_Initial_Start_Reqs(0); } } #else static int LSCRIU_Init_Global_Counter(int value) { if (LSCRIU_Get_Global_Counter_Type() != CRIU_GCOUNTER_SHM || !s_initial_start_reqs) { return 0; } return 0; } static void LSCRIU_Increase_Global_Counter(void) { if (LSCRIU_Get_Global_Counter_Type() != CRIU_GCOUNTER_SHM || !s_initial_start_reqs) { return; } s_requests_count = LSAPI_Inc_Req_Processed(1); } static void LSCRIU_Get_Global_Counter(void) { if (!s_initial_start_reqs) { return; } s_requests_count = LSAPI_Inc_Req_Processed(0); } #endif static int LSCRIU_need_checkpoint(void) { if (!s_initial_start_reqs) { return 0; } if (LSCRIU_Get_Global_Counter_Type() == CRIU_GCOUNTER_SHM && s_requests_count <= s_initial_start_reqs) { LSCRIU_Get_Global_Counter(); } if (s_initial_start_reqs > 0 && s_requests_count >= s_initial_start_reqs) { return 1; } return 0; } static int LSCRIU_load_liblscapi(void) { void *lib_handle = NULL; void *pthread_lib_handle = NULL; char ch; char *pchForceNative = NULL; char *pchNative = NULL; pchForceNative = getenv("LSAPI_CRIU_FORCE_NATIVE"); pchNative = getenv("LSCAPI_CRIU_NATIVE"); if (pchForceNative && ((ch = *pchForceNative | 0x20) == '1' || ch == 't' || (ch == 'o' && ((*(pchForceNative + 1) | 0x20) == 'n')))) s_native = 1; else if (pchNative && ((ch = *pchNative | 0x20) == '1' || ch == 't' || (ch == 'o' && ((*(pchNative + 1) | 0x20) == 'n')))) s_native = 1; else if (!s_native) { // Numerical signals indicates Apache int error = 1; char *last; if (!(lib_handle = dlopen(last = "liblscapi.so", RTLD_LAZY)) /*|| !(pthread_lib_handle = dlopen(last = "libpthread.so", RTLD_LAZY))*/) fprintf(stderr, "LSCRIU (%d): failed to dlopen %s: %s - ignore CRIU\n", getpid(), last, dlerror()); else if (!(s_lscapi_dump_me = dlsym(lib_handle, last = "lscapi_dump_me")) || !(s_lscapi_prepare_me = dlsym(lib_handle, last = "lscapi_prepare_me")) || !(psem_open = dlsym(pthread_lib_handle, last = "sem_open")) || !(psem_post = dlsym(pthread_lib_handle, last = "sem_post")) || !(psem_close = dlsym(pthread_lib_handle, last = "sem_close"))) fprintf(stderr, "LSCRIU (%d): failed to dlsym %s: %s - ignore CRIU\n", getpid(), last, dlerror()); else error = 0; if (error) { // close the dll handles so we release the resources if (lib_handle) dlclose(lib_handle); if (pthread_lib_handle) dlclose(pthread_lib_handle); return -1; } } return 0; } static void LSCRIU_Wink_Server_is_Ready(void) { char sem_name[60]; if (s_native) { // Not used for native return; } if (getenv("LSAPI_UNIQE")) snprintf(sem_name, sizeof sem_name - 1, "lsphp[hash=%s].is_ready", getenv("LSAPI_UNIQE")); else snprintf(sem_name, sizeof sem_name - 1, "lsphp[euid=0x%x].is_ready", geteuid()); sem_t *is_ready_sem = psem_open(sem_name, O_RDWR); if (is_ready_sem) { if (psem_post(is_ready_sem) < 0) lsapi_error(sem_name, errno); if (psem_close(is_ready_sem) < 0) lsapi_error(sem_name, errno); } else if (errno != ENOENT) lsapi_error(sem_name, errno); } /* To reset server state to proper initial state after restoring server process from CRIU image */ //static void reset_server_state( void ); #if defined(__FreeBSD__) # include #endif #ifndef __CMSG_ALIGN #define __CMSG_ALIGN(p) (((u_int)(p) + sizeof(int) - 1) &~(sizeof(int) - 1)) #endif /* Length of the contents of a control message of length len */ #ifndef CMSG_LEN #define CMSG_LEN(len) (__CMSG_ALIGN(sizeof(struct cmsghdr)) + (len)) #endif /* Length of the space taken up by a padded control message of length len */ #ifndef CMSG_SPACE #define CMSG_SPACE(len) (__CMSG_ALIGN(sizeof(struct cmsghdr)) + __CMSG_ALIGN(len)) #endif static char *LSCRIU_Error_File_Name(char *pchFile, int max_len) { const char *pchDefaultSocketPath = "/tmp/"; const char *pchDefaultLogFileName = "lsws_error.log"; snprintf(pchFile, max_len, "%s%s", pchDefaultSocketPath, pchDefaultLogFileName); return pchFile; } #ifdef LSAPILIB_DEBUG_CRIU static void LSCRIU_Debugging(void) { char *pchCRIUDebug; pchCRIUDebug = getenv("LSAPI_CRIU_DEBUG"); if (!pchCRIUDebug) pchCRIUDebug = getenv("LSCAPI_CRIU_DEBUG"); //fprintf(stderr,"(%d) LSCRIU: CRIU debug environment variable: %s\n", // getpid(), pchCRIUDebug); // I've made it easy to turn on debugging. CloudLinux Apache sets // LSCAPI_CRIU_DEBUG to nothing to indicate it's on. Sigh. if ((!pchCRIUDebug) || ((!*pchCRIUDebug) || (*pchCRIUDebug == '0') || (*pchCRIUDebug == 'f') || (*pchCRIUDebug == 'F') || (((*pchCRIUDebug == 'O') || (*pchCRIUDebug == 'o')) && ((*(pchCRIUDebug + 1)) && ((*(pchCRIUDebug + 1) == 'F') || (*(pchCRIUDebug + 1) == 'f')))))) { lscriu_dbg("LSCRIU (%d): CRIU Debugging disabled by environment\n", getpid()); s_criu_debug = 0; } else { s_criu_debug = 1; lscriu_dbg("LSCRIU (%d): CRIU Debugging enabled by environment\n", getpid()); fprintf(stderr,"LSCRIU (%d): CRIU debug environment variable: %s\n", getpid(), pchCRIUDebug); } } static void LSCRIU_Restored_Error(int iFatal, char *format, ...) { // This routine deals with the awful situation of trying to get info while the stderr handle is closed on purpose. int iOldUMask; int iFd = -1; char chFile[1024]; if (!iFatal) { // LSCRIU_Debugging(); if (!s_criu_debug) { // Debugging message and debugging is off return; } } if (!LSCRIU_Error_File_Name(chFile, sizeof(chFile))) { // We're done here...nowhere to write return; } iOldUMask = umask(0); iFd = open( chFile, O_WRONLY | O_APPEND | O_CREAT, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH); umask(iOldUMask); if (iFd >= 0) { char chFullMessage[0x1000]; struct timeb sTimeb; struct tm sTm; ftime(&sTimeb); localtime_r(&sTimeb.time,&sTm); va_list ap; va_start(ap, format); char buf[0x1000]; vsnprintf(buf, sizeof(buf), format, ap); va_end(ap); int n = snprintf(chFullMessage, sizeof(chFullMessage), "%04d-%02d-%02d %02d:%02d:%02d.%03d: LSCRIU (%d): %s %s\n", sTm.tm_year + 1900, sTm.tm_mon + 1, sTm.tm_mday, sTm.tm_hour, sTm.tm_min, sTm.tm_sec, sTimeb.millitm, getpid(), iFatal ? "FATAL! " : "(debug) ", buf); if (n > (int)sizeof(chFullMessage)) n = sizeof(chFullMessage); write(iFd, chFullMessage, n); close(iFd); } } #else // no debugging static void inline LSCRIU_Debugging(void) {} static void inline LSCRIU_Restored_Error(int iFatal, char *format, ...) {} #endif static ssize_t read_fd(int fd, void *ptr, size_t nbytes, int *recvfd) { struct msghdr msg; struct iovec iov[1]; ssize_t n; #ifdef HAVE_MSGHDR_MSG_CONTROL union { struct cmsghdr cm; char control[CMSG_SPACE(sizeof(int))]; } control_un; struct cmsghdr *cmptr; msg.msg_control = control_un.control; msg.msg_controllen = sizeof(control_un.control); #else int newfd; msg.msg_accrights = (caddr_t) &newfd; msg.msg_accrightslen = sizeof(int); #endif msg.msg_name = NULL; msg.msg_namelen = 0; iov[0].iov_base = ptr; iov[0].iov_len = nbytes; msg.msg_iov = iov; msg.msg_iovlen = 1; if ( (n = recvmsg(fd, &msg, 0)) <= 0) return(n); #ifdef HAVE_MSGHDR_MSG_CONTROL if ( (cmptr = CMSG_FIRSTHDR(&msg)) != NULL && cmptr->cmsg_len == CMSG_LEN(sizeof(int))) { if (cmptr->cmsg_level != SOL_SOCKET) { LSCRIU_Restored_Error(1, "control level != SOL_SOCKET"); return(-1); } if (cmptr->cmsg_type != SCM_RIGHTS) { LSCRIU_Restored_Error(1, "control type != SCM_RIGHTS"); return(-1); } *recvfd = *((int *) CMSG_DATA(cmptr)); } else *recvfd = -1; /* descriptor was not passed */ #else /* *INDENT-OFF* */ if (msg.msg_accrightslen == sizeof(int)) *recvfd = newfd; else *recvfd = -1; /* descriptor was not passed */ /* *INDENT-ON* */ #endif return(n); } static char *CloudLinux_Socket_Name(pid_t iPidDumped, char chFullName[], int iMaxSize) { snprintf(chFullName,iMaxSize,"/tmp/%lu.sock",iPidDumped); return chFullName; } static int LSCRIU_Receive_Handles(char *pchSocketPath, pid_t *piPidSender, int iDumped) { time_t iTime; int iError = 0; time(&iTime); LSCRIU_Restored_Error(0, "Receive handles on %s and then Reset requests", pchSocketPath); { int fdSocket = -1; int fdConnected = -1; int fdZero = -1; int fdTwo = -1; int fdSave = -1; struct sockaddr_un sSockaddrUn, sSockaddrUnRemote; int iRc, iRemoteLength; char chSocketPath[SUN_PATH_MAX]; int path_len = strlen(pchSocketPath); if (path_len > (int)sizeof(chSocketPath) - 1) return -1; memmove(chSocketPath, pchSocketPath, path_len + 1); pchSocketPath = chSocketPath; fdSave = g_req.m_fdListen; LSCRIU_Restored_Error(0, "Opening domain socket defined at " "LSCAPI_CRIU_SOCKET_NAME: %s, comm #%d, %s", pchSocketPath, fdSave, iDumped ? "DUMP" : "RESTORE"); // Before listening, let's delete it, just in case fdSocket = socket(AF_UNIX, SOCK_STREAM, 0); if (fdSocket == -1) { LSCRIU_Restored_Error(1, "Error performing simple socket call: %s", strerror(errno)); iError = 1; } else { memset(&sSockaddrUn, 0, sizeof(sSockaddrUn)); sSockaddrUn.sun_family = AF_UNIX; memmove(sSockaddrUn.sun_path, pchSocketPath, path_len); iRc = bind(fdSocket, (struct sockaddr *) &sSockaddrUn, sizeof(sSockaddrUn)); if (iRc == -1) { LSCRIU_Restored_Error( 1, "Error binding socket %s: %s", pchSocketPath, strerror(errno)); iError = 1; } } if (!iError) { iRc = listen(fdSocket, 5); if (iRc == -1) { LSCRIU_Restored_Error( 1, "Error listening on socket %s: %s", pchSocketPath, strerror(errno)); iError = 1; } } if (!iError) { fdConnected = accept(fdSocket, (struct sockaddr *)&sSockaddrUnRemote, (unsigned int *)&iRemoteLength); if (fdConnected == -1) { LSCRIU_Restored_Error( 1, "Error accepting on socket %s: %s", pchSocketPath, strerror(errno)); iError = 1; } } if (!iError) { LSCRIU_Restored_Error( 0, "Connected - now receive the file handles"); // Zero is only used on a restore - it's the fd_listen handle on a dump. iRc = read_fd(fdConnected, piPidSender, sizeof(pid_t), &fdZero); if (iRc == -1) { LSCRIU_Restored_Error( 1, "Error reading handle %d through " "sockets: %s", (iDumped ? fdSave : 0), strerror(errno)); iError = 1; } } if (!iError) { LSCRIU_Restored_Error(0, "Now receive handle 2"); iRc = read_fd(fdConnected, piPidSender, sizeof(pid_t), &fdTwo); if (iRc == -1) { LSCRIU_Restored_Error( 1, "Error reading handle 2 through " "sockets: %s", strerror(errno)); iError = 1; } } if (!iError) { LSCRIU_Restored_Error( 0, "Received handles, Dup and use them. " "Received caller pid: %d, handles 1, 2 and " "fdSave=%d, fdZero=%d, fdTwo=%d", *piPidSender, fdSave, fdZero, fdTwo); // So we don't step on ourselves. if (fdSave == fdTwo) { dup2(fdTwo,2); dup2(fdZero,fdSave); } else { dup2(fdZero,fdSave); dup2(fdTwo,2); } dup2(2,1); // Theoretically I can now go back to normal tracing...but keep // logging the other way, just in case... LSCRIU_Restored_Error( 0, "One final trace before writing to " "stderr\n"); lscriu_dbg("LSCRIU (%d): Restored handles - almost ready to actually resume!\n", getpid()); LSCRIU_Restored_Error( 0, "We just wrote to stderr"); } if ((fdTwo > 3) && (fdTwo != fdSave)) { // So we don't close something we need! lscriu_dbg("LSCRIU (%d): Restored handles - about to close fdTwo: %d\n", getpid(), fdTwo); close(fdTwo); } if ((fdZero > 3) && (fdZero != fdSave)) { // We verify that we're not closing a socket we just dup-ed to! lscriu_dbg("LSCRIU (%d): Restored handles - about to close fdZero: %d\n", getpid(), fdZero); close(fdZero); } if ((fdConnected > 3) && (fdConnected != fdSave)) { lscriu_dbg("LSCRIU (%d): Restored handles - about to close fdConnected: %d\n", getpid(), fdConnected); close(fdConnected); } if ((fdSocket > 3) && (fdSocket != fdSave)) { lscriu_dbg("LSCRIU (%d): Restored handles - about to close fdSocket: %d\n", getpid(), fdSocket); close(fdSocket); } /* Leave the socket path file around so we can restore it again! lscriu_dbg("LSCRIU (%d): Closed the sockets, now delete the socket file\n", getpid()); if (pchSocketPath) { if (unlink(pchSocketPath) == -1) { lscriu_err("LSCRIU (%d): Error deleting socket path: %s: %s\n", getpid(), pchSocketPath, strerror(errno)); } else { lscriu_dbg("LSCRIU (%d): Deleted %s\n", getpid(), pchSocketPath); } } else { char buf[0x1000]; snprintf(buf, sizeof(buf) - 1, "LSCRIU (%d): Lost the LSCAPI_CRIU_SOCKET_NAME environment" " variable", getpid()); fprintf(stderr, "%s\n", buf ); LSCRIU_Restored_Error(1, buf ); } */ } return(iError ? -1 : 0); } /* This is pretty standard code taken from: * http://www.cs.cmu.edu/afs/cs/academic/class/15213-f00/unpv12e/lib/write_fd.c * But also in UNIX Network Programming */ static ssize_t write_fd(int fd, void *ptr, size_t nbytes, int sendfd) { struct msghdr msg; struct iovec iov[1]; #ifdef HAVE_MSGHDR_MSG_CONTROL union { struct cmsghdr cm; char control[CMSG_SPACE(sizeof(int))]; } control_un; struct cmsghdr *cmptr; msg.msg_control = control_un.control; msg.msg_controllen = sizeof(control_un.control); cmptr = CMSG_FIRSTHDR(&msg); cmptr->cmsg_len = CMSG_LEN(sizeof(int)); cmptr->cmsg_level = SOL_SOCKET; cmptr->cmsg_type = SCM_RIGHTS; *((int *) CMSG_DATA(cmptr)) = sendfd; #else msg.msg_accrights = (caddr_t) &sendfd; msg.msg_accrightslen = sizeof(int); #endif msg.msg_name = NULL; msg.msg_namelen = 0; iov[0].iov_base = ptr; iov[0].iov_len = nbytes; msg.msg_iov = iov; msg.msg_iovlen = 1; return(sendmsg(fd, &msg, 0)); } /* int LSCRIU_Send_File_Handles(char *pchSocketName) { // Called by the child after the fork, sends the two closed handles struct sockaddr_un sSockaddrUn; int iFdSocket = -1; int iLength; int iRc; time_t iTimeEntry = 0; time_t iTimeNow; int iError = 0; int iConnected = 0; sSockaddrUn.sun_family = AF_UNIX; LSCRIU_Restored_Error(0, "Send file handles using socket file: %s", pchSocketName); strncpy(sSockaddrUn.sun_path, pchSocketName, sizeof(sSockaddrUn.sun_path)); iFdSocket = socket(AF_UNIX, SOCK_STREAM, 0); if (iFdSocket == -1) { LSCRIU_Restored_Error( 1, "Send file handles to restored images, error " "creating initial socket: %s",strerror(errno)); return(0); } iLength = strlen(sSockaddrUn.sun_path) + sizeof(sSockaddrUn.sun_family); do { iRc = connect(iFdSocket, (struct sockaddr *)&sSockaddrUn, iLength); if (iRc == -1) { time(&iTimeNow); if (!iTimeEntry) { iTimeEntry = iTimeNow; } else if (iTimeNow - iTimeEntry > 5) { LSCRIU_Restored_Error( 1, "Timed out trying to connect to " "restore handles"); iError = 1; } else { usleep(10); // Keep waiting } } else { LSCRIU_Restored_Error(0, "Connected to restored child to send " "handles."); iConnected = 1; } } while ((!iConnected) && (!iError)); if (iConnected) { pid_t iPid = LSAPI_Get_ppid(); if (!iPid) { iPid = getpid(); } if (write_fd(iFdSocket, &iPid, sizeof(iPid), g_req.m_fdListen) == -1) { LSCRIU_Restored_Error( 1, "Error writing listen socket #%d to " "parent: %s", g_req.m_fdListen, strerror(errno)); iError = 1; } else if (write_fd(iFdSocket, &iPid, sizeof(iPid), 2) == -1) { LSCRIU_Restored_Error( 1, "Error writing socket #2 to parent: %s", strerror(errno)); iError = 1; } else { LSCRIU_Restored_Error(0, "Sockets sent to child - it can now perform" " the function"); } } if (iFdSocket != -1) { close(iFdSocket); } return(!iError); } */ static int LSCRIU_Native_Dump(pid_t iPid, char *pchSocketName, char *pchSocketPath, char *pchImagePath, int iFdNative) { criu_native_dump_t criu_native_dump; char *pchLastSlash; criu_native_dump_response_t criu_native_dump_response; criu_native_dump.m_iPidToDump = iPid; strncpy(criu_native_dump.m_chServiceAddress, pchSocketPath, sizeof(criu_native_dump.m_chServiceAddress)); strncpy(criu_native_dump.m_chImageDirectory, pchImagePath, sizeof(criu_native_dump.m_chImageDirectory)); strncpy(criu_native_dump.m_chSocketDir, pchSocketName, sizeof(criu_native_dump.m_chSocketDir)); pchLastSlash = strrchr(criu_native_dump.m_chSocketDir,'/'); if (pchLastSlash) { pchLastSlash++; (*pchLastSlash) = 0; } if (write(iFdNative, &criu_native_dump, sizeof(criu_native_dump)) == -1) { lscriu_err("LSCRIU (%d): Error sending dump request to the listener: %s\n", getpid(), strerror(errno)); return(-1); } lscriu_dbg("LSCRIU (%d): Sent the dump request to the listener\n", getpid()); //while (sleep(7200)); if (read(iFdNative, &criu_native_dump_response, sizeof(criu_native_dump_response)) == -1) { // The test will actually fail it! //LSCRIU_Restored_Error(1, "Error reading dump socket #%d from parent: %s", // iFdNative, strerror(errno)); //return(-1); } return(0); } static void LSCRIU_CloudLinux_Checkpoint(void) { int iRet; if ((!s_native) && (!s_lscapi_dump_me)) { lscriu_dbg("LSCRIU (%d): Not native and unable to dump - abandon one-time " "dump\n", getpid()); return; } // NOTE - NOTE - NOTE // In the CloudLinux implementation they do not do a prepare_me. Why, I // don't know, so I won't either! //iRet = s_lscapi_prepare_me(); //if (iRet) { //LSCRIU_Restored_Error(1, "lscapi_prepare_me failed: %s", // strerror(errno)); //lscriu_err("LSCRIU (%d): failed to lscapi_prepare_me: %s\n", // getpid(), strerror(errno)); //But keep going anyway! Not fatal yet //} iRet = s_lscapi_dump_me(); if (iRet < 0) { char *pchError; lscriu_err("LSCRIU: CloudLinux dump of PID: %d, error: %s\n", getpid(), strerror(errno)); } if (iRet == 0) { // Dumped. To continue the child must send us the handles back lscriu_err("LSCRIU: Successful CloudLinux dump of PID: %d\n", getpid()); } else { s_restored = 1; LSAPI_reset_server_state(); /* Here we have restored the php process, so we should to tell (via semaphore) mod_lsapi that we are started and ready to receive data. */ LSCRIU_Wink_Server_is_Ready(); lscriu_err("LSCRIU: Successful CloudLinux restore of PID: %d, parent: %d.\n", getpid(), getppid()); } LSCRIU_Set_Initial_Start_Reqs(0); } static void LSCRIU_try_checkpoint(void) { int iRet; pid_t iPid; pid_t iPidDump = getpid(); int iFdNative; char *pchImagePath; char *pchSocketPath; char *pchSocketName; if (s_tried_checkpoint) { lscriu_dbg("LSCRIU (%d): Already tried checkpoint - one time per customer\n", getpid()); return; } lscriu_dbg("LSCRIU (%d): Trying checkpoint\n", getpid()); s_tried_checkpoint = 1; if (!s_native) { LSCRIU_CloudLinux_Checkpoint(); return; } char *pchFd; pchSocketName = getenv("LSCAPI_CRIU_SOCKET_NAME"); if (!pchSocketName) { lscriu_err("LSCRIU (%d): LSCAPI_CRIU_SOCKET_NAME internal environment " "variable not set - contact Litespeed tech support\n", getpid()); return; } unlink(pchSocketName); pchFd = getenv("LSCAPI_CRIU_SYNC_FD"); pchImagePath = getenv("LSCAPI_CRIU_IMAGE_PATH"); pchSocketPath = getenv("LSAPI_CRIU_SOCKET_PATH"); if (!pchSocketPath) { pchSocketPath = getenv("LSCAPI_CRIU_SOCKET_PATH"); } if (!pchFd) { lscriu_err("LSCRIU (%d): LSCAPI_CRIU_SYNC_FD internal environment " "variable not set - contact Litespeed tech support\n", getpid()); return; } if (!pchImagePath) { lscriu_err("LSCRIU (%d): LSCAPI_CRIU_IMAGE_PATH internal environment " "variable not set - contact Litespeed tech support\n", getpid()); return; } if (!pchSocketPath) { lscriu_err("LSCRIU (%d): LSAPI_CRIU_SOCKET_PATH internal environment " "variable not set - contact Litespeed tech support\n", getpid()); return; } lscriu_dbg("LSCRIU (%d): Checkpoint dump. ImagePath: %s, SocketName %s, " "SocketPath: %s\n", getpid(), pchImagePath, pchSocketName, pchSocketPath); iFdNative = atoi(pchFd); lscriu_dbg("LSCRIU (%d): Native checkpoint. Use filepointer %d (%s) to send " "pid %d\n", getpid(), iFdNative, pchFd, iPidDump); // Handle 0 is the connected comm handle, handle 1 and 2 are the output data // streams. We can't do a dump with 1 or 2 open. And there's no reason to // dump 0 since it will change. So on George's advice, we'll fork here, let // the child close the handles and do the dump. // On restore, the recovered child will create a domain socket, and the // parent will send it the handles it can use to continue. lscriu_dbg("LSCRIU (%d): fork!\n", getpid()); iPid = fork(); if (iPid < 0) { lscriu_err("LSCRIU (%d): Can't checkpoint due to a fork error: %s\n", getpid(), strerror(errno)); return; } if (iPid > 0) { // We're the parent. Close the handles, do the dump and receive them // back from the child or the parent //close(0); // Let the child do the dump usleep(1); // Get the child to run and close everything so we can dump pid_t iPidParent = getppid(); iRet = LSCRIU_Native_Dump(iPid, pchSocketName, pchSocketPath, pchImagePath, iFdNative); if (iRet == 0) { if (iPidParent != getppid()) lscriu_dbg("LSCRIU (%d): PID %d dumped to disk; PID %d killed in " "prior message - is this the restore?\n", getpid(), iPidDump, iPid); else lscriu_err("LSCRIU (%d): PID %d dumped to disk and killed in " "prior message\n", getpid(), iPid); } else lscriu_err("LSCRIU (%d): Native dump of PID: %d FAILED\n", getpid(), iPid); LSCRIU_Restored_Error(1, "Restored child process - this is unexpected!"); } else { int iResult; pid_t iPidSender; pid_t iPidParent = getppid(); setsid(); close(1); close(2); close(g_req.m_fdListen); // If we don't do this we're dead... close(iFdNative); // Now get restored. We know if we're restored if the ppid changes! // If we're dumped, we're killed (no use worrying about that!). { time_t iTimeStart = 0; time_t iTimeNow; int iRestored = 0; do { usleep(10); time(&iTimeNow); if (!iTimeStart) { iTimeStart = iTimeNow; } else if ((iPidParent != getppid()) || (iTimeNow - iTimeStart > 10)) { iRestored = 1; } else if (iTimeNow - iTimeStart > 5) { LSCRIU_Restored_Error(1, "Timed out waiting to be dumped"); exit(1); } } while (!iRestored); } LSCRIU_Restored_Error(0, "Restored!"); iRet = LSCRIU_Receive_Handles(pchSocketName, &iPidSender, 0); if (iRet == 0) { //lscriu_dbg("LSCRIU (%d): Fully restored, parent: %d.\n", getpid(), iPidSender); LSAPI_Set_Restored_Parent_Pid(iPidSender); lscriu_err("LSCRIU: Fully restored, pid: %d, parent: %d.\n", getpid(), iPidSender); LSAPI_reset_server_state(); s_restored = 1; /* Here we have restored the php process, so we should to tell(via semaphore) mod_lsapi that we are started and ready to receive data */ // Not used for native! //LSCRIU_Wink_Server_is_Ready(); } else { LSCRIU_Restored_Error(1, "Restore error - terminating"); exit(-1); } } LSCRIU_Set_Initial_Start_Reqs(0); } static int LSCRIU_Init_Env_Parameters(void) { const char *p; int n; // LSAPI_CRIU is not passed down in Apache. So we won't require it //p = getenv("LSAPI_CRIU"); //if ((p) && // (*p) && // ((*p == '1') || // (*p == 'T') || // (*p == 't') || // (*p == 'Y') || // (*p == 'y') || // (((*p == 'O') || // (*p == 'o')) && // (((*(p + 1)) == 'N') || // ((*(p + 1)) == 'n'))))) { // lscriu_dbg("LSCRIU (%d): Enabled by environment.\n", getpid()); // // We're enabled! //} //else { // lscriu_dbg("LSCRIU (%d): Disabled by environment.\n", getpid()); // return 0; //} p = getenv("LSAPI_INITIAL_START"); if (!p) p = getenv("LSAPI_BACKEND_INITIAL_START"); if (p) { n = atoi(p); if (n > 0) { lscriu_dbg("LSCRIU (%d): Set start requests based on environment (%d)\n", getpid(), n); LSCRIU_Set_Initial_Start_Reqs(n); } else { lscriu_dbg("LSCRIU (%d): LSAPI_INITIAL_START set to 0 disabled\n", getpid()); return 0; } } else { lscriu_dbg("LSCRIU (%d): LSAPI_INITIAL_START NOT set - disabled\n", getpid()); return 0; } if (LSAPI_Is_Listen()) { lscriu_dbg("LSCRIU (%d): Listening...\n", getpid()); GlobalCounterType_t gc_type = CRIU_GCOUNTER_SHM; char *env; if ((env = getenv("LSAPI_CRIU_USE_SHM"))) { // CloudLinux doc: Off (shared memory) or Signals. // Litespeed doc: On (shared memory) or Signals // So just check the first character for an 'S' and if not, then // use shared memory. Pipe support is lost (sigh). if ((*env == 'S') || (*env == 's')) gc_type = CRIU_GCOUNTER_SIG; // Just assume the rest is signals // else use the default of shared memory } else if ((env = getenv("LSAPI_SIGNALS"))) { if ((*env == '1') || (*env == 'Y') || (*env == 'y') || (*env == 'T') || (*env == 't') || (((*env == 'O') || (*env == 'o')) && ((*(env + 1) == 'N') || (*(env + 1) == 'n')))) gc_type = CRIU_GCOUNTER_SIG; else if (*env == 2) gc_type = CRIU_GCOUNTER_PIPE; // The only case for pipe //else use the default of shared memory } if (gc_type != CRIU_GCOUNTER_SHM) { lscriu_dbg("LSCRIU (%d): Use %s\n", getpid(), gc_type == CRIU_GCOUNTER_SIG ? "signals" : "pipe"); lsapi_criu_signal(SIGUSR2, lsapi_siguser2); } else lscriu_dbg("LSCRIU (%d): Use shared memory\n", getpid()); LSCRIU_Set_Global_Counter_Type(gc_type); } else lscriu_dbg("LSCRIU (%d): NOT Listening\n", getpid()); //unset_lsapi_envs(); return 0; } void LSCRIU_inc_req_procssed() { if (!LSCRIU_Get_Global_Counter_Type()) { ++s_requests_count; } lscriu_dbg("LSCRIU (%d): s_requests_count %d counter %d\n", getpid(), s_requests_count, s_initial_start_reqs); if (s_initial_start_reqs > 0 && s_requests_count <= s_initial_start_reqs) { if (LSCRIU_Get_Global_Counter_Type() == CRIU_GCOUNTER_SHM) { LSCRIU_Increase_Global_Counter(); if (s_requests_count >= s_initial_start_reqs) { //Maybe this time we can stop to send signal and wait for //1 second of select timeout //kill( LSCRIU_Get_ppid(), SIGUSR2 ); lscriu_dbg("LSCRIU (%d): Time to dump main process with semaphore\n", getpid()); } } else { kill(LSAPI_Get_ppid(), SIGUSR2); lscriu_dbg("LSCRIU (%d): Send kill to main process with signals\n", getpid()); } } } static void LSCRIU_on_timer(void) { lscriu_dbg("LSCRIU (%d): LSCRIU_on_timer\n", getpid()); if (LSCRIU_need_checkpoint()) { LSCRIU_try_checkpoint(); } } int LSCRIU_Init(void) { LSCRIU_Debugging(); LSCRIU_Init_Env_Parameters(); if (s_initial_start_reqs) { if (LSCRIU_load_liblscapi() == -1) s_initial_start_reqs = 0; } if (s_initial_start_reqs) { LSCRIU_Wink_Server_is_Ready(); lscriu_dbg("LSCRIU (%d): LSAPI_Register_Pgrp_Timer_Callback\n", getpid()); LSAPI_Register_Pgrp_Timer_Callback(LSCRIU_on_timer); LSCRIU_Init_Global_Counter(0); } return s_initial_start_reqs > 0; }