diff options
Diffstat (limited to 'REORG.TODO/hurd/report-wait.c')
| -rw-r--r-- | REORG.TODO/hurd/report-wait.c | 243 |
1 files changed, 243 insertions, 0 deletions
diff --git a/REORG.TODO/hurd/report-wait.c b/REORG.TODO/hurd/report-wait.c new file mode 100644 index 0000000000..92e8aba71c --- /dev/null +++ b/REORG.TODO/hurd/report-wait.c @@ -0,0 +1,243 @@ +/* Report on what a thread in our task is waiting for. + Copyright (C) 1996-2017 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, see + <http://www.gnu.org/licenses/>. */ + +#include <hurd.h> +#include <hurd/signal.h> +#include <hurd/fd.h> +#include <string.h> +#include <assert.h> +#include <hurd/msg_server.h> +#include <thread_state.h> +#include <intr-msg.h> + +static char * +describe_number (string_t description, const char *flavor, long int i) +{ + unsigned long int j; + char *p = flavor == NULL ? description : __stpcpy (description, flavor); + char *end; + + /* Handle sign. */ + if (i < 0) + { + i = -i; + *p++ = '-'; + } + + /* Allocate space for the number at the end of DESCRIPTION. */ + for (j = i; j >= 10; j /= 10) + p++; + end = p + 1; + *end = '\0'; + + do + { + *p-- = '0' + i % 10; + i /= 10; + } while (i != 0); + + return end; +} + +static char * +describe_port (string_t description, mach_port_t port) +{ + int i; + + if (port == MACH_PORT_NULL) + return __stpcpy (description, "(null)"); + if (port == MACH_PORT_DEAD) + return __stpcpy (description, "(dead)"); + + if (port == __mach_task_self ()) + return __stpcpy (description, "task-self"); + + for (i = 0; i < _hurd_nports; ++i) + if (port == _hurd_ports[i].port) + return describe_number (description, "init#", i); + + if (_hurd_init_dtable) + { + for (i = 0; i < _hurd_init_dtablesize; ++i) + if (port == _hurd_init_dtable[i]) + return describe_number (description, "fd#", i); + } + else if (_hurd_dtable) + { + for (i = 0; i < _hurd_dtablesize; ++i) + if (_hurd_dtable[i] == NULL) + continue; + else if (port == _hurd_dtable[i]->port.port) + return describe_number (description, "fd#", i); + else if (port == _hurd_dtable[i]->ctty.port) + return describe_number (description, "bgfd#", i); + } + + return describe_number (description, "port#", port); +} + + +/* We want _HURD_ITIMER_THREAD, but don't want to link in the itimer code + unnecessarily. */ +#if 0 /* libc.so.0.0 needs this defined, so make it a weak alias for now. */ +extern thread_t _hurd_itimer_thread; /* XXX */ +weak_extern (_hurd_itimer_thread) +#else +static thread_t default_hurd_itimer_thread; +weak_alias (default_hurd_itimer_thread, _hurd_itimer_thread) +#endif + +kern_return_t +_S_msg_report_wait (mach_port_t msgport, thread_t thread, + string_t description, mach_msg_id_t *msgid) +{ + *msgid = 0; + + if (thread == _hurd_msgport_thread) + /* Cute. */ + strcpy (description, "msgport"); + else if (&_hurd_itimer_thread && thread == _hurd_itimer_thread) + strcpy (description, "itimer"); + else + { + /* Make sure this is really one of our threads. */ + + struct hurd_sigstate *ss; + + __mutex_lock (&_hurd_siglock); + for (ss = _hurd_sigstates; ss != NULL; ss = ss->next) + if (ss->thread == thread) + break; + __mutex_unlock (&_hurd_siglock); + if (ss == NULL) + /* To hell with you. */ + return EINVAL; + + if (ss->suspended != MACH_PORT_NULL) + strcpy (description, "sigsuspend"); + else + { + /* Examine the thread's state to see if it is blocked in an RPC. */ + + struct machine_thread_state state; + mach_msg_type_number_t count = MACHINE_THREAD_STATE_COUNT; + error_t err; + + err = __thread_get_state (thread, MACHINE_THREAD_STATE_FLAVOR, + (natural_t *) &state, &count); + if (err) + return err; + assert (count == MACHINE_THREAD_STATE_COUNT); + if (SYSCALL_EXAMINE (&state, msgid)) + { + mach_port_t send_port, rcv_port; + mach_msg_option_t option; + mach_msg_timeout_t timeout; + + /* Blocked in a system call. */ + if (*msgid == -25 + /* mach_msg system call. Examine its parameters. */ + && MSG_EXAMINE (&state, msgid, &send_port, &rcv_port, + &option, &timeout) == 0) + { + char *p; + if (send_port != MACH_PORT_NULL && *msgid != 0) + { + /* For the normal case of RPCs, we consider the + destination port to be the interesting thing + whether we are in fact sending or receiving at the + moment. That tells us who we are waiting for the + reply from. */ + if (send_port == ss->intr_port) + { + /* This is a Hurd interruptible RPC. + Mark it by surrounding the port description + string with [...] brackets. */ + description[0] = '['; + p = describe_port (description + 1, send_port); + *p++ = ']'; + *p = '\0'; + } + else + (void) describe_port (description, send_port); + } + else if (rcv_port != MACH_PORT_NULL) + { + /* This system call had no send port, but had a + receive port. The msgid we extracted is then just + some garbage or perhaps the msgid of the last + message this thread received, but it's not a + helpful thing to return. */ + strcpy (describe_port (description, rcv_port), ":rcv"); + *msgid = 0; + } + else if ((option & (MACH_RCV_MSG|MACH_RCV_TIMEOUT)) + == (MACH_RCV_MSG|MACH_RCV_TIMEOUT)) + { + /* A receive with no valid port can be used for a + pure timeout. Report the timeout value (counted + in milliseconds); note this is the original total + time, not the time remaining. */ + strcpy (describe_number (description, 0, timeout), "ms"); + *msgid = 0; + } + else + { + strcpy (description, "mach_msg"); + *msgid = 0; + } + } + else /* Some other system call. */ + { + (void) describe_number (description, "syscall#", *msgid); + *msgid = 0; + } + } + else + description[0] = '\0'; + } + } + + __mach_port_deallocate (__mach_task_self (), thread); + return 0; +} + +kern_return_t +_S_msg_describe_ports (mach_port_t msgport, mach_port_t refport, + mach_port_t *ports, mach_msg_type_number_t nports, + char **desc, mach_msg_type_number_t *desclen) +{ + char *p, *end; + + if (__USEPORT (AUTH, msgport != port)) + return EPERM; + + end = *desc + *desclen; + p = *desc; + while (nports-- > 0) + { + char this[200]; + describe_port (this, *ports++); + p = __stpncpy (p, this, end - p); + if (p == end && p[-1] != '\0') + return ENOMEM; + } + + *desclen = p - *desc; + return 0; +} |