static int
ftinit(Serialport *p)
{
Serial *ser;
uint timerval;
int res;
ser = p->s;
if(p->isjtag){
res = ftdiwrite(p, FTSETFLOWCTRL, 0, FTDISABLEFLOWCTRL);
if(res < 0)
return -1;
res = ftdiread(p, FTSETLATENCYTIMER, 0, (uchar *)&timerval,
FTLATENCYTIMERSZ);
if(res < 0)
return -1;
dsprint(2, "serial: jtag latency timer is %d\n", timerval);
timerval = 2;
ftdiwrite(p, FTLATENCYDEFAULT, 0, FTSETLATENCYTIMER);
res = ftdiread(p, FTSETLATENCYTIMER, 0, (uchar *)&timerval,
FTLATENCYTIMERSZ);
if(res < 0)
return -1;
dsprint(2, "serial: jtag latency timer set to %d\n", timerval);
/* may be unnecessary */
devctl(p->epin, "timeout 5000");
devctl(p->epout, "timeout 5000");
/* 0xb is the mask for lines. plug dependant? */
ftdiwrite(p, BMMPSSE|0x0b, 0, FTSETBITMODE);
}
incref(ser->dev);
threadcreate(statusreader, p, 8*1024);
return 0;
}
static int
plseteps(Serialport *p)
{
devctl(p->epin, "maxpkt 256");
devctl(p->epout, "maxpkt 256");
return 0;
}
static pid_t
do_attach (pid_t pid)
{
procfs_status status;
struct sigevent event;
if (nto_inferior.ctl_fd != -1)
{
close (nto_inferior.ctl_fd);
init_nto_inferior (&nto_inferior);
}
xsnprintf (nto_inferior.nto_procfs_path, PATH_MAX - 1, "/proc/%d/as", pid);
nto_inferior.ctl_fd = open (nto_inferior.nto_procfs_path, O_RDWR);
if (nto_inferior.ctl_fd == -1)
{
TRACE ("Failed to open %s\n", nto_inferior.nto_procfs_path);
init_nto_inferior (&nto_inferior);
return -1;
}
if (devctl (nto_inferior.ctl_fd, DCMD_PROC_STOP, &status, sizeof (status), 0)
!= EOK)
{
do_detach ();
return -1;
}
nto_inferior.pid = pid;
/* Define a sigevent for process stopped notification. */
event.sigev_notify = SIGEV_SIGNAL_THREAD;
event.sigev_signo = SIGUSR1;
event.sigev_code = 0;
event.sigev_value.sival_ptr = NULL;
event.sigev_priority = -1;
devctl (nto_inferior.ctl_fd, DCMD_PROC_EVENT, &event, sizeof (event), 0);
if (devctl (nto_inferior.ctl_fd, DCMD_PROC_STATUS, &status, sizeof (status),
0) == EOK
&& (status.flags & _DEBUG_FLAG_STOPPED))
{
ptid_t ptid;
struct process_info *proc;
kill (pid, SIGCONT);
ptid = ptid_build (status.pid, status.tid, 0);
the_low_target.arch_setup ();
proc = add_process (status.pid, 1);
proc->tdesc = nto_tdesc;
TRACE ("Adding thread: pid=%d tid=%ld\n", status.pid,
ptid_get_lwp (ptid));
nto_find_new_threads (&nto_inferior);
}
else
{
do_detach ();
return -1;
}
return pid;
}
static void
portreset(Hub *h, int p)
{
int sts;
Dev *d, *nd;
Port *pp;
d = h->dev;
pp = &h->port[p];
nd = pp->dev;
dprint(2, "%s: %s: port %d: resetting\n", argv0, d->dir, p);
if(hubfeature(h, p, Fportreset, 1) < 0){
dprint(2, "%s: %s: port %d: reset: %r\n", argv0, d->dir, p);
goto Fail;
}
sleep(Resetdelay);
sts = portstatus(h, p);
if(sts < 0)
goto Fail;
if((sts & PSenable) == 0){
dprint(2, "%s: %s: port %d: not enabled?\n", argv0, d->dir, p);
hubfeature(h, p, Fportenable, 1);
sts = portstatus(h, p);
if((sts & PSenable) == 0)
goto Fail;
}
nd = pp->dev;
opendevdata(nd, ORDWR);
if(usbcmd(nd, Rh2d|Rstd|Rdev, Rsetaddress, nd->id, 0, nil, 0) < 0){
dprint(2, "%s: %s: port %d: setaddress: %r\n", argv0, d->dir, p);
goto Fail;
}
if(devctl(nd, "address") < 0){
dprint(2, "%s: %s: port %d: set address: %r\n", argv0, d->dir, p);
goto Fail;
}
if(usbcmd(nd, Rh2d|Rstd|Rdev, Rsetconf, 1, 0, nil, 0) < 0){
dprint(2, "%s: %s: port %d: setconf: %r\n", argv0, d->dir, p);
unstall(nd, nd, Eout);
if(usbcmd(nd, Rh2d|Rstd|Rdev, Rsetconf, 1, 0, nil, 0) < 0)
goto Fail;
}
if(nd->dfd >= 0)
close(nd->dfd);
return;
Fail:
pp->state = Pdisabled;
pp->sts = 0;
if(pp->hub != nil)
pp->hub = nil; /* hub closed by enumhub */
hubfeature(h, p, Fportenable, 0);
if(nd != nil)
devctl(nd, "detach");
closedev(nd);
}
static void
writeinfo(Dev *d)
{
char buf[128];
char *s;
char *se;
Usbdev *ud;
Conf *c;
Iface *ifc;
int i, j;
ud = d->usb;
s = buf;
se = buf+sizeof(buf);
s = seprint(s, se, "info %s csp %#08ux", classname(ud->class), ud->csp);
for(i = 0; i < ud->nconf; i++){
c = ud->conf[i];
if(c == nil)
break;
for(j = 0; j < nelem(c->iface); j++){
ifc = c->iface[j];
if(ifc == nil)
break;
if(ifc->csp != ud->csp)
s = seprint(s, se, " csp %#08ulx", ifc->csp);
}
}
s = seprint(s, se, " vid %06#x did %06#x", ud->vid, ud->did);
seprint(s, se, " %q %q", ud->vendor, ud->product);
devctl(d, "%s", buf);
}
static int twl4030_i2c_read(int fd, uint8_t addr, uint8_t reg, uint8_t * val)
{
struct send_recv
{
i2c_sendrecv_t hdr;
uint8_t buf[2];
} twl4030_rd_data;
/*Read the Registers Current Value */
twl4030_rd_data.buf[0] = reg;
twl4030_rd_data.hdr.send_len = 1;
twl4030_rd_data.hdr.recv_len = 1;
twl4030_rd_data.hdr.slave.addr = addr;
twl4030_rd_data.hdr.slave.fmt = I2C_ADDRFMT_7BIT;
twl4030_rd_data.hdr.stop = 1;
if (devctl(fd, DCMD_I2C_SENDRECV, &twl4030_rd_data, sizeof(twl4030_rd_data), NULL))
{
slogf(_SLOGC_SIM_MMC, _SLOG_ERROR, "BEAGLE MMCSD: twl4030_i2c_read fail");
return -1;
}
*val = twl4030_rd_data.buf[0];
return 0;
}
void PMAPI PM_saveConsoleState(void *stateBuf,int console_id)
{
#ifdef __QNXNTO__
int fd;
int flags;
if ((fd = open("/dev/con1", O_RDWR)) == -1)
return;
flags = _CONCTL_INVISIBLE_CHG | _CONCTL_INVISIBLE;
devctl(fd, DCMD_CHR_SERCTL, &flags, sizeof flags, 0);
close(fd);
#else
uchar *buf = &((uchar*)stateBuf)[PM_getVGAStateSize()];
/* Save QNX 4 console state */
console_read(cc, -1, 0, NULL, 0,
(int *)buf+1, (int *)buf+2, NULL);
*(int *)buf = console_ctrl(cc, -1,
CONSOLE_NORESIZE | CONSOLE_NOSWITCH | CONSOLE_INVISIBLE,
CONSOLE_NORESIZE | CONSOLE_NOSWITCH | CONSOLE_INVISIBLE);
/* Save state of VGA registers */
PM_saveVGAState(stateBuf);
#endif
}
static void* shared_memory_open(const IPC_str *name, int size)
{
DEBUG_PRINT("%s( %s, 0x%x )\n", __FUNCTION__, name, size);
int fd = ipc_driver_handle();
if(fd < 0) {
DEBUG_PRINT("%s(): IPC driver was not opened\n", __FUNCTION__);
return NULL;
}
struct ipc_create_t ipc_create_param;
memset(&ipc_create_param,0,sizeof(ipc_create_param));
ipc_create_param.handle = NULL;
ipc_create_param.value = size;
snprintf(ipc_create_param.name, sizeof(ipc_create_param.name), "%s", name);
int res = devctl(fd,IOCTL_IPC_SHM_OPEN,&ipc_create_param, sizeof(ipc_create_param), NULL);
if(res < 0) {
DEBUG_PRINT("%s(): Error register shared memory", __FUNCTION__ );
return NULL;
}
return ipc_create_param.handle;
}
static int
nto_stopped_by_watchpoint (void)
{
int ret = 0;
TRACE ("%s\n", __func__);
if (nto_inferior.ctl_fd != -1 && current_inferior != NULL)
{
ptid_t ptid;
ptid = thread_to_gdb_id (current_inferior);
if (nto_set_thread (ptid))
{
const int watchmask = _DEBUG_FLAG_TRACE_RD | _DEBUG_FLAG_TRACE_WR
| _DEBUG_FLAG_TRACE_MODIFY;
procfs_status status;
int err;
err = devctl (nto_inferior.ctl_fd, DCMD_PROC_STATUS, &status,
sizeof (status), 0);
if (err == EOK && (status.flags & watchmask))
ret = 1;
}
}
TRACE ("%s: %s\n", __func__, ret ? "yes" : "no");
return ret;
}
/*!
* @brief Function to map a memory region specific to the driver.
*
* @sa OsalDrv_close,OsalDrv_open
*/
UInt32
OsalDrv_map (UInt32 addr, UInt32 size, Bool isCached)
{
UInt32 userAddr = (UInt32) NULL;
OsalMemMap_CmdArgs args;
GT_0trace (curTrace, GT_ENTER, "OsalDrv_map");
if (OsalDrv_refCount == 1) {
args.len = size;
args.paddr = (off_t)addr;
args.isCached = isCached;
devctl(OsalDrv_handle, DCMD_OSALMEM_MMAP, &args, sizeof(args), NULL);
userAddr = (UInt32)(args.vaddr);
#if !defined(SYSLINK_BUILD_OPTIMIZE)
if (userAddr == (UInt32) MAP_FAILED) {
userAddr = (UInt32)NULL;
GT_setFailureReason (curTrace,
GT_4CLASS,
"OsalDrv_map",
OSALDRV_E_MAP,
"Failed to map memory to user space!");
}
#endif /* #if !defined(SYSLINK_BUILD_OPTIMIZE) */
}
GT_1trace (curTrace, GT_LEAVE, "OsalDrv_map", userAddr);
/*! @retval NULL Operation was successful. */
/*! @retval valid-address Operation successfully completed. */
return userAddr;
}
/*!
* @brief Function to invoke the APIs through ioctl.
*
* @param cmd Command for driver ioctl
* @param args Arguments for the ioctl command
*
* @sa
*/
Int
OsalDrv_ioctl (UInt32 cmd, Ptr args)
{
Int status = OSALDRV_SUCCESS;
int osStatus = 0;
TraceDrv_CmdArgs * cmdArgs = (TraceDrv_CmdArgs *) args;
GT_2trace (curTrace, GT_ENTER, "OsalDrv_ioctl", cmd, args);
GT_assert (curTrace, (OsalDrv_refCount > 0));
// osStatus = ioctl (OsalDrv_handle, cmd, args);
osStatus = devctl( OsalDrv_handle, DCMD_TRACEDRV_SETTRACE, cmdArgs, sizeof(TraceDrv_CmdArgs), NULL);
if (osStatus < 0) {
/*! @retval OSALDRV_E_OSFAILURE Driver ioctl failed */
status = OSALDRV_E_OSFAILURE;
GT_setFailureReason (curTrace,
GT_4CLASS,
"OsalDrv_ioctl",
status,
"Driver ioctl failed!");
}
else {
/* First field in the structure is the API status. */
status = ((TraceDrv_CmdArgs *) args)->apiStatus;
}
GT_1trace (curTrace, GT_LEAVE, "OsalDrv_ioctl", status);
/*! @retval OSALDRV_SUCCESS Operation successfully completed. */
return status;
}
static void
portdetach(Hub *h, int p)
{
Dev *d;
Port *pp;
extern void usbfsgone(char*);
d = h->dev;
pp = &h->port[p];
/*
* Clear present, so that we detect an attach on reconnects.
*/
pp->sts &= ~(PSpresent|PSenable);
if(pp->state == Pdisabled)
return;
pp->state = Pdisabled;
dprint(2, "%s: %s: port %d: detached\n", argv0, d->dir, p);
if(pp->hub != nil){
closehub(pp->hub);
pp->hub = nil;
}
if(pp->devmaskp != nil)
putdevnb(pp->devmaskp, pp->devnb);
pp->devmaskp = nil;
if(pp->dev != nil){
devctl(pp->dev, "detach");
usbfsgone(pp->dev->dir);
closedev(pp->dev);
pp->dev = nil;
}
}
static void
nto_store_registers (struct regcache *regcache, int regno)
{
procfs_greg greg;
int err;
ptid_t ptid;
TRACE ("%s (regno:%d)\n", __func__, regno);
if (current_inferior == NULL)
{
TRACE ("current_inferior is NULL\n");
return;
}
ptid = thread_to_gdb_id (current_inferior);
if (!nto_set_thread (ptid))
return;
memset (&greg, 0, sizeof (greg));
for (regno = 0; regno != the_low_target.num_regs; ++regno)
{
const unsigned int regoffset
= the_low_target.register_offset (regno);
collect_register (regcache, regno, ((char *)&greg) + regoffset);
}
err = devctl (nto_inferior.ctl_fd, DCMD_PROC_SETGREG, &greg, sizeof (greg),
0);
if (err != EOK)
TRACE ("Error: setting registers.\n");
}
int main(void)
{
int data, fd, toggle = 1;
/* Open the device we wish to manipulate. */
if((fd = open ("/dev/kbd", O_RDONLY)) == -1)
{
fprintf(stderr, "Error with open() on /dev/kbd. Make sure exists.\n");
perror (NULL);
exit(EXIT_FAILURE);
}
while(1)
{
switch(toggle)
{
case 1:
{
/*
Lets now turn on Num Lock and make sure that
Caps and Scroll lock are turned off.
*/
data = (_CONCTL_NUM_CHG | _CONCTL_NUM) | _CONCTL_CAPS_CHG | _CONCTL_SCROLL_CHG;
break;
}
case 2:
{
/*
Turn off Num Lock and now turn on Caps Lock
(Scroll lock is already off).
*/
data = _CONCTL_NUM_CHG | (_CONCTL_CAPS_CHG | _CONCTL_CAPS);
break;
}
case 3:
{
/*
Turn off Caps lock and turn on Scroll lock
(Num lock is already off).
*/
data = _CONCTL_CAPS_CHG | (_CONCTL_SCROLL_CHG | _CONCTL_SCROLL);
toggle = 0;
break;
}
}
/* Explanation below. */
if (devctl (fd, DCMD_CHR_SERCTL, &data, sizeof(data), NULL))
{
fprintf(stderr, "Error setting KBD.\n");
perror (NULL);
exit(EXIT_FAILURE);
}
sleep(1);
toggle++;
}
return (1);
}
static void
etherfree(Ether *e)
{
int i;
Buf *bp;
if(e->free != nil)
e->free(e);
closedev(e->epin);
closedev(e->epout);
if(e->rc == nil){ /* not really started */
free(e);
return;
}
for(i = 0; i < e->nconns; i++)
if(e->conns[i] != nil){
while((bp = nbrecvp(e->conns[i]->rc)) != nil)
free(bp);
chanfree(e->conns[i]->rc);
free(e->conns[i]);
}
shutdownchan(e->bc);
shutdownchan(e->rc);
shutdownchan(e->wc);
e->epin = e->epout = nil;
devctl(e->dev, "detach");
free(e);
}
static int
ftseteps(Serialport *p)
{
char *s;
Serial *ser;
ser = p->s;
s = smprint("maxpkt %d", ser->maxrtrans);
devctl(p->epin, s);
free(s);
s = smprint("maxpkt %d", ser->maxwtrans);
devctl(p->epout, s);
free(s);
return 0;
}
static void
nto_request_interrupt (void)
{
TRACE ("%s\n", __func__);
nto_set_thread (ptid_build (nto_inferior.pid, 1, 0));
if (EOK != devctl (nto_inferior.ctl_fd, DCMD_PROC_STOP, NULL, 0, 0))
TRACE ("Error stopping inferior.\n");
}
/*!
* Алгоритм работы:
* 1. Получение дескриптора файла жесткого диска
* 2. Получение серийного номера при помощи @c devctl и его запись в @p serial
* 3. Если интерфейс найден - копирование MAC-адреса в @p mac
*/
int pll_get_hdserial(char* serial, size_t serial_len, const char* hd_name) {
int file = open(hd_name, O_RDONLY);
if (!file) return -1;
int err = devctl(file, DCMD_CAM_DEV_SERIAL_NUMBER, serial, serial_len, NULL);
if (err != EOK) return -1;
return 0;
}
static int
seteps(Serialport *p)
{
if(devctl(p->epin, "timeout 0") < 0){
fprint(2, "can't set timeout on %s: %r\n", p->epin->dir);
return -1;
}
return 0;
}
FridaHostProcessInfo *
frida_system_enumerate_processes (int * result_length)
{
GArray * processes;
FridaImageData no_icon;
GDir * proc_dir;
const gchar * proc_name;
static struct
{
procfs_debuginfo info;
char buff [PATH_MAX];
} procfs_name;
processes = g_array_new (FALSE, FALSE, sizeof (FridaHostProcessInfo));
frida_image_data_init (&no_icon, 0, 0, 0, "");
proc_dir = g_dir_open ("/proc", 0, NULL);
g_assert (proc_dir != NULL);
while ((proc_name = g_dir_read_name (proc_dir)) != NULL)
{
guint pid;
gchar * tmp = NULL, * name;
gint fd;
FridaHostProcessInfo * process_info;
pid = strtoul (proc_name, &tmp, 10);
if (*tmp != '\0')
continue;
tmp = g_build_filename ("/proc", proc_name, "as", NULL);
fd = open(tmp, O_RDONLY);
g_free (tmp);
g_assert (fd != -1);
g_assert (devctl (fd, DCMD_PROC_MAPDEBUG_BASE, &procfs_name,
sizeof (procfs_name), 0) == EOK);
name = g_path_get_basename (procfs_name.info.path);
g_array_set_size (processes, processes->len + 1);
process_info = &g_array_index (processes, FridaHostProcessInfo, processes->len - 1);
frida_host_process_info_init (process_info, pid, name, &no_icon, &no_icon);
g_free (name);
}
g_dir_close (proc_dir);
frida_image_data_destroy (&no_icon);
*result_length = processes->len;
return (FridaHostProcessInfo *) g_array_free (processes, FALSE);
}
static int
openeps(Ether *e, int epin, int epout)
{
e->epin = openep(e->dev, epin);
if(e->epin == nil){
fprint(2, "ether: in: openep %d: %r\n", epin);
return -1;
}
if(epout == epin){
incref(e->epin);
e->epout = e->epin;
}else
e->epout = openep(e->dev, epout);
if(e->epout == nil){
fprint(2, "ether: out: openep %d: %r\n", epout);
closedev(e->epin);
return -1;
}
if(e->epin == e->epout)
opendevdata(e->epin, ORDWR);
else{
opendevdata(e->epin, OREAD);
opendevdata(e->epout, OWRITE);
}
if(e->epin->dfd < 0 || e->epout->dfd < 0){
fprint(2, "ether: open i/o ep data: %r\n");
closedev(e->epin);
closedev(e->epout);
return -1;
}
dprint(2, "ether: ep in %s maxpkt %d; ep out %s maxpkt %d\n",
e->epin->dir, e->epin->maxpkt, e->epout->dir, e->epout->maxpkt);
/* time outs are not activated for I/O endpoints */
if(usbdebug > 2 || etherdebug > 2){
devctl(e->epin, "debug 1");
devctl(e->epout, "debug 1");
devctl(e->dev, "debug 1");
}
return 0;
}
int read_boardid(int address, BDIDENT *bdident, int showerr)
{
AM335X_BOARDID bdid;
int r;
sprintf(bdid.devname, BOARDID_I2C_DEVICE);
bdid.fd = open(bdid.devname, O_RDWR);
if (bdid.fd == -1)
{
printf("Unable to open %s (errno=%d)\n", bdid.devname, errno);
return -1;
}
r=devctl(bdid.fd, DCMD_I2C_LOCK, NULL, 0, NULL);
if (r)
{
printf("Unable to lock %s (errno=%d)\n", bdid.devname, errno);
close(bdid.fd);
return -1;
}
bdid.i2c_address = address;
r = bdid_read(&bdid, bdident, showerr);
if (r<0)
{
if (showerr) printf("Unable to read %s (errno=%d)\n", bdid.devname, errno);
close(bdid.fd);
return -1;
}
r=devctl(bdid.fd, DCMD_I2C_UNLOCK, NULL, 0, NULL);
if (r)
{
printf("Unable to unlock %s (errno=%d)\n", bdid.devname, errno);
close(bdid.fd);
return -1;
}
close(bdid.fd);
return 0;
}
static void
etherexiting(Ether *e)
{
devctl(e->dev, "detach");
e->exiting = 1;
close(e->epin->dfd);
e->epin->dfd = -1;
close(e->epout->dfd);
e->epout->dfd = -1;
nbsend(e->wc, nil);
}
/* Resume play */
static int SDL_SYS_CDResume(SDL_CD *cdrom)
{
if (devctl(cdrom->id, DCMD_CAM_CDROMRESUME, NULL, 0, NULL)!=0)
{
return -1;
}
else
{
return 0;
}
}
/* Pause play */
static int SDL_SYS_CDPause(SDL_CD *cdrom)
{
if (devctl(cdrom->id, DCMD_CAM_CDROMPAUSE, NULL, 0, NULL)!=0)
{
return -1;
}
else
{
return 0;
}
}
/* Stop play */
static int SDL_SYS_CDStop(SDL_CD *cdrom)
{
if (devctl(cdrom->id, DCMD_CAM_CDROMSTOP, NULL, 0, NULL)!=0)
{
return -1;
}
else
{
return 0;
}
}
/* Eject the CD-ROM */
static int SDL_SYS_CDEject(SDL_CD *cdrom)
{
if (devctl(cdrom->id, DCMD_CAM_EJECT_MEDIA, NULL, 0, NULL)!=0)
{
return -1;
}
else
{
return 0;
}
}
static int
nto_breakpoint (CORE_ADDR addr, int type, int size)
{
procfs_break brk;
brk.type = type;
brk.addr = addr;
brk.size = size;
if (devctl (nto_inferior.ctl_fd, DCMD_PROC_BREAK, &brk, sizeof (brk), 0)
!= EOK)
return 1;
return 0;
}
int
RTCFUNC(get,net)(struct tm *tm, int cent_reg) {
uint64_t nsecs;
int secs, retval, scratch;
union {
struct syspage_entry ent;
char padding[8192];
} sp, tmpsp;
do {
devctl(fd, DCMD_PROC_SYSINFO, &tmpsp, sizeof tmpsp, &scratch);
retval = devctl(fd, DCMD_PROC_SYSINFO, &sp, sizeof sp, &scratch);
} while(retval == EOK && (_SYSPAGE_ENTRY(&sp.ent, qtime)->nsec -
_SYSPAGE_ENTRY(&tmpsp.ent, qtime)->nsec > 1e+9) );
if(retval != EOK)
return -1;
nsecs = _SYSPAGE_ENTRY(&sp.ent, qtime)->nsec +
_SYSPAGE_ENTRY(&sp.ent, qtime)->nsec_tod_adjust ;
secs = nsecs / 1e+9;
*tm = *gmtime((time_t *)&secs);
return 0;
}
static void
nto_find_new_threads (struct nto_inferior *nto_inferior)
{
pthread_t tid;
TRACE ("%s pid:%d\n", __func__, nto_inferior->pid);
if (nto_inferior->ctl_fd == -1)
return;
for (tid = 1;; ++tid)
{
procfs_status status;
ptid_t ptid;
int err;
status.tid = tid;
err = devctl (nto_inferior->ctl_fd, DCMD_PROC_TIDSTATUS, &status,
sizeof (status), 0);
if (err != EOK || status.tid == 0)
break;
/* All threads in between are gone. */
while (tid != status.tid || status.state == STATE_DEAD)
{
struct thread_info *ti;
ptid = ptid_build (nto_inferior->pid, tid, 0);
ti = find_thread_ptid (ptid);
if (ti != NULL)
{
TRACE ("Removing thread %d\n", tid);
remove_thread (ti);
}
if (tid == status.tid)
break;
++tid;
}
if (status.state != STATE_DEAD)
{
TRACE ("Adding thread %d\n", tid);
ptid = ptid_build (nto_inferior->pid, tid, 0);
if (!find_thread_ptid (ptid))
add_thread (ptid, NULL);
}
}
}
