OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-7.1/] [gdb/] [nto-procfs.c] - Blame information for rev 842

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 227 jeremybenn
/* Machine independent support for QNX Neutrino /proc (process file system)
2
   for GDB.  Written by Colin Burgess at QNX Software Systems Limited.
3
 
4
   Copyright (C) 2003, 2006, 2007, 2008, 2009, 2010
5
   Free Software Foundation, Inc.
6
 
7
   Contributed by QNX Software Systems Ltd.
8
 
9
   This file is part of GDB.
10
 
11
   This program is free software; you can redistribute it and/or modify
12
   it under the terms of the GNU General Public License as published by
13
   the Free Software Foundation; either version 3 of the License, or
14
   (at your option) any later version.
15
 
16
   This program is distributed in the hope that it will be useful,
17
   but WITHOUT ANY WARRANTY; without even the implied warranty of
18
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19
   GNU General Public License for more details.
20
 
21
   You should have received a copy of the GNU General Public License
22
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
23
 
24
#include "defs.h"
25
 
26
#include <fcntl.h>
27
#include <spawn.h>
28
#include <sys/debug.h>
29
#include <sys/procfs.h>
30
#include <sys/neutrino.h>
31
#include <sys/syspage.h>
32
#include "gdb_dirent.h"
33
#include <sys/netmgr.h>
34
 
35
#include "exceptions.h"
36
#include "gdb_string.h"
37
#include "gdbcore.h"
38
#include "inferior.h"
39
#include "target.h"
40
#include "objfiles.h"
41
#include "gdbthread.h"
42
#include "nto-tdep.h"
43
#include "command.h"
44
#include "regcache.h"
45
#include "solib.h"
46
 
47
#define NULL_PID                0
48
#define _DEBUG_FLAG_TRACE       (_DEBUG_FLAG_TRACE_EXEC|_DEBUG_FLAG_TRACE_RD|\
49
                _DEBUG_FLAG_TRACE_WR|_DEBUG_FLAG_TRACE_MODIFY)
50
 
51
static struct target_ops procfs_ops;
52
 
53
int ctl_fd;
54
 
55
static void (*ofunc) ();
56
 
57
static procfs_run run;
58
 
59
static void procfs_open (char *, int);
60
 
61
static int procfs_can_run (void);
62
 
63
static int procfs_xfer_memory (CORE_ADDR, gdb_byte *, int, int,
64
                               struct mem_attrib *attrib,
65
                               struct target_ops *);
66
 
67
static void notice_signals (void);
68
 
69
static void init_procfs_ops (void);
70
 
71
static ptid_t do_attach (ptid_t ptid);
72
 
73
static int procfs_can_use_hw_breakpoint (int, int, int);
74
 
75
static int procfs_insert_hw_watchpoint (CORE_ADDR addr, int len, int type);
76
 
77
static int procfs_remove_hw_watchpoint (CORE_ADDR addr, int len, int type);
78
 
79
static int procfs_stopped_by_watchpoint (void);
80
 
81
/* These two globals are only ever set in procfs_open(), but are
82
   referenced elsewhere.  'nto_procfs_node' is a flag used to say
83
   whether we are local, or we should get the current node descriptor
84
   for the remote QNX node.  */
85
static char nto_procfs_path[PATH_MAX] = { "/proc" };
86
static unsigned nto_procfs_node = ND_LOCAL_NODE;
87
 
88
/* Return the current QNX Node, or error out.  This is a simple
89
   wrapper for the netmgr_strtond() function.  The reason this
90
   is required is because QNX node descriptors are transient so
91
   we have to re-acquire them every time.  */
92
static unsigned
93
nto_node (void)
94
{
95
  unsigned node;
96
 
97
  if (ND_NODE_CMP (nto_procfs_node, ND_LOCAL_NODE) == 0)
98
    return ND_LOCAL_NODE;
99
 
100
  node = netmgr_strtond (nto_procfs_path, 0);
101
  if (node == -1)
102
    error (_("Lost the QNX node.  Debug session probably over."));
103
 
104
  return (node);
105
}
106
 
107
static enum gdb_osabi
108
procfs_is_nto_target (bfd *abfd)
109
{
110
  return GDB_OSABI_QNXNTO;
111
}
112
 
113
/* This is called when we call 'target procfs <arg>' from the (gdb) prompt.
114
   For QNX6 (nto), the only valid arg will be a QNX node string,
115
   eg: "/net/some_node".  If arg is not a valid QNX node, we will
116
   default to local.  */
117
static void
118
procfs_open (char *arg, int from_tty)
119
{
120
  char *nodestr;
121
  char *endstr;
122
  char buffer[50];
123
  int fd, total_size;
124
  procfs_sysinfo *sysinfo;
125
  struct cleanup *cleanups;
126
 
127
  nto_is_nto_target = procfs_is_nto_target;
128
 
129
  /* Set the default node used for spawning to this one,
130
     and only override it if there is a valid arg.  */
131
 
132
  nto_procfs_node = ND_LOCAL_NODE;
133
  nodestr = arg ? xstrdup (arg) : arg;
134
 
135
  init_thread_list ();
136
 
137
  if (nodestr)
138
    {
139
      nto_procfs_node = netmgr_strtond (nodestr, &endstr);
140
      if (nto_procfs_node == -1)
141
        {
142
          if (errno == ENOTSUP)
143
            printf_filtered ("QNX Net Manager not found.\n");
144
          printf_filtered ("Invalid QNX node %s: error %d (%s).\n", nodestr,
145
                           errno, safe_strerror (errno));
146
          xfree (nodestr);
147
          nodestr = NULL;
148
          nto_procfs_node = ND_LOCAL_NODE;
149
        }
150
      else if (*endstr)
151
        {
152
          if (*(endstr - 1) == '/')
153
            *(endstr - 1) = 0;
154
          else
155
            *endstr = 0;
156
        }
157
    }
158
  snprintf (nto_procfs_path, PATH_MAX - 1, "%s%s", nodestr ? nodestr : "",
159
            "/proc");
160
  if (nodestr)
161
    xfree (nodestr);
162
 
163
  fd = open (nto_procfs_path, O_RDONLY);
164
  if (fd == -1)
165
    {
166
      printf_filtered ("Error opening %s : %d (%s)\n", nto_procfs_path, errno,
167
                       safe_strerror (errno));
168
      error (_("Invalid procfs arg"));
169
    }
170
  cleanups = make_cleanup_close (fd);
171
 
172
  sysinfo = (void *) buffer;
173
  if (devctl (fd, DCMD_PROC_SYSINFO, sysinfo, sizeof buffer, 0) != EOK)
174
    {
175
      printf_filtered ("Error getting size: %d (%s)\n", errno,
176
                       safe_strerror (errno));
177
      error (_("Devctl failed."));
178
    }
179
  else
180
    {
181
      total_size = sysinfo->total_size;
182
      sysinfo = alloca (total_size);
183
      if (!sysinfo)
184
        {
185
          printf_filtered ("Memory error: %d (%s)\n", errno,
186
                           safe_strerror (errno));
187
          error (_("alloca failed."));
188
        }
189
      else
190
        {
191
          if (devctl (fd, DCMD_PROC_SYSINFO, sysinfo, total_size, 0) != EOK)
192
            {
193
              printf_filtered ("Error getting sysinfo: %d (%s)\n", errno,
194
                               safe_strerror (errno));
195
              error (_("Devctl failed."));
196
            }
197
          else
198
            {
199
              if (sysinfo->type !=
200
                  nto_map_arch_to_cputype (gdbarch_bfd_arch_info
201
                                           (target_gdbarch)->arch_name))
202
                error (_("Invalid target CPU."));
203
            }
204
        }
205
    }
206
  do_cleanups (cleanups);
207
  printf_filtered ("Debugging using %s\n", nto_procfs_path);
208
}
209
 
