static int check_and_rewind_pc(char *put_str, char *arg)
{
unsigned long addr = lookup_addr(arg);
unsigned long ip;
int offset = 0;
kgdb_hex2mem(&put_str[1], (char *)kgdbts_gdb_regs,
NUMREGBYTES);
gdb_regs_to_pt_regs(kgdbts_gdb_regs, &kgdbts_regs);
ip = instruction_pointer(&kgdbts_regs);
v2printk("Stopped at IP: %lx\n", ip);
#ifdef GDB_ADJUSTS_BREAK_OFFSET
/* On some arches, a breakpoint stop requires it to be decremented */
if (addr + BREAK_INSTR_SIZE == ip)
offset = -BREAK_INSTR_SIZE;
#endif
if (strcmp(arg, "silent") && ip + offset != addr) {
eprintk("kgdbts: BP mismatch %lx expected %lx\n",
ip + offset, addr);
return 1;
}
/* Readjust the instruction pointer if needed */
ip += offset;
#ifdef GDB_ADJUSTS_BREAK_OFFSET
instruction_pointer_set(&kgdbts_regs, ip);
#endif
return 0;
}
static int check_and_rewind_pc(char *put_str, char *arg)
{
unsigned long addr = lookup_addr(arg);
int offset = 0;
kgdb_hex2mem(&put_str[1], (char *)kgdbts_gdb_regs,
NUMREGBYTES);
gdb_regs_to_pt_regs(kgdbts_gdb_regs, &kgdbts_regs);
v2printk("Stopped at IP: %lx\n", instruction_pointer(&kgdbts_regs));
#ifdef CONFIG_X86
/* On x86 a breakpoint stop requires it to be decremented */
if (addr + 1 == kgdbts_regs.ip)
offset = -1;
#endif
if (strcmp(arg, "silent") &&
instruction_pointer(&kgdbts_regs) + offset != addr) {
eprintk("kgdbts: BP mismatch %lx expected %lx\n",
instruction_pointer(&kgdbts_regs) + offset, addr);
return 1;
}
#ifdef CONFIG_X86
/* On x86 adjust the instruction pointer if needed */
kgdbts_regs.ip += offset;
#endif
return 0;
}
static void break_helper(char *bp_type, char *arg, unsigned long vaddr)
{
unsigned long addr;
if (arg)
addr = lookup_addr(arg);
else
addr = vaddr;
sprintf(scratch_buf, "%s,%lx,%i", bp_type, addr,
BREAK_INSTR_SIZE);
fill_get_buf(scratch_buf);
}
static int check_single_step(char *put_str, char *arg)
{
unsigned long addr = lookup_addr(arg);
static int matched_id;
/*
* From an arch indepent point of view the instruction pointer
* should be on a different instruction
*/
kgdb_hex2mem(&put_str[1], (char *)kgdbts_gdb_regs,
NUMREGBYTES);
gdb_regs_to_pt_regs(kgdbts_gdb_regs, &kgdbts_regs);
v2printk("Singlestep stopped at IP: %lx\n",
instruction_pointer(&kgdbts_regs));
if (sstep_thread_id != cont_thread_id) {
/*
* Ensure we stopped in the same thread id as before, else the
* debugger should continue until the original thread that was
* single stepped is scheduled again, emulating gdb's behavior.
*/
v2printk("ThrID does not match: %lx\n", cont_thread_id);
if (arch_needs_sstep_emulation) {
if (matched_id &&
instruction_pointer(&kgdbts_regs) != addr)
goto continue_test;
matched_id++;
ts.idx -= 2;
sstep_state = 0;
return 0;
}
cont_instead_of_sstep = 1;
ts.idx -= 4;
return 0;
}
continue_test:
matched_id = 0;
if (instruction_pointer(&kgdbts_regs) == addr) {
eprintk("kgdbts: SingleStep failed at %lx\n",
instruction_pointer(&kgdbts_regs));
return 1;
}
return 0;
}
static int check_single_step(char *put_str, char *arg)
{
unsigned long addr = lookup_addr(arg);
/*
* From an arch indepent point of view the instruction pointer
* should be on a different instruction
*/
kgdb_hex2mem(&put_str[1], (char *)kgdbts_gdb_regs,
NUMREGBYTES);
gdb_regs_to_pt_regs(kgdbts_gdb_regs, &kgdbts_regs);
v2printk("Singlestep stopped at IP: %lx\n",
instruction_pointer(&kgdbts_regs));
if (instruction_pointer(&kgdbts_regs) == addr) {
eprintk("kgdbts: SingleStep failed at %lx\n",
instruction_pointer(&kgdbts_regs));
return 1;
}
return 0;
}
static int check_and_rewind_pc(char *put_str, char *arg)
{
unsigned long addr = lookup_addr(arg);
unsigned long ip;
int offset = 0;
kgdb_hex2mem(&put_str[1], (char *)kgdbts_gdb_regs,
NUMREGBYTES);
gdb_regs_to_pt_regs(kgdbts_gdb_regs, &kgdbts_regs);
ip = instruction_pointer(&kgdbts_regs);
v2printk("Stopped at IP: %lx\n", ip);
#ifdef GDB_ADJUSTS_BREAK_OFFSET
/* On some arches, a breakpoint stop requires it to be decremented */
if (addr + BREAK_INSTR_SIZE == ip)
offset = -BREAK_INSTR_SIZE;
#endif
if (arch_needs_sstep_emulation && sstep_addr &&
ip + offset == sstep_addr &&
((!strcmp(arg, "sys_open") || !strcmp(arg, "do_fork")))) {
/* This is special case for emulated single step */
v2printk("Emul: rewind hit single step bp\n");
restart_from_top_after_write = 1;
} else if (strcmp(arg, "silent") && ip + offset != addr) {
eprintk("kgdbts: BP mismatch %lx expected %lx\n",
ip + offset, addr);
return 1;
}
/* Readjust the instruction pointer if needed */
ip += offset;
cont_addr = ip;
#ifdef GDB_ADJUSTS_BREAK_OFFSET
instruction_pointer_set(&kgdbts_regs, ip);
#endif
return 0;
}
int
proc_addr2sym(struct proc_handle *p, uintptr_t addr, char *name,
size_t namesz, GElf_Sym *symcopy)
{
GElf_Ehdr ehdr;
GElf_Shdr shdr;
Elf *e;
Elf_Scn *scn, *dynsymscn = NULL, *symtabscn = NULL;
prmap_t *map;
const char *s;
uintptr_t off;
u_long symtabstridx = 0, dynsymstridx = 0;
int fd, error = -1;
if ((map = proc_addr2map(p, addr)) == NULL)
return (-1);
if ((fd = find_dbg_obj(map->pr_mapname)) < 0) {
DPRINTF("ERROR: open %s failed", map->pr_mapname);
goto err0;
}
if ((e = elf_begin(fd, ELF_C_READ, NULL)) == NULL) {
DPRINTFX("ERROR: elf_begin() failed: %s", elf_errmsg(-1));
goto err1;
}
if (gelf_getehdr(e, &ehdr) == NULL) {
DPRINTFX("ERROR: gelf_getehdr() failed: %s", elf_errmsg(-1));
goto err2;
}
/*
* Find the index of the STRTAB and SYMTAB sections to locate
* symbol names.
*/
scn = NULL;
while ((scn = elf_nextscn(e, scn)) != NULL) {
gelf_getshdr(scn, &shdr);
switch (shdr.sh_type) {
case SHT_SYMTAB:
symtabscn = scn;
symtabstridx = shdr.sh_link;
break;
case SHT_DYNSYM:
dynsymscn = scn;
dynsymstridx = shdr.sh_link;
break;
}
}
off = ehdr.e_type == ET_EXEC ? 0 : map->pr_vaddr;
/*
* First look up the symbol in the dynsymtab, and fall back to the
* symtab if the lookup fails.
*/
error = lookup_addr(e, dynsymscn, dynsymstridx, off, addr, &s, symcopy);
if (error == 0)
goto out;
error = lookup_addr(e, symtabscn, symtabstridx, off, addr, &s, symcopy);
if (error != 0)
goto err2;
out:
demangle(s, name, namesz);
err2:
elf_end(e);
err1:
close(fd);
err0:
free(map);
return (error);
}
static void accept_new(void)
{
char buffer[MAX_ATM_ADDR_LEN+1];
struct sockaddr_atmsvc addr;
struct atm_qos qos;
ENTRY *entry;
VCC *vcc;
int fd,error;
socklen_t len,size;
len = sizeof(addr);
if ((fd = accept(incoming,(struct sockaddr *) &addr,&len)) < 0) {
error = errno;
diag(COMPONENT,DIAG_ERROR,"accept: %s",strerror(errno));
if (error == EUNATCH) {
diag(COMPONENT,DIAG_WARN,"disabling SVCs");
(void) close(incoming);
incoming = -1;
}
return;
}
/* the following code probably belongs to arp.c ... */
if (atm2text(buffer,MAX_ATM_ADDR_LEN+1,(struct sockaddr *) &addr,pretty) <
0) strcpy(buffer,"<atm2text error>");
diag(COMPONENT,DIAG_DEBUG,"Incoming call from %s",buffer);
size = sizeof(qos);
if (getsockopt(fd,SOL_ATM,SO_ATMQOS,&qos,&size) < 0)
diag(COMPONENT,DIAG_FATAL,"getsockopt SO_ATMQOS: %s",strerror(errno));
if (size != sizeof(qos))
diag(COMPONENT,DIAG_FATAL,"SO_ATMQOS: size %d != %d",size,sizeof(qos));
if (ioctl(fd,ATMARP_MKIP,qos.txtp.traffic_class == ATM_NONE ? 0 :
CLIP_DEFAULT_IDLETIMER) < 0) {
diag(COMPONENT,DIAG_ERROR,"ioctl ATMARP_MKIP: %s",strerror(errno));
(void) do_close(fd);
return;
}
vcc = alloc_t(VCC);
vcc->active = 0;
vcc->connecting = 0;
vcc->fd = fd;
if (qos.txtp.traffic_class == ATM_NONE) {
vcc->entry = NULL;
incoming_unidirectional(vcc);
Q_INSERT_HEAD(unidirectional_vccs,vcc);
return;
}
if (merge) {
ITF *itf;
for (itf = itfs; itf; itf = itf->next) {
entry = lookup_addr(itf,&addr);
if (entry) {
vcc->entry = entry;
Q_INSERT_HEAD(entry->vccs,vcc);
if (entry->state == as_valid) {
if (set_ip(vcc->fd,entry->ip) < 0) {
diag(COMPONENT,DIAG_ERROR,"set_ip: %s",
strerror(errno));
disconnect_vcc(vcc);
}
else set_sndbuf(vcc);
}
return;
}
}
}
entry = alloc_entry(1);
entry->state = as_invalid;
entry->addr = alloc_t(struct sockaddr_atmsvc);
*entry->addr = addr;
entry->flags = ATF_PUBL;
Q_INSERT_HEAD(unknown_incoming,entry);
vcc->entry = entry;
Q_INSERT_HEAD(entry->vccs,vcc);
incoming_call(vcc);
}
JNIEXPORT jlong JNICALL
Java_com_caucho_vfs_JniServerSocketImpl_bindPort(JNIEnv *env,
jobject obj,
jstring jaddr,
jint port)
{
int val = 0;
char addr_name[256];
const char *temp_string = 0;
int sock;
int family = 0;
int protocol = 0;
server_socket_t *ss;
char sin_data[256];
struct sockaddr_in *sin = (struct sockaddr_in *) sin_data;
int sin_length = sizeof(sin_data);
#ifdef WIN32
{
WSADATA data;
WORD version = MAKEWORD(2,2);
WSAStartup(version, &data);
}
#endif
addr_name[0] = 0;
memset(sin_data, 0, sizeof(sin_data));
if (jaddr != 0) {
temp_string = (*env)->GetStringUTFChars(env, jaddr, 0);
if (temp_string) {
strncpy(addr_name, temp_string, sizeof(addr_name));
addr_name[sizeof(addr_name) - 1] = 0;
(*env)->ReleaseStringUTFChars(env, jaddr, temp_string);
}
else {
resin_throw_exception(env, "java/lang/NullPointerException", "missing addr");
return 0;
}
sin = lookup_addr(env, addr_name, port, sin_data,
&family, &protocol, &sin_length);
}
else {
sin = (struct sockaddr_in *) sin_data;
sin->sin_family = AF_INET;
sin->sin_port = htons(port);
family = AF_INET;
protocol = IPPROTO_TCP;
sin_length = sizeof(struct sockaddr_in);
}
if (! sin)
return 0;
sock = socket(family, SOCK_STREAM, 0);
if (sock < 0) {
return 0;
}
val = 1;
if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR,
(char *) &val, sizeof(int)) < 0) {
closesocket(sock);
return 0;
}
if (bind(sock, (struct sockaddr *) sin, sin_length) < 0) {
int i = 5;
int result = 0;
/* somewhat of a hack to clear the old connection. */
while (result == 0 && i-- >= 0) {
int fd = socket(AF_INET, SOCK_STREAM, 0);
result = connect(fd, (struct sockaddr *) &sin, sizeof(sin));
closesocket(fd);
}
result = -1;
for (i = 50; result < 0 && i >= 0; i--) {
result = bind(sock, (struct sockaddr *) sin, sin_length);
if (result < 0) {
struct timeval tv;
tv.tv_sec = 0;
tv.tv_usec = 100000;
select(0, 0, 0, 0, &tv);
}
}
if (result < 0) {
closesocket(sock);
return 0;
}
}
sin_length = sizeof(sin_data);
getsockname(sock, (struct sockaddr *) sin, &sin_length);
/* must be 0 if the poll is missing for accept */
#if 0 && defined(O_NONBLOCK)
/*
* sets nonblock to ensure the timeout work in the case of multiple threads.
*/
{
int flags;
int result;
flags = fcntl(sock, F_GETFL);
result = fcntl(sock, F_SETFL, O_NONBLOCK|flags);
}
#endif
ss = (server_socket_t *) cse_malloc(sizeof(server_socket_t));
memset(ss, 0, sizeof(server_socket_t));
ss->fd = sock;
ss->port = ntohs(sin->sin_port);
ss->conn_socket_timeout = 65000;
ss->accept = &std_accept;
ss->close = &std_close_ss;
#ifdef WIN32
ss->accept_lock = CreateMutex(0, 0, 0);
ss->ssl_lock = CreateMutex(0, 0, 0);
#endif
init_server_socket(env, ss);
return (PTR) ss;
}