static void
gdb_cmd_write_mem(unsigned long addr, unsigned long length,
const char *buf, struct gdb_context *ctx)
{
int x, r;
unsigned char val;
dbg_printk("Memory write starting at %lx, length %lx.\n", addr, length);
for ( x = 0; x < length; x++, addr++, buf += 2 )
{
val = str2ulong(buf, sizeof(val));
r = gdb_arch_copy_to_user((void*)addr, (void*)&val, 1);
if ( r != 0 )
{
dbg_printk("Error writing to %lx.\n", addr);
break;
}
}
if (x == length)
gdb_write_to_packet_str("OK", ctx);
else
gdb_write_to_packet_str("E11", ctx);
dbg_printk("Write done.\n");
gdb_send_packet(ctx);
}
bool proc_dot(char* mnemonic, char** op, int opcnt, tState *state) {
if ( strcasecmp(".long", mnemonic) == 0 ) {
if ( opcnt != 1 ) {
throw std::string("Operand count not match");
}
inst_t data = (inst_t)str2ulong(trim(op[0]));
state->dest.push_back(data);
return true;
} else {
//TODO 今のところlong以外は放置
return true;
}
}
/* str2uchar - safely convert string to uint8
*
* @str: source string to convert from
* @uchr_ptr: pointer where to store result
*
* returns zero on success
* returns (-1) if one of args is NULL, (-2) or (-3) if conversion fails
*/
int str2uchar(const char * str, uint8_t * uchr_ptr)
{
int rc = (-3);
uint64_t arg_ulong = 0;
if ( (rc = str2ulong(str, &arg_ulong)) != 0 ) {
*uchr_ptr = 0;
return rc;
}
if (arg_ulong > UINT8_MAX)
return (-3);
*uchr_ptr = (uint8_t)arg_ulong;
return 0;
} /* str2uchar(...) */
/* str2ushort - safely convert string to uint16_t
*
* @str: source string to convert from
* @ushrt_ptr: pointer where to store result
*
* returns zero on success
* returns (-1) if one of args is NULL, (-2) invalid input, (-3) for *flow
*/
int str2ushort(const char * str, uint16_t * ushrt_ptr)
{
int rc = (-3);
uint64_t arg_ulong = 0;
if ( (rc = str2ulong(str, &arg_ulong)) != 0 ) {
*ushrt_ptr = 0;
return rc;
}
if (arg_ulong > UINT16_MAX)
return (-3);
*ushrt_ptr = (uint16_t)arg_ulong;
return 0;
} /* str2ushort(...) */
/* str2uint - safely convert string to uint32_t
*
* @str: source string to convert from
* @uint_ptr: pointer where to store result
*
* returns zero on success
* returns (-1) if one of args is NULL, (-2) invalid input, (-3) for *flow
*/
int str2uint(const char * str, uint32_t * uint_ptr)
{
int rc = 0;
uint64_t arg_ulong = 0;
if ( (rc = str2ulong(str, &arg_ulong)) != 0) {
*uint_ptr = 0;
return rc;
}
if (arg_ulong > UINT32_MAX)
return (-3);
*uint_ptr = (uint32_t)arg_ulong;
return 0;
} /* str2uint(...) */
/* command dispatcher */
static int
process_command(struct cpu_user_regs *regs, struct gdb_context *ctx)
{
const char *ptr;
unsigned long addr, length, val;
int resume = 0;
unsigned long type = GDB_CONTINUE;
/* XXX check ctx->in_bytes >= 2 or similar. */
gdb_start_packet(ctx);
switch ( ctx->in_buf[0] )
{
case '?': /* query signal number */
gdb_cmd_signum(ctx);
break;
case 'H': /* thread operations */
gdb_send_reply("OK", ctx);
break;
case 'g': /* Read registers */
gdb_arch_read_reg_array(regs, ctx);
break;
case 'G': /* Write registers */
gdb_arch_write_reg_array(regs, ctx->in_buf + 1, ctx);
break;
case 'm': /* Read memory */
addr = simple_strtoul(ctx->in_buf + 1, &ptr, 16);
if ( (ptr == (ctx->in_buf + 1)) || (ptr[0] != ',') )
{
gdb_send_reply("E03", ctx);
return 0;
}
length = simple_strtoul(ptr + 1, &ptr, 16);
if ( ptr[0] != 0 )
{
gdb_send_reply("E04", ctx);
return 0;
}
gdb_cmd_read_mem(addr, length, ctx);
break;
case 'M': /* Write memory */
addr = simple_strtoul(ctx->in_buf + 1, &ptr, 16);
if ( (ptr == (ctx->in_buf + 1)) || (ptr[0] != ',') )
{
gdb_send_reply("E03", ctx);
return 0;
}
length = simple_strtoul(ptr + 1, &ptr, 16);
if ( ptr[0] != ':')
{
gdb_send_reply("E04", ctx);
return 0;
}
gdb_cmd_write_mem(addr, length, ptr + 1, ctx);
break;
case 'p': /* read register */
addr = simple_strtoul(ctx->in_buf + 1, &ptr, 16);
if ( ptr == (ctx->in_buf + 1) )
{
gdb_send_reply("E03", ctx);
return 0;
}
if ( ptr[0] != 0 )
{
gdb_send_reply("E04", ctx);
return 0;
}
gdb_arch_read_reg(addr, regs, ctx);
break;
case 'P': /* write register */
addr = simple_strtoul(ctx->in_buf + 1, &ptr, 16);
if ( ptr == (ctx->in_buf + 1) )
{
gdb_send_reply("E03", ctx);
return 0;
}
if ( ptr[0] != '=' )
{
gdb_send_reply("E04", ctx);
return 0;
}
ptr++;
val = str2ulong(ptr, sizeof(unsigned long));
gdb_arch_write_reg(addr, val, regs, ctx);
break;
case 'D':
case 'k':
gdbstub_detach(ctx);
gdb_send_reply("OK", ctx);
ctx->connected = 0;
resume = 1;
break;
case 's': /* Single step */
type = GDB_STEP;
case 'c': /* Resume at current address */
addr = ~((unsigned long)0);
if ( ctx->in_buf[1] )
addr = str2ulong(&ctx->in_buf[1], sizeof(unsigned long));
gdbstub_attach(ctx);
resume = 1;
gdb_arch_resume(regs, addr, type, ctx);
break;
default:
gdb_send_reply("", ctx);
break;
}
return resume;
}
std::set<long>* getProcessSocketInode(long pid) {
std::set<long>* v = new std::set<long>();
char temp[50];
memset(temp, 0, 50);
sprintf(temp, "%ld", pid);
size_t dirlen = 10 + strlen(temp);
char * dirname = (char *) malloc (dirlen * sizeof(char));
snprintf(dirname, dirlen, "/proc/%s/fd", temp);
int isExist = access(dirname, F_OK);
if (isExist == -1) {
free(dirname);
printf("process do not exist, pid is : %d\n", pid);
return NULL;
}
DIR * dir = opendir (dirname);
dirent * entry;
while ((entry = readdir(dir))) {
if (entry->d_type != DT_LNK)
continue;
//std::cout << "Looking at: " << entry->d_name << std::endl;
int fromlen = dirlen + strlen(entry->d_name) + 1;
char * fromname = (char *) malloc (fromlen * sizeof(char));
snprintf (fromname, fromlen, "%s/%s", dirname, entry->d_name);
//std::cout << "Linking from: " << fromname << std::endl;
int linklen = 80;
char linkname [linklen];
int usedlen = readlink(fromname, linkname, linklen-1);
if (usedlen == -1)
{
free (fromname);
continue;
}
linkname[usedlen] = '\0';
//std::cout << "Linking to: " << linkname << std::endl;
//get_info_by_linkname (pid, linkname);
if (strncmp(linkname, "socket:[", 8) == 0) {
char * ptr = linkname + 8;
unsigned long inode = str2ulong(ptr);
//char * progname = getprogname (temp);
//free(progname);
v->insert(inode);
} else {
//std::cout << "Linkname looked like: " << linkname << endl;
}
free (fromname);
}
closedir(dir);
free(dirname);
return v;
}
void get_info_by_linkname (const char * pid, const char * linkname) {
if (strncmp(linkname, "socket:[", 8) == 0) {
setnode(str2ulong(linkname + 8), str2int(pid));
}
}
int main(int argc, char *argv[]) {
u32t flen;
void *fdata;
str_list *cfg;
char *value;
// just exit ;)
if (hlp_hosttype()==QSHT_EFI) return 3;
// check "we are called" flag
if (sto_dword(RUN_ONCE_KEY)) {
printf("Second configuration check call is not required.\n");
return 2;
}
// read cfg file, be quiet if failed
fdata = hlp_freadfull("OS2LDR.CFG", &flen, 0);
if (!fdata) return 1;
cfg = str_settext((char*)fdata, flen);
hlp_memfree(fdata);
// save non-zero value to flag "we are called at least once"
sto_savedword(RUN_ONCE_KEY, 1);
// process config keys
value = str_findkey(cfg, "HIDEMEM", 0);
if (value) shell_cmd("mem hide ", value);
// limit can be already set by VMTRR or someone else, check this too
value = str_findkey(cfg, "MEMLIMIT", 0);
if (value) {
u32t limit = str2ulong(value);
if (limit) {
u32t oldv = sto_dword(STOKEY_MEMLIM);
if (!oldv || limit<oldv) sto_savedword(STOKEY_MEMLIM, limit);
}
}
// bootos2.exe will use this key when found no LOGSIZE parameter
value = str_findkey(cfg, "LOGSIZE", 0);
if (value) {
u32t logsize = str2ulong(value);
if (logsize>=64) sto_savedword(STOKEY_LOGSIZE, logsize); else
log_printf("aoscfg: logsize too small (%u)!\n", logsize);
}
// apply DBPORT & DBCARD only if NO port selected
if (hlp_seroutinfo(0)==0) {
value = str_findkey(cfg, "DBCARD", 0);
if (value) shell_cmd("dbcard ", value); else {
value = str_findkey(cfg, "DBPORT", 0);
if (value) {
u32t port = str2ulong(value);
if (port) hlp_seroutset(port, 0);
}
}
}
// ramdisk creation (only if not exist one)
value = str_findkey(cfg, "RAMDISKNAME", 0);
if (value) setenv("VDISKNAME", value, 1);
value = str_findkey(cfg, "RAMDISK", 0);
if (value) {
qs_vdisk dsk = NEW(qs_vdisk);
if (dsk) {
u32t sectors;
qserr res = dsk->query(0, 0, §ors, 0, 0);
DELETE(dsk);
if (!res) {
log_printf("aoscfg: ramdisk already exists (%uMb)!\n", sectors>>11);
} else {
shell_cmd("ramdisk ", value);
}
} else
