/* Process tracing interface `ptrace' for GNU Hurd.

   Copyright (C) 1991-2018 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 <errno.h>

#include <sys/ptrace.h>

#include <sys/types.h>

#include <stdarg.h>

#include <hurd.h>

#include <hurd/signal.h>

#include <hurd/msg.h>

#include <thread_state.h>

/* Perform process tracing functions.  REQUEST is one of the values

   in <sys/ptrace.h>, and determines the action to be taken.

   For all requests except PTRACE_TRACEME, PID specifies the process to be

   traced.

   PID and the other arguments described above for the various requests should

   appear (those that are used for the particular request) as:

     pid_t PID, void *ADDR, int DATA, void *ADDR2

   after PID.  */

int

ptrace (enum __ptrace_request request, ... )

{

  pid_t pid;

  void *addr, *addr2;

  natural_t data;

  va_list ap;

  /* Read data from PID's address space, from ADDR for DATA bytes.  */

  error_t read_data (task_t task, vm_address_t *ourpage, vm_size_t *size)

    {

      /* Read the pages containing the addressed range.  */

      error_t err;

      *size = round_page (addr + data) - trunc_page (addr);

      err = __vm_read (task, trunc_page (addr), *size, ourpage, size);

      return err;

    }

  /* Fetch the thread port for PID's user thread.  */

  error_t fetch_user_thread (task_t task, thread_t *thread)

    {

      thread_t threadbuf[3], *threads = threadbuf;

      mach_msg_type_number_t nthreads = 3, i;

      error_t err = __task_threads (task, &threads, &nthreads);

      if (err)

	return err;

      if (nthreads == 0)

	return EINVAL;

      *thread = threads[0];	/* Assume user thread is first.  */

      for (i = 1; i < nthreads; ++i)

	__mach_port_deallocate (__mach_task_self (), threads[i]);

      if (threads != threadbuf)

	__vm_deallocate (__mach_task_self (),

			 (vm_address_t) threads, nthreads * sizeof threads[0]);

      return 0;

    }

  /* Fetch a thread state structure from PID and store it at ADDR.  */

  int get_regs (int flavor, mach_msg_type_number_t count)

    {

      error_t err;

      task_t task = __pid2task (pid);

      thread_t thread;

      if (task == MACH_PORT_NULL)

	return -1;

      err = fetch_user_thread (task, &thread);

      __mach_port_deallocate (__mach_task_self (), task);

      if (!err)

	err = __thread_get_state (thread, flavor, addr, &count);

      __mach_port_deallocate (__mach_task_self (), thread);

      return err ? __hurd_fail (err) : 0;

    }

  switch (request)

    {

    case PTRACE_TRACEME:

      /* Make this process be traced.  */

      __sigfillset (&_hurdsig_traced);

      __USEPORT (PROC, __proc_mark_traced (port));

      break;

    case PTRACE_CONT:

      va_start (ap, request);

      pid = va_arg (ap, pid_t);

      addr = va_arg (ap, void *);

      data = va_arg (ap, int);

      va_end (ap);

      {

	/* Send a DATA signal to PID, telling it to take the signal

	   normally even if it's traced.  */

	error_t err;

	task_t task = __pid2task (pid);

	if (task == MACH_PORT_NULL)

	  return -1;

	if (data == SIGKILL)

	  err = __task_terminate (task);

	else

	  {

	    if (addr != (void *) 1)

	      {

		/* Move the user thread's PC to ADDR.  */

		thread_t thread;

		err = fetch_user_thread (task, &thread);

		if (!err)

		  {

		    struct machine_thread_state state;

		    mach_msg_type_number_t count = MACHINE_THREAD_STATE_COUNT;

		    err = __thread_get_state (thread,

					      MACHINE_THREAD_STATE_FLAVOR,

					      (natural_t *) &state, &count);

		    if (!err)

		      {

			MACHINE_THREAD_STATE_SET_PC (&state, addr);

			err = __thread_set_state (thread,

						  MACHINE_THREAD_STATE_FLAVOR,

						  (natural_t *) &state, count);

		      }

		  }

		__mach_port_deallocate (__mach_task_self (), thread);

	      }

	    else

	      err = 0;

	    if (! err)

	      /* Tell the process to take the signal (or just resume if 0).  */

	      err = HURD_MSGPORT_RPC

		(__USEPORT (PROC, __proc_getmsgport (port, pid, &msgport)),

		 0, 0, __msg_sig_post_untraced (msgport, data, 0, task));

	  }

	__mach_port_deallocate (__mach_task_self (), task);

	return err ? __hurd_fail (err) : 0;

      }

    case PTRACE_KILL:

      va_start (ap, request);

      pid = va_arg (ap, pid_t);

      va_end (ap);

      /* SIGKILL always just terminates the task,

	 so normal kill is just the same when traced.  */

      return __kill (pid, SIGKILL);

    case PTRACE_SINGLESTEP:

      /* This is a machine-dependent kernel RPC on

	 machines that support it.  Punt.  */

      return __hurd_fail (EOPNOTSUPP);

    case PTRACE_ATTACH:

    case PTRACE_DETACH:

      va_start (ap, request);

      pid = va_arg (ap, pid_t);

      va_end (ap);

      {

	/* Tell PID to set or clear its trace bit.  */

	error_t err;

	mach_port_t msgport;

	task_t task = __pid2task (pid);

	if (task == MACH_PORT_NULL)

	  return -1;

	err = __USEPORT (PROC, __proc_getmsgport (port, pid, &msgport));

	if (! err)

	  {

	    err = __msg_set_init_int (msgport, task, INIT_TRACEMASK,

				      request == PTRACE_DETACH ? 0 :

				      ~(sigset_t) 0);

	    if (! err)

	      {

		if (request == PTRACE_ATTACH)

		  /* Now stop the process.  */

		  err = __msg_sig_post (msgport, SIGSTOP, 0, task);

		else

		  /* Resume the process from tracing stop.  */

		  err = __msg_sig_post_untraced (msgport, 0, 0, task);

	      }

	    __mach_port_deallocate (__mach_task_self (), msgport);

	  }

	__mach_port_deallocate (__mach_task_self (), task);

	return err ? __hurd_fail (err) : 0;

      }

    case PTRACE_PEEKTEXT:

    case PTRACE_PEEKDATA:

      va_start (ap, request);

      pid = va_arg (ap, pid_t);

      addr = va_arg (ap, void *);

      va_end (ap);

      {

	/* Read the page (or two pages, if the word lies on a boundary)

	   containing the addressed word.  */

	error_t err;

	vm_address_t ourpage;

	vm_size_t size;

	natural_t word;

	task_t task = __pid2task (pid);

	if (task == MACH_PORT_NULL)

	  return -1;

	data = sizeof word;

	ourpage = 0;

	size = 0;

	err = read_data (task, &ourpage, &size);

	__mach_port_deallocate (__mach_task_self (), task);

	if (err)

	  return __hurd_fail (err);

	word = *(natural_t *) ((vm_address_t) addr - trunc_page (addr)

			       + ourpage);

	__vm_deallocate (__mach_task_self (), ourpage, size);

	return word;

      }

    case PTRACE_PEEKUSER:

    case PTRACE_POKEUSER:

      /* U area, what's that?  */

      return __hurd_fail (EOPNOTSUPP);

    case PTRACE_GETREGS:

    case PTRACE_SETREGS:

      va_start (ap, request);

      pid = va_arg (ap, pid_t);

      addr = va_arg (ap, void *);

      va_end (ap);

      return get_regs (MACHINE_THREAD_STATE_FLAVOR,

		       MACHINE_THREAD_STATE_COUNT);

    case PTRACE_GETFPREGS:

    case PTRACE_SETFPREGS:

      va_start (ap, request);

      pid = va_arg (ap, pid_t);

      addr = va_arg (ap, void *);

      va_end (ap);

#ifdef MACHINE_THREAD_FLOAT_STATE_FLAVOR

      return get_regs (MACHINE_THREAD_FLOAT_STATE_FLAVOR,

		       MACHINE_THREAD_FLOAT_STATE_COUNT);

#else

      return __hurd_fail (EOPNOTSUPP);

#endif

    case PTRACE_GETFPAREGS:

    case PTRACE_SETFPAREGS:

      va_start (ap, request);

      pid = va_arg (ap, pid_t);

      addr = va_arg (ap, void *);

      va_end (ap);

#ifdef MACHINE_THREAD_FPA_STATE_FLAVOR

      return get_regs (MACHINE_THREAD_FPA_STATE_FLAVOR,

		       MACHINE_THREAD_FPA_STATE_COUNT);

#else

      return __hurd_fail (EOPNOTSUPP);

#endif

    case PTRACE_POKETEXT:

    case PTRACE_POKEDATA:

      va_start (ap, request);

      pid = va_arg (ap, pid_t);

      addr = va_arg (ap, void *);

      data = va_arg (ap, int);

      va_end (ap);

      {

	/* Read the page (or two pages, if the word lies on a boundary)

	   containing the addressed word.  */

	error_t err;

	vm_address_t ourpage;

	vm_size_t size;

	task_t task = __pid2task (pid);

	if (task == MACH_PORT_NULL)

	  return -1;

	data = sizeof (natural_t);

	ourpage = 0;

	size = 0;

	err = read_data (task, &ourpage, &size);

	if (!err)

	  {

	    /* Now modify the specified word and write the page back.  */

	    *(natural_t *) ((vm_address_t) addr - trunc_page (addr)

			    + ourpage) = data;

	    err = __vm_write (task, trunc_page (addr), ourpage, size);

	    __vm_deallocate (__mach_task_self (), ourpage, size);

	  }

	__mach_port_deallocate (__mach_task_self (), task);

	return err ? __hurd_fail (err) : 0;

      }

    case PTRACE_READDATA:

    case PTRACE_READTEXT:

      va_start (ap, request);

      pid = va_arg (ap, pid_t);

      addr = va_arg (ap, void *);

      data = va_arg (ap, int);

      addr2 = va_arg (ap, void *);

      va_end (ap);

      {

	error_t err;

	vm_address_t ourpage;

	vm_size_t size;

	task_t task = __pid2task (pid);

	if (task == MACH_PORT_NULL)

	  return -1;

	if (((vm_address_t) addr2 + data) % __vm_page_size == 0)

	  {

	    /* Perhaps we can write directly to the user's buffer.  */

	    ourpage = (vm_address_t) addr2;

	    size = data;

	  }

	else

	  {

	    ourpage = 0;

	    size = 0;

	  }

	err = read_data (task, &ourpage, &size);

	__mach_port_deallocate (__mach_task_self (), task);

	if (!err && ourpage != (vm_address_t) addr2)

	  {

	    memcpy (addr2, (void *) ourpage, data);

	    __vm_deallocate (__mach_task_self (), ourpage, size);

	  }

	return err ? __hurd_fail (err) : 0;

      }

    case PTRACE_WRITEDATA:

    case PTRACE_WRITETEXT:

      va_start (ap, request);

      pid = va_arg (ap, pid_t);

      addr = va_arg (ap, void *);

      data = va_arg (ap, int);

      addr2 = va_arg (ap, void *);

      va_end (ap);

      {

	error_t err;

	vm_address_t ourpage;

	vm_size_t size;

	task_t task = __pid2task (pid);

	if (task == MACH_PORT_NULL)

	  return -1;

	if ((vm_address_t) addr % __vm_page_size == 0 &&

	    (vm_address_t) data % __vm_page_size == 0)

	  {

	    /* Writing whole pages; can go directly from the user's buffer.  */

	    ourpage = (vm_address_t) addr2;

	    size = data;

	    err = 0;

	  }

	else

	  {

	    /* Read the task's pages and modify our own copy.  */

	    ourpage = 0;

	    size = 0;

	    err = read_data (task, &ourpage, &size);

	    if (!err)

	      memcpy ((void *) ((vm_address_t) addr - trunc_page (addr)

				+ ourpage),

		      addr2,

		      data);

	  }

	if (!err)

	  /* Write back the modified pages.  */

	  err = __vm_write (task, trunc_page (addr), ourpage, size);

	__mach_port_deallocate (__mach_task_self (), task);

	return err ? __hurd_fail (err) : 0;

      }

    default:

      errno = EINVAL;

      return -1;

    }

  return 0;

}