Пример #1
0
/* Callback thread */
int CallbackThread(SceSize args, void *argp) {
    int cbid;

    cbid = sceKernelCreateCallback("Exit Callback", exit_callback, NULL);
    sceKernelRegisterExitCallback(cbid);
    sceKernelSleepThreadCB();
    return 0;
}
Пример #2
0
    int callbacks_thread(unsigned int, void*)
    {
        int id;

        id = sceKernelCreateCallback("exit_cb", callbacks_exit, NULL);
        sceKernelRegisterExitCallback(id);
        sceKernelSleepThreadCB();

        return 0;
    }
Пример #3
0
// Thread to create the callbacks and then begin polling
int CallbackThread (int args, void *argp)
{
	int cbid;

	cbid = sceKernelCreateCallback ("Exit Callback", (SceKernelCallbackFunction)ExitCallback, NULL);
	sceKernelRegisterExitCallback  (cbid);
	cbid = sceKernelCreateCallback ("Power Callback", (SceKernelCallbackFunction)PowerCallback, NULL);
	scePowerRegisterCallback       (0, cbid);

	sceKernelSleepThreadCB ();
}
Пример #4
0
/* Callback thread */
int CallbackThread(SceSize args, void *argp)
{
	int cbid;

	printf("\nCallback Thread Status:\n");
	dump_threadstatus();
	cbid = sceKernelCreateCallback("Exit Callback", exit_callback, NULL);
	sceKernelRegisterExitCallback(cbid);

	sceKernelSleepThreadCB();

	return 0;
}
Пример #5
0
int 
psp_callback_thread(SceSize args, void *argp)
{
  int cid;

  cid = sceKernelCreateCallback("Exit Call Back", psp_exit_callback, NULL);
  sceKernelRegisterExitCallback(cid);
  cid = sceKernelCreateCallback("Power Call Back", psp_power_callback, NULL);
  //scePowerRegisterCallback(0,cid);

	sceKernelSleepThreadCB();
  
  return 0;
}
Пример #6
0
/* Callback thread */
int CallbackThread(SceSize args, void *argp)
{
    int cbid;

    //SceKernelThreadInfo info;
    //info.size = sizeof(SceKernelThreadInfo);
    //sceKernelReferThreadStatus (0, &info);
    //printf("thread '%-12s' sp %p w %08x START\n", info.name, info.stack, info.waitId);

    cbid = sceKernelCreateCallback("Exit Callback", exit_callback, NULL);
    sceKernelRegisterExitCallback(cbid);
    sceKernelSleepThreadCB();

    return 0;
}
Пример #7
0
/* Callback thread */
static int callback_thread(SceSize args, void *argp)
{
	int cbid;

	lprintf("callback_thread started with id %08x, priority %i\n",
		sceKernelGetThreadId(), sceKernelGetThreadCurrentPriority());

	cbid = sceKernelCreateCallback("Exit Callback", exit_callback, NULL);
	sceKernelRegisterExitCallback(cbid);
	cbid = sceKernelCreateCallback("Power Callback", power_callback, NULL);
	scePowerRegisterCallback(0, cbid);

	sceKernelSleepThreadCB();

	return 0;
}
Пример #8
0
/* Callback thread */
int CallbackThread(SceSize /*size*/, void *arg) {
	int cbid;

	cbid = sceKernelCreateCallback("Exit Callback", (SceKernelCallbackFunction)exit_callback, NULL);
	sceKernelRegisterExitCallback(cbid);
	/* Set up callbacks for PSPIoStream */

	cbid = sceKernelCreateCallback("Power Callback", (SceKernelCallbackFunction)power_callback, 0);
	if (cbid >= 0) {
		if (scePowerRegisterCallback(-1, cbid) < 0) {
			PSP_ERROR("Couldn't register callback for power_callback\n");
		}
	} else {
		PSP_ERROR("Couldn't create a callback for power_callback\n");
	}

	sceKernelSleepThreadCB();
	return 0;
}
Пример #9
0
int LoadExecForKernel_4AC57943(SceUID cbId) 
{
	WARN_LOG(SCEKERNEL,"LoadExecForKernel_4AC57943:Not support this patcher");
	return sceKernelRegisterExitCallback(cbId);//not sure right
}
Пример #10
0
static int ExitCallbackThread(SceSize args, void *argp)
{
	sceKernelRegisterExitCallback(sceKernelCreateCallback("HOME button Callback", exit_callback, NULL));
	sceKernelSleepThreadCB();
	return 0;
}
Пример #11
0
extern "C" int main(int argc, char *argv[]) {
	ExitCallbackArg arg;
	ExitCallbackArgParams params;

	arg.unknown1 = 0;
	arg.params = &params;
	params.size = 12;
	params.unk1 = 0x1337;
	params.unk2 = 0x1337;

	Callback cb1("count1", &cbFunc, NULL);
	Callback cb2("count2", &cbFunc, &arg.common);

	checkpointNext("Objects:");
	checkpoint("  Normal: %08x", sceKernelRegisterExitCallback(cb1));
	checkpoint("  NULL: %08x", sceKernelRegisterExitCallback(0));
	checkpoint("  Invalid: %08x", sceKernelRegisterExitCallback(0xDEADBEEF));
	cb1.Delete();
	checkpoint("  Deleted: %08x", sceKernelRegisterExitCallback(cb1));

	sceKernelSetCompiledSdkVersion(0x3090500);
	cb1.Create("count1", &cbFunc, NULL);

	checkpointNext("Objects (SDK 3.95+):");
	checkpoint("  Normal: %08x", sceKernelRegisterExitCallback(cb1));
	checkpoint("  NULL: %08x", sceKernelRegisterExitCallback(0));
	checkpoint("  Invalid: %08x", sceKernelRegisterExitCallback(0xDEADBEEF));
	cb1.Delete();
	checkpoint("  Deleted: %08x", sceKernelRegisterExitCallback(cb1));
	
	cb1.Create("count1", &cbFunc, NULL);
	checkpointNext("LoadExecForUser_362A956B:");
	testLoadExec362A956B("  With invalid CB", arg);
	checkpoint("  Register without arg: %08x", sceKernelRegisterExitCallback(cb1));
	testLoadExec362A956B("  Without arg", arg);
	checkpoint("  Register invalid: %08x", sceKernelRegisterExitCallback(0));
	testLoadExec362A956B("  With invalid again", arg);
	checkpoint("  Register valid: %08x", sceKernelRegisterExitCallback(cb2));

	int unknown1s[] = {-1, 0, 1, 2, 3, 4};
	for (size_t i = 0; i < ARRAY_SIZE(unknown1s); ++i) {
		char temp[32];
		snprintf(temp, sizeof(temp), "  arg.unknown1 = %d", unknown1s[i]);
		arg.unknown1 = unknown1s[i];
		params.unk1 = 0x1337;
		params.unk2 = 0x1337;
		testLoadExec362A956B(temp, arg);
	}
	arg.unknown1 = 0;

	int sizes[] = {-1, 0, 1, 2, 3, 4, 11, 12, 13, 16};
	for (size_t i = 0; i < ARRAY_SIZE(sizes); ++i) {
		char temp[32];
		snprintf(temp, sizeof(temp), "  arg.param->size = %d", sizes[i]);
		params.size = sizes[i];
		params.unk1 = 0x1337;
		params.unk2 = 0x1337;
		testLoadExec362A956B(temp, arg);
	}
	params.size = 12;

	cb1.Delete();
	cb2.Delete();
	return 0;
}