604 lines
19 KiB
C++
604 lines
19 KiB
C++
#include "system/iplCdbBackup.h"
|
|
|
|
#include "iplSystem.h"
|
|
|
|
namespace ipl {
|
|
const int CdbBackup::unknown = (cdb::Manager::UNKNOWN_VALUE * 0x1400000) / 100;
|
|
|
|
void cdb_backup_delete_task_(void*);
|
|
void cdb_backup_move_task_(void*);
|
|
|
|
CdbBackup::CdbBackup()
|
|
: mbDoneProcess(false), mCDBResult(0), mPrevFreeSize(0), mTotalFreeSize(0), mState(STATE_MOUNT_SD), mState2(STATE_INVALID) {
|
|
System::getHomeButtonMenu()->disable();
|
|
System::stopReceiveSchedule();
|
|
|
|
if (System::getCdbManager()->getSDWorker()->is_working()) {
|
|
mState = STATE_WAIT_WORKER;
|
|
mState2 = STATE_MOUNT_SD;
|
|
}
|
|
}
|
|
|
|
CdbBackup::~CdbBackup() {
|
|
System::getHomeButtonMenu()->enable();
|
|
System::startReceiveSchedule();
|
|
}
|
|
|
|
void CdbBackup::update() {
|
|
switch (mState) {
|
|
case STATE_WAIT_WORKER: {
|
|
stt_wait_worker();
|
|
break;
|
|
}
|
|
case STATE_MOUNT_SD: {
|
|
stt_mount_sd();
|
|
break;
|
|
}
|
|
case STATE_CHECK_SD: {
|
|
stt_check_sd();
|
|
break;
|
|
}
|
|
case STATE_DELETING: {
|
|
stt_wait_del_msg();
|
|
break;
|
|
}
|
|
case STATE_DELETING_2: {
|
|
stt_wait_besd_del_msg();
|
|
break;
|
|
}
|
|
case STATE_WAIT_DELETING: {
|
|
stt_wait_delete();
|
|
break;
|
|
}
|
|
case STATE_DONE_DELETE: {
|
|
stt_wait_del_msg_fns();
|
|
break;
|
|
}
|
|
case STATE_SD_BACKING: {
|
|
stt_wait_sd_back_msg();
|
|
break;
|
|
}
|
|
case STATE_SD_CHECK_ERR: {
|
|
stt_check_sd_err();
|
|
break;
|
|
}
|
|
case STATE_SD_BACK_PREPARE: {
|
|
stt_check_prepare_back();
|
|
break;
|
|
}
|
|
case STATE_WAIT_SD_BACKING: {
|
|
stt_wait_backup();
|
|
break;
|
|
}
|
|
case STATE_DONE_SD_BACK: {
|
|
stt_wait_back_msg_fns();
|
|
break;
|
|
}
|
|
case STATE_FINISHED_2: {
|
|
mState = STATE_FINISHED;
|
|
break;
|
|
}
|
|
case STATE_CLEAN_SD_BACK: {
|
|
stt_clean_up_back();
|
|
break;
|
|
}
|
|
case STATE_WAIT_RET: {
|
|
stt_wait_ret_msg();
|
|
break;
|
|
}
|
|
case STATE_WAIT_FINISH_MSG: {
|
|
stt_wait_fns_msg();
|
|
break;
|
|
}
|
|
case STATE_WAIT_TERMINATE: {
|
|
stt_wait_terminate();
|
|
break;
|
|
}
|
|
default: {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void CdbBackup::stt_wait_worker() {
|
|
if (!System::getCdbManager()->getSDWorker()->is_working()) {
|
|
error_handling();
|
|
mState = mState2;
|
|
mState2 = STATE_INVALID;
|
|
}
|
|
}
|
|
|
|
void CdbBackup::stt_mount_sd() {
|
|
System::getCdbManager()->getSDWorker()->mount_sd_async();
|
|
mState2 = STATE_CHECK_SD;
|
|
mState = STATE_WAIT_WORKER;
|
|
}
|
|
|
|
void CdbBackup::stt_check_sd() {
|
|
SDVFWorker* sdVfWorker = System::getCdbManager()->getSDWorker();
|
|
// ...
|
|
if (System::isSafeMode()) {
|
|
}
|
|
switch (sdVfWorker->get_sd_state()) {
|
|
case SDVFWorker::SD_STATE_INITIAL: {
|
|
break;
|
|
}
|
|
case SDVFWorker::SD_STATE_EJECTED: {
|
|
// @bug Should set `bSwapSound` to true
|
|
System::getDialog()->callBtn2(MESG_CDBBACKUP_ASK_FOR_DELETE, MESG_CMN_NO, MESG_CMN_YES);
|
|
mState = STATE_DELETING;
|
|
break;
|
|
}
|
|
case SDVFWorker::SD_STATE_INSERTED: {
|
|
mState = STATE_MOUNT_SD;
|
|
break;
|
|
}
|
|
default: {
|
|
// @bug Should set `bSwapSound` to true
|
|
System::getDialog()->callBtn2(MESG_CDBBACKUP_ASK_FOR_BACKUP, MESG_CMN_NO, MESG_CMN_YES);
|
|
mState = STATE_SD_BACKING;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void CdbBackup::stt_wait_del_msg() {
|
|
switch (System::getDialog()->getLastResult()) {
|
|
// "Yes"
|
|
case DialogWindow::RESULT_LEFT_BUTTON: {
|
|
mbDoneProcess = false;
|
|
System::getTask1()->request(cdb_backup_delete_task_, this, NULL);
|
|
System::getDialog()->callBtn0(MESG_CDBBACKUP_DELETING, 0, true);
|
|
mState = STATE_WAIT_DELETING;
|
|
break;
|
|
}
|
|
// "No"
|
|
case DialogWindow::RESULT_RIGHT_BUTTON: {
|
|
System::getDialog()->callBtn1(MESG_CDBBACKUP_BACKING_NO_SD, MESG_CMN_OK);
|
|
mState = STATE_WAIT_RET;
|
|
mState2 = STATE_MOUNT_SD;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void CdbBackup::stt_wait_besd_del_msg() {
|
|
switch (System::getDialog()->getLastResult()) {
|
|
// "Yes"
|
|
case DialogWindow::RESULT_LEFT_BUTTON: {
|
|
mbDoneProcess = false;
|
|
System::getTask1()->request(cdb_backup_delete_task_, this, NULL);
|
|
System::getDialog()->callBtn0(MESG_CDBBACKUP_DELETING, 0, true);
|
|
mState = STATE_WAIT_DELETING;
|
|
break;
|
|
}
|
|
// "No"
|
|
case DialogWindow::RESULT_RIGHT_BUTTON: {
|
|
mState = STATE_CHECK_SD;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void CdbBackup::stt_wait_delete() {
|
|
if (mbDoneProcess) {
|
|
System::getDialog()->terminate();
|
|
mState = STATE_DONE_DELETE;
|
|
}
|
|
}
|
|
|
|
void CdbBackup::stt_wait_del_msg_fns() {
|
|
if (System::getDialog()->getLastResult() != DialogWindow::RESULT_NONE) {
|
|
if (!System::getCdbManager()->isOverFlow()) {
|
|
System::getDialog()->callBtn1(MESG_CDBBACKUP_DELETE_FINISH, MESG_CMN_OK);
|
|
mState = STATE_WAIT_FINISH_MSG;
|
|
mState2 = STATE_FINISHED;
|
|
}
|
|
}
|
|
}
|
|
|
|
void CdbBackup::stt_wait_sd_back_msg() {
|
|
if (!System::getCdbManager()->getSDWorker()->is_working()) {
|
|
if (System::getCdbManager()->getSDWorker()->get_sd_state() == SDVFWorker::SD_STATE_INSERTED) {
|
|
System::getCdbManager()->getSDWorker()->mount_sd_async();
|
|
}
|
|
} else {
|
|
error_handling();
|
|
}
|
|
|
|
switch (System::getDialog()->getLastResult()) {
|
|
// "Yes"
|
|
case DialogWindow::RESULT_LEFT_BUTTON: {
|
|
if (System::getCdbManager()->getSDWorker()->is_working()) {
|
|
mState = STATE_WAIT_WORKER;
|
|
mState2 = 8;
|
|
} else {
|
|
mState = STATE_SD_CHECK_ERR;
|
|
}
|
|
break;
|
|
}
|
|
// "No"
|
|
case DialogWindow::RESULT_RIGHT_BUTTON: {
|
|
// @bug Should set `bSwapSound` to true
|
|
System::getDialog()->callBtn2(MESG_CDBBACKUP_ASK_FOR_DELETE, MESG_CMN_NO, MESG_CMN_YES);
|
|
mState = STATE_DELETING_2;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void CdbBackup::stt_check_sd_err() {
|
|
SDVFWorker* sdVfWorker = System::getCdbManager()->getSDWorker();
|
|
switch (sdVfWorker->get_sd_state()) {
|
|
case SDVFWorker::SD_STATE_READY: {
|
|
if (sdVfWorker->is_sd_write_protected()) {
|
|
System::getDialog()->callBtn1(MESG_CDBBACKUP_SD_LOCKED, MESG_CMN_OK);
|
|
mState = STATE_WAIT_RET;
|
|
mState2 = STATE_MOUNT_SD;
|
|
} else {
|
|
sdVfWorker->prepare_cdb_backup_to_sd_async();
|
|
mState = STATE_WAIT_WORKER;
|
|
mState2 = STATE_SD_BACK_PREPARE;
|
|
}
|
|
break;
|
|
}
|
|
case SDVFWorker::SD_STATE_BROKEN:
|
|
case SDVFWorker::SD_STATE_ERROR: {
|
|
System::getDialog()->callBtn1(MESG_CDBBACKUP_SD_UNAVAILABLE, MESG_CMN_OK);
|
|
mState = STATE_WAIT_RET;
|
|
mState2 = STATE_MOUNT_SD;
|
|
break;
|
|
}
|
|
default: {
|
|
System::getDialog()->callBtn1(MESG_CDBBACKUP_SD_UNKNOWN_ERR, MESG_CMN_OK);
|
|
mState = STATE_WAIT_RET;
|
|
mState2 = STATE_MOUNT_SD;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void CdbBackup::stt_check_prepare_back() {
|
|
if (System::getCdbManager()->getSDWorker()->get_async_result() == SDVFWorker::RESULT_SUCCESS) {
|
|
mbDoneProcess = false;
|
|
System::getTask1()->request(cdb_backup_move_task_, this, NULL);
|
|
System::getDialog()->callBtnPrg(MESG_CDBBACKUP_BACKING);
|
|
mState = STATE_WAIT_SD_BACKING;
|
|
} else {
|
|
System::getDialog()->callBtn1(MESG_CDBBACKUP_SD_UNKNOWN_ERR, MESG_CMN_OK);
|
|
mState = STATE_WAIT_RET;
|
|
mState2 = STATE_MOUNT_SD;
|
|
}
|
|
}
|
|
|
|
void CdbBackup::stt_wait_backup() {
|
|
if (getProgressPercent() < 100) {
|
|
System::getDialog()->setProgBarLength(getProgressPercent());
|
|
}
|
|
|
|
if (mbDoneProcess) {
|
|
if (getProgressPercent() >= 100) {
|
|
System::getDialog()->setProgBarLength(100);
|
|
} else {
|
|
System::getDialog()->terminate();
|
|
}
|
|
mState = STATE_DONE_SD_BACK;
|
|
}
|
|
}
|
|
|
|
void CdbBackup::stt_wait_back_msg_fns() {
|
|
if (System::getDialog()->getLastResult() != DialogWindow::RESULT_NONE) {
|
|
cdb::Manager* cdbManager = System::getCdbManager();
|
|
|
|
switch (mCDBResult) {
|
|
case CDB_ERROR_OK: {
|
|
System::getDialog()->callBtn1(MESG_CDBBACKUP_BACK_FINISHED, MESG_CMN_OK);
|
|
mState = STATE_WAIT_FINISH_MSG;
|
|
mState2 = STATE_FINISHED_2;
|
|
break;
|
|
}
|
|
case CDB_ERROR_OUT_OF_SPACE: {
|
|
if (cdbManager->isOverFlow()) {
|
|
System::getDialog()->callBtn1(MESG_CDBBACKUP_BACK_SD_FULL, MESG_CMN_OK);
|
|
mState = STATE_WAIT_RET;
|
|
mState2 = STATE_CLEAN_SD_BACK;
|
|
} else {
|
|
System::getDialog()->callBtn1(MESG_CDBBACKUP_BACK_FINISHED_2, MESG_CMN_OK);
|
|
mState = STATE_WAIT_FINISH_MSG;
|
|
mState2 = STATE_FINISHED_2;
|
|
}
|
|
break;
|
|
}
|
|
default: {
|
|
System::getDialog()->callBtn1(MESG_CDBBACKUP_BACK_SD_ERROR, MESG_CMN_OK);
|
|
mState = STATE_WAIT_RET;
|
|
mState2 = STATE_CLEAN_SD_BACK;
|
|
}
|
|
}
|
|
mCDBResult = 0;
|
|
}
|
|
}
|
|
|
|
void CdbBackup::stt_wait_ret_msg() {
|
|
if (System::getDialog()->getLastResult() != DialogWindow::RESULT_NONE) {
|
|
mState = mState2;
|
|
mState2 = STATE_INVALID;
|
|
}
|
|
}
|
|
|
|
void CdbBackup::stt_wait_fns_msg() {
|
|
if (System::getDialog()->getLastResult() != DialogWindow::RESULT_NONE) {
|
|
mState = mState2;
|
|
mState2 = STATE_INVALID;
|
|
}
|
|
}
|
|
|
|
void CdbBackup::stt_clean_up_back() {
|
|
System::getCdbManager()->getSDWorker()->cleanup_cdb_backup_to_sd_async();
|
|
mState = STATE_WAIT_WORKER;
|
|
mState2 = STATE_MOUNT_SD;
|
|
}
|
|
|
|
void CdbBackup::stt_wait_terminate() {
|
|
if (System::getCdbManager()->getSDWorker()->is_terminated()) {
|
|
mState = STATE_FINISHED;
|
|
}
|
|
}
|
|
|
|
void CdbBackup::error_handling() {
|
|
switch (System::getCdbManager()->getSDWorker()->get_async_result()) {
|
|
// SD Card errors are considered corrupted system files??
|
|
case SDVFWorker::RESULT_FA_ERROR: {
|
|
IPLErrorLogAndDisplay(MESG_ERR_FILE, "SDVFWorker", SDVFWorker::RESULT_FA_ERROR, 592);
|
|
break;
|
|
}
|
|
// Unused code (likely left over from it's base, NandSDWorker)
|
|
case SDVFWorker::RESULT_NAND_CORRUPT: {
|
|
IPLErrorDisplay(MESG_ERR_NAND);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
int CdbBackup::getProgressPercent() {
|
|
return ((mTotalFreeSize - mPrevFreeSize) * 100) / ((0x1400000 - unknown) - mPrevFreeSize);
|
|
}
|
|
|
|
BOOL cdb_backup_delete_search_cb_(void* work, CDBRecord* record) {
|
|
CdbBackup* cdbBackup = reinterpret_cast<CdbBackup*>(work);
|
|
|
|
BOOL result = TRUE;
|
|
|
|
cdb::Manager* cdbManager = System::getCdbManager();
|
|
|
|
if (cdbManager->remove(record)) {
|
|
cdbManager->getFreeSize();
|
|
if (cdbManager->isUnderFlow()) {
|
|
result = FALSE;
|
|
}
|
|
} else {
|
|
result = FALSE;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
#ifdef __MWERKS__
|
|
extern "C" System::Arg smArg__Q23ipl6System;
|
|
extern "C" void cdb_backup_delete_search_cb___3iplFPvP10_CDBRecord();
|
|
extern "C" void cdb_backup_move_search_cb___3iplFPvP10_CDBRecord();
|
|
extern "C" void getFreeSize__Q33ipl3cdb7ManagerFPUl();
|
|
extern "C" void search__Q33ipl3cdb7ManagerFRCUlRCUl18CDBSearchDirection17CDBRecordLocationiPFPvP10_CDBRecord_iPv();
|
|
extern "C" void cleanUpEmptyDirectories__Q33ipl3cdb7ManagerF17CDBRecordLocation();
|
|
|
|
asm void cdb_backup_delete_task_(register void* work) {
|
|
nofralloc
|
|
|
|
stwu r1, -0x20(r1)
|
|
mflr r0
|
|
li r4, 0
|
|
li r5, 1
|
|
stw r0, 0x24(r1)
|
|
li r6, 0
|
|
li r7, 0
|
|
li r8, 0
|
|
stw r31, 0x1c(r1)
|
|
mr r31, r3
|
|
li r3, 0x7d0
|
|
bl CDBMakeCDBDate
|
|
stw r3, 0xc(r1)
|
|
li r3, 0x7f3
|
|
li r4, 0xc
|
|
li r5, 0x1f
|
|
li r6, 0x17
|
|
li r7, 0x3b
|
|
li r8, 0x3b
|
|
bl CDBMakeCDBDate
|
|
lis r4, smArg__Q23ipl6System@ha
|
|
stw r3, 0x8(r1)
|
|
addi r4, r4, smArg__Q23ipl6System@l
|
|
lbz r0, 0x2bc(r4)
|
|
cmpwi r0, 0
|
|
beq cdb_backup_delete_task_L1
|
|
li r3, 0
|
|
b cdb_backup_delete_task_L2
|
|
cdb_backup_delete_task_L1:
|
|
lwz r3, 0x7c(r4)
|
|
cdb_backup_delete_task_L2:
|
|
lis r9, cdb_backup_delete_search_cb___3iplFPvP10_CDBRecord@ha
|
|
mr r10, r31
|
|
addi r4, r1, 0xc
|
|
addi r5, r1, 0x8
|
|
addi r9, r9, cdb_backup_delete_search_cb___3iplFPvP10_CDBRecord@l
|
|
li r6, 1
|
|
li r7, 1
|
|
li r8, 0
|
|
bl search__Q33ipl3cdb7ManagerFRCUlRCUl18CDBSearchDirection17CDBRecordLocationiPFPvP10_CDBRecord_iPv
|
|
lis r3, smArg__Q23ipl6System@ha
|
|
addi r3, r3, smArg__Q23ipl6System@l
|
|
lbz r0, 0x2bc(r3)
|
|
cmpwi r0, 0
|
|
beq cdb_backup_delete_task_L3
|
|
li r3, 0
|
|
b cdb_backup_delete_task_L4
|
|
cdb_backup_delete_task_L3:
|
|
lwz r3, 0x7c(r3)
|
|
cdb_backup_delete_task_L4:
|
|
li r4, 1
|
|
bl cleanUpEmptyDirectories__Q33ipl3cdb7ManagerF17CDBRecordLocation
|
|
li r0, 1
|
|
stb r0, 0(r31)
|
|
lwz r0, 0x24(r1)
|
|
lwz r31, 0x1c(r1)
|
|
mtlr r0
|
|
addi r1, r1, 0x20
|
|
blr
|
|
}
|
|
#else
|
|
void cdb_backup_delete_task_(void* work) {
|
|
CdbBackup* cdbBackup = reinterpret_cast<CdbBackup*>(work);
|
|
|
|
CDBDate beginDate = CDBMakeCDBDate(MIN_YEAR, MIN_MONTH - 1, MIN_DAY, MIN_HOUR, MIN_MINUTE, MIN_SECOND);
|
|
// @Bug should be MAX_MONTH-1
|
|
CDBDate endDate = CDBMakeCDBDate(MAX_YEAR, MAX_MONTH, MAX_DAY, MAX_HOUR, MAX_MINUTE, MAX_SECOND);
|
|
|
|
System::getCdbManager()->search(beginDate, endDate, CDB_SEARCH_DIRECTION_RIGHT, CDB_RECORD_LOCATION_NAND, 0, cdb_backup_delete_search_cb_,
|
|
cdbBackup);
|
|
|
|
System::getCdbManager()->cleanUpEmptyDirectories(CDB_RECORD_LOCATION_NAND);
|
|
|
|
cdbBackup->set_done_process(true);
|
|
}
|
|
#endif
|
|
|
|
BOOL cdb_backup_move_search_cb_(void* work, CDBRecord* record) {
|
|
CdbBackup* cdbBackup = reinterpret_cast<CdbBackup*>(work);
|
|
|
|
BOOL result = TRUE;
|
|
|
|
cdb::Manager* cdbManager = System::getCdbManager();
|
|
|
|
u32 freeSize = 0;
|
|
|
|
BOOL result2 = cdbManager->backupToSD(record);
|
|
cdbBackup->set_cdb_result(cdbManager->getCDBResult());
|
|
|
|
if (result2) {
|
|
cdbManager->getFreeSize(&freeSize);
|
|
cdbBackup->set_free_size(freeSize);
|
|
if (cdbManager->isUnderFlow()) {
|
|
result = FALSE;
|
|
}
|
|
} else {
|
|
result = FALSE;
|
|
}
|
|
|
|
cdbManager->close(record);
|
|
|
|
return result;
|
|
}
|
|
|
|
#ifdef __MWERKS__
|
|
asm void cdb_backup_move_task_(register void* work) {
|
|
nofralloc
|
|
|
|
stwu r1, -0x20(r1)
|
|
mflr r0
|
|
li r4, 0
|
|
li r5, 1
|
|
stw r0, 0x24(r1)
|
|
li r6, 0
|
|
li r7, 0
|
|
li r8, 0
|
|
stw r31, 0x1c(r1)
|
|
mr r31, r3
|
|
li r3, 0x7d0
|
|
bl CDBMakeCDBDate
|
|
stw r3, 0x10(r1)
|
|
li r3, 0x7f3
|
|
li r4, 0xc
|
|
li r5, 0x1f
|
|
li r6, 0x17
|
|
li r7, 0x3b
|
|
li r8, 0x3b
|
|
bl CDBMakeCDBDate
|
|
lis r4, smArg__Q23ipl6System@ha
|
|
stw r3, 0xc(r1)
|
|
addi r4, r4, smArg__Q23ipl6System@l
|
|
lbz r0, 0x2bc(r4)
|
|
cmpwi r0, 0
|
|
beq cdb_backup_move_task_L1
|
|
li r3, 0
|
|
b cdb_backup_move_task_L2
|
|
cdb_backup_move_task_L1:
|
|
lwz r3, 0x7c(r4)
|
|
cdb_backup_move_task_L2:
|
|
addi r4, r1, 0x8
|
|
bl getFreeSize__Q33ipl3cdb7ManagerFPUl
|
|
lwz r0, 0x8(r1)
|
|
lis r3, smArg__Q23ipl6System@ha
|
|
addi r3, r3, smArg__Q23ipl6System@l
|
|
stw r0, 0x8(r31)
|
|
lwz r0, 0x8(r1)
|
|
stw r0, 0xc(r31)
|
|
lbz r0, 0x2bc(r3)
|
|
cmpwi r0, 0
|
|
beq cdb_backup_move_task_L3
|
|
li r3, 0
|
|
b cdb_backup_move_task_L4
|
|
cdb_backup_move_task_L3:
|
|
lwz r3, 0x7c(r3)
|
|
cdb_backup_move_task_L4:
|
|
lis r9, cdb_backup_move_search_cb___3iplFPvP10_CDBRecord@ha
|
|
mr r10, r31
|
|
addi r4, r1, 0x10
|
|
addi r5, r1, 0xc
|
|
addi r9, r9, cdb_backup_move_search_cb___3iplFPvP10_CDBRecord@l
|
|
li r6, 1
|
|
li r7, 1
|
|
li r8, 1
|
|
bl search__Q33ipl3cdb7ManagerFRCUlRCUl18CDBSearchDirection17CDBRecordLocationiPFPvP10_CDBRecord_iPv
|
|
lis r3, smArg__Q23ipl6System@ha
|
|
addi r3, r3, smArg__Q23ipl6System@l
|
|
lbz r0, 0x2bc(r3)
|
|
cmpwi r0, 0
|
|
beq cdb_backup_move_task_L5
|
|
li r3, 0
|
|
b cdb_backup_move_task_L6
|
|
cdb_backup_move_task_L5:
|
|
lwz r3, 0x7c(r3)
|
|
cdb_backup_move_task_L6:
|
|
li r4, 1
|
|
bl cleanUpEmptyDirectories__Q33ipl3cdb7ManagerF17CDBRecordLocation
|
|
li r0, 1
|
|
stb r0, 0(r31)
|
|
lwz r0, 0x24(r1)
|
|
lwz r31, 0x1c(r1)
|
|
mtlr r0
|
|
addi r1, r1, 0x20
|
|
blr
|
|
}
|
|
#else
|
|
void cdb_backup_move_task_(void* work) {
|
|
CdbBackup* cdbBackup = reinterpret_cast<CdbBackup*>(work);
|
|
|
|
const CDBDate beginDate = CDBMakeCDBDate(MIN_YEAR, MIN_MONTH - 1, MIN_DAY, MIN_HOUR, MIN_MINUTE, MIN_SECOND);
|
|
// @Bug should be MAX_MONTH-1
|
|
const CDBDate endDate = CDBMakeCDBDate(MAX_YEAR, MAX_MONTH, MAX_DAY, MAX_HOUR, MAX_MINUTE, MAX_SECOND);
|
|
u32 freeSize;
|
|
|
|
System::getCdbManager()->getFreeSize(&freeSize);
|
|
|
|
cdbBackup->set_prev_free_size(freeSize);
|
|
cdbBackup->set_free_size(freeSize);
|
|
|
|
System::getCdbManager()->search(beginDate, endDate, CDB_SEARCH_DIRECTION_RIGHT, CDB_RECORD_LOCATION_NAND, 1, cdb_backup_move_search_cb_,
|
|
cdbBackup);
|
|
|
|
System::getCdbManager()->cleanUpEmptyDirectories(CDB_RECORD_LOCATION_NAND);
|
|
|
|
cdbBackup->set_done_process(true);
|
|
}
|
|
#endif
|
|
} // namespace ipl
|