210
static void
211
procfs_set_thread (ptid_t ptid)
212
{
213
  pid_t tid;
214
 
215
  tid = ptid_get_tid (ptid);
216
  devctl (ctl_fd, DCMD_PROC_CURTHREAD, &tid, sizeof (tid), 0);
217
}
218
 
219
/*  Return nonzero if the thread TH is still alive.  */
220
static int
221
procfs_thread_alive (struct target_ops *ops, ptid_t ptid)
222
{
223
  pid_t tid;
224
  pid_t pid;
225
  procfs_status status;
226
  int err;
227
 
228
  tid = ptid_get_tid (ptid);
229
  pid = ptid_get_pid (ptid);
230
 
231
  if (kill (pid, 0) == -1)
232
    return 0;
233
 
234
  status.tid = tid;
235
  if ((err = devctl (ctl_fd, DCMD_PROC_TIDSTATUS,
236
                     &status, sizeof (status), 0)) != EOK)
237
    return 0;
238
 
239
  /* Thread is alive or dead but not yet joined,
240
     or dead and there is an alive (or dead unjoined) thread with
241
     higher tid.
242
 
243
     If the tid is not the same as requested, requested tid is dead.  */
244
  return (status.tid == tid) && (status.state != STATE_DEAD);
245
}
246
 
247
static void
248
update_thread_private_data_name (struct thread_info *new_thread,
249
                                 const char *newname)
250
{
251
  int newnamelen;
252
  struct private_thread_info *pti;
253
 
254
  gdb_assert (newname != NULL);
255
  gdb_assert (new_thread != NULL);
256
  newnamelen = strlen (newname);
257
  if (!new_thread->private)
258
    {
259
      new_thread->private = xmalloc (offsetof (struct private_thread_info,
260
                                               name)
261
                                     + newnamelen + 1);
262
      memcpy (new_thread->private->name, newname, newnamelen + 1);
263
    }
264
  else if (strcmp (newname, new_thread->private->name) != 0)
265
    {
266
      /* Reallocate if neccessary.  */
267
      int oldnamelen = strlen (new_thread->private->name);
268
 
269
      if (oldnamelen < newnamelen)
270
        new_thread->private = xrealloc (new_thread->private,
271
                                        offsetof (struct private_thread_info,
272
                                                  name)
273
                                        + newnamelen + 1);
274
      memcpy (new_thread->private->name, newname, newnamelen + 1);
275
    }
276
}
277
 
278
static void
279
update_thread_private_data (struct thread_info *new_thread,
280
                            pthread_t tid, int state, int flags)
281
{
282
  struct private_thread_info *pti;
283
  procfs_info pidinfo;
284
  struct _thread_name *tn;
285
  procfs_threadctl tctl;
286
 
287
#if _NTO_VERSION > 630
288
  gdb_assert (new_thread != NULL);
289
 
290
  if (devctl (ctl_fd, DCMD_PROC_INFO, &pidinfo,
291
              sizeof(pidinfo), 0) != EOK)
292
    return;
293
 
294
  memset (&tctl, 0, sizeof (tctl));
295
  tctl.cmd = _NTO_TCTL_NAME;
296
  tn = (struct _thread_name *) (&tctl.data);
297
 
298
  /* Fetch name for the given thread.  */
299
  tctl.tid = tid;
300
  tn->name_buf_len = sizeof (tctl.data) - sizeof (*tn);
301
  tn->new_name_len = -1; /* Getting, not setting.  */
302
  if (devctl (ctl_fd, DCMD_PROC_THREADCTL, &tctl, sizeof (tctl), NULL) != EOK)
303
    tn->name_buf[0] = '\0';
304
 
305
  tn->name_buf[_NTO_THREAD_NAME_MAX] = '\0';
306
 
307
  update_thread_private_data_name (new_thread, tn->name_buf);
308
 
309
  pti = (struct private_thread_info *) new_thread->private;
310
  pti->tid = tid;
311
  pti->state = state;
312
  pti->flags = flags;
313
#endif /* _NTO_VERSION */
314
}
315
 
316
void
317
procfs_find_new_threads (struct target_ops *ops)
318
{
319
  procfs_status status;
320
  pid_t pid;
321
  ptid_t ptid;
322
  pthread_t tid;
323
  struct thread_info *new_thread;
324
 
325
  if (ctl_fd == -1)
326
    return;
327
 
328
  pid = ptid_get_pid (inferior_ptid);
329
 
330
  status.tid = 1;
331
 
332
  for (tid = 1;; ++tid)
333
    {
334
      if (status.tid == tid
335
          && (devctl (ctl_fd, DCMD_PROC_TIDSTATUS, &status, sizeof (status), 0)
336
              != EOK))
337
        break;
338
      if (status.tid != tid)
339
        /* The reason why this would not be equal is that devctl might have
340
           returned different tid, meaning the requested tid no longer exists
341
           (e.g. thread exited).  */
342
        continue;
343
      ptid = ptid_build (pid, 0, tid);
344
      new_thread = find_thread_ptid (ptid);
345
      if (!new_thread)
346
        new_thread = add_thread (ptid);
347
      update_thread_private_data (new_thread, tid, status.state, 0);
348
      status.tid++;
349
    }
350
  return;
351
}
352
 
353
static void
354
do_closedir_cleanup (void *dir)
355
{
356
  closedir (dir);
357
}
358
 
