JS_REQUIRES_STACK AbortableRecordingStatus
TraceRecorder::downRecursion()
{
JSStackFrame* fp = cx->fp;
if ((jsbytecode*)fragment->ip < fp->script->code ||
(jsbytecode*)fragment->ip >= fp->script->code + fp->script->length) {
RETURN_STOP_A("inner recursive call must compile first");
}
/* Adjust the stack by the budget the down-frame needs. */
int slots = NativeStackSlots(cx, 1) - NativeStackSlots(cx, 0);
JS_ASSERT(unsigned(slots) == NativeStackSlots(cx, 1) - fp->argc - 2 - fp->script->nfixed - 2);
/* Guard that there is enough stack space. */
JS_ASSERT(tree->maxNativeStackSlots >= tree->nativeStackBase / sizeof(double));
int guardSlots = slots + tree->maxNativeStackSlots -
tree->nativeStackBase / sizeof(double);
LIns* sp_top = lir->ins2(LIR_piadd, lirbuf->sp, lir->insImmWord(guardSlots * sizeof(double)));
guard(true, lir->ins2(LIR_plt, sp_top, eos_ins), OOM_EXIT);
/* Guard that there is enough call stack space. */
LIns* rp_top = lir->ins2(LIR_piadd, lirbuf->rp, lir->insImmWord(sizeof(FrameInfo*)));
guard(true, lir->ins2(LIR_plt, rp_top, eor_ins), OOM_EXIT);
/*
* For every slot in the new frame that is not in the tracker, create a load
* in the tracker. This is necessary because otherwise snapshot() will see
* missing imports and use the down frame, rather than the new frame.
* This won't affect performance because the loads will be killed if not
* used.
*/
ImportFrameSlotsVisitor visitor(*this);
VisitStackSlots(visitor, cx, callDepth);
/* Add space for a new JIT frame. */
lirbuf->sp = lir->ins2(LIR_piadd, lirbuf->sp, lir->insImmWord(slots * sizeof(double)));
lir->insStorei(lirbuf->sp, lirbuf->state, offsetof(InterpState, sp));
lirbuf->rp = lir->ins2(LIR_piadd, lirbuf->rp, lir->insImmWord(sizeof(FrameInfo*)));
lir->insStorei(lirbuf->rp, lirbuf->state, offsetof(InterpState, rp));
--callDepth;
clearCurrentFrameSlotsFromTracker(nativeFrameTracker);
/*
* If the callee and caller have identical call sites, this is a down-
* recursive loop. Otherwise something special happened. For example, a
* recursive call that is unwinding could nest back down recursively again.
* In this case, we build a fragment that ideally we'll never invoke
* directly, but link from a down-recursive branch. The UNLINKED_EXIT tells
* closeLoop() that the peer trees should match the recursive pc, not the
* tree pc.
*/
VMSideExit* exit;
if ((jsbytecode*)fragment->root->ip == fp->script->code)
exit = snapshot(UNSTABLE_LOOP_EXIT);
else
exit = snapshot(RECURSIVE_UNLINKED_EXIT);
exit->recursive_pc = fp->script->code;
debug_only_print0(LC_TMTracer, "Compiling down-recursive function call.\n");
JS_ASSERT(tree->recursion != Recursion_Disallowed);
tree->recursion = Recursion_Detected;
return closeLoop(exit);
}
void
StorageComponent::setDistribution(DistributionSP distribution)
{
std::lock_guard guard(_lock);
_distribution = distribution;
}
bool GlobalCache::has_seen(STATE, Symbol* sym) {
utilities::thread::SpinLock::LockGuard guard(lock_);
SeenMethodSet::const_iterator seen = seen_methods.find(sym->index());
return seen != seen_methods.end();
}
void
StorageComponent::setDocumentTypeRepo(DocumentTypeRepoSP repo)
{
std::lock_guard guard(_lock);
_docTypeRepo = repo;
}
void
StorageComponent::setLoadTypes(LoadTypeSetSP loadTypes)
{
std::lock_guard guard(_lock);
_loadTypes = loadTypes;
}
StorageComponent::LoadTypeSetSP
StorageComponent::getLoadTypes() const
{
std::lock_guard guard(_lock);
return _loadTypes;
}
StorageComponent::DistributionSP
StorageComponent::getDistribution() const
{
std::lock_guard guard(_lock);
return _distribution;
}
ComboBox::ActionGuard<ComboBox::TextChangeAction> ComboBox::SetTextChangeAction(TextChangeAction action) {
ActionGuard<TextChangeAction> guard(&text_change_action_, TextChangeAction::UnselectDropDownItem);
text_change_action_ = action;
return guard;
}
StorageComponent::DocumentTypeRepoSP
StorageComponent::getTypeRepo() const
{
std::lock_guard guard(_lock);
return _docTypeRepo;
}
void SoapServerInternal::SetProtocolBinding(const string& url, SoapProtocol* binding)
{
lock_guard<mutex> guard(m_protocolLock);
m_protocolBindings[url] = binding;
}
ComboBox::ActionGuard<ComboBox::SelectionChangeAction> ComboBox::SetSelectionChangeAction(SelectionChangeAction action) {
ActionGuard<SelectionChangeAction> guard(&selection_change_action_, SelectionChangeAction::CloseDropDownWindow);
selection_change_action_ = action;
return guard;
}
bool Bra::isUnconditional() const
{
return guard()->isAlwaysTrue();
}
void Instruction::setGuard(PredicateOperand* p)
{
delete guard();
reads[0] = p;
}
JS_REQUIRES_STACK LIns*
TraceRecorder::slurpNullSlot(LIns* val_ins, jsval* vp, VMSideExit* exit)
{
guard(true, lir->ins_peq0(val_ins), exit);
return val_ins;
}
void
FeedHandler::changeFeedState(FeedState::SP newState)
{
std::lock_guard<std::mutex> guard(_feedLock);
changeFeedState(std::move(newState), guard);
}
void GlobalCache::add_seen(STATE, Symbol* sym) {
utilities::thread::SpinLock::LockGuard guard(lock_);
seen_methods.insert(sym->index());
}
void AuthorizationManagerImpl::invalidateUserCache() {
CacheGuard guard(this, CacheGuard::fetchSynchronizationManual);
_invalidateUserCache_inlock();
}
Status AuthorizationManagerImpl::acquireUser(OperationContext* opCtx,
const UserName& userName,
User** acquiredUser) {
if (userName == internalSecurity.user->getName()) {
*acquiredUser = internalSecurity.user;
return Status::OK();
}
stdx::unordered_map<UserName, User*>::iterator it;
CacheGuard guard(this, CacheGuard::fetchSynchronizationManual);
while ((_userCache.end() == (it = _userCache.find(userName))) &&
guard.otherUpdateInFetchPhase()) {
guard.wait();
}
if (it != _userCache.end()) {
fassert(16914, it->second);
fassert(17003, it->second->isValid());
fassert(17008, it->second->getRefCount() > 0);
it->second->incrementRefCount();
*acquiredUser = it->second;
return Status::OK();
}
std::unique_ptr<User> user;
int authzVersion = _version;
guard.beginFetchPhase();
// Number of times to retry a user document that fetches due to transient
// AuthSchemaIncompatible errors. These errors should only ever occur during and shortly
// after schema upgrades.
static const int maxAcquireRetries = 2;
Status status = Status::OK();
for (int i = 0; i < maxAcquireRetries; ++i) {
if (authzVersion == schemaVersionInvalid) {
Status status = _externalState->getStoredAuthorizationVersion(opCtx, &authzVersion);
if (!status.isOK())
return status;
}
switch (authzVersion) {
default:
status = Status(ErrorCodes::BadValue,
mongoutils::str::stream()
<< "Illegal value for authorization data schema version, "
<< authzVersion);
break;
case schemaVersion28SCRAM:
case schemaVersion26Final:
case schemaVersion26Upgrade:
status = _fetchUserV2(opCtx, userName, &user);
break;
case schemaVersion24:
status = Status(ErrorCodes::AuthSchemaIncompatible,
mongoutils::str::stream()
<< "Authorization data schema version "
<< schemaVersion24
<< " not supported after MongoDB version 2.6.");
break;
}
if (status.isOK())
break;
if (status != ErrorCodes::AuthSchemaIncompatible)
return status;
authzVersion = schemaVersionInvalid;
}
if (!status.isOK())
return status;
guard.endFetchPhase();
user->incrementRefCount();
// NOTE: It is not safe to throw an exception from here to the end of the method.
if (guard.isSameCacheGeneration()) {
_userCache.insert(std::make_pair(userName, user.get()));
if (_version == schemaVersionInvalid)
_version = authzVersion;
} else {
// If the cache generation changed while this thread was in fetch mode, the data
// associated with the user may now be invalid, so we must mark it as such. The caller
// may still opt to use the information for a short while, but not indefinitely.
user->invalidate();
}
*acquiredUser = user.release();
return Status::OK();
}
JS_REQUIRES_STACK AbortableRecordingStatus
TraceRecorder::slurpDownFrames(jsbytecode* return_pc)
{
/* Missing - no go */
if (cx->fp->argc != cx->fp->fun->nargs)
RETURN_STOP_A("argc != nargs");
LIns* argv_ins;
unsigned frameDepth;
unsigned downPostSlots;
JSStackFrame* fp = cx->fp;
LIns* fp_ins = addName(lir->insLoad(LIR_ldp, cx_ins, offsetof(JSContext, fp)), "fp");
/*
* When first emitting slurp code, do so against the down frame. After
* popping the interpreter frame, it is illegal to resume here, as the
* down frame has been moved up. So all this code should be skipped if
* anchoring off such an exit.
*/
if (!anchor || anchor->exitType != RECURSIVE_SLURP_FAIL_EXIT) {
fp_ins = addName(lir->insLoad(LIR_ldp, fp_ins, offsetof(JSStackFrame, down)), "downFp");
fp = fp->down;
argv_ins = addName(lir->insLoad(LIR_ldp, fp_ins, offsetof(JSStackFrame, argv)), "argv");
/* If recovering from a SLURP_MISMATCH, all of this is unnecessary. */
if (!anchor || anchor->exitType != RECURSIVE_SLURP_MISMATCH_EXIT) {
/* fp->down should not be NULL. */
guard(false, lir->ins_peq0(fp_ins), RECURSIVE_LOOP_EXIT);
/* fp->down->argv should not be NULL. */
guard(false, lir->ins_peq0(argv_ins), RECURSIVE_LOOP_EXIT);
/*
* Guard on the script being the same. This might seem unnecessary,
* but it lets the recursive loop end cleanly if it doesn't match.
* With only the pc check, it is harder to differentiate between
* end-of-recursion and recursion-returns-to-different-pc.
*/
guard(true,
lir->ins2(LIR_peq,
addName(lir->insLoad(LIR_ldp,
fp_ins,
offsetof(JSStackFrame, script)),
"script"),
INS_CONSTPTR(cx->fp->down->script)),
RECURSIVE_LOOP_EXIT);
}
/* fp->down->regs->pc should be == pc. */
guard(true,
lir->ins2(LIR_peq,
lir->insLoad(LIR_ldp,
addName(lir->insLoad(LIR_ldp, fp_ins, offsetof(JSStackFrame, regs)),
"regs"),
offsetof(JSFrameRegs, pc)),
INS_CONSTPTR(return_pc)),
RECURSIVE_SLURP_MISMATCH_EXIT);
/* fp->down->argc should be == argc. */
guard(true,
lir->ins2(LIR_eq,
addName(lir->insLoad(LIR_ld, fp_ins, offsetof(JSStackFrame, argc)),
"argc"),
INS_CONST(cx->fp->argc)),
MISMATCH_EXIT);
/* Pop the interpreter frame. */
LIns* args[] = { lirbuf->state, cx_ins };
guard(false, lir->ins_eq0(lir->insCall(&js_PopInterpFrame_ci, args)), MISMATCH_EXIT);
/* Compute slots for the down frame. */
downPostSlots = NativeStackSlots(cx, 1) - NativeStackSlots(cx, 0);
frameDepth = 1;
} else {
/* Note: loading argv from fp, not fp->down. */
argv_ins = addName(lir->insLoad(LIR_ldp, fp_ins, offsetof(JSStackFrame, argv)), "argv");
/* Slots for this frame, minus the return value. */
downPostSlots = NativeStackSlots(cx, 0) - 1;
frameDepth = 0;
}
/*
* This is a special exit used as a template for the stack-slurping code.
* LeaveTree will ignore all but the final slot, which contains the return
* value. The slurpSlot variable keeps track of the last slot that has been
* unboxed, as to avoid re-unboxing when taking a SLURP_FAIL exit.
*/
unsigned numGlobalSlots = tree->globalSlots->length();
unsigned safeSlots = NativeStackSlots(cx, frameDepth) + 1 + numGlobalSlots;
jsbytecode* recursive_pc = return_pc + JSOP_CALL_LENGTH;
VMSideExit* exit = (VMSideExit*)
traceMonitor->traceAlloc->alloc(sizeof(VMSideExit) + sizeof(TraceType) * safeSlots);
memset(exit, 0, sizeof(VMSideExit));
exit->pc = (jsbytecode*)recursive_pc;
exit->from = fragment;
exit->exitType = RECURSIVE_SLURP_FAIL_EXIT;
exit->numStackSlots = downPostSlots + 1;
exit->numGlobalSlots = numGlobalSlots;
exit->sp_adj = ((downPostSlots + 1) * sizeof(double)) - tree->nativeStackBase;
exit->recursive_pc = recursive_pc;
/*
* Build the exit typemap. This may capture extra types, but they are
* thrown away.
*/
TraceType* typeMap = exit->stackTypeMap();
jsbytecode* oldpc = cx->fp->regs->pc;
cx->fp->regs->pc = exit->pc;
CaptureStackTypes(cx, frameDepth, typeMap);
cx->fp->regs->pc = oldpc;
if (!anchor || anchor->exitType != RECURSIVE_SLURP_FAIL_EXIT)
typeMap[downPostSlots] = determineSlotType(&stackval(-1));
else
typeMap[downPostSlots] = anchor->stackTypeMap()[anchor->numStackSlots - 1];
determineGlobalTypes(&typeMap[exit->numStackSlots]);
#if defined JS_JIT_SPEW
TreevisLogExit(cx, exit);
#endif
/*
* Return values are tricky because there are two cases. Anchoring off a
* slurp failure (the second case) means the return value has already been
* moved. However it can still be promoted to link trees together, so we
* load it from the new location.
*
* In all other cases, the return value lives in the tracker and it can be
* grabbed safely.
*/
LIns* rval_ins;
TraceType returnType = exit->stackTypeMap()[downPostSlots];
if (!anchor || anchor->exitType != RECURSIVE_SLURP_FAIL_EXIT) {
rval_ins = get(&stackval(-1));
if (returnType == TT_INT32) {
JS_ASSERT(determineSlotType(&stackval(-1)) == TT_INT32);
JS_ASSERT(isPromoteInt(rval_ins));
rval_ins = demote(lir, rval_ins);
}
/*
* The return value must be written out early, before slurping can fail,
* otherwise it will not be available when there's a type mismatch.
*/
lir->insStorei(rval_ins, lirbuf->sp, exit->sp_adj - sizeof(double));
} else {
switch (returnType)
{
case TT_PSEUDOBOOLEAN:
case TT_INT32:
rval_ins = lir->insLoad(LIR_ld, lirbuf->sp, exit->sp_adj - sizeof(double));
break;
case TT_DOUBLE:
rval_ins = lir->insLoad(LIR_ldf, lirbuf->sp, exit->sp_adj - sizeof(double));
break;
case TT_FUNCTION:
case TT_OBJECT:
case TT_STRING:
case TT_NULL:
rval_ins = lir->insLoad(LIR_ldp, lirbuf->sp, exit->sp_adj - sizeof(double));
break;
default:
JS_NOT_REACHED("unknown type");
RETURN_STOP_A("unknown type");
}
}
/* Slurp */
SlurpInfo info;
info.curSlot = 0;
info.exit = exit;
info.typeMap = typeMap;
info.slurpFailSlot = (anchor && anchor->exitType == RECURSIVE_SLURP_FAIL_EXIT) ?
anchor->slurpFailSlot : 0;
/* callee */
slurpSlot(lir->insLoad(LIR_ldp, argv_ins, -2 * ptrdiff_t(sizeof(jsval))),
&fp->argv[-2],
&info);
/* this */
slurpSlot(lir->insLoad(LIR_ldp, argv_ins, -1 * ptrdiff_t(sizeof(jsval))),
&fp->argv[-1],
&info);
/* args[0..n] */
for (unsigned i = 0; i < JS_MAX(fp->argc, fp->fun->nargs); i++)
slurpSlot(lir->insLoad(LIR_ldp, argv_ins, i * sizeof(jsval)), &fp->argv[i], &info);
/* argsobj */
slurpSlot(addName(lir->insLoad(LIR_ldp, fp_ins, offsetof(JSStackFrame, argsobj)), "argsobj"),
&fp->argsobj,
&info);
/* scopeChain */
slurpSlot(addName(lir->insLoad(LIR_ldp, fp_ins, offsetof(JSStackFrame, scopeChain)), "scopeChain"),
(jsval*) &fp->scopeChain,
&info);
/* vars */
LIns* slots_ins = addName(lir->insLoad(LIR_ldp, fp_ins, offsetof(JSStackFrame, slots)),
"slots");
for (unsigned i = 0; i < fp->script->nfixed; i++)
slurpSlot(lir->insLoad(LIR_ldp, slots_ins, i * sizeof(jsval)), &fp->slots[i], &info);
/* stack vals */
unsigned nfixed = fp->script->nfixed;
jsval* stack = StackBase(fp);
LIns* stack_ins = addName(lir->ins2(LIR_piadd,
slots_ins,
INS_CONSTWORD(nfixed * sizeof(jsval))),
"stackBase");
size_t limit = size_t(fp->regs->sp - StackBase(fp));
if (anchor && anchor->exitType == RECURSIVE_SLURP_FAIL_EXIT)
limit--;
else
limit -= fp->fun->nargs + 2;
for (size_t i = 0; i < limit; i++)
slurpSlot(lir->insLoad(LIR_ldp, stack_ins, i * sizeof(jsval)), &stack[i], &info);
JS_ASSERT(info.curSlot == downPostSlots);
/* Jump back to the start */
exit = copy(exit);
exit->exitType = UNSTABLE_LOOP_EXIT;
#if defined JS_JIT_SPEW
TreevisLogExit(cx, exit);
#endif
RecursiveSlotMap slotMap(*this, downPostSlots, rval_ins);
for (unsigned i = 0; i < downPostSlots; i++)
slotMap.addSlot(typeMap[i]);
slotMap.addSlot(&stackval(-1), typeMap[downPostSlots]);
VisitGlobalSlots(slotMap, cx, *tree->globalSlots);
debug_only_print0(LC_TMTracer, "Compiling up-recursive slurp...\n");
exit = copy(exit);
if (exit->recursive_pc == fragment->root->ip)
exit->exitType = UNSTABLE_LOOP_EXIT;
else
exit->exitType = RECURSIVE_UNLINKED_EXIT;
debug_only_printf(LC_TMTreeVis, "TREEVIS CHANGEEXIT EXIT=%p TYPE=%s\n", (void*)exit,
getExitName(exit->exitType));
JS_ASSERT(tree->recursion >= Recursion_Unwinds);
return closeLoop(slotMap, exit);
}
std::exception_ptr rt_kafka_link_t::get_closing_error() {
std::unique_lock<mutex_t> guard(closing_error_lock_);
return closing_error_;
}
OID AuthorizationManagerImpl::getCacheGeneration() {
CacheGuard guard(this, CacheGuard::fetchSynchronizationManual);
return _cacheGeneration;
}
void PSPSaveDialog::DisplaySaveDataInfo2(bool showNewData) {
std::lock_guard<std::mutex> guard(paramLock);
tm modif_time;
const char *save_title;
u32 data_size;
if (showNewData || param.GetFileInfo(currentSelectedSave).size == 0) {
time_t t;
time(&t);
localtime_r(&t, &modif_time);
save_title = param.GetPspParam()->sfoParam.savedataTitle;
// TODO: Account for icon, etc., etc.
data_size = param.GetPspParam()->dataSize;
} else {
modif_time = param.GetFileInfo(currentSelectedSave).modif_time;
save_title = param.GetFileInfo(currentSelectedSave).saveTitle;
data_size = param.GetFileInfo(currentSelectedSave).size;
}
char date[256];
char am_pm[] = "AM";
char hour_time[10] ;
int hour = modif_time.tm_hour;
int min = modif_time.tm_min;
switch (g_Config.iTimeFormat) {
case 1:
if (hour > 12) {
strcpy(am_pm, "PM");
hour -= 12;
}
snprintf(hour_time, 10, "%02d:%02d %s", hour, min, am_pm);
break;
case 2:
snprintf(hour_time, 10, "%02d:%02d", hour, min);
break;
default:
if (hour > 12) {
strcpy(am_pm, "PM");
hour -= 12;
}
snprintf(hour_time, 10, "%02d:%02d %s", hour, min, am_pm);
}
int day = modif_time.tm_mday;
int month = modif_time.tm_mon + 1;
int year = modif_time.tm_year + 1900;
s64 sizeK = data_size / 1024;
switch (g_Config.iDateFormat) {
case 1:
snprintf(date, 256, "%d/%02d/%02d", year, month, day);
break;
case 2:
snprintf(date, 256, "%02d/%02d/%d", month, day, year);
break;
case 3:
snprintf(date, 256, "%02d/%02d/%d", day, month, year);
break;
default:
snprintf(date, 256, "%d/%02d/%02d", year, month, day);
}
std::string saveinfoTxt = StringFromFormat("%.128s\n%s %s\n%lld KB", save_title, date, hour_time, sizeK);
PPGeDrawText(saveinfoTxt.c_str(), 9, 202, PPGE_ALIGN_LEFT, 0.5f, CalcFadedColor(0x80000000));
PPGeDrawText(saveinfoTxt.c_str(), 8, 200, PPGE_ALIGN_LEFT, 0.5f, CalcFadedColor(0xFFFFFFFF));
}
int PSPSaveDialog::Update(int animSpeed)
{
if (GetStatus() != SCE_UTILITY_STATUS_RUNNING)
return SCE_ERROR_UTILITY_INVALID_STATUS;
if (!param.GetPspParam()) {
ChangeStatusShutdown(SAVEDATA_SHUTDOWN_DELAY_US);
return 0;
}
if (pendingStatus != SCE_UTILITY_STATUS_RUNNING) {
// We're actually done, we're just waiting to tell the game that.
return 0;
}
// The struct may have been updated by the game. This happens in "Where Is My Heart?"
// Check if it has changed, reload it.
// TODO: Cut down on preloading? This rebuilds the list from scratch.
int size = Memory::Read_U32(requestAddr);
if (memcmp(Memory::GetPointer(requestAddr), &originalRequest, size) != 0) {
memset(&request, 0, sizeof(request));
Memory::Memcpy(&request, requestAddr, size);
Memory::Memcpy(&originalRequest, requestAddr, size);
std::lock_guard<std::mutex> guard(paramLock);
param.SetPspParam(&request);
}
UpdateButtons();
UpdateFade(animSpeed);
okButtonImg = I_CIRCLE;
cancelButtonImg = I_CROSS;
okButtonFlag = CTRL_CIRCLE;
cancelButtonFlag = CTRL_CROSS;
if (param.GetPspParam()->common.buttonSwap == 1) {
okButtonImg = I_CROSS;
cancelButtonImg = I_CIRCLE;
okButtonFlag = CTRL_CROSS;
cancelButtonFlag = CTRL_CIRCLE;
}
I18NCategory *di = GetI18NCategory("Dialog");
switch (display)
{
case DS_SAVE_LIST_CHOICE:
StartDraw();
DisplaySaveList();
DisplaySaveDataInfo1();
DisplayButtons(DS_BUTTON_OK | DS_BUTTON_CANCEL);
DisplayBanner(DB_SAVE);
if (IsButtonPressed(cancelButtonFlag)) {
param.GetPspParam()->common.result = SCE_UTILITY_DIALOG_RESULT_CANCEL;
StartFade(false);
} else if (IsButtonPressed(okButtonFlag)) {
// Save exist, ask user confirm
if (param.GetFileInfo(currentSelectedSave).size > 0) {
yesnoChoice = 0;
display = DS_SAVE_CONFIRM_OVERWRITE;
} else {
display = DS_SAVE_SAVING;
StartIOThread();
}
}
EndDraw();
break;
case DS_SAVE_CONFIRM:
StartDraw();
DisplaySaveIcon(false);
DisplaySaveDataInfo2(true);
DisplayMessage(di->T("Confirm Save", "Do you want to save this data?"), true);
DisplayButtons(DS_BUTTON_OK | DS_BUTTON_CANCEL);
DisplayBanner(DB_SAVE);
if (IsButtonPressed(cancelButtonFlag) || (IsButtonPressed(okButtonFlag) && yesnoChoice == 0)) {
param.GetPspParam()->common.result = SCE_UTILITY_DIALOG_RESULT_CANCEL;
StartFade(false);
} else if (IsButtonPressed(okButtonFlag)) {
display = DS_SAVE_SAVING;
StartIOThread();
}
EndDraw();
break;
case DS_SAVE_CONFIRM_OVERWRITE:
StartDraw();
DisplaySaveIcon(true);
DisplaySaveDataInfo2();
DisplayMessage(di->T("Confirm Overwrite","Do you want to overwrite the data?"), true);
DisplayButtons(DS_BUTTON_OK | DS_BUTTON_CANCEL);
DisplayBanner(DB_SAVE);
if (IsButtonPressed(cancelButtonFlag) || (IsButtonPressed(okButtonFlag) && yesnoChoice == 0)) {
if (param.GetPspParam()->mode != SCE_UTILITY_SAVEDATA_TYPE_SAVE)
display = DS_SAVE_LIST_CHOICE;
else {
param.GetPspParam()->common.result = SCE_UTILITY_DIALOG_RESULT_CANCEL;
StartFade(false);
}
} else if (IsButtonPressed(okButtonFlag)) {
display = DS_SAVE_SAVING;
StartIOThread();
}
EndDraw();
break;
case DS_SAVE_SAVING:
if (ioThreadStatus != SAVEIO_PENDING) {
JoinIOThread();
}
StartDraw();
DisplaySaveIcon(true);
DisplaySaveDataInfo2(true);
DisplayMessage(di->T("Saving","Saving\nPlease Wait..."));
DisplayBanner(DB_SAVE);
EndDraw();
break;
case DS_SAVE_FAILED:
JoinIOThread();
StartDraw();
DisplaySaveIcon(true);
DisplaySaveDataInfo2(true);
DisplayMessage(di->T("SavingFailed", "Unable to save data."));
DisplayButtons(DS_BUTTON_CANCEL);
DisplayBanner(DB_SAVE);
if (IsButtonPressed(cancelButtonFlag)) {
// Go back to the list so they can try again.
if (param.GetPspParam()->mode != SCE_UTILITY_SAVEDATA_TYPE_SAVE) {
display = DS_SAVE_LIST_CHOICE;
} else {
param.GetPspParam()->common.result = SCE_UTILITY_DIALOG_RESULT_CANCEL;
StartFade(false);
}
}
EndDraw();
break;
case DS_SAVE_DONE:
if (ioThread) {
JoinIOThread();
param.SetPspParam(param.GetPspParam());
}
StartDraw();
DisplaySaveIcon(true);
DisplaySaveDataInfo2(true);
DisplayMessage(di->T("Save completed"));
DisplayButtons(DS_BUTTON_CANCEL);
DisplayBanner(DB_SAVE);
if (IsButtonPressed(cancelButtonFlag)) {
param.GetPspParam()->common.result = SCE_UTILITY_DIALOG_RESULT_SUCCESS;
// Set the save to use for autosave and autoload
param.SetSelectedSave(param.GetFileInfo(currentSelectedSave).idx);
StartFade(false);
}
EndDraw();
break;
case DS_LOAD_LIST_CHOICE:
StartDraw();
DisplaySaveList();
DisplaySaveDataInfo1();
DisplayButtons(DS_BUTTON_OK | DS_BUTTON_CANCEL);
DisplayBanner(DB_LOAD);
if (IsButtonPressed(cancelButtonFlag)) {
param.GetPspParam()->common.result = SCE_UTILITY_DIALOG_RESULT_CANCEL;
StartFade(false);
} else if (IsButtonPressed(okButtonFlag)) {
display = DS_LOAD_LOADING;
StartIOThread();
}
EndDraw();
break;
case DS_LOAD_CONFIRM:
StartDraw();
DisplaySaveIcon(true);
DisplaySaveDataInfo2();
DisplayMessage(di->T("ConfirmLoad", "Load this data?"), true);
DisplayButtons(DS_BUTTON_OK | DS_BUTTON_CANCEL);
DisplayBanner(DB_LOAD);
if (IsButtonPressed(cancelButtonFlag) || (IsButtonPressed(okButtonFlag) && yesnoChoice == 0)) {
param.GetPspParam()->common.result = SCE_UTILITY_DIALOG_RESULT_CANCEL;
StartFade(false);
} else if (IsButtonPressed(okButtonFlag)) {
display = DS_LOAD_LOADING;
StartIOThread();
}
EndDraw();
break;
case DS_LOAD_LOADING:
if (ioThreadStatus != SAVEIO_PENDING) {
JoinIOThread();
}
StartDraw();
DisplaySaveIcon(true);
DisplaySaveDataInfo2();
DisplayMessage(di->T("Loading","Loading\nPlease Wait..."));
DisplayBanner(DB_LOAD);
EndDraw();
break;
case DS_LOAD_FAILED:
JoinIOThread();
StartDraw();
DisplaySaveIcon(true);
DisplaySaveDataInfo2();
DisplayMessage(di->T("LoadingFailed", "Unable to load data."));
DisplayButtons(DS_BUTTON_CANCEL);
DisplayBanner(DB_LOAD);
if (IsButtonPressed(cancelButtonFlag)) {
// Go back to the list so they can try again.
if (param.GetPspParam()->mode != SCE_UTILITY_SAVEDATA_TYPE_LOAD) {
display = DS_LOAD_LIST_CHOICE;
} else {
param.GetPspParam()->common.result = SCE_UTILITY_DIALOG_RESULT_CANCEL;
StartFade(false);
}
}
EndDraw();
break;
case DS_LOAD_DONE:
JoinIOThread();
StartDraw();
DisplaySaveIcon(true);
DisplaySaveDataInfo2();
DisplayMessage(di->T("Load completed"));
DisplayButtons(DS_BUTTON_CANCEL);
DisplayBanner(DB_LOAD);
// Allow OK to be pressed as well to confirm the save.
// The PSP only allows cancel, but that's generally not great UX.
// Allowing this here makes it quicker for most users to get into the actual game.
if (IsButtonPressed(cancelButtonFlag) || IsButtonPressed(okButtonFlag)) {
param.GetPspParam()->common.result = SCE_UTILITY_DIALOG_RESULT_SUCCESS;
// Set the save to use for autosave and autoload
param.SetSelectedSave(param.GetFileInfo(currentSelectedSave).idx);
StartFade(false);
}
EndDraw();
break;
case DS_LOAD_NODATA:
StartDraw();
DisplayMessage(di->T("There is no data"));
DisplayButtons(DS_BUTTON_CANCEL);
DisplayBanner(DB_LOAD);
if (IsButtonPressed(cancelButtonFlag)) {
param.GetPspParam()->common.result = SCE_UTILITY_SAVEDATA_ERROR_LOAD_NO_DATA;
StartFade(false);
}
EndDraw();
break;
case DS_DELETE_LIST_CHOICE:
StartDraw();
DisplaySaveList();
DisplaySaveDataInfo1();
DisplayButtons(DS_BUTTON_OK | DS_BUTTON_CANCEL);
DisplayBanner(DB_DELETE);
if (IsButtonPressed(cancelButtonFlag)) {
param.GetPspParam()->common.result = SCE_UTILITY_DIALOG_RESULT_CANCEL;
StartFade(false);
} else if (IsButtonPressed(okButtonFlag)) {
yesnoChoice = 0;
display = DS_DELETE_CONFIRM;
}
EndDraw();
break;
case DS_DELETE_CONFIRM:
StartDraw();
DisplaySaveIcon(true);
DisplaySaveDataInfo2();
DisplayMessage(di->T("DeleteConfirm",
"This save data will be deleted.\nAre you sure you want to continue?"),
true);
DisplayButtons(DS_BUTTON_OK | DS_BUTTON_CANCEL);
DisplayBanner(DB_DELETE);
if (IsButtonPressed(cancelButtonFlag))
display = DS_DELETE_LIST_CHOICE;
else if (IsButtonPressed(okButtonFlag)) {
if (yesnoChoice == 0)
display = DS_DELETE_LIST_CHOICE;
else {
display = DS_DELETE_DELETING;
StartIOThread();
}
}
EndDraw();
break;
case DS_DELETE_DELETING:
if (ioThreadStatus != SAVEIO_PENDING) {
JoinIOThread();
}
StartDraw();
DisplayMessage(di->T("Deleting","Deleting\nPlease Wait..."));
DisplayBanner(DB_DELETE);
EndDraw();
break;
case DS_DELETE_FAILED:
JoinIOThread();
StartDraw();
DisplayMessage(di->T("DeleteFailed", "Unable to delete data."));
DisplayButtons(DS_BUTTON_CANCEL);
DisplayBanner(DB_DELETE);
if (IsButtonPressed(cancelButtonFlag)) {
display = DS_DELETE_LIST_CHOICE;
}
EndDraw();
break;
case DS_DELETE_DONE:
if (ioThread) {
JoinIOThread();
param.SetPspParam(param.GetPspParam());
}
StartDraw();
DisplayMessage(di->T("Delete completed"));
DisplayButtons(DS_BUTTON_CANCEL);
DisplayBanner(DB_DELETE);
if (IsButtonPressed(cancelButtonFlag)) {
if (param.GetFilenameCount() == 0)
display = DS_DELETE_NODATA;
else
display = DS_DELETE_LIST_CHOICE;
}
EndDraw();
break;
case DS_DELETE_NODATA:
StartDraw();
DisplayMessage(di->T("There is no data"));
DisplayButtons(DS_BUTTON_CANCEL);
DisplayBanner(DB_DELETE);
if (IsButtonPressed(cancelButtonFlag)) {
param.GetPspParam()->common.result = SCE_UTILITY_SAVEDATA_ERROR_DELETE_NO_DATA;
StartFade(false);
}
EndDraw();
break;
case DS_NONE: // For action which display nothing
switch (ioThreadStatus) {
case SAVEIO_NONE:
StartIOThread();
break;
case SAVEIO_PENDING:
case SAVEIO_DONE:
// To make sure there aren't any timing variations, we sync the next frame.
JoinIOThread();
ChangeStatus(SCE_UTILITY_STATUS_FINISHED, 0);
break;
}
break;
default:
ChangeStatus(SCE_UTILITY_STATUS_FINISHED, 0);
break;
}
if (status == SCE_UTILITY_STATUS_FINISHED || pendingStatus == SCE_UTILITY_STATUS_FINISHED)
Memory::Memcpy(requestAddr, &request, request.common.size);
return 0;
}
std::string CachingFileLoader::Path() const {
lock_guard guard(backendMutex_);
return backend_->Path();
}
void PSPSaveDialog::DisplaySaveDataInfo1()
{
std::lock_guard<std::mutex> guard(paramLock);
if (param.GetFileInfo(currentSelectedSave).size == 0) {
I18NCategory *di = GetI18NCategory("Dialog");
PPGeDrawText(di->T("NEW DATA"), 180, 136, PPGE_ALIGN_VCENTER, 0.6f, CalcFadedColor(0xFFFFFFFF));
} else {
char title[512];
char time[512];
char saveTitle[1024];
char saveDetail[1024];
char am_pm[] = "AM";
char hour_time[10] ;
int hour = param.GetFileInfo(currentSelectedSave).modif_time.tm_hour;
int min = param.GetFileInfo(currentSelectedSave).modif_time.tm_min;
switch (g_Config.iTimeFormat) {
case 1:
if (hour > 12) {
strcpy(am_pm, "PM");
hour -= 12;
}
snprintf(hour_time,10,"%02d:%02d %s", hour, min, am_pm);
break;
case 2:
snprintf(hour_time,10,"%02d:%02d", hour, min);
break;
default:
if (hour > 12) {
strcpy(am_pm, "PM");
hour -= 12;
}
snprintf(hour_time,10,"%02d:%02d %s", hour, min, am_pm);
}
snprintf(title, sizeof(title), "%s", param.GetFileInfo(currentSelectedSave).title);
int day = param.GetFileInfo(currentSelectedSave).modif_time.tm_mday;
int month = param.GetFileInfo(currentSelectedSave).modif_time.tm_mon + 1;
int year = param.GetFileInfo(currentSelectedSave).modif_time.tm_year + 1900;
s64 sizeK = param.GetFileInfo(currentSelectedSave).size / 1024;
switch (g_Config.iDateFormat) {
case 1:
snprintf(time, sizeof(time), "%d/%02d/%02d %s %lld KB", year, month, day, hour_time, sizeK);
break;
case 2:
snprintf(time, sizeof(time), "%02d/%02d/%d %s %lld KB", month, day, year, hour_time, sizeK);
break;
case 3:
snprintf(time, sizeof(time), "%02d/%02d/%d %s %lld KB", day, month, year, hour_time, sizeK);
break;
default:
snprintf(time, sizeof(time), "%d/%02d/%02d %s %lld KB", year, month, day, hour_time, sizeK);
}
snprintf(saveTitle, sizeof(saveTitle), "%s", param.GetFileInfo(currentSelectedSave).saveTitle);
snprintf(saveDetail, sizeof(saveDetail), "%s", param.GetFileInfo(currentSelectedSave).saveDetail);
PPGeDrawRect(180, 136, 480, 137, CalcFadedColor(0xFFFFFFFF));
std::string titleTxt = title;
std::string timeTxt = time;
std::string saveTitleTxt = saveTitle;
std::string saveDetailTxt = saveDetail;
PPGeDrawText(titleTxt.c_str(), 181, 138, PPGE_ALIGN_BOTTOM, 0.6f, CalcFadedColor(0x80000000));
PPGeDrawText(titleTxt.c_str(), 180, 136, PPGE_ALIGN_BOTTOM, 0.6f, CalcFadedColor(0xFFC0C0C0));
PPGeDrawText(timeTxt.c_str(), 181, 139, PPGE_ALIGN_LEFT, 0.5f, CalcFadedColor(0x80000000));
PPGeDrawText(timeTxt.c_str(), 180, 137, PPGE_ALIGN_LEFT, 0.5f, CalcFadedColor(0xFFFFFFFF));
PPGeDrawText(saveTitleTxt.c_str(), 176, 162, PPGE_ALIGN_LEFT, 0.55f, CalcFadedColor(0x80000000));
PPGeDrawText(saveTitleTxt.c_str(), 175, 159, PPGE_ALIGN_LEFT, 0.55f, CalcFadedColor(0xFFFFFFFF));
PPGeDrawText(saveDetailTxt.c_str(), 176, 183, PPGE_ALIGN_LEFT, 0.5f, CalcFadedColor(0x80000000));
PPGeDrawText(saveDetailTxt.c_str(), 175, 181, PPGE_ALIGN_LEFT, 0.5f, CalcFadedColor(0xFFFFFFFF));
}
}
bool CJob::wasCancelled() const {
CMutexLocker guard(CThreadPool::Get().m_mutex);
return m_eState == CANCELLED;
}
void CThreadPool::cancelJobs(const std::set<CJob*>& jobs) {
// Thanks to the mutex, jobs cannot change state anymore. There are
// three different states which can occur:
//
// READY: The job is still in our list of pending jobs and no threads
// got it yet. Just clean up.
//
// DONE: The job finished running and was already written to the pipe
// that is used for waking up finished jobs. We can just read from the
// pipe until we see this job.
//
// RUNNING: This is the complicated case. The job is currently being
// executed. We change its state to CANCELLED so that wasCancelled()
// returns true. Afterwards we wait on a CV for the job to have finished
// running. This CV is signaled by jobDone() which checks the job's
// status and sees that the job was cancelled. It signals to us that
// cancellation is done by changing the job's status to DONE.
CMutexLocker guard(m_mutex);
std::set<CJob*> wait, finished, deleteLater;
std::set<CJob*>::const_iterator it;
// Start cancelling all jobs
for (it = jobs.begin(); it != jobs.end(); ++it) {
switch ((*it)->m_eState) {
case CJob::READY: {
(*it)->m_eState = CJob::CANCELLED;
// Job wasn't started yet, must be in the queue
std::list<CJob*>::iterator it2 =
std::find(m_jobs.begin(), m_jobs.end(), *it);
assert(it2 != m_jobs.end());
m_jobs.erase(it2);
deleteLater.insert(*it);
continue;
}
case CJob::RUNNING:
(*it)->m_eState = CJob::CANCELLED;
wait.insert(*it);
continue;
case CJob::DONE:
(*it)->m_eState = CJob::CANCELLED;
finished.insert(*it);
continue;
case CJob::CANCELLED:
default:
assert(0);
}
}
// Now wait for cancellation to be done
// Collect jobs that really were cancelled. Finished cancellation is
// signaled by changing their state to DONE.
while (!wait.empty()) {
it = wait.begin();
while (it != wait.end()) {
if ((*it)->m_eState != CJob::CANCELLED) {
assert((*it)->m_eState == CJob::DONE);
// Re-set state for the destructor
(*it)->m_eState = CJob::CANCELLED;
deleteLater.insert(*it);
wait.erase(it++);
} else
it++;
}
if (wait.empty()) break;
// Then wait for more to be done
m_cancellationCond.wait(m_mutex);
}
// We must call destructors with m_mutex unlocked so that they can call
// wasCancelled()
guard.unlock();
// Handle finished jobs. They must already be in the pipe.
while (!finished.empty()) {
CJob* job = getJobFromPipe();
if (finished.erase(job) > 0) {
assert(job->m_eState == CJob::CANCELLED);
delete job;
} else
finishJob(job);
}
// Delete things that still need to be deleted
while (!deleteLater.empty()) {
delete *deleteLater.begin();
deleteLater.erase(deleteLater.begin());
}
}
string g_GetPasswordFromConsole(const string& prompt)
{
string password;
CMutex lock;
CMutexGuard guard(lock);
#if defined(NCBI_OS_UNIX)
// UNIX implementation
#if defined(HAVE_READPASSPHRASE)
char password_buffer[1024];
char* raw_password = readpassphrase(prompt.c_str(), password_buffer,
sizeof(password_buffer),
RPP_ECHO_OFF | RPP_REQUIRE_TTY);
#elif defined(HAVE_GETPASSPHRASE)
char* raw_password = getpassphrase(prompt.c_str());
#elif defined(HAVE_GETPASS)
char* raw_password = getpass(prompt.c_str());
#else
# error "Unsupported Unix platform; the getpass, getpassphrase, and readpassphrase functions are all absent"
#endif
if (!raw_password)
NCBI_THROW
(CGetPasswordFromConsoleException, eGetPassError,
"g_GetPasswordFromConsole(): error getting password");
password = string(raw_password);
#elif defined(NCBI_OS_MSWIN)
// Windows implementation
for (size_t index = 0; index < prompt.size(); ++index) {
_putch(prompt[index]);
}
for (;;) {
char ch;
ch = _getch();
if (ch == '\r' || ch == '\n')
break;
if (ch == '\003')
NCBI_THROW(CGetPasswordFromConsoleException, eKeyboardInterrupt,
"g_GetPasswordFromConsole(): keyboard interrupt");
if (ch == '\b') {
if ( !password.empty() ) {
password.resize(password.size() - 1);
}
}
else
password.append(1, ch);
}
_putch('\r');
_putch('\n');
#endif
return password;
}
/**
*
* Test program and example for guarded logs.
*
*/
int main(int argc, char *argv[])
{
maci::SimpleClient client;
if (client.init(argc,argv) == 0)
{
return -1;
}
else
{
// Log into the manager before doing anything
client.login();
}
/*****************************************************************/
/*
* This example guards a log
* produced using any subclass of Logging::BaseLog
* These are the normal logs
*
* All examples follow this same pattern
*/
/*
* 1. The first step is to instantiate the guard template.
* In this case the guarding is not done for multiple
* executions of this function, since it is the main().
*
* In that case we would have to declare the guard as static.
* The same applies to all following examples
*
* This approach also allows to use the same guard for multiple logs
* (as long as they are of the same logger type)
*/
Logging::RepeatGuardLogger<Logging::BaseLog> guardbl(10000000,10);
/*
* 2. We get the standard logger for this "object"
* and we make a simple normal log, just to see that it works.
*/
Logging::Logger::LoggerSmartPtr logger = getLogger();
logger->log(Logging::Logger::LM_INFO, "Simple test.",
__FILE__,__LINE__,
"main");
/*
* 3. Finally we make a loop with the guarded log
*/
for(int i=0;i<50;i++)
{
guardbl.log(logger, Logging::Logger::LM_INFO,
"Log A without incrementing",
__FILE__,__LINE__,
"main");
guardbl.log(logger, Logging::Logger::LM_INFO,
"Log B without incrementing",
__FILE__,__LINE__,
"main");
guardbl.logAndIncrement(logger, Logging::Logger::LM_INFO,
"LogAndIncrement",
__FILE__,__LINE__,
"main");
}
/*****************************************************************/
/*
* This example guards a type-safe log
* produced using any subclass of Logging::TypeSafeLog
*/
Logging::RepeatGuardLogger<Logging::TypeSafeLog> guard(10000000,10);
repeatGuardLogTypeExample::simpleLog my_simpleLog(__FILE__,__LINE__,"main");
my_simpleLog.log();
guard.log(my_simpleLog);
for(int i=0;i<50;i++)
{
guard.logAndIncrement(my_simpleLog);
}
/*****************************************************************/
/*
* This example guards the logging of an exception
* produced using any subclass of ACSErr::ACSbaseExImpl
*/
Logging::RepeatGuardLogger<ACSErr::ACSbaseExImpl> guardex(10000000,10);
ACSErrTypeCommon::GenericErrorExImpl displayMessageEx(
__FILE__, __LINE__, "main");
displayMessageEx.log();
guardex.log(displayMessageEx);
for(int i=0;i<50;i++)
{
guardex.logAndIncrement(displayMessageEx);
}
/*****************************************************************/
client.logout();
return 0;
}
static NTSTATUS DOKAN_CALLBACK
FuseGetFileSecurity(LPCWSTR FileName, PSECURITY_INFORMATION SecurityInformation,
PSECURITY_DESCRIPTOR SecurityDescriptor, ULONG BufferLength,
PULONG LengthNeeded, PDOKAN_FILE_INFO DokanFileInfo) {
impl_fuse_context *impl = the_impl;
if (impl->debug())
FPRINTF(stderr, "GetFileSecurity: " PRIxDWORD "\n", *SecurityInformation);
BY_HANDLE_FILE_INFORMATION byHandleFileInfo;
ZeroMemory(&byHandleFileInfo, sizeof(BY_HANDLE_FILE_INFORMATION));
int ret;
{
impl_chain_guard guard(impl, DokanFileInfo->ProcessId);
ret =
impl->get_file_information(FileName, &byHandleFileInfo, DokanFileInfo);
}
if (0 != ret) {
return errno_to_ntstatus_error(ret);
}
if (byHandleFileInfo.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
// We handle directories for the Explorer's
// context menu. (New Folder, ...)
// Authenticated users rights
PSECURITY_DESCRIPTOR SecurityDescriptorTmp = nullptr;
ULONG Size = 0;
if (!ConvertStringSecurityDescriptorToSecurityDescriptor(
"D:PAI(A;OICI;FA;;;AU)", SDDL_REVISION_1, &SecurityDescriptorTmp,
&Size)) {
return STATUS_NOT_IMPLEMENTED;
}
LPTSTR pStringBuffer = nullptr;
if (!ConvertSecurityDescriptorToStringSecurityDescriptor(
SecurityDescriptorTmp, SDDL_REVISION_1, *SecurityInformation,
&pStringBuffer, nullptr)) {
return STATUS_NOT_IMPLEMENTED;
}
LocalFree(SecurityDescriptorTmp);
SecurityDescriptorTmp = nullptr;
Size = 0;
if (!ConvertStringSecurityDescriptorToSecurityDescriptor(
pStringBuffer, SDDL_REVISION_1, &SecurityDescriptorTmp, &Size)) {
return STATUS_NOT_IMPLEMENTED;
}
if (Size > BufferLength) {
*LengthNeeded = Size;
return STATUS_BUFFER_OVERFLOW;
}
memcpy(SecurityDescriptor, SecurityDescriptorTmp, Size);
*LengthNeeded = Size;
if (pStringBuffer != nullptr)
LocalFree(pStringBuffer);
if (SecurityDescriptorTmp != nullptr)
LocalFree(SecurityDescriptorTmp);
return STATUS_SUCCESS;
}
return STATUS_NOT_IMPLEMENTED;
}
