static void dump_frba(struct frba_t *frba) { int i; printf("Found Region Section\n"); for (i = 0; i < MAX_REGIONS; i++) { printf("FLREG%d: 0x%08x\n", i, frba->flreg[i]); dump_region(i, frba); } }
int module_start(SceSize argc, const void *args) { int i, j; int ret; size_t num; SceKernelModuleInfo modinfo; SceUID modlist[MOD_LIST_SIZE]; log_reset(); LOG("kplugin by xerpi\n"); memset(modlist, 0, sizeof(modlist)); num = MOD_LIST_SIZE; ret = ksceKernelGetModuleList(KERNEL_PID, 0x80000001, 1, modlist, &num); if (ret < 0) LOG("Error getting the module list\n"); LOG("Found %d modules.\n", num); for (i = 0; i < num; i++) { memset(&modinfo, 0, sizeof(modinfo)); ret = ksceKernelGetModuleInfo(KERNEL_PID, modlist[i], &modinfo); if (ret < 0) { LOG("Error getting the module info for module: %d\n", i); continue; } LOG("Module %d name: %s\n", i, modinfo.module_name); for (j = 0; j < 4; j++) { char path[128]; SceKernelSegmentInfo *seginfo = &modinfo.segments[j]; if (seginfo->size != sizeof(*seginfo)) continue; if (seginfo->vaddr == NULL) continue; snprintf(path, sizeof(path), DUMP_PATH "%s_0x%08X_seg%d.bin", modinfo.module_name, (uintptr_t)seginfo->vaddr, j); dump_region(path, seginfo->vaddr, seginfo->memsz); } doDump(&modinfo); } return SCE_KERNEL_START_SUCCESS; }
int main(int argc, char *argv[]) { FILE *maps; int mem; pid_t pid; char path[BUFSIZ]; if(argc < 2) { fprintf(stderr, "usage: %s pid\n", argv[0]); return EXIT_FAILURE; } pid = strtol(argv[1], NULL, 10); if(ptrace(PTRACE_ATTACH, pid, NULL, NULL) == -1) { perror("ptrace"); return EXIT_FAILURE; } snprintf(path, sizeof(path), "/proc/%d/maps", pid); maps = fopen(path, "r"); snprintf(path, sizeof(path), "/proc/%d/mem", pid); mem = open(path, O_RDONLY); if(maps && mem != -1) { char buf[BUFSIZ + 1]; while(fgets(buf, BUFSIZ, maps)) { off64_t start, end; sscanf(buf, "%llx-%llx", &start, &end); dump_region(mem, start, end); } } ptrace(PTRACE_DETACH, pid, NULL, NULL); if(mem != -1) close(mem); if(maps) fclose(maps); return EXIT_SUCCESS; }
static int setpropex(int init_pid, int argc, char *argv[]) { int ret = -1; char tmp[128]; mapinfo *mi; if(argc != 3) { fprintf(stderr, "usage: setpropex <key> <value>\n"); return 1; } /* open it up, so we can read a copy */ sprintf(tmp, "/proc/%d/mem", init_pid); int mem = open(tmp, O_RDONLY); if(mem == -1) { LOGE("unable to open init's mem: %s", strerror(errno)); goto error2; } mi = load_maps(init_pid); while(mi != NULL) { if ( /* try several different strategies to find the property area in init */ (!strcmp(mi->perm, "rw-s") && !strcmp(mi->name, "/dev/__properties__")) || (!strcmp(mi->perm, "rw-s") && !strcmp(mi->name, "/dev/__properties__ (deleted)")) || (!strcmp(mi->perm, "rwxs") && !strcmp(mi->name, "/dev/__properties__ (deleted)")) || (!strcmp(mi->perm, "rwxs") && !strcmp(mi->name, "/dev/ashmem/system_properties (deleted)")) || /* property spaces split per SELinux type */ (!strcmp(mi->perm, "rw-s") && !strncmp(mi->name, "/dev/__properties__/u", strlen("/dev/__properties__/u"))) ) { LOGD("map found @ %"PRIxPTR" %"PRIxPTR" %s %s", mi->start, mi->end, mi->perm, mi->name); pa_size = mi->end - mi->start; pa_data_size = pa_size - sizeof(prop_area); /* allocate memory for our copy */ void *p = malloc(pa_size); if(p == 0) { LOGE("unable to allocate memory for our copy of the property area"); goto error1; } /* got it, read the data and set it for the system_property code */ dump_region(mem, mi->start, mi->end, p); __system_property_area__ = p; /* detect old versions of android and use the correct implementation * accordingly */ if (__system_property_area__->version == PROP_AREA_VERSION_COMPAT) compat_mode = true; /* set the property */ ret = property_set_ex(argv[1], argv[2], mem, mi); /* clean up */ free(p); if (ret == 0) break; } mi = mi->next; } if(ret == -1){ LOGE("didn't find the property!"); } error1: close(mem); error2: if(ret == 0){ return 0; } return 1; }
/************************************************************************* * ScrollDC (X11DRV.@) */ BOOL X11DRV_ScrollDC( HDC hdc, INT dx, INT dy, const RECT *lprcScroll, const RECT *lprcClip, HRGN hrgnUpdate, LPRECT lprcUpdate ) { RECT rcSrc, rcClip, offset; INT dxdev, dydev, res; HRGN DstRgn, clipRgn, visrgn; INT code = X11DRV_START_EXPOSURES; TRACE("dx,dy %d,%d rcScroll %s rcClip %s hrgnUpdate %p lprcUpdate %p\n", dx, dy, wine_dbgstr_rect(lprcScroll), wine_dbgstr_rect(lprcClip), hrgnUpdate, lprcUpdate); /* enable X-exposure events */ if (hrgnUpdate || lprcUpdate) ExtEscape( hdc, X11DRV_ESCAPE, sizeof(code), (LPSTR)&code, 0, NULL ); /* get the visible region */ visrgn=CreateRectRgn( 0, 0, 0, 0); GetRandomRgn( hdc, visrgn, SYSRGN); if( !(GetVersion() & 0x80000000)) { /* Window NT/2k/XP */ POINT org; GetDCOrgEx(hdc, &org); OffsetRgn( visrgn, -org.x, -org.y); } /* intersect with the clipping Region if the DC has one */ clipRgn = CreateRectRgn( 0, 0, 0, 0); if (GetClipRgn( hdc, clipRgn) != 1) { DeleteObject(clipRgn); clipRgn=NULL; } else CombineRgn( visrgn, visrgn, clipRgn, RGN_AND); /* only those pixels in the scroll rectangle that remain in the clipping * rect are scrolled. */ if( lprcClip) rcClip = *lprcClip; else GetClipBox( hdc, &rcClip); rcSrc = rcClip; OffsetRect( &rcClip, -dx, -dy); IntersectRect( &rcSrc, &rcSrc, &rcClip); /* if an scroll rectangle is specified, only the pixels within that * rectangle are scrolled */ if( lprcScroll) IntersectRect( &rcSrc, &rcSrc, lprcScroll); /* now convert to device coordinates */ LPtoDP(hdc, (LPPOINT)&rcSrc, 2); TRACE("source rect: %s\n", wine_dbgstr_rect(&rcSrc)); /* also dx and dy */ SetRect(&offset, 0, 0, dx, dy); LPtoDP(hdc, (LPPOINT)&offset, 2); dxdev = offset.right - offset.left; dydev = offset.bottom - offset.top; /* now intersect with the visible region to get the pixels that will * actually scroll */ DstRgn = CreateRectRgnIndirect( &rcSrc); res = CombineRgn( DstRgn, DstRgn, visrgn, RGN_AND); /* and translate, giving the destination region */ OffsetRgn( DstRgn, dxdev, dydev); if( TRACE_ON( scroll)) dump_region( "Destination scroll region: ", DstRgn); /* if there are any, do it */ if( res > NULLREGION) { RECT rect ; /* clip to the destination region, so we can BitBlt with a simple * bounding rectangle */ if( clipRgn) ExtSelectClipRgn( hdc, DstRgn, RGN_AND); else SelectClipRgn( hdc, DstRgn); GetRgnBox( DstRgn, &rect); DPtoLP(hdc, (LPPOINT)&rect, 2); TRACE("destination rect: %s\n", wine_dbgstr_rect(&rect)); BitBlt( hdc, rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top, hdc, rect.left - dx, rect.top - dy, SRCCOPY); } /* compute the update areas. This is the combined clip rectangle * minus the scrolled region, and intersected with the visible * region. */ if (hrgnUpdate || lprcUpdate) { HRGN hrgn = hrgnUpdate; HRGN ExpRgn = 0; /* collect all the exposures */ code = X11DRV_END_EXPOSURES; ExtEscape( hdc, X11DRV_ESCAPE, sizeof(code), (LPSTR)&code, sizeof(ExpRgn), (LPSTR)&ExpRgn ); /* Intersect clip and scroll rectangles, allowing NULL values */ if( lprcScroll) if( lprcClip) IntersectRect( &rcClip, lprcClip, lprcScroll); else rcClip = *lprcScroll; else if( lprcClip) rcClip = *lprcClip; else GetClipBox( hdc, &rcClip); /* Convert the combined clip rectangle to device coordinates */ LPtoDP(hdc, (LPPOINT)&rcClip, 2); if( hrgn ) SetRectRgn( hrgn, rcClip.left, rcClip.top, rcClip.right, rcClip.bottom); else hrgn = CreateRectRgnIndirect( &rcClip); CombineRgn( hrgn, hrgn, visrgn, RGN_AND); CombineRgn( hrgn, hrgn, DstRgn, RGN_DIFF); /* add the exposures to this */ if( ExpRgn) { if( TRACE_ON( scroll)) dump_region( "Expose region: ", ExpRgn); CombineRgn( hrgn, hrgn, ExpRgn, RGN_OR); DeleteObject( ExpRgn); } if( TRACE_ON( scroll)) dump_region( "Update region: ", hrgn); if( lprcUpdate) { GetRgnBox( hrgn, lprcUpdate ); /* Put the lprcUpdate in logical coordinates */ DPtoLP( hdc, (LPPOINT)lprcUpdate, 2 ); TRACE("returning lprcUpdate %s\n", wine_dbgstr_rect(lprcUpdate)); } if( !hrgnUpdate) DeleteObject( hrgn); } /* restore original clipping region */ SelectClipRgn( hdc, clipRgn); DeleteObject( visrgn); DeleteObject( DstRgn); if( clipRgn) DeleteObject( clipRgn); return TRUE; }
static void test_savedc_2(void) { HWND hwnd; HDC hdc; HRGN hrgn; RECT rc, rc_clip; int ret; hwnd = CreateWindowExA(0, "static", "", WS_POPUP, 0,0,100,100, 0, 0, 0, NULL); assert(hwnd != 0); ShowWindow(hwnd, SW_SHOW); UpdateWindow(hwnd); hrgn = CreateRectRgn(0, 0, 0, 0); assert(hrgn != 0); hdc = GetDC(hwnd); ok(hdc != NULL, "GetDC failed\n"); ret = GetClipBox(hdc, &rc_clip); ok(ret == SIMPLEREGION, "GetClipBox returned %d instead of SIMPLEREGION\n", ret); ret = GetClipRgn(hdc, hrgn); ok(ret == 0, "GetClipRgn returned %d instead of 0\n", ret); ret = GetRgnBox(hrgn, &rc); ok(ret == NULLREGION, "GetRgnBox returned %d (%d,%d-%d,%d) instead of NULLREGION\n", ret, rc.left, rc.top, rc.right, rc.bottom); /*dump_region(hrgn);*/ SetRect(&rc, 0, 0, 100, 100); ok(EqualRect(&rc, &rc_clip), "rects are not equal: (%d,%d-%d,%d) - (%d,%d-%d,%d)\n", rc.left, rc.top, rc.right, rc.bottom, rc_clip.left, rc_clip.top, rc_clip.right, rc_clip.bottom); ret = SaveDC(hdc); todo_wine { ok(ret == 1, "ret = %d\n", ret); } ret = IntersectClipRect(hdc, 0, 0, 50, 50); if (ret == COMPLEXREGION) { /* XP returns COMPLEXREGION although dump_region reports only 1 rect */ trace("Windows BUG: IntersectClipRect returned %d instead of SIMPLEREGION\n", ret); /* let's make sure that it's a simple region */ ret = GetClipRgn(hdc, hrgn); ok(ret == 1, "GetClipRgn returned %d instead of 1\n", ret); dump_region(hrgn); } else ok(ret == SIMPLEREGION, "IntersectClipRect returned %d instead of SIMPLEREGION\n", ret); ret = GetClipBox(hdc, &rc_clip); ok(ret == SIMPLEREGION, "GetClipBox returned %d instead of SIMPLEREGION\n", ret); SetRect(&rc, 0, 0, 50, 50); ok(EqualRect(&rc, &rc_clip), "rects are not equal\n"); ret = RestoreDC(hdc, 1); ok(ret, "ret = %d\n", ret); ret = GetClipBox(hdc, &rc_clip); ok(ret == SIMPLEREGION, "GetClipBox returned %d instead of SIMPLEREGION\n", ret); SetRect(&rc, 0, 0, 100, 100); ok(EqualRect(&rc, &rc_clip), "rects are not equal\n"); DeleteObject(hrgn); ReleaseDC(hwnd, hdc); DestroyWindow(hwnd); }
boolean save_executable(char *filename, lispobj init_function) { char *dir_name; #if defined WANT_CGC volatile lispobj *func_ptr = &init_function; char sbuf[128]; strcpy(sbuf, filename); filename = sbuf; /* Get rid of remnant stuff. This is a MUST so that * the memory manager can get started correctly when * we restart after this save. Purify is going to * maybe move the args so we need to consider them volatile, * especially if the gcc optimizer is working!! */ purify(NIL, NIL); init_function = *func_ptr; /* Set dynamic space pointer to base value so we don't write out * MBs of just cleared heap. */ if(SymbolValue(X86_CGC_ACTIVE_P) != NIL) SetSymbolValue(ALLOCATION_POINTER, DYNAMIC_0_SPACE_START); #endif dir_name = dirname(strdup(filename)); printf("[Undoing binding stack... "); fflush(stdout); unbind_to_here((lispobj *)BINDING_STACK_START); SetSymbolValue(CURRENT_CATCH_BLOCK, 0); SetSymbolValue(CURRENT_UNWIND_PROTECT_BLOCK, 0); SetSymbolValue(EVAL_STACK_TOP, 0); printf("done]\n"); #if defined WANT_CGC && defined X86_CGC_ACTIVE_P SetSymbolValue(X86_CGC_ACTIVE_P, T); #endif printf("[Saving current lisp image as executable into \"%s\":\n", filename); printf("\t[Writing core objects\n"); fflush(stdout); write_space_object(dir_name, READ_ONLY_SPACE_ID, (os_vm_address_t)read_only_space, (os_vm_address_t)SymbolValue(READ_ONLY_SPACE_FREE_POINTER)); write_space_object(dir_name, STATIC_SPACE_ID, (os_vm_address_t)static_space, (os_vm_address_t)SymbolValue(STATIC_SPACE_FREE_POINTER)); #ifdef GENCGC /* Flush the current_region updating the tables. */ #ifdef DEBUG_BAD_HEAP fprintf(stderr, "before ALLOC_POINTER = %p\n", (lispobj *) SymbolValue(ALLOCATION_POINTER)); dump_region(&boxed_region); #endif gc_alloc_update_page_tables(0,&boxed_region); gc_alloc_update_page_tables(1,&unboxed_region); #ifdef DEBUG_BAD_HEAP fprintf(stderr, "boxed_region after update\n"); dump_region(&boxed_region); print_ptr((lispobj*) 0x2805a184); #endif #ifdef DEBUG_BAD_HEAP /* * For some reason x86 has a heap corruption problem. I (rtoy) * have not been able to figure out how that occurs, but what is * happening is that when a core is loaded, there is some static * object pointing to an object that is on a free page. In normal * usage, at startup there should be 4 objects in static space * pointing to a free page, because these are newly allocated * objects created by the C runtime. However, there is an * additional object. * * I do not know what this object should be or how it got there, * but it will often cause CMUCL to fail to save a new core file. * * Disabling this call to update_dynamic_space_free_pointer is a * work around. What is happening is that u_d_s_f_p is resetting * ALLOCATION_POINTER, but that weird object is in the current * region, but after resetting the pointer, that object isn't * saved to the core file. By not resetting the pointer, the * object (or at least enough of it) gets saved in the core file * that we don't have problems when reloading. * * Note that on sparc and ppc, u_d_s_f_p doesn't actually do * anything because the call to reset ALLOCATION_POINTER is a nop * on sparc and ppc. And sparc and ppc dont' have the heap * corruption issue. That's not conclusive evidence, though. * * This needs more work and investigation. */ update_dynamic_space_free_pointer(); #endif #ifdef DEBUG_BAD_HEAP fprintf(stderr, "after ALLOC_POINTER = %p\n", (lispobj *) SymbolValue(ALLOCATION_POINTER)); #endif #endif #ifdef reg_ALLOC write_space_object(dir_name, DYNAMIC_SPACE_ID, (os_vm_address_t)current_dynamic_space, (os_vm_address_t)current_dynamic_space_free_pointer); #else write_space_object(dir_name, DYNAMIC_SPACE_ID, (os_vm_address_t)current_dynamic_space, (os_vm_address_t)SymbolValue(ALLOCATION_POINTER)); #endif printf("\tdone]\n"); fflush(stdout); printf("Linking executable...\n"); fflush(stdout); obj_run_linker(init_function, filename); printf("done.\n"); exit(0); }