359
void
360
procfs_pidlist (char *args, int from_tty)
361
{
362
  DIR *dp = NULL;
363
  struct dirent *dirp = NULL;
364
  char buf[512];
365
  procfs_info *pidinfo = NULL;
366
  procfs_debuginfo *info = NULL;
367
  procfs_status *status = NULL;
368
  pid_t num_threads = 0;
369
  pid_t pid;
370
  char name[512];
371
  struct cleanup *cleanups;
372
 
373
  dp = opendir (nto_procfs_path);
374
  if (dp == NULL)
375
    {
376
      fprintf_unfiltered (gdb_stderr, "failed to opendir \"%s\" - %d (%s)",
377
                          nto_procfs_path, errno, safe_strerror (errno));
378
      return;
379
    }
380
 
381
  cleanups = make_cleanup (do_closedir_cleanup, dp);
382
 
383
  /* Start scan at first pid.  */
384
  rewinddir (dp);
385
 
386
  do
387
    {
388
      int fd;
389
      struct cleanup *inner_cleanup;
390
 
391
      /* Get the right pid and procfs path for the pid.  */
392
      do
393
        {
394
          dirp = readdir (dp);
395
          if (dirp == NULL)
396
            {
397
              do_cleanups (cleanups);
398
              return;
399
            }
400
          snprintf (buf, 511, "%s/%s/as", nto_procfs_path, dirp->d_name);
401
          pid = atoi (dirp->d_name);
402
        }
403
      while (pid == 0);
404
 
405
      /* Open the procfs path. */
406
      fd = open (buf, O_RDONLY);
407
      if (fd == -1)
408
        {
409
          fprintf_unfiltered (gdb_stderr, "failed to open %s - %d (%s)\n",
410
                              buf, errno, safe_strerror (errno));
411
          do_cleanups (cleanups);
412
          return;
413
        }
414
      inner_cleanup = make_cleanup_close (fd);
415
 
416
      pidinfo = (procfs_info *) buf;
417
      if (devctl (fd, DCMD_PROC_INFO, pidinfo, sizeof (buf), 0) != EOK)
418
        {
419
          fprintf_unfiltered (gdb_stderr,
420
                              "devctl DCMD_PROC_INFO failed - %d (%s)\n",
421
                              errno, safe_strerror (errno));
422
          break;
423
        }
424
      num_threads = pidinfo->num_threads;
425
 
426
      info = (procfs_debuginfo *) buf;
427
      if (devctl (fd, DCMD_PROC_MAPDEBUG_BASE, info, sizeof (buf), 0) != EOK)
428
        strcpy (name, "unavailable");
429
      else
430
        strcpy (name, info->path);
431
 
432
      /* Collect state info on all the threads.  */
433
      status = (procfs_status *) buf;
434
      for (status->tid = 1; status->tid <= num_threads; status->tid++)
435
        {
436
          if (devctl (fd, DCMD_PROC_TIDSTATUS, status, sizeof (buf), 0) != EOK
437
              && status->tid != 0)
438
            break;
439
          if (status->tid != 0)
440
            printf_filtered ("%s - %d/%d\n", name, pid, status->tid);
441
        }
442
 
443
      do_cleanups (inner_cleanup);
444
    }
445
  while (dirp != NULL);
446
 
447
  do_cleanups (cleanups);
448
  return;
449
}
450
 
451
void
452
procfs_meminfo (char *args, int from_tty)
453
{
454
  procfs_mapinfo *mapinfos = NULL;
455
  static int num_mapinfos = 0;
456
  procfs_mapinfo *mapinfo_p, *mapinfo_p2;
457
  int flags = ~0, err, num, i, j;
458
 
459
  struct
460
  {
461
    procfs_debuginfo info;
462
    char buff[_POSIX_PATH_MAX];
463
  } map;
464
 
465
  struct info
466
  {
467
    unsigned addr;
468
    unsigned size;
469
    unsigned flags;
470
    unsigned debug_vaddr;
471
    unsigned long long offset;
472
  };
473
 
474
  struct printinfo
475
  {
476
    unsigned long long ino;
477
    unsigned dev;
478
    struct info text;
479
    struct info data;
480
    char name[256];
481
  } printme;
482
 
483
  /* Get the number of map entrys.  */
484
  err = devctl (ctl_fd, DCMD_PROC_MAPINFO, NULL, 0, &num);
485
  if (err != EOK)
486
    {
487
      printf ("failed devctl num mapinfos - %d (%s)\n", err,
488
              safe_strerror (err));
489
      return;
490
    }
491
 
492
  mapinfos = xmalloc (num * sizeof (procfs_mapinfo));
493
 
494
  num_mapinfos = num;
495
  mapinfo_p = mapinfos;
496
 
497
  /* Fill the map entrys.  */
498
  err = devctl (ctl_fd, DCMD_PROC_MAPINFO, mapinfo_p, num
499
                * sizeof (procfs_mapinfo), &num);
500
  if (err != EOK)
501
    {
502
      printf ("failed devctl mapinfos - %d (%s)\n", err, safe_strerror (err));
503
      xfree (mapinfos);
504
      return;
505
    }
506
 
507
  num = min (num, num_mapinfos);
508
 
509
  /* Run through the list of mapinfos, and store the data and text info
510
     so we can print it at the bottom of the loop.  */
511
  for (mapinfo_p = mapinfos, i = 0; i < num; i++, mapinfo_p++)
512
    {
513
      if (!(mapinfo_p->flags & flags))
514
        mapinfo_p->ino = 0;
515
 
516
      if (mapinfo_p->ino == 0)   /* Already visited.  */
517
        continue;
518
 
519
      map.info.vaddr = mapinfo_p->vaddr;
520
 
521
      err = devctl (ctl_fd, DCMD_PROC_MAPDEBUG, &map, sizeof (map), 0);
522
      if (err != EOK)
523
        continue;
524
 
525
      memset (&printme, 0, sizeof printme);
526
      printme.dev = mapinfo_p->dev;
527
      printme.ino = mapinfo_p->ino;
528
      printme.text.addr = mapinfo_p->vaddr;
529
      printme.text.size = mapinfo_p->size;
530
      printme.text.flags = mapinfo_p->flags;
531
      printme.text.offset = mapinfo_p->offset;
532
      printme.text.debug_vaddr = map.info.vaddr;
533
      strcpy (printme.name, map.info.path);
534
 
535
      /* Check for matching data.  */
536
      for (mapinfo_p2 = mapinfos, j = 0; j < num; j++, mapinfo_p2++)
537
        {
538
          if (mapinfo_p2->vaddr != mapinfo_p->vaddr
539
              && mapinfo_p2->ino == mapinfo_p->ino
540
              && mapinfo_p2->dev == mapinfo_p->dev)
541
            {
542
              map.info.vaddr = mapinfo_p2->vaddr;
543
              err =
544
                devctl (ctl_fd, DCMD_PROC_MAPDEBUG, &map, sizeof (map), 0);
545
              if (err != EOK)
546
                continue;
547
 
548
              if (strcmp (map.info.path, printme.name))
549
                continue;
550
 
551
              /* Lower debug_vaddr is always text, if nessessary, swap.  */
552
              if ((int) map.info.vaddr < (int) printme.text.debug_vaddr)
553
                {
554
                  memcpy (&(printme.data), &(printme.text),
555
                          sizeof (printme.data));
556
                  printme.text.addr = mapinfo_p2->vaddr;
557
                  printme.text.size = mapinfo_p2->size;
558
                  printme.text.flags = mapinfo_p2->flags;
559
                  printme.text.offset = mapinfo_p2->offset;
560
                  printme.text.debug_vaddr = map.info.vaddr;
561
                }
562
              else
563
                {
564
                  printme.data.addr = mapinfo_p2->vaddr;
565
                  printme.data.size = mapinfo_p2->size;
566
                  printme.data.flags = mapinfo_p2->flags;
567
                  printme.data.offset = mapinfo_p2->offset;
568
                  printme.data.debug_vaddr = map.info.vaddr;
569
                }
570
              mapinfo_p2->ino = 0;
571
            }
572
        }
573
      mapinfo_p->ino = 0;
574
 
575
      printf_filtered ("%s\n", printme.name);
576
      printf_filtered ("\ttext=%08x bytes @ 0x%08x\n", printme.text.size,
577
                       printme.text.addr);
578
      printf_filtered ("\t\tflags=%08x\n", printme.text.flags);
579
      printf_filtered ("\t\tdebug=%08x\n", printme.text.debug_vaddr);
580
      printf_filtered ("\t\toffset=%016llx\n", printme.text.offset);
581
      if (printme.data.size)
582
        {
583
          printf_filtered ("\tdata=%08x bytes @ 0x%08x\n", printme.data.size,
584
                           printme.data.addr);
585
          printf_filtered ("\t\tflags=%08x\n", printme.data.flags);
586
          printf_filtered ("\t\tdebug=%08x\n", printme.data.debug_vaddr);
587
          printf_filtered ("\t\toffset=%016llx\n", printme.data.offset);
588
        }
589
      printf_filtered ("\tdev=0x%x\n", printme.dev);
590
      printf_filtered ("\tino=0x%x\n", (unsigned int) printme.ino);
591
    }
592
  xfree (mapinfos);
593
  return;
594
}
595
 
