1 /* 2 * Copyright (C) 2007 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #define LOG_TAG "Zygote" 18 19 #include <cutils/sockets.h> 20 #include <cutils/zygote.h> 21 #include <cutils/log.h> 22 23 #include <stdio.h> 24 #include <string.h> 25 #include <errno.h> 26 #include <time.h> 27 #include <stdint.h> 28 #include <stdlib.h> 29 #include <unistd.h> 30 #include <arpa/inet.h> 31 #include <sys/types.h> 32 #include <sys/socket.h> 33 34 #define ZYGOTE_SOCKET "zygote" 35 36 #define ZYGOTE_RETRY_COUNT 1000 37 #define ZYGOTE_RETRY_MILLIS 500 38 39 static void replace_nl(char *str); 40 41 /* 42 * If sendStdio is non-zero, the current process's stdio file descriptors 43 * will be sent and inherited by the spawned process. 44 */ 45 static int send_request(int fd, int sendStdio, int argc, const char **argv) 46 { 47 #ifndef HAVE_ANDROID_OS 48 // not supported on simulator targets 49 //LOGE("zygote_* not supported on simulator targets"); 50 return -1; 51 #else /* HAVE_ANDROID_OS */ 52 uint32_t pid; 53 int i; 54 struct iovec ivs[2]; 55 struct msghdr msg; 56 char argc_buffer[12]; 57 const char *newline_string = "\n"; 58 struct cmsghdr *cmsg; 59 char msgbuf[CMSG_SPACE(sizeof(int) * 3)]; 60 int *cmsg_payload; 61 ssize_t ret; 62 63 memset(&msg, 0, sizeof(msg)); 64 memset(&ivs, 0, sizeof(ivs)); 65 66 // First line is arg count 67 snprintf(argc_buffer, sizeof(argc_buffer), "%d\n", argc); 68 69 ivs[0].iov_base = argc_buffer; 70 ivs[0].iov_len = strlen(argc_buffer); 71 72 msg.msg_iov = ivs; 73 msg.msg_iovlen = 1; 74 75 if (sendStdio != 0) { 76 // Pass the file descriptors with the first write 77 msg.msg_control = msgbuf; 78 msg.msg_controllen = sizeof msgbuf; 79 80 cmsg = CMSG_FIRSTHDR(&msg); 81 82 cmsg->cmsg_len = CMSG_LEN(3 * sizeof(int)); 83 cmsg->cmsg_level = SOL_SOCKET; 84 cmsg->cmsg_type = SCM_RIGHTS; 85 86 cmsg_payload = (int *)CMSG_DATA(cmsg); 87 cmsg_payload[0] = STDIN_FILENO; 88 cmsg_payload[1] = STDOUT_FILENO; 89 cmsg_payload[2] = STDERR_FILENO; 90 } 91 92 do { 93 ret = sendmsg(fd, &msg, MSG_NOSIGNAL); 94 } while (ret < 0 && errno == EINTR); 95 96 if (ret < 0) { 97 return -1; 98 } 99 100 // Only send the fd's once 101 msg.msg_control = NULL; 102 msg.msg_controllen = 0; 103 104 // replace any newlines with spaces and send the args 105 for (i = 0; i < argc; i++) { 106 char *tofree = NULL; 107 const char *toprint; 108 109 toprint = argv[i]; 110 111 if (strchr(toprint, '\n') != NULL) { 112 tofree = strdup(toprint); 113 toprint = tofree; 114 replace_nl(tofree); 115 } 116 117 ivs[0].iov_base = (char *)toprint; 118 ivs[0].iov_len = strlen(toprint); 119 ivs[1].iov_base = (char *)newline_string; 120 ivs[1].iov_len = 1; 121 122 msg.msg_iovlen = 2; 123 124 do { 125 ret = sendmsg(fd, &msg, MSG_NOSIGNAL); 126 } while (ret < 0 && errno == EINTR); 127 128 if (tofree != NULL) { 129 free(tofree); 130 } 131 132 if (ret < 0) { 133 return -1; 134 } 135 } 136 137 // Read the pid, as a 4-byte network-order integer 138 139 ivs[0].iov_base = &pid; 140 ivs[0].iov_len = sizeof(pid); 141 msg.msg_iovlen = 1; 142 143 do { 144 do { 145 ret = recvmsg(fd, &msg, MSG_NOSIGNAL | MSG_WAITALL); 146 } while (ret < 0 && errno == EINTR); 147 148 if (ret < 0) { 149 return -1; 150 } 151 152 ivs[0].iov_len -= ret; 153 ivs[0].iov_base += ret; 154 } while (ivs[0].iov_len > 0); 155 156 pid = ntohl(pid); 157 158 return pid; 159 #endif /* HAVE_ANDROID_OS */ 160 } 161 162 int zygote_run_wait(int argc, const char **argv, void (*post_run_func)(int)) 163 { 164 int fd; 165 int pid; 166 int err; 167 const char *newargv[argc + 1]; 168 169 fd = socket_local_client(ZYGOTE_SOCKET, 170 ANDROID_SOCKET_NAMESPACE_RESERVED, AF_LOCAL); 171 172 if (fd < 0) { 173 return -1; 174 } 175 176 // The command socket is passed to the peer as close-on-exec 177 // and will close when the peer dies 178 newargv[0] = "--peer-wait"; 179 memcpy(newargv + 1, argv, argc * sizeof(*argv)); 180 181 pid = send_request(fd, 1, argc + 1, newargv); 182 183 if (pid > 0 && post_run_func != NULL) { 184 post_run_func(pid); 185 } 186 187 // Wait for socket to close 188 do { 189 int dummy; 190 err = read(fd, &dummy, sizeof(dummy)); 191 } while ((err < 0 && errno == EINTR) || err != 0); 192 193 do { 194 err = close(fd); 195 } while (err < 0 && errno == EINTR); 196 197 return 0; 198 } 199 200 /** 201 * Spawns a new dalvik instance via the Zygote process. The non-zygote 202 * arguments are passed to com.android.internal.os.RuntimeInit(). The 203 * first non-option argument should be a class name in the system class path. 204 * 205 * The arg list may start with zygote params such as --set-uid. 206 * 207 * If sendStdio is non-zero, the current process's stdio file descriptors 208 * will be sent and inherited by the spawned process. 209 * 210 * The pid of the child process is returned, or -1 if an error was 211 * encountered. 212 * 213 * zygote_run_oneshot waits up to ZYGOTE_RETRY_COUNT * 214 * ZYGOTE_RETRY_MILLIS for the zygote socket to be available. 215 */ 216 int zygote_run_oneshot(int sendStdio, int argc, const char **argv) 217 { 218 int fd = -1; 219 int err; 220 int i; 221 int retries; 222 int pid; 223 const char **newargv = argv; 224 const int newargc = argc; 225 226 for (retries = 0; (fd < 0) && (retries < ZYGOTE_RETRY_COUNT); retries++) { 227 if (retries > 0) { 228 struct timespec ts; 229 230 memset(&ts, 0, sizeof(ts)); 231 ts.tv_nsec = ZYGOTE_RETRY_MILLIS * 1000 * 1000; 232 233 do { 234 err = nanosleep (&ts, &ts); 235 } while (err < 0 && errno == EINTR); 236 } 237 fd = socket_local_client(ZYGOTE_SOCKET, AF_LOCAL, 238 ANDROID_SOCKET_NAMESPACE_RESERVED); 239 } 240 241 if (fd < 0) { 242 return -1; 243 } 244 245 pid = send_request(fd, 0, newargc, newargv); 246 247 do { 248 err = close(fd); 249 } while (err < 0 && errno == EINTR); 250 251 return pid; 252 } 253 254 /** 255 * Replaces all occurrances of newline with space. 256 */ 257 static void replace_nl(char *str) 258 { 259 for(; *str; str++) { 260 if (*str == '\n') { 261 *str = ' '; 262 } 263 } 264 } 265 266 267 268
