The-Homebrew-Cloud/WiiUPluginSystem
2
0
Fork 0
mirror of https://github.com/wiiu-env/WiiUPluginSystem.git synced 2024-09-30 10:08:35 +02:00
Code Issues Packages Projects Releases Wiki Activity

Fix types

Browse Source
This commit is contained in:
Maschell 2018-06-20 16:15:23 +02:00
parent 25c3488c3c
commit 6e6c727b12
51 changed files with 539 additions and 536 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
loader/filelist.sh
View File

@ -40,6 +40,7 @@ cat <<EOF > $outFile
* Any manual modification of this file will be overwriten by the generation. * Any manual modification of this file will be overwriten by the generation.
*****************************************************************************/ *****************************************************************************/
#include <resources/filelist.h> #include <resources/filelist.h>
#include <stdint.h>
EOF EOF
@ -47,8 +48,8 @@ for i in ${files[@]}
do do
filename=${i%.*} filename=${i%.*}
extension=${i##*.} extension=${i##*.}
echo 'extern const u8 '$filename'_'$extension'[];' >> $outFile echo 'extern const uint8_t '$filename'_'$extension'[];' >> $outFile
echo 'extern const u32 '$filename'_'$extension'_size;' >> $outFile echo 'extern const uint32_t '$filename'_'$extension'_size;' >> $outFile
echo '' >> $outFile echo '' >> $outFile
done done

8
loader/src/Application.cpp
View File

@ -60,7 +60,7 @@ Application::~Application() {
DEBUG_FUNCTION_LINE("Destroy controller\n"); DEBUG_FUNCTION_LINE("Destroy controller\n");
for(s32 i = 0; i < 5; i++) for(int32_t i = 0; i < 5; i++)
delete controller[i]; delete controller[i];
//We may have to handle Asyncdelete in the Destructors. //We may have to handle Asyncdelete in the Destructors.
@ -82,7 +82,7 @@ Application::~Application() {
SoundHandler::DestroyInstance(); SoundHandler::DestroyInstance();
} }
s32 Application::exec() { int32_t Application::exec() {
//! start main GX2 thread //! start main GX2 thread
resumeThread(); resumeThread();
//! now wait for thread to finish //! now wait for thread to finish
@ -99,7 +99,7 @@ void Application::fadeOut() {
0, 0, 0, 255 0, 0, 0, 255
}); });
for(s32 i = 0; i < 255; i += 10) { for(int32_t i = 0; i < 255; i += 10) {
if(i > 255) if(i > 255)
i = 255; i = 255;
@ -177,7 +177,7 @@ void Application::executeThread(void) {
DEBUG_FUNCTION_LINE("Entering main loop\n"); DEBUG_FUNCTION_LINE("Entering main loop\n");
while(!exitApplication && !reloadUIflag) { while(!exitApplication && !reloadUIflag) {
//! Read out inputs //! Read out inputs
for(s32 i = 0; i < 5; i++) { for(int32_t i = 0; i < 5; i++) {
if(controller[i]->update(video->getTvWidth(), video->getTvHeight()) == false) if(controller[i]->update(video->getTvWidth(), video->getTvHeight()) == false)
continue; continue;

6
loader/src/Application.h
View File

@ -52,12 +52,12 @@ public:
return bgMusic; return bgMusic;
} }
s32 exec(void); int32_t exec(void);
void fadeOut(void); void fadeOut(void);
void reloadUI(void); void reloadUI(void);
void quit(s32 code) { void quit(int32_t code) {
exitCode = code; exitCode = code;
exitApplication = true; exitApplication = true;
} }
@ -79,7 +79,7 @@ private:
CVideo *video; CVideo *video;
MainWindow *mainWindow; MainWindow *mainWindow;
GuiController *controller[5]; GuiController *controller[5];
s32 exitCode; int32_t exitCode;
}; };
#endif //_APPLICATION_H #endif //_APPLICATION_H

6
loader/src/common/common.h
View File

@ -15,9 +15,9 @@ extern "C" {
#define NAME_PREFIX_SD "sd: " #define NAME_PREFIX_SD "sd: "
#define NAME_PREFIX_USB "usb:" #define NAME_PREFIX_USB "usb:"
#define ELF_DATA_ADDR (*(volatile unsigned int*)(MEM_BASE + 0x1300 + 0x00)) #define ELF_DATA_ADDR (*(volatile uint32_t*)(MEM_BASE + 0x1300 + 0x00))
#define ELF_DATA_SIZE (*(volatile unsigned int*)(MEM_BASE + 0x1300 + 0x04)) #define ELF_DATA_SIZE (*(volatile uint32_t*)(MEM_BASE + 0x1300 + 0x04))
#define MAIN_ENTRY_ADDR (*(volatile unsigned int*)(MEM_BASE + 0x1400 + 0x00)) #define MAIN_ENTRY_ADDR (*(volatile uint32_t*)(MEM_BASE + 0x1400 + 0x00))
#ifndef EXIT_SUCCESS #ifndef EXIT_SUCCESS
#define EXIT_SUCCESS 0 #define EXIT_SUCCESS 0

8
loader/src/common/retain_vars.cpp
View File

@ -3,12 +3,12 @@
replacement_data_t gbl_replacement_data __attribute__((section(".data"))); replacement_data_t gbl_replacement_data __attribute__((section(".data")));
dyn_linking_relocation_data_t gbl_dyn_linking_data __attribute__((section(".data"))); dyn_linking_relocation_data_t gbl_dyn_linking_data __attribute__((section(".data")));
u8 gAppStatus __attribute__((section(".data"))) = 0; uint8_t gAppStatus __attribute__((section(".data"))) = 0;
u64 gGameTitleID __attribute__((section(".data"))) = 0; uint64_t gGameTitleID __attribute__((section(".data"))) = 0;
volatile u8 gSDInitDone __attribute__((section(".data"))) = 0; volatile uint8_t gSDInitDone __attribute__((section(".data"))) = 0;
void * ntfs_mounts __attribute__((section(".data"))) = NULL; void * ntfs_mounts __attribute__((section(".data"))) = NULL;
int ntfs_mount_count __attribute__((section(".data"))) = 0; int32_t ntfs_mount_count __attribute__((section(".data"))) = 0;
struct buffer_store drc_store __attribute__((section(".data"))); struct buffer_store drc_store __attribute__((section(".data")));
struct buffer_store tv_store __attribute__((section(".data"))); struct buffer_store tv_store __attribute__((section(".data")));

8
loader/src/common/retain_vars.h
View File

@ -6,13 +6,13 @@
extern replacement_data_t gbl_replacement_data; extern replacement_data_t gbl_replacement_data;
extern dyn_linking_relocation_data_t gbl_dyn_linking_data; extern dyn_linking_relocation_data_t gbl_dyn_linking_data;
extern u8 gAppStatus; extern uint8_t gAppStatus;
extern u64 gGameTitleID; extern uint64_t gGameTitleID;
extern volatile u8 gSDInitDone; extern volatile uint8_t gSDInitDone;
extern void * ntfs_mounts; extern void * ntfs_mounts;
extern int ntfs_mount_count; extern int32_t ntfs_mount_count;
extern struct buffer_store drc_store; extern struct buffer_store drc_store;
extern struct buffer_store tv_store; extern struct buffer_store tv_store;

2
loader/src/entry.c
View File

@ -1,7 +1,7 @@
#include <string.h> #include <string.h>
#include "main.h" #include "main.h"
int __entry_menu(int argc, char **argv) { int32_t __entry_menu(int32_t argc, char **argv) {
//! ******************************************************************* //! *******************************************************************
//! * Jump to our application * //! * Jump to our application *
//! ******************************************************************* //! *******************************************************************

18
loader/src/main.cpp
View File

@ -62,11 +62,11 @@
static void ApplyPatchesAndCallHookStartingApp(); static void ApplyPatchesAndCallHookStartingApp();
static void RestorePatches(); static void RestorePatches();
s32 isInMiiMakerHBL(); int32_t isInMiiMakerHBL();
void readAndPrintSegmentRegister(CThread *thread, void *arg); void readAndPrintSegmentRegister(CThread *thread, void *arg);
extern "C" int Menu_Main(int argc, char **argv) { extern "C" int32_t Menu_Main(int32_t argc, char **argv) {
if(gAppStatus == 2) { if(gAppStatus == 2) {
//"No, we don't want to patch stuff again."); //"No, we don't want to patch stuff again.");
return EXIT_RELAUNCH_ON_LOAD; return EXIT_RELAUNCH_ON_LOAD;
@ -86,7 +86,7 @@ extern "C" int Menu_Main(int argc, char **argv) {
log_init(); log_init();
DEBUG_FUNCTION_LINE("We have %d kb for plugins.\n",(PLUGIN_LOCATION_END_ADDRESS-getApplicationEndAddr())/1024); DEBUG_FUNCTION_LINE("We have %d kb for plugins.\n",(PLUGIN_LOCATION_END_ADDRESS-getApplicationEndAddr())/1024);
setup_os_exceptions(); //setup_os_exceptions();
DEBUG_FUNCTION_LINE("Wii U Plugin System Loader %s\n",APP_VERSION); DEBUG_FUNCTION_LINE("Wii U Plugin System Loader %s\n",APP_VERSION);
DEBUG_FUNCTION_LINE("Sizeof dyn_linking_relocation_data_t %d\n",sizeof(dyn_linking_relocation_data_t)); DEBUG_FUNCTION_LINE("Sizeof dyn_linking_relocation_data_t %d\n",sizeof(dyn_linking_relocation_data_t));
@ -97,7 +97,7 @@ extern "C" int Menu_Main(int argc, char **argv) {
gGameTitleID = OSGetTitleID(); gGameTitleID = OSGetTitleID();
s32 result = 0; int32_t result = 0;
//Reset everything when were going back to the Mii Maker //Reset everything when were going back to the Mii Maker
if(isInMiiMakerHBL()) { if(isInMiiMakerHBL()) {
@ -191,7 +191,7 @@ extern "C" int Menu_Main(int argc, char **argv) {
void ApplyPatchesAndCallHookStartingApp() { void ApplyPatchesAndCallHookStartingApp() {
PatchInvidualMethodHooks(method_hooks_hooks, method_hooks_size_hooks, method_calls_hooks); PatchInvidualMethodHooks(method_hooks_hooks, method_hooks_size_hooks, method_calls_hooks);
for(int plugin_index=0; plugin_index<gbl_replacement_data.number_used_plugins; plugin_index++) { for(int32_t plugin_index=0; plugin_index<gbl_replacement_data.number_used_plugins; plugin_index++) {
CallHookEx(WUPS_LOADER_HOOK_STARTING_APPLICATION,plugin_index); CallHookEx(WUPS_LOADER_HOOK_STARTING_APPLICATION,plugin_index);
new_PatchInvidualMethodHooks(&gbl_replacement_data.plugin_data[plugin_index]); new_PatchInvidualMethodHooks(&gbl_replacement_data.plugin_data[plugin_index]);
CallHookEx(WUPS_LOADER_HOOK_FUNCTIONS_PATCHED,plugin_index); CallHookEx(WUPS_LOADER_HOOK_FUNCTIONS_PATCHED,plugin_index);
@ -203,14 +203,14 @@ void DeInit() {
} }
void RestorePatches() { void RestorePatches() {
for(int plugin_index=gbl_replacement_data.number_used_plugins-1; plugin_index>=0; plugin_index--) { for(int32_t plugin_index=gbl_replacement_data.number_used_plugins-1; plugin_index>=0; plugin_index--) {
DEBUG_FUNCTION_LINE("Restoring function for plugin: %d\n",plugin_index); DEBUG_FUNCTION_LINE("Restoring function for plugin: %d\n",plugin_index);
new_RestoreInvidualInstructions(&gbl_replacement_data.plugin_data[plugin_index]); new_RestoreInvidualInstructions(&gbl_replacement_data.plugin_data[plugin_index]);
} }
RestoreInvidualInstructions(method_hooks_hooks, method_hooks_size_hooks); RestoreInvidualInstructions(method_hooks_hooks, method_hooks_size_hooks);
} }
s32 isInMiiMakerHBL() { int32_t isInMiiMakerHBL() {
if (OSGetTitleID != 0 && ( if (OSGetTitleID != 0 && (
OSGetTitleID() == 0x000500101004A200 || // mii maker eur OSGetTitleID() == 0x000500101004A200 || // mii maker eur
OSGetTitleID() == 0x000500101004A100 || // mii maker usa OSGetTitleID() == 0x000500101004A100 || // mii maker usa
@ -229,7 +229,7 @@ void Init() {
} }
void Init_SD_USB() { void Init_SD_USB() {
int res = IOSUHAX_Open(NULL); int32_t res = IOSUHAX_Open(NULL);
if(res < 0) { if(res < 0) {
ExecuteIOSExploitWithDefaultConfig(); ExecuteIOSExploitWithDefaultConfig();
} }
@ -248,7 +248,7 @@ void Init_SD_USB() {
} else { } else {
DEBUG_FUNCTION_LINE("Using IOSUHAX for SD/USB access\n"); DEBUG_FUNCTION_LINE("Using IOSUHAX for SD/USB access\n");
gSDInitDone |= WUPS_SDUSB_LIBIOSU_LOADED; gSDInitDone |= WUPS_SDUSB_LIBIOSU_LOADED;
int ntfs_mounts = mountAllNTFS(); int32_t ntfs_mounts = mountAllNTFS();
if(ntfs_mounts > 0) { if(ntfs_mounts > 0) {
gSDInitDone |= WUPS_USB_MOUNTED_LIBNTFS; gSDInitDone |= WUPS_USB_MOUNTED_LIBNTFS;
} }

2
loader/src/main.h
View File

@ -29,7 +29,7 @@ extern "C" {
#include <libelf.h> #include <libelf.h>
//! C wrapper for our C++ functions //! C wrapper for our C++ functions
int Menu_Main(int argc, char **argv); int32_t Menu_Main(int32_t argc, char **argv);
void Init_SD_USB(); void Init_SD_USB();

90
loader/src/menu/MainWindow.cpp
View File

@ -27,10 +27,10 @@
MainWindow * MainWindow::instance = NULL; MainWindow * MainWindow::instance = NULL;
MainWindow::MainWindow(s32 w, s32 h) MainWindow::MainWindow(int32_t w, int32_t h)
: width(w) : width(w)
, height(h) { , height(h) {
for(s32 i = 0; i < 4; i++) { for(int32_t i = 0; i < 4; i++) {
std::string filename = StringTools::strfmt("player%i_point.png", i+1); std::string filename = StringTools::strfmt("player%i_point.png", i+1);
pointerImgData[i] = Resources::GetImageData(filename.c_str()); pointerImgData[i] = Resources::GetImageData(filename.c_str());
pointerImg[i] = new GuiImage(pointerImgData[i]); pointerImg[i] = new GuiImage(pointerImgData[i]);
@ -51,7 +51,7 @@ MainWindow::~MainWindow() {
delete drcElements[0]; delete drcElements[0];
remove(drcElements[0]); remove(drcElements[0]);
} }
for(s32 i = 0; i < 4; i++) { for(int32_t i = 0; i < 4; i++) {
delete pointerImg[i]; delete pointerImg[i];
Resources::RemoveImageData(pointerImgData[i]); Resources::RemoveImageData(pointerImgData[i]);
} }
@ -59,16 +59,16 @@ MainWindow::~MainWindow() {
void MainWindow::updateEffects() { void MainWindow::updateEffects() {
//! dont read behind the initial elements in case one was added //! dont read behind the initial elements in case one was added
u32 tvSize = tvElements.size(); uint32_t tvSize = tvElements.size();
u32 drcSize = drcElements.size(); uint32_t drcSize = drcElements.size();
for(u32 i = 0; (i < drcSize) && (i < drcElements.size()); ++i) { for(uint32_t i = 0; (i < drcSize) && (i < drcElements.size()); ++i) {
drcElements[i]->updateEffects(); drcElements[i]->updateEffects();
} }
//! only update TV elements that are not updated yet because they are on DRC //! only update TV elements that are not updated yet because they are on DRC
for(u32 i = 0; (i < tvSize) && (i < tvElements.size()); ++i) { for(uint32_t i = 0; (i < tvSize) && (i < tvElements.size()); ++i) {
u32 n; uint32_t n;
for(n = 0; (n < drcSize) && (n < drcElements.size()); n++) { for(n = 0; (n < drcSize) && (n < drcElements.size()); n++) {
if(tvElements[i] == drcElements[n]) if(tvElements[i] == drcElements[n])
break; break;
@ -81,16 +81,16 @@ void MainWindow::updateEffects() {
void MainWindow::process() { void MainWindow::process() {
//! dont read behind the initial elements in case one was added //! dont read behind the initial elements in case one was added
u32 tvSize = tvElements.size(); uint32_t tvSize = tvElements.size();
u32 drcSize = drcElements.size(); uint32_t drcSize = drcElements.size();
for(u32 i = 0; (i < drcSize) && (i < drcElements.size()); ++i) { for(uint32_t i = 0; (i < drcSize) && (i < drcElements.size()); ++i) {
drcElements[i]->process(); drcElements[i]->process();
} }
//! only update TV elements that are not updated yet because they are on DRC //! only update TV elements that are not updated yet because they are on DRC
for(u32 i = 0; (i < tvSize) && (i < tvElements.size()); ++i) { for(uint32_t i = 0; (i < tvSize) && (i < tvElements.size()); ++i) {
u32 n; uint32_t n;
for(n = 0; (n < drcSize) && (n < drcElements.size()); n++) { for(n = 0; (n < drcSize) && (n < drcElements.size()); n++) {
if(tvElements[i] == drcElements[n]) if(tvElements[i] == drcElements[n])
break; break;
@ -103,26 +103,26 @@ void MainWindow::process() {
void MainWindow::update(GuiController *controller) { void MainWindow::update(GuiController *controller) {
//! dont read behind the initial elements in case one was added //! dont read behind the initial elements in case one was added
//u32 tvSize = tvElements.size(); //uint32_t tvSize = tvElements.size();
if(controller->chan & GuiTrigger::CHANNEL_1) { if(controller->chan & GuiTrigger::CHANNEL_1) {
u32 drcSize = drcElements.size(); uint32_t drcSize = drcElements.size();
for(u32 i = 0; (i < drcSize) && (i < drcElements.size()); ++i) { for(uint32_t i = 0; (i < drcSize) && (i < drcElements.size()); ++i) {
drcElements[i]->update(controller); drcElements[i]->update(controller);
} }
} else { } else {
u32 tvSize = tvElements.size(); uint32_t tvSize = tvElements.size();
for(u32 i = 0; (i < tvSize) && (i < tvElements.size()); ++i) { for(uint32_t i = 0; (i < tvSize) && (i < tvElements.size()); ++i) {
tvElements[i]->update(controller); tvElements[i]->update(controller);
} }
} }
// //! only update TV elements that are not updated yet because they are on DRC // //! only update TV elements that are not updated yet because they are on DRC
// for(u32 i = 0; (i < tvSize) && (i < tvElements.size()); ++i) // for(uint32_t i = 0; (i < tvSize) && (i < tvElements.size()); ++i)
// { // {
// u32 n; // uint32_t n;
// for(n = 0; (n < drcSize) && (n < drcElements.size()); n++) // for(n = 0; (n < drcSize) && (n < drcElements.size()); n++)
// { // {
// if(tvElements[i] == drcElements[n]) // if(tvElements[i] == drcElements[n])
@ -135,9 +135,9 @@ void MainWindow::update(GuiController *controller) {
// } // }
if(controller->chanIdx >= 1 && controller->chanIdx <= 4 && controller->data.validPointer) { if(controller->chanIdx >= 1 && controller->chanIdx <= 4 && controller->data.validPointer) {
s32 wpadIdx = controller->chanIdx - 1; int32_t wpadIdx = controller->chanIdx - 1;
f32 posX = controller->data.x; float posX = controller->data.x;
f32 posY = controller->data.y; float posY = controller->data.y;
pointerImg[wpadIdx]->setPosition(posX, posY); pointerImg[wpadIdx]->setPosition(posX, posY);
pointerImg[wpadIdx]->setAngle(controller->data.pointerAngle); pointerImg[wpadIdx]->setAngle(controller->data.pointerAngle);
pointerValid[wpadIdx] = true; pointerValid[wpadIdx] = true;
@ -145,11 +145,11 @@ void MainWindow::update(GuiController *controller) {
} }
void MainWindow::drawDrc(CVideo *video) { void MainWindow::drawDrc(CVideo *video) {
for(u32 i = 0; i < drcElements.size(); ++i) { for(uint32_t i = 0; i < drcElements.size(); ++i) {
drcElements[i]->draw(video); drcElements[i]->draw(video);
} }
for(s32 i = 0; i < 4; i++) { for(int32_t i = 0; i < 4; i++) {
if(pointerValid[i]) { if(pointerValid[i]) {
pointerImg[i]->setAlpha(0.5f); pointerImg[i]->setAlpha(0.5f);
pointerImg[i]->draw(video); pointerImg[i]->draw(video);
@ -159,11 +159,11 @@ void MainWindow::drawDrc(CVideo *video) {
} }
void MainWindow::drawTv(CVideo *video) { void MainWindow::drawTv(CVideo *video) {
for(u32 i = 0; i < tvElements.size(); ++i) { for(uint32_t i = 0; i < tvElements.size(); ++i) {
tvElements[i]->draw(video); tvElements[i]->draw(video);
} }
for(s32 i = 0; i < 4; i++) { for(int32_t i = 0; i < 4; i++) {
if(pointerValid[i]) { if(pointerValid[i]) {
pointerImg[i]->draw(video); pointerImg[i]->draw(video);
pointerValid[i] = false; pointerValid[i] = false;
@ -185,16 +185,16 @@ void MainWindow::OnOpenEffectFinish(GuiElement *element) {
} }
void MainWindow::appendToAllElements(GuiElement * element) { void MainWindow::appendToAllElements(GuiElement * element) {
u32 drcSize = drcElements.size(); uint32_t drcSize = drcElements.size();
for(u32 i = 0; (i < drcSize) && (i < drcElements.size()); ++i) { for(uint32_t i = 0; (i < drcSize) && (i < drcElements.size()); ++i) {
GuiFrame * realElement = dynamic_cast<GuiFrame*>(drcElements[i]); GuiFrame * realElement = dynamic_cast<GuiFrame*>(drcElements[i]);
if(realElement != NULL) { if(realElement != NULL) {
realElement->append(element); realElement->append(element);
} }
} }
u32 tvSize = tvElements.size(); uint32_t tvSize = tvElements.size();
for(u32 i = 0; (i < tvSize) && (i < tvElements.size()); ++i) { for(uint32_t i = 0; (i < tvSize) && (i < tvElements.size()); ++i) {
GuiFrame * realElement = dynamic_cast<GuiFrame*>(tvElements[i]); GuiFrame * realElement = dynamic_cast<GuiFrame*>(tvElements[i]);
if(realElement != NULL) { if(realElement != NULL) {
realElement->append(element); realElement->append(element);
@ -203,16 +203,16 @@ void MainWindow::appendToAllElements(GuiElement * element) {
} }
void MainWindow::removeFromAllElements(GuiElement * element) { void MainWindow::removeFromAllElements(GuiElement * element) {
u32 drcSize = drcElements.size(); uint32_t drcSize = drcElements.size();
for(u32 i = 0; (i < drcSize) && (i < drcElements.size()); ++i) { for(uint32_t i = 0; (i < drcSize) && (i < drcElements.size()); ++i) {
GuiFrame * realElement = dynamic_cast<GuiFrame*>(drcElements[i]); GuiFrame * realElement = dynamic_cast<GuiFrame*>(drcElements[i]);
if(realElement != NULL) { if(realElement != NULL) {
realElement->remove(element); realElement->remove(element);
} }
} }
u32 tvSize = tvElements.size(); uint32_t tvSize = tvElements.size();
for(u32 i = 0; (i < tvSize) && (i < tvElements.size()); ++i) { for(uint32_t i = 0; (i < tvSize) && (i < tvElements.size()); ++i) {
GuiFrame * realElement = dynamic_cast<GuiFrame*>(tvElements[i]); GuiFrame * realElement = dynamic_cast<GuiFrame*>(tvElements[i]);
if(realElement != NULL) { if(realElement != NULL) {
realElement->remove(element); realElement->remove(element);
@ -221,26 +221,26 @@ void MainWindow::removeFromAllElements(GuiElement * element) {
} }
void MainWindow::setState(s32 val, s32 c) { void MainWindow::setState(int32_t val, int32_t c) {
u32 drcSize = drcElements.size(); uint32_t drcSize = drcElements.size();
for(u32 i = 0; (i < drcSize) && (i < drcElements.size()); ++i) { for(uint32_t i = 0; (i < drcSize) && (i < drcElements.size()); ++i) {
drcElements[i]->setState(val,c); drcElements[i]->setState(val,c);
} }
u32 tvSize = tvElements.size(); uint32_t tvSize = tvElements.size();
for(u32 i = 0; (i < tvSize) && (i < tvElements.size()); ++i) { for(uint32_t i = 0; (i < tvSize) && (i < tvElements.size()); ++i) {
tvElements[i]->setState(val,c); tvElements[i]->setState(val,c);
} }
} }
void MainWindow::clearState(s32 val, s32 c) { void MainWindow::clearState(int32_t val, int32_t c) {
u32 drcSize = drcElements.size(); uint32_t drcSize = drcElements.size();
for(u32 i = 0; (i < drcSize) && (i < drcElements.size()); ++i) { for(uint32_t i = 0; (i < drcSize) && (i < drcElements.size()); ++i) {
drcElements[i]->clearState(val,c); drcElements[i]->clearState(val,c);
} }
u32 tvSize = tvElements.size(); uint32_t tvSize = tvElements.size();
for(u32 i = 0; (i < tvSize) && (i < tvElements.size()); ++i) { for(uint32_t i = 0; (i < tvSize) && (i < tvElements.size()); ++i) {
tvElements[i]->clearState(val,c); tvElements[i]->clearState(val,c);
} }
} }

20
loader/src/menu/MainWindow.h
View File

@ -30,7 +30,7 @@ public:
static MainWindow *instance; static MainWindow *instance;
static MainWindow *getInstance(s32 w,s32 h) { static MainWindow *getInstance(int32_t w,int32_t h) {
if(!instance) { if(!instance) {
instance = new MainWindow(w, h); instance = new MainWindow(w, h);
} }
@ -68,14 +68,14 @@ public:
appendDrc(e); appendDrc(e);
} }
void insertTv(u32 pos, GuiElement *e) { void insertTv(uint32_t pos, GuiElement *e) {
if(!e) if(!e)
return; return;
removeTv(e); removeTv(e);
tvElements.insert(tvElements.begin() + pos, e); tvElements.insert(tvElements.begin() + pos, e);
} }
void insertDrc(u32 pos, GuiElement *e) { void insertDrc(uint32_t pos, GuiElement *e) {
if(!e) if(!e)
return; return;
@ -83,13 +83,13 @@ public:
drcElements.insert(drcElements.begin() + pos, e); drcElements.insert(drcElements.begin() + pos, e);
} }
void insert(u32 pos, GuiElement *e) { void insert(uint32_t pos, GuiElement *e) {
insertTv(pos, e); insertTv(pos, e);
insertDrc(pos, e); insertDrc(pos, e);
} }
void removeTv(GuiElement *e) { void removeTv(GuiElement *e) {
for(u32 i = 0; i < tvElements.size(); ++i) { for(uint32_t i = 0; i < tvElements.size(); ++i) {
if(e == tvElements[i]) { if(e == tvElements[i]) {
tvElements.erase(tvElements.begin() + i); tvElements.erase(tvElements.begin() + i);
break; break;
@ -97,7 +97,7 @@ public:
} }
} }
void removeDrc(GuiElement *e) { void removeDrc(GuiElement *e) {
for(u32 i = 0; i < drcElements.size(); ++i) { for(uint32_t i = 0; i < drcElements.size(); ++i) {
if(e == drcElements[i]) { if(e == drcElements[i]) {
drcElements.erase(drcElements.begin() + i); drcElements.erase(drcElements.begin() + i);
break; break;
@ -122,8 +122,8 @@ public:
void appendToAllElements(GuiElement * element); void appendToAllElements(GuiElement * element);
void removeFromAllElements(GuiElement * element); void removeFromAllElements(GuiElement * element);
void setState(s32 i, s32 c = -1 ); void setState(int32_t i, int32_t c = -1 );
void clearState(s32 i, s32 c = -1); void clearState(int32_t i, int32_t c = -1);
void lockGUI() { void lockGUI() {
guiMutex.lock(); guiMutex.lock();
@ -133,13 +133,13 @@ public:
} }
private: private:
MainWindow(s32 w, s32 h); MainWindow(int32_t w, int32_t h);
void SetupMainView(void); void SetupMainView(void);
void OnOpenEffectFinish(GuiElement *element); void OnOpenEffectFinish(GuiElement *element);
void OnCloseEffectFinish(GuiElement *element); void OnCloseEffectFinish(GuiElement *element);
s32 width, height; int32_t width, height;
std::vector<GuiElement *> drcElements; std::vector<GuiElement *> drcElements;
std::vector<GuiElement *> tvElements; std::vector<GuiElement *> tvElements;

2
loader/src/menu/MainWindowContent.cpp
View File

@ -16,7 +16,7 @@
****************************************************************************/ ****************************************************************************/
#include "MainWindowContent.h" #include "MainWindowContent.h"
MainWindowContent::MainWindowContent(s32 w, s32 h) MainWindowContent::MainWindowContent(int32_t w, int32_t h)
: GuiFrame(w, h) : GuiFrame(w, h)
, width(w) , width(w)
, height(h) , height(h)

4
loader/src/menu/MainWindowContent.h
View File

@ -31,7 +31,7 @@ public:
CONTENT_HOME, CONTENT_HOME,
}; };
MainWindowContent(s32 w, s32 h); MainWindowContent(int32_t w, int32_t h);
virtual ~MainWindowContent(); virtual ~MainWindowContent();
void SetScreen(ContentTemplate * new_content); void SetScreen(ContentTemplate * new_content);
@ -51,7 +51,7 @@ public:
} }
private: private:
s32 width, height; int32_t width, height;
GuiImage bgImageColor; GuiImage bgImageColor;
ContentTemplate * content = NULL; ContentTemplate * content = NULL;

4
loader/src/menu/MainWindowGUI.cpp
View File

@ -17,7 +17,7 @@
#include "MainWindowGUI.h" #include "MainWindowGUI.h"
#include "MenuCommon.h" #include "MenuCommon.h"
MainWindowGUI::MainWindowGUI(s32 w, s32 h) MainWindowGUI::MainWindowGUI(int32_t w, int32_t h)
: GuiFrame(w, h) : GuiFrame(w, h)
, width(w) , width(w)
, height(h) , height(h)
@ -27,7 +27,7 @@ MainWindowGUI::MainWindowGUI(s32 w, s32 h)
append(&content); append(&content);
} }
void MainWindowGUI::setState(s32 i, s32 c) { void MainWindowGUI::setState(int32_t i, int32_t c) {
GuiFrame::setState(i,c); GuiFrame::setState(i,c);
} }

6
loader/src/menu/MainWindowGUI.h
View File

@ -25,13 +25,13 @@
class MainWindowGUI : public GuiFrame, public sigslot::has_slots<> { class MainWindowGUI : public GuiFrame, public sigslot::has_slots<> {
public: public:
MainWindowGUI(s32 w, s32 h); MainWindowGUI(int32_t w, int32_t h);
virtual ~MainWindowGUI(); virtual ~MainWindowGUI();
private: private:
s32 width, height; int32_t width, height;
MainWindowContent content; MainWindowContent content;
void setState(s32 i, s32 c); void setState(int32_t i, int32_t c);
void process(); void process();
}; };

8
loader/src/mykernel/kernel_defs.h
View File

@ -10,14 +10,14 @@ extern "C" {
typedef struct _sr_table_t typedef struct _sr_table_t
{ {
u32 value[16]; uint32_t value[16];
u32 sdr1; uint32_t sdr1;
} sr_table_t; } sr_table_t;
typedef struct _bat_t typedef struct _bat_t
{ {
u32 h; uint32_t h;
u32 l; uint32_t l;
} bat_t; } bat_t;
typedef struct _bat_table_t typedef struct _bat_table_t

93
loader/src/mykernel/kernel_utils.c
View File

@ -4,7 +4,7 @@
#include <kernel/syscalls.h> #include <kernel/syscalls.h>
static void KernelReadSRs(sr_table_t * table) { static void KernelReadSRs(sr_table_t * table) {
u32 i = 0; uint32_t i = 0;
// calculate PT_size ((end-start)*8/4096)*4 or (end-start)/128 // calculate PT_size ((end-start)*8/4096)*4 or (end-start)/128
// Minimum page table size is 64Kbytes. // Minimum page table size is 64Kbytes.
@ -50,7 +50,7 @@ static void KernelReadSRs(sr_table_t * table) {
} }
static void KernelWriteSRs(sr_table_t * table) { static void KernelWriteSRs(sr_table_t * table) {
u32 i = 0; uint32_t i = 0;
asm volatile("eieio; isync"); asm volatile("eieio; isync");
@ -79,17 +79,17 @@ static void KernelWriteSRs(sr_table_t * table) {
asm volatile("isync"); asm volatile("isync");
} }
void KernelReadPTE(u32* dest, u32 size) { void KernelReadPTE(uint32_t* dest, uint32_t size) {
u32 msr = 0; uint32_t msr = 0;
u32 oldmsr = 0; uint32_t oldmsr = 0;
//TODO: Calculate from SDR1 //TODO: Calculate from SDR1
u32 addr_base = 0xFFE20000; uint32_t addr_base = 0xFFE20000;
asm volatile("mfmsr %0" : "=r" (msr)); asm volatile("mfmsr %0" : "=r" (msr));
oldmsr = msr; oldmsr = msr;
msr &= ~0x10; msr &= ~0x10;
for(int i = 0;i<size/0x04;i++){ for(uint32_t i = 0;i<size/0x04;i++){
u32 value_read = 0; uint32_t value_read = 0;
u32 addr = addr_base + (i*4); uint32_t addr = addr_base + (i*4);
// Disable Data address translation // Disable Data address translation
asm volatile("mtmsr %0" : : "r" (msr)); asm volatile("mtmsr %0" : : "r" (msr));
__asm __volatile("lwz %0,0(%1)" : "=r"(value_read) : "r"(addr)); __asm __volatile("lwz %0,0(%1)" : "=r"(value_read) : "r"(addr));
@ -99,17 +99,17 @@ void KernelReadPTE(u32* dest, u32 size) {
} }
} }
void KernelWritePTE(u32 * in_addr, u32 size) { void KernelWritePTE(uint32_t * in_addr, uint32_t size) {
u32 msr = 0; uint32_t msr = 0;
u32 oldmsr = 0; uint32_t oldmsr = 0;
//TODO: Calculate from SDR1 //TODO: Calculate from SDR1
u32 addr_base = 0xFFE20000; uint32_t addr_base = 0xFFE20000;
asm volatile("mfmsr %0" : "=r" (msr)); asm volatile("mfmsr %0" : "=r" (msr));
oldmsr = msr; oldmsr = msr;
msr &= ~0x10; msr &= ~0x10;
for(int i = 0;i<size/0x04;i++){ for(uint32_t i = 0;i<size/0x04;i++){
u32 addr = addr_base + (i*4); uint32_t addr = addr_base + (i*4);
u32 value = in_addr[i]; uint32_t value = in_addr[i];
// Disable Data address translation // Disable Data address translation
asm volatile("mtmsr %0" : : "r" (msr)); asm volatile("mtmsr %0" : : "r" (msr));
__asm __volatile("stw %0,0(%1)" : : "r"(value),"r"(addr)); __asm __volatile("stw %0,0(%1)" : : "r"(value),"r"(addr));
@ -118,11 +118,11 @@ void KernelWritePTE(u32 * in_addr, u32 size) {
} }
} }
void KernelWriteWitoutDAT(u32 addr, u32 value) { void KernelWriteWitoutDAT(uint32_t addr, uint32_t value) {
u32 msr = 0; uint32_t msr = 0;
u32 oldmsr = 0; uint32_t oldmsr = 0;
//TODO: Calculate from SDR1 //TODO: Calculate from SDR1
u32 addr_base = 0xFFE20000; //uint32_t addr_base = 0xFFE20000;
asm volatile("mfmsr %0" : "=r" (msr)); asm volatile("mfmsr %0" : "=r" (msr));
oldmsr = msr; oldmsr = msr;
msr &= ~0x10; msr &= ~0x10;
@ -133,7 +133,7 @@ void KernelWriteWitoutDAT(u32 addr, u32 value) {
asm volatile("mtmsr %0" : : "r" (oldmsr)); asm volatile("mtmsr %0" : : "r" (oldmsr));
} }
void SC0x0A_KernelWriteWitoutDAT(u32 addr,u32 value); void SC0x0A_KernelWriteWitoutDAT(uint32_t addr,uint32_t value);
void wups_init_kernel_syscalls(){ void wups_init_kernel_syscalls(){
//! assign 1 so that this variable gets into the retained .data section //! assign 1 so that this variable gets into the retained .data section
@ -143,39 +143,38 @@ void wups_init_kernel_syscalls(){
ucSyscallsSetupRequired = 0; ucSyscallsSetupRequired = 0;
kern_write((void*)(OS_SPECIFICS->addr_KernSyscallTbl1 + (0x0A * 4)), (uint32_t)KernelWriteWitoutDAT);
kern_write((void*)(OS_SPECIFICS->addr_KernSyscallTbl1 + (0x0A * 4)), (unsigned int)KernelWriteWitoutDAT); kern_write((void*)(OS_SPECIFICS->addr_KernSyscallTbl2 + (0x0A * 4)), (uint32_t)KernelWriteWitoutDAT);
kern_write((void*)(OS_SPECIFICS->addr_KernSyscallTbl2 + (0x0A * 4)), (unsigned int)KernelWriteWitoutDAT); kern_write((void*)(OS_SPECIFICS->addr_KernSyscallTbl3 + (0x0A * 4)), (uint32_t)KernelWriteWitoutDAT);
kern_write((void*)(OS_SPECIFICS->addr_KernSyscallTbl3 + (0x0A * 4)), (unsigned int)KernelWriteWitoutDAT); kern_write((void*)(OS_SPECIFICS->addr_KernSyscallTbl4 + (0x0A * 4)), (uint32_t)KernelWriteWitoutDAT);
kern_write((void*)(OS_SPECIFICS->addr_KernSyscallTbl4 + (0x0A * 4)), (unsigned int)KernelWriteWitoutDAT); kern_write((void*)(OS_SPECIFICS->addr_KernSyscallTbl5 + (0x0A * 4)), (uint32_t)KernelWriteWitoutDAT);
kern_write((void*)(OS_SPECIFICS->addr_KernSyscallTbl5 + (0x0A * 4)), (unsigned int)KernelWriteWitoutDAT);
// Override all writes to SR8 with nops. // Override all writes to SR8 with nops.
SC0x0A_KernelWriteWitoutDAT(0xFFF1D754,0x60000000); SC0x0A_KernelWriteWitoutDAT(0xFFF1D754,0x60000000);
SC0x0A_KernelWriteWitoutDAT(0xFFF1D64C,0x60000000); SC0x0A_KernelWriteWitoutDAT(0xFFF1D64C,0x60000000);
SC0x0A_KernelWriteWitoutDAT(0xFFE00638,0x60000000); SC0x0A_KernelWriteWitoutDAT(0xFFE00638,0x60000000);
kern_write((void*)(OS_SPECIFICS->addr_KernSyscallTbl1 + (0x36 * 4)), (unsigned int)KernelReadSRs); kern_write((void*)(OS_SPECIFICS->addr_KernSyscallTbl1 + (0x36 * 4)), (uint32_t)KernelReadSRs);
kern_write((void*)(OS_SPECIFICS->addr_KernSyscallTbl2 + (0x36 * 4)), (unsigned int)KernelReadSRs); kern_write((void*)(OS_SPECIFICS->addr_KernSyscallTbl2 + (0x36 * 4)), (uint32_t)KernelReadSRs);
kern_write((void*)(OS_SPECIFICS->addr_KernSyscallTbl3 + (0x36 * 4)), (unsigned int)KernelReadSRs); kern_write((void*)(OS_SPECIFICS->addr_KernSyscallTbl3 + (0x36 * 4)), (uint32_t)KernelReadSRs);
kern_write((void*)(OS_SPECIFICS->addr_KernSyscallTbl4 + (0x36 * 4)), (unsigned int)KernelReadSRs); kern_write((void*)(OS_SPECIFICS->addr_KernSyscallTbl4 + (0x36 * 4)), (uint32_t)KernelReadSRs);
kern_write((void*)(OS_SPECIFICS->addr_KernSyscallTbl5 + (0x36 * 4)), (unsigned int)KernelReadSRs); kern_write((void*)(OS_SPECIFICS->addr_KernSyscallTbl5 + (0x36 * 4)), (uint32_t)KernelReadSRs);
kern_write((void*)(OS_SPECIFICS->addr_KernSyscallTbl1 + (0x37 * 4)), (unsigned int)KernelReadPTE); kern_write((void*)(OS_SPECIFICS->addr_KernSyscallTbl1 + (0x37 * 4)), (uint32_t)KernelReadPTE);
kern_write((void*)(OS_SPECIFICS->addr_KernSyscallTbl2 + (0x37 * 4)), (unsigned int)KernelReadPTE); kern_write((void*)(OS_SPECIFICS->addr_KernSyscallTbl2 + (0x37 * 4)), (uint32_t)KernelReadPTE);
kern_write((void*)(OS_SPECIFICS->addr_KernSyscallTbl3 + (0x37 * 4)), (unsigned int)KernelReadPTE); kern_write((void*)(OS_SPECIFICS->addr_KernSyscallTbl3 + (0x37 * 4)), (uint32_t)KernelReadPTE);
kern_write((void*)(OS_SPECIFICS->addr_KernSyscallTbl4 + (0x37 * 4)), (unsigned int)KernelReadPTE); kern_write((void*)(OS_SPECIFICS->addr_KernSyscallTbl4 + (0x37 * 4)), (uint32_t)KernelReadPTE);
kern_write((void*)(OS_SPECIFICS->addr_KernSyscallTbl5 + (0x37 * 4)), (unsigned int)KernelReadPTE); kern_write((void*)(OS_SPECIFICS->addr_KernSyscallTbl5 + (0x37 * 4)), (uint32_t)KernelReadPTE);
kern_write((void*)(OS_SPECIFICS->addr_KernSyscallTbl1 + (0x09 * 4)), (unsigned int)KernelWritePTE); kern_write((void*)(OS_SPECIFICS->addr_KernSyscallTbl1 + (0x09 * 4)), (uint32_t)KernelWritePTE);
kern_write((void*)(OS_SPECIFICS->addr_KernSyscallTbl2 + (0x09 * 4)), (unsigned int)KernelWritePTE); kern_write((void*)(OS_SPECIFICS->addr_KernSyscallTbl2 + (0x09 * 4)), (uint32_t)KernelWritePTE);
kern_write((void*)(OS_SPECIFICS->addr_KernSyscallTbl3 + (0x09 * 4)), (unsigned int)KernelWritePTE); kern_write((void*)(OS_SPECIFICS->addr_KernSyscallTbl3 + (0x09 * 4)), (uint32_t)KernelWritePTE);
kern_write((void*)(OS_SPECIFICS->addr_KernSyscallTbl4 + (0x09 * 4)), (unsigned int)KernelWritePTE); kern_write((void*)(OS_SPECIFICS->addr_KernSyscallTbl4 + (0x09 * 4)), (uint32_t)KernelWritePTE);
kern_write((void*)(OS_SPECIFICS->addr_KernSyscallTbl5 + (0x09 * 4)), (unsigned int)KernelWritePTE); kern_write((void*)(OS_SPECIFICS->addr_KernSyscallTbl5 + (0x09 * 4)), (uint32_t)KernelWritePTE);
kern_write((void*)(OS_SPECIFICS->addr_KernSyscallTbl1 + (0x0A * 4)), (unsigned int)KernelWriteSRs); kern_write((void*)(OS_SPECIFICS->addr_KernSyscallTbl1 + (0x0A * 4)), (uint32_t)KernelWriteSRs);
kern_write((void*)(OS_SPECIFICS->addr_KernSyscallTbl2 + (0x0A * 4)), (unsigned int)KernelWriteSRs); kern_write((void*)(OS_SPECIFICS->addr_KernSyscallTbl2 + (0x0A * 4)), (uint32_t)KernelWriteSRs);
kern_write((void*)(OS_SPECIFICS->addr_KernSyscallTbl3 + (0x0A * 4)), (unsigned int)KernelWriteSRs); kern_write((void*)(OS_SPECIFICS->addr_KernSyscallTbl3 + (0x0A * 4)), (uint32_t)KernelWriteSRs);
kern_write((void*)(OS_SPECIFICS->addr_KernSyscallTbl4 + (0x0A * 4)), (unsigned int)KernelWriteSRs); kern_write((void*)(OS_SPECIFICS->addr_KernSyscallTbl4 + (0x0A * 4)), (uint32_t)KernelWriteSRs);
kern_write((void*)(OS_SPECIFICS->addr_KernSyscallTbl5 + (0x0A * 4)), (unsigned int)KernelWriteSRs); kern_write((void*)(OS_SPECIFICS->addr_KernSyscallTbl5 + (0x0A * 4)), (uint32_t)KernelWriteSRs);
} }

4
loader/src/mykernel/syscalls.h
View File

@ -9,8 +9,8 @@ extern "C" {
void SC0x0A_KernelWriteSRs(sr_table_t * table); void SC0x0A_KernelWriteSRs(sr_table_t * table);
void SC0x36_KernelReadSRs(sr_table_t * table); void SC0x36_KernelReadSRs(sr_table_t * table);
void SC0x37_KernelReadPTE(u32* dest, u32 size); void SC0x37_KernelReadPTE(uint32_t* dest, uint32_t size);
void SC0x09_KernelWritePTE(u32* addr,u32 size); void SC0x09_KernelWritePTE(uint32_t* addr,uint32_t size);
void KernelTest(); void KernelTest();
#ifdef __cplusplus #ifdef __cplusplus

234
loader/src/mymemory/memory_mapping.cpp
View File

@ -11,10 +11,10 @@
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
void runOnAllCores(CThread::Callback callback, void *callbackArg, s32 iAttr = 0, s32 iPriority = 16, s32 iStackSize = 0x8000) { void runOnAllCores(CThread::Callback callback, void *callbackArg, int32_t iAttr = 0, int32_t iPriority = 16, int32_t iStackSize = 0x8000) {
int aff[] = {CThread::eAttributeAffCore2,CThread::eAttributeAffCore1,CThread::eAttributeAffCore0}; int32_t aff[] = {CThread::eAttributeAffCore2,CThread::eAttributeAffCore1,CThread::eAttributeAffCore0};
for(u32 i = 0; i <(sizeof(aff)/sizeof(aff[0])); i++) { for(uint32_t i = 0; i <(sizeof(aff)/sizeof(aff[0])); i++) {
CThread * thread = CThread::create(callback, callbackArg, iAttr | aff[i],iPriority,iStackSize); CThread * thread = CThread::create(callback, callbackArg, iAttr | aff[i],iPriority,iStackSize);
thread->resumeThread(); thread->resumeThread();
delete thread; delete thread;
@ -23,7 +23,7 @@ void runOnAllCores(CThread::Callback callback, void *callbackArg, s32 iAttr = 0,
void writeSegmentRegister(CThread *thread, void *arg) { void writeSegmentRegister(CThread *thread, void *arg) {
sr_table_t * table = (sr_table_t *) arg; sr_table_t * table = (sr_table_t *) arg;
u16 core = OSGetThreadAffinity(OSGetCurrentThread()); uint16_t core = OSGetThreadAffinity(OSGetCurrentThread());
DEBUG_FUNCTION_LINE("Writing segment register to core %d\n",core); DEBUG_FUNCTION_LINE("Writing segment register to core %d\n",core);
DCFlushRange(table,sizeof(sr_table_t)); DCFlushRange(table,sizeof(sr_table_t));
@ -31,7 +31,7 @@ void writeSegmentRegister(CThread *thread, void *arg) {
} }
void readAndPrintSegmentRegister(CThread *thread, void *arg) { void readAndPrintSegmentRegister(CThread *thread, void *arg) {
u16 core = OSGetThreadAffinity(OSGetCurrentThread()); uint16_t core = OSGetThreadAffinity(OSGetCurrentThread());
DEBUG_FUNCTION_LINE("Reading segment register and page table from core %d\n",core); DEBUG_FUNCTION_LINE("Reading segment register and page table from core %d\n",core);
sr_table_t srTable; sr_table_t srTable;
memset(&srTable,0,sizeof(srTable)); memset(&srTable,0,sizeof(srTable));
@ -39,11 +39,11 @@ void readAndPrintSegmentRegister(CThread *thread, void *arg) {
SC0x36_KernelReadSRs(&srTable); SC0x36_KernelReadSRs(&srTable);
DCFlushRange(&srTable,sizeof(srTable)); DCFlushRange(&srTable,sizeof(srTable));
for(int i = 0; i < 16; i++) { for(int32_t i = 0; i < 16; i++) {
DEBUG_FUNCTION_LINE("[%d] SR[%d]=%08X\n",core,i,srTable.value[i]); DEBUG_FUNCTION_LINE("[%d] SR[%d]=%08X\n",core,i,srTable.value[i]);
} }
u32 pageTable[0x8000]; uint32_t pageTable[0x8000];
memset(pageTable,0,sizeof(pageTable)); memset(pageTable,0,sizeof(pageTable));
DEBUG_FUNCTION_LINE("Reading pageTable now.\n"); DEBUG_FUNCTION_LINE("Reading pageTable now.\n");
@ -68,61 +68,61 @@ bool MemoryMapping::isMemoryMapped() {
return false; return false;
} }
u32 MemoryMapping::getHeapAddress() { uint32_t MemoryMapping::getHeapAddress() {
return MEMORY_START_PLUGIN_HEAP; return MEMORY_START_PLUGIN_HEAP;
} }
u32 MemoryMapping::getHeapSize() { uint32_t MemoryMapping::getHeapSize() {
return getAreaSizeFromPageTable(MEMORY_START_PLUGIN_HEAP,MEMORY_START_PLUGIN_HEAP_END - MEMORY_START_PLUGIN_HEAP); return getAreaSizeFromPageTable(MEMORY_START_PLUGIN_HEAP,MEMORY_START_PLUGIN_HEAP_END - MEMORY_START_PLUGIN_HEAP);
} }
void MemoryMapping::searchEmptyMemoryRegions() { void MemoryMapping::searchEmptyMemoryRegions() {
DEBUG_FUNCTION_LINE("Searching for empty memory.\n"); DEBUG_FUNCTION_LINE("Searching for empty memory.\n");
for(int i = 0;; i++) { for(int32_t i = 0;; i++) {
if(mem_mapping[i].physical_addresses == NULL) { if(mem_mapping[i].physical_addresses == NULL) {
break; break;
} }
u32 ea_start_address = mem_mapping[i].effective_start_address; uint32_t ea_start_address = mem_mapping[i].effective_start_address;
const memory_values_t * mem_vals = mem_mapping[i].physical_addresses; const memory_values_t * mem_vals = mem_mapping[i].physical_addresses;
u32 ea_size = 0; uint32_t ea_size = 0;
for(u32 j = 0;; j++) { for(uint32_t j = 0;; j++) {
u32 pa_start_address = mem_vals[j].start_address; uint32_t pa_start_address = mem_vals[j].start_address;
u32 pa_end_address = mem_vals[j].end_address; uint32_t pa_end_address = mem_vals[j].end_address;
if(pa_end_address == 0 && pa_start_address == 0) { if(pa_end_address == 0 && pa_start_address == 0) {
break; break;
} }
ea_size += pa_end_address - pa_start_address; ea_size += pa_end_address - pa_start_address;
} }
u32* flush_start = (u32*)ea_start_address; uint32_t* flush_start = (uint32_t*)ea_start_address;
u32 flush_size = ea_size; uint32_t flush_size = ea_size;
DEBUG_FUNCTION_LINE("Flushing %08X (%d kB) at %08X.\n",flush_size,flush_size/1024, flush_start); DEBUG_FUNCTION_LINE("Flushing %08X (%d kB) at %08X.\n",flush_size,flush_size/1024, flush_start);
DCFlushRange(flush_start,flush_size); DCFlushRange(flush_start,flush_size);
DEBUG_FUNCTION_LINE("Searching in memory region %d. 0x%08X - 0x%08X. Size 0x%08X (%d KBytes).\n",i+1,ea_start_address,ea_start_address+ea_size,ea_size,ea_size/1024); DEBUG_FUNCTION_LINE("Searching in memory region %d. 0x%08X - 0x%08X. Size 0x%08X (%d KBytes).\n",i+1,ea_start_address,ea_start_address+ea_size,ea_size,ea_size/1024);
bool success = true; bool success = true;
u32 * memory_ptr = (u32*) ea_start_address; uint32_t * memory_ptr = (uint32_t*) ea_start_address;
bool inFailRange = false; bool inFailRange = false;
u32 startFailing = 0; uint32_t startFailing = 0;
u32 startGood = ea_start_address; uint32_t startGood = ea_start_address;
for(u32 j=0; j < ea_size/4; j++) { for(uint32_t j=0; j < ea_size/4; j++) {
if(memory_ptr[j] != 0) { if(memory_ptr[j] != 0) {
success = false; success = false;
if(!success && !inFailRange) { if(!success && !inFailRange) {
if((((u32)&memory_ptr[j])-(u32)startGood)/1024 > 512) { if((((uint32_t)&memory_ptr[j])-(uint32_t)startGood)/1024 > 512) {
u32 start_addr = startGood & 0xFFFE0000; uint32_t start_addr = startGood & 0xFFFE0000;
if(start_addr != startGood) { if(start_addr != startGood) {
start_addr += 0x20000; start_addr += 0x20000;
} }
u32 end_addr = ((u32)&memory_ptr[j]) - MEMORY_START_BASE; uint32_t end_addr = ((uint32_t)&memory_ptr[j]) - MEMORY_START_BASE;
end_addr = (end_addr & 0xFFFE0000); end_addr = (end_addr & 0xFFFE0000);
DEBUG_FUNCTION_LINE("+ Free between 0x%08X and 0x%08X size: %u kB\n",start_addr - MEMORY_START_BASE,end_addr,(((u32)end_addr)-((u32)startGood - MEMORY_START_BASE))/1024); DEBUG_FUNCTION_LINE("+ Free between 0x%08X and 0x%08X size: %u kB\n",start_addr - MEMORY_START_BASE,end_addr,(((uint32_t)end_addr)-((uint32_t)startGood - MEMORY_START_BASE))/1024);
} }
startFailing = (u32)&memory_ptr[j]; startFailing = (uint32_t)&memory_ptr[j];
inFailRange = true; inFailRange = true;
startGood = 0; startGood = 0;
j = ((j & 0xFFFF8000) + 0x00008000)-1; j = ((j & 0xFFFF8000) + 0x00008000)-1;
@ -130,17 +130,17 @@ void MemoryMapping::searchEmptyMemoryRegions() {
//break; //break;
} else { } else {
if(inFailRange) { if(inFailRange) {
//DEBUG_FUNCTION_LINE("- Error between 0x%08X and 0x%08X size: %u kB\n",startFailing,&memory_ptr[j],(((u32)&memory_ptr[j])-(u32)startFailing)/1024); //DEBUG_FUNCTION_LINE("- Error between 0x%08X and 0x%08X size: %u kB\n",startFailing,&memory_ptr[j],(((uint32_t)&memory_ptr[j])-(uint32_t)startFailing)/1024);
startFailing = 0; startFailing = 0;
startGood = (u32) &memory_ptr[j]; startGood = (uint32_t) &memory_ptr[j];
inFailRange = false; inFailRange = false;
} }
} }
} }
if(startGood != 0 && (startGood != ea_start_address + ea_size)) { if(startGood != 0 && (startGood != ea_start_address + ea_size)) {
DEBUG_FUNCTION_LINE("+ Good between 0x%08X and 0x%08X size: %u kB\n",startGood - MEMORY_START_BASE,((u32)(ea_start_address + ea_size) - (u32)MEMORY_START_BASE),((u32)(ea_start_address + ea_size) - (u32)startGood)/1024); DEBUG_FUNCTION_LINE("+ Good between 0x%08X and 0x%08X size: %u kB\n",startGood - MEMORY_START_BASE,((uint32_t)(ea_start_address + ea_size) - (uint32_t)MEMORY_START_BASE),((uint32_t)(ea_start_address + ea_size) - (uint32_t)startGood)/1024);
} else if(inFailRange) { } else if(inFailRange) {
DEBUG_FUNCTION_LINE("- Used between 0x%08X and 0x%08X size: %u kB\n",startFailing,ea_start_address + ea_size,((u32)(ea_start_address + ea_size) - (u32)startFailing)/1024); DEBUG_FUNCTION_LINE("- Used between 0x%08X and 0x%08X size: %u kB\n",startFailing,ea_start_address + ea_size,((uint32_t)(ea_start_address + ea_size) - (uint32_t)startFailing)/1024);
} }
if(success) { if(success) {
DEBUG_FUNCTION_LINE("Test %d was successful!\n",i+1); DEBUG_FUNCTION_LINE("Test %d was successful!\n",i+1);
@ -152,33 +152,33 @@ void MemoryMapping::searchEmptyMemoryRegions() {
void MemoryMapping::writeTestValuesToMemory() { void MemoryMapping::writeTestValuesToMemory() {
//don't smash the stack. //don't smash the stack.
u32 chunk_size = 0x1000; uint32_t chunk_size = 0x1000;
u32 testBuffer[chunk_size]; uint32_t testBuffer[chunk_size];
for(int i = 0;; i++) { for(int32_t i = 0;; i++) {
if(mem_mapping[i].physical_addresses == NULL) { if(mem_mapping[i].physical_addresses == NULL) {
break; break;
} }
u32 cur_ea_start_address = mem_mapping[i].effective_start_address; uint32_t cur_ea_start_address = mem_mapping[i].effective_start_address;
DEBUG_FUNCTION_LINE("Preparing memory test for region %d. Region start at effective address %08X.\n",i+1,cur_ea_start_address); DEBUG_FUNCTION_LINE("Preparing memory test for region %d. Region start at effective address %08X.\n",i+1,cur_ea_start_address);
const memory_values_t * mem_vals = mem_mapping[i].physical_addresses; const memory_values_t * mem_vals = mem_mapping[i].physical_addresses;
u32 counter = 0; uint32_t counter = 0;
for(u32 j = 0;; j++) { for(uint32_t j = 0;; j++) {
u32 pa_start_address = mem_vals[j].start_address; uint32_t pa_start_address = mem_vals[j].start_address;
u32 pa_end_address = mem_vals[j].end_address; uint32_t pa_end_address = mem_vals[j].end_address;
if(pa_end_address == 0 && pa_start_address == 0) { if(pa_end_address == 0 && pa_start_address == 0) {
break; break;
} }
u32 pa_size = pa_end_address - pa_start_address; uint32_t pa_size = pa_end_address - pa_start_address;
DEBUG_FUNCTION_LINE("Writing region %d of mapping %d. From %08X to %08X Size: %d KBytes...\n",j+1,i+1,pa_start_address,pa_end_address,pa_size/1024); DEBUG_FUNCTION_LINE("Writing region %d of mapping %d. From %08X to %08X Size: %d KBytes...\n",j+1,i+1,pa_start_address,pa_end_address,pa_size/1024);
for(u32 k=0; k<=pa_size/4; k++) { for(uint32_t k=0; k<=pa_size/4; k++) {
if(k > 0 && (k % chunk_size) == 0) { if(k > 0 && (k % chunk_size) == 0) {
DCFlushRange(&testBuffer,sizeof(testBuffer)); DCFlushRange(&testBuffer,sizeof(testBuffer));
DCInvalidateRange(&testBuffer,sizeof(testBuffer)); DCInvalidateRange(&testBuffer,sizeof(testBuffer));
u32 destination = pa_start_address + ((k*4) - sizeof(testBuffer)); uint32_t destination = pa_start_address + ((k*4) - sizeof(testBuffer));
SC0x25_KernelCopyData(destination,(u32)OSEffectiveToPhysical(testBuffer),sizeof(testBuffer)); SC0x25_KernelCopyData(destination,(uint32_t)OSEffectiveToPhysical(testBuffer),sizeof(testBuffer));
//DEBUG_FUNCTION_LINE("Copy testBuffer into %08X\n",destination); //DEBUG_FUNCTION_LINE("Copy testBuffer into %08X\n",destination);
} }
if(k != pa_size/4) { if(k != pa_size/4) {
@ -186,8 +186,8 @@ void MemoryMapping::writeTestValuesToMemory() {
} }
//DEBUG_FUNCTION_LINE("testBuffer[%d] = %d\n",i % chunk_size,i); //DEBUG_FUNCTION_LINE("testBuffer[%d] = %d\n",i % chunk_size,i);
} }
u32* flush_start = (u32*)cur_ea_start_address; uint32_t* flush_start = (uint32_t*)cur_ea_start_address;
u32 flush_size = pa_size; uint32_t flush_size = pa_size;
cur_ea_start_address += pa_size; cur_ea_start_address += pa_size;
@ -202,42 +202,42 @@ void MemoryMapping::writeTestValuesToMemory() {
void MemoryMapping::readTestValuesFromMemory() { void MemoryMapping::readTestValuesFromMemory() {
DEBUG_FUNCTION_LINE("Testing reading the written values.\n"); DEBUG_FUNCTION_LINE("Testing reading the written values.\n");
for(int i = 0;; i++) { for(int32_t i = 0;; i++) {
if(mem_mapping[i].physical_addresses == NULL) { if(mem_mapping[i].physical_addresses == NULL) {
break; break;
} }
u32 ea_start_address = mem_mapping[i].effective_start_address; uint32_t ea_start_address = mem_mapping[i].effective_start_address;
const memory_values_t * mem_vals = mem_mapping[i].physical_addresses; const memory_values_t * mem_vals = mem_mapping[i].physical_addresses;
//u32 counter = 0; //uint32_t counter = 0;
u32 ea_size = 0; uint32_t ea_size = 0;
for(u32 j = 0;; j++) { for(uint32_t j = 0;; j++) {
u32 pa_start_address = mem_vals[j].start_address; uint32_t pa_start_address = mem_vals[j].start_address;
u32 pa_end_address = mem_vals[j].end_address; uint32_t pa_end_address = mem_vals[j].end_address;
if(pa_end_address == 0 && pa_start_address == 0) { if(pa_end_address == 0 && pa_start_address == 0) {
break; break;
} }
ea_size += pa_end_address - pa_start_address; ea_size += pa_end_address - pa_start_address;
} }
u32* flush_start = (u32*)ea_start_address; uint32_t* flush_start = (uint32_t*)ea_start_address;
u32 flush_size = ea_size; uint32_t flush_size = ea_size;
DEBUG_FUNCTION_LINE("Flushing %08X (%d kB) at %08X to map memory.\n",flush_size,flush_size/1024, flush_start); DEBUG_FUNCTION_LINE("Flushing %08X (%d kB) at %08X to map memory.\n",flush_size,flush_size/1024, flush_start);
DCFlushRange(flush_start,flush_size); DCFlushRange(flush_start,flush_size);
DEBUG_FUNCTION_LINE("Testing memory region %d. 0x%08X - 0x%08X. Size 0x%08X (%d KBytes).\n",i+1,ea_start_address,ea_start_address+ea_size,ea_size,ea_size/1024); DEBUG_FUNCTION_LINE("Testing memory region %d. 0x%08X - 0x%08X. Size 0x%08X (%d KBytes).\n",i+1,ea_start_address,ea_start_address+ea_size,ea_size,ea_size/1024);
bool success = true; bool success = true;
u32 * memory_ptr = (u32*) ea_start_address; uint32_t * memory_ptr = (uint32_t*) ea_start_address;
bool inFailRange = false; bool inFailRange = false;
u32 startFailing = 0; uint32_t startFailing = 0;
u32 startGood = ea_start_address; uint32_t startGood = ea_start_address;
for(u32 j=0; j < ea_size/4; j++) { for(uint32_t j=0; j < ea_size/4; j++) {
if(memory_ptr[j] != j) { if(memory_ptr[j] != j) {
success = false; success = false;
if(!success && !inFailRange) { if(!success && !inFailRange) {
DEBUG_FUNCTION_LINE("+ Good between 0x%08X and 0x%08X size: %u kB\n",startGood,&memory_ptr[j],(((u32)&memory_ptr[j])-(u32)startGood)/1024); DEBUG_FUNCTION_LINE("+ Good between 0x%08X and 0x%08X size: %u kB\n",startGood,&memory_ptr[j],(((uint32_t)&memory_ptr[j])-(uint32_t)startGood)/1024);
startFailing = (u32)&memory_ptr[j]; startFailing = (uint32_t)&memory_ptr[j];
inFailRange = true; inFailRange = true;
startGood = 0; startGood = 0;
j = ((j & 0xFFFF8000) + 0x00008000)-1; j = ((j & 0xFFFF8000) + 0x00008000)-1;
@ -245,17 +245,17 @@ void MemoryMapping::readTestValuesFromMemory() {
//break; //break;
} else { } else {
if(inFailRange) { if(inFailRange) {
DEBUG_FUNCTION_LINE("- Error between 0x%08X and 0x%08X size: %u kB\n",startFailing,&memory_ptr[j],(((u32)&memory_ptr[j])-(u32)startFailing)/1024); DEBUG_FUNCTION_LINE("- Error between 0x%08X and 0x%08X size: %u kB\n",startFailing,&memory_ptr[j],(((uint32_t)&memory_ptr[j])-(uint32_t)startFailing)/1024);
startFailing = 0; startFailing = 0;
startGood = (u32) &memory_ptr[j]; startGood = (uint32_t) &memory_ptr[j];
inFailRange = false; inFailRange = false;
} }
} }
} }
if(startGood != 0 && (startGood != ea_start_address + ea_size)) { if(startGood != 0 && (startGood != ea_start_address + ea_size)) {
DEBUG_FUNCTION_LINE("+ Good between 0x%08X and 0x%08X size: %u kB\n",startGood,ea_start_address + ea_size,((u32)(ea_start_address + ea_size) - (u32)startGood)/1024); DEBUG_FUNCTION_LINE("+ Good between 0x%08X and 0x%08X size: %u kB\n",startGood,ea_start_address + ea_size,((uint32_t)(ea_start_address + ea_size) - (uint32_t)startGood)/1024);
} else if(inFailRange) { } else if(inFailRange) {
DEBUG_FUNCTION_LINE("- Error between 0x%08X and 0x%08X size: %u kB\n",startFailing,ea_start_address + ea_size,((u32)(ea_start_address + ea_size) - (u32)startFailing)/1024); DEBUG_FUNCTION_LINE("- Error between 0x%08X and 0x%08X size: %u kB\n",startFailing,ea_start_address + ea_size,((uint32_t)(ea_start_address + ea_size) - (uint32_t)startFailing)/1024);
} }
if(success) { if(success) {
DEBUG_FUNCTION_LINE("Test %d was successful!\n",i+1); DEBUG_FUNCTION_LINE("Test %d was successful!\n",i+1);
@ -265,28 +265,28 @@ void MemoryMapping::readTestValuesFromMemory() {
DEBUG_FUNCTION_LINE("All tests done.\n"); DEBUG_FUNCTION_LINE("All tests done.\n");
} }
void MemoryMapping::memoryMappingForRegions(const memory_mapping_t * memory_mapping, sr_table_t SRTable, u32 * translation_table) { void MemoryMapping::memoryMappingForRegions(const memory_mapping_t * memory_mapping, sr_table_t SRTable, uint32_t * translation_table) {
for(int i = 0; /* waiting for a break */; i++) { for(int32_t i = 0; /* waiting for a break */; i++) {
DEBUG_FUNCTION_LINE("In loop %d\n",i); DEBUG_FUNCTION_LINE("In loop %d\n",i);
if(memory_mapping[i].physical_addresses == NULL) { if(memory_mapping[i].physical_addresses == NULL) {
DEBUG_FUNCTION_LINE("break %d\n",i); DEBUG_FUNCTION_LINE("break %d\n",i);
break; break;
} }
u32 cur_ea_start_address = memory_mapping[i].effective_start_address; uint32_t cur_ea_start_address = memory_mapping[i].effective_start_address;
DEBUG_FUNCTION_LINE("Mapping area %d. effective address %08X...\n",i+1,cur_ea_start_address); DEBUG_FUNCTION_LINE("Mapping area %d. effective address %08X...\n",i+1,cur_ea_start_address);
const memory_values_t * mem_vals = memory_mapping[i].physical_addresses; const memory_values_t * mem_vals = memory_mapping[i].physical_addresses;
for(u32 j = 0;; j++) { for(uint32_t j = 0;; j++) {
DEBUG_FUNCTION_LINE("In inner loop %d\n",j); DEBUG_FUNCTION_LINE("In inner loop %d\n",j);
u32 pa_start_address = mem_vals[j].start_address; uint32_t pa_start_address = mem_vals[j].start_address;
u32 pa_end_address = mem_vals[j].end_address; uint32_t pa_end_address = mem_vals[j].end_address;
if(pa_end_address == 0 && pa_start_address == 0) { if(pa_end_address == 0 && pa_start_address == 0) {
DEBUG_FUNCTION_LINE("inner break %d\n",j); DEBUG_FUNCTION_LINE("inner break %d\n",j);
// Break if entry was empty. // Break if entry was empty.
break; break;
} }
u32 pa_size = pa_end_address - pa_start_address; uint32_t pa_size = pa_end_address - pa_start_address;
DEBUG_FUNCTION_LINE("Adding page table entry %d for mapping area %d. %08X-%08X => %08X-%08X...\n",j+1,i+1,cur_ea_start_address,memory_mapping[i].effective_start_address+pa_size,pa_start_address,pa_end_address); DEBUG_FUNCTION_LINE("Adding page table entry %d for mapping area %d. %08X-%08X => %08X-%08X...\n",j+1,i+1,cur_ea_start_address,memory_mapping[i].effective_start_address+pa_size,pa_start_address,pa_end_address);
if(!mapMemory(pa_start_address,pa_end_address,cur_ea_start_address,SRTable,translation_table)) { if(!mapMemory(pa_start_address,pa_end_address,cur_ea_start_address,SRTable,translation_table)) {
log_print("error =(\n"); log_print("error =(\n");
@ -305,7 +305,7 @@ void MemoryMapping::setupMemoryMapping() {
//runOnAllCores(readAndPrintSegmentRegister,NULL,0,16,0x20000); //runOnAllCores(readAndPrintSegmentRegister,NULL,0,16,0x20000);
sr_table_t srTableCpy; sr_table_t srTableCpy;
u32 pageTableCpy[0x8000]; uint32_t pageTableCpy[0x8000];
SC0x36_KernelReadSRs(&srTableCpy); SC0x36_KernelReadSRs(&srTableCpy);
SC0x37_KernelReadPTE(pageTableCpy,sizeof(pageTableCpy)); SC0x37_KernelReadPTE(pageTableCpy,sizeof(pageTableCpy));
@ -313,7 +313,7 @@ void MemoryMapping::setupMemoryMapping() {
DCFlushRange(&srTableCpy,sizeof(srTableCpy)); DCFlushRange(&srTableCpy,sizeof(srTableCpy));
DCFlushRange(pageTableCpy,sizeof(pageTableCpy)); DCFlushRange(pageTableCpy,sizeof(pageTableCpy));
for(int i = 0; i < 16; i++) { for(int32_t i = 0; i < 16; i++) {
DEBUG_FUNCTION_LINE("SR[%d]=%08X\n",i,srTableCpy.value[i]); DEBUG_FUNCTION_LINE("SR[%d]=%08X\n",i,srTableCpy.value[i]);
} }
@ -324,8 +324,8 @@ void MemoryMapping::setupMemoryMapping() {
// is currently unmapped. // is currently unmapped.
// This is nice because it leads to SR[8] which also seems to be unused (was set to 0x30FFFFFF) // This is nice because it leads to SR[8] which also seems to be unused (was set to 0x30FFFFFF)
// The content of the segment was chosen randomly. // The content of the segment was chosen randomly.
u32 segment_index = MEMORY_START_BASE >> 28; uint32_t segment_index = MEMORY_START_BASE >> 28;
u32 segment_content = 0x20000000 | SEGMENT_UNIQUE_ID; uint32_t segment_content = 0x20000000 | SEGMENT_UNIQUE_ID;
DEBUG_FUNCTION_LINE("Setting SR[%d] to %08X\n",segment_index,segment_content); DEBUG_FUNCTION_LINE("Setting SR[%d] to %08X\n",segment_index,segment_content);
srTableCpy.value[segment_index] = segment_content; srTableCpy.value[segment_index] = segment_content;
@ -356,34 +356,34 @@ void MemoryMapping::setupMemoryMapping() {
} }
u32 MemoryMapping::getAreaSizeFromPageTable(u32 start, u32 maxSize) { uint32_t MemoryMapping::getAreaSizeFromPageTable(uint32_t start, uint32_t maxSize) {
sr_table_t srTable; sr_table_t srTable;
u32 pageTable[0x8000]; uint32_t pageTable[0x8000];
SC0x36_KernelReadSRs(&srTable); SC0x36_KernelReadSRs(&srTable);
SC0x37_KernelReadPTE(pageTable,sizeof(pageTable)); SC0x37_KernelReadPTE(pageTable,sizeof(pageTable));
u32 sr_start = start >> 28; uint32_t sr_start = start >> 28;
u32 sr_end = (start + maxSize) >> 28; uint32_t sr_end = (start + maxSize) >> 28;
if(sr_end < sr_start) { if(sr_end < sr_start) {
return 0; return 0;
} }
u32 cur_address = start; uint32_t cur_address = start;
u32 end_address = start + maxSize; uint32_t end_address = start + maxSize;
u32 memSize = 0; uint32_t memSize = 0;
for(u32 segment = sr_start; segment <= sr_end ; segment++) { for(uint32_t segment = sr_start; segment <= sr_end ; segment++) {
u32 sr = srTable.value[segment]; uint32_t sr = srTable.value[segment];
if(sr >> 31) { if(sr >> 31) {
DEBUG_FUNCTION_LINE("Direct access not supported\n"); DEBUG_FUNCTION_LINE("Direct access not supported\n");
} else { } else {
u32 vsid = sr & 0xFFFFFF; uint32_t vsid = sr & 0xFFFFFF;
u32 pageSize = 1 << PAGE_INDEX_SHIFT; uint32_t pageSize = 1 << PAGE_INDEX_SHIFT;
u32 cur_end_addr = 0; uint32_t cur_end_addr = 0;
if(segment == sr_end) { if(segment == sr_end) {
cur_end_addr = end_address; cur_end_addr = end_address;
} else { } else {
@ -393,9 +393,9 @@ u32 MemoryMapping::getAreaSizeFromPageTable(u32 start, u32 maxSize) {
cur_address = (segment) * 0x10000000; cur_address = (segment) * 0x10000000;
} }
bool success = true; bool success = true;
for(u32 addr = cur_address; addr < cur_end_addr; addr += pageSize) { for(uint32_t addr = cur_address; addr < cur_end_addr; addr += pageSize) {
u32 PTEH = 0; uint32_t PTEH = 0;
u32 PTEL = 0; uint32_t PTEL = 0;
if(getPageEntryForAddress(srTable.sdr1, addr, vsid, pageTable, &PTEH, &PTEL, false)) { if(getPageEntryForAddress(srTable.sdr1, addr, vsid, pageTable, &PTEH, &PTEL, false)) {
memSize += pageSize; memSize += pageSize;
} else { } else {
@ -411,10 +411,10 @@ u32 MemoryMapping::getAreaSizeFromPageTable(u32 start, u32 maxSize) {
return memSize; return memSize;
} }
bool MemoryMapping::getPageEntryForAddress(u32 SDR1,u32 addr, u32 vsid, u32 * translation_table,u32* oPTEH, u32* oPTEL, bool checkSecondHash) { bool MemoryMapping::getPageEntryForAddress(uint32_t SDR1,uint32_t addr, uint32_t vsid, uint32_t * translation_table,uint32_t* oPTEH, uint32_t* oPTEL, bool checkSecondHash) {
u32 pageMask = SDR1 & 0x1FF; uint32_t pageMask = SDR1 & 0x1FF;
u32 pageIndex = (addr >> PAGE_INDEX_SHIFT) & PAGE_INDEX_MASK; uint32_t pageIndex = (addr >> PAGE_INDEX_SHIFT) & PAGE_INDEX_MASK;
u32 primaryHash = (vsid & 0x7FFFF) ^ pageIndex; uint32_t primaryHash = (vsid & 0x7FFFF) ^ pageIndex;
if(getPageEntryForAddressEx(SDR1, addr, vsid, primaryHash, translation_table, oPTEH, oPTEL, 0)) { if(getPageEntryForAddressEx(SDR1, addr, vsid, primaryHash, translation_table, oPTEH, oPTEL, 0)) {
return true; return true;
@ -429,18 +429,18 @@ bool MemoryMapping::getPageEntryForAddress(u32 SDR1,u32 addr, u32 vsid, u32 * tr
return false; return false;
} }
bool MemoryMapping::getPageEntryForAddressEx(u32 pageMask, u32 addr, u32 vsid, u32 primaryHash, u32 * translation_table,u32* oPTEH, u32* oPTEL,u32 H) { bool MemoryMapping::getPageEntryForAddressEx(uint32_t pageMask, uint32_t addr, uint32_t vsid, uint32_t primaryHash, uint32_t * translation_table,uint32_t* oPTEH, uint32_t* oPTEL,uint32_t H) {
uint32_t maskedHash = primaryHash & ((pageMask << 10) | 0x3FF); uint32_t maskedHash = primaryHash & ((pageMask << 10) | 0x3FF);
uint32_t api = (addr >> 22) & 0x3F; uint32_t api = (addr >> 22) & 0x3F;
uint32_t pteAddrOffset = (maskedHash << 6); uint32_t pteAddrOffset = (maskedHash << 6);
for (int j = 0; j < 8; j++, pteAddrOffset += 8) { for (int32_t j = 0; j < 8; j++, pteAddrOffset += 8) {
uint32_t PTEH = 0; uint32_t PTEH = 0;
uint32_t PTEL = 0; uint32_t PTEL = 0;
u32 pteh_index = pteAddrOffset / 4; uint32_t pteh_index = pteAddrOffset / 4;
u32 ptel_index = pteh_index + 1; uint32_t ptel_index = pteh_index + 1;
PTEH = translation_table[pteh_index]; PTEH = translation_table[pteh_index];
PTEL = translation_table[ptel_index]; PTEL = translation_table[ptel_index];
@ -478,29 +478,29 @@ bool MemoryMapping::getPageEntryForAddressEx(u32 pageMask, u32 addr, u32 vsid, u
return false; return false;
} }
void MemoryMapping::printPageTableTranslation(sr_table_t srTable, u32 * translation_table) { void MemoryMapping::printPageTableTranslation(sr_table_t srTable, uint32_t * translation_table) {
u32 SDR1 = srTable.sdr1; uint32_t SDR1 = srTable.sdr1;
pageInformation current; pageInformation current;
memset(&current,0,sizeof(current)); memset(&current,0,sizeof(current));
std::vector<pageInformation> pageInfos; std::vector<pageInformation> pageInfos;
for(u32 segment = 0; segment < 16 ; segment++) { for(uint32_t segment = 0; segment < 16 ; segment++) {
u32 sr = srTable.value[segment]; uint32_t sr = srTable.value[segment];
if(sr >> 31) { if(sr >> 31) {
DEBUG_FUNCTION_LINE("Direct access not supported\n"); DEBUG_FUNCTION_LINE("Direct access not supported\n");
} else { } else {
u32 ks = (sr >> 30) & 1; uint32_t ks = (sr >> 30) & 1;
u32 kp = (sr >> 29) & 1; uint32_t kp = (sr >> 29) & 1;
u32 nx = (sr >> 28) & 1; uint32_t nx = (sr >> 28) & 1;
u32 vsid = sr & 0xFFFFFF; uint32_t vsid = sr & 0xFFFFFF;
DEBUG_FUNCTION_LINE("ks %08X kp %08X nx %08X vsid %08X\n",ks,kp,nx,vsid); DEBUG_FUNCTION_LINE("ks %08X kp %08X nx %08X vsid %08X\n",ks,kp,nx,vsid);
u32 pageSize = 1 << PAGE_INDEX_SHIFT; uint32_t pageSize = 1 << PAGE_INDEX_SHIFT;
for(u32 addr = segment * 0x10000000; addr < (segment + 1) * 0x10000000; addr += pageSize) { for(uint32_t addr = segment * 0x10000000; addr < (segment + 1) * 0x10000000; addr += pageSize) {
u32 PTEH = 0; uint32_t PTEH = 0;
u32 PTEL = 0; uint32_t PTEL = 0;
if(getPageEntryForAddress(SDR1, addr, vsid, translation_table, &PTEH, &PTEL, false)) { if(getPageEntryForAddress(SDR1, addr, vsid, translation_table, &PTEH, &PTEL, false)) {
uint32_t pp = PTEL & 3; uint32_t pp = PTEL & 3;
uint32_t phys = PTEL & 0xFFFFF000; uint32_t phys = PTEL & 0xFFFFF000;
@ -556,11 +556,11 @@ void MemoryMapping::printPageTableTranslation(sr_table_t srTable, u32 * translat
} }
bool MemoryMapping::mapMemory(uint32_t pa_start_address,uint32_t pa_end_address,uint32_t ea_start_address, sr_table_t SRTable, u32 * translation_table) { bool MemoryMapping::mapMemory(uint32_t pa_start_address,uint32_t pa_end_address,uint32_t ea_start_address, sr_table_t SRTable, uint32_t * translation_table) {
// Based on code from dimok. Thanks! // Based on code from dimok. Thanks!
//u32 byteOffsetMask = (1 << PAGE_INDEX_SHIFT) - 1; //uint32_t byteOffsetMask = (1 << PAGE_INDEX_SHIFT) - 1;
//u32 apiShift = 22 - PAGE_INDEX_SHIFT; //uint32_t apiShift = 22 - PAGE_INDEX_SHIFT;
// Information on page 5. // Information on page 5.
// https://www.nxp.com/docs/en/application-note/AN2794.pdf // https://www.nxp.com/docs/en/application-note/AN2794.pdf
@ -570,7 +570,7 @@ bool MemoryMapping::mapMemory(uint32_t pa_start_address,uint32_t pa_end_address,
// Iterate to all possible pages. Each page is 1<<(PAGE_INDEX_SHIFT) big. // Iterate to all possible pages. Each page is 1<<(PAGE_INDEX_SHIFT) big.
uint32_t pageSize = 1<<(PAGE_INDEX_SHIFT); uint32_t pageSize = 1<<(PAGE_INDEX_SHIFT);
for(u32 i = 0; i < pa_end_address - pa_start_address; i += pageSize) { for(uint32_t i = 0; i < pa_end_address - pa_start_address; i += pageSize) {
// Calculate the current effective address. // Calculate the current effective address.
uint32_t ea_addr = ea_start_address + i; uint32_t ea_addr = ea_start_address + i;
// Calculate the segement. // Calculate the segement.
@ -622,8 +622,8 @@ bool MemoryMapping::mapMemory(uint32_t pa_start_address,uint32_t pa_end_address,
bool setSuccessfully = false; bool setSuccessfully = false;
PTEGoffset += 7*8; PTEGoffset += 7*8;
// Lets iterate through the PTE group where out PTE should be saved. // Lets iterate through the PTE group where out PTE should be saved.
for(int j = 7; j>0; PTEGoffset -= 8) { for(int32_t j = 7; j>0; PTEGoffset -= 8) {
int index = (PTEGoffset/4); int32_t index = (PTEGoffset/4);
uint32_t pteh = translation_table[index]; uint32_t pteh = translation_table[index];
// Check if it's already taken. The first bit indicates if the PTE-slot inside // Check if it's already taken. The first bit indicates if the PTE-slot inside
@ -651,8 +651,8 @@ bool MemoryMapping::mapMemory(uint32_t pa_start_address,uint32_t pa_end_address,
PTEGoffset = PTEGaddr2 - (HTABORG << 16); PTEGoffset = PTEGaddr2 - (HTABORG << 16);
PTEGoffset += 7*8; PTEGoffset += 7*8;
// Same as before. // Same as before.
for(int j = 7; j>0; PTEGoffset -= 8) { for(int32_t j = 7; j>0; PTEGoffset -= 8) {
int index = (PTEGoffset/4); int32_t index = (PTEGoffset/4);
uint32_t pteh = translation_table[index]; uint32_t pteh = translation_table[index];
//Check if it's already taken. //Check if it's already taken.
if ((pteh == 0)) { if ((pteh == 0)) {

22
loader/src/mymemory/memory_mapping.h
View File

@ -19,12 +19,12 @@ typedef struct pageInformation_ {
} pageInformation; } pageInformation;
typedef struct _memory_values_t { typedef struct _memory_values_t {
unsigned int start_address; uint32_t start_address;
unsigned int end_address; uint32_t end_address;
} memory_values_t; } memory_values_t;
typedef struct _memory_mapping_t { typedef struct _memory_mapping_t {
unsigned int effective_start_address; uint32_t effective_start_address;
const memory_values_t* physical_addresses; const memory_values_t* physical_addresses;
} memory_mapping_t; } memory_mapping_t;
@ -115,7 +115,7 @@ public:
static void setupMemoryMapping(); static void setupMemoryMapping();
static void printPageTableTranslation(sr_table_t srTable, u32 * translation_table); static void printPageTableTranslation(sr_table_t srTable, uint32_t * translation_table);
static void writeTestValuesToMemory(); static void writeTestValuesToMemory();
@ -123,22 +123,22 @@ public:
static void searchEmptyMemoryRegions(); static void searchEmptyMemoryRegions();
static u32 getHeapAddress(); static uint32_t getHeapAddress();
static u32 getHeapSize(); static uint32_t getHeapSize();
static u32 getAreaSizeFromPageTable(u32 start, u32 maxSize); static uint32_t getAreaSizeFromPageTable(uint32_t start, uint32_t maxSize);
private: private:
static void memoryMappingForRegions(const memory_mapping_t * memory_mapping, sr_table_t SRTable, u32 * translation_table); static void memoryMappingForRegions(const memory_mapping_t * memory_mapping, sr_table_t SRTable, uint32_t * translation_table);
static bool mapMemory(u32 pa_start_address,u32 pa_end_address,u32 ea_start_address, sr_table_t SRTable, u32 * translation_table); static bool mapMemory(uint32_t pa_start_address,uint32_t pa_end_address,uint32_t ea_start_address, sr_table_t SRTable, uint32_t * translation_table);
static bool getPageEntryForAddress(u32 SDR1, u32 addr, u32 vsid, u32 * translation_table,u32* oPTEH, u32* oPTEL, bool checkSecondHash); static bool getPageEntryForAddress(uint32_t SDR1, uint32_t addr, uint32_t vsid, uint32_t * translation_table,uint32_t* oPTEH, uint32_t* oPTEL, bool checkSecondHash);
static bool getPageEntryForAddressEx(u32 pageMask, u32 addr, u32 vsid, u32 primaryHash, u32 * translation_table,u32* oPTEH, u32* oPTEL,u32 H) ; static bool getPageEntryForAddressEx(uint32_t pageMask, uint32_t addr, uint32_t vsid, uint32_t primaryHash, uint32_t * translation_table,uint32_t* oPTEH, uint32_t* oPTEL,uint32_t H) ;
}; };

30
loader/src/myutils/TcpReceiver.cpp
View File

@ -18,7 +18,7 @@
#include "plugin/PluginLoader.h" #include "plugin/PluginLoader.h"
#include "plugin/PluginInformation.h" #include "plugin/PluginInformation.h"
TcpReceiver::TcpReceiver(int port) TcpReceiver::TcpReceiver(int32_t port)
: CThread(CThread::eAttributeAffCore0 | CThread::eAttributePinnedAff) : CThread(CThread::eAttributeAffCore0 | CThread::eAttributePinnedAff)
, exitRequested(false) , exitRequested(false)
, serverPort(port) , serverPort(port)
@ -40,7 +40,7 @@ void TcpReceiver::executeThread() {
if (serverSocket < 0) if (serverSocket < 0)
return; return;
u32 enable = 1; uint32_t enable = 1;
setsockopt(serverSocket, SOL_SOCKET, SO_REUSEADDR, &enable, sizeof(enable)); setsockopt(serverSocket, SOL_SOCKET, SO_REUSEADDR, &enable, sizeof(enable));
struct sockaddr_in bindAddress; struct sockaddr_in bindAddress;
@ -49,7 +49,7 @@ void TcpReceiver::executeThread() {
bindAddress.sin_port = serverPort; bindAddress.sin_port = serverPort;
bindAddress.sin_addr.s_addr = INADDR_ANY; bindAddress.sin_addr.s_addr = INADDR_ANY;
s32 ret; int32_t ret;
if ((ret = bind(serverSocket, (struct sockaddr *)&bindAddress, sizeof(bindAddress))) < 0) { if ((ret = bind(serverSocket, (struct sockaddr *)&bindAddress, sizeof(bindAddress))) < 0) {
socketclose(serverSocket); socketclose(serverSocket);
return; return;
@ -61,14 +61,14 @@ void TcpReceiver::executeThread() {
} }
struct sockaddr_in clientAddr; struct sockaddr_in clientAddr;
s32 addrlen = sizeof(struct sockaddr); int32_t addrlen = sizeof(struct sockaddr);
while(!exitRequested) { while(!exitRequested) {
s32 clientSocket = accept(serverSocket, (struct sockaddr*)&clientAddr, &addrlen); int32_t clientSocket = accept(serverSocket, (struct sockaddr*)&clientAddr, &addrlen);
if(clientSocket >= 0) { if(clientSocket >= 0) {
u32 ipAddress = clientAddr.sin_addr.s_addr; uint32_t ipAddress = clientAddr.sin_addr.s_addr;
//serverReceiveStart(this, ipAddress); //serverReceiveStart(this, ipAddress);
int result = loadToMemory(clientSocket, ipAddress); int32_t result = loadToMemory(clientSocket, ipAddress);
//serverReceiveFinished(this, ipAddress, result); //serverReceiveFinished(this, ipAddress, result);
socketclose(clientSocket); socketclose(clientSocket);
@ -82,11 +82,11 @@ void TcpReceiver::executeThread() {
socketclose(serverSocket); socketclose(serverSocket);
} }
int TcpReceiver::loadToMemory(s32 clientSocket, u32 ipAddress) { int32_t TcpReceiver::loadToMemory(int32_t clientSocket, uint32_t ipAddress) {
DEBUG_FUNCTION_LINE("Loading file from ip %08X\n", ipAddress); DEBUG_FUNCTION_LINE("Loading file from ip %08X\n", ipAddress);
u32 fileSize = 0; uint32_t fileSize = 0;
u32 fileSizeUnc = 0; uint32_t fileSizeUnc = 0;
unsigned char haxx[8]; unsigned char haxx[8];
memset(haxx, 0, sizeof(haxx)); memset(haxx, 0, sizeof(haxx));
//skip haxx //skip haxx
@ -97,8 +97,8 @@ int TcpReceiver::loadToMemory(s32 clientSocket, u32 ipAddress) {
recvwait(clientSocket, (unsigned char*)&fileSizeUnc, sizeof(fileSizeUnc)); // Compressed protocol, read another 4 bytes recvwait(clientSocket, (unsigned char*)&fileSizeUnc, sizeof(fileSizeUnc)); // Compressed protocol, read another 4 bytes
} }
u32 bytesRead = 0;
struct in_addr in; struct in_addr in;
uint32_t bytesRead = 0;
in.s_addr = ipAddress; in.s_addr = ipAddress;
DEBUG_FUNCTION_LINE("transfer start\n"); DEBUG_FUNCTION_LINE("transfer start\n");
@ -112,11 +112,11 @@ int TcpReceiver::loadToMemory(s32 clientSocket, u32 ipAddress) {
// Copy rpl in memory // Copy rpl in memory
while(bytesRead < fileSize) { while(bytesRead < fileSize) {
u32 blockSize = 0x1000; uint32_t blockSize = 0x1000;
if(blockSize > (fileSize - bytesRead)) if(blockSize > (fileSize - bytesRead))
blockSize = fileSize - bytesRead; blockSize = fileSize - bytesRead;
int ret = recv(clientSocket, loadAddress + bytesRead, blockSize, 0); int32_t ret = recv(clientSocket, loadAddress + bytesRead, blockSize, 0);
if(ret <= 0) { if(ret <= 0) {
DEBUG_FUNCTION_LINE("Failure on reading file\n"); DEBUG_FUNCTION_LINE("Failure on reading file\n");
break; break;
@ -151,7 +151,7 @@ int TcpReceiver::loadToMemory(s32 clientSocket, u32 ipAddress) {
return NOT_ENOUGH_MEMORY; return NOT_ENOUGH_MEMORY;
} }
int ret = 0; int32_t ret = 0;
z_stream s; z_stream s;
memset(&s, 0, sizeof(s)); memset(&s, 0, sizeof(s));
@ -193,7 +193,7 @@ int TcpReceiver::loadToMemory(s32 clientSocket, u32 ipAddress) {
} }
uLongf f = fileSizeUnc; uLongf f = fileSizeUnc;
int result = uncompress((Bytef*)&inflatedData[0], &f, (Bytef*)loadAddress, fileSize); int32_t result = uncompress((Bytef*)&inflatedData[0], &f, (Bytef*)loadAddress, fileSize);
if(result != Z_OK) { if(result != Z_OK) {
DEBUG_FUNCTION_LINE("uncompress failed %i\n", result); DEBUG_FUNCTION_LINE("uncompress failed %i\n", result);
os_sleep(1); os_sleep(1);

14
loader/src/myutils/TcpReceiver.h
View File

@ -20,21 +20,21 @@ public:
NOT_A_VALID_PLUGIN = -5, NOT_A_VALID_PLUGIN = -5,
}; };
TcpReceiver(int port); TcpReceiver(int32_t port);
~TcpReceiver(); ~TcpReceiver();
sigslot::signal2<GuiElement *, u32> serverReceiveStart; sigslot::signal2<GuiElement *, uint32_t> serverReceiveStart;
sigslot::signal3<GuiElement *, u32, int> serverReceiveFinished; sigslot::signal3<GuiElement *, uint32_t, int32_t> serverReceiveFinished;
private: private:
void executeThread(); void executeThread();
int loadToMemory(s32 clientSocket, u32 ipAddress); int32_t loadToMemory(int32_t clientSocket, uint32_t ipAddress);
bool saveFileToSDCard(const char * path, void * buffer,u32 size); bool saveFileToSDCard(const char * path, void * buffer,uint32_t size);
bool exitRequested; bool exitRequested;
s32 serverPort; int32_t serverPort;
s32 serverSocket; int32_t serverSocket;
}; };

4
loader/src/myutils/libfat.cpp
View File

@ -4,8 +4,8 @@
#include <fat.h> #include <fat.h>
#include "common/retain_vars.h" #include "common/retain_vars.h"
int mount_libfatAll() { int32_t mount_libfatAll() {
int res = -1; int32_t res = -1;
if((res = fatInitDefault()) >= 0) { if((res = fatInitDefault()) >= 0) {
DEBUG_FUNCTION_LINE("fatInitDefault success\n"); DEBUG_FUNCTION_LINE("fatInitDefault success\n");
return 0; return 0;

4
loader/src/myutils/libfat.h
View File

@ -5,7 +5,9 @@
extern "C" { extern "C" {
#endif #endif
int mount_libfatAll(); #include <stdint.h>
int32_t mount_libfatAll();
void unmount_libfat(const char * path); void unmount_libfat(const char * path);
#ifdef __cplusplus #ifdef __cplusplus

8
loader/src/myutils/libntfs.cpp
View File

@ -7,8 +7,8 @@
#include <ntfs.h> #include <ntfs.h>
#include "common/retain_vars.h" #include "common/retain_vars.h"
int mountAllNTFS() { int32_t mountAllNTFS() {
int i; int32_t i;
// Mount all NTFS volumes on all inserted block devices // Mount all NTFS volumes on all inserted block devices
ntfs_mount_count = ntfsMountAll((ntfs_md **) &ntfs_mounts, NTFS_DEFAULT | NTFS_RECOVER); ntfs_mount_count = ntfsMountAll((ntfs_md **) &ntfs_mounts, NTFS_DEFAULT | NTFS_RECOVER);
if (ntfs_mount_count == -1) { if (ntfs_mount_count == -1) {
@ -25,9 +25,9 @@ int mountAllNTFS() {
return ntfs_mount_count; return ntfs_mount_count;
} }
int unmountAllNTFS(void) { int32_t unmountAllNTFS(void) {
if (ntfs_mounts) { if (ntfs_mounts) {
int i = 0; int32_t i = 0;
for (i = 0; i < ntfs_mount_count; i++) { for (i = 0; i < ntfs_mount_count; i++) {
ntfsUnmount(((ntfs_md *)ntfs_mounts)[i].name, true); ntfsUnmount(((ntfs_md *)ntfs_mounts)[i].name, true);
} }

4
loader/src/myutils/libntfs.h
View File

@ -1,7 +1,7 @@
#ifndef __LIBNTFS_MOUNT_H_ #ifndef __LIBNTFS_MOUNT_H_
#define __LIBNTFS_MOUNT_H_ #define __LIBNTFS_MOUNT_H_
int mountAllNTFS(void); int32_t mountAllNTFS(void);
int unmountAllNTFS(); int32_t unmountAllNTFS();
#endif #endif

40
loader/src/myutils/mocha.cpp
View File

@ -19,20 +19,20 @@ https://raw.githubusercontent.com/dimok789/mocha/
#define ARM_CODE_BASE 0x08135000 #define ARM_CODE_BASE 0x08135000
#define REPLACE_SYSCALL 0x081298BC #define REPLACE_SYSCALL 0x081298BC
//extern const u8 launch_image_tga[]; //extern const uint8_t launch_image_tga[];
//extern const u32 launch_image_tga_size; //extern const uint32_t launch_image_tga_size;
static void uhs_exploit_init(int uhs_handle, cfw_config_t * config); static void uhs_exploit_init(int32_t uhs_handle, cfw_config_t * config);
static int uhs_write32(int uhs_handle, int arm_addr, int val); static int32_t uhs_write32(int32_t uhs_handle, int32_t arm_addr, int32_t val);
//!------Variables used in exploit------ //!------Variables used in exploit------
static int *pretend_root_hub = (int*)0xF5003ABC; static int32_t *pretend_root_hub = (int32_t*)0xF5003ABC;
static int *ayylmao = (int*)0xF4500000; static int32_t *ayylmao = (int32_t*)0xF4500000;
//!------------------------------------- //!-------------------------------------
typedef struct { typedef struct {
u32 size; uint32_t size;
u8 data[0]; uint8_t data[0];
} payload_info_t; } payload_info_t;
/* YOUR ARM CODE HERE (starts at ARM_CODE_BASE) */ /* YOUR ARM CODE HERE (starts at ARM_CODE_BASE) */
@ -45,7 +45,7 @@ typedef struct {
/* ROP CHAIN STARTS HERE (0x1015BD78) */ /* ROP CHAIN STARTS HERE (0x1015BD78) */
static const unsigned int final_chain[] = { static const uint32_t final_chain[] = {
0x101236f3, // 0x00 POP {R1-R7,PC} 0x101236f3, // 0x00 POP {R1-R7,PC}
0x0, // 0x04 arg 0x0, // 0x04 arg
0x0812974C, // 0x08 stackptr CMP R3, #1; STREQ R1, [R12]; BX LR 0x0812974C, // 0x08 stackptr CMP R3, #1; STREQ R1, [R12]; BX LR
@ -236,7 +236,7 @@ static const unsigned int final_chain[] = {
REPLACE_SYSCALL, // 0x1DC start of syscall IOS_GetUpTime64 REPLACE_SYSCALL, // 0x1DC start of syscall IOS_GetUpTime64
0x4001, // 0x1E0 on > 0x4000 it flushes all data caches 0x4001, // 0x1E0 on > 0x4000 it flushes all data caches
0x0, // 0x1E0 0x0, // 0x1E0
0x1012ED4C, // 0x1E4 IOS_FlushDCache(void *ptr, unsigned int len) 0x1012ED4C, // 0x1E4 IOS_FlushDCache(void *ptr, uint32_t len)
0x0, // 0x1DC 0x0, // 0x1DC
0x0, // 0x1E0 0x0, // 0x1E0
0x10123a9f, // 0x1E4 POP {R0,R1,R4,PC} 0x10123a9f, // 0x1E4 POP {R0,R1,R4,PC}
@ -258,7 +258,7 @@ static const unsigned int final_chain[] = {
0x101312D0, 0x101312D0,
}; };
static const int second_chain[] = { static const int32_t second_chain[] = {
0x10123a9f, // 0x00 POP {R0,R1,R4,PC} 0x10123a9f, // 0x00 POP {R0,R1,R4,PC}
CHAIN_START + 0x14 + 0x4 + 0x20 - 0xF000, // 0x04 destination CHAIN_START + 0x14 + 0x4 + 0x20 - 0xF000, // 0x04 destination
0x0, // 0x08 0x0, // 0x08
@ -311,7 +311,7 @@ static const int second_chain[] = {
0x1012EA68, // 0xAC stack pivot 0x1012EA68, // 0xAC stack pivot
}; };
static void uhs_exploit_init(int dev_uhs_0_handle, cfw_config_t * config) { static void uhs_exploit_init(int32_t dev_uhs_0_handle, cfw_config_t * config) {
ayylmao[5] = 1; ayylmao[5] = 1;
ayylmao[8] = 0x500000; ayylmao[8] = 0x500000;
@ -370,23 +370,23 @@ static void uhs_exploit_init(int dev_uhs_0_handle, cfw_config_t * config) {
DCStoreRange((void*)0xF4120000, sizeof(second_chain)); DCStoreRange((void*)0xF4120000, sizeof(second_chain));
DCStoreRange((void*)0xF4130000, sizeof(final_chain)); DCStoreRange((void*)0xF4130000, sizeof(final_chain));
DCStoreRange((void*)0xF4140000, sizeof(ios_kernel_bin)); DCStoreRange((void*)0xF4140000, sizeof(ios_kernel_bin));
DCStoreRange((void*)0xF4148000, ((u32)payloads) - 0xF4148000); DCStoreRange((void*)0xF4148000, ((uint32_t)payloads) - 0xF4148000);
} }
static int uhs_write32(int dev_uhs_0_handle, int arm_addr, int val) { static int32_t uhs_write32(int32_t dev_uhs_0_handle, int32_t arm_addr, int32_t val) {
ayylmao[520] = arm_addr - 24; //! The address to be overwritten, minus 24 bytes ayylmao[520] = arm_addr - 24; //! The address to be overwritten, minus 24 bytes
DCStoreRange(ayylmao, 521 * 4); //! Make CPU fetch new data (with updated adress) DCStoreRange(ayylmao, 521 * 4); //! Make CPU fetch new data (with updated adress)
OSSleepTicks(0x200000); //! Improves stability OSSleepTicks(0x200000); //! Improves stability
int request_buffer[] = { -(0xBEA2C), val }; //! -(0xBEA2C) gets IOS_USB to read from the middle of MEM1 int32_t request_buffer[] = { -(0xBEA2C), val }; //! -(0xBEA2C) gets IOS_USB to read from the middle of MEM1
int output_buffer[32]; int32_t output_buffer[32];
return IOS_Ioctl(dev_uhs_0_handle, 0x15, request_buffer, sizeof(request_buffer), output_buffer, sizeof(output_buffer)); return IOS_Ioctl(dev_uhs_0_handle, 0x15, request_buffer, sizeof(request_buffer), output_buffer, sizeof(output_buffer));
} }
int ExecuteIOSExploit(cfw_config_t * config) { int32_t ExecuteIOSExploit(cfw_config_t * config) {
DEBUG_FUNCTION_LINE("Running ExecuteIOSExploit\n"); DEBUG_FUNCTION_LINE("Running ExecuteIOSExploit\n");
int iosuhaxFd = IOS_Open("/dev/iosuhax", 0); int32_t iosuhaxFd = IOS_Open("/dev/iosuhax", 0);
if(iosuhaxFd >= 0) { if(iosuhaxFd >= 0) {
int dummy = 0; int32_t dummy = 0;
IOS_Ioctl(iosuhaxFd, 0x03, &dummy, sizeof(dummy), &dummy, sizeof(dummy)); IOS_Ioctl(iosuhaxFd, 0x03, &dummy, sizeof(dummy), &dummy, sizeof(dummy));
@ -397,7 +397,7 @@ int ExecuteIOSExploit(cfw_config_t * config) {
} }
//! execute exploit //! execute exploit
int dev_uhs_0_handle = IOS_Open("/dev/uhs/0", 0); int32_t dev_uhs_0_handle = IOS_Open("/dev/uhs/0", 0);
if(dev_uhs_0_handle < 0) { if(dev_uhs_0_handle < 0) {
DEBUG_FUNCTION_LINE("Failed to open \"/dev/uhs/0\"\n"); DEBUG_FUNCTION_LINE("Failed to open \"/dev/uhs/0\"\n");
return dev_uhs_0_handle; return dev_uhs_0_handle;

26
loader/src/myutils/overlay_helper.cpp
View File

@ -12,13 +12,13 @@
extern "C" { extern "C" {
#endif #endif
u32 * getFromGX2Buffer(struct buffer_store store, u32 size) { uint32_t * getFromGX2Buffer(struct buffer_store store, uint32_t size) {
if(store.buffer != NULL) { if(store.buffer != NULL) {
DEBUG_FUNCTION_LINE("We try to use the GX2 buffer. Needed space %08X (%d kb), available %08X (%d kb).\n",size,size/1024,store.buffer_size,store.buffer_size/1024); DEBUG_FUNCTION_LINE("We try to use the GX2 buffer. Needed space %08X (%d kb), available %08X (%d kb).\n",size,size/1024,store.buffer_size,store.buffer_size/1024);
if(store.buffer_size >= size) { if(store.buffer_size >= size) {
memset(store.buffer,0,store.buffer_size); memset(store.buffer,0,store.buffer_size);
GX2Invalidate(GX2_INVALIDATE_CPU, store.buffer, store.buffer_size); GX2Invalidate(GX2_INVALIDATE_CPU, store.buffer, store.buffer_size);
return (u32*) store.buffer; return (uint32_t*) store.buffer;
} }
} }
return NULL; return NULL;
@ -32,18 +32,18 @@ void overlay_helper(wups_overlay_options_type_t screen, overlay_callback callbac
OSScreenInit(); OSScreenInit();
u32 * screenbuffer0 = NULL; uint32_t * screenbuffer0 = NULL;
u32 * screenbuffer1 = NULL; uint32_t * screenbuffer1 = NULL;
bool allocated_tv = false; bool allocated_tv = false;
bool allocated_drc = false; bool allocated_drc = false;
if(screen == WUPS_OVERLAY_DRC_ONLY) { if(screen == WUPS_OVERLAY_DRC_ONLY) {
u32 screen_buf1_size = OSScreenGetBufferSizeEx(1); uint32_t screen_buf1_size = OSScreenGetBufferSizeEx(1);
screenbuffer1 = getFromGX2Buffer(tv_store,screen_buf1_size); screenbuffer1 = getFromGX2Buffer(tv_store,screen_buf1_size);
if(screenbuffer1 == NULL) { if(screenbuffer1 == NULL) {
DEBUG_FUNCTION_LINE("We need to try to allocate buffer for the DRC.\n"); DEBUG_FUNCTION_LINE("We need to try to allocate buffer for the DRC.\n");
screenbuffer1 = (u32*)memalign(0x100, screen_buf1_size); screenbuffer1 = (uint32_t*)memalign(0x100, screen_buf1_size);
if(screenbuffer1 != NULL) { if(screenbuffer1 != NULL) {
memset(screenbuffer1,0,screen_buf1_size); memset(screenbuffer1,0,screen_buf1_size);
DEBUG_FUNCTION_LINE("Successfully allocated DRC buffer!.\n"); DEBUG_FUNCTION_LINE("Successfully allocated DRC buffer!.\n");
@ -51,25 +51,25 @@ void overlay_helper(wups_overlay_options_type_t screen, overlay_callback callbac
} }
} }
} else if(screen == WUPS_OVERLAY_TV_ONLY) { } else if(screen == WUPS_OVERLAY_TV_ONLY) {
u32 screen_buf0_size = OSScreenGetBufferSizeEx(0); uint32_t screen_buf0_size = OSScreenGetBufferSizeEx(0);
screenbuffer0 = getFromGX2Buffer(tv_store,screen_buf0_size); screenbuffer0 = getFromGX2Buffer(tv_store,screen_buf0_size);
if(screenbuffer0 == NULL) { if(screenbuffer0 == NULL) {
DEBUG_FUNCTION_LINE("We need to try to allocate buffer for the TV.\n"); DEBUG_FUNCTION_LINE("We need to try to allocate buffer for the TV.\n");
screenbuffer0 = (u32*)memalign(0x100, screen_buf0_size); screenbuffer0 = (uint32_t*)memalign(0x100, screen_buf0_size);
if(screenbuffer0 != NULL) { if(screenbuffer0 != NULL) {
memset(screenbuffer0,0,screen_buf0_size); memset(screenbuffer0,0,screen_buf0_size);
DEBUG_FUNCTION_LINE("Successfully allocated TV buffer!.\n"); DEBUG_FUNCTION_LINE("Successfully allocated TV buffer!.\n");
allocated_tv = true; allocated_tv = true;
} }
} }
} else if( screen == WUPS_OVERLAY_DRC_AND_TV || WUPS_OVERLAY_DRC_AND_TV_WITH_DRC_PRIO) { } else if( screen == WUPS_OVERLAY_DRC_AND_TV || screen == WUPS_OVERLAY_DRC_AND_TV_WITH_DRC_PRIO) {
// TV Buffer init. // TV Buffer init.
u32 screen_buf0_size = OSScreenGetBufferSizeEx(0); uint32_t screen_buf0_size = OSScreenGetBufferSizeEx(0);
screenbuffer0 = getFromGX2Buffer(tv_store,screen_buf0_size); screenbuffer0 = getFromGX2Buffer(tv_store,screen_buf0_size);
if(screenbuffer0 == NULL) { if(screenbuffer0 == NULL) {
DEBUG_FUNCTION_LINE("We need to try to allocate buffer for the TV.\n"); DEBUG_FUNCTION_LINE("We need to try to allocate buffer for the TV.\n");
screenbuffer0 = (u32*)memalign(0x100, screen_buf0_size); screenbuffer0 = (uint32_t*)memalign(0x100, screen_buf0_size);
if(screenbuffer0 != NULL) { if(screenbuffer0 != NULL) {
memset(screenbuffer0,0,screen_buf0_size); memset(screenbuffer0,0,screen_buf0_size);
DEBUG_FUNCTION_LINE("Successfully allocated TV buffer!.\n"); DEBUG_FUNCTION_LINE("Successfully allocated TV buffer!.\n");
@ -78,11 +78,11 @@ void overlay_helper(wups_overlay_options_type_t screen, overlay_callback callbac
} }
// DRC Buffer init. // DRC Buffer init.
u32 screen_buf1_size = OSScreenGetBufferSizeEx(1); uint32_t screen_buf1_size = OSScreenGetBufferSizeEx(1);
// Doesn't fit in the GX2 DRC buffer, we don't need to check it. // Doesn't fit in the GX2 DRC buffer, we don't need to check it.
DEBUG_FUNCTION_LINE("We need to try to allocate buffer for the DRC.\n"); DEBUG_FUNCTION_LINE("We need to try to allocate buffer for the DRC.\n");
screenbuffer1 = (u32*)memalign(0x100, screen_buf1_size); screenbuffer1 = (uint32_t*)memalign(0x100, screen_buf1_size);
if(screenbuffer1 != NULL) { if(screenbuffer1 != NULL) {
DEBUG_FUNCTION_LINE("Successfully allocated DRC buffer!.\n"); DEBUG_FUNCTION_LINE("Successfully allocated DRC buffer!.\n");
allocated_drc = true; allocated_drc = true;

8
loader/src/myutils/overlay_helper.h
View File

@ -9,10 +9,10 @@ extern "C" {
struct buffer_store { struct buffer_store {
void * buffer; void * buffer;
s32 buffer_size; uint32_t buffer_size;
s32 mode; int32_t mode;
s32 surface_format; int32_t surface_format;
vs32 buffering_mode; volatile int32_t buffering_mode;
}; };
void overlay_helper(wups_overlay_options_type_t screen, overlay_callback callback); void overlay_helper(wups_overlay_options_type_t screen, overlay_callback callback);

80
loader/src/patcher/function_patcher.cpp
View File

@ -105,20 +105,20 @@ void new_PatchInvidualMethodHooks(replacement_data_plugin_t * plugin_data) {
DEBUG_FUNCTION_LINE("Patching %d given functions\n",plugin_data->number_used_functions); DEBUG_FUNCTION_LINE("Patching %d given functions\n",plugin_data->number_used_functions);
s32 method_hooks_count = plugin_data->number_used_functions; int32_t method_hooks_count = plugin_data->number_used_functions;
u32 skip_instr = 1; uint32_t skip_instr = 1;
u32 my_instr_len = 6; uint32_t my_instr_len = 6;
u32 instr_len = my_instr_len + skip_instr + 6; uint32_t instr_len = my_instr_len + skip_instr + 6;
u32 flush_len = 4*instr_len; uint32_t flush_len = 4*instr_len;
for(s32 i = 0; i < method_hooks_count; i++) { for(int32_t i = 0; i < method_hooks_count; i++) {
replacement_data_function_t * function_data = &plugin_data->functions[i]; replacement_data_function_t * function_data = &plugin_data->functions[i];
/* Patch branches to it. */ /* Patch branches to it. */
volatile u32 *space = function_data->replace_data; volatile uint32_t *space = function_data->replace_data;
DEBUG_FUNCTION_LINE("Patching %s ...\n",function_data->function_name); DEBUG_FUNCTION_LINE("Patching %s ...\n",function_data->function_name);
if(function_data->functionType == STATIC_FUNCTION && function_data->alreadyPatched == 1) { if(function_data->functionType == STATIC_FUNCTION && function_data->alreadyPatched == 1) {
if(new_isDynamicFunction((u32)OSEffectiveToPhysical((void*)function_data->realAddr))) { if(new_isDynamicFunction((uint32_t)OSEffectiveToPhysical((void*)function_data->realAddr))) {
DEBUG_FUNCTION_LINE("INFO: The function %s is a dynamic function.\n", function_data->function_name); DEBUG_FUNCTION_LINE("INFO: The function %s is a dynamic function.\n", function_data->function_name);
function_data->functionType = DYNAMIC_FUNCTION; function_data->functionType = DYNAMIC_FUNCTION;
} else { } else {
@ -127,11 +127,11 @@ void new_PatchInvidualMethodHooks(replacement_data_plugin_t * plugin_data) {
} }
} }
u32 physical = 0; uint32_t physical = 0;
u32 repl_addr = (u32)function_data->replaceAddr; uint32_t repl_addr = (uint32_t)function_data->replaceAddr;
u32 call_addr = (u32)function_data->replaceCall; uint32_t call_addr = (uint32_t)function_data->replaceCall;
u32 real_addr = new_GetAddressOfFunction(function_data->function_name,function_data->library); uint32_t real_addr = new_GetAddressOfFunction(function_data->function_name,function_data->library);
if(!real_addr) { if(!real_addr) {
log_printf("\n"); log_printf("\n");
@ -143,7 +143,7 @@ void new_PatchInvidualMethodHooks(replacement_data_plugin_t * plugin_data) {
DEBUG_FUNCTION_LINE("%s is located at %08X!\n", function_data->function_name,real_addr); DEBUG_FUNCTION_LINE("%s is located at %08X!\n", function_data->function_name,real_addr);
} }
physical = (u32)OSEffectiveToPhysical((void*)real_addr); physical = (uint32_t)OSEffectiveToPhysical((void*)real_addr);
if(!physical) { if(!physical) {
log_printf("Error. Something is wrong with the physical address\n"); log_printf("Error. Something is wrong with the physical address\n");
continue; continue;
@ -153,10 +153,10 @@ void new_PatchInvidualMethodHooks(replacement_data_plugin_t * plugin_data) {
DEBUG_FUNCTION_LINE("%s physical is located at %08X!\n", function_data->function_name,physical); DEBUG_FUNCTION_LINE("%s physical is located at %08X!\n", function_data->function_name,physical);
} }
*(volatile u32 *)(call_addr) = (u32)(space); *(volatile uint32_t *)(call_addr) = (uint32_t)(space);
SC0x25_KernelCopyData((u32)space, physical, 4); SC0x25_KernelCopyData((uint32_t)space, physical, 4);
space++; space++;
//Only works if skip_instr == 1 //Only works if skip_instr == 1
@ -196,7 +196,7 @@ void new_PatchInvidualMethodHooks(replacement_data_plugin_t * plugin_data) {
space++; space++;
u32 repl_addr_test = (u32) space; uint32_t repl_addr_test = (uint32_t) space;
*space = 0x9061FFE0; *space = 0x9061FFE0;
space++; space++;
*space = 0x3C600000 | (((repl_addr) >> 16) & 0x0000FFFF); // lis r3, repl_addr@h *space = 0x3C600000 | (((repl_addr) >> 16) & 0x0000FFFF); // lis r3, repl_addr@h
@ -213,11 +213,11 @@ void new_PatchInvidualMethodHooks(replacement_data_plugin_t * plugin_data) {
ICInvalidateRange((unsigned char*)(space - instr_len), flush_len); ICInvalidateRange((unsigned char*)(space - instr_len), flush_len);
//setting jump back //setting jump back
u32 replace_instr = 0x48000002 | (repl_addr_test & 0x03fffffc); uint32_t replace_instr = 0x48000002 | (repl_addr_test & 0x03fffffc);
ICInvalidateRange(&replace_instr, 4); ICInvalidateRange(&replace_instr, 4);
DCFlushRange(&replace_instr, 4); DCFlushRange(&replace_instr, 4);
SC0x25_KernelCopyData(physical, (u32)OSEffectiveToPhysical(&replace_instr), 4); SC0x25_KernelCopyData(physical, (uint32_t)OSEffectiveToPhysical(&replace_instr), 4);
ICInvalidateRange((void*)(real_addr), 4); ICInvalidateRange((void*)(real_addr), 4);
DCFlushRange((void*)(real_addr), 4); DCFlushRange((void*)(real_addr), 4);
@ -236,9 +236,9 @@ void new_RestoreInvidualInstructions(replacement_data_plugin_t * plugin_data) {
new_resetLibs(); new_resetLibs();
DEBUG_FUNCTION_LINE("Restoring given functions!\n"); DEBUG_FUNCTION_LINE("Restoring given functions!\n");
s32 method_hooks_count = plugin_data->number_used_functions; int32_t method_hooks_count = plugin_data->number_used_functions;
for(s32 i = 0; i < method_hooks_count; i++) { for(int32_t i = 0; i < method_hooks_count; i++) {
replacement_data_function_t * function_data = &plugin_data->functions[i]; replacement_data_function_t * function_data = &plugin_data->functions[i];
DEBUG_FUNCTION_LINE("Restoring %s... ",function_data->function_name); DEBUG_FUNCTION_LINE("Restoring %s... ",function_data->function_name);
@ -247,14 +247,14 @@ void new_RestoreInvidualInstructions(replacement_data_plugin_t * plugin_data) {
continue; continue;
} }
u32 real_addr = new_GetAddressOfFunction(function_data->function_name,function_data->library); uint32_t real_addr = new_GetAddressOfFunction(function_data->function_name,function_data->library);
if(!real_addr) { if(!real_addr) {
log_printf("OSDynLoad_FindExport failed for %s\n", function_data->function_name); log_printf("OSDynLoad_FindExport failed for %s\n", function_data->function_name);
continue; continue;
} }
u32 physical = (u32)OSEffectiveToPhysical((void*)real_addr); uint32_t physical = (uint32_t)OSEffectiveToPhysical((void*)real_addr);
if(!physical) { if(!physical) {
log_printf("Something is wrong with the physical address\n"); log_printf("Something is wrong with the physical address\n");
continue; continue;
@ -263,11 +263,11 @@ void new_RestoreInvidualInstructions(replacement_data_plugin_t * plugin_data) {
if(new_isDynamicFunction(physical)) { if(new_isDynamicFunction(physical)) {
log_printf("Its a dynamic function. We don't need to restore it!\n",function_data->function_name); log_printf("Its a dynamic function. We don't need to restore it!\n",function_data->function_name);
} else { } else {
physical = (u32)OSEffectiveToPhysical((void*)function_data->realAddr); //When its an static function, we need to use the old location physical = (uint32_t)OSEffectiveToPhysical((void*)function_data->realAddr); //When its an static function, we need to use the old location
if(DEBUG_LOG_DYN) { if(DEBUG_LOG_DYN) {
DEBUG_FUNCTION_LINE("Restoring %08X to %08X\n",(u32)function_data->restoreInstruction,physical); DEBUG_FUNCTION_LINE("Restoring %08X to %08X\n",(uint32_t)function_data->restoreInstruction,physical);
} }
SC0x25_KernelCopyData(physical,(u32)&function_data->restoreInstruction, 4); SC0x25_KernelCopyData(physical,(uint32_t)&function_data->restoreInstruction, 4);
if(DEBUG_LOG_DYN) { if(DEBUG_LOG_DYN) {
DEBUG_FUNCTION_LINE("ICInvalidateRange %08X\n",(void*)function_data->realAddr); DEBUG_FUNCTION_LINE("ICInvalidateRange %08X\n",(void*)function_data->realAddr);
} }
@ -281,37 +281,37 @@ void new_RestoreInvidualInstructions(replacement_data_plugin_t * plugin_data) {
DEBUG_FUNCTION_LINE("Done with restoring given functions!\n"); DEBUG_FUNCTION_LINE("Done with restoring given functions!\n");
} }
s32 new_isDynamicFunction(u32 physicalAddress) { int32_t new_isDynamicFunction(uint32_t physicalAddress) {
if((physicalAddress & 0x80000000) == 0x80000000) { if((physicalAddress & 0x80000000) == 0x80000000) {
return 1; return 1;
} }
return 0; return 0;
} }
u32 new_GetAddressOfFunction(const char * functionName,wups_loader_library_type_t library) { uint32_t new_GetAddressOfFunction(const char * functionName,wups_loader_library_type_t library) {
u32 real_addr = 0; uint32_t real_addr = 0;
if(strcmp(functionName, "OSDynLoad_Acquire") == 0) { if(strcmp(functionName, "OSDynLoad_Acquire") == 0) {
memcpy(&real_addr, &OSDynLoad_Acquire, 4); memcpy(&real_addr, &OSDynLoad_Acquire, 4);
return real_addr; return real_addr;
} else if(strcmp(functionName, "LiWaitOneChunk") == 0) { } else if(strcmp(functionName, "LiWaitOneChunk") == 0) {
real_addr = (u32)addr_LiWaitOneChunk; real_addr = (uint32_t)addr_LiWaitOneChunk;
return real_addr; return real_addr;
} else if(strcmp(functionName, "LiBounceOneChunk") == 0) { } else if(strcmp(functionName, "LiBounceOneChunk") == 0) {
//! not required on firmwares above 3.1.0 //! not required on firmwares above 3.1.0
if(OS_FIRMWARE >= 400) if(OS_FIRMWARE >= 400)
return 0; return 0;
u32 addr_LiBounceOneChunk = 0x010003A0; uint32_t addr_LiBounceOneChunk = 0x010003A0;
real_addr = (u32)addr_LiBounceOneChunk; real_addr = (uint32_t)addr_LiBounceOneChunk;
return real_addr; return real_addr;
} }
u32 rpl_handle = 0; uint32_t rpl_handle = 0;
int rpl_handles_size = sizeof rpl_handles / sizeof rpl_handles[0]; int32_t rpl_handles_size = sizeof rpl_handles / sizeof rpl_handles[0];
for(int i = 0; i< rpl_handles_size; i++) { for(int32_t i = 0; i< rpl_handles_size; i++) {
if(rpl_handles[i].library == library) { if(rpl_handles[i].library == library) {
if(rpl_handles[i].handle == 0) { if(rpl_handles[i].handle == 0) {
DEBUG_FUNCTION_LINE("Lets acquire handle for rpl: %s\n",rpl_handles[i].rplname); DEBUG_FUNCTION_LINE("Lets acquire handle for rpl: %s\n",rpl_handles[i].rplname);
@ -338,13 +338,13 @@ u32 new_GetAddressOfFunction(const char * functionName,wups_loader_library_type_
return 0; return 0;
} }
if((library == WUPS_LOADER_LIBRARY_NN_ACP) && (u32)(*(volatile u32*)(real_addr) & 0x48000002) == 0x48000000) { if((library == WUPS_LOADER_LIBRARY_NN_ACP) && (uint32_t)(*(volatile uint32_t*)(real_addr) & 0x48000002) == 0x48000000) {
u32 address_diff = (u32)(*(volatile u32*)(real_addr) & 0x03FFFFFC); uint32_t address_diff = (uint32_t)(*(volatile uint32_t*)(real_addr) & 0x03FFFFFC);
if((address_diff & 0x03000000) == 0x03000000) { if((address_diff & 0x03000000) == 0x03000000) {
address_diff |= 0xFC000000; address_diff |= 0xFC000000;
} }
real_addr += (s32)address_diff; real_addr += (int32_t)address_diff;
if((u32)(*(volatile u32*)(real_addr) & 0x48000002) == 0x48000000) { if((uint32_t)(*(volatile uint32_t*)(real_addr) & 0x48000002) == 0x48000000) {
return 0; return 0;
} }
} }
@ -353,9 +353,9 @@ u32 new_GetAddressOfFunction(const char * functionName,wups_loader_library_type_
} }
void new_resetLibs() { void new_resetLibs() {
int rpl_handles_size = sizeof rpl_handles / sizeof rpl_handles[0]; int32_t rpl_handles_size = sizeof rpl_handles / sizeof rpl_handles[0];
for(int i = 0; i< rpl_handles_size; i++) { for(int32_t i = 0; i< rpl_handles_size; i++) {
if(rpl_handles[i].handle != 0) { if(rpl_handles[i].handle != 0) {
DEBUG_FUNCTION_LINE("Resetting handle for rpl: %s\n",rpl_handles[i].rplname); DEBUG_FUNCTION_LINE("Resetting handle for rpl: %s\n",rpl_handles[i].rplname);
} }

28
loader/src/patcher/function_patcher.h
View File

@ -29,7 +29,7 @@ extern "C" {
struct rpl_handling { struct rpl_handling {
wups_loader_library_type_t library; wups_loader_library_type_t library;
const char rplname[15]; const char rplname[15];
u32 handle; uint32_t handle;
}; };
#define STATIC_FUNCTION 0 #define STATIC_FUNCTION 0
#define DYNAMIC_FUNCTION 1 #define DYNAMIC_FUNCTION 1
@ -40,15 +40,15 @@ struct rpl_handling {
#define MAXIMUM_FUNCTION_NAME_LENGTH 61 #define MAXIMUM_FUNCTION_NAME_LENGTH 61
struct replacement_data_function_t { struct replacement_data_function_t {
u32 replaceAddr; /* [needs to be filled] Address of our replacement function */ uint32_t replaceAddr; /* [needs to be filled] Address of our replacement function */
u32 replaceCall; /* [needs to be filled] Address to access the real_function */ uint32_t replaceCall; /* [needs to be filled] Address to access the real_function */
wups_loader_library_type_t library; /* [needs to be filled] rpl where the function we want to replace is. */ wups_loader_library_type_t library; /* [needs to be filled] rpl where the function we want to replace is. */
char function_name[MAXIMUM_FUNCTION_NAME_LENGTH]; /* [needs to be filled] name of the function we want to replace */ char function_name[MAXIMUM_FUNCTION_NAME_LENGTH]; /* [needs to be filled] name of the function we want to replace */
u32 realAddr; /* [will be filled] Address of the real function we want to replace. */ uint32_t realAddr; /* [will be filled] Address of the real function we want to replace. */
volatile u32 replace_data [FUNCTION_PATCHER_METHOD_STORE_SIZE]; /* [will be filled] Space for us to store some jump instructions */ volatile uint32_t replace_data [FUNCTION_PATCHER_METHOD_STORE_SIZE]; /* [will be filled] Space for us to store some jump instructions */
u32 restoreInstruction; /* [will be filled] Copy of the instruction we replaced to jump to our code. */ uint32_t restoreInstruction; /* [will be filled] Copy of the instruction we replaced to jump to our code. */
u8 functionType; /* [will be filled] */ uint8_t functionType; /* [will be filled] */
u8 alreadyPatched; /* [will be filled] */ uint8_t alreadyPatched; /* [will be filled] */
}; };
struct replacement_data_hook_t { struct replacement_data_hook_t {
@ -62,25 +62,25 @@ struct replacement_data_hook_t {
struct replacement_data_plugin_t { struct replacement_data_plugin_t {
char path[MAXIMUM_PLUGIN_PATH_NAME_LENGTH] = ""; // Path where the plugin is stored char path[MAXIMUM_PLUGIN_PATH_NAME_LENGTH] = ""; // Path where the plugin is stored
char plugin_name[MAXIMUM_PLUGIN_NAME_LENGTH] = ""; // Name of this plugin char plugin_name[MAXIMUM_PLUGIN_NAME_LENGTH] = ""; // Name of this plugin
int priority; // Priority of this plugin int32_t priority; // Priority of this plugin
int number_used_functions; // Number of used function. Maximum is MAXIMUM_FUNCTION_PER_PLUGIN int32_t number_used_functions; // Number of used function. Maximum is MAXIMUM_FUNCTION_PER_PLUGIN
replacement_data_function_t functions[MAXIMUM_FUNCTION_PER_PLUGIN]; // Replacement information for each function. replacement_data_function_t functions[MAXIMUM_FUNCTION_PER_PLUGIN]; // Replacement information for each function.
int number_used_hooks; // Number of used hooks. Maximum is MAXIMUM_HOOKS_PER_PLUGIN int32_t number_used_hooks; // Number of used hooks. Maximum is MAXIMUM_HOOKS_PER_PLUGIN
replacement_data_hook_t hooks[MAXIMUM_HOOKS_PER_PLUGIN]; // Replacement information for each function. replacement_data_hook_t hooks[MAXIMUM_HOOKS_PER_PLUGIN]; // Replacement information for each function.
}; };
#define MAXIMUM_PLUGINS 32 #define MAXIMUM_PLUGINS 32
struct replacement_data_t { struct replacement_data_t {
int number_used_plugins = 0; // Number of used function. Maximum is MAXIMUM_FUNCTION_PER_PLUGIN int32_t number_used_plugins = 0; // Number of used function. Maximum is MAXIMUM_FUNCTION_PER_PLUGIN
replacement_data_plugin_t plugin_data[MAXIMUM_PLUGINS]; replacement_data_plugin_t plugin_data[MAXIMUM_PLUGINS];
}; };
void new_PatchInvidualMethodHooks(replacement_data_plugin_t * data); void new_PatchInvidualMethodHooks(replacement_data_plugin_t * data);
void new_RestoreInvidualInstructions(replacement_data_plugin_t * plugin_data); void new_RestoreInvidualInstructions(replacement_data_plugin_t * plugin_data);
u32 new_GetAddressOfFunction(const char * functionName,wups_loader_library_type_t library); uint32_t new_GetAddressOfFunction(const char * functionName,wups_loader_library_type_t library);
s32 new_isDynamicFunction(u32 physicalAddress); int32_t new_isDynamicFunction(uint32_t physicalAddress);
void new_resetLibs(); void new_resetLibs();
#ifdef __cplusplus #ifdef __cplusplus

18
loader/src/patcher/hooks_patcher.cpp
View File

@ -19,8 +19,8 @@ DECL(void, __PPCExit, void) {
real___PPCExit(); real___PPCExit();
} }
DECL(u32, ProcUIProcessMessages, u32 u) { DECL(uint32_t, ProcUIProcessMessages, uint32_t u) {
u32 res = real_ProcUIProcessMessages(u); uint32_t res = real_ProcUIProcessMessages(u);
// Only continue if we are in the "right" application. // Only continue if we are in the "right" application.
if(res != gAppStatus && OSGetTitleID() == gGameTitleID) { if(res != gAppStatus && OSGetTitleID() == gGameTitleID) {
DEBUG_FUNCTION_LINE("App status changed from %d to %d \n",gAppStatus,res); DEBUG_FUNCTION_LINE("App status changed from %d to %d \n",gAppStatus,res);
@ -35,7 +35,7 @@ DECL(u32, ProcUIProcessMessages, u32 u) {
return res; return res;
} }
DECL(void, GX2SetTVBuffer, void *buffer, u32 buffer_size, s32 tv_render_mode, s32 format, s32 buffering_mode) { DECL(void, GX2SetTVBuffer, void *buffer, uint32_t buffer_size, int32_t tv_render_mode, int32_t format, int32_t buffering_mode) {
tv_store.buffer = buffer; tv_store.buffer = buffer;
tv_store.buffer_size = buffer_size; tv_store.buffer_size = buffer_size;
tv_store.mode = tv_render_mode; tv_store.mode = tv_render_mode;
@ -45,7 +45,7 @@ DECL(void, GX2SetTVBuffer, void *buffer, u32 buffer_size, s32 tv_render_mode, s3
return real_GX2SetTVBuffer(buffer,buffer_size,tv_render_mode,format,buffering_mode); return real_GX2SetTVBuffer(buffer,buffer_size,tv_render_mode,format,buffering_mode);
} }
DECL(void, GX2SetDRCBuffer, void *buffer, u32 buffer_size, s32 drc_mode, s32 surface_format, s32 buffering_mode) { DECL(void, GX2SetDRCBuffer, void *buffer, uint32_t buffer_size, int32_t drc_mode, int32_t surface_format, int32_t buffering_mode) {
drc_store.buffer = buffer; drc_store.buffer = buffer;
drc_store.buffer_size = buffer_size; drc_store.buffer_size = buffer_size;
drc_store.mode = drc_mode; drc_store.mode = drc_mode;
@ -60,9 +60,9 @@ DECL(void, GX2WaitForVsync, void) {
real_GX2WaitForVsync(); real_GX2WaitForVsync();
} }
u8 vpadPressCooldown = 0xFF; uint8_t vpadPressCooldown = 0xFF;
DECL(int, VPADRead, int chan, VPADData *buffer, u32 buffer_size, s32 *error) { DECL(int32_t, VPADRead, int32_t chan, VPADData *buffer, uint32_t buffer_size, int32_t *error) {
int result = real_VPADRead(chan, buffer, buffer_size, error); int32_t result = real_VPADRead(chan, buffer, buffer_size, error);
if(result > 0 && (buffer[0].btns_h == (VPAD_BUTTON_PLUS | VPAD_BUTTON_R | VPAD_BUTTON_L)) && vpadPressCooldown == 0 && OSIsHomeButtonMenuEnabled()) { if(result > 0 && (buffer[0].btns_h == (VPAD_BUTTON_PLUS | VPAD_BUTTON_R | VPAD_BUTTON_L)) && vpadPressCooldown == 0 && OSIsHomeButtonMenuEnabled()) {
if(MemoryMapping::isMemoryMapped()) { if(MemoryMapping::isMemoryMapped()) {
@ -89,8 +89,8 @@ hooks_magic_t method_hooks_hooks[] __attribute__((section(".data"))) = {
}; };
u32 method_hooks_size_hooks __attribute__((section(".data"))) = sizeof(method_hooks_hooks) / sizeof(hooks_magic_t); uint32_t method_hooks_size_hooks __attribute__((section(".data"))) = sizeof(method_hooks_hooks) / sizeof(hooks_magic_t);
//! buffer to store our instructions needed for our replacements //! buffer to store our instructions needed for our replacements
volatile u32 method_calls_hooks[sizeof(method_hooks_hooks) / sizeof(hooks_magic_t) * FUNCTION_PATCHER_METHOD_STORE_SIZE] __attribute__((section(".data"))); volatile uint32_t method_calls_hooks[sizeof(method_hooks_hooks) / sizeof(hooks_magic_t) * FUNCTION_PATCHER_METHOD_STORE_SIZE] __attribute__((section(".data")));

4
loader/src/patcher/hooks_patcher.h
View File

@ -8,8 +8,8 @@ extern "C" {
#endif #endif
extern hooks_magic_t method_hooks_hooks[]; extern hooks_magic_t method_hooks_hooks[];
extern u32 method_hooks_size_hooks; extern uint32_t method_hooks_size_hooks;
extern volatile u32 method_calls_hooks[]; extern volatile uint32_t method_calls_hooks[];
#ifdef __cplusplus #ifdef __cplusplus
} }

26
loader/src/plugin/DynamicLinkingHelper.cpp
View File

@ -13,7 +13,7 @@ dyn_linking_function_t * DynamicLinkingHelper::getOrAddFunctionEntryByName(const
return NULL; return NULL;
} }
dyn_linking_function_t * result = NULL; dyn_linking_function_t * result = NULL;
for(int i = 0; i < DYN_LINK_FUNCTION_LIST_LENGTH; i++) { for(int32_t i = 0; i < DYN_LINK_FUNCTION_LIST_LENGTH; i++) {
dyn_linking_function_t * curEntry = &gbl_dyn_linking_data.functions[i]; dyn_linking_function_t * curEntry = &gbl_dyn_linking_data.functions[i];
if(strlen(curEntry->functionName) == 0) { if(strlen(curEntry->functionName) == 0) {
strncpy(curEntry->functionName,functionName,DYN_LINK_FUNCTION_NAME_LENGTH); strncpy(curEntry->functionName,functionName,DYN_LINK_FUNCTION_NAME_LENGTH);
@ -43,7 +43,7 @@ dyn_linking_import_t * DynamicLinkingHelper::getOrAddImport(const char* importNa
return NULL; return NULL;
} }
dyn_linking_import_t * result = NULL; dyn_linking_import_t * result = NULL;
for(int i = 0; i < DYN_LINK_IMPORT_LIST_LENGTH; i++) { for(int32_t i = 0; i < DYN_LINK_IMPORT_LIST_LENGTH; i++) {
dyn_linking_import_t * curEntry = &gbl_dyn_linking_data.imports[i]; dyn_linking_import_t * curEntry = &gbl_dyn_linking_data.imports[i];
if(strlen(curEntry->importName) == 0) { if(strlen(curEntry->importName) == 0) {
strncpy(curEntry->importName,importName,DYN_LINK_IMPORT_NAME_LENGTH); strncpy(curEntry->importName,importName,DYN_LINK_IMPORT_NAME_LENGTH);
@ -62,7 +62,7 @@ bool DynamicLinkingHelper::addReloationEntry(RelocationData * relocationData) {
return addReloationEntry(relocationData->getType(), relocationData->getOffset(), relocationData->getAddend(), relocationData->getDestination(), relocationData->getName(), relocationData->getImportRPLInformation()); return addReloationEntry(relocationData->getType(), relocationData->getOffset(), relocationData->getAddend(), relocationData->getDestination(), relocationData->getName(), relocationData->getImportRPLInformation());
} }
bool DynamicLinkingHelper::addReloationEntry(char type, size_t offset, int addend, void *destination, std::string name, ImportRPLInformation * rplInfo) { bool DynamicLinkingHelper::addReloationEntry(char type, size_t offset, int32_t addend, void *destination, std::string name, ImportRPLInformation * rplInfo) {
dyn_linking_import_t * importInfoGbl = DynamicLinkingHelper::getOrAddImport(rplInfo->getName().c_str(),rplInfo->isData()); dyn_linking_import_t * importInfoGbl = DynamicLinkingHelper::getOrAddImport(rplInfo->getName().c_str(),rplInfo->isData());
if(importInfoGbl == NULL) { if(importInfoGbl == NULL) {
DEBUG_FUNCTION_LINE("Getting import info failed. Probably maximum of %d rpl files to import reached.\n",DYN_LINK_IMPORT_LIST_LENGTH); DEBUG_FUNCTION_LINE("Getting import info failed. Probably maximum of %d rpl files to import reached.\n",DYN_LINK_IMPORT_LIST_LENGTH);
@ -78,8 +78,8 @@ bool DynamicLinkingHelper::addReloationEntry(char type, size_t offset, int adden
return addReloationEntry(type, offset, addend, destination, functionInfo, importInfoGbl); return addReloationEntry(type, offset, addend, destination, functionInfo, importInfoGbl);
} }
bool DynamicLinkingHelper::addReloationEntry(char type, size_t offset, int addend, void *destination, dyn_linking_function_t * functionName, dyn_linking_import_t * importInfo) { bool DynamicLinkingHelper::addReloationEntry(char type, size_t offset, int32_t addend, void *destination, dyn_linking_function_t * functionName, dyn_linking_import_t * importInfo) {
for(int i = 0; i < DYN_LINK_RELOCATION_LIST_LENGTH; i++) { for(int32_t i = 0; i < DYN_LINK_RELOCATION_LIST_LENGTH; i++) {
dyn_linking_relocation_entry_t * curEntry = &gbl_dyn_linking_data.entries[i]; dyn_linking_relocation_entry_t * curEntry = &gbl_dyn_linking_data.entries[i];
if(curEntry->functionEntry != NULL) { if(curEntry->functionEntry != NULL) {
continue; continue;
@ -98,7 +98,7 @@ bool DynamicLinkingHelper::addReloationEntry(char type, size_t offset, int adden
std::vector<dyn_linking_relocation_entry_t *> DynamicLinkingHelper::getAllValidDynamicLinkingRelocations() { std::vector<dyn_linking_relocation_entry_t *> DynamicLinkingHelper::getAllValidDynamicLinkingRelocations() {
std::vector<dyn_linking_relocation_entry_t *> result; std::vector<dyn_linking_relocation_entry_t *> result;
for(int i = 0; i < DYN_LINK_RELOCATION_LIST_LENGTH; i++) { for(int32_t i = 0; i < DYN_LINK_RELOCATION_LIST_LENGTH; i++) {
if(gbl_dyn_linking_data.entries[i].functionEntry == NULL) { if(gbl_dyn_linking_data.entries[i].functionEntry == NULL) {
break; break;
} }
@ -133,7 +133,7 @@ bool DynamicLinkingHelper::fillRelocations(std::vector<dyn_linking_relocation_en
} else { } else {
OSDynLoad_Acquire(importEntry->importName, &importEntry->handle); OSDynLoad_Acquire(importEntry->importName, &importEntry->handle);
} }
int isData = 0; int32_t isData = 0;
if(importEntry->isData) { if(importEntry->isData) {
isData = 1; isData = 1;
//DEBUG_FUNCTION_LINE("isData\n"); //DEBUG_FUNCTION_LINE("isData\n");
@ -154,8 +154,8 @@ bool DynamicLinkingHelper::fillRelocations(std::vector<dyn_linking_relocation_en
80 61 ff e0 lwz r3,-32(r1) 80 61 ff e0 lwz r3,-32(r1)
4e 80 04 20 bctr*/ 4e 80 04 20 bctr*/
functionEntry->big_jump[0] = 0x9061FFE0; functionEntry->big_jump[0] = 0x9061FFE0;
functionEntry->big_jump[1] = 0x3C600000 | ((((u32) functionEntry->address) >> 16) & 0x0000FFFF); // lis r3, real_addr@h functionEntry->big_jump[1] = 0x3C600000 | ((((uint32_t) functionEntry->address) >> 16) & 0x0000FFFF); // lis r3, real_addr@h
functionEntry->big_jump[2] = 0x60630000 | (((u32) functionEntry->address) & 0x0000ffff); // ori r3, r3, real_addr@l functionEntry->big_jump[2] = 0x60630000 | (((uint32_t) functionEntry->address) & 0x0000ffff); // ori r3, r3, real_addr@l
functionEntry->big_jump[3] = 0x7C6903A6; // mtctr r3 functionEntry->big_jump[3] = 0x7C6903A6; // mtctr r3
functionEntry->big_jump[4] = 0x8061FFE0; // lwz r3,-32(r1) functionEntry->big_jump[4] = 0x8061FFE0; // lwz r3,-32(r1)
functionEntry->big_jump[5] = 0x4E800420; // bctr functionEntry->big_jump[5] = 0x4E800420; // bctr
@ -169,14 +169,14 @@ bool DynamicLinkingHelper::fillRelocations(std::vector<dyn_linking_relocation_en
//DEBUG_FUNCTION_LINE("We cached the address of function %s :%08X\n",functionEntry->functionName,functionEntry->address); //DEBUG_FUNCTION_LINE("We cached the address of function %s :%08X\n",functionEntry->functionName,functionEntry->address);
} }
//DEBUG_FUNCTION_LINE("Linking: t: %02X o: %08X a: %d dest: %08X tar: %08X big_j: %08X\n",curEntry->type, curEntry->offset, curEntry->addend, curEntry->destination, functionEntry->address, (u32) functionEntry->big_jump); //DEBUG_FUNCTION_LINE("Linking: t: %02X o: %08X a: %d dest: %08X tar: %08X big_j: %08X\n",curEntry->type, curEntry->offset, curEntry->addend, curEntry->destination, functionEntry->address, (uint32_t) functionEntry->big_jump);
DEBUG_FUNCTION_LINE("Resolving relocation to %s\n",functionEntry->functionName); DEBUG_FUNCTION_LINE("Resolving relocation to %s\n",functionEntry->functionName);
if(!curEntry->importEntry->isData && (u32) functionEntry->address > 0x04000000) { if(!curEntry->importEntry->isData && (uint32_t) functionEntry->address > 0x04000000) {
ElfTools::elfLinkOne(curEntry->type, curEntry->offset, curEntry->addend, curEntry->destination, (u32) functionEntry->big_jump); ElfTools::elfLinkOne(curEntry->type, curEntry->offset, curEntry->addend, curEntry->destination, (uint32_t) functionEntry->big_jump);
} else { } else {
ElfTools::elfLinkOne(curEntry->type, curEntry->offset, curEntry->addend, curEntry->destination, (u32) functionEntry->address); ElfTools::elfLinkOne(curEntry->type, curEntry->offset, curEntry->addend, curEntry->destination, (uint32_t) functionEntry->address);
} }
} }

4
loader/src/plugin/DynamicLinkingHelper.h
View File

@ -67,9 +67,9 @@ public:
bool addReloationEntry(RelocationData * relocationData); bool addReloationEntry(RelocationData * relocationData);
bool addReloationEntry(char type, size_t offset, int addend, void *destination, std::string name, ImportRPLInformation * rplInfo); bool addReloationEntry(char type, size_t offset, int32_t addend, void *destination, std::string name, ImportRPLInformation * rplInfo);
bool addReloationEntry(char type, size_t offset, int addend, void *destination, dyn_linking_function_t * functionName, dyn_linking_import_t * importInfo); bool addReloationEntry(char type, size_t offset, int32_t addend, void *destination, dyn_linking_function_t * functionName, dyn_linking_import_t * importInfo);
std::vector<dyn_linking_relocation_entry_t *> getAllValidDynamicLinkingRelocations(); std::vector<dyn_linking_relocation_entry_t *> getAllValidDynamicLinkingRelocations();

42
loader/src/plugin/ElfTools.cpp
View File

@ -208,7 +208,7 @@ bool ElfTools::elfLink(Elf *elf, size_t shndx, void *destination, Elf32_Sym *sym
reloc->address = destination; reloc->address = destination;
reloc->offset = rel[i].r_offset; reloc->offset = rel[i].r_offset;
reloc->type = ELF32_R_TYPE(rel[i].r_info); reloc->type = ELF32_R_TYPE(rel[i].r_info);
reloc->addend = *(int *)((char *)destination + rel[i].r_offset); reloc->addend = *(int32_t *)((char *)destination + rel[i].r_offset);
continue; continue;
*/ */
@ -230,7 +230,7 @@ bool ElfTools::elfLink(Elf *elf, size_t shndx, void *destination, Elf32_Sym *sym
} }
} }
if (!ElfTools::elfLinkOne(ELF32_R_TYPE(rel[i].r_info), rel[i].r_offset, *(int *)((char *)destination + rel[i].r_offset), destination, symbol_addr)) { if (!ElfTools::elfLinkOne(ELF32_R_TYPE(rel[i].r_info), rel[i].r_offset, *(int32_t *)((char *)destination + rel[i].r_offset), destination, symbol_addr)) {
DEBUG_FUNCTION_LINE("elfLinkOne failed\n"); DEBUG_FUNCTION_LINE("elfLinkOne failed\n");
return false; return false;
} }
@ -268,11 +268,11 @@ bool ElfTools::elfLink(Elf *elf, size_t shndx, void *destination, Elf32_Sym *sym
break; break;
} }
case SHN_COMMON: { case SHN_COMMON: {
u32 align = symtab[symbol].st_value; uint32_t align = symtab[symbol].st_value;
u32 size = symtab[symbol].st_size; uint32_t size = symtab[symbol].st_size;
uint32_t address = pluginData->getMemoryForCommonBySymbol(symbol, align, size); uint32_t address = pluginData->getMemoryForCommonBySymbol(symbol, align, size);
if(address == NULL){ if(address == 0){
DEBUG_FUNCTION_LINE("Failed to get memory for common relocation\n"); DEBUG_FUNCTION_LINE("Failed to get memory for common relocation\n");
return false; return false;
} }
@ -372,8 +372,8 @@ bool ElfTools::elfLink(Elf *elf, size_t shndx, void *destination, Elf32_Sym *sym
return true; return true;
} }
bool ElfTools::elfLinkOne(char type, size_t offset, int addend, void *destination, uint32_t symbol_addr) { bool ElfTools::elfLinkOne(char type, size_t offset, int32_t addend, void *destination, uint32_t symbol_addr) {
int value; int32_t value;
char *target = (char *)destination + offset; char *target = (char *)destination + offset;
bool result = false; bool result = false;
@ -389,7 +389,7 @@ bool ElfTools::elfLinkOne(char type, size_t offset, int addend, void *destinatio
case R_PPC_ADDR14_BRNTAKEN: case R_PPC_ADDR14_BRNTAKEN:
case R_PPC_UADDR32: case R_PPC_UADDR32:
case R_PPC_UADDR16: { case R_PPC_UADDR16: {
value = (int)symbol_addr + addend; value = (int32_t)symbol_addr + addend;
break; break;
} }
case R_PPC_REL24: case R_PPC_REL24:
@ -400,7 +400,7 @@ bool ElfTools::elfLinkOne(char type, size_t offset, int addend, void *destinatio
case R_PPC_REL14_BRNTAKEN: case R_PPC_REL14_BRNTAKEN:
case R_PPC_REL32: case R_PPC_REL32:
case R_PPC_ADDR30: { case R_PPC_ADDR30: {
value = (int)symbol_addr + addend - (int)target; value = (int32_t)symbol_addr + addend - (int32_t)target;
break; break;
} }
case R_PPC_SECTOFF: case R_PPC_SECTOFF:
@ -415,7 +415,7 @@ bool ElfTools::elfLinkOne(char type, size_t offset, int addend, void *destinatio
case R_PPC_EMB_NADDR16_LO: case R_PPC_EMB_NADDR16_LO:
case R_PPC_EMB_NADDR16_HI: case R_PPC_EMB_NADDR16_HI:
case R_PPC_EMB_NADDR16_HA: { case R_PPC_EMB_NADDR16_HA: {
value = addend - (int)symbol_addr; value = addend - (int32_t)symbol_addr;
break; break;
} }
default: default:
@ -429,15 +429,15 @@ bool ElfTools::elfLinkOne(char type, size_t offset, int addend, void *destinatio
case R_PPC_REL32: case R_PPC_REL32:
case R_PPC_SECTOFF: case R_PPC_SECTOFF:
case R_PPC_EMB_NADDR32: { case R_PPC_EMB_NADDR32: {
*(int *)target = value; *(int32_t *)target = value;
break; break;
} }
case R_PPC_ADDR24: case R_PPC_ADDR24:
case R_PPC_PLTREL24: case R_PPC_PLTREL24:
case R_PPC_LOCAL24PC: case R_PPC_LOCAL24PC:
case R_PPC_REL24: { case R_PPC_REL24: {
*(int *)target = *(int32_t *)target =
(*(int *)target & 0xfc000003) | (value & 0x03fffffc); (*(int32_t *)target & 0xfc000003) | (value & 0x03fffffc);
break; break;
} }
case R_PPC_ADDR16: case R_PPC_ADDR16:
@ -466,26 +466,26 @@ bool ElfTools::elfLinkOne(char type, size_t offset, int addend, void *destinatio
} }
case R_PPC_ADDR14: case R_PPC_ADDR14:
case R_PPC_REL14: { case R_PPC_REL14: {
*(int *)target = *(int32_t *)target =
(*(int *)target & 0xffff0003) | (value & 0x0000fffc); (*(int32_t *)target & 0xffff0003) | (value & 0x0000fffc);
break; break;
} }
case R_PPC_ADDR14_BRTAKEN: case R_PPC_ADDR14_BRTAKEN:
case R_PPC_REL14_BRTAKEN: { case R_PPC_REL14_BRTAKEN: {
*(int *)target = *(int32_t *)target =
(*(int *)target & 0xffdf0003) | (value & 0x0000fffc) | (*(int32_t *)target & 0xffdf0003) | (value & 0x0000fffc) |
0x00200000; 0x00200000;
break; break;
} }
case R_PPC_ADDR14_BRNTAKEN: case R_PPC_ADDR14_BRNTAKEN:
case R_PPC_REL14_BRNTAKEN: { case R_PPC_REL14_BRNTAKEN: {
*(int *)target = *(int32_t *)target =
(*(int *)target & 0xffdf0003) | (value & 0x0000fffc); (*(int32_t *)target & 0xffdf0003) | (value & 0x0000fffc);
break; break;
} }
case R_PPC_ADDR30: { case R_PPC_ADDR30: {
*(int *)target = *(int32_t *)target =
(*(int *)target & 0x00000003) | (value & 0xfffffffc); (*(int32_t *)target & 0x00000003) | (value & 0xfffffffc);
break; break;
} }
default: default:

2
loader/src/plugin/ElfTools.h
View File

@ -46,7 +46,7 @@ public:
static bool loadElfSymtab(Elf *elf, Elf32_Sym **symtab, size_t *symtab_count, size_t *symtab_strndx); static bool loadElfSymtab(Elf *elf, Elf32_Sym **symtab, size_t *symtab_count, size_t *symtab_strndx);
static void elfLoadSymbols(size_t shndx, const void *destination, Elf32_Sym *symtab, size_t symtab_count); static void elfLoadSymbols(size_t shndx, const void *destination, Elf32_Sym *symtab, size_t symtab_count);
static bool elfLink(Elf *elf, size_t shndx, void *destination, Elf32_Sym *symtab, size_t symtab_count, size_t symtab_strndx, bool allow_globals, PluginData * pluginData = NULL); static bool elfLink(Elf *elf, size_t shndx, void *destination, Elf32_Sym *symtab, size_t symtab_count, size_t symtab_strndx, bool allow_globals, PluginData * pluginData = NULL);
static bool elfLinkOne(char type, size_t offset, int addend, void *destination, uint32_t symbol_addr); static bool elfLinkOne(char type, size_t offset, int32_t addend, void *destination, uint32_t symbol_addr);
}; };
#endif #endif

8
loader/src/plugin/ImportRPLInformation.h
View File

@ -24,7 +24,7 @@
class ImportRPLInformation { class ImportRPLInformation {
public: public:
ImportRPLInformation(int section_header_index, std::string name, bool isData = false) { ImportRPLInformation(int32_t section_header_index, std::string name, bool isData = false) {
this->name = name; this->name = name;
this->section_header_index = section_header_index; this->section_header_index = section_header_index;
this->_isData = isData; this->_isData = isData;
@ -34,7 +34,7 @@ public:
} }
static ImportRPLInformation * createImportRPLInformation(int section_header_index, std::string rawSectionName) { static ImportRPLInformation * createImportRPLInformation(int32_t section_header_index, std::string rawSectionName) {
std::string fimport = ".fimport_"; std::string fimport = ".fimport_";
std::string dimport = ".dimport_"; std::string dimport = ".dimport_";
@ -61,7 +61,7 @@ public:
return name; return name;
} }
int getSectionHeaderIndex() { int32_t getSectionHeaderIndex() {
return section_header_index; return section_header_index;
} }
@ -72,7 +72,7 @@ public:
private: private:
std::string name; std::string name;
bool _isData = false; bool _isData = false;
int section_header_index = 0; int32_t section_header_index = 0;
}; };

2
loader/src/plugin/PluginData.cpp
View File

@ -21,7 +21,7 @@
#include "PluginData.h" #include "PluginData.h"
#include "PluginLoader.h" #include "PluginLoader.h"
ImportRPLInformation * PluginData::getImportRPLInformationBySectionHeaderIndex(int section_header_index) { ImportRPLInformation * PluginData::getImportRPLInformationBySectionHeaderIndex(int32_t section_header_index) {
for(size_t i = 0; i< importRPLInformation_list.size(); i++) { for(size_t i = 0; i< importRPLInformation_list.size(); i++) {
if(importRPLInformation_list[i] != NULL && importRPLInformation_list[i]->getSectionHeaderIndex() == section_header_index) { if(importRPLInformation_list[i] != NULL && importRPLInformation_list[i]->getSectionHeaderIndex() == section_header_index) {
return importRPLInformation_list[i]; return importRPLInformation_list[i];

2
loader/src/plugin/PluginData.h
View File

@ -109,7 +109,7 @@ public:
\return A pointer to the corresponding ImportRPLInformation, return NULL if no corresponding information was found. \return A pointer to the corresponding ImportRPLInformation, return NULL if no corresponding information was found.
**/ **/
ImportRPLInformation * getImportRPLInformationBySectionHeaderIndex(int section_header_index); ImportRPLInformation * getImportRPLInformationBySectionHeaderIndex(int32_t section_header_index);
PluginInformation * getPluginInformation() { PluginInformation * getPluginInformation() {

2
loader/src/plugin/PluginInformation.cpp
View File

@ -65,7 +65,7 @@ bool PluginInformation::checkFileExtenstion(const char * path) {
bool PluginInformation::openAndParseElf() { bool PluginInformation::openAndParseElf() {
bool result = false; bool result = false;
int fd = -1; int32_t fd = -1;
Elf *elf = NULL; Elf *elf = NULL;
/* check for compile errors */ /* check for compile errors */

24
loader/src/plugin/PluginLoader.cpp
View File

@ -81,7 +81,7 @@ std::vector<PluginInformation *> PluginLoader::getPluginInformation(const char *
std::vector<PluginInformation *> PluginLoader::getPluginsLoadedInMemory() { std::vector<PluginInformation *> PluginLoader::getPluginsLoadedInMemory() {
std::vector<PluginInformation *> pluginInformation; std::vector<PluginInformation *> pluginInformation;
for(s32 i = 0; i < gbl_replacement_data.number_used_plugins; i++) { for(int32_t i = 0; i < gbl_replacement_data.number_used_plugins; i++) {
replacement_data_plugin_t * pluginInfo = &gbl_replacement_data.plugin_data[i]; replacement_data_plugin_t * pluginInfo = &gbl_replacement_data.plugin_data[i];
PluginInformation * curPlugin = PluginInformation::loadPluginInformation(pluginInfo->path); PluginInformation * curPlugin = PluginInformation::loadPluginInformation(pluginInfo->path);
if(curPlugin != NULL) { if(curPlugin != NULL) {
@ -134,7 +134,7 @@ void PluginLoader::clearPluginInformation(std::vector<PluginInformation *> plugi
PluginData * PluginLoader::loadAndLinkPlugin(PluginInformation * pluginInformation) { PluginData * PluginLoader::loadAndLinkPlugin(PluginInformation * pluginInformation) {
PluginData * result = NULL; PluginData * result = NULL;
int fd = -1; int32_t fd = -1;
Elf *elf = NULL; Elf *elf = NULL;
if(pluginInformation == NULL) { if(pluginInformation == NULL) {
@ -142,7 +142,7 @@ PluginData * PluginLoader::loadAndLinkPlugin(PluginInformation * pluginInformati
goto exit_error; goto exit_error;
} }
if(pluginInformation->getSize() > ((u32) getAvailableSpace())) { if(pluginInformation->getSize() > ((uint32_t) getAvailableSpace())) {
DEBUG_FUNCTION_LINE("Not enough space left to loader the plugin into memory %08X %08X\n",pluginInformation->getSize(),getAvailableSpace()); DEBUG_FUNCTION_LINE("Not enough space left to loader the plugin into memory %08X %08X\n",pluginInformation->getSize(),getAvailableSpace());
goto exit_error; goto exit_error;
} }
@ -192,7 +192,7 @@ bool PluginLoader::loadAndLinkElf(PluginData * pluginData, Elf *elf, void * endA
return false; return false;
} }
u32 curAddress = (u32) endAddress; uint32_t curAddress = (uint32_t) endAddress;
Elf_Scn *scn; Elf_Scn *scn;
size_t symtab_count, section_count, shstrndx, symtab_strndx, entries_count, hooks_count; size_t symtab_count, section_count, shstrndx, symtab_strndx, entries_count, hooks_count;
@ -202,7 +202,7 @@ bool PluginLoader::loadAndLinkElf(PluginData * pluginData, Elf *elf, void * endA
wups_loader_hook_t *hooks = NULL; wups_loader_hook_t *hooks = NULL;
bool result = false; bool result = false;
int i = 1; int32_t i = 1;
std::vector<wups_loader_entry_t *> entry_t_list; std::vector<wups_loader_entry_t *> entry_t_list;
std::vector<wups_loader_hook_t *> hook_t_list; std::vector<wups_loader_hook_t *> hook_t_list;
@ -304,13 +304,13 @@ bool PluginLoader::loadAndLinkElf(PluginData * pluginData, Elf *elf, void * endA
curAddress -= shdr->sh_size; curAddress -= shdr->sh_size;
if (shdr->sh_addralign > 3) { if (shdr->sh_addralign > 3) {
curAddress = (u32)((int)curAddress & ~(shdr->sh_addralign - 1)); curAddress = (uint32_t)((int32_t)curAddress & ~(shdr->sh_addralign - 1));
} else { } else {
curAddress = (u32)((int)curAddress & ~3); curAddress = (uint32_t)((int32_t)curAddress & ~3);
} }
destinations[elf_ndxscn(scn)] = (uint8_t *) curAddress; destinations[elf_ndxscn(scn)] = (uint8_t *) curAddress;
if((u32) curAddress < (u32) this->startAddress) { if((uint32_t) curAddress < (uint32_t) this->startAddress) {
DEBUG_FUNCTION_LINE("Not enough space to load function %s into memory at %08X.\n",name,curAddress); DEBUG_FUNCTION_LINE("Not enough space to load function %s into memory at %08X.\n",name,curAddress);
goto exit_error; goto exit_error;
} }
@ -406,7 +406,7 @@ void PluginLoader::copyPluginDataIntoGlobalStruct(std::vector<PluginData *> plug
// Reset data // Reset data
memset((void*)&gbl_replacement_data,0,sizeof(gbl_replacement_data)); memset((void*)&gbl_replacement_data,0,sizeof(gbl_replacement_data));
DynamicLinkingHelper::getInstance()->clearAll(); DynamicLinkingHelper::getInstance()->clearAll();
int plugin_index = 0; int32_t plugin_index = 0;
// Copy data to global struct. // Copy data to global struct.
for(size_t i = 0; i< plugins.size(); i++) { for(size_t i = 0; i< plugins.size(); i++) {
PluginData * cur_plugin = plugins.at(i); PluginData * cur_plugin = plugins.at(i);
@ -462,8 +462,8 @@ void PluginLoader::copyPluginDataIntoGlobalStruct(std::vector<PluginData *> plug
strncpy(function_data->function_name,cur_function->getName().c_str(),MAXIMUM_FUNCTION_NAME_LENGTH-1); strncpy(function_data->function_name,cur_function->getName().c_str(),MAXIMUM_FUNCTION_NAME_LENGTH-1);
function_data->library = cur_function->getLibrary(); function_data->library = cur_function->getLibrary();
function_data->replaceAddr = (u32) cur_function->getReplaceAddress(); function_data->replaceAddr = (uint32_t) cur_function->getReplaceAddress();
function_data->replaceCall = (u32) cur_function->getReplaceCall(); function_data->replaceCall = (uint32_t) cur_function->getReplaceCall();
plugin_data->number_used_functions++; plugin_data->number_used_functions++;
} }
@ -491,7 +491,7 @@ void PluginLoader::copyPluginDataIntoGlobalStruct(std::vector<PluginData *> plug
} }
uint32_t PluginLoader::getMemoryFromDataSection(size_t align, size_t size) { uint32_t PluginLoader::getMemoryFromDataSection(size_t align, size_t size) {
uint32_t ptr = (u32)gbl_common_data_ptr; uint32_t ptr = (uint32_t)gbl_common_data_ptr;
ptr = (ptr + (align - 1)) & -align; // Round up to align boundary ptr = (ptr + (align - 1)) & -align; // Round up to align boundary
uint32_t result = ptr; uint32_t result = ptr;

12
loader/src/plugin/PluginLoader.h
View File

@ -95,11 +95,11 @@ public:
static void flushCache() { static void flushCache() {
u32 startAddress = getApplicationEndAddr(); uint32_t startAddress = getApplicationEndAddr();
u32 endAddress = PLUGIN_LOCATION_END_ADDRESS; uint32_t endAddress = PLUGIN_LOCATION_END_ADDRESS;
DCFlushRange((void*)startAddress,(u32)endAddress - (u32)startAddress); DCFlushRange((void*)startAddress,(uint32_t)endAddress - (uint32_t)startAddress);
ICInvalidateRange((void*)startAddress,(u32)endAddress - (u32)startAddress); ICInvalidateRange((void*)startAddress,(uint32_t)endAddress - (uint32_t)startAddress);
} }
/** /**
@ -110,11 +110,11 @@ public:
void clearPluginInformation(std::vector<PluginInformation*> PluginInformation); void clearPluginInformation(std::vector<PluginInformation*> PluginInformation);
size_t getTotalSpace() { size_t getTotalSpace() {
return ((u32) this->endAddress - (u32) this->startAddress); return ((uint32_t) this->endAddress - (uint32_t) this->startAddress);
} }
size_t getAvailableSpace() { size_t getAvailableSpace() {
return ((u32) this->currentStoreAddress - (u32) this->startAddress); return ((uint32_t) this->currentStoreAddress - (uint32_t) this->startAddress);
} }
size_t getUsedSpace() { size_t getUsedSpace() {

6
loader/src/plugin/RelocationData.h
View File

@ -25,7 +25,7 @@
class RelocationData { class RelocationData {
public: public:
RelocationData(char type, size_t offset, int addend, void *destination, std::string name, ImportRPLInformation * rplInfo) { RelocationData(char type, size_t offset, int32_t addend, void *destination, std::string name, ImportRPLInformation * rplInfo) {
this->type = type; this->type = type;
this->offset = offset; this->offset = offset;
this->addend = addend; this->addend = addend;
@ -46,7 +46,7 @@ public:
return offset; return offset;
} }
int getAddend() { int32_t getAddend() {
return addend; return addend;
} }
@ -69,7 +69,7 @@ public:
private: private:
char type; char type;
size_t offset; size_t offset;
int addend; int32_t addend;
void *destination; void *destination;
std::string name; std::string name;
ImportRPLInformation * rplInfo; ImportRPLInformation * rplInfo;

6
loader/src/plugin/dynamic_linking_defines.h
View File

@ -35,13 +35,13 @@ extern "C" {
typedef struct _dyn_linking_function_t { typedef struct _dyn_linking_function_t {
char functionName[DYN_LINK_FUNCTION_NAME_LENGTH+1]; char functionName[DYN_LINK_FUNCTION_NAME_LENGTH+1];
void * address; void * address;
u32 big_jump[6]; uint32_t big_jump[6];
} dyn_linking_function_t; } dyn_linking_function_t;
typedef struct _dyn_linking_import_t { typedef struct _dyn_linking_import_t {
char importName[DYN_LINK_IMPORT_NAME_LENGTH+1]; char importName[DYN_LINK_IMPORT_NAME_LENGTH+1];
bool isData = false; bool isData = false;
u32 handle = 0; uint32_t handle = 0;
} dyn_linking_import_t; } dyn_linking_import_t;
typedef struct _dyn_linking_relocation_entry_t { typedef struct _dyn_linking_relocation_entry_t {
@ -50,7 +50,7 @@ typedef struct _dyn_linking_relocation_entry_t {
void * destination = NULL; void * destination = NULL;
char type; char type;
size_t offset; size_t offset;
int addend; int32_t addend;
} dyn_linking_relocation_entry_t; } dyn_linking_relocation_entry_t;
typedef struct _dyn_linking_relocation_data_t { typedef struct _dyn_linking_relocation_data_t {

21
loader/src/resources/filelist.cpp
View File

@ -7,21 +7,22 @@
* Any manual modification of this file will be overwriten by the generation. * Any manual modification of this file will be overwriten by the generation.
*****************************************************************************/ *****************************************************************************/
#include <resources/filelist.h> #include <resources/filelist.h>
#include <stdint.h>
extern const u8 font_ttf[]; extern const uint8_t font_ttf[];
extern const u32 font_ttf_size; extern const uint32_t font_ttf_size;
extern const u8 GithubIcon_png[]; extern const uint8_t GithubIcon_png[];
extern const u32 GithubIcon_png_size; extern const uint32_t GithubIcon_png_size;
extern const u8 HomeButtonIcon_png[]; extern const uint8_t HomeButtonIcon_png[];
extern const u32 HomeButtonIcon_png_size; extern const uint32_t HomeButtonIcon_png_size;
extern const u8 PlusButtonIcon_png[]; extern const uint8_t PlusButtonIcon_png[];
extern const u32 PlusButtonIcon_png_size; extern const uint32_t PlusButtonIcon_png_size;
extern const u8 TwitterIcon_png[]; extern const uint8_t TwitterIcon_png[];
extern const u32 TwitterIcon_png_size; extern const uint32_t TwitterIcon_png_size;
static ResourceFile ResourceList[] = static ResourceFile ResourceList[] =
{ {

14
loader/src/settings/CSettings.cpp
View File

@ -42,7 +42,7 @@ CSettings::CSettings() {
} }
CSettings::~CSettings() { CSettings::~CSettings() {
for(u32 i = 0; i < settingsValues.size(); i++) { for(uint32_t i = 0; i < settingsValues.size(); i++) {
if(settingsValues[i].dataType == TypeString) if(settingsValues[i].dataType == TypeString)
delete settingsValues[i].strValue; delete settingsValues[i].strValue;
} }
@ -50,7 +50,7 @@ CSettings::~CSettings() {
} }
void CSettings::SetDefault() { void CSettings::SetDefault() {
for(u32 i = 0; i < settingsValues.size(); i++) { for(uint32_t i = 0; i < settingsValues.size(); i++) {
if(settingsValues[i].dataType == TypeString) if(settingsValues[i].dataType == TypeString)
delete settingsValues[i].strValue; delete settingsValues[i].strValue;
} }
@ -80,7 +80,7 @@ bool CSettings::Load() {
std::string strBuffer; std::string strBuffer;
strBuffer.resize(file.size()); strBuffer.resize(file.size());
file.read((u8 *) &strBuffer[0], strBuffer.size()); file.read((uint8_t *) &strBuffer[0], strBuffer.size());
file.close(); file.close();
@ -100,7 +100,7 @@ bool CSettings::Load() {
if(lines.empty() || !ValidVersion(lines[0])) if(lines.empty() || !ValidVersion(lines[0]))
return false; return false;
for(u32 i = 0; i < lines.size(); ++i) { for(uint32_t i = 0; i < lines.size(); ++i) {
std::vector<std::string> valueSplit = StringTools::stringSplit(lines[i], "="); std::vector<std::string> valueSplit = StringTools::stringSplit(lines[i], "=");
if(valueSplit.size() != 2) if(valueSplit.size() != 2)
continue; continue;
@ -111,7 +111,7 @@ bool CSettings::Load() {
while((valueSplit[1].size() > 0) && valueSplit[1][ valueSplit[1].size() - 1 ] == ' ') while((valueSplit[1].size() > 0) && valueSplit[1][ valueSplit[1].size() - 1 ] == ' ')
valueSplit[1].resize(valueSplit[1].size() - 1); valueSplit[1].resize(valueSplit[1].size() - 1);
for(u32 n = 0; n < settingsNames.size(); n++) { for(uint32_t n = 0; n < settingsNames.size(); n++) {
if(!settingsNames[n]) if(!settingsNames[n])
continue; continue;
@ -158,7 +158,7 @@ bool CSettings::Load() {
} }
bool CSettings::ValidVersion(const std::string & versionString) { bool CSettings::ValidVersion(const std::string & versionString) {
int version = 0; int32_t version = 0;
if(versionString.find(VERSION_LINE) != 0) if(versionString.find(VERSION_LINE) != 0)
return false; return false;
@ -193,7 +193,7 @@ bool CSettings::Save() {
file.fwrite("%s%i\n", VERSION_LINE, VALID_VERSION); file.fwrite("%s%i\n", VERSION_LINE, VALID_VERSION);
for(u32 i = 0; i < settingsValues.size(); i++) { for(uint32_t i = 0; i < settingsValues.size(); i++) {
switch(settingsValues[i].dataType) { switch(settingsValues[i].dataType) {
case TypeBool: case TypeBool:
file.fwrite("%s=%i\n", settingsNames[i], settingsValues[i].bValue); file.fwrite("%s=%i\n", settingsNames[i], settingsValues[i].bValue);

54
loader/src/settings/CSettings.h
View File

@ -70,117 +70,117 @@ public:
MAX_VALUE MAX_VALUE
}; };
static const u8 & getDataType(int idx) { static const uint8_t & getDataType(int32_t idx) {
if(idx > INVALID && idx < MAX_VALUE) if(idx > INVALID && idx < MAX_VALUE)
return instance()->settingsValues[idx].dataType; return instance()->settingsValues[idx].dataType;
return instance()->nullValue.dataType; return instance()->nullValue.dataType;
} }
static const bool & getValueAsBool(int idx) { static const bool & getValueAsBool(int32_t idx) {
if(idx > INVALID && idx < MAX_VALUE && instance()->settingsValues[idx].dataType == TypeBool) if(idx > INVALID && idx < MAX_VALUE && instance()->settingsValues[idx].dataType == TypeBool)
return instance()->settingsValues[idx].bValue; return instance()->settingsValues[idx].bValue;
return instance()->nullValue.bValue; return instance()->nullValue.bValue;
} }
static const s8 & getValueAsS8(int idx) { static const int8_t & getValueAsS8(int32_t idx) {
if(idx > INVALID && idx < MAX_VALUE && instance()->settingsValues[idx].dataType == TypeS8) if(idx > INVALID && idx < MAX_VALUE && instance()->settingsValues[idx].dataType == TypeS8)
return instance()->settingsValues[idx].cValue; return instance()->settingsValues[idx].cValue;
return instance()->nullValue.cValue; return instance()->nullValue.cValue;
} }
static const u8 & getValueAsU8(int idx) { static const uint8_t & getValueAsU8(int32_t idx) {
if(idx > INVALID && idx < MAX_VALUE && instance()->settingsValues[idx].dataType == TypeU8) if(idx > INVALID && idx < MAX_VALUE && instance()->settingsValues[idx].dataType == TypeU8)
return instance()->settingsValues[idx].ucValue; return instance()->settingsValues[idx].ucValue;
return instance()->nullValue.ucValue; return instance()->nullValue.ucValue;
} }
static const s16 & getValueAsS16(int idx) { static const int16_t & getValueAsS16(int32_t idx) {
if(idx > INVALID && idx < MAX_VALUE && instance()->settingsValues[idx].dataType == TypeS16) if(idx > INVALID && idx < MAX_VALUE && instance()->settingsValues[idx].dataType == TypeS16)
return instance()->settingsValues[idx].sValue; return instance()->settingsValues[idx].sValue;
return instance()->nullValue.sValue; return instance()->nullValue.sValue;
} }
static const u16 & getValueAsU16(int idx) { static const uint16_t & getValueAsU16(int32_t idx) {
if(idx > INVALID && idx < MAX_VALUE && instance()->settingsValues[idx].dataType == TypeU16) if(idx > INVALID && idx < MAX_VALUE && instance()->settingsValues[idx].dataType == TypeU16)
return instance()->settingsValues[idx].usValue; return instance()->settingsValues[idx].usValue;
return instance()->nullValue.usValue; return instance()->nullValue.usValue;
} }
static const s32 & getValueAsS32(int idx) { static const int32_t & getValueAsS32(int32_t idx) {
if(idx > INVALID && idx < MAX_VALUE && instance()->settingsValues[idx].dataType == TypeS32) if(idx > INVALID && idx < MAX_VALUE && instance()->settingsValues[idx].dataType == TypeS32)
return instance()->settingsValues[idx].iValue; return instance()->settingsValues[idx].iValue;
return instance()->nullValue.iValue; return instance()->nullValue.iValue;
} }
static const u32 & getValueAsU32(int idx) { static const uint32_t & getValueAsU32(int32_t idx) {
if(idx > INVALID && idx < MAX_VALUE && instance()->settingsValues[idx].dataType == TypeU32) if(idx > INVALID && idx < MAX_VALUE && instance()->settingsValues[idx].dataType == TypeU32)
return instance()->settingsValues[idx].uiValue; return instance()->settingsValues[idx].uiValue;
return instance()->nullValue.uiValue; return instance()->nullValue.uiValue;
} }
static const f32 & getValueAsF32(int idx) { static const float & getValueAsF32(int32_t idx) {
if(idx > INVALID && idx < MAX_VALUE && instance()->settingsValues[idx].dataType == TypeF32) if(idx > INVALID && idx < MAX_VALUE && instance()->settingsValues[idx].dataType == TypeF32)
return instance()->settingsValues[idx].fValue; return instance()->settingsValues[idx].fValue;
return instance()->nullValue.fValue; return instance()->nullValue.fValue;
} }
static const std::string & getValueAsString(int idx) { static const std::string & getValueAsString(int32_t idx) {
if(idx > INVALID && idx < MAX_VALUE && instance()->settingsValues[idx].dataType == TypeString && instance()->settingsValues[idx].strValue) if(idx > INVALID && idx < MAX_VALUE && instance()->settingsValues[idx].dataType == TypeString && instance()->settingsValues[idx].strValue)
return *(instance()->settingsValues[idx].strValue); return *(instance()->settingsValues[idx].strValue);
return *(instance()->nullValue.strValue); return *(instance()->nullValue.strValue);
} }
static void setValueAsBool(int idx, const bool & val) { static void setValueAsBool(int32_t idx, const bool & val) {
if(idx > INVALID && idx < MAX_VALUE && instance()->settingsValues[idx].dataType == TypeBool) { if(idx > INVALID && idx < MAX_VALUE && instance()->settingsValues[idx].dataType == TypeBool) {
instance()->settingsValues[idx].bValue = val; instance()->settingsValues[idx].bValue = val;
instance()->bChanged = true; instance()->bChanged = true;
} }
} }
static void setValueAsS8(int idx, const s8 & val) { static void setValueAsS8(int32_t idx, const int8_t & val) {
if(idx > INVALID && idx < MAX_VALUE && instance()->settingsValues[idx].dataType == TypeS8) { if(idx > INVALID && idx < MAX_VALUE && instance()->settingsValues[idx].dataType == TypeS8) {
instance()->settingsValues[idx].cValue = val; instance()->settingsValues[idx].cValue = val;
instance()->bChanged = true; instance()->bChanged = true;
} }
} }
static void setValueAsU8(int idx, const u8 & val) { static void setValueAsU8(int32_t idx, const uint8_t & val) {
if(idx > INVALID && idx < MAX_VALUE && instance()->settingsValues[idx].dataType == TypeU8) { if(idx > INVALID && idx < MAX_VALUE && instance()->settingsValues[idx].dataType == TypeU8) {
instance()->settingsValues[idx].ucValue = val; instance()->settingsValues[idx].ucValue = val;
instance()->bChanged = true; instance()->bChanged = true;
} }
} }
static void setValueAsS16(int idx, const s16 & val) { static void setValueAsS16(int32_t idx, const int16_t & val) {
if(idx > INVALID && idx < MAX_VALUE && instance()->settingsValues[idx].dataType == TypeS16) { if(idx > INVALID && idx < MAX_VALUE && instance()->settingsValues[idx].dataType == TypeS16) {
instance()->settingsValues[idx].sValue = val; instance()->settingsValues[idx].sValue = val;
instance()->bChanged = true; instance()->bChanged = true;
} }
} }
static void setValueAsU16(int idx, const u16 & val) { static void setValueAsU16(int32_t idx, const uint16_t & val) {
if(idx > INVALID && idx < MAX_VALUE && instance()->settingsValues[idx].dataType == TypeU16) { if(idx > INVALID && idx < MAX_VALUE && instance()->settingsValues[idx].dataType == TypeU16) {
instance()->settingsValues[idx].usValue = val; instance()->settingsValues[idx].usValue = val;
instance()->bChanged = true; instance()->bChanged = true;
} }
} }
static void setValueAsS32(int idx, const s32 & val) { static void setValueAsS32(int32_t idx, const int32_t & val) {
if(idx > INVALID && idx < MAX_VALUE && instance()->settingsValues[idx].dataType == TypeS32) { if(idx > INVALID && idx < MAX_VALUE && instance()->settingsValues[idx].dataType == TypeS32) {
instance()->settingsValues[idx].iValue = val; instance()->settingsValues[idx].iValue = val;
instance()->bChanged = true; instance()->bChanged = true;
} }
} }
static void setValueAsU32(int idx, const u32 & val) { static void setValueAsU32(int32_t idx, const uint32_t & val) {
if(idx > INVALID && idx < MAX_VALUE && instance()->settingsValues[idx].dataType == TypeU32) { if(idx > INVALID && idx < MAX_VALUE && instance()->settingsValues[idx].dataType == TypeU32) {
instance()->settingsValues[idx].uiValue = val; instance()->settingsValues[idx].uiValue = val;
instance()->bChanged = true; instance()->bChanged = true;
} }
} }
static void setValueAsF32(int idx, const f32 & val) { static void setValueAsF32(int32_t idx, const float & val) {
if(idx > INVALID && idx < MAX_VALUE && instance()->settingsValues[idx].dataType == TypeF32) { if(idx > INVALID && idx < MAX_VALUE && instance()->settingsValues[idx].dataType == TypeF32) {
instance()->settingsValues[idx].fValue = val; instance()->settingsValues[idx].fValue = val;
instance()->bChanged = true; instance()->bChanged = true;
} }
} }
static void setValueAsString(int idx, const std::string & val) { static void setValueAsString(int32_t idx, const std::string & val) {
if(idx > INVALID && idx < MAX_VALUE && instance()->settingsValues[idx].dataType == TypeString && instance()->settingsValues[idx].strValue) { if(idx > INVALID && idx < MAX_VALUE && instance()->settingsValues[idx].dataType == TypeString && instance()->settingsValues[idx].strValue) {
*(instance()->settingsValues[idx].strValue) = val; *(instance()->settingsValues[idx].strValue) = val;
instance()->bChanged = true; instance()->bChanged = true;
@ -197,17 +197,17 @@ protected:
static CSettings *settingsInstance; static CSettings *settingsInstance;
typedef struct { typedef struct {
u8 dataType; uint8_t dataType;
union { union {
bool bValue; bool bValue;
s8 cValue; int8_t cValue;
u8 ucValue; uint8_t ucValue;
s16 sValue; int16_t sValue;
u16 usValue; uint16_t usValue;
s32 iValue; int32_t iValue;
u32 uiValue; uint32_t uiValue;
f32 fValue; float fValue;
std::string *strValue; std::string *strValue;
}; };
} SettingValue; } SettingValue;

6
loader/src/settings/SettingsDefs.h
View File

@ -20,15 +20,15 @@
#define __SETTINGS_DEFS_ #define __SETTINGS_DEFS_
typedef struct { typedef struct {
int value; int32_t value;
const char *name; const char *name;
} ValueString; } ValueString;
typedef struct { typedef struct {
const char *name; const char *name;
const ValueString *valueStrings; const ValueString *valueStrings;
int type; int32_t type;
int index; int32_t index;
} SettingType; } SettingType;
#endif // __SETTINGS_DEFS_ #endif // __SETTINGS_DEFS_

24
loader/src/utils.cpp
View File

@ -19,15 +19,15 @@ void CallHook(wups_loader_hook_type_t hook_type) {
CallHookEx(hook_type,-1); CallHookEx(hook_type,-1);
} }
void CallHookEx(wups_loader_hook_type_t hook_type, s32 plugin_index_needed) { void CallHookEx(wups_loader_hook_type_t hook_type, int32_t plugin_index_needed) {
for(int plugin_index=0; plugin_index<gbl_replacement_data.number_used_plugins; plugin_index++) { for(int32_t plugin_index=0; plugin_index<gbl_replacement_data.number_used_plugins; plugin_index++) {
replacement_data_plugin_t * plugin_data = &gbl_replacement_data.plugin_data[plugin_index]; replacement_data_plugin_t * plugin_data = &gbl_replacement_data.plugin_data[plugin_index];
if(plugin_index_needed != -1 && plugin_index_needed != plugin_index) { if(plugin_index_needed != -1 && plugin_index_needed != plugin_index) {
continue; continue;
} }
//DEBUG_FUNCTION_LINE("Checking hook functions for %s.\n",plugin_data->plugin_name); //DEBUG_FUNCTION_LINE("Checking hook functions for %s.\n",plugin_data->plugin_name);
//DEBUG_FUNCTION_LINE("Found hooks: %d\n",plugin_data->number_used_hooks); //DEBUG_FUNCTION_LINE("Found hooks: %d\n",plugin_data->number_used_hooks);
for(int j=0; j<plugin_data->number_used_hooks; j++) { for(int32_t j=0; j<plugin_data->number_used_hooks; j++) {
replacement_data_hook_t * hook_data = &plugin_data->hooks[j]; replacement_data_hook_t * hook_data = &plugin_data->hooks[j];
if(hook_data->type == hook_type) { if(hook_data->type == hook_type) {
DEBUG_FUNCTION_LINE("Calling hook of type %d for plugin %s\n",hook_data->type,plugin_data->plugin_name); DEBUG_FUNCTION_LINE("Calling hook of type %d for plugin %s\n",hook_data->type,plugin_data->plugin_name);
@ -50,16 +50,16 @@ void CallHookEx(wups_loader_hook_type_t hook_type, s32 plugin_index_needed) {
args.readdir_repl = (const void*)&readdir; args.readdir_repl = (const void*)&readdir;
args.mkdir_repl = (const void*)&mkdir; args.mkdir_repl = (const void*)&mkdir;
((void (*)(wups_loader_init_fs_args_t))((unsigned int*)func_ptr) )(args); ((void (*)(wups_loader_init_fs_args_t))((uint32_t*)func_ptr) )(args);
} else if(hook_type == WUPS_LOADER_HOOK_INIT_OVERLAY) { } else if(hook_type == WUPS_LOADER_HOOK_INIT_OVERLAY) {
wups_loader_init_overlay_args_t args; wups_loader_init_overlay_args_t args;
args.overlayfunction_ptr = (const void*)&overlay_helper; args.overlayfunction_ptr = (const void*)&overlay_helper;
((void (*)(wups_loader_init_overlay_args_t))((unsigned int*)func_ptr) )(args); ((void (*)(wups_loader_init_overlay_args_t))((uint32_t*)func_ptr) )(args);
} else if(hook_type == WUPS_LOADER_HOOK_INIT_PLUGIN) { } else if(hook_type == WUPS_LOADER_HOOK_INIT_PLUGIN) {
((void (*)(void))((unsigned int*)func_ptr) )(); ((void (*)(void))((uint32_t*)func_ptr) )();
} else if(hook_type == WUPS_LOADER_HOOK_DEINIT_PLUGIN) { } else if(hook_type == WUPS_LOADER_HOOK_DEINIT_PLUGIN) {
((void (*)(void))((unsigned int*)func_ptr) )(); ((void (*)(void))((uint32_t*)func_ptr) )();
} else if(hook_type == WUPS_LOADER_HOOK_STARTING_APPLICATION) { } else if(hook_type == WUPS_LOADER_HOOK_STARTING_APPLICATION) {
wups_loader_app_started_args_t args; wups_loader_app_started_args_t args;
memset(&args,0,sizeof(args)); memset(&args,0,sizeof(args));
@ -69,13 +69,13 @@ void CallHookEx(wups_loader_hook_type_t hook_type, s32 plugin_index_needed) {
if(gSDInitDone & WUPS_USB_MOUNTED) { if(gSDInitDone & WUPS_USB_MOUNTED) {
args.usb_mounted = true; args.usb_mounted = true;
} }
((void (*)(wups_loader_app_started_args_t))((unsigned int*)func_ptr) )(args); ((void (*)(wups_loader_app_started_args_t))((uint32_t*)func_ptr) )(args);
} else if(hook_type == WUPS_LOADER_HOOK_FUNCTIONS_PATCHED) { } else if(hook_type == WUPS_LOADER_HOOK_FUNCTIONS_PATCHED) {
((void (*)(void))((unsigned int*)func_ptr))(); ((void (*)(void))((uint32_t*)func_ptr))();
} else if(hook_type == WUPS_LOADER_HOOK_ENDING_APPLICATION) { } else if(hook_type == WUPS_LOADER_HOOK_ENDING_APPLICATION) {
((void (*)(void))((unsigned int*)func_ptr))(); ((void (*)(void))((uint32_t*)func_ptr))();
} else if(hook_type == WUPS_LOADER_HOOK_VSYNC) { } else if(hook_type == WUPS_LOADER_HOOK_VSYNC) {
((void (*)(void))((unsigned int*)func_ptr))(); ((void (*)(void))((uint32_t*)func_ptr))();
} else if(hook_type == WUPS_LOADER_HOOK_APP_STATUS_CHANGED) { } else if(hook_type == WUPS_LOADER_HOOK_APP_STATUS_CHANGED) {
wups_loader_app_status_t status; wups_loader_app_status_t status;
if(gAppStatus == 0) { if(gAppStatus == 0) {
@ -87,7 +87,7 @@ void CallHookEx(wups_loader_hook_type_t hook_type, s32 plugin_index_needed) {
} else { } else {
status = WUPS_APP_STATUS_UNKNOWN; status = WUPS_APP_STATUS_UNKNOWN;
} }
((void (*)(wups_loader_app_status_t))((unsigned int*)func_ptr))(status); ((void (*)(wups_loader_app_status_t))((uint32_t*)func_ptr))(status);
} else { } else {
DEBUG_FUNCTION_LINE("ERROR: HOOK TYPE WAS NOT IMPLEMENTED %08X \n",hook_type); DEBUG_FUNCTION_LINE("ERROR: HOOK TYPE WAS NOT IMPLEMENTED %08X \n",hook_type);
} }

2
loader/src/utils.h
View File

@ -11,7 +11,7 @@ extern "C" {
void CallHook(wups_loader_hook_type_t hook_type); void CallHook(wups_loader_hook_type_t hook_type);
void CallHookEx(wups_loader_hook_type_t hook_type, s32 plugin_index_needed); void CallHookEx(wups_loader_hook_type_t hook_type, int32_t plugin_index_needed);
#ifdef __cplusplus #ifdef __cplusplus
} }