596
/* Print status information about what we're accessing.  */
597
static void
598
procfs_files_info (struct target_ops *ignore)
599
{
600
  struct inferior *inf = current_inferior ();
601
 
602
  printf_unfiltered ("\tUsing the running image of %s %s via %s.\n",
603
                     inf->attach_flag ? "attached" : "child",
604
                     target_pid_to_str (inferior_ptid), nto_procfs_path);
605
}
606
 
607
/* Mark our target-struct as eligible for stray "run" and "attach" commands.  */
608
static int
609
procfs_can_run (void)
610
{
611
  return 1;
612
}
613
 
614
/* Attach to process PID, then initialize for debugging it.  */
615
static void
616
procfs_attach (struct target_ops *ops, char *args, int from_tty)
617
{
618
  char *exec_file;
619
  int pid;
620
  struct inferior *inf;
621
 
622
  pid = parse_pid_to_attach (args);
623
 
624
  if (pid == getpid ())
625
    error (_("Attaching GDB to itself is not a good idea..."));
626
 
627
  if (from_tty)
628
    {
629
      exec_file = (char *) get_exec_file (0);
630
 
631
      if (exec_file)
632
        printf_unfiltered ("Attaching to program `%s', %s\n", exec_file,
633
                           target_pid_to_str (pid_to_ptid (pid)));
634
      else
635
        printf_unfiltered ("Attaching to %s\n",
636
                           target_pid_to_str (pid_to_ptid (pid)));
637
 
638
      gdb_flush (gdb_stdout);
639
    }
640
  inferior_ptid = do_attach (pid_to_ptid (pid));
641
  inf = current_inferior ();
642
  inferior_appeared (inf, pid);
643
  inf->attach_flag = 1;
644
 
645
  push_target (ops);
646
 
647
  procfs_find_new_threads (ops);
648
}
649
 
650
static void
651
procfs_post_attach (pid_t pid)
652
{
653
  if (exec_bfd)
654
    solib_create_inferior_hook (0);
655
}
656
 
657
static ptid_t
658
do_attach (ptid_t ptid)
659
{
660
  procfs_status status;
661
  struct sigevent event;
662
  char path[PATH_MAX];
663
 
664
  snprintf (path, PATH_MAX - 1, "%s/%d/as", nto_procfs_path, PIDGET (ptid));
665
  ctl_fd = open (path, O_RDWR);
666
  if (ctl_fd == -1)
667
    error (_("Couldn't open proc file %s, error %d (%s)"), path, errno,
668
           safe_strerror (errno));
669
  if (devctl (ctl_fd, DCMD_PROC_STOP, &status, sizeof (status), 0) != EOK)
670
    error (_("Couldn't stop process"));
671
 
672
  /* Define a sigevent for process stopped notification.  */
673
  event.sigev_notify = SIGEV_SIGNAL_THREAD;
674
  event.sigev_signo = SIGUSR1;
675
  event.sigev_code = 0;
676
  event.sigev_value.sival_ptr = NULL;
677
  event.sigev_priority = -1;
678
  devctl (ctl_fd, DCMD_PROC_EVENT, &event, sizeof (event), 0);
679
 
680
  if (devctl (ctl_fd, DCMD_PROC_STATUS, &status, sizeof (status), 0) == EOK
681
      && status.flags & _DEBUG_FLAG_STOPPED)
682
    SignalKill (nto_node (), PIDGET (ptid), 0, SIGCONT, 0, 0);
683
  nto_init_solib_absolute_prefix ();
684
  return ptid_build (PIDGET (ptid), 0, status.tid);
685
}
686
 
