| Age | Commit message (Collapse) | Author |
|---|
|
cpp file
The destructor doesn't need to be a pure-virtual function.
|
|
"Better Hid" Rework Part 1
|
|
Implement flushing in the rasterizer cache
|
|
svc: Clarify enum values for AddressSpaceBaseAddr and AddressSpaceSize in svcGetInfo()
|
|
savedata_factory: Add DeviceSaveData and fix TemporaryStorage
|
|
Reason for the change is to allow both docked and undocked mode to work
|
|
- This will be used as a catch-all for slow-but-accurate GPU emulation paths.
|
|
content_archive/patch_manager: Lower log levels to eliminate some unnecessary logs
|
|
* Implement VI ConvertScalingMode
* Fixed push enum
* Scale mode now uses Nintendo scale mode as an enum as well
|
|
core: Convert shared_ptr instances into unique_ptr instances where applicable for System and Cpu
|
|
Required for TemporaryStorage saves (in addition to SaveDataType)
|
|
Uses the same path as SaveData except with UID 0. Adds a warning if UID is not 0.
|
|
shared_ptrs where applicable
The data retrieved in these cases are ultimately chiefly owned by either
the RegisteredCache instance itself, or the filesystem factories. Both
these should live throughout the use of their contained data. If they
don't, it should be considered an interface/design issue, and using
shared_ptr instances here would mask that, as the data would always be
prolonged after the main owner's lifetime ended.
This makes the lifetime of the data explicit and makes it harder to
accidentally create cyclic references. It also makes the interface
slightly more flexible than the previous API, as a shared_ptr can be
created from a unique_ptr, but not the other way around, so this allows
for that use-case if it ever becomes necessary in some form.
|
|
web_service: Make linkage of web_service-related externals and the library private
|
|
These are just the size of the data being passed in, so we can specify
that via the size() member function.
|
|
aoc: Fix various bugs in current AOC implementation
|
|
nro/nso: Minor error handling changes
|
|
If a malformed NSO is attempted to be loaded, we shouldn't continue
onwards. We should be reporting an error and bailing out.
|
|
|
|
There's no need for shared ownership here, as the only owning class
instance of those Cpu instances is the System class itself. We can also
make the thread_to_cpu map use regular pointers instead of shared_ptrs,
given that the Cpu instances will always outlive the cases where they're
used with that map.
|
|
Like the barrier, this is owned entirely by the System and will always
outlive the encompassing state, so shared ownership semantics aren't
necessary here.
|
|
This will always outlive the Cpu instances, since it's destroyed after
we destroy the Cpu instances on shutdown, so there's no need for shared
ownership semantics here.
|
|
|
|
|
|
This function doesn't need to care about ownership semantics, so we can
just pass it a reference to the file itself, rather than a
std::shared_ptr alias.
|
|
svcGetInfo()
So, one thing that's puzzled me is why the kernel seemed to *not* use
the direct code address ranges in some cases for some service functions.
For example, in svcMapMemory, the full address space width is compared
against for validity, but for svcMapSharedMemory, it compares against
0xFFE00000, 0xFF8000000, and 0x7FF8000000 as upper bounds, and uses
either 0x200000 or 0x8000000 as the lower-bounds as the beginning of the
compared range. Coincidentally, these exact same values are also used in
svcGetInfo, and also when initializing the user address space, so this
is actually retrieving the ASLR extents, not the extents of the address
space in general.
|
|
Falls back to title ID + 0x1000, which is what HOS does.
|
|
key_manager/partition_data_manager: Minor changes
|
|
filesystem: Make CreateFactories() and InstallInterface() take a VfsFilesystem by reference
|
|
svc: Implement svcGetProcessInfo
|
|
This should help diagnose crashes easier and prevent many users thinking that a game is still running when in fact it's just an audio thread still running(this is typically not killed when svcBreak is hit since the game expects us to do this)
|
|
|
|
A fairly basic service function, which only appears to currently support
retrieving the process state. This also alters the ProcessStatus enum to
contain all of the values that a kernel process seems to be able of
reporting with regards to state.
|
|
VfsFilesystem instance by reference
Neither of these functions alter the ownership of the provided pointer,
so we can simply make the parameters a reference rather than a direct
shared pointer alias. This way we also disallow passing incorrect memory values like
nullptr.
|
|
DecryptPackage2()
We can just reserve the memory then perform successive insertions
instead of needing to use memcpy. This also avoids the need to zero out
the output vector's memory before performing the insertions.
We can also std::move the output std::vector into the destination so
that we don't need to make a completely new copy of the vector, getting
rid of an unnecessary allocation.
Additionally, we can use iterators to determine the beginning and end
ranges of the std::vector instances that comprise the output vector, as
the end of one range just becomes the beginning for the next successive
range, and since std::vector's iterator constructor copies data within
the range [begin, end), this is more straightforward and gets rid of the
need to have an offset variable that keeps getting incremented to
determine where to do the next std::memcpy.
|
|
Aside from emplacing elements into the map, the map itself is never
actually queried for contained data.
|
|
These are only ever read from, so we don't need to make a copy of all
the keys here.
|
|
Given it's only used in one spot and has a fairly generic name, we can
just specify it directly in the function call. This also the benefit of
automatically moving it.
|
|
Commented out code shouldn't be left in without a reason indicating why
in a comment.
|
|
|
|
Instead, we can make it part of the type and make named variables for
them, so they only require one definition (and if they ever change for
whatever reason, they only need to be changed in one spot).
|
|
Given the VirtualFile instance isn't stored into the class as a data
member, or written to, this can just be turned into a const reference,
as the constructor doesn't need to make a copy of it.
|
|
Orders the members in the exact order they would be initialized. This
also prevents compiler warnings about this sort of thing.
|
|
Gets unused includes out of the headers and moves them into the cpp file
if they're used there instead.
|
|
back_inserter
If the data is unconditionally being appended to the back of a
std::vector, we can just directly insert it there without the need to
insert all of the elements one-by-one with a std::back_inserter.
|
|
If a conditional (or it's body) travels more than one line, it should be
braced.
|
|
Given the filesystem should always be assumed to be volatile, we should
check and bail out if a seek operation isn't successful. This'll prevent
potentially writing/returning garbage data from the function in rare
cases.
This also allows removing a check to see if an offset is within the
bounds of a file before perfoming a seek operation. If a seek is
attempted beyond the end of a file, it will fail, so this essentially
combines two checks into one in one place.
|
|
Given the file is opened a few lines above and no operations are done,
other than check if the file is in a valid state, the read/write pointer
will always be at the beginning of the file.
|
|
Normal Program-type patches will still be logged to aid in debugging, but for others (mainly Control), it was moved to Debug.
|
|
Avoids printing live keys in the general log.
|
