Esempio n. 1
0
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);
	}
}
Esempio n. 2
0
/*
 * 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);
}
Esempio n. 3
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);
}
Esempio n. 4
0
/*
 * 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;
}
Esempio n. 5
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;
}
Esempio n. 6
0
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;
	}
}
Esempio n. 7
0
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, "");
}
Esempio n. 9
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);
}
Esempio n. 10
0
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 );

}
Esempio n. 11
0
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++;
	}
}
Esempio n. 12
0
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));
}
Esempio n. 13
0
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");
}
Esempio n. 14
0
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);
}
Esempio n. 15
0
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;

}
Esempio n. 16
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);
}
Esempio n. 17
0
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);
}
Esempio n. 18
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);
}
Esempio n. 19
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);
}
Esempio n. 20
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);
}
Esempio n. 21
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);
}
Esempio n. 22
0
/*
 * 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();
}
Esempio n. 23
0
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");
    }
}
Esempio n. 24
0
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;

}
Esempio n. 25
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);
}
Esempio n. 26
0
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);
}
Esempio n. 27
0
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);
}
Esempio n. 28
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);
}
Esempio n. 29
0
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;
	}
}
Esempio n. 30
0
/* 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;
}