687
/* Ask the user what to do when an interrupt is received.  */
688
static void
689
interrupt_query (void)
690
{
691
  target_terminal_ours ();
692
 
693
  if (query (_("Interrupted while waiting for the program.\n\
694
Give up (and stop debugging it)? ")))
695
    {
696
      target_mourn_inferior ();
697
      deprecated_throw_reason (RETURN_QUIT);
698
    }
699
 
700
  target_terminal_inferior ();
701
}
702
 
703
/* The user typed ^C twice.  */
704
static void
705
nto_interrupt_twice (int signo)
706
{
707
  signal (signo, ofunc);
708
  interrupt_query ();
709
  signal (signo, nto_interrupt_twice);
710
}
711
 
712
static void
713
nto_interrupt (int signo)
714
{
715
  /* If this doesn't work, try more severe steps.  */
716
  signal (signo, nto_interrupt_twice);
717
 
718
  target_stop (inferior_ptid);
719
}
720
 
721
static ptid_t
722
procfs_wait (struct target_ops *ops,
723
             ptid_t ptid, struct target_waitstatus *ourstatus, int options)
724
{
725
  sigset_t set;
726
  siginfo_t info;
727
  procfs_status status;
728
  static int exit_signo = 0;     /* To track signals that cause termination.  */
729
 
730
  ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
731
 
732
  if (ptid_equal (inferior_ptid, null_ptid))
733
    {
734
      ourstatus->kind = TARGET_WAITKIND_STOPPED;
735
      ourstatus->value.sig = TARGET_SIGNAL_0;
736
      exit_signo = 0;
737
      return null_ptid;
738
    }
739
 
740
  sigemptyset (&set);
741
  sigaddset (&set, SIGUSR1);
742
 
743
  devctl (ctl_fd, DCMD_PROC_STATUS, &status, sizeof (status), 0);
744
  while (!(status.flags & _DEBUG_FLAG_ISTOP))
745
    {
746
      ofunc = (void (*)()) signal (SIGINT, nto_interrupt);
747
      sigwaitinfo (&set, &info);
748
      signal (SIGINT, ofunc);
749
      devctl (ctl_fd, DCMD_PROC_STATUS, &status, sizeof (status), 0);
750
    }
751
 
752
  if (status.flags & _DEBUG_FLAG_SSTEP)
753
    {
754
      ourstatus->kind = TARGET_WAITKIND_STOPPED;
755
      ourstatus->value.sig = TARGET_SIGNAL_TRAP;
756
    }
757
  /* Was it a breakpoint?  */
758
  else if (status.flags & _DEBUG_FLAG_TRACE)
759
    {
760
      ourstatus->kind = TARGET_WAITKIND_STOPPED;
761
      ourstatus->value.sig = TARGET_SIGNAL_TRAP;
762
    }
763
  else if (status.flags & _DEBUG_FLAG_ISTOP)
764
    {
765
      switch (status.why)
766
        {
767
        case _DEBUG_WHY_SIGNALLED:
768
          ourstatus->kind = TARGET_WAITKIND_STOPPED;
769
          ourstatus->value.sig =
770
            target_signal_from_host (status.info.si_signo);
771
          exit_signo = 0;
772
          break;
773
        case _DEBUG_WHY_FAULTED:
774
          ourstatus->kind = TARGET_WAITKIND_STOPPED;
775
          if (status.info.si_signo == SIGTRAP)
776
            {
777
              ourstatus->value.sig = 0;
778
              exit_signo = 0;
779
            }
780
          else
781
            {
782
              ourstatus->value.sig =
783
                target_signal_from_host (status.info.si_signo);
784
              exit_signo = ourstatus->value.sig;
785
            }
786
          break;
787
 
788
        case _DEBUG_WHY_TERMINATED:
789
          {
790
            int waitval = 0;
791
 
792
            waitpid (PIDGET (inferior_ptid), &waitval, WNOHANG);
793
            if (exit_signo)
794
              {
795
                /* Abnormal death.  */
796
                ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
797
                ourstatus->value.sig = exit_signo;
798
              }
799
            else
800
              {
801
                /* Normal death.  */
802
                ourstatus->kind = TARGET_WAITKIND_EXITED;
803
                ourstatus->value.integer = WEXITSTATUS (waitval);
804
              }
805
            exit_signo = 0;
806
            break;
807
          }
808
 
809
        case _DEBUG_WHY_REQUESTED:
810
          /* We are assuming a requested stop is due to a SIGINT.  */
811
          ourstatus->kind = TARGET_WAITKIND_STOPPED;
812
          ourstatus->value.sig = TARGET_SIGNAL_INT;
813
          exit_signo = 0;
814
          break;
815
        }
816
    }
817
 
818
  return ptid_build (status.pid, 0, status.tid);
819
}
820
 
821
/* Read the current values of the inferior's registers, both the
822
   general register set and floating point registers (if supported)
823
   and update gdb's idea of their current values.  */
824
static void
825
procfs_fetch_registers (struct target_ops *ops,
826
                        struct regcache *regcache, int regno)
827
{
828
  union
829
  {
830
    procfs_greg greg;
831
    procfs_fpreg fpreg;
832
    procfs_altreg altreg;
833
  }
834
  reg;
835
  int regsize;
836
 
837
  procfs_set_thread (inferior_ptid);
838
  if (devctl (ctl_fd, DCMD_PROC_GETGREG, &reg, sizeof (reg), &regsize) == EOK)
839
    nto_supply_gregset (regcache, (char *) &reg.greg);
840
  if (devctl (ctl_fd, DCMD_PROC_GETFPREG, &reg, sizeof (reg), &regsize)
841
      == EOK)
842
    nto_supply_fpregset (regcache, (char *) &reg.fpreg);
843
  if (devctl (ctl_fd, DCMD_PROC_GETALTREG, &reg, sizeof (reg), &regsize)
844
      == EOK)
845
    nto_supply_altregset (regcache, (char *) &reg.altreg);
846
}
847
 
848
/* Copy LEN bytes to/from inferior's memory starting at MEMADDR
849
   from/to debugger memory starting at MYADDR.  Copy from inferior
850
   if DOWRITE is zero or to inferior if DOWRITE is nonzero.
851
 
852
   Returns the length copied, which is either the LEN argument or
853
   zero.  This xfer function does not do partial moves, since procfs_ops
854
   doesn't allow memory operations to cross below us in the target stack
855
   anyway.  */
856
static int
857
procfs_xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len, int dowrite,
858
                    struct mem_attrib *attrib, struct target_ops *target)
859
{
860
  int nbytes = 0;
861
 
862
  if (lseek (ctl_fd, (off_t) memaddr, SEEK_SET) == (off_t) memaddr)
863
    {
864
      if (dowrite)
865
        nbytes = write (ctl_fd, myaddr, len);
866
      else
867
        nbytes = read (ctl_fd, myaddr, len);
868
      if (nbytes < 0)
869
        nbytes = 0;
870
    }
871
  return (nbytes);
872
}
873
 
874
/* Take a program previously attached to and detaches it.
875
   The program resumes execution and will no longer stop
876
   on signals, etc.  We'd better not have left any breakpoints
877
   in the program or it'll die when it hits one.  */
878
static void
879
procfs_detach (struct target_ops *ops, char *args, int from_tty)
880
{
881
  int siggnal = 0;
882
  int pid;
883
 
884
  if (from_tty)
885
    {
886
      char *exec_file = get_exec_file (0);
887
      if (exec_file == 0)
888
        exec_file = "";
889
      printf_unfiltered ("Detaching from program: %s %s\n",
890
                         exec_file, target_pid_to_str (inferior_ptid));
891
      gdb_flush (gdb_stdout);
892
    }
893
  if (args)
894
    siggnal = atoi (args);
895
 
896
  if (siggnal)
897
    SignalKill (nto_node (), PIDGET (inferior_ptid), 0, siggnal, 0, 0);
898
 
899
  close (ctl_fd);
900
  ctl_fd = -1;
901
 
902
  pid = ptid_get_pid (inferior_ptid);
903
  inferior_ptid = null_ptid;
904
  detach_inferior (pid);
905
  init_thread_list ();
906
  unpush_target (&procfs_ops);  /* Pop out of handling an inferior.  */
907
}
908
 
909
static int
910
procfs_breakpoint (CORE_ADDR addr, int type, int size)
911
{
912
  procfs_break brk;
913
 
914
  brk.type = type;
915
  brk.addr = addr;
916
  brk.size = size;
917
  errno = devctl (ctl_fd, DCMD_PROC_BREAK, &brk, sizeof (brk), 0);
918
  if (errno != EOK)
919
    return 1;
920
  return 0;
921
}
922
 
923
static int
924
procfs_insert_breakpoint (struct gdbarch *gdbarch,
925
                          struct bp_target_info *bp_tgt)
926
{
927
  return procfs_breakpoint (bp_tgt->placed_address, _DEBUG_BREAK_EXEC, 0);
928
}
929
 
930
static int
931
procfs_remove_breakpoint (struct gdbarch *gdbarch,
932
                          struct bp_target_info *bp_tgt)
933
{
934
  return procfs_breakpoint (bp_tgt->placed_address, _DEBUG_BREAK_EXEC, -1);
935
}
936
 
937
static int
938
procfs_insert_hw_breakpoint (struct gdbarch *gdbarch,
939
                             struct bp_target_info *bp_tgt)
940
{
941
  return procfs_breakpoint (bp_tgt->placed_address,
942
                            _DEBUG_BREAK_EXEC | _DEBUG_BREAK_HW, 0);
943
}
944
 
945
static int
946
procfs_remove_hw_breakpoint (struct gdbarch *gdbarch,
947
                             struct bp_target_info *bp_tgt)
948
{
949
  return procfs_breakpoint (bp_tgt->placed_address,
950
                            _DEBUG_BREAK_EXEC | _DEBUG_BREAK_HW, -1);
951
}
952
 
953
static void
954
procfs_resume (struct target_ops *ops,
955
               ptid_t ptid, int step, enum target_signal signo)
956
{
957
  int signal_to_pass;
958
  procfs_status status;
959
  sigset_t *run_fault = (sigset_t *) (void *) &run.fault;
960
 
961
  if (ptid_equal (inferior_ptid, null_ptid))
962
    return;
963
 
964
  procfs_set_thread (ptid_equal (ptid, minus_one_ptid) ? inferior_ptid :
965
                     ptid);
966
 
967
  run.flags = _DEBUG_RUN_FAULT | _DEBUG_RUN_TRACE;
968
  if (step)
969
    run.flags |= _DEBUG_RUN_STEP;
970
 
971
  sigemptyset (run_fault);
972
  sigaddset (run_fault, FLTBPT);
973
  sigaddset (run_fault, FLTTRACE);
974
  sigaddset (run_fault, FLTILL);
975
  sigaddset (run_fault, FLTPRIV);
976
  sigaddset (run_fault, FLTBOUNDS);
977
  sigaddset (run_fault, FLTIOVF);
978
  sigaddset (run_fault, FLTIZDIV);
979
  sigaddset (run_fault, FLTFPE);
980
  /* Peter V will be changing this at some point.  */
981
  sigaddset (run_fault, FLTPAGE);
982
 
983
  run.flags |= _DEBUG_RUN_ARM;
984
 
985
  sigemptyset (&run.trace);
986
  notice_signals ();
987
  signal_to_pass = target_signal_to_host (signo);
988
 
989
  if (signal_to_pass)
990
    {
991
      devctl (ctl_fd, DCMD_PROC_STATUS, &status, sizeof (status), 0);
992
      signal_to_pass = target_signal_to_host (signo);
993
      if (status.why & (_DEBUG_WHY_SIGNALLED | _DEBUG_WHY_FAULTED))
994
        {
995
          if (signal_to_pass != status.info.si_signo)
996
            {
997
              SignalKill (nto_node (), PIDGET (inferior_ptid), 0,
998
                          signal_to_pass, 0, 0);
999
              run.flags |= _DEBUG_RUN_CLRFLT | _DEBUG_RUN_CLRSIG;
1000
            }
1001
          else                  /* Let it kill the program without telling us.  */
1002
            sigdelset (&run.trace, signal_to_pass);
1003
        }
1004
    }
1005
  else
1006
    run.flags |= _DEBUG_RUN_CLRSIG | _DEBUG_RUN_CLRFLT;
1007
 
1008
  errno = devctl (ctl_fd, DCMD_PROC_RUN, &run, sizeof (run), 0);
1009
  if (errno != EOK)
1010
    {
1011
      perror ("run error!\n");
1012
      return;
1013
    }
1014
}
1015
 
1016
static void
1017
procfs_mourn_inferior (struct target_ops *ops)
1018
{
1019
  if (!ptid_equal (inferior_ptid, null_ptid))
1020
    {
1021
      SignalKill (nto_node (), PIDGET (inferior_ptid), 0, SIGKILL, 0, 0);
1022
      close (ctl_fd);
1023
    }
1024
  inferior_ptid = null_ptid;
1025
  init_thread_list ();
1026
  unpush_target (&procfs_ops);
1027
  generic_mourn_inferior ();
1028
}
1029
 
1030
/* This function breaks up an argument string into an argument
1031
   vector suitable for passing to execvp().
1032
   E.g., on "run a b c d" this routine would get as input
1033
   the string "a b c d", and as output it would fill in argv with
1034
   the four arguments "a", "b", "c", "d".  The only additional
1035
   functionality is simple quoting.  The gdb command:
1036
        run a "b c d" f
1037
   will fill in argv with the three args "a", "b c d", "e".  */
1038
static void
1039
breakup_args (char *scratch, char **argv)
1040
{
1041
  char *pp, *cp = scratch;
1042
  char quoting = 0;
1043
 
1044
  for (;;)
1045
    {
1046
      /* Scan past leading separators.  */
1047
      quoting = 0;
1048
      while (*cp == ' ' || *cp == '\t' || *cp == '\n')
1049
        cp++;
1050
 
1051
      /* Break if at end of string.  */
1052
      if (*cp == '\0')
1053
        break;
1054
 
1055
      /* Take an arg.  */
1056
      if (*cp == '"')
1057
        {
1058
          cp++;
1059
          quoting = strchr (cp, '"') ? 1 : 0;
1060
        }
1061
 
1062
      *argv++ = cp;
1063
 
1064
      /* Scan for next arg separator.  */
1065
      pp = cp;
1066
      if (quoting)
1067
        cp = strchr (pp, '"');
1068
      if ((cp == NULL) || (!quoting))
1069
        cp = strchr (pp, ' ');
1070
      if (cp == NULL)
1071
        cp = strchr (pp, '\t');
1072
      if (cp == NULL)
1073
        cp = strchr (pp, '\n');
1074
 
1075
      /* No separators => end of string => break.  */
1076
      if (cp == NULL)
1077
        {
1078
          pp = cp;
1079
          break;
1080
        }
1081
 
1082
      /* Replace the separator with a terminator.  */
1083
      *cp++ = '\0';
1084
    }
1085
 
1086
  /* Execv requires a null-terminated arg vector.  */
1087
  *argv = NULL;
1088
}
1089
 
1090
static void
1091
procfs_create_inferior (struct target_ops *ops, char *exec_file,
1092
                        char *allargs, char **env, int from_tty)
1093
{
1094
  struct inheritance inherit;
1095
  pid_t pid;
1096
  int flags, errn;
1097
  char **argv, *args;
1098
  const char *in = "", *out = "", *err = "";
1099
  int fd, fds[3];
1100
  sigset_t set;
1101
  const char *inferior_io_terminal = get_inferior_io_terminal ();
1102
  struct inferior *inf;
1103
 
1104
  argv = xmalloc (((strlen (allargs) + 1) / (unsigned) 2 + 2) *
1105
                  sizeof (*argv));
1106
  argv[0] = get_exec_file (1);
1107
  if (!argv[0])
1108
    {
1109
      if (exec_file)
1110
        argv[0] = exec_file;
1111
      else
1112
        return;
1113
    }
1114
 
1115
  args = xstrdup (allargs);
1116
  breakup_args (args, exec_file ? &argv[1] : &argv[0]);
1117
 
1118
  argv = nto_parse_redirection (argv, &in, &out, &err);
1119
 
1120
  fds[0] = STDIN_FILENO;
1121
  fds[1] = STDOUT_FILENO;
1122
  fds[2] = STDERR_FILENO;
1123
 
1124
  /* If the user specified I/O via gdb's --tty= arg, use it, but only
1125
     if the i/o is not also being specified via redirection.  */
1126
  if (inferior_io_terminal)
1127
    {
1128
      if (!in[0])
1129
        in = inferior_io_terminal;
1130
      if (!out[0])
1131
        out = inferior_io_terminal;
1132
      if (!err[0])
1133
        err = inferior_io_terminal;
1134
    }
1135
 
1136
  if (in[0])
1137
    {
1138
      fd = open (in, O_RDONLY);
1139
      if (fd == -1)
1140
        perror (in);
1141
      else
1142
        fds[0] = fd;
1143
    }
1144
  if (out[0])
1145
    {
1146
      fd = open (out, O_WRONLY);
1147
      if (fd == -1)
1148
        perror (out);
1149
      else
1150
        fds[1] = fd;
1151
    }
1152
  if (err[0])
1153
    {
1154
      fd = open (err, O_WRONLY);
1155
      if (fd == -1)
1156
        perror (err);
1157
      else
1158
        fds[2] = fd;
1159
    }
1160
 
1161
  /* Clear any pending SIGUSR1's but keep the behavior the same.  */
1162
  signal (SIGUSR1, signal (SIGUSR1, SIG_IGN));
1163
 
1164
  sigemptyset (&set);
1165
  sigaddset (&set, SIGUSR1);
1166
  sigprocmask (SIG_UNBLOCK, &set, NULL);
1167
 
1168
  memset (&inherit, 0, sizeof (inherit));
1169
 
1170
  if (ND_NODE_CMP (nto_procfs_node, ND_LOCAL_NODE) != 0)
1171
    {
1172
      inherit.nd = nto_node ();
1173
      inherit.flags |= SPAWN_SETND;
1174
      inherit.flags &= ~SPAWN_EXEC;
1175
    }
1176
  inherit.flags |= SPAWN_SETGROUP | SPAWN_HOLD;
1177
  inherit.pgroup = SPAWN_NEWPGROUP;
1178
  pid = spawnp (argv[0], 3, fds, &inherit, argv,
1179
                ND_NODE_CMP (nto_procfs_node, ND_LOCAL_NODE) == 0 ? env : 0);
1180
  xfree (args);
1181
 
1182
  sigprocmask (SIG_BLOCK, &set, NULL);
1183
 
1184
  if (pid == -1)
1185
    error (_("Error spawning %s: %d (%s)"), argv[0], errno,
1186
           safe_strerror (errno));
1187
 
1188
  if (fds[0] != STDIN_FILENO)
1189
    close (fds[0]);
1190
  if (fds[1] != STDOUT_FILENO)
1191
    close (fds[1]);
1192
  if (fds[2] != STDERR_FILENO)
1193
    close (fds[2]);
1194
 
1195
  inferior_ptid = do_attach (pid_to_ptid (pid));
1196
  procfs_find_new_threads (ops);
1197
 
1198
  inf = current_inferior ();
1199
  inferior_appeared (inf, pid);
1200
  inf->attach_flag = 0;
1201
 
1202
  flags = _DEBUG_FLAG_KLC;      /* Kill-on-Last-Close flag.  */
1203
  errn = devctl (ctl_fd, DCMD_PROC_SET_FLAG, &flags, sizeof (flags), 0);
1204
  if (errn != EOK)
1205
    {
1206
      /* FIXME: expected warning?  */
1207
      /* warning( "Failed to set Kill-on-Last-Close flag: errno = %d(%s)\n",
1208
         errn, strerror(errn) ); */
1209
    }
1210
  push_target (ops);
1211
  target_terminal_init ();
1212
 
1213
  if (exec_bfd != NULL
1214
      || (symfile_objfile != NULL && symfile_objfile->obfd != NULL))
1215
    solib_create_inferior_hook (0);
1216
}
1217
 
1218
static void
1219
procfs_stop (ptid_t ptid)
1220
{
1221
  devctl (ctl_fd, DCMD_PROC_STOP, NULL, 0, 0);
1222
}
1223
 
1224
static void
1225
procfs_kill_inferior (struct target_ops *ops)
1226
{
1227
  target_mourn_inferior ();
1228
}
1229
 
1230
/* Store register REGNO, or all registers if REGNO == -1, from the contents
1231
   of REGISTERS.  */
1232
static void
1233
procfs_prepare_to_store (struct regcache *regcache)
1234
{
1235
}
1236
 
1237
/* Fill buf with regset and return devctl cmd to do the setting.  Return
1238
   -1 if we fail to get the regset.  Store size of regset in regsize.  */
1239
static int
1240
get_regset (int regset, char *buf, int bufsize, int *regsize)
1241
{
1242
  int dev_get, dev_set;
1243
  switch (regset)
1244
    {
1245
    case NTO_REG_GENERAL:
1246
      dev_get = DCMD_PROC_GETGREG;
1247
      dev_set = DCMD_PROC_SETGREG;
1248
      break;
1249
 
1250
    case NTO_REG_FLOAT:
1251
      dev_get = DCMD_PROC_GETFPREG;
1252
      dev_set = DCMD_PROC_SETFPREG;
1253
      break;
1254
 
1255
    case NTO_REG_ALT:
1256
      dev_get = DCMD_PROC_GETALTREG;
1257
      dev_set = DCMD_PROC_SETALTREG;
1258
      break;
1259
 
1260
    case NTO_REG_SYSTEM:
1261
    default:
1262
      return -1;
1263
    }
1264
  if (devctl (ctl_fd, dev_get, buf, bufsize, regsize) != EOK)
1265
    return -1;
1266
 
1267
  return dev_set;
1268
}
1269
 
1270
void
1271
procfs_store_registers (struct target_ops *ops,
1272
                        struct regcache *regcache, int regno)
1273
{
1274
  union
1275
  {
1276
    procfs_greg greg;
1277
    procfs_fpreg fpreg;
1278
    procfs_altreg altreg;
1279
  }
1280
  reg;
1281
  unsigned off;
1282
  int len, regset, regsize, dev_set, err;
1283
  char *data;
1284
 
1285
  if (ptid_equal (inferior_ptid, null_ptid))
1286
    return;
1287
  procfs_set_thread (inferior_ptid);
1288
 
1289
  if (regno == -1)
1290
    {
1291
      for (regset = NTO_REG_GENERAL; regset < NTO_REG_END; regset++)
1292
        {
1293
          dev_set = get_regset (regset, (char *) &reg,
1294
                                sizeof (reg), &regsize);
1295
          if (dev_set == -1)
1296
            continue;
1297
 
1298
          if (nto_regset_fill (regcache, regset, (char *) &reg) == -1)
1299
            continue;
1300
 
1301
          err = devctl (ctl_fd, dev_set, &reg, regsize, 0);
1302
          if (err != EOK)
1303
            fprintf_unfiltered (gdb_stderr,
1304
                                "Warning unable to write regset %d: %s\n",
1305
                                regno, safe_strerror (err));
1306
        }
1307
    }
1308
  else
1309
    {
1310
      regset = nto_regset_id (regno);
1311
      if (regset == -1)
1312
        return;
1313
 
1314
      dev_set = get_regset (regset, (char *) &reg, sizeof (reg), &regsize);
1315
      if (dev_set == -1)
1316
        return;
1317
 
1318
      len = nto_register_area (get_regcache_arch (regcache),
1319
                               regno, regset, &off);
1320
 
1321
      if (len < 1)
1322
        return;
1323
 
1324
      regcache_raw_collect (regcache, regno, (char *) &reg + off);
1325
 
1326
      err = devctl (ctl_fd, dev_set, &reg, regsize, 0);
1327
      if (err != EOK)
1328
        fprintf_unfiltered (gdb_stderr,
1329
                            "Warning unable to write regset %d: %s\n", regno,
1330
                            safe_strerror (err));
1331
    }
1332
}
1333
 
1334
static void
1335
notice_signals (void)
1336
{
1337
  int signo;
1338
 
1339
  for (signo = 1; signo < NSIG; signo++)
1340
    {
1341
      if (signal_stop_state (target_signal_from_host (signo)) == 0
1342
          && signal_print_state (target_signal_from_host (signo)) == 0
1343
          && signal_pass_state (target_signal_from_host (signo)) == 1)
1344
        sigdelset (&run.trace, signo);
1345
      else
1346
        sigaddset (&run.trace, signo);
1347
    }
1348
}
1349
 
1350
/* When the user changes the state of gdb's signal handling via the
1351
   "handle" command, this function gets called to see if any change
1352
   in the /proc interface is required.  It is also called internally
1353
   by other /proc interface functions to initialize the state of
1354
   the traced signal set.  */
1355
static void
1356
procfs_notice_signals (ptid_t ptid)
1357
{
1358
  sigemptyset (&run.trace);
1359
  notice_signals ();
1360
}
1361
 
1362
static struct tidinfo *
1363
procfs_thread_info (pid_t pid, short tid)
1364
{
1365
/* NYI */
1366
  return NULL;
1367
}
1368
 
1369
char *
1370
procfs_pid_to_str (struct target_ops *ops, ptid_t ptid)
1371
{
1372
  static char buf[1024];
1373
  int pid, tid, n;
1374
  struct tidinfo *tip;
1375
 
1376
  pid = ptid_get_pid (ptid);
1377
  tid = ptid_get_tid (ptid);
1378
 
1379
  n = snprintf (buf, 1023, "process %d", pid);
1380
 
1381
#if 0                           /* NYI */
1382
  tip = procfs_thread_info (pid, tid);
1383
  if (tip != NULL)
1384
    snprintf (&buf[n], 1023, " (state = 0x%02x)", tip->state);
1385
#endif
1386
 
1387
  return buf;
1388
}
1389
 
1390
static void
1391
init_procfs_ops (void)
1392
{
1393
  procfs_ops.to_shortname = "procfs";
1394
  procfs_ops.to_longname = "QNX Neutrino procfs child process";
1395
  procfs_ops.to_doc =
1396
    "QNX Neutrino procfs child process (started by the \"run\" command).\n\
1397
        target procfs <node>";
1398
  procfs_ops.to_open = procfs_open;
1399
  procfs_ops.to_attach = procfs_attach;
1400
  procfs_ops.to_post_attach = procfs_post_attach;
1401
  procfs_ops.to_detach = procfs_detach;
1402
  procfs_ops.to_resume = procfs_resume;
1403
  procfs_ops.to_wait = procfs_wait;
1404
  procfs_ops.to_fetch_registers = procfs_fetch_registers;
1405
  procfs_ops.to_store_registers = procfs_store_registers;
1406
  procfs_ops.to_prepare_to_store = procfs_prepare_to_store;
1407
  procfs_ops.deprecated_xfer_memory = procfs_xfer_memory;
1408
  procfs_ops.to_files_info = procfs_files_info;
1409
  procfs_ops.to_insert_breakpoint = procfs_insert_breakpoint;
1410
  procfs_ops.to_remove_breakpoint = procfs_remove_breakpoint;
1411
  procfs_ops.to_can_use_hw_breakpoint = procfs_can_use_hw_breakpoint;
1412
  procfs_ops.to_insert_hw_breakpoint = procfs_insert_hw_breakpoint;
1413
  procfs_ops.to_remove_hw_breakpoint = procfs_remove_breakpoint;
1414
  procfs_ops.to_insert_watchpoint = procfs_insert_hw_watchpoint;
1415
  procfs_ops.to_remove_watchpoint = procfs_remove_hw_watchpoint;
1416
  procfs_ops.to_stopped_by_watchpoint = procfs_stopped_by_watchpoint;
1417
  procfs_ops.to_terminal_init = terminal_init_inferior;
1418
  procfs_ops.to_terminal_inferior = terminal_inferior;
1419
  procfs_ops.to_terminal_ours_for_output = terminal_ours_for_output;
1420
  procfs_ops.to_terminal_ours = terminal_ours;
1421
  procfs_ops.to_terminal_info = child_terminal_info;
1422
  procfs_ops.to_kill = procfs_kill_inferior;
1423
  procfs_ops.to_create_inferior = procfs_create_inferior;
1424
  procfs_ops.to_mourn_inferior = procfs_mourn_inferior;
1425
  procfs_ops.to_can_run = procfs_can_run;
1426
  procfs_ops.to_notice_signals = procfs_notice_signals;
1427
  procfs_ops.to_thread_alive = procfs_thread_alive;
1428
  procfs_ops.to_find_new_threads = procfs_find_new_threads;
1429
  procfs_ops.to_pid_to_str = procfs_pid_to_str;
1430
  procfs_ops.to_stop = procfs_stop;
1431
  procfs_ops.to_stratum = process_stratum;
1432
  procfs_ops.to_has_all_memory = default_child_has_all_memory;
1433
  procfs_ops.to_has_memory = default_child_has_memory;
1434
  procfs_ops.to_has_stack = default_child_has_stack;
1435
  procfs_ops.to_has_registers = default_child_has_registers;
1436
  procfs_ops.to_has_execution = default_child_has_execution;
1437
  procfs_ops.to_magic = OPS_MAGIC;
1438
  procfs_ops.to_have_continuable_watchpoint = 1;
1439
  procfs_ops.to_extra_thread_info = nto_extra_thread_info;
1440
}
1441
 
1442
#define OSTYPE_NTO 1
1443
 
1444
void
1445
_initialize_procfs (void)
1446
{
1447
  sigset_t set;
1448
 
1449
  init_procfs_ops ();
1450
  add_target (&procfs_ops);
1451
 
1452
  /* We use SIGUSR1 to gain control after we block waiting for a process.
1453
     We use sigwaitevent to wait.  */
1454
  sigemptyset (&set);
1455
  sigaddset (&set, SIGUSR1);
1456
  sigprocmask (SIG_BLOCK, &set, NULL);
1457
 
1458
  /* Set up trace and fault sets, as gdb expects them.  */
1459
  sigemptyset (&run.trace);
1460
 
1461
  /* Stuff some information.  */
1462
  nto_cpuinfo_flags = SYSPAGE_ENTRY (cpuinfo)->flags;
1463
  nto_cpuinfo_valid = 1;
1464
 
1465
  add_info ("pidlist", procfs_pidlist, _("pidlist"));
1466
  add_info ("meminfo", procfs_meminfo, _("memory information"));
1467
 
1468
  nto_is_nto_target = procfs_is_nto_target;
1469
}
1470
 
1471
 
1472
static int
1473
procfs_hw_watchpoint (int addr, int len, int type)
1474
{
1475
  procfs_break brk;
1476
 
1477
  switch (type)
1478
    {
1479
    case 1:                     /* Read.  */
1480
      brk.type = _DEBUG_BREAK_RD;
1481
      break;
1482
    case 2:                     /* Read/Write.  */
1483
      brk.type = _DEBUG_BREAK_RW;
1484
      break;
1485
    default:                    /* Modify.  */
1486
/* FIXME: brk.type = _DEBUG_BREAK_RWM gives EINVAL for some reason.  */
1487
      brk.type = _DEBUG_BREAK_RW;
1488
    }
1489
  brk.type |= _DEBUG_BREAK_HW;  /* Always ask for HW.  */
1490
  brk.addr = addr;
1491
  brk.size = len;
1492
 
1493
  errno = devctl (ctl_fd, DCMD_PROC_BREAK, &brk, sizeof (brk), 0);
1494
  if (errno != EOK)
1495
    {
1496
      perror ("Failed to set hardware watchpoint");
1497
      return -1;
1498
    }
1499
  return 0;
1500
}
1501
 
1502
static int
1503
procfs_can_use_hw_breakpoint (int type, int cnt, int othertype)
1504
{
1505
  return 1;
1506
}
1507
 
1508
static int
1509
procfs_remove_hw_watchpoint (CORE_ADDR addr, int len, int type)
1510
{
1511
  return procfs_hw_watchpoint (addr, -1, type);
1512
}
1513
 
1514
static int
1515
procfs_insert_hw_watchpoint (CORE_ADDR addr, int len, int type)
1516
{
1517
  return procfs_hw_watchpoint (addr, len, type);
1518
}
1519
 
1520
static int
1521
procfs_stopped_by_watchpoint (void)
1522
{
1523
  return 0;
1524
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.