]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blame - gdb/gdbserver/nto-low.c
Remove ptid_get_pid
[thirdparty/binutils-gdb.git] / gdb / gdbserver / nto-low.c
CommitLineData
ac8c974e
AR
1/* QNX Neutrino specific low level interface, for the remote server
2 for GDB.
e2882c85 3 Copyright (C) 2009-2018 Free Software Foundation, Inc.
ac8c974e
AR
4
5 This file is part of GDB.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
19
20
21#include "server.h"
623b6bdf 22#include "gdbthread.h"
ac8c974e 23#include "nto-low.h"
533b0600 24#include "hostio.h"
ac8c974e
AR
25
26#include <limits.h>
27#include <fcntl.h>
28#include <spawn.h>
29#include <sys/procfs.h>
30#include <sys/auxv.h>
ac8c974e
AR
31#include <sys/iomgr.h>
32#include <sys/neutrino.h>
33
34
35extern int using_threads;
36int using_threads = 1;
37
3aee8918
PA
38const struct target_desc *nto_tdesc;
39
ac8c974e
AR
40static void
41nto_trace (const char *fmt, ...)
42{
43 va_list arg_list;
44
45 if (debug_threads == 0)
46 return;
47 fprintf (stderr, "nto:");
48 va_start (arg_list, fmt);
49 vfprintf (stderr, fmt, arg_list);
50 va_end (arg_list);
51}
52
53#define TRACE nto_trace
54
55/* Structure holding neutrino specific information about
56 inferior. */
57
58struct nto_inferior
59{
60 char nto_procfs_path[PATH_MAX];
61 int ctl_fd;
62 pid_t pid;
63 int exit_signo; /* For tracking exit status. */
64};
65
66static struct nto_inferior nto_inferior;
67
68static void
69init_nto_inferior (struct nto_inferior *nto_inferior)
70{
71 memset (nto_inferior, 0, sizeof (struct nto_inferior));
72 nto_inferior->ctl_fd = -1;
73 nto_inferior->pid = -1;
74}
75
76static void
77do_detach (void)
78{
79 if (nto_inferior.ctl_fd != -1)
80 {
81 nto_trace ("Closing fd\n");
82 close (nto_inferior.ctl_fd);
83 init_nto_inferior (&nto_inferior);
84 }
85}
86
87/* Set current thread. Return 1 on success, 0 otherwise. */
88
89static int
90nto_set_thread (ptid_t ptid)
91{
92 int res = 0;
93
e99b03dc 94 TRACE ("%s pid: %d tid: %ld\n", __func__, ptid.pid (),
ac8c974e
AR
95 ptid_get_lwp (ptid));
96 if (nto_inferior.ctl_fd != -1
97 && !ptid_equal (ptid, null_ptid)
98 && !ptid_equal (ptid, minus_one_ptid))
99 {
100 pthread_t tid = ptid_get_lwp (ptid);
101
102 if (EOK == devctl (nto_inferior.ctl_fd, DCMD_PROC_CURTHREAD, &tid,
103 sizeof (tid), 0))
104 res = 1;
105 else
106 TRACE ("%s: Error: failed to set current thread\n", __func__);
107 }
108 return res;
109}
110
111/* This function will determine all alive threads. Note that we do not list
112 dead but unjoined threads even though they are still in the process' thread
113 list.
114
115 NTO_INFERIOR must not be NULL. */
116
117static void
118nto_find_new_threads (struct nto_inferior *nto_inferior)
119{
120 pthread_t tid;
121
122 TRACE ("%s pid:%d\n", __func__, nto_inferior->pid);
123
124 if (nto_inferior->ctl_fd == -1)
125 return;
126
127 for (tid = 1;; ++tid)
128 {
129 procfs_status status;
130 ptid_t ptid;
131 int err;
132
133 status.tid = tid;
134 err = devctl (nto_inferior->ctl_fd, DCMD_PROC_TIDSTATUS, &status,
135 sizeof (status), 0);
136
137 if (err != EOK || status.tid == 0)
138 break;
139
140 /* All threads in between are gone. */
141 while (tid != status.tid || status.state == STATE_DEAD)
142 {
143 struct thread_info *ti;
144
fd79271b 145 ptid = ptid_t (nto_inferior->pid, tid, 0);
ac8c974e
AR
146 ti = find_thread_ptid (ptid);
147 if (ti != NULL)
148 {
149 TRACE ("Removing thread %d\n", tid);
150 remove_thread (ti);
151 }
152 if (tid == status.tid)
153 break;
154 ++tid;
155 }
156
157 if (status.state != STATE_DEAD)
158 {
159 TRACE ("Adding thread %d\n", tid);
fd79271b 160 ptid = ptid_t (nto_inferior->pid, tid, 0);
ac8c974e
AR
161 if (!find_thread_ptid (ptid))
162 add_thread (ptid, NULL);
163 }
164 }
165}
166
167/* Given pid, open procfs path. */
168
169static pid_t
170do_attach (pid_t pid)
171{
172 procfs_status status;
173 struct sigevent event;
174
175 if (nto_inferior.ctl_fd != -1)
176 {
177 close (nto_inferior.ctl_fd);
178 init_nto_inferior (&nto_inferior);
179 }
6cebaf6e 180 xsnprintf (nto_inferior.nto_procfs_path, PATH_MAX - 1, "/proc/%d/as", pid);
ac8c974e
AR
181 nto_inferior.ctl_fd = open (nto_inferior.nto_procfs_path, O_RDWR);
182 if (nto_inferior.ctl_fd == -1)
183 {
184 TRACE ("Failed to open %s\n", nto_inferior.nto_procfs_path);
185 init_nto_inferior (&nto_inferior);
186 return -1;
187 }
188 if (devctl (nto_inferior.ctl_fd, DCMD_PROC_STOP, &status, sizeof (status), 0)
189 != EOK)
190 {
191 do_detach ();
192 return -1;
193 }
194 nto_inferior.pid = pid;
195 /* Define a sigevent for process stopped notification. */
196 event.sigev_notify = SIGEV_SIGNAL_THREAD;
197 event.sigev_signo = SIGUSR1;
198 event.sigev_code = 0;
199 event.sigev_value.sival_ptr = NULL;
200 event.sigev_priority = -1;
201 devctl (nto_inferior.ctl_fd, DCMD_PROC_EVENT, &event, sizeof (event), 0);
202
203 if (devctl (nto_inferior.ctl_fd, DCMD_PROC_STATUS, &status, sizeof (status),
204 0) == EOK
205 && (status.flags & _DEBUG_FLAG_STOPPED))
206 {
207 ptid_t ptid;
3aee8918 208 struct process_info *proc;
ac8c974e
AR
209
210 kill (pid, SIGCONT);
fd79271b 211 ptid = ptid_t (status.pid, status.tid, 0);
ac8c974e 212 the_low_target.arch_setup ();
3aee8918
PA
213 proc = add_process (status.pid, 1);
214 proc->tdesc = nto_tdesc;
ac8c974e
AR
215 TRACE ("Adding thread: pid=%d tid=%ld\n", status.pid,
216 ptid_get_lwp (ptid));
217 nto_find_new_threads (&nto_inferior);
218 }
219 else
220 {
221 do_detach ();
222 return -1;
223 }
224
225 return pid;
226}
227
228/* Read or write LEN bytes from/to inferior's MEMADDR memory address
229 into gdbservers's MYADDR buffer. Return number of bytes actually
230 transfered. */
231
232static int
233nto_xfer_memory (off_t memaddr, unsigned char *myaddr, int len,
234 int dowrite)
235{
236 int nbytes = 0;
237
238 if (lseek (nto_inferior.ctl_fd, memaddr, SEEK_SET) == memaddr)
239 {
240 if (dowrite)
241 nbytes = write (nto_inferior.ctl_fd, myaddr, len);
242 else
243 nbytes = read (nto_inferior.ctl_fd, myaddr, len);
244 if (nbytes < 0)
245 nbytes = 0;
246 }
247 if (nbytes == 0)
248 {
249 int e = errno;
250 TRACE ("Error in %s : errno=%d (%s)\n", __func__, e, strerror (e));
251 }
252 return nbytes;
253}
254
255/* Insert or remove breakpoint or watchpoint at address ADDR.
256 TYPE can be one of Neutrino breakpoint types. SIZE must be 0 for
257 inserting the point, -1 for removing it.
258
259 Return 0 on success, 1 otherwise. */
260
261static int
262nto_breakpoint (CORE_ADDR addr, int type, int size)
263{
264 procfs_break brk;
265
266 brk.type = type;
267 brk.addr = addr;
268 brk.size = size;
269 if (devctl (nto_inferior.ctl_fd, DCMD_PROC_BREAK, &brk, sizeof (brk), 0)
270 != EOK)
271 return 1;
272 return 0;
273}
274
275/* Read auxiliary vector from inferior's initial stack into gdbserver's
276 MYADDR buffer, up to LEN bytes.
277
278 Return number of bytes read. */
279
280static int
281nto_read_auxv_from_initial_stack (CORE_ADDR initial_stack,
282 unsigned char *myaddr,
283 unsigned int len)
284{
285 int data_ofs = 0;
286 int anint;
287 unsigned int len_read = 0;
288
289 /* Skip over argc, argv and envp... Comment from ldd.c:
290
291 The startup frame is set-up so that we have:
292 auxv
293 NULL
294 ...
295 envp2
296 envp1 <----- void *frame + (argc + 2) * sizeof(char *)
297 NULL
298 ...
299 argv2
300 argv1
301 argc <------ void * frame
302
303 On entry to ldd, frame gives the address of argc on the stack. */
304 if (nto_xfer_memory (initial_stack, (unsigned char *)&anint,
305 sizeof (anint), 0) != sizeof (anint))
306 return 0;
307
308 /* Size of pointer is assumed to be 4 bytes (32 bit arch. ) */
309 data_ofs += (anint + 2) * sizeof (void *); /* + 2 comes from argc itself and
310 NULL terminating pointer in
311 argv. */
312
313 /* Now loop over env table: */
314 while (nto_xfer_memory (initial_stack + data_ofs,
315 (unsigned char *)&anint, sizeof (anint), 0)
316 == sizeof (anint))
317 {
318 data_ofs += sizeof (anint);
319 if (anint == 0)
320 break;
321 }
322 initial_stack += data_ofs;
323
324 memset (myaddr, 0, len);
325 while (len_read <= len - sizeof (auxv_t))
326 {
327 auxv_t *auxv = (auxv_t *)myaddr;
328
329 /* Search backwards until we have read AT_PHDR (num. 3),
330 AT_PHENT (num 4), AT_PHNUM (num 5) */
331 if (nto_xfer_memory (initial_stack, (unsigned char *)auxv,
332 sizeof (auxv_t), 0) == sizeof (auxv_t))
333 {
334 if (auxv->a_type != AT_NULL)
335 {
336 auxv++;
337 len_read += sizeof (auxv_t);
338 }
339 if (auxv->a_type == AT_PHNUM) /* That's all we need. */
340 break;
341 initial_stack += sizeof (auxv_t);
342 }
343 else
344 break;
345 }
346 TRACE ("auxv: len_read: %d\n", len_read);
347 return len_read;
348}
349
2090129c
SDJ
350/* Start inferior specified by PROGRAM, using PROGRAM_ARGS as its
351 arguments. */
ac8c974e
AR
352
353static int
2090129c
SDJ
354nto_create_inferior (const char *program,
355 const std::vector<char *> &program_args)
ac8c974e
AR
356{
357 struct inheritance inherit;
358 pid_t pid;
359 sigset_t set;
2090129c 360 std::string str_program_args = stringify_argv (program_args);
ac8c974e
AR
361
362 TRACE ("%s %s\n", __func__, program);
363 /* Clear any pending SIGUSR1's but keep the behavior the same. */
364 signal (SIGUSR1, signal (SIGUSR1, SIG_IGN));
365
366 sigemptyset (&set);
367 sigaddset (&set, SIGUSR1);
368 sigprocmask (SIG_UNBLOCK, &set, NULL);
369
370 memset (&inherit, 0, sizeof (inherit));
371 inherit.flags |= SPAWN_SETGROUP | SPAWN_HOLD;
372 inherit.pgroup = SPAWN_NEWPGROUP;
2090129c
SDJ
373 pid = spawnp (program, 0, NULL, &inherit,
374 (char *) str_program_args.c_str (), 0);
ac8c974e
AR
375 sigprocmask (SIG_BLOCK, &set, NULL);
376
377 if (pid == -1)
378 return -1;
379
380 if (do_attach (pid) != pid)
381 return -1;
382
383 return pid;
384}
385
386/* Attach to process PID. */
387
388static int
389nto_attach (unsigned long pid)
390{
391 TRACE ("%s %ld\n", __func__, pid);
392 if (do_attach (pid) != pid)
393 error ("Unable to attach to %ld\n", pid);
394 return 0;
395}
396
397/* Send signal to process PID. */
398
399static int
400nto_kill (int pid)
401{
402 TRACE ("%s %d\n", __func__, pid);
403 kill (pid, SIGKILL);
404 do_detach ();
405 return 0;
406}
407
408/* Detach from process PID. */
409
410static int
411nto_detach (int pid)
412{
413 TRACE ("%s %d\n", __func__, pid);
414 do_detach ();
415 return 0;
416}
417
505106cd
PA
418static void
419nto_mourn (struct process_info *process)
420{
421 remove_process (process);
422}
423
ac8c974e
AR
424/* Check if the given thread is alive.
425
426 Return 1 if alive, 0 otherwise. */
427
428static int
429nto_thread_alive (ptid_t ptid)
430{
431 int res;
432
e99b03dc 433 TRACE ("%s pid:%d tid:%d\n", __func__, ptid.pid (),
ac8c974e 434 ptid_get_lwp (ptid));
e99b03dc 435 if (SignalKill (0, ptid.pid (), ptid_get_lwp (ptid),
ac8c974e
AR
436 0, 0, 0) == -1)
437 res = 0;
438 else
439 res = 1;
440 TRACE ("%s: %s\n", __func__, res ? "yes" : "no");
441 return res;
442}
443
444/* Resume inferior's execution. */
445
446static void
447nto_resume (struct thread_resume *resume_info, size_t n)
448{
449 /* We can only work in all-stop mode. */
450 procfs_status status;
451 procfs_run run;
452 int err;
453
454 TRACE ("%s\n", __func__);
455 /* Workaround for aliasing rules violation. */
456 sigset_t *run_fault = (sigset_t *) (void *) &run.fault;
457
458 nto_set_thread (resume_info->thread);
459
460 run.flags = _DEBUG_RUN_FAULT | _DEBUG_RUN_TRACE;
461 if (resume_info->kind == resume_step)
462 run.flags |= _DEBUG_RUN_STEP;
463 run.flags |= _DEBUG_RUN_ARM;
464
465 sigemptyset (run_fault);
466 sigaddset (run_fault, FLTBPT);
467 sigaddset (run_fault, FLTTRACE);
468 sigaddset (run_fault, FLTILL);
469 sigaddset (run_fault, FLTPRIV);
470 sigaddset (run_fault, FLTBOUNDS);
471 sigaddset (run_fault, FLTIOVF);
472 sigaddset (run_fault, FLTIZDIV);
473 sigaddset (run_fault, FLTFPE);
474 sigaddset (run_fault, FLTPAGE);
475 sigaddset (run_fault, FLTSTACK);
476 sigaddset (run_fault, FLTACCESS);
477
478 sigemptyset (&run.trace);
479 if (resume_info->sig)
480 {
481 int signal_to_pass;
482
483 devctl (nto_inferior.ctl_fd, DCMD_PROC_STATUS, &status, sizeof (status),
484 0);
485 signal_to_pass = resume_info->sig;
486 if (status.why & (_DEBUG_WHY_SIGNALLED | _DEBUG_WHY_FAULTED))
487 {
488 if (signal_to_pass != status.info.si_signo)
489 {
490 kill (status.pid, signal_to_pass);
491 run.flags |= _DEBUG_RUN_CLRFLT | _DEBUG_RUN_CLRSIG;
492 }
493 else /* Let it kill the program without telling us. */
494 sigdelset (&run.trace, signal_to_pass);
495 }
496 }
497 else
498 run.flags |= _DEBUG_RUN_CLRSIG | _DEBUG_RUN_CLRFLT;
499
500 sigfillset (&run.trace);
501
502 regcache_invalidate ();
503
504 err = devctl (nto_inferior.ctl_fd, DCMD_PROC_RUN, &run, sizeof (run), 0);
505 if (err != EOK)
506 TRACE ("Error: %d \"%s\"\n", err, strerror (err));
507}
508
509/* Wait for inferior's event.
510
511 Return ptid of thread that caused the event. */
512
513static ptid_t
514nto_wait (ptid_t ptid,
515 struct target_waitstatus *ourstatus, int target_options)
516{
517 sigset_t set;
518 siginfo_t info;
519 procfs_status status;
520 const int trace_mask = (_DEBUG_FLAG_TRACE_EXEC | _DEBUG_FLAG_TRACE_RD
521 | _DEBUG_FLAG_TRACE_WR | _DEBUG_FLAG_TRACE_MODIFY);
522
523 TRACE ("%s\n", __func__);
524
525 ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
526
527 sigemptyset (&set);
528 sigaddset (&set, SIGUSR1);
529
530 devctl (nto_inferior.ctl_fd, DCMD_PROC_STATUS, &status, sizeof (status), 0);
531 while (!(status.flags & _DEBUG_FLAG_ISTOP))
532 {
533 sigwaitinfo (&set, &info);
534 devctl (nto_inferior.ctl_fd, DCMD_PROC_STATUS, &status, sizeof (status),
535 0);
536 }
537 nto_find_new_threads (&nto_inferior);
538
539 if (status.flags & _DEBUG_FLAG_SSTEP)
540 {
541 TRACE ("SSTEP\n");
542 ourstatus->kind = TARGET_WAITKIND_STOPPED;
a493e3e2 543 ourstatus->value.sig = GDB_SIGNAL_TRAP;
ac8c974e
AR
544 }
545 /* Was it a breakpoint? */
546 else if (status.flags & trace_mask)
547 {
548 TRACE ("STOPPED\n");
549 ourstatus->kind = TARGET_WAITKIND_STOPPED;
a493e3e2 550 ourstatus->value.sig = GDB_SIGNAL_TRAP;
ac8c974e
AR
551 }
552 else if (status.flags & _DEBUG_FLAG_ISTOP)
553 {
554 TRACE ("ISTOP\n");
555 switch (status.why)
556 {
557 case _DEBUG_WHY_SIGNALLED:
558 TRACE (" SIGNALLED\n");
559 ourstatus->kind = TARGET_WAITKIND_STOPPED;
560 ourstatus->value.sig =
2ea28649 561 gdb_signal_from_host (status.info.si_signo);
ac8c974e
AR
562 nto_inferior.exit_signo = ourstatus->value.sig;
563 break;
564 case _DEBUG_WHY_FAULTED:
565 TRACE (" FAULTED\n");
566 ourstatus->kind = TARGET_WAITKIND_STOPPED;
567 if (status.info.si_signo == SIGTRAP)
568 {
569 ourstatus->value.sig = 0;
570 nto_inferior.exit_signo = 0;
571 }
572 else
573 {
574 ourstatus->value.sig =
2ea28649 575 gdb_signal_from_host (status.info.si_signo);
ac8c974e
AR
576 nto_inferior.exit_signo = ourstatus->value.sig;
577 }
578 break;
579
580 case _DEBUG_WHY_TERMINATED:
581 {
582 int waitval = 0;
583
584 TRACE (" TERMINATED\n");
e99b03dc 585 waitpid (ptid.pid (), &waitval, WNOHANG);
ac8c974e
AR
586 if (nto_inferior.exit_signo)
587 {
588 /* Abnormal death. */
589 ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
590 ourstatus->value.sig = nto_inferior.exit_signo;
591 }
592 else
593 {
594 /* Normal death. */
595 ourstatus->kind = TARGET_WAITKIND_EXITED;
596 ourstatus->value.integer = WEXITSTATUS (waitval);
597 }
598 nto_inferior.exit_signo = 0;
599 break;
600 }
601
602 case _DEBUG_WHY_REQUESTED:
603 TRACE ("REQUESTED\n");
604 /* We are assuming a requested stop is due to a SIGINT. */
605 ourstatus->kind = TARGET_WAITKIND_STOPPED;
a493e3e2 606 ourstatus->value.sig = GDB_SIGNAL_INT;
ac8c974e
AR
607 nto_inferior.exit_signo = 0;
608 break;
609 }
610 }
611
fd79271b 612 return ptid_t (status.pid, status.tid, 0);
ac8c974e
AR
613}
614
615/* Fetch inferior's registers for currently selected thread (CURRENT_INFERIOR).
616 If REGNO is -1, fetch all registers, or REGNO register only otherwise. */
617
618static void
442ea881 619nto_fetch_registers (struct regcache *regcache, int regno)
ac8c974e
AR
620{
621 int regsize;
622 procfs_greg greg;
ac8c974e
AR
623
624 TRACE ("%s (regno=%d)\n", __func__, regno);
625 if (regno >= the_low_target.num_regs)
626 return;
627
0bfdf32f 628 if (current_thread == NULL)
ac8c974e 629 {
0bfdf32f 630 TRACE ("current_thread is NULL\n");
ac8c974e
AR
631 return;
632 }
124aceb4 633 ptid_t ptid = ptid_of (current_thread);
ac8c974e
AR
634 if (!nto_set_thread (ptid))
635 return;
636
637 if (devctl (nto_inferior.ctl_fd, DCMD_PROC_GETGREG, &greg, sizeof (greg),
638 &regsize) == EOK)
639 {
640 if (regno == -1) /* All registers. */
641 {
642 for (regno = 0; regno != the_low_target.num_regs; ++regno)
643 {
644 const unsigned int registeroffset
645 = the_low_target.register_offset (regno);
493e2a69
MS
646 supply_register (regcache, regno,
647 ((char *)&greg) + registeroffset);
ac8c974e
AR
648 }
649 }
650 else
651 {
652 const unsigned int registeroffset
653 = the_low_target.register_offset (regno);
654 if (registeroffset == -1)
655 return;
442ea881 656 supply_register (regcache, regno, ((char *)&greg) + registeroffset);
ac8c974e
AR
657 }
658 }
659 else
660 TRACE ("ERROR reading registers from inferior.\n");
661}
662
663/* Store registers for currently selected thread (CURRENT_INFERIOR).
664 We always store all registers, regardless of REGNO. */
665
666static void
442ea881 667nto_store_registers (struct regcache *regcache, int regno)
ac8c974e
AR
668{
669 procfs_greg greg;
670 int err;
ac8c974e
AR
671
672 TRACE ("%s (regno:%d)\n", __func__, regno);
673
0bfdf32f 674 if (current_thread == NULL)
ac8c974e 675 {
0bfdf32f 676 TRACE ("current_thread is NULL\n");
ac8c974e
AR
677 return;
678 }
124aceb4 679 ptid_t ptid = ptid_of (current_thread);
ac8c974e
AR
680 if (!nto_set_thread (ptid))
681 return;
682
683 memset (&greg, 0, sizeof (greg));
684 for (regno = 0; regno != the_low_target.num_regs; ++regno)
685 {
686 const unsigned int regoffset
687 = the_low_target.register_offset (regno);
442ea881 688 collect_register (regcache, regno, ((char *)&greg) + regoffset);
ac8c974e
AR
689 }
690 err = devctl (nto_inferior.ctl_fd, DCMD_PROC_SETGREG, &greg, sizeof (greg),
691 0);
692 if (err != EOK)
693 TRACE ("Error: setting registers.\n");
694}
695
696/* Read LEN bytes from inferior's memory address MEMADDR into
697 gdbserver's MYADDR buffer.
698
699 Return 0 on success -1 otherwise. */
700
701static int
702nto_read_memory (CORE_ADDR memaddr, unsigned char *myaddr, int len)
703{
704 TRACE ("%s memaddr:0x%08lx, len:%d\n", __func__, memaddr, len);
705
706 if (nto_xfer_memory (memaddr, myaddr, len, 0) != len)
707 {
708 TRACE ("Failed to read memory\n");
709 return -1;
710 }
711
712 return 0;
713}
714
715/* Write LEN bytes from gdbserver's buffer MYADDR into inferior's
716 memory at address MEMADDR.
717
718 Return 0 on success -1 otherwise. */
719
720static int
721nto_write_memory (CORE_ADDR memaddr, const unsigned char *myaddr, int len)
722{
723 int len_written;
724
725 TRACE ("%s memaddr: 0x%08llx len: %d\n", __func__, memaddr, len);
726 if ((len_written = nto_xfer_memory (memaddr, (unsigned char *)myaddr, len,
727 1))
728 != len)
729 {
730 TRACE ("Wanted to write: %d but written: %d\n", len, len_written);
731 return -1;
732 }
733
734 return 0;
735}
736
737/* Stop inferior. We always stop all threads. */
738
739static void
740nto_request_interrupt (void)
741{
742 TRACE ("%s\n", __func__);
fd79271b 743 nto_set_thread (ptid_t (nto_inferior.pid, 1, 0));
ac8c974e
AR
744 if (EOK != devctl (nto_inferior.ctl_fd, DCMD_PROC_STOP, NULL, 0, 0))
745 TRACE ("Error stopping inferior.\n");
746}
747
748/* Read auxiliary vector from inferior's memory into gdbserver's buffer
749 MYADDR. We always read whole auxv.
750
751 Return number of bytes stored in MYADDR buffer, 0 if OFFSET > 0
752 or -1 on error. */
753
754static int
755nto_read_auxv (CORE_ADDR offset, unsigned char *myaddr, unsigned int len)
756{
757 int err;
758 CORE_ADDR initial_stack;
759 procfs_info procinfo;
760
761 TRACE ("%s\n", __func__);
762 if (offset > 0)
763 return 0;
764
765 err = devctl (nto_inferior.ctl_fd, DCMD_PROC_INFO, &procinfo,
766 sizeof procinfo, 0);
767 if (err != EOK)
768 return -1;
769
770 initial_stack = procinfo.initial_stack;
771
772 return nto_read_auxv_from_initial_stack (initial_stack, myaddr, len);
773}
774
802e8e6d
PA
775static int
776nto_supports_z_point_type (char z_type)
777{
778 switch (z_type)
779 {
780 case Z_PACKET_SW_BP:
781 case Z_PACKET_HW_BP:
782 case Z_PACKET_WRITE_WP:
783 case Z_PACKET_READ_WP:
784 case Z_PACKET_ACCESS_WP:
785 return 1;
786 default:
787 return 0;
788 }
789}
790
791/* Insert {break/watch}point at address ADDR. SIZE is not used. */
ac8c974e
AR
792
793static int
802e8e6d
PA
794nto_insert_point (enum raw_bkpt_type type, CORE_ADDR addr,
795 int size, struct raw_breakpoint *bp)
ac8c974e
AR
796{
797 int wtype = _DEBUG_BREAK_HW; /* Always request HW. */
798
774ee6d2 799 TRACE ("%s type:%c addr: 0x%08lx len:%d\n", __func__, (int)type, addr, size);
ac8c974e
AR
800 switch (type)
801 {
802e8e6d 802 case raw_bkpt_type_sw:
ac8c974e
AR
803 wtype = _DEBUG_BREAK_EXEC;
804 break;
802e8e6d 805 case raw_bkpt_type_hw:
ac8c974e
AR
806 wtype |= _DEBUG_BREAK_EXEC;
807 break;
802e8e6d 808 case raw_bkpt_type_write_wp:
ac8c974e
AR
809 wtype |= _DEBUG_BREAK_RW;
810 break;
802e8e6d 811 case raw_bkpt_type_read_wp:
ac8c974e
AR
812 wtype |= _DEBUG_BREAK_RD;
813 break;
802e8e6d 814 case raw_bkpt_type_access_wp:
ac8c974e
AR
815 wtype |= _DEBUG_BREAK_RW;
816 break;
817 default:
818 return 1; /* Not supported. */
819 }
820 return nto_breakpoint (addr, wtype, 0);
821}
822
802e8e6d 823/* Remove {break/watch}point at address ADDR. SIZE is not used. */
ac8c974e
AR
824
825static int
802e8e6d
PA
826nto_remove_point (enum raw_bkpt_type type, CORE_ADDR addr,
827 int size, struct raw_breakpoint *bp)
ac8c974e
AR
828{
829 int wtype = _DEBUG_BREAK_HW; /* Always request HW. */
830
774ee6d2 831 TRACE ("%s type:%c addr: 0x%08lx len:%d\n", __func__, (int)type, addr, size);
ac8c974e
AR
832 switch (type)
833 {
802e8e6d 834 case raw_bkpt_type_sw:
ac8c974e
AR
835 wtype = _DEBUG_BREAK_EXEC;
836 break;
802e8e6d 837 case raw_bkpt_type_hw:
ac8c974e
AR
838 wtype |= _DEBUG_BREAK_EXEC;
839 break;
802e8e6d 840 case raw_bkpt_type_write_wp:
ac8c974e
AR
841 wtype |= _DEBUG_BREAK_RW;
842 break;
802e8e6d 843 case raw_bkpt_type_read_wp:
ac8c974e
AR
844 wtype |= _DEBUG_BREAK_RD;
845 break;
802e8e6d 846 case raw_bkpt_type_access_wp:
ac8c974e
AR
847 wtype |= _DEBUG_BREAK_RW;
848 break;
849 default:
850 return 1; /* Not supported. */
851 }
852 return nto_breakpoint (addr, wtype, -1);
853}
854
855/* Check if the reason of stop for current thread (CURRENT_INFERIOR) is
856 a watchpoint.
857
858 Return 1 if stopped by watchpoint, 0 otherwise. */
859
860static int
861nto_stopped_by_watchpoint (void)
862{
863 int ret = 0;
864
865 TRACE ("%s\n", __func__);
0bfdf32f 866 if (nto_inferior.ctl_fd != -1 && current_thread != NULL)
ac8c974e 867 {
124aceb4 868 ptid_t ptid = ptid_of (current_thread);
ac8c974e
AR
869 if (nto_set_thread (ptid))
870 {
871 const int watchmask = _DEBUG_FLAG_TRACE_RD | _DEBUG_FLAG_TRACE_WR
872 | _DEBUG_FLAG_TRACE_MODIFY;
873 procfs_status status;
874 int err;
875
876 err = devctl (nto_inferior.ctl_fd, DCMD_PROC_STATUS, &status,
877 sizeof (status), 0);
878 if (err == EOK && (status.flags & watchmask))
879 ret = 1;
880 }
881 }
882 TRACE ("%s: %s\n", __func__, ret ? "yes" : "no");
883 return ret;
884}
885
886/* Get instruction pointer for CURRENT_INFERIOR thread.
887
888 Return inferior's instruction pointer value, or 0 on error. */
889
890static CORE_ADDR
891nto_stopped_data_address (void)
892{
893 CORE_ADDR ret = (CORE_ADDR)0;
894
895 TRACE ("%s\n", __func__);
0bfdf32f 896 if (nto_inferior.ctl_fd != -1 && current_thread != NULL)
ac8c974e 897 {
124aceb4 898 ptid_t ptid = ptid_of (current_thread);
ac8c974e
AR
899
900 if (nto_set_thread (ptid))
901 {
902 procfs_status status;
903
904 if (devctl (nto_inferior.ctl_fd, DCMD_PROC_STATUS, &status,
905 sizeof (status), 0) == EOK)
906 ret = status.ip;
907 }
908 }
909 TRACE ("%s: 0x%08lx\n", __func__, ret);
910 return ret;
911}
912
913/* We do not currently support non-stop. */
914
915static int
916nto_supports_non_stop (void)
917{
918 TRACE ("%s\n", __func__);
919 return 0;
920}
921
fb78e89c
AT
922/* Implementation of the target_ops method "sw_breakpoint_from_kind". */
923
924static const gdb_byte *
925nto_sw_breakpoint_from_kind (int kind, int *size)
926{
927 *size = the_low_target.breakpoint_len;
928 return the_low_target.breakpoint;
929}
ac8c974e
AR
930
931
932static struct target_ops nto_target_ops = {
933 nto_create_inferior,
ece66d65 934 NULL, /* post_create_inferior */
ac8c974e
AR
935 nto_attach,
936 nto_kill,
937 nto_detach,
505106cd 938 nto_mourn,
ac8c974e
AR
939 NULL, /* nto_join */
940 nto_thread_alive,
941 nto_resume,
942 nto_wait,
943 nto_fetch_registers,
944 nto_store_registers,
90d74c30 945 NULL, /* prepare_to_access_memory */
0146f85b 946 NULL, /* done_accessing_memory */
ac8c974e
AR
947 nto_read_memory,
948 nto_write_memory,
949 NULL, /* nto_look_up_symbols */
950 nto_request_interrupt,
951 nto_read_auxv,
802e8e6d 952 nto_supports_z_point_type,
ac8c974e
AR
953 nto_insert_point,
954 nto_remove_point,
f5771b1d
PA
955 NULL, /* stopped_by_sw_breakpoint */
956 NULL, /* supports_stopped_by_sw_breakpoint */
957 NULL, /* stopped_by_hw_breakpoint */
958 NULL, /* supports_stopped_by_hw_breakpoint */
70b90b91 959 target_can_do_hardware_single_step,
ac8c974e
AR
960 nto_stopped_by_watchpoint,
961 nto_stopped_data_address,
962 NULL, /* nto_read_offsets */
963 NULL, /* thread_db_set_tls_address */
964 NULL,
965 hostio_last_error_from_errno,
966 NULL, /* nto_qxfer_osdata */
967 NULL, /* xfer_siginfo */
968 nto_supports_non_stop,
969 NULL, /* async */
fb78e89c
AT
970 NULL, /* start_non_stop */
971 NULL, /* supports_multi_process */
972 NULL, /* supports_fork_events */
973 NULL, /* supports_vfork_events */
974 NULL, /* supports_exec_events */
975 NULL, /* handle_new_gdb_connection */
976 NULL, /* handle_monitor_command */
977 NULL, /* core_of_thread */
978 NULL, /* read_loadmap */
979 NULL, /* process_qsupported */
980 NULL, /* supports_tracepoints */
981 NULL, /* read_pc */
982 NULL, /* write_pc */
983 NULL, /* thread_stopped */
984 NULL, /* get_tib_address */
985 NULL, /* pause_all */
986 NULL, /* unpause_all */
987 NULL, /* stabilize_threads */
988 NULL, /* install_fast_tracepoint_jump_pad */
989 NULL, /* emit_ops */
990 NULL, /* supports_disable_randomization */
991 NULL, /* get_min_fast_tracepoint_insn_len */
992 NULL, /* qxfer_libraries_svr4 */
993 NULL, /* support_agent */
fb78e89c
AT
994 NULL, /* enable_btrace */
995 NULL, /* disable_btrace */
996 NULL, /* read_btrace */
997 NULL, /* read_btrace_conf */
998 NULL, /* supports_range_stepping */
999 NULL, /* pid_to_exec_file */
1000 NULL, /* multifs_open */
1001 NULL, /* multifs_unlink */
1002 NULL, /* multifs_readlink */
1003 NULL, /* breakpoint_kind_from_pc */
1004 nto_sw_breakpoint_from_kind,
ac8c974e
AR
1005};
1006
1007
1008/* Global function called by server.c. Initializes QNX Neutrino
1009 gdbserver. */
1010
1011void
1012initialize_low (void)
1013{
1014 sigset_t set;
1015
1016 TRACE ("%s\n", __func__);
1017 set_target_ops (&nto_target_ops);
ac8c974e
AR
1018
1019 /* We use SIGUSR1 to gain control after we block waiting for a process.
1020 We use sigwaitevent to wait. */
1021 sigemptyset (&set);
1022 sigaddset (&set, SIGUSR1);
1023 sigprocmask (SIG_BLOCK, &set, NULL);
1024}
1025