Memory: Fix invalidation handling from the CPU/Services

This reverts commit d9dde7e6f3.

LICENSE.md

@@ -1,675 +0,0 @@
-# GNU GENERAL PUBLIC LICENSE
-
-Version 3, 29 June 2007
-
-Copyright (C) 2007 Free Software Foundation, Inc.
-<https://fsf.org/>
-
-Everyone is permitted to copy and distribute verbatim copies of this
-license document, but changing it is not allowed.
-
-## Preamble
-
-The GNU General Public License is a free, copyleft license for
-software and other kinds of works.
-
-The licenses for most software and other practical works are designed
-to take away your freedom to share and change the works. By contrast,
-the GNU General Public License is intended to guarantee your freedom
-to share and change all versions of a program--to make sure it remains
-free software for all its users. We, the Free Software Foundation, use
-the GNU General Public License for most of our software; it applies
-also to any other work released this way by its authors. You can apply
-it to your programs, too.
-
-When we speak of free software, we are referring to freedom, not
-price. Our General Public Licenses are designed to make sure that you
-have the freedom to distribute copies of free software (and charge for
-them if you wish), that you receive source code or can get it if you
-want it, that you can change the software or use pieces of it in new
-free programs, and that you know you can do these things.
-
-To protect your rights, we need to prevent others from denying you
-these rights or asking you to surrender the rights. Therefore, you
-have certain responsibilities if you distribute copies of the
-software, or if you modify it: responsibilities to respect the freedom
-of others.
-
-For example, if you distribute copies of such a program, whether
-gratis or for a fee, you must pass on to the recipients the same
-freedoms that you received. You must make sure that they, too, receive
-or can get the source code. And you must show them these terms so they
-know their rights.
-
-Developers that use the GNU GPL protect your rights with two steps:
-(1) assert copyright on the software, and (2) offer you this License
-giving you legal permission to copy, distribute and/or modify it.
-
-For the developers' and authors' protection, the GPL clearly explains
-that there is no warranty for this free software. For both users' and
-authors' sake, the GPL requires that modified versions be marked as
-changed, so that their problems will not be attributed erroneously to
-authors of previous versions.
-
-Some devices are designed to deny users access to install or run
-modified versions of the software inside them, although the
-manufacturer can do so. This is fundamentally incompatible with the
-aim of protecting users' freedom to change the software. The
-systematic pattern of such abuse occurs in the area of products for
-individuals to use, which is precisely where it is most unacceptable.
-Therefore, we have designed this version of the GPL to prohibit the
-practice for those products. If such problems arise substantially in
-other domains, we stand ready to extend this provision to those
-domains in future versions of the GPL, as needed to protect the
-freedom of users.
-
-Finally, every program is threatened constantly by software patents.
-States should not allow patents to restrict development and use of
-software on general-purpose computers, but in those that do, we wish
-to avoid the special danger that patents applied to a free program
-could make it effectively proprietary. To prevent this, the GPL
-assures that patents cannot be used to render the program non-free.
-
-The precise terms and conditions for copying, distribution and
-modification follow.
-
-## TERMS AND CONDITIONS
-
-### 0. Definitions.
-
-"This License" refers to version 3 of the GNU General Public License.
-
-"Copyright" also means copyright-like laws that apply to other kinds
-of works, such as semiconductor masks.
-
-"The Program" refers to any copyrightable work licensed under this
-License. Each licensee is addressed as "you". "Licensees" and
-"recipients" may be individuals or organizations.
-
-To "modify" a work means to copy from or adapt all or part of the work
-in a fashion requiring copyright permission, other than the making of
-an exact copy. The resulting work is called a "modified version" of
-the earlier work or a work "based on" the earlier work.
-
-A "covered work" means either the unmodified Program or a work based
-on the Program.
-
-To "propagate" a work means to do anything with it that, without
-permission, would make you directly or secondarily liable for
-infringement under applicable copyright law, except executing it on a
-computer or modifying a private copy. Propagation includes copying,
-distribution (with or without modification), making available to the
-public, and in some countries other activities as well.
-
-To "convey" a work means any kind of propagation that enables other
-parties to make or receive copies. Mere interaction with a user
-through a computer network, with no transfer of a copy, is not
-conveying.
-
-An interactive user interface displays "Appropriate Legal Notices" to
-the extent that it includes a convenient and prominently visible
-feature that (1) displays an appropriate copyright notice, and (2)
-tells the user that there is no warranty for the work (except to the
-extent that warranties are provided), that licensees may convey the
-work under this License, and how to view a copy of this License. If
-the interface presents a list of user commands or options, such as a
-menu, a prominent item in the list meets this criterion.
-
-### 1. Source Code.
-
-The "source code" for a work means the preferred form of the work for
-making modifications to it. "Object code" means any non-source form of
-a work.
-
-A "Standard Interface" means an interface that either is an official
-standard defined by a recognized standards body, or, in the case of
-interfaces specified for a particular programming language, one that
-is widely used among developers working in that language.
-
-The "System Libraries" of an executable work include anything, other
-than the work as a whole, that (a) is included in the normal form of
-packaging a Major Component, but which is not part of that Major
-Component, and (b) serves only to enable use of the work with that
-Major Component, or to implement a Standard Interface for which an
-implementation is available to the public in source code form. A
-"Major Component", in this context, means a major essential component
-(kernel, window system, and so on) of the specific operating system
-(if any) on which the executable work runs, or a compiler used to
-produce the work, or an object code interpreter used to run it.
-
-The "Corresponding Source" for a work in object code form means all
-the source code needed to generate, install, and (for an executable
-work) run the object code and to modify the work, including scripts to
-control those activities. However, it does not include the work's
-System Libraries, or general-purpose tools or generally available free
-programs which are used unmodified in performing those activities but
-which are not part of the work. For example, Corresponding Source
-includes interface definition files associated with source files for
-the work, and the source code for shared libraries and dynamically
-linked subprograms that the work is specifically designed to require,
-such as by intimate data communication or control flow between those
-subprograms and other parts of the work.
-
-The Corresponding Source need not include anything that users can
-regenerate automatically from other parts of the Corresponding Source.
-
-The Corresponding Source for a work in source code form is that same
-work.
-
-### 2. Basic Permissions.
-
-All rights granted under this License are granted for the term of
-copyright on the Program, and are irrevocable provided the stated
-conditions are met. This License explicitly affirms your unlimited
-permission to run the unmodified Program. The output from running a
-covered work is covered by this License only if the output, given its
-content, constitutes a covered work. This License acknowledges your
-rights of fair use or other equivalent, as provided by copyright law.
-
-You may make, run and propagate covered works that you do not convey,
-without conditions so long as your license otherwise remains in force.
-You may convey covered works to others for the sole purpose of having
-them make modifications exclusively for you, or provide you with
-facilities for running those works, provided that you comply with the
-terms of this License in conveying all material for which you do not
-control copyright. Those thus making or running the covered works for
-you must do so exclusively on your behalf, under your direction and
-control, on terms that prohibit them from making any copies of your
-copyrighted material outside their relationship with you.
-
-Conveying under any other circumstances is permitted solely under the
-conditions stated below. Sublicensing is not allowed; section 10 makes
-it unnecessary.
-
-### 3. Protecting Users' Legal Rights From Anti-Circumvention Law.
-
-No covered work shall be deemed part of an effective technological
-measure under any applicable law fulfilling obligations under article
-11 of the WIPO copyright treaty adopted on 20 December 1996, or
-similar laws prohibiting or restricting circumvention of such
-measures.
-
-When you convey a covered work, you waive any legal power to forbid
-circumvention of technological measures to the extent such
-circumvention is effected by exercising rights under this License with
-respect to the covered work, and you disclaim any intention to limit
-operation or modification of the work as a means of enforcing, against
-the work's users, your or third parties' legal rights to forbid
-circumvention of technological measures.
-
-### 4. Conveying Verbatim Copies.
-
-You may convey verbatim copies of the Program's source code as you
-receive it, in any medium, provided that you conspicuously and
-appropriately publish on each copy an appropriate copyright notice;
-keep intact all notices stating that this License and any
-non-permissive terms added in accord with section 7 apply to the code;
-keep intact all notices of the absence of any warranty; and give all
-recipients a copy of this License along with the Program.
-
-You may charge any price or no price for each copy that you convey,
-and you may offer support or warranty protection for a fee.
-
-### 5. Conveying Modified Source Versions.
-
-You may convey a work based on the Program, or the modifications to
-produce it from the Program, in the form of source code under the
-terms of section 4, provided that you also meet all of these
-conditions:
-
--   a) The work must carry prominent notices stating that you modified
-    it, and giving a relevant date.
--   b) The work must carry prominent notices stating that it is
-    released under this License and any conditions added under
-    section 7. This requirement modifies the requirement in section 4
-    to "keep intact all notices".
--   c) You must license the entire work, as a whole, under this
-    License to anyone who comes into possession of a copy. This
-    License will therefore apply, along with any applicable section 7
-    additional terms, to the whole of the work, and all its parts,
-    regardless of how they are packaged. This License gives no
-    permission to license the work in any other way, but it does not
-    invalidate such permission if you have separately received it.
--   d) If the work has interactive user interfaces, each must display
-    Appropriate Legal Notices; however, if the Program has interactive
-    interfaces that do not display Appropriate Legal Notices, your
-    work need not make them do so.
-
-A compilation of a covered work with other separate and independent
-works, which are not by their nature extensions of the covered work,
-and which are not combined with it such as to form a larger program,
-in or on a volume of a storage or distribution medium, is called an
-"aggregate" if the compilation and its resulting copyright are not
-used to limit the access or legal rights of the compilation's users
-beyond what the individual works permit. Inclusion of a covered work
-in an aggregate does not cause this License to apply to the other
-parts of the aggregate.
-
-### 6. Conveying Non-Source Forms.
-
-You may convey a covered work in object code form under the terms of
-sections 4 and 5, provided that you also convey the machine-readable
-Corresponding Source under the terms of this License, in one of these
-ways:
-
--   a) Convey the object code in, or embodied in, a physical product
-    (including a physical distribution medium), accompanied by the
-    Corresponding Source fixed on a durable physical medium
-    customarily used for software interchange.
--   b) Convey the object code in, or embodied in, a physical product
-    (including a physical distribution medium), accompanied by a
-    written offer, valid for at least three years and valid for as
-    long as you offer spare parts or customer support for that product
-    model, to give anyone who possesses the object code either (1) a
-    copy of the Corresponding Source for all the software in the
-    product that is covered by this License, on a durable physical
-    medium customarily used for software interchange, for a price no
-    more than your reasonable cost of physically performing this
-    conveying of source, or (2) access to copy the Corresponding
-    Source from a network server at no charge.
--   c) Convey individual copies of the object code with a copy of the
-    written offer to provide the Corresponding Source. This
-    alternative is allowed only occasionally and noncommercially, and
-    only if you received the object code with such an offer, in accord
-    with subsection 6b.
--   d) Convey the object code by offering access from a designated
-    place (gratis or for a charge), and offer equivalent access to the
-    Corresponding Source in the same way through the same place at no
-    further charge. You need not require recipients to copy the
-    Corresponding Source along with the object code. If the place to
-    copy the object code is a network server, the Corresponding Source
-    may be on a different server (operated by you or a third party)
-    that supports equivalent copying facilities, provided you maintain
-    clear directions next to the object code saying where to find the
-    Corresponding Source. Regardless of what server hosts the
-    Corresponding Source, you remain obligated to ensure that it is
-    available for as long as needed to satisfy these requirements.
--   e) Convey the object code using peer-to-peer transmission,
-    provided you inform other peers where the object code and
-    Corresponding Source of the work are being offered to the general
-    public at no charge under subsection 6d.
-
-A separable portion of the object code, whose source code is excluded
-from the Corresponding Source as a System Library, need not be
-included in conveying the object code work.
-
-A "User Product" is either (1) a "consumer product", which means any
-tangible personal property which is normally used for personal,
-family, or household purposes, or (2) anything designed or sold for
-incorporation into a dwelling. In determining whether a product is a
-consumer product, doubtful cases shall be resolved in favor of
-coverage. For a particular product received by a particular user,
-"normally used" refers to a typical or common use of that class of
-product, regardless of the status of the particular user or of the way
-in which the particular user actually uses, or expects or is expected
-to use, the product. A product is a consumer product regardless of
-whether the product has substantial commercial, industrial or
-non-consumer uses, unless such uses represent the only significant
-mode of use of the product.
-
-"Installation Information" for a User Product means any methods,
-procedures, authorization keys, or other information required to
-install and execute modified versions of a covered work in that User
-Product from a modified version of its Corresponding Source. The
-information must suffice to ensure that the continued functioning of
-the modified object code is in no case prevented or interfered with
-solely because modification has been made.
-
-If you convey an object code work under this section in, or with, or
-specifically for use in, a User Product, and the conveying occurs as
-part of a transaction in which the right of possession and use of the
-User Product is transferred to the recipient in perpetuity or for a
-fixed term (regardless of how the transaction is characterized), the
-Corresponding Source conveyed under this section must be accompanied
-by the Installation Information. But this requirement does not apply
-if neither you nor any third party retains the ability to install
-modified object code on the User Product (for example, the work has
-been installed in ROM).
-
-The requirement to provide Installation Information does not include a
-requirement to continue to provide support service, warranty, or
-updates for a work that has been modified or installed by the
-recipient, or for the User Product in which it has been modified or
-installed. Access to a network may be denied when the modification
-itself materially and adversely affects the operation of the network
-or violates the rules and protocols for communication across the
-network.
-
-Corresponding Source conveyed, and Installation Information provided,
-in accord with this section must be in a format that is publicly
-documented (and with an implementation available to the public in
-source code form), and must require no special password or key for
-unpacking, reading or copying.
-
-### 7. Additional Terms.
-
-"Additional permissions" are terms that supplement the terms of this
-License by making exceptions from one or more of its conditions.
-Additional permissions that are applicable to the entire Program shall
-be treated as though they were included in this License, to the extent
-that they are valid under applicable law. If additional permissions
-apply only to part of the Program, that part may be used separately
-under those permissions, but the entire Program remains governed by
-this License without regard to the additional permissions.
-
-When you convey a copy of a covered work, you may at your option
-remove any additional permissions from that copy, or from any part of
-it. (Additional permissions may be written to require their own
-removal in certain cases when you modify the work.) You may place
-additional permissions on material, added by you to a covered work,
-for which you have or can give appropriate copyright permission.
-
-Notwithstanding any other provision of this License, for material you
-add to a covered work, you may (if authorized by the copyright holders
-of that material) supplement the terms of this License with terms:
-
--   a) Disclaiming warranty or limiting liability differently from the
-    terms of sections 15 and 16 of this License; or
--   b) Requiring preservation of specified reasonable legal notices or
-    author attributions in that material or in the Appropriate Legal
-    Notices displayed by works containing it; or
--   c) Prohibiting misrepresentation of the origin of that material,
-    or requiring that modified versions of such material be marked in
-    reasonable ways as different from the original version; or
--   d) Limiting the use for publicity purposes of names of licensors
-    or authors of the material; or
--   e) Declining to grant rights under trademark law for use of some
-    trade names, trademarks, or service marks; or
--   f) Requiring indemnification of licensors and authors of that
-    material by anyone who conveys the material (or modified versions
-    of it) with contractual assumptions of liability to the recipient,
-    for any liability that these contractual assumptions directly
-    impose on those licensors and authors.
-
-All other non-permissive additional terms are considered "further
-restrictions" within the meaning of section 10. If the Program as you
-received it, or any part of it, contains a notice stating that it is
-governed by this License along with a term that is a further
-restriction, you may remove that term. If a license document contains
-a further restriction but permits relicensing or conveying under this
-License, you may add to a covered work material governed by the terms
-of that license document, provided that the further restriction does
-not survive such relicensing or conveying.
-
-If you add terms to a covered work in accord with this section, you
-must place, in the relevant source files, a statement of the
-additional terms that apply to those files, or a notice indicating
-where to find the applicable terms.
-
-Additional terms, permissive or non-permissive, may be stated in the
-form of a separately written license, or stated as exceptions; the
-above requirements apply either way.
-
-### 8. Termination.
-
-You may not propagate or modify a covered work except as expressly
-provided under this License. Any attempt otherwise to propagate or
-modify it is void, and will automatically terminate your rights under
-this License (including any patent licenses granted under the third
-paragraph of section 11).
-
-However, if you cease all violation of this License, then your license
-from a particular copyright holder is reinstated (a) provisionally,
-unless and until the copyright holder explicitly and finally
-terminates your license, and (b) permanently, if the copyright holder
-fails to notify you of the violation by some reasonable means prior to
-60 days after the cessation.
-
-Moreover, your license from a particular copyright holder is
-reinstated permanently if the copyright holder notifies you of the
-violation by some reasonable means, this is the first time you have
-received notice of violation of this License (for any work) from that
-copyright holder, and you cure the violation prior to 30 days after
-your receipt of the notice.
-
-Termination of your rights under this section does not terminate the
-licenses of parties who have received copies or rights from you under
-this License. If your rights have been terminated and not permanently
-reinstated, you do not qualify to receive new licenses for the same
-material under section 10.
-
-### 9. Acceptance Not Required for Having Copies.
-
-You are not required to accept this License in order to receive or run
-a copy of the Program. Ancillary propagation of a covered work
-occurring solely as a consequence of using peer-to-peer transmission
-to receive a copy likewise does not require acceptance. However,
-nothing other than this License grants you permission to propagate or
-modify any covered work. These actions infringe copyright if you do
-not accept this License. Therefore, by modifying or propagating a
-covered work, you indicate your acceptance of this License to do so.
-
-### 10. Automatic Licensing of Downstream Recipients.
-
-Each time you convey a covered work, the recipient automatically
-receives a license from the original licensors, to run, modify and
-propagate that work, subject to this License. You are not responsible
-for enforcing compliance by third parties with this License.
-
-An "entity transaction" is a transaction transferring control of an
-organization, or substantially all assets of one, or subdividing an
-organization, or merging organizations. If propagation of a covered
-work results from an entity transaction, each party to that
-transaction who receives a copy of the work also receives whatever
-licenses to the work the party's predecessor in interest had or could
-give under the previous paragraph, plus a right to possession of the
-Corresponding Source of the work from the predecessor in interest, if
-the predecessor has it or can get it with reasonable efforts.
-
-You may not impose any further restrictions on the exercise of the
-rights granted or affirmed under this License. For example, you may
-not impose a license fee, royalty, or other charge for exercise of
-rights granted under this License, and you may not initiate litigation
-(including a cross-claim or counterclaim in a lawsuit) alleging that
-any patent claim is infringed by making, using, selling, offering for
-sale, or importing the Program or any portion of it.
-
-### 11. Patents.
-
-A "contributor" is a copyright holder who authorizes use under this
-License of the Program or a work on which the Program is based. The
-work thus licensed is called the contributor's "contributor version".
-
-A contributor's "essential patent claims" are all patent claims owned
-or controlled by the contributor, whether already acquired or
-hereafter acquired, that would be infringed by some manner, permitted
-by this License, of making, using, or selling its contributor version,
-but do not include claims that would be infringed only as a
-consequence of further modification of the contributor version. For
-purposes of this definition, "control" includes the right to grant
-patent sublicenses in a manner consistent with the requirements of
-this License.
-
-Each contributor grants you a non-exclusive, worldwide, royalty-free
-patent license under the contributor's essential patent claims, to
-make, use, sell, offer for sale, import and otherwise run, modify and
-propagate the contents of its contributor version.
-
-In the following three paragraphs, a "patent license" is any express
-agreement or commitment, however denominated, not to enforce a patent
-(such as an express permission to practice a patent or covenant not to
-sue for patent infringement). To "grant" such a patent license to a
-party means to make such an agreement or commitment not to enforce a
-patent against the party.
-
-If you convey a covered work, knowingly relying on a patent license,
-and the Corresponding Source of the work is not available for anyone
-to copy, free of charge and under the terms of this License, through a
-publicly available network server or other readily accessible means,
-then you must either (1) cause the Corresponding Source to be so
-available, or (2) arrange to deprive yourself of the benefit of the
-patent license for this particular work, or (3) arrange, in a manner
-consistent with the requirements of this License, to extend the patent
-license to downstream recipients. "Knowingly relying" means you have
-actual knowledge that, but for the patent license, your conveying the
-covered work in a country, or your recipient's use of the covered work
-in a country, would infringe one or more identifiable patents in that
-country that you have reason to believe are valid.
-
-If, pursuant to or in connection with a single transaction or
-arrangement, you convey, or propagate by procuring conveyance of, a
-covered work, and grant a patent license to some of the parties
-receiving the covered work authorizing them to use, propagate, modify
-or convey a specific copy of the covered work, then the patent license
-you grant is automatically extended to all recipients of the covered
-work and works based on it.
-
-A patent license is "discriminatory" if it does not include within the
-scope of its coverage, prohibits the exercise of, or is conditioned on
-the non-exercise of one or more of the rights that are specifically
-granted under this License. You may not convey a covered work if you
-are a party to an arrangement with a third party that is in the
-business of distributing software, under which you make payment to the
-third party based on the extent of your activity of conveying the
-work, and under which the third party grants, to any of the parties
-who would receive the covered work from you, a discriminatory patent
-license (a) in connection with copies of the covered work conveyed by
-you (or copies made from those copies), or (b) primarily for and in
-connection with specific products or compilations that contain the
-covered work, unless you entered into that arrangement, or that patent
-license was granted, prior to 28 March 2007.
-
-Nothing in this License shall be construed as excluding or limiting
-any implied license or other defenses to infringement that may
-otherwise be available to you under applicable patent law.
-
-### 12. No Surrender of Others' Freedom.
-
-If conditions are imposed on you (whether by court order, agreement or
-otherwise) that contradict the conditions of this License, they do not
-excuse you from the conditions of this License. If you cannot convey a
-covered work so as to satisfy simultaneously your obligations under
-this License and any other pertinent obligations, then as a
-consequence you may not convey it at all. For example, if you agree to
-terms that obligate you to collect a royalty for further conveying
-from those to whom you convey the Program, the only way you could
-satisfy both those terms and this License would be to refrain entirely
-from conveying the Program.
-
-### 13. Use with the GNU Affero General Public License.
-
-Notwithstanding any other provision of this License, you have
-permission to link or combine any covered work with a work licensed
-under version 3 of the GNU Affero General Public License into a single
-combined work, and to convey the resulting work. The terms of this
-License will continue to apply to the part which is the covered work,
-but the special requirements of the GNU Affero General Public License,
-section 13, concerning interaction through a network will apply to the
-combination as such.
-
-### 14. Revised Versions of this License.
-
-The Free Software Foundation may publish revised and/or new versions
-of the GNU General Public License from time to time. Such new versions
-will be similar in spirit to the present version, but may differ in
-detail to address new problems or concerns.
-
-Each version is given a distinguishing version number. If the Program
-specifies that a certain numbered version of the GNU General Public
-License "or any later version" applies to it, you have the option of
-following the terms and conditions either of that numbered version or
-of any later version published by the Free Software Foundation. If the
-Program does not specify a version number of the GNU General Public
-License, you may choose any version ever published by the Free
-Software Foundation.
-
-If the Program specifies that a proxy can decide which future versions
-of the GNU General Public License can be used, that proxy's public
-statement of acceptance of a version permanently authorizes you to
-choose that version for the Program.
-
-Later license versions may give you additional or different
-permissions. However, no additional obligations are imposed on any
-author or copyright holder as a result of your choosing to follow a
-later version.
-
-### 15. Disclaimer of Warranty.
-
-THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
-APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
-HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT
-WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND
-PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE
-DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR
-CORRECTION.
-
-### 16. Limitation of Liability.
-
-IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
-WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR
-CONVEYS THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
-INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES
-ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT
-NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR
-LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM
-TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER
-PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
-
-### 17. Interpretation of Sections 15 and 16.
-
-If the disclaimer of warranty and limitation of liability provided
-above cannot be given local legal effect according to their terms,
-reviewing courts shall apply local law that most closely approximates
-an absolute waiver of all civil liability in connection with the
-Program, unless a warranty or assumption of liability accompanies a
-copy of the Program in return for a fee.
-
-END OF TERMS AND CONDITIONS
-
-## How to Apply These Terms to Your New Programs
-
-If you develop a new program, and you want it to be of the greatest
-possible use to the public, the best way to achieve this is to make it
-free software which everyone can redistribute and change under these
-terms.
-
-To do so, attach the following notices to the program. It is safest to
-attach them to the start of each source file to most effectively state
-the exclusion of warranty; and each file should have at least the
-"copyright" line and a pointer to where the full notice is found.
-
-        <one line to give the program's name and a brief idea of what it does.>
-        Copyright (C) <year>  <name of author>
-
-        This program is free software: you can redistribute it and/or modify
-        it under the terms of the GNU General Public License as published by
-        the Free Software Foundation, either version 3 of the License, or
-        (at your option) any later version.
-
-        This program is distributed in the hope that it will be useful,
-        but WITHOUT ANY WARRANTY; without even the implied warranty of
-        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-        GNU General Public License for more details.
-
-        You should have received a copy of the GNU General Public License
-        along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-Also add information on how to contact you by electronic and paper
-mail.
-
-If the program does terminal interaction, make it output a short
-notice like this when it starts in an interactive mode:
-
-        <program>  Copyright (C) <year>  <name of author>
-        This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
-        This is free software, and you are welcome to redistribute it
-        under certain conditions; type `show c' for details.
-
-The hypothetical commands \`show w' and \`show c' should show the
-appropriate parts of the General Public License. Of course, your
-program's commands might be different; for a GUI interface, you would
-use an "about box".
-
-You should also get your employer (if you work as a programmer) or
-school, if any, to sign a "copyright disclaimer" for the program, if
-necessary. For more information on this, and how to apply and follow
-the GNU GPL, see <https://www.gnu.org/licenses/>.
-
-The GNU General Public License does not permit incorporating your
-program into proprietary programs. If your program is a subroutine
-library, you may consider it more useful to permit linking proprietary
-applications with the library. If this is what you want to do, use the
-GNU Lesser General Public License instead of this License. But first,
-please read <https://www.gnu.org/licenses/why-not-lgpl.html>.

LICENSE.txt

@@ -0,0 +1,674 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<https://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<https://www.gnu.org/licenses/why-not-lgpl.html>.

src/android/app/src/main/jni/emu_window/emu_window.cpp

@@ -9,7 +9,6 @@
 #include "input_common/drivers/virtual_gamepad.h"
 #include "input_common/main.h"
 #include "jni/emu_window/emu_window.h"
-#include "jni/native.h"
 
 void EmuWindow_Android::OnSurfaceChanged(ANativeWindow* surface) {
     m_window_width = ANativeWindow_getWidth(surface);
@@ -58,13 +57,6 @@ void EmuWindow_Android::OnRemoveNfcTag() {
     m_input_subsystem->GetVirtualAmiibo()->CloseAmiibo();
 }
 
-void EmuWindow_Android::OnFrameDisplayed() {
-    if (!m_first_frame) {
-        EmulationSession::GetInstance().OnEmulationStarted();
-        m_first_frame = true;
-    }
-}
-
 EmuWindow_Android::EmuWindow_Android(InputCommon::InputSubsystem* input_subsystem,
                                      ANativeWindow* surface,
                                      std::shared_ptr<Common::DynamicLibrary> driver_library)

src/android/app/src/main/jni/emu_window/emu_window.h

@@ -45,7 +45,7 @@ public:
                               float gyro_z, float accel_x, float accel_y, float accel_z);
     void OnReadNfcTag(std::span<u8> data);
     void OnRemoveNfcTag();
-    void OnFrameDisplayed() override;
+    void OnFrameDisplayed() override {}
 
     std::unique_ptr<Core::Frontend::GraphicsContext> CreateSharedContext() const override {
         return {std::make_unique<GraphicsContext_Android>(m_driver_library)};
@@ -61,6 +61,4 @@ private:
     float m_window_height{};
 
     std::shared_ptr<Common::DynamicLibrary> m_driver_library;
-
-    bool m_first_frame = false;
 };

src/android/app/src/main/jni/native.cpp

@@ -372,6 +372,8 @@ void EmulationSession::RunEmulation() {
         m_system.InitializeDebugger();
     }
 
+    OnEmulationStarted();
+
     while (true) {
         {
             [[maybe_unused]] std::unique_lock lock(m_mutex);

src/android/app/src/main/jni/native.h

@@ -52,10 +52,9 @@ public:
     void OnGamepadDisconnectEvent([[maybe_unused]] int index);
     SoftwareKeyboard::AndroidKeyboard* SoftwareKeyboard();
 
-    static void OnEmulationStarted();
-
 private:
     static void LoadDiskCacheProgress(VideoCore::LoadCallbackStage stage, int progress, int max);
+    static void OnEmulationStarted();
     static void OnEmulationStopped(Core::SystemResultStatus result);
 
 private:

src/common/page_table.cpp

@@ -9,12 +9,12 @@ PageTable::PageTable() = default;
 
 PageTable::~PageTable() noexcept = default;
 
-bool PageTable::BeginTraversal(TraversalEntry* out_entry, TraversalContext* out_context,
-                               Common::ProcessAddress address) const {
+bool PageTable::BeginTraversal(TraversalEntry& out_entry, TraversalContext& out_context,
+                               u64 address) const {
     // Setup invalid defaults.
-    out_entry->phys_addr = 0;
-    out_entry->block_size = page_size;
-    out_context->next_page = 0;
+    out_entry.phys_addr = 0;
+    out_entry.block_size = page_size;
+    out_context.next_page = 0;
 
     // Validate that we can read the actual entry.
     const auto page = address / page_size;
@@ -29,20 +29,20 @@ bool PageTable::BeginTraversal(TraversalEntry* out_entry, TraversalContext* out_
     }
 
     // Populate the results.
-    out_entry->phys_addr = phys_addr + GetInteger(address);
-    out_context->next_page = page + 1;
-    out_context->next_offset = GetInteger(address) + page_size;
+    out_entry.phys_addr = phys_addr + address;
+    out_context.next_page = page + 1;
+    out_context.next_offset = address + page_size;
 
     return true;
 }
 
-bool PageTable::ContinueTraversal(TraversalEntry* out_entry, TraversalContext* context) const {
+bool PageTable::ContinueTraversal(TraversalEntry& out_entry, TraversalContext& context) const {
     // Setup invalid defaults.
-    out_entry->phys_addr = 0;
-    out_entry->block_size = page_size;
+    out_entry.phys_addr = 0;
+    out_entry.block_size = page_size;
 
     // Validate that we can read the actual entry.
-    const auto page = context->next_page;
+    const auto page = context.next_page;
     if (page >= backing_addr.size()) {
         return false;
     }
@@ -54,9 +54,9 @@ bool PageTable::ContinueTraversal(TraversalEntry* out_entry, TraversalContext* c
     }
 
     // Populate the results.
-    out_entry->phys_addr = phys_addr + context->next_offset;
-    context->next_page = page + 1;
-    context->next_offset += page_size;
+    out_entry.phys_addr = phys_addr + context.next_offset;
+    context.next_page = page + 1;
+    context.next_offset += page_size;
 
     return true;
 }

src/common/page_table.h

@@ -6,7 +6,6 @@
 #include <atomic>
 
 #include "common/common_types.h"
-#include "common/typed_address.h"
 #include "common/virtual_buffer.h"
 
 namespace Common {
@@ -101,9 +100,9 @@ struct PageTable {
     PageTable(PageTable&&) noexcept = default;
     PageTable& operator=(PageTable&&) noexcept = default;
 
-    bool BeginTraversal(TraversalEntry* out_entry, TraversalContext* out_context,
-                        Common::ProcessAddress address) const;
-    bool ContinueTraversal(TraversalEntry* out_entry, TraversalContext* context) const;
+    bool BeginTraversal(TraversalEntry& out_entry, TraversalContext& out_context,
+                        u64 address) const;
+    bool ContinueTraversal(TraversalEntry& out_entry, TraversalContext& context) const;
 
     /**
      * Resizes the page table to be able to accommodate enough pages within
@@ -118,16 +117,6 @@ struct PageTable {
         return current_address_space_width_in_bits;
     }
 
-    bool GetPhysicalAddress(Common::PhysicalAddress* out_phys_addr,
-                            Common::ProcessAddress virt_addr) const {
-        if (virt_addr > (1ULL << this->GetAddressSpaceBits())) {
-            return false;
-        }
-
-        *out_phys_addr = backing_addr[virt_addr / page_size] + GetInteger(virt_addr);
-        return true;
-    }
-
     /**
      * Vector of memory pointers backing each page. An entry can only be non-null if the
      * corresponding attribute element is of type `Memory`.

src/core/CMakeLists.txt

@@ -271,9 +271,8 @@ add_library(core STATIC
     hle/kernel/k_page_heap.h
     hle/kernel/k_page_group.cpp
     hle/kernel/k_page_group.h
+    hle/kernel/k_page_table.cpp
     hle/kernel/k_page_table.h
-    hle/kernel/k_page_table_base.cpp
-    hle/kernel/k_page_table_base.h
     hle/kernel/k_page_table_manager.h
     hle/kernel/k_page_table_slab_heap.h
     hle/kernel/k_port.cpp
@@ -281,7 +280,6 @@ add_library(core STATIC
     hle/kernel/k_priority_queue.h
     hle/kernel/k_process.cpp
     hle/kernel/k_process.h
-    hle/kernel/k_process_page_table.h
     hle/kernel/k_readable_event.cpp
     hle/kernel/k_readable_event.h
     hle/kernel/k_resource_limit.cpp
@@ -332,6 +330,8 @@ add_library(core STATIC
     hle/kernel/physical_core.cpp
     hle/kernel/physical_core.h
     hle/kernel/physical_memory.h
+    hle/kernel/process_capability.cpp
+    hle/kernel/process_capability.h
     hle/kernel/slab_helpers.h
     hle/kernel/svc.cpp
     hle/kernel/svc.h

src/core/debugger/gdbstub.cpp

@@ -562,120 +562,6 @@ static std::string PaginateBuffer(std::string_view buffer, std::string_view requ
     }
 }
 
-static VAddr GetModuleEnd(Kernel::KProcessPageTable& page_table, VAddr base) {
-    Kernel::KMemoryInfo mem_info;
-    Kernel::Svc::MemoryInfo svc_mem_info;
-    Kernel::Svc::PageInfo page_info;
-    VAddr cur_addr{base};
-
-    // Expect: r-x Code (.text)
-    R_ASSERT(page_table.QueryInfo(std::addressof(mem_info), std::addressof(page_info), cur_addr));
-    svc_mem_info = mem_info.GetSvcMemoryInfo();
-    cur_addr = svc_mem_info.base_address + svc_mem_info.size;
-    if (svc_mem_info.state != Kernel::Svc::MemoryState::Code ||
-        svc_mem_info.permission != Kernel::Svc::MemoryPermission::ReadExecute) {
-        return cur_addr - 1;
-    }
-
-    // Expect: r-- Code (.rodata)
-    R_ASSERT(page_table.QueryInfo(std::addressof(mem_info), std::addressof(page_info), cur_addr));
-    svc_mem_info = mem_info.GetSvcMemoryInfo();
-    cur_addr = svc_mem_info.base_address + svc_mem_info.size;
-    if (svc_mem_info.state != Kernel::Svc::MemoryState::Code ||
-        svc_mem_info.permission != Kernel::Svc::MemoryPermission::Read) {
-        return cur_addr - 1;
-    }
-
-    // Expect: rw- CodeData (.data)
-    R_ASSERT(page_table.QueryInfo(std::addressof(mem_info), std::addressof(page_info), cur_addr));
-    svc_mem_info = mem_info.GetSvcMemoryInfo();
-    cur_addr = svc_mem_info.base_address + svc_mem_info.size;
-    return cur_addr - 1;
-}
-
-static Loader::AppLoader::Modules FindModules(Core::System& system) {
-    Loader::AppLoader::Modules modules;
-
-    auto& page_table = system.ApplicationProcess()->GetPageTable();
-    auto& memory = system.ApplicationMemory();
-    VAddr cur_addr = 0;
-
-    // Look for executable sections in Code or AliasCode regions.
-    while (true) {
-        Kernel::KMemoryInfo mem_info{};
-        Kernel::Svc::PageInfo page_info{};
-        R_ASSERT(
-            page_table.QueryInfo(std::addressof(mem_info), std::addressof(page_info), cur_addr));
-        auto svc_mem_info = mem_info.GetSvcMemoryInfo();
-
-        if (svc_mem_info.permission == Kernel::Svc::MemoryPermission::ReadExecute &&
-            (svc_mem_info.state == Kernel::Svc::MemoryState::Code ||
-             svc_mem_info.state == Kernel::Svc::MemoryState::AliasCode)) {
-            // Try to read the module name from its path.
-            constexpr s32 PathLengthMax = 0x200;
-            struct {
-                u32 zero;
-                s32 path_length;
-                std::array<char, PathLengthMax> path;
-            } module_path;
-
-            if (memory.ReadBlock(svc_mem_info.base_address + svc_mem_info.size, &module_path,
-                                 sizeof(module_path))) {
-                if (module_path.zero == 0 && module_path.path_length > 0) {
-                    // Truncate module name.
-                    module_path.path[PathLengthMax - 1] = '\0';
-
-                    // Ignore leading directories.
-                    char* path_pointer = module_path.path.data();
-
-                    for (s32 i = 0; i < std::min(PathLengthMax, module_path.path_length) &&
-                                    module_path.path[i] != '\0';
-                         i++) {
-                        if (module_path.path[i] == '/' || module_path.path[i] == '\\') {
-                            path_pointer = module_path.path.data() + i + 1;
-                        }
-                    }
-
-                    // Insert output.
-                    modules.emplace(svc_mem_info.base_address, path_pointer);
-                }
-            }
-        }
-
-        // Check if we're done.
-        const uintptr_t next_address = svc_mem_info.base_address + svc_mem_info.size;
-        if (next_address <= cur_addr) {
-            break;
-        }
-
-        cur_addr = next_address;
-    }
-
-    return modules;
-}
-
-static VAddr FindMainModuleEntrypoint(Core::System& system) {
-    Loader::AppLoader::Modules modules;
-    system.GetAppLoader().ReadNSOModules(modules);
-
-    // Do we have a module named main?
-    const auto main = std::find_if(modules.begin(), modules.end(),
-                                   [](const auto& key) { return key.second == "main"; });
-
-    if (main != modules.end()) {
-        return main->first;
-    }
-
-    // Do we have any loaded executable sections?
-    modules = FindModules(system);
-    if (!modules.empty()) {
-        return modules.begin()->first;
-    }
-
-    // As a last resort, use the start of the code region.
-    return GetInteger(system.ApplicationProcess()->GetPageTable().GetCodeRegionStart());
-}
-
 void GDBStub::HandleQuery(std::string_view command) {
     if (command.starts_with("TStatus")) {
         // no tracepoint support
@@ -687,10 +573,21 @@ void GDBStub::HandleQuery(std::string_view command) {
         const auto target_xml{arch->GetTargetXML()};
         SendReply(PaginateBuffer(target_xml, command.substr(30)));
     } else if (command.starts_with("Offsets")) {
-        const auto main_offset = FindMainModuleEntrypoint(system);
-        SendReply(fmt::format("TextSeg={:x}", main_offset));
+        Loader::AppLoader::Modules modules;
+        system.GetAppLoader().ReadNSOModules(modules);
+
+        const auto main = std::find_if(modules.begin(), modules.end(),
+                                       [](const auto& key) { return key.second == "main"; });
+        if (main != modules.end()) {
+            SendReply(fmt::format("TextSeg={:x}", main->first));
+        } else {
+            SendReply(fmt::format(
+                "TextSeg={:x}",
+                GetInteger(system.ApplicationProcess()->GetPageTable().GetCodeRegionStart())));
+        }
     } else if (command.starts_with("Xfer:libraries:read::")) {
-        auto modules = FindModules(system);
+        Loader::AppLoader::Modules modules;
+        system.GetAppLoader().ReadNSOModules(modules);
 
         std::string buffer;
         buffer += R"(<?xml version="1.0"?>)";
@@ -830,6 +727,32 @@ static constexpr const char* GetMemoryPermissionString(const Kernel::Svc::Memory
     }
 }
 
+static VAddr GetModuleEnd(Kernel::KPageTable& page_table, VAddr base) {
+    Kernel::Svc::MemoryInfo mem_info;
+    VAddr cur_addr{base};
+
+    // Expect: r-x Code (.text)
+    mem_info = page_table.QueryInfo(cur_addr).GetSvcMemoryInfo();
+    cur_addr = mem_info.base_address + mem_info.size;
+    if (mem_info.state != Kernel::Svc::MemoryState::Code ||
+        mem_info.permission != Kernel::Svc::MemoryPermission::ReadExecute) {
+        return cur_addr - 1;
+    }
+
+    // Expect: r-- Code (.rodata)
+    mem_info = page_table.QueryInfo(cur_addr).GetSvcMemoryInfo();
+    cur_addr = mem_info.base_address + mem_info.size;
+    if (mem_info.state != Kernel::Svc::MemoryState::Code ||
+        mem_info.permission != Kernel::Svc::MemoryPermission::Read) {
+        return cur_addr - 1;
+    }
+
+    // Expect: rw- CodeData (.data)
+    mem_info = page_table.QueryInfo(cur_addr).GetSvcMemoryInfo();
+    cur_addr = mem_info.base_address + mem_info.size;
+    return cur_addr - 1;
+}
+
 void GDBStub::HandleRcmd(const std::vector<u8>& command) {
     std::string_view command_str{reinterpret_cast<const char*>(&command[0]), command.size()};
     std::string reply;
@@ -844,7 +767,7 @@ void GDBStub::HandleRcmd(const std::vector<u8>& command) {
 
     if (command_str == "get fastmem") {
         if (Settings::IsFastmemEnabled()) {
-            const auto& impl = page_table.GetImpl();
+            const auto& impl = page_table.PageTableImpl();
             const auto region = reinterpret_cast<uintptr_t>(impl.fastmem_arena);
             const auto region_bits = impl.current_address_space_width_in_bits;
             const auto region_size = 1ULL << region_bits;
@@ -856,27 +779,26 @@ void GDBStub::HandleRcmd(const std::vector<u8>& command) {
             reply = "Fastmem is not enabled.\n";
         }
     } else if (command_str == "get info") {
-        auto modules = FindModules(system);
+        Loader::AppLoader::Modules modules;
+        system.GetAppLoader().ReadNSOModules(modules);
 
         reply = fmt::format("Process:     {:#x} ({})\n"
                             "Program Id:  {:#018x}\n",
                             process->GetProcessId(), process->GetName(), process->GetProgramId());
-        reply += fmt::format(
-            "Layout:\n"
-            "  Alias: {:#012x} - {:#012x}\n"
-            "  Heap:  {:#012x} - {:#012x}\n"
-            "  Aslr:  {:#012x} - {:#012x}\n"
-            "  Stack: {:#012x} - {:#012x}\n"
-            "Modules:\n",
-            GetInteger(page_table.GetAliasRegionStart()),
-            GetInteger(page_table.GetAliasRegionStart()) + page_table.GetAliasRegionSize() - 1,
-            GetInteger(page_table.GetHeapRegionStart()),
-            GetInteger(page_table.GetHeapRegionStart()) + page_table.GetHeapRegionSize() - 1,
-            GetInteger(page_table.GetAliasCodeRegionStart()),
-            GetInteger(page_table.GetAliasCodeRegionStart()) + page_table.GetAliasCodeRegionSize() -
-                1,
-            GetInteger(page_table.GetStackRegionStart()),
-            GetInteger(page_table.GetStackRegionStart()) + page_table.GetStackRegionSize() - 1);
+        reply += fmt::format("Layout:\n"
+                             "  Alias: {:#012x} - {:#012x}\n"
+                             "  Heap:  {:#012x} - {:#012x}\n"
+                             "  Aslr:  {:#012x} - {:#012x}\n"
+                             "  Stack: {:#012x} - {:#012x}\n"
+                             "Modules:\n",
+                             GetInteger(page_table.GetAliasRegionStart()),
+                             GetInteger(page_table.GetAliasRegionEnd()),
+                             GetInteger(page_table.GetHeapRegionStart()),
+                             GetInteger(page_table.GetHeapRegionEnd()),
+                             GetInteger(page_table.GetAliasCodeRegionStart()),
+                             GetInteger(page_table.GetAliasCodeRegionEnd()),
+                             GetInteger(page_table.GetStackRegionStart()),
+                             GetInteger(page_table.GetStackRegionEnd()));
 
         for (const auto& [vaddr, name] : modules) {
             reply += fmt::format("  {:#012x} - {:#012x} {}\n", vaddr,
@@ -889,34 +811,27 @@ void GDBStub::HandleRcmd(const std::vector<u8>& command) {
         while (true) {
             using MemoryAttribute = Kernel::Svc::MemoryAttribute;
 
-            Kernel::KMemoryInfo mem_info{};
-            Kernel::Svc::PageInfo page_info{};
-            R_ASSERT(page_table.QueryInfo(std::addressof(mem_info), std::addressof(page_info),
-                                          cur_addr));
-            auto svc_mem_info = mem_info.GetSvcMemoryInfo();
+            auto mem_info = page_table.QueryInfo(cur_addr).GetSvcMemoryInfo();
 
-            if (svc_mem_info.state != Kernel::Svc::MemoryState::Inaccessible ||
-                svc_mem_info.base_address + svc_mem_info.size - 1 !=
-                    std::numeric_limits<u64>::max()) {
-                const char* state = GetMemoryStateName(svc_mem_info.state);
-                const char* perm = GetMemoryPermissionString(svc_mem_info);
+            if (mem_info.state != Kernel::Svc::MemoryState::Inaccessible ||
+                mem_info.base_address + mem_info.size - 1 != std::numeric_limits<u64>::max()) {
+                const char* state = GetMemoryStateName(mem_info.state);
+                const char* perm = GetMemoryPermissionString(mem_info);
 
-                const char l = True(svc_mem_info.attribute & MemoryAttribute::Locked) ? 'L' : '-';
-                const char i =
-                    True(svc_mem_info.attribute & MemoryAttribute::IpcLocked) ? 'I' : '-';
-                const char d =
-                    True(svc_mem_info.attribute & MemoryAttribute::DeviceShared) ? 'D' : '-';
-                const char u = True(svc_mem_info.attribute & MemoryAttribute::Uncached) ? 'U' : '-';
+                const char l = True(mem_info.attribute & MemoryAttribute::Locked) ? 'L' : '-';
+                const char i = True(mem_info.attribute & MemoryAttribute::IpcLocked) ? 'I' : '-';
+                const char d = True(mem_info.attribute & MemoryAttribute::DeviceShared) ? 'D' : '-';
+                const char u = True(mem_info.attribute & MemoryAttribute::Uncached) ? 'U' : '-';
                 const char p =
-                    True(svc_mem_info.attribute & MemoryAttribute::PermissionLocked) ? 'P' : '-';
+                    True(mem_info.attribute & MemoryAttribute::PermissionLocked) ? 'P' : '-';
 
-                reply += fmt::format(
-                    "  {:#012x} - {:#012x} {} {} {}{}{}{}{} [{}, {}]\n", svc_mem_info.base_address,
-                    svc_mem_info.base_address + svc_mem_info.size - 1, perm, state, l, i, d, u, p,
-                    svc_mem_info.ipc_count, svc_mem_info.device_count);
+                reply += fmt::format("  {:#012x} - {:#012x} {} {} {}{}{}{}{} [{}, {}]\n",
+                                     mem_info.base_address,
+                                     mem_info.base_address + mem_info.size - 1, perm, state, l, i,
+                                     d, u, p, mem_info.ipc_count, mem_info.device_count);
             }
 
-            const uintptr_t next_address = svc_mem_info.base_address + svc_mem_info.size;
+            const uintptr_t next_address = mem_info.base_address + mem_info.size;
             if (next_address <= cur_addr) {
                 break;
             }

src/core/hle/kernel/board/nintendo/nx/k_system_control.cpp

@@ -222,7 +222,7 @@ Result KSystemControl::AllocateSecureMemory(KernelCore& kernel, KVirtualAddress*
     };
 
     // We succeeded.
-    *out = KPageTable::GetHeapVirtualAddress(kernel, paddr);
+    *out = KPageTable::GetHeapVirtualAddress(kernel.MemoryLayout(), paddr);
     R_SUCCEED();
 }
 
@@ -238,17 +238,8 @@ void KSystemControl::FreeSecureMemory(KernelCore& kernel, KVirtualAddress addres
     ASSERT(Common::IsAligned(size, alignment));
 
     // Close the secure region's pages.
-    kernel.MemoryManager().Close(KPageTable::GetHeapPhysicalAddress(kernel, address),
+    kernel.MemoryManager().Close(KPageTable::GetHeapPhysicalAddress(kernel.MemoryLayout(), address),
                                  size / PageSize);
 }
 
-// Insecure Memory.
-KResourceLimit* KSystemControl::GetInsecureMemoryResourceLimit(KernelCore& kernel) {
-    return kernel.GetSystemResourceLimit();
-}
-
-u32 KSystemControl::GetInsecureMemoryPool() {
-    return static_cast<u32>(KMemoryManager::Pool::SystemNonSecure);
-}
-
 } // namespace Kernel::Board::Nintendo::Nx

src/core/hle/kernel/board/nintendo/nx/k_system_control.h

@@ -8,8 +8,7 @@
 
 namespace Kernel {
 class KernelCore;
-class KResourceLimit;
-} // namespace Kernel
+}
 
 namespace Kernel::Board::Nintendo::Nx {
 
@@ -41,10 +40,6 @@ public:
                                        u32 pool);
     static void FreeSecureMemory(KernelCore& kernel, KVirtualAddress address, size_t size,
                                  u32 pool);
-
-    // Insecure Memory.
-    static KResourceLimit* GetInsecureMemoryResourceLimit(KernelCore& kernel);
-    static u32 GetInsecureMemoryPool();
 };
 
 } // namespace Kernel::Board::Nintendo::Nx

src/core/hle/kernel/k_capabilities.cpp

@@ -4,16 +4,14 @@
 #include "core/hardware_properties.h"
 #include "core/hle/kernel/k_capabilities.h"
 #include "core/hle/kernel/k_memory_layout.h"
-#include "core/hle/kernel/k_process_page_table.h"
-#include "core/hle/kernel/k_trace.h"
+#include "core/hle/kernel/k_page_table.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/svc_results.h"
 #include "core/hle/kernel/svc_version.h"
 
 namespace Kernel {
 
-Result KCapabilities::InitializeForKip(std::span<const u32> kern_caps,
-                                       KProcessPageTable* page_table) {
+Result KCapabilities::InitializeForKip(std::span<const u32> kern_caps, KPageTable* page_table) {
     // We're initializing an initial process.
     m_svc_access_flags.reset();
     m_irq_access_flags.reset();
@@ -43,8 +41,7 @@ Result KCapabilities::InitializeForKip(std::span<const u32> kern_caps,
     R_RETURN(this->SetCapabilities(kern_caps, page_table));
 }
 
-Result KCapabilities::InitializeForUser(std::span<const u32> user_caps,
-                                        KProcessPageTable* page_table) {
+Result KCapabilities::InitializeForUser(std::span<const u32> user_caps, KPageTable* page_table) {
     // We're initializing a user process.
     m_svc_access_flags.reset();
     m_irq_access_flags.reset();
@@ -124,7 +121,7 @@ Result KCapabilities::SetSyscallMaskCapability(const u32 cap, u32& set_svc) {
     R_SUCCEED();
 }
 
-Result KCapabilities::MapRange_(const u32 cap, const u32 size_cap, KProcessPageTable* page_table) {
+Result KCapabilities::MapRange_(const u32 cap, const u32 size_cap, KPageTable* page_table) {
     const auto range_pack = MapRange{cap};
     const auto size_pack = MapRangeSize{size_cap};
 
@@ -145,13 +142,16 @@ Result KCapabilities::MapRange_(const u32 cap, const u32 size_cap, KProcessPageT
                                                         ? KMemoryPermission::UserRead
                                                         : KMemoryPermission::UserReadWrite;
     if (MapRangeSize{size_cap}.normal) {
-        R_RETURN(page_table->MapStatic(phys_addr, size, perm));
+        // R_RETURN(page_table->MapStatic(phys_addr, size, perm));
     } else {
-        R_RETURN(page_table->MapIo(phys_addr, size, perm));
+        // R_RETURN(page_table->MapIo(phys_addr, size, perm));
     }
+
+    UNIMPLEMENTED();
+    R_SUCCEED();
 }
 
-Result KCapabilities::MapIoPage_(const u32 cap, KProcessPageTable* page_table) {
+Result KCapabilities::MapIoPage_(const u32 cap, KPageTable* page_table) {
     // Get/validate address/size
     const u64 phys_addr = MapIoPage{cap}.address.Value() * PageSize;
     const size_t num_pages = 1;
@@ -160,7 +160,10 @@ Result KCapabilities::MapIoPage_(const u32 cap, KProcessPageTable* page_table) {
     R_UNLESS(((phys_addr + size - 1) & ~PhysicalMapAllowedMask) == 0, ResultInvalidAddress);
 
     // Do the mapping.
-    R_RETURN(page_table->MapIo(phys_addr, size, KMemoryPermission::UserReadWrite));
+    // R_RETURN(page_table->MapIo(phys_addr, size, KMemoryPermission_UserReadWrite));
+
+    UNIMPLEMENTED();
+    R_SUCCEED();
 }
 
 template <typename F>
@@ -197,11 +200,13 @@ Result KCapabilities::ProcessMapRegionCapability(const u32 cap, F f) {
     R_SUCCEED();
 }
 
-Result KCapabilities::MapRegion_(const u32 cap, KProcessPageTable* page_table) {
+Result KCapabilities::MapRegion_(const u32 cap, KPageTable* page_table) {
     // Map each region into the process's page table.
     return ProcessMapRegionCapability(
-        cap, [page_table](KMemoryRegionType region_type, KMemoryPermission perm) -> Result {
-            R_RETURN(page_table->MapRegion(region_type, perm));
+        cap, [](KMemoryRegionType region_type, KMemoryPermission perm) -> Result {
+            // R_RETURN(page_table->MapRegion(region_type, perm));
+            UNIMPLEMENTED();
+            R_SUCCEED();
         });
 }
 
@@ -275,7 +280,7 @@ Result KCapabilities::SetDebugFlagsCapability(const u32 cap) {
 }
 
 Result KCapabilities::SetCapability(const u32 cap, u32& set_flags, u32& set_svc,
-                                    KProcessPageTable* page_table) {
+                                    KPageTable* page_table) {
     // Validate this is a capability we can act on.
     const auto type = GetCapabilityType(cap);
     R_UNLESS(type != CapabilityType::Invalid, ResultInvalidArgument);
@@ -313,7 +318,7 @@ Result KCapabilities::SetCapability(const u32 cap, u32& set_flags, u32& set_svc,
     }
 }
 
-Result KCapabilities::SetCapabilities(std::span<const u32> caps, KProcessPageTable* page_table) {
+Result KCapabilities::SetCapabilities(std::span<const u32> caps, KPageTable* page_table) {
     u32 set_flags = 0, set_svc = 0;
 
     for (size_t i = 0; i < caps.size(); i++) {
@@ -330,8 +335,6 @@ Result KCapabilities::SetCapabilities(std::span<const u32> caps, KProcessPageTab
 
             // Map the range.
             R_TRY(this->MapRange_(cap, size_cap, page_table));
-        } else if (GetCapabilityType(cap) == CapabilityType::MapRegion && !IsKTraceEnabled) {
-            continue;
         } else {
             R_TRY(this->SetCapability(cap, set_flags, set_svc, page_table));
         }

src/core/hle/kernel/k_capabilities.h

@@ -15,15 +15,15 @@
 
 namespace Kernel {
 
-class KProcessPageTable;
+class KPageTable;
 class KernelCore;
 
 class KCapabilities {
 public:
     constexpr explicit KCapabilities() = default;
 
-    Result InitializeForKip(std::span<const u32> kern_caps, KProcessPageTable* page_table);
-    Result InitializeForUser(std::span<const u32> user_caps, KProcessPageTable* page_table);
+    Result InitializeForKip(std::span<const u32> kern_caps, KPageTable* page_table);
+    Result InitializeForUser(std::span<const u32> user_caps, KPageTable* page_table);
 
     static Result CheckCapabilities(KernelCore& kernel, std::span<const u32> user_caps);
 
@@ -264,9 +264,9 @@ private:
 
     Result SetCorePriorityCapability(const u32 cap);
     Result SetSyscallMaskCapability(const u32 cap, u32& set_svc);
-    Result MapRange_(const u32 cap, const u32 size_cap, KProcessPageTable* page_table);
-    Result MapIoPage_(const u32 cap, KProcessPageTable* page_table);
-    Result MapRegion_(const u32 cap, KProcessPageTable* page_table);
+    Result MapRange_(const u32 cap, const u32 size_cap, KPageTable* page_table);
+    Result MapIoPage_(const u32 cap, KPageTable* page_table);
+    Result MapRegion_(const u32 cap, KPageTable* page_table);
     Result SetInterruptPairCapability(const u32 cap);
     Result SetProgramTypeCapability(const u32 cap);
     Result SetKernelVersionCapability(const u32 cap);
@@ -277,9 +277,8 @@ private:
     static Result ProcessMapRegionCapability(const u32 cap, F f);
     static Result CheckMapRegion(KernelCore& kernel, const u32 cap);
 
-    Result SetCapability(const u32 cap, u32& set_flags, u32& set_svc,
-                         KProcessPageTable* page_table);
-    Result SetCapabilities(std::span<const u32> caps, KProcessPageTable* page_table);
+    Result SetCapability(const u32 cap, u32& set_flags, u32& set_svc, KPageTable* page_table);
+    Result SetCapabilities(std::span<const u32> caps, KPageTable* page_table);
 
 private:
     Svc::SvcAccessFlagSet m_svc_access_flags{};

src/core/hle/kernel/k_device_address_space.cpp

@@ -54,7 +54,7 @@ Result KDeviceAddressSpace::Detach(Svc::DeviceName device_name) {
     R_SUCCEED();
 }
 
-Result KDeviceAddressSpace::Map(KProcessPageTable* page_table, KProcessAddress process_address,
+Result KDeviceAddressSpace::Map(KPageTable* page_table, KProcessAddress process_address,
                                 size_t size, u64 device_address, u32 option, bool is_aligned) {
     // Check that the address falls within the space.
     R_UNLESS((m_space_address <= device_address &&
@@ -113,7 +113,7 @@ Result KDeviceAddressSpace::Map(KProcessPageTable* page_table, KProcessAddress p
     R_SUCCEED();
 }
 
-Result KDeviceAddressSpace::Unmap(KProcessPageTable* page_table, KProcessAddress process_address,
+Result KDeviceAddressSpace::Unmap(KPageTable* page_table, KProcessAddress process_address,
                                   size_t size, u64 device_address) {
     // Check that the address falls within the space.
     R_UNLESS((m_space_address <= device_address &&

src/core/hle/kernel/k_device_address_space.h

@@ -5,7 +5,7 @@
 
 #include <string>
 
-#include "core/hle/kernel/k_process_page_table.h"
+#include "core/hle/kernel/k_page_table.h"
 #include "core/hle/kernel/k_typed_address.h"
 #include "core/hle/kernel/slab_helpers.h"
 #include "core/hle/result.h"
@@ -31,23 +31,23 @@ public:
     Result Attach(Svc::DeviceName device_name);
     Result Detach(Svc::DeviceName device_name);
 
-    Result MapByForce(KProcessPageTable* page_table, KProcessAddress process_address, size_t size,
+    Result MapByForce(KPageTable* page_table, KProcessAddress process_address, size_t size,
                       u64 device_address, u32 option) {
         R_RETURN(this->Map(page_table, process_address, size, device_address, option, false));
     }
 
-    Result MapAligned(KProcessPageTable* page_table, KProcessAddress process_address, size_t size,
+    Result MapAligned(KPageTable* page_table, KProcessAddress process_address, size_t size,
                       u64 device_address, u32 option) {
         R_RETURN(this->Map(page_table, process_address, size, device_address, option, true));
     }
 
-    Result Unmap(KProcessPageTable* page_table, KProcessAddress process_address, size_t size,
+    Result Unmap(KPageTable* page_table, KProcessAddress process_address, size_t size,
                  u64 device_address);
 
     static void Initialize();
 
 private:
-    Result Map(KProcessPageTable* page_table, KProcessAddress process_address, size_t size,
+    Result Map(KPageTable* page_table, KProcessAddress process_address, size_t size,
                u64 device_address, u32 option, bool is_aligned);
 
 private:

src/core/hle/kernel/k_memory_layout.h

@@ -394,14 +394,6 @@ private:
         return region.GetEndAddress();
     }
 
-public:
-    static const KMemoryRegion* Find(const KMemoryLayout& layout, KVirtualAddress address) {
-        return Find(address, layout.GetVirtualMemoryRegionTree());
-    }
-    static const KMemoryRegion* Find(const KMemoryLayout& layout, KPhysicalAddress address) {
-        return Find(address, layout.GetPhysicalMemoryRegionTree());
-    }
-
 private:
     u64 m_linear_phys_to_virt_diff{};
     u64 m_linear_virt_to_phys_diff{};

src/core/hle/kernel/k_memory_manager.cpp

@@ -456,7 +456,8 @@ size_t KMemoryManager::Impl::Initialize(KPhysicalAddress address, size_t size,
 }
 
 void KMemoryManager::Impl::InitializeOptimizedMemory(KernelCore& kernel) {
-    auto optimize_pa = KPageTable::GetHeapPhysicalAddress(kernel, m_management_region);
+    auto optimize_pa =
+        KPageTable::GetHeapPhysicalAddress(kernel.MemoryLayout(), m_management_region);
     auto* optimize_map = kernel.System().DeviceMemory().GetPointer<u64>(optimize_pa);
 
     std::memset(optimize_map, 0, CalculateOptimizedProcessOverheadSize(m_heap.GetSize()));
@@ -464,7 +465,8 @@ void KMemoryManager::Impl::InitializeOptimizedMemory(KernelCore& kernel) {
 
 void KMemoryManager::Impl::TrackUnoptimizedAllocation(KernelCore& kernel, KPhysicalAddress block,
                                                       size_t num_pages) {
-    auto optimize_pa = KPageTable::GetHeapPhysicalAddress(kernel, m_management_region);
+    auto optimize_pa =
+        KPageTable::GetHeapPhysicalAddress(kernel.MemoryLayout(), m_management_region);
     auto* optimize_map = kernel.System().DeviceMemory().GetPointer<u64>(optimize_pa);
 
     // Get the range we're tracking.
@@ -483,7 +485,8 @@ void KMemoryManager::Impl::TrackUnoptimizedAllocation(KernelCore& kernel, KPhysi
 
 void KMemoryManager::Impl::TrackOptimizedAllocation(KernelCore& kernel, KPhysicalAddress block,
                                                     size_t num_pages) {
-    auto optimize_pa = KPageTable::GetHeapPhysicalAddress(kernel, m_management_region);
+    auto optimize_pa =
+        KPageTable::GetHeapPhysicalAddress(kernel.MemoryLayout(), m_management_region);
     auto* optimize_map = kernel.System().DeviceMemory().GetPointer<u64>(optimize_pa);
 
     // Get the range we're tracking.
@@ -503,7 +506,8 @@ void KMemoryManager::Impl::TrackOptimizedAllocation(KernelCore& kernel, KPhysica
 bool KMemoryManager::Impl::ProcessOptimizedAllocation(KernelCore& kernel, KPhysicalAddress block,
                                                       size_t num_pages, u8 fill_pattern) {
     auto& device_memory = kernel.System().DeviceMemory();
-    auto optimize_pa = KPageTable::GetHeapPhysicalAddress(kernel, m_management_region);
+    auto optimize_pa =
+        KPageTable::GetHeapPhysicalAddress(kernel.MemoryLayout(), m_management_region);
     auto* optimize_map = device_memory.GetPointer<u64>(optimize_pa);
 
     // We want to return whether any pages were newly allocated.

src/core/hle/kernel/k_page_table.h

@@ -3,14 +3,548 @@
 
 #pragma once
 
-#include "core/hle/kernel/k_page_table_base.h"
+#include <memory>
+
+#include "common/common_funcs.h"
+#include "common/page_table.h"
+#include "core/file_sys/program_metadata.h"
+#include "core/hle/kernel/k_dynamic_resource_manager.h"
+#include "core/hle/kernel/k_light_lock.h"
+#include "core/hle/kernel/k_memory_block.h"
+#include "core/hle/kernel/k_memory_block_manager.h"
+#include "core/hle/kernel/k_memory_layout.h"
+#include "core/hle/kernel/k_memory_manager.h"
+#include "core/hle/kernel/k_typed_address.h"
+#include "core/hle/result.h"
+#include "core/memory.h"
+
+namespace Core {
+class System;
+}
 
 namespace Kernel {
 
-class KPageTable final : public KPageTableBase {
+enum class DisableMergeAttribute : u8 {
+    None = (0U << 0),
+    DisableHead = (1U << 0),
+    DisableHeadAndBody = (1U << 1),
+    EnableHeadAndBody = (1U << 2),
+    DisableTail = (1U << 3),
+    EnableTail = (1U << 4),
+    EnableAndMergeHeadBodyTail = (1U << 5),
+    EnableHeadBodyTail = EnableHeadAndBody | EnableTail,
+    DisableHeadBodyTail = DisableHeadAndBody | DisableTail,
+};
+
+struct KPageProperties {
+    KMemoryPermission perm;
+    bool io;
+    bool uncached;
+    DisableMergeAttribute disable_merge_attributes;
+};
+static_assert(std::is_trivial_v<KPageProperties>);
+static_assert(sizeof(KPageProperties) == sizeof(u32));
+
+class KBlockInfoManager;
+class KMemoryBlockManager;
+class KResourceLimit;
+class KSystemResource;
+
+class KPageTable final {
+protected:
+    struct PageLinkedList;
+
 public:
-    explicit KPageTable(KernelCore& kernel) : KPageTableBase(kernel) {}
-    ~KPageTable() = default;
+    enum class ICacheInvalidationStrategy : u32 { InvalidateRange, InvalidateAll };
+
+    YUZU_NON_COPYABLE(KPageTable);
+    YUZU_NON_MOVEABLE(KPageTable);
+
+    explicit KPageTable(Core::System& system_);
+    ~KPageTable();
+
+    Result InitializeForProcess(Svc::CreateProcessFlag as_type, bool enable_aslr,
+                                bool enable_das_merge, bool from_back, KMemoryManager::Pool pool,
+                                KProcessAddress code_addr, size_t code_size,
+                                KSystemResource* system_resource, KResourceLimit* resource_limit,
+                                Core::Memory::Memory& memory);
+
+    void Finalize();
+
+    Result MapProcessCode(KProcessAddress addr, size_t pages_count, KMemoryState state,
+                          KMemoryPermission perm);
+    Result MapCodeMemory(KProcessAddress dst_address, KProcessAddress src_address, size_t size);
+    Result UnmapCodeMemory(KProcessAddress dst_address, KProcessAddress src_address, size_t size,
+                           ICacheInvalidationStrategy icache_invalidation_strategy);
+    Result UnmapProcessMemory(KProcessAddress dst_addr, size_t size, KPageTable& src_page_table,
+                              KProcessAddress src_addr);
+    Result MapPhysicalMemory(KProcessAddress addr, size_t size);
+    Result UnmapPhysicalMemory(KProcessAddress addr, size_t size);
+    Result MapMemory(KProcessAddress dst_addr, KProcessAddress src_addr, size_t size);
+    Result UnmapMemory(KProcessAddress dst_addr, KProcessAddress src_addr, size_t size);
+    Result SetProcessMemoryPermission(KProcessAddress addr, size_t size,
+                                      Svc::MemoryPermission svc_perm);
+    KMemoryInfo QueryInfo(KProcessAddress addr);
+    Result SetMemoryPermission(KProcessAddress addr, size_t size, Svc::MemoryPermission perm);
+    Result SetMemoryAttribute(KProcessAddress addr, size_t size, u32 mask, u32 attr);
+    Result SetMaxHeapSize(size_t size);
+    Result SetHeapSize(u64* out, size_t size);
+    Result LockForMapDeviceAddressSpace(bool* out_is_io, KProcessAddress address, size_t size,
+                                        KMemoryPermission perm, bool is_aligned, bool check_heap);
+    Result LockForUnmapDeviceAddressSpace(KProcessAddress address, size_t size, bool check_heap);
+
+    Result UnlockForDeviceAddressSpace(KProcessAddress addr, size_t size);
+
+    Result LockForIpcUserBuffer(KPhysicalAddress* out, KProcessAddress address, size_t size);
+    Result UnlockForIpcUserBuffer(KProcessAddress address, size_t size);
+
+    Result SetupForIpc(KProcessAddress* out_dst_addr, size_t size, KProcessAddress src_addr,
+                       KPageTable& src_page_table, KMemoryPermission test_perm,
+                       KMemoryState dst_state, bool send);
+    Result CleanupForIpcServer(KProcessAddress address, size_t size, KMemoryState dst_state);
+    Result CleanupForIpcClient(KProcessAddress address, size_t size, KMemoryState dst_state);
+
+    Result LockForTransferMemory(KPageGroup* out, KProcessAddress address, size_t size,
+                                 KMemoryPermission perm);
+    Result UnlockForTransferMemory(KProcessAddress address, size_t size, const KPageGroup& pg);
+    Result LockForCodeMemory(KPageGroup* out, KProcessAddress addr, size_t size);
+    Result UnlockForCodeMemory(KProcessAddress addr, size_t size, const KPageGroup& pg);
+    Result MakeAndOpenPageGroup(KPageGroup* out, KProcessAddress address, size_t num_pages,
+                                KMemoryState state_mask, KMemoryState state,
+                                KMemoryPermission perm_mask, KMemoryPermission perm,
+                                KMemoryAttribute attr_mask, KMemoryAttribute attr);
+
+    Common::PageTable& PageTableImpl() {
+        return *m_page_table_impl;
+    }
+
+    const Common::PageTable& PageTableImpl() const {
+        return *m_page_table_impl;
+    }
+
+    KBlockInfoManager* GetBlockInfoManager() {
+        return m_block_info_manager;
+    }
+
+    Result MapPages(KProcessAddress* out_addr, size_t num_pages, size_t alignment,
+                    KPhysicalAddress phys_addr, KProcessAddress region_start,
+                    size_t region_num_pages, KMemoryState state, KMemoryPermission perm) {
+        R_RETURN(this->MapPages(out_addr, num_pages, alignment, phys_addr, true, region_start,
+                                region_num_pages, state, perm));
+    }
+
+    Result MapPages(KProcessAddress* out_addr, size_t num_pages, size_t alignment,
+                    KPhysicalAddress phys_addr, KMemoryState state, KMemoryPermission perm) {
+        R_RETURN(this->MapPages(out_addr, num_pages, alignment, phys_addr, true,
+                                this->GetRegionAddress(state),
+                                this->GetRegionSize(state) / PageSize, state, perm));
+    }
+
+    Result MapPages(KProcessAddress* out_addr, size_t num_pages, KMemoryState state,
+                    KMemoryPermission perm) {
+        R_RETURN(this->MapPages(out_addr, num_pages, PageSize, 0, false,
+                                this->GetRegionAddress(state),
+                                this->GetRegionSize(state) / PageSize, state, perm));
+    }
+
+    Result MapPages(KProcessAddress address, size_t num_pages, KMemoryState state,
+                    KMemoryPermission perm);
+    Result UnmapPages(KProcessAddress address, size_t num_pages, KMemoryState state);
+
+    Result MapPageGroup(KProcessAddress* out_addr, const KPageGroup& pg,
+                        KProcessAddress region_start, size_t region_num_pages, KMemoryState state,
+                        KMemoryPermission perm);
+    Result MapPageGroup(KProcessAddress address, const KPageGroup& pg, KMemoryState state,
+                        KMemoryPermission perm);
+    Result UnmapPageGroup(KProcessAddress address, const KPageGroup& pg, KMemoryState state);
+    void RemapPageGroup(PageLinkedList* page_list, KProcessAddress address, size_t size,
+                        const KPageGroup& pg);
+
+    KProcessAddress GetRegionAddress(Svc::MemoryState state) const;
+    size_t GetRegionSize(Svc::MemoryState state) const;
+    bool CanContain(KProcessAddress addr, size_t size, Svc::MemoryState state) const;
+
+    KProcessAddress GetRegionAddress(KMemoryState state) const {
+        return this->GetRegionAddress(static_cast<Svc::MemoryState>(state & KMemoryState::Mask));
+    }
+    size_t GetRegionSize(KMemoryState state) const {
+        return this->GetRegionSize(static_cast<Svc::MemoryState>(state & KMemoryState::Mask));
+    }
+    bool CanContain(KProcessAddress addr, size_t size, KMemoryState state) const {
+        return this->CanContain(addr, size,
+                                static_cast<Svc::MemoryState>(state & KMemoryState::Mask));
+    }
+
+protected:
+    struct PageLinkedList {
+    private:
+        struct Node {
+            Node* m_next;
+            std::array<u8, PageSize - sizeof(Node*)> m_buffer;
+        };
+
+    public:
+        constexpr PageLinkedList() = default;
+
+        void Push(Node* n) {
+            ASSERT(Common::IsAligned(reinterpret_cast<uintptr_t>(n), PageSize));
+            n->m_next = m_root;
+            m_root = n;
+        }
+
+        void Push(Core::Memory::Memory& memory, KVirtualAddress addr) {
+            this->Push(memory.GetPointer<Node>(GetInteger(addr)));
+        }
+
+        Node* Peek() const {
+            return m_root;
+        }
+
+        Node* Pop() {
+            Node* const r = m_root;
+
+            m_root = r->m_next;
+            r->m_next = nullptr;
+
+            return r;
+        }
+
+    private:
+        Node* m_root{};
+    };
+    static_assert(std::is_trivially_destructible<PageLinkedList>::value);
+
+private:
+    enum class OperationType : u32 {
+        Map = 0,
+        MapGroup = 1,
+        MapFirstGroup = 2,
+        Unmap = 3,
+        ChangePermissions = 4,
+        ChangePermissionsAndRefresh = 5,
+        ChangePermissionsAndRefreshAndFlush = 6,
+        Separate = 7,
+    };
+
+    static constexpr KMemoryAttribute DefaultMemoryIgnoreAttr =
+        KMemoryAttribute::IpcLocked | KMemoryAttribute::DeviceShared;
+
+    Result MapPages(KProcessAddress* out_addr, size_t num_pages, size_t alignment,
+                    KPhysicalAddress phys_addr, bool is_pa_valid, KProcessAddress region_start,
+                    size_t region_num_pages, KMemoryState state, KMemoryPermission perm);
+    bool IsRegionContiguous(KProcessAddress addr, u64 size) const;
+    void AddRegionToPages(KProcessAddress start, size_t num_pages, KPageGroup& page_linked_list);
+    KMemoryInfo QueryInfoImpl(KProcessAddress addr);
+    KProcessAddress AllocateVirtualMemory(KProcessAddress start, size_t region_num_pages,
+                                          u64 needed_num_pages, size_t align);
+    Result Operate(KProcessAddress addr, size_t num_pages, const KPageGroup& page_group,
+                   OperationType operation);
+    Result Operate(KProcessAddress addr, size_t num_pages, KMemoryPermission perm,
+                   OperationType operation, KPhysicalAddress map_addr = 0);
+    void FinalizeUpdate(PageLinkedList* page_list);
+
+    KProcessAddress FindFreeArea(KProcessAddress region_start, size_t region_num_pages,
+                                 size_t num_pages, size_t alignment, size_t offset,
+                                 size_t guard_pages);
+
+    Result CheckMemoryStateContiguous(size_t* out_blocks_needed, KProcessAddress addr, size_t size,
+                                      KMemoryState state_mask, KMemoryState state,
+                                      KMemoryPermission perm_mask, KMemoryPermission perm,
+                                      KMemoryAttribute attr_mask, KMemoryAttribute attr) const;
+    Result CheckMemoryStateContiguous(KProcessAddress addr, size_t size, KMemoryState state_mask,
+                                      KMemoryState state, KMemoryPermission perm_mask,
+                                      KMemoryPermission perm, KMemoryAttribute attr_mask,
+                                      KMemoryAttribute attr) const {
+        R_RETURN(this->CheckMemoryStateContiguous(nullptr, addr, size, state_mask, state, perm_mask,
+                                                  perm, attr_mask, attr));
+    }
+
+    Result CheckMemoryState(const KMemoryInfo& info, KMemoryState state_mask, KMemoryState state,
+                            KMemoryPermission perm_mask, KMemoryPermission perm,
+                            KMemoryAttribute attr_mask, KMemoryAttribute attr) const;
+    Result CheckMemoryState(KMemoryState* out_state, KMemoryPermission* out_perm,
+                            KMemoryAttribute* out_attr, size_t* out_blocks_needed,
+                            KMemoryBlockManager::const_iterator it, KProcessAddress last_addr,
+                            KMemoryState state_mask, KMemoryState state,
+                            KMemoryPermission perm_mask, KMemoryPermission perm,
+                            KMemoryAttribute attr_mask, KMemoryAttribute attr,
+                            KMemoryAttribute ignore_attr = DefaultMemoryIgnoreAttr) const;
+    Result CheckMemoryState(KMemoryState* out_state, KMemoryPermission* out_perm,
+                            KMemoryAttribute* out_attr, size_t* out_blocks_needed,
+                            KProcessAddress addr, size_t size, KMemoryState state_mask,
+                            KMemoryState state, KMemoryPermission perm_mask, KMemoryPermission perm,
+                            KMemoryAttribute attr_mask, KMemoryAttribute attr,
+                            KMemoryAttribute ignore_attr = DefaultMemoryIgnoreAttr) const;
+    Result CheckMemoryState(size_t* out_blocks_needed, KProcessAddress addr, size_t size,
+                            KMemoryState state_mask, KMemoryState state,
+                            KMemoryPermission perm_mask, KMemoryPermission perm,
+                            KMemoryAttribute attr_mask, KMemoryAttribute attr,
+                            KMemoryAttribute ignore_attr = DefaultMemoryIgnoreAttr) const {
+        R_RETURN(CheckMemoryState(nullptr, nullptr, nullptr, out_blocks_needed, addr, size,
+                                  state_mask, state, perm_mask, perm, attr_mask, attr,
+                                  ignore_attr));
+    }
+    Result CheckMemoryState(KProcessAddress addr, size_t size, KMemoryState state_mask,
+                            KMemoryState state, KMemoryPermission perm_mask, KMemoryPermission perm,
+                            KMemoryAttribute attr_mask, KMemoryAttribute attr,
+                            KMemoryAttribute ignore_attr = DefaultMemoryIgnoreAttr) const {
+        R_RETURN(this->CheckMemoryState(nullptr, addr, size, state_mask, state, perm_mask, perm,
+                                        attr_mask, attr, ignore_attr));
+    }
+
+    Result LockMemoryAndOpen(KPageGroup* out_pg, KPhysicalAddress* out_KPhysicalAddress,
+                             KProcessAddress addr, size_t size, KMemoryState state_mask,
+                             KMemoryState state, KMemoryPermission perm_mask,
+                             KMemoryPermission perm, KMemoryAttribute attr_mask,
+                             KMemoryAttribute attr, KMemoryPermission new_perm,
+                             KMemoryAttribute lock_attr);
+    Result UnlockMemory(KProcessAddress addr, size_t size, KMemoryState state_mask,
+                        KMemoryState state, KMemoryPermission perm_mask, KMemoryPermission perm,
+                        KMemoryAttribute attr_mask, KMemoryAttribute attr,
+                        KMemoryPermission new_perm, KMemoryAttribute lock_attr,
+                        const KPageGroup* pg);
+
+    Result MakePageGroup(KPageGroup& pg, KProcessAddress addr, size_t num_pages);
+    bool IsValidPageGroup(const KPageGroup& pg, KProcessAddress addr, size_t num_pages);
+
+    bool IsLockedByCurrentThread() const {
+        return m_general_lock.IsLockedByCurrentThread();
+    }
+
+    bool IsHeapPhysicalAddress(const KMemoryLayout& layout, KPhysicalAddress phys_addr) {
+        ASSERT(this->IsLockedByCurrentThread());
+
+        return layout.IsHeapPhysicalAddress(m_cached_physical_heap_region, phys_addr);
+    }
+
+    bool GetPhysicalAddressLocked(KPhysicalAddress* out, KProcessAddress virt_addr) const {
+        ASSERT(this->IsLockedByCurrentThread());
+
+        *out = GetPhysicalAddr(virt_addr);
+
+        return *out != 0;
+    }
+
+    Result SetupForIpcClient(PageLinkedList* page_list, size_t* out_blocks_needed,
+                             KProcessAddress address, size_t size, KMemoryPermission test_perm,
+                             KMemoryState dst_state);
+    Result SetupForIpcServer(KProcessAddress* out_addr, size_t size, KProcessAddress src_addr,
+                             KMemoryPermission test_perm, KMemoryState dst_state,
+                             KPageTable& src_page_table, bool send);
+    void CleanupForIpcClientOnServerSetupFailure(PageLinkedList* page_list, KProcessAddress address,
+                                                 size_t size, KMemoryPermission prot_perm);
+
+    Result AllocateAndMapPagesImpl(PageLinkedList* page_list, KProcessAddress address,
+                                   size_t num_pages, KMemoryPermission perm);
+    Result MapPageGroupImpl(PageLinkedList* page_list, KProcessAddress address,
+                            const KPageGroup& pg, const KPageProperties properties, bool reuse_ll);
+
+    mutable KLightLock m_general_lock;
+    mutable KLightLock m_map_physical_memory_lock;
+
+public:
+    constexpr KProcessAddress GetAddressSpaceStart() const {
+        return m_address_space_start;
+    }
+    constexpr KProcessAddress GetAddressSpaceEnd() const {
+        return m_address_space_end;
+    }
+    constexpr size_t GetAddressSpaceSize() const {
+        return m_address_space_end - m_address_space_start;
+    }
+    constexpr KProcessAddress GetHeapRegionStart() const {
+        return m_heap_region_start;
+    }
+    constexpr KProcessAddress GetHeapRegionEnd() const {
+        return m_heap_region_end;
+    }
+    constexpr size_t GetHeapRegionSize() const {
+        return m_heap_region_end - m_heap_region_start;
+    }
+    constexpr KProcessAddress GetAliasRegionStart() const {
+        return m_alias_region_start;
+    }
+    constexpr KProcessAddress GetAliasRegionEnd() const {
+        return m_alias_region_end;
+    }
+    constexpr size_t GetAliasRegionSize() const {
+        return m_alias_region_end - m_alias_region_start;
+    }
+    constexpr KProcessAddress GetStackRegionStart() const {
+        return m_stack_region_start;
+    }
+    constexpr KProcessAddress GetStackRegionEnd() const {
+        return m_stack_region_end;
+    }
+    constexpr size_t GetStackRegionSize() const {
+        return m_stack_region_end - m_stack_region_start;
+    }
+    constexpr KProcessAddress GetKernelMapRegionStart() const {
+        return m_kernel_map_region_start;
+    }
+    constexpr KProcessAddress GetKernelMapRegionEnd() const {
+        return m_kernel_map_region_end;
+    }
+    constexpr KProcessAddress GetCodeRegionStart() const {
+        return m_code_region_start;
+    }
+    constexpr KProcessAddress GetCodeRegionEnd() const {
+        return m_code_region_end;
+    }
+    constexpr KProcessAddress GetAliasCodeRegionStart() const {
+        return m_alias_code_region_start;
+    }
+    constexpr KProcessAddress GetAliasCodeRegionEnd() const {
+        return m_alias_code_region_end;
+    }
+    constexpr size_t GetAliasCodeRegionSize() const {
+        return m_alias_code_region_end - m_alias_code_region_start;
+    }
+    size_t GetNormalMemorySize() const {
+        KScopedLightLock lk(m_general_lock);
+        return GetHeapSize() + m_mapped_physical_memory_size;
+    }
+    constexpr size_t GetAddressSpaceWidth() const {
+        return m_address_space_width;
+    }
+    constexpr size_t GetHeapSize() const {
+        return m_current_heap_end - m_heap_region_start;
+    }
+    constexpr size_t GetNumGuardPages() const {
+        return IsKernel() ? 1 : 4;
+    }
+    KPhysicalAddress GetPhysicalAddr(KProcessAddress addr) const {
+        const auto backing_addr = m_page_table_impl->backing_addr[addr >> PageBits];
+        ASSERT(backing_addr);
+        return backing_addr + GetInteger(addr);
+    }
+    constexpr bool Contains(KProcessAddress addr) const {
+        return m_address_space_start <= addr && addr <= m_address_space_end - 1;
+    }
+    constexpr bool Contains(KProcessAddress addr, size_t size) const {
+        return m_address_space_start <= addr && addr < addr + size &&
+               addr + size - 1 <= m_address_space_end - 1;
+    }
+    constexpr bool IsInAliasRegion(KProcessAddress addr, size_t size) const {
+        return this->Contains(addr, size) && m_alias_region_start <= addr &&
+               addr + size - 1 <= m_alias_region_end - 1;
+    }
+    constexpr bool IsInHeapRegion(KProcessAddress addr, size_t size) const {
+        return this->Contains(addr, size) && m_heap_region_start <= addr &&
+               addr + size - 1 <= m_heap_region_end - 1;
+    }
+
+public:
+    static KVirtualAddress GetLinearMappedVirtualAddress(const KMemoryLayout& layout,
+                                                         KPhysicalAddress addr) {
+        return layout.GetLinearVirtualAddress(addr);
+    }
+
+    static KPhysicalAddress GetLinearMappedPhysicalAddress(const KMemoryLayout& layout,
+                                                           KVirtualAddress addr) {
+        return layout.GetLinearPhysicalAddress(addr);
+    }
+
+    static KVirtualAddress GetHeapVirtualAddress(const KMemoryLayout& layout,
+                                                 KPhysicalAddress addr) {
+        return GetLinearMappedVirtualAddress(layout, addr);
+    }
+
+    static KPhysicalAddress GetHeapPhysicalAddress(const KMemoryLayout& layout,
+                                                   KVirtualAddress addr) {
+        return GetLinearMappedPhysicalAddress(layout, addr);
+    }
+
+    static KVirtualAddress GetPageTableVirtualAddress(const KMemoryLayout& layout,
+                                                      KPhysicalAddress addr) {
+        return GetLinearMappedVirtualAddress(layout, addr);
+    }
+
+    static KPhysicalAddress GetPageTablePhysicalAddress(const KMemoryLayout& layout,
+                                                        KVirtualAddress addr) {
+        return GetLinearMappedPhysicalAddress(layout, addr);
+    }
+
+private:
+    constexpr bool IsKernel() const {
+        return m_is_kernel;
+    }
+    constexpr bool IsAslrEnabled() const {
+        return m_enable_aslr;
+    }
+
+    constexpr bool ContainsPages(KProcessAddress addr, size_t num_pages) const {
+        return (m_address_space_start <= addr) &&
+               (num_pages <= (m_address_space_end - m_address_space_start) / PageSize) &&
+               (addr + num_pages * PageSize - 1 <= m_address_space_end - 1);
+    }
+
+private:
+    class KScopedPageTableUpdater {
+    private:
+        KPageTable* m_pt{};
+        PageLinkedList m_ll;
+
+    public:
+        explicit KScopedPageTableUpdater(KPageTable* pt) : m_pt(pt) {}
+        explicit KScopedPageTableUpdater(KPageTable& pt) : KScopedPageTableUpdater(&pt) {}
+        ~KScopedPageTableUpdater() {
+            m_pt->FinalizeUpdate(this->GetPageList());
+        }
+
+        PageLinkedList* GetPageList() {
+            return std::addressof(m_ll);
+        }
+    };
+
+private:
+    KProcessAddress m_address_space_start{};
+    KProcessAddress m_address_space_end{};
+    KProcessAddress m_heap_region_start{};
+    KProcessAddress m_heap_region_end{};
+    KProcessAddress m_current_heap_end{};
+    KProcessAddress m_alias_region_start{};
+    KProcessAddress m_alias_region_end{};
+    KProcessAddress m_stack_region_start{};
+    KProcessAddress m_stack_region_end{};
+    KProcessAddress m_kernel_map_region_start{};
+    KProcessAddress m_kernel_map_region_end{};
+    KProcessAddress m_code_region_start{};
+    KProcessAddress m_code_region_end{};
+    KProcessAddress m_alias_code_region_start{};
+    KProcessAddress m_alias_code_region_end{};
+
+    size_t m_max_heap_size{};
+    size_t m_mapped_physical_memory_size{};
+    size_t m_mapped_unsafe_physical_memory{};
+    size_t m_mapped_insecure_memory{};
+    size_t m_mapped_ipc_server_memory{};
+    size_t m_address_space_width{};
+
+    KMemoryBlockManager m_memory_block_manager;
+    u32 m_allocate_option{};
+
+    bool m_is_kernel{};
+    bool m_enable_aslr{};
+    bool m_enable_device_address_space_merge{};
+
+    KMemoryBlockSlabManager* m_memory_block_slab_manager{};
+    KBlockInfoManager* m_block_info_manager{};
+    KResourceLimit* m_resource_limit{};
+
+    u32 m_heap_fill_value{};
+    u32 m_ipc_fill_value{};
+    u32 m_stack_fill_value{};
+    const KMemoryRegion* m_cached_physical_heap_region{};
+
+    KMemoryManager::Pool m_memory_pool{KMemoryManager::Pool::Application};
+    KMemoryManager::Direction m_allocation_option{KMemoryManager::Direction::FromFront};
+
+    std::unique_ptr<Common::PageTable> m_page_table_impl;
+
+    Core::System& m_system;
+    KernelCore& m_kernel;
+    Core::Memory::Memory* m_memory{};
 };
 
 } // namespace Kernel

src/core/hle/kernel/k_page_table_base.h

@@ -1,759 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include <memory>
-
-#include "common/common_funcs.h"
-#include "common/page_table.h"
-#include "core/core.h"
-#include "core/hle/kernel/k_dynamic_resource_manager.h"
-#include "core/hle/kernel/k_light_lock.h"
-#include "core/hle/kernel/k_memory_block.h"
-#include "core/hle/kernel/k_memory_block_manager.h"
-#include "core/hle/kernel/k_memory_layout.h"
-#include "core/hle/kernel/k_memory_manager.h"
-#include "core/hle/kernel/k_typed_address.h"
-#include "core/hle/kernel/kernel.h"
-#include "core/hle/result.h"
-#include "core/memory.h"
-
-namespace Kernel {
-
-enum class DisableMergeAttribute : u8 {
-    None = (0U << 0),
-
-    DisableHead = (1U << 0),
-    DisableHeadAndBody = (1U << 1),
-    EnableHeadAndBody = (1U << 2),
-    DisableTail = (1U << 3),
-    EnableTail = (1U << 4),
-    EnableAndMergeHeadBodyTail = (1U << 5),
-
-    EnableHeadBodyTail = EnableHeadAndBody | EnableTail,
-    DisableHeadBodyTail = DisableHeadAndBody | DisableTail,
-};
-DECLARE_ENUM_FLAG_OPERATORS(DisableMergeAttribute);
-
-struct KPageProperties {
-    KMemoryPermission perm;
-    bool io;
-    bool uncached;
-    DisableMergeAttribute disable_merge_attributes;
-};
-static_assert(std::is_trivial_v<KPageProperties>);
-static_assert(sizeof(KPageProperties) == sizeof(u32));
-
-class KResourceLimit;
-class KSystemResource;
-
-class KPageTableBase {
-    YUZU_NON_COPYABLE(KPageTableBase);
-    YUZU_NON_MOVEABLE(KPageTableBase);
-
-public:
-    using TraversalEntry = Common::PageTable::TraversalEntry;
-    using TraversalContext = Common::PageTable::TraversalContext;
-
-    class MemoryRange {
-    private:
-        KernelCore& m_kernel;
-        KPhysicalAddress m_address;
-        size_t m_size;
-        bool m_heap;
-
-    public:
-        explicit MemoryRange(KernelCore& kernel)
-            : m_kernel(kernel), m_address(0), m_size(0), m_heap(false) {}
-
-        void Set(KPhysicalAddress address, size_t size, bool heap) {
-            m_address = address;
-            m_size = size;
-            m_heap = heap;
-        }
-
-        KPhysicalAddress GetAddress() const {
-            return m_address;
-        }
-        size_t GetSize() const {
-            return m_size;
-        }
-        bool IsHeap() const {
-            return m_heap;
-        }
-
-        void Open();
-        void Close();
-    };
-
-protected:
-    enum MemoryFillValue : u8 {
-        MemoryFillValue_Zero = 0,
-        MemoryFillValue_Stack = 'X',
-        MemoryFillValue_Ipc = 'Y',
-        MemoryFillValue_Heap = 'Z',
-    };
-
-    enum class OperationType {
-        Map = 0,
-        MapGroup = 1,
-        MapFirstGroup = 2,
-        Unmap = 3,
-        ChangePermissions = 4,
-        ChangePermissionsAndRefresh = 5,
-        ChangePermissionsAndRefreshAndFlush = 6,
-        Separate = 7,
-    };
-
-    static constexpr size_t MaxPhysicalMapAlignment = 1_GiB;
-    static constexpr size_t RegionAlignment = 2_MiB;
-    static_assert(RegionAlignment == KernelAslrAlignment);
-
-    struct PageLinkedList {
-    private:
-        struct Node {
-            Node* m_next;
-            std::array<u8, PageSize - sizeof(Node*)> m_buffer;
-        };
-        static_assert(std::is_trivial_v<Node>);
-
-    private:
-        Node* m_root{};
-
-    public:
-        constexpr PageLinkedList() : m_root(nullptr) {}
-
-        void Push(Node* n) {
-            ASSERT(Common::IsAligned(reinterpret_cast<uintptr_t>(n), PageSize));
-            n->m_next = m_root;
-            m_root = n;
-        }
-
-        Node* Peek() const {
-            return m_root;
-        }
-
-        Node* Pop() {
-            Node* const r = m_root;
-
-            m_root = r->m_next;
-            r->m_next = nullptr;
-
-            return r;
-        }
-    };
-    static_assert(std::is_trivially_destructible_v<PageLinkedList>);
-
-    static constexpr auto DefaultMemoryIgnoreAttr =
-        KMemoryAttribute::IpcLocked | KMemoryAttribute::DeviceShared;
-
-    static constexpr size_t GetAddressSpaceWidth(Svc::CreateProcessFlag as_type) {
-        switch (static_cast<Svc::CreateProcessFlag>(as_type &
-                                                    Svc::CreateProcessFlag::AddressSpaceMask)) {
-        case Svc::CreateProcessFlag::AddressSpace64Bit:
-            return 39;
-        case Svc::CreateProcessFlag::AddressSpace64BitDeprecated:
-            return 36;
-        case Svc::CreateProcessFlag::AddressSpace32Bit:
-        case Svc::CreateProcessFlag::AddressSpace32BitWithoutAlias:
-            return 32;
-        default:
-            UNREACHABLE();
-        }
-    }
-
-private:
-    class KScopedPageTableUpdater {
-    private:
-        KPageTableBase* m_pt;
-        PageLinkedList m_ll;
-
-    public:
-        explicit KScopedPageTableUpdater(KPageTableBase* pt) : m_pt(pt), m_ll() {}
-        explicit KScopedPageTableUpdater(KPageTableBase& pt)
-            : KScopedPageTableUpdater(std::addressof(pt)) {}
-        ~KScopedPageTableUpdater() {
-            m_pt->FinalizeUpdate(this->GetPageList());
-        }
-
-        PageLinkedList* GetPageList() {
-            return std::addressof(m_ll);
-        }
-    };
-
-private:
-    KernelCore& m_kernel;
-    Core::System& m_system;
-    KProcessAddress m_address_space_start{};
-    KProcessAddress m_address_space_end{};
-    KProcessAddress m_heap_region_start{};
-    KProcessAddress m_heap_region_end{};
-    KProcessAddress m_current_heap_end{};
-    KProcessAddress m_alias_region_start{};
-    KProcessAddress m_alias_region_end{};
-    KProcessAddress m_stack_region_start{};
-    KProcessAddress m_stack_region_end{};
-    KProcessAddress m_kernel_map_region_start{};
-    KProcessAddress m_kernel_map_region_end{};
-    KProcessAddress m_alias_code_region_start{};
-    KProcessAddress m_alias_code_region_end{};
-    KProcessAddress m_code_region_start{};
-    KProcessAddress m_code_region_end{};
-    size_t m_max_heap_size{};
-    size_t m_mapped_physical_memory_size{};
-    size_t m_mapped_unsafe_physical_memory{};
-    size_t m_mapped_insecure_memory{};
-    size_t m_mapped_ipc_server_memory{};
-    mutable KLightLock m_general_lock;
-    mutable KLightLock m_map_physical_memory_lock;
-    KLightLock m_device_map_lock;
-    std::unique_ptr<Common::PageTable> m_impl{};
-    Core::Memory::Memory* m_memory{};
-    KMemoryBlockManager m_memory_block_manager{};
-    u32 m_allocate_option{};
-    u32 m_address_space_width{};
-    bool m_is_kernel{};
-    bool m_enable_aslr{};
-    bool m_enable_device_address_space_merge{};
-    KMemoryBlockSlabManager* m_memory_block_slab_manager{};
-    KBlockInfoManager* m_block_info_manager{};
-    KResourceLimit* m_resource_limit{};
-    const KMemoryRegion* m_cached_physical_linear_region{};
-    const KMemoryRegion* m_cached_physical_heap_region{};
-    MemoryFillValue m_heap_fill_value{};
-    MemoryFillValue m_ipc_fill_value{};
-    MemoryFillValue m_stack_fill_value{};
-
-public:
-    explicit KPageTableBase(KernelCore& kernel);
-    ~KPageTableBase();
-
-    Result InitializeForKernel(bool is_64_bit, KVirtualAddress start, KVirtualAddress end,
-                               Core::Memory::Memory& memory);
-    Result InitializeForProcess(Svc::CreateProcessFlag as_type, bool enable_aslr,
-                                bool enable_device_address_space_merge, bool from_back,
-                                KMemoryManager::Pool pool, KProcessAddress code_address,
-                                size_t code_size, KSystemResource* system_resource,
-                                KResourceLimit* resource_limit, Core::Memory::Memory& memory);
-
-    void Finalize();
-
-    bool IsKernel() const {
-        return m_is_kernel;
-    }
-    bool IsAslrEnabled() const {
-        return m_enable_aslr;
-    }
-
-    bool Contains(KProcessAddress addr) const {
-        return m_address_space_start <= addr && addr <= m_address_space_end - 1;
-    }
-
-    bool Contains(KProcessAddress addr, size_t size) const {
-        return m_address_space_start <= addr && addr < addr + size &&
-               addr + size - 1 <= m_address_space_end - 1;
-    }
-
-    bool IsInAliasRegion(KProcessAddress addr, size_t size) const {
-        return this->Contains(addr, size) && m_alias_region_start <= addr &&
-               addr + size - 1 <= m_alias_region_end - 1;
-    }
-
-    bool IsInHeapRegion(KProcessAddress addr, size_t size) const {
-        return this->Contains(addr, size) && m_heap_region_start <= addr &&
-               addr + size - 1 <= m_heap_region_end - 1;
-    }
-
-    bool IsInUnsafeAliasRegion(KProcessAddress addr, size_t size) const {
-        // Even though Unsafe physical memory is KMemoryState_Normal, it must be mapped inside the
-        // alias code region.
-        return this->CanContain(addr, size, Svc::MemoryState::AliasCode);
-    }
-
-    KScopedLightLock AcquireDeviceMapLock() {
-        return KScopedLightLock(m_device_map_lock);
-    }
-
-    KProcessAddress GetRegionAddress(Svc::MemoryState state) const;
-    size_t GetRegionSize(Svc::MemoryState state) const;
-    bool CanContain(KProcessAddress addr, size_t size, Svc::MemoryState state) const;
-
-    KProcessAddress GetRegionAddress(KMemoryState state) const {
-        return this->GetRegionAddress(static_cast<Svc::MemoryState>(state & KMemoryState::Mask));
-    }
-    size_t GetRegionSize(KMemoryState state) const {
-        return this->GetRegionSize(static_cast<Svc::MemoryState>(state & KMemoryState::Mask));
-    }
-    bool CanContain(KProcessAddress addr, size_t size, KMemoryState state) const {
-        return this->CanContain(addr, size,
-                                static_cast<Svc::MemoryState>(state & KMemoryState::Mask));
-    }
-
-public:
-    Core::Memory::Memory& GetMemory() {
-        return *m_memory;
-    }
-
-    Core::Memory::Memory& GetMemory() const {
-        return *m_memory;
-    }
-
-    Common::PageTable& GetImpl() {
-        return *m_impl;
-    }
-
-    Common::PageTable& GetImpl() const {
-        return *m_impl;
-    }
-
-    size_t GetNumGuardPages() const {
-        return this->IsKernel() ? 1 : 4;
-    }
-
-protected:
-    // NOTE: These three functions (Operate, Operate, FinalizeUpdate) are virtual functions
-    // in Nintendo's kernel. We devirtualize them, since KPageTable is the only derived
-    // class, and this avoids unnecessary virtual function calls.
-    Result Operate(PageLinkedList* page_list, KProcessAddress virt_addr, size_t num_pages,
-                   KPhysicalAddress phys_addr, bool is_pa_valid, const KPageProperties properties,
-                   OperationType operation, bool reuse_ll);
-    Result Operate(PageLinkedList* page_list, KProcessAddress virt_addr, size_t num_pages,
-                   const KPageGroup& page_group, const KPageProperties properties,
-                   OperationType operation, bool reuse_ll);
-    void FinalizeUpdate(PageLinkedList* page_list);
-
-    bool IsLockedByCurrentThread() const {
-        return m_general_lock.IsLockedByCurrentThread();
-    }
-
-    bool IsLinearMappedPhysicalAddress(KPhysicalAddress phys_addr) {
-        ASSERT(this->IsLockedByCurrentThread());
-
-        return m_kernel.MemoryLayout().IsLinearMappedPhysicalAddress(
-            m_cached_physical_linear_region, phys_addr);
-    }
-
-    bool IsLinearMappedPhysicalAddress(KPhysicalAddress phys_addr, size_t size) {
-        ASSERT(this->IsLockedByCurrentThread());
-
-        return m_kernel.MemoryLayout().IsLinearMappedPhysicalAddress(
-            m_cached_physical_linear_region, phys_addr, size);
-    }
-
-    bool IsHeapPhysicalAddress(KPhysicalAddress phys_addr) {
-        ASSERT(this->IsLockedByCurrentThread());
-
-        return m_kernel.MemoryLayout().IsHeapPhysicalAddress(m_cached_physical_heap_region,
-                                                             phys_addr);
-    }
-
-    bool IsHeapPhysicalAddress(KPhysicalAddress phys_addr, size_t size) {
-        ASSERT(this->IsLockedByCurrentThread());
-
-        return m_kernel.MemoryLayout().IsHeapPhysicalAddress(m_cached_physical_heap_region,
-                                                             phys_addr, size);
-    }
-
-    bool IsHeapPhysicalAddressForFinalize(KPhysicalAddress phys_addr) {
-        ASSERT(!this->IsLockedByCurrentThread());
-
-        return m_kernel.MemoryLayout().IsHeapPhysicalAddress(m_cached_physical_heap_region,
-                                                             phys_addr);
-    }
-
-    bool ContainsPages(KProcessAddress addr, size_t num_pages) const {
-        return (m_address_space_start <= addr) &&
-               (num_pages <= (m_address_space_end - m_address_space_start) / PageSize) &&
-               (addr + num_pages * PageSize - 1 <= m_address_space_end - 1);
-    }
-
-private:
-    KProcessAddress FindFreeArea(KProcessAddress region_start, size_t region_num_pages,
-                                 size_t num_pages, size_t alignment, size_t offset,
-                                 size_t guard_pages) const;
-
-    Result CheckMemoryStateContiguous(size_t* out_blocks_needed, KProcessAddress addr, size_t size,
-                                      KMemoryState state_mask, KMemoryState state,
-                                      KMemoryPermission perm_mask, KMemoryPermission perm,
-                                      KMemoryAttribute attr_mask, KMemoryAttribute attr) const;
-    Result CheckMemoryStateContiguous(KProcessAddress addr, size_t size, KMemoryState state_mask,
-                                      KMemoryState state, KMemoryPermission perm_mask,
-                                      KMemoryPermission perm, KMemoryAttribute attr_mask,
-                                      KMemoryAttribute attr) const {
-        R_RETURN(this->CheckMemoryStateContiguous(nullptr, addr, size, state_mask, state, perm_mask,
-                                                  perm, attr_mask, attr));
-    }
-
-    Result CheckMemoryState(const KMemoryInfo& info, KMemoryState state_mask, KMemoryState state,
-                            KMemoryPermission perm_mask, KMemoryPermission perm,
-                            KMemoryAttribute attr_mask, KMemoryAttribute attr) const;
-    Result CheckMemoryState(KMemoryState* out_state, KMemoryPermission* out_perm,
-                            KMemoryAttribute* out_attr, size_t* out_blocks_needed,
-                            KMemoryBlockManager::const_iterator it, KProcessAddress last_addr,
-                            KMemoryState state_mask, KMemoryState state,
-                            KMemoryPermission perm_mask, KMemoryPermission perm,
-                            KMemoryAttribute attr_mask, KMemoryAttribute attr,
-                            KMemoryAttribute ignore_attr = DefaultMemoryIgnoreAttr) const;
-    Result CheckMemoryState(KMemoryState* out_state, KMemoryPermission* out_perm,
-                            KMemoryAttribute* out_attr, size_t* out_blocks_needed,
-                            KProcessAddress addr, size_t size, KMemoryState state_mask,
-                            KMemoryState state, KMemoryPermission perm_mask, KMemoryPermission perm,
-                            KMemoryAttribute attr_mask, KMemoryAttribute attr,
-                            KMemoryAttribute ignore_attr = DefaultMemoryIgnoreAttr) const;
-    Result CheckMemoryState(size_t* out_blocks_needed, KProcessAddress addr, size_t size,
-                            KMemoryState state_mask, KMemoryState state,
-                            KMemoryPermission perm_mask, KMemoryPermission perm,
-                            KMemoryAttribute attr_mask, KMemoryAttribute attr,
-                            KMemoryAttribute ignore_attr = DefaultMemoryIgnoreAttr) const {
-        R_RETURN(this->CheckMemoryState(nullptr, nullptr, nullptr, out_blocks_needed, addr, size,
-                                        state_mask, state, perm_mask, perm, attr_mask, attr,
-                                        ignore_attr));
-    }
-    Result CheckMemoryState(KProcessAddress addr, size_t size, KMemoryState state_mask,
-                            KMemoryState state, KMemoryPermission perm_mask, KMemoryPermission perm,
-                            KMemoryAttribute attr_mask, KMemoryAttribute attr,
-                            KMemoryAttribute ignore_attr = DefaultMemoryIgnoreAttr) const {
-        R_RETURN(this->CheckMemoryState(nullptr, addr, size, state_mask, state, perm_mask, perm,
-                                        attr_mask, attr, ignore_attr));
-    }
-
-    Result LockMemoryAndOpen(KPageGroup* out_pg, KPhysicalAddress* out_paddr, KProcessAddress addr,
-                             size_t size, KMemoryState state_mask, KMemoryState state,
-                             KMemoryPermission perm_mask, KMemoryPermission perm,
-                             KMemoryAttribute attr_mask, KMemoryAttribute attr,
-                             KMemoryPermission new_perm, KMemoryAttribute lock_attr);
-    Result UnlockMemory(KProcessAddress addr, size_t size, KMemoryState state_mask,
-                        KMemoryState state, KMemoryPermission perm_mask, KMemoryPermission perm,
-                        KMemoryAttribute attr_mask, KMemoryAttribute attr,
-                        KMemoryPermission new_perm, KMemoryAttribute lock_attr,
-                        const KPageGroup* pg);
-
-    Result QueryInfoImpl(KMemoryInfo* out_info, Svc::PageInfo* out_page,
-                         KProcessAddress address) const;
-
-    Result QueryMappingImpl(KProcessAddress* out, KPhysicalAddress address, size_t size,
-                            Svc::MemoryState state) const;
-
-    Result AllocateAndMapPagesImpl(PageLinkedList* page_list, KProcessAddress address,
-                                   size_t num_pages, KMemoryPermission perm);
-    Result MapPageGroupImpl(PageLinkedList* page_list, KProcessAddress address,
-                            const KPageGroup& pg, const KPageProperties properties, bool reuse_ll);
-
-    void RemapPageGroup(PageLinkedList* page_list, KProcessAddress address, size_t size,
-                        const KPageGroup& pg);
-
-    Result MakePageGroup(KPageGroup& pg, KProcessAddress addr, size_t num_pages);
-    bool IsValidPageGroup(const KPageGroup& pg, KProcessAddress addr, size_t num_pages);
-
-    Result GetContiguousMemoryRangeWithState(MemoryRange* out, KProcessAddress address, size_t size,
-                                             KMemoryState state_mask, KMemoryState state,
-                                             KMemoryPermission perm_mask, KMemoryPermission perm,
-                                             KMemoryAttribute attr_mask, KMemoryAttribute attr);
-
-    Result MapPages(KProcessAddress* out_addr, size_t num_pages, size_t alignment,
-                    KPhysicalAddress phys_addr, bool is_pa_valid, KProcessAddress region_start,
-                    size_t region_num_pages, KMemoryState state, KMemoryPermission perm);
-
-    Result MapIoImpl(KProcessAddress* out, PageLinkedList* page_list, KPhysicalAddress phys_addr,
-                     size_t size, KMemoryState state, KMemoryPermission perm);
-    Result ReadIoMemoryImpl(KProcessAddress dst_addr, KPhysicalAddress phys_addr, size_t size,
-                            KMemoryState state);
-    Result WriteIoMemoryImpl(KPhysicalAddress phys_addr, KProcessAddress src_addr, size_t size,
-                             KMemoryState state);
-
-    Result SetupForIpcClient(PageLinkedList* page_list, size_t* out_blocks_needed,
-                             KProcessAddress address, size_t size, KMemoryPermission test_perm,
-                             KMemoryState dst_state);
-    Result SetupForIpcServer(KProcessAddress* out_addr, size_t size, KProcessAddress src_addr,
-                             KMemoryPermission test_perm, KMemoryState dst_state,
-                             KPageTableBase& src_page_table, bool send);
-    void CleanupForIpcClientOnServerSetupFailure(PageLinkedList* page_list, KProcessAddress address,
-                                                 size_t size, KMemoryPermission prot_perm);
-
-    size_t GetSize(KMemoryState state) const;
-
-    bool GetPhysicalAddressLocked(KPhysicalAddress* out, KProcessAddress virt_addr) const {
-        // Validate pre-conditions.
-        ASSERT(this->IsLockedByCurrentThread());
-
-        return this->GetImpl().GetPhysicalAddress(out, virt_addr);
-    }
-
-public:
-    bool GetPhysicalAddress(KPhysicalAddress* out, KProcessAddress virt_addr) const {
-        // Validate pre-conditions.
-        ASSERT(!this->IsLockedByCurrentThread());
-
-        // Acquire exclusive access to the table while doing address translation.
-        KScopedLightLock lk(m_general_lock);
-
-        return this->GetPhysicalAddressLocked(out, virt_addr);
-    }
-
-    KBlockInfoManager* GetBlockInfoManager() const {
-        return m_block_info_manager;
-    }
-
-    Result SetMemoryPermission(KProcessAddress addr, size_t size, Svc::MemoryPermission perm);
-    Result SetProcessMemoryPermission(KProcessAddress addr, size_t size,
-                                      Svc::MemoryPermission perm);
-    Result SetMemoryAttribute(KProcessAddress addr, size_t size, KMemoryAttribute mask,
-                              KMemoryAttribute attr);
-    Result SetHeapSize(KProcessAddress* out, size_t size);
-    Result SetMaxHeapSize(size_t size);
-    Result QueryInfo(KMemoryInfo* out_info, Svc::PageInfo* out_page_info,
-                     KProcessAddress addr) const;
-    Result QueryPhysicalAddress(Svc::lp64::PhysicalMemoryInfo* out, KProcessAddress address) const;
-    Result QueryStaticMapping(KProcessAddress* out, KPhysicalAddress address, size_t size) const {
-        R_RETURN(this->QueryMappingImpl(out, address, size, Svc::MemoryState::Static));
-    }
-    Result QueryIoMapping(KProcessAddress* out, KPhysicalAddress address, size_t size) const {
-        R_RETURN(this->QueryMappingImpl(out, address, size, Svc::MemoryState::Io));
-    }
-    Result MapMemory(KProcessAddress dst_address, KProcessAddress src_address, size_t size);
-    Result UnmapMemory(KProcessAddress dst_address, KProcessAddress src_address, size_t size);
-    Result MapCodeMemory(KProcessAddress dst_address, KProcessAddress src_address, size_t size);
-    Result UnmapCodeMemory(KProcessAddress dst_address, KProcessAddress src_address, size_t size);
-    Result MapIo(KPhysicalAddress phys_addr, size_t size, KMemoryPermission perm);
-    Result MapIoRegion(KProcessAddress dst_address, KPhysicalAddress phys_addr, size_t size,
-                       Svc::MemoryMapping mapping, Svc::MemoryPermission perm);
-    Result UnmapIoRegion(KProcessAddress dst_address, KPhysicalAddress phys_addr, size_t size,
-                         Svc::MemoryMapping mapping);
-    Result MapStatic(KPhysicalAddress phys_addr, size_t size, KMemoryPermission perm);
-    Result MapRegion(KMemoryRegionType region_type, KMemoryPermission perm);
-    Result MapInsecureMemory(KProcessAddress address, size_t size);
-    Result UnmapInsecureMemory(KProcessAddress address, size_t size);
-
-    Result MapPages(KProcessAddress* out_addr, size_t num_pages, size_t alignment,
-                    KPhysicalAddress phys_addr, KProcessAddress region_start,
-                    size_t region_num_pages, KMemoryState state, KMemoryPermission perm) {
-        R_RETURN(this->MapPages(out_addr, num_pages, alignment, phys_addr, true, region_start,
-                                region_num_pages, state, perm));
-    }
-
-    Result MapPages(KProcessAddress* out_addr, size_t num_pages, size_t alignment,
-                    KPhysicalAddress phys_addr, KMemoryState state, KMemoryPermission perm) {
-        R_RETURN(this->MapPages(out_addr, num_pages, alignment, phys_addr, true,
-                                this->GetRegionAddress(state),
-                                this->GetRegionSize(state) / PageSize, state, perm));
-    }
-
-    Result MapPages(KProcessAddress* out_addr, size_t num_pages, KMemoryState state,
-                    KMemoryPermission perm) {
-        R_RETURN(this->MapPages(out_addr, num_pages, PageSize, 0, false,
-                                this->GetRegionAddress(state),
-                                this->GetRegionSize(state) / PageSize, state, perm));
-    }
-
-    Result MapPages(KProcessAddress address, size_t num_pages, KMemoryState state,
-                    KMemoryPermission perm);
-    Result UnmapPages(KProcessAddress address, size_t num_pages, KMemoryState state);
-
-    Result MapPageGroup(KProcessAddress* out_addr, const KPageGroup& pg,
-                        KProcessAddress region_start, size_t region_num_pages, KMemoryState state,
-                        KMemoryPermission perm);
-    Result MapPageGroup(KProcessAddress address, const KPageGroup& pg, KMemoryState state,
-                        KMemoryPermission perm);
-    Result UnmapPageGroup(KProcessAddress address, const KPageGroup& pg, KMemoryState state);
-
-    Result MakeAndOpenPageGroup(KPageGroup* out, KProcessAddress address, size_t num_pages,
-                                KMemoryState state_mask, KMemoryState state,
-                                KMemoryPermission perm_mask, KMemoryPermission perm,
-                                KMemoryAttribute attr_mask, KMemoryAttribute attr);
-
-    Result InvalidateProcessDataCache(KProcessAddress address, size_t size);
-    Result InvalidateCurrentProcessDataCache(KProcessAddress address, size_t size);
-
-    Result ReadDebugMemory(KProcessAddress dst_address, KProcessAddress src_address, size_t size);
-    Result ReadDebugIoMemory(KProcessAddress dst_address, KProcessAddress src_address, size_t size,
-                             KMemoryState state);
-
-    Result WriteDebugMemory(KProcessAddress dst_address, KProcessAddress src_address, size_t size);
-    Result WriteDebugIoMemory(KProcessAddress dst_address, KProcessAddress src_address, size_t size,
-                              KMemoryState state);
-
-    Result LockForMapDeviceAddressSpace(bool* out_is_io, KProcessAddress address, size_t size,
-                                        KMemoryPermission perm, bool is_aligned, bool check_heap);
-    Result LockForUnmapDeviceAddressSpace(KProcessAddress address, size_t size, bool check_heap);
-
-    Result UnlockForDeviceAddressSpace(KProcessAddress address, size_t size);
-    Result UnlockForDeviceAddressSpacePartialMap(KProcessAddress address, size_t size);
-
-    Result OpenMemoryRangeForMapDeviceAddressSpace(KPageTableBase::MemoryRange* out,
-                                                   KProcessAddress address, size_t size,
-                                                   KMemoryPermission perm, bool is_aligned);
-    Result OpenMemoryRangeForUnmapDeviceAddressSpace(MemoryRange* out, KProcessAddress address,
-                                                     size_t size);
-
-    Result LockForIpcUserBuffer(KPhysicalAddress* out, KProcessAddress address, size_t size);
-    Result UnlockForIpcUserBuffer(KProcessAddress address, size_t size);
-
-    Result LockForTransferMemory(KPageGroup* out, KProcessAddress address, size_t size,
-                                 KMemoryPermission perm);
-    Result UnlockForTransferMemory(KProcessAddress address, size_t size, const KPageGroup& pg);
-    Result LockForCodeMemory(KPageGroup* out, KProcessAddress address, size_t size);
-    Result UnlockForCodeMemory(KProcessAddress address, size_t size, const KPageGroup& pg);
-
-    Result OpenMemoryRangeForProcessCacheOperation(MemoryRange* out, KProcessAddress address,
-                                                   size_t size);
-
-    Result CopyMemoryFromLinearToUser(KProcessAddress dst_addr, size_t size,
-                                      KProcessAddress src_addr, KMemoryState src_state_mask,
-                                      KMemoryState src_state, KMemoryPermission src_test_perm,
-                                      KMemoryAttribute src_attr_mask, KMemoryAttribute src_attr);
-    Result CopyMemoryFromLinearToKernel(void* buffer, size_t size, KProcessAddress src_addr,
-                                        KMemoryState src_state_mask, KMemoryState src_state,
-                                        KMemoryPermission src_test_perm,
-                                        KMemoryAttribute src_attr_mask, KMemoryAttribute src_attr);
-    Result CopyMemoryFromUserToLinear(KProcessAddress dst_addr, size_t size,
-                                      KMemoryState dst_state_mask, KMemoryState dst_state,
-                                      KMemoryPermission dst_test_perm,
-                                      KMemoryAttribute dst_attr_mask, KMemoryAttribute dst_attr,
-                                      KProcessAddress src_addr);
-    Result CopyMemoryFromKernelToLinear(KProcessAddress dst_addr, size_t size,
-                                        KMemoryState dst_state_mask, KMemoryState dst_state,
-                                        KMemoryPermission dst_test_perm,
-                                        KMemoryAttribute dst_attr_mask, KMemoryAttribute dst_attr,
-                                        void* buffer);
-    Result CopyMemoryFromHeapToHeap(KPageTableBase& dst_page_table, KProcessAddress dst_addr,
-                                    size_t size, KMemoryState dst_state_mask,
-                                    KMemoryState dst_state, KMemoryPermission dst_test_perm,
-                                    KMemoryAttribute dst_attr_mask, KMemoryAttribute dst_attr,
-                                    KProcessAddress src_addr, KMemoryState src_state_mask,
-                                    KMemoryState src_state, KMemoryPermission src_test_perm,
-                                    KMemoryAttribute src_attr_mask, KMemoryAttribute src_attr);
-    Result CopyMemoryFromHeapToHeapWithoutCheckDestination(
-        KPageTableBase& dst_page_table, KProcessAddress dst_addr, size_t size,
-        KMemoryState dst_state_mask, KMemoryState dst_state, KMemoryPermission dst_test_perm,
-        KMemoryAttribute dst_attr_mask, KMemoryAttribute dst_attr, KProcessAddress src_addr,
-        KMemoryState src_state_mask, KMemoryState src_state, KMemoryPermission src_test_perm,
-        KMemoryAttribute src_attr_mask, KMemoryAttribute src_attr);
-
-    Result SetupForIpc(KProcessAddress* out_dst_addr, size_t size, KProcessAddress src_addr,
-                       KPageTableBase& src_page_table, KMemoryPermission test_perm,
-                       KMemoryState dst_state, bool send);
-    Result CleanupForIpcServer(KProcessAddress address, size_t size, KMemoryState dst_state);
-    Result CleanupForIpcClient(KProcessAddress address, size_t size, KMemoryState dst_state);
-
-    Result MapPhysicalMemory(KProcessAddress address, size_t size);
-    Result UnmapPhysicalMemory(KProcessAddress address, size_t size);
-
-    Result MapPhysicalMemoryUnsafe(KProcessAddress address, size_t size);
-    Result UnmapPhysicalMemoryUnsafe(KProcessAddress address, size_t size);
-
-    Result UnmapProcessMemory(KProcessAddress dst_address, size_t size, KPageTableBase& src_pt,
-                              KProcessAddress src_address);
-
-public:
-    KProcessAddress GetAddressSpaceStart() const {
-        return m_address_space_start;
-    }
-    KProcessAddress GetHeapRegionStart() const {
-        return m_heap_region_start;
-    }
-    KProcessAddress GetAliasRegionStart() const {
-        return m_alias_region_start;
-    }
-    KProcessAddress GetStackRegionStart() const {
-        return m_stack_region_start;
-    }
-    KProcessAddress GetKernelMapRegionStart() const {
-        return m_kernel_map_region_start;
-    }
-    KProcessAddress GetCodeRegionStart() const {
-        return m_code_region_start;
-    }
-    KProcessAddress GetAliasCodeRegionStart() const {
-        return m_alias_code_region_start;
-    }
-
-    size_t GetAddressSpaceSize() const {
-        return m_address_space_end - m_address_space_start;
-    }
-    size_t GetHeapRegionSize() const {
-        return m_heap_region_end - m_heap_region_start;
-    }
-    size_t GetAliasRegionSize() const {
-        return m_alias_region_end - m_alias_region_start;
-    }
-    size_t GetStackRegionSize() const {
-        return m_stack_region_end - m_stack_region_start;
-    }
-    size_t GetKernelMapRegionSize() const {
-        return m_kernel_map_region_end - m_kernel_map_region_start;
-    }
-    size_t GetCodeRegionSize() const {
-        return m_code_region_end - m_code_region_start;
-    }
-    size_t GetAliasCodeRegionSize() const {
-        return m_alias_code_region_end - m_alias_code_region_start;
-    }
-
-    size_t GetNormalMemorySize() const {
-        // Lock the table.
-        KScopedLightLock lk(m_general_lock);
-
-        return (m_current_heap_end - m_heap_region_start) + m_mapped_physical_memory_size;
-    }
-
-    size_t GetCodeSize() const;
-    size_t GetCodeDataSize() const;
-    size_t GetAliasCodeSize() const;
-    size_t GetAliasCodeDataSize() const;
-
-    u32 GetAllocateOption() const {
-        return m_allocate_option;
-    }
-
-    u32 GetAddressSpaceWidth() const {
-        return m_address_space_width;
-    }
-
-public:
-    // Linear mapped
-    static u8* GetLinearMappedVirtualPointer(KernelCore& kernel, KPhysicalAddress addr) {
-        return kernel.System().DeviceMemory().GetPointer<u8>(addr);
-    }
-
-    static KPhysicalAddress GetLinearMappedPhysicalAddress(KernelCore& kernel,
-                                                           KVirtualAddress addr) {
-        return kernel.MemoryLayout().GetLinearPhysicalAddress(addr);
-    }
-
-    static KVirtualAddress GetLinearMappedVirtualAddress(KernelCore& kernel,
-                                                         KPhysicalAddress addr) {
-        return kernel.MemoryLayout().GetLinearVirtualAddress(addr);
-    }
-
-    // Heap
-    static u8* GetHeapVirtualPointer(KernelCore& kernel, KPhysicalAddress addr) {
-        return kernel.System().DeviceMemory().GetPointer<u8>(addr);
-    }
-
-    static KPhysicalAddress GetHeapPhysicalAddress(KernelCore& kernel, KVirtualAddress addr) {
-        return GetLinearMappedPhysicalAddress(kernel, addr);
-    }
-
-    static KVirtualAddress GetHeapVirtualAddress(KernelCore& kernel, KPhysicalAddress addr) {
-        return GetLinearMappedVirtualAddress(kernel, addr);
-    }
-
-    // Member heap
-    u8* GetHeapVirtualPointer(KPhysicalAddress addr) {
-        return GetHeapVirtualPointer(m_kernel, addr);
-    }
-
-    KPhysicalAddress GetHeapPhysicalAddress(KVirtualAddress addr) {
-        return GetHeapPhysicalAddress(m_kernel, addr);
-    }
-
-    KVirtualAddress GetHeapVirtualAddress(KPhysicalAddress addr) {
-        return GetHeapVirtualAddress(m_kernel, addr);
-    }
-
-    // TODO: GetPageTableVirtualAddress
-    // TODO: GetPageTablePhysicalAddress
-};
-
-} // namespace Kernel

src/core/hle/kernel/k_process.cpp

@@ -298,9 +298,9 @@ Result KProcess::Initialize(const Svc::CreateProcessParameter& params, const KPa
         const bool enable_aslr = True(params.flags & Svc::CreateProcessFlag::EnableAslr);
         const bool enable_das_merge =
             False(params.flags & Svc::CreateProcessFlag::DisableDeviceAddressSpaceMerge);
-        R_TRY(m_page_table.Initialize(as_type, enable_aslr, enable_das_merge, !enable_aslr, pool,
-                                      params.code_address, params.code_num_pages * PageSize,
-                                      m_system_resource, res_limit, this->GetMemory()));
+        R_TRY(m_page_table.InitializeForProcess(
+            as_type, enable_aslr, enable_das_merge, !enable_aslr, pool, params.code_address,
+            params.code_num_pages * PageSize, m_system_resource, res_limit, this->GetMemory()));
     }
     ON_RESULT_FAILURE_2 {
         m_page_table.Finalize();
@@ -391,9 +391,9 @@ Result KProcess::Initialize(const Svc::CreateProcessParameter& params,
         const bool enable_aslr = True(params.flags & Svc::CreateProcessFlag::EnableAslr);
         const bool enable_das_merge =
             False(params.flags & Svc::CreateProcessFlag::DisableDeviceAddressSpaceMerge);
-        R_TRY(m_page_table.Initialize(as_type, enable_aslr, enable_das_merge, !enable_aslr, pool,
-                                      params.code_address, code_size, m_system_resource, res_limit,
-                                      this->GetMemory()));
+        R_TRY(m_page_table.InitializeForProcess(as_type, enable_aslr, enable_das_merge,
+                                                !enable_aslr, pool, params.code_address, code_size,
+                                                m_system_resource, res_limit, this->GetMemory()));
     }
     ON_RESULT_FAILURE_2 {
         m_page_table.Finalize();
@@ -1122,9 +1122,9 @@ Result KProcess::GetThreadList(s32* out_num_threads, KProcessAddress out_thread_
 void KProcess::Switch(KProcess* cur_process, KProcess* next_process) {}
 
 KProcess::KProcess(KernelCore& kernel)
-    : KAutoObjectWithSlabHeapAndContainer(kernel), m_page_table{kernel}, m_state_lock{kernel},
-      m_list_lock{kernel}, m_cond_var{kernel.System()}, m_address_arbiter{kernel.System()},
-      m_handle_table{kernel} {}
+    : KAutoObjectWithSlabHeapAndContainer(kernel), m_page_table{kernel.System()},
+      m_state_lock{kernel}, m_list_lock{kernel}, m_cond_var{kernel.System()},
+      m_address_arbiter{kernel.System()}, m_handle_table{kernel} {}
 KProcess::~KProcess() = default;
 
 Result KProcess::LoadFromMetadata(const FileSys::ProgramMetadata& metadata, std::size_t code_size,

src/core/hle/kernel/k_process.h

@@ -5,14 +5,13 @@
 
 #include <map>
 
-#include "core/file_sys/program_metadata.h"
 #include "core/hle/kernel/code_set.h"
 #include "core/hle/kernel/k_address_arbiter.h"
 #include "core/hle/kernel/k_capabilities.h"
 #include "core/hle/kernel/k_condition_variable.h"
 #include "core/hle/kernel/k_handle_table.h"
+#include "core/hle/kernel/k_page_table.h"
 #include "core/hle/kernel/k_page_table_manager.h"
-#include "core/hle/kernel/k_process_page_table.h"
 #include "core/hle/kernel/k_system_resource.h"
 #include "core/hle/kernel/k_thread.h"
 #include "core/hle/kernel/k_thread_local_page.h"
@@ -66,7 +65,7 @@ private:
     using TLPIterator = TLPTree::iterator;
 
 private:
-    KProcessPageTable m_page_table;
+    KPageTable m_page_table;
     std::atomic<size_t> m_used_kernel_memory_size{};
     TLPTree m_fully_used_tlp_tree{};
     TLPTree m_partially_used_tlp_tree{};
@@ -255,8 +254,9 @@ public:
         return m_is_hbl;
     }
 
-    u32 GetAllocateOption() const {
-        return m_page_table.GetAllocateOption();
+    Kernel::KMemoryManager::Direction GetAllocateOption() const {
+        // TODO: property of the KPageTableBase
+        return KMemoryManager::Direction::FromFront;
     }
 
     ThreadList& GetThreadList() {
@@ -295,10 +295,10 @@ public:
         return m_list_lock;
     }
 
-    KProcessPageTable& GetPageTable() {
+    KPageTable& GetPageTable() {
         return m_page_table;
     }
-    const KProcessPageTable& GetPageTable() const {
+    const KPageTable& GetPageTable() const {
         return m_page_table;
     }
 

src/core/hle/kernel/k_process_page_table.h

@@ -1,480 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include "core/hle/kernel/k_page_table.h"
-#include "core/hle/kernel/k_scoped_lock.h"
-#include "core/hle/kernel/svc_types.h"
-
-namespace Core {
-class ARM_Interface;
-}
-
-namespace Kernel {
-
-class KProcessPageTable {
-private:
-    KPageTable m_page_table;
-
-public:
-    KProcessPageTable(KernelCore& kernel) : m_page_table(kernel) {}
-
-    Result Initialize(Svc::CreateProcessFlag as_type, bool enable_aslr, bool enable_das_merge,
-                      bool from_back, KMemoryManager::Pool pool, KProcessAddress code_address,
-                      size_t code_size, KSystemResource* system_resource,
-                      KResourceLimit* resource_limit, Core::Memory::Memory& memory) {
-        R_RETURN(m_page_table.InitializeForProcess(as_type, enable_aslr, enable_das_merge,
-                                                   from_back, pool, code_address, code_size,
-                                                   system_resource, resource_limit, memory));
-    }
-
-    void Finalize() {
-        m_page_table.Finalize();
-    }
-
-    Core::Memory::Memory& GetMemory() {
-        return m_page_table.GetMemory();
-    }
-
-    Core::Memory::Memory& GetMemory() const {
-        return m_page_table.GetMemory();
-    }
-
-    Common::PageTable& GetImpl() {
-        return m_page_table.GetImpl();
-    }
-
-    Common::PageTable& GetImpl() const {
-        return m_page_table.GetImpl();
-    }
-
-    size_t GetNumGuardPages() const {
-        return m_page_table.GetNumGuardPages();
-    }
-
-    KScopedLightLock AcquireDeviceMapLock() {
-        return m_page_table.AcquireDeviceMapLock();
-    }
-
-    Result SetMemoryPermission(KProcessAddress addr, size_t size, Svc::MemoryPermission perm) {
-        R_RETURN(m_page_table.SetMemoryPermission(addr, size, perm));
-    }
-
-    Result SetProcessMemoryPermission(KProcessAddress addr, size_t size,
-                                      Svc::MemoryPermission perm) {
-        R_RETURN(m_page_table.SetProcessMemoryPermission(addr, size, perm));
-    }
-
-    Result SetMemoryAttribute(KProcessAddress addr, size_t size, KMemoryAttribute mask,
-                              KMemoryAttribute attr) {
-        R_RETURN(m_page_table.SetMemoryAttribute(addr, size, mask, attr));
-    }
-
-    Result SetHeapSize(KProcessAddress* out, size_t size) {
-        R_RETURN(m_page_table.SetHeapSize(out, size));
-    }
-
-    Result SetMaxHeapSize(size_t size) {
-        R_RETURN(m_page_table.SetMaxHeapSize(size));
-    }
-
-    Result QueryInfo(KMemoryInfo* out_info, Svc::PageInfo* out_page_info,
-                     KProcessAddress addr) const {
-        R_RETURN(m_page_table.QueryInfo(out_info, out_page_info, addr));
-    }
-
-    Result QueryPhysicalAddress(Svc::lp64::PhysicalMemoryInfo* out, KProcessAddress address) {
-        R_RETURN(m_page_table.QueryPhysicalAddress(out, address));
-    }
-
-    Result QueryStaticMapping(KProcessAddress* out, KPhysicalAddress address, size_t size) {
-        R_RETURN(m_page_table.QueryStaticMapping(out, address, size));
-    }
-
-    Result QueryIoMapping(KProcessAddress* out, KPhysicalAddress address, size_t size) {
-        R_RETURN(m_page_table.QueryIoMapping(out, address, size));
-    }
-
-    Result MapMemory(KProcessAddress dst_address, KProcessAddress src_address, size_t size) {
-        R_RETURN(m_page_table.MapMemory(dst_address, src_address, size));
-    }
-
-    Result UnmapMemory(KProcessAddress dst_address, KProcessAddress src_address, size_t size) {
-        R_RETURN(m_page_table.UnmapMemory(dst_address, src_address, size));
-    }
-
-    Result MapCodeMemory(KProcessAddress dst_address, KProcessAddress src_address, size_t size) {
-        R_RETURN(m_page_table.MapCodeMemory(dst_address, src_address, size));
-    }
-
-    Result UnmapCodeMemory(KProcessAddress dst_address, KProcessAddress src_address, size_t size) {
-        R_RETURN(m_page_table.UnmapCodeMemory(dst_address, src_address, size));
-    }
-
-    Result MapIo(KPhysicalAddress phys_addr, size_t size, KMemoryPermission perm) {
-        R_RETURN(m_page_table.MapIo(phys_addr, size, perm));
-    }
-
-    Result MapIoRegion(KProcessAddress dst_address, KPhysicalAddress phys_addr, size_t size,
-                       Svc::MemoryMapping mapping, Svc::MemoryPermission perm) {
-        R_RETURN(m_page_table.MapIoRegion(dst_address, phys_addr, size, mapping, perm));
-    }
-
-    Result UnmapIoRegion(KProcessAddress dst_address, KPhysicalAddress phys_addr, size_t size,
-                         Svc::MemoryMapping mapping) {
-        R_RETURN(m_page_table.UnmapIoRegion(dst_address, phys_addr, size, mapping));
-    }
-
-    Result MapStatic(KPhysicalAddress phys_addr, size_t size, KMemoryPermission perm) {
-        R_RETURN(m_page_table.MapStatic(phys_addr, size, perm));
-    }
-
-    Result MapRegion(KMemoryRegionType region_type, KMemoryPermission perm) {
-        R_RETURN(m_page_table.MapRegion(region_type, perm));
-    }
-
-    Result MapInsecureMemory(KProcessAddress address, size_t size) {
-        R_RETURN(m_page_table.MapInsecureMemory(address, size));
-    }
-
-    Result UnmapInsecureMemory(KProcessAddress address, size_t size) {
-        R_RETURN(m_page_table.UnmapInsecureMemory(address, size));
-    }
-
-    Result MapPageGroup(KProcessAddress addr, const KPageGroup& pg, KMemoryState state,
-                        KMemoryPermission perm) {
-        R_RETURN(m_page_table.MapPageGroup(addr, pg, state, perm));
-    }
-
-    Result UnmapPageGroup(KProcessAddress address, const KPageGroup& pg, KMemoryState state) {
-        R_RETURN(m_page_table.UnmapPageGroup(address, pg, state));
-    }
-
-    Result MapPages(KProcessAddress* out_addr, size_t num_pages, size_t alignment,
-                    KPhysicalAddress phys_addr, KMemoryState state, KMemoryPermission perm) {
-        R_RETURN(m_page_table.MapPages(out_addr, num_pages, alignment, phys_addr, state, perm));
-    }
-
-    Result MapPages(KProcessAddress* out_addr, size_t num_pages, KMemoryState state,
-                    KMemoryPermission perm) {
-        R_RETURN(m_page_table.MapPages(out_addr, num_pages, state, perm));
-    }
-
-    Result MapPages(KProcessAddress address, size_t num_pages, KMemoryState state,
-                    KMemoryPermission perm) {
-        R_RETURN(m_page_table.MapPages(address, num_pages, state, perm));
-    }
-
-    Result UnmapPages(KProcessAddress addr, size_t num_pages, KMemoryState state) {
-        R_RETURN(m_page_table.UnmapPages(addr, num_pages, state));
-    }
-
-    Result MakeAndOpenPageGroup(KPageGroup* out, KProcessAddress address, size_t num_pages,
-                                KMemoryState state_mask, KMemoryState state,
-                                KMemoryPermission perm_mask, KMemoryPermission perm,
-                                KMemoryAttribute attr_mask, KMemoryAttribute attr) {
-        R_RETURN(m_page_table.MakeAndOpenPageGroup(out, address, num_pages, state_mask, state,
-                                                   perm_mask, perm, attr_mask, attr));
-    }
-
-    Result InvalidateProcessDataCache(KProcessAddress address, size_t size) {
-        R_RETURN(m_page_table.InvalidateProcessDataCache(address, size));
-    }
-
-    Result ReadDebugMemory(KProcessAddress dst_address, KProcessAddress src_address, size_t size) {
-        R_RETURN(m_page_table.ReadDebugMemory(dst_address, src_address, size));
-    }
-
-    Result ReadDebugIoMemory(KProcessAddress dst_address, KProcessAddress src_address, size_t size,
-                             KMemoryState state) {
-        R_RETURN(m_page_table.ReadDebugIoMemory(dst_address, src_address, size, state));
-    }
-
-    Result WriteDebugMemory(KProcessAddress dst_address, KProcessAddress src_address, size_t size) {
-        R_RETURN(m_page_table.WriteDebugMemory(dst_address, src_address, size));
-    }
-
-    Result WriteDebugIoMemory(KProcessAddress dst_address, KProcessAddress src_address, size_t size,
-                              KMemoryState state) {
-        R_RETURN(m_page_table.WriteDebugIoMemory(dst_address, src_address, size, state));
-    }
-
-    Result LockForMapDeviceAddressSpace(bool* out_is_io, KProcessAddress address, size_t size,
-                                        KMemoryPermission perm, bool is_aligned, bool check_heap) {
-        R_RETURN(m_page_table.LockForMapDeviceAddressSpace(out_is_io, address, size, perm,
-                                                           is_aligned, check_heap));
-    }
-
-    Result LockForUnmapDeviceAddressSpace(KProcessAddress address, size_t size, bool check_heap) {
-        R_RETURN(m_page_table.LockForUnmapDeviceAddressSpace(address, size, check_heap));
-    }
-
-    Result UnlockForDeviceAddressSpace(KProcessAddress address, size_t size) {
-        R_RETURN(m_page_table.UnlockForDeviceAddressSpace(address, size));
-    }
-
-    Result UnlockForDeviceAddressSpacePartialMap(KProcessAddress address, size_t size) {
-        R_RETURN(m_page_table.UnlockForDeviceAddressSpacePartialMap(address, size));
-    }
-
-    Result OpenMemoryRangeForMapDeviceAddressSpace(KPageTableBase::MemoryRange* out,
-                                                   KProcessAddress address, size_t size,
-                                                   KMemoryPermission perm, bool is_aligned) {
-        R_RETURN(m_page_table.OpenMemoryRangeForMapDeviceAddressSpace(out, address, size, perm,
-                                                                      is_aligned));
-    }
-
-    Result OpenMemoryRangeForUnmapDeviceAddressSpace(KPageTableBase::MemoryRange* out,
-                                                     KProcessAddress address, size_t size) {
-        R_RETURN(m_page_table.OpenMemoryRangeForUnmapDeviceAddressSpace(out, address, size));
-    }
-
-    Result LockForIpcUserBuffer(KPhysicalAddress* out, KProcessAddress address, size_t size) {
-        R_RETURN(m_page_table.LockForIpcUserBuffer(out, address, size));
-    }
-
-    Result UnlockForIpcUserBuffer(KProcessAddress address, size_t size) {
-        R_RETURN(m_page_table.UnlockForIpcUserBuffer(address, size));
-    }
-
-    Result LockForTransferMemory(KPageGroup* out, KProcessAddress address, size_t size,
-                                 KMemoryPermission perm) {
-        R_RETURN(m_page_table.LockForTransferMemory(out, address, size, perm));
-    }
-
-    Result UnlockForTransferMemory(KProcessAddress address, size_t size, const KPageGroup& pg) {
-        R_RETURN(m_page_table.UnlockForTransferMemory(address, size, pg));
-    }
-
-    Result LockForCodeMemory(KPageGroup* out, KProcessAddress address, size_t size) {
-        R_RETURN(m_page_table.LockForCodeMemory(out, address, size));
-    }
-
-    Result UnlockForCodeMemory(KProcessAddress address, size_t size, const KPageGroup& pg) {
-        R_RETURN(m_page_table.UnlockForCodeMemory(address, size, pg));
-    }
-
-    Result OpenMemoryRangeForProcessCacheOperation(KPageTableBase::MemoryRange* out,
-                                                   KProcessAddress address, size_t size) {
-        R_RETURN(m_page_table.OpenMemoryRangeForProcessCacheOperation(out, address, size));
-    }
-
-    Result CopyMemoryFromLinearToUser(KProcessAddress dst_addr, size_t size,
-                                      KProcessAddress src_addr, KMemoryState src_state_mask,
-                                      KMemoryState src_state, KMemoryPermission src_test_perm,
-                                      KMemoryAttribute src_attr_mask, KMemoryAttribute src_attr) {
-        R_RETURN(m_page_table.CopyMemoryFromLinearToUser(dst_addr, size, src_addr, src_state_mask,
-                                                         src_state, src_test_perm, src_attr_mask,
-                                                         src_attr));
-    }
-
-    Result CopyMemoryFromLinearToKernel(void* dst_addr, size_t size, KProcessAddress src_addr,
-                                        KMemoryState src_state_mask, KMemoryState src_state,
-                                        KMemoryPermission src_test_perm,
-                                        KMemoryAttribute src_attr_mask, KMemoryAttribute src_attr) {
-        R_RETURN(m_page_table.CopyMemoryFromLinearToKernel(dst_addr, size, src_addr, src_state_mask,
-                                                           src_state, src_test_perm, src_attr_mask,
-                                                           src_attr));
-    }
-
-    Result CopyMemoryFromUserToLinear(KProcessAddress dst_addr, size_t size,
-                                      KMemoryState dst_state_mask, KMemoryState dst_state,
-                                      KMemoryPermission dst_test_perm,
-                                      KMemoryAttribute dst_attr_mask, KMemoryAttribute dst_attr,
-                                      KProcessAddress src_addr) {
-        R_RETURN(m_page_table.CopyMemoryFromUserToLinear(dst_addr, size, dst_state_mask, dst_state,
-                                                         dst_test_perm, dst_attr_mask, dst_attr,
-                                                         src_addr));
-    }
-
-    Result CopyMemoryFromKernelToLinear(KProcessAddress dst_addr, size_t size,
-                                        KMemoryState dst_state_mask, KMemoryState dst_state,
-                                        KMemoryPermission dst_test_perm,
-                                        KMemoryAttribute dst_attr_mask, KMemoryAttribute dst_attr,
-                                        void* src_addr) {
-        R_RETURN(m_page_table.CopyMemoryFromKernelToLinear(dst_addr, size, dst_state_mask,
-                                                           dst_state, dst_test_perm, dst_attr_mask,
-                                                           dst_attr, src_addr));
-    }
-
-    Result CopyMemoryFromHeapToHeap(KProcessPageTable& dst_page_table, KProcessAddress dst_addr,
-                                    size_t size, KMemoryState dst_state_mask,
-                                    KMemoryState dst_state, KMemoryPermission dst_test_perm,
-                                    KMemoryAttribute dst_attr_mask, KMemoryAttribute dst_attr,
-                                    KProcessAddress src_addr, KMemoryState src_state_mask,
-                                    KMemoryState src_state, KMemoryPermission src_test_perm,
-                                    KMemoryAttribute src_attr_mask, KMemoryAttribute src_attr) {
-        R_RETURN(m_page_table.CopyMemoryFromHeapToHeap(
-            dst_page_table.m_page_table, dst_addr, size, dst_state_mask, dst_state, dst_test_perm,
-            dst_attr_mask, dst_attr, src_addr, src_state_mask, src_state, src_test_perm,
-            src_attr_mask, src_attr));
-    }
-
-    Result CopyMemoryFromHeapToHeapWithoutCheckDestination(
-        KProcessPageTable& dst_page_table, KProcessAddress dst_addr, size_t size,
-        KMemoryState dst_state_mask, KMemoryState dst_state, KMemoryPermission dst_test_perm,
-        KMemoryAttribute dst_attr_mask, KMemoryAttribute dst_attr, KProcessAddress src_addr,
-        KMemoryState src_state_mask, KMemoryState src_state, KMemoryPermission src_test_perm,
-        KMemoryAttribute src_attr_mask, KMemoryAttribute src_attr) {
-        R_RETURN(m_page_table.CopyMemoryFromHeapToHeapWithoutCheckDestination(
-            dst_page_table.m_page_table, dst_addr, size, dst_state_mask, dst_state, dst_test_perm,
-            dst_attr_mask, dst_attr, src_addr, src_state_mask, src_state, src_test_perm,
-            src_attr_mask, src_attr));
-    }
-
-    Result SetupForIpc(KProcessAddress* out_dst_addr, size_t size, KProcessAddress src_addr,
-                       KProcessPageTable& src_page_table, KMemoryPermission test_perm,
-                       KMemoryState dst_state, bool send) {
-        R_RETURN(m_page_table.SetupForIpc(out_dst_addr, size, src_addr, src_page_table.m_page_table,
-                                          test_perm, dst_state, send));
-    }
-
-    Result CleanupForIpcServer(KProcessAddress address, size_t size, KMemoryState dst_state) {
-        R_RETURN(m_page_table.CleanupForIpcServer(address, size, dst_state));
-    }
-
-    Result CleanupForIpcClient(KProcessAddress address, size_t size, KMemoryState dst_state) {
-        R_RETURN(m_page_table.CleanupForIpcClient(address, size, dst_state));
-    }
-
-    Result MapPhysicalMemory(KProcessAddress address, size_t size) {
-        R_RETURN(m_page_table.MapPhysicalMemory(address, size));
-    }
-
-    Result UnmapPhysicalMemory(KProcessAddress address, size_t size) {
-        R_RETURN(m_page_table.UnmapPhysicalMemory(address, size));
-    }
-
-    Result MapPhysicalMemoryUnsafe(KProcessAddress address, size_t size) {
-        R_RETURN(m_page_table.MapPhysicalMemoryUnsafe(address, size));
-    }
-
-    Result UnmapPhysicalMemoryUnsafe(KProcessAddress address, size_t size) {
-        R_RETURN(m_page_table.UnmapPhysicalMemoryUnsafe(address, size));
-    }
-
-    Result UnmapProcessMemory(KProcessAddress dst_address, size_t size,
-                              KProcessPageTable& src_page_table, KProcessAddress src_address) {
-        R_RETURN(m_page_table.UnmapProcessMemory(dst_address, size, src_page_table.m_page_table,
-                                                 src_address));
-    }
-
-    bool GetPhysicalAddress(KPhysicalAddress* out, KProcessAddress address) {
-        return m_page_table.GetPhysicalAddress(out, address);
-    }
-
-    bool Contains(KProcessAddress addr, size_t size) const {
-        return m_page_table.Contains(addr, size);
-    }
-
-    bool IsInAliasRegion(KProcessAddress addr, size_t size) const {
-        return m_page_table.IsInAliasRegion(addr, size);
-    }
-    bool IsInHeapRegion(KProcessAddress addr, size_t size) const {
-        return m_page_table.IsInHeapRegion(addr, size);
-    }
-    bool IsInUnsafeAliasRegion(KProcessAddress addr, size_t size) const {
-        return m_page_table.IsInUnsafeAliasRegion(addr, size);
-    }
-
-    bool CanContain(KProcessAddress addr, size_t size, KMemoryState state) const {
-        return m_page_table.CanContain(addr, size, state);
-    }
-
-    KProcessAddress GetAddressSpaceStart() const {
-        return m_page_table.GetAddressSpaceStart();
-    }
-    KProcessAddress GetHeapRegionStart() const {
-        return m_page_table.GetHeapRegionStart();
-    }
-    KProcessAddress GetAliasRegionStart() const {
-        return m_page_table.GetAliasRegionStart();
-    }
-    KProcessAddress GetStackRegionStart() const {
-        return m_page_table.GetStackRegionStart();
-    }
-    KProcessAddress GetKernelMapRegionStart() const {
-        return m_page_table.GetKernelMapRegionStart();
-    }
-    KProcessAddress GetCodeRegionStart() const {
-        return m_page_table.GetCodeRegionStart();
-    }
-    KProcessAddress GetAliasCodeRegionStart() const {
-        return m_page_table.GetAliasCodeRegionStart();
-    }
-
-    size_t GetAddressSpaceSize() const {
-        return m_page_table.GetAddressSpaceSize();
-    }
-    size_t GetHeapRegionSize() const {
-        return m_page_table.GetHeapRegionSize();
-    }
-    size_t GetAliasRegionSize() const {
-        return m_page_table.GetAliasRegionSize();
-    }
-    size_t GetStackRegionSize() const {
-        return m_page_table.GetStackRegionSize();
-    }
-    size_t GetKernelMapRegionSize() const {
-        return m_page_table.GetKernelMapRegionSize();
-    }
-    size_t GetCodeRegionSize() const {
-        return m_page_table.GetCodeRegionSize();
-    }
-    size_t GetAliasCodeRegionSize() const {
-        return m_page_table.GetAliasCodeRegionSize();
-    }
-
-    size_t GetNormalMemorySize() const {
-        return m_page_table.GetNormalMemorySize();
-    }
-
-    size_t GetCodeSize() const {
-        return m_page_table.GetCodeSize();
-    }
-    size_t GetCodeDataSize() const {
-        return m_page_table.GetCodeDataSize();
-    }
-
-    size_t GetAliasCodeSize() const {
-        return m_page_table.GetAliasCodeSize();
-    }
-    size_t GetAliasCodeDataSize() const {
-        return m_page_table.GetAliasCodeDataSize();
-    }
-
-    u32 GetAllocateOption() const {
-        return m_page_table.GetAllocateOption();
-    }
-
-    u32 GetAddressSpaceWidth() const {
-        return m_page_table.GetAddressSpaceWidth();
-    }
-
-    KPhysicalAddress GetHeapPhysicalAddress(KVirtualAddress address) {
-        return m_page_table.GetHeapPhysicalAddress(address);
-    }
-
-    u8* GetHeapVirtualPointer(KPhysicalAddress address) {
-        return m_page_table.GetHeapVirtualPointer(address);
-    }
-
-    KVirtualAddress GetHeapVirtualAddress(KPhysicalAddress address) {
-        return m_page_table.GetHeapVirtualAddress(address);
-    }
-
-    KBlockInfoManager* GetBlockInfoManager() {
-        return m_page_table.GetBlockInfoManager();
-    }
-
-    KPageTable& GetBasePageTable() {
-        return m_page_table;
-    }
-
-    const KPageTable& GetBasePageTable() const {
-        return m_page_table;
-    }
-};
-
-} // namespace Kernel

src/core/hle/kernel/k_server_session.cpp

@@ -383,7 +383,7 @@ Result KServerSession::SendReply(bool is_hle) {
         if (event != nullptr) {
             // // Get the client process/page table.
             // KProcess *client_process             = client_thread->GetOwnerProcess();
-            // KProcessPageTable *client_page_table = std::addressof(client_process->PageTable());
+            // KPageTable *client_page_table        = std::addressof(client_process->PageTable());
 
             // // If we need to, reply with an async error.
             // if (R_FAILED(client_result)) {

src/core/hle/kernel/k_system_resource.cpp

@@ -40,7 +40,7 @@ Result KSecureSystemResource::Initialize(size_t size, KResourceLimit* resource_l
 
     // Get resource pointer.
     KPhysicalAddress resource_paddr =
-        KPageTable::GetHeapPhysicalAddress(m_kernel, m_resource_address);
+        KPageTable::GetHeapPhysicalAddress(m_kernel.MemoryLayout(), m_resource_address);
     auto* resource =
         m_kernel.System().DeviceMemory().GetPointer<KPageTableManager::RefCount>(resource_paddr);
 

src/core/hle/kernel/k_thread_local_page.cpp

@@ -37,8 +37,8 @@ Result KThreadLocalPage::Initialize(KernelCore& kernel, KProcess* process) {
 
 Result KThreadLocalPage::Finalize() {
     // Get the physical address of the page.
-    KPhysicalAddress phys_addr{};
-    ASSERT(m_owner->GetPageTable().GetPhysicalAddress(std::addressof(phys_addr), m_virt_addr));
+    const KPhysicalAddress phys_addr = m_owner->GetPageTable().GetPhysicalAddr(m_virt_addr);
+    ASSERT(phys_addr);
 
     // Unmap the page.
     R_TRY(m_owner->GetPageTable().UnmapPages(this->GetAddress(), 1, KMemoryState::ThreadLocal));

src/core/hle/kernel/process_capability.cpp

@@ -0,0 +1,389 @@
+// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include <bit>
+
+#include "common/bit_util.h"
+#include "common/logging/log.h"
+#include "core/hle/kernel/k_handle_table.h"
+#include "core/hle/kernel/k_page_table.h"
+#include "core/hle/kernel/process_capability.h"
+#include "core/hle/kernel/svc_results.h"
+
+namespace Kernel {
+namespace {
+
+// clang-format off
+
+// Shift offsets for kernel capability types.
+enum : u32 {
+    CapabilityOffset_PriorityAndCoreNum = 3,
+    CapabilityOffset_Syscall            = 4,
+    CapabilityOffset_MapPhysical        = 6,
+    CapabilityOffset_MapIO              = 7,
+    CapabilityOffset_MapRegion          = 10,
+    CapabilityOffset_Interrupt          = 11,
+    CapabilityOffset_ProgramType        = 13,
+    CapabilityOffset_KernelVersion      = 14,
+    CapabilityOffset_HandleTableSize    = 15,
+    CapabilityOffset_Debug              = 16,
+};
+
+// Combined mask of all parameters that may be initialized only once.
+constexpr u32 InitializeOnceMask = (1U << CapabilityOffset_PriorityAndCoreNum) |
+                                   (1U << CapabilityOffset_ProgramType) |
+                                   (1U << CapabilityOffset_KernelVersion) |
+                                   (1U << CapabilityOffset_HandleTableSize) |
+                                   (1U << CapabilityOffset_Debug);
+
+// Packed kernel version indicating 10.4.0
+constexpr u32 PackedKernelVersion = 0x520000;
+
+// Indicates possible types of capabilities that can be specified.
+enum class CapabilityType : u32 {
+    Unset              = 0U,
+    PriorityAndCoreNum = (1U << CapabilityOffset_PriorityAndCoreNum) - 1,
+    Syscall            = (1U << CapabilityOffset_Syscall) - 1,
+    MapPhysical        = (1U << CapabilityOffset_MapPhysical) - 1,
+    MapIO              = (1U << CapabilityOffset_MapIO) - 1,
+    MapRegion          = (1U << CapabilityOffset_MapRegion) - 1,
+    Interrupt          = (1U << CapabilityOffset_Interrupt) - 1,
+    ProgramType        = (1U << CapabilityOffset_ProgramType) - 1,
+    KernelVersion      = (1U << CapabilityOffset_KernelVersion) - 1,
+    HandleTableSize    = (1U << CapabilityOffset_HandleTableSize) - 1,
+    Debug              = (1U << CapabilityOffset_Debug) - 1,
+    Ignorable          = 0xFFFFFFFFU,
+};
+
+// clang-format on
+
+constexpr CapabilityType GetCapabilityType(u32 value) {
+    return static_cast<CapabilityType>((~value & (value + 1)) - 1);
+}
+
+u32 GetFlagBitOffset(CapabilityType type) {
+    const auto value = static_cast<u32>(type);
+    return static_cast<u32>(Common::BitSize<u32>() - static_cast<u32>(std::countl_zero(value)));
+}
+
+} // Anonymous namespace
+
+Result ProcessCapabilities::InitializeForKernelProcess(const u32* capabilities,
+                                                       std::size_t num_capabilities,
+                                                       KPageTable& page_table) {
+    Clear();
+
+    // Allow all cores and priorities.
+    core_mask = 0xF;
+    priority_mask = 0xFFFFFFFFFFFFFFFF;
+    kernel_version = PackedKernelVersion;
+
+    return ParseCapabilities(capabilities, num_capabilities, page_table);
+}
+
+Result ProcessCapabilities::InitializeForUserProcess(const u32* capabilities,
+                                                     std::size_t num_capabilities,
+                                                     KPageTable& page_table) {
+    Clear();
+
+    return ParseCapabilities(capabilities, num_capabilities, page_table);
+}
+
+void ProcessCapabilities::InitializeForMetadatalessProcess() {
+    // Allow all cores and priorities
+    core_mask = 0xF;
+    priority_mask = 0xFFFFFFFFFFFFFFFF;
+    kernel_version = PackedKernelVersion;
+
+    // Allow all system calls and interrupts.
+    svc_capabilities.set();
+    interrupt_capabilities.set();
+
+    // Allow using the maximum possible amount of handles
+    handle_table_size = static_cast<s32>(KHandleTable::MaxTableSize);
+
+    // Allow all debugging capabilities.
+    is_debuggable = true;
+    can_force_debug = true;
+}
+
+Result ProcessCapabilities::ParseCapabilities(const u32* capabilities, std::size_t num_capabilities,
+                                              KPageTable& page_table) {
+    u32 set_flags = 0;
+    u32 set_svc_bits = 0;
+
+    for (std::size_t i = 0; i < num_capabilities; ++i) {
+        const u32 descriptor = capabilities[i];
+        const auto type = GetCapabilityType(descriptor);
+
+        if (type == CapabilityType::MapPhysical) {
+            i++;
+
+            // The MapPhysical type uses two descriptor flags for its parameters.
+            // If there's only one, then there's a problem.
+            if (i >= num_capabilities) {
+                LOG_ERROR(Kernel, "Invalid combination! i={}", i);
+                return ResultInvalidCombination;
+            }
+
+            const auto size_flags = capabilities[i];
+            if (GetCapabilityType(size_flags) != CapabilityType::MapPhysical) {
+                LOG_ERROR(Kernel, "Invalid capability type! size_flags={}", size_flags);
+                return ResultInvalidCombination;
+            }
+
+            const auto result = HandleMapPhysicalFlags(descriptor, size_flags, page_table);
+            if (result.IsError()) {
+                LOG_ERROR(Kernel, "Failed to map physical flags! descriptor={}, size_flags={}",
+                          descriptor, size_flags);
+                return result;
+            }
+        } else {
+            const auto result =
+                ParseSingleFlagCapability(set_flags, set_svc_bits, descriptor, page_table);
+            if (result.IsError()) {
+                LOG_ERROR(
+                    Kernel,
+                    "Failed to parse capability flag! set_flags={}, set_svc_bits={}, descriptor={}",
+                    set_flags, set_svc_bits, descriptor);
+                return result;
+            }
+        }
+    }
+
+    return ResultSuccess;
+}
+
+Result ProcessCapabilities::ParseSingleFlagCapability(u32& set_flags, u32& set_svc_bits, u32 flag,
+                                                      KPageTable& page_table) {
+    const auto type = GetCapabilityType(flag);
+
+    if (type == CapabilityType::Unset) {
+        return ResultInvalidArgument;
+    }
+
+    // Bail early on ignorable entries, as one would expect,
+    // ignorable descriptors can be ignored.
+    if (type == CapabilityType::Ignorable) {
+        return ResultSuccess;
+    }
+
+    // Ensure that the give flag hasn't already been initialized before.
+    // If it has been, then bail.
+    const u32 flag_length = GetFlagBitOffset(type);
+    const u32 set_flag = 1U << flag_length;
+    if ((set_flag & set_flags & InitializeOnceMask) != 0) {
+        LOG_ERROR(Kernel,
+                  "Attempted to initialize flags that may only be initialized once. set_flags={}",
+                  set_flags);
+        return ResultInvalidCombination;
+    }
+    set_flags |= set_flag;
+
+    switch (type) {
+    case CapabilityType::PriorityAndCoreNum:
+        return HandlePriorityCoreNumFlags(flag);
+    case CapabilityType::Syscall:
+        return HandleSyscallFlags(set_svc_bits, flag);
+    case CapabilityType::MapIO:
+        return HandleMapIOFlags(flag, page_table);
+    case CapabilityType::MapRegion:
+        return HandleMapRegionFlags(flag, page_table);
+    case CapabilityType::Interrupt:
+        return HandleInterruptFlags(flag);
+    case CapabilityType::ProgramType:
+        return HandleProgramTypeFlags(flag);
+    case CapabilityType::KernelVersion:
+        return HandleKernelVersionFlags(flag);
+    case CapabilityType::HandleTableSize:
+        return HandleHandleTableFlags(flag);
+    case CapabilityType::Debug:
+        return HandleDebugFlags(flag);
+    default:
+        break;
+    }
+
+    LOG_ERROR(Kernel, "Invalid capability type! type={}", type);
+    return ResultInvalidArgument;
+}
+
+void ProcessCapabilities::Clear() {
+    svc_capabilities.reset();
+    interrupt_capabilities.reset();
+
+    core_mask = 0;
+    priority_mask = 0;
+
+    handle_table_size = 0;
+    kernel_version = 0;
+
+    program_type = ProgramType::SysModule;
+
+    is_debuggable = false;
+    can_force_debug = false;
+}
+
+Result ProcessCapabilities::HandlePriorityCoreNumFlags(u32 flags) {
+    if (priority_mask != 0 || core_mask != 0) {
+        LOG_ERROR(Kernel, "Core or priority mask are not zero! priority_mask={}, core_mask={}",
+                  priority_mask, core_mask);
+        return ResultInvalidArgument;
+    }
+
+    const u32 core_num_min = (flags >> 16) & 0xFF;
+    const u32 core_num_max = (flags >> 24) & 0xFF;
+    if (core_num_min > core_num_max) {
+        LOG_ERROR(Kernel, "Core min is greater than core max! core_num_min={}, core_num_max={}",
+                  core_num_min, core_num_max);
+        return ResultInvalidCombination;
+    }
+
+    const u32 priority_min = (flags >> 10) & 0x3F;
+    const u32 priority_max = (flags >> 4) & 0x3F;
+    if (priority_min > priority_max) {
+        LOG_ERROR(Kernel,
+                  "Priority min is greater than priority max! priority_min={}, priority_max={}",
+                  core_num_min, priority_max);
+        return ResultInvalidCombination;
+    }
+
+    // The switch only has 4 usable cores.
+    if (core_num_max >= 4) {
+        LOG_ERROR(Kernel, "Invalid max cores specified! core_num_max={}", core_num_max);
+        return ResultInvalidCoreId;
+    }
+
+    const auto make_mask = [](u64 min, u64 max) {
+        const u64 range = max - min + 1;
+        const u64 mask = (1ULL << range) - 1;
+
+        return mask << min;
+    };
+
+    core_mask = make_mask(core_num_min, core_num_max);
+    priority_mask = make_mask(priority_min, priority_max);
+    return ResultSuccess;
+}
+
+Result ProcessCapabilities::HandleSyscallFlags(u32& set_svc_bits, u32 flags) {
+    const u32 index = flags >> 29;
+    const u32 svc_bit = 1U << index;
+
+    // If we've already set this svc before, bail.
+    if ((set_svc_bits & svc_bit) != 0) {
+        return ResultInvalidCombination;
+    }
+    set_svc_bits |= svc_bit;
+
+    const u32 svc_mask = (flags >> 5) & 0xFFFFFF;
+    for (u32 i = 0; i < 24; ++i) {
+        const u32 svc_number = index * 24 + i;
+
+        if ((svc_mask & (1U << i)) == 0) {
+            continue;
+        }
+
+        svc_capabilities[svc_number] = true;
+    }
+
+    return ResultSuccess;
+}
+
+Result ProcessCapabilities::HandleMapPhysicalFlags(u32 flags, u32 size_flags,
+                                                   KPageTable& page_table) {
+    // TODO(Lioncache): Implement once the memory manager can handle this.
+    return ResultSuccess;
+}
+
+Result ProcessCapabilities::HandleMapIOFlags(u32 flags, KPageTable& page_table) {
+    // TODO(Lioncache): Implement once the memory manager can handle this.
+    return ResultSuccess;
+}
+
+Result ProcessCapabilities::HandleMapRegionFlags(u32 flags, KPageTable& page_table) {
+    // TODO(Lioncache): Implement once the memory manager can handle this.
+    return ResultSuccess;
+}
+
+Result ProcessCapabilities::HandleInterruptFlags(u32 flags) {
+    constexpr u32 interrupt_ignore_value = 0x3FF;
+    const u32 interrupt0 = (flags >> 12) & 0x3FF;
+    const u32 interrupt1 = (flags >> 22) & 0x3FF;
+
+    for (u32 interrupt : {interrupt0, interrupt1}) {
+        if (interrupt == interrupt_ignore_value) {
+            continue;
+        }
+
+        // NOTE:
+        // This should be checking a generic interrupt controller value
+        // as part of the calculation, however, given we don't currently
+        // emulate that, it's sufficient to mark every interrupt as defined.
+
+        if (interrupt >= interrupt_capabilities.size()) {
+            LOG_ERROR(Kernel, "Process interrupt capability is out of range! svc_number={}",
+                      interrupt);
+            return ResultOutOfRange;
+        }
+
+        interrupt_capabilities[interrupt] = true;
+    }
+
+    return ResultSuccess;
+}
+
+Result ProcessCapabilities::HandleProgramTypeFlags(u32 flags) {
+    const u32 reserved = flags >> 17;
+    if (reserved != 0) {
+        LOG_ERROR(Kernel, "Reserved value is non-zero! reserved={}", reserved);
+        return ResultReservedUsed;
+    }
+
+    program_type = static_cast<ProgramType>((flags >> 14) & 0b111);
+    return ResultSuccess;
+}
+
+Result ProcessCapabilities::HandleKernelVersionFlags(u32 flags) {
+    // Yes, the internal member variable is checked in the actual kernel here.
+    // This might look odd for options that are only allowed to be initialized
+    // just once, however the kernel has a separate initialization function for
+    // kernel processes and userland processes. The kernel variant sets this
+    // member variable ahead of time.
+
+    const u32 major_version = kernel_version >> 19;
+
+    if (major_version != 0 || flags < 0x80000) {
+        LOG_ERROR(Kernel,
+                  "Kernel version is non zero or flags are too small! major_version={}, flags={}",
+                  major_version, flags);
+        return ResultInvalidArgument;
+    }
+
+    kernel_version = flags;
+    return ResultSuccess;
+}
+
+Result ProcessCapabilities::HandleHandleTableFlags(u32 flags) {
+    const u32 reserved = flags >> 26;
+    if (reserved != 0) {
+        LOG_ERROR(Kernel, "Reserved value is non-zero! reserved={}", reserved);
+        return ResultReservedUsed;
+    }
+
+    handle_table_size = static_cast<s32>((flags >> 16) & 0x3FF);
+    return ResultSuccess;
+}
+
+Result ProcessCapabilities::HandleDebugFlags(u32 flags) {
+    const u32 reserved = flags >> 19;
+    if (reserved != 0) {
+        LOG_ERROR(Kernel, "Reserved value is non-zero! reserved={}", reserved);
+        return ResultReservedUsed;
+    }
+
+    is_debuggable = (flags & 0x20000) != 0;
+    can_force_debug = (flags & 0x40000) != 0;
+    return ResultSuccess;
+}
+
+} // namespace Kernel

src/core/hle/kernel/process_capability.h

@@ -0,0 +1,266 @@
+// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <bitset>
+
+#include "common/common_types.h"
+
+union Result;
+
+namespace Kernel {
+
+class KPageTable;
+
+/// The possible types of programs that may be indicated
+/// by the program type capability descriptor.
+enum class ProgramType {
+    SysModule,
+    Application,
+    Applet,
+};
+
+/// Handles kernel capability descriptors that are provided by
+/// application metadata. These descriptors provide information
+/// that alters certain parameters for kernel process instance
+/// that will run said application (or applet).
+///
+/// Capabilities are a sequence of flag descriptors, that indicate various
+/// configurations and constraints for a particular process.
+///
+/// Flag types are indicated by a sequence of set low bits. E.g. the
+/// types are indicated with the low bits as follows (where x indicates "don't care"):
+///
+/// - Priority and core mask   : 0bxxxxxxxxxxxx0111
+/// - Allowed service call mask: 0bxxxxxxxxxxx01111
+/// - Map physical memory      : 0bxxxxxxxxx0111111
+/// - Map IO memory            : 0bxxxxxxxx01111111
+/// - Interrupts               : 0bxxxx011111111111
+/// - Application type         : 0bxx01111111111111
+/// - Kernel version           : 0bx011111111111111
+/// - Handle table size        : 0b0111111111111111
+/// - Debugger flags           : 0b1111111111111111
+///
+/// These are essentially a bit offset subtracted by 1 to create a mask.
+/// e.g. The first entry in the above list is simply bit 3 (value 8 -> 0b1000)
+///      subtracted by one (7 -> 0b0111)
+///
+/// An example of a bit layout (using the map physical layout):
+/// <example>
+///   The MapPhysical type indicates a sequence entry pair of:
+///
+///   [initial, memory_flags], where:
+///
+///   initial:
+///     bits:
+///       7-24: Starting page to map memory at.
+///       25  : Indicates if the memory should be mapped as read only.
+///
+///   memory_flags:
+///     bits:
+///       7-20 : Number of pages to map
+///       21-25: Seems to be reserved (still checked against though)
+///       26   : Whether or not the memory being mapped is IO memory, or physical memory
+/// </example>
+///
+class ProcessCapabilities {
+public:
+    using InterruptCapabilities = std::bitset<1024>;
+    using SyscallCapabilities = std::bitset<192>;
+
+    ProcessCapabilities() = default;
+    ProcessCapabilities(const ProcessCapabilities&) = delete;
+    ProcessCapabilities(ProcessCapabilities&&) = default;
+
+    ProcessCapabilities& operator=(const ProcessCapabilities&) = delete;
+    ProcessCapabilities& operator=(ProcessCapabilities&&) = default;
+
+    /// Initializes this process capabilities instance for a kernel process.
+    ///
+    /// @param capabilities     The capabilities to parse
+    /// @param num_capabilities The number of capabilities to parse.
+    /// @param page_table       The memory manager to use for handling any mapping-related
+    ///                         operations (such as mapping IO memory, etc).
+    ///
+    /// @returns ResultSuccess if this capabilities instance was able to be initialized,
+    ///          otherwise, an error code upon failure.
+    ///
+    Result InitializeForKernelProcess(const u32* capabilities, std::size_t num_capabilities,
+                                      KPageTable& page_table);
+
+    /// Initializes this process capabilities instance for a userland process.
+    ///
+    /// @param capabilities     The capabilities to parse.
+    /// @param num_capabilities The total number of capabilities to parse.
+    /// @param page_table       The memory manager to use for handling any mapping-related
+    ///                         operations (such as mapping IO memory, etc).
+    ///
+    /// @returns ResultSuccess if this capabilities instance was able to be initialized,
+    ///          otherwise, an error code upon failure.
+    ///
+    Result InitializeForUserProcess(const u32* capabilities, std::size_t num_capabilities,
+                                    KPageTable& page_table);
+
+    /// Initializes this process capabilities instance for a process that does not
+    /// have any metadata to parse.
+    ///
+    /// This is necessary, as we allow running raw executables, and the internal
+    /// kernel process capabilities also determine what CPU cores the process is
+    /// allowed to run on, and what priorities are allowed for  threads. It also
+    /// determines the max handle table size, what the program type is, whether or
+    /// not the process can be debugged, or whether it's possible for a process to
+    /// forcibly debug another process.
+    ///
+    /// Given the above, this essentially enables all capabilities across the board
+    /// for the process. It allows the process to:
+    ///
+    /// - Run on any core
+    /// - Use any thread priority
+    /// - Use the maximum amount of handles a process is allowed to.
+    /// - Be debuggable
+    /// - Forcibly debug other processes.
+    ///
+    /// Note that this is not a behavior that the kernel allows a process to do via
+    /// a single function like this. This is yuzu-specific behavior to handle
+    /// executables with no capability descriptors whatsoever to derive behavior from.
+    /// It being yuzu-specific is why this is also not the default behavior and not
+    /// done by default in the constructor.
+    ///
+    void InitializeForMetadatalessProcess();
+
+    /// Gets the allowable core mask
+    u64 GetCoreMask() const {
+        return core_mask;
+    }
+
+    /// Gets the allowable priority mask
+    u64 GetPriorityMask() const {
+        return priority_mask;
+    }
+
+    /// Gets the SVC access permission bits
+    const SyscallCapabilities& GetServiceCapabilities() const {
+        return svc_capabilities;
+    }
+
+    /// Gets the valid interrupt bits.
+    const InterruptCapabilities& GetInterruptCapabilities() const {
+        return interrupt_capabilities;
+    }
+
+    /// Gets the program type for this process.
+    ProgramType GetProgramType() const {
+        return program_type;
+    }
+
+    /// Gets the number of total allowable handles for the process' handle table.
+    s32 GetHandleTableSize() const {
+        return handle_table_size;
+    }
+
+    /// Gets the kernel version value.
+    u32 GetKernelVersion() const {
+        return kernel_version;
+    }
+
+    /// Whether or not this process can be debugged.
+    bool IsDebuggable() const {
+        return is_debuggable;
+    }
+
+    /// Whether or not this process can forcibly debug another
+    /// process, even if that process is not considered debuggable.
+    bool CanForceDebug() const {
+        return can_force_debug;
+    }
+
+private:
+    /// Attempts to parse a given sequence of capability descriptors.
+    ///
+    /// @param capabilities     The sequence of capability descriptors to parse.
+    /// @param num_capabilities The number of descriptors within the given sequence.
+    /// @param page_table       The memory manager that will perform any memory
+    ///                         mapping if necessary.
+    ///
+    /// @return ResultSuccess if no errors occur, otherwise an error code.
+    ///
+    Result ParseCapabilities(const u32* capabilities, std::size_t num_capabilities,
+                             KPageTable& page_table);
+
+    /// Attempts to parse a capability descriptor that is only represented by a
+    /// single flag set.
+    ///
+    /// @param set_flags    Running set of flags that are used to catch
+    ///                     flags being initialized more than once when they shouldn't be.
+    /// @param set_svc_bits Running set of bits representing the allowed supervisor calls mask.
+    /// @param flag         The flag to attempt to parse.
+    /// @param page_table   The memory manager that will perform any memory
+    ///                     mapping if necessary.
+    ///
+    /// @return ResultSuccess if no errors occurred, otherwise an error code.
+    ///
+    Result ParseSingleFlagCapability(u32& set_flags, u32& set_svc_bits, u32 flag,
+                                     KPageTable& page_table);
+
+    /// Clears the internal state of this process capability instance. Necessary,
+    /// to have a sane starting point due to us allowing running executables without
+    /// configuration metadata. We assume a process is not going to have metadata,
+    /// and if it turns out that the process does, in fact, have metadata, then
+    /// we attempt to parse it. Thus, we need this to reset data members back to
+    /// a good state.
+    ///
+    /// DO NOT ever make this a public member function. This isn't an invariant
+    /// anything external should depend upon (and if anything comes to rely on it,
+    /// you should immediately be questioning the design of that thing, not this
+    /// class. If the kernel itself can run without depending on behavior like that,
+    /// then so can yuzu).
+    ///
+    void Clear();
+
+    /// Handles flags related to the priority and core number capability flags.
+    Result HandlePriorityCoreNumFlags(u32 flags);
+
+    /// Handles flags related to determining the allowable SVC mask.
+    Result HandleSyscallFlags(u32& set_svc_bits, u32 flags);
+
+    /// Handles flags related to mapping physical memory pages.
+    Result HandleMapPhysicalFlags(u32 flags, u32 size_flags, KPageTable& page_table);
+
+    /// Handles flags related to mapping IO pages.
+    Result HandleMapIOFlags(u32 flags, KPageTable& page_table);
+
+    /// Handles flags related to mapping physical memory regions.
+    Result HandleMapRegionFlags(u32 flags, KPageTable& page_table);
+
+    /// Handles flags related to the interrupt capability flags.
+    Result HandleInterruptFlags(u32 flags);
+
+    /// Handles flags related to the program type.
+    Result HandleProgramTypeFlags(u32 flags);
+
+    /// Handles flags related to the handle table size.
+    Result HandleHandleTableFlags(u32 flags);
+
+    /// Handles flags related to the kernel version capability flags.
+    Result HandleKernelVersionFlags(u32 flags);
+
+    /// Handles flags related to debug-specific capabilities.
+    Result HandleDebugFlags(u32 flags);
+
+    SyscallCapabilities svc_capabilities;
+    InterruptCapabilities interrupt_capabilities;
+
+    u64 core_mask = 0;
+    u64 priority_mask = 0;
+
+    s32 handle_table_size = 0;
+    u32 kernel_version = 0;
+
+    ProgramType program_type = ProgramType::SysModule;
+
+    bool is_debuggable = false;
+    bool can_force_debug = false;
+};
+
+} // namespace Kernel

src/core/hle/kernel/svc/svc_memory.cpp

@@ -29,8 +29,7 @@ constexpr bool IsValidAddressRange(u64 address, u64 size) {
 // Helper function that performs the common sanity checks for svcMapMemory
 // and svcUnmapMemory. This is doable, as both functions perform their sanitizing
 // in the same order.
-Result MapUnmapMemorySanityChecks(const KProcessPageTable& manager, u64 dst_addr, u64 src_addr,
-                                  u64 size) {
+Result MapUnmapMemorySanityChecks(const KPageTable& manager, u64 dst_addr, u64 src_addr, u64 size) {
     if (!Common::Is4KBAligned(dst_addr)) {
         LOG_ERROR(Kernel_SVC, "Destination address is not aligned to 4KB, 0x{:016X}", dst_addr);
         R_THROW(ResultInvalidAddress);
@@ -124,8 +123,7 @@ Result SetMemoryAttribute(Core::System& system, u64 address, u64 size, u32 mask,
     R_UNLESS(page_table.Contains(address, size), ResultInvalidCurrentMemory);
 
     // Set the memory attribute.
-    R_RETURN(page_table.SetMemoryAttribute(address, size, static_cast<KMemoryAttribute>(mask),
-                                           static_cast<KMemoryAttribute>(attr)));
+    R_RETURN(page_table.SetMemoryAttribute(address, size, mask, attr));
 }
 
 /// Maps a memory range into a different range.

src/core/hle/kernel/svc/svc_physical_memory.cpp

@@ -16,14 +16,7 @@ Result SetHeapSize(Core::System& system, u64* out_address, u64 size) {
     R_UNLESS(size < MainMemorySizeMax, ResultInvalidSize);
 
     // Set the heap size.
-    KProcessAddress address{};
-    R_TRY(GetCurrentProcess(system.Kernel())
-              .GetPageTable()
-              .SetHeapSize(std::addressof(address), size));
-
-    // We succeeded.
-    *out_address = GetInteger(address);
-    R_SUCCEED();
+    R_RETURN(GetCurrentProcess(system.Kernel()).GetPageTable().SetHeapSize(out_address, size));
 }
 
 /// Maps memory at a desired address

src/core/hle/kernel/svc/svc_process_memory.cpp

@@ -247,7 +247,8 @@ Result UnmapProcessCodeMemory(Core::System& system, Handle process_handle, u64 d
         R_THROW(ResultInvalidCurrentMemory);
     }
 
-    R_RETURN(page_table.UnmapCodeMemory(dst_address, src_address, size));
+    R_RETURN(page_table.UnmapCodeMemory(dst_address, src_address, size,
+                                        KPageTable::ICacheInvalidationStrategy::InvalidateAll));
 }
 
 Result SetProcessMemoryPermission64(Core::System& system, Handle process_handle, uint64_t address,

src/core/hle/kernel/svc/svc_query_memory.cpp

@@ -31,12 +31,12 @@ Result QueryProcessMemory(Core::System& system, uint64_t out_memory_info, PageIn
     }
 
     auto& current_memory{GetCurrentMemory(system.Kernel())};
+    const auto memory_info{process->GetPageTable().QueryInfo(address).GetSvcMemoryInfo()};
 
-    KMemoryInfo mem_info;
-    R_TRY(process->GetPageTable().QueryInfo(std::addressof(mem_info), out_page_info, address));
+    current_memory.WriteBlock(out_memory_info, std::addressof(memory_info), sizeof(memory_info));
 
-    const auto svc_mem_info = mem_info.GetSvcMemoryInfo();
-    current_memory.WriteBlock(out_memory_info, std::addressof(svc_mem_info), sizeof(svc_mem_info));
+    //! This is supposed to be part of the QueryInfo call.
+    *out_page_info = {};
 
     R_SUCCEED();
 }

src/core/hle/result.h

@@ -407,34 +407,3 @@ constexpr inline Result __TmpCurrentResultReference = ResultSuccess;
 
 /// Evaluates a boolean expression, and succeeds if that expression is true.
 #define R_SUCCEED_IF(expr) R_UNLESS(!(expr), ResultSuccess)
-
-#define R_TRY_CATCH(res_expr)                                                                      \
-    {                                                                                              \
-        const auto R_CURRENT_RESULT = (res_expr);                                                  \
-        if (R_FAILED(R_CURRENT_RESULT)) {                                                          \
-            if (false)
-
-#define R_END_TRY_CATCH                                                                            \
-    else if (R_FAILED(R_CURRENT_RESULT)) {                                                         \
-        R_THROW(R_CURRENT_RESULT);                                                                 \
-    }                                                                                              \
-    }                                                                                              \
-    }
-
-#define R_CATCH_ALL()                                                                              \
-    }                                                                                              \
-    else if (R_FAILED(R_CURRENT_RESULT)) {                                                         \
-        if (true)
-
-#define R_CATCH(res_expr)                                                                          \
-    }                                                                                              \
-    else if ((res_expr) == (R_CURRENT_RESULT)) {                                                   \
-        if (true)
-
-#define R_CONVERT(catch_type, convert_type)                                                        \
-    R_CATCH(catch_type) { R_THROW(static_cast<Result>(convert_type)); }
-
-#define R_CONVERT_ALL(convert_type)                                                                \
-    R_CATCH_ALL() { R_THROW(static_cast<Result>(convert_type)); }
-
-#define R_ASSERT(res_expr) ASSERT(R_SUCCEEDED(res_expr))

src/core/hle/service/hid/irs.cpp

@@ -138,7 +138,7 @@ void IRS::RunMomentProcessor(HLERequestContext& ctx) {
 
     if (result.IsSuccess()) {
         auto& device = GetIrCameraSharedMemoryDeviceEntry(parameters.camera_handle);
-        MakeProcessorWithCoreContext<MomentProcessor>(parameters.camera_handle, device);
+        MakeProcessor<MomentProcessor>(parameters.camera_handle, device);
         auto& image_transfer_processor = GetProcessor<MomentProcessor>(parameters.camera_handle);
         image_transfer_processor.SetConfig(parameters.processor_config);
         npad_device->SetPollingMode(Core::HID::EmulatedDeviceIndex::RightIndex,

src/core/hle/service/hid/irsensor/clustering_processor.cpp

@@ -3,18 +3,16 @@
 
 #include <queue>
 
-#include "core/core.h"
-#include "core/core_timing.h"
 #include "core/hid/emulated_controller.h"
 #include "core/hid/hid_core.h"
 #include "core/hle/service/hid/irsensor/clustering_processor.h"
 
 namespace Service::IRS {
-ClusteringProcessor::ClusteringProcessor(Core::System& system_,
+ClusteringProcessor::ClusteringProcessor(Core::HID::HIDCore& hid_core_,
                                          Core::IrSensor::DeviceFormat& device_format,
                                          std::size_t npad_index)
-    : device{device_format}, system{system_} {
-    npad_device = system.HIDCore().GetEmulatedControllerByIndex(npad_index);
+    : device{device_format} {
+    npad_device = hid_core_.GetEmulatedControllerByIndex(npad_index);
 
     device.mode = Core::IrSensor::IrSensorMode::ClusteringProcessor;
     device.camera_status = Core::IrSensor::IrCameraStatus::Unconnected;
@@ -50,7 +48,7 @@ void ClusteringProcessor::OnControllerUpdate(Core::HID::ControllerTriggerType ty
     }
 
     next_state = {};
-    const auto& camera_data = npad_device->GetCamera();
+    const auto camera_data = npad_device->GetCamera();
     auto filtered_image = camera_data.data;
 
     RemoveLowIntensityData(filtered_image);
@@ -85,7 +83,7 @@ void ClusteringProcessor::OnControllerUpdate(Core::HID::ControllerTriggerType ty
     }
 
     next_state.sampling_number = camera_data.sample;
-    next_state.timestamp = system.CoreTiming().GetGlobalTimeNs().count();
+    next_state.timestamp = next_state.timestamp + 131;
     next_state.ambient_noise_level = Core::IrSensor::CameraAmbientNoiseLevel::Low;
     shared_memory->clustering_lifo.WriteNextEntry(next_state);
 
@@ -204,14 +202,14 @@ ClusteringProcessor::ClusteringData ClusteringProcessor::MergeCluster(
 }
 
 u8 ClusteringProcessor::GetPixel(const std::vector<u8>& data, std::size_t x, std::size_t y) const {
-    if ((y * width) + x >= data.size()) {
+    if ((y * width) + x > data.size()) {
         return 0;
     }
     return data[(y * width) + x];
 }
 
 void ClusteringProcessor::SetPixel(std::vector<u8>& data, std::size_t x, std::size_t y, u8 value) {
-    if ((y * width) + x >= data.size()) {
+    if ((y * width) + x > data.size()) {
         return;
     }
     data[(y * width) + x] = value;

src/core/hle/service/hid/irsensor/clustering_processor.h

@@ -8,10 +8,6 @@
 #include "core/hle/service/hid/irs_ring_lifo.h"
 #include "core/hle/service/hid/irsensor/processor_base.h"
 
-namespace Core {
-class System;
-}
-
 namespace Core::HID {
 class EmulatedController;
 } // namespace Core::HID
@@ -19,7 +15,8 @@ class EmulatedController;
 namespace Service::IRS {
 class ClusteringProcessor final : public ProcessorBase {
 public:
-    explicit ClusteringProcessor(Core::System& system_, Core::IrSensor::DeviceFormat& device_format,
+    explicit ClusteringProcessor(Core::HID::HIDCore& hid_core_,
+                                 Core::IrSensor::DeviceFormat& device_format,
                                  std::size_t npad_index);
     ~ClusteringProcessor() override;
 
@@ -109,7 +106,5 @@ private:
     Core::IrSensor::DeviceFormat& device;
     Core::HID::EmulatedController* npad_device;
     int callback_key{};
-
-    Core::System& system;
 };
 } // namespace Service::IRS

src/core/hle/service/hid/irsensor/image_transfer_processor.cpp

@@ -49,7 +49,7 @@ void ImageTransferProcessor::OnControllerUpdate(Core::HID::ControllerTriggerType
         return;
     }
 
-    const auto& camera_data = npad_device->GetCamera();
+    const auto camera_data = npad_device->GetCamera();
 
     // This indicates how much ambient light is present
     processor_state.ambient_noise_level = Core::IrSensor::CameraAmbientNoiseLevel::Low;

src/core/hle/service/hid/irsensor/moment_processor.cpp

@@ -1,137 +1,24 @@
 // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
-#include "core/core.h"
-#include "core/core_timing.h"
-#include "core/hid/emulated_controller.h"
-#include "core/hid/hid_core.h"
 #include "core/hle/service/hid/irsensor/moment_processor.h"
 
 namespace Service::IRS {
-static constexpr auto format = Core::IrSensor::ImageTransferProcessorFormat::Size40x30;
-static constexpr std::size_t ImageWidth = 40;
-static constexpr std::size_t ImageHeight = 30;
-
-MomentProcessor::MomentProcessor(Core::System& system_, Core::IrSensor::DeviceFormat& device_format,
-                                 std::size_t npad_index)
-    : device(device_format), system{system_} {
-    npad_device = system.HIDCore().GetEmulatedControllerByIndex(npad_index);
-
+MomentProcessor::MomentProcessor(Core::IrSensor::DeviceFormat& device_format)
+    : device(device_format) {
     device.mode = Core::IrSensor::IrSensorMode::MomentProcessor;
     device.camera_status = Core::IrSensor::IrCameraStatus::Unconnected;
     device.camera_internal_status = Core::IrSensor::IrCameraInternalStatus::Stopped;
-
-    shared_memory = std::construct_at(
-        reinterpret_cast<MomentSharedMemory*>(&device_format.state.processor_raw_data));
-
-    Core::HID::ControllerUpdateCallback engine_callback{
-        .on_change = [this](Core::HID::ControllerTriggerType type) { OnControllerUpdate(type); },
-        .is_npad_service = true,
-    };
-    callback_key = npad_device->SetCallback(engine_callback);
 }
 
-MomentProcessor::~MomentProcessor() {
-    npad_device->DeleteCallback(callback_key);
-};
+MomentProcessor::~MomentProcessor() = default;
 
-void MomentProcessor::StartProcessor() {
-    device.camera_status = Core::IrSensor::IrCameraStatus::Available;
-    device.camera_internal_status = Core::IrSensor::IrCameraInternalStatus::Ready;
-}
+void MomentProcessor::StartProcessor() {}
 
 void MomentProcessor::SuspendProcessor() {}
 
 void MomentProcessor::StopProcessor() {}
 
-void MomentProcessor::OnControllerUpdate(Core::HID::ControllerTriggerType type) {
-    if (type != Core::HID::ControllerTriggerType::IrSensor) {
-        return;
-    }
-
-    next_state = {};
-    const auto& camera_data = npad_device->GetCamera();
-
-    const auto window_width = static_cast<std::size_t>(current_config.window_of_interest.width);
-    const auto window_height = static_cast<std::size_t>(current_config.window_of_interest.height);
-    const auto window_start_x = static_cast<std::size_t>(current_config.window_of_interest.x);
-    const auto window_start_y = static_cast<std::size_t>(current_config.window_of_interest.y);
-
-    const std::size_t block_width = window_width / Columns;
-    const std::size_t block_height = window_height / Rows;
-
-    for (std::size_t row = 0; row < Rows; row++) {
-        for (std::size_t column = 0; column < Columns; column++) {
-            const size_t x_pos = (column * block_width) + window_start_x;
-            const size_t y_pos = (row * block_height) + window_start_y;
-            auto& statistic = next_state.statistic[column + (row * Columns)];
-            statistic = GetStatistic(camera_data.data, x_pos, y_pos, block_width, block_height);
-        }
-    }
-
-    next_state.sampling_number = camera_data.sample;
-    next_state.timestamp = system.CoreTiming().GetGlobalTimeNs().count();
-    next_state.ambient_noise_level = Core::IrSensor::CameraAmbientNoiseLevel::Low;
-    shared_memory->moment_lifo.WriteNextEntry(next_state);
-
-    if (!IsProcessorActive()) {
-        StartProcessor();
-    }
-}
-
-u8 MomentProcessor::GetPixel(const std::vector<u8>& data, std::size_t x, std::size_t y) const {
-    if ((y * ImageWidth) + x >= data.size()) {
-        return 0;
-    }
-    return data[(y * ImageWidth) + x];
-}
-
-MomentProcessor::MomentStatistic MomentProcessor::GetStatistic(const std::vector<u8>& data,
-                                                               std::size_t start_x,
-                                                               std::size_t start_y,
-                                                               std::size_t width,
-                                                               std::size_t height) const {
-    // The actual implementation is always 320x240
-    static constexpr std::size_t RealWidth = 320;
-    static constexpr std::size_t RealHeight = 240;
-    static constexpr std::size_t Threshold = 30;
-    MomentStatistic statistic{};
-    std::size_t active_points{};
-
-    // Sum all data points on the block that meet with the threshold
-    for (std::size_t y = 0; y < width; y++) {
-        for (std::size_t x = 0; x < height; x++) {
-            const size_t x_pos = x + start_x;
-            const size_t y_pos = y + start_y;
-            const auto pixel =
-                GetPixel(data, x_pos * ImageWidth / RealWidth, y_pos * ImageHeight / RealHeight);
-
-            if (pixel < Threshold) {
-                continue;
-            }
-
-            statistic.average_intensity += pixel;
-
-            statistic.centroid.x += static_cast<float>(x_pos);
-            statistic.centroid.y += static_cast<float>(y_pos);
-
-            active_points++;
-        }
-    }
-
-    // Return an empty field if no points were available
-    if (active_points == 0) {
-        return {};
-    }
-
-    // Finally calculate the actual centroid and average intensity
-    statistic.centroid.x /= static_cast<float>(active_points);
-    statistic.centroid.y /= static_cast<float>(active_points);
-    statistic.average_intensity /= static_cast<f32>(width * height);
-
-    return statistic;
-}
-
 void MomentProcessor::SetConfig(Core::IrSensor::PackedMomentProcessorConfig config) {
     current_config.camera_config.exposure_time = config.camera_config.exposure_time;
     current_config.camera_config.gain = config.camera_config.gain;
@@ -142,8 +29,6 @@ void MomentProcessor::SetConfig(Core::IrSensor::PackedMomentProcessorConfig conf
     current_config.preprocess =
         static_cast<Core::IrSensor::MomentProcessorPreprocess>(config.preprocess);
     current_config.preprocess_intensity_threshold = config.preprocess_intensity_threshold;
-
-    npad_device->SetCameraFormat(format);
 }
 
 } // namespace Service::IRS

src/core/hle/service/hid/irsensor/moment_processor.h

@@ -6,22 +6,12 @@
 #include "common/bit_field.h"
 #include "common/common_types.h"
 #include "core/hid/irs_types.h"
-#include "core/hle/service/hid/irs_ring_lifo.h"
 #include "core/hle/service/hid/irsensor/processor_base.h"
 
-namespace Core {
-class System;
-}
-
-namespace Core::HID {
-class EmulatedController;
-} // namespace Core::HID
-
 namespace Service::IRS {
 class MomentProcessor final : public ProcessorBase {
 public:
-    explicit MomentProcessor(Core::System& system_, Core::IrSensor::DeviceFormat& device_format,
-                             std::size_t npad_index);
+    explicit MomentProcessor(Core::IrSensor::DeviceFormat& device_format);
     ~MomentProcessor() override;
 
     // Called when the processor is initialized
@@ -37,9 +27,6 @@ public:
     void SetConfig(Core::IrSensor::PackedMomentProcessorConfig config);
 
 private:
-    static constexpr std::size_t Columns = 8;
-    static constexpr std::size_t Rows = 6;
-
     // This is nn::irsensor::MomentProcessorConfig
     struct MomentProcessorConfig {
         Core::IrSensor::CameraConfig camera_config;
@@ -63,29 +50,12 @@ private:
         u64 timestamp;
         Core::IrSensor::CameraAmbientNoiseLevel ambient_noise_level;
         INSERT_PADDING_BYTES(4);
-        std::array<MomentStatistic, Columns * Rows> statistic;
+        std::array<MomentStatistic, 0x30> stadistic;
     };
     static_assert(sizeof(MomentProcessorState) == 0x258, "MomentProcessorState is an invalid size");
 
-    struct MomentSharedMemory {
-        Service::IRS::Lifo<MomentProcessorState, 6> moment_lifo;
-    };
-    static_assert(sizeof(MomentSharedMemory) == 0xE20, "MomentSharedMemory is an invalid size");
-
-    void OnControllerUpdate(Core::HID::ControllerTriggerType type);
-    u8 GetPixel(const std::vector<u8>& data, std::size_t x, std::size_t y) const;
-    MomentStatistic GetStatistic(const std::vector<u8>& data, std::size_t start_x,
-                                 std::size_t start_y, std::size_t width, std::size_t height) const;
-
-    MomentSharedMemory* shared_memory = nullptr;
-    MomentProcessorState next_state{};
-
     MomentProcessorConfig current_config{};
     Core::IrSensor::DeviceFormat& device;
-    Core::HID::EmulatedController* npad_device;
-    int callback_key{};
-
-    Core::System& system;
 };
 
 } // namespace Service::IRS

src/core/hle/service/ldr/ldr.cpp

@@ -286,14 +286,9 @@ public:
         rb.Push(ResultSuccess);
     }
 
-    bool ValidateRegionForMap(Kernel::KProcessPageTable& page_table, VAddr start,
-                              std::size_t size) const {
+    bool ValidateRegionForMap(Kernel::KPageTable& page_table, VAddr start, std::size_t size) const {
         const std::size_t padding_size{page_table.GetNumGuardPages() * Kernel::PageSize};
-
-        Kernel::KMemoryInfo start_info;
-        Kernel::Svc::PageInfo page_info;
-        R_ASSERT(
-            page_table.QueryInfo(std::addressof(start_info), std::addressof(page_info), start - 1));
+        const auto start_info{page_table.QueryInfo(start - 1)};
 
         if (start_info.GetState() != Kernel::KMemoryState::Free) {
             return {};
@@ -303,9 +298,7 @@ public:
             return {};
         }
 
-        Kernel::KMemoryInfo end_info;
-        R_ASSERT(page_table.QueryInfo(std::addressof(end_info), std::addressof(page_info),
-                                      start + size));
+        const auto end_info{page_table.QueryInfo(start + size)};
 
         if (end_info.GetState() != Kernel::KMemoryState::Free) {
             return {};
@@ -314,7 +307,7 @@ public:
         return (start + size + padding_size) <= (end_info.GetAddress() + end_info.GetSize());
     }
 
-    Result GetAvailableMapRegion(Kernel::KProcessPageTable& page_table, u64 size, VAddr& out_addr) {
+    Result GetAvailableMapRegion(Kernel::KPageTable& page_table, u64 size, VAddr& out_addr) {
         size = Common::AlignUp(size, Kernel::PageSize);
         size += page_table.GetNumGuardPages() * Kernel::PageSize * 4;
 
@@ -398,8 +391,12 @@ public:
 
             if (bss_size) {
                 auto block_guard = detail::ScopeExit([&] {
-                    page_table.UnmapCodeMemory(addr + nro_size, bss_addr, bss_size);
-                    page_table.UnmapCodeMemory(addr, nro_addr, nro_size);
+                    page_table.UnmapCodeMemory(
+                        addr + nro_size, bss_addr, bss_size,
+                        Kernel::KPageTable::ICacheInvalidationStrategy::InvalidateRange);
+                    page_table.UnmapCodeMemory(
+                        addr, nro_addr, nro_size,
+                        Kernel::KPageTable::ICacheInvalidationStrategy::InvalidateRange);
                 });
 
                 const Result result{page_table.MapCodeMemory(addr + nro_size, bss_addr, bss_size)};
@@ -581,17 +578,21 @@ public:
         auto& page_table{system.ApplicationProcess()->GetPageTable()};
 
         if (info.bss_size != 0) {
-            R_TRY(page_table.UnmapCodeMemory(info.nro_address + info.text_size + info.ro_size +
-                                                 info.data_size,
-                                             info.bss_address, info.bss_size));
+            R_TRY(page_table.UnmapCodeMemory(
+                info.nro_address + info.text_size + info.ro_size + info.data_size, info.bss_address,
+                info.bss_size, Kernel::KPageTable::ICacheInvalidationStrategy::InvalidateRange));
         }
 
-        R_TRY(page_table.UnmapCodeMemory(info.nro_address + info.text_size + info.ro_size,
-                                         info.src_addr + info.text_size + info.ro_size,
-                                         info.data_size));
-        R_TRY(page_table.UnmapCodeMemory(info.nro_address + info.text_size,
-                                         info.src_addr + info.text_size, info.ro_size));
-        R_TRY(page_table.UnmapCodeMemory(info.nro_address, info.src_addr, info.text_size));
+        R_TRY(page_table.UnmapCodeMemory(
+            info.nro_address + info.text_size + info.ro_size,
+            info.src_addr + info.text_size + info.ro_size, info.data_size,
+            Kernel::KPageTable::ICacheInvalidationStrategy::InvalidateRange));
+        R_TRY(page_table.UnmapCodeMemory(
+            info.nro_address + info.text_size, info.src_addr + info.text_size, info.ro_size,
+            Kernel::KPageTable::ICacheInvalidationStrategy::InvalidateRange));
+        R_TRY(page_table.UnmapCodeMemory(
+            info.nro_address, info.src_addr, info.text_size,
+            Kernel::KPageTable::ICacheInvalidationStrategy::InvalidateRange));
         return ResultSuccess;
     }
 

src/core/memory.cpp

@@ -1,8 +1,10 @@
 // SPDX-FileCopyrightText: 2015 Citra Emulator Project
+// SPDX-FileCopyrightText: 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include <algorithm>
 #include <cstring>
+#include <mutex>
 #include <span>
 
 #include "common/assert.h"
@@ -10,6 +12,7 @@
 #include "common/common_types.h"
 #include "common/logging/log.h"
 #include "common/page_table.h"
+#include "common/scope_exit.h"
 #include "common/settings.h"
 #include "common/swap.h"
 #include "core/core.h"
@@ -41,7 +44,7 @@ struct Memory::Impl {
     explicit Impl(Core::System& system_) : system{system_} {}
 
     void SetCurrentPageTable(Kernel::KProcess& process, u32 core_id) {
-        current_page_table = &process.GetPageTable().GetImpl();
+        current_page_table = &process.GetPageTable().PageTableImpl();
         current_page_table->fastmem_arena = system.DeviceMemory().buffer.VirtualBasePointer();
 
         const std::size_t address_space_width = process.GetPageTable().GetAddressSpaceWidth();
@@ -195,7 +198,7 @@ struct Memory::Impl {
 
     bool WalkBlock(const Common::ProcessAddress addr, const std::size_t size, auto on_unmapped,
                    auto on_memory, auto on_rasterizer, auto increment) {
-        const auto& page_table = system.ApplicationProcess()->GetPageTable().GetImpl();
+        const auto& page_table = system.ApplicationProcess()->GetPageTable().PageTableImpl();
         std::size_t remaining_size = size;
         std::size_t page_index = addr >> YUZU_PAGEBITS;
         std::size_t page_offset = addr & YUZU_PAGEMASK;
@@ -318,7 +321,7 @@ struct Memory::Impl {
             [&](const Common::ProcessAddress current_vaddr, const std::size_t copy_amount,
                 u8* const host_ptr) {
                 if constexpr (!UNSAFE) {
-                    system.GPU().InvalidateRegion(GetInteger(current_vaddr), copy_amount);
+                    HandleRasterizerWrite(GetInteger(current_vaddr), copy_amount);
                 }
                 std::memcpy(host_ptr, src_buffer, copy_amount);
             },
@@ -351,7 +354,7 @@ struct Memory::Impl {
             },
             [&](const Common::ProcessAddress current_vaddr, const std::size_t copy_amount,
                 u8* const host_ptr) {
-                system.GPU().InvalidateRegion(GetInteger(current_vaddr), copy_amount);
+                HandleRasterizerWrite(GetInteger(current_vaddr), copy_amount);
                 std::memset(host_ptr, 0, copy_amount);
             },
             [](const std::size_t copy_amount) {});
@@ -420,7 +423,7 @@ struct Memory::Impl {
                                  const std::size_t block_size) {
             // dc cvac: Store to point of coherency
             // CPU flush -> GPU invalidate
-            system.GPU().InvalidateRegion(GetInteger(current_vaddr), block_size);
+            HandleRasterizerWrite(GetInteger(current_vaddr), block_size);
         };
         return PerformCacheOperation(dest_addr, size, on_rasterizer);
     }
@@ -430,7 +433,7 @@ struct Memory::Impl {
                                  const std::size_t block_size) {
             // dc civac: Store to point of coherency, and invalidate from cache
             // CPU flush -> GPU invalidate
-            system.GPU().InvalidateRegion(GetInteger(current_vaddr), block_size);
+            HandleRasterizerWrite(GetInteger(current_vaddr), block_size);
         };
         return PerformCacheOperation(dest_addr, size, on_rasterizer);
     }
@@ -767,7 +770,18 @@ struct Memory::Impl {
     }
 
     void HandleRasterizerWrite(VAddr address, size_t size) {
-        const size_t core = system.GetCurrentHostThreadID();
+        constexpr size_t sys_core = Core::Hardware::NUM_CPU_CORES - 1;
+        const size_t core = std::min(system.GetCurrentHostThreadID(),
+                                     sys_core); // any other calls threads go to syscore.
+        // Guard on sys_core;
+        if (core == sys_core) [[unlikely]] {
+            sys_core_guard.lock();
+        }
+        SCOPE_EXIT({
+            if (core == sys_core) [[unlikely]] {
+                sys_core_guard.unlock();
+            }
+        });
         auto& current_area = rasterizer_write_areas[core];
         VAddr subaddress = address >> YUZU_PAGEBITS;
         bool do_collection = current_area.last_address == subaddress;
@@ -799,6 +813,7 @@ struct Memory::Impl {
         rasterizer_read_areas{};
     std::array<GPUDirtyState, Core::Hardware::NUM_CPU_CORES> rasterizer_write_areas{};
     std::span<Core::GPUDirtyMemoryManager> gpu_dirty_managers;
+    std::mutex sys_core_guard;
 };
 
 Memory::Memory(Core::System& system_) : system{system_} {
@@ -826,7 +841,7 @@ void Memory::UnmapRegion(Common::PageTable& page_table, Common::ProcessAddress b
 
 bool Memory::IsValidVirtualAddress(const Common::ProcessAddress vaddr) const {
     const Kernel::KProcess& process = *system.ApplicationProcess();
-    const auto& page_table = process.GetPageTable().GetImpl();
+    const auto& page_table = process.GetPageTable().PageTableImpl();
     const size_t page = vaddr >> YUZU_PAGEBITS;
     if (page >= page_table.pointers.size()) {
         return false;

src/video_core/fence_manager.h

@@ -86,10 +86,7 @@ public:
             uncommitted_operations.emplace_back(std::move(func));
         }
         pending_operations.emplace_back(std::move(uncommitted_operations));
-        {
-            std::scoped_lock lock{buffer_cache.mutex, texture_cache.mutex};
-            QueueFence(new_fence);
-        }
+        QueueFence(new_fence);
         if (!delay_fence) {
             func();
         }

src/video_core/renderer_opengl/gl_rasterizer.cpp

@@ -555,7 +555,7 @@ void RasterizerOpenGL::OnCacheInvalidation(VAddr addr, u64 size) {
     }
     {
         std::scoped_lock lock{buffer_cache.mutex};
-        buffer_cache.CachedWriteMemory(addr, size);
+        buffer_cache.WriteMemory(addr, size);
     }
     shader_cache.InvalidateRegion(addr, size);
 }

src/video_core/renderer_vulkan/renderer_vulkan.cpp

@@ -132,16 +132,12 @@ void RendererVulkan::SwapBuffers(const Tegra::FramebufferConfig* framebuffer) {
     const bool use_accelerated =
         rasterizer.AccelerateDisplay(*framebuffer, framebuffer_addr, framebuffer->stride);
     const bool is_srgb = use_accelerated && screen_info.is_srgb;
+    RenderScreenshot(*framebuffer, use_accelerated);
 
-    {
-        std::scoped_lock lock{rasterizer.LockCaches()};
-        RenderScreenshot(*framebuffer, use_accelerated);
-
-        Frame* frame = present_manager.GetRenderFrame();
-        blit_screen.DrawToSwapchain(frame, *framebuffer, use_accelerated, is_srgb);
-        scheduler.Flush(*frame->render_ready);
-        present_manager.Present(frame);
-    }
+    Frame* frame = present_manager.GetRenderFrame();
+    blit_screen.DrawToSwapchain(frame, *framebuffer, use_accelerated, is_srgb);
+    scheduler.Flush(*frame->render_ready);
+    present_manager.Present(frame);
 
     gpu.RendererFrameEndNotify();
     rasterizer.TickFrame();

src/video_core/renderer_vulkan/vk_rasterizer.cpp

@@ -199,7 +199,7 @@ void RasterizerVulkan::PrepareDraw(bool is_indexed, Func&& draw_func) {
     if (!pipeline) {
         return;
     }
-    std::scoped_lock lock{LockCaches()};
+    std::scoped_lock lock{buffer_cache.mutex, texture_cache.mutex};
     // update engine as channel may be different.
     pipeline->SetEngine(maxwell3d, gpu_memory);
     pipeline->Configure(is_indexed);
@@ -621,7 +621,7 @@ void RasterizerVulkan::OnCacheInvalidation(VAddr addr, u64 size) {
     }
     {
         std::scoped_lock lock{buffer_cache.mutex};
-        buffer_cache.CachedWriteMemory(addr, size);
+        buffer_cache.WriteMemory(addr, size);
     }
     pipeline_cache.InvalidateRegion(addr, size);
 }
@@ -710,7 +710,6 @@ void RasterizerVulkan::TiledCacheBarrier() {
 }
 
 void RasterizerVulkan::FlushCommands() {
-    std::scoped_lock lock{LockCaches()};
     if (draw_counter == 0) {
         return;
     }
@@ -808,7 +807,6 @@ void RasterizerVulkan::FlushWork() {
     if ((++draw_counter & 7) != 7) {
         return;
     }
-    std::scoped_lock lock{LockCaches()};
     if (draw_counter < DRAWS_TO_DISPATCH) {
         // Send recorded tasks to the worker thread
         scheduler.DispatchWork();
@@ -1507,7 +1505,7 @@ void RasterizerVulkan::UpdateVertexInput(Tegra::Engines::Maxwell3D::Regs& regs)
 void RasterizerVulkan::InitializeChannel(Tegra::Control::ChannelState& channel) {
     CreateChannel(channel);
     {
-        std::scoped_lock lock{LockCaches()};
+        std::scoped_lock lock{buffer_cache.mutex, texture_cache.mutex};
         texture_cache.CreateChannel(channel);
         buffer_cache.CreateChannel(channel);
     }
@@ -1520,7 +1518,7 @@ void RasterizerVulkan::BindChannel(Tegra::Control::ChannelState& channel) {
     const s32 channel_id = channel.bind_id;
     BindToChannel(channel_id);
     {
-        std::scoped_lock lock{LockCaches()};
+        std::scoped_lock lock{buffer_cache.mutex, texture_cache.mutex};
         texture_cache.BindToChannel(channel_id);
         buffer_cache.BindToChannel(channel_id);
     }
@@ -1533,7 +1531,7 @@ void RasterizerVulkan::BindChannel(Tegra::Control::ChannelState& channel) {
 void RasterizerVulkan::ReleaseChannel(s32 channel_id) {
     EraseChannel(channel_id);
     {
-        std::scoped_lock lock{LockCaches()};
+        std::scoped_lock lock{buffer_cache.mutex, texture_cache.mutex};
         texture_cache.EraseChannel(channel_id);
         buffer_cache.EraseChannel(channel_id);
     }

src/video_core/renderer_vulkan/vk_rasterizer.h

@@ -133,10 +133,6 @@ public:
 
     void ReleaseChannel(s32 channel_id) override;
 
-    std::scoped_lock<std::recursive_mutex, std::recursive_mutex> LockCaches() {
-        return std::scoped_lock{buffer_cache.mutex, texture_cache.mutex};
-    }
-
 private:
     static constexpr size_t MAX_TEXTURES = 192;
     static constexpr size_t MAX_IMAGES = 48;

src/yuzu/main.cpp

@@ -1909,8 +1909,7 @@ void GMainWindow::BootGame(const QString& filename, u64 program_id, std::size_t
                            StartGameType type, AmLaunchType launch_type) {
     LOG_INFO(Frontend, "yuzu starting...");
 
-    if (program_id == 0 ||
-        program_id > static_cast<u64>(Service::AM::Applets::AppletProgramId::MaxProgramId)) {
+    if (program_id > static_cast<u64>(Service::AM::Applets::AppletProgramId::MaxProgramId)) {
         StoreRecentFile(filename); // Put the filename on top of the list
     }
 
@@ -4296,7 +4295,7 @@ void GMainWindow::OnAlbum() {
 
     const auto filename = QString::fromStdString(album_nca->GetFullPath());
     UISettings::values.roms_path = QFileInfo(filename).path();
-    BootGame(filename, AlbumId);
+    BootGame(filename);
 }
 
 void GMainWindow::OnCabinet(Service::NFP::CabinetMode mode) {
@@ -4320,7 +4319,7 @@ void GMainWindow::OnCabinet(Service::NFP::CabinetMode mode) {
 
     const auto filename = QString::fromStdString(cabinet_nca->GetFullPath());
     UISettings::values.roms_path = QFileInfo(filename).path();
-    BootGame(filename, CabinetId);
+    BootGame(filename);
 }
 
 void GMainWindow::OnMiiEdit() {
@@ -4343,7 +4342,7 @@ void GMainWindow::OnMiiEdit() {
 
     const auto filename = QString::fromStdString((mii_applet_nca->GetFullPath()));
     UISettings::values.roms_path = QFileInfo(filename).path();
-    BootGame(filename, MiiEditId);
+    BootGame(filename);
 }
 
 void GMainWindow::OnCaptureScreenshot() {

src/yuzu/vk_device_info.cpp

@@ -31,7 +31,6 @@ void PopulateRecords(std::vector<Record>& records, QWindow* window) try {
     // Create a test window with a Vulkan surface type for checking present modes.
     QWindow test_window(window);
     test_window.setSurfaceType(QWindow::VulkanSurface);
-    test_window.create();
     auto wsi = QtCommon::GetWindowSystemInfo(&test_window);
 
     vk::InstanceDispatch dld;