int control_module_threads(SceUID module_id, int pause) {
// get an array of all threads
int thread_count;
if (sceKernelGetThreadmanIdList(SCE_KERNEL_TMID_Thread, NULL, 0, &thread_count) < 0)
return 0;
if (thread_count < 1)
return 0;
SceUID thread_id[thread_count];
if (sceKernelGetThreadmanIdList(SCE_KERNEL_TMID_Thread, thread_id, thread_count, NULL) < 0)
return 0;
int i;
SceModule* module;
SceKernelThreadInfo thread_info;
thread_info.size = sizeof(SceKernelThreadInfo);
for (i = 0; i < thread_count; i++) {
// determine if a thread is from the game
if (sceKernelReferThreadStatus(thread_id[i], &thread_info))
continue;
module = sceKernelFindModuleByAddress((unsigned int) thread_info.entry);
if (module && module->modid == module_id) {
// pause or resume the thread
if (pause)
sceKernelSuspendThread(thread_id[i]);
else
sceKernelResumeThread(thread_id[i]);
}
}
return 1;
}
int nkThreadSuspend(SceUID thId){
int i, j;
SceUID myThread, *Thread_Now;
if(bufNow.pThread != 0) return 1;
bufNow.pThread = sceKernelAllocPartitionMemory(1, "th", 0, MAX_THREAD*sizeof(SceUID), NULL);
if(bufNow.pThread < 0){
bufNow.count = 0;
bufNow.pThread = 0;
return 1;
}
Thread_Now = (SceUID*)sceKernelGetBlockHeadAddr(bufNow.pThread);
sceKernelGetThreadmanIdList(SCE_KERNEL_TMID_Thread, Thread_Now, MAX_THREAD, &(bufNow.count));
myThread = sceKernelGetThreadId();
for(i = 0; i < bufNow.count; i++){
unsigned char match = 0;
SceUID tmp_thid = Thread_Now[i];
for(j = 0; j < count_Start; j++){
if((tmp_thid == Thread_Start[j]) || (tmp_thid == thId) || (tmp_thid == myThread)){
match = 1;
j = count_Start;
}
}
if(match == 0){
sceKernelSuspendThread(tmp_thid);
}
}
return 0;
}
static int _pspSdkReferInternal(const char *name, enum SceKernelIdListType type,
struct _ThreadInfoSkel *pInfo, int size, ReferFunc pRefer)
{
int uid_count = 0;
/* First determine the number of threads we have. */
int res = sceKernelGetThreadmanIdList(type, NULL, 0, &uid_count);
if (res < 0) {
return res;
}
if (uid_count == 0) {
return -1; /* XXX: Should we return a kernel errorcode here? */
}
/* Grab UIDs for all of the threads. */
SceUID uid_buf[uid_count];
res = sceKernelGetThreadmanIdList(type, uid_buf, uid_count, NULL);
if (res < 0) {
return res;
}
int i;
for (i = 0; i < uid_count; i++) {
memset(pInfo, 0, size);
pInfo->size = size;
res = pRefer(uid_buf[i], pInfo);
if (res < 0) {
/* If we got an error than we probably don't have enough privileges
to access the thread's info. */
continue;
}
if (pInfo->name[0] != '\0' && strcmp(pInfo->name, name) == 0) {
/* Found it. */
return uid_buf[i];
}
}
/* Unable to find the thread (or insufficient access to retrieve it's info). */
return -1; /* XXX: Should we return a kernel errorcode here? */
}
int nkLoad(){
count_Start = 0;
sceKernelGetThreadmanIdList(SCE_KERNEL_TMID_Thread, Thread_Start, MAX_THREAD, &count_Start);
bufNow.count = 0;
bufNow.pThread = 0;
return 0;
}
int threadCtrlSuspend()
{
if (threadCtrlState() == THREAD_CTRL_STATE_SUSPEND) {
return 1;
}
int i, n;
SceUID this_thid;
SceKernelThreadInfo thinfo;
this_thid = sceKernelGetThreadId();
sceKernelGetThreadmanIdList(SCE_KERNEL_TMID_Thread, current_thid, MAX_THREAD, ¤t_count);
for (i = 0;i < current_count;i++) {
memset(&thinfo, 0, sizeof(SceKernelThreadInfo));
thinfo.size = sizeof(SceKernelThreadInfo);
sceKernelReferThreadStatus(current_thid[i], &thinfo);
if (thinfo.status & PSP_THREAD_SUSPEND || current_thid[i] == this_thid) {
current_thid[i] = -1;
continue;
}
for (n = 0;n < first_count;n++) {
if (current_thid[i] == first_thid[n]) {
current_thid[i] = -1;
break;
}
}
}
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - */
/* I got a hint from taba's JPCheat, thanks! */
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - */
if (use_safely_suspend) {
int count;
for (count = 0;count < 1000;count++) {
if ((IO_MEM_STICK_STATUS & 0x2000) == 0) {
count = 0;
}
sceKernelDelayThread(1);
}
}
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - */
for (i = 0;i < current_count;i++) {
if (current_thid[i] >= 0) {
sceKernelSuspendThread(current_thid[i]);
}
}
return 0;
}
static int MainThread( SceSize args, void *argp )
{
hookDisplay();
sceKernelDcacheWritebackInvalidateAll();
sceKernelIcacheInvalidateAll();
//scePowerTick( 0 );
unsigned int paddata_old = 0;
char file[64], flag = 0, size = 0;
int x, y, fd, count = 0, thread_count_start, thread_count_now;
SceUID thread_buf_start[MAX_THREAD], thread_buf_now[MAX_THREAD], myThread = sceKernelGetThreadId();
SceCtrlData paddata;
sceKernelDelayThread(10000);
sceKernelGetThreadmanIdList(SCE_KERNEL_TMID_Thread, thread_buf_start, MAX_THREAD, &thread_count_start);
while(1)
{
sceCtrlPeekBufferPositive(&paddata, 1);
if(paddata.Buttons != paddata_old)
{
//press "note" button and magick begin
if(paddata.Buttons & PSP_CTRL_NOTE)
{
// IdList Now
sceKernelGetThreadmanIdList(SCE_KERNEL_TMID_Thread, thread_buf_now, MAX_THREAD, &thread_count_now);
//hold all threads for a moment
for(x = 0; x < thread_count_now; x++)
{
// thread id match 0 or 1
unsigned char match = 0;
SceUID tmp_thid = thread_buf_now[x];
for(y = 0; y < thread_count_start; y++)
{
if((tmp_thid == thread_buf_start[y]) || (tmp_thid == myThread))
{
match = 1;
y = thread_count_start;
}
}
if(thread_count_start == 0) match = 1;
if(match == 0)
{
sceKernelSuspendThread(tmp_thid);
}
}
//can parse command list
can_parse = 1;
//resume all threads
for(x = 0; x < thread_count_now; x++)
{
// thread id match 0 or 1
unsigned char match = 0;
SceUID tmp_thid = thread_buf_now[x];
for(y = 0; y < thread_count_start; y++)
{
if((tmp_thid == thread_buf_start[y]) || (tmp_thid == myThread))
{
match = 1;
y = thread_count_start;
}
}
if(thread_count_start == 0) match = 1;
if(match == 0)
{
sceKernelResumeThread(tmp_thid);
}
}
}
}
paddata_old = paddata.Buttons;
sceKernelDelayThread(10000);
}
return( 0 );
}
int threadCtrlInit()
{
return sceKernelGetThreadmanIdList(SCE_KERNEL_TMID_Thread, first_thid, MAX_THREAD, &first_count);
}
