long int ptrace (enum __ptrace_request __request, ...)
{
pid_t pid;
void *addr, *data;
va_list ap;
va_start(ap, __request);
pid = va_arg(ap, pid_t);
addr = va_arg(ap, void *);
data = va_arg(ap, void *);
va_end(ap);
if(__request == PTRACE_GETREGS)
{
return get_regs(pid, addr, data);
}
else if(__request == PTRACE_SETREGS)
{
return set_regs(pid, addr, data);
}
#if 0
//some old system may require this command to get register
else if(__request == PTRACE_PEEKUSER)
{
}
#endif
else if(__request == PTRACE_GETFPREGS)
{
return get_fpregs(pid, addr, data, FALSE);
}
else if(__request == PTRACE_SETFPREGS)
{
return set_fpregs(pid, addr, data, FALSE);
}
else if(__request == PTRACE_GETFPXREGS)
{
return get_fpregs(pid, addr, data, TRUE);
}
else if(__request == PTRACE_SETFPXREGS)
{
return set_fpregs(pid, addr, data, TRUE);
}
//xstave for avx
else if(__request == PTRACE_GETREGSET)
{
return get_regset(pid, addr, data);
}
else if(__request == PTRACE_SETREGSET)
{
return set_regset(pid, addr, data);
}
//For other request just forward it to real ptrace call;
return g_sys_ptrace(__request, pid, addr, data);
}
void
print_pc(struct tcb *tcp)
{
#if defined ARCH_PC_REG
# define ARCH_GET_PC 0
#elif defined ARCH_PC_PEEK_ADDR
kernel_ulong_t pc;
# define ARCH_PC_REG pc
# define ARCH_GET_PC upeek(tcp->pid, ARCH_PC_PEEK_ADDR, &pc)
#else
# error Neither ARCH_PC_REG nor ARCH_PC_PEEK_ADDR is defined
#endif
get_regs(tcp->pid);
if (get_regs_error || ARCH_GET_PC)
tprints(current_wordsize == 4 ? "[????????] "
: "[????????????????] ");
else
tprintf(current_wordsize == 4
? "[%08" PRI_klx "] " : "[%016" PRI_klx "] ",
(kernel_ulong_t) ARCH_PC_REG);
}
/* Returns:
* 0: "bail out".
* 1: ok.
* -1: error in one of ptrace ops.
*
* If not 0, call syscall_exiting_trace(tcp, res), where res is the return
* value. Anyway, call syscall_exiting_finish(tcp) then.
*/
int
syscall_exiting_decode(struct tcb *tcp, struct timeval *ptv)
{
/* Measure the exit time as early as possible to avoid errors. */
if ((Tflag || cflag) && !(filtered(tcp) || hide_log(tcp)))
gettimeofday(ptv, NULL);
#ifdef USE_LIBUNWIND
if (stack_trace_enabled) {
if (tcp->s_ent->sys_flags & STACKTRACE_INVALIDATE_CACHE)
unwind_cache_invalidate(tcp);
}
#endif
if (filtered(tcp) || hide_log(tcp))
return 0;
get_regs(tcp->pid);
#if SUPPORTED_PERSONALITIES > 1
update_personality(tcp, tcp->currpers);
#endif
return get_regs_error ? -1 : get_syscall_result(tcp);
}
static void
bnad_get_regs(struct net_device *netdev, struct ethtool_regs *regs, void *buf)
{
memset(buf, 0, bnad_get_regs_len(netdev));
get_regs(netdev_priv(netdev), buf);
}
static int
bnad_get_regs_len(struct net_device *netdev)
{
int ret = get_regs(netdev_priv(netdev), NULL) * sizeof(u32);
return ret;
}
static long
ptrace_getregset(pid_t pid)
{
# ifdef ARCH_IOVEC_FOR_GETREGSET
/* variable iovec */
ARCH_IOVEC_FOR_GETREGSET.iov_len = sizeof(ARCH_REGS_FOR_GETREGSET);
return ptrace(PTRACE_GETREGSET, pid, NT_PRSTATUS,
&ARCH_IOVEC_FOR_GETREGSET);
# else
/* constant iovec */
static struct iovec io = {
.iov_base = &ARCH_REGS_FOR_GETREGSET,
.iov_len = sizeof(ARCH_REGS_FOR_GETREGSET)
};
return ptrace(PTRACE_GETREGSET, pid, NT_PRSTATUS, &io);
# endif
}
# ifndef HAVE_GETREGS_OLD
# define ptrace_setregset_or_setregs ptrace_setregset
static int
ptrace_setregset(pid_t pid)
{
# ifdef ARCH_IOVEC_FOR_GETREGSET
/* variable iovec */
return ptrace(PTRACE_SETREGSET, pid, NT_PRSTATUS,
&ARCH_IOVEC_FOR_GETREGSET);
# else
/* constant iovec */
static struct iovec io = {
.iov_base = &ARCH_REGS_FOR_GETREGSET,
.iov_len = sizeof(ARCH_REGS_FOR_GETREGSET)
};
return ptrace(PTRACE_SETREGSET, pid, NT_PRSTATUS, &io);
# endif
}
# endif /* !HAVE_GETREGS_OLD */
#elif defined ARCH_REGS_FOR_GETREGS
# define ptrace_getregset_or_getregs ptrace_getregs
static long
ptrace_getregs(pid_t pid)
{
# if defined SPARC || defined SPARC64
/* SPARC systems have the meaning of data and addr reversed */
return ptrace(PTRACE_GETREGS, pid, (void *) &ARCH_REGS_FOR_GETREGS, 0);
# else
return ptrace(PTRACE_GETREGS, pid, NULL, &ARCH_REGS_FOR_GETREGS);
# endif
}
# ifndef HAVE_GETREGS_OLD
# define ptrace_setregset_or_setregs ptrace_setregs
static int
ptrace_setregs(pid_t pid)
{
# if defined SPARC || defined SPARC64
/* SPARC systems have the meaning of data and addr reversed */
return ptrace(PTRACE_SETREGS, pid, (void *) &ARCH_REGS_FOR_GETREGS, 0);
# else
return ptrace(PTRACE_SETREGS, pid, NULL, &ARCH_REGS_FOR_GETREGS);
# endif
}
# endif /* !HAVE_GETREGS_OLD */
#endif /* ARCH_REGS_FOR_GETREGSET || ARCH_REGS_FOR_GETREGS */
static void
get_regs(pid_t pid)
{
#undef USE_GET_SYSCALL_RESULT_REGS
#ifdef ptrace_getregset_or_getregs
if (get_regs_error != -1)
return;
# ifdef HAVE_GETREGS_OLD
/*
* Try PTRACE_GETREGSET/PTRACE_GETREGS first,
* fallback to getregs_old.
*/
static int use_getregs_old;
if (use_getregs_old < 0) {
get_regs_error = ptrace_getregset_or_getregs(pid);
return;
} else if (use_getregs_old == 0) {
get_regs_error = ptrace_getregset_or_getregs(pid);
if (get_regs_error >= 0) {
use_getregs_old = -1;
return;
}
if (errno == EPERM || errno == ESRCH)
return;
use_getregs_old = 1;
}
get_regs_error = getregs_old(pid);
# else /* !HAVE_GETREGS_OLD */
/* Assume that PTRACE_GETREGSET/PTRACE_GETREGS works. */
get_regs_error = ptrace_getregset_or_getregs(pid);
# endif /* !HAVE_GETREGS_OLD */
#else /* !ptrace_getregset_or_getregs */
# define USE_GET_SYSCALL_RESULT_REGS 1
# warning get_regs is not implemented for this architecture yet
get_regs_error = 0;
#endif /* !ptrace_getregset_or_getregs */
}
#ifdef ptrace_setregset_or_setregs
static int
set_regs(pid_t pid)
{
return ptrace_setregset_or_setregs(pid);
}
#endif /* ptrace_setregset_or_setregs */
struct sysent_buf {
struct tcb *tcp;
struct_sysent ent;
char buf[sizeof("syscall_%lu") + sizeof(kernel_ulong_t) * 3];
};
static void
free_sysent_buf(void *ptr)
{
struct sysent_buf *s = ptr;
s->tcp->s_prev_ent = s->tcp->s_ent = NULL;
free(ptr);
}
/*
* Returns:
* 0: "ignore this ptrace stop", syscall_entering_decode() should return a "bail
* out silently" code.
* 1: ok, continue in syscall_entering_decode().
* other: error, syscall_entering_decode() should print error indicator
* ("????" etc) and return an appropriate code.
*/
int
get_scno(struct tcb *tcp)
{
get_regs(tcp->pid);
if (get_regs_error)
return -1;
int rc = arch_get_scno(tcp);
if (rc != 1)
return rc;
if (scno_is_valid(tcp->scno)) {
tcp->s_ent = &sysent[tcp->scno];
tcp->qual_flg = qual_flags(tcp->scno);
} else {
struct sysent_buf *s = xcalloc(1, sizeof(*s));
s->tcp = tcp;
s->ent.nargs = MAX_ARGS;
s->ent.sen = SEN_printargs;
s->ent.sys_func = printargs;
s->ent.sys_name = s->buf;
sprintf(s->buf, "syscall_%" PRI_klu, shuffle_scno(tcp->scno));
tcp->s_ent = &s->ent;
tcp->qual_flg = QUAL_RAW | DEFAULT_QUAL_FLAGS;
set_tcb_priv_data(tcp, s, free_sysent_buf);
if (debug_flag)
error_msg("pid %d invalid syscall %" PRI_kld,
tcp->pid, tcp->scno);
}
return 1;
}
#ifdef USE_GET_SYSCALL_RESULT_REGS
static int get_syscall_result_regs(struct tcb *);
#endif
/* Returns:
* 1: ok, continue in syscall_exiting_trace().
* -1: error, syscall_exiting_trace() should print error indicator
* ("????" etc) and bail out.
*/
static int
get_syscall_result(struct tcb *tcp)
{
#ifdef USE_GET_SYSCALL_RESULT_REGS
if (get_syscall_result_regs(tcp))
return -1;
#endif
tcp->u_error = 0;
get_error(tcp, !(tcp->s_ent->sys_flags & SYSCALL_NEVER_FAILS));
return 1;
}
#include "get_scno.c"
#include "set_scno.c"
#include "get_syscall_args.c"
#ifdef USE_GET_SYSCALL_RESULT_REGS
# include "get_syscall_result.c"
#endif
#include "get_error.c"
#include "set_error.c"
#ifdef HAVE_GETREGS_OLD
# include "getregs_old.c"
#endif
const char *
syscall_name(kernel_ulong_t scno)
{
#if defined X32_PERSONALITY_NUMBER && defined __X32_SYSCALL_BIT
if (current_personality == X32_PERSONALITY_NUMBER)
scno &= ~__X32_SYSCALL_BIT;
#endif
return scno_is_valid(scno) ? sysent[scno].sys_name : NULL;
}
static u32 pxa168fb_ovly_set_colorkeyalpha(struct pxa168fb_info *fbi)
{
struct _sColorKeyNAlpha color_a = fbi->ckey_alpha;
unsigned int rb, x, layer, dma0, shift, r, b;
struct pxa168fb_mach_info *mi;
struct lcd_regs *regs;
dev_dbg(fbi->fb_info->dev, "Enter %s\n", __func__);
mi = fbi->dev->platform_data;
regs = get_regs(fbi->id);
dma0 = dma_ctrl_read(fbi->id, 0);
shift = fbi->id ? 20 : 18;
rb = layer = 0;
r = color_a.Y_ColorAlpha;
b = color_a.V_ColorAlpha;
/* reset to 0x0 to disable color key. */
x = dma_ctrl_read(fbi->id, 1) & ~(CFG_COLOR_KEY_MASK |
CFG_ALPHA_MODE_MASK | CFG_ALPHA_MASK);
/* switch to color key mode */
switch (color_a.mode) {
case FB_DISABLE_COLORKEY_MODE:
/* do nothing */
break;
case FB_ENABLE_Y_COLORKEY_MODE:
x |= CFG_COLOR_KEY_MODE(0x1);
break;
case FB_ENABLE_U_COLORKEY_MODE:
x |= CFG_COLOR_KEY_MODE(0x2);
break;
case FB_ENABLE_V_COLORKEY_MODE:
x |= CFG_COLOR_KEY_MODE(0x4);
pr_info("V colorkey not supported, Chroma key instead\n");
break;
case FB_ENABLE_RGB_COLORKEY_MODE:
x |= CFG_COLOR_KEY_MODE(0x3);
rb = 1;
break;
case FB_ENABLE_R_COLORKEY_MODE:
x |= CFG_COLOR_KEY_MODE(0x1);
rb = 1;
break;
case FB_ENABLE_G_COLORKEY_MODE:
x |= CFG_COLOR_KEY_MODE(0x6);
pr_info("G colorkey not supported, Luma key instead\n");
break;
case FB_ENABLE_B_COLORKEY_MODE:
x |= CFG_COLOR_KEY_MODE(0x7);
rb = 1;
break;
default:
pr_info("unknown mode");
return -1;
}
/* switch to alpha path selection */
switch (color_a.alphapath) {
case FB_VID_PATH_ALPHA:
x |= CFG_ALPHA_MODE(0x0);
layer = CFG_CKEY_DMA;
if (rb)
rb = ((dma0 & CFG_DMA_SWAPRB_MASK) >> 4) ^
(mi->panel_rbswap);
break;
case FB_GRA_PATH_ALPHA:
x |= CFG_ALPHA_MODE(0x1);
layer = CFG_CKEY_GRA;
if (rb)
rb = ((dma0 & CFG_GRA_SWAPRB_MASK) >> 12) ^
(mi->panel_rbswap);
break;
case FB_CONFIG_ALPHA:
x |= CFG_ALPHA_MODE(0x2);
rb = 0;
break;
default:
pr_info("unknown alpha path");
return -1;
}
/* check whether DMA turn on RB swap for this pixelformat. */
if (rb) {
if (color_a.mode == FB_ENABLE_R_COLORKEY_MODE) {
x &= ~CFG_COLOR_KEY_MODE(0x1);
x |= CFG_COLOR_KEY_MODE(0x7);
}
if (color_a.mode == FB_ENABLE_B_COLORKEY_MODE) {
x &= ~CFG_COLOR_KEY_MODE(0x7);
x |= CFG_COLOR_KEY_MODE(0x1);
}
/* exchange r b fields. */
r = color_a.V_ColorAlpha;
b = color_a.Y_ColorAlpha;
/* only alpha_Y take effect, switch back from V */
if (color_a.mode == FB_ENABLE_RGB_COLORKEY_MODE) {
r &= 0xffffff00;
r |= (color_a.Y_ColorAlpha & 0xff);
}
}
/* configure alpha */
x |= CFG_ALPHA((color_a.config & 0xff));
dma_ctrl_write(fbi->id, 1, x);
writel(r, ®s->v_colorkey_y);
writel(color_a.U_ColorAlpha, ®s->v_colorkey_u);
writel(b, ®s->v_colorkey_v);
if (fbi->id != 2) {
/* enable DMA colorkey on graphics/video layer
* in panel/TV path */
x = readl(fbi->reg_base + LCD_TV_CTRL1);
x &= ~(3<<shift); x |= layer<<shift;
writel(x, fbi->reg_base + LCD_TV_CTRL1);
}
return 0;
}
int main(int argc, char **argv){
int ram_fd;
char *ram, *ram_filename;
struct stat ram_fs;
//int num_vms;
int num_vcpus;
pid_t creator;
int vmfd;
int rv;
int sc[3];
struct kvm_regs regs;
struct kvm_sregs sregs;
union event_data event_data;
go = 1;
signal(SIGINT, sig_handler);
if (argc < 3){
printf("Usage: [qemu pid] [guest ram filename]\n");
return -1;
}
ram_filename = argv[2];
printf("Mapping Guest Memory...\n");
if (stat(ram_filename, &ram_fs) == -1){
perror("stat");
return -1;
}
if ((ram_fd = open(ram_filename,O_RDWR)) == -1){
perror("open");
return -1;
}
if((ram = mmap(NULL, ram_fs.st_size, (PROT_READ | PROT_WRITE), MAP_SHARED, ram_fd, 0)) == (void*)-1){
perror("mmap");
close(ram_fd);
return -1;
}
printf("Initializing KVM...\n");
if(init_kvm()){
printf("Unable to initialize kvm, exiting.\n");
return -1;
}
printf("Initialized\n\n");
creator = (pid_t)atoi(argv[1]);
printf("calling attach_vm() with creator pid: %d...\n",creator);
vmfd = attach_vm(creator);
if(vmfd < 0){
printf("Error attaching to VM, exiting\n");
return -1;
}
printf("attach_vm() returned %d\n\n",vmfd);
printf("calling attach_vcpus()...\n");
num_vcpus = attach_vcpus();
printf("attach_vcpus() returned %d\n\n",num_vcpus);
/*
printf("calling get_regs()...\n");
if(get_regs(0,®s)){
printf("Error getting regs, exiting\n");
return -1;
}
printf("get_regs() returned rip: 0x%llX\n\n",regs.rip);
printf("calling get_sregs()...\n");
if(get_sregs(0,&sregs)){
printf("Error getting sregs, exiting\n");
return -1;
}
printf("get_sregs() returned cr0: 0x%llX\n\n",sregs.cr0);
*/
printf("calling set_syscall_trap()...\n");
sc[0] = 0x9f;
sc[1] = 0x4a;
sc[2] = 0xaa;
rv = set_syscall_trap(sc,3);
printf("set_syscall_trap() returned %d\n\n",rv);
while(go){
rv = get_event(0,&event_data);
if(get_regs(0,®s)){
printf("Error getting regs, exiting\n");
continue_vm(0);
break;
}
if(get_sregs(0,&sregs)){
printf("Error getting sregs, exiting\n");
continue_vm(0);
break;
}
if(rv == KVM_NITRO_EVENT_SYSCALL)
printf("Syscall trapped key: 0x%lX cr3: 0x%llX rax: 0x%llX\n",event_data.syscall,sregs.cr3,regs.rax);
else if(rv == KVM_NITRO_EVENT_SYSRET)
printf("Sysret trapped key: 0x%lX cr3: 0x%llX\n",event_data.syscall,sregs.cr3);
rv = continue_vm(0);
}
printf("calling unset_syscall_trap()...\n");
rv = unset_syscall_trap();
printf("unset_syscall_trap() returned %d\n\n",rv);
close_kvm();
munmap(ram,ram_fs.st_size);
close(ram_fd);
return 0;
}
