| /******************************************************************************* |
| * Copyright (c) 2007 Wind River Systems, Inc. and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * Wind River Systems - initial API and implementation |
| *******************************************************************************/ |
| |
| /* |
| * TCF Processes - process control service. |
| * Processes service provides access to the target OS's process information, |
| * allows to start and terminate a process, and allows to attach and |
| * detach a process for debugging. Debug services, like Memory and Run Control, |
| * require a process to be attached before they can access it. |
| */ |
| |
| #include "config.h" |
| #if SERVICE_Processes |
| |
| #include <stdlib.h> |
| #include <stdio.h> |
| #include <string.h> |
| #include <errno.h> |
| #include <signal.h> |
| #include <assert.h> |
| #include "mdep.h" |
| #include "myalloc.h" |
| #include "protocol.h" |
| #include "context.h" |
| #include "json.h" |
| #include "exceptions.h" |
| |
| static const char * PROCESSES = "Processes"; |
| |
| #if defined(WIN32) |
| # include <direct.h> |
| #elif defined(_WRS_KERNEL) |
| # include <symLib.h> |
| # include <sysSymTbl.h> |
| #else |
| # include <sys/stat.h> |
| # include <fcntl.h> |
| # include <unistd.h> |
| # include <dirent.h> |
| #endif |
| |
| static void write_context(OutputStream * out, char * id, char * dir) { |
| Context * ctx = NULL; |
| |
| out->write(out, '{'); |
| |
| #if defined(WIN32) |
| #elif defined(_WRS_KERNEL) |
| #else |
| if (chdir(dir) >= 0) { |
| int sz; |
| char fnm[FILE_PATH_SIZE + 1]; |
| |
| json_write_string(out, "CanTerminate"); |
| out->write(out, ':'); |
| json_write_boolean(out, 1); |
| out->write(out, ','); |
| |
| if ((sz = readlink("exe", fnm, FILE_PATH_SIZE)) > 0) { |
| fnm[sz] = 0; |
| json_write_string(out, "Name"); |
| out->write(out, ':'); |
| json_write_string(out, fnm); |
| out->write(out, ','); |
| } |
| } |
| #endif |
| |
| ctx = id2ctx(id); |
| if (ctx != NULL) { |
| json_write_string(out, "Attached"); |
| out->write(out, ':'); |
| json_write_boolean(out, 1); |
| out->write(out, ','); |
| } |
| |
| json_write_string(out, "ID"); |
| out->write(out, ':'); |
| json_write_string(out, id); |
| |
| out->write(out, '}'); |
| } |
| |
| static void command_get_context(char * token, InputStream * inp, OutputStream * out) { |
| int err = 0; |
| char id[256]; |
| pid_t pid, parent; |
| char dir[FILE_PATH_SIZE]; |
| |
| json_read_string(inp, id, sizeof(id)); |
| if (inp->read(inp) != 0) exception(ERR_JSON_SYNTAX); |
| if (inp->read(inp) != MARKER_EOM) exception(ERR_JSON_SYNTAX); |
| |
| pid = id2pid(id, &parent); |
| write_stringz(out, "R"); |
| write_stringz(out, token); |
| |
| pid = id2pid(id, &parent); |
| snprintf(dir, sizeof(dir), "/proc/%d", pid); |
| if (pid != 0 && parent == 0) { |
| #if defined(WIN32) |
| #elif defined(_WRS_KERNEL) |
| if (TASK_ID_VERIFY(pid) == ERROR) err = ERR_INV_CONTEXT; |
| #else |
| struct_stat st; |
| if (lstat(dir, &st) < 0) err = errno; |
| else if (!S_ISDIR(st.st_mode)) err = ERR_INV_CONTEXT; |
| #endif |
| } |
| |
| write_errno(out, err); |
| |
| if (err == 0 && pid != 0 && parent == 0) { |
| write_context(out, id, dir); |
| out->write(out, 0); |
| } |
| else { |
| write_stringz(out, "null"); |
| } |
| |
| out->write(out, MARKER_EOM); |
| } |
| |
| static void command_get_children(char * token, InputStream * inp, OutputStream * out) { |
| char id[256]; |
| pid_t parent = 0; |
| int attached_only; |
| |
| json_read_string(inp, id, sizeof(id)); |
| if (inp->read(inp) != 0) exception(ERR_JSON_SYNTAX); |
| attached_only = json_read_boolean(inp); |
| if (inp->read(inp) != 0) exception(ERR_JSON_SYNTAX); |
| if (inp->read(inp) != MARKER_EOM) exception(ERR_JSON_SYNTAX); |
| |
| write_stringz(out, "R"); |
| write_stringz(out, token); |
| |
| if (id[0] != 0) { |
| write_errno(out, 0); |
| write_stringz(out, "null"); |
| } |
| else { |
| #if defined(WIN32) |
| #elif defined(_WRS_KERNEL) |
| int i = 0; |
| int cnt = 0; |
| int ids_cnt = 0; |
| int ids_max = 500; |
| int * ids = (int *)loc_alloc(ids_max * sizeof(int)); |
| while (1) { |
| ids_cnt = taskIdListGet(ids, ids_max); |
| if (ids_cnt < ids_max) break; |
| loc_free(ids); |
| ids_max *= 2; |
| ids = (int *)loc_alloc(ids_max * sizeof(int)); |
| } |
| out->write(out, '['); |
| for (i = 0; i < ids_cnt; i++) { |
| if (!attached_only || context_find_from_pid(ids[i]) != NULL) { |
| if (cnt > 0) out->write(out, ','); |
| json_write_string(out, pid2id(ids[i], 0)); |
| cnt++; |
| } |
| } |
| out->write(out, ']'); |
| out->write(out, 0); |
| #else |
| DIR * proc = opendir("/proc"); |
| if (proc == NULL) { |
| write_errno(out, errno); |
| write_stringz(out, "null"); |
| } |
| else { |
| int cnt = 0; |
| write_errno(out, 0); |
| out->write(out, '['); |
| for (;;) { |
| struct dirent * ent = readdir(proc); |
| if (ent == NULL) break; |
| if (ent->d_name[0] >= '1' && ent->d_name[0] <= '9') { |
| pid_t pid = atol(ent->d_name); |
| if (!attached_only || context_find_from_pid(pid) != NULL) { |
| if (cnt > 0) out->write(out, ','); |
| json_write_string(out, pid2id(pid, 0)); |
| cnt++; |
| } |
| } |
| } |
| out->write(out, ']'); |
| out->write(out, 0); |
| closedir(proc); |
| } |
| #endif |
| } |
| |
| out->write(out, MARKER_EOM); |
| } |
| |
| static void command_attach(char * token, InputStream * inp, OutputStream * out) { |
| int err = 0; |
| char id[256]; |
| pid_t pid, parent; |
| |
| json_read_string(inp, id, sizeof(id)); |
| if (inp->read(inp) != 0) exception(ERR_JSON_SYNTAX); |
| if (inp->read(inp) != MARKER_EOM) exception(ERR_JSON_SYNTAX); |
| |
| pid = id2pid(id, &parent); |
| write_stringz(out, "R"); |
| write_stringz(out, token); |
| |
| if (parent != 0) { |
| err = ERR_INV_CONTEXT; |
| } |
| else if (context_find_from_pid(pid) != NULL) { |
| err = ERR_ALREADY_ATTACHED; |
| } |
| else { |
| if (context_attach(pid, NULL) < 0) err = errno; |
| } |
| |
| write_errno(out, err); |
| out->write(out, MARKER_EOM); |
| } |
| |
| static void command_detach(char * token, InputStream * inp, OutputStream * out) { |
| // TODO: implement command_detach() |
| exception(ERR_PROTOCOL); |
| } |
| |
| static void command_terminate(char * token, InputStream * inp, OutputStream * out) { |
| int err = 0; |
| char id[256]; |
| pid_t pid, parent; |
| |
| json_read_string(inp, id, sizeof(id)); |
| if (inp->read(inp) != 0) exception(ERR_JSON_SYNTAX); |
| if (inp->read(inp) != MARKER_EOM) exception(ERR_JSON_SYNTAX); |
| |
| pid = id2pid(id, &parent); |
| write_stringz(out, "R"); |
| write_stringz(out, token); |
| |
| if (parent != 0) { |
| err = ERR_INV_CONTEXT; |
| } |
| else { |
| #if defined(WIN32) |
| err = ENOSYS; |
| #elif defined(_WRS_KERNEL) |
| if (kill(pid, SIGTERM) < 0) err = errno; |
| #else |
| if (kill(pid, SIGTERM) < 0) err = errno; |
| #endif |
| } |
| |
| write_errno(out, err); |
| out->write(out, MARKER_EOM); |
| } |
| |
| static void command_signal(char * token, InputStream * inp, OutputStream * out) { |
| int err = 0; |
| char id[256]; |
| int signal = 0; |
| pid_t pid, parent; |
| |
| json_read_string(inp, id, sizeof(id)); |
| if (inp->read(inp) != 0) exception(ERR_JSON_SYNTAX); |
| signal = (int)json_read_long(inp); |
| if (inp->read(inp) != 0) exception(ERR_JSON_SYNTAX); |
| if (inp->read(inp) != MARKER_EOM) exception(ERR_JSON_SYNTAX); |
| |
| pid = id2pid(id, &parent); |
| write_stringz(out, "R"); |
| write_stringz(out, token); |
| |
| if (parent != 0) { |
| err = ERR_INV_CONTEXT; |
| } |
| else { |
| #if defined(WIN32) |
| err = ENOSYS; |
| #elif defined(_WRS_KERNEL) |
| if (kill(pid, signal) < 0) err = errno; |
| #else |
| if (kill(pid, signal) < 0) err = errno; |
| #endif |
| } |
| |
| write_errno(out, err); |
| out->write(out, MARKER_EOM); |
| } |
| |
| static void command_get_environment(char * token, InputStream * inp, OutputStream * out) { |
| char ** p = environ; |
| |
| if (inp->read(inp) != MARKER_EOM) exception(ERR_JSON_SYNTAX); |
| |
| write_stringz(out, "R"); |
| write_stringz(out, token); |
| write_errno(out, 0); |
| out->write(out, '['); |
| if (p != NULL) { |
| while (*p != NULL) { |
| if (p != environ) out->write(out, ','); |
| json_write_string(out, *p++); |
| } |
| } |
| out->write(out, ']'); |
| out->write(out, 0); |
| out->write(out, MARKER_EOM); |
| } |
| |
| static void command_start(char * token, InputStream * inp, OutputStream * out) { |
| Context * ctx = NULL; |
| int pid = 0; |
| int err = 0; |
| char dir[FILE_PATH_SIZE]; |
| char exe[FILE_PATH_SIZE]; |
| char ** args = NULL; |
| char ** envp = NULL; |
| int args_len = 0; |
| int envp_len = 0; |
| int attach = 0; |
| Trap trap; |
| |
| if (set_trap(&trap)) { |
| json_read_string(inp, dir, sizeof(dir)); |
| if (inp->read(inp) != 0) exception(ERR_JSON_SYNTAX); |
| json_read_string(inp, exe, sizeof(exe)); |
| if (inp->read(inp) != 0) exception(ERR_JSON_SYNTAX); |
| args = json_read_alloc_string_array(inp, &args_len); |
| if (inp->read(inp) != 0) exception(ERR_JSON_SYNTAX); |
| envp = json_read_alloc_string_array(inp, &envp_len); |
| if (inp->read(inp) != 0) exception(ERR_JSON_SYNTAX); |
| attach = json_read_boolean(inp); |
| if (inp->read(inp) != 0) exception(ERR_JSON_SYNTAX); |
| if (inp->read(inp) != MARKER_EOM) exception(ERR_JSON_SYNTAX); |
| |
| if (dir[0] != 0 && chdir(dir) < 0) err = errno; |
| if (err == 0) { |
| #if defined(WIN32) |
| #elif defined(_WRS_KERNEL) |
| char * ptr; |
| SYM_TYPE type; |
| if (symFindByName(sysSymTbl, exe, &ptr, &type) != OK) { |
| err = errno; |
| if (err == S_symLib_SYMBOL_NOT_FOUND) err = ERR_SYM_NOT_FOUND; |
| assert(err != 0); |
| } |
| else { |
| // TODO: arguments, environment |
| pid = taskCreate("tTcf", 100, 0, 0x4000, (FUNCPTR)ptr, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); |
| if (attach) { |
| taskStop(pid); |
| taskActivate(pid); |
| assert(taskIsStopped(pid)); |
| } |
| else { |
| taskActivate(pid); |
| } |
| } |
| #else |
| pid = fork(); |
| if (pid < 0) err = errno; |
| if (pid == 0) { |
| if (attach) tkill(getpid(), SIGSTOP); |
| exit(execve(exe, args, envp)); |
| } |
| #endif |
| } |
| if (attach) { |
| if (err == 0 && context_attach(pid, &ctx) < 0) err = errno; |
| if (ctx != NULL && !ctx->stopped) ctx->pending_intercept = 1; |
| } |
| |
| write_stringz(out, "R"); |
| write_stringz(out, token); |
| write_errno(out, err); |
| if (err || pid == 0) { |
| write_stringz(out, "null"); |
| } |
| else { |
| char bf[256]; |
| snprintf(dir, sizeof(dir), "/proc/%d", pid); |
| write_context(out, strcpy(bf, pid2id(pid, 0)), dir); |
| out->write(out, 0); |
| } |
| out->write(out, MARKER_EOM); |
| clear_trap(&trap); |
| } |
| |
| loc_free(args); |
| loc_free(envp); |
| |
| if (trap.error) exception(trap.error); |
| } |
| |
| void ini_processes_service(void) { |
| add_command_handler(PROCESSES, "getContext", command_get_context); |
| add_command_handler(PROCESSES, "getChildren", command_get_children); |
| add_command_handler(PROCESSES, "attach", command_attach); |
| add_command_handler(PROCESSES, "detach", command_detach); |
| add_command_handler(PROCESSES, "terminate", command_terminate); |
| add_command_handler(PROCESSES, "signal", command_signal); |
| add_command_handler(PROCESSES, "getEnvironment", command_get_environment); |
| add_command_handler(PROCESSES, "start", command_start); |
| } |
| |
| #endif |
| |
