| Age | Commit message (Collapse) | Author |
|---|
|
Initially required due to the split codepath with how the initial main
process instance was initialized. We used to initialize the process
like:
Init() {
main_process = Process::Create(...);
kernel.MakeCurrentProcess(main_process.get());
}
Load() {
const auto load_result = loader.Load(*kernel.GetCurrentProcess());
if (load_result != Loader::ResultStatus::Success) {
// Handle error here.
}
...
}
which presented a problem.
Setting a created process as the main process would set the page table
for that process as the main page table. This is fine... until we get to
the part that the page table can have its size changed in the Load()
function via NPDM metadata, which can dictate either a 32-bit, 36-bit,
or 39-bit usable address space.
Now that we have full control over the process' creation in load, we can
simply set the initial process as the main process after all the loading
is done, reflecting the potential page table changes without any
special-casing behavior.
We can also remove the cache flushing within LoadModule(), as execution
wouldn't have even begun yet during all usages of this function, now
that we have the initialization order cleaned up.
|
|
Now that we have dependencies on the initialization order, we can move
the creation of the main process to a more sensible area: where we
actually load in the executable data.
This allows localizing the creation and loading of the process in one
location, making the initialization of the process much nicer to trace.
|
|
Like with CPU emulation, we generally don't want to fire off the threads
immediately after the relevant classes are initialized, we want to do
this after all necessary data is done loading first.
This splits the thread creation into its own interface member function
to allow controlling when these threads in particular get created.
|
|
Our initialization process is a little wonky than one would expect when
it comes to code flow. We initialize the CPU last, as opposed to
hardware, where the CPU obviously needs to be first, otherwise nothing
else would work, and we have code that adds checks to get around this.
For example, in the page table setting code, we check to see if the
system is turned on before we even notify the CPU instances of a page
table switch. This results in dead code (at the moment), because the
only time a page table switch will occur is when the system is *not*
running, preventing the emulated CPU instances from being notified of a
page table switch in a convenient manner (technically the code path
could be taken, but we don't emulate the process creation svc handlers
yet).
This moves the threads creation into its own member function of the core
manager and restores a little order (and predictability) to our
initialization process.
Previously, in the multi-threaded cases, we'd kick off several threads
before even the main kernel process was created and ready to execute (gross!).
Now the initialization process is like so:
Initialization:
1. Timers
2. CPU
3. Kernel
4. Filesystem stuff (kind of gross, but can be amended trivially)
5. Applet stuff (ditto in terms of being kind of gross)
6. Main process (will be moved into the loading step in a following
change)
7. Telemetry (this should be initialized last in the future).
8. Services (4 and 5 should ideally be alongside this).
9. GDB (gross. Uses namespace scope state. Needs to be refactored into a
class or booted altogether).
10. Renderer
11. GPU (will also have its threads created in a separate step in a
following change).
Which... isn't *ideal* per-se, however getting rid of the wonky
intertwining of CPU state initialization out of this mix gets rid of
most of the footguns when it comes to our initialization process.
|
|
kernel/svc: Deglobalize the supervisor call handlers
|
|
kernel: Make handle type declarations constexpr
|
|
Some objects declare their handle type as const, while others declare it
as constexpr. This makes the const ones constexpr for consistency, and
prevent unexpected compilation errors if these happen to be attempted to be
used within a constexpr context.
|
|
These are holdovers from Citra.
|
|
file_sys: Provide generic interface for accessing game data
|
|
We need to ensure dynarmic gets a valid pointer if the page table is
resized (the relevant pointers would be invalidated in this scenario).
In this scenario, the page table can be resized depending on what kind
of address space is specified within the NPDM metadata (if it's
present).
|
|
Adjusts the interface of the wrappers to take a system reference, which
allows accessing a system instance without using the global accessors.
This also allows getting rid of all global accessors within the
supervisor call handling code. While this does make the wrappers
themselves slightly more noisy, this will be further cleaned up in a
follow-up. This eliminates the global system accessors in the current
code while preserving the existing interface.
|
|
core/memory: Minor simplifications to page table management
|
|
kernel/{server_port, server_session}: Return pairs instead of tuples from pair creation functions
|
|
These are holdovers from Citra and can be removed.
|
|
Now that nothing actually touches the internal page table aside from the
memory subsystem itself, we can remove the accessor to it.
|
|
Given the page table will always be guaranteed to be that of whatever
the current process is, we no longer need to keep this around.
|
|
Centralizes the page table switching to one spot, rather than making
calling code deal with it everywhere.
|
|
Keeps the return type consistent with the function name. While we're at
it, we can also reduce the amount of boilerplate involved with handling
these by using structured bindings.
|
|
Returns the same type that the function name describes.
|
|
kernel/server_session: Provide a GetName() override
|
|
Port citra-emu/citra#4651: "gdbstub: Fix some bugs in IsMemoryBreak() and ServeBreak. Add workaround to let watchpoints break into GDB."
|
|
file_sys/fsmitm_romfsbuild: Utilize a string_view in romfs_calc_path_hash
|
|
core: Add missing override specifiers where applicable
|
|
file_sys/nca_metadata: Remove unnecessary comparison operators for TitleType
|
|
service/fsp_srv: Update SaveDataInfo and SaveDataDescriptor structs
|
|
file_sys/program_metadata: Remove obsolete TODOs
|
|
kernel/svc: Properly sanitize mutex address in WaitProcessWideKeyAtomic
|
|
hle/result: Remove unnecessary bitfield entry for ResultCode
|
|
This is a hold over from the 3DS error codes in Citra.
|
|
BitField has been trivially copyable since
e99a14862841841d74be8d0ea9426c2d23546b5e, so we can eliminate these
TODO comments and use ReadObject() directly instead of memcpying the
data.
|
|
enum class elements from the same enum can already be compared against
one another without the need for explicitly defined comparison
operators.
|
|
The given string instance doesn't need to be copied entirely, we can
just use a view instead.
|
|
Passing around a 64 byte data struct by value is kind of wasteful,
instead pass a reference to the struct.
|
|
The unknown member here is actually padding due to being passed as a
struct. We can do the same, and remove the need to pop a padding word.
|
|
I realized that I updated the documentation on SwitchBrew a while ago,
but never actually updated the structs within yuzu.
|
|
filesystem: Use a std::string_view in OpenFile()
|
|
file_sys/control_metadata: Amend naming of members
|
|
Rather than make a full copy of the path, we can just use a string view
and truncate the viewed portion of the string instead of creating a totally
new truncated string.
|
|
In several places, we have request parsers where there's nothing to
really parse, simply because the HLE function in question operates on
buffers. In these cases we can just remove these instances altogether.
In the other cases, we can retrieve the relevant members from the parser
and at least log them out, giving them some use.
|
|
Applies the override specifier where applicable. In the case of
destructors that are defaulted in their definition, they can
simply be removed.
This also removes the unnecessary inclusions being done in audin_u and
audrec_u, given their close proximity.
|
|
service/am: Correct behavior of CreateTransferMemoryStorage()
|
|
Better LZ4 compression utilization for the disk based shader cache and the yuzu build system
|
|
kernel/object: Remove unused handle type entry
|
|
Quite a bit of these were out of sync with Switchbrew (and in some cases
entirely wrong). While we're at it, also expand the section of named
members. A segment within the control metadata is used to specify
maximum values for the user, device, and cache storage max sizes and
journal sizes.
These appear to be generally used by the am service (e.g. in
CreateCacheStorage, etc).
|
|
We need to be checking whether or not the given address is within the
kernel address space or if the given address isn't word-aligned and bail
in these scenarios instead of trashing any kernel state.
|
|
For whatever reason, shared memory was being used here instead of
transfer memory, which (quite clearly) will not work based off the name
of the function.
This corrects this wonky usage of shared memory.
|
|
Also amend erroneous use of size_t. We should be using u64 here.
|
|
service/am: Implement EnterFatalSection/LeaveFatalSection
|
|
kernel/shared_memory: Sanitize supplied size when unmapping
|
|
kernel/thread: Minor interface cleanup
|
