int main(int argc, char **argv) { const char * rilLibPath = NULL; char **rilArgv; void *dlHandle; const RIL_RadioFunctions *(*rilInit)(const struct RIL_Env *, int, char **); const RIL_RadioFunctions *(*rilInitSocket)(const struct RIL_EnvSocket *, int, char **); const RIL_RadioFunctions *funcs; const RIL_RadioFunctionsSocket *funcsSocket; char libPath[PROPERTY_VALUE_MAX]; char socPath[PROPERTY_VALUE_MAX]; unsigned char hasLibArgs = 0; int i; const char *clientId = NULL; RLOGD("**RIL Daemon Started**"); RLOGD("**RILd param count=%d**", argc); #ifdef MTK_RIL_MD2 RLOGD("RILD started (MD2)"); #else RLOGD("RILD started"); #endif if (mtkInit() == -1) goto done; umask(S_IRGRP | S_IWGRP | S_IXGRP | S_IROTH | S_IWOTH | S_IXOTH); for (i = 1; i < argc ;) { if (0 == strcmp(argv[i], "-l") && (argc - i > 1)) { rilLibPath = argv[i + 1]; i += 2; } else if (0 == strcmp(argv[i], "--")) { i++; hasLibArgs = 1; break; } else if (0 == strcmp(argv[i], "-c") && (argc - i > 1)) { clientId = argv[i+1]; i += 2; } else { usage(argv[0]); } } if (clientId == NULL) { clientId = "0"; } else if (atoi(clientId) >= MAX_RILDS) { RLOGE("Max Number of rild's supported is: %d", MAX_RILDS); exit(0); } if (strncmp(clientId, "0", MAX_CLIENT_ID_LENGTH)) { RIL_setRilSocketName(strncat(rild, clientId, MAX_SOCKET_NAME_LENGTH)); } if (rilLibPath == NULL) { #ifdef MTK_RIL_MD2 if ( 0 == property_get(LIB_PATH_PROPERTY, libPath, "/system/lib/mtk-rilmd2.so")) { #else if ( 0 == property_get(LIB_PATH_PROPERTY, libPath, "/system/lib/mtk-ril.so")) { #endif // No lib sepcified on the command line, and nothing set in props. // Assume "no-ril" case. goto done; } else { rilLibPath = libPath; } } /* special override when in the emulator */ #if 1 { static char* arg_overrides[5]; static char arg_device[32]; int done = 0; #ifdef MTK_RIL_MD2 #define REFERENCE_RIL_PATH "/system/lib/mtk-rilmd2.so" #else #define REFERENCE_RIL_PATH "/system/lib/mtk-ril.so" #endif /* first, read /proc/cmdline into memory */ char buffer[1024], *p, *q; int len; int fd = open("/proc/cmdline",O_RDONLY); if (fd < 0) { RLOGD("could not open /proc/cmdline:%s", strerror(errno)); goto OpenLib; } do { len = read(fd,buffer,sizeof(buffer)); } while (len == -1 && errno == EINTR); if (len < 0) { RLOGD("could not read /proc/cmdline:%s", strerror(errno)); close(fd); goto OpenLib; } close(fd); if (strstr(buffer, "android.qemud=") != NULL) { /* the qemud daemon is launched after rild, so * give it some time to create its GSM socket */ int tries = 5; #define QEMUD_SOCKET_NAME "qemud" while (1) { int fd; sleep(1); fd = qemu_pipe_open("qemud:gsm"); if (fd < 0) { fd = socket_local_client( QEMUD_SOCKET_NAME, ANDROID_SOCKET_NAMESPACE_RESERVED, SOCK_STREAM ); } if (fd >= 0) { close(fd); snprintf( arg_device, sizeof(arg_device), "%s/%s", ANDROID_SOCKET_DIR, QEMUD_SOCKET_NAME ); arg_overrides[1] = "-s"; arg_overrides[2] = arg_device; done = 1; break; } RLOGD("could not connect to %s socket: %s", QEMUD_SOCKET_NAME, strerror(errno)); if (--tries == 0) break; } if (!done) { RLOGE("could not connect to %s socket (giving up): %s", QEMUD_SOCKET_NAME, strerror(errno)); while(1) sleep(0x00ffffff); } } /* otherwise, try to see if we passed a device name from the kernel */ if (!done) do { #define KERNEL_OPTION "android.ril=" #define DEV_PREFIX "/dev/" p = strstr( buffer, KERNEL_OPTION ); if (p == NULL) break; p += sizeof(KERNEL_OPTION)-1; q = strpbrk( p, " \t\n\r" ); if (q != NULL) *q = 0; snprintf( arg_device, sizeof(arg_device), DEV_PREFIX "%s", p ); arg_device[sizeof(arg_device)-1] = 0; arg_overrides[1] = "-d"; arg_overrides[2] = arg_device; done = 1; } while (0); if (done) { argv = arg_overrides; argc = 3; i = 1; hasLibArgs = 1; rilLibPath = REFERENCE_RIL_PATH; RLOGD("overriding with %s %s", arg_overrides[1], arg_overrides[2]); } } OpenLib: #endif switchUser(); #ifdef MTK_RIL_MD2 rilLibPath = "/system/lib/mtk-rilmd2.so"; #endif RLOGD("Open ril lib path: %s", rilLibPath); dlHandle = dlopen(rilLibPath, RTLD_NOW); if (dlHandle == NULL) { RLOGE("dlopen failed: %s", dlerror()); exit(EXIT_FAILURE); } RIL_startEventLoop(); rilInitSocket = (const int(*)(void))dlsym(dlHandle, "RIL_InitSocket"); if (rilInitSocket == NULL) { RLOGD("Vendor RIL do not need socket id!"); rilInit = (const RIL_RadioFunctions *(*)(const struct RIL_Env *, int, char **))dlsym(dlHandle, "RIL_Init"); if (rilInit == NULL) { RLOGE("RIL_Init not defined or exported in %s\n", rilLibPath); exit(EXIT_FAILURE); } } else { RLOGD("vendor RIL need socket id"); } if (hasLibArgs) { rilArgv = argv + i - 1; argc = argc -i + 1; } else { static char * newArgv[MAX_LIB_ARGS]; static char args[PROPERTY_VALUE_MAX]; rilArgv = newArgv; #ifdef MTK_RIL_MD2 property_get(LIB_ARGS_PROPERTY, args, "-d /dev/ccci2_tty0"); #else property_get(LIB_ARGS_PROPERTY, args, "-d /dev/ttyC0"); #endif argc = make_argv(args, rilArgv); } rilArgv[argc++] = "-c"; rilArgv[argc++] = clientId; RLOGD("RIL_Init argc = %d clientId = %s", argc, rilArgv[argc-1]); // Make sure there's a reasonable argv[0] rilArgv[0] = argv[0]; if (rilInitSocket == NULL) { RLOGD("Old vendor ril! so RIL_register is called"); funcs = rilInit(&s_rilEnv, argc, rilArgv); RIL_register(funcs); } else { RLOGD("New vendor ril! so RIL_registerSocket is called"); funcsSocket = rilInitSocket(&s_rilEnvSocket, argc, rilArgv); RIL_registerSocket(funcsSocket); } done: RLOGD("RIL_Init starting sleep loop"); while (true) { sleep(UINT32_MAX); } }
status_t QemuClient::connectClient(const char* param) { LOGV("%s: '%s'", __FUNCTION__, param ? param : ""); /* Make sure that client is not connected already. */ if (mPipeFD >= 0) { LOGE("%s: Qemu client is already connected", __FUNCTION__); return EINVAL; } /* Select one of the two: 'factory', or 'emulated camera' service */ if (param == NULL || *param == '\0') { /* No parameters: connect to the factory service. */ char pipe_name[512]; snprintf(pipe_name, sizeof(pipe_name), "qemud:%s", mCameraServiceName); mPipeFD = qemu_pipe_open(pipe_name); } else { /* One extra char ':' that separates service name and parameters + six * characters for 'qemud:'. This is required by qemu pipe protocol. */ char* connection_str = new char[strlen(mCameraServiceName) + strlen(param) + 8]; sprintf(connection_str, "qemud:%s:%s", mCameraServiceName, param); mPipeFD = qemu_pipe_open(connection_str); delete[] connection_str; } if (mPipeFD < 0) { LOGE("%s: Unable to connect to the camera service '%s': %s", __FUNCTION__, param ? param : "Factory", strerror(errno)); return errno ? errno : EINVAL; } return NO_ERROR; }
int pipe_openQemuPipe( Pipe* pipe, const char* pipename ) { pipe->socket = qemu_pipe_open(pipename); if (pipe->socket < 0) { fprintf(stderr, "%s: Could not open '%s' pipe: %s\n", __FUNCTION__, pipename, strerror(errno)); return -1; } return 0; }
/* Initializes connection with the adb-debug qemud service in the emulator. */ static int adb_qemu_trace_init(void) { char con_name[32]; if (adb_debug_qemu >= 0) { return 0; } /* adb debugging QEMUD service connection request. */ snprintf(con_name, sizeof(con_name), "qemud:adb-debug"); adb_debug_qemu = qemu_pipe_open(con_name); return (adb_debug_qemu >= 0) ? 0 : -1; }
void notifyHostBootComplete() { if (s_QemuMiscPipe < 0) { s_QemuMiscPipe = qemu_pipe_open(QEMU_MISC_PIPE); if (s_QemuMiscPipe < 0) { ALOGE("failed to open %s", QEMU_MISC_PIPE); return; } } char set[] = "bootcomplete"; int pipe_command_length = sizeof(set); WriteFully(s_QemuMiscPipe, &pipe_command_length, sizeof(pipe_command_length)); WriteFully(s_QemuMiscPipe, set, pipe_command_length); ReadFully(s_QemuMiscPipe, &pipe_command_length, sizeof(pipe_command_length)); if (pipe_command_length > sizeof(set) || pipe_command_length <= 0) return; ReadFully(s_QemuMiscPipe, set, pipe_command_length); }
static int qemu_channel_open_qemud_pipe( QemuChannel* channel, const char* name ) { int fd; char pipe_name[512]; snprintf(pipe_name, sizeof(pipe_name), "qemud:%s", name); fd = qemu_pipe_open(pipe_name); if (fd < 0) { D("no qemud pipe: %s", strerror(errno)); return -1; } channel->is_qemud = 1; channel->fd = fd; return 0; }
/* A worker thread that monitors host connections, and registers a transport for * every new host connection. This thread replaces server_socket_thread on * condition that adbd daemon runs inside the emulator, and emulator uses QEMUD * pipe to communicate with adbd daemon inside the guest. This is done in order * to provide more robust communication channel between ADB host and guest. The * main issue with server_socket_thread approach is that it runs on top of TCP, * and thus is sensitive to network disruptions. For instance, the * ConnectionManager may decide to reset all network connections, in which case * the connection between ADB host and guest will be lost. To make ADB traffic * independent from the network, we use here 'adb' QEMUD service to transfer data * between the host, and the guest. See external/qemu/android/adb-*.* that * implements the emulator's side of the protocol. Another advantage of using * QEMUD approach is that ADB will be up much sooner, since it doesn't depend * anymore on network being set up. * The guest side of the protocol contains the following phases: * - Connect with adb QEMUD service. In this phase a handle to 'adb' QEMUD service * is opened, and it becomes clear whether or not emulator supports that * protocol. * - Wait for the ADB host to create connection with the guest. This is done by * sending an 'accept' request to the adb QEMUD service, and waiting on * response. * - When new ADB host connection is accepted, the connection with adb QEMUD * service is registered as the transport, and a 'start' request is sent to the * adb QEMUD service, indicating that the guest is ready to receive messages. * Note that the guest will ignore messages sent down from the emulator before * the transport registration is completed. That's why we need to send the * 'start' request after the transport is registered. */ static void *qemu_socket_thread(void * arg) { /* 'accept' request to the adb QEMUD service. */ static const char _accept_req[] = "accept"; /* 'start' request to the adb QEMUD service. */ static const char _start_req[] = "start"; /* 'ok' reply from the adb QEMUD service. */ static const char _ok_resp[] = "ok"; const int port = (int) (uintptr_t) arg; int res, fd; char tmp[256]; char con_name[32]; D("transport: qemu_socket_thread() starting\n"); /* adb QEMUD service connection request. */ snprintf(con_name, sizeof(con_name), "qemud:adb:%d", port); /* Connect to the adb QEMUD service. */ fd = qemu_pipe_open(con_name); if (fd < 0) { /* This could be an older version of the emulator, that doesn't * implement adb QEMUD service. Fall back to the old TCP way. */ D("adb service is not available. Falling back to TCP socket.\n"); adb_thread_create(server_socket_thread, arg); return 0; } for(;;) { /* * Wait till the host creates a new connection. */ /* Send the 'accept' request. */ res = adb_write(fd, _accept_req, strlen(_accept_req)); if ((size_t)res == strlen(_accept_req)) { /* Wait for the response. In the response we expect 'ok' on success, * or 'ko' on failure. */ res = adb_read(fd, tmp, sizeof(tmp)); if (res != 2 || memcmp(tmp, _ok_resp, 2)) { D("Accepting ADB host connection has failed.\n"); adb_close(fd); } else { /* Host is connected. Register the transport, and start the * exchange. */ register_socket_transport(fd, "host", port, 1); adb_write(fd, _start_req, strlen(_start_req)); } /* Prepare for accepting of the next ADB host connection. */ fd = qemu_pipe_open(con_name); if (fd < 0) { D("adb service become unavailable.\n"); return 0; } } else { D("Unable to send the '%s' request to ADB service.\n", _accept_req); return 0; } } D("transport: qemu_socket_thread() exiting\n"); return 0; }
int main(int argc, char **argv) { const char * rilLibPath = NULL; char **rilArgv; void *dlHandle; const RIL_RadioFunctions *(*rilInit)(const struct RIL_Env *, int, char **); const RIL_RadioFunctions *funcs; char libPath[PROPERTY_VALUE_MAX]; unsigned char hasLibArgs = 0; int modem_type = UNKNOWN_MODEM; int i; umask(S_IRGRP | S_IWGRP | S_IXGRP | S_IROTH | S_IWOTH | S_IXOTH); for (i = 1; i < argc ;) { if (0 == strcmp(argv[i], "-l") && (argc - i > 1)) { rilLibPath = argv[i + 1]; i += 2; } else if (0 == strcmp(argv[i], "--")) { i++; hasLibArgs = 1; break; } else { usage(argv[0]); } } //Wait for device ready. if (rilLibPath == NULL) { while(UNKNOWN_MODEM == modem_type){ modem_type = runtime_3g_port_type(); ALOGD("Couldn't find proper modem, retrying..."); s_poll_device_cnt++; if (s_poll_device_cnt > MAX_POLL_DEVICE_CNT){ /* *Maybe no device right now, start to monitor *hotplug event later. */ start_uevent_monitor(); goto done; } sleep(5); } } start_uevent_monitor(); switch (modem_type){ case ZTE_MODEM: rilLibPath = REFERENCE_RIL_ZTE_PATH; break; case HUAWEI_MODEM: case AMAZON_MODEM: default: if (!rilLibPath) rilLibPath = REFERENCE_RIL_DEF_PATH; break; } RLOGE("ril lib path=%s\n", rilLibPath); if (rilLibPath == NULL) { if ( 0 == property_get(LIB_PATH_PROPERTY, libPath, NULL)) { // No lib sepcified on the command line, and nothing set in props. // Assume "no-ril" case. goto done; } else { rilLibPath = libPath; } } /* special override when in the emulator */ #if 1 { static char* arg_overrides[3]; static char arg_device[32]; int done = 0; #define REFERENCE_RIL_PATH "/system/lib/libreference-ril.so" /* first, read /proc/cmdline into memory */ char buffer[1024], *p, *q; int len; int fd = open("/proc/cmdline",O_RDONLY); if (fd < 0) { RLOGD("could not open /proc/cmdline:%s", strerror(errno)); goto OpenLib; } do { len = read(fd,buffer,sizeof(buffer)); } while (len == -1 && errno == EINTR); if (len < 0) { RLOGD("could not read /proc/cmdline:%s", strerror(errno)); close(fd); goto OpenLib; } close(fd); if (strstr(buffer, "android.qemud=") != NULL) { /* the qemud daemon is launched after rild, so * give it some time to create its GSM socket */ int tries = 5; #define QEMUD_SOCKET_NAME "qemud" while (1) { int fd; sleep(1); fd = qemu_pipe_open("qemud:gsm"); if (fd < 0) { fd = socket_local_client( QEMUD_SOCKET_NAME, ANDROID_SOCKET_NAMESPACE_RESERVED, SOCK_STREAM ); } if (fd >= 0) { close(fd); snprintf( arg_device, sizeof(arg_device), "%s/%s", ANDROID_SOCKET_DIR, QEMUD_SOCKET_NAME ); arg_overrides[1] = "-s"; arg_overrides[2] = arg_device; done = 1; break; } RLOGD("could not connect to %s socket: %s", QEMUD_SOCKET_NAME, strerror(errno)); if (--tries == 0) break; } if (!done) { RLOGE("could not connect to %s socket (giving up): %s", QEMUD_SOCKET_NAME, strerror(errno)); while(1) sleep(0x00ffffff); } } /* otherwise, try to see if we passed a device name from the kernel */ if (!done) do { #define KERNEL_OPTION "android.ril=" #define DEV_PREFIX "/dev/" p = strstr( buffer, KERNEL_OPTION ); if (p == NULL) break; p += sizeof(KERNEL_OPTION)-1; q = strpbrk( p, " \t\n\r" ); if (q != NULL) *q = 0; snprintf( arg_device, sizeof(arg_device), DEV_PREFIX "%s", p ); arg_device[sizeof(arg_device)-1] = 0; arg_overrides[1] = "-d"; arg_overrides[2] = arg_device; done = 1; } while (0); if (done) { argv = arg_overrides; argc = 3; i = 1; hasLibArgs = 1; rilLibPath = REFERENCE_RIL_PATH; RLOGD("overriding with %s %s", arg_overrides[1], arg_overrides[2]); } } OpenLib: #endif switchUser(); dlHandle = dlopen(rilLibPath, RTLD_NOW); if (dlHandle == NULL) { RLOGE("dlopen failed: %s", dlerror()); exit(-1); } RIL_startEventLoop(); rilInit = (const RIL_RadioFunctions *(*)(const struct RIL_Env *, int, char **))dlsym(dlHandle, "RIL_Init"); if (rilInit == NULL) { RLOGE("RIL_Init not defined or exported in %s\n", rilLibPath); exit(-1); } if (hasLibArgs) { rilArgv = argv + i - 1; argc = argc -i + 1; } else { static char * newArgv[MAX_LIB_ARGS]; static char args[PROPERTY_VALUE_MAX]; rilArgv = newArgv; property_get(LIB_ARGS_PROPERTY, args, ""); argc = make_argv(args, rilArgv); } // Make sure there's a reasonable argv[0] rilArgv[0] = argv[0]; funcs = rilInit(&s_rilEnv, argc, rilArgv); RIL_register(funcs); done: while(1) { // sleep(UINT32_MAX) seems to return immediately on bionic sleep(0x00ffffff); } }
int QemuPipeStream::connect(void) { m_sock = qemu_pipe_open("opengles"); if (!valid()) return -1; return 0; }
int main(int argc, char **argv) { const char * rilLibPath = NULL; char **rilArgv; static char * s_argv[MAX_LIB_ARGS] = {NULL}; void *dlHandle; const RIL_RadioFunctions *(*rilInit)(const struct RIL_Env *, int, char **); const RIL_RadioFunctions *funcs; char libPath[PROPERTY_VALUE_MAX]; unsigned char hasLibArgs = 0; int j = 0; int i; static char clientId[3] = {'0'}; RLOGD("**RIL Daemon Started**"); RLOGD("**RILd param count=%d**", argc); memset(s_argv, 0, sizeof(s_argv)); s_argv[0] = argv[0]; umask(S_IRGRP | S_IWGRP | S_IXGRP | S_IROTH | S_IWOTH | S_IXOTH); for (i = 1, j = 1; i < argc ;) { if (0 == strcmp(argv[i], "-l") && (argc - i > 1)) { rilLibPath = argv[i + 1]; i += 2; } else if (0 == strcmp(argv[i], "-c") && (argc - i > 1)) { strncpy(clientId, argv[i+1], strlen(clientId)); i += 2; } else if (0 == strcmp(argv[i], "--")) { i++; hasLibArgs = 1; memcpy(&s_argv[j], &argv[i], argc-i); break; } else { usage(argv[0]); } } #ifdef QCOM_HARDWARE if (atoi(clientId) >= MAX_RILDS) { RLOGE("Max Number of rild's supported is: %d", MAX_RILDS); exit(0); } RLOGD ("RIL Client Id:=%s", clientId); if (strncmp(clientId, "0", MAX_CLIENT_ID_LENGTH)) { if (RIL_setRilSocketName) { RIL_setRilSocketName(clientId); } else { RLOGE("Trying to instantiate multiple rild sockets without a compatible libril!"); } } #endif if (rilLibPath == NULL) { if ( 0 == property_get(LIB_PATH_PROPERTY, libPath, NULL)) { // No lib sepcified on the command line, and nothing set in props. // Assume "no-ril" case. goto done; } else { rilLibPath = libPath; } } /* special override when in the emulator */ #if 1 { static char arg_device[32]; int done = 0; //连接库地址:/system/lib/libreference-ril.so #define REFERENCE_RIL_PATH "/system/lib/libreference-ril.so" /* first, read /proc/cmdline into memory */ char buffer[1024], *p, *q; int len; int fd = open("/proc/cmdline",O_RDONLY); if (fd < 0) { RLOGD("could not open /proc/cmdline:%s", strerror(errno)); goto OpenLib; } do { len = read(fd,buffer,sizeof(buffer)); } while (len == -1 && errno == EINTR); if (len < 0) { RLOGD("could not read /proc/cmdline:%s", strerror(errno)); close(fd); goto OpenLib; } close(fd); if (strstr(buffer, "android.qemud=") != NULL) { /* the qemud daemon is launched after rild, so * give it some time to create its GSM socket */ int tries = 5; #define QEMUD_SOCKET_NAME "qemud" while (1) { int fd; sleep(1); fd = qemu_pipe_open("qemud:gsm"); if (fd < 0) { fd = socket_local_client( QEMUD_SOCKET_NAME, ANDROID_SOCKET_NAMESPACE_RESERVED, SOCK_STREAM ); } if (fd >= 0) { close(fd); snprintf( arg_device, sizeof(arg_device), "%s/%s", ANDROID_SOCKET_DIR, QEMUD_SOCKET_NAME ); memset(s_argv, 0, sizeof(s_argv)); s_argv[1] = "-s"; s_argv[2] = arg_device; done = 1; break; } RLOGD("could not connect to %s socket: %s", QEMUD_SOCKET_NAME, strerror(errno)); if (--tries == 0) break; } if (!done) { RLOGE("could not connect to %s socket (giving up): %s", QEMUD_SOCKET_NAME, strerror(errno)); while(1) sleep(0x00ffffff); } } /* otherwise, try to see if we passed a device name from the kernel */ if (!done) do { #define KERNEL_OPTION "android.ril=" #define DEV_PREFIX "/dev/" p = strstr( buffer, KERNEL_OPTION ); if (p == NULL) break; p += sizeof(KERNEL_OPTION)-1; q = strpbrk( p, " \t\n\r" ); if (q != NULL) *q = 0; snprintf( arg_device, sizeof(arg_device), DEV_PREFIX "%s", p ); arg_device[sizeof(arg_device)-1] = 0; memset(s_argv, 0, sizeof(s_argv)); s_argv[1] = "-d"; s_argv[2] = arg_device; done = 1; } while (0); if (done) { argc = 3; i = 1; hasLibArgs = 1; rilLibPath = REFERENCE_RIL_PATH; RLOGD("overriding with %s %s", s_argv[1], s_argv[2]); } } OpenLib: #endif //切换UID为AID_RADIO switchUser(); // 打开链接库 dlHandle = dlopen(rilLibPath, RTLD_NOW); if (dlHandle == NULL) { RLOGE("dlopen failed: %s", dlerror()); exit(-1); } // 开启EventLoop循环 RIL_startEventLoop(); // 从链接库中(也就是reference-ril.c)寻找RIL_Init函数地址 rilInit = (const RIL_RadioFunctions *(*)(const struct RIL_Env *, int, char **))dlsym(dlHandle, "RIL_Init"); if (rilInit == NULL) { RLOGE("RIL_Init not defined or exported in %s\n", rilLibPath); exit(-1); } if (hasLibArgs) { argc = argc-i+1; } else { static char * newArgv[MAX_LIB_ARGS]; static char args[PROPERTY_VALUE_MAX]; property_get(LIB_ARGS_PROPERTY, args, ""); argc = make_argv(args, s_argv); } // Make sure there's a reasonable argv[0] s_argv[0] = argv[0]; if (argc >= MAX_LIB_ARGS - 2) { RLOGE("Max arguments are passed for rild, args count = %d", argc); exit(0); } #ifdef QCOM_HARDWARE /* Client-id is a qualcomm thing */ s_argv[argc++] = "-c"; s_argv[argc++] = clientId; #endif RLOGD("RIL_Init argc = %d clientId = %s", argc, s_argv[argc-1]); // 初始化过程将s_rilEnv全局变量传递给了reference,然后在reference-ril.c内部将这个值传给了s_rilenv // 而s_rilEnv的各个处理函数是在ril.cpp中实现的 // 调用reference-ril.c中的RIL_Init函数进行初始化INIT,同时得到reference-ril的回调函数 funcs = rilInit(&s_rilEnv, argc, s_argv); #ifdef QCOM_HARDWARE if (funcs == NULL) { /* Pre-multi-client qualcomm vendor libraries won't support "-c" either, so * try again without it. This should only happen on ancient qcoms, so raise * a big fat warning */ argc -= 2; RLOGE("============= Retrying RIL_Init without a client id. This is only required for very old versions,"); RLOGE("============= and you're likely to have more radio breakage elsewhere!"); funcs = rilInit(&s_rilEnv, argc, s_argv); } #endif //注册得到的reference的回调函数 RIL_register(funcs); done: while(1) { // sleep(UINT32_MAX) seems to return immediately on bionic sleep(0x00ffffff); } }