void db_cmd_list(struct db_command *table) { struct db_command *cmd; for (cmd = table; cmd->name != 0; cmd++) { db_printf("%-12s", cmd->name); db_end_line(12); } }
/* * Execute a script, breaking it up into individual commands and passing them * sequentially into DDB's input processing. Use the KDB jump buffer to * restore control to the main script loop if things get too wonky when * processing a command -- i.e., traps, etc. Also, make sure we don't exceed * practical limits on recursion. * * XXXRW: If any individual command is too long, it will be truncated when * injected into the input at a lower layer. We should validate the script * before configuring it to avoid this scenario. */ static int db_script_exec(const char *scriptname, int warnifnotfound) { struct db_recursion_data *drd; struct ddb_script *dsp; char *buffer, *command; void *prev_jb; jmp_buf jb; dsp = db_script_lookup(scriptname); if (dsp == NULL) { if (warnifnotfound) db_printf("script '%s' not found\n", scriptname); return (ENOENT); } if (db_recursion >= DB_MAXSCRIPTRECURSION) { db_printf("Script stack too deep\n"); return (E2BIG); } db_recursion++; drd = &db_recursion_data[db_recursion]; /* * Parse script in temporary buffer, since strsep() is destructive. */ buffer = drd->drd_buffer; strcpy(buffer, dsp->ds_script); while ((command = strsep(&buffer, ";")) != NULL) { db_printf("db:%d:%s> %s\n", db_recursion, scriptname, command); db_command_trim(&command); prev_jb = kdb_jmpbuf(jb); if (setjmp(jb) == 0) db_command_script(command); else db_printf("Script command '%s' returned error\n", command); kdb_jmpbuf(prev_jb); } db_recursion--; return (0); }
DB_SHOW_COMMAND(ifnet, db_show_ifnet) { if (!have_addr) { db_printf("usage: show ifnet <struct ifnet *>\n"); return; } if_show_ifnet((struct ifnet *)addr); }
/* * Terminate DDB output capture--real work is deferred to db_capture_dump, * which executes outside of the DDB context. We don't zero pad here because * capture may be started again before the dump takes place. */ static void db_capture_stop(void) { if (db_capture_inprogress == 0) { db_printf("Capture not started\n"); return; } db_capture_inprogress = 0; }
/* * Start capture. Only one session is allowed at any time, but we may * continue a previous session, so the buffer isn't reset. */ static void db_capture_start(void) { if (db_capture_inprogress) { db_printf("Capture already started\n"); return; } db_capture_inprogress = 1; }
static void db_print_sbstate(short sb_state) { int comma; comma = 0; if (sb_state & SBS_CANTSENDMORE) { db_printf("%sSBS_CANTSENDMORE", comma ? ", " : ""); comma = 1; } if (sb_state & SBS_CANTRCVMORE) { db_printf("%sSBS_CANTRCVMORE", comma ? ", " : ""); comma = 1; } if (sb_state & SBS_RCVATMARK) { db_printf("%sSBS_RCVATMARK", comma ? ", " : ""); comma = 1; } }
void db_show_regs(db_expr_t dummy1, int dummy2, db_expr_t dummy3, char *dummy4) { register struct db_variable *regp; db_expr_t value, offset; char * name; for (regp = db_regs; regp < db_eregs; regp++) { db_read_variable(regp, &value); db_printf("%-12s%#10n", regp->name, value); db_find_xtrn_sym_and_offset((db_addr_t)value, &name, &offset); if (name != 0 && offset <= db_maxoff && offset != value) { db_printf("\t%s", name); if (offset != 0) db_printf("+%#r", offset); } db_printf("\n"); } db_print_loc_and_inst(PC_REGS(DDB_REGS)); }
void db_switch_cpu_cmd(db_expr_t addr, bool have_addr, db_expr_t count, const char *modif) { if (addr >= maxcpus) { db_printf("cpu %"DDB_EXPR_FMT"d out of range", addr); return; } struct cpu_info *new_ci = cpu_lookup(addr); if (new_ci == NULL) { db_printf("cpu %"DDB_EXPR_FMT"d does not exist", addr); return; } if (DDB_REGS->tf_spsr & PSR_T_bit) { DDB_REGS->tf_pc -= 2; /* XXX */ } else { DDB_REGS->tf_pc -= 4; } db_newcpu = new_ci; db_continue_cmd(0, false, 0, ""); }
void db_disprint(void *arg, const char *fmt, ...) { va_list ap; char stre[64]; va_start(ap,fmt); vsnprintf(stre, sizeof(stre), fmt, ap); va_end(ap); db_printf(stre); }
void alarmfn1(cyg_handle_t alarmh, cyg_addrword_t data) { db_printf("%s: %d\n",__PRETTY_FUNCTION__,cyg_counter_current_value( counter )); alarmfn_called[1]++; // Reschedule alarm[0] to run every tick until alarm[2] next runs. cyg_alarm_initialize( alarm[0], cyg_counter_current_value( counter )+1, 1 ); }
void db_help_cmd(void) { struct command *cmd = db_command_table; while (cmd->name != 0) { db_printf("%-12s", cmd->name); db_end_line(12); cmd++; } }
int db_md_set_watchpoint(db_expr_t addr, db_expr_t size) { int dummy; if (watch_virt_active()) { db_printf("Overwriting previously active watch point at " "0x%lx\n", watch_virt_get(&dummy)); } return (watch_virt_set(addr, size)); }
void db_md_list_watchpoints(void) { vm_offset_t va; vm_paddr_t pa; int bm; db_printf("Physical address watchpoint:\n"); if (watch_phys_active()) { pa = watch_phys_get(&bm); db_watch_print(pa, bm); } else db_printf("\tnot active.\n"); db_printf("Virtual address watchpoint:\n"); if (watch_virt_active()) { va = watch_virt_get(&bm); db_watch_print(va, bm); } else db_printf("\tnot active.\n"); }
static int db_mach_vtrace(void) { struct ktr_entry *kp; if (tstate.cur == tstate.first) { db_printf("--- End of trace buffer ---\n"); return (0); } kp = &ktr_buf[tstate.cur]; /* Skip over unused entries. */ if (kp->ktr_desc == NULL) { db_printf("--- End of trace buffer ---\n"); return (0); } db_printf("%d (%p", tstate.cur, kp->ktr_thread); #ifdef SMP db_printf(":cpu%d", kp->ktr_cpu); #endif db_printf(")"); if (db_ktr_verbose >= 1) { db_printf(" %10.10lld", (long long)kp->ktr_timestamp); } if (db_ktr_verbose >= 2) { db_printf(" %s.%d", kp->ktr_file, kp->ktr_line); } db_printf(": "); db_printf(kp->ktr_desc, kp->ktr_parms[0], kp->ktr_parms[1], kp->ktr_parms[2], kp->ktr_parms[3], kp->ktr_parms[4], kp->ktr_parms[5]); db_printf("\n"); if (tstate.first == -1) tstate.first = tstate.cur; if (--tstate.cur < 0) tstate.cur = KTR_ENTRIES - 1; return (1); }
int tstcopy5(void *src, void *snk, unsigned int lgn) { unsigned int i = 0, crap; unsigned char ic, ec, oic, pc; oic = ((unsigned char *)snk)[0]; /* Original first sink character */ ic = ((unsigned char *)src)[0]; /* Original first source character */ ec = ((unsigned char *)snk)[lgn]; /* Original character just after last sink character */ pc = ((unsigned char *)snk)[-1]; /* Original character just before sink */ bcopy(src, snk, lgn); if(((unsigned char *)snk)[lgn] != ec) { /* Did we copy too far forward? */ crap = (unsigned int)&((unsigned char *)snk)[i]; db_printf("Copied too far at sink[%d] (%08X) it is %02X\n", i, crap, ((unsigned char *)snk)[lgn]); return 1; } if(((unsigned char *)snk)[-1] != pc) { /* Did we copy too far backward? */ crap = (unsigned int)&((unsigned char *)snk)[i]; db_printf("Copied too far at sink[%d] (%08X) it is %02X\n", i, crap, ((unsigned char *)snk)[lgn]); return 1; } for(i = 0; i < lgn; i++) { /* Check sink byte sequence */ if(((unsigned char *)snk)[i] != ic) { crap = (unsigned int)&((unsigned char *)snk)[i]; db_printf("bad copy at sink[%d] (%08X) it is %02X\n", i ,crap, ((unsigned char *)snk)[i]); return 1; } ic = (ic + 1) % patper; } for(i=0; i < lgn; i++) { /* Restore pattern */ ((unsigned char *)snk)[i] = oic; oic = (oic + 1) % patper; } return 0; }
int db_xcdump( db_addr_t addr, int size, int count, task_t task) { register int i, n; db_expr_t value; int bcount; db_addr_t off; char *name; char data[DB_XCDUMP_NC]; db_find_task_sym_and_offset(addr, &name, &off, task); for (n = count*size; n > 0; n -= bcount) { db_prev = addr; if (off == 0) { db_printf("%s:\n", name); off = -1; } db_printf("%0*X:%s", 2*sizeof(db_addr_t), addr, (size != 1) ? " " : "" ); bcount = ((n > DB_XCDUMP_NC)? DB_XCDUMP_NC: n); if (trunc_page(addr) != trunc_page(addr+bcount-1)) { db_addr_t next_page_addr = trunc_page(addr+bcount-1); if (!DB_CHECK_ACCESS(next_page_addr, sizeof(int), task)) bcount = next_page_addr - addr; } db_read_bytes((vm_offset_t)addr, bcount, data, task); for (i = 0; i < bcount && off != 0; i += size) { if (i % 4 == 0) db_printf(" "); value = db_get_task_value(addr, size, FALSE, task); db_printf("%0*x ", size*2, value); addr += size; db_find_task_sym_and_offset(addr, &name, &off, task); } db_printf("%*s", ((DB_XCDUMP_NC-i)/size)*(size*2+1)+(DB_XCDUMP_NC-i)/4, ""); bcount = i; db_printf("%s*", (size != 1)? " ": ""); for (i = 0; i < bcount; i++) { value = data[i]; db_printf("%c", (value >= ' ' && value <= '~')? value: '.'); } db_printf("*\n"); } return(addr); }
DB_SHOW_COMMAND(tcpcb, db_show_tcpcb) { struct tcpcb *tp; if (!have_addr) { db_printf("usage: show tcpcb <addr>\n"); return; } tp = (struct tcpcb *)addr; db_print_tcpcb(tp, "tcpcb", 0); }
DB_SHOW_COMMAND(socket, db_show_socket) { struct socket *so; if (!have_addr) { db_printf("usage: show socket <addr>\n"); return; } so = (struct socket *)addr; db_print_socket(so, "socket", 0); }
DB_SHOW_COMMAND(sockbuf, db_show_sockbuf) { struct sockbuf *sb; if (!have_addr) { db_printf("usage: show sockbuf <addr>\n"); return; } sb = (struct sockbuf *)addr; db_print_sockbuf(sb, "sockbuf", 0); }
DB_SHOW_COMMAND(protosw, db_show_protosw) { struct protosw *pr; if (!have_addr) { db_printf("usage: show protosw <addr>\n"); return; } pr = (struct protosw *)addr; db_print_protosw(pr, "protosw", 0); }
DB_SHOW_COMMAND(in_ifaddr, db_show_in_ifaddr) { struct in_ifaddr *ia; ia = (struct in_ifaddr *)addr; if (ia == NULL) { db_printf("usage: show in_ifaddr <struct in_ifaddr *>\n"); return; } in_show_in_ifaddr(ia); }
/* * Remove a named script. */ void db_unscript_cmd(db_expr_t addr, boolean_t have_addr, db_expr_t count, char *modif) { int error, t; t = db_read_token(); if (t != tIDENT) { db_printf("?\n"); db_skip_to_eol(); return; } error = db_script_unset(db_tok_string); if (error == ENOENT) { db_printf("script '%s' not found\n", db_tok_string); db_skip_to_eol(); return; } db_skip_to_eol(); }
void Obstacle::markForMove(void) { if (!m_in_move_list) { m_in_move_list = true; } else { db_printf("WARNING: two moves queued for same shape prior to rerouting." "\n This is not safe.\n"); } }
int tstcopy(void *src, void *snk, unsigned int lgn) { unsigned int i, crap; bcopy(src, snk, lgn); for(i = 0; i < lgn; i++) { if(((unsigned char *)snk)[i] != 0x55) { crap = (unsigned int)&((unsigned char *)snk)[i]; db_printf("bad copy at sink[%d] (%08X) it is %02X\n", i,crap, ((unsigned char *)snk)[i]); return 1; } } if(((unsigned char *)snk)[lgn] != 0xAA) { /* Is it right? */ crap = (unsigned int)&((unsigned char *)snk)[i]; db_printf("Copied too far at sink[%d] (%08X) it is %02X\n", i, crap, ((unsigned char *)snk)[lgn]); return 1; } return 0; }
static void saa9730_dsr(cyg_vector_t vector, cyg_ucount32 count, cyg_addrword_t data) { struct saa9730_priv_data *spd = (struct saa9730_priv_data *)data; struct cyg_netdevtab_entry *ndp = (struct cyg_netdevtab_entry *)(spd->ndp); struct eth_drv_sc *sc = (struct eth_drv_sc *)(ndp->device_instance); #ifdef DEBUG db_printf("saa9730_dsr\n"); #endif eth_drv_dsr(vector, count, (cyg_addrword_t)sc); }
void db_trace_self(void) { db_addr_t addr; addr = (db_addr_t)__builtin_frame_address(0); if (addr == 0) { db_printf("Null frame address\n"); return; } db_backtrace(curthread, *(db_addr_t *)addr, -1); }
DB_SHOW_COMMAND(domain, db_show_domain) { struct domain *d; if (!have_addr) { db_printf("usage: show protosw <addr>\n"); return; } d = (struct domain *)addr; db_print_domain(d, "domain", 0); }
void db_task_trap( int type, int code, boolean_t user_space) { jmp_buf_t db_jmpbuf; jmp_buf_t *prev; boolean_t bkpt; boolean_t watchpt; task_t task; task_t task_space; task = db_current_task(); task_space = db_target_space(current_act(), user_space); bkpt = IS_BREAKPOINT_TRAP(type, code); watchpt = IS_WATCHPOINT_TRAP(type, code); /* * Note: we look up PC values in an address space (task_space), * but print symbols using a (task-specific) symbol table, found * using task. */ db_init_default_act(); db_check_breakpoint_valid(); if (db_stop_at_pc(&bkpt, task, task_space)) { if (db_inst_count) { db_printf("After %d instructions (%d loads, %d stores),\n", db_inst_count, db_load_count, db_store_count); } if (bkpt) db_printf("Breakpoint at "); else if (watchpt) db_printf("Watchpoint at "); else db_printf("Stopped at "); db_dot = PC_REGS(DDB_REGS); prev = db_recover; if (_setjmp(db_recover = &db_jmpbuf) == 0) { #if defined(__alpha) db_print_loc(db_dot, task_space); db_printf("\n\t"); db_print_inst(db_dot, task_space); #else /* !defined(__alpha) */ #if defined(__powerpc__) db_print_loc_and_inst(db_dot, task_space); #else /* __powerpc__ */ db_print_loc_and_inst(db_dot, task); #endif /* __powerpc__ */ #endif /* defined(__alpha) */ } else db_printf("Trouble printing location %#X.\n", db_dot); db_recover = prev; db_command_loop(); } db_restart_at_pc(watchpt, task_space); }
static void db_print_sotype(short so_type) { switch (so_type) { case SOCK_STREAM: db_printf("SOCK_STREAM"); break; case SOCK_DGRAM: db_printf("SOCK_DGRAM"); break; case SOCK_RAW: db_printf("SOCK_RAW"); break; case SOCK_RDM: db_printf("SOCK_RDM"); break; case SOCK_SEQPACKET: db_printf("SOCK_SEQPACKET"); break; default: db_printf("unknown"); break; } }
/* THREAD FOR DNS SCANNING. */ void dns_scan_t(void){ socklen_t sas=0; char *p; struct sockaddr_in sad; sas=sizeof(struct sockaddr_in); memset((char *)&sad,0,sas); sad.sin_family=AF_INET; sad.sin_port=htons(53); if(!(p=(char *)malloc(18+strlen(RESOLV_DOMAIN)+1))) print_msg(1,"malloc() failed."); sprintf(p,"%c%c%c%c%c%c%c%c%c%c%c%c%s%c%c%c%c%c",0,1,1,0,0,1,0,0,0,0,0,0, dns_converthost(RESOLV_DOMAIN),0,0,1,0,1); while(!nexit){ /* RELATED TO NO SQL CONNECION. */ while(idle)sleep(1); dns_inc_ip(); sad.sin_addr.s_addr=ip_i; sendto(sd,p,(18+strlen(RESOLV_DOMAIN)),0,(struct sockaddr *)&sad, sizeof(struct sockaddr_in)); if(((ip_i>>24)&0xff)==1){ /* CLEAN OUT NON-DUPS. (FALL_BACK) */ db_printf("DELETE FROM db WHERE (id<%u OR id>%u) AND rsp<%u", r_32(ip_i)-FALL_BACK-1,r_32(ip_i),MIN_RESPONSE); /* CLEAN OUT THE NEXT /24. */ db_printf("DELETE FROM db WHERE id>%u AND id<%u", r_32(ip_i),r_32(ip_i)+254); /* SAVE LOCATION AT THE BEGINNING OF EACH /24. */ write_last_ip(sad.sin_addr); } usleep(PACKET_DELAY); } free(p); pthread_exit(0); return; }