| Age | Commit message (Collapse) | Author |
|---|
|
core/hle/kernel: Make Mutex a per-process class.
|
|
kernel/vm_manager: Amend flag value for code data
|
|
file_sys: Implement parser and interpreter for game memory cheats
|
|
respectively
Makes it more evident that one is for actual code and one is for actual
data. Mutable and static are less than ideal terms here, because
read-only data is technically not mutable, but we were mapping it with
that label.
|
|
This should actually be using the data flags, rather than the code
flags.
|
|
core/kernel: Migrate CodeSet to its own source files
|
|
The segment itself isn't actually modified.
|
|
Given this is utilized by the loaders, this allows avoiding inclusion of
the kernel process definitions where avoidable.
This also keeps the loading format for all executable data separate from
the kernel objects.
|
|
|
|
kernel/thread: Amend conditional test and assignment within UpdatePriority()
|
|
core: Move PageTable struct into Common.
|
|
|
|
This was intended to be removed in
51d7f6bffcc0498a47abc7de27bf0906fc523dae, but I guess I forgot to
actually save the file like a dingus.
|
|
kernel/thread: Remove WaitCurrentThread_Sleep() and ExitCurrentThread()
|
|
Puts the operation on global state in the same places as the rest of the
svc calls.
|
|
Rather than make a global accessor for this sort of thing. We can make
it a part of the thread interface itself. This allows getting rid of a
hidden global accessor in the kernel code.
|
|
Aims to disambiguate why each priority instance exists a little bit.
While we're at it, also add an explanatory comment to UpdatePriority().
|
|
|
|
This condition was checking against the nominal thread priority, whereas
the kernel itself checks against the current priority instead. We were
also assigning the nominal priority, when we should be assigning
current_priority, which takes priority inheritance into account.
This can lead to the incorrect priority being assigned to a thread.
Given we recursively update the relevant threads, we don't need to go
through the whole mutex waiter list. This matches what the kernel does
as well (only accessing the first entry within the waiting list).
|
|
The kernel keeps the internal waiting list ordered by priority. This is
trivial to do with std::find_if followed by an insertion.
|
|
Removes the use of global system accessors, and instead uses the
explicit interface provided.
|
|
Makes it an instantiable class like it is in the actual kernel. This
will also allow removing reliance on global accessors in a following
change, now that we can encapsulate a reference to the system instance
in the class.
|
|
kernel/process: Remove use of global system accessors
|
|
kernel/server_port: Make data members private
|
|
Now that we pass in a reference to the system instance, we can utilize
it to eliminate the global accessors in Process-related code.
|
|
kernel: Make the address arbiter instance per-process
|
|
With this, all kernel objects finally have all of their data members
behind an interface, making it nicer to reason about interactions with
other code (as external code no longer has the freedom to totally alter
internals and potentially messing up invariants).
|
|
kernel/scheduler: Pass in system instance in constructor
|
|
kernel/hle_ipc: Convert std::shared_ptr IPC header instances to std::optional
|
|
There's no real need to use a shared lifetime here, since we don't
actually expose them to anything else. This is also kind of an
unnecessary use of the heap given the objects themselves are so small;
small enough, in fact that changing over to optionals actually reduces
the overall size of the HLERequestContext struct (818 bytes to 808
bytes).
|
|
Now that we have the address arbiter extracted to its own class, we can
fix an innaccuracy with the kernel. Said inaccuracy being that there
isn't only one address arbiter. Each process instance contains its own
AddressArbiter instance in the actual kernel.
This fixes that and gets rid of another long-standing issue that could
arise when attempting to create more than one process.
|
|
Similar to how WaitForAddress was isolated to its own function, we can
also move the necessary conditional checking into the address arbiter
class itself, allowing us to hide the implementation details of it from
public use.
|
|
Rather than let the service call itself work out which function is the
proper one to call, we can make that a behavior of the arbiter itself,
so we don't need to directly expose those implementation details.
|
|
kernel/shared_memory: Get rid of the use of global accessor functions within Create()
|
|
kernel/client_session, kernel/server_session: Make data members private
|
|
core/hle/ipc: Remove unnecessary includes
|
|
kernel/address_arbiter: Convert the address arbiter into a class
|
|
svc: Move memory range checking functions to the VMManager class
|
|
Makes it much nicer to locally reason about server session behavior, as
part of its functionality isn't placed around other classes.
|
|
These can be made private, as they aren't accessed in contexts that
require them to be public.
|
|
Allows getting rid of reliance on the global accessor functions and
instead operating on the provided system instance.
|
|
- Invert conditions into guard clases where applicable.
- Mark std::vector parameter of WakeThreads as const
|
|
Places all of the functions for address arbiter operation into a class.
This will be necessary for future deglobalizing efforts related to both
the memory and system itself.
|
|
|
|
This is a TODO carried over from Citra that doesn't apply here.
|
|
Removes a few inclusion dependencies from the headers or replaces
existing ones with ones that don't indirectly include the required
headers.
This allows removing an inclusion of core/memory.h, meaning that if the
memory header is ever changed in the future, it won't result in
rebuilding the entirety of the HLE services (as the IPC headers are used
quite ubiquitously throughout the HLE service implementations).
|
|
Used as root for one region of cheats, set by loader
|
|
Significantly tidies up two guard conditionals.
|
|
Makes the interface uniform when it comes to checking various memory
regions.
|
|
Avoids directly relying on the global system instance and instead makes
an arbitrary system instance an explicit dependency on construction.
This also allows removing dependencies on some global accessor functions
as well